translate_string_node.h

Go to the documentation of this file.

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

#ifndef XPACE_TRANSLATE_STRING_NODE_H
#define XPACE_TRANSLATE_STRING_NODE_H

#include <iterator>

#include <QtCore/qstring.h>

#include "data/data.h"
#include "base/config.h"
#include "base/integer.h"
#include "base/datetime.h"
#include "util/matchstring.h"

#if _WIN32 || _WIN64
# pragma warning(push)
# pragma warning(disable : 4355)
#endif

namespace Xpace
{
  // ================================ TRANSLATIONS ============

  /// Called on translation error 
  /// @param ch the offending character
  /// @param term the offending term
  /// @return true to accept the term as far as possible, false to skip it
  typedef std::function<bool(utf16_t ch, const String& term)> TranslationError;

  /// Default error handler
  inline
  bool default_on_error
    (utf16_t, 
     const String&)
  {
    return true;
  }

  struct TranslateNames
  {
    static const char *VECTOR_TAG, *SUBTYPE_TAG, *COUNT_TAG;
    static const char *FORMAT_TAG, *LENGTH_TAG, *PRECISION_TAG, *RADIX_TAG, *SIZE_TAG;
    static const char *NUMERAL_TAG;
    static const char *DELIMS_TAG;
  };

  /// Translate content 
  /// Input can be anything
  /// Output is to a Sink<LOC> so must be one of its supported types
  template <typename LOC>
  class TranslateNode
  {
  public: 
    virtual ~TranslateNode
      () 
    {
    }

    // the output type of this translator
    const BaseDataType& getType
      ()
      const
    {
      return type;
    }

    class unknownType : public Exception
    {
    public:
      unknownType
        (String type) :
          Exception("Unknown type \"%1\".")
      {
        addParam(type);
      }
    };

  protected:
    TranslateNode
      (const BaseDataType& t,
       Sink<LOC>* s,
       TranslationError onErr = default_on_error) :
        type(t),
        sink(s)
    {
    }

    TranslationError onError;

  private:
    const BaseDataType type;

  protected:
    Sink<LOC>* sink;
    LOC loc;
  };

  // ================================ FROM STRING =============

  template<typename LOC, typename STR>
  class TranslateString : public TranslateNode<LOC>
  {
  public:
    static
    TranslateString* create
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError = default_on_error);

    virtual bool operator()
      (const STR) 
    = 0;

  protected:
    TranslateString
      (BaseDataType t,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslateNode<LOC>(t, sink, onError)
    {
    }
  };

  template<typename LOC, typename STR>
  class SkipStringNode : public TranslateString<LOC, STR>
  {
  public:
    SkipStringNode
      () :
        TranslateString<LOC, STR>(BaseDataType::btNone, 0, default_on_error)
    {
    }

    virtual bool operator()
      (const STR) override
    {
      return true;
    }
  };

  // ================================ STRING ==================

  template<typename LOC, typename STR>
  class TranslateStringString : public TranslateString<LOC, STR>
  {
  public:
    TranslateStringString
      (const String& name,
       Sink<LOC>* s,
       TranslationError onError = default_on_error) :
        TranslateString<LOC, STR>(BaseDataType::stringType<STR>().getBaseType(), s, onError)
    {
      this->loc = this->sink->add(name, BaseDataType::stringType<STR>().getBaseType(), ~0);
    }

    TranslateStringString
      (const Configuration& config,     
       Sink<LOC>* sink,
       TranslationError onError = default_on_error) :
        TranslateString<LOC, STR>(BaseDataType::stringType<STR>().getBaseType(), sink, onError)
    {
      this->loc = sink->add(config, ~0);
    }

    bool operator()
      (const STR val) override
    {
      return this->sink->set(this->loc, val);
    }
  };

  // ================================ INTEGER =================

  template<typename LOC, typename STR>
  class TranslateStringUint : public TranslateString<LOC, STR>
  {
  public:
    TranslateStringUint
      (uint size,
       uint radix,
       Sink<LOC>* s,
       TranslationError onErr = default_on_error) :
        TranslateString<LOC, STR>(BaseDataType::btUint, size, s, onErr),
        radix(radix)
    {
      this->loc = this->sink->add(this->name, BaseDataType::btUint, ~0);
    }

