qdp_map_obj_disk_multiple.h

Go to the documentation of this file.

// -*- C++ -*-
 
 
#ifndef __qdp_map_obj_disk_multiple_h__
#define __qdp_map_obj_disk_multiple_h__
 
#include "qdp_map_obj_disk.h"
#include <vector>
 
namespace QDP
{
 
  //----------------------------------------------------------------------------
  template<typename K, typename V>
  class MapObjectDiskMultiple
  {
  public:
    MapObjectDiskMultiple() {}

    ~MapObjectDiskMultiple() {}

    void setDebug(int level)
    {
      for(int i=0; i < dbs_.size(); ++i)
        dbs_[i]->setDebug(level);
    }

    int getDebug() const {return dbs_[0]->getDebug();}

    void open(const std::vector<std::string>& files)
    {
      dbs_.resize(files.size());
 
      for(int i=0; i < dbs_.size(); ++i)
      {
        dbs_[i] = new MapObjectDisk<K,V>();
        dbs_[i]->open(files[i], std::ios_base::in);
      }
    }
 

    bool fileExists(const std::vector<std::string>& files) const
    {
      bool ret = true;
      for(int i=0; i < dbs_.size(); ++i)
      {
        ret = dbs_[i]->fileExists(files[i]);
        if (! ret)
          return ret;
      }
 
      return ret;
    }
 

    void close()
    {
      for(int i=0; i < dbs_.size(); ++i)
      {
        dbs_[i]->close();
        delete dbs_[i];
      }
    }
 

    int get(const K& key, V& val) const
    {
      int ret = -1;
 
      for(int i=0; i < dbs_.size(); ++i) 
      {
        ret = dbs_[i]->get(key, val);
        if (ret == 0)
          break;
      }
      return ret;
    }
 

    void keys(std::vector<K>& keys_) const {
      keys_.clear();
 
      std::unordered_map<std::string,int> unique_it;
 
      for(int i=0; i < dbs_.size(); ++i) 
      {
        std::vector<K> kk;
        dbs_[i]->keys(kk);
 
        for(typename std::vector<K>::const_iterator k=kk.begin(); k != kk.end(); ++k)
        {
          BinaryBufferWriter bin;
          write(bin, *k);
 
          unique_it.insert(std::make_pair(bin.str(),1));
        }
      }
 
      for(typename std::unordered_map<std::string,int>::const_iterator k=unique_it.begin(); k != unique_it.end(); ++k)
      {
        BinaryBufferReader bin(k->first);
        K key;
        read(bin, key);
        keys_.push_back(key);
      }
    }
    
    void flush()
    {
      for(int i=0; i < dbs_.size(); ++i)
      {
        dbs_[i]->flush();
      }
    }
 

    bool exist(const K& key) const
    {
      bool ret = false;
      
      for(int i=0; i < dbs_.size(); ++i)
      {
        ret = dbs_[i]->exist(key);
        if (ret)
          break;
      }
      
      return ret;
    }

    int getUserdata(std::string& user_data) const
    {
      int ret = -1;
 
      if (dbs_.size() == 0)
        return ret;
 
      // Grab the first db
      ret = dbs_[0]->getUserdata(user_data);
 
      return ret;
    }
 
  private:
    MapObjectDiskMultiple(const MapObjectDiskMultiple&) {}

    void operator=(const MapObjectDiskMultiple&) {}
 
  private:
    std::vector< MapObjectDisk<K,V>* > dbs_;
  };
 
} // namespace Chroma
 
#endif