chdemko / php-sorted-collections

src/SortedCollection/ReversedMap.php

Indentation +226 added lines, -226 removed lines

@@ -36,246 +36,246 @@
  */
 class ReversedMap extends AbstractMap
 {
-    /**
-     * @var SortedMap  Internal map
-     *
-     * @since 1.0.0
-     */
-    private $map;
+	/**
+	 * @var SortedMap  Internal map
+	 *
+	 * @since 1.0.0
+	 */
+	private $map;
 
-    /**
-     * @var callable  Comparator function
-     *
-     * @param mixed $key1 First key
-     * @param mixed $key2 Second key
-     *
-     * @return integer negative if $key1 is lesser than $key2,
-     *                 0 if $key1 is equal to $key2,
-     *                 positive if $key1 is greater than $key2
-     *
-     * @since 1.0.0
-     */
-    private $comparator;
+	/**
+	 * @var callable  Comparator function
+	 *
+	 * @param mixed $key1 First key
+	 * @param mixed $key2 Second key
+	 *
+	 * @return integer negative if $key1 is lesser than $key2,
+	 *                 0 if $key1 is equal to $key2,
+	 *                 positive if $key1 is greater than $key2
+	 *
+	 * @since 1.0.0
+	 */
+	private $comparator;
 
-    /**
-     * Constructor
-     *
-     * @param SortedMap $map Internal map
-     *
-     * @since 1.0.0
-     */
-    protected function __construct(SortedMap $map)
-    {
-        $this->map = $map;
-        $this->comparator = function ($key1, $key2) {
-            return - call_user_func($this->map->comparator, $key1, $key2);
-        };
-    }
+	/**
+	 * Constructor
+	 *
+	 * @param SortedMap $map Internal map
+	 *
+	 * @since 1.0.0
+	 */
+	protected function __construct(SortedMap $map)
+	{
+		$this->map = $map;
+		$this->comparator = function ($key1, $key2) {
+			return - call_user_func($this->map->comparator, $key1, $key2);
+		};
+	}
 
-    /**
-     * Create
-     *
-     * @param SortedMap $map Internal map
-     *
-     * @return ReversedMap A new reversed map
-     *
-     * @since 1.0.0
-     */
-    public static function create(SortedMap $map)
-    {
-        return new static($map);
-    }
+	/**
+	 * Create
+	 *
+	 * @param SortedMap $map Internal map
+	 *
+	 * @return ReversedMap A new reversed map
+	 *
+	 * @since 1.0.0
+	 */
+	public static function create(SortedMap $map)
+	{
+		return new static($map);
+	}
 
-    /**
-     * Magic get method
-     *
-     * @param string $property The property
-     *
-     * @return mixed The value associated to the property
-     *
-     * @since 1.0.0
-     */
-    public function __get($property)
-    {
-        switch ($property) {
-            case 'map':
-                return $this->map;
-            default:
-                return parent::__get($property);
-        }
-    }
+	/**
+	 * Magic get method
+	 *
+	 * @param string $property The property
+	 *
+	 * @return mixed The value associated to the property
+	 *
+	 * @since 1.0.0
+	 */
+	public function __get($property)
+	{
+		switch ($property) {
+			case 'map':
+				return $this->map;
+			default:
+				return parent::__get($property);
+		}
+	}
 
-    /**
-     * Get the comparator
-     *
-     * @return callable The comparator
-     *
-     * @since 1.0.0
-     */
-    public function comparator()
-    {
-        return $this->comparator;
-    }
+	/**
+	 * Get the comparator
+	 *
+	 * @return callable The comparator
+	 *
+	 * @since 1.0.0
+	 */
+	public function comparator()
+	{
+		return $this->comparator;
+	}
 
-    /**
-     * Get the first element
-     *
-     * @return mixed The first element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function first()
-    {
-        return $this->map->last();
-    }
+	/**
+	 * Get the first element
+	 *
+	 * @return mixed The first element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function first()
+	{
+		return $this->map->last();
+	}
 
-    /**
-     * Get the last element
-     *
-     * @return mixed The last element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function last()
-    {
-        return $this->map->first();
-    }
+	/**
+	 * Get the last element
+	 *
+	 * @return mixed The last element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function last()
+	{
+		return $this->map->first();
+	}
 
-    /**
-     * Get the predecessor element
-     *
-     * @param TreeNode $element A tree node member of the underlying TreeMap
-     *
-     * @return mixed The predecessor element
-     *
-     * @throws \OutOfBoundsException If there is no predecessor
-     *
-     * @since 1.0.0
-     */
-    public function predecessor($element)
-    {
-        return $this->map->successor($element);
-    }
+	/**
+	 * Get the predecessor element
+	 *
+	 * @param TreeNode $element A tree node member of the underlying TreeMap
+	 *
+	 * @return mixed The predecessor element
+	 *
+	 * @throws \OutOfBoundsException If there is no predecessor
+	 *
+	 * @since 1.0.0
+	 */
+	public function predecessor($element)
+	{
+		return $this->map->successor($element);
+	}
 
-    /**
-     * Get the successor element
-     *
-     * @param TreeNode $element A tree node member of the underlying TreeMap
-     *
-     * @return mixed The successor element
-     *
-     * @throws \OutOfBoundsException If there is no successor
-     */
-    public function successor($element)
-    {
-        return $this->map->predecessor($element);
-    }
+	/**
+	 * Get the successor element
+	 *
+	 * @param TreeNode $element A tree node member of the underlying TreeMap
+	 *
+	 * @return mixed The successor element
+	 *
+	 * @throws \OutOfBoundsException If there is no successor
+	 */
+	public function successor($element)
+	{
+		return $this->map->predecessor($element);
+	}
 
-    /**
-     * Returns the element whose key is the greatest key lesser than the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no lower element
-     *
-     * @since 1.0.0
-     */
-    public function lower($key)
-    {
-        return $this->map->higher($key);
-    }
+	/**
+	 * Returns the element whose key is the greatest key lesser than the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no lower element
+	 *
+	 * @since 1.0.0
+	 */
+	public function lower($key)
+	{
+		return $this->map->higher($key);
+	}
 
-    /**
-     * Returns the element whose key is the greatest key lesser than or equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no floor element
-     *
-     * @since 1.0.0
-     */
-    public function floor($key)
-    {
-        return $this->map->ceiling($key);
-    }
+	/**
+	 * Returns the element whose key is the greatest key lesser than or equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no floor element
+	 *
+	 * @since 1.0.0
+	 */
+	public function floor($key)
+	{
+		return $this->map->ceiling($key);
+	}
 
-    /**
-     * Returns the element whose key is equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no such element
-     *
-     * @since 1.0.0
-     */
-    public function find($key)
-    {
-        return $this->map->find($key);
-    }
+	/**
+	 * Returns the element whose key is equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no such element
+	 *
+	 * @since 1.0.0
+	 */
+	public function find($key)
+	{
+		return $this->map->find($key);
+	}
 
-    /**
-     * Returns the element whose key is the lowest key greater than or equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no ceiling element
-     *
-     * @since 1.0.0
-     */
-    public function ceiling($key)
-    {
-        return $this->map->floor($key);
-    }
+	/**
+	 * Returns the element whose key is the lowest key greater than or equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no ceiling element
+	 *
+	 * @since 1.0.0
+	 */
+	public function ceiling($key)
+	{
+		return $this->map->floor($key);
+	}
 
-    /**
-     * Returns the element whose key is the lowest key greater than to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no higher element
-     *
-     * @since 1.0.0
-     */
-    public function higher($key)
-    {
-        return $this->map->lower($key);
-    }
+	/**
+	 * Returns the element whose key is the lowest key greater than to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no higher element
+	 *
+	 * @since 1.0.0
+	 */
+	public function higher($key)
+	{
+		return $this->map->lower($key);
+	}
 
-    /**
-     * Serialize the object
-     *
-     * @return array Array of values
-     *
-     * @since 1.0.0
-     */
-    public function jsonSerialize()
-    {
-        return array('ReversedMap' => $this->map->jsonSerialize());
-    }
+	/**
+	 * Serialize the object
+	 *
+	 * @return array Array of values
+	 *
+	 * @since 1.0.0
+	 */
+	public function jsonSerialize()
+	{
+		return array('ReversedMap' => $this->map->jsonSerialize());
+	}
 
-    /**
-     * Count the number of key/value pairs
-     *
-     * @return integer
-     *
-     * @since 1.0.0
-     */
-    public function count()
-    {
-        return $this->map->count();
-    }
+	/**
+	 * Count the number of key/value pairs
+	 *
+	 * @return integer
+	 *
+	 * @since 1.0.0
+	 */
+	public function count()
+	{
+		return $this->map->count();
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -67,8 +67,8 @@
     protected function __construct(SortedMap $map)
     {
         $this->map = $map;
-        $this->comparator = function ($key1, $key2) {
-            return - call_user_func($this->map->comparator, $key1, $key2);
+        $this->comparator = function($key1, $key2) {
+            return -call_user_func($this->map->comparator, $key1, $key2);
         };
     }
 

src/SortedCollection/AbstractSet.php

Indentation +278 added lines, -278 removed lines

@@ -29,304 +29,304 @@
  */
 abstract class AbstractSet implements SortedSet
 {
-    /**
-     * @var SortedMap  Underlying map
-     *
-     * @since 1.0.0
-     */
-    private $map;
+	/**
+	 * @var SortedMap  Underlying map
+	 *
+	 * @since 1.0.0
+	 */
+	private $map;
 
-    /**
-     * Get the map
-     *
-     * @return SortedMap The underlying map
-     *
-     * @since 1.0.0
-     */
-    protected function getMap()
-    {
-        return $this->map;
-    }
+	/**
+	 * Get the map
+	 *
+	 * @return SortedMap The underlying map
+	 *
+	 * @since 1.0.0
+	 */
+	protected function getMap()
+	{
+		return $this->map;
+	}
 
-    /**
-     * Set the map
-     *
-     * @param SortedMap $map The underlying map
-     *
-     * @return AbstractSet $this for chaining
-     *
-     * @since 1.0.0
-     */
-    protected function setMap(SortedMap $map)
-    {
-        $this->map = $map;
+	/**
+	 * Set the map
+	 *
+	 * @param SortedMap $map The underlying map
+	 *
+	 * @return AbstractSet $this for chaining
+	 *
+	 * @since 1.0.0
+	 */
+	protected function setMap(SortedMap $map)
+	{
+		$this->map = $map;
 
-        return $this;
-    }
+		return $this;
+	}
 
-    /**
-     * Magic get method
-     *
-     * @param string $property The property
-     *
-     * @throws \RuntimeException If the property does not exist
-     *
-     * @return mixed The value associated to the property
-     *
-     * @since 1.0.0
-     */
-    public function __get($property)
-    {
-        switch ($property) {
-            case 'comparator':
-                return $this->comparator();
-            case 'first':
-                return $this->first();
-            case 'last':
-                return $this->last();
-            case 'count':
-                return $this->count();
-            default:
-                throw new \RuntimeException('Undefined property');
-        }
-    }
+	/**
+	 * Magic get method
+	 *
+	 * @param string $property The property
+	 *
+	 * @throws \RuntimeException If the property does not exist
+	 *
+	 * @return mixed The value associated to the property
+	 *
+	 * @since 1.0.0
+	 */
+	public function __get($property)
+	{
+		switch ($property) {
+			case 'comparator':
+				return $this->comparator();
+			case 'first':
+				return $this->first();
+			case 'last':
+				return $this->last();
+			case 'count':
+				return $this->count();
+			default:
+				throw new \RuntimeException('Undefined property');
+		}
+	}
 
-    /**
-     * Get the comparator
-     *
-     * @return callable The comparator
-     *
-     * @since 1.0.0
-     */
-    public function comparator()
-    {
-        return $this->map->comparator();
-    }
+	/**
+	 * Get the comparator
+	 *
+	 * @return callable The comparator
+	 *
+	 * @since 1.0.0
+	 */
+	public function comparator()
+	{
+		return $this->map->comparator();
+	}
 
-    /**
-     * Get the first element
-     *
-     * @return mixed The first element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function first()
-    {
-        return $this->map->firstKey();
-    }
+	/**
+	 * Get the first element
+	 *
+	 * @return mixed The first element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function first()
+	{
+		return $this->map->firstKey();
+	}
 
-    /**
-     * Get the last element
-     *
-     * @return mixed The last element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function last()
-    {
-        return $this->map->lastKey();
-    }
+	/**
+	 * Get the last element
+	 *
+	 * @return mixed The last element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function last()
+	{
+		return $this->map->lastKey();
+	}
 
-    /**
-     * Returns the greatest element lesser than the given element
-     *
-     * @param mixed $element The searched element
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no lower element
-     *
-     * @since 1.0.0
-     */
-    public function lower($element)
-    {
-        return $this->map->lowerKey($element);
-    }
+	/**
+	 * Returns the greatest element lesser than the given element
+	 *
+	 * @param mixed $element The searched element
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no lower element
+	 *
+	 * @since 1.0.0
+	 */
+	public function lower($element)
+	{
+		return $this->map->lowerKey($element);
+	}
 
-    /**
-     * Returns the greatest element lesser than or equal to the given element
-     *
-     * @param mixed $element The searched element
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no floor element
-     *
-     * @since 1.0.0
-     */
-    public function floor($element)
-    {
-        return $this->map->floorKey($element);
-    }
+	/**
+	 * Returns the greatest element lesser than or equal to the given element
+	 *
+	 * @param mixed $element The searched element
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no floor element
+	 *
+	 * @since 1.0.0
+	 */
+	public function floor($element)
+	{
+		return $this->map->floorKey($element);
+	}
 
-    /**
-     * Returns the element equal to the given element
-     *
-     * @param mixed $element The searched element
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no such element
-     *
-     * @since 1.0.0
-     */
-    public function find($element)
-    {
-        return $this->map->findKey($element);
-    }
+	/**
+	 * Returns the element equal to the given element
+	 *
+	 * @param mixed $element The searched element
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no such element
+	 *
+	 * @since 1.0.0
+	 */
+	public function find($element)
+	{
+		return $this->map->findKey($element);
+	}
 
-    /**
-     * Returns the lowest element greater than or equal to the given element
-     *
-     * @param mixed $element The searched element
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no ceiling element
-     *
-     * @since 1.0.0
-     */
-    public function ceiling($element)
-    {
-        return $this->map->ceilingKey($element);
-    }
+	/**
+	 * Returns the lowest element greater than or equal to the given element
+	 *
+	 * @param mixed $element The searched element
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no ceiling element
+	 *
+	 * @since 1.0.0
+	 */
+	public function ceiling($element)
+	{
+		return $this->map->ceilingKey($element);
+	}
 
-    /**
-     * Returns the lowest element greater than to the given element
-     *
-     * @param mixed $element The searched element
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no higher element
-     *
-     * @since 1.0.0
-     */
-    public function higher($element)
-    {
-        return $this->map->higherKey($element);
-    }
+	/**
+	 * Returns the lowest element greater than to the given element
+	 *
+	 * @param mixed $element The searched element
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no higher element
+	 *
+	 * @since 1.0.0
+	 */
+	public function higher($element)
+	{
+		return $this->map->higherKey($element);
+	}
 
-    /**
-     * Convert the object to a string
-     *
-     * @return string String representation of the object
-     *
-     * @since 1.0.0
-     */
-    public function __toString()
-    {
-        return json_encode($this->toArray());
-    }
+	/**
+	 * Convert the object to a string
+	 *
+	 * @return string String representation of the object
+	 *
+	 * @since 1.0.0
+	 */
+	public function __toString()
+	{
+		return json_encode($this->toArray());
+	}
 
-    /**
-     * Convert the object to an array
-     *
-     * @return array Array representation of the object
-     *
-     * @since 1.0.0
-     */
-    public function toArray()
-    {
-        $array = array();
+	/**
+	 * Convert the object to an array
+	 *
+	 * @return array Array representation of the object
+	 *
+	 * @since 1.0.0
+	 */
+	public function toArray()
+	{
+		$array = array();
 
-        foreach ($this as $value) {
-            $array[] = $value;
-        }
+		foreach ($this as $value) {
+			$array[] = $value;
+		}
 
-        return $array;
-    }
+		return $array;
+	}
 
-    /**
-     * Create an iterator
-     *
-     * @return Iterator A new iterator
-     *
-     * @since 1.0.0
-     */
-    public function getIterator()
-    {
-        return Iterator::keys($this->map);
-    }
+	/**
+	 * Create an iterator
+	 *
+	 * @return Iterator A new iterator
+	 *
+	 * @since 1.0.0
+	 */
+	public function getIterator()
+	{
+		return Iterator::keys($this->map);
+	}
 
-    /**
-     * Get the value for an element
-     *
-     * @param mixed $element The element
-     *
-     * @return mixed The found value
-     *
-     * @since 1.0.0
-     */
-    public function offsetGet($element)
-    {
-        try {
-            return (bool) $this->map->find($element);
-        } catch (\OutOfBoundsException $e) {
-            return false;
-        }
-    }
+	/**
+	 * Get the value for an element
+	 *
+	 * @param mixed $element The element
+	 *
+	 * @return mixed The found value
+	 *
+	 * @since 1.0.0
+	 */
+	public function offsetGet($element)
+	{
+		try {
+			return (bool) $this->map->find($element);
+		} catch (\OutOfBoundsException $e) {
+			return false;
+		}
+	}
 
-    /**
-     * Test the existence of an element
-     *
-     * @param mixed $element The element
-     *
-     * @return boolean TRUE if the element exists, false otherwise
-     *
-     * @since 1.0.0
-     */
-    public function offsetExists($element)
-    {
-        return $this->offsetGet($element);
-    }
+	/**
+	 * Test the existence of an element
+	 *
+	 * @param mixed $element The element
+	 *
+	 * @return boolean TRUE if the element exists, false otherwise
+	 *
+	 * @since 1.0.0
+	 */
+	public function offsetExists($element)
+	{
+		return $this->offsetGet($element);
+	}
 
-    /**
-     * Set the value for an element
-     *
-     * @param mixed $element The element
-     * @param mixed $value   The value
-     *
-     * @return void
-     *
-     * @throws \RuntimeOperation The operation is not supported by this class
-     *
-     * @since 1.0.0
-     */
-    public function offsetSet($element, $value)
-    {
-        throw new \RuntimeException('Unsupported operation');
-    }
+	/**
+	 * Set the value for an element
+	 *
+	 * @param mixed $element The element
+	 * @param mixed $value   The value
+	 *
+	 * @return void
+	 *
+	 * @throws \RuntimeOperation The operation is not supported by this class
+	 *
+	 * @since 1.0.0
+	 */
+	public function offsetSet($element, $value)
+	{
+		throw new \RuntimeException('Unsupported operation');
+	}
 
-    /**
-     * Unset the existence of an element
-     *
-     * @param mixed $element The element
-     *
-     * @return void
-     *
-     * @throws \RuntimeOperation The operation is not supported by this class
-     *
-     * @since 1.0.0
-     */
-    public function offsetUnset($element)
-    {
-        throw new \RuntimeException('Unsupported operation');
-    }
+	/**
+	 * Unset the existence of an element
+	 *
+	 * @param mixed $element The element
+	 *
+	 * @return void
+	 *
+	 * @throws \RuntimeOperation The operation is not supported by this class
+	 *
+	 * @since 1.0.0
+	 */
+	public function offsetUnset($element)
+	{
+		throw new \RuntimeException('Unsupported operation');
+	}
 
-    /**
-     * Count the number of elements
-     *
-     * @return integer
-     *
-     * @since 1.0.0
-     */
-    public function count()
-    {
-        return count($this->map);
-    }
+	/**
+	 * Count the number of elements
+	 *
+	 * @return integer
+	 *
+	 * @since 1.0.0
+	 */
+	public function count()
+	{
+		return count($this->map);
+	}
 }

src/SortedCollection/TreeMap.php

Indentation +410 added lines, -410 removed lines

@@ -35,414 +35,414 @@
  */
 class TreeMap extends AbstractMap
 {
-    /**
-     * @var TreeNode  Root of the tree
-     *
-     * @since 1.0.0
-     */
-    private $root;
-
-    /**
-     * @var callable  Comparator function
-     *
-     * @param mixed $key1 First key
-     * @param mixed $key2 Second key
-     *
-     * @return integer negative if $key1 is lesser than $key2,
-     *                  0 if $key1 is equal to $key2,
-     *                  positive if $key1 is greater than $key2
-     *
-     * @since 1.0.0
-     */
-    private $comparator;
-
-    /**
-     * Constructor
-     *
-     * @param callable $comparator Comparison function
-     *
-     * @since 1.0.0
-     */
-    protected function __construct($comparator = null)
-    {
-        if ($comparator == null) {
-            $this->comparator = function ($key1, $key2) {
-                return $key1 - $key2;
-            };
-        } else {
-            $this->comparator = $comparator;
-        }
-    }
-
-    /**
-     * Create
-     *
-     * @param callable $comparator Comparison function
-     *
-     * @return TreeMap A new TreeMap
-     *
-     * @since 1.0.0
-     */
-    public static function create($comparator = null)
-    {
-        return new static($comparator);
-    }
-
-    /**
-     * Get the comparator
-     *
-     * @return callable The comparator
-     *
-     * @since 1.0.0
-     */
-    public function comparator()
-    {
-        return $this->comparator;
-    }
-
-    /**
-     * Get the first element
-     *
-     * @return mixed The first element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function first()
-    {
-        if ($this->root) {
-            return $this->root->first;
-        } else {
-            throw new \OutOfBoundsException('First element unexisting');
-        }
-    }
-
-    /**
-     * Get the last element
-     *
-     * @return mixed The last element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function last()
-    {
-        if ($this->root) {
-            return $this->root->last;
-        } else {
-            throw new \OutOfBoundsException('Last element unexisting');
-        }
-    }
-
-    /**
-     * Get the predecessor element
-     *
-     * @param TreeNode $element A tree node member of the underlying TreeMap
-     *
-     * @return mixed The predecessor element
-     *
-     * @throws \OutOfBoundsException  If there is no predecessor
-     *
-     * @since 1.0.0
-     */
-    public function predecessor($element)
-    {
-        $predecessor = $element->predecessor;
-
-        if ($predecessor) {
-            return $predecessor;
-        } else {
-            throw new \OutOfBoundsException('Predecessor element unexisting');
-        }
-    }
-
-    /**
-     * Get the successor element
-     *
-     * @param TreeNode $element A tree node member of the underlying TreeMap
-     *
-     * @return mixed The successor element
-     *
-     * @throws \OutOfBoundsException If there is no successor
-     *
-     * @since 1.0.0
-     */
-    public function successor($element)
-    {
-        $successor = $element->successor;
-
-        if ($successor) {
-            return $successor;
-        } else {
-            throw new \OutOfBoundsException('Successor element unexisting');
-        }
-    }
-
-    /**
-     * Returns the element whose key is the greatest key lesser than the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no lower element
-     *
-     * @since 1.0.0
-     */
-    public function lower($key)
-    {
-        if ($this->root) {
-            $lower = $this->root->find($key, $this->comparator, -2);
-        } else {
-            $lower = null;
-        }
-
-        if ($lower) {
-            return $lower;
-        } else {
-            throw new \OutOfBoundsException('Lower element unexisting');
-        }
-    }
-
-    /**
-     * Returns the element whose key is the greatest key lesser than or equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no floor element
-     *
-     * @since 1.0.0
-     */
-    public function floor($key)
-    {
-        if ($this->root) {
-            $floor = $this->root->find($key, $this->comparator, -1);
-        } else {
-            $floor = null;
-        }
-
-        if ($floor) {
-            return $floor;
-        } else {
-            throw new \OutOfBoundsException('Floor element unexisting');
-        }
-    }
-
-    /**
-     * Returns the element whose key is equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no such element
-     *
-     * @since 1.0.0
-     */
-    public function find($key)
-    {
-        if ($this->root) {
-            $find = $this->root->find($key, $this->comparator, 0);
-        } else {
-            $find = null;
-        }
-
-        if ($find) {
-            return $find;
-        } else {
-            throw new \OutOfBoundsException('Element unexisting');
-        }
-    }
-
-    /**
-     * Returns the element whose key is the lowest key greater than or equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no ceiling element
-     *
-     * @since 1.0.0
-     */
-    public function ceiling($key)
-    {
-        if ($this->root) {
-            $ceiling = $this->root->find($key, $this->comparator, 1);
-        } else {
-            $ceiling = null;
-        }
-
-        if ($ceiling) {
-            return $ceiling;
-        } else {
-            throw new \OutOfBoundsException('Ceiling element unexisting');
-        }
-    }
-
-    /**
-     * Returns the element whose key is the lowest key greater than to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found element
-     *
-     * @throws \OutOfBoundsException If there is no higher element
-     *
-     * @since 1.0.0
-     */
-    public function higher($key)
-    {
-        if ($this->root) {
-            $higher = $this->root->find($key, $this->comparator, 2);
-        } else {
-            $higher = null;
-        }
-
-        if ($higher) {
-            return $higher;
-        } else {
-            throw new \OutOfBoundsException('Higher element unexisting');
-        }
-    }
-
-    /**
-     * Put values in the map
-     *
-     * @param \Traversable $traversable Values to put in the map
-     *
-     * @return TreeMap $this for chaining
-     *
-     * @since 1.0.0
-     */
-    public function put($traversable = array())
-    {
-        foreach ($traversable as $key => $value) {
-            $this[$key] = $value;
-        }
-
-        return $this;
-    }
-
-    /**
-     * Clear the map
-     *
-     * @return TreeMap $this for chaining
-     *
-     * @since 1.0.0
-     */
-    public function clear()
-    {
-        $this->root = null;
-
-        return $this;
-    }
-
-    /**
-     * Initialise the map
-     *
-     * @param \Traversable $traversable Values to initialise the map
-     *
-     * @return TreeMap $this for chaining
-     *
-     * @since 1.0.0
-     */
-    public function initialise($traversable = array())
-    {
-        return $this->clear()->put($traversable);
-    }
-
-    /**
-     * Clone the map
-     *
-     * @return void
-     *
-     * @since 1.0.0
-     */
-    public function __clone()
-    {
-        if ($this->root != null) {
-            $root = $this->root;
-            $this->root = null;
-            $node = $root->first;
-
-            while ($node != null) {
-                $this[$node->key] = $node->value;
-                $node = $node->successor;
-            }
-        }
-    }
-
-    /**
-     * Serialize the object
-     *
-     * @return array Array of values
-     *
-     * @since 1.0.0
-     */
-    public function jsonSerialize()
-    {
-        $array = array();
-
-        foreach ($this as $key => $value) {
-            $array[$key] = $value;
-        }
-
-        return array('TreeMap' => $array);
-    }
-
-    /**
-     * Set the value for a key
-     *
-     * @param mixed $key   The key
-     * @param mixed $value The value
-     *
-     * @return void
-     *
-     * @since 1.0.0
-     */
-    public function offsetSet($key, $value)
-    {
-        if ($this->root) {
-            $this->root = $this->root->insert($key, $value, $this->comparator);
-        } else {
-            $this->root = TreeNode::create($key, $value);
-        }
-    }
-
-    /**
-     * Unset the existence of a key
-     *
-     * @param mixed $key The key
-     *
-     * @return void
-     *
-     * @since 1.0.0
-     */
-    public function offsetUnset($key)
-    {
-        if ($this->root) {
-            $this->root = $this->root->remove($key, $this->comparator);
-        }
-    }
-
-    /**
-     * Count the number of key/value pairs
-     *
-     * @return integer
-     *
-     * @since 1.0.0
-     */
-    public function count()
-    {
-        if ($this->root) {
-            return count($this->root);
-        } else {
-            return 0;
-        }
-    }
+	/**
+	 * @var TreeNode  Root of the tree
+	 *
+	 * @since 1.0.0
+	 */
+	private $root;
+
+	/**
+	 * @var callable  Comparator function
+	 *
+	 * @param mixed $key1 First key
+	 * @param mixed $key2 Second key
+	 *
+	 * @return integer negative if $key1 is lesser than $key2,
+	 *                  0 if $key1 is equal to $key2,
+	 *                  positive if $key1 is greater than $key2
+	 *
+	 * @since 1.0.0
+	 */
+	private $comparator;
+
+	/**
+	 * Constructor
+	 *
+	 * @param callable $comparator Comparison function
+	 *
+	 * @since 1.0.0
+	 */
+	protected function __construct($comparator = null)
+	{
+		if ($comparator == null) {
+			$this->comparator = function ($key1, $key2) {
+				return $key1 - $key2;
+			};
+		} else {
+			$this->comparator = $comparator;
+		}
+	}
+
+	/**
+	 * Create
+	 *
+	 * @param callable $comparator Comparison function
+	 *
+	 * @return TreeMap A new TreeMap
+	 *
+	 * @since 1.0.0
+	 */
+	public static function create($comparator = null)
+	{
+		return new static($comparator);
+	}
+
+	/**
+	 * Get the comparator
+	 *
+	 * @return callable The comparator
+	 *
+	 * @since 1.0.0
+	 */
+	public function comparator()
+	{
+		return $this->comparator;
+	}
+
+	/**
+	 * Get the first element
+	 *
+	 * @return mixed The first element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function first()
+	{
+		if ($this->root) {
+			return $this->root->first;
+		} else {
+			throw new \OutOfBoundsException('First element unexisting');
+		}
+	}
+
+	/**
+	 * Get the last element
+	 *
+	 * @return mixed The last element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function last()
+	{
+		if ($this->root) {
+			return $this->root->last;
+		} else {
+			throw new \OutOfBoundsException('Last element unexisting');
+		}
+	}
+
+	/**
+	 * Get the predecessor element
+	 *
+	 * @param TreeNode $element A tree node member of the underlying TreeMap
+	 *
+	 * @return mixed The predecessor element
+	 *
+	 * @throws \OutOfBoundsException  If there is no predecessor
+	 *
+	 * @since 1.0.0
+	 */
+	public function predecessor($element)
+	{
+		$predecessor = $element->predecessor;
+
+		if ($predecessor) {
+			return $predecessor;
+		} else {
+			throw new \OutOfBoundsException('Predecessor element unexisting');
+		}
+	}
+
+	/**
+	 * Get the successor element
+	 *
+	 * @param TreeNode $element A tree node member of the underlying TreeMap
+	 *
+	 * @return mixed The successor element
+	 *
+	 * @throws \OutOfBoundsException If there is no successor
+	 *
+	 * @since 1.0.0
+	 */
+	public function successor($element)
+	{
+		$successor = $element->successor;
+
+		if ($successor) {
+			return $successor;
+		} else {
+			throw new \OutOfBoundsException('Successor element unexisting');
+		}
+	}
+
+	/**
+	 * Returns the element whose key is the greatest key lesser than the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no lower element
+	 *
+	 * @since 1.0.0
+	 */
+	public function lower($key)
+	{
+		if ($this->root) {
+			$lower = $this->root->find($key, $this->comparator, -2);
+		} else {
+			$lower = null;
+		}
+
+		if ($lower) {
+			return $lower;
+		} else {
+			throw new \OutOfBoundsException('Lower element unexisting');
+		}
+	}
+
+	/**
+	 * Returns the element whose key is the greatest key lesser than or equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no floor element
+	 *
+	 * @since 1.0.0
+	 */
+	public function floor($key)
+	{
+		if ($this->root) {
+			$floor = $this->root->find($key, $this->comparator, -1);
+		} else {
+			$floor = null;
+		}
+
+		if ($floor) {
+			return $floor;
+		} else {
+			throw new \OutOfBoundsException('Floor element unexisting');
+		}
+	}
+
+	/**
+	 * Returns the element whose key is equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no such element
+	 *
+	 * @since 1.0.0
+	 */
+	public function find($key)
+	{
+		if ($this->root) {
+			$find = $this->root->find($key, $this->comparator, 0);
+		} else {
+			$find = null;
+		}
+
+		if ($find) {
+			return $find;
+		} else {
+			throw new \OutOfBoundsException('Element unexisting');
+		}
+	}
+
+	/**
+	 * Returns the element whose key is the lowest key greater than or equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no ceiling element
+	 *
+	 * @since 1.0.0
+	 */
+	public function ceiling($key)
+	{
+		if ($this->root) {
+			$ceiling = $this->root->find($key, $this->comparator, 1);
+		} else {
+			$ceiling = null;
+		}
+
+		if ($ceiling) {
+			return $ceiling;
+		} else {
+			throw new \OutOfBoundsException('Ceiling element unexisting');
+		}
+	}
+
+	/**
+	 * Returns the element whose key is the lowest key greater than to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found element
+	 *
+	 * @throws \OutOfBoundsException If there is no higher element
+	 *
+	 * @since 1.0.0
+	 */
+	public function higher($key)
+	{
+		if ($this->root) {
+			$higher = $this->root->find($key, $this->comparator, 2);
+		} else {
+			$higher = null;
+		}
+
+		if ($higher) {
+			return $higher;
+		} else {
+			throw new \OutOfBoundsException('Higher element unexisting');
+		}
+	}
+
+	/**
+	 * Put values in the map
+	 *
+	 * @param \Traversable $traversable Values to put in the map
+	 *
+	 * @return TreeMap $this for chaining
+	 *
+	 * @since 1.0.0
+	 */
+	public function put($traversable = array())
+	{
+		foreach ($traversable as $key => $value) {
+			$this[$key] = $value;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Clear the map
+	 *
+	 * @return TreeMap $this for chaining
+	 *
+	 * @since 1.0.0
+	 */
+	public function clear()
+	{
+		$this->root = null;
+
+		return $this;
+	}
+
+	/**
+	 * Initialise the map
+	 *
+	 * @param \Traversable $traversable Values to initialise the map
+	 *
+	 * @return TreeMap $this for chaining
+	 *
+	 * @since 1.0.0
+	 */
+	public function initialise($traversable = array())
+	{
+		return $this->clear()->put($traversable);
+	}
+
+	/**
+	 * Clone the map
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.0
+	 */
+	public function __clone()
+	{
+		if ($this->root != null) {
+			$root = $this->root;
+			$this->root = null;
+			$node = $root->first;
+
+			while ($node != null) {
+				$this[$node->key] = $node->value;
+				$node = $node->successor;
+			}
+		}
+	}
+
+	/**
+	 * Serialize the object
+	 *
+	 * @return array Array of values
+	 *
+	 * @since 1.0.0
+	 */
+	public function jsonSerialize()
+	{
+		$array = array();
+
+		foreach ($this as $key => $value) {
+			$array[$key] = $value;
+		}
+
+		return array('TreeMap' => $array);
+	}
+
+	/**
+	 * Set the value for a key
+	 *
+	 * @param mixed $key   The key
+	 * @param mixed $value The value
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.0
+	 */
+	public function offsetSet($key, $value)
+	{
+		if ($this->root) {
+			$this->root = $this->root->insert($key, $value, $this->comparator);
+		} else {
+			$this->root = TreeNode::create($key, $value);
+		}
+	}
+
+	/**
+	 * Unset the existence of a key
+	 *
+	 * @param mixed $key The key
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.0
+	 */
+	public function offsetUnset($key)
+	{
+		if ($this->root) {
+			$this->root = $this->root->remove($key, $this->comparator);
+		}
+	}
+
+	/**
+	 * Count the number of key/value pairs
+	 *
+	 * @return integer
+	 *
+	 * @since 1.0.0
+	 */
+	public function count()
+	{
+		if ($this->root) {
+			return count($this->root);
+		} else {
+			return 0;
+		}
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -66,7 +66,7 @@
     protected function __construct($comparator = null)
     {
         if ($comparator == null) {
-            $this->comparator = function ($key1, $key2) {
+            $this->comparator = function($key1, $key2) {
                 return $key1 - $key2;
             };
         } else {

src/SortedCollection/Iterator.php

Indentation +185 added lines, -185 removed lines

@@ -23,189 +23,189 @@
  */
 class Iterator implements \Iterator
 {
-    /**
-     * Iterate on pairs
-     *
-     * @since 1.0.0
-     */
-    private const PAIRS = 0;
-
-    /**
-     * Iterate on keys
-     *
-     * @since 1.0.0
-     */
-    private const KEYS = 1;
-
-    /**
-     * Iterate on values
-     *
-     * @since 1.0.0
-     */
-    private const VALUES = 2;
-
-    /**
-     * @var integer  Type: self::PAIRS, self::KEYS or self::VALUES
-     *
-     * @since 1.0.0
-     */
-    private $type;
-
-    /**
-     * @var integer  Index
-     *
-     * @since 1.0.0
-     */
-    private $index;
-
-    /**
-     * @var SortedMap  Map
-     *
-     * @since 1.0.0
-     */
-    private $map;
-
-    /**
-     * Constructor
-     *
-     * @param SortedMap $map  Sorted map
-     * @param integer   $type Iterator type
-     *
-     * @since 1.0.0
-     */
-    protected function __construct(SortedMap $map, $type)
-    {
-        $this->map = $map;
-        $this->type = $type;
-        $this->rewind();
-    }
-
-    /**
-     * Create a new iterator on pairs
-     *
-     * @param SortedMap $map Sorted map
-     *
-     * @return Iterator A new iterator on pairs
-     *
-     * @since 1.0.0
-     */
-    public static function create(SortedMap $map)
-    {
-        return new static($map, self::PAIRS);
-    }
-
-    /**
-     * Create a new iterator on keys
-     *
-     * @param SortedMap $map Sorted map
-     *
-     * @return Iterator A new iterator on keys
-     *
-     * @since 1.0.0
-     */
-    public static function keys(SortedMap $map)
-    {
-        return new static($map, self::KEYS);
-    }
-
-    /**
-     * Create a new iterator on values
-     *
-     * @param SortedMap $map Sorted map
-     *
-     * @return Iterator A new iterator on values
-     *
-     * @since 1.0.0
-     */
-    public static function values(SortedMap $map)
-    {
-        return new static($map, self::VALUES);
-    }
-
-    /**
-     * @var TreeNode  The current node
-     *
-     * @since 1.0.0
-     */
-    protected $current;
-
-    /**
-     * Rewind the Iterator to the first element
-     *
-     * @return void
-     *
-     * @since 1.0.0
-     */
-    public function rewind()
-    {
-        $this->index = 0;
-
-        try {
-            $this->current = $this->map->first();
-        } catch (\OutOfBoundsException $e) {
-            $this->current = null;
-        }
-    }
-
-    /**
-     * Return the current key
-     *
-     * @return mixed The current key
-     *
-     * @since 1.0.0
-     */
-    public function key()
-    {
-        if ($this->type == self::PAIRS) {
-            return $this->current->key;
-        } else {
-            return $this->index;
-        }
-    }
-
-    /**
-     * Return the current value
-     *
-     * @return mixed The current value
-     *
-     * @since 1.0.0
-     */
-    public function current()
-    {
-        if ($this->type == self::KEYS) {
-            return $this->current->key;
-        } else {
-            return $this->current->value;
-        }
-    }
-
-    /**
-     * Move forward to the next element
-     *
-     * @return void
-     *
-     * @since 1.0.0
-     */
-    public function next()
-    {
-        try {
-            $this->current = $this->map->successor($this->current);
-        } catch (\OutOfBoundsException $e) {
-            $this->current = null;
-        }
-
-        $this->index++;
-    }
-
-    /**
-     * Checks if current position is valid
-     *
-     * @return boolean
-     *
-     * @since 1.0.0
-     */
-    public function valid()
-    {
-        return (bool) $this->current;
-    }
+	/**
+	 * Iterate on pairs
+	 *
+	 * @since 1.0.0
+	 */
+	private const PAIRS = 0;
+
+	/**
+	 * Iterate on keys
+	 *
+	 * @since 1.0.0
+	 */
+	private const KEYS = 1;
+
+	/**
+	 * Iterate on values
+	 *
+	 * @since 1.0.0
+	 */
+	private const VALUES = 2;
+
+	/**
+	 * @var integer  Type: self::PAIRS, self::KEYS or self::VALUES
+	 *
+	 * @since 1.0.0
+	 */
+	private $type;
+
+	/**
+	 * @var integer  Index
+	 *
+	 * @since 1.0.0
+	 */
+	private $index;
+
+	/**
+	 * @var SortedMap  Map
+	 *
+	 * @since 1.0.0
+	 */
+	private $map;
+
+	/**
+	 * Constructor
+	 *
+	 * @param SortedMap $map  Sorted map
+	 * @param integer   $type Iterator type
+	 *
+	 * @since 1.0.0
+	 */
+	protected function __construct(SortedMap $map, $type)
+	{
+		$this->map = $map;
+		$this->type = $type;
+		$this->rewind();
+	}
+
+	/**
+	 * Create a new iterator on pairs
+	 *
+	 * @param SortedMap $map Sorted map
+	 *
+	 * @return Iterator A new iterator on pairs
+	 *
+	 * @since 1.0.0
+	 */
+	public static function create(SortedMap $map)
+	{
+		return new static($map, self::PAIRS);
+	}
+
+	/**
+	 * Create a new iterator on keys
+	 *
+	 * @param SortedMap $map Sorted map
+	 *
+	 * @return Iterator A new iterator on keys
+	 *
+	 * @since 1.0.0
+	 */
+	public static function keys(SortedMap $map)
+	{
+		return new static($map, self::KEYS);
+	}
+
+	/**
+	 * Create a new iterator on values
+	 *
+	 * @param SortedMap $map Sorted map
+	 *
+	 * @return Iterator A new iterator on values
+	 *
+	 * @since 1.0.0
+	 */
+	public static function values(SortedMap $map)
+	{
+		return new static($map, self::VALUES);
+	}
+
+	/**
+	 * @var TreeNode  The current node
+	 *
+	 * @since 1.0.0
+	 */
+	protected $current;
+
+	/**
+	 * Rewind the Iterator to the first element
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.0
+	 */
+	public function rewind()
+	{
+		$this->index = 0;
+
+		try {
+			$this->current = $this->map->first();
+		} catch (\OutOfBoundsException $e) {
+			$this->current = null;
+		}
+	}
+
+	/**
+	 * Return the current key
+	 *
+	 * @return mixed The current key
+	 *
+	 * @since 1.0.0
+	 */
+	public function key()
+	{
+		if ($this->type == self::PAIRS) {
+			return $this->current->key;
+		} else {
+			return $this->index;
+		}
+	}
+
+	/**
+	 * Return the current value
+	 *
+	 * @return mixed The current value
+	 *
+	 * @since 1.0.0
+	 */
+	public function current()
+	{
+		if ($this->type == self::KEYS) {
+			return $this->current->key;
+		} else {
+			return $this->current->value;
+		}
+	}
+
+	/**
+	 * Move forward to the next element
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.0
+	 */
+	public function next()
+	{
+		try {
+			$this->current = $this->map->successor($this->current);
+		} catch (\OutOfBoundsException $e) {
+			$this->current = null;
+		}
+
+		$this->index++;
+	}
+
+	/**
+	 * Checks if current position is valid
+	 *
+	 * @return boolean
+	 *
+	 * @since 1.0.0
+	 */
+	public function valid()
+	{
+		return (bool) $this->current;
+	}
 }

src/SortedCollection/SortedCollection.php

Indentation +88 added lines, -88 removed lines

@@ -31,99 +31,99 @@
  */
 interface SortedCollection extends \ArrayAccess, \Countable, \IteratorAggregate, \JsonSerializable
 {
-    /**
-     * Get the comparator
-     *
-     * @return callable The comparator
-     *
-     * @since 1.0.0
-     */
-    public function comparator();
+	/**
+	 * Get the comparator
+	 *
+	 * @return callable The comparator
+	 *
+	 * @since 1.0.0
+	 */
+	public function comparator();
 
-    /**
-     * Get the first element
-     *
-     * @return mixed The first element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function first();
+	/**
+	 * Get the first element
+	 *
+	 * @return mixed The first element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function first();
 
-    /**
-     * Get the last element
-     *
-     * @return mixed The last element
-     *
-     * @throws \OutOfBoundsException If there is no element
-     *
-     * @since 1.0.0
-     */
-    public function last();
+	/**
+	 * Get the last element
+	 *
+	 * @return mixed The last element
+	 *
+	 * @throws \OutOfBoundsException If there is no element
+	 *
+	 * @since 1.0.0
+	 */
+	public function last();
 
-    /**
-     * Returns the greatest element lesser than the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found node
-     *
-     * @throws \OutOfBoundsException If there is no lower element
-     *
-     * @since 1.0.0
-     */
-    public function lower($key);
+	/**
+	 * Returns the greatest element lesser than the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found node
+	 *
+	 * @throws \OutOfBoundsException If there is no lower element
+	 *
+	 * @since 1.0.0
+	 */
+	public function lower($key);
 
-    /**
-     * Returns the greatest element lesser than or equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found node
-     *
-     * @throws \OutOfBoundsException If there is no floor element
-     *
-     * @since 1.0.0
-     */
-    public function floor($key);
+	/**
+	 * Returns the greatest element lesser than or equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found node
+	 *
+	 * @throws \OutOfBoundsException If there is no floor element
+	 *
+	 * @since 1.0.0
+	 */
+	public function floor($key);
 
-    /**
-     * Returns the element equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found node
-     *
-     * @throws \OutOfBoundsException If there is no such element
-     *
-     * @since 1.0.0
-     */
-    public function find($key);
+	/**
+	 * Returns the element equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found node
+	 *
+	 * @throws \OutOfBoundsException If there is no such element
+	 *
+	 * @since 1.0.0
+	 */
+	public function find($key);
 
-    /**
-     * Returns the lowest element greater than or equal to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found node
-     *
-     * @throws \OutOfBoundsException If there is no ceiling element
-     *
-     * @since 1.0.0
-     */
-    public function ceiling($key);
+	/**
+	 * Returns the lowest element greater than or equal to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found node
+	 *
+	 * @throws \OutOfBoundsException If there is no ceiling element
+	 *
+	 * @since 1.0.0
+	 */
+	public function ceiling($key);
 
-    /**
-     * Returns the lowest element greater than to the given key
-     *
-     * @param mixed $key The searched key
-     *
-     * @return mixed The found node
-     *
-     * @throws \OutOfBoundsException If there is no higher element
-     *
-     * @since 1.0.0
-     */
-    public function higher($key);
+	/**
+	 * Returns the lowest element greater than to the given key
+	 *
+	 * @param mixed $key The searched key
+	 *
+	 * @return mixed The found node
+	 *
+	 * @throws \OutOfBoundsException If there is no higher element
+	 *
+	 * @since 1.0.0
+	 */
+	public function higher($key);
 }

src/SortedCollection/ReversedSet.php

Indentation +59 added lines, -59 removed lines

@@ -30,67 +30,67 @@
  */
 class ReversedSet extends AbstractSet
 {
-    /**
-     * @var SortedSet  Internal set
-     *
-     * @since 1.0.0
-     */
-    private $set;
+	/**
+	 * @var SortedSet  Internal set
+	 *
+	 * @since 1.0.0
+	 */
+	private $set;
 
-    /**
-     * Constructor
-     *
-     * @param SortedSet $set Internal set
-     *
-     * @since 1.0.0
-     */
-    protected function __construct(SortedSet $set)
-    {
-        $this->setMap(ReversedMap::create($set->getMap()))->set = $set;
-    }
+	/**
+	 * Constructor
+	 *
+	 * @param SortedSet $set Internal set
+	 *
+	 * @since 1.0.0
+	 */
+	protected function __construct(SortedSet $set)
+	{
+		$this->setMap(ReversedMap::create($set->getMap()))->set = $set;
+	}
 
-    /**
-     * Create
-     *
-     * @param SortedSet $set Internal set
-     *
-     * @return ReversedSet A new reversed set
-     *
-     * @since 1.0.0
-     */
-    public static function create(SortedSet $set)
-    {
-        return new static($set);
-    }
+	/**
+	 * Create
+	 *
+	 * @param SortedSet $set Internal set
+	 *
+	 * @return ReversedSet A new reversed set
+	 *
+	 * @since 1.0.0
+	 */
+	public static function create(SortedSet $set)
+	{
+		return new static($set);
+	}
 
-    /**
-     * Magic get method
-     *
-     * @param string $property The property
-     *
-     * @return mixed The value associated to the property
-     *
-     * @since 1.0.0
-     */
-    public function __get($property)
-    {
-        switch ($property) {
-            case 'set':
-                return $this->set;
-            default:
-                return parent::__get($property);
-        }
-    }
+	/**
+	 * Magic get method
+	 *
+	 * @param string $property The property
+	 *
+	 * @return mixed The value associated to the property
+	 *
+	 * @since 1.0.0
+	 */
+	public function __get($property)
+	{
+		switch ($property) {
+			case 'set':
+				return $this->set;
+			default:
+				return parent::__get($property);
+		}
+	}
 
-    /**
-     * Serialize the object
-     *
-     * @return array Array of values
-     *
-     * @since 1.0.0
-     */
-    public function jsonSerialize()
-    {
-        return array('ReversedSet' => $this->set->jsonSerialize());
-    }
+	/**
+	 * Serialize the object
+	 *
+	 * @return array Array of values
+	 *
+	 * @since 1.0.0
+	 */
+	public function jsonSerialize()
+	{
+		return array('ReversedSet' => $this->set->jsonSerialize());
+	}
 }

benchmarks/TreeMapBench.php

Indentation +169 added lines, -169 removed lines

@@ -25,184 +25,184 @@
  */
 class TreeMapBench
 {
-    /**
-     * @var TreeMap The tree map
-     *
-     * @since 1.0.5
-     */
-    protected $tree;
+	/**
+	 * @var TreeMap The tree map
+	 *
+	 * @since 1.0.5
+	 */
+	protected $tree;
 
-    /**
-     * @var SortedMap The sorted map
-     *
-     * @since 1.0.5
-     */
-    protected $data;
+	/**
+	 * @var SortedMap The sorted map
+	 *
+	 * @since 1.0.5
+	 */
+	protected $data;
 
-    /**
-     * Provider for counts
-     *
-     * @return iterator Iterator on count
-     *
-     * @since 1.0.5
-     */
-    public function provideCounts()
-    {
-        yield array('count' => 100);
-        yield array('count' => 1000);
-        yield array('count' => 10000);
-        yield array('count' => 100000);
-    }
+	/**
+	 * Provider for counts
+	 *
+	 * @return iterator Iterator on count
+	 *
+	 * @since 1.0.5
+	 */
+	public function provideCounts()
+	{
+		yield array('count' => 100);
+		yield array('count' => 1000);
+		yield array('count' => 10000);
+		yield array('count' => 100000);
+	}
 
-    /**
-     * Provider for counts
-     *
-     * @return iterator Iterator on type
-     *
-     * @since 1.0.5
-     */
-    public function provideTypes()
-    {
-        yield array('type' => 'tree');
-        yield array('type' => 'reversed');
-        yield array('type' => 'sub', 'from' => 0.30, 'to' => 0.70);
-        yield array('type' => 'sub', 'from' => 0.40, 'to' => 0.80);
-    }
+	/**
+	 * Provider for counts
+	 *
+	 * @return iterator Iterator on type
+	 *
+	 * @since 1.0.5
+	 */
+	public function provideTypes()
+	{
+		yield array('type' => 'tree');
+		yield array('type' => 'reversed');
+		yield array('type' => 'sub', 'from' => 0.30, 'to' => 0.70);
+		yield array('type' => 'sub', 'from' => 0.40, 'to' => 0.80);
+	}
 
-    /**
-     * Create the tree map.
-     *
-     * @param array $params Array of parameters
-     *
-     * @return void
-     *
-     * @since 1.0.5
-     */
-    public function init($params)
-    {
-        $this->tree = TreeMap::create();
-    }
+	/**
+	 * Create the tree map.
+	 *
+	 * @param array $params Array of parameters
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.5
+	 */
+	public function init($params)
+	{
+		$this->tree = TreeMap::create();
+	}
 
-    /**
-     * Create the sorted map.
-     *
-     * @param array $params Array of parameters
-     *
-     * @return void
-     *
-     * @since 1.0.5
-     */
-    public function data($params)
-    {
-        if (isset($params['type'])) {
-            switch ($params['type']) {
-                case 'tree':
-                    $this->data = $this->tree;
-                    break;
-                case 'reversed':
-                    $this->data = ReversedMap::create($this->tree);
-                    break;
-                case 'sub':
-                    if (isset($params['from']) && isset($params['to'])) {
-                        $this->data = SubMap::create(
-                            $this->tree,
-                            (int) ($params['from'] * $params['count']),
-                            (int) ($params['to'] * $params['count'])
-                        );
-                    } else {
-                        $this->data = SubMap::create(
-                            $this->tree,
-                            null,
-                            null
-                        );
-                    }
-                    break;
-            }
-        } else {
-            $this->data = $this->tree;
-        }
-    }
+	/**
+	 * Create the sorted map.
+	 *
+	 * @param array $params Array of parameters
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.5
+	 */
+	public function data($params)
+	{
+		if (isset($params['type'])) {
+			switch ($params['type']) {
+				case 'tree':
+					$this->data = $this->tree;
+					break;
+				case 'reversed':
+					$this->data = ReversedMap::create($this->tree);
+					break;
+				case 'sub':
+					if (isset($params['from']) && isset($params['to'])) {
+						$this->data = SubMap::create(
+							$this->tree,
+							(int) ($params['from'] * $params['count']),
+							(int) ($params['to'] * $params['count'])
+						);
+					} else {
+						$this->data = SubMap::create(
+							$this->tree,
+							null,
+							null
+						);
+					}
+					break;
+			}
+		} else {
+			$this->data = $this->tree;
+		}
+	}
 
-    /**
-     * Clear the tree map.
-     *
-     * @param array $params Array of parameters
-     *
-     * @return void
-     *
-     * @since 1.0.5
-     */
-    public function finish($params)
-    {
-        $this->tree->clear();
-    }
+	/**
+	 * Clear the tree map.
+	 *
+	 * @param array $params Array of parameters
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.5
+	 */
+	public function finish($params)
+	{
+		$this->tree->clear();
+	}
 
-    /**
-     * @BeforeMethods({"init", "data"})
-     * @AfterMethods({"finish"})
-     * @Revs(5)
-     * @ParamProviders({"provideCounts"})
-     *
-     * @param array $params Array of parameters
-     *
-     * @return void
-     *
-     * @since 1.0.5
-     */
-    public function benchFill($params)
-    {
-        for ($i = 0; $i < $params['count']; $i++) {
-            $this->tree[$i] = $i;
-        }
-    }
+	/**
+	 * @BeforeMethods({"init", "data"})
+	 * @AfterMethods({"finish"})
+	 * @Revs(5)
+	 * @ParamProviders({"provideCounts"})
+	 *
+	 * @param array $params Array of parameters
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.5
+	 */
+	public function benchFill($params)
+	{
+		for ($i = 0; $i < $params['count']; $i++) {
+			$this->tree[$i] = $i;
+		}
+	}
 
-    /**
-     * @BeforeMethods({"init", "benchFill", "data"})
-     * @AfterMethods({"finish"})
-     * @Revs(5)
-     * @ParamProviders({"provideCounts", "provideTypes"})
-     *
-     * @param array $params Array of parameters
-     *
-     * @return void
-     *
-     * @since 1.0.5
-     */
-    public function benchSearch($params)
-    {
-        if (isset($params['from'])) {
-            $min = (int) ($params['from'] * $params['count']);
-        } else {
-            $min = 0;
-        }
+	/**
+	 * @BeforeMethods({"init", "benchFill", "data"})
+	 * @AfterMethods({"finish"})
+	 * @Revs(5)
+	 * @ParamProviders({"provideCounts", "provideTypes"})
+	 *
+	 * @param array $params Array of parameters
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.5
+	 */
+	public function benchSearch($params)
+	{
+		if (isset($params['from'])) {
+			$min = (int) ($params['from'] * $params['count']);
+		} else {
+			$min = 0;
+		}
 
-        if (isset($params['to'])) {
-            $max = (int) ($params['to'] * $params['count']);
-        } else {
-            $max = $params['count'];
-        }
+		if (isset($params['to'])) {
+			$max = (int) ($params['to'] * $params['count']);
+		} else {
+			$max = $params['count'];
+		}
 
-        for ($i = $min; $i < $max; $i++) {
-            $value = $this->data[$i];
-        }
-    }
+		for ($i = $min; $i < $max; $i++) {
+			$value = $this->data[$i];
+		}
+	}
 
-    /**
-     * @BeforeMethods({"init", "benchFill", "data"})
-     * @AfterMethods({"finish"})
-     * @Revs(5)
-     * @ParamProviders({"provideCounts"})
-     *
-     * @param array $params Array of parameters
-     *
-     * @return void
-     *
-     * @since 1.0.5
-     */
-    public function benchClean($params)
-    {
-        for ($i = 0; $i < $params['count']; $i++) {
-            unset($this->tree[$i]);
-        }
-    }
+	/**
+	 * @BeforeMethods({"init", "benchFill", "data"})
+	 * @AfterMethods({"finish"})
+	 * @Revs(5)
+	 * @ParamProviders({"provideCounts"})
+	 *
+	 * @param array $params Array of parameters
+	 *
+	 * @return void
+	 *
+	 * @since 1.0.5
+	 */
+	public function benchClean($params)
+	{
+		for ($i = 0; $i < $params['count']; $i++) {
+			unset($this->tree[$i]);
+		}
+	}
 }

examples/TreeSet.php

Indentation +1 added lines, -1 removed lines

@@ -49,7 +49,7 @@
 
 // Print 0-0;1-1;2-2;3-3;4-4;5-7;6-8;7-9;
 foreach ($set as $key => $value) {
-    echo $key . '-' . $value . ';';
+	echo $key . '-' . $value . ';';
 }
 
 echo PHP_EOL;

Spacing +9 added lines, -9 removed lines

@@ -14,42 +14,42 @@
  * This file is part of the php-sorted-collections package https://github.com/chdemko/php-sorted-collections
  */
 
-require __DIR__ . '/../vendor/autoload.php';
+require __DIR__.'/../vendor/autoload.php';
 
 use chdemko\SortedCollection\TreeSet;
 
 $set = TreeSet::create()->put(array(1, 9, 5, 2, 6, 3, 0, 8, 7, 4));
 
 // Print [0,1,2,3,4,5,6,7,8,9]
-echo $set . PHP_EOL;
+echo $set.PHP_EOL;
 
 // Print 0
-echo $set->first . PHP_EOL;
+echo $set->first.PHP_EOL;
 
 // Print 9
-echo $set->last . PHP_EOL;
+echo $set->last.PHP_EOL;
 
 // Print 10
-echo count($set) . PHP_EOL;
+echo count($set).PHP_EOL;
 
 // Print 1
-echo $set[5] . PHP_EOL;
+echo $set[5].PHP_EOL;
 
 // Change value for $set[5]
 $set[5] = false;
 
 // Print [0,1,2,3,4,6,7,8,9]
-echo $set . PHP_EOL;
+echo $set.PHP_EOL;
 
 // Unset $set[6]
 unset($set[6]);
 
 // Print [0,1,2,3,4,7,8,9]
-echo $set . PHP_EOL;
+echo $set.PHP_EOL;
 
 // Print 0-0;1-1;2-2;3-3;4-4;5-7;6-8;7-9;
 foreach ($set as $key => $value) {
-    echo $key . '-' . $value . ';';
+    echo $key.'-'.$value.';';
 }
 
 echo PHP_EOL;

examples/TreeMap.php

Indentation +1 added lines, -1 removed lines

@@ -49,7 +49,7 @@
 
 // Print 0-0;1-1;2-2;3-3;4-4;6-6;7-7;8-8;9-9;
 foreach ($tree as $key => $value) {
-    echo $key . '-' . $value . ';';
+	echo $key . '-' . $value . ';';
 }
 
 echo PHP_EOL;

Spacing +9 added lines, -9 removed lines

@@ -14,42 +14,42 @@
  * This file is part of the php-sorted-collections package https://github.com/chdemko/php-sorted-collections
  */
 
-require __DIR__ . '/../vendor/autoload.php';
+require __DIR__.'/../vendor/autoload.php';
 
 use chdemko\SortedCollection\TreeMap;
 
 $tree = TreeMap::create()->put(array(1 => 1, 9 => 9, 5 => 5, 2 => 2, 6 => 6, 3 => 3, 0 => 0, 8 => 8, 7 => 7, 4 => 4));
 
 // Print [0,1,2,3,4,5,6,7,8,9]
-echo $tree . PHP_EOL;
+echo $tree.PHP_EOL;
 
 // Print 0
-echo $tree->firstKey . PHP_EOL;
+echo $tree->firstKey.PHP_EOL;
 
 // Print 9
-echo $tree->lastValue . PHP_EOL;
+echo $tree->lastValue.PHP_EOL;
 
 // Print 10
-echo count($tree) . PHP_EOL;
+echo count($tree).PHP_EOL;
 
 // Print 5
-echo $tree[5] . PHP_EOL;
+echo $tree[5].PHP_EOL;
 
 // Change value for $tree[5]
 $tree[5] = 10;
 
 // Print [0,1,2,3,4,10,6,7,8,9]
-echo $tree . PHP_EOL;
+echo $tree.PHP_EOL;
 
 // Unset $tree[5]
 unset($tree[5]);
 
 // Print {"0":0,"1":1,"2":2,"3":3,"4":4,"6":6,"7":7,"8":8,"9":9}
-echo $tree . PHP_EOL;
+echo $tree.PHP_EOL;
 
 // Print 0-0;1-1;2-2;3-3;4-4;6-6;7-7;8-8;9-9;
 foreach ($tree as $key => $value) {
-    echo $key . '-' . $value . ';';
+    echo $key.'-'.$value.';';
 }
 
 echo PHP_EOL;