Data Structures

はじめに
インストール/設定
- 要件
- インストール手順
定義済み定数
例
Ds\Collection — The Collection interface
- Ds\Collection::clear — Removes all values
- Ds\Collection::copy — Returns a shallow copy of the collection
- Ds\Collection::isEmpty — Returns whether the collection is empty
- Ds\Collection::toArray — Converts the collection to an array
Ds\Hashable — The Hashable interface
- Ds\Hashable::equals — Determines whether an object is equal to the current instance
- Ds\Hashable::hash — Returns a scalar value to be used as a hash value
Ds\Sequence — The Sequence interface
- Ds\Sequence::allocate — Allocates enough memory for a required capacity
- Ds\Sequence::apply — Updates all values by applying a callback function to each value
- Ds\Sequence::capacity — Returns the current capacity
- Ds\Sequence::contains — Determines if the sequence contains given values
- Ds\Sequence::filter — Creates a new sequence using a callable to determine which values to include
- Ds\Sequence::find — Attempts to find a value's index
- Ds\Sequence::first — Returns the first value in the sequence
- Ds\Sequence::get — Returns the value at a given index
- Ds\Sequence::insert — Inserts values at a given index
- Ds\Sequence::join — Joins all values together as a string
- Ds\Sequence::last — Returns the last value
- Ds\Sequence::map — Returns the result of applying a callback to each value
- Ds\Sequence::merge — Returns the result of adding all given values to the sequence
- Ds\Sequence::pop — Removes and returns the last value
- Ds\Sequence::push — Adds values to the end of the sequence
- Ds\Sequence::reduce — Reduces the sequence to a single value using a callback function
- Ds\Sequence::remove — Removes and returns a value by index
- Ds\Sequence::reverse — Reverses the sequence in-place
- Ds\Sequence::reversed — Returns a reversed copy
- Ds\Sequence::rotate — Rotates the sequence by a given number of rotations
- Ds\Sequence::set — Updates a value at a given index
- Ds\Sequence::shift — Removes and returns the first value
- Ds\Sequence::slice — Returns a sub-sequence of a given range
- Ds\Sequence::sort — Sorts the sequence in-place
- Ds\Sequence::sorted — Returns a sorted copy
- Ds\Sequence::sum — Returns the sum of all values in the sequence
- Ds\Sequence::unshift — Adds values to the front of the sequence
Ds\Vector — The Vector class
- Ds\Vector::allocate — Allocates enough memory for a required capacity
- Ds\Vector::apply — Updates all values by applying a callback function to each value
- Ds\Vector::capacity — Returns the current capacity
- Ds\Vector::clear — Removes all values
- Ds\Vector::__construct — Creates a new instance
- Ds\Vector::contains — Determines if the vector contains given values
- Ds\Vector::copy — Returns a shallow copy of the vector
- Ds\Vector::count — Returns the number of values in the collection
- Ds\Vector::filter — Creates a new vector using a callable to determine which values to include
- Ds\Vector::find — Attempts to find a value's index
- Ds\Vector::first — Returns the first value in the vector
- Ds\Vector::get — Returns the value at a given index
- Ds\Vector::insert — Inserts values at a given index
- Ds\Vector::isEmpty — Returns whether the vector is empty
- Ds\Vector::join — Joins all values together as a string
- Ds\Vector::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\Vector::last — Returns the last value
- Ds\Vector::map — Returns the result of applying a callback to each value
- Ds\Vector::merge — Returns the result of adding all given values to the vector
- Ds\Vector::pop — Removes and returns the last value
- Ds\Vector::push — Adds values to the end of the vector
- Ds\Vector::reduce — Reduces the vector to a single value using a callback function
- Ds\Vector::remove — Removes and returns a value by index
- Ds\Vector::reverse — Reverses the vector in-place
- Ds\Vector::reversed — Returns a reversed copy
- Ds\Vector::rotate — Rotates the vector by a given number of rotations
- Ds\Vector::set — Updates a value at a given index
- Ds\Vector::shift — Removes and returns the first value
- Ds\Vector::slice — Returns a sub-vector of a given range
- Ds\Vector::sort — Sorts the vector in-place
- Ds\Vector::sorted — Returns a sorted copy
- Ds\Vector::sum — Returns the sum of all values in the vector
- Ds\Vector::toArray — Converts the vector to an array
- Ds\Vector::unshift — Adds values to the front of the vector
Ds\Deque — The Deque class
- Ds\Deque::allocate — Allocates enough memory for a required capacity
- Ds\Deque::apply — Updates all values by applying a callback function to each value
- Ds\Deque::capacity — Returns the current capacity
- Ds\Deque::clear — Removes all values from the deque
- Ds\Deque::__construct — Creates a new instance
- Ds\Deque::contains — Determines if the deque contains given values
- Ds\Deque::copy — Returns a shallow copy of the deque
- Ds\Deque::count — Returns the number of values in the collection
- Ds\Deque::filter — Creates a new deque using a callable to determine which values to include
- Ds\Deque::find — Attempts to find a value's index
- Ds\Deque::first — Returns the first value in the deque
- Ds\Deque::get — Returns the value at a given index
- Ds\Deque::insert — Inserts values at a given index
- Ds\Deque::isEmpty — Returns whether the deque is empty
- Ds\Deque::join — Joins all values together as a string
- Ds\Deque::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\Deque::last — Returns the last value
- Ds\Deque::map — Returns the result of applying a callback to each value
- Ds\Deque::merge — Returns the result of adding all given values to the deque
- Ds\Deque::pop — Removes and returns the last value
- Ds\Deque::push — Adds values to the end of the deque
- Ds\Deque::reduce — Reduces the deque to a single value using a callback function
- Ds\Deque::remove — Removes and returns a value by index
- Ds\Deque::reverse — Reverses the deque in-place
- Ds\Deque::reversed — Returns a reversed copy
- Ds\Deque::rotate — Rotates the deque by a given number of rotations
- Ds\Deque::set — Updates a value at a given index
- Ds\Deque::shift — Removes and returns the first value
- Ds\Deque::slice — Returns a sub-deque of a given range
- Ds\Deque::sort — Sorts the deque in-place
- Ds\Deque::sorted — Returns a sorted copy
- Ds\Deque::sum — Returns the sum of all values in the deque
- Ds\Deque::toArray — Converts the deque to an array
- Ds\Deque::unshift — Adds values to the front of the deque
Ds\Map — The Map class
- Ds\Map::allocate — Allocates enough memory for a required capacity
- Ds\Map::apply — Updates all values by applying a callback function to each value
- Ds\Map::capacity — Returns the current capacity
- Ds\Map::clear — Removes all values
- Ds\Map::__construct — Creates a new instance
- Ds\Map::copy — Returns a shallow copy of the map
- Ds\Map::count — Returns the number of values in the map
- Ds\Map::diff — Creates a new map using keys that aren't in another map
- Ds\Map::filter — Creates a new map using a callable to determine which pairs to include
- Ds\Map::first — Returns the first pair in the map
- Ds\Map::get — Returns the value for a given key
- Ds\Map::hasKey — Determines whether the map contains a given key
- Ds\Map::hasValue — Determines whether the map contains a given value
- Ds\Map::intersect — Creates a new map by intersecting keys with another map
- Ds\Map::isEmpty — Returns whether the map is empty
- Ds\Map::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\Map::keys — Returns a set of the map's keys
- Ds\Map::ksort — Sorts the map in-place by key
- Ds\Map::ksorted — Returns a copy, sorted by key
- Ds\Map::last — Returns the last pair of the map
- Ds\Map::map — Returns the result of applying a callback to each value
- Ds\Map::merge — Returns the result of adding all given associations
- Ds\Map::pairs — Returns a sequence containing all the pairs of the map
- Ds\Map::put — Associates a key with a value
- Ds\Map::putAll — Associates all key-value pairs of a traversable object or array
- Ds\Map::reduce — Reduces the map to a single value using a callback function
- Ds\Map::remove — Removes and returns a value by key
- Ds\Map::reverse — Reverses the map in-place
- Ds\Map::reversed — Returns a reversed copy
- Ds\Map::skip — Returns the pair at a given positional index
- Ds\Map::slice — Returns a subset of the map defined by a starting index and length
- Ds\Map::sort — Sorts the map in-place by value
- Ds\Map::sorted — Returns a copy, sorted by value
- Ds\Map::sum — Returns the sum of all values in the map
- Ds\Map::toArray — Converts the map to an array
- Ds\Map::union — Creates a new map using values from the current instance and another map
- Ds\Map::values — Returns a sequence of the map's values
- Ds\Map::xor — Creates a new map using keys of either the current instance or of another map, but not of both
Ds\Pair — The Pair class
- Ds\Pair::clear — Removes all values
- Ds\Pair::__construct — Creates a new instance
- Ds\Pair::copy — Returns a shallow copy of the pair
- Ds\Pair::isEmpty — Returns whether the pair is empty
- Ds\Pair::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\Pair::toArray — Converts the pair to an array
Ds\Set — The Set class
- Ds\Set::add — Adds values to the set
- Ds\Set::allocate — Allocates enough memory for a required capacity
- Ds\Set::capacity — Returns the current capacity
- Ds\Set::clear — Removes all values
- Ds\Set::__construct — Creates a new instance
- Ds\Set::contains — Determines if the set contains all values
- Ds\Set::copy — Returns a shallow copy of the set
- Ds\Set::count — Returns the number of values in the set
- Ds\Set::diff — Creates a new set using values that aren't in another set
- Ds\Set::filter — Creates a new set using a callable to determine which values to include
- Ds\Set::first — Returns the first value in the set
- Ds\Set::get — Returns the value at a given index
- Ds\Set::intersect — Creates a new set by intersecting values with another set
- Ds\Set::isEmpty — Returns whether the set is empty
- Ds\Set::join — Joins all values together as a string
- Ds\Set::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\Set::last — Returns the last value in the set
- Ds\Set::merge — Returns the result of adding all given values to the set
- Ds\Set::reduce — Reduces the set to a single value using a callback function
- Ds\Set::remove — Removes all given values from the set
- Ds\Set::reverse — Reverses the set in-place
- Ds\Set::reversed — Returns a reversed copy
- Ds\Set::slice — Returns a sub-set of a given range
- Ds\Set::sort — Sorts the set in-place
- Ds\Set::sorted — Returns a sorted copy
- Ds\Set::sum — Returns the sum of all values in the set
- Ds\Set::toArray — Converts the set to an array
- Ds\Set::union — Creates a new set using values from the current instance and another set
- Ds\Set::xor — Creates a new set using values in either the current instance or in another set, but not in both
Ds\Stack — The Stack class
- Ds\Stack::allocate — Allocates enough memory for a required capacity
- Ds\Stack::capacity — Returns the current capacity
- Ds\Stack::clear — Removes all values
- Ds\Stack::__construct — Creates a new instance
- Ds\Stack::copy — Returns a shallow copy of the stack
- Ds\Stack::count — Returns the number of values in the stack
- Ds\Stack::isEmpty — Returns whether the stack is empty
- Ds\Stack::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\Stack::peek — Returns the value at the top of the stack
- Ds\Stack::pop — Removes and returns the value at the top of the stack
- Ds\Stack::push — Pushes values onto the stack
- Ds\Stack::toArray — Converts the stack to an array
Ds\Queue — The Queue class
- Ds\Queue::allocate — Allocates enough memory for a required capacity
- Ds\Queue::capacity — Returns the current capacity
- Ds\Queue::clear — Removes all values
- Ds\Queue::__construct — Creates a new instance
- Ds\Queue::copy — Returns a shallow copy of the queue
- Ds\Queue::count — Returns the number of values in the queue
- Ds\Queue::isEmpty — Returns whether the queue is empty
- Ds\Queue::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\Queue::peek — Returns the value at the front of the queue
- Ds\Queue::pop — Removes and returns the value at the front of the queue
- Ds\Queue::push — Pushes values into the queue
- Ds\Queue::toArray — Converts the queue to an array
Ds\PriorityQueue — The PriorityQueue class
- Ds\PriorityQueue::allocate — Allocates enough memory for a required capacity
- Ds\PriorityQueue::capacity — Returns the current capacity
- Ds\PriorityQueue::clear — Removes all values
- Ds\PriorityQueue::__construct — Creates a new instance
- Ds\PriorityQueue::copy — Returns a shallow copy of the queue
- Ds\PriorityQueue::count — Returns the number of values in the queue
- Ds\PriorityQueue::isEmpty — Returns whether the queue is empty
- Ds\PriorityQueue::jsonSerialize — Returns a representation that can be converted to JSON
- Ds\PriorityQueue::peek — Returns the value at the front of the queue
- Ds\PriorityQueue::pop — Removes and returns the value with the highest priority
- Ds\PriorityQueue::push — Pushes values into the queue
- Ds\PriorityQueue::toArray — Converts the queue to an array

