ndn-regex-matcher-base.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_NDN_REGEX_MATCHER_BASE_HPP
#define NDN_NDN_REGEX_MATCHER_BASE_HPP

// Depending if ndn-cpp-config.h defines NDN_CPP_HAVE_BOOST_REGEX or sets
//   NDN_CPP_HAVE_STD_REGEX = 1, define the regex_lib namespace alias.
// Set NDN_CPP_HAVE_REGEX_LIB = 1 if regex_lib is defined.

#include <ndn-cpp/ndn-cpp-config.h>
#if NDN_CPP_HAVE_STD_REGEX
  #include <regex>
  namespace ndn { namespace regex_lib = std; }
  #define NDN_CPP_HAVE_REGEX_LIB 1

  // Only Boost needs the correction.
  static const size_t NDN_REGEXP_MARK_COUNT_CORRECTION = 0;
#elif defined(NDN_CPP_HAVE_BOOST_REGEX)
  #include <boost/regex.hpp>
  #include <boost/version.hpp>
  namespace ndn { namespace regex_lib = boost; }
  #define NDN_CPP_HAVE_REGEX_LIB 1

  // Re: http://www.boost.org/users/history/version_1_56_0.html
  // Correct the behavior of basic_regex<>::mark_count() to match existing
  // documentation, basic_regex<>::subexpression(n) changed to match, see
  // https://svn.boost.org/trac/boost/ticket/9227
  static const size_t NDN_REGEXP_MARK_COUNT_CORRECTION =
  #if BOOST_VERSION < 105600
    1;
  #else
    0;
  #endif
#else
  #define NDN_CPP_HAVE_REGEX_LIB 0
#endif

// Only compile if we set NDN_CPP_HAVE_REGEX_LIB.
#if NDN_CPP_HAVE_REGEX_LIB

#include <string>
#include <ndn-cpp/name.hpp>

namespace ndn {

class NdnRegexBackrefManager;

class NdnRegexMatcherBase {
public:
  class Error : public std::exception {
  public:
    Error(const std::string& errorMessage) throw();

    virtual ~Error() throw();

    std::string
    Msg() const { return errorMessage_; }

    virtual const char*
    what() const throw();

  private:
    const std::string errorMessage_;
  };

  enum NdnRegexExprType {
    NDN_REGEX_EXPR_TOP,
    NDN_REGEX_EXPR_PATTERN_LIST,
    NDN_REGEX_EXPR_REPEAT_PATTERN,
    NDN_REGEX_EXPR_BACKREF,
    NDN_REGEX_EXPR_COMPONENT_SET,
    NDN_REGEX_EXPR_COMPONENT,
    NDN_REGEX_EXPR_PSEUDO
  };

  NdnRegexMatcherBase
    (const std::string& expr, const NdnRegexExprType& type,
     ptr_lib::shared_ptr<NdnRegexBackrefManager> backrefManager =
       ptr_lib::shared_ptr<NdnRegexBackrefManager>());

  virtual
  ~NdnRegexMatcherBase();

  virtual bool
  match(const Name& name, size_t offset, size_t len);

  const std::vector<Name::Component>&
  getMatchResult() const { return matchResult_; }

  const std::string&
  getExpr() const { return expr_; }

protected:
  virtual void
  compile() = 0;

private:
  bool
  recursiveMatch(size_t matcherNo, const Name& name, size_t offset, size_t len);

protected:
  const std::string expr_;
  const NdnRegexExprType type_;
  ptr_lib::shared_ptr<NdnRegexBackrefManager> backrefManager_;
  std::vector<ptr_lib::shared_ptr<NdnRegexMatcherBase> > matchers_;
  std::vector<Name::Component> matchResult_;
};

inline std::ostream&
operator<<(std::ostream& os, const NdnRegexMatcherBase& regex)
{
  os << regex.getExpr();
  return os;
}

}

#endif // NDN_CPP_HAVE_REGEX_LIB

#endif