MetaDataManagerImpl (DataNucleus Core 5.1.13-SNAPSHOT API)

java.lang.Object
- org.datanucleus.metadata.MetaDataManagerImpl

All Implemented Interfaces:

Serializable, MetaDataManager
```
public abstract class MetaDataManagerImpl
extends Object
implements Serializable, MetaDataManager
```
Manager of metadata information in DataNucleus having scope of an NucleusContext. Each PMF/EMF will effectively have a single MetaDataManager handling all XML/Annotations metadata.
Metadata can be loaded into the MetaDataManager in two ways
- Load when required. When the persistence process needs a class it will ask for metadata, and we can go and find its metadata from XML/annotations.
- Load explicitly via API calls. This happens when handling persistence for a persistence-unit for example since we know what classes/mapping is involved. It is also the case with the enhancer where we know what classes to enhance so we load the metadata first
Acts as a registry of metadata so that metadata files don't need to be parsed multiple times. MetaData is stored as a FileMetaData, which contains PackageMetaData, which contains ClassMetaData, and so on. This maps exactly to the users model of their metadata. The users access point is getMetaDataForClass() which will check the known classes without metadata, then check the existing registered metdata, then check the valid locations for metdata files. This way, the metadata is managed from this single point.

Maintains a list of all classes that have been checked for MetaData and don't have any available. This avoids the needs to look up MetaData multiple times finding the same result. Currently this list is for all ClassMetaData objects keyed by the class name.

Users can register interest in knowing when metadata for classes are loaded by registering a listener using the addListener method. This will then notify the listener when metadata for any class is initialised. This provides the opportunity to reject the metadata where particular features are not supported. For example a StoreManager could register a listener where it doesn't support datastore identity and throw an InvalidMetaDataException. This would then filter back out to the user for the operation they invoked

MetaDataManager is intended to be thread-safe. All maps are ConcurrentHashMap to provide basic multithread usage. In addition all mutating methods make use of an update "lock" so that only one thread can update the metadata definition at any time.
See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`allowAnnotations` Whether we allow annotations metadata.
`protected boolean`	`allowMetaDataLoad` Flag defining if we allow metadata load currently.
`protected boolean`	`allowORM` Whether we allow ORM XML metadata.
`protected boolean`	`allowXML` Whether we allow XML metadata.
`protected AnnotationManager`	`annotationManager` Manager for annotations.
`protected Collection<String>`	`classesWithoutPersistenceInfo` Cache of class names that are known to not have MetaData/annotations.
`protected MultiMap`	`classMetaDataByAppIdClassName` Map of class metadata, keyed by the application-id object-id class name (not SingleField).
`protected Map<String,AbstractClassMetaData>`	`classMetaDataByClass` Map of ClassMetaData, keyed by the class name.
`protected Map<String,AbstractClassMetaData>`	`classMetaDataByDiscriminatorName` Map of ClassMetaData, keyed by the class discriminator name.
`protected Map<String,AbstractClassMetaData>`	`classMetaDataByEntityName` Map of ClassMetaData, keyed by the JPA "entity name".
`protected Map<String,Set<String>>`	`concreteSubclassNamesByClassName` Cache of names of concrete subclass for a class name.
`protected boolean`	`defaultNullable` Flag defining the default nullability for fields.
`protected Map<String,Set<String>>`	`directSubclassesByClass` Cache subclass information as that is expensive to compute, keyed by class name
`protected Map<String,org.datanucleus.metadata.MetaDataManagerImpl.DiscriminatorLookup>`	`discriminatorLookupByRootClassName`
`protected Map<String,FetchPlanMetaData>`	`fetchPlanMetaDataByName` Map of FetchPlanMetaData, keyed by the fetch plan name.
`protected Map<String,FileMetaData>`	`fileMetaDataByURLString` Map of FileMetaData for the parsed files, keyed by the URL string.
`protected Set<MetaDataListener>`	`listeners` Listeners for metadata load.
`protected NucleusContext`	`nucleusContext` The NucleusContext that this metadata manager is operating in.
`protected Map<String,QueryMetaData>`	`queryMetaDataByName` Map of QueryMetaData, keyed by the (class name + query name).
`protected Map<String,QueryResultMetaData>`	`queryResultMetaDataByName` Map of QueryResultMetaData keyed by the name.
`protected Map<String,SequenceMetaData>`	`sequenceMetaDataByPackageSequence` Map of SequenceMetaData, keyed by the package name and sequence name.
`protected Map<String,StoredProcQueryMetaData>`	`storedProcQueryMetaDataByName` Map of StoredProcQueryMetaData, keyed by the (class name + query name).
`protected boolean`	`supportXMLNamespaces` Flag whether we should be (XML) namespace aware when parsing.
`protected Map<String,TableGeneratorMetaData>`	`tableGeneratorMetaDataByPackageSequence` Map of TableGeneratorMetaData, keyed by the package name and generator name.
`protected Lock`	`updateLock`
`protected Map<String,AbstractClassMetaData>`	`usableClassMetaDataByClass`
`protected int`	`userMetaDataNumber` Number of user metadata items.
`protected ArrayList<FileMetaData>`	`utilisedFileMetaData` Temporary list of the FileMetaData objects utilised in this call for metadata.
`protected boolean`	`validateXML` Flag whether we should validate the (XML) metadata files when parsing.

Constructor Summary

Constructors
Constructor and Description

MetaDataManagerImpl(NucleusContext ctx)
Constructor, specifying the context used.

