All Classes and Interfaces
Class
Description
Helper class for matching element wrappers, possibly in case-insensitive
manner.
Sub-class of
StdTypeResolverBuilder specifically used with
Default Typing.Indentation to use with XML is different from JSON, because JSON
requires use of separator characters and XML just basic whitespace.
This is a very simple indenter that only every adds a
single space for indentation.
Interface that defines objects that can produce indentation used
to separate object entries and array values.
Dummy implementation that adds no indentation whatsoever
Value container to represent XML Document Type Declaration,
to be written using
XmlGeneratorInitializer.Minimal API to be implemented by XML-backed parsers for which "virtual"
wrapping may be imposed.
JsonParser implementation that exposes XML structure as
set of JSON events that can be used for data binding.Extension of
JacksonAnnotationIntrospector that is needed to support
additional xml-specific annotation that Jackson provides.Adding this annotation will result in value of the property to be serialized
within an xml
CDATA section.Annotation that is similar to JAXB
jakarta.xml.bind.annotation.XmlElementWrapper,
to indicate wrapper element to use (if any) for Collection types (arrays,
Collection).Annotation that can be used to provide XML-specific configuration
for properties, above and beyond what
JsonProperty contains.Deprecated.
Interface that is loosely similar to
jakarta.xml.bind.annotation.XmlValue
in that it can be used on one (and only one!)Entity representing binding from prefix to namespace URI, used
to determine prefix to use for given namespace URI (and dynamically
adding necessary declarations)
Automatically generated from PackageVersion.java.in during
packageVersion-generate execution of maven-replacer-plugin in
pom.xml.
Value container to represent XML Comment within Prolog
part of the Document (before XML Root element, after XML
declaration if one written),
to be written using
XmlGeneratorInitializer.Base API for XML nodes -- Comments, DTDs, Processing Instructions -- to
be written in Document Prolog (before actual XML Document (root node),
after optional XML Declaration).
Value container to represent XML Processing Instruction (PI)
within Prolog part of the Document (before XML Root element,
after XML declaration if one written),
to be written using
XmlGeneratorInitializer.Value container to represent an attribute to add to the root XML element
being written, to be registered via
XmlGeneratorInitializer.addRootAttribute(QName, String)
(or its String-name overload).Refinement of
Stax2ReaderAdapter to override certain methods,
to patch over flaws of JDK-provided default Stax implementation, SJSXPJsonGenerator that outputs JAXB-style XML output instead of JSON content.Copy of
UnwrappingBeanSerializer required to extend
XmlBeanSerializerBase for XML-specific handling.Delegating deserializer whose only function is to handle case of
"unwrapped" List/array deserialization from XML.
Additional extension interface used above and beyond
AnnotationIntrospector to handle XML-specific configuration.Extension of
AnnotationIntrospector.Pair that can
also dispatch 'XmlAnnotationIntrospector' methods.The main reason for a modifier is to support handling of
'wrapped' Collection types.
Property writer sub-class used for handling element wrapping needed for serializing
collection (array, Collection; not Map) types.
Variant of
BeanSerializer for XML handling.Specific sub-class of
BeanSerializerBase needed to take care
of some xml-specific aspects, such as distinction between attributes
and elements.We need a
ValueSerializerModifier to replace default BeanSerializer
with XML-specific one; mostly to ensure that attribute properties are output
before element properties.Immutable entity representing an XML Declaration to write (e.g.
XML-specific
DeserializationContext needed to override certain
handlers.Factory used for constructing
FromXmlParser and ToXmlGenerator
instances.TSFBuilder
implementation for constructing XmlFactory instances.Default
GeneratorInitializer implementation to use with
ToXmlGenerator, registered via
ObjectWriter.with(GeneratorInitializer).Common API for XML entities to write via
ToXmlGenerator.Helper container class used to contain XML specific information
we need to retain to construct proper bean serializer
Customized
ObjectMapper that will read and write XML instead of JSON,
using XML-backed TokenStreamFactory
implementation (XmlFactory), operation on STAX
XMLStreamReaders and
XMLStreamWriters.Builder implementation for constructing
XmlMapper instances.Saved configuration entity to use with builder for
XmlMapper instances.API of processors primarily used for dealing with XML names
containing invalid characters.
Representation of an XML element or attribute name
Contains default
XmlNameProcessor implementations.Property writer sub-class used for unwrapped (no wrapper element) Collection/array
properties.
There are some XML-specific quirks that need extra TLC when
indenting: so we will use a refinement of general purpose one.
Extension of
TokenStreamContext, which implements
core methods needed, and adds small amount of additional
state data we need.Enumeration that defines all togglable features for XML parsers.
Helper class used for efficiently finding root element name used with
XML serializations.
We need to override some parts of
SerializationContext
implementation to handle oddities of XML output, like "extra" root element.Factory implementation we need to provide custom
SerializationContext
variants.Delegating deserializer that is used in the special cases where
we may sometimes see a "plain" String value but need to map it
as if it was a property of POJO.
XML-specific
TokenBuffer sub-class that ensures parsers created
from buffered content implement ElementWrappable, allowing
virtual wrapping to be configured even when content has been buffered
(e.g., during polymorphic type resolution or @JsonUnwrapped handling).Simple helper class used on top of STAX
XMLStreamReader to further
abstract out all irrelevant details, and to expose equivalent of flat token
stream with no "fluff" tokens (comments, processing instructions, mixed
content) all of which is just to simplify
actual higher-level conversion to JSON tokens.Custom specialization of
StdTypeResolverBuilder; needed so that
type id property name can be modified as necessary to make it legal
XML element or attribute name.ValueInstantiators implementation that renames creator properties
to match the names that XmlBeanDeserializerModifier.updateProperties(tools.jackson.databind.DeserializationConfig, tools.jackson.databind.BeanDescription.Supplier, java.util.List<tools.jackson.databind.introspect.BeanPropertyDefinition>)
will give to the corresponding property definitions.Enumeration that defines all togglable extra XML-specific features.
JsonRootNameinstead