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 RuleDebugInfo FromProtobuf(RuleDebugInfoMsg msg)
{
var debugInfo = new RuleDebugInfo
{
Id = msg.Id,
GoalId = msg.GoalId,
Name = msg.Name,
Variables = new List <RuleVariableDebugInfo>(),
Actions = new List <ActionDebugInfo>(),
ConditionsStartLine = msg.ConditionsStartLine,
ConditionsEndLine = msg.ConditionsEndLine,
ActionsStartLine = msg.ActionsStartLine,
ActionsEndLine = msg.ActionsEndLine
};
foreach (var variableMsg in msg.Variables)
{
var variable = FromProtobuf(variableMsg);
debugInfo.Variables.Add(variable);
}
foreach (var action in msg.Actions)
{
debugInfo.Actions.Add(FromProtobuf(action));
}
return(debugInfo);
}
private RuleDebugInfoMsg ToProtobuf(RuleDebugInfo debugInfo)
{
var msg = new RuleDebugInfoMsg
{
Id = debugInfo.Id,
GoalId = debugInfo.GoalId,
Name = debugInfo.Name,
ConditionsStartLine = debugInfo.ConditionsStartLine,
ConditionsEndLine = debugInfo.ConditionsEndLine,
ActionsStartLine = debugInfo.ActionsStartLine,
ActionsEndLine = debugInfo.ActionsEndLine
};
foreach (var variable in debugInfo.Variables)
{
var varMsg = ToProtobuf(variable);
msg.Variables.Add(varMsg);
}
foreach (var action in debugInfo.Actions)
{
var varAct = ToProtobuf(action);
msg.Actions.Add(varAct);
}
return(msg);
}
public string TupleToString(MsgFrame frame)
{
string tuple = "";
var node = DebugInfo.Nodes[frame.NodeId];
RuleDebugInfo rule = null;
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];
string columnName = TupleVariableIndexToName(rule, node, i);
string valueStr;
switch ((Value.Type)value.TypeId)
{
case Value.Type.None:
valueStr = "(None)";
break;
case Value.Type.Integer:
case Value.Type.Integer64:
valueStr = value.Intval.ToString();
break;
case Value.Type.Float:
valueStr = value.Floatval.ToString();
break;
case Value.Type.String:
case Value.Type.GuidString:
default:
valueStr = value.Stringval;
break;
}
if (columnName.Length > 0)
{
tuple += String.Format("{0}={1}, ", columnName, valueStr);
}
else
{
tuple += String.Format("{0}, ", valueStr);
}
}
return(tuple);
}
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));
}
}
}
