field.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------------
/*

Fix8 is released under the GNU LESSER GENERAL PUBLIC LICENSE Version 3.

Fix8 Open Source FIX Engine.
Copyright (C) 2010-16 David L. Dight <fix@fix8.org>

Fix8 is free software: you can  redistribute it and / or modify  it under the  terms of the
GNU Lesser General  Public License as  published  by the Free  Software Foundation,  either
version 3 of the License, or (at your option) any later version.

Fix8 is distributed in the hope  that it will be useful, but WITHOUT ANY WARRANTY;  without
even the  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

You should  have received a copy of the GNU Lesser General Public  License along with Fix8.
If not, see <http://www.gnu.org/licenses/>.

BECAUSE THE PROGRAM IS  LICENSED FREE OF  CHARGE, THERE IS NO  WARRANTY FOR THE PROGRAM, TO
THE EXTENT  PERMITTED  BY  APPLICABLE  LAW.  EXCEPT WHEN  OTHERWISE  STATED IN  WRITING THE
COPYRIGHT HOLDERS AND/OR OTHER PARTIES  PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY
KIND,  EITHER EXPRESSED   OR   IMPLIED,  INCLUDING,  BUT   NOT  LIMITED   TO,  THE  IMPLIED
WARRANTIES  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO
THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE,
YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

IN NO EVENT UNLESS REQUIRED  BY APPLICABLE LAW  OR AGREED TO IN  WRITING WILL ANY COPYRIGHT
HOLDER, OR  ANY OTHER PARTY  WHO MAY MODIFY  AND/OR REDISTRIBUTE  THE PROGRAM AS  PERMITTED
ABOVE,  BE  LIABLE  TO  YOU  FOR  DAMAGES,  INCLUDING  ANY  GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR
THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH
HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

*/
//-------------------------------------------------------------------------------------------------
#ifndef FIX8_FIELD_HPP_
#define FIX8_FIELD_HPP_

#include <Poco/Timestamp.h>
#include <Poco/DateTime.h>

//-------------------------------------------------------------------------------------------------
namespace FIX8 {

//-------------------------------------------------------------------------------------------------
// Misc consts
const size_t MAX_MSGTYPE_FIELD_LEN(32);
const size_t HEADER_CALC_OFFSET(32);

//-------------------------------------------------------------------------------------------------

template<unsigned field> struct EnumType {};

//-------------------------------------------------------------------------------------------------
struct RealmBase
{
   enum RealmType { dt_range, dt_set };

   const void *_range;
   RealmType _dtype;
   FieldTrait::FieldType _ftype;
   const int _sz;
   const char * const *_descriptions;

   RealmBase(const void *range, RealmType dtype, FieldTrait::FieldType ftype, int sz, const char * const *descriptions)
      : _range(range), _dtype(dtype), _ftype(ftype), _sz(sz), _descriptions(descriptions) {}

   template<typename T>
   bool is_valid(const T& what) const
   {
      const T *rng(static_cast<const T*>(_range));
      return _dtype == dt_set ? std::binary_search(rng, rng + _sz, what) : *rng <= what && what <= *(rng + 1);
   }

   template<typename T>
   const T& get_rlm_val(const int idx) const { return *(static_cast<const T*>(_range) + idx); }

   template<typename T>
   int get_rlm_idx(const T& what) const
   {
      if (_dtype == dt_set)
      {
         const T *rng(static_cast<const T*>(_range)), *res(std::lower_bound(rng, rng + _sz, what));
         return res != rng + _sz ? res - rng : -1;
      }
      return 0;
   }

   template<typename T>
   std::ostream& _print(std::ostream& os, int idx) const { return os << *((static_cast<const T *>(_range) + idx)); }

   std::ostream& print(std::ostream& os, int idx) const
   {
      return FieldTrait::is_int(_ftype) ? _print<int>(os, idx)
         : FieldTrait::is_char(_ftype) ? _print<char>(os, idx)
         : FieldTrait::is_float(_ftype) ? _print<fp_type>(os, idx)
         : FieldTrait::is_string(_ftype) ? _print<f8String>(os, idx) : os;
   }
};

//-------------------------------------------------------------------------------------------------
class BaseField
{
   const unsigned short _fnum;

protected:
   const RealmBase *_rlm;

public:
   BaseField(unsigned short fnum, const RealmBase *rlm=nullptr) : _fnum(fnum), _rlm(rlm) {}

