This package provides miscellaneous php interfaces and classes to structure and organize data as well as groups of objects.
- Iterator
- IteratorAware
- IteratorReverse
- IteratorLimit
- Paginator
- IteratorDecoratorAbstract
- IteratorDecoratorReverse
- IteratorDecoratorLimit
- PaginatorDecorator
- Collection
- CollectionDecorator
- ArrayList
- Map
- HashMap
- TreeMap
- Set
- HashSet
- Tree
- Enumerator
- Composite
This package is inspired by java.util package. The concepts has been adjusted to the PHP world.
- PHP5.3
install the latest version via composer
composer require naucon/utility
Start the build-in webserver to see the examples in action:
cd examples
php -S 127.0.0.1:3000
open url in browser
http://127.0.0.1:3000/index.html
Iterator extends IteratorAbstract
IteratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
The Iterator class holds data in a internal array. The class can be iterated with the foreach() command to retrieve the data from the array.
It also provides the following methods to cycle and count data: isFirst(), isLast(), current(), next(), hasNext(), previous(), hasPrevious(), first(), last(), rewind(), key(), indexOf(), hasIndex(), setItemPosition(), count().
The class implements the Iterator and Countable interface of PHP.
In contrast to the Collection or the ArrayList the Iterator is only can retrieve data it can not add them. Also it has no control of its index.
$array = array();
$array[] = 'foo';
$array[] = 'bar';
// create instance
use Naucon\Utility\Iterator;
$iteratorObject = new Iterator($array);
// count
echo count($iteratorObject); // output: 2
// iterate
foreach ($iteratorObject as $key => $value) {
echo $value . ' ';
}
// output: foo bar
IteratorAware extends IteratorAwareAbstract
IteratorAwareAbstract implements IteratorAwareInterface
IteratorAwareInterface extends IteratorAggregate, Countable
The IteratorAware class works like the Iterator class. Instead of a array it holds the data in a internal Iterator instance.
Without any methodes to cycle data the class can be iterated with the foreach() command. To count data it provides the methode count().
The internal Iterator can be accessed through the method getIterator().
The class implements the IteratorAggregate and Countable interface.
// create instance
use Naucon\Utility\IteratorAware;
use Naucon\Utility\Iterator;
$iteratorAwareObject = new IteratorAware(new Iterator(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)));
// count
echo count($iteratorAwareObject); // output: 10
// iterate
foreach ($iteratorAwareObject as $key => $value) {
echo $value . '';
}
// output: 1 2 3 4 5 6 7 8 9 10
IteratorReverse extends IteratorReverseAbstract
IteratorReverseAbstract extends IteratorAbstract
IteratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
Based on the Iterator the IteratorReverse class reverse the order of the returned items.
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// create instance
use Naucon\Utility\IteratorReverse;
$iteratorObject = new IteratorReverse($array);
// count
echo count($iteratorObject); // Output: 10
// iterate
foreach ($iteratorObject as $key => $value) {
echo $value . ' ';
}
// Output: 10 9 8 7 6 5 4 3 2 1
IteratorLimit extends IteratorLimitAbstract
IteratorLimitAbstract extends IteratorAbstract implements IteratorLimitInterface
IteratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
Based on the Iterator the IteratorLimit class retrieve a subset of the data by a given offset and count parameter.
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
// create instance
use Naucon\Utility\IteratorLimit;
$iteratorObject = new IteratorLimit($array, 10, 10); // offset=10, count=10
// count
echo count($iteratorObject); // Output: 21
// iterate
foreach ($iteratorObject as $key => $value) {
echo $value . ' ';
}
// Output: 11 12 13 14 15 16 17 18 19 20
Paginator extends PaginatorAbstract
PaginatorAbstract extends IteratorLimitAbstract implements PaginatorInterface
IteratorLimitAbstract extends IteratorAbstract implements IteratorLimitInterface
IteratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
Based on the IteratorLimit the Paginator class devise the data into pages by a given itemsPerPage parameter.
It also provides the following methods to control pages: getCurrentPageNumber(), setPage(), nextPage(), countPages(), isFirstPage(), isLastPage(), hasNextPage(), hasPreviousPage(), getNextPageNumber(), getPreviousPageNumber().
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
// create instance
use Naucon\Utility\Paginator;
$paginatorObject = new Paginator($array, 10);
// count
echo count($paginatorObject); // Output: 21
// iterate page 1
foreach ($paginatorObject as $key => $value) {
echo $value . ' ';
}
// Output: 1 2 3 4 5 6 7 8 9 10
// next page
$paginatorObject->nextPage();
// iterate page 2
foreach ($paginatorObject as $key => $value) {
echo $value . ' ';
}
// Output: 11 12 13 14 15 16 17 18 19 20
// set a certain page
$paginatorObject->setPage(3);
// iterate page 3
foreach ($paginatorObject as $key => $value) {
echo $value . ' ';
}
// Output: 21
IteratorDecoratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
The IteratorDecoratorAbstract is a abstract class. Like the IteratorAware class it holds the data in a internal Iterator instance.
Instead of the IteratorAware it implements every method of the IteratorInterface to be completely compatible to a normal Iterator.
His purpose is to create a abstraction layer between Iterator and a individual implementation.
For example the Paginator and IteratorLimit can't modify the same data or instance. Because they are individual implementations of the IteratorInterface.
Which a decorator you can modify any Iterator instance a often as you like.
As you can guess it is the basement of the IteratorDecoratorReverse, IteratorDecoratorLimit and PaginatorDecorator class.
IteratorDecoratorReverse extends IteratorDecoratorAbstract
IteratorDecoratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
The IteratorDecoratorReverse class is a decorator for any instance of IteratorInterface. The Decorator reverse the order of the returned items.
It have the same methods as the IteratorLimit class.
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// create instance
use Naucon\Utility\Iterator;
use Naucon\Utility\IteratorDecoratorReverse;
$iteratorLimitObject = new IteratorDecoratorReverse(new Iterator($array));
IteratorDecoratorLimit extends IteratorDecoratorAbstract
IteratorDecoratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
The IteratorDecoratorLimit class is a decorator for any instance of IteratorInterface. The Decorator retrieve a subset of the data by a given offset and count parameter.
It have the same methods as the IteratorLimit class.
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
// create instance
use Naucon\Utility\Iterator;
use Naucon\Utility\IteratorDecoratorLimit;
$iteratorLimitObject = new IteratorDecoratorLimit(new Iterator($array), 0, 10);
PaginatorDecorator extends IteratorDecoratorLimit implements PaginatorInterface
IteratorDecoratorLimit extends IteratorDecoratorAbstract
IteratorDecoratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
The PaginatorDecorator class is a decorator for any instance of IteratorInterface. The Decorator devise the data into pages by a given itemsPerPage parameter.
It have the same methods as the Paginator class.
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
// create instance
use Naucon\Utility\Iterator;
use Naucon\Utility\PaginatorDecorator;
$paginatorObject = new PaginatorDecorator(new Iterator($array), 10);
Collection extends CollectionAbstract
CollectionAbstract extends IteratorAwareAbstract implements CollectionInterface
IteratorAwareAbstract implements IteratorAwareInterface
IteratorAwareInterface extends IteratorAggregate, Countable
The Collection class holds, add and remove data in a internal array. Also it implements the IteratorAwareInterface to iterated the data with the foreach() command.
In contrast to the Iterator or IteratorAware the Collection can retrieve, add and remove data. But he also has no control of the index.
It provides the following methods to add and count data: add(), addAll(), clear(), contains(), isEmpty(), getIterator(), remove(), count(), toArray().
The class implements the IteratorAggregate and Countable interface of PHP.
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// create instance
use Naucon\Utility\Collection;
$collectionObject = new Collection($array);
// count
echo count($collectionObject); // Output: 10
// iterate
foreach ($collectionObject as $key => $value) {
echo $value . ' ';
}
// Output: 1 2 3 4 5 6 7 8 9 10
// dump data to a array
var_dump($collectionObject->toArray());
// Output: array(10) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) [4]=> int(5) [5]=> int(6) [6]=> int(7) [7]=> int(8) [8]=> int(9) [9]=> int(10) }
// contains value of 10
if ($collectionObject->contains(10)) {
echo 'TRUE';
} else {
echo 'FALSE';
}
// Output: TRUE
// contains value of 40
if ($collectionObject->contains(40)) {
echo 'TRUE';
} else {
echo 'FALSE';
}
// Output: FALSE
// add data
$collectionObject->add(11);
// add array of data
$collectionObject->addAll(array(12, 13, 14, 15, 16));
// remove data
$collectionObject->remove(4);
// remove all data
$collectionObject->clear();
CollectionDecorator extends CollectionDecoratorAbstract
CollectionDecoratorAbstract implements CollectionInterface
CollectionInterface extends IteratorAwareInterface
IteratorAwareInterface extends IteratorAggregate, Countable
The CollectionDecorator is a abstract class. Like the IteratorDecoratorAbstract class it holds the data in a internal Collection instance.
It implements every method of the CollectionInterface to be completely compatible to a normal Collection.
His purpose is to create a abstraction layer between Collection and a individual implementation.
ArrayList extends ListAbstract
ListAbstract extends CollectionAbstract implements ListInterface
CollectionAbstract extends IteratorAwareAbstract implements CollectionInterface
IteratorAwareAbstract implements IteratorAwareInterface
IteratorAwareInterface extends IteratorAggregate, Countable
The ArrayList class holds, add and remove data in a internal array with a individual index. Also it implements the CollectionInterface and therefore the IteratorAwareInterface to iterated the data with the foreach() command.
In contrast to the Collection he has control of the index.
It provides the following methods to add and count data: add(), addWithIndex(), addAll(), get(), hasIndex(), removeIndex(), set(), clear(), contains(), isEmpty(), getIterator(), remove(), count(), toArray().
The class implements the IteratorAggregate and Countable interface of PHP.
$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// create instance
use Naucon\Utility\ArrayList;
$listObject = new ArrayList($array);
// count
echo count($listObject); // Output: 10
// iterate
foreach ($listObject as $key => $value) {
echo $value . ' ';
}
// Output: 1 2 3 4 5 6 7 8 9 10
// dump data to a array
var_dump($listObject->toArray());
// Output: array(10) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) [4]=> int(5) [5]=> int(6) [6]=> int(7) [7]=> int(8) [8]=> int(9) [9]=> int(10) }
// get entry by index
echo $listObject->get(0); // Output: 1
echo $listObject->get(9); // Output: 10
// add data
$listObject->add(11);
// add array of data
$listObject->addAll(array(12, 13, 14, 15, 16));
// add data with index
$listObject->addWithIndex(16, 17);
$listObject->addWithIndex(17, 18);
$listObject->set(18, 19);
$listObject->set(10, 99);
// remove data by value
$listObject->remove(4);
// remove data by index
$listObject->removeIndex(0);
// remove all data
$listObject->clear();
Map extends MapAbstract
MapAbstract implements MapInterface
MapInterface extends Countable
The Map class holds, add and remove key-value pairs of data in a internal array. In contrast to the Iterator and Collection classes it can not interate data with the foreach() command.
A key in a Map can only be used once. when adding a key-value pair with a existing key it will overwrite the existing key-value pair.
That is the main difference to the Set class.
It provides the following methods to add and remove key-value pairs: hasKey(), hasValue(), get(), getAll(), set(), setAll(), set(), remove(), clear(), count().
The class implements the Countable interface of PHP.
// create instance
use Naucon\Utility\Map;
$mapObject = new Map();
// key-value pair 1
$mapKey[] = 'KeyA';
$mapValue[] = 'Value A';
// key-value pair 2
$mapKey[] = 'KeyB';
$mapValue[] = 'Value B';
// key-value pair 3
$mapKey[] = 'KeyC';
$mapValue[] = 'Value C';
// add key-value-pairs to map
$mapObject->set($mapKey[0], $mapValue[0]);
$mapObject->set($mapKey[1], $mapValue[1]);
$mapObject->set($mapKey[2], $mapValue[2]);
// get key-value-pairs from map
echo $mapObject->get($mapKey[0]); // Output: Value A
echo $mapObject->get($mapKey[1]); // Output: Value B
echo $mapObject->get($mapKey[2]); // Output: Value C
// count key-value-pairs
echo count($mapObject); // Output: 3
// remove key-value pair with 'Value B'
$mapObject->remove($mapKey[1]);
HashMap extends HashMapAbstract
HashMapAbstract extends MapAbstract implements HashMapInterface
MapAbstract implements MapInterface
MapInterface extends Countable
Based on the Map the HashMap add and remove key-value pairs in the same way as the Map class do.
In contrast to the Map class the key in an HashMap can also be a instance of an object. The HashMap converts the instance with the spl_object_hash() function to a hash key.
Because the key is converted to a hash the HashMap can not return it original form (object). But values can be added, removed and returned by a given instance.
It provides the following methods to add and remove key-value pairs: hasKey(), hasValue(), get(), getAll(), set(), setAll(), set(), remove(), clear(), count().
The class implements the Countable interface of PHP.
TreeMap extends TreeMapAbstract
TreeMapAbstract extends Map implements MapInterface
Map extends MapAbstract
MapAbstract implements MapInterface
MapInterface extends Countable
The TreeMap class works like the Map Class. It holds, add and remove key-value pairs of data in a internal array.
A contrast to a a Map the TreeMap can add multiple value to one key.
It provides the following methods to add and remove key-value pairs: hasKey(), hasValue(), get(), getAll(), set(), setAll(), set(), remove(), clear(), count().
The class implements the Countable interface of PHP.
// create instance
use Naucon\Utility\TreeMap;
$mapObject = new TreeMap();
// key-value pair 1
$mapKey[0] = 'KeyA';
$mapValue[0] = 'Value A';
// key-value pair 2
$mapKey[1] = 'KeyB';
$mapValue[1] = 'Value B';
// key-value pair 3
$mapKey[2] = 'KeyC';
$mapValue[2][0] = 'Value C1';
$mapValue[2][1] = 'Value C2';
$mapValue[2][2] = 'Value C3';
// add key-value pairs to map
$mapObject->set($mapKey[0], $mapValue[0]);
$mapObject->set($mapKey[1], $mapValue[1]);
$mapObject->set($mapKey[2], $mapValue[2][0]);
$mapObject->set($mapKey[2], $mapValue[2][1]);
$mapObject->set($mapKey[2], $mapValue[2][2]);
// get key-value pairs from map
echo $mapObject->get($mapKey[0]); // Output: Value A
echo $mapObject->get($mapKey[1]); // Output: Value B
foreach ($mapObject->get($mapKey[2]) as $value) {
echo $value . ' ';
}
// Output: Value C1 Value C2 Value C3'
// count key-value-pairs
echo count($mapObject); // Output: 3
// remove key-value with 'Value B'
$mapObject->remove($mapKey[1]);
Set extends SetAbstract
SetAbstract extends CollectionAbstract
CollectionAbstract extends IteratorAwareAbstract implements CollectionInterface
IteratorAwareAbstract implements IteratorAwareInterface
The Set class works like the Collection Class. It holds, add and remove data in a internal array.
A existing value can only added once. Also data can be interated throught the foreach() command.
It provides the following methods to retrieve, add and remove data: add(), addAll(), clear(), contains(), isEmpty(), getIterator(), remove(), count(), toArray().
The class implements the IteratorAggregate and Countable interface of PHP.
// create instance
use Naucon\Utility\Set;
$setObject = new Set();
$setObject->addAll(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
// count
echo count($setObject); // Output: 10
// iterate
foreach ($setObject as $key => $value) {
echo $value . ' ';
}
// Output: 1 2 3 4 5 6 7 8 9 10
// dump data to a array
var_dump($setObject->toArray());
// Output: array(10) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) [4]=> int(5) [5]=> int(6) [6]=> int(7) [7]=> int(8) [8]=> int(9) [9]=> int(10) }
// contains value of 10
if ($setObject->contains(10)) {
echo 'TRUE';
} else {
echo 'FALSE';
}
// Output: TRUE
// contains value of 40
if ($setObject->contains(40)) {
echo 'TRUE';
} else {
echo 'FALSE';
}
// Output: FALSE
// add data
$setObject->add(11); // return true
// add array of data
$setObject->addAll(array(12, 13, 14, 15, 16));
// add duplicate data // return false
$setObject->add(11);
// remove data
$setObject->remove(4);
// remove all data
$setObject->clear();
HashSet extends HashSetAbstract
HashSetAbstract extends SetAbstract implements HashSetInterface
SetAbstract extends CollectionAbstract
CollectionAbstract extends IteratorAwareAbstract implements CollectionInterface
IteratorAwareAbstract implements IteratorAwareInterface
Based on the Set the HashSet hold, add and remove data in the same way as the Set class do.
In contrast to the Set class the key in an HashSet is a hash of its value. The HashSet converts a given instance of an value with the spl_object_hash() function to a hash key.
Like the Set class a existing value can only added once. Also data can be interated throught the foreach() command.
It provides the following methods to add and remove key-value pairs: add(), addAll(), clear(), contains(), isEmpty(), getIterator(), remove(), count(), toArray().
The class implements the IteratorAggregate and Countable interface of PHP.
Tree extends TreeAbstract
TreeAbstract extends TreeNodeAbstract implements TreeInterface
TreeNodeAbstract implements TreeNodeInterface
TreeInterface extends TreeNodeInterface, IteratorAwareInterface
IteratorAwareInterface extends IteratorAggregate, Countable
The Tree class holds hierarchical structure data in a internal HashSet. The class can be iterated with the foreach() command to retrieve the data from the HashSet.
It also provides the following methods to retrieve, add, remove data: getIterator(), hasChilds(), count(), add(), addChild(), removeChild(), hasParent(), getParent(), removeNode(), rewind(), key(), indexOf(), hasIndex(), setItemPosition(), count().
The class implements the IteratorAggregate and Countable interface of PHP.
In contrast to the IteratorAware, Iterator or Collection the Tree only works with instances of TreeNodeInterface.
// create instance
use Naucon\Utility\TreeNodeAbstract;
use Naucon\Utility\TreeInterface;
use Naucon\Utility\TreeAbstract;
use Naucon\Utility\Tree;
$treeRootObject = new Tree();
// declare a simple tree node class
class FooTree extends TreeNodeAbstract
{
protected $value = '';
public function __construct($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}
// declare another simple tree node class
class BarTree extends TreeAbstract
{
protected $value = '';
public function __construct($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}
// create instance of tree nodes
$fooObj1 = new \FooTree('A');
$fooObj2 = new \FooTree('B');
// add a nodes A and B to tree
$treeRootObject->add($fooObj1);
$treeRootObject->add($fooObj2);
// add a tree C to tree
$treeChildLevel1Object = $treeRootObject->add(new \BarTree('C')); // add() returns a instance of the `TreeNode`
// add a node C1 to node C
$treeChildLevel1Object->add(new \FooTree('C1'));
// add a node C2 to node C
$treeChildLevel2Object = $treeChildLevel1Object->add(new \BarTree('C2'));
// add a node C21 to node C2
$treeChildLevel2Object->add(new \FooTree('C21'));
// add a node C3 to node C
$treeChildLevel1Object->add(new \FooTree('C3'));
// add a node D to tree
$treeRootObject->add(new \FooTree('D'));
// count
echo count($treeRootObject); // Output: 4
// iterate
foreach ($treeRootObject as $treeNodeObject) {
echo $treeNodeObject->getValue();
echo '<br/>';
if ($treeNodeObject instanceof TreeInterface) {
foreach ($treeNodeObject as $treeChildNodeObject) {
echo $treeNodeObject->getValue() . ' - ' . $treeChildNodeObject->getValue();
echo '<br/>';
if ($treeChildNodeObject instanceof TreeInterface) {
foreach ($treeChildNodeObject as $treeChild2NodeObject) {
echo $treeNodeObject->getValue() . ' - ' . $treeChildNodeObject->getValue() . ' - ' . $treeChild2NodeObject->getValue();
echo '<br/>';
}
}
}
}
}
// Output:
// A
// B
// C
// C - C1
// C - C2
// C - C2 - C21
// C - C3
// D
// remove tree node from tree
$treeRootObject->remove($fooObj2);
Enumerator extends EnumeratorAbstract
EnumeratorAbstract extends IteratorAbstract implements EnumeratorInterface
IteratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
The Enumerator class provides a easy way to retrieve, add and interated key-value-pairs of data. The class can be iterated with the foreach() command.
It also provides the following methods to retrieve, add and remove key-value pairs of data: set(), remove(), isFirst(), isLast(), current(), next(), hasNext(), previous(), hasPrevious(), first(), last(), key(), valid(), rewind(), hasIndex(), indexOf(), setItemPosition(), count().
The class implements the Iterator and Countable interface.
// create instance
use Naucon\Utility\Enumerator;
$enumeratorObject1 = new Enumerator('RED', 'BLUE', 'GREEN', 'YELLOW', 'BLACK');
echo 'My favorite color is ' . $enumeratorObject1->RED;
// Output: My favorite color is RED
// iterate
foreach ($enumeratorObject1 as $key => $value) {
echo $value . ' ';
}
// Output: RED BLUE GREEN YELLOW BLACK
// create another instance
$enumeratorObject2 = new Enumerator();
// add enumeration
$enumeratorObject2->set('FF0000', 'RED');
$enumeratorObject2->set('0000FF', 'BLUE');
$enumeratorObject2->set('00FF00', 'GREEN');
$enumeratorObject2->set('FFFF00', 'YELLOW');
$enumeratorObject2->set('000000', 'BLACK');
echo 'HEX color code of RED is #' . $enumeratorObject2->RED;
// Output: HEX color code of RED is #FF0000
// create another instance
$enumeratorObject3 = new Enumerator();
// add enumeration
$enumeratorObject3->RED = 'FF0000';
$enumeratorObject3->BLUE = '0000FF';
$enumeratorObject3->GREEN = '00FF00';
$enumeratorObject3->YELLOW = 'FFFF00';
$enumeratorObject3->BLACK = '000000';
echo 'HEX color code of RED is #' . $enumeratorObject3->RED;
// Output: HEX color code of RED is #FF0000
// create another instance
$enumeratorObjectParent = new Enumerator();
// add enumeration
$enumeratorObjectParent->COLOR = $enumeratorObject3; // add a enumeration instance
$enumeratorObjectParent->FOO = 'bar';
echo 'HEX color code of RED is #' . $enumeratorObjectParent->COLOR->RED . '<br/>';
// Output: HEX color code of RED is #FF0000
// iterate
foreach ($enumeratorObjectParent as $key => $value) {
if ($value instanceof Enumerator) {
echo $key . ' ';
foreach ($value as $value2) {
echo $value2 . ' ';
}
} else {
echo (string)$value . ' ';
}
}
// Output: COLOR FF0000 0000FF 00FF00 FFFF00 000000 bar
Composite extends CompositeAbstract
CompositeAbstract extends IteratorAbstract implements CompositeElementInterface
IteratorAbstract implements IteratorInterface
IteratorInterface extends Iterator, Countable
The Composite class holds hierarchical structure data in a internal array similar to the Tree class. The class can be iterated with the foreach() command to retrieve the child elements.
It also provides the following methods to retrieve, add, remove data: add(), remove(), isFirst(), isLast(), current(), next(), hasNext(), previous(), hasPrevious(), first(), last(), key(), valid(), rewind(), indexOf(), setItemPosition(), count().
The class implements the Iterator and Countable interface of PHP.
In contrast to the Tree class the composite has no root element. Every element is equal to each other.
The elements have to be a instances of CompositeElementInterface.
use Naucon\Utility\CompositeAbstract;
// declare simple composite element class
class CompositeElement extends CompositeAbstract
{
protected $state = null;
public function __construct($state)
{
$this->state = $state;
}
public function __toString()
{
return $this->state;
}
}
// create element instances
$elementAObject = new \CompositeElement('A');
$elementBObject = new \CompositeElement('B');
$elementCObject = new \CompositeElement('C');
$elementDObject = new \CompositeElement('D');
$elementEObject = new \CompositeElement('E');
// add elements
$elementAObject->add($elementBObject); // B to A
$elementAObject->add($elementCObject); // C to A
$elementBObject->add($elementDObject); // D to B
$elementAObject->add($elementEObject); // E to A
// iterate
foreach ($elementAObject as $elementChildObject) {
echo (string)$elementChildObject . ' '; // call __toString() method
}
// Output: B C E
// remove element
//$elementAObject->remove($elementBObject);
The MIT License (MIT)
Copyright (c) 2015 Sven Sanzenbacher
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.