| Package | Description | 
|---|---|
| org.datanucleus | 
 This package provides classes that are typically externally called, whether that means by developers
    or by other DataNucleus plugins. 
 | 
| org.datanucleus.api | 
 
        Provides adapters for different client APIs, like JDO, JPA and so on. 
 | 
| org.datanucleus.enhancer | 
 
        DataNucleus ByteCode enhancer framework. 
 | 
| org.datanucleus.exceptions | 
 This package provides exceptions thrown by the core (client-facing) parts of DataNucleus. 
 | 
| org.datanucleus.identity | 
 
        Package defining object identity classes. 
 | 
| org.datanucleus.metadata | 
 
        Provides classes representing the MetaData for files, packages, classes, fields, containers, etc. 
 | 
| org.datanucleus.metadata.annotations | 
 
        Provides classes for parsing annotations input data and converting into org.datanucleus.metadata input 
        data for the DataNucleus persistence process. 
 | 
| org.datanucleus.plugin | 
 Package providing the plugin mechanism utilised by DataNucleus. 
 | 
| org.datanucleus.query | 
 This package provides general classes for querying across all datastores in particular languages. 
 | 
| org.datanucleus.query.compiler | 
 Package handling the compilation of queries. 
 | 
| org.datanucleus.query.inmemory | 
 Package providing the evaluation of queries using an in-memory process with evaluators for JDOQL and JPQL. 
 | 
| org.datanucleus.state | 
 Provides classes relating to the life cycle state of a persistable object. 
 | 
| org.datanucleus.store | 
 Package handling the storage of classes to the datastore, and the management of the datastore. 
 | 
| org.datanucleus.store.autostart | 
 Package providing the structure and some implementation for the auto-start mechanism. 
 | 
| org.datanucleus.store.federation | 
 Package providing management for federation of datastores. 
 | 
| org.datanucleus.store.query | 
 Package providing implementation of query language support for datastores. 
 | 
| org.datanucleus.store.schema.naming | 
 This package is a work-in-progress to provide datastore-agnostic naming strategies for JDO, JPA and
    indeed any other API. 
 | 
| org.datanucleus.store.schema.table | 
 Provides a series of convenience classes for modelling tables and columns that a class and its members map onto. 
 | 
| org.datanucleus.store.types | 
 Package providing basic java type handling for DataNucleus. 
 | 
| org.datanucleus.store.types.containers | |
| org.datanucleus.store.types.converters | 
 Package providing type conversion for member types, using the interface TypeConverter allowing
    conversion between some member Java type, and a Java type suitable for persistence in the datastore. 
 | 
| org.datanucleus.transaction.jta | 
 Package providing handlers for JTA transactions 
 | 
| org.datanucleus.util | 
 Provides utility classes used in the implementation that don't fit in a particular functional part of the system. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ClassLoaderResolverImpl
A basic implementation of a ClassLoaderResolver. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected Map<String,ClassLoaderResolver> | 
AbstractNucleusContext.classLoaderResolverMap
Map of the ClassLoaderResolver, keyed by the clr class and the primaryLoader name. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
ClassLoaderResolver | 
ExecutionContext.getClassLoaderResolver()
Accessor for the ClassLoader resolver to use in class loading issues. 
 | 
ClassLoaderResolver | 
ExecutionContextImpl.getClassLoaderResolver()  | 
ClassLoaderResolver | 
NucleusContext.getClassLoaderResolver(ClassLoader primaryLoader)
Accessor for a ClassLoaderResolver to use in resolving classes. 
 | 
ClassLoaderResolver | 
AbstractNucleusContext.getClassLoaderResolver(ClassLoader primaryLoader)  | 
| Modifier and Type | Method and Description | 
|---|---|
static StoreManager | 
NucleusContextHelper.createStoreManagerForProperties(Map<String,Object> props,
                               Map<String,Object> datastoreProps,
                               ClassLoaderResolver clr,
                               NucleusContext nucCtx)
Method to create a StoreManager based on the specified properties passed in. 
 | 
protected void | 
PersistenceNucleusContextImpl.initialiseAutoStart(ClassLoaderResolver clr)
Method to initialise the auto-start mechanism, loading up the classes
 from its store into memory so that we start from what is required to be loaded. 
 | 
protected void | 
PersistenceNucleusContextImpl.initialiseNamedQueries(ClassLoaderResolver clr)
Method to compile all registered named queries (when the user has initialised using a persistence-unit). 
 | 
<T> T | 
ImplementationCreator.newInstance(Class<T> pc,
           ClassLoaderResolver loader)
Constructs an implementation for an interface and instantiates it 
 | 
| Constructor and Description | 
|---|
FetchPlan(ExecutionContext ec,
         ClassLoaderResolver clr)
Constructor. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
boolean | 
ApiAdapter.isValidPrimaryKeyClass(Class pkClass,
                      AbstractClassMetaData cmd,
                      ClassLoaderResolver clr,
                      int noOfPkFields,
                      MetaDataManager mmgr)
Utility to check if a primary-key class is valid. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected ClassLoaderResolver | 
ClassEnhancerImpl.clr
Class Loader Resolver to use for any loading issues. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
ClassLoaderResolver | 
ClassEnhancer.getClassLoaderResolver()
Accessor for the ClassLoaderResolver in use. 
 | 
