public override IConcreteFunction CreateConcrete(FunnyType[] concreteTypes) { var from = concreteTypes[1]; var to = concreteTypes[0]; if (to == FunnyType.Anything || from == to) { return(new ConcreteConverter(o => o, from, to)); } if (to == FunnyType.Text) { return(new ConcreteConverter(o => o.ToString(), from, to)); } var safeConverter = VarTypeConverter.GetConverterOrNull(from, to); if (safeConverter != null) { return(new ConcreteConverter(safeConverter, from, to)); } if (to.ArrayTypeSpecification?.FunnyType == FunnyType.UInt8) { var serializer = CreateSerializerOrNull(from); if (serializer != null) { return(new ConcreteConverter(serializer, from, to)); } } else if (to.ArrayTypeSpecification?.FunnyType == FunnyType.Bool) { var serializer = CreateBinarizerOrNull(from); if (serializer != null) { return(new ConcreteConverter(serializer, from, to)); } } if (from.ArrayTypeSpecification?.FunnyType == FunnyType.UInt8) { var deserializer = CreateDeserializerOrNull(to); if (deserializer != null) { return(new ConcreteConverter(deserializer, from, to)); } } else if (from.IsText) { var parser = CreateParserOrNull(to); if (parser != null) { return(new ConcreteConverter(parser, from, to)); } } throw FunParseException.ErrorStubToDo($"Impossible explicit convertation {from}->{to}"); }
public static IExpressionNode GetConvertedOrOriginOrThrow(IExpressionNode origin, FunnyType to) { if (origin.Type == to) { return(origin); } var converter = VarTypeConverter.GetConverterOrThrow(origin.Type, to, origin.Interval); return(new CastExpressionNode(origin, to, converter, origin.Interval)); }
public void ConvertPrimitives(object from, object expected, BaseFunnyType typeFrom, BaseFunnyType typeTo) { Assert.IsTrue(VarTypeConverter.CanBeConverted( @from: FunnyType.PrimitiveOf(typeFrom), to: FunnyType.PrimitiveOf(typeTo))); var converter = VarTypeConverter.GetConverterOrNull( FunnyType.PrimitiveOf(typeFrom), FunnyType.PrimitiveOf(typeTo)); var converted = converter(from); Assert.AreEqual(converted, expected); }
public void ConvertFun() { var typeFrom = FunnyType.Fun(FunnyType.Bool, FunnyType.Int32); var typeTo = FunnyType.Fun(FunnyType.Text, FunnyType.UInt8); Assert.IsTrue(VarTypeConverter.CanBeConverted(typeFrom, typeTo)); var coverter = VarTypeConverter.GetConverterOrNull(typeFrom, typeTo); Func <int, bool> funcFrom = (input) => input > 0; var convertedFunc = coverter(new LambdaToFunWrapper <int, bool>(funcFrom)) as IConcreteFunction; var result = convertedFunc.Calc(new object[] { ((byte)12) }); Assert.IsInstanceOf <IFunArray>(result, $"Actual result is {result}"); Assert.AreEqual((result as IFunArray).ToText(), "True"); }
public void ConvertIntArrayToRealArray() { var intArray = new ImmutableFunArray(new[] { 1, 2, 3, 4 }); var typeFrom = FunnyType.ArrayOf(FunnyType.Int32); var typeTo = FunnyType.ArrayOf(FunnyType.Real); Assert.IsTrue(VarTypeConverter.CanBeConverted(typeFrom, typeTo)); var coverter = VarTypeConverter.GetConverterOrNull(typeFrom, typeTo); var actual = coverter(intArray) as IFunArray; Assert.IsNotNull(actual); Assert.AreEqual(typeTo.ArrayTypeSpecification.FunnyType, actual.ElementType); CollectionAssert.AreEqual(new double[] { 1, 2, 3, 4 }, actual); }
private IExpressionNode CreateFunctionCall(IFunCallSyntaxNode node, IConcreteFunction function) { var children = node.Args.SelectToArray(ReadNode); var converted = function.CreateWithConvertionOrThrow(children, node.Interval); if (converted.Type != node.OutputType) { var converter = VarTypeConverter.GetConverterOrThrow(converted.Type, node.OutputType, node.Interval); return(new CastExpressionNode(converted, node.OutputType, converter, node.Interval)); } else { return(converted); } }
public void ConvertStruct() { var typeTo = FunnyType.StructOf(("name", FunnyType.Text)); var typeFrom = FunnyType.StructOf(("name", FunnyType.Text), ("age", FunnyType.Int32)); Assert.IsTrue(VarTypeConverter.CanBeConverted(typeFrom, typeTo)); var coverter = VarTypeConverter.GetConverterOrNull(typeFrom, typeTo); var fromStruct = FunnyStruct.Create(("name", new TextFunArray("vasa")), ("age", 42)); var convertedStruct = coverter(fromStruct) as FunnyStruct; Assert.IsNotNull(convertedStruct); var val = convertedStruct.GetValue("name") as TextFunArray; Assert.AreEqual(val, new TextFunArray("vasa")); }
public IExpressionNode CreateWithConvertionOrThrow(IList <IExpressionNode> children, Interval interval) { var i = 0; var argNode = children[0]; var toType = ArgTypes[i]; var fromType = argNode.Type; var castedNode = argNode; if (fromType != toType) { var converter = VarTypeConverter.GetConverterOrThrow(fromType, toType, argNode.Interval); castedNode = new CastExpressionNode(argNode, toType, converter, argNode.Interval); } i++; return(new FunOfSingleArgExpressionNode(this, castedNode, interval)); }
public static IExpressionNode BuildExpression( ISyntaxNode node, IFunctionDictionary functions, FunnyType outputType, VariableDictionary variables, TypeInferenceResults typeInferenceResults, TicTypesConverter typesConverter) { var result = node.Accept( new ExpressionBuilderVisitor(functions, variables, typeInferenceResults, typesConverter)); if (result.Type == outputType) { return(result); } var converter = VarTypeConverter.GetConverterOrThrow(result.Type, outputType, node.Interval); return(new CastExpressionNode(result, outputType, converter, node.Interval)); }
public IExpressionNode CreateWithConvertionOrThrow(IList <IExpressionNode> children, Interval interval) { var castedChildren = new IExpressionNode[children.Count]; var i = 0; foreach (var argNode in children) { var toType = ArgTypes[i]; var fromType = argNode.Type; var castedNode = argNode; if (fromType != toType) { var converter = VarTypeConverter.GetConverterOrThrow(fromType, toType, argNode.Interval); castedNode = new CastExpressionNode(argNode, toType, converter, argNode.Interval); } castedChildren[i] = castedNode; i++; } return(new FunOfTwoArgsExpressionNode(this, castedChildren[0], castedChildren[1], interval)); }