Exemple #1
0
        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);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
 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);
     }
 }
Exemple #4
0
 public void ExecuteAssignment(NodeAssignment assignment, INodeToObjectBuilder builder, BuilderContext context)
 {
     if (!assignment.Assignment.Member.MemberType.IsCollection())
     {
         AssignSingleValue(assignment, builder, context);
     }
     else
     {
         AssignCollection(assignment);
     }
 }
Exemple #5
0
 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);
     }
 }
Exemple #6
0
        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);
            }
        }
Exemple #7
0
        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);
            }
        }
Exemple #8
0
        private void AssembleFromSourceValue(MemberAssignment a, ConstructionNode node, BuilderContext context)
        {
            var conversionResult = Converter.Convert(a.SourceValue, a.Member.MemberType, new ConvertContext()
            {
                Node = node, BuilderContext = context
            });

            a.Values = new List <ConstructionNode>
            {
                new ConstructionNode(a.Member.MemberType)
                {
                    Instance  = conversionResult.Item2,
                    IsCreated = conversionResult.Item1,
                    Parent    = node,
                }
            };
        }
Exemple #9
0
 protected virtual void AssembleFromChildren(MemberAssignment a, ConstructionNode constructionNode, INodeToObjectBuilder nodeToObjectBuilder, BuilderContext context)
 {
     foreach (var node in a.Values)
     {
         Assemble(node, nodeToObjectBuilder, constructionNode, context);
     }
 }