TypeDescription.inc.php

<?php
define('TYPE_DESCRIPTION_CARDINALITY_SCALAR', '-1');
define('TYPE_DESCRIPTION_CARDINALITY_UNKNOWN', '0');
 
class TypeDescription {
   var $_typeName;
 
   var $_cardinality;
 
   function __construct($typeName) {
      $this->_typeName = $typeName;
      if (!$this->_parseTypeNameInternally($typeName)) {
         // Invalid type
         fatalError('Trying to instantiate a "'.$this->getNamespace().'" type description with an invalid type name "'.$typeName.'".');
      }
   }
 
 
   //
   // Setters and Getters
   //
   function getNamespace() {
      // Must be implemented by subclasses.
      assert(false);
   }
 
   function getTypeName() {
      return $this->_typeName;
   }
 
   function getTypeDescription() {
      return $this->getNamespace().'::'.$this->getTypeName();
   }
 
 
   //
   // Public methods
   //
   function isCompatible($object) {
      // Null is never compatible
      if (is_null($object)) return false;
 
      // Check cardinality
      if ($this->_cardinality == TYPE_DESCRIPTION_CARDINALITY_SCALAR) {
         // Should be a scalar
         if (!is_scalar($object) && !is_object($object)) return false;
 
         // Delegate to subclass for type checking
         if (!$this->checkType($object)) return false;
      } else {
         // Should be an array
         if (!is_array($object)) return false;
 
         if ($this->_cardinality !=  TYPE_DESCRIPTION_CARDINALITY_UNKNOWN) {
            // We know an exact cardinality - so check it
            if (count($object) != $this->_cardinality) return false;
         }
 
         // We currently only support homogeneous one-dimensional arrays.
         foreach($object as $scalar) {
            // Should be a scalar
            if (!is_scalar($scalar) && !is_object($scalar)) return false;
 
            // Delegate to subclass for type checking
            if (!$this->checkType($scalar)) return false;
         }
      }
 
      // All checks passed so the object complies to the type spec.
      return true;
   }
 
 
   //
   // Abstract template methods
   //
   function parseTypeName($typeName) {
      // Must be implemented by subclasses
      assert(false);
   }
 
   function checkType(&$object) {
      // Must be implemented by subclasses
      assert(false);
   }
 
 
   //
   // Private helper methods
   //
   function _parseTypeNameInternally($typeName) {
      // Identify cardinality
      $typeNameParts = explode('[', $typeName);
      switch(count($typeNameParts)) {
         case 1:
            // This is not an array
            $this->_cardinality = TYPE_DESCRIPTION_CARDINALITY_SCALAR;
            break;
 
         case 2:
            // This is an array, identify its cardinality
            $typeName = $typeNameParts[0];
            $cardinality = trim($typeNameParts[1], ']');
            if($cardinality === '') {
               // A variable length array
               $this->_cardinality = TYPE_DESCRIPTION_CARDINALITY_UNKNOWN;
            } elseif (is_numeric($cardinality)) {
               // A fixed-length array
               $cardinality = (int)$cardinality;
               assert($cardinality > 0);
               $this->_cardinality = $cardinality;
            } else {
               // Invalid type description
               return false;
            }
            break;
 
         default:
            // Invalid type description
            return false;
      }
 
      // Delegate to the subclass to parse the actual type name.
      return $this->parseTypeName($typeName);
   }
}