f8types.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/>.

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_TYPES_HPP_
#define FIX8_TYPES_HPP_

//-------------------------------------------------------------------------------------------------
#include <map>
#include <algorithm>

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

//-------------------------------------------------------------------------------------------------
using f8String = std::string;
#if defined FIX8_USE_SINGLE_PRECISION
using fp_type = float;
#else
using fp_type = double;
#endif

//-------------------------------------------------------------------------------------------------
enum ProcessModel { pm_thread, pm_pipeline, pm_coro, pm_count };

const unsigned char default_field_separator(0x1);

const unsigned char default_assignment_separator('=');

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

template<typename Key, typename Val>
struct _pair
{
   Key _key;
   Val _value;

   const Key& first() const { return _key; }
   const Val& second() const { return _value; }

   static bool Less(const _pair& p1, const _pair& p2) { return p1._key < p2._key; }
};


template<typename Val>
struct _pair<const char *, Val>
{
   const char *_key;
   Val _value;

   const char *first() const { return _key; }
   const Val& second() const { return _value; }

   static bool Less(const _pair& p1, const _pair& p2) { return ::strcmp(p1._key, p2._key) < 0; }
};


template<typename Key, typename Val>
class GeneratedTable
{
public:
   using Pair = _pair<Key, Val>;
   using iterator = Pair*;
   using const_iterator = const Pair*;

#ifndef _MSC_VER
private:
#endif
   const_iterator _pairs;

   const size_t _pairsz;

   const_iterator _find(const Key& key) const
   {
      const_iterator res(std::lower_bound (begin(), end(), reinterpret_cast<const Pair&>(key), Pair::Less));
      return res != end() && !Pair::Less(reinterpret_cast<const Pair&>(key), *res) ? res : nullptr;
   }

public:
   GeneratedTable(const_iterator pairs, const size_t pairsz)
      : _pairs(pairs), _pairsz(pairsz) {}

   const_iterator begin() const { return _pairs; }

   const_iterator end() const { return _pairs + _pairsz; }

   const Val& find_ref(const Key& key) const
   {
      const_iterator res(_find(key));
      if (res)
         return res->_value;
      throw InvalidMetadata<Key>(key);
   }

   const Val *find_ptr(const Key& key) const
   {
      const_iterator res(_find(key));
      return res ? &res->_value : nullptr;
   }

   const_iterator find_pair_ptr(const Key& key) const
   {
      const_iterator res(_find(key));
      return res ? res : nullptr;
   }

   const_iterator at(const size_t idx) const { return idx < _pairsz ? _pairs + idx : nullptr; }

   size_t size() const { return _pairsz; }
};

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

template<typename K, typename T, typename Comp>
class presorted_set
{
public:
   using iterator = T*;
   using const_iterator = const T*;
   using result = std::pair<iterator, bool>;

private:
   const size_t _reserve;
   size_t _sz, _rsz;
   T *_arr;

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

   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;
   }

public:
   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 T[_rsz])
         { memcpy(_arr, arr_start, _sz * sizeof(T)); }

   presorted_set(const presorted_set& from) : _reserve(from._reserve),
      _sz(from._sz), _rsz(from._rsz), _arr(from._arr ? new T[_rsz] : 0)
         { if (_arr) memcpy(_arr, from._arr, _sz * sizeof(T)); }

   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() {}

   ~presorted_set() { delete[] _arr; }

   iterator find(const T what, bool& answer)
   {
      const internal_result res(std::equal_range (_arr, _arr + _sz, what, Comp()));
      answer = res.first != res.second;
      return res.first;
   }

   iterator find(const K key, bool& answer) { return find(T(key), answer); }

   const_iterator find(const K key) const { return find(T(key)); }

   const_iterator find(const T what) const
   {
      const const_internal_result res(std::equal_range (_arr, _arr + _sz, what, Comp()));
      return res.first != res.second ? res.first : end();
   }

   iterator find(const K key) { return find(T(key)); }

   iterator find(const T what)
   {
      internal_result res(std::equal_range (_arr, _arr + _sz, what, Comp()));
      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 T[_rsz];
         memcpy(_arr, what, sizeof(T));
         ++_sz;
         return result(_arr, true);
      }

      bool answer;
      iterator where(find(*what, answer));
      if (answer)
         return result(end(), false);

      if (_sz < _rsz)
      {
         memmove(where + 1, where, (end() - where) * sizeof(T));
         memcpy(where, what, sizeof(T));
      }
      else
      {
         iterator new_arr(new T[_rsz = _sz + calc_reserve(_sz, _reserve)]);
         const size_t wptr(where - _arr);
         if (wptr > 0)
            memcpy(new_arr, _arr, sizeof(T) * wptr);
         memcpy(new_arr + wptr, what, sizeof(T));
         memcpy(new_arr + wptr + 1, where, (end() - where) * sizeof(T));
         delete[] _arr;
         _arr = new_arr;
      }
      ++_sz;
      return result(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; }
};

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

template<typename T, typename... args> struct Type2Type {};

//-------------------------------------------------------------------------------------------------
struct null_insert { template <typename T> null_insert& operator<<(const T&) { return *this; } };

} // FIX8

#endif // F8_TYPES_HPP_