public override string TypeOfMemberOrAttribute(string matchOrGraphElementType, string memberOrAttribute)
{
if (matchOrGraphElementType.StartsWith("match<class "))
{
String matchClassName = TypesHelper.GetMatchClassName(matchOrGraphElementType);
IMatchClass matchClass = actionsTypeInformation.matchClasses[matchClassName];
IPatternElement element = matchClass.GetPatternElement(memberOrAttribute);
if (element == null)
{
throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember);
}
GrGenType elementType = element.Type;
return(TypesHelper.DotNetTypeToXgrsType(elementType));
}
else if (matchOrGraphElementType.StartsWith("match<"))
{
String ruleName = TypesHelper.GetRuleName(matchOrGraphElementType);
if (!actionsTypeInformation.rulesToTopLevelEntities[ruleName].Contains(memberOrAttribute))
{
throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember);
}
int indexOfEntity = actionsTypeInformation.rulesToTopLevelEntities[ruleName].IndexOf(memberOrAttribute);
return(actionsTypeInformation.rulesToTopLevelEntityTypes[ruleName][indexOfEntity]);
}
else
{
GrGenType graphElementType = TypesHelper.GetNodeOrEdgeType(matchOrGraphElementType, Model);
AttributeType attributeType = graphElementType.GetAttributeType(memberOrAttribute);
if (attributeType == null)
{
throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownAttribute);
}
return(TypesHelper.AttributeTypeToXgrsType(attributeType));
}
}
public override string TypeOfMemberOrAttribute(string matchOrGraphElementType, string memberOrAttribute)
{
if (matchOrGraphElementType.StartsWith("match<class "))
{
MatchClassFilterer matchClass = actions.GetMatchClass(TypesHelper.GetMatchClassName(matchOrGraphElementType));
IPatternElement element = matchClass.info.GetPatternElement(memberOrAttribute);
if (element == null)
{
throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember);
}
GrGenType elementType = element.Type;
return(TypesHelper.DotNetTypeToXgrsType(elementType));
}
else if (matchOrGraphElementType.StartsWith("match<"))
{
IAction action = actions.GetAction(TypesHelper.GetRuleName(matchOrGraphElementType));
IPatternElement element = action.RulePattern.PatternGraph.GetPatternElement(memberOrAttribute);
if (element == null)
{
throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember);
}
GrGenType elementType = element.Type;
return(TypesHelper.DotNetTypeToXgrsType(elementType));
}
else
{
GrGenType graphElementType = TypesHelper.GetNodeOrEdgeType(matchOrGraphElementType, Model);
AttributeType attributeType = graphElementType.GetAttributeType(memberOrAttribute);
if (attributeType == null)
{
throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownAttribute);
}
return(TypesHelper.AttributeTypeToXgrsType(attributeType));
}
}
protected override string OutputParameterType(int i, Invocation invocation, GrGenType ownerType)
{
if (invocation is RuleInvocation)
{
RuleInvocation ruleInvocation = (RuleInvocation)invocation;
return(actionsTypeInformation.rulesToOutputTypes[ruleInvocation.PackagePrefixedName][i]);
}
else if (invocation is SequenceInvocation)
{
SequenceInvocation seqInvocation = (SequenceInvocation)invocation;
return(actionsTypeInformation.sequencesToOutputTypes[seqInvocation.PackagePrefixedName][i]);
}
else if (invocation is ProcedureInvocation)
{
ProcedureInvocation procInvocation = (ProcedureInvocation)invocation;
if (ownerType != null)
{
IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name);
return(TypesHelper.DotNetTypeToXgrsType(procDef.Outputs[i]));
}
else
{
return(actionsTypeInformation.proceduresToOutputTypes[procInvocation.PackagePrefixedName][i]);
}
}
throw new Exception("Internal error");
}
protected static void FillReturnVariablesFromValues(SequenceVariable[] ReturnVars, IAction Action, IGraphProcessingEnvironment procEnv, List <object[]> retElemsList)
{
IList[] returnVars = null;
if (ReturnVars.Length > 0)
{
returnVars = new IList[ReturnVars.Length];
for (int i = 0; i < ReturnVars.Length; ++i)
{
returnVars[i] = ReturnVars[i].GetVariableValue(procEnv) as IList;
if (returnVars[i] == null)
{
string returnType = TypesHelper.DotNetTypeToXgrsType(Action.RulePattern.Outputs[i]);
Type valueType = TypesHelper.GetType(returnType, procEnv.Graph.Model);
returnVars[i] = ContainerHelper.NewList(valueType);
ReturnVars[i].SetVariableValue(returnVars[i], procEnv);
}
else
{
returnVars[i].Clear();
}
}
}
for (int curRetElemNum = 0; curRetElemNum < retElemsList.Count; ++curRetElemNum)
{
object[] retElems = retElemsList[curRetElemNum];
for (int i = 0; i < ReturnVars.Length; ++i)
{
returnVars[i].Add(retElems[i]);
}
}
}
public override string TypeOfTopLevelEntityInRule(string ruleName, string entityName)
{
IAction rule = actions.GetAction(ruleName);
if (rule == null)
{
throw new SequenceParserException(ruleName, SequenceParserError.UnknownRule);
}
foreach (IPatternNode node in rule.RulePattern.PatternGraph.Nodes)
{
if (node.UnprefixedName == entityName)
{
return(TypesHelper.DotNetTypeToXgrsType(node.Type));
}
}
foreach (IPatternEdge edge in rule.RulePattern.PatternGraph.Edges)
{
if (edge.UnprefixedName == entityName)
{
return(TypesHelper.DotNetTypeToXgrsType(edge.Type));
}
}
foreach (IPatternVariable var in rule.RulePattern.PatternGraph.Variables)
{
if (var.UnprefixedName == entityName)
{
return(TypesHelper.DotNetTypeToXgrsType(var.Type));
}
}
throw new SequenceParserException(ruleName, entityName, SequenceParserError.UnknownPatternElement);
}
protected override string InputParameterType(int i, Invocation invocation, GrGenType ownerType)
{
if (invocation is RuleInvocation)
{
RuleInvocation ruleInvocation = (RuleInvocation)invocation;
IAction action = SequenceBase.GetAction(ruleInvocation);
return(TypesHelper.DotNetTypeToXgrsType(action.RulePattern.Inputs[i]));
}
else if (invocation is SequenceInvocation)
{
SequenceSequenceCallInterpreted seqInvocation = (SequenceSequenceCallInterpreted)invocation;
if (seqInvocation.SequenceDef is SequenceDefinitionInterpreted)
{
SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqInvocation.SequenceDef;
return(seqDef.InputVariables[i].Type);
}
else
{
SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqInvocation.SequenceDef;
return(TypesHelper.DotNetTypeToXgrsType(seqDef.SeqInfo.ParameterTypes[i]));
}
}
else if (invocation is ProcedureInvocation)
{
ProcedureInvocation procInvocation = (ProcedureInvocation)invocation;
if (ownerType != null)
{
IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name);
return(TypesHelper.DotNetTypeToXgrsType(procDef.Inputs[i]));
}
else
{
SequenceComputationProcedureCallInterpreted procInvocationInterpreted = (SequenceComputationProcedureCallInterpreted)procInvocation;
return(TypesHelper.DotNetTypeToXgrsType(procInvocationInterpreted.ProcedureDef.Inputs[i]));
}
}
else if (invocation is FunctionInvocation)
{
FunctionInvocation funcInvocation = (FunctionInvocation)invocation;
if (ownerType != null)
{
IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name);
return(TypesHelper.DotNetTypeToXgrsType(funcDef.Inputs[i]));
}
else
{
SequenceExpressionFunctionCallInterpreted funcInvocationInterpreted = (SequenceExpressionFunctionCallInterpreted)funcInvocation;
return(TypesHelper.DotNetTypeToXgrsType(funcInvocationInterpreted.FunctionDef.Inputs[i]));
}
}
throw new Exception("Internal error");
}
private static void ToString(object value, out string type, out string content, IGraph graph,
bool firstLevelObjectEmitted, IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv)
{
if (value == null)
{
type = "<INVALID>";
content = ToString(value, null, graph, firstLevelObjectEmitted, nameToObject, procEnv);
return;
}
if (value is IMatch)
{
type = "IMatch";
content = ToString((IMatch)value, graph, firstLevelObjectEmitted, nameToObject, procEnv);
return;
}
if (value is IObject)
{
type = ((IObject)value).Type.PackagePrefixedName;
content = ToString((IObject)value, graph, firstLevelObjectEmitted, nameToObject, procEnv);
return;
}
if (value is ITransientObject)
{
type = ((ITransientObject)value).Type.PackagePrefixedName;
content = ToString((ITransientObject)value, graph, firstLevelObjectEmitted, nameToObject, procEnv);
return;
}
Debug.Assert(value.GetType().Name != "Dictionary`2" &&
value.GetType().Name != "List`1" && value.GetType().Name != "Deque`1");
type = TypesHelper.DotNetTypeToXgrsType(value.GetType().Name, value.GetType().FullName);
foreach (ExternalObjectType externalObjectType in graph.Model.ExternalObjectTypes)
{
if (externalObjectType.Name == value.GetType().Name)
{
type = "object";
}
}
if (type == "object")
{
content = ToStringObject(value, null, graph);
}
else
{
content = ToString(value, null, graph, firstLevelObjectEmitted, nameToObject, procEnv);
}
}
private string FilterFunctionParameterType(int i, SequenceFilterCall sequenceFilterCall)
{
if (sequenceFilterCall.Filter is IFilterAutoSupplied)
{
IFilterAutoSupplied filterAutoSupplied = (IFilterAutoSupplied)sequenceFilterCall.Filter;
return(TypesHelper.DotNetTypeToXgrsType(filterAutoSupplied.Inputs[i]));
}
if (sequenceFilterCall.Filter is IFilterFunction)
{
IFilterFunction filterFunction = (IFilterFunction)sequenceFilterCall.Filter;
return(TypesHelper.DotNetTypeToXgrsType(filterFunction.Inputs[i]));
}
throw new Exception("Internal error"); // auto-generated
}
private static void ToString(object value, out string type, out string content, IGraph graph)
{
if (value == null)
{
type = "<INVALID>";
content = ToString(value, null, graph);
return;
}
if (value is IMatch)
{
type = "IMatch";
content = ToString((IMatch)value, graph);
return;
}
Debug.Assert(value.GetType().Name != "Dictionary`2" &&
value.GetType().Name != "List`1" && value.GetType().Name != "Deque`1");
type = TypesHelper.DotNetTypeToXgrsType(value.GetType().Name, value.GetType().FullName);
foreach (ExternalType externalType in graph.Model.ExternalTypes)
{
if (externalType.Name == value.GetType().Name)
{
type = "object";
}
}
if (type == "object")
{
content = ToStringObject(value, null, graph);
}
else
{
content = ToString(value, null, graph);
}
}
public static IList Extract(object container, string memberOrAttribute, IGraphProcessingEnvironment procEnv)
{
IList array = (IList)container;
string arrayType = TypesHelper.DotNetTypeToXgrsType(array.GetType());
string arrayValueType = TypesHelper.ExtractSrc(arrayType);
if (arrayValueType.StartsWith("match<"))
{
if (arrayValueType == "match<>")
{
if (array.Count > 0)
{
IMatch match = (IMatch)array[0];
object matchElement = match.GetMember(memberOrAttribute);
Type matchElementType;
if (matchElement is IGraphElement)
{
matchElementType = TypesHelper.GetType(((IGraphElement)matchElement).Type, procEnv.Graph.Model);
}
else
{
matchElementType = matchElement.GetType();
}
Type listType = typeof(List <>).MakeGenericType(matchElementType);
IList extractedArray = (IList)Activator.CreateInstance(listType);
ExtractMatchMember(array, memberOrAttribute, extractedArray);
return(extractedArray);
}
else
{
return(new List <object>());
}
}
else
{
if (arrayValueType.StartsWith("match<class "))
{
MatchClassFilterer matchClass = procEnv.Actions.GetMatchClass(TypesHelper.GetMatchClassName(arrayValueType));
IPatternElement element = matchClass.info.GetPatternElement(memberOrAttribute);
GrGenType elementType = element.Type;
Type listType = typeof(List <>).MakeGenericType(TypesHelper.GetType(elementType, procEnv.Graph.Model));
IList extractedArray = (IList)Activator.CreateInstance(listType);
ExtractMatchMember(array, memberOrAttribute, extractedArray);
return(extractedArray);
}
else
{
IAction action = procEnv.Actions.GetAction(TypesHelper.GetRuleName(arrayValueType));
IPatternElement element = action.RulePattern.PatternGraph.GetPatternElement(memberOrAttribute);
GrGenType elementType = element.Type;
Type listType = typeof(List <>).MakeGenericType(TypesHelper.GetType(elementType, procEnv.Graph.Model));
IList extractedArray = (IList)Activator.CreateInstance(listType);
ExtractMatchMember(array, memberOrAttribute, extractedArray);
return(extractedArray);
}
}
}
else
{
GrGenType graphElementType = TypesHelper.GetNodeOrEdgeType(arrayValueType, procEnv.Graph.Model);
if (graphElementType != null)
{
AttributeType attributeType = graphElementType.GetAttributeType(memberOrAttribute);
Type listType = typeof(List <>).MakeGenericType(attributeType.Type);
IList extractedArray = (IList)Activator.CreateInstance(listType);
ExtractAttribute(array, memberOrAttribute, extractedArray);
return(extractedArray);
}
else
{
if (array.Count > 0)
{
IGraphElement graphElement = (IGraphElement)array[0];
object element = graphElement.GetAttribute(memberOrAttribute);
Type elementType;
if (element is IGraphElement)
{
elementType = TypesHelper.GetType(((IGraphElement)element).Type, procEnv.Graph.Model);
}
else
{
elementType = element.GetType();
}
Type listType = typeof(List <>).MakeGenericType(elementType);
IList extractedArray = (IList)Activator.CreateInstance(listType);
ExtractAttribute(array, memberOrAttribute, extractedArray);
return(extractedArray);
}
else
{
return(new List <object>());
}
}
}
}
