Dictionary.hpp

Go to the documentation of this file.

#ifndef DICTIONARY_HPP
#define DICTIONARY_HPP

#include <algorithm>
#include <iterator>
#include <iostream>
#include <sstream>
#include <vector>
#include <map>
#include <type_traits>

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
template <typename _Key=std::string, typename _Value=unsigned int>
class Dictionary
{
public:
  typedef std::map<_Key, _Value> Items;
  typedef typename Items::iterator Iterator;
  typedef typename Items::const_iterator ConstIterator;

  Dictionary(void) : items() {}
  Dictionary(const Dictionary& rhs);
  Dictionary(Dictionary&& rhs);
  virtual ~Dictionary(void) {}

  Dictionary& operator=(const Dictionary& rhs);
  Dictionary& operator=(Dictionary&& rhs);

  Dictionary& operator+=(const Dictionary& rhs);
  Dictionary& operator/=(size_t count);

  const Items& getItems(void) const {return items;}

  size_t getItemsCount(void) const;
  bool isExist(const _Key key) const;
  const _Value& getItem(const _Key& key) const;
  _Value getItem(const _Key& key);
  void setItem(const _Key& key, const _Value& value);
  void setItem(const _Key& key, _Value&& value);

  void clear(void);

  template <class _Other> _Other cast(void) const;
  template <class _Other, class _Arg> _Other cast(_Arg arg) const;
  template <class _Other> void copy(_Other& other) const;

  Iterator begin(void) noexcept;
  ConstIterator begin(void) const noexcept;

  Iterator end(void) noexcept;
  ConstIterator end(void) const noexcept;
protected:
  Items items;
};
//-----------------------------------------------------------------------------
template <class _Key, class _Value> Dictionary<_Key, _Value>::Dictionary(const Dictionary& rhs)
: items()
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> Dictionary<_Key, _Value>::Dictionary(Dictionary&& rhs)
: items()
{
  (*this) = std::forward<Dictionary>(rhs);
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> Dictionary<_Key, _Value>& Dictionary<_Key, _Value>::operator=(const Dictionary& rhs)
{
  if (this!=&rhs)
  {
    items = rhs.getItems();
  }
  return *this;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> Dictionary<_Key, _Value>& Dictionary<_Key, _Value>::operator=(Dictionary&& rhs)
{
  if (this!=&rhs)
  {
    items = std::move(rhs.getItems());
  }
  return *this;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> Dictionary<_Key, _Value>& Dictionary<_Key, _Value>::operator+=(const Dictionary& rhs)
{
  for (Dictionary::ConstIterator iter=rhs.begin();iter!=rhs.end();++iter)
  {
    this->setItem((*iter).first, getItem((*iter).first)+(*iter).second);
  }
  return *this;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> Dictionary<_Key, _Value>& Dictionary<_Key, _Value>::operator/=(size_t count)
{
  if (std::is_arithmetic<_Value>::value && count)
  {
    for (Dictionary::Iterator iter=begin();iter!=end();++iter)
    {
      (*iter).second /= count;
    }
  }
  return *this;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> size_t Dictionary<_Key, _Value>::getItemsCount(void) const
{
  return items.size();
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> bool Dictionary<_Key, _Value>::isExist(const _Key key) const
{
  return (items.find(key) != end());
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> const _Value& Dictionary<_Key, _Value>::getItem(const _Key& key) const
{
  ConstIterator iter = items.find(key);
  return (*iter).second;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> _Value Dictionary<_Key, _Value>::getItem(const _Key& key)
{
  return (isExist(key))?items[key]:_Value();
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> void Dictionary<_Key, _Value>::setItem(const _Key& key, const _Value& value)
{
  items[key] = value;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> void Dictionary<_Key, _Value>::setItem(const _Key& key, _Value&& value)
{
  items[key] = std::move(std::forward<_Value>(value));
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> void Dictionary<_Key, _Value>::clear(void)
{
  items.clear();
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> template <class _Other> _Other Dictionary<_Key, _Value>::cast(void) const
{
  _Other other;
  copy<_Other>(other);
  return other;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> template <class _Other, class _Arg> _Other Dictionary<_Key, _Value>::cast(_Arg arg) const
{
  _Other other(arg);
  copy<_Other>(other);
  return other;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> template <class _Other> void Dictionary<_Key, _Value>::copy(_Other& other) const
{
  HCE::handlers::Dictionary<_Key, _Value>* pOther = dynamic_cast<HCE::handlers::Dictionary<_Key, _Value>*>(&other);
  if (pOther)
  {
    *pOther = *this;
  }
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> typename Dictionary<_Key, _Value>::Iterator Dictionary<_Key, _Value>::begin(void) noexcept
{
  return items.begin();
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> typename Dictionary<_Key, _Value>::ConstIterator Dictionary<_Key, _Value>::begin(void) const noexcept
{
  return items.begin();
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> typename Dictionary<_Key, _Value>::Iterator Dictionary<_Key, _Value>::end(void) noexcept
{
  return items.end();
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> typename Dictionary<_Key, _Value>::ConstIterator Dictionary<_Key, _Value>::end(void) const noexcept
{
  return items.end();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
template <typename _Key, typename _Value>
class DictionaryConverter
{
  static const char DELIMITER = ',';
public:
  DictionaryConverter(void);
  explicit DictionaryConverter(const Dictionary<_Key, _Value>& rhs);
  explicit DictionaryConverter(const std::string& rhs);

  Dictionary<_Key, _Value> toObject(void) const {return dictionary;}
  std::string toString(const char delimiter=DELIMITER);

  void fromObject(const Dictionary<_Key, _Value>& rhs);
  void fromString(const std::string& data, const char delimiter=DELIMITER);
private:
  Dictionary<_Key, _Value> dictionary;
};
//-----------------------------------------------------------------------------
template <class _Key, class _Value> DictionaryConverter<_Key, _Value>::DictionaryConverter(void)
: dictionary()
{
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> DictionaryConverter<_Key, _Value>::DictionaryConverter(const Dictionary<_Key, _Value>& rhs)
: dictionary(rhs)
{
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> DictionaryConverter<_Key, _Value>::DictionaryConverter(const std::string& rhs)
: dictionary()
{
  fromString(rhs);
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> std::string DictionaryConverter<_Key, _Value>::toString(const char delimiter)
{
  std::stringstream ostr;
  for (typename Dictionary<_Key, _Value>::ConstIterator iter=dictionary.begin();iter!=dictionary.end();++iter)
  {
    if (iter!=dictionary.begin())
      ostr << delimiter;
    ostr << (*iter).second;
  }
  return ostr.str();
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> void DictionaryConverter<_Key, _Value>::fromObject(const Dictionary<_Key, _Value>& rhs)
{
  dictionary = rhs;
}
//-----------------------------------------------------------------------------
template <class _Key, class _Value> void DictionaryConverter<_Key, _Value>::fromString(const std::string& data, const char delimiter)
{
  dictionary.clear();
  std::string str(data);
  std::replace(str.begin(), str.end(), delimiter, ' ');
  std::stringstream istr(str);
  std::istream_iterator<std::string> iit(istr);
  std::istream_iterator<std::string> eos;

  unsigned int index = 0;
  while (iit != eos)
  {
    _Key key;
    std::istringstream(std::to_string(++index)) >> key;
    _Value value;
    std::istringstream(*iit) >> value;

    dictionary.setItem(key, value);
    ++iit;
  }
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE 

#endif // DICTIONARY_HPP