message.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_MESSAGE_HPP_
#define FIX8_MESSAGE_HPP_

#include <vector>
#if defined FIX8_PREENCODE_MSG_SUPPORT
#include <array>
#endif

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

//-------------------------------------------------------------------------------------------------
class MessageBase;
class Message;
class Session;
class GroupBase;
using GroupElement = std::vector<MessageBase *>;

//-------------------------------------------------------------------------------------------------
using Groups = std::map<unsigned short, GroupBase *>;

class GroupBase
{
   unsigned short _fnum;
   GroupElement _msgs;

public:
   GroupBase(const unsigned short fnum) : _fnum(fnum) {}

   virtual ~GroupBase() { clear(false); }

   virtual MessageBase *create_group(bool deepctor=true) const = 0;

   virtual GroupBase *create_nested_group(unsigned short fnum) const { return nullptr; }

   void add(MessageBase *what) { _msgs.push_back(what); }

   void operator+=(MessageBase *what) { add(what); }

   GroupBase& operator<<(MessageBase *what) { add(what); return *this; }

   size_t size() const { return _msgs.size(); }

   MessageBase *operator[](const unsigned idx) const { return get_element(idx); }

   MessageBase *get_element(const unsigned idx) const { return idx < _msgs.size() ? _msgs[idx] : nullptr; }

   void clear(bool reuse=true);

   friend std::ostream& operator<<(std::ostream& os, const GroupBase& what);

   friend class MessageBase;
};

//-------------------------------------------------------------------------------------------------
class Router
{
public:
   virtual ~Router() {}

   virtual bool operator()(const Message *msg) const { return false; }

   virtual bool operator()(const Message *msg) { return false; }
};

class Minst
{
   struct _gen
   {
      template<typename T>
      static Message *_make(bool deepctor) { return new T(deepctor); }

      template<typename T, typename R>
      static Message *_make(bool deepctor) { return reinterpret_cast<Message *>(new T(deepctor)); }

#if defined FIX8_HAVE_EXTENDED_METADATA

      template<typename T, typename R = void>
      static const TraitHelper& _make_traits()
      {
         static const TraitHelper _helper { T::get_traits(), T::get_fieldcnt() };
         return _helper;
      }
#endif
   };

public:
   std::function<Message *(bool)> _do;
#if defined FIX8_HAVE_EXTENDED_METADATA
   const TraitHelper& (&_get_traits)();
#endif

   template<typename T, typename... args>
   Minst(Type2Type<T, args...>) : _do(_gen::_make<T, args...>)
#if defined FIX8_HAVE_EXTENDED_METADATA
       , _get_traits(_gen::_make_traits<T, args...>)
#endif
   {}
};

struct BaseMsgEntry
{
   const Minst _create;
   const char *_name, *_comment;
};

//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
using c_str_compare = std::function<bool(const char *, const char *)>;
using msg_create = std::function<Message *(bool)>;
using MsgTable = GeneratedTable<const char *, BaseMsgEntry>;
using ReverseMsgTable = std::map<const char * const, const BaseMsgEntry *, c_str_compare>;
using FieldTable = GeneratedTable<unsigned, BaseEntry>;
using ReverseFieldTable = std::map<const char * const, const BaseEntry *, c_str_compare>;

//-------------------------------------------------------------------------------------------------
struct F8MetaCntx
{
   const unsigned _version;

   const MsgTable& _bme;
   const FieldTable& _be;
   const char **_cn;
   const unsigned _flu_sz;
   const BaseEntry **_flu;
   msg_create _mk_hdr, _mk_trl;
   const f8String _beginStr;
   const size_t _preamble_sz;

   ReverseMsgTable _reverse_msgtable;
   ReverseFieldTable _reverse_fieldtable;
   static bool _comp(const char *p1, const char *p2) { return ::strcmp(p1, p2) < 0; }

