graph_filter.h

#ifndef GRAPH_FILTER_H_
#define GRAPH_FILTER_H_

#include <string>
#include <cstddef>
#include <typeinfo>
#include <iostream>

template<typename GraphType>
class GraphFilter {
  public:
    typedef typename GraphType::node_value_type V_type;
    typedef typename GraphType::edge_value_type E_type;
  
    GraphFilter()  {
      name_ = "";
      type_ = "";
      enabled_ = true;
      inverted_ = false;
      nodes_ = true;
      edges_ = true;
    }

    //  @param nodes Whether the filter operates on nodes
    //  @param nodes Whether the filter operates on edges 
    GraphFilter(std::string filter_name = "", 
                std::string filter_type = "", 
                bool inverted = false, 
                bool enabled = true,
                bool nodes = true,
                bool edges = true) {
      name_ = filter_name;
      type_ = filter_type;
      inverted_ = inverted;
      enabled_ = enabled;
      nodes_ = nodes;
      edges_ = edges;
     }

    virtual ~GraphFilter() {
    }

    void set_inverted(bool status) {
      inverted_ = status;
    }

    void set_enabled(bool enabled) {
      enabled_ = enabled;
    }

    std::string name() const { return name_; }

    std::string type() const { return type_; }

    bool inverted() const { return inverted_; }

    virtual bool enabled() const { return enabled_; }

    virtual bool nodes() const { return nodes_; }

    virtual bool edges() const { return edges_; }

    virtual GraphFilter<GraphType>* clone() = 0;
      
    virtual bool operator() ( V_type m) = 0;

    virtual bool operator() (E_type e) = 0;

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

  private:
    std::string name_;
    std::string type_;

  protected:
    bool inverted_;
    bool enabled_;
    bool nodes_;
    bool edges_;
};


#endif