   virtual ~BaseField() {}

   unsigned short get_tag() const { return _fnum; }

   virtual std::ostream& print(std::ostream& os) const = 0;

   virtual size_t print(char *to) const = 0;

   virtual FieldTrait::FieldType get_underlying_type() const = 0;

   virtual BaseField *copy() = 0;

   virtual int get_rlm_idx() const { return -1; }

   template<typename T>
   T& from() { return *static_cast<T*>(this); }

   template<typename T>
   const T *as() const { return static_cast<T*>(this); }

   size_t encode(std::ostream& os) const
   {
      const std::ios::pos_type where(os.tellp());
      os << _fnum << default_assignment_separator << *this << default_field_separator;
      return os.tellp() - where;
   }

   size_t encode(char *to) const
   {
      const char *cur_ptr(to);
      to += itoa(_fnum, to, 10);
      *to++ = default_assignment_separator;
      to += print(to);
      *to++ = default_field_separator;
      return to - cur_ptr;
   }


   bool same_base(const BaseField& that) const { return that._fnum == _fnum; }


   virtual bool operator==(const BaseField& that) const = 0;


   virtual bool operator<(const BaseField& that) const = 0;


   virtual bool operator>(const BaseField& that) const = 0;


   bool operator!=(const BaseField& that) const { return !(*this == that); }


   bool operator<=(const BaseField& that) const { return *this < that || *this == that; }


   bool operator>=(const BaseField& that) const { return *this > that || *this == that; }

   const RealmBase *get_realm() const { return _rlm; }

   friend std::ostream& operator<<(std::ostream& os, const BaseField& what) { return what.print(os); }
   friend class MessageBase;
};

//-------------------------------------------------------------------------------------------------

template<typename T, unsigned short field>
class Field : public BaseField
{
   Field() = delete;
   Field(const Field&) = delete;
   Field& operator=(const Field&) = delete;
   Field(const f8String&, const RealmBase *) = delete;
};

//-------------------------------------------------------------------------------------------------

template<unsigned short field>
class Field<int, field> : public BaseField
{
protected:
   int _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_int;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field), _value() {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const int val, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(val) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(fast_atoi<int>(from.c_str())) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(fast_atoi<int>(from)) {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }

   virtual ~Field() {}


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<int, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<int, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<int, field>&>(that)._value; }

   bool is_valid() const { return _rlm ? _rlm->is_valid(_value) : true; }

   int get_rlm_idx() const { return _rlm ? _rlm->get_rlm_idx(_value) : -1; }

   const int& get() const { return _value; }

   const int& operator()() const { return _value; }

   const int& set(const int& from) { return _value = from; }

   const int& set_from_raw(const f8String& from) { return _value = fast_atoi<int>(from.c_str()); }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os << _value; }

   size_t print(char *to) const { return itoa(_value, to, 10); }
};

//-------------------------------------------------------------------------------------------------

template<unsigned short field>
class Field<char *, field> : public BaseField
{
protected:
   const char *_value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_data;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(from) {}

   virtual ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const char *that) const { return ::strcmp(_value, that) == 0; }


   bool operator!=(const char *that) const { return ::strcmp(_value, that); }


   bool operator==(const BaseField& that) const
      { return same_base(that) && ::strcmp(static_cast<const Field<char *, field>&>(that)._value, _value) == 0; }


   virtual bool operator<(const BaseField& that) const
      { return same_base(that) && ::strcmp(_value, static_cast<const Field<char *, field>&>(that)._value) < 0; }


   virtual bool operator>(const BaseField& that) const
      { return same_base(that) && ::strcmp(_value, static_cast<const Field<char *, field>&>(that)._value) > 0; }

   bool is_valid() const { return _rlm ? _rlm->is_valid(_value) : true; }

   int get_rlm_idx() const { return _rlm ? _rlm->get_rlm_idx(_value) : -1; }

   const char *get() const { return _value; }

   const char *operator()() const { return _value; }

   const char *set(const char *from) { return _value = from; }

   const char *set_from_raw(const char *from) { return _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os << _value; }

   size_t print(char *to) const { ::strcpy(to, _value); return ::strlen(_value); }
};

