Container

MMO\core\helpers · 1 symbole · générée le 27 Oct 2026

class

Container

Implementation of PSR ContainerInterface: a nested, json-path-addressable data container (backed by

class MMO\core\helpers\Container implements Psr\Container\ContainerInterface, MMO\core\interfaces\iArray, JsonSerializable use MMO\core\classes\tArray

Espace de noms: MMO\core\helpers
Implémente: ContainerInterface, iArray, JsonSerializable
Utilise les traits: tArray
Voir: tArray's plain $content array), usable both as a general-purpose config/data holder and as a dependency container. Containers can be nested (getParent / getRoot), and every instance with a non-null getId is registered process-wide so it can be looked up again by that id (Fetch).

$c = new Container(['a' => ['b' => 1]]); $c->get('a/b'); // 1 $c->set('a/c', 2); $c->has('a/nope'); // false

Index

	MAX_REFERENCE_DEPTH
	content
	id
	IDS static
	parent
	clear()	Empty the underlying content, keeping the object itself.
	count()	\Countable::count
	delete($id)	Remove the value at $id and return it.
	Exists($url) static
	Fetch($url) static	Get the container registered under $url (`$IDS`), fetching (and caching) it via the `Fetch` event if it isn't already loaded.
	get($id, $default)	Get a value from the container.
	getContent()
	getId()
	getIterator()	\IteratorAggregate::getIterator
	getParent()
	getRoot()
	has($id)
	inject($id, $config, $recursive)	Merge $config into the content at $id (each of $config's own keys is injected at `$id/$key`).
	isEmpty()
	jsonSerialize($options)
	keys()
	load($configs)	Merge one or more configs into this container's content (via `inject`).
	loadArray($data)	Load every entry of a plain array into the content, through `offsetSet` (so any offsetSet() override defined by the class using this trait, e.g.
	offsetExists($key)	\ArrayAccess::offsetExists
	offsetGet($key)	\ArrayAccess::offsetGet
	offsetSet($key, $value)	\ArrayAccess::offsetSet -- a null $key appends (`$bag[] = $value`), like a plain PHP array.
	offsetUnset($key)	\ArrayAccess::offsetUnset -- on a list (sequential integer keys, as produced by `$bag[] = ...`), the element is spliced out (closing the gap and reindexing), matching \unset() semantics on a plain …
	push($id, $value, $create)	Push a value in content
	set($id, $value, $create)	Set a value at $id, creating intermediate structure as needed.
	setContent($content)	Replace the whole content wholesale.
	setId($id)
	toArray()	Convert the content to a plain array, recursively converting any nested `iArray` value (e.g.
	UnFetch($url) static	Forget the container registered under $url (it can be `Fetch-ed` again afterward, rebuilding it).
	UnFetchAll() static	Forget every registered container.
	__construct($content, $id, $parent)	Create container

Constantes1

MAX_REFERENCE_DEPTH

const MAX_REFERENCE_DEPTH = 10

Propriétés4

content

protected $content = []

id

#[MMO\core\attributes\Serialize(unserialize: 'setId', order: -100)] protected ?string $id = null

Type: null | string

IDS

static

#[MMO\core\attributes\Serialize(false)] protected static array $IDS = []

Type: array

parent

protected ?self $parent

Type: null | self

Méthodes30

clear()

tArray.php:25

Empty the underlying content, keeping the object itself.

function clear()

retourne

$bag->clear(); // count($bag) === 0 afterwards

count()

tArray.php:90

\Countable::count

function count(): int

retourne

int

delete($id)

Container.php:222

Remove the value at $id and return it. A path starting with '/' is applied to getRoot instead of $this.

function delete(string $id): mixed

$id	string
retourne	mixed	the removed value

$container->delete('a/b');

Exists($url)

staticContainer.php:59

static function Exists(string $url): bool

$url	string
retourne	bool	true if a container is currently registered under $url

Fetch($url)

staticContainer.php:46

Get the container registered under $url ($IDS), fetching (and caching) it via the Fetch event if it isn't already loaded.

static function Fetch(string $url): static

$url	string
retourne	static
lève		if the fetched data is neither an array nor an instance of static
lève		if nothing answers the Fetch event for $url

get($id, $default)

Container.php:187

Get a value from the container. A path starting with '/' is resolved from getRoot instead of $this, so a nested container can still reach data owned by an ancestor.

function get($id, mixed $default = null): mixed

$id		if string, MUST be a valid JSON path.
$default = null	mixed	returned if $id's leaf is missing. See `get`'s own docblock for the exact (and slightly surprising) missing-leaf-vs-missing-intermediate-segment rules.
retourne	mixed	the extracted data
lève		if an INTERMEDIATE path segment cannot be resolved (e.g. it isn't an array at all)

$container->get('a/b');

$container->get('a/nope', 'fallback');

getContent()

Container.php:132

function getContent(): array

retourne

array

the raw underlying content array

getId()

Container.php:96

function getId(): ?string

retourne

null | string

this container's registered id, if any

getIterator()

tArray.php:97

\IteratorAggregate::getIterator

function getIterator(): Traversable

retourne

Traversable

getParent()

Container.php:118

function getParent(): ?self

retourne

null | self

the container this one was constructed with as its $parent

getRoot()

Container.php:126

function getRoot(): self

retourne self the outermost ancestor -- $this itself if it has no parent. Used to resolve absolute ('/'-prefixed) paths in get / set / delete / push / inject.

has($id)

Container.php:196

function has($id): bool

$id
retourne	bool	true if $id resolves to an actual (possibly null) value

$container->has('a/b');

inject($id, $config, $recursive)

Container.php:251

Merge $config into the content at $id (each of $config's own keys is injected at $id/$key). A path starting with '/' is applied to getRoot instead of $this.

function inject(string $id, array $config, bool $recursive = true): void

$id	string
$config	array
$recursive = true	bool	passed through to `inject`
retourne	void

$container->inject('a', ['d' => 5]);

isEmpty()

tArray.php:33

function isEmpty()

retourne

true if the underlying content has no elements

$bag->isEmpty(); // true right after clear(), false as soon as an item is set

jsonSerialize($options)

Container.php:146

function jsonSerialize(array $options = []): mixed

$options = []	array
retourne	mixed	the raw content, for json_encode()

keys()

tArray.php:82

function keys(): array

retourne

array

the list of keys currently set

$bag->keys(); // e.g. ['x', 0]

load($configs)

Container.php:158

Merge one or more configs into this container's content (via inject).

function load(array|string ...$configs): void

...$configs	array \| string
retourne	void
lève		if a string config resolves to something that isn't an array/Container

$container->load(['a' => 1], 'path/to/config.php');

loadArray($data)

tArray.php:71

Load every entry of a plain array into the content, through offsetSet (so any offsetSet() override defined by the class using this trait, e.g. for validation or type coercion, is honored for every entry).

function loadArray(array $data): static

$data	array
retourne	static	$this, for chaining

$bag->loadArray(['x' => 1, 'y' => 2]); // equivalent to $bag['x'] = 1; $bag['y'] = 2;

offsetExists($key)

tArray.php:130

\ArrayAccess::offsetExists

function offsetExists(mixed $key): bool

$key	mixed
retourne	bool

offsetGet($key)

tArray.php:115

\ArrayAccess::offsetGet

function offsetGet(mixed $key): mixed

$key	mixed
retourne	mixed

offsetSet($key, $value)

tArray.php:122

\ArrayAccess::offsetSet -- a null $key appends ($bag[] = $value), like a plain PHP array.

function offsetSet(mixed $key, mixed $value): void

$key	mixed
$value	mixed
retourne	void

offsetUnset($key)

tArray.php:107

\ArrayAccess::offsetUnset -- on a list (sequential integer keys, as produced by $bag[] = ...), the element is spliced out (closing the gap and reindexing), matching \unset() semantics on a plain PHP list; on an associative array, the key is simply removed.

function offsetUnset(mixed $key): void

$key	mixed
retourne	void

unset($bag[0]); // on a list: every following index shifts down by one, like array_splice()

push($id, $value, $create)

Container.php:236

Push a value in content

function push(string $id, mixed $value, bool $create = true): ArrayAccess|array

$id	string	the content's path to add value to.
$value	mixed	the value to push
$create = true	bool	if false, a missing intermediate segment is not auto-created
retourne	ArrayAccess \| array	a reference on the array in which the value has been pushed

$container->push('list', 'x');

set($id, $value, $create)

Container.php:209

Set a value at $id, creating intermediate structure as needed. A path starting with '/' is applied to

function set(string $id, mixed $value, bool $create = true): void

Voir: getRoot instead of $this.

$id	string
$value	mixed
$create = true	bool	if false, a missing intermediate segment is not auto-created (raises eItemNotFound instead)
retourne	void

$container->set('a/b', 1);

setContent($content)

Container.php:141

Replace the whole content wholesale.

function setContent(array $content): void

$content	array
retourne	void

setId($id)

Container.php:105

function setId(?string $id): void

$id	null \| string
retourne	void
lève		if $id is already registered to a different container

toArray()

tArray.php:56

Convert the content to a plain array, recursively converting any nested iArray value (e.g. another object using this same trait) into its own plain-array form as well.

function toArray(): array

retourne

array

$inner = new Bag(); $inner['a'] = 1; $outer = new Bag(); $outer['inner'] = $inner; $outer->toArray(); // ['inner' => ['a' => 1]] -- $inner is recursively expanded, not left as an object

UnFetch($url)

staticContainer.php:68

Forget the container registered under $url (it can be Fetch-ed again afterward, rebuilding it).

static function UnFetch(string $url): void

$url	string
retourne	void

UnFetchAll()

staticContainer.php:76

Forget every registered container.

static function UnFetchAll(): void

retourne

void

__construct($content, $id, $parent)

Container.php:89

Create container

function __construct(array $content = [], ?string $id = null, ?self $parent = null)

$content = []	array
$id = null	null \| string	if given, registers this container under $id (`Fetch` / `Exists`)
$parent = null	null \| self