Message.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 <iosfwd>
#include <string>
 
#include <OnixS/FIXEngine/FIX/SequenceNumber.h>
 
#include <OnixS/FIXEngine/FIX/FieldSet.h>
#include <OnixS/FIXEngine/FIX/Dictionary.h>
 
#include <OnixS/FIXEngine/FIX/MessageStringingFlags.h>
#include <OnixS/FIXEngine/FIX/MessageParsingFlags.h>
#include <OnixS/FIXEngine/FIX/MessageValidationFlags.h>
 
#include <OnixS/FIXEngine/FIX/RawMessage.h>
 
namespace OnixS {
namespace FIX {
class
    ONIXS_FIXENGINE_API
    Message : public FieldSet
{
public:
    explicit Message(size_t expectedMessageSize = DefaultExpectedMessageSize);

    Message(const char * type, const Dictionary & dictionary, size_t expectedMessageSize = DefaultExpectedMessageSize);

    Message(const Message & other);

    Message(Message && moved) noexcept;

    virtual ~Message();

    Dictionary dictionary() const;

    FieldValueRef type() const;

    SequenceNumber seqNum() const;

    void seqNum(SequenceNumber value);

    FieldValueRef senderCompId() const;

    void senderCompId(const std::string &);

    FieldValueRef targetCompId() const;

    void targetCompId(const std::string &);

    void * userData() const;

    void userData(void * data);

    bool operator == (const Message &) const;

    bool operator != (const Message &) const;

    void validate() const;

    void validateAll() const;

    void validate(MessageValidationFlags validationFlags) const;

    void validateAll(MessageValidationFlags validationFlags) const;

    bool tryValidate(MessageValidationFlags validationFlags, std::string & errorDescription) const;

    bool tryValidateAll(MessageValidationFlags validationFlags, std::string & errorDescription) const;

    void clear();

    void toRaw(RawMessage &) const;

    std::string
    toString(
        char delimiter = 0x1,
        MessageStringingFlags flags =
            MessageStringingFlag::IncludeFieldTagNumber) const;

    void
    toString(
        std::string & str,
        char delimiter = 0x1,
        MessageStringingFlags flags =
            MessageStringingFlag::IncludeFieldTagNumber) const;

    std::string
    toXml(const std::string & indent = "  ", const std::string & endOfLineDelimiter = "\n") const;

    void
    toXml(std::string & str, const std::string & indent = "  ", const std::string & endOfLineDelimiter = "\n") const;

    std::string
    toJson(const std::string & indent = "  ", const std::string & endOfLineDelimiter = "\n") const;

    void
    toJson(std::string & str, const std::string & indent = "  ", const std::string & endOfLineDelimiter = "\n") const;

    void updateBodyLengthAndCheckSum();

    void swap(Message & other) noexcept;
 
    // Reassigns the message as a copy of other one.
    Message & operator = (const Message &);

    Message & operator = (Message &&) noexcept;
 
    // Copies all message fields (except the protocol version) from another message object.
    void copyFields(const Message &);

    static
    void
    parse(
        const char * rawMessage,
        size_t rawMessageSize,
        Message & message);

    static
    void
    parse(
        const char * rawMessage,
        size_t rawMessageSize,
        MessageParsingFlags parsingFlags,
        Message & message);

    static
    void
    parse(
        const char * rawMessage,
        size_t rawMessageSize,
        const Dictionary & dictionary,
        MessageParsingFlags parsingFlags,
        Message & message);

    static
    bool
    parsePartial(
        const char * rawMessage,
        size_t rawMessageSize,
        Message & message);

    static
    bool
    parsePartial(
        const char * rawMessage,
        size_t rawMessageSize,
        const Dictionary & dictionary,
        Message & message);
 
    struct MakeShallowCopy {};
 
protected:
    Message(const Message & other, MakeShallowCopy);
 
private:
    friend class MessageWrapper;
    friend class MessageOperator;
 
    Message(const void *);
 
private:
 
    virtual void userDataImpl(void * data);
 
    unsigned char impl_[6 * sizeof(size_t)];
    unsigned char allocator_[4 * sizeof(size_t)];
 
    static const size_t DefaultExpectedMessageSize = 10240;
 
    void construct(size_t expectedMessageSize = DefaultExpectedMessageSize);
    void destruct();
};
 
inline
std::string
Message::toString(
    char delimiter,
    MessageStringingFlags flags) const
{
    std::string str;
 
    toString(str, delimiter, flags);
 
    return str;
}

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