ClassLoaderResolver | 
ClassEnhancerImpl.getClassLoaderResolver()
Accessor for the ClassLoaderResolver 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
EnhancerClassLoader.defineClass(String fullClassName,
           byte[] bytes,
           ClassLoaderResolver clr)
Define a class in this ClassLoader. 
 | 
void | 
ImplementationGenerator.enhance(ClassLoaderResolver clr)
Enhance the implementation of the class/interface. 
 | 
Object | 
ImplementationCreatorImpl.newInstance(Class cls,
           ClassLoaderResolver clr)
Method to generate an instance of an interface, abstract class, or concrete PC class. 
 | 
protected Persistable | 
ImplementationCreatorImpl.newInstance(ClassMetaData cmd,
           ClassLoaderResolver clr)
Constructs an implementation for an abstract class and instantiates it. 
 | 
protected Persistable | 
ImplementationCreatorImpl.newInstance(InterfaceMetaData imd,
           ClassLoaderResolver clr)
Constructs an implementation for an interface and instantiates it. 
 | 
| Constructor and Description | 
|---|
ClassEnhancerImpl(ClassMetaData cmd,
                 ClassLoaderResolver clr,
                 MetaDataManager mmgr,
                 EnhancementNamer namer)
Constructor for an enhancer for the class. 
 | 
ClassEnhancerImpl(ClassMetaData cmd,
                 ClassLoaderResolver clr,
                 MetaDataManager mmgr,
                 EnhancementNamer namer,
                 byte[] classBytes)
Constructor for an enhancer to enhance a class defined by the provided bytes. 
 | 
EnhancerClassLoader(ClassLoaderResolver iDelegate)  | 
| Modifier and Type | Method and Description | 
|---|---|
ClassLoaderResolver | 
DatastoreReadOnlyException.getClassLoaderResolver()  | 
| Constructor and Description | 
|---|
DatastoreReadOnlyException(String msg,
                          ClassLoaderResolver clr)  | 
| Modifier and Type | Method and Description | 
|---|---|
Object | 
IdentityManager.getApplicationId(ClassLoaderResolver clr,
                AbstractClassMetaData acmd,
                String keyToString)
Utility to create a new application identity when you know the metadata for the target class,
 and the toString() output of the identity. 
 | 
Object | 
IdentityManagerImpl.getApplicationId(ClassLoaderResolver clr,
                AbstractClassMetaData acmd,
                String keyToString)
Utility to create a new application identity when you know the metadata for the target class,
 and the toString() output of the identity. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
MetaDataManager.addAnnotationsDataToClass(Class c,
                         AbstractClassMetaData cmd,
                         ClassLoaderResolver clr)  | 
void | 
MetaDataManagerImpl.addAnnotationsDataToClass(Class c,
                         AbstractClassMetaData cmd,
                         ClassLoaderResolver clr)
Load up and add any annotations mapping info for the specified class to the stored ClassMetaData. 
 | 
void | 
MetaDataManager.addORMDataToClass(Class c,
                 ClassLoaderResolver clr)  | 
void | 
MetaDataManagerImpl.addORMDataToClass(Class c,
                 ClassLoaderResolver clr)
Load up and add any O/R mapping info for the specified class to the stored ClassMetaData (if supported). 
 | 
protected void | 
AbstractClassMetaData.determineSuperClassName(ClassLoaderResolver clr,
                       Class cls)
Determine the nearest superclass that is persistable (if any). 
 | 
int[] | 
AbstractClassMetaData.getBasicMemberPositions(ClassLoaderResolver clr)
Accessor for the absolute positions of fields/properties that are considered basic. 
 | 
int[] | 
AbstractClassMetaData.getBidirectionalRelationMemberPositions(ClassLoaderResolver clr)
Convenience method to return the absolute positions of fields/properties that have bidirectional
 relations. 
 | 
String[] | 
MetaDataManager.getClassesImplementingInterface(String interfaceName,
                               ClassLoaderResolver clr)
Accessor for the list of names of classes that are declared to implement the specified interface
 (using <implements> in the MetaData). 
 | 
String[] | 
MetaDataManagerImpl.getClassesImplementingInterface(String interfaceName,
                               ClassLoaderResolver clr)  | 
AbstractClassMetaData | 
ArrayMetaData.getElementClassMetaData(ClassLoaderResolver clr)
Convenience accessor for the Element ClassMetaData. 
 | 
AbstractClassMetaData | 
CollectionMetaData.getElementClassMetaData(ClassLoaderResolver clr)
Convenience accessor for the Element ClassMetaData. 
 | 
static FileMetaData[] | 
MetaDataUtils.getFileMetaDataForInputFiles(MetaDataManager metaDataMgr,
                            ClassLoaderResolver clr,
                            String[] inputFiles)
Method to take the provided input files and returns the FileMetaData that they implies. 
 | 
String[] | 
MetaDataUtils.getImplementationNamesForReferenceField(AbstractMemberMetaData fmd,
                                       FieldRole fieldRole,
                                       ClassLoaderResolver clr,
                                       MetaDataManager mmgr)
