Resolves dot-notation at an array (data-store in our case)

@param string $dots notation returning the value at the last pointer of the dot-notation.
@param array $array to be accessed.
170182
private static function resolveByDotNotation($dots, $scalar = false)
    {
        # Explode the $def string to array by "."
        $exploded = explode('.', $dots);
        # Initial pointer to array is the private array variable
        $arrPointer = static::$store;

        # Each subsequent dot-value
        foreach ($exploded as $explode) {
            # The value if set, so goto new array pointer
            if ( isset($arrPointer[$explode]) ) {
                $arrPointer = $arrPointer[$explode];
                # Not found the value by dot-notation at given loop run so return null
            } else {
                return null;
            }

            # Finished iterating the array and the value array pointer is pointing to is not another array (except you want a non scalar value)...
            if ( end($exploded) == $explode && ($scalar === false || !is_array($arrPointer)) ) {
                return $arrPointer;
            }
        }
    }
951341
private function _bindPdoParam($array = [])
    {
        // bind array data in pdo
        foreach ($array as $f => $v) {
            // check pass data type for appropriate field
            switch (gettype($array[$f])) {
                // is string found then pdo param as string
                case 'string':
                    $this->STH->bindParam($f + 1, $array[$f], PDO::PARAM_STR);
                    break;
                // if int found then pdo param set as int
                case 'integer':
                    $this->STH->bindParam($f + 1, $array[$f], PDO::PARAM_INT);
                    break;
                // if boolean found then set pdo param as boolean
                case 'boolean':
                    $this->STH->bindParam($f + 1, $array[$f], PDO::PARAM_BOOL);
                    break;
            }
        } // end for each here
    }
959471
public static function dot(array $array, string $prepend = ''): array
    {
        $cache = serialize(['array' => $array, 'prepend' => $prepend]);

        if (array_key_exists($cache, self::$dotted)) {
            return self::$dotted[$cache];
        }

        $results = [];

        foreach ($array as $key => $value) {
            if (is_array($value)) {
                $results = array_merge($results, static::dot($value, $prepend . $key . '.'));
            } else {
                $results[$prepend . $key] = $value;
            }
        }

        return self::$dotted[$cache] = $results;
    }
291530
public static function IsNumericIndicated( array $array ) : bool
   {

      $itemCount = \count( $array );

      if ( $itemCount < 1 ) { return true; }

      // Create the representative value (the joined array keys must be equal to it)
      $nums = \implode( '', \range( 0, $itemCount - 1 ) );

      // check the required array keys with the given.
      return ( $nums === \implode( '', \array_keys( $array ) ) );

   }
920522
private static function limit($array) {
        $origin = $array;
        if(count($array) > 1) {
            self::calls(array_shift($array));
        }
        return ' LIMIT ' . $origin[0] . (intval($origin[1]) > 0 ? ', ' . $origin[1] : '');
    }
1365094
public function overWritePostDataSet ($array) {
		if (!Arrays::IsTraversable($array)) {
			return false;
		}
		foreach ($array as $name => $data) {
			Request::OverWritePostData($name, $data);
			$this->request->data->$name = $data;
		}
		return true;
	}
756563
protected function assocToString($array, $keyValueSeparator = ' - ', $pairSeparator = '; ')
    {
        if (! is_array($array)) {
            return print_r($array, true);
        }

        foreach ($array as $key => &$value) {
            $value = $key . $keyValueSeparator . $value;
        }
        return implode($pairSeparator, $array);
    }