   F8MetaCntx(const unsigned version, const MsgTable& bme, const FieldTable& be, const char **cn, const f8String& bg)
      : _version(version), _bme(bme), _be(be), _cn(cn),
      _flu_sz(_be.at(_be.size() - 1)->_key + 1), _flu(new const BaseEntry *[_flu_sz]),
      _mk_hdr(_bme.find_ref("header")._create._do), _mk_trl(_bme.find_ref("trailer")._create._do),
      _beginStr(bg), _preamble_sz(2 + _beginStr.size() + 1 + 3),
      _reverse_msgtable(_comp), _reverse_fieldtable(_comp)
   {
      if (_flu_sz == 1)
         throw f8Exception("F8MetaCntx initialisation incomplete");
      std::fill(_flu, _flu + _flu_sz, nullptr);
      for (unsigned offset(0); offset < _be.size(); ++offset)
         *(_flu + _be.at(offset)->_key) = &_be.at(offset)->_value;

      std::for_each(_be.begin(), _be.end(), [this](const FieldTable::Pair& pp)
         { _reverse_fieldtable.emplace(std::make_pair(pp.second()._name, &pp.second())); });
      std::for_each(_bme.begin(), _bme.end(), [this](const MsgTable::Pair& pp)
         { _reverse_msgtable.emplace(std::make_pair(pp.second()._name, &pp.second())); });
   }

   ~F8MetaCntx() { delete[] _flu; _flu = nullptr; }

   const BaseEntry *find_be(const unsigned short fnum) const
      { return fnum < _flu_sz ? _flu[fnum] : nullptr; }

   const BaseEntry *reverse_find_be(const char *fieldstr) const
   {
      if (fieldstr && *fieldstr)
      {
         auto itr(_reverse_fieldtable.find(fieldstr));
         return itr != _reverse_fieldtable.cend() ? itr->second : nullptr;
      }
      return nullptr;
   }

   unsigned short reverse_find_fnum(const char *fieldstr) const
   {
      if (fieldstr && *fieldstr)
      {
         auto itr(_reverse_fieldtable.find(fieldstr));
         return itr != _reverse_fieldtable.cend() ? itr->second->_fnum : 0;
      }
      return 0;
   }

   BaseField *create_field(unsigned short fnum, const char *from) const
   {
      const BaseEntry *be(find_be(fnum));
      return be ? be->_create._do(from, be->_rlm, -1) : nullptr;
   }

   BaseField *create_field(const char *tag, const char *from) const
   {
      const BaseEntry *be(reverse_find_be(tag));
      return be ? be->_create._do(from, be->_rlm, -1) : nullptr;
   }

   const BaseMsgEntry *find_bme(const char *tag) const { return _bme.find_ptr(tag); }

   const BaseMsgEntry *reverse_find_bme(const char *msgstr) const
   {
      auto itr(_reverse_msgtable.find(msgstr));
      return itr != _reverse_msgtable.cend() ? itr->second : nullptr;
   }

   Message *create_msg_from_longname(const char *tag, bool deepctor=true) const
   {
      const BaseMsgEntry *bme(reverse_find_bme(tag));
      return bme ? bme->_create._do(deepctor) : nullptr;
   }

   Message *create_msg(const char *tag, bool deepctor=true) const
   {
      const BaseMsgEntry *bme(find_bme(tag));
      return bme ? bme->_create._do(deepctor) : nullptr;
   }

   unsigned version() const { return _version; }

   const f8String& get_beginStr() const { return _beginStr; }

#if defined FIX8_HAVE_EXTENDED_METADATA
   //----------------------------------------------------------------------------------------------
   // The following methods can be used to iterate and interrogate static traits
   //----------------------------------------------------------------------------------------------
   using const_iterator = const FieldTrait*;
   using const_internal_result = std::pair<const_iterator, const_iterator>;
   static const_iterator find(unsigned short fnum, const TraitHelper& from)
   {
      const const_internal_result res(std::equal_range (from._traits, from._traits + from._fieldcnt,
         FieldTrait(fnum), FieldTrait::Compare()));
      return res.first != res.second ? res.first : nullptr;
   }

   static const_iterator begin(const TraitHelper& from) { return from._traits; }
   static const_iterator end(const TraitHelper& from) { return from._traits + from._fieldcnt; }
#endif
};

//-------------------------------------------------------------------------------------------------
using Fields = std::map <unsigned short, BaseField *>;
using Positions = std::multimap<unsigned short, BaseField *>;

class MessageBase
{
   f8String _unknown;

protected:
   Fields _fields;
   FieldTraits _fp;
   Positions _pos;
   Groups _groups;
   const f8String& _msgType;
   const F8MetaCntx& _ctx;

   static unsigned extract_header(const f8String& from, char *len, char *mtype);

