FlatMessage.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/
 
#pragma once
 
#include <iterator>
 
#include <OnixS/FIXEngine/FIX/Tag.h>
#include <OnixS/FIXEngine/FIX/Numeric.h>
#include <OnixS/FIXEngine/FIX/StringRef.h>
#include <OnixS/FIXEngine/FIX/Timestamp.h>
 
#include <OnixS/FIXEngine/FIX/FlatFieldRefAndKey.h>
#include <OnixS/FIXEngine/FIX/FieldValueRef.h>
 
#include <OnixS/FIXEngine/FIX/ProtocolVersion.h>
 
namespace OnixS {
namespace FIX {
ONIXS_FIXENGINE_API_DECL(class, Message);
ONIXS_FIXENGINE_API_DECL(class, FlatGroup);
 
namespace Core {
namespace Messaging {
namespace Extras {
class FlatMessage;
}
}
}

struct InsertMode
{
    enum Enum
    {
        Before,

        After
    };
};

class ONIXS_FIXENGINE_API FlatField
{
public:

    FlatField()
        : tag_(0), value_(nullptr), size_(0) {}

    FlatField(
        Tag fieldTag,
        const StringRef & fieldValue)
        : tag_(fieldTag), value_(fieldValue.data()), size_(fieldValue.size()) {}

    Tag tag() const { return tag_; }

    StringRef value() const { return StringRef(value_, size_); }
 
private:

    Tag tag_;

    const char * value_;

    size_t size_;
};

class ONIXS_FIXENGINE_API FlatMessage
{
public:
    FlatMessage();

    FlatMessage(OnixS::FIX::ProtocolVersion::Enum protocolVersion, const char * msgType);

    FlatMessage(const char * rawMessage, size_t rawMessageSize, bool useZeroCopyBuffer = true);

    FlatMessage(
        OnixS::FIX::ProtocolVersion::Enum protocolVersion,
        const char * msgType,
        const char * senderCompId,
        const char * targetCompId,
        const char * rawMessageWithoutHeaderTrailer,
        size_t rawMessageWithoutHeaderTrailerSize,
        bool useZeroCopyBuffer = true);

    FlatMessage(const OnixS::FIX::Message & message, bool useZeroCopyBuffer = true);

    FlatMessage(const FlatMessage & other);

    FlatMessage(FlatMessage && moved) noexcept;

    ~FlatMessage();

    bool valid() const;

    const char * chars() const;

    size_t size() const;

    std::string toString(char delimiter = 0x1) const;

    FlatFieldRef find(Tag) const;

    FlatFieldRef find(Tag, const FlatFieldRef &) const;

    FlatFieldKey allocateKey(const FlatFieldRef &);

    FlatFieldKey allocateKey(Tag);

    StringRef operator[](const FlatFieldRef &) const;

    StringRef operator[](FlatFieldKey) const;

    FlatGroup getGroup(const FlatFieldRef & numberOfInstancesRef) const;

    FlatFieldRef getFlatFieldRef(const StringRef & value) const;

    FlatMessage & set(FlatFieldRef &, const StringRef &);

    FlatMessage & set(FlatFieldKey, const StringRef &);

    FlatMessage & set(FlatFieldRef &, Char);

    FlatMessage & set(FlatFieldKey, Char);

    FlatMessage & set(FlatFieldRef &, Int32);

    FlatMessage & set(FlatFieldKey, Int32);

    FlatMessage & set(FlatFieldRef &, UInt32);

    FlatMessage & set(FlatFieldKey, UInt32);

    FlatMessage & set(FlatFieldRef &, Int64);

    FlatMessage & set(FlatFieldKey, Int64);

    FlatMessage & set(FlatFieldRef &, UInt64);

    FlatMessage & set(FlatFieldKey, UInt64);

    FlatMessage & set(FlatFieldRef &, const Decimal &);

    FlatMessage & set(FlatFieldKey, const Decimal &);

    FlatMessage & set(FlatFieldRef &, const Timestamp &, TimestampFormat::Enum);

    FlatMessage & set(FlatFieldKey, const Timestamp &, TimestampFormat::Enum);

    FlatMessage & set(FlatFieldRef &, const TimeSpan &, TimeSpanFormat::Enum);

    FlatMessage & set(FlatFieldKey, const TimeSpan &, TimeSpanFormat::Enum);

    FlatMessage & set(FlatFieldRef &, const FieldValueRef &);

    FlatMessage & set(FlatFieldKey, const FieldValueRef &);

    FlatMessage & add(Tag, const StringRef &);

    FlatMessage & add(Tag, Char);

    FlatMessage & add(Tag, Int32);

    FlatMessage & add(Tag, UInt32);

    FlatMessage & add(Tag, Int64);

    FlatMessage & add(Tag, UInt64);

    FlatMessage & add(Tag, const Decimal &);

    FlatMessage & add(Tag, const Timestamp &, TimestampFormat::Enum);

    FlatMessage & add(Tag, const TimeSpan &, TimeSpanFormat::Enum);

    FlatMessage & insert(Tag, const StringRef &, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, Char, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, Int32, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, UInt32, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, Int64, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, UInt64, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, const Decimal &, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, const Timestamp &, TimestampFormat::Enum, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & insert(Tag, const TimeSpan &, TimeSpanFormat::Enum, Tag, InsertMode::Enum = InsertMode::Before);

    FlatMessage & remove(Tag);

    void adjust();

    void reset(const char * rawMessage, size_t rawMessageSize);

    void reset();
 
    // Returns the `ProtocolVersion`, which corresponds to `BeginString` and 'ApplVerID' tag values.
    ProtocolVersion::Enum version() const;

    void * userData() const;

    void userData(void * data);

    void swap(FlatMessage & other) noexcept;

    FlatMessage & operator = (const FlatMessage &);

    FlatMessage & operator = (FlatMessage &&) noexcept;

    class ONIXS_FIXENGINE_API ConstIterator
    {
    public:
 
        typedef std::forward_iterator_tag iterator_category;
        typedef FlatField value_type;
        typedef std::ptrdiff_t difference_type;
        typedef const FlatField * pointer;
        typedef const FlatField & reference;

        ConstIterator(const FlatMessage *, Tag);
 
        reference operator*() const {
            return currentField_;
        }
 
        pointer operator->() const {
            return &currentField_;
        }
 
        bool operator == (const ConstIterator &) const;
        bool operator != (const ConstIterator &) const;
 
        ConstIterator & operator ++();
 
    private:
        const FlatMessage * container_;

        FlatField currentField_;
    };
 
    typedef ConstIterator const_iterator;

    ConstIterator begin() const;

    ConstIterator end() const;
 
private:
    friend class MessageOperator;
    friend class FlatMessageWrapper;
 
    FlatMessage(const OnixS::FIX::Core::Messaging::Extras::FlatMessage & other);
 
    OnixS::FIX::Core::Messaging::Extras::FlatMessage * impl_;
    bool isOwned_;
};
 
typedef FlatMessage SerializedMessage;
 
inline
FlatFieldRef
FlatMessage::find(Tag tag) const
{
    return find(tag, FlatFieldRef());
}

ONIXS_FIXENGINE_API
std::ostream & operator << (std::ostream & os, const FlatMessage & message);
}
}