/// <summary>
/// This <c>readObject</c> method is used to perform the
/// deserialization of the XML in to any original value. If there
/// is no original value then this will do a read and instantiate
/// a new value to deserialize in to. Reading in to the original
/// ensures that existing lists or maps can be read in to.
/// </summary>
/// <param name="node">
/// this is the node that contains the contact value
/// </param>
/// <param name="source">
/// the source object to assign the contact value to
/// </param>
/// <param name="label">
/// this is the label used to create the converter
/// </param>
/// <returns>
/// this returns the original value deserialized in to
/// </returns>
public Object ReadObject(InputNode node, Object source, Label label) {
Converter reader = label.getConverter(context);
String name = label.GetName(context);
if(label.isCollection()) {
Variable variable = criteria.Get(name);
Contact contact = label.getContact();
if(variable != null) {
Object value = variable.getValue();
return reader.Read(node, value);
} else {
if(source != null) {
Object value = contact.Get(source);
if(value != null) {
return reader.Read(node, value);
}
}
}
}
return reader.Read(node);
}
/// <summary>
/// This <c>validate</c> method is used to perform validation
/// of the provided node object using a delegate converter. This is
/// typically another <c>Composite</c> converter, or if the
/// node is an attribute a <c>Primitive</c> converter. If this
/// fails validation then an exception is thrown to report the issue.
/// </summary>
/// <param name="node">
/// this is the node that contains the contact value
/// </param>
/// <param name="label">
/// this is the label used to create the converter
/// </param>
public void Validate(InputNode node, Label label) {
Converter reader = label.getConverter(context);
Position line = node.getPosition();
Class expect = type.Type;
bool valid = reader.Validate(node);
if(valid == false) {
throw new PersistenceException("Invalid value for %s in %s at %s", label, expect, line);
}
criteria.Set(label, null);
}
/// <summary>
/// This write method is used to append the provided object as an
/// element to the given XML element object. This will recursively
/// write the contacts from the provided object as elements. This is
/// done using the <c>Converter</c> acquired from the contact
/// label. If the type of the contact value is not of the same
/// type as the XML schema class a "class" attribute is appended.
/// <p>
/// If the element being written is inline, then this will not
/// check to see if there is a "class" attribute specifying the
/// name of the class. This is because inline elements do not have
/// an outer class and thus could never have an override.
/// </summary>
/// <param name="value">
/// this is the value to be set as an element
/// </param>
/// <param name="node">
/// this is the XML element to write the element to
/// </param>
/// <param name="label">
/// the label that contains the contact details
/// </param>
public void WriteElement(OutputNode node, Object value, Label label) {
if(value != null) {
String name = label.GetName(context);
OutputNode next = node.getChild(name);
Type contact = label.getContact();
Class type = contact.Type;
if(!label.isInline()) {
WriteNamespaces(next, type, label);
}
if(label.isInline() || !IsOverridden(next, value, contact)) {
Converter convert = label.getConverter(context);
bool data = label.isData();
next.setData(data);
WriteElement(next, value, convert);
}
}
}
