/// <summary>
/// Constructor for the <c>CompositeValue</c> object. This
/// will create an object capable of reading an writing composite
/// values from an XML element. This also allows a parent element
/// to be created to wrap the key object if desired.
/// </summary>
/// <param name="context">
/// this is the root context for the serialization
/// </param>
/// <param name="entry">
/// this is the entry object used for configuration
/// </param>
/// <param name="type">
/// this is the type of object the value represents
/// </param>
public CompositeValue(Context context, Entry entry, Type type) {
this.root = new Traverser(context);
this.style = context.Style;
this.context = context;
this.entry = entry;
this.type = type;
}
/// <summary>
/// Constructor for the <c>CompositeMap</c> object. This will
/// create a converter that is capable of writing map objects to
/// and from XML. The resulting XML is configured by an annotation
/// such that key values can attributes and values can be inline.
/// </summary>
/// <param name="context">
/// this is the root context for the serialization
/// </param>
/// <param name="entry">
/// this provides configuration for the resulting XML
/// </param>
/// <param name="type">
/// this is the map type that is to be converted
/// </param>
public CompositeMap(Context context, Entry entry, Type type) {
this.factory = new MapFactory(context, type);
this.value = entry.GetValue(context);
this.key = entry.GetKey(context);
this.style = context.getStyle();
this.entry = entry;
}
/// <summary>
/// Constructor for the <c>CamelCaseStyle</c> object. This
/// is used to create a style that will create camel case XML
/// attributes and elements allowing a consistent format for
/// generated XML. Both the attribute an elements are configurable.
/// </summary>
/// <param name="element">
/// if true the element will start as upper case
/// </param>
/// <param name="attribute">
/// if true the attribute starts as upper case
/// </param>
public CamelCaseStyle(bool element, bool attribute) {
this.style = new CamelCaseBuilder(element, attribute);
this.builder = new Builder(style);
}
/// <summary>
/// Constructor for the <c>Source</c> object. This is used to
/// maintain a context during the serialization process. It holds
/// the <c>Strategy</c> and <c>Context</c> used in the
/// serialization process. The same source instance is used for
/// each XML element evaluated in a the serialization process.
/// </summary>
/// <param name="strategy">
/// this is used to resolve the classes used
/// </param>
/// <param name="support">
/// this is the context used to process strings
/// </param>
/// <param name="style">
/// this is the style used for the serialization
/// </param>
/// <param name="strict">
/// this determines whether to read in strict mode
/// </param>
public Source(Strategy strategy, Support support, Style style, bool strict) {
this.filter = new TemplateFilter(this, support);
this.engine = new TemplateEngine(filter);
this.session = new Session();
this.strategy = strategy;
this.support = support;
this.strict = strict;
this.style = style;
}
/// <summary>
/// Constructor for the <c>Source</c> object. This is used to
/// maintain a context during the serialization process. It holds
/// the <c>Strategy</c> and <c>Context</c> used in the
/// serialization process. The same source instance is used for
/// each XML element evaluated in a the serialization process.
/// </summary>
/// <param name="strategy">
/// this is used to resolve the classes used
/// </param>
/// <param name="support">
/// this is the context used to process strings
/// </param>
/// <param name="style">
/// this is the style used for the serialization
/// </param>
public Source(Strategy strategy, Support support, Style style) {
this(strategy, support, style, true);
}
/// <summary>
/// Constructor for the <c>Persister</c> object. This is used
/// to create a serializer object that will use the provided matcher
/// for customizable transformations. The <c>Matcher</c> will
/// enable the persister to determine the correct way to transform
/// the types that are not annotated and considered primitives.
/// <p>
/// This persister will use the provided <c>Strategy</c> to
/// intercept the XML elements in order to read and write persistent
/// data, such as the class name or version of the document.
/// </summary>
/// <param name="strategy">
/// this is the strategy used to resolve classes
/// </param>
/// <param name="matcher">
/// this is used to customize the transformations
/// </param>
/// <param name="filter">
/// the filter used to replace template variables
/// </param>
public Persister(Strategy strategy, Filter filter, Matcher matcher, Format format) {
this.support = new Support(filter, matcher);
this.style = format.Style;
this.strategy = strategy;
this.format = format;
}
/// <summary>
/// Constructor for the <c>HyphenStyle</c> object. This is
/// used to create a style that will hyphenate XML attributes
/// and elements allowing a consistent format for generated XML.
/// </summary>
public HyphenStyle() {
this.style = new HyphenBuilder();
this.builder = new Builder(style);
}
/// <summary>
/// Constructor for the <c>PrimitiveKey</c> object. This is
/// used to create the key object which converts the map key to an
/// instance of the key type. This can also resolve references.
/// </summary>
/// <param name="context">
/// this is the context object used for serialization
/// </param>
/// <param name="entry">
/// this is the entry object that describes entries
/// </param>
/// <param name="type">
/// this is the type that this converter deals with
/// </param>
public PrimitiveKey(Context context, Entry entry, Type type) {
this.factory = new PrimitiveFactory(context, type);
this.root = new Primitive(context, type);
this.style = context.Style;
this.context = context;
this.entry = entry;
this.type = type;
}
/// <summary>
/// Constructor for the <c>Traverser</c> object. This creates
/// a traverser that can be used to perform serialization or
/// or deserialization of an object. This requires a source object.
/// </summary>
/// <param name="context">
/// the context object used for the traversal
/// </param>
public Traverser(Context context) {
this.style = context.Style;
this.context = context;
}
/// <summary>
/// Constructor for the <c>Format</c> object. This creates an
/// object that is used to describe how the formatter should create
/// the XML document. This constructor uses the specified indent
/// size and the text to use in the generated prolog.
/// </summary>
/// <param name="indent">
/// This is the number of spaces used in the indent.
/// </param>
/// <param name="prolog">
/// This is the prolog for the generated XML document.
/// </param>
/// <param name="style">
/// This is the style to apply to the format object.
/// </param>
public Format(int indent, String prolog, Style style) {
this.prolog = prolog;
this.indent = indent;
this.style = style;
}
/// <summary>
/// Constructor for the <c>Format</c> object. This creates an
/// object that is used to describe how the formatter should create
/// the XML document. This constructor uses the specified indent
/// size and the style provided to style the XML document.
/// </summary>
/// <param name="indent">
/// This is the number of spaces used in the indent.
/// </param>
/// <param name="style">
/// This is the style to apply to the format object.
/// </param>
public Format(int indent, Style style) : this(indent, null, style) {
}
/// <summary>
/// Constructor for the <c>Format</c> object. This creates an
/// object that is used to describe how the formatter should create
/// the XML document. This constructor uses the specified style
/// to style the attributes and elements of the XML document.
/// </summary>
/// <param name="style">
/// This is the style to apply to the format object.
/// </param>
public Format(Style style) : this(3, null, style) {
}