Witam,

Potrzebuję pomocy w zrozumieniu w jaki sposób kontrolować dane wejściowe w odpowiednich klasach.
Dopiero raczkuję z obiektowym więc porszę o wyrozumiałość...

Stworzyłem interfejs Validator z funkcją validate()
Interfejs jest zaimplementowany w klasie PropertyObject która wygląda tak:

[PHP] pobierz, plaintext 
<?php
abstract class PropertyObject implements Validator
{
 
  /** Aggregations: */
 
  /** Compositions: */
 
   /*** Attributes: ***/
 
  /**
   * 
   * @access protected
   */
  
  protected $propertyTable =array ();
  protected $changedProperties= array();
  protected $data;
  protected $errors = array();
 
 
  public function __construct($arData){
      $this->data=$arData;
  }
 
  function __get($propertyName){
      if(!array_key_exists($propertyName, $this->propertyTable))
            throw new Exception("Błędna własność \"$propertyName\"!");
 
      if(method_exists($this, 'get'.$propertyName)){
          return call_user_func(array($this, 'get'.$propertyName));
      } else {
          //print ('nie ma funkcji '.$propertyName.'<br>');
          return $this->data[$this->propertyTable[$propertyName]];
      }
  }
 
  function __set($propertyName, $value){
      if(!array_key_exists($propertyName, $this->propertyTable))
        throw new Exception("Błędna własność \"$errors[$propertyName]\"");
      if(method_exists($this, 'set'.$propertyName)){
          return call_user_func(
              array($this,'set'.$propertyName),
              $value
          );
      } else {
          //jeżeli wartość własności uległa zmianie i nie ma jej
          //jeszcze w tabeli chengedProperties, zostanie do niej dołączona
          if($this->propertyTable[$propertyName]!=$value &&
              !in_array($propertyName,$this->changedProperties)){
                $this->changedProperties[]=$propertyName;
              }
          $this->data[$this->propertyTable[$propertyName]] = $value;
      }
  }
 
 
  /**
   *
   *
   * @return
   * @access public
   */
  function validate( ) {
      
  } // end of member function validate
 
} // end of PropertyObject
?>
[PHP] pobierz, plaintext 

Dziedziczę klasę w konkretnym obiekcie np:

[PHP] pobierz, plaintext 
<?php
class WareHouse extends PropertyObject
{
 
  /** Aggregations: */
 
  /** Compositions: */
 
   /*** Attributes: ***/
 
  /**
   * 
   * @access private
   *   
  private $entity = array();
  private $id_warehouse;
   */
    private $category = array();
 
 
  public function __construct($id_warehouse){
      $this->propertyTable['WareHouseID']=$id_warehouse;
  }
 
....
 
  public function validate(){
      if(!$this->WareHouseID){
          $this->errors['WareHouseID']='Brak id dla magazynu';
      }
      if(sizeof($this->errors)){
          return false;
      } else {
          return true;
      }
  }
 
 
} // end of WareHouse
?>
[PHP] pobierz, plaintext 

Do tablicy errors[] zbieram informacje o ewentualnych błędach.
Przykład jest przerobiony z książki niestety nie mam tam informacji jak w tym przykładzie wyciągnąć dane z tej tablicy - w przypadku gdy nie jest ona pusta.

Dodam, że mam inne klasy które w zasadzie składają się na obiekt WareHouse i tam również implementuję funkcję validate()
Pytanie które mnie gnębi to jak tego użyć? Tak aby w przypadku wprowadzenia błędnych danych pojawiała się odpowiednia informacja.

Przykładowo:

[PHP] pobierz, plaintext 
<?php
abstract class PropertyObject implements Validator{
  //ciach
  public function hasErrors(){
    return (count($this->errors) > 0);
  }
 
  public function getErrors(){
    return $this->errors;
  }
}
 
$o = new ...;
if($o->hasErrors()){
  foreach($o->getErrors() as $key => $error){
    //wyświetlanie błędów
  }
}
 
//nie wiem czy o to chodzi dokładnie
class WareHouse extends PropertyObject{
  //ciach
  public function validate(){
    //walidacja obiektów category (zakładam że też rozszerzają PropertyObject)
    foreach($this->category as $category){
      $category->validate();
      if($category->hasErrors()){
        //dodanie informacji o błędzie
        $this->errors = array_merge($this->errors, $category->getErrors());
      }
      //ustawienie błędów tego obiektu
    }
  }
}
 
//lub ewentualnie
class WareHouse extends PropertyObject{
  //ciach
  public function validate(){
    //walidacja obiektów category (zakładam że też rozszerzają PropertyObject)
    foreach($this->category as $category){
      $category->validate();
    }
    //ustawienie błędów tego obiektu
  }
 
  public function hasErrors(){
    $has = parent::hasErrors();
    if($has) return true;
    foreach($this->category as $cat){
      if($cat->hasError()){
        $has = true;
        break;
      }
    }
    return $has;
  }
 
  public function getErrors(){
    $errors = $this->errors;
 
    foreach($this->category as $category){
      if($category->hasErrors()){
        //dodanie informacji o błędzie
        $errors = array_merge($errors, $category->getErrors());
      }
  }
}
//bardziej wydajny jest sposób pierwszy, czyli dodawanie ewentualnych błędów z obiektu składowego do obiektu
//nadrzędnego bezpośrednio po walidacji
?>
[PHP] pobierz, plaintext 

prawdę mówiąc to trochę skomplikowane to co napisałeś - przynajmniej dla mnie
rozwiązałem swój problem w ten sposób że w każdej klasie mam validate() która zbiera do tablicy errors informacje o błędach i zwraca true lub false w zależności czy tablica zawiera elementy a żeby je wypisać dodałem jedynie do PropertyObject getErrors();
I jak tak teraz sobie pomyślę o tym to aż mi wstyd że w ogóle pytałem...
Mimo wszystko dzięki za pomoc, a swoją drogą to temat walidacji danych przy tworzeniu obiektu bardzo mnie interesuje i jestem ciekaw jakie Wy macie uniwersalne i sprawdzone rozwiązania.