protected override void AssembleFromChildren(MemberAssignment a, ConstructionNode constructionNode, INodeToObjectBuilder nodeToObjectBuilder, BuilderContext context) { var loaderInfo = metadataProvider.Get(constructionNode.ActualInstanceType).FragmentLoaderInfo; if (loaderInfo != null) { if (constructionNode.ActualInstanceType == loaderInfo.Type && a.Member.MemberName == loaderInfo.PropertyName) { ConstructionNode payload = constructionNode.Assignments.First(assignment => assignment.Member.MemberName == loaderInfo.PropertyName).Values.First(); var loader = loaderInfo.Loader.Load(payload, nodeToObjectBuilder, context); CreateInstance(constructionNode); ApplyAssignments(constructionNode, nodeToObjectBuilder, context); a.Values = new[] { new ConstructionNode(loader.GetType()) { Instance = loader } }; AssigmentApplier.ExecuteAssignment(new NodeAssignment(a, constructionNode.Instance), nodeToObjectBuilder, context); } } else { base.AssembleFromChildren(a, constructionNode, nodeToObjectBuilder, context); } }
protected void ApplyAssignments(ConstructionNode node, INodeToObjectBuilder builder, BuilderContext context) { foreach (var assignment in node.Assignments) { var nodeAssignment = new NodeAssignment(assignment, node.Instance); AssigmentApplier.ExecuteAssignment(nodeAssignment, builder, context); } }
public void ExecuteAssignment(NodeAssignment assignment, INodeToObjectBuilder builder, BuilderContext context) { if (!assignment.Assignment.Member.MemberType.IsCollection()) { AssignSingleValue(assignment, builder, context); } else { AssignCollection(assignment); } }
private void SetMember(Assignment assignment, ConstructionNode parentNode, INodeToObjectBuilder builder, BuilderContext context) { var mutableUnit = new MutablePipelineUnit(parentNode, assignment.Value); pipeline.Handle(assignment.Target.Instance, assignment.Member, mutableUnit, builder, context); if (mutableUnit.Handled) { return; } assignment.Member.SetValue(assignment.Target.Instance, mutableUnit.Value); }
private void AssignSingleValue(NodeAssignment assignment, INodeToObjectBuilder builder, BuilderContext context) { var children = assignment.Assignment.Values.ToList(); if (children.Count > 1) { throw new InvalidOperationException($"Cannot assign multiple values to a the property {assignment}"); } var nodeBeingAssigned = children.First(); var value = nodeBeingAssigned.Instance; var assign = new Assignment(assignment.Instance, assignment.Assignment.Member, value); SetMember(assign, nodeBeingAssigned, builder, context); }
public void Assemble(ConstructionNode node, INodeToObjectBuilder nodeToObjectBuilder, ConstructionNode parent = null, BuilderContext context = null) { node.Parent = parent; if (node.IsCreated) { return; } if (node.SourceValue != null) { AssembleLeafNode(node, context); } else { CreateIntermediateNode(node, nodeToObjectBuilder, context); } }
private void CreateIntermediateNode(ConstructionNode node, INodeToObjectBuilder nodeToObjectBuilder, BuilderContext context) { foreach (var a in node.Assignments) { AssembleAssignment(a, node, nodeToObjectBuilder, context); } foreach (var c in node.Children) { Assemble(c, nodeToObjectBuilder, node, context); } if (CanBeCreated(node)) { CreateInstance(node); ApplyAssignments(node, nodeToObjectBuilder, context); AttachChildren(node); } }
public TemplateContent(ConstructionNode node, INodeToObjectBuilder builder, BuilderContext context) { this.node = node; this.builder = builder; this.context = context; }
protected abstract void HandleCore(object parent, Member member, MutablePipelineUnit mutable, INodeToObjectBuilder builder, BuilderContext context);
public void Handle(object parent, Member member, MutablePipelineUnit mutable, INodeToObjectBuilder builder, BuilderContext context) { if (!mutable.Handled) { pipeline.Handle(parent, member, mutable, builder, context); HandleCore(parent, member, mutable, builder, context); } }
protected override void HandleCore(object parent, Member member, MutablePipelineUnit mutable, INodeToObjectBuilder builder, BuilderContext context) { var od = mutable.Value as ObserveDefinition; var bd = mutable.Value as BindDefinition; if (od != null) { //BindToObservable(od); } else if (bd != null) { if (bd.TargetInstance is IPropertyHost) { ClearExistingBinding(bd); var bindingSubscription = BindToProperty(context, bd); AddExistingBinding(bd, bindingSubscription); } mutable.Handled = true; } }
protected override void HandleCore(object parent, Member member, MutablePipelineUnit mutable, INodeToObjectBuilder builder, BuilderContext context) { var deferringLoader = metadataProvider.Get(parent.GetType()).FragmentLoaderInfo; if (deferringLoader == null) { return; } if (IsApplicable(deferringLoader, parent, member)) { mutable.Value = deferringLoader.Loader.Load(mutable.ParentNode, builder, context); } }
public void Handle(object parent, Member member, MutablePipelineUnit mutable, INodeToObjectBuilder builder, BuilderContext context) { }
protected virtual void AssembleFromChildren(MemberAssignment a, ConstructionNode constructionNode, INodeToObjectBuilder nodeToObjectBuilder, BuilderContext context) { foreach (var node in a.Values) { Assemble(node, nodeToObjectBuilder, constructionNode, context); } }
public void ExecuteAssignment(NodeAssignment assignment, INodeToObjectBuilder builder, BuilderContext context) { func(assignment, builder, context); }
public void Assemble(ConstructionNode node, INodeToObjectBuilder nodeToObjectBuilder, ConstructionNode parent = null, BuilderContext context = null) { assembler.Assemble(node, nodeToObjectBuilder, parent, context); assembler.Assemble(node, nodeToObjectBuilder, parent, context); }
protected override void HandleCore(object parent, Member member, MutablePipelineUnit mutable, INodeToObjectBuilder builder, BuilderContext context) { var extension = mutable.Value as IMarkupExtension; if (extension != null) { var keyedInstance = new KeyedInstance(parent); var assignment = new Assignment(keyedInstance, member, mutable.Value); var finalValue = extension.GetValue(new ExtensionValueContext(assignment, null, null, null)); mutable.Value = finalValue; } }
public TemplateContent(ConstructionNode node, INodeToObjectBuilder builder) { this.node = node; this.builder = builder; }
public object Load(ConstructionNode node, INodeToObjectBuilder builder, BuilderContext context) { return(new TemplateContent(node, builder, context)); }
private void AssembleAssignment(MemberAssignment memberAssignment, ConstructionNode node, INodeToObjectBuilder nodeToObjectBuilder, BuilderContext context) { if (memberAssignment.SourceValue != null) { AssembleFromSourceValue(memberAssignment, node, context); } else { AssembleFromChildren(memberAssignment, node, nodeToObjectBuilder, context); } }