The Collection interface

はじめに

Collection is the base interface which covers functionality common to all the data structures in this library. It guarantees that all structures are traversable, countable, and can be converted to json using json_encode.

インターフェイス概要

Ds\Collection extends Countable IteratorAggregate JsonSerializable

/* メソッド */

public void Ds\Collection::clear()

public Ds\Collection Ds\Collection::copy()

public bool Ds\Collection::isEmpty()

public array Ds\Collection::toArray()

/* 継承したメソッド */

public int Countable::count()

public Traversable IteratorAggregate::getIterator()

public mixed JsonSerializable::jsonSerialize()

変更履歴

バージョン	説明
PECL ds 1.4.0	Collection implements IteratorAggregate now instead of just Traversable. (This change came to the polyfill in 1.4.1.)

The Hashable interface

はじめに

Hashable is an interface which allows objects to be used as keys. It’s an alternative to spl_object_hash, which determines an object’s hash based on its handle: this means that two objects that are considered equal by an implicit definition would not treated as equal because they are not the same instance.

hash is used to return a scalar value to be used as the object's hash value, which determines where it goes in the hash table. While this value does not have to be unique, objects which are equal must have the same hash value.

equals is used to determine if two objects are equal. It's guaranteed that the comparing object will be an instance of the same class as the subject.

