/// <summary>
/// Traverses a complex element.
/// </summary>
/// <param name="element">The current element.</param>
/// <param name="type">The current element type.</param>
/// <param name="name">The element name.</param>
/// <param name="typeName">The element type name, that is, name + typeNaming.</param>
/// <param name="parent">The parent of the element received.</param>
/// <returns>The IVisitableComponent to add to the composite parent.</returns>
private IVisitableComponent RecurseElement(XmlSchemaElement element, XmlSchemaComplexType type,
string name, string typeName, BaseSchemaTypedElement parent)
{
VisitableElementComplexType result =
new VisitableElementComplexType(element, type, name, typeName, parent);
// Traverse all the attributes of the complex type.
foreach (XmlSchemaObject obj in type.Attributes)
{
if (obj is XmlSchemaAttribute)
{
result.Add(Build(obj as XmlSchemaAttribute, result));
}
}
// We only take into account the Choice and Sequence subgroups.
if (type.Particle is XmlSchemaGroupBase && !(type.Particle is XmlSchemaAll))
{
XmlSchemaGroupBase group = type.Particle as XmlSchemaGroupBase;
foreach (XmlSchemaObject item in group.Items)
{
if (item is XmlSchemaElement)
{
result.Add(Build(item as XmlSchemaElement, result));
}
}
}
return(result);
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="element">The schema element.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="parent">The parent of the element.</param>
public VisitableElementIntrinsicType(XmlSchemaElement element, string name,
BaseSchemaTypedElement parent) : base(element, null, name, string.Empty, parent)
{
if (element.SchemaTypeName.Namespace != XmlSchema.Namespace)
{
throw new ArgumentException("The element doesn't have an intrinsic XSD type.");
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="attribute">The schema attribute.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="parent">The parent of the element.</param>
public VisitableAttributeIntrinsicType(XmlSchemaAttribute attribute,
string name, BaseSchemaTypedElement parent) :
base(attribute, null, name, string.Empty, parent)
{
if (attribute.SchemaTypeName.Namespace != XmlSchema.Namespace)
{
throw new ArgumentException("The attribute doesn't have an intrinsic XSD type.");
}
}
/// <summary>
/// Protected constructor for use by the descendents.
/// </summary>
/// <param name="element">The schema object.</param>
/// <param name="type">The schema type of the object.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="typeName">The type name, which can be different from the
/// schema type name because of TypeNaming conventions.</param>
/// <param name="parent">The parent of the element.</param>
protected BaseSchemaTypedElement(XmlSchemaObject element, XmlSchemaType type,
string name, string typeName, BaseSchemaTypedElement parent)
{
_schemaobject = element;
_name = name;
_typename = typeName;
_schematype = type;
_parent = parent;
}
/// <summary>
/// Builds an IVisitableComponent with the element passed.
/// </summary>
/// <param name="element">The element to use to build the visitable component.</param>
/// <param name="parent">The parent element of the visitable component to build.</param>
/// <returns>The visitable component.</returns>
/// <remarks>If element type is a named complex type, the component typeName will depend on the IterationType
/// selected in the configuration. So it IterationType.ComplexElements is selected, the typeName will
/// be the element name plus the TypeNaming convention specified. Else, the ComplexType name is used.
/// If it is a simple type, the simple type name is used. If the type is unnamed, the element name
/// plus the TypeNaming is used.
/// </remarks>
private IVisitableComponent Build(XmlSchemaElement element, BaseSchemaTypedElement parent)
{
if (!element.SchemaTypeName.IsEmpty)
{
if (element.SchemaTypeName.Namespace == XmlSchema.Namespace)
{
return(new VisitableElementIntrinsicType(element, element.Name, parent));
}
else
{
foreach (XmlSchemaObject item in _context.Items)
{
if (item is XmlSchemaType &&
((XmlSchemaType)item).Name == element.SchemaTypeName.Name)
{
if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType st = item as XmlSchemaSimpleType;
return(new VisitableElementSimpleType(element, st, element.Name, st.Name, parent));
}
else
{
XmlSchemaComplexType ct = item as XmlSchemaComplexType;
if (_config.Iteration == IterationType.ComplexType)
{
return(RecurseElement(element, ct, element.Name, ct.Name, parent));
}
else
{
return(RecurseElement(element, ct, element.Name, element.Name +
_config.TypeNaming, parent));
}
}
}
}
}
}
else if (element.SchemaType is XmlSchemaSimpleType)
{
return(new VisitableElementSimpleType(element,
element.SchemaType as XmlSchemaSimpleType, element.Name, element.Name +
_config.TypeNaming, parent));
}
else if (element.SchemaType is XmlSchemaComplexType)
{
XmlSchemaComplexType ct = element.SchemaType as XmlSchemaComplexType;
return(RecurseElement(element, ct, element.Name,
element.Name + _config.TypeNaming, parent));
}
return(null);
}
/// <summary>
/// Builds an IVisitableComponent with the attribute passed.
/// </summary>
/// <param name="attribute">The attribute to use to build the visitable component.</param>
/// <param name="parent">The parent element of the visitable component to build.</param>
/// <returns>The visitable component.</returns>
/// <remarks>If attribute type is a named simple type, that will be the typeName used for the component if
/// IterationType.ComplexType is selected. Otherwise, the same naming convention for unnamed simpletypes is followed.
/// If the simple type is unnamed, the attribute name plus the TypeNaming is used as the typeName parameter
/// for component.
/// </remarks>
private IVisitableComponent Build(XmlSchemaAttribute attribute, BaseSchemaTypedElement parent)
{
if (!attribute.SchemaTypeName.IsEmpty)
{
if (attribute.SchemaTypeName.Namespace == XmlSchema.Namespace)
{
return(new VisitableAttributeIntrinsicType(attribute, attribute.Name, parent));
}
else
{
foreach (XmlSchemaObject item in _context.Items)
{
if (item is XmlSchemaSimpleType &&
((XmlSchemaSimpleType)item).Name == attribute.SchemaTypeName.Name)
{
XmlSchemaSimpleType st = item as XmlSchemaSimpleType;
if (_config.Iteration == IterationType.ComplexType)
{
return(new VisitableAttributeSimpleType(attribute, st, attribute.Name,
st.Name, parent));
}
else
{
return(new VisitableAttributeSimpleType(attribute, st,
attribute.Name, attribute.Name + _config.TypeNaming, parent));
}
}
}
}
}
else
{
return(new VisitableAttributeSimpleType(attribute,
attribute.SchemaType as XmlSchemaSimpleType, attribute.Name,
attribute.Name + _config.TypeNaming, parent));
}
return(null);
}
/// <summary>
/// Protected constructor for use by the descendents.
/// </summary>
/// <param name="attribute">The schema attribute.</param>
/// <param name="type">The schema type of the object.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="typeName">The type name, which can be different from the
/// schema type name because of TypeNaming conventions.</param>
/// <param name="parent">The parent of the element.</param>
protected BaseVisitableAttribute(XmlSchemaAttribute attribute,
XmlSchemaSimpleType type, string name,
string typeName, BaseSchemaTypedElement parent) :
base(attribute, type, name, typeName, parent)
{
}
/// <summary>
/// Default constructor, for use by descendents.
/// </summary>
/// <param name="element">The schema element.</param>
/// <param name="type">The schema type of the object.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="typeName">The type name, which can be different from the
/// schema type name because of TypeNaming conventions.</param>
/// <param name="parent">The parent of the element.</param>
protected BaseVisitableElement(XmlSchemaElement element, XmlSchemaType type,
string name, string typeName, BaseSchemaTypedElement parent) :
base(element, type, name, typeName, parent)
{
}
/// <summary>
/// Protected constructor for use by the descendents.
/// </summary>
/// <param name="element">The schema object.</param>
/// <param name="type">The schema type of the object.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="typeName">The type name, which can be different from the
/// schema type name because of TypeNaming conventions.</param>
/// <param name="parent">The parent of the element.</param>
protected BaseCompositeSchemaElement(XmlSchemaObject element,
XmlSchemaType type, string name, string typeName, BaseSchemaTypedElement parent) :
base(element, type, name, typeName, parent)
{
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="element">The schema element.</param>
/// <param name="type">The schema type of the object.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="typeName">The type name, which can be different from the
/// schema type name because of TypeNaming conventions.</param>
/// <param name="parent">The parent of the element.</param>
public VisitableElementSimpleType(XmlSchemaElement element,
XmlSchemaSimpleType type, string name, string typeName,
BaseSchemaTypedElement parent) : base(element, type, name, typeName, parent)
{
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="element">The schema element.</param>
/// <param name="type">The schema type of the object.</param>
/// <param name="name">The name the element will have.</param>
/// <param name="typeName">The type name, which can be different from the
/// schema type name because of TypeNaming conventions.</param>
/// <param name="parent">The parent of the element.</param>
public VisitableElementComplexType(XmlSchemaObject element,
XmlSchemaComplexType type, string name, string typeName,
BaseSchemaTypedElement parent) : base(element, type, name, typeName, parent)
{
}