Constructors
Constructor and Description
`MetaDataManagerImpl(NucleusContext ctx)` Constructor, specifying the context used.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abstractClassMetaDataInitialised(AbstractClassMetaData cmd)` Method called (by AbstractClassMetaData.initialise()) when a class has its metadata initialised.
`void`	`addAnnotationsDataToClass(Class c, AbstractClassMetaData cmd, ClassLoaderResolver clr)` Load up and add any annotations mapping info for the specified class to the stored ClassMetaData.
`void`	`addORMDataToClass(Class c, ClassLoaderResolver clr)` Load up and add any O/R mapping info for the specified class to the stored ClassMetaData (if supported).
`void`	`close()`
`void`	`deregisterListener(MetaDataListener listener)` Method to deregister a listener from being notified when metadata for a class/interface is initialised.
`AnnotationManager`	`getAnnotationManager()`
`ApiAdapter`	`getApiAdapter()`
`String[]`	`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).
`Collection<String>`	`getClassesWithMetaData()` Accessor for the names of the classes with MetaData currently registered with this manager.
`ClassMetaData`	`getClassMetaDataForImplementationOfPersistentInterface(String interfaceName)` Accessor for the metadata for the implementation of the specified "persistent-interface".
`Collection<AbstractClassMetaData>`	`getClassMetaDataWithApplicationId(String objectIdClassName)` Accessor for the metadata for the class(es) with the specified object-id class name as PK.
`String`	`getClassNameForDiscriminatorValueWithRoot(AbstractClassMetaData rootCmd, String discrimValue)`
`String`	`getClassNameFromDiscriminatorValue(String discrimValue, DiscriminatorMetaData dismd)`
`String[]`	`getConcreteSubclassesForClass(String className)` Accessor for the names of all concrete subclasses of the provided class.
`String`	`getDiscriminatorValueForClass(AbstractClassMetaData cmd, String discrimValue)`
`String`	`getEnhancedMethodNamePrefix()`
`FileMetaData[]`	`getFileMetaData()` Accessor for all FileMetaData currently managed here.
`String`	`getImplementationNameForPersistentInterface(String interfaceName)` Accessor for the implementation name for the specified "persistent-interface".
`AbstractClassMetaData`	`getMetaDataForClass(Class c, ClassLoaderResolver clr)` Main accessor for the MetaData for a class.
`AbstractClassMetaData`	`getMetaDataForClass(String className, ClassLoaderResolver clr)` Accessor for the MetaData for a class given the name and a loader.
`AbstractClassMetaData`	`getMetaDataForClassInternal(Class c, ClassLoaderResolver clr)` Internal convenience method for accessing the MetaData for a class.
`AbstractClassMetaData`	`getMetaDataForDiscriminator(String discriminator)` Accessor for the MetaData for a class given the "discriminator".
`AbstractClassMetaData`	`getMetaDataForEntityName(String entityName)` Accessor for the MetaData for a class given the "entity-name".
`FetchPlanMetaData`	`getMetaDataForFetchPlan(String name)` Accessor for the MetaData for a named fetch plan.
`ClassMetaData`	`getMetaDataForImplementationOfReference(Class referenceClass, Object implValue, ClassLoaderResolver clr)` Accessor for the MetaData for an implementation of a reference type.
`InterfaceMetaData`	`getMetaDataForInterface(Class c, ClassLoaderResolver clr)` Accessor for the MetaData for an interface.
`QueryMetaData`	`getMetaDataForQuery(Class cls, ClassLoaderResolver clr, String queryName)` Accessor for the MetaData for a named query for a class.
`QueryResultMetaData`	`getMetaDataForQueryResult(String name)` Accessor for the MetaData for a QueryResult.
`SequenceMetaData`	`getMetaDataForSequence(ClassLoaderResolver clr, String seqName)` Accessor for the MetaData for a Sequence in a package.
`StoredProcQueryMetaData`	`getMetaDataForStoredProcQuery(Class cls, ClassLoaderResolver clr, String queryName)` Accessor for the MetaData for a named stored procedure query for a class.
`TableGeneratorMetaData`	`getMetaDataForTableGenerator(ClassLoaderResolver clr, String genName)` Accessor for the MetaData for a TableGenerator in a package.
`Set<String>`	`getNamedQueryNames()` Convenience method to access the names of named queries that are registered with this manager.
`NucleusContext`	`getNucleusContext()`
`List<AbstractClassMetaData>`	`getReferencedClasses(String[] classNames, ClassLoaderResolver clr)` Convenience method to get the MetaData for all referenced classes with the passed set of classes as root.
`protected List<AbstractClassMetaData>`	`getReferencedClassMetaData(AbstractClassMetaData cmd, ClassLoaderResolver clr)` Utility to return all ClassMetaData that is referenced from the supplier class.
`protected MetaDataScanner`	`getScanner(ClassLoaderResolver clr)` Accessor for any scanner for metadata classes (optional).
`String[]`	`getSubclassesForClass(String className, boolean includeDescendents)` Accessor for the subclasses of a particular class
`boolean`	`hasMetaDataForClass(String className)` Convenience method to check if we have metadata present for the specified class.
`protected void`	`initialiseAbstractClassMetaData(AbstractClassMetaData cmd, ClassLoaderResolver clr)` Convenience method to initialise the MetaData for the specified class/interface.
`protected void`	`initialiseClassMetaData(ClassMetaData cmd, Class cls, ClassLoaderResolver clr)` Utility to initialise the MetaData for a class, using the specified class.
`protected void`	`initialiseFileMetaData(FileMetaData filemd, ClassLoaderResolver clr, ClassLoader primary)` Initialise all classes/interfaces in a Meta-Data file.
`protected void`	`initialiseFileMetaDataForUse(Collection<FileMetaData> fileMetaData, ClassLoaderResolver clr)` Method to initialise the provided FileMetaData, ready for use.
`protected void`	`initialiseInterfaceMetaData(InterfaceMetaData imd, ClassLoaderResolver clr, ClassLoader primary)` Utility to initialise the MetaData for a interface, using the specified class.
`boolean`	`isClassPersistable(String className)` Convenience method to return if the specified class is a known persistable class.
`protected boolean`	`isClassWithoutPersistenceInfo(String className)` Accessor for whether a class doesn't have MetaData or annotations.
`boolean`	`isDefaultNullable()` Acessor for the default nullability of fields.
`boolean`	`isEnhancerField(String fieldName)`
`boolean`	`isEnhancing()` Accessor for whether we are managing the enhancement process.
`boolean`	`isFieldTypePersistable(Class type)` Utility to return if this field is persistable.
`boolean`	`isPersistentDefinitionImplementation(String implName)` Convenience method to return if the passed class name is an implementation of a "persistent definition".
`boolean`	`isPersistentInterface(String name)` Convenience method to return if the passed class name is a "persistent-interface".
`boolean`	`isPersistentInterfaceImplementation(String interfaceName, String implName)` Convenience method to return if the passed class name is an implementation of the passed "persistent-interface".
`protected FileMetaData`	`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.
`FileMetaData[]`	`loadClasses(String[] classNames, ClassLoader loader)` Method to load up all metadata for the specified classes.
`Collection<FileMetaData>`	`loadFiles(String[] metadataFiles, ClassLoaderResolver clr)` Method to load the metadata from the specified files.
`FileMetaData[]`	`loadJar(String jarFileName, ClassLoader loader)` Initialisation method to load the metadata provided by the specified jar.
`FileMetaData[]`	`loadMetadataFiles(String[] metadataFiles, ClassLoader loader)` Method to load up all metadata defined by the specified metadata files.
`protected abstract AbstractClassMetaData`	`loadMetaDataForClass(Class c, ClassLoaderResolver clr)` Load the metadata for the specified class (if available).
`FileMetaData[]`	`loadPersistenceUnit(PersistenceUnitMetaData pumd, ClassLoader loader)` Initialisation method to to load all class metadata defined by the "persistence-unit".
`void`	`loadUserMetaData(FileMetaData fileMetaData, ClassLoader loader)` Method to load user-provided (dynamic) metadata (from the JDO MetaData API).
`protected abstract FileMetaData`	`parseFile(URL fileURL)` Utility to parse an XML metadata file.
`protected boolean`	`populateAbstractClassMetaData(AbstractClassMetaData cmd, ClassLoaderResolver clr, ClassLoader loader)` Convenience method to populate the MetaData for the specified class/interface.
`protected void`	`populateFileMetaData(FileMetaData filemd, ClassLoaderResolver clr, ClassLoader primary)` Convenience method to populate all classes/interfaces in a Meta-Data file.
`protected void`	`postProcessClassMetaData(AbstractClassMetaData cmd, ClassLoaderResolver clr)` Method that will perform any necessary post-processing on metadata.
`protected void`	`processListenerLoadingCall()`
`AbstractClassMetaData`	`readMetaDataForClass(String className)` Method to access the (already known) metadata for the specified class.
`AbstractMemberMetaData`	`readMetaDataForMember(String className, String memberName)` Method to access the (already known) metadata for the field/property of the specified class.
`void`	`registerDiscriminatorValueForClass(AbstractClassMetaData cmd, String discrimValue)`
`protected void`	`registerFetchPlansForFile(FileMetaData filemd)` Convenience method to register all FetchPlans found in the passed file.
`abstract void`	`registerFile(String fileURLString, FileMetaData filemd, ClassLoaderResolver clr)` Method to take the FileMetaData and register the relevant parts of it with the assorted caches provided.
`void`	`registerImplementationOfAbstractClass(ClassMetaData cmd, Class implClass, ClassLoaderResolver clr)` Method to register the metadata for an implementation of a persistent abstract class.
`void`	`registerListener(MetaDataListener listener)` Method to register a listener to be notified when metadata for a class/interface is initialised.
`protected void`	`registerMetaDataForClass(String fullClassName, AbstractClassMetaData cmd)` Internal method called when we want to register the metadata for a class/interface.
`void`	`registerNamedQuery(QueryMetaData qmd)` Convenience method to register a query under a name.
`void`	`registerPersistentInterface(InterfaceMetaData imd, Class implClass, ClassLoaderResolver clr)` Method to register a persistent interface and its implementation with the MetaData system.
`protected void`	`registerQueriesForFile(FileMetaData filemd)` Convenience method to register all queries found in the passed file.
`protected void`	`registerQueryResultMetaDataForFile(FileMetaData filemd)` Convenience method to register all table generators found in the passed file.
`void`	`registerSequencesForFile(FileMetaData filemd)` Convenience method to register all sequences found in the passed file.
`protected void`	`registerStoredProcQueriesForFile(FileMetaData filemd)` Convenience method to register all stored proc queries found in the passed file.
`void`	`registerTableGeneratorsForFile(FileMetaData filemd)` Convenience method to register all table generators found in the passed file.
`void`	`setAllowAnnotations(boolean allow)`
`void`	`setAllowMetaDataLoad(boolean allow)`
`void`	`setAllowXML(boolean allow)`
`void`	`setDefaultNullable(boolean defaultNullable)`
`void`	`setValidate(boolean validate)` Mutator for whether to validate the MetaData files for XML compliance.
`void`	`setXmlNamespaceAware(boolean aware)` Mutator for whether to support XML namespaces.
`boolean`	`supportsORM()` Accessor for whether the MetaData manager supports ORM concepts and metadata.
`void`	`unloadMetaDataForClass(String className)` Convenience method to allow the unloading of metadata, for example where the user wants to reload a class definition and that class maybe has different metadata with the new definition.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - nucleusContext
```
protected final NucleusContext nucleusContext
```
    The NucleusContext that this metadata manager is operating in.
  - annotationManager
```
protected final AnnotationManager annotationManager
```
    Manager for annotations.
  - validateXML
```
protected boolean validateXML
```
    Flag whether we should validate the (XML) metadata files when parsing.
  - supportXMLNamespaces
```
protected boolean supportXMLNamespaces
```
    Flag whether we should be (XML) namespace aware when parsing.
  - allowMetaDataLoad
```
protected boolean allowMetaDataLoad
```
    Flag defining if we allow metadata load currently. If false then we only allow access to currently loaded metadata.
  - allowXML
```
protected boolean allowXML
```
    Whether we allow XML metadata.
  - allowAnnotations
```
protected boolean allowAnnotations
```
    Whether we allow annotations metadata.
  - allowORM
```
protected boolean allowORM
```
    Whether we allow ORM XML metadata.
  - defaultNullable
```
protected boolean defaultNullable
```
    Flag defining the default nullability for fields.
  - updateLock
```
protected Lock updateLock
```
  - classesWithoutPersistenceInfo
```
protected Collection<String> classesWithoutPersistenceInfo
```
    Cache of class names that are known to not have MetaData/annotations.
  - classMetaDataByClass
```
protected Map<String,AbstractClassMetaData> classMetaDataByClass
```
    Map of ClassMetaData, keyed by the class name.
  - usableClassMetaDataByClass
```
protected Map<String,AbstractClassMetaData> usableClassMetaDataByClass
```
  - fileMetaDataByURLString
```
protected Map<String,FileMetaData> fileMetaDataByURLString
```
    Map of FileMetaData for the parsed files, keyed by the URL string.
  - classMetaDataByEntityName
```
protected Map<String,AbstractClassMetaData> classMetaDataByEntityName
```
    Map of ClassMetaData, keyed by the JPA "entity name".
  - classMetaDataByDiscriminatorName
```
protected Map<String,AbstractClassMetaData> classMetaDataByDiscriminatorName
```
    Map of ClassMetaData, keyed by the class discriminator name.
  - directSubclassesByClass
```
protected Map<String,Set<String>> directSubclassesByClass
```
    Cache subclass information as that is expensive to compute, keyed by class name
  - concreteSubclassNamesByClassName
```
protected Map<String,Set<String>> concreteSubclassNamesByClassName
```
    Cache of names of concrete subclass for a class name. Used for fast lookups from ids.
  - queryMetaDataByName
```
protected Map<String,QueryMetaData> queryMetaDataByName
```
    Map of QueryMetaData, keyed by the (class name + query name).
  - storedProcQueryMetaDataByName
```
protected Map<String,StoredProcQueryMetaData> storedProcQueryMetaDataByName
```
    Map of StoredProcQueryMetaData, keyed by the (class name + query name).
  - fetchPlanMetaDataByName
```
protected Map<String,FetchPlanMetaData> fetchPlanMetaDataByName
```
    Map of FetchPlanMetaData, keyed by the fetch plan name.
  - sequenceMetaDataByPackageSequence
```
protected Map<String,SequenceMetaData> sequenceMetaDataByPackageSequence
```
    Map of SequenceMetaData, keyed by the package name and sequence name.
  - tableGeneratorMetaDataByPackageSequence
```
protected Map<String,TableGeneratorMetaData> tableGeneratorMetaDataByPackageSequence
```
    Map of TableGeneratorMetaData, keyed by the package name and generator name.
  - queryResultMetaDataByName
```
protected Map<String,QueryResultMetaData> queryResultMetaDataByName
```
    Map of QueryResultMetaData keyed by the name.
  - classMetaDataByAppIdClassName
```
protected MultiMap classMetaDataByAppIdClassName
```
    Map of class metadata, keyed by the application-id object-id class name (not SingleField).
  - listeners
```
protected Set<MetaDataListener> listeners
```
    Listeners for metadata load.
  - userMetaDataNumber
```
protected int userMetaDataNumber
```
    Number of user metadata items.
  - discriminatorLookupByRootClassName
```
protected Map<String,org.datanucleus.metadata.MetaDataManagerImpl.DiscriminatorLookup> discriminatorLookupByRootClassName
```
  - utilisedFileMetaData
```
protected ArrayList<FileMetaData> utilisedFileMetaData
```
    Temporary list of the FileMetaData objects utilised in this call for metadata.
- Constructor Detail
  - MetaDataManagerImpl
```
public MetaDataManagerImpl(NucleusContext ctx)
```
    Constructor, specifying the context used.
    
    Parameters:
    
    ctx - context that this metadata manager operates in
- Method Detail
  - close
```
public void close()
```
    Specified by:
    
    close in interface MetaDataManager
  - registerListener
```
public void registerListener(MetaDataListener listener)
```
    Description copied from interface: MetaDataManager
    
    Method to register a listener to be notified when metadata for a class/interface is initialised.
    
    Specified by:
    
    registerListener in interface MetaDataManager
    
    Parameters:
    
    listener - The listener
  - deregisterListener
```
public void deregisterListener(MetaDataListener listener)
```
    Description copied from interface: MetaDataManager
    
    Method to deregister a listener from being notified when metadata for a class/interface is initialised.
    
    Specified by:
    
    deregisterListener in interface MetaDataManager
    
    Parameters:
    
    listener - The listener
  - getEnhancedMethodNamePrefix
```
public String getEnhancedMethodNamePrefix()
```
    Specified by:
    
    getEnhancedMethodNamePrefix in interface MetaDataManager
  - isEnhancerField
```
public boolean isEnhancerField(String fieldName)
```
    Specified by:
    
    isEnhancerField in interface MetaDataManager
  - setAllowMetaDataLoad
```
public void setAllowMetaDataLoad(boolean allow)
```
    Specified by:
    
    setAllowMetaDataLoad in interface MetaDataManager
  - setAllowXML
```
public void setAllowXML(boolean allow)
```
    Specified by:
    
    setAllowXML in interface MetaDataManager
  - setDefaultNullable
```
public void setDefaultNullable(boolean defaultNullable)
```
    Specified by:
    
    setDefaultNullable in interface MetaDataManager
  - setAllowAnnotations
```
public void setAllowAnnotations(boolean allow)
```
    Specified by:
    
    setAllowAnnotations in interface MetaDataManager
  - supportsORM
```
public boolean supportsORM()
```
    Description copied from interface: MetaDataManager
    
    Accessor for whether the MetaData manager supports ORM concepts and metadata. With object datastores this will return false.
    
    Specified by:
    
    supportsORM in interface MetaDataManager
    
    Returns:
    
    Whether we support ORM
  - isDefaultNullable
```
public boolean isDefaultNullable()
```
    Description copied from interface: MetaDataManager
    
    Acessor for the default nullability of fields.
    
    Specified by:
    
    isDefaultNullable in interface MetaDataManager
    
    Returns:
    
    true if fields should be null by default and false whether it should be not-null.
  - isEnhancing
```
public boolean isEnhancing()
```
    Description copied from interface: MetaDataManager
    
    Accessor for whether we are managing the enhancement process.
    
    Specified by:
    
    isEnhancing in interface MetaDataManager
    
    Returns:
    
    Whether we are enhancing
  - setValidate
```
public void setValidate(boolean validate)
```
    Description copied from interface: MetaDataManager
    
    Mutator for whether to validate the MetaData files for XML compliance.
    
    Specified by:
    
    setValidate in interface MetaDataManager
    
    Parameters:
    
    validate - Whether to validate
  - setXmlNamespaceAware
```
public void setXmlNamespaceAware(boolean aware)
```
    Description copied from interface: MetaDataManager
    
    Mutator for whether to support XML namespaces.
    
    Specified by:
    
    setXmlNamespaceAware in interface MetaDataManager
    
    Parameters:
    
    aware - Whether to be XML namespace aware
  - getNucleusContext
```
public NucleusContext getNucleusContext()
```
    Specified by:
    
    getNucleusContext in interface MetaDataManager
  - getApiAdapter
```
public ApiAdapter getApiAdapter()
```
    Specified by:
    
    getApiAdapter in interface MetaDataManager
  - getAnnotationManager
```
public AnnotationManager getAnnotationManager()
```
    Specified by:
    
    getAnnotationManager in interface MetaDataManager
  - loadMetadataFiles
```
public FileMetaData[] loadMetadataFiles(String[] metadataFiles,
                                        ClassLoader loader)