インターフェイス概要

Ds\Hashable

/* メソッド */

abstract public bool Ds\Hashable::equals(object $obj)

abstract public mixed Ds\Hashable::hash()

The Sequence interface

はじめに

A Sequence describes the behaviour of values arranged in a single, linear dimension. Some languages refer to this as a "List". It’s similar to an array that uses incremental integer keys, with the exception of a few characteristics:

Values will always be indexed as [0, 1, 2, …, size - 1].
Only allowed to access values by index in the range [0, size - 1].

Use cases:

Wherever you would use an array as a list (not concerned with keys).
A more efficient alternative to SplDoublyLinkedList and SplFixedArray.

インターフェイス概要

Ds\Sequence extends Ds\Collection ArrayAccess

/* メソッド */

abstract public void Ds\Sequence::allocate(int $capacity)

abstract public void Ds\Sequence::apply(callable $callback)

abstract public int Ds\Sequence::capacity()

abstract public bool Ds\Sequence::contains(mixed ...$values)

abstract public Ds\Sequence Ds\Sequence::filter(callable $callback = ?)

abstract public mixed Ds\Sequence::find(mixed $value)

abstract public mixed Ds\Sequence::first()

abstract public mixed Ds\Sequence::get(int $index)

abstract public void Ds\Sequence::insert(int $index, mixed ...$values)

