/**
* @param EventInterface $value
* @throws \Exception
*/
public function onNext($value)
{
$uri = $value->getName();
// TODO add route cache
foreach ($this->routing as $subject) {
/* @var ReplaySubject $subject */
$routes = $this->routing->offsetGet($subject);
foreach ($routes as $data) {
if (!preg_match($data['regex'], $uri, $matches)) {
continue;
}
$vars = [];
$i = 0;
foreach ($data['routeMap'] as $varName) {
$vars[$varName] = $matches[++$i];
}
$labels = $value->getLabels();
$labels = array_merge($labels, $vars);
$value->setLabels($labels);
$subject->onNext($value);
return;
}
}
throw new \Exception("not found");
}
/**
* @param \AGmakonts\STL\String\Text $entityType
*
* @return AbstractRepository
* @throws \AGmakonts\DddBricks\Repository\Exception\HelperException
*/
protected function getHelperForEntityType(Text $entityType)
{
if (FALSE === $this->_helpers->offsetExists($entityType)) {
throw new HelperException(HelperException::HELPER_UNKNOWN);
}
return $this->_helpers->offsetGet($entityType);
}
/**
* @param Peer $peer
* @return PeerState
*/
public function fetch(Peer $peer)
{
if (!$this->storage->contains($peer)) {
$state = $this->createState($peer);
} else {
$state = $this->storage->offsetGet($peer);
}
return $state;
}
/**
* @param HandlerInterface $handler
* @param array $categories
*/
public function attach(HandlerInterface $handler, array $categories = array())
{
if ($this->handlers->contains($handler)) {
$handlerCategories = $this->handlers->offsetGet($handler);
$this->handlers->offsetSet($handler, array_merge((array) $handlerCategories, $categories));
} else {
$this->handlers->attach($handler, $categories);
}
}
/**
* {@inheritdoc}
*/
public function finish(RequestInterface $request, ResponseInterface $response)
{
if ($this->isTerminableKernel) {
list($sfRequest, $sfResponse) = $this->requestMapping->offsetGet($request);
$this->requestMapping->detach($request);
$kernel = $this->kernel;
/* @var $kernel TerminableInterface */
$kernel->terminate($sfRequest, $sfResponse);
}
}
/**
* Triggered when a client sends data through the socket
* @param \Ratchet\ConnectionInterface $from The socket/connection that sent the message to your application
* @param string $msg The message received
* @throws \Exception
*
* expects:
* { 'cmd': "identifier", 'payload': {<data>}}
* could use bson instead
*/
function onMessage(ConnectionInterface $from, $msg)
{
$from = $this->connections->offsetGet($from);
if (null === ($json = @json_decode($msg, true))) {
throw new JsonException();
}
if (!is_array($json)) {
throw new Exception("Invalid message");
}
$this->wrapped->onMessage($from, $json);
}
/**
* Returns list of observers for subject
*
* @param SubjectInterface $s
*
* @return \SplObjectStorage|ObserverInterface[]
*/
protected function getObservers(SubjectInterface $s)
{
if ($this->perSubjectObservers === null) {
$this->perSubjectObservers = new \SplObjectStorage();
}
if (!isset($this->perSubjectObservers[$s])) {
$observers = new \SplObjectStorage();
$this->perSubjectObservers->offsetSet($s, $observers);
} else {
$observers = $this->perSubjectObservers->offsetGet($s);
}
return $observers;
}
/**
* @return bool
*/
public function save()
{
$pkField = self::getAutoIncrementField();
if ($this->isNewRecord()) {
if (($id = $this->insertGetId((array) $this)) > 0) {
$this->{$pkField} = $id;
return true;
}
return false;
} else {
$original = unserialize(static::$modelStorage->offsetGet($this));
return 1 == $this->where($pkField . '=?', array($original[$pkField]))->update((array) $this);
}
}
/**
* Returns the validation groups of the given form.
*
* @param FormInterface $form The form.
*
* @return array The validation groups.
*/
private static function getValidationGroups(FormInterface $form)
{
$root = $form->getRoot();
// Determine the clicked button of the complete form tree
if (!static::$clickedButtons->contains($root)) {
// Only call findClickedButton() once to prevent an exponential
// runtime
// https://github.com/symfony/symfony/issues/8317
static::$clickedButtons->attach($root, self::findClickedButton($root));
}
$button = static::$clickedButtons->offsetGet($root);
if (null !== $button) {
$groups = $button->getConfig()->getOption('validation_groups');
if (null !== $groups) {
return self::resolveValidationGroups($groups, $form);
}
}
do {
$groups = $form->getConfig()->getOption('validation_groups');
if (null !== $groups) {
return self::resolveValidationGroups($groups, $form);
}
$form = $form->getParent();
} while (null !== $form);
return array(Constraint::DEFAULT_GROUP);
}
/**
* Call the view helper associated with this object.
*
* First, it evaluates the arguments of the view helper.
*
* If the view helper implements \TYPO3\Fluid\Core\ViewHelper\Facets\ChildNodeAccessInterface,
* it calls setChildNodes(array childNodes) on the view helper.
*
* Afterwards, checks that the view helper did not leave a variable lying around.
*
* @param RenderingContextInterface $renderingContext
* @return object evaluated node after the view helper has been called.
*/
public function evaluate(RenderingContextInterface $renderingContext)
{
if ($this->viewHelpersByContext->contains($renderingContext)) {
$viewHelper = $this->viewHelpersByContext->offsetGet($renderingContext);
$viewHelper->resetState();
} else {
$viewHelper = clone $this->uninitializedViewHelper;
$this->viewHelpersByContext->attach($renderingContext, $viewHelper);
}
$evaluatedArguments = array();
if (count($viewHelper->prepareArguments())) {
/** @var $argumentDefinition ArgumentDefinition */
foreach ($viewHelper->prepareArguments() as $argumentName => $argumentDefinition) {
if (isset($this->arguments[$argumentName])) {
/** @var $argumentValue NodeInterface */
$argumentValue = $this->arguments[$argumentName];
$evaluatedArguments[$argumentName] = $argumentValue->evaluate($renderingContext);
} else {
$evaluatedArguments[$argumentName] = $argumentDefinition->getDefaultValue();
}
}
}
$viewHelper->setArguments($evaluatedArguments);
$viewHelper->setViewHelperNode($this);
$viewHelper->setRenderingContext($renderingContext);
if ($viewHelper instanceof ChildNodeAccessInterface) {
$viewHelper->setChildNodes($this->childNodes);
}
$output = $viewHelper->initializeArgumentsAndRender();
return $output;
}
/**
* @param \Sitemapper\SitemapInterface $sitemap
*/
protected function saveSitemap(SitemapInterface $sitemap)
{
if ($this->sitemaps->contains($sitemap)) {
$index = $this->sitemaps->offsetGet($sitemap);
$this->saveFile($this->getPathname($index), $sitemap->getOutput());
$this->savedSitemaps->attach($sitemap);
}
}
/**
* @param WebSocketObservableTable $table
*
* @return Vector|WebSocketConnection[]
*/
private function getConnectionsSubscribedToTable(WebSocketObservableTable $table)
{
try {
return $this->tableConnectionMap->offsetGet($table);
} catch (\Exception $e) {
return new Vector();
}
}
/**
* getData()
*
* gets the data set of a given route
*
* @param \Naquadria\Components\Routing\Route $route
* @throws \Naquadria\Components\Routing\Exceptions\RouteNotFoundException
* @return mixed
*/
public function getData(Route $route)
{
if (!parent::contains($route)) {
throw new RouteNotFoundException('Unknown route instance');
}
$current = parent::offsetGet($route);
return $current['data'];
}
public function handleItems($object, array $items, SerializationContext $context)
{
if ($this->deferredData->contains($object)) {
$items = array_merge($this->deferredData->offsetGet($object), $items);
$this->deferredData->detach($object);
}
$parentObjectInlining = $this->getParentObjectInlining($object, $context);
if (null === $parentObjectInlining) {
return $items;
}
if ($this->deferredData->contains($parentObjectInlining)) {
$items = array_merge($items, $this->deferredData->offsetGet($parentObjectInlining));
}
// We need to defer the links serialization to the $parentObject
$this->deferredData->attach($parentObjectInlining, $items);
return array();
}
/**
* Send data to database
*
* @return \Sokil\Mongo\Persistence
*/
public function flush()
{
/** @var $document \Sokil\Mongo\Document */
foreach ($this->_pool as $document) {
switch ($this->_pool->offsetGet($document)) {
case self::STATE_SAVE:
$document->save();
break;
case self::STATE_REMOVE:
// delete document form db
$document->delete();
// remove link form pool
$this->detach($document);
break;
}
}
return $this;
}
/**
* @param object $object
*
* @return \Kdyby\Doctrine\Forms\EntityContainer|\Kdyby\Doctrine\Forms\CollectionContainer
*/
public function getComponent($object)
{
if ($this->entities->contains($object)) {
return $this->entities->offsetGet($object);
} elseif ($this->collections->contains($object)) {
return $this->collections->offsetGet($object);
}
return NULL;
}
private function eventsToPublishOn(EventMessageInterface $event, EventBusInterface $eventBus)
{
if (!$this->eventsToPublish->contains($eventBus)) {
$this->eventsToPublish->attach($eventBus, array($event));
return;
}
$events = $this->eventsToPublish->offsetGet($eventBus);
$events[] = $event;
$this->eventsToPublish->offsetSet($eventBus, $events);
}
/**
* @param BlockHeaderInterface $header
* @return BlockIndexInterface|bool
*/
public function hasBlockTip(BlockHeaderInterface $header)
{
echo "CheckHashBlockTip - " . count($this->segments) . PHP_EOL;
foreach ($this->segments as $segment) {
/** @var BlockIndexInterface $segBlock */
$segBlock = $this->segmentBlock->offsetGet($segment);
if ($header->getPrevBlock()->equals($segBlock->getHash())) {
return $segBlock;
}
}
return false;
}
/**
* @param Type $type
* The element type for an array.
*
* @return GenericArrayType
* Get a type representing an array of the given type
*/
public static function fromElementType(Type $type) : GenericArrayType
{
// Make sure we only ever create exactly one
// object for any unique type
static $canonical_object_map = null;
if (!$canonical_object_map) {
$canonical_object_map = new \SplObjectStorage();
}
if (!$canonical_object_map->contains($type)) {
$canonical_object_map->attach($type, new GenericArrayType($type));
}
return $canonical_object_map->offsetGet($type);
}
/**
* Returns the current focused model, sets the focus if $class is specified
*
* @param Yada_Model|string $model
* @return Yada_Model
*/
public function model($model = NULL)
{
if ($model instanceof Yada_Model) {
if (!$this->_models->contains($model)) {
$this->attach($model);
} else {
$this->_current = $model;
$this->_meta = $this->_models->offsetGet($this->_current);
}
} elseif (is_string($model)) {
// Attach and initialize unknown models
$model = Yada::model($model);
$this->attach($model);
}
// Return the current Model object
return $this->_current;
}
/**
* Offset to retrieve
* @link http://php.net/manual/en/arrayaccess.offsetget.php
* @param mixed $offset <p>
* The offset to retrieve.
* </p>
* @return mixed Can return all value types.
* @since 5.0.0
*/
public function offsetGet($offset)
{
if (is_scalar($offset)) {
return $this->scalarStore[$offset];
}
if (is_object($offset)) {
return $this->objectStore->offsetGet($offset);
}
if (is_array($offset)) {
// offsetGet is often called directly after offsetExists, so optimize to avoid second loop:
if ($this->lastArrayKey === $offset) {
return $this->lastArrayValue;
}
foreach ($this->arrayKeys as $index => $entry) {
if ($entry === $offset) {
return $this->arrayValues[$index];
}
}
}
return null;
}
/**
* This method is called to hydrate ACLs and ACEs.
*
* This method was designed for performance; thus, a lot of code has been
* inlined at the cost of readability, and maintainability.
*
* Keep in mind that changes to this method might severely reduce the
* performance of the entire ACL system.
*
* @param Statement $stmt
* @param array $oidLookup
* @param array $sids
* @throws \RuntimeException
* @return \SplObjectStorage
*/
protected function hydrateObjectIdentities(Statement $stmt, array $oidLookup, array $sids)
{
$parentIdToFill = new \SplObjectStorage();
$acls = $aces = $emptyArray = array();
$oidCache = $oidLookup;
$result = new \SplObjectStorage();
$loadedAces =& $this->loadedAces;
$loadedAcls =& $this->loadedAcls;
$permissionGrantingStrategy = $this->permissionGrantingStrategy;
// we need these to set protected properties on hydrated objects
$aclReflection = new \ReflectionClass('Symfony\\Component\\Security\\Acl\\Domain\\Acl');
$aclClassAcesProperty = $aclReflection->getProperty('classAces');
$aclClassAcesProperty->setAccessible(true);
$aclClassFieldAcesProperty = $aclReflection->getProperty('classFieldAces');
$aclClassFieldAcesProperty->setAccessible(true);
$aclObjectAcesProperty = $aclReflection->getProperty('objectAces');
$aclObjectAcesProperty->setAccessible(true);
$aclObjectFieldAcesProperty = $aclReflection->getProperty('objectFieldAces');
$aclObjectFieldAcesProperty->setAccessible(true);
$aclParentAclProperty = $aclReflection->getProperty('parentAcl');
$aclParentAclProperty->setAccessible(true);
// fetchAll() consumes more memory than consecutive calls to fetch(),
// but it is faster
foreach ($stmt->fetchAll(\PDO::FETCH_NUM) as $data) {
list($aclId, $objectIdentifier, $parentObjectIdentityId, $entriesInheriting, $classType, $aceId, $objectIdentityId, $fieldName, $aceOrder, $mask, $granting, $grantingStrategy, $auditSuccess, $auditFailure, $username, $securityIdentifier) = $data;
// has the ACL been hydrated during this hydration cycle?
if (isset($acls[$aclId])) {
$acl = $acls[$aclId];
} else {
if (isset($loadedAcls[$classType][$objectIdentifier])) {
$acl = $loadedAcls[$classType][$objectIdentifier];
// keep reference in local array (saves us some hash calculations)
$acls[$aclId] = $acl;
// attach ACL to the result set; even though we do not enforce that every
// object identity has only one instance, we must make sure to maintain
// referential equality with the oids passed to findAcls()
if (!isset($oidCache[$objectIdentifier . $classType])) {
$oidCache[$objectIdentifier . $classType] = $acl->getObjectIdentity();
}
$result->attach($oidCache[$objectIdentifier . $classType], $acl);
} else {
// create object identity if we haven't done so yet
$oidLookupKey = $objectIdentifier . $classType;
if (!isset($oidCache[$oidLookupKey])) {
$oidCache[$oidLookupKey] = new ObjectIdentity($objectIdentifier, $classType);
}
$acl = new Acl((int) $aclId, $oidCache[$oidLookupKey], $permissionGrantingStrategy, $emptyArray, !!$entriesInheriting);
// keep a local, and global reference to this ACL
$loadedAcls[$classType][$objectIdentifier] = $acl;
$acls[$aclId] = $acl;
// try to fill in parent ACL, or defer until all ACLs have been hydrated
if (null !== $parentObjectIdentityId) {
if (isset($acls[$parentObjectIdentityId])) {
$aclParentAclProperty->setValue($acl, $acls[$parentObjectIdentityId]);
} else {
$parentIdToFill->attach($acl, $parentObjectIdentityId);
}
}
$result->attach($oidCache[$oidLookupKey], $acl);
}
}
// check if this row contains an ACE record
if (null !== $aceId) {
// have we already hydrated ACEs for this ACL?
if (!isset($aces[$aclId])) {
$aces[$aclId] = array($emptyArray, $emptyArray, $emptyArray, $emptyArray);
}
// has this ACE already been hydrated during a previous cycle, or
// possible been loaded from cache?
// It is important to only ever have one ACE instance per actual row since
// some ACEs are shared between ACL instances
if (!isset($loadedAces[$aceId])) {
if (!isset($sids[$key = ($username ? '1' : '0') . $securityIdentifier])) {
if ($username) {
$sids[$key] = new UserSecurityIdentity(substr($securityIdentifier, 1 + ($pos = strpos($securityIdentifier, '-'))), substr($securityIdentifier, 0, $pos));
} else {
$sids[$key] = new RoleSecurityIdentity($securityIdentifier);
}
}
if (null === $fieldName) {
$loadedAces[$aceId] = new Entry((int) $aceId, $acl, $sids[$key], $grantingStrategy, (int) $mask, !!$granting, !!$auditFailure, !!$auditSuccess);
} else {
$loadedAces[$aceId] = new FieldEntry((int) $aceId, $acl, $fieldName, $sids[$key], $grantingStrategy, (int) $mask, !!$granting, !!$auditFailure, !!$auditSuccess);
}
}
$ace = $loadedAces[$aceId];
// assign ACE to the correct property
if (null === $objectIdentityId) {
if (null === $fieldName) {
$aces[$aclId][0][$aceOrder] = $ace;
} else {
$aces[$aclId][1][$fieldName][$aceOrder] = $ace;
}
} else {
if (null === $fieldName) {
$aces[$aclId][2][$aceOrder] = $ace;
} else {
$aces[$aclId][3][$fieldName][$aceOrder] = $ace;
}
}
}
}
// We do not sort on database level since we only want certain subsets to be sorted,
// and we are going to read the entire result set anyway.
// Sorting on DB level increases query time by an order of magnitude while it is
// almost negligible when we use PHPs array sort functions.
foreach ($aces as $aclId => $aceData) {
$acl = $acls[$aclId];
ksort($aceData[0]);
$aclClassAcesProperty->setValue($acl, $aceData[0]);
foreach (array_keys($aceData[1]) as $fieldName) {
ksort($aceData[1][$fieldName]);
}
$aclClassFieldAcesProperty->setValue($acl, $aceData[1]);
ksort($aceData[2]);
$aclObjectAcesProperty->setValue($acl, $aceData[2]);
foreach (array_keys($aceData[3]) as $fieldName) {
ksort($aceData[3][$fieldName]);
}
$aclObjectFieldAcesProperty->setValue($acl, $aceData[3]);
}
// fill-in parent ACLs where this hasn't been done yet cause the parent ACL was not
// yet available
$processed = 0;
foreach ($parentIdToFill as $acl) {
$parentId = $parentIdToFill->offsetGet($acl);
// let's see if we have already hydrated this
if (isset($acls[$parentId])) {
$aclParentAclProperty->setValue($acl, $acls[$parentId]);
$processed += 1;
continue;
}
}
// reset reflection changes
$aclClassAcesProperty->setAccessible(false);
$aclClassFieldAcesProperty->setAccessible(false);
$aclObjectAcesProperty->setAccessible(false);
$aclObjectFieldAcesProperty->setAccessible(false);
$aclParentAclProperty->setAccessible(false);
// this should never be true if the database integrity hasn't been compromised
if ($processed < count($parentIdToFill)) {
throw new \RuntimeException('Not all parent ids were populated. This implies an integrity problem.');
}
return $result;
}
public function offsetUnset($index)
{
$this->validateIndex($index);
// Decrement counters when replacing existing item
if (parent::offsetExists($index)) {
$oldResult = parent::offsetGet($index);
if ($oldResult instanceof Success) {
$this->countSuccess--;
} elseif ($oldResult instanceof Failure) {
$this->countFailure--;
} elseif ($oldResult instanceof Warning) {
$this->countWarning--;
} else {
$this->countUnknown--;
}
}
parent::offsetUnset($index);
}
/**
* Generates the inline definition of a service.
*
* @param string $id
* @param Definition $definition
*
* @return string
*
* @throws RuntimeException When the factory definition is incomplete
* @throws ServiceCircularReferenceException When a circular reference is detected
*/
private function addServiceInlinedDefinitions($id, $definition)
{
$code = '';
$variableMap = $this->definitionVariables;
$nbOccurrences = new \SplObjectStorage();
$processed = new \SplObjectStorage();
$inlinedDefinitions = $this->getInlinedDefinitions($definition);
foreach ($inlinedDefinitions as $definition) {
if (false === $nbOccurrences->contains($definition)) {
$nbOccurrences->offsetSet($definition, 1);
} else {
$i = $nbOccurrences->offsetGet($definition);
$nbOccurrences->offsetSet($definition, $i + 1);
}
}
foreach ($inlinedDefinitions as $sDefinition) {
if ($processed->contains($sDefinition)) {
continue;
}
$processed->offsetSet($sDefinition);
$class = $this->dumpValue($sDefinition->getClass());
if ($nbOccurrences->offsetGet($sDefinition) > 1 || $sDefinition->getMethodCalls() || $sDefinition->getProperties() || null !== $sDefinition->getConfigurator() || false !== strpos($class, '$')) {
$name = $this->getNextVariableName();
$variableMap->offsetSet($sDefinition, new Variable($name));
// a construct like:
// $a = new ServiceA(ServiceB $b); $b = new ServiceB(ServiceA $a);
// this is an indication for a wrong implementation, you can circumvent this problem
// by setting up your service structure like this:
// $b = new ServiceB();
// $a = new ServiceA(ServiceB $b);
// $b->setServiceA(ServiceA $a);
if ($this->hasReference($id, $sDefinition->getArguments())) {
throw new ServiceCircularReferenceException($id, array($id));
}
$code .= $this->addNewInstance($id, $sDefinition, '$'.$name, ' = ');
if (!$this->hasReference($id, $sDefinition->getMethodCalls(), true) && !$this->hasReference($id, $sDefinition->getProperties(), true)) {
$code .= $this->addServiceMethodCalls(null, $sDefinition, $name);
$code .= $this->addServiceProperties(null, $sDefinition, $name);
$code .= $this->addServiceConfigurator(null, $sDefinition, $name);
}
$code .= "\n";
}
}
return $code;
}
private function updateAce(\SplObjectStorage $aces, $ace)
{
$propertyChanges = $aces->offsetGet($ace);
$sets = array();
if (isset($propertyChanges['aceOrder']) && $propertyChanges['aceOrder'][1] > $propertyChanges['aceOrder'][0] && $propertyChanges == $aces->offsetGet($ace)) {
$aces->next();
if ($aces->valid()) {
$this->updateAce($aces, $aces->current());
}
}
if (isset($propertyChanges['mask'])) {
$sets[] = sprintf('mask = %d', $propertyChanges['mask'][1]);
}
if (isset($propertyChanges['strategy'])) {
$sets[] = sprintf('granting_strategy = %s', $this->connection->quote($propertyChanges['strategy']));
}
if (isset($propertyChanges['aceOrder'])) {
$sets[] = sprintf('ace_order = %d', $propertyChanges['aceOrder'][1]);
}
if (isset($propertyChanges['auditSuccess'])) {
$sets[] = sprintf('audit_success = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditSuccess'][1]));
}
if (isset($propertyChanges['auditFailure'])) {
$sets[] = sprintf('audit_failure = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditFailure'][1]));
}
$this->connection->executeQuery($this->getUpdateAccessControlEntrySql($ace->getId(), $sets));
}
/**
* Gets ACL associated with the given object identity from the collections specified in $acls argument.
*
* @param \SplObjectStorage $acls
* @param OID $oid
* @return AclInterface|null
*/
protected function findAclByOid(\SplObjectStorage $acls, ObjectIdentity $oid)
{
$result = null;
foreach ($acls as $aclOid) {
if ($oid->equals($aclOid)) {
$result = $acls->offsetGet($aclOid);
break;
}
}
return $result;
}
/**
* This method is called to hydrate ACLs and ACEs.
*
* This method was designed for performance; thus, a lot of code has been
* inlined at the cost of readability, and maintainability.
*
* Keep in mind that changes to this method might severely reduce the
* performance of the entire ACL system.
*
* @param Cursor $cursor
* @param Cursor $objectIdentities
* @param array $oidLookup
* @param array $sids
* @throws \RuntimeException
* @return \SplObjectStorage
*/
protected function hydrateObjectIdentities(Cursor $entryCursor, Cursor $objectCursor, array $oidLookup, array $sids)
{
$parentIdToFill = new \SplObjectStorage();
$acls = $aces = $emptyArray = array();
$oidCache = $oidLookup;
$result = new \SplObjectStorage();
$loadedAces =& $this->loadedAces;
$loadedAcls =& $this->loadedAcls;
$permissionGrantingStrategy = $this->permissionGrantingStrategy;
// we need these to set protected properties on hydrated objects
$aclReflection = new \ReflectionClass('Symfony\\Component\\Security\\Acl\\Domain\\Acl');
$aclClassAcesProperty = $aclReflection->getProperty('classAces');
$aclClassAcesProperty->setAccessible(true);
$aclClassFieldAcesProperty = $aclReflection->getProperty('classFieldAces');
$aclClassFieldAcesProperty->setAccessible(true);
$aclObjectAcesProperty = $aclReflection->getProperty('objectAces');
$aclObjectAcesProperty->setAccessible(true);
$aclObjectFieldAcesProperty = $aclReflection->getProperty('objectFieldAces');
$aclObjectFieldAcesProperty->setAccessible(true);
$aclParentAclProperty = $aclReflection->getProperty('parentAcl');
$aclParentAclProperty->setAccessible(true);
$entries = $classEntries = array();
/**
* using iterator_to_array is faster, but could cause potential problems with low memory, high data set
* if it does in the foreach()
* use $entryCursor instead of $entryData
* use $objectCursor instead of $objectData
*
* TODO: should this be configurable?
*/
$entryData = iterator_to_array($entryCursor);
foreach ($entryData as $entry) {
$eid = (string) $entry['_id'];
if (isset($entry['objectIdentity'])) {
$objectId = (string) $entry['objectIdentity']['$id'];
$entries[$objectId][$eid] = $entry;
} elseif (isset($entry['class'])) {
$class = (string) $entry['class'];
$classEntries[$class][$eid] = $entry;
}
}
$objectData = iterator_to_array($objectCursor);
foreach ($objectData as $curObject) {
$aclId = (string) $curObject['_id'];
$type = (string) $curObject['type'];
$oid[$aclId] = $curObject;
if (!isset($entries[$aclId])) {
$parent = $curObject;
while ((string) $parent['_id'] != $aclId && isset($parent['parent'])) {
if (isset($parent['parent'])) {
$parent = $parent['parent'];
}
}
$entries[$aclId][0] = array('objectIdentity' => $parent, 'fieldName' => null, 'aceOrder' => null, 'grantingStrategy' => null, 'mask' => null, 'granting' => null, 'auditFailure' => null, 'auditSuccess' => null);
}
//Attach the class aces to the right entry if the type of current object matches class
if (array_key_exists($type, $classEntries)) {
foreach ($classEntries[$type] as $entry) {
$eid = (string) $entry['_id'];
$entries[$aclId][$eid] = $entry;
}
}
foreach ($entries[$aclId] as $aceId => $entry) {
$objectIdentity = $oid[$aclId];
$classType = $objectIdentity['type'];
$objectIdentifier = $objectIdentity['identifier'];
$entryObjectIdentity = isset($entry['objectIdentity']) ? $entry['objectIdentity'] : null;
$fieldName = isset($entry['fieldName']) ? $entry['fieldName'] : null;
$aceOrder = $entry['aceOrder'];
$grantingStrategy = $entry['grantingStrategy'];
$mask = (int) $entry['mask'];
$granting = $entry['granting'];
$auditFailure = $entry['auditFailure'];
$auditSuccess = $entry['auditSuccess'];
if (isset($acls[$aclId])) {
// the ACL been hydrated during this hydration cycle
$acl = $acls[$aclId];
} else {
if (isset($loadedAcls[$classType][$objectIdentifier])) {
// the ACL been hydrated during any previous cycle or loaded from cache
$acl = $loadedAcls[$classType][$objectIdentifier];
// keep reference in local array (saves us some hash calculations)
$acls[$aclId] = $acl;
// attach ACL to the result set; even though we do not enforce that every
// object identity has only one instance, we must make sure to maintain
// referential equality with the oids passed to findAcls()
$oidLookupKey = $objectIdentifier . $classType;
if (!isset($oidCache[$oidLookupKey])) {
$oidCache[$oidLookupKey] = $acl->getObjectIdentity();
}
$result->attach($oidCache[$oidLookupKey], $acl);
} else {
// this hasn't been hydrated yet
// create object identity if we haven't done so yet
$oidLookupKey = $objectIdentifier . $classType;
if (!isset($oidCache[$oidLookupKey])) {
$oidCache[$oidLookupKey] = new ObjectIdentity($objectIdentifier, $classType);
}
$acl = new Acl($aclId, $oidCache[$oidLookupKey], $permissionGrantingStrategy, $emptyArray, !!$objectIdentity['entriesInheriting']);
// keep a local, and global reference to this ACL
$loadedAcls[$classType][$objectIdentifier] = $acl;
$acls[$aclId] = $acl;
// try to fill in parent ACL, or defer until all ACLs have been hydrated
if (isset($objectIdentity['parent'])) {
$parentObjectIdentityId = (string) $objectIdentity['parent']['_id'];
if (isset($acls[$parentObjectIdentityId])) {
$aclParentAclProperty->setValue($acl, $acls[$parentObjectIdentityId]);
} else {
$parentIdToFill->attach($acl, $parentObjectIdentityId);
}
}
$result->attach($oidCache[$oidLookupKey], $acl);
}
}
// check if this row contains an ACE record
if (0 !== $aceId) {
// have we already hydrated ACEs for this ACL?
if (!isset($aces[$aclId])) {
$aces[$aclId] = array($emptyArray, $emptyArray, $emptyArray, $emptyArray);
}
// has this ACE already been hydrated during a previous cycle, or
// possible been loaded from cache?
// It is important to only ever have one ACE instance per actual row since
// some ACEs are shared between ACL instances
if (!isset($loadedAces[$aceId])) {
if (isset($entry['securityIdentity']['username'])) {
$securityId = '1' . $entry['securityIdentity']['username'];
if (!isset($sids[$securityId])) {
$sids[$securityId] = new UserSecurityIdentity($entry['securityIdentity']['username'], $entry['securityIdentity']['class']);
}
} else {
$securityId = '0' . $entry['securityIdentity']['role'];
if (!isset($sids[$securityId])) {
$sids[$securityId] = new RoleSecurityIdentity($entry['securityIdentity']['role']);
}
}
if (null === $fieldName) {
$loadedAces[$aceId] = new Entry($aceId, $acl, $sids[$securityId], $grantingStrategy, (int) $mask, !!$granting, !!$auditFailure, !!$auditSuccess);
} else {
$loadedAces[$aceId] = new FieldEntry($aceId, $acl, $fieldName, $sids[$securityId], $grantingStrategy, (int) $mask, !!$granting, !!$auditFailure, !!$auditSuccess);
}
}
$ace = $loadedAces[$aceId];
// assign ACE to the correct property
if (null === $entryObjectIdentity) {
if (null === $fieldName) {
$aces[$aclId][0][$aceOrder] = $ace;
} else {
$aces[$aclId][1][$fieldName][$aceOrder] = $ace;
}
} else {
if (null === $fieldName) {
$aces[$aclId][2][$aceOrder] = $ace;
} else {
$aces[$aclId][3][$fieldName][$aceOrder] = $ace;
}
}
}
}
}
// We do not sort on database level since we only want certain subsets to be sorted,
// and we are going to read the entire result set anyway.
// Sorting on DB level increases query time by an order of magnitude while it is
// almost negligible when we use PHPs array sort functions.
foreach ($aces as $aclId => $aceData) {
$acl = $acls[$aclId];
ksort($aceData[0]);
$aclClassAcesProperty->setValue($acl, $aceData[0]);
foreach (array_keys($aceData[1]) as $fieldName) {
ksort($aceData[1][$fieldName]);
}
$aclClassFieldAcesProperty->setValue($acl, $aceData[1]);
ksort($aceData[2]);
$aclObjectAcesProperty->setValue($acl, $aceData[2]);
foreach (array_keys($aceData[3]) as $fieldName) {
ksort($aceData[3][$fieldName]);
}
$aclObjectFieldAcesProperty->setValue($acl, $aceData[3]);
}
// fill-in parent ACLs where this hasn't been done yet cause the parent ACL was not yet available
$processed = 0;
foreach ($parentIdToFill as $acl) {
$parentId = $parentIdToFill->offsetGet($acl);
// let's see if we have already hydrated this
if (isset($acls[$parentId])) {
$aclParentAclProperty->setValue($acl, $acls[$parentId]);
$processed += 1;
continue;
}
}
// reset reflection changes
$aclClassAcesProperty->setAccessible(false);
$aclClassFieldAcesProperty->setAccessible(false);
$aclObjectAcesProperty->setAccessible(false);
$aclObjectFieldAcesProperty->setAccessible(false);
$aclParentAclProperty->setAccessible(false);
// this should never be true if the database integrity hasn't been compromised
if ($processed < count($parentIdToFill)) {
throw new \RuntimeException('Not all parent ids were populated. This implies an integrity problem.');
}
return $result;
}
public function offsetGet($object)
{
$this->initialize();
return parent::offsetGet($object);
}
/**
* @deprecated Using the SplObjectStorage API on the Crawler is deprecated as of 2.8 and will be removed in 3.0.
*/
public function offsetGet($object)
{
@trigger_error('The ' . __METHOD__ . ' method is deprecated as of 2.8 and will be removed in 3.0.', E_USER_DEPRECATED);
return parent::offsetGet($object);
}
/**
* Generates the inline definition of a service.
*
* @param string $id
* @param Definition $definition
*
* @return string
*
* @throws \RuntimeException When the factory definition is incomplete
* @throws ServiceCircularReferenceException When a circular reference is detected
*/
private function addServiceInlinedDefinitions($id, $definition)
{
$code = '';
$variableMap = $this->definitionVariables;
$nbOccurrences = new \SplObjectStorage();
$processed = new \SplObjectStorage();
$inlinedDefinitions = $this->getInlinedDefinitions($definition);
foreach ($inlinedDefinitions as $definition) {
if (false === $nbOccurrences->contains($definition)) {
$nbOccurrences->offsetSet($definition, 1);
} else {
$i = $nbOccurrences->offsetGet($definition);
$nbOccurrences->offsetSet($definition, $i + 1);
}
}
foreach ($inlinedDefinitions as $sDefinition) {
if ($processed->contains($sDefinition)) {
continue;
}
$processed->offsetSet($sDefinition);
$class = $this->dumpValue($sDefinition->getClass());
if ($nbOccurrences->offsetGet($sDefinition) > 1 || count($sDefinition->getMethodCalls()) > 0 || $sDefinition->getProperties() || null !== $sDefinition->getConfigurator() || false !== strpos($class, '$')) {
$name = $this->getNextVariableName();
$variableMap->offsetSet($sDefinition, new Variable($name));
// a construct like:
// $a = new ServiceA(ServiceB $b); $b = new ServiceB(ServiceA $a);
// this is an indication for a wrong implementation, you can circumvent this problem
// by setting up your service structure like this:
// $b = new ServiceB();
// $a = new ServiceA(ServiceB $b);
// $b->setServiceA(ServiceA $a);
if ($this->hasReference($id, $sDefinition->getArguments())) {
throw new ServiceCircularReferenceException($id, array($id));
}
$arguments = array();
foreach ($sDefinition->getArguments() as $argument) {
$arguments[] = $this->dumpValue($argument);
}
if (null !== $sDefinition->getFactoryMethod()) {
if (null !== $sDefinition->getFactoryClass()) {
$code .= sprintf(" \$%s = call_user_func(array(%s, '%s')%s);\n", $name, $this->dumpValue($sDefinition->getFactoryClass()), $sDefinition->getFactoryMethod(), count($arguments) > 0 ? ', ' . implode(', ', $arguments) : '');
} elseif (null !== $sDefinition->getFactoryService()) {
$code .= sprintf(" \$%s = %s->%s(%s);\n", $name, $this->getServiceCall($sDefinition->getFactoryService()), $sDefinition->getFactoryMethod(), implode(', ', $arguments));
} else {
throw new RuntimeException('Factory service or factory class must be defined in service definition for ' . $id);
}
} elseif (false !== strpos($class, '$')) {
$code .= sprintf(" \$class = %s;\n \$%s = new \$class(%s);\n", $class, $name, implode(', ', $arguments));
} else {
$code .= sprintf(" \$%s = new \\%s(%s);\n", $name, substr(str_replace('\\\\', '\\', $class), 1, -1), implode(', ', $arguments));
}
if (!$this->hasReference($id, $sDefinition->getMethodCalls()) && !$this->hasReference($id, $sDefinition->getProperties())) {
$code .= $this->addServiceMethodCalls(null, $sDefinition, $name);
$code .= $this->addServiceProperties(null, $sDefinition, $name);
$code .= $this->addServiceConfigurator(null, $sDefinition, $name);
}
$code .= "\n";
}
}
return $code;
}
