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

/// Raises exception on invalid best bid/offer threshold value.
inline void throwBadBboThreshold()
{
    throw std::runtime_error("Threshold for tracking best bids "
                             "or offers can't be a negative value. ");
}

/// Defines tracking attributes for a particular BBO parameter.
class ONIXS_CMEMDH_LTWT BboThreshold
{
public:
    /// Initializes BBO attribute (price, qty, etc) tracking.
    ///
    /// Optional setting group instance allows binding the given
    /// set of settings to a particular group of settings.
    BboThreshold(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : group_(group ? *group : SettingGroup::null())
        , threshold_()
        , enabled_(false)
    {
    }

    /// Initializes as a copy of the
    /// other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    BboThreshold(const BboThreshold& other)
        : group_(SettingGroup::null())
        , threshold_(other.threshold_)
        , enabled_(other.enabled_)
    {
    }

    /// Finalizes the group.
    ~BboThreshold() {}

    /// Indicates whether tracking is enabled.
    bool enabled() const
    {
        return enabled_;
    }

    /// Indicates whether tracking is enabled.
    BboThreshold& enabled(bool value)
    {
        group_.controlAssignment("BBO Threshold Enable", enabled_, value);

        return *this;
    }

    /// Threshold for the parameter being tracked.
    const Decimal& threshold() const
    {
        return threshold_;
    }

    /// Updates threshold for the
    /// parameter being tracked.
    BboThreshold& threshold(const Decimal& value)
    {
        if (0 <= value.mantissa())
        {
            group_.controlAssignment("BBO Threshold", threshold_, value);
        }
        else
        {
            throwBadBboThreshold();
        }

        return *this;
    }

    /// Re-initializes as a copy of the other one.
    ///
    /// Attributes controlling value assignment aren't
    /// cloned and thus only settings are copied.
    BboThreshold& operator=(const BboThreshold& other)
    {
        group_.controlChange("BBO Threshold Settings", &BboThreshold::assignNoControl, *this, other);

        return *this;
    }

protected:
    /// Lets grouping and value assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(MboBboTracking);

    /// Lets grouping and value assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(ImpliedBboTracking);

    /// Lets grouping and value assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(DirectBboTracking);

    /// Instance of a group which the
    /// given set of settings belongs to.
    const SettingGroup& group() const
    {
        return group_;
    }

    /// Re-initializes the instance as a copy of the
    /// other one and bypassing assignment control.
    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_;
};

/// Checks whether new value exceeds given
/// threshold in compare to the old value.
ONIXS_CMEMDH_EXPORTED
bool thresholdExceeded(const Decimal&, const Decimal&, const Decimal&);

/// Checks whether new value exceeds given
/// threshold in compare to the old value.
ONIXS_CMEMDH_EXPORTED
bool thresholdExceeded(const Decimal&, Int32, Int32);

/// Defines tracking for BBO in MBO books.
class ONIXS_CMEMDH_LTWT MboBboTracking
{
public:
    /// Initializes tracking settings
    /// with optional grouping services.
    MboBboTracking(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : price_(group)
    {
    }

    /// Initializes the instance as a copy of the other one.
    ///
    /// Attributes controlling value assignment aren't
    /// cloned and thus only settings' values are copied.
    MboBboTracking(const MboBboTracking& other)
        : price_(other.price_)
    {
    }

    /// Finalizes the instance.
    ~MboBboTracking() {}

    /// Price tracking attributes.
    const BboThreshold& price() const
    {
        return price_;
    }

    /// Price tracking attributes.
    BboThreshold& price()
    {
        return price_;
    }

    /// Indicates whether tracking enabled at all.
    bool enabled() const
    {
        return (price_.enabled());
    }

    /// Checks whether any of thresholds is exceeded.
    bool exceeded(const Order& previous, const Order& current) const
    {
        return (price_.enabled() && thresholdExceeded(price_.threshold(), previous.price(), current.price()));
    }

    /// Re-initializes the instance
    /// as a copy of the other one.
    MboBboTracking& operator=(const MboBboTracking& other)
    {
        group().controlChange("MBO BBO Tracking Settings", &MboBboTracking::assignNoControl, *this, other);

        return *this;
    }

protected:
    /// Lets grouping and value assignment control functioning.
    template <class>
    friend class BaseBookManagement;

    /// Instance of the group of setting which
    /// the given set of settings belongs to.
    const SettingGroup& group() const
    {
        return price_.group();
    }

    /// Re-initializes as a copy of the other instance
    /// without involving value assignment control services.
    void assignNoControl(const MboBboTracking& other)
    {
        price_.assignNoControl(other.price_);
    }

private:
    BboThreshold price_;
};

/// Serializes BBO tracking parameters into string.
ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const MboBboTracking&);

/// Serializes BBO tracking parameters into string.
inline std::string toStr(const MboBboTracking& tracking)
{
    std::string str;

    toStr(str, tracking);

    return str;
}

/// Defines tracking for BBO in implied books.
class ONIXS_CMEMDH_LTWT ImpliedBboTracking
{
public:
    /// Initializes tracking with
    /// optional grouping facilities.
    ImpliedBboTracking(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : price_(group)
        , quantity_(group)
    {
    }

    /// Initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    ImpliedBboTracking(const ImpliedBboTracking& other)
        : price_(other.price_)
        , quantity_(other.quantity_)
    {
    }

    /// Finalizes the instance.
    ~ImpliedBboTracking() {}

    /// Price tracking attributes.
    const BboThreshold& price() const
    {
        return price_;
    }

    /// Price tracking attributes.
    BboThreshold& price()
    {
        return price_;
    }

    /// Quantity tracking attributes.
    const BboThreshold& quantity() const
    {
        return quantity_;
    }

    /// Quantity tracking attributes.
    BboThreshold& quantity()
    {
        return quantity_;
    }

    /// Indicates whether tracking enabled at all.
    bool enabled() const
    {
        return (price_.enabled() || quantity_.enabled());
    }

    /// Checks whether any of thresholds is exceeded.
    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())
            )
        );
    }

    /// Re-initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    ImpliedBboTracking& operator=(const ImpliedBboTracking& other)
    {
        group().controlChange("Implied BBO Tracking Settings", &ImpliedBboTracking::assignNoControl, *this, other);

        return *this;
    }

