Options.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/ICE/BOE/IceBoe.h>
 
#include <map>
#include <iostream>
#include <sstream>
 
#include "../Settings/Defaults.h"
 
namespace Samples {
 
typedef std::string Option;
typedef std::string OptionArg;
typedef std::vector<OptionArg> OptionArgs;
 
// Implements a carriage over command line arguments.
class ArgCarriage
{
public:
    ArgCarriage(size_t qty, char** args) noexcept
        : qty_(qty)
        , args_(args)
    {
    }
 
    // Checks whether the carriage is in a valid state.
    operator bool() const
    {
        return (0 < qty_);
    }
 
    // If valid, provides access to the argument
    // which the carriage currently points to.
    const char* operator*() const
    {
        assert(0 < qty_);
 
        return *args_;
    }
 
    // Advances the carriage to the next argument.
    void advance()
    {
        --qty_;
        ++args_;
    }
 
private:
    size_t qty_;
    char** args_;
};
 
[[noreturn]] inline void throwBadOption(const Char* arg)
{
    assert(arg);
 
    std::string issue;
 
    issue += "The given argument [";
    issue += arg;
    issue += "] does not represent an option which must begin with the '--' prefix. ";
 
    throw std::runtime_error(issue);
}
 
[[noreturn]] inline void throwDuplicatedOption(const Char* option)
{
    std::string issue;
 
    issue += "The given option [";
    issue += option;
    issue += "] is defined twice in the argument list. ";
 
    throw std::runtime_error(issue);
}
 
// Groups the command line arguments by options.
class Options
{
public:
    // Processes application input arguments and builds the option-to-values map.
    Options(size_t qty, char** args)
    {
        assert(0 < qty);
        assert(args);
 
        ArgCarriage carriage(qty, args);
 
        // Cuts application name.
        carriage.advance();
 
        // If there are arguments except the application name.
        if (carriage)
        {
            std::string option;
 
            if (isOption(*carriage, &option))
            {
                do
                {
                    carriage.advance();
 
                    const std::pair<Items::iterator, bool> inserted =
                        items_.insert(std::make_pair(option, OptionArgs()));
 
                    if (inserted.second)
                    {
                        OptionArgs& optionArgs = inserted.first->second;
 
                        while (carriage && !isOption(*carriage, &option))
                        {
                            optionArgs.push_back(*carriage);
 
                            carriage.advance();
                        }
                    }
                    else
                    {
                        throwDuplicatedOption(option.c_str());
                    }
                }
                while (carriage);
            }
            else
            {
                throwBadOption(*carriage);
            }
        }
    }
 
    // Transforms available options into the given destination.
    template <class Iterator>
    void get(Iterator target) const
    {
        std::transform(items_.begin(), items_.end(), target, PairFirst<Option, OptionArgs>());
    }
 
    // Exposes arguments for the given option. Returns null if option is not present.
    const OptionArgs* args(const char* option) const
    {
        return args(option ? std::string(option) : std::string());
    }
 
    // Exposes arguments for the given option. Returns null if option is not present.
    const OptionArgs* args(const std::string& option) const
    {
        const auto foundItem = items_.find(option);
        return (foundItem != items_.end() ? &foundItem->second : nullptr);
    }
 
private:
    template <typename First, typename Second>
    struct PairFirst
    {
        typedef std::pair<First, Second> Pair;
 
        inline First operator()(const Pair& item) const
        {
            return item.first;
        }
    };
 
    typedef std::map<Option, OptionArgs> Items;
    Items items_;
 
