FeedEngineSettings.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 <OnixS/SgxTitan/MarketData/Itch/FeedEngine.h>

#include "Formatting.h"
#include "Formatting.Helpers.h"

#include <sstream>

#include "NamespaceHelper.h"

using namespace std;

ONIXS_HANDLER_NAMESPACE_BEGIN

ThreadAffinity::ThreadAffinity() 
: indices_(new CpuIndexes())
{
}

ThreadAffinity::ThreadAffinity(const ThreadAffinity& other)
 : indices_(new CpuIndexes())
{
    *indices_ = *other.indices_;
}

ThreadAffinity::~ThreadAffinity()
{
    delete indices_;
}

bool ThreadAffinity::empty() const
{
    return indices_->empty();
}

void ThreadAffinity::copyTo(CpuIndexes& indices) const
{
    indices.insert(indices_->begin(), indices_->end());
}

bool ThreadAffinity::insert(CpuIndex index)
{
    return indices_->insert(index).second;
}

bool ThreadAffinity::erase(CpuIndex index)
{
    return indices_->erase(index);
}

void ThreadAffinity::clear()
{
    indices_->clear();
}

ThreadAffinity& ThreadAffinity::operator =(const ThreadAffinity& other)
{
    *indices_ = *other.indices_;

    return *this;
}

/// Returns the string representation.
std::string ThreadAffinity::toString() const
{
    Util::TextBuilder builder;
    builder << Util::JoinWrapper<CpuIndexes>(*indices_, ",");
    return builder.toString();
}

FeedEngineSettings::FeedEngineSettings()
    : threadAffinity_()
    , threadCount_(1)
    , dataWaitTime_(10)
    , spinBeforeIdleTime_(1)
    , socketBufferSize_(8 * 1024 * 1024)
{
}

FeedEngineSettings::~FeedEngineSettings()
{
}

string FeedEngineSettings::toString() const
{
    ostringstream out;
    out << *this;
    return out.str();
}

std::ostream & operator << (std::ostream & stream, const FeedEngineSettings & settings)
{
    stream << "FeedEngineSettings [dataWaitTime=" << settings.dataWaitTime()
        << ", " << "threadAffinity=" << settings.threadAffinity().toString()
        << ", " << "threadCount=" << settings.threadCount()
        << ", " << "spinBeforeIdleTime=" << settings.spinBeforeIdleTime()
        << ", " << "udpSocketBufferSize=" << settings.socketBufferSize()
        << "]";

    return stream;
}


ONIXS_HANDLER_NAMESPACE_END