public void CreateStringLengthMethod()
{
// Create method
stringLengthMethod = new MethodGraph("StringLength")
{
Class = cls,
Modifiers = MethodModifiers.None
};
List <TypeNode> returnTypeNodes = new List <TypeNode>()
{
new TypeNode(stringLengthMethod, TypeSpecifier.FromType <int>()),
};
for (int i = 0; i < returnTypeNodes.Count; i++)
{
stringLengthMethod.MainReturnNode.AddReturnType();
GraphUtil.ConnectTypePins(returnTypeNodes[i].OutputTypePins[0], stringLengthMethod.MainReturnNode.InputTypePins[i]);
}
TypeSpecifier stringType = TypeSpecifier.FromType <string>();
TypeSpecifier intType = TypeSpecifier.FromType <int>();
// Create nodes
VariableGetterNode getStringNode = new VariableGetterNode(stringLengthMethod, new VariableSpecifier("testVariable", stringType, MemberVisibility.Public, MemberVisibility.Public, stringType, VariableModifiers.None));
VariableGetterNode getLengthNode = new VariableGetterNode(stringLengthMethod, new VariableSpecifier("Length", intType, MemberVisibility.Public, MemberVisibility.Public, stringType, VariableModifiers.None));
// Connect node execs
GraphUtil.ConnectExecPins(stringLengthMethod.EntryNode.InitialExecutionPin, stringLengthMethod.ReturnNodes.First().ReturnPin);
// Connect node data
GraphUtil.ConnectDataPins(getStringNode.ValuePin, getLengthNode.TargetPin);
GraphUtil.ConnectDataPins(getLengthNode.ValuePin, stringLengthMethod.ReturnNodes.First().InputDataPins[0]);
}
public void TestGenerics()
{
// Create the open class<T> which contains a List<T>
GenericType genericClassArg = new GenericType("T");
Class openClass = new Class();
openClass.Name = "OpenClass";
openClass.Namespace = "Namespace";
openClass.DeclaredGenericArguments.Add(genericClassArg);
TypeSpecifier listType = TypeSpecifier.FromType(typeof(List <>));
Assert.AreEqual(listType.GenericArguments.Count, 1);
listType.GenericArguments[0] = genericClassArg;
Method openMethod = new Method("OpenMethod");
// Add open list parameter
TypeNode listTypeNode = new TypeNode(openMethod, listType);
openMethod.MainReturnNode.AddReturnType();
GraphUtil.ConnectTypePins(listTypeNode.OutputTypePins[0], openMethod.MainReturnNode.InputTypePins[0]);
GraphUtil.ConnectExecPins(openMethod.EntryNode.InitialExecutionPin, openMethod.ReturnNodes.First().ReturnPin);
openClass.Methods.Add(openMethod);
// Create the closed class which contains a List<string>
Class closedClass = new Class();
closedClass.Name = "ClosedClass";
closedClass.Namespace = "Namespace";
TypeSpecifier closedListType = TypeSpecifier.FromType <string>();
Method closedMethod = new Method("ClosedMethod");
// Add closed list parameter
TypeNode closedListTypeNode = new TypeNode(closedMethod, closedListType);
closedMethod.MainReturnNode.AddReturnType();
GraphUtil.ConnectTypePins(closedListTypeNode.OutputTypePins[0], closedMethod.MainReturnNode.InputTypePins[0]);
GraphUtil.ConnectExecPins(closedMethod.EntryNode.InitialExecutionPin, closedMethod.ReturnNodes.First().ReturnPin);
closedClass.Methods.Add(closedMethod);
// Translate the classes
ClassTranslator translator = new ClassTranslator();
string openClassTranslated = translator.TranslateClass(openClass);
string closedClassTranslated = translator.TranslateClass(closedClass);
}
public void CreateStringLengthMethod()
{
List <TypeSpecifier> argumentTypes = new List <TypeSpecifier>()
{
TypeSpecifier.FromType <string>(),
};
// Create method
stringLengthMethod = new Method("StringLength")
{
Visibility = MemberVisibility.Public
};
// Add arguments
List <TypeNode> argTypeNodes = new List <TypeNode>()
{
new TypeNode(stringLengthMethod, TypeSpecifier.FromType <string>()),
};
for (int i = 0; i < argTypeNodes.Count; i++)
{
stringLengthMethod.EntryNode.AddArgument();
GraphUtil.ConnectTypePins(argTypeNodes[i].OutputTypePins[0], stringLengthMethod.EntryNode.InputTypePins[i]);
}
// Add return types
List <TypeNode> returnTypeNodes = new List <TypeNode>()
{
new TypeNode(stringLengthMethod, TypeSpecifier.FromType <int>()),
};
for (int i = 0; i < returnTypeNodes.Count; i++)
{
stringLengthMethod.MainReturnNode.AddReturnType();
GraphUtil.ConnectTypePins(returnTypeNodes[i].OutputTypePins[0], stringLengthMethod.MainReturnNode.InputTypePins[i]);
}
// Create nodes
var getLengthNode = new VariableGetterNode(stringLengthMethod, new VariableSpecifier("Length", TypeSpecifier.FromType <int>(),
MemberVisibility.Public, MemberVisibility.Public, TypeSpecifier.FromType <string>(), VariableModifiers.None));
// Connect node execs
GraphUtil.ConnectExecPins(stringLengthMethod.EntryNode.InitialExecutionPin, stringLengthMethod.ReturnNodes.First().ReturnPin);
// Connect node data
GraphUtil.ConnectDataPins(stringLengthMethod.EntryNode.OutputDataPins[0], getLengthNode.InputDataPins[0]);
GraphUtil.ConnectDataPins(getLengthNode.OutputDataPins[0], stringLengthMethod.ReturnNodes.First().InputDataPins[0]);
}
public void CreateIfElseMethod()
{
// Create method
ifElseMethod = new Method("IfElse")
{
Visibility = MemberVisibility.Public
};
// Add arguments
List <TypeNode> argTypeNodes = new List <TypeNode>()
{
new TypeNode(ifElseMethod, TypeSpecifier.FromType <int>()),
new TypeNode(ifElseMethod, TypeSpecifier.FromType <bool>()),
};
for (int i = 0; i < argTypeNodes.Count; i++)
{
ifElseMethod.EntryNode.AddArgument();
GraphUtil.ConnectTypePins(argTypeNodes[i].OutputTypePins[0], ifElseMethod.EntryNode.InputTypePins[i]);
}
// Add return types
List <TypeNode> returnTypeNodes = new List <TypeNode>()
{
new TypeNode(ifElseMethod, TypeSpecifier.FromType <int>()),
};
for (int i = 0; i < returnTypeNodes.Count; i++)
{
ifElseMethod.MainReturnNode.AddReturnType();
GraphUtil.ConnectTypePins(returnTypeNodes[i].OutputTypePins[0], ifElseMethod.MainReturnNode.InputTypePins[i]);
}
// Create nodes
IfElseNode ifElseNode = new IfElseNode(ifElseMethod);
LiteralNode literalNode = LiteralNode.WithValue(ifElseMethod, 123);
// Connect exec nodes
GraphUtil.ConnectExecPins(ifElseMethod.EntryNode.InitialExecutionPin, ifElseNode.ExecutionPin);
GraphUtil.ConnectExecPins(ifElseNode.TruePin, ifElseMethod.ReturnNodes.First().ReturnPin);
GraphUtil.ConnectExecPins(ifElseNode.FalsePin, ifElseMethod.ReturnNodes.First().ReturnPin);
// Connect node data
GraphUtil.ConnectDataPins(ifElseMethod.EntryNode.OutputDataPins[1], ifElseNode.ConditionPin);
GraphUtil.ConnectDataPins(ifElseMethod.EntryNode.OutputDataPins[0], ifElseMethod.ReturnNodes.First().InputDataPins[0]);
GraphUtil.ConnectDataPins(literalNode.ValuePin, ifElseMethod.ReturnNodes.First().InputDataPins[0]);
}
public void TestTypeGraph()
{
Method method = new Method("Method");
var unboundListType = new TypeSpecifier("System.Collections.Generic.List", genericArguments: new BaseType[] { new GenericType("T") });
var literalNode = new LiteralNode(method, unboundListType);
Assert.AreEqual(literalNode.InputTypePins.Count, 1);
var typeNode = new TypeNode(method, TypeSpecifier.FromType <int>());
Assert.AreEqual(literalNode.InputTypePins.Count, 1);
GraphUtil.ConnectTypePins(typeNode.OutputTypePins[0], literalNode.InputTypePins[0]);
Assert.AreEqual(literalNode.InputTypePins[0].InferredType.Value, new TypeSpecifier("System.Int32"));
Assert.AreEqual(literalNode.OutputDataPins[0].PinType.Value, new TypeSpecifier("System.Collections.Generic.List", genericArguments: new BaseType[] { new TypeSpecifier("System.Int32") }));
}
public void TestDelegate()
{
// Create method
Method delegateMethod = new Method("DelegateMethod")
{
Visibility = MemberVisibility.Public
};
List <TypeNode> returnTypeNodes = new List <TypeNode>()
{
new TypeNode(delegateMethod, TypeSpecifier.FromType <Func <int, string, float> >()),
};
for (int i = 0; i < returnTypeNodes.Count; i++)
{
delegateMethod.MainReturnNode.AddReturnType();
GraphUtil.ConnectTypePins(returnTypeNodes[i].OutputTypePins[0], delegateMethod.MainReturnNode.InputTypePins[i]);
}
MethodSpecifier delegateMethodSpecifier = new MethodSpecifier("TestMethod",
new MethodParameter[]
{
new MethodParameter("arg1", TypeSpecifier.FromType <int>(), MethodParameterPassType.Default),
new MethodParameter("arg2", TypeSpecifier.FromType <string>(), MethodParameterPassType.Default)
},
new BaseType[] { TypeSpecifier.FromType <float>() },
MethodModifiers.Static, MemberVisibility.Public,
TypeSpecifier.FromType <double>(), Array.Empty <BaseType>());
// Create nodes
MakeDelegateNode makeDelegateNode = new MakeDelegateNode(delegateMethod, delegateMethodSpecifier);
// Connect node execs
GraphUtil.ConnectExecPins(delegateMethod.EntryNode.InitialExecutionPin, delegateMethod.ReturnNodes.First().ReturnPin);
// Connect node data
GraphUtil.ConnectDataPins(makeDelegateNode.OutputDataPins[0], delegateMethod.ReturnNodes.First().InputDataPins[0]);
string translated = methodTranslator.Translate(delegateMethod, true);
}