//-------------------------------------------------------------------------------------------------

template<unsigned short field>
class Field<f8String, field> : public BaseField
{
protected:
   f8String _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_data;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(from) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(from) {}

   virtual ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<f8String, field>&>(that)._value == _value; }


   virtual bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<f8String, field>&>(that)._value; }


   virtual bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<f8String, field>&>(that)._value; }

   bool is_valid() const { return _rlm ? _rlm->is_valid(_value) : true; }

   int get_rlm_idx() const { return _rlm ? _rlm->get_rlm_idx(_value) : -1; }

   const f8String& get() const { return _value; }

   const f8String& operator()() const { return _value; }

   const f8String& set(const f8String& from) { return _value = from; }

   const f8String& set_from_raw(const f8String& from) { return _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os << _value; }

   size_t print(char *to) const { return _value.copy(to, _value.size()); }
};

//-------------------------------------------------------------------------------------------------

template<unsigned short field>
class Field<fp_type, field> : public BaseField
{
protected:
   fp_type _value;
   int _precision;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_float;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field), _value(), _precision(FIX8_DEFAULT_PRECISION) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field, from._rlm), _value(from._value), _precision(from._precision) {}

   Field (const fp_type& val, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(val), _precision(FIX8_DEFAULT_PRECISION) {}

   Field (const fp_type& val, const int prec, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(val), _precision(prec) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(fast_atof(from.c_str())), _precision(FIX8_DEFAULT_PRECISION) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(fast_atof(from)), _precision(FIX8_DEFAULT_PRECISION) {}

   virtual ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<fp_type, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<fp_type, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<fp_type, field>&>(that)._value; }

   void set_precision(const int prec) { _precision = prec; }

   bool is_valid() const { return _rlm ? _rlm->is_valid(_value) : true; }

   int get_rlm_idx() const { return _rlm ? _rlm->get_rlm_idx(_value) : -1; }

   const fp_type& get() const { return _value; }

   const fp_type& operator()() const { return _value; }

   const fp_type& set(const fp_type& from) { return _value = from; }

   const fp_type& set_from_raw(const f8String& from) { return _value = fast_atof(from.c_str()); }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os << _value; }

   size_t print(char *to) const { return modp_dtoa(_value, to, _precision); }
};

//-------------------------------------------------------------------------------------------------

template<unsigned short field>
class Field<char, field> : public BaseField
{
   char _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_char;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field), _value() {}

   Field (const Field& from) : BaseField(field, from._rlm), _value(from._value) {}

   Field (const char& val, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(val) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(from[0]) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(*from) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<char, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<char, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<char, field>&>(that)._value; }

   bool is_valid() const { return _rlm ? _rlm->is_valid(_value) : true; }

   int get_rlm_idx() const { return _rlm ? _rlm->get_rlm_idx(_value) : -1; }

   const char& get() const { return _value; }

   const char& operator()() const { return _value; }

   const char& set(const char& from) { return _value = from; }

   const char& set_from_raw(const f8String& from) { return _value = from[0]; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os << _value; }

   size_t print(char *to) const { *to = _value; return 1; }
};

//-------------------------------------------------------------------------------------------------
inline void format0(int data, char *to, int width)
{
   while(width-- > 0)
   {
      to[width] = data % 10 + '0';
      data /= 10;
   }
}

inline size_t parse_decimal(const char *begin, size_t len, int &to)
{
   const char *bsv(begin);
   while(len-- > 0)
      to = (to << 3) + (to << 1) + (*begin++ - '0');
   return begin - bsv;
}

inline time_t time_to_epoch (const tm& ltm, int utcdiff=0)
{
   static const int mon_days[] {0,
      31,
      31 + 28,
      31 + 28 + 31,
      31 + 28 + 31 + 30,
      31 + 28 + 31 + 30 + 31,
      31 + 28 + 31 + 30 + 31 + 30,
      31 + 28 + 31 + 30 + 31 + 30 + 31,
      31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
      31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
      31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
      31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
      31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31
   };

   const int tyears(ltm.tm_year ? ltm.tm_year - 70 : 0); // tm->tm_year is from 1900.
   int tdays(mon_days[ltm.tm_mon] + (ltm.tm_mday ? ltm.tm_mday - 1 : 0) + tyears * 365 + (tyears + 2) / 4);
   if (ltm.tm_year && ltm.tm_year % 4 == 0 && ltm.tm_mon < 2) // works till 2100, adjust for leap year with jan/feb +1day error
      --tdays;
   return tdays * 86400 + (ltm.tm_hour + utcdiff) * 3600 + ltm.tm_min * 60 + ltm.tm_sec;
}

