src/framework/uima/typesystemdescription.hpp - uima-uimacpp - Git at Google

 /** \file typesystemdescription.hpp .
 -----------------------------------------------------------------------------


  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.

 -----------------------------------------------------------------------------

     \brief Contains classes uima::TypeDescription uima::FeatureDescription and uima::TypeSystemDescription

    Description: Defines the type system used in a Text Analysis Engine

 -----------------------------------------------------------------------------

    01/30/2003  Initial creation

 -------------------------------------------------------------------------- */
 #ifndef UIMA_TYPESYSTEMDESCRIPTION_HPP
 #define UIMA_TYPESYSTEMDESCRIPTION_HPP

 // ---------------------------------------------------------------------------
 //  Includes
 // ---------------------------------------------------------------------------

 #include "uima/pragmas.hpp" //must be first to surpress warnings
 #include "uima/err_ids.h"
 #include "uima/taemetadata.hpp"
 #include "uima/importdescription.hpp"

 #include <vector>
 #include <map>

 namespace uima {

   /**
   * If a type can only contain an enumeration of values, there is an <code>AllowedValue</code> object
   * for each value. The value itself is returned by <code>getName</code>, <code>getDescription</code>
   * returns a description of the value.
   **/
   class UIMA_LINK_IMPORTSPEC AllowedValue :public MetaDataObject {
   public:
     AllowedValue()
         :MetaDataObject(), iv_name(), iv_description() {}

     AllowedValue(const AllowedValue & crOther) {
       iv_name = crOther.getName();
       iv_description = crOther.getDescription();
     }


     TyErrorId setName(const icu::UnicodeString & name) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_name = name;
       return UIMA_ERR_NONE;
     }

     TyErrorId setDescription(const icu::UnicodeString &  description) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_description = description;
       return UIMA_ERR_NONE;
     }

     const icu::UnicodeString & getName() const {
       return iv_name;
     }

     const icu::UnicodeString & getDescription() const {
       return iv_description;
     }

   private:
     icu::UnicodeString iv_name;
     icu::UnicodeString iv_description;
   };

   /**
   * Defines a feature by its name and the range type that its values can assume.
   * <code>getDescription</code> returns a textual description of the feature.
   **/
   class UIMA_LINK_IMPORTSPEC FeatureDescription:public MetaDataObject {

   public:

     FeatureDescription()
         :MetaDataObject(), iv_name(), iv_description(), iv_rangeType(),
               iv_elementType(), iv_multipleRefsAllowed(false) {}

     FeatureDescription(const FeatureDescription & crOther) {
       iv_name = crOther.getName();
       iv_description = crOther.getDescription();
       iv_rangeType = crOther.getRangeTypeName();
       iv_elementType = crOther.getElementType();
       iv_multipleRefsAllowed =  crOther.isMultipleReferencesAllowed();
     }

     TyErrorId setName(const icu::UnicodeString & featName) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_name = featName;
       return UIMA_ERR_NONE;
     }

     const icu::UnicodeString & getName() const {
       return iv_name;
     }

     TyErrorId setRangeTypeName(const icu::UnicodeString & rangeName) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_rangeType = rangeName;
       return UIMA_ERR_NONE;
     }

     const icu::UnicodeString & getRangeTypeName() const {
       return iv_rangeType;
     }

     TyErrorId setElementType(const icu::UnicodeString & elementName) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_elementType = elementName;
       return UIMA_ERR_NONE;
     }

     const icu::UnicodeString & getElementType() const {
       return iv_elementType;
     }

     TyErrorId setDescription(const icu::UnicodeString & desc) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_description = desc;
       return UIMA_ERR_NONE;
     }

 	const icu::UnicodeString & getDescription() const {
       return iv_description;
     }

 	TyErrorId setMultipleReferencesAllowed(bool allowed) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_multipleRefsAllowed = allowed;
       return UIMA_ERR_NONE;
     }

 	const bool isMultipleReferencesAllowed()  const {
 		return iv_multipleRefsAllowed;
 	}

   private:
     icu::UnicodeString iv_name;
     icu::UnicodeString iv_description;
     icu::UnicodeString iv_rangeType;
     icu::UnicodeString iv_elementType;
 	bool iv_multipleRefsAllowed;
   };

   /**
   * Defines a type by its name and the name of its super type.
   * If a type defines features or can only assume values from a
   * predefined set, the information is accessible via
   * <code>getFeatureDescriptions</code> and <code>getAllowedValues</code>, resp.
   * <code>getDescription</code> returns a textual description of the type.
   **/
   class UIMA_LINK_IMPORTSPEC TypeDescription :public MetaDataObject {

   public:
     typedef std::vector<FeatureDescription *> TyVecpFeatureDescriptions;
     typedef std::vector<AllowedValue *> TyVecpAllowedValues;

     TypeDescription()
         :MetaDataObject(), iv_typeName(), iv_superTypeName(), iv_description(),
         iv_vecpFeatureDescriptions(), iv_vecpAllowedValues() {};

     TypeDescription(const TypeDescription & crOther);

     ~TypeDescription() {
       size_t i;
       for (i=0; i < iv_vecpFeatureDescriptions.size(); i++) {
         delete iv_vecpFeatureDescriptions[i];
       }
       for (i=0; i < iv_vecpAllowedValues.size(); i++) {
         delete iv_vecpAllowedValues[i];
       }
     }

     void commit() {
       size_t i;
       for (i=0; i < iv_vecpFeatureDescriptions.size(); i++) {
         iv_vecpFeatureDescriptions[i]->commit();
       }
       for (i=0; i < iv_vecpAllowedValues.size(); i++) {
         iv_vecpAllowedValues[i]->commit();
       }
       iv_bIsModifiable = false;
     }

     TyErrorId setName(const icu::UnicodeString & name) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_typeName = name;
       return UIMA_ERR_NONE;
     }

     const icu::UnicodeString & getName() const {
       return iv_typeName;
     }

     TyErrorId setSuperTypeName(const icu::UnicodeString & name) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_superTypeName = name;
       return UIMA_ERR_NONE;
     }

     const icu::UnicodeString & getSuperTypeName() const {
       return iv_superTypeName;
     }

     TyErrorId setDescription(const icu::UnicodeString & desc) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_description = desc;
       return UIMA_ERR_NONE;
     }

     const icu::UnicodeString & getDescription() const {
       return iv_description;
     }

     /**
     * NOTE: This object will assume memory ownership of <code>feature</code>,
     * i.e. it will delete it when destroyed.
     **/
     TyErrorId addFeatureDescription(FeatureDescription * feature, bool & takesMemoryOwnership);

     /**
      * Adds an AllowedValue object to the list of AllowedValues
      * NOTE: This object will assume memory ownership of <code>AllowedValue</code>,
         * i.e. it will delete it when destroyed.
         */
     TyErrorId addAllowedValue(AllowedValue * allowed, bool & takesMemoryOwnership);

     /**
     * Adds all feature descriptions in descs to this TypeDescription.
     * If there are two features with the same name and rangetype, only
     * one will be in this TypeDescription.
     * However, if two features have the same name, but different rangetypes,
     * the TypeDescription will contain both.
     * The error will be identified when validating the TextAnalysisEngineSpecifier.
     * <code>FeatureDescription</code> objects contained in <code>descs</code> will
     * be copied, hence, the memory ownership of the objects in <code>descs</code>
     * will remain with the caller of this method.
     *
     **/
     void mergeFeatureDescriptions(const TyVecpFeatureDescriptions & descs);

     void mergeAllowedValues(const TyVecpAllowedValues & descs);

     const TyVecpFeatureDescriptions & getFeatureDescriptions() const {
       return iv_vecpFeatureDescriptions;
     }

     const TyVecpAllowedValues & getAllowedValues() const {
       return iv_vecpAllowedValues;
     }

     /**
     * returns a <code>FeatureDescription</code> with name <code>featureName</code>
     * or NULL, if no such feature can be found.
     **/
     FeatureDescription * getFeatureDescription(const icu::UnicodeString & featureName) const;

     AllowedValue * getAllowedValue(const icu::UnicodeString & name) const;

 	void validate();
   private:

     TypeDescription & operator=(const TypeDescription & crOther);

     icu::UnicodeString iv_typeName;
     icu::UnicodeString iv_superTypeName;
     icu::UnicodeString iv_description;
     TyVecpFeatureDescriptions iv_vecpFeatureDescriptions;
     TyVecpAllowedValues iv_vecpAllowedValues;
   };

   /**
   * Contains an ordered list of type names. The ordering implies priority,
   * that is, if entry b comes after entry a in the list, then a as a higher
   * priority than b.
   **/
   class UIMA_LINK_IMPORTSPEC TypePriority :public MetaDataObject {
   public:
     TypePriority() :iv_vecTypeOrder() {}

     TyErrorId addType(const icu::UnicodeString & type) {
       if (! isModifiable()) {
         return UIMA_ERR_CONFIG_OBJECT_COMITTED;
       }
       iv_vecTypeOrder.push_back(type);
       return UIMA_ERR_NONE;
     }

     const std::vector <icu::UnicodeString> & getTypeOrder() const {
       return iv_vecTypeOrder;
     }

   private:
     std::vector <icu::UnicodeString> iv_vecTypeOrder;
   };

   /**
   * Contains all <code>TypeDescription</code> and <code>TypePriority</code> objects
   * for a <code>TextAnalysisEngine</code>.
   **/
   class UIMA_LINK_IMPORTSPEC TypeSystemDescription :public MetaDataObject {
   public:
     typedef std::vector<TypeDescription *> TyVecpTypeDescriptions;
     typedef std::vector<ImportDescription *> TyVecpImportDescriptions;


     TypeSystemDescription()
         :MetaDataObject(), iv_vecpTypeDescriptions() {};

     ~TypeSystemDescription() {
       size_t i;
       for (i=0; i < iv_vecpTypeDescriptions.size(); i++) {
         delete iv_vecpTypeDescriptions[i];
       }
       for (i=0; i < iv_vecpImportDescriptions.size(); i++) {
         delete iv_vecpImportDescriptions[i];
       }
     }

     void commit() {
       iv_bIsModifiable = false;

       std::vector<icu::UnicodeString> alreadyImportedLocations;
       resolveImports(alreadyImportedLocations);
       size_t i;
       for (i=0; i < iv_vecpTypeDescriptions.size(); i++) {
         iv_vecpTypeDescriptions[i]->commit();
       }
     }

     /**
     * Adds all type descriptions in descs to this type system description.
     * If there are two type descriptions with the same name and same supertype,
     * their features are merged into one TypeDescription.
     * If two descriptions have the same name, but different supertype names
     * (which is not allowed), the TypeSystemDescription will contain both entries.
     * The error will be identified when validating the TextAnalysisEngineSpecifier
     * <code>TypeDescription</code> objects contained in <code>descs</code> will
     * be copied, hence, the memory ownership of the objects in <code>descs</code>
     * will remain with the caller of this method.
     * @see validate()
     **/
     void mergeTypeDescriptions(const TyVecpTypeDescriptions & descs);

     /**
     * NOTE: This object will assume memory ownership of <code>desc</code>,
     * i.e. it will delete it when destroyed !
     **/
     TyErrorId addTypeDescription(TypeDescription * desc, bool & takesMemoryOwnerShip);

     const TyVecpTypeDescriptions & getTypeDescriptions() const {
       return iv_vecpTypeDescriptions;
     }

     TypeDescription * getTypeDescription(const icu::UnicodeString & typeName) const;

     const TypeDescription * getTypeDescriptionConst(const icu::UnicodeString & typeName) const {
       return getTypeDescription(typeName);
     }

     bool hasTypeDescription(const icu::UnicodeString & typeName) const {
       return(EXISTS(getTypeDescriptionConst(typeName)));
     }

     //Import
     void setXmlFileLocation(const icu::UnicodeString xmlLoc) {
       iv_xmlFileLoc = xmlLoc;
     }

     /**
     * @return The full path name of the XML file used to build up this Specifier.
     * If it was built from a memory buffer,
     * returns some buffer ID generated by Xerces
     */
     const icu::UnicodeString & getXmlFileLocation() const {
       return iv_xmlFileLoc;
     }

     TyErrorId addImportDescription(ImportDescription * pDesc, bool & takesMemoryOwnerShip );

     const TyVecpImportDescriptions & getImportDescriptions() const {
       return iv_vecpImportDescriptions;
     }

     TyErrorId resolveImports(std::vector<icu::UnicodeString> & alreadyImportedTypeSystemLocations);

     TyErrorId resolveImport(const icu::UnicodeString & fileLocation,
                             std::vector<icu::UnicodeString> & alreadyImportedTypeSystemLocations,
                             TyVecpTypeDescriptions & result);
 	void validate();
   private:
     TypeSystemDescription(const TypeSystemDescription & crOther);
     TypeSystemDescription operator=(const TypeSystemDescription & crOther);

     TyVecpTypeDescriptions iv_vecpTypeDescriptions;
     TyVecpImportDescriptions iv_vecpImportDescriptions;
     icu::UnicodeString iv_xmlFileLoc;
   };


 }
 #endif
	/** \file typesystemdescription.hpp .
	-----------------------------------------------------------------------------



	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.

	-----------------------------------------------------------------------------

	\brief Contains classes uima::TypeDescription uima::FeatureDescription and uima::TypeSystemDescription

	Description: Defines the type system used in a Text Analysis Engine

	-----------------------------------------------------------------------------

	01/30/2003 Initial creation

	-------------------------------------------------------------------------- */
	#ifndef UIMA_TYPESYSTEMDESCRIPTION_HPP
	#define UIMA_TYPESYSTEMDESCRIPTION_HPP

	// ---------------------------------------------------------------------------
	// Includes
	// ---------------------------------------------------------------------------

	#include "uima/pragmas.hpp" //must be first to surpress warnings
	#include "uima/err_ids.h"
	#include "uima/taemetadata.hpp"
	#include "uima/importdescription.hpp"

	#include <vector>
	#include <map>

	namespace uima {

	/**
	* If a type can only contain an enumeration of values, there is an <code>AllowedValue</code> object
	* for each value. The value itself is returned by <code>getName</code>, <code>getDescription</code>
	* returns a description of the value.
	**/
	class UIMA_LINK_IMPORTSPEC AllowedValue :public MetaDataObject {
	public:
	AllowedValue()
	:MetaDataObject(), iv_name(), iv_description() {}

	AllowedValue(const AllowedValue & crOther) {
	iv_name = crOther.getName();
	iv_description = crOther.getDescription();
	}



	TyErrorId setName(const icu::UnicodeString & name) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_name = name;
	return UIMA_ERR_NONE;
	}

	TyErrorId setDescription(const icu::UnicodeString & description) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_description = description;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getName() const {
	return iv_name;
	}

	const icu::UnicodeString & getDescription() const {
	return iv_description;
	}

	private:
	icu::UnicodeString iv_name;
	icu::UnicodeString iv_description;
	};

	/**
	* Defines a feature by its name and the range type that its values can assume.
	* <code>getDescription</code> returns a textual description of the feature.
	**/
	class UIMA_LINK_IMPORTSPEC FeatureDescription:public MetaDataObject {

	public:

	FeatureDescription()
	:MetaDataObject(), iv_name(), iv_description(), iv_rangeType(),
	iv_elementType(), iv_multipleRefsAllowed(false) {}

	FeatureDescription(const FeatureDescription & crOther) {
	iv_name = crOther.getName();
	iv_description = crOther.getDescription();
	iv_rangeType = crOther.getRangeTypeName();
	iv_elementType = crOther.getElementType();
	iv_multipleRefsAllowed = crOther.isMultipleReferencesAllowed();
	}

	TyErrorId setName(const icu::UnicodeString & featName) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_name = featName;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getName() const {
	return iv_name;
	}

	TyErrorId setRangeTypeName(const icu::UnicodeString & rangeName) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_rangeType = rangeName;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getRangeTypeName() const {
	return iv_rangeType;
	}

	TyErrorId setElementType(const icu::UnicodeString & elementName) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_elementType = elementName;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getElementType() const {
	return iv_elementType;
	}

	TyErrorId setDescription(const icu::UnicodeString & desc) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_description = desc;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getDescription() const {
	return iv_description;
	}

	TyErrorId setMultipleReferencesAllowed(bool allowed) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_multipleRefsAllowed = allowed;
	return UIMA_ERR_NONE;
	}

	const bool isMultipleReferencesAllowed() const {
	return iv_multipleRefsAllowed;
	}

	private:
	icu::UnicodeString iv_name;
	icu::UnicodeString iv_description;
	icu::UnicodeString iv_rangeType;
	icu::UnicodeString iv_elementType;
	bool iv_multipleRefsAllowed;
	};

	/**
	* Defines a type by its name and the name of its super type.
	* If a type defines features or can only assume values from a
	* predefined set, the information is accessible via
	* <code>getFeatureDescriptions</code> and <code>getAllowedValues</code>, resp.
	* <code>getDescription</code> returns a textual description of the type.
	**/
	class UIMA_LINK_IMPORTSPEC TypeDescription :public MetaDataObject {

	public:
	typedef std::vector<FeatureDescription *> TyVecpFeatureDescriptions;
	typedef std::vector<AllowedValue *> TyVecpAllowedValues;

	TypeDescription()
	:MetaDataObject(), iv_typeName(), iv_superTypeName(), iv_description(),
	iv_vecpFeatureDescriptions(), iv_vecpAllowedValues() {};

	TypeDescription(const TypeDescription & crOther);

	~TypeDescription() {
	size_t i;
	for (i=0; i < iv_vecpFeatureDescriptions.size(); i++) {
	delete iv_vecpFeatureDescriptions[i];
	}
	for (i=0; i < iv_vecpAllowedValues.size(); i++) {
	delete iv_vecpAllowedValues[i];
	}
	}

	void commit() {
	size_t i;
	for (i=0; i < iv_vecpFeatureDescriptions.size(); i++) {
	iv_vecpFeatureDescriptions[i]->commit();
	}
	for (i=0; i < iv_vecpAllowedValues.size(); i++) {
	iv_vecpAllowedValues[i]->commit();
	}
	iv_bIsModifiable = false;
	}

	TyErrorId setName(const icu::UnicodeString & name) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_typeName = name;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getName() const {
	return iv_typeName;
	}

	TyErrorId setSuperTypeName(const icu::UnicodeString & name) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_superTypeName = name;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getSuperTypeName() const {
	return iv_superTypeName;
	}

	TyErrorId setDescription(const icu::UnicodeString & desc) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_description = desc;
	return UIMA_ERR_NONE;
	}

	const icu::UnicodeString & getDescription() const {
	return iv_description;
	}

	/**
	* NOTE: This object will assume memory ownership of <code>feature</code>,
	* i.e. it will delete it when destroyed.
	**/
	TyErrorId addFeatureDescription(FeatureDescription * feature, bool & takesMemoryOwnership);

	/**
	* Adds an AllowedValue object to the list of AllowedValues
	* NOTE: This object will assume memory ownership of <code>AllowedValue</code>,
	* i.e. it will delete it when destroyed.
	*/
	TyErrorId addAllowedValue(AllowedValue * allowed, bool & takesMemoryOwnership);

	/**
	* Adds all feature descriptions in descs to this TypeDescription.
	* If there are two features with the same name and rangetype, only
	* one will be in this TypeDescription.
	* However, if two features have the same name, but different rangetypes,
	* the TypeDescription will contain both.
	* The error will be identified when validating the TextAnalysisEngineSpecifier.
	* <code>FeatureDescription</code> objects contained in <code>descs</code> will
	* be copied, hence, the memory ownership of the objects in <code>descs</code>
	* will remain with the caller of this method.
	*
	**/
	void mergeFeatureDescriptions(const TyVecpFeatureDescriptions & descs);

	void mergeAllowedValues(const TyVecpAllowedValues & descs);

	const TyVecpFeatureDescriptions & getFeatureDescriptions() const {
	return iv_vecpFeatureDescriptions;
	}

	const TyVecpAllowedValues & getAllowedValues() const {
	return iv_vecpAllowedValues;
	}

	/**
	* returns a <code>FeatureDescription</code> with name <code>featureName</code>
	* or NULL, if no such feature can be found.
	**/
	FeatureDescription * getFeatureDescription(const icu::UnicodeString & featureName) const;

	AllowedValue * getAllowedValue(const icu::UnicodeString & name) const;

	void validate();
	private:

	TypeDescription & operator=(const TypeDescription & crOther);

	icu::UnicodeString iv_typeName;
	icu::UnicodeString iv_superTypeName;
	icu::UnicodeString iv_description;
	TyVecpFeatureDescriptions iv_vecpFeatureDescriptions;
	TyVecpAllowedValues iv_vecpAllowedValues;
	};

	/**
	* Contains an ordered list of type names. The ordering implies priority,
	* that is, if entry b comes after entry a in the list, then a as a higher
	* priority than b.
	**/
	class UIMA_LINK_IMPORTSPEC TypePriority :public MetaDataObject {
	public:
	TypePriority() :iv_vecTypeOrder() {}

	TyErrorId addType(const icu::UnicodeString & type) {
	if (! isModifiable()) {
	return UIMA_ERR_CONFIG_OBJECT_COMITTED;
	}
	iv_vecTypeOrder.push_back(type);
	return UIMA_ERR_NONE;
	}

	const std::vector <icu::UnicodeString> & getTypeOrder() const {
	return iv_vecTypeOrder;
	}

	private:
	std::vector <icu::UnicodeString> iv_vecTypeOrder;
	};

	/**
	* Contains all <code>TypeDescription</code> and <code>TypePriority</code> objects
	* for a <code>TextAnalysisEngine</code>.
	**/
	class UIMA_LINK_IMPORTSPEC TypeSystemDescription :public MetaDataObject {
	public:
	typedef std::vector<TypeDescription *> TyVecpTypeDescriptions;
	typedef std::vector<ImportDescription *> TyVecpImportDescriptions;


	TypeSystemDescription()
	:MetaDataObject(), iv_vecpTypeDescriptions() {};

	~TypeSystemDescription() {
	size_t i;
	for (i=0; i < iv_vecpTypeDescriptions.size(); i++) {
	delete iv_vecpTypeDescriptions[i];
	}
	for (i=0; i < iv_vecpImportDescriptions.size(); i++) {
	delete iv_vecpImportDescriptions[i];
	}
	}

	void commit() {
	iv_bIsModifiable = false;

	std::vector<icu::UnicodeString> alreadyImportedLocations;
	resolveImports(alreadyImportedLocations);
	size_t i;
	for (i=0; i < iv_vecpTypeDescriptions.size(); i++) {
	iv_vecpTypeDescriptions[i]->commit();
	}
	}

	/**
	* Adds all type descriptions in descs to this type system description.
	* If there are two type descriptions with the same name and same supertype,
	* their features are merged into one TypeDescription.
	* If two descriptions have the same name, but different supertype names
	* (which is not allowed), the TypeSystemDescription will contain both entries.
	* The error will be identified when validating the TextAnalysisEngineSpecifier
	* <code>TypeDescription</code> objects contained in <code>descs</code> will
	* be copied, hence, the memory ownership of the objects in <code>descs</code>
	* will remain with the caller of this method.
	* @see validate()
	**/
	void mergeTypeDescriptions(const TyVecpTypeDescriptions & descs);

	/**
	* NOTE: This object will assume memory ownership of <code>desc</code>,
	* i.e. it will delete it when destroyed !
	**/
	TyErrorId addTypeDescription(TypeDescription * desc, bool & takesMemoryOwnerShip);

	const TyVecpTypeDescriptions & getTypeDescriptions() const {
	return iv_vecpTypeDescriptions;
	}

	TypeDescription * getTypeDescription(const icu::UnicodeString & typeName) const;

	const TypeDescription * getTypeDescriptionConst(const icu::UnicodeString & typeName) const {
	return getTypeDescription(typeName);
	}

	bool hasTypeDescription(const icu::UnicodeString & typeName) const {
	return(EXISTS(getTypeDescriptionConst(typeName)));
	}

	//Import
	void setXmlFileLocation(const icu::UnicodeString xmlLoc) {
	iv_xmlFileLoc = xmlLoc;
	}

	/**
	* @return The full path name of the XML file used to build up this Specifier.
	* If it was built from a memory buffer,
	* returns some buffer ID generated by Xerces
	*/
	const icu::UnicodeString & getXmlFileLocation() const {
	return iv_xmlFileLoc;
	}

	TyErrorId addImportDescription(ImportDescription * pDesc, bool & takesMemoryOwnerShip );

	const TyVecpImportDescriptions & getImportDescriptions() const {
	return iv_vecpImportDescriptions;
	}

	TyErrorId resolveImports(std::vector<icu::UnicodeString> & alreadyImportedTypeSystemLocations);

	TyErrorId resolveImport(const icu::UnicodeString & fileLocation,
	std::vector<icu::UnicodeString> & alreadyImportedTypeSystemLocations,
	TyVecpTypeDescriptions & result);
	void validate();
	private:
	TypeSystemDescription(const TypeSystemDescription & crOther);
	TypeSystemDescription operator=(const TypeSystemDescription & crOther);

	TyVecpTypeDescriptions iv_vecpTypeDescriptions;
	TyVecpImportDescriptions iv_vecpImportDescriptions;
	icu::UnicodeString iv_xmlFileLoc;
	};



	}
	#endif