/// <summary> /// Writes the address space declaration file. /// </summary> private void WriteTemplate_DataTypeDesign(string fileName, string targetNamespace) { StreamWriter writer = new StreamWriter(String.Format(@"{0}\{1}.xml", OutputDirectory, fileName), false); try { Template template = new Template(writer, TemplatePath + "File.xml", Assembly.GetExecutingAssembly()); template.AddReplacement("_Date_", DateTime.Now.ToString()); template.AddReplacement("_TargetNamespace_", targetNamespace); AddTemplate( template, "<!-- ListOfDataTypes -->", TemplatePath + "DataType.xml", GetListOfTypes(m_exportAll), new LoadTemplateEventHandler(LoadTemplate_DataType), new WriteTemplateEventHandler(WriteTemplate_DataType)); template.WriteTemplate(null); } finally { writer.Close(); } }
/// <summary> /// Writes the address space declaration file. /// </summary> private void WriteTemplate_ServicesWsdl(string fileName, string namespacePrefix, string dictionaryName) { StreamWriter writer = new StreamWriter(String.Format(@"{0}\{1}.Services.wsdl", OutputDirectory, namespacePrefix, fileName), false); try { Template template = new Template(writer, TemplatePath + "Services.wsdl", Assembly.GetExecutingAssembly()); template.Replacements.Add("_BuildDate_", Utils.Format("{0:yyyy-MM-dd}", DateTime.UtcNow)); template.Replacements.Add("_Version_", Utils.Format("{0}.{1}", Utils.GetAssemblySoftwareVersion(), Utils.GetAssemblyBuildNumber())); template.Replacements.Add("_Namespace_", TargetNamespace); template.Replacements.Add("_NamespacePrefix_", fileName); template.Replacements.Add("_ServicesNamespace_", ServicesNamespace); template.Replacements.Add("_TypesNamespace_", TypesNamespace); AddTemplate( template, "<!-- Message List -->", TemplatePath + "Message.wsdl", GetListOfTypes(typeof(ServiceType), m_exportAll, true), null, new WriteTemplateEventHandler(WriteTemplate_Message)); AddTemplate( template, "<!-- Session Operation List -->", TemplatePath + "PortType.wsdl", GetListOfServices(InterfaceType.Session), null, new WriteTemplateEventHandler(WriteTemplate_Message)); AddTemplate( template, "<!-- Discovery Operation List -->", TemplatePath + "PortType.wsdl", GetListOfServices(InterfaceType.Discovery), null, new WriteTemplateEventHandler(WriteTemplate_Message)); AddTemplate( template, "<!-- Registration Operation List -->", TemplatePath + "PortType.wsdl", GetListOfServices(InterfaceType.Registration), null, new WriteTemplateEventHandler(WriteTemplate_Message)); template.WriteTemplate(null); } finally { writer.Close(); } }
/// <summary> /// Writes the template. /// </summary> public bool Write(Template template, Context context) { // check for override. if (m_writeTemplate != null) { return(m_writeTemplate(template, context)); } // use the default function to write the template. return(template.WriteTemplate(context)); }
private void WriteTemplate_HFIndecesImplementation(string namespacePrefix, string dictionaryName) { List <HFEntry> tmp = new List <HFEntry>(); foreach (HFEntry entry in m_lstFields) { bool bAdd = true; foreach (HFEntry entry2 in tmp) { if (entry.FieldName() == entry2.FieldName()) { bAdd = false; break; } } if (bAdd) { tmp.Add(entry); } } m_lstFields = tmp; string fileName = String.Format(@"{0}\{1}_hfindeces.c", OutputDirectory, namespacePrefix); fileName = fileName.ToLower(); StreamWriter writer = new StreamWriter(fileName, false); Template template = new Template(writer, WiresharkTemplatePath + "hfentries.c", Assembly.GetExecutingAssembly()); template.AddReplacement("_Date_", DateTime.Now.ToString()); AddTemplate( template, "// _INDECES_", WiresharkTemplatePath + "hfentries.c", m_lstFields, null, new WriteTemplateEventHandler(WriteTemplate_Field)); AddTemplate( template, "// _FIELDS_", WiresharkTemplatePath + "hfentries.c", m_lstFields, null, new WriteTemplateEventHandler(WriteTemplate_Field)); template.WriteTemplate(null); writer.Close(); }
/// <summary> /// Writes an array declaration to the stream. /// </summary> private bool WriteTemplate_Message(Template template, Context context) { ServiceType datatype = context.Target as ServiceType; if (datatype == null) { return(false); } template.AddReplacement("_Namespace_", TargetNamespace); template.AddReplacement("_ServicesNamespace_", ServicesNamespace); template.AddReplacement("_TypesNamespace_", TypesNamespace); template.AddReplacement("_NAME_", datatype.QName.Name); return(template.WriteTemplate(context)); }
/// <summary> /// Writes an array declaration to the stream. /// </summary> private bool WriteTemplate_Array(Template template, Context context) { DataType datatype = context.Target as DataType; if (datatype == null) { return(false); } if (!datatype.AllowArrays) { return(false); } template.WriteLine(String.Empty); template.AddReplacement("_TypeName_", datatype.QName.Name); return(template.WriteTemplate(context)); }
private void WriteTemplate_HFIndecesHeader(string namespacePrefix, string dictionaryName) { string fileName = String.Format(@"{0}\{1}_hfindeces.h", OutputDirectory, namespacePrefix); fileName = fileName.ToLower(); StreamWriter writer = new StreamWriter(fileName, false); Template template = new Template(writer, WiresharkTemplatePath + "hfentries.h", Assembly.GetExecutingAssembly()); template.AddReplacement("_Date_", DateTime.Now.ToString()); AddTemplate( template, "// _EXTERNINDECES_", WiresharkTemplatePath + "hfentries.h", m_lstFields, null, new WriteTemplateEventHandler(WriteTemplate_Field)); template.WriteTemplate(null); writer.Close(); }
/// <summary> /// Writes the address space declaration file. /// </summary> private void WriteTemplate_BinarySchema(string fileName) { StreamWriter writer = new StreamWriter(String.Format(@"{0}\{1}.bsd", OutputDirectory, fileName), false); try { Template template = new Template(writer, TemplatePath + "File.xml", Assembly.GetExecutingAssembly()); template.Replacements.Add("_BuildDate_", Utils.Format("{0:yyyy-MM-dd}", DateTime.UtcNow)); template.Replacements.Add("_Version_", Utils.Format("{0}.{1}", Utils.GetAssemblySoftwareVersion(), Utils.GetAssemblyBuildNumber())); template.Replacements.Add("_DictionaryUri_", TargetNamespace); StringBuilder buffer = new StringBuilder(); buffer.AppendFormat("xmlns=\"{0}\"", NamespaceUris[0]); if (!m_exportAll) { for (int ii = 1; ii < NamespaceUris.Count; ii++) { buffer.Append(template.NewLine); buffer.Append(" "); buffer.AppendFormat("xmlns:s{0}=\"{1}\"", ii - 1, NamespaceUris[ii]); } } template.Replacements.Add("xmlns:s0=\"ListOfNamespaces\"", buffer.ToString()); List <string> imports = new List <string>(); imports.Add(Namespaces.OpcUaBuiltInTypes); if (!m_exportAll) { for (int ii = 1; ii < NamespaceUris.Count; ii++) { imports.Add(NamespaceUris[ii]); } } AddTemplate( template, "<!-- Imports -->", null, imports, new LoadTemplateEventHandler(LoadTemplate_Imports), null); AddTemplate( template, "<!-- ListOfTypes -->", TemplatePath + "OpaqueType.xml", GetListOfTypes(m_exportAll), new LoadTemplateEventHandler(LoadTemplate_DataType), new WriteTemplateEventHandler(WriteTemplate_DataType)); template.WriteTemplate(null); } finally { writer.Close(); } }
/// <summary> /// Writes the /// </summary> private bool WriteTemplate_DataType(Template template, Context context) { DataType datatype = context.Target as DataType; if (datatype == null) { return(false); } template.AddReplacement("_TypeName_", datatype.QName.Name); CreateDescription(template, "_Description_", datatype.Documentation); ComplexType complexType = datatype as ComplexType; if (complexType != null) { List <FieldType> fields = new List <FieldType>(); GetFields(complexType, fields); AddTemplate( template, "<!-- ListOfFields -->", TemplatePath + "Field.xml", fields, new LoadTemplateEventHandler(LoadTemplate_Field), null); } EnumeratedType enumeratedType = datatype as EnumeratedType; if (enumeratedType != null) { uint lengthInBits = 32; bool isOptionSet = false; List <EnumeratedValue> values = new List <EnumeratedValue>(enumeratedType.Value); if (enumeratedType.IsOptionSet) { isOptionSet = true; var baseType = Validator.ResolveType(enumeratedType.BaseType); if (baseType != null) { switch (baseType.Name) { case "SByte": { lengthInBits = 8; break; } case "Byte": { lengthInBits = 8; break; } case "Int16": { lengthInBits = 16; break; } case "UInt16": { lengthInBits = 16; break; } case "Int32": { lengthInBits = 32; break; } case "UInt32": { lengthInBits = 32; break; } case "Int64": { lengthInBits = 64; break; } case "UInt64": { lengthInBits = 64; break; } } } values.Add(new EnumeratedValue() { Name = "None", Value = 0, ValueSpecified = true }); } template.AddReplacement("_LengthInBits_", lengthInBits); template.AddReplacement("_IsOptionSet_", (isOptionSet) ? " IsOptionSet=\"true\"" : ""); AddTemplate( template, "<!-- ListOfValues -->", TemplatePath + "EnumeratedValue.xml", values, new LoadTemplateEventHandler(LoadTemplate_EnumeratedValue), null); } ServiceType serviceType = datatype as ServiceType; if (serviceType != null) { AddTemplate( template, "<!-- ListOfRequestParameters -->", TemplatePath + "Field.xml", serviceType.Request, new LoadTemplateEventHandler(LoadTemplate_Field), null); AddTemplate( template, "<!-- ListOfResponseParameters -->", TemplatePath + "Field.xml", serviceType.Response, new LoadTemplateEventHandler(LoadTemplate_Field), null); } return(template.WriteTemplate(context)); }
/// <summary> /// Writes the /// </summary> private bool WriteTemplate_DataType(Template template, Context context) { DataType datatype = context.Target as DataType; if (datatype == null) { return(false); } template.AddReplacement("_TypeName_", datatype.QName.Name); CreateDescription(template, "_Description_", datatype.Documentation); ComplexType complexType = datatype as ComplexType; if (complexType != null) { List <FieldType> fields = new List <FieldType>(); GetFields(complexType, fields); AddTemplate( template, "<!-- ListOfFields -->", TemplatePath + "Field.xml", fields, new LoadTemplateEventHandler(LoadTemplate_Field), null); } EnumeratedType enumeratedType = datatype as EnumeratedType; if (enumeratedType != null) { AddTemplate( template, "<!-- ListOfValues -->", TemplatePath + "EnumeratedValue.xml", enumeratedType.Value, new LoadTemplateEventHandler(LoadTemplate_EnumeratedValue), null); } ServiceType serviceType = datatype as ServiceType; if (serviceType != null) { AddTemplate( template, "<!-- ListOfRequestParameters -->", TemplatePath + "Field.xml", serviceType.Request, new LoadTemplateEventHandler(LoadTemplate_Field), null); AddTemplate( template, "<!-- ListOfResponseParameters -->", TemplatePath + "Field.xml", serviceType.Response, new LoadTemplateEventHandler(LoadTemplate_Field), null); } return(template.WriteTemplate(context)); }
private void WriteTemplate_EnumsImplementation(string namespacePrefix, string dictionaryNam) { // get datatypes. List <DataType> datatypes = GetDataTypeList(null, m_exportAll, false); if (datatypes.Count == 0) { return; } // sort types to ensure types are declared in the correct order. List <DataType> sortedTypes = new List <DataType>(); foreach (DataType datatype in datatypes) { AddDataType(datatype, sortedTypes); } datatypes = sortedTypes; string fileName = String.Format(@"{0}\{1}_enumparser.c", OutputDirectory, namespacePrefix); fileName = fileName.ToLower(); StreamWriter writer = new StreamWriter(fileName, false); writer.Write(string.Format(m_sHeader, "OpcUa Enum Type Parser", DateTime.Now)); writer.Write("#ifdef HAVE_CONFIG_H\n" + "# include \"config.h\"\n" + "#endif\n" + "\n" + "#include <gmodule.h>\n" + "#include <epan/packet.h>\n\n" + "#include \"opcua_enumparser.h\"\n\n"); try { foreach (DataType datatype in sortedTypes) { EnumeratedType enumtype = datatype as EnumeratedType; if (enumtype != null) { Template template = new Template(writer, WiresharkTemplatePath + "enumparser.c", Assembly.GetExecutingAssembly()); template.AddReplacement("_NAME_", enumtype.Name); AddTemplate( template, "// _ENTRY_", WiresharkTemplatePath + "enumparser.c", enumtype.Value, null, new WriteTemplateEventHandler(WriteTemplate_Enum)); template.WriteTemplate(null); } } writer.Write("\n/** header field definitions */\n" + "static hf_register_info hf[] =\n" + "{"); int index = 0; int count = 0; // count number of enums foreach (DataType datatype in sortedTypes) { EnumeratedType enumtype = datatype as EnumeratedType; if (enumtype != null) { count++; } } // generate code foreach (DataType datatype in sortedTypes) { EnumeratedType enumtype = datatype as EnumeratedType; if (enumtype != null) { Template template = new Template(writer, WiresharkTemplatePath + "enumregisterinfo.c", Assembly.GetExecutingAssembly()); template.AddReplacement("_NAME_", enumtype.Name); template.WriteTemplate(null); if ((index + 1) < count) { writer.Write(","); } index++; } } writer.Write("\n};\n\n"); writer.Write("/** Register enum types. */\n"); writer.Write("void registerEnumTypes(int proto)\n"); writer.Write("{\n"); writer.Write(" proto_register_field_array(proto, hf, array_length(hf));\n"); writer.Write("}\n"); } finally { writer.Close(); } }
private void WriteTemplate_ComplexTypesImplementation(string namespacePrefix, string dictionaryNam) { // get datatypes. List <DataType> datatypes = GetDataTypeList(null, m_exportAll, false); if (datatypes.Count == 0) { return; } // sort types to ensure types are declared in the correct order. List <DataType> sortedTypes = new List <DataType>(); foreach (DataType datatype in datatypes) { AddDataType(datatype, sortedTypes); } datatypes = sortedTypes; string fileName = String.Format(@"{0}\{1}_complextypeparser.c", OutputDirectory, namespacePrefix); fileName = fileName.ToLower(); List <string> list = new List <string>(); StreamWriter writer = new StreamWriter(fileName, false); writer.Write(string.Format(m_sHeader, "OpcUa Complex Type Parser", DateTime.Now)); writer.Write("#ifdef HAVE_CONFIG_H\n" + "# include \"config.h\"\n" + "#endif\n" + "\n" + "#include <gmodule.h>\n" + "#include <epan/packet.h>\n" + "#include \"opcua_complextypeparser.h\"\n" + "#include \"opcua_enumparser.h\"\n" + "#include \"opcua_simpletypes.h\"\n" + "#include \"opcua_hfindeces.h\"\n\n"); try { foreach (DataType datatype in sortedTypes) { ComplexType complextype = datatype as ComplexType; if (complextype != null) { Template template = new Template(writer, WiresharkTemplatePath + "complexparserfunction.c", Assembly.GetExecutingAssembly()); list.Add(complextype.Name); template.AddReplacement("_NAME_", complextype.Name); if (complextype.BaseType == null) { template.AddReplacement("// _BASE_", ""); } else { template.AddReplacement("// _BASE_", string.Format(" /* parse base class members */ \n parse{0}(subtree, tvb, pOffset, \"[{0}]\");\n /* parse additional members */", complextype.BaseType.Name)); } AddTemplate( template, "// _FIELDS_", WiresharkTemplatePath + "complexparserfunction.c", complextype.Field, null, new WriteTemplateEventHandler(WriteTemplate_Parser)); template.WriteTemplate(null); } } } finally { writer.Write("\n/** Setup protocol subtree array */\n" + "static gint *ett[] =\n{\n"); foreach (string sName in list) { writer.Write(" &ett_opcua_" + sName + ",\n"); } writer.Write("};\n\n"); writer.Write("void registerComplexTypes()\n" + "{\n" + " proto_register_subtree_array(ett, array_length(ett));\n" + "}\n\n"); writer.Close(); } }
/// <summary> /// Writes the nodes that describe a data type or method. /// </summary> private bool WriteTemplate_DataType(Template template, Context context) { DataType datatype = context.Target as DataType; if (datatype == null) { return(false); } template.AddReplacement("_TypeName_", datatype.QName.Name); template.AddReplacement("_DictionaryName_", m_dictionaryName); if (datatype.NotInAddressSpace) { template.AddReplacement(" NotInAddressSpace=\"false\"", " NotInAddressSpace=\"true\""); } else { template.AddReplacement(" NotInAddressSpace=\"false\"", ""); } if (!datatype.AllowArrays) { template.AddReplacement(" NoArraysAllowed=\"false\"", " NoArraysAllowed=\"true\""); } else { template.AddReplacement(" NoArraysAllowed=\"false\"", ""); } TypeDeclaration declaration = datatype as TypeDeclaration; if (declaration != null) { DataType sourceType = Validator.ResolveType(declaration.SourceType); if (sourceType != null) { template.AddReplacement("_BaseType_", GetPrefixedName(sourceType.QName)); } } ComplexType complexType = datatype as ComplexType; if (complexType != null) { if (!IsNull(complexType.BaseType)) { template.AddReplacement("_BaseType_", GetPrefixedName(complexType.BaseType)); } else { template.AddReplacement("_BaseType_", "ua:Structure"); } AddTemplate( template, "<!-- ListOfFields -->", TemplatePath + "DataType.xml", new ComplexType[] { complexType }, new LoadTemplateEventHandler(LoadTemplate_ComplexTypeFields), null); } EnumeratedType enumeratedType = datatype as EnumeratedType; if (enumeratedType != null) { if (enumeratedType != null) { template.AddReplacement("_BaseType_", "ua:Enumeration"); } else { template.AddReplacement("_BaseType_", "ua:BaseDataType"); } AddTemplate( template, "<!-- ListOfFields -->", TemplatePath + "DataType.xml", new EnumeratedType[] { enumeratedType }, new LoadTemplateEventHandler(LoadTemplate_EnumeratedTypeValues), null); } ServiceType serviceType = datatype as ServiceType; if (serviceType != null) { ComplexType requestType = new ComplexType(); requestType.Name = String.Format("{0}Request", serviceType.Name); requestType.QName = new XmlQualifiedName(requestType.Name, serviceType.QName.Namespace); requestType.Field = serviceType.Request; requestType.NotInAddressSpace = true; AddTemplate( template, "<!-- Request -->", TemplatePath + "DataType.xml", new ComplexType[] { requestType }, new LoadTemplateEventHandler(LoadTemplate_DataType), new WriteTemplateEventHandler(WriteTemplate_DataType)); ComplexType responseType = new ComplexType(); responseType.Name = String.Format("{0}Response", serviceType.Name); responseType.QName = new XmlQualifiedName(responseType.Name, serviceType.QName.Namespace); responseType.Field = serviceType.Response; responseType.NotInAddressSpace = true; AddTemplate( template, "<!-- Response -->", TemplatePath + "DataType.xml", new ComplexType[] { responseType }, new LoadTemplateEventHandler(LoadTemplate_DataType), new WriteTemplateEventHandler(WriteTemplate_DataType)); } return(template.WriteTemplate(context)); }
/// <summary> /// Writes the address space declaration file. /// </summary> private void WriteTemplate_Constants(string namespacePrefix, string className, List <DataType> datatypes) { m_className = className; // assign identifiers. foreach (DataType datatype in datatypes) { Constant constant = datatype as Constant; if (constant != null) { if (constant.Name.StartsWith(Severity.Bad.ToString())) { constant.Severity = Severity.Bad; } if (constant.Name.StartsWith(Severity.Good.ToString())) { constant.Severity = Severity.Good; } if (constant.Name.StartsWith(Severity.Uncertain.ToString())) { constant.Severity = Severity.Uncertain; } } } string fileName = null; switch (TargetLanguage) { case Language.DotNet: { fileName = String.Format(@"{0}\{1}.{2}.cs", OutputDirectory, namespacePrefix, className); m_templateSuffix = ".cs"; break; } case Language.AnsiC: { fileName = String.Format(@"{0}\{1}_{2}.h", OutputDirectory, namespacePrefix, className); fileName = fileName.ToLower(); m_templateSuffix = ".h"; break; } case Language.CSV: { fileName = String.Format(@"{0}\{1}.{2}.csv", OutputDirectory, namespacePrefix, className); m_templateSuffix = ".csv"; break; } } StreamWriter writer = new StreamWriter(fileName, false); try { string templatePath = TemplatePath + "Constants.File" + m_templateSuffix; if (className == "Identifiers") { templatePath = TemplatePath + "Constants.DataTypes" + m_templateSuffix; } Template template = new Template(writer, templatePath, Assembly.GetExecutingAssembly()); template.AddReplacement("_Date_", DateTime.Now); template.AddReplacement("_Prefix_", namespacePrefix); template.AddReplacement("_ClassName_", className); template.AddReplacement("_FileName_", namespacePrefix + '_' + className); AddTemplate( template, "// ListOfIdentifiers", TemplatePath + "Constants.Constant" + m_templateSuffix, datatypes, new LoadTemplateEventHandler(LoadTemplate_Constant), new WriteTemplateEventHandler(WriteTemplate_Constant)); AddTemplate( template, "// ListOfEncodings", TemplatePath + "Constants.Constant" + m_templateSuffix, datatypes, new LoadTemplateEventHandler(LoadTemplate_Constant), new WriteTemplateEventHandler(WriteTemplate_Constant)); Context context = new Context(); context.BlankLine = TargetLanguage != Language.CSV; template.WriteTemplate(context); } finally { writer.Close(); } }
/// <summary> /// Writes a constant. /// </summary> private bool WriteTemplate_Constant(Template template, Context context) { DataType datatype = context.Target as DataType; if (datatype == null) { return(false); } Constant constant = context.Target as Constant; if (constant != null) { if (!String.IsNullOrEmpty(constant.Value)) { template.AddReplacement("_IdType_", "string"); template.AddReplacement("_Identifier_", String.Format("\"{0}\"", constant.Value)); template.AddReplacement("_ClassName_", "_" + m_className); } else { if (constant.Severity != Severity.None) { context.BlankLine = TargetLanguage != Language.CSV; uint id = Convert.ToUInt32(constant.Identifier); id <<= 16; switch (constant.Severity) { case Severity.Bad: { id += 0x80000000; break; } case Severity.Uncertain: { id += 0x40000000; break; } } template.AddReplacement("_IdType_", "uint"); template.AddReplacement("_Identifier_", String.Format("0x{0:X8}", id)); template.AddReplacement("_ClassName_", String.Empty); } else { template.AddReplacement("_IdType_", "uint"); template.AddReplacement("_Identifier_", constant.Identifier); template.AddReplacement("_ClassName_", "_" + m_className); } } } string symbolicId = datatype.Name; if (constant != null) { if (constant.Severity != Severity.None) { string name = datatype.Name; int index = name.IndexOf('_'); if (index != -1) { name = name.Substring(index + 1); } symbolicId = String.Format("{0}{1}", constant.Severity, name); } } else { template.AddReplacement("_IdType_", "uint"); template.AddReplacement("_Identifier_", datatype.Identifier); template.AddReplacement("_ClassName_", "Id"); } template.AddReplacement("_SymbolicId_", symbolicId); string description = GetDescription(datatype.Documentation); if (String.IsNullOrEmpty(description)) { description = String.Format("The identifier for the {0} datatype.", symbolicId); } template.AddReplacement("_Description_", description); ComplexType complexType = context.Target as ComplexType; if (complexType != null) { template.AddReplacement("_XmlEncodingId_", complexType.XmlEncodingId); template.AddReplacement("_BinaryEncodingId_", complexType.BinaryEncodingId); } return(template.WriteTemplate(context)); }
/// <summary> /// Writes a datatype to the stream. /// </summary> private bool WriteTemplate_DataType(Template template, Context context) { DataType datatype = context.Target as DataType; if (datatype == null) { return(false); } template.AddReplacement("_TypeName_", datatype.QName.Name); CreateDescription(template, "_Description_", datatype.Documentation); AddTemplate( template, "<!-- ArrayDeclaration -->", TemplatePath + "Array.xml", new DataType[] { datatype }, null, new WriteTemplateEventHandler(WriteTemplate_Array)); ComplexType complexType = datatype as ComplexType; if (complexType != null) { if (!IsNull(complexType.BaseType)) { DataType basetype = Validator.ResolveType(complexType.BaseType); if (basetype == null) { throw new ApplicationException(String.Format("Could not find base type '{0}' for complex type '{1}'.", complexType.BaseType, complexType.QName)); } template.AddReplacement("_BaseType_", GetXmlSchemaTypeName(basetype.QName, -1)); } AddTemplate( template, "<!-- ListOfFields -->", TemplatePath + "Field.xml", complexType.Field, new LoadTemplateEventHandler(LoadTemplate_Field), null); } EnumeratedType enumeratedType = datatype as EnumeratedType; if (enumeratedType != null) { AddTemplate( template, "<!-- ListOfValues -->", TemplatePath + "EnumeratedValue.xml", enumeratedType.Value, new LoadTemplateEventHandler(LoadTemplate_EnumeratedValue), null); } ServiceType serviceType = datatype as ServiceType; if (serviceType != null) { AddTemplate( template, "<!-- ListOfRequestParameters -->", TemplatePath + "Field.xml", serviceType.Request, new LoadTemplateEventHandler(LoadTemplate_Field), null); AddTemplate( template, "<!-- ListOfResponseParameters -->", TemplatePath + "Field.xml", serviceType.Response, new LoadTemplateEventHandler(LoadTemplate_Field), null); } return(template.WriteTemplate(context)); }