<?php

/**
 * Contiene métodos para el trabajo con array
 *
 */
class ubArray
{
	/**
	 * Permite crear de un arreglo una cadena con un formato comun
	 * por defecto el separador de la varibles es la coma(,) y el signo 
	 * para relacionarlos es los dos putos(:)
	 *
	 * @param string $exp
	 * @param string $div
	 * @param string $rel
	 * @return array
	 */
	static public function create_exp($array,$div = ',', $rel = ':')
	{
		foreach ($array as $key => $value) {
			if (preg_match("/^([a-z])+$/i", $value))
				$data[] = "$key $rel $value";
			else	
				$data[] = "$key $rel \"$value\"";
		}
		return implode($div,$data);	
	}
	
	/**
	 * Permite obtenerun arreglo de una cadena con un formato comun
	 * por defecto el separador de la varibles es la coma(,) y el signo 
	 * para relacionarlos es los dos putos(:)
	 *
	 * @param string $exp
	 * @param string $div
	 * @param string $rel
	 * @return array
	 */
	static public function parser_exp($exp,$div = ',', $rel = ':')
	{
		$keys_values = explode($div,$exp);
		$result = array();
		foreach ($keys_values as $valor)
		{
			$valor = trim($valor);
			$array = explode( $rel ,$valor);
			$array[0] = trim($array[0]);
			$array[1] = trim($array[1]);
			$result[$array[0]] = $array[1];
		}
		return $result;	
	}

	/**
	 * Verifica que el parámetro sea un array de lo contrario crea uno con dicho 
	 * parámetro como valor correspondiente a esa llave
	 *
	 * @param array $array
	 * @param string $key
	 * @return array
	 */
	static public function validate(&$array,$key = 0,$force = false)
	{
		if(!is_array($array) || $force)
		{
			if($array != null || $array != "")
				$array = array($key => $array);
			else	
				$array = array();
		}
		
		return $array;
	}
	
	/**
	 * Verifica que el array entrado no posea valores que sean array
	 *
	 * @param array $arr
	 * @return bool
	 */
	static public function hav_array($arr)
	{
		foreach ($arr as $value) {
			if(is_array($value))
				return false;
		}
		
		return true;
	}
		
	/**
	 * Devuelve un arreglo de los elementos correspondientes a esa llave
	 * o método
	 *
	 * @param Matrix $array
	 * @param string $method o key
	 * @param bool $as_array	=> en caso de que se deseen los valores en un arreglo de esa posición
	 * @return array
	 */
	static public function filter_by_key($array,$key,$as_array = false)
	{
		self::validate($array);
		
		$result = array();
		foreach ($array as $key_ => $value_) 
		{
			$in_ = false;
			if(is_object($value_))
				$value_ = $value_->$key();
			else
				$value_ = $value_[$key];
				
			if($as_array !== false)
			{
				$key_out = ($as_array === true)?$key:$as_array;
				$result[] = array( $key_out => $value_);
			}
			else
				$result[] = $value_;
		}
		return $result;
	}
		
	/**
	 * Devuelve del solo los elementos donde en la llave o método key
	 * concuerde con el valor pasado
	 *
	 * @param Matrix $array
	 * @param string $method o key
	 * @param string o array $value
	 * @return array
	 */
	static public function filter_by_value($array,$key,$value,$in = true)
	{
		self::validate($array);
		self::validate($value);
		
		$result = array();
		foreach ($array as $key_ => $value_) 
		{
			$in_ = false;
			if(is_object($value_))
			{
				if(in_array($value_->$key(),$value))
					$in_ = true;
			}
			else
			{
				if(in_array($value_[$key],$value))
					$in_ = true;
			}
			
			if($in === $in_)
			{
				if (is_numeric($key_)) {
					$result[] = $value_;
				}
				else
					$result[$key_] = $value_;
			}
		}
		return $result;
	}
	
	/**
	 * Devuelve la dimensión de un arreglo
	 *
	 * @param array $array
	 * @return integer
	 */
	static public function dimention($array)
	{
		if(!is_array($array))
			return 0;
			
		$dim = 1;
		foreach ($array as $value) {
			if(is_array($value))		
				$dim_value = self::dimention($value)+1;
			else
				$dim_value = 0;
			
			$dim = ($dim_value > $dim)?$dim_value:$dim;			
		}	
		
		return $dim;
	}
	
