qdp_map_obj_memory.h

Go to the documentation of this file.

// -*- C++ -*-
 
#ifndef __qdp_map_obj_memory_h__
#define __qdp_map_obj_memory_h__
 
#include "qdp_map_obj.h"
#include <vector>
#include <unordered_map>
 
namespace QDP
{
 
 
  //----------------------------------------------------------------------------
  template<typename K, typename V>
  class MapObjectMemoryIterator : public std::iterator<std::input_iterator_tag, 
                                                 std::unordered_map<std::string, std::pair<K,V> > >
  {
  public:
    typedef std::unordered_map<std::string, std::pair<K,V> > MapType_t;

    MapObjectMemoryIterator(const typename MapType_t::const_iterator& iter_) : src_iter(iter_) {}

    MapObjectMemoryIterator(const MapObjectMemoryIterator& p) : src_iter(p.src_iter) {}

    MapObjectMemoryIterator& operator++() {++src_iter; return *this;}
 
    MapObjectMemoryIterator operator++(int) 
    {
      MapObjectMemoryIterator<K,V> tmp(*this); 
      operator++(); 
      return tmp;
    }

    bool operator==(const MapObjectMemoryIterator& rhs) const {return src_iter == rhs.src_iter;}

    bool operator!=(const MapObjectMemoryIterator& rhs) const {return src_iter != rhs.src_iter;}
 
    // Coercion
    const std::pair<K,V>& operator*() const {return src_iter->second;}
    
    // Coercion
    const std::pair<K,V>* operator->() const {return &(src_iter->second);}
    
  private:
    typename MapType_t::const_iterator src_iter;
    
  };
 
 
  //----------------------------------------------------------------------------
  template<typename K, typename V>
  class MapObjectMemory : public MapObject<K,V>
  {
  public:
    typedef K key_type;
    typedef V mapped_type;
    typedef std::pair<K,V> value_type;
    typedef MapObjectMemoryIterator<K,V> const_iterator;

    typedef std::unordered_map<std::string, value_type> MapType_t;
    
    MapObjectMemory() {}

    ~MapObjectMemory() {}

    int insertUserdata(const std::string& user_data_) 
    {
      user_data = user_data_;
      return 0;
    }
    
    int getUserdata(std::string& user_data_) const 
    {
      user_data_ = user_data;
      return 0;
    }

    int insert(const K& key, const V& val) 
    {
      return this->insert(std::make_pair(key,val));
    }
                        
    template<typename InputIterator>
    int insert(InputIterator first, InputIterator last)
    {
      int ret = 0;
      for(InputIterator iter = first; iter != last; ++iter)
        this->insert(*iter);
      return ret;
    }
                        
    int insert(const value_type& vv) 
    { 
      int ret = 0;
      BinaryBufferWriter bin;
      write(bin, vv.first);
 
      const std::string bin_key(bin.str());
      typename MapType_t::iterator iter = src_map.find(bin_key);
      if (iter != src_map.end())
      {
        iter->second = vv;
      }
      else
      {
        src_map.insert(std::make_pair(bin_key,vv));
      }
      return ret;
    }
                        
    int get(const K& key, V& val) const
    {
      int ret = 0;
      BinaryBufferWriter bin;
      write(bin, key);
 
      typename MapType_t::const_iterator iter = src_map.find(bin.str());
      if (iter == src_map.end()) {
        ret = 1;
      }
      else {
        val = iter->second.second;
      }
      return ret;
    }
                        
    void erase(const K& key) 
    {
      BinaryBufferWriter bin;
      write(bin, key);
 
      typename MapType_t::const_iterator iter = src_map.find(bin.str());
      if (iter != src_map.end())
      {
        src_map.erase(iter);
      }
    }
                        
    void clear() {src_map.clear();}

    void flush() {}

