public static void Serialize(TextWriter tw, AbstractTemplateElement element, IDictionary <string, string> vars, IDictionary <string, IEnumerable <string> > arrays, TemplateSerializationParms parms)
        {
            if (m_CommandSerializers == null)
            {
                m_CommandSerializers = InitCommandSerializers();
            }

            if (!m_CommandSerializers.ContainsKey(element.GetType()))
            {
                throw new ArgumentOutOfRangeException(nameof(element), $"ElementType {element.GetType()} not serializable");
            }

            var typeInfo = m_CommandSerializers[element.GetType()];
            var ctor     = typeInfo.Serializer.GetConstructor(Type.EmptyTypes);
            var instance = (AbstractTemplateSerializer)ctor?.Invoke(new object[0]);

            if (instance == null)
            {
                throw new ArgumentOutOfRangeException(nameof(element), $"Serializer for {element.GetType()} not instanciable");
            }

            if (typeInfo.UseClones)
            {
                var cloneVars   = new Dictionary <string, string>(vars);
                var cloneArrays = new Dictionary <string, IEnumerable <string> >(arrays);
                instance.Initialize(element, cloneVars, cloneArrays, parms);
            }
            else
            {
                instance.Initialize(element, vars, arrays, parms);
            }

            instance.Serialize(tw);
        }
        public static void ExtractVariables(AbstractTemplateElement element, IDictionary <string, ExtractedVariable> variables, VariableExtractionParms parms)
        {
            if (m_CommandSerializers == null)
            {
                m_CommandSerializers = InitCommandSerializers();
            }

            if (!m_CommandSerializers.ContainsKey(element.GetType()))
            {
                throw new ArgumentOutOfRangeException(nameof(element), $"ElementType {element.GetType()} not serializable");
            }

            var typeInfo = m_CommandSerializers[element.GetType()];
            var ctor     = typeInfo.VariableExtractor.GetConstructor(Type.EmptyTypes);
            var instance = (AbstractVariableExtractor)ctor?.Invoke(new object[0]);

            if (instance == null)
            {
                throw new ArgumentOutOfRangeException(nameof(element), $"Serializer for {element.GetType()} not instanciable");
            }

            instance.Initialize(element, parms);
            instance.ExtractVariables(variables);
        }
Пример #3
0
        public static void CompareTemplateElements(AbstractTemplateElement left, AbstractTemplateElement right)
        {
            Assert.IsNotNull(left);
            Assert.IsNotNull(right);
            Assert.IsTrue(right.GetType().IsInstanceOfType(left));

            if (left is XmTemplateElement)
            {
                new XmTemplateComparator().Compare(left, right);
            }

            else if (left is StaticTemplateElement)
            {
                new StaticTemplateComparator().Compare(left, right);
            }

            else if (left is DefineTemplateElement)
            {
                new DefineTemplateComparator().Compare(left, right);
            }

            else if (left is ConditionalTemplateElement)
            {
                new ConditionnalTemplateComparator().Compare(left, right);
            }

            else if (left is EnumeratorTemplateElement)
            {
                new EnumeratorTemplateComparator().Compare(left, right);
            }

            else if (left is EvaluateTemplateElement)
            {
                new EvaluateTemplateComparator().Compare(left, right);
            }

            else if (left is RangeTemplateElement)
            {
                new RangeTemplateComparator().Compare(left, right);
            }

            else
            {
                throw new NotImplementedException("Unable to compare template, template element not supported " + right.GetType());
            }
        }