   static unsigned extract_trailer(const f8String& from, f8String& chksum);

   // used by the printer
   F8API static unsigned _tabsize;

public:
   template<typename InputIterator>
   MessageBase(const struct F8MetaCntx& ctx, const f8String& msgType, const InputIterator begin, const size_t cnt,
      const FieldTrait_Hash_Array *ftha) : _fp(begin, cnt, ftha),
      _msgType(msgType), _ctx(ctx) {}

   F8API MessageBase(const MessageBase& from);
   F8API MessageBase& operator=(const MessageBase& that);

   virtual ~MessageBase() { clear(false); }

   virtual void clear(bool reuse=true)
   {
    std::for_each(_fields.begin(), _fields.end(), [](Fields::value_type& pp) { delete pp.second; pp.second = nullptr; });
    std::for_each(_groups.begin(), _groups.end(), [](Groups::value_type& pp) { delete pp.second; pp.second = nullptr; });
      if (reuse)
      {
         _fields.clear();
         //_groups.clear();
         _fp.clear_flag(FieldTrait::present);
         _pos.clear();
      }
   }

   void clear_positions() { _pos.clear(); }

   size_t size() const { return _fp.size(); }

   F8API unsigned decode(const f8String& from, unsigned offset, unsigned ignore=0, bool permissive_mode=false);

   unsigned decode_group(GroupBase *grpbase, const unsigned short fnum, const f8String& from,
      unsigned s_offset, unsigned ignore);

   F8API size_t encode(std::ostream& to) const;

   F8API size_t encode(char *to) const;

   F8API size_t encode_group(const unsigned short fnum, std::ostream& to) const;

   F8API size_t encode_group(const unsigned short fnum, char *to) const;

   virtual GroupBase *create_nested_group(unsigned short fnum) const { return nullptr; }

   F8API unsigned check_positions();

   F8API unsigned copy_legal(MessageBase *to, bool force=false) const;

   F8API unsigned move_legal(MessageBase *to, bool force=false);

   void push_unknown(MessageBase *to) const
   {
      if (_unknown.size() && to)
         to->_unknown = _unknown;
   }

   void check_set_rlm(BaseField *where) const
   {
      if (!where->_rlm)
      {
         const BaseEntry *tbe(_ctx.find_be(where->_fnum));
         if (tbe && tbe->_rlm)
            where->_rlm = tbe->_rlm;   // populate realm;
      }
   }

   const f8String& get_msgtype() const { return _msgType; }

   void add_field_decoder(const unsigned short fnum, const unsigned pos, BaseField *what)
   {
      _fields.insert({fnum, what});
      _pos.insert({pos, what});
   }

   void add_field(const unsigned short fnum, Presence::const_iterator itr, const unsigned pos, BaseField *what, bool check)
   {
      if (check && _fp.get(fnum, itr, FieldTrait::present)) // for now, silently replace duplicate
      {
         glout_debug << _msgType << " replacing field:" << fnum;
         delete replace(fnum, itr, what);
         return;
      }

      _fields.insert({fnum, what});
      _pos.insert({pos, what});
      _fp.set(fnum, itr, FieldTrait::present);
   }

   void add_field(const unsigned short fnum, Fields::iterator fitr, const unsigned pos, BaseField *what, bool check=true)
   {
      Presence::const_iterator itr(_fp.get_presence().end());
      if (check && _fp.get(fnum, itr, FieldTrait::present)) // for now, silently replace duplicate
      {
         glout_debug << _msgType << " replacing field:" << fnum;
         delete replace(fnum, itr, what);
         return;
      }

      _fields.insert(fitr, {fnum, what});
      _pos.insert({pos, what});
      _fp.set(fnum, itr, FieldTrait::present);
   }

   void add_field(const unsigned short fnum, const unsigned pos, BaseField *what, bool check=true)
   {
      Presence::const_iterator itr(_fp.get_presence().end());
      if (check && _fp.get(fnum, itr, FieldTrait::present)) // for now, silently replace duplicate
      {
         glout_debug << _msgType << " replacing field:" << fnum;
         delete replace(fnum, itr, what);
         return;
      }

      _fields.insert({fnum, what});
      _pos.insert({pos, what});
      _fp.set(fnum, itr, FieldTrait::present);
   }