    // Checks whether the given argument represents an option. Extracts the option (cuts prefix) upon request.
    static bool isOption(const char* arg, std::string* option = nullptr)
    {
        assert(arg);
 
        const size_t argLength = strlen(arg);
 
        static const StrRef prefix = toStrRef("--");
 
        if (argLength > prefix.size() && prefix == StrRef(arg, prefix.size()) && prefix[0] != arg[prefix.size()])
        {
            if (option)
                option->assign(arg + prefix.size(), argLength - prefix.size());
 
            return true;
        }
 
        return false;
    }
};
 
// Enhances options manipulation services with data conversion facilities.
[[noreturn]] inline void throwOptionArgConversionFailed(const Char* option)
{
    assert(nullptr != option);
 
    std::string issue;
 
    issue += "Value for the option [";
    issue += option;
    issue += "] is not recognized. Run application help for information on valid values for the option. ";
 
    throw std::runtime_error(issue);
}
 
 
template <typename T>
bool fromStr(T& result, const std::string& s)
{
    return Messaging::fromStr(result, s.data(), s.size());
}
 
inline
bool fromStr(SessionStorageType::Enum& result, const std::string& s)
{
    try
    {
        result = SessionStorageType::parse(s);
        return true;
    }
    catch(...)
    {
        return false;
    }
}
 
template <typename Value>
class OptionArgConverter
{
public:
    OptionArgConverter(const Char* option = nullptr)
        : option_(option)
    {
    }
 
    Value operator()(const std::string& str) const
    {
        Value value = Value();
 
        if (!fromStr(value, str))
            throwOptionArgConversionFailed(option_);
 
        return value;
    }
 
private:
    const Char* option_;
};
 
template <>
class OptionArgConverter<std::string>
{
public:
    OptionArgConverter(const Char* = nullptr) {}
 
    std::string operator()(const std::string& str) const
    {
        return str;
    }
};
 
template <>
class OptionArgConverter<const Char*>
{
public:
    OptionArgConverter(const Char* = nullptr) {}
 
    const Char* operator()(const std::string& str) const
    {
        return str.c_str();
    }
};
 
template <typename Value>
inline void convertOptionArg(Value& value, const Char* option, const std::string& str)
{
    const OptionArgConverter<Value> converter(option);
 
    value = converter(str);
}
 
inline void throwBadOptionArgQty(const Char* option, size_t argQty, size_t minQty, size_t maxQty)
{
    assert(nullptr != option);
 
    std::string issue;
 
    issue += "Number of arguments for the option [";
 
    issue += option;
 
    issue += "] does not meet the requirements. "
             "It must be not less than ";
 
    toStr(issue, minQty);
 
    if (maxQty != static_cast<size_t>(-1))
    {
        issue += " and not greater than ";
 
        toStr(issue, maxQty);
    }
 
    issue += ". Meanwhile, the actual number is ";
 
    toStr(issue, argQty);
 
    issue += ". ";
 
    throw std::runtime_error(issue);
}
 
[[noreturn]] inline void throwReqiredOptionArgMissing(const Char* option)
{
    assert(nullptr != option);
 
    std::string issue;
 
    issue += "The required option [";
 
    issue += option;
 
    issue += "] or its argument is missing. ";
 
    throw std::runtime_error(issue);
}
 
template <typename Value, typename Iterator>
inline bool args(
    const Options& options,
    const Char* option,
    Iterator target,
    size_t minQty = 0,
    size_t maxQty = static_cast<size_t>(-1)
)
{
    if (const OptionArgs* args = options.args(option))
    {
        const size_t argQty = args->size();
 
        if (minQty <= argQty && maxQty >= argQty)
        {
            const OptionArgConverter<Value> converter(option);
 
            std::transform(args->begin(), args->end(), target, converter);
 
            return true;
        }
        else
        {
            throwBadOptionArgQty(option, argQty, minQty, maxQty);
        }
    }
 
    return false;
}
 
template <typename Value>
inline Value argOrDefault(const Options& options, const Char* option, const Value& defaultValue = Value())
{
    Value value = defaultValue;
 
    args<Value>(options, option, &value, 1, 1);
 
    return value;
}
 
template <typename Value, size_t Length>
inline const Value* argOrDefault(const Options& options, const Char* option, Value (&defaultValue)[Length])
{
    return argOrDefault<const Value*>(options, option, static_cast<const Value*>(defaultValue));
}
 
template <typename Value>
inline Value requiredArg(const Options& options, const Char* option)
{
    const OptionArgs* args = options.args(option);
 
    if (nullptr == args || 1 != args->size())
    {
        throwReqiredOptionArgMissing(option);
    }
 
    const OptionArgConverter<Value> converter(option);
 
    return converter((*args)[0]);
}
 
 
class ConfigurationBase
{
public:
    bool show() const
    {
        return exist(options(), "help");
    }
 
