LimitCover algo - remove cancel_on_blah params, add hedge_ticks

This commit is contained in:
John Colvin committed 2020-05-13 16:18:46 -05:00
1 parent 2ccdef9dc5
commit d51d20e84c
2 files changed
+17 -30

No files matched your search

@@ -50,11 +50,18 @@ struct DeleteThreshold : public Param<uint32_t> {
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).delete_threshold(v); }) { }
};
template<uint32_t gate_num>
struct HedgeTicks : public Param<uint32_t> {
HedgeTicks() : Param<uint32_t>(gate_param_name<gate_num>("Hedge Ticks"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).hedge_ticks(); },
[](LimitCoverDefinition& def, uint32_t v) { def.gate(gate_num).hedge_ticks(v); }) { }
};
template<uint32_t gate_num>
struct TopTicksOff : public Param<uint32_t> {
TopTicksOff() : Param<uint32_t>(gate_param_name<gate_num>("Top Ticks Offset"),
[](const LimitCoverDefinition& def) {return def.gate(gate_num).top_ticks_offset(); },
[](LimitCoverDefinition& def, uint32_t v) {return def.gate(gate_num).top_ticks_offset(v); }) { }
[](const LimitCoverDefinition& def) { return def.gate(gate_num).top_ticks_offset(); },
[](LimitCoverDefinition& def, uint32_t v) { def.gate(gate_num).top_ticks_offset(v); }) { }
};
template<uint32_t gate_num>
@@ -64,20 +71,6 @@ struct MaxChaseTicks : public Param<uint32_t> {
[](LimitCoverDefinition& def, uint32_t v) { def.mgate(gate_num).max_chase_ticks(v); }) { }
};
template<uint32_t gate_num>
struct CancelHedgesOnCancel : public Param<bool> {
CancelHedgesOnCancel() : Param<bool>(gate_param_name<gate_num>("Cancel Hedges On Cancel"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).cancel_hedges_on_cancel(); },
[](LimitCoverDefinition& def, bool v) { def.mgate(gate_num).cancel_hedges_on_cancel(v); }) { }
};
template<uint32_t gate_num>
struct CancelOnExternalHedgeCancel : public Param<bool> {
CancelOnExternalHedgeCancel() : Param<bool>(gate_param_name<gate_num>("Cancel On External Hedge Cancel"),
[](const LimitCoverDefinition& def) { return def.gate(gate_num).cancel_on_external_hedge_cancel(); },
[](LimitCoverDefinition& def, bool v) { def.mgate(gate_num).cancel_on_external_hedge_cancel(v); }) { }
};
template<uint32_t gate_num>
struct TradeTowardBehavior : public dynamic_adapter::EnumParamKey<LimitCoverDefinition, OnToward> {
TradeTowardBehavior() : EnumParamKey<LimitCoverDefinition, OnToward>(
@@ -108,29 +101,26 @@ using Adapter = dynamic_adapter::DynamicOrderAdapter<LimitCoverDefinition,
TicksOffset,
// [gate 0]
ActivationThreshold<0>,
HedgeTicks<0>,
TopTicksOff<0>,
MaxChaseTicks<0>,
TradeTowardBehavior<0>,
CancelHedgesOnCancel<0>,
CancelOnExternalHedgeCancel<0>,
// gate 1
ActivationThreshold<1>,
CoverThreshold<1>,
DeleteThreshold<1>,
HedgeTicks<1>,
TopTicksOff<1>,
MaxChaseTicks<1>,
TradeTowardBehavior<1>,
CancelHedgesOnCancel<1>,
CancelOnExternalHedgeCancel<1>,
// gate 2
ActivationThreshold<2>,
CoverThreshold<2>,
DeleteThreshold<2>,
HedgeTicks<2>,
TopTicksOff<2>,
MaxChaseTicks<2>,
TradeTowardBehavior<2>,
CancelHedgesOnCancel<2>,
CancelOnExternalHedgeCancel<2>>;
TradeTowardBehavior<2>>;
LimitCoverDefinition LimitCoverAdapter::from_proto(const api::orderman::OrderDefinition& order) {
if (order.has_custom_def())
@@ -43,7 +43,10 @@ struct LimitCoverGate {
}
_definition.mutable_top_threshold()->set_absolute(value);
}
// hedge ticks
uint32_t hedge_ticks() const { return _definition.hedge_ticks(); }
void hedge_ticks(uint32_t value) { _definition.set_hedge_ticks(value); }
// top ticks offset
uint32_t top_ticks_offset() const { return _definition.ticks_off(); }
void top_ticks_offset(uint32_t value) { _definition.set_ticks_off(value); }
@@ -53,12 +56,6 @@ struct LimitCoverGate {
// on toward
api::orderman::LeanOnToward on_toward() const { return _definition.trade_toward_behavior(); }
void on_toward(api::orderman::LeanOnToward value) { _definition.set_trade_toward_behavior(value); }
// cancel hedges on cancel
bool cancel_hedges_on_cancel() const { return _definition.cancel_hedges_on_cancel(); }
void cancel_hedges_on_cancel(bool value) { _definition.set_cancel_hedges_on_cancel(value); }
// cancel on external hedge cancel
bool cancel_on_external_hedge_cancel() const { return _definition.cancel_on_external_hedge_cancel(); }
void cancel_on_external_hedge_cancel(bool value) { _definition.set_cancel_on_external_hedge_cancel(value); }
// definition
const api::orderman::DeleteAndCoverDefinition& definition() const { return _definition; }
api::orderman::DeleteAndCoverDefinition& mdefinition() { return _definition; }