/** * Default constructor assigning the delegate. In case the provider implements observable interface the observation * of this instance is delegated as well, otherwise an empty independent list of observers is created. * * @param delegate delegate to use, can't be null */ public AbstractMetadataDelegate(MetadataProvider delegate) { Assert.notNull(delegate, "Delegate can't be null"); this.delegate = delegate; if (delegate instanceof ObservableMetadataProvider) { observers = ((ObservableMetadataProvider) delegate).getObservers(); } else { observers = new LinkedList<Observer>(); } }
/** * Removes a metadata provider from the list of registered providers. * * @param provider provider to be removed */ public void removeMetadataProvider(MetadataProvider provider) { Lock writeLock = providerLock.writeLock(); writeLock.lock(); ObservableMetadataProvider observableProvider; try { if (providers.remove(provider) && provider instanceof ObservableMetadataProvider) { observableProvider = (ObservableMetadataProvider) provider; for (Observer observer : observableProvider.getObservers()) { if (observer instanceof ContainedProviderObserver) { observableProvider.getObservers().remove(observer); } } } } finally { writeLock.unlock(); } }
/** * Constructor. * * @param metadataProvider provider of the metadata * * @throws IllegalArgumentException thrown if the supplied provider is null */ public MetadataPKIXValidationInformationResolver(MetadataProvider metadataProvider) { super(); if (metadataProvider == null) { throw new IllegalArgumentException("Metadata provider may not be null"); } metadata = metadataProvider; entityPKIXCache = new HashMap<MetadataCacheKey, SoftReference<List<PKIXValidationInformation>>>(); extensionsCache = new HashMap<Extensions, SoftReference<List<PKIXValidationInformation>>>(); entityNamesCache = new HashMap<MetadataCacheKey, SoftReference<Set<String>>>(); rwlock = new ReentrantReadWriteLock(); if (metadata instanceof ObservableMetadataProvider) { ObservableMetadataProvider observable = (ObservableMetadataProvider) metadataProvider; observable.getObservers().add(new MetadataProviderObserver()); } }
/** * Constructor. * * @param metadataProvider provider of the metadata * * @throws IllegalArgumentException thrown if the supplied provider is null */ public MetadataCredentialResolver(MetadataProvider metadataProvider) { super(); if (metadataProvider == null) { throw new IllegalArgumentException("Metadata provider may not be null"); } metadata = metadataProvider; cache = new HashMap<MetadataCacheKey, SoftReference<Collection<Credential>>>(); keyInfoCredentialResolver = Configuration.getGlobalSecurityConfiguration() .getDefaultKeyInfoCredentialResolver(); rwlock = new ReentrantReadWriteLock(); if (metadata instanceof ObservableMetadataProvider) { ObservableMetadataProvider observable = (ObservableMetadataProvider) metadataProvider; observable.getObservers().add(new MetadataProviderObserver()); } }
/** * Adds a metadata provider to the given collection. The new provider is checked to see if it is null, if not the * providers {@link MetadataProvider#requireValidMetadata()} property is set to the value of this metadata * provider's property. If the given metadata provider is an instance of {@link ObservableMetadataProvider} then a * ContainedProviderObserver is added to it as well. * * @param provider provider to be added to the collection * @param providerList collection to which the provider is added */ protected void doAddMetadataProvider(MetadataProvider provider, List<MetadataProvider> providerList) { if (provider != null) { provider.setRequireValidMetadata(requireValidMetadata()); if (provider instanceof ObservableMetadataProvider) { ((ObservableMetadataProvider) provider).getObservers().add(new ContainedProviderObserver()); } providerList.add(provider); } }