enum TimeIndicator { _time_only, _time_with_ms, _short_date_only, _date_only, _sec_only, _with_ms };

inline size_t date_time_format(const Tickval& tickval, char *to, TimeIndicator ind)
{
   const tm result(tickval.get_tm());
   const char *start(to);

   if (ind > _time_with_ms)
   {
      format0(result.tm_year + 1900, to, 4);
      to += 4;
      format0(result.tm_mon + 1, to, 2);
      to += 2;
      if (ind == _short_date_only)
         return to - start;
      format0(result.tm_mday, to, 2);
      to += 2;
      if (ind == _date_only)
         return to - start;
      *to++ = '-';
   }

   format0(result.tm_hour, to, 2);
   to += 2;
   *to++ = ':';
   format0(result.tm_min, to, 2);
   to += 2;
   *to++ = ':';
   format0(result.tm_sec, to, 2);
   to += 2;

   if (ind == _time_with_ms || ind == _with_ms)
   {
      *to++ = '.';
      format0(tickval.msecs(), to, 3);
      to += 3;
   }

   return to - start;
}

inline Tickval::ticks date_time_parse(const char *ptr, size_t len)
{
   if (len == 0 || (*ptr == 'n' && len == 3 && *(ptr + 1) == 'o' && *(ptr + 2) == 'w'))   // special cases initialise to 'now'
      return Tickval(true).get_ticks();

   Tickval::ticks result(Tickval::noticks);
   int millisecond(0);
   tm tms {};

   ptr += parse_decimal(ptr, 4, tms.tm_year);
   tms.tm_year -= 1900;
   ptr += parse_decimal(ptr, 2, tms.tm_mon);
   --tms.tm_mon;
   ptr += parse_decimal(ptr, 2, tms.tm_mday);
   ++ptr;
   ptr += parse_decimal(ptr, 2, tms.tm_hour);
   ++ptr;
   ptr += parse_decimal(ptr, 2, tms.tm_min);
   ++ptr;
   ptr += parse_decimal(ptr, 2, tms.tm_sec);
   switch(len)
   {
   case 21: //_with_ms: // 19981231-23:59:59.123
      parse_decimal(++ptr, 3, millisecond);
      result = millisecond * Tickval::million; // drop through
   case 17: //: // 19981231-23:59:59
      result += time_to_epoch(tms) * Tickval::billion;
      break;
   default:
      break;
   }

   return result;
}

inline Tickval::ticks time_parse(const char *ptr, size_t len, bool timeonly=false)
{
   if (len == 0 || (*ptr == 'n' && len == 3 && *(ptr + 1) == 'o' && *(ptr + 2) == 'w'))   // special cases initialise to 'now'
      return Tickval(true).get_ticks();

   Tickval::ticks result(Tickval::noticks);
   int millisecond(0);
   tm tms {};

   ptr += parse_decimal(ptr, 2, tms.tm_hour);
   ++ptr;
   ptr += parse_decimal(ptr, 2, tms.tm_min);
   ++ptr;
   ptr += parse_decimal(ptr, 2, tms.tm_sec);
   switch(len)
   {
   case 12: // 23:59:59.123
      parse_decimal(++ptr, 3, millisecond);
      result = millisecond * Tickval::million; // drop through
   case 8: // 23:59:59
      if (!timeonly)
         result += time_to_epoch(tms) * Tickval::billion;
      else
         result += (tms.tm_hour * 3600ULL + tms.tm_min * 60ULL + tms.tm_sec) * Tickval::billion;
      break;
   default:
      break;
   }

   return result;
}

inline Tickval::ticks date_parse(const char *ptr, size_t len)
{
   if (len == 0 || (*ptr == 'n' && len == 3 && *(ptr + 1) == 'o' && *(ptr + 2) == 'w'))   // special cases initialise to 'now'
      return Tickval(true).get_ticks();

   tm tms {};
   ptr += parse_decimal(ptr, 4, tms.tm_year);
   tms.tm_year -= 1900;
   ptr += parse_decimal(ptr, 2, tms.tm_mon);
   --tms.tm_mon;
   if (len == 8)
      parse_decimal(ptr, 2, tms.tm_mday);
   else
      tms.tm_mday = 1;
   return time_to_epoch(tms) * Tickval::billion;
}

