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;

class ONIXS_CME_DROP_COPY_EXPORT FieldValueRef
{
public:
    FieldValueRef();

    FieldValueRef(const FieldValueRef&);

    operator bool() const;

    operator std::string() const;

    bool operator==(const FieldValueRef&) const;

    bool operator!=(const FieldValueRef&) const;

    bool operator==(const StringRef&) const;

    bool operator!=(const StringRef&) const;

    bool toNumber(Int32&) const;

    bool toNumber(UInt32&) const;

    bool toNumber(Int64&) const;

    bool toNumber(UInt64&) const;

    bool toNumber(Decimal&) const;

    bool toTimestamp(Timestamp&, SinceEpochUnit) const;

    bool toStringRef(StringRef&) const;

    bool toChar(char&) const;

    bool toGroup(Group&) const;

    void toString(std::string&) const;

    std::string toString() const;

    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);
}

class ONIXS_CME_DROP_COPY_EXPORT FieldSet
{
public:
    operator bool() const;

    FieldValueRef get(Tag tag) const;

    char getChar(Tag tag) const;

    Int32 getInt32(Tag tag) const;

    UInt32 getUInt32(Tag tag) const;

    Int64 getInt64(Tag tag) const;

    UInt64 getUInt64(Tag tag) const;

    Decimal getDecimal(Tag tag) const;

    StringRef getStringRef(Tag tag) const;

    Timestamp getTimestamp(Tag tag, SinceEpochUnit unit) const;

    Group getGroup(Tag tag) const;

    Group getOptionalGroup(Tag tag, bool strict = true) const;

    bool hasFlag(Tag tag) const;

    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;
}

class ONIXS_CME_DROP_COPY_EXPORT GroupInstance : public FieldSet
{
public:
    GroupInstance();

    GroupInstance(const GroupInstance& other);

    GroupInstance& operator=(const GroupInstance&);

    const Message& message() const;
 
private:
    friend class MessageOperator;
 
    GroupInstance(const Message*, const void*);
};
 
inline const Message& GroupInstance::message() const
{
    return *container_;
}

class ONIXS_CME_DROP_COPY_EXPORT Group
{
public:
    Group();

    Group(const Group& other);

    operator bool() const;

    size_t size() const;

    const GroupInstance at(size_t index) const;

    const GroupInstance operator[](size_t index) const;

    Group& operator=(const Group& other);

    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:
    TypedGroup()
      : underlyingGroup_()
    {
    }

    size_t size() const
    {
        return underlyingGroup_ ? underlyingGroup_.size() : 0;
    }

    bool empty() const
    {
        return 0 == size();
    }

    Entry operator[](size_t index) const
    {
        return Entry(underlyingGroup_[index]);
    }

    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_;
};

struct ONIXS_CME_DROP_COPY_EXPORT MessageStringingFlag
{
    enum Enum
    {
        NoFieldInfo = 0x0,

        IncludeFieldTagNumber = 0x1,

        IncludeFieldName = 0x2
    };
};

typedef unsigned MessageStringingFlags;

class ONIXS_CME_DROP_COPY_EXPORT Message : public FieldSet
{
public:
    Message();

    Message(const Message& other);

    ~Message();

    FieldValueRef type() const;

    SequenceNumber sequenceNumber() const;

    Timestamp sendingTime() const;

    const Timestamp& receiveTime() const;

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

    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;
}

class ONIXS_CME_DROP_COPY_EXPORT BitmapField
{
public:
    typedef UInt32 BaseType;

    explicit BitmapField(BaseType bits = 0)
      : bits_(bits)
    {
    }

    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&);
 
}