run_block_filter.h

#ifndef RUN_BLOCK_FILTER_H_
#define RUN_BLOCK_FILTER_H_

#include <string>
#include <vector>

#include "graph_filter.h"


template<typename GraphType>
class RunBlockFilter : public GraphFilter<GraphType> {
  public:
    typedef typename GraphType::node_value_type V_type;
    typedef typename GraphType::edge_value_type E_type;
    
    RunBlockFilter(std::string filter_name,
                   std::string executable_name,
                   Linkler* l) :
                    GraphFilter<GraphType>(filter_name, "run_block", false, true, true, false) {          
      executable_name_ = executable_name;
      set_linkler(l);
    }

    void set_linkler(Linkler* l) {
      l_ = l;
      swu_names_.clear();
      valid_executable_ = false;

      if(l_ != NULL) {
        SWUSet* swus = l_->get_full_swuset(executable_name_);
        if(swus != NULL) {
          valid_executable_ = true;
          SWUSet::iterator it = swus->begin();
          for(; it != swus->end(); ++it) {
            swu_names_.push_back((*it)->name());
          }
        }
      }
    }
    
    virtual GraphFilter<GraphType>* clone() {
      RunBlockFilter<GraphType>* clone = new RunBlockFilter<GraphType>(*this);
      return clone;
    }
    
    virtual bool operator() (E_type edge) {
      return !this->inverted_;
    }
  
    virtual bool enabled() const {
      if(!valid_executable_)
        return false;
      return this->enabled_;
    }

    virtual bool operator() (V_type swu) {
      if(this->enabled_ && valid_executable_) {
        // Search whether or not the SWU exists in the list of SWU names
        std::vector<std::string>::iterator res = std::find(swu_names_.begin(), swu_names_.end(), swu->name());
        // If it is in the list return
        if(res == swu_names_.end() && !this->inverted_) {
          return false;
        } else if(res != swu_names_.end() && this->inverted_) {
          return false;
        }
      }
      return true;
    }
 
    template<typename P1, typename P2>
    bool operator() (std::pair<P1, P2>& m) {
        return  operator()(m.second);
    }

    std::string executable_name() {
      return executable_name_;
    }

    std::vector<std::string>& swu_names() {
      return swu_names_;
    }
  private:
    std::string executable_name_;
    std::vector<std::string> swu_names_;
    bool valid_executable_;
    Linkler* l_;
};
#endif