   void set(const unsigned short field, FieldTrait::TraitTypes type=FieldTrait::present) { _fp.set(field, type); }

   template<typename T>
   bool add_field(T *what)
   {
      Presence::const_iterator itr(_fp.get_presence().end());
      if (_fp.has(T::get_field_id(), itr))
      {
         add_field(T::get_field_id(), itr, _fp.getPos(T::get_field_id(), itr), what, true);
         return true;
      }
      throw InvalidField(T::get_field_id());
      return false;
   }

   bool add_field(BaseField *what)
   {
      const unsigned short& fnum(what->_fnum);
      Presence::const_iterator itr(_fp.get_presence().end());
      if (_fp.has(fnum, itr))
      {
         add_field(fnum, itr, _fp.getPos(fnum, itr), what, true);
         return true;
      }
      throw InvalidField(fnum);
      return false;
   }

   Groups& get_groups() { return _groups; }

   template<typename T>
   bool operator+=(T *what) { return add_field(what); }

   template<typename T>
   MessageBase& operator<<(T *what) { add_field(what); return *this; }

   template<typename T>
   bool get(T& to) const
   {
      Fields::const_iterator fitr(_fields.find(T::get_field_id()));
      if (fitr == _fields.end())
         return false;
      to.set(fitr->second->from<T>().get());
      if (fitr->second->_rlm)
         to._rlm = fitr->second->_rlm;
      return true;
   }

   template<typename T>
   bool has() const { return _fp.get(T::get_field_id()); }

   bool is_legal(unsigned short fnum) const { return _fp.has(fnum); }

   template<typename T>
   bool is_legal() const { return _fp.has(T::get_field_id()); }

   template<typename T>
   const T *get() const
   {
      Fields::const_iterator fitr(_fields.find(T::get_field_id()));
      return fitr == _fields.cend() ? nullptr : &fitr->second->from<T>();
   }

   template<typename T>
   bool operator()(T& to) const { return get(to); }

   template<typename T>
   const T *operator()() const { return get<T>(); }

   bool have(const unsigned short fnum) const { return _fp.get(fnum, FieldTrait::present); }

   Fields::const_iterator find_field(const unsigned short fnum) const { return _fields.find(fnum); }

   BaseField *get_field(const unsigned short fnum) const
   {
      auto itr(_fields.find(fnum));
      return itr != _fields.cend() ? itr->second : nullptr;
   }

   BaseField *get_field_by_name(const char *tag) const
   {
      auto itr(_fields.find(_ctx.reverse_find_fnum(tag)));
      return itr != _fields.cend() ? itr->second : nullptr;
   }

   Fields::const_iterator fields_begin() const { return _fields.begin(); }

   Fields::const_iterator fields_end() const { return _fields.end(); }

   F8API BaseField *replace(const unsigned short fnum, Presence::const_iterator itr, BaseField *with);

   F8API BaseField *replace(const unsigned short fnum, BaseField *with);

   F8API GroupBase *replace(const unsigned short fnum, GroupBase *with);

   F8API BaseField *remove(const unsigned short fnum, Presence::const_iterator itr);

   F8API BaseField *remove(const unsigned short fnum);

   template<typename T>
   GroupBase *find_group() const { return find_group(T::_fnum); }

   GroupBase *find_group(const unsigned short fnum) const
   {
      auto gitr(_groups.find(fnum));
      return gitr != _groups.cend() ? gitr->second : nullptr;
   }

   template<typename T>
   GroupBase *find_add_group(GroupBase *grpbase=nullptr) { return find_add_group(T::_fnum, grpbase); }

   GroupBase *find_add_group(const unsigned short fnum, GroupBase *grpbase=nullptr)
   {
      auto gitr(_groups.find(fnum));
      if (gitr != _groups.end())
         return gitr->second;
      GroupBase *gb1(grpbase ? grpbase->create_nested_group(fnum) : create_nested_group(fnum));
      add_group(gb1);
      return gb1;
   }

   template<typename T>
   void append_group(T *what) { _groups.insert(_groups.end(), {T::_fnum, what}); }

   void add_group(GroupBase *what) { _groups.insert({what->_fnum, what}); }

   MessageBase& operator<<(GroupBase *what) { add_group(what); return *this; }

   void operator+=(GroupBase *what) { add_group(what); }

