[code=php]
<?php

class MyList implements Countable, ArrayAccess
{
    //class-variabelen
    //- type van de elementen
    //- lijst van elementen
    private $listType;
    private $innerList = array();

    //default constructor
    public function __construct($type = "string")
    {
        $this->listType = $type;
    }
	
    //item toevoegen als het type juist is
    public function Add($item)
    {
        if($this->IsType($item))
	    $this->innerList[] = $item;
    }
	
    //collectie van items toevoegen als het een array is
    public function AddRange($collection)
    {
        if($this->IsArray($collection))
            foreach($collection as $item)
                $this->Add($item);
    }
	
    //lijst leegmaken
    public function Clear()
    {
        unset($this->innerList);
    }
	
    //controleren of de lijst een item bevat
    public function Contains($item)
    {
        if($this->IsType($item))
        {
            foreach($this->innerList as $innerItem)
                if($item == $innerItem)
                    return true;
            return false;
        }
    }
	
    //aantal elementen in de lijst tellen
    public function Count()
    {
        return count($this->innerList);
    }
	
    //index van een bepaald element weergeven
    //-1 wordt teruggestuurd als het niet bestaat in de lijst
    public function IndexOf($item)
    {
        if($this->IsType($item))
        {
            $i = 0;
            foreach($this->innerList as $innerItem)
            {
                if($item == $innerItem)
                    return $i;
                else
                    $i++;
            }
            return -1;
        }
    }
	
    //element op een bepaalde index invoegen
    public function Insert($index, $item)
    {
        if($this->IsValidIndex($index) && $this->IsType($item))
        {	
            $temp1 = array_slice($this->innerList, 0, $index);
            $temp2 = array_slice($this->innerList, $index);
			
            array_push($temp1, $item);
            $this->innerList = array_merge($temp1, $temp2);
        }
    }
	
    //collectie van elementen op een bepaalde index invoegen
    public function InsertRange($index, $collection)
    {
        if($this->IsValidIndex($index) && $this->IsArray($collection))
        {
            $collection = array_reverse($collection);
            foreach($collection as $item)
                if($this->IsType($item))
                    $this->Insert($index, $item);
        }
    }
	
    //de laatste index van een element geven
    public function LastIndexOf($item)
    {
        if($this->IsType($item))
        {
            for($i = count($this->innerList)-1; $i >= 0; $i--)
                if($this->innerList[$i] == $item)
                    return $i;
            return -1;
        }
    }
	
    //een bepaald item uit de lijst verwijderen
    public function Remove($item)
    {
        if($this->IsType($item))
            $this->RemoveAt($this->IndexOf($item));
    }
	
    //een item op basis van index verwijderen
    public function RemoveAt($index)
    {
        if($this->IsValidIndex($index))
            array_splice($this->innerList, $index, 1);
    }
	
    //een collectie van items verwijderen
    public function RemoveRange($index = 0, $count)
    {
        if($this->IsValidRange($index, $count))
            for($i = 0; $i < $count; $i++)
                $this->RemoveAt($index);
    }
	
    //de volgorde van de elementen van de lijst omdraaien
    public function Reverse()
    {
        $this->innerList = array_reverse($this->innerList);
    }
	
    //een sublijst maken van de huidge en terugsturen
    public function SubList($index, $count)
    {
        $returnList = new MyList($this->listType);
        if($this->IsValidRange($index, $count))
            $returnList->AddRange(array_slice($this->innerList, $index, $count));
        return $returnList;
    }
	
    //maakt een standaard array van de elementen van de lijst
    public function ToArray()
    {
        return array_slice($this->innerList, 0);
    }
	
    //deze functie zorgt ervoor dat je de foreach-loop
    //kan gebruiken om door de elementen van de lijst te gaan
    public function GetIterator()
    {
        return new ArrayIterator($this->innerList);
    }
	
    //vanzelfsprekend
    private function IsInteger($input)
    {
        return is_int($input);
    }
	
    //vanzelfsprekend
    private function IsArray($item)
    {
        return is_array($item);
    }
	
    //deze functie kijkt na of het opgegeven type gelijk
    //is aan het type dat verwacht wordt voor de lijst
    private function IsType($item)
    {
        $itemType = gettype($item) == "object" ? get_class($item) : gettype($item);
        return $this->listType == $itemType;
    }

    //nakijken of de opgegeven index wel valid is
    private function IsValidIndex($index)
    {
        if(!$this->IsInteger($index))
            return false;
        return ($index >= 0 && $index < count($this->innerList));
    }
	
    //kijken of de range van elementen vanaf de index
    //tot het aantal elementen wel 'mag'
    //->dus dat die range niet buiten de lijst ligt
    private function IsValidRange($index, $count)
    {
        if($index < 0 || $count < 1)
            return false;
        if($count > $this->Count())
            return false;
        if(($index + $count)-1 > $this->Count()-1)
            return false;
        return true;
    }
	
    //private functie zodat je $var = $myList[$index] kan gebruiken
    private function GetItem($index)
    {
        if($this->IsValidIndex($index))
            return $this->innerList[$index];
    }
	
    //private functie zodat je $myList[$index] = $value kan gebruiken
    private function SetItem($index, $item)
    {
        if($this->IsValidIndex($index) && $this->IsType($item))
            $this->innerList[$index] = $item;
    }
	
    //wordt niet direct gebruikt maar moet neergeschreven worden
    //omdat deze klasse de interface ArrayAcces implementeert
    public function offsetExists($index)
    {
        return $this->Contains($index);
    }
	
    //functie vanuit de interface ArrayAccess die het resultaat van GetItem() terugstuurt
    //$var = myList[$index];
    public function offsetGet($index)
    {
        return $this->GetItem($index);
    }
	
    //functie die SetItem() aanroept
    //myList[$index] = $value;
    public function offsetSet($index, $item)
    {
        $this->SetItem($index, $item);
    }

    //zelfde hier als met offsetExsists
    public function offsetUnset($index)
    {
        $this->RemoveAt($index);
    }
}

?>

Mogelijk voorbeeld van gebruik:

[code=php]
require_once "List.php";

$lst = new MyList("string");
$values = array("een", "twee", "drie");
$lst->AddRange($values);
//$lst = een, twee, drie

$lst->Remove("een");
//$lst = twee, drie

$lst[1] = "vier";
//$lst = twee, vier

$lst->RemoveAt(0);
//$lst = vier

$lst->AddRange($values);
$lst->Reverse()
//$lst = drie, twee, een, vier

$sub = $lst->SubList(1, 2);
//$sub = twee, een

Voorbeeld met object:

[code=php]
require_once "List.php";
require_once "Person.php";

$lst = new MyList("Person");

$user = new Person();
$user->Naam = "abbas";
$user->Geboortejaar = 1985;

$lst->Add($user);

$newUser = $lst[0];
//$newUser = $user
$strNaam = $lst[0]->Naam;
//$strNaam = abbas
//Alle andere functies zijn ook toepasbaar