    bool exist(const K& key) const
    {
      BinaryBufferWriter bin;
      write(bin, key);
      return (src_map.find(bin.str()) == src_map.end()) ? false : true;
    }
                        
//    size_t size() const {return src_map.size();}
    unsigned int size() const {return static_cast<unsigned long>(src_map.size());}

    void keys(std::vector<K>& _keys) const
    {
      _keys.resize(0);
      for(typename MapType_t::const_iterator iter  = src_map.begin(); iter != src_map.end(); ++iter)
      {
        _keys.push_back(iter->second.first);
      }
    }

    virtual void keysAndValues(std::vector<K>& _keys, std::vector<V>& _vals) const 
    {
      _keys.resize(0);
      _vals.resize(0);
      for(typename MapType_t::const_iterator iter  = src_map.begin(); iter != src_map.end(); ++iter)
      {
        _keys.push_back(iter->second.first);
        _vals.push_back(iter->second.second);
      }
    }
 
    // Extensions to the basic MapObject
    const V& operator[](const K& key) const 
    {
      BinaryBufferWriter bin;
      write(bin, key);
 
      typename MapType_t::const_iterator iter = src_map.find(bin.str());
      if (iter == src_map.end())
      {
        std::cerr << "MapObject: key not found" << std::endl;
        exit(1);
      }
 
      return iter->second.second;
    }
                        
    V& operator[](const K& key) 
    {
      BinaryBufferWriter bin;
      write(bin, key);
 
      typename MapType_t::iterator iter = src_map.find(bin.str());
      if (iter == src_map.end())
      {
        std::cerr << "MapObject: key not found" << std::endl;
        exit(1);
      }
 
      return iter->second.second;
    }

    virtual const_iterator begin() const {return MapObjectMemoryIterator<K,V>(src_map.begin());}

    virtual const_iterator end() const {return MapObjectMemoryIterator<K,V>(src_map.end());}
 
 
  protected:  
    mutable MapType_t src_map;

    std::string user_data;
  };
 
 
 
  //----------------------------------------------------------------------------
  template<typename K, typename V>
  inline
  void read(XMLReader& xml, const std::string& s, MapObjectMemory<K,V>& input)
  {
    XMLReader arraytop(xml, s);
 
    std::ostringstream error_message;
    std::string elemName = "elem";
  
    int array_size;
    try {
      array_size = arraytop.count(elemName);
    }
    catch( const std::string& e) { 
      error_message << "Exception occurred while counting " << elemName
                    << " during array read " << s << std::endl;
      arraytop.close();
      throw error_message.str();
    }
      
    // Get the elements one by one
    for(int i=0; i < array_size; i++) 
    {
      std::ostringstream element_xpath;
 
      // Create the query for the element 
      element_xpath << elemName << "[" << (i+1) << "]";
 
      // recursively try and read the element.
      try {
        XMLReader xml_elem(arraytop, element_xpath.str());
 
        K key;
        V val;
 
        read(xml_elem, std::string("Key"), key);
        read(xml_elem, std::string("Val"), val);
 
        input.insert(key, val);
      } 
      catch (const std::string& e) 
      {
        error_message << "Failed to match element " << i
                      << " of array  " << s << "  with query " << element_xpath.str()
                      << std::endl
                      << "Query returned error: " << e;
        arraytop.close();
        throw error_message.str();
      }
    }
 
    // Arraytop should self destruct but just to be sure.
    arraytop.close();
  }
 
 
  //----------------------------------------------------------------------------
  template<typename K, typename V>
  inline
  void write(XMLWriter& xml, const std::string& path, const MapObjectMemory<K,V>& param)
  {
    push(xml, path);
 
    for(typename MapObjectMemory<K,V>::const_iterator iter = param.begin(); iter != param.end(); ++iter)
    {
      push(xml, "elem");
      write(xml, "Key", iter->first);
      write(xml, "Val", iter->second);
      pop(xml);
    }
 
    pop(xml);
  }
 
} // namespace QDP
 
#endif