private IPrimitive CreateMarketOrder(MetaAction action, string side) { var code = new CodeBlock(); code.Add("local current_serial = source:serial(period);"); var executeCommandCode = new CodeBlock(); executeCommandCode.Add("last_serial = current_serial;"); var oppositeSide = side == "B" ? "S" : "B"; var closeTradesCode = new CodeBlock(); closeTradesCode .Add($"local trades = trading:FindTrade():WhenSide(\"{oppositeSide}\"):WhenCustomID(custom_id):All();") .Add("for _, trade in ipairs(trades) do") .Add(" trading:Close(trade);") .Add("end"); executeCommandCode.Add(PrimitiveBuilder .If("instance.parameters.close_on_opposite") .Then(closeTradesCode) .Build(_variables)); executeCommandCode.Add($"local command = trading:MarketOrder(source:instrument()):SetSide(\"{side}\"):SetDefaultAmount():SetCustomID(custom_id);"); AddStop(action, executeCommandCode); AddLimit(action, executeCommandCode); executeCommandCode.Add("command:Execute();"); code.Add(new IfStatement(new NotEqualPrimitive("last_serial", "current_serial"), executeCommandCode, _variables, "")); return(code); }
/* * Retorna a lista de ações descritas na lista de nós XML. */ protected Dictionary <string, MetaAction> getActions(XmlNodeList nodes, MetaUnit unit) { if (nodes != null) { IEnumerator ienum = (IEnumerator)nodes.GetEnumerator(); Dictionary <string, MetaAction> actionList = new Dictionary <string, MetaAction>(); MetaAction action; XmlNode actionNode; while (ienum.MoveNext()) { actionNode = (XmlNode)ienum.Current; action = new MetaAction(); action.Id = generator.genId(); action.Father = unit; action.Name = actionNode.SelectSingleNode("identifier").InnerText; List <Transition> trans = getTransitions(actionNode.SelectSingleNode("protocol").FirstChild, unit, Configuration.INITIAL_STATE, Configuration.FINAL_STATE, 2, 0); action.Protocol = new Configuration(numStates, trans, numTransations); actionList.Add(action.Name, action); } if (actionList.Count > 0) { return(actionList); } } return(null); }
/// <summary> /// /// </summary> /// <param name="action"></param> /// <exception cref="StrategyGeneratorException"></exception> /// <returns></returns> private IPrimitive FormatAction(MetaAction action) { switch (action.ActionType) { case MetaActionType.Buy: return(CreateMarketOrder(action, "B")); case MetaActionType.Sell: return(CreateMarketOrder(action, "S")); case MetaActionType.Customizable: return($"DoAction(source:instrument(), instance.parameters.{action.ActionId});".MakePrimitive()); case MetaActionType.Exit: return("trading:CloseAllForInstrument(source:instrument());".MakePrimitive()); case MetaActionType.ExitBuy: return("trading:CloseSideForInstrument(source:instrument(), \"B\");".MakePrimitive()); case MetaActionType.ExitSell: return("trading:CloseSideForInstrument(source:instrument(), \"S\");".MakePrimitive()); case MetaActionType.EntryBuy: return(CreateEntryOrder(action, "B")); case MetaActionType.EntrySell: return(CreateEntryOrder(action, "S")); } throw new NotSupportedActionException(action.ActionType, "Lua"); }
public static Image CreateImage(MetaAction source) { var result = new Image { Source = source.Icon.ToBitmapSource() }; result.SetValue(RenderOptions.BitmapScalingModeProperty, BitmapScalingMode.HighQuality); return(result); }
/// <summary> /// Helper method for generating a MetaObject which calls a specific method on Dynamic w/ the /// meta object array as the params. /// </summary> private MetaObject CallMethodNAry(MetaAction action, MetaObject[] args, string methodName) { return(new MetaObject( Expression.Call( GetLimitedSelf(), typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance), ReplaceSelfWithAction(action, args) ), GetRestrictions() )); }
/// <summary> /// Helper method for generating a MetaObject which calls a specific method on Dynamic /// w/o any additional parameters. /// </summary> private MetaObject CallMethodUnary(MetaAction action, string methodName) { return(new MetaObject( Expression.Call( GetLimitedSelf(), typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance), Expression.Constant(action) ), GetRestrictions() )); }
public void EndTargetPhase(MetaAction metaAction, ActionInfo actionInfo) { foreach (ui_ability_script b in buttonManager) { b.TurnOffHighlight(); } ActionDist actions = metaAction.Execute(actionInfo); this.board.world.ExecuteActionDist(actions); this.EndTurn(); }
static void Main(string[] args) { Action Execute = delegate { }; MetaAction meta = MetaAction.Create(h => Execute += h, h => Execute -= h); var prog = new ProgramTest(meta); var subscription = prog.AddMethod(); Execute(); subscription.Dispose(); }
/// <summary> /// Helper which returns an Expression array corresponding to the arguments minus /// the DynamicObject instance (arg0) plus the MetaAction constant. /// </summary> private static Expression[] ReplaceSelfWithAction(MetaAction action, MetaObject[] args) { Expression[] paramArgs = new Expression[args.Length - 1]; for (int i = 0; i < paramArgs.Length; i++) { paramArgs[i] = Expression.ConvertHelper(args[i + 1].Expression, typeof(object)); } return(new Expression[] { Expression.Constant(action), Expression.NewArrayInit(typeof(object), paramArgs) }); }
public void Run(MetaAction action) { if (action.Protocol.Monitors == null || action.Protocol.Monitors.Count == 0) { br.ufc.pargo.hpe.connector.monitoring.Monitor monitor = new br.ufc.pargo.hpe.connector.monitoring.Monitor(); monitor.Add(this); action.Protocol.AddMonitor(monitor); } Interpreter interpreter = new Interpreter(action); interpreters.Add(interpreter); interpreter.Go(); }
/// <summary> /// /// </summary> /// <param name="action"></param> /// <param name="side"></param> /// <exception cref="StrategyGeneratorException">On missing rate for the entry</exception> /// <returns></returns> private IPrimitive CreateEntryOrder(MetaAction action, string side) { if (action.Entry == null) { throw new StrategyGeneratorException($"No entry rate for the {action.Name}"); } (string value, bool isValueInPips) = FormatOrderValue(action.Entry); string entry = $":SetRate({value})"; var code = new CodeBlock(); code.Add($"local command = trading:EntryOrder(source:instrument()):SetSide(\"{side}\"):SetDefaultAmount(){entry}:SetCustomID(custom_id);"); AddStop(action, code); AddLimit(action, code); code.Add("command:Execute();"); return(code); }
private void AddLimit(MetaAction action, CodeBlock code) { (string limitValue, bool isLimitValueInPips) = FormatOrderValue(action.Limit); if (limitValue != null) { if (isLimitValueInPips) { code.Add($"command = command:SetPipLimit({limitValue});"); } else { code.Add($"command = command:SetLimit({limitValue});"); } } else { code.Add(new IfStatement("instance.parameters.set_limit".MakePrimitive(), "command = command:SetPipLimit(nil, instance.parameters.limit);".MakePrimitive(), _variables, "")); } }
private void AddStop(MetaAction action, CodeBlock code) { (string stopValue, bool isStopValueInPips) = FormatOrderValue(action.Stop); if (stopValue != null) { if (isStopValueInPips) { code.Add($"command = command:SetPipStop({stopValue});"); } else { code.Add($"command = command:SetStop({stopValue});"); } } else { code.Add(new IfStatement("instance.parameters.set_stop".MakePrimitive(), "command = command:SetPipStop(nil, instance.parameters.stop, instance.parameters.trailing_stop and instance.parameters.trailing or nil);".MakePrimitive(), _variables, "")); } }
private void TargetPhase(MetaAction metaAction, KeyCode keyPressed) { ActionInfo actionInfo = new ActionInfo(); if (metaAction is TargetedMetaAction) { TargetedMetaAction targetAction = metaAction as TargetedMetaAction; GameObject cursor = Instantiate((GameObject)Resources.Load(Player.cursorPf)); actionInfo.originId = this.id; actionInfo.originPos = this.position; cursor.GetComponent <TargetCursor>().Setup(this, targetAction.PotentialTargets(board, actionInfo), targetAction, actionInfo, keyPressed); selectActionPhase = false; } else { actionInfo.originId = this.id; actionInfo.originPos = this.position; actionInfo.targetId = World.InvalidId; actionInfo.targetPos = Board.InvalidPos; EndTargetPhase(metaAction, actionInfo); } }
public void Run(string actionName) { //System.Diagnostics.Console.WriteLine("[ConfigurationManager.Run] iniciando a ação " + actionName); MetaAction action = null; if (unit != null && unit.Entity != null) { action = unit.Actions [actionName]; if (action != null) { Run(action); } else { throw new Exception("Invalid action name."); } } else { throw new Exception("Null entity."); } }
public override string ToString() { string cname = ""; string s = ""; s += "type: " + type; s += " | initialState: " + initialState; s += " | finalState: " + finalState; s += " | isElse: " + isElse; if (type == TransitionType.SIMPLE && getExecutionAction() != null && getExecutionAction().MetaAction != null) { MetaAction maction = getExecutionAction().MetaAction; s += " | action: " + maction.Name; if (maction.Name != null) { if (maction.Father.Father.GetType().Name.Equals("MetaInnerComponent")) { cname = ((MetaInnerComponent)maction.Father.Father).Identifier; } else { cname = maction.Father.Father.Name; } } s += " | slice: " + cname + "." + maction.Father.Name; s += "(" + maction.Father.GetType().Name + ")"; } if (type == TransitionType.SIMPLE && getExecutionAction().Condition != null) { s += " | condition: " + getExecutionAction().Condition; } return(s); }
/* * geração das transitions baseado no protocolo da ação. */ public List <Transition> getTransitions(XmlNode node, MetaUnit unit, int initial, int final, int numStates, int numTransations) { List <Transition> transitions = new List <Transition> (); Queue <Transition> treat = new Queue <Transition> (); //Console.WriteLine("Initial {0} | Final {1} | numStates {2} | numTrans {3}", initial, final, numStates, numTransations); treat.Enqueue(new Transition(initial, final, node, numTransations++)); Transition t; XmlNode pivotNode, child, guardNode; XmlNodeList children; XmlAttribute attr; Condition condition; int initialState, finalState; bool repeat; initialState = finalState = 0; while (treat.Count > 0) { t = treat.Dequeue(); pivotNode = (XmlNode)t.Action; t.Action = null; transitions.Add(t); condition = null; attr = (XmlAttribute)pivotNode.Attributes.GetNamedItem("id"); if (attr != null) { t.AddId(attr.Value); } repeat = false; attr = (XmlAttribute)pivotNode.Attributes.GetNamedItem("repeat"); if (attr != null) { repeat = attr.Value.Equals("true"); } guardNode = pivotNode.SelectSingleNode("guard"); condition = null; //Console.WriteLine("[XmlLoaderUtil.getTransitions] Ação a avaliar... {0}", pivotNode.Name); if (pivotNode.Name.Equals("seq") || pivotNode.Name.Equals("par")) { if (guardNode != null) { condition = getCondition(guardNode); Transition tElse; initialState = numStates++; if (condition != null) //condition nao é else. { transitions.Add(new Transition(t.InitialState, initialState, new ExecutionAction(null, condition), Transition.INTERNAL_TRANSITION)); tElse = new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION); } else { tElse = new Transition(t.InitialState, initialState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION); } tElse.IsElse = true; transitions.Add(tElse); } else { initialState = t.InitialState; } } switch (pivotNode.Name) { case "seq": children = pivotNode.ChildNodes; for (int r = 0; r < children.Count; r++) { child = children.Item(r); if (child.Name.Equals("guard")) { continue; } if (r == (children.Count - 1)) { if (repeat) { finalState = t.InitialState; } else { finalState = t.FinalState; } } else { finalState = numStates++; } treat.Enqueue(new Transition(initialState, finalState, child.FirstChild, numTransations++)); initialState = finalState; } break; case "par": children = pivotNode.ChildNodes; if (repeat) { finalState = numStates++; transitions.Add(new Transition(finalState, t.InitialState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION)); } else { finalState = t.FinalState; } for (int r = 0; r < children.Count; r++) { child = children.Item(r); if (child.Name.Equals("guard")) { continue; } treat.Enqueue(new Transition(initialState, finalState, child.FirstChild, numTransations++)); } break; case "perform": bool isElse = false; initialState = t.InitialState; finalState = t.FinalState; child = pivotNode; if (guardNode != null) { condition = getCondition(guardNode); if (condition == null) { isElse = true; } } attr = (XmlAttribute)child.Attributes.GetNamedItem("slice_id"); //Console.WriteLine("[XmlLoaderUtil.getTransitions] Avaliando ação sobre a fatia {0}", attr.Value); string sliceName = ""; if (attr != null) { sliceName = attr.Value; } string methodName = child.Attributes.GetNamedItem("action_id").Value; //Console.WriteLine("[XmlLoaderUtil.getTransitions] Avaliando ação {0}", methodName); MetaAction selectedAction = null; if (sliceName.Equals("")) { //Console.WriteLine("[XmlLoaderUtil.getTransitions] unit {0} | action {1}", unit.Name, methodName); unit.Actions.TryGetValue(methodName, out selectedAction); //Console.WriteLine("[XmlLoaderUtil.getTransitions] Action {0} encontrada? {1}",methodName, selectedAction != null); if (selectedAction == null) { selectedAction = new MetaAction(); selectedAction.Id = generator.genId(); selectedAction.Name = methodName; selectedAction.Father = unit; unit.AddAction(methodName, selectedAction); } } else { MetaSlice slice = null; //Console.WriteLine("[XmlLoaderUtil.getTransitions] slice {0}", sliceName); unit.Slices.TryGetValue(sliceName, out slice); if (slice == null && candidateSlices != null) { candidateSlices.TryGetValue(sliceName, out slice); } if (slice != null) { //Console.WriteLine("[XmlLoaderUtil.getTransitions] slice {0} encontrada", sliceName); if (slice.Unit.Actions != null) { foreach (MetaAction mact in slice.Unit.Actions.Values) { if (mact.Name.Equals(methodName)) { selectedAction = mact; break; } } } if (selectedAction == null) { selectedAction = new MetaAction(); selectedAction.Id = generator.genId(); selectedAction.Name = methodName; selectedAction.Father = slice.Unit; slice.Unit.AddAction(methodName, selectedAction); } } } if (selectedAction != null) { Transition tst = new Transition(initialState, finalState, new ExecutionAction(selectedAction, condition), numTransations++); tst.IsElse = isElse; transitions.Add(tst); } else { throw new Exception("Fatia inexistente nesta unidade: " + sliceName); } break; default: throw new Exception("invalid action: " + pivotNode.Name); } } this.numStates = numStates; this.numTransations = numTransations; return(transitions); }
public ExecutionAction(MetaAction mAction, Condition cond) { this.metaAction = mAction; this.Condition = cond; }
public ReconfigurationRequest loadRequest(string xml, MetaHashComponent component) { ReconfigurationRequest request = null; Console.WriteLine("[XmlLoader.loadRequest] Iniciando carga de script de reconfiguração... "); if (true /*validator.IsValid (REQUEST_XSD, xml)*/) { clear(); generator.setInitialCode(component.LastIdCode); request = new ReconfigurationRequest(); XmlDocument document = new XmlDocument(); XmlNode nodeRequest, data; document.Load(xml); nodeRequest = document.SelectSingleNode("reconfigurationRequest"); data = nodeRequest.SelectSingleNode("targetComponent"); request.TargetComponent = data.InnerText; //Console.WriteLine("[XmlLoader.LoadRequest] Obtendo componente alvo {0}", request.TargetComponent); List <MetaParameter> parameterList = uLoader.getParameters(nodeRequest.SelectNodes("parameter")); if (parameterList != null) { Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações estruturais..."); request.StructuralRequest = new StructuralReconfigurationRequest(parameterList); } BehavioralReconfigurationRequest behavioralRequest = null; List <MetaInnerComponent> innerComponents = generateInnerComponents(nodeRequest.SelectNodes("innerComponent")); //Console.WriteLine("[XmlLoader.LoadRequest] Tem innerComponent para adicionar? {0}", innerComponents != null); if (innerComponents != null) { behavioralRequest = new BehavioralReconfigurationRequest(); Console.WriteLine("[XmlLoader.LoadRequest] Carregando novos componentes aninhados..."); //Console.WriteLine("[XmlLoader.LoadRequest] {0} InnerComponent(s) adicionado(s)", innerComponents.Count); behavioralRequest.NewInnerComponents = innerComponents; uLoader.CandidateInnerComponents = innerComponents; } uLoader.InnerComponents = innerComponents; XmlNodeList changeActionList = nodeRequest.SelectNodes("changeAction"); if (changeActionList != null) { Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações comportamentais..."); IEnumerator ienum = changeActionList.GetEnumerator(); BehavioralChange change; XmlNode changeNode; if (behavioralRequest == null) { behavioralRequest = new BehavioralReconfigurationRequest(); } XmlAttribute attr; int initialCode; int aditionalStates, aditionalTrans; aditionalStates = aditionalTrans = 0; while (ienum.MoveNext()) { changeNode = (XmlNode)ienum.Current; change = new BehavioralChange(); //Console.WriteLine("[XmlLoader.LoadRequest] Criando uma nova BehavioralChange"); initialCode = generator.getCurrentCode(); attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("unit"); change.Unit = attr.Value; //Console.WriteLine("[XmlLoader.LoadRequest] Unit a sofrer alteração: {0}", change.Unit); MetaUnit u = component.Units[change.Unit]; if (u != null) { //Console.WriteLine("[XmlLoader.LoadRequest] Unit {0} encontrada!", change.Unit); attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("action"); change.Action = attr.Value; //Console.WriteLine("[XmlLoader.LoadRequest] Ação a sofrer alteração: {0}", change.Action); MetaAction a = u.Actions[change.Action]; if (a != null && !a.IsNative) { //Console.WriteLine("[XmlLoader.LoadRequest] Ação {0} encontrada!", change.Action); attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("type"); if (attr.Value.Equals("remove")) { change.Type = BehavioralChange.BehavioralChangeType.REMOVE; } else { change.Type = BehavioralChange.BehavioralChangeType.INCLUDE; } attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("point"); change.Point = attr.Value; //Console.WriteLine("[XmlLoader.LoadRequest] Ponto a sofrer alteração: {0}", change.Point); Transition t = a.Protocol.getTransition(change.Point); if (t != null) { //Console.WriteLine("[XmlLoader.LoadRequest] Ponto {0} encontrado.", change.Point); change.NewSlices = uLoader.getSlices(changeNode.SelectNodes("slice")); uLoader.CandidateSlices = change.NewSlices; if (change.Type == BehavioralChange.BehavioralChangeType.INCLUDE) { //Console.WriteLine("[XmlLoader.LoadRequest] Obtendo novo protocolo"); change.Transitions = uLoader.getTransitions(changeNode.SelectSingleNode("protocol").FirstChild, u, t.InitialState, t.FinalState, a.Protocol.NumStates + aditionalStates, a.Protocol.LastTransationId + aditionalTrans); aditionalStates = uLoader.NumStates - a.Protocol.NumStates; aditionalTrans = uLoader.NumTransations - a.Protocol.LastTransationId; //TODO remover //Console.WriteLine("Transações de reconfiguração"); //foreach(Transition tst in change.Transitions) { // Console.WriteLine(tst); //} } else { change.Transitions = new List <Transition>(); change.Transitions.Add(new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, a.Protocol.LastTransationId++)); } } else { throw new Exception("[XmlLoader.loadRequest] Ponto de reconfiguração não existe: " + change.Point); } } else { throw new Exception("[XmlLoader.loadRequest] Ação a ser alterada não existe ou nãoo é uma configuração: " + change.Action); } } else { throw new Exception("[XmlLoader.loadRequest] Unidade da ação a ser alterada não existe: " + change.Unit); } change.AditionalStates = generator.getCurrentCode() - initialCode; behavioralRequest.AddChange(change); } } request.BehavioralRequest = behavioralRequest; component.LastIdCode = generator.getCurrentCode(); } uLoader.CandidateSlices = null; uLoader.CandidateInnerComponents = null; Console.WriteLine("[XmlLoader.loadRequest] Carga de script realizada com sucesso!"); return(request); }
/// <summary> /// Helper method for generating a MetaObject which calls a specific method on Dynamic /// w/o any additional parameters. /// </summary> private MetaObject CallMethodUnary(MetaAction action, string methodName) { return new MetaObject( Expression.Call( GetLimitedSelf(), typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance), Expression.Constant(action) ), GetRestrictions() ); }
/// <summary> /// Helper method for generating a MetaObject which calls a specific method on Dynamic w/ the /// meta object array as the params. /// </summary> private MetaObject CallMethodNAry(MetaAction action, MetaObject[] args, string methodName) { return new MetaObject( Expression.Call( GetLimitedSelf(), typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance), ReplaceSelfWithAction(action, args) ), GetRestrictions() ); }
/// <summary> /// Helper which returns an Expression array corresponding to the arguments minus /// the DynamicObject instance (arg0) plus the MetaAction constant. /// </summary> private static Expression[] ReplaceSelfWithAction(MetaAction action, MetaObject[] args) { Expression[] paramArgs = new Expression[args.Length - 1]; for (int i = 0; i < paramArgs.Length; i++) { paramArgs[i] = Expression.ConvertHelper(args[i + 1].Expression, typeof(object)); } return new Expression[] { Expression.Constant(action), Expression.NewArrayInit(typeof(object), paramArgs) }; }
public ProgramTest(MetaAction meta) { _meta = meta; }
public static void SetAction(DependencyObject element, MetaAction value) { element.SetValue(ActionProperty, value); }