private object ReadListElement(XmlTypeMapping typeMap, bool isNullable, object list, bool canCreateInstance) { Type type = typeMap.TypeData.Type; ListMap listMap = (ListMap)typeMap.ObjectMap; if (type.IsArray && base.ReadNull()) { return(null); } if (list == null) { if (!canCreateInstance || !typeMap.TypeData.HasPublicConstructor) { throw base.CreateReadOnlyCollectionException(typeMap.TypeFullName); } list = this.CreateList(type); } if (base.Reader.IsEmptyElement) { base.Reader.Skip(); if (type.IsArray) { list = base.ShrinkArray((Array)list, 0, type.GetElementType(), false); } return(list); } int length = 0; base.Reader.ReadStartElement(); base.Reader.MoveToContent(); while (base.Reader.NodeType != XmlNodeType.EndElement) { if (base.Reader.NodeType == XmlNodeType.Element) { XmlTypeMapElementInfo xmlTypeMapElementInfo = listMap.FindElement(base.Reader.LocalName, base.Reader.NamespaceURI); if (xmlTypeMapElementInfo != null) { this.AddListValue(typeMap.TypeData, ref list, length++, this.ReadObjectElement(xmlTypeMapElementInfo), false); } else { base.UnknownNode(null); } } else { base.UnknownNode(null); } base.Reader.MoveToContent(); } base.ReadEndElement(); if (type.IsArray) { list = base.ShrinkArray((Array)list, length, type.GetElementType(), false); } return(list); }
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns, bool forceUseMemberName) { CodeAttributeDeclaration att; TypeData memType = member.TypeMapMember.TypeData; if (member.Any) { XmlTypeMapElementInfoList list = (XmlTypeMapElementInfoList)((XmlTypeMapMemberElement)member.TypeMapMember).ElementInfo; foreach (XmlTypeMapElementInfo info in list) { if (info.IsTextElement) { metadata.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlText")); } else { att = new CodeAttributeDeclaration("System.Xml.Serialization.XmlAnyElement"); if (!info.IsUnnamedAnyElement) { att.Arguments.Add(MapCodeGenerator.GetArg("Name", info.ElementName)); if (info.Namespace != ns) { att.Arguments.Add(MapCodeGenerator.GetArg("Namespace", member.Namespace)); } } metadata.Add(att); } } } else if (member.TypeMapMember is XmlTypeMapMemberList) { // Array parameter XmlTypeMapMemberList list = member.TypeMapMember as XmlTypeMapMemberList; ListMap listMap = (ListMap)list.ListTypeMapping.ObjectMap; codeGenerator.AddArrayAttributes(metadata, list, ns, forceUseMemberName); codeGenerator.AddArrayItemAttributes(metadata, listMap, memType.ListItemTypeData, list.Namespace, 0); } else if (member.TypeMapMember is XmlTypeMapMemberElement) { codeGenerator.AddElementMemberAttributes((XmlTypeMapMemberElement)member.TypeMapMember, ns, metadata, forceUseMemberName); } else if (member.TypeMapMember is XmlTypeMapMemberAttribute) { codeGenerator.AddAttributeMemberAttributes((XmlTypeMapMemberAttribute)member.TypeMapMember, ns, metadata, forceUseMemberName); } else { throw new NotSupportedException("Schema type not supported"); } }
XmlTypeMapping ImportListMapping(TypeData typeData, string defaultNamespace) { Type type = typeData.Type; XmlTypeMapping map = helper.GetRegisteredClrType(type, XmlSerializer.EncodingNamespace); if (map != null) { return(map); } ListMap obmap = new ListMap(); TypeData itemTypeData = typeData.ListItemTypeData; map = CreateTypeMapping(typeData, "Array", XmlSerializer.EncodingNamespace); helper.RegisterClrType(map, type, XmlSerializer.EncodingNamespace); map.MultiReferenceType = true; map.ObjectMap = obmap; XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(null, itemTypeData); if (elem.TypeData.IsComplexType) { elem.MappedType = ImportTypeMapping(typeData.ListItemType, defaultNamespace); elem.TypeData = elem.MappedType.TypeData; } elem.ElementName = "Item"; elem.Namespace = string.Empty; elem.IsNullable = true; // By default, items are nullable XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); list.Add(elem); obmap.ItemInfo = list; XmlTypeMapping objMap = ImportTypeMapping(typeof(object), defaultNamespace); objMap.DerivedTypes.Add(map); // Register any of the including types as a derived class of object SoapIncludeAttribute[] includes = (SoapIncludeAttribute[])type.GetCustomAttributes(typeof(SoapIncludeAttribute), false); for (int i = 0; i < includes.Length; i++) { Type includedType = includes[i].Type; objMap.DerivedTypes.Add(ImportTypeMapping(includedType, defaultNamespace)); } return(map); }
void ExportArrayCode(XmlTypeMapping map) { ListMap listMap = (ListMap)map.ObjectMap; foreach (XmlTypeMapElementInfo ainfo in listMap.ItemInfo) { if (ainfo.MappedType != null) { if (!IsMapExported(ainfo.MappedType) && includeArrayTypes) { AddInclude(ainfo.MappedType); } ExportMapCode(ainfo.MappedType, false); } } }
void AddArrayElementFieldMember(CodeTypeDeclaration codeClass, XmlTypeMapMemberList member, string defaultNamespace) { CodeTypeMember codeField = CreateFieldMember(codeClass, member.TypeData, member.Name); CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection(); AddArrayAttributes(attributes, member, defaultNamespace, false); ListMap listMap = (ListMap)member.ListTypeMapping.ObjectMap; AddArrayItemAttributes(attributes, listMap, member.TypeData.ListItemTypeData, defaultNamespace, 0); if (attributes.Count > 0) { codeField.CustomAttributes = attributes; } }
private XmlTypeMapping ImportListMapping(TypeData typeData, string defaultNamespace) { Type type = typeData.Type; XmlTypeMapping xmlTypeMapping = this.helper.GetRegisteredClrType(type, "http://schemas.xmlsoap.org/soap/encoding/"); if (xmlTypeMapping != null) { return(xmlTypeMapping); } ListMap listMap = new ListMap(); TypeData listItemTypeData = typeData.ListItemTypeData; xmlTypeMapping = this.CreateTypeMapping(typeData, "Array", "http://schemas.xmlsoap.org/soap/encoding/"); this.helper.RegisterClrType(xmlTypeMapping, type, "http://schemas.xmlsoap.org/soap/encoding/"); xmlTypeMapping.MultiReferenceType = true; xmlTypeMapping.ObjectMap = listMap; XmlTypeMapElementInfo xmlTypeMapElementInfo = new XmlTypeMapElementInfo(null, listItemTypeData); if (xmlTypeMapElementInfo.TypeData.IsComplexType) { xmlTypeMapElementInfo.MappedType = this.ImportTypeMapping(typeData.ListItemType, defaultNamespace); xmlTypeMapElementInfo.TypeData = xmlTypeMapElementInfo.MappedType.TypeData; } xmlTypeMapElementInfo.ElementName = "Item"; xmlTypeMapElementInfo.Namespace = string.Empty; xmlTypeMapElementInfo.IsNullable = true; listMap.ItemInfo = new XmlTypeMapElementInfoList { xmlTypeMapElementInfo }; XmlTypeMapping xmlTypeMapping2 = this.ImportTypeMapping(typeof(object), defaultNamespace); xmlTypeMapping2.DerivedTypes.Add(xmlTypeMapping); SoapIncludeAttribute[] array = (SoapIncludeAttribute[])type.GetCustomAttributes(typeof(SoapIncludeAttribute), false); for (int i = 0; i < array.Length; i++) { Type type2 = array[i].Type; xmlTypeMapping2.DerivedTypes.Add(this.ImportTypeMapping(type2, defaultNamespace)); } return(xmlTypeMapping); }
void AddArrayElementFieldMember(CodeTypeDeclaration codeClass, XmlTypeMapMemberList member, string defaultNamespace) { CodeMemberField codeField = new CodeMemberField(GetDomType(member.TypeData), member.Name); AddComments(codeField, member.Documentation); codeField.Attributes = MemberAttributes.Public; codeClass.Members.Add(codeField); CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection(); AddArrayAttributes(attributes, member, defaultNamespace, false); ListMap listMap = (ListMap)member.ListTypeMapping.ObjectMap; AddArrayItemAttributes(attributes, listMap, member.TypeData.ListItemTypeData, defaultNamespace, 0); if (attributes.Count > 0) { codeField.CustomAttributes = attributes; } }
public override bool Equals(object other) { ListMap listMap = other as ListMap; if (listMap == null) { return(false); } if (this._itemInfo.Count != listMap._itemInfo.Count) { return(false); } for (int i = 0; i < this._itemInfo.Count; i++) { if (!this._itemInfo[i].Equals(listMap._itemInfo[i])) { return(false); } } return(true); }
public override bool Equals(object other) { ListMap lmap = other as ListMap; if (lmap == null) { return(false); } if (_itemInfo.Count != lmap._itemInfo.Count) { return(false); } for (int n = 0; n < _itemInfo.Count; n++) { if (!_itemInfo[n].Equals(lmap._itemInfo[n])) { return(false); } } return(true); }
private object ReadListString(XmlTypeMapping typeMap, string values) { Type type = typeMap.TypeData.Type; ListMap listMap = (ListMap)typeMap.ObjectMap; values = values.Trim(); if (values == string.Empty) { return(Array.CreateInstance(type.GetElementType(), 0)); } string[] array = values.Split(new char[] { ' ' }); Array array2 = Array.CreateInstance(type.GetElementType(), array.Length); XmlTypeMapElementInfo xmlTypeMapElementInfo = (XmlTypeMapElementInfo)listMap.ItemInfo[0]; for (int i = 0; i < array.Length; i++) { array2.SetValue(this.GetValueFromXmlString(array[i], xmlTypeMapElementInfo.TypeData, xmlTypeMapElementInfo.MappedType), i); } return(array2); }
object ReadListString(XmlTypeMapping typeMap, string values) { Type listType = typeMap.TypeData.Type; ListMap listMap = (ListMap)typeMap.ObjectMap; values = values.Trim(); if (values == string.Empty) { return(Array.CreateInstance(listType.GetElementType(), 0)); } string[] valueArray = values.Split(' '); Array list = Array.CreateInstance(listType.GetElementType(), valueArray.Length); XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0]; for (int index = 0; index < valueArray.Length; index++) { list.SetValue(GetValueFromXmlString(valueArray[index], info.TypeData, info.MappedType), index); } return(list); }
protected virtual void GenerateArrayItemAttributes(CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel) { }
private void WriteListContent(object container, TypeData listType, ListMap map, object ob, StringBuilder targetString) { if (listType.Type.IsArray) { Array array = (Array)ob; for (int i = 0; i < array.Length; i++) { object value = array.GetValue(i); XmlTypeMapElementInfo xmlTypeMapElementInfo = map.FindElement(container, i, value); if (xmlTypeMapElementInfo != null && targetString == null) { this.WriteMemberElement(xmlTypeMapElementInfo, value); } else if (xmlTypeMapElementInfo != null && targetString != null) { targetString.Append(this.GetStringValue(xmlTypeMapElementInfo.MappedType, xmlTypeMapElementInfo.TypeData, value)).Append(" "); } else if (value != null) { throw base.CreateUnknownTypeException(value); } } } else if (ob is ICollection) { int num = (int)ob.GetType().GetProperty("Count").GetValue(ob, null); PropertyInfo indexerProperty = TypeData.GetIndexerProperty(listType.Type); object[] array2 = new object[1]; for (int j = 0; j < num; j++) { array2[0] = j; object value2 = indexerProperty.GetValue(ob, array2); XmlTypeMapElementInfo xmlTypeMapElementInfo2 = map.FindElement(container, j, value2); if (xmlTypeMapElementInfo2 != null && targetString == null) { this.WriteMemberElement(xmlTypeMapElementInfo2, value2); } else if (xmlTypeMapElementInfo2 != null && targetString != null) { targetString.Append(this.GetStringValue(xmlTypeMapElementInfo2.MappedType, xmlTypeMapElementInfo2.TypeData, value2)).Append(" "); } else if (value2 != null) { throw base.CreateUnknownTypeException(value2); } } } else { if (!(ob is IEnumerable)) { throw new Exception("Unsupported collection type"); } IEnumerable enumerable = (IEnumerable)ob; foreach (object obj in enumerable) { XmlTypeMapElementInfo xmlTypeMapElementInfo3 = map.FindElement(container, -1, obj); if (xmlTypeMapElementInfo3 != null && targetString == null) { this.WriteMemberElement(xmlTypeMapElementInfo3, obj); } else if (xmlTypeMapElementInfo3 != null && targetString != null) { targetString.Append(this.GetStringValue(xmlTypeMapElementInfo3.MappedType, xmlTypeMapElementInfo3.TypeData, obj)).Append(" "); } else if (obj != null) { throw base.CreateUnknownTypeException(obj); } } } }
XmlTypeMapping ImportListMapping (TypeData typeData, XmlRootAttribute root, string defaultNamespace, XmlAttributes atts, int nestingLevel) { Type type = typeData.Type; ListMap obmap = new ListMap (); if (!allowPrivateTypes) ReflectionHelper.CheckSerializableType (type, true); if (atts == null) atts = new XmlAttributes(); Type itemType = typeData.ListItemType; // warning: byte[][] should not be considered multiarray bool isMultiArray = (type.IsArray && (TypeTranslator.GetTypeData(itemType).SchemaType == SchemaTypes.Array) && itemType.IsArray); XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); foreach (XmlArrayItemAttribute att in atts.XmlArrayItems) { if (att.Namespace != null && att.Form == XmlSchemaForm.Unqualified) throw new InvalidOperationException ("XmlArrayItemAttribute.Form must not be Unqualified when it has an explicit Namespace value."); if (att.NestingLevel != nestingLevel) continue; Type elemType = (att.Type != null) ? att.Type : itemType; XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (null, TypeTranslator.GetTypeData(elemType, att.DataType)); elem.Namespace = att.Namespace != null ? att.Namespace : defaultNamespace; if (elem.Namespace == null) elem.Namespace = ""; elem.Form = att.Form; if (att.Form == XmlSchemaForm.Unqualified) elem.Namespace = string.Empty; elem.IsNullable = att.IsNullable && CanBeNull (elem.TypeData); elem.NestingLevel = att.NestingLevel; if (isMultiArray) { elem.MappedType = ImportListMapping (elemType, null, elem.Namespace, atts, nestingLevel + 1); } else if (elem.TypeData.IsComplexType) { elem.MappedType = ImportTypeMapping (elemType, null, elem.Namespace); } if (att.ElementName.Length != 0) { elem.ElementName = XmlConvert.EncodeLocalName (att.ElementName); } else if (elem.MappedType != null) { elem.ElementName = elem.MappedType.ElementName; } else { elem.ElementName = TypeTranslator.GetTypeData (elemType).XmlType; } list.Add (elem); } if (list.Count == 0) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (null, TypeTranslator.GetTypeData (itemType)); if (isMultiArray) elem.MappedType = ImportListMapping (itemType, null, defaultNamespace, atts, nestingLevel + 1); else if (elem.TypeData.IsComplexType) elem.MappedType = ImportTypeMapping (itemType, null, defaultNamespace); if (elem.MappedType != null) { elem.ElementName = elem.MappedType.XmlType; } else { elem.ElementName = TypeTranslator.GetTypeData (itemType).XmlType; } elem.Namespace = (defaultNamespace != null) ? defaultNamespace : ""; elem.IsNullable = CanBeNull (elem.TypeData); list.Add (elem); } obmap.ItemInfo = list; // If there can be different element names (types) in the array, then its name cannot // be "ArrayOfXXX" it must be something like ArrayOfChoiceNNN string baseName; if (list.Count > 1) { baseName = "ArrayOfChoice" + (arrayChoiceCount++); } else { XmlTypeMapElementInfo elem = ((XmlTypeMapElementInfo) list[0]); if (elem.MappedType != null) { baseName = TypeTranslator.GetArrayName (elem.MappedType.XmlType); } else { baseName = TypeTranslator.GetArrayName (elem.ElementName); } } // Avoid name colisions int nameCount = 1; string name = baseName; do { XmlTypeMapping foundMap = helper.GetRegisteredSchemaType (name, defaultNamespace); if (foundMap == null) nameCount = -1; else if (obmap.Equals (foundMap.ObjectMap) && typeData.Type == foundMap.TypeData.Type) return foundMap; else name = baseName + (nameCount++); } while (nameCount != -1); XmlTypeMapping map = CreateTypeMapping (typeData, root, name, defaultNamespace); map.ObjectMap = obmap; // Register any of the including types as a derived class of object XmlIncludeAttribute[] includes = (XmlIncludeAttribute[])type.GetCustomAttributes (typeof (XmlIncludeAttribute), false); XmlTypeMapping objectMapping = ImportTypeMapping (typeof(object)); for (int i = 0; i < includes.Length; i++) { Type includedType = includes[i].Type; objectMapping.DerivedTypes.Add(ImportTypeMapping (includedType, null, defaultNamespace)); } // Register this map as a derived class of object helper.RegisterSchemaType (map, name, defaultNamespace); ImportTypeMapping (typeof(object)).DerivedTypes.Add (map); return map; }
XmlTypeMapping GetTypeMapping (TypeData typeData) { if (typeData.Type == typeof(object) && !anyTypeImported) ImportAllObjectTypes (); XmlTypeMapping map = GetRegisteredTypeMapping (typeData); if (map != null) return map; if (typeData.IsListType) { // Create an array map for the type XmlTypeMapping itemMap = GetTypeMapping (typeData.ListItemTypeData); map = new XmlTypeMapping (typeData.XmlType, itemMap.Namespace, typeData, typeData.XmlType, itemMap.Namespace); map.IncludeInSchema = true; ListMap listMap = new ListMap (); listMap.ItemInfo = new XmlTypeMapElementInfoList(); listMap.ItemInfo.Add (CreateElementInfo (itemMap.Namespace, null, typeData.ListItemTypeData.XmlType, typeData.ListItemTypeData, false, XmlSchemaForm.None, -1)); map.ObjectMap = listMap; RegisterTypeMapping (new XmlQualifiedName(map.ElementName, map.Namespace), typeData, map); return map; } else if (typeData.SchemaType == SchemaTypes.Primitive || typeData.Type == typeof(object) || typeof(XmlNode).IsAssignableFrom(typeData.Type)) { return CreateSystemMap (typeData); } throw new InvalidOperationException ("Map for type " + typeData.TypeName + " not found"); }
void ImportChoiceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaChoice choice, CodeIdentifiers classIds, bool multiValue) { XmlTypeMapElementInfoList choices = new XmlTypeMapElementInfoList (); multiValue = ImportChoices (typeQName, null, choices, choice.Items) || multiValue; if (choices.Count == 0) return; if (choice.MaxOccurs > 1) multiValue = true; XmlTypeMapMemberElement member; if (multiValue) { member = new XmlTypeMapMemberFlatList (); member.Name = classIds.AddUnique ("Items", member); ListMap listMap = new ListMap (); listMap.ItemInfo = choices; ((XmlTypeMapMemberFlatList)member).ListMap = listMap; } else { member = new XmlTypeMapMemberElement (); member.Name = classIds.AddUnique ("Item", member); } // If all choices have the same type, use that type for the member. // If not use System.Object. // If there are at least two choices with the same type, use a choice // identifier attribute TypeData typeData = null; bool twoEqual = false; bool allEqual = true; Hashtable types = new Hashtable (); for (int n = choices.Count - 1; n >= 0; n--) { XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) choices [n]; // In some complex schemas, we may end up with several options // with the same name. It is better to ignore the extra options // than to crash. It's the best we can do, and btw it works // better than in MS.NET. if (cmap.GetElement (einfo.ElementName, einfo.Namespace, einfo.ExplicitOrder) != null || choices.IndexOfElement (einfo.ElementName, einfo.Namespace) != n) { choices.RemoveAt (n); continue; } if (types.ContainsKey (einfo.TypeData)) twoEqual = true; else types.Add (einfo.TypeData, einfo); TypeData choiceType = einfo.TypeData; if (choiceType.SchemaType == SchemaTypes.Class) { // When comparing class types, use the most generic class in the // inheritance hierarchy XmlTypeMapping choiceMap = GetTypeMapping (choiceType); BuildPendingMap (choiceMap); while (choiceMap.BaseMap != null) { choiceMap = choiceMap.BaseMap; BuildPendingMap (choiceMap); choiceType = choiceMap.TypeData; } } if (typeData == null) typeData = choiceType; else if (typeData != choiceType) allEqual = false; } if (!allEqual) typeData = TypeTranslator.GetTypeData (typeof(object)); if (twoEqual) { // Create the choice member XmlTypeMapMemberElement choiceMember = new XmlTypeMapMemberElement (); choiceMember.Ignore = true; choiceMember.Name = classIds.AddUnique (member.Name + "ElementName", choiceMember); member.ChoiceMember = choiceMember.Name; // Create the choice enum XmlTypeMapping enumMap = CreateTypeMapping (new XmlQualifiedName (member.Name + "ChoiceType", typeQName.Namespace), SchemaTypes.Enum, null); enumMap.IncludeInSchema = false; CodeIdentifiers codeIdents = new CodeIdentifiers (); EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [choices.Count]; for (int n=0; n<choices.Count; n++) { XmlTypeMapElementInfo it =(XmlTypeMapElementInfo) choices[n]; bool extraNs = (it.Namespace != null && it.Namespace != "" && it.Namespace != typeQName.Namespace); string xmlName = extraNs ? it.Namespace + ":" + it.ElementName : it.ElementName; string enumName = codeIdents.AddUnique (CodeIdentifier.MakeValid (it.ElementName), it); members [n] = new EnumMap.EnumMapMember (xmlName, enumName); } enumMap.ObjectMap = new EnumMap (members, false); choiceMember.TypeData = multiValue ? enumMap.TypeData.ListTypeData : enumMap.TypeData; choiceMember.ElementInfo.Add (CreateElementInfo (typeQName.Namespace, choiceMember, choiceMember.Name, choiceMember.TypeData, false, XmlSchemaForm.None, -1)); cmap.AddMember (choiceMember); } if (typeData == null) return; if (multiValue) typeData = typeData.ListTypeData; member.ElementInfo = choices; member.Documentation = GetDocumentation (choice); member.TypeData = typeData; cmap.AddMember (member); }
string GenerateWriteListContent (string container, TypeData listType, ListMap map, string ob, bool writeToString) { string targetString = null; if (writeToString) { targetString = GetStrTempVar (); WriteLine ("System.Text.StringBuilder " + targetString + " = new System.Text.StringBuilder();"); } if (listType.Type.IsArray) { string itemVar = GetNumTempVar (); WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Length; "+itemVar+"++) {"); GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString); WriteLineUni ("}"); } else if (typeof(ICollection).IsAssignableFrom (listType.Type)) { string itemVar = GetNumTempVar (); WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Count; "+itemVar+"++) {"); GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString); WriteLineUni ("}"); } else if (typeof(IEnumerable).IsAssignableFrom (listType.Type)) { string itemVar = GetObTempVar (); WriteLineInd ("foreach (" + listType.ListItemTypeData.CSharpFullName + " " + itemVar + " in " + ob + ") {"); GenerateListLoop (container, map, itemVar, null, listType.ListItemTypeData, targetString); WriteLineUni ("}"); } else throw new Exception ("Unsupported collection type"); return targetString; }
private XmlQualifiedName ExportArraySchema(XmlTypeMapping map, string defaultNamespace) { ListMap listMap = (ListMap)map.ObjectMap; if (this.encodedFormat) { string str; string text; listMap.GetArrayType(-1, out str, out text); string text2; if (text == "http://www.w3.org/2001/XMLSchema") { text2 = defaultNamespace; } else { text2 = text; } if (this.IsMapExported(map)) { return(new XmlQualifiedName(listMap.GetSchemaArrayName(), text2)); } this.SetMapExported(map); XmlSchema schema = this.GetSchema(text2); XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType(); xmlSchemaComplexType.Name = listMap.GetSchemaArrayName(); schema.Items.Add(xmlSchemaComplexType); XmlSchemaComplexContent xmlSchemaComplexContent = new XmlSchemaComplexContent(); xmlSchemaComplexContent.IsMixed = false; xmlSchemaComplexType.ContentModel = xmlSchemaComplexContent; XmlSchemaComplexContentRestriction xmlSchemaComplexContentRestriction = new XmlSchemaComplexContentRestriction(); xmlSchemaComplexContent.Content = xmlSchemaComplexContentRestriction; xmlSchemaComplexContentRestriction.BaseTypeName = new XmlQualifiedName("Array", "http://schemas.xmlsoap.org/soap/encoding/"); XmlSchemaAttribute xmlSchemaAttribute = new XmlSchemaAttribute(); xmlSchemaComplexContentRestriction.Attributes.Add(xmlSchemaAttribute); xmlSchemaAttribute.RefName = new XmlQualifiedName("arrayType", "http://schemas.xmlsoap.org/soap/encoding/"); XmlAttribute xmlAttribute = this.Document.CreateAttribute("arrayType", "http://schemas.xmlsoap.org/wsdl/"); xmlAttribute.Value = text + ((!(text != string.Empty)) ? string.Empty : ":") + str; xmlSchemaAttribute.UnhandledAttributes = new XmlAttribute[] { xmlAttribute }; this.ImportNamespace(schema, "http://schemas.xmlsoap.org/wsdl/"); XmlTypeMapElementInfo xmlTypeMapElementInfo = (XmlTypeMapElementInfo)listMap.ItemInfo[0]; if (xmlTypeMapElementInfo.MappedType != null) { switch (xmlTypeMapElementInfo.TypeData.SchemaType) { case SchemaTypes.Enum: this.ExportEnumSchema(xmlTypeMapElementInfo.MappedType); break; case SchemaTypes.Array: this.ExportArraySchema(xmlTypeMapElementInfo.MappedType, text2); break; case SchemaTypes.Class: this.ExportClassSchema(xmlTypeMapElementInfo.MappedType); break; } } return(new XmlQualifiedName(listMap.GetSchemaArrayName(), text2)); } else { if (this.IsMapExported(map)) { return(new XmlQualifiedName(map.XmlType, map.XmlTypeNamespace)); } this.SetMapExported(map); XmlSchema schema2 = this.GetSchema(map.XmlTypeNamespace); XmlSchemaComplexType xmlSchemaComplexType2 = new XmlSchemaComplexType(); xmlSchemaComplexType2.Name = map.ElementName; schema2.Items.Add(xmlSchemaComplexType2); XmlSchemaParticle schemaArrayElement = this.GetSchemaArrayElement(schema2, listMap.ItemInfo); if (schemaArrayElement is XmlSchemaChoice) { xmlSchemaComplexType2.Particle = schemaArrayElement; } else { xmlSchemaComplexType2.Particle = new XmlSchemaSequence { Items = { schemaArrayElement } }; } return(new XmlQualifiedName(map.XmlType, map.XmlTypeNamespace)); } }
XmlTypeMapping ImportListMapping(Type type, XmlRootAttribute root, string defaultNamespace, XmlAttributes atts, int nestingLevel) { TypeData typeData = TypeTranslator.GetTypeData(type); ListMap obmap = new ListMap(); if (!allowPrivateTypes) { ReflectionHelper.CheckSerializableType(type); } if (atts == null) { atts = new XmlAttributes(); } Type itemType = typeData.ListItemType; // warning: byte[][] should not be considered multiarray bool isMultiArray = (type.IsArray && (TypeTranslator.GetTypeData(itemType).SchemaType == SchemaTypes.Array) && itemType.IsArray); XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); foreach (XmlArrayItemAttribute att in atts.XmlArrayItems) { if (att.NestingLevel != nestingLevel) { continue; } Type elemType = (att.Type != null) ? att.Type : itemType; XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(null, TypeTranslator.GetTypeData(elemType, att.DataType)); elem.Namespace = att.Namespace != null ? att.Namespace : defaultNamespace; if (elem.Namespace == null) { elem.Namespace = ""; } elem.Form = att.Form; elem.IsNullable = att.IsNullable && CanBeNull(elem.TypeData); elem.NestingLevel = att.NestingLevel; if (isMultiArray) { elem.MappedType = ImportListMapping(elemType, null, elem.Namespace, atts, nestingLevel + 1); } else if (elem.TypeData.IsComplexType) { elem.MappedType = ImportTypeMapping(elemType, null, elem.Namespace); } if (att.ElementName != null) { elem.ElementName = att.ElementName; } else if (elem.MappedType != null) { elem.ElementName = elem.MappedType.ElementName; } else { elem.ElementName = TypeTranslator.GetTypeData(elemType).XmlType; } list.Add(elem); } if (list.Count == 0) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(null, TypeTranslator.GetTypeData(itemType)); if (isMultiArray) { elem.MappedType = ImportListMapping(itemType, null, defaultNamespace, atts, nestingLevel + 1); } else if (elem.TypeData.IsComplexType) { elem.MappedType = ImportTypeMapping(itemType, null, defaultNamespace); } if (elem.MappedType != null) { elem.ElementName = elem.MappedType.XmlType; } else { elem.ElementName = TypeTranslator.GetTypeData(itemType).XmlType; } elem.Namespace = (defaultNamespace != null) ? defaultNamespace : ""; elem.IsNullable = CanBeNull(elem.TypeData); list.Add(elem); } obmap.ItemInfo = list; // If there can be different element names (types) in the array, then its name cannot // be "ArrayOfXXX" it must be something like ArrayOfChoiceNNN string baseName; if (list.Count > 1) { baseName = "ArrayOfChoice" + (arrayChoiceCount++); } else { XmlTypeMapElementInfo elem = ((XmlTypeMapElementInfo)list[0]); if (elem.MappedType != null) { baseName = TypeTranslator.GetArrayName(elem.MappedType.XmlType); } else { baseName = TypeTranslator.GetArrayName(elem.ElementName); } } // Avoid name colisions int nameCount = 1; string name = baseName; do { XmlTypeMapping foundMap = helper.GetRegisteredSchemaType(name, defaultNamespace); if (foundMap == null) { nameCount = -1; } else if (obmap.Equals(foundMap.ObjectMap) && typeData.Type == foundMap.TypeData.Type) { return(foundMap); } else { name = baseName + (nameCount++); } }while (nameCount != -1); XmlTypeMapping map = CreateTypeMapping(typeData, root, name, defaultNamespace); map.ObjectMap = obmap; // Register any of the including types as a derived class of object XmlIncludeAttribute[] includes = (XmlIncludeAttribute[])type.GetCustomAttributes(typeof(XmlIncludeAttribute), false); XmlTypeMapping objectMapping = ImportTypeMapping(typeof(object)); for (int i = 0; i < includes.Length; i++) { Type includedType = includes[i].Type; objectMapping.DerivedTypes.Add(ImportTypeMapping(includedType, null, defaultNamespace)); } // Register this map as a derived class of object helper.RegisterSchemaType(map, name, defaultNamespace); ImportTypeMapping(typeof(object)).DerivedTypes.Add(map); return(map); }
object ReadListElement(XmlTypeMapping typeMap, bool isNullable, object list, bool canCreateInstance) { Type listType = typeMap.TypeData.Type; ListMap listMap = (ListMap)typeMap.ObjectMap; if (listType.IsArray && ReadNull()) { return(null); } if (list == null) { if (canCreateInstance && typeMap.TypeData.HasPublicConstructor) { list = CreateList(listType); } else { throw CreateReadOnlyCollectionException(typeMap.TypeFullName); } } if (Reader.IsEmptyElement) { Reader.Skip(); if (listType.IsArray) { list = ShrinkArray((Array)list, 0, listType.GetElementType(), false); } return(list); } int index = 0; Reader.ReadStartElement(); Reader.MoveToContent(); while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { XmlTypeMapElementInfo elemInfo = listMap.FindElement(Reader.LocalName, Reader.NamespaceURI); if (elemInfo != null) { AddListValue(typeMap.TypeData, ref list, index++, ReadObjectElement(elemInfo), false); } else { UnknownNode(null); } } else { UnknownNode(null); } Reader.MoveToContent(); } ReadEndElement(); if (listType.IsArray) { list = ShrinkArray((Array)list, index, listType.GetElementType(), false); } return(list); }
XmlTypeMapping GetTypeMapping (TypeData typeData) { XmlTypeMapping map = (XmlTypeMapping) dataMappedTypes [typeData]; if (map != null) return map; if (map == null && typeData.IsListType) { // Create an array map for the type XmlTypeMapping itemMap = GetTypeMapping (typeData.ListItemTypeData); map = new XmlTypeMapping (typeData.XmlType, itemMap.Namespace, typeData, typeData.XmlType, itemMap.Namespace); map.IncludeInSchema = true; ListMap listMap = new ListMap (); listMap.ItemInfo = new XmlTypeMapElementInfoList(); listMap.ItemInfo.Add (CreateElementInfo (itemMap.Namespace, null, typeData.ListItemTypeData.XmlType, typeData.ListItemTypeData, false, XmlSchemaForm.None)); map.ObjectMap = listMap; mappedTypes [new XmlQualifiedName(map.ElementName, map.Namespace)] = map; dataMappedTypes [typeData] = map; return map; } else if (typeData.SchemaType == SchemaTypes.Primitive || typeData.Type == typeof(object) || typeof(XmlNode).IsAssignableFrom(typeData.Type)) { map = new XmlTypeMapping (typeData.XmlType, XmlSchema.Namespace, typeData, typeData.XmlType, XmlSchema.Namespace); map.IncludeInSchema = false; map.ObjectMap = new ClassMap (); dataMappedTypes [typeData] = map; if (typeData.Type == typeof(object)) { // All complex types are subtypes of anyType, so all of them // must also be imported foreach (XmlSchema schema in schemas) { foreach (XmlSchemaObject sob in schema.Items) { XmlSchemaComplexType sct = sob as XmlSchemaComplexType; if (sct != null) ImportType (new XmlQualifiedName (sct.Name, schema.TargetNamespace), sct, null); } } } return map; } throw new InvalidOperationException ("Map for type " + typeData.TypeName + " not found"); }
public void AddArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, string defaultNamespace, int nestingLevel) { foreach (XmlTypeMapElementInfo ainfo in listMap.ItemInfo) { string defaultName; if (ainfo.MappedType != null) defaultName = ainfo.MappedType.ElementName; else defaultName = ainfo.TypeData.XmlType; GenerateArrayItemAttributes (attributes, listMap, type, ainfo, defaultName, defaultNamespace, nestingLevel); if (ainfo.MappedType != null) { if (!IsMapExported (ainfo.MappedType) && includeArrayTypes) AddInclude (ainfo.MappedType); ExportMapCode (ainfo.MappedType); } } if (listMap.IsMultiArray) { XmlTypeMapping nmap = listMap.NestedArrayMapping; AddArrayItemAttributes (attributes, (ListMap) nmap.ObjectMap, nmap.TypeData.ListItemTypeData, defaultNamespace, nestingLevel + 1); } }
protected override void GenerateArrayItemAttributes(CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel) { bool needsType = (listMap.ItemInfo.Count > 1) || (ainfo.TypeData.FullTypeName != type.FullTypeName && !listMap.IsMultiArray); CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Xml.Serialization.XmlArrayItem"); if (ainfo.ElementName != defaultName) { att.Arguments.Add(GetArg("ElementName", ainfo.ElementName)); } if (ainfo.Namespace != defaultNamespace && ainfo.Namespace != XmlSchema.Namespace) { att.Arguments.Add(GetArg("Namespace", ainfo.Namespace)); } if (needsType) { att.Arguments.Add(GetTypeArg("Type", ainfo.TypeData.FullTypeName)); } if (!ainfo.IsNullable) { att.Arguments.Add(GetArg("IsNullable", false)); } if (ainfo.Form == XmlSchemaForm.Unqualified) { att.Arguments.Add(MapCodeGenerator.GetEnumArg("Form", "System.Xml.Schema.XmlSchemaForm", ainfo.Form.ToString())); } if (att.Arguments.Count > 0 && nestingLevel > 0) { att.Arguments.Add(GetArg("NestingLevel", nestingLevel)); } if (att.Arguments.Count > 0) { attributes.Add(att); } }
XmlQualifiedName ExportArraySchema(XmlTypeMapping map, string defaultNamespace) { ListMap lmap = (ListMap)map.ObjectMap; if (encodedFormat) { string name, ns, schemaNs; lmap.GetArrayType(-1, out name, out ns); if (ns == XmlSchema.Namespace) { schemaNs = defaultNamespace; } else { schemaNs = ns; } if (IsMapExported(map)) { return(new XmlQualifiedName(lmap.GetSchemaArrayName(), schemaNs)); } SetMapExported(map); XmlSchema schema = GetSchema(schemaNs); XmlSchemaComplexType stype = new XmlSchemaComplexType(); stype.Name = lmap.GetSchemaArrayName(); schema.Items.Add(stype); XmlSchemaComplexContent content = new XmlSchemaComplexContent(); content.IsMixed = false; stype.ContentModel = content; XmlSchemaComplexContentRestriction rest = new XmlSchemaComplexContentRestriction(); content.Content = rest; rest.BaseTypeName = new XmlQualifiedName("Array", XmlSerializer.EncodingNamespace); XmlSchemaAttribute at = new XmlSchemaAttribute(); rest.Attributes.Add(at); at.RefName = new XmlQualifiedName("arrayType", XmlSerializer.EncodingNamespace); XmlAttribute arrayType = Document.CreateAttribute("arrayType", XmlSerializer.WsdlNamespace); arrayType.Value = ns + (ns != "" ? ":" : "") + name; at.UnhandledAttributes = new XmlAttribute [] { arrayType }; ImportNamespace(schema, XmlSerializer.WsdlNamespace); XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo)lmap.ItemInfo[0]; if (einfo.MappedType != null) { switch (einfo.TypeData.SchemaType) { case SchemaTypes.Enum: ExportEnumSchema(einfo.MappedType); break; case SchemaTypes.Array: ExportArraySchema(einfo.MappedType, schemaNs); break; case SchemaTypes.Class: ExportClassSchema(einfo.MappedType); break; } } return(new XmlQualifiedName(lmap.GetSchemaArrayName(), schemaNs)); } else { if (IsMapExported(map)) { return(new XmlQualifiedName(map.XmlType, map.XmlTypeNamespace)); } SetMapExported(map); XmlSchema schema = GetSchema(map.XmlTypeNamespace); XmlSchemaComplexType stype = new XmlSchemaComplexType(); stype.Name = map.ElementName; schema.Items.Add(stype); XmlSchemaParticle spart = GetSchemaArrayElement(schema, lmap.ItemInfo); if (spart is XmlSchemaChoice) { stype.Particle = spart; } else { XmlSchemaSequence seq = new XmlSchemaSequence(); seq.Items.Add(spart); stype.Particle = seq; } return(new XmlQualifiedName(map.XmlType, map.XmlTypeNamespace)); } }
void WriteListContent(object container, TypeData listType, ListMap map, object ob, StringBuilder targetString) { if (listType.Type.IsArray) { Array array = (Array)ob; for (int n = 0; n < array.Length; n++) { object item = array.GetValue(n); XmlTypeMapElementInfo info = map.FindElement(container, n, item); if (info != null && targetString == null) { WriteMemberElement(info, item); } else if (info != null && targetString != null) { targetString.Append(GetStringValue(info.MappedType, info.TypeData, item)).Append(" "); } else if (item != null) { throw CreateUnknownTypeException(item); } } } else if (ob is ICollection) { int count = (int)ob.GetType().GetProperty("Count").GetValue(ob, null); PropertyInfo itemProp = TypeData.GetIndexerProperty(listType.Type); object[] index = new object[1]; for (int n = 0; n < count; n++) { index[0] = n; object item = itemProp.GetValue(ob, index); XmlTypeMapElementInfo info = map.FindElement(container, n, item); if (info != null && targetString == null) { WriteMemberElement(info, item); } else if (info != null && targetString != null) { targetString.Append(GetStringValue(info.MappedType, info.TypeData, item)).Append(" "); } else if (item != null) { throw CreateUnknownTypeException(item); } } } else if (ob is IEnumerable) { IEnumerable e = (IEnumerable)ob; foreach (object item in e) { XmlTypeMapElementInfo info = map.FindElement(container, -1, item); if (info != null && targetString == null) { WriteMemberElement(info, item); } else if (info != null && targetString != null) { targetString.Append(GetStringValue(info.MappedType, info.TypeData, item)).Append(" "); } else if (item != null) { throw CreateUnknownTypeException(item); } } } else { throw new Exception("Unsupported collection type"); } }
void GenerateGetArrayType (ListMap map, string itemCount, out string localName, out string ns) { string arrayDim; if (itemCount != "") arrayDim = ""; else arrayDim = "[]"; XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) map.ItemInfo[0]; if (info.TypeData.SchemaType == SchemaTypes.Array) { string nm; GenerateGetArrayType ((ListMap)info.MappedType.ObjectMap, "", out nm, out ns); localName = nm + arrayDim; } else { if (info.MappedType != null) { localName = info.MappedType.XmlType + arrayDim; ns = info.MappedType.Namespace; } else { localName = info.TypeData.XmlType + arrayDim; ns = info.DataTypeNamespace; } } if (itemCount != "") { localName = "\"" + localName + "[\" + " + itemCount + " + \"]\""; ns = GetLiteral (ns); } }
XmlTypeMapping ImportListMapping (TypeData typeData, string defaultNamespace) { Type type = typeData.Type; XmlTypeMapping map = helper.GetRegisteredClrType (type, XmlSerializer.EncodingNamespace); if (map != null) return map; ListMap obmap = new ListMap (); TypeData itemTypeData = typeData.ListItemTypeData; map = CreateTypeMapping (typeData, "Array", XmlSerializer.EncodingNamespace); helper.RegisterClrType (map, type, XmlSerializer.EncodingNamespace); map.MultiReferenceType = true; map.ObjectMap = obmap; XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (null, itemTypeData); if (elem.TypeData.IsComplexType) { elem.MappedType = ImportTypeMapping (typeData.ListItemType, defaultNamespace); elem.TypeData = elem.MappedType.TypeData; } elem.ElementName = "Item"; elem.Namespace = string.Empty; elem.IsNullable = true; // By default, items are nullable XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); list.Add (elem); obmap.ItemInfo = list; XmlTypeMapping objMap = ImportTypeMapping (typeof(object), defaultNamespace); objMap.DerivedTypes.Add (map); // Register any of the including types as a derived class of object SoapIncludeAttribute[] includes = (SoapIncludeAttribute[])type.GetCustomAttributes (typeof (SoapIncludeAttribute), false); for (int i = 0; i < includes.Length; i++) { Type includedType = includes[i].Type; objMap.DerivedTypes.Add(ImportTypeMapping (includedType, defaultNamespace)); } return map; }
void GenerateListLoop (string container, ListMap map, string item, string index, TypeData itemTypeData, string targetString) { bool multichoice = (map.ItemInfo.Count > 1); if (map.ChoiceMember != null && container != null && index != null) { WriteLineInd ("if ((" + container + ".@" + map.ChoiceMember + " == null) || (" + index + " >= " + container + ".@" + map.ChoiceMember + ".Length))"); WriteLine ("throw CreateInvalidChoiceIdentifierValueException (" + container + ".GetType().ToString(), \"" + map.ChoiceMember + "\");"); Unindent (); } if (multichoice) WriteLine ("if (((object)" + item + ") == null) { }"); foreach (XmlTypeMapElementInfo info in map.ItemInfo) { if (map.ChoiceMember != null && multichoice) WriteLineInd ("else if (" + container + ".@" + map.ChoiceMember + "[" + index + "] == " + GetLiteral (info.ChoiceValue) + ") {"); else if (multichoice) WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.CSharpFullName + ")) {"); if (targetString == null) GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item)); else { string strVal = GenerateGetStringValue (info.MappedType, info.TypeData, GetCast (info.TypeData, itemTypeData, item), false); WriteLine (targetString + ".Append (" + strVal + ").Append (\" \");"); } if (multichoice) WriteLineUni ("}"); } if (multichoice) WriteLine ("else throw CreateUnknownTypeException (" + item + ");"); }
void WriteListContent (object container, TypeData listType, ListMap map, object ob, StringBuilder targetString) { if (listType.Type.IsArray) { Array array = (Array)ob; for (int n=0; n<array.Length; n++) { object item = array.GetValue (n); XmlTypeMapElementInfo info = map.FindElement (container, n, item); if (info != null && targetString == null) WriteMemberElement (info, item); else if (info != null && targetString != null) targetString.Append (GetStringValue (info.MappedType, info.TypeData, item)).Append (" "); else if (item != null) throw CreateUnknownTypeException (item); } } else if (ob is ICollection) { int count = (int) ob.GetType().GetProperty ("Count").GetValue(ob,null); PropertyInfo itemProp = TypeData.GetIndexerProperty (listType.Type); object[] index = new object[1]; for (int n=0; n<count; n++) { index[0] = n; object item = itemProp.GetValue (ob, index); XmlTypeMapElementInfo info = map.FindElement (container, n, item); if (info != null && targetString == null) WriteMemberElement (info, item); else if (info != null && targetString != null) targetString.Append (GetStringValue (info.MappedType, info.TypeData, item)).Append (" "); else if (item != null) throw CreateUnknownTypeException (item); } } else if (ob is IEnumerable) { IEnumerable e = (IEnumerable)ob; foreach (object item in e) { XmlTypeMapElementInfo info = map.FindElement (container, -1, item); if (info != null && targetString == null) WriteMemberElement (info, item); else if (info != null && targetString != null) targetString.Append (GetStringValue (info.MappedType, info.TypeData, item)).Append (" "); else if (item != null) throw CreateUnknownTypeException (item); } } else throw new Exception ("Unsupported collection type"); }
XmlTypeMapping ImportClassSimpleType (XmlQualifiedName typeQName, XmlSchemaSimpleType stype, XmlQualifiedName root) { if (CanBeEnum (stype)) { // Create an enum map CodeIdentifiers codeIdents = new CodeIdentifiers (); XmlTypeMapping enumMap = CreateTypeMapping (typeQName, SchemaTypes.Enum, root); enumMap.Documentation = GetDocumentation (stype); bool isFlags = false; if (stype.Content is XmlSchemaSimpleTypeList) { stype = ((XmlSchemaSimpleTypeList)stype.Content).ItemType; isFlags = true; } XmlSchemaSimpleTypeRestriction rest = (XmlSchemaSimpleTypeRestriction)stype.Content; codeIdents.AddReserved (enumMap.TypeData.TypeName); EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [rest.Facets.Count]; for (int n=0; n<rest.Facets.Count; n++) { XmlSchemaEnumerationFacet enu = (XmlSchemaEnumerationFacet) rest.Facets[n]; string enumName = codeIdents.AddUnique(CodeIdentifier.MakeValid (enu.Value), enu); members [n] = new EnumMap.EnumMapMember (enu.Value, enumName); members [n].Documentation = GetDocumentation (enu); } enumMap.ObjectMap = new EnumMap (members, isFlags); enumMap.IsSimpleType = true; return enumMap; } if (stype.Content is XmlSchemaSimpleTypeList) { XmlSchemaSimpleTypeList slist = (XmlSchemaSimpleTypeList)stype.Content; TypeData arrayTypeData = FindBuiltInType (slist.ItemTypeName, stype); ListMap listMap = new ListMap (); listMap.ItemInfo = new XmlTypeMapElementInfoList (); listMap.ItemInfo.Add (CreateElementInfo (typeQName.Namespace, null, "Item", arrayTypeData.ListItemTypeData, false, XmlSchemaForm.None, -1)); XmlTypeMapping map = CreateArrayTypeMapping (typeQName, arrayTypeData); map.ObjectMap = listMap; map.IsSimpleType = true; return map; } // It is an extension of a primitive or known type TypeData typeData = FindBuiltInType (typeQName, stype); XmlTypeMapping rmap = GetTypeMapping (typeData); // The resulting map must be a simple type. It needs to be explicitely set for arrays rmap.IsSimpleType = true; return rmap; }
void GenerateListLoop (ListMap map, string item, TypeData itemTypeData, string targetString) { bool multichoice = (map.ItemInfo.Count > 1); if (multichoice) WriteLine ("if (" + item + " == null) { }"); foreach (XmlTypeMapElementInfo info in map.ItemInfo) { if (multichoice) WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.FullTypeName + ")) {"); if (targetString == null) GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item)); else { string strVal = GenerateGetStringValue (info.MappedType, info.TypeData, GetCast (info.TypeData, itemTypeData, item)); WriteLine (targetString + ".Append (" + strVal + ").Append (\" \");"); } if (multichoice) WriteLineUni ("}"); } if (multichoice) WriteLine ("else throw CreateUnknownTypeException (" + item + ");"); }
ListMap BuildEncodedArrayMap (string type, string ns, out TypeData arrayTypeData) { ListMap map = new ListMap (); int i = type.LastIndexOf ("["); if (i == -1) throw new InvalidOperationException ("Invalid arrayType value: " + type); if (type.IndexOf (",",i) != -1) throw new InvalidOperationException ("Multidimensional arrays are not supported"); string itemType = type.Substring (0,i); TypeData itemTypeData; if (itemType.IndexOf ("[") != -1) { ListMap innerListMap = BuildEncodedArrayMap (itemType, ns, out itemTypeData); int dims = itemType.Split ('[').Length - 1; string name = TypeTranslator.GetArrayName (type, dims); XmlQualifiedName qname = new XmlQualifiedName (name, ns); XmlTypeMapping tmap = CreateArrayTypeMapping (qname, itemTypeData); tmap.ObjectMap = innerListMap; } else { itemTypeData = GetTypeData (new XmlQualifiedName (itemType, ns), null, false); } arrayTypeData = itemTypeData.ListTypeData; map.ItemInfo = new XmlTypeMapElementInfoList(); map.ItemInfo.Add (CreateElementInfo ("", null, "Item", itemTypeData, true, XmlSchemaForm.None, -1)); return map; }
public void AddArrayItemAttributes(CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, string defaultNamespace, int nestingLevel) { foreach (XmlTypeMapElementInfo ainfo in listMap.ItemInfo) { string defaultName; if (ainfo.MappedType != null) { defaultName = ainfo.MappedType.ElementName; } else { defaultName = ainfo.TypeData.XmlType; } GenerateArrayItemAttributes(attributes, listMap, type, ainfo, defaultName, defaultNamespace, nestingLevel); if (ainfo.MappedType != null) { if (!IsMapExported(ainfo.MappedType) && includeArrayTypes) { AddInclude(ainfo.MappedType); } ExportMapCode(ainfo.MappedType, false); } } if (listMap.IsMultiArray) { XmlTypeMapping nmap = listMap.NestedArrayMapping; AddArrayItemAttributes(attributes, (ListMap)nmap.ObjectMap, nmap.TypeData.ListItemTypeData, defaultNamespace, nestingLevel + 1); } }
protected override void GenerateArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel) { bool needsType = (listMap.ItemInfo.Count > 1) || (ainfo.TypeData.FullTypeName != type.FullTypeName && !listMap.IsMultiArray); CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlArrayItem"); if (ainfo.ElementName != defaultName) att.Arguments.Add (GetArg ("ElementName", ainfo.ElementName)); if (ainfo.Namespace != defaultNamespace && ainfo.Namespace != XmlSchema.Namespace) att.Arguments.Add (GetArg ("Namespace", ainfo.Namespace)); if (needsType) att.Arguments.Add (GetTypeArg ("Type", ainfo.TypeData.FullTypeName)); if (!ainfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", false)); if (ainfo.Form == XmlSchemaForm.Unqualified) att.Arguments.Add (MapCodeGenerator.GetEnumArg ("Form", "System.Xml.Schema.XmlSchemaForm", ainfo.Form.ToString())); if (att.Arguments.Count > 0 && nestingLevel > 0) att.Arguments.Add (GetArg ("NestingLevel", nestingLevel)); if (att.Arguments.Count > 0) attributes.Add (att); }
protected virtual void GenerateArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel) { }