+2003-08-28 Lluis Sanchez Gual <lluis@ximian.com>
+
+ * XmlReflectionImporter.cs: Fill RelatedMaps property of the generated map.
+ * XmlSchemas.cs: Find method: make sure the returned object belongs to
+ the requested type.
+ * XmlSerializationReader.cs: Removed unneded virtual ReadObject method.
+ Add null checks for eventSource.
+ * XmlSerializationReaderInterpreter.cs: ReadObject is not virtual any more.
+ * XmlSerializationWriter.cs: In Initialize method, initialize the provided
+ namespece declarations. Virtual method WriteObject not needed any more.
+ In WriteStartElement, write the provided namespaces.
+ * XmlSerializationWriterInterpreter.cs: Write object is not virtual any more.
+ Added GetTypeMap method, that returns the map for a given type. Added some
+ virtual methods, so writer behavior can be extended at several places by
+ derived classes.
+ * XmlSerializer.cs: Changed behavior to match what MS.NET does. The virtual
+ methods CreateReader and CreateWriter are not called unless no type or
+ type mapping was provided in the constructor.
+
2003-08-12 Lluis Sanchez Gual <lluis@ximian.com>
* XmlSchemaImporter.cs: ImportTypeMapping doesn't need to check if the
ArrayList includedTypes;
ReflectionHelper helper = new ReflectionHelper();
int arrayChoiceCount = 1;
+ ArrayList relatedMaps = new ArrayList ();
static readonly string errSimple = "Cannot serialize object of type '{0}'. Base " +
"type '{1}' has simpleContent and can be only extended by adding XmlAttribute " +
mapping[n] = new XmlMemberMapping (members[n], mapMem);
}
XmlMembersMapping mps = new XmlMembersMapping (elementName, ns, hasWrapperElement, mapping);
+ mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Literal;
return mps;
}
default: throw new NotSupportedException ("Type " + type.FullName + " not supported for XML stialization");
}
+ map.RelatedMaps = relatedMaps;
map.Format = SerializationFormat.Literal;
return map;
}
if (membersNamespace == null) membersNamespace = "";
XmlTypeMapping map = new XmlTypeMapping (elementName, membersNamespace, typeData, defaultXmlType, defaultNamespace);
+ relatedMaps.Add (map);
return map;
}
if (!schema.IsCompiled) {\r
try {\r
schema.Compile (null);\r
- } catch {\r
+ } catch (Exception ex) {\r
throw new InvalidOperationException ("Error compiling XmlSchema " + \r
name.Namespace);\r
}\r
else if (type == typeof (XmlSchemaNotation))\r
tbl = schema.Notations;\r
\r
- return (tbl != null) ? tbl [name] : null;\r
+ object res = (tbl != null) ? tbl [name] : null;\r
+ if (res != null && res.GetType () != type) return null;\r
+ else return res;\r
}\r
\r
public int IndexOf (XmlSchema schema)\r
\r
#endregion // Methods\r
}\r
-}\r
+}
InitIDs ();
}
- internal virtual object ReadObject ()
- {
- throw new NotImplementedException ();
- }
-
private ArrayList EnsureArrayList (ArrayList list)
{
if (list == null)
line_number = 0;
line_position = 0;
}
-
- eventSource.OnUnknownAttribute (new XmlAttributeEventArgs (attr, line_number, line_position, o));
+
+ if (eventSource != null)
+ eventSource.OnUnknownAttribute (new XmlAttributeEventArgs (attr, line_number, line_position, o));
}
protected void UnknownElement (object o, XmlElement elem)
line_number = 0;
line_position = 0;
}
-
- eventSource.OnUnknownElement (new XmlElementEventArgs (elem, line_number, line_position,o));
+
+ if (eventSource != null)
+ eventSource.OnUnknownElement (new XmlElementEventArgs (elem, line_number, line_position,o));
}
protected void UnknownNode (object o)
line_number = 0;
line_position = 0;
}
-
- eventSource.OnUnknownNode (new XmlNodeEventArgs(line_number, line_position, Reader.LocalName, Reader.Name, Reader.NamespaceURI, Reader.NodeType, o, Reader.Value));
+
+ if (eventSource != null)
+ eventSource.OnUnknownNode (new XmlNodeEventArgs(line_number, line_position, Reader.LocalName, Reader.Name, Reader.NamespaceURI, Reader.NodeType, o, Reader.Value));
+
if (Reader.NodeType == XmlNodeType.Attribute)
{
XmlAttribute att = (XmlAttribute) ReadXmlNode (false);
protected void UnreferencedObject (string id, object o)
{
- eventSource.OnUnreferencedObject (new UnreferencedObjectEventArgs (o,id));
+ if (eventSource != null)
+ eventSource.OnUnreferencedObject (new UnreferencedObjectEventArgs (o,id));
}
#endregion // Methods
}
}
-
{
}
- internal override object ReadObject ()
+ public object ReadObject ()
{
Reader.MoveToContent();
if (_typeMap is XmlTypeMapping)
{
qnameCount = 0;
}
+
+ internal void Initialize (XmlWriter writer, XmlSerializerNamespaces nss)
+ {
+ this.writer = writer;
+ if (nss != null)
+ {
+ namespaces = new ArrayList ();
+ foreach (XmlQualifiedName ns in nss.ToArray())
+ namespaces.Add (ns);
+ }
+ }
#endregion // Constructors
#region Methods
- internal void Initialize (XmlWriter writer)
- {
- this.writer = writer;
- }
-
- internal virtual void WriteObject (object ob)
- {
- throw new NotImplementedException ();
- }
-
protected void AddWriteCallback (Type type, string typeName, string typeNs, XmlSerializationWriteCallback callback)
{
WriteCallbackInfo info = new WriteCallbackInfo ();
WriteAttribute ("xmlns","xsd",xmlNamespace,XmlSchema.Namespace);
if (Writer.LookupPrefix (XmlSchema.InstanceNamespace) == null)
WriteAttribute ("xmlns","xsi",xmlNamespace,XmlSchema.InstanceNamespace);
+
+ if (namespaces != null)
+ {
+ foreach (XmlQualifiedName qn in namespaces)
+ WriteAttribute ("xmlns",qn.Name,xmlNamespace,qn.Namespace);
+ }
}
topLevelElement = false;
}
namespace System.Xml.Serialization
{
- internal class XmlSerializationWriterInterpreter: XmlSerializationWriter
+ public class XmlSerializationWriterInterpreter: XmlSerializationWriter
{
XmlMapping _typeMap;
SerializationFormat _format;
- public XmlSerializationWriterInterpreter(XmlMapping typeMap)
+ public XmlSerializationWriterInterpreter (XmlMapping typeMap)
{
_typeMap = typeMap;
_format = typeMap.Format;
}
}
- internal override void WriteObject (object ob)
+ public void WriteObject (object ob)
{
WriteStartDocument ();
WriteReferencedElements ();
}
+
+ protected XmlTypeMapping GetTypeMap (Type type)
+ {
+ ArrayList maps = _typeMap.RelatedMaps;
+ if (maps != null)
+ {
+ foreach (XmlTypeMapping map in maps)
+ if (map.TypeData.Type == type) return map;
+ }
+ throw new InvalidOperationException ("Type " + type + " not mapped");
+ }
- internal void WriteObject (XmlTypeMapping typeMap, object ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
+ protected virtual void WriteObject (XmlTypeMapping typeMap, object ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
{
if (ob == null)
{
WriteEndElement (ob);
}
- void WriteMessage (XmlMembersMapping membersMap, object[] parameters)
+ protected virtual void WriteMessage (XmlMembersMapping membersMap, object[] parameters)
{
if (membersMap.HasWrapperElement) {
TopLevelElement ();
WriteEndElement();
}
- void WriteObjectElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
+ protected virtual void WriteObjectElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
{
ClassMap map = (ClassMap)typeMap.ObjectMap;
if (map.NamespaceDeclarations != null)
WriteNamespaceDeclarations ((XmlSerializerNamespaces) map.NamespaceDeclarations.GetValue (ob));
- WriteMembers (map, ob, false);
+
+ WriteObjectElementAttributes (typeMap, ob);
+ WriteObjectElementElements (typeMap, ob);
+ }
+
+ protected virtual void WriteObjectElementAttributes (XmlTypeMapping typeMap, object ob)
+ {
+ ClassMap map = (ClassMap)typeMap.ObjectMap;
+ WriteAttributeMembers (map, ob, false);
+ }
+
+ protected virtual void WriteObjectElementElements (XmlTypeMapping typeMap, object ob)
+ {
+ ClassMap map = (ClassMap)typeMap.ObjectMap;
+ WriteElementMembers (map, ob, false);
}
void WriteMembers (ClassMap map, object ob, bool isValueList)
+ {
+ WriteAttributeMembers (map, ob, isValueList);
+ WriteElementMembers (map, ob, isValueList);
+ }
+
+ void WriteAttributeMembers (ClassMap map, object ob, bool isValueList)
{
// Write attributes
WriteAttribute (attr.Prefix, attr.LocalName, attr.NamespaceURI, attr.Value);
}
}
+ }
- // Write elements
-
+ void WriteElementMembers (ClassMap map, object ob, bool isValueList)
+ {
ICollection members = map.ElementMembers;
if (members != null)
{
}
}
- void WriteListElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
+ protected virtual void WriteListElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
{
if (_format == SerializationFormat.Encoded)
{
}
}
- void WritePrimitiveElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
+ protected virtual void WritePrimitiveElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
{
Writer.WriteString (GetStringValue (typeMap, typeMap.TypeData, ob));
}
- void WriteEnumElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
+ protected virtual void WriteEnumElement (XmlTypeMapping typeMap, object ob, string element, string namesp)
{
Writer.WriteString (GetEnumXmlValue (typeMap, ob));
}
XmlReflectionImporter importer = new XmlReflectionImporter (overrides, defaultNamespace);
- if (extraTypes != null) \r
+ if (extraTypes != null)
{
foreach (Type intype in extraTypes)
importer.IncludeType (intype);
protected virtual XmlSerializationReader CreateReader ()
{
- return new XmlSerializationReaderInterpreter (typeMapping);
+ // Must be implemented in derived class
+ throw new NotImplementedException ();
}
protected virtual XmlSerializationWriter CreateWriter ()
{
- return new XmlSerializationWriterInterpreter (typeMapping);
+ // Must be implemented in derived class
+ throw new NotImplementedException ();
}
public object Deserialize (Stream stream)
public object Deserialize (XmlReader xmlReader)
{
- XmlSerializationReader xsReader = CreateReader ();
+ XmlSerializationReader xsReader;
+ if (typeMapping == null)
+ xsReader = CreateReader ();
+ else
+ xsReader = new XmlSerializationReaderInterpreter (typeMapping);
+
xsReader.Initialize (xmlReader, this);
return Deserialize (xsReader);
}
protected virtual object Deserialize (XmlSerializationReader reader)
{
- return reader.ReadObject ();
+ if (typeMapping == null)
+ {
+ XmlSerializationReaderInterpreter rd = reader as XmlSerializationReaderInterpreter;
+ if (rd == null) throw new InvalidOperationException ();
+ return rd.ReadObject ();
+ }
+ else
+ // Must be implemented in derived class
+ throw new NotImplementedException ();
}
public static XmlSerializer [] FromMappings (XmlMapping [] mappings)
protected virtual void Serialize (object o, XmlSerializationWriter writer)
{
- writer.WriteObject (o);
+ if (typeMapping != null)
+ {
+ XmlSerializationWriterInterpreter wr = writer as XmlSerializationWriterInterpreter;
+ if (wr == null) throw new InvalidOperationException ();
+ wr.WriteObject (o);
+ }
+ else
+ // Must be implemented in derived class
+ throw new NotImplementedException ();
}
public void Serialize (Stream stream, object o)
public void Serialize (XmlWriter writer, object o, XmlSerializerNamespaces namespaces)
{
- XmlSerializationWriter xsWriter = CreateWriter ();
- xsWriter.Initialize (writer);
+ XmlSerializationWriter xsWriter;
+
+ if (typeMapping == null)
+ xsWriter = CreateWriter ();
+ else
+ xsWriter = new XmlSerializationWriterInterpreter (typeMapping);
+
+ xsWriter.Initialize (writer, namespaces);
Serialize (o, xsWriter);
writer.Flush ();
}
projects / mono.git / commitdiff