strbitset.h

Go to the documentation of this file.

#ifndef strbitset_h
#define strbitset_h

#include <string>
#include <map>
#include <vector>
#include <iostream>
#include <fstream>

namespace pat {

class strbitset {
 public:


  class index_type {
  public:
    typedef unsigned int   size_t;
    
    friend class strbitset;

  index_type() :bitset_(nullptr), i_(0) {}
    
  index_type( strbitset const * b, std::string const & s) :
    bitset_(b) 
    {
      if ( bitset_ ) {
    i_ = bitset_->index(s);
      } else {
    i_ = 0;
      }
    }

    std::string const & str() const { return bitset_->index(i_);}

    bool operator< ( index_type const & r) const { return i_ < r.i_;}
    bool operator> ( index_type const & r) const { return i_ > r.i_;}
    bool operator<=( index_type const & r) const { return i_ <= r.i_;}
    bool operator>=( index_type const & r) const { return i_ >= r.i_;}
    bool operator==( index_type const & r) const { return i_ == r.i_;}    

    friend std::ostream & operator<<(std::ostream & out, const index_type & r);
      
  protected:
    strbitset const *   bitset_;
    size_t              i_;
  };


  friend class index_type;

  // Add typedefs
  typedef unsigned int                    size_t;
  typedef std::map<std::string, size_t>   str_index_map;
  typedef std::vector<bool>               bit_vector;

 strbitset() {
    clear();
  }

  void clear() {
    map_.clear();
    bits_.clear();
  }

  operator bool() const {
    bool b = true;
    for ( bit_vector::const_iterator bitsBegin = bits_.begin(),
        bitsEnd = bits_.end(), ibit = bitsBegin;
      ibit != bitsEnd; ++ibit ) {
      if ( *ibit == false ) b = false;
    }
    return b;
  }

  bool operator!() const {
    return ! ( operator bool() );
  }
  
  void push_back( std::string s ) {
    if ( map_.find(s) == map_.end() ) {
      map_[s] = bits_.size();
      bits_.resize( bits_.size() + 1 );
      *(bits_.rbegin()) = false;
    } else {
      std::cout << "Duplicate entry " << s << ", not added to registry" << std::endl;
    }
  }


  void print(std::ostream & out) const {
    for( str_index_map::const_iterator mbegin = map_.begin(),
       mend = map_.end(),
       mit = mbegin;
     mit != mend; ++mit ) {
      char buff[100];
      sprintf(buff, "%10s = %6i", mit->first.c_str(), (int)(bits_.at(mit->second)));
      out << buff << std::endl;
    }
  }

  bit_vector::const_reference operator[] ( const std::string s) const {
    size_t index = this->index(s);
    return bits_.operator[](index);
  }

  bit_vector::const_reference operator[] ( index_type const & i) const {
    return bits_.operator[](i.i_);
  }

  bit_vector::reference operator[] ( const std::string s) {
    size_t index = this->index(s);
    return bits_.operator[](index);
  }

  bit_vector::reference operator[] ( index_type const & i ) {
    return bits_.operator[](i.i_);
  }


  strbitset & set( bool val = true) {
    for ( bit_vector::iterator ibegin = bits_.begin(),
        iend = bits_.end(), i = ibegin;
      i != iend; ++i ) {
      *i = val;
    }
    return *this;
  }

  strbitset & flip() {
    for ( bit_vector::iterator ibegin = bits_.begin(),
        iend = bits_.end(), i = ibegin;
      i != iend; ++i ) {
      *i = ! (*i);
    }
    return *this;
  }

  strbitset & set( std::string s, bool val = true) {
    (*this)[s] = val;
    return *this;
  }

  strbitset & set( index_type const & i, bool val = true) {
    (*this)[i] = val;
    return *this;
  }


  strbitset & flip( std::string s) {
    (*this)[s] = !( (*this)[s] );
    return *this;
  }

  strbitset & flip( index_type const & i ) {
    (*this)[i] = !( (*this)[i] );
    return *this;
  }

  strbitset operator~() {
    strbitset ret(*this);
    for ( bit_vector::iterator ibegin = ret.bits_.begin(),
        iend = ret.bits_.end(), i = ibegin;
      i != iend; ++i ) {
      *i = !(*i);
    }
    return ret;
  }

  strbitset & operator&=( const strbitset & r) {
    if ( map_.size() != r.map_.size() ) { 
      std::cout << "strbitset operator&= : bitsets not the same size" << std::endl;
    } else {
      str_index_map::iterator ibegin = map_.begin(), iend = map_.end(), i = ibegin;
      for ( ; i != iend; ++i ) {
    std::string key = i->first;
    str_index_map::const_iterator j = r.map_.find( key );
    if ( j == r.map_.end() ) {
      std::cout << "strbitset operator&= : cannot find key " << key << std::endl;
    } else {
      (*this)[key] = (*this)[key] && r[key];
    }
      }
    }
    return *this;
  }


