<?
//Here are some examples
//Let me start with an important note: YOU MUST EDIT THE CONFIG FILE!!! :)
require_once('GenericCollection.php');
require_once('GenericDictionary.php');
require_once('GenericQueue.php');
require_once('GenericStack.php');
//There are 4 collections in this package. Each of them has 2 versions: one generic and one not generic.
//All of the collections extend the Enumerable class so I'll start with some info about it's methods.
//The Enumerable class is abstract so I'll make a simple Collection to explain it's methods.
$a = new Collection(15, array(1,2,3,4,5));
//To clear the collection use:
$a->Clear();
//To get the number of elements in the collection use:
$a->Count();
//To check whether a collection is empty use:
$a->IsEmpty();
//To print the collection use:
$a->PrintCollection(false);
//If the parameter is true, the collection will be printed using var_dump, otherwise print_r will be used
//Default value is false
//To get the array in which the collection stores it's elements use:
$d = $a->GetArray();
//To get an iterator use:
$e = $a->getIterator();
//All collections have these methods.
//Now some info about the constructors of the collections
//Creates a Collection that contains the items in the array. You can also use anything that extends IteratorAggregate.
//Also sets the exceptions level to 13 (*)
$a = new Collection(13, array(1,2,3,4,5)); //All params optional
//Creates a GenericCollection that accepts only items of the primitive type int. (**)
$a = new GenericCollection(Type::GetType('`int`'), 15, array(1,2,3,4,5)); //last two params are optional
//Creates a Dictionary and sets the exceptions lavel (*)
$b = new Dictionary(ExceptionsManager::EX_FATAL); //the param is optional
//Creates a GenericDictionary with int keys and string values
$b = new GenericDictionary(Type::GetType('`int`'), Type::GetType('`string`'), 13); //the last param is optional
//Creates a Stack
$c = new Stack(ExceptionsManager::EX_HIGH); //the param is optional
//Creates a GenericStack with int elements
$c = new GenericStack(Type::GetType('`int`'), 12); //last param is optional
//Creates a Queue
$d = new Queue(10); //param optional
//Creates a GenericQueue with bool elements
$d= new GenericQueue(Type::GetType('`bool`'), 2); //last param is optional
//(*) - For more information read the example in the ExceptionsManager package
//(**) - For more information read the example in the Generics package
//It is very important to read the example in the Generics package if you want to use the Generic versions of the classes
//Now lets create one of each non-generic type
$a = new Collection();
$b = new Dictionary();
$c = new Stack();
$d = new Queue();
//To add an element use:
$a->Add(12);
$b->Add('key', 'value');
$c->Push(true);
$d->Enqueue(123.23);
//To remove an element use:
$a->Remove(12); //removes the element 12
$a->RemoveAt(0); //removes the element at position 0
$b->Remove('key');
//Stack and Queue don't have methods to do this
//To add multiple values from an array ot anything that extends IteratorAggregate use:
$a->AddRange(array(1,2));
$c->PushMultiple(array(1,2));
$d->EnqueueMultiple(array(1,2));
//Dictionary doesn't have a method for this
//To check whether some element is in a collection use:
$a->Contains(12);
$b->ContainsKey('key');
$b->ContainsValue('value');
$c->Contains(123);
$d->Contains('sdfsd');
//Collection and Dictionary implement ArrayAccess, so you can use them as arrays
//To get the index of the first occurance of an element in a Collection use:
$a->IndexOf('item', 2,5); //tha last two params are optional: first and last element positions to search
//For the last index use:
$a->LastIndexOf('item',2,3);
//To get an array of all positions at which an element occurs use:
$a->AllIndexesOf('item');
//To get the n-th element of a Collection use:
$n=123;
$a->ElementAt($n);
//Stack, Queue and Dictionary doesn't have methods for this
//In Collection you can insert an item in a specific position less than the number of elements in the collection
$a->Insert(2,'item');
//If $a has 1,2,3,4 before the insertion, after that $a will have 1,2,'item',3,4
//To get an array of all keys in a Dictionary use:
$b->Keys();
//To get the values use:
$b->Values();
$res;
$b->TryGetValue('key', $res);
//returns false if the key doesn't exist and true if it does and sets the velue of $res to the element corresponding to the key
$c->Peek(); //Returns the last element inserted into the Stack
$c->Pop(); //Returns the last element inserted into the Stack and removes it
$d->Peek(); //Returns the first element inserted into the Queue
$d->Dequeue(); //Returns the first element inserted into the Queue and removes it
//As seen above:
//The Stack class implements the LIFO data structure
//The Queue class implements the FIFO data structure
//GenericCollection, GenericStack and GenericQueue have the method GetType()
$a = new GenericCollection(Type::GetType('`int`'));
$a->GetType(); //Retrurns the Type object createed by Type::GetType('`int`')
//GenericDictionary has methods: GetKeyType() and GetValueType()
//All generic classes implement the IGeneric interface
//For more information on it's methods see the example in the Generics package
//If you need any help send me a mail :)
?>
|
Download
