new pisilinux web sites

Internal/package-datatypes/Arrays/AddElement.php

@@ -0,0 +1,55 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+class AddElement
+{
+    /**
+     * Add First
+     * 
+     * @param array $array
+     * @param mixed $element
+     * 
+     * @return array
+     */
+    public static function first(array $array, $element, $type = 'array_unshift') : array
+    {
+        if( ! is_array($element) )
+        {
+            $type($array, $element);
+        }
+        else
+        {
+            if( $type === 'array_unshift' )
+            {
+                $array = array_merge($element, $array);
+            }
+            else
+            {
+                $array = array_merge($array, $element);
+            }
+        }
+
+        return $array;
+    }
+
+    /**
+     * Add Last
+     * 
+     * @param array $array
+     * @param mixed $element
+     * 
+     * @return array
+     */
+    public static function last(array $array, $element) : array
+    {
+        return self::first($array, $element, 'array_push');
+    }
+}

Internal/package-datatypes/Arrays/Casing.php

@@ -0,0 +1,137 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+use ZN\Datatype;
+
+class Casing
+{
+    /**
+     * Case Array
+     * 
+     * @param array  $array
+     * @param string $type   - options[lower|upper|title]
+     * @param string $keyval - options[all|key|value]
+     * 
+     * @return array
+     */
+    public static function use(array $array, string $type = 'lower', string $keyval = 'all') : array
+    {
+        return Datatype::caseArray($array, $type, $keyval);
+    }
+
+    /**
+     * Lower Keys
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function lowerKeys(array $array) : array
+    {
+        return array_change_key_case($array);
+    }
+
+    /**
+     * Title Keys
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function titleKeys(array $array) : array
+    {
+        return self::use($array, 'title', 'key');
+    }
+
+    /**
+     * Upper Keys
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function upperKeys(array $array) : array
+    {
+        return array_change_key_case($array, CASE_UPPER);
+    }
+
+    /**
+     * Lower Values
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function lowerValues(array $array) : array
+    {
+        return self::use($array, 'lower', 'value');
+    }
+
+    /**
+     * Title Values
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function titleValues(array $array) : array
+    {
+        return self::use($array, 'title', 'value');
+    }
+
+    /**
+     * Upper Values
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function upperValues(array $array) : array
+    {
+        return self::use($array, 'upper', 'value');
+    }
+
+    /**
+     * All Lower Case
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function lower(array $array) : array
+    {
+        return self::use($array, 'lower', 'all');
+    }
+
+    /**
+     * All Title Case
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function title(array $array) : array
+    {
+        return self::use($array, 'title', 'all');
+    }
+
+    /**
+     * All Upper Case
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function upper(array $array) : array
+    {
+        return self::use($array, 'upper', 'all');
+    }
+}

Internal/package-datatypes/Arrays/Each.php

@@ -0,0 +1,27 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+class Each
+{
+    /**
+     * Each
+     * 
+     * @param array    $array
+     * @param callable $callable
+     */
+    public static function use(array $array, callable $callable)
+    {
+        foreach( $array as $k => $v )
+        {
+            $callable($v, $k);
+        }
+    }
+}

Internal/package-datatypes/Arrays/Element.php

@@ -0,0 +1,38 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+use ZN\DataTypes\Exception\InvalidArgumentException;
+
+class Element
+{
+    /**
+     * Array Elements
+     * 
+     * @param array  $array
+     * @param string $keyval = 'value' - options[value|key|values|keys]
+     * 
+     * @return mixed 
+     */
+    public static function use(array $array, string $keyval = 'value')
+    {
+        switch( $keyval )
+        {
+            case 'value'  : return current($array);
+            case 'key'    : return key($array);
+            case 'values' : return array_values($array);
+            case 'keys'   : return array_keys($array);
+            default       : throw new InvalidArgumentException
+            (
+                '[Arrays::keyval()], 2.($keyval) parameter is invalid! [Available Options:] value, key, values, keys'
+            );
+        }
+    }
+}

