C# (CSharp) SimpleFramework.Xml.Core Пространство имен

Классы

Имя Описание
A
AnnotationFactory The AnnotationFactory is used to create annotations using a given class. This will classify the provided type as either a list, map, array, or a default object. Depending on the type provided a suitable annotation will be created. Annotations produced by this will have default attribute values.
AnnotationHandler The AnnotationHandler object is used to handle all invocation made on a synthetic annotation. This is required so that annotations can be created without an implementation. The java.lang.reflect.Proxy object is used to wrap this invocation handler with the annotation interface.
AnnotationHandlerTest
AnnotationProviderTest
AnonymousClassTest.Anonymous
ArrayEntryTest
ArrayEntryTest.Entry
ArrayFactory The ArrayFactory is used to create object array types that are compatible with the field type. This simply requires the type of the array in order to instantiate that array. However, this also performs a check on the field type to ensure that the array component types are compatible.
ArrayTest
ArrayTest.ArrayExample
ArrayTest.BadArrayExample
ArrayTest.CharacterArrayExample
ArrayTest.DefaultCompositeArrayExample
ArrayTest.DefaultPrimitiveArrayExample
ArrayTest.DifferentArrayExample
ArrayTest.ExtendedText
ArrayTest.ParentCompositeArrayExample
ArrayTest.PrimitiveArrayExample
ArrayTest.PrimitiveIntegerArrayExample
ArrayTest.PrimitiveMultidimensionalIntegerArrayExample
ArrayTest.Text
AttributeEntry
AttributeException The AttributeException is used to represent conditions when an XML attribute is in an invalid state. Typically this is used when and attribute cannot be serialized or deserialized. Such a condition can arise when an attribute exists within the source XML that does not match the schema class. For serialization this exception is thrown if a required field is null.
AttributeParameter The AttributeParameter represents a constructor parameter. It contains the XML annotation used on the parameter as well as the name of the parameter and its position index. A parameter is used to validate against the annotated methods and fields and also to determine the deserialized values that should be injected in to the constructor to instantiate it.
AttributeParameter.Contact
Builder The Builder object is used to represent an single constructor within an object. It contains the actual constructor as well as the list of parameters. Each builder will score its weight when given a Criteria object. This allows the deserialization process to find the most suitable one to use when instantiating an object.
CallbackTest
CallbackTest.Entry
CallbackTest.ExtendedEntry
CallbackTest.OverrideEntry
CaseTest
CaseTest.CaseExample
CaseTest.TextEntry
CaseTest.URLEntry
ClassCreator The ClassCreator is responsible for instantiating objects using either the default no argument constructor or one that takes deserialized values as parameters. This also exposes the parameters and constructors used to instantiate the object.
ClassInstance The ClassInstance object is used to create an object by using a Class to determine the type. If the given class can not be instantiated then this throws an exception when the instance is requested. For performance an instantiator is given as it contains a reflection cache for constructors.
ClassScanner The ClassScanner performs the reflective inspection of a class and extracts all the class level annotations. This will also extract the methods that are annotated. This ensures that the callback methods can be invoked during the deserialization process. Also, this will read the namespace annotations that are used.
ClassSchema The Schema object is used to track which fields within an object have been visited by a converter. This object is necessary for processing Composite objects. In particular it is necessary to keep track of which required nodes have been visited and which have not, if a required not has not been visited then the XML source does not match the XML class schema and serialization must fail before processing any further.
ClassType The ClassType object is used to represent a type that is neither a field or method. Such a type is used when an object is to be used to populate a collection. In such a scenario there is no method or field annotations associated with the object.
CollectionEntryTest
CollectionEntryTest.Entry
CollectionFactory The CollectionFactory is used to create collection instances that are compatible with the field type. This performs resolution of the collection class by firstly consulting the specified Strategy implementation. If the strategy cannot resolve the collection class then this will select a type from the Java Collections framework, if a compatible one exists.
CollectionTest
CollectionTest.Entry
CollectionTest.EntryList
CollectionTest.EntrySet
CollectionTest.EntrySortedSet
CollectionTest.ExtendedEntry
CollectionTest.TypeFromFieldList
CollectionTest.TypeFromMethodList
CollectionTest.UnknownCollectionList
Comparer The Comparer is used to compare annotations on the attributes of that annotation. Unlike the equals method, this can ignore some attributes based on the name of the attributes. This is useful if some annotations have overridden values, such as the field or method name.
CompatibilityTest
CompatibilityTest.Example_v1
CompatibilityTest.Example_v2
Composite The Composite object is used to perform serialization of objects that contain XML annotation. Composite objects are objects that are not primitive and contain references to serializable fields. This Converter will visit each field within the object and deserialize or serialize that field depending on the requested action. If a required field is not present when deserializing from an XML element this terminates the deserialization reports the error. <element name="test" class="some.package.Type"> <text>string value</text> <integer>1234</integer> </element> To deserialize the above XML source this will attempt to match the attribute name with an Attribute annotation from the XML schema class, which is specified as "some.package.Type". This type must also contain Element annotations for the "text" and "integer" elements.

