98 lines
3.1 KiB
C++
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 ¶m);
|
|
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 ¶m) {
|
|
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 ¶m : 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
|