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

ONIXS_CONFLATEDUDP_LTWT_CLASS
InstrumentSelection
{
public:
    typedef 
    TinySet<SecurityId>
    SecurityIds;

    typedef 
    TinyStrSet
    Symbols;

    typedef 
    TinyStrSet
    SecurityGroups;

    typedef 
    TinyStrSet
    Assets;

    InstrumentSelection()
    {
    }

    InstrumentSelection(
        const 
        InstrumentSelection& other)
        : securityIds_(
            other.securityIds())
        , securityGroups_(
            other.securityGroups())
        , symbols_(
            other.symbols())
        , assets_(
            other.assets_)
    {
    }

    const 
    SecurityIds& 
    securityIds() const
    {
        return securityIds_;
    }

    SecurityIds& 
    securityIds()
    {
        return securityIds_;
    }

    const 
    SecurityGroups& 
    securityGroups() const
    {
        return securityGroups_;
    }

    SecurityGroups& 
    securityGroups()
    {
        return securityGroups_;
    }

    const 
    Symbols& 
    symbols() const
    {
        return symbols_;
    }

    Symbols& 
    symbols()
    {
        return symbols_;
    }

    const 
    Assets& 
    assets() const
    {
        return assets_;
    }

    Assets& 
    assets()
    {
        return assets_;
    }

    void clear()
    {
        securityIds_.clear();
        securityGroups_.clear();
 
        symbols_.clear();
        assets_.clear();
    }

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

ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    const 
    InstrumentSelection&);

inline
std::string
toStr(
    const 
    InstrumentSelection& 
    selection)
{
    std::string str;
 
    toStr(str, selection);
 
    return str;
}
 
//

inline 
bool 
selected(
    const 
    InstrumentSelection::
    SecurityIds& ids,
    SecurityId id)
{
    return (
        ids.empty() || 
        (ids.end() != ids.find(id))
    );
}

inline 
bool
selected(
    const TinyStrSet& selection,
    const StrRef& value)
{
    return (
        value.empty()
        ||
        selection.empty() 
        || 
        (selection.end() != 
        selection.find(value))
    );
}

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