    TranslateStringUint
      (const Configuration& config,
       Sink<LOC>* s,
       TranslationError onErr) :
       TranslateString<LOC, STR>(BaseDataType(BaseDataType::btUint, size_t(config.getValueInt(TranslateNames::SIZE_TAG, 8))), s, onErr),
       radix(uint(config.getValueInt(TranslateNames::RADIX_TAG, 10)))
    {
      this->loc = this->sink->add(config, ~0);
    }

    bool operator()
      (const STR val) override
    {
      if (!stringToUint(val, radix, &buf))
        return true;

      return (buf.size() <= 1) 
        ? this->sink->set(this->loc, buf[0]) 
        : this->sink->set(this->loc, BytesRef(reinterpret_cast<byte*>(&buf[0]), sizeof(buf[0]) * buf.size()));
    }

  private:
    const uint radix;
    std::vector<uint64> buf;
  };

  template<typename LOC, typename STR>
  class TranslateStringInt : public TranslateString<LOC, STR>
  {
  public:
    TranslateStringInt
      (uint size,
       uint radix,
       Sink<LOC>* s,       
       TranslationError onErr = default_on_error) :
        TranslateString<LOC, STR>(BaseDataType(BaseDataType::btInt, size), s, onErr),
        radix(radix)
    {
      this->loc = this->sink->add(this->name, BaseDataType::btInt, ~0);
    }

    TranslateStringInt
      (const Configuration& config,
       Sink<LOC>* s,
       TranslationError onErr) :
        TranslateString<LOC, STR>(BaseDataType(BaseDataType::btInt, size_t(config.getValueInt(TranslateNames::SIZE_TAG, 8))), s, onErr),
        radix(uint(config.getValueInt(TranslateNames::RADIX_TAG, 10)))
    {
      this->loc = this->sink->add(config, ~0);
    }

    virtual bool operator()
      (const STR val) override
    {
      if (!stringToInt(val, radix, &buf))
        return true;

      return (buf.size() <= 1) 
        ? this->sink->set(this->loc, int64(buf[0])) 
        : this->sink->set(this->loc, BytesRef(reinterpret_cast<byte*>(&buf[0]), sizeof(buf[0]) * buf.size()));
    }

  private:
    const uint radix;
    std::vector<uint64> buf;
  };

   #ifdef XPACE_DECIMAL_FLOAT_H
  // ================================ FLOAT ===================

  template<typename LOC, typename STR>
  class TranslateStringFloat : public TranslateString<LOC, STR>
  {
  public:
    TranslateStringFloat
      (const Configuration& config,
       Sink<LOC>* s,       
       TranslationError onErr) :
        TranslateString<LOC, STR>(BaseDataType(BaseDataType::btFloat), s, onErr),
        precision(uint(config.getValueInt(PRECISION_TAG)))
    {
      this->loc = this->sink->add(config, ~0);
    }

    bool operator()
      (const STR val) override
    {
      return this->sink->set(this->loc, DecimalFloat(val));
    }

  private:
    const String PRECISION_TAG;
    const uint precision;
  };
  #endif

  // ================================ DATE-TIME ===============

  template<typename LOC, typename STR>
  class TranslateStringDateTime : public TranslateString<LOC, STR>
  {
  public:
    TranslateStringDateTime
      (const String& fmt,
       Sink<LOC>* s,
       TranslationError onErr) :
        TranslateString<LOC, STR>(BaseDataType::btInt, s, onErr),
        format(fmt)
    {
      this->loc = this->sink->add(this->name, BaseDataType::btInt, ~0);
    }

    TranslateStringDateTime
      (const Configuration& config,
       Sink<LOC>* s,
       TranslationError onErr) :
        TranslateString<LOC, STR>(BaseDataType(BaseDataType::btInt, sizeof(int64)), s, onErr),
        format(config.getValue(TranslateNames::FORMAT_TAG))
    {
      if (!format)
        throw XML_No_Value(TranslateNames::FORMAT_TAG, config.toString());
      this->loc = this->sink->add(config, ~0);
    }

    virtual bool operator()
      (const STR val) override
    {
      return this->sink->set(this->loc, DateTime(String(val.data, val.length), format).toInt());
    }

  private:
    const String format;
  };

  // ================================ IPv4 ====================
      
