traits.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_TRAITS_HPP_
#define FIX8_TRAITS_HPP_

#include <set>

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

//-------------------------------------------------------------------------------------------------
#if defined FIX8_HAVE_EXTENDED_METADATA
struct TraitHelper
{
   const struct FieldTrait *_traits;
   const unsigned _fieldcnt;
};
#endif

//-------------------------------------------------------------------------------------------------
struct FieldTrait
{
   enum FieldType
   {
      ft_untyped,
      ft_int,
      ft_Length, ft_TagNum, ft_SeqNum, ft_NumInGroup, ft_DayOfMonth, ft_end_int=ft_DayOfMonth,
      ft_char,
      ft_Boolean, ft_end_char=ft_Boolean,
      ft_float,
      ft_Qty, ft_Price, ft_PriceOffset, ft_Amt, ft_Percentage, ft_end_float=ft_Percentage,
      ft_string,
      ft_MultipleCharValue, ft_MultipleStringValue, ft_Country, ft_Currency, ft_Exchange,
      ft_MonthYear, ft_UTCTimestamp, ft_UTCTimeOnly, ft_UTCDateOnly, ft_LocalMktDate, ft_TZTimeOnly, ft_TZTimestamp,
      ft_data, ft_XMLData,
      ft_pattern,
      ft_Tenor, ft_Reserved100Plus, ft_Reserved1000Plus, ft_Reserved4000Plus,
      ft_Language, ft_end_string=ft_Language
   };

   enum TraitTypes { mandatory, present, position, group, component, suppress, automatic, count };

   static bool is_int(FieldType ftype) { return ft_int <= ftype && ftype <= ft_end_int; }

   static bool is_char(FieldType ftype) { return ft_char <= ftype && ftype <= ft_end_char; }

   static bool is_float(FieldType ftype) { return ft_float <= ftype && ftype <= ft_end_float; }

   static bool is_string(FieldType ftype) { return ft_string <= ftype && ftype <= ft_end_string; }

   static FieldType underlying_type(FieldType ftype)
   {
      return is_int(ftype) ? ft_int : is_char(ftype) ? ft_char : is_float(ftype) ? ft_float : is_string(ftype) ? ft_string : ft_untyped;
   }

   FieldTrait() = default;

   FieldTrait(const FieldTrait& from) : _fnum(from._fnum), _ftype(from._ftype), _pos(from._pos),
      _component(from._component), _field_traits(from._field_traits) {}

   FieldTrait(unsigned short fnum, unsigned ftype, unsigned short pos, unsigned short compon, unsigned short field_traits
#if defined FIX8_HAVE_EXTENDED_METADATA
      , const FieldTrait *group=nullptr, unsigned fieldcnt=0
#endif
      )
      : _fnum(fnum), _ftype(FieldType(ftype)), _pos(pos), _component(compon), _field_traits(field_traits)
#if defined FIX8_HAVE_EXTENDED_METADATA
      , _group(TraitHelper{group, fieldcnt})
#endif
   {}

   FieldTrait(const unsigned short field) : _fnum(field) {}

   FieldTrait(const unsigned short field, const FieldType ftype, const unsigned short pos=0,
      bool ismandatory=false, bool isgroup=false, const unsigned compon=0, bool ispresent=false) :
      _fnum(field), _ftype(ftype), _pos(pos), _component(compon),
      _field_traits((ismandatory ? 1 : 0) | (ispresent ? 1 : 0) << present
      | (pos ? 1 : 0) << position | (isgroup ? 1 : 0) << group | (compon ? 1 : 0) << component) {}

   unsigned short _fnum;
   FieldType _ftype;
   mutable unsigned short _pos, _component;
   mutable ebitset<TraitTypes, unsigned short> _field_traits;
#if defined FIX8_HAVE_EXTENDED_METADATA
    const TraitHelper _group = TraitHelper{ nullptr, 0 };
#endif

   struct Compare
   {
      bool operator()(const FieldTrait& p1, const FieldTrait& p2) const { return p1._fnum < p2._fnum; }
   };

