} //WriteXmlSchemaSimpleType()
//XmlSchemaParticle
public static void WriteXmlSchemaParticle(XmlSchemaParticle particle,
XmlSchema myXmlSchema,
XmlTextWriter myXmlTextWriter)
{
if (particle is XmlSchemaElement)
{
WriteXmlSchemaElement((XmlSchemaElement)particle, myXmlSchema, myXmlTextWriter);
} //if
else if (particle is XmlSchemaSequence)
{
myXmlTextWriter.WriteStartElement("sequence", XmlSchema.Namespace);
foreach (XmlSchemaParticle particle1 in ((XmlSchemaSequence)particle).Items)
{
WriteXmlSchemaParticle(particle1, myXmlSchema, myXmlTextWriter);
}
myXmlTextWriter.WriteEndElement();
} //else if
else if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef xsgr = (XmlSchemaGroupRef)particle;
XmlSchemaGroup group = (XmlSchemaGroup)myXmlSchema.Groups[xsgr.RefName];
WriteXmlSchemaGroup(group, myXmlSchema, myXmlTextWriter, xsgr.RefName.Name);
} //else if
else
{
Console.WriteLine("Not Implemented for this type: {0}", particle.ToString());
} //else
} //WriteXmlSchemaParticle()
protected override void Visit(XmlSchemaGroupRef groupRef)
{
var group = _schemaSet.ResolveGroup(groupRef);
AddParent(group);
Traverse(group);
}
private void GenerateParticleField(XmlSchemaParticle particle)
{
if (particle is XmlSchemaAny)
{
GenerateParticleAnyField(particle
as XmlSchemaAny);
}
else if (particle is XmlSchemaElement)
{
GenerateElementField(particle
as XmlSchemaElement);
}
else if (particle is XmlSchemaAll)
{
GenerateParticleAllField(particle
as XmlSchemaAll);
}
else if (particle is XmlSchemaChoice)
{
GenerateParticleChoiceField(particle
as XmlSchemaChoice);
}
else if (particle is XmlSchemaSequence)
{
GenerateParticleSequenceField(particle
as XmlSchemaSequence);
}
else if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef gRef = particle
as XmlSchemaGroupRef;
GenerateGroupField(FindGroup(gRef.RefName));
}
}
/// <summary>
/// Parses xs:group ref="..." elements in the schema
/// </summary>
/// <param name="groupRef"></param>
/// <returns></returns>
private RecursiveChildren ParseGoupRef(XmlSchemaGroupRef groupRef)
{
log.WriteLine("Parsing groupRef {0}", groupRef.RefName);
using (log.Indent())
{
return(ParseGroupBase(groupRef.Particle));
}
}
public void IterateThrough(XmlSchemaGroupRef obj)
{
if (_functionalVisitor.StartProcessing(obj))
{
var group = XmlSchemaExtensions.GetGroup(_schemaSet, obj.RefName);
@group?.Accept(this);
}
_functionalVisitor.EndProcessing(obj);
}
protected override void Visit(XmlSchemaGroupRef groupRef)
{
if (groupRef.MaxOccurs == 0)
{
return;
}
var group = _schemaSetManager.SchemaSet.ResolveGroup(groupRef);
Traverse(group.Particle);
}
public static XmlSchemaGroup ResolveGroup(this XmlSchemaSet schemaSet, XmlSchemaGroupRef groupRef)
{
foreach (var schema in schemaSet.GetAllSchemas())
{
var group = (XmlSchemaGroup)schema.Groups[groupRef.RefName];
if (group != null)
{
return(group);
}
}
return(null);
}
/// <summary>Determines whether the specified <paramref name="element"/> is expected.</summary>
/// <param name="element">Element to check.</param>
/// <param name="elementName">
/// <see cref="XmlQualifiedName"/> of the <paramref name="element"/> (passed to avoid recreation).
/// </param>
/// <param name="expected">Expected schema particle.</param>
/// <returns>true if the element is expected; false otherwise.</returns>
private static bool IsElementExpected(XElement element, XmlQualifiedName elementName, XmlSchemaParticle expected)
{
Debug.Assert(element != null, "element != null");
Debug.Assert(elementName != null, "elementName != null");
Debug.Assert(expected != null, "expected != null");
Debug.Assert(
ToQualifiedName(element.Name) == elementName,
"ToQualifiedName(element.Name) == elementName -- otherwise the caller get the 'caching' wrong");
// These are all possibilities for a particle.
XmlSchemaGroupRef schemaGroupRef = expected as XmlSchemaGroupRef;
XmlSchemaAny schemaAny = expected as XmlSchemaAny;
XmlSchemaElement schemaElement = expected as XmlSchemaElement;
XmlSchemaAll schemaAll = expected as XmlSchemaAll;
XmlSchemaChoice schemaChoice = expected as XmlSchemaChoice;
XmlSchemaSequence schemaSequence = expected as XmlSchemaSequence;
Debug.Assert(schemaGroupRef == null, "schemaGroupRef == null -- the validator flattens this out as options.");
Debug.Assert(schemaSequence == null, "schemaSequence == null -- the validator flattens this out and picks the right one in seq.");
Debug.Assert(schemaAll == null, "schemaAll == null -- the validator flattens this out as options.");
Debug.Assert(schemaChoice == null, "schemaChoice == null -- the validator flattens this out as options.");
if (schemaAny != null)
{
Debug.Assert(
schemaAny.Namespace == "##other" || schemaAny.Namespace == "##any",
"schemaAny.Namespace == '##other' || '##any' -- otherwise CSDL XSD resource was changed");
if (schemaAny.Namespace == "##any")
{
return(true);
}
else if (schemaAny.Namespace == "##other")
{
string realElementNamespace = element.Name.NamespaceName;
if (realElementNamespace != GetTargetNamespace(expected))
{
return(true);
}
}
}
if (schemaElement != null)
{
if (schemaElement.QualifiedName == elementName)
{
return(true);
}
}
return(false);
}
internal XSModelGroupDefinition(XmlSchemaGroupRef xmlGroupRef)
{
_group = xmlGroupRef;
if (_group.Annotation is XmlSchemaAnnotation annotation)
{
_annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation);
_annotation.BindToContainer(RootContainer, this);
}
if (xmlGroupRef.RefName is XmlQualifiedName qualifiedName)
{
_reference = XMLSchemaSerializer.CreateXMLExpandedName(qualifiedName);
}
}
private void Write55_XmlSchemaGroupRef(XmlSchemaGroupRef o)
{
if (o != null)
{
this.WriteStartElement("group");
this.WriteAttribute("id", "", o.Id);
this.WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
this.WriteAttribute("maxOccurs", "", (o.MaxOccurs == 79228162514264337593543950335M) ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
if (!o.RefName.IsEmpty)
{
this.WriteAttribute("ref", "", o.RefName);
}
this.WriteAttributes(o.UnhandledAttributes, o);
this.Write5_XmlSchemaAnnotation(o.Annotation);
this.WriteEndElement();
}
}
void Write55_XmlSchemaGroupRef(XmlSchemaGroupRef o)
{
if ((object)o == null)
{
return;
}
WriteStartElement("group");
WriteAttribute(@"id", @"", ((System.String)o.@Id));
WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
WriteAttribute(@"maxOccurs", @"", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
if (!o.RefName.IsEmpty)
{
WriteAttribute("ref", "", o.RefName);
}
WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o);
Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.@Annotation);
WriteEndElement();
}
void CollectSubElements(XmlSchemaParticle particle)
{
// choice | sequence
XmlSchemaGroupBase sgb = particle as XmlSchemaGroupBase;
if (sgb != null)
{
foreach (XmlSchemaObject xso in sgb.Items)
{
XmlSchemaElement xse = xso as XmlSchemaElement;
if (xse != null)
{
// If it's a ref, xse.QualifiedName.Name is the name of the element
ElementWrapper elw = new ElementWrapper(xse, false);
if (elw.IsComplexType)
{
Add(this.complexSubElements, xse);
}
else
{
Add(this.simpleSubElements, xse);
}
continue;
}
XmlSchemaParticle subParticle = xso as XmlSchemaParticle;
if (subParticle != null)
{
CollectSubElements(subParticle);
continue;
}
}
}
// group
XmlSchemaGroupRef groupRef = particle as XmlSchemaGroupRef;
if (groupRef != null)
{
CollectSubElements(groupRef.Particle);
}
}
} //WriteExampleAttribute()
// Write example particles
public static void WriteExampleParticle(XmlSchemaParticle particle,
XmlSchema myXmlSchema,
XmlTextWriter myXmlTextWriter)
{
Decimal max;
if (particle.MaxOccurs == -1 || particle.MaxOccurs > 10000)
{
max = 5;
} //if
else
{
max = particle.MaxOccurs;
} //else
for (int i = 0; i < max; i++)
{
if (particle is XmlSchemaElement)
{
WriteExampleElement((XmlSchemaElement)particle, myXmlSchema, myXmlTextWriter);
} //if
else if (particle is XmlSchemaSequence)
{
foreach (XmlSchemaParticle particle1 in ((XmlSchemaSequence)particle).Items)
{
WriteExampleParticle(particle1, myXmlSchema, myXmlTextWriter);
}
} //else if
else if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef xsgr = (XmlSchemaGroupRef)particle;
XmlSchemaGroup group = (XmlSchemaGroup)myXmlSchema.Groups[xsgr.RefName];
WriteExampleParticle(group.Particle, myXmlSchema, myXmlTextWriter);
} //else if
else
{
Console.WriteLine("Not Implemented for this type: {0}", particle.ToString());
} //else
} //for
} //WriteExampleParticle()
void GetChildElementCompletionData(XmlCompletionDataList data, XmlSchemaGroupRef groupRef, string prefix)
{
var group = FindGroup(groupRef.RefName.Name);
if (group == null)
{
return;
}
var sequence = group.Particle as XmlSchemaSequence;
if (sequence != null)
{
GetChildElementCompletionData(data, sequence.Items, prefix);
return;
}
var choice = group.Particle as XmlSchemaChoice;
if (choice != null)
{
GetChildElementCompletionData(data, choice.Items, prefix);
return;
}
}
XmlSchemaElement FindElement(XmlSchemaGroupRef groupRef, QualifiedName name)
{
var group = FindGroup(groupRef.RefName.Name);
if (group == null)
{
return(null);
}
var sequence = group.Particle as XmlSchemaSequence;
if (sequence != null)
{
return(FindElement(sequence.Items, name));
}
var choice = group.Particle as XmlSchemaChoice;
if (choice != null)
{
return(FindElement(choice.Items, name));
}
return(null);
}
private bool LoadXmlSchemaGroupRef(XmlSchemaGroupRef groupRef)
{
if (groupRef == null)
{
return(false);
}
if (groupRef.RefName != null)
{
XmlSchemaParticle part = null;
string groupName = groupRef.RefName.Name;
if (xcontoler._complexTypes.ContainsKey(groupName))
{
XmlSchemaComplexType cct = xcontoler._complexTypes[groupName];
part = cct.Particle;
}
else if (xcontoler._groups.ContainsKey(groupName))
{
XmlSchemaGroup group = xcontoler._groups[groupName];
part = group.Particle;
}
LoadXmlSchemaObject(part);
}
return(true);
}
internal void Depends(XmlSchemaObject item, ArrayList refs)
{
if (item == null || scope[item] != null)
{
return;
}
Type t = item.GetType();
if (typeof(XmlSchemaType).IsAssignableFrom(t))
{
XmlQualifiedName baseName = XmlQualifiedName.Empty;
XmlSchemaType baseType = null;
XmlSchemaParticle particle = null;
XmlSchemaObjectCollection attributes = null;
if (item is XmlSchemaComplexType)
{
XmlSchemaComplexType ct = (XmlSchemaComplexType)item;
if (ct.ContentModel != null)
{
XmlSchemaContent content = ct.ContentModel.Content;
if (content is XmlSchemaComplexContentRestriction)
{
baseName = ((XmlSchemaComplexContentRestriction)content).BaseTypeName;
attributes = ((XmlSchemaComplexContentRestriction)content).Attributes;
}
else if (content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content;
if (restriction.BaseType != null)
{
baseType = restriction.BaseType;
}
else
{
baseName = restriction.BaseTypeName;
}
attributes = restriction.Attributes;
}
else if (content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
attributes = extension.Attributes;
particle = extension.Particle;
baseName = extension.BaseTypeName;
}
else if (content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension)content;
attributes = extension.Attributes;
baseName = extension.BaseTypeName;
}
}
else
{
attributes = ct.Attributes;
particle = ct.Particle;
}
if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef refGroup = (XmlSchemaGroupRef)particle;
particle = ((XmlSchemaGroup)schemas.Find(refGroup.RefName, typeof(XmlSchemaGroup), false)).Particle;
}
else if (particle is XmlSchemaGroupBase)
{
particle = (XmlSchemaGroupBase)particle;
}
}
else if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)item;
XmlSchemaSimpleTypeContent content = simpleType.Content;
if (content is XmlSchemaSimpleTypeRestriction)
{
baseType = ((XmlSchemaSimpleTypeRestriction)content).BaseType;
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (content is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)content;
if (list.ItemTypeName != null && !list.ItemTypeName.IsEmpty)
{
baseName = list.ItemTypeName;
}
if (list.ItemType != null)
{
baseType = list.ItemType;
}
}
else if (content is XmlSchemaSimpleTypeRestriction)
{
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (t == typeof(XmlSchemaSimpleTypeUnion))
{
XmlQualifiedName[] memberTypes = ((XmlSchemaSimpleTypeUnion)item).MemberTypes;
if (memberTypes != null)
{
for (int i = 0; i < memberTypes.Length; i++)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(memberTypes[i], typeof(XmlSchemaType), false);
AddRef(refs, type);
}
}
}
}
if (baseType == null && !baseName.IsEmpty && baseName.Namespace != XmlSchema.Namespace)
{
baseType = (XmlSchemaType)schemas.Find(baseName, typeof(XmlSchemaType), false);
}
if (baseType != null)
{
AddRef(refs, baseType);
}
if (particle != null)
{
Depends(particle, refs);
}
if (attributes != null)
{
for (int i = 0; i < attributes.Count; i++)
{
Depends(attributes[i], refs);
}
}
}
else if (t == typeof(XmlSchemaElement))
{
XmlSchemaElement el = (XmlSchemaElement)item;
if (!el.SubstitutionGroup.IsEmpty)
{
if (el.SubstitutionGroup.Namespace != XmlSchema.Namespace)
{
XmlSchemaElement head = (XmlSchemaElement)schemas.Find(el.SubstitutionGroup, typeof(XmlSchemaElement), false);
AddRef(refs, head);
}
}
if (!el.RefName.IsEmpty)
{
el = (XmlSchemaElement)schemas.Find(el.RefName, typeof(XmlSchemaElement), false);
AddRef(refs, el);
}
else if (!el.SchemaTypeName.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(el.SchemaTypeName, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
else
{
Depends(el.SchemaType, refs);
}
}
else if (t == typeof(XmlSchemaGroup))
{
Depends(((XmlSchemaGroup)item).Particle);
}
else if (t == typeof(XmlSchemaGroupRef))
{
XmlSchemaGroup group = (XmlSchemaGroup)schemas.Find(((XmlSchemaGroupRef)item).RefName, typeof(XmlSchemaGroup), false);
AddRef(refs, group);
}
else if (typeof(XmlSchemaGroupBase).IsAssignableFrom(t))
{
foreach (XmlSchemaObject o in ((XmlSchemaGroupBase)item).Items)
{
Depends(o, refs);
}
}
else if (t == typeof(XmlSchemaAttributeGroupRef))
{
XmlSchemaAttributeGroup group = (XmlSchemaAttributeGroup)schemas.Find(((XmlSchemaAttributeGroupRef)item).RefName, typeof(XmlSchemaAttributeGroup), false);
AddRef(refs, group);
}
else if (t == typeof(XmlSchemaAttributeGroup))
{
foreach (XmlSchemaObject o in ((XmlSchemaAttributeGroup)item).Attributes)
{
Depends(o, refs);
}
}
else if (t == typeof(XmlSchemaAttribute))
{
XmlSchemaAttribute at = (XmlSchemaAttribute)item;
if (!at.RefName.IsEmpty)
{
at = (XmlSchemaAttribute)schemas.Find(at.RefName, typeof(XmlSchemaAttribute), false);
AddRef(refs, at);
}
else if (!at.SchemaTypeName.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(at.SchemaTypeName, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
else
{
Depends(at.SchemaType, refs);
}
}
if (typeof(XmlSchemaAnnotated).IsAssignableFrom(t))
{
XmlAttribute[] attrs = (XmlAttribute[])((XmlSchemaAnnotated)item).UnhandledAttributes;
if (attrs != null)
{
for (int i = 0; i < attrs.Length; i++)
{
XmlAttribute attribute = attrs[i];
if (attribute.LocalName == Wsdl.ArrayType && attribute.NamespaceURI == Wsdl.Namespace)
{
string dims;
XmlQualifiedName qname = TypeScope.ParseWsdlArrayType(attribute.Value, out dims, item);
XmlSchemaType type = (XmlSchemaType)schemas.Find(qname, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
}
}
}
}
internal void Depends(XmlSchemaObject item, ArrayList refs)
{
if ((item != null) && (this.scope[item] == null))
{
Type c = item.GetType();
if (typeof(XmlSchemaType).IsAssignableFrom(c))
{
XmlQualifiedName empty = XmlQualifiedName.Empty;
XmlSchemaType o = null;
XmlSchemaParticle particle = null;
XmlSchemaObjectCollection attributes = null;
if (item is XmlSchemaComplexType)
{
XmlSchemaComplexType type3 = (XmlSchemaComplexType)item;
if (type3.ContentModel != null)
{
XmlSchemaContent content = type3.ContentModel.Content;
if (content is XmlSchemaComplexContentRestriction)
{
empty = ((XmlSchemaComplexContentRestriction)content).BaseTypeName;
attributes = ((XmlSchemaComplexContentRestriction)content).Attributes;
}
else if (content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content;
if (restriction.BaseType != null)
{
o = restriction.BaseType;
}
else
{
empty = restriction.BaseTypeName;
}
attributes = restriction.Attributes;
}
else if (content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
attributes = extension.Attributes;
particle = extension.Particle;
empty = extension.BaseTypeName;
}
else if (content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension extension2 = (XmlSchemaSimpleContentExtension)content;
attributes = extension2.Attributes;
empty = extension2.BaseTypeName;
}
}
else
{
attributes = type3.Attributes;
particle = type3.Particle;
}
if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef ref2 = (XmlSchemaGroupRef)particle;
particle = ((XmlSchemaGroup)this.schemas.Find(ref2.RefName, typeof(XmlSchemaGroup), false)).Particle;
}
else if (particle is XmlSchemaGroupBase)
{
particle = (XmlSchemaGroupBase)particle;
}
}
else if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType type4 = (XmlSchemaSimpleType)item;
XmlSchemaSimpleTypeContent content2 = type4.Content;
if (content2 is XmlSchemaSimpleTypeRestriction)
{
o = ((XmlSchemaSimpleTypeRestriction)content2).BaseType;
empty = ((XmlSchemaSimpleTypeRestriction)content2).BaseTypeName;
}
else if (content2 is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)content2;
if ((list.ItemTypeName != null) && !list.ItemTypeName.IsEmpty)
{
empty = list.ItemTypeName;
}
if (list.ItemType != null)
{
o = list.ItemType;
}
}
else if (content2 is XmlSchemaSimpleTypeRestriction)
{
empty = ((XmlSchemaSimpleTypeRestriction)content2).BaseTypeName;
}
else if (c == typeof(XmlSchemaSimpleTypeUnion))
{
XmlQualifiedName[] memberTypes = ((XmlSchemaSimpleTypeUnion)item).MemberTypes;
if (memberTypes != null)
{
for (int i = 0; i < memberTypes.Length; i++)
{
XmlSchemaType type5 = (XmlSchemaType)this.schemas.Find(memberTypes[i], typeof(XmlSchemaType), false);
this.AddRef(refs, type5);
}
}
}
}
if (((o == null) && !empty.IsEmpty) && (empty.Namespace != "http://www.w3.org/2001/XMLSchema"))
{
o = (XmlSchemaType)this.schemas.Find(empty, typeof(XmlSchemaType), false);
}
if (o != null)
{
this.AddRef(refs, o);
}
if (particle != null)
{
this.Depends(particle, refs);
}
if (attributes != null)
{
for (int j = 0; j < attributes.Count; j++)
{
this.Depends(attributes[j], refs);
}
}
}
else if (c == typeof(XmlSchemaElement))
{
XmlSchemaElement element = (XmlSchemaElement)item;
if (!element.SubstitutionGroup.IsEmpty && (element.SubstitutionGroup.Namespace != "http://www.w3.org/2001/XMLSchema"))
{
XmlSchemaElement element2 = (XmlSchemaElement)this.schemas.Find(element.SubstitutionGroup, typeof(XmlSchemaElement), false);
this.AddRef(refs, element2);
}
if (!element.RefName.IsEmpty)
{
element = (XmlSchemaElement)this.schemas.Find(element.RefName, typeof(XmlSchemaElement), false);
this.AddRef(refs, element);
}
else if (!element.SchemaTypeName.IsEmpty)
{
XmlSchemaType type6 = (XmlSchemaType)this.schemas.Find(element.SchemaTypeName, typeof(XmlSchemaType), false);
this.AddRef(refs, type6);
}
else
{
this.Depends(element.SchemaType, refs);
}
}
else if (c == typeof(XmlSchemaGroup))
{
this.Depends(((XmlSchemaGroup)item).Particle);
}
else if (c == typeof(XmlSchemaGroupRef))
{
XmlSchemaGroup group = (XmlSchemaGroup)this.schemas.Find(((XmlSchemaGroupRef)item).RefName, typeof(XmlSchemaGroup), false);
this.AddRef(refs, group);
}
else if (typeof(XmlSchemaGroupBase).IsAssignableFrom(c))
{
foreach (XmlSchemaObject obj2 in ((XmlSchemaGroupBase)item).Items)
{
this.Depends(obj2, refs);
}
}
else if (c == typeof(XmlSchemaAttributeGroupRef))
{
XmlSchemaAttributeGroup group2 = (XmlSchemaAttributeGroup)this.schemas.Find(((XmlSchemaAttributeGroupRef)item).RefName, typeof(XmlSchemaAttributeGroup), false);
this.AddRef(refs, group2);
}
else if (c == typeof(XmlSchemaAttributeGroup))
{
foreach (XmlSchemaObject obj3 in ((XmlSchemaAttributeGroup)item).Attributes)
{
this.Depends(obj3, refs);
}
}
else if (c == typeof(XmlSchemaAttribute))
{
XmlSchemaAttribute attribute = (XmlSchemaAttribute)item;
if (!attribute.RefName.IsEmpty)
{
attribute = (XmlSchemaAttribute)this.schemas.Find(attribute.RefName, typeof(XmlSchemaAttribute), false);
this.AddRef(refs, attribute);
}
else if (!attribute.SchemaTypeName.IsEmpty)
{
XmlSchemaType type7 = (XmlSchemaType)this.schemas.Find(attribute.SchemaTypeName, typeof(XmlSchemaType), false);
this.AddRef(refs, type7);
}
else
{
this.Depends(attribute.SchemaType, refs);
}
}
if (typeof(XmlSchemaAnnotated).IsAssignableFrom(c))
{
XmlAttribute[] unhandledAttributes = ((XmlSchemaAnnotated)item).UnhandledAttributes;
if (unhandledAttributes != null)
{
for (int k = 0; k < unhandledAttributes.Length; k++)
{
XmlAttribute attribute2 = unhandledAttributes[k];
if ((attribute2.LocalName == "arrayType") && (attribute2.NamespaceURI == "http://schemas.xmlsoap.org/wsdl/"))
{
string str;
XmlQualifiedName name = TypeScope.ParseWsdlArrayType(attribute2.Value, out str, item);
XmlSchemaType type8 = (XmlSchemaType)this.schemas.Find(name, typeof(XmlSchemaType), false);
this.AddRef(refs, type8);
}
}
}
}
}
}
private void method_4(XmlSchemaGroupBase A_0, XmlNode A_1, bool A_2)
{
int num = 8;
XmlSchemaComplexType item = new XmlSchemaComplexType {
Name = A_1.Attributes[BookmarkStart.b("䀭儯弱儳", 8)].Value
};
if (A_2)
{
string name = item.Name + BookmarkStart.b("椭䈯崱䄳䘵", num);
XmlSchemaGroupRef ref2 = new XmlSchemaGroupRef {
RefName = new XmlQualifiedName(name)
};
item.Particle = ref2;
XmlSchemaGroup group = new XmlSchemaGroup {
Name = name,
Particle = A_0
};
this.xmlSchema_0.Items.Add(group);
}
else
{
item.Particle = A_0;
item.Particle.MaxOccursString = BookmarkStart.b("嬭帯倱嬳䌵嘷帹夻娽", num);
item.Particle.MinOccurs = 0M;
}
this.xmlSchema_0.Items.Add(item);
foreach (XmlNode node4 in A_1.SelectNodes(BookmarkStart.b("䌭ਯ圱堳匵唷弹刻䨽", num), this.xmlNamespaceManager_0))
{
this.method_5(node4, A_0);
}
foreach (XmlNode node in A_1.SelectNodes(BookmarkStart.b("䌭ਯ唱䘳夵䴷䨹", num), this.xmlNamespaceManager_0))
{
XmlAttribute attribute = node.Attributes[BookmarkStart.b("尭唯吱", num)];
if (attribute != null)
{
XmlNode node2 = this.xmlElement_0.SelectSingleNode(BookmarkStart.b("䌭ਯ唱䘳夵䴷䨹朻總⸿⍁⥃⍅畇浉", num) + attribute.Value + BookmarkStart.b("भ洯", num), this.xmlNamespaceManager_0);
this.method_6(node2, A_0);
}
else
{
this.method_6(node, A_0);
}
}
XmlSchemaObjectCollection attributes = item.Attributes;
if (A_2)
{
string str2 = item.Name + BookmarkStart.b("漭䐯䘱䘳焵䨷唹䤻丽", num);
XmlSchemaAttributeGroupRef ref3 = new XmlSchemaAttributeGroupRef {
RefName = new XmlQualifiedName(str2)
};
item.Attributes.Add(ref3);
XmlSchemaAttributeGroup group2 = new XmlSchemaAttributeGroup {
Name = str2
};
this.xmlSchema_0.Items.Add(group2);
attributes = group2.Attributes;
}
foreach (XmlNode node3 in A_1.SelectNodes(BookmarkStart.b("䌭ਯ匱䀳䈵䨷匹帻䬽㐿❁", num), this.xmlNamespaceManager_0))
{
this.method_7(node3, attributes);
}
XmlSchemaAttribute attribute2 = new XmlSchemaAttribute {
Name = BookmarkStart.b("䜭启", num),
SchemaTypeName = new XmlQualifiedName(BookmarkStart.b("䜭帯䘱", num), BookmarkStart.b("䘭䐯䘱䐳వᔹ䬻䤽㜿汁㍃畅晇╉㹋⥍罏恑摓晕楗留ћ፝ⱟㅡݣ൧ݩ൫", num))
};
item.Attributes.Add(attribute2);
}
private static XmlSchema CreateFakeSoapEncodingSchema(string ns, string name)
{
var schema = new XmlSchema();
schema.TargetNamespace = ns;
var item = new XmlSchemaGroup();
item.Name = "Array";
var sequence = new XmlSchemaSequence();
var any = new XmlSchemaAny();
any.MinOccurs = 0M;
any.MaxOccurs = 79228162514264337593543950335M;
sequence.Items.Add(any);
any.Namespace = "##any";
any.ProcessContents = XmlSchemaContentProcessing.Lax;
item.Particle = sequence;
schema.Items.Add(item);
var type = new XmlSchemaComplexType();
type.Name = name;
var ref2 = new XmlSchemaGroupRef();
ref2.RefName = new XmlQualifiedName("Array", ns);
type.Particle = ref2;
var attribute = new XmlSchemaAttribute();
attribute.RefName = new XmlQualifiedName("arrayType", ns);
type.Attributes.Add(attribute);
schema.Items.Add(type);
attribute = new XmlSchemaAttribute();
attribute.Use = XmlSchemaUse.None;
attribute.Name = "arrayType";
schema.Items.Add(attribute);
AddSimpleType(schema, "base64", "base64Binary");
AddElementAndType(schema, "anyURI", ns);
AddElementAndType(schema, "base64Binary", ns);
AddElementAndType(schema, "boolean", ns);
AddElementAndType(schema, "byte", ns);
AddElementAndType(schema, "date", ns);
AddElementAndType(schema, "dateTime", ns);
AddElementAndType(schema, "decimal", ns);
AddElementAndType(schema, "double", ns);
AddElementAndType(schema, "duration", ns);
AddElementAndType(schema, "ENTITIES", ns);
AddElementAndType(schema, "ENTITY", ns);
AddElementAndType(schema, "float", ns);
AddElementAndType(schema, "gDay", ns);
AddElementAndType(schema, "gMonth", ns);
AddElementAndType(schema, "gMonthDay", ns);
AddElementAndType(schema, "gYear", ns);
AddElementAndType(schema, "gYearMonth", ns);
AddElementAndType(schema, "hexBinary", ns);
AddElementAndType(schema, "ID", ns);
AddElementAndType(schema, "IDREF", ns);
AddElementAndType(schema, "IDREFS", ns);
AddElementAndType(schema, "int", ns);
AddElementAndType(schema, "integer", ns);
AddElementAndType(schema, "language", ns);
AddElementAndType(schema, "long", ns);
AddElementAndType(schema, "Name", ns);
AddElementAndType(schema, "NCName", ns);
AddElementAndType(schema, "negativeInteger", ns);
AddElementAndType(schema, "NMTOKEN", ns);
AddElementAndType(schema, "NMTOKENS", ns);
AddElementAndType(schema, "nonNegativeInteger", ns);
AddElementAndType(schema, "nonPositiveInteger", ns);
AddElementAndType(schema, "normalizedString", ns);
AddElementAndType(schema, "positiveInteger", ns);
AddElementAndType(schema, "QName", ns);
AddElementAndType(schema, "short", ns);
AddElementAndType(schema, "string", ns);
AddElementAndType(schema, "time", ns);
AddElementAndType(schema, "token", ns);
AddElementAndType(schema, "unsignedByte", ns);
AddElementAndType(schema, "unsignedInt", ns);
AddElementAndType(schema, "unsignedLong", ns);
AddElementAndType(schema, "unsignedShort", ns);
return(schema);
}
public override void Check(ConformanceCheckContext ctx, XmlSchemaGroupRef value)
{
CheckSchemaQName(ctx, value, value.RefName);
}
private void roopItem(XmlSchemaGroupBase xgb, bool tf, string choiceStr)
{
bool choice = tf;
bool isVector = false;
string includePathStr;
string cStr = choiceStr;
if (xgb is XmlSchemaChoice)
{
choice = true;
if (xgb.Id == null)
{
choiceStr = "choiceStr_" + m_ClassGen.ChoiceStr.Count;
}
else
{
choiceStr = "choiceStr_" + xgb.Id;
}
m_ClassGen.ChoiceStr.Add(choiceStr);
m_ClassGen.ChoiceStrMember.Add(choiceStr, new List <string>());
}
foreach (XmlSchemaObject item in xgb.Items)
{
isVector = false;
if (item is XmlSchemaElement)
{
XmlSchemaElement itemCast = item as XmlSchemaElement;
if (itemCast.RefName.IsEmpty)
{
#region directDef
if (choice)
{
m_ClassGen.ChoiceStrMember[choiceStr].Add(itemCast.Name);
}
if (itemCast.SchemaTypeName.IsEmpty)
{
includePathStr = includePath["boolean"];
m_MemberVariable.Add(new Variable("boolean",
itemCast.Name,
includePathStr,
isVector,
choice));
}
else
{
decimal aa = itemCast.MaxOccurs;
if (itemCast.MaxOccurs > 1)
{
isVector = true;
}
includePathStr = includePath[itemCast.SchemaTypeName.Name];
m_MemberVariable.Add(new Variable(itemCast.SchemaTypeName.Name,
itemCast.Name,
includePathStr,
isVector,
choice));
}
#endregion
}
else
{
#region refDef
string type = elementRef[itemCast.RefName.Name];
if (choice)
{
m_ClassGen.ChoiceStrMember[choiceStr].Add(itemCast.RefName.Name);
}
includePathStr = includePath[type];
m_MemberVariable.Add(new Variable(type,
itemCast.RefName.Name,
includePathStr,
isVector,
choice));
foreach (KeyValuePair <string, string> substiItem in elementSubstitutionRef)
{
if (substiItem.Key == itemCast.RefName.Name)
{
choice = false;
bool substi = true; // 주석을 위한 것
string substiStr = elementRef[substiItem.Value];
includePathStr = includePath[substiStr];
Variable substiVariable = new Variable(substiStr,
substiItem.Value,
includePathStr,
isVector,
choice,
substi);
//substiVariable.SubstitudeStr = itemCast.RefName.Name; 주석에 들어갈건데 먼저 생성자에서 코드가 생성되서리 적용이 안댐 그냥 우선은 패스
m_MemberVariable.Add(substiVariable);
}
}
#endregion
}
}
else if (item is XmlSchemaGroupRef)
{
#region groupRefDef
XmlSchemaGroupRef xsgr = item as XmlSchemaGroupRef;
XmlSchemaGroup xsg = elementGroupRef[xsgr.RefName.Name];
roopItem(xsg.Particle, choice, choiceStr);
#endregion
}
else if (item is XmlSchemaGroupBase)
{
XmlSchemaGroupBase xgbSub = item as XmlSchemaGroupBase;
roopItem(xgbSub, choice, choiceStr);
}
}
}
public virtual void Check(ConformanceCheckContext ctx, XmlSchemaGroupRef value)
{
}
XmlSchemaParticle GetRefGroupParticle(XmlSchemaGroupRef refGroup)
{
XmlSchemaGroup grp = (XmlSchemaGroup)schemas.Find(refGroup.RefName, typeof(XmlSchemaGroup));
return(grp.Particle);
}
static void Check(ConformanceCheckContext ctx, ConformanceChecker checker, Hashtable visitedObjects, XmlSchemaObject value)
{
if (value == null)
{
return;
}
if (visitedObjects.Contains(value))
{
return;
}
visitedObjects.Add(value, value);
if (value is XmlSchemaImport)
{
XmlSchemaImport so = (XmlSchemaImport)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaAll)
{
XmlSchemaAll so = (XmlSchemaAll)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaAnnotation)
{
XmlSchemaAnnotation so = (XmlSchemaAnnotation)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaAttribute)
{
XmlSchemaAttribute so = (XmlSchemaAttribute)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaAttributeGroup)
{
XmlSchemaAttributeGroup so = (XmlSchemaAttributeGroup)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
Check(ctx, checker, visitedObjects, so.RedefinedAttributeGroup);
}
else if (value is XmlSchemaAttributeGroupRef)
{
XmlSchemaAttributeGroupRef so = (XmlSchemaAttributeGroupRef)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaChoice)
{
XmlSchemaChoice so = (XmlSchemaChoice)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaComplexContent)
{
XmlSchemaComplexContent so = (XmlSchemaComplexContent)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Content);
}
else if (value is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension so = (XmlSchemaComplexContentExtension)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Particle);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
}
else if (value is XmlSchemaComplexContentRestriction)
{
XmlSchemaComplexContentRestriction so = (XmlSchemaComplexContentRestriction)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Particle);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
}
else if (value is XmlSchemaComplexType)
{
XmlSchemaComplexType so = (XmlSchemaComplexType)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.ContentModel);
Check(ctx, checker, visitedObjects, so.Particle);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
Check(ctx, checker, visitedObjects, so.ContentTypeParticle);
Check(ctx, checker, visitedObjects, so.AttributeWildcard);
}
else if (value is XmlSchemaElement)
{
XmlSchemaElement so = (XmlSchemaElement)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.SchemaType);
CheckObjects(ctx, checker, visitedObjects, so.Constraints);
}
else if (value is XmlSchemaGroup)
{
XmlSchemaGroup so = (XmlSchemaGroup)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Particle);
}
else if (value is XmlSchemaGroupRef)
{
XmlSchemaGroupRef so = (XmlSchemaGroupRef)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaIdentityConstraint)
{
XmlSchemaIdentityConstraint so = (XmlSchemaIdentityConstraint)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Fields);
Check(ctx, checker, visitedObjects, so.Selector);
}
else if (value is XmlSchemaKeyref)
{
XmlSchemaKeyref so = (XmlSchemaKeyref)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaRedefine)
{
XmlSchemaRedefine so = (XmlSchemaRedefine)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaSequence)
{
XmlSchemaSequence so = (XmlSchemaSequence)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaSimpleContent)
{
XmlSchemaSimpleContent so = (XmlSchemaSimpleContent)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Content);
}
else if (value is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension so = (XmlSchemaSimpleContentExtension)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
}
else if (value is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction so = (XmlSchemaSimpleContentRestriction)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
CheckObjects(ctx, checker, visitedObjects, so.Facets);
}
else if (value is XmlSchemaSimpleType)
{
XmlSchemaSimpleType so = (XmlSchemaSimpleType)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Content);
}
else if (value is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList so = (XmlSchemaSimpleTypeList)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaSimpleTypeRestriction)
{
XmlSchemaSimpleTypeRestriction so = (XmlSchemaSimpleTypeRestriction)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Facets);
}
else if (value is XmlSchemaSimpleTypeUnion)
{
XmlSchemaSimpleTypeUnion so = (XmlSchemaSimpleTypeUnion)value;
checker.Check(ctx, so);
}
}
protected override void Visit(XmlSchemaGroupRef groupRef)
{
// Don't visit children.
}
public static void Main()
{
XmlSchema schema = new XmlSchema();
// <xs:element name="thing1" type="xs:string"/>
XmlSchemaElement elementThing1 = new XmlSchemaElement();
schema.Items.Add(elementThing1);
elementThing1.Name = "thing1";
elementThing1.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
// <xs:element name="thing2" type="xs:string"/>
XmlSchemaElement elementThing2 = new XmlSchemaElement();
schema.Items.Add(elementThing2);
elementThing2.Name = "thing2";
elementThing2.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
// <xs:element name="thing3" type="xs:string"/>
XmlSchemaElement elementThing3 = new XmlSchemaElement();
schema.Items.Add(elementThing3);
elementThing3.Name = "thing3";
elementThing3.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
// <xs:attribute name="myAttribute" type="xs:decimal"/>
XmlSchemaAttribute myAttribute = new XmlSchemaAttribute();
schema.Items.Add(myAttribute);
myAttribute.Name = "myAttribute";
myAttribute.SchemaTypeName = new XmlQualifiedName("decimal", "http://www.w3.org/2001/XMLSchema");
// <xs:group name="myGroupOfThings">
XmlSchemaGroup myGroupOfThings = new XmlSchemaGroup();
schema.Items.Add(myGroupOfThings);
myGroupOfThings.Name = "myGroupOfThings";
// <xs:sequence>
XmlSchemaSequence sequence = new XmlSchemaSequence();
myGroupOfThings.Particle = sequence;
// <xs:element ref="thing1"/>
XmlSchemaElement elementThing1Ref = new XmlSchemaElement();
sequence.Items.Add(elementThing1Ref);
elementThing1Ref.RefName = new XmlQualifiedName("thing1");
// <xs:element ref="thing2"/>
XmlSchemaElement elementThing2Ref = new XmlSchemaElement();
sequence.Items.Add(elementThing2Ref);
elementThing2Ref.RefName = new XmlQualifiedName("thing2");
// <xs:element ref="thing3"/>
XmlSchemaElement elementThing3Ref = new XmlSchemaElement();
sequence.Items.Add(elementThing3Ref);
elementThing3Ref.RefName = new XmlQualifiedName("thing3");
// <xs:complexType name="myComplexType">
XmlSchemaComplexType myComplexType = new XmlSchemaComplexType();
schema.Items.Add(myComplexType);
myComplexType.Name = "myComplexType";
// <xs:group ref="myGroupOfThings"/>
XmlSchemaGroupRef myGroupOfThingsRef = new XmlSchemaGroupRef();
myComplexType.Particle = myGroupOfThingsRef;
myGroupOfThingsRef.RefName = new XmlQualifiedName("myGroupOfThings");
// <xs:attribute ref="myAttribute"/>
XmlSchemaAttribute myAttributeRef = new XmlSchemaAttribute();
myComplexType.Attributes.Add(myAttributeRef);
myAttributeRef.RefName = new XmlQualifiedName("myAttribute");
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
schemaSet.Add(schema);
schemaSet.Compile();
XmlSchema compiledSchema = null;
foreach (XmlSchema schema1 in schemaSet.Schemas())
{
compiledSchema = schema1;
}
XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
compiledSchema.Write(Console.Out, nsmgr);
}
private static XmlSchema CreateFakeSoapEncodingSchema(string ns, string name)
{
XmlSchema schema1 = new XmlSchema();
schema1.TargetNamespace = ns;
XmlSchemaGroup group1 = new XmlSchemaGroup();
group1.Name = "Array";
XmlSchemaSequence sequence1 = new XmlSchemaSequence();
XmlSchemaAny any1 = new XmlSchemaAny();
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = new decimal(-1, -1, -1, false, 0);
sequence1.Items.Add(any1);
any1.Namespace = "##any";
any1.ProcessContents = XmlSchemaContentProcessing.Lax;
group1.Particle = sequence1;
schema1.Items.Add(group1);
XmlSchemaComplexType type1 = new XmlSchemaComplexType();
type1.Name = name;
XmlSchemaGroupRef ref1 = new XmlSchemaGroupRef();
ref1.RefName = new XmlQualifiedName("Array", ns);
type1.Particle = ref1;
XmlSchemaAttribute attribute1 = new XmlSchemaAttribute();
attribute1.RefName = new XmlQualifiedName("arrayType", ns);
type1.Attributes.Add(attribute1);
schema1.Items.Add(type1);
attribute1 = new XmlSchemaAttribute();
attribute1.Use = XmlSchemaUse.None;
attribute1.Name = "arrayType";
schema1.Items.Add(attribute1);
AddSimpleType(schema1, "base64", "base64Binary");
AddElementAndType(schema1, "anyURI", ns);
AddElementAndType(schema1, "base64Binary", ns);
AddElementAndType(schema1, "boolean", ns);
AddElementAndType(schema1, "byte", ns);
AddElementAndType(schema1, "date", ns);
AddElementAndType(schema1, "dateTime", ns);
AddElementAndType(schema1, "decimal", ns);
AddElementAndType(schema1, "double", ns);
AddElementAndType(schema1, "duration", ns);
AddElementAndType(schema1, "ENTITIES", ns);
AddElementAndType(schema1, "ENTITY", ns);
AddElementAndType(schema1, "float", ns);
AddElementAndType(schema1, "gDay", ns);
AddElementAndType(schema1, "gMonth", ns);
AddElementAndType(schema1, "gMonthDay", ns);
AddElementAndType(schema1, "gYear", ns);
AddElementAndType(schema1, "gYearMonth", ns);
AddElementAndType(schema1, "hexBinary", ns);
AddElementAndType(schema1, "ID", ns);
AddElementAndType(schema1, "IDREF", ns);
AddElementAndType(schema1, "IDREFS", ns);
AddElementAndType(schema1, "int", ns);
AddElementAndType(schema1, "integer", ns);
AddElementAndType(schema1, "language", ns);
AddElementAndType(schema1, "long", ns);
AddElementAndType(schema1, "Name", ns);
AddElementAndType(schema1, "NCName", ns);
AddElementAndType(schema1, "negativeInteger", ns);
AddElementAndType(schema1, "NMTOKEN", ns);
AddElementAndType(schema1, "NMTOKENS", ns);
AddElementAndType(schema1, "nonNegativeInteger", ns);
AddElementAndType(schema1, "nonPositiveInteger", ns);
AddElementAndType(schema1, "normalizedString", ns);
AddElementAndType(schema1, "positiveInteger", ns);
AddElementAndType(schema1, "QName", ns);
AddElementAndType(schema1, "short", ns);
AddElementAndType(schema1, "string", ns);
AddElementAndType(schema1, "time", ns);
AddElementAndType(schema1, "token", ns);
AddElementAndType(schema1, "unsignedByte", ns);
AddElementAndType(schema1, "unsignedInt", ns);
AddElementAndType(schema1, "unsignedLong", ns);
AddElementAndType(schema1, "unsignedShort", ns);
return(schema1);
}
private static void Equal(XmlSchemaGroupRef expected, XmlSchemaGroupRef actual)
{
ParticleEqual(expected, actual);
Assert.Equal(expected.RefName, actual.RefName);
}
protected virtual void Visit(XmlSchemaGroupRef groupRef)
{
}