XmlQualifiedName ExportTypeMapping(TypeMapping mapping, string ns) { if (mapping is ArrayMapping) { return(ExportArrayMapping((ArrayMapping)mapping, ns)); } else if (mapping is EnumMapping) { return(ExportEnumMapping((EnumMapping)mapping, ns)); } else if (mapping is PrimitiveMapping) { PrimitiveMapping pm = (PrimitiveMapping)mapping; if (pm.TypeDesc.IsXsdType) { return(ExportPrimitiveMapping(pm)); } else { return(ExportNonXsdPrimitiveMapping(pm, ns)); } } else if (mapping is StructMapping) { return(ExportStructMapping((StructMapping)mapping, ns)); } else if (mapping is MembersMapping) { return(ExportMembersMapping((MembersMapping)mapping, ns)); } else { throw new ArgumentException(Res.GetString(Res.XmlInternalError), "mapping"); } }
internal TypeMapping GetDefaultMapping(TypeFlags flags) { PrimitiveMapping mapping = new PrimitiveMapping(); mapping.TypeDesc = Scope.GetTypeDesc("string", XmlSchema.Namespace, flags); mapping.TypeName = mapping.TypeDesc.DataType.Name; mapping.Namespace = XmlSchema.Namespace; return mapping; }
private XmlQualifiedName ExportTypeMapping(TypeMapping mapping, string ns) { if (mapping is ArrayMapping) { return(this.ExportArrayMapping((ArrayMapping)mapping, ns)); } if (mapping is EnumMapping) { return(this.ExportEnumMapping((EnumMapping)mapping, ns)); } if (mapping is PrimitiveMapping) { PrimitiveMapping mapping2 = (PrimitiveMapping)mapping; if (mapping2.TypeDesc.IsXsdType) { return(this.ExportPrimitiveMapping(mapping2)); } return(this.ExportNonXsdPrimitiveMapping(mapping2, ns)); } if (mapping is StructMapping) { return(this.ExportStructMapping((StructMapping)mapping, ns)); } if (mapping is NullableMapping) { return(this.ExportTypeMapping(((NullableMapping)mapping).BaseMapping, ns)); } if (!(mapping is MembersMapping)) { throw new ArgumentException(Res.GetString("XmlInternalError"), "mapping"); } return(this.ExportMembersMapping((MembersMapping)mapping, ns)); }
private PrimitiveMapping ImportPrimitiveMapping(PrimitiveModel model, string dataType) { PrimitiveMapping mapping = new PrimitiveMapping { IsSoap = true }; if (dataType.Length > 0) { mapping.TypeDesc = this.typeScope.GetTypeDesc(dataType, "http://www.w3.org/2001/XMLSchema"); if (mapping.TypeDesc == null) { mapping.TypeDesc = this.typeScope.GetTypeDesc(dataType, "http://microsoft.com/wsdl/types/"); if (mapping.TypeDesc == null) { throw new InvalidOperationException(Res.GetString("XmlUdeclaredXsdType", new object[] { dataType })); } } } else { mapping.TypeDesc = model.TypeDesc; } mapping.TypeName = mapping.TypeDesc.DataType.Name; mapping.Namespace = mapping.TypeDesc.IsXsdType ? "http://www.w3.org/2001/XMLSchema" : "http://microsoft.com/wsdl/types/"; return(mapping); }
private PrimitiveMapping ImportPrimitiveMapping(PrimitiveModel model, string dataType) { PrimitiveMapping mapping = new PrimitiveMapping(); mapping.IsSoap = true; if (dataType.Length > 0) { mapping.TypeDesc = _typeScope.GetTypeDesc(dataType, XmlSchema.Namespace); if (mapping.TypeDesc == null) { // try it as a non-Xsd type mapping.TypeDesc = _typeScope.GetTypeDesc(dataType, UrtTypes.Namespace); if (mapping.TypeDesc == null) { throw new InvalidOperationException(SR.Format(SR.XmlUdeclaredXsdType, dataType)); } } } else { mapping.TypeDesc = model.TypeDesc; } mapping.TypeName = mapping.TypeDesc.DataType.Name; mapping.Namespace = mapping.TypeDesc.IsXsdType ? XmlSchema.Namespace : UrtTypes.Namespace; return(mapping); }
PrimitiveMapping ImportPrimitiveMapping(PrimitiveModel model, string dataType) { PrimitiveMapping mapping = new PrimitiveMapping(); mapping.IsSoap = true; if (dataType.Length > 0) { mapping.TypeDesc = typeScope.GetTypeDesc(new XmlQualifiedName(dataType, XmlSchema.Namespace)); if (mapping.TypeDesc == null) { // try it as a non-Xsd type mapping.TypeDesc = typeScope.GetTypeDesc(new XmlQualifiedName(dataType, UrtTypes.Namespace)); if (mapping.TypeDesc == null) { throw new InvalidOperationException(Res.GetString(Res.XmlUdeclaredXsdType, dataType)); } } } else { mapping.TypeDesc = model.TypeDesc; } mapping.TypeName = mapping.TypeDesc.DataType.Name; mapping.Namespace = mapping.TypeDesc.IsXsdType ? XmlSchema.Namespace : UrtTypes.Namespace; if (mapping.TypeDesc.IsXsdType && mapping.TypeName == "hexBinary") { throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedSoapTypeKind, mapping.TypeName)); } return(mapping); }
private object ImportDefaultValue(TypeMapping mapping, string defaultValue) { if (defaultValue == null) { return(null); } if (mapping is PrimitiveMapping) { if (mapping is EnumMapping) { EnumMapping mapping2 = (EnumMapping)mapping; ConstantMapping[] constants = mapping2.Constants; if (mapping2.IsFlags) { Hashtable vals = new Hashtable(); string[] strArray = new string[constants.Length]; long[] ids = new long[constants.Length]; for (int j = 0; j < constants.Length; j++) { ids[j] = mapping2.IsFlags ? (((long)1L) << j) : ((long)j); strArray[j] = constants[j].Name; vals.Add(constants[j].Name, ids[j]); } return(XmlCustomFormatter.FromEnum(XmlCustomFormatter.ToEnum(defaultValue, vals, mapping2.TypeName, true), strArray, ids, mapping2.TypeDesc.FullName)); } for (int i = 0; i < constants.Length; i++) { if (constants[i].XmlName == defaultValue) { return(constants[i].Name); } } throw new InvalidOperationException(Res.GetString("XmlInvalidDefaultValue", new object[] { defaultValue, mapping2.TypeDesc.FullName })); } PrimitiveMapping mapping3 = (PrimitiveMapping)mapping; if (!mapping3.TypeDesc.HasCustomFormatter) { if (mapping3.TypeDesc.FormatterName == "String") { return(defaultValue); } if (mapping3.TypeDesc.FormatterName == "DateTime") { return(XmlCustomFormatter.ToDateTime(defaultValue)); } Type type = typeof(XmlConvert); MethodInfo method = type.GetMethod("To" + mapping3.TypeDesc.FormatterName, new Type[] { typeof(string) }); if (method != null) { return(method.Invoke(type, new object[] { defaultValue })); } } else if (mapping3.TypeDesc.HasDefaultSupport) { return(XmlCustomFormatter.ToDefaultValue(defaultValue, mapping3.TypeDesc.FormatterName)); } } return(DBNull.Value); }
private TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, bool isList) { TypeMapping mapping = (TypeMapping)base.ImportedMappings[dataType]; if (mapping != null) { return(mapping); } XmlSchemaSimpleType type = this.FindDataType(dataType.DerivedFrom); TypeDesc typeDesc = base.Scope.GetTypeDesc(type); if ((typeDesc != null) && (typeDesc != base.Scope.GetTypeDesc(typeof(string)))) { return(this.ImportPrimitiveDataType(dataType)); } identifier = Accessor.UnescapeName(identifier); string name = base.GenerateUniqueTypeName(identifier); EnumMapping mapping2 = new EnumMapping { IsReference = base.Schemas.IsReference(dataType), TypeDesc = new TypeDesc(name, name, TypeKind.Enum, null, TypeFlags.None), TypeName = identifier, Namespace = typeNs, IsFlags = isList }; CodeIdentifiers identifiers = new CodeIdentifiers(); if (!(dataType.Content is XmlSchemaSimpleTypeRestriction)) { throw new InvalidOperationException(Res.GetString("XmlInvalidEnumContent", new object[] { dataType.Content.GetType().Name, identifier })); } XmlSchemaSimpleTypeRestriction content = (XmlSchemaSimpleTypeRestriction)dataType.Content; for (int i = 0; i < content.Facets.Count; i++) { object obj2 = content.Facets[i]; if (obj2 is XmlSchemaEnumerationFacet) { XmlSchemaEnumerationFacet facet = (XmlSchemaEnumerationFacet)obj2; ConstantMapping mapping3 = new ConstantMapping(); string str2 = CodeIdentifier.MakeValid(facet.Value); mapping3.Name = identifiers.AddUnique(str2, mapping3); mapping3.XmlName = facet.Value; mapping3.Value = i; } } mapping2.Constants = (ConstantMapping[])identifiers.ToArray(typeof(ConstantMapping)); if (isList && (mapping2.Constants.Length > 0x3f)) { mapping = new PrimitiveMapping { TypeDesc = base.Scope.GetTypeDesc(typeof(string)), TypeName = mapping.TypeDesc.DataType.Name }; base.ImportedMappings.Add(dataType, mapping); return(mapping); } base.ImportedMappings.Add(dataType, mapping2); base.Scope.AddTypeMapping(mapping2); return(mapping2); }
private PrimitiveMapping ImportPrimitiveDataType(XmlSchemaSimpleType dataType) { TypeDesc sourceTypeDesc = GetDataTypeSource(dataType); PrimitiveMapping mapping = new PrimitiveMapping(); mapping.TypeDesc = sourceTypeDesc; mapping.TypeName = sourceTypeDesc.DataType.Name; return(mapping); }
XmlQualifiedName ExportNonXsdPrimitiveMapping(PrimitiveMapping mapping, string ns) { XmlSchemaSimpleType type = mapping.TypeDesc.DataType; if (!SchemaContainsItem(type, UrtTypes.Namespace)) { AddSchemaItem(type, UrtTypes.Namespace, ns); } return(new XmlQualifiedName(mapping.TypeDesc.DataType.Name, UrtTypes.Namespace)); }
private XmlQualifiedName ExportNonXsdPrimitiveMapping(PrimitiveMapping mapping, string ns) { XmlSchemaType dataType = mapping.TypeDesc.DataType; if (!this.SchemaContainsItem(dataType, "http://microsoft.com/wsdl/types/")) { this.AddSchemaItem(dataType, "http://microsoft.com/wsdl/types/", ns); } else { this.AddSchemaImport("http://microsoft.com/wsdl/types/", ns); } return(new XmlQualifiedName(mapping.TypeDesc.DataType.Name, "http://microsoft.com/wsdl/types/")); }
PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType) { PrimitiveMapping mapping = null; TypeDesc typeDesc = null; if (dataType.Name != null && dataType.Name.Length != 0) { typeDesc = scope.GetTypeDesc(new XmlQualifiedName(dataType.Name, UrtTypes.Namespace)); if (typeDesc != null) { mapping = new PrimitiveMapping(); mapping.TypeDesc = typeDesc; mapping.TypeName = typeDesc.DataType.Name; } } return(mapping); }
private PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType, string ns) { PrimitiveMapping mapping = null; TypeDesc typeDesc = null; if (dataType.Name != null && dataType.Name.Length != 0) { typeDesc = Scope.GetTypeDesc(dataType.Name, ns); if (typeDesc != null) { mapping = new PrimitiveMapping(); mapping.TypeDesc = typeDesc; mapping.TypeName = typeDesc.DataType.Name; } } return(mapping); }
private PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType, string ns) { PrimitiveMapping mapping = null; TypeDesc typeDesc = null; if ((dataType.Name != null) && (dataType.Name.Length != 0)) { typeDesc = base.Scope.GetTypeDesc(dataType.Name, ns); if (typeDesc != null) { mapping = new PrimitiveMapping { TypeDesc = typeDesc, TypeName = typeDesc.DataType.Name }; } } return(mapping); }
TypeMapping ImportDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier) { TypeMapping mapping = ImportNonXsdPrimitiveDataType(dataType); if (mapping != null) { return(mapping); } if (dataType.Content is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)dataType.Content; foreach (object o in restriction.Facets) { if (o is XmlSchemaEnumerationFacet) { return(ImportEnumeratedDataType(dataType, typeNs, identifier)); } } } else if (dataType.Content is XmlSchemaSimpleTypeList || dataType.Content is XmlSchemaSimpleTypeUnion) { if (dataType.Content is XmlSchemaSimpleTypeList) { // check if we have enumeration list XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)dataType.Content; if (list.ItemType != null) { mapping = ImportDataType(list.ItemType, typeNs, identifier); if (mapping != null && mapping is EnumMapping) { ((EnumMapping)mapping).IsFlags = true; return(mapping); } } } mapping = new PrimitiveMapping(); mapping.TypeDesc = scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; return(mapping); } return(ImportPrimitiveDataType(dataType)); }
private void WriteText(object o, TextAccessor text) { if (text.Mapping is PrimitiveMapping) { PrimitiveMapping mapping = (PrimitiveMapping)text.Mapping; string stringValue; if (text.Mapping is EnumMapping) { stringValue = WriteEnumMethod((EnumMapping)mapping, o); } else { if (!WritePrimitiveValue(mapping.TypeDesc, o, false, out stringValue)) { // #10593: Add More Tests for Serialization Code Debug.Assert(o is byte[]); } } if (o is byte[]) { WriteValue((byte[])o); } else { WriteValue(stringValue); } } else if (text.Mapping is SpecialMapping) { SpecialMapping mapping = (SpecialMapping)text.Mapping; switch (mapping.TypeDesc.Kind) { case TypeKind.Node: ((XmlNode)o).WriteTo(Writer); break; default: throw new InvalidOperationException(SR.Format(SR.XmlInternalError)); } } }
XmlQualifiedName ExportPrimitiveMapping(PrimitiveMapping mapping, string ns) { XmlQualifiedName qname; if (mapping is EnumMapping) { qname = ExportEnumMapping((EnumMapping)mapping, ns); } else { if (mapping.TypeDesc.IsXsdType) { qname = new XmlQualifiedName(mapping.TypeDesc.DataType.Name, XmlSchema.Namespace); } else { qname = ExportNonXsdPrimitiveMapping(mapping, ns); } } return(qname); }
private ArrayMapping ImportArrayMapping(XmlSchemaType type, string ns) { ArrayMapping mapping; if ((type.Name == "Array") && (ns == "http://schemas.xmlsoap.org/soap/encoding/")) { mapping = new ArrayMapping(); TypeMapping rootMapping = base.GetRootMapping(); ElementAccessor accessor = new ElementAccessor { IsSoap = true, Name = "anyType", Namespace = ns, Mapping = rootMapping, IsNullable = true, Form = XmlSchemaForm.None }; mapping.Elements = new ElementAccessor[] { accessor }; mapping.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc(); mapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(accessor.Mapping.TypeName); return(mapping); } if ((type.DerivedFrom.Name != "Array") || (type.DerivedFrom.Namespace != "http://schemas.xmlsoap.org/soap/encoding/")) { return(null); } XmlSchemaContentModel contentModel = ((XmlSchemaComplexType)type).ContentModel; if (!(contentModel.Content is XmlSchemaComplexContentRestriction)) { return(null); } mapping = new ArrayMapping(); XmlSchemaComplexContentRestriction content = (XmlSchemaComplexContentRestriction)contentModel.Content; for (int i = 0; i < content.Attributes.Count; i++) { XmlSchemaAttribute parent = content.Attributes[i] as XmlSchemaAttribute; if (((parent != null) && (parent.RefName.Name == "arrayType")) && (parent.RefName.Namespace == "http://schemas.xmlsoap.org/soap/encoding/")) { string str = null; if (parent.UnhandledAttributes != null) { foreach (XmlAttribute attribute2 in parent.UnhandledAttributes) { if ((attribute2.LocalName == "arrayType") && (attribute2.NamespaceURI == "http://schemas.xmlsoap.org/wsdl/")) { str = attribute2.Value; break; } } } if (str != null) { string str2; TypeMapping mapping3; XmlQualifiedName name = TypeScope.ParseWsdlArrayType(str, out str2, parent); TypeDesc typeDesc = base.Scope.GetTypeDesc(name.Name, name.Namespace); if ((typeDesc != null) && typeDesc.IsPrimitive) { mapping3 = new PrimitiveMapping { TypeDesc = typeDesc, TypeName = typeDesc.DataType.Name }; } else { mapping3 = this.ImportType(name, false); } ElementAccessor accessor2 = new ElementAccessor { IsSoap = true, Name = name.Name, Namespace = ns, Mapping = mapping3, IsNullable = true, Form = XmlSchemaForm.None }; mapping.Elements = new ElementAccessor[] { accessor2 }; mapping.TypeDesc = accessor2.Mapping.TypeDesc.CreateArrayTypeDesc(); mapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(accessor2.Mapping.TypeName); return(mapping); } } } XmlSchemaParticle particle = content.Particle; if (!(particle is XmlSchemaAll) && !(particle is XmlSchemaSequence)) { return(null); } XmlSchemaGroupBase base2 = (XmlSchemaGroupBase)particle; if ((base2.Items.Count != 1) || !(base2.Items[0] is XmlSchemaElement)) { return(null); } XmlSchemaElement element = (XmlSchemaElement)base2.Items[0]; if (!element.IsMultipleOccurrence) { return(null); } ElementAccessor accessor3 = this.ImportElement(element, ns); mapping.Elements = new ElementAccessor[] { accessor3 }; mapping.TypeDesc = accessor3.Mapping.TypeDesc.CreateArrayTypeDesc(); return(mapping); }
private AttributeAccessor ImportSpecialAttribute(XmlQualifiedName name, string identifier) { PrimitiveMapping mapping; mapping = new PrimitiveMapping { TypeDesc = base.Scope.GetTypeDesc(typeof(string)), TypeName = mapping.TypeDesc.DataType.Name }; AttributeAccessor accessor = new AttributeAccessor { Name = name.Name, Namespace = "http://www.w3.org/XML/1998/namespace" }; accessor.CheckSpecial(); accessor.Mapping = mapping; return accessor; }
XmlQualifiedName ExportPrimitiveMapping(PrimitiveMapping mapping) { return(new XmlQualifiedName(mapping.TypeDesc.DataType.Name, XmlSchema.Namespace)); }
XmlQualifiedName ExportPrimitiveMapping(PrimitiveMapping mapping, string ns) { XmlQualifiedName qname; if (mapping is EnumMapping) { XmlSchemaType type = ExportEnumMapping((EnumMapping)mapping, ns); qname = new XmlQualifiedName(type.Name, mapping.Namespace); } else { if (mapping.TypeDesc.IsXsdType) { qname = new XmlQualifiedName(mapping.TypeDesc.DataType.Name, XmlSchema.Namespace); } else { qname = ExportNonXsdPrimitiveMapping(mapping, ns); } } return qname; }
XmlQualifiedName ExportNonXsdPrimitiveMapping(PrimitiveMapping mapping, string ns) { XmlSchemaSimpleType type = (XmlSchemaSimpleType)mapping.TypeDesc.DataType; if (!SchemaContainsItem(type, UrtTypes.Namespace)) { AddSchemaItem(type, UrtTypes.Namespace, ns); } else { AddSchemaImport(mapping.Namespace, ns); } return new XmlQualifiedName(mapping.TypeDesc.DataType.Name, UrtTypes.Namespace); }
static internal string ExportDefaultValue(TypeMapping mapping, object value) { #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (!(mapping is PrimitiveMapping)) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Mapping " + mapping.GetType() + ", should not have Default")); } else if (mapping.IsList) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Mapping " + mapping.GetType() + ", should not have Default")); } #endif if (mapping is EnumMapping) { EnumMapping em = (EnumMapping)mapping; #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (value.GetType() != typeof(string)) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, Res.GetString(Res.XmlInvalidDefaultValue, value.ToString(), value.GetType().FullName))); } #endif // check the validity of the value ConstantMapping[] c = em.Constants; if (em.IsFlags) { string[] names = new string[c.Length]; long[] ids = new long[c.Length]; Hashtable values = new Hashtable(); for (int i = 0; i < c.Length; i++) { names[i] = c[i].XmlName; ids[i] = 1 << i; values.Add(c[i].Name, ids[i]); } long val = XmlCustomFormatter.ToEnum((string)value, values, em.TypeName, false); return(val != 0 ? XmlCustomFormatter.FromEnum(val, names, ids) : null); } else { for (int i = 0; i < c.Length; i++) { if (c[i].Name == (string)value) { return(c[i].XmlName); } } return(null); // unknown value } } PrimitiveMapping pm = (PrimitiveMapping)mapping; if (!pm.TypeDesc.HasCustomFormatter) { #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (pm.TypeDesc.Type == null) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Mapping for " + pm.TypeDesc.Name + " missing type property")); } #endif if (pm.TypeDesc.FormatterName == "String") { return((string)value); } Type formatter = typeof(XmlConvert); System.Reflection.MethodInfo format = formatter.GetMethod("ToString", new Type[] { pm.TypeDesc.Type }); if (format != null) { return((string)format.Invoke(formatter, new Object[] { value })); } } else { string defaultValue = XmlCustomFormatter.FromDefaultValue(value, pm.TypeDesc.FormatterName); if (defaultValue == null) { throw new InvalidOperationException(Res.GetString(Res.XmlInvalidDefaultValue, value.ToString(), pm.TypeDesc.Name)); } return(defaultValue); } throw new InvalidOperationException(Res.GetString(Res.XmlInvalidDefaultValue, value.ToString(), pm.TypeDesc.Name)); }
private void AddDefaultValueAttribute(CodeMemberField field, CodeAttributeDeclarationCollection metadata, object defaultValue, TypeMapping mapping, CodeCommentStatementCollection comments, TypeDesc memberTypeDesc, Accessor accessor, CodeConstructor ctor) { string str = accessor.IsFixed ? "fixed" : "default"; if (!memberTypeDesc.HasDefaultSupport) { if ((comments != null) && (defaultValue is string)) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropAttributeValue", new object[] { str, mapping.TypeName, defaultValue.ToString() })); } } else if (memberTypeDesc.IsArrayLike && (accessor is ElementAccessor)) { if ((comments != null) && (defaultValue is string)) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropArrayAttributeValue", new object[] { str, defaultValue.ToString(), ((ElementAccessor)accessor).Name })); } } else if ((mapping.TypeDesc.IsMappedType && (field != null)) && (defaultValue is string)) { SchemaImporterExtension extension = mapping.TypeDesc.ExtendedType.Extension; CodeExpression init = extension.ImportDefaultValue((string)defaultValue, mapping.TypeDesc.FullName); if (init != null) { if (ctor != null) { AddInitializationStatement(ctor, field, init); } else { field.InitExpression = extension.ImportDefaultValue((string)defaultValue, mapping.TypeDesc.FullName); } } if (comments != null) { DropDefaultAttribute(accessor, comments, mapping.TypeDesc.FullName); if (init == null) { CodeExporter.AddWarningComment(comments, Res.GetString("XmlNotKnownDefaultValue", new object[] { extension.GetType().FullName, str, (string)defaultValue, mapping.TypeName, mapping.Namespace })); } } } else { object obj2 = null; if ((defaultValue is string) || (defaultValue == null)) { obj2 = this.ImportDefault(mapping, (string)defaultValue); } if (obj2 != null) { if (!(mapping is PrimitiveMapping)) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropNonPrimitiveAttributeValue", new object[] { str, defaultValue.ToString() })); } else { PrimitiveMapping mapping2 = (PrimitiveMapping)mapping; if (((comments != null) && !mapping2.TypeDesc.HasDefaultSupport) && mapping2.TypeDesc.IsMappedType) { DropDefaultAttribute(accessor, comments, mapping2.TypeDesc.FullName); } else if (obj2 == DBNull.Value) { if (comments != null) { CodeExporter.AddWarningComment(comments, Res.GetString("XmlDropAttributeValue", new object[] { str, mapping2.TypeName, defaultValue.ToString() })); } } else { CodeAttributeArgument[] arguments = null; CodeExpression initExpression = null; if (mapping2.IsList) { object[] objArray = (object[])obj2; CodeExpression[] initializers = new CodeExpression[objArray.Length]; for (int i = 0; i < objArray.Length; i++) { this.GetDefaultValueArguments(mapping2, objArray[i], out initializers[i]); } initExpression = new CodeArrayCreateExpression(field.Type, initializers); } else { arguments = this.GetDefaultValueArguments(mapping2, obj2, out initExpression); } if (field != null) { if (ctor != null) { AddInitializationStatement(ctor, field, initExpression); } else { field.InitExpression = initExpression; } } if (((arguments != null) && mapping2.TypeDesc.HasDefaultSupport) && (accessor.IsOptional && !accessor.IsFixed)) { CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(typeof(DefaultValueAttribute).FullName, arguments); metadata.Add(declaration); } else if (comments != null) { DropDefaultAttribute(accessor, comments, memberTypeDesc.FullName); } } } } } }
private XmlQualifiedName ExportPrimitiveMapping(PrimitiveMapping mapping) { return(new XmlQualifiedName(mapping.TypeDesc.DataType.Name, "http://www.w3.org/2001/XMLSchema")); }
private PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType, string ns, TypeFlags flags) { PrimitiveMapping mapping = null; TypeDesc typeDesc = null; if (dataType.Name != null && dataType.Name.Length != 0) { typeDesc = Scope.GetTypeDesc(dataType.Name, ns, flags); if (typeDesc != null) { mapping = new PrimitiveMapping(); mapping.TypeDesc = typeDesc; mapping.TypeName = typeDesc.DataType.Name; mapping.Namespace = mapping.TypeDesc.IsXsdType ? XmlSchema.Namespace : ns; } } return mapping; }
private PrimitiveMapping ImportPrimitiveDataType(XmlSchemaSimpleType dataType, TypeFlags flags) { TypeDesc sourceTypeDesc = GetDataTypeSource(dataType, flags); PrimitiveMapping mapping = new PrimitiveMapping(); mapping.TypeDesc = sourceTypeDesc; mapping.TypeName = sourceTypeDesc.DataType.Name; mapping.Namespace = mapping.TypeDesc.IsXsdType ? XmlSchema.Namespace : UrtTypes.Namespace; return mapping; }
XmlQualifiedName ExportPrimitiveMapping(PrimitiveMapping mapping) { return new XmlQualifiedName(mapping.TypeDesc.DataType.Name, XmlSchema.Namespace); }
private PrimitiveMapping ImportPrimitiveMapping(PrimitiveModel model, ImportContext context, string dataType, bool repeats) { PrimitiveMapping mapping = new PrimitiveMapping(); if (dataType.Length > 0) { mapping.TypeDesc = this.typeScope.GetTypeDesc(dataType, "http://www.w3.org/2001/XMLSchema"); if (mapping.TypeDesc == null) { mapping.TypeDesc = this.typeScope.GetTypeDesc(dataType, "http://microsoft.com/wsdl/types/"); if (mapping.TypeDesc == null) { throw new InvalidOperationException(Res.GetString("XmlUdeclaredXsdType", new object[] { dataType })); } } } else { mapping.TypeDesc = model.TypeDesc; } mapping.TypeName = mapping.TypeDesc.DataType.Name; mapping.Namespace = mapping.TypeDesc.IsXsdType ? "http://www.w3.org/2001/XMLSchema" : "http://microsoft.com/wsdl/types/"; mapping.IsList = repeats; this.CheckContext(mapping.TypeDesc, context); return mapping; }
PrimitiveMapping ImportPrimitiveMapping(PrimitiveModel model, ImportContext context, string dataType, bool repeats) { PrimitiveMapping mapping = new PrimitiveMapping(); if (dataType.Length > 0) { mapping.TypeDesc = typeScope.GetTypeDesc(new XmlQualifiedName(dataType, XmlSchema.Namespace)); if (mapping.TypeDesc == null) { // try it as a non-Xsd type mapping.TypeDesc = typeScope.GetTypeDesc(new XmlQualifiedName(dataType, UrtTypes.Namespace)); if (mapping.TypeDesc == null) { throw new InvalidOperationException(Res.GetString(Res.XmlUdeclaredXsdType, dataType)); } } } else { mapping.TypeDesc = model.TypeDesc; } mapping.TypeName = mapping.TypeDesc.DataType.Name; mapping.IsList = repeats; CheckContext(mapping.TypeDesc, context); return mapping; }
private CodeAttributeArgument[] GetDefaultValueArguments(PrimitiveMapping mapping, object value, out CodeExpression initExpression) { initExpression = null; if (value == null) { return(null); } CodeExpression left = null; CodeExpression expression2 = null; Type type = value.GetType(); CodeAttributeArgument[] argumentArray = null; if (mapping is EnumMapping) { if (((EnumMapping)mapping).IsFlags) { string[] strArray = ((string)value).Split(null); for (int i = 0; i < strArray.Length; i++) { if (strArray[i].Length != 0) { CodeExpression right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), strArray[i]); if (left != null) { left = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BitwiseOr, right); } else { left = right; } } } } else { left = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), (string)value); } initExpression = left; argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(left) }; } else if (((type == typeof(bool)) || (type == typeof(int))) || ((type == typeof(string)) || (type == typeof(double)))) { initExpression = left = new CodePrimitiveExpression(value); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(left) }; } else if (((type == typeof(short)) || (type == typeof(long))) || (((type == typeof(float)) || (type == typeof(byte))) || (type == typeof(decimal)))) { left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (((type == typeof(sbyte)) || (type == typeof(ushort))) || ((type == typeof(uint)) || (type == typeof(ulong)))) { value = CodeExporter.PromoteType(type, value); left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (type == typeof(DateTime)) { string str; long ticks; DateTime time = (DateTime)value; if (mapping.TypeDesc.FormatterName == "Date") { str = XmlCustomFormatter.FromDate(time); DateTime time2 = new DateTime(time.Year, time.Month, time.Day); ticks = time2.Ticks; } else if (mapping.TypeDesc.FormatterName == "Time") { str = XmlCustomFormatter.FromDateTime(time); ticks = time.Ticks; } else { str = XmlCustomFormatter.FromDateTime(time); ticks = time.Ticks; } left = new CodePrimitiveExpression(str); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(DateTime)), new CodeExpression[] { new CodePrimitiveExpression(ticks) }); } else if (type == typeof(Guid)) { left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(Guid)), new CodeExpression[] { left }); } if ((mapping.TypeDesc.FullName != type.ToString()) && !(mapping is EnumMapping)) { initExpression = new CodeCastExpression(mapping.TypeDesc.FullName, initExpression); } return(argumentArray); }
AttributeAccessor ImportSpecialAttribute(XmlQualifiedName name, string identifier) { PrimitiveMapping mapping = new PrimitiveMapping(); mapping.TypeDesc = scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; AttributeAccessor accessor = new AttributeAccessor(); accessor.Name = name.Name; accessor.Namespace = XmlReservedNs.NsXml; accessor.CheckSpecial(); accessor.Mapping = mapping; return accessor; }
void ExportAttributeAccessor(XmlSchemaComplexType type, AttributeAccessor accessor, bool valueTypeOptional, string ns) { if (accessor == null) { return; } XmlSchemaObjectCollection attributes; if (type.ContentModel != null) { if (type.ContentModel.Content is XmlSchemaComplexContentRestriction) { attributes = ((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Attributes; } else if (type.ContentModel.Content is XmlSchemaComplexContentExtension) { attributes = ((XmlSchemaComplexContentExtension)type.ContentModel.Content).Attributes; } else if (type.ContentModel.Content is XmlSchemaSimpleContentExtension) { attributes = ((XmlSchemaSimpleContentExtension)type.ContentModel.Content).Attributes; } else { throw new InvalidOperationException(Res.GetString(Res.XmlInvalidContent, type.ContentModel.Content.GetType().Name)); } } else { attributes = type.Attributes; } if (accessor.IsSpecialXmlNamespace) { // add <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> AddSchemaImport(XmlReservedNs.NsXml, ns); // generate <xsd:attribute ref="xml:lang" use="optional" /> XmlSchemaAttribute attribute = new XmlSchemaAttribute(); attribute.Use = XmlSchemaUse.Optional; attribute.RefName = new XmlQualifiedName(accessor.Name, XmlReservedNs.NsXml); attributes.Add(attribute); } else if (accessor.Any) { if (type.ContentModel == null) { type.AnyAttribute = new XmlSchemaAnyAttribute(); } else { XmlSchemaContent content = type.ContentModel.Content; if (content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content; extension.AnyAttribute = new XmlSchemaAnyAttribute(); } else if (content is XmlSchemaComplexContentRestriction) { XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)content; restriction.AnyAttribute = new XmlSchemaAnyAttribute(); } } } else { XmlSchemaAttribute attribute = new XmlSchemaAttribute(); attribute.Use = XmlSchemaUse.None; if (!accessor.HasDefault && !valueTypeOptional && accessor.Mapping.TypeDesc.IsValueType) { attribute.Use = XmlSchemaUse.Required; } attribute.Name = accessor.Name; if (accessor.Namespace == null || accessor.Namespace == ns) { // determine the form attribute value XmlSchema schema = schemas[ns]; if (schema == null) { attribute.Form = accessor.Form == attributeFormDefault ? XmlSchemaForm.None : accessor.Form; } else { attribute.Form = accessor.Form == schema.AttributeFormDefault ? XmlSchemaForm.None : accessor.Form; } attributes.Add(attribute); } else { // we are going to add the attribute to the top-level items. "use" attribute should not be set attribute.Use = XmlSchemaUse.None; attribute.Form = accessor.Form; AddSchemaItem(attribute, accessor.Namespace, ns); XmlSchemaAttribute refAttribute = new XmlSchemaAttribute(); refAttribute.Use = XmlSchemaUse.None; refAttribute.RefName = new XmlQualifiedName(accessor.Name, accessor.Namespace); attributes.Add(refAttribute); } if (accessor.Mapping is PrimitiveMapping) { PrimitiveMapping pm = (PrimitiveMapping)accessor.Mapping; if (pm.IsList) { // create local simple type for the list-like attributes XmlSchemaSimpleType dataType = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); list.ItemTypeName = ExportPrimitiveMapping(pm, accessor.Namespace == null ? ns : accessor.Namespace); dataType.Content = list; attribute.SchemaType = dataType; } else { attribute.SchemaTypeName = ExportPrimitiveMapping(pm, accessor.Namespace == null ? ns : accessor.Namespace); } } else if (!(accessor.Mapping is SpecialMapping)) { throw new InvalidOperationException(Res.GetString(Res.XmlInternalError)); } if (accessor.HasDefault && accessor.Mapping.TypeDesc.HasDefaultSupport) { attribute.DefaultValue = ExportDefaultValue(accessor.Mapping, accessor.Default); } } }
AttributeAccessor ImportAttribute(XmlSchemaAttribute attribute, string identifier, string ns) { if (attribute.Use == XmlSchemaUse.Prohibited) return null; if (!attribute.RefName.IsEmpty) { if (attribute.RefName.Namespace == XmlReservedNs.NsXml) return ImportSpecialAttribute(attribute.RefName, identifier); else return ImportAttribute(FindAttribute(attribute.RefName), identifier, attribute.RefName.Namespace); } TypeMapping mapping; if (attribute.Name.Length == 0) throw new InvalidOperationException(Res.GetString(Res.XmlAttributeHasNoName)); if (identifier.Length == 0) identifier = CodeIdentifier.MakeValid(attribute.Name); else identifier += CodeIdentifier.MakePascal(attribute.Name); if (!attribute.SchemaTypeName.IsEmpty) mapping = (TypeMapping)ImportType(attribute.SchemaTypeName, typeof(TypeMapping), null); else if (attribute.SchemaType != null) mapping = ImportDataType((XmlSchemaSimpleType)attribute.SchemaType, ns, identifier, null); else { mapping = new PrimitiveMapping(); mapping.TypeDesc = scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; } AttributeAccessor accessor = new AttributeAccessor(); accessor.Name = attribute.Name; accessor.Namespace = ns; if (attribute.Form == XmlSchemaForm.None) { XmlSchema schema = schemas[ns]; if (schema != null) accessor.Form = schema.AttributeFormDefault; } else { accessor.Form = attribute.Form; } accessor.CheckSpecial(); accessor.Mapping = mapping; accessor.IsList = mapping.IsList; if (attribute.DefaultValue != null) { accessor.Default = ImportDefaultValue(mapping, attribute.DefaultValue); } else if (attribute.FixedValue != null) { accessor.Default = ImportDefaultValue(mapping, attribute.FixedValue); } return accessor; }
void ExportTypeMembers(XmlSchemaComplexType type, MemberMapping[] members, string name, string ns, bool hasSimpleContent) { XmlSchemaGroupBase seq = new XmlSchemaSequence(); TypeMapping textMapping = null; for (int i = 0; i < members.Length; i++) { MemberMapping member = members[i]; if (member.Ignore) { continue; } if (member.Text != null) { if (textMapping != null) { throw new InvalidOperationException(Res.GetString(Res.XmlIllegalMultipleText, name)); } textMapping = member.Text.Mapping; } if (member.Elements.Length > 0) { bool repeats = member.TypeDesc.IsArrayLike && !(member.Elements.Length == 1 && member.Elements[0].Mapping is ArrayMapping); bool valueTypeOptional = member.CheckSpecified || member.CheckShouldPersist; ExportElementAccessors(seq, member.Elements, repeats, valueTypeOptional, ns); } } if (seq.Items.Count > 0) { if (type.ContentModel != null) { if (type.ContentModel.Content is XmlSchemaComplexContentRestriction) { ((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Particle = seq; } else if (type.ContentModel.Content is XmlSchemaComplexContentExtension) { ((XmlSchemaComplexContentExtension)type.ContentModel.Content).Particle = seq; } else { throw new InvalidOperationException(Res.GetString(Res.XmlInvalidContent, type.ContentModel.Content.GetType().Name)); } } else { type.Particle = seq; } } if (textMapping != null) { if (hasSimpleContent) { if (textMapping is PrimitiveMapping && seq.Items.Count == 0) { PrimitiveMapping pm = (PrimitiveMapping)textMapping; if (pm.IsList) { type.IsMixed = true; } else { // Create simpleContent XmlSchemaSimpleContent model = new XmlSchemaSimpleContent(); XmlSchemaSimpleContentExtension ex = new XmlSchemaSimpleContentExtension(); model.Content = ex; type.ContentModel = model; ex.BaseTypeName = ExportPrimitiveMapping(pm, ns); } } } else { type.IsMixed = true; } } for (int i = 0; i < members.Length; i++) { ExportAttributeAccessor(type, members[i].Attribute, members[i].CheckSpecified || members[i].CheckShouldPersist, ns); } }
private void WriteElement(object o, ElementAccessor element, string arrayName, bool writeAccessor, XmlMapping parentMapping = null) { string name = writeAccessor ? element.Name : element.Mapping.TypeName; string ns = element.Any && element.Name.Length == 0 ? null : (element.Form == XmlSchemaForm.Qualified ? (writeAccessor ? element.Namespace : element.Mapping.Namespace) : ""); if (element.Mapping is NullableMapping) { if (o != null) { ElementAccessor e = element.Clone(); e.Mapping = ((NullableMapping)element.Mapping).BaseMapping; WriteElement(o, e, arrayName, writeAccessor); } else if (element.IsNullable) { WriteNullTagLiteral(element.Name, ns); } } else if (element.Mapping is ArrayMapping) { var mapping = (ArrayMapping)element.Mapping; if (mapping.IsSoap) { throw new PlatformNotSupportedException(); } if (element.IsNullable && o == null) { WriteNullTagLiteral(element.Name, element.Form == XmlSchemaForm.Qualified ? element.Namespace : ""); } else { if (element.IsUnbounded) { TypeDesc arrayTypeDesc = mapping.TypeDesc.CreateArrayTypeDesc(); var enumerable = (IEnumerable)o; foreach (var e in enumerable) { element.IsUnbounded = false; WriteElement(e, element, arrayName, writeAccessor); element.IsUnbounded = true; } } else { if (o != null) { WriteStartElement(name, ns, false); WriteArrayItems(mapping.ElementsSortedByDerivation, null, null, mapping.TypeDesc, o); WriteEndElement(); } } } } else if (element.Mapping is EnumMapping) { if (element.Mapping.IsSoap) { Writer.WriteStartElement(name, ns); WriteEnumMethod((EnumMapping)element.Mapping, o); WriteEndElement(); } else { WritePrimitive(WritePrimitiveMethodRequirement.WriteElementString, name, ns, element.Default, o, element.Mapping, false, true, element.IsNullable); } } else if (element.Mapping is PrimitiveMapping) { PrimitiveMapping mapping = (PrimitiveMapping)element.Mapping; if (mapping.TypeDesc == QnameTypeDesc) { WriteQualifiedNameElement(name, ns, element.Default, (XmlQualifiedName)o, element.IsNullable, mapping.IsSoap, mapping); } else { WritePrimitiveMethodRequirement suffixNullable = mapping.IsSoap ? WritePrimitiveMethodRequirement.Encoded : WritePrimitiveMethodRequirement.None; WritePrimitiveMethodRequirement suffixRaw = mapping.TypeDesc.XmlEncodingNotRequired ? WritePrimitiveMethodRequirement.Raw : WritePrimitiveMethodRequirement.None; WritePrimitive(element.IsNullable ? WritePrimitiveMethodRequirement.WriteNullableStringLiteral | suffixNullable | suffixRaw : WritePrimitiveMethodRequirement.WriteElementString | suffixRaw, name, ns, element.Default, o, mapping, mapping.IsSoap, true, element.IsNullable); } } else if (element.Mapping is StructMapping) { var mapping = (StructMapping)element.Mapping; if (mapping.IsSoap) { EnsureXmlSerializationWriteCallbackForMapping(mapping, name, ns, element.IsNullable, needType: false, parentMapping: parentMapping); WritePotentiallyReferencingElement(name, ns, o, !writeAccessor ? mapping.TypeDesc.Type : null, !writeAccessor, element.IsNullable); } else { WriteStructMethod(mapping, name, ns, o, element.IsNullable, needType: false, parentMapping: parentMapping); } } else if (element.Mapping is SpecialMapping) { if (element.Mapping is SerializableMapping) { WriteSerializable((IXmlSerializable)o, name, ns, element.IsNullable, !element.Any); } else { // XmlNode, XmlElement var node = o as XmlNode; if (node != null) { WriteElementLiteral(node, name, ns, element.IsNullable, element.Any); } else { throw CreateInvalidAnyTypeException(o); } } } else { throw new InvalidOperationException(SR.XmlInternalError); } }
XmlSchemaType ExportAnonymousPrimitiveMapping(PrimitiveMapping mapping) { if (mapping is EnumMapping) { return ExportEnumMapping((EnumMapping)mapping, null); } else { throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Unsuported anonymous mapping type: " + mapping.ToString())); } }
private XmlSchemaType ExportAnonymousPrimitiveMapping(PrimitiveMapping mapping) { if (!(mapping is EnumMapping)) { throw new InvalidOperationException(Res.GetString("XmlInternalErrorDetails", new object[] { "Unsuported anonymous mapping type: " + mapping.ToString() })); } return this.ExportEnumMapping((EnumMapping) mapping, null); }
private void WriteQualifiedNameElement(string name, string ns, object defaultValue, XmlQualifiedName o, bool nullable, bool isSoap, PrimitiveMapping mapping) { bool hasDefault = defaultValue != null && !Globals.IsDBNullValue(defaultValue) && mapping.TypeDesc.HasDefaultSupport; if (hasDefault && IsDefaultValue(mapping, o, defaultValue, nullable)) return; if (isSoap) { throw new PlatformNotSupportedException(); } if (nullable) { WriteNullableQualifiedNameLiteral(name, ns, o); } else { WriteElementQualifiedName(name, ns, o); } }
private XmlQualifiedName ExportPrimitiveMapping(PrimitiveMapping mapping, string ns) { if (mapping is EnumMapping) { return new XmlQualifiedName(this.ExportEnumMapping((EnumMapping) mapping, ns).Name, mapping.Namespace); } if (mapping.TypeDesc.IsXsdType) { return new XmlQualifiedName(mapping.TypeDesc.DataType.Name, "http://www.w3.org/2001/XMLSchema"); } return this.ExportNonXsdPrimitiveMapping(mapping, ns); }
private TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, bool isList) { TypeMapping mapping = (TypeMapping)ImportedMappings[dataType]; if (mapping != null) { return(mapping); } XmlSchemaSimpleType sourceDataType = FindDataType(dataType.DerivedFrom); TypeDesc sourceTypeDesc = Scope.GetTypeDesc(sourceDataType); if (sourceTypeDesc != null && sourceTypeDesc != Scope.GetTypeDesc(typeof(string))) { return(ImportPrimitiveDataType(dataType)); } identifier = Accessor.UnescapeName(identifier); string typeName = GenerateUniqueTypeName(identifier); EnumMapping enumMapping = new EnumMapping(); enumMapping.IsReference = Schemas.IsReference(dataType); enumMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Enum, null, 0); enumMapping.TypeName = identifier; enumMapping.Namespace = typeNs; enumMapping.IsFlags = isList; CodeIdentifiers constants = new CodeIdentifiers(); if (!(dataType.Content is XmlSchemaSimpleTypeRestriction)) { throw new InvalidOperationException(SR.Format(SR.XmlInvalidEnumContent, dataType.Content.GetType().Name, identifier)); } XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)dataType.Content; for (int i = 0; i < restriction.Facets.Count; i++) { object facet = restriction.Facets[i]; if (!(facet is XmlSchemaEnumerationFacet)) { continue; } XmlSchemaEnumerationFacet enumeration = (XmlSchemaEnumerationFacet)facet; ConstantMapping constant = new ConstantMapping(); string constantName = CodeIdentifier.MakeValid(enumeration.Value); constant.Name = constants.AddUnique(constantName, constant); constant.XmlName = enumeration.Value; constant.Value = i; } enumMapping.Constants = (ConstantMapping[])constants.ToArray(typeof(ConstantMapping)); if (isList && enumMapping.Constants.Length > 63) { // if we have 64+ flag constants we cannot map the type to long enum, we will use string mapping instead. mapping = new PrimitiveMapping(); mapping.TypeDesc = Scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; ImportedMappings.Add(dataType, mapping); return(mapping); } ImportedMappings.Add(dataType, enumMapping); Scope.AddTypeMapping(enumMapping); return(enumMapping); }
private PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType, string ns, TypeFlags flags) { PrimitiveMapping mapping = null; TypeDesc desc = null; if ((dataType.Name != null) && (dataType.Name.Length != 0)) { desc = base.Scope.GetTypeDesc(dataType.Name, ns, flags); if (desc != null) { mapping = new PrimitiveMapping { TypeDesc = desc, TypeName = desc.DataType.Name, Namespace = mapping.TypeDesc.IsXsdType ? "http://www.w3.org/2001/XMLSchema" : ns }; } } return mapping; }
private void WriteQualifiedNameElement(string name, string ns, object defaultValue, XmlQualifiedName o, bool nullable, bool isSoap, PrimitiveMapping mapping) { bool hasDefault = defaultValue != null && !Globals.IsDBNullValue(defaultValue) && mapping.TypeDesc.HasDefaultSupport; if (hasDefault && IsDefaultValue(mapping, o, defaultValue, nullable)) { return; } if (isSoap) { throw new PlatformNotSupportedException(); } if (nullable) { WriteNullableQualifiedNameLiteral(name, ns, o); } else { WriteElementQualifiedName(name, ns, o); } }
TypeMapping ImportDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, bool isList) { TypeMapping mapping = ImportNonXsdPrimitiveDataType(dataType, typeNs); if (mapping != null) return mapping; if (dataType.Content is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)dataType.Content; foreach (object o in restriction.Facets) { if (o is XmlSchemaEnumerationFacet) { return ImportEnumeratedDataType(dataType, typeNs, identifier, isList); } } } else if (dataType.Content is XmlSchemaSimpleTypeList || dataType.Content is XmlSchemaSimpleTypeUnion) { if (dataType.Content is XmlSchemaSimpleTypeList) { // check if we have enumeration list XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)dataType.Content; if (list.ItemType != null) { mapping = ImportDataType(list.ItemType, typeNs, identifier, true); if (mapping != null) { return mapping; } } } mapping = new PrimitiveMapping(); mapping.TypeDesc = Scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; return mapping; } return ImportPrimitiveDataType(dataType); }
private XmlQualifiedName ExportNonXsdPrimitiveMapping(PrimitiveMapping mapping, string ns) { XmlSchemaSimpleType dataType = (XmlSchemaSimpleType) mapping.TypeDesc.DataType; if (!this.SchemaContainsItem(dataType, "http://microsoft.com/wsdl/types/")) { this.AddSchemaItem(dataType, "http://microsoft.com/wsdl/types/", ns); } else { this.AddSchemaImport(mapping.Namespace, ns); } return new XmlQualifiedName(mapping.TypeDesc.DataType.Name, "http://microsoft.com/wsdl/types/"); }
PrimitiveMapping ImportPrimitiveDataType(XmlSchemaSimpleType dataType) { TypeDesc sourceTypeDesc = GetDataTypeSource(dataType); PrimitiveMapping mapping = new PrimitiveMapping(); mapping.TypeDesc = sourceTypeDesc; mapping.TypeName = sourceTypeDesc.DataType.Name; return mapping; }
private ArrayMapping ImportArrayMapping(XmlSchemaType type, string ns) { ArrayMapping arrayMapping; if (type.Name == Soap.Array && ns == Soap.Encoding) { arrayMapping = new ArrayMapping(); TypeMapping mapping = GetRootMapping(); ElementAccessor itemAccessor = new ElementAccessor(); itemAccessor.IsSoap = true; itemAccessor.Name = Soap.UrType; itemAccessor.Namespace = ns; itemAccessor.Mapping = mapping; itemAccessor.IsNullable = true; itemAccessor.Form = XmlSchemaForm.None; arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = itemAccessor.Mapping.TypeDesc.CreateArrayTypeDesc(); arrayMapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(itemAccessor.Mapping.TypeName); return(arrayMapping); } if (!(type.DerivedFrom.Name == Soap.Array && type.DerivedFrom.Namespace == Soap.Encoding)) { return(null); } // the type should be a XmlSchemaComplexType XmlSchemaContentModel model = ((XmlSchemaComplexType)type).ContentModel; // the Content should be an restriction if (!(model.Content is XmlSchemaComplexContentRestriction)) { return(null); } arrayMapping = new ArrayMapping(); XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)model.Content; for (int i = 0; i < restriction.Attributes.Count; i++) { XmlSchemaAttribute attribute = restriction.Attributes[i] as XmlSchemaAttribute; if (attribute != null && attribute.RefName.Name == Soap.ArrayType && attribute.RefName.Namespace == Soap.Encoding) { // read the value of the wsdl:arrayType attribute string arrayType = null; if (attribute.UnhandledAttributes != null) { foreach (XmlAttribute a in attribute.UnhandledAttributes) { if (a.LocalName == Wsdl.ArrayType && a.NamespaceURI == Wsdl.Namespace) { arrayType = a.Value; break; } } } if (arrayType != null) { string dims; XmlQualifiedName typeName = TypeScope.ParseWsdlArrayType(arrayType, out dims, attribute); TypeMapping mapping; TypeDesc td = Scope.GetTypeDesc(typeName.Name, typeName.Namespace); if (td != null && td.IsPrimitive) { mapping = new PrimitiveMapping(); mapping.TypeDesc = td; mapping.TypeName = td.DataType.Name; } else { mapping = ImportType(typeName, false); } ElementAccessor itemAccessor = new ElementAccessor(); itemAccessor.IsSoap = true; itemAccessor.Name = typeName.Name; itemAccessor.Namespace = ns; itemAccessor.Mapping = mapping; itemAccessor.IsNullable = true; itemAccessor.Form = XmlSchemaForm.None; arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = itemAccessor.Mapping.TypeDesc.CreateArrayTypeDesc(); arrayMapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(itemAccessor.Mapping.TypeName); return(arrayMapping); } } } XmlSchemaParticle particle = restriction.Particle; if (particle is XmlSchemaAll || particle is XmlSchemaSequence) { XmlSchemaGroupBase group = (XmlSchemaGroupBase)particle; if (group.Items.Count != 1 || !(group.Items[0] is XmlSchemaElement)) { return(null); } XmlSchemaElement itemElement = (XmlSchemaElement)group.Items[0]; if (!itemElement.IsMultipleOccurrence) { return(null); } ElementAccessor itemAccessor = ImportElement(itemElement, ns); arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = ((TypeMapping)itemAccessor.Mapping).TypeDesc.CreateArrayTypeDesc(); } else { return(null); } return(arrayMapping); }
private CodeAttributeArgument[] GetDefaultValueArguments(PrimitiveMapping mapping, object value, out CodeExpression initExpression) { initExpression = null; if (value == null) { return null; } CodeExpression left = null; CodeExpression expression2 = null; Type type = value.GetType(); CodeAttributeArgument[] argumentArray = null; if (mapping is EnumMapping) { if (((EnumMapping) mapping).IsFlags) { string[] strArray = ((string) value).Split(null); for (int i = 0; i < strArray.Length; i++) { if (strArray[i].Length != 0) { CodeExpression right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), strArray[i]); if (left != null) { left = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BitwiseOr, right); } else { left = right; } } } } else { left = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), (string) value); } initExpression = left; argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(left) }; } else if (((type == typeof(bool)) || (type == typeof(int))) || ((type == typeof(string)) || (type == typeof(double)))) { initExpression = left = new CodePrimitiveExpression(value); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(left) }; } else if (((type == typeof(short)) || (type == typeof(long))) || (((type == typeof(float)) || (type == typeof(byte))) || (type == typeof(decimal)))) { left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (((type == typeof(sbyte)) || (type == typeof(ushort))) || ((type == typeof(uint)) || (type == typeof(ulong)))) { value = CodeExporter.PromoteType(type, value); left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (type == typeof(DateTime)) { string str; long ticks; DateTime time = (DateTime) value; if (mapping.TypeDesc.FormatterName == "Date") { str = XmlCustomFormatter.FromDate(time); DateTime time2 = new DateTime(time.Year, time.Month, time.Day); ticks = time2.Ticks; } else if (mapping.TypeDesc.FormatterName == "Time") { str = XmlCustomFormatter.FromDateTime(time); ticks = time.Ticks; } else { str = XmlCustomFormatter.FromDateTime(time); ticks = time.Ticks; } left = new CodePrimitiveExpression(str); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(DateTime)), new CodeExpression[] { new CodePrimitiveExpression(ticks) }); } else if (type == typeof(Guid)) { left = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); expression2 = new CodeTypeOfExpression(type.FullName); argumentArray = new CodeAttributeArgument[] { new CodeAttributeArgument(expression2), new CodeAttributeArgument(left) }; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(Guid)), new CodeExpression[] { left }); } if ((mapping.TypeDesc.FullName != type.ToString()) && !(mapping is EnumMapping)) { initExpression = new CodeCastExpression(mapping.TypeDesc.FullName, initExpression); } return argumentArray; }
TypeMapping ImportDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, Type baseType) { if (baseType != null) return ImportStructDataType(dataType, typeNs, identifier, baseType); TypeMapping mapping = ImportNonXsdPrimitiveDataType(dataType); if (mapping != null) return mapping; if (dataType.Content is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)dataType.Content; foreach (object o in restriction.Facets) { if (o is XmlSchemaEnumerationFacet) { return ImportEnumeratedDataType(dataType, typeNs, identifier); } } } else if (dataType.Content is XmlSchemaSimpleTypeList || dataType.Content is XmlSchemaSimpleTypeUnion) { if (dataType.Content is XmlSchemaSimpleTypeList) { // check if we have enumeration list XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)dataType.Content; if (list.ItemType != null) { mapping = ImportDataType(list.ItemType, typeNs, identifier, null); if (mapping != null && mapping is EnumMapping) { ((EnumMapping)mapping).IsFlags = true; return mapping; } } else if (list.ItemTypeName != null && !list.ItemTypeName.IsEmpty) { mapping = ImportType(list.ItemTypeName, typeof(TypeMapping), null); if (mapping != null && mapping is PrimitiveMapping) { ((PrimitiveMapping)mapping).IsList = true; return mapping; } } } mapping = new PrimitiveMapping(); mapping.TypeDesc = scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; return mapping; } return ImportPrimitiveDataType(dataType); }
private XmlQualifiedName ExportPrimitiveMapping(PrimitiveMapping mapping) { return new XmlQualifiedName(mapping.TypeDesc.DataType.Name, "http://www.w3.org/2001/XMLSchema"); }
ArrayMapping ImportArrayMapping(XmlSchemaType type, string ns) { ArrayMapping arrayMapping; if (type.Name == Soap.Array && ns == Soap.Encoding) { arrayMapping = new ArrayMapping(); TypeMapping mapping = GetRootMapping(); ElementAccessor itemAccessor = new ElementAccessor(); itemAccessor.IsSoap = true; itemAccessor.Name = Soap.UrType; itemAccessor.Namespace = ns; itemAccessor.Mapping = mapping; itemAccessor.IsNullable = true; itemAccessor.Form = XmlSchemaForm.None; arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = itemAccessor.Mapping.TypeDesc.CreateArrayTypeDesc(); arrayMapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(itemAccessor.Mapping.TypeName); return arrayMapping; } if (!(type.DerivedFrom.Name == Soap.Array && type.DerivedFrom.Namespace == Soap.Encoding)) return null; // the type should be a XmlSchemaComplexType XmlSchemaContentModel model = ((XmlSchemaComplexType)type).ContentModel; // the Content should be an restriction if (!(model.Content is XmlSchemaComplexContentRestriction)) return null; arrayMapping = new ArrayMapping(); XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)model.Content; for (int i = 0; i < restriction.Attributes.Count; i++) { XmlSchemaAttribute attribute = restriction.Attributes[i] as XmlSchemaAttribute; if (attribute != null && attribute.RefName.Name == Soap.ArrayType && attribute.RefName.Namespace == Soap.Encoding) { // read the value of the wsdl:arrayType attribute string arrayType = null; if (attribute.UnhandledAttributes != null) { foreach (XmlAttribute a in attribute.UnhandledAttributes) { if (a.LocalName == Wsdl.ArrayType && a.NamespaceURI == Wsdl.Namespace) { arrayType = a.Value; break; } } } if (arrayType != null) { string dims; XmlQualifiedName typeName = TypeScope.ParseWsdlArrayType(arrayType, out dims, attribute); TypeMapping mapping; TypeDesc td = Scope.GetTypeDesc(typeName.Name, typeName.Namespace); if (td != null && td.IsPrimitive) { mapping = new PrimitiveMapping(); mapping.TypeDesc = td; mapping.TypeName = td.DataType.Name; } else { mapping = ImportType(typeName, false); } ElementAccessor itemAccessor = new ElementAccessor(); itemAccessor.IsSoap = true; itemAccessor.Name = typeName.Name; itemAccessor.Namespace = ns; itemAccessor.Mapping = mapping; itemAccessor.IsNullable = true; itemAccessor.Form = XmlSchemaForm.None; arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = itemAccessor.Mapping.TypeDesc.CreateArrayTypeDesc(); arrayMapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(itemAccessor.Mapping.TypeName); return arrayMapping; } } } XmlSchemaParticle particle = restriction.Particle; if (particle is XmlSchemaAll || particle is XmlSchemaSequence) { XmlSchemaGroupBase group = (XmlSchemaGroupBase)particle; if (group.Items.Count != 1 || !(group.Items[0] is XmlSchemaElement)) return null; XmlSchemaElement itemElement = (XmlSchemaElement)group.Items[0]; if (!itemElement.IsMultipleOccurrence) return null; ElementAccessor itemAccessor = ImportElement(itemElement, ns); arrayMapping.Elements = new ElementAccessor[] { itemAccessor }; arrayMapping.TypeDesc = ((TypeMapping)itemAccessor.Mapping).TypeDesc.CreateArrayTypeDesc(); } else { return null; } return arrayMapping; }
PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType) { PrimitiveMapping mapping = null; TypeDesc typeDesc = null; if (dataType.Name != null && dataType.Name.Length != 0) { typeDesc = scope.GetTypeDesc(new XmlQualifiedName(dataType.Name, UrtTypes.Namespace)); if (typeDesc != null) { mapping = new PrimitiveMapping(); mapping.TypeDesc = typeDesc; mapping.TypeName = typeDesc.DataType.Name; } } return mapping; }
TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, bool isList) { TypeMapping mapping = (TypeMapping)ImportedMappings[dataType]; if (mapping != null) return mapping; XmlSchemaSimpleType sourceDataType = FindDataType(dataType.DerivedFrom); TypeDesc sourceTypeDesc = Scope.GetTypeDesc(sourceDataType); if (sourceTypeDesc != null && sourceTypeDesc != Scope.GetTypeDesc(typeof(string))) return ImportPrimitiveDataType(dataType); identifier = Accessor.UnescapeName(identifier); string typeName = GenerateUniqueTypeName(identifier); EnumMapping enumMapping = new EnumMapping(); enumMapping.IsReference = Schemas.IsReference(dataType); enumMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Enum, null, 0); enumMapping.TypeName = identifier; enumMapping.Namespace = typeNs; enumMapping.IsFlags = isList; CodeIdentifiers constants = new CodeIdentifiers(); if (!(dataType.Content is XmlSchemaSimpleTypeRestriction)) throw new InvalidOperationException(Res.GetString(Res.XmlInvalidEnumContent, dataType.Content.GetType().Name, identifier)); XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)dataType.Content; for (int i = 0; i < restriction.Facets.Count; i++) { object facet = restriction.Facets[i]; if (!(facet is XmlSchemaEnumerationFacet)) continue; XmlSchemaEnumerationFacet enumeration = (XmlSchemaEnumerationFacet)facet; ConstantMapping constant = new ConstantMapping(); string constantName = CodeIdentifier.MakeValid(enumeration.Value); constant.Name = constants.AddUnique(constantName, constant); constant.XmlName = enumeration.Value; constant.Value = i; } enumMapping.Constants = (ConstantMapping[])constants.ToArray(typeof(ConstantMapping)); if (isList && enumMapping.Constants.Length > 63) { // if we have 64+ flag constants we cannot map the type to long enum, we will use string mapping instead. mapping = new PrimitiveMapping(); mapping.TypeDesc = Scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; ImportedMappings.Add(dataType, mapping); return mapping; } ImportedMappings.Add(dataType, enumMapping); Scope.AddTypeMapping(enumMapping); return enumMapping; }
void ImportTextMember(CodeIdentifiers members, XmlQualifiedName simpleContentType) { TypeMapping mapping; bool isMixed = false; if (simpleContentType != null) { mapping = ImportType(simpleContentType, typeof(TypeMapping), null); if (!(mapping is PrimitiveMapping || mapping.TypeDesc.CanBeTextValue)) { return; } } else { // this is a case of the mixed content type, just generate string typeDesc isMixed = true; mapping = new PrimitiveMapping(); mapping.TypeDesc = scope.GetTypeDesc(typeof(string)); mapping.TypeName = mapping.TypeDesc.DataType.Name; } TextAccessor accessor = new TextAccessor(); accessor.Mapping = mapping; MemberMapping member = new MemberMapping(); member.Elements = new ElementAccessor[0]; member.Text = accessor; if (isMixed) { // just generate code for the standard mixed case (string[] text) member.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc(); member.Name = members.MakeRightCase("Text"); } else { // import mapping for the simpleContent PrimitiveMapping pm = (PrimitiveMapping)accessor.Mapping; if (pm.IsList) { member.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc(); member.Name = members.MakeRightCase("Text"); } else { member.TypeDesc = accessor.Mapping.TypeDesc; member.Name = members.MakeRightCase("Value"); } } member.Name = members.AddUnique(member.Name, member); }
PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType, string ns) { PrimitiveMapping mapping = null; TypeDesc typeDesc = null; if (dataType.Name != null && dataType.Name.Length != 0) { typeDesc = Scope.GetTypeDesc(dataType.Name, ns); if (typeDesc != null) { mapping = new PrimitiveMapping(); mapping.TypeDesc = typeDesc; mapping.TypeName = typeDesc.DataType.Name; } } return mapping; }
CodeAttributeArgument[] GetDefaultValueArguments(PrimitiveMapping mapping, object value, out CodeExpression initExpression) { initExpression = null; if (value == null) return null; CodeExpression valueExpression = null; CodeExpression typeofValue = null; Type type = value.GetType(); CodeAttributeArgument[] arguments = null; if (mapping is EnumMapping) { #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (value.GetType() != typeof(string)) throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Invalid enumeration type " + value.GetType().Name)); #endif if (((EnumMapping)mapping).IsFlags) { string[] values = ((string)value).Split(null); for (int i = 0; i < values.Length; i++) { if (values[i].Length == 0) continue; CodeExpression enumRef = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), values[i]); if (valueExpression != null) valueExpression = new CodeBinaryOperatorExpression(valueExpression, CodeBinaryOperatorType.BitwiseOr, enumRef); else valueExpression = enumRef; } } else { valueExpression = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(mapping.TypeDesc.FullName), (string)value); } initExpression = valueExpression; arguments = new CodeAttributeArgument[] {new CodeAttributeArgument(valueExpression)}; } else if (type == typeof(bool) || type == typeof(Int32) || type == typeof(string) || type == typeof(double)) { initExpression = valueExpression = new CodePrimitiveExpression(value); arguments = new CodeAttributeArgument[] {new CodeAttributeArgument(valueExpression)}; } else if (type == typeof(Int16) || type == typeof(Int64) || type == typeof(float) || type == typeof(byte) || type == typeof(decimal)) { valueExpression = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); typeofValue = new CodeTypeOfExpression(type.FullName); arguments = new CodeAttributeArgument[] {new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression)}; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (type == typeof(sbyte) || type == typeof(UInt16) || type == typeof(UInt32) || type == typeof(UInt64)) { // need to promote the non-CLS complient types value = PromoteType(type, value); valueExpression = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); typeofValue = new CodeTypeOfExpression(type.FullName); arguments = new CodeAttributeArgument[] {new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression)}; initExpression = new CodeCastExpression(type.FullName, new CodePrimitiveExpression(value)); } else if (type == typeof(DateTime)) { DateTime dt = (DateTime)value; string dtString; long ticks; if (mapping.TypeDesc.FormatterName == "Date") { dtString = XmlCustomFormatter.FromDate(dt); ticks = (new DateTime(dt.Year, dt.Month, dt.Day)).Ticks; } else if (mapping.TypeDesc.FormatterName == "Time") { dtString = XmlCustomFormatter.FromDateTime(dt); ticks = dt.Ticks; } else { dtString = XmlCustomFormatter.FromDateTime(dt); ticks = dt.Ticks; } valueExpression = new CodePrimitiveExpression(dtString); typeofValue = new CodeTypeOfExpression(type.FullName); arguments = new CodeAttributeArgument[] {new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression)}; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(DateTime)), new CodeExpression[] {new CodePrimitiveExpression(ticks)}); } else if (type == typeof(Guid)) { valueExpression = new CodePrimitiveExpression(Convert.ToString(value, NumberFormatInfo.InvariantInfo)); typeofValue = new CodeTypeOfExpression(type.FullName); arguments = new CodeAttributeArgument[] {new CodeAttributeArgument(typeofValue), new CodeAttributeArgument(valueExpression)}; initExpression = new CodeObjectCreateExpression(new CodeTypeReference(typeof(Guid)), new CodeExpression[] {valueExpression}); } if (mapping.TypeDesc.FullName != type.ToString() && !(mapping is EnumMapping)) { // generate cast initExpression = new CodeCastExpression(mapping.TypeDesc.FullName, initExpression); } return arguments; }
PrimitiveMapping ImportPrimitiveMapping(PrimitiveModel model, string dataType) { PrimitiveMapping mapping = new PrimitiveMapping(); mapping.IsSoap = true; if (dataType.Length > 0) { mapping.TypeDesc = typeScope.GetTypeDesc(dataType, XmlSchema.Namespace); if (mapping.TypeDesc == null) { // try it as a non-Xsd type mapping.TypeDesc = typeScope.GetTypeDesc(dataType, UrtTypes.Namespace); if (mapping.TypeDesc == null) { throw new InvalidOperationException(Res.GetString(Res.XmlUdeclaredXsdType, dataType)); } } } else { mapping.TypeDesc = model.TypeDesc; } mapping.TypeName = mapping.TypeDesc.DataType.Name; mapping.Namespace = mapping.TypeDesc.IsXsdType ? XmlSchema.Namespace : UrtTypes.Namespace; return mapping; }
private PrimitiveMapping ImportNonXsdPrimitiveDataType(XmlSchemaSimpleType dataType, string ns) { PrimitiveMapping mapping = null; TypeDesc typeDesc = null; if ((dataType.Name != null) && (dataType.Name.Length != 0)) { typeDesc = base.Scope.GetTypeDesc(dataType.Name, ns); if (typeDesc != null) { mapping = new PrimitiveMapping { TypeDesc = typeDesc, TypeName = typeDesc.DataType.Name }; } } return mapping; }