Trade.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/Eurex/MarketData/ABI.h>
#include <OnixS/Eurex/MarketData/Compiler.h>
#include <OnixS/Eurex/MarketData/DepthSnapshot.h>
#include <OnixS/Eurex/MarketData/DepthIncremental.h>

namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {
            /// Trade.
            template< class TTradeEntry >
            class Trade
            {
            public:
                /// Initializes an instance.
                Trade (SecurityId id, UInt32 sequenceNumber, const TTradeEntry& tradeEntry);

                /// Unique instrument ID as qualified by the
                /// exchange per tag 22-SecurityIDSource (tag 48).
                SecurityId securityId() const;

                /// Defines when the trade happens.
                ///
                /// Only present for TradeCondition=AW.
                TrdType::Enum type() const
                {
                    return tradeEntry_.trdType();
                }

                /// Defines the trade condition.
                TradeConditionSet condition() const
                {
                    return tradeEntry_.tradeCondition();
                }

                /// Trade volume
                bool volume (Decimal& value) const
                {
                    return tradeEntry_.mdEntrySize (value);
                }

                /// Trade price
                bool price (Decimal& value) const
                {
                    return tradeEntry_.mdEntryPx (value);
                }

                /// Returns group entry (FIX fields) of underlying message.
                /// Entry contains all the data related with given trade.
                const TTradeEntry& underlyingEntry() const
                {
                    return tradeEntry_;
                }

                /// Sequence number of the last processed message
                UInt32 sequenceNumber() const
                {
                    return sequenceNumber_;
                }

                /// Underlying entry size
                UInt32 size() const;

                /// Returns text presentation.
                std::string toString() const;

                /// Appends text presentation.
                virtual void toString (std::string&) const = 0;

                virtual ~Trade() { }

            protected:
                SecurityId securityId_;
                UInt32 sequenceNumber_;

                // Underlying trade entry.
                const TTradeEntry& tradeEntry_;
            };

            template< class TTradeEntry >
            Trade<TTradeEntry>::Trade (SecurityId securityId, UInt32 sequenceNumber, const TTradeEntry& tradeEntry)
                : securityId_ (securityId)
                , sequenceNumber_ (sequenceNumber)
                , tradeEntry_ (tradeEntry)
            {
            }

            template< class TTradeEntry >
            SecurityId Trade<TTradeEntry>::securityId() const
            {
                return securityId_;
            }

            template< class TTradeEntry >
            UInt32 Trade<TTradeEntry>::size() const
            {
                Decimal size;
                tradeEntry_.mdEntrySize (size);
                return size;
            }

            template< class TTradeEntry >
            std::string Trade<TTradeEntry>::toString() const
            {
                std::string str;

                toString (str);

                return str;
            }

            /// Snapshot trade
            class ONIXS_EUREX_EMDI_API SnapshotTrade : public Trade<MDSnapshotEntry>
            {
            public:
                /// Appends text presentation.
                void toString (std::string&) const ONIXS_EUREX_EMDI_OVERRIDE;

            protected:
                /// Initializes an instance.
                SnapshotTrade (SecurityId id, UInt32 sequenceNumber, const MDSnapshotEntry& tradeEntry);

            private:
                /// Initializes instance as reference to the other one.
                SnapshotTrade (const SnapshotTrade&);

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

                // Underlying implementation.
                void* impl_;
            };

            /// Incremental trade
            class ONIXS_EUREX_EMDI_API IncrementalTrade : public Trade<MDIncrementalEntry>
            {
            public:
                /// MDEntryID
                UInt32 entryId() const;

                /// Appends text presentation.
                void toString (std::string&) const ONIXS_EUREX_EMDI_OVERRIDE;

            protected:
                /// Initializes an instance.
                IncrementalTrade (SecurityId id, UInt32 sequenceNumber, const MDIncrementalEntry& tradeEntry);

            private:
                /// Initializes instance as reference to the other one.
                IncrementalTrade (const IncrementalTrade&);

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

                // Underlying implementation.
                void* impl_;
            };
        }
    }
}