protected:
    /// Lets grouping and value assignment control functioning.
    template <class>
    friend class BaseBookManagement;

    /// Instance of the group of setting which
    /// the given set of settings belongs to.
    const SettingGroup& group() const
    {
        return price_.group();
    }

    /// Re-initializes as a copy of the other instance
    /// without involving value assignment control services.
    void assignNoControl(const ImpliedBboTracking& other)
    {
        price_.assignNoControl(other.price_);
        quantity_.assignNoControl(other.quantity_);
    }

private:
    BboThreshold price_;
    BboThreshold quantity_;
};

/// Serializes BBO tracking parameters into string.
ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const ImpliedBboTracking&);

/// Serializes BBO tracking parameters into string.
inline std::string toStr(const ImpliedBboTracking& tracking)
{
    std::string str;

    toStr(str, tracking);

    return str;
}

/// Defines tracking for BBO in direct books.
class ONIXS_CMEMDH_LTWT DirectBboTracking : public ImpliedBboTracking
{
public:
    /// Initializes tracking with the
    /// optional grouping services enabled.
    DirectBboTracking(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : ImpliedBboTracking(group)
        , numberOfOrders_(group)
    {
    }

    /// Initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    DirectBboTracking(const DirectBboTracking& other)
        : ImpliedBboTracking(static_cast<const ImpliedBboTracking&>(other))
        , numberOfOrders_(other.numberOfOrders_)
    {
    }

    /// Finalizes the instance.
    ~DirectBboTracking() {}

    /// Tracking for order quantity.
    const BboThreshold& numberOfOrders() const
    {
        return numberOfOrders_;
    }

    /// Tracking for order quantity.
    BboThreshold& numberOfOrders()
    {
        return numberOfOrders_;
    }

    /// Indicates whether tracking enabled at all.
    bool enabled() const
    {
        return (ImpliedBboTracking::enabled() || numberOfOrders_.enabled());
    }

    /// Checks whether any of thresholds is exceeded.
    bool exceeded(const DirectPriceLevel& previous, const DirectPriceLevel& current) const
    {
        return (
            ImpliedBboTracking::exceeded(previous, current)
            || (numberOfOrders_.enabled()
                && thresholdExceeded(numberOfOrders_.threshold(), previous.numberOfOrders(), current.numberOfOrders()))
        );
    }

    /// Re-initializes instance as
    /// a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    DirectBboTracking& operator=(const DirectBboTracking& other)
    {
        group().controlChange("Direct BBO Tracking Settings", &DirectBboTracking::assignNoControl, *this, other);

        return *this;
    }

protected:
    /// Lets grouping and value
    /// assignment control functioning.
    template <class>
    friend class BaseBookManagement;

    /// Re-initializes as a copy of the other instance
    /// without involving value assignment control services.
    void assignNoControl(const DirectBboTracking& other)
    {
        ImpliedBboTracking::assignNoControl(other);

        numberOfOrders_.assignNoControl(other.numberOfOrders_);
    }

private:
    BboThreshold numberOfOrders_;
};

/// Serializes BBO tracking parameters into string.
ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const DirectBboTracking&);