```
    Description copied from interface: MetaDataManager
    
    Method to load up all metadata defined by the specified metadata files. Metadata files can be absolute/relative filenames, or can be resources in the CLASSPATH.
    
    Specified by:
    
    loadMetadataFiles in interface MetaDataManager
    
    Parameters:
    
    metadataFiles - The metadata files
    
    loader - ClassLoader to use in loading the metadata (if any)
    
    Returns:
    
    Array of the FileMetaData that is managed
  - loadClasses
```
public FileMetaData[] loadClasses(String[] classNames,
                                  ClassLoader loader)
```
    Description copied from interface: MetaDataManager
    
    Method to load up all metadata for the specified classes.
    
    Specified by:
    
    loadClasses in interface MetaDataManager
    
    Parameters:
    
    classNames - The class names
    
    loader - ClassLoader to use in loading the classes (if any)
    
    Returns:
    
    Array of the FileMetaData that is managed
  - loadJar
```
public FileMetaData[] loadJar(String jarFileName,
                              ClassLoader loader)
```
    Description copied from interface: MetaDataManager
    
    Initialisation method to load the metadata provided by the specified jar.
    
    Specified by:
    
    loadJar in interface MetaDataManager
    
    Parameters:
    
    jarFileName - Name of the jar file
    
    loader - ClassLoader to use in loading of the jar (if any)
    
    Returns:
    
    Array of the FileMetaData that is managed
  - loadPersistenceUnit
```
public FileMetaData[] loadPersistenceUnit(PersistenceUnitMetaData pumd,
                                          ClassLoader loader)