774056
public static function resolve_path_with_dots($path) {

		if(!is_null($path) && is_string($path) && strlen($path)) {
			while(preg_match('/\/\//', $path)) {
				$path = preg_replace('/\/\//', '/', $path);
			}
			$retval = $path;
			if(preg_match('/\./', $path)) {

				$isAbsolute = FALSE;
				if(preg_match('/^\//', $path)) {
					$isAbsolute = TRUE;
					$path = preg_replace('/^\//', '', $path);
				}
				$pieces = explode('/', $path);

				$finalPieces = array();
				for($i=0; $i < count($pieces); $i++) {
					$dirName = $pieces[$i];
					if($dirName == '.') {
						//do nothing; don't bother appending.
					}
					elseif($dirName == '..') {
						array_pop($finalPieces);
					}
					else {
						$finalPieces[] = $dirName;
					}
				}

				//$retval = cs_global::string_from_array($finalPieces, NULL, '/');
				$retval = implode('/', $finalPieces);
				if($isAbsolute) {
					$retval = '/'. $retval;
				}
			}
		}
		else {
			throw new \InvalidArgumentException(__METHOD__ .": invalid path (". $path .")");
		}

		if(is_null($retval)) {
			throw new \LogicException(__METHOD__ .": returning NULL for path (". $path .")");
		}
		return($retval);
	}
727210
public function isSequentialArray($array)
    {
        $counter = 0;
        foreach ($array as $key => $value) {
            if ($counter !== $key) {
                return false;
            }
            $counter++;
        }

        return true;
    }
211769
static private function recursionGetValue($array,array $keys)
    {
        if (! is_array($array) && ! empty($keys)) {
            return null;
        }
        if (empty($keys)) {
            return $array;
        }
        if (! isset($array[$keys[0]])) {
            return null;
        }
        return self::recursionGetValue($array[$keys[0]],array_slice($keys,1));
    }
569575
protected function sequentialArrayToKey(array $array)
    {

        if ($this->isObjectAndId($array)) {
            return get_class($array[0]) . '-' . $array[1];
        }

        $parts = [];

        foreach ($array as $value) {
            $parts[] = $this->castArrayValue($this->key($value));
        }

        return implode('_', $parts);
    }
905414
private function isAssocStr($array)
    {
        if(!is_array($array)){
            return false;
        }
        for (reset($array); is_int(key($array));
             next($array)) {
            if (is_null(key($array)))
                return false;
        }
        return true;
    }
936601
public static function flatten($array, $glue = ':', $reset = true, $indexed = true)
    {
        static $return = array();
        static $curr_key = array();

        if ($reset) {
            $return = array();
            $curr_key = array();
        }

        foreach ($array as $key => $val) {
            $curr_key[] = $key;
            if (is_array($val) and ($indexed or array_values($val) !== $val)) {
                static::flatten_assoc($val, $glue, false);
            } else {
                $return[implode($glue, $curr_key)] = $val;
            }
            array_pop($curr_key);
        }
        return $return;
    }
777098
public function fromArray( $array ){
		foreach( $array as $key => $value ){
			if( is_array( $value ) ){
				$this->__set( $key, NULL );
				$this->data[$key]->fromArray( $value );
			}
			else{
				$this->__set( $key, $value );
			}
		}

	}
1054139
protected function normalize(array &$array)
    {
        foreach ($array as $key => $value) {
            if (array_key_exists($key, self::$apcFix)) {
                unset($array[$key]);
                $array[self::$apcFix[$key]] = $value;
            }
        }
    }
1327815
public static function forget(&$array, $keys)
	{
		$original = &$array;

		$keys = static::toArray($keys);

		if (count($keys) === 0)
			return;

		foreach ($keys as $key) {
			// if the exact key exists in the top-level, remove it
			if (static::exists($array, $key)) {
				unset($array[(string) $key]);
				continue;
			}

			$parts = static::toKey($key);

			// clean up before each pass
			$array = &$original;

			while (count($parts) > 1) {
				$part = $parts->shift();

				if (static::exists($array, $part) && static::accessible($array[$part]))
					$array = &$array[$part];
				else
					continue 2;
			}

			unset($array[$parts->shift()]);
		}
	}
651619
private function _convertDottedPropertiesToArray(&$array)
    {
        foreach ($array as $section => $sectionArray) {

            $merged = array();

            foreach ($sectionArray as $key => $value) {

                $property = $this->_dotToArray($key, $value);
                $merged = array_merge_recursive($merged, $property);
            }

            $array[$section] = $merged;
        }
    }