private FormatRendererNode BuildRendererFromParts(string rendererName, FormatRendererNode childRenderer, List<FormatArgumentNode> arguments)
 {
     FormatRendererNode renderer = new FormatRendererNode(rendererName);
     if (childRenderer != null)
     {
         renderer = new FormatTransformerNode(rendererName, childRenderer);
     }
     if (arguments != null)
     {
         foreach (FormatArgumentNode argument in arguments)
         {
             renderer.SetArgument(argument);
         }
     }
     return renderer;
 }
        private FormatRenderer CreateRenderer(FormatRendererNode node)
        {
            if (node == null)
            {
                throw new InvalidOperationException("Encountered empty renderer node.");
            }

            FormatRenderer renderer;
            FormatTransformerNode transformerNode = node as FormatTransformerNode;

            if (transformerNode != null)
            {
                // Create the child renderer.
                var childRenderer = this.CreateRenderer(transformerNode.Renderer);
                if (childRenderer == null)
                {
                    // We could not create the child renderer.
                    throw new FormatPatternException("Could not create child renderer node '{0}'.", (transformerNode.Renderer.Name));
                }

                // Get the type of the transformer from the type map.
                Type transformerType = _typeMap.GetRendererType(node.Name);
                if (transformerType == null)
                {
                    // We could not find the transformer.
                    throw new FormatPatternException("Could not resolve transformer '{0}'.", node.Name);
                }

                // If this is a generic transformer?
                if (transformerType.IsGenericType && transformerType.ContainsGenericParameters)
                {
                    // Create a generic type of it with the context as argument.
                    throw new NotImplementedException();
                    //transformerType = transformerType.MakeGenericType(typeof(TContext));
                }

                // Create the transformer.
                renderer = Activator.CreateInstance(transformerType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
                    null, new object[] { childRenderer }, null) as FormatRenderer;
            }
            else
            {
                // Get the renderer type.
                Type rendererType = _typeMap.GetRendererType(node.Name);
                if (rendererType == null)
                {
                    // We could not find the renderer.
                    throw new FormatPatternException("Could not resolve renderer '{0}'.", node.Name);
                }

                // Is this a transformer without a renderer?
                if (rendererType.Inherits(typeof(FormatTransformer)))
                {
                    throw new FormatPatternException("Transformer '{0}' has no attached renderer.", node.Name);
                }

                // Create the renderer.
                renderer = Activator.CreateInstance(rendererType, true) as FormatRenderer;
            }

            // Map all arguments.
            this.MapArguments(renderer, node.Arguments);

            // Return the transformer.
            return renderer;
        }
 public FormatTransformerNode(string name, FormatRendererNode renderer)
     : base(name)
 {
     _renderer = renderer;
 }