include/vrfGuiCore/disDictionary.h

Go to the documentation of this file.

   /*******************************************************************************
** Copyright (c) 2005 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: disDictionary.h,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/


#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrfGuiCore/entityMapperKey.h>
#include <vrfGuiCore/orderedKeyList.h>

#include <map>
#include <string>

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtDisEntry
   {
   public:
      DtDisEntry();
      DtDisEntry(const std::string&);
      virtual ~DtDisEntry();

   public:
      virtual DtDisEntry* addDisEntry(int iVal, const std::string& sVal);
      virtual DtDisEntry* find(int iVal);

   public:
      std::map<int, DtDisEntry*> myEntries;
      std::string                myValue;
   };

   class DT_DLL_VRFGUICORE DtDisEntityTypeEntry : public DtEntityMapperKey
   {
   public:
      DtDisEntityTypeEntry(const DtEntityMapperKey& key) : DtEntityMapperKey(key) {};
      DtDisEntityTypeEntry(const DtDisEntityTypeEntry& orig)
      : DtEntityMapperKey(orig)
      , myStrings(orig.myStrings)
      {
      }

      void addString(const std::string& str);
      const std::vector<std::string>& strings() const;

      int& operator[](int i) { return DtEntityMapperKey::operator[](i); };
      const int operator[](int i) const  { return DtEntityMapperKey::operator[](i); };

      DtDisEntityTypeEntry* clone()
      {
         return new DtDisEntityTypeEntry(*this);
      }

   protected:
      std::vector<std::string> myStrings;
   };

   class DT_DLL_VRFGUICORE DtDisDictionary
   {
   public:
      DtDisDictionary();
      virtual ~DtDisDictionary();

      virtual bool loadFromFile(const std::string& file);

      const DtOrderedKeyList<DtDisEntityTypeEntry*>& enumerationList() const;
      DtOrderedKeyList<DtDisEntityTypeEntry*>& enumerationList();
      const DtDisEntry& disEntries() const;
      DtDisEntry& disEntries();

      const DtDisEntityTypeEntry* findEntry(const DtEntityMapperKey& entKey) const;
      DtDisEntityTypeEntry* findEntry(const DtEntityMapperKey& entKey);
      std::string findCountry(int c);

      static std::map<int, std::string>& countries();

   protected:
      virtual void lineProcessed(int line);

   protected:
      virtual int countLines(const char*);

   protected:
      DtDisEntry                                myDisEntries;
      DtOrderedKeyList<DtDisEntityTypeEntry*>   myEntityKeys;
      static std::map<int, std::string>         theCountries;
   };

   inline const DtDisEntityTypeEntry* DtDisDictionary::findEntry(const DtEntityMapperKey& entKey) const
   {
      return myEntityKeys.find(entKey);
   }

   inline DtDisEntityTypeEntry* DtDisDictionary::findEntry(const DtEntityMapperKey& entKey)
   {
      return myEntityKeys.find(entKey);
   }

   inline const DtOrderedKeyList<DtDisEntityTypeEntry*>& DtDisDictionary::enumerationList() const
   {
      return myEntityKeys;
   }

   inline DtOrderedKeyList<DtDisEntityTypeEntry*>& DtDisDictionary::enumerationList()
   {
      return myEntityKeys;
   }

   inline const DtDisEntry& DtDisDictionary::disEntries() const
   {
      return myDisEntries;
   }

   inline DtDisEntry& DtDisDictionary::disEntries()
   {
      return myDisEntries;
   }

   inline std::string DtDisDictionary::findCountry(int c)
   {
      std::map<int, std::string>::const_iterator iter = countries().find(c);

      if (iter == countries().end())
      {
         return "";
      }
      else
      {
         return iter->second;
      }
   }

   inline void DtDisEntityTypeEntry::addString(const std::string& str)
   {
      myStrings.push_back(str);
   }

   inline const std::vector<std::string>& DtDisEntityTypeEntry::strings() const
   {
      return myStrings;
   }
}