All Classes and Interfaces
Class
Description
Base
CpoData implementation for datastore bindings that are
addressed by a positional index (e.g. a JDBC parameter or column index) in addition to the CpoAttribute they move data for.Base
CpoData implementation that owns the CpoAttribute being bound and handles
the transform half of the contract (AbstractCpoData.transformIn(Object)/AbstractCpoData.transformOut(Object)).Base
CpoMetaAdapter implementation that maintains the in-memory map of loaded CpoClass metadata and the shared logic for loading that metadata from the JAXB-bound Ct*
classes produced by unmarshalling a CPO meta XML document.Base
DataSourceInfo implementation that holds the common name/fetchSize/batchSize
configuration and lazily creates the underlying datasource object on first access, guarding
creation with a lock so concurrent callers cannot race to create it twice.Base class for
MetaVisitor implementations that generate Java source (interfaces,
classes) from CpoClass meta model objects.Default
CpoOrderBy implementation: an immutable, bindable sort clause on a single
attribute, optionally wrapped in a native datastore function and associated with a custom marker
for multi-clause substitution.Default
CpoWhere implementation: a bindable where-clause node that is also a Node, allowing leaf comparisons to be chained into branches via BindableCpoWhere.addWhere(CpoWhere) and
rendered to native SQL/CQL text via BindableCpoWhere.toString(CpoClass).A
NodeVisitor that walks a BindableCpoWhere tree and, as a side effect of the
traversal, accumulates both the rendered native (SQL/CQL) where-clause text and the ordered list
of BindAttribute values that must be bound to its parameter placeholders.BindAttribute pairs a single bind value produced while walking a CpoWhere tree
(see BindableWhereBuilder) with either the resolved CpoAttribute it belongs to,
or, when no matching bean attribute exists, the raw attribute name it was addressed by.ExpressionParser implementation for native expressions that use positional ? bind
markers (the common JDBC/CQL convention).Exception class acts as a catch all for any condition occurring in with regards to an Element
The comparison operators for where clauses
XmlObject exporter for meta objects
CpoAdapter is an interface for a set of routines that are responsible for Creating, Retrieving,
Updating, and Deleting (CRUD) value beans within a datasource.
Process-wide cache of
CpoAdapter instances keyed by adapter name.Creates
CpoAdapter instances (plain, transactional, or XA) for a single named data source
configuration.Process-wide cache of
CpoAdapterFactory instances keyed by config name.CpoAdapterFactoryManager is the static entry point applications use to obtain CpoAdapter, CpoTrxAdapter, and CpoXaResource instances by named configuration
context.Represents a single bound argument of a
CpoFunction: a reference to the CpoAttribute whose value is supplied for one of the function's bind markers.Runtime metadata for a single JavaBean-to-datastore attribute binding: extends
CpoAttributeBean's plain configuration data with the reflectively-resolved getter/setter Methods and, if configured, the CpoTransform instance and its transform methods.Plain-data holder for the fields of a CPO attribute as loaded from meta XML: the Java-side
name/type, the datastore-side name/type, and an optional
CpoTransform class name.The CpoBaseAdapter has common functionality needed by all Adapter implementations
Base
CpoXaResource implementation that tracks per-Xid state for a family of XA
resources and drives the JTA two-phase-commit protocol against a subclass-supplied local resource
of type T (e.g. a JDBC Connection).Runtime metadata for a JavaBean class mapped by CPO: its
CpoAttributes, keyed both by
Java property name and by datastore column name, and its CpoFunctionGroups (one per named
CRUD operation group).Plain-data holder for a name and description, the common base for the CPO metadata bean classes
(
CpoClass, CpoArgument, CpoFunctionGroup) that all identify themselves
primarily by name.CpoClass variant whose datastore-name lookups are case-insensitive: attribute data names
are upper-cased before being used as map keys.CpoClass variant whose datastore-name lookups are case-sensitive: attribute data names
are used as map keys exactly as configured.This is a proxy class designed to handle the different classloaders needed when running in a
container as a skinny war versus running from the console.
The CpoClassSourceGenerator generates java source code to define the cpo classes.
CpoData is the binding between a single bean attribute and the mechanics needed to move
its value into and out of the datastore: invoking the bean's getter/setter reflectively and
applying any configured CpoTransform on the way in or out.A
CpoException is the common superclass for any number of CPO related exceptions
that may occur during the execution of a business task.Runtime metadata for a single CPO function: extends
CpoFunctionBean's name/expression/
description with the ordered list of CpoArguments bound to the function's positional bind
markers.Plain-data holder for the fields of a CPO function as loaded from meta XML: its name, native
expression (SQL/CQL), and description.
Runtime metadata for a named group of
CpoFunctions that together implement one CRUD
operation (e.g. all the INSERT functions named "cpo_default") for a CpoClass.Plain-data holder for the fields of a CPO function group as loaded from meta XML: the group's
name (inherited from
CpoClassBean) and its CRUD type (INSERT, RETRIEVE, UPDATE, DELETE,
EXIST, EXECUTE).The CpoInterfaceSourceGenerator generates java source code to define the cpo interfaces.
The CpoClassSourceGenerator generates java source code to define the cpo classes.
CpoMetaAdapter is the datastore-agnostic view over a loaded CPO metadata source: it
resolves the CpoClass for a given bean, exposes the classes it knows about, and bridges
between the datastore's native data type names/ids and their Java equivalents via the
implementation's DataTypeMapper.CpoMetaDescriptor is the runtime, named handle on a loaded CPO metadata source: it owns
the datastore-specific AbstractCpoMetaAdapter that holds the actual CpoClass
metadata, and delegates the CpoMetaAdapter contract to it.Process-wide cache of
CpoMetaDescriptor instances keyed by descriptor name.CpoMetaExportable is implemented by metadata sources that can serialize their loaded
CpoClass metadata back out to a CPO meta XML document.Represents a native (datastore-specific) function expression bound to a marker, for embedding
SQL/CQL functions like
UPPER(?) into a CPO where/order-by clause.CpoOrderBy is an interface for specifying the sort order in which objects are returned from the
Datasource.
The clauses of a
CpoAdapter operation: the function group to run plus any run-time where
constraints, orderings, and native expressions.CpoReleasable is a class that can be called during a CpoTransform when there are resources that
need to released after the current prepared statement is processed.
CpoStatementFactory is the base class that encapsulates the creation of the native statement for
the target datastore from the meta expression, where clauses, and order-by clauses.
CpoTransform converts an attribute's value between the raw form stored/read at the
datastore and the form exposed on the Java bean, e.g. clob-to-string or gzip compression.CpoTrxAdapter adds commit, rollback, and close functionality to the methods already in
CpoAdapter.
`CpoWhere` is an interface for specifying the where clause to filter objects that are returned
from the Datasource.
The XA error codes used by Cpo, mirroring the
int constants declared on XAException so error codes can be passed around as a type-safe enum instead of a bare
int.A JTA
XAResource that additionally allows the resource for a specific transaction branch
to be closed directly, without waiting for commit/rollback/forget.Mutable state tracked for a single XA transaction branch (
Xid): its association state
with a resource manager, its underlying resource, and its success/prepared flags.Simple holder for a
Xid-to-CpoXaState map, one per family of XA resources.The kinds of operation a CPO function group can perform against a datasource.
Interface that defines the methods needed by CPO for any class that collects DataSource info and
instantiates the DataSource
DataTypeMapEntry is a class that defines the mapping of datasource datatypes to java types
Maps datastore data types, identified by either a
java.sql.Types constant or a native
type name, to their DataTypeMapEntry.Static helpers for extracting readable messages from a
Throwable and for normalizing
arbitrary exceptions into CpoException.ExpressionParser extracts bind-marker information from a native (SQL/CQL) function
expression, letting CPO figure out which bean attribute each positional bind marker in the
expression corresponds to.Logical operators for where clauses
Defines that a implementer of this interface allows visits from a MetaVisitor.
This defines a depth first meta visitor.
XmlObject exporter for meta objects
MethodMapEntry is a class defines the getters and setters for JDBC specific data classes
MethodMapper maps java classes to the datastore-specific getter and setter methods used to bind
them.
This is a general Node class to be used to build different types of trees.
This is the interface for the visitors to the Node Hierarchy
Base
CpoData implementation for reading a bound attribute's
value out of a datastore result row (e.g. a JDBC ResultSet or Cassandra Row).Converts a String to a byte[]
Servlet that will output the current state of a meta descriptor in the form of xml.
Static helpers for locating and safely unmarshalling CPO's XML configuration and meta data files.