   struct PosCompare
   {
      bool operator()(const FieldTrait* p1, const FieldTrait* p2) const
         { return p1->_pos < p2->_pos; }
   };

   static F8API std::string& get_type_string(FieldType ftype, std::string& to);

   friend F8API std::ostream& operator<<(std::ostream& os, const FieldTrait& what);
};

F8API std::ostream& operator<<(std::ostream& os, const FieldTrait& what);

//-------------------------------------------------------------------------------------------------
struct FieldTrait_Hash_Array
{
   const unsigned _els, _sz;
   unsigned short *_arr;

   FieldTrait_Hash_Array(const FieldTrait *from, const size_t els)
      : _els(static_cast<unsigned>(els)), _sz((from + _els - 1)->_fnum + 1), _arr(new unsigned short [_sz])
   {
      std::fill(_arr, _arr + _sz, 0);
      for (unsigned offset(0); offset < _els; ++offset)
         *(_arr + (from + offset)->_fnum) = offset;
   }

   ~FieldTrait_Hash_Array() { delete[] _arr; }
};

//-------------------------------------------------------------------------------------------------
template<>
class presorted_set<unsigned short, FieldTrait, FieldTrait::Compare>
{
public:
   using iterator = FieldTrait*;
   using const_iterator = const FieldTrait*;
   using result = std::pair<iterator, bool>;

   static size_t calc_reserve(size_t sz, size_t res)
   {
      if (!sz)  // special case - reserve means number to reserve, not %
         return res;
      const size_t val(sz * res / 100);
      return val ? val : 1;
   }

private:
   size_t _reserve;
   size_t _sz, _rsz;
   FieldTrait *_arr;
   const FieldTrait_Hash_Array *_ftha;

   using internal_result = std::pair<iterator, iterator>;
   using const_internal_result = std::pair<const_iterator, const_iterator>;

public:
   presorted_set(const_iterator arr_start, const size_t sz, const FieldTrait_Hash_Array *ftha)
      : _reserve(), _sz(sz), _arr(new FieldTrait[_sz]), _ftha(ftha)
         { memcpy(_arr, arr_start, _sz * sizeof(FieldTrait)); }

   presorted_set(const_iterator arr_start, const size_t sz, const size_t reserve=FIX8_RESERVE_PERCENT) : _reserve(reserve),
      _sz(sz), _rsz(_sz + calc_reserve(_sz, _reserve)), _arr(new FieldTrait[_rsz]), _ftha()
         { memcpy(_arr, arr_start, _sz * sizeof(FieldTrait)); }

   presorted_set(const presorted_set& from) : _reserve(from._reserve),
      _sz(from._sz), _rsz(from._rsz), _arr(new FieldTrait[_rsz]), _ftha(from._ftha)
         { memcpy(_arr, from._arr, _sz * sizeof(FieldTrait)); }

   explicit presorted_set(const size_t sz=0, const size_t reserve=FIX8_RESERVE_PERCENT) : _reserve(reserve),
      _sz(sz), _rsz(_sz + calc_reserve(_sz, _reserve)), _arr(), _ftha() {}

   ~presorted_set() { delete[] _arr; }

   iterator find(const FieldTrait what, bool& answer)
   {
      if (_ftha)
         return (answer = what._fnum < _ftha->_sz && (_arr + _ftha->_arr[what._fnum])->_fnum == what._fnum) ? _arr + _ftha->_arr[what._fnum] : 0;
      const internal_result res(std::equal_range (_arr, _arr + _sz, what, FieldTrait::Compare()));
      answer = res.first != res.second;
      return res.first;
   }

   iterator find(const unsigned short key, bool& answer) { return find(FieldTrait(key), answer); }

   const_iterator find(const unsigned short key) const
   {
      if (_ftha)
         return key < _ftha->_sz && (_arr + _ftha->_arr[key])->_fnum == key ? _arr + _ftha->_arr[key] : end();
      const FieldTrait what(key);
      const const_internal_result res(std::equal_range (_arr, _arr + _sz, what, FieldTrait::Compare()));
      return res.first != res.second ? res.first : end();
   }

