translate_byteptr_node.h

Go to the documentation of this file.

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

#include "data/translate_string_node.h"

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

    virtual bool isSkip
      ()
      const
    {
      return false;
    }

    virtual bool operator()
      (const typename STR::charType*)
    = 0;

  protected:
    TranslatePtr
      (const Configuration& config,
       BaseDataType t,
       Sink<LOC>* sink,
       TranslationError onErr = default_on_error) :
        TranslateNode<LOC>(t, sink, onErr),
        length(config.getValueInt(TranslateNames::LENGTH_TAG))
    {
      if (!!config && (length == 0))
        throw XML_No_Value(TranslateNames::LENGTH_TAG, config.toString());
    }

    const uint length;
  };

  template<typename LOC, typename STR>
  class SkipPtrNode : public TranslatePtr<LOC, STR>
  {
  public:
    SkipPtrNode
      () :
        TranslatePtr<LOC, STR>(Configuration(), BaseDataType::btNone, 0)
    {
    }

    virtual bool operator()
      (const typename STR::charType*) override
    {
      return true;
    }
  };

  // ================================ PASS-THROUGH TO STRING ==

  template <typename LOC, typename STR>
  class PassNumeral : public TranslatePtr<LOC, STR>
  {
  public:
    PassNumeral
      (const Configuration& config,
       BaseDataType t,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, t, sink, onError)
    {
      switch (t.getBaseType())
      {
      case BaseDataType::btInt : 
        translate_string.reset(new TranslateStringInt<LOC, STR>(config, sink, onError));
        break;
      case BaseDataType::btUint : 
        translate_string.reset(new TranslateStringUint<LOC, STR>(config, sink, onError));
        break;
      case BaseDataType::btFloat:
        translate_string.reset(new TranslateStringFloat<LOC, STR>(config, sink, onError));
        break;
      default:
        assert(0);  // TODO: exception
      }
    }

    bool operator()
      (const typename STR::charType* val) override
    {
      return (*translate_string)(STR((typename STR::charType*)val, this->length));
    }

  private:
    std::unique_ptr<TranslateString<LOC, STR>> translate_string;
  };

  template <typename LOC, typename STR>
  class PassString : public TranslatePtr<LOC, STR>
  {
  public:
    PassString
      (const Configuration& config,
       BaseDataType t,
       Sink<LOC>* sink, 
       TranslateString<LOC, STR>* ts) :
        TranslatePtr<LOC, STR>(config, t, sink), 
        translate_string(ts),
        is_delim((sizeof(typename STR::charType) == 1) ? 256 : 65536)
    {
      String delims(config.getValue(TranslateNames::DELIMS_TAG));
      for (size_t i(0); i < delims.getLength(); ++i)
      {
        utf16_t ch(delims.toUtf16()[i]);
        if (ch < is_delim.size())
          is_delim[ch] = true;
      }
    }

    bool operator()
      (const typename STR::charType* val) override
    {
      STR v((typename STR::charType*)val, this->length);
      while (v.length && is_delim[v.data[v.length - 1]])
        --v.length;

      return (!v.length || (*translate_string)(v));
    }

  private:
    std::unique_ptr<TranslateString<LOC, STR>> translate_string;

    std::vector<bool> is_delim;
  };

  // ================================ INT =====================

  template <typename LOC, typename STR, bool SIGNED, uint SIZE>
  class TranslatePtrInt : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      int64 v(0);
      memcpy(&v, val, SIZE);
      if (SIGNED && int8(*(val + SIZE - 1)) < 0)
        v = -v;
      return this->sink->set(this->loc, v);
    }
  };

  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, false, 1> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, int64(*val));
    }
  };

  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, true, 1> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, int64(*reinterpret_cast<const int8*>(val)));
    }
  };
  
  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, false, 2> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, int64(*reinterpret_cast<const uint16*>(val)));
    }
  };
  
  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, true, 2> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, int64(*reinterpret_cast<const int16*>(val)));
    }
  };
  
  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, false, 4> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, int64(*reinterpret_cast<const uint32*>(val)));
    }
  };
  
  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, true, 4> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, int64(*reinterpret_cast<const int32*>(val)));
    }
  };  
  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, false, 8> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, int64(*reinterpret_cast<const uint64*>(val)));   // TODO: check for overflow
    }
  };
  
  template <typename LOC, typename STR>
  class TranslatePtrInt<LOC, STR, true, 8> : public TranslatePtr<LOC, STR>
  {
  public:
    TranslatePtrInt
      (const Configuration& config,
       Sink<LOC>* sink,
       TranslationError onError) :
        TranslatePtr<LOC, STR>(config, BaseDataType::btInt, sink, onError)
    {
    }

    virtual bool operator()
      (const typename STR::charType* val) override
    {
      return this->sink->set(this->loc, *reinterpret_cast<const int64*>(val));
    }
  };

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

  template<typename LOC, typename STR>
  inline
  TranslatePtr<LOC, STR>* TranslatePtr<LOC, STR>::create
    (const Configuration& config,
     Sink<LOC>* sink,
     TranslationError onError)
  {
    #ifndef NDEBUG
    QString qconfig(config.toString());
    #endif

    String type(config.getValue(BaseDataTags::TYPE_TAG));
    if (type == TranslateNames::VECTOR_TAG)
      type = config.getValue(TranslateNames::SUBTYPE_TAG);
   
    if (config.getValueBool(TranslateNames::NUMERAL_TAG))
      return new PassNumeral<LOC, STR>(config, BaseDataType::btInt, sink, onError);

    DerivedDataType dt(type);
    switch (dt.getDerivedType())
    {
      case DerivedDataType::dtDateTime:
        return new PassString<LOC, STR>(config, BaseDataType::btUint, sink, new TranslateStringDateTime<LOC, STR>(config, sink, onError));
      case DerivedDataType::dtIPv4:
        return new PassString<LOC, STR>(config, BaseDataType::btUint, sink, new TranslateStringIPv4<LOC, STR>(config, sink, onError));
      default:
        break;
    }
    switch (dt.getBaseType())
    {
      case BaseDataType::btNone:
        return new SkipPtrNode<LOC, STR>();
      case BaseDataType::btString8:
      case BaseDataType::btString16:
        return new PassString<LOC, STR>(config, dt.getBaseType(), sink, new TranslateStringString<LOC, STR>(config, sink, onError));
      case BaseDataType::btUint:
        switch (config.getValueInt(TranslateNames::LENGTH_TAG, sizeof(uint)))
        {
          case 1: return new TranslatePtrInt<LOC, STR, false, 1>(config, sink, onError);
          case 2: return new TranslatePtrInt<LOC, STR, false, 2>(config, sink, onError);
          case 3: return new TranslatePtrInt<LOC, STR, false, 3>(config, sink, onError);
          case 4: return new TranslatePtrInt<LOC, STR, false, 4>(config, sink, onError);
          case 5: return new TranslatePtrInt<LOC, STR, false, 5>(config, sink, onError);
          case 6: return new TranslatePtrInt<LOC, STR, false, 6>(config, sink, onError);
          case 7: return new TranslatePtrInt<LOC, STR, false, 7>(config, sink, onError);
          default: return new TranslatePtrInt<LOC, STR, false, 8>(config, sink, onError);
        }
      case BaseDataType::btInt:
        switch (config.getValueInt(TranslateNames::LENGTH_TAG, sizeof(int)))
        {
          case 1: return new TranslatePtrInt<LOC, STR, true, 1>(config, sink, onError);
          case 2: return new TranslatePtrInt<LOC, STR, true, 2>(config, sink, onError);
          case 3: return new TranslatePtrInt<LOC, STR, true, 3>(config, sink, onError);
          case 4: return new TranslatePtrInt<LOC, STR, true, 4>(config, sink, onError);
          case 5: return new TranslatePtrInt<LOC, STR, true, 5>(config, sink, onError);
          case 6: return new TranslatePtrInt<LOC, STR, true, 6>(config, sink, onError);
          case 7: return new TranslatePtrInt<LOC, STR, true, 7>(config, sink, onError);
          default: return new TranslatePtrInt<LOC, STR, true, 8>(config, sink, onError);
        }
      #ifdef XPACE_DECIMAL_FLOAT_H
      case BaseDataType::btFloat:
          // TODO
      #endif
      default:
        break;
    }

    // TODO: throw
    return new SkipPtrNode<LOC, STR>();
  }

}