mi32/mimap3.h

Go to the documentation of this file.

#ifndef  INC_MI32_MIMAP3_H
#define  INC_MI32_MIMAP3_H

#include <map>
#include <vector>

#ifndef  INC_MI32_MISTRING_H
#include <mi32/mistring.h>
#endif


template <typename STORED_TYPE> class MIMAP3 {
   public:


      explicit MIMAP3 (
         unsigned NumValues = 0,                
         unsigned MaxValues = 0
         ):
         m_VectorStored(NumValues),
         m_VectorValid(NumValues,false),
         m_MaxValues((NumValues > MaxValues) ? NumValues : MaxValues),
         m_UseMap(m_MaxValues==0)
         { }

      bool Find (
         unsigned value,
         STORED_TYPE &ret
         ) const {
            if (value >= m_VectorValid.size() || !m_VectorValid[value]) {
               if (m_UseMap) return (Find(static_cast<double>(value),ret));
               else return (false);
               }
            ret = m_VectorStored[value];
            return (true);
            }

      bool Find (
         double value,
         STORED_TYPE &ret
         ) const {
            typename MAP_DOUBLE::const_iterator it = m_MapDouble.find(value);
            if (it == m_MapDouble.end()) return (false);
            ret = it->second;
            return (true);
            }

      bool Find (
         const MISTRING& value,
         STORED_TYPE &ret
         ) const {
            typename MAP_STRING::const_iterator it = m_MapString.find(value);
            if (it == m_MapString.end()) return (false);
            ret = it->second;
            return (true);
            }

      void Store (
         unsigned value,
         const STORED_TYPE& stored
         ) {
         if (value >= m_MaxValues) {
            Store(static_cast<double>(value),stored);
            m_UseMap = true;
            }
         else {
            if (value >= m_VectorValid.size()) {
               m_VectorValid.resize(value+1,false);
               m_VectorStored.resize(value+1);
               }
            m_VectorValid[value] = true;
            m_VectorStored[value] = stored;
            }
         }

      void Store (
         double value,
         const STORED_TYPE& stored
         ) { m_MapDouble.insert(std::pair<double,STORED_TYPE>(value,stored)); }

      void Store (
         const MISTRING& value,
         const STORED_TYPE& stored
         ) { m_MapString.insert(std::pair<MISTRING,STORED_TYPE>(value,stored)); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      typedef std::map<double,STORED_TYPE> MAP_DOUBLE;
      typedef std::map<MISTRING,STORED_TYPE> MAP_STRING;

      std::vector<STORED_TYPE> m_VectorStored;
      std::vector<UINT8> m_VectorValid;
      MAP_DOUBLE m_MapDouble;
      MAP_STRING m_MapString;
      unsigned m_MaxValues;
      bool m_UseMap;

      #endif
   };

#endif   INC_MI32_MIMAP3_H

---