aConverter

MMO\core\classes · 1 symbol · generated 30 Sep 2026

class

aConverter

Class used to convert a value from one type to another.

abstract class MMO\core\classes\aConverter extends MMO\core\classes\aModule implements MMO\core\interfaces\iConverter

Namespace: MMO\core\classes
Extends: aModule
Implements: iConverter

Any converter MUST throw an eInvalid|InvalidArgumentException exception if the value cannot be converted A "type" here is either one of [`getType`](https://mmoframework.fr/documentation/mmo.core/php/classes/aConverter.md#aconverter-gettype)'s normalized type names ('integer', 'number', 'string', 'boolean', 'array', 'object', 'null', 'enum', 'instance'), or a class/interface name (matched by [`getClassFunction`](https://mmoframework.fr/documentation/mmo.core/php/classes/aConverter.md#aconverter-getclassfunction), which also matches subclasses/implementations, e.g. a function registered for `\DateTime::class` is found for a `MyDate extends \DateTime` instance too).

class MyConverter extends aConverter { public function __invoke(mixed $value, array $options = []): mixed {return $this->call($this->getType($value), $value, $options);} } $c = MyConverter::Shared(); $c->setFunction('integer', fn($v, $opts) => (int)round($v * ($opts['scale']??1)), ['scale' => 1]); $c($value); // e.g. converts an int/float/string $value to an int, scaled per the registered options

Index

	cachedClassFunctions
	functions
	globalOptions
	addOptions($type, $options)	Merge $options into $type's existing options (via `merge`), rather than replacing them wholesale like `setOptions`.
	call($type, $value, $options)	Call the function associated to a type
	clear()	Remove every registered type/function.
	getClassFunction($class)	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)
	getFunctions()
	getOptions($type)
	getType($value, $allowClass)	Normalize $value's type into one of this converter's type names.
	hasType($type)
	setFunction($type, $fn, $options)	Set a coercer
	setFunctions($fns)	Register many functions at once, e.g.
	setOptions($type, $options)	Replace $type's options wholesale.

Properties3

cachedClassFunctions

private array $cachedClassFunctions = []

Type: array

functions

#[MMO\core\attributes\Serialize(serialize: false, unserialize: 'setFunctions')] protected array $functions = []

Type: array

globalOptions

array $globalOptions = []

Type: array

Methods12

addOptions($type, $options)

aConverter.php:209

Merge $options into $type's existing options (via merge), rather than replacing them wholesale like setOptions.

function addOptions(string $type, array $options): void

$type	string
$options	array
returns	void
throws		if $type is not registered

call($type, $value, $options)

aConverter.php:242

Call the function associated to a type

function call(string $type, mixed $value, array $options = []): mixed

See: $globalOptions (lowest priority)

$type	string
$value	mixed
$options = []	array	merged with $type's registered options (these take priority) and with
returns	mixed	whatever the registered function returns
throws		if $type is not registered

$c->setFunction('integer', fn($v, $opts) => (int)round($v * ($opts['scale']??1)), ['scale' => 1]); $c->call('integer', 3.7); // 4 -- uses the registered options (scale: 1) $c->call('integer', 3.7, ['scale' => 10]); // 37 -- $options overrides the registered scale

clear()

aConverter.php:115

Remove every registered type/function.

function clear(): void

returns

void

getClassFunction($class)

aConverter.php:60

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. Results are cached per $class.

function getClassFunction(string $class): ?string

$class	string
returns	null \| string	the matching registered type name, or null if none of $class's ancestors/interfaces are registered

$c->setFunction(\DateTime::class, fn($v, $o) => $v->format('Y')); $c->getClassFunction(MyDateSubclass::class); // \DateTime::class, since MyDateSubclass extends \DateTime $c->getClassFunction(\DateTimeImmutable::class); // null: it does NOT extend \DateTime

getFunction($type)

aConverter.php:46

function getFunction(string $type): ?callable

$type	string
returns	null \| callable	the raw function registered for $type (without its options -- see `call` to invoke it correctly), or null if $type is not registered

getFunctions()

aConverter.php:122

function getFunctions(): array

returns

array

type => [callable, options] for every registered type

getOptions($type)

aConverter.php:197

function getOptions(string $type): ?array

$type	string
returns	null \| array	the options currently registered for $type, or null if $type is not registered or has no options

getType($value, $allowClass)

aConverter.php:94

Normalize $value's type into one of this converter's type names.

function getType(mixed $value, bool $allowClass = true): string

$value	mixed
$allowClass = true	bool	if true (the default) and $value is an object whose class matches a registered type (via `getClassFunction`), that registered type name is returned instead of the generic 'instance'/'enum'
returns	string	one of: 'integer', 'number' (float), 'string', 'boolean', 'null', 'array' (a list), 'object' (an associative array), 'resource', 'unknown', 'enum', 'instance', or a registered class/interface name

$c->getType(5); // 'integer' $c->getType(5.5); // 'number' $c->getType([1, 2]); // 'array' -- a list $c->getType(['a'=>1]); // 'object' -- associative $c->getType(new \DateTime()); // 'instance', unless \DateTime (or an ancestor/interface) is a registered type

hasType($type)

aConverter.php:37

function hasType(string $type): bool

$type	string
returns	bool	true if a conversion function is registered for $type

setFunction($type, $fn, $options)

aConverter.php:160

Set a coercer

function setFunction(string $type, ?callable $fn, ?array $options = null): bool

$type	string
$fn	null \| callable	function($value, $options). if null remove function
$options = null	null \| array	options to pass to the coercer when called. if null, leave the previous options as they were.
returns	bool	true if function or options have changed

$c->setFunction('integer', fn($v, $opts) => (int)round($v), []);

$c->setFunction('integer', null); // removes the 'integer' converter entirely

setFunctions($fns)

aConverter.php:132

function setFunctions(array $fns): bool

$fns	array	type => callable, or type => [callable, options]
returns	bool	true if any registration actually changed something (see `setFunction`)
throws		if any entry is not a valid callable

setOptions($type, $options)

aConverter.php:221

Replace $type's options wholesale.

function setOptions(string $type, ?array $options): void

$type	string
$options	null \| array	null removes the options entirely
returns	void
throws		if $type is not registered

Inherited members (49)

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
	`verbosity`	aModule

Methods	Declared by	Description
`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).
`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.
`getVerbosity()`	aModule
`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
`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.
`__invoke($value, $options)`	iConverter	Convert any value to a given type