Convenience method to return the class names of the available implementation types for 
 an interface/Object field, given its required role. 
 | 
AbstractClassMetaData | 
MapMetaData.getKeyClassMetaData(ClassLoaderResolver clr)
Convenience accessor for the Key ClassMetaData. 
 | 
AbstractClassMetaData | 
MetaDataManager.getMetaDataForClass(Class c,
                   ClassLoaderResolver clr)
Main accessor for the MetaData for a class. 
 | 
AbstractClassMetaData | 
MetaDataManagerImpl.getMetaDataForClass(Class c,
                   ClassLoaderResolver clr)  | 
AbstractClassMetaData | 
MetaDataManager.getMetaDataForClass(String className,
                   ClassLoaderResolver clr)
Accessor for the MetaData for a class given the name and a loader. 
 | 
AbstractClassMetaData | 
MetaDataManagerImpl.getMetaDataForClass(String className,
                   ClassLoaderResolver clr)  | 
AbstractClassMetaData | 
MetaDataManager.getMetaDataForClassInternal(Class c,
                           ClassLoaderResolver clr)
Internal convenience method for accessing the MetaData for a class. 
 | 
AbstractClassMetaData | 
MetaDataManagerImpl.getMetaDataForClassInternal(Class c,
                           ClassLoaderResolver clr)  | 
ClassMetaData | 
MetaDataManager.getMetaDataForImplementationOfReference(Class referenceClass,
                                       Object implValue,
                                       ClassLoaderResolver clr)
Accessor for the MetaData for an implementation of a reference type. 
 | 
ClassMetaData | 
MetaDataManagerImpl.getMetaDataForImplementationOfReference(Class referenceClass,
                                       Object implValue,
                                       ClassLoaderResolver clr)  | 
InterfaceMetaData | 
MetaDataManager.getMetaDataForInterface(Class c,
                       ClassLoaderResolver clr)
Accessor for the MetaData for an interface. 
 | 
InterfaceMetaData | 
MetaDataManagerImpl.getMetaDataForInterface(Class c,
                       ClassLoaderResolver clr)  | 
QueryMetaData | 
MetaDataManager.getMetaDataForQuery(Class cls,
                   ClassLoaderResolver clr,
                   String queryName)
Accessor for the MetaData for a named query for a class. 
 | 
QueryMetaData | 
MetaDataManagerImpl.getMetaDataForQuery(Class cls,
                   ClassLoaderResolver clr,
                   String queryName)  | 
SequenceMetaData | 
MetaDataManager.getMetaDataForSequence(ClassLoaderResolver clr,
                      String seqName)
Accessor for the MetaData for a Sequence in a package. 
 | 
SequenceMetaData | 
MetaDataManagerImpl.getMetaDataForSequence(ClassLoaderResolver clr,
                      String seqName)  | 
StoredProcQueryMetaData | 
MetaDataManager.getMetaDataForStoredProcQuery(Class cls,
                             ClassLoaderResolver clr,
                             String queryName)
Accessor for the MetaData for a named stored procedure query for a class. 
 | 
StoredProcQueryMetaData | 
MetaDataManagerImpl.getMetaDataForStoredProcQuery(Class cls,
                             ClassLoaderResolver clr,
                             String queryName)  | 
TableGeneratorMetaData | 
MetaDataManager.getMetaDataForTableGenerator(ClassLoaderResolver clr,
                            String genName)
Accessor for the MetaData for a TableGenerator in a package. 
 | 
TableGeneratorMetaData | 
MetaDataManagerImpl.getMetaDataForTableGenerator(ClassLoaderResolver clr,
                            String genName)  | 
int[] | 
AbstractClassMetaData.getNonRelationMemberPositions(ClassLoaderResolver clr)  | 
List<AbstractClassMetaData> | 
MetaDataManager.getReferencedClasses(String[] classNames,
                    ClassLoaderResolver clr)
Convenience method to get the MetaData for all referenced classes with the passed set of classes as root. 
 | 
List<AbstractClassMetaData> | 
MetaDataManagerImpl.getReferencedClasses(String[] classNames,
                    ClassLoaderResolver clr)  | 
protected List<AbstractClassMetaData> | 
MetaDataManagerImpl.getReferencedClassMetaData(AbstractClassMetaData cmd,
                          ClassLoaderResolver clr)
Utility to return all ClassMetaData that is referenced from the supplier class. 
 | 
AbstractMemberMetaData[] | 
AbstractMemberMetaData.getRelatedMemberMetaData(ClassLoaderResolver clr)
Accessor for the FieldMetaData of any related field/property (where this field is part of a 
 bidirectional relation). 
 | 
AbstractMemberMetaData | 
AbstractMemberMetaData.getRelatedMemberMetaDataForObject(ClassLoaderResolver clr,
                                 Object thisPC,
                                 Object otherPC)
Convenience accessor for the MetaData for the field/property at the other side of the bidirectional
 relation given the objects at this side and the other side. 
 | 
int[] | 
AbstractClassMetaData.getRelationMemberPositions(ClassLoaderResolver clr)
Convenience method to return the absolute positions of all fields/properties that have relations. 
 | 
