PHP Collection::count方法代码示例

 public function testClone()
 {
     $clone = $this->collection->clone();
     $clone->push('test');
     $this->assertEquals(4, $this->collection->count());
     $this->assertEquals(5, $clone->count());
 }

 /**
  * {@inheritdoc}
  */
 public function count()
 {
     if ($this->mapping['isInverseSide']) {
         $this->initialize();
     }
     return count($this->mongoData) + $this->coll->count();
 }

 public function testAddsAllElements()
 {
     $list = new Collection(\Cassandra::TYPE_VARINT);
     $list->add(new Varint('1'), new Varint('2'), new Varint('3'), new Varint('4'), new Varint('5'), new Varint('6'), new Varint('7'), new Varint('8'));
     $this->assertEquals(8, $list->count());
     $this->assertEquals(array(new Varint('1'), new Varint('2'), new Varint('3'), new Varint('4'), new Varint('5'), new Varint('6'), new Varint('7'), new Varint('8')), $list->values());
 }

 /**
  * Return a list of available configuration options.
  *
  * @param Collection $availableTypes Collection of Injector\InjectorInterface::TYPE_*
  *     constants indicating valid package types that could be injected.
  * @param string $projectRoot Path to the project root; assumes PWD by
  *     default.
  * @return Collection Collection of ConfigOption instances.
  */
 public function getAvailableConfigOptions(Collection $availableTypes, $projectRoot = '')
 {
     // Create an initial collection to which we'll append.
     // This approach is used to ensure indexes are sane.
     $discovered = new Collection([new ConfigOption('Do not inject', new Injector\NoopInjector())]);
     Collection::create($this->discovery)->map(function ($discoveryClass) use($projectRoot) {
         if (is_array($discoveryClass)) {
             return new ConfigDiscovery\DiscoveryChain($discoveryClass, $projectRoot);
         }
         return new $discoveryClass($projectRoot);
     })->filter(function ($discovery) {
         return $discovery->locate();
     })->map(function ($discovery, $file) use($projectRoot, $availableTypes) {
         // Look up the injector based on the file type
         $injectorClass = $this->injectors[$file];
         if (is_array($injectorClass)) {
             return new Injector\ConfigInjectorChain($injectorClass, $discovery, $availableTypes, $projectRoot);
         }
         return new $injectorClass($projectRoot);
     })->filter(function ($injector) use($availableTypes) {
         return $availableTypes->reduce(function ($flag, $type) use($injector) {
             return $flag || $injector->registersType($type);
         }, false);
     })->each(function ($injector, $file) use($discovered) {
         $discovered[] = new ConfigOption($file, $injector);
     });
     return 1 === $discovered->count() ? new Collection([]) : $discovered;
 }

 /**
  * Find element from collection by key and value
  * 
  * @param string $key - search index
  * @param string $value - search value
  * @param [boolean $onlyIndex] - this flag can return only indixes of records found
  * @return NULL|Collection <NULL, \VCAPI\Common\Collection>
  */
 public function find($key, $value, $onlyIndex = false)
 {
     if (empty($this->collection)) {
         return null;
     }
     $return = new Collection();
     foreach ($this->collection as $index => $item) {
         if (is_array($item)) {
             if (!isset($item[$key])) {
                 continue;
             }
             if ($item[$key] == $value) {
                 if ($onlyIndex) {
                     $return->add($index);
                 } else {
                     $return->add($item);
                 }
             }
         } elseif (is_object($item)) {
             if (!property_exists($item, $key)) {
                 continue;
             }
             if ($item->{$key} == $value) {
                 if ($onlyIndex) {
                     $return->add($index);
                 } else {
                     $return->add($item);
                 }
             }
         }
     }
     return $return->count() ? $return : null;
 }

 /**
  * Dynamically retrieve attributes on the model.
  *
  * @param  string $key
  *
  * @return Collection
  */
 public function __get($key)
 {
     $newCollection = new Collection();
     foreach ($this->items as $item) {
         if ($item instanceof Collection) {
             foreach ($item as $subItem) {
                 $newCollection->put($newCollection->count(), $subItem->{$key});
             }
         } elseif (is_object($item) && !$item instanceof Collection && $item->{$key} instanceof Collection) {
             foreach ($item->{$key} as $subItem) {
                 $newCollection->put($newCollection->count(), $subItem);
             }
         } else {
             $newCollection->put($newCollection->count(), $item->{$key});
         }
     }
     return $newCollection;
 }

 /**
  * Add a new category that list items
  *
  * @param \Amisure\P4SApiBundle\Entity\EvaluationItemCategory|string $category
  *        	Evaluation item category, or name of the evaluation item category
  * @see \Amisure\P4SApiBundle\Entity\EvaluationItemCategory
  * @return \Amisure\P4SApiBundle\Entity\Evaluation
  */
 public function addCategory($category)
 {
     $evaluationCategory = $category;
     if (is_string($category)) {
         $evaluationCategory = new EvaluationModelCategory($category);
     }
     $evaluationCategory->setEvaluation($this);
     if (-1 == $evaluationCategory->getCategoryId()) {
         $evaluationCategory->setCategoryId($this->categories->count());
     }
     $this->categories->add($evaluationCategory);
     return $this;
 }

 /**
  * Add a new item
  *
  * @param \Amisure\P4SApiBundle\Entity\EvaluationModelItem|string $item
  *        	Evaluation item, or description of the evaluation item
  * @param string $value
  *        	Value of the evaluation item if the evaluation item itself is not previsously provided
  * @see \Amisure\P4SApiBundle\Entity\EvaluationModelItem
  * @return \Amisure\P4SApiBundle\Entity\EvaluationModelCategory
  */
 public function addItem($item, $responseType = '')
 {
     $evaluationItem = $item;
     if (is_string($item)) {
         $evaluationItem = new EvaluationModelItem($item, $responseType);
     }
     $evaluationItem->setCategory($this);
     if (-1 == $evaluationItem->getItemId()) {
         $evaluationItem->setItemId($this->items->count());
     }
     $this->items->add($evaluationItem);
     return $this;
 }

 /**
  * Add a new item response
  *
  * @param \Amisure\P4SApiBundle\Entity\EvaluationModelItemResponse|string $item
  *        	Evaluation item, or description of the evaluation item
  * @param string $label
  *        	Label of the evaluation item response if the evaluation item response itself is not previsously provided
  * @param string $type
  *        	Type of the evaluation item response if the evaluation item response itself is not previsously provided
  * @see \Amisure\P4SApiBundle\Entity\EvaluationModelItem
  * @return \Amisure\P4SApiBundle\Entity\EvaluationModelItem
  */
 public function addResponse($response, $label = '', $type = EvaluationModelItemResponse::TypeString)
 {
     $evaluationResponse = $response;
     if (is_string($response)) {
         $evaluationResponse = new EvaluationModelItem($response, $label, $type);
     }
     $evaluationResponse->setItem($this);
     if (-1 == $evaluationResponse->getResponseId()) {
         $evaluationResponse->setResponseId($this->responses->count());
     }
     $this->responses->add($evaluationResponse);
     return $this;
 }

 public function test3_Appending()
 {
     $collection = new Collection(new Yaml());
     $collection_of_values = new Collection(new Yaml());
     # appending
     static::$collection->append('part1.item2', ['name' => 'Janice']);
     $this->assertEquals('Janice', static::$collection->get('part1.item2.name'));
     static::$collection->forget('part1');
     static::$collection->append('part1', ['item2' => ['name' => 'Janice']]);
     static::$collection->with('with', 'with test');
     $this->assertEquals('with test', static::$collection->get('with'));
     $this->assertTrue(static::$collection->count() === 2);
     static::$collection->forget('with');
     $this->assertTrue(static::$collection->count() === 1);
     # setup
     $test_array = ['merge_with' => ['merge' => 'this']];
     $collection_of_values->with($test_array);
     # test with an array
     $collection->merge($test_array);
     $this->assertEquals($collection->get('merge_with.merge'), 'this');
     $collection->forget('merge_with');
     # test with a collection as a value object
     $collection->merge($collection_of_values);
     $this->assertEquals($collection->get('merge_with.merge'), 'this');
     $collection->forget('merge_with');
     # test with value object
     $value_object = new \stdClass();
     $value_object->merge_with = $test_array['merge_with'];
     $collection->merge($value_object);
     $this->assertEquals($collection->get('merge_with.merge'), 'this');
     # test with flat array
     $collection->merge(Util::array_from_str('merge with'));
     $this->assertEquals($collection->get('merge'), NULL);
     $this->assertEquals($collection->get('with'), NULL);
     $this->setExpectedException('InvalidArgumentException', "Cannot append an already existing key: 'part1'");
     static::$collection->append('part1', ['item2' => ['name' => 'Mary']]);
 }

 /**
  * build a Collection object with objects of this class based on filters
  *
  * @param Array $filters
  * @param string|null $order literal SQL appended to "ORDER BY " if used.
  * @returns Collection object
  */
 public static function buildCollection($filters, $order = null)
 {
     Debug::log(">>" . get_called_class() . ":: " . __FUNCTION__ . " called with filters:", $filters);
     $collection = new Collection();
     $sql = static::buildCollectionSql($params, $filters, $order);
     $stmt = static::getConnection()->prepAndExecute(new \ArtfulRobot\PDO_Query("Fetch records from " . static::TABLE_NAME, $sql, $params));
     if ($stmt->errorCode() != '00000') {
         throw new Exception("PDO error: " . print_r($stmt->errorInfo(), 1));
     }
     while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
         // create an object of the class
         $obj = new static();
         $obj->loadFromArray($row, false, self::CAST_DB);
         $collection->append($obj, $obj->id);
         unset($obj);
     }
     Debug::log("<< Returning collection with " . $collection->count() . " entries");
     return $collection;
 }

 /**
  * Get the number of public properties in the ArrayObject
  * @return int
  */
 public function count()
 {
     if (!$this->isLoaded() && $this->isLoadable()) {
         $this->load();
     }
     return parent::count();
 }

 /**
  * Check node children
  *
  * @return bool
  */
 public function hasChildren()
 {
     return $this->_childNodes->count() > 0;
 }

