/// <summary>
/// Load this Simple type from the .NET schema
/// </summary>
/// <param name="type">The type to load</param>
public void Load(System.Xml.Schema.XmlSchemaSimpleType type)
{
if (type == null)
{
return;
}
this.Name = type.Name;
this.Namespace = type.QualifiedName != null ? type.QualifiedName.Namespace : Schema.TargetNamespace;
this.SystemType = type.Datatype.ValueType;
this.systemTypeCode = type.Datatype.TypeCode;
this.Type = SimpleType.Extension;
// Deal with an enum
if (type.Content is System.Xml.Schema.XmlSchemaSimpleTypeList)
{
Type = SimpleType.Enum;
System.Xml.Schema.XmlSchemaSimpleTypeList stl = type.Content as System.Xml.Schema.XmlSchemaSimpleTypeList;
this.SystemType = stl.BaseItemType.Datatype.ValueType;
this.systemTypeCode = stl.BaseItemType.Datatype.TypeCode;
System.Xml.Schema.XmlSchemaObjectCollection listitems = null;
if (stl.ItemType != null && stl.ItemType.Content is System.Xml.Schema.XmlSchemaSimpleTypeRestriction) // Restriction meaning this is an enum
{
listitems = (stl.ItemType.Content as System.Xml.Schema.XmlSchemaSimpleTypeRestriction).Facets;
}
else if (stl.BaseItemType.Content is System.Xml.Schema.XmlSchemaSimpleTypeUnion)
{
listitems = new System.Xml.Schema.XmlSchemaObjectCollection();
foreach (System.Xml.Schema.XmlSchemaObject so in (stl.BaseItemType.Content as System.Xml.Schema.XmlSchemaSimpleTypeUnion).BaseMemberTypes)
{
if (so is System.Xml.Schema.XmlSchemaSimpleType)
{
foreach (System.Xml.Schema.XmlSchemaObject o in ((so as System.Xml.Schema.XmlSchemaSimpleType).Content as System.Xml.Schema.XmlSchemaSimpleTypeRestriction).Facets)
{
listitems.Add(o);
}
}
}
}
// TODO: Can lists appear somewhere else?
// Iterate through the restrictions
if (listitems != null)
{
foreach (System.Xml.Schema.XmlSchemaObject o in listitems)
{
if (o is System.Xml.Schema.XmlSchemaEnumerationFacet)
{
Restrictions.Add((o as System.Xml.Schema.XmlSchemaEnumerationFacet).Value);
}
}
}
}
//Debugger.Break();
}
/// <summary> Convert the attributes in the Collection to an ArrayList </summary>
public static System.Collections.ArrayList GetAttributes(System.Xml.Schema.XmlSchemaObjectCollection typeAttributes)
{
System.Collections.ArrayList attributes = new System.Collections.ArrayList();
foreach (System.Xml.Schema.XmlSchemaObject obj in typeAttributes)
{
if (obj is System.Xml.Schema.XmlSchemaAttribute)
{
attributes.Add(obj);
}
else if (obj is System.Xml.Schema.XmlSchemaAttributeGroupRef)
{
System.Xml.Schema.XmlSchemaAttributeGroupRef elt = obj as System.Xml.Schema.XmlSchemaAttributeGroupRef;
System.Xml.Schema.XmlSchemaAttributeGroup group = null;
// Find the referenced group
foreach (System.Xml.Schema.XmlSchemaObject item in Program.Schema.Items)
{
if (item is System.Xml.Schema.XmlSchemaAttributeGroup)
{
group = item as System.Xml.Schema.XmlSchemaAttributeGroup;
if (group.Name == elt.RefName.Name)
{
break;
}
else
{
group = null; // not the good one
}
}
}
if (group != null) // => Found; add its attributes
{
foreach (System.Xml.Schema.XmlSchemaObject att in group.Attributes)
{
attributes.Add(att);
}
}
else
{
log.Warn("Unknow AttributeGroup: " + elt.RefName.Name);
}
}
else
{
log.Warn("Unknow Attribute: " + obj.ToString());
}
}
return(attributes);
}
/// <summary> Convert the elements in the Collection to an ArrayList </summary>
public static System.Collections.ArrayList GetElements(System.Xml.Schema.XmlSchemaObjectCollection seqItems, System.Xml.Schema.XmlSchemaObjectCollection schemaItems)
{
System.Collections.ArrayList elements = new System.Collections.ArrayList();
foreach (System.Xml.Schema.XmlSchemaObject obj in seqItems)
{
if (obj is System.Xml.Schema.XmlSchemaElement)
{
elements.Add(obj);
}
else if (obj is System.Xml.Schema.XmlSchemaChoice)
{
System.Xml.Schema.XmlSchemaChoice choice = obj as System.Xml.Schema.XmlSchemaChoice;
// Add each element of the choice
foreach (System.Xml.Schema.XmlSchemaObject item in choice.Items)
{
if (item is System.Xml.Schema.XmlSchemaElement)
{
elements.Add(item);
}
else if (item is System.Xml.Schema.XmlSchemaGroupRef)
{
// Find the Group
string groupName = (obj as System.Xml.Schema.XmlSchemaGroupRef).RefName.Name;
System.Xml.Schema.XmlSchemaGroup group = null;
foreach (System.Xml.Schema.XmlSchemaObject schemaItem in schemaItems)
{
if (schemaItem is System.Xml.Schema.XmlSchemaGroup && groupName == (schemaItem as System.Xml.Schema.XmlSchemaGroup).Name)
{
group = schemaItem as System.Xml.Schema.XmlSchemaGroup; // Found
break;
}
}
if (group == null) // Not found
{
throw new System.Exception("Unknown xs:group " + groupName + string.Format(", nh-mapping.xsd({0})", obj.LineNumber));
}
elements.AddRange(GetElements(group.Particle.Items, schemaItems));
}
else if (item is System.Xml.Schema.XmlSchemaSequence)
{
System.Xml.Schema.XmlSchemaSequence subSeq = item as System.Xml.Schema.XmlSchemaSequence;
elements.AddRange(GetElements(subSeq.Items, schemaItems));
}
else
{
log.Warn("Unknown Object: " + item.ToString() + string.Format(", nh-mapping.xsd({0})", item.LineNumber));
}
}
}
else if (obj is System.Xml.Schema.XmlSchemaGroupRef)
{
// Find the Group
string groupName = (obj as System.Xml.Schema.XmlSchemaGroupRef).RefName.Name;
System.Xml.Schema.XmlSchemaGroup group = null;
foreach (System.Xml.Schema.XmlSchemaObject schemaItem in schemaItems)
{
if (schemaItem is System.Xml.Schema.XmlSchemaGroup && groupName == (schemaItem as System.Xml.Schema.XmlSchemaGroup).Name)
{
group = schemaItem as System.Xml.Schema.XmlSchemaGroup; // Found
break;
}
}
if (group == null) // Not found
{
throw new System.Exception("Unknown xs:group " + groupName + string.Format(", nh-mapping.xsd({0})", obj.LineNumber));
}
elements.AddRange(GetElements(group.Particle.Items, schemaItems));
}
else if (obj is System.Xml.Schema.XmlSchemaSequence)
{
System.Xml.Schema.XmlSchemaSequence subSeq = obj as System.Xml.Schema.XmlSchemaSequence;
elements.AddRange(GetElements(subSeq.Items, schemaItems));
}
else
{
log.Warn("Unknown Object: " + obj.ToString() + string.Format(", nh-mapping.xsd({0})", obj.LineNumber));
}
}
return(elements);
}
/// <summary> Add the content of the method IsNextElement(). </summary>
public static void FillIsNextElement(Refly.CodeDom.MethodDeclaration method, System.Xml.Schema.XmlSchemaObjectCollection schemaItems)
{
method.Attributes = System.CodeDom.MemberAttributes.Public | System.CodeDom.MemberAttributes.Overloaded;
method.Doc.Summary.AddText(" Tells if 'element1' come after 'element2' in rootType's 'sub-elements' order. "); // Create the <summary />
method.Signature.Parameters.Add("BaseAttribute", "element1");
method.Signature.Parameters.Add("BaseAttribute", "baseAttrib");
method.Signature.Parameters.Add(typeof(System.Type), "typeOfElement2");
method.Signature.ReturnType = new Refly.CodeDom.TypeTypeDeclaration(typeof(bool));
method.Body.Add(Refly.CodeDom.Stm.Snippet(
@"if( element1 == null )
return false;" ));
foreach (System.Xml.Schema.XmlSchemaObject obj in schemaItems)
{
if (obj is System.Xml.Schema.XmlSchemaElement)
{
System.Xml.Schema.XmlSchemaElement elt = obj as System.Xml.Schema.XmlSchemaElement;
method.Body.Add(Refly.CodeDom.Stm.Snippet(@"
if( baseAttrib is " + Utils.Capitalize(elt.Name) + @"Attribute )
{" ));
if (elt.SchemaType is System.Xml.Schema.XmlSchemaComplexType)
{
System.Xml.Schema.XmlSchemaComplexType type = elt.SchemaType as System.Xml.Schema.XmlSchemaComplexType;
// Add the elements
if (type.Particle is System.Xml.Schema.XmlSchemaSequence)
{
System.Xml.Schema.XmlSchemaSequence seq = (elt.SchemaType as System.Xml.Schema.XmlSchemaComplexType).Particle as System.Xml.Schema.XmlSchemaSequence;
System.Collections.ArrayList members = Utils.GetElements(seq.Items, schemaItems);
for (int i = 0; i < members.Count; i++)
{
System.Xml.Schema.XmlSchemaElement member = members[i] as System.Xml.Schema.XmlSchemaElement;
if (member.RefName.Name == string.Empty)
{
continue; // Ignore elements like <query> and <sql-query>
}
string memberName = Utils.Capitalize(member.Name + member.RefName.Name); // One of them is empty
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append(
@" if( typeOfElement2 == typeof("+ memberName + @"Attribute) )
{
if( " );
for (int j = i + 1; j < members.Count; j++)
{
System.Xml.Schema.XmlSchemaElement nextMember = members[j] as System.Xml.Schema.XmlSchemaElement;
if (nextMember.RefName.Name == string.Empty)
{
continue; // Ignore elements like <query> and <sql-query>
}
string nextMemberName = Utils.Capitalize(nextMember.Name + nextMember.RefName.Name); // One of them is empty
sb.Append("element1 is " + nextMemberName + "Attribute || ");
}
// Add "typeOfElement2 == null" at the end to handle "||" and empty "if()" without compilation warning
sb.Append(@"typeOfElement2 == null )
return true;
}" );
method.Body.Add(Refly.CodeDom.Stm.Snippet(sb.ToString()));
}
}
}
method.Body.Add(Refly.CodeDom.Stm.Snippet("}"));
}
}
method.Body.Add(Refly.CodeDom.Stm.Snippet("return false;"));
// -----------------------------------------------------------------
}
/// <summary> Generate a Writer method for a XmlSchemaElement. </summary>
public static void GenerateElementWriter(System.Xml.Schema.XmlSchemaElement schemaElt, string schemaEltName, Refly.CodeDom.MethodDeclaration method, System.Xml.Schema.XmlSchemaComplexType refSchemaType, System.Xml.Schema.XmlSchemaObjectCollection schemaItems)
{
bool schemaEltIsRoot = Utils.IsRoot(schemaEltName);
method.Attributes = System.CodeDom.MemberAttributes.Public | System.CodeDom.MemberAttributes.Overloaded;
method.Doc.Summary.AddText(" Write a " + schemaEltName + " XML Element from attributes in a " + (schemaEltIsRoot?"type":"member") + ". "); // Create the <summary />
method.Signature.Parameters.Add(typeof(System.Xml.XmlWriter), "writer");
if (schemaEltIsRoot)
{
method.Signature.Parameters.Add(typeof(System.Type), "type");
}
else
{
method.Signature.Parameters.Add(typeof(System.Reflection.MemberInfo), "member");
method.Signature.Parameters.Add(schemaEltName + "Attribute", "attribute");
method.Signature.Parameters.Add("BaseAttribute", "parentAttribute");
method.Signature.Parameters.Add(typeof(System.Type), "mappedClass");
}
// Beginning of the method's body
if (schemaEltIsRoot)
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
@"object[] attributes = {1}.GetCustomAttributes(typeof({0}Attribute), false);
if(attributes.Length == 0)
return;
{0}Attribute attribute = attributes[0] as {0}Attribute;
", schemaEltName, schemaEltIsRoot ? "type" : "member"))); // Note : Root should never allow multiple !
}
method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
"writer.WriteStartElement( \"{0}\" );", schemaElt.Name)));
System.Xml.Schema.XmlSchemaComplexType type = schemaElt.SchemaType as System.Xml.Schema.XmlSchemaComplexType;
if (type == null && !schemaElt.SchemaTypeName.IsEmpty) // eg: <xs:element name="cache" type="cacheType" />
{
type = refSchemaType;
}
if (type != null)
{
// Add the attributes
System.Collections.ArrayList attributes = Utils.GetAttributes(type.Attributes);
log.Debug("Add Attributes: Count=" + attributes.Count);
foreach (System.Xml.Schema.XmlSchemaAttribute attrib in attributes)
{
string attribName = attrib.Name + attrib.RefName.Name; // One is empty
string methodAttribName = "attribute." + Utils.Capitalize(attribName);
method.Body.Add(Refly.CodeDom.Stm.Comment("Attribute: <" + attribName + ">"));
// If the attribute is not explicitly marked required, then we consider it optionnal
if (attrib.Use != System.Xml.Schema.XmlSchemaUse.Required)
{
if ("System.Boolean" == Utils.GetAttributeTypeName(schemaElt, attrib))
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(
string.Format(@"if( {0} )", methodAttribName + "Specified")));
}
else
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(
string.Format(@"if({0} != {1})", methodAttribName,
Utils.GetUnspecifiedValue(schemaElt, attrib))));
}
}
// Write the value
if (attrib.Use == System.Xml.Schema.XmlSchemaUse.Required)
{
// Here, we use a helper if the field is not specified (mainly used for "name" which is the name of the member)
log.Debug(" Create Helper for " + (schemaEltIsRoot ? "ClassType" : "MemberInfo") + " <" + schemaElt.Name + "> <" + attribName + ">");
string helper = string.Format(@"{0}=={1} ? DefaultHelper.Get_{2}_{3}_DefaultValue({4}) : ", // "typed" method name :)
methodAttribName, Utils.GetUnspecifiedValue(schemaElt, attrib), schemaEltName,
Utils.Capitalize(attribName),
schemaEltIsRoot ? "type" : "member");
method.Body.Add(Refly.CodeDom.Stm.Snippet(
string.Format(@"writer.WriteAttributeString(""{0}"", {2}{1});",
attribName, AttributeToXmlValue(schemaElt, attrib, attribName, schemaEltIsRoot), helper)));
}
else
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(
string.Format(@"writer.WriteAttributeString(""{0}"", {1});",
attribName, AttributeToXmlValue(schemaElt, attrib, attribName, schemaEltIsRoot))));
if (schemaEltName == "Property" && attribName == "type")
{
// Special case to handle Patterns for <property ... type="..." />
// Eg: set Nullables.NHibernate.NullableXXXType for Nullables.NullableXXX
method.Body.Add(Refly.CodeDom.Stm.Snippet(@"else
{
System.Type type = null;
if(member is System.Reflection.PropertyInfo)
type = (member as System.Reflection.PropertyInfo).PropertyType;
else if(member is System.Reflection.FieldInfo)
type = (member as System.Reflection.FieldInfo).FieldType;
if(type != null) // Transform using RegularExpressions
{
string typeName = HbmWriterHelper.GetNameWithAssembly(type);
foreach(System.Collections.DictionaryEntry pattern in Patterns)
{
if(System.Text.RegularExpressions.Regex.IsMatch(typeName, pattern.Key as string))
{
writer.WriteAttributeString( ""type"",
System.Text.RegularExpressions.Regex.Replace(typeName,
pattern.Key as string,
pattern.Value as string) );
break;
}
}
}
}" ));
}
}
}
// Add the elements
method.Body.Add(Refly.CodeDom.Stm.Snippet(
schemaEltIsRoot ? @"
WriteUserDefinedContent(writer, type, null, attribute);" : @"
WriteUserDefinedContent(writer, member, null, attribute);"
));
if (type.Particle is System.Xml.Schema.XmlSchemaSequence)
{
System.Xml.Schema.XmlSchemaSequence seq = (schemaElt.SchemaType as System.Xml.Schema.XmlSchemaComplexType).Particle as System.Xml.Schema.XmlSchemaSequence;
System.Collections.ArrayList members = Utils.GetElements(seq.Items, schemaItems);
if (!schemaEltIsRoot)
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(@"
System.Collections.ArrayList memberAttribs = GetSortedAttributes(member);
int attribPos; // Find the position of the {0}Attribute (its <sub-element>s must be after it)
for(attribPos=0; attribPos<memberAttribs.Count; attribPos++)
if( memberAttribs[attribPos] is {0}Attribute
&& ((BaseAttribute)memberAttribs[attribPos]).Position == attribute.Position )
break; // found
int i = attribPos + 1;
", schemaEltName)));
}
foreach (System.Xml.Schema.XmlSchemaElement member in members)
{
if (member.RefName.Name != null && member.RefName.Name != string.Empty &&
member.Name != null && member.Name != string.Empty)
{
log.Error(string.Format("Both member.RefName.Name({0}) & member.Name({1}) are not empty", member.RefName.Name, member.Name));
}
string realMemberName = member.Name + member.RefName.Name; // One of them should be empty
string memberName = Utils.Capitalize(realMemberName);
string listName = memberName + "List";
string attributeName = memberName + "Attribute";
log.Debug(schemaEltName + " Element: <" + realMemberName + ">");
method.Body.Add(Refly.CodeDom.Stm.Comment("Element: <" + realMemberName + ">"));
// There are three way to treat elements:
// if(eltName is root)
// if(memberName is root)
// => They are both root, so we process the nestedTypes (eg. <class> to <sub-class>)
// else
// => It is an element of a root => we add them as element
// else
// => They are both members, so we use the member again (eg. <list> to <one-to-many>)
if (schemaEltIsRoot)
{
if (Utils.IsRoot(memberName))
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
@"WriteNested{0}Types(writer, type);", memberName)));
}
else
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(string.Format(
@"System.Collections.ArrayList {1} = FindAttributedMembers( attribute, typeof({2}), type );
foreach( System.Reflection.MemberInfo member in {1} )
" , memberName, listName, attributeName) + "{"
+ string.Format(
@"
object[] objects = member.GetCustomAttributes(typeof({2}), false);
System.Collections.ArrayList memberAttribs = new System.Collections.ArrayList();
memberAttribs.AddRange(objects);
memberAttribs.Sort();
" + (Utils.CanContainItself(memberName) ?
// => Just take the first (others will be inside it)
@" Write{0}(writer, member, memberAttribs[0] as {2}, attribute, type);"
:
@" foreach(object memberAttrib in memberAttribs)
Write{0}(writer, member, memberAttrib as {2}, attribute, type);" ),
memberName, listName, attributeName) + @"
}" ));
}
method.Body.Add(Refly.CodeDom.Stm.Snippet(
"WriteUserDefinedContent(writer, type, typeof(" + attributeName + "), attribute);"));
}
else
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(
@"for(; i<memberAttribs.Count; i++)
{
BaseAttribute memberAttrib = memberAttribs[i] as BaseAttribute;
if( IsNextElement(memberAttrib, parentAttribute, attribute.GetType())
|| IsNextElement(memberAttrib, attribute, typeof(" + attributeName + @")) )
break; // next attributes are 'elements' of the same level OR for 'sub-elements'"
+ (Utils.IsRoot(memberName) ? "" // A NotRoot can not contain a Root! eg. [DynComp] can't contain a [Comp] (instead, use [CompProp])
: @"
else
{"
+ (Utils.CanContainItself(memberName) ? "" : @"
if( memberAttrib is " + schemaEltName + @"Attribute )
break; // Following attributes are for this " + schemaEltName) + @"
if( memberAttrib is " + attributeName + @" )
Write" + memberName + @"(writer, member, memberAttrib as " + attributeName + @", attribute, mappedClass);
}" ) + @"
}" ));
method.Body.Add(Refly.CodeDom.Stm.Snippet(
"WriteUserDefinedContent(writer, member, typeof(" + attributeName + "), attribute);"));
}
}
}
if (type.IsMixed) // used by elements like <param>
{
method.Body.Add(Refly.CodeDom.Stm.Snippet(@"
// Write the content of this element (mixed=""true"")
writer.WriteString(attribute.Content);" ));
}
}
else
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append("Unknow Element: ").Append(schemaElt.Name);
if (schemaElt.SchemaType != null)
{
sb.Append(", SchemaType = ").Append(schemaElt.SchemaType).Append(" - ").Append(schemaElt.SchemaType.Name);
}
if (!schemaElt.SchemaTypeName.IsEmpty)
{
sb.Append(", SchemaTypeName = ").Append(schemaElt.SchemaTypeName.Name);
}
if (schemaElt.ElementSchemaType != null)
{
sb.Append(", ElementType = ").Append(schemaElt.ElementSchemaType.Name);
}
log.Warn(sb.ToString());
}
method.Body.Add(Refly.CodeDom.Stm.Snippet(@"
writer.WriteEndElement();" ));
}