```
    Description copied from interface: MetaDataManager
    
    Initialisation method to to load all class metadata defined by the "persistence-unit".
    
    Specified by:
    
    loadPersistenceUnit in interface MetaDataManager
    
    Parameters:
    
    pumd - The MetaData for this "persistence-unit"
    
    loader - ClassLoader to use in loading of the persistence unit (if any)
    
    Returns:
    
    Array of the FileMetaData that is managed
  - loadUserMetaData
```
public void loadUserMetaData(FileMetaData fileMetaData,
                             ClassLoader loader)
```
    Description copied from interface: MetaDataManager
    
    Method to load user-provided (dynamic) metadata (from the JDO MetaData API).
    
    Specified by:
    
    loadUserMetaData in interface MetaDataManager
    
    Parameters:
    
    fileMetaData - FileMetaData to register/populate/initialise
    
    loader - ClassLoader to use in loading the metadata (if any)
  - loadMetaDataForClass
```
protected abstract AbstractClassMetaData loadMetaDataForClass(Class c,
                                                              ClassLoaderResolver clr)
```
    Load the metadata for the specified class (if available).
    
    Parameters:
    
    c - The class
    
    clr - ClassLoader resolver
    
    Returns:
    
    The metadata for this class (if found)
  - unloadMetaDataForClass
```
public void unloadMetaDataForClass(String className)
```
    Description copied from interface: MetaDataManager
    
    Convenience method to allow the unloading of metadata, for example where the user wants to reload a class definition and that class maybe has different metadata with the new definition.
    
    Specified by:
    
    unloadMetaDataForClass in interface MetaDataManager
    
    Parameters:
    
    className - Name of the class
  - getScanner
```
protected MetaDataScanner getScanner(ClassLoaderResolver clr)
```
    Accessor for any scanner for metadata classes (optional). Looks for the persistence property "datanucleus.metadata.scanner" (if defined)
    
    Parameters:
    
    clr - The classloader resolver
    
    Returns:
    
    scanner instance or null if it doesn't exist or cannot be instantiated
  - initialiseFileMetaDataForUse
```
protected void initialiseFileMetaDataForUse(Collection<FileMetaData> fileMetaData,
                                            ClassLoaderResolver clr)