abstract public string Ds\Sequence::join(string $glue = ?)

abstract public mixed Ds\Sequence::last()

abstract public Ds\Sequence Ds\Sequence::map(callable $callback)

abstract public Ds\Sequence Ds\Sequence::merge(mixed $values)

abstract public mixed Ds\Sequence::pop()

abstract public void Ds\Sequence::push(mixed ...$values)

abstract public mixed Ds\Sequence::reduce(callable $callback, mixed $initial = ?)

abstract public mixed Ds\Sequence::remove(int $index)

abstract public void Ds\Sequence::reverse()

abstract public Ds\Sequence Ds\Sequence::reversed()

abstract public void Ds\Sequence::rotate(int $rotations)

abstract public void Ds\Sequence::set(int $index, mixed $value)

abstract public mixed Ds\Sequence::shift()

abstract public Ds\Sequence Ds\Sequence::slice(int $index, int $length = ?)

abstract public void Ds\Sequence::sort(callable $comparator = ?)

abstract public Ds\Sequence Ds\Sequence::sorted(callable $comparator = ?)

abstract public intfloat Ds\Sequence::sum()

abstract public void Ds\Sequence::unshift(mixed $values = ?)

/* 継承したメソッド */

public void Ds\Collection::clear()

public Ds\Collection Ds\Collection::copy()

