206 lines
5.3 KiB
C++
206 lines
5.3 KiB
C++
#pragma once
|
|
|
|
#include <memory>
|
|
#include <cstring>
|
|
|
|
#include "lib/utils/bts_assert.h"
|
|
#include "lib/jetfix/codec/FIXBuffer.h"
|
|
#include "lib/jetfix/codec/Fields.h"
|
|
|
|
namespace bts {
|
|
namespace jetfix {
|
|
|
|
// helper used to facilitate the encoding of a FIX message fragment
|
|
class FIXFragment
|
|
{
|
|
public:
|
|
FIXFragment(FIXBuffer &buffer,uint32_t checksum)
|
|
:
|
|
_buffer (&buffer),
|
|
_checksum (checksum),
|
|
_initial_offset (buffer.size ()),
|
|
_owns_buffer (false)
|
|
{}
|
|
|
|
FIXFragment(FIXBuffer &buffer)
|
|
:
|
|
_buffer (&buffer),
|
|
_checksum (0),
|
|
_initial_offset (buffer.size ()),
|
|
_owns_buffer (false)
|
|
{}
|
|
|
|
explicit FIXFragment(uint32_t initial_capacity=100)
|
|
:
|
|
_buffer (new FIXBuffer (initial_capacity)),
|
|
_checksum (0),
|
|
_initial_offset (0),
|
|
_owns_buffer (true)
|
|
{}
|
|
|
|
~FIXFragment ()
|
|
{
|
|
if (_owns_buffer)
|
|
delete _buffer;
|
|
}
|
|
|
|
FIXFragment (FIXFragment const&src) :
|
|
_buffer (),
|
|
_checksum (0),
|
|
_initial_offset (0),
|
|
_owns_buffer ()
|
|
{
|
|
operator=(src);
|
|
}
|
|
|
|
FIXFragment (FIXFragment &&src) :
|
|
_buffer (std::move (src._buffer)),
|
|
_checksum (src._checksum),
|
|
_initial_offset (src._initial_offset),
|
|
_owns_buffer (src._owns_buffer)
|
|
{
|
|
src._buffer = nullptr;
|
|
src._checksum = 0;
|
|
src._initial_offset = 0;
|
|
src._owns_buffer = false;
|
|
}
|
|
|
|
void reset ()
|
|
{
|
|
bts_assert (_owns_buffer);
|
|
_buffer->reset ();
|
|
}
|
|
|
|
FIXFragment&operator=(FIXFragment const&src)
|
|
{
|
|
this->~FIXFragment ();
|
|
|
|
if (src._owns_buffer)
|
|
_buffer = new FIXBuffer (*src._buffer);
|
|
else
|
|
_buffer = src._buffer;
|
|
_checksum = src._checksum;
|
|
_initial_offset = src._initial_offset;
|
|
_owns_buffer = src._owns_buffer;
|
|
return *this;
|
|
}
|
|
|
|
FIXFragment&operator=(FIXFragment &&src)
|
|
{
|
|
this->~FIXFragment ();
|
|
_buffer = src._buffer;
|
|
_owns_buffer = src._owns_buffer;
|
|
_checksum= src._checksum;
|
|
_initial_offset = src._initial_offset;
|
|
src._buffer = nullptr;
|
|
src._checksum = 0;
|
|
src._initial_offset = 0;
|
|
src._owns_buffer = false;
|
|
return *this;
|
|
}
|
|
|
|
template <class FT>
|
|
struct Bookmark
|
|
{
|
|
Bookmark (uint32_t idx,uint32_t sz,uint32_t checksum) :
|
|
offset (idx),
|
|
sz (sz),
|
|
val_checksum (checksum)
|
|
{}
|
|
Bookmark () :
|
|
offset (0),
|
|
sz (0),
|
|
val_checksum (0)
|
|
{}
|
|
|
|
bool valid () const {return sz > 0;}
|
|
|
|
Bookmark shift (uint32_t by) const
|
|
{return Bookmark (offset+by,sz,val_checksum);}
|
|
|
|
typedef FT Field;
|
|
uint32_t offset;
|
|
uint32_t sz;
|
|
uint32_t val_checksum;
|
|
};
|
|
|
|
template <class Field, typename... Args>
|
|
inline Bookmark<Field> add (Args&&... args)
|
|
{
|
|
auto non_value_data_sz = Field::tag_sz + 2; // =,SOH
|
|
auto val_max_size = Field::max_value_size (std::forward<Args>(args)...);
|
|
|
|
auto ptr = _buffer->reserve (val_max_size + non_value_data_sz);
|
|
std::memcpy (ptr,Field::tag_s,Field::tag_sz);
|
|
ptr = _buffer->advance (Field::tag_sz);
|
|
*ptr = '=';
|
|
ptr = _buffer->advance (1);
|
|
auto start_of_value = _buffer->size ();
|
|
auto write_result = Field::write (ptr,std::forward<Args>(args)...);
|
|
ptr = _buffer->advance (write_result.first);
|
|
*ptr = 1;
|
|
ptr = _buffer->advance (1);
|
|
_checksum += (write_result.second + Field::tag_checksum + '=' + 1);
|
|
return Bookmark<Field> (start_of_value,write_result.first, write_result.second);
|
|
}
|
|
|
|
template <class Field, typename... Args>
|
|
inline Bookmark<Field> overwrite (Bookmark<Field> const &bm,Args &&... args)
|
|
{
|
|
_checksum -= bm.val_checksum;
|
|
auto ptr = _buffer->get_offset (bm.offset);
|
|
auto write_result = Field::write (ptr,std::forward<Args>(args)...);
|
|
ptr[bm.sz] = 1; // i32_toa, d_toa both put a 0 at end of the number
|
|
bts_assert (write_result.first == bm.sz);
|
|
_checksum += write_result.second;
|
|
return Bookmark<Field> (bm.offset,bm.sz, write_result.second);
|
|
}
|
|
|
|
inline Bookmark<IntField<10>> add_checksum (uint8_t chk)
|
|
{
|
|
auto checksum = _checksum;
|
|
auto bm = add<IntField<10>> (chk,3);
|
|
_checksum = checksum;
|
|
bm.val_checksum = 0;
|
|
return bm;
|
|
}
|
|
|
|
inline Bookmark<IntField<10>> overwrite_checksum (Bookmark<IntField<10>> const&bm,uint8_t chk)
|
|
{
|
|
auto checksum = _checksum;
|
|
overwrite<IntField<10>> (bm,chk,3);
|
|
_checksum = checksum;
|
|
return bm;
|
|
}
|
|
|
|
template <class FIX_DATA> inline void append (FIX_DATA const &src)
|
|
{append (src.data (),src.size (),src.checksum ());}
|
|
|
|
inline void append (const char*data, uint32_t data_size, uint32_t data_checksum)
|
|
{
|
|
auto ptr = _buffer->reserve (data_size);
|
|
_checksum += data_checksum;
|
|
memcpy (ptr,data,data_size);
|
|
_buffer->advance (data_size);
|
|
}
|
|
|
|
std::string to_str () const
|
|
{
|
|
return std::string (_buffer->data (),
|
|
_initial_offset,
|
|
_buffer->size ());
|
|
}
|
|
|
|
uint32_t size () const {return _buffer->size () - _initial_offset;}
|
|
uint32_t checksum () const {return _checksum; }
|
|
const char* data () const {return _buffer->get_offset (_initial_offset);}
|
|
|
|
private:
|
|
FIXBuffer *_buffer;
|
|
size_t _checksum;
|
|
uint32_t _initial_offset;
|
|
bool _owns_buffer;
|
|
};
|
|
|
|
}}
|