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);
}
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);
}
private MemberMapping[] ImportTypeMembers(XmlSchemaComplexType type, string typeNs, CodeIdentifiers members)
{
if (type.AnyAttribute != null)
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidAnyAttributeUse, type.Name, type.QualifiedName.Namespace));
}
XmlSchemaObjectCollection items = type.Attributes;
for (int i = 0; i < items.Count; i++)
{
object item = items[i];
if (item is XmlSchemaAttributeGroup)
{
throw new InvalidOperationException(SR.Format(SR.XmlSoapInvalidAttributeUse, type.Name, type.QualifiedName.Namespace));
}
if (item is XmlSchemaAttribute)
{
XmlSchemaAttribute attr = (XmlSchemaAttribute)item;
if (attr.Use != XmlSchemaUse.Prohibited)
{
throw new InvalidOperationException(SR.Format(SR.XmlSoapInvalidAttributeUse, type.Name, type.QualifiedName.Namespace));
}
}
}
if (type.Particle != null)
{
ImportGroup(type.Particle, members, typeNs);
}
else if (type.ContentModel != null && type.ContentModel is XmlSchemaComplexContent)
{
XmlSchemaComplexContent model = (XmlSchemaComplexContent)type.ContentModel;
if (model.Content is XmlSchemaComplexContentExtension)
{
if (((XmlSchemaComplexContentExtension)model.Content).Particle != null)
{
ImportGroup(((XmlSchemaComplexContentExtension)model.Content).Particle, members, typeNs);
}
}
else if (model.Content is XmlSchemaComplexContentRestriction)
{
if (((XmlSchemaComplexContentRestriction)model.Content).Particle != null)
{
ImportGroup(((XmlSchemaComplexContentRestriction)model.Content).Particle, members, typeNs);
}
}
}
return((MemberMapping[])members.ToArray(typeof(MemberMapping)));
}
private MemberMapping[] ImportTypeMembers(XmlSchemaComplexType type, string typeNs, CodeIdentifiers members)
{
if (type.AnyAttribute != null)
{
throw new InvalidOperationException(Res.GetString("XmlInvalidAnyAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
XmlSchemaObjectCollection attributes = type.Attributes;
for (int i = 0; i < attributes.Count; i++)
{
object obj2 = attributes[i];
if (obj2 is XmlSchemaAttributeGroup)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
if (obj2 is XmlSchemaAttribute)
{
XmlSchemaAttribute attribute = (XmlSchemaAttribute)obj2;
if (attribute.Use != XmlSchemaUse.Prohibited)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
}
}
if (type.Particle != null)
{
this.ImportGroup(type.Particle, members, typeNs);
}
else if ((type.ContentModel != null) && (type.ContentModel is XmlSchemaComplexContent))
{
XmlSchemaComplexContent contentModel = (XmlSchemaComplexContent)type.ContentModel;
if (contentModel.Content is XmlSchemaComplexContentExtension)
{
if (((XmlSchemaComplexContentExtension)contentModel.Content).Particle != null)
{
this.ImportGroup(((XmlSchemaComplexContentExtension)contentModel.Content).Particle, members, typeNs);
}
}
else if ((contentModel.Content is XmlSchemaComplexContentRestriction) && (((XmlSchemaComplexContentRestriction)contentModel.Content).Particle != null))
{
this.ImportGroup(((XmlSchemaComplexContentRestriction)contentModel.Content).Particle, members, typeNs);
}
}
return((MemberMapping[])members.ToArray(typeof(MemberMapping)));
}
MemberMapping[] ImportTypeMembers(XmlSchemaType type, string typeNs, string identifier, CodeIdentifiers members) {
TypeItems items = GetTypeItems(type);
bool mixed = IsMixed(type);
if (mixed) {
// check if we can transfer the attribute to the base class
XmlSchemaType t = type;
while (!t.DerivedFrom.IsEmpty) {
t = FindType(t.DerivedFrom);
if (IsMixed(t)) {
// keep the mixed attribute on the base class
mixed = false;
break;
}
}
}
if (items.Particle != null) {
ImportGroup(items.Particle, identifier, members, typeNs, mixed);
}
for (int i = 0; i < items.Attributes.Count; i++) {
object item = items.Attributes[i];
if (item is XmlSchemaAttribute) {
ImportAttributeMember((XmlSchemaAttribute)item, identifier, members, typeNs);
}
else if (item is XmlSchemaAttributeGroupRef) {
ImportAttributeGroupMembers(FindAttributeGroup(((XmlSchemaAttributeGroupRef)item).RefName), identifier, members, typeNs);
}
}
if (items.baseSimpleType != null) {
mixed = true;
}
if (items.AnyAttribute != null) {
ImportAnyAttributeMember(items.AnyAttribute, members);
}
else if (mixed && items.Particle == null) {
ImportTextMember(members, items.baseSimpleType);
}
ImportXmlnsDeclarationsMember(type, members);
return (MemberMapping[])members.ToArray(typeof(MemberMapping));
}
StructMapping ImportStructDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, Type baseType) {
string typeName = GenerateUniqueTypeName(identifier);
StructMapping structMapping = new StructMapping();
TypeFlags flags = TypeFlags.Reference;
TypeDesc baseTypeDesc = scope.GetTypeDesc(baseType);
structMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Struct, baseTypeDesc, flags);
structMapping.Namespace = typeNs;
structMapping.TypeName = identifier;
CodeIdentifiers members = new CodeIdentifiers();
members.AddReserved(typeName);
ImportTextMember(members, null);
structMapping.Members = (MemberMapping[])members.ToArray(typeof(MemberMapping));
scope.AddTypeMapping(structMapping);
return structMapping;
}
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;
}
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;
}
private MemberMapping[] ImportTypeMembers(XmlSchemaType type, string typeNs, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, INameScope elementsScope, ref bool needExplicitOrder, bool order, bool allowUnboundedElements)
{
TypeItems items = GetTypeItems(type);
bool mixed = IsMixed(type);
if (mixed)
{
// check if we can transfer the attribute to the base class
XmlSchemaType t = type;
while (!t.DerivedFrom.IsEmpty)
{
t = FindType(t.DerivedFrom, TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue);
if (IsMixed(t))
{
// keep the mixed attribute on the base class
mixed = false;
break;
}
}
}
if (items.Particle != null)
{
ImportGroup(items.Particle, identifier, members, membersScope, elementsScope, typeNs, mixed, ref needExplicitOrder, order, items.IsUnbounded, allowUnboundedElements);
}
for (int i = 0; i < items.Attributes.Count; i++)
{
object item = items.Attributes[i];
if (item is XmlSchemaAttribute)
{
ImportAttributeMember((XmlSchemaAttribute)item, identifier, members, membersScope, typeNs);
}
else if (item is XmlSchemaAttributeGroupRef)
{
XmlQualifiedName groupName = ((XmlSchemaAttributeGroupRef)item).RefName;
ImportAttributeGroupMembers(FindAttributeGroup(groupName), identifier, members, membersScope, groupName.Namespace);
}
}
if (items.AnyAttribute != null)
{
ImportAnyAttributeMember(items.AnyAttribute, members, membersScope);
}
if (items.baseSimpleType != null || (items.Particle == null && mixed))
{
ImportTextMember(members, membersScope, mixed ? null : items.baseSimpleType);
}
ImportXmlnsDeclarationsMember(type, members, membersScope);
MemberMapping[] typeMembers = (MemberMapping[])members.ToArray(typeof(MemberMapping));
return typeMembers;
}
private MemberMapping[] ImportTypeMembers(XmlSchemaComplexType type, string typeNs, CodeIdentifiers members)
{
if (type.AnyAttribute != null)
{
throw new InvalidOperationException(Res.GetString("XmlInvalidAnyAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
XmlSchemaObjectCollection attributes = type.Attributes;
for (int i = 0; i < attributes.Count; i++)
{
object obj2 = attributes[i];
if (obj2 is XmlSchemaAttributeGroup)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
if (obj2 is XmlSchemaAttribute)
{
XmlSchemaAttribute attribute = (XmlSchemaAttribute) obj2;
if (attribute.Use != XmlSchemaUse.Prohibited)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
}
}
if (type.Particle != null)
{
this.ImportGroup(type.Particle, members, typeNs);
}
else if ((type.ContentModel != null) && (type.ContentModel is XmlSchemaComplexContent))
{
XmlSchemaComplexContent contentModel = (XmlSchemaComplexContent) type.ContentModel;
if (contentModel.Content is XmlSchemaComplexContentExtension)
{
if (((XmlSchemaComplexContentExtension) contentModel.Content).Particle != null)
{
this.ImportGroup(((XmlSchemaComplexContentExtension) contentModel.Content).Particle, members, typeNs);
}
}
else if ((contentModel.Content is XmlSchemaComplexContentRestriction) && (((XmlSchemaComplexContentRestriction) contentModel.Content).Particle != null))
{
this.ImportGroup(((XmlSchemaComplexContentRestriction) contentModel.Content).Particle, members, typeNs);
}
}
return (MemberMapping[]) members.ToArray(typeof(MemberMapping));
}
MemberMapping[] ImportTypeMembers(XmlSchemaComplexType type, string typeNs, CodeIdentifiers members) {
if (type.AnyAttribute != null) {
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidAnyAttributeUse, type.Name, type.QualifiedName.Namespace));
}
XmlSchemaObjectCollection items = type.Attributes;
for (int i = 0; i < items.Count; i++) {
object item = items[i];
if (item is XmlSchemaAttributeGroup) {
throw new InvalidOperationException(Res.GetString(Res.XmlSoapInvalidAttributeUse, type.Name, type.QualifiedName.Namespace));
}
if (item is XmlSchemaAttribute) {
XmlSchemaAttribute attr = (XmlSchemaAttribute)item;
if (attr.Use != XmlSchemaUse.Prohibited) throw new InvalidOperationException(Res.GetString(Res.XmlSoapInvalidAttributeUse, type.Name, type.QualifiedName.Namespace));
}
}
if (type.Particle != null) {
ImportGroup(type.Particle, members, typeNs);
}
else if (type.ContentModel != null && type.ContentModel is XmlSchemaComplexContent) {
XmlSchemaComplexContent model = (XmlSchemaComplexContent)type.ContentModel;
if (model.Content is XmlSchemaComplexContentExtension) {
if (((XmlSchemaComplexContentExtension)model.Content).Particle != null) {
ImportGroup(((XmlSchemaComplexContentExtension)model.Content).Particle, members, typeNs);
}
}
else if (model.Content is XmlSchemaComplexContentRestriction) {
if (((XmlSchemaComplexContentRestriction)model.Content).Particle != null) {
ImportGroup(((XmlSchemaComplexContentRestriction)model.Content).Particle, members, typeNs);
}
}
}
return (MemberMapping[])members.ToArray(typeof(MemberMapping));
}
private StructMapping ImportStructDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, Type baseType)
{
identifier = Accessor.UnescapeName(identifier);
string name = base.GenerateUniqueTypeName(identifier);
StructMapping typeMapping = new StructMapping {
IsReference = base.Schemas.IsReference(dataType)
};
TypeFlags reference = TypeFlags.Reference;
TypeDesc typeDesc = base.Scope.GetTypeDesc(baseType);
typeMapping.TypeDesc = new TypeDesc(name, name, TypeKind.Struct, typeDesc, reference);
typeMapping.Namespace = typeNs;
typeMapping.TypeName = identifier;
CodeIdentifiers scope = new CodeIdentifiers();
scope.AddReserved(name);
base.AddReservedIdentifiersForDataBinding(scope);
this.ImportTextMember(scope, new CodeIdentifiers(), null);
typeMapping.Members = (MemberMapping[]) scope.ToArray(typeof(MemberMapping));
typeMapping.Scope = scope;
base.Scope.AddTypeMapping(typeMapping);
return typeMapping;
}
private TypeMapping ImportEnumeratedDataType(XmlSchemaSimpleType dataType, string typeNs, string identifier, TypeFlags flags, bool isList)
{
TypeMapping defaultMapping = (TypeMapping) base.ImportedMappings[dataType];
if (defaultMapping != null)
{
return defaultMapping;
}
XmlSchemaType type = dataType;
while (!type.DerivedFrom.IsEmpty)
{
type = this.FindType(type.DerivedFrom, TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
}
if (type is XmlSchemaComplexType)
{
return null;
}
TypeDesc typeDesc = base.Scope.GetTypeDesc((XmlSchemaSimpleType) type);
if ((typeDesc != null) && (typeDesc.FullName != typeof(string).FullName))
{
return this.ImportPrimitiveDataType(dataType, flags);
}
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)
};
if ((dataType.Name != null) && (dataType.Name.Length > 0))
{
mapping2.TypeName = identifier;
}
mapping2.Namespace = typeNs;
mapping2.IsFlags = isList;
CodeIdentifiers identifiers = new CodeIdentifiers();
XmlSchemaSimpleTypeContent content = dataType.Content;
if (content is XmlSchemaSimpleTypeRestriction)
{
XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) content;
for (int i = 0; i < restriction.Facets.Count; i++)
{
object obj2 = restriction.Facets[i];
if (obj2 is XmlSchemaEnumerationFacet)
{
XmlSchemaEnumerationFacet facet = (XmlSchemaEnumerationFacet) obj2;
if ((typeDesc != null) && typeDesc.HasCustomFormatter)
{
XmlCustomFormatter.ToDefaultValue(facet.Value, typeDesc.FormatterName);
}
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))
{
defaultMapping = this.GetDefaultMapping(TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.CanBeAttributeValue);
base.ImportedMappings.Add(dataType, defaultMapping);
return defaultMapping;
}
base.ImportedMappings.Add(dataType, mapping2);
base.Scope.AddTypeMapping(mapping2);
return mapping2;
}
private EnumMapping ImportEnumeratedChoice(ElementAccessor[] choice, string typeNs, string typeName)
{
typeName = this.GenerateUniqueTypeName(Accessor.UnescapeName(typeName), typeNs);
EnumMapping typeMapping = new EnumMapping {
TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Enum, null, TypeFlags.None),
TypeName = typeName,
Namespace = typeNs,
IsFlags = false,
IncludeInSchema = false
};
if (this.GenerateOrder)
{
Array.Sort(choice, new ElementComparer());
}
CodeIdentifiers identifiers = new CodeIdentifiers();
for (int i = 0; i < choice.Length; i++)
{
ElementAccessor accessor = choice[i];
ConstantMapping mapping2 = new ConstantMapping();
string identifier = CodeIdentifier.MakeValid(accessor.Name);
mapping2.Name = identifiers.AddUnique(identifier, mapping2);
mapping2.XmlName = accessor.ToString(typeNs);
mapping2.Value = i;
}
typeMapping.Constants = (ConstantMapping[]) identifiers.ToArray(typeof(ConstantMapping));
base.Scope.AddTypeMapping(typeMapping);
return typeMapping;
}
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;
}
private MemberMapping[] ImportTypeMembers(XmlSchemaType type, string typeNs, string identifier, CodeIdentifiers members, CodeIdentifiers membersScope, INameScope elementsScope, ref bool needExplicitOrder, bool order, bool allowUnboundedElements)
{
TypeItems typeItems = this.GetTypeItems(type);
bool mixed = IsMixed(type);
if (mixed)
{
XmlSchemaType type2 = type;
while (!type2.DerivedFrom.IsEmpty)
{
type2 = this.FindType(type2.DerivedFrom, TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue);
if (IsMixed(type2))
{
mixed = false;
break;
}
}
}
if (typeItems.Particle != null)
{
this.ImportGroup(typeItems.Particle, identifier, members, membersScope, elementsScope, typeNs, mixed, ref needExplicitOrder, order, typeItems.IsUnbounded, allowUnboundedElements);
}
for (int i = 0; i < typeItems.Attributes.Count; i++)
{
object obj2 = typeItems.Attributes[i];
if (obj2 is XmlSchemaAttribute)
{
this.ImportAttributeMember((XmlSchemaAttribute) obj2, identifier, members, membersScope, typeNs);
}
else if (obj2 is XmlSchemaAttributeGroupRef)
{
XmlQualifiedName refName = ((XmlSchemaAttributeGroupRef) obj2).RefName;
this.ImportAttributeGroupMembers(this.FindAttributeGroup(refName), identifier, members, membersScope, refName.Namespace);
}
}
if (typeItems.AnyAttribute != null)
{
this.ImportAnyAttributeMember(typeItems.AnyAttribute, members, membersScope);
}
if ((typeItems.baseSimpleType != null) || ((typeItems.Particle == null) && mixed))
{
this.ImportTextMember(members, membersScope, mixed ? null : typeItems.baseSimpleType);
}
this.ImportXmlnsDeclarationsMember(type, members, membersScope);
return (MemberMapping[]) members.ToArray(typeof(MemberMapping));
}
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 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;
}
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;
}
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;
}