/// Serializes BBO tracking parameters into string.
inline std::string toStr(const DirectBboTracking& tracking)
{
    std::string str;

    toStr(str, tracking);

    return str;
}

/// Parameters affecting book management machinery for
/// a particular book type (direct, implied, consolidated).
template <class BboTracking>
class BaseBookManagement
{
public:
    /// Initializes instance with the default values
    /// and setting validation facilities enabled.
    BaseBookManagement(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : maintain_(false)
        , bboTracking_(group)
    {
    }

    /// Initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    BaseBookManagement(const BaseBookManagement& other)
        : maintain_(other.maintain_)
        , bboTracking_(other.bboTracking_)
    {
    }

    /// Finalizes the instance.
    ~BaseBookManagement() {}

    /// Forces to build order book of a particular kind.
    ///
    /// Unless parameter is set to 'true', Handler doesn't
    /// construct and doesn't process data blocks for the
    /// books of given kind. If book isn't built, book snapshot
    /// retrieval is not possible.
    ///
    /// @note Default value is 'false'.
    bool maintain() const
    {
        return maintain_;
    }

    /// Forces Handler to maintain order books.
    BaseBookManagement& maintain(bool value)
    {
        group().controlAssignment("Maintain", maintain_, value);

        return *this;
    }

    /// Parameters affecting BBO tracking for
    /// books which given settings refer to.
    const BboTracking& bboTracking() const
    {
        return bboTracking_;
    }

    /// Parameters affecting BBO tracking for
    /// books which given settings refer to.
    BboTracking& bboTracking()
    {
        return bboTracking_;
    }

    /// Re-initializes the instance
    /// as a copy of other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    BaseBookManagement& operator=(const BaseBookManagement& other)
    {
        group().controlChange("Base Book Management Settings", &BaseBookManagement::assignNoControl, *this, other);

        return *this;
    }

protected:
    /// Lets grouping and value
    /// assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(BookManagement);

    /// Instance of the group of setting which
    /// the given set of settings belongs to.
    const SettingGroup& group() const
    {
        return bboTracking_.group();
    }

    /// Re-initializes as a copy of the other instance
    /// without involving value assignment control services.
    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_;
};

/// Parameters affecting book management machinery for
/// a particular book type (direct, implied, consolidated).
template <class BboTracking, typename Depth>
class FixedDepthBookManagement : public BaseBookManagement<BboTracking>
{
public:
    /// Initializes instance with defaults
    /// and optional grouping facilities.
    FixedDepthBookManagement(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR, Depth defaultDepth = 0)
        : Base(group)
        , defaultDepth_(defaultDepth)
    {
    }

    /// Initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    FixedDepthBookManagement(const FixedDepthBookManagement& other)
        : Base(static_cast<const Base&>(other))
        , defaultDepth_(other.defaultDepth_)
    {
    }

    /// Finalizes the instance.
    ~FixedDepthBookManagement() {}

    /// Defines default depth of order book for
    /// the security whose definition wasn't
    /// received or had no corresponding data.
    Depth defaultDepth() const
    {
        return defaultDepth_;
    }

    /// Defines default depth of order book for
    /// the security whose definition wasn't
    /// received or had no corresponding data.
    FixedDepthBookManagement& defaultDepth(Depth value)
    {
        this->group().controlAssignment("Default Depth", defaultDepth_, value);

        return *this;
    }

    /// Re-initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    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_;
    }
};

/// Parameters affecting book management machinery
/// for a books having variable depth like MBO ones.
template <class BboTracking, typename Depth>
class AnyDepthBookManagement : public BaseBookManagement<BboTracking>
{
public:
    /// Initializes the instance with default values.
    /// Optional parameter to enable grouping facilities.
    AnyDepthBookManagement(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : Base(group)
    {
    }

    /// Initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    AnyDepthBookManagement(const AnyDepthBookManagement& other)
        : Base(static_cast<const Base&>(other))
    {
    }

    /// Re-initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    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);
    }
};

/// Defines book update notification strategies.
struct ONIXS_CMEMDH_LTWT BookUpdateNotification
{
    /// Integral type used as basement for constants.
    typedef UInt32 Base;