    void show(std::ostream& out) const
    {
        out << "Options affecting the application behavior: " << std::endl;
        showOptions(out);
        out << "  --help" << std::endl << "\tDisplays this message. " << std::endl;
    }
 
    virtual ~ConfigurationBase() = default;
 
protected:
    ConfigurationBase(size_t qty, char** args) noexcept
        : opts_(qty, args)
    {
    }
 
    const Options& options() const noexcept
    {
        return opts_;
    }
 
    virtual void showOptions(std::ostream&) const = 0;
 
    static bool exist(const Options& options, const Char* option)
    {
        assert(nullptr != option);
 
        return (nullptr != options.args(option));
    }
 
private:
    Options opts_;
};
 
 
class ConnectivityConfiguration : public virtual ConfigurationBase
{
public:
    std::string host() const
    {
        return argOrDefault(options(), "host", "127.0.0.1");
    }
 
    Port port() const
    {
        return argOrDefault(options(), "port", 10000);
    }
 
    bool useEmulator() const
    {
        return argOrDefault<std::string>(options(), "host", {}).empty();
    }
 
    bool useTLS() const
    {
        return !useEmulator() && port() == Default::TlsPort;
    }
 
protected:
    ConnectivityConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --host [host]" << std::endl
            << "\tIf not specified, an emulator is used." << std::endl
            << "  --port [port]" << std::endl;
    }
};
 
class SettingsConfiguration : public virtual ConfigurationBase
{
public:
    std::string settingsFile() const
    {
        return argOrDefault(options(), "settings", "");
    }
 
protected:
    SettingsConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --settings [settings]" << std::endl
            << "\tSettings file." << std::endl;
    }
};
 
class NetworkInterfaceConfiguration : public virtual ConfigurationBase
{
public:
    std::string nif() const
    {
        return requiredArg<std::string>(options(), "nif");
    }
 
protected:
    NetworkInterfaceConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --nif <nif>" << std::endl
            << "\tNetwork interface." << std::endl;
    }
};
 
class LogonConfiguration : public virtual ConfigurationBase
{
public:
    int clientId() const
    {
        return argOrDefault(options(), "clientId", Default::ClientId);
    }
 
    std::string userId() const
    {
        return argOrDefault(options(), "userId", Default::UserId);
    }
 
    std::string password() const
    {
        return argOrDefault(options(), "password", Default::Password);
    }
 
    std::string traderId() const
    {
        return argOrDefault(options(), "traderId", Default::TraderId);
    }
 
    std::string traderPwd() const
    {
        return argOrDefault(options(), "traderPwd", Default::TraderPassword);
    }
 
protected:
    LogonConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --clientId [clientId]" << std::endl
            << "  --userId [userId]" << std::endl
            << "  --password [password]" << std::endl
            << "  --traderId [traderId]" << std::endl
            << "  --traderPwd [traderPwd]" << std::endl;
    }
};
 
class StorageConfigurationBase : public virtual ConfigurationBase
{
public:
    ONIXS_ICEBOE_NAMESPACE::SessionStorageType::Enum storage() const
    {
        return argOrDefault(options(), "storage", defaultStorage());
    }
 
    ONIXS_ICEBOE_NAMESPACE::CpuIndex storageAffinity() const
    {
        if(storage() == SessionStorageType::AsyncFileBased)
            return requiredArg<CpuIndex>(options(), "storageCpu");
 
        return 0;
    }
 
protected:
    StorageConfigurationBase(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    virtual ONIXS_ICEBOE_NAMESPACE::SessionStorageType::Enum defaultStorage() const = 0;
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --storage [FileBased|AsyncFileBased|MemoryBased]" << std::endl
            << "\tDefault value is [" << SessionStorageType::toString(defaultStorage()) << "]" << std::endl
            << "  --storageCpu <cpu>" << std::endl
            << "\tAsyncFileBased storage CPU affinity" << std::endl
            ;
    }
};
 