<?php

include "../patches.php";
$patch = new Patch(18);
if (!$patch->exists()) {
    $createSql = "CREATE TABLE IF NOT EXISTS `webcam_images` (\n\t\t\t  `timestamp` datetime NOT NULL,\n\t\t\t  `image_id` bigint(11) unsigned NOT NULL,\n\t\t\t  `user_id` int(11) unsigned NOT NULL,\n\t\t\t  `bot_id` int(11) unsigned NULL,\n\t\t\t  `job_id` int(11) unsigned NULL,\n\t\t\t  PRIMARY KEY (`timestamp`, `image_id`),\n\t\t\t  FOREIGN KEY (`image_id`) REFERENCES s3_files(`id`) ON DELETE CASCADE,\n\t\t\t  FOREIGN KEY (`user_id`) REFERENCES users(`id`) ON DELETE CASCADE,\n\t\t\t  FOREIGN KEY (`bot_id`) REFERENCES bots(`id`) ON DELETE CASCADE,\n\t\t\t  FOREIGN KEY (`job_id`) REFERENCES jobs(`id`) ON DELETE CASCADE\n\t\t\t) ENGINE=InnoDB DEFAULT CHARSET=utf8;";
    db()->execute($createSql);
    $failCount = 0;
    $rowSql = "SELECT id from jobs where webcam_images!=''";
    $jobsCollection = new Collection($rowSql);
    $jobsCollection->bindType('id', 'Job');
    $jobs = $jobsCollection->getAll();
    $total = $jobsCollection->count();
    $count = 0;
    $patch->progress(0);
    // Get the current webcam images in an array, so we can quickly skip those.
    $pdoStatement = db()->query("SELECT image_id from webcam_images");
    $existingImages = array();
    foreach ($pdoStatement->fetchAll(PDO::FETCH_ASSOC) as $row) {
        $existingImages[$row['image_id']] = true;
    }
    foreach ($jobs as $row) {
        /** @var Job $job */
        $job = $row['Job'];
        $images_json = $job->get('webcam_images');
        if ($job->isHydrated() && $images_json != "") {
            $images = json_decode($images_json, true);
            $rowData = array();
            foreach ($images as $timestamp => $image_id) {
                if (!array_key_exists($image_id, $existingImages)) {
                    $file = Storage::get($image_id);

 /**
  * @return bool
  */
 public function hasGists()
 {
     return $this->gists->count() > 0;
 }