#ifndef UIMA_LOWLEVEL_INDEXDEFINITION_HPP
#define UIMA_LOWLEVEL_INDEXDEFINITION_HPP
/** \file lowlevel_indexdefinition.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.

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

   Description:

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


-------------------------------------------------------------------------- */


/* ----------------------------------------------------------------------- */
/*       Include dependencies                                              */
/* ----------------------------------------------------------------------- */
#include "uima/pragmas.hpp"

#include <map>
#include <vector>
#include "uima/lowlevel_typedefs.hpp"
#include "uima/lowlevel_indexcomparator.hpp"
#include "unicode/unistr.h"

/* ----------------------------------------------------------------------- */
/*       Constants                                                         */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Forward declarations                                              */
/* ----------------------------------------------------------------------- */
namespace uima {
  namespace lowlevel {
    class TypeSystem;
    class IndexComparator;
    namespace internal {
      class IndexFactory;
    }
  }
}

/* ----------------------------------------------------------------------- */
/*       Types / Classes                                                   */
/* ----------------------------------------------------------------------- */
namespace uima {
  namespace lowlevel {

    /**
     * This class contains all index definitions together with the factories
     * needed for actually creating them.
     */
    class UIMA_LINK_IMPORTSPEC IndexDefinition {
      friend class uima::lowlevel::IndexRepository;
    public:
      typedef icu::UnicodeString TyIndexID;
      typedef enum {
        enOrdered = 0,
        enSet = 1,
        enFIFO = 2,
        enIndexKindNumber = 3
      } EnIndexKind;
    private:
      TypeSystem const & iv_crTypeSystem;
      // maps ids to index factories
      std::map<TyIndexID, internal::IndexFactory*> iv_mapFactories;

      // iv_mapIndexTypes[i] is the type of the index with ID i
      std::map<TyIndexID, TyFSType> iv_mapIndexTypes;

      // iv_mapIsPermanentFlags[i] is true if index with ID i contains permanent feature structures
      std::map<TyIndexID, bool> iv_mapIsPermanentFlags;
      std::vector<uima::lowlevel::IndexComparator*> iv_vecComparators;

      bool iv_bIsCommitted;

      /**
       * checks if the index defined in the first four arguments is compatible to
       * the one with ID crID.
       */
      bool isCompatibleIndexDefinition(EnIndexKind enIxKind,
                                       TyFSType tyType,
                                       std::vector<uima::lowlevel::TyFSFeature> const & crKeyFeatures,
                                       std::vector<uima::lowlevel::IndexComparator::EnKeyFeatureComp> const & crComparators,
                                       TyIndexID const & crID,
                                       bool ) const;
      /**
       * create a factory for the index defined by the arguments to this method.
       */
      uima::lowlevel::internal::IndexFactory * createFactory(EnIndexKind enIxKind,
          TyFSType,
          IndexComparator const * pComparator) const;

      void clear();

      IndexDefinition(IndexDefinition const &);
      IndexDefinition& operator=(IndexDefinition const &);

    public:
      IndexDefinition(uima::lowlevel::TypeSystem const &);
      ~IndexDefinition();

      TypeSystem const & getTypeSystem() const {
        return iv_crTypeSystem;
      }

      void commit();

      bool isCommitted() const {
        return iv_bIsCommitted;
      }

      /*@{*/
      /**
       * @name Index Creation
       */

      /**
       * add an index definition
       *
       * @param enIxKind the kind of the index
       * @param tyType the most general type where the index should be introduced
       * @param crKeyFeatures a vector of key features used for comparison
       * @param crComparators a vector defining how the key features should be compared
       * @param id the ID under which this index can be identified
       * @param bIsPermanent flag indicating if this index contains only permanent feature structures
       */
      void defineIndex(EnIndexKind enIxKind,
                       TyFSType tyType,
                       std::vector<uima::lowlevel::TyFSFeature> const & crKeyFeatures,
                       std::vector<uima::lowlevel::IndexComparator::EnKeyFeatureComp> const & crComparators,
                       TyIndexID const & id,
                       bool bIsPermanent = false);


      /*@}*/

      /**
       * check if an index with ID <code>id</code> exists.
       */
      bool isValidIndexId(TyIndexID const & crID) const {
        return(iv_mapFactories.find(crID) != iv_mapFactories.end());
      }

      /**
       * returns the comparator for the index with the specidied ID.
       * If the index has no comparator, NULL is returned.
       */
      uima::lowlevel::IndexComparator const * getComparator(TyIndexID const & crID) const;

      /**
       * get the kind of the index.
       */
      EnIndexKind getIndexKind(TyIndexID const & crID) const;

      /**
       * check if an index with ID <code>id</code> for type <code>tyType</code> exists.
       */
      bool isValidIndexId(TyIndexID const &, TyFSType tyType) const;

      /**
       * get the number of existing indexes.
       */
      size_t getNumberOfIndexes() const {
        return iv_mapFactories.size();
      }

      /**
       * get the most general type the index with ID <code>id</code> is defined for.
       */
      TyFSType getTypeForIndex(TyIndexID const & crID) const {
        //assert( isValidIndexId(crID) );
	std::map<TyIndexID, TyFSType>::const_iterator cit = iv_mapIndexTypes.find(crID);
        return (*cit).second;
      }

      uima::lowlevel::internal::IndexFactory const * getFactory(TyIndexID const & crID) const {
	std::map<TyIndexID, internal::IndexFactory*>::const_iterator cit = iv_mapFactories.find(crID);
        if (cit == iv_mapFactories.end()) {
          return NULL;
        }
        return (*cit).second;
      }

      /**
       * get the IDs of all indexes.
       * @param rResult output parameter
       */
      void getAllIndexIDs(std::vector<TyIndexID>& rResult) const;

      void reset();

    };
  }
}

/* ----------------------------------------------------------------------- */
/*       Implementation                                                    */
/* ----------------------------------------------------------------------- */


/* ----------------------------------------------------------------------- */


#endif