Public

getServiceProviders

Scans for factory plug-ins of the given category, with guard against
recursivities. The recursivity 

scanForPlugins

Returns the first provider in the registry for the specified category, using the
specified map of hi

getServiceProvider

lookupProviders

registerServiceProvider

Constructs a new registry for the specified categories.

<init>

Log a debug message for #getServiceProvider method. Note: we are not required to
insert the method n

debug

Returns the providers available in the cache, or null if none. To be overridden
by FactoryCreator on

getCachedProviders

getCategories

Returns all class loaders to be used for scanning plugins. Current
implementation returns the follow

getClassLoaders

getFactories

Prepares a message to be logged if any provider has been registered.

getLogHeader

Search the first implementation in the registery matching the specified
conditions. This method is i

getServiceImplementation

getServiceProviderByClass

Implementation of #getServiceProviders(Class,Filter,Hints) without the filtering
applied by the #isA

getUnfilteredProviders

Returns true is the specified factory meets the requirements specified by a map
of hints and the fil

isAcceptable

Returns true if the specified factory is available.

isAvailable

Invoked when a factory can't be loaded. Log a warning, but do not stop the
process.

loadingFailure

Log the specified message after all provider for a given category have been
registered.

Registers every factories from the specified provider for the given category.

register

Charset

Creating JSON documents from java classes using gson

ObjectMapper provides functionality for reading and writing JSON, either to and
from basic POJOs (Pl

com.fasterxml.jackson.databind.ObjectMapper

The GridLayout class is a layout manager that lays out a container's components
in a rectangular gri

java.awt.GridLayout

 Calendar is an abstract base class for converting between a Date object and a
set of integer fields

java.util.Calendar

Timers schedule one-shot or recurring TimerTask for execution. Prefer
java.util.concurrent.Scheduled

java.util.Timer

An int value that may be updated atomically. See the java.util.concurrent.atomic
package specificati

java.util.concurrent.atomic.AtomicInteger

Abstract superclass of object loading (and querying) strategies. This class
implements useful common

org.hibernate.loader.Loader

Return the original filename in the client's filesystem.This may contain path
information depending 

getOriginalFilename

getContentResolver

getExternalFilesDir

/**
     * Implementation of {@link #getServiceProviders(Class, Filter, Hints)} without the filtering
     * applied by the {@link #isAcceptable(Object, Class, Hints, Filter)} method. If this filtering
     * is not already presents in the filter given to this method, then it must be applied on the
     * elements returned by the iterator. The later is preferrable when:
     * <p>
     * <ul>
     *   <li>There is some cheaper tests to perform before {@code isAcceptable}.</li>
     *   <li>We don't want a restrictive filter in order to avoid trigging a classpath
     *       scan if this method doesn't found any element to iterate.</li>
     * </ul>
     * <p>
     * <b>Note:</b>
     * {@link #synchronizeIteratorProviders} should also be invoked once before this method.
     *
     * @todo Use Hints to match Constructor.
     */

/*
         * If the map is not empty, then this mean that a scanning is under progress, i.e.
         * 'scanForPlugins' is currently being executed. This is okay as long as the user
         * is not asking for one of the categories under scanning. Otherwise, the answer
         * returned by 'getServiceProviders' would be incomplete because not all plugins
         * have been found yet. This can lead to some bugs hard to spot because this methoud
         * could complete normally but return the wrong plugin. It is safer to thrown an
         * exception so the user is advised that something is wrong.
         */

/**
     * Returns the providers in the registry for the specified category, filter and hints.
     * Providers that are not {@linkplain OptionalFactory#isAvailable available} will be
     * ignored. This method will {@linkplain #scanForPlugins() scan for plugins} the first
     * time it is invoked for the given category.
     *
     * @param <T>      The class represented by the {@code category} argument.
     * @param category The category to look for. Usually an interface class
     *                 (not the actual implementation class).
     * @param filter   The optional filter, or {@code null}.
     * @param hints    The optional user requirements, or {@code null}.
     * @return Factories ready to use for the specified category, filter and hints.
     *
     * @since 2.3
     */

/*
         * The implementation of this method is very similar to the 'getUnfilteredProviders'
         * one except for filter handling. See the comments in 'getUnfilteredProviders' for
         * more implementation details.
         */

// Please note you will get errors here if you accidentally allow

// more than one thread to use your FactoryRegistry at a time.

How to use scanForPluginsIfNeededmethodin org.geotools.factory.FactoryRegistry

Best Java code snippets using org.geotools.factory.FactoryRegistry.scanForPluginsIfNeeded (Showing top 2 results out of 315)

How to use
scanForPluginsIfNeeded
method
in
org.geotools.factory.FactoryRegistry