All Classes and Interfaces
Class
Description
Represents transport-specific exceptions which are used to indicate that
 a given invocation was suspended
Abstract base class factoring out common Conduit logic,
 allowing non-decoupled transports to be written without any
 regard for the decoupled back-channel or partial response logic.
Abstract base class holding logic common to any ConduitSelector
 that retrieves a Conduit from the ConduitInitiator.
Supply default implementations, as appropriate, for DataBinding.
java.util.logging.Logger implementation delegating to another framework.
Abstract base class factoring out common Destination logic,
 allowing non-decoupled transports to be written without any
 regard for the decoupled back-channel or partial response logic.
Abstract logic for creating XMLStreamReader from DOM documents.
This class makes it easy to create two simultaneous beans - a factory bean and the bean
 that the factory produces.
A Feature is something that is able to customize a Server, Client, or Bus, typically
 adding capabilities.
Abstract implementation of Invoker.
Deprecated. 
Provides a starting point implementation for a interceptors that
 participate in phased message processing.
A portable - i.e. for jaxws and jaxrs - Feature is something that is able to customize
 a Server, Client, or Bus, typically adding capabilities.
Outputstream that will buffer a certain amount before writing anything to the underlying
 stream.
Helper methods for 
DestinationFactorys and ConduitInitiators.A base class to build your own message implementations on.
Provides a convenient hook onFirstWrite() for those needing
 to wrap an output stream.
This wrapper helper will use reflection to handle the wrapped message
Creates an XMLStreamReader from the InputStream on the Message.
Encapsulation of version-specific WS-Addressing constants.
Abstraction of Message Addressing Properties.
Process instance of an annotated class.
Visits the annotated elements of an object
API used in the to allow a message exchange participant to
 assert its capabilities for the underlying message.
An implementation of a FilterInputStream that decodes the
 stream data in BASE64 encoding format.
This class converts to/from base64.
Invoker for externally created service objects.
A Binding provides interceptors and message creation logic for a
 specific protocol binding.
A configuration for a binding.
A factory interface for creating Bindings from BindingInfo metadata.
The manager interface represents a repository for accessing
 
BindingFactorys.A container for static utility methods related to resource bundle
 naming conventons.
The Bus is the central place in CXF.
The listener interface for receiving notification of when 
Bus
 objects are created.The BusException class is used to indicate a bus exception has occurred.
Factory to create CXF Bus objects.
The listener interface for receiving notification of 
Bus
 lifecycle events.The manager interface for registering 
BusLifeCycleListeners.BeanFactoryPostProcessor that looks for any bean definitions that have the
 
AbstractBeanDefinitionParser.WIRE_BUS_ATTRIBUTE attribute set.Enumeration for the ways in which the CXF bus can be wired into a Spring
 bean.
This outputstream implementation will both write to the outputstream
 that is specified and cache the data at the same time.
