Filtering.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/ConflatedUDP/Integral.h>
#include <OnixS/CME/ConflatedUDP/Security.h>
#include <OnixS/CME/ConflatedUDP/TinySet.h>

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

/// Represents selection of instruments whose 
/// market data is to be processed by the Handler.
ONIXS_CONFLATEDUDP_LTWT_CLASS
InstrumentSelection
{
public:
    /// Collection of security ids specified 
    /// for given instrument selection. 
    typedef 
    TinySet<SecurityId>
    SecurityIds;

    /// Collection of symbols specified 
    /// for given instrument selection. 
    typedef 
    TinyStrSet
    Symbols;

    /// Collection of security groups specified 
    /// for given instrument selection. 
    typedef 
    TinyStrSet
    SecurityGroups;

    /// Collection of assets specified 
    /// for given instrument selection. 
    typedef 
    TinyStrSet
    Assets;

    /// Initializes empty selection. 
    InstrumentSelection()
    {
    }

    /// Initializes selection as 
    /// copy of the other instance. 
    InstrumentSelection(
        const 
        InstrumentSelection& other)
        : securityIds_(
            other.securityIds())
        , securityGroups_(
            other.securityGroups())
        , symbols_(
            other.symbols())
        , assets_(
            other.assets_)
    {
    }

    /// Securities selected by their identifiers.
    const 
    SecurityIds& 
    securityIds() const
    {
        return securityIds_;
    }

    /// Securities selected by their identifiers.
    SecurityIds& 
    securityIds()
    {
        return securityIds_;
    }

    /// Securities selected by their groups.
    const 
    SecurityGroups& 
    securityGroups() const
    {
        return securityGroups_;
    }

    /// Securities selected by their groups.
    SecurityGroups& 
    securityGroups()
    {
        return securityGroups_;
    }

    /// Securities selected by their symbols.
    const 
    Symbols& 
    symbols() const
    {
        return symbols_;
    }

    /// Securities selected by their symbols.
    Symbols& 
    symbols()
    {
        return symbols_;
    }

    /// Securities selected by their assets.
    const 
    Assets& 
    assets() const
    {
        return assets_;
    }

    /// Securities selected by their assets.
    Assets& 
    assets()
    {
        return assets_;
    }

    /// Clears selection.
    void clear()
    {
        securityIds_.clear();
        securityGroups_.clear();

        symbols_.clear();
        assets_.clear();
    }

    /// Re-initializes selection as 
    /// copy of the other instance. 
    InstrumentSelection&
    operator =(
        const 
        InstrumentSelection& other)
    {
        if (this != &other)
        {
            SecurityIds 
            ids(
                other.securityIds());

            SecurityGroups 
            groups(
                other.securityGroups());

            Symbols symbols(
                other.symbols());

            Assets assets(
                other.assets());

            //

            securityIds_.swap(ids);
            securityGroups_.swap(groups);

            symbols_.swap(symbols);
            assets_.swap(assets);
        }

        return *this;
    }

private:
    SecurityIds securityIds_;
    SecurityGroups securityGroups_;

    Symbols symbols_;
    Assets assets_;
};

/// Serializes instrument selection into text presentation. 
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    const 
    InstrumentSelection&);

/// Serializes instrument selection into text presentation. 
inline
std::string
toStr(
    const 
    InstrumentSelection& 
    selection)
{
    std::string str;

    toStr(str, selection);

    return str;
}

//

/// Checks whether security with given 
/// identifier belongs to given selection.
inline 
bool 
selected(
    const 
    InstrumentSelection::
    SecurityIds& ids,
    SecurityId id)
{
    return (
        ids.empty() || 
        (ids.end() != ids.find(id))
    );
}

/// Checks whether security with given 
/// attribute belongs to given selection.
inline 
bool
selected(
    const TinyStrSet& selection,
    const StrRef& value)
{
    return (
        value.empty()
        ||
        selection.empty() 
        || 
        (selection.end() != 
        selection.find(value))
    );
}

/// Checks whether security 
/// belongs to given selection.
inline
bool
selected(
    const InstrumentSelection& selection,
    const Security& security)
{
    return (
        selected(
            selection.securityIds(), 
            security.id())
        &&
        selected(
            selection.securityGroups(), 
            security.group())
        &&
        selected(
            selection.symbols(), 
            security.symbol())
        &&
        selected(
            selection.assets(), 
            security.asset())
    );
}

ONIXS_CONFLATEDUDP_NAMESPACE_END