public function addText(SimpleToken $text, $parent = null) { if ($parent) { $parent->addChild($text->getValue()); } else { parent::push($text->getValue()); } }
function get_result($t, $ladders, $snakes) { fill_graph($t, $ladders); fill_graph($t, $snakes); $len = count($t); $vertices = array(); for ($k = 0; $k < $len; $k++) { $vertices[$k] = new vertex($k); } $adjacencyList = array(); for ($u = 0; $u < $len; $u++) { $list = new SplDoublyLinkedList(); for ($v = 0; $v < $len; $v++) { if ($t[$u][$v] != 0) { $list->push(array('vertex' => $vertices[$v], 'distance' => $t[$u][$v])); } } $list->rewind(); $adjacencyList[] = $list; } calcShortestPaths($vertices[0], $adjacencyList); $path = end($vertices)->path; $result = $p = 0; for ($n = 0; $n < count($path); $n++) { $p++; if (@$path[$n + 1] - $path[$n] != 1) { $result = $result + ceil(($p - 1) / 6); $p = 0; } } //echo "[" . implode(', ', $path) . "]\n\n"; return $result; }
function resetCreateGlobalVars() { global $v0, $v1, $v2, $v3, $v4, $v5, $list0, $list1, $list2, $list3, $list4, $list5, $adjacencyList; $v0 = new vertex(0); $v1 = new vertex(1); $v2 = new vertex(2); $v3 = new vertex(3); $v4 = new vertex(4); $v5 = new vertex(5); $list0 = new SplDoublyLinkedList(); $list0->push(array('vertex' => $v1, 'distance' => 3)); $list0->push(array('vertex' => $v3, 'distance' => 1)); $list0->rewind(); $list1 = new SplDoublyLinkedList(); $list1->push(array('vertex' => $v0, 'distance' => 3)); $list1->push(array('vertex' => $v2, 'distance' => 7)); $list1->rewind(); $list2 = new SplDoublyLinkedList(); $list2->push(array('vertex' => $v1, 'distance' => 7)); $list2->push(array('vertex' => $v3, 'distance' => 8)); $list2->push(array('vertex' => $v4, 'distance' => 12)); $list2->rewind(); $list3 = new SplDoublyLinkedList(); $list3->push(array('vertex' => $v0, 'distance' => 1)); $list3->push(array('vertex' => $v2, 'distance' => 8)); $list3->rewind(); $list4 = new SplDoublyLinkedList(); $list4->push(array('vertex' => $v2, 'distance' => 12)); $list4->push(array('vertex' => $v5, 'distance' => 3)); $list4->rewind(); $list5 = new SplDoublyLinkedList(); $list5->push(array('vertex' => $v4, 'distance' => 3)); $list5->rewind(); $adjacencyList = array($list0, $list1, $list2, $list3, $list4, $list5); }
/** * {@inheritdoc} */ public function getOpcode() { if (count($this->_frames) == 0) { throw new \UnderflowException('No frames have been added to this message'); } return $this->_frames->bottom()->getOpcode(); }
function __construct() { $this->listClients = new SplDoublyLinkedList(); //=========================load file===============================// $read = new ReadCsv(); $lisClient = $read->get2DArrayFromCsv('files/clientes.csv', ','); foreach ($lisClient as $row => $data) { $listProductByClient = new SplDoublyLinkedList(); $contLines = 0; $codeProduct = 0; foreach ($data as $rowL => $dataL) { if ($rowL > 1 && $dataL != "") { if ($contLines == 0) { $codeProduct = $dataL; $contLines++; } else { $listProdCliente = new ListaProductosPorCliente(); $listProdCliente->setIdProducto($codeProduct); $listProdCliente->setProducto($dataL); $listProductByClient->push($listProdCliente); $contLines--; } } } $client1 = new Clientes(); $client1->setName($data[0]); $client1->setId($data[1]); $client1->setListPruductByClient($listProductByClient); $this->listClients->push($client1); } //=========================//load file=============================// $this->listClients->serialize(); //$this->loadFile(); }
/** * @param $vertex * @return \SplDoublyLinkedList */ public function createTransitionsList($vertex) { $list = new \SplDoublyLinkedList(); $list->setIteratorMode(\SplDoublyLinkedList::IT_MODE_FIFO | \SplDoublyLinkedList::IT_MODE_KEEP); $list->push($vertex); return $list; }
/** * @todo make recursive * * Reads a stream character for character until the suffix ('e') is found * and returns the remainder of the string. * * @param string $stream Reads the stream into the buffer. * * @throws Bencode\Exceptions\IntegerException */ public function decode($stream) { $flag = false; $stream = str_split($stream); $buffer = ''; $size = count($stream); $stack = new \SplDoublyLinkedList(); for ($i = 0; $i < $size - 1; $i++) { if ($flag) { if (is_numeric($stream[$i]) || $stream[$i] === '-') { $stack->push($stream[$i]); } } if ($stream[$i] === 'i') { $flag = true; } if ($stream[$i] === 'e') { $flag = false; unset($stream[$i]); break; } unset($stream[$i]); } foreach ($stack as $s) { $buffer .= $s; } $this->_buffer = $buffer; return implode('', array_values($stream)); }
/** * Reads a stream and decodes the byte character by character. This method * will return the remainder of the stream. * * @param string $stream The stream to be decoded. * @return string The remainder of the stream, if any. */ public function decode($stream) { $stream = str_split($stream); $buffer = ''; $size = count($stream); $sizeList = new \SplDoublyLinkedList(); $bufList = new \SplDoublyLinkedList(); // read the size of the byte from the stream for ($i = 0; $i < count($stream); $i++) { $temp = $stream[$i]; unset($stream[$i]); if ($temp === ':') { break; } $sizeList->push($temp); } $stream = array_values($stream); $size = 0; foreach ($sizeList as $sl) { $size .= $sl; } // read the length of the byte from the stream for ($i = 0; $i < $size; $i++) { $bufList->push($stream[$i]); unset($stream[$i]); } // read the byte into the buffer foreach ($bufList as $bl) { $buffer .= $bl; } $this->_buffer = $buffer; return implode('', array_values($stream)); }
public function resolve($obj) { $result = new \SplDoublyLinkedList(); foreach ($obj as $value) { $result->push($value); } return $result; }
public static function castDoublyLinkedList(\SplDoublyLinkedList $c, array $a, Stub $stub, $isNested) { $mode = $c->getIteratorMode(); $c->setIteratorMode(\SplDoublyLinkedList::IT_MODE_KEEP | $mode & ~\SplDoublyLinkedList::IT_MODE_DELETE); $a += array("~mode" => new ConstStub(($mode & \SplDoublyLinkedList::IT_MODE_LIFO ? 'IT_MODE_LIFO' : 'IT_MODE_FIFO') . ' | ' . ($mode & \SplDoublyLinkedList::IT_MODE_KEEP ? 'IT_MODE_KEEP' : 'IT_MODE_DELETE'), $mode), "~dllist" => iterator_to_array($c)); $c->setIteratorMode($mode); return $a; }
public static function castDoublyLinkedList(\SplDoublyLinkedList $c, array $a, Stub $stub, $isNested) { $prefix = Caster::PREFIX_VIRTUAL; $mode = $c->getIteratorMode(); $c->setIteratorMode(\SplDoublyLinkedList::IT_MODE_KEEP | $mode & ~\SplDoublyLinkedList::IT_MODE_DELETE); $a += array($prefix . 'mode' => new ConstStub(($mode & \SplDoublyLinkedList::IT_MODE_LIFO ? 'IT_MODE_LIFO' : 'IT_MODE_FIFO') . ' | ' . ($mode & \SplDoublyLinkedList::IT_MODE_KEEP ? 'IT_MODE_KEEP' : 'IT_MODE_DELETE'), $mode), $prefix . 'dllist' => iterator_to_array($c)); $c->setIteratorMode($mode); return $a; }
public function process($index, \SplDoublyLinkedList $list) { $first = $list->offsetGet($index - 1); $second = $list->offsetGet($index + 1); $result = $first * $second; $list->offsetSet($index - 1, $result); unset($list[$index]); unset($list[$index]); }
function test(SplDoublyLinkedList $l) { $l->push("a"); $l->push("b"); $l->push("c"); echo "ArrayAccess Unset:", PHP_EOL; unset($l[0]); var_dump($l[0]); echo PHP_EOL; }
/** * {@inheritdoc} */ public function tokenize($userAgent) { $iterator = new \SplDoublyLinkedList(); $iterator->setIteratorMode(\SplDoublyLinkedList::IT_MODE_FIFO); foreach ($this->getTokens($userAgent) as $position => $token) { $token = trim($token); $iterator->push(new Node($token, $position, $this->resolveType($token))); } return $iterator; }
public function process($index, \SplDoublyLinkedList $list) { $first = $list->offsetGet($index - 1); $second = $list->offsetGet($index + 1); if ($second == 0) { throw new \Exception('zero division error'); } $result = $first / $second; $list->offsetSet($index - 1, $result); unset($list[$index]); unset($list[$index]); }
public function testPHPUnitCommand() { // need an explicit Traversable $skippedPaths = new \SplDoublyLinkedList(); $skippedPaths->push('a'); $skippedPaths->push('b'); // going for 'bang for the buck' here re: test converage $task = (new \Robo\Task\ApiGen\ApiGen('apigen'))->config('./apigen.neon')->source('src')->extensions('php')->exclude(array('test', 'tmp'))->skipDocPath($skippedPaths)->charset(array('utf8', 'iso88591'))->internal('no')->php(true)->tree('Y')->debug('n'); $cmd = 'apigen --config ./apigen.neon --source src --extensions php --exclude test --exclude tmp --skip-doc-path a --skip-doc-path b --charset \'utf8,iso88591\' --internal no --php yes --tree yes --debug no'; verify($task->getCommand())->equals($cmd); $task->run(); $this->apigen->verifyInvoked('executeCommand', [$cmd]); }
/** * Gets an iterator that iterates over each article. * * This list is never cached. * * @param bool $unpublished Whether articles not yet published should be fetched. */ public function getIterator($unpublished = false) : \Iterator { $articles = new \SplDoublyLinkedList(); foreach (new \GlobIterator($this->path . '/*.md') as $file) { if ($file->isFile()) { $article = $this->getArticleFromFile($file->getFilename()); if ($unpublished || !$article->date()->isFuture()) { $articles->unshift($article); } } } return new \IteratorIterator($articles); }
/** * Returns true, if the item has any listeners. * * @return Boolean */ public function hasListeners() { if ($this->_listeners === null) { return false; } return $this->_listeners->count() > 0; }
/** * Retrieve the maintenance task entry, from unique identfier * @param $maintenanceTaskEntryIdentifier Identifier to locate entry * @return mixed|null Returns the maintenance task entry or null on error * @throws InvalidArgumentException if the provided argument is not set or of correct type */ public function retrieveMaintenanceTaskEntry($maintenanceTaskEntryIdentifier) { if (!isset($maintenanceTaskEntryIdentifier)) { //argument check throw new InvalidArgumentException("Missing Argument"); } else { if (!is_numeric($maintenanceTaskEntryIdentifier)) { //argument check throw new InvalidArgumentException("maintenanceTaskEntryIdentifier is not a number"); } } if ($this->maintenanceTaskList->isEmpty()) { //if list is empty, unable to return entry return null; } else { $this->maintenanceTaskList->setIteratorMode(SplDoublyLinkedList::IT_MODE_FIFO); //set iteration FIFO for ($this->maintenanceTaskList->rewind(); $this->maintenanceTaskList->valid(); $this->maintenanceTaskList->next()) { if ($this->maintenanceTaskList->current()->getTaskEntryIdentifier() == $maintenanceTaskEntryIdentifier) { //if entry identifier matches supplied identifier return $this->maintenanceTaskList->current(); } //return the matching entry } } return null; //entry with given identifier not found }
/** * Dispatch * @return mixed */ private function dispatch() { // for each route for (; $this->routes->valid(); $this->routes->next()) { $route = $this->routes->current(); // if method is OK if (strtoupper($route['method']) === $this->method || $route['method'] === '*') { $regex = $this->normalizeRegex($route['path']); // if path is OK if (preg_match("@^{$regex}@", $this->uri, $matches)) { $callback = $route['callback']; $req = new \ArrayObject(); $req->params = (object) $matches; $req->uri = $this->uri; $req->path = $this->path; $req->query = $this->query; if ($this->method !== 'GET') { if (!isset($data)) { parse_str(file_get_contents("php://input"), $data); } $req->body = $data; } $that = $this; $next = function () use($that) { $that->routes->next(); $that->dispatch(); }; return $callback($req, $next); } } } }
/** * (excerpt from http://docs.hhvm.com/manual/en/splstack.setiteratormode.php) * * * @mode mixed There is only one iteration parameter you can * modify. The behavior of the iterator (either one or * the other): SplDoublyLinkedList::IT_MODE_DELETE * (Elements are deleted by the iterator) * SplDoublyLinkedList::IT_MODE_KEEP (Elements are * traversed by the iterator) * * The default mode is 0x2 : * SplDoublyLinkedList::IT_MODE_LIFO | * SplDoublyLinkedList::IT_MODE_KEEP Warning * * The direction of iteration can no longer be changed * for SplStacks. Trying to do so will result in a * RuntimeException being thrown. * * @return mixed No value is returned. */ public function setIteratorMode($mode) { if (($mode & self::IT_MODE_LIFO) == 0) { throw new RuntimeException('Iterators\' LIFO/FIFO modes for SplStack/SplQueue objects are frozen'); } parent::setIteratorMode($mode); }
/** * {@inheritdoc} */ public function handle(Exception $exception) { if ($this->rethrow) { throw $exception; } foreach ($this->handlers as $index => $handler) { try { if (is_string($handler)) { $handler = $this->resolver->resolve($handler); $this->handlers->offsetSet($index, $handler); } else { if (is_array($handler) && is_string($handler[0])) { $handler[0] = $this->resolver->resolve($handler[0]); $this->handlers->offsetSet($index, $handler); } } if (!$this->matchesTypehint($handler, $exception)) { continue; } $result = $this->callHandler($handler, $exception); if ($result !== null) { return $this->makeResponse($result, $exception); } } catch (Exception $newException) { return $this->handle($newException); } } return $this->makeResponse($this->defaultHandler->handle($exception), $exception); }
/** * @return boolean */ public function isBinary() { if ($this->_frames->isEmpty()) { throw new \UnderflowException('Not enough data has been received to determine if message is binary'); } return Frame::OP_BINARY === $this->_frames->bottom()->getOpcode(); }
/** * @param VisitAction $futureVisitAction * @param Expression $lastVisitedExpression * @return \SplDoublyLinkedList */ protected function prepareQueueForFutureVisits(VisitAction $futureVisitAction = null, Expression $lastVisitedExpression) { $stackForExpressions = new \SplDoublyLinkedList(); if ($lastVisitedExpression instanceof ExpressionIterable) { foreach ($lastVisitedExpression as $futureVisit) { $stackForExpressions->push($futureVisit); } } else { if ($lastVisitedExpression instanceof ExpressionAggregate) { $futureVisit = $lastVisitedExpression->getExpression(); $stackForExpressions->push($futureVisit); } } if ($futureVisitAction instanceof VisitAction) { $stackForExpressions->push($futureVisitAction); } return $stackForExpressions; }
/** * Perform a depth-first traversal on the provided graph. * * @param Digraph $graph * The graph on which to perform the depth-first search. * @param DepthFirstVisitorInterface $visitor * The visitor object to use during the traversal. * @param object|\SplDoublyLinkedList $start * A vertex, or vertices, to use as start points for the traversal. There * are a few sub-behaviors here: * - If an SplDoublyLinkedList, SplQueue, or SplStack is provided, the * traversal will deque and visit vertices contained therein. * - If a single vertex object is provided, it will be the sole * originating point for the traversal. * - If no value is provided, DepthFirst::find_sources() is called to * search the graph for source vertices. These are place into an * SplQueue in the order in which they are discovered, and traversal * is then run over that queue in the same manner as if calling code * had provided a queue directly. This method *guarantees* that all * vertices in the graph will be visited. * * @throws RuntimeException * Thrown if an invalid $start parameter is provided. */ public static function traverse(Digraph $graph, DepthFirstVisitorInterface $visitor, $start = NULL) { if ($start === NULL) { $queue = self::find_sources($graph, $visitor); } else { if ($start instanceof \SplDoublyLinkedList) { $queue = $start; } else { if (is_object($start)) { $queue = new \SplDoublyLinkedList(); $queue->push($start); } } } if ($queue->isEmpty()) { throw new RuntimeException('No start vertex or vertices were provided, and no source vertices could be found in the provided graph.', E_WARNING); } $visiting = new \SplObjectStorage(); $visited = new \SplObjectStorage(); $visitor->beginTraversal(); $visit = function ($vertex) use($graph, $visitor, &$visit, $visiting, $visited) { if ($visiting->contains($vertex)) { $visitor->onBackEdge($vertex, $visit); } else { if (!$visited->contains($vertex)) { $visiting->attach($vertex); $visitor->onStartVertex($vertex, $visit); foreach ($graph->successorsOf($vertex) as $head) { $visitor->onExamineEdge($vertex, $head, $visit); $visit($head); } $visitor->onFinishVertex($vertex, $visit); $visiting->detach($vertex); $visited->attach($vertex); } } }; // TODO experiment with adding a generator-producing visitor method that yields the queue here while (!$queue->isEmpty()) { $vertex = $queue->shift(); $visit($vertex); } $visitor->endTraversal(); }
/** * Perform a depth-first traversal on the provided graph. * * @param DirectedGraph $graph * The graph on which to perform the depth-first search. * @param DepthFirstVisitorInterface $visitor * The visitor object to use during the traversal. * @param object|\SplDoublyLinkedList $start * A vertex, or vertices, to use as start points for the traversal. There * are a few sub-behaviors here: * - If an SplDoublyLinkedList, SplQueue, or SplStack is provided, the * traversal will deque and visit vertices contained therein. * - If a single vertex object is provided, it will be the sole * originating point for the traversal. * - If no value is provided, DepthFirst::find_sources() is called to * search the graph for source vertices. These are place into an * SplQueue in the order in which they are discovered, and traversal * is then run over that queue in the same manner as if calling code * had provided a queue directly. This method *guarantees* that all * vertices in the graph will be visited. * * @throws RuntimeException * Thrown if an invalid $start parameter is provided. */ public static function traverse(DirectedGraph $graph, DepthFirstVisitorInterface $visitor, $start = NULL) { if ($start === NULL) { $queue = self::find_sources($graph, $visitor); } else { if ($start instanceof \SplDoublyLinkedList) { $queue = $start; } else { if (is_object($start)) { $queue = new \SplDoublyLinkedList(); $queue->push($start); } } } if ($queue->isEmpty()) { throw new RuntimeException('No start vertex or vertices were provided, and no source vertices could be found in the provided graph.', E_WARNING); } $visiting = new \SplObjectStorage(); $visited = new \SplObjectStorage(); $visitor->beginTraversal(); $visit = function ($vertex) use($graph, $visitor, &$visit, $visiting, $visited) { if ($visiting->contains($vertex)) { $visitor->onBackEdge($vertex, $visit); } else { if (!$visited->contains($vertex)) { $visiting->attach($vertex); $visitor->onStartVertex($vertex, $visit); $graph->eachAdjacent($vertex, function ($to) use($vertex, &$visit, $visitor) { $visitor->onExamineEdge($vertex, $to, $visit); $visit($to); }); $visitor->onFinishVertex($vertex, $visit); $visiting->detach($vertex); $visited->attach($vertex); } } }; while (!$queue->isEmpty()) { $vertex = $queue->shift(); $visit($vertex); } $visitor->endTraversal(); }
/** * Look for the node in the list and remove it * * @param Node $node */ public function removeChild(Node $node) { foreach ($this->children as $key => $child) { if ($child !== $node) { continue; } $this->children->offsetUnset($key); break; } }
/** * Returns the number or items in this collection * * @return int */ public function count() { if (!$this->_started) { $this->rewind(); } while ($this->valid()) { $this->next(); } return $this->_buffer->count(); }
/** * {@inheritdoc} */ public function mergeSets($x, $y) { $setx = $this->findSet($x); $sety = $this->findSet($y); if ($setx === Null || $sety === Null) { return; } // create a new linked list from both sets $setxy = new SplDoublyLinkedList(); foreach ($this->_sets[$x] as $e) { $setxy->push($e); } foreach ($this->_sets[$y] as $e) { $setxy->push($e); } unset($this->_sets[$x]); unset($this->_sets[$y]); $this->_sets[$x] = $setxy; }
function test(SplDoublyLinkedList $l) { $l->push("a"); $l->push("b"); $l->push("c"); echo "Foreach:", PHP_EOL; foreach ($l as $key => $val) { echo $key, '=>', $val, PHP_EOL; } echo PHP_EOL; echo "ArrayAccess:", PHP_EOL; var_dump($l[0]); var_dump($l[1]); var_dump($l[2]); echo PHP_EOL; echo "ArrayAccess Set:", PHP_EOL; $l[2] = "two"; var_dump($l[2]); try { $l[3] = "five"; // 3 would be the next element } catch (OutOfRangeException $e) { echo "OutOfRangeException caught", PHP_EOL; } echo PHP_EOL; echo "ArrayAccess Exists:", PHP_EOL; var_dump(isset($l[0]), isset($l[2]), isset($l[3])); // true, true, false echo PHP_EOL; echo "ArrayAccess Unset:", PHP_EOL; unset($l[0]); var_dump($l->offsetGet(0)); echo PHP_EOL; echo "Foreach:", PHP_EOL; foreach ($l as $key => $val) { echo $key, '=>', $val, PHP_EOL; } echo PHP_EOL; }