Abstract.php

<?php
abstract class Dsao_DataHandler_Abstract
{
  protected $_data = array();

  protected $_propertiesMandatory = array();

  protected $_propertiesProtected = array();

  protected $_readOnly = false;

  protected $_valid = null;

  public function __call($method, $parameters)
  {
    // 'getId' -> 'get_id'
    $methodUnderscored = Dsao_Model_Abstract::underscore($method);
    $parts = explode('_', $methodUnderscored, 2);

    // 'get_id' -> 'get'
    $operation  = (isset($parts[0]) ? $parts[0] : null);
    // 'get_id' -> 'id'
    $property   = (isset($parts[1]) ? $parts[1] : null);

    switch ($operation)
    {
      case 'get':
      case 'unset':
      case 'isset':
      {
        $methodName = '__'.$operation;

        return $this->$methodName($property);
      }
      break;

      case 'set':
      {
        // Falls kein Parameter übergeben wurde, null annehmen (->unset)
        if (!isset($parameters[0]))
        {
          $parameters[0] = null;
        }

        $this->__set($property, $parameters[0]);

        // Fließendes Interface bei set*()-Methoden
        return $this;
      }
      break;

      default:
      {
        throw new Dsao_Exception(array(
          'message' =>'dsao_datahandler_abstract_method_not_found',
          'variables' => array('method' => $method)));
      }
    }
  }

  public function __construct(array $data = array(), $readOnly = false)
  {
    // Damit man einfach isset() benutzen kann
    $this->_propertiesProtected = array_flip($this->_propertiesProtected);

    $this->setData($data);

    $this->setReadOnly($readOnly);
  }

  public function __get($property)
  {
    $property = (string) $property;

    return isset($this->_data[$property]) ?
      $this->_data[$property] : null;
  }

  public function __isset($property)
  {
    return isset($this->_data[(string) $property]);
  }

  public function __set($property, $value)
  {
    if (!$property)
    {
      return;
    }

    // Ggf. Exception werfen
    $this->_resetValidity(true);

    // Falls null übergeben wurde, löschen
    if (null === $value)
    {
      $this->__unset($property);
    }
    else
    {
      $this->_data[(string) $property] = $value;
    }
  }

  public function __sleep()
  {
    // Wichtige Einstellungen sichern
    return array('_readOnly', '_data', '_valid');
  }

  public function __unset($property)
  {
    $this->_resetValidity();

    $property = (string) $property;

    // Falls Element vorhanden
    if ($this->__isset($property))
    {
      unset($this->_data[$property]);
    }
  }

  public function __wakeup()
  {
    $this->_propertiesProtected = array_flip($this->_propertiesProtected);
  }

  protected function _checkValidity()
  {
    // Pflichtdaten durchgehen
    foreach ($this->_propertiesMandatory as $property)
    {
      // Falls Datum nicht vorhanden
      if (!$this->__isset($property))
      {
        $this->_valid = false;

        return false;
      }
    }

    $this->_valid = true;

    return true;
  }

  protected function _cleanData($data)
  {
    foreach ($data as $property => $value)
    {
      // Falls geschütze Eigenschaft übergeben wurde und diese bereits
      // vorhanden, löschen
      if (isset($this->_propertiesProtected[$property])
        && $this->__isset($property))
      {
        unset($data[$property]);
      }
    }

    return $data;
  }

  protected function _resetValidity()
  {
    $this->isReadOnly(true);

    $this->_valid = null;
  }

  public function clearData()
  {
    // Gültigkeit zurücksetzen
    $this->_resetValidity();

    // Daten löschen
    $this->_data = array();

    return $this;
  }

