Messaging.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 "OnixS/CME/DropCopy/Export.h"
#include "OnixS/CME/DropCopy/Numeric.h"
#include "OnixS/CME/DropCopy/String.h"
#include "OnixS/CME/DropCopy/Time.h"
#include "OnixS/CME/DropCopy/Types.h"

namespace OnixS { namespace CME { namespace DropCopy {

class Message;
class Group;
class MessageOperator;

/// Reference to a read-only FIX field value.
///
/// Reference may refers to a valid field value or
/// to nothing. 'operator bool()' is exposed to check
/// whether instance refers to existent field value.
class ONIXS_CME_DROP_COPY_EXPORT FieldValueRef
{
public:
    /// Uninitialized value.
    FieldValueRef();

    /// Shallow copy from another one.
    FieldValueRef(const FieldValueRef&);

    /// Indicated whether the instance
    /// refers to a valid value.
    operator bool() const;

    /// Return string presentation
    /// of the value being referenced.
    operator std::string() const;

    /// Compares with another instance for equality.
    bool operator==(const FieldValueRef&) const;

    /// Compares with another instance for inequality.
    bool operator!=(const FieldValueRef&) const;

    /// Compares string presentation for
    /// equality with given text reference.
    bool operator==(const StringRef&) const;

    /// Compares string presentation for
    /// equality with given text reference.
    bool operator!=(const StringRef&) const;

    /// Converts field value into a whole number.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toNumber(Int32&) const;

    /// Converts field value into a whole number.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toNumber(UInt32&) const;

    /// Converts field value into a whole number.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toNumber(Int64&) const;

    /// Converts field value into a whole number.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toNumber(UInt64&) const;

    /// Converts field value into a whole number.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toNumber(Decimal&) const;

    /// Converts field value into Timestamp.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toTimestamp(Timestamp&, SinceEpochUnit) const;

    /// If value represents text, returns reference to it.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    /// If value being referenced is not of string type
    /// (like number or datetime), conversion fails.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toStringRef(StringRef&) const;

    /// If value represent one-char text,
    /// copies it into given variable.
    ///
    /// \returns false if value referenced by instance
    /// can't be converted into value of target type.
    ///
    /// \note conversion of instance referencing
    /// to nothing always fails.
    bool toChar(char&) const;

    /// If repeating group is associated with
    /// field, allows to get instance of it.
    ///
    /// \returns false if no group is associated with field.
    bool toGroup(Group&) const;

    /// Appends copy of referenced value text
    /// presentation to the std::string.
    void toString(std::string&) const;

    /// Return string presentation of field value.
    std::string toString() const;

    /// Updates instance to refer to another field value.
    /// \warning Does NOT perform deep copy of field values.
    /// Just updates reference to point to value of other field.
    FieldValueRef& operator=(const FieldValueRef&);

private:
    friend class MessageOperator;

    const void* impl_;
    const Message* container_;

    FieldValueRef(const Message*, const void*);
};

inline FieldValueRef::operator std::string() const
{
    std::string str;
    toString(str);
    return str;
}

inline std::string FieldValueRef::toString() const
{
    std::string str;
    toString(str);
    return str;
}

// More comparison operators.

inline bool operator==(const FieldValueRef& ref, const std::string& str)
{
    return ref == StringRef(str);
}

inline bool operator!=(const FieldValueRef& ref, const std::string& str)
{
    return ref != StringRef(str);
}

inline bool operator==(const std::string& str, const FieldValueRef& ref)
{
    return ref == StringRef(str);
}

inline bool operator!=(const std::string& str, const FieldValueRef& ref)
{
    return ref != StringRef(str);
}

// More comparison operators.

inline bool operator==(const FieldValueRef& ref, const char* str)
{
    return ref == StringRef(str);
}

inline bool operator!=(const FieldValueRef& ref, const char* str)
{
    return ref != StringRef(str);
}

inline bool operator==(const char* str, const FieldValueRef& ref)
{
    return ref == StringRef(str);
}

inline bool operator!=(const char* str, const FieldValueRef& ref)
{
    return ref != StringRef(str);
}

/// Encapsulates primary operations over collection of FIX
/// fields like FIX message and repeating group instance are.
class ONIXS_CME_DROP_COPY_EXPORT FieldSet
{
public:
    /// Indicates whether instance refers to a valid set of fields.
    ///
    /// If given instance doesn't refer to a valid fields set,
    /// none of other members must be used.
    operator bool() const;

