Filter.inc.php

<?php
import('lib.pkp.classes.core.DataObject');
import('lib.pkp.classes.filter.TypeDescriptionFactory');
 
class Filter extends DataObject {
   var $_inputType;
 
   var $_outputType;
 
   var $_input;
 
   var $_output;
 
   var $_errors = array();
 
   var $_runtimeEnvironment = false;
 
   function __construct($inputType, $outputType) {
      // Initialize the filter.
      parent::__construct();
      $this->setTransformationType($inputType, $outputType);
   }
 
   //
   // Setters and Getters
   //
   function setDisplayName($displayName) {
      $this->setData('displayName', $displayName);
   }
 
   function getDisplayName() {
      if (!$this->hasData('displayName')) {
         $this->setData('displayName', get_class($this));
      }
 
      return $this->getData('displayName');
   }
 
   function setSequence($seq) {
      $this->setData('seq', $seq);
   }
 
   function getSequence() {
      return $this->getData('seq');
   }
 
   function setTransformationType(&$inputType, &$outputType) {
      $typeDescriptionFactory = TypeDescriptionFactory::getInstance();
 
      // Instantiate the type descriptions if we got string input.
      if (!is_a($inputType, 'TypeDescription')) {
         assert(is_string($inputType));
         $inputType = $typeDescriptionFactory->instantiateTypeDescription($inputType);
      }
      if (!is_a($outputType, 'TypeDescription')) {
         assert(is_string($outputType));
         $outputType = $typeDescriptionFactory->instantiateTypeDescription($outputType);
      }
 
      $this->_inputType = $inputType;
      $this->_outputType = $outputType;
   }
 
 
   function &getInputType() {
      return $this->_inputType;
   }
 
   function &getOutputType() {
      return $this->_outputType;
   }
 
   function &getLastOutput() {
      return $this->_output;
   }
 
   function &getLastInput() {
      return $this->_input;
   }
 
   function addError($message) {
      $this->_errors[] = $message;
   }
 
   function getErrors() {
      return $this->_errors;
   }
 
   function hasErrors() {
      return (!empty($this->_errors));
   }
 
   function clearErrors() {
      $this->_errors = array();
   }
 
   function setRuntimeEnvironment(&$runtimeEnvironment) {
      assert(is_a($runtimeEnvironment, 'RuntimeEnvironment'));
      $this->_runtimeEnvironment =& $runtimeEnvironment;
 
      // Inject the runtime settings into the data object
      // for persistence.
      $runtimeSettings = $this->supportedRuntimeEnvironmentSettings();
      foreach($runtimeSettings as $runtimeSetting => $defaultValue) {
         $methodName = 'get'.PKPString::ucfirst($runtimeSetting);
         $this->setData($runtimeSetting, $runtimeEnvironment->$methodName());
      }
   }
 
   function &getRuntimeEnvironment() {
      return $this->_runtimeEnvironment;
   }
 
 
   //
   // Abstract template methods to be implemented by subclasses
   //
   function &process(&$input) {
      assert(false);
   }
 
   //
   // Public methods
   //
   function supports(&$input, &$output) {
      // Validate input
      $inputType =& $this->getInputType();
      $validInput = $inputType->isCompatible($input);
 
      // If output is null then we're done
      if (is_null($output)) return $validInput;
 
      // Validate output
      $outputType =& $this->getOutputType();
      $validOutput = $outputType->isCompatible($output);
 
      return $validInput && $validOutput;
   }
 
   function supportsAsInput(&$input) {
      $nullVar = null;
      return($this->supports($input, $nullVar));
   }
 
   function isCompatibleWithRuntimeEnvironment() {
      if ($this->_runtimeEnvironment === false) {
         // The runtime environment has never been
         // queried before.
         $runtimeSettings = $this->supportedRuntimeEnvironmentSettings();
 
         // Find out whether we have any runtime restrictions set.
         $hasRuntimeSettings = false;
         foreach($runtimeSettings as $runtimeSetting => $defaultValue) {
            if ($this->hasData($runtimeSetting)) {
               $$runtimeSetting = $this->getData($runtimeSetting);
               $hasRuntimeSettings = true;
            } else {
               $$runtimeSetting = $defaultValue;
            }
         }
 
         // If we found any runtime restrictions then construct a
         // runtime environment from the settings.
         if ($hasRuntimeSettings) {
            import('lib.pkp.classes.core.RuntimeEnvironment');
            $this->_runtimeEnvironment = new RuntimeEnvironment($phpVersionMin, $phpVersionMax, $phpExtensions, $externalPrograms);
         } else {
            // Set null so that we don't try to construct
            // a runtime environment object again.
            $this->_runtimeEnvironment = null;
         }
      }
 
      if (is_null($this->_runtimeEnvironment) || $this->_runtimeEnvironment->isCompatible()) return true;
 
      return false;
   }
 
   function &execute(&$input, $returnErrors = false) {
      // Make sure that we don't destroy referenced
      // data somewhere out there.
      unset($this->_input, $this->_output);
 
      // Check the runtime environment
      if (!$this->isCompatibleWithRuntimeEnvironment()) {
         // Missing installation requirements.
         fatalError('Trying to run a transformation that is not supported in your installation environment.');
      }
 
      // Validate the filter input
      if (!$this->supportsAsInput($input)) {
         // We have no valid input so return
         // an empty output (see unset statement
         // above).
         return $this->_output;
      }
 
      // Save a reference to the last valid input
      $this->_input =& $input;
 
      // Process the filter
      $preliminaryOutput =& $this->process($input);
 
      HookRegistry::call(strtolower_codesafe(get_class($this) . '::execute'), array(&$preliminaryOutput));
 
      // Validate the filter output
      if ((!is_null($preliminaryOutput) && $this->supports($input, $preliminaryOutput)) || $returnErrors) {
         $this->_output =& $preliminaryOutput;
      }
 
      // Return processed data
      return $this->_output;
   }
 
   //
   // Public helper methods
   //
   static function supportedRuntimeEnvironmentSettings() {
      static $runtimeEnvironmentSettings = array(
         'phpVersionMin' => PHP_REQUIRED_VERSION,
         'phpVersionMax' => null,
         'phpExtensions' => array(),
         'externalPrograms' => array()
      );
 
      return $runtimeEnvironmentSettings;
   }
}