	/**
	 * devuelve el valor de esa posición no importa si existen claves intermedias o no
	 *
	 * @param array $array
	 * @param integer $pos
	 * @return mixed
	 */
	static public function choose_position($array,$pos = 0){
		$cont = 0;
		foreach ($array as $value) {
			if($cont == $pos)
				return $value;
			
			$cont++;		
		}
	}
	
	/**
	 * Une los elementos de un arreglo poniendo la cadena "$among"
	 * entre los elementos, así como el inicio "$begin" y el fin
	 * "$end"
	 *
	 * @param array $arr
	 * @param string $among
	 * @param string $begin
	 * @param string $end
	 * @return string
	 */
	static public function implode($arr,$among = "",$begin = "",$end = "")
	{
		self::validate($arr);
		$return = implode($among,$arr);	
		if($return)
			return $begin.$return.$end;

		return "";	
	}
	
	/**
	 * Une los elementos de un arreglo poniendo la cadena "$among"
	 * entre los elementos, así como el inicio "$begin" y el fin
	 * "$end" y es sensible a string y números(le pone comillas a los string)
	 *
	 * @param array $arr
	 * @param string $among
	 * @param string $begin
	 * @param string $end
	 * @return string
	 */
	static public function implode_sensitive($arr,$among = "",$begin = "",$end = "",$ignore = array())
	{
		self::validate($arr);
		$return = "";	
		foreach ($arr as $value) 
		{
			if($return !== "")
				$return .= $among;
			
			if(in_array($value,$ignore) || is_numeric($value))
				$return .= $value;	
			else
				$return .= "'$value'";		
		}
		if($return)
			return $begin.$return.$end;

		return "";	
	}
	
	/**
	 * Convierte un arreglo normal de valores 
	 * a un arreglo qeu es sencible a las cadenas
	 *
	 * @param array $arr
	 * @param array $ignore
	 * @return array
	 */
	static public function to_sensitive($arr,$ignore = array())
	{
		self::validate($arr);
		$return = array();	
		foreach ($arr as $value) 
		{
			if(in_array($value,$ignore) || is_numeric($value))
				$return[] = $value;	
			else
				$return[] = "'$value'";		
		}

		return $return;	
	}
	
	/**
	 * Une los elementos de un arreglo poniendo la cadena "$among"
	 * entre los elementos, así como el inicio "$begin" y el fin
	 * "$end"
	 *
	 * @param array $arr
	 * @param string $among
	 * @param string $begin
	 * @param string $end
	 * @return string
	 */
	static public function implode_object($arr_obj,$method,$among = "",$begin = "",$end = "")
	{
		$arr = self::array_object($arr_obj,$method);
		$return = implode($among,$arr);	
		if($return)
			return $begin.$return.$end;

		return "";	
	}
	
	/**
	 * Devuelve una arreglo con los valores de ese metodo para cada objeto
	 *
	 * @param array object $arr_obj
	 * @param string $method
	 * @return array
	 */
	static public function array_object($arr_obj,$method,$as_array = false)
	{
		self::validate($arr_obj);
		$return = array();
		foreach ($arr_obj as $key => $value)
			if($as_array == true)
				$result[] = array( $key => $value[$key]);
			else
				$result[] = $value[$key];
		
			$return[$key] = $value->$method();
			
		return $return;	
	}
	
	/**
	 * Une dos array pero los elementos  no se repetiran
	 * a menos que sus llaves sean diferentes
	 *
	 * @param array $arr1
	 * @param array $arr2
	 * @return array
	 */
	static public function merge($arr1,$arr2)
	{
		self::validate($arr1);
		self::validate($arr2);
		$result = $arr1;
		
		foreach ($arr2 as $key => $value) {
			if(is_numeric($key))
			{
				if(!in_array($value,$arr1))
					$result[] = $value;
			}
			else
			{
				if(!$arr1[$key])
					$result[$key] = $value;
			}
		}
		return $result;
	}
	
