PHP Collection::merge方法代码示例

 public static function newMerged(array $decks)
 {
     $merged = new Collection();
     foreach ($decks as $deck) {
         $merged->merge($deck);
     }
     return new static($merged);
 }

 public function testMerge()
 {
     $collection1 = new Collection(['a', 'b']);
     $collection2 = new Collection(['a', 'c']);
     $collection3 = new Collection(['d', 'e']);
     $result = $collection1->merge($collection2, $collection3);
     $this->assertNotSame($collection1, $result);
     $this->assertInstanceOf(get_class($collection1), $result);
     $this->assertSame(['a', 'b', 'a', 'c', 'd', 'e'], (array) $result);
 }

function smarty_function_origin_picker($params, &$smarty)
{
    $gf = new GroupFilter(new PFC_And(new PFC_Not(new GFC_Namespace(Group::NS_USER)), new GFC_User(S::user(), Rights::admin())), new GFO_Score());
    $gs = $gf->get();
    if ($params['not_only_admin']) {
        $gfo = new GroupFilter(new PFC_And(new GFC_Namespace(array(Group::NS_BINET, Group::NS_FREE)), new GFC_User(S::user(), Rights::restricted())), new GFO_Score());
        $gso = $gfo->get()->diff($gs);
        $temp = new Collection();
        $temp->merge($gs)->merge($gso);
        $temp->select(GroupSelect::base());
        $smarty->assign('not_admin', $gso);
    } else {
        $gs = $gf->get()->select(GroupSelect::base());
    }
    $smarty->assign($params['out'], $gs);
}

 /**
  * @param string $table
  * @param mixed $hash
  * @param Context\Query $context
  * @return \Riverline\DynamoDB\Collection
  */
 public function query($table, $hash, Context\Query $context = null)
 {
     $collection = new Collection();
     do {
         try {
             $items = $this->connection->query($table, $hash, $context);
             $collection->merge($items);
             if ($items->more()) {
                 $context = $items->getNextContext();
             } else {
                 // End
                 break;
             }
         } catch (\Riverline\DynamoDB\Exception\ProvisionedThroughputExceededException $e) {
             // Continue
         }
     } while (true);
     return $collection;
 }