   unsigned short getPos(const unsigned short field) const { return _fp.getPos(field); }

   bool add_trait(const FieldTrait& what) { return _fp.add(what); }

   template<typename InputIterator>
   void add_trait(const InputIterator begin, const size_t cnt) { _fp.add(begin, cnt); }

   F8API virtual void print(std::ostream& os, int depth=0) const;

   F8API virtual void print_field(const unsigned short fnum, std::ostream& os) const;

   F8API virtual void print_group(const unsigned short fnum, std::ostream& os, int depth=0) const;

   const FieldTraits& get_fp() const { return _fp; }

   static unsigned extract_element(const char *from, const unsigned sz, char *tag, char *val)
   {
      enum { get_tag, get_value } state(get_tag);

      for (unsigned ii(0); ii < sz; ++ii)
      {
         switch (state)
         {
         case get_tag:
            if (!isdigit(from[ii]))
            {
               if (from[ii] != default_assignment_separator)
                  return *val = *tag = 0;
               state = get_value;
            }
            else
               *tag++ = from[ii];
            break;
         case get_value:
            if (from[ii] == default_field_separator)
            {
               *val = *tag = 0;
               return ++ii;
            }
            *val++ = from[ii];
            break;
         }
      }
      return *val = *tag = 0;
   }

   static unsigned extract_element_fixed_width(const char *from, const unsigned sz, const unsigned val_sz, char *tag, char *val)
   {
      *val = *tag = 0;
      for (unsigned ii(0); ii < sz; ++ii)
      {
         if(isdigit(from[ii]))
         {
            *tag++ = from[ii];
            continue;
         }

         if (from[ii++] != default_assignment_separator || sz < (ii + val_sz))
            break;

         ::memcpy(val, &from[ii], val_sz);
         val[val_sz] = 0;
         return ii + val_sz + 1; // account for field separator
      }
      return *val = *tag = 0;
   }

   static unsigned extract_element(const char *from, const unsigned sz, f8String& tag, f8String& val)
   {
      enum { get_tag, get_value } state(get_tag);
      tag.clear();
      val.clear();

      for (unsigned ii(0); ii < sz; ++ii)
      {
         switch (state)
         {
         case get_tag:
            if (!isdigit(from[ii]))
            {
               if (from[ii] != default_assignment_separator)
                  return 0;
               state = get_value;
            }
            else
               tag += from[ii];
            break;
         case get_value:
            if (from[ii] == default_field_separator)
               return ++ii;
            val += from[ii];
            break;
         }
      }
      return 0;
   }

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

   static void set_tabsize (unsigned tabsize) { _tabsize = tabsize; }

   static unsigned get_tabsize () { return _tabsize; }

   static bool has_group_count(const BaseField *bf) { return static_cast<const Field<int, 0> *>(bf)->get() > 0; }

   void print_fp(std::ostream& os) { os << _fp; }

   virtual begin_string *get_begin_string() { return nullptr; }

   virtual body_length *get_body_length() { return nullptr; }

   virtual msg_type *get_msg_type() { return nullptr; }

   virtual check_sum *get_check_sum() { return nullptr; }

   const f8String& get_unknown() const { return _unknown; }
};

//-------------------------------------------------------------------------------------------------
inline void GroupBase::clear(bool reuse)
{
   std::for_each (_msgs.begin(), _msgs.end(), [](MessageBase *pp) { delete pp; });
   if (reuse)
      _msgs.clear();
}

//-------------------------------------------------------------------------------------------------
#if defined FIX8_CODECTIMING
struct codec_timings
{
   double _cpu_used;
   unsigned _msg_count;

   codec_timings() : _cpu_used(), _msg_count() {}
};

#endif

//-------------------------------------------------------------------------------------------------
#if defined FIX8_SIZEOF_UNSIGNED_LONG && FIX8_SIZEOF_UNSIGNED_LONG == 8
#ifndef _MSC_VER
constexpr unsigned long COLLAPSE_INT64(unsigned long x)
      { return x + (x >> 8) + (x >> 16) + (x >> 24) + (x >> 32) + (x >> 40) + (x >> 48) + (x >> 56); }
#else
#define COLLAPSE_INT64(x) (x + (x >> 8) + (x >> 16) + (x >> 24) + (x >> 32) + (x >> 40) + (x >> 48) + (x >> 56))
#endif
#endif

