mFAST C++ Library

The fast_encoder provides two primary ways to encode a message_cref into a byte stream:

1. Encode into a fixed-size buffer

std::size_t encode(const message_cref &message, char *buffer, std::size_t buffer_size, bool force_reset = false)

• Returns: The size of the encoded byte stream.
• Throws: An exception if the provided buffer_size is smaller than the required size.
• force_reset: If true, the encoder resets and discards all existing history values before encoding.

2. Encode into a std::vector<char>

void encode(const message_cref &message, std::vector<char> &buffer, bool force_reset = false)

• Behavior: Appends the encoded FAST stream to the existing contents of the buffer.
• force_reset: If true, the encoder resets and discards all existing history values before encoding.

// Fixed buffer usage
char buf[512];
std::size_t len = encoder.encode(msg, buf, sizeof(buf), true);

// Vector append usage
std::vector<char> vec;
encoder.encode(msg, vec, false);

The field_instruction class is the primary base class for defining how individual fields are constructed, destroyed, and copied within mFAST. It manages metadata such as the field's name, namespace (ns), ID, type, and presence (mandatory vs. optional).

Key Methods

• construct_value(value_storage &storage, allocator *alloc): (Virtual) Must be implemented by derived classes to initialize the field's value in storage.
• destruct_value(value_storage &storage, allocator *alloc): Cleans up the field's value.
• copy_construct_value(...): Performs a deep copy of the field from a source value_storage to a destination.
• accept(field_instruction_visitor &, void *): Used for the Visitor pattern to process instructions.
• clone(arena_allocator &alloc): Creates a copy of the instruction using an arena allocator.

Metadata Accessors

• name(): Returns the field name.
• ns(): Returns the namespace.
• id(): Returns the unique field ID.
• field_type(): Returns the field_type_enum_t.
• optional(): Returns true if the field is optional.
• is_array(): Returns true if the field type is a string, byte vector, or sequence.

To process or traverse mFAST field instructions, you must implement the field_instruction_visitor abstract base class. This interface uses the Visitor pattern, requiring you to override the visit method for each specific instruction type you wish to handle. Each visit method accepts a pointer to the specific instruction type and a void * context pointer for passing user-defined data through the traversal.

Supported instruction types for overriding include:

• Integer types: int32_field_instruction, uint32_field_instruction, int64_field_instruction, uint64_field_instruction
• Vector types: int32_vector_field_instruction, uint32_vector_field_instruction, int64_vector_field_instruction, uint64_vector_field_instruction
• Specialized types: decimal_field_instruction, ascii_field_instruction, unicode_field_instruction, byte_vector_field_instruction, enum_field_instruction, set_field_instruction
• Structural types: group_field_instruction, sequence_field_instruction, template_instruction, templateref_instruction

#include <mfast/field_instructions.h>

class MyInstructionProcessor : public mfast::field_instruction_visitor {
public:
    // Example: handling an int32 instruction
    void visit(const mfast::int32_field_instruction *inst, void *data) override {
        // Process the instruction using 'inst' and 'data'
    }

    // You must implement all other pure virtual visit methods defined in the interface...
    void visit(const mfast::uint32_field_instruction *inst, void *data) override {}
    // ... etc
};

// Usage:
// MyInstructionProcessor processor;
// instruction->accept(processor, my_context_data);