/** * This <code>read</code> method will read the XML element list from * the provided node and deserialize its children as entry types. * This ensures each entry type is deserialized as a root type, that * is, its <code>Root</code> annotation must be present and the * name of the entry element must match that root element name. * * @param node this is the XML element that is to be deserialized * @param list this is the array that is to be deserialized * * @return this returns the item to attach to the object contact */ public Object read(InputNode node, Object list) throws Exception{ int length = Array.getLength(list); for(int pos = 0; true; pos++) { Position line = node.getPosition(); InputNode next = node.getNext(); if(next == null) { return list; } if(pos >= length){ throw new ElementException("Array length missing or incorrect for %s at %s", type, line); } read(next, list, pos); } }
/** * This <code>readAttribute</code> method is used for deserialization * of the provided node object using a delegate converter. This is * typically another <code>Composite</code> converter, or if the * node is an attribute a <code>Primitive</code> converter. When * the delegate converter has completed the deserialized value is * assigned to the contact. * * @param node this is the node that contains the contact value * @param source the type of the object that is being deserialized * @param section this is the section to read the attribute from * @param map this is the map that contains the label objects */ private void readAttribute(InputNode node, Object source, Section section, LabelMap map) throws Exception { String name = node.getName(); String path = section.getAttribute(name); Label label = map.getLabel(path); if(label == null) { Position line = node.getPosition(); Class expect = context.getType(type, source); if(map.isStrict(context) && revision.isEqual()) { throw new AttributeException("Attribute '%s' does not have a match in %s at %s", path, expect, line); } } else { readInstance(node, source, label); } }
/** * This <code>readElement</code> method is used for deserialization * of the provided node object using a delegate converter. This is * typically another <code>Composite</code> converter, or if the * node is an attribute a <code>Primitive</code> converter. When * the delegate converter has completed the deserialized value is * assigned to the contact. * * @param node this is the node that contains the contact value * @param source the type of the object that is being deserialized * @param section this is the section to read the element from * @param map this is the map that contains the label objects */ private void readElement(InputNode node, Object source, Section section, LabelMap map) throws Exception { String name = node.getName(); String path = section.getPath(name); Label label = map.getLabel(path); if(label == null) { label = criteria.resolve(path); } if(label == null) { Position line = node.getPosition(); Class expect = context.getType(type, source); if(map.isStrict(context) && revision.isEqual()) { throw new ElementException("Element '%s' does not have a match in %s at %s", path, expect, line); } else { node.skip(); } } else { readUnion(node, source, map, label); } }
/** * This <code>read</code> method is used to perform deserialization * of the provided node object using a delegate converter. This is * typically another <code>Composite</code> converter, or if the * node is an attribute a <code>Primitive</code> converter. When * the delegate converter has completed the deserialized value is * assigned to the contact. * * @param node this is the node that contains the contact value * @param source the type of the object that is being deserialized * @param label this is the label used to create the converter */ private Object readInstance(InputNode node, Object source, Label label) throws Exception { Object object = readVariable(node, source, label); if(object == null) { Position line = node.getPosition(); Class expect = context.getType(type, source); if(label.isRequired() && revision.isEqual()) { throw new ValueRequiredException("Empty value for %s in %s at %s", label, expect, line); } } else { if(object != label.getEmpty(context)) { criteria.set(label, object); } } return object; }
/** * This method checks to see if there are any <code>Label</code> * objects remaining in the provided map that are required. This is * used when deserialization is performed to ensure the the XML * element deserialized contains sufficient details to satisfy the * XML schema class annotations. If there is a required label that * remains it is reported within the exception thrown. * * @param node this is the node that contains the contact value * @param map this is the map to check for remaining labels * @param source this is the object that has been deserialized */ private void validate(InputNode node, LabelMap map, Object source) throws Exception { Class expect = context.getType(type, source); Position line = node.getPosition(); for(Label label : map) { if(label.isRequired() && revision.isEqual()) { throw new ValueRequiredException("Unable to satisfy %s for %s at %s", label, expect, line); } Object value = label.getEmpty(context); if(value != null) { criteria.set(label, value); } } }
/** * This <code>validateAttribute</code> method performs a validation * of the provided node object using a delegate converter. This is * typically another <code>Composite</code> converter, or if the * node is an attribute a <code>Primitive</code> converter. If this * fails validation then an exception is thrown to report the issue. * * @param node this is the node that contains the contact value * @param section this is the section to validate this attribute in * @param map this is the map that contains the label objects */ private void validateAttribute(InputNode node, Section section, LabelMap map) throws Exception { Position line = node.getPosition(); String name = node.getName(); String path = section.getAttribute(name); Label label = map.getLabel(path); if(label == null) { Class expect = type.getType(); if(map.isStrict(context) && revision.isEqual()) { throw new AttributeException("Attribute '%s' does not exist for %s at %s", path, expect, line); } } else { validate(node, label); } }
/** * This <code>validateElement</code> method performs a validation * of the provided node object using a delegate converter. This is * typically another <code>Composite</code> converter, or if the * node is an attribute a <code>Primitive</code> converter. If this * fails validation then an exception is thrown to report the issue. * * @param node this is the node that contains the contact value * @param section this is the section to validate this element in * @param map this is the map that contains the label objects */ private void validateElement(InputNode node, Section section, LabelMap map) throws Exception { String name = node.getName(); String path = section.getPath(name); Label label = map.getLabel(path); if(label == null) { label = criteria.resolve(path); } if(label == null) { Position line = node.getPosition(); Class expect = type.getType(); if(map.isStrict(context) && revision.isEqual()) { throw new ElementException("Element '%s' does not exist for %s at %s", path, expect, line); } else { node.skip(); } } else { validateUnion(node, map, label); } }
/** * This <code>read</code> method will read the XML element list from * the provided node and deserialize its children as entry types. * This will deserialize each entry type as a primitive value. In * order to do this the parent string provided forms the element. * * @param node this is the XML element that is to be deserialized * @param list this is the array to read the array values in to * * @return this returns the item to attach to the object contact */ public Object read(InputNode node, Object list) throws Exception{ int length = Array.getLength(list); for(int pos = 0; true; pos++) { Position line = node.getPosition(); InputNode next = node.getNext(); if(next == null) { return list; } if(pos >= length){ throw new ElementException("Array length missing or incorrect for %s at %s", type, line); } Array.set(list, pos, root.read(next)); } }
/** * This is used to get a possible override from the provided node. * If the node provided is an element then this checks for a * specific class override using the <code>Strategy</code> object. * If the strategy cannot resolve a class then this will return * null. If the resolved <code>Value</code> is not assignable to * the field then this will thrown an exception. * * @param node this is the node used to search for the override * * @return this returns null if no override type can be found * * @throws Exception if the override type is not compatible */ protected Value getOverride(InputNode node) throws Exception { Value value = getConversion(node); if(value != null) { Position line = node.getPosition(); Class proposed = value.getType(); Class expect = getType(); if(!isCompatible(expect, proposed)) { throw new InstantiationException("Incompatible %s for %s at %s", proposed, type, line); } } return value; }
/** * This method is used to read the key value from the node. The * value read from the node is resolved using the template filter. * If the key value can not be found according to the annotation * attributes then null is assumed and returned. * * @param node this is the node to read the key value from * * @return this returns the value deserialized from the node */ public Object read(InputNode node) throws Exception { Position line = node.getPosition(); Class expect = type.getType(); String name = entry.getKey(); if(name == null) { name = context.getName(expect); } if(entry.isAttribute()) { throw new AttributeException("Can not have %s as an attribute for %s at %s", expect, entry, line); } return read(node, name); }
/** * This method is used to read the key value from the node. The * value read from the node is resolved using the template filter. * If the key value can not be found according to the annotation * attributes then null is assumed and the node is valid. * * @param node this is the node to read the key value from * * @return this returns the value deserialized from the node */ public boolean validate(InputNode node) throws Exception { Position line = node.getPosition(); Class expect = type.getType(); String name = entry.getKey(); if(name == null) { name = context.getName(expect); } if(entry.isAttribute()) { throw new ElementException("Can not have %s as an attribute for %s at %s", expect, entry, line); } return validate(node, name); }
/** * This <code>read</code> method will perform a read using the * provided object with the repeater. Reading with this method * ensures that any additional XML elements within the source * will be added to the value. * * @param node this is the node that contains the extra data * * @return this will return the original deserialized object */ public Object read(InputNode node, Object value) throws Exception { Position line = node.getPosition(); String name = node.getName(); if(reader instanceof Repeater) { Repeater repeat = (Repeater) reader; return repeat.read(node, value); } throw new PersistenceException("Element '%s' is already used with %s at %s", name, label, line); }
/** * This <code>read</code> method will perform a read using the * provided object with the repeater. Reading with this method * ensures that any additional XML elements within the source * will be added to the value. * * @param node this is the node that contains the extra data * * @return this will return the original deserialized object */ public boolean validate(InputNode node) throws Exception { Position line = node.getPosition(); String name = node.getName(); if(reader instanceof Repeater) { Repeater repeat = (Repeater) reader; return repeat.validate(node); } throw new PersistenceException("Element '%s' declared twice at %s", name, line); }
/** * The <code>readResolve</code> method is used to determine if there * is a resolution method which can be used to substitute the object * deserialized. The resolve method is used when an object wishes * to provide a substitute within the deserialized object graph. * This acts as an equivalent to the Java Object Serialization * <code>readResolve</code> method for the object deserialization. * * @param node the XML element object provided as a replacement * @param source the type of the object that is being deserialized * @param caller this is used to invoke the callback methods * * @return this returns a replacement for the deserialized object */ private Object readResolve(InputNode node, Object source, Caller caller) throws Exception { if(source != null) { Position line = node.getPosition(); Object value = caller.resolve(source); Class expect = type.getType(); Class real = value.getClass(); if(!expect.isAssignableFrom(real)) { throw new ElementException("Type %s does not match %s at %s", real, expect, line); } return value; } return source; }
/** * This <code>validate</code> method is used to perform validation * of the provided node object using a delegate converter. This is * typically another <code>Composite</code> converter, or if the * node is an attribute a <code>Primitive</code> converter. If this * fails validation then an exception is thrown to report the issue. * * @param node this is the node that contains the contact value * @param label this is the label used to create the converter */ private void validate(InputNode node, Label label) throws Exception { Converter reader = label.getConverter(context); Position line = node.getPosition(); Class expect = type.getType(); boolean 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); }
/** * This method checks to see if there are any <code>Label</code> * objects remaining in the provided map that are required. This is * used when validation is performed to ensure the the XML element * validated contains sufficient details to satisfy the XML schema * class annotations. If there is a required label that remains it * is reported within the exception thrown. * * @param node this is the node that contains the composite data * @param map this contains the converters to perform validation */ private void validate(InputNode node, LabelMap map) throws Exception { Position line = node.getPosition(); for(Label label : map) { Class expect = type.getType(); if(label.isRequired() && revision.isEqual()) { throw new ValueRequiredException("Unable to satisfy %s for %s at %s", label, expect, line); } } }
@Override public Position getPosition() { return null; }
/** * This method is used to read the key value from the node. The * value read from the node is resolved using the template filter. * If the key value can not be found according to the annotation * attributes then null is assumed and returned. * * @param node this is the node to read the key value from * @param value this is the value to deserialize in to * * @return this returns the value deserialized from the node * * @throws Exception if value is not null an exception is thrown */ public Object read(InputNode node, Object value) throws Exception { Position line = node.getPosition(); Class expect = type.getType(); if(value != null) { throw new PersistenceException("Can not read key of %s for %s at %s", expect, entry, line); } return read(node); }