    enum Enum
    {
        /// Book update event is raised once security id is changed in
        /// sequence of market data entries being processed by the Handler.
        ///
        /// @warning Given strategy does not follow MDP policy
        /// on exposing order books and thus can be used on own risk!
        /// Also, books may not be in a valid state (especially consolidated),
        /// as far as exposed earlier than data for entire market event
        /// is processed.
        OnSecurityChange,

        /// Book update event is raised at the end of market event.
        ///
        /// Direct books updates are raised at the end of real
        /// quotes updates, implied books updates are raised at
        /// the end of implied quotes updates and consolidated
        /// books updates are raised at the end of entire event.
        OnEndOfEvent
    };
};

/// Serializes book update notification policy into a string.
ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, BookUpdateNotification::Enum);

/// Serializes book update notification policy into a string.
inline std::string toStr(BookUpdateNotification::Enum strategy)
{
    std::string str;

    toStr(str, strategy);

    return str;
}

// Aliases for instantiations.

/// Management and tracking parameters for MBO books.
typedef AnyDepthBookManagement<MboBboTracking, SortedOrders::size_type> MboBookManagement;

/// Management and tracking parameters for direct books.
typedef FixedDepthBookManagement<DirectBboTracking, MbpBookDepth> DirectBookManagement;

/// Management and tracking parameters for implied books.
typedef FixedDepthBookManagement<ImpliedBboTracking, MbpBookDepth> ImpliedBookManagement;

/// Management and tracking parameters for consolidated books.
typedef BaseBookManagement<ImpliedBboTracking> ConsolidatedBookManagement;

/// Parameters affecting book management machinery.
class ONIXS_CMEMDH_LTWT BookManagement : public SettingGroup
{
public:
    /// Initializes instance with default values.
    BookManagement(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : SettingGroup(controller)
        , mboBooks_(&group())
        , directBooks_(&group(), 10)
        , impliedBooks_(&group(), 2)
        , updateNotification_(BookUpdateNotification::OnEndOfEvent)
    {
    }

    /// Initializes the instance
    /// as a copy of the other one.
    ///
    /// Attributes controlling value
    /// assignment aren't cloned and
    /// thus only settings are copied.
    BookManagement(const BookManagement& other)
        : SettingGroup()
        , mboBooks_(other.mboBooks_)
        , directBooks_(other.directBooks_)
        , impliedBooks_(other.impliedBooks_)
        , consolidatedBooks_(other.consolidatedBooks_)
        , updateNotification_(other.updateNotification_)
    {
    }

    // Finalizes the instance.
    ~BookManagement() {}

    /// Management and tracking parameters for direct books.
    const MboBookManagement& mboBooks() const
    {
        return mboBooks_;
    }

    /// Management and tracking parameters for direct books.
    MboBookManagement& mboBooks()
    {
        return mboBooks_;
    }

    /// Management and tracking parameters for direct books.
    const DirectBookManagement& directBooks() const
    {
        return directBooks_;
    }

    /// Management and tracking parameters for direct books.
    DirectBookManagement& directBooks()
    {
        return directBooks_;
    }

    /// Management and tracking parameters for implied books.
    const ImpliedBookManagement& impliedBooks() const
    {
        return impliedBooks_;
    }

    /// Management and tracking parameters for implied books.
    ImpliedBookManagement& impliedBooks()
    {
        return impliedBooks_;
    }

    /// Management and tracking parameters for consolidated books.
    const ConsolidatedBookManagement& consolidatedBooks() const
    {
        return consolidatedBooks_;
    }

    /// Management and tracking parameters for consolidated books.
    ConsolidatedBookManagement& consolidatedBooks()
    {
        return consolidatedBooks_;
    }

    /// Defines the way Handler raises onBookUpdated callbacks.
    ///
    /// @note Default is BookUpdateNotification::OnEndOfEvent.
    BookUpdateNotification::Enum updateNotification() const
    {
        return updateNotification_;
    }

    /// Defines the way Handler raises order book update event.
    BookManagement& updateNotification(BookUpdateNotification::Enum value)
    {
        group().controlAssignment("Update Notification", updateNotification_, value);

        return *this;
    }

    /// Copies settings from the given instance.
    ///
    /// Attributes controlling value assignment aren't
    /// cloned and thus only settings' values are copied.
    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_;
    }
};

/// Serializes book management settings into string.
ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const BookManagement&);

/// Serializes book management settings into string.
inline std::string toStr(const BookManagement& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

ONIXS_CMEMDH_NAMESPACE_END