Book.cpp

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.
*/
#include "Book.h"
 
namespace Samples {
 
Order& Book::store(OrderPtr newEntry)
{
    return store(newEntry, newEntry->id());
}
 
CrossOrder& Book::store(CrossOrderPtr entry)
{
    const Guard guard(mutex_);
 
    store(entry->sellSideOrder_);
    store(entry->buySideOrder_);
 
    const auto res = crossOrders_.insert(std::make_pair(entry->id(), entry));
 
    if (!res.second)
        throw std::domain_error("Cross orders already has an entry registered under ID = '" + std::to_string(entry->id()) + "'.");
 
    return *res.first->second;
}
 
Order& Book::store(OrderPtr newEntry, BookEntryId id)
{
    assert(newEntry);
 
    const Guard guard(mutex_);
 
    const auto res = entries_.emplace(
        std::piecewise_construct,
        std::forward_as_tuple(id),
        std::forward_as_tuple(newEntry)
    );
 
    if (!res.second)
        throw std::domain_error("Book already has an entry registered under ID = '" + std::to_string(id) + "'.");
 
    auto& order = res.first->second;
 
    assert(id == order->id());
 
    return *order;
}
 
Book::OrdersList Book::getEntries(std::function<bool(const Order&)> predicate)
{
    OrdersList list;
 
    const Guard guard(mutex_);
 
    for (const auto& entry : entries_)
        if(predicate(*entry.second))
            list.push_back(entry.second);
 
    return list;
}
 
OptionalRef<Order> Book::find(BookEntryId id)
{
    const Guard guard(mutex_);
 
    const auto entry = entries_.find(id);
    return entry == entries_.end() ? OptionalRef<Order>{} : OptionalRef<Order>{entry->second};
}
 
OptionalRef<CrossOrder> Book::findCross(BookEntryId id)
{
    const Guard guard(mutex_);
 
    const auto entry = crossOrders_.find(id);
    return entry == crossOrders_.end() ? OptionalRef<CrossOrder>{} : OptionalRef<CrossOrder>{entry->second};
}
 
}