//-------------------------------------------------------------------------------------------------
using UTCTimestamp = EnumType<FieldTrait::ft_UTCTimestamp>;


template<unsigned short field>
class Field<UTCTimestamp, field> : public BaseField
{
   Tickval _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_string;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field), _value(true) {}

   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const Tickval& val, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(val) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(date_time_parse(from.data(), from.size())) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field), _value(date_time_parse(from, from ? ::strlen(from) : 0)) {}

   Field (const tm& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(time_to_epoch(from) * Tickval::billion) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<UTCTimestamp, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<UTCTimestamp, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<UTCTimestamp, field>&>(that)._value; }

   const Tickval& get() const { return _value; }

   const Tickval& operator()() const { return _value; }

   void set(const Tickval& from) { _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const
   {
      char buf[MAX_MSGTYPE_FIELD_LEN] {};
      print(buf);
      return os << buf;
   }

   size_t print(char *to) const { return date_time_format(_value, to, _with_ms); }
};

//-------------------------------------------------------------------------------------------------
using UTCTimeOnly = EnumType<FieldTrait::ft_UTCTimeOnly>;


template<unsigned short field>
class Field<UTCTimeOnly, field> : public BaseField
{
   Tickval _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_string;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(time_parse(from.data(), from.size(), true)) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field), _value(time_parse(from, from ? ::strlen(from) : 0, true)) {}

   Field (const tm& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(time_to_epoch(from) * Tickval::billion) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<UTCTimeOnly, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<UTCTimeOnly, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<UTCTimeOnly, field>&>(that)._value; }

   const Tickval& get() const { return _value; }

   const Tickval& operator()() const { return _value; }

   void set(const Tickval& from) { _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const
   {
      char buf[MAX_MSGTYPE_FIELD_LEN] {};
      print(buf);
      return os << buf;
   }

   size_t print(char *to) const { return date_time_format(_value, to, _time_with_ms); }
};

//-------------------------------------------------------------------------------------------------
using UTCDateOnly = EnumType<FieldTrait::ft_UTCDateOnly>;


template<unsigned short field>
class Field<UTCDateOnly, field> : public BaseField
{
   Tickval _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_string;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(date_parse(from.data(), from.size())) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field), _value(date_parse(from, from ? ::strlen(from) : 0)) {}

   Field (const tm& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(time_to_epoch(from) * Tickval::billion) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<UTCDateOnly, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<UTCDateOnly, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<UTCDateOnly, field>&>(that)._value; }

   const Tickval& get() const { return _value; }

   const Tickval& operator()() const { return _value; }

   void set(const Tickval& from) { _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const
   {
      char buf[MAX_MSGTYPE_FIELD_LEN] {};
      print(buf);
      return os << buf;
   }

   size_t print(char *to) const { return date_time_format(_value, to, _date_only); }
};

//-------------------------------------------------------------------------------------------------
using LocalMktDate = EnumType<FieldTrait::ft_LocalMktDate>;


template<unsigned short field>
class Field<LocalMktDate, field> : public BaseField
{
   Tickval _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_string;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(date_parse(from.data(), from.size())) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field), _value(date_parse(from, from ? ::strlen(from) : 0)) {}

   Field (const tm& from, const RealmBase *rlm=nullptr) : BaseField(field), _value(time_to_epoch(from) * Tickval::billion) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<LocalMktDate, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<LocalMktDate, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<LocalMktDate, field>&>(that)._value; }

   const Tickval& get() const { return _value; }

   const Tickval& operator()() const { return _value; }

   void set(const Tickval& from) { _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const
   {
      char buf[MAX_MSGTYPE_FIELD_LEN] {};
      print(buf);
      return os << buf;
   }

   size_t print(char *to) const { return date_time_format(_value, to, _date_only); }
};

//-------------------------------------------------------------------------------------------------
using MonthYear = EnumType<FieldTrait::ft_MonthYear>;


