BookManagement.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 <string>
 
#include <OnixS/CME/MDH/Decimal.h>
 
#include <OnixS/CME/MDH/DirectPriceLevel.h>
 
#include <OnixS/CME/MDH/MboBookTraits.h>
#include <OnixS/CME/MDH/MbpBookTraits.h>
 
#include <OnixS/CME/MDH/SettingGroup.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

inline void throwBadBboThreshold()
{
    throw std::runtime_error("Threshold for tracking best bids "
                             "or offers can't be a negative value. ");
}

class ONIXS_CMEMDH_LTWT BboThreshold
{
public:
    BboThreshold(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : group_(group ? *group : SettingGroup::null())
        , threshold_()
        , enabled_(false)
    {
    }

    BboThreshold(const BboThreshold& other)
        : group_(SettingGroup::null())
        , threshold_(other.threshold_)
        , enabled_(other.enabled_)
    {
    }

    ~BboThreshold() {}

    bool enabled() const
    {
        return enabled_;
    }

    BboThreshold& enabled(bool value)
    {
        group_.controlAssignment("BBO Threshold Enable", enabled_, value);
 
        return *this;
    }

    const Decimal& threshold() const
    {
        return threshold_;
    }

    BboThreshold& threshold(const Decimal& value)
    {
        if (0 <= value.mantissa())
        {
            group_.controlAssignment("BBO Threshold", threshold_, value);
        }
        else
        {
            throwBadBboThreshold();
        }
 
        return *this;
    }

    BboThreshold& operator=(const BboThreshold& other)
    {
        group_.controlChange("BBO Threshold Settings", &BboThreshold::assignNoControl, *this, other);
 
        return *this;
    }
 
protected:
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(MboBboTracking);

    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(ImpliedBboTracking);

    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(DirectBboTracking);

    const SettingGroup& group() const
    {
        return group_;
    }

    void assignNoControl(const BboThreshold& other)
    {
        threshold_ = other.threshold_;
        enabled_ = other.enabled_;
    }
 
private:
    // Group which the given set of settings belongs to.
    const SettingGroup& group_;
 
    // Actual threshold value.
    Decimal threshold_;
 
    // Indicates whether threshold must be used.
    bool enabled_;
};

ONIXS_CMEMDH_EXPORTED
bool thresholdExceeded(const Decimal&, const Decimal&, const Decimal&);

ONIXS_CMEMDH_EXPORTED
bool thresholdExceeded(const Decimal&, Int64, Int64);

class ONIXS_CMEMDH_LTWT MboBboTracking
{
public:
    MboBboTracking(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : price_(group)
    {
    }

    MboBboTracking(const MboBboTracking& other)
        : price_(other.price_)
    {
    }

    ~MboBboTracking() {}

    const BboThreshold& price() const
    {
        return price_;
    }

    BboThreshold& price()
    {
        return price_;
    }

    bool enabled() const
    {
        return (price_.enabled());
    }

    bool exceeded(const Order& previous, const Order& current) const
    {
        return (price_.enabled() && thresholdExceeded(price_.threshold(), previous.price(), current.price()));
    }

    MboBboTracking& operator=(const MboBboTracking& other)
    {
        group().controlChange("MBO BBO Tracking Settings", &MboBboTracking::assignNoControl, *this, other);
 
        return *this;
    }
 
protected:
    template <class>
    friend class BaseBookManagement;

    const SettingGroup& group() const
    {
        return price_.group();
    }

    void assignNoControl(const MboBboTracking& other)
    {
        price_.assignNoControl(other.price_);
    }
 
private:
    BboThreshold price_;
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const MboBboTracking&);

inline std::string toStr(const MboBboTracking& tracking)
{
    std::string str;
 
    toStr(str, tracking);
 
    return str;
}

class ONIXS_CMEMDH_LTWT ImpliedBboTracking
{
public:
    ImpliedBboTracking(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : price_(group)
        , quantity_(group)
    {
    }

    ImpliedBboTracking(const ImpliedBboTracking& other)
        : price_(other.price_)
        , quantity_(other.quantity_)
    {
    }

    ~ImpliedBboTracking() {}

    const BboThreshold& price() const
    {
        return price_;
    }

    BboThreshold& price()
    {
        return price_;
    }

    const BboThreshold& quantity() const
    {
        return quantity_;
    }

    BboThreshold& quantity()
    {
        return quantity_;
    }

    bool enabled() const
    {
        return (price_.enabled() || quantity_.enabled());
    }

    bool exceeded(const ImpliedPriceLevel& previous, const ImpliedPriceLevel& current) const
    {
        return (
            (price_.enabled() && thresholdExceeded(price_.threshold(), previous.price(), current.price()))
            || (quantity_.enabled() && thresholdExceeded(quantity_.threshold(), previous.quantity(), current.quantity())
            )
        );
    }

    ImpliedBboTracking& operator=(const ImpliedBboTracking& other)
    {
        group().controlChange("Implied BBO Tracking Settings", &ImpliedBboTracking::assignNoControl, *this, other);
 
        return *this;
    }
 
protected:
    template <class>
    friend class BaseBookManagement;

    const SettingGroup& group() const
    {
        return price_.group();
    }

    void assignNoControl(const ImpliedBboTracking& other)
    {
        price_.assignNoControl(other.price_);
        quantity_.assignNoControl(other.quantity_);
    }
 
private:
    BboThreshold price_;
    BboThreshold quantity_;
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const ImpliedBboTracking&);

inline std::string toStr(const ImpliedBboTracking& tracking)
{
    std::string str;
 
    toStr(str, tracking);
 
    return str;
}

class ONIXS_CMEMDH_LTWT DirectBboTracking : public ImpliedBboTracking
{
public:
    DirectBboTracking(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : ImpliedBboTracking(group)
        , numberOfOrders_(group)
    {
    }

    DirectBboTracking(const DirectBboTracking& other)
        : ImpliedBboTracking(static_cast<const ImpliedBboTracking&>(other))
        , numberOfOrders_(other.numberOfOrders_)
    {
    }

    ~DirectBboTracking() {}

    const BboThreshold& numberOfOrders() const
    {
        return numberOfOrders_;
    }

    BboThreshold& numberOfOrders()
    {
        return numberOfOrders_;
    }

    bool enabled() const
    {
        return (ImpliedBboTracking::enabled() || numberOfOrders_.enabled());
    }

    bool exceeded(const DirectPriceLevel& previous, const DirectPriceLevel& current) const
    {
        return (
            ImpliedBboTracking::exceeded(previous, current)
            || (numberOfOrders_.enabled()
                && thresholdExceeded(numberOfOrders_.threshold(), previous.numberOfOrders(), current.numberOfOrders()))
        );
    }

    DirectBboTracking& operator=(const DirectBboTracking& other)
    {
        group().controlChange("Direct BBO Tracking Settings", &DirectBboTracking::assignNoControl, *this, other);
 
        return *this;
    }
 
protected:
    template <class>
    friend class BaseBookManagement;

    void assignNoControl(const DirectBboTracking& other)
    {
        ImpliedBboTracking::assignNoControl(other);
 
        numberOfOrders_.assignNoControl(other.numberOfOrders_);
    }
 
private:
    BboThreshold numberOfOrders_;
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const DirectBboTracking&);

inline std::string toStr(const DirectBboTracking& tracking)
{
    std::string str;
 
    toStr(str, tracking);
 
    return str;
}

template <class BboTracking>
class BaseBookManagement
{
public:
    BaseBookManagement(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : maintain_(false)
        , bboTracking_(group)
    {
    }

    BaseBookManagement(const BaseBookManagement& other)
        : maintain_(other.maintain_)
        , bboTracking_(other.bboTracking_)
    {
    }

    ~BaseBookManagement() {}

    bool maintain() const
    {
        return maintain_;
    }

    BaseBookManagement& maintain(bool value)
    {
        group().controlAssignment("Maintain", maintain_, value);
 
        return *this;
    }

    const BboTracking& bboTracking() const
    {
        return bboTracking_;
    }

    BboTracking& bboTracking()
    {
        return bboTracking_;
    }

    BaseBookManagement& operator=(const BaseBookManagement& other)
    {
        group().controlChange("Base Book Management Settings", &BaseBookManagement::assignNoControl, *this, other);
 
        return *this;
    }
 
protected:
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(BookManagement);

    const SettingGroup& group() const
    {
        return bboTracking_.group();
    }

    void assignNoControl(const BaseBookManagement& other)
    {
        maintain_ = other.maintain_;
 
        bboTracking_.assignNoControl(other.bboTracking_);
    }
 
private:
    // Indicates whether feature is enabled.
    bool maintain_;
 
    // Parameters for tracking.
    BboTracking bboTracking_;
};

template <class BboTracking, typename Depth>
class FixedDepthBookManagement : public BaseBookManagement<BboTracking>
{
public:
    FixedDepthBookManagement(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR, Depth defaultDepth = 0)
        : Base(group)
        , defaultDepth_(defaultDepth)
    {
    }

