Classe : \Lys\ArrayQuery

<?php
/**
* Lys
*
* GNU General Public License
*
* Copyright © 2007 - 2022, Yohann Schwan. All rights reserved.
*/
namespace Lys {

class ArrayQuery
{
/**
* @var string
*/
private static $key = array();

/**
* @var -1|1
*/
private static $asc = array();

/**
* @var array
*/
private static $criteria = array();

/**
* @args array $rows, $order
* @return array
*/
static function order(array $rows, $order)
{
self::$key = array();
self::$asc = array();

foreach(explode(',', $order) as $order)
{
$args = explode(' ', trim($order), 2) + array(1 => 'ASC');

if($args[1] == 'ASC')
{
self::$asc[] = 1;
}
elseif($args[1] == 'DESC')
{
self::$asc[] = -1;
}
else {
throw new LogicException('(ArrayQuery) Invalid order type, ASC or DESC only');
}

self::$key[] = $args[0];
}

if(uasort($rows, array('self', 'compare')))
{
return $rows;
}

throw new LogicException('(ArrayQuery) Unable to order array');
}

/**
* @args array $rows, int $page_id, int $page_size
* @return array
*/
static function paginate($rows, $page_id, $page_size)
{
if(($page_id < 1) || ($page_size < 1))
{
throw new LogicException('(ArrayQuery) Invalid page id or size');
}

$r = array(
'pagination_limit' => ceil(count($rows) / $page_size),

);

$rows = array_slice($rows, $id = ($page_id - 1) * $page_size, $page_size, true);

foreach($rows as $k => $row)
{
$id ++;

$rows[$k] += $r + array(
'row_id' => $id, 'pagination_id' => ceil($id / $page_size),
);
}

return $rows;
}

/**
* @args array $rows, array $q = array()
* @return array
*/
static function filter(array $rows, array $q = array())
{
self::$criteria = array();

foreach($q as $k => $v)
{
$args = explode(' ', $k, 2) + array(1 => '=');

# Fix criteria before self::clear
self::$criteria[] = array(trim($args[0]), trim($args[1]), $v);
}

return array_filter($rows, array('self', 'clear'));
}

/**
* Callback
*
* @args array $row, array $q
* @return null|array
*/
private static function clear(array $row)
{
foreach(self::$criteria as $args)
{
list($k, $op, $v) = $args;

if(isset($row[$k]))
{
$r = $row[$k];

if($op == '=')
{
if($r != $v)
{
return false;
}
}
elseif($op == '<>')
{
if($r == $v)
{
return false;
}
}
elseif($op == '<')
{
if(!($r < $v))
{
return false;
}
}
elseif($op == '>')
{
if(!($r > $v))
{
return false;
}
}
elseif($op == '<=')
{
if($r > $v)
{
return false;
}
}
elseif($op == '>=')
{
if($r < $v)
{
return false;
}
}
else {
throw new LogicException('(ArrayQuery) Invalid criteria operator ' . $op);
}
}
}

return true;
}

/**
* Callback
*
* @args array $a, array $b
* @return array
*/
private static function compare(array $a, array $b)
{
foreach(self::$key as $i => $k)
{
if($r = var_compare($a[$k], $b[$k]) * self::$asc[$i])
{
return $r;
}
}
}
}
}