   const_iterator find(const FieldTrait what) const
   {
      if (_ftha)
         return what._fnum < _ftha->_sz && (_arr + _ftha->_arr[what._fnum])->_fnum == what._fnum ? _arr + _ftha->_arr[what._fnum] : end();
      const const_internal_result res(std::equal_range (_arr, _arr + _sz, what, FieldTrait::Compare()));
      return res.first != res.second ? res.first : end();
   }

   iterator find(const unsigned short key)
   {
      if (_ftha)
         return key < _ftha->_sz && (_arr + _ftha->_arr[key])->_fnum == key ? _arr + _ftha->_arr[key] : end();
      const FieldTrait what(key);
      internal_result res(std::equal_range (_arr, _arr + _sz, what, FieldTrait::Compare()));
      return res.first != res.second ? res.first : end();
   }

   iterator find(const FieldTrait what)
   {
      internal_result res(std::equal_range (_arr, _arr + _sz, what, FieldTrait::Compare()));
      return res.first != res.second ? res.first : end();
   }

   const_iterator at(const size_t idx) const { return idx < _sz ? _arr + idx : end(); }

   result insert(const_iterator what)
   {
      if (!_sz)
      {
         _arr = new FieldTrait[_rsz];
         memcpy(_arr, what, sizeof(FieldTrait));
         ++_sz;
         return std::make_pair(_arr, true);
      }

      bool answer;
      iterator where(find(*what, answer));
      if (answer) // sorry already here
         return std::make_pair(end(), false);

      if (_sz < _rsz) // we have space
      {
         memmove(where + 1, where, (end() - where) * sizeof(FieldTrait));
         memcpy(where, what, sizeof(FieldTrait));
      }
      else // we have to make space
      {
         iterator new_arr(new FieldTrait[_rsz = _sz + calc_reserve(_sz, _reserve)]);
         const size_t wptr(where - _arr);
         if (wptr > 0)
            memcpy(new_arr, _arr, sizeof(FieldTrait) * wptr);
         memcpy(new_arr + wptr, what, sizeof(FieldTrait));
         memcpy(new_arr + wptr + 1, where, (end() - where) * sizeof(FieldTrait));
         delete[] _arr;
         _arr = new_arr;
      }
      ++_sz;
      return std::make_pair(where, true);
   }

   static size_t distance(const_iterator what_begin, const_iterator what_end)
      { return what_end - what_begin; }

   void insert(const_iterator what_begin, const_iterator what_end)
   {
      for (const_iterator ptr(what_begin); ptr < what_end; ++ptr)
         if (!insert(ptr).second)
            break;
   }

   void clear() { _sz = 0; }

   size_t size() const { return _sz; }

   bool empty() const { return _sz == 0; }

   size_t rsize() const { return _rsz; }

   iterator begin() { return _arr; }

   iterator end() { return _arr + _sz; }

   const_iterator begin() const { return _arr; }

   const_iterator end() const { return _arr + _sz; }
};

//-------------------------------------------------------------------------------------------------
using Presence = presorted_set<unsigned short, FieldTrait, FieldTrait::Compare>;

class FieldTraits
{
   Presence _presence;

public:
   template<typename InputIterator>
   FieldTraits(const InputIterator begin, const size_t cnt,
      const FieldTrait_Hash_Array *ftha) : _presence(begin, cnt, ftha) {}
   FieldTraits() {}

   bool has(const unsigned short field, Presence::const_iterator& itr) const
   {
      if (itr == _presence.end())
         itr = _presence.find(field);
      return itr != _presence.end();
   }

   bool has(const unsigned short field) const
   {
      Presence::const_iterator itr(_presence.find(field));
      return itr != _presence.end();
   }

   unsigned getval(const unsigned short field)
   {
      Presence::const_iterator itr(_presence.find(field));
      return itr != _presence.end() ? itr->_field_traits.get() : 0;
   }

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

   bool get(const unsigned short field, FieldTrait::TraitTypes type=FieldTrait::present) const
   {
      Presence::const_iterator itr(_presence.find(field));
      return itr != _presence.end() ? itr->_field_traits.has(type) : false;
   }

