/** * Constructor * @param $name string the unique name of the property within a meta-data schema (can be a property URI) * @param $assocTypes array an array of integers that define the application entities that can * be described with this property. * @param $allowedTypes mixed must be a scalar or an array with the supported types, default: METADATA_PROPERTY_TYPE_STRING * @param $translated boolean whether the property may have various language versions, default: false * @param $cardinality integer must be on of the supported cardinalities, default: METADATA_PROPERTY_CARDINALITY_ONE * @param $displayName string * @param $validationMessage string A string that can be displayed in case a user tries to set an invalid value for this property. * @param $mandatory boolean Is this a mandatory property within the schema? */ function MetadataProperty($name, $assocTypes = array(), $allowedTypes = METADATA_PROPERTY_TYPE_STRING, $translated = false, $cardinality = METADATA_PROPERTY_CARDINALITY_ONE, $displayName = null, $validationMessage = null, $mandatory = false) { // Validate name and assoc type array assert(is_string($name)); assert(is_array($assocTypes)); // A single type will be transformed to an // array of types so that we can handle them // uniformly. if (is_scalar($allowedTypes) || count($allowedTypes) == 1) { $allowedTypes = array($allowedTypes); } // Validate types $canonicalizedTypes = array(); foreach ($allowedTypes as $allowedType) { if (is_array($allowedType)) { // We expect an array with a single entry // of the form "type => additional parameter". assert(count($allowedType) == 1); // Reset the array, just in case... reset($allowedType); // Extract the type and the additional parameter $allowedTypeId = key($allowedType); $allowedTypeParam = current($allowedType); } else { // No additional parameter has been set. $allowedTypeId = $allowedType; $allowedTypeParam = null; } // Validate type assert(in_array($allowedTypeId, MetadataProperty::getSupportedTypes())); // Transform the type array in a // structure that is easy to handle // in for loops. $canonicalizedTypes[$allowedTypeId][] = $allowedTypeParam; // Validate additional type parameter. switch ($allowedTypeId) { case METADATA_PROPERTY_TYPE_COMPOSITE: // Validate the assoc id of the composite. assert(is_integer($allowedTypeParam)); // Properties that allow composite types cannot be translated. assert(!$translated); break; case METADATA_PROPERTY_TYPE_VOCABULARY: // Validate the symbolic name of the vocabulary. assert(is_string($allowedTypeParam)); break; default: // No other types support an additional parameter assert(is_null($allowedTypeParam)); } } // Validate translation and cardinality assert(is_bool($translated)); assert(in_array($cardinality, MetadataProperty::getSupportedCardinalities())); // Default display name if (is_null($displayName)) { $displayName = 'metadata.property.displayName.' . $name; } assert(is_string($displayName)); // Default validation message if (is_null($validationMessage)) { $validationMessage = 'metadata.property.validationMessage.' . $name; } assert(is_string($validationMessage)); // Initialize the class $this->_name = (string) $name; $this->_assocTypes =& $assocTypes; $this->_allowedTypes =& $canonicalizedTypes; $this->_translated = (bool) $translated; $this->_cardinality = (int) $cardinality; $this->_displayName = (string) $displayName; $this->_validationMessage = (string) $validationMessage; $this->_mandatory = (bool) $mandatory; }
/** * Constructor * @param $name string the unique name of the property within a meta-data schema (can be a property URI) * @param $assocTypes array an array of integers that define the application entities that can * be described with this property. * @param $types mixed must be a scalar or an array with the supported types, default: METADATA_PROPERTY_TYPE_STRING * @param $translated boolean whether the property may have various language versions, default: false * @param $cardinality integer must be on of the supported cardinalities, default: METADATA_PROPERTY_CARDINALITY_ONE * @param $compositeType integer an association type, mandatory if $type is METADATA_PROPERTY_TYPE_COMPOSITE */ function MetadataProperty($name, $assocTypes = array(), $types = METADATA_PROPERTY_TYPE_STRING, $translated = false, $cardinality = METADATA_PROPERTY_CARDINALITY_ONE, $displayName = null) { // Validate name and assoc type array assert(is_string($name)); assert(is_array($assocTypes)); // A single type (scalar or composite) will be // transformed to an array of types so that we // can treat them uniformly. if (is_scalar($types) || count($types) == 1) { $types = array($types); } // Validate types foreach ($types as $type) { if (is_array($type)) { // Validate composite types assert(count($type) == 1 && isset($type[METADATA_PROPERTY_TYPE_COMPOSITE]) && is_integer($type[METADATA_PROPERTY_TYPE_COMPOSITE])); // Properties that allow composite types cannot be translated assert(!$translated); } else { // Validate all other types assert($type != METADATA_PROPERTY_TYPE_COMPOSITE && in_array($type, MetadataProperty::getSupportedTypes())); } } // Validate translation and cardinality assert(is_bool($translated)); assert(in_array($cardinality, MetadataProperty::getSupportedCardinalities())); // Default display name if (is_null($displayName)) { $displayName = 'metadata.property.displayName.' . $name; } assert(is_string($displayName)); // Initialize the class $this->_name = (string) $name; $this->_assocTypes =& $assocTypes; $this->_types =& $types; $this->_translated = (bool) $translated; $this->_cardinality = (int) $cardinality; $this->_displayName = (string) $displayName; }