// Copyright (C) Ximian, Inc., 2003
//
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
using System.CodeDom;
+using System.CodeDom.Compiler;
using System.Collections;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
using System.Xml.Schema;
+using Microsoft.CSharp;
+
namespace System.Xml.Serialization {
internal class MapCodeGenerator {
CodeNamespace codeNamespace;
- CodeCompileUnit codeCompileUnit;
+// CodeCompileUnit codeCompileUnit;
CodeAttributeDeclarationCollection includeMetadata;
- bool encodedFormat;
+ XmlTypeMapping exportedAnyType;
+ protected bool includeArrayTypes;
+ CodeDomProvider codeProvider;
+ CodeGenerationOptions options;
+ CodeIdentifiers identifiers;
Hashtable exportedMaps = new Hashtable ();
+ Hashtable includeMaps = new Hashtable ();
+
+ public MapCodeGenerator (CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit, CodeGenerationOptions options)
+ {
+// this.codeCompileUnit = codeCompileUnit;
+ this.codeNamespace = codeNamespace;
+ this.options = options;
+ this.identifiers = new CodeIdentifiers ();
+ }
- public MapCodeGenerator (CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit)
+ public MapCodeGenerator (CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit, CodeDomProvider codeProvider, CodeGenerationOptions options, Hashtable mappings)
{
- this.codeCompileUnit = codeCompileUnit;
+// this.codeCompileUnit = codeCompileUnit;
this.codeNamespace = codeNamespace;
+ this.options = options;
+ this.codeProvider = codeProvider;
+ this.identifiers = new CodeIdentifiers ((codeProvider.LanguageOptions & LanguageOptions.CaseInsensitive) == 0);
+// this.mappings = mappings;
}
+ public CodeAttributeDeclarationCollection IncludeMetadata
+ {
+ get
+ {
+ if (includeMetadata != null) return includeMetadata;
+ includeMetadata = new CodeAttributeDeclarationCollection ();
+
+ foreach (XmlTypeMapping map in includeMaps.Values)
+ GenerateClassInclude (includeMetadata, map);
+
+ return includeMetadata;
+ }
+ }
+
#region Code generation methods
public void ExportMembersMapping (XmlMembersMapping xmlMembersMapping)
ExportMembersMapCode (dummyClass, (ClassMap)xmlMembersMapping.ObjectMap, xmlMembersMapping.Namespace, null);
}
- public void ExportTypeMapping (XmlTypeMapping xmlTypeMapping)
+ public void ExportTypeMapping (XmlTypeMapping xmlTypeMapping, bool isTopLevel)
{
- ExportMapCode (xmlTypeMapping);
+ ExportMapCode (xmlTypeMapping, isTopLevel);
+ RemoveInclude (xmlTypeMapping);
}
- void ExportMapCode (XmlTypeMapping map)
+ void ExportMapCode (XmlTypeMapping map, bool isTopLevel)
{
switch (map.TypeData.SchemaType)
{
case SchemaTypes.Enum:
- ExportEnumCode (map);
+ ExportEnumCode (map, isTopLevel);
break;
case SchemaTypes.Array:
break;
case SchemaTypes.Class:
- ExportClassCode (map);
+ ExportClassCode (map, isTopLevel);
break;
case SchemaTypes.XmlSerializable:
}
}
- void ExportClassCode (XmlTypeMapping map)
+ void ExportClassCode (XmlTypeMapping map, bool isTopLevel)
{
- if (IsMapExported (map)) return;
- SetMapExported (map);
+ CodeTypeDeclaration codeClass;
+ if (IsMapExported (map)) {
+ codeClass = GetMapDeclaration (map);
+ if (codeClass != null) {
+ // Regenerate attributes, since things may have changed
+ codeClass.CustomAttributes.Clear ();
+ AddClassAttributes (codeClass);
+ GenerateClass (map, codeClass, isTopLevel);
+ ExportDerivedTypeAttributes (map, codeClass);
+ }
+ return;
+ }
+
+ if (map.TypeData.Type == typeof(object))
+ {
+ exportedAnyType = map;
+ SetMapExported (map, null);
+ foreach (XmlTypeMapping dmap in exportedAnyType.DerivedTypes) {
+ if (IsMapExported (dmap) || !dmap.IncludeInSchema) continue;
+ ExportTypeMapping (dmap, false);
+ AddInclude (dmap);
+ }
+ return;
+ }
+
+ codeClass = new CodeTypeDeclaration (map.TypeData.TypeName);
+ SetMapExported (map, codeClass);
- CodeTypeDeclaration codeClass = new CodeTypeDeclaration (map.TypeData.TypeName);
AddCodeType (codeClass, map.Documentation);
codeClass.Attributes = MemberAttributes.Public;
- GenerateClass (map, codeClass);
+ codeClass.IsPartial = CodeProvider.Supports(GeneratorSupport.PartialTypes);
+ AddClassAttributes (codeClass);
+ GenerateClass (map, codeClass, isTopLevel);
+ ExportDerivedTypeAttributes (map, codeClass);
+
ExportMembersMapCode (codeClass, (ClassMap)map.ObjectMap, map.XmlTypeNamespace, map.BaseMap);
- if (map.BaseMap != null)
+ if (map.BaseMap != null && map.BaseMap.TypeData.SchemaType != SchemaTypes.XmlNode)
{
- CodeTypeReference ctr = new CodeTypeReference (map.BaseMap.TypeData.FullTypeName);
+ CodeTypeReference ctr = GetDomType (map.BaseMap.TypeData, false);
codeClass.BaseTypes.Add (ctr);
- ExportMapCode (map.BaseMap);
+ if (map.BaseMap.IncludeInSchema) {
+ ExportMapCode (map.BaseMap, false);
+ AddInclude (map.BaseMap);
+ }
}
-
ExportDerivedTypes (map, codeClass);
}
+ void ExportDerivedTypeAttributes (XmlTypeMapping map, CodeTypeDeclaration codeClass)
+ {
+ foreach (XmlTypeMapping tm in map.DerivedTypes)
+ {
+ GenerateClassInclude (codeClass.CustomAttributes, tm);
+ ExportDerivedTypeAttributes (tm, codeClass);
+ }
+ }
+
void ExportDerivedTypes (XmlTypeMapping map, CodeTypeDeclaration codeClass)
{
foreach (XmlTypeMapping tm in map.DerivedTypes)
{
- GenerateClassInclude (codeClass, tm);
- ExportMapCode (tm);
+ if (codeClass.CustomAttributes == null)
+ codeClass.CustomAttributes = new CodeAttributeDeclarationCollection ();
+
+ ExportMapCode (tm, false);
ExportDerivedTypes (tm, codeClass);
}
}
void ExportMembersMapCode (CodeTypeDeclaration codeClass, ClassMap map, string defaultNamespace, XmlTypeMapping baseMap)
{
+ ICollection attributes = map.AttributeMembers;
ICollection members = map.ElementMembers;
+
+ // collect names
+ if (attributes != null)
+ foreach (XmlTypeMapMemberAttribute attr in attributes)
+ identifiers.AddUnique (attr.Name, attr);
+ if (members != null)
+ foreach (XmlTypeMapMemberElement member in members)
+ identifiers.AddUnique (member.Name, member);
+
+ // Write attributes
+
+ if (attributes != null) {
+ foreach (XmlTypeMapMemberAttribute attr in attributes) {
+ if (baseMap != null && DefinedInBaseMap (baseMap, attr)) continue;
+ AddAttributeFieldMember (codeClass, attr, defaultNamespace);
+ }
+ }
+
+ members = map.ElementMembers;
if (members != null)
{
}
}
- // Write attributes
-
- ICollection attributes = map.AttributeMembers;
- if (attributes != null)
- {
- foreach (XmlTypeMapMemberAttribute attr in attributes) {
- if (baseMap != null && DefinedInBaseMap (baseMap, attr)) continue;
- AddAttributeFieldMember (codeClass, attr, defaultNamespace);
- }
- }
-
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
if (anyAttrMember != null)
{
- CodeMemberField codeField = new CodeMemberField (anyAttrMember.TypeData.FullTypeName, anyAttrMember.Name);
+ CodeTypeMember codeField = CreateFieldMember (codeClass, anyAttrMember.TypeData, anyAttrMember.Name);
AddComments (codeField, anyAttrMember.Documentation);
codeField.Attributes = MemberAttributes.Public;
GenerateAnyAttribute (codeField);
- codeClass.Members.Add (codeField);
}
}
+
+ CodeTypeMember CreateFieldMember (CodeTypeDeclaration codeClass, Type type, string name)
+ {
+ return CreateFieldMember (codeClass, new CodeTypeReference(type), name, System.DBNull.Value, null, null);
+ }
+
+ CodeTypeMember CreateFieldMember (CodeTypeDeclaration codeClass, TypeData type, string name)
+ {
+ return CreateFieldMember (codeClass, GetDomType (type, false), name, System.DBNull.Value, null, null);
+ }
- CodeMemberField CreateFieldMember (string type, string name, object defaultValue, string comments)
+ CodeTypeMember CreateFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMember member)
{
- CodeMemberField codeField = new CodeMemberField (type, name);
- codeField.Attributes = MemberAttributes.Public;
- AddComments (codeField, comments);
+ return CreateFieldMember (codeClass, GetDomType (member.TypeData, member.RequiresNullable), member.Name, member.DefaultValue, member.TypeData, member.Documentation);
+ }
+
+ CodeTypeMember CreateFieldMember (CodeTypeDeclaration codeClass, CodeTypeReference type, string name, object defaultValue, TypeData defaultType, string documentation)
+ {
+ CodeMemberField codeField = null;
+ CodeTypeMember codeProp = null;
+ if ((options & CodeGenerationOptions.GenerateProperties) > 0) {
+ string field = identifiers.AddUnique (CodeIdentifier.MakeCamel (name + "Field"), name);
+ codeField = new CodeMemberField (type, field);
+ codeField.Attributes = MemberAttributes.Private;
+ codeClass.Members.Add (codeField);
+
+ CodeMemberProperty prop = new CodeMemberProperty ();
+ prop.Name = name;
+ prop.Type = type;
+ prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
+ codeProp = prop;
+ prop.HasGet = prop.HasSet = true;
+
+ CodeExpression ce = new CodeFieldReferenceExpression (new CodeThisReferenceExpression(), field);
+ prop.SetStatements.Add (new CodeAssignStatement (ce, new CodePropertySetValueReferenceExpression()));
+ prop.GetStatements.Add (new CodeMethodReturnStatement (ce));
+ }
+ else {
+ codeField = new CodeMemberField (type, name);
+ codeField.Attributes = MemberAttributes.Public;
+ codeProp = codeField;
+ }
+
if (defaultValue != System.DBNull.Value)
- GenerateDefaultAttribute (codeField, defaultValue);
+ GenerateDefaultAttribute (codeField, codeProp, defaultType, defaultValue);
- return codeField;
+ AddComments (codeProp, documentation);
+ codeClass.Members.Add (codeProp);
+ return codeProp;
}
void AddAttributeFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMemberAttribute attinfo, string defaultNamespace)
{
- CodeMemberField codeField = CreateFieldMember (attinfo.TypeData.FullTypeName, attinfo.Name, attinfo.DefaultValue, attinfo.Documentation);
- codeClass.Members.Add (codeField);
+ CodeTypeMember codeField = CreateFieldMember (codeClass, attinfo);
- GenerateAttributeMember (codeField, attinfo, defaultNamespace);
+ CodeAttributeDeclarationCollection attributes = codeField.CustomAttributes;
+ if (attributes == null) attributes = new CodeAttributeDeclarationCollection ();
+
+ GenerateAttributeMember (attributes, attinfo, defaultNamespace, false);
+ if (attributes.Count > 0) codeField.CustomAttributes = attributes;
- if (attinfo.MappedType != null)
- ExportMapCode (attinfo.MappedType);
+ if (attinfo.MappedType != null) {
+ ExportMapCode (attinfo.MappedType, false);
+ RemoveInclude (attinfo.MappedType);
+ }
if (attinfo.TypeData.IsValueType && attinfo.IsOptionalValueType)
{
- codeField = new CodeMemberField (typeof(bool), attinfo.Name + "Specified");
+ codeField = CreateFieldMember (codeClass, typeof(bool), identifiers.MakeUnique (attinfo.Name + "Specified"));
codeField.Attributes = MemberAttributes.Public;
- codeClass.Members.Add (codeField);
GenerateSpecifierMember (codeField);
}
}
+
+ public void AddAttributeMemberAttributes (XmlTypeMapMemberAttribute attinfo, string defaultNamespace, CodeAttributeDeclarationCollection attributes, bool forceUseMemberName)
+ {
+ GenerateAttributeMember (attributes, attinfo, defaultNamespace, forceUseMemberName);
+ }
void AddElementFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMemberElement member, string defaultNamespace)
{
- CodeMemberField codeField = CreateFieldMember (member.TypeData.FullTypeName, member.Name, member.DefaultValue, member.Documentation);
- codeClass.Members.Add (codeField);
+ CodeTypeMember codeField = CreateFieldMember (codeClass, member);
+
+ CodeAttributeDeclarationCollection attributes = codeField.CustomAttributes;
+ if (attributes == null) attributes = new CodeAttributeDeclarationCollection ();
+
+ AddElementMemberAttributes (member, defaultNamespace, attributes, false);
+ if (attributes.Count > 0) codeField.CustomAttributes = attributes;
+
+ if (member.TypeData.IsValueType && member.IsOptionalValueType)
+ {
+ codeField = CreateFieldMember (codeClass, typeof(bool), identifiers.MakeUnique (member.Name + "Specified"));
+ codeField.Attributes = MemberAttributes.Public;
+ GenerateSpecifierMember (codeField);
+ }
+ }
+
+ public void AddElementMemberAttributes (XmlTypeMapMemberElement member, string defaultNamespace, CodeAttributeDeclarationCollection attributes, bool forceUseMemberName)
+ {
TypeData defaultType = member.TypeData;
bool addAlwaysAttr = false;
defaultType = defaultType.ListItemTypeData;
addAlwaysAttr = true;
}
-
+
foreach (XmlTypeMapElementInfo einfo in member.ElementInfo)
{
- if (ExportExtraElementAttributes (codeField, einfo, defaultNamespace, defaultType))
+ if (einfo.MappedType != null) {
+ ExportMapCode (einfo.MappedType, false);
+ RemoveInclude (einfo.MappedType);
+ }
+
+ if (ExportExtraElementAttributes (attributes, einfo, defaultNamespace, defaultType))
continue;
- GenerateElementInfoMember (codeField, member, einfo, defaultType, defaultNamespace, addAlwaysAttr);
- if (einfo.MappedType != null) ExportMapCode (einfo.MappedType);
+ GenerateElementInfoMember (attributes, member, einfo, defaultType, defaultNamespace, addAlwaysAttr, forceUseMemberName | addAlwaysAttr);
}
- GenerateElementMember (codeField, member);
-
- if (member.TypeData.IsValueType && member.IsOptionalValueType)
- {
- codeField = new CodeMemberField (typeof(bool), member.Name + "Specified");
- codeField.Attributes = MemberAttributes.Public;
- codeClass.Members.Add (codeField);
- GenerateSpecifierMember (codeField);
- }
+ GenerateElementMember (attributes, member);
}
void AddAnyElementFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMemberElement member, string defaultNamespace)
{
- CodeMemberField codeField = CreateFieldMember (member.TypeData.FullTypeName, member.Name, member.DefaultValue, member.Documentation);
- codeClass.Members.Add (codeField);
+ CodeTypeMember codeField = CreateFieldMember (codeClass, member);
+ CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection ();
foreach (XmlTypeMapElementInfo einfo in member.ElementInfo)
- {
- ExportExtraElementAttributes (codeField, einfo, defaultNamespace, einfo.TypeData);
- }
+ ExportExtraElementAttributes (attributes, einfo, defaultNamespace, einfo.TypeData);
+
+ if (attributes.Count > 0) codeField.CustomAttributes = attributes;
}
bool DefinedInBaseMap (XmlTypeMapping map, XmlTypeMapMember member)
void AddArrayElementFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMemberList member, string defaultNamespace)
{
- CodeMemberField codeField = new CodeMemberField (member.TypeData.FullTypeName, member.Name);
- AddComments (codeField, member.Documentation);
- codeField.Attributes = MemberAttributes.Public;
- codeClass.Members.Add (codeField);
-
- GenerateArrayElement (codeField, member, defaultNamespace);
+ CodeTypeMember codeField = CreateFieldMember (codeClass, member.TypeData, member.Name);
+
+ CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection ();
+ AddArrayAttributes (attributes, member, defaultNamespace, false);
ListMap listMap = (ListMap) member.ListTypeMapping.ObjectMap;
- AddArrayItemAttributes (codeField, listMap, member.TypeData.ListItemTypeData, defaultNamespace, 0);
+ AddArrayItemAttributes (attributes, listMap, member.TypeData.ListItemTypeData, defaultNamespace, 0);
+
+ if (attributes.Count > 0) codeField.CustomAttributes = attributes;
+ }
+
+ public void AddArrayAttributes (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName)
+ {
+ GenerateArrayElement (attributes, member, defaultNamespace, forceUseMemberName);
}
- void AddArrayItemAttributes (CodeMemberField codeField, ListMap listMap, TypeData type, string defaultNamespace, int nestingLevel)
+ public void AddArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, string defaultNamespace, int nestingLevel)
{
foreach (XmlTypeMapElementInfo ainfo in listMap.ItemInfo)
{
if (ainfo.MappedType != null) defaultName = ainfo.MappedType.ElementName;
else defaultName = ainfo.TypeData.XmlType;
- GenerateArrayItemAttributes (codeField, listMap, type, ainfo, defaultName, defaultNamespace, nestingLevel);
- if (ainfo.MappedType != null) ExportMapCode (ainfo.MappedType);
+ GenerateArrayItemAttributes (attributes, listMap, type, ainfo, defaultName, defaultNamespace, nestingLevel);
+ if (ainfo.MappedType != null) {
+ if (!IsMapExported (ainfo.MappedType) && includeArrayTypes)
+ AddInclude (ainfo.MappedType);
+ ExportMapCode (ainfo.MappedType, false);
+ }
}
if (listMap.IsMultiArray)
{
XmlTypeMapping nmap = listMap.NestedArrayMapping;
- AddArrayItemAttributes (codeField, (ListMap) nmap.ObjectMap, nmap.TypeData.ListItemTypeData, defaultNamespace, nestingLevel + 1);
+ AddArrayItemAttributes (attributes, (ListMap) nmap.ObjectMap, nmap.TypeData.ListItemTypeData, defaultNamespace, nestingLevel + 1);
}
}
ListMap listMap = (ListMap) map.ObjectMap;
foreach (XmlTypeMapElementInfo ainfo in listMap.ItemInfo)
{
- if (ainfo.MappedType != null)
- ExportMapCode (ainfo.MappedType);
+ if (ainfo.MappedType != null) {
+ if (!IsMapExported (ainfo.MappedType) && includeArrayTypes)
+ AddInclude (ainfo.MappedType);
+ ExportMapCode (ainfo.MappedType, false);
+ }
}
}
- bool ExportExtraElementAttributes (CodeMemberField codeField, XmlTypeMapElementInfo einfo, string defaultNamespace, TypeData defaultType)
+ bool ExportExtraElementAttributes (CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, string defaultNamespace, TypeData defaultType)
{
if (einfo.IsTextElement) {
- GenerateTextElementAttribute (codeField, einfo, defaultType);
+ GenerateTextElementAttribute (attributes, einfo, defaultType);
return true;
}
else if (einfo.IsUnnamedAnyElement) {
- GenerateUnnamedAnyElementAttribute (codeField, einfo, defaultNamespace);
+ GenerateUnnamedAnyElementAttribute (attributes, einfo, defaultNamespace);
return true;
}
return false;
}
- void ExportEnumCode (XmlTypeMapping map)
+ void ExportEnumCode (XmlTypeMapping map, bool isTopLevel)
{
if (IsMapExported (map)) return;
- SetMapExported (map);
CodeTypeDeclaration codeEnum = new CodeTypeDeclaration (map.TypeData.TypeName);
+ SetMapExported (map, codeEnum);
+
codeEnum.Attributes = MemberAttributes.Public;
codeEnum.IsEnum = true;
AddCodeType (codeEnum, map.Documentation);
- GenerateEnum (map, codeEnum);
EnumMap emap = (EnumMap) map.ObjectMap;
-
if (emap.IsFlags)
- codeEnum.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Flags"));
+ codeEnum.CustomAttributes.Add (new CodeAttributeDeclaration ("System.FlagsAttribute"));
+
+ CodeAttributeDeclaration generatedCodeAttribute = new CodeAttributeDeclaration (
+ new CodeTypeReference (typeof(GeneratedCodeAttribute)));
+ generatedCodeAttribute.Arguments.Add (new CodeAttributeArgument (
+ new CodePrimitiveExpression ("System.Xml")));
+ generatedCodeAttribute.Arguments.Add (new CodeAttributeArgument (
+ new CodePrimitiveExpression (Consts.FxFileVersion)));
+ codeEnum.CustomAttributes.Add (generatedCodeAttribute);
+
+ codeEnum.CustomAttributes.Add (new CodeAttributeDeclaration (
+ new CodeTypeReference (typeof (SerializableAttribute))));
+ GenerateEnum (map, codeEnum, isTopLevel);
+
int flag = 1;
foreach (EnumMap.EnumMapMember emem in emap.Members)
{
codeEnum.Members.Add (codeField);
}
}
+
+ void AddInclude (XmlTypeMapping map)
+ {
+ if (!includeMaps.ContainsKey (map.TypeData.FullTypeName))
+ includeMaps [map.TypeData.FullTypeName] = map;
+ }
+
+ void RemoveInclude (XmlTypeMapping map)
+ {
+ includeMaps.Remove (map.TypeData.FullTypeName);
+ }
#endregion
bool IsMapExported (XmlTypeMapping map)
{
- if (exportedMaps.Contains (map)) return true;
- if (map.TypeData.Type == typeof(object)) return true;
- if (!map.IncludeInSchema) return true;
+ if (exportedMaps.Contains (map.TypeData.FullTypeName)) return true;
return false;
}
- void SetMapExported (XmlTypeMapping map)
+ void SetMapExported (XmlTypeMapping map, CodeTypeDeclaration declaration)
{
- exportedMaps.Add (map,map);
+ exportedMaps.Add (map.TypeData.FullTypeName, declaration);
+ }
+
+ CodeTypeDeclaration GetMapDeclaration (XmlTypeMapping map)
+ {
+ return exportedMaps [map.TypeData.FullTypeName] as CodeTypeDeclaration;
}
public static void AddCustomAttribute (CodeTypeMember ctm, CodeAttributeDeclaration att, bool addIfNoParams)
return new CodeAttributeArgument (name, new CodeTypeOfExpression(typeName));
}
+ public static CodeAttributeArgument GetEnumArg (string name, string enumType, string enumValue)
+ {
+ return new CodeAttributeArgument (name, new CodeFieldReferenceExpression (new CodeTypeReferenceExpression(enumType), enumValue));
+ }
+
public static void AddComments (CodeTypeMember member, string comments)
{
if (comments == null || comments == "") member.Comments.Add (new CodeCommentStatement ("<remarks/>", true));
AddComments (type, comments);
codeNamespace.Types.Add (type);
}
+
+ void AddClassAttributes (CodeTypeDeclaration codeClass)
+ {
+ CodeAttributeDeclaration generatedCodeAttribute = new CodeAttributeDeclaration (
+ new CodeTypeReference (typeof (GeneratedCodeAttribute)));
+ generatedCodeAttribute.Arguments.Add (new CodeAttributeArgument (
+ new CodePrimitiveExpression ("System.Xml")));
+ generatedCodeAttribute.Arguments.Add (new CodeAttributeArgument (
+ new CodePrimitiveExpression (Consts.FxFileVersion)));
+ codeClass.CustomAttributes.Add (generatedCodeAttribute);
+
+ codeClass.CustomAttributes.Add (new CodeAttributeDeclaration (
+ new CodeTypeReference (typeof (SerializableAttribute))));
+ codeClass.CustomAttributes.Add (new CodeAttributeDeclaration (
+ new CodeTypeReference (typeof (DebuggerStepThroughAttribute))));
+
+ CodeAttributeDeclaration designerCategoryAttribute = new CodeAttributeDeclaration (
+ new CodeTypeReference (typeof (DesignerCategoryAttribute)));
+ designerCategoryAttribute.Arguments.Add (new CodeAttributeArgument (
+ new CodePrimitiveExpression ("code")));
+ codeClass.CustomAttributes.Add (designerCategoryAttribute);
+ }
- #endregion
+ CodeTypeReference GetDomType (TypeData data, bool requiresNullable)
+ {
+ if (data.IsValueType && (data.IsNullable || requiresNullable))
+ return new CodeTypeReference ("System.Nullable", new CodeTypeReference (data.FullTypeName));
+ if (data.SchemaType == SchemaTypes.Array)
+ return new CodeTypeReference (GetDomType (data.ListItemTypeData, false),1);
+ else
+ return new CodeTypeReference (data.FullTypeName);
+ }
+ #endregion
+
+ #region Private Properties
+
+ private CodeDomProvider CodeProvider {
+ get {
+ if (codeProvider == null) {
+ codeProvider = new CSharpCodeProvider ();
+ }
+ return codeProvider;
+ }
+ }
+
+ #endregion
+
#region Overridable methods
-
- protected virtual void GenerateClass (XmlTypeMapping map, CodeTypeDeclaration codeClass)
+
+ protected virtual void GenerateClass (XmlTypeMapping map, CodeTypeDeclaration codeClass, bool isTopLevel)
{
}
- protected virtual void GenerateClassInclude (CodeTypeDeclaration codeClass, XmlTypeMapping map)
+ protected virtual void GenerateClassInclude (CodeAttributeDeclarationCollection attributes, XmlTypeMapping map)
{
}
- protected virtual void GenerateAnyAttribute (CodeMemberField codeField)
+ protected virtual void GenerateAnyAttribute (CodeTypeMember codeField)
{
}
- protected virtual void GenerateDefaultAttribute (CodeMemberField codeField, object defaultValue)
+ protected virtual void GenerateDefaultAttribute (CodeMemberField internalField, CodeTypeMember externalField, TypeData typeData, object defaultValue)
{
+ if (typeData.Type == null)
+ {
+ // It must be an enumeration defined in the schema.
+ if (typeData.SchemaType != SchemaTypes.Enum)
+ throw new InvalidOperationException ("Type " + typeData.TypeName + " not supported");
+
+ IFormattable defaultValueFormattable = defaultValue as IFormattable;
+ CodeFieldReferenceExpression fref = new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (GetDomType (typeData, false)), defaultValueFormattable != null ? defaultValueFormattable.ToString(null, CultureInfo.InvariantCulture) : defaultValue.ToString ());
+ CodeAttributeArgument arg = new CodeAttributeArgument (fref);
+ AddCustomAttribute (externalField, "System.ComponentModel.DefaultValue", arg);
+ //internalField.InitExpression = fref;
+ }
+ else
+ {
+ defaultValue = defaultValue is decimal ? (object) ('"' + ((decimal) defaultValue).ToString (CultureInfo.InvariantCulture) + '"') : defaultValue;
+ AddCustomAttribute (externalField, "System.ComponentModel.DefaultValue", GetArg (defaultValue));
+ //internalField.InitExpression = new CodePrimitiveExpression (defaultValue);
+ }
}
- protected virtual void GenerateAttributeMember (CodeMemberField codeField, XmlTypeMapMemberAttribute attinfo, string defaultNamespace)
+ protected virtual void GenerateAttributeMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberAttribute attinfo, string defaultNamespace, bool forceUseMemberName)
{
}
- protected virtual void GenerateElementInfoMember (CodeMemberField codeField, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr)
+ protected virtual void GenerateElementInfoMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName)
{
}
- protected virtual void GenerateElementMember (CodeMemberField codeField, XmlTypeMapMemberElement member)
+ protected virtual void GenerateElementMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member)
{
}
- protected virtual void GenerateArrayElement (CodeMemberField codeField, XmlTypeMapMemberElement member, string defaultNamespace)
+ protected virtual void GenerateArrayElement (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName)
{
}
- protected virtual void GenerateArrayItemAttributes (CodeMemberField codeField, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)
+ protected virtual void GenerateArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)
{
}
- protected virtual void GenerateTextElementAttribute (CodeMemberField codeField, XmlTypeMapElementInfo einfo, TypeData defaultType)
+ protected virtual void GenerateTextElementAttribute (CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, TypeData defaultType)
{
}
- protected virtual void GenerateUnnamedAnyElementAttribute (CodeMemberField codeField, XmlTypeMapElementInfo einfo, string defaultNamespace)
+ protected virtual void GenerateUnnamedAnyElementAttribute (CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, string defaultNamespace)
{
}
-
- protected virtual void GenerateEnum (XmlTypeMapping map, CodeTypeDeclaration codeEnum)
+
+ protected virtual void GenerateEnum (XmlTypeMapping map, CodeTypeDeclaration codeEnum, bool isTopLevel)
{
- }
+ }
protected virtual void GenerateEnumItem (CodeMemberField codeField, EnumMap.EnumMapMember emem)
{
}
- protected virtual void GenerateSpecifierMember (CodeMemberField codeField)
+ protected virtual void GenerateSpecifierMember (CodeTypeMember codeField)
{
}
projects / mono.git / blobdiff