SmallWORMDict.h

Go to the documentation of this file.

#ifndef cond_SmallWORMDict_h
#define cond_SmallWORMDict_h

#include "CondFormats/Serialization/interface/Serializable.h"

#include<vector>
#include<string>
#include<algorithm>
#include<numeric>
#include<exception>
#include <boost/bind.hpp>
#include <boost/iterator_adaptors.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/iterator/counting_iterator.hpp>

// Function for testing SmallWORMDict
namespace test {
  namespace SmallWORMDict {
    int test();
  }
}

namespace cond {

  class SmallWORMDict {
    friend int test::SmallWORMDict::test();

  public:
    SmallWORMDict();
    ~SmallWORMDict();
    
    struct Frame {
      Frame(): b(0){}
      Frame(char const * ib,
        unsigned int il,
        unsigned int iind) :
    b(ib),l(il),ind(iind){}
      char const * b;
      unsigned int l;
      unsigned int ind;
    };

    struct IterHelp {
      typedef Frame result_type;
      IterHelp() : v(0){}
      IterHelp(SmallWORMDict const & iv) : v(&iv){}
      
      result_type const & operator()(int i) const {
    int k = (0==i) ? 0 : v->m_index[i-1]; 
    return  frame(&v->m_data[k], v->m_index[i]-k, i);
      } 
      
      Frame const & frame(char const * b,
              unsigned int l,
              unsigned int ind) const { 
    f.b = b; f.l=l; f.ind=ind;
    return f;
      }
      
    private:
      SmallWORMDict const * v;
      mutable Frame f;
    };
    
    friend struct IterHelp;

    typedef boost::transform_iterator<IterHelp,boost::counting_iterator<int> > const_iterator;

 
    const_iterator begin() const {
      return  boost::make_transform_iterator(boost::counting_iterator<int>(0),
                         IterHelp(*this));
    }
    
    const_iterator end() const {
      return  boost::make_transform_iterator(boost::counting_iterator<int>(size()),
                         IterHelp(*this));
    }

    Frame operator[](int i) const {
      int k = (0==i) ? 0 : m_index[i-1]; 
      return  Frame(&m_data[k], m_index[i]-k, i);
      } 

    const_iterator find(std::string const & s) const;

    const_iterator find(char const * s) const;

    // constructror from config
    explicit SmallWORMDict(std::vector<std::string> const & idict);
    
    // find location of a word
    size_t index(std::string const & s) const;

    size_t index(char const * s) const;

    size_t size() const;

  private: 
    std::vector<char> m_data;
    std::vector<unsigned int> m_index;
  
 COND_SERIALIZABLE;
};


}

#endif