RelationType | 
AbstractMemberMetaData.getRelationType(ClassLoaderResolver clr)
Accessor for the relation type for this field. 
 | 
protected MetaDataScanner | 
MetaDataManagerImpl.getScanner(ClassLoaderResolver clr)
Accessor for any scanner for metadata classes (optional). 
 | 
AbstractClassMetaData | 
MapMetaData.getValueClassMetaData(ClassLoaderResolver clr)
Convenience accessor for the Value ClassMetaData 
 | 
boolean | 
AbstractClassMetaData.hasRelations(ClassLoaderResolver clr)
Convenience method to return if the class has relations to other objects. 
 | 
void | 
AbstractElementMetaData.initialise(ClassLoaderResolver clr)
Method to initialise the object, creating any convenience arrays needed. 
 | 
void | 
ClassMetaData.initialise(ClassLoaderResolver clr)
Method to initialise the object, creating internal convenience arrays. 
 | 
void | 
JoinMetaData.initialise(ClassLoaderResolver clr)
Method to initialise the object, creating internal convenience arrays. 
 | 
void | 
DiscriminatorMetaData.initialise(ClassLoaderResolver clr)
Initialisation method. 
 | 
void | 
AbstractMemberMetaData.initialise(ClassLoaderResolver clr)
Initialisation method. 
 | 
void | 
InheritanceMetaData.initialise(ClassLoaderResolver clr)
Method to initialise the object, creating internal convenience arrays. 
 | 
void | 
OrderMetaData.initialise(ClassLoaderResolver clr)
Method to initialise the object, creating internal convenience arrays. 
 | 
void | 
PackageMetaData.initialise(ClassLoaderResolver clr)  | 
void | 
MetaData.initialise(ClassLoaderResolver clr)  | 
void | 
InterfaceMetaData.initialise(ClassLoaderResolver clr)
Method to initialise the object, creating internal convenience arrays. 
 | 
void | 
EmbeddedMetaData.initialise(ClassLoaderResolver clr)
Method to initialise the object, creating all internal convenience arrays. 
 | 
void | 
VersionMetaData.initialise(ClassLoaderResolver clr)
Initialisation method. 
 | 
protected void | 
MetaDataManagerImpl.initialiseAbstractClassMetaData(AbstractClassMetaData cmd,
                               ClassLoaderResolver clr)
Convenience method to initialise the MetaData for the specified class/interface. 
 | 
protected void | 
MetaDataManagerImpl.initialiseClassMetaData(ClassMetaData cmd,
                       Class cls,
                       ClassLoaderResolver clr)
Utility to initialise the MetaData for a class, using the specified
 class. 
 | 
protected void | 
MetaDataManagerImpl.initialiseFileMetaData(FileMetaData filemd,
                      ClassLoaderResolver clr,
                      ClassLoader primary)
Initialise all classes/interfaces in a Meta-Data file. 
 | 
protected void | 
MetaDataManagerImpl.initialiseFileMetaDataForUse(Collection fileMetaData,
                            ClassLoaderResolver clr)
Method to initialise the provided FileMetaData, ready for use. 
 | 
protected void | 
MetaDataManagerImpl.initialiseInterfaceMetaData(InterfaceMetaData imd,
                           ClassLoaderResolver clr,
                           ClassLoader primary)
Utility to initialise the MetaData for a interface, using the specified
 class. 
 | 
static boolean | 
MetaDataUtils.isMemberEmbedded(AbstractMemberMetaData mmd,
                RelationType relationType,
                ClassLoaderResolver clr,
                MetaDataManager mmgr)
Convenience method to return whether a member is stored as embedded. 
 | 
boolean | 
MetaDataUtils.isMemberEmbedded(MetaDataManager mmgr,
                ClassLoaderResolver clr,
                AbstractMemberMetaData mmd,
                RelationType relationType,
                AbstractMemberMetaData ownerMmd)
Convenience method to return if the specified member is embedded. 
 | 
boolean | 
AbstractMemberMetaData.isPersistentInterface(ClassLoaderResolver clr)
Convenience method to return if this member relates to a persistent interface. 
 | 
boolean | 
AbstractMemberMetaData.isRelationOwner(ClassLoaderResolver clr)
Convenience method for whether this field is the owner of the relation. 
 | 
protected FileMetaData | 
MetaDataManagerImpl.loadAnnotationsForClass(Class cls,
                       ClassLoaderResolver clr,
                       boolean register,
                       boolean populate)
Method to load the annotations for the specified class and return the FileMetaData containing
 the class. 
 | 
protected Class | 
AbstractClassMetaData.loadClass(ClassLoaderResolver clr,
         ClassLoader primary)
Load the persistent interface/class 
 | 
Collection<FileMetaData> | 
MetaDataManager.loadFiles(String[] metadataFiles,
         ClassLoaderResolver clr)
Method to load the metadata from the specified files. 
 | 
Collection<FileMetaData> | 
MetaDataManagerImpl.loadFiles(String[] metadataFiles,
         ClassLoaderResolver clr)  | 
protected abstract AbstractClassMetaData | 
MetaDataManagerImpl.loadMetaDataForClass(Class c,
                    ClassLoaderResolver clr)
Load the metadata for the specified class (if available). 
 | 