Serialization requires that contacts marked as required must have values that are not null. This ensures that the serialized object can be deserialized at a later stage using the same class schema. If a required value is null the serialization terminates and an exception is thrown.

CompositeArray The CompositeArray object is used to convert a list of elements to an array of object entries. This in effect performs a root serialization and deserialization of entry elements for the array object. On serialization each objects type must be checked against the array component type so that it is serialized in a form that can be deserialized dynamically. <array length="2"> <entry> <text>example text value</text> </entry> <entry> <text>some other example</text> </entry> </array> For the above XML element list the element entry is contained within the array. Each entry element is deserialized as a root element and then inserted into the array. For serialization the reverse is done, each element taken from the array is written as a root element to the parent element to create the list. Entry objects do not need to be of the same type.
CompositeEntry
CompositeInlineList The CompositeInlineList object is used to convert an group of elements in to a collection of element entries. This is used when a containing element for a list is not required. It extracts the elements by matching elements to name of the type that the annotated field or method requires. This enables these element entries to exist as siblings to other objects within the object. One restriction is that the Root annotation for each of the types within the list must be the same. <entry attribute="one"> <text>example text value</text> </entry> <entry attribute="two"> <text>some other example</text> </entry> <entry attribute="three"> <text>yet another example</text> </entry> For the above XML element list the element entry is contained within the list. Each entry element is thus deserialized as a root element and then inserted into the list. This enables lists to be composed from XML documents. For serialization the reverse is done, each element taken from the collection is written as a root element to the owning element to create the list. Entry objects do not need to be of the same type.
CompositeInlineMap The CompositeMap is used to serialize and deserialize maps to and from a source XML document. The structure of the map in the XML format is determined by the annotation. Keys can be either attributes or elements, and values can be inline. This can perform serialization and deserialization of the key and value objects whether the object types are primitive or composite. <map> <entry key='1'> <value>one</value> </entry> <entry key='2'> <value>two</value> </entry> </map> For the above XML element map the element entry is used to wrap the key and value such that they can be grouped. This element does not represent any real object. The names of each of the XML elements serialized and deserialized can be configured.
CompositeInlineMapTest.MockElementMap
CompositeKey The CompositeKey object is used to convert an object to an from an XML element. This accepts only composite objects and will throw an exception if the ElementMap annotation is configured to have an attribute key. If a key name is given for the annotation then this will act as a parent element to the resulting XML element for the composite object.
CompositeList The CompositeList object is used to convert an element list to a collection of element entries. This in effect performs a root serialization and deserialization of entry elements for the collection object. On serialization each objects type must be checked against the XML annotation entry so that it is serialized in a form that can be deserialized. <list> <entry attribute="value"> <text>example text value</text> </entry> <entry attribute="demo"> <text>some other example</text> </entry> </list> For the above XML element list the element entry is contained within the list. Each entry element is thus deserialized as a root element and then inserted into the list. This enables lists to be composed from XML documents. For serialization the reverse is done, each element taken from the collection is written as a root element to the owning element to create the list. Entry objects do not need to be of the same type.
CompositeMap The CompositeMap is used to serialize and deserialize maps to and from a source XML document. The structure of the map in the XML format is determined by the annotation. Keys can be either attributes or elements, and values can be inline. This can perform serialization and deserialization of the key and value objects whether the object types are primitive or composite. <map> <entry key='1'> <value>one</value> </entry> <entry key='2'> <value>two</value> </entry> </map> For the above XML element map the element entry is used to wrap the key and value such that they can be grouped. This element does not represent any real object. The names of each of the XML elements serialized and deserialized can be configured.
CompositeMapTest.MockElementMap
CompositeTest
CompositeValue The CompositeValue object is used to convert an object to an from an XML element. This accepts only composite objects and will maintain all references within the object using the cycle strategy if required. This also ensures that should the value to be written to the XML element be null that nothing is written.
ConstructorException The ConstructorException is used to represent any errors where an annotated constructor parameter is invalid. This is thrown when constructor injection is used and the schema is invalid. Invalid schemas are schemas where an annotated method or field does not match an annotated constructor parameter.
ConstructorInjectionTest
ConstructorInjectionTest.Example
ConstructorScanner The ConstructorScanner object is used to scan all all constructors that have XML annotations for their parameters. parameters. Each constructor scanned is converted in to a Builder object. In order to ensure consistency amongst the annotated parameters each named parameter must have the exact same type and annotation attributes across the constructors. This ensures a consistent XML representation.
ContextualCallbackTest
ContextualCallbackTest.Entry
ConversionInstance The ConversionInstance object is used to promote the type to some more specialized type. For example if a field or method that represents a List is annotated then this might create a specialized type such as a Vector. It typically used to promote a type either because it is abstract or because another type is required.