  template<typename LOC, typename STR>
  class TranslateStringIPv4 : public TranslateString<LOC, STR>
  {
  public:
    TranslateStringIPv4
      (const Configuration& config,
       Sink<LOC>* s,
       TranslationError onErr) : 
        TranslateString<LOC, STR>(BaseDataType(BaseDataType::btInt, sizeof(int64)), s, onErr),
        matcher(!!config.getValue(TranslateNames::FORMAT_TAG) ? config.getValue(TranslateNames::FORMAT_TAG) : "a.a.a.a"),    
        has_addrs(matcher.add(typename STR::charType('a'), IntWrapper<_addrs>(&addrs))),
        has_port(matcher.add(typename STR::charType('p'), IntWrapper<_num>(&port))),
        has_xnum(matcher.add(typename STR::charType('n'), IntWrapper<_num>(&xnum)))
    {
      QString name(config.getTag());
      if (!!has_addrs)
        addrs_loc = this->sink->add(name + ".addrs", DerivedDataType::dtIPv4, ~0);
      if (!!has_port)
        port_loc = this->sink->add(name + ".port", BaseDataType::btUint, ~0);
      if (!!has_xnum)
        xnum_loc = this->sink->add(name + ".xnum", BaseDataType::btUint, ~0);
    }

    virtual bool operator()
      (const STR val) override
    {
      addrs.reset();
      port.reset();
      if (matcher.match(val))
      {
        int64 n;
        return (!has_addrs || !addrs.get(&n) || this->sink->set(addrs_loc, n)) &&
               (!has_port  || !port.get(&n)  || this->sink->set(port_loc, n)) &&
               (!has_xnum  || !xnum.get(&n)  || this->sink->set(xnum_loc, n));
      }
      return true;
    }

  private:
    const String format;

    MatchString<STR> matcher;

    bool has_addrs, has_port, has_xnum;
    uint addrs_loc, port_loc, xnum_loc;

    struct _addrs
    {
      void reset
        ()
      {
        val = cnt = 0;
      }

      bool operator()
        (int64 n)
      {
        ++cnt;
        assert(n < 256);
        val <<= 8;
        val += n;
        return true;
      }

      bool get
        (int64* n)
        const
      { 
        return (cnt == 4) ? (*n = val, true) : false;
      }

      int64 val;
      uint cnt;

    } addrs;    

    struct _num
    {
      void reset
        ()
      {
        num = -1;
      }

      bool operator()
        (int64 n)
      {
        num = n;
        return true;
      }

      bool get
        (int64* n)
      { 
        return (num == -1) ? false : (*n = num, true);
      }

      int64 num;

    } port, xnum;   
  };
 
  // ==========================================================
  // ==========================================================
  // ==========================================================

  template<typename LOC, typename STR>
  inline
  TranslateString<LOC, STR>* TranslateString<LOC, STR>::create
    (const Configuration& config,
     Sink<LOC>* sink,
     TranslationError onError)
  {
    String type(config.getValue(BaseDataTags::TYPE_TAG));

    #ifndef NDEBUG
    QString qconfig(config.toString());
    QString qtype(type);
    #endif

    DerivedDataType dt(type);
    switch (dt.getDerivedType())
    {
      case DerivedDataType::dtDateTime:
        return new TranslateStringDateTime<LOC, STR>(config, sink, onError);
      case DerivedDataType::dtIPv4:
        return new TranslateStringIPv4<LOC, STR>(config, sink, onError);
      default:
        break;
    }
    switch (dt.getBaseType())
    {
      case BaseDataType::btString8:
      case BaseDataType::btString16:
        return new TranslateStringString<LOC, STR>(config, sink, onError);
      case BaseDataType::btUint:
        return new TranslateStringUint<LOC, STR>(config, sink, onError);
      case BaseDataType::btInt:
        return new TranslateStringInt<LOC, STR>(config, sink, onError);
      #ifdef XPACE_DECIMAL_FLOAT_H
      case BaseDataType::btFloat:
        return new TranslateStringFloat<LOC, STR>(config, sink, onError);
      #endif
      default:
        break;
    }

    return new SkipStringNode<LOC, STR>();
  }
}

#if _WIN32 || _WIN64
# pragma warning(pop)
#endif

#endif