static PersistenceFileMetaData[] | 
MetaDataUtils.parsePersistenceFiles(PluginManager pluginMgr,
                     String persistenceFilename,
                     boolean validate,
                     ClassLoaderResolver clr)
Method to parse the available "persistence.xml" files returning the metadata for all found. 
 | 
void | 
ArrayMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Method to populate any defaults, and check the validity of the MetaData. 
 | 
void | 
AbstractElementMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Populate the metadata. 
 | 
void | 
ImplementsMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Method to populate the details of the implements. 
 | 
void | 
MapMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Method to populate any defaults, and check the validity of the MetaData. 
 | 
void | 
ValueMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Populate the MetaData. 
 | 
void | 
ElementMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Populate the MetaData. 
 | 
void | 
KeyMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Populate the MetaData. 
 | 
void | 
CollectionMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Method to populate any defaults, and check the validity of the MetaData. 
 | 
void | 
EmbeddedMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary)
Method to populate the embedded MetaData. 
 | 
void | 
ClassMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary,
        MetaDataManager mgr)
Method to provide the details of the class being represented by this MetaData. 
 | 
void | 
InterfaceMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary,
        MetaDataManager mgr)
Method to provide the details of the class being represented by this
 MetaData. 
 | 
abstract void | 
AbstractClassMetaData.populate(ClassLoaderResolver clr,
        ClassLoader primary,
        MetaDataManager mmgr)
Method to provide the details of the class being represented by this MetaData. 
 | 
void | 
AbstractMemberMetaData.populate(ClassLoaderResolver clr,
        Field field,
        Method method,
        ClassLoader primary,
        MetaDataManager mmgr)
Method to provide the details of the field being represented by this MetaData hence populating
 certain parts of the MetaData. 
 | 
protected boolean | 
MetaDataManagerImpl.populateAbstractClassMetaData(AbstractClassMetaData cmd,
                             ClassLoaderResolver clr,
                             ClassLoader loader)
Convenience method to populate the MetaData for the specified class/interface. 
 | 
protected void | 
MetaDataManagerImpl.populateFileMetaData(FileMetaData filemd,
                    ClassLoaderResolver clr,
                    ClassLoader primary)
Convenience method to populate all classes/interfaces in a Meta-Data file. 
 | 
protected void | 
ClassMetaData.populateMemberMetaData(ClassLoaderResolver clr,
                      Class cls,
                      boolean pkMembers,
                      ClassLoader primary)
Populate MetaData for all members. 
 | 
protected void | 
InterfaceMetaData.populatePropertyMetaData(ClassLoaderResolver clr,
                        Class cls,
                        boolean pkFields,
                        ClassLoader primary)
Populate PropertyMetaData. 
 | 
protected void | 
MetaDataManagerImpl.postProcessClassMetaData(AbstractClassMetaData cmd,
                        ClassLoaderResolver clr)
Method that will perform any necessary post-processing on metadata. 
 | 
void | 
MetaDataManager.registerFile(String fileURLString,
            FileMetaData filemd,
            ClassLoaderResolver clr)
Method to take the FileMetaData and register the relevant parts of it with the assorted caches provided. 
 | 
abstract void | 
MetaDataManagerImpl.registerFile(String fileURLString,
            FileMetaData filemd,
            ClassLoaderResolver clr)  | 
void | 
MetaDataManager.registerImplementationOfAbstractClass(ClassMetaData cmd,
                                     Class implClass,
                                     ClassLoaderResolver clr)
Method to register the metadata for an implementation of a persistent abstract class. 
 | 
void | 
MetaDataManagerImpl.registerImplementationOfAbstractClass(ClassMetaData cmd,
                                     Class implClass,
                                     ClassLoaderResolver clr)  | 
void | 
MetaDataManager.registerPersistentInterface(InterfaceMetaData imd,
                           Class implClass,
                           ClassLoaderResolver clr)
Method to register a persistent interface and its implementation with the MetaData system. 
 | 
void | 
MetaDataManagerImpl.registerPersistentInterface(InterfaceMetaData imd,
                           Class implClass,
                           ClassLoaderResolver clr)  | 
protected void | 
AbstractMemberMetaData.setRelation(ClassLoaderResolver clr)
Convenience method that sets up the relation type of this field, and the reference to 
 any related field when it is bidirectional. 
 | 
protected void | 
AbstractClassMetaData.validateObjectIdClass(ClassLoaderResolver clr)
Validate the objectid-class of this class. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
AbstractClassMetaData | 
AnnotationManagerImpl.getMetaDataForClass(Class cls,
                   PackageMetaData pmd,
                   ClassLoaderResolver clr)
Accessor for the MetaData for the specified class, read from annotations. 
 | 
AbstractClassMetaData | 
AnnotationManager.getMetaDataForClass(Class cls,
                   PackageMetaData pmd,
                   ClassLoaderResolver clr)
Method to get the ClassMetaData for a class from its annotations. 
 | 
AbstractClassMetaData | 
AbstractAnnotationReader.getMetaDataForClass(Class cls,
                   PackageMetaData pmd,
                   ClassLoaderResolver clr)
Accessor for the ClassMetaData for the specified class from its annotations. 
 | 
