Files
spark/src/lib/jetfix/codec/FIXFragment.h
T

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