matchstring.h

Go to the documentation of this file.

/**********************************************************//**
 **
 ** @file util/matchstring.h
 **
 ** Copyright (C) 2012  Xpace, LLC.  All rights reserved
 **
 ** www.xpace.net
 **
 **************************************************************/

#ifndef XPACE_MATCHSTRING_H
#define XPACE_MATCHSTRING_H

#include <unordered_map>

namespace Xpace
{
  template <typename FUNCTION>
  struct IntWrapper
  {
    IntWrapper
      (FUNCTION* f) : f(f)
    {
    }

    bool operator()
      (int64 n)
    {
      return (*f)(n);
    }

    FUNCTION* f;
  };

  template <typename STR>
  class MatchString
  {
  public:
    typedef typename STR::charType CH;

    //typedef std::function<bool(CH*, size_t)> string_func;
    typedef std::function<bool(int64)> intFunc;

    MatchString
      (const String& fmt);

    const STR& getNativeFormat
      ()
      const
    {
      return format;
    }

    const String& getStringFormat
      ()
      const
    {
      return string_format;
    }

    bool add
      (const CH ch,
       intFunc fn);

    bool match
      (const STR str)
      const;
    
  private:
    const String string_format;

    struct fchar
    {
      fchar
        (CH c);
      CH ch;
      bool isDelim;
    };
    std::vector<fchar> format;
 
    std::unordered_map<CH, intFunc> int_funcs;

    static
    int64 to_int64
      (const CH* b,
       CH* e);
  };

  // ==========================================================
  // ==========================================================
  // ==========================================================

  template<>
  inline
  MatchString<String8>::MatchString
    (const String& fmt) :
      string_format(fmt)
  {
    auto fv(fmt.toUtf8());
    for (auto f(fv.begin()); f != fv.end(); ++f)
      format.push_back(*f);
    format.push_back(0);
  }
    
  template<>
  inline
  MatchString<String16>::MatchString
    (const String& fmt) :
     string_format(fmt)
  {
    #ifndef NDEBUG
    QString qfmt(fmt);
    #endif

    auto f(fmt.toUtf16());
    do
      format.push_back(*f);
    while (*f++);
  }

  template <typename STR>
  inline
  bool MatchString<STR>::add
    (const CH ch,
      intFunc fn)
  {
    bool found(false);
    for (auto f(format.begin()); f != format.end(); ++f)
        if (f->ch == ch)
        {
          f->isDelim = false;
          found = true;
        }
      
      return (found) ? (int_funcs[ch] = fn, true) : false;
  }

  template <typename STR>
  inline
  bool MatchString<STR>::match
    (const STR str)
    const
  {
    auto f(format.begin());
    auto s(str.data);
    auto scur(s);
    auto send(str.data + str.length);

    CH sub(0);

    while (f->ch)
    {
      while (!f->isDelim)
        sub = f++->ch;
      while ((*scur != f->ch) && (scur != send))
        ++scur;
      if (sub)
      {     
        if (!int_funcs.find(sub)->second(to_int64(s, scur)))
          return false;
        if (f->ch)
          ++f;
        s = ++scur;
        sub = 0;
      }
      else if (f->isDelim)
      {
        if (f->ch == *s)
        { 
          ++f;
          ++s;
          ++scur;
        }
        else // no match - quit
          return true;
      }
    }
    return true;
  }    

  template <typename STR>
  inline
  MatchString<STR>::fchar::fchar
    (CH c) :
      ch(c),
      isDelim(true)
  {
  }

  template<>
  inline
  int64 MatchString<String8>::to_int64
    (const CH* b,
     CH* e)
  {        
    return
      #ifdef _WIN32
      _strtoi64
      #else
      strtoll
      #endif
        (reinterpret_cast<const char*>(b), reinterpret_cast<char**>(&e), 10);
  }     

  template<>
  inline
  int64 MatchString<String16>::to_int64
    (const CH* b,
     CH* e)
  {      
    return
      #ifdef _WIN32
      _wcstoi64
      #else
      wcstoll
      #endif
        (reinterpret_cast<const wchar_t*>(b), reinterpret_cast<wchar_t**>(&e), 10);
  }  
}

#endif