    FixedDepthBookManagement(const FixedDepthBookManagement& other)
        : Base(static_cast<const Base&>(other))
        , defaultDepth_(other.defaultDepth_)
    {
    }

    ~FixedDepthBookManagement() {}

    Depth defaultDepth() const
    {
        return defaultDepth_;
    }

    FixedDepthBookManagement& defaultDepth(Depth value)
    {
        this->group().controlAssignment("Default Depth", defaultDepth_, value);
 
        return *this;
    }

    FixedDepthBookManagement& operator=(const FixedDepthBookManagement& other)
    {
        this->group().controlChange(
            "Fixed Depth Book Management Settings", &FixedDepthBookManagement::assignNoControl, *this, other
        );
 
        return *this;
    }
 
private:
    // Lets grouping and value assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(BookManagement);
 
    // Alias for the base class.
    typedef BaseBookManagement<BboTracking> Base;
 
    //
 
    Depth defaultDepth_;
 
    // Re-initializes as a copy of the other instance
    // without involving value assignment control services.
    void assignNoControl(const FixedDepthBookManagement& other)
    {
        Base::assignNoControl(other);
 
        defaultDepth_ = other.defaultDepth_;
    }
};

template <class BboTracking, typename Depth>
class AnyDepthBookManagement : public BaseBookManagement<BboTracking>
{
public:
    AnyDepthBookManagement(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : Base(group)
    {
    }

    AnyDepthBookManagement(const AnyDepthBookManagement& other)
        : Base(static_cast<const Base&>(other))
    {
    }

    AnyDepthBookManagement& operator=(const AnyDepthBookManagement& other)
    {
        this->group().controlChange(
            "Any Depth Book Management Settings", &AnyDepthBookManagement::assignNoControl, *this, other
        );
 
        return *this;
    }
 
private:
    // Lets grouping and value assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(BookManagement);
 
    // Alias for the base class.
    typedef BaseBookManagement<BboTracking> Base;
 
    Depth reserved_;
 
    // Re-initializes as a copy of the other instance
    // without involving value assignment control services.
    void assignNoControl(const AnyDepthBookManagement& other)
    {
        Base::assignNoControl(other);
    }
};

struct ONIXS_CMEMDH_LTWT BookUpdateNotification
{
    typedef UInt32 Base;
 
