internal CodeTypeDeclaration ExportEnum(EnumMapping mapping, Type type) { CodeTypeDeclaration codeClass = new CodeTypeDeclaration(mapping.TypeDesc.Name); codeClass.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true)); codeClass.IsEnum = true; if (mapping.IsFlags && mapping.Constants.Length > 31) { codeClass.BaseTypes.Add(new CodeTypeReference(typeof(long))); } codeClass.TypeAttributes |= TypeAttributes.Public; CodeNamespace.Types.Add(codeClass); for (int i = 0; i < mapping.Constants.Length; i++) { ExportConstant(codeClass, mapping.Constants[i], type, mapping.IsFlags, 1L << i); } if (mapping.IsFlags) { // Add [FlagsAttribute] CodeAttributeDeclaration flags = new CodeAttributeDeclaration(typeof(FlagsAttribute).FullName); codeClass.CustomAttributes.Add(flags); } CodeGenerator.ValidateIdentifiers(codeClass); return(codeClass); }
private string WriteEnumMethod(EnumMapping mapping, object v) { string returnString = null; if (mapping != null) { ConstantMapping[] constants = mapping.Constants; if (constants.Length > 0) { bool foundValue = false; var enumValue = Convert.ToInt64(v); for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; if (enumValue == c.Value) { returnString = c.XmlName; foundValue = true; break; } } if (!foundValue) { if (mapping.IsFlags) { string[] xmlNames = new string[constants.Length]; long[] valueIds = new long[constants.Length]; for (int i = 0; i < constants.Length; i++) { xmlNames[i] = constants[i].XmlName; valueIds[i] = constants[i].Value; } returnString = FromEnum(enumValue, xmlNames, valueIds); } else { throw CreateInvalidEnumValueException(v, mapping.TypeDesc.FullName); } } } } else { returnString = v.ToString(); } if (mapping.IsSoap) { WriteXsiType(mapping.TypeName, mapping.Namespace); Writer.WriteString(returnString); return(null); } else { return(returnString); } }
private string WriteEnumMethod(EnumMapping mapping, object v) { if (mapping != null && mapping.IsSoap) { throw new PlatformNotSupportedException(); } if (mapping != null && mapping.IsFlags) { Type type = mapping.TypeDesc.Type; List <string> valueStrings = new List <string>(); List <long> valueIds = new List <long>(); foreach (var value in Enum.GetValues(type)) { valueStrings.Add(value.ToString()); valueIds.Add(Convert.ToInt64(value)); } return(FromEnum(Convert.ToInt64(v), valueStrings.ToArray(), valueIds.ToArray())); } else { return(v.ToString()); } }
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 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); }
internal string GetStringForEnumCompare(EnumMapping mapping, string memberName, bool useReflection) { if (!useReflection) { CodeIdentifier.CheckValidIdentifier(memberName); return(mapping.TypeDesc.CSharpName + ".@" + memberName); } string variable = this.GetStringForEnumMember(mapping.TypeDesc.CSharpName, memberName, useReflection); return(this.GetStringForEnumLongValue(variable, useReflection)); }
private string FindChoiceEnumValue(ElementAccessor element, EnumMapping choiceMapping, bool useReflection) { string ident = null; for (int i = 0; i < choiceMapping.Constants.Length; i++) { string xmlName = choiceMapping.Constants[i].XmlName; if (element.Any && (element.Name.Length == 0)) { if (!(xmlName == "##any:")) { continue; } if (useReflection) { ident = choiceMapping.Constants[i].Value.ToString(CultureInfo.InvariantCulture); } else { ident = choiceMapping.Constants[i].Name; } break; } int length = xmlName.LastIndexOf(':'); string str3 = (length < 0) ? choiceMapping.Namespace : xmlName.Substring(0, length); string str4 = (length < 0) ? xmlName : xmlName.Substring(length + 1); if ((element.Name == str4) && (((element.Form == XmlSchemaForm.Unqualified) && string.IsNullOrEmpty(str3)) || (element.Namespace == str3))) { if (useReflection) { ident = choiceMapping.Constants[i].Value.ToString(CultureInfo.InvariantCulture); } else { ident = choiceMapping.Constants[i].Name; } break; } } if ((ident == null) || (ident.Length == 0)) { if (element.Any && (element.Name.Length == 0)) { throw new InvalidOperationException(Res.GetString("XmlChoiceMissingAnyValue", new object[] { choiceMapping.TypeDesc.FullName })); } throw new InvalidOperationException(Res.GetString("XmlChoiceMissingValue", new object[] { choiceMapping.TypeDesc.FullName, element.Namespace + ":" + element.Name, element.Name, element.Namespace })); } if (!useReflection) { CodeIdentifier.CheckValidIdentifier(ident); } return ident; }
private bool WriteEnumAndArrayTypes(StructMapping structMapping, object o, string n, string ns, XmlMapping parentMapping) { if (o is Enum) { Writer.WriteStartElement(n, ns); EnumMapping enumMapping = null; Type enumType = o.GetType(); foreach (var m in parentMapping.Scope.TypeMappings) { var em = m as EnumMapping; if (em != null && em.TypeDesc.Type == enumType) { enumMapping = em; break; } } Debug.Assert(enumMapping != null); WriteXsiType(enumMapping.TypeName, ns); Writer.WriteString(WriteEnumMethod(enumMapping, o)); Writer.WriteEndElement(); return(true); } if (o is Array) { Debug.Assert(parentMapping != null); Writer.WriteStartElement(n, ns); ArrayMapping arrayMapping = null; Type arrayType = o.GetType(); foreach (var m in parentMapping.Scope.TypeMappings) { var am = m as ArrayMapping; if (am != null && am.TypeDesc.Type == arrayType) { arrayMapping = am; break; } } Debug.Assert(arrayMapping != null); WriteXsiType(arrayMapping.TypeName, ns); WriteMember(o, null, arrayMapping.ElementsSortedByDerivation, null, null, arrayMapping.TypeDesc, true); Writer.WriteEndElement(); return(true); } return(false); }
private Dictionary <string, long> WriteHashtable(EnumMapping mapping, string name) { var h = new Dictionary <string, long>(); ConstantMapping[] constants = mapping.Constants; for (int i = 0; i < constants.Length; i++) { h.Add(constants[i].XmlName, constants[i].Value); } return(h); }
TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier) { EnumMapping enumMapping = (EnumMapping)mappings[dataType]; if (enumMapping != null) { return(enumMapping); } XmlSchemaSimpleType sourceDataType = FindDataType(dataType.DerivedFrom); TypeDesc sourceTypeDesc = scope.GetTypeDesc(sourceDataType); if (sourceTypeDesc != null && sourceTypeDesc != scope.GetTypeDesc(typeof(string))) { return(ImportPrimitiveDataType(dataType)); } string typeName = GenerateUniqueTypeName(identifier); enumMapping = new EnumMapping(); enumMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Enum, null, 0); enumMapping.TypeName = identifier; enumMapping.Namespace = typeNs; enumMapping.IsFlags = false; mappings.Add(dataType, enumMapping); 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)); scope.AddTypeMapping(enumMapping); return(enumMapping); }
EnumMapping ImportEnumMapping(EnumModel model) { SoapAttributes a = GetAttributes(model.Type); string typeNs = defaultNs; if (a.SoapType != null && a.SoapType.Namespace != null) { typeNs = a.SoapType.Namespace; } string typeName = string.Empty; if (a.SoapType != null) { typeName = a.SoapType.TypeName; } if (typeName.Length == 0) { typeName = model.TypeDesc.Name; } EnumMapping mapping = (EnumMapping)GetTypeMapping(typeName, typeNs, model.TypeDesc); if (mapping == null) { mapping = new EnumMapping(); mapping.IsSoap = true; mapping.TypeDesc = model.TypeDesc; mapping.TypeName = typeName; mapping.Namespace = typeNs; mapping.IsFlags = model.Type.IsDefined(typeof(FlagsAttribute), false); typeScope.AddTypeMapping(mapping); types.Add(typeName, typeNs, mapping); ArrayList constants = new ArrayList(); for (int i = 0; i < model.Constants.Length; i++) { ConstantMapping constant = ImportConstantMapping(model.Constants[i]); if (constant != null) { constants.Add(constant); } } if (constants.Count == 0) { throw new InvalidOperationException(Res.GetString(Res.XmlNoSerializableMembers, model.TypeDesc.FullName)); } mapping.Constants = (ConstantMapping[])constants.ToArray(typeof(ConstantMapping)); } return(mapping); }
XmlQualifiedName ExportEnumMapping(EnumMapping mapping, string ns) { if (!mapping.IncludeInSchema) { throw new InvalidOperationException(Res.GetString(Res.XmlCannotIncludeInSchema, mapping.TypeDesc.Name)); } XmlSchemaSimpleType dataType = (XmlSchemaSimpleType)types[mapping]; if (dataType == null) { CheckForDuplicateType(mapping.TypeName, mapping.Namespace); dataType = new XmlSchemaSimpleType(); dataType.Name = mapping.TypeName; types.Add(mapping, dataType); AddSchemaItem(dataType, mapping.Namespace, ns); XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping constant = mapping.Constants[i]; XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet(); enumeration.Value = constant.XmlName; restriction.Facets.Add(enumeration); } if (!mapping.IsFlags) { dataType.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType enumType = new XmlSchemaSimpleType(); enumType.Content = restriction; list.ItemType = enumType; dataType.Content = list; } } else { AddSchemaImport(mapping.Namespace, ns); } return(new XmlQualifiedName(dataType.Name, mapping.Namespace)); }
void ExportEnum(EnumMapping mapping) { CodeTypeDeclaration codeClass = new CodeTypeDeclaration(mapping.TypeDesc.Name); codeClass.IsEnum = true; codeClass.TypeAttributes |= TypeAttributes.Public; codeClass.Comments.Add(new CodeCommentStatement("<remarks/>", true)); codeNamespace.Types.Add(codeClass); codeClass.CustomAttributes = new CodeAttributeDeclarationCollection(); AddTypeMetadata(codeClass.CustomAttributes, mapping.TypeName, mapping.Namespace, mapping.IncludeInSchema); for (int i = 0; i < mapping.Constants.Length; i++) { ExportConstant(codeClass, mapping.Constants[i]); } if (mapping.IsFlags) { AddCustomAttribute(codeClass.CustomAttributes, typeof(FlagsAttribute), new CodeAttributeArgument[0]); } }
private XmlQualifiedName ExportEnumMapping(EnumMapping mapping, string ns) { if (((XmlSchemaSimpleType)this.types[mapping]) == null) { this.CheckForDuplicateType(mapping.TypeName, mapping.Namespace); XmlSchemaSimpleType type = new XmlSchemaSimpleType { Name = mapping.TypeName }; this.types.Add(mapping, type); this.AddSchemaItem(type, mapping.Namespace, ns); XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema") }; for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping mapping2 = mapping.Constants[i]; XmlSchemaEnumerationFacet item = new XmlSchemaEnumerationFacet { Value = mapping2.XmlName }; restriction.Facets.Add(item); } if (!mapping.IsFlags) { type.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType type2 = new XmlSchemaSimpleType { Content = restriction }; list.ItemType = type2; type.Content = list; } } else { this.AddSchemaImport(mapping.Namespace, ns); } return(new XmlQualifiedName(mapping.TypeName, mapping.Namespace)); }
private object WriteEnumMethod(EnumMapping mapping, Func <string> readFunc) { if (mapping.IsSoap) { // #10676: As all SOAP relates APIs are not in CoreCLR yet, the reflection based method // currently throws PlatformNotSupportedException when types require SOAP serialization. throw new PlatformNotSupportedException(); } string source = readFunc(); if (mapping.IsFlags) { Dictionary <string, long> table = WriteHashtable(mapping, mapping.TypeDesc.Name); return(Enum.ToObject(mapping.TypeDesc.Type, ToEnum(source, table, mapping.TypeDesc.Name))); } else { return(Enum.Parse(mapping.TypeDesc.Type, source)); } }
private EnumMapping ImportEnumMapping(EnumModel model) { SoapAttributes a = this.GetAttributes(model.Type); string defaultNs = this.defaultNs; if ((a.SoapType != null) && (a.SoapType.Namespace != null)) { defaultNs = a.SoapType.Namespace; } string typeName = XmlConvert.EncodeLocalName(this.XsdTypeName(model.Type, a, model.TypeDesc.Name)); EnumMapping typeMapping = (EnumMapping)this.GetTypeMapping(typeName, defaultNs, model.TypeDesc); if (typeMapping == null) { typeMapping = new EnumMapping { IsSoap = true, TypeDesc = model.TypeDesc, TypeName = typeName, Namespace = defaultNs, IsFlags = model.Type.IsDefined(typeof(FlagsAttribute), false) }; this.typeScope.AddTypeMapping(typeMapping); this.types.Add(typeName, defaultNs, typeMapping); ArrayList list = new ArrayList(); for (int i = 0; i < model.Constants.Length; i++) { ConstantMapping mapping2 = this.ImportConstantMapping(model.Constants[i]); if (mapping2 != null) { list.Add(mapping2); } } if (list.Count == 0) { throw new InvalidOperationException(Res.GetString("XmlNoSerializableMembers", new object[] { model.TypeDesc.FullName })); } typeMapping.Constants = (ConstantMapping[])list.ToArray(typeof(ConstantMapping)); } return(typeMapping); }
internal CodeTypeDeclaration ExportEnum(EnumMapping mapping, Type type) { CodeTypeDeclaration declaration = new CodeTypeDeclaration(mapping.TypeDesc.Name); declaration.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true)); declaration.IsEnum = true; if (mapping.IsFlags && (mapping.Constants.Length > 0x1f)) { declaration.BaseTypes.Add(new CodeTypeReference(typeof(long))); } declaration.TypeAttributes |= TypeAttributes.Public; this.CodeNamespace.Types.Add(declaration); for (int i = 0; i < mapping.Constants.Length; i++) { ExportConstant(declaration, mapping.Constants[i], type, mapping.IsFlags, ((long)1L) << i); } if (mapping.IsFlags) { CodeAttributeDeclaration declaration2 = new CodeAttributeDeclaration(typeof(FlagsAttribute).FullName); declaration.CustomAttributes.Add(declaration2); } CodeGenerator.ValidateIdentifiers(declaration); return(declaration); }
private TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, TypeFlags flags, bool isList) { TypeMapping mapping = (TypeMapping)ImportedMappings[dataType]; if (mapping != null) return mapping; XmlSchemaType sourceType = dataType; while (!sourceType.DerivedFrom.IsEmpty) { sourceType = FindType(sourceType.DerivedFrom, TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue); } if (sourceType is XmlSchemaComplexType) return null; TypeDesc sourceTypeDesc = Scope.GetTypeDesc((XmlSchemaSimpleType)sourceType); if (sourceTypeDesc != null && sourceTypeDesc.FullName != typeof(string).FullName) return ImportPrimitiveDataType(dataType, flags); 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); if (dataType.Name != null && dataType.Name.Length > 0) enumMapping.TypeName = identifier; enumMapping.Namespace = typeNs; enumMapping.IsFlags = isList; CodeIdentifiers constants = new CodeIdentifiers(); XmlSchemaSimpleTypeContent content = dataType.Content; if (content is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)content; for (int i = 0; i < restriction.Facets.Count; i++) { object facet = restriction.Facets[i]; if (!(facet is XmlSchemaEnumerationFacet)) continue; XmlSchemaEnumerationFacet enumeration = (XmlSchemaEnumerationFacet)facet; // validate the enumeration value if (sourceTypeDesc != null && sourceTypeDesc.HasCustomFormatter) { XmlCustomFormatter.ToDefaultValue(enumeration.Value, sourceTypeDesc.FormatterName); } 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 = GetDefaultMapping(TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.CanBeAttributeValue); ImportedMappings.Add(dataType, mapping); return mapping; } ImportedMappings.Add(dataType, enumMapping); Scope.AddTypeMapping(enumMapping); return enumMapping; }
string WriteHashtable(EnumMapping mapping, string typeName) { CodeIdentifier.CheckValidIdentifier(typeName); string propName = MakeUnique(mapping, typeName + "Values"); if (propName == null) return CodeIdentifier.GetCSharpName(typeName); string memberName = MakeUnique(mapping, "_" + propName); propName = CodeIdentifier.GetCSharpName(propName); Writer.WriteLine(); Writer.Write(typeof(Hashtable).FullName); Writer.Write(" "); Writer.Write(memberName); Writer.WriteLine(";"); Writer.WriteLine(); Writer.Write("internal "); Writer.Write(typeof(Hashtable).FullName); Writer.Write(" "); Writer.Write(propName); Writer.WriteLine(" {"); Writer.Indent++; Writer.WriteLine("get {"); Writer.Indent++; Writer.Write("if ((object)"); Writer.Write(memberName); Writer.WriteLine(" == null) {"); Writer.Indent++; Writer.Write(typeof(Hashtable).FullName); Writer.Write(" h = new "); Writer.Write(typeof(Hashtable).FullName); Writer.WriteLine("();"); ConstantMapping[] constants = mapping.Constants; for (int i = 0; i < constants.Length; i++) { Writer.Write("h.Add("); WriteQuotedCSharpString(constants[i].XmlName); if (!mapping.TypeDesc.UseReflection){ Writer.Write(", (long)"); Writer.Write(mapping.TypeDesc.CSharpName); Writer.Write(".@"); CodeIdentifier.CheckValidIdentifier(constants[i].Name); Writer.Write(constants[i].Name); } else{ Writer.Write(", "); Writer.Write(constants[i].Value.ToString(CultureInfo.InvariantCulture)+"L"); } Writer.WriteLine(");"); } Writer.Write(memberName); Writer.WriteLine(" = h;"); Writer.Indent--; Writer.WriteLine("}"); Writer.Write("return "); Writer.Write(memberName); Writer.WriteLine(";"); Writer.Indent--; Writer.WriteLine("}"); Writer.Indent--; Writer.WriteLine("}"); return propName; }
private string WriteEnumMethod(EnumMapping mapping, object v) { if (mapping != null && mapping.IsSoap) { throw new PlatformNotSupportedException(); } if (mapping != null && mapping.IsFlags) { Type type = mapping.TypeDesc.Type; List<string> valueStrings = new List<string>(); List<long> valueIds = new List<long>(); foreach (var value in Enum.GetValues(type)) { valueStrings.Add(value.ToString()); valueIds.Add(Convert.ToInt64(value)); } return FromEnum(Convert.ToInt64(v), valueStrings.ToArray(), valueIds.ToArray()); } else { return v.ToString(); } }
string WriteHashtable(EnumMapping mapping, string typeName) { CodeIdentifier.CheckValidIdentifier(typeName); string propName = MakeUnique(mapping, typeName + "Values"); if (propName == null) return CodeIdentifier.EscapeKeywords(typeName); string memberName = MakeUnique(mapping, "_" + propName); propName = CodeIdentifier.EscapeKeywords(propName); writer.WriteLine(); writer.Write(typeof(Hashtable).FullName); writer.Write(" "); writer.Write(memberName); writer.WriteLine(";"); writer.WriteLine(); writer.Write("internal "); writer.Write(typeof(Hashtable).FullName); writer.Write(" "); writer.Write(propName); writer.WriteLine(" {"); writer.Indent++; writer.WriteLine("get {"); writer.Indent++; writer.Write("if ((object)"); writer.Write(memberName); writer.WriteLine(" == null) {"); writer.Indent++; writer.Write(typeof(Hashtable).FullName); writer.Write(" h = new "); writer.Write(typeof(Hashtable).FullName); writer.WriteLine("();"); ConstantMapping[] constants = mapping.Constants; for (int i = 0; i < constants.Length; i++) { writer.Write("h.Add("); WriteQuotedCSharpString(constants[i].XmlName); writer.Write(", ("); writer.Write(typeof(long).FullName); writer.Write(")"); writer.Write(CodeIdentifier.EscapeKeywords(mapping.TypeDesc.FullName)); writer.Write(".@"); CodeIdentifier.CheckValidIdentifier(constants[i].Name); writer.Write(constants[i].Name); writer.WriteLine(");"); } writer.Write(memberName); writer.WriteLine(" = h;"); writer.Indent--; writer.WriteLine("}"); writer.Write("return "); writer.Write(memberName); writer.WriteLine(";"); writer.Indent--; writer.WriteLine("}"); writer.Indent--; writer.WriteLine("}"); return propName; }
XmlSchemaType ExportEnumMapping(EnumMapping mapping, string ns) { if (!mapping.IncludeInSchema) throw new InvalidOperationException(Res.GetString(Res.XmlCannotIncludeInSchema, mapping.TypeDesc.Name)); XmlSchemaSimpleType dataType = (XmlSchemaSimpleType)types[mapping]; if (dataType == null) { CheckForDuplicateType(mapping, mapping.Namespace); dataType = new XmlSchemaSimpleType(); dataType.Name = mapping.TypeName; if (!mapping.IsAnonymousType) { types.Add(mapping, dataType); AddSchemaItem(dataType, mapping.Namespace, ns); } XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping constant = mapping.Constants[i]; XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet(); enumeration.Value = constant.XmlName; restriction.Facets.Add(enumeration); } if (!mapping.IsFlags) { dataType.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType enumType = new XmlSchemaSimpleType(); enumType.Content = restriction; list.ItemType = enumType; dataType.Content = list; } } if (!mapping.IsAnonymousType) { AddSchemaImport(mapping.Namespace, ns); } return dataType; }
void WriteEnumMethod(EnumMapping mapping) { string tableName = null; if (mapping.IsFlags) tableName = WriteHashtable(mapping, mapping.TypeDesc.Name); string methodName = (string)methodNames[mapping]; writer.WriteLine(); string fullTypeName = CodeIdentifier.EscapeKeywords(mapping.TypeDesc.FullName); if (mapping.IsSoap) { writer.Write("object"); writer.Write(" "); writer.Write(methodName); writer.WriteLine("() {"); writer.Indent++; writer.WriteLine("string s = Reader.ReadElementString();"); } else { writer.Write(fullTypeName); writer.Write(" "); writer.Write(methodName); writer.WriteLine("(string s) {"); writer.Indent++; } ConstantMapping[] constants = mapping.Constants; if (mapping.IsFlags) { writer.Write("return ("); writer.Write(fullTypeName); writer.Write(")ToEnum(s, "); writer.Write(tableName); writer.Write(", "); WriteQuotedCSharpString(fullTypeName); writer.WriteLine(");"); } else { writer.WriteLine("switch (s) {"); writer.Indent++; for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; CodeIdentifier.CheckValidIdentifier(c.Name); writer.Write("case "); WriteQuotedCSharpString(c.XmlName); writer.Write(": return "); writer.Write(fullTypeName); writer.Write(".@"); writer.Write(c.Name); writer.WriteLine(";"); } writer.Write("default: throw CreateUnknownConstantException(s, typeof("); writer.Write(fullTypeName); writer.WriteLine("));"); writer.Indent--; writer.WriteLine("}"); } writer.Indent--; writer.WriteLine("}"); }
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)); }
XmlQualifiedName ExportEnumMapping(EnumMapping mapping, string ns) { XmlSchemaSimpleType dataType = (XmlSchemaSimpleType)types[mapping]; if (dataType == null) { CheckForDuplicateType(mapping.TypeName, mapping.Namespace); dataType = new XmlSchemaSimpleType(); dataType.Name = mapping.TypeName; types.Add(mapping, dataType); AddSchemaItem(dataType, mapping.Namespace, ns); XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping constant = mapping.Constants[i]; XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet(); enumeration.Value = constant.XmlName; restriction.Facets.Add(enumeration); } if (!mapping.IsFlags) { dataType.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType enumType = new XmlSchemaSimpleType(); enumType.Content = restriction; list.ItemType = enumType; dataType.Content = list; } } else { AddSchemaImport(mapping.Namespace, ns); } return new XmlQualifiedName(mapping.TypeName, mapping.Namespace); }
string FindChoiceEnumValue(ElementAccessor element, EnumMapping choiceMapping, bool useReflection) { string enumValue = null; for (int i = 0; i < choiceMapping.Constants.Length; i++) { string xmlName = choiceMapping.Constants[i].XmlName; if (element.Any && element.Name.Length == 0) { if (xmlName == "##any:") { if (useReflection) enumValue = choiceMapping.Constants[i].Value.ToString(CultureInfo.InvariantCulture); else enumValue = choiceMapping.Constants[i].Name; break; } continue; } int colon = xmlName.LastIndexOf(':'); string choiceNs = colon < 0 ? choiceMapping.Namespace : xmlName.Substring(0, colon); string choiceName = colon < 0 ? xmlName : xmlName.Substring(colon+1); if (element.Name == choiceName) { if ((element.Form == XmlSchemaForm.Unqualified && string.IsNullOrEmpty(choiceNs)) || element.Namespace == choiceNs) { if (useReflection) enumValue = choiceMapping.Constants[i].Value.ToString(CultureInfo.InvariantCulture); else enumValue = choiceMapping.Constants[i].Name; break; } } } if (enumValue == null || enumValue.Length == 0) { if (element.Any && element.Name.Length == 0) { // Type {0} is missing enumeration value '##any' for XmlAnyElementAttribute. throw new InvalidOperationException(Res.GetString(Res.XmlChoiceMissingAnyValue, choiceMapping.TypeDesc.FullName)); } // Type {0} is missing value for '{1}'. throw new InvalidOperationException(Res.GetString(Res.XmlChoiceMissingValue, choiceMapping.TypeDesc.FullName, element.Namespace + ":" + element.Name, element.Name, element.Namespace)); } if(!useReflection) CodeIdentifier.CheckValidIdentifier(enumValue); return enumValue; }
private void CheckChoiceIdentifierMapping(EnumMapping choiceMapping) { System.Xml.Serialization.NameTable table = new System.Xml.Serialization.NameTable(); for (int i = 0; i < choiceMapping.Constants.Length; i++) { string xmlName = choiceMapping.Constants[i].XmlName; int length = xmlName.LastIndexOf(':'); string name = (length < 0) ? xmlName : xmlName.Substring(length + 1); string ns = (length < 0) ? "" : xmlName.Substring(0, length); if (table[name, ns] != null) { throw new InvalidOperationException(Res.GetString("XmlChoiceIdDuplicate", new object[] { choiceMapping.TypeName, xmlName })); } table.Add(name, ns, choiceMapping.Constants[i]); } }
internal CodeTypeDeclaration ExportEnum(EnumMapping mapping, Type type) { CodeTypeDeclaration declaration = new CodeTypeDeclaration(mapping.TypeDesc.Name); declaration.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true)); declaration.IsEnum = true; if (mapping.IsFlags && (mapping.Constants.Length > 0x1f)) { declaration.BaseTypes.Add(new CodeTypeReference(typeof(long))); } declaration.TypeAttributes |= TypeAttributes.Public; this.CodeNamespace.Types.Add(declaration); for (int i = 0; i < mapping.Constants.Length; i++) { ExportConstant(declaration, mapping.Constants[i], type, mapping.IsFlags, ((long) 1L) << i); } if (mapping.IsFlags) { CodeAttributeDeclaration declaration2 = new CodeAttributeDeclaration(typeof(FlagsAttribute).FullName); declaration.CustomAttributes.Add(declaration2); } CodeGenerator.ValidateIdentifiers(declaration); return declaration; }
private EnumMapping ImportEnumMapping(EnumModel model, string ns, bool repeats) { XmlAttributes a = this.GetAttributes(model.Type, false); string str = ns; if ((a.XmlType != null) && (a.XmlType.Namespace != null)) { str = a.XmlType.Namespace; } string name = IsAnonymousType(a, ns) ? null : this.XsdTypeName(model.Type, a, model.TypeDesc.Name); name = XmlConvert.EncodeLocalName(name); EnumMapping mapping = (EnumMapping) this.GetTypeMapping(name, str, model.TypeDesc, this.types, model.Type); if (mapping == null) { mapping = new EnumMapping { TypeDesc = model.TypeDesc, TypeName = name, Namespace = str, IsFlags = model.Type.IsDefined(typeof(FlagsAttribute), false) }; if (mapping.IsFlags && repeats) { throw new InvalidOperationException(Res.GetString("XmlIllegalAttributeFlagsArray", new object[] { model.TypeDesc.FullName })); } mapping.IsList = repeats; mapping.IncludeInSchema = (a.XmlType == null) || a.XmlType.IncludeInSchema; if (!mapping.IsAnonymousType) { this.types.Add(name, str, mapping); } else { this.anonymous[model.Type] = mapping; } ArrayList list = new ArrayList(); for (int i = 0; i < model.Constants.Length; i++) { ConstantMapping mapping2 = this.ImportConstantMapping(model.Constants[i]); if (mapping2 != null) { list.Add(mapping2); } } if (list.Count == 0) { throw new InvalidOperationException(Res.GetString("XmlNoSerializableMembers", new object[] { model.TypeDesc.FullName })); } mapping.Constants = (ConstantMapping[]) list.ToArray(typeof(ConstantMapping)); this.typeScope.AddTypeMapping(mapping); } return mapping; }
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 void WriteEnumValue(EnumMapping mapping, SourceInfo source, out Type returnType) { string methodName = ReferenceMapping(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 (methodName == null) throw new InvalidOperationException(SR.Format(SR.XmlInternalErrorMethod, mapping.TypeDesc.Name)); #endif // For enum, its write method (eg. Write1_Gender) could be called multiple times // prior to its declaration. MethodBuilder methodBuilder = EnsureMethodBuilder(typeBuilder, methodName, CodeGenerator.PrivateMethodAttributes, typeof(string), new Type[] { mapping.TypeDesc.Type }); ilg.Ldarg(0); source.Load(mapping.TypeDesc.Type); ilg.Call(methodBuilder); returnType = typeof(string); }
private XmlSchemaType ExportEnumMapping(EnumMapping mapping, string ns) { if (!mapping.IncludeInSchema) { throw new InvalidOperationException(Res.GetString("XmlCannotIncludeInSchema", new object[] { mapping.TypeDesc.Name })); } XmlSchemaSimpleType type = (XmlSchemaSimpleType) this.types[mapping]; if (type == null) { this.CheckForDuplicateType(mapping, mapping.Namespace); type = new XmlSchemaSimpleType { Name = mapping.TypeName }; if (!mapping.IsAnonymousType) { this.types.Add(mapping, type); this.AddSchemaItem(type, mapping.Namespace, ns); } XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema") }; for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping mapping2 = mapping.Constants[i]; XmlSchemaEnumerationFacet item = new XmlSchemaEnumerationFacet { Value = mapping2.XmlName }; restriction.Facets.Add(item); } if (!mapping.IsFlags) { type.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType type2 = new XmlSchemaSimpleType { Content = restriction }; list.ItemType = type2; type.Content = list; } } if (!mapping.IsAnonymousType) { this.AddSchemaImport(mapping.Namespace, ns); } return type; }
internal CodeTypeDeclaration ExportEnum(EnumMapping mapping, Type type) { CodeTypeDeclaration codeClass = new CodeTypeDeclaration(mapping.TypeDesc.Name); codeClass.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true)); codeClass.IsEnum = true; if (mapping.IsFlags && mapping.Constants.Length > 31) { codeClass.BaseTypes.Add(new CodeTypeReference(typeof(long))); } codeClass.TypeAttributes |= TypeAttributes.Public; CodeNamespace.Types.Add(codeClass); for (int i = 0; i < mapping.Constants.Length; i++) { ExportConstant(codeClass, mapping.Constants[i], type, mapping.IsFlags, 1L << i); } if (mapping.IsFlags) { // Add [FlagsAttribute] CodeAttributeDeclaration flags = new CodeAttributeDeclaration(typeof(FlagsAttribute).FullName); codeClass.CustomAttributes.Add(flags); } CodeGenerator.ValidateIdentifiers(codeClass); return codeClass; }
private void WriteEnumMethod(EnumMapping mapping) { string methodName = (string)MethodNames[mapping]; List<Type> argTypes = new List<Type>(); List<string> argNames = new List<string>(); argTypes.Add(mapping.TypeDesc.Type); argNames.Add("v"); ilg = new CodeGenerator(this.typeBuilder); ilg.BeginMethod( typeof(string), GetMethodBuilder(methodName), argTypes.ToArray(), argNames.ToArray(), CodeGenerator.PrivateMethodAttributes); LocalBuilder sLoc = ilg.DeclareLocal(typeof(string), "s"); ilg.Load(null); ilg.Stloc(sLoc); ConstantMapping[] constants = mapping.Constants; if (constants.Length > 0) { InternalHashtable values = new InternalHashtable(); List<Label> caseLabels = new List<Label>(); List<string> retValues = new List<string>(); Label defaultLabel = ilg.DefineLabel(); Label endSwitchLabel = ilg.DefineLabel(); // This local is necessary; otherwise, it becomes if/else LocalBuilder localTmp = ilg.DeclareLocal(mapping.TypeDesc.Type, "localTmp"); ilg.Ldarg("v"); ilg.Stloc(localTmp); for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; if (values[c.Value] == null) { Label caseLabel = ilg.DefineLabel(); ilg.Ldloc(localTmp); ilg.Ldc(Enum.ToObject(mapping.TypeDesc.Type, c.Value)); ilg.Beq(caseLabel); caseLabels.Add(caseLabel); retValues.Add(GetCSharpString(c.XmlName)); values.Add(c.Value, c.Value); } } if (mapping.IsFlags) { ilg.Br(defaultLabel); for (int i = 0; i < caseLabels.Count; i++) { ilg.MarkLabel(caseLabels[i]); ilg.Ldc(retValues[i]); ilg.Stloc(sLoc); ilg.Br(endSwitchLabel); } ilg.MarkLabel(defaultLabel); RaCodeGen.ILGenForEnumLongValue(ilg, "v"); LocalBuilder strArray = ilg.DeclareLocal(typeof(String[]), "strArray"); ilg.NewArray(typeof(String), constants.Length); ilg.Stloc(strArray); for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; ilg.Ldloc(strArray); ilg.Ldc(i); ilg.Ldstr(GetCSharpString(c.XmlName)); ilg.Stelem(typeof(String)); } ilg.Ldloc(strArray); LocalBuilder longArray = ilg.DeclareLocal(typeof(long[]), "longArray"); ilg.NewArray(typeof(long), constants.Length); ilg.Stloc(longArray); for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; ilg.Ldloc(longArray); ilg.Ldc(i); ilg.Ldc(c.Value); ilg.Stelem(typeof(long)); } ilg.Ldloc(longArray); ilg.Ldstr(GetCSharpString(mapping.TypeDesc.FullName)); MethodInfo XmlSerializationWriter_FromEnum = typeof(XmlSerializationWriter).GetMethod( "FromEnum", CodeGenerator.StaticBindingFlags, new Type[] { typeof(Int64), typeof(String[]), typeof(Int64[]), typeof(String) } ); ilg.Call(XmlSerializationWriter_FromEnum); ilg.Stloc(sLoc); ilg.Br(endSwitchLabel); } else { ilg.Br(defaultLabel); // Case bodies for (int i = 0; i < caseLabels.Count; i++) { ilg.MarkLabel(caseLabels[i]); ilg.Ldc(retValues[i]); ilg.Stloc(sLoc); ilg.Br(endSwitchLabel); } MethodInfo CultureInfo_get_InvariantCulture = typeof(CultureInfo).GetMethod( "get_InvariantCulture", CodeGenerator.StaticBindingFlags, Array.Empty<Type>() ); MethodInfo Int64_ToString = typeof(Int64).GetMethod( "ToString", CodeGenerator.InstanceBindingFlags, new Type[] { typeof(IFormatProvider) } ); MethodInfo XmlSerializationWriter_CreateInvalidEnumValueException = typeof(XmlSerializationWriter).GetMethod( "CreateInvalidEnumValueException", CodeGenerator.InstanceBindingFlags, new Type[] { typeof(object), typeof(string) } ); // Default body ilg.MarkLabel(defaultLabel); ilg.Ldarg(0); ilg.Ldarg("v"); ilg.ConvertValue(mapping.TypeDesc.Type, typeof(Int64)); LocalBuilder numLoc = ilg.DeclareLocal(typeof(Int64), "num"); ilg.Stloc(numLoc); // Invoke method on Value type need address ilg.LdlocAddress(numLoc); ilg.Call(CultureInfo_get_InvariantCulture); ilg.Call(Int64_ToString); ilg.Ldstr(GetCSharpString(mapping.TypeDesc.FullName)); ilg.Call(XmlSerializationWriter_CreateInvalidEnumValueException); ilg.Throw(); } ilg.MarkLabel(endSwitchLabel); } ilg.Ldloc(sLoc); ilg.EndMethod(); }
void WriteEnumValue(EnumMapping mapping, string source) { string methodName = ReferenceMapping(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 (methodName == null) throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorMethod, mapping.TypeDesc.Name) + Environment.StackTrace); #endif Writer.Write(methodName); Writer.Write("("); Writer.Write(source); Writer.Write(")"); }
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 WriteEnumMethod(EnumMapping mapping) { MethodBuilder get_TableName = null; if (mapping.IsFlags) WriteHashtable(mapping, mapping.TypeDesc.Name, out get_TableName); string methodName = (string)MethodNames[mapping]; string fullTypeName = mapping.TypeDesc.CSharpName; List<Type> argTypes = new List<Type>(); List<string> argNames = new List<string>(); Type returnType; Type underlyingType; returnType = mapping.TypeDesc.Type; underlyingType = Enum.GetUnderlyingType(returnType); argTypes.Add(typeof(string)); argNames.Add("s"); ilg = new CodeGenerator(this.typeBuilder); ilg.BeginMethod( returnType, GetMethodBuilder(methodName), argTypes.ToArray(), argNames.ToArray(), CodeGenerator.PrivateMethodAttributes); ConstantMapping[] constants = mapping.Constants; if (mapping.IsFlags) { { MethodInfo XmlSerializationReader_ToEnum = typeof(XmlSerializationReader).GetMethod( "ToEnum", CodeGenerator.StaticBindingFlags, null, new Type[] { typeof(String), typeof(Hashtable), typeof(String) }, null ); ilg.Ldarg("s"); ilg.Ldarg(0); Debug.Assert(get_TableName != null); ilg.Call(get_TableName); ilg.Ldstr(fullTypeName); ilg.Call(XmlSerializationReader_ToEnum); // XmlSerializationReader_ToEnum return long! if (underlyingType != typeof(long)) { ilg.ConvertValue(typeof(long), underlyingType); } ilg.Stloc(ilg.ReturnLocal); ilg.Br(ilg.ReturnLabel); } } else { List<Label> caseLabels = new List<Label>(); List<object> retValues = new List<object>(); Label defaultLabel = ilg.DefineLabel(); Label endSwitchLabel = ilg.DefineLabel(); // This local is necessary; otherwise, it becomes if/else LocalBuilder localTmp = ilg.GetTempLocal(typeof(string)); ilg.Ldarg("s"); ilg.Stloc(localTmp); ilg.Ldloc(localTmp); ilg.Brfalse(defaultLabel); Hashtable cases = new Hashtable(); for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; CodeIdentifier.CheckValidIdentifier(c.Name); if (cases[c.XmlName] == null) { cases[c.XmlName] = c.XmlName; Label caseLabel = ilg.DefineLabel(); ilg.Ldloc(localTmp); ilg.Ldstr(c.XmlName); MethodInfo String_op_Equality = typeof(string).GetMethod( "op_Equality", CodeGenerator.StaticBindingFlags, null, new Type[] { typeof(string), typeof(string) }, null ); ilg.Call(String_op_Equality); ilg.Brtrue(caseLabel); caseLabels.Add(caseLabel); retValues.Add(Enum.ToObject(mapping.TypeDesc.Type, c.Value)); } } ilg.Br(defaultLabel); // Case bodies for (int i = 0; i < caseLabels.Count; i++) { ilg.MarkLabel(caseLabels[i]); ilg.Ldc(retValues[i]); ilg.Stloc(ilg.ReturnLocal); ilg.Br(ilg.ReturnLabel); } MethodInfo XmlSerializationReader_CreateUnknownConstantException = typeof(XmlSerializationReader).GetMethod( "CreateUnknownConstantException", CodeGenerator.InstanceBindingFlags, null, new Type[] { typeof(string), typeof(Type) }, null ); // Default body ilg.MarkLabel(defaultLabel); ilg.Ldarg(0); ilg.Ldarg("s"); // typeof(..) ilg.Ldc(mapping.TypeDesc.Type); ilg.Call(XmlSerializationReader_CreateUnknownConstantException); ilg.Throw(); // End switch ilg.MarkLabel(endSwitchLabel); } ilg.MarkLabel(ilg.ReturnLabel); ilg.Ldloc(ilg.ReturnLocal); ilg.EndMethod(); }
string MakeUnique(EnumMapping mapping, string name) { string uniqueName = name; object m = Enums[uniqueName]; if (m != null) { if (m == mapping) { // we already have created the hashtable return null; } int i = 0; while (m != null) { i++; uniqueName = name + i.ToString(CultureInfo.InvariantCulture); m = Enums[uniqueName]; } } Enums.Add(uniqueName, mapping); return uniqueName; }
string WriteHashtable(EnumMapping mapping, string typeName, out MethodBuilder get_TableName) { get_TableName = null; CodeIdentifier.CheckValidIdentifier(typeName); string propName = MakeUnique(mapping, typeName + "Values"); if (propName == null) return CodeIdentifier.GetCSharpName(typeName); string memberName = MakeUnique(mapping, "_" + propName); propName = CodeIdentifier.GetCSharpName(propName); FieldBuilder fieldBuilder = this.typeBuilder.DefineField( memberName, typeof(Hashtable), FieldAttributes.Private ); PropertyBuilder propertyBuilder = this.typeBuilder.DefineProperty( propName, PropertyAttributes.None, CallingConventions.HasThis, typeof(Hashtable), null, null, null, null, null); ilg = new CodeGenerator(this.typeBuilder); ilg.BeginMethod( typeof(Hashtable), "get_" + propName, CodeGenerator.EmptyTypeArray, CodeGenerator.EmptyStringArray, MethodAttributes.Assembly | MethodAttributes.HideBySig | MethodAttributes.SpecialName); ilg.Ldarg(0); ilg.LoadMember(fieldBuilder); ilg.Load(null); ilg.If(Cmp.EqualTo); ConstructorInfo Hashtable_ctor = typeof(Hashtable).GetConstructor( CodeGenerator.InstanceBindingFlags, null, CodeGenerator.EmptyTypeArray, null ); LocalBuilder hLoc = ilg.DeclareLocal(typeof(Hashtable), "h"); ilg.New(Hashtable_ctor); ilg.Stloc(hLoc); ConstantMapping[] constants = mapping.Constants; MethodInfo Hashtable_Add = typeof(Hashtable).GetMethod( "Add", CodeGenerator.InstanceBindingFlags, null, new Type[] { typeof(Object), typeof(Object) }, null ); for (int i = 0; i < constants.Length; i++) { ilg.Ldloc(hLoc); ilg.Ldstr(constants[i].XmlName); ilg.Ldc(Enum.ToObject(mapping.TypeDesc.Type, constants[i].Value)); ilg.ConvertValue(mapping.TypeDesc.Type, typeof(long)); ilg.ConvertValue(typeof(long), typeof(Object)); ilg.Call(Hashtable_Add); } ilg.Ldarg(0); ilg.Ldloc(hLoc); ilg.StoreMember(fieldBuilder); ilg.EndIf(); ilg.Ldarg(0); ilg.LoadMember(fieldBuilder); get_TableName = ilg.EndMethod(); propertyBuilder.SetGetMethod(get_TableName); return propName; }
void WriteEnumMethod(EnumMapping mapping) { string tableName = null; if (mapping.IsFlags) tableName = WriteHashtable(mapping, mapping.TypeDesc.Name); string methodName = (string)MethodNames[mapping]; Writer.WriteLine(); bool useReflection = mapping.TypeDesc.UseReflection; string fullTypeName = mapping.TypeDesc.CSharpName; if (mapping.IsSoap) { Writer.Write("object"); Writer.Write(" "); Writer.Write(methodName); Writer.WriteLine("() {"); Writer.Indent++; Writer.WriteLine("string s = Reader.ReadElementString();"); } else { Writer.Write(useReflection?"object":fullTypeName); Writer.Write(" "); Writer.Write(methodName); Writer.WriteLine("(string s) {"); Writer.Indent++; } ConstantMapping[] constants = mapping.Constants; if (mapping.IsFlags) { if (useReflection){ Writer.Write("return "); Writer.Write(typeof(Enum).FullName); Writer.Write(".ToObject("); Writer.Write(RaCodeGen.GetStringForTypeof(fullTypeName, useReflection)); Writer.Write(", ToEnum(s, "); Writer.Write(tableName); Writer.Write(", "); WriteQuotedCSharpString(fullTypeName); Writer.WriteLine("));"); } else{ Writer.Write("return ("); Writer.Write(fullTypeName); Writer.Write(")ToEnum(s, "); Writer.Write(tableName); Writer.Write(", "); WriteQuotedCSharpString(fullTypeName); Writer.WriteLine(");"); } } else { Writer.WriteLine("switch (s) {"); Writer.Indent++; Hashtable cases = new Hashtable(); for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; CodeIdentifier.CheckValidIdentifier(c.Name); if (cases[c.XmlName] == null) { Writer.Write("case "); WriteQuotedCSharpString(c.XmlName); Writer.Write(": return "); Writer.Write(RaCodeGen.GetStringForEnumMember(fullTypeName, c.Name, useReflection)); Writer.WriteLine(";"); cases[c.XmlName] = c.XmlName; } } Writer.Write("default: throw CreateUnknownConstantException(s, "); Writer.Write(RaCodeGen.GetStringForTypeof(fullTypeName, useReflection)); Writer.WriteLine(");"); Writer.Indent--; Writer.WriteLine("}"); } Writer.Indent--; Writer.WriteLine("}"); }
TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier) { EnumMapping enumMapping = (EnumMapping)mappings[dataType]; if (enumMapping != null) return enumMapping; XmlSchemaType sourceType = FindType(dataType.DerivedFrom); if (sourceType is XmlSchemaComplexType) return null; TypeDesc sourceTypeDesc = scope.GetTypeDesc((XmlSchemaSimpleType)sourceType); if (sourceTypeDesc != null && sourceTypeDesc.FullName != typeof(string).FullName) return ImportPrimitiveDataType(dataType); string typeName = GenerateUniqueTypeName(identifier); enumMapping = new EnumMapping(); enumMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Enum, null, 0); enumMapping.TypeName = identifier; enumMapping.Namespace = typeNs; enumMapping.IsFlags = false; mappings.Add(dataType, enumMapping); CodeIdentifiers constants = new CodeIdentifiers(); XmlSchemaSimpleTypeContent content = dataType.Content; if (content is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)content; for (int i = 0; i < restriction.Facets.Count; i++) { object facet = restriction.Facets[i]; if (!(facet is XmlSchemaEnumerationFacet)) continue; XmlSchemaEnumerationFacet enumeration = (XmlSchemaEnumerationFacet)facet; // validate the enumeration value if (sourceTypeDesc != null && sourceTypeDesc.HasCustomFormatter) { XmlCustomFormatter.ToDefaultValue(enumeration.Value, sourceTypeDesc.FormatterName); } 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)); scope.AddTypeMapping(enumMapping); return enumMapping; }
EnumMapping ImportEnumMapping(EnumModel model) { SoapAttributes a = GetAttributes(model.Type); string typeNs = defaultNs; if (a.SoapType != null && a.SoapType.Namespace != null) typeNs = a.SoapType.Namespace; string typeName = XsdTypeName(model.Type, a, model.TypeDesc.Name); typeName = XmlConvert.EncodeLocalName(typeName); EnumMapping mapping = (EnumMapping)GetTypeMapping(typeName, typeNs, model.TypeDesc); if (mapping == null) { mapping = new EnumMapping(); mapping.IsSoap = true; mapping.TypeDesc = model.TypeDesc; mapping.TypeName = typeName; mapping.Namespace = typeNs; mapping.IsFlags = model.Type.IsDefined(typeof(FlagsAttribute), false); typeScope.AddTypeMapping(mapping); types.Add(typeName, typeNs, mapping); ArrayList constants = new ArrayList(); for (int i = 0; i < model.Constants.Length; i++) { ConstantMapping constant = ImportConstantMapping(model.Constants[i]); if (constant != null) constants.Add(constant); } if (constants.Count == 0) { throw new InvalidOperationException(Res.GetString(Res.XmlNoSerializableMembers, model.TypeDesc.FullName)); } mapping.Constants = (ConstantMapping[])constants.ToArray(typeof(ConstantMapping)); } return mapping; }
EnumMapping ImportEnumeratedChoice(ElementAccessor[] choice, string typeNs, string typeName) { typeName = GenerateUniqueTypeName(typeName, typeNs); EnumMapping enumMapping = new EnumMapping(); enumMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Enum, null, 0); enumMapping.TypeName = typeName; enumMapping.Namespace = typeNs; enumMapping.IsFlags = false; enumMapping.IncludeInSchema = false; CodeIdentifiers constants = new CodeIdentifiers(); for (int i = 0; i < choice.Length; i++) { ElementAccessor element = choice[i]; ConstantMapping constant = new ConstantMapping(); string constantName = CodeIdentifier.MakeValid(element.Name); constant.Name = constants.AddUnique(constantName, constant); constant.XmlName = element.Namespace == typeNs ? element.Name : element.Namespace + ":" + element.Name; constant.Value = i; } enumMapping.Constants = (ConstantMapping[])constants.ToArray(typeof(ConstantMapping)); scope.AddTypeMapping(enumMapping); return enumMapping; }
void WriteEnumMethod(EnumMapping mapping) { string methodName = (string)MethodNames[mapping]; Writer.WriteLine(); string fullTypeName = mapping.TypeDesc.CSharpName; if (mapping.IsSoap) { Writer.Write("void "); Writer.Write(methodName); Writer.WriteLine("(object e) {"); WriteLocalDecl(fullTypeName, "v", "e", mapping.TypeDesc.UseReflection); } else { Writer.Write("string "); Writer.Write(methodName); Writer.Write("("); Writer.Write(mapping.TypeDesc.UseReflection? "object" : fullTypeName ); Writer.WriteLine(" v) {"); } Writer.Indent++; Writer.WriteLine("string s = null;"); ConstantMapping[] constants = mapping.Constants; if (constants.Length > 0) { Hashtable values = new Hashtable(); if (mapping.TypeDesc.UseReflection) Writer.WriteLine("switch ("+RaCodeGen.GetStringForEnumLongValue("v", mapping.TypeDesc.UseReflection)+" ){"); else Writer.WriteLine("switch (v) {"); Writer.Indent++; for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; if (values[c.Value] == null) { WriteEnumCase(fullTypeName, c, mapping.TypeDesc.UseReflection); Writer.Write("s = "); WriteQuotedCSharpString(c.XmlName); Writer.WriteLine("; break;"); values.Add(c.Value, c.Value); } } if (mapping.IsFlags) { Writer.Write("default: s = FromEnum("); Writer.Write(RaCodeGen.GetStringForEnumLongValue("v", mapping.TypeDesc.UseReflection)); Writer.Write(", new string[] {"); Writer.Indent++; for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; if (i > 0) Writer.WriteLine(", "); WriteQuotedCSharpString(c.XmlName); } Writer.Write("}, new "); Writer.Write(typeof(long).FullName); Writer.Write("[] {"); for (int i = 0; i < constants.Length; i++) { ConstantMapping c = constants[i]; if (i > 0) Writer.WriteLine(", "); Writer.Write("(long)"); if (mapping.TypeDesc.UseReflection) Writer.Write(c.Value.ToString(CultureInfo.InvariantCulture)); else { Writer.Write(fullTypeName); Writer.Write(".@"); CodeIdentifier.CheckValidIdentifier(c.Name); Writer.Write(c.Name); } } Writer.Indent--; Writer.Write("}, "); WriteQuotedCSharpString(mapping.TypeDesc.FullName); Writer.WriteLine("); break;"); } else { Writer.Write("default: throw CreateInvalidEnumValueException("); Writer.Write(RaCodeGen.GetStringForEnumLongValue("v", mapping.TypeDesc.UseReflection)); Writer.Write(".ToString(System.Globalization.CultureInfo.InvariantCulture), "); WriteQuotedCSharpString(mapping.TypeDesc.FullName); Writer.WriteLine(");"); } Writer.Indent--; Writer.WriteLine("}"); } if (mapping.IsSoap) { Writer.Write("WriteXsiType("); WriteQuotedCSharpString(mapping.TypeName); Writer.Write(", "); WriteQuotedCSharpString(mapping.Namespace); Writer.WriteLine(");"); Writer.WriteLine("Writer.WriteString(s);"); } else { Writer.WriteLine("return s;"); } Writer.Indent--; Writer.WriteLine("}"); }
void CheckChoiceIdentifierMapping(EnumMapping choiceMapping) { NameTable ids = new NameTable(); for (int i = 0; i < choiceMapping.Constants.Length; i++) { string choiceId = choiceMapping.Constants[i].XmlName; int colon = choiceId.LastIndexOf(':'); string choiceName = colon < 0 ? choiceId : choiceId.Substring(colon+1); string choiceNs = colon < 0 ? "" : choiceId.Substring(0, colon); if (ids[choiceName, choiceNs] != null) { // Enum values in the XmlChoiceIdentifier '{0}' have to be unique. Value '{1}' already present. throw new InvalidOperationException(Res.GetString(Res.XmlChoiceIdDuplicate, choiceMapping.TypeName, choiceId)); } ids.Add(choiceName, choiceNs, choiceMapping.Constants[i]); } }
internal string GetStringForEnumCompare(EnumMapping mapping, string memberName, bool useReflection){ if(!useReflection){ CodeIdentifier.CheckValidIdentifier(memberName); return mapping.TypeDesc.CSharpName+".@"+memberName; } string memberAccess = GetStringForEnumMember(mapping.TypeDesc.CSharpName, memberName, useReflection); return GetStringForEnumLongValue(memberAccess, useReflection); }
EnumMapping ImportEnumMapping(EnumModel model, string ns, bool repeats) { XmlAttributes a = GetAttributes(model.Type, false); string typeNs = ns; if (a.XmlType != null && a.XmlType.Namespace != null) typeNs = a.XmlType.Namespace; string typeName = XsdTypeName(model.Type, a, model.TypeDesc.Name); typeName = XmlConvert.EncodeLocalName(typeName); EnumMapping mapping = (EnumMapping)GetTypeMapping(typeName, typeNs, model.TypeDesc, types, model.Type); if (mapping == null) { mapping = new EnumMapping(); mapping.TypeDesc = model.TypeDesc; mapping.TypeName = typeName; mapping.Namespace = typeNs; mapping.IsFlags = model.Type.IsDefined(typeof(FlagsAttribute), false); if (mapping.IsFlags && repeats) throw new InvalidOperationException(Res.GetString(Res.XmlIllegalAttributeFlagsArray, model.TypeDesc.FullName)); mapping.IsList = repeats; mapping.IncludeInSchema = a.XmlType == null ? true : a.XmlType.IncludeInSchema; if (!mapping.IsAnonymousType) types.Add(typeName, typeNs, mapping); else anonymous[model.Type] = mapping; ArrayList constants = new ArrayList(); for (int i = 0; i < model.Constants.Length; i++) { ConstantMapping constant = ImportConstantMapping(model.Constants[i]); if (constant != null) constants.Add(constant); } if (constants.Count == 0) { throw new InvalidOperationException(Res.GetString(Res.XmlNoSerializableMembers, model.TypeDesc.FullName)); } mapping.Constants = (ConstantMapping[])constants.ToArray(typeof(ConstantMapping)); typeScope.AddTypeMapping(mapping); } return mapping; }