//-------------------------------------------------------------------------------------------------
class Message : public MessageBase
{
#if defined FIX8_CODECTIMING
   static codec_timings _encode_timings, _decode_timings;
#endif

protected:
   MessageBase *_header, *_trailer;
   unsigned _custom_seqnum;
   bool _no_increment, _end_of_batch;
#if defined FIX8_RAW_MSG_SUPPORT
   mutable f8String _rawmsg;
   mutable int _begin_payload = -1;
   mutable unsigned _payload_len = 0;
#endif
#if defined FIX8_PREENCODE_MSG_SUPPORT
   mutable std::array<char, FIX8_MAX_MSG_LENGTH> _preencode;
   mutable size_t _preencode_len = 0;
#endif

public:
   template<typename InputIterator>
   Message(const F8MetaCntx& ctx, const f8String& msgType, const InputIterator begin, const size_t cnt,
      const FieldTrait_Hash_Array *ftha)
      : MessageBase(ctx, msgType, begin, cnt, ftha),_header(ctx._mk_hdr(true)),
        _trailer(ctx._mk_trl(true)), _custom_seqnum(), _no_increment(), _end_of_batch(true)
   {}

   virtual ~Message() { delete _header; delete _trailer; }

   MessageBase *Header() const { return _header; }

   MessageBase *Trailer() const { return _trailer; }

   MessageBase *Header() { return _header; }

   MessageBase *Trailer() { return _trailer; }

   unsigned decode(const f8String& from, unsigned offset=0, unsigned ignore=0, bool permissive_mode=false)
   {
      const unsigned hlen(_header->decode(from, offset, 0, permissive_mode));
      const unsigned blen(MessageBase::decode(from, hlen, 0, permissive_mode));
#if defined FIX8_RAW_MSG_SUPPORT
      _begin_payload = hlen;
      _payload_len = blen;
      _rawmsg = from;
#endif
      return _trailer->decode(from, blen, ignore, permissive_mode);
   }

   F8API size_t encode(f8String& to) const;

   F8API size_t encode(char **to) const;

   F8API Message *clone() const;

   virtual bool process(Router& rt) const { return (rt)(this); }

   virtual bool is_admin() const { return false; }

   virtual void clear(bool reuse=true)
   {
      if (_header)
         _header->clear(reuse);
      if (_trailer)
         _trailer->clear(reuse);
      MessageBase::clear(reuse);
   }

   static unsigned calc_chksum(const char *from, const size_t sz, const unsigned offset=0, const int len=-1)
   {
#if defined FIX8_SIZEOF_UNSIGNED_LONG && FIX8_SIZEOF_UNSIGNED_LONG == 8
      // steroid chksum algorithm by charles.cooper@lambda-tg.com
      // Basic strategy is to unroll the loop. normally adding in a loop
      // is slow because of the dependency, the cpu has to finish each loop
      // before it starts the next one and is unable to pipeline. one
      // way to get around this is to have multiple registers and have
      // multiple adds per loop, then consolidating at the end
      // as in unroll_checksum.
      // that is slow though because there is a lot of wasted space and
      // the cpu has to do a lot of adds.
      // key is that addition of a word is going to be faster
      // than addition of two chars, and also each word has 8 chars in it.
      // so we get 8 adds per loop. long1 + long2 is almost like
      // looping over two arrays of 8 chars and adding them element wise.
      // except for the overflow. so we have to keep track of the overflow
      // and get rid of it at the end.

      const unsigned long OVERFLOW_MASK (1UL << 8 | 1UL << 16 | 1UL << 24 | 1UL << 32 | 1UL << 40 | 1UL << 48 | 1UL << 56);
      unsigned long ret{}, overflow{};
      from += offset;
      const unsigned long elen (len != -1 ? len : sz);
      size_t ii{};
      for (; ii < (elen - elen % 8); ii += 8)
      {
         unsigned long expected_overflow((ret & OVERFLOW_MASK) ^ (OVERFLOW_MASK & *reinterpret_cast<const unsigned long*>(from + ii)));
         ret += *reinterpret_cast<const unsigned long*>(from + ii);
         overflow += (expected_overflow ^ ret) & OVERFLOW_MASK;
      }
      ret = COLLAPSE_INT64(ret);
      overflow = COLLAPSE_INT64(overflow);
      for (; ii < elen; ret += from[ii++]); // add up rest one by one
      return (ret - overflow) & 0xff;
#else
      // native chksum algorithm
      unsigned val(0);
      const char *eptr(from + (len != -1 ? len + offset : sz - offset));
      for (const char *ptr(from + offset); ptr < eptr; val += *ptr++);
      return val % 256;
#endif
   }

