private List <DebugVariable> TupleToVariables(MsgFrame frame)
{
var variables = new List <DebugVariable>();
NodeDebugInfo node = null;
RuleDebugInfo rule = null;
if (frame.NodeId != 0)
{
node = DebugInfo.Nodes[frame.NodeId];
if (node.RuleId != 0)
{
rule = DebugInfo.Rules[node.RuleId];
}
}
for (var i = 0; i < frame.Tuple.Column.Count; i++)
{
var value = frame.Tuple.Column[i];
var variable = new DebugVariable
{
Name = Formatter.TupleVariableIndexToName(rule, node, i),
// TODO type name!
Type = value.TypeId.ToString(),
Value = Formatter.ValueToString(value),
TypedValue = value
};
variables.Add(variable);
}
return(variables);
}
private NodeDebugInfo FromProtobuf(NodeDebugInfoMsg msg)
{
var debugInfo = new NodeDebugInfo
{
Id = msg.Id,
RuleId = msg.RuleId,
Line = (Int32)msg.Line,
ColumnToVariableMaps = new Dictionary <int, int>(),
DatabaseId = msg.DatabaseId,
Name = msg.Name,
Type = (LSLib.LS.Story.Node.Type)msg.Type,
ParentNodeId = msg.ParentNodeId
};
if (msg.FunctionName != "")
{
debugInfo.FunctionName = new FunctionNameAndArity(msg.FunctionName, (int)msg.FunctionArity);
}
foreach (var map in msg.ColumnMaps)
{
debugInfo.ColumnToVariableMaps.Add((Int32)map.Key, (Int32)map.Value);
}
return(debugInfo);
}
private void AddLineMapping(LineType type, GoalDebugInfo goal, NodeDebugInfo node, UInt32 index, UInt32 line)
{
GoalLineMap goalMap;
if (!GoalMap.TryGetValue(goal.Name, out goalMap))
{
goalMap = new GoalLineMap
{
Goal = goal,
LineMap = new Dictionary <uint, LineDebugInfo>()
};
GoalMap.Add(goal.Name, goalMap);
}
var mapping = new LineDebugInfo
{
Type = type,
Goal = goal,
Node = node,
ActionIndex = index,
Line = line
};
goalMap.LineMap[line] = mapping;
}
public BenchmarkLhsExpression()
{
_nodeInfo = new NodeDebugInfo();
Expression <Func <string, int, decimal, bool> > betaExpression = (s, i, d) => s.Length == i;
var betaElement = Element.Condition(betaExpression);
_lhsExpression = ExpressionCompiler.CompileLhsTupleFactExpression <bool>(betaElement, betaElement.Imports.ToList());
_lhsTupleExpression = ExpressionCompiler.CompileLhsTupleExpression <bool>(betaElement, betaElement.Imports.ToList());
_tuple = ToTuple("abcd", 4, 1.0m);
Expression <Func <string, bool> > alphaExpression = s => s.Length == 1;
var alphaElement = Element.Condition(alphaExpression);
_lhsFactExpression = ExpressionCompiler.CompileLhsFactExpression <bool>(alphaElement);
_fact = new Fact("abcd");
}
static WorldGraph CreateTestGraph(out NodePerlinNoise2D perlinNode, out NodeDebugInfo debugNode)
{
var graph = GraphBuilder.NewGraph <WorldGraph>()
.NewNode(typeof(NodePerlinNoise2D), "perlin")
.NewNode(typeof(NodeDebugInfo), "debug")
.Link("perlin", "debug")
.Execute()
.GetGraph() as WorldGraph;
perlinNode = graph.FindNodeByName <NodePerlinNoise2D>("perlin");
debugNode = graph.FindNodeByName <NodeDebugInfo>("debug");
graph.chunkSize = 64;
graph.step = .5f;
graph.chunkPosition = new Vector3(10, 42, -7);
graph.seed = 123456789;
return(graph as WorldGraph);
}
public static void PerlinNoiseToDebugNodeExecution()
{
string perlinNodeName = "perlin";
string debugNodeName = "debug";
var graph = GraphBuilder.NewGraph <WorldGraph>()
.NewNode <NodePerlinNoise2D>(perlinNodeName)
.NewNode <NodeDebugInfo>(debugNodeName)
.Link(perlinNodeName, debugNodeName)
.Execute()
.GetGraph();
NodePerlinNoise2D perlinNode = graph.FindNodeByName(perlinNodeName) as NodePerlinNoise2D;
NodeDebugInfo debugNode = graph.FindNodeByName(debugNodeName) as NodeDebugInfo;
Assert.That(perlinNode != null, "Perlin node not found in the graph (using FindNodeByName)");
Assert.That(debugNode != null, "Debug node not found in the graph (using FindNodeByName)");
NodeLink link = perlinNode.GetOutputLinks().First();
Assert.That(link != null, "Link can't be found in the graph");
Assert.That(link.toNode == debugNode);
}
private void BuildLineMap(NodeDebugInfo node)
{
if (node.RuleId != 0)
{
var rule = DebugInfo.Rules[node.RuleId];
var goal = DebugInfo.Goals[rule.GoalId];
if (node.Line != 0 &&
node.Type != LSLib.LS.Story.Node.Type.Rule)
{
AddLineMapping(LineType.NodeLine, goal, node, 0, (UInt32)node.Line);
}
if (node.Type == LSLib.LS.Story.Node.Type.Rule)
{
for (var index = 0; index < rule.Actions.Count; index++)
{
AddLineMapping(LineType.RuleActionLine, goal, node, (UInt32)index, rule.Actions[index].Line);
}
}
}
}
private NodeDebugInfoMsg ToProtobuf(NodeDebugInfo debugInfo)
{
var msg = new NodeDebugInfoMsg
{
Id = debugInfo.Id,
RuleId = debugInfo.RuleId,
Line = (UInt32)debugInfo.Line,
DatabaseId = debugInfo.DatabaseId,
Name = debugInfo.Name,
Type = (NodeDebugInfoMsg.Types.NodeType)debugInfo.Type,
ParentNodeId = debugInfo.ParentNodeId,
FunctionName = debugInfo.FunctionName != null ? debugInfo.FunctionName.Name : "",
FunctionArity = debugInfo.FunctionName != null ? (uint)debugInfo.FunctionName.Arity : 0
};
foreach (var map in debugInfo.ColumnToVariableMaps)
{
msg.ColumnMaps.Add((UInt32)map.Key, (UInt32)map.Value);
}
return(msg);
}
public String TupleVariableIndexToName(RuleDebugInfo rule, NodeDebugInfo node, int index)
{
if (rule == null)
{
return("#" + index.ToString());
}
else if (node != null)
{
if (index < node.ColumnToVariableMaps.Count)
{
var mappedColumnIdx = node.ColumnToVariableMaps[index];
if (mappedColumnIdx < rule.Variables.Count)
{
return(rule.Variables[mappedColumnIdx].Name);
}
else
{
return(String.Format("(Bad Variable Idx #{0})", index));
}
}
else
{
return(String.Format("(Unknown #{0})", index));
}
}
else
{
if (index < rule.Variables.Count)
{
return(rule.Variables[index].Name);
}
else
{
return(String.Format("(Bad Variable Idx #{0})", index));
}
}
}
internal AggregationContext(IExecutionContext executionContext, NodeDebugInfo nodeInfo)
{
ExecutionContext = executionContext;
NodeInfo = nodeInfo;
}
public void RaiseLhsExpressionFailed(ISession session, Exception exception, Expression expression, IArgumentMap argumentMap, Tuple tuple, Fact fact, NodeDebugInfo nodeInfo, ref bool isHandled)
{
var handler = LhsExpressionFailedEvent;
if (handler != null)
{
var arguments = new LhsExpressionArguments(argumentMap, tuple, fact);
var @event = new LhsExpressionErrorEventArgs(expression, exception, arguments, tuple, fact, nodeInfo.Rules);
handler(session, @event);
isHandled |= @event.IsHandled;
}
_parent?.RaiseLhsExpressionFailed(session, exception, expression, argumentMap, tuple, fact, nodeInfo, ref isHandled);
}
public void RaiseLhsExpressionEvaluated(ISession session, Exception exception, Expression expression, IArgumentMap argumentMap, object result, Tuple tuple, Fact fact, NodeDebugInfo nodeInfo)
{
var handler = LhsExpressionEvaluatedEvent;
if (handler != null)
{
var arguments = new LhsExpressionArguments(argumentMap, tuple, fact);
var @event = new LhsExpressionEventArgs(expression, exception, arguments, result, tuple, fact, nodeInfo.Rules);
handler(session, @event);
}
_parent?.RaiseLhsExpressionEvaluated(session, exception, expression, argumentMap, result, tuple, fact, nodeInfo);
}
internal AggregationContext(ISessionInternal session, IEventAggregator eventAggregator, NodeDebugInfo nodeInfo)
{
Session = session;
EventAggregator = eventAggregator;
NodeInfo = nodeInfo;
}
public override void OnNodeEnable()
{
node = target as NodeDebugInfo;
}