This is used by the CollectionFactory to convert the type of a collection field from an abstract type to a instantiable type. This is used to simplify strategy implementations.

D
Decorator This acts as a strategy and intercepts all XML elements that are serialized and deserialized so that the XML can be manipulated by the provided interceptor implementation.
DefaultAnnotationTest
DefaultAnnotationTest.Customer
DefaultAnnotationTest.OrderItem
DefaultAnnotationTest.OrderList
DefaultAnnotationTest.TypeMisMatch
DefaultEmptyTest
DefaultEmptyTest.DefaultExample
DefaultStyle The DefaultStyle object is used to represent a style that does not modify the tokens passed in to it. This is used if there is no style specified or if there is no need to convert the XML elements an attributes to a particular style. This is also the most performant style as it does not require cache lookups.
DefaultTest
DefaultTest.DefaultTextList
DefaultTest.TextEntry
DefaultTestClassWithInvalidElement
DefaultWithParametersInGetterTest
DefaultWithParametersInGetterTest.DefaultTestClass
DefaultWithParametersInGetterTest.DefaultTestClassWithInvalidTransient
DuplicateExample
DuplicateExample.NonMatchingAnnotationExample
ElementArrayLabel The ElementArrayLabel represents a label that is used to represent an XML element array in a class schema. This element array label can be used to convert an XML node into an array of composite or primitive objects. If the array is of primitive types then the entry attribute must be specified so that the primitive values can be serialized in a structured manner.
ElementEntry
ElementException The ElementException is used to represent conditions when an XML element is in an invalid state. Typically this is used when and element cannot be serialized or deserialized. Such a condition can arise when an element exists within the source XML that does not match the schema class. For serialization this exception is thrown if a required field is null.
ElementLabel The ElementLabel represents a label that is used to represent an XML element in a class schema. This element can be used to convert an XML node into either a primitive value such as a string or composite object value, which is itself a schema for a section of XML within the XML document.
ElementListLabel The ElementListLabel represents a label that is used to represent an XML element list in a class schema. This element list label can be used to convert an XML node into a collection of composite objects. Each element converted with the converter this creates must be an XML serializable element.
ElementMapLabel The ElementMapLabel represents a label that is used to represent an XML element map in a class schema. This element list label can be used to convert an XML node into a map object of composite or primitive key value pairs. Each element converted with the converter this creates must be an XML serializable element.
ElementParameter The ElementParameter represents a constructor parameter. It contains the XML annotation used on the parameter as well as the name of the parameter and its position index. A parameter is used to validate against the annotated methods and fields and also to determine the deserialized values that should be injected in to the constructor to instantiate it.
ElementParameter.Contact
EmptyMapEntryTest
EmptyMapEntryTest.SimpleBug1
EmptyMapEntryTest.SimpleBug1.Mojo
EmptyMatcher The EmptyMatcher object is used as a delegate type that is used when no user specific matcher is specified. This ensures that no transform is resolved for a specified type, and allows the normal resolution of the stock transforms.
EmptyTest
EmptyTest.EmptyCollection
EmptyTest.OptionalElement
EmptyTest.RequiredElement
EmptyTest.RequiredMethodElement
EmptyTest.RequiredMethodElement.DefaultedAttribute
EmptyTest.RequiredMethodElement.OptionalAttribute
EmptyTest.RequiredMethodElement.RequiredAttribute
Entry
Entry.
EntryTest
EntryTest.CompositeKey
EnumArrayTest
EnumArrayTest.NumberArray
EnumMapTest
EnumMapTest.EnumMapExample
EnumSetTest
EnumSetTest.EnumSetExample
ExampleArray
ExampleArray.ExamplePrimitiveArray
ExampleCollection
ExampleCollection.ExampleInlineCollection
ExampleCollection.ExampleInlineCollection.ExamplePrimitiveCollection
ExampleCollection.ExampleInlineCollection.ExamplePrimitiveCollection.ExamplePrimitiveInlineCollection
ExampleStrategy
ExceptionTest
ExceptionTest.Entry
ExceptionTest.EntryList
ExceptionTest.ListEntry
ExceptionTest.ListEntryList
ExceptionTest.NoRootListEntry
ExceptionTest.RootListEntry
ExtendTest
ExtendTest.First
ExtendTest.Second
ExtendTest.Third
Factory The Factory object provides a base class for factories used to produce field values from XML elements. The goal of this type of factory is to make use of the Strategy object to determine the type of the field value. The strategy class must be assignable to the field class type, that is, it must extend it or implement it if it represents an interface. If the strategy returns a null Value then the subclass implementation determines the type used to populate the object field value.
FieldContact The FieldContact object is used to act as a contact for a field within an object. This allows a value to be set on an object field during deserialization and acquired from the same field during serialization.
FieldScannerDefaultTest
FieldScannerDefaultTest.MixedAnnotations
FieldScannerDefaultTest.NoAnnotations
FieldScannerTest
FieldScannerTest.Entry
FieldScannerTest.Example
FileMatch
FilterTest
FilterTest.Entry
FriendList
Function The Function object is used to encapsulated the method that is called when serializing an object. This contains details on the type of method represented and ensures that reflection is not required each time the method is to be invoked.
GetPart The GetPart object represents the getter method for a Java Bean property. This composes the get part of the method contact for an object. The get part contains the method that is used to get the value in an object and the annotation that tells the serialization process how to serialize the value.
Index The Index object is used to represent an index of parameters iterable in declaration order. This is used so that parameters can be acquired by name for validation. It is also used to create an array of Parameter objects that can be used to acquire the correct deserialized values to use in order to instantiate the object.
InjectTest
InjectTest.InjectExample
InjectionTest
InjectionTest.ExampleMessage
InjectionTest.InjectionExample
InlineListWithDataTest
InlineListWithDataTest.ListWithDataExample
InlineListWithDataTest.ListWithDataExample.MapWithDataExample
InlineMapTest
InlineMapTest.PrimitiveInlineAttributeMap
InlineMapTest.PrimitiveInlineAttributeValueMap
InlineMapTest.PrimitiveInlineMap
InlineNamedList
InlinePrimitiveList
InstantiationException The InstantiationException is thrown when an object cannot be instantiated either because it is an abstract class or an interface. Such a situation can arise if a serializable field is an abstract type and a suitable concrete class cannot be found. Also, if an override type is not assignable to the field type this is thrown, for example if an XML element list is not a collection.
Instantiator The Instantiator is used to instantiate types that will leverage a constructor cache to quickly create the objects. This is used by the various object factories to return type instances that can be used by converters to create the objects that will later be deserialized.
LiteralTest.LiteralExample
LiteralTest.LiteralExample.Literal
LiteralTest.LiteralExample.LiteralMatcher
LiteralTest.LiteralExample.LiteralTransform
Manipulator The manipulator object is used to manipulate the attributes added to the XML elements by the strategy in such a way that they do not contain Java class names but rather neutral ones.
MapFactory The MapFactory is used to create map instances that are compatible with the field type. This performs resolution of the map class by consulting the specified Strategy implementation. If the strategy cannot resolve the map class then this will select a type from the Java Collections framework, if a compatible one exists.
MapNullTest
MapNullTest.ComplexMap
MapNullTest.CompositeKey
MapNullTest.MapEntry
MapNullTest.PrimitiveMap
MapTest
MapTest.ComplexMap
MapTest.ComplexValueKeyOverrideMap
MapTest.CompositeKey
MapTest.EntryMap
MapTest.Field
MapTest.IndexConfig
MapTest.Lucene
MapTest.MapEntry
MapTest.PrimitiveInlineMap
MapTest.PrimitiveMap
MapTest.PrimitiveValueKeyOverrideMap
MapTest.PrimitiveValueOverrideMap
MapTest.Query
MapTest.StringMap
Message
MethodContact The MethodContact object is acts as a contact that can set and get data to and from an object using methods. This requires a get method and a set method that share the same class type for the return and parameter respectively.
MethodContactTest
MethodContactTest.Example
MethodContactTest.Example.Entry
MethodException The MethodException is used to represent conditions where a Java Bean property has been annotated incorrectly. This is thrown if a class schema performs illegal annotations. Such annotations occur if the methods do not conform to the Java Bean naming conventions, or if field and method annotations are mixed.
MethodName The MethodName object is used to represent the name of a Java Bean method. This contains the Java Bean name the type and the actual method it represents. This allows the scanner to create MethodPart objects based on the method type.
MethodPartFactory The MethodPartFactory is used to create method parts based on the method signature and the XML annotation. This is effectively where a method is classified as either a getter or a setter method within an object. In order to determine the type of method the method name is checked to see if it is prefixed with either the "get", "is", or "set" tokens.

