csvDisDictionary.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2016 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrfGuiCore/entityMapperKey.h>
#include <vrfGuiCore/orderedKeyList.h>
#include <vrfGuiCore/disDictionaryInterface.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 DtCsvDisDictionary : public DtDisDictionaryInterface
   {
   public:
      DtCsvDisDictionary(makVrv::DtDe&);
      virtual ~DtCsvDisDictionary();

      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);
      virtual std::string country(int c) const;

      virtual bool countryList(std::map<int, std::string>& list);
      virtual bool kindList(std::map<int, std::string>& list);
      virtual bool domainList(int kind, std::map<int, std::string>& list);
      virtual bool categoryList(int kind, int domain, std::map<int, std::string>& list);
      virtual bool subcategoryList(int kind, int domain, int country, int cat, std::map<int, std::string>& list);
      virtual bool specificList(int kind, int domain, int country, int cat, int subcat, std::map<int, std::string>& list);
      virtual bool extraList(int kind, int domain, int country, int cat, int subcat, int specific, std::map<int, std::string>& list);
      virtual void fillList(DtDisEntry*, std::map<int, std::string>& list);

      virtual std::string enumerationStrings(const DtEntityType&);

      virtual std::string displayName(const DtEntityType&, bool includeKind = true, int stopAt = 5);

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

      virtual DtString articulatedPart(int) const;

   protected:
      virtual void lineProcessed(int line);

   protected:
      virtual int countLines(const char*);
      virtual void initializeArticulatedParts();

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

      typedef std::map<int, DtString> ArticulatedPartMap;
      ArticulatedPartMap myArticulatedParts;
   };

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

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

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

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

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

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

   inline std::string DtCsvDisDictionary::country(int c) const
   {
      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;
   }
}