    enum Enum
    {
        OnSecurityChange,

        OnEndOfEvent
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, BookUpdateNotification::Enum);

inline std::string toStr(BookUpdateNotification::Enum strategy)
{
    std::string str;
 
    toStr(str, strategy);
 
    return str;
}
 
// Aliases for instantiations.

typedef AnyDepthBookManagement<MboBboTracking, SortedOrders::size_type> MboBookManagement;

typedef FixedDepthBookManagement<DirectBboTracking, MbpBookDepth> DirectBookManagement;

typedef FixedDepthBookManagement<ImpliedBboTracking, MbpBookDepth> ImpliedBookManagement;

typedef BaseBookManagement<ImpliedBboTracking> ConsolidatedBookManagement;

class ONIXS_CMEMDH_LTWT BookManagement : public SettingGroup
{
public:
    BookManagement(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : SettingGroup(controller)
        , mboBooks_(&group())
        , directBooks_(&group(), 10)
        , impliedBooks_(&group(), 2)
        , updateNotification_(BookUpdateNotification::OnEndOfEvent)
    {
    }

    BookManagement(const BookManagement& other)
        : SettingGroup()
        , mboBooks_(other.mboBooks_)
        , directBooks_(other.directBooks_)
        , impliedBooks_(other.impliedBooks_)
        , consolidatedBooks_(other.consolidatedBooks_)
        , updateNotification_(other.updateNotification_)
    {
    }
 
    // Finalizes the instance.
    ~BookManagement() {}

    const MboBookManagement& mboBooks() const
    {
        return mboBooks_;
    }

    MboBookManagement& mboBooks()
    {
        return mboBooks_;
    }

    const DirectBookManagement& directBooks() const
    {
        return directBooks_;
    }

    DirectBookManagement& directBooks()
    {
        return directBooks_;
    }

    const ImpliedBookManagement& impliedBooks() const
    {
        return impliedBooks_;
    }

    ImpliedBookManagement& impliedBooks()
    {
        return impliedBooks_;
    }

    const ConsolidatedBookManagement& consolidatedBooks() const
    {
        return consolidatedBooks_;
    }

    ConsolidatedBookManagement& consolidatedBooks()
    {
        return consolidatedBooks_;
    }

    BookUpdateNotification::Enum updateNotification() const
    {
        return updateNotification_;
    }

    BookManagement& updateNotification(BookUpdateNotification::Enum value)
    {
        group().controlAssignment("Update Notification", updateNotification_, value);
 
        return *this;
    }

    BookManagement& operator=(const BookManagement& other)
    {
        group().controlChange("Book Management Settings", &BookManagement::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    // Lets grouping and value
    // assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(HandlerSettings);
 
    // Subsets of parameters.
 
    MboBookManagement mboBooks_;
 
    DirectBookManagement directBooks_;
    ImpliedBookManagement impliedBooks_;
 
    ConsolidatedBookManagement consolidatedBooks_;
 
    BookUpdateNotification::Enum updateNotification_;
 
    // Casts the given instance to an
    // instance of SettingGroup class.
    const SettingGroup& group() const
    {
        return *this;
    }
 
    // Re-initializes the given instance
    // as a copy of the other one without
    // involving assignment control service.
    void assignNoControl(const BookManagement& other)
    {
        mboBooks_.assignNoControl(other.mboBooks_);
 
        directBooks_.assignNoControl(other.directBooks_);
 
        impliedBooks_.assignNoControl(other.impliedBooks_);
 
        consolidatedBooks_.assignNoControl(other.consolidatedBooks_);
 
        updateNotification_ = other.updateNotification_;
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const BookManagement&);

inline std::string toStr(const BookManagement& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}
 
ONIXS_CMEMDH_NAMESPACE_END