Class MetaDataManagerImpl

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
The property allowMetaDataLoad is used to distinguish which of these is permitted. Similarly there are only certain methods that are available to load metadata during operation. The updateLock is used to lock access on these methods.

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:
  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:
    • 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 Map<String,Collection<AbstractClassMetaData>> 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.
    • listenersLoadedMetaData

      private List<AbstractClassMetaData> listenersLoadedMetaData
      Temporary list of class metadata loaded during the current call, for use with listeners.
    • userMetaDataNumber

      protected int userMetaDataNumber
      Number of user metadata items.
    • discriminatorLookupByRootClassName

      protected Map<String,MetaDataManagerImpl.DiscriminatorLookup> discriminatorLookupByRootClassName
    • utilisedFileMetaData

      protected ArrayList<FileMetaData> utilisedFileMetaData
      Temporary list of the FileMetaData objects utilised in this call for metadata.
  • Constructor Details

    • MetaDataManagerImpl

      public MetaDataManagerImpl(NucleusContext ctx)
      Constructor, specifying the context used.
      Parameters:
      ctx - context that this metadata manager operates in
  • Method Details

    • 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()
      Description copied from interface: MetaDataManager
      Method to return the prefix applied to all enhancer method names
      Specified by:
      getEnhancedMethodNamePrefix in interface MetaDataManager
      Returns:
      The enhancer method name prefix (e.g "dn")
    • isEnhancerField

      public boolean isEnhancerField(String fieldName)
      Description copied from interface: MetaDataManager
      Method to return whether the specified member is an enhancer-provided member.
      Specified by:
      isEnhancerField in interface MetaDataManager
      Parameters:
      fieldName - Name of the member
      Returns:
      Whether it was added by the enhancer (e.g prefix "dn")
    • 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
      Initialisation 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
      Initialisation 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
      Primary 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. Only used by org.datanucleus.metadata classes.
      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. Only used by org.datanucleus.metadata classes.
      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)
      Description copied from interface: MetaDataManager
      Load up and add any O/R mapping info for the specified class to the stored ClassMetaData (if supported). Only to be invoked by ClassMetaData, InterfaceMetaData.
      Specified by:
      addORMDataToClass in interface MetaDataManager
      Parameters:
      c - The class
      clr - ClassLoader resolver
    • addAnnotationsDataToClass

      public void addAnnotationsDataToClass(Class c, AbstractClassMetaData cmd, ClassLoaderResolver clr)
      Description copied from interface: MetaDataManager
      Load up and add any annotations mapping info for the specified class to the stored ClassMetaData. Only to be invoked by ClassMetaData, InterfaceMetaData.
      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
    • 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

      protected ClassMetaData getClassMetaDataForImplementationOfPersistentInterface(String interfaceName)
      Accessor for the metadata for the implementation of the specified "persistent-interface".
      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 JDO ImplementationCreator.
      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 JDO ImplementationCreator.
      Specified by:
      registerImplementationOfAbstractClass in interface MetaDataManager
      Parameters:
      cmd - MetaData for the abstract class
      implClass - The implementation class
      clr - ClassLoader resolver
    • parseXmlFile

      protected abstract FileMetaData parseXmlFile(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)
      Description copied from interface: MetaDataManager
      Convenience method to register the discriminator value used by the specified class for easy lookup.
      Specified by:
      registerDiscriminatorValueForClass in interface MetaDataManager
      Parameters:
      cmd - Metadata for the class
      discrimValue - The discriminator value
    • getClassNameForDiscriminatorValueWithRoot

      public String getClassNameForDiscriminatorValueWithRoot(AbstractClassMetaData rootCmd, String discrimValue)
      Description copied from interface: MetaDataManager
      Method to return the class name that uses the provided discriminator value using the specified root class to search from.
      Specified by:
      getClassNameForDiscriminatorValueWithRoot in interface MetaDataManager
      Parameters:
      rootCmd - The root class
      discrimValue - The discriminator value
      Returns:
      The class using this value
    • getDiscriminatorValueForClass

      public String getDiscriminatorValueForClass(AbstractClassMetaData cmd)
      Description copied from interface: MetaDataManager
      Method to return the discriminator value used by the specified class.
      Specified by:
      getDiscriminatorValueForClass in interface MetaDataManager
      Parameters:
      cmd - Class to search for
      Returns:
      The discriminator value used by this class
    • getClassNameFromDiscriminatorValue

      public String getClassNameFromDiscriminatorValue(String discrimValue, DiscriminatorMetaData dismd)
      Description copied from interface: MetaDataManager
      Method to return the class name that uses the specified discriminator value for the specified discriminator.
      Specified by:
      getClassNameFromDiscriminatorValue in interface MetaDataManager
      Parameters:
      discrimValue - Discriminator value
      dismd - The discriminator metadata
      Returns:
      The class name (or null if not found)
    • registerSequencesForFile

      public void registerSequencesForFile(FileMetaData filemd)
      Description copied from interface: MetaDataManager
      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)
      Description copied from interface: MetaDataManager
      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 the query result metadata for the provided 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)
      Description copied from interface: MetaDataManager
      Method called (by AbstractClassMetaData.initialise()) when a class/interface has its metadata initialised. Only to be invoked by ClassMetaData, InterfaceMetaData.
      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
    • provideSubclassesForClass

      private void provideSubclassesForClass(String className, boolean includeDescendents, Collection<String> consumer)
      Provide the subclasses of a particular class to a given consumer
      Parameters:
      className - Name of the class that we want the known subclasses for.
      includeDescendents - Whether to include subclasses of subclasses etc
      consumer - the Collection (Set) where discovered subclasses are added
    • 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 of a persistable type.
      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.