    /// Provides access to field value using field tag.
    ///
    /// \returns Reference to a value associated with field
    /// identified by tag. If there's no value associated with
    /// a field, returned reference refers to nothing.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    FieldValueRef get(Tag tag) const;

    /// Returns field value as a char value.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    char getChar(Tag tag) const;

    /// Returns field value as an Int32 value.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    Int32 getInt32(Tag tag) const;

    /// Returns field value as an UInt32 value.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    UInt32 getUInt32(Tag tag) const;

    /// Returns field value as an Int64 value.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    Int64 getInt64(Tag tag) const;

    /// Returns field value as an UInt64 value.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    UInt64 getUInt64(Tag tag) const;

    /// Returns the field value as a decimal number.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    Decimal getDecimal(Tag tag) const;

    /// Returns reference to a read-only text chain.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    StringRef getStringRef(Tag tag) const;

    /// Returns the field value as timestamp of requested format.
    ///
    /// \throw std::exception if field is absent or associated
    /// value can't be converted to target type.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use casting to bool operator to check whether instance
    /// refers to a valid set of fields.
    Timestamp getTimestamp(Tag tag, SinceEpochUnit unit) const;

    /// Returns reference to a repeating group if underlying
    /// field defines length of repeating group.
    ///
    /// \param tag represent tag number of the field that defines
    /// number of instances in this repeating group (the NoXXX field).
    ///
    /// \throw std::exception if no repeating group is
    /// associated with given field including field absence.
    Group getGroup(Tag tag) const;

    /// Returns reference to a repeating group if underlying
    /// field defines length of repeating group. If field is absent
    /// returns instance referencing to nothing. If field is undefined
    /// for this message throws exception (if strict parameter is true)
    /// or returns instance referencing to nothing (if strict parameter is false).
    ///
    /// \param tag represent tag number of the field that defines
    /// number of instances in this repeating group (the NoXXX field).
    /// \param strict set to true (default) if field undefined for this message
    /// shall throw exception or to false if shall return empty group instance.
    ///
    /// \throw std::exception if given field is undefined (and strict parameter
    /// is true) or doesn't suppose to represent repeating group.
    Group getOptionalGroup(Tag tag, bool strict = true) const;

    /// Returns true if the given flag is present
    /// and it equals to "Y", otherwise false.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use operator bool() to check whether
    /// instance is in valid state.
    bool hasFlag(Tag tag) const;

    /// Checks the presence of a field
    /// This method should be used if the actual field value is NOT of interest -
    /// otherwise field lookup operation will be done twice.
    bool contain(Tag tag) const;

protected:
    // Underlying implementation.
    const void* impl_;

    // Message to which given set belongs to.
    const Message* container_;

    // Full details initialization.
    FieldSet(const Message*, const void*);

    // Clone construction.
    FieldSet(const FieldSet&);

    // Destruction available via descendants.
    ~FieldSet();

    FieldSet& operator=(const FieldSet&);

private:
    friend class Message;
    friend class GroupInstance;
    friend class MessageOperator;
};

template <typename Enumeration>
inline typename Enumeration::Enum getIntEnumFieldValue(const FieldSet& fieldSet, Tag tag)
{
    UInt32 value = 0;
    FieldValueRef valueRef = fieldSet.get(tag);

    return (valueRef && valueRef.toNumber(value)) ? static_cast<typename Enumeration::Enum>(value)
                                                  : Enumeration::Undefined;
}

template <typename Enumeration>
inline typename Enumeration::Enum getCharEnumFieldValue(const FieldSet& fieldSet, Tag tag)
{
    char value = 0;
    FieldValueRef valueRef = fieldSet.get(tag);

    return (valueRef && valueRef.toChar(value)) ? static_cast<typename Enumeration::Enum>(value)
                                                : Enumeration::Undefined;
}

inline bool getDate(const FieldSet& fieldSet, Tag tag, Timestamp& date)
{
    UInt64 value;

    if (fieldSet.get(tag).toNumber(value))
    {
        date = Timestamp::fromUnixTimestamp(value, SinceEpochUnits::Days);
        return true;
    }

    return false;
}

/// Single instance of FIX Repeating Group. Provides access
/// to the fields of a particular repeating group instance.
///
/// Class behaves like a pointer/reference to a set of FIX
/// fields. Coping and assignment operations just update reference
/// to the field-set being pointed, no deep copying is performed.
class ONIXS_CME_DROP_COPY_EXPORT GroupInstance : public FieldSet
{
public:
    /// Initializes instance referencing to nothing.
    GroupInstance();