AbstractClassMetaData | 
AnnotationReader.getMetaDataForClass(Class cls,
                   PackageMetaData pmd,
                   ClassLoaderResolver clr)
Method to get the ClassMetaData for a class from its annotations. 
 | 
void | 
ClassAnnotationHandler.processClassAnnotation(AnnotationObject annotation,
                      AbstractClassMetaData cmd,
                      ClassLoaderResolver clr)
Method to process a class level annotation. 
 | 
protected abstract AbstractClassMetaData | 
AbstractAnnotationReader.processClassAnnotations(PackageMetaData pmd,
                       Class cls,
                       AnnotationObject[] annotations,
                       ClassLoaderResolver clr)
Method to process the "class" level annotations and create the outline ClassMetaData object. 
 | 
void | 
ValidationNotNullAnnotationHandler.processMemberAnnotation(AnnotationObject annotation,
                       AbstractMemberMetaData mmd,
                       ClassLoaderResolver clr)  | 
void | 
ValidationSizeAnnotationHandler.processMemberAnnotation(AnnotationObject annotation,
                       AbstractMemberMetaData mmd,
                       ClassLoaderResolver clr)  | 
void | 
MemberAnnotationHandler.processMemberAnnotation(AnnotationObject annotation,
                       AbstractMemberMetaData mmd,
                       ClassLoaderResolver clr)
Method to process a member (field/property) level annotation. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static PluginRegistry | 
PluginRegistryFactory.newPluginRegistry(String registryClassName,
                 String registryBundleCheck,
                 boolean allowUserBundles,
                 ClassLoaderResolver clr)
Instantiates a PluginRegistry. 
 | 
| Constructor and Description | 
|---|
NonManagedPluginRegistry(ClassLoaderResolver clr,
                        String bundleCheckType,
                        boolean allowUserBundles)
Constructor. 
 | 
OSGiPluginRegistry(ClassLoaderResolver clr)
Constructor 
 | 
PluginManager(String registryClassName,
             ClassLoaderResolver clr,
             Properties props)
Constructor. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static List | 
QueryUtils.orderCandidates(List candidates,
               Class type,
               String ordering,
               ExecutionContext ec,
               ClassLoaderResolver clr)
Convenience method to in-memory order the candidates, using the ordering supplied. 
 | 
static List | 
QueryUtils.orderCandidates(List candidates,
               Class type,
               String ordering,
               ExecutionContext ec,
               ClassLoaderResolver clr,
               String queryLanguage)
Convenience method to in-memory order the candidates, using the ordering supplied. 
 | 
static List | 
QueryUtils.orderCandidates(List candidates,
               Expression[] ordering,
               Map state,
               String candidateAlias,
               ExecutionContext ec,
               ClassLoaderResolver clr,
               Map parameterValues,
               Imports imports,
               String queryLanguage)
Convenience method to order the input List of objects to the ordering defined by the compilation. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected ClassLoaderResolver | 
JavaQueryCompiler.clr  | 
protected ClassLoaderResolver | 
AbstractSymbolResolver.clr  | 
| Modifier and Type | Field and Description | 
|---|---|
protected ClassLoaderResolver | 
JavaQueryInMemoryEvaluator.clr  | 
| Constructor and Description | 
|---|
InMemoryExpressionEvaluator(ExecutionContext ec,
                           Map params,
                           Map<String,Object> state,
                           Imports imports,
                           ClassLoaderResolver clr,
                           String candidateAlias,
                           String queryLang)
Constructor for an in-memory evaluator. 
 | 
JavaQueryInMemoryEvaluator(String language,
                          Query query,
                          QueryCompilation compilation,
                          Map parameterValues,
                          ClassLoaderResolver clr,
                          Collection candidates)
Constructor for the evaluator of a query in the specified language. 
 | 
JDOQLInMemoryEvaluator(Query query,
                      Collection candidates,
                      QueryCompilation compilation,
                      Map parameterValues,
                      ClassLoaderResolver clr)
Constructor. 
 | 
JPQLInMemoryEvaluator(Query query,
                     Collection candidates,
                     QueryCompilation compilation,
                     Map parameterValues,
                     ClassLoaderResolver clr)
