public override bool Equals(TypeSpecifier other)
{
if (other == null)
return false;
StructureSpecifier stOther = other as StructureSpecifier;
if (stOther == null)
return false;
if (this.Identifier != null)
{
if (this.Identifier.Equals(stOther.Identifier))
return true;
}
else if (stOther.Identifier == null)
{
if (this.StructureDeclarationList.Count == stOther.StructureDeclarationList.Count)
{
for (int i = 0; i < this.StructureDeclarationList.Count; ++i)
{
if (!stOther.StructureDeclarationList[i].Equals(this.StructureDeclarationList[i]))
return false;
}
return true;
}
}
return false;
}
public IEnumerable <ConstructorSpecifier> GetConstructors(TypeSpecifier typeSpecifier)
{
var symbol = GetTypeFromSpecifier <INamedTypeSymbol>(typeSpecifier);
if (symbol != null)
{
return(symbol.Constructors.Select(c => ReflectionConverter.ConstructorSpecifierFromSymbol(c)));
}
return(new ConstructorSpecifier[0]);
}
public void AddReturnType()
{
if (this != Method.MainReturnNode)
{
throw new InvalidOperationException("Can only add return types on the main return node.");
}
int returnIndex = InputDataPins.Count;
AddInputDataPin($"Output{returnIndex}", new ObservableValue <BaseType>(TypeSpecifier.FromType <object>()));
AddInputTypePin($"Output{returnIndex}Type");
}
/// <summary>
/// Translates an object into a literal value (eg. a float 32.32 -> "32.32f")
/// </summary>
/// <param name="obj">Object value to translate.</param>
/// <param name="type">Specifier for the type of the literal.</param>
/// <returns></returns>
public static string ObjectToLiteral(object obj, TypeSpecifier type)
{
// Interpret object string as enum field
if (type.IsEnum)
{
return($"{type}.{obj}");
}
// Null
if (obj is null)
{
return("null");
}
// Put quotes around string literals
if (type == TypeSpecifier.FromType <string>())
{
return($"\"{obj}\"");
}
else if (type == TypeSpecifier.FromType <float>())
{
return($"{obj}F");
}
else if (type == TypeSpecifier.FromType <double>())
{
return($"{obj}D");
}
else if (type == TypeSpecifier.FromType <uint>())
{
return($"{obj}U");
}
// Put single quotes around char literals
else if (type == TypeSpecifier.FromType <char>())
{
return($"'{obj}'");
}
else if (type == TypeSpecifier.FromType <long>())
{
return($"{obj}L");
}
else if (type == TypeSpecifier.FromType <ulong>())
{
return($"{obj}UL");
}
else if (type == TypeSpecifier.FromType <decimal>())
{
return($"{obj}M");
}
else
{
return(obj.ToString());
}
}
private static MethodSpecifier TryMakeClosedMethod(MethodSpecifier method,
BaseType typeToReplace, TypeSpecifier replacementType)
{
// Create a list of generic types to replace with another type
// These will then look for those generic types in the argument-
// and return types and replace them with the new type
Dictionary <GenericType, BaseType> replacedGenericTypes =
new Dictionary <GenericType, BaseType>();
// If the arg is already generic itself, replace it directly with the
// passed type specifier
// Otherwise, recursively check if the generic arguments should
// be replaced
if (typeToReplace is GenericType genType)
{
replacedGenericTypes.Add(genType, replacementType);
}
else if (typeToReplace is TypeSpecifier argTypeSpec)
{
if (!FindGenericArgumentsToReplace(argTypeSpec.GenericArguments,
replacementType.GenericArguments, ref replacedGenericTypes))
{
return(null);
}
}
IList <BaseType> methodArgTypes = method.ArgumentTypes.ToList();
ReplaceGenericTypes(methodArgTypes, replacedGenericTypes);
// Replace method arguments' types by the replaced ones
for (int i = 0; i < method.Arguments.Count; i++)
{
method.Arguments[i].Value = methodArgTypes[i];
}
ReplaceGenericTypes(method.ReturnTypes, replacedGenericTypes);
// Remove the replaced generic arguments from the method
replacedGenericTypes.Keys.ToList().ForEach(g =>
method.GenericArguments.Remove(g));
// Only add fully closed methods
if (!method.GenericArguments.Any(a => a is GenericType))
{
return(method);
}
return(null);
}
public void TestGenericTypeConversionEquality()
{
TypeSpecifier typeInt = typeof(System.Collections.Generic.List <int>);
Assert.AreEqual(typeInt, typeof(System.Collections.Generic.List <int>));
Assert.AreEqual(typeof(System.Collections.Generic.List <int>), typeInt);
Assert.AreNotEqual(typeInt, typeof(System.Collections.Generic.List <string>));
Assert.AreNotEqual(typeof(System.Collections.Generic.List <string>), typeInt);
Assert.AreNotEqual(typeInt, typeof(System.Collections.Generic.Stack <string>));
Assert.AreNotEqual(typeof(System.Collections.Generic.Stack <string>), typeInt);
}
public ConstantExpression(object value, TypeSpecifier type, ISourcePositionInfo location = null) : base(type, location)
{
if (value == null)
{
Error.ArgumentNull("value");
}
if (value is P.Any && (value is P.Boolean || value is P.Decimal || value is P.Integer || value is P.Long || value is P.String))
{
throw new ArgumentException("Internal error: not yet ready to handle Any-based primitives in FhirPath.");
}
Value = value;
}
public object Find(TypeSpecifier typeSpecifier)
{
if (typeSpecifier is SimpleType)
{
var t = typeSpecifier as SimpleType;
if (t.TypeKind == SimpleTypeKind.Class)
{
return(Classes.Where(_ => _.Name == t.TypeName && _.Namespace == _.Namespace).FirstOrDefault());
}
}
return(null);
}
public IEnumerable <string> GetEnumNames(TypeSpecifier typeSpecifier)
{
var symbol = GetTypeFromSpecifier(typeSpecifier);
if (symbol != null)
{
return(symbol.GetAllMembers()
.Where(member => member.Kind == SymbolKind.Field)
.Select(member => member.Name));
}
return(new string[0]);
}
public void TestGetNativeType()
{
Assert.AreEqual(typeof(string), TypeSpecifier.String.GetNativeType());
Assert.AreEqual(typeof(Quantity), TypeSpecifier.Quantity.GetNativeType());
Assert.AreEqual(typeof(object), TypeSpecifier.Any.GetNativeType());
Assert.AreEqual(typeof(PartialTime), TypeSpecifier.Time.GetNativeType());
Assert.AreEqual(typeof(Guid), TypeSpecifier.ForNativeType(typeof(Guid)).GetNativeType());
#if !NET40
Assert.ThrowsException <NotSupportedException>(() => TypeSpecifier.GetByName("DotNet", "NoSuchType").GetNativeType());
Assert.ThrowsException <NotSupportedException>(() => TypeSpecifier.GetByName("Internal", "NoSuchType").GetNativeType());
#endif
}
public static Parser <Expression> FunctionParameter(string name)
{
// Make exception for is() and as() FUNCTIONS (operators are handled elsewhere), since they don't
// take a normal parameter, but an identifier (which is not normally a FhirPath type)
if (name != "is" && name != "as")
{
return(Grammar.Expression);
}
else
{
return(TypeSpecifier.Select(s => new ConstantExpression(s)));
}
}
public VariableSetterNode(NodeGraph graph, VariableSpecifier variable)
: base(graph, variable)
{
AddInputExecPin("Exec");
AddOutputExecPin("Exec");
AddInputDataPin("NewValue", variable.Type);
if (this.IsEvent)
{
AddInputDataPin("Subscribe", TypeSpecifier.FromType <bool>());
}
}
public void TestGenericTypeConversionEquality()
{
TypeSpecifier typeInt = TypeSpecifier.FromType <List <int> >();
Assert.AreEqual(typeInt, TypeSpecifier.FromType <List <int> >());
Assert.AreEqual(TypeSpecifier.FromType <List <int> >(), typeInt);
Assert.AreNotEqual(typeInt, TypeSpecifier.FromType <List <string> >());
Assert.AreNotEqual(TypeSpecifier.FromType <List <string> >(), typeInt);
Assert.AreNotEqual(typeInt, TypeSpecifier.FromType <Stack <string> >());
Assert.AreNotEqual(TypeSpecifier.FromType <Stack <string> >(), typeInt);
}
public override bool Equals(TypeSpecifier other)
{
if (other == null)
return false;
EnumSpecifier enOther = other as EnumSpecifier;
if (enOther == null)
return false;
if (Identifier.Equals(enOther.Identifier))
return true;
return false;
}
public void TestEquality()
{
Assert.AreEqual(TypeSpecifier.Concept, TypeSpecifier.Concept);
Assert.AreNotEqual(TypeSpecifier.Concept, TypeSpecifier.Code);
#pragma warning disable CS1718 // Comparison made to same variable - we're testing the '==' operator here
Assert.IsTrue(TypeSpecifier.Concept == TypeSpecifier.Concept);
#pragma warning restore CS1718 // Comparison made to same variable
Assert.IsTrue(TypeSpecifier.Concept != TypeSpecifier.Code);
Assert.AreEqual(TypeSpecifier.Concept, TypeSpecifier.GetByName("Concept"));
Assert.AreEqual(TypeSpecifier.Concept, TypeSpecifier.GetByName("System", "Concept"));
Assert.AreNotEqual(TypeSpecifier.Concept, TypeSpecifier.GetByName("System", "concept"));
Assert.AreNotEqual(TypeSpecifier.GetByName("System", "Concept"), TypeSpecifier.GetByName("System", "concept"));
}
private static void AddOperator(string opName, bool unary, TypeSpecifier argType, TypeSpecifier returnType)
{
IEnumerable <MethodParameter> parameters = new[]
{
new MethodParameter("a", argType, MethodParameterPassType.Default),
};
if (!unary)
{
parameters = parameters.Concat(new[] { new MethodParameter("b", argType, MethodParameterPassType.Default) });
}
all.Add(new MethodSpecifier(opName, parameters, new[] { returnType }, MethodModifiers.Static, MemberVisibility.Public, returnType, new BaseType[0]));
}
public ForLoopNode(Method method)
: base(method)
{
AddInputExecPin("Exec");
AddInputExecPin("Continue");
AddOutputExecPin("Loop");
AddOutputExecPin("Completed");
AddInputDataPin("InitialIndex", TypeSpecifier.FromType <int>());
AddInputDataPin("MaxIndex", TypeSpecifier.FromType <int>());
AddOutputDataPin("Index", TypeSpecifier.FromType <int>());
}
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 = typeof(List <>);
Assert.AreEqual(listType.GenericArguments.Count, 1);
listType.GenericArguments[0] = genericClassArg;
Method openMethod = new Method("OpenMethod");
openMethod.ArgumentTypes.Add(listType);
GraphUtil.ConnectExecPins(openMethod.EntryNode.InitialExecutionPin, openMethod.ReturnNode.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 = typeof(List <string>);
Method closedMethod = new Method("ClosedMethod");
closedMethod.ArgumentTypes.Add(closedListType);
GraphUtil.ConnectExecPins(closedMethod.EntryNode.InitialExecutionPin, closedMethod.ReturnNode.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 static bool Prompt(out TypeSpecifier type)
{
var selectTypeDialog = new SelectTypeDialog();
if (selectTypeDialog.ShowDialog() == true)
{
type = (TypeSpecifier)selectTypeDialog.SelectedItem;
if (type is not null && type.Equals(null) == false)
{
return(true);
}
}
type = default;
return(false);
}
public ForeachLoopNode(NodeGraph graph) :
base(graph)
{
AddInputExecPin("Exec");
//AddInputExecPin("Break");
AddOutputExecPin("Completed");
AddOutputExecPin("Loop");
AddOutputDataPin("Index", TypeSpecifier.FromType <int>());
AddOutputDataPin("Element", TypeSpecifier.FromType <object>());
AddInputDataPin("Collection", TypeSpecifier.FromType <IEnumerable <object> >());
SetupEvents();
UpdateElementPin();
}
public static TypeSpecifier DetermineTypeNodeType(TypeNode node)
{
// TODO: Copy node.Type
// Replace generic arguments with input pins
foreach (NodeInputTypePin inputTypePin in node.InputTypePins)
{
// TODO: Check inputTypePin constraints
TypeSpecifier inputType = DetermineTypeNodeType(inputTypePin.Node);
int pinIndex = node.InputTypePins.IndexOf(inputTypePin);
node.Type.GenericArguments[pinIndex] = inputType;
}
return(node.Type);
}
public ForLoopNode(NodeGraph graph)
: base(graph)
{
AddInputExecPin("Exec");
AddOutputExecPin("Completed");
AddOutputExecPin("Loop");
AddInputDataPin("InitialIndex", TypeSpecifier.FromType <int>());
AddInputDataPin("MaxIndex", TypeSpecifier.FromType <int>());
AddOutputDataPin("Index", TypeSpecifier.FromType <int>());
InitialIndexPin.UsesExplicitDefaultValue = true;
InitialIndexPin.ExplicitDefaultValue = 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 ConstantExpression(object value, ISourcePositionInfo location = null) : base(TypeSpecifier.Any, location)
{
if (value == null)
{
Error.ArgumentNull("value");
}
if (Any.TryConvertToSystemValue(value, out var systemValue))
{
Value = systemValue;
ExpressionType = TypeSpecifier.ForNativeType(value.GetType());
}
else
{
throw Error.InvalidOperation("Internal logic error: encountered unmappable Value of type " + Value.GetType().Name);
}
}
public static string ObjectToLiteral(object obj, TypeSpecifier type)
{
// Interpret object string as enum field
if (type.IsEnum)
{
return($"{type}.{obj}");
}
// Put quotes around string literals
if (type == typeof(string))
{
return($"\"{obj}\"");
}
else if (type == typeof(float))
{
return($"{obj}F");
}
else if (type == typeof(double))
{
return($"{obj}D");
}
else if (type == typeof(uint))
{
return($"{obj}U");
}
// Put single quotes around char literals
else if (type == typeof(char))
{
return($"'{obj}'");
}
else if (type == typeof(long))
{
return($"{obj}L");
}
else if (type == typeof(ulong))
{
return($"{obj}UL");
}
else if (type == typeof(decimal))
{
return($"{obj}M");
}
else
{
return(obj.ToString());
}
}
public void Setup()
{
classTranslator = new ClassTranslator();
cls = new ClassGraph()
{
Name = "TestClass",
Namespace = "TestNamespace",
};
CreateStringLengthMethod();
CreateMainMethod();
cls.Variables.Add(new Variable(cls, "testVariable", TypeSpecifier.FromType <string>(), null, null, VariableModifiers.None));
cls.Methods.Add(stringLengthMethod);
cls.Methods.Add(mainMethod);
}
public void TestConstruction()
{
var sysT = TypeSpecifier.GetByName("Concept");
Assert.AreEqual("System", sysT.Namespace);
Assert.AreEqual("Concept", sysT.Name);
Assert.IsTrue(Object.ReferenceEquals(sysT, TypeSpecifier.Concept));
sysT = TypeSpecifier.GetByName("AsYetUnknown");
Assert.AreEqual("System", sysT.Namespace);
Assert.AreEqual("AsYetUnknown", sysT.Name);
var cusT = TypeSpecifier.GetByName("MySpace", "MyType");
Assert.AreEqual("MySpace", cusT.Namespace);
Assert.AreEqual("MyType", cusT.Name);
}
public LiteralNode(Method method, TypeSpecifier literalType)
: base(method)
{
LiteralType = literalType;
// Add type pins for each generic argument of the literal type
// and monitor them for changes to reconstruct the actual pin types.
foreach (var genericArg in literalType.GenericArguments.OfType <GenericType>())
{
AddInputTypePin(genericArg.Name);
}
AddInputDataPin("Value", literalType);
AddOutputDataPin("Value", literalType);
UpdatePinTypes();
}
public IEnumerable <MethodSpecifier> GetStaticFunctionsWithArgumentType(TypeSpecifier searchTypeSpec)
{
// Find all public static methods
IEnumerable <IMethodSymbol> availableMethods = GetValidTypes()
.Where(t => t.IsPublic())
.SelectMany(t =>
t.GetMethods()
.Where(m => m.IsPublic() && m.IsStatic && !m.ContainingType.IsUnboundGenericType))
.OrderBy(m => m?.ContainingNamespace.Name)
.ThenBy(m => m?.ContainingType.Name)
.ThenBy(m => m.Name);
ITypeSymbol searchType = GetTypeFromSpecifier(searchTypeSpec);
List <MethodSpecifier> foundMethods = new List <MethodSpecifier>();
// Find compatible methods
foreach (IMethodSymbol availableMethod in availableMethods)
{
MethodSpecifier availableMethodSpec = ReflectionConverter.MethodSpecifierFromSymbol(availableMethod);
// Check each argument whether it can be replaced by the wanted type
for (int i = 0; i < availableMethodSpec.Arguments.Count; i++)
{
ITypeSymbol argType = availableMethod.Parameters[i].Type;
BaseType arg = ReflectionConverter.BaseTypeSpecifierFromSymbol(argType);
if (arg == searchTypeSpec || searchType.IsSubclassOf(argType))
{
MethodSpecifier foundMethod = ReflectionConverter.MethodSpecifierFromSymbol(availableMethod);
foundMethod = TryMakeClosedMethod(foundMethod, arg, searchTypeSpec);
// Only add fully closed methods
if (foundMethod != null && !foundMethods.Contains(foundMethod))
{
foundMethods.Add(foundMethod);
}
}
}
}
return(foundMethods);
}
public IEnumerable <MethodSpecifier> GetStaticFunctionsWithArgumentType(TypeSpecifier searchTypeSpec)
{
// Find all public static methods
IEnumerable <MethodInfo> availableMethods = Assemblies
.SelectMany(a =>
a.GetTypes()
.Where(t => t.IsPublic)
.SelectMany(t =>
t.GetMethods(BindingFlags.Static | BindingFlags.Public)
.Where(m => !m.IsSpecialName &&
!m.DeclaringType.ContainsGenericParameters)));
Type searchType = GetTypeFromSpecifier(searchTypeSpec);
List <MethodSpecifier> foundMethods = new List <MethodSpecifier>();
// Find compatible methods
foreach (MethodInfo availableMethod in availableMethods)
{
MethodSpecifier availableMethodSpec = availableMethod;
// Check each argument whether it can be replaced by the wanted type
for (int i = 0; i < availableMethodSpec.Arguments.Count; i++)
{
Type argType = availableMethod.GetParameters()[i].ParameterType;
BaseType arg = argType;
if (arg == searchTypeSpec || searchType.IsSubclassOf(argType))
{
MethodSpecifier foundMethod = availableMethod;
foundMethod = TryMakeClosedMethod(foundMethod, arg, searchTypeSpec);
// Only add fully closed methods
if (foundMethod != null && !foundMethods.Contains(foundMethod))
{
foundMethods.Add(foundMethod);
}
}
}
}
return(foundMethods);
}
public void GetPrimitiveName()
{
Dictionary <Type, string> data = new Dictionary <Type, string>
{
{ typeof(PartialDateTime), "dateTime" },
{ typeof(UInt16), "integer" },
{ typeof(Boolean), "boolean" }
};
foreach (var pair in data)
{
var native = pair.Key;
var expected = pair.Value;
Assert.IsTrue(TypeSpecifier.TryGetPrimitiveTypeName(native, out var actual));
Assert.AreEqual(expected, actual);
}
}