All Classes

Class	Description
AbsExpression	The ABS function removes the minus sign from a specified argument and returns the absolute value, which is always a positive number or zero.
AbsExpressionFactory	This AbsExpressionFactory creates a new AbsExpression when the portion of the query to parse starts with ABS.
AbsExpressionStateObject	The ABS function removes the minus sign from a specified argument and returns the absolute value, which is always a positive number or zero.
AbsFunctionResolver	This Resolver is responsible to calculate the IType based on the type of the ABS expression.
AbstractActualJPQLQueryFormatter	This IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed, which means this formatter can only be used when the StateObject was created by parsing a JPQL query because it needs to retrieve parsing information from the corresponding Expression.
AbstractCaseExpressionStateObjectBuilder	This abstract implementation of ICaseExpressionStateObjectBuilder adds support for creating a CASE expression.
AbstractColumnMapping	Purpose: Maps an attribute or some other property to the corresponding database field type.
AbstractCompositeCollectionMapping	Define an embedded collection of objects.
AbstractCompositeDirectCollectionMapping	AbstractCompositeDirectCollectionMapping consolidates the behavior of mappings that map collections of "native" data objects (e.g.
AbstractCompositeObjectMapping	Chunks of data from non-relational data sources can have an embedded component objects.
AbstractConditionalClause	Conditional expressions are composed of other conditional expressions, comparison operations, logical operations, path expressions that evaluate to boolean values, boolean literals, and boolean input parameters.
AbstractConditionalClauseStateObject	Conditional expressions are composed of other conditional expressions, comparison operations, logical operations, path expressions that evaluate to boolean values, boolean literals, and boolean input parameters.
AbstractConditionalExpressionStateObjectBuilder<T extends IAbstractConditionalExpressionStateObjectBuilder<T>>	The abstract implementation of IConditionalExpressionStateObjectBuilder that supports the creation of the conditional expression based on the JPQL grammar defined in JPA 2.0.
AbstractConditionalStateObjectBuilderWrapper	This builder wraps another builder and delegates the calls to it.
AbstractContentAssistVisitor	The visitor provides support for finding the possible proposals within a JPQL query at a certain position.
AbstractContentAssistVisitor.AbstractAppendableExpressionVisitor
AbstractContentAssistVisitor.AbstractConditionalClauseCollectionHelper<T extends Expression>	This helper handles adding proposals within a conditional expression that might be parsed as a single expression or has a collection of expression, which means the fragment is either incomplete or invalid.
AbstractContentAssistVisitor.AbstractFromClauseStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AbstractGroupByClauseStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AbstractHavingClauseStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AbstractSelectClauseCollectionHelper<T extends AbstractSelectClause>
AbstractContentAssistVisitor.AbstractSelectClauseStatementHelper
AbstractContentAssistVisitor.AbstractWhereClauseSelectStatementHelper<T extends AbstractSelectStatement>
AbstractContentAssistVisitor.AcceptableTypeVisitor	This visitor retrieves the permitted type from the path expression's parent.
AbstractContentAssistVisitor.AppendableExpressionVisitor	This visitor scans the visited Expression and determines if a JPQL identifier can be added ("appended") when the position of the cursor is at the end of the expression.
AbstractContentAssistVisitor.AppendableType	This is used to determine how AbstractContentAssistVisitor.AppendableExpressionVisitor should perform the check.
AbstractContentAssistVisitor.CollectionExpressionHelper<T extends Expression>	This helper is used to determine how to add proposals within a collection of expressions.
AbstractContentAssistVisitor.CollectionExpressionVisitor	This visitor retrieves the CollectionExpression if it is visited.
AbstractContentAssistVisitor.CollectionMappingFilter
AbstractContentAssistVisitor.ConcatExpressionCollectionHelper
AbstractContentAssistVisitor.ConditionalClauseCollectionHelper	This helpers handles adding proposals for AbstractConditionalClause.
AbstractContentAssistVisitor.ConstrutorCollectionHelper
AbstractContentAssistVisitor.DeclarationVisitor
AbstractContentAssistVisitor.DefaultMappingCollector	The default implementation of AbstractContentAssistVisitor.MappingCollector, which simply returns an empty collection.
AbstractContentAssistVisitor.DeleteClauseCollectionHelper
AbstractContentAssistVisitor.DeleteClauseStatementHelper
AbstractContentAssistVisitor.DifferentComparisonFilter
AbstractContentAssistVisitor.DoubleEncapsulatedCollectionHelper
AbstractContentAssistVisitor.EncapsulatedExpressionVisitor
AbstractContentAssistVisitor.EndingQueryPositionBuilder	This builder populates a QueryPosition by traversing the valid portion of the JPQL query.
AbstractContentAssistVisitor.EnumVisitor	This visitor determines whether a path expression can be resolved as a fully qualified enum type and an enum constant.
AbstractContentAssistVisitor.FilteringMappingCollector	This AbstractContentAssistVisitor.MappingCollector returns the possible mappings (non-collection type or collection type) from a managed type.
AbstractContentAssistVisitor.FollowingClausesVisitor
AbstractContentAssistVisitor.FollowingInvalidExpressionVisitor
AbstractContentAssistVisitor.FromClauseCollectionHelper
AbstractContentAssistVisitor.FromClauseStatementHelper
AbstractContentAssistVisitor.GroupByClauseCollectionHelper
AbstractContentAssistVisitor.GroupByClauseStatementHelper
AbstractContentAssistVisitor.HavingClauseStatementHelper
AbstractContentAssistVisitor.IdentificationVariableType	The various ways of retrieving identification variables from the declaration expression.
AbstractContentAssistVisitor.IncompleteCollectionExpressionVisitor	This visitor is used when a clause or a compound expression was parsed with a collection of expressions representing an invalid fragment.
AbstractContentAssistVisitor.InvalidExpressionVisitor	This visitor determines if the visited Expression is one of the two that represents an invalid expression.
AbstractContentAssistVisitor.JoinCollectionHelper
AbstractContentAssistVisitor.MappingCollector	A collector is responsible to retrieve the possible proposals by using the mappings that can complete a path expression.
AbstractContentAssistVisitor.MappingFilterBuilder	This visitor is responsible to create the right Filter based on the type of the Expression.
AbstractContentAssistVisitor.MappingTypeFilter	This Filter is responsible to filter out the mappings that can't have their type assignable to the one passed in.
AbstractContentAssistVisitor.NotExpressionVisitor
AbstractContentAssistVisitor.OrderByClauseCollectionHelper
AbstractContentAssistVisitor.OrderByClauseStatementHelper
AbstractContentAssistVisitor.PropertyMappingFilter
AbstractContentAssistVisitor.RangeVariableDeclarationVisitor
AbstractContentAssistVisitor.ResultVariableVisitor
AbstractContentAssistVisitor.SelectClauseCollectionHelper
AbstractContentAssistVisitor.SelectClauseStatementHelper
AbstractContentAssistVisitor.SimpleFromClauseStatementHelper
AbstractContentAssistVisitor.SimpleGroupByClauseStatementHelper
AbstractContentAssistVisitor.SimpleHavingClauseStatementHelper
AbstractContentAssistVisitor.SimpleSelectClauseCollectionHelper
AbstractContentAssistVisitor.SimpleSelectClauseStatementHelper
AbstractContentAssistVisitor.SimpleWhereClauseSelectStatementHelper
AbstractContentAssistVisitor.StatementHelper<T extends Expression>	This helper helps to add JPQL identifiers for the clauses that make up a query statement and also chains the clauses within the query.
AbstractContentAssistVisitor.SubqueryAppendableExpressionVisitor
AbstractContentAssistVisitor.SubqueryVisitor	This visitor determines if an Expression is in a subquery.
AbstractContentAssistVisitor.TripleEncapsulatedCollectionHelper
AbstractContentAssistVisitor.UpdateClauseStatementHelper
AbstractContentAssistVisitor.UpdateItemCollectionHelper
AbstractContentAssistVisitor.VisitParentVisitor	This visitor is meant to adjust the corrections stack when traversing an Expression in order to increase the list of valid proposals.
AbstractContentAssistVisitor.WhenClauseConditionalClauseCollectionHelper	This helpers handles adding proposals for WhenClause.
AbstractContentAssistVisitor.WhereClauseDeleteStatementHelper
AbstractContentAssistVisitor.WhereClauseSelectStatementHelper
AbstractContentAssistVisitor.WhereClauseUpdateStatementHelper
AbstractContentAssistVisitor.WithinInvalidExpressionVisitor
AbstractCopyPolicy	Purpose: Allows customization of how an object is cloned.
AbstractDirectMapping	Purpose: Maps an attribute to the corresponding database field type.
AbstractDoubleEncapsulatedExpression	This Expression takes care of parsing an expression that encapsulates two expressions separated by a comma.
AbstractDoubleEncapsulatedExpressionStateObject	This StateObject represents a JPQL expression that has a JPQL identifier followed by two an encapsulated expression with parenthesis, the two expression are separated by a comma.
AbstractEclipseLinkExpressionVisitor	The abstract implementation of EclipseLinkExpressionVisitor.
AbstractEclipseLinkParameterTypeVisitor	This visitor calculates the type of an input parameter.
AbstractEclipseLinkSelectExpressionStateObjectBuilder
AbstractEclipseLinkSemanticValidator	This validator is responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid for EclipseLink.
AbstractEclipseLinkSemanticValidator.EclipseLinkOwningClauseVisitor	This visitor retrieves the clause owning the visited Expression.
AbstractEclipseLinkSemanticValidator.SubquerySelectItemCalculator
AbstractEclipseLinkSemanticValidator.TableExpressionVisitor
AbstractEclipseLinkSemanticValidator.TopLevelFirstDeclarationVisitor
AbstractEclipseLinkSimpleSelectExpressionStateObjectBuilder
AbstractEclipseLinkStateObjectVisitor	The abstract definition of EclipseLinkStateObjectVisitor, which implements all the methods but does nothing.
AbstractEclipseLinkTraverseChildrenVisitor	This ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given Expression.
AbstractEclipseLinkTraverseChildrenVisitor	This StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given StateObject.
AbstractEclipseLinkTraverseParentVisitor	This EclipseLinkExpressionVisitor traverses up the hierarchy.
AbstractEclipseLinkTraverseParentVisitor	This StateObjectVisitor traverses up the hierarchy.
AbstractEncapsulatedExpression	This expression handles parsing the identifier followed by an expression encapsulated within parenthesis.
AbstractEncapsulatedExpressionStateObject	This expression handles parsing the identifier followed by an expression encapsulated within parenthesis.
AbstractEntityResource	Base class for entity resource.
AbstractExceptionMapper
AbstractExpression	This is the abstract definition of all the parts used to create the tree hierarchy representing the parsed JPQL query.
AbstractExpressionVisitor	The abstract definition of ExpressionVisitor, which implements all the methods but does nothing.
AbstractFromClause	The FROM clause of a query defines the domain of the query by declaring identification variables.
AbstractFromClauseStateObject	This state object represents the abstract definition of a FROM clause, which is either the FROM clause of the query or of a sub-query expression.
AbstractGrammarValidator	The base validator responsible to gather the problems found in a JPQL query by validating it against the provided JPQL grammar.
AbstractGrammarValidator.AbstractCollectionValidator	This validate is responsible to validate the collection of Expressions: Making sure they are all separated by a comma or by a space (depending on which one is required); Making sure it does not end with a comma; There is no empty expression between two commas.
AbstractGrammarValidator.AbstractDoubleEncapsulatedExpressionHelper<T extends AbstractDoubleEncapsulatedExpression>
AbstractGrammarValidator.AbstractEncapsulatedExpressionHelper<T extends AbstractEncapsulatedExpression>	The root helper that validates any AbstractEncapsulatedExpression.
AbstractGrammarValidator.AbstractSingleEncapsulatedExpressionHelper<T extends AbstractSingleEncapsulatedExpression>	The abstract implementation of AbstractGrammarValidator.AbstractSingleEncapsulatedExpressionHelper which implements some of the methods since the behavior is the same for all subclasses of AbstractSingleEncapsulatedExpression.
AbstractGrammarValidator.AbstractTripleEncapsulatedExpressionHelper<T extends AbstractTripleEncapsulatedExpression>
AbstractGrammarValidator.CollectionExpressionVisitor	This visitor retrieves the CollectionExpression if it is visited.
AbstractGrammarValidator.CollectionSeparatedByCommaValidator	This validator validates a CollectionExpression by making sure each item is separated by a comma.
AbstractGrammarValidator.CollectionSeparatedBySpaceValidator	This validator validates a CollectionExpression by making sure each item is not separated by a comma.
AbstractGrammarValidator.ComparisonExpressionVisitor
AbstractGrammarValidator.DateTimeVisitor
AbstractGrammarValidator.NullExpressionVisitor	This visitor checks to see if the visited expression is NullExpression.
AbstractIdentificationVariableDeclarationStateObject
AbstractJPQLGrammar	The abstract definition of a JPQLGrammar.
AbstractJPQLQueryBuilder	An abstract implementation of IJPQLQueryBuilder that parses a JPQL query or any JPQL fragments and creates the StateObject representation by delegating the creation to an instance of BasicStateObjectBuilder.
AbstractJPQLQueryFormatter	The abstract definition of a IJPQLQueryFormatter, which converts an StateObject into its string representation that can be used as a real JPQL query.
AbstractJPQLQueryHelper	This helper can perform the following operations over a JPQL query: Calculates the result type of a query: AbstractJPQLQueryHelper.getResultType(); Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String). Calculates the possible choices to complete the query from a given position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int). Validates the query by introspecting it grammatically and semantically: AbstractJPQLQueryHelper.validate(), AbstractJPQLQueryHelper.validateGrammar(), AbstractJPQLQueryHelper.validateSemantic(). Refactoring support: AbstractJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the refactoring operation through a collection of TextEdit objects. AbstractJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through the editable StateObject and once all refactoring operations have been executed, the IJPQLQueryFormatter will generate a new string representation of the JPQL query.
AbstractListHolderStateObject<T extends StateObject>	The abstraction definition of a StateObject that holds onto a list of children, the methods defined in ListHolderStateObject are automatically handled here.
AbstractLiteralExpressionFactory	This factory is responsible to return the right literal expression.
AbstractMarshallerImpl	Partial default Marshaller implementation.
AbstractModifyClauseStateObject
AbstractModifyStatementStateObject	The abstract definition of a modify statement.
AbstractNewValueStateObjectBuilder
AbstractNullPolicy	PUBLIC: Description: This node null policy allows for the handling of various representations of null in XML documents.
AbstractOrderByClause	An ordering clause allows the objects or values that are returned by the query to be ordered.
AbstractPathExpression	An identification variable followed by the navigation operator (.) and a state field or association field is a path expression.
AbstractPathExpressionStateObject	An identification variable followed by the navigation operator (.) and a state field or association field is a path expression.
AbstractPathResolver	This Resolver is responsible to resolve a single path of a path expression (state field path expression, singled valued object field, or a collection-valued path expression).
AbstractPersistenceResource	Base class for persistent unit resources.
AbstractPersistenceUnitResource
AbstractQuery<T>	The AbstractQuery interface defines functionality that is common to both top-level queries and subqueries.
AbstractQueryResource	Base class for query resource.
AbstractRangeDeclaration	The abstract definition of a range declaration, which is used to navigate to a "root" object.
AbstractRangeVariableDeclarationStateObject
AbstractRefactoringTool	The abstract definition of a refactoring
AbstractResource	Base class for all resources.
AbstractScalarExpressionStateObjectBuilder<T extends IScalarExpressionStateObjectBuilder<T>>	This abstract definition of a builder provides the support for creating expressions defined by a scalar expression.
AbstractSchemaName	An abstract schema name designates the abstract schema type over which the query ranges.
AbstractSchemaNameBNF	The query BNF for an abstract schema name.
AbstractSchemaNameFactory	This AbstractSchemaNameFactory creates a new AbstractSchemaName.
AbstractSchemaNameStateObject	An abstract schema name designates the abstract schema type over which the query ranges.
AbstractSelectClause	The SELECT clause denotes the query result.
AbstractSelectClauseStateObject	This state object represents the abstract definition of a SELECT clause, which is either the SELECT clause of the top-level query or of a subquery.
AbstractSelectExpressionStateObjectBuilder
AbstractSelectStatement	A query is an operation that retrieves data from one or more tables or views.
AbstractSelectStatementStateObject	This state object represents the select statement, which has at least a SELECT clause and a FROM clause.
AbstractSemanticValidator	The base validator responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid, i.e. based on the information contained in the JPA application.
AbstractSemanticValidator.CollectionValuedPathExpressionVisitor	This visitor is meant to retrieve an CollectionValuedPathExpression if the visited Expression is that object.
AbstractSemanticValidator.ComparingEntityTypeLiteralVisitor
AbstractSemanticValidator.ComparisonExpressionVisitor	This visitor compares the left and right expressions of a comparison expression and gathers information about those expressions if they are an identification variable or a path expression.
AbstractSemanticValidator.FirstDeclarationVisitor
AbstractSemanticValidator.InItemsVisitor
AbstractSemanticValidator.PathType	This enumeration allows AbstractSemanticValidator.validateStateFieldPathExpression( StateFieldPathExpression, PathType) to validate the type of the mapping and to make sure it is allowed based on its location.
AbstractSemanticValidator.StateFieldPathExpressionVisitor	This visitor is meant to retrieve an AbstractSemanticValidator.StateFieldPathExpressionVisitor if the visited Expression is that object.
AbstractSemanticValidator.SubqueryFirstDeclarationVisitor
AbstractSemanticValidator.TopLevelFirstDeclarationVisitor
AbstractSerializer	Abstract Serializer class.
AbstractSessionLog	Represents the abstract log that implements all the generic logging functions.
AbstractSimpleSelectExpressionStateObjectBuilder	The abstract implementation of ISimpleSelectExpressionStateObjectBuilder that supports the creation of the select expression based on the JPQL grammar defined in JPA 2.0.
AbstractSingleEncapsulatedExpression	This expression handles parsing a JPQL identifier followed by an expression encapsulated within parenthesis.
AbstractSingleEncapsulatedExpressionStateObject	This StateObject represents a JPQL expression that has a JPQL identifier followed by an encapsulated expression with parenthesis.
AbstractSingleResultQueryResource	Base class for all single result query resources.
AbstractStateObject	The abstract definition of a StateObject.
AbstractStateObjectBuilder	The abstract definition of a builder of a StateObject hierarchy based on a JPQL fragment that is manually created.
AbstractStateObjectVisitor	The abstract definition of StateObjectVisitor, which implements all the methods but does nothing.
AbstractSynchronizationListener	Purpose: Abstract Synchronization Listener class Description: This abstract class is paired with the AbstractTransactionController class.
AbstractTransactionController	Purpose: Abstract implementation of an ExternalTransactionController.
AbstractTransformationMapping	Purpose: A transformation mapping is used for a specialized translation between how a value is represented in Java and its representation on the databae.
AbstractTraverseChildrenVisitor	This ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given Expression.
AbstractTraverseChildrenVisitor	This StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given StateObject.
AbstractTraverseParentVisitor	This ExpressionVisitor traverses up the hierarchy.
AbstractTraverseParentVisitor	This StateObjectVisitor traverses up the hierarchy.
AbstractTripleEncapsulatedExpression	This Expression takes care of parsing an expression that encapsulates three expressions separated by a comma.
AbstractTripleEncapsulatedExpressionStateObject	This state object takes care of parsing an expression that encapsulates three expressions separated by a comma.
AbstractUnmarshallerImpl	Partial default Unmarshaller implementation.
AbstractValidator	The abstract definition of a validator, which provides helper methods and visitors.
AbstractValidator.BypassChildCollectionExpressionVisitor	This visitor is responsible to traverse the children of a CollectionExpression in order to properly validate the Expression.
AbstractValidator.BypassParentSubExpressionVisitor	This visitor is responsible to traverse the parent hierarchy and to skip SubExpression if it's a parent.
AbstractValidator.ChildrenCollectorVisitor	This visitor gathers the children of a CollectionExpression or a single visited Expression.
AbstractValidator.JPQLQueryBNFValidator	This visitor validates any Expression by checking its BNF against some BNFs.
AbstractValidator.NestedArrayVisitor
AbstractValidator.OwningClauseVisitor	This visitor retrieves the clause owning the visited Expression.
AbstractValidator.OwningStatementVisitor	This visitor retrieves the statement owning the visited Expression.
AbstractValidator.SubqueryVisitor	This visitor retrieves the statement owning the visited Expression.
Access	Used to specify an access type to be applied to an entity class, mapped superclass, or embeddable class, or to a specific attribute of such a class.
AccessMethods	JPA scripting API implementation.
AccessPlatform	Purpose: Provides Microsoft Access specific behavior.
AccessType	Used with the Access annotation to specify an access type to be applied to an entity class, mapped superclass, or embeddable class, or to a specific attribute of such a class.
AdditionalCriteria	An additional criteria can be specified at the Entity or MappedSuperclass level.
AdditionalCriteria	JPA scripting API implementation.
AdditionExpression	One of the four binary operators.
AdditionExpressionStateObject	TODO: BNF: arithmetic_expression ::= arithmetic_expression + arithmetic_term
AggregateChangeRecord	Purpose: Define the Public interface for the Aggregate Change Record.
AggregateCollectionChangeRecord	Purpose: Define the Public interface for the Aggregate Collection Change Record.
AggregateCollectionMapping	Purpose: The aggregate collection mapping is used to represent the aggregate relationship between a single source object and a collection of target objects.
AggregateExpressionBNF	The query BNF for an aggregate expression.
AggregateFunction	In the SELECT clause the result of a query may be the result of an aggregate function applied to a path expression.
AggregateFunctionStateObject	In the SELECT clause the result of a query may be the result of an aggregate function applied to a path expression.
AggregateMapping	Purpose: Two objects can be considered to be related by aggregation if there is a strict 1:1 relationship between the objects.
AggregateObjectMapping	Purpose:Two objects can be considered to be related by aggregation if there is a strict 1:1 relationship between the objects.
AllFieldsLockingPolicy	Purpose: An implementation of the OptimisticLockingPolicy interface.
AllOrAnyExpression	An ALL conditional expression is a predicate that is true if the comparison operation is true for all values in the result of the subquery or the result of the subquery is empty.
AllOrAnyExpressionBNF	The query BNF for an all or any expression.
AllOrAnyExpressionFactory	This AllOrAnyExpressionFactory creates a new AllOrAnyExpression when the portion of the query to parse starts with ALL, ANY or SOME.
AllOrAnyExpressionStateObject	An ALL conditional expression is a predicate that is true if the comparison operation is true for all values in the result of the subquery or the result of the subquery is empty.
AndExpression	The AND logical operator chains multiple criteria together.
AndExpressionFactory	This AndExpression creates a new AdditionExpression when the portion of the query to parse starts with AND.
AndExpressionStateObject	The AND logical operator chains multiple criteria together.
AndFilter<T>	This filter will "accept" any object that is accept by both of the specified wrapped filters.
AnnotationHelper	Purpose:Provide a class which is responsible for returning Annotations from AnnotatedElements.
AnnotationProxy	Purpose:The purpose of this class is to act as a dynamic proxy that allows JDK Annotation method calls to be made on a non Annotation object.
AnnotationsProcessor	INTERNAL:
AnonymousExpressionVisitor	This visitor allows a subclass to simply override AnonymousExpressionVisitor.visit(Expression) and perform the same task for all visited expressions.
AnonymousStateObjectVisitor	This visitor allows a subclass to simply override AnonymousStateObjectVisitor.visit(StateObject) and perform the same task for all visited ItateObjects.
AnonynousEclipseLinkStateObjectVisitor	This visitor allows a subclass to simply override AnonymousStateObjectVisitor.visit(StateObject) and perform the same task for all visited ItateObjects.
ANTLRQueryBuilder	Deprecated. replaced with Hermes parser, which is the default.
AppendNewElementsOrderingPolicy	INTERNAL:
Archive	Provides an abstraction to deal with various kinds of URLs that can be returned by PersistenceUnitInfo.getPersistenceUnitRootUrl()
ArchiveFactory	This interface should be implemented by users that want to provide a custom way of dealing with archives that contain persistence units.
ArithmeticExpression	This expression represents an arithmetic expression, which means the first and second expressions are aggregated with an arithmetic sign.
ArithmeticExpressionBNF	The query BNF for an arithmetic expression.
ArithmeticExpressionFactory	This ExpressionFactory creates a new expression when the portion of the query to parse starts with an arithmetic identifier.
ArithmeticExpressionStateObject	This expression represents an arithmetic expression, which means the first and second expressions are aggregated with an arithmetic sign.
ArithmeticFactor	This expression simply adds a plus or minus sign to the arithmetic primary expression.
ArithmeticFactorBNF	The query BNF for an arithmetic factor expression.
ArithmeticFactorStateObject	This state object simply adds a plus or minus sign to the arithmetic primary expression.
ArithmeticPrimaryBNF	The query BNF for an arithmetic primary expression.
ArithmeticTermBNF	The query BNF for an arithmetic term expression.
Array	Array types are extended object-relational data-types supported by some databases.
Array	JPA scripting API implementation.
ArrayCollectionMapping	Interface used by the ArrayCollectionMappingHelper to interact with the assorted array collection mappings.
ArrayCollectionMappingHelper	Helper class to consolidate all the heinous comparing and merging code for the Array collection mappings.
ArrayIterable<E>	An ArrayIterable provides an Iterable for an array of objects of type E.
ArrayIterator<E>	An ArrayIterator provides a Iterator for an array of objects.
ArrayMapping	Purpose: In an object-relational data model, structures can contain "Arrays" or collections of other data-types.
AsOfClause	Purpose:Wraps an immutable value for a past time.
AsOfClause	An AS OF clause is part of a flashback query, which provides ways to view past states of database objects, or to return database objects to a previous state, without using traditional point-in-time recovery.
AsOfClauseBNF	The query BNF for the AS OF clause.
AsOfClauseFactory	This AsOfClauseFactory creates a new AsOfClause when the portion of the JPQL query to parse starts with AS OF.
AsOfSCNClause	Purpose:Wraps an immutable value for a past time, represented as a database system change number.
Assert	An utility class that provides various checks and when the condition fails, then an Assert.AssertException is thrown.
Assert.AssertException	The exception thrown when the condition is not met.
Association	Purpose: Generic association object.
AssociationOverride	Used to override a mapping for an entity relationship.
AssociationOverride	JPA scripting API implementation.
AssociationOverrides	Used to override mappings of multiple relationship properties or fields.
AttachmentMarshaller	Enable JAXB marshalling to optimize storage of binary data.
AttachmentMarshallerAdapter	INTERNAL:
AttachmentUnmarshaller	Enables JAXB unmarshalling of a root document containing optimized binary data formats.
AttachmentUnmarshallerAdapter	INTERNAL:
Attribute<X,Y>	Represents an attribute of a Java type.
Attribute.PersistentAttributeType
AttributeAccessor	Purpose: This provides an abstract class for setting and retrieving the attribute value for the mapping from an object.
AttributeChangeTrackingPolicy	PUBLIC: An AttributeChangeTrackingPolicy allows change tracking at the attribute level of an object by implementing ChangeTracker.
AttributeConverter<X,Y>	A class that implements this interface can be used to convert entity attribute state into database column representation and back again.
AttributeGroup	Purpose: An AttributeGroup represents a set of mappings and nested AttributeGroups for relationship mappings for an entity type.
AttributeNode<T>	Represents an attribute node of an entity graph.
AttributeNode	Represents an AttributeNode of an entity graph.
AttributeOverride	Used to override the mapping of a Basic (whether explicit or default) property or field or Id property or field.
AttributeOverride	JPA scripting API implementation.
AttributeOverrides	Used to override mappings of multiple properties or fields.
AttributeTransformer	PUBLIC:
AttributeTransformerAdapter	Purpose: Provides an empty implementation of AttributeTransformer.
AttunityPlatform	TopLink Platform class which works with Attunity's Connect JDBC driver.
AvgFunction	One of the aggregate functions.
AvgFunctionFactory	This AvgFunctionFactory creates a new AvgFunction when the portion of the query to parse starts with AVG.
AvgFunctionStateObject	One of the aggregate functions.
BadExpression	This wraps another Expression that was correctly parsed by it is located in an invalid location within the JPQL query.
BadExpressionBNF	The query BNF used for an expression that is invalid.
BadExpressionFactory	This BadExpressionFactory creates a new BadExpression when the portion of the query to parse is malformed.
BadExpressionStateObject	This wraps an invalid portion of the JPQL query that could not be parsed.
BaseDeclarationIdentificationVariableFinder	This visitor traverses the parsed tree and retrieves the IdentificationVariable defined in the base range variable declaration for the top-level statement if and only if the query is a DELETE or UPDATE query.
BaseJPQLQueryFormatter	An abstract implementation of a IJPQLQueryFormatter.
Basic	The simplest type of mapping to a database column.
Basic	JPA scripting API implementation.
BasicCollection	Deprecated.
BasicMap	Deprecated.
BasicRefactoringTool	The abstract implementation providing refactoring support for JPQL queries.
BasicRefactoringTool.JavaQuery	A simple implementation of IQuery.
BasicStateObjectBuilder	The default implementation of a IBuilder, which creates a StateObject representation of the Expression being visited.
BasicStateObjectBuilder.CollectionExpressionVisitor
BasicStateObjectBuilder.CollectionMemberDeclarationBuilder
BasicType<X>	Instances of the type BasicType represent basic types (including temporal and enumerated types).
BatchFetch	A BatchFetch annotation can be used on any relationship mapping, (OneToOne, ManyToOne, OneToMany, ManyToMany, ElementCollection, BasicCollection, BasicMap).
BatchFetch	JPA scripting API implementation.
BatchFetchPolicy	BatchFetchPolicy defines batch reading configuration.
BatchFetchType	Enum used with the BatchFetch annotation, or "eclipselink.batch.type" query hint.
BatchWriting	Specify the use of batch writing to optimize transactions with multiple writes, by default batch writing is not used.
BeanValidationChecker	Helper class.
BeanValidationException	BeanValidationException should be used to represent any exception that happens during Bean Validation in MOXy.
BeanValidationExceptionResource	INTERNAL: English ResourceBundle for BeanValidationException messages.
BeanValidationHelper	INTERNAL: Asynchronously starts validation.xml file processing when created.
BeanValidationMode
BeanValidationPlugin	XJC Plugin for generation of JSR349 (Bean Validation) annotations.
BetweenExpression	Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values.
BetweenExpressionBNF	The query BNF for the between expression.
BetweenExpressionFactory	This BetweenExpressionFactory creates a new BetweenExpression when the portion of the query to parse starts with BETWEEN or NOT BETWEEN.
BetweenExpressionStateObject	Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values.
BidirectionalPolicy	Purpose: Provides a means to configure bidirectional relationship maintenance for OXM mappings.
Bindable<T>	Instances of the type Bindable represent object or attribute types that can be bound into a Path.
Bindable.BindableType
Binder<XmlNode>	Enable synchronization between XML infoset nodes and JAXB objects representing same XML document.
BooleanExpressionBNF	The query BNF for a boolean expression.
BooleanLiteralBNF	The query BNF for a boolean literal expression.
BooleanPrimaryBNF	The query BNF for a boolean primary expression.
BroadcastTransportManager	Purpose: Base class transport manager for broadcasting RCM protocols: JMS and Oc4jJGroups.
Cache	Interface used to interact with the second-level cache.
Cache	The Cache annotation is used to configure the EclipseLink object cache.
Cache	JPA scripting API implementation.
Cacheable	Specifies whether an entity should be cached if caching is enabled when the value of the persistence.xml caching element is ENABLE_SELECTIVE or DISABLE_SELECTIVE.
CacheCoordinationProtocol	Cache coordination protocol persistence property values.
CacheCoordinationType	An enum that is used within the Cache annotation.
CacheIndex	Allow a cache index to be define.
CacheIndex	Purpose: Define a secondary index on the cache.
CacheIndex	JPA scripting API implementation.
CacheIndexes	Allow a set of cache indexes to be define on an Entity.
CacheInterceptor	A CacheInterceptor can be set on an Entity and allows all EclipseLink cache access to be intercepted by the developer provided interceptor.
CacheInterceptor	JPA scripting API implementation.
CacheInterceptor	Purpose: Define a class through which Cache access can be intercepted.
CacheInvalidationPolicy	PUBLIC: A CacheInvalidationPolicy is used to set objects in TopLink's identity maps to be invalid following given rules.
CacheIsolationType	Options for how Entity instances should be shared within an EclipseLink Persistence Unit / ServerSession
CacheKeyInterceptor	The CacheKeyInterceptor allows a Cache Interceptor implementation to wrap the EclipseLink CacheKey.
CacheKeyType	Configures what type of Id value is used to store the object in the cache.
CachePolicy	Purpose: CachePolicy defines the cache configuration.
CacheRetrieveMode	Used as the value of the javax.persistence.cache.retrieveMode property to specify the behavior when data is retrieved by the find methods and by queries.
CacheStoreMode	Used as the value of the javax.persistence.cache.storeMode property to specify the behavior when data is read from the database and when data is committed into the database.
CacheType	The CacheType enum is used with the Cache annotation for a persistent class.
CacheType	Cache type persistence property values.
CacheUsage	Cache usage hint values.
CacheUsageIndirectionPolicy	In-memory querying and conforming indirection policy.
Call	Call defines the interface used primarily by EclipseLink queries and query mechanisms to perform the necessary actions (read, insert, update, delete) on the data store.
Cascade	JPA scripting API implementation.
CascadeOnDelete	Define the foreign key defined by the relationship to cascade the delete on the database.
CascadePolicy	Cascade policy hint values.
CascadeType	Defines the set of cascadable operations that are propagated to the associated entity.
CaseExpression	BNF: general_case_expression ::= CASE when_clause {when_clause}* ELSE scalar_expression END or BNF: simple_case_expression ::= CASE case_operand simple_when_clause {simple_when_clause}* ELSE scalar_expression END
CaseExpressionBNF	The query BNF for a case expression.
CaseExpressionFactory	This CaseExpressionFactory creates a new CaseExpression when the portion of the query to parse starts with CASE.
CaseExpressionStateObject	A CASE predicate is used to calculate a condition and when it's true, its THEN expression will be executed.
CaseOperandBNF	The query BNF for the case operand specified in the case expression.
CastExpression	The CAST function cast value to a different type.
CastExpressionBNF	The query BNF for the CAST function.
CastExpressionFactory	This CastExpressionFactory creates a new CastExpression when the portion of the query to parse starts with CAST.
ChangedFieldsLockingPolicy	Purpose: An implementation of the OptimisticLockingPolicy interface.
ChangeListener	A ChangeListener is used to extend a PersistenceContext to react to database sent change events.
ChangeRecord	Purpose: Define the base Change Record API.
ChangeSupport	This ChangeSupport is responsible to notifies registered listeners upon changes made to a StateObject, those changes are either a property has changed (IPropertyChangeListener) or the content of a list has changed (IListChangeListener).
ChangeTracker	Purpose: Define an interface for any object that wishes to use attribute change tracking.
ChangeTracking	The ChangeTracking annotation is used to specify the org.eclipse.persistence.descriptors.changetracking.ObjectChangePolicy which computes changes sets for EclipseLink's UnitOfWork commit process.
ChangeTracking	JPA scripting API implementation.
ChangeTrackingType	An enum that is used within the ChangeTracking annotation.
CharacterEscapeHandler	Provide an interface to allow for custom character escaping behaviour.
ClassDescriptor	Purpose: Abstract descriptor class for defining persistence information on a class.
ClassExtractor	A ClassExtractor allows for a user defined class indicator in place of providing a discriminator column.
ClassExtractor	Purpose: Abstract class to allow complex inheritance support.
ClassInstanceConverter	Purpose: Allows a class name to be converted to and from a new instance of the class.
ClassNameResolver	This Resolver simply holds onto the fully qualified class name of the IType.
ClassResolver	This Resolver simply holds onto the actual type since it is already determined.
ClassSummaryDetail	The class is used internally by the Portable JMX Framework to convert model specific classes into Open Types so that the attributes of model class can be exposed by MBeans.
ClassSummaryDetail	The class is used internally by the Portable JMX Framework to convert model specific classes into Open Types so that the attributes of model class can be exposed by MBeans.
ClassSummaryDetail	The class is used internally by the Portable JMX Framework to convert model specific classes into Open Types so that the attributes of model class can be exposed by MBeans.
ClassSummaryDetail	The class is used internally by the Portable JMX Framework to convert model specific classes into Open Types so that the attributes of model class can be exposed by MBeans.
ClassSummaryDetailBase	The class is used internally by the Portable JMX Framework to convert model specific classes into Open Types so that the attributes of model class can be exposed by MBeans.
ClassTransformer	A persistence provider supplies an instance of this interface to the PersistenceUnitInfo.addTransformer method.
ClientSession	Purpose: Acts as a client to the server session.
CloneCopyPolicy	A CloneCopyPolicy is used to set an org.eclipse.persistence.descriptors.copying.CloneCopyPolicy on an Entity.
CloneCopyPolicy	Purpose: Allows a clone of an object to be created with a method that returns the cloned object.
CloneCopyPolicy	JPA scripting API implementation.
CloneIterable<E>	Pull together remover state and behavior for subclasses.
CloneIterator<E>	A CloneIterator iterates over a copy of a collection, allowing for concurrent access to the original collection.
CloneIterator.Remover<T>	Used by CloneIterator to remove elements from the original collection; since the iterator does not have direct access to the original collection.
CloneIterator.Remover.ReadOnly<S>
CloneListIterable<E>	Pull together mutator state and behavior for subclasses.
CloneListIterator<E>	A CloneListIterator iterates over a copy of a list, allowing for concurrent access to the original list.
CloneListIterator.Mutator<T>	Used by CloneListIterator to remove elements from the original list; since the list iterator does not have direct access to the original list.
CloneListIterator.Mutator.ReadOnly<S>
CloudscapePlatform	Purpose: Provides CloudScape DBMS specific behavior.
CMPPolicy	Description: Place holder for CMP specific information.
CMPPolicy.KeyElementAccessor	INTERNAL: This is the interface used to encapsulate the the type of key class element
CMPPolicy.KeyIsElementAccessor	INTERNAL: This class will be used when the keyClass is a primitive
CoalesceExpression	A COALESCE expression returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
CoalesceExpressionBNF	The query BNF for a coalesce expression.
CoalesceExpressionFactory	This CoalesceExpressionFactory creates a new CoalesceExpression when the portion of the query to parse starts with COALESCE.
CoalesceExpressionStateObject	A COALESCE expression returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
CollapsedStringAdapter	Built-in XmlAdapter to handle xs:token and its derived types.
CollectionAttribute<X,E>	Instances of the type CollectionAttribute represent persistent java.util.Collection-valued attributes.
CollectionChangeEvent	Purpose: Define a change event for collection types.
CollectionChangeRecord	Purpose: This interface defines the API for the changeRecord that maintains the changes made to a collection attribute of an object.
CollectionChangeTracker	Purpose: Define an interface for any collection that wishes to use attribute change track.
CollectionDeclaration	This CollectionDeclaration represents a collection member declaration that was declared in the FROM clause of a SELECT top-level query or subquery.
CollectionEquivalentResolver	This Resolver compares each IType retrieved from the list of Resolvers that were gathered for a given Expression and returns that type if they are all the same type otherwise the IType for Object is returned.
CollectionExpression	A CollectionExpression wraps many expression which they are separated by spaces and/or commas.
CollectionExpressionStateObject	This StateObject is a temporary object used to store a list of StateObjects.
CollectionJoin<Z,E>	The CollectionJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.Collection.
CollectionMapping	Purpose: Abstract class for relationship mappings which store collection of objects
CollectionMemberDeclaration	An identification variable declared by a collection member declaration ranges over values of a collection obtained by navigation using a path expression.
CollectionMemberDeclarationBNF	The query BNF for a collection member declaration expression.
CollectionMemberDeclarationFactory	This CollectionMemberDeclarationFactory creates a new CollectionMemberDeclaration when the portion of the query to parse starts with IN.
CollectionMemberDeclarationStateObject	An identification variable declared by a collection_member_declaration ranges over values of a collection obtained by navigation using a path expression.
CollectionMemberExpression	This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression.
CollectionMemberExpressionBNF	The query BNF for a collection member expression.
CollectionMemberExpressionFactory	This CollectionMemberExpressionFactory creates a new CollectionMemberExpression when the portion of the query to parse starts with MEMBER, MEMBER OF, NOT MEMBER or NOT MEMBER OF.
CollectionMemberExpressionStateObject	This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression.
CollectionProxy	JPARS 2.0 collection proxy interface.
CollectionTable	Specifies the table that is used for the mapping of collections of basic or embeddable types.
CollectionTable	Deprecated.
CollectionTable	JPA scripting API implementation.
CollectionTools	This utility class provides utility methods related to collections, iterators and arrays.
CollectionValuedFieldResolver	This Resolver is responsible to resolve the type of a collection-valued field.
CollectionValuedFieldResolver.MapManagedType
CollectionValuedPathExpression	A collection_valued_field is designated by the name of an association field in a one-to-many or a many-to-many relationship or by the name of an element collection field.
CollectionValuedPathExpressionBNF	The query BNF for a collection-valued path expression.
CollectionValuedPathExpressionFactory
CollectionValuedPathExpressionStateObject	A collection-valued field is designated by the name of an association field in a one-to-many or a many-to-many relationship or by the name of an element collection field.
CollectionWrapperBuilder	Helper class used to create proxies for collections.
CollectionWrapperMetadataSource	Makes the CollectionWrapper class available in our Dynamic JAXB context.
Column	Specifies the mapped column for a persistent property or field.
Column	JPA scripting API implementation.
ColumnResult	Used in conjunction with the SqlResultSetMapping annotation or ConstructorResult annotation to map a column of the SELECT list of a SQL query.
ColumnResult	JPA scripting API implementation.
ColumnResult	Purpose: Concrete class to represent the ColumnResult structure as defined by the EJB 3.0 Persistence specification.
Command	Purpose: Provide an extendable framework class for a Command object that can be remotely executed.
CommandConverter	Purpose: Define a pluggable conversion interface that can be supplied by the application
CommandManager	Purpose: Provide an interface that clients can use to invoke remote commands on other EclipseLink instances, or on other applications that may want to receive and process EclipseLink commands.
CommandProcessor	Purpose: Defines a pluggable interface for EclipseLink sessions and EclipseLink applications to be able to be on the receiving end of EclipseLink command objects.
CommitOrderType	Commit order type persistence property values.
CommonAbstractCriteria	The CommonAbstractCriteria interface defines functionality that is common to both top-level criteria queries and subqueries as well as to update and delete criteria operations.
CommunicationException	Purpose:This exception wraps all RMI or CORBA or IO exception that may occur.
CommunicationExceptionResource	INTERNAL: English ResourceBundle for CommunicationException messages.
ComparisonExpression	Only the values of like types are permitted to be compared.
ComparisonExpressionBNF	The query BNF for a comparison expression.
ComparisonExpressionFactory	This ComparisonExpressionFactory creates a new ComparisonExpression when the portion of the query to parse starts with <, >, <>, <=, >= or =.
ComparisonExpressionStateObject	Only the values of like types are permitted to be compared.
CompilerHelper	Helper class for code that needs to be shared between AnnotationsProcessor, MappingsGenerator, SchemaGenerator
ComplexQueryResult	Purpose: Used to return multiple sets of information from a query.
CompositeMember	A CompositeMember annotation is ignored unless is in composite member persistence unit.
CompoundExpression	A compound expression has a left and right expressions combined by an identifier.
CompoundExpressionStateObject	A compound StateObject has a left and right expressions combined by an identifier.
CompoundFilter<T>	This filter provides a simple framework for combining the behavior of a pair of filters.
CompoundSelection<X>	The CompoundSelection interface defines a compound selection item (tuple, array, or result of constructor).
ConcatExpression	The CONCAT function returns a string that is a concatenation of its arguments.
ConcatExpressionFactory	This ConcatExpressionFactory creates a new ConcatExpression when the portion of the query to parse starts with CONCAT.
ConcatExpressionStateObject	The CONCAT function returns a string that is a concatenation of its arguments.
ConcreteSubclassFactory	Factory class to create concrete subclasses of abstract classes.
ConcurrencyException	Purpose: Concurrency deadlock or interupts will raise this exception.
ConcurrencyExceptionResource	INTERNAL: English ResourceBundle for ConcurrencyException messages.
ConditionalExpressionBNF	The query BNF for a conditional expression.
ConditionalFactorBNF	The query BNF for a conditional factor expression.
ConditionalPrimaryBNF	The query BNF for a conditional primary expression.
ConditionalTermBNF	The query BNF for a conditional term expression.
ConnectByClause	The CONNECT BY clause allows selecting rows in a hierarchical order using the hierarchical query clause.
ConnectByClauseBNF	The query BNF for a CONNECT BY clause.
ConnectByClauseFactory	This ConnectByClauseFactory creates a new ConnectByClause when the portion of the query to parse starts with CONNECT BY.
ConnectionPolicy	Purpose: Used to specify how a client session's should be allocated.
ConnectionPolicy.ExclusiveMode	Default value Transactional causes creation of ClientSession, the other two values - ExclusiveIsolatedClientSession.
ConnectionPool	Purpose: Used to specify how connection should be pooled in a server session.
Connector	Purpose: Define an interface for supplying TopLink with a Connection to a JDBC database.
ConstantTransformer	Purpose: Allows a field to always be mapped to a constant value.
ConstraintMode	Used to control the application of a constraint.
ConstraintViolationWrapper<T>	Wrapper over ConstraintViolation class.
ConstructorExpression	In the SELECT clause a constructor may be used in the SELECT list to return one or more Java instances.
ConstructorExpressionBNF	The query BNF for a constructor expression.
ConstructorExpressionFactory	This ConstructorExpressionFactory creates a new ConstructorExpression when the portion of the query to parse starts with NEW.
ConstructorExpressionStateObject	In the SELECT clause a constructor may be used in the SELECT list to return one or more Java instances.
ConstructorItemBNF	The query BNF for a constructor item expression.
ConstructorReportItem	Purpose: An item specifying a class constructor method to be used in a ReportQuery's returned results.
ConstructorResult	Used in conjunction with the SqlResultSetMapping annotation to map the SELECT clause of a SQL query to a constructor.
ConstructorResult	JPA scripting API implementation.
ConstructorResult	Purpose: Concrete class to represent the ConstructorResult structure as defined by the JPA 2.1 Persistence specification.
ContainerMapping	Interface used by clients to interact with the assorted mappings that use ContainerPolicy.
ContentAssistExtension	This extension can be used to provide additional support to JPQL content assist that is outside the scope of providing proposals related to JPA metadata.
ContentAssistProposals	This object stores the various proposals available for content assist for a certain position within a JPQL query.
ContentAssistProposals.ClassType	This enumeration determines the type of classes returned by ContentAssistProposals.classNames().
ContentAssistProposals.EnumProposals	Holds onto the IType of the enum type and the list of possible enum constants.
ContentHandlerRecord	Use this type of MarshalRecord when the marshal target is a ContentHandler.
ConversionException	Purpose: Conversion exceptions such as method or class not defined will raise this exception.
ConversionExceptionResource	INTERNAL: English ResourceBundle for ConversionException messages.
ConversionValue	A ConversionValue annotation is used within an ObjectTypeConverter.
ConversionValue	JPA scripting API implementation.
Convert	Specifies the conversion of a Basic field or property.
Convert	The Convert annotation specifies that a named converter should be used with the corresponding mapped attribute.
Convert	JPA scripting API implementation.
Converter	Specifies that the annotated class is a converter and defines its scope.
Converter	A Converter is used to customize the values during the reading from the database into the object model as well as during the writing back of changes into the database.
Converter	JPA scripting API implementation.
Converter	Purpose: Conversion interface to allow conversion between object and data types.
ConverterClass	JPA scripting API implementation.
ConverterClass<T extends AttributeConverter<X,Y>,X,Y>	A JPA attribute converter class wrapped with an EclipseLink converter.
Converters	A Converters annotation allows the definition of multiple Converter.
Converts	Used to group Convert annotations.
CopyGroup	Purpose: Define how an object is to be copied.
CopyPolicy	A CopyPolicy is used to set an org.eclipse.persistence.descriptors.copying.CopyPolicy on an Entity.
CopyPolicy	Purpose: Allows customization of how an object is cloned.
CopyPolicy	JPA scripting API implementation.
CORBAConnection	This class exists on on the client side which talks to remote session controller through RMI connection.
CORBARemoteSessionController	INTERNAL: org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionController.java Generated by the IDL-to-Java compiler (portable), version "3.0" from CorbaRemoteSessionControllerSun.idl Monday, November 19, 2001 1:51:44 o'clock PM EST
CORBARemoteSessionControllerDispatcher	RemoteSessionController sits between the remote session and the session.
CORBARemoteSessionControllerHelper	INTERNAL: org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionControllerHelper.java Generated by the IDL-to-Java compiler (portable), version "3.0" from CorbaRemoteSessionControllerSun.idl Monday, November 19, 2001 1:51:44 o'clock PM EST
CORBARemoteSessionControllerHolder	INTERNAL: org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionControllerHolder.java Generated by the IDL-to-Java compiler (portable), version "3.0" from CorbaRemoteSessionControllerSun.idl Monday, November 19, 2001 1:51:44 o'clock PM EST
CORBARemoteSessionControllerOperations	INTERNAL: org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionControllerOperations.java Generated by the IDL-to-Java compiler (portable), version "3.0" from CorbaRemoteSessionControllerSun.idl Monday, November 19, 2001 1:51:44 o'clock PM EST
CORBATransportManager
CoreAttributeAccessor	INTERNAL A abstraction of attribute accessor capturing behavior common to all persistence types.
CoreAttributeGroup<ATTRIBUTE_ITEM extends CoreAttributeItem,DESCRIPTOR extends CoreDescriptor>	INTERNAL Purpose: A generic super class for AttributeGroup and other subclasses
CoreAttributeItem<ATTRIBUTE_GROUP extends CoreAttributeGroup>	INTERNAL Purpose: Generic superclass for AttributeItem.
CoreConverter<MAPPING extends CoreMapping,SESSION extends CoreSession>	INTERNAL A abstraction of converter capturing behavior common to all persistence types.
CoreDescriptor<ATTRIBUTE_GROUP extends CoreAttributeGroup,DESCRIPTOR_EVENT_MANAGER extends CoreDescriptorEventManager,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField,INHERITANCE_POLICY extends CoreInheritancePolicy,INSTANTIATION_POLICY extends org.eclipse.persistence.internal.core.descriptors.CoreInstantiationPolicy,LIST extends java.util.List,OBJECT_BUILDER extends org.eclipse.persistence.internal.core.descriptors.CoreObjectBuilder>	INTERNAL A abstraction of descriptor capturing behavior common to all persistence types.
CoreDescriptorEvent	INTERNAL A abstraction of descriptor event capturing behavior common to all persistence types.
CoreDescriptorEventManager<DESCRIPTOR_EVENT extends CoreDescriptorEvent>	INTERNAL A abstraction of descriptor event manager capturing behavior common to all persistence types.
CoreFieldTransformer<SESSION extends CoreSession>	This interface is used by the Transformation Mapping to build the value for a specific field.
CoreInheritancePolicy<ABSTRACT_RECORD extends org.eclipse.persistence.internal.core.sessions.CoreAbstractRecord,ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,DESCRIPTOR extends CoreDescriptor,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField>	INTERNAL A abstraction of inheritance policy capturing behavior common to all persistence types.
CoreLogin<PLATFORM extends org.eclipse.persistence.internal.core.databaseaccess.CorePlatform>	INTERNAL A abstraction of login capturing behavior common to all persistence types.
CoreMapping<ATTRIBUTE_ACCESSOR extends CoreAttributeAccessor,ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,CONTAINER_POLICY extends org.eclipse.persistence.internal.core.queries.CoreContainerPolicy,DESCRIPTOR extends CoreDescriptor,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField>	INTERNAL A abstraction of mapping capturing behavior common to all persistence types.
CoreProject<DESCRIPTOR extends CoreDescriptor,LOGIN extends CoreLogin,SESSION extends CoreSession>	INTERNAL A abstraction of project capturing behavior common to all persistence types.
CoreSession<DESCRIPTOR extends CoreDescriptor,LOGIN extends CoreLogin,PLATFORM extends org.eclipse.persistence.internal.core.databaseaccess.CorePlatform,PROJECT extends CoreProject,SESSION_EVENT_MANAGER extends CoreSessionEventManager>	INTERNAL A abstraction of session capturing behavior common to all persistence types.
CoreSessionEventListener	INTERNAL A abstraction of session event listener capturing behavior common to all persistence types.
CoreSessionEventManager<SESSION_EVENT_LISTENER extends CoreSessionEventListener>	INTERNAL A abstraction of sessuin event manager capturing behavior common to all persistence types.
CountFunction	One of the aggregate functions.
CountFunctionFactory	This CountFunctionFactory creates a new CountFunction when the portion of the query to parse starts with COUNT.
CountFunctionStateObject	One of the aggregate functions.
CriteriaBuilder	Used to construct criteria queries, compound selections, expressions, predicates, orderings.
CriteriaBuilder.Case<R>	Interface used to build general case expressions.
CriteriaBuilder.Coalesce<T>	Interface used to build coalesce expressions.
CriteriaBuilder.In<T>	Interface used to build in predicates.
CriteriaBuilder.SimpleCase<C,R>	Interface used to build simple case expressions.
CriteriaBuilder.Trimspec	Used to specify how strings are trimmed.
CriteriaDelete<T>	The CriteriaDelete interface defines functionality for performing bulk delete operations using the Criteria API
CriteriaQuery<T>	The CriteriaQuery interface defines functionality that is specific to top-level queries.
CriteriaUpdate<T>	The CriteriaUpdate interface defines functionality for performing bulk update operations using the Criteria API.
Cursor	Purpose: Abstract class for CursoredStream and ScrolableCursor
CursoredStream	Purpose: Stream class which is used to deal with large collections returned from TOPLink queries more efficiently.
CursoredStreamPolicy	Purpose: Used to support cursored streams in a read query.
CursorPolicy	Purpose: Abstract class for all Cursor-related policy objects
Customizer	The Customizer annotation is used to specify a class that implements the org.eclipse.persistence.config.DescriptorCustomizer interface and is to run against an entity's class descriptor after all metadata processing has been completed.
CustomPartitioningPolicy	PUBLIC: Defines a user defined partitioning policy.
CustomServerPlatform	INTERNAL: This is the concrete subclass responsible for handling backward compatibility for 9.0.4.
DailyCacheInvalidationPolicy	PUBLIC: A CacheInvalidationPolicy that allows objects to expire every day at a specific time.
DatabaseChangeNotificationType	Configures what type of database change notification an entity/descriptor should use.
DatabaseEventListener	PUBLIC: Defines the API for integration with a database event notification service.
DatabaseEventListenerFactory	Provides a mechanism for plugging in database event listener creation.
DatabaseException	Purpose: Wrapper for any database exception that occurred through EclipseLink.
DatabaseExceptionResource	INTERNAL: English ResourceBundle for DatabaseException messages.
DatabaseLogin	Purpose: Hold the configuration information necessary to connect to a JDBC driver.
DatabaseMapping	Purpose: Defines how an attribute of an object maps to and from the database
DatabaseMapping.WriteType
DatabaseObjectDefinition	Purpose: Define a database object for the purpose of creation and deletion.
DatabasePlatform	DatabasePlatform is private to EclipseLink.
DatabaseQuery	Purpose: Abstract class for all database query objects.
DatabaseQuery.ParameterType	Used for parameter retreival in JPQL
DatabaseRecord	Purpose: Define a representation of a database row as field=>value pairs.
DatabaseSession	Purpose: Add login and configuration API to that of Session.
DatabaseType	This expression represents the database specific data type, which may include size and scale.
DatabaseTypeFactory
DatabaseTypeQueryBNF	The query BNF for the database type.
DataBindingException	Exception that represents a failure in a JAXB operation.
DataModifyQuery	Purpose: Concrete class used for executing non selecting SQL strings.
DataPartitioningCallback	PUBLIC: Defines the API for the integration with an external DataSources data partitioning support.
DataReadQuery	Purpose: Concrete class to perform read using raw SQL.
DataService	JPA scripting API implementation.
DatasourceLogin	Purpose: Hold the configuration information necessary to connect to a datasource.
DataStorage
DatatypeConverter	The javaType binding declaration can be used to customize the binding of an XML schema datatype to a Java datatype.
DatatypeConverterInterface	The DatatypeConverterInterface is for JAXB provider use only.
DateTime	This Expression represents a date or time.
DatetimeExpressionBNF	The query BNF for a date/time expression.
DateTimeFactory	This DateTimeFactory creates a new DateTime when the portion of the query to parse starts with CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP or with the JDBC escape format used for date/time/timestamp.
DateTimePrimaryBNF	The query BNF for a date/time primary expression.
DateTimeStateObject	This DateTimeStateObject represents a date or time.
DateTimeTimestampLiteralBNF	The query BNF for a date/time/timestamp expression.
DB2MainframePlatform	Purpose: Provides DB2 Mainframe specific behavior.
DB2Platform	Purpose: Provides DB2 specific behavior.
DB2ZPlatform	Purpose: Provides DB2 z/OS specific behavior.
DBasePlatform	Purpose: Provides DBase specific behavior.
DBWSException	PUBLIC: runtime exception for EclipseLink DBWS Service
DBWSExceptionResource	INTERNAL: Purpose:
DBWSModel	PUBLIC: model object for eclipselink-dbws.xml descriptor file.
DBWSModelProject
DecimalMaxFacet
DecimalMinFacet
Declaration	The abstract definition of JPQLQueryDeclaration.
DeclarationResolver	This Resolver is responsible to visit the current query (which is either the top-level query or a subquery) and gathers the information from the declaration clause.
DeclarationResolver.QualifyRangeDeclarationVisitor
DeclarationStateObject	This defines the declaration portion of a query, which is the FROM clause of a query.
DefaultActualJPQLQueryFormatter	This IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed, which means this formatter can only be used when the StateObject was created by parsing a JPQL query because it needs to retrieve parsing information from the corresponding Expression.
DefaultBasicRefactoringTool	This utility class provides basic refactoring support.
DefaultCaseExpressionStateObjectBuilder	The default implementation of a ICaseExpressionStateObjectBuilder.
DefaultConditionalExpressionStateObjectBuilder	The default implementation of IConditionalExpressionStateObjectBuilder.
DefaultConnector	Purpose:Use this Connector to build a java.sql.Connection in the "standard" fashion, via the DriverManager.
DefaultContentAssistProposals	The default implementation of ContentAssistProposals which stores the valid proposals.
DefaultContentAssistVisitor	This visitor traverses the JPQL parsed tree and gathers the possible proposals at a given position.
DefaultEclipseLinkJPQLGrammar	This JPQL grammar provides support for parsing JPQL queries defined by the JPA 2.1 functional specification and the EclipseLink 2.6.
DefaultEclipseLinkJPQLQueryBuilder	An implementation of IJPQLQueryBuilder that provides support based on the latest release of the Java Persistence functional specification.
DefaultErrorHandler	INTERNAL: A default implementation of ErrorHandler that simply rethrows the SAXParseExceptions.
DefaultGrammarValidator	This validator is responsible to validate a JPQL query grammatically purely based on the JPA specification document.
DefaultJPQLGrammar	This JPQL grammar provides support for parsing JPQL queries defined in the latest JPA functional specification.
DefaultJPQLQueryBuilder	An implementation of IJPQLQueryBuilder that provides support based on the latest release of the Java Persistence functional specification.
DefaultJPQLQueryContext	This context is used to store information related to the JPQL query.
DefaultJPQLQueryFormatter	The default implementation of a IJPQLQueryFormatter, which support creating a string representation of a JPQL query written for JPA 1.0 and 2.0.
DefaultJPQLQueryHelper	This helper can perform the following operations over a JPQL query: Calculates the result type of a query: AbstractJPQLQueryHelper.getResultType(); Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String). Calculates the possible choices to complete the query from a given position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int). Validates the query by introspecting it grammatically and semantically: AbstractJPQLQueryHelper.validate(), AbstractJPQLQueryHelper.validateGrammar(), AbstractJPQLQueryHelper.validateSemantic(). Refactoring support: DefaultJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the refactoring operation through a collection of TextEdit objects. DefaultJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through the editable StateObject and once all refactoring operations have been executed, the IJPQLQueryFormatter will generate a new string representation of the JPQL query. This helper should be used when the JPQL query is written using the JPQL grammar defined in the Java Persistence functional specification 1.0 or 2.x.
DefaultLiteralVisitor	This visitor traverses an Expression and retrieves the "literal" value.
DefaultNewValueStateObjectBuilder	The default implementation of INewValueStateObjectBuilder.
DefaultParameterTypeVisitor	This visitor calculates the type of an input parameter.
DefaultProblem	The default implementation of Problem.
DefaultRefactoringDelta	The default implementation of RefactoringDelta which contains the TextEdit that were creating during the refactoring of a JPQL query.
DefaultRefactoringTool	This utility class provides basic refactoring support.
DefaultResolverBuilder	The default implementation of a ResolverBuilder, which follows the JPA functional specification.
DefaultSelectExpressionStateObjectBuilder
DefaultSemanticValidator	This validator is responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid.
DefaultSemanticValidator.NullValueVisitor
DefaultSemanticValidator.ResultVariableInOrderByVisitor
DefaultSemanticValidator.UpdateClauseAbstractSchemaNameFinder
DefaultSequence	Purpose: Reference to the default sequence.
DefaultSessionLog	Purpose: Default log used for the session when message logging is enabled.
DefaultSimpleSelectExpressionStateObjectBuilder
DefaultStateObjectBuilder	The default implementation of BasicStateObjectBuilder, which provides support for creating a StateObject representation of any Expression.
DefaultStringExpression	An implementation of an Expression that wraps a string.
DefaultTableGenerator	DefaultTableGenerator is a utility class used to generate a default table schema for a EclipseLink project object.
DefaultTextEdit	The default implementation of a TextEdit, which contains the location of the change within the JPQL query (offset) and the old and new values.
DefaultUnmappedContentHandler	Purpose:Provide a default implementation of the UnmappedContentHandler
DefaultValidationEventHandler	JAXB 1.0 only default validation event handler.
DefaultXMLNameTransformer	Class called to transform Java names to XML names.
DeferredChangeDetectionPolicy	PUBLIC: A DeferredChangeDetectionPolicy defers all change detection to the UnitOfWork's change detection process.
DeleteAll	A DeleteAll annotation is specified to indicate that when an relationship is deleted, it should use a delete all query.
DeleteAllQuery	Purpose: Query used to delete a collection of objects.
DeleteClause	This is the delete clause of the delete statement.
DeleteClauseBNF	The query BNF for the delete clause.
DeleteClauseFactory	This DeleteClauseFactory creates a new DeleteClause when the portion of the query to parse starts with DELETE FROM.
DeleteClauseRangeVariableDeclarationBNF	The query BNF for a range variable declaration expression used by the DELETE clause, which accepts collection and aggregate expression, which is used by invalid queries.
DeleteClauseStateObject	This is the DELETE clause of the DELETE statement.
DeleteObjectQuery	Purpose: Used for deleting objects.
DeleteStatement	Bulk delete operation apply to entities of a single entity class (together with its subclasses, if any).
DeleteStatementBNF	The query BNF for the delete statement.
DeleteStatementFactory	This DeleteStatementFactory creates a new DeleteStatement when the portion of the query to parse starts with DELETE FROM.
DeleteStatementStateObject	Bulk delete operation apply to entities of a single entity class (together with its subclasses, if any).
DerbyPlatform	Purpose: Provides Derby DBMS specific behavior.
DerivedCollectionMemberDeclarationBNF	The query BNF for a derived collection member declaration expression.
DerivedDeclaration	This DerivedDeclaration represents an identification variable declaration that was declared in the FROM clause of a SELECT subquery.
DerivedPathIdentificationVariableDeclarationStateObject
DerivedPathVariableDeclarationStateObject	BNF: subselect_identification_variable_declaration ::= derived_path_expression [AS] identification_variable {join}*
DescriptorBasedDatabaseEventListener	Extends EclipseLink's database event listening capabilities by allowing a listener to subscribe to to change notifications from the database This listener also expands the interface to support subscription on a descriptor basis rather than the wholesale subscription provided by its superclass.
DescriptorCustomizer	Customize a ClassDescriptor when the DescriptorCustomizer.customize(ClassDescriptor) method is called during the loading/population of the mappings.
DescriptorCustomizer	Deprecated. replaced by org.eclipse.persistence.config.DescriptorCustomizer
DescriptorEvent	Purpose: Encapsulate the information provided with descriptor events.
DescriptorEventAdapter	Purpose: Provides an empty implementation of DescriptorEventListener.
DescriptorEventListener	Purpose: Used to support Java event listener event model on descriptors.
DescriptorEventManager	Purpose: The event manager allows for a descriptor to specify that an object should be notified when a EclipseLink event occurs.
DescriptorException	Purpose: This exception is used for any problem that is detected with a descriptor or mapping.
DescriptorExceptionResource	INTERNAL: English ResourceBundle for DescriptorException messages.
DescriptorQueryManager	Purpose: The query manager allows for the database operations that EclipseLink performs to be customized by the application.
DevelopmentServices	Purpose: Provide a dynamic interface into the EclipseLink Identity Map Manager.
DigitsFacet
DirectCollectionChangeRecord	Purpose: This interface defines the API for the ChangeRecord that holds the changes made to a direct collection attribute of an object.
DirectCollectionMapping	Purpose: This mapping is used to store a collection of simple types (String, Number, Date, etc.)
DirectCollectionQueryKey	Purpose:Represents a direct collection join query.
DirectConnector	Purpose:Use this Connector to build a java.sql.Connection by directly instantiating the Driver, as opposed to using the DriverManager.
Direction	An enum that is used within the StoredProcedureParameter annotation.
DirectMapMapping	Mapping for a collection of key-value pairs.
DirectQueryKey	Purpose: Define an alias to a database field.
DirectReadQuery	Purpose: Concrete class to perform a direct read.
DirectToFieldChangeRecord	Purpose: This interface provides public API to the class responsible for holding the change made to a directToFieldMapping.
DirectToFieldMapping	Purpose: Maps an attribute to the corresponding database field type.
DirectToXMLTypeMapping	Purpose: Mapping used to map from a DOM (org.w3c.Document) or XML String into an Oracle XMLType field, in Oracle 9i XDB.
DiscoveryException	Instances of this exception are raised if a problem is detected during the discovery of a TopLink cluster.
DiscoveryExceptionResource	INTERNAL: English ResourceBundle for ConcurrencyException messages.
DiscoveryManager	Purpose: Detects new members of a logical EclipseLink cluster.
DiscriminatorClass	A DiscriminatorClass is used within a VariableOneToOne annotation.
DiscriminatorClass	JPA scripting API implementation.
DiscriminatorColumn	Specifies the discriminator column for the SINGLE_TABLE and JOINED Inheritance mapping strategies.
DiscriminatorColumn	JPA scripting API implementation.
DiscriminatorType	Defines supported types of the discriminator column.
DiscriminatorValue	Specifies the value of the discriminator column for entities of the given type.
DistributedSession	Purpose: Super class to all remote client session's.
DivisionExpression	One of the four binary operators.
DivisionExpressionStateObject	TODO: BNF: arithmetic_expression ::= arithmetic_expression / arithmetic_term
DocumentPreservationPolicy	Purpose:Provides an interface for customizing how Documents are preserved.
DoesExistQuery	Purpose: This should only be used by the descriptor, this should not be executed directly.
DomHandler<ElementT,ResultT extends javax.xml.transform.Result>	Converts an element (and its descendants) from/to DOM (or similar) representation.
DOMPlatform	INTERNAL:
DOMRecord	DOMRecord is an extension of the JCA Record interface that provides support for XML data.
DOMRecord	PUBLIC: Provides a Record/Map API on an XML DOM element.
DynamicClassLoader	This custom ClassLoader provides support for dynamically generating classes within an EclipseLink application using byte codes created using a DynamicClassWriter.
DynamicClassLoader.EnumInfo
DynamicClassWriter	Write the byte codes of a dynamic entity class.
DynamicEntity	DynamicEntity is the public interface for dealing with dynamic persistent objects.
DynamicEnumBuilder
DynamicException	Custom exception type that provides information about failure cases encountered when using a GenericEntity with TopLink.
DynamicHelper	A DynamicHelper provides some utility methods to simplify application development with dynamic types.
DynamicHelper.SessionCustomizer	A SessionCustomizer which configures all descriptors as dynamic entity types.
DynamicIdentityPolicy	Custom CMPPolicy to handle Object[].
DynamicJAXBContext	A specialized JAXBContext for marshalling and unmarshalling DynamicEntities.
DynamicJAXBContextFactory	DynamicJAXBContextFactory allows the user to create a DynamicJAXBContext without having realized Java classes available on the classpath.
DynamicSchemaManager	Extended SchemaManager to handle the creation of tables for dynamic types.
DynamicType	An EntityType provides a metadata facade into the EclipseLink object-relational metadata (descriptors & mappings) with specific knowledge of the entity types being dynamic.
DynamicTypeBuilder	The EntityTypeBuilder is a factory class for creating and extending dynamic entity types.
DynamicXMLMetadataSource	MetadataSource used in the creation of dynamic JAXB contexts for applications.
DynamicXmlV2MetadataSource	MetadataSource used in the creation of dynamic JAXB contexts for applications in JPARS v2.0.
EclipseLinkActualJPQLQueryFormatter	This IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed, which means this formatter can only be used when the StateObject was created by parsing a JPQL query because it needs to retrieve parsing information from the corresponding Expression.
EclipseLinkAnonymousExpressionVisitor	This visitor allows a subclass to simply override AnonymousExpressionVisitor.visit(Expression) and perform the same task for all visited expressions including those defined by EclipseLink.
EclipseLinkBasicRefactoringTool	This utility class provides basic refactoring support.
EclipseLinkClassWriter
EclipseLinkConditionalStateObjectBuilder	The EclipseLink extension over the basic support provided by IConditionalExpressionStateObjectBuilder.
EclipseLinkContentAssistVisitor	This extension over the default content assist visitor adds the additional support EclipseLink provides.
EclipseLinkContentAssistVisitor.AcceptableTypeVisitor
EclipseLinkContentAssistVisitor.AppendableExpressionVisitor
EclipseLinkContentAssistVisitor.EndingQueryPositionBuilder
EclipseLinkContentAssistVisitor.FollowingClausesVisitor	This visitor adds support for the additional clauses provided by EclipseLink, such as the
EclipseLinkDeclarationResolver	The EclipseLink implementation of DeclarationResolver that adds support for its additional support.
EclipseLinkException	Purpose: Any exception raised by EclipseLink should be a subclass of this exception class.
EclipseLinkExpressionVisitor	The ExpressionVisitor that adds support for the additional JPQL identifiers supported by EclipseLink that is not defined in the JPA function specification.
EclipseLinkGrammarValidator	This validator adds EclipseLink extension over what the JPA functional specification had defined.
EclipseLinkGrammarValidator.InExpressionVisitor
EclipseLinkGrammarValidator.InExpressionWithNestedArrayVisitor
EclipseLinkJPQLGrammar1	This JPQL grammar provides support for parsing JPQL queries defined in JSR-220 - Enterprise JavaBeans 3.0.
EclipseLinkJPQLGrammar2_0	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLGrammar2_1	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0 and the additional support provided by EclipseLink 2.1.
EclipseLinkJPQLGrammar2_2	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLGrammar2_3	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLGrammar2_4	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional support provided by EclipseLink 2.4.
EclipseLinkJPQLGrammar2_5	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional support provided by EclipseLink 2.5.
EclipseLinkJPQLGrammar2_6	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional support provided by EclipseLink 2.6.
EclipseLinkJPQLQueryBuilder	An implementation of IJPQLQueryBuilder that provides support based on the release of the Java Persistence functional specification defined in JSR-337 - Java Persistence 2.0.
EclipseLinkJPQLQueryContext	This context is used to store information related to the JPQL query.
EclipseLinkJPQLQueryFormatter	The default implementation of a IJPQLQueryFormatter that adds support for formatting EclipseLink specific JPQL identifiers.
EclipseLinkJPQLQueryHelper	This helper can perform the following operations over a JPQL query: Calculates the result type of a query: AbstractJPQLQueryHelper.getResultType(); Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String). Calculates the possible choices to complete the query from a given position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int). Validates the query by introspecting it grammatically and semantically: AbstractJPQLQueryHelper.validate(), AbstractJPQLQueryHelper.validateGrammar(), AbstractJPQLQueryHelper.validateSemantic(). Refactoring support: EclipseLinkJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the refactoring operation through a collection of TextEdit objects. EclipseLinkJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through the editable StateObject and once all refactoring operations have been executed, the IJPQLQueryFormatter will generate a new string representation of the JPQL query. This helper should be used when the JPQL query is written using the JPQL grammar defined in the Java Persistence functional specification 2.1 and it contains the additional support provided by EclipseLink.
EclipseLinkLiteralVisitor	This visitor traverses an Expression and retrieves the "literal" value.
EclipseLinkLogRecord	INTERNAL:
EclipseLinkParameterTypeVisitor	This visitor calculates the type of an input parameter.
EclipseLinkRefactoringTool	This refactoring tool add support for EclipseLink specific extension over the default implementation of JPQL defined in the Java Persistence functional specification.
EclipseLinkResolverBuilder	An implementation of a ResolverBuilder that adds support for EclipseLink extension.
EclipseLinkSelectExpressionStateObjectBuilder
EclipseLinkSemanticValidator	This validator is responsible to gather the problems found in a JPQL query by validating the content to make sure it is semantically valid for EclipseLink.
EclipseLinkSemanticValidatorExtension	This extension provides additional support to semantic validation by adding support for non-JPA specific artifacts, such as database objects.
EclipseLinkSimpleSelectExpressionStateObjectBuilder
EclipseLinkStateObjectBuilder	The default implementation of BasicStateObjectBuilder, which provides support based on the JPQL grammar defined in the Java Persistence functional specification and for the additional support provided by EclipseLink.
EclipseLinkStateObjectVisitor	The interface is used to traverse the StateObject hierarchy that represents a JPQL query as well as what EclipseLink adds on top of the basic grammar.
EclipseLinkVersion	An enumeration listing the various releases of EclipseLink.
EISAccessor	EISAccessor is an implementation of the Accessor interface.
EISCollectionChangeRecord	INTERNAL: Capture the changes for an unordered collection as collections of adds and removes.
EISCollectionChangeRecord	Purpose: To provide API into the EISCollectionChangeSet.
EISCompositeCollectionMapping	EIS Composite Collection Mappings map a java.util.Map or java.util.Collection of Java objects to an EIS record in a privately owned, one-to-many relationship according to its descriptor's record type.
EISCompositeDirectCollectionMapping	EIS Composite Direct Collection Mappings map a collection of simple Java attributes to and from an EIS Record according to its descriptor's record type.
EISCompositeObjectMapping	EIS Composite Object Mappings map a Java object to a privately owned, one-to-one relationship to an EIS Record according to its descriptor's record type.
EISConnectionSpec	An EISConnectionSpec specifies how the javax.resource.cci.Connection is accessed.
EISDescriptor	An EISDescriptor defines the mapping from a JCA data structure to a Java object.
EISDirectMapping	EIS Direct Mappings map a simple Java attribute to and from an EIS Record according to its descriptor's record type.
EISDOMRecord	An EISDOMRecord is a wrapper for a DOM tree.
EISException	Use an EISException when any problem is detected while interacting with an EIS datasource
EISExceptionResource	INTERNAL: English ResourceBundle for EISException messages.
EISInteraction	Defines the specification for a call to a JCA interaction.
EISLogin	An EISLogin defines connection information and datasource properties.
EISMappedRecord	An EISMappedRecord acts as a Record wrapper.
EISMapping	INTERNAL All mappings which can be added to org.eclipse.persistence.eis.EISDescriptor must implement this interface.
EISObjectPersistenceXMLProject	INTERNAL:
EISOneToManyMapping	An EIS one-to-many mapping is a reference mapping that represents the relationship between a single source object and a collection of mapped persistent Java objects.
EISOneToManyMappingHelper	INTERNAL: Helper class to consolidate all the heinous comparing and merging code for the EIS one to many mappings.
EISOneToOneMapping	An EIS one-to-one mapping is a reference mapping that represents the relationship between a single source object and a single mapped persistent Java object.
EISOrderedCollectionChangeRecord	INTERNAL: Capture the changes for an ordered collection where the entire collection is simply replaced if it has changed.
EISOrderedCollectionChangeRecord	Purpose: To provide API into the EISCollectionChangeSet.
EISPlatform	An EISPlatform defines any EIS adapter specific behavior.
EISSequence	The EISSequence class allows access to sequence resources using custom read (ValueReadQuery) and update (DataModifyQuery) queries and a user specified preallocation size.
EISTransformationMapping	EIS Transformation Mappings allow the creation of custom mappings where one or more fields in an EIS Record can be used to create the object to be stored in a Java class's attribute.
Element	This is an element marker interface.
ElementCollection	Specifies a collection of instances of a basic type or embeddable class.
ElementCollection	JPA scripting API implementation.
ElementDeclaration	An ElementDeclaration object is used to represent the information that is associated with a global element in XML.
ElseExpressionBNF	The query BNF for a else expression specified in the case expression.
Embeddable	Specifies a class whose instances are stored as an intrinsic part of an owning entity and share the identity of the entity.
Embeddable	JPA scripting API implementation.
EmbeddableMapping	INTERNAL Common interface to those mappings that are used to map JPA Embedded objects
EmbeddableType<X>	Instances of the type EmbeddableType represent embeddable types.
Embedded	Specifies a persistent field or property of an entity whose value is an instance of an embeddable class.
Embedded	JPA scripting API implementation.
EmbeddedId	Applied to a persistent field or property of an entity class or mapped superclass to denote a composite primary key that is an embeddable class.
EmbeddedId	JPA scripting API implementation.
EmptyCollectionComparisonExpression	This expression tests whether or not the collection designated by the collection-valued path expression is empty (i.e, has no elements).
EmptyCollectionComparisonExpressionBNF	The query BNF for an empty collection comparison expression.
EmptyCollectionComparisonExpressionStateObject	This expression tests whether or not the collection designated by the collection-valued path expression is empty (i.e, has no elements).
EmptyIterable<E>	An EmptyIterable is just that.
EmptyIterator	A null instance of an Iterator.
EncapsulatedIdentificationVariableExpression	This Expression represents an identification variable that maps a Map property, either the key, the value or a Map.Entry).
EncapsulatedIdentificationVariableExpressionStateObject	This object represents an identification variable that is wrapped by a function.
Entity	Specifies that the class is an entity.
Entity	JPA scripting API implementation.
EntityExistsException	Thrown by the persistence provider when EntityManager.persist(Object) is called and the entity already exists.
EntityExpressionBNF	The query BNF for a entity expression.
EntityGraph<T>	This type represents the root of an entity graph that will be used as a template to define the attribute nodes and boundaries of a graph of entities and entity relationships.
EntityListener	JPA scripting API implementation.
EntityListeners	Specifies the callback listener classes to be used for an entity or mapped superclass.
EntityManager	Interface used to interact with the persistence context.
EntityManagerFactory	Interface used to interact with the entity manager factory for the persistence unit.
EntityManagerProperties	The class defines EclipseLink properties' names for use at the EntityManager level.
EntityManagerSetupException
EntityManagerSetupExceptionResource	INTERNAL: English ResourceBundle for EntityManagerSetupException messages.
EntityNotFoundException	Thrown by the persistence provider when an entity reference obtained by EntityManager.getReference is accessed but the entity does not exist.
EntityOrValueExpressionBNF	The query BNF for a entity or value expression.
EntityResolver	This Resolver retrieves the type for an abstract schema name (entity name).
EntityResource	Entity resource.
EntityResource	Deprecated. Use EntityResource instead.
EntityResult	Used in conjunction with the SqlResultSetMapping annotation to map the SELECT clause of a SQL query to an entity result.
EntityResult	JPA scripting API implementation.
EntityResult	Purpose: Concrete class to represent the EntityResult structure as defined by the EJB 3.0 Persistence specification.
EntityTransaction	Interface used to control transactions on resource-local entity managers.
EntityType<X>	Instances of the type EntityType represent entity types.
EntityTypeExpressionBNF	The query BNF for the TYPE expression.
EntityTypeLiteral	This Expression wraps the name of an entity type.
EntityTypeLiteralBNF	The query BNF for the entity type literal.
EntityTypeLiteralFactory	This factory creates an EntityTypeLiteral, which wraps an entity name.
EntityTypeLiteralStateObject	This StateObject wraps the name of an entity type.
EntryExpression	An identification variable qualified by the ENTRY operator is a path expression.
EntryExpressionFactory	This EntryExpressionFactory creates a new EntryExpression when the portion of the query to parse starts with ENTRY.
EntryExpressionStateObject	This object represents an identification variable that maps the Map.Entry) of a Map.
Enumerated	Specifies that a persistent property or field should be persisted as a enumerated type.
Enumerated	JPA scripting API implementation.
EnumExpressionBNF	The query BNF for a enum expression.
EnumLiteralBNF	The query BNF for an enumeration constant expression.
EnumLiteralResolver	This Resolver retrieves the type for an enum constant.
EnumPrimaryBNF	The query BNF for an enum primary expression.
EnumType	Defines mapping for enumerated types.
EnumTypeConverter	Purpose: Object type converter is used to match a fixed number of database data values to a Java enum object value.
EnumTypeInfo	INTERNAL:
EnumTypeStateObject	This StateObject wraps the name of an Enum constant.
ErrorResponse
ErrorResponseMetadataSource	Makes the ErrorResponse class available to JAXB context.
ExceptionHandler	Exception handler can catch errors that occur on queries or during database access.
ExceptionMessageGenerator	INTERNAL: Utility class to generate exception messages using ResourceBundles.
ExceptionResource	INTERNAL: English ResourceBundle for EclipseLinkException messages.
ExcludeDefaultListeners	Specifies that the invocation of default listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
ExcludeDefaultMappings	Specifies default mappings (those that are not explicitly decorated in XML or using annotations)should be omitted.
ExcludeSuperclassListeners	Specifies that the invocation of superclass listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
ExclusiveConnectionMode	This property could be specified while creating either EntityManagerFactory (createEntityManagerFactory or persistence.xml) or EntityManager (createEntityManager); the latter overrides the former.
ExistenceChecking	The ExistenceChecking annotation is used to specify the type of checking EclipseLink should use when determining if an entity is new or existing.
ExistenceType	An enum that is used within the ExistenceChecking annotation.
ExistsExpression	An EXISTS expression is a predicate that is true only if the result of the subquery consists of one or more values and that is false otherwise.
ExistsExpressionBNF	The query BNF for the exists expression.
ExistsExpressionFactory	This ExistsExpressionFactory creates a new ExistsExpression when the portion of the query to parse starts with EXISTS.
ExistsExpressionStateObject	An EXISTS expression is a predicate that is true only if the result of the subquery consists of one or more values and that is false otherwise.
Expression<T>	Type for query expressions.
Expression	Purpose: Define an object-level representation of a database query where clause.
Expression	This is the root interface of the parsed tree representation of a JPQL query.
ExpressionBuilder	Purpose: Allow for instances of expression to be created.
ExpressionFactory	An ExpressionFactory is responsible to parse a portion of JPQL query which starts with one of the factory's JPQL identifiers.
ExpressionMath	Purpose: This class mirrors the java.lang.Math class to allow mathimetical function support within expressions.
ExpressionOperator	Purpose: ADVANCED: The expression operator is used internally to define SQL operations and functions.
ExpressionRegistry	This registry contains the necessary information used by Hermes parser.
ExpressionTools	A utility class containing various methods related to the Hermes parser.
ExpressionVisitor	This interface is used to traverse the JPQL parsed tree.
ExpressionVisitorWrapper	This ExpressionVisitor wraps another ExpressionVisitor and delegates all its calls to it (the delegate).
ExternalConnectionPool	Purpose: This subclass is intended to be used with external connection pools.
ExternalTransactionController	Purpose: Interface for external transaction management.
ExtractExpression	The EXTRACT function extracts a date part from a date/time value.
ExtractExpressionBNF	The query BNF for the EXTRACT function.
ExtractExpressionFactory	This ExtractExpressionFactory creates a new ExtractExpression when the portion of the query to parse starts with EXTRACT.
Facet
FacetVisitor<R,P>	Visitor for Facet.
FeatureResponseBuilder	Common interface for all response builders.
FeatureResponseBuilderImpl	Response builder used in JPARS 1.0 and earlier versions.
FeatureSet	This interface represents a set of JPARS features.
FeatureSet.Feature
FeatureSetPreV2	The legacy initial feature set.
FeatureSetV2	Feature set for service version 2.0.
Fetch<Z,X>	Represents a join-fetched association or attribute.
FetchAttribute	A fetch attribute is specified within a fetch group and is used as a performance enhancement that allows a group of attributes of an object to be loaded on demand, which means that the data for an attribute might not loaded from the underlying data source until an explicit access call for the attribute first occurs.
FetchAttribute	JPA scripting API implementation.
FetchGroup	A fetch group is a performance enhancement that allows a group of attributes of an object to be loaded on demand, which means that the data for an attribute might not loaded from the underlying data source until an explicit access call for the attribute first occurs.
FetchGroup	JPA scripting API implementation.
FetchGroup	A FetchGroup is a performance enhancement that allows a group of attributes of an object to be loaded on demand, which means that the data for an attribute might not loaded from the underlying data source until an explicit access call for the attribute first occurs.
FetchGroupManager	Purpose: The fetch group manager controls the named fetch groups defined at the descriptor level.
FetchGroupMonitor	Purpose: Provide a very simple low overhead means for measuring fetch group field usage.
FetchGroups	A FetchGroups annotation allows the definition of multiple FetchGroup.
FetchGroupTracker	Purpose: The fetch group tracker interface provides a set of APIs which the domain object must implement, in order to take advantage of the EclipseLink fetch group performance enhancement feature.
FetchParent<Z,X>	Represents an element of the from clause which may function as the parent of Fetches.
FetchType	Defines strategies for fetching data from the database.
Field	JPA scripting API implementation.
FieldDefinition	Purpose: Define a database field definition for creation within a table.
FieldPartitioningPolicy	PUBLIC: FieldPartitioningPolicy partitions access to a database cluster by a field value from the object, such as the object's id, location, or tenant.
FieldResult	Used in conjunction with the EntityResult annotation to map columns specified in the SELECT list of a SQL query to the properties or fields of an entity class.
FieldResult	JPA scripting API implementation.
FieldResult	Purpose: Concrete class to represent the FieldResult structure as defined by the EJB 3.0 Persistence specification.
FieldsFilter	Filter for fields filtering (projection) feature.
FieldsFilteringValidator	Fields filtering feature validator/processor.
FieldsFilterType	Type of fields filter.
FieldsLockingPolicy	Purpose: An abstract superclass of some implementations of the OptimisticLockingPolicy interface.
FieldTransformer	PUBLIC: This interface is used by the Transformation Mapping to build the value for a specific field.
FieldTransformerAdapter	Purpose: Provides an empty implementation of FieldTransformer.
FileBasedProjectCache	Purpose: Support serializing/deserializing a project representing application metadata to/from a file.
FileUtil	INTERNAL: Purpose: Provide common file I/O utilities
Filter<T>	A filter is used to determine if a value can be "accepted" or "rejected".
FirebirdPlatform
FixedMimeTypePolicy
FlushClearCache	FlushClearCache persistence property defines modes of cache handling after em.flush call followed by em.clear call.
FlushModeType	Flush mode setting.
ForeignKey	Used to specify the handling of foreign key constraints when schema generation is in effect.
ForeignKey	JPA scripting API implementation.
ForeignKeyConstraint	Purpose: Define a foreign key from one table to another.
ForeignReferenceMapping	Purpose: Abstract class for relationship mappings
ForeignReferenceQueryKey	Purpose: Define an alias to a foreign object.
FormattedOutputStreamRecord	Use this type of MarshalRecord when the marshal target is an OutputStream and the XML should be formatted with carriage returns and indenting.
FormattedWriterRecord	Use this type of MarshalRecord when the marshal target is a Writer and the XML should be formatted with carriage returns and indenting.
From<Z,X>	Represents a bound type, usually an entity that appears in the from clause, but may also be an embeddable belonging to an entity in the from clause.
FromClause	The FROM clause of a query defines the domain of the query by declaring identification variables.
FromClauseBNF	The query BNF for the from clause.
FromClauseFactory	This FromClauseFactory creates a new FromClause when the portion of the query to parse starts with FROM.
FromClauseStateObject	The FROM clause of a query defines the domain of the query by declaring identification variables.
FromSubqueryResolver	This Resolver wraps a subquery that is used as the "root" object in a query's declaration.
FromSubqueryResolver.VirtualMapping	This virtual IMapping wraps one of the select items.
FullyQualifyPathExpressionVisitor	This visitor makes sure that all path expressions are fully qualified with a "virtual" identification variable if the range variable declaration does not define one.
FunctionExpression	This expression adds support to call native database functions.
FunctionExpressionBNF	The query BNF for the EclipseLink's function expression.
FunctionExpressionFactory	This FunctionExpressionFactory creates a new FunctionExpression when the portion of the query to parse starts with an identifier related to a SQL function.
FunctionExpressionFactory.ParameterCount	The number of parameters a FunctionExpression can have.
FunctionExpressionStateObject
FunctionItemBNF	The query BNF for the parameters of a function expression.
FunctionsReturningDatetimeBNF	The query BNF for a function expression returning a date/time value.
FunctionsReturningNumericsBNF	The query BNF for a function expression returning a numeric value.
FunctionsReturningStringsBNF	The query BNF for a function expression returning a string value.
GeneralCaseExpressionBNF	The query BNF for a general case expression.
GeneralIdentificationExpressionFactory	This ValueExpressionFactory creates a general identification variable, which is either with the identifier KEY or VALUE and then checks the existence of a path expression.
GeneralIdentificationVariableBNF	The query BNF for a general identification variable expression.
GeneratedValue	Provides for the specification of generation strategies for the values of primary keys.
GeneratedValue	JPA scripting API implementation.
GenerationType	Defines the types of primary key generation strategies.
Generator	INTERNAL:
GenericQueryBNF	A generic JPQLQueryBNF can be used to manually create a new BNF without having to create a concrete instance.
GenericSemanticValidatorHelper	An implementation of SemanticValidatorHelper that uses JPQLQueryContext to return the required information and Hermes SPI.
GenericSemanticValidatorHelper.IdentificationVariableVisitor
GenericTypeHelper	This generic implementation of ITypeHelper wraps ITypeHelper and delegates the calls to it.
GlassfishPlatform	PUBLIC: This is the concrete subclass responsible for representing Glassfish server behavior.
GlassfishPlatformDetector
GlassfishRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
GlassfishTransactionController	Purpose: TransactionController implementation for Glassfish JTA
GroupByClause	The GROUP BY construct enables the aggregation of values according to the properties of an entity class.
GroupByClauseBNF	The query BNF for the group by clause.
GroupByClauseFactory	This GroupByClauseFactory creates a new GroupByClause when the portion of the query to parse starts with GROUP BY.
GroupByClauseStateObject	The GROUP BY construct enables the aggregation of values according to the properties of an entity class.
GroupByItemBNF	The query BNF for a group by item expression.
GroupByItemFactory	This GroupByItemFactory is responsible to return the right expression and to support invalid expression as well.
H2Platform
HANAPlatform	Database Platform for SAP HANA
HashPartitioning	HashPartitioning partitions access to a database cluster by the hash of a field value from the object, such as the object's location, or tenant.
HashPartitioning	JPA scripting API implementation.
HashPartitioningPolicy	PUBLIC: HashPartitioningPolicy partitions access to a database cluster by the hash of a field value from the object, such as the object's location, or tenant.
HavingClause	The HAVING construct enables conditions to be specified that further restrict the query result as restrictions upon the groups.
HavingClauseBNF	The query BNF for the having clause.
HavingClauseFactory	This HavingClauseFactory creates a new HavingClause when the portion of the query to parse starts with HAVING.
HavingClauseStateObject	The HAVING construct enables conditions to be specified that further restrict the query result as restrictions upon the groups.
Helper	INTERNAL:
HexBinaryAdapter	XmlAdapter for xs:hexBinary.
HierarchicalQueryClause	If a table contains hierarchical data, then rows can be selected in a hierarchical order using the hierarchical query clause.
HierarchicalQueryClauseBNF
HierarchicalQueryClauseFactory	This HierarchicalQueryClauseFactory creates a new HierarchicalQueryClause when the portion of the query to parse starts with either VERSIONS or AS OF.
HintValues	Hint values.
HistoryPolicy	Purpose:Expresses how historical data is saved on the data store.
HrefHelper	A collection of static methods used to build 'href' attribute values for REST 'link' elements.
HSQLPlatform	Purpose: Provides HSQL specific behavior.
IAbstractConditionalExpressionStateObjectBuilder<T extends IScalarExpressionStateObjectBuilder<T>>
IBuilder<T extends StateObject,S extends StateObject>	This builder is used by BasicStateObjectBuilder, which allows subclasses to easily change any internal builders used for properly creating the state model representation of a JPQL query.
ICaseExpressionStateObjectBuilder	This builder is responsible to create a CASE expression.
IConditionalExpressionStateObjectBuilder	This builder can be used to easily create a conditional expression without having to create each object manually.
IConstructor	The external representation of a Java class constructor.
Id	Specifies the primary key of an entity.
Id	JPA scripting API implementation.
IdClass	Specifies a composite primary key class that is mapped to multiple fields or properties of the entity.
IdentifiableType<X>	Instances of the type IdentifiableType represent entity or mapped superclass types.
IdentificationVariable	An identification variable is a valid identifier declared in the FROM clause of a query.
IdentificationVariableBNF	The query BNF for an identification variable expression.
IdentificationVariableDeclaration	An identification variable is a valid identifier declared in the FROM clause of a query.
IdentificationVariableDeclarationBNF	The query BNF for an identification variable declaration expression.
IdentificationVariableDeclarationFactory	This IdentificationVariableDeclarationFactory handles parsing the JPQL fragment within the FROM clause.
IdentificationVariableDeclarationStateObject	An identification variable is a valid identifier declared in the FROM clause of a query.
IdentificationVariableFactory	This IdentificationVariableFactory creates a new IdentificationVariable.
IdentificationVariableResolver	This Resolver is responsible to resolve the type of an identification variable.
IdentificationVariableStateObject	This state object represents a single identification variable, which is identifying TODO.
IdentifierRole	A role describes the purpose of the JPQL identifier.
IdentityMapAccessor	PUBLIC: IdentityMapAccessor provides the public interface into all functionality associated with EclipseLink's cache.
IdHelper	EclipseLink helper class used for converting composite key values passed into JAX-RS calls as query or matrix parameters into a value that can be used in a find.
IDResolver	IDResolver can be subclassed to allow customization of the ID/IDREF processing of JAXBUnmarshaller.
IDResolver	IDResolver can be subclassed to allow customization of the ID/IDREF processing of XMLUnmarshaller.
IdValidation	IdValidation configures which id values are considered valid when loading from the database.
IEclipseLinkConditionalStateObjectBuilder	The EclipseLink extension over the basic support provided by IEclipseLinkConditionalStateObjectBuilder.
IEclipseLinkMappingType	This enumeration lists the mapping types defined in the Java Persistence functional specification and those that are provided by EclipseLink.
IEclipseLinkSelectExpressionStateObjectBuilder
IEclipseLinkSimpleSelectExpressionStateObjectBuilder
IEmbeddable	The external representation of the managed type that is annotated with @Embeddable.
IEntity	The external representation of the managed type that is annotated with @Entity.
IgnoreNewElementsOrderingPolicy	INTERNAL:
IJPQLQueryBuilder	This builder is responsible to create an editable StateObject representation of a JPQL query.
IJPQLQueryFormatter	A IJPQLQueryFormatter helps to write a string representation of a StateObject.
IJPQLQueryFormatter.IdentifierStyle	This enumeration determines how the JPQL identifiers are formatted when written out.
IListChangeEvent<T>	This is used in conjunction with IListChangeListener.
IListChangeEvent.EventType	This enumeration lists the possible modification a list can have.
IListChangeListener<T>	A IListChangeListener can be registered with a StateObject in order to be notified when a list changes (items are added or removed from it or some items have been moved inside of that list).
IManagedType	The external representation of a managed type, which is a JPA persistent object.
IManagedTypeProvider	The external representation of the provider of managed types, which provide access to the JPA domain model.
IManagedTypeVisitor	The interface is used to visit a IManagedType.
IMappedSuperclass	The external representation of the managed type that is annotated with @MappedSuperclass.
IMapping	The external representation of a mapping, which represents a single persistence property of a managed type.
IMappingBuilder<T>	A mapping builder is used to create the appropriate implementation of a IMapping.
IMappingType	This enumeration lists the mapping types defined in the Java Persistence functional specification.
Index	Used in schema generation to specify creation of an index.
Index	Allow a database INDEX to be define when generating DDL.
Index	JPA scripting API implementation.
IndexDefinition	Purpose: Allow for indexes to be created.
IndexedInteraction	Defines the specification for a call to a JCA interaction that uses indexed records.
Indexes	Allow a set of database indexes to be define on an Entity.
IndexExpression	The INDEX function returns an integer value corresponding to the position of its argument in an ordered list.
IndexExpressionFactory	This IndexExpressionFactory creates a new IndexExpression when the portion of the query to parse starts with INDEX.
IndexExpressionStateObject	The INDEX function returns an integer value corresponding to the position of its argument in an ordered list.
IndirectCollection	Purpose: Common interface to indirect collections.
IndirectCollectionsFactory	Provides factory methods to create JDK specific implementation of particular type of IndirectCollection.
IndirectCollectionsFactory.IndirectCollectionsProvider	Define API providers of IndirectCollection implementations must conform to.
IndirectContainer	Purpose: Define an interface for a Container that can also act as an EclipseLink "indirection" object; i.e. the Container will only read its contents from the database when necessary (typically, on receipt of the first Container-related message).
IndirectList<E>	IndirectList allows a domain class to take advantage of TopLink indirection without having to declare its instance variable as a ValueHolderInterface.
IndirectMap<K,V>	IndirectMap allows a domain class to take advantage of TopLink indirection without having to declare its instance variable as a ValueHolderInterface.
IndirectSet<E>	IndirectSet is an example implementation of the Set protocol that allows a domain class to take advantage of TopLink Indirection without having to declare its instance variable as a ValueHolderInterface.
INewValueStateObjectBuilder
InExpression	The state field path expression must have a string, numeric, or enum value.
InExpressionBNF	The query BNF for an in expression.
InExpressionExpressionBNF	The query BNF describes the expression being tested by the IN expression.
InExpressionFactory	This InExpressionFactory creates a new InExpression when the portion of the query to parse starts with IN or NOT IN.
InExpressionItemBNF	The query BNF for the items of an IN expression.
InExpressionStateObject	The state field path expression must have a string, numeric, or enum value.
Informix11Platform	An InformixPlatform that fixes many EclipseLink bugs related to Informix support.
InformixPlatform	Purpose: Provides Informix specific behavior.
Inheritance	Specifies the inheritance strategy to be used for an entity class hierarchy.
Inheritance	JPA scripting API implementation.
InheritancePolicy	Purpose: Allows customization of an object's inheritance.
InheritanceType	Defines inheritance strategy options.
InMemoryArchive	This archive is designed for use with dynamic persistence units it is built with a stream that allows it to read a persistence.xml file and creates a fake base URL based the classpath location of the InMemoryArchiveClass
InMemoryQueryIndirectionPolicy	Purpose: Provide a means of controlling the behavior of in-memory and conforming queries that access un-instantiated indirection objects in processing the query against cached objects.
InputParameter	Either positional or named parameters may be used.
InputParameterBNF	The query BNF for a input parameter.
InputParameterStateObject	Either positional or named parameters may be used.
InsertObjectQuery	Purpose: Used for inserting new objects into the database.
InstantiationCopyPolicy	An InstantiationCopyPolicy is used to set an org.eclipse.persistence.descriptors.copying.InstantiationCopyPolicy on an Entity.
InstantiationCopyPolicy	Purpose: This is the default copy policy.
InstantiationCopyPolicy	JPA scripting API implementation.
IntegrityChecker	Purpose: IntegrityChecker is used for catching all the descriptor exceptions, and checking database tables.
IntegrityException	Purpose: IntegrityExceptions is used to throw all the Descriptors exceptions.
InterfacePolicy	Purpose: Allows for a descriptor's implemented interfaces to be configured.
InternalAggregateFunctionBNF	The query BNF for the parameter of an aggregate expression.
InternalBetweenExpressionBNF	The query BNF for the lower and upper expressions defined in the between expression.
InternalCoalesceExpressionBNF	The query BNF for the parameters defined in the coalesce expression.
InternalColumnExpressionBNF	The query BNF for the items of a COLUMN expression.
InternalConcatExpressionBNF	The query BNF for the COUNT expression's encapsulated expressions.
InternalConnectByClauseBNF
InternalCountBNF	The query BNF for the parameter of the COUNT function.
InternalEntityTypeExpressionBNF	The query BNF for the parameters defined in the type expression.
InternalFromClauseBNF	The query BNF for the FROM declaration, basically what follows the FROM identifier.
InternalJoinBNF	The query BNF for what's following the join identifier.
InternalLengthExpressionBNF	The query BNF for the parameter of the LENGTH expression.
InternalLocateStringExpressionBNF	The query BNF for the first two parameters of the LOCATE expression.
InternalLocateThirdExpressionBNF	The query BNF for the third parameter of the LOCATE expression.
InternalLowerExpressionBNF	The query BNF for the parameter of the LOWER expression.
InternalModExpressionBNF	The query BNF for the parameters of the MOD expression.
InternalOrderByClauseBNF	The query BNF for what's following the order by identifier.
InternalOrderByItemBNF	The query BNF for an order by item.
InternalOrderByItemFactory	This InternalOrderByItemFactory creates either a StateFieldPathExpression or an IdentificationVariable.
InternalSelectExpressionBNF
InternalSimpleFromClauseBNF	The query BNF for the from declaration used in a subquery.
InternalSimpleSelectExpressionBNF
InternalSqrtExpressionBNF	The query BNF for the parameter of the SQRT expression.
InternalSubstringPositionExpressionBNF	The query BNF for the position parameters of the SUBSTRING expression.
InternalSubstringStringExpressionBNF	The query BNF for the parameter of the LENGTH expression.
InternalUpdateClauseBNF	The query BNF for what's following the update identifier.
InternalUpperExpressionBNF	The query BNF for the parameter of the UPPER expression.
InternalWhenClauseBNF	The query BNF for the expression following the WHEN identifier.
IPropertyChangeEvent<T>	This is used in conjunction with IPropertyChangeListener.
IPropertyChangeListener<T>	A IPropertyChangeListener can be registered with a StateObject in order to be notified when the value of a property changes.
IQuery	The external representation of a JPQL query.
IScalarExpressionStateObjectBuilder<T extends IScalarExpressionStateObjectBuilder<T>>	This builder can be used to easily create a scalar expression without having to create each object manually.
ISelectExpressionStateObjectBuilder	This builder can be used to easily create a select expression without having to create each object manually.
IsExpressionFactory	This IsExpressionFactory creates a new expression when the portion of the query to parse starts with IS.
ISimpleSelectExpressionStateObjectBuilder	This builder can be used to easily create a select expression defined for a subquery without having to create each object manually.
IsSetNullPolicy	PUBLIC: Description: This null policy allows for various configurations of isSet behavior to be set. Marshal: The boolean value of the isSet() state of a node will determine whether a node will be written out for a null value.
ItemLinksBuilder	Convenient ItemLinks object builder.
ItemLinksMetadataSource	Makes the ItemLinks class available in our Dynamic JAXB context.
IType	The external representation of a Java type.
ITypeDeclaration	The external representation of a type declaration, which is used to give more information about the type, i.e. if it's an array and if it has parameter types.
ITypeHelper
ITypeRepository	The external representation of the repository of Java types, which gives access to the application's classes.
JavaAnnotation	INTERNAL:
JavaAnnotationImpl	INTERNAL:
JavaAttribute	Java class for java-attribute complex type.
JavaClass	INTERNAL:
JavaClassCompareByNamespace
JavaClassImpl	INTERNAL:
JavaClassInstanceOf	INTERNAL:
JavaConstructor	Purpose: JavaModel representation of a java.lang.reflect.Constructor object.
JavaConstructorImpl	Purpose: JavaModel representation of a java.lang.reflect.Constructor object.
JavaDBPlatform	Purpose: Allows to use JavaDBPlatform as a synonym for DerbyPlatform
JavaField	INTERNAL:
JavaFieldImpl	INTERNAL:
JavaHasAnnotations	INTERNAL:
JavaLangMetadataSource	Makes java.lang package classes available to JPA-RS JAXB context.
JavaLog	PUBLIC:
JavaMathMetadataSource	Makes java.math package classes available to JPA-RS JAXB context.
JavaMethod	INTERNAL:
JavaMethodImpl	INTERNAL:
JavaModel	INTERNAL:
JavaModelImpl	INTERNAL:
JavaModelInput	INTERNAL:
JavaModelInputImpl	INTERNAL:
JavaPackage	INTERNAL:
JavaPackageImpl	INTERNAL:
JavaSerializer	Plain old Java serialization.
JavaType	Java class for anonymous complex type.
JavaType.JavaAttributes	Java class for anonymous complex type.
JavaUtilMetadataSource	Makes java.util package classes available to JPA-RS JAXB context.
JAXB	Class that defines convenience methods for common, simple use of JAXB.
JAXBBinder	INTERNAL
JAXBContext	The JAXBContext class provides the client's entry point to the JAXB API.
JAXBContext	Purpose:Provide a EclipseLink implementation of the JAXBContext interface.
JAXBContext.JAXBContextInput	The JAXBContextInput is used to create a JAXBContextState which is responsible for accessing the underlying XMLContext
JAXBContext.JAXBContextState
JAXBContextFactory	Factory that creates new JAXBContext instances.
JAXBContextFactory	Purpose:An EclipseLink specific JAXBContextFactory.
JAXBContextProperties	These are properties that may be passed in to create a JAXBContext:
JAXBElement<T>	JAXB representation of an Xml Element.
JAXBElement.GlobalScope	Designates global scope for an xml element.
JAXBEnumTypeConverter	INTERNAL:
JAXBErrorHandler	Implementation of org.xml.sax.ErrorHandler.
JAXBException	This is the root exception class for all JAXB exceptions.
JAXBException	Purpose: This class provides an implementation of EclipseLinkException specific to the EclipseLink JAXB implementation
JAXBExceptionResource	INTERNAL: Purpose:
JAXBHelper	This class provides a mechanism to obtain the EclipseLink implementation of various JAXB runtime classes based on a given JAXB class/interface.
JAXBIntrospector	Provide access to JAXB xml binding data for a JAXB object.
JAXBIntrospector	INTERNAL
JAXBMarshaller	INTERNAL:
JAXBMarshalListener	INTERNAL:
JAXBMetadataLogger	Class used to log warnings during the processing of JAXB annotations and OXM XML bindings files.
JAXBPermission	This class is for JAXB permissions.
JAXBResult	JAXP Result implementation that unmarshals a JAXB object.
JAXBSource	JAXP Source implementation that marshals a JAXB-generated object.
JAXBTypeElement	Subclass of JAXBElement to allow the use of ParameterizedTypes.
JAXBTypesafeEnumConverter	Purpose: JAXBTypesafeEnumConverter is used to allow mapping to type safe enums according to the JAXB 1.0 spec.
JAXBUnmarshaller	INTERNAL:
JAXBUnmarshallerHandler	Implementation of UnmarshallerHandler to be used by JAXBUnmarshaller.
JAXBUnmarshalListener	INTERNAL:
JAXBValidator	Facilitates JAXBValidation.
JAXPNamespaceContext	Purpose: Wrap a org.eclipse.persistence.platform.xml.XMLNamespaceResolver and expose it as a javax.xml.namespace.NamespaceContext.
JAXPParser	Purpose: An implementation of XMLParser using JAXP 1.3 APIs.
JAXPPlatform	Purpose: An implementation of XMLPlatform using JAXP 1.3 APIs.
JAXPTransformer	Purpose: An implementation of XMLTransformer using JAXP 1.3 APIs.
JBossPlatform	PUBLIC: This is the concrete subclass responsible for representing JBoss-specific server behavior.
JBossRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
JBossTransactionController	Purpose: TransactionController implementation for JBoss JTA
JCEEncryptorCmd
JDBCType	PUBLIC: Marker interface for JDBC type metadata
JDBCTypes	PUBLIC: JDBC types
JMSProcessingExceptionResource	INTERNAL: English ResourceBundle for JMSProcessingException messages.
JMSPublishingHelper	This helper class allows access to abstract JMSPublishingTransportManager internals when processing JMS messages for RCM, and can be expanded upon to include other EclipseLink JMS functionality.
JMSPublishingTransportManager	Purpose: Provide a transport implementation for the Remote Command Module (RCM) that publishes to a JMS topic.
JMSTopicTransportManager	Purpose: Provide a transport implementation for the Remote Command Module (RCM) that both publishes and subscribes to a JMS topic.
JMXEnabledPlatform	PUBLIC: This interface must be implemented by server platform classes that have JMX/MBean functionality enabled in EclipseLink. As of EclipseLink
JMXServerPlatformBase	PUBLIC: Subclass of org.eclipse.persistence.platform.server.ServerPlatformBase in support of the JMXEnabledPlatform interface
JNDIConnector	Specifies the J2EE DataSource lookup options.
Join<Z,X>	A join to an entity, embeddable, or basic type.
Join	A JOIN enables the fetching of an association as a side effect of the execution of a query.
JoinAssociationPathExpressionBNF	The query BNF for a join association path expression.
JoinBNF	The query BNF for the join expression.
JoinCollectionValuedPathExpressionFactory
JoinColumn	Specifies a column for joining an entity association or element collection.
JoinColumn	JPA scripting API implementation.
JoinColumns	Specifies the mapping for composite foreign keys.
JoinFactory	This JoinFactory creates a new Join when the portion of the query to parse starts with JOIN or FETCH JOIN, respectively.
JoinFetch	A JoinFetch annotation can be used on any relationship mapping, (OneToOne, ManyToOne, OneToMany, ManyToMany, BasicCollection, BasicMap).
JoinFetchBNF	The query BNF for the fetch join expression.
JoinFetchType	An enum type that is used within the JoinFetch annotation.
JoinField	JPA scripting API implementation.
JoinStateObject	A JOIN enables the fetching of an association as a side effect of the execution of a query.
JoinTable	Specifies the mapping of associations.
JoinTable	JPA scripting API implementation.
JoinType	Defines the three types of joins.
JotmTransactionController	Purpose: TransactionController implementation for JOTM
JpaCache	Extends JPA Cache interface with additional EclipseLink API.
JpaCriteriaBuilder	PUBLIC: EclipseLInk specific JPA Criteria interface.
JPADynamicHelper
JPADynamicTypeBuilder
JpaEntityManager	Purpose: Defines the Interface for EclipseLink extensions to the EntityManager
JpaEntityManagerFactory	Purpose: Defines the Interface for EclipseLink extensions to the EntityManagerFactory
JpaHelper	This sample illustrates the JPA helper methods that may be of use to EclipseLink customers attempting to leverage EclipseLink specific functionality.
JpaQuery<X>	PUBLIC: EclipseLInk specific JPA query interface.
JPAQueryBuilder	This interface defines the entry point for implementing a JPQL query parsing system in EclipseLink.
JPARSErrorCodes
JPARSException
JPARSExceptionMapper
JPARSExceptionResource
JPARSLogger	Logger for EclipseLink JPA-RS related functionality.
JPAVersion	An enumeration listing the various releases of the Java Persistence specification.
JPQLCall	Purpose: Used as an abstraction of a database invocation.
JPQLException	Purpose: EJBQL parsing and resolution problems will raise this exception
JPQLExceptionResource	INTERNAL: English ResourceBundle for EJBQLException.
JPQLExpression	A JPQLExpression is the root of the parsed tree representation of a JPQL query.
JPQLGrammar	A JPQL grammar defines how a JPQL query can be parsed.
JPQLGrammar1_0	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-220 - Enterprise JavaBeans 3.0.
JPQLGrammar2_0	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.
JPQLGrammar2_1	This JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1.
JPQLQueryBNF	This defines a single Backus-Naur Form (BNF) of the JPQL grammar.
JPQLQueryBuilder1_0	An implementation of IJPQLQueryBuilder that provides support based on the Java Persistence functional specification defined in JSR-220 - Enterprise JavaBeans 3.0.
JPQLQueryBuilder2_0	An implementation of IJPQLQueryBuilder that provides support based on the Java Persistence functional specification defined in JSR-337 - Java Persistence 2.0.
JPQLQueryBuilder2_1	An implementation of IJPQLQueryBuilder that provides support based on the Java Persistence functional specification defined in JSR-338 - Java Persistence 2.1.
JPQLQueryBuilderWrapper	This builder wraps another builder and simply delegates the calls to it.
JPQLQueryContext	This context is used to store information related to the JPQL query.
JPQLQueryContext.QueryExpressionVisitor	This visitor is responsible to retrieve the Expression that is the beginning of a query.
JPQLQueryDeclaration	A JPQLQueryDeclaration represents either an identification variable declaration or a collection member declaration.
JPQLQueryDeclaration.Type	This enum type defines the various types of declarations supported by both the JPA functional specification and EclipseLink.
JPQLQueryProblem	A problem describes an issue found in a JPQL query because it is either grammatically or semantically incorrect.
JPQLQueryProblemMessages	The list of messages used by JPQLQueryProblems when validating a JPQL query.
JPQLQueryProblemResourceBundle	The resource bundle containing the problems encountered in a JPQL query.
JPQLQueryStateObject	This is the root of the StateObject hierarchy that represents a JPQL query.
JPQLStatementBNF	The query BNF for the JPQL expression.
JsonArrayBuilderResult
JsonBuilderRecord
JsonBuilderRecord.Level	Instances of this class are used to maintain state about the current level of the JSON message being marshalled.
JSONException	Purpose: This class provides an implementation of EclipseLinkException specific to the EclipseLink JSON handling (marshall, unmarshall, Jersey provider)
JSONExceptionResource	INTERNAL: Purpose:
JSONFormattedWriterRecord	Use this type of MarshalRecord when the marshal target is a Writer and the JSON should be formatted with carriage returns and indenting.
JsonGeneratorRecord
JsonGeneratorResult
JsonObjectBuilderResult
JsonParserSource	Object to be used with Unmarshaller to unmarshal JsonParser objects Usage: JsonParserSource source = new JsonParserSource(jsonParser); Object unmarshalled = jaxbUnmarshaller.unmarshal(source);
JsonRecord<T extends JsonRecord.Level>
JsonRecord.Level	Instances of this class are used to maintain state about the current level of the JSON message being marshalled.
JsonSchemaOutputResolver	PUBLIC:
JSONSerializer	Uses EclipseLink Moxy to convert an object to JSON.
JsonStructureSource	Object to be used with Unmarshaller to unmarshal javax.json.JsonStructure objects (ie: javax.json.JsonObject or javax.json.JsonArray) Usage: JsonStructureSource source = new JsonStructureSource(jsonObject); Object unmarshalled = jaxbUnmarshaller.unmarshal(source);
JSONWithPadding<T>	JSONWithPadding is used to hold an Object along with the corresponding callback name to marshal.
JSONWriterRecord	Use this type of MarshalRecord when the marshal target is a Writer and the JSON should not be formatted with carriage returns or indenting.
JSONWriterRecord.Level	Instances of this class are used to maintain state about the current level of the JSON message being marshalled.
JSONWriterRecord.Output
JSONWriterRecord.OutputStreamOutput
JTASynchronizationListener	Purpose: Synchronization object implementation for JTA 1.0
JTATransactionController	Purpose: TransactionController implementation for JTA 1.0
JTATransactionWrapper
KeyExpression	An identification variable qualified by the KEY operator is a path expression.
KeyExpressionFactory	This KeyExpressionFactory creates a new KeyExpression when the portion of the query to parse starts with KEY.
KeyExpressionStateObject	This object represents an identification variable that maps the keys of a Map.
KeyResolver	This Resolver is responsible to return the map key, which means that for identification variables referring to an instance of an association or collection represented as a Map, the identification variable is of the abstract schema type of the map key.
KeywordExpression	The expression representing some keywords: TRUE, FALSE or NULL.
KeywordExpressionFactory	This KeywordExpressionFactory creates a new KeywordExpression when the portion of the JPQL query to parse is FALSE, TRUE or NULL.
KeywordExpressionStateObject	The expression representing some keywords: TRUE, FALSE or NULL.
LengthExpression	The LENGTH function returns the length of the string in characters as an integer.
LengthExpressionFactory	This LengthExpressionFactory creates a new LengthExpression when the portion of the query to parse starts with LENGTH.
LengthExpressionStateObject	The LENGTH function returns the length of the string in characters as an integer.
LikeExpression	The LIKE condition is used to specify a search for a pattern.
LikeExpressionBNF	The query BNF for a expression.
LikeExpressionEscapeCharacterBNF	This BNF is used when parsing an invalid fragment or to extend the default grammar.
LikeExpressionFactory	This LikeExpressionFactory creates a new LikeExpression when the portion of the query to parse starts with LIKE or NOT LIKE.
LikeExpressionStateObject	The LIKE condition is used to specify a search for a pattern.
LinkAdapter	Used with JAXB to convert from a URL representing an relationship to an object It provides functionality at marshall and unmarshall time At marshall time, the target of a relationship will be marshalled as a URL that could be used to find the object through a REST service At unmarsall time, the URL will be deconstructed and used to find the object in JPA.
LinkList	This class is used to wrap collection of Link objects
LinkMetadataSource	Makes the Link class available in our Dynamic JAXB context.
LinkV2MetadataSource	Makes the LinkV2 class available in our Dynamic JAXB context.
ListAttribute<X,E>	Instances of the type ListAttribute represent persistent javax.util.List-valued attributes.
ListChangeEvent<T>	The default implementation of IListChangeListener where the generics is the type of the items.
ListExpressionOperator	INTERNAL: A ListExpressionOperator is used with an ArgumentListFunctionExpression.
ListHolderStateObject<T>	A ListHolderStateObject is a StateObject having a list of children and this gives access to some operation over the list.
ListIterable<T>	A ListIterable simply forces the returned object to be an instance of ListIterator.
ListJoin<Z,E>	The ListJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.List.
LiteralBNF	The query BNF for literals, which is based on the listing defined in section 4.6.1 of the Java Specification document for JPA 2.0.
LiteralExpressionFactory	This LiteralExpressionFactory is responsible to return the right literal expression.
LiteralType	Some Expression can have a "literal", this enumeration is used to visit an Expression and to retrieve the right value.
LiteralVisitor	This visitor traverses an Expression and retrieves the "literal" value.
LoadGroup	Purpose: Used to load specified relationship attributes and nested relationship attributes.
LoadState	Load states returned by the ProviderUtil SPI methods.
Lob	Specifies that a persistent property or field should be persisted as a large object to a database-supported large object type.
Lob	JPA scripting API implementation.
LocateExpression	The LOCATE function returns the position of a given string within a string, starting the search at a specified position.
LocateExpressionFactory	This LocateExpressionFactory creates a new LocateExpression when the portion of the query to parse starts with LOCATE.
LocateExpressionStateObject	The LOCATE function returns the position of a given string within a string, starting the search at a specified position.
LockModeType	Lock modes can be specified by means of passing a LockModeType argument to one of the EntityManager methods that take locks (lock, find, or refresh) or to the Query.setLockMode() or TypedQuery.setLockMode() method.
LockTimeoutException	Thrown by the persistence provider when an pessimistic locking conflict occurs that does not result in transaction rollback.
LogCategory	EclipseLink categories used for logging name space.
LogFormatter	Print a brief summary of a TopLink LogRecord in a human readable format.
LoggerType	Logger type persistence property values.
LoggingLocalization
LoggingLocalizationResource
LogicalExpression	This expression represents a logical expression, which means the first and second expressions are aggregated with either AND or OR.
LogicalExpressionStateObject	This expression represents a logical expression, which means the first and second expressions are aggregated with either the AND or the OR operator.
Login	Purpose: Define the information required to connect to an EclipseLink session.
LogLevel	Log levels for EclipseLink logging.
LowerExpression	The LOWER function converts a string to lower case and it returns a string.
LowerExpressionFactory	This LowerExpressionFactory creates a new LowerExpression when the portion of the query to parse starts with LOWER.
LowerExpressionStateObject	The LOWER function converts a string to lower case and it returns a string.
ManagedType<X>	Instances of the type ManagedType represent entity, mapped superclass, and embeddable types.
ManyToMany	Specifies a many-valued association with many-to-many multiplicity.
ManyToMany	JPA scripting API implementation.
ManyToManyMapping	Purpose: Many to many mappings are used to represent the relationships between a collection of source objects and a collection of target objects.
ManyToManyQueryKey	Purpose:Represents a m-m join query.
ManyToOne	Specifies a single-valued association to another entity class that has many-to-one multiplicity.
ManyToOne	JPA scripting API implementation.
ManyToOneMapping	Purpose: Define the relationship to be a ManyToOne.
MapAttribute<X,K,V>	Instances of the type MapAttribute represent persistent java.util.Map-valued attributes.
MapChangeEvent	Purpose: Define a change event for Map types.
MapComponentMapping	A MapComponentMapping is any mapping that can be used as the key or the value in a mapping that uses a MappedKeyMapContainerPolicy.
MapJoin<Z,K,V>	The MapJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.Map.
MapKey	Specifies the map key for associations of type java.util.Map when the map key is itself the primary key or a persistent field or property of the entity that is the value of the map.
MapKey	JPA scripting API implementation.
MapKeyClass	Specifies the type of the map key for associations of type java.util.Map.
MapKeyColumn	Specifies the mapping for the key column of a map whose map key is a basic type.
MapKeyConvert	The MapKeyConvert annotation specifies that a named converter should be used with the corresponding mapped attribute key column.
MapKeyEnumerated	Specifies the enum type for a map key whose basic type is an enumerated type.
MapKeyJoinColumn	Specifies a mapping to an entity that is a map key.
MapKeyJoinColumns	Supports composite map keys that reference entities.
MapKeyMapping	MapKeyMapping is implemented by DatabaseMappings that can be used to map the key in a map that uses a MappedKeyMapContainerPolicy.
MapKeyTemporal	This annotation must be specified for persistent map keys of type Date and Calendar.
MappedInteraction	Defines the specification for a call to a JCA interaction using Mapped records.
MappedSuperclass	Designates a class whose mapping information is applied to the entities that inherit from it.
MappedSuperclass	JPA scripting API implementation.
MappedSuperclassType<X>	Instances of the type MappedSuperclassType represent mapped superclass types.
Mappings	JPA scripting API implementation.
MappingsGenerator	INTERNAL:
MapsId	Designates a ManyToOne or OneToOne relationship attribute that provides the mapping for an EmbeddedId primary key, an attribute within an EmbeddedId primary key, or a simple primary key of the parent entity.
MarshalCallback	INTERNAL:
MarshalException	This exception indicates that an error has occurred while performing a marshal operation that the provider is unable to recover from.
Marshaller	The Marshaller class is responsible for governing the process of serializing Java content trees back into XML data.
Marshaller.Listener	Register an instance of an implementation of this class with a Marshaller to externally listen for marshal events.
MarshallerProperties	These are properties that may be set on an instance of Marshaller.
MarshalRecord<MARSHALLER extends org.eclipse.persistence.internal.oxm.Marshaller>	A MarshalRecord encapsulates the marshal target.
MatrixParameters
MaxDBPlatform	Database Platform for SAP MaxDB.
MaxFacet
MaxFunction	One of the aggregate functions.
MaxFunctionFactory	This MaxFunctionFactory creates a new MaxFunction when the portion of the query to parse starts with MAX.
MaxFunctionStateObject	One of the aggregate functions.
MBeanDevelopmentServices	Purpose: Provide a dynamic interface into the EclipseLink Identity Map Manager.
MBeanDevelopmentServicesMBean	Purpose: Provide a dynamic interface into the EclipseLink Identity Map Manager.
MBeanGlassfishRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanGlassfishRuntimeServicesMBean	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanJBossRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanJBossRuntimeServicesMBean	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanRuntimeServicesMBean	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanWebLogicRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanWebLogicRuntimeServicesMBean	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanWebSphereRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
MBeanWebSphereRuntimeServicesMBean	Purpose: Provide a dynamic interface into the EclipseLink Session.
MediaType	This enum represents the different media types supported by EclipseLink MOXy.
MergeChangeSetCommand	Purpose: Provide a remote command implementation for remote cache merges of changes.
Metadata
MetadataRefreshListener
MetadataResource	JPARS 2.0 metadata catalog.
MetadataSource
MetadataSource	Purpose: Interface used to support additional persistence unit metadata being provided from outside of what was packaged within the application.
MetadataSourceAdapter	You may subclass this class rather than implement the MetadataSource interface allowing insulation from future additions to the interface.
MetadataSourceAdapter	Purpose: To provide a trivial implementation of MetadataSource.
Metamodel	Provides access to the metamodel of persistent entities in the persistence unit.
MethodBasedAttributeTransformer
MethodBasedFieldTransformer
MethodBaseQueryRedirector	Purpose: Allows a class to be a QueryRedirector without implementing QueryRedirector.
MethodClassExtractor	Purpose: Used to allow complex inheritance support.
MethodExitLogData
MigrateTopLinkToEclipseLink	Provides a product rename utility specific to moving Oracle TopLink source to EclipseLink.
MimeTypePolicy	Purpose:
MinFacet
MinFunction	One of the aggregate functions.
MinFunctionFactory	This MinFunctionFactory creates a new MinFunction when the portion of the query to parse starts with MIN.
MinFunctionStateObject	One of the aggregate functions.
ModExpression	The modulo operation finds the remainder of division of one number by another.
ModExpressionFactory	This ModExpressionFactory creates a new ModExpression when the portion of the query to parse starts with MOD.
ModExpressionStateObject	The modulo operation finds the remainder of division of one number by another.
ModifyAllQuery	PUBLIC: Query used to perform a bulk delete using the expression framework.
ModifyQuery	Purpose: Abstract class for all modify queries.
ModuleUtil	Intended to be overridden on JDK9, with JEP 238 multi-release class copy.
MOXyJsonProvider	This is an implementation of MessageBodyReader/MessageBodyWriter that can be used to enable EclipseLink JAXB (MOXy) as the JSON provider.
MOXySystemProperties
MultiplicationExpression	One of the four binary operators.
MultiplicationExpressionStateObject	TODO: BNF: arithmetic_expression ::= arithmetic_expression * arithmetic_term
Multitenant	Multitenant specifies that a given entity is shared amongst multiple tenants of a given application.
Multitenant	JPA scripting API implementation.
MultitenantPolicy	A multitenant interface.
MultitenantPrimaryKeyMapping	Purpose: Maps a multitenant property to the corresponding database field type.
MultitenantType	An enum that is used within the Multitenant annotation.
Mutable	A Mutable annotation can be used on a @Basic mapping.
MySQLPlatform	Purpose: Provides MySQL specific behavior.
NamedAttributeNode	A NamedAttributeNode is a member element of a NamedEntityGraph.
NamedEntityGraph	Used to specify the path and boundaries for a find operation or query.
NamedEntityGraphs	Used to group NamedEntityGraph annotations.
NamedNativeQueries	Specifies multiple native SQL named queries.
NamedNativeQuery	Specifies a named native SQL query.
NamedNativeQuery	JPA scripting API implementation.
NamedPLSQLStoredFunctionQueries	A NamedPLSQLStoredFunctionQueries annotation allows the definition of multiple NamedPLSQLStoredFunctionQuery.
NamedPlsqlStoredFunctionQuery	JPA scripting API implementation.
NamedPLSQLStoredFunctionQuery	A NamedPLSQLStoredFunctionQuery annotation allows the definition of queries that call PLSQL stored functions as named queries.
NamedPLSQLStoredProcedureQueries	A NamedPLSQLStoredProcedureQueries annotation allows the definition of multiple NamedPLSQLStoredProcedureQuery.
NamedPlsqlStoredProcedureQuery	JPA scripting API implementation.
NamedPLSQLStoredProcedureQuery	A PLSQLNamedStoredProcedureQuery annotation allows the definition of queries that call PLSQL stored procedures as named queries.
NamedQueries	Specifies multiple named Jakarta Persistence query language queries.
NamedQuery	Specifies a static, named query in the Jakarta Persistence query language.
NamedQuery	JPA scripting API implementation.
NamedStoredFunctionQueries	A NamedStoredFunctionQueries annotation allows the definition of multiple NamedStoredFunctionQuery.
NamedStoredFunctionQuery	A NamedStoredFunctionQuery annotation allows the definition of queries that call stored functions as named queries.
NamedStoredFunctionQuery	JPA scripting API implementation.
NamedStoredProcedureQueries	Specifies multiple named stored procedure queries.
NamedStoredProcedureQueries	A NamedStoredProcedureQueries annotation allows the definition of multiple NamedStoredProcedureQuery.
NamedStoredProcedureQuery	Specifies and names a stored procedure, its parameters, and its result type.
NamedStoredProcedureQuery	A NamedStoredProcedureQuery annotation allows the definition of queries that call stored procedures as named queries.
NamedStoredProcedureQuery	JPA scripting API implementation.
NamedSubgraph	A NamedSubgraph is a member element of a NamedEntityGraph.
NamespaceInfo	INTERNAL:
NamespacePrefixMapper	Purpose:Provides a means to customise the namespace prefixes used while marshalling An implementation of this class can be set on an instance of XMLMarshaller to allow for each instance of XMLMarshaller to use different namespace prefixes.
NamespaceResolver	It is common for an XML document to include one or more namespaces.
NativeSequence	Purpose: Define a database's native sequencing mechanism.
NestedTableDefinition	Purpose: Allow for creation of nested table types.
NestedTableMapping	Purpose: Nested tables are similar to VARRAYs except internally they store their information in a separate table from their parent structure's table.
NewValueBNF	The query BNF for a new value expression.
NodeOrderingPolicy	Purpose:Provide a policy that specifies how new XML Elements are added to an existing XML Document.
NodeRecord	Use this type of MarshalRecord when the marshal target is a Node.
NoExpiryCacheInvalidationPolicy	PUBLIC: A cache invalidation policy in which no objects will expire.
Noncacheable	The NonCacheable annotation is used to configure caching behavior for relationships.
NonUniqueResultException	Thrown by the persistence provider when Query.getSingleResult() or TypedQuery.getSingleResult() is executed on a query and there is more than one result from the query.
NoResultException	Thrown by the persistence provider when Query.getSingleResult() or TypedQuery.getSingleResult()is executed on a query and there is no result to return.
NormalizedStringAdapter	XmlAdapter to handle xs:normalizedString.
NoServerPlatform	PUBLIC: This platform is used when EclipseLink is not within any server (Oc4j, WebLogic, ...)
NoServerPlatformDetector
NoSql	JPA scripting API implementation.
NotExpression	BNF: expression ::= NOT conditional_primary
NotExpressionFactory	This NotExpressionFactory creates a new NotExpression when the portion of the query to parse starts with NOT.
NotExpressionStateObject	BNF: expression ::= NOT conditional_primary
NotIdentifiableEvent	This event indicates that a problem was encountered resolving an ID/IDREF.
NotIdentifiableEventImpl	Default implementation of the NotIdentifiableEvent interface.
NullComparisonExpression	A null comparison tests whether or not the single-valued path expression or input parameter is a NULL value.
NullComparisonExpressionBNF	The query BNF for a null comparison expression.
NullComparisonExpressionStateObject	A null comparison tests whether or not the single-valued path expression or input parameter is a NULL value.
NullExpression	A null Expression is used instead of a true null, which allows operations to be performed without doing a null check first.
NullFilter	A null implementation of a Filter.
NullIfExpression	NULLIF returns the first expression if the two expressions are not equal.
NullIfExpressionBNF	The query BNF for a nullif expression.
NullIfExpressionFactory	This NullIfExpressionFactory creates a new NullIfExpression when the portion of the query to parse starts with NULLIF.
NullIfExpressionStateObject	NULLIF returns the first expression if the two expressions are not equal.
NullPolicy	PUBLIC: Description: This null policy is the default implementation class. Marshal: The boolean value of the isSet() state of a node has no effect on whether a node will be written out for a null value - a set is always performed unless the isSetPerformedForAbsentNode flag is set to false for absent nodes. Unmarshal:
NullResolver	A "null" implementation of a Resolver.
NumericLiteral	Exact numeric literals support the use of Java integer literal syntax as well as SQL exact numeric literal syntax.
NumericLiteralBNF	The query BNF for a numeric literal.
NumericLiteralStateObject	Exact numeric literals support the use of Java integer literal syntax as well as SQL exact numeric literal syntax.
NumericResolver	This Resolver is responsible to return the numeric type for a list of Resolvers.
NumericTypeComparator	This Comparator is used to sort ITypes based on the numerical priority.
ObjectArrayMapping	Purpose: In an object-relational data model, structures can contain "Arrays" or collections of other data-types.
ObjectBuildingQuery	Purpose: Abstract class for all read queries that build objects and potentially manipulate the TopLink cache.
ObjectChangePolicy	INTERNAL: Implementers of ObjectChangePolicy implement the code which computes changes sets for the UnitOfWork commit process.
ObjectChangeSet	Purpose: Provides API to the Class that holds all changes made to a particular Object.
ObjectChangeTrackingPolicy	PUBLIC: A ObjectChangeTrackingPolicy allows an object to calculate for itself whether it should has changed by implementing ChangeTracker.
ObjectCopyingPolicy	Deprecated. use CopyGroup instead.
ObjectExpression	Stand-alone identification variables in the SELECT clause may optionally be qualified by the OBJECT operator.
ObjectExpressionBNF	The query BNF for an object expression.
ObjectExpressionFactory	This ObjectExpressionFactory creates a new ObjectExpression when the portion of the query to parse starts with OBJECT.
ObjectExpressionStateObject	Stand-alone identification variables in the SELECT clause may optionally be qualified by the OBJECT operator.
ObjectFactory	This object contains factory methods for each Java content interface and Java element interface generated in the org.eclipse.persistence.jaxb.xmlmodel package.
ObjectGraph	This type represents the root of an object graph that will be used as a template to define the attribute nodes and boundaries of a graph of JAXB objects and relationships.
ObjectGraphBuilder	Builds object graph for JPARS 2.0.
ObjectLevelModifyQuery	Purpose: Abstract class for all object modify queries.
ObjectLevelReadQuery	Purpose: Abstract class for all read queries using objects.
ObjectReferenceChangeRecord	Purpose: Provides API for the ObjectReferenceChangeRecord.
ObjectReferenceMapping	Purpose: Abstract class for 1:1, variable 1:1 and reference mappings
ObjectRelationalDatabaseField	INTERNAL: A database field of object-relational type: either a java.sql.Array, java.sql.Struct, or java.sql.Ref.
ObjectRelationalDataTypeDescriptor	Purpose: Differentiates object-relational descriptors from normal relational descriptors.
ObjectTypeConverter	The ObjectTypeConverter annotation is used to specify a TopLink org.eclipse.persistence.mappings.converters.ObjectTypeConverter that converts a fixed number of database data value(s) to Java object value(s) during the reading and writing of a mapped attribute An ObjectTypeConverter must be be uniquely identified by name and can be defined at the class, field and property level and can be specified within an Entity, MappedSuperclass and Embeddable class.
ObjectTypeConverter	JPA scripting API implementation.
ObjectTypeConverter	Purpose: Object type converter is used to match a fixed number of database data values to Java object value.
ObjectTypeConverters	An ObjectTypeConverters annotation allows the definition of multiple ObjectTypeConverter.
ObjectVarrayDefinition	Purpose: Allow for creation of object varray type.
Oc4jPlatform	PUBLIC: This is the concrete subclass responsible for representing Oc4j-specific server behavior.
Oc4jTransactionController	Purpose: TransactionController implementation for OC4J JTA
OnClause	Returns an expression that allows a join ON clause to be defined.
OnClauseBNF	The query BNF for the on clause.
OnClauseFactory	This OnClauseFactory creates a new OnClause when the portion of the query to parse starts with ON.
OneToMany	Specifies a many-valued association with one-to-many multiplicity.
OneToMany	JPA scripting API implementation.
OneToManyMapping	Purpose: This mapping is used to represent the typical RDBMS relationship between a single source object and collection of target objects; where, on the database, the target objects have references (foreign keys) to the source object.
OneToManyQueryKey	Purpose:Represents a 1-m join query.
OneToOne	Specifies a single-valued association to another entity that has one-to-one multiplicity.
OneToOne	JPA scripting API implementation.
OneToOneMapping	Purpose: One to one mappings are used to represent a pointer references between two java objects.
OneToOneMapping.ShallowMode	Mode for writeFromObjectIntoRowInternal method
OneToOneQueryKey	Purpose: Define an alias to a foreign one to one object.
OptimisticLockException	Thrown by the persistence provider when an optimistic locking conflict occurs.
OptimisticLockException	Purpose: This exception is used when TopLink's optimistic locking feature is used.
OptimisticLockExceptionResource	INTERNAL: English ResourceBundle for OptimisticLockException messages.
OptimisticLocking	The OptimisticLocking annotation is used to specify the type of optimistic locking TopLink should use when updating or deleting entities.
OptimisticLocking	JPA scripting API implementation.
OptimisticLockingType	An enum that is used within the OptimisticLocking annotation.
Oracle10Platform	Purpose: Provides Oracle version specific behavior when org.eclipse.persistence.oracle bundle is not available.
Oracle11Platform	Purpose: Provides Oracle version specific behavior when org.eclipse.persistence.oracle bundle is not available.
Oracle12Platform	Purpose: Provides Oracle version specific behavior when org.eclipse.persistence.oracle bundle is not available.
Oracle18Platform
Oracle19Platform
Oracle21Platform
Oracle23Platform
Oracle8Platform	Purpose: Provides Oracle version specific behavior when org.eclipse.persistence.oracle bundle is not available.
Oracle9Platform	Purpose: Provides Oracle version specific behavior when org.eclipse.persistence.oracle bundle is not available.
OracleArray	JPA scripting API implementation.
OracleArray	An OracleArray annotation is used to define an Oracle database VARRAY type.
OracleArrays	An OracleArrays annotation allows the definition of multiple VARRAY types.
OracleArrayType
OracleDirectToXMLTypeMappingHelper	Helper class to abstract the XML mapping for DirectToXMLType.
OracleObject	JPA scripting API implementation.
OracleObject	An OracleObject annotation is used to define an Oracle database OBJECT type.
OracleObjects	An OracleObjects annotation allows the definition of multiple Oracle OBJECT types.
OracleObjectType
OraclePlatform	Purpose: Provides Oracle specific behavior.
OraclePLSQLType	PUBLIC: Marker interface for Oracle PL/SQL types
OraclePLSQLTypes	PUBLIC: Oracle PL/SQL types
Order	An object that defines an ordering over the query results.
OrderBy	Specifies the ordering of the elements of a collection valued association or element collection at the point when the association or collection is retrieved.
OrderByClause	The ORDER BY clause allows the objects or values that are returned by the query to be ordered.
OrderByClauseBNF	The query BNF for the order by clause.
OrderByClauseFactory	This OrderByClauseFactory creates a new OrderByClause when the portion of the query to parse starts with ORDER BY.
OrderByClauseStateObject	The ORDER BY clause allows the objects or values that are returned by the query to be ordered.
OrderByItem	An orderby_item must be one of the following: A state_field_path_expression that evaluates to an orderable state field of an entity or embeddable class abstract schema type designated in the SELECT clause by one of the following: A general_identification_variable A single_valued_object_path_expression A state_field_path_expression that evaluates to the same state field of the same entity or embeddable abstract schema type as a state_field_path_expression in the SELECT clause A result_variable that refers to an orderable item in the SELECT clause for which the same result_variable has been specified.
OrderByItem.NullOrdering	This enumeration lists all the possible choices for ordering nulls in an item.
OrderByItem.Ordering	This enumeration lists all the possible choices for ordering an item.
OrderByItemBNF	The query BNF for the order by item expression.
OrderByItemFactory	This OrderByItemFactory creates a new OrderByItem.
OrderByItemStateObject	An ORDER BY item must be one of the following: A state_field_path_expression that evaluates to an orderable state field of an entity or embeddable class abstract schema type designated in the SELECT clause by one of the following: A general_identification_variable A single_valued_object_path_expression A state_field_path_expression that evaluates to the same state field of the same entity or embeddable abstract schema type as a state_field_path_expression in the SELECT clause A result_variable that refers to an orderable item in the SELECT clause for which the same result_variable has been specified.
OrderColumn	Specifies a column that is used to maintain the persistent order of a list.
OrderColumn	JPA scripting API implementation.
OrderCorrection	OrderCorrection annotation may be specified together with OrderColumn annotation.
OrderCorrectionType	The OrderCorrectionType enum is used with OrderCorrection annotation that could be applied together with OrderColumn annotation.
OrderSiblingsByClause	In a hierarchical query, if the rows of siblings of the same parent need to be ordered, then the ORDER SIBLINGS BY clause should be used.
OrderSiblingsByClauseBNF	The query BNF for the order siblings by clause.
OrderSiblingsByClauseFactory	This OrderSiblingsByClauseFactory creates a new OrderSiblingsByClause when the portion of the query to parse starts with ORDER SIBLINGS BY.
OrExpression	The OR logical operator chains multiple criteria together.
OrExpressionFactory	This OrExpressionFactory creates a new OrExpression when the portion of the query to parse starts with OR.
OrExpressionStateObject	The OR logical operator chains multiple criteria together.
OutputStreamRecord	Use this type of MarshalRecord when the marshal target is an OutputStream and the XML should not be formatted with carriage returns or indenting.
OXMJavaClassImpl	INTERNAL:
OXMJavaConstructorImpl	INTERNAL:
OXMJavaFieldImpl	INTERNAL:
OXMJavaMethodImpl	INTERNAL:
OXMJavaModelImpl	INTERNAL:
OXMJavaModelInputImpl	INTERNAL:
OXMJavaPackageImpl	INTERNAL:
OXMJAXBElementImpl	INTERNAL:
OXMMetadata
OXMObjectFactoryImpl	INTERNAL:
PackageDefinition	Purpose: Allow a semi-generic way of creating packages.
PackageInfo	INTERNAL: Represents the the package level annotations from a specific package.
PackageRenamer	This class performs package renaming.
PackageRenamer	This class performs package renaming.
PackageRenamer.PackageRenamerException
PageableCollection<T>	Marker interface for queries returning paged results
PageableFieldValidator	Finds out if an entity field is pageable and validates paging parameters.
PageableQueryValidator	Finds out if a named query is pageable and validates paging parameters.
PagingResponseBuilder	FeatureResponseBuilder implementation used for pageable collections.
Parameter<T>	Type for query parameter objects.
ParameterDelimiterType	Parameter delimiter char hint values.
ParameterExpression<T>	Type of criteria query parameter expressions.
ParameterMode	Specifies the mode of a parameter of a stored procedure query.
ParameterTypeVisitor	This visitor calculates the type of an input parameter.
ParseConversionEvent	This event indicates that a problem was encountered while converting a string from the XML data into a value of the target Java data type.
ParseConversionEventImpl	Default implementation of the ParseConversionEvent interface.
ParserType	Parser type property values.
ParserValidationType	Parser type property values.
Partitioned	Partitioning is used to partition the data for a class across multiple difference databases or across a database cluster such as Oracle RAC.
Partitioning	A Partitioning is used to partition the data for a class across multiple difference databases or across a database cluster such as Oracle RAC.
Partitioning	JPA scripting API implementation.
PartitioningPolicy	PUBLIC: A PartitioningPolicy is used to partition the data for a class across multiple difference databases or across a database cluster such as Oracle RAC.
Path<X>	Represents a simple or compound attribute path from a bound type or collection, and is a "primitive" expression.
PatternFacet
PatternListFacet
PatternValueBNF	The query BNF for a pattern value.
PerformanceMonitor	Purpose: A tool used to provide performance monitoring information in a server environment.
PerformanceProfiler	Purpose: A tool used to provide high level performance profiling information.
Persistence	Bootstrap class that is used to obtain an EntityManagerFactory in Java SE environments.
PersistenceContext	Expresses a dependency on a container-managed EntityManager and its associated persistence context.
PersistenceContext	A wrapper around the JPA and JAXB artifacts used to persist an application.
PersistenceContextFactory
PersistenceContextFactoryProvider
PersistenceContexts	Declares one or more PersistenceContext annotations.
PersistenceContextType	Specifies whether a transaction-scoped or extended persistence context is to be used in PersistenceContext.
PersistenceEntityCopyPolicy	Purpose: This is the default copy policy when weaving is used.
PersistenceException	Thrown by the persistence provider when a problem occurs.
PersistenceFactoryBase	Manages the PersistenceContexts that are used by a JPA-RS deployment.
PersistenceProperty	Describes a single container or persistence provider property.
PersistenceProvider	Interface implemented by the persistence provider.
PersistenceProvider	This is the EclipseLink EJB 3.0 provider This provider should be used by JavaEE and JavaSE users.
PersistenceProviderResolver	Determine the list of persistence providers available in the runtime environment.
PersistenceProviderResolverHolder	Holds the global PersistenceProviderResolver instance.
PersistenceResource	Persistence units catalog resource (JPARS version 2.0 and above).
PersistenceResource	Deprecated. Use PersistenceResource instead.
PersistenceUnit	Expresses a dependency on an EntityManagerFactory and its associated persistence unit.
PersistenceUnit	JPA scripting API implementation.
PersistenceUnitDefaults	JPA scripting API implementation.
PersistenceUnitInfo	Interface implemented by the container and used by the persistence provider when creating an EntityManagerFactory.
PersistenceUnitLoadingException
PersistenceUnitLoadingExceptionResource
PersistenceUnitMetadata	JPA scripting API implementation.
PersistenceUnitProperties	The class defines EclipseLink persistence unit property names.
PersistenceUnitResource	Metadata catalog resource in JPARS version less than 2.0.
PersistenceUnitResource	Deprecated. Use PersistenceUnitResource instead.
PersistenceUnits	Declares one or more PersistenceUnit annotations.
PersistenceUnitTransactionType	Specifies whether entity managers created by the EntityManagerFactory will be JTA or resource-local entity managers.
PersistenceUnitUtil	Utility interface between the application and the persistence provider managing the persistence unit.
PersistenceUtil	Utility interface between the application and the persistence provider(s).
PervasivePlatform	Purpose: Provides Pervasive SQL DBMS specific behavior.
PessimisticLock	PessimisticLock hint values.
PessimisticLockException	Thrown by the persistence provider when an pessimistic locking conflict occurs.
PessimisticLockingPolicy	Description: This policy is used to configure bean level pessimistic locking feature.
PessimisticLockScope	Defines the values of the javax.persistence.lock.scope property for pessimistic locking.
PinnedPartitioning	PinnedPartitionPolicy pins requests to a single connection pool.
PinnedPartitioning	JPA scripting API implementation.
PinnedPartitioningPolicy	PUBLIC: PinnedPartitionPolicy pins requests to a single connection pool.
PLSQLargument	INTERNAL: Helper class - tracks argument's original position as well as re-ordered position Used by PLSQLrecord and PLSQLStoredProcedureCall
PLSQLCollection	PUBLIC: Marker interface for Oracle PL/SQL Collections (Nested Tables and Varrays)
PLSQLCursor	PUBLIC: describe an Oracle PL/SQL Cursor type
PlsqlParameter	JPA scripting API implementation.
PLSQLParameter	A PLSQLParameter annotation is used within a NamedPLSQLStoredProcedureQuery or PLSQLRecord annotation.
PlsqlRecord	JPA scripting API implementation.
PLSQLrecord	PUBLIC: describe an Oracle PL/SQL Record type
PLSQLRecord	A PLSQLRecord annotation is used to define a database PLSQL RECORD type.
PLSQLRecords	A PLSQLRecords annotation allows the definition of multiple PLSQLRecord.
PLSQLStoredFunctionCall	Purpose: Used to define a platform independent function call.
PLSQLStoredProcedureCall	Purpose: Generates an Anonymous PL/SQL block to invoke the specified Stored Procedure with arguments that may or may not have JDBC equivalents.
PlsqlTable	JPA scripting API implementation.
PLSQLTable	A PLSQLTable annotation is used to define a database PLSQL TABLE type.
PLSQLTables	A PLSQLRecords annotation allows the definition of multiple PLSQLTable.
PluralAttribute<X,C,E>	Instances of the type PluralAttribute represent persistent collection-valued attributes.
PluralAttribute.CollectionType
PluralJoin<Z,C,E>	The PluralJoin interface defines functionality that is common to joins to all collection types.
PointBasePlatform	Support the Pointbase database.
PopulationManager	Purpose: This class is used to populate example data into the database, it allows for circular references to be resolved.
PostgreSQLPlatform	Purpose: Provides Postgres specific behavior.
PostLoad	Specifies a callback method for the corresponding lifecycle event.
PostPersist	Specifies a callback method for the corresponding lifecycle event.
PostRemove	Specifies a callback method for the corresponding lifecycle event.
PostUpdate	Specifies a callback method for the corresponding lifecycle event.
Predicate	The type of a simple or compound predicate: a conjunction or disjunction of restrictions.
Predicate.BooleanOperator
PreLoginMappingAdapter	This adapter alters the way the JAXBContext handles relationships for an existing persistence unit.
PreLoginMappingAdapterV2	This listener is used for crating XML mappings for weaved fields.
PrePersist	Specifies a callback method for the corresponding lifecycle event.
PreRemove	Specifies a callback method for the corresponding lifecycle event.
PreUpdate	Specifies a callback method for the corresponding lifecycle event.
PrimaryKey	The PrimaryKey annotation allows advanced configuration of the Id.
PrimaryKey	JPA scripting API implementation.
PrimaryKeyJoinColumn	Specifies a primary key column that is used as a foreign key to join to another table.
PrimaryKeyJoinColumn	JPA scripting API implementation.
PrimaryKeyJoinColumns	Groups PrimaryKeyJoinColumn annotations.
PrintConversionEvent	This event indicates that a problem was encountered while converting data from the Java content tree into its lexical representation.
PrintConversionEventImpl	Default implementation of the PrintConversionEvent interface.
PrivateOwned	A PrivateOwned annotation is used to specify a relationship is privately owned.
Problem	A problem describes an issue found in a JPQL query because it is either grammatically or semantically incorrect.
Profile	Purpose: Any information stored for a profile operation.
ProfilerType	Profiler type persistence property values.
Project	Purpose: Maintain all of the EclipseLink configuration information for a system.
ProjectCache	Purpose: Interface used to support caching the project generated from metadata avoiding costs associated processing the same metadata over multiple deployments.
ProjectClassGenerator	Purpose: Allow for a class storing a TopLink project's descriptors (meta-data) to be generated.
Properties	Annotation for user defined properties.
PropertiesUtils	A static utility class that handles parsing a String "key=value,key1=value1...." and calls an appropriate set[key]([value]) method on the provided instance.
Property	Annotation for a user defined property.
Property	INTERNAL:
Property	JPA scripting API implementation.
PropertyAssociation	Purpose: Generic association object.
PropertyChangeEvent<T>	The default implementation of IPropertyChangeEvent where the generics is the type of the old and new values.
PropertyException	This exception indicates that an error was encountered while getting or setting a property.
ProviderUtil	Utility interface implemented by the persistence provider.
QualifiedIdentificationVariableBNF	The query BNF for a qualified identification variable expression.
Query	Interface used to control query execution.
QueryByExamplePolicy	Purpose: This policy defines the configuration options for a Query By Example query.
QueryException	Purpose: This exception is used for any problem that is detected with a query.
QueryExceptionResource	INTERNAL: English ResourceBundle for QueryException messages.
QueryHint	Used to supply a query property or hint to the NamedQuery or NamedNativeQuery annotation.
QueryHint	JPA scripting API implementation.
QueryHints	The class defines EclipseLink query hints.
QueryKey	Purpose: Define a Java appropriate alias to a database field or function.
QueryList	This class is used to wrap collection of Query objects
QueryMonitor	Purpose: Provide a very simple low overhead means for measuring query executions, and cache hits.
QueryParameters
QueryPosition	This object contains the cursor position within the parsed tree and within each of the Expression from the root to the deepest leaf.
QueryRedirector	Purpose: Query redirection allows for a named or parameterized query (or finder) to dynamically determine how the query is to be executed based on the arguments.
QueryRedirectorHelper	Purpose: The purpose of this class is to provide the query redirector with some helper methods for general EclipseLink operations (such as checking a query against the cache) which may not occur because the query is being redirected.
QueryRedirectors	Redirectors allow EclipseLink queries to be intercepted and pre/post processed or redirected.
QueryRedirectors	JPA scripting API implementation.
QueryResource	Query resource.
QueryResource	Deprecated. Use QueryResource instead.
QueryResultsCachePolicy	PUBLIC: A QueryResultsCache policy dictates how a query's results will be cached.
QuerySequence	Purpose: An generic query sequence mechanism.
QueryStringInteraction	Defines the specification for a call to a JCA interaction that uses a query string.
QueryTimeoutException	Thrown by the persistence provider when a query times out and only the statement is rolled back.
QueryType	Query type hint values.
RangeDeclaration	This RangeDeclaration represents an identification variable declaration that was declared in the FROM clause of a SELECT top-level query or subquery.
RangeDeclarationBNF
RangeDeclarationFactory
RangePartition	Represent a specific range partition.
RangePartition	PUBLIC: Represent a specific range partition.
RangePartition	JPA scripting API implementation.
RangePartitioning	RangePartitioningPolicy partitions access to a database cluster by a field value from the object, such as the object's id, location, or tenant.
RangePartitioning	JPA scripting API implementation.
RangePartitioningPolicy	PUBLIC: RangePartitioningPolicy partitions access to a database cluster by a field value from the object, such as the object's id, location, or tenant.
RangeVariableDeclaration	Range variable declarations allow the developer to designate a "root" for objects which may not be reachable by navigation.
RangeVariableDeclarationBNF	The query BNF for a range variable declaration expression.
RangeVariableDeclarationFactory	This RangeVariableDeclaration creates a new RangeVariableDeclaration.
RangeVariableDeclarationStateObject	Range variable declarations allow the developer to designate a "root" for objects which may not be reachable by navigation.
ReadAllQuery	Purpose: Concrete class for all read queries involving a collection of objects.
ReadAllQuery.Direction	Specifies the direction in which the hierarchy is traversed in a hierarchical query.
ReadAllQueryResultCollection	This class is used to wrap collection of records returned by a JPA read all query and includes paging links.
ReadAllQueryResultCollectionMetadataSource	Makes the ReadAllQueryResultCollection class available to JPA-RS JAXB context.
ReadConnectionPool	Purpose: The read connection pool is used for read access through the server session.
ReadObjectQuery	Purpose: Concrete class for all read queries involving a single object.
ReadOnly	The ReadOnly annotation is used to specify that a class is read only.
ReadQuery	Purpose: Abstract class for all read queries.
ReadTransformer	Annotation for org.eclipse.persistence.mappings.TransformationMapping.
ReadTransformer	JPA scripting API implementation.
Record	This interface defines the public interface for the EclipseLink DatabaseRecord (was Record), and the other record types XMLRecord, EISRecord.
RecordConverter	The RecordConverter interface allows conversion of an adapter specific record.
RefactoringDelta	A refactoring delta contains an ordered collection of TextEdit.
RefactoringTool	The abstract implementation providing refactoring support for JPQL queries.
RefactoringTool.ClassNameRenamer	This visitor renames a fully qualified class name.
RefactoringTool.EntityNameRenamer	This visitor renames an entity name.
RefactoringTool.EnumConstantRenamer	This visitor renames an enum constant.
RefactoringTool.FieldNameRenamer	This visitor renames any segment of a path expression.
RefactoringTool.ResultVariableNameRenamer	This visitor renames all the result variables found in the JPQL query.
RefactoringTool.StateObjectUpdater<T extends StateObject>	This interface is used to transparently push the new value into the StateObject.
RefactoringTool.VariableNameRenamer	This visitor renames all the identification variables found in the JPQL query.
ReferenceAdapter<T extends org.eclipse.persistence.internal.weaving.PersistenceWeavedRest>
ReferenceAdapterV2<T extends org.eclipse.persistence.internal.weaving.PersistenceWeavedRest>	Reference adapter used in JPARS V2.
ReferenceMapping	Purpose: In an object-relational data model, structures reference each other through "Refs"; not through foreign keys as in the relational data model.
ReferenceMode	Purpose: This class is a configuration property used to specify What type of Referenes EclipseLink will use when referencing Entities within the Persistence Context / UnitOfWork.
RegexpExpression	The REGEXP condition is used to specify a search for a pattern.
RegexpExpressionBNF	The query BNF for a REGEXP expression.
RegexpExpressionFactory	This RegexpExpressionFactory creates a new RegexpExpression when the portion of the query to parse starts with REGEXP.
RelationalDescriptor	Purpose: EclipseLink has been designed to take advantage of the similarities between relational databases and objects while accommodating for their differences, providing an object oriented wrapper for relational databases.
RelationalMapping	INTERNAL All mappings which can be added to org.eclipse.persistence.mappings.Descriptor must implement this interface.
RelationshipLinkAdapter
RelationTableMechanism	Purpose: Contains relation table functionality that was originally defined in ManyToManyMapping and now is shared with OneToOneMapping.
RelativePositionOrderingPolicy	INTERNAL:
RemoteCommandManager	Purpose: Provide a CommandManager implementation for cache coordination.
RemoteCommandManagerException	Instances of this exception are raised if a problem is detected in the RemoteCommandManager (RCM) feature.
RemoteCommandManagerExceptionResource	INTERNAL: English ResourceBundle for RemoteCommandManagerExceptionResource messages.
RemoteProtocol	Remote JPA protocol persistence property values.
RemoteSession	Purpose: Provide transparent remote three-tiered replacation support.
RenameFileData
RenameValue
ReplicationPartitioning	ReplicationPartitioning sends requests to a set of connection pools.
ReplicationPartitioning	JPA scripting API implementation.
ReplicationPartitioningPolicy	PUBLIC: ReplicationPartitioningPolicy sends requests to a set of connection pools.
ReportQuery	Purpose: Query for information about a set of objects instead of the objects themselves.
ReportQueryResult	Purpose: A single row (type) result for a ReportQuery
ReportQueryResult.RecordEntry	Entry class for implementing Map interface.
ReportQueryResultCollection	This class is used to wrap collection of records returned by a JPA report query and includes paging links.
ReportQueryResultCollectionMetadataSource	Makes the ReportQueryResultCollection class available to JPA-RS JAXB context.
ReportQueryResultList	This class is used to wrap collection of records returned by a JPA report query.
ReportQueryResultListItem	This class is used to wrap collection of attributes of a record returned by a JPA report query.
ReportQueryResultListItemMetadataSource	Makes the ReportQueryResultListItem class available to JPA-RS JAXB context.
ReportQueryResultListMetadataSource	Makes the ReportQueryResultList class available to JPA-RS JAXB context.
ReservedWords	This class contains constants used in JPARS.
Resolver	A Resolver is responsible to resolve a property by retrieving either the managed type, the mapping, the type and the type declaration depending on the type of resolver.
ResolverBuilder	This visitor creates a Resolver that gives information about the visited Expression.
ResolverBuilder.CollectionExpressionVisitor	This visitor is used to check if the expression visited is a CollectionExpression.
ResourceLocalTransactionWrapper
RestCollectionAdapter<T extends org.eclipse.persistence.internal.weaving.PersistenceWeavedRest>	Collections adapter used in JPARS V2.
RestPageable	Collection fields annotated by this annotation support pagination in JPARS service.
RestPageableQueries	This annotation annotation allows the definition of multiple RestPageableQuery.
RestPageableQuery	Defines a pageable query.
ResultQuery	This is used to retrieve the new JPQL query when a content assist item needs to be insert at a certain position.
ResultSetConcurrency	JDBC ResultSet concurrency hint values.
ResultSetMappingQuery	Purpose: Concrete class to perform read using raw SQL and the SQLResultSetMapping.
ResultSetType	JDBC ResultSet type hint values.
ResultType	Result type hint values.
ResultVariable	A result variable may be used to name a select item in the query result.
ResultVariableBNF	The query BNF for a result variable expression.
ResultVariableFactory	This ResultVariableFactory creates a new ResultVariable when the portion of the query to parse starts with or without AS.
ResultVariableStateObject	A result variable may be used to name a select item in the query result.
ReturningPolicy	Purpose: Allows for INSERT or UPDATE operations to return values back into the object being written.
ReturningPolicy.Info	INTERNAL:
ReturnInsert	A ReturnInsert annotation allows for INSERT operations to return values back into the object being written.
ReturnInsert	JPA scripting API implementation.
ReturnUpdate	A ReturnUpdate annotation allows for UPDATE operations to return values back into the object being written.
RMIConnection	This class exists on on the client side which talks to remote session controller through RMI connection.
RMIConnection	This class exists on on the client side which talks to remote session controller through RMI connection.
RMIRemoteSessionController	Defines the public methods remote connection can invoke on the remote session controller.
RMIRemoteSessionController	Defines the public methods remote connection can invoke on the remote session controller.
RMIRemoteSessionControllerDispatcher	RemoteSessionController sits between the remote session and the session.
RMIRemoteSessionControllerDispatcher	RemoteSessionController sits between the remote session and the session.
RMIServerSessionManager
RMIServerSessionManagerDispatcher
RMITransportManager	Purpose: Provide an RMI transport implementation for RCM.
RollbackException	Thrown by the persistence provider when EntityTransaction.commit() fails.
Root<X>	A root type in the from clause.
RoundRobinPartitioning	RoundRobinPartitioning sends requests in a round robin fashion to the set of connection pools.
RoundRobinPartitioning	JPA scripting API implementation.
RoundRobinPartitioningPolicy	PUBLIC: RoundRobinPartitioningPolicy sends requests in a round robin fashion to the set of connection pools.
RuntimeFactory	JPA scripting API implementation.
RuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
SafeModeTuner	Configures the persistence unit for debugging.
SAPNetWeaver_7_1_Platform	Server platform for SAP NetWeaver AS Java 7.1 (including EhP 1), 7.2 and follow-up releases.
SAPNetWeaverTransactionController	TransactionController implementation for SAP NetWeaver AS Java 7.1 (including EhP 1), 7.2 and follow-up releases.
SAXDocumentBuilder	Purpose: Build a DOM from SAX events.
SAXPlatform
ScalarExpressionBNF	The query BNF for a scalar expression.
SchemaGenerator	INTERNAL:
SchemaManager	Purpose: Define all user level protocol for development time database manipulation.
SchemaMetadata
SchemaOutputResolver	Controls where a JAXB implementation puts the generates schema files.
SchemaPerMultitenantPolicy	A schema per tenant multitenant policy.
SchemaTypeInfo	INTERNAL:
ScrollableCursor
ScrollableCursorPolicy	PUBLIC: ScrollableCursorPolicy allows for additional options to be specified for ReadAllQuery or DataReadQuery.
SDOException	Purpose: This class provides an implementation of EclipseLinkException specific to the EclipseLink SDO (Service Data Objects) API.
SDOExceptionResource	INTERNAL: Purpose:
SecondaryTable	Specifies a secondary table for the annotated entity class.
SecondaryTable	JPA scripting API implementation.
SecondaryTables	Specifies multiple secondary tables for an entity.
Securable	EclipseLink encryption interface
SelectClause	The SELECT clause queries data from entities.
SelectClauseBNF	The query BNF for the select clause.
SelectClauseFactory	This SelectClauseFactory creates a new SelectClause when the portion of the query to parse starts with SELECT.
SelectClauseStateObject	The SELECT statement queries data from entities, which determines the type of the objects or values to be selected.
SelectedFieldsLockingPolicy	Purpose: An implementation of the OptimisticLockingPolicy interface.
SelectExpressionBNF	The query BNF for a select expression.
Selection<X>	The Selection interface defines an item that is to be returned in a query result.
SelectStatement	A SELECT query is an operation that retrieves data from one or more tables or views.
SelectStatementBNF	The query BNF for the select statement.
SelectStatementFactory	This SelectStatementFactory creates a new SelectStatement when the portion of the query to parse starts with SELECT.
SelectStatementStateObject	This state object represents a select statement, which has at least a SELECT clause and a FROM clause.
SelfLinksResponseBuilder	FeatureResponseBuilder implementation generating 'self' and 'canonical' links.
SemanticValidatorHelper	This helper is used by AbstractSemanticValidator in order to retrieve JPA information.
Sequence	Purpose: Abstract class to define sequencing.
SequenceDefinition	Purpose: Allow a generic way of creating sequences on the different platforms, and allow optional parameters to be specified.
SequencedObject	In order to mark a domain object as being a Sequenced Object it must implement this interface.
SequenceGenerator	Defines a primary key generator that may be referenced by name when a generator element is specified for the GeneratedValue annotation.
SequenceGenerator	JPA scripting API implementation.
SequenceGenerators	Used to group SequenceGenerator annotations.
SequenceObjectDefinition	Purpose: Sequence definition Native Sequence object.
SequencingControl	Purpose: Define an interface to control sequencing functionality.
SerializableDescriptorEventHolder	INTERNAL: Interface to hold onto a DescriptorEvents within a project so they can be rebuilt after serialization.
SerializedConverter	A SerializedConverter is used to serialize an object's value into a database binary, character, or XML field.
SerializedConverters	A TypeConverters annotation allows the definition of multiple SerializedConverter.
SerializedObject	SerializedObject annotation is used to set an org.eclipse.persistence.descriptors.SerializedObjectPolicy on an Entity or MappedSuperClass.
SerializedObjectConverter	Purpose: The serialized object converter can be used to store an arbitrary object or set of objects into a database binary or character field.
SerializedObjectPolicy	SerializedObjectPolicy (SOP) could be set on a non-aggregate descriptor.
Serializer	Generic serializer interface.
Server	Purpose: A single session that supports multiple user/clients connection at the same time.
ServerLog	Basic logging class that provides framework for integration with the application server log.
ServerPlatform	PUBLIC: This is the interface describing the behavior for ServerPlatformBase, and any other class that wants to provide behavior for a server.
ServerPlatformBase	PUBLIC: Implementation of org.eclipse.persistence.platform.server.ServerPlatform
ServerPlatformDetector	A generic interface that allows implementors to try to detect which platform is currently being executed on.
ServerPlatformException
ServerPlatformExceptionResource
ServerPlatformUtils	A utility class to interact with ServerPlatforms.
ServerSession	Implementation of Server INTERNAL: The public interface should be used.
ServiceId	Purpose: Encapsulate the information that uniquely identifies a specific remote command service instance.
ServiceVersion	JPARS service version.
Session	Purpose: Define the EclipseLink session public interface.
SessionBroker	Purpose: Provide a single view to a TopLink session that transparently accesses multple databases.
SessionCustomizer	PUBLIC: This interface is to allow extra customization on an EclipseLink Session
SessionCustomizer	Deprecated. replaced by org.eclipse.persistence.config.SessionCustomizer
SessionEvent	Purpose: Encapsulate the information provided with session events.
SessionEventAdapter	Purpose: To provide a trivial implemetation of SessionEventListener.
SessionEventListener	Purpose: Used to support session events.
SessionEventManager	Purpose: Used to support session events.
SessionFactory	Helper class to simplify the development and generation of code that accesses TopLink through the SessionManager (sessions config XML).
SessionLoaderException
SessionLoaderExceptionResource	INTERNAL: English ResourceBundle for SessionLoaderExceptionResource messages.
SessionLog	SessionLog is the ever-so-simple interface used by EclipseLink to log generated messages and SQL.
SessionLogEntry	SessionLogEntry is a simple container object that holds all the information pertinent to an EclipseLink logging event.
SessionManager	Purpose: Global session location.
SessionProfiler	Purpose: This interface defines the link between the Session and the PerformanceProfiler tool.
SessionProfilerAdapter	Adapter class for SessionProfiler interface.
SessionTuner	Generic tuning interface.
SetAttribute<X,E>	Instances of the type SetAttribute represent persistent java.util.Set-valued attributes.
SetJoin<Z,E>	The SetJoin interface is the type of the result of joining to a collection over an association or element collection that has been specified as a java.util.Set.
Setting	Setting objects are used to control the order in which the mappings for Sequenced Objects are processed.
SharedCacheMode	Specifies how the provider must use a second-level cache for the persistence unit.
SimpleArithmeticExpressionBNF	The query BNF for a simple arithmetic expression.
SimpleCaseExpressionBNF	The query BNF for a simple case expression.
SimpleConditionalExpressionBNF	The query BNF for a simple conditional expression.
SimpleEntityExpressionBNF	The query BNF for a simple entity expression.
SimpleEntityOrValueExpressionBNF	The query BNF for a simple entity or value expression.
SimpleFromClause	The FROM clause of a query defines the domain of the query by declaring identification variables.
SimpleFromClauseStateObject	The FROM clause of a sub-query defines the domain of the sub-query by declaring identification variables.
SimpleHomogeneousList	This class is used to wrap collection of homogeneous simple java type attributes, such as Strings, Integers, etc..., and MUST NOT be used to wrap collection of attributes with the type that is assignable from PersistenceWeavedRest.
SimpleHomogeneousListMetadataSource	Makes the SimpleHomogeneousList class available to JPA-RS JAXB context.
SimpleResultVariableBNF	The query BNF for a result variable expression.
SimpleSelectClause	The SELECT statement queries data from entities.
SimpleSelectClauseBNF	The query BNF for the simple select clause.
SimpleSelectClauseStateObject	The SELECT statement queries data from entities.
SimpleSelectExpressionBNF	The query BNF for a simple select expression.
SimpleSelectStatement	BNFL subquery ::= simple_select_clause subquery_from_clause [where_clause] [groupby_clause] [having_clause]
SimpleSelectStatementFactory	This SimpleSelectStatementFactory creates a new SimpleSelectStatement when the portion of the query to parse starts with SELECT.
SimpleSelectStatementStateObject	This state object represents a subquery, which has at least a SELECT clause and a FROM clause.
SimpleStateObject	This StateObject simply holds onto a string.
SingleElementListIterable<E>	A SingleElementListIterable returns a ListIterator that holds a single element and returns it with the first call to ListIterator.next(), at which point it will return false to any subsequent call to ListIterator.hasNext().
SingleElementListIterator<E>	A SingleElementListIterator holds a single element and returns it with the first call to SingleElementListIterator.next(), at which point it will return false to any subsequent call to SingleElementListIterator.hasNext().
SingleResultQuery	Marker interface for queries returning single results.
SingleResultQueryList	This class is used to wrap collection of attributes returned by the single-result JPA report query.
SingleResultQueryListMetadataSource	Makes the SingleResultQueryList class available to JPA-RS JAXB context.
SingleResultQueryResource	Single result query resource.
SingleResultQueryResource	Deprecated. Use SingleResultQueryResource instead.
SingleResultQueryResult	The result of single result query.
SingleResultQueryResultMetadataSource	Makes the SingleResultQueryResult class available to JPA-RS JAXB context.
SingleTableMultitenantPolicy	A single table "striped" multitenant policy.
SingleValuedObjectPathExpressionBNF	The query BNF for a simple valued object path expression.
SingleValuedPathExpressionBNF	The query BNF for a single valued path expression.
SingularAttribute<X,T>	Instances of the type SingularAttribute represents persistent single-valued properties or fields.
SizeExpression	The SIZE function returns an integer value, the number of elements of the collection.
SizeExpressionFactory	This SizeExpressionFactory creates a new SizeExpression when the portion of the query to parse starts with SIZE.
SizeExpressionStateObject	The SIZE function returns an integer value, the number of elements of the collection.
SizeFacet
SnapshotCloneIterable<E>	A SnapshotCloneIterable returns an iterator on a "snapshot" of a collection, allowing for concurrent access to the original collection.
SnapshotCloneIterable.LocalCloneIterator<E>	provide access to "internal" constructor
SnapshotCloneListIterable<E>	A SnapshotCloneListIterable returns a list iterator on a "snapshot" of a list, allowing for concurrent access to the original list.
SnapshotCloneListIterable.LocalCloneListIterator<E>	provide access to "internal" constructor
SpatialExpressionFactory	This class is used to construct expressions that use Oracle Spatial operators
SpatialParameters	PUBLIC: A utility class used to set parameters on spatial operators within TopLink's expression framework.
SpatialParameters.Mask
SpatialParameters.QueryType
SpatialParameters.Units
SQLAnywherePlatform	Provides SQL Anywhere specific behaviour.
SQLCall	Purpose: Used as an abstraction of an SQL call.
SQLResult	Purpose: An abstract superclass that represents the commonalities between the main result types of the SQLResultSetMapping
SqlResultSetMapping	Specifies the mapping of the result of a native SQL query or stored procedure.
SqlResultSetMapping	JPA scripting API implementation.
SQLResultSetMapping	Purpose: Concrete class to represent the SQLResultSetMapping structure as defined by the EJB 3.0 Persistence specification.
SqlResultSetMappings	Is used to define one or more SqlResultSetMapping annotations.
SQLServerPlatform	Purpose: Provides SQL Server specific behavior.
SqrtExpression	The SQRT function takes a numeric argument and returns a double.
SqrtExpressionFactory	This SqrtExpressionFactory creates a new SqrtExpression when the portion of the query to parse starts with SQRT.
SqrtExpressionStateObject	The SQRT function takes a numeric argument and returns a Double.
StandardSequence	Purpose: An abstract class providing default sequence behavior.
StandardTuner	Default tuner.
StartWithClause	A START WITH clause is optional and specifies the root row(s) of the hierarchy.
StartWithClauseBNF	The query BNF for the START WITH clause.
StartWithClauseFactory	This StartWithClauseFactory creates a new StartWithClause when the portion of the query to parse starts with START WITH.
StateFieldPathExpression	A single_valued_association_field is designated by the name of an association-field in a one-to-one or many-to-one relationship.
StateFieldPathExpressionBNF	The query BNF for a state field path expression.
StateFieldPathExpressionFactory	This StateFieldPathExpressionFactory is meant to handle the parsing of a portion of the query when it's expected to be a state field path.
StateFieldPathExpressionStateObject	A single-valued association field is designated by the name of an association-field in a one-to-one or many-to-one relationship.
StateFieldPathExpressionStateObject.MapManagedType
StateFieldResolver	This Resolver is responsible to resolve the type of a state field, which is the leaf of the state field path expression.
StateObject	A StateObject is an editable representation of a JPQL query.
StateObjectProblem
StateObjectProblemConstants
StateObjectVisitor	The visitor is used to traverse the StateObject hierarchy that represents a JPQL query.
StaticMetamodel	The StaticMetamodel annotation specifies that the class is a metamodel class that represents the entity, mapped superclass, or embeddable class designated by the value element.
StaticWeave	Description: This is the static weave command line processing class that verifies command options and invokes StaticWeaveProcessor to statically weave the classes.
StaticWeaveAntTask	Description: This is the static weave ant task definition class that verifies the value of specified attributes and invokes StaticWeaveProcessor to weave classes.
StaticWeaveClassTransformer	Description: This class provides the implementation of class transformer by leveraging on the following existing APIs, PersistenceUnitProcessor.processORMetadata() - get class descriptor.
StaticWeaveException
StaticWeaveExceptionResource
StaticWeaveProcessor	Description: The StaticWeaveProcessor controls the static weaving process.
StoredFunctionCall	Purpose: Used to define a platform independent function call.
StoredFunctionDefinition	Purpose: Allow a semi-generic way of creating store function.
StoredProcedureCall	Purpose: Used to define a platform independent procedure call.
StoredProcedureDefinition	Purpose: Allow a semi-generic way of creating stored procedures.
StoredProcedureGenerator	Purpose: To generate StoredProcedures from EclipseLink Projects
StoredProcedureParameter	Specifies a parameter of a named stored procedure query.
StoredProcedureParameter	A StoredProcedureParameter annotation is used within a NamedStoredProcedureQuery annotation.
StoredProcedureParameter	JPA scripting API implementation.
StoredProcedureQuery	Interface used to control stored procedure query execution.
StreamingOutputMarshaller	Simple StreamingOutput implementation that uses the provided JAXBContext to marshal the result when requested to either XML or JSON based on the accept media provided.
StringExpressionBNF	The query BNF for a string expression.
StringLiteral	A string literal is enclosed in single quotes.
StringLiteralBNF	The query BNF for a string literal.
StringLiteralFactory	This StringLiteralFactory is responsible to parse a sub-query starting with a single quote.
StringLiteralStateObject	A string literal is enclosed in single quotes.
StringPrimaryBNF	The query BNF for a string primary expression.
Struct	Struct types are extended object-relational data-types supported by some databases.
Struct	JPA scripting API implementation.
StructConverter	A StructConverter is a special type of converter that handles the conversion of a specific database Struct type.
StructConverter	JPA scripting API implementation.
StructConverter	PUBLIC: A StuctConverter can be added to a DatabasePlatform It allows custom processing dealing java.sql.Struct types When added to the DatabasePlatform: 1. convertToObject(Struct) will be invoked when a Struct named by the value returned by getStructName() is returned from the database.
StructConverters	A StructConverters annotation allows the definition of multiple StructConverter.
StructConverterType	This class contains predefined StructConverter types.
Structure	Struct types are extended object-relational data-types supported by some databases.
Structure	JPA scripting API implementation.
StructureMapping	Purpose: A structure is an object-relational user-defined data-type or object-type.
SubExpression	This expression wraps a sub-expression within parenthesis.
SubExpressionStateObject	This expression wraps a sub-expression within parenthesis.
Subgraph<T>	This type represents a subgraph for an attribute node that corresponds to a Managed Type.
Subgraph	This type represents a AttributeNode of an EntityGraph that corresponds to a Managed Type.
Subquery<T>	The Subquery interface defines functionality that is specific to subqueries.
SubqueryBNF	The query BNF for a subquery expression.
SubqueryDeclaration	This Declaration uses a subquery as the "root" object.
SubqueryEntityResolver	This Resolver retrieves the type for an abstract schema name (entity name) if it can be resolved otherwise a derived path will be assumed.
SubqueryFromClauseBNF	The query BNF for the from clause defined in a subquery.
SubSelectIdentificationVariableDeclarationBNF	The query BNF for an identification variable declaration expression defined in a sub-select expression.
SubstringExpression	The second and third arguments of the SUBSTRING function denote the starting position and length of the substring to be returned.
SubstringExpressionFactory	This SubstringExpressionFactory creates a new SubstringExpression when the portion of the query to parse starts with SUBSTRING.
SubstringExpressionStateObject	The second and third arguments of the SUBSTRING function denote the starting position and length of the substring to be returned.
SubtractionExpression	One of the four binary operators.
SubtractionExpressionStateObject	TODO: BNF: arithmetic_expression ::= arithmetic_expression - arithmetic_term
SumFunction	One of the aggregate functions.
SumFunctionFactory	This SumFunctionFactory creates a new SumFunction when the portion of the query to parse starts with SUM.
SumFunctionResolver	This Resolver is responsible to calculate the type based on the type of the state field.
SumFunctionStateObject	One of the aggregate functions.
SunAS9ServerPlatform	Deprecated. since 2.5 replaced by GlassfishServerPlatform
SunAS9TransactionController	Deprecated. since 2.5 replaced by GlassfishTransactionController
SunCORBATransportManager
SybasePlatform	Purpose: Provides Sybase ASE specific behavior.
SymfowarePlatform	Symfoware Server http://wiki.eclipse.org/EclipseLink/Development/Incubator/Extensions/SymfowarePlatform Test results: http://wiki.eclipse.org/EclipseLink/Development/DatabasePlatform/SymfowarePlatform/TestResults Contributed by: Fujitsu Ltd. Contributed under bug: 288715
SynchronizationListenerFactory	Purpose: Generate synchronization listener objects of the appropriate type.
SynchronizationType	Specifies whether the persistence context is always automatically synchronized with the current transaction or whether the persistence context must be explicitly joined to the current transaction by means of the EntityManager.joinTransaction() method.
SystemDefaults
SystemProperties	This class provides the list of System properties that are recognized by EclipseLink.
Table	Specifies the primary table for the annotated entity.
Table	JPA scripting API implementation.
TableCreator	Purpose: This class is responsible for creating the tables defined in the project.
TableCreatorClassGenerator	Purpose: Allow for a class storing a TopLink table creator's tables (meta-data) to be generated.
TableDeclaration	This Declaration uses a database table as the "root" object.
TableDefinition	Purpose: Allow a generic way of creating tables on the different platforms.
TableExpression	Defines a table expression.
TableExpressionBNF	The query BNF for a table expression.
TableExpressionFactory	This TableExpressionFactory creates a new TableExpression.
TableGenerator	Defines a primary key generator that may be referenced by name when a generator element is specified for the GeneratedValue annotation.
TableGenerator	JPA scripting API implementation.
TableGenerators	Used to group TableGenerator annotations.
TablePerClassPolicy	Purpose: Provides the functionality to support a TABLE_PER_CLASS inheritance strategy.
TablePerMultitenantPolicy	A table per tenant multitenant policy.
TableSequence	Purpose: Defines sequencing through using a SEQUENCE table.
TableSequenceDefinition	Purpose: Allow a generic way of creating sequences on the different platforms, and allow optional parameters to be specified.
TableVariableDeclaration	Defines a table expression.
TableVariableDeclarationBNF	The query BNF for a table declaration.
TableVariableDeclarationFactory	This TableVariableDeclarationFactory creates a new TableVariableDeclaration.
TargetDatabase	Target database persistence property values.
TargetServer	Target server persistence property values.
Temporal	This annotation must be specified for persistent fields or properties of type java.util.Date and java.util.Calendar.
Temporal	JPA scripting API implementation.
TemporalType	Type used to indicate a specific mapping of java.util.Date or java.util.Calendar.
TenantDiscriminatorColumn	Tenant discriminator column(s) are used with a SINGLE_TABLE multitenant strategy.
TenantDiscriminatorColumn	JPA scripting API implementation.
TenantDiscriminatorColumns	A TenantDiscriminatorColumns annotation allows the definition of multiple TenantDiscriminatorColumn.
TenantTableDiscriminator	A tenant table discriminator is used with a TABLE_PER_TENANT multitenant strategy.
TenantTableDiscriminator	JPA scripting API implementation.
TenantTableDiscriminatorType	An enum that is used within the TenantTableDiscriminator annotation.
TextEdit	A TextEdit contains the information of a change that can be made to the JPQL query after performing a refactoring operation.
TimeOfDay	A TimeOfDay annotation is used to specify a specific time of day using a Calendar instance which is to be used within an OptimisticLocking annotation.
TimeOfDay	JPA scripting API implementation.
TimestampLockingPolicy	Purpose: Used to allow a single version timestamp to be used for optimistic locking.
TimesTen7Platform	Purpose: Provides TimesTen 7 specific behavior.
TimesTenPlatform	Database platform for the TimesTen database product.
TimeToLiveCacheInvalidationPolicy	PUBLIC: A CacheInvalidationPolicy which allows objects to live for a specific amount of time after they are read.
TransactionException
TransactionExceptionResource	INTERNAL: English ResourceBundle for TransactionException messages.
TransactionRequiredException	Thrown by the persistence provider when a transaction is required but is not active.
TransactionWrapper
Transformation	Transformation is an optional annotation for org.eclipse.persistence.mappings.TransformationMapping.
Transformation	JPA scripting API implementation.
TransformationMapping	Purpose: A transformation mapping is used for a specialized translation between how a value is represented in Java and its representation on the databae.
TransformationMappingChangeRecord	Purpose: To Provide API to the TransformationMappingChangeRecord.
TransformerPropertyBuilder	This class is building properties from write transformers.
TransformerReflectionHelper	Provides return type from write transformation method.
Transient	Specifies that the property or field is not persistent.
Transient	JPA scripting API implementation.
TransientCompatibleAnnotations	PUBLIC: This class is used by our JPA annotation processing to discover which annotations may coexist with a javax.persistence.Transient annotation.
TransporterDefaultFactory	INTERNAL: org/eclipse/persistence/internal/remote/TransporterDefaultFactory.java Generated by the IDL-to-Java compiler (portable), version "3.0" from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl Thursday, May 3, 2001 1:36:59 PM EDT
TransporterHelper	INTERNAL: org/eclipse/persistence/internal/remote/TransporterHelper.java Generated by the IDL-to-Java compiler (portable), version "3.0" from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl Thursday, May 3, 2001 1:36:59 PM EDT
TransporterHolder	INTERNAL: org/eclipse/persistence/internal/remote/TransporterHolder.java Generated by the IDL-to-Java compiler (portable), version "3.0" from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl Thursday, May 3, 2001 1:36:59 PM EDT
TransportManager	Purpose: Provide an abstract class that offers a common API to handling remote command connections.
TreatExpression	Returns an expression that allows to treat its base as if it were a subclass of the class returned by the base.
TreatExpressionBNF	The query BNF for a TREAT expression.
TreatExpressionFactory	This TreatExpressionFactory creates a new TreatExpression when the portion of the query to parse starts with TREAT.
TreatExpressionStateObject	Returns an expression that allows to treat its base as if it were a subclass of the class returned by the base.
TreatResolver	This Resolver resolves a path and casts it as another entity type.
TrimExpression	The TRIM function trims the specified character from a string.
TrimExpression.Specification	The possible ways to trim the string.
TrimExpressionFactory	This TrimExpressionFactory creates a new TrimExpression when the portion of the query to parse starts with TRIM.
TrimExpressionStateObject	The TRIM function trims the specified character from a string.
TunerType	Tuning persistence property values.
Tuple	Interface for extracting the elements of a query result tuple.
TupleElement<X>	The TupleElement interface defines an element that is returned in a query result tuple.
Type<X>	Instances of the type Type represent persistent object or attribute types.
Type.PersistenceType
TypeConstraintException	This exception indicates that a violation of a dynamically checked type constraint was detected.
TypeConversionConverter	Purpose: Type conversion converters are used to explicitly map a database type to a Java type.
TypeConverter	The TypeConverter annotation is used to specify an EclipseLink org.eclipse.persistence.mappings.converters.TypeConversionConverter for modification of the data value(s) during the reading and writing of a mapped attribute.
TypeConverter	JPA scripting API implementation.
TypeConverters	A TypeConverters annotation allows the definition of multiple TypeConverter.
TypedAssociation	Purpose: Generic association object.
TypeDefinition	Purpose: Allow for Oracle 8 object-relational user defined type to be created.
TypedQuery<X>	Interface used to control the execution of typed queries.
TypeExpression	An entity type expression can be used to restrict query polymorphism.
TypeExpressionBNF	The query BNF for a type expression.
TypeExpressionFactory	This TypeExpressionFactory creates a new TypeExpression when the portion of the query to parse starts with TYPE.
TypeExpressionStateObject	An entity type expression can be used to restrict query polymorphism.
TypeHelper	This helper contains methods related to IType and can perform equivalency checks.
TypeInfo	INTERNAL:
TypeMappingInfo	Purpose: Provides a wrapper for a java type to be used when creating a JAXB context.
TypeMappingInfo.ElementScope
TypeTableDefinition	Purpose: Allow for tabels of Oracle 8 object-relational user defined type to be created.
UnaryTableSequence	Purpose: Defines sequencing through using a singleton sequence table.
UnaryTableSequenceDefinition	Purpose: Creates / drops an unary sequence table: the name of the table is sequence name; its only field is named unarySequenceCounterFieldName
UnidirectionalOneToManyMapping	Purpose: UnidirectionalOneToManyMapping doesn't have 1:1 back reference mapping.
UnionClause	The UNION clause allows the results of two queries to be combined.
UnionClauseBNF	The query BNF for the order by clause.
UnionClauseFactory	This UnionClauseFactory creates a new UnionClause when the portion of the query to parse starts with UNION, INTERSECT or EXCEPT.
UnionPartitioning	UnionPartitioning sends queries to all connection pools and unions the results.
UnionPartitioning	JPA scripting API implementation.
UnionPartitioningPolicy	PUBLIC: UnionPartitionPolicy sends queries to all connection pools and unions the results.
UniqueConstraint	Specifies that a unique constraint is to be included in the generated DDL for a primary or secondary table.
UniqueConstraint	JPA scripting API implementation.
UniqueKeyConstraint	Purpose: Define a unique key constraint for a table.
UnitOfWork	Purpose: To allow object level transactions.
UnitOfWork.CommitOrderType	Defines the ordering of updates and deletes of a set of the same entity type during a commit or flush operation.
UnitOfWorkChangeSet	Purpose: To Provide API to the UnitOfWorkChangeSet.
UnknownDeclaration	This Declaration represents an unknown (invalid/incomplete) declaration.
UnknownExpression	This expression contains a portion of the query that is unknown to the parser.
UnknownExpressionFactory	This UnknownExpressionFactory creates a new UnknownExpression when the portion of the query to parse is unknown.
UnknownExpressionStateObject	This StateObject holds onto an unknown portion of a JPQL query that could not be parsed.
UnmappedContentHandler	Purpose:Provide an interface that can be implemented for handling unmapped content during unmarshal operations with SAXPlatform.
UnmarshalCallback	INTERNAL:
UnmarshalException	This exception indicates that an error has occurred while performing an unmarshal operation that prevents the JAXB Provider from completing the operation.
UnmarshalKeepAsElementPolicy	Purpose: Used in conjunction with XMLAnyObject/CollectionMapping and XMLCompositeObject/CollectionMapping to specify when (if at all) to keep parts of the unmarshalled document as nodes.
Unmarshaller	The Unmarshaller class governs the process of deserializing XML data into newly created Java content trees, optionally validating the XML data as it is unmarshalled.
Unmarshaller.Listener	Register an instance of an implementation of this class with Unmarshaller to externally listen for unmarshal events.
UnmarshallerHandler	Unmarshaller implemented as SAX ContentHandler.
UnmarshallerProperties	These are properties that may be set on an instance of Unmarshaller.
UnmarshalRecord
UpdateAllQuery	PUBLIC: A Query Class used to perform a bulk update using TopLink's expression framework.
UpdateClause	This is the update clause of the update statement.
UpdateClauseBNF	The query BNF for the update clause.
UpdateClauseFactory	This UpdateClauseFactory creates a new UpdateClause when the portion of the query to parse starts with UPDATE.
UpdateClauseStateObject	This is the UPDATE clause of the UPDATE statement.
UpdateItem	The new_value specified for an update operation must be compatible in type with the field to which it is assigned.
UpdateItemBNF	The query BNF for the update item expression.
UpdateItemFactory	This UpdateItemFactory creates a new UpdateItem.
UpdateItemStateFieldPathExpressionBNF	The query BNF for a state field path expression used in an update item.
UpdateItemStateFieldPathExpressionFactory	This UpdateItemStateFieldPathExpressionFactory is meant to handle the parsing of a portion of the query when it's expected to be a state field path.
UpdateItemStateObject	The new_value specified for an update operation must be compatible in type with the field to which it is assigned.
UpdateObjectQuery	Purpose: Used for updating existing objects into the database.
UpdateStatement	The UPDATE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.
UpdateStatementBNF	The query BNF for the update statement.
UpdateStatementFactory	This UpdateStatementFactory creates a new UpdateStatement when the portion of the query to parse starts with UPDATE.
UpdateStatementStateObject	The UPDATE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.
UpperExpression	The UPPER function converts a string to upper case and it returns a string.
UpperExpressionFactory	This UpperExpressionFactory creates a new UpperExpression when the portion of the query to parse starts with UPPER.
UpperExpressionStateObject	The UPPER function converts a string to upper case and it returns a string.
UuidGenerator	Defines a primary key generator that may be referenced by name when a generator element is specified for the GeneratedValue annotation.
UuidGenerator	JPA scripting API implementation.
UuidGenerators	A UuidGenerators annotation allows the definition of multiple UuidGenerator.
UUIDSequence
ValidatingMarshalRecord
ValidatingMarshalRecord.MarshalSAXParseException
ValidationEvent	This event indicates that a problem was encountered while validating the incoming XML data during an unmarshal operation, while performing on-demand validation of the Java content tree, or while marshalling the Java content tree back to XML data.
ValidationEventCollector	ValidationEventHandler implementation that collects all events.
ValidationEventHandler	A basic event handler interface for validation errors.
ValidationEventImpl	Default implementation of the ValidationEvent interface.
ValidationEventLocator	Encapsulate the location of a ValidationEvent.
ValidationEventLocatorImpl	Default implementation of the ValidationEventLocator interface.
ValidationException	This exception indicates that an error has occurred while performing a validate operation.
ValidationException	Purpose: This exception is used if incorrect state or method arguments are detected in a general TopLink object.
ValidationExceptionResource	INTERNAL: English ResourceBundle for ValidationException messages.
ValidationMode	The validation mode to be used by the provider for the persistence unit.
ValidationXMLReader	Detects external Bean Validation configuration.
Validator	Deprecated. since JAXB 2.0
ValueExpression	An identification variable qualified by the VALUE operator is a path expression.
ValueExpressionFactory	This ValueExpressionFactory creates a new ValueExpression when the portion of the query to parse starts with VALUE.
ValueExpressionStateObject	This object represents an identification variable that maps the values of a Map.
ValueHolder	Purpose: Act as a place holder for a variable that required a value holder interface.
ValueHolderInterface	Purpose: Interface to allow lazy loading of an object's relationships from the database.
ValuePartition	Represent a specific value partition.
ValuePartition	JPA scripting API implementation.
ValuePartitioning	ValuePartitioning partitions access to a database cluster by a field value from the object, such as the object's location, or tenant.
ValuePartitioning	JPA scripting API implementation.
ValuePartitioningPolicy	PUBLIC: ValuePartitioningPolicy partitions access to a database cluster by a field value from the object, such as the object's location, or tenant.
ValueReadQuery	Purpose: Concrete class to perform a read of a single data value.
ValueResolver	This Resolver is responsible to return the map value, which means that for identification variables referring to an instance of an association or collection represented as a Map, the identification variable is of the abstract schema type of the map value.
VariableDeclarationStateObject	This defines a variable declaration, which has a "root" object and an identification variable.
VariableOneToOne	Variable one to one mappings are used to represent a pointer references between a java object and an implementer of an interface.
VariableOneToOne	JPA scripting API implementation.
VariableOneToOneMapping	Purpose: Variable one to one mappings are used to represent a pointer references between a java object and an implementer of an interface.
VarrayDefinition	Purpose: Allow for creation of varray type.
Version	Specifies the version field or property of an entity class that serves as its optimistic lock value.
Version	JPA scripting API implementation.
Version	This class stores variables for the version and build numbers that are used in printouts and exceptions.
VersionLockingPolicy	Purpose: Used to allow a single version number to be used for optimistic locking.
ViewDefinition	Purpose: Allow for creation of views.
VirtualAccessMethods	Specifies that this class contains virtual attributes.
VirtualJPQLQueryBNF	This JPQLQueryBNF can be used as a virtual BNF, which can wrap another BNF or BNFs and modify the default behavior.
VPDMultitenantPolicy	A vpd multitenant policy.
W3CDomHandler	DomHandler implementation for W3C DOM (org.w3c.dom package.)
WeavedAttributeValueHolderInterface	INTERNAL: This interface defines functionality required by ValueHolders for OneToOneMappings that have LAZY access weaved into them and use Property (method) based access The weaving feature adds a paralell valueholder to the class it weaves and uses that valueholder to control the lazy loading.
WebLogic_10_Platform	PUBLIC: This is the concrete subclass responsible for representing WebLogic 10 specific behavior.
WebLogic_12_Platform
WebLogic_9_Platform	PUBLIC: This is the concrete subclass responsible for representing WebLogic9 specific behavior.
WebLogicPlatform	PUBLIC: This is the concrete subclass responsible for representing WebLogic-specific server behavior.
WebLogicPlatformDetector
WebLogicRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
WebLogicTransactionController	Purpose: TransactionController implementation for WLS JTA
WebSphere_6_1_Platform	PUBLIC: This is the concrete subclass responsible for representing WebSphere 6.1-specific server behavior.
WebSphere_7_Platform	PUBLIC: This is the concrete subclass responsible for representing WebSphere 7 -specific server behavior.
WebSphere_EJBEmbeddable_Platform
WebSphere_Liberty_Platform	PUBLIC: This is the concrete subclass responsible for representing WebSphere-specific server behavior.
WebSphereEJBEmbeddableTransactionController
WebSphereLibertyTransactionController
WebSpherePlatform	PUBLIC: This is the concrete subclass responsible for representing WebSphere-specific server behavior.
WebSpherePlatformDetector
WebSphereRuntimeServices	Purpose: Provide a dynamic interface into the EclipseLink Session.
WebSphereTransactionController	Purpose: TransactionController implementation for WebSphere
WhenClause	A WHEN predicate is used to calculate a condition and when it's true, its THEN will be executed.
WhenClauseBNF	The query BNF for the when clause of the case expression.
WhenClauseFactory	This WhenClauseFactory creates a new WhenClause when the portion of the query to parse starts with WHEN.
WhenClauseStateObject	A WHEN predicate is used to calculate a condition and when it's true, its THEN will be executed.
WhereClause	The WHERE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.
WhereClauseBNF	The query BNF for the where clause.
WhereClauseFactory	This WhereClauseFactory creates a new WhereClause when the portion of the query to parse starts with WHERE.
WhereClauseStateObject	The WHERE clause of a query consists of a conditional expression used to select objects or values that satisfy the expression.
WordParser	This "parser/scanner" holds onto the string version of the JPQL query that is parsed into a parsed tree.
WordParser.WordType	This enumeration determines the type of word that was scanned.
WrapperPolicy	Purpose: The wrapper policy can be used to wrap all objects read from the database in another object.
WriteObjectQuery	Purpose: Used for inserting or updating objects WriteObjectQuery determines whether to perform a insert or an update on the database.
WriterRecord	Use this type of MarshalRecord when the marshal target is a Writer and the XML should not be formatted with carriage returns or indenting.
WriteTransformer	Annotation for org.eclipse.persistence.mappings.TransformationMapping.
WriteTransformer	JPA scripting API implementation.
WriteTransformers	An optional annotation for org.eclipse.persistence.mappings.TransformationMapping.
XJCJavaAnnotationImpl	INTERNAL:
XJCJavaClassImpl	INTERNAL:
XJCJavaConstructorImpl	INTERNAL:
XJCJavaFieldImpl	INTERNAL:
XJCJavaMethodImpl	INTERNAL:
XJCJavaModelImpl	INTERNAL:
XJCJavaModelInputImpl	INTERNAL:
XJCJavaPackageImpl	INTERNAL:
XMLAbstractAnyMapping	Purpose: An abstract superclass for XMLAnyObjectMapping and XMLAnyCollectionMapping.
XmlAbstractNullPolicy	Java class for xml-abstract-null-policy complex type.
XmlAccessMethods	Java class for xml-access-methods complex type.
XmlAccessMethods	Purpose:This annotation allows the userTo specify accessor methods for a given property.
XmlAccessOrder	Used by XmlAccessorOrder to control the ordering of properties and fields in a JAXB bound class.
XmlAccessOrder	Java class for xml-access-order.
XmlAccessorOrder	Controls the ordering of fields and properties in a class.
XmlAccessorType	Controls whether fields or Javabean properties are serialized by default.
XmlAccessType	Used by XmlAccessorType to control serialization of fields or properties.
XmlAccessType	Java class for xml-access-type.
XmlAdapter<ValueType,BoundType>	Adapts a Java type for custom marshaling.
XmlAnyAttribute	Maps a JavaBean property to a map of wildcard attributes.
XmlAnyAttribute	Java class for anonymous complex type.
XMLAnyAttributeMapping	Purpose:The XMLAnyAttributeMapping is used to map to an attribute in an object to any xml attributes contained on a specific element in the XML Document.
XMLAnyCollectionMapping	Any collection XML mappings map an attribute that contains a heterogenous collection of objects to multiple XML elements.
XmlAnyElement	Maps a JavaBean property to XML infoset representation and/or JAXB element.
XmlAnyElement	Java class for anonymous complex type.
XMLAnyObjectMapping	Any object XML mappings map an attribute that contains a single object to an XML element.
XMLAttachmentMarshaller	Purpose: Provides an interface through which EclipseLink can allow a user to do special handling for Binary Data.
XmlAttachmentRef	Marks a field/property that its XML form is a uri reference to mime content.
XMLAttachmentUnmarshaller	Purpose: Provides an interface through which EclipseLink can allow a user to do special handling for Binary Data.
XmlAttribute	Maps a JavaBean property to a XML attribute.
XmlAttribute	Java class for anonymous complex type.
XMLBinaryDataCollectionMapping	Purpose:Provide a mapping for a collection of binary data values that can be treated as either inline binary values or as an attachment.
XMLBinaryDataMapping	Purpose:Provide a mapping for binary data that can be treated as either inline or as an attachment.
XMLBinder	PUBLIC:
XmlBindings	Java class for anonymous complex type.
XmlBindings.JavaTypes	Java class for anonymous complex type.
XmlBindings.XmlEnums	Java class for anonymous complex type.
XmlBindings.XmlRegistries	Java class for anonymous complex type.
XmlCDATA	Wrap the value inside a CDATA section.
XMLChoiceCollectionMapping	PUBLIC:
XMLChoiceObjectMapping	PUBLIC:
XmlClassExtractor	Java class for xml-class-extractor complex type.
XmlClassExtractor	A ClassExtractor allows for a user defined class indicator in place of using xsi:type.
XMLCollectionReferenceMapping	TopLink OXM version of a 1-M mapping.
XMLComparer	This class is used to compare if two DOM nodes are equal.
XMLCompositeCollectionMapping	Composite collection XML mappings map an attribute that contains a homogeneous collection of objects to multiple XML elements.
XMLCompositeDirectCollectionMapping	Composite direct collection XML mappings map a collection of simple types (String, Number, Date, etc.) to and from a sequence of composite XML nodes.
XMLCompositeObjectMapping	Composite object XML mappings represent a relationship between two classes.
XMLConstants	XMLConstants maintains a list of useful XML constants.
XmlContainerProperty	Deprecated. As of EclipseLink 2.0, replaced by XmlInverseReference.
XMLContext	An XMLContext is created based on EclipseLink sessions or projects and can then used to create instances of XMLMarshaller, XMLUnmarshaller and XMLValidator.
XMLConversionException	Purpose: XML conversion exceptions are raised for any problem when converting Java types to/from XML.
XMLConversionExceptionResource	INTERNAL:
XMLConverter	Purpose: Conversion interface to allow conversion between object and data types.
XMLConverterAdapter
XmlCustomizer	The XmlCustomizer annotation is used to specify a class that implements the org.eclipse.persistence.config.DescriptorCustomizer interface and is to run against a class descriptor after all metadata processing has been completed.
XMLDescriptor	Use an XML project for nontransactional, nonpersistent (in-memory) conversions between Java objects and XML documents.
XMLDirectMapping	XML Direct Mappings map a Java attribute directly to XML attribute or text node.
XmlDiscriminatorNode	The XmlDiscriminatorNode annotation is used to specify the class indicator field name when using inheritance.
XmlDiscriminatorValue	The XmlDiscriminatorValue annotation is used to specify the class indicator for a given type when using inheritance.
XmlElement	Maps a JavaBean property to a XML element derived from property name.
XmlElement	Java class for anonymous complex type.
XmlElement.DEFAULT	Used in XmlElement.type() to signal that the type be inferred from the signature of the property.
XmlElement.XmlInverseReference	Java class for anonymous complex type.
XmlElementDecl	Maps a factory method to a XML element.
XmlElementDecl.GLOBAL	Used in XmlElementDecl.scope() to signal that the declaration is in the global scope.
XmlElementNillable	Java class for anonymous complex type.
XmlElementNillable	Purpose: Provide a means of setting nillable on type and package level, which is not possible with standard XmlElement annotation.
XmlElementRef	Maps a JavaBean property to a XML element derived from property's type.
XmlElementRef	Java class for anonymous complex type.
XmlElementRef.DEFAULT	Used in XmlElementRef.type() to signal that the type be inferred from the signature of the property.
XmlElementRefs	Marks a property that refers to classes with XmlElement or JAXBElement.
XmlElementRefs	Java class for anonymous complex type.
XmlElements	A container for multiple @XmlElement annotations.
XmlElements	Java class for anonymous complex type.
XmlElementsJoinNodes	XmlElementsJoinNodes is used in conjunction with XmlElements in order to specify the key references for the targets of the XmlElements annotation.
XmlElementWrapper	Generates a wrapper element around XML representation.
XmlElementWrapper	Java class for anonymous complex type.
XMLEntry	INTERNAL:
XmlEnum	Maps an enum type Enum to XML representation.
XmlEnum	Java class for anonymous complex type.
XmlEnumValue	Maps an enum constant in Enum type to XML representation.
XmlEnumValue	Java class for anonymous complex type.
XmlEscapeCharacterConverter	This converter handles references when dealing with text or markup in an XML document.
XMLEventWriterRecord
XMLField	TopLink XML mappings make use of XMLFields based on XPath statements to find the relevant data in an XML document.
XMLFragmentCollectionMapping	Purpose: This mapping provides a means to keep a part of the xml tree as a collection of DOM elements.
XMLFragmentMapping	Purpose: This mapping provides a means to keep a part of the xml tree as a DOM element.
XmlID	Maps a JavaBean property to XML ID.
XmlIDExtension	Purpose: Provide a way to allow properties with XmlID annotation have different type than java.lang.String.
XmlIDREF	Maps a JavaBean property to XML IDREF.
XmlInlineBinaryData	Disable consideration of XOP encoding for datatypes that are bound to base64-encoded binary data in XML.
XMLInteraction	Defines the specification for a call to a JCA interaction that uses XML.
XmlInverseReference	Java class for anonymous complex type.
XmlInverseReference	This annotation is used to map a back-pointer during the unmarshal operation.
XMLInverseReferenceMapping	This mapping is used to map a back-pointer.
XmlIsSetNullPolicy	Java class for anonymous complex type.
XmlIsSetNullPolicy	Purpose: Provide a means of using annotations to customise the handling of null values and their xml representation.
XmlIsSetNullPolicy.IsSetParameter	Java class for anonymous complex type.
XmlJavaTypeAdapter	Use an adapter that implements XmlAdapter for custom marshaling.
XmlJavaTypeAdapter	Java class for anonymous complex type.
XmlJavaTypeAdapter.DEFAULT	Used in XmlJavaTypeAdapter.type() to signal that the type be inferred from the signature of the field, property, parameter or the class.
XmlJavaTypeAdapters	A container for multiple @XmlJavaTypeAdapter annotations.
XmlJavaTypeAdapters	Java class for anonymous complex type.
XmlJoinNode	XmlJoinNode is used in conjunction with XmlKey to specify a reference mapping.
XmlJoinNodes	Java class for anonymous complex type.
XmlJoinNodes	XmlJoinNodes is a holder for multiple XmlJoinNode annotations.
XmlJoinNodes.XmlJoinNode	Java class for anonymous complex type.
XmlKey	XmlKey is used to mark a property as a key, to be referenced using a key-based mapping via XmlJoinNode.
XmlList	Used to map a property to a list simple type.
XMLListConverter	Purpose: Provides an implementation of Converter that can be used to convert a collection of Objects into a space separated list of Strings and back.
XmlLocation	XmlLocation can be used on a property of type Locator, to provide information about the XML location (line and column number, source location) that the owning object was unmarshalled from.
XMLLogFormatter	Format a TopLink LogRecord into a standard XML format.
XMLLogin	In OX, the platform determines which parsing method will be used, DOM vs SAX.
XmlMap	Java class for anonymous complex type.
XmlMap.Key	Java class for anonymous complex type.
XmlMap.Value	Java class for anonymous complex type.
XMLMapping	INTERNAL All mappings which can be added to org.eclipse.persistence.oxm.XMLDescriptor must implement this interface.
XMLMarshalException	Purpose: XMLMarshalExceptions are raised when issues are encountered during XMLMarshaller or XMLUnmarshaller operations.
XMLMarshalExceptionResource	INTERNAL: English ResourceBundle for XMLValidationException.
XMLMarshaller	Class used to marshal object to XML.
XMLMarshalListener	An implementation of XMLMarshalListener can be set on an XMLMarshaller to provide additional behaviour during marshal operations.
XmlMarshalNullRepresentation	Java class for xml-marshal-null-representation.
XmlMarshalNullRepresentation	Purpose: This enumeration provides a means of specifying how a null value in a java object should be marshalled to XML.
XMLMetadataSource	A concrete implementation of MetadataSource that can represent the following metadata input types; java.io.File java.io.InputStream java.io.Reader java.net.URL javax.xml.stream.XMLEventReader javax.xml.stream.XMLStreamReader javax.xml.transform.Source org.w3c.dom.Node org.xml.sax.InputSource
XMLMetadataSource	Purpose: Support reading metadata for a persistence unit in an XML format from a URL and if the property is undefined, it will look for a file.
XmlMimeType	Associates the MIME type that controls the XML representation of the property.
XmlMixed	Annotate a JavaBean multi-valued property to support mixed content.
XmlNamedAttributeNode	Java class for xml-named-attribute-node complex type.
XmlNamedAttributeNode	A XmlNamedAttributeNode is a member element of a XmlNamedObjectGraph.
XmlNamedObjectGraph	Java class for anonymous complex type.
XmlNamedObjectGraph	Purpose: Used to define the boundaries for a marshal or unmarhsal operation.
XmlNamedObjectGraphs	Java class for anonymous complex type.
XmlNamedObjectGraphs	Used to group XmlNamedObjectGraph annotations.
XmlNamedSubgraph	Java class for xml-named-subgraph complex type.
XmlNamedSubgraph	A XmlNamedSubgraph is a member element of a XmlNamedObjectGraph.
XMLNamespaceResolver
XmlNameTransformer	An XmlNameTransformer allows for a user defined class to transform names.
XMLNameTransformer	Interface used when converting from XML to Java names.
XmlNillableInfo
XMLNillableMapping	INTERNAL All nillable mappings which can be added to org.eclipse.persistence.oxm.XMLDescriptor must implement this interface. The default policy is AbstractNullPolicy.
XMLNodeList	Implementation of the org.w3c.dom.NodeList interface
XmlNs	Associates a namespace prefix with a XML namespace URI.
XmlNsForm	Enumeration of XML Schema namespace qualifications.
XmlNsForm	Java class for xml-ns-form.
XmlNullPolicy	Java class for anonymous complex type.
XmlNullPolicy	Purpose: Provide a means of using annotations to customise the handling of null values and their xml representation.
XMLNullRepresentationType	Description: An enum that is used within a Node Null Policy to determine what to marshal for a null node. We define 3 final instances available to the user (XSI_NIL, ABSENT_NODE(default) and EMPTY_NODE.
XMLObjectReferenceMapping	TopLink OXM version of a 1-1 mapping.
XmlParameter	Purpose: An annotation representing a parameter to a method.
XMLParseException
XMLParseExceptionResource
XMLParser
XmlPath	XPath based mapping is what allows an existing object model to be mapped to an existing XML schema.
XmlPaths	Purpose: This annotation is used in conjunction with an XmlElements annotation to specify an XmlPath for each of the XmlElement annotations in the XmlElements.
XMLPlatform<XML_UNMARSHALLER extends org.eclipse.persistence.internal.oxm.XMLUnmarshaller>
XMLPlatform
XMLPlatformException
XMLPlatformExceptionResource	INTERNAL:
XMLPlatformFactory
XMLProcessor	INTERNAL:
XMLProjectReader	Purpose: Allow for a EclipseLink Mapping Workbench generated deployment XML project file to be read.
XMLProjectWriter	Purpose: Write the deployment XML (object persistence meta-data) for the TopLink project instance to a file.
XmlProperties	Java class for xml-properties complex type.
XmlProperties	Annotation for user defined properties.
XmlProperties.XmlProperty	Java class for anonymous complex type.
XmlProperty	Annotation for a user defined property.
XmlReadOnly	Purpose: This annotation indicates that a specific property should be flagged as read-only by EclipseLink.
XmlReadTransformer	Purpose: XmlReadTransformer is used to allow the user direct access to the XML in order to populate their object model.
XMLRecord	PUBLIC: Provides a Record/Map API on an XML DOM element.
XmlRegistry	Marks a class that has XmlElementDecls.
XmlRegistry	Java class for anonymous complex type.
XmlRegistry.XmlElementDecl	Java class for anonymous complex type.
XMLRoot	XMLRoot is used to hold an Object along with the corresponding QName and some other related information.
XMLRootConverter	Purpose: Provides an implementation of XMLConverter to wrap/unwrap objects in an XMLRoot in order to capture element name information.
XmlRootElement	Maps a class or an enum type to an XML element.
XmlRootElement	Java class for anonymous complex type.
XMLRootRecord	Record for handling simple root elements that have a single text child node, and are being unmarshalled to a primitive wrapper object.
XmlSchema	Maps a package name to a XML namespace.
XmlSchema	Java class for anonymous complex type.
XmlSchema.XmlNs	Java class for anonymous complex type.
XMLSchemaClassPathReference	A schema reference for accessing an XML Schema from the class path.
XMLSchemaFileReference	A schema reference for accessing an XML Schema from a file.
XMLSchemaReference	Provides a way for a descriptor's reference to its schema to be specified.
XMLSchemaReference	A schema reference is used to access a schema in order to validate a document.
XmlSchemaType	Maps a Java type to a simple schema built-in type.
XmlSchemaType	Java class for anonymous complex type.
XmlSchemaType.DEFAULT	Used in XmlSchemaType.type() to signal that the type be inferred from the signature of the property.
XmlSchemaTypes	A container for multiple @XmlSchemaType annotations.
XmlSchemaTypes	Java class for anonymous complex type.
XMLSchemaURLReference
XmlSeeAlso	Instructs JAXB to also bind other classes when binding this class.
XMLSerializer	Uses JAXB to convert an object to XML.
XMLSessionConfigLoader	Provide a mechanism for loading Session configuration XML files.
XMLStreamWriterRecord	Use this type of MarshalRecord when the marshal target is an XMLStreamWriter
XmlTransformation	Java class for anonymous complex type.
XmlTransformation	Transformation is an optional annotation for org.eclipse.persistence.mappings.oxm.XMLTransformationMapping.
XmlTransformation.XmlReadTransformer	Java class for anonymous complex type.
XmlTransformation.XmlWriteTransformer	Java class for anonymous complex type.
XMLTransformationMapping	Transformation XML mappings are used to create a custom mapping where one or more XML nodes can be used to create the object to be stored in a Java class's attribute.
XMLTransformer
XmlTransient	Prevents the mapping of a JavaBean property/type to XML representation.
XmlTransient	Java class for anonymous complex type.
XmlType	Maps a class or an enum type to a XML Schema type.
XmlType	Java class for anonymous complex type.
XmlType.DEFAULT	Used in XmlType.factoryClass() to signal that either factory mehod is not used or that it's in the class with this XmlType itself.
XMLUnionField	Subclass of XMLField for fields that are mapped to unions.
XMLUnmarshaller	Class used to unmarshal XML & JSON to objects.
XMLUnmarshallerHandler	Class used to unmarshal SAX events to objects.
XMLUnmarshalListener	An implementation of XMLUnmarshalListener can be set on an XMLUnmarshaller to provide additional behaviour during unmarshal operations.
XMLValidator	Class used to validate XML.
XmlValue	Enables mapping a class to a XML Schema complex type with a simpleContent or a XML Schema simple type.
XmlValue	Java class for anonymous complex type.
XmlValueExtension	Purpose: Provide a way to allow classes, which contain property annotated with XmlValue to extend classes other than java.lang.Object.
XmlVariableNode	Java class for anonymous complex type.
XmlVariableNode
XmlVariableNode.DEFAULT	Used in XmlVariableNode.type() to signal that the type be inferred from the signature of the property.
XMLVariableXPathCollectionMapping
XMLVariableXPathObjectMapping
XmlVirtualAccessMethods	Java class for anonymous complex type.
XmlVirtualAccessMethods	The XmlVirtualAccessMethods annotation is used to indicate that this class has been configured to hold virtual properties.
XmlVirtualAccessMethodsSchema	Purpose: XmlVirtualAccessMethodsSchema enumeration is used in conjunction with XmlVirtualAcessMethods to configure how virtual properties are generated into the schema.
XmlVirtualAccessMethodsSchema
XmlWriteOnly	Purpose: This annotation indicates that a specific property should be flagged as write-only by EclipseLink.
XmlWriteTransformer	Annotation for org.eclipse.persistence.mappings.oxm.XMLTransformationMapping.
XmlWriteTransformers	Purpose: Annotation used to wrap multiple XmlWriteTransformer annotations.
XQueryInteraction	Defines the specification for a call to a JCA interaction that uses XQuery.
_CORBARemoteSessionControllerImplBase	INTERNAL: org/eclipse/persistence/remote/corba/sun/_CORBARemoteSessionControllerImplBase.java Generated by the IDL-to-Java compiler (portable), version "3.0" from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl Thursday, May 3, 2001 1:36:59 PM EDT
_CORBARemoteSessionControllerStub	INTERNAL: org/eclipse/persistence/remote/corba/sun/_CORBARemoteSessionControllerStub.java Generated by the IDL-to-Java compiler (portable), version "3.0" from CorbaRemoteSessionControllerSun.idl Monday, November 19, 2001 1:51:44 o'clock PM EST
_RMIRemoteSessionController_Stub	INTERNAL:
_RMIRemoteSessionControllerDispatcher_Tie	INTERNAL: