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
        {
            template< class TTradeEntry >
            class Trade
            {
            public:
                Trade (SecurityId id, UInt32 sequenceNumber, const TTradeEntry& tradeEntry);

                SecurityId securityId() const;

                TrdType::Enum type() const
                {
                    return tradeEntry_.trdType();
                }

                TradeConditionSet condition() const
                {
                    return tradeEntry_.tradeCondition();
                }

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

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

                const TTradeEntry& underlyingEntry() const
                {
                    return tradeEntry_;
                }

                UInt32 sequenceNumber() const
                {
                    return sequenceNumber_;
                }

                UInt32 size() const;

                std::string toString() const;

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

            class ONIXS_EUREX_EMDI_API SnapshotTrade : public Trade<MDSnapshotEntry>
            {
            public:
                void toString (std::string&) const ONIXS_EUREX_EMDI_OVERRIDE;
 
            protected:
                SnapshotTrade (SecurityId id, UInt32 sequenceNumber, const MDSnapshotEntry& tradeEntry);
 
            private:
                SnapshotTrade (const SnapshotTrade&);

                SnapshotTrade& operator = (const SnapshotTrade&);
 
                // Underlying implementation.
                void* impl_;
            };

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

                void toString (std::string&) const ONIXS_EUREX_EMDI_OVERRIDE;
 
            protected:
                IncrementalTrade (SecurityId id, UInt32 sequenceNumber, const MDIncrementalEntry& tradeEntry);
 
            private:
                IncrementalTrade (const IncrementalTrade&);

                IncrementalTrade& operator = (const IncrementalTrade&);
 
                // Underlying implementation.
                void* impl_;
            };
        }
    }
}