dependency_degree_filter.h

#ifndef DEPENDENCY_DEGREE_FILTER_H_
#define DEPENDENCY_DEGREE_FILTER_H_

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

template<typename GraphType>
class DependencyDegreeFilter : 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;

  DependencyDegreeFilter(std::string filter_name,
                         int min_degree,
                         int max_degree,
                         bool dependents = true,
                         bool dependencies = true) :
                         GraphFilter<GraphType>(filter_name, "dependency_degree", false, true, true, false)  {
        min_degree_ = min_degree;
        max_degree_ = max_degree;
        dependents_ = dependents;
        dependencies_ = dependencies;
  }

  DependencyDegreeFilter(int min_degree,
                         int max_degree,
                         bool dependents = true,
                         bool dependencies = true) :
                         GraphFilter<GraphType>("", "dependency_degree", false, true, true, false)  {
        min_degree_ = min_degree;
        max_degree_ = max_degree;
        dependents_ = dependents;
        dependencies_ = dependencies;
  }

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

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

  virtual bool operator() (V_type m) {
    if(this->enabled_) {
      bool include = false;

      unsigned int degree =  0;
      if(dependencies_)
        degree += m->dependencies()->size();
      if(dependents_)
        degree += m->dependents()->size();

      // if the degree falls in the range include it
      if(min_degree_ < 0 || degree >= static_cast<unsigned int>(min_degree_)) {
        if(max_degree_ < 0 || degree <= static_cast<unsigned int>(max_degree_)) {
          include = true;
        }
      }

      if(!include && !this->inverted_)
        return false;
      if(include && this->inverted_)
        return false;
    }
    return true;
  }

  void set_dependents(bool dependents) {
    dependents_ = dependents;
  }

  void set_dependencies(bool dependencies) {
    dependencies_ = dependencies;
  }

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

  int min_degree() {
    return min_degree_;
  }

  int max_degree() {
    return max_degree_;
  }

  bool dependents() {
    return dependents_;
  }

  bool dependencies() {
    return dependencies_;
  }

private:
  int min_degree_;
  int max_degree_;
  bool dependents_;
  bool dependencies_;
};

#endif