Once the method is determined to be a Java Bean method according to conventions the method signature is validated. If the method signature does not follow a return type with no arguments for the get method, and a single argument for the set method then this will throw an exception.

MethodPartFactoryTest
MethodScannerDefaultTest
MethodScannerDefaultTest.NoAnnotations
MethodTest
MethodTest.ExplicitMethodNameExample
MethodTest.ExplicitMethodNameExample.ImplicitMethodNameExample
MissingArrayLengthTest
MissingArrayLengthTest.MissingArrayLengthExample
MissingGenericsTest
MissingGenericsTest.MissingGenerics
MixTest
MixTest.MixExample
MultiElementMapTest
MultiElementMapTest.Properties
MultiElementMapTest.Value
MultiThreadedPersisterTest.Example
MultiThreadedPersisterTest.Worker
NamespaceDecorator The NamespaceDecorator object is used to decorate any output node with namespaces. All namespaces added to this are applied to nodes that require decoration. This can add namespaces to the node as well as setting the primary namespace reference for the node. This results in qualification for the node.
NamespaceDecoratorTest.MockNamespace
NamespaceDefaultTest
NamespaceInheritanceTest
NamespaceInheritanceTest.Aaa
NamespaceInheritanceTest.AaaWithPrefix
NamespaceInheritanceTest.Bbb
NamespaceInheritanceTest.BbbWithPrefix
NamespaceScopeTest
NamespaceScopeTest.A
NamespaceScopeTest.B
NamespaceScopeTest.D
NamespaceVerbosityTest
NonFinalConstructorInjectionTest.NonFinalExample
NullArrayEntryTest
NullArrayEntryTest.Entry
ObjectFactory The ObjectFactory is the most basic factory. This will basically check to see if there is an override type within the XML node provided, if there is then that is instantiated, otherwise the field type is instantiated. Any type created must have a default no argument constructor. If the override type is an abstract class or an interface then this factory throws an exception.
ObjectInstance The ObjectInstance is used to instantiate an object from the criteria provided in the given Value. If the value contains a reference then the reference is provided from this type. For performance the Context object is used to instantiate the object as it contains a reflection cache of constructors.
OriginalTest
OriginalTest.Entry
OverrideTest
Paragraph
ParameterFactory The ParameterFactory object is used to create instances of the Parameter object. Each parameter created can be used to validate against the annotated fields and methods to ensure that the annotations are compatible.

