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

Reading from database using SQL prepared statement

Uses a one-way hash function to turn an arbitrary number of bytes into a
fixed-length byte sequence.

java.security.MessageDigest

A Set is a data structure which does not allow duplicate elements.

java.util.Set

javax.swing.JTextField

org.hamcrest.core.IsNull

Factory that creates instances of DateTimeFormatter from patterns and styles. 
Datetime formatting i

org.joda.time.format.DateTimeFormat

The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is
expected that loggin

org.slf4j.Logger

getApplicationContext

getSystemService

scheduleAtFixedRate

/**
     * Returns the service registry. The registry will be created the first
     * time this method is invoked.
     */

/**
     * Dynamically register a new process factory into SPI
     * @param factory
     */

/**
     * If a system property was setup, load the class (if not already registered)
     * and move it in front of any other factory. This is done for compatibility
     * with legacy {@code FactoryFinder} implementation.
     *
     * @param loader   The class loader to use.
     * @param category The category to scan for plug-ins.
     * @param message  A buffer where to write the logging message.
     * @return {@code true} if at least one factory has been registered.
     */

/*
                     * Put this factory in front of every other factories (including the ones loaded
                     * in previous class loaders, which is why we don't inline this ordering in the
                     * 'register' loop). Note: if some factories were not yet registered, they will
                     * not be properly ordered. Since this code exists more for compatibility reasons
                     * than as a commited API, we ignore this short comming for now.
                     */

// The class has not been found, maybe because we are not using the appropriate

// class loader. Ignore (do not thrown an exception), in order to give a chance

// to the caller to invokes this method again with a different class loader.

// We are not allowed to read property, probably

// because we are running in an applet. Ignore...

/*
                 * Put this factory in front of every other factories (including the ones loaded
                 * in previous class loaders, which is why we don't inline this ordering in the
                 * 'register' loop). Note: if some factories were not yet registered, they will
                 * not be properly ordered. Since this code exists more for compatibility reasons
                 * than as a commited API, we ignore this short comming for now.
                 */

/**
     * {@linkplain #registerServiceProvider Registers} all factories given by the
     * supplied iterator.
     *
     * @param factories The factories (or "service providers") to register.
     * @param category  the category under which to register the providers.
     * @param message   A buffer where to write the logging message.
     * @return {@code true} if at least one factory has been registered.
     */

// Makes sure that we don't try to handle this error.

/*
                 * A provider can't be registered because of some missing dependencies.
                 * This occurs for example when trying to register the WarpTransform2D
                 * math transform on a machine without JAI installation. Since the factory
                 * may not be essential (this is the case of WarpTransform2D), just skip it.
                 */

/*
                 * If an exception occured during class initialization, log the cause.
                 * The ExceptionInInitializerError alone doesn't help enough.
                 */

// We want to handle sun.misc.ServiceConfigurationError only. Unfortunatly, we

// need to rely on reflection because this error class is not a commited API.

// TODO: Check if the error is catchable with JSE 6.

/*
                 * Failed to register a factory for a reason probably related to the plugin
                 * initialisation. It may be some factory-dependent missing resources.
                 */

/*
                 * If the factory implements more than one interface and an
                 * instance were already registered, reuse the same instance
                 * instead of duplicating it.
                 */

// Need to register anyway, because the category may not be

/*
                     * The factory is now registered. Add it to the message to
                     * be logged. We will log all factories together in a single
                     * log event because some registration (e.g.
                     * MathTransformProviders) would be otherwise quite verbose.
                     */

/*
             * If the factory implements more than one interface and an instance were
             * already registered, reuse the same instance instead of duplicating it.
             */

// Need to register anyway, because the category may not be the same.

/*
                 * The factory is now registered. Add it to the message to be logged. We will log
                 * all factories together in a single log event because some registration (e.g.
                 * MathTransformProviders) would be otherwise quite verbose.
                 */

How to use registerServiceProvidermethodin org.geotools.factory.FactoryRegistry

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

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