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/MDH/messaging/Integral.h>
#include <OnixS/CME/MDH/messaging/StrRef.h>
 
#include <OnixS/CME/MDH/Security.h>
#include <OnixS/CME/MDH/TinySet.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

class ONIXS_CMEMDH_LTWT 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_CMEMDH_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, Messaging::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_CMEMDH_NAMESPACE_END