DataObject.inc.php

<?php
 
class DataObject {
   var $_data = array();
 
   var $_hasLoadableAdapters = false;
 
   var $_metadataExtractionAdapters = array();
 
   var $_extractionAdaptersLoaded = false;
 
   var $_metadataInjectionAdapters = array();
 
   var $_injectionAdaptersLoaded = false;
 
   public function __construct() { }
 
 
   //
   // Getters and Setters
   //
   public function getLocalizedData($key, $preferredLocale = null) {
      $localePrecedence = AppLocale::getLocalePrecedence();
      foreach ($localePrecedence as $locale) {
         $value =& $this->getData($key, $locale);
         if (!empty($value)) return $value;
         unset($value);
      }
 
      // Fallback: Get the first available piece of data.
      $data =& $this->getData($key, null);
      if (!empty($data)) {
         // WARNING: Collapsing the following into a single line causes PHP 5.0.5 to die.
         $locales = array_keys($data);
         $firstLocale = array_shift($locales);
         return $data[$firstLocale];
      }
 
      // No data available; return null.
      unset($data);
      $data = null;
      return $data;
   }
 
   public function &getData($key, $locale = null) {
      if (is_null($locale)) {
         if (array_key_exists($key, $this->_data)) {
            return $this->_data[$key];
         }
      } else {
         // see http://bugs.php.net/bug.php?id=29848
         if (array_key_exists($key, $this->_data) && is_array($this->_data[$key]) && array_key_exists($locale, $this->_data[$key])) {
            return $this->_data[$key][$locale];
         }
      }
      $nullVar = null;
      return $nullVar;
   }
 
   public function setData($key, $value, $locale = null) {
      if (is_null($locale)) {
         // This is either a non-localized value or we're
         // passing in all locales at once.
         if (is_null($value)) {
            if (array_key_exists($key, $this->_data)) unset($this->_data[$key]);
         } else {
            $this->_data[$key] = $value;
         }
      } else {
         // (Un-)set a single localized value.
         if (is_null($value)) {
            // see http://bugs.php.net/bug.php?id=29848
            if (array_key_exists($key, $this->_data)) {
               if (is_array($this->_data[$key]) && array_key_exists($locale, $this->_data[$key])) unset($this->_data[$key][$locale]);
               // Was this the last entry for the data variable?
               if (empty($this->_data[$key])) unset($this->_data[$key]);
            }
         } else {
            $this->_data[$key][$locale] = $value;
         }
      }
   }
 
   public function unsetData($key, $locale = null) {
      if (is_null($locale)) {
         unset($this->_data[$key]);
      } else {
         unset($this->_data[$key][$locale]);
      }
   }
 
   public function hasData($key, $locale = null) {
      if (is_null($locale)) {
         return array_key_exists($key, $this->_data);
      } else {
         // see http://bugs.php.net/bug.php?id=29848
         return array_key_exists($key, $this->_data) && is_array($this->_data[$key]) && array_key_exists($locale, $this->_data[$key]);
      }
   }
 
   public function &getAllData() {
      return $this->_data;
   }
 
   public function setAllData(&$data) {
      $this->_data =& $data;
   }
 
   public function getId() {
      return $this->getData('id');
   }
 
   public function setId($id) {
      $this->setData('id', $id);
   }
 
 
   //
   // Public helper methods
   //
   public function upcastTo($targetObject) {
      // Copy data from the source to the target.
      $targetObject->setAllData($this->getAllData());
 
      // Return the upcast object.
      return $targetObject;
   }
 
 
   //
   // MetadataProvider interface implementation
   //
   public function setHasLoadableAdapters($hasLoadableAdapters) {
      $this->_hasLoadableAdapters = $hasLoadableAdapters;
   }
 
   public function getHasLoadableAdapters() {
      return $this->_hasLoadableAdapters;
   }
 
   public function addSupportedMetadataAdapter($metadataAdapter) {
      $metadataSchemaName = $metadataAdapter->getMetadataSchemaName();
      assert(!empty($metadataSchemaName));
 
      // NB: Some adapters are injectors and extractors at the same time,
      // notably the meta-data description dummy adapter that converts
      // from/to a meta-data description. That's why we have to check
      // input and output type separately.
 
      // Is this a meta-data extractor?
      $inputType = $metadataAdapter->getInputType();
      if ($inputType->checkType($this)) {
         if (!isset($this->_metadataExtractionAdapters[$metadataSchemaName])) {
            $this->_metadataExtractionAdapters[$metadataSchemaName] = $metadataAdapter;
         }
      }
 
      // Is this a meta-data injector?
      $outputType = $metadataAdapter->getOutputType();
      if ($outputType->checkType($this)) {
         if (!isset($this->_metadataInjectionAdapters[$metadataSchemaName])) {
            $this->_metadataInjectionAdapters[$metadataSchemaName] = $metadataAdapter;
         }
      }
   }
 
