//
// System.Xml.Serialization.SerializationCodeGenerator.cs:
//
-// Author:
+// Authors:
// Lluis Sanchez Gual (lluis@ximian.com)
+// Atsushi Enomoto (atsushi@ximian.com)
//
// (C) 2002, 2003 Ximian, Inc. http://www.ximian.com
+// Copyright (C) 2006 Novell, Inc.
//
//
using System.Xml.Serialization;
using System.Collections;
using System.Globalization;
+using System.Text;
namespace System.Xml.Serialization
{
if (type == null) throw new InvalidOperationException ("Type " + info.ClassName + " not found");
string file = info.OutFileName;
- if (file == null || file == "") {
+ if (file == null || file.Length == 0) {
int i = info.ClassName.LastIndexOf (".");
if (i != -1) file = info.ClassName.Substring (i+1);
else file = info.ClassName;
string readerClassName = null;
string writerClassName = null;
+ string baseClassName = null;
+ string implClassName = null;
string namspace = null;
if (_config != null)
{
readerClassName = _config.ReaderClassName;
writerClassName = _config.WriterClassName;
+ baseClassName = _config.BaseSerializerClassName;
+ implClassName = _config.ImplementationClassName;
namspace = _config.Namespace;
}
-
- if (readerClassName == null || readerClassName == "")
+
+ if (readerClassName == null || readerClassName.Length == 0)
readerClassName = "GeneratedReader";
-
- if (writerClassName == null || writerClassName == "")
+
+ if (writerClassName == null || writerClassName.Length == 0)
writerClassName = "GeneratedWriter";
-
+ if (baseClassName == null || baseClassName.Length == 0)
+ baseClassName = "BaseXmlSerializer";
+ if (implClassName == null || implClassName.Length == 0)
+ implClassName = "XmlSerializerContract";
readerClassName = GetUniqueClassName (readerClassName);
writerClassName = GetUniqueClassName (writerClassName);
-
+ baseClassName = GetUniqueClassName (baseClassName);
+ implClassName = GetUniqueClassName (implClassName);
Hashtable mapsByNamespace = new Hashtable ();
Hashtable generatedMaps = new Hashtable ();
generatedMaps [_typeMap] = _result;
string typeName;
- if (_typeMap is XmlTypeMapping) typeName = ((XmlTypeMapping)_typeMap).TypeName;
+ if (_typeMap is XmlTypeMapping) typeName = CodeIdentifier.MakeValid (((XmlTypeMapping)_typeMap).TypeData.CSharpName);
else typeName = ((XmlMembersMapping)_typeMap).ElementName;
_result.ReaderClassName = readerClassName;
_result.WriterClassName = writerClassName;
-
- if (namspace == null || namspace == "")
+ _result.BaseSerializerClassName = baseClassName;
+ _result.ImplementationClassName = implClassName;
+
+ if (namspace == null || namspace.Length == 0)
_result.Namespace = "Mono.GeneratedSerializers." + _typeMap.Format;
else
_result.Namespace = namspace;
}
}
+ static string ToCSharpFullName (Type type)
+ {
+ return TypeData.ToCSharpName (type, true);
+ }
+
#region Writer Generation
//*******************************************************
GenerationResult main = (GenerationResult) generatedMaps[0];
- string baseSerializerName = GetUniqueClassName ("BaseXmlSerializer");
+ string baseSerializerName = main.BaseSerializerClassName;
+ string access_mod = (_config == null || !_config.GenerateAsInternal) ? "public" : "internal";
WriteLine ("");
- WriteLine ("public class " + baseSerializerName + " : System.Xml.Serialization.XmlSerializer");
+ WriteLine (access_mod + " class " + baseSerializerName + " : System.Xml.Serialization.XmlSerializer");
WriteLineInd ("{");
WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {");
WriteLine ("return new " + main.ReaderClassName + " ();");
{
res.SerializerClassName = GetUniqueClassName (res.Mapping.ElementName + "Serializer");
- WriteLine ("public sealed class " + res.SerializerClassName + " : " + baseSerializerName);
+ WriteLine (access_mod + " sealed class " + res.SerializerClassName + " : " + baseSerializerName);
WriteLineInd ("{");
WriteLineInd ("protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {");
WriteLine ("((" + res.WriterClassName + ")writer)." + res.WriteMethodName + "(obj);");
WriteLine ("");
}
- WriteLine ("public class XmlSerializerContract : System.Xml.Serialization.IXmlSerializerImplementation");
+ WriteLine (access_mod + " class " + main.ImplementationClassName + " : System.Xml.Serialization.XmlSerializerImplementation");
WriteLineInd ("{");
WriteLine ("System.Collections.Hashtable readMethods = null;");
WriteLine ("System.Collections.Hashtable typedSerializers = null;");
WriteLine ("");
- WriteLineInd ("public System.Xml.Serialization.XmlSerializationReader Reader {");
+ WriteLineInd ("public override System.Xml.Serialization.XmlSerializationReader Reader {");
WriteLineInd ("get {");
WriteLine ("return new " + main.ReaderClassName + "();");
WriteLineUni ("}");
WriteLineUni ("}");
WriteLine ("");
- WriteLineInd ("public System.Xml.Serialization.XmlSerializationWriter Writer {");
+ WriteLineInd ("public override System.Xml.Serialization.XmlSerializationWriter Writer {");
WriteLineInd ("get {");
WriteLine ("return new " + main.WriterClassName + "();");
WriteLineUni ("}");
WriteLineUni ("}");
WriteLine ("");
- WriteLineInd ("public System.Collections.Hashtable ReadMethods {");
+ WriteLineInd ("public override System.Collections.Hashtable ReadMethods {");
WriteLineInd ("get {");
- WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
+ WriteLineInd ("lock (this) {");
WriteLineInd ("if (readMethods == null) {");
WriteLine ("readMethods = new System.Collections.Hashtable ();");
foreach (GenerationResult res in generatedMaps)
WriteLineUni ("}");
WriteLine ("");
- WriteLineInd ("public System.Collections.Hashtable WriteMethods {");
+ WriteLineInd ("public override System.Collections.Hashtable WriteMethods {");
WriteLineInd ("get {");
- WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
+ WriteLineInd ("lock (this) {");
WriteLineInd ("if (writeMethods == null) {");
WriteLine ("writeMethods = new System.Collections.Hashtable ();");
foreach (GenerationResult res in generatedMaps)
WriteLineUni ("}");
WriteLine ("");
- WriteLineInd ("public System.Collections.Hashtable TypedSerializers {");
+ WriteLineInd ("public override System.Collections.Hashtable TypedSerializers {");
WriteLineInd ("get {");
- WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
+ WriteLineInd ("lock (this) {");
WriteLineInd ("if (typedSerializers == null) {");
WriteLine ("typedSerializers = new System.Collections.Hashtable ();");
foreach (GenerationResult res in generatedMaps)
WriteLineUni ("}");
WriteLineUni ("}");
WriteLineUni ("}");
+ WriteLine ("");
+
+ WriteLine ("public override XmlSerializer GetSerializer (Type type)");
+ WriteLineInd ("{");
+ WriteLine ("switch (type.FullName) {");
+ foreach (GenerationResult res in generatedMaps) {
+ if (res.Mapping is XmlTypeMapping) {
+ WriteLineInd ("case \"" + ((XmlTypeMapping) res.Mapping).TypeData.CSharpFullName + "\":");
+ WriteLine ("return (XmlSerializer) TypedSerializers [\"" + res.Mapping.GetKey () + "\"];");
+ WriteLineUni ("");
+ }
+ }
+ WriteLine ("}");
+ WriteLine ("return base.GetSerializer (type);");
+ WriteLineUni ("}");
+ WriteLine ("");
- WriteLineInd ("public bool CanSerialize (System.Type type) {");
+ WriteLineInd ("public override bool CanSerialize (System.Type type) {");
foreach (GenerationResult res in generatedMaps) {
if (res.Mapping is XmlTypeMapping)
- WriteLine ("if (type == typeof(" + (res.Mapping as XmlTypeMapping).TypeData.FullTypeName + ")) return true;");
+ WriteLine ("if (type == typeof(" + (res.Mapping as XmlTypeMapping).TypeData.CSharpFullName + ")) return true;");
}
WriteLine ("return false;");
WriteLineUni ("}");
{
EnumMap emap = (EnumMap) map.ObjectMap;
- WriteLine ("string " + GetGetEnumValueName (map) + " (" + map.TypeFullName + " val)");
- WriteLineInd ("{");
+ string xmlNamesArray = null;
+ string valuesArray = null;
+
+ if (emap.IsFlags) {
+ // create static string[] holding XML names of enum constants
+ xmlNamesArray = GetUniqueName ("gxe", map, "_xmlNames" + map.XmlType);
+ Write ("static readonly string[] " + xmlNamesArray + " = { ");
+ for (int i = 0; i < emap.XmlNames.Length; i++) {
+ if (i > 0)
+ _writer.Write (',');
+ _writer.Write ('"');
+ _writer.Write (emap.XmlNames[i]);
+ _writer.Write ('\"');
+ }
+ _writer.WriteLine (" };");
+
+ // create const long[] holding values of enum constants
+ valuesArray = GetUniqueName ("gve", map, "_values" + map.XmlType);
+ Write ("static readonly long[] " + valuesArray + " = { ");
+ for (int i = 0; i < emap.Values.Length; i++) {
+ if (i > 0)
+ _writer.Write (',');
+ _writer.Write (emap.Values[i].ToString (CultureInfo.InvariantCulture));
+ _writer.Write ("L");
+ }
+ _writer.WriteLine (" };");
+ WriteLine (string.Empty);
+ }
- WriteLine ("switch (val)");
+ WriteLine ("string " + GetGetEnumValueName (map) + " (" + map.TypeData.CSharpFullName + " val)");
WriteLineInd ("{");
- foreach (EnumMap.EnumMapMember mem in emap.Members)
- WriteLine ("case " + map.TypeFullName + "." + mem.EnumName + ": return " + GetLiteral (mem.XmlName) + ";");
- if (emap.IsFlags)
- {
- WriteLineInd ("default:");
- WriteLine ("System.Text.StringBuilder sb = new System.Text.StringBuilder ();");
- WriteLine ("string[] enumNames = val.ToString().Split (',');");
- WriteLine ("foreach (string name in enumNames)");
- WriteLineInd ("{");
- WriteLine ("switch (name.Trim())");
- WriteLineInd ("{");
-
- foreach (EnumMap.EnumMapMember mem in emap.Members)
- WriteLine ("case " + GetLiteral(mem.EnumName) + ": sb.Append (" + GetLiteral(mem.XmlName) + ").Append (' '); break; ");
- WriteLine ("default: sb.Append (name.Trim()).Append (' '); break; ");
- WriteLineUni ("}");
- WriteLineUni ("}");
- WriteLine ("return sb.ToString ().Trim();");
- Unindent ();
- }
- else
+ WriteLineInd ("switch (val) {");
+ for (int i = 0; i < emap.EnumNames.Length; i++)
+ WriteLine ("case " + map.TypeData.CSharpFullName + "." + emap.EnumNames[i] + ": return " + GetLiteral (emap.XmlNames[i]) + ";");
+
+ if (emap.IsFlags) {
+ WriteLineInd ("default:");
+ // FromEnum actually covers this case too, but we save some cycles here
+ WriteLine ("if (val.ToString () == \"0\") return string.Empty;");
+ Write ("return FromEnum ((long) val, " + xmlNamesArray + ", " + valuesArray);
+#if NET_2_0
+ _writer.Write (", typeof (");
+ _writer.Write (map.TypeData.CSharpFullName);
+ _writer.Write (").FullName");
+#endif
+ _writer.Write (')'); // close FromEnum method call
+ WriteUni (";"); // end statement
+ } else {
+#if NET_2_0
+ WriteLine ("default: throw CreateInvalidEnumValueException ((long) val, typeof (" + map.TypeData.CSharpFullName + ").FullName);");
+#else
WriteLine ("default: return ((long)val).ToString(CultureInfo.InvariantCulture);");
+#endif
+ }
WriteLineUni ("}");
void GenerateWriteObject (XmlTypeMapping typeMap)
{
- WriteLine ("void " + GetWriteObjectName (typeMap) + " (" + typeMap.TypeFullName + " ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)");
+ WriteLine ("void " + GetWriteObjectName (typeMap) + " (" + typeMap.TypeData.CSharpFullName + " ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)");
WriteLineInd ("{");
PushHookContext ();
- SetHookVar ("$TYPE", typeMap.TypeName);
- SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
+ SetHookVar ("$TYPE", typeMap.TypeData.CSharpName);
+ SetHookVar ("$FULLTYPE", typeMap.TypeData.CSharpFullName);
SetHookVar ("$OBJECT", "ob");
SetHookVar ("$ELEMENT", "element");
SetHookVar ("$NAMESPACE", "namesp");
ArrayList types = typeMap.DerivedTypes;
WriteLine ("System.Type type = ob.GetType ();");
- WriteLine ("if (type == typeof(" + typeMap.TypeFullName + "))");
- WriteLine ("\t;");
+ WriteLine ("if (type == typeof(" + typeMap.TypeData.CSharpFullName + "))");
+ WriteLine ("{ }");
for (int n=0; n<types.Count; n++)
{
XmlTypeMapping map = (XmlTypeMapping)types[n];
- WriteLineInd ("else if (type == typeof(" + map.TypeFullName + ")) { ");
- WriteLine (GetWriteObjectName (map) + "((" + map.TypeFullName + ")ob, element, namesp, isNullable, true, writeWrappingElem);");
+ WriteLineInd ("else if (type == typeof(" + map.TypeData.CSharpFullName + ")) { ");
+ WriteLine (GetWriteObjectName (map) + "((" + map.TypeData.CSharpFullName + ")ob, element, namesp, isNullable, true, writeWrappingElem);");
WriteLine ("return;");
WriteLineUni ("}");
}
else if (memType == typeof(XmlTypeMapMemberFlatList))
{
WriteLineInd ("if (" + memberValue + " != null) {");
- GenerateWriteListContent (member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
+ GenerateWriteListContent (ob, member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
WriteLineUni ("}");
}
else if (memType == typeof(XmlTypeMapMemberAnyElement))
bool first = true;
foreach (XmlTypeMapElementInfo elem in member.ElementInfo)
{
- WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.FullTypeName + ") {");
+ WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.CSharpFullName + ") {");
GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
WriteLineUni ("}");
first = false;
}
else {
WriteMetCall ("WriteStartElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue);
- GenerateWriteListContent (elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
+ GenerateWriteListContent (null, elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
WriteMetCall ("WriteEndElement", memberValue);
}
WriteLineUni ("}");
WriteMetCall ("WriteAttribute", GetLiteral("arrayType"), GetLiteral(XmlSerializer.EncodingNamespace), arrayType);
}
- GenerateWriteListContent (typeMap.TypeData, (ListMap) typeMap.ObjectMap, ob, false);
+ GenerateWriteListContent (null, typeMap.TypeData, (ListMap) typeMap.ObjectMap, ob, false);
}
void GenerateWriteAnyElementContent (XmlTypeMapMemberAnyElement member, string memberValue)
}
string elem = GetObTempVar ();
- WriteLine ("XmlElement " + elem + " = " + var + " as XmlElement;");
- WriteLine ("if (" + elem + " == null) throw CreateUnknownTypeException (" + elem + ");");
+ WriteLine ("XmlNode " + elem + " = " + var + ";");
+ WriteLine ("if (" + elem + " is XmlElement) {");
if (!member.IsDefaultAny) {
for (int n=0; n<member.ElementInfo.Count; n++) {
else WriteLine ("|| " + txt);
}
}
-
+ WriteLine ("}");
+ WriteLine ("else " + elem + ".WriteTo (Writer);");
+
if (_format == SerializationFormat.Literal)
WriteLine ("WriteElementLiteral (" + elem + ", \"\", \"\", false, true);");
else
string str = GetStrTempVar ();
WriteLine ("string " + str + " = null;");
WriteLineInd ("if (" + value + " != null) {");
- string res = GenerateWriteListContent (typeMap.TypeData, (ListMap)typeMap.ObjectMap, value, true);
+ string res = GenerateWriteListContent (null, typeMap.TypeData, (ListMap)typeMap.ObjectMap, value, true);
WriteLine (str + " = " + res + ".ToString ().Trim ();");
WriteLineUni ("}");
return str;
}
}
- string GenerateWriteListContent (TypeData listType, ListMap map, string ob, bool writeToString)
+ string GenerateWriteListContent (string container, TypeData listType, ListMap map, string ob, bool writeToString)
{
string targetString = null;
{
string itemVar = GetNumTempVar ();
WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Length; "+itemVar+"++) {");
- GenerateListLoop (map, ob + "["+itemVar+"]", listType.ListItemTypeData, targetString);
+ GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
WriteLineUni ("}");
}
else if (typeof(ICollection).IsAssignableFrom (listType.Type))
{
string itemVar = GetNumTempVar ();
WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Count; "+itemVar+"++) {");
- GenerateListLoop (map, ob + "["+itemVar+"]", listType.ListItemTypeData, targetString);
+ GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
WriteLineUni ("}");
}
else if (typeof(IEnumerable).IsAssignableFrom (listType.Type))
{
string itemVar = GetObTempVar ();
- WriteLineInd ("foreach (" + listType.ListItemTypeData.FullTypeName + " " + itemVar + " in " + ob + ") {");
- GenerateListLoop (map, itemVar, listType.ListItemTypeData, targetString);
+ WriteLineInd ("foreach (" + listType.ListItemTypeData.CSharpFullName + " " + itemVar + " in " + ob + ") {");
+ GenerateListLoop (container, map, itemVar, null, listType.ListItemTypeData, targetString);
WriteLineUni ("}");
}
else
return targetString;
}
- void GenerateListLoop (ListMap map, string item, TypeData itemTypeData, string targetString)
+ void GenerateListLoop (string container, ListMap map, string item, string index, TypeData itemTypeData, string targetString)
{
bool multichoice = (map.ItemInfo.Count > 1);
+ if (map.ChoiceMember != null && container != null && index != null) {
+ WriteLineInd ("if ((" + container + ".@" + map.ChoiceMember + " == null) || (" + index + " >= " + container + ".@" + map.ChoiceMember + ".Length))");
+ WriteLine ("throw CreateInvalidChoiceIdentifierValueException (" + container + ".GetType().ToString(), \"" + map.ChoiceMember + "\");");
+ Unindent ();
+ }
+
if (multichoice)
WriteLine ("if (((object)" + item + ") == null) { }");
-
+
foreach (XmlTypeMapElementInfo info in map.ItemInfo)
{
- if (multichoice)
- WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.FullTypeName + ")) {");
-
+ if (map.ChoiceMember != null && multichoice)
+ WriteLineInd ("else if (" + container + ".@" + map.ChoiceMember + "[" + index + "] == " + GetLiteral (info.ChoiceValue) + ") {");
+ else if (multichoice)
+ WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.CSharpFullName + ")) {");
+
if (targetString == null)
GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item));
else
string GenerateGetMemberValue (XmlTypeMapMember member, string ob, bool isValueList)
{
- if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.Index + "]");
+ if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.GlobalIndex + "]");
else return ob + ".@" + member.Name;
}
string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
{
if (isValueList) {
- return ob + ".Length > " + member.Index;
+ return ob + ".Length > " + member.GlobalIndex;
}
else if (member.DefaultValue != System.DBNull.Value) {
string mem = ob + ".@" + member.Name;
if (_format == SerializationFormat.Literal)
{
- if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
- throw new Exception ("Not supported for XmlNode types");
-
- WriteLineInd ("if (Reader.LocalName != " + GetLiteral (typeMap.ElementName) + " || Reader.NamespaceURI != " + GetLiteral (typeMap.Namespace) + ")");
- WriteLine ("throw CreateUnknownNodeException();");
- Unindent ();
+ if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode) {
+ if (typeMap.TypeData.Type == typeof (XmlDocument))
+ WriteLine ("return ReadXmlDocument (false);");
+ else
+ WriteLine ("return ReadXmlNode (false);");
+ } else {
+ WriteLineInd ("if (Reader.LocalName != " + GetLiteral (typeMap.ElementName) + " || Reader.NamespaceURI != " + GetLiteral (typeMap.Namespace) + ")");
+ WriteLine ("throw CreateUnknownNodeException();");
+ Unindent ();
- WriteLine ("return " + GetReadObjectCall (typeMap, "true", "true") + ";");
+ WriteLine ("return " + GetReadObjectCall (typeMap, GetLiteral(typeMap.IsNullable), "true") + ";");
+ }
}
else
{
{
string isNullable;
if (_format == SerializationFormat.Literal) {
- WriteLine ("public " + typeMap.TypeFullName + " " + GetReadObjectName (typeMap) + " (bool isNullable, bool checkType)");
+ WriteLine ("public " + typeMap.TypeData.CSharpFullName + " " + GetReadObjectName (typeMap) + " (bool isNullable, bool checkType)");
isNullable = "isNullable";
}
else {
PushHookContext ();
- SetHookVar ("$TYPE", typeMap.TypeName);
- SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
+ SetHookVar ("$TYPE", typeMap.TypeData.CSharpName);
+ SetHookVar ("$FULLTYPE", typeMap.TypeData.CSharpFullName);
SetHookVar ("$NULLABLE", "isNullable");
switch (typeMap.TypeData.SchemaType)
{
case SchemaTypes.Class: GenerateReadClassInstance (typeMap, isNullable, "checkType"); break;
case SchemaTypes.Array:
- WriteLine ("return " + GenerateReadListElement (typeMap, null, isNullable, true) + ";");
+ string list = GenerateReadListElement (typeMap, null, isNullable, true);
+ if (list != null)
+ WriteLine ("return " + list + ";");
break;
case SchemaTypes.XmlNode: GenerateReadXmlNodeElement (typeMap, isNullable); break;
case SchemaTypes.Primitive: GenerateReadPrimitiveElement (typeMap, isNullable); break;
SetHookVar ("$OBJECT", "ob");
if (!typeMap.TypeData.IsValueType)
{
- WriteLine (typeMap.TypeFullName + " ob = null;");
+ WriteLine (typeMap.TypeData.CSharpFullName + " ob = null;");
if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
WriteLine ("return ob;");
}
else
{
- WriteLine (typeMap.TypeFullName + " ob = new " + typeMap.TypeFullName + " ();");
+ WriteLine (typeMap.TypeData.CSharpFullName + " ob = new " + typeMap.TypeData.CSharpFullName + " ();");
if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
WriteLine ("return ob;");
WriteLine ("System.Xml.XmlQualifiedName t = GetXsiType();");
WriteLine ("if (t == null)");
if (typeMap.TypeData.Type != typeof(object))
- WriteLine ("\t;");
+ WriteLine ("{ }");
else
WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (new System.Xml.XmlQualifiedName(\"anyType\", System.Xml.Schema.XmlSchema.Namespace))") + ";");
}
WriteLine ("");
- WriteLine ("ob = new " + typeMap.TypeFullName + " ();");
+ WriteLine ("ob = new " + typeMap.TypeData.CSharpFullName + " ();");
}
WriteLine ("");
if (anyAttrMember != null)
{
WriteLine ("int anyAttributeIndex = 0;");
- WriteLine (anyAttrMember.TypeData.FullTypeName + " anyAttributeArray = null;");
+ WriteLine (anyAttrMember.TypeData.CSharpFullName + " anyAttributeArray = null;");
}
WriteLine ("while (Reader.MoveToNextAttribute())");
if (anyAttrMember != null && !MemberHasReadReplaceHook (xmlMapType, anyAttrMember))
{
WriteLine ("");
- WriteLine("anyAttributeArray = (" + anyAttrMember.TypeData.FullTypeName + ") ShrinkArray (anyAttributeArray, anyAttributeIndex, " + GetTypeOf(anyAttrMember.TypeData.Type.GetElementType()) + ", true);");
+ WriteLine("anyAttributeArray = (" + anyAttrMember.TypeData.CSharpFullName + ") ShrinkArray (anyAttributeArray, anyAttributeIndex, " + GetTypeOf(anyAttrMember.TypeData.Type.GetElementType()) + ", true);");
GenerateSetMemberValue (anyAttrMember, ob, "anyAttributeArray", isValueList);
}
WriteLine ("");
string[] indexes = null;
string[] flatLists = null;
+ string[] flatListsChoices = null;
if (map.FlatLists != null)
{
string code = "int ";
for (int n=0; n<map.FlatLists.Count; n++)
{
- XmlTypeMapMember mem = (XmlTypeMapMember)map.FlatLists[n];
+ XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement)map.FlatLists[n];
indexes[n] = GetNumTempVar ();
if (n > 0) code += ", ";
code += indexes[n] + "=0";
if (!MemberHasReadReplaceHook (xmlMapType, mem)) {
flatLists[n] = GetObTempVar ();
string rval;
- if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList))
- rval = ob + ".@" + mem.Name;
- else
+ WriteLine (mem.TypeData.CSharpFullName + " " + flatLists[n] + ";");
+ if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList)) {
+ rval = GenerateGetMemberValue (mem, ob, isValueList);
+ WriteLine (flatLists[n] + " = " + rval + ";");
+ } else if (mem.TypeData.Type.IsArray) {
rval = GenerateInitializeList (mem.TypeData);
- WriteLine (mem.TypeData.FullTypeName + " " + flatLists[n] + " = " + rval + ";");
+ WriteLine (flatLists[n] + " = " + rval + ";");
+ } else {
+ WriteLine (flatLists[n] + " = " + GenerateGetMemberValue (mem, ob, isValueList) + ";");
+ WriteLineInd ("if (((object)" + flatLists[n] + ") == null) {");
+ WriteLine (flatLists[n] + " = " + GenerateInitializeList (mem.TypeData) + ";");
+ GenerateSetMemberValue (mem, ob, flatLists[n], isValueList);
+ WriteLineUni ("}");
+ }
+ }
+
+ if (mem.ChoiceMember != null) {
+ if (flatListsChoices == null)
+ flatListsChoices = new string [map.FlatLists.Count];
+ flatListsChoices[n] = GetObTempVar ();
+ string rval = GenerateInitializeList (mem.ChoiceTypeData);
+ WriteLine (mem.ChoiceTypeData.CSharpFullName + " " + flatListsChoices[n] + " = " + rval + ";");
}
}
WriteLine (code + ";");
WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // Already read
if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
- WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral(info.TypeData.FullTypeName) + ");");
+ WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral(info.TypeData.CSharpFullName) + ");");
else
GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
WriteLineUni ("}");
else
{
if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
- if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList)) GenerateReadListElement (info.MappedType, GenerateGetMemberValue (info.Member, ob, isValueList), GetLiteral(info.IsNullable), false);
- else GenerateSetMemberValue (info.Member, ob, GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true), isValueList);
+ if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList)) {
+ GenerateReadListElement (info.MappedType, GenerateGetMemberValue (info.Member, ob, isValueList), GetLiteral(info.IsNullable), false);
+ } else if (info.MappedType.TypeData.Type.IsArray) {
+ if (info.IsNullable)
+ GenerateSetMemberValue (info.Member, ob, GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true), isValueList);
+ else {
+ string list = GetObTempVar ();
+ WriteLine (info.MappedType.TypeData.CSharpFullName + " " + list + " = " + GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true) + ";");
+ WriteLineInd ("if (((object)" + list + ") != null) {");
+ GenerateSetMemberValue (info.Member, ob, list, isValueList);
+ WriteLineUni ("}");
+ }
+ } else {
+ string list = GetObTempVar ();
+ WriteLine (info.MappedType.TypeData.CSharpFullName + " " + list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
+ WriteLineInd ("if (((object)" + list + ") == null) {");
+ WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
+ GenerateSetMemberValue (info.Member, ob, list, isValueList);
+ WriteLineUni ("}");
+ GenerateReadListElement (info.MappedType, list, GetLiteral(info.IsNullable), true);
+ }
GenerateEndHook ();
}
}
XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GenerateReadObjectElement (info), !IsReadOnly (typeMap, info.Member, info.TypeData, isValueList));
+ if (mem.ChoiceMember != null) {
+ GenerateAddListValue (mem.ChoiceTypeData, flatListsChoices[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetLiteral (info.ChoiceValue), true);
+ }
GenerateEndHook ();
}
WriteLine (indexes[mem.FlatArrayIndex] + "++;");
if (map.XmlTextCollector != null)
{
- WriteLine ("else if (Reader.NodeType == System.Xml.XmlNodeType.Text)");
+ WriteLine ("else if (Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA)");
WriteLineInd ("{");
if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
string list = flatLists[mem.FlatArrayIndex];
if (mem.TypeData.Type.IsArray)
- WriteLine (list + " = (" + mem.TypeData.FullTypeName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.TypeData.Type.GetElementType()) + ", true);");
- if (!IsReadOnly (typeMap, mem, mem.TypeData, isValueList))
+ WriteLine (list + " = (" + mem.TypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.TypeData.Type.GetElementType()) + ", true);");
+ if (!IsReadOnly (typeMap, mem, mem.TypeData, isValueList) && mem.TypeData.Type.IsArray)
GenerateSetMemberValue (mem, ob, list, isValueList);
}
}
+ if (flatListsChoices != null)
+ {
+ WriteLine ("");
+ foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
+ {
+ if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
+ if (mem.ChoiceMember == null) continue;
+
+ string list = flatListsChoices[mem.FlatArrayIndex];
+ WriteLine (list + " = (" + mem.ChoiceTypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.ChoiceTypeData.Type.GetElementType()) + ", true);");
+ WriteLine (ob + ".@" + mem.ChoiceMember + " = " + list + ";");
+ }
+ }
+
GenerateSetListMembersDefaults (typeMap, map, ob, isValueList);
GenerateEndHook ();
void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList)
{
- if (isValueList) WriteLine (ob + "[" + member.Index + "] = " + value + ";");
+ if (isValueList) WriteLine (ob + "[" + member.GlobalIndex + "] = " + value + ";");
else {
WriteLine (ob + ".@" + member.Name + " = " + value + ";");
if (member.IsOptionalValueType)
return GetReadObjectCall (elem.MappedType, GetLiteral(elem.IsNullable), "true");
case SchemaTypes.XmlSerializable:
- return GetCast (elem.TypeData, "ReadSerializable (new " + elem.TypeData.FullTypeName + " ())");
+ return GetCast (elem.TypeData, "ReadSerializable (new " + elem.TypeData.CSharpFullName + " ())");
default:
throw new NotSupportedException ("Invalid value type");
{
Type listType = typeMap.TypeData.Type;
ListMap listMap = (ListMap)typeMap.ObjectMap;
+ bool doNullCheck = typeMap.TypeData.Type.IsArray;
if (canCreateInstance && typeMap.TypeData.HasPublicConstructor)
{
- list = GetObTempVar ();
- WriteLine (typeMap.TypeFullName + " " + list + " = null;");
- WriteLineInd ("if (!ReadNull()) {");
- WriteLine (list + " = " + GenerateCreateList (listType) + ";");
+ if (list == null) {
+ list = GetObTempVar ();
+ WriteLine (typeMap.TypeData.CSharpFullName + " " + list + " = null;");
+ if (doNullCheck)
+ WriteLineInd ("if (!ReadNull()) {");
+ WriteLine (list + " = " + GenerateCreateList (listType) + ";");
+ } else {
+ if (doNullCheck)
+ WriteLineInd ("if (!ReadNull()) {");
+ }
}
else
{
if (list != null) {
WriteLineInd ("if (((object)" + list + ") == null)");
- WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
+ WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeData.CSharpFullName) + ");");
Unindent ();
- WriteLineInd ("if (!ReadNull()) {");
+ doNullCheck = false;
}
else {
- list = GetObTempVar ();
- WriteLine (typeMap.TypeFullName + " " + list + " = null;");
- WriteLineInd ("if (((object)" + list + ") == null)");
- WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
- Unindent ();
+ WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeData.CSharpFullName) + ");");
return list;
}
}
WriteLineInd ("if (Reader.IsEmptyElement) {");
WriteLine ("Reader.Skip();");
if (listType.IsArray)
- WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", 0, " + GetTypeOf(listType.GetElementType()) + ", " + isNullable + ");");
+ WriteLine (list + " = (" + typeMap.TypeData.CSharpFullName + ") ShrinkArray (" + list + ", 0, " + GetTypeOf(listType.GetElementType()) + ", false);");
Unindent ();
WriteLineInd ("} else {");
WriteLine ("ReadEndElement();");
if (listType.IsArray)
- WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", " + index + ", " + GetTypeOf(listType.GetElementType()) + ", " + isNullable + ");");
+ WriteLine (list + " = (" + typeMap.TypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + index + ", " + GetTypeOf(listType.GetElementType()) + ", false);");
WriteLineUni ("}");
- WriteLineUni ("}");
+ if (doNullCheck)
+ WriteLineUni ("}");
return list;
}
{
Type listType = typeMap.TypeData.Type;
ListMap listMap = (ListMap)typeMap.ObjectMap;
- string itemType = listType.GetElementType().FullName;
+ string itemType = ToCSharpFullName (listType.GetElementType());
string list = GetObTempVar ();
WriteLine (itemType + "[] " + list + ";");
string valueArray = GetObTempVar ();
WriteLine ("string[] " + valueArray + " = " + var + ".Split (' ');");
- WriteLine (list + " = new " + itemType + " [" + valueArray + ".Length];");
-
+ WriteLine (list + " = new " + GetArrayDeclaration (listType, valueArray + ".Length") + ";");
+
XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0];
string index = GetNumTempVar ();
Unindent ();
WriteLineUni ("}");
WriteLine ("else");
- WriteLine ("\t" + list + " = new " + itemType + " [0];");
+ WriteLine ("\t" + list + " = new " + GetArrayDeclaration (listType, "0") + ";");
return list;
}
+
+ string GetArrayDeclaration (Type type, string length)
+ {
+ Type t = type.GetElementType();
+ System.Text.StringBuilder sb = new System.Text.StringBuilder ();
+ sb.Append ('[').Append (length).Append (']');
+ while (t.IsArray) {
+ sb.Append ("[]");
+ t = t.GetElementType();
+ }
+ sb.Insert (0, ToCSharpFullName (t));
+ return sb.ToString ();
+ }
void GenerateAddListValue (TypeData listType, string list, string index, string value, bool canCreateInstance)
{
Type type = listType.Type;
if (type.IsArray)
{
- WriteLine (list + " = (" + type.FullName + ") EnsureArrayIndex (" + list + ", " + index + ", " + GetTypeOf(type.GetElementType()) + ");");
+ WriteLine (list + " = (" + ToCSharpFullName (type) + ") EnsureArrayIndex (" + list + ", " + index + ", " + GetTypeOf(type.GetElementType()) + ");");
WriteLine (list + "[" + index + "] = " + value + ";");
}
else // Must be IEnumerable
{
WriteLine ("if (((object)" + list + ") == null)");
if (canCreateInstance)
- WriteLine ("\t" + list + " = new " + listType.FullTypeName + "();");
+ WriteLine ("\t" + list + " = new " + listType.CSharpFullName + "();");
else
- WriteLine ("\tthrow CreateReadOnlyCollectionException (" + GetLiteral (listType.FullTypeName) + ");");
+ WriteLine ("\tthrow CreateReadOnlyCollectionException (" + GetLiteral (listType.CSharpFullName) + ");");
WriteLine (list + ".Add (" + value + ");");
}
string GenerateCreateList (Type listType)
{
if (listType.IsArray)
- return "(" + listType.FullName + ") EnsureArrayIndex (null, 0, " + GetTypeOf(listType.GetElementType()) + ")";
+ return "(" + ToCSharpFullName (listType) + ") EnsureArrayIndex (null, 0, " + GetTypeOf(listType.GetElementType()) + ")";
else
- return "new " + listType.FullName + "()";
+ return "new " + ToCSharpFullName (listType) + "()";
}
string GenerateInitializeList (TypeData listType)
if (listType.Type.IsArray)
return "null";
else
- return "new " + listType.Type.FullName + "()";
+ return "new " + listType.CSharpFullName + "()";
}
void GenerateFillerCallbacks ()
string metName = GetFillListName (td);
WriteLine ("void " + metName + " (object list, object source)");
WriteLineInd ("{");
- WriteLine ("if (((object)list) == null) throw CreateReadOnlyCollectionException (" + GetLiteral (td.FullTypeName) + ");");
+ WriteLine ("if (((object)list) == null) throw CreateReadOnlyCollectionException (" + GetLiteral (td.CSharpFullName) + ");");
WriteLine ("");
- WriteLine (td.FullTypeName + " dest = (" + td.FullTypeName + ") list;");
+ WriteLine (td.CSharpFullName + " dest = (" + td.CSharpFullName + ") list;");
WriteLine ("foreach (object ob in (IEnumerable)source)");
WriteLine ("\tdest.Add (" + GetCast (td.ListItemTypeData, "ob") + ");");
WriteLineUni ("}");
void GenerateReadEnumElement (XmlTypeMapping typeMap, string isNullable)
{
WriteLine ("Reader.ReadStartElement ();");
- WriteLine (typeMap.TypeFullName + " res = " + GenerateGetEnumValue (typeMap, "Reader.ReadString()") + ";");
- WriteLine ("Reader.ReadEndElement ();");
+ WriteLine (typeMap.TypeData.CSharpFullName + " res = " + GenerateGetEnumValue (typeMap, "Reader.ReadString()") + ";");
+ WriteLineInd ("if (Reader.NodeType != XmlNodeType.None)");
+ WriteLineUni ("Reader.ReadEndElement ();");
WriteLine ("return res;");
}
if (map.IsFlags)
{
string switchMethod = metName + "_Switch";
- WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
+ WriteLine (typeMap.TypeData.CSharpFullName + " " + metName + " (string xmlName)");
WriteLineInd ("{");
WriteLine ("xmlName = xmlName.Trim();");
- WriteLine ("if (xmlName.Length == 0) return (" + typeMap.TypeFullName + ")0;");
- WriteLine ("if (xmlName.IndexOf (' ') != -1)");
- WriteLineInd ("{");
- WriteLine (typeMap.TypeFullName + " sb = (" + typeMap.TypeFullName + ")0;");
- WriteLine ("string[] enumNames = xmlName.ToString().Split (' ');");
+ WriteLine ("if (xmlName.Length == 0) return (" + typeMap.TypeData.CSharpFullName + ")0;");
+ WriteLine (typeMap.TypeData.CSharpFullName + " sb = (" + typeMap.TypeData.CSharpFullName + ")0;");
+ WriteLine ("string[] enumNames = xmlName.Split (null);");
WriteLine ("foreach (string name in enumNames)");
WriteLineInd ("{");
WriteLine ("if (name == string.Empty) continue;");
WriteLineUni ("}");
WriteLine ("return sb;");
WriteLineUni ("}");
- WriteLine ("else");
- WriteLine ("\treturn " + switchMethod + " (xmlName);");
- WriteLineUni ("}");
+ WriteLine ("");
metName = switchMethod;
}
- WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
+ WriteLine (typeMap.TypeData.CSharpFullName + " " + metName + " (string xmlName)");
WriteLineInd ("{");
GenerateGetSingleEnumValue (typeMap, "xmlName");
WriteLineUni ("}");
WriteLineInd ("{");
foreach (EnumMap.EnumMapMember mem in map.Members)
{
- WriteLine ("case " + GetLiteral (mem.XmlName) + ": return " + typeMap.TypeFullName + "." + mem.EnumName + ";");
+ WriteLine ("case " + GetLiteral (mem.XmlName) + ": return " + typeMap.TypeData.CSharpFullName + "." + mem.EnumName + ";");
}
WriteLineInd ("default:");
- WriteLineInd ("try {");
- WriteLine ("return (" + typeMap.TypeFullName + ") Int64.Parse (" + val + ", CultureInfo.InvariantCulture);");
- WriteLineUni ("}");
- WriteLineInd ("catch {");
- WriteLine ("throw CreateUnknownConstantException (" + val + ", typeof(" + typeMap.TypeFullName + "));");
- WriteLineUni ("}");
+ WriteLine ("throw CreateUnknownConstantException (" + val + ", typeof(" + typeMap.TypeData.CSharpFullName + "));");
Unindent ();
WriteLineUni ("}");
}
WriteLine ("if (Reader.NodeType == XmlNodeType.Element)");
WriteLineInd ("{");
WriteLine ("if (Reader.LocalName == " + GetLiteral (typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
- WriteLine ("\treturn ReadSerializable (new " + typeMap.TypeData.FullTypeName + "());");
+ WriteLine ("\treturn ReadSerializable (new " + typeMap.TypeData.CSharpFullName + "());");
WriteLine ("else");
WriteLine ("\tthrow CreateUnknownNodeException ();");
WriteLineUni ("}");
foreach (XmlMapping map in _fixupCallbacks)
{
bool isList = map is XmlMembersMapping;
- string tname = !isList ? ((XmlTypeMapping)map).TypeFullName : "object[]";
+ string tname = !isList ? ((XmlTypeMapping)map).TypeData.CSharpFullName : "object[]";
WriteLine ("void " + GetFixupCallbackName (map) + " (object obfixup)");
WriteLineInd ("{");
WriteLine ("Fixup fixup = (Fixup)obfixup;");
string GetRootTypeName ()
{
- if (_typeMap is XmlTypeMapping) return ((XmlTypeMapping)_typeMap).TypeFullName;
+ if (_typeMap is XmlTypeMapping) return ((XmlTypeMapping)_typeMap).TypeData.CSharpFullName;
else return "object[]";
}
string GetFillListName (TypeData td)
{
if (!_listsToFill.Contains (td)) _listsToFill.Add (td);
- return GetUniqueName ("fl", td, "Fill_" + td.TypeName);
+ return GetUniqueName ("fl", td, "Fill_" + CodeIdentifier.MakeValid (td.CSharpName));
}
string GetCast (TypeData td, TypeData tdval, string val)
{
- if (td.FullTypeName == tdval.FullTypeName) return val;
+ if (td.CSharpFullName == tdval.CSharpFullName) return val;
else return GetCast (td, val);
}
string GetCast (TypeData td, string val)
{
- return "((" + td.FullTypeName + ") " + val + ")";
+ return "((" + td.CSharpFullName + ") " + val + ")";
}
string GetCast (Type td, string val)
{
- return "((" + td.FullName + ") " + val + ")";
+ return "((" + ToCSharpFullName (td) + ") " + val + ")";
}
string GetTypeOf (TypeData td)
{
- return "typeof(" + td.FullTypeName + ")";
+ return "typeof(" + td.CSharpFullName + ")";
}
string GetTypeOf (Type td)
{
- return "typeof(" + td.FullName.Replace ('+','.') + ")";
+ return "typeof(" + ToCSharpFullName (td) + ")";
}
string GetLiteral (object ob)
XmlQualifiedName qn = (XmlQualifiedName)ob;
return "new XmlQualifiedName (" + GetLiteral(qn.Name) + "," + GetLiteral(qn.Namespace) + ")";
}
- if (ob is Enum) return ob.GetType () + "." + ob;
+ if (ob is Enum) {
+ string typeName = ToCSharpFullName (ob.GetType ());
+ StringBuilder sb = new StringBuilder ();
+ string namedValue = Enum.Format (ob.GetType (), ob, "g");
+ string[] names = namedValue.Split (',');
+ foreach (string name in names) {
+ // individual named constants can be seperated by a comma
+ // combined with some additional whitespace characters
+ string cleanName = name.Trim ();
+ if (cleanName.Length == 0)
+ continue;
+
+ if (sb.Length > 0)
+ sb.Append (" | ");
+
+ sb.Append (typeName);
+ sb.Append ('.');
+ sb.Append (cleanName);
+ }
+ return sb.ToString ();
+ }
+
return (ob is IFormattable) ? ((IFormattable) ob).ToString (null, CultureInfo.InvariantCulture) : ob.ToString ();
}
if (_indent > 0) _indent--;
WriteLine (code);
}
-
+
+ void Write (string code)
+ {
+ if (code.Length > 0)
+ _writer.Write (new String ('\t', _indent));
+ _writer.Write (code);
+ }
+
+ void WriteUni (string code)
+ {
+ if (_indent > 0) _indent--;
+ _writer.Write (code);
+ _writer.WriteLine (string.Empty);
+ }
+
void WriteLine (string code)
{
- if (code != "") _writer.Write (new String ('\t',_indent));
+ if (code.Length > 0)
+ _writer.Write (new String ('\t',_indent));
_writer.WriteLine (code);
}
public string WriteMethodName;
public string Namespace;
public string SerializerClassName;
+ public string BaseSerializerClassName;
+ public string ImplementationClassName;
}
}