Internal/package-datatypes/Arrays/Excluding.php

@@ -0,0 +1,43 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+use ZN\DataTypes\Exception\LogicException;
+
+class Excluding
+{
+    /**
+     * Exclude Element
+     * 
+     * @param array $array
+     * @param array $excluding
+     * 
+     * @return array
+     */
+    public static function use(array $array, array $excluding) : array
+    {
+        $newArray = [];
+
+        if( count($excluding) > count($array) )
+        {
+            return $newArray;
+        }
+
+        foreach( $array as $key => $val )
+        {
+            if( ! in_array($val, $excluding) && ! in_array($key, $excluding) )
+            {
+                $newArray[$key] = $val;
+            }
+        }
+
+        return $newArray;
+    }
+}

Internal/package-datatypes/Arrays/Force.php

@@ -0,0 +1,70 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+class Force
+{
+    /**
+     * Force Values
+     * 
+     * @param array    $array
+     * @param callable $callable
+     * 
+     * @return array
+     */
+    public static function values(array $array, callable $callable) : array
+    {
+        return array_map($callable, $array);
+    }
+
+    /**
+     * Force Keys
+     * 
+     * @param array    $array
+     * @param callable $callable
+     * 
+     * @return array
+     */
+    public static function keys(array $array, callable $callable) : array
+    {
+        $keys = array_map($callable, array_keys($array));
+
+        return array_combine($keys, array_values($array));
+    }
+
+    /**
+     * Force All
+     * 
+     * @param array    $array
+     * @param callable $callable
+     * 
+     * @return array
+     */
+    public static function do(array $array, callable $callable) : array
+    {
+        $values = array_values(array_map($callable, $array));
+        $keys   = array_values(array_map($callable, array_keys($array)));
+
+        return array_combine($keys, $values);
+    }
+
+    /**
+     * Force Recursive
+     * 
+     * @param array $array
+     * @param callable $callback
+     * 
+     * @return array
+     */
+    public static function recursive(array $array, callable $callback) : array
+    {
+        return filter_var($array, FILTER_CALLBACK, ['options' => $callback]);
+    }
+}

Internal/package-datatypes/Arrays/GetElement.php

