diff_filter.h

#ifndef DIFF_FILTER_H
#define DIFF_FILTER_H

#include "graph_filter.h"
#include "linkler_diff.h"
#include <iostream>
#include <string>

template<typename GraphType>
class DiffFilter : public GraphFilter<GraphType> {
  public:
    typedef typename GraphType::node_value_type V_type;
    typedef typename GraphType::edge_value_type E_type;

    enum filter_type { ADDED, REMOVED, UNCHANGED };

    DiffFilter(std::string filter_name,
               LinklerDiff* ld,
               filter_type ft)
               : GraphFilter<GraphType>(filter_name, "diff") {
      linkler_diff_ = ld;
      f_type_ = ft;
    }

    DiffFilter(std::string filter_name,
               filter_type ft)
               : GraphFilter<GraphType>(filter_name,"diff") {
      linkler_diff_ = NULL;
      f_type_ = ft;
    }

    void set_LinklerDiff(LinklerDiff* ld) {
      linkler_diff_ = ld;
    }

    void set_filter_type(filter_type ft) {
      f_type_ = ft;
    }

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

    virtual bool operator() (E_type e) {
      return check(e);
    }

    virtual bool operator() (V_type v) {
      return check(v);
    }

    virtual bool enabled() const {
      if(linkler_diff_ == NULL) 
        return false;
      return this->enabled_;
    }

    template<typename P1, typename P2>
    bool operator() (std::pair<P1, P2>& m) {
        return  operator()(m.second);
    }
    std::string type(){
      switch(f_type_){
        case ADDED: return "ADDED";
        case REMOVED: return "REMOVED";
        case UNCHANGED: return "UNCHANGED";
        default: return "";
      }
    }

  private:
    LinklerDiff* linkler_diff_;
    filter_type f_type_;

    template<typename T> bool check(T e) {
      if(this->enabled_) {
        if (linkler_diff_ == NULL) {
          // If no linkler diff has been set the filter should not do
          // anything.
          // This case is as if the filter is not enabled.
          return true;
        }

        switch (f_type_) {
          case ADDED:
            if (!linkler_diff_->added(e) && !this->inverted_) {
              return false;
            } else if(linkler_diff_->added(e) && this->inverted_) {
              return false;
            }
            break;
          case REMOVED:
            if (!linkler_diff_->removed(e) && !this->inverted_) {
              return false;
            } else if(linkler_diff_->removed(e) && this->inverted_) {
              return false;
            }
            break;
          case UNCHANGED:
          default:
            if((linkler_diff_->added(e) || linkler_diff_->removed(e)) && !this->inverted_) {
              return false;
            } else if(!linkler_diff_->added(e) && !linkler_diff_->removed(e) && this->inverted_) {
              return false;
            }
        }
      }
      return true;
    }


};

#endif