/** * Initializes a new instance of that class. * * @param IEnumerable $sequence The base sequence. * @param callable $selector The selector for the sort values to use. * @param bool $preventKeys Prevent keys or not. */ public function __construct(IEnumerable $sequence, callable $selector, callable $comparer) { $this->_comparer = $comparer; $this->_selector = $selector; $this->_sequence = $sequence; parent::__construct($sequence); $this->resetMe(false); }
/** * Initializes a new instance of that class. * * @param IEnumerable $grps The sequence of groupings. * * @throws \System\ArgumentException */ public function __construct($grps) { $grps = static::asIterator($grps, true); $dict = new Dictionary(null, null, null, \sprintf('$x => $x instanceof %s', IGrouping::class)); while ($grps->valid()) { /* @var IGrouping $curGrouping */ $curGrouping = $grps->current(); $dict->add($curGrouping->key(), $curGrouping); $grps->next(); } parent::__construct($dict); }
public function test1Iterator() { $seq = Enumerable::create(new ArrayIterator([1, 2, 3])); $items1 = static::sequenceToArray($seq); $items2 = static::sequenceToArray($seq->reset()); $this->assertEquals(count($items1), count($items2)); foreach ($items1 as $key => $value) { $this->assertTrue(isset($items2[$key])); $this->assertTrue($items2[$key] === $value); $this->assertTrue($items2[$key] === $items1[$key]); } }
public function testRange3() { foreach ($this->createRangeIncreaseByFuncs() as $increaseByFunc) { $seq = Enumerable::range(2, 3, $increaseByFunc); $items = static::sequenceToArray($seq); $this->assertEquals(3, count($items)); $this->assertTrue(isset($items[0])); $this->assertSame(2, $items[0]); $this->assertTrue(isset($items[1])); $this->assertSame(2.5, $items[1]); $this->assertTrue(isset($items[2])); $this->assertSame(3.0, $items[2]); } }
public function testIterator() { $this->executeForPersonSequence(function (array $persons) { return Enumerable::create(new ArrayIterator($persons)); }); }
/** * Creates a list of sequences from an array. * * @param array $arr The array with the data for each sequence. * * @return IEnumerable[] The list of sequences. */ protected static function sequenceListFromArray(array $arr = []) : array { return [static::sequenceFromArray($arr), Enumerable::create(new \ArrayIterator($arr)), Enumerable::create(static::generatorFromArray($arr))]; }
public function testPrependFormatArray() { $createGenerator = function () { (yield 'ys'); (yield 'Mk'); (yield null); }; $str1 = $this->createInstance('xyz'); $str2 = $this->checkTransformMethod(function (IString $str) { return $str->prependFormatArray('{2}{0}{3}{1}', [1, 2.0, '3.0', '4']); }, '3.0142xyz', $str1); $str3 = $this->checkTransformMethod(function (IString $str) use($createGenerator) { return $str->prependFormatArray(' {0}{1}{2} {4}{3}{5} ', $createGenerator(), Enumerable::create($createGenerator())->select('$x => \\strtoupper($x)')->reverse()); }, ' ysMk MKYS 3.0142xyz', $str2); }
/** * {@inheritDoc} */ public final function enumerateFiles() : IEnumerable { $path = (string) $this->_fullName; return Enumerable::create(\scandir($path))->select(function ($x) use($path) { if (ClrString::isNullOrWhitespace($x)) { return null; } if ('.' === \trim($x)) { return null; } if ('..' === \trim($x)) { return null; } $fullPath = \realpath($path . \DIRECTORY_SEPARATOR . $x); if (false === $fullPath) { return null; } $scopePath = $fullPath; if (@\is_link($scopePath)) { $link = @\readlink($scopePath); if (false !== $link) { $scopePath = $link; } } if (!\is_file($scopePath)) { return null; } return $fullPath; })->ofType('string')->select('$x => new \\System\\IO\\FileInfo($x)'); }
public function syntax(Language $lang = null, $linePrefix = '') { $doc = $this->docBlock(); $visibility = null; if (!$this->reflector()->getDeclaringClass()->isInterface()) { if ($this->reflector()->isPublic()) { $visibility = 'public '; } else { if ($this->reflector()->isProtected()) { $visibility = 'protected '; } else { if ($this->reflector()->isPrivate()) { $visibility = 'private '; } } } } $isStatic = null; if ($this->reflector()->isStatic()) { $isStatic = 'static '; } $isAbstract = null; if (!$this->reflector()->getDeclaringClass()->isInterface()) { if ($this->reflector()->isAbstract()) { $isAbstract = 'abstract '; } } $isFinal = null; if ($this->reflector()->isFinal()) { $isFinal = 'final '; } $syntax = \sprintf('%s%s%s%s%sfunction %s(', $linePrefix, $isAbstract, $visibility, $isStatic, $isFinal, $this->reflector()->getName()); /* @var ParamTag[] $paramTags */ $paramTags = $doc->getTagsByName('param'); $findParamTag = function (\ReflectionParameter $rp) use($paramTags) { $paramName = '$' . $rp->getName(); $result = null; foreach ($paramTags as $pt) { if (\trim($pt->getVariableName()) === $paramName) { $result = $pt; } } return $result; }; $parameters = Enumerable::create($this->reflector()->getParameters())->select(function (\ReflectionParameter $x, IIndexedItemContext $ctx) use($findParamTag, $linePrefix, $syntax) { $result = !$ctx->isFirst() ? "\n" . \str_repeat(' ', \strlen($syntax)) : ''; $tag = $findParamTag($x); if ($tag instanceof ParamTag) { $types = Enumerable::create($tag->getTypes())->select('$x => \\trim($x)')->distinct('($x, $y) => \\strtolower($x) === \\strtolower($y)')->toArray(); if (!empty($types)) { $result .= \implode(' | ', $types) . ' '; } } $result .= '$' . $x->getName(); if ($x->isOptional()) { $result .= ' = ' . \var_export($x->getDefaultValue(), true); } return $result; })->joinToString(','); $syntax .= \sprintf('%s)', $parameters); $syntax .= ';'; return $syntax; }
public function testKeyValidators() { foreach ($this->createKeyValidators() as $keyValidator) { unset($dict1); unset($dict2); unset($thrownEx1); unset($thrownEx2); try { $dict1 = Enumerable::create(['a' => 111, 'b' => 2.7, 'C' => '33three'])->toDictionary(null, $keyValidator); } catch (\Exception $ex) { $thrownEx1 = $ex; } $this->assertTrue(isset($dict1)); $this->assertFalse(isset($thrownEx1)); $this->assertInstanceOf(IDictionary::class, $dict1); $this->assertEquals(3, count($dict1)); $this->checkForExpectedValues($dict1->keys()->asResettable(), ['a', 'b', 'C']); $this->checkForExpectedValues($dict1->values()->asResettable(), [111, 2.7, '33three']); try { $dict2 = Enumerable::create(['a' => 111, 2 => 3, 'C' => '33three'])->toDictionary(null, $keyValidator); } catch (\Exception $ex) { $thrownEx2 = $ex; } $this->assertFalse(isset($dict2)); $this->assertTrue(isset($thrownEx2)); $this->assertInstanceOf(InvalidKeyException::class, $thrownEx2); } }
public function syntax(Language $lang = null, $linePrefix = '') { $classType = $this->classType($lang); $syntax = $linePrefix . $classType . ' ' . $this->reflector()->getShortName() . " {\n"; Enumerable::create($this->methods())->each(function (Method_ $x, IEachItemContext $ctx) use($lang, &$syntax) { if (!$ctx->isFirst()) { $syntax .= "\n"; } $syntax .= $x->syntax($lang, ' ') . "\n"; }); $syntax .= "}"; return $syntax; }
/** * {@inheritDoc} */ public final function split($delimiter, $limit = null) : IEnumerable { $delimiter = static::valueToString($delimiter, false); $str = $this->_wrappedValue; if (\func_num_args() < 2) { $result = Enumerable::create(\explode($delimiter, $str)); } else { $result = Enumerable::create(\explode($delimiter, $str, $limit)); } return $result->select(static::format('$x => new \\{0}($x)', static::class)); }
/** * @return static[] */ public static function fromNameArray($names, Language $lang = null, Project $proj = null) { $rc = new \ReflectionClass(static::class); $fn = $rc->getMethod('fromName')->getClosure(null); return Enumerable::create($names)->select('$x => \\trim($x)')->where('$x => "" !== $x')->distinct('($x) => \\strtolower($x)')->select(function ($x) use($fn, $lang, $proj) { return $fn($x, $lang, $proj); })->ofType($rc)->toArray(); }