@@ -0,0 +1,84 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+class GetElement
+{
+    /**
+     * Get Last Element
+     * 
+     * @param array $array
+     * @param int   $count       = 1
+     * @param bool  $preserveKey = false
+     * 
+     * @return array
+     */
+    public static function last(array $array, int $count = 1, bool $preserveKey = false)
+    {
+        if( $count <= 1 )
+        {
+            $array = end($array) ?? NULL;
+        }
+        else
+        {
+            return array_slice($array, -$count, NULL, $preserveKey);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Get First Element
+     * 
+     * @param array $array
+     * @param int   $count       = 1
+     * @param bool  $preserveKey = false
+     * 
+     * @return array
+     */
+    public static function first(array $array, int $count = 1, bool $preserveKey = false)
+    {
+        if( $count <= 1 )
+        {
+            $array = current($array) ?? NULL;
+        }
+        else
+        {
+            return array_slice($array, 0, $count, $preserveKey);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Get values by key
+     * 
+     * 5.7.6[added]
+     * 
+     * @param array  $arrays
+     * @param string $pick
+     * 
+     * @return array
+     */
+    public static function pick(array $arrays, string $pick) : array
+    {
+        $values = [];
+    
+        foreach( $arrays as $array ) 
+        {
+            if( is_array($array) && isset($array[$pick]) ) 
+            {
+                $values[] = $array[$pick];
+            }
+        }
+    
+        return $values;
+    }
+}

Internal/package-datatypes/Arrays/Including.php

@@ -0,0 +1,43 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+use ZN\DataTypes\Exception\LogicException;
+
+class Including
+{
+    /**
+     * Include Element
+     * 
+     * @param array $array
+     * @param array $including
+     * 
+     * @return array
+     */
+    public static function use(array $array, array $including) : array
+    {
+        $newArray = [];
+
+        if( count($including) > count($array) )
+        {
+            return $newArray;
+        }
+
+        foreach( $array as $key => $val )
+        {
+            if( in_array($val, $including) || in_array($key, $including) )
+            {
+                $newArray[$key] = $val;
+            }
+        }
+
+        return $newArray;
+    }
+}

Internal/package-datatypes/Arrays/RemoveElement.php

@@ -0,0 +1,138 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+class RemoveElement
+{
+    /**
+     * Remove Key
+     * 
+     * @param array $array
+     * @param mixed $keys
+     * 
+     * @return array
+     */
+    public static function key(array $array, $keys) : array
+    {
+        if( ! is_array($keys) )
+        {
+            unset($array[$keys]);
+        }
+        else
+        {
+            foreach( $keys as $key )
+            {
+                unset($array[$key]);
+            }
+        }
+
+        return $array;
+    }
+
+    /**
+     * Remove Value
+     * 
+     * @param array $array
+     * @param mixed $values
+     * 
+     * @return array
+     */
+    public static function value(array $array, $values) : array
+    {
+        return self::element($array, $values);
+    }
+
+    /**
+     * Remove
+     * 
+     * @param array $array
+     * @param mixed $keys
+     * @param mixed $values
+     * 
+     * @return array
+     */
+    public static function use(array $array, $keys = [], $values = []) : array
+    {
+        if( ! empty($keys) )
+        {
+            $array = self::key($array, $keys);
+        }
+
+        if( ! empty($values) )
+        {
+            $array = self::value($array, $values);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Remove Last Element
+     * 
+     * @param array $array
+     * @param int   $count = 1
+     * 
+     * @return array
+     */
+    public static function last(array $array, int $count = 1, $type = 'array_pop') : array
+    {
+        if( $count <= 1 )
+        {
+            $type($array);
+        }
+        else
+        {
+            $arrayCount = count($array);
+
+            for( $i = 1; $i <= $count; $i++ )
+            {
+                $type($array);
+
+                if( $i === $arrayCount )
+                {
+                    break; // @codeCoverageIgnore
+                }
+            }
+        }
+
+        return $array;
+    }
+
+    /**
+     * Remove First Element
+     * 
+     * @param array $array
+     * @param int   $count = 1
+     * 
+     * @return array
+     */
+    public static function first(array $array, int $count = 1) : array
+    {
+        return self::last($array, $count, 'array_shift');
+    }
+
+    /**
+     * Delete Element
+     * 
+     * @param array $array
+     * @param mixed $object
+     * 
+     * @return array
+     */
+    public static function element(array $array, $object) : array
+    {
+        if( ! is_array($object) )
+        {
+            $object = [$object];
+        }
+
+        return array_diff($array, $object);
+    }
+}

Internal/package-datatypes/Arrays/Search.php

@@ -0,0 +1,241 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+class Search
+{
+    /**
+     * Finds the expression between two expressions, including parameters. By value to key.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     * 
+     * @return array|bool
+     */
+    public static function betweenBothWithValueToKey(array $array, $start, $end)
+    {
+        $startPosition = array_search($start, $array);
+
+        if( isset($array[$end]) && $startPosition !== false )
+        {
+            return self::betweenBothForeachFunction($array, $startPosition, $end);
+        }
+
+        return false;
+    }
+
+    /**
+     * Finds the expression between two expressions, including parameters. By key to value.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     * 
+     * @return array|bool
+     */
+    public static function betweenBothWithKeyToValue(array $array, $start, $end)
+    {
+        $endPosition = array_search($end, $array);
+
+        if( isset($array[$start]) && $endPosition !== false )
+        {
+            return self::betweenBothForeachFunction($array, $start, $endPosition);
+        }
+
+        return false;
+    }
+
+    /**
+     * Finds the expression between two statements.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     * 
+     * @return array|bool
+     */
+    public static function betweenWithValueToKey(array $array, $start, $end)
+    {
+        $startPosition = array_search($start, $array);
+
+        if( isset($array[$end]) && $startPosition !== false )
+        {
+            return self::betweenForeachFunction($array, $startPosition, $end);
+        }
+
+        return false;
+    }
+
+    /**
+     * Finds the expression between two statements.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     * 
+     * @return array|bool
+     */
+    public static function betweenWithKeyToValue(array $array, $start, $end)
+    {
+        $endPosition = array_search($end, $array);
+
+        if( isset($array[$start]) && $endPosition !== false )
+        {
+            return self::betweenForeachFunction($array, $start, $endPosition);
+        }
+
+        return false;
+    }
+
+    /**
+     * Finds the expression between two statements.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     * 
+     * @return array|bool
+     */
+    public static function betweenWithKey(array $array, $start, $end)
+    {
+        if( isset($array[$start]) )
+        {
+            return self::betweenForeachFunction($array, $start, $end);
+        }
+
+
+        return false;
+    }
+
+    /**
+     * Finds the expression between two expressions, including parameters.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     * 
+     * @return array|bool
+     */
+    public static function betweenBothWithKey(array $array, $start, $end)
+    {
+        if( isset($array[$start]) )
+        {
+            return self::betweenBothForeachFunction($array, $start, $end);
+        }
+
+        return false;
+    }
+
+    /**
+     * Finds the expression between two statements.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     * 
+     * @return array|bool
+     */
+    public static function between(array $array, $start, $end)
+    {
+        if( self::betweenFunction($array, $start, $end, $startPosition, $endPosition) )
+        {
+            return self::betweenForeachFunction($array, $startPosition, $endPosition);
+        }
+
+        return false;
+    }
+
+   /**
+     * Finds the expression between two expressions, including parameters.
+     * 
+     * @param array $array
+     * @param mixed $start
+     * @param mixed $end
+     *
+     * @return array|bool
+     */
+    public static function betweenBoth(array $array, $start, $end) 
+    {
+        if( self::betweenFunction($array, $start, $end, $startPosition, $endPosition) )
+        {
+            return self::betweenBothForeachFunction($array, $startPosition, $endPosition);
+        }
+
+        return false;
+    }
+
+    /**
+     * Protected between foreach function.
+     */
+    protected static function betweenForeachFunction($array, $startPosition, $endPosition)
+    {
+        $foundElements = []; $searchStatus = false;
+
+        foreach( $array as $key => $val )
+        {
+            if( $key === $endPosition )
+            {
+                break;
+            }
+
+            if( $searchStatus === true )
+            {
+                $foundElements[$key] = $val;
+            }
+
+            if( $key === $startPosition )
+            {
+                $searchStatus = true;
+            }                     
+        }
+
+        return $foundElements;
+    }
+
+    /**
+     * Protected between both foreach function.
+     */
+    protected static function betweenBothForeachFunction($array, $startPosition, $endPosition)
+    {
+        $foundElements = []; $searchStatus = false;
+
+        foreach( $array as $key => $val )
+        {    
+            if( $key === $startPosition )
+            {
+                $searchStatus = true;
+            }       
+            
+            if( $searchStatus === true )
+            {
+                $foundElements[$key] = $val;
+            }
+            
+            if( $key === $endPosition )
+            {
+                break;
+            }
+        }
+
+        return $foundElements;
+    }
+
+    /**
+     * Protected between function.
+     */
+    protected static function betweenFunction($array, $start, $end, &$startPosition, &$endPosition)
+    {  
+        $startPosition = array_search($start, $array);
+        $endPosition   = array_search($end  , $array);
+
+        return $startPosition !== false && $endPosition !== false;
+    }
+}

Internal/package-datatypes/Arrays/Sort.php

@@ -0,0 +1,159 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+use ZN\Helper;
+
+class Sort
+{
+    /**
+     * Array Order
+     * 
+     * @param array  $array
+     * @param string $type  = NULL      - options[desc|asc|asckey|desckey|insens|natural|reverse|userassoc|userkey|user|random]
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function order(array $array, $type = NULL, $flags = 'regular') : array
+    {
+        $flags = Helper::toConstant($flags, 'SORT_');
+
+        switch($type)
+        {
+            case 'desc'         : arsort($array, $flags);   break;
+            case 'asc'          : asort($array, $flags);    break;
+            case 'asckey'       : ksort($array, $flags);    break;
+            case 'desckey'      : krsort($array, $flags);   break;
+            case 'insens'       : natcasesort($array);      break;
+            case 'natural'      : natsort($array);          break;
+            case 'reverse'      : rsort($array, $flags);    break;
+            case 'random'       : shuffle($array);          break;
+            default             : sort($array, $flags);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Normal Order
+     * 
+     * @param array  $array
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function normal(array $array, string $flag = 'regular') : array
+    {
+        return self::order($array, 'sort', $flag);
+    }
+
+    /**
+     * Descending Order
+     * 
+     * @param array  $array
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function descending(array $array, string $flag = 'regular') : array
+    {
+        return self::order($array, 'desc', $flag);
+    }
+
+    /**
+     * Ascending Order
+     * 
+     * @param array  $array
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function ascending(array $array, string $flag = 'regular') : array
+    {
+        return self::order($array, 'asc', $flag);
+    }
+
+    /**
+     * Ascending Key Order
+     * 
+     * @param array  $array
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function ascendingKey(array $array, string $flag = 'regular') : array
+    {
+        return self::order($array, 'asckey', $flag);
+    }
+
+    /**
+     * Descending Key Order
+     * 
+     * @param array  $array
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function descendingKey(array $array, string $flag = 'regular') : array
+    {
+        return self::order($array, 'desckey', $flag);
+    }
+
+    /**
+     * Reverse
+     * 
+     * @param array  $array
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function reverse(array $array, string $flag = 'regular') : array
+    {
+        return self::order($array, 'reverse', $flag);
+    }
+
+    /**
+     * Insensitive Order
+     * 
+     * @param array  $array
+     * @param string $flags = 'regular' - options[regular|numeric|string|localeString]
+     * 
+     * @return array
+     */
+    public static function insensitive(array $array) : array
+    {
+        return self::order($array, 'insens');
+    }
+
+    /**
+     * Natural Order
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function natural(array $array) : array
+    {
+        return self::order($array, 'natural');
+    }
+
+    /**
+     * Shuffle Order
+     * 
+     * @param array  $array
+     * 
+     * @return array
+     */
+    public static function shuffle(array $array) : array
+    {
+        return self::order($array, 'random');
+    }
+}

Internal/package-datatypes/Arrays/Unidimensional.php

@@ -0,0 +1,36 @@
+<?php namespace ZN\DataTypes\Arrays;
+/**
+ * ZN PHP Web Framework
+ * 
+ * "Simplicity is the ultimate sophistication." ~ Da Vinci
+ * 
+ * @package ZN
+ * @license MIT [http://opensource.org/licenses/MIT]
+ * @author  Ozan UYKUN [ozan@znframework.com]
+ */
+
+use RecursiveIteratorIterator, RecursiveArrayIterator;
+
+class Unidimensional
+{
+    /**
+     * Unidimensional
+     * 
+     * @param array $array
+     * @param bool  $preserveKey = false
+     * 
+     * @return array
+     */
+    public static function do(array $array, bool $preserveKey = true) : array
+    {
+        return iterator_to_array
+        (
+            new RecursiveIteratorIterator
+            (
+                new RecursiveArrayIterator($array)
+            ), 
+   
+            $preserveKey
+        );
+    }
+}