GeezerVison

BUCKET_NAME ${BUCKET_NAME}

TEST_SRCS ${TEST_SRCS}

)

O2_GENERATE_MAN(NAME Algorithm SECTION 3)

O2_GENERATE_MAN(NAME algorithm_parser SECTION 3)

AliceO2 - module

.B Algorithm

A collection of generic algorithms for Alice O2

algorithm_parser(3)

AliceO2 - module

.B Algorithm

- data parsers

.B ForwardParser<

.I SomeHeaderType

,

.I SomeTrailerType

.B >

.B ReverseParser<

.I SomeHeaderType

,

.I SomeTrailerType

.B >

.TP 2

.B struct FrameInfo {

using PtrT = const PayloadType*;

const HeaderType* header = nullptr;

const TrailerType* trailer = nullptr;

PtrT payload = nullptr;

size_t length = 0;

.B };

.TP 2

alias for callback checking the header, return true if the object is a valid header

.TP 2

alias for callback checking the trailer

.TP 2

alias for callback to get the complete frame size including header, trailer and the data

.TP 2

function callback to insert/handle one frame into, sequentially called for all frames if the whole block has a valid format

.TP 2

.B int parse(const InputType* \fIbuffer\fB, size_t \fIbufferSize\fB, CheckHeaderFct \fIcheckHeader\fB, CheckTrailerFct \fIcheckTrailer\fB, GetFrameSizeFct \fIgetFrameSize\fB, InsertFct \fIinsert\fB)

.TP 2

the length offset due to header

.TP 2

the length offset due to trailer

.TP 2

total length offset due to header and trailer

Template utilities for parsing of data sequences. Each entry in the sequence consist of a header, variable payload, and optionally a trailer. The three parts are collected in the FrameInfo structure for every entry.

Callback functions for checking header and trailer integrity, getting length of the current frame and handling of a frame.

The size is expected to be part of the header, parsing starts at beginning of buffer.

Trailer type can be void, which is also the default template parameter. That

allows to define a frame consisting of only header and data.

The size is expected to be part of the trailer, the parsing is thus in reverse direction. Also the insert callback is called with the entries starting form the end of the buffer.

An easy extension can be to reverse the order of the inserts, meaning that the entries are read from the beginning.

.EX

.EE

.EX

.EE

Please add an issue to

.UR https://github.com/AliceO2Group/AliceO2/issues

.UE

.UR https://github.com/AliceO2Group/AliceO2/blob/dev/Algorithm/include/Algorithm/Parser.h

.UE

namespace algorithm {

template<typename T>

struct typesize {

static const size_t size = sizeof(T);

};

template<>

struct typesize<void> {

static const size_t size = 0;

template<typename HeaderT,

typename TrailerT = void

using TrailerType = TrailerT;

using PayloadType = unsigned char;

/// @struct FrameInfo

/// a compound of header, data, and trailer

struct FrameInfo {

using PtrT = const PayloadType*;

size_t length = 0;

};

// the length offset due to header and trailer

/// the length offset due to header

static const size_t headOffset = typesize<HeaderType>::size;

/// the length offset due to trailer

static const size_t tailOffset = typesize<TrailerType>::size;

/// total length offset due to header and trailer

static const size_t totalOffset = headOffset + tailOffset;

// alias for callback checking the header, return true if the object

// is a valid header

/// alias for callback checking the header, return true if the object

/// is a valid header

using CheckHeaderFct = std::function<bool(const HeaderType&)>;

// alias for the argument type to be used in the CheckTrailer function

// have to forward to a valid type in case of void TrailerType in order

// to allow passing by reference

/// alias for the argument type to be used in the CheckTrailer function

/// have to forward to a valid type in case of void TrailerType in order

/// to allow passing by reference

using CheckTrailerFctArgumentT = typename std::conditional<

!std::is_void<TrailerType>::value, TrailerType, int>::type;

// alias for callback checking the trailer, takes reference to trailer

// object if TrailerType is a valid type, no argument otherwise

/// alias for callback checking the trailer, takes reference to trailer

/// object if TrailerType is a valid type, no argument otherwise

template <typename U>

using CheckTrailerFct = typename std::conditional<

!std::is_void<U>::value,

std::function<bool(const CheckTrailerFctArgumentT&)>,

std::function<bool()>>::type;

// alias for callback to get the complete frame size including header,

// trailer and the data

/// alias for callback to get the complete frame size including header,

/// trailer and the data

using GetFrameSizeFct = std::function<size_t(const HeaderType& )>;

// function callback to insert/handle one frame into, sequentially called

// for all frames if the whole block has a valid format

/// function callback to insert/handle one frame into, sequentially called

/// for all frames if the whole block has a valid format

using InsertFct = std::function<bool(FrameInfo&)>;

/// Parse buffer of size bufferSize, requires callbacks to check header

/// trailer, the frame size, and insert callback to handle a FrameInfo

/// object.

template<typename InputType>

int parse(const InputType* buffer, size_t bufferSize,

CheckHeaderFct checkHeader,

return -1;

}

/// Parse buffer of size bufferSize, specialization skipping the trailer

/// check, e.g. when its type is void, or when the integrity of the trailer

/// is not relevant. Requires callbacks to check header, frame size, and

/// insert callback to handle a FrameInfo object.

template<typename InputType, typename U = TrailerType>

typename std::enable_if<std::is_void<U>::value, int>::type

parse(const InputType* buffer, size_t bufferSize,

}

/// internal function to check the trailer, distinguishes void and non-void

/// trailer type.

template <typename U = TrailerType>

typename std::enable_if<!std::is_void<U>::value, bool>::type

CheckTrailer(const FrameInfo& entry, CheckTrailerFct<TrailerType>& checkTrailer) const {

template<typename HeaderT, typename TrailerT>

class ReverseParser {

using TrailerType = TrailerT;

using PayloadType = unsigned char;

/// @struct FrameInfo a compound of header, data, and trailer

struct FrameInfo {

using PtrT = const PayloadType*;

/// total length offset due to header and trailer

static const size_t totalOffset = headOffset + tailOffset;

/// alias for callback checking the header, return true if the object

/// is a valid header

using CheckHeaderFct = std::function<bool(const HeaderType&)>;

/// alias for callback checking the trailer

using CheckTrailerFct = std::function<bool(const TrailerType&)>;

/// alias for callback to get the complete frame size including header,

/// trailer and the data

using GetFrameSizeFct = std::function<size_t(const TrailerType&)>;

/// function callback to insert/handle one frame into, sequentially called

/// for all frames if the whole block has a valid format

using InsertFct = std::function<bool(const FrameInfo&)>;

/// Parse buffer of size bufferSize, requires callbacks to check header

/// trailer, the frame size, and insert callback to handle a FrameInfo

/// object.

template<typename InputType>

int parse(const InputType* buffer, size_t bufferSize,

CheckHeaderFct checkHeader,