Class 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:
    Serialized Form
    • 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.
      • 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).
      • 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

      • 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")
      • 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
      • 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
      • 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
      • 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
      • 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
      • 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
      • 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)
      • registerQueryResultMetaDataForFile

        protected void registerQueryResultMetaDataForFile​(FileMetaData filemd)
        Convenience method to register the query result metadata for the provided file.
        Parameters:
        filemd - MetaData for the file
      • 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
      • 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.