The Parameter objects created by this are selected using the XML annotation type. If the annotation type is not known the factory will throw an exception, otherwise a parameter instance is created that will expose the properties of the annotation.

PerformanceTest
PerformanceTest.ChildEntry
PerformanceTest.ElementEntry
PerformanceTest.EmptyFilter
PerformanceTest.GrandChildEntry
PerformanceTest.RootEntry
PersistenceException The PersistenceException is thrown when there is a persistance exception. This exception this will be thrown from the Persister should serialization or deserialization of an object fail. Error messages provided to this exception are formatted similar to the PrintStream.printf method.
Persister The Persister object is used to provide an implementation of a serializer. This : the Serializer interface and enables objects to be persisted and loaded from various sources. This implementation makes use of Filter objects to replace template variables within the source XML document. It is fully thread safe and can be shared by multiple threads without concerns.

Deserialization is performed by passing an XML schema class into one of the read methods along with the source of an XML stream. The read method then reads the contents of the XML stream and builds the object using annotations within the XML schema class.

Serialization is performed by passing an object and an XML stream into one of the write methods. The serialization process will use the class of the provided object as the schema class. The object is traversed and all fields are marshalled to the result stream.

Person
Primitive The Primitive object is used to provide serialization for primitive objects. This can serialize and deserialize any primitive object and enumerations. Primitive values are converted to text using the String.valueOf method. Enumerated types are converted using the Enum.valueOf method.

