PHP self::push方法代码示例

 public static function create(callable $handler = null) : self
 {
     $stack = new self($handler ?: choose_handler());
     $stack->push(Middleware::httpErrors());
     $stack->push(Middleware::prepareBody());
     return $stack;
 }

 /**
  * Creates a default handler stack that can be used by clients.
  *
  * The returned handler will wrap the provided handler or use the most
  * appropriate default handler for you system. The returned HandlerStack has
  * support for cookies, redirects, HTTP error exceptions, and preparing a body
  * before sending.
  *
  * The returned handler stack can be passed to a client in the "handler"
  * option.
  *
  * @param callable $handler HTTP handler function to use with the stack. If no
  *                          handler is provided, the best handler for your
  *                          system will be utilized.
  *
  * @return HandlerStack
  */
 public static function create(callable $handler = null)
 {
     $stack = new self($handler ?: choose_handler());
     $stack->push(Middleware::httpErrors(), 'http_errors');
     $stack->push(Middleware::redirect(), 'allow_redirects');
     $stack->push(Middleware::cookies(), 'cookies');
     $stack->push(Middleware::prepareBody(), 'prepare_body');
     return $stack;
 }

 static function range(date $first, date $last)
 {
     $week = new self();
     $day = $first;
     $week->push($day);
     do {
         $day = $day->tomorrow();
         $week->push($day);
     } while (!$day->is_equal($last));
     return $week;
 }

 /**
  * Only used for tests.
  * @param string[] $displayNames
  * @return array|CurrentPath
  */
 public static function fromArray(array $displayNames)
 {
     $path = new self();
     foreach ($displayNames as $v) {
         $path->push(new ResourceField(new ResourceDefinition(null), $v));
     }
     return $path;
 }

 /**
  * @param Traversable $from
  *
  * @return Collection
  */
 public static function from(Traversable $from)
 {
     $self = new self();
     foreach ($from as $item) {
         $self->push($item);
     }
     return $self;
 }

 public function reduce(callable $callback, $preserveKeys = false)
 {
     $collection = new self();
     foreach ($this->collection as $key => $item) {
         if ($callback($item)) {
             $collection->push($item, $preserveKeys ? $key : null);
         }
     }
     return $collection;
 }

 public function whereRecip($email)
 {
     $coll = new self();
     foreach ($this as $msg) {
         if ($msg->recipients->contains('email', $email)) {
             $coll->push($msg);
         }
     }
     return $coll;
 }

 /**
  * @param int[]|\BitWasp\Bitcoin\Script\Interpreter\Number[]|BufferInterface[] $sequence
  * @return $this
  */
 public function sequence(array $sequence)
 {
     $new = new self($this->math, $this->opcodes, null);
     foreach ($sequence as $operation) {
         if (is_int($operation)) {
             if (!$this->opcodes->offsetExists($operation)) {
                 throw new \RuntimeException('Unknown opcode');
             }
             $new->script .= chr($operation);
         } elseif ($operation instanceof Number) {
             $new->push($operation->getBuffer());
         } elseif ($operation instanceof BufferInterface) {
             $new->push($operation);
         } else {
             throw new \RuntimeException('Input was neither an opcode or BufferInterfacecc');
         }
     }
     $this->concat($new->getScript());
     return $this;
 }

 private function copyFromContext(LinkedNode $context)
 {
     $list = new self();
     for ($n = $context; $n !== $this->tail; $n = $n->next()) {
         /**
          * @var LinkedDataNode $n
          */
         $list->push($n->value());
     }
     return $list;
 }

 /**
  * Get all the unique values in the collection.
  *
  * @param bool $preserveKeys
  *
  * @return CollectionInterface
  */
 public function unique($preserveKeys = true)
 {
     $values = new self();
     $this->each(function ($item) use($values, $preserveKeys) {
         if (!$values->contains($item)) {
             if ($preserveKeys) {
             }
             $values->push($item);
         }
     });
     return $values;
 }

 public function diff(Delta $other)
 {
     $delta = new self();
     if ($this->getOperations() === $other->getOperations()) {
         return $delta;
     }
     $strings = array_map(function (OperationCollection $operations) use($other) {
         return implode(array_map(function (OperationInterface $operation) use($operations, $other) {
             if ($operation->getType() === OperationInterface::TYPE_INSERT) {
                 return is_string($operation->getValue()) ? $operation->getValue() : chr(0);
             }
             throw new \RuntimeException(sprintf('diff() called %s non-document', $operations === $other->getOperations() ? 'on' : 'with'));
         }, $operations->toArray()));
     }, [$this->getOperations(), $other->getOperations()]);
     $diffResults = FastDiff::diff($strings[0], $strings[1]);
     $thisIterator = $this->getOperations()->getIterator();
     $otherIterator = $other->getOperations()->getIterator();
     foreach ($diffResults as $diffResult) {
         $length = mb_strlen($diffResult[1]);
         while ($length > 0) {
             $operationLength = 0;
             switch ($diffResult[0]) {
                 case FastDiff::DIFF_INSERT:
                     $operationLength = min($otherIterator->getPeekLength(), $length);
                     $delta->push($otherIterator->next($operationLength));
                     break;
                 case FastDiff::DIFF_DELETE:
                     $operationLength = min($length, $thisIterator->getPeekLength());
                     $thisIterator->next($operationLength);
                     $delta->delete($operationLength);
                     break;
                 case FastDiff::DIFF_EQUAL:
                     $operationLength = min($thisIterator->getPeekLength(), $otherIterator->getPeekLength(), $length);
                     $thisOperation = $thisIterator->next($operationLength);
                     $otherOperation = $otherIterator->next($operationLength);
                     if ($thisOperation->getValue() === $otherOperation->getValue()) {
                         $delta->retain($operationLength, $this->diffAttributes($thisOperation->getAttributes(), $otherOperation->getAttributes()));
                     } else {
                         $delta->push($otherOperation)->delete($operationLength);
                     }
                     break;
             }
             $length -= $operationLength;
         }
     }
     return $delta->chop();
 }

 static function fromSlice(array $tokens) : self
 {
     $ts = new self();
     $ts->first = new NodeStart();
     $ts->last = new NodeEnd();
     self::link($ts->first, $ts->last);
     foreach ($tokens as $token) {
         $ts->push($token);
     }
     $ts->reset();
     return $ts;
 }

 public function map($callback)
 {
     if (!is_callable($callback)) {
         throw new \InvalidArgumentException('Invalid (not callable) callback given');
     }
     $result = new self();
     for ($i = 0; $i < $this->count(); $i++) {
         $value = $callback($this->storage[$i]);
         if (null !== $value) {
             $result->push($value);
         }
     }
     return $result;
 }

 public function filter($var, $value)
 {
     $result = new self();
     foreach ($this as $e) {
         if ($e->{$var} == $value) {
             $result->push($e);
         }
     }
     return $result;
 }