   public function removeSupportedMetadataAdapter($metadataSchemaName) {
      $result = false;
      if (isset($this->_metadataExtractionAdapters[$metadataSchemaName])) {
         unset($this->_metadataExtractionAdapters[$metadataSchemaName]);
         $result = true;
      }
      if (isset($this->_metadataInjectionAdapters[$metadataSchemaName])) {
         unset($this->_metadataInjectionAdapters[$metadataSchemaName]);
         $result = true;
      }
      return $result;
   }
 
   public function getSupportedExtractionAdapters() {
      // Load meta-data adapters from the database.
      if ($this->getHasLoadableAdapters() && !$this->_extractionAdaptersLoaded) {
         $filterDao = DAORegistry::getDAO('FilterDAO'); /* @var $filterDao FilterDAO */
         $loadedAdapters = $filterDao->getObjectsByTypeDescription('class::%', 'metadata::%', $this);
         foreach($loadedAdapters as $loadedAdapter) {
            $this->addSupportedMetadataAdapter($loadedAdapter);
         }
         $this->_extractionAdaptersLoaded = true;
      }
 
      return $this->_metadataExtractionAdapters;
   }
 
   public function getSupportedInjectionAdapters() {
      // Load meta-data adapters from the database.
      if ($this->getHasLoadableAdapters() && !$this->_injectionAdaptersLoaded) {
         $filterDao = DAORegistry::getDAO('FilterDAO'); /* @var $filterDao FilterDAO */
         $loadedAdapters = $filterDao->getObjectsByTypeDescription('metadata::%', 'class::%', $this, false);
         foreach($loadedAdapters as $loadedAdapter) {
            $this->addSupportedMetadataAdapter($loadedAdapter);
         }
         $this->_injectionAdaptersLoaded = true;
      }
 
      return $this->_metadataInjectionAdapters;
   }
 
   public function getSupportedMetadataSchemas() {
      $supportedMetadataSchemas = array();
      $extractionAdapters = $this->getSupportedExtractionAdapters();
      foreach($extractionAdapters as $metadataAdapter) {
         $supportedMetadataSchemas[] = $metadataAdapter->getMetadataSchema();
      }
      return $supportedMetadataSchemas;
   }
 
   public function getMetadataFieldNames($translated = true) {
      // Create a list of all possible meta-data field names
      $metadataFieldNames = array();
      $extractionAdapters = $this->getSupportedExtractionAdapters();
      foreach($extractionAdapters as $metadataAdapter) {
         // Add the field names from the current adapter
         $metadataFieldNames = array_merge(
            $metadataFieldNames,
            $metadataAdapter->getDataObjectMetadataFieldNames($translated)
         );
      }
      return array_unique($metadataFieldNames);
   }
 
   public function getSetMetadataFieldNames($translated = true) {
      // Retrieve a list of all possible meta-data field names
      $metadataFieldNameCandidates = $this->getMetadataFieldNames($translated);
 
      // Only retain those fields that have data
      $metadataFieldNames = array();
      foreach($metadataFieldNameCandidates as $metadataFieldNameCandidate) {
         if($this->hasData($metadataFieldNameCandidate)) {
            $metadataFieldNames[] = $metadataFieldNameCandidate;
         }
      }
      return $metadataFieldNames;
   }
 
   public function getLocaleMetadataFieldNames() {
      return $this->getMetadataFieldNames(true);
   }
 
   public function getAdditionalMetadataFieldNames() {
      return $this->getMetadataFieldNames(false);
   }
 
   public function injectMetadata($metadataDescription) {
      $dataObject = null;
      $metadataSchemaName = $metadataDescription->getMetadataSchemaName();
      $injectionAdapters = $this->getSupportedInjectionAdapters();
      if(isset($injectionAdapters[$metadataSchemaName])) {
         // Get the meta-data adapter that supports the
         // given meta-data description's schema.
         $metadataAdapter = $injectionAdapters[$metadataSchemaName]; /* @var $metadataAdapter MetadataDataObjectAdapter */
 
         // Pass in a reference to the data object which
         // the filter will use to update the current instance
         // of the data object.
         $metadataAdapter->setTargetDataObject($this);
 
         // Use adapter filter to convert from a meta-data
         // description to a data object.
         $dataObject = $metadataAdapter->execute($metadataDescription);
      }
      return $dataObject;
   }
 
   public function extractMetadata($metadataSchema) {
      $metadataDescription = null;
      $metadataSchemaName = $metadataSchema->getClassName();
      $extractionAdapters = $this->getSupportedExtractionAdapters();
      if(isset($extractionAdapters[$metadataSchemaName])) {
         // Get the meta-data adapter that supports the
         // given meta-data description's schema.
         $metadataAdapter = $extractionAdapters[$metadataSchemaName];
 
         // Use adapter filter to convert from a data object
         // to a meta-data description.
         $metadataDescription = $metadataAdapter->execute($this);
      }
      return $metadataDescription;
   }
 
   public function getDAO() {
      assert(false);
   }
}