template<unsigned short field>
class Field<MonthYear, field> : public BaseField
{
   size_t _sz;
   Tickval _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_string;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _sz(from._sz), _value(from._value) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field), _sz(from.size()), _value(date_parse(from.data(), _sz)) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field), _sz(from ? ::strlen(from) : 0), _value(date_parse(from, _sz)) {}

   Field (const tm& from, const RealmBase *rlm=nullptr) : BaseField(field), _sz(6), _value(time_to_epoch(from) * Tickval::billion) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<MonthYear, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<MonthYear, field>&>(that)._value; }


   virtual bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<MonthYear, field>&>(that)._value; }

   const Tickval& get() const { return _value; }

   const Tickval& operator()() const { return _value; }

   void set(const Tickval& from) { _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const
   {
      char buf[MAX_MSGTYPE_FIELD_LEN] {};
      print(buf);
      return os << buf;
   }

   size_t print(char *to) const { return date_time_format(_value, to, _sz == 6 ? _short_date_only : _date_only); }
};

//-------------------------------------------------------------------------------------------------
using TZTimeOnly = EnumType<FieldTrait::ft_TZTimeOnly>;


template<unsigned short field>
class Field<TZTimeOnly, field> : public BaseField
{
   Tickval _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_string;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field, rlm) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<TZTimeOnly, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<TZTimeOnly, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<TZTimeOnly, field>&>(that)._value; }

   const Tickval& get() const { return _value; }

   const Tickval& operator()() const { return _value; }

   void set(const Tickval& from) { _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os; }     // TODO

   size_t print(char *to) const { return 0; }   // TODO
};

//-------------------------------------------------------------------------------------------------
using TZTimestamp = EnumType<FieldTrait::ft_TZTimestamp>;


template<unsigned short field>
class Field<TZTimestamp, field> : public BaseField
{
   Tickval _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_string;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field, rlm) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm) {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<TZTimestamp, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<TZTimestamp, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<TZTimestamp, field>&>(that)._value; }

   const Tickval& get() const { return _value; }

   const Tickval& operator()() const { return _value; }

   void set(const Tickval& from) { _value = from; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os; }     // TODO

   size_t print(char *to) const { return 0; }   // TODO
};

//-------------------------------------------------------------------------------------------------
using Length = EnumType<FieldTrait::ft_Length>;


template<unsigned short field>
class Field<Length, field> : public Field<int, field>
{
public:
   Field () : Field<int, field>() {}

   Field (unsigned val, const RealmBase *rlm=nullptr) : Field<int, field>(val, rlm) {}

   /* \param from field to copy */
   Field (const Field& from) : Field<int, field>(from) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : Field<int, field>(from.c_str(), rlm) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   ~Field() {}
};

//-------------------------------------------------------------------------------------------------
using TagNum = EnumType<FieldTrait::ft_TagNum>;


template<unsigned short field>
class Field<TagNum, field> : public Field<int, field>
{
public:
   Field () : Field<int, field>() {}

   Field (const unsigned& val, const RealmBase *rlm=nullptr) : Field<int, field>(val, rlm) {}

   /* \param from field to copy */
   Field (const Field& from) : Field<int, field>(from) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   ~Field() {}
};

//-------------------------------------------------------------------------------------------------
using SeqNum = EnumType<FieldTrait::ft_SeqNum>;


template<unsigned short field>
class Field<SeqNum, field> : public Field<int, field>
{
public:
   Field () : Field<int, field>() {}

   Field (const unsigned& val, const RealmBase *rlm=nullptr) : Field<int, field>(val, rlm) {}

   /* \param from field to copy */
   Field (const Field& from) : Field<int, field>(from) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   ~Field() {}
};

//-------------------------------------------------------------------------------------------------
using NumInGroup = EnumType<FieldTrait::ft_NumInGroup>;


template<unsigned short field>
class Field<NumInGroup, field> : public Field<int, field>
{
public:
   Field () : Field<int, field>() {}

   Field (const unsigned& val, const RealmBase *rlm=nullptr) : Field<int, field>(val, rlm) {}

   /* \param from field to copy */
   Field (const Field& from) : Field<int, field>(from) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   ~Field() {}
};

//-------------------------------------------------------------------------------------------------
using DayOfMonth = EnumType<FieldTrait::ft_DayOfMonth>;


