AbstractCsv.php
2 months ago
ByteSequence.php
2 months ago
CannotInsertRecord.php
2 months ago
CharsetConverter.php
2 months ago
ColumnConsistency.php
2 months ago
EncloseField.php
2 months ago
EscapeFormula.php
2 months ago
Exception.php
2 months ago
HTMLConverter.php
2 months ago
Info.php
2 months ago
InvalidArgument.php
2 months ago
MapIterator.php
2 months ago
RFC4180Field.php
2 months ago
Reader.php
2 months ago
ResultSet.php
2 months ago
Statement.php
2 months ago
Stream.php
2 months ago
SyntaxError.php
2 months ago
TabularDataReader.php
2 months ago
UnableToProcessCsv.php
2 months ago
UnavailableFeature.php
2 months ago
UnavailableStream.php
2 months ago
Writer.php
2 months ago
XMLConverter.php
2 months ago
functions.php
2 months ago
functions_include.php
2 months ago
ResultSet.php
211 lines
| 1 | <?php |
| 2 | |
| 3 | /** |
| 4 | * League.Csv (https://csv.thephpleague.com) |
| 5 | * |
| 6 | * (c) Ignace Nyamagana Butera <nyamsprod@gmail.com> |
| 7 | * |
| 8 | * For the full copyright and license information, please view the LICENSE |
| 9 | * file that was distributed with this source code. |
| 10 | */ |
| 11 | declare (strict_types=1); |
| 12 | namespace ProfilePressVendor\League\Csv; |
| 13 | |
| 14 | use CallbackFilterIterator; |
| 15 | use Generator; |
| 16 | use Iterator; |
| 17 | use JsonSerializable; |
| 18 | use LimitIterator; |
| 19 | use function array_flip; |
| 20 | use function array_search; |
| 21 | use function is_string; |
| 22 | use function iterator_count; |
| 23 | use function iterator_to_array; |
| 24 | /** |
| 25 | * Represents the result set of a {@link Reader} processed by a {@link Statement}. |
| 26 | */ |
| 27 | class ResultSet implements TabularDataReader, JsonSerializable |
| 28 | { |
| 29 | /** The CSV records collection. */ |
| 30 | protected Iterator $records; |
| 31 | /** @var array<string> The CSV records collection header. */ |
| 32 | protected array $header = []; |
| 33 | public function __construct(Iterator $records, array $header) |
| 34 | { |
| 35 | $this->validateHeader($header); |
| 36 | $this->records = $records; |
| 37 | $this->header = $header; |
| 38 | } |
| 39 | /** |
| 40 | * @throws SyntaxError if the header syntax is invalid |
| 41 | */ |
| 42 | protected function validateHeader(array $header): void |
| 43 | { |
| 44 | if ($header !== $filtered_header = array_filter($header, 'is_string')) { |
| 45 | throw SyntaxError::dueToInvalidHeaderColumnNames(); |
| 46 | } |
| 47 | if ($header !== array_unique($filtered_header)) { |
| 48 | throw SyntaxError::dueToDuplicateHeaderColumnNames($header); |
| 49 | } |
| 50 | } |
| 51 | public function __destruct() |
| 52 | { |
| 53 | unset($this->records); |
| 54 | } |
| 55 | /** |
| 56 | * Returns a new instance from an object implementing the TabularDataReader interface. |
| 57 | */ |
| 58 | public static function createFromTabularDataReader(TabularDataReader $reader): self |
| 59 | { |
| 60 | return new self($reader->getRecords(), $reader->getHeader()); |
| 61 | } |
| 62 | /** |
| 63 | * Returns the header associated with the result set. |
| 64 | * |
| 65 | * @return array<string> |
| 66 | */ |
| 67 | public function getHeader(): array |
| 68 | { |
| 69 | return $this->header; |
| 70 | } |
| 71 | public function getIterator(): Iterator |
| 72 | { |
| 73 | return $this->getRecords(); |
| 74 | } |
| 75 | public function getRecords(array $header = []): Iterator |
| 76 | { |
| 77 | $this->validateHeader($header); |
| 78 | $records = $this->combineHeader($header); |
| 79 | foreach ($records as $offset => $value) { |
| 80 | yield $offset => $value; |
| 81 | } |
| 82 | } |
| 83 | /** |
| 84 | * Combine the header to each record if present. |
| 85 | */ |
| 86 | protected function combineHeader(array $header): Iterator |
| 87 | { |
| 88 | if ($header === $this->header || [] === $header) { |
| 89 | return $this->records; |
| 90 | } |
| 91 | $field_count = count($header); |
| 92 | $mapper = static function (array $record) use ($header, $field_count): array { |
| 93 | if (count($record) != $field_count) { |
| 94 | $record = array_slice(array_pad($record, $field_count, null), 0, $field_count); |
| 95 | } |
| 96 | /** @var array<string|null> $assocRecord */ |
| 97 | $assocRecord = array_combine($header, $record); |
| 98 | return $assocRecord; |
| 99 | }; |
| 100 | return new MapIterator($this->records, $mapper); |
| 101 | } |
| 102 | public function count(): int |
| 103 | { |
| 104 | return iterator_count($this->records); |
| 105 | } |
| 106 | public function jsonSerialize(): array |
| 107 | { |
| 108 | return iterator_to_array($this->records, \false); |
| 109 | } |
| 110 | public function fetchOne(int $nth_record = 0): array |
| 111 | { |
| 112 | if ($nth_record < 0) { |
| 113 | throw InvalidArgument::dueToInvalidRecordOffset($nth_record, __METHOD__); |
| 114 | } |
| 115 | $iterator = new LimitIterator($this->records, $nth_record, 1); |
| 116 | $iterator->rewind(); |
| 117 | $result = $iterator->current(); |
| 118 | if (!is_array($result)) { |
| 119 | return []; |
| 120 | } |
| 121 | return $result; |
| 122 | } |
| 123 | /** |
| 124 | * @throws Exception |
| 125 | */ |
| 126 | public function fetchColumnByName(string $name): Iterator |
| 127 | { |
| 128 | return $this->yieldColumn($this->getColumnIndexByValue($name, 'name', __METHOD__)); |
| 129 | } |
| 130 | /** |
| 131 | * @throws Exception |
| 132 | */ |
| 133 | public function fetchColumnByOffset(int $offset): Iterator |
| 134 | { |
| 135 | return $this->yieldColumn($this->getColumnIndexByKey($offset, 'offset', __METHOD__)); |
| 136 | } |
| 137 | public function fetchColumn($index = 0): Iterator |
| 138 | { |
| 139 | return $this->yieldColumn($this->getColumnIndex($index, 'offset', __METHOD__)); |
| 140 | } |
| 141 | /** |
| 142 | * @param string|int $offset |
| 143 | */ |
| 144 | protected function yieldColumn($offset): Generator |
| 145 | { |
| 146 | $iterator = new MapIterator(new CallbackFilterIterator($this->records, fn(array $record): bool => isset($record[$offset])), fn(array $record): string => $record[$offset]); |
| 147 | foreach ($iterator as $key => $value) { |
| 148 | yield $key => $value; |
| 149 | } |
| 150 | } |
| 151 | /** |
| 152 | * Filter a column name against the header if any. |
| 153 | * |
| 154 | * @param string|int $field the field name or the field index |
| 155 | * |
| 156 | * @throws InvalidArgument if the field is invalid or not found |
| 157 | * |
| 158 | * @return string|int |
| 159 | */ |
| 160 | protected function getColumnIndex($field, string $type, string $method) |
| 161 | { |
| 162 | if (is_string($field)) { |
| 163 | return $this->getColumnIndexByValue($field, $type, $method); |
| 164 | } |
| 165 | return $this->getColumnIndexByKey($field, $type, $method); |
| 166 | } |
| 167 | /** |
| 168 | * Returns the selected column name. |
| 169 | * |
| 170 | * @throws InvalidArgument if the column is not found |
| 171 | */ |
| 172 | protected function getColumnIndexByValue(string $value, string $type, string $method): string |
| 173 | { |
| 174 | if (\false === array_search($value, $this->header, \true)) { |
| 175 | throw InvalidArgument::dueToInvalidColumnIndex($value, $type, $method); |
| 176 | } |
| 177 | return $value; |
| 178 | } |
| 179 | /** |
| 180 | * Returns the selected column name according to its offset. |
| 181 | * |
| 182 | * @throws InvalidArgument if the field is invalid or not found |
| 183 | * |
| 184 | * @return int|string |
| 185 | */ |
| 186 | protected function getColumnIndexByKey(int $index, string $type, string $method) |
| 187 | { |
| 188 | if ($index < 0) { |
| 189 | throw InvalidArgument::dueToInvalidColumnIndex($index, $type, $method); |
| 190 | } |
| 191 | if ([] === $this->header) { |
| 192 | return $index; |
| 193 | } |
| 194 | $value = array_search($index, array_flip($this->header), \true); |
| 195 | if (\false === $value) { |
| 196 | throw InvalidArgument::dueToInvalidColumnIndex($index, $type, $method); |
| 197 | } |
| 198 | return $value; |
| 199 | } |
| 200 | public function fetchPairs($offset_index = 0, $value_index = 1): Iterator |
| 201 | { |
| 202 | $offset = $this->getColumnIndex($offset_index, 'offset', __METHOD__); |
| 203 | $value = $this->getColumnIndex($value_index, 'value', __METHOD__); |
| 204 | $iterator = new MapIterator(new CallbackFilterIterator($this->records, fn(array $record): bool => isset($record[$offset])), fn(array $record): array => [$record[$offset], $record[$value] ?? null]); |
| 205 | /** @var array{0:int|string, 1:string|null} $pair */ |
| 206 | foreach ($iterator as $pair) { |
| 207 | yield $pair[0] => $pair[1]; |
| 208 | } |
| 209 | } |
| 210 | } |
| 211 |