  public function getData($properties = null, $default = null)
  {
    // Falls alles zurueckgegeben werden soll
    if (!$properties)
    {
      return $this->_data;
    }

    // Falls nur eine Eigenschaft zurueckgegeben werden soll
    if (!is_array($properties))
    {
      // Falls Element nicht vorhanden
      if (!$this->__isset($properties))
      {
        return $default;
      }

      return $this->_data[$properties];
    }

    // Array mit Ergebnissen
    $results = array();

    // Array/Objekt durchgehen
    foreach ($properties as $property => $defaultValue)
    {
      // Falls Index numerisch
      if (is_numeric($property))
      {
        $property = $defaultValue;
        $defaultValue = $default;
      }

      // Falls Element nicht vorhanden
      if (!$this->__isset($property))
      {
        $results[$property] = $defaultValue;
        continue;
      }

      // Eigenschaft dem Ergebnisarray zuweisen
      $results[$property] = $this->_data[$property];
    }

    return $results;
  }

  public function hasData(array $properties = array(), $or = false, array $skip = array())
  {
    // Falls nichts übergeben wurde, nur prüfen, ob überhaupt Parameter
    // vorhanden sind
    if (empty($properties))
    {
      $propertiesCount = count($this->_data);

      // Zu überspringende Eigenschaften aus Zählung herausnehmen
      foreach ($skip as $property)
      {
        // Token soll nicht mitgezählt werden
        if ($this->__isset($property))
        {
          $parametersCount--;
        }
      }

      return (bool) $propertiesCount;
    }

    // Eigenschaften durchgehen
    foreach ($properties as $property)
    {
      // Falls Eigenschaft vorhanden
      if ($this->__isset($property))
      {
        // Falls nur einer der Eigenschaften vorhanden sein soll, hier
        // abbrechen
        if ($or)
        {
          return true;
        }
      }
      // Eigenschaft nicht vorhanden, also abbrechen, wenn alle Parameter
      // für das Erfüllen der Bedingung vorhanden sein müssen
      else if (!$or)
      {
        return false;
      }
    }

    // Alle Eigenschaften vorhanden
    return true;
  }

  public function isReadOnly($throw = false)
  {
    // Falls Objekt schreibgeschützt und Exception geworfen werden soll
    if ($this->_readOnly && $throw)
    {
      throw new Dsao_Exception('dsao_datahandler_abstract_readonly');
    }

    return (bool) $this->_readOnly;
  }

  public function isValid($throw = false)
  {
    // Falls Gültigkeit noch nicht geprüft wurde oder erneut geprüft werden
    // soll
    if (null === $this->_valid)
    {
      $this->_checkValidity();
    }

    // Falls Objekt ungültig und Exception geworfen werden soll
    if (!$this->_valid && $throw)
    {
      throw new Dsao_Exception('dsao_datahandler_abstract_invalid');
    }

    return $this->_valid;
  }

  public function setData(array $data = array(), $overwrite = true)
  {
    // Falls keine Daten übergeben wurden, abbrechen
    if (empty($data))
    {
      return $this;
    }

    // Gültigkeit zurück setzen
    $this->_resetValidity();

    // Daten säubern
    $data = $this->_cleanData($data);

    // Zu setzende Eigenschaften durchlaufen
    foreach ($data as $property => $value)
    {
      // Falls Eigenschaft vorhanden und Überschreiben deaktiviert
      if (!$overwrite && $this->__isset($property))
      {
        continue;
      }

      // Falls null übergeben wurde, überspringen
      if (null === $value)
      {
        continue;
      }
      // Ansonsten normal setzen (kein __set(), um Zeit zu sparen)
      else
      {
        $this->_data[$property] = $value;
      }
    }

    return $this;
  }

  public function setFromArray(array $data = array())
  {
    // Daten löschen
    $this->clearData();

    // Und neu setzen
    $this->_data = $this->_cleanData($data);

    return $this;
  }

  public function setReadOnly($readOnly = true)
  {
    $this->_readOnly = (bool) $readOnly;

    return $this;
  }

  public function setValid($valid = true)
  {
    // Gültigkeitsprüfung durchführen
    $validityChecked = $this->_checkValidity();

    if (!$validityChecked && $valid)
    {
      throw new Dsao_Exception('dsao_datahandler_abstract_set_valid');
    }

    $this->_valid = (bool) $valid;

    return $this;
  }

  public function toArray()
  {
    return $this->_data;
  }
}