Files
spark/src/lib/plugin/SparkServices.cpp
T

98 lines
3.1 KiB
C++

#include "SparkServices.h"
#include "lib/logging/logging.h"
#include "lib/orderman/order_factory/DynamicOrderRegistry.h"
namespace bts {
using namespace orderman;
struct SparkServices::PImpl {
PImpl(orderman::DynamicOrderRegistry &r) : dyn_order_registry(r) {}
DynamicOrderRegistry &dyn_order_registry;
};
SparkServices::SparkServices(orderman::DynamicOrderRegistry &r)
: me(new PImpl(r)) {}
SparkServices::~SparkServices() {}
void SparkServices::register_dynamic_order(
api::orderman::DynamicOrderDescriptor const &desc,
std::function<std::unique_ptr<Order>()> const &builder) {
me->dyn_order_registry.register_dynamic_order(desc, builder);
}
bool validate_param(const api::orderman::DynamicOrderParamDescriptor &param);
bool validate_type(
const std::string name,
const api::orderman::DynamicOrderTypeDescriptor &type) {
switch (type.descriptor_case()) {
case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kPrimitive:
break;
case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kArray:
if (!type.array().has_element_type()) {
LOG(OrderMan, Error, "Array parameter {} missing element type", name);
return false;
}
if (!validate_type(name + "::array", type.array().element_type()))
return false;
break;
case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kStructure:
for (const auto &field : type.structure().field()) {
if (!validate_param(field))
return false;
}
break;
case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kEnumerated:
if (type.enumerated().element_size() == 0) {
LOG(OrderMan, Error, "Enumerated parameter {} missing options list",
name);
return false;
}
case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::
DESCRIPTOR_NOT_SET:
break;
}
return true;
}
bool validate_param(const api::orderman::DynamicOrderParamDescriptor &param) {
if (param.param_name().empty()) {
LOG(OrderMan, Error, "Parameter missing param_name");
return false;
}
if (!param.has_param_type()) {
LOG(OrderMan, Error, "Parameter {} missing type", param.param_name());
return false;
}
return validate_type(param.param_name(), param.param_type());
return true;
}
bool validate_descriptor(const api::orderman::DynamicOrderDescriptor &desc) {
if (desc.dynamic_order_type().empty()) {
LOG(OrderMan, Error, "Algo missing 'dynamic_order_type'");
return false;
}
for (const auto &param : desc.param_desc()) {
if (!validate_param(param)) {
return false;
}
}
return true;
}
AlgoRegistrationResult SparkServices::register_dynamic_algo_order(
api::orderman::DynamicOrderDescriptor const &desc,
std::function<std::unique_ptr<orderman::IAlgoOrder>()> const &builder) {
if (validate_descriptor(desc)) {
me->dyn_order_registry.register_dynamic_algo_order(desc, builder);
return AlgoRegistrationResult::SUCCESS;
}
return AlgoRegistrationResult::ERROR;
}
extern "C" void initialize_spark_plugin(SparkServices &) {}
} // namespace bts