UArrayModels.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\utils\models;
 
use Ubiquity\orm\OrmUtils;
 
class UArrayModels {
    public static function sort(array $array , callable $callback):array{
        \usort($array,$callback);
        return $array;
    }
    
    public static function groupsBy(array $objects, array $gbCallbacks, ?callable $lineCallback=null, ?bool $sort=null):array {
        if(\count($gbCallbacks)==0) {
            return $objects;
        }
        $objects=self::groupBy($objects, current($gbCallbacks), $lineCallback, $sort);
        \array_shift($gbCallbacks);
        $result=[];
        foreach ($objects as $k=>$v){
            $result[$k]=self::groupsBy($v,$gbCallbacks);
        }
        return $result;
    }
    
    public static function groupBy(array $objects, callable $gbCallback, ?callable $lineCallback=null, ?bool $sort=null):array {
        if($sort){
            $objects=self::sort($objects, function ($item1, $item2) use ($gbCallback){
                return $gbCallback($item1)<=>$gbCallback($item2);
            });
        }elseif($sort===false){
            $objects=self::sort($objects, function ($item1, $item2) use ($gbCallback){
                return $gbCallback($item2)<=>$gbCallback($item1);
            });
        }
        $result=[];
        $groupBy=null;
        foreach ($objects as $line){
            if($groupBy!==($nGB=$gbCallback($line))){
                $groupBy=$nGB;
            }
            $result[$groupBy][]=(isset($lineCallback))?$lineCallback($line):$line;
        }
        return $result;
    }
    
    public static function asKeyValues(array $objects, $keyFunction = NULL, $valueFunction = NULL) {
        $result = [];
        if (isset($valueFunction) === false) {
            $valueFunction = '__toString';
        }
        if (isset($keyFunction) === false) {
            foreach ($objects as $object) {
                $result[] = self::callFunction($object, $valueFunction);
            }
        } else {
            foreach ($objects as $object) {
                $result[self::callFunction($object, $keyFunction)] = self::callFunction($object, $valueFunction);
            }
        }
        return $result;
    }
    
    public static function find(?array $objects,callable $callback){
        if(\is_array($objects)) {
            foreach ($objects as $o){
                if($callback($o)){
                    return $o;
                }
            }
        }
        return null;
    }
    
    public static function findBy(?array $objects,$value,string $property='id'){
        if(!\is_array($objects)){
            return null;
        }
        $get='get'.\ucfirst($property);
        foreach ($objects as $index=>$o) {
            if($value==$o->$get()){
                return $o;
            }
        }
        return null;
    }
    
    public static function findById(?array $objects,$idValue){
        if(!is_array($objects) && \count($objects)>0){
            return null;
        }
        $property=OrmUtils::getFirstKey(\get_class(\current($objects)));
        return self::findBy($objects, $idValue,$property);
    }
    
    public static function contains(?array $objects,callable $callback):bool{
        return self::find($objects, $callback)!==null;
    }
    
    public static function containsBy(?array $objects,object $object,string $property='id'):bool{
        if($object===null){
            return false;
        }
        $get='get'.\ucfirst($property);
        $objectValue=$object->$get();
        return self::findBy($objects, $objectValue,$property)!==null;
    }
    
    public static function containsById(?array $objects,object $object):bool {
        if($object===null){
            return false;
        }
        $property=OrmUtils::getFirstKey(\get_class($object));
        return self::containsBy($objects, $object,$property);
    }
    
    
    public static function remove(?array $objects,callable $callback):array{
        foreach ($objects as $index=>$o) {
            if($callback($o)){
                unset($objects[$index]);
                break;
            }
        }
        return $objects;
    }
 
    public static function removeBy(?array $objects,object $object,string $property='id'):?array{
        if(!is_array($objects) || $object==null){
            return null;
        }
        $get='get'.\ucfirst($property);
        $objectValue=$object->$get();
        foreach ($objects as $index=>$o) {
            if($objectValue===$o->$get()){
                unset($objects[$index]);
                return $objects;
            }
        }
        return $objects;
    }
    
    public static function removeAllBy(?array $objects,object $object,string $property='id'):?array{
        if(!is_array($objects) || $object==null){
            return null;
        }
        $get='get'.\ucfirst($property);
        $objectValue=$object->$get();
        $toRemove=[];
        foreach ($objects as $index=>$o) {
            if($objectValue===$o->$get()){
                $toRemove[]=$index;
            }
        }
        foreach ($toRemove as $index){
            unset($objects[$index]);
        }
        return $objects;
    }
    
    public static function compute(?array $objects,callable $callable,callable $computeCall){
        $res=null;
        if($objects!=null) {
            foreach ($objects as $object) {
                $computeCall($res, $callable($object));
            }
        }
        return $res;
    }
    
    public static function computeSumProperty(?array $objects,string $propertyName){
        $getter='get'.\ucfirst($propertyName);
        return self::compute($objects,fn($o)=>$o->$getter(),fn(&$r,$o)=>$r+=$o);
    }
    
    public static function computeSum(?array $objects,callable $callable){
        return self::compute($objects,$callable,fn(&$r,$o)=>$r+=$o);
    }
    
    public static function removeAll(?array $objects,callable $callback):array{
        $toRemove=[];
        foreach ($objects as $index=>$o) {
            if($callback($o)){
                $toRemove[]=$index;
            }
        }
        foreach ($toRemove as $index){
            unset($objects[$index]);
        }
        return $objects;
    }
    
    public static function asArray(array $objects):array{
        $result=[];
        foreach ($objects as $index=>$o) {
            $result[$index]=$o->_rest??[];
        }
        return $result;
    }
    
    public static function asJson(array $objects,int $options=0):string{
        $result=[];
        foreach ($objects as $index=>$o) {
            $result[$index]=$o->_rest??[];
        }
        return \json_encode($result,$options);
    }
    
    public static function asArrayProperties(array $objects,array $properties):array{
        $res=[];
        $accessors=self::getAccessors($properties);
        foreach ($objects as $object){
            $or=[];
            foreach ($accessors as $prop=>$get){
                $or[$prop]=$object->$get();
            }
            $res[]=$or;
        }
        return $res;
    }
    
    public static function asJsonProperties(array $objects,array $properties,int $options=0):string{
        return \json_encode(self::asArrayProperties($objects, $properties),$options);
    }
    
    private static function getAccessors($properties,$prefix='get'){
        $res=[];
        foreach ($properties as $property){
            $res[$property]=$prefix.\ucfirst($property);
            
        }
        return $res;
    }
    
    private static function callFunction($object, $callback) {
        if (\is_string($callback)){
            return \call_user_func(array(
                    $object,
                    $callback
            ), []);
        }
        if (\is_callable($callback)) {
            return $callback($object);
        }
        return $object;
    }
}