<?php

/**
 *
 * @author Peter Csubak (chuby)
 * @copyright Peter Csubak (chuby)
 */
class Where{
	
	private $logicalOp;
	private $fieldName;
	private $operator;
	private $value1;
	private $value2;
	private $whereElements;
	
	/**
	 * Lekérdezést végző magic metódus. 
	 * Azért van rá szükség, hogy az adattagok ne legyenek publikusak, így lehet felügyelni a helyességüket
	 * a beállításkor, illetve a lekérdezéskor is.
	 * 
	 * @return mixed A lekérdezett attribútum értéke.
	 * @throws PersistenceException A második érték lekérdezésekor, ha az operátor nem between, akkor 170-es 
	 * hibakódú kivételt vált ki.
	 */
	public function __get($name){
		if ($name == "value2"){
			if (strtolower($this->operator) == "between"){
				return $this->value2;
			}else{
				throw new PersistenceException("A where elem második értéke csak akkor kérdezhető le, ha az operátor between.", null, 170);
			}
		}elseif ($name == "whereElements"){
			if (is_array($this->whereElements) && (current($this->whereElements) instanceof Where)){
				return $this->whereElements;
			}
		}elseif (($name == "logicalOp") || ($name == "operator")){
			return strtolower($this->$name);
		}else{
			return $this->$name;
		}
	}
	
	/**
	 * Beállítást végző magic metódus.
	 * Azért van rá szükség, hogy az adattagok ne legyenek publikusak, így lehet felügyelni a helyességüket
	 * a beállításkor, illetve a lekérdezéskor is.
	 * 
	 * @throws PersistenceException A második érték beállításakor, ha az operátor nem between, 171-es hibakódú
	 * kivételt vált ki. Amennyiben pedig a whereElements attribútumot próbáljuk beállítani, akkor egy 172-es hibakódú
	 * kivételt vált ki, mert a whereElements attribútum, csak a logikai operátorokat reprezentáló metódusokkal
	 * állítható be. 
	 */
	public function __set($name, $value){
		if ($name == "value2"){
			if (strtolower($this->operator) == "between"){
				$this->value2 = $value;
			}else{
				throw new PersistenceException("A where elem második értéke csak akkor állítható be, ha az operátor between.", null, 171);
			}
		}elseif ($name == "whereElements"){
			throw new PersistenceException("A where elemek csak a logikai operátorokat reprezentáló metódusokkal állítható be.", null, 172);
		}else{
			$this->$name = $value;
		}
	}
	
	/**
	 * Szabványos konstruktor, amelyen keresztül az összes lényeges attribútum beállítható.
	 * Egyelőre a beállítás ellenőrzés nélkül történik, de ez nem jelent gondot, minthogy az ellenőrzések a 
	 * lekérdezésekkor is megtörténnek.
	 * 
	 * @param string $field A tábla mezőneve, amelyre az feltételt meg szeretnénk adni. Gyakorlatilag az első 
	 * operandust reprezentálsó tábla mező. 
	 * @param mixed $value1 A feltétel jobboldalán álló érték, azaz a hasonlító operátorok második operandusa.
	 * @param mixed $value2 Ha a hasonlító operátor between, akkor a between három operandusú operátor harmadik 
	 * operandusa 
	 * @param string $operator A hasonlító operátor, ami lehet ("=" - egyenlőség; "<" - kisebb; ">" - nagyobb;
	 * "<=" - kisebb egyenlő; ">=" nagyobb egyenlő; "<>" - nem egyenlő; "like" - SQL szerint értelmezett LIKE 
	 * operátor; "between" - SQL szerint értelmezett BETWEEN operátor) A null értékek esetében az egyenlőség
	 * megegyezik az IS operátorral, és csak ezen a módon írható le ez az operátor, minden más operátor az 
	 * IS NOT operandust fogja jelenteni.
	 */
	public function __construct($field, $operator, $value1, $value2 = null){
		$this->whereElements = array();
		$this->fieldName = $field;
		$this->operator = $operator;
		$this->value1 = $value1;
		$this->value2 = $value2;
		$this->logicalOp = null;
	}
	

	/**
	 * A logikai AND operátort leíró metódus. A megadott paraméterek alapján felépít egy Where típusú objektumot,
	 * amit a whereElements listába AND kapcsolatban fel is láncol, majd ezt az új elemet vissza is adja a metódus.
	 * Ezt a visszatérési értéket használva, és azokon további "logikai operátorokat" alkalmazva létrehozható egy
	 * zárójelezett alfeltétel.
	 * 
	 * @param string $field A tábla mezőneve, amelyre az feltételt meg szeretnénk adni. Gyakorlatilag az első 
	 * operandust reprezentálsó tábla mező. 
	 * @param mixed $value1 A feltétel jobboldalán álló érték, azaz a hasonlító operátorok második operandusa.
	 * @param mixed $value2 Ha a hasonlító operátor between, akkor a between három operandusú operátor harmadik 
	 * operandusa 
	 * @param string $operator A hasonlító operátor, ami lehet ("=" - egyenlőség; "<" - kisebb; ">" - nagyobb;
	 * "<=" - kisebb egyenlő; ">=" nagyobb egyenlő; "<>" - nem egyenlő; "like" - SQL szerint értelmezett LIKE 
	 * operátor; "between" - SQL szerint értelmezett BETWEEN operátor) A null értékek esetében az egyenlőség
	 * megegyezik az IS operátorral, és csak ezen a módon írható le ez az operátor, minden más operátor az 
	 * IS NOT operandust fogja jelenteni.
	 * @return Where Az újonnan létrehozott Where elem.
	 */
	public function _and($field, $operator, $value1, $value2 = null){
		$whr = new Where($field, $operator, $value1, $value2);
		$whr->logicalOp = "and";
		$this->whereElements[count($this->whereElements)] = $whr;
		return $whr; 
	}
	
