déplacer les fonctions vers nulib
This commit is contained in:
parent
0c40769619
commit
f7e692df0c
@ -2,6 +2,7 @@
|
||||
namespace nulib\php\access;
|
||||
|
||||
use ArrayAccess;
|
||||
use nulib\A;
|
||||
use nulib\cl;
|
||||
|
||||
/**
|
||||
@ -118,85 +119,18 @@ class KeyAccess extends AbstractAccess {
|
||||
}
|
||||
|
||||
function ensureAssoc(array $keys, ?array $params=null): void {
|
||||
$dest =& $this->dest;
|
||||
$prefix = $params["key_prefix"] ?? null;
|
||||
$suffix = $params["key_suffix"] ?? null;
|
||||
$index = 0;
|
||||
foreach ($keys as $key) {
|
||||
if ($prefix !== null || $suffix !== null) {
|
||||
$destKey = "$prefix$key$suffix";
|
||||
} else {
|
||||
# préserver les clés numériques
|
||||
$destKey = $key;
|
||||
}
|
||||
if ($dest !== null && array_key_exists($destKey, $dest)) continue;
|
||||
while (in_array($index, $keys, true)) {
|
||||
$index++;
|
||||
}
|
||||
if ($dest !== null && array_key_exists($index, $dest)) {
|
||||
$dest[$destKey] = $dest[$index];
|
||||
unset($dest[$index]);
|
||||
$index++;
|
||||
}
|
||||
}
|
||||
A::ensure_assoc($this->dest, $keys, $params);
|
||||
}
|
||||
|
||||
function ensureKeys(array $defaults, ?array $missings, ?array $params=null): void {
|
||||
$dest =& $this->dest;
|
||||
$keys = array_keys($defaults);
|
||||
$prefix = $params["key_prefix"] ?? null;
|
||||
$suffix = $params["key_suffix"] ?? null;
|
||||
foreach ($keys as $key) {
|
||||
$destKey = "$prefix$key$suffix";
|
||||
$haveMissing = $missings !== null && array_key_exists($key, $missings);
|
||||
if ($dest === null || !array_key_exists($destKey, $dest)) {
|
||||
$dest[$destKey] = $defaults[$key];
|
||||
} elseif ($haveMissing && $dest[$destKey] === $missings[$key]) {
|
||||
$dest[$destKey] = $defaults[$key];
|
||||
}
|
||||
}
|
||||
A::ensure_keys($this->dest, $defaults, $missings, $params);
|
||||
}
|
||||
|
||||
function deleteMissings(array $missings, ?array $params=null): void {
|
||||
$dest =& $this->dest;
|
||||
$prefix = $params["key_prefix"] ?? null;
|
||||
$suffix = $params["key_suffix"] ?? null;
|
||||
foreach ($missings as $key => $missing) {
|
||||
$destKey = "$prefix$key$suffix";
|
||||
if (array_key_exists($destKey, $dest) && $dest[$destKey] === $missing) {
|
||||
unset($dest[$destKey]);
|
||||
}
|
||||
}
|
||||
A::delete_missings($this->dest, $missings, $params);
|
||||
}
|
||||
|
||||
function ensureOrder(array $keys, ?array $params=null): void {
|
||||
$dest =& $this->dest;
|
||||
if ($dest === null) return;
|
||||
|
||||
$prefix = $params["key_prefix"] ?? null;
|
||||
$suffix = $params["key_suffix"] ?? null;
|
||||
if ($prefix !== null || $suffix !== null) {
|
||||
foreach ($keys as &$key) {
|
||||
$key = "$prefix$key$suffix";
|
||||
}; unset($key);
|
||||
}
|
||||
|
||||
$destKeys = array_keys($dest);
|
||||
$keyCount = count($keys);
|
||||
if (array_slice($destKeys, 0, $keyCount) === $keys) {
|
||||
# si le tableau a déjà les bonnes clés dans le bon ordre, rien à faire
|
||||
return;
|
||||
}
|
||||
|
||||
$ordered = [];
|
||||
foreach ($keys as $key) {
|
||||
if (array_key_exists($key, $dest)) {
|
||||
$ordered[$key] = $dest[$key];
|
||||
unset($dest[$key]);
|
||||
}
|
||||
}
|
||||
$preserveKeys = $params["preserve_keys"] ?? false;
|
||||
if ($preserveKeys) $dest = cl::merge2($ordered, $dest);
|
||||
else $dest = array_merge($ordered, $dest);
|
||||
A::ensure_order($this->dest, $keys, $params);
|
||||
}
|
||||
}
|
||||
|
||||
@ -30,77 +30,6 @@ class Cursor implements Iterator {
|
||||
"cols_func" => ["?callable"],
|
||||
];
|
||||
|
||||
/**
|
||||
* tester si $row satisfait les conditions de $filter
|
||||
* - $filter est un scalaire, le transformer en [$filter]
|
||||
* - sinon $filter doit être un tableau de scalaires
|
||||
*
|
||||
* les règles des conditions sont les suivantes:
|
||||
* - une valeur séquentielle $key est équivalente à la valeur associative
|
||||
* $key => true
|
||||
* - une valeur associative $key => bool indique que la clé correspondante ne
|
||||
* doit pas (resp. doit) exister selon que bool vaut false (resp. true)
|
||||
* - une valeur associative $key => $value indique que la clé correspondante
|
||||
* doit exiter avec la valeur spécifiée
|
||||
*/
|
||||
static function filter_row(?array $row, $filter): bool {
|
||||
if ($filter === null) return false;
|
||||
if (!is_array($filter)) $filter = [$filter];
|
||||
if (!$filter) return false;
|
||||
|
||||
$index = 0;
|
||||
foreach ($filter as $key => $value) {
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
if ($row === null) return false;
|
||||
if (!array_key_exists($value, $row)) return false;
|
||||
} elseif (is_bool($value)) {
|
||||
if ($value) {
|
||||
if ($row === null || !array_key_exists($key, $row)) return false;
|
||||
} else {
|
||||
if ($row !== null && array_key_exists($key, $row)) return false;
|
||||
}
|
||||
} else {
|
||||
if ($row === null) return false;
|
||||
if (!array_key_exists($key, $row)) return false;
|
||||
if ($row[$key] !== $value) return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* mapper le tableau source $row selon les règles suivantes illustrées dans
|
||||
* l'exemple suivant:
|
||||
* si
|
||||
* $map = ["a", "b" => "x", "c" => function() { return "y"; }, "d" => null]
|
||||
* alors retourner le tableau
|
||||
* ["a" => $row["a"], "b" => $row["x"], "c" => "y", "d" => null]
|
||||
*
|
||||
* si une fonction est utilisée, sa signature est
|
||||
* <code>function(mixed $value, string|int $key, ?array $row)</code>
|
||||
*/
|
||||
static function map_row(?array $row, ?array $map): array {
|
||||
if ($map === null) return $row;
|
||||
$index = 0;
|
||||
$mapped = [];
|
||||
foreach ($map as $key => $value) {
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
if ($value === null) $mapped[] = null;
|
||||
else $mapped[$value] = cl::get($row, $value);
|
||||
} elseif (is_callable($value)) {
|
||||
$func = func::with($value);
|
||||
$value = cl::get($row, $key);
|
||||
$mapped[$key] = $func->invoke([$value, $key, $row]);
|
||||
} else {
|
||||
if ($value === null) $mapped[$key] = null;
|
||||
else $mapped[$key] = cl::get($row, $value);
|
||||
}
|
||||
}
|
||||
return $mapped;
|
||||
}
|
||||
|
||||
function __construct(?iterable $rows=null, ?array $params=null) {
|
||||
if ($rows !== null) $params["rows"] = $rows;
|
||||
|
||||
@ -149,7 +78,7 @@ class Cursor implements Iterator {
|
||||
|
||||
function setFilter(array $filter): self {
|
||||
$this->filterFunc = func::with(function(?array $row) use ($filter) {
|
||||
return self::filter_row($row, $filter);
|
||||
return cl::filter($row, $filter);
|
||||
});
|
||||
return $this;
|
||||
}
|
||||
@ -165,7 +94,7 @@ class Cursor implements Iterator {
|
||||
|
||||
function setMap(array $map): self {
|
||||
$this->mapFunc = func::with(function(?array $row) use ($map) {
|
||||
return self::map_row($row, $map);
|
||||
return cl::map($row, $map);
|
||||
});
|
||||
return $this;
|
||||
}
|
||||
|
||||
@ -16,7 +16,7 @@ class CursorTest extends TestCase {
|
||||
function test_map_row() {
|
||||
$cursor = new class extends Cursor {
|
||||
function mapRow(array $row, ?array $map): array {
|
||||
return self::map_row($row, $map);
|
||||
return cl::map($row, $map);
|
||||
}
|
||||
};
|
||||
$row = ["a" => 1, "b" => 2, "c" => 3, "x" => 99];
|
||||
@ -32,7 +32,7 @@ class CursorTest extends TestCase {
|
||||
function test_filter_row() {
|
||||
$cursor = new class extends Cursor {
|
||||
function filterRow(array $row, $filter): bool {
|
||||
return self::filter_row($row, $filter);
|
||||
return cl::filter($row, $filter);
|
||||
}
|
||||
};
|
||||
$row = ["a" => 1, "b" => 2, "c" => 3, "x" => 99];
|
||||
|
||||
Loading…
Reference in New Issue
Block a user