function smarty_function_target_picker($params, &$smarty)
{
    // Get user groups
    $everybody_groups = S::user()->castes(Rights::everybody())->groups();
    // Get Frankiz special groups
    $fkz = new Collection('Group');
    $fkz->add(array('everybody', 'public'));
    $fkz->select(new GroupSelect(array('description')));
    // BDE, study and promo groups
    $study_groups = $everybody_groups->filter('ns', Group::NS_BDE);
    $study_groups->merge($everybody_groups->filter('ns', Group::NS_PROMO));
    $study_groups->merge($everybody_groups->filter('ns', Group::NS_STUDY));
    // Get all groups user is admin, without the user one
    $gs = S::user()->castes(Rights::admin())->groups();
    $gs->diff($fkz);
    $gs->filter(function ($g) {
        return $g->ns() != Group::NS_USER;
    });
    if ($params['even_only_friend']) {
        $gfo = new GroupFilter(new PFC_And(new GFC_Namespace(array(Group::NS_BINET, Group::NS_FREE)), new GFC_User(S::user(), Rights::everybody())), new GFO_Score());
        $gso = $gfo->get()->diff($gs)->diff($fkz);
        $temp = new Collection();
        $temp->merge($gs)->merge($gso);
        $temp->select(GroupSelect::base());
        $smarty->assign('only_friend', $gso);
        $temp = new Collection();
        $temp->merge($gs)->merge($fkz)->merge($gso);
        $temp->select(GroupSelect::base());
    } else {
        $temp = new Collection();
        $temp->merge($gs)->merge($fkz);
        $temp->select(GroupSelect::base());
    }
    $smarty->assign($params['user_groups'], $gs);
    $smarty->assign($params['fkz_groups'], $fkz);
    $smarty->assign($params['study_groups'], $study_groups);
    $smarty->assign($params['own_group'], S::user()->group());
}

 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']]);
 }

 function handler_groups($page)
 {
     global $globals;
     $except = new PFC_True();
     $max = $globals->groups->limit;
     // Re-fetch user's groups
     S::user()->select(UserSelect::castes());
     // Fetch samples of other groups
     $binet = new GroupFilter(new PFC_And(new GFC_Namespace(Group::NS_BINET), $except), new GFO_Score(true));
     $binet = $binet->get(new PlLimit($max));
     $course = new GroupFilter(new PFC_And(new GFC_Namespace(Group::NS_COURSE), $except), new GFO_Score(true));
     $course = $course->get(new PlLimit($max));
     $free = new GroupFilter(new PFC_And(new GFC_Namespace(Group::NS_FREE), $except), new GFO_Score(true));
     $free = $free->get(new PlLimit($max));
     // Load associated datas
     $temp = new Collection('Group');
     $temp->merge($binet)->merge($course)->merge($free);
     $temp->select(GroupSelect::base());
     // Fetch the total count of groups
     $allf = new GroupFilter(new GFC_Visible());
     $total = $allf->getTotalCount();
     $user_binet = S::user()->castes()->groups()->filter('ns', Group::NS_BINET)->remove($binet);
     $page->assign('binet', $binet);
     $page->assign('user_binet', $user_binet);
     $user_course = S::user()->castes()->groups()->filter('ns', Group::NS_COURSE)->remove($course);
     $page->assign('course', $course);
     $page->assign('user_course', $user_course);
     $user_free = S::user()->castes()->groups()->filter('ns', Group::NS_FREE)->remove($free);
     $page->assign('free', $free);
     $page->assign('user_free', $user_free);
     $page->assign('user', S::user());
     $page->assign('total', $total);
     $page->assign('title', 'Groupes');
     $page->changeTpl('groups/groups.tpl');
     $page->addCssLink('groups.css');
 }

 public function testMergeCollection()
 {
     $this->collection->merge(new Collection(['test']));
     $this->assertEquals(5, $this->collection->count());
     $this->assertEquals('test', $this->collection->last());
 }

 public function targetCastes()
 {
     $target_castes = new Collection();
     $target_castes->merge($this->castes(Rights::restricted()));
     $target_castes->merge($this->castes(Rights::everybody()));
     return $target_castes;
 }

 public function __call($method, $arguments)
 {
     $className = $this->className;
     $inferedMethod = 'batch' . ucfirst($method);
     if (method_exists($className, $inferedMethod)) {
         // Call $className->batch$method($this->collected, ...)
         array_unshift($arguments, $this->collected);
         $r = forward_static_call_array(array($className, $inferedMethod), $arguments);
         if (!is_array($r)) {
             return $r;
         }
         $c = new Collection($className);
         if (!empty($r)) {
             $c->add($r);
         }
         return $c;
     }
     // If there is no argument, build an array with values from $collected->$method
     if (empty($arguments)) {
         $values = array_map(function ($mixed) use($method) {
             return $mixed->{$method}();
         }, $this->collected);
         // Try magic things with the schema
         $schema = Schema::get($className);
         if ($schema->isScalar($method)) {
             // Return an array of scalar values
             return $values;
         } elseif ($schema->isObject($method)) {
             // Return a collection
             return Collection::fromArray($values, $schema->objectType($method));
         } elseif ($schema->isFlagset($method)) {
             // Return a merged flagset
             $fs = new PlFlagSet();
             foreach ($values as $flags) {
                 foreach ($flags as $flag) {
                     $fs->addFlag($flag);
                 }
             }
             return $fs;
         } elseif ($schema->isCollection($method)) {
             // Return a merged collection
             $col = new Collection();
             foreach ($values as $c) {
                 $col->merge($c);
             }
             return $col;
         }
         throw new Exception("Unknown automatic field {$method} is schema for {$className}");
     }
     throw new Exception("The method {$className}::{$inferedMethod} doesn't exist");
 }

 public static function batchLeaves(array $nodes)
 {
     $leaves = new Collection();
     foreach ($nodes as $n) {
         $leaves->merge($n->leaves());
     }
     return $leaves;
 }