  strbitset & operator|=( const strbitset & r) {
    if ( map_.size() != r.map_.size() ) { 
      std::cout << "strbitset operator&= : bitsets not the same size" << std::endl;
    } else {
      str_index_map::iterator ibegin = map_.begin(), iend = map_.end(), i = ibegin;
      for ( ; i != iend; ++i ) {
    std::string key = i->first;
    str_index_map::const_iterator j = r.map_.find( key );
    if ( j == r.map_.end() ) {
      std::cout << "strbitset operator&= : cannot find key " << key << std::endl;
    } else {
      (*this)[key] = (*this)[key] || r[key];
    }
      }
    }
    return *this;
  }



  strbitset & operator^=( const strbitset & r) {
    if ( map_.size() != r.map_.size() ) { 
      std::cout << "strbitset operator&= : bitsets not the same size" << std::endl;
    } else {
      str_index_map::iterator ibegin = map_.begin(), iend = map_.end(), i = ibegin;
      for ( ; i != iend; ++i ) {
    std::string key = i->first;
    str_index_map::const_iterator j = r.map_.find( key );
    if ( j == r.map_.end() ) {
      std::cout << "strbitset operator&= : cannot find key " << key << std::endl;
    } else {
      (*this)[key] = ( (*this)[key] || r[key]) && ! ((*this)[key] && r[key]);
    }
      }
    }
    return *this;
  }





  bool operator==( const strbitset & r) const {
    if ( map_.size() != r.map_.size() ) { 
      std::cout << "strbitset operator&= : bitsets not the same size" << std::endl;
    } else {
      str_index_map::const_iterator ibegin = map_.begin(), iend = map_.end(), i = ibegin;
      for ( ; i != iend; ++i ) {
    std::string key = i->first;
    str_index_map::const_iterator j = r.map_.find( key );
    if ( j == r.map_.end() ) {
      std::cout << "strbitset operator&= : cannot find key " << key << std::endl;
    } else {
      if ( (*this)[key] != r[key] ) return false;
    }
      }
    }
    return true;
  }

  bool operator==( bool b ) const {
    bool result = true;
    for ( bit_vector::const_iterator iBegin = bits_.begin(),
        iEnd = bits_.end(), ibit = iBegin;
      ibit != iEnd; ++ibit ) {
      result &= ( *ibit == b );
    }
    return result;
  }


  bool operator!=( const strbitset & r) const {
    return ! (operator==(r));
  }

  bool operator!=( bool b ) const {
    return ! ( operator==(b));
  }

  size_t count() const {
    size_t ret = 0;
    for ( bit_vector::const_iterator ibegin = bits_.begin(),
        iend = bits_.end(), i = ibegin;
      i != iend; ++i ) {
      if ( *i ) ++ret;
    }    
    return ret;
  }



  size_t any() const {
    for ( bit_vector::const_iterator ibegin = bits_.begin(),
        iend = bits_.end(), i = ibegin;
      i != iend; ++i ) {
      if ( *i ) return true;
    }
    return true;
  }

  size_t none () const {
    return !any();
  }

  bool test(std::string s) const {
    return (*this)[s] == true;
  }

  bool test(index_type const &i) const {
    return (*this)[i] == true;
  }

  const bit_vector& bits() const {
    return bits_;
  }


  const std::vector<std::string> strings() const {
    std::vector<std::string> strings;
    strings.resize(bits_.size());
    for (str_index_map::const_iterator it = map_.begin(), 
         end = map_.end(); it != end; ++it){
      strings[it->second] = it->first;
    }
    return strings;
  }



  friend strbitset operator&(const strbitset& l, const strbitset& r);
  friend strbitset operator|(const strbitset& l, const strbitset& r);
  friend strbitset operator^(const strbitset& l, const strbitset& r);


 private:


  size_t  index(std::string s) const {
    str_index_map::const_iterator f = map_.find(s);
    if ( f == map_.end() ) {
      std::cout << "Cannot find " << s << ", returning size()" << std::endl;
      return map_.size();
    } else {
      return f->second;
    }
  }
  
  std::string const & index( size_t i ) const {
    for ( str_index_map::const_iterator f = map_.begin(),
        fEnd = map_.end();
      f != fEnd; ++f ) {
      if ( f->second == i ) return f->first;
    }
    std::cout << "Cannot find " << i << ", returning dummy" << std::endl;
    return dummy_;

  }

  static const std::string       dummy_;
  str_index_map     map_;   
  bit_vector        bits_;  
};

 strbitset operator&(const strbitset& l, const strbitset& r);

 strbitset operator|(const strbitset& l, const strbitset& r);
 strbitset operator^(const strbitset& l, const strbitset& r);



}

#endif