public void Setup() { _options = Options.Create(); _source = new ValueNode( new Context(_options, Mode.Deserialize, "json"), null, new SimpleValue(typeof(int?).ToCachedType()), null, null); _target = new ValueNode( new Context(_options, Mode.Deserialize, "json"), null, new SimpleValue(typeof(int?).ToCachedType()), null, null); _readers = new ReaderConventions(_options); _visitorIncrement = (s, t, o) => { should_have_valid_parameters(s, t, o); t.Value = t.Value == null ? 1 : (int?)t.Value + 1; }; _readerIncrement = (s, t, o) => { should_have_valid_parameters(s, t, o); t.Value = t.Value == null ? 1 : (int?)t.Value + 1; }; _readerIncrementValue = (v, s, t, o) => { should_have_valid_parameters(v, s, t, o); return s.Value == null ? 1 : (int)s.Value + 1; }; _readerIncrementNullableValue = (v, s, t, o) => { should_have_valid_parameters(v, s, t, o); return s.Value == null ? 1 : (int?)s.Value + 1; }; }
public static Instruction CreateBinaryInstruction( string mnemonic, OperationNode op, int exUnit, ValueNode vres, RegisterSet vresRegs, ValueNode v1, RegisterSet v1Regs, ValueNode v2, RegisterSet v2Regs) { InstructionPattern ip = new InstructionPattern(); ip.AddNode(op); ip.AddNode(vres); ip.AddNode(v1); ip.AddNode(v2); ip.AddEdge(op, vres); ip.AddEdge(v1, op); ip.AddEdge(v2, op); ip.OperandValues.Add(v1); ip.OperandValues.Add(v2); ip.ResultValue = vres; Instruction i = new Instruction(mnemonic, ip); i.ExecutionUnit = exUnit; i.ResultRegisters = vresRegs; i.OperandsRegisters[0] = v1Regs; i.OperandsRegisters[1] = v2Regs; return i; }
public FarmDataRoot(BlockNode.BLOCK_NAME block_name, BufferNode.BUFFER_NAME buffer_name) { Guid = Guid.NewGuid(); Block = new BlockNode(block_name); Buffer = new BufferNode(buffer_name); TempValueNode = new ValueNode(); }
public FarmDataRoot() { Guid = Guid.NewGuid(); Block = new BlockNode(); Buffer = new BufferNode(); TempValueNode = new ValueNode(); }
protected void CreateSingleLoop( ProgramGraph g, ValueNode ap, ValueNode bp, ValueNode s, ValueNode ap1, ValueNode bp1, ValueNode s1) { OperationNode[] o = new OperationNode[8]; o[0] = new AddOperationNode(); o[1] = new MulOperationNode(); o[2] = new LoadOperationNode(); o[3] = new AddOperationNode(); o[4] = new LoadOperationNode(); o[5] = new AddOperationNode(); o[6] = new ConstOperationNode(); o[7] = new ConstOperationNode(); foreach (OperationNode op in o) g.AddNode(op); ValueNode[] v = new ValueNode[7]; v[0] = new FloatRegisterNode(); v[1] = new FloatRegisterNode(); v[2] = new FloatRegisterNode(); v[3] = new IntRegisterNode(); v[4] = new IntRegisterNode(); v[5] = new IntConstantNode(4); v[6] = new IntConstantNode(4); foreach (ValueNode val in v) g.AddNode(val); g.AddEdge(v[0], o[0]); g.AddEdge(s, o[0]); g.AddEdge(o[0], s1); g.AddEdge(v[1], o[1]); g.AddEdge(v[2], o[1]); g.AddEdge(o[1], v[0]); g.AddEdge(ap, o[2]); g.AddEdge(o[2], v[1]); g.AddEdge(ap, o[3]); g.AddEdge(v[3], o[3]); g.AddEdge(o[3], ap1); g.AddEdge(bp, o[4]); g.AddEdge(o[4], v[2]); g.AddEdge(bp, o[5]); g.AddEdge(v[4], o[5]); g.AddEdge(o[5], bp1); g.AddEdge(v[5], o[6]); g.AddEdge(o[6], v[3]); g.AddEdge(v[6], o[7]); g.AddEdge(o[7], v[4]); }
public ProgramGraph CreateUnrolledProgramGraph(int k) { ProgramGraph g = new ProgramGraph(); ValueNode[] ap = new ValueNode[k + 1]; ValueNode[] bp = new ValueNode[k + 1]; ValueNode[] cp = new ValueNode[k + 1]; for (int i = 0; i < k + 1; i++) { ap[i] = new TestRegisterNode("a[" + i + "]", Datatype.AddressValue); bp[i] = new TestRegisterNode("b[" + i + "]", Datatype.AddressValue); cp[i] = new TestRegisterNode("c[" + i + "]", Datatype.AddressValue); g.AddNode(ap[i]); g.AddNode(bp[i]); g.AddNode(cp[i]); } ValueNode k0 = new TestRegisterNode("k0", Datatype.FloatValue); ValueNode k1 = new TestRegisterNode("k1", Datatype.FloatValue); g.AddNode(k0); g.AddNode(k1); for (int i = 0; i < k; i++) { CreateSingleLoop( g, ap[i], bp[i], cp[i], k0, k1, ap[i + 1], bp[i + 1], cp[i + 1]); } g.InitInputValues(); g.InitOutputValues(); g.OutputValues.Add(k0); g.OutputValues.Add(k1); g.CyclicDependencies[ap[0]] = ap[k]; g.CyclicDependencies[ap[k]] = ap[0]; g.CyclicDependencies[bp[0]] = bp[k]; g.CyclicDependencies[bp[k]] = bp[0]; g.CyclicDependencies[cp[0]] = cp[k]; g.CyclicDependencies[cp[k]] = cp[0]; return g; }
public void Setup() { _options = Options.Create(); _source = new ValueNode( new Context(_options, Mode.Deserialize, "object"), null, new SimpleValue(typeof(int?).ToCachedType()), null, null); _target = new Node("yada") { NodeType = NodeType.Value, Format = "xml", Type = "element" }; _writers = new WriterConventions(_options); _visitorIncrement = (s, t, o) => { should_have_valid_parameters(s, t, o); t.Value = t.Value == null ? 1 : (int?)t.Value + 1; }; _writerObjectIncrement = (v, s, t, o) => { should_have_valid_parameters(s, t, o); t.Value = (int?) t.Value + 1 ?? 1; }; _writerIncrement = (v, s, t, o) => { should_have_valid_parameters(s, t, o); t.Value = (int?) t.Value + 1 ?? 1; }; _writerNullableIncrement = (v, s, t, o) => { should_have_valid_parameters(s, t, o); t.Value = t.Value == null ? 1 : (int?)t.Value + 1; }; _writerIncrementValue = (v, s, t, o) => { should_have_valid_parameters(s, t, o); return v + 1; }; _writerIncrementNullableValue = (v, s, t, o) => { should_have_valid_parameters(s, t, o); return v == null ? 1 : v + 1; }; }
// Use this for initialization void Start() { Patch p = new Patch(); ValueNode<float> v1 = new ValueNode<float>(); p.AddNode(v1); v1.Output.Value = 15; v2 = new ValueNode<float>(); p.AddNode(v2); AddNode sum = new AddNode(); p.AddNode(sum); p.Connect(v1.Output, sum.A); p.Connect(v2.Output, sum.B); patchEvaluator = new PatchEvaluator(p); patchEvaluator.Evaluate(); }
public static Instruction CreateLeftTernaryInstruction( string mnemonic, OperationNode op1, OperationNode op2, int exUnit, ValueNode vres, RegisterSet vresRegs, ValueNode v1, RegisterSet v1Regs, ValueNode v2, RegisterSet v2Regs, ValueNode v3, RegisterSet v3Regs) { InstructionPattern ip = new InstructionPattern(); ip.AddNode(op1); ip.AddNode(op2); ip.AddNode(vres); ip.AddNode(v1); ip.AddNode(v2); ip.AddNode(v3); ValueNode iv1 = new RegisterValueNode(v1.Datatype); ip.AddNode(iv1); ip.AddEdge(v1, op1); ip.AddEdge(v2, op1); ip.AddEdge(op1, iv1); ip.AddEdge(iv1, op2); ip.AddEdge(v3, op2); ip.AddEdge(op2, vres); ip.OperandValues.Add(v1); ip.OperandValues.Add(v2); ip.OperandValues.Add(v3); ip.ResultValue = vres; Instruction i = new Instruction(mnemonic, ip); i.ExecutionUnit = exUnit; i.ResultRegisters = vresRegs; i.OperandsRegisters[0] = v1Regs; i.OperandsRegisters[1] = v2Regs; i.OperandsRegisters[2] = v3Regs; return i; }
private void DoCalculateData() { _ratingsByUser = _commonData.AllRatings.ToLookup(key => key.User); var variance = new List<Tuple<KeyNode, ValueNode>>(); foreach (var combo in GetAllTwoMovieCombinations()) { var valuesForKeyByMovie3 = GetAllKeyedValues(combo).ToLookup(key => key.Movie3); foreach (var v in valuesForKeyByMovie3) { double score1 = v.Average(x => x.Rating1); double score2 = v.Average(x => x.Rating2); double score3 = v.Average(x => x.Rating3); var meanValueNode = new ValueNode(score1, score2, v.Key, score3); variance.Add(Tuple.Create(combo, meanValueNode)); } } _variance = variance.ToLookup(key => key.Item1, val => val.Item2); }
public ProgramGraph CreateUnrolledProgramGraph(int k) { ProgramGraph g = new ProgramGraph(); ValueNode[] ap = new ValueNode[k + 1]; ValueNode[] bp = new ValueNode[k + 1]; ValueNode[] s = new ValueNode[k + 1]; for (int i = 0; i < k + 1; i++) { ap[i] = new TestRegisterNode("a[" + i + "]", Datatype.AddressValue); bp[i] = new TestRegisterNode("b[" + i + "]", Datatype.AddressValue); s[i] = new TestRegisterNode("s[" + i + "]", Datatype.FloatValue); g.AddNode(ap[i]); g.AddNode(bp[i]); g.AddNode(s[i]); } for (int i = 0; i < k; i++) CreateSingleLoop( g, ap[i], bp[i], s[i], ap[i + 1], bp[i + 1], s[i + 1]); }
public void SetUp() { nodeList = new MasterNodeList<string>(); vn = nodeList.newValueNodeFromValue("A"); vn2 = nodeList.newValueNodeFromValue("B"); vn3 = nodeList.newValueNodeFromValue("C"); edge = new Edge() { link = new DirectedPair() { from = vn, to = vn2 } }; edge2 = new Edge() { link = new DirectedPair() { from = vn3, to = vn } }; routeFactory = new RouteFactory<string>(); routeFactory.newRouteFromEdge(edge); }
public void should_add_value_reader_and_fail_read_with_value_reader_exception_when_friendly_error_does_not_exist() { _source.Value = 0; var target = new ValueNode( new Context(_options, Mode.Deserialize, "json"), null, new SimpleValue(typeof(Tuple<string>).ToCachedType()), null, null); var exception = new Exception(); _readers.AddValueReader<Tuple<string>>((v, s, t, o) => { throw exception; }, (v, s, t, o) => true); Assert.DoesNotThrow(() => _readers.Mapping.HasMapping(_source, target)); Assert.Throws<ReaderException>(() => _readers .Mapping.Map(_source, target)) .InnerException.ShouldBeSameAs(exception); }
public void Visit(ElementNode node, INode parentNode) { var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node)); TypeDefinition typedef = typeref.ResolveCached(); if (IsXaml2009LanguagePrimitive(node)) { var vardef = new VariableDefinition(typeref); Context.Variables [node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(PushValueFromLanguagePrimitive(typedef, node)); Context.IL.Emit(OpCodes.Stloc, vardef); return; } //if this is a MarkupExtension that can be compiled directly, compile and returns the value var compiledMarkupExtensionName = typeref.GetCustomAttribute(Module.ImportReferenceCached(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?[0].Value as string; Type compiledMarkupExtensionType; ICompiledMarkupExtension markupProvider; if (compiledMarkupExtensionName != null && (compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null && (markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null) { var il = markupProvider.ProvideValue(node, Module, Context, out typeref); typeref = Module.ImportReference(typeref); var vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(il); Context.IL.Emit(OpCodes.Stloc, vardef); //clean the node as it has been fully exhausted foreach (var prop in node.Properties) { if (!node.SkipProperties.Contains(prop.Key)) { node.SkipProperties.Add(prop.Key); } } node.CollectionItems.Clear(); return; } MethodDefinition factoryCtorInfo = null; MethodDefinition factoryMethodInfo = null; MethodDefinition parameterizedCtorInfo = null; MethodDefinition ctorInfo = null; if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod)) { factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.HasParameters && md.MatchXArguments(node, typeref, Module, Context)); if (factoryCtorInfo == null) { throw new XamlParseException( string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node); } ctorInfo = factoryCtorInfo; if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params { Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node)); } } else if (node.Properties.ContainsKey(XmlName.xFactoryMethod)) { var factoryMethod = (string)(node.Properties [XmlName.xFactoryMethod] as ValueNode).Value; factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor && md.Name == factoryMethod && md.IsStatic && md.MatchXArguments(node, typeref, Module, Context)); if (factoryMethodInfo == null) { throw new XamlParseException( String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node); } Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node)); } if (ctorInfo == null && factoryMethodInfo == null) { parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.HasParameters && md.Parameters.All( pd => pd.CustomAttributes.Any( ca => ca.AttributeType.FullName == "Xamarin.Forms.ParameterAttribute"))); } if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node)) { ctorInfo = parameterizedCtorInfo; // IL_0000: ldstr "foo" Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node)); } ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic); var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module); var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module); var implicitOperatorref = typedef.Methods.FirstOrDefault(md => md.IsPublic && md.IsStatic && md.IsSpecialName && md.Name == "op_Implicit" && md.Parameters [0].ParameterType.FullName == "System.String"); if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType) { VariableDefinition vardef = new VariableDefinition(typeref); Context.Variables [node] = vardef; Context.Body.Variables.Add(vardef); ValueNode vnode = null; if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && vardef.VariableType.IsValueType) { //<Color>Purple</Color> Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider [] { typedef }, node.PushServiceProvider(Context), false, true)); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && implicitOperatorref != null) { //<FileImageSource>path.png</FileImageSource> var implicitOperator = Module.ImportReference(implicitOperatorref); Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string); Context.IL.Emit(OpCodes.Call, implicitOperator); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (factorymethodinforef != null) { Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef)); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (!typedef.IsValueType) { var ctor = Module.ImportReference(ctorinforef); // IL_0001: newobj instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::'.ctor'() // IL_0006: stloc.0 Context.IL.Emit(OpCodes.Newobj, ctor); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context)) { // IL_0008: ldloca.s 1 // IL_000a: ldc.i4.1 // IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool) var ctor = Module.ImportReference(ctorinforef); Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node)); Context.IL.Emit(OpCodes.Call, ctor); } else { // IL_0000: ldloca.s 0 // IL_0002: initobj Test/Foo Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef)); } if (typeref.FullName == "Xamarin.Forms.Xaml.ArrayExtension") { var visitor = new SetPropertiesVisitor(Context); foreach (var cnode in node.Properties.Values.ToList()) { cnode.Accept(visitor, node); } foreach (var cnode in node.CollectionItems) { cnode.Accept(visitor, node); } markupProvider = new ArrayExtension(); var il = markupProvider.ProvideValue(node, Module, Context, out typeref); vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(il); Context.IL.Emit(OpCodes.Stloc, vardef); //clean the node as it has been fully exhausted foreach (var prop in node.Properties) { if (!node.SkipProperties.Contains(prop.Key)) { node.SkipProperties.Add(prop.Key); } } node.CollectionItems.Clear(); return; } } }
protected void CreateSingleLoop( ProgramGraph g, ValueNode ap, ValueNode bp, ValueNode cp, ValueNode k0, ValueNode k1, ValueNode ap1, ValueNode bp1, ValueNode cp1) { OperationNode[] o = new OperationNode[12]; o[0] = new AddOperationNode(); o[1] = new MulOperationNode(); o[2] = new MulOperationNode(); o[3] = new LoadOperationNode(); o[4] = new AddOperationNode(); o[5] = new LoadOperationNode(); o[6] = new AddOperationNode(); o[7] = new ConstOperationNode(); o[8] = new ConstOperationNode(); o[9] = new StoreOperationNode(); o[10] = new AddOperationNode(); o[11] = new ConstOperationNode(); foreach (OperationNode op in o) g.AddNode(op); ValueNode[] v = new ValueNode[12]; v[0] = new FloatRegisterNode(); v[1] = new FloatRegisterNode(); v[2] = new FloatRegisterNode(); v[3] = new FloatRegisterNode(); v[4] = new IntRegisterNode(); v[5] = new IntRegisterNode(); v[6] = new IntConstantNode(4); v[7] = new IntConstantNode(4); v[8] = new FloatRegisterNode(); v[9] = new FloatMemoryNode(null); v[10] = new IntRegisterNode(); v[11] = new IntConstantNode(4); foreach (ValueNode val in v) g.AddNode(val); g.AddEdge(v[0], o[0]); g.AddEdge(v[1], o[0]); g.AddEdge(o[0], v[8]); g.AddEdge(v[2], o[1]); g.AddEdge(k0, o[1]); g.AddEdge(o[1], v[0]); g.AddEdge(v[3], o[2]); g.AddEdge(k1, o[2]); g.AddEdge(o[2], v[1]); g.AddEdge(ap, o[3]); g.AddEdge(o[3], v[2]); g.AddEdge(ap, o[4]); g.AddEdge(v[4], o[4]); g.AddEdge(o[4], ap1); g.AddEdge(bp, o[5]); g.AddEdge(o[5], v[3]); g.AddEdge(bp, o[6]); g.AddEdge(v[5], o[6]); g.AddEdge(o[6], bp1); g.AddEdge(v[6], o[7]); g.AddEdge(o[7], v[4]); g.AddEdge(v[7], o[8]); g.AddEdge(o[8], v[5]); g.AddEdge(v[8], o[9]); g.AddEdge(cp, o[9]); g.AddEdge(o[9], v[9]); g.AddEdge(cp, o[10]); g.AddEdge(v[10], o[10]); g.AddEdge(o[10], cp1); g.AddEdge(v[11], o[11]); g.AddEdge(o[11], v[10]); }
public ValueNode(ValueNode node) { Value = node.Value; Name = Value.ToString(); }
public override ValueNode CreateSerializerOverride(ValueNode parent) { return(new UnknownValueNode(parent, Name, this)); }
public ProgramGraph CreateUnrolledProgramGraph(int k) { ProgramGraph g = new ProgramGraph(); ValueNode[] px = new ValueNode[k + 1]; ValueNode[] py = new ValueNode[k + 1]; for (int i = 0; i < k + 1; i++) { px[i] = new TestRegisterNode("x[" + i + "]", Datatype.AddressValue); py[i] = new TestRegisterNode("y[" + i + "]", Datatype.AddressValue); g.AddNode(px[i]); g.AddNode(py[i]); } ValueNode[] x = new ValueNode[k]; ValueNode[] y = new ValueNode[k]; for (int i = 0; i < k; i++) { x[i] = new FloatRegisterNode(); y[i] = new FloatRegisterNode(); g.AddNode(x[i]); g.AddNode(y[i]); } ValueNode[] x0 = new ValueNode[k + 1]; ValueNode[] x1 = new ValueNode[k + 1]; for (int i = 0; i < k + 1; i++) { x0[i] = new TestRegisterNode("x0[" + i + "]", Datatype.FloatValue); x1[i] = new TestRegisterNode("x1[" + i + "]", Datatype.FloatValue); g.AddNode(x0[i]); g.AddNode(x1[i]); } ValueNode pc0 = new FloatMemoryNode("c0"); ValueNode pc1 = new FloatMemoryNode("c1"); ValueNode pc2 = new FloatMemoryNode("c2"); ValueNode pc3 = new FloatMemoryNode("c3"); ValueNode pc4 = new FloatMemoryNode("c4"); OperationNode lc0 = new LoadOperationNode(); OperationNode lc1 = new LoadOperationNode(); OperationNode lc2 = new LoadOperationNode(); OperationNode lc3 = new LoadOperationNode(); OperationNode lc4 = new LoadOperationNode(); ValueNode c0 = new FloatRegisterNode(); ValueNode c1 = new FloatRegisterNode(); ValueNode c2 = new FloatRegisterNode(); ValueNode c3 = new FloatRegisterNode(); ValueNode c4 = new FloatRegisterNode(); g.AddNode(pc0); g.AddNode(pc1); g.AddNode(pc2); g.AddNode(pc3); g.AddNode(pc4); g.AddNode(lc0); g.AddNode(lc1); g.AddNode(lc2); g.AddNode(lc3); g.AddNode(lc4); g.AddNode(c0); g.AddNode(c1); g.AddNode(c2); g.AddNode(c3); g.AddNode(c4); g.AddEdge(pc0, lc0); g.AddEdge(lc0, c0); g.AddEdge(pc1, lc1); g.AddEdge(lc1, c1); g.AddEdge(pc2, lc2); g.AddEdge(lc2, c2); g.AddEdge(pc3, lc3); g.AddEdge(lc3, c3); g.AddEdge(pc4, lc4); g.AddEdge(lc4, c4); for (int i = 0; i < k; i++) { CreateLoadIncGraph( g, x[i], px[i], px[i + 1], 4); CreateStoreIncGraph( g, y[i], py[i], py[i + 1], 4); CreateSingleFilterLoop( g, x[i], x0[i], x1[i], c0, c1, c2, c3, c4, x0[i + 1], x1[i + 1], y[i]); } g.InitInputValues(); g.InitOutputValues(); g.CyclicDependencies[x0[0]] = x0[k]; g.CyclicDependencies[x0[k]] = x0[0]; g.CyclicDependencies[x1[0]] = x1[k]; g.CyclicDependencies[x1[k]] = x1[0]; g.CyclicDependencies[px[0]] = px[k]; g.CyclicDependencies[px[k]] = px[0]; g.CyclicDependencies[py[0]] = py[k]; g.CyclicDependencies[py[k]] = py[0]; return g; }
protected void CreateSingleLoop( ProgramGraph g, ValueNode xp, ValueNode yp, ValueNode x, ValueNode y, ValueNode c0, ValueNode c1, ValueNode c2, ValueNode xp1, ValueNode yp1, ValueNode x1, ValueNode y1) { OperationNode[] o = new OperationNode[11]; o[0] = new StoreOperationNode(); o[1] = new AddOperationNode(); o[2] = new AddOperationNode(); o[3] = new ConstOperationNode(); o[4] = new AddOperationNode(); o[5] = new MulOperationNode(); o[6] = new MulOperationNode(); o[7] = new MulOperationNode(); o[8] = new LoadOperationNode(); o[9] = new AddOperationNode(); o[10] = new ConstOperationNode(); foreach (OperationNode op in o) g.AddNode(op); ValueNode[] v = new ValueNode[9]; v[0] = new FloatMemoryNode(null); v[1] = new IntRegisterNode(); v[2] = new FloatRegisterNode(); v[3] = new FloatRegisterNode(); v[4] = new IntConstantNode(4); v[5] = new FloatRegisterNode(); v[6] = new FloatRegisterNode(); v[7] = new IntRegisterNode(); v[8] = new IntConstantNode(4); foreach (ValueNode val in v) g.AddNode(val); g.AddEdge(y1, o[0]); g.AddEdge(yp, o[0]); g.AddEdge(o[0], v[0]); g.AddEdge(yp, o[1]); g.AddEdge(v[1], o[1]); g.AddEdge(o[1], yp1); g.AddEdge(v[2], o[2]); g.AddEdge(v[3], o[2]); g.AddEdge(o[2], y1); g.AddEdge(v[4], o[3]); g.AddEdge(o[3], v[1]); g.AddEdge(v[5], o[4]); g.AddEdge(v[6], o[4]); g.AddEdge(o[4], v[2]); g.AddEdge(c2, o[5]); g.AddEdge(y, o[5]); g.AddEdge(o[5], v[3]); g.AddEdge(c1, o[6]); g.AddEdge(x, o[6]); g.AddEdge(o[6], v[5]); g.AddEdge(c0, o[7]); g.AddEdge(x1, o[7]); g.AddEdge(o[7], v[6]); g.AddEdge(xp, o[8]); g.AddEdge(o[8], x1); g.AddEdge(xp, o[9]); g.AddEdge(v[7], o[9]); g.AddEdge(o[9], xp1); g.AddEdge(v[8], o[10]); g.AddEdge(o[10], v[7]); }
public object GetBoundValue(ValueNode target) { return(GetValue(binding => binding.GetBoundValue(target))); }
public void WriteName(ITextColorWriter output, ValueNode vm) => vm.CachedName.WriteTo(output);
public void CreateValueNode() { ValueNode field = factory.CreateValueNode("Value", ValueNodeType.Text); Assert.IsNotNull(field); }
public void CreateValueNode_FromString() { ValueNode field = factory.CreateValueNode("Value", "Text"); Assert.IsNotNull(field); }
private static TomlObject ToTomlValue(ITomlRoot root, ValueNode node) { switch (node.Value.SyntaxNode()) { case TerminalNode tn: return(CreateValueFromTerminal(tn.Terminal)); case ArrayNode an: return(CreateArrayOrTableArray(an)); case InlineTableNode it: return(CreateInlineTable(it)); default: throw new Exception($"Cannot create TomlValue from node with type '{node.GetType()}'."); } TomlValue CreateValueFromTerminal(Token terminal) { switch (terminal.Type) { case TokenType.Integer: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 0)), TomlInt.IntTypes.Decimal)); case TokenType.HexInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 16), TomlInt.IntTypes.Hex)); case TokenType.BinaryInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 2), TomlInt.IntTypes.Binary)); case TokenType.OctalInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 8), TomlInt.IntTypes.Octal)); case TokenType.Bool: return(new TomlBool(root, Convert.ToBoolean(terminal.Value))); case TokenType.String: return(new TomlString(root, terminal.Value.Unescape(terminal))); case TokenType.LiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Literal)); case TokenType.MultilineLiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.MultilineLiteral)); case TokenType.MultilineString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Multiline)); case TokenType.Float: return(TomlFloat.FromTerminal(root, terminal)); case TokenType.OffsetDateTime: return(TomlOffsetDateTime.Parse(root, terminal.Value)); case TokenType.LocalTime: return(TomlLocalTime.Parse(root, terminal.Value)); case TokenType.Duration: return(TomlDuration.Parse(root, terminal.Value)); case TokenType.LocalDate: return(TomlLocalDate.Parse(root, terminal.Value)); case TokenType.LocalDateTime: return(TomlLocalDateTime.Parse(root, terminal.Value)); default: throw new NotSupportedException(); } string Cleanup(string s, int sub) => s.Substring(sub).Replace("_", string.Empty); } TomlObject CreateArrayOrTableArray(ArrayNode array) { var values = CreateValues(array.GetValues()).ToList(); var tables = values.OfType <TomlTable>().ToList(); if (tables.Count > 0 && tables.Count == values.Count) { var ta = new TomlTableArray(root, tables); ta.AddComments(array); return(ta); } else if (tables.Count == 0) { var arr = new TomlArray(root, values.Cast <TomlValue>().ToArray()); arr.AddComments(array); return(arr); } else { throw new InvalidOperationException("Array is a mixture of a value array and a TOML table array."); } IEnumerable <TomlObject> CreateValues(IEnumerable <ValueNode> nodes) { var linked = nodes.Select(n => Tuple.Create(n, ToTomlValue(root, n))).ToList(); var expectedType = linked.DistinctBy(n => n.Item2.GetType()).FirstOrDefault(); var wrongType = linked.DistinctBy(n => n.Item2.GetType()).Skip(1).FirstOrDefault(); if (wrongType != null) { string msg = $"Expected array value of type '{expectedType.Item2.ReadableTypeName}' " + $"but value of type '{wrongType.Item2.ReadableTypeName}' was found.'"; throw ParseException.MessageForNode(wrongType.Item1, msg); } return(linked.Select(l => l.Item2)); } } TomlTable CreateInlineTable(InlineTableNode it) { TomlTable table = new TomlTable(root, TomlTable.TableTypes.Inline); table.AddComments(it); System.Collections.Generic.IEnumerable <KeyValueExpressionNode> expressions = it.GetExpressions(); foreach (KeyValueExpressionNode e in expressions) { table.AddRow(e.Key.SyntaxNode().ExpressionKey(), ToTomlValue(root, e.Value.SyntaxNode())); } return(table); } }
public static void UnbundleEvent(Node node) { EventNode eNode = node.Control as EventNode; List <Relation> deleteRels = new List <Relation>(); //relations to delete List <Node> updateValues = new List <Node>(); //value nodes to update List <KeyValuePair <Node, Anchor> > extendRelations = new List <KeyValuePair <Node, Anchor> >(); //relations to extend foreach (Relation rel in relations) { if (rel.Parent == node || rel.Child == node) { deleteRels.Add(rel); if (rel.Parent == node && rel.Child.Type == NodeType.Value) { updateValues.Add(rel.Child); } if (rel.Child == node && rel.Parent.Type == NodeType.Event) { extendRelations.Add(new KeyValuePair <Node, Anchor>(rel.Parent, rel.ParentAnchor)); } } } if (extendRelations.Count > 0) //if any relations has to be extended { Node[] extendedParents = ExtendedParents(node); foreach (Node vNode in updateValues) { ValueOutcome[] oldOutcomes = (vNode.Control as ValueNode).Outcomes; //values before unbundling ValueOutcome[] newOutcomes = NewOutcomes(vNode, node, extendedParents); //new values after unbundling foreach (ValueOutcome newOutc in newOutcomes) { List <ValueOutcome> relevantOlds = new List <ValueOutcome>(); foreach (ValueOutcome oldOutc in oldOutcomes) // find relevant outcomes out of old ones { if (IsRelevant(newOutc, oldOutc) && oldOutc.Factors.Intersect(newOutc.Factors).Any()) //check if value doesnt negate itself and if factors align { relevantOlds.Add(oldOutc); } } double newValue = 0; foreach (ValueOutcome relevant in relevantOlds) { foreach (Probability prob in eNode.Probabilities) { //probability has any common factors with old relevant outcome and new outcome. It must not negate any of it if (relevant.Factors.Intersect(prob.Factors).Any() && newOutc.Factors.Intersect(prob.Factors).Any() && IsRelevant(prob, relevant)) { newValue += relevant.Value * prob.Value; } } } newOutc.Value = newValue; } (vNode.Control as ValueNode).Outcomes = newOutcomes; //assing new values to tha respective value node (vNode.OutcomeControl as PropertyValue).UpdateOutcomes(); //update UI foreach (KeyValuePair <Node, Anchor> newParent in extendRelations) { new Relation(newParent.Key, newParent.Value, vNode, vNode.TopAnchor, false); //create new extended relation } } } foreach (Relation rel in deleteRels) //delete all previous relations { RemoveRelation(rel); } if (extendRelations.Count == 0) //if no realtions have to be extended { foreach (Node value in updateValues) { ValueNode vNode = value.Control as ValueNode; ValueOutcome[] oldOutc = vNode.Outcomes; vNode.UpdateOutcomes(); // have value node produce new outcomes based on parents foreach (ValueOutcome newOutc in vNode.Outcomes) //go trough every new outcome end find relevant outcomes amongst old ones { List <ValueOutcome> relevantOutc = new List <ValueOutcome>(); foreach (ValueOutcome oldc in oldOutc) { if (IsRelevant(newOutc, oldc) && newOutc.Factors.Intersect(oldc.Factors).Any()) { relevantOutc.Add(oldc); } } double newValue = 0; foreach (ValueOutcome relevantOut in relevantOutc) { foreach (Probability prob in eNode.Probabilities) { //probability must not negate old relevant outcomes and needs to have common factors if (IsRelevant(prob, relevantOut) && prob.Factors.Intersect(relevantOut.Factors).Any()) { newValue += (prob.Value * relevantOut.Value); } } } newOutc.Value = newValue; } (value.OutcomeControl as PropertyValue).UpdateOutcomes(); //update UI foreach (KeyValuePair <Node, Anchor> newParent in extendRelations) //quite unnecessary { new Relation(newParent.Key, newParent.Value, value, value.TopAnchor, false); } } } RemoveNode(node); MainWindow.GetCanvas.Children.Remove(node.Control); //remove nodes MainWindow.GetCanvas.Children.Remove(node.DefinitionControl); MainWindow.GetCanvas.Children.Remove(node.ProbabilityControl); CheckCorrectness(); //check if any nodes doesnt have outgoing relations and delete it RefreshCalculator(); //refresh probability set }
public static void UnbundleDecision(Node node) { List <Relation> deleteRels = new List <Relation>(); //relations to delete List <Node> updateValues = new List <Node>(); //value nodes to update List <Node> extendRelations = new List <Node>(); //unnecessary, since no relation will extend foreach (Relation rel in relations) { if (rel.Parent == node || rel.Child == node) { deleteRels.Add(rel); if (rel.Parent == node && rel.Child.Type == NodeType.Value) { updateValues.Add(rel.Child); } if (rel.Child == node) { extendRelations.Add(rel.Parent); } } } foreach (Relation rel in deleteRels) //remove relations { RemoveRelation(rel); } foreach (Node value in updateValues) { ValueNode vNode = value.Control as ValueNode; ValueOutcome[] oldOutcomes = vNode.Outcomes; //save old outcomes vNode.UpdateOutcomes(); //have value node update its outcomes string bestDecision = ""; //keep track of nodes best decision foreach (ValueOutcome outc in vNode.Outcomes) //find relevant old outcomes { List <ValueOutcome> relevant = new List <ValueOutcome>(); foreach (ValueOutcome olds in oldOutcomes) { //when unbundling decision, old outcome has to be a superset to new outcome to be relevant if (!outc.Factors.Except(olds.Factors).Any()) { relevant.Add(olds); } } double bestValue = Double.NaN; foreach (ValueOutcome olds in relevant) { //find new best value and decision based on min/max rule if (vNode.Better == "max") { if (Double.IsNaN(bestValue) || olds.Value > bestValue) { bestValue = olds.Value; bestDecision = (olds.Factors.Intersect(node.Definitions).ToArray().First() as string) + " - " + node.Name; } } else if (vNode.Better == "min") { if (Double.IsNaN(bestValue) || olds.Value < bestValue) { bestValue = olds.Value; bestDecision = (olds.Factors.Intersect(node.Definitions).ToArray().First() as string) + " - " + node.Name; } } } outc.Value = bestValue; } (value.Control as ValueNode).BestDecisions = (value.Control as ValueNode).BestDecisions.Concat(new string[] { bestDecision }).ToArray(); //save best decision (value.OutcomeControl as PropertyValue).UpdateOutcomes(); // update UI } RemoveNode(node); //remove node MainWindow.GetCanvas.Children.Remove(node.Control); MainWindow.GetCanvas.Children.Remove(node.DefinitionControl); }
public Operation(FieldNode field, ValueNode valueNode) : base(field, valueNode) { }
public void WriteValueAndObjectId(ITextColorWriter output, ValueNode vm, out bool textChanged) { WriteValue(output, vm, out textChanged); WriteObjectId(output, vm); }
/// <summary> /// Initializes a new instance of the <see cref="ValueNodeTest"/> class. /// </summary> public ValueNodeTest() { this._valueNode = new ValueNode <int>(ParameterNodeTest.Identifier, new IntegerDomain()); }
public void WriteValue(ITextColorWriter output, ValueNode vm, out bool textChanged) { vm.CachedValue.WriteTo(output); textChanged = !vm.OldCachedValue.IsDefault && !vm.OldCachedValue.Equals(vm.CachedValue); }
protected void CreateStoreIncGraph( OperationValueGraph g, ValueNode x, ValueNode p, ValueNode pi, int inc) { OperationNode storeOp = new StoreOperationNode(); OperationNode addOp = new AddOperationNode(); OperationNode constOp = new ConstOperationNode(); g.AddNode(storeOp); g.AddNode(addOp); g.AddNode(constOp); ValueNode m = new MemoryValueNode(x.Datatype, null); g.AddNode(m); ValueNode t = new IntRegisterNode(); ValueNode i = new IntConstantNode(inc); g.AddNode(t); g.AddNode(i); g.AddEdge(x, storeOp); g.AddEdge(p, storeOp); g.AddEdge(storeOp, m); g.AddEdge(p, addOp); g.AddEdge(i, constOp); g.AddEdge(constOp, t); g.AddEdge(t, addOp); g.AddEdge(addOp, pi); }
public ValueValueNode(ValueNode parent, string name, TypeNode typeNode) : base(parent, name, typeNode) { }
private void ProcessScope(ScssPackage package, ScopeNode scope, CssRoot root, CssSelector selector, int level, string nspace = "") { if (scope is SelectorNode) { var snode = (SelectorNode) scope; var s = snode.Selector.Resolve(scope); if (selector != null) { s = ExpandSelector(selector.Selector, s); } selector = new CssSelector(s, level); root.Add(selector); } foreach (var node in scope.Nodes) { var useNode = node; if (node is PropertyNode) { var n = (PropertyNode) node; var value = n.Expression.Resolve(scope).Value; selector.Add(new CssProperty(nspace + n.Name.Resolve(scope), value, level + 1)); } else if (node is MediaNode) { var n = (MediaNode) node; var s = new CssMedia(level + 1) { Definition = n.Definition }; root.Add(s); int nextLevel = level + 1; if (selector != null) { selector = new CssSelector(selector.Selector, level + 2); s.Add(selector); nextLevel++; } ProcessScope(package, (ScopeNode) n, s, selector, nextLevel, nspace); } else if (node is CommentNode) { var n = (CommentNode) node; CssNode p = root; if (selector != null) p = selector; p.Add(new CssComment(n.Comment, level + 1)); } else if (node is ImportNode) { var n = (ImportNode) node; if (n.Path.Contains(".css") || n.Path.Contains("http://") || n.Path.Contains("url(") || n.Path.Contains(" ")) { root.Add(new CssImport(n.Path, level + 1)); } else { var path = n.Path.Trim('\"'); ProcessImport(path, package, scope, root, selector, level, nspace); } } else if (node is VariableNode) { var n = (VariableNode) node; scope.SetVariable(n); } else if (node is MixinNode) { var n = (MixinNode) node; scope.SetMixin(n); } else if (node is ContentNode) { var sn = scope.GetContent(); ProcessScope(package, sn, root, selector, level - 1, nspace); } else if (node is IfNode) { var n = (IfNode) node; var sn = n.GetActiveScope(scope); if (sn != null) ProcessScope(package, sn, root, selector, level, nspace); } else if (node is EachNode) { var n = (EachNode) node; var var = n.Variables; foreach (var value in n.List) { if (var.Count == 1) { var[0].Expression = new Expression(value); n.SetVariable(var[0]); } else { if (!(value is ValueList)) throw new Exception("This must be a list"); var subList = (ValueList) value; // There is a bug in the reader causing unecessary levels of value lists // TODO UNDONE if (subList.Count == 1) subList = (ValueList) subList[0]; for (int i = 0; i < var.Count; i++) { var[i].Expression = new Expression(subList[i]); n.SetVariable(var[i]); } } ProcessScope(package, n, root, selector, level, nspace); } } else if (node is ForNode) { var n = (ForNode) node; var var = n.Variable; int from = int.Parse(n.From.Resolve(scope).Value); int to = 0; string toStr = n.Through.Resolve(scope).Value; if (!int.TryParse(toStr, out to)) throw new Exception("Failed to parse to value"); for (int i = from; i <= to; i++) { var value = new ValueNode(i.ToString()); var.Expression = new Expression(value); n.SetVariable(var); ProcessScope(package, n, root, selector, level, nspace); } } else if (node is ExtendNode) { var n = (ExtendNode) node; package.AddExtension(new ScssExtension() { Selector = selector.Selector, Super = ((ExtendNode) node).Selector }); } else if (node is FunctionNode) { var n = (FunctionNode) node; scope.SetFunction(n); } else if (node is NamespaceNode) { var subLevel = level; var n = (NamespaceNode) node; string header = n.Header.Name.Resolve(scope); if (!n.Header.Expression.Empty) { var value = n.Header.Expression.Resolve(scope).Value; selector.Add(new CssProperty(header, value, level + 1)); subLevel++; } ProcessScope(package, (ScopeNode) node, root, selector, subLevel, header + "-"); } else if (node is IncludeNode) { var n = (IncludeNode) node; var mn = scope.GetMixin(n.MixinName); mn.Initialize(n); ProcessScope(package, mn, root, selector, level); } else if (useNode is SelectorNode) { ProcessScope(package, (ScopeNode) node, root, selector, level + 1); } } }
public static IEnumerable <Instruction> PushConvertedValue(this ValueNode node, ILContext context, TypeReference targetTypeRef, TypeReference typeConverter, IEnumerable <Instruction> pushServiceProvider, bool boxValueTypes, bool unboxValueTypes) { var module = context.Body.Method.Module; var str = (string)node.Value; //If the TypeConverter has a ProvideCompiledAttribute that can be resolved, shortcut this var compiledConverterName = typeConverter?.GetCustomAttribute(module, ("Xamarin.Forms.Core", "Xamarin.Forms.Xaml", "ProvideCompiledAttribute"))?.ConstructorArguments?.First().Value as string; Type compiledConverterType; if (compiledConverterName != null && (compiledConverterType = Type.GetType(compiledConverterName)) != null) { var compiledConverter = Activator.CreateInstance(compiledConverterType); var converter = typeof(ICompiledTypeConverter).GetMethods().FirstOrDefault(md => md.Name == "ConvertFromString"); IEnumerable <Instruction> instructions; try { instructions = (IEnumerable <Instruction>)converter.Invoke(compiledConverter, new object[] { node.Value as string, context, node as BaseNode }); } catch (System.Reflection.TargetInvocationException tie) when(tie.InnerException is XamlParseException) { throw tie.InnerException; } foreach (var i in instructions) { yield return(i); } if (targetTypeRef.IsValueType && boxValueTypes) { yield return(Instruction.Create(OpCodes.Box, module.ImportReference(targetTypeRef))); } yield break; } //If there's a [TypeConverter], use it if (typeConverter != null) { var isExtendedConverter = typeConverter.ImplementsInterface(module.ImportReference(("Xamarin.Forms.Core", "Xamarin.Forms", "IExtendedTypeConverter"))); var typeConverterCtorRef = module.ImportCtorReference(typeConverter, paramCount: 0); var convertFromInvariantStringDefinition = isExtendedConverter ? module.ImportReference(("Xamarin.Forms.Core", "Xamarin.Forms", "IExtendedTypeConverter")) .ResolveCached() .Methods.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 2) : typeConverter.ResolveCached() .AllMethods() .FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 1); var convertFromInvariantStringReference = module.ImportReference(convertFromInvariantStringDefinition); yield return(Instruction.Create(OpCodes.Newobj, typeConverterCtorRef)); yield return(Instruction.Create(OpCodes.Ldstr, node.Value as string)); if (isExtendedConverter) { foreach (var instruction in pushServiceProvider) { yield return(instruction); } } yield return(Instruction.Create(OpCodes.Callvirt, convertFromInvariantStringReference)); if (targetTypeRef.IsValueType && unboxValueTypes) { yield return(Instruction.Create(OpCodes.Unbox_Any, module.ImportReference(targetTypeRef))); } //ConvertFrom returns an object, no need to Box yield break; } var originalTypeRef = targetTypeRef; var isNullable = false; MethodReference nullableCtor = null; if (targetTypeRef.ResolveCached().FullName == "System.Nullable`1") { var nullableTypeRef = targetTypeRef; targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0]; isNullable = true; nullableCtor = originalTypeRef.GetMethods(md => md.IsConstructor && md.Parameters.Count == 1, module).Single().Item1; nullableCtor = nullableCtor.ResolveGenericParameters(nullableTypeRef, module); } var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module); //Obvious Built-in conversions if (targetTypeRef.ResolveCached().BaseType != null && targetTypeRef.ResolveCached().BaseType.FullName == "System.Enum") { yield return(PushParsedEnum(targetTypeRef, str, node)); } else if (targetTypeRef.FullName == "System.Char") { yield return(Instruction.Create(OpCodes.Ldc_I4, Char.Parse(str))); } else if (targetTypeRef.FullName == "System.SByte") { yield return(Instruction.Create(OpCodes.Ldc_I4, SByte.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Int16") { yield return(Instruction.Create(OpCodes.Ldc_I4, Int16.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Int32") { yield return(Instruction.Create(OpCodes.Ldc_I4, Int32.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Int64") { yield return(Instruction.Create(OpCodes.Ldc_I8, Int64.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Byte") { yield return(Instruction.Create(OpCodes.Ldc_I4, Byte.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.UInt16") { yield return(Instruction.Create(OpCodes.Ldc_I4, unchecked ((int)UInt16.Parse(str, CultureInfo.InvariantCulture)))); } else if (targetTypeRef.FullName == "System.UInt32") { yield return(Instruction.Create(OpCodes.Ldc_I4, unchecked ((int)UInt32.Parse(str, CultureInfo.InvariantCulture)))); } else if (targetTypeRef.FullName == "System.UInt64") { yield return(Instruction.Create(OpCodes.Ldc_I8, unchecked ((long)UInt64.Parse(str, CultureInfo.InvariantCulture)))); } else if (targetTypeRef.FullName == "System.Single") { yield return(Instruction.Create(OpCodes.Ldc_R4, Single.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Double") { yield return(Instruction.Create(OpCodes.Ldc_R8, Double.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Boolean") { if (Boolean.Parse(str)) { yield return(Instruction.Create(OpCodes.Ldc_I4_1)); } else { yield return(Instruction.Create(OpCodes.Ldc_I4_0)); } } else if (targetTypeRef.FullName == "System.TimeSpan") { var ts = TimeSpan.Parse(str, CultureInfo.InvariantCulture); var ticks = ts.Ticks; yield return(Instruction.Create(OpCodes.Ldc_I8, ticks)); yield return(Instruction.Create(OpCodes.Newobj, module.ImportCtorReference(("mscorlib", "System", "TimeSpan"), parameterTypes: new[] { ("mscorlib", "System", "Int64") })));
internal OpLess(FieldNode field, ValueNode valueNode) : base(field, valueNode) { }
private ResolveNodeBase InnerBuildResolveTree(Type interfaceType, ICollection <Type> discoveredTypes, List <IParameterValue> userDefinedParameters = null) { // Factory ? Func <object> factory; if (_factories.TryGetValue(interfaceType, out factory)) { return new FactoryNode { InterfaceType = interfaceType, Factory = factory } } ; // Instance ? object instance; if (_instances.TryGetValue(interfaceType, out instance)) { return new InstanceNode { InterfaceType = interfaceType, Instance = instance } } ; // Implementation ? Type implementationType; if (!_implementations.TryGetValue(interfaceType, out implementationType)) { return(ErrorNode.TypeNotRegistered); } ConstructorInfo[] constructorInfos = implementationType.GetConstructors(); // Valid constructor ? if (constructorInfos.Length == 0 || (constructorInfos.Length == 1 && !constructorInfos[0].IsPublic)) { return(ErrorNode.NoPublicConstructorOrNoConstructor); } // Get parameters for each ctor var constructorAndParameters = constructorInfos.Select(x => new { Constructor = x, Parameters = x.GetParameters() }).ToList(); // Get first parameterless if any var parameterless = constructorAndParameters.FirstOrDefault(x => x.Parameters.Length == 0); if (parameterless != null) { return new BuildableNode { InterfaceType = interfaceType, ConstructorInfo = parameterless.Constructor } } ; // Check if every ctor's parameter is registered in container or resolvable, returns first resolvable foreach (var c in constructorAndParameters) { List <ResolveNodeBase> parametersResolvable = new List <ResolveNodeBase>(c.Parameters.Length); // Try to resolved every parameters bool ok = true; foreach (ParameterInfo parameterInfo in c.Parameters) { IParameterValue parameterValue = userDefinedParameters?.FirstOrDefault(x => x.Name == parameterInfo.Name); if (parameterValue != null) { ValueNode parameter = new ValueNode { InterfaceType = null, ParameterValue = parameterValue }; parametersResolvable.Add(parameter); } else { if (discoveredTypes.Any(x => x == parameterInfo.ParameterType)) // check cyclic dependency { ok = false; break; } discoveredTypes.Add(parameterInfo.ParameterType); // add parameter type to discovered type ResolveNodeBase parameter = InnerBuildResolveTree(parameterInfo.ParameterType, discoveredTypes, userDefinedParameters); discoveredTypes.Remove(parameterInfo.ParameterType); // remove parameter type from discovered type if (parameter is ErrorNode) // once an invalid ctor parameter has been found, try next ctor { ok = false; break; } parametersResolvable.Add(parameter); } } if (ok) { return new BuildableNode { InterfaceType = interfaceType, ConstructorInfo = c.Constructor, Parameters = parametersResolvable } } ; } return(ErrorNode.NoResolvableConstructor); } #endregion } }
public void Visit(ValueNode node, INode parentNode) { Context.Values[node] = node.Value; }
internal OpBeginsWith(FieldNode field, ValueNode valueNode) : base(field, valueNode) { }
public static bool CanConvertValue(this ValueNode node, ILContext context, TypeReference targetTypeRef, TypeReference typeConverter) { var str = (string)node.Value; var module = context.Body.Method.Module; //If there's a [TypeConverter], use it if (typeConverter != null && str != null) { var typeConvAttribute = typeConverter.GetCustomAttribute(module, ("Xamarin.Forms.Core", "Xamarin.Forms.Xaml", "TypeConversionAttribute")); if (typeConvAttribute == null) //trust the unattributed TypeConverter { return(true); } var toType = typeConvAttribute.ConstructorArguments.First().Value as TypeReference; return(toType.InheritsFromOrImplements(targetTypeRef)); } //check if it's assignable from a string if (targetTypeRef.ResolveCached().FullName == "System.Nullable`1") { targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0]; } if (targetTypeRef.ResolveCached().BaseType != null && targetTypeRef.ResolveCached().BaseType.FullName == "System.Enum") { return(true); } if (targetTypeRef.FullName == "System.Char") { return(true); } if (targetTypeRef.FullName == "System.SByte") { return(true); } if (targetTypeRef.FullName == "System.Int16") { return(true); } if (targetTypeRef.FullName == "System.Int32") { return(true); } if (targetTypeRef.FullName == "System.Int64") { return(true); } if (targetTypeRef.FullName == "System.Byte") { return(true); } if (targetTypeRef.FullName == "System.UInt16") { return(true); } if (targetTypeRef.FullName == "System.UInt32") { return(true); } if (targetTypeRef.FullName == "System.UInt64") { return(true); } if (targetTypeRef.FullName == "System.Single") { return(true); } if (targetTypeRef.FullName == "System.Double") { return(true); } if (targetTypeRef.FullName == "System.Boolean") { return(true); } if (targetTypeRef.FullName == "System.TimeSpan") { return(true); } if (targetTypeRef.FullName == "System.DateTime") { return(true); } if (targetTypeRef.FullName == "System.String") { return(true); } if (targetTypeRef.FullName == "System.Object") { return(true); } if (targetTypeRef.FullName == "System.Decimal") { return(true); } var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module); if (implicitOperator != null) { return(true); } return(false); }
/// <summary>Evaluates whether the signal is zero (0).</summary> public static bool IsAdditiveIdentity(ValueNode signal) { if(signal == null) throw new ArgumentNullException("signal"); IAlgebraicAdditiveIdentityElement monoid = signal.Value as IAlgebraicAdditiveIdentityElement; return monoid != null && monoid.IsAdditiveIdentity; }
public void Visit(ElementNode node, INode parentNode) { var typeref = node.XmlType.GetTypeReference(Module, node); TypeDefinition typedef = typeref.Resolve(); if (IsXaml2009LanguagePrimitive(node)) { var vardef = new VariableDefinition(typeref); Context.Variables [node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(PushValueFromLanguagePrimitive(typedef, node)); Context.IL.Emit(OpCodes.Stloc, vardef); return; } if (typeref.FullName == "Xamarin.Forms.Xaml.StaticExtension") { var markupProvider = new StaticExtension(); var il = markupProvider.ProvideValue(node, Module, out typeref); var vardef = new VariableDefinition(typeref); Context.Variables [node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(il); Context.IL.Emit(OpCodes.Stloc, vardef); //clean the node as it has been fully exhausted node.Properties.Clear(); node.CollectionItems.Clear(); return; } MethodDefinition factoryCtorInfo = null; MethodDefinition factoryMethodInfo = null; MethodDefinition parameterizedCtorInfo = null; MethodDefinition ctorInfo = null; if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod)) { factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.HasParameters && md.MatchXArguments(node, Module, Context)); if (factoryCtorInfo == null) { throw new XamlParseException( string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node); } ctorInfo = factoryCtorInfo; if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params { Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node)); } } else if (node.Properties.ContainsKey(XmlName.xFactoryMethod)) { var factoryMethod = (string)(node.Properties [XmlName.xFactoryMethod] as ValueNode).Value; factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor && md.Name == factoryMethod && md.IsStatic && md.MatchXArguments(node, Module, Context)); if (factoryMethodInfo == null) { throw new XamlParseException( String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node); } Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node)); } if (ctorInfo == null && factoryMethodInfo == null) { parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.HasParameters && md.Parameters.All( pd => pd.CustomAttributes.Any( ca => ca.AttributeType.FullName == "Xamarin.Forms.ParameterAttribute"))); } if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node)) { ctorInfo = parameterizedCtorInfo; // IL_0000: ldstr "foo" Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node)); } ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic); var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module); var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module); var implicitOperatorref = typedef.Methods.FirstOrDefault(md => md.IsPublic && md.IsStatic && md.IsSpecialName && md.Name == "op_Implicit" && md.Parameters [0].ParameterType.FullName == "System.String"); if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType) { VariableDefinition vardef = new VariableDefinition(typeref); Context.Variables [node] = vardef; Context.Body.Variables.Add(vardef); ValueNode vnode = null; if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && vardef.VariableType.IsValueType) { //<Color>Purple</Color> Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider [] { typedef }, node.PushServiceProvider(Context), false, true)); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && implicitOperatorref != null) { //<FileImageSource>path.png</FileImageSource> var implicitOperator = Module.Import(implicitOperatorref); Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string); Context.IL.Emit(OpCodes.Call, implicitOperator); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (factorymethodinforef != null) { var factory = Module.Import(factorymethodinforef); Context.IL.Emit(OpCodes.Call, factory); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (!typedef.IsValueType) { var ctor = Module.Import(ctorinforef); // IL_0001: newobj instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::'.ctor'() // IL_0006: stloc.0 Context.IL.Emit(OpCodes.Newobj, ctor); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, Module, Context)) { // IL_0008: ldloca.s 1 // IL_000a: ldc.i4.1 // IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool) var ctor = Module.Import(ctorinforef); Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node)); Context.IL.Emit(OpCodes.Call, ctor); } else { // IL_0000: ldloca.s 0 // IL_0002: initobj Test/Foo Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Emit(OpCodes.Initobj, Module.Import(typedef)); } //if/when we land the compiled converters, those 2 blocks could be greatly simplified if (typeref.FullName == "Xamarin.Forms.Xaml.TypeExtension") { var visitor = new SetPropertiesVisitor(Context); foreach (var cnode in node.Properties.Values.ToList()) { cnode.Accept(visitor, node); } foreach (var cnode in node.CollectionItems) { cnode.Accept(visitor, node); } //As we're stripping the TypeExtension bare, keep the type if we need it later (hint: we do need it) INode ntype; if (!node.Properties.TryGetValue(new XmlName("", "TypeName"), out ntype)) { ntype = node.CollectionItems [0]; } var type = ((ValueNode)ntype).Value as string; var namespaceuri = type.Contains(":") ? node.NamespaceResolver.LookupNamespace(type.Split(':') [0].Trim()) : ""; type = type.Contains(":") ? type.Split(':') [1].Trim() : type; Context.TypeExtensions [node] = new XmlType(namespaceuri, type, null).GetTypeReference(Module, node); if (!node.SkipProperties.Contains(new XmlName("", "TypeName"))) { node.SkipProperties.Add(new XmlName("", "TypeName")); } var vardefref = new VariableDefinitionReference(vardef); Context.IL.Append(SetPropertiesVisitor.ProvideValue(vardefref, Context, Module, node)); if (vardef != vardefref.VariableDefinition) { Context.Variables [node] = vardefref.VariableDefinition; Context.Body.Variables.Add(vardefref.VariableDefinition); } } } }
public static bool IsUndefined(ValueNode signal) { if(signal == null) throw new ArgumentNullException("signal"); return signal.Value is MathNet.Symbolics.Packages.Standard.Structures.UndefinedSymbol; }
public override void Remove(ValueNode <TItem> item) { Remove(this.SelectKey(item.Value)); }
public ValueNodeEventArgs(ValueNode node) { _node = node; }
internal OpGreater(FieldNode field, ValueNode valueNode) : base(field, valueNode) { }
protected override bool Equals(ValueNode <byte> node) { return(Value == node.Value); }
/// <summary>Evaluates whether the signal is one (1).</summary> public static bool IsMultiplicativeIdentity(ValueNode signal) { if(signal == null) throw new ArgumentNullException("signal"); IAlgebraicMultiplicativeIdentityElement ring = signal.Value as IAlgebraicMultiplicativeIdentityElement; return ring != null && ring.IsMultiplicativeIdentity; }
public static IEnumerable <Instruction> PushConvertedValue(this ValueNode node, ILContext context, TypeReference targetTypeRef, TypeReference typeConverter, IEnumerable <Instruction> pushServiceProvider, bool boxValueTypes, bool unboxValueTypes) { var module = context.Body.Method.Module; var str = (string)node.Value; //If the TypeConverter has a ProvideCompiledAttribute that can be resolved, shortcut this var compiledConverterName = typeConverter?.GetCustomAttribute(module.ImportReference(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?.First().Value as string; Type compiledConverterType; if (compiledConverterName != null && (compiledConverterType = Type.GetType(compiledConverterName)) != null) { var compiledConverter = Activator.CreateInstance(compiledConverterType); var converter = typeof(ICompiledTypeConverter).GetMethods().FirstOrDefault(md => md.Name == "ConvertFromString"); var instructions = (IEnumerable <Instruction>)converter.Invoke(compiledConverter, new object[] { node.Value as string, context, node as BaseNode }); foreach (var i in instructions) { yield return(i); } if (targetTypeRef.IsValueType && boxValueTypes) { yield return(Instruction.Create(OpCodes.Box, module.ImportReference(targetTypeRef))); } yield break; } //If there's a [TypeConverter], use it if (typeConverter != null) { var isExtendedConverter = typeConverter.ImplementsInterface(module.ImportReference(typeof(IExtendedTypeConverter))); var typeConverterCtor = typeConverter.Resolve().Methods.Single(md => md.IsConstructor && md.Parameters.Count == 0 && !md.IsStatic); var typeConverterCtorRef = module.ImportReference(typeConverterCtor); var convertFromInvariantStringDefinition = isExtendedConverter ? module.ImportReference(typeof(IExtendedTypeConverter)) .Resolve() .Methods.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 2) : typeConverter.Resolve() .AllMethods() .FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 1); var convertFromInvariantStringReference = module.ImportReference(convertFromInvariantStringDefinition); yield return(Instruction.Create(OpCodes.Newobj, typeConverterCtorRef)); yield return(Instruction.Create(OpCodes.Ldstr, node.Value as string)); if (isExtendedConverter) { foreach (var instruction in pushServiceProvider) { yield return(instruction); } } yield return(Instruction.Create(OpCodes.Callvirt, convertFromInvariantStringReference)); if (targetTypeRef.IsValueType && unboxValueTypes) { yield return(Instruction.Create(OpCodes.Unbox_Any, module.ImportReference(targetTypeRef))); } //ConvertFrom returns an object, no need to Box yield break; } var originalTypeRef = targetTypeRef; var isNullable = false; MethodReference nullableCtor = null; if (targetTypeRef.Resolve().FullName == "System.Nullable`1") { var nullableTypeRef = targetTypeRef; targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0]; isNullable = true; nullableCtor = originalTypeRef.GetMethods(md => md.IsConstructor && md.Parameters.Count == 1, module).Single().Item1; nullableCtor = nullableCtor.ResolveGenericParameters(nullableTypeRef, module); } var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module); //Obvious Built-in conversions if (targetTypeRef.Resolve().BaseType != null && targetTypeRef.Resolve().BaseType.FullName == "System.Enum") { yield return(PushParsedEnum(targetTypeRef, str, node)); } else if (targetTypeRef.FullName == "System.Char") { yield return(Instruction.Create(OpCodes.Ldc_I4, Char.Parse(str))); } else if (targetTypeRef.FullName == "System.SByte") { yield return(Instruction.Create(OpCodes.Ldc_I4, SByte.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Int16") { yield return(Instruction.Create(OpCodes.Ldc_I4, Int16.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Int32") { yield return(Instruction.Create(OpCodes.Ldc_I4, Int32.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Int64") { yield return(Instruction.Create(OpCodes.Ldc_I8, Int64.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Byte") { yield return(Instruction.Create(OpCodes.Ldc_I4, Byte.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.UInt16") { yield return(Instruction.Create(OpCodes.Ldc_I4, unchecked ((int)UInt16.Parse(str, CultureInfo.InvariantCulture)))); } else if (targetTypeRef.FullName == "System.UInt32") { yield return(Instruction.Create(OpCodes.Ldc_I4, UInt32.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.UInt64") { yield return(Instruction.Create(OpCodes.Ldc_I8, unchecked ((long)UInt64.Parse(str, CultureInfo.InvariantCulture)))); } else if (targetTypeRef.FullName == "System.Single") { yield return(Instruction.Create(OpCodes.Ldc_R4, Single.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Double") { yield return(Instruction.Create(OpCodes.Ldc_R8, Double.Parse(str, CultureInfo.InvariantCulture))); } else if (targetTypeRef.FullName == "System.Boolean") { if (Boolean.Parse(str)) { yield return(Instruction.Create(OpCodes.Ldc_I4_1)); } else { yield return(Instruction.Create(OpCodes.Ldc_I4_0)); } } else if (targetTypeRef.FullName == "System.TimeSpan") { var ts = TimeSpan.Parse(str, CultureInfo.InvariantCulture); var ticks = ts.Ticks; var timeSpanCtor = module.ImportReference(typeof(TimeSpan)) .Resolve() .Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1); var timeSpanCtorRef = module.ImportReference(timeSpanCtor); yield return(Instruction.Create(OpCodes.Ldc_I8, ticks)); yield return(Instruction.Create(OpCodes.Newobj, timeSpanCtorRef)); } else if (targetTypeRef.FullName == "System.DateTime") { var dt = DateTime.Parse(str, CultureInfo.InvariantCulture); var ticks = dt.Ticks; var dateTimeCtor = module.ImportReference(typeof(DateTime)) .Resolve() .Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1); var dateTimeCtorRef = module.ImportReference(dateTimeCtor); yield return(Instruction.Create(OpCodes.Ldc_I8, ticks)); yield return(Instruction.Create(OpCodes.Newobj, dateTimeCtorRef)); } else if (targetTypeRef.FullName == "System.String" && str.StartsWith("{}", StringComparison.Ordinal)) { yield return(Instruction.Create(OpCodes.Ldstr, str.Substring(2))); } else if (targetTypeRef.FullName == "System.String") { yield return(Instruction.Create(OpCodes.Ldstr, str)); } else if (targetTypeRef.FullName == "System.Object") { yield return(Instruction.Create(OpCodes.Ldstr, str)); } else if (targetTypeRef.FullName == "System.Decimal") { decimal outdecimal; if (decimal.TryParse(str, NumberStyles.Number, CultureInfo.InvariantCulture, out outdecimal)) { var vardef = new VariableDefinition(context.Body.Method.Module.ImportReference(typeof(decimal))); context.Body.Variables.Add(vardef); //Use an extra temp var so we can push the value to the stack, just like other cases // IL_0003: ldstr "adecimal" // IL_0008: ldc.i4.s 0x6f // IL_000a: call class [mscorlib]System.Globalization.CultureInfo class [mscorlib]System.Globalization.CultureInfo::get_InvariantCulture() // IL_000f: ldloca.s 0 // IL_0011: call bool valuetype [mscorlib]System.Decimal::TryParse(string, valuetype [mscorlib]System.Globalization.NumberStyles, class [mscorlib]System.IFormatProvider, [out] valuetype [mscorlib]System.Decimal&) // IL_0016: pop yield return(Instruction.Create(OpCodes.Ldstr, str)); yield return(Instruction.Create(OpCodes.Ldc_I4, 0x6f)); //NumberStyles.Number var getInvariantInfo = context.Body.Method.Module.ImportReference(typeof(CultureInfo)) .Resolve() .Properties.FirstOrDefault(pd => pd.Name == "InvariantCulture") .GetMethod; var getInvariant = context.Body.Method.Module.ImportReference(getInvariantInfo); yield return(Instruction.Create(OpCodes.Call, getInvariant)); yield return(Instruction.Create(OpCodes.Ldloca, vardef)); var tryParseInfo = context.Body.Method.Module.ImportReference(typeof(decimal)) .Resolve() .Methods.FirstOrDefault(md => md.Name == "TryParse" && md.Parameters.Count == 4); var tryParse = context.Body.Method.Module.ImportReference(tryParseInfo); yield return(Instruction.Create(OpCodes.Call, tryParse)); yield return(Instruction.Create(OpCodes.Pop)); yield return(Instruction.Create(OpCodes.Ldloc, vardef)); } else { yield return(Instruction.Create(OpCodes.Ldc_I4_0)); var decimalctorinfo = context.Body.Method.Module.ImportReference(typeof(decimal)) .Resolve() .Methods.FirstOrDefault( md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters[0].ParameterType.FullName == "System.Int32"); var decimalctor = context.Body.Method.Module.ImportReference(decimalctorinfo); yield return(Instruction.Create(OpCodes.Newobj, decimalctor)); } } else if (implicitOperator != null) { yield return(Instruction.Create(OpCodes.Ldstr, node.Value as string)); yield return(Instruction.Create(OpCodes.Call, module.ImportReference(implicitOperator))); } else { yield return(Instruction.Create(OpCodes.Ldnull)); } if (isNullable) { yield return(Instruction.Create(OpCodes.Newobj, module.ImportReference(nullableCtor))); } if (originalTypeRef.IsValueType && boxValueTypes) { yield return(Instruction.Create(OpCodes.Box, module.ImportReference(originalTypeRef))); } }
public PropertyValue(ValueNode owner) { InitializeComponent(); this.owner = owner; outcomes = owner.Outcomes; StackPanel first = new StackPanel { Orientation = Orientation.Horizontal }; foreach (ValueOutcome outc in outcomes) { foreach (Node fac in outc.FacNodes) { first.Children.Add(new Label { Content = fac.Name, Width = 100, FontWeight = FontWeights.Bold }); } break; } first.Children.Add(new Label { Content = owner.Name, Width = 100, FontWeight = FontWeights.Bold }); this.Container.Children.Add(first); foreach (ValueOutcome outc in outcomes) { StackPanel sp = new StackPanel { Orientation = Orientation.Horizontal }; string[] items = outc.Factors.ToArray(); foreach (string item in items) { sp.Children.Add(new Label { Content = item.Substring(owner.Owner.ID.Length + 1), Width = 100 }); } sp.Children.Add(new TextBox { Text = outc.Value.ToString(), Width = 100 }); this.Container.Children.Add(sp); } if (owner.BestDecisions.Length > 0) { Container.Children.Add(new Label { Content = "BestDecisions", FontStyle = FontStyles.Italic }); foreach (string bestDecision in owner.BestDecisions) { Container.Children.Add(new Label { Content = bestDecision.Substring(owner.Owner.ID.Length + 1) }); } } Button save = new Button { Content = "Save Values" }; save.Click += Save_Click; this.Container.Children.Add(save); LayoutUpdated += PropertyValue_LayoutUpdated; this.SetBinding(PropertyValue.AnchorX1Property, new Binding() { Source = owner.Owner, Path = new PropertyPath(Node.AnchorRightXProperty) }); this.SetBinding(PropertyValue.AnchorY1Property, new Binding() { Source = owner.Owner, Path = new PropertyPath(Node.AnchorRightYProperty) }); this.SetBinding(Canvas.LeftProperty, new Binding() { Source = this, Path = new PropertyPath(PropertyValue.AnchorX1Property) }); this.SetBinding(Canvas.TopProperty, new Binding() { Source = this, Path = new PropertyPath(PropertyValue.AnchorY1Property) }); MainWindow.GetCanvas.Children.Add(this); }
private void Date(ExpressionType expType, ValueNode value) { var date = (DateValueNode)value; if (date.Year != null) { if (date.Year < 1900 || date.Year > 2200) throw new SchyntaxParseException("Year " + date.Year + " is not a valid year. Must be between 1900 and 2200.", Input, date.Index); } if (date.Month < 1 || date.Month > 12) { throw new SchyntaxParseException("Month " + date.Month + " is not a valid month. Must be between 1 and 12.", Input, date.Index); } var daysInMonth = DateTime.DaysInMonth(date.Year ?? 2000, date.Month); // default to a leap year, if no year is specified if (date.Day < 1 || date.Day > daysInMonth) { throw new SchyntaxParseException(date.Day + " is not a valid day for the month specified. Must be between 1 and " + daysInMonth, Input, date.Index); } }
protected void CreateLoadIncGraph( OperationValueGraph g, ValueNode x, ValueNode p, ValueNode pi, int inc) { OperationNode loadOp = new LoadOperationNode(); OperationNode addOp = new AddOperationNode(); OperationNode constOp = new ConstOperationNode(); g.AddNode(loadOp); g.AddNode(addOp); g.AddNode(constOp); ValueNode t = new IntRegisterNode(); ValueNode i = new IntConstantNode(inc); g.AddNode(t); g.AddNode(i); g.AddEdge(p, loadOp); g.AddEdge(loadOp, x); g.AddEdge(p, addOp); g.AddEdge(i, constOp); g.AddEdge(constOp, t); g.AddEdge(t, addOp); g.AddEdge(addOp, pi); }
IEnumerable <Instruction> PushCtorXArguments(MethodDefinition factoryCtorInfo, ElementNode enode) { if (!enode.Properties.ContainsKey(XmlName.xArguments)) { yield break; } var arguments = new List <INode>(); var node = enode.Properties[XmlName.xArguments] as ElementNode; if (node != null) { node.Accept(new SetPropertiesVisitor(Context, true), null); arguments.Add(node); } var list = enode.Properties[XmlName.xArguments] as ListNode; if (list != null) { foreach (var n in list.CollectionItems) { arguments.Add(n); } } for (var i = 0; i < arguments.Count; i++) { var parameter = factoryCtorInfo.Parameters[i]; var arg = arguments[i]; VariableDefinition vardef; ValueNode vnode = null; if (arg is IElementNode && (vardef = Context.Variables[arg as IElementNode]) != null) { yield return(Instruction.Create(OpCodes.Ldloc, vardef)); } else if ((vnode = arg as ValueNode) != null) { foreach (var instruction in vnode.PushConvertedValue(Context, parameter.ParameterType, new ICustomAttributeProvider[] { parameter, parameter.ParameterType.ResolveCached() }, enode.PushServiceProvider(Context), false, true)) { yield return(instruction); } } } for (var i = arguments.Count; i < factoryCtorInfo.Parameters.Count; i++) { var parameter = factoryCtorInfo.Parameters[i]; var arg = new ValueNode(parameter.Constant?.ToString(), node?.NamespaceResolver); foreach (var instruction in arg.PushConvertedValue(Context, parameter.ParameterType, new ICustomAttributeProvider[] { parameter, parameter.ParameterType.ResolveCached() }, enode.PushServiceProvider(Context), false, true)) { yield return(instruction); } } }
protected void CreateSingleFilterLoop( ProgramGraph g, ValueNode x, ValueNode x0, ValueNode x1, ValueNode c0, ValueNode c1, ValueNode c2, ValueNode c3, ValueNode c4, ValueNode z0, ValueNode z1, ValueNode y) { OperationNode[] o = new OperationNode[13]; o[0] = new AddOperationNode(); o[1] = new MulOperationNode(); o[2] = new AddOperationNode(); o[3] = new AddOperationNode(); o[4] = new MulOperationNode(); o[5] = new AddOperationNode(); o[6] = new AddOperationNode(); o[7] = new AddOperationNode(); o[8] = new MulOperationNode(); o[9] = new MulOperationNode(); o[10] = new MulOperationNode(); o[11] = new AddOperationNode(); o[12] = new AddOperationNode(); foreach (OperationNode opNode in o) g.AddNode(opNode); ValueNode[] v = new ValueNode[10]; for (int i = 0; i < v.Length; i++) v[i] = new FloatRegisterNode(); foreach (ValueNode vNode in v) g.AddNode(vNode); g.AddEdge(x, o[0]); g.AddEdge(x0, o[0]); g.AddEdge(o[0], v[0]); g.AddEdge(c0, o[1]); g.AddEdge(v[0], o[1]); g.AddEdge(o[1], v[1]); g.AddEdge(x, o[2]); g.AddEdge(v[1], o[2]); g.AddEdge(o[2], v[2]); g.AddEdge(v[2], o[3]); g.AddEdge(x1, o[3]); g.AddEdge(o[3], v[3]); g.AddEdge(c1, o[4]); g.AddEdge(v[3], o[4]); g.AddEdge(o[4], v[4]); g.AddEdge(v[2], o[5]); g.AddEdge(v[4], o[5]); g.AddEdge(o[5], z1); g.AddEdge(v[1], o[6]); g.AddEdge(x0, o[6]); g.AddEdge(o[6], v[5]); g.AddEdge(v[4], o[7]); g.AddEdge(x1, o[7]); g.AddEdge(o[7], z0); g.AddEdge(v[5], o[8]); g.AddEdge(c2, o[8]); g.AddEdge(o[8], v[6]); g.AddEdge(z0, o[9]); g.AddEdge(c3, o[9]); g.AddEdge(o[9], v[7]); g.AddEdge(z1, o[10]); g.AddEdge(c4, o[10]); g.AddEdge(o[10], v[9]); g.AddEdge(v[6], o[11]); g.AddEdge(v[7], o[11]); g.AddEdge(o[11], v[8]); g.AddEdge(v[8], o[12]); g.AddEdge(v[9], o[12]); g.AddEdge(o[12], y); }
public void Visit(ElementNode node, INode parentNode) { var typeref = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, Module, node)); TypeDefinition typedef = typeref.ResolveCached(); if (IsXaml2009LanguagePrimitive(node)) { var vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(PushValueFromLanguagePrimitive(typeref, node)); Context.IL.Emit(OpCodes.Stloc, vardef); return; } //if this is a MarkupExtension that can be compiled directly, compile and returns the value var compiledMarkupExtensionName = typeref .GetCustomAttribute(Module, (XamlCTask.xamlAssemblyName, XamlCTask.xamlNameSpace, "ProvideCompiledAttribute")) ?.ConstructorArguments?[0].Value as string; Type compiledMarkupExtensionType; ICompiledMarkupExtension markupProvider; if (compiledMarkupExtensionName != null && (compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null && (markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null) { var il = markupProvider.ProvideValue(node, Module, Context, out typeref); typeref = Module.ImportReference(typeref); var vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(il); Context.IL.Emit(OpCodes.Stloc, vardef); //clean the node as it has been fully exhausted foreach (var prop in node.Properties) { if (!node.SkipProperties.Contains(prop.Key)) { node.SkipProperties.Add(prop.Key); } } node.CollectionItems.Clear(); return; } MethodDefinition factoryCtorInfo = null; MethodDefinition factoryMethodInfo = null; TypeDefinition ownerTypeOfFactoryMethod = null; MethodDefinition parameterizedCtorInfo = null; MethodDefinition ctorInfo = null; if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod)) { factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.HasParameters && md.MatchXArguments(node, typeref, Module, Context)); if (factoryCtorInfo == null) { throw new XamlParseException( string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node); } ctorInfo = factoryCtorInfo; if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params { Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node)); } } else if (node.Properties.ContainsKey(XmlName.xFactoryMethod)) { var factoryMethod = (string)(node.Properties[XmlName.xFactoryMethod] as ValueNode).Value; factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor && md.Name == factoryMethod && md.IsStatic && md.MatchXArguments(node, typeref, Module, Context)); if (factoryMethodInfo == null) { var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.OnlyGetTypeExtension, Module, node)); typeExtensionRef = typeExtensionRef?.ResolveCached(); if (null != typeExtensionRef?.Resolve()) { factoryMethodInfo = typeExtensionRef.Resolve().AllMethods().FirstOrDefault(md => !md.IsConstructor && md.Name == factoryMethod && md.IsStatic && md.MatchXArguments(node, typeref, Module, Context)); if (null != factoryMethod) { ownerTypeOfFactoryMethod = typeExtensionRef.ResolveCached(); } } } else { ownerTypeOfFactoryMethod = typedef; } if (factoryMethodInfo == null) { throw new XamlParseException( String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node); } Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node)); } if (ctorInfo == null && factoryMethodInfo == null) { parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.HasParameters && md.Parameters.All( pd => pd.CustomAttributes.Any( ca => ca.AttributeType.FullName == "Tizen.NUI.Binding.ParameterAttribute"))); } string missingCtorParameter = null; if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node, out missingCtorParameter)) { ctorInfo = parameterizedCtorInfo; // IL_0000: ldstr "foo" Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node)); } ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic); if (null == ctorInfo && null == factoryMethodInfo) { foreach (var method in typedef.Methods) { if (method.IsConstructor && !method.IsStatic) { bool areAllParamsDefault = true; foreach (var param in method.Parameters) { if (!param.HasDefault) { areAllParamsDefault = false; break; } } if (areAllParamsDefault) { if (null == ctorInfo) { ctorInfo = method; } else { throw new XamlParseException($"{typedef.FullName} has more than one constructor which params are all default.", node); } } } } if (null == ctorInfo) { if (!typedef.IsValueType) { throw new XamlParseException($"{typedef.FullName} has no constructor which params are all default.", node); } } else { factoryCtorInfo = ctorInfo; if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params { Context.IL.Append(PushCtorDefaultArguments(factoryCtorInfo, node)); } } } if (parameterizedCtorInfo != null && ctorInfo == null) { //there was a parameterized ctor, we didn't use it throw new XamlParseException($"The Property '{missingCtorParameter}' is required to create a '{typedef.FullName}' object.", node); } var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module); var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(ownerTypeOfFactoryMethod, Module); var implicitOperatorref = typedef.Methods.FirstOrDefault(md => md.IsPublic && md.IsStatic && md.IsSpecialName && md.Name == "op_Implicit" && md.Parameters[0].ParameterType.FullName == "System.String"); if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType) { VariableDefinition vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); ValueNode vnode = null; if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && vardef.VariableType.IsValueType) { //<Color>Purple</Color> Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider[] { typedef }, node.PushServiceProvider(Context), false, true)); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && implicitOperatorref != null) { //<FileImageSource>path.png</FileImageSource> var implicitOperator = Module.ImportReference(implicitOperatorref); Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string); Context.IL.Emit(OpCodes.Call, implicitOperator); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (factorymethodinforef != null) { Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef)); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (!typedef.IsValueType) { var ctor = Module.ImportReference(ctorinforef); // IL_0001: newobj instance void class [Tizen.NUI.Xaml.UIComponents]Tizen.NUI.Xaml.UIComponents.Button::'.ctor'() // IL_0006: stloc.0 bool isConvertValue = false; if (node.CollectionItems.Count == 1 && node.CollectionItems.First() is ValueNode valueNode) { if (valueNode.CanConvertValue(Context.Module, typeref, (TypeReference)null)) { var converterType = valueNode.GetConverterType(new ICustomAttributeProvider[] { typeref.Resolve() }); if (null != converterType) { isConvertValue = true; Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider[] { typedef }, node.PushServiceProvider(Context), false, true)); } } } if (false == isConvertValue) { Context.IL.Emit(OpCodes.Newobj, ctor); } Context.IL.Emit(OpCodes.Stloc, vardef); } else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context)) { // IL_0008: ldloca.s 1 // IL_000a: ldc.i4.1 // IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool) var ctor = Module.ImportReference(ctorinforef); Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node)); Context.IL.Emit(OpCodes.Call, ctor); } else { // IL_0000: ldloca.s 0 // IL_0002: initobj Test/Foo Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef)); } if (null != XamlCTask.BaseTypeDefiniation && typedef.InheritsFromOrImplements(XamlCTask.BaseTypeDefiniation)) { var field = XamlCTask.BaseTypeDefiniation.Properties.SingleOrDefault(fd => fd.Name == "IsCreateByXaml"); if (field == null) { return; } ValueNode value = new ValueNode("true", node.NamespaceResolver); Set(Context.Variables[node], "IsCreateByXaml", value, null); } if (typeref.FullName == "Tizen.NUI.Xaml.ArrayExtension") { var visitor = new SetPropertiesVisitor(Context); foreach (var cnode in node.Properties.Values.ToList()) { cnode.Accept(visitor, node); } foreach (var cnode in node.CollectionItems) { cnode.Accept(visitor, node); } markupProvider = new ArrayExtension(); var il = markupProvider.ProvideValue(node, Module, Context, out typeref); vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(il); Context.IL.Emit(OpCodes.Stloc, vardef); //clean the node as it has been fully exhausted foreach (var prop in node.Properties) { if (!node.SkipProperties.Contains(prop.Key)) { node.SkipProperties.Add(prop.Key); } } return; } } }
public ProgramGraph CreateUnrolledProgramGraph(int k) { ProgramGraph g = new ProgramGraph(); ValueNode[] xp = new ValueNode[k + 1]; ValueNode[] yp = new ValueNode[k + 1]; ValueNode[] y = new ValueNode[k + 1]; ValueNode[] x = new ValueNode[k + 1]; for (int i = 0; i < k + 1; i++) { xp[i] = new TestRegisterNode("xp[" + i + "]", Datatype.AddressValue); yp[i] = new TestRegisterNode("yp[" + i + "]", Datatype.AddressValue); y[i] = new TestRegisterNode("y[" + i + "]", Datatype.FloatValue); x[i] = new TestRegisterNode("x[" + i + "]", Datatype.FloatValue); g.AddNode(xp[i]); g.AddNode(yp[i]); g.AddNode(x[i]); g.AddNode(y[i]); } ValueNode pc0 = new FloatMemoryNode("c0"); ValueNode pc1 = new FloatMemoryNode("c1"); ValueNode pc2 = new FloatMemoryNode("c2"); OperationNode lc0 = new LoadOperationNode(); OperationNode lc1 = new LoadOperationNode(); OperationNode lc2 = new LoadOperationNode(); ValueNode c0 = new FloatRegisterNode(); ValueNode c1 = new FloatRegisterNode(); ValueNode c2 = new FloatRegisterNode(); g.AddNode(pc0); g.AddNode(pc1); g.AddNode(pc2); g.AddNode(lc0); g.AddNode(lc1); g.AddNode(lc2); g.AddNode(c0); g.AddNode(c1); g.AddNode(c2); g.AddEdge(pc0, lc0); g.AddEdge(lc0, c0); g.AddEdge(pc1, lc1); g.AddEdge(lc1, c1); g.AddEdge(pc2, lc2); g.AddEdge(lc2, c2); for (int i = 0; i < k; i++) { CreateSingleLoop( g, xp[i], yp[i], x[i], y[i], c0, c1, c2, xp[i + 1], yp[i + 1], x[i + 1], y[i + 1]); } g.InitInputValues(); g.InitOutputValues(); g.OutputValues.Add(x[k]); g.OutputValues.Add(y[k]); x[k].OutputFlag = true; y[k].OutputFlag = true; g.CyclicDependencies[xp[0]] = xp[k]; g.CyclicDependencies[xp[k]] = xp[0]; g.CyclicDependencies[yp[0]] = yp[k]; g.CyclicDependencies[yp[k]] = yp[0]; g.CyclicDependencies[y[0]] = y[k]; g.CyclicDependencies[y[k]] = y[0]; g.CyclicDependencies[x[0]] = x[k]; g.CyclicDependencies[x[k]] = x[0]; return g; }
public static bool CanConvertValue(this ValueNode node, ILContext context, TypeReference targetTypeRef, TypeReference typeConverter) { var str = (string)node.Value; var module = context.Body.Method.Module; //If there's a [TypeConverter], assume we can convert if (typeConverter != null && str != null) { return(true); } //check if it's assignable from a string if (targetTypeRef.ResolveCached().FullName == "System.Nullable`1") { targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0]; } if (targetTypeRef.ResolveCached().BaseType != null && targetTypeRef.ResolveCached().BaseType.FullName == "System.Enum") { return(true); } if (targetTypeRef.FullName == "System.Char") { return(true); } if (targetTypeRef.FullName == "System.SByte") { return(true); } if (targetTypeRef.FullName == "System.Int16") { return(true); } if (targetTypeRef.FullName == "System.Int32") { return(true); } if (targetTypeRef.FullName == "System.Int64") { return(true); } if (targetTypeRef.FullName == "System.Byte") { return(true); } if (targetTypeRef.FullName == "System.UInt16") { return(true); } if (targetTypeRef.FullName == "System.UInt32") { return(true); } if (targetTypeRef.FullName == "System.UInt64") { return(true); } if (targetTypeRef.FullName == "System.Single") { return(true); } if (targetTypeRef.FullName == "System.Double") { return(true); } if (targetTypeRef.FullName == "System.Boolean") { return(true); } if (targetTypeRef.FullName == "System.TimeSpan") { return(true); } if (targetTypeRef.FullName == "System.DateTime") { return(true); } if (targetTypeRef.FullName == "System.String") { return(true); } if (targetTypeRef.FullName == "System.Object") { return(true); } if (targetTypeRef.FullName == "System.Decimal") { return(true); } var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module); if (implicitOperator != null) { return(true); } return(false); }
public void Visit(ValueNode node, INode parentNode) { }
public string Visit(ValueNode node) => node.Value.ToString();
internal OpContains(FieldNode field, ValueNode valueNode) : base(field, valueNode) { }
internal override ValueNode CreateSerializerOverride(ValueNode parent) { return(new CustomValueNode(parent, Name, this)); }