public bool Ds\Collection::isEmpty()

public array Ds\Collection::toArray()

public int Countable::count()

public Traversable IteratorAggregate::getIterator()

public mixed JsonSerializable::jsonSerialize()

public bool ArrayAccess::offsetExists(mixed $offset)

public mixed ArrayAccess::offsetGet(mixed $offset)

public void ArrayAccess::offsetSet(mixed $offset, mixed $value)

public void ArrayAccess::offsetUnset(mixed $offset)

変更履歴

バージョン	説明
PECL ds 1.3.0	The interface now extends ArrayAccess.

The Vector class

はじめに

A Vector is a sequence of values in a contiguous buffer that grows and shrinks automatically. It’s the most efficient sequential structure because a value’s index is a direct mapping to its index in the buffer, and the growth factor isn't bound to a specific multiple or exponent.

Strengths

Supports array syntax (square brackets).
Uses less overall memory than an array for the same number of values.
Automatically frees allocated memory when its size drops low enough.
Capacity does not have to be a power of 2.
get, set, push, pop are all O(1).

Weaknesses

shift, unshift, insert and remove are all O(n).

クラス概要

Ds\Vector

class Ds\Vector implements Ds\Sequence, ArrayAccess {

/* 定数 */

const int Ds\Vector::MIN_CAPACITY = 10;

/* メソッド */

public void allocate(int $capacity)

public void apply(callable $callback)

public int capacity()

public void clear()

public bool contains(mixed ...$values)

public Ds\Vector copy()

public Ds\Vector filter(callable $callback = ?)

public mixed find(mixed $value)

public mixed first()

public mixed get(int $index)

public void insert(int $index, mixed ...$values)

public bool isEmpty()

public string join(string $glue = ?)

public mixed last()

public Ds\Vector map(callable $callback)

public Ds\Vector merge(mixed $values)

public mixed pop()

public void push(mixed ...$values)

public mixed reduce(callable $callback, mixed $initial = ?)

public mixed remove(int $index)

public void reverse()

public Ds\Vector reversed()

public void rotate(int $rotations)

public void set(int $index, mixed $value)

public mixed shift()

public Ds\Vector slice(int $index, int $length = ?)

public void sort(callable $comparator = ?)

public Ds\Vector sorted(callable $comparator = ?)

public intfloat sum()

public array toArray()

public void unshift(mixed $values = ?)

}

定義済み定数

Ds\Vector::MIN_CAPACITY

変更履歴

バージョン	説明
PECL ds 1.3.0	The class now implements ArrayAccess.

The Deque class

はじめに

A Deque (pronounced “deck”) is a sequence of values in a contiguous buffer that grows and shrinks automatically. The name is a common abbreviation of “double-ended queue” and is used internally by Ds\Queue.

Two pointers are used to keep track of a head and a tail. The pointers can “wrap around” the end of the buffer, which avoids the need to move other values around to make room. This makes shift and unshift very fast — something a Ds\Vector can’t compete with.

Accessing a value by index requires a translation between the index and its corresponding position in the buffer: ((head + position) % capacity).

Strengths

Supports array syntax (square brackets).
Uses less overall memory than an array for the same number of values.
Automatically frees allocated memory when its size drops low enough.
get, set, push, pop, shift, and unshift are all O(1).