```
    Method to initialise the provided FileMetaData, ready for use.
    
    Parameters:
    
    fileMetaData - Collection of FileMetaData
    
    clr - ClassLoader resolver
    
    Throws:
    
    NucleusUserException - thrown if an error occurs during the populate/initialise of the supplied metadata.
  - loadFiles
```
public Collection<FileMetaData> loadFiles(String[] metadataFiles,
                                          ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Method to load the metadata from the specified files. Supports absolute/relative file names, or CLASSPATH resources.
    
    Specified by:
    
    loadFiles in interface MetaDataManager
    
    Parameters:
    
    metadataFiles - array of MetaData files
    
    clr - ClassLoader resolver
    
    Returns:
    
    List of FileMetaData
  - isClassPersistable
```
public boolean isClassPersistable(String className)
```
    Description copied from interface: MetaDataManager
    
    Convenience method to return if the specified class is a known persistable class.
    
    Specified by:
    
    isClassPersistable in interface MetaDataManager
    
    Parameters:
    
    className - Name of the class
    
    Returns:
    
    Whether it is persistable
  - getFileMetaData
```
public FileMetaData[] getFileMetaData()
```
    Description copied from interface: MetaDataManager
    
    Accessor for all FileMetaData currently managed here.
    
    Specified by:
    
    getFileMetaData in interface MetaDataManager
    
    Returns:
    
    FileMetaData managed here currently
  - getClassesWithMetaData
```
public Collection<String> getClassesWithMetaData()
```
    Description copied from interface: MetaDataManager
    
    Accessor for the names of the classes with MetaData currently registered with this manager.
    
    Specified by:
    
    getClassesWithMetaData in interface MetaDataManager
    
    Returns:
    
    Names of classes with MetaData
  - hasMetaDataForClass
```
public boolean hasMetaDataForClass(String className)
```
    Description copied from interface: MetaDataManager
    
    Convenience method to check if we have metadata present for the specified class.
    
    Specified by:
    
    hasMetaDataForClass in interface MetaDataManager
    
    Parameters:
    
    className - The name of the class to check
    
    Returns:
    
    Whether the metadata is already registered for this class
  - isClassWithoutPersistenceInfo
```
protected boolean isClassWithoutPersistenceInfo(String className)
```
    Accessor for whether a class doesn't have MetaData or annotations.
    
    Parameters:
    
    className - Name of the class
    
    Returns:
    
    Whether it has no metadata and annotations
  - getClassMetaDataWithApplicationId
```
public Collection<AbstractClassMetaData> getClassMetaDataWithApplicationId(String objectIdClassName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the metadata for the class(es) with the specified object-id class name as PK. This only works for user-provided object-id classes (not SingleFieldIdentity).
    
    Specified by:
    
    getClassMetaDataWithApplicationId in interface MetaDataManager
    
    Parameters:
    
    objectIdClassName - The object-id class name
    
    Returns:
    
    Collection of AbstractClassMetaData for the classes using this PK
  - getMetaDataForClass
```
public AbstractClassMetaData getMetaDataForClass(String className,
                                                 ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a class given the name and a loader. All MetaData returned from this method will be initialised and ready for full use. If the class can't be loaded, null will be returned.
    
    Specified by:
    
    getMetaDataForClass in interface MetaDataManager
    
    Parameters:
    
    className - Name of the class to find MetaData for
    
    clr - ClassLoaderResolver resolver for use in loading the class.
    
    Returns:
    
    The ClassMetaData for this class (or null if not found)
  - getMetaDataForClass
```
public AbstractClassMetaData getMetaDataForClass(Class c,
                                                 ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Main accessor for the MetaData for a class. All MetaData returned from this method will be initialised and ready for full use.
    
    Specified by:
    
    getMetaDataForClass in interface MetaDataManager
    
    Parameters:
    
    c - The class to find MetaData for
    
    clr - the ClassLoaderResolver
    
    Returns:
    
    The ClassMetaData for this class (or null if not found)
  - processListenerLoadingCall
```
protected void processListenerLoadingCall()
```
  - getMetaDataForEntityName
```
public AbstractClassMetaData getMetaDataForEntityName(String entityName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a class given the "entity-name".
    
    Specified by:
    
    getMetaDataForEntityName in interface MetaDataManager
    
    Parameters:
    
    entityName - The entity name to find MetaData for
    
    Returns:
    
    The ClassMetaData for this entity name (or null if not found)
  - getMetaDataForDiscriminator
```
public AbstractClassMetaData getMetaDataForDiscriminator(String discriminator)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a class given the "discriminator".
    
    Specified by:
    
    getMetaDataForDiscriminator in interface MetaDataManager
    
    Parameters:
    
    discriminator - The discriminator name to find MetaData for
    
    Returns:
    
    The ClassMetaData for this discriminator (or null if not found)
  - readMetaDataForClass
```
public AbstractClassMetaData readMetaDataForClass(String className)
```
    Description copied from interface: MetaDataManager
    
    Method to access the (already known) metadata for the specified class. If the class is not yet known about it returns null.
    
    Specified by:
    
    readMetaDataForClass in interface MetaDataManager
    
    Parameters:
    
    className - Name of the class
    
    Returns:
    
    MetaData for the class
  - readMetaDataForMember
```
public AbstractMemberMetaData readMetaDataForMember(String className,
                                                    String memberName)
```
    Description copied from interface: MetaDataManager
    
    Method to access the (already known) metadata for the field/property of the specified class. If the class (or this field/property) is not yet known about it returns null.
    
    Specified by:
    
    readMetaDataForMember in interface MetaDataManager
    
    Parameters:
    
    className - Name of the class
    
    memberName - Name of the field/property
    
    Returns:
    
    MetaData for the field/property
  - getMetaDataForClassInternal
```
public AbstractClassMetaData getMetaDataForClassInternal(Class c,
                                                         ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Internal convenience method for accessing the MetaData for a class. MetaData returned by this method may be uninitialised so should only really be used in initialisation processes. To be implemented by the implementing class.
    
    Specified by:
    
    getMetaDataForClassInternal in interface MetaDataManager
    
    Parameters:
    
    c - The class to find MetaData for
    
    clr - ClassLoader resolver
    
    Returns:
    
    The ClassMetaData for this class (or null if not found)
  - registerMetaDataForClass
```
protected void registerMetaDataForClass(String fullClassName,
                                        AbstractClassMetaData cmd)
```
    Internal method called when we want to register the metadata for a class/interface.
    
    Parameters:
    
    fullClassName - Name of the class
    
    cmd - The metadata
  - getClassesImplementingInterface
```
public String[] getClassesImplementingInterface(String interfaceName,
                                                ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the list of names of classes that are declared to implement the specified interface (using <implements> in the MetaData). This will include subclasses of declared classes. Ignore abstract classes. The array of implementation class names will have the initial implementations first followed by the subclass implementations etc. So for example if we look for all implementations of I and A implements I and B extends A, then it will return [A, B] in that order.
    
    Specified by:
    
    getClassesImplementingInterface in interface MetaDataManager
    
    Parameters:
    
    interfaceName - Name of the interface
    
    clr - The ClassLoaderResolver
    
    Returns:
    
    The names of the classes declared as implementing that interface. return null if no classes
  - addORMDataToClass
```
public void addORMDataToClass(Class c,
                              ClassLoaderResolver clr)
```
    Load up and add any O/R mapping info for the specified class to the stored ClassMetaData (if supported). This implementation does nothing so if ORM files are supported then this should be overridden by subclasses. Is package-access so that is only accessible by MetaData classes.
    
    Specified by:
    
    addORMDataToClass in interface MetaDataManager
    
    Parameters:
    
    c - The class
    
    clr - ClassLoader resolver
  - addAnnotationsDataToClass
```
public void addAnnotationsDataToClass(Class c,
                                      AbstractClassMetaData cmd,
                                      ClassLoaderResolver clr)
```
    Load up and add any annotations mapping info for the specified class to the stored ClassMetaData. Is package-access so that is only accessible by MetaData classes.
    
    Specified by:
    
    addAnnotationsDataToClass in interface MetaDataManager
    
    Parameters:
    
    c - The class
    
    cmd - the metadata to add annotation to
    
    clr - ClassLoader resolver
  - getMetaDataForImplementationOfReference
```
public ClassMetaData getMetaDataForImplementationOfReference(Class referenceClass,
                                                             Object implValue,
                                                             ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for an implementation of a reference type. Finds the metadata for the implementation of this reference.
    
    Specified by:
    
    getMetaDataForImplementationOfReference in interface MetaDataManager
    
    Parameters:
    
    referenceClass - The reference class to find MetaData for
    
    implValue - Object of an implementation class, to return if possible (null=ignore)
    
    clr - ClassLoader resolver
    
    Returns:
    
    The ClassMetaData for an implementation of a reference type
  - getMetaDataForQuery
```
public QueryMetaData getMetaDataForQuery(Class cls,
                                         ClassLoaderResolver clr,
                                         String queryName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a named query for a class. If the class is not specified, searches for the query with this name for any class. Will only return metadata for queries already registered in this implementation.
    
    Specified by:
    
    getMetaDataForQuery in interface MetaDataManager
    
    Parameters:
    
    cls - The class which has the query defined for it
    
    clr - the ClassLoaderResolver
    
    queryName - Name of the query
    
    Returns:
    
    The QueryMetaData for the query for this class
  - getNamedQueryNames
```
public Set<String> getNamedQueryNames()
```
    Description copied from interface: MetaDataManager
    
    Convenience method to access the names of named queries that are registered with this manager.
    
    Specified by:
    
    getNamedQueryNames in interface MetaDataManager
    
    Returns:
    
    Names of the named queries
  - getMetaDataForStoredProcQuery
```
public StoredProcQueryMetaData getMetaDataForStoredProcQuery(Class cls,
                                                             ClassLoaderResolver clr,
                                                             String queryName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a named stored procedure query for a class. If the class is not specified, searches for the query with this name for any class. Will only return metadata for queries already registered in this implementation.
    
    Specified by:
    
    getMetaDataForStoredProcQuery in interface MetaDataManager
    
    Parameters:
    
    cls - The class which has the query defined for it
    
    clr - the ClassLoaderResolver
    
    queryName - Name of the (stored proc) query
    
    Returns:
    
    The StoredProcQueryMetaData for the query for this class
  - getMetaDataForFetchPlan
```
public FetchPlanMetaData getMetaDataForFetchPlan(String name)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a named fetch plan.
    
    Specified by:
    
    getMetaDataForFetchPlan in interface MetaDataManager
    
    Parameters:
    
    name - Name of the fetch plan
    
    Returns:
    
    The FetchPlanMetaData for this name (if any)
  - getMetaDataForSequence
```
public SequenceMetaData getMetaDataForSequence(ClassLoaderResolver clr,
                                               String seqName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a Sequence in a package. This implementation simply checks what is already loaded and returns if found
    
    Specified by:
    
    getMetaDataForSequence in interface MetaDataManager
    
    Parameters:
    
    clr - the ClassLoaderResolver
    
    seqName - Name of the package (fully qualified if necessary)
    
    Returns:
    
    The SequenceMetaData for this named sequence
  - getMetaDataForTableGenerator
```
public TableGeneratorMetaData getMetaDataForTableGenerator(ClassLoaderResolver clr,
                                                           String genName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a TableGenerator in a package. This implementation simply checks what is already loaded and returns if found
    
    Specified by:
    
    getMetaDataForTableGenerator in interface MetaDataManager
    
    Parameters:
    
    clr - the ClassLoaderResolver
    
    genName - Name of the package (fully qualified if necessary)
    
    Returns:
    
    The TableGenerator for this named generator
  - getMetaDataForQueryResult
```
public QueryResultMetaData getMetaDataForQueryResult(String name)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for a QueryResult.
    
    Specified by:
    
    getMetaDataForQueryResult in interface MetaDataManager
    
    Parameters:
    
    name - Name of the query result
    
    Returns:
    
    The QueryResultMetaData under this name
  - getMetaDataForInterface
```
public InterfaceMetaData getMetaDataForInterface(Class c,
                                                 ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the MetaData for an interface. Part of the support for "persistent-interface". This defaults to returning null since interfaces are only supported by JDO.
    
    Specified by:
    
    getMetaDataForInterface in interface MetaDataManager
    
    Parameters:
    
    c - The interface to find MetaData for
    
    clr - the ClassLoaderResolver
    
    Returns:
    
    The InterfaceMetaData for this interface (or null if not found)
  - isPersistentInterface
```
public boolean isPersistentInterface(String name)
```
    Description copied from interface: MetaDataManager
    
    Convenience method to return if the passed class name is a "persistent-interface".
    
    Specified by:
    
    isPersistentInterface in interface MetaDataManager
    
    Parameters:
    
    name - Name if the interface
    
    Returns:
    
    Whether it is a "persistent-interface"
  - isPersistentInterfaceImplementation
```
public boolean isPersistentInterfaceImplementation(String interfaceName,
                                                   String implName)
```
    Description copied from interface: MetaDataManager
    
    Convenience method to return if the passed class name is an implementation of the passed "persistent-interface".
    
    Specified by:
    
    isPersistentInterfaceImplementation in interface MetaDataManager
    
    Parameters:
    
    interfaceName - Name of the persistent interface
    
    implName - The implementation name
    
    Returns:
    
    Whether it is a (DataNucleus-generated) impl of the persistent interface
  - isPersistentDefinitionImplementation
```
public boolean isPersistentDefinitionImplementation(String implName)
```
    Description copied from interface: MetaDataManager
    
    Convenience method to return if the passed class name is an implementation of a "persistent definition".
    
    Specified by:
    
    isPersistentDefinitionImplementation in interface MetaDataManager
    
    Parameters:
    
    implName - The implementation name
    
    Returns:
    
    Whether it is a (DataNucleus-generated) impl of the persistent interface or abstract class
  - getImplementationNameForPersistentInterface
```
public String getImplementationNameForPersistentInterface(String interfaceName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the implementation name for the specified "persistent-interface".
    
    Specified by:
    
    getImplementationNameForPersistentInterface in interface MetaDataManager
    
    Parameters:
    
    interfaceName - The name of the persistent interface
    
    Returns:
    
    The name of the implementation class
  - getClassMetaDataForImplementationOfPersistentInterface
```
public ClassMetaData getClassMetaDataForImplementationOfPersistentInterface(String interfaceName)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the metadata for the implementation of the specified "persistent-interface".
    
    Specified by:
    
    getClassMetaDataForImplementationOfPersistentInterface in interface MetaDataManager
    
    Parameters:
    
    interfaceName - The name of the persistent interface
    
    Returns:
    
    The ClassMetaData of the implementation class
  - registerPersistentInterface
```
public void registerPersistentInterface(InterfaceMetaData imd,
                                        Class implClass,
                                        ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Method to register a persistent interface and its implementation with the MetaData system. This is called by the JDOImplementationCreator.
    
    Specified by:
    
    registerPersistentInterface in interface MetaDataManager
    
    Parameters:
    
    imd - MetaData for the interface
    
    implClass - The implementation class
    
    clr - ClassLoader Resolver to use
  - registerImplementationOfAbstractClass
```
public void registerImplementationOfAbstractClass(ClassMetaData cmd,
                                                  Class implClass,
                                                  ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Method to register the metadata for an implementation of a persistent abstract class. This is called by the JDOImplementationCreator.
    
    Specified by:
    
    registerImplementationOfAbstractClass in interface MetaDataManager
    
    Parameters:
    
    cmd - MetaData for the abstract class
    
    implClass - The implementation class
    
    clr - ClassLoader resolver
  - parseFile
```
protected abstract FileMetaData parseFile(URL fileURL)
```
    Utility to parse an XML metadata file.
    
    Parameters:
    
    fileURL - URL of the file
    
    Returns:
    
    The FileMetaData for this file
  - registerFile
```
public abstract void registerFile(String fileURLString,
                                  FileMetaData filemd,
                                  ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Method to take the FileMetaData and register the relevant parts of it with the assorted caches provided. Note : this is only public to allow enhancer tests to load up metadata manually.
    
    Specified by:
    
    registerFile in interface MetaDataManager
    
    Parameters:
    
    fileURLString - URL of the metadata file
    
    filemd - The File MetaData
    
    clr - ClassLoader resolver
  - registerDiscriminatorValueForClass
```
public void registerDiscriminatorValueForClass(AbstractClassMetaData cmd,
                                               String discrimValue)
```
    Specified by:
    
    registerDiscriminatorValueForClass in interface MetaDataManager
  - getClassNameForDiscriminatorValueWithRoot
```
public String getClassNameForDiscriminatorValueWithRoot(AbstractClassMetaData rootCmd,
                                                        String discrimValue)
```
    Specified by:
    
    getClassNameForDiscriminatorValueWithRoot in interface MetaDataManager
  - getDiscriminatorValueForClass
```
public String getDiscriminatorValueForClass(AbstractClassMetaData cmd,
                                            String discrimValue)
```
    Specified by:
    
    getDiscriminatorValueForClass in interface MetaDataManager
  - getClassNameFromDiscriminatorValue
```
public String getClassNameFromDiscriminatorValue(String discrimValue,
                                                 DiscriminatorMetaData dismd)
```
    Specified by:
    
    getClassNameFromDiscriminatorValue in interface MetaDataManager
  - registerSequencesForFile
```
public void registerSequencesForFile(FileMetaData filemd)
```
    Convenience method to register all sequences found in the passed file.
    
    Specified by:
    
    registerSequencesForFile in interface MetaDataManager
    
    Parameters:
    
    filemd - MetaData for the file
  - registerTableGeneratorsForFile
```
public void registerTableGeneratorsForFile(FileMetaData filemd)
```
    Convenience method to register all table generators found in the passed file.
    
    Specified by:
    
    registerTableGeneratorsForFile in interface MetaDataManager
    
    Parameters:
    
    filemd - MetaData for the file
  - registerQueryResultMetaDataForFile
```
protected void registerQueryResultMetaDataForFile(FileMetaData filemd)
```
    Convenience method to register all table generators found in the passed file.
    
    Parameters:
    
    filemd - MetaData for the file
  - registerNamedQuery
```
public void registerNamedQuery(QueryMetaData qmd)
```
    Convenience method to register a query under a name.
    
    Specified by:
    
    registerNamedQuery in interface MetaDataManager
    
    Parameters:
    
    qmd - Query metadata
  - registerQueriesForFile
```
protected void registerQueriesForFile(FileMetaData filemd)
```
    Convenience method to register all queries found in the passed file.
    
    Parameters:
    
    filemd - MetaData for the file
  - registerStoredProcQueriesForFile
```
protected void registerStoredProcQueriesForFile(FileMetaData filemd)
```
    Convenience method to register all stored proc queries found in the passed file.
    
    Parameters:
    
    filemd - MetaData for the file
  - registerFetchPlansForFile
```
protected void registerFetchPlansForFile(FileMetaData filemd)
```
    Convenience method to register all FetchPlans found in the passed file.
    
    Parameters:
    
    filemd - MetaData for the file
  - populateFileMetaData
```
protected void populateFileMetaData(FileMetaData filemd,
                                    ClassLoaderResolver clr,
                                    ClassLoader primary)
```
    Convenience method to populate all classes/interfaces in a Meta-Data file.
    
    Parameters:
    
    filemd - The MetaData file
    
    clr - Class Loader to use in population
    
    primary - the primary ClassLoader to use (or null)
  - initialiseFileMetaData
```
protected void initialiseFileMetaData(FileMetaData filemd,
                                      ClassLoaderResolver clr,
                                      ClassLoader primary)
```
    Initialise all classes/interfaces in a Meta-Data file.
    
    Parameters:
    
    filemd - the FileMetaData
    
    clr - ClassLoader resolver to use
    
    primary - the primary ClassLoader to use (or null)
  - initialiseClassMetaData
```
protected void initialiseClassMetaData(ClassMetaData cmd,
                                       Class cls,
                                       ClassLoaderResolver clr)
```
    Utility to initialise the MetaData for a class, using the specified class. This assigns defaults to tags that haven't been assigned. If the class that is being used to populate the MetaData is not enhanced, this will throw a NucleusUserException informing them of this.
    
    Parameters:
    
    cmd - The classes metadata
    
    cls - The class to use as a basis for initialisation
    
    clr - ClassLoader resolver to use
    
    Throws:
    
    NucleusUserException - if the class is not enhanced
  - initialiseInterfaceMetaData
```
protected void initialiseInterfaceMetaData(InterfaceMetaData imd,
                                           ClassLoaderResolver clr,
                                           ClassLoader primary)
```
    Utility to initialise the MetaData for a interface, using the specified class. This assigns defaults to tags that haven't been assigned. If the class that is being used to populate the MetaData is not enhanced, this will throw a NucleusUserException informing them of this.
    
    Parameters:
    
    imd - The interface metadata
    
    clr - The loader of the interface
    
    primary - the primary ClassLoader to use (or null)
  - loadAnnotationsForClass
```
protected FileMetaData 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. The FileMetaData, PackageMetaData will be dummy records.
    
    Parameters:
    
    cls - The class
    
    clr - ClassLoader resolver
    
    register - Whether to register the data
    
    populate - Whether to populate the data
    
    Returns:
    
    The FileMetaData
  - postProcessClassMetaData
```
protected void postProcessClassMetaData(AbstractClassMetaData cmd,
                                        ClassLoaderResolver clr)
```
    Method that will perform any necessary post-processing on metadata.
    
    Parameters:
    
    cmd - Metadata for the class
    
    clr - ClassLoader resolver
  - populateAbstractClassMetaData
```
protected boolean populateAbstractClassMetaData(AbstractClassMetaData cmd,
                                                ClassLoaderResolver clr,
                                                ClassLoader loader)
```
    Convenience method to populate the MetaData for the specified class/interface.
    
    Parameters:
    
    cmd - MetaData
    
    clr - ClassLoader resolver
    
    loader - The primary class loader
    
    Returns:
    
    Whether it was successful
  - initialiseAbstractClassMetaData
```
protected void initialiseAbstractClassMetaData(AbstractClassMetaData cmd,
                                               ClassLoaderResolver clr)
```
    Convenience method to initialise the MetaData for the specified class/interface.
    
    Parameters:
    
    cmd - MetaData
    
    clr - ClassLoaderResolver
  - abstractClassMetaDataInitialised
```
public void abstractClassMetaDataInitialised(AbstractClassMetaData cmd)
```
    Method called (by AbstractClassMetaData.initialise()) when a class has its metadata initialised.
    
    Specified by:
    
    abstractClassMetaDataInitialised in interface MetaDataManager
    
    Parameters:
    
    cmd - Metadata that has been initialised
  - getConcreteSubclassesForClass
```
public String[] getConcreteSubclassesForClass(String className)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the names of all concrete subclasses of the provided class.
    
    Specified by:
    
    getConcreteSubclassesForClass in interface MetaDataManager
    
    Parameters:
    
    className - Name of the class that we want the known concrete subclasses for.
    
    Returns:
    
    Names of the subclasses. Returns null if there are no subclasses
  - getSubclassesForClass
```
public String[] getSubclassesForClass(String className,
                                      boolean includeDescendents)
```
    Description copied from interface: MetaDataManager
    
    Accessor for the subclasses of a particular class
    
    Specified by:
    
    getSubclassesForClass in interface MetaDataManager
    
    Parameters:
    
    className - Name of the class that we want the known subclasses for.
    
    includeDescendents - Whether to include subclasses of subclasses etc
    
    Returns:
    
    Names of the subclasses. return null if there are no subclasses
  - getReferencedClasses
```
public List<AbstractClassMetaData> getReferencedClasses(String[] classNames,
                                                        ClassLoaderResolver clr)
```
    Description copied from interface: MetaDataManager
    
    Convenience method to get the MetaData for all referenced classes with the passed set of classes as root.
    
    Specified by:
    
    getReferencedClasses in interface MetaDataManager
    
    Parameters:
    
    classNames - Names of the root classes
    
    clr - ClassLoader resolver
    
    Returns:
    
    List of AbstractClassMetaData objects for the referenced classes
  - getReferencedClassMetaData
```
protected List<AbstractClassMetaData> getReferencedClassMetaData(AbstractClassMetaData cmd,
                                                                 ClassLoaderResolver clr)
```
    Utility to return all ClassMetaData that is referenced from the supplier class.
    
    Parameters:
    
    cmd - The origin class's MetaData.
    
    clr - ClassLoaderResolver resolver for loading any classes.
    
    Returns:
    
    List of ClassMetaData referenced by the origin
  - isFieldTypePersistable
```
public boolean isFieldTypePersistable(Class type)
```
    Description copied from interface: MetaDataManager
    
    Utility to return if this field is persistable.
    
    Specified by:
    
    isFieldTypePersistable in interface MetaDataManager
    
    Parameters:
    
    type - Type of the field (for when "type" is not yet set)
    
    Returns:
    
    Whether the field type is persistable.

Class MetaDataManagerImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

nucleusContext

annotationManager

validateXML

supportXMLNamespaces

allowMetaDataLoad

allowXML

allowAnnotations

allowORM

defaultNullable

updateLock

classesWithoutPersistenceInfo

classMetaDataByClass

usableClassMetaDataByClass

fileMetaDataByURLString

classMetaDataByEntityName

classMetaDataByDiscriminatorName

directSubclassesByClass

concreteSubclassNamesByClassName

queryMetaDataByName

storedProcQueryMetaDataByName

fetchPlanMetaDataByName

sequenceMetaDataByPackageSequence

tableGeneratorMetaDataByPackageSequence

queryResultMetaDataByName

classMetaDataByAppIdClassName

listeners

userMetaDataNumber

discriminatorLookupByRootClassName

utilisedFileMetaData

Constructor Detail

MetaDataManagerImpl

Method Detail

close

registerListener

deregisterListener

getEnhancedMethodNamePrefix

isEnhancerField

setAllowMetaDataLoad

setAllowXML

setDefaultNullable

setAllowAnnotations

supportsORM

isDefaultNullable

isEnhancing

setValidate

setXmlNamespaceAware

getNucleusContext

getApiAdapter

getAnnotationManager

loadMetadataFiles

loadClasses

loadJar

loadPersistenceUnit

loadUserMetaData

loadMetaDataForClass

unloadMetaDataForClass

getScanner

initialiseFileMetaDataForUse

loadFiles

isClassPersistable

getFileMetaData

getClassesWithMetaData

hasMetaDataForClass

isClassWithoutPersistenceInfo

getClassMetaDataWithApplicationId

getMetaDataForClass

getMetaDataForClass

processListenerLoadingCall

getMetaDataForEntityName

getMetaDataForDiscriminator

readMetaDataForClass

readMetaDataForMember

getMetaDataForClassInternal

registerMetaDataForClass