    /// Initializes instance as reference to the other one.
    GroupInstance(const GroupInstance& other);

    /// Reinitializes instance as reference of other one.
    GroupInstance& operator=(const GroupInstance&);

    /// Instance of Message holding
    /// given repeating group instance.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use operator bool() to check whether
    /// instance is in valid state.
    const Message& message() const;

private:
    friend class MessageOperator;

    GroupInstance(const Message*, const void*);
};

inline const Message& GroupInstance::message() const
{
    return *container_;
}

/// Encapsulates operations over FIX Repeating Group.
///
/// Repeating group represents array of repeating group instances,
/// So, class exposes corresponding services to manipulate array
/// of repeating group instances. Similar to the GroupInstance
/// it behaves like a pointer/reference to the underlying data. It's
/// a light-weight object which just wraps internal data.
///
/// Group remains valid until corresponding field (which defines
/// size/length of repeating group) from field-set (message or outer
/// repeating group instance) is updated.
class ONIXS_CME_DROP_COPY_EXPORT Group
{
public:
    /// Initializes instance as referred to nothing.
    Group();

    /// Initializes instance as reference to given repeating group.
    Group(const Group& other);

    /// Indicated whether group refers to a valid instance.
    operator bool() const;

    /// Return number of instances in repeating group.
    ///
    /// \warning Due to performance considerations,
    /// instance is not checked for validness. Member
    /// must be used only when instance is in valid state.
    size_t size() const;

    /// Accesses to repeating group instance.
    ///
    /// \throw std::exception if If index exceeds allowed bounds.
    ///
    /// \warning Due to performance considerations,
    /// instance is not checked for validness. Member
    /// must be used only when instance is in valid state.
    const GroupInstance at(size_t index) const;

    /// Accesses to repeating group instance.
    ///
    /// Does NOT check index validness.
    ///
    /// \warning Due to performance considerations,
    /// instance is not checked for validness. Member
    /// must be used only when instance is in valid state.
    const GroupInstance operator[](size_t index) const;

    /// Reinitializes instance as reference to other one.
    Group& operator=(const Group& other);

    /// Instance of Message holding
    /// given repeating group instance.
    ///
    /// \warning Due to performance considerations, doesn't
    /// check whether instance refers to a valid set of fields.
    /// Use operator bool() to check whether
    /// instance is in valid state.
    const Message& message() const;

private:
    friend class MessageOperator;

    const void* impl_;

    const Message* container_;

    Group(const Message*, const void*);
};

inline const Message& Group::message() const
{
    return *container_;
}

template <typename Entry>
class TypedGroup
{
public:
    /// Initializes set with no entries.
    TypedGroup()
      : underlyingGroup_()
    {
    }

    /// Return number of instances in repeating group.
    size_t size() const
    {
        return underlyingGroup_ ? underlyingGroup_.size() : 0;
    }

    /// Indicates whether set has an entries.
    bool empty() const
    {
        return 0 == size();
    }

    /// Accesses to repeating group instance.
    ///
    /// Does NOT check index validness.
    Entry operator[](size_t index) const
    {
        return Entry(underlyingGroup_[index]);
    }

