/**
* Is the given restriciton object registered?
*
* @static
*
* @param Falcraft\Data\Types\Restrictions
* The restrictions possibly registered
*
* @return bool True on success, False on failure
*
*/
public static function isRestrictionObjectRegistered($restrictions)
{
if (self::$registry === null) {
self::$registry = new Map();
self::initRegsitry();
}
$values = self::$registry->getValues();
foreach ($values as $value) {
if (Restrictions::compare($restrictions, $value)) {
return true;
}
}
return false;
}
/**
* UnorderedNode Class Constructor
*
* It takes three RestrictedSets, whose restrictions have to match the
* UnorderedNode restrictions (VertexInterface). In this vertex model
* (unordered node) incoming connections are parents, outgoing connections
* are children, and mutual connections are siblings. These are all in
* any order, so unlike an HTML document for instance, it can't be put
* 'in order'.
*
* This initializes the restrictions member for the interface
* VertexInterface (supported in Falcraft\Data\Types\Restrictions 1.3)
*
* NOTE: Mutual connections are made one way, not in the constructor
*
* @param Falcraft\Data\Types\RestrictedSet $parents The initial parent vertices
* @param Falcraft\Data\Types\RestrictedSet $children The initial children vertices
* @param Falcraft\Data\Types\RestrictedSet $siblings The initial sibling vertices
*
* @throws Falcraft\Data\Types\Exception\InvalidArgumentException
* If a given RestrictedSet has non-matching restrictions
*
*/
public function __construct(RestrictedSet $parents = null, RestrictedSet $children = null, RestrictedSet $siblings = null)
{
$this->initializeIdentifier();
/* Initialize restrictions, anything that is an instanceof
(implements) VertexInterface) */
$this->restrictions = new Restrictions(array(Type::TYPED_OBJECT), array('Falcraft\\Data\\Types\\Resource\\VertexInterface'), array('autoload' => true));
// Map the parameters to the AbstractVertex lingo
$params = array('incoming' => 'parents', 'outgoing' => 'children', 'mutual' => 'siblings');
// Cycle through parameters, replacing 'incoming' with 'parents' etc.
// This whole mixup is done so that people won't be confused about where
// to put parents, children, and siblings. (incoming, outgoing, mutual)
foreach ($params as $key => $param) {
if (is_null(${$param})) {
$this->{$key} = RestrictedSet::build(array(), $this->restrictions, array('strict' => true, 'unique' => true));
/* Make sure the restrictions on the RestrictedSet match with
our own restrictions */
} else {
if (Restrictions::compare($this->restrictions, ${$param}->getRestrictions())) {
$this->{$key} = ${$param};
} else {
throw new TypesException\InvalidArgumentException('UnorderedNode->__construct: Improper RestrictedSet ' . 'At Constructor: ' . $param);
}
}
}
// Connect actual nodes
Set::map(array($this, 'connectIncoming'), $this->incoming);
foreach ($this->incoming->iterate() as $vertex) {
$vertex->connectOutgoing($this);
}
Set::map(array($this, 'connectOutgoing'), $this->outgoing);
foreach ($this->outgoing->iterate() as $vertex) {
$vertex->connectIncoming($this);
}
}
/**
* OrderedNode Class Constructor
*
* It takes two RestrictedSets, whose restrictions have to match the
* OrderedNode restrictions (VertexInterface). In this vertex model
* (ordered node) incoming connections are parents, outgoing connections
* are children, and mutual connections are siblings.
*
* Children are a special matter, they're made up a VertexList.
* A VertexList is an ordered list of Vertices (held together
* by a double linked list of edges) The vertexlist takes care of the
* children's mutual connections (I know, bad coupling). To do
* vertexlist operations use getVertexList()
*
* This initializes the restrictions member for the interface
* VertexInterface (supported in Falcraft\Data\Types\Restrictions 1.3)
*
* @param Falcraft\Data\Types\RestrictedSet $parents
* The initial parent vertices
* @param array $children
* The initial children vertices in reference
* @param Falcraft\Data\Types\RestrictedSet $siblings
* The initial sibling vertices
*
* @throws TypesException\InvalidArgumentException
* If a given RestrictedSet has non-matching restrictions
*
*/
public function __construct(RestrictedSet $parents = null, array $children = array(), RestrictedSet $siblings = null, array $options = array())
{
parent::__construct(null, null, null, $options);
// Initialize restrictions, anything that is an instanceof (implements) VertexInterface)
$this->restrictions = new Restrictions(array(Type::TYPED_OBJECT), array('Falcraft\\Data\\Types\\Resource\\VertexInterface'), array('autoload' => true));
// Map the parameters to the AbstractVertex lingo
$params = array('incoming' => 'parents', 'mutual' => 'siblings');
// Cycle through parameters, replacing 'incoming' with 'parents' etc.
// This whole mixup is done so that people won't be confused about where
// to put parents, children, and siblings. (incoming, outgoing, mutual)
foreach ($params as $key => $param) {
if (is_null(${$param})) {
$this->{$param} = RestrictedSet::build(array(), $this->restrictions, array('strict' => true));
// Make sure the restrictions on the RestrictedSet match with our own restrictions
} else {
if (Restrictions::compare($this->restrictions, ${$param}->getRestrictions())) {
$this->{$key} = ${$param};
} else {
throw new TypesException\InvalidArgumentException('OrderedNode->__construct: Improper RestrictedSet At ' . 'Constructor: ' . $param);
}
}
}
// Children are a special matter in this class
$this->outgoing = new VertexList($children);
}
