node_exclusion_filter.h

#ifndef NODE_EXCLUSION_FILTER_H_
#define NODE_EXCLUSION_FILTER_H_

#include <string>
#include <set>
#include <vector>
#include <iterator>

#include "graph_filter.h"


template<typename GraphType>
class NodeExclusionFilter : public GraphFilter<GraphType> {
  public:
    typedef typename GraphType::node_value_type V_type;
    typedef typename GraphType::edge_value_type E_type;
    typedef typename GraphType::index_type_t index_type_t;
    typedef typename GraphType::comparator V_CompareFunctor;
    typedef typename std::set<V_type, V_CompareFunctor> ExcludedNodeSet;
    typedef typename ExcludedNodeSet::iterator iterator;
    typedef typename ExcludedNodeSet::const_iterator const_iterator;

    NodeExclusionFilter(std::string filter_name = "node_exclusion_filter") :
                        GraphFilter<GraphType>(filter_name, "node_exclusion_filter", false, true, true, false)  {
    }

    NodeExclusionFilter(std::set<V_type, V_CompareFunctor>& nodes, std::string filter_name = "node_exclusion_filter") : 
                        GraphFilter<GraphType>(filter_name, "node_exclusion_filter", false, true, true, false), excluded_nodes_(nodes)  { 
    }

    virtual GraphFilter<GraphType>* clone() {
      NodeExclusionFilter<GraphType>* clone = new NodeExclusionFilter<GraphType>(*this);
      return clone;
    }

    void add_exclusion(V_type excluded) {
      excluded_nodes_.insert(excluded);
    }

    ExcludedNodeSet& excluded_nodes(){
      return excluded_nodes_;
    }

    iterator begin() { return excluded_nodes_.begin(); }

    iterator end() { return excluded_nodes_.end(); }

    void remove_exclusion(V_type excluded) {
      excluded_nodes_.erase(excluded);
    }

    void clear_filter() {
      excluded_nodes_.clear();
    }

   virtual bool operator() (E_type edge) {
      return !(this->inverted_);
   }

  virtual bool operator() (V_type m) {
    if(this->enabled_) {
      typename ExcludedNodeSet::iterator res = excluded_nodes_.find(m);
      if(res != excluded_nodes_.end() && !this->inverted_) {
        return false;
      } else if(res == excluded_nodes_.end() && this->inverted_) {
        return false;
      }
    }
    return true;
  }

  template<typename P1, typename P2>
  bool operator() (std::pair<P1, P2>& m) {
    return  operator()(m.second);
  }

  private:
    ExcludedNodeSet excluded_nodes_;
};

#endif