    /// Accesses to repeating group instance.
    ///
    /// check index validness.
    Entry at(size_t index) const
    {
        if (index < size())
        {
            return Entry(underlyingGroup_[index]);
        }

        throw std::out_of_range("Index");
    }

protected:
    TypedGroup(const Group& group)
      : underlyingGroup_(group)
    {
    }

    Group underlyingGroup_;
};

/// Contains flags which affect FIX message textual presentation.
struct ONIXS_CME_DROP_COPY_EXPORT MessageStringingFlag
{
    /// Flags which affect FIX message textual presentation.
    enum Enum
    {
        /// Only field values are serialized.
        NoFieldInfo = 0x0,

        /// Field tag numbers are included during serialization.
        IncludeFieldTagNumber = 0x1,

        /// Field names are included during serialization.
        IncludeFieldName = 0x2
    };
};

/// Collection of message stringing flags.
typedef unsigned MessageStringingFlags;

/// Encapsulates operations over a FIX Message.
///
/// Message supports 'unconstructed' state which can be
/// treated as pointer in null state. However, in contrast to
/// Group and GroupInstance classes it
/// does NOT represent light-weight wrapper over internal structures.
/// In fact, it holds all the data which is fully copied on assignment
/// or copy construction and disposed at instance destruction.
///
/// FIX field related operations now available via FieldSet
/// class from which Message class is now derived.
class ONIXS_CME_DROP_COPY_EXPORT Message : public FieldSet
{
public:
    /// Initializes message in 'unconstructed' state.
    Message();

    /// Initializes instance as deep copy of other one.
    ///
    /// \param other Message to be copied from.
    Message(const Message& other);

    /// Disposes all internal data structures.
    ///
    /// \warning Once instance is destructed, all instances of
    /// Group and GroupInstance classes
    /// obtained from this instance must not be used any more.
    ~Message();

    /// Returns the message type (MsgType(35) field value).
    FieldValueRef type() const;

    /// Returns the MsgSeqNum field from CME binary packet header.
    /// Please note: this field is attributed to packet, not message.
    /// Packet can contain several messages, so they will share same sequence number.
    SequenceNumber sequenceNumber() const;

    /// Returns the Sending Time field from CME binary packet header.
    /// Please note: this field is attributed to packet, not message.
    /// Packet can contain several messages, so they will share same sending time.
    Timestamp sendingTime() const;

    /// Indicates time when packet
    /// holding given message was received.
    const Timestamp& receiveTime() const;

    /// Returns the string representation of the message using
    /// the given delimiter and additional control flags.
    ///
    /// \param delimiter Defines field delimiter to be used.
    std::string toString(char delimiter = 0x1) const;

    /// Appends string representation of the message using
    /// the given delimiter and additional control flags.
    ///
    /// \param str String to which presentation is appended.
    /// \param delimiter Defines field delimiter to be used.
    void toString(std::string& str, char delimiter = 0x1) const;

    // Reassigns message as copy of other one.
    Message& operator=(const Message&);

private:
    friend class MessageOperator;

    Message(const void* core, const Timestamp& receiveTime);

private:
    const void* core_;
    Timestamp receiveTime_;
};

inline std::string Message::toString(char delimiter) const
{
    std::string str;
    toString(str, delimiter);
    return str;
}

/// Simple wrapper for bitmap field
class ONIXS_CME_DROP_COPY_EXPORT BitmapField
{
public:
    typedef UInt32 BaseType;

    /// Initializes bitmap field instance with explicit value.
    explicit BitmapField(BaseType bits = 0)
      : bits_(bits)
    {
    }

    /// Initializes bitmap field instance from FIX field set.
    BitmapField(const FieldSet& msg, Tag tag)
      : bits_(0)
    {
        msg.get(tag).toNumber(bits_);
    }

protected:
    bool state(BaseType bit) const
    {
        return (bits_ >> bit) & 1;
    }

    bool any() const
    {
        return bits_ != 0;
    }

    BaseType bits() const
    {
        return bits_;
    }

private:
    BaseType bits_;
};

}}}

namespace std {

// Outputs message into standard stream.
ONIXS_CME_DROP_COPY_EXPORT std::ostream&
operator<<(std::ostream&, const OnixS::CME::DropCopy::Message&);

}