regex_filter.h

#ifndef REGEX_FILTER_H_
#define REGEX_FILTER_H_

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

template<typename GraphType>
class RegexFilter : public GraphFilter<GraphType> {
  private:
    std::string regex_pattern_;

  public:
    typedef typename GraphType::node_value_type V_type;
    typedef typename GraphType::edge_value_type E_type;

    RegexFilter( std::string pattern ) :
                  GraphFilter<GraphType>("", "regex", false, true, true, false)  {
      regex_pattern_ = pattern;
    }

    RegexFilter( std::string filter_name, std::string pattern ) :
                  GraphFilter<GraphType>(filter_name, "regex", false, true, true, false)  {
      regex_pattern_ = pattern;
    }

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

    virtual bool operator() (E_type edge) {
      return !this->inverted_;
    }
   
    virtual bool operator() (V_type m) {
      if(this->enabled_){
        int status;
        regex_t re;
      
        // Regex compile    
        // Sets pattern as empty string if failed to compile.
        if(regcomp(&re, regex_pattern_.c_str(), REG_EXTENDED) != 0) {
            regcomp(&re,"", REG_EXTENDED);
        }

        // Status, 0 if match, 1 if not matched
        status = regexec(&re, m->name().c_str(), 0, 0, 0);
        regfree(&re); // free mem alocation made by regex compile

        if (status != 0 && !this->inverted_) { // If no match with pattern
                    return false;
        } else if(status == 0 && this->inverted_) {  // If match
                    return false;
        }
      }
      return true;
    }

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

    std::string pattern() {
      return regex_pattern_;
    }
};

#endif