template <ONIXS_ICEBOE_NAMESPACE::SessionStorageType::Enum DefaultStorage>
class StorageConfiguration : public StorageConfigurationBase
{
protected:
    ONIXS_ICEBOE_NAMESPACE::SessionStorageType::Enum defaultStorage() const override
    {
        return DefaultStorage;
    }
 
    StorageConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
        , StorageConfigurationBase(qty, args)
    {
    }
};
 
class MainThreadAffinityConfiguration : public virtual ConfigurationBase
{
public:
    Threading::CpuIndex mainThreadCpu() const
    {
        return argOrDefault(options(), "mainThreadCpu", Default::MainThreadCpuAffinity);
    }
 
protected:
    MainThreadAffinityConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --mainThreadCpu [mainThreadCpu]" << std::endl
            << "\tDefault value is [" << toStr(Default::MainThreadCpuAffinity) << "]" << std::endl;
    }
};
 
class ReceivingThreadAffinityConfiguration : public virtual ConfigurationBase
{
public:
    Threading::CpuIndex receivingThreadCpu() const
    {
        return argOrDefault(options(), "receivingThreadCpu", Default::ReceivingThreadCpuAffinity);
    }
 
protected:
    ReceivingThreadAffinityConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --receivingThreadCpu [mainThreadCpu]" << std::endl
            << "\tDefault value is [" << toStr(Default::ReceivingThreadCpuAffinity) << "]" << std::endl;
    }
};
 
class BenchmarkConfiguration : public virtual ConfigurationBase
{
public:
    size_t numberOfMessages() const
    {
        return argOrDefault(options(), "numberOfMessages", Default::NumberOfMessages);
    }
 
    size_t warmupInterval() const
    {
        return argOrDefault(options(), "warmupInterval", Default::WarmupInterval);
    }
 
    size_t intervalBetweenSending() const
    {
        return argOrDefault(options(), "intervalBetweenSending", Default::IntervalBetweenSending);
    }
 
protected:
    BenchmarkConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
        if (!this->show())
        {
            if (Utils::BuildInfo::library().debug() || Utils::consumerBuildInfo().debug())
            {
                std::cerr << "Please use the RELEASE build for benchmarking." << std::endl;
 
#if !defined(ONIXS_DEBUGGING)
                exit(1);
#endif
            }
        }
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --numberOfMessages [number]" << std::endl
            << "\tDefault value is [" << toStr(Default::NumberOfMessages) << "]" << std::endl
            << "  --warmupInterval [number]" << std::endl
            << "\tMicroseconds, Default value is [" << toStr(Default::WarmupInterval) << "]" << std::endl
            << "  --warmupInterval [number]" << std::endl
            << "\tMicroseconds, Default value is [" << toStr(Default::IntervalBetweenSending) << "]" << std::endl;
    }
};
 
 
template <typename... Bases>
struct AppConfiguration final : public Bases...
{
    AppConfiguration(const char* name, int argc, char** argv, std::ostream& out = std::clog)
        : ConfigurationBase(argc, argv)
        , Bases(argc, argv)...
    {
        out << "OnixS ICE Binary Order Entry C++ '" << name << "' Sample, version " << Session::version() << '.' << std::endl;
 
        if (this->show())
        {
            this->show(out);
            exit(0);
        }
    }
 
    void showOptions(std::ostream& out) const override
    {
        ONIXS_ICEBOE_UNUSED const int _[] = {0, ((void)Bases::showOptions(out), 0)...};
    }
};
 
class InputLogFileConfiguration : public virtual Samples::ConfigurationBase
{
public:
    std::string location() const
    {
        return Samples::requiredArg<std::string>(options(), "location");
    }
 
protected:
    InputLogFileConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --location <FileName|DirectoryName>" << std::endl;
    }
};
 
}