/** * Creates a new iterator over a sequence * * @param util.data.Sequence $seq * @throws lang.IllegalStateException If the sequence has been processed */ public function __construct(Sequence $seq) { $this->it = $seq->getIterator(); try { $this->it->rewind(); } catch (\Exception $e) { throw new IllegalStateException($e->getMessage()); } }
public function flatten_generator_with_key() { $this->assertSequence([3, 6], Sequence::of([1 => 2])->flatten(function ($n, $key) { (yield $n + $key); (yield $n * ($n + $key)); })); }
/** * Lazy fetching sequence * * @param int $limit * @param int $page * @return util.data.Sequence */ protected function records($limit = self::PAGE, $page = 0) { $records = $this->loadPage($page * $limit, $limit); return Sequence::concat($records, sizeof($records) < $limit ? null : function () use($page, $limit) { return $this->records($limit, ++$page); }); }
public function concat_iteratively() { $seq = Sequence::$EMPTY; foreach ([[1, 2], [3, 4], [5, 6]] as $array) { $seq = Sequence::concat($seq, Sequence::of($array)); } $this->assertSequence([1, 2, 3, 4, 5, 6], $seq); }
public function with_generator_and_key() { $records = Sequence::of(['color' => 'green', 'price' => 12.99]); $generator = function ($value, $key) { (yield strtoupper($key) => $value); }; $this->assertEquals(['COLOR' => 'green', 'PRICE' => 12.99], $records->map($generator)->toMap()); }
public function min_max_sum_average_and_count_for_non_empty() { Sequence::of([1, 2, 3, 4])->collecting($min, Aggregations::min())->collecting($max, Aggregations::max())->collecting($average, Aggregations::average())->collecting($sum, Aggregations::sum())->collecting($count, Aggregations::count())->each(); $this->assertEquals(1, $min); $this->assertEquals(4, $max); $this->assertEquals(2.5, $average); $this->assertEquals(10, $sum); $this->assertEquals(4, $count); }
public function map_key_is_passed_to_function() { $keys = []; Sequence::of(['one' => 1, 'two' => 2, 'three' => 3])->filter(function ($e, $key) use(&$keys) { $keys[] = $key; return true; })->each(); $this->assertEquals(['one', 'two', 'three'], $keys); }
public function at_end($input) { $it = Sequence::of($input)->getIterator(); $it->rewind(); $it->next(); $it->next(); $it->next(); $this->assertEquals([], iterator_to_array(new ContinuationOf($it))); }
public function used_for_joining() { $result = Sequence::of(['a', 'b', 'c'])->collect(new Collector(function () { return ''; }, function (&$result, $arg) { $result .= ', ' . $arg; }, function ($result) { return substr($result, 2); })); $this->assertEquals('a, b, c', $result); }
/** * Add a measurable class * * @param var $class Either a string or an `XPClass` instance * @return self This * @throws lang.IllegalArgumentException If the class is not a subclass of util.profiling.Measurable */ public function measuring($type) { $class = $type instanceof XPClass ? $type : XPClass::forName($type); if (!$class->isSubclassOf('util.profiling.Measurable')) { throw new IllegalArgumentException($class->toString() . ' must be a subclass of util.profiling.Measurable'); } $this->measurables = Sequence::of($class->getMethods())->filter(self::$ANNOTATED)->map(function ($method) use($class) { if ($method->hasAnnotation('values')) { return $this->permutationOf($class, $method, $method->getAnnotation('values')); } else { return [$class->newInstance($method)]; } })->flatten(); return $this; }
/** * Returns fixed enumerables, that is, those that can be rewound. * * @return var[][] */ public static function fixedMaps() { return [[['color' => 'green', 'price' => 12.99], 'map'], [new \ArrayObject(['color' => 'green', 'price' => 12.99]), 'iterable'], [new \ArrayIterator(['color' => 'green', 'price' => 12.99]), 'iterator'], [Sequence::of(['color' => 'green', 'price' => 12.99]), 'self']]; }
public function raises_exception_when_given_null_and_args() { Sequence::of([])->each(null, []); }
/** * Assertion helper * * @param var[] $expected * @param util.data.Sequence $sequence * @param string $message * @throws unittest.AssertionFailedError */ protected function assertSequence($expected, $sequence, $message = '!=') { $this->assertEquals($expected, $sequence->toArray(), $message); }
public function max_using_closure() { $this->assertEquals(new Date('2014-07-17'), Sequence::of([new Date('1977-12-14'), new Date('2014-07-17'), new Date('1979-12-29')])->max(function ($a, $b) { return $b->compareTo($a); })); }
public function summing_with_function_and_names($key, $expect) { $pivot = Sequence::of($this->measurements())->collect((new InPivot())->groupingBy('type')->summing(function ($row) { return $row['occurrences']; }, $key)); $this->assertEquals($expect, $pivot->sum('bad')); }
public function flattens_array_and_sequence() { $this->assertEquals([1, 2, 3, 4], $this->flatten([[1, 2], Sequence::of([3, 4])])); }
public function used_for_concatenation() { $this->assertEquals('Hello World', Sequence::of(['Hello', ' ', 'World'])->reduce('', function ($a, $b) { return $a . $b; })); }
public function receives_offset() { $this->assertSequence([3, 4], Sequence::of([1, 2, 3, 4])->skip(function ($e, $offset) { return $offset < 2; })); }
public function sequence_of_iterator($input) { $this->assertSequence([1, 2, 3], Sequence::of(Sequence::of($input)->iterator())); }
public function receives_offset() { $this->assertSequence([1, 2], Sequence::of([1, 2, 3, 4])->limit(function ($e, $offset) { return $offset >= 2; })); }
public function raises_exception_when_given($noncallable) { Sequence::of([])->peek($noncallable); }
public function passing_null_to_of_yields_an_empty_sequence() { $this->assertEquals(Sequence::$EMPTY, Sequence::of(null)); }
public function toString_for_sequence_of_array() { $this->assertEquals('util.data.Sequence@[1, 2, 3]', Sequence::of([1, 2, 3])->toString()); }
public function sorted_by_natural_order_string_comparison() { $this->assertSequence(['rfc1.txt', 'rfc822.txt', 'rfc2086.txt'], Sequence::of(['rfc1.txt', 'rfc2086.txt', 'rfc822.txt'])->sorted(function ($a, $b) { return strnatcasecmp($a, $b); }), 'http://sourcefrog.net/projects/natsort/'); }
public function partitioningBy_handles_non_booleans() { $this->assertHashTable([true => new Vector(['Test', 'Unittest']), false => new Vector(['Trial & Error'])], Sequence::of(['Test', 'Unittest', 'Trial & Error'])->collect(Collectors::partitioningBy(function ($e) { return stristr($e, 'Test'); }))); }