   static unsigned calc_chksum(const f8String& from, const unsigned offset=0, const int len=-1)
      { return calc_chksum(from.c_str(), from.size(), offset, len); }

   static f8String fmt_chksum(const unsigned val)
   {
      char buf[4] { '0', '0', '0', 0 };
      itoa<unsigned>(val, buf + (val > 99 ? 0 : val > 9 ? 1 : 2), 10);
      return f8String(buf);
   }

   static Message *factory(const F8MetaCntx& ctx, const char *from, bool no_chksum=false, bool permissive_mode=false)
   {
      const f8String to(from);
      return factory(ctx, to, no_chksum, permissive_mode);
   }

   F8API static Message *factory(const F8MetaCntx& ctx, const f8String& from, bool no_chksum=false, bool permissive_mode=false);

   virtual void set_custom_seqnum(unsigned seqnum) { _custom_seqnum = seqnum; }

   unsigned get_custom_seqnum() const { return _custom_seqnum; }

   virtual void set_no_increment(bool flag=true) { _no_increment = flag; }

   virtual bool get_no_increment() const { return _no_increment; }

   bool get_end_of_batch() const { return _end_of_batch; }

   void set_end_of_batch(bool is_end_of_batch) { _end_of_batch = is_end_of_batch; }

   void setup_reuse()
   {
      if (_header)
      {
         _header->_fp.set(Common_BeginString, FieldTrait::suppress);
         _header->_fp.set(Common_BodyLength, FieldTrait::suppress);
         delete _header->remove(Common_MsgSeqNum);
      }
      if (_trailer)
         _trailer->_fp.set(Common_CheckSum, FieldTrait::suppress);
   }

   void push_unknown(Message *to) const
   {
      if (_header)
         _header->push_unknown(to->_header);
      MessageBase::push_unknown(to);
      if (_trailer)
         _trailer->push_unknown(to->_trailer);
   }

   BaseField *get_field_flattened(const unsigned short fnum) const
   {
      auto itr (_fields.find(fnum));
      return  itr != _fields.end() ? itr->second
            : (itr = _header->_fields.find(fnum)) != _header->_fields.end() ? itr->second
            : (itr = _trailer->_fields.find(fnum)) != _trailer->_fields.end() ? itr->second : nullptr;
   }

   BaseField *get_field_by_name_flattened(const char *tag) const
   {
      return get_field_flattened(_ctx.reverse_find_fnum(tag));
   }

#if defined FIX8_RAW_MSG_SUPPORT

   const f8String& get_rawmsg() const { return _rawmsg; }

   f8String::const_iterator begin_payload() const { return f8String::const_iterator(_rawmsg.data() + _begin_payload); }

   f8String::const_iterator end_payload() const { return f8String::const_iterator(_rawmsg.data() + _begin_payload + _payload_len); }

   unsigned get_payload_len() const { return _payload_len; }

   unsigned get_payload_begin() const { return _begin_payload; }
#endif
#if defined FIX8_PREENCODE_MSG_SUPPORT

   const char *get_preencode_msg() const { return _preencode_len ? _preencode.data() : nullptr; }

   size_t get_preencode_len() const { return _preencode_len; }

   size_t preencode() { return _preencode_len = MessageBase::encode(_preencode.data()); }
#endif

   F8API virtual void print(std::ostream& os, int depth=0) const;

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

#if defined FIX8_CODECTIMING
   F8API static void format_codec_timings(const f8String& md, std::ostream& ostr, codec_timings& tobj);
   F8API static void report_codec_timings(const f8String& tag);
#endif
};

//-------------------------------------------------------------------------------------------------
inline std::ostream& operator<<(std::ostream& os, const GroupBase& what)
{
   for (const auto *pp : what._msgs)
      pp->print(os);
   return os;
}

} // FIX8

#endif // FIX8_MESSAGE_HPP_