Text within attributes and elements can contain template variables similar to those found in Apache Ant. This allows values such as system properties, environment variables, and user specified mappings to be inserted into the text in place of the template reference variables. <example attribute="${value}> <text>Text with a ${variable}</text> </example> In the above XML element the template variable references will be checked against the Filter object used by the context serialization object. If they corrospond to a filtered value then they are replaced, if not the text remains unchanged.

PrimitiveArray The PrimitiveArray object is used to convert a list of elements to an array of object entries. This in effect performs a serialization and deserialization of primitive elements for the array object. On serialization each primitive type must be checked against the array component type so that it is serialized in a form that can be deserialized dynamically. <array> <entry>example text one</entry> <entry>example text two</entry> <entry>example text three</entry> </array> For the above XML element list the element entry is contained within the array. Each entry element is deserialized as a from a parent XML element, which is specified in the annotation. For serialization the reverse is done, each element taken from the array is written into an element created from the parent element.
PrimitiveArrayTest
PrimitiveFactory The PrimitiveFactory object is used to create objects that are primitive types. This creates primitives and enumerated types when given a string value. The string value is parsed using a matched Transform implementation. The transform is then used to convert the object instance to an from a suitable XML representation. Only enumerated types are not transformed using a transform, instead they use Enum.name.
PrimitiveInlineList The PrimitiveInlineList object is used to convert a group of elements in to a collection of element entries. This is used when a containing element for a list is not required. It extracts the elements by matching elements to name of the type that the annotated field or method requires. This enables these element entries to exist as siblings to other objects within the object. One restriction is that the Root annotation for each of the types within the list must be the same. <entry>example one</entry> <entry>example two</entry> <entry>example three</entry> <entry>example four</entry> For the above XML element list the element entry is used to wrap the primitive string value. This wrapping XML element is configurable and defaults to the lower case string for the name of the class it represents. So, for example, if the primitive type is an int the enclosing element will be called int.
PrimitiveKey The PrimitiveKey is used to serialize a primitive key to and from a node. If a key name is provided in the annotation then this will serialize and deserialize that key with the given name, if the key is an attribute, then it is written using the provided name. <entry key="one">example one</entry> <entry key="two">example two</entry> <entry key="three">example three</entry> Allowing the key to be written as either an XML attribute or an element enables a more flexible means for representing the key. Composite elements can not be used as attribute values as they do not serialize to a string. Primitive keys as elements can be maintained as references using the cycle strategy.
PrimitiveKeyTest.MockElementMap
PrimitiveList The PrimitiveList object is used to convert an element list to a collection of element entries. This in effect performs a serialization and deserialization of primitive entry elements for the collection object. On serialization each objects type must be checked against the XML annotation entry so that it is serialized in a form that can be deserialized. <list> <entry>example one</entry> <entry>example two</entry> <entry>example three</entry> <entry>example four</entry> </list> For the above XML element list the element entry is used to wrap the primitive string value. This wrapping XML element is configurable and defaults to the lower case string for the name of the class it represents. So, for example, if the primitive type is an int the enclosing element will be called int.
PrimitiveListTest
PrimitiveTest
PrimitiveType
PrimitiveValue The PrimitiveValue is used to serialize a primitive value to and from a node. If a value name is provided in the annotation then this will serialize and deserialize that value with the given name, if the value is primitive and no name is specified then the value is written inline, that is without any enclosing XML element. <entry key="one">example one</entry> <entry key="two">example two</entry> <entry key="three">example three</entry> Allowing the value to be written as either an XML element or an inline text value enables a more flexible means for representing the value. The only condition for having an inline value is that the key is specified as an attribute in the annotation.
Qualifier The Qualifier object is used to provide decorations to an output node for namespaces. This will scan a provided contact object for namespace annotations. If any are found they can then be used to apply these namespaces to the provided node. The Contact objects can represent fields or methods that have been annotated with XML annotations.
Reflector The Reflector object is used to determine the type of a generic type. This is used when the type of an XML annotation is not explicitly and the schema scanner needs to determine via reflection what the generic parameters are of a specific type. In particular this is used to determine the parameters within a list annotated with the ElementList annotation. This also has special handling for arrays within generic collections.
ReflectorTest
ReplaceThisTest
ReplaceThisTest.RealParent
ReplaceThisTest.RealParent.ReplaceThisParent
RequiredTest
RequiredTest.Entry
Revision The Revision object is used represent the revision of a class as read from a version attribute. It determines the type of deserialization that takes place.
RootException The RootException is thrown if the Root annotation is missing from a root object that is to be serialized or deserialized. Not all objects require a root annotation, only those objects that are to be deserialized to or serialized from an ElementList field and root objects that are to be deserialized or serialized directly from the persister.
RootTest
RootTest.RootExample
RootTest.RootExample.ExtendedExplicitlyOverriddenRootExample
RootTest.RootExample.ExtendedOverriddenRootExample
RootTest.RootExample.ExtendedRootExample
Scanner The Scanner object performs the reflective inspection of a class and builds a map of attributes and elements for each annotated field. This acts as a cachable container for reflection actions performed on a specific type. When scanning the provided class this inserts the scanned field as a Label in to a map so that it can be retrieved by name. Annotations classified as attributes have the Attribute annotation, all other annotated fields are stored as elements.
ScannerDefaultTest.DuplicateExample
ScannerDefaultTest.DuplicateExample.NonMatchingAnnotationExample
ScannerDefaultTest.OrderItem
ScannerDefaultTest.OrderItem.Customer
ScannerFactory The ScannerFactory is used to create scanner objects that will scan a class for its XML class schema. Caching is done by this factory so that repeat retrievals of a Scanner will not require repeat scanning of the class for its XML schema.
ScannerTest
ScannerTest.Entry
ScannerTest.Example
ScannerTest.MixedExample
ScannerTest.MixedExample.DuplicateAttributeExample
ScannerTest.MixedExample.DuplicateAttributeExample.NonMatchingElementExample
ScannerTest.MixedExample.DuplicateAttributeExample.NonMatchingElementExample.IllegalTextExample
ScatterTest
ScatterTest.InlineTextList
Section
Session The Session object represents a session with name value pairs. The persister uses this to allow objects to add or remove name value pairs to an from an internal map. This is done so that the deserialized objects can set template values as well as share information. In particular this is useful for any Strategy implementation as it allows it so store persistence state during the persistence process.