The 
Bus extension to clean up unclosed CachedOutputStream instances (and alike) backed by
 temporary files (leading to disk fill, see https://issues.apache.org/jira/browse/CXF-7396.Implements a useful caching map.
Create a suitable CallbackHandler for the given message.
Resolves URIs using Apache Commons Resolver API.
Map a certificate to a user name for the jaas login
A class to hold a pair of encryption and decryption ciphers.
Class loader used to store and retrieve class generated during runtime to avoid class generation each time.
This class is extremely useful for loading resources and classes in a fault
 tolerant manner that works across different applications servers.
Resolve resources from the system class path.
Wrappers the contexts in a way that allows the contexts
 to be cleared and released in an try-with-resources block
Asynchronous callback object for calls to 
Client.invoke(ClientCallback, String, Object...)
 and related functions.Takes a Fault and converts it to a local exception type if possible.
A pipe between peers that channels transport-level messages.
Factory for Conduits.
The ConduitInitiatorManager provides an interface to register and retrieve
 transport factories.
Strategy for retrieving a Conduit to mediate an outbound message.
A configurable interface for obtaining a bean's name
 A class which implements this interface should return the
 unique bean name for configuration to use
The configurer's interface
 A class that implements this interface will perform a
 bean's configuration work
Holder for utility methods relating to contexts, allows to lazily load JAXB compared to ContextUtils.
Holder for utility methods relating to contexts.
Represents transport-neutral suspended invocation instances
 or continuations
Callback that receives continuation status updates.
Provides transport-neutral support for creating suspended invocation primitives
 or continuations
CXF reads a series of Spring XML files as part of initialization.
Marker interface for OutputStreams that can directly support
 copying from an input stream.
Specifies the DataBinding to use with the service
The 'read' side of the data binding abstraction of CXF.
The 'write' side of the data binding abstraction of CXF.
Default provider which accepts a map of operation names to schema validation types.
SecurityContext which implements isUserInRole using the
 following approach : skip the first Subject principal, and then checks
 Groups the principal is a member of
Strategy for lazy deferred retreival of a Conduit to mediate an
 outbound message.
Enable to convert a 
AbstractPortableFeature to a AbstractFeature.Creates an XMLStreamReader from the InputStream on the Message.
XMLStreamReader implementation which can be used to enforce a number of
 depth-restricting policies.
A Destination is a transport-level endpoint capable of receiving
 unsolicited incoming messages from different peers.
Factory for Destinations.
The DestinationFactoryManager provides an interface to register and retrieve
 transport factories.
A destination that has a specific endpoint.
Few simple utils to read DOM.
Represents an endpoint that receives messages.
This interface defines an object that can create EndpointImpl
 objects.
The EndpointInfo contains the information for a web service 'port' inside of a service.
Specifies properties to record for the endpoint
Specifies a property to record for the endpoint
Provides utility methods for obtaining endpoint references, wsdl definitions, etc.
Implementations of this interface are responsible for mapping
 between abstract and concrete endpoint references, and/or
 renewing stale references.
Implementations of this interface are responsible for mediating
 access to registered EndpointResolvers, which themselves map
 between abstract and concrete endpoint references, and/or
 facilitate renewal of stale references.
This implementation class is responsible for mediating
 access to registered EndpointResolvers, which themselves map
 between abstract and concrete endpoint references, and/or
 facilitate renewal of stale references.
Marker for CXF Features.
This bus uses CXF's built in extension manager to load components
 (as opposed to using the Spring bus implementation).
Static registry of extensions that are loaded in addition to the
 extensions the Bus will automatically detect.
Represents an object factory.
This invoker implementation calls a Factory to create the service object.
Defines the factory used for the service.
Enables FastInfoset negotiation
 <!
A Fault that occurs during invocation processing.
If applied on an exception type, the value specifies the WS-Addressing Action
 which will be applied if this exception is thrown from a WSA-enabled service.
Implement this interface to customize behavior for Exceptions
 thrown by the application implementing the service call.
Marker interfaces for Exceptions that have a
 getFaultInfo() method that returns some sort
 of object that the FaultOutInterceptor can
 marshal into a fault detail element
A Feature is something that is able to customize a Server, Client, or Bus, typically
 adding capabilities.
Creates an XMLStreamReader from the InputStream on the Message.
Creates an XMLStreamReader from the InputStream on the Message.
Wraps a XMLStreamReader and provides optional START_DOCUMENT and END_DOCUMENT events.
Class loader used to find class generated during build time to avoid class generation during runtime.
Implement this interface to store class generated in order during build phase
  inject it back before runtime to avoid class generation.
If class has been generated during build time
  (use @see org.apache.cxf.common.spi.GeneratedClassClassLoaderCapture capture to save bytes)
  you can set class loader to avoid class generation during runtime:
  bus.setExtension(new GeneratedNamespaceClassLoader(bus), NamespaceClassCreator.class);
Enables GZIP compression negotiation
This class is used to control GZIP compression of messages.
CXF interceptor that uncompresses those incoming messages that have "gzip"
 content-encoding.
CXF interceptor that compresses outgoing messages using gzip and sets the
 HTTP Content-Encoding header appropriately.
Enum giving the possible values for whether we should gzip a particular
 message.
Specifies a list of classes that are added to the inbound fault
 interceptor chain.
Specifies a list of classes that are added to the inbound interceptor
 chain.
InstrumentationManager interface for the instrumentations query, register
  and unregister
Base interface for all interceptors.
Base interface for all interceptor chains.
The 
InterceptorProvider interface is implemented by objects
 that have interceptor chains associated with them.Exception thrown when we detect an attempt to set an impossible XML Schema reference.
Invokers control how a particular service is invoked.
Feature to do JAAS authentication with defaults for karaf integration
Return holder of the context, classes, etc...
A container for WS-Addressing constants.
A DataSource which will search through a Collection of attachments so as to
 lazily load the attachment from the collection.
Subclass of ByteArrayOutputStream that allows creation of a
 ByteArrayInputStream directly without creating a copy of the byte[].
Deprecated.
Deprecated.
use the logging module rt/features/logging instead
Deprecated.
use the logging module rt/features/logging instead
Deprecated.
use the logging module rt/features/logging instead
Deprecated.
use the logging module rt/features/logging instead
LoginSecurityContext provides additional information about the
 authenticated principal.
A container for static utility methods related to logging.
LSInput implementation that can be used in
 custom LSResourceResolver implementations for getting
 schema import and include references resolved.
Basic interface for representing a Instrumented object.
Logical Handler responsible for aggregating the Message Addressing
 Properties for outgoing messages.
The base interface for all all message implementations.
Interface abstracting various ID caches for enforcement of ID uniqueness.
A message for an operation.
Observer for incoming messages.
Takes the Conduit from the exchange and sends the message through it.
Holder for utility methods relating to messages.
Provides functionality to map BindingOperations to Methods and
 vis a versa.
This MessageObserver creates an Interceptor chain which adds in the interceptors
 set on this class and the global Bus interceptors.
A MultiplexDestination is a transport-level endpoint capable of receiving
 unsolicited incoming messages from different peers for multiple targets
 identified by a unique id.
All elements of the service model that are named by a QName implement this interface.
Holder for WS-Addressing names (of headers, namespaces etc.).
SPI interface to implement the proxy defining logic.
Supply a password for a userName to get roles from LoginModule
Marker annotation to let our JSR250 Processor know
 not to bother examining the class for annotations
 as it's know not to have any
Utility FaultListener for blocking the default PhaseInterceptorChain fault logging
Strategy for null Conduit retrieval.
Allows Observers to register for notification on incoming messages.
Used to provide simple async Executor semantics by creating a one-shot
 thread.
Base interface for client interceptors that are compatible with one way 
 message processing (primarily, JAX-WS).
Specifies a list of classes that are added to the outbound fault
 interceptor chain.
Specifies a list of classes that are added to the outbound
 interceptor chain.
Special StreamWriter that will "overlay" any write events onto the DOM.
Read from a StaX reader, stopping when the next element is a specified element.
Creates a new instance of the service object for each call to create().
The PhaseChainCache provides default interceptor chains for SOAP requests
 and responses, both from the client and web service side.
A phase interceptor is an intercetor that participates in a
 PhaseInterceptorChain.
A PhaseInterceptorChain orders Interceptors according to the phase they
 participate in and also according to the before & after properties on an
 Interceptor.
Used to attach multiple Policy annotations
 to a method or type if policies need to be added
 to more than one place in the wsdl.
Attaches a Policy to a service or method
Factory the maintains a pool of instances that are used.
Strategy for retreival of a pre-existing Conduit to mediate an
 outbound message.
A StreamReaderDelegate that expands property references in element and attribute values.
Replace by org.springframework.core.io.support.PropertiesLoaderUtils
 when moving to Spring 2.0.
Holder of generic property related methods
Utility class loader that can be used to create proxies in cases where
 the the client classes are not visible to the loader of the
 service class.
InputStream implementation that reads a character stream from a Reader
 and transforms it to a byte stream using a specified charset encoding.injects references specified using @Resource annotation
Locates resources that are used at runtime.
Resolves resource.
Implemented by Clients that are willing to accept retried invocations.
Utility for encoding and decoding values according to RFC 5987.
Wrapper class for XmlSchemaCollection that deals with various quirks and bugs.
Enables schema validation
A feature to configure schema validation at the operation level, as an alternative to
 using the @SchemaValidation annotation.
Returning null from the getSchemaValidationType will be ignored.
Provides basic security information about the current message exchange
A 
ServiceContractResolver resolves a service's QName to the URI
 of the service's WSDL contract.A registry for maintaining a collection of contract resolvers.
A simple contract resolver registry.
Invokes a Binding's invoker with the 
INVOCATION_INPUT from
 the Exchange.Implements the Visitor pattern for the Service model.
The ServiceInfo class has schema in two forms: the XmlSchema, in a SchemaCollection, and the
 DOM trees in the SchemaInfo objects.
A Session which can be bound to HTTP, WS-Adddressing, etc.
Creates a new instance for each session.
This bean parser will map all the attributes to properties on the bean.
Create ordinary EndpointImpl objects.
Simple Group implementation
Simple Principal implementation
Always returns a single instance of the bean.
 java.util.logging.Logger implementation delegating to SLF4J.
This class implements most of the Set interface, backed by a
 sorted Array.
A simple databinding implementation which reads and writes Source objects.
Factory that will query the Spring ApplicationContext for the
 appropriate bean for each request.
Holder for utility methods related to manipulating SSL settings, common
 to the connection and listener factories (previously duplicated).
A simple databinding implementation which reads and writes Source objects.
Creates an XMLStreamReader from the InputStream on the Message.
Creates an XMLStreamWriter from the OutputStream on the Message.
 <!
A variation on HashMap which allows lookup by Class, via the string
 returned by 
Class.getName().Represents transport-specific exceptions which are used to indicate that
 a given invocation was suspended
Used to mimic Executor semantics by hijacking calling thread.
This class extends 
TLSParameterBase with client-specific
 SSL/TLS parameters.This class provides the TLSClientParameters that programmatically
 configure a HTTPConduit.
This class is the base class for SSL/TLS parameters that are common
 to both client and server sides.
This class provides some functionality to convert the JAXB
 generated types in the security.xsd to the items needed
 to programatically configure the HTTPConduit and HTTPDestination
 with TLSClientParameters and TLSServerParameters respectively.
This class extends 
TLSParameterBase with service-specific
 SSL/TLS parameters.This class is used by Spring Config to convert the TLSServerParameters
 JAXB generated type into programmatic TLS Server Parameters for the
 configuration of the http-destination.
An immutable struct that contains information about a negotiated
 TLS Session, including the (potentially negotiated) peer certificates
 as well as the currently effective TLS cipher suite.
Implementing classes support transfer of their data to a file.
Creates an XMLStreamReader from the InputStream on the Message.
Creates an XMLStreamReader from the InputStream on the Message.
Strategy for eager upfront retreival of a Conduit to mediate an
 outbound message.
Resolves a File, classpath resource, or URL according to the follow rules:
 
 Check to see if a file exists, relative to the base URI.
 If the file doesn't exist, check the classpath
 If the classpath doesn't exist, try to create URL from the URI.
 
Utility class for decoding and encoding URLs
Instructs the runtime to dispatch using the async method
 on service if continuations are available.
Instructs the runtime to copy the input stream to the output stream using NIO.
This class is responsible for transforming between the native
 WS-Addressing schema version (i.e. 2005/08) and exposed
 version (currently may be 2005/08 or 2004/08).
Holder for 2004/03 Names
Holder for 2004/08 Names
Legacy implementation for Woostox 5.x.
Implements a combination of WeakHashMap and IdentityHashMap.
A Feature is something that is able to customize a Server, Client, or Bus, typically
 adding capabilities.
To create the WrapperHelper instance for the wrapper capable data binding
This wrapper helper will help to create a wrapper object with part elements or
  get a list of part elements from a wrapper object.
This outputstream implementation will cache the message until close()
 is called, at which point it will write the message to the OutputStream
 supplied via the constructor.
Holder for utility methods relating to contexts.
Adds documentation nodes to the generated WSDL
Used to attach multiple WSDLDocumentation annotations
 to a method or type if documentation needs to be added
 to more than one place in the wsdl.
Very simple exception class used to detect internal errors.
Some functions that avoid problems with Commons XML Schema.
Interface for XMLStreamReader wrappers
This class defines a feature is used to transform message using XSLT script.
Class provides XSLT transformation of incoming message.
Class provides XSLT transformation of outgoing message.