| #ifndef UIMA_TYPENAMESPACE_HPP |
| #define UIMA_TYPENAMESPACE_HPP |
| /** \file typenamespace.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 class uima::TypeNameSpace and uima::TypeNameSpaceImport |
| |
| Description: |
| |
| ----------------------------------------------------------------------------- |
| |
| |
| -------------------------------------------------------------------------- */ |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Include dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| #include "uima/pragmas.hpp" // must be first file to be included to get pragmas |
| #include "uima/typesystem.hpp" |
| #include "unicode/unistr.h" |
| #include <vector> |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Forward declarations */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Types / Classes */ |
| /* ----------------------------------------------------------------------- */ |
| |
| |
| namespace uima { |
| |
| /// The constant we use to seperate namespace parts: A period |
| const char TYPENAMESPACE_SEP = '.'; |
| |
| /** |
| * An accessor object that gives access to all types that share a common |
| * namespace. |
| * For example if a TypeNameSpace object is created for the |
| * namespace "uima.tt" |
| * (<code> TypeNameSpace ttNameSpace(ts, "uima.tt");</code>) |
| * you can then use this object to get type objects from types names |
| * by using only short names e.g. |
| * <code>Type t = ttNameSpace.getType("Lemma");</code> |
| * would be equivalent to |
| * <code>Type t = ts.getType("uima.tt.Lemma);</code> |
| */ |
| class UIMA_LINK_IMPORTSPEC TypeNameSpace { |
| private: |
| icu::UnicodeString iv_usName; |
| uima::TypeSystem const * iv_cpTypeSystem; |
| public: |
| /** |
| * Construct a TypeNameSpace object by passing it a reference |
| * the type system it lives in and the name of the namespace |
| * it should represent. |
| */ |
| TypeNameSpace(uima::TypeSystem const & crTypeSystem, icu::UnicodeString const & crName); |
| |
| /** |
| * Find a type object by it's short name. |
| * Implicitly this just prepends the namespace name to crTypeBaseName |
| */ |
| Type getType(icu::UnicodeString const & crTypeBaseName) const; |
| |
| /// Return the name of this namespace object |
| icu::UnicodeString const & getName() const; |
| |
| /// Return a container with type objects for all types in this namespace |
| void getAllTypes(std::vector<Type> & rResult) const; |
| |
| /// Return the typesystem this namespace lives in |
| TypeSystem const & getTypeSystem() const; |
| }; |
| |
| |
| /** |
| * This class is usefull to bundle several TypeNameSpace objects into |
| * a lookup sequence that can be used to lookup unqualified type names. |
| * The TypeNameSpaceImport object will try to find an unqualified type |
| * name in each TypeNameSpace objects that has been added to it. |
| * The lookup will be done in the sequence in which the TypeNameSpace |
| * objects have been added. |
| */ |
| class UIMA_LINK_IMPORTSPEC TypeNameSpaceImport { |
| private: |
| std::vector<TypeNameSpace> iv_vecImports; |
| uima::TypeSystem const * iv_cpTypeSystem; |
| public: |
| /** |
| * Construct a TypeNameSpaceImport object from an type system |
| */ |
| TypeNameSpaceImport( uima::TypeSystem const & ); |
| |
| /** |
| * Add a TypeNameSpace object to this TypeNameSpaceImport object. |
| * Note: The order of the addNameSpace() calls will be relevant |
| * for a later lookup using getType() |
| */ |
| void addNameSpace(TypeNameSpace const & crNamespace); |
| |
| /** |
| * try to get the type with the specified relative name. |
| * If there is a name conflict, false is returned, true otherwise. |
| * @param crRelativeTypeName input: not fully specified type name |
| * @param rResult output parameter |
| */ |
| bool getType(icu::UnicodeString const & crRelativeTypeName, Type & rResult) const; |
| |
| /** |
| * Return a container with type objects for all types of all namespace |
| * that have been added to this TypeNameSpaceImport object |
| */ |
| void getAllTypes(std::vector<Type> & rResult) const; |
| |
| /// Return the typesystem this TypeNameSpaceImport object lives in |
| TypeSystem const & getTypeSystem() const; |
| }; |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| |
| |
| #endif |
| |