Weaknesses

Capacity must be a power of 2.
insert and remove are O(n).

クラス概要

Ds\Deque

class Ds\Deque implements Ds\Sequence, ArrayAccess {

/* 定数 */

const int Ds\Deque::MIN_CAPACITY = 8;

/* メソッド */

public void allocate(int $capacity)

public void apply(callable $callback)

public int capacity()

public void clear()

public bool contains(mixed ...$values)

public Ds\Deque copy()

public Ds\Deque filter(callable $callback = ?)

public mixed find(mixed $value)

public mixed first()

public mixed get(int $index)

public void insert(int $index, mixed ...$values)

public bool isEmpty()

public string join(string $glue = ?)

public mixed last()

public Ds\Deque map(callable $callback)

public Ds\Deque merge(mixed $values)

public mixed pop()

public void push(mixed ...$values)

public mixed reduce(callable $callback, mixed $initial = ?)

public mixed remove(int $index)

public void reverse()

public Ds\Deque reversed()

public void rotate(int $rotations)

public void set(int $index, mixed $value)

public mixed shift()

public Ds\Deque slice(int $index, int $length = ?)

public void sort(callable $comparator = ?)

public Ds\Deque sorted(callable $comparator = ?)

public intfloat sum()

public array toArray()

public void unshift(mixed $values = ?)

}

定義済み定数

Ds\Deque::MIN_CAPACITY

変更履歴

バージョン	説明
PECL ds 1.3.0	The class now implements ArrayAccess.

The Map class

はじめに

A Map is a sequential collection of key-value pairs, almost identical to an array used in a similar context. Keys can be any type, but must be unique. Values are replaced if added to the map using the same key.

Strengths

Keys and values can be any type, including objects.
Supports array syntax (square brackets).
Insertion order is preserved.
Performance and memory efficiency is very similar to an array.
Automatically frees allocated memory when its size drops low enough.

Weaknesses

Can’t be converted to an array when objects are used as keys.

クラス概要

Ds\Map

class Ds\Map implements Ds\Collection, ArrayAccess {

/* 定数 */

const int Ds\Map::MIN_CAPACITY = 16;

/* メソッド */

public void allocate(int $capacity)

public void apply(callable $callback)

public int capacity()

public void clear()

public Ds\Map copy()

public Ds\Map diff(Ds\Map $map)

public Ds\Map filter(callable $callback = ?)

public Ds\Pair first()

public mixed get(mixed $key, mixed $default = ?)

public bool hasKey(mixed $key)

public bool hasValue(mixed $value)

public Ds\Map intersect(Ds\Map $map)

public bool isEmpty()

public Ds\Set keys()

public void ksort(callable $comparator = ?)

public Ds\Map ksorted(callable $comparator = ?)

public Ds\Pair last()

public Ds\Map map(callable $callback)

public Ds\Map merge(mixed $values)

public Ds\Sequence pairs()

public void put(mixed $key, mixed $value)

public void putAll(mixed $pairs)

public mixed reduce(callable $callback, mixed $initial = ?)

public mixed remove(mixed $key, mixed $default = ?)

public void reverse()

public Ds\Map reversed()

public Ds\Pair skip(int $position)

public Ds\Map slice(int $index, int $length = ?)

public void sort(callable $comparator = ?)

public Ds\Map sorted(callable $comparator = ?)

public intfloat sum()

public array toArray()

public Ds\Map union(Ds\Map $map)

public Ds\Sequence values()

public Ds\Map xor(Ds\Map $map)

}

定義済み定数

Ds\Map::MIN_CAPACITY

変更履歴

バージョン	説明
PECL ds 1.3.0	The class now implements ArrayAccess.

The Pair class

はじめに

A pair is used by Ds\Map to pair keys with values.

クラス概要

Ds\Pair

class Ds\Pair implements JsonSerializable {

/* メソッド */

public __construct(mixed $key = ?, mixed $value = ?)

public void clear()

public Ds\Pair copy()

public bool isEmpty()

public array toArray()

}

The Set class