Another important reason for the session map is that it is used to wrap the map that is handed to objects during callback methods. This opens the possibility for those objects to grab a reference to the map, which will cause problems for any of the strategy implementations that wanted to use the session reference for weakly storing persistence artifacts.

SetPart The SetPart object represents the setter method for a Java Bean property. This composes the set part of the method contact for an object. The set part contains the method that is used to set the value on an object and the annotation that tells the deserialization process how to deserialize the value.
Signature The Signature object is used to determine the details to use for an annotated field or method using both the field an annotation details. This allows defaults to be picked up from the method or field type if that have not been explicitly overridden in the annotation.
SimpleConstructorInjectionTest
SimpleEntry
SimpleInlineList
SimplePrimitiveInlineList
SimpleType
Source The Source object acts as a contextual object that is used to store all information regarding an instance of serialization or deserialization. This maintains the Strategy as well as the Filter used to replace template variables. When serialization and deserialization are performed the source is required as it acts as a factory for objects used in the process.

For serialization the source object is required as a factory for Schema objects, which are used to visit each field in the class that can be serialized. Also this can be used to get any data entered into the session Map object.

When deserializing the source object provides the contextual data used to replace template variables extracted from the XML source. This is performed using the Filter object. Also, as in serialization it acts as a factory for the Schema objects used to examine the serializable fields of an object.