	/**
	 * Devuelve un arreglo con la imformación sin repetirse
	 *
	 * @param array $arr
	 * @return array
	 */
	static public function remove_repeated($arr)
	{
		self::validate($arr);
		$return = array();
		
		foreach ($arr as $key => $value) {
			if(is_numeric($key))
			{
				if(!in_array($value,$return))
					$return[] = $value;
			}else 
				$return[$key] = $value;
		}
		
		return $return;
	}
	
	/**
	 * Elimina un elemento del arreglo
	 *
	 * @param array $arr
	 * @param mixed $elem
	 * @return array
	 */
	static public function exclude_elem($arr,$elem)
	{
		self::validate($arr);
		self::validate($elem);
		$return = array();
		
		foreach ($arr as $key => $value) {
			if(!in_array($value,$elem))
			{
				if(is_numeric($key))
					$return[] = $value;
				else
					$return[$key] = $value;
					
			}
				
		}
		
		return $return;
	}
	
	/**
	 * Elimina un elemento o varios elementos del arreglo por la key
	 *
	 * @param array $array
	 * @param mixed $key
	 * @param mixed $value
	 * @return array
	 */
	static public function remove_by_key($array,$key,$value)
	{
		self::validate($array);
		self::validate($value);
		$return = array();
		
		foreach ($array as $key_ => $value_) {
			if(!in_array($value_[$key],$value))
			{
				if(is_numeric($key_))
					$return[] = $value_;
				else
					$return[$key_] = $value_;
					
			}
				
		}
		
		return $return;
	}
	
	/**
	 * Adiciona un valor a cada posición dentro del arreglo
	 *
	 * @param array $arr
	 * @param mixed $elem
	 * @return array
	 */
	static public function add_elem($arr,$elem)
	{
		self::validate($arr);
		self::validate($elem);
		$return = $arr;
		
		foreach ($arr as $key => $value) 
		{
			foreach ($elem as $key_elem => $value_elem) 
			{
				if(is_numeric($key_elem))
					$return[$key][] = $value_elem;
				else
					$return[$key][$key_elem] = $value_elem;
			}
		}
		
		return $return;
	}
	
	/**
	 * Busca si en el arreglo de objetos existe un campo con ese valor
	 *
	 * @param array $arr
	 * @param mixed $value
	 * @param string $field
	 * @return bool
	 */
	static public function in_array_object($arr,$method,$value)
	{
		self::validate($arr);
		
		foreach ($arr as $key => $obj) {
			if($obj->$method() == $value)
				return $key;
		}
		
		return false;
	}
	
	/**
	 * Busca si en el arreglo bidimencional existe un campo con ese valor
	 *
	 * @param array $arr
	 * @param mixed $value
	 * @param string $key
	 * @return bool or int
	 */
	static public function in_array_key($arr,$key,$value)
	{
		self::validate($arr);

		foreach ($arr as $arr_key => $arr_value) {
			if($arr_value[$key] === $value)
			{
				return $arr_key;
			}
		}
		
		return false;
	}
	
	/**
	 * Devuelve las llaves que correspondan con el valor de ese campo en específico
	 * para un arreglo de objeto
	 *
	 * @param array $arr
	 * @param mixed $value
	 * @param string $field
	 * @return array
	 */
	static public function array_keys_object($arr,$method,$value)
	{
		self::validate($arr);
		self::validate($value);
		$return = array();
		
		foreach ($arr as $key => $obj)
		{
			if(in_array($obj->$method(),$value))
				$return[] = $key;
		}
		
		return $return;
	}
	
	/**
	 * Devuelve solo las llaves no numéricas del array entrante
	 *
	 * @param array $arr
	 * @param mixed[optional] $search
	 * @return array
	 */
	static public function array_keys_not_numeric($arr,$search = null)
	{
		self::validate($arr);
		if ($search !== null)
			$return = array_keys($arr,$search);
		else
			$return = array_keys($arr);
				
		foreach ($return as $key => $value) {
			if (is_numeric($value))
				unset($return[$key]);
		}
		return $return;
	}
}
?>