private static void ProcessCompositeType(NamespaceDescriptor namespaceDescriptor, XmlSchemaComplexType complexType, string typeHint)
{
var descriptor = complexType.BaseXmlSchemaType != null
? namespaceDescriptor.CreateCompositeType(ConvertSchemaType(complexType, typeHint), complexType.BaseXmlSchemaType.Name) //TODO namespace
: namespaceDescriptor.CreateCompositeType(ConvertSchemaType(complexType, typeHint));
ProcessItems(descriptor, complexType.Attributes);
switch (complexType.ContentModel)
{
case XmlSchemaSimpleContent simpleContentModel:
switch (simpleContentModel.Content)
{
case XmlSchemaSimpleContentExtension extension:
ProcessItems(descriptor, extension.Attributes);
descriptor.AddField("Content", ConvertSchemaType(extension.BaseTypeName), false, new Dictionary <string, object> {
{ "isContent", true }
});
break;
case XmlSchemaSimpleContentRestriction restriction:
descriptor.AddField("Content", ConvertSchemaType(restriction.BaseTypeName), false, new Dictionary <string, object> {
{ "isContent", true }
});
break;
default:
throw new NotSupportedException("Not supported simple content model ");
}
break;
case XmlSchemaComplexContent complexContentModel:
switch (complexContentModel.Content)
{
case XmlSchemaComplexContentExtension extension:
ProcessItems(descriptor, extension.Attributes);
if (extension.Particle is XmlSchemaSequence sequence)
{
ProcessItems(descriptor, sequence.Items);
}
break;
case XmlSchemaComplexContentRestriction restriction:
//TODO restriction
break;
}
break;
case null:
AddField(descriptor, complexType.ContentTypeParticle, false);
break;
}
}
private static void ReadComposite(XmlReader reader, NamespaceDescriptor namespaceDescriptor)
{
reader.MoveToFirstAttribute();
var descriptor = namespaceDescriptor.CreateCompositeType(reader.Value);
if (ReadToDescendantElement(reader))
{
ReadField(reader, descriptor);
while (reader.ReadToNextSibling("Field"))
{
ReadField(reader, descriptor);
}
}
ReadEndElement(reader);
}
private static void processNamespace(NamespaceDesc ns, NamespaceDescriptor namespaceDescriptor)
{
if (ns.Items != null)
{
foreach (var t in ns.Items)
{
if (t is Composite composite)
{
var descriptor = namespaceDescriptor.CreateCompositeType(composite.name);
if (composite.Field != null)
{
foreach (var field in composite.Field)
{
var newField = descriptor.AddField(field.name, field.type, field.isCollectionSpecified && field.isCollection);
if (field.AttachedData != null)
{//TODO hack for boolean values
field.AttachedData.Select(_ => new KeyValuePair <string, object>(_.key, _.value == "True" ? (object)true : _.value)).ToList().ForEach(_ => newField.AttachedData.Add(_));
}
}
}
}
else
{
if (t is Primitive primitive)
{
var descriptor = namespaceDescriptor.CreatePrimitiveType(primitive.name);
}
else
{
if (t is Enumeration enumeration)
{
var descriptor = namespaceDescriptor.CreateEnumerationType(enumeration.name);
int i = 0;
foreach (var item in enumeration.Item)
{
if (item.valueSpecified)
{
descriptor.AddItem(item.name, item.value);
i = item.value;
}
else
{
descriptor.AddItem(item.name, i);
}
++i;
}
}
else
{
throw new Exception("Unknown type");
}
}
}
}
}
if (ns.Namespace != null)
{
foreach (var n in ns.Namespace)
{
processNamespace(n, namespaceDescriptor.GetOrCreateNamespace(n.name));
}
}
}