StackOverflowTest
StackOverflowTest.BenefitMutation
StackOverflowTest.Delivery
StackOverflowTest.NewBenefit
StaticTest
StaticTest.Detail
StaticTest.Document
StrategyTest
StrategyTest.Example
StrategyTest.ExampleExample
StrictModeTest
StrictTest
StrictTest.NamedStrictObject
StrictTest.StrictEntry
StrictTest.StrictExample
StrictTest.StrictObject
StyleTest
StyleTest.CaseExample
StyleTest.TextEntry
StyleTest.URLEntry
SubstituteTest
SubstituteTest.LargeSubstitute
SubstituteTest.OtherSubstitute
SubstituteTest.SimpleSubstitute
SubstituteTest.Substitute
SubstituteTest.SubstituteExample
SubstituteTest.YetAnotherSubstitute
SuperTypeTest
SuperTypeTest.MyMap
SuperTypeTest.SubType1
SuperTypeTest.SubType2
Support The Support object is used to provide support to the serialization engine for processing and transforming strings. This contains a Transformer which will create objects from strings and will also reverse this process converting an object to a string. This is used in the conversion of primitive types.
Template This is primarily used to replace the StringBuffer class, as a way for the TemplateEngine to store the data for a specific region within the parse data that constitutes a desired value. The methods are not synchronized so it enables the characters to be taken quicker than the string buffer class.
TemplateEngine The TemplateEngine object is used to create strings which have system variable names replaced with their values. This is used by the Source context object to ensure that values taken from an XML element or attribute can be values values augmented with system or environment variable values. tools=${java.home}/lib/tools.jar Above is an example of the use of an system variable that has been inserted into a plain Java properties file. This will be converted to the full path to tools.jar when the system variable "java.home" is replaced with the matching value.
TemplateFilter The TemplateFilter class is used to provide variables to the template engine. This template acquires variables from two different sources. Firstly this will consult the user contextual Context object, which can contain variables that have been added during the deserialization process. If a variable is not present from this context it asks the Filter that has been specified by the user.
TemplateTest
TemplateTest.Details
TemplateTest.Example
TemplateTest.Variable
TextEntry
TextException The TextException is used to represent conditions when an XML element text value is in an invalid state. Typically this is used when text cannot be serialized or deserialized. Also this may be thrown if the Text annotation is used to label a field that is not a primitive type.
TextLabel The TextLabel represents a label that is used to get a converter for a text entry within an XML element. This label is used to convert an XML text entry into a primitive value such as a string or an integer, this will throw an exception if the field value does not represent a primitive object.
TextTest
TextTest.DuplicateTextEntry
TextTest.IllegalElementTextEntry
TextTest.NonPrimitiveTextEntry
TextTest.OptionalTextEntry
TextTest.TextEntry
TextTest.TextList
Traverser The Traverser object is used to traverse the XML class schema and either serialize or deserialize an object. This is the root of all serialization and deserialization operations. It uses the Root annotation to ensure that the XML schema matches the provided XML element. If no root element is defined the serialization and deserialization cannot be performed.
TutorialTest
TutorialTest.Detail
TutorialTest.Document
TypeTest
TypeTest.Entry
TypeTest.ObjectEntry
TypeTest.PrimitiveEntry
UnicodeTest
UnicodeTest.Unicode
UnicodeTest.Unicode.UnicodeExample
ValidateTest
ValidateTest.TextEntry
ValidateTest.TextList
ValueInstance The ValueInstance object is used to create an object by using a Value instance to determine the type. If the provided value instance represents a reference then this will simply provide the value of the reference, otherwise it will instantiate a new object and return that.
ValueRequiredException The ValueRequiredException is thrown when an attribute or element is missing from the XML document. This is thrown only if the attribute or element is required according to the annotation for that field within the XML schema class.
Variable The Variable object is used to represent a variable for a method or field of a deserialized object. It has the value for the field or method as well as the details from the annotation. This is used by the Collector to populate an object once all the values for that object have been collected.
Variable.Adapter The Adapter object is used to call the repeater with the original deserialized object. Using this object the converter interface can be used to perform repeat reads for the object. This must be given a Repeater in order to invoke the repeat read method.
VersionLabel The VersionLabel object is used convert any double retrieved from an XML attribute to a version revision. The version is used to determine how to perform serialization of a composite by determining version compatibility.
VersionTest
VersionTest.Example
VersionTest.Example1
VersionTest.Example1.Example2
VersionTest.Example1.Example2.Entry
VersionTest.Example1.Example2.SimpleType