aCoercer

MMO\core\classes · 1 symbol · generated 5 Oct 2026

class

aCoercer

An aConverter specialized for coercion: given an ordered list of acceptable $types, try to convert $value into the first one that accepts it (rather than aConverter's single-type aConverter::call, which requires the caller to already know the right type). Used by the schema system to coerce a raw input value against a type list like ['integer', 'string'].

abstract class MMO\core\classes\aCoercer extends MMO\core\classes\aConverter implements MMO\core\interfaces\iCoercer

Namespace: MMO\core\classes
Extends: aConverter
Implements: iCoercer

class MyCoercer extends aCoercer {} $c = MyCoercer::Shared(); $c->setFunction('integer', function ($v, $opts) { if (!is_numeric($v)) {throw new eInvalid('coerce', 'not numeric');} return (int)$v; }); $c->setFunction('string', fn($v, $opts) => (string)$v); MyCoercer::Coerce(['integer', 'string'], '42'); // (int) 42 -- 'integer' accepts it MyCoercer::Coerce(['integer', 'string'], 'hello'); // (string) 'hello' -- falls through to 'string'

Index

	Coerce($types, $value, $options) static
	__invoke($value, $options, $types)	Try each of $types in turn (via `aConverter::call`), returning the result of the first one that doesn't throw an `eInvalid`.

Methods2

Coerce($types, $value, $options)

staticaCoercer.php:32

static function Coerce(array $types, mixed $value, array $options = []): mixed

$types	array	the acceptable types, in preference order (see `__invoke` for the one exception: 'string' is always tried last)
$value	mixed
$options = []	array
returns	mixed	the value coerced to the first $types entry that accepts it
throws		if none of $types can coerce $value

MyCoercer::Coerce(['integer', 'string'], '42'); // (int) 42

__invoke($value, $options, $types)

aCoercer.php:47

Try each of $types in turn (via aConverter::call), returning the result of the first one that doesn't throw an eInvalid. 'string' is always tried last regardless of its position in $types, since almost any value can be coerced to a string -- letting it win by being listed first would defeat every other type.

function __invoke(mixed $value, array $options = [], array $types = []): mixed

$value	mixed
$options = []	array
$types = []	array	candidate types, in preference order
returns	mixed	the converted value
throws		if every type in $types rejects $value (in MODE_DEV, the message includes each type's specific rejection reason; elsewhere it is a bare, non-leaking message)

Inherited members (62)

Constants	Declared by	Description
`ALERT`	iLogLevel	Alert: Action must be taken immediately.
`ALL`	iLogLevel	Mask for all
`ALL_PLUS`	iLogLevel	debug everything
`BACKTRACE`	iLogLevel
`CRITICAL`	iLogLevel	Critical: Critical conditions.
`DEBUG`	iLogLevel	Debug: Detailed debug information.
`DEEP`	iLogLevel	debug everything with arguments
`EMERGENCY`	iLogLevel	Emergency: System is unusable.
`ERROR`	iLogLevel	Error: Runtime errors that do not require immediate action but should typically be logged and monitored.
`ERROR_PLUS`	iLogLevel	Mask for all error
`FATAL`	iLogLevel	Mask for all fatal error
`INFO`	iLogLevel	Info: Interesting events.
`INFO_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`MEMORY`	iLogLevel	include backtrace object
`NOTICE`	iLogLevel	Notice: Normal but significant events.
`NOTICE_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`TRACE`	iLogLevel	include backtrace as origins
`WARNING`	iLogLevel	Warning: Exceptional occurrences that are not errors.
`WARNING_PLUS`	iLogLevel	Mask for all errors and warnings

	Properties	Declared by	Description
	`functions`	aConverter
	`globalOptions`	aConverter
	`verbosity`	aModule

Methods	Declared by	Description
`addOptions($type, $options)`	aConverter	Merge $options into $type's existing options (via `merge`), rather than replacing them wholesale like `setOptions`.
`alert($message, $context)`	aModule	Action must be taken immediately.
`backtraces($message, $context)`	aModule	Force-log a message at INFO level together with a full stack trace/memory snapshot (`iLogLevel::BACKTRACE`), bypassing the verbosity mask entirely (any non-zero verbosity is enough to trigger it).
`call($type, $value, $options)`	aConverter	Call the function associated to a type
`clear()`	aConverter	Remove every registered type/function.
`Configure($config)`	aModule	Merge $config into this module's configuration in the shared `Configuration`.
`critical($message, $context)`	aModule	Critical conditions. No-op if CRITICAL is currently filtered out by the verbosity mask.
`debug($message, $context)`	aModule	Detailed debug information.
`debugName()`	aModule	Human-readable identifier used as the default `{origin}` in this instance's log messages.
`DefaultConfig()`	aModule	The config a module starts from before anything loaded via `Configuration` is merged in.
`emergency($message, $context)`	aModule	System is unusable. No-op if EMERGENCY is currently filtered out by the verbosity mask.
`error($message, $context)`	aModule	Runtime errors that do not require immediate action but should typically be logged and monitored.
`getClassFunction($class)`	aConverter	Find which registered type (a class or interface name) applies to $class: itself if directly registered, else the closest registered ancestor class or implemented interface.
`getFunction($type)`	aConverter
`getFunctions()`	aConverter
`getOptions($type)`	aConverter
`getType($value, $allowClass)`	aConverter	Normalize $value's type into one of this converter's type names.
`getVerbosity()`	aModule
`hasType($type)`	aConverter
`info($message, $context)`	aModule	Interesting events. No-op if INFO is currently filtered out by the verbosity mask.
`Instantiate($config)`	aModule	(Re)create the shared instance immediately, configured with $config merged into the class's existing config.
`IsShared()`	aModule
`log($level, $message, $context)`	aModule	Logs with an arbitrary level.
`notice($message, $context)`	aModule	Normal but significant events.
`offsetExists($key)`	aModule	\ArrayAccess::offsetExists -- tells whether $key is a declared property at all, regardless of whether it is currently readable/writable through array access.
`offsetGet($key)`	aModule	\ArrayAccess::offsetGet -- reads a property directly, unless it has a `#[Serialize(serialize: 'methodName')]` attribute, in which case that zero-argument method is called instead (e.g.
`offsetSet($key, $value)`	aModule	\ArrayAccess::offsetSet -- sets a property directly, unless it has a `#[Serialize(unserialize: 'methodName')]` attribute, in which case that method is called with $value instead (e.g.
`offsetUnset($key)`	aModule	\ArrayAccess::offsetUnset -- equivalent to `$module[$key] = null`.
`serialize($path, $serializer)`	aModule	\MMO\core\interfaces\iSerializable::serialize -- exports every property (via
`setFunction($type, $fn, $options)`	aConverter	Set a coercer
`setFunctions($fns)`	aConverter	Register many functions at once, e.g.
`setOptions($type, $options)`	aConverter	Replace $type's options wholesale.
`setVerbosity($verb)`	aModule	Set the current verbosity mask, replacing whatever it was before.
`Shared()`	aModule	Get the shared instance, creating (and configuring) it on first call.
`testVerbosity($level)`	aModule	Test whether a given level (or set of levels) is currently enabled by this instance's verbosity mask.
`traitUnshare($serialize)`	aModule	Remove the shared instance, so the next `Shared()` call creates a fresh one.
`unserialize($data, $path, $instances)`	aModule	\MMO\core\interfaces\iSerializable::unserialize -- merges $data onto `DefaultConfig`, runs it through the (possibly overridden) constructor, then applies each resulting value to its property (via
`Unshare($serialize)`	aModule	Like `tSingleton::Unshare`, but also disconnects this module's instance from every event it was listening to (via `Event::DisconnectListeners`) before dropping it.
`warning($message, $context)`	aModule	Exceptional occurrences that are not errors.
`__construct($config)`	aModule	protected constructor, so it is not possible to do `new Module(...)` called by the serialization process just before being injected with data.