Cleaning up

This commit is contained in:
Taha Afzal authored and John Colvin committed 2019-11-06 22:40:50 -06:00
1 parent f543a61758
commit 05aeb78026
2 files changed
+56 -40

No files matched your search

@@ -17,6 +17,7 @@ using namespace api::orderman;
enum class PyramidAlgo::Status { WAITING_FOR_MD, WORKING, WAITING_FOR_CANCEL, DONE };
struct LegData{
const size_t index;
const SecurityKey sec_key;
@@ -25,8 +26,8 @@ struct LegData{
OrderKey order_key;
ChildState order_state;
Book book;
Quantity top_delete;
Quantity cover_payup;
Quantity top_delete; // this will be DONTCARE for covers
Quantity cover_payup;// this will be DONTCARE for top
LegData (size_t index_a,
SecurityKey sec_key_a,
api::Side side_a,
@@ -87,9 +88,15 @@ OrderOpResult PyramidAlgo::do_before_launch(IBeforeLaunchAlgoServices& serv) {
// params are good
me->params = std::get<0>(conv_res);
me->side = def.side();
size_t i = 0;
for (SecurityKey key : me->params.sec_keys){
auto side = i == 0 ? def.side() : _opp(def.side());
// top spread
auto* t = _create_order_template(serv,
me->params.top_spread,
def.side());
me->legs.emplace_back(0, me->params.top_spread, def.side(), t);
// covers
size_t i = 1;
for (SecurityKey key : me->params.cover_spreads){
auto side = _opp(def.side());
auto* t = _create_order_template(serv,
key,
side);
@@ -109,8 +116,8 @@ void PyramidAlgo::do_launch(IAlgoServices& algo_services) {
me->algo_services = &algo_services;
me->out_price = algo_services.price();
me->out_qty = algo_services.quantity();
for (SecurityKey bkey : me->params.sec_keys)
algo_services.subscribe_book(bkey);
for (const LegData& l : me->legs)
algo_services.subscribe_book(l.sec_key);
}
void PyramidAlgo::do_launch_attached(IAlgoServices&, OrderKey, ChildState) {
}
@@ -131,6 +138,14 @@ void PyramidAlgo::do_update(const api::orderman::Update& update) {
_algo().terminate_error("Invalid update");
return;
}
else{
// copy state
auto params = std::get<0>(conv_res);
me->legs[0].top_delete = params.top_delete;
size_t i = 1;
for (Quantity pu : params.cover_payups)
me->legs[i++].cover_payup = pu;
}
switch(me->state){
case PyramidAlgo::Status::WAITING_FOR_MD:
me->out_price = Price(update.price());
@@ -199,58 +214,56 @@ void PyramidAlgo::on_child_change(OrderKey key, const ChildState &st) {
///////////////////////////////////////////////////////////////////////////////
// helpers ////////////////////////////////////////////////////////////////////
std::tuple<PyramidAlgo::PyramidAlgoParams,bool,std::string>
PyramidAlgo::_convert_params (const CustomOrderDefinition& cod){
PyramidAlgo::PyramidAlgoParams PyramidAlgo::_convert_params (
const CustomOrderDefinition& cod){
const DynamicOrderDefinition& def = cod.dynamic();
const auto& params = def.order_params();
PyramidAlgoParams rv;
// rv.sec_keys.emplace_back(4294964892);
// rv.sec_keys.emplace_back(4294964643);
// rv.sec_keys.emplace_back(4294964605);
auto r = get_if<uint32_t>(params, "Top Spread");
if (r.has_value() && r.value()!=0)
rv.sec_keys.emplace_back(r.value());
else
return std::make_tuple(rv,false,
std::string("Top Spread is not defined"));
// top contract
auto r = get_if<uint32_t>(params, "Top Spread");
rv.top_spread = r.has_value() ? SecurityKey(r.value()) : SecurityKey(0);
// top delete
r = get_if<uint32_t>(params, "Delete");
rv.top_delete = Quantity(r.has_value() ? r.value() : UINT32_MAX);
for (size_t i = 0; i < 5; i++){
auto idx = std::to_string(i+1);
auto b = get_if<uint32_t>(params, "Spread " + idx);
if (b.has_value() && b.value() != 0){
rv.sec_keys.emplace_back(b.value());
rv.cover_spreads.emplace_back(b.value());
auto pu = get_if<uint32_t>(params, "Spread " + idx + " Payup");
rv.cover_payups.emplace_back(pu.has_value() ? pu.value() : UINT32_MAX);
}
}
if(rv.sec_keys.size() < 3)
return std::make_tuple(
rv,
false,
std::string("Pyramid Algo has to have atlest 2 base spreads"));
return std::make_tuple(rv,true,std::string(""));
}
std::tuple<PyramidAlgo::PyramidAlgoParams,bool,std::string>
PyramidAlgo::_get_creation_params(const CustomOrderDefinition& cod,
IBeforeLaunchAlgoServices& serv){
auto rv = _convert_params(cod);
if (std::get<1>(rv)){
const auto& p = std::get<0>(rv);
if(p.sec_keys[0].value() != serv.security().id()){
std::get<2>(rv) = "Algo can only be launched from the Top Spread";
std::get<1>(rv) = false;
}
}
return rv;
}
std::tuple<PyramidAlgo::PyramidAlgoParams,bool,std::string>
PyramidAlgo::_get_creation_params(const CustomOrderDefinition& cod,
IBeforeLaunchAlgoServices& serv){
PyramidAlgo::PyramidAlgoParams rv = _convert_params(cod);
// error checking
if(rv.top_spread.value() != serv.security().id())
return std::make_tuple(rv,false,
"Algo can only be launched from the Top Spread");
if(rv.cover_spreads.size() < 2)
return std::make_tuple(rv,false,
"Not enough cover spreads");
if (rv.cover_spreads[0].value() == 0 ||
rv.cover_spreads[1].value() == 0)
return std::make_tuple(rv,false,
"Not enough cover spreads");
return std::make_tuple(rv,true,std::string(""));
}
std::tuple<PyramidAlgo::PyramidAlgoParams,bool,std::string>
PyramidAlgo::_get_update_params(const Update& update,
const PyramidAlgoParams& curr_params){
const PyramidAlgoParams&){
auto rv = _convert_params(update.custom());
// TODO: compare contracts and dont allow them to change
return std::make_tuple(curr_params,true,std::string(""));
return std::make_tuple(rv,true,std::string(""));
}
ChildTemplate* PyramidAlgo::_create_order_template (
@@ -16,9 +16,10 @@ class PyramidAlgo : public IAlgoOrder {
PyramidAlgo();
~PyramidAlgo();
struct PyramidAlgoParams{
// first one is the top
std::vector<SecurityKey> sec_keys;
// first one is the top
SecurityKey top_spread;
Quantity top_delete;
std::vector<SecurityKey> cover_spreads;
std::vector<Quantity> cover_payups;
};
public:
@@ -35,7 +36,9 @@ class PyramidAlgo : public IAlgoOrder {
std::unique_ptr<PImpl> me;
private:
IAlgoServices& _algo() const ;
static std::tuple<PyramidAlgoParams,bool,std::string> _convert_params (
// converts parameters from the CustomOrderDefinition::dynamic
// to PyramidAlgoParams
static PyramidAlgoParams _convert_params (
const bts::api::orderman::CustomOrderDefinition&);
static std::tuple<PyramidAlgoParams,bool,std::string> _get_creation_params(
const bts::api::orderman::CustomOrderDefinition&,