   bool get(const unsigned short field, Presence::const_iterator& itr, FieldTrait::TraitTypes type) const
   {
      if (itr != _presence.end())
         return itr->_field_traits.has(type);
      itr = _presence.find(field);
      return itr != _presence.end() ? itr->_field_traits.has(type) : false;
   }

   unsigned short find_missing(FieldTrait::TraitTypes type=FieldTrait::mandatory) const
   {
      for (Presence::const_iterator itr(_presence.begin()); itr != _presence.end(); ++itr)
         if ((itr->_field_traits & type) && (itr->_field_traits & FieldTrait::present) == 0)
            return itr->_fnum;
      return 0;
   }

   void set(const unsigned short field, Presence::const_iterator& itr, FieldTrait::TraitTypes type)
   {
      if (itr == _presence.end())
      {
         itr = _presence.find(field);
         if (itr != _presence.end())
            itr->_field_traits.set(type);
      }
      else
         itr->_field_traits.set(type);
   }

   void set(const unsigned short field, FieldTrait::TraitTypes type=FieldTrait::present)
   {
      Presence::iterator itr(_presence.find(field));
      if (itr != _presence.end())
         itr->_field_traits.set(type);
   }

   void clear(const unsigned short field, Presence::const_iterator& itr, FieldTrait::TraitTypes type=FieldTrait::present)
   {
      if (itr == _presence.end())
      {
         itr = _presence.find(field);
         if (itr != _presence.end())
            itr->_field_traits.clear(type);
      }
      else
         itr->_field_traits.clear(type);
   }

   void clear(const unsigned short field, FieldTrait::TraitTypes type=FieldTrait::present)
   {
      Presence::iterator itr(_presence.find(field));
      if (itr != _presence.end())
         itr->_field_traits.clear(type);
   }

   bool add(const FieldTrait& what) { return _presence.insert(&what).second; }

   template<typename InputIterator>
   void add(const InputIterator begin, const size_t cnt) { _presence.insert(begin, begin + cnt); }

   void clear_flag(FieldTrait::TraitTypes type=FieldTrait::present)
      { for (Presence::const_iterator itr(_presence.begin()); itr != _presence.end(); itr++->_field_traits.clear(type)); }

   bool is_present(const unsigned short field) const { return get(field, FieldTrait::present); }

   bool is_mandatory(const unsigned short field) const { return get(field, FieldTrait::mandatory); }

   bool is_group(const unsigned short field, Presence::const_iterator& itr) const { return get(field, itr, FieldTrait::group); }

   bool is_group(const unsigned short field) const { return get(field, FieldTrait::group); }

   bool is_component(const unsigned short field) const { return get(field, FieldTrait::component); }

   unsigned short getComp(const unsigned short field, Presence::const_iterator& itr) const
   {
      if (itr != _presence.end())
         return itr->_component;
      itr = _presence.find(field);
      return itr != _presence.end() ? itr->_component : 0;
   }

   unsigned short getComp(const unsigned short field) const
   {
      Presence::const_iterator itr(_presence.find(field));
      return itr != _presence.end() ? itr->_component : 0;
   }

   unsigned short getPos(const unsigned short field, Presence::const_iterator& itr) const
   {
      if (itr != _presence.end())
         return itr->_field_traits.has(FieldTrait::position) ? itr->_pos : 0;
      itr = _presence.find(field);
      return itr != _presence.end() && itr->_field_traits.has(FieldTrait::position) ? itr->_pos : 0;
   }

   unsigned short getPos(const unsigned short field) const
   {
      Presence::const_iterator itr(_presence.find(field));
      return itr != _presence.end() && itr->_field_traits.has(FieldTrait::position) ? itr->_pos : 0;
   }

   const Presence& get_presence() const { return _presence; }

   friend F8API std::ostream& operator<<(std::ostream& os, const FieldTraits& what);
};

F8API std::ostream& operator<<(std::ostream& os, const FieldTraits& what);

} // FIX8

#endif // FIX8_TRAITS_HPP_