	/**
	 * Az AND NOT logikai operátort reprezentáló metódus. A megadott paraméterek alapján felépít egy Where típusú objektumot,
	 * amit a whereElements listába AND NOT kapcsolatban fel is láncol, majd ezt az új elemet vissza is adja a metódus.
	 * Ezt a visszatérési értéket használva, és azokon további "logikai operátorokat" alkalmazva létrehozható egy
	 * zárójelezett alfeltétel.
	 * 
	 * @param string $field A tábla mezőneve, amelyre az feltételt meg szeretnénk adni. Gyakorlatilag az első 
	 * operandust reprezentálsó tábla mező. 
	 * @param mixed $value1 A feltétel jobboldalán álló érték, azaz a hasonlító operátorok második operandusa.
	 * @param mixed $value2 Ha a hasonlító operátor between, akkor a between három operandusú operátor harmadik 
	 * operandusa 
	 * @param string $operator A hasonlító operátor, ami lehet ("=" - egyenlőség; "<" - kisebb; ">" - nagyobb;
	 * "<=" - kisebb egyenlő; ">=" nagyobb egyenlő; "<>" - nem egyenlő; "like" - SQL szerint értelmezett LIKE 
	 * operátor; "between" - SQL szerint értelmezett BETWEEN operátor) A null értékek esetében az egyenlőség
	 * megegyezik az IS operátorral, és csak ezen a módon írható le ez az operátor, minden más operátor az 
	 * IS NOT operandust fogja jelenteni.
	 * @return Where Az újonnan létrehozott Where elem.
	 */
	public function _andnot($field, $operator, $value1, $value2 = null){
		$whr = new Where($field, $operator, $value1, $value2);
		$whr->logicalOp = "andnot";
		$this->whereElements[count($this->whereElements)] = $whr;
		return $whr; 
	}
	
	/**
	 * Az OR logikai operátort reprezentáló metódus. A megadott paraméterek alapján felépít egy Where típusú objektumot,
	 * amit a whereElements listába OR kapcsolatban fel is láncol, majd ezt az új elemet vissza is adja a metódus.
	 * Ezt a visszatérési értéket használva, és azokon további "logikai operátorokat" alkalmazva létrehozható egy
	 * zárójelezett alfeltétel.
	 * 
	 * @param string $field A tábla mezőneve, amelyre az feltételt meg szeretnénk adni. Gyakorlatilag az első 
	 * operandust reprezentálsó tábla mező. 
	 * @param mixed $value1 A feltétel jobboldalán álló érték, azaz a hasonlító operátorok második operandusa.
	 * @param mixed $value2 Ha a hasonlító operátor between, akkor a between három operandusú operátor harmadik 
	 * operandusa 
	 * @param string $operator A hasonlító operátor, ami lehet ("=" - egyenlőség; "<" - kisebb; ">" - nagyobb;
	 * "<=" - kisebb egyenlő; ">=" nagyobb egyenlő; "<>" - nem egyenlő; "like" - SQL szerint értelmezett LIKE 
	 * operátor; "between" - SQL szerint értelmezett BETWEEN operátor) A null értékek esetében az egyenlőség
	 * megegyezik az IS operátorral, és csak ezen a módon írható le ez az operátor, minden más operátor az 
	 * IS NOT operandust fogja jelenteni.
	 * @return Where Az újonnan létrehozott Where elem.
	 */
	public function _or($field, $operator, $value1, $value2 = null){
		$whr = new Where($field, $operator, $value1, $value2);
		$whr->logicalOp = "or";
		$this->whereElements[count($this->whereElements)] = $whr;
		return $whr; 
	}
	
	/**
	 * Az OR NOT logikai operátort reprezentáló metódus. A megadott paraméterek alapján felépít egy Where típusú objektumot,
	 * amit a whereElements listába OR NOT kapcsolatban fel is láncol, majd ezt az új elemet vissza is adja a metódus.
	 * Ezt a visszatérési értéket használva, és azokon további "logikai operátorokat" alkalmazva létrehozható egy
	 * zárójelezett alfeltétel.
	 * 
	 * @param string $field A tábla mezőneve, amelyre az feltételt meg szeretnénk adni. Gyakorlatilag az első 
	 * operandust reprezentálsó tábla mező. 
	 * @param mixed $value1 A feltétel jobboldalán álló érték, azaz a hasonlító operátorok második operandusa.
	 * @param mixed $value2 Ha a hasonlító operátor between, akkor a between három operandusú operátor harmadik 
	 * operandusa 
	 * @param string $operator A hasonlító operátor, ami lehet ("=" - egyenlőség; "<" - kisebb; ">" - nagyobb;
	 * "<=" - kisebb egyenlő; ">=" nagyobb egyenlő; "<>" - nem egyenlő; "like" - SQL szerint értelmezett LIKE 
	 * operátor; "between" - SQL szerint értelmezett BETWEEN operátor) A null értékek esetében az egyenlőség
	 * megegyezik az IS operátorral, és csak ezen a módon írható le ez az operátor, minden más operátor az 
	 * IS NOT operandust fogja jelenteni.
	 * @return Where Az újonnan létrehozott Where elem.
	 */
	public function _ornot($field, $operator, $value1, $value2 = null){
		$whr = new Where($field, $operator, $value1, $value2);
		$whr->logicalOp = "ornot";
		$this->whereElements[count($this->whereElements)] = $whr;
		return $whr; 
	}
	
}
?>