/** * Remove the given log message handler if it is registered. * * @param LogHandler $handler */ public function removeHandler(LogHandler $handler) { if ($this->handlers->contains($handler)) { $this->handlers->detach($handler); $this->enabled = $this->handlers->count() ? true : false; } }
protected function shouldShutDownMessenger(Messenger $messenger) { if ($this->callQueue->count() == 0 && $this->pool->count() > $this->options['min_size']) { unset($this->coreMessengerMapping[spl_object_hash($messenger)]); $this->pool->detach($messenger); $messenger->softTerminate(); return; } $this->readyPool->enqueue($messenger); }
/** * @param $pos * * @return null|AbstractSQLConnection */ public function getConnectionByPosition($pos) { $pos = (int) $pos; $this->storage->rewind(); for ($i = 0; $this->storage->count() > $i; $i++) { if ($i === $pos) { return $this->storage->current(); } $this->storage->next(); } return null; }
/** * @see ArrayAccess::offsetExists() */ public function offsetExists($offset) { if ($this->container->count()) { $result = true; /* @var $keyValue \ArrayAccess */ foreach ($this->container as $keyValue) { $result = $result && $keyValue->offsetExists($offset); } return $result; } else { return false; } }
/** * @inheritDoc */ public function getLink(Driver $driver, Query $query) { if (!$this->idle->isEmpty()) { return $this->idle->dequeue(); } if ($this->pool->count() >= $this->params['max_connections']) { $this->waiting->enqueue($query); return false; } $link = $driver->connect($this->params, $this->params['username'], $this->params['passwd']); $this->pool->attach($link); return $link; }
/** * @coroutine * * @return \Generator * * @resolve \Icicle\Postgres\Connection */ private function pop() : \Generator { while (null !== $this->awaitable) { try { (yield $this->awaitable); // Prevent simultaneous connection creation. } catch (\Throwable $exception) { // Ignore failure or cancellation of other operations. } } if ($this->idle->isEmpty()) { try { if ($this->connections->count() >= $this->getMaxConnections()) { // All possible connections busy, so wait until one becomes available. $this->awaitable = new Delayed(); (yield $this->awaitable); } else { // Max connection count has not been reached, so open another connection. $this->awaitable = new Coroutine($this->createConnection()); $this->addConnection((yield $this->awaitable)); } } finally { $this->awaitable = null; } } // Shift a connection off the idle queue. return $this->idle->shift(); }
protected function getVarId(Operand $var) { if (isset($this->varIds[$var])) { return $this->varIds[$var]; } else { return $this->varIds[$var] = $this->varIds->count() + 1; } }
public function withConnection($cb) { // First check idle connections. if ($this->available->count() > 0) { $connection = $this->available->dequeue(); $cb($connection); return; } // Check if we have max connections if ($this->pool->count() >= $this->maxConnections) { $this->waiting->enqueue($cb); } // Otherwise, create a new connection $connection = ConnectionFactory::createConnection(); $this->pool->attach($connection); $cb($connection); }
/** * @return ResourceObject|mixed */ private function invoke() { if ($this->requests->count() === 0) { return $this->invoker->invoke($this->request); } $this->requests->attach($this->request); return $this->invoker->invokeSync($this->requests); }
/** * @param \Sitemapper\SitemapInterface $sitemap */ public function addSitemap(SitemapInterface $sitemap) { $this->boot(); $this->sitemaps->attach($sitemap); $index = $this->sitemaps->count(); $sitemap->setLocation($this->getLocation($index)); $this->sitemaps->offsetSet($sitemap, $index); $this->indexSitemap->addSitemap($sitemap); }
protected function findReturnBlocks(Block $block, $result = []) { $toProcess = new \SplObjectStorage(); $processed = new \SplObjectStorage(); $results = new \SplObjectStorage(); $addNull = false; $toProcess->attach($block); while ($toProcess->count() > 0) { foreach ($toProcess as $block) { $toProcess->detach($block); $processed->attach($block); foreach ($block->children as $op) { if ($op instanceof Op\Terminal\Return_) { $results->attach($op); continue 2; // Prevent dead code from executing } elseif ($op instanceof Op\Terminal\Throw_) { // throws are ok continue 2; } elseif ($op instanceof Op\Stmt\Jump) { if (!$processed->contains($op->target)) { $toProcess->attach($op->target); } continue 2; } elseif ($op instanceof Op\Stmt\JumpIf) { if (!$processed->contains($op->if)) { $toProcess->attach($op->if); } if (!$processed->contains($op->else)) { $toProcess->attach($op->else); } continue 2; } elseif ($op instanceof Op\Stmt\Switch_) { foreach ($op->targets as $target) { if (!is_array($target)) { // TODO FIX THIS $target = [$target]; } foreach ($target as $t) { if (!$processed->contains($t)) { $toProcess->attach($t); } } } continue 2; } } // If we reach here, we have an empty return default block, add it to the result $addNull = true; } } $results = iterator_to_array($results); if ($addNull) { $results[] = null; } return $results; }
/** * @param null|mixed|array $models (optional) */ public function commit($models = null) { $pool = $this->manager->getPool(); /** @var ObjectManager[] $managers */ $managers = $pool->getIterator(); if (null === $models) { foreach ($managers as $manager) { $manager->flush(); } if (!$this->models->count()) { return; } $this->models->rewind(); while ($this->models->valid()) { $model = $this->models->current(); $class = $this->manager->getClassMetadata(get_class($model)); $managerName = $class->getManagerReferenceGenerator(); $ref = call_user_func(array($model, 'get' . ucfirst($managerName))); $id = call_user_func(array($ref, 'get' . ucfirst($class->getIdentifierReference($managerName)->referenceField))); foreach ($this->models->getInfo() as $managerName) { $this->saveSpecificModel($model, $managerName, $id); } $this->models->next(); } // clear list $this->models = new \SplObjectStorage(); } else { if (!is_array($models)) { $models = array($models); } foreach ($models as $model) { $class = $this->manager->getClassMetadata(get_class($model)); $managerName = $class->getManagerReferenceGenerator(); $ref = call_user_func(array($model, 'get' . ucfirst($managerName))); $pool->getManager($managerName)->flush($ref); $id = call_user_func(array($ref, 'get' . ucfirst($class->getIdentifierReference($managerName)->referenceField))); foreach ($class->getFieldManagerNames() as $managerName) { $this->saveSpecificModel($model, $managerName, $id); } } } }
public function createRelationsContent(ClassMetadataInterface $classMetadata, $object) { $relationsContent = new \SplObjectStorage(); foreach ($classMetadata->getRelations() as $relationMetadata) { if (null === $relationMetadata->getContent()) { continue; } $relationsContent->attach($relationMetadata, $this->getContent($relationMetadata, $object)); } return $relationsContent->count() === 0 ? null : $relationsContent; }
/** * {@inheritdoc} */ public function run() { $this->running = true; while ($this->running) { $this->nextTickQueue->tick(); $this->futureTickQueue->tick(); $flags = \Ev::RUN_ONCE; if (!$this->running || !$this->nextTickQueue->isEmpty() || !$this->futureTickQueue->isEmpty()) { $flags |= \Ev::RUN_NOWAIT; } elseif (!$this->readEvents && !$this->writeEvents && !$this->timerEvents->count()) { break; } $this->loop->run($flags); } }
/** * Performs the pipeline of callbacks to initial data. * It is possible to set an starting value, and to specify if that starting value has to be * casted (only has effect if a caster is set). * * @param mixed $initial * @param \Toobo\PipePie\DTO $dto * @param mixed $cursor * @return mixed */ public function applyTo($initial, DTO $dto = null, $cursor = null) { if ($this->working) { throw new LogicException("It is not possible run a Pipeline that is already working."); } if ($this->pipeline->count() === 0) { return $initial; } $this->DTOs->push($this->init($dto, $initial)); $carry = $this->initialValue($initial, $cursor); while ($this->pipeline->valid()) { $carry = $this->run($initial, $carry); $this->pipeline->next(); } $this->working = false; return $carry; }
/** * @return RequestHandler */ protected function nextRequest() { if ($this->pendingRequests->count() > 0) { $this->pendingRequests->rewind(); $handler = $this->pendingRequests->current(); $handler->incrementAttempts(); $this->pendingRequests->detach($handler); } else { $request = $this->requestProvider->nextRequest(); if ($request instanceof Request) { $handler = new RequestHandler($request); } else { $this->requestProviderEmpty = true; $handler = null; } } return $handler; }
/** * @param \SplObjectStorage $param * * @return \SplObjectStorage */ public function filter($param = null) : \SplObjectStorage { if (!$param) { return new \SplObjectStorage(); } if ($param->count() === 1) { return $param; } $idValue = $returnNode = null; $returnCollection = new \SplObjectStorage(); foreach ($param as $node) { if (!$idValue || $this->compare($node->getId(), $idValue)) { $idValue = $node->getId(); $returnNode = $node; } } $returnCollection->attach($returnNode); return $returnCollection; }
/** * Attach a new Model Object by storing a new Meta ArrayObject * * @param Yada_Model $model * @param mixed $values * @return Yada_Model */ public function attach(Yada_Model $model, $values = NULL) { // Get the class and common name of the Model $class = get_class($model); $name = Yada::common_name('model', $class); $plural = inflector::plural($name); $index = $this->_models->count(); // Create a new ArrayObject to act as the Meta Object and initialize some properties $this->_meta = new ArrayObject(array('name' => $name, 'class' => $class, 'plural' => $plural, 'index' => $index, 'alias' => $index . '_' . $name, 'fields' => array(), 'clauses' => array(), 'select' => array(), 'exclude' => array(), 'mapper' => NULL, 'collect' => NULL), ArrayObject::ARRAY_AS_PROPS); // Initialize objects of derived Meta classes $this->_attach($this->_meta, $values); // Attach the model and meta data, set the focus $this->_models->attach($model, $this->_meta); $this->_current = $model; // Initialize the Model $model::initialize($model, $this); // Initialize the Mapper Object $this->_meta['mapper'] = Yada::mapper($this, $model, $values); // Register aggregate methods $this->export($model); // return the model return $model; }
public function __construct($dom) { $this->alreadyMatched = new SplObjectStorage(); $matches = new SplObjectStorage(); if (is_array($dom) || $dom instanceof SplObjectStorage) { foreach ($dom as $item) { if ($item instanceof DOMNode && $item->nodeType == XML_ELEMENT_NODE) { $matches->attach($item); } } if ($matches->count() > 0) { $matches->rewind(); $this->dom = $matches->current(); } else { $this->dom = NULL; } $this->matches = $matches; } elseif ($dom instanceof DOMDocument) { $this->dom = $dom->documentElement; $matches->attach($dom->documentElement); } elseif ($dom instanceof DOMElement) { $this->dom = $dom; $matches->attach($dom); } elseif ($dom instanceof DOMNodeList) { $a = array(); foreach ($dom as $item) { if ($item->nodeType == XML_ELEMENT_NODE) { $matches->attach($item); $a[] = $item; } } $this->dom = $a; } else { throw new Exception("Unhandled type: " . get_class($dom)); } $this->matches = $matches; }
<?php try { $s = new SplObjectStorage(); $s->unserialize('s:31:"something which is not an array";'); } catch (UnexpectedValueException $e) { var_dump($e->getMessage()); } var_dump($s->count() == 0); echo "===RUN2===\n"; try { $s = new SplObjectStorage(); $s->unserialize('s:60:"something broken";'); } catch (UnexpectedValueException $e) { var_dump($e->getMessage()); } var_dump($s->count() == 0);
/** * Check if object has neighbors * * @return bool */ public function hasNeighbors() { return $this->neighbors->count() > 0; }
/** * @return boolean */ public function hasChildren() { return 0 < $this->children->count(); }
/** * (non-PHPdoc) * @see Countable::count() */ public function count() { return $this->rows->count(); }
/** * {@inheritdoc} */ public function order() { return $this->vertices->count(); }
public function count() { if (is_array($this->objectIdentifiers)) { return count($this->objectIdentifiers); } else { return parent::count(); } }
/** * Checks if there are any unsuccessful requests at all. * * @return bool */ public function hasExceptions() { return $this->exceptions->count() > 0; }
/** * Count elements of an object * * @link http://php.net/manual/en/countable.count.php * @return int The custom count as an integer. * </p> * <p> * The return value is cast to an integer. * @since 5.1.0 */ public function count() { return $this->collection->count(); }
/** * {@inheritdoc} */ public function count() { return $this->cookies->count(); }
/** * Create a new event handler. */ public function __construct($dom) { $this->alreadyMatched = new \SplObjectStorage(); $matches = new \SplObjectStorage(); // Array of DOMElements if (is_array($dom) || $dom instanceof \SplObjectStorage) { //$matches = array(); foreach ($dom as $item) { if ($item instanceof \DOMNode && $item->nodeType == XML_ELEMENT_NODE) { //$matches[] = $item; $matches->attach($item); } } //$this->dom = count($matches) > 0 ? $matches[0] : NULL; if ($matches->count() > 0) { $matches->rewind(); $this->dom = $matches->current(); } else { //throw new Exception("Setting DOM to Null"); $this->dom = NULL; } $this->matches = $matches; } elseif ($dom instanceof \DOMDocument) { $this->dom = $dom->documentElement; $matches->attach($dom->documentElement); } elseif ($dom instanceof \DOMElement) { $this->dom = $dom; $matches->attach($dom); } elseif ($dom instanceof \DOMNodeList) { $a = array(); // Not sure why we are doing this.... foreach ($dom as $item) { if ($item->nodeType == XML_ELEMENT_NODE) { $matches->attach($item); $a[] = $item; } } $this->dom = $a; } else { throw new \QueryPath\Exception("Unhandled type: " . get_class($dom)); } $this->matches = $matches; }
/** * {@inheritdoc} */ public function findAcls(array $oids, array $sids = array()) { $result = new \SplObjectStorage(); $currentBatch = array(); $oidLookup = array(); for ($i = 0, $c = count($oids); $i < $c; $i++) { $oid = $oids[$i]; $oidLookupKey = $oid->getIdentifier() . $oid->getType(); $oidLookup[$oidLookupKey] = $oid; $aclFound = false; // check if result already contains an ACL if ($result->contains($oid)) { $aclFound = true; } // check if this ACL has already been hydrated if (!$aclFound && isset($this->loadedAcls[$oid->getType()][$oid->getIdentifier()])) { $acl = $this->loadedAcls[$oid->getType()][$oid->getIdentifier()]; if (!$acl->isSidLoaded($sids)) { // FIXME: we need to load ACEs for the missing SIDs. This is never // reached by the default implementation, since we do not // filter by SID throw new \RuntimeException('This is not supported by the default implementation.'); } else { $result->attach($oid, $acl); $aclFound = true; } } // check if we can locate the ACL in the cache if (!$aclFound && null !== $this->cache) { $acl = $this->cache->getFromCacheByIdentity($oid); if (null !== $acl) { if ($acl->isSidLoaded($sids)) { // check if any of the parents has been loaded since we need to // ensure that there is only ever one ACL per object identity $parentAcl = $acl->getParentAcl(); while (null !== $parentAcl) { $parentOid = $parentAcl->getObjectIdentity(); if (isset($this->loadedAcls[$parentOid->getType()][$parentOid->getIdentifier()])) { $acl->setParentAcl($this->loadedAcls[$parentOid->getType()][$parentOid->getIdentifier()]); break; } else { $this->loadedAcls[$parentOid->getType()][$parentOid->getIdentifier()] = $parentAcl; $this->updateAceIdentityMap($parentAcl); } $parentAcl = $parentAcl->getParentAcl(); } $this->loadedAcls[$oid->getType()][$oid->getIdentifier()] = $acl; $this->updateAceIdentityMap($acl); $result->attach($oid, $acl); $aclFound = true; } else { $this->cache->evictFromCacheByIdentity($oid); foreach ($this->findChildren($oid) as $childOid) { $this->cache->evictFromCacheByIdentity($childOid); } } } } // looks like we have to load the ACL from the database if (!$aclFound) { $currentBatch[] = $oid; } // Is it time to load the current batch? $currentBatchesCount = count($currentBatch); if ($currentBatchesCount > 0 && (self::MAX_BATCH_SIZE === $currentBatchesCount || $i + 1 === $c)) { try { $loadedBatch = $this->lookupObjectIdentities($currentBatch, $sids, $oidLookup); } catch (AclNotFoundException $aclNotFoundException) { if ($result->count()) { $partialResultException = new NotAllAclsFoundException('The provider could not find ACLs for all object identities.'); $partialResultException->setPartialResult($result); throw $partialResultException; } else { throw $aclNotFoundException; } } foreach ($loadedBatch as $loadedOid) { $loadedAcl = $loadedBatch->offsetGet($loadedOid); if (null !== $this->cache) { $this->cache->putInCache($loadedAcl); } if (isset($oidLookup[$loadedOid->getIdentifier() . $loadedOid->getType()])) { $result->attach($loadedOid, $loadedAcl); } } $currentBatch = array(); } } // check that we got ACLs for all the identities foreach ($oids as $oid) { if (!$result->contains($oid)) { if (1 === count($oids)) { $objectName = method_exists($oid, '__toString') ? $oid : get_class($oid); throw new AclNotFoundException(sprintf('No ACL found for %s.', $objectName)); } $partialResultException = new NotAllAclsFoundException('The provider could not find ACLs for all object identities.'); $partialResultException->setPartialResult($result); throw $partialResultException; } } return $result; }