Class AbstractActiveDescriptor<T>

    • Field Detail

      • serialVersionUID

        private static final long serialVersionUID
        For serialization
        See Also:
        Constant Field Values
      • EMPTY_QUALIFIER_SET

        private static final java.util.Set<java.lang.annotation.Annotation> EMPTY_QUALIFIER_SET
      • advertisedContracts

        private java.util.Set<java.lang.reflect.Type> advertisedContracts
      • scopeAnnotation

        private java.lang.annotation.Annotation scopeAnnotation
      • scope

        private java.lang.Class<? extends java.lang.annotation.Annotation> scope
      • qualifiers

        private java.util.Set<java.lang.annotation.Annotation> qualifiers
      • factoryServiceId

        private java.lang.Long factoryServiceId
      • factoryLocatorId

        private java.lang.Long factoryLocatorId
      • isReified

        private boolean isReified
      • cacheSet

        private transient boolean cacheSet
      • cachedValue

        private transient T cachedValue
      • rwLock

        private final java.util.concurrent.locks.ReentrantReadWriteLock rwLock
      • rLock

        private final java.util.concurrent.locks.Lock rLock
      • wLock

        private final java.util.concurrent.locks.Lock wLock
    • Constructor Detail

      • AbstractActiveDescriptor

        public AbstractActiveDescriptor()
        For serialization
      • AbstractActiveDescriptor

        protected AbstractActiveDescriptor​(Descriptor baseDescriptor)
        Creates a NON reified ActiveDescriptor based on a copy of the given baseDescriptor. The values from the baseDescriptor will be copied deeply
        Parameters:
        baseDescriptor - The non-null base descriptor to copy values from
      • AbstractActiveDescriptor

        protected AbstractActiveDescriptor​(java.util.Set<java.lang.reflect.Type> advertisedContracts,
                                           java.lang.Class<? extends java.lang.annotation.Annotation> scope,
                                           java.lang.String name,
                                           java.util.Set<java.lang.annotation.Annotation> qualifiers,
                                           DescriptorType descriptorType,
                                           DescriptorVisibility descriptorVisibility,
                                           int ranking,
                                           java.lang.Boolean proxy,
                                           java.lang.Boolean proxyForSameScope,
                                           java.lang.String analyzerName,
                                           java.util.Map<java.lang.String,​java.util.List<java.lang.String>> metadata)
        This constructor must be called with the information about this descriptor
        Parameters:
        advertisedContracts - The contracts that should be advertised by this descriptor (may not be null, but may be empty)
        scope - The scope of this descriptor (may not be null)
        name - The name of this descriptor (may be null)
        qualifiers - The qualifiers of this descriptor (may not be null, but may be empty)
        ranking - The ranking for this descriptor
        proxy - whether the descriptor should be proxied
        proxyForSameScope - whether or not to proxy this descriptor for other services in the same scope
        analyzerName - the name of the service used to analyze this class
        metadata - Metadata to add to this descriptor
    • Method Detail

      • removeNamedQualifier

        private void removeNamedQualifier()
      • setImplementationType

        public void setImplementationType​(java.lang.reflect.Type t)
      • setName

        public void setName​(java.lang.String name)
        Sets the name of this descriptor. Will remove any existing Named qualifier and add a Named qualifier for this name
        Overrides:
        setName in class DescriptorImpl
        Parameters:
        name - The name for this descriptor
      • getCache

        public T getCache()
        Description copied from interface: SingleCache
        This can be used for scopes that will only every be created once. The returned value must have been set previously with setCache. If this is called when isCacheSet is false will result in a RuntimeException
        Specified by:
        getCache in interface SingleCache<T>
        Returns:
        A value cached with this ActiveDescriptor
      • isCacheSet

        public boolean isCacheSet()
        Description copied from interface: SingleCache
        Returns true if this cache has been set
        Specified by:
        isCacheSet in interface SingleCache<T>
        Returns:
        true if there is a currently cached value, false otherwise
      • setCache

        public void setCache​(T cacheMe)
        Description copied from interface: SingleCache
        Sets the value into the cache
        Specified by:
        setCache in interface SingleCache<T>
        Parameters:
        cacheMe - A single value that can be cached in this active descriptor
      • releaseCache

        public void releaseCache()
        Description copied from interface: SingleCache
        Removes the cached value and makes it such that this cache has not been set
        Specified by:
        releaseCache in interface SingleCache<T>
      • isReified

        public boolean isReified()
        Description copied from interface: ActiveDescriptor
        This method returns true if this descriptor has been reified (class loaded). If this method returns false then the other methods in this interface will throw an IllegalStateException. Once this method returns true it may be
        Specified by:
        isReified in interface ActiveDescriptor<T>
        Returns:
        true if this descriptor has been reified, false otherwise
      • setReified

        public void setReified​(boolean reified)
        This method is called to change the state of the reification of this descriptor
        Parameters:
        reified - true if this descriptor should appear reified, false otherwise
      • getContractTypes

        public java.util.Set<java.lang.reflect.Type> getContractTypes()
        Description copied from interface: ActiveDescriptor
        The set of types that this ActiveDescriptor must produce. These types may be Classes or ParameterizedTypes, and may be no other subclass of Type
        Specified by:
        getContractTypes in interface ActiveDescriptor<T>
        Returns:
        the set of types this ActiveDescriptor must implement or extend
      • addContractType

        public void addContractType​(java.lang.reflect.Type addMe)
        Adds an advertised contract to the set of contracts advertised by this descriptor
        Parameters:
        addMe - The contract to add. May not be null
      • removeContractType

        public boolean removeContractType​(java.lang.reflect.Type removeMe)
        Removes an advertised contract from the set of contracts advertised by this descriptor
        Parameters:
        removeMe - The contract to remove. May not be null
        Returns:
        true if removeMe was removed from the set
      • getScopeAsAnnotation

        public java.lang.annotation.Annotation getScopeAsAnnotation()
        Description copied from interface: ActiveDescriptor
        Returns the scope as an Annotation implementation that this ActiveDescriptor belongs to
        Specified by:
        getScopeAsAnnotation in interface ActiveDescriptor<T>
        Returns:
        The scope of this ActiveDescriptor as an Annotation
      • setScopeAsAnnotation

        public void setScopeAsAnnotation​(java.lang.annotation.Annotation scopeAnnotation)
        Sets the scope as an Annotation implementation. This method will also modify the scope as a Class and the underlying scope as a String
        Parameters:
        scopeAnnotation - The scope as an Annotation. May not be null
      • getScopeAnnotation

        public java.lang.Class<? extends java.lang.annotation.Annotation> getScopeAnnotation()
        Description copied from interface: ActiveDescriptor
        Returns the scope that this ActiveDescriptor belongs to
        Specified by:
        getScopeAnnotation in interface ActiveDescriptor<T>
        Returns:
        The scope of this ActiveDescriptor
      • setScopeAnnotation

        public void setScopeAnnotation​(java.lang.Class<? extends java.lang.annotation.Annotation> scopeAnnotation)
        Sets the scope annotation for this descriptor
        Parameters:
        scopeAnnotation - The non-null scope annotation for this service
      • getQualifierAnnotations

        public java.util.Set<java.lang.annotation.Annotation> getQualifierAnnotations()
        Description copied from interface: ActiveDescriptor
        The full set of qualifiers that this ActiveDescriptor provides
        Specified by:
        getQualifierAnnotations in interface ActiveDescriptor<T>
        Returns:
        The set of annotations that this ActiveDescriptor provides
      • addQualifierAnnotation

        public void addQualifierAnnotation​(java.lang.annotation.Annotation addMe)
        Adds the given string to the list of qualifiers
        Parameters:
        addMe - The fully qualified class name of the qualifier to add. May not be null
      • removeQualifierAnnotation

        public boolean removeQualifierAnnotation​(java.lang.annotation.Annotation removeMe)
        Removes the given qualifier from the list of qualifiers
        Parameters:
        removeMe - The fully qualifier class name of the qualifier to remove. May not be null
        Returns:
        true if the given qualifier was removed
      • getFactoryServiceId

        public java.lang.Long getFactoryServiceId()
        Description copied from interface: ActiveDescriptor
        If this ActiveDescriptor has DescriptorType of PROVIDE_METHOD then this field will return the ServiceId of its associated Factory service. Otherwise this method should return null
        Specified by:
        getFactoryServiceId in interface ActiveDescriptor<T>
        Returns:
        The service ID of the associated factory service
      • getFactoryLocatorId

        public java.lang.Long getFactoryLocatorId()
        Description copied from interface: ActiveDescriptor
        If this ActiveDescriptor has DescriptorType of PROVIDE_METHOD then this field will return the ServiceId of its associated Factory service. Otherwise this method should return null
        Specified by:
        getFactoryLocatorId in interface ActiveDescriptor<T>
        Returns:
        The locator ID of the associated factory service
      • setFactoryId

        public void setFactoryId​(java.lang.Long locatorId,
                                 java.lang.Long serviceId)
        Sets the locator and serviceId for the factory. This descriptor must be of type PROVIDE_METHOD
        Parameters:
        locatorId - The locatorId of the factory associated with this method
        serviceId - The serviceId of the factory associated with this method
      • getInjectees

        public java.util.List<Injectee> getInjectees()
        Description copied from interface: ActiveDescriptor
        Returns the full list of Injectees this class has. These references will be resolved prior to the class being constructed, even if these injectees are field or method injectees.

        If this descriptor is describing a factory created type then this list must have zero length

        Specified by:
        getInjectees in interface ActiveDescriptor<T>
        Returns:
        Will not return null, but may return an empty list. The set of Injectees that must be resolved before this ActiveDescriptor can be constructed
      • dispose

        public void dispose​(T instance)
        Description copied from interface: ActiveDescriptor
        Disposes this instance. All the PerLookup objects that were created for this instance will be destroyed after this object has been destroyed
        Specified by:
        dispose in interface ActiveDescriptor<T>
        Parameters:
        instance - The instance to destroy
      • equals

        public boolean equals​(java.lang.Object o)
        Description copied from class: DescriptorImpl
        This equals matches only if the following fields of the descriptor match:
        • implementation
        • contracts
        • name
        • scope
        • qualifiers
        • descriptorType
        • descriptorVisibility
        • metadata
        • proxiable
        • proxyForSameScope
        • analysisName
        Overrides:
        equals in class DescriptorImpl
        Parameters:
        o - The object to compare to this one. May be null (which will result in a false)
        Returns:
        true if the descriptors are equal