はじめに

A Set is a sequence of unique values. This implementation uses the same hash table as Ds\Map, where values are used as keys and the mapped value is ignored.

Strengths

Values can be any type, including objects.
Supports array syntax (square brackets).
Insertion order is preserved.
Automatically frees allocated memory when its size drops low enough.
add, remove and contains are all O(1).

Weaknesses

Doesn’t support push, pop, insert, shift, or unshift.
get is O(n) if there are deleted values in the buffer before the accessed index, O(1) otherwise.

クラス概要

Ds\Set

class Ds\Set implements Ds\Collection, ArrayAccess {

/* 定数 */

const int Ds\Set::MIN_CAPACITY = 16;

/* メソッド */

public void add(mixed ...$values)

public void allocate(int $capacity)

public int capacity()

public void clear()

public bool contains(mixed ...$values)

public Ds\Set copy()

public Ds\Set diff(Ds\Set $set)

public Ds\Set filter(callable $callback = ?)

public mixed first()

public mixed get(int $index)

public Ds\Set intersect(Ds\Set $set)

public bool isEmpty()

public string join(string $glue = ?)

public mixed last()

public Ds\Set merge(mixed $values)

public mixed reduce(callable $callback, mixed $initial = ?)

public void remove(mixed ...$values)

public void reverse()

public Ds\Set reversed()

public Ds\Set slice(int $index, int $length = ?)

public void sort(callable $comparator = ?)

public Ds\Set sorted(callable $comparator = ?)

public intfloat sum()

public array toArray()

public Ds\Set union(Ds\Set $set)

public Ds\Set xor(Ds\Set $set)

}

定義済み定数

Ds\Set::MIN_CAPACITY

変更履歴

バージョン	説明
PECL ds 1.3.0	The class now implements ArrayAccess.

The Stack class

はじめに

A Stack is a “last in, first out” or “LIFO” collection that only allows access to the value at the top of the structure and iterates in that order, destructively.

Uses a Ds\Vector internally.

クラス概要

Ds\Stack

class Ds\Stack implements Ds\Collection, ArrayAccess {

/* メソッド */

public void allocate(int $capacity)

public int capacity()

public void clear()

public Ds\Stack copy()

public bool isEmpty()

public mixed peek()

public mixed pop()

public void push(mixed ...$values)

public array toArray()

}

変更履歴

バージョン	説明
PECL ds 1.3.0	The class now implements ArrayAccess.

The Queue class

はじめに

A Queue is a “first in, first out” or “FIFO” collection that only allows access to the value at the front of the queue and iterates in that order, destructively.

クラス概要

Ds\Queue

class Ds\Queue implements Ds\Collection, ArrayAccess {

/* 定数 */

const int Ds\Queue::MIN_CAPACITY = 8;

/* メソッド */

public void allocate(int $capacity)

public int capacity()

public void clear()

public Ds\Queue copy()

public bool isEmpty()

public mixed peek()

public mixed pop()

public void push(mixed ...$values)

public array toArray()

}

定義済み定数

Ds\Queue::MIN_CAPACITY

変更履歴

バージョン	説明
PECL ds 1.3.0	The class now implements ArrayAccess.

The PriorityQueue class

はじめに

A PriorityQueue is very similar to a Queue. Values are pushed into the queue with an assigned priority, and the value with the highest priority will always be at the front of the queue.

Implemented using a max heap.

注意:
"First in, first out" ordering is preserved for values with the same priority.

注意:
Iterating over a PriorityQueue is destructive, equivalent to successive pop operations until the queue is empty.

クラス概要

Ds\PriorityQueue

class Ds\PriorityQueue implements Ds\Collection {

/* 定数 */

const int Ds\PriorityQueue::MIN_CAPACITY = 8;

/* メソッド */

public void allocate(int $capacity)

public int capacity()

public void clear()

public Ds\PriorityQueue copy()

public bool isEmpty()

public mixed peek()

public mixed pop()

public void push(mixed $value, int $priority)

public array toArray()

}

定義済み定数

Ds\PriorityQueue::MIN_CAPACITY