fastmatch Class Reference

#include <DQMStore.h>

Public Member Functions
	fastmatch (std::string const &_fastString)
bool	match (std::string const &s) const
	~fastmatch ()

Private Types
enum	MatchingHeuristicEnum { UseFull, OneStarStart, OneStarEnd, TwoStar }

Private Member Functions
bool	compare_strings (std::string const &pattern, std::string const &input) const
bool	compare_strings_reverse (std::string const &pattern, std::string const &input) const

Private Attributes
std::string	fastString_
MatchingHeuristicEnum	matching_
lat::Regexp *	regexp_

Detailed Description

Implements RegEx patterns which occur often in a high-performant mattern. For all other expressions, the full RegEx engine is used. Note: this class can only be used for lat::Regexp::Wildcard-like patterns.

Definition at line 51 of file DQMStore.h.

Member Enumeration Documentation

enum fastmatch::MatchingHeuristicEnum

private

Enumerator
UseFull
OneStarStart
OneStarEnd
TwoStar

Definition at line 54 of file DQMStore.h.

{ UseFull, OneStarStart, OneStarEnd, TwoStar };

Constructor & Destructor Documentation

fastmatch::fastmatch

(

std::string const &

_fastString

)

Definition at line 129 of file DQMStore.cc.

References alignCSCRings::e, fastString_, matching_, NULL, OneStarEnd, OneStarStart, raiseDQMError(), regexp_, and TwoStar.

                                                  :
  fastString_ (_fastString),  matching_ (UseFull)
{
  try
  {
    regexp_ = NULL;
    regexp_ = new lat::Regexp(fastString_, 0, lat::Regexp::Wildcard);
    regexp_->study();
  }
  catch (lat::Error &e)
  {
    delete regexp_;
    raiseDQMError("DQMStore", "Invalid wildcard pattern '%s' in quality"
                  " test specification", fastString_.c_str());
  }

  // count stars ( "*" )
  size_t starCount = 0;
  int pos = -1;
  while (true)
  {
    pos = fastString_.find("*", pos + 1 );
    if ((size_t)pos == std::string::npos)
      break;
    starCount ++;
  }

  // investigate for heuristics
  if ((fastString_.find('"') != std::string::npos)  ||
      (fastString_.find(']') != std::string::npos)  ||
      (fastString_.find('?') != std::string::npos)  ||
      (fastString_.find('\\') != std::string::npos) ||
      (starCount > 2))
  {
    // no fast version can be used
    return;
  }

  // match for pattern "*MyString" and "MyString*"
  if (starCount == 1)
  {
    if (boost::algorithm::starts_with(fastString_, "*"))
    {
      matching_ = OneStarStart;
      fastString_.erase(0,1);
      return;
    }

    if (boost::algorithm::ends_with(fastString_, "*"))
    {
      matching_ = OneStarEnd;
      fastString_.erase(fastString_.length()-1,1);
      return;
    }
  }

  // match for pattern "*MyString*"
  if (starCount == 2)
  {
    if (boost::algorithm::starts_with(fastString_, "*") &&
        boost::algorithm::ends_with(fastString_, "*"))
    {
      matching_ = TwoStar;
      fastString_.erase(0,1);
      fastString_.erase(fastString_.size() - 1, 1);
      return;
    }
  }
}

fastmatch::~fastmatch

(

)

Definition at line 199 of file DQMStore.cc.

References NULL, and regexp_.

{
  if (regexp_ != NULL)
    delete regexp_;
}

Member Function Documentation

bool fastmatch::compare_strings ( std::string const &  pattern, std::string const &  input  ) const

private

Definition at line 226 of file DQMStore.cc.

Referenced by match().

{
  if (input.size() < pattern.size())
    return false;

  // compare the two strings character by character for equalness:
  // this does not create uneeded copies of std::string. The
  // boost::algorithm implementation does.
  std::string::const_iterator rit_pattern = pattern.begin();
  std::string::const_iterator rit_input = input.begin();

  for (; rit_pattern < pattern.end(); rit_pattern++, rit_input++)
  {
    if (*rit_pattern != *rit_input)
      // found a difference, fail
      return false;
  }
  return true;
}

bool fastmatch::compare_strings_reverse ( std::string const &  pattern, std::string const &  input  ) const

private

Definition at line 205 of file DQMStore.cc.

Referenced by match().

{
  if (input.size() < pattern.size())
    return false;

  // compare the two strings character by character for equalness:
  // this does not create uneeded copies of std::string. The
  // boost::algorithm implementation does
  std::string::const_reverse_iterator rit_pattern = pattern.rbegin();
  std::string::const_reverse_iterator rit_input = input.rbegin();

  for (; rit_pattern < pattern.rend(); rit_pattern++, rit_input++)
  {
    if (*rit_pattern != *rit_input)
      // found a difference, fail
      return false;
  }
  return true;
}

bool fastmatch::match

(

std::string const &

s

)

const

Definition at line 247 of file DQMStore.cc.

References compare_strings(), compare_strings_reverse(), fastString_, matching_, OneStarEnd, OneStarStart, regexp_, and TwoStar.

{
  switch (matching_)
  {
  case OneStarStart:
    return compare_strings_reverse(fastString_, s);

  case OneStarEnd:
    return compare_strings(fastString_, s);

  case TwoStar:
    return (s.find(fastString_) != std::string::npos);

  default:
    return regexp_->match(s);
  }
}

Member Data Documentation

std::string fastmatch::fastString_

private

Definition at line 71 of file DQMStore.h.

Referenced by fastmatch(), and match().

MatchingHeuristicEnum fastmatch::matching_

private

Definition at line 72 of file DQMStore.h.

Referenced by fastmatch(), and match().

lat::Regexp* fastmatch::regexp_

private

Definition at line 70 of file DQMStore.h.

Referenced by fastmatch(), match(), and ~fastmatch().