template<unsigned short field>
class Field<DayOfMonth, field> : public Field<int, field>
{
public:
   Field () : Field<int, field>() {}

   Field (const unsigned& val, const RealmBase *rlm=nullptr) : Field<int, field>(val, rlm) {}

   /* \param from field to copy */
   Field (const Field& from) : Field<int, field>(from) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   Field (const char *from, const RealmBase *rlm=nullptr) : Field<int, field>(from, rlm) {}

   ~Field() {}
};

//-------------------------------------------------------------------------------------------------
using Boolean = EnumType<FieldTrait::ft_Boolean>;


template<unsigned short field>
class Field<Boolean, field> : public BaseField
{
   bool _value;
   static const FieldTrait::FieldType _ftype = FieldTrait::ft_char;

public:
   static unsigned short get_field_id() { return field; }

   FieldTrait::FieldType get_underlying_type() const { return _ftype; }

   Field () : BaseField(field) {}

   Field (const char val, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(toupper(val) == 'Y') {}

   explicit Field (const bool val) : BaseField(field), _value(val) {}

   /* \param from field to copy */
   Field (const Field& from) : BaseField(field), _value(from._value) {}

   Field (const f8String& from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(toupper(from[0]) == 'Y') {}

   Field (const char *from, const RealmBase *rlm=nullptr) : BaseField(field, rlm), _value(toupper(*from) == 'Y') {}

   ~Field() {}


   Field& operator=(const Field& that)
   {
      if (this != &that)
         _value = that._value;
      return *this;
   }


   bool operator==(const BaseField& that) const
      { return same_base(that) && static_cast<const Field<Boolean, field>&>(that)._value == _value; }


   bool operator<(const BaseField& that) const
      { return same_base(that) && _value < static_cast<const Field<Boolean, field>&>(that)._value; }


   bool operator>(const BaseField& that) const
      { return same_base(that) && _value > static_cast<const Field<Boolean, field>&>(that)._value; }

   bool get() const { return _value; }

   bool operator()() const { return _value; }

   int get_rlm_idx() const { return _rlm ? _rlm->get_rlm_idx(_value ? 'Y' : 'N') : -1; }

   bool set(const bool from) { return _value = from; }

   bool set_from_raw(const f8String& from) { return _value = toupper(from[0]) == 'Y'; }

   Field *copy() { return new Field(*this); }

   std::ostream& print(std::ostream& os) const { return os << (_value ? 'Y' : 'N'); }

   size_t print(char *to) const { *to = _value ? 'Y' : 'N'; return 1; }
};

//-------------------------------------------------------------------------------------------------
using Qty = fp_type;
using Amt = fp_type;
using price = fp_type;
using PriceOffset = fp_type;
using Percentage = fp_type;

//-------------------------------------------------------------------------------------------------
using MultipleCharValue = f8String;
using MultipleStringValue = f8String;
using country = f8String;
using currency = f8String;
using Exchange = f8String;
using Language = f8String;
using XMLData = f8String;
using data = f8String;

//-------------------------------------------------------------------------------------------------
class Inst
{
   struct _gen
   {
      template<typename T>
      static BaseField *_make(const char *from, const RealmBase *db, const int rv)
         { return new T{from, db}; }

      template<typename T, typename R>
      static BaseField *_make(const char *from, const RealmBase *db, const int rv)
      {
         return !db || rv < 0 || rv >= db->_sz || db->_dtype != RealmBase::dt_set
            ? new T(from, db) : new T(db->get_rlm_val<R>(rv), db);
      }
   };

public:
   BaseField *(&_do)(const char *from, const RealmBase *db, const int);

   template<typename T, typename... args>
   Inst(Type2Type<T, args...>) : _do(_gen::_make<T, args...>) {}
};

struct BaseEntry
{
   const Inst _create;
   const char *_name;
   const unsigned short _fnum;
   const RealmBase *_rlm;
   const char *_comment;
};

//-------------------------------------------------------------------------------------------------
// Common (administrative) msgtypes
const f8String Common_MsgType_HEARTBEAT("0");
const f8String Common_MsgType_TEST_REQUEST("1");
const f8String Common_MsgType_RESEND_REQUEST("2");
const f8String Common_MsgType_REJECT("3");
const f8String Common_MsgType_SEQUENCE_RESET("4");
const f8String Common_MsgType_LOGOUT("5");
const f8String Common_MsgType_LOGON("A");
const f8String Common_MsgType_BUSINESS_REJECT("j");
const char Common_MsgByte_HEARTBEAT('0');
const char Common_MsgByte_TEST_REQUEST('1');
const char Common_MsgByte_RESEND_REQUEST('2');
const char Common_MsgByte_REJECT('3');
const char Common_MsgByte_SEQUENCE_RESET('4');
const char Common_MsgByte_LOGOUT('5');
const char Common_MsgByte_LOGON('A');
const char Common_MsgByte_BUSINESS_REJECT('j');

//-------------------------------------------------------------------------------------------------
// Common FIX field numbers

const unsigned short Common_BeginSeqNo(7);
const unsigned short Common_BeginString(8);
const unsigned short Common_BodyLength(9);
const unsigned short Common_CheckSum(10);
const unsigned short Common_EndSeqNo(16);
const unsigned short Common_MsgSeqNum(34);
const unsigned short Common_MsgType(35);
const unsigned short Common_NewSeqNo(36);
const unsigned short Common_PossDupFlag(43);
const unsigned short Common_RefSeqNum(45);
const unsigned short Common_SenderCompID(49);
const unsigned short Common_SendingTime(52);
const unsigned short Common_TargetCompID(56);
const unsigned short Common_Text(58);
const unsigned short Common_EncryptMethod(98);
const unsigned short Common_HeartBtInt(108);
const unsigned short Common_TestReqID(112);
const unsigned short Common_OnBehalfOfCompID(115);
const unsigned short Common_OnBehalfOfSubID(116);
const unsigned short Common_OrigSendingTime(122);
const unsigned short Common_GapFillFlag(123);
const unsigned short Common_ResetSeqNumFlag(141);
const unsigned short Common_OnBehalfOfLocationID(144);
const unsigned short Common_OnBehalfOfSendingTime(370);
const unsigned short Common_RefMsgType(372);
const unsigned short Common_BusinessRejectReason(380);
const unsigned short Common_DefaultApplVerID(1137);   // >= 5.0 || FIXT1.1

//-------------------------------------------------------------------------------------------------
// Common FIX fields

using msg_seq_num = Field<SeqNum, Common_MsgSeqNum>;
using begin_seq_num = Field<SeqNum, Common_BeginSeqNo>;
using end_seq_num = Field<SeqNum, Common_EndSeqNo>;
using new_seq_num = Field<SeqNum, Common_NewSeqNo>;
using ref_seq_num = Field<SeqNum, Common_RefSeqNum>;

using body_length = Field<Length, Common_BodyLength>;

using sender_comp_id = Field<f8String, Common_SenderCompID>;
using target_comp_id = Field<f8String, Common_TargetCompID>;
using msg_type = Field<f8String, Common_MsgType>;
using check_sum = Field<f8String, Common_CheckSum>;
using begin_string = Field<f8String, Common_BeginString>;
using test_request_id = Field<f8String, Common_TestReqID>;
using text = Field<f8String, Common_Text>;
using default_appl_ver_id = Field<f8String, Common_DefaultApplVerID>;
using ref_msg_type = Field<f8String, Common_RefMsgType>;

using sending_time = Field<UTCTimestamp, Common_SendingTime>;
using orig_sending_time = Field<UTCTimestamp, Common_OrigSendingTime>;

using gap_fill_flag = Field<Boolean, Common_GapFillFlag>;
using poss_dup_flag = Field<Boolean, Common_PossDupFlag>;
using reset_seqnum_flag = Field<Boolean, Common_ResetSeqNumFlag>;

using heartbeat_interval = Field<int, Common_HeartBtInt>;
using encrypt_method = Field<int, Common_EncryptMethod>;
using business_reject_reason = Field<int, Common_BusinessRejectReason>;

using onbehalfof_comp_id = Field<f8String, Common_OnBehalfOfCompID>;
using onbehalfof_sub_id = Field<f8String, Common_OnBehalfOfSubID>;
using onbehalfof_location_id = Field<f8String, Common_OnBehalfOfLocationID>;
using onbehalfof_sending_time = Field<UTCTimestamp, Common_OnBehalfOfSendingTime>;

//-------------------------------------------------------------------------------------------------

} // FIX8

#endif // FIX8_FIELD_HPP_