Constructor. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
RelationshipManagerImpl.checkManyToManyBidirectionalRelation(AbstractMemberMetaData mmd,
                                    ClassLoaderResolver clr,
                                    ExecutionContext ec,
                                    List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to check consistency of the passed field as M-N. 
 | 
protected void | 
RelationshipManagerImpl.checkManyToOneBidirectionalRelation(AbstractMemberMetaData mmd,
                                   ClassLoaderResolver clr,
                                   ExecutionContext ec,
                                   List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to check the consistency of the passed field as N-1. 
 | 
protected void | 
RelationshipManagerImpl.checkOneToManyBidirectionalRelation(AbstractMemberMetaData mmd,
                                   ClassLoaderResolver clr,
                                   ExecutionContext ec,
                                   List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to check the consistency of the passed field as 1-N. 
 | 
protected void | 
RelationshipManagerImpl.checkOneToOneBidirectionalRelation(AbstractMemberMetaData mmd,
                                  ClassLoaderResolver clr,
                                  ExecutionContext ec,
                                  List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to check the consistency of the passed field as 1-1. 
 | 
protected void | 
RelationshipManagerImpl.processManyToManyBidirectionalRelation(AbstractMemberMetaData mmd,
                                      ClassLoaderResolver clr,
                                      ExecutionContext ec,
                                      List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to process all M-N bidirectional fields. 
 | 
protected void | 
RelationshipManagerImpl.processManyToOneBidirectionalRelation(AbstractMemberMetaData mmd,
                                     ClassLoaderResolver clr,
                                     ExecutionContext ec,
                                     List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to process all N-1 bidirectional fields. 
 | 
protected void | 
RelationshipManagerImpl.processOneToManyBidirectionalRelation(AbstractMemberMetaData mmd,
                                     ClassLoaderResolver clr,
                                     ExecutionContext ec,
                                     List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to process all 1-N bidirectional fields. 
 | 
protected void | 
RelationshipManagerImpl.processOneToOneBidirectionalRelation(AbstractMemberMetaData mmd,
                                    ClassLoaderResolver clr,
                                    ExecutionContext ec,
                                    List<org.datanucleus.state.RelationshipManagerImpl.RelationChange> changes)
Method to process all 1-1 bidir fields. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Store | 
BackedSCOStoreManager.getBackingStoreForField(ClassLoaderResolver clr,
                       AbstractMemberMetaData mmd,
                       Class type)
Accessor for the backing store for the specified field/property. 
 | 
String | 
StoreManager.getClassNameForObjectID(Object id,
                       ClassLoaderResolver clr,
                       ExecutionContext ec)
Returns the class corresponding to the given object identity. 
 | 
String | 
AbstractStoreManager.getClassNameForObjectID(Object id,
                       ClassLoaderResolver clr,
                       ExecutionContext ec)  | 
Collection<String> | 
StoreManager.getSubClassesForClass(String className,
                     boolean includeDescendents,
                     ClassLoaderResolver clr)
Utility to return the names of the classes that are known subclasses of the provided
 class. 
 | 
Collection<String> | 
AbstractStoreManager.getSubClassesForClass(String className,
                     boolean includeDescendents,
                     ClassLoaderResolver clr)  | 
void | 
StoreManager.manageClasses(ClassLoaderResolver clr,
             String... classNames)
Manage the specified classes. 
 | 
void | 
AbstractStoreManager.manageClasses(ClassLoaderResolver clr,
             String... classNames)  | 
String | 
StoreManager.manageClassForIdentity(Object id,
                      ClassLoaderResolver clr)
Convenience method to ensure that the class defined by the passed OID/SingleFIeldIdentity is 
 managed by the store. 
 | 
String | 
AbstractStoreManager.manageClassForIdentity(Object id,
                      ClassLoaderResolver clr)  | 
protected StoreData | 
AbstractStoreManager.newStoreData(ClassMetaData cmd,
            ClassLoaderResolver clr)
Instantiate a StoreData instance using the provided ClassMetaData and ClassLoaderResolver. 
 | 
void | 
StoreManager.unmanageAllClasses(ClassLoaderResolver clr)
Remove all classes from the persistence model for the datastore. 
 | 
void | 
AbstractStoreManager.unmanageAllClasses(ClassLoaderResolver clr)  | 
void | 
StoreManager.unmanageClass(ClassLoaderResolver clr,
             String className,
             boolean removeFromDatastore)
Method to remove knowledge of the specified class from this StoreManager. 
 | 
void | 
AbstractStoreManager.unmanageClass(ClassLoaderResolver clr,
             String className,
             boolean removeFromDatastore)  | 
| Constructor and Description | 
|---|
AbstractStoreManager(String key,
                    ClassLoaderResolver clr,
                    PersistenceNucleusContext nucleusContext,
                    Map<String,Object> props)
Constructor for a new StoreManager. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected ClassLoaderResolver | 
MetaDataAutoStarter.clr  | 
| Constructor and Description | 
|---|
ClassesAutoStarter(StoreManager storeMgr,
                  ClassLoaderResolver clr)
Constructor, taking the names of the classes to use. 
 | 
MetaDataAutoStarter(StoreManager storeMgr,
                   ClassLoaderResolver clr)
Constructor, taking the names of the metadata to use. 
 | 
XMLAutoStarter(StoreManager storeMgr,
              ClassLoaderResolver clr)
Constructor, taking the XML file URL. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
String | 
FederatedStoreManager.getClassNameForObjectID(Object id,
                       ClassLoaderResolver clr,
                       ExecutionContext ec)  | 
StoreManager | 
FederatedStoreManager.getStoreManagerForClass(String className,
                       ClassLoaderResolver clr)
Accessor for the StoreManager to use for the specified class. 
 | 
Collection<String> | 
FederatedStoreManager.getSubClassesForClass(String className,
                     boolean includeDescendents,
                     ClassLoaderResolver clr)  | 
void | 
FederatedStoreManager.manageClasses(ClassLoaderResolver clr,
             String... classNames)  | 
String | 
FederatedStoreManager.manageClassForIdentity(Object id,
                      ClassLoaderResolver clr)  | 
void | 
FederatedStoreManager.unmanageAllClasses(ClassLoaderResolver clr)  | 
void | 
FederatedStoreManager.unmanageClass(ClassLoaderResolver clr,
             String className,
             boolean removeFromDatastore)  | 
| Constructor and Description | 
|---|
FederatedStoreManager(ClassLoaderResolver clr,
                     PersistenceNucleusContext nucleusContext)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected ClassLoaderResolver | 
Query.clr  | 
| Modifier and Type | Field and Description | 
|---|---|
protected ClassLoaderResolver | 
AbstractNamingFactory.clr  | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
CompleteClassTable.processEmbeddedMember(List<AbstractMemberMetaData> mmds,
                     ClassLoaderResolver clr,
                     EmbeddedMetaData embmd,
                     boolean ownerNested)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected ClassLoaderResolver | 
TypeManagerImpl.clr  | 
| Modifier and Type | Method and Description | 
|---|---|
protected ClassLoaderResolver | 
TypeManagerImpl.getClassLoaderResolver()  | 
| Modifier and Type | Method and Description | 
|---|---|
static Comparator | 
SCOUtils.getComparator(AbstractMemberMetaData mmd,
             ClassLoaderResolver clr)
Convenience method for creating a Comparator using extension metadata tags for the specified field. 
 | 
boolean | 
ContainerHandler.isDefaultFetchGroup(ClassLoaderResolver clr,
                   TypeManager typeMgr,
                   AbstractMemberMetaData mmd)  | 
void | 
ContainerHandler.populateMetaData(ClassLoaderResolver clr,
                ClassLoader primary,
                AbstractMemberMetaData mmd)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ClassStringConverter.setClassLoaderResolver(ClassLoaderResolver clr)  | 
| Modifier and Type | Method and Description | 
|---|---|
protected Class | 
WebSphereTransactionManagerLocator.getFactoryClass(ClassLoaderResolver clr)
Method to return the factory class for this locator 
 | 
protected Class | 
JOnASTransactionManagerLocator.getFactoryClass(ClassLoaderResolver clr)
Accessor for the factory class to use for this locator. 
 | 
protected Class | 
JOTMTransactionManagerLocator.getFactoryClass(ClassLoaderResolver clr)
Accessor for the factory class to use for this locator. 
 | 
protected abstract Class | 
FactoryBasedTransactionManagerLocator.getFactoryClass(ClassLoaderResolver clr)
Accessor for the factory class to use for this locator. 
 | 
protected Class | 
BTMTransactionManagerLocator.getFactoryClass(ClassLoaderResolver clr)
Accessor for the factory class to use for this locator. 
 | 
TransactionManager | 
TransactionManagerLocator.getTransactionManager(ClassLoaderResolver clr)
Method to return the TransactionManager. 
 | 
TransactionManager | 
AtomikosTransactionManagerLocator.getTransactionManager(ClassLoaderResolver clr)  | 
TransactionManager | 
TransactionManagerFinder.getTransactionManager(ClassLoaderResolver clr)
Accessor for the accessible JTA transaction manager. 
 | 
TransactionManager | 
JNDIBasedTransactionManagerLocator.getTransactionManager(ClassLoaderResolver clr)
Method to return the TransactionManager looking it up using JNDI. 
 | 
TransactionManager | 
FactoryBasedTransactionManagerLocator.getTransactionManager(ClassLoaderResolver clr)
Method to return the TransactionManager. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static void | 
ClassUtils.assertClassForJarExistsInClasspath(ClassLoaderResolver clr,
                                  String className,
                                  String jarName)
Convenience method to throw a NucleusUserException if the specified class is not loadable 
 from the ClassLoaderResolver. 
 | 
static boolean | 
ClassUtils.classesAreDescendents(ClassLoaderResolver clr,
                     String class_name_1,
                     String class_name_2)
Method to check if 2 classes are direct descendents. 
 | 
static String | 
ClassUtils.getClassNameForFileName(String fileName,
                       ClassLoaderResolver clr)
Convenience method to try to find the class name stored in the specified file. 
 | 
static Object | 
TypeConversionHelper.getEnumForStoredValue(AbstractMemberMetaData mmd,
                     FieldRole role,
                     Object value,
                     ClassLoaderResolver clr)  | 
static JdbcType | 
TypeConversionHelper.getJdbcTypeForEnum(AbstractMemberMetaData mmd,
                  FieldRole role,
                  ClassLoaderResolver clr)  | 
static int | 
ClassUtils.getModifiersForFieldOfClass(ClassLoaderResolver clr,
                           String className,
                           String fieldName)
Convenience accessor for the modifiers of a field in a class. 
 | 
Class | 
Imports.resolveClassDeclaration(String classDecl,
                       ClassLoaderResolver clr,
                       ClassLoader primaryClassLoader)
Utility to resolve a class declaration. 
 | 
String | 
MacroString.substituteMacros(MacroString.MacroHandler mh,
                ClassLoaderResolver clr)
Utility to substitute macros using the supplier handler. 
 | 
static boolean | 
ClassUtils.typesAreCompatible(Class cls1,
                  String clsName2,
                  ClassLoaderResolver clr)
Convenience method to return if two types are compatible. 
 | 
Copyright © 2018. All rights reserved.