-
barrysoft.plugins.Plugin
-
bear.plugins.Plugin
@author Andrey Chaschev chaschev@gmail.com
-
com.abiquo.ssm.plugin.annotations.Plugin
-
com.adito.extensions.types.Plugin
Interface to be implemented by all extension components that provide one or more
Plugin.
When the core server starts up, first all plugins have their {@link #startPlugin(PluginDefinition,ExtensionDescriptor,Element)}method called. Any plugins which throw an exception at this point are discarded and will not be available for the remaining lifetime of the server.
Any plugins that successfully initialised are then checked to see if the have been used before. If they haven't then the {@link #installPlugin()} methodis invoked. Here the plugin may perform any one-off tasks such as adding default resources.
Next, the {@link #activatePlugin()} method is called.
When the server shuts down, the {@link #canStopPlugin()} method is called,if this is true
then the {@link #stopPlugin()} method is called.
Plugins are defined in the Extension Description for the extension they are part of. Information required for plugin includes the fully qualified class name of this interface implementation, sort order, names and descriptions and dependencies.
-
com.atlassian.plugin.Plugin
-
com.bbn.openmap.plugin.PlugIn
This interface describes a component that can supply OMGraphics based on a Projection. PlugIns can be added to the map via a PlugInLayer.
@see com.bbn.openmap.plugin.PlugInLayer
-
com.bramosystems.oss.player.core.client.Plugin
-
com.cloudbees.sdk.Plugin
-
com.crawljax.web.model.Plugin
-
com.dotmarketing.plugin.model.Plugin
@author Jason Tesser
@since 1.6.5bA simple POJO for dotCMS plugins
-
com.dtolabs.rundeck.core.plugins.Plugin
-
com.facebook.presto.spi.Plugin
-
com.github.couchapptakeout.plugins.Plugin
-
com.godshawk.lib.annotations.modularity.Plugin
-
com.google.jstestdriver.Plugin
A representation of a parsed plugin.
@author corysmith
-
com.groupon.odo.proxylib.models.Plugin
-
com.hlcl.rql.as.Plugin
Diese Klasse beschreibt ein Plugin.
@author LEJAFR
-
com.jcloisterzone.ui.plugin.Plugin
-
com.sun.source.util.Plugin
The interface for a javac plug-in.
The javac plug-in mechanism allows a user to specify one or more plug-ins on the javac command line, to be started soon after the compilation has begun. Plug-ins are identified by a user-friendly name. Each plug-in that is started will be passed an array of strings, which may be used to provide the plug-in with values for any desired options or other arguments.
Plug-ins are located via a {@link ServiceLoader}, using the same class path as annotation processors (i.e. {@link StandardLocation#ANNOTATION_PROCESSOR_PATH ANNOTATION_PROCESSOR_PATH} or{@code -processorpath}).
It is expected that a typical plug-in will simply register a {@link TaskListener} to be informed of events during the executionof the compilation, and that the rest of the work will be done by the task listener.
@since 1.8
-
com.sun.tools.internal.xjc.Plugin
Add-on that works on the generated source code.
This add-on will be called after the default bean generation has finished.
@author Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com)
@since JAXB RI 2.0 EA
-
com.sun.tools.xjc.Plugin
Add-on that works on the generated source code.
This add-on will be called after the default bean generation has finished.
@author Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com)
@since JAXB RI 2.0 EA
-
com.tulskiy.musique.spi.Plugin
Author: Denis Tulskiy Date: 2/27/11
-
de.odysseus.calyxo.control.Plugin
Plugin interface. Plugins may be used to extend a module's capabilities. A plugin implementation requires a public default constructor. The plugin's init()
(destroy()
) method is called when the underlying module is initialized (destroyed).
@see de.odysseus.calyxo.control.PluginContext
@author Christoph Beck
-
de.pdf_scrutinizer.API.app.plugIn
-
de.taliis.editor.plugin.Plugin
A plugin is something that extends our main programms Functionality. This plugin superclass provides the definition of all interface functions. NOTE A 'plugin' is a middle class. Plugin's get instanced as soon they got loaded. Therefore its NOT recomed to implement the functionality of the Plugin outside of the Plugin itself. The plugin can get alot of references from the main application. Such as menue, config and file loader references. This references are OPTIONAL given by the main application. In this version the following types of plugin's are allowed: - view : Representation (and editor) for data classes. - function : Functionality Plugin. Import, Export for exsample - wizard : Subtype of function that provides a set of graphical wizards for whatever. - storage : complete binary parsing classes for a given file type All thoose types can be combined by logical AND
@author Tharo Herberg
-
devplugin.Plugin
Superclass for all Java-TV-Browser plugins.
To create a plugin do the following:
- Create a class that extends this class and name its package equal to the class name but with lower case letters. E.g.
myplugin.MyPlugin
. - Write your plugin code in that class.
- Pack your plugin class including all needed resources in a jar file named equal to your class. E.g.
MyPlugin.jar
. - Put the jar in the
plugin
directory of your TV-Browser installation.
@author Martin Oberhauser
@author Til Schneider, www.murfman.de
-
edu.umd.cs.findbugs.Plugin
A FindBugs plugin. A plugin contains executable Detector classes, as well as meta information describing those detectors (such as human-readable detector and bug descriptions).
@see PluginLoader
@author David Hovemeyer
-
forestry.plugins.Plugin
-
fr.soleil.lib.flyscan.model.parsing.plugin.Plugin
Plugin specified in .prop file, containing parameters descriptions
@author guerre-giordano
-
giggler.Plugin
This interface represents a plugin.
A plugin has a name and a version number. The plugin's lifecycle get initiated with {@link #init()}, gets active only with {@link #start()} and ends its existance with {@link #shutdown()}.
-
honeycrm.server.test.Plugin
-
hudson.Plugin
r/hudson/configure). This is convenient for exposing/maintaining configuration that doesn't fit any {@link Descriptor}s.
Up until Hudson 1.150 or something, subclasses of {@link Plugin} required@plugin javadoc annotation, but that is no longer a requirement.
@author Kohsuke Kawaguchi
@since 1.42
-
hudson.model.UpdateSite.Plugin
-
ij.plugin.PlugIn
Plugins that acquire images or display windows should implement this interface. Plugins that process images should implement the PlugInFilter interface.
-
it.freedomotic.api.Plugin
-
jsynoptic.base.Plugin
This is the base class for JSynoptic plugins
@author Nicolas Brodu
@version 1.0 2001
-
kameleon.plugin.PlugIn
Superclass for all plug-ins.
All plug-in must extend this class (directly or not) and implement its methods to be usable by the software.
@author Schnell Michaël
@version 1.0
-
net.datacrow.core.plugin.Plugin
The Plugin class should be extended by every plugin.
@author Robert Jan van der Waals
-
net.sf.minuteProject.configuration.bean.system.Plugin
-
net.xeoh.plugins.base.Plugin
The base class of all plugins. Plugin creation is fairly simple:
1. Create a new top level package for your plugin, e.g., com.company.plugins.imagedb
in case of an image database.
2. Create an interface within that package. The interface should (well, must) extend Plugin. Add all the methods you like, for example listImages()
3. Create an impl sub-package with the plugin package, in our case this is com.company.plugins.imagedb.impl
. The impl-name is not required, but should be kept as a convention. In the future there might exist tools that depend on it, or work better with it. If you have multiple implementations, create several sub-packages within the impl folder. In our example case, this could be the implementations impl.simple
(for a simple test implementation), impl.distributed
(for our distributed image storage) and impl.compatiblity
(for the old DB API)
4. Implement your interfaces, i.e., create a class / classes inside the respective impl
folder.
5. Add the @ {@link PluginImplementation} annotation to your implemented class(es).
6. You're done. Technically your plugin is ready now to use. It can be compiled now (Eclipse will probably have done this for you already). You might want to have a look at the {@link PluginManager} documentation to see how you can load and retrieve it (see addPluginsFrom()
and getPlugin()
).
NOTE: You should ensure that all implementations of your plugins are thread safe! Expect your functions to be called any time in any state.
@author Ralf Biedert
@see PluginManager
@see PluginUtil
-
org.apache.archiva.model.Plugin
-
org.apache.cxf.tools.plugin.Plugin
3.org/2001/XMLSchema}anyType"> <sequence> <element name="frontend" type="{http://cxf.apache.org/tools/plugin}FrontEnd" maxOccurs="unbounded"/> <element name="databinding" type="{http://cxf.apache.org/tools/plugin}DataBinding" maxOccurs="unbounded"/> </sequence> <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" /> <attribute name="version" use="required" type="{http://www.w3.org/2001/XMLSchema}string" /> <attribute name="provider" use="required" type="{http://www.w3.org/2001/XMLSchema}string" /> </restriction> </complexContent> </complexType>
-
org.apache.felix.mosgi.console.ifc.Plugin
-
org.apache.log4j.component.plugins.Plugin
Defines the required interface for all Plugin objects.
A plugin implements some specific functionality to extend the log4j framework. Each plugin is associated with a specific LoggerRepository, which it then uses/acts upon. The functionality of the plugin is up to the developer.
Examples of plugins are Receiver and Watchdog. Receiver plugins allow for remote logging events to be received and processed by a repository as if the event was sent locally. Watchdog plugins allow for a repository to be reconfigured when some "watched" configuration data changes.
@author Mark Womack (mwomack@apache.org)
@author Nicko Cadell
@author Paul Smith (psmith@apache.org)
-
org.apache.log4j.plugins.Plugin
Defines the required interface for all Plugin objects.
A plugin implements some specific functionality to extend the log4j framework. Each plugin is associated with a specific LoggerRepository, which it then uses/acts upon. The functionality of the plugin is up to the developer.
Examples of plugins are Receiver and Watchdog. Receiver plugins allow for remote logging events to be received and processed by a repository as if the event was sent locally. Watchdog plugins allow for a repository to be reconfigured when some "watched" configuration data changes.
@author Mark Womack
@author Nicko Cadell
@author Paul Smith
@since 1.3
-
org.apache.logging.log4j.core.config.plugins.Plugin
-
org.apache.maven.archiva.model.Plugin
-
org.apache.maven.artifact.repository.metadata.Plugin
Mapping information for a single plugin within this group.
@version $Revision$ $Date$
-
org.apache.maven.bootstrap.model.Plugin
Describes a dependency.
@version $Id: Plugin.java 332580 2005-11-11 15:05:53Z brett $
-
org.apache.maven.model.Plugin
The <plugin>
element contains informations required for a plugin.
@version $Revision$ $Date$
-
org.apache.maven.plugin.registry.Plugin
Policy for updating a single plugin.
@version $Revision$ $Date$
-
org.apache.qpid.server.model.Plugin
-
org.apache.struts.action.PlugIn
A PlugIn is a configuration wrapper for a module-specific resource or service that needs to be notified about application startup and application shutdown events (corresponding to when the container calls init
and destroy
on the corresponding {@link ActionServlet} instance). PlugIn
objectscan be configured in the struts-config.xml
file, without the need to subclass {@link ActionServlet} simply to perform applicationlifecycle activities.
Implementations of this interface must supply a zero-argument constructor for use by {@link ActionServlet}. Configuration can be accomplished by providing standard JavaBeans property setter methods, which will all have been called before the init()
method is invoked.
This interface can be applied to any class, including an Action subclass.
@version $Rev: 421119 $ $Date: 2005-05-14 01:09:32 -0400 (Sat, 14 May 2005)$
@since Struts 1.1
-
org.bladerunnerjs.plugin.Plugin
oracle.com/javase/tutorial/sound/SPI-intro.html">SPI Mechanism introduced in Java 6), and are constructed using a zero-arg constructor. The {@link #setBRJS setBRJS()} method is used in lieu of a parameterized constructor, and is invoked before any non-
identifier methods(see below).
Because plug-ins form part of the model, yet use the model to initialize themselves, an untenable circular dependency exists. To overcome this problem, each concrete plug-in instance is wrapped inside a virtual proxy that delays plug-in initialization until somebody attempts to actually use the plug-in. Since code interested in interacting with a subset of the plug-ins will often need to query all of them to locate the ones it needs, certain identifier-methods are proxied through before the object's {@link #setBRJS setBRJS()} method has been invoked, which plug-in authors must be aware of.
Another consequence of wrapping all plug-ins in a virtual proxy is that the instanceof
operator and the Object.getClass()
method do not work as expected. The {@link #instanceOf instanceOf()} and {@link #getPluginClass} methods are provided to overcome these deficiencies.
-
org.brickred.socialauth.plugin.Plugin
This interface represents the Plugin. All plugins should be inherited from this interface.
@author tarun.nagpal
-
org.bukkit.plugin.Plugin
Represents a Plugin
The use of {@link PluginBase} is recommended for actual Implementation
-
org.eclipse.core.runtime.Plugin
other initialization } // ... other methods } In the above example, a call to
MyPluginClass.getInstance()
will always return an initialized instance of
MyPluginClass
.
Constructors and life cycle methods
If the plugin.xml of a plug-in indicates <?eclipse version="3.0"?> and its prerequisite list includes org.eclipse.core.runtime
, the default constructor of the plug-in class is used and {@link #start(BundleContext)} and {@link #stop(BundleContext)} arecalled as life cycle methods.
If the plugin.xml of a plug-in indicates <?eclipse version="3.0"?> and its prerequisite list includes org.eclipse.core.runtime.compatibility
, the {@link #Plugin(IPluginDescriptor)}constructor is used and {@link #startup()} and {@link #shutdown()} are called as life cycle methods.Note that in this situation, start() is called before startup() and stop() is called after shutdown.
If the plugin.xml of your plug-in does not indicate <?eclipse version="3.0"?> it is therefore not a 3.0 plug-in. Consequently the {@link #Plugin(IPluginDescriptor)} is used and {@link #startup()} and {@link #shutdown()} are called as life cycle methods.
Since Eclipse 3.0 APIs of the Plugin class can be called only when the Plugin is in an active state, i.e., after it was started up and before it is shutdown. In particular, it means that Plugin APIs should not be called from overrides of {@link #Plugin()}.
-
org.elasticsearch.plugins.Plugin
An extension point allowing to plug in custom functionality.
@author kimchy (shay.banon)
-
org.geotools.validation.PlugIn
fractions.net/docs/Validating_Web_Feature_Server.pdf>A PDF on Validating Web Feature Servers
@source $URL$
-
org.gradle.api.Plugin
A Plugin
represents an extension to Gradle. A plugin applies some configuration to a target object. Usually, this target object is a {@link org.gradle.api.Project}, but plugins can be applied to any type of objects.
@param < T> The type of object which this plugin can configure.
-
org.graylog2.plugin.Plugin
-
org.gudy.azureus2.plugins.Plugin
Defines the plugin interface to implement in order to create a Plugin
@author Olivier
-
org.hotswap.agent.annotation.Plugin
-
org.jboss.forge.shell.plugins.Plugin
A custom {@link Plugin} must implement this interface in order to be detected and installed at framework boot-time.In order to create plugin shell-commands, one must create a method annotated with @ {@link Command}. Any command method parameters to be provided as input through the shell must be individually annotated with the @ {@link Option}annotation; other (non-annotated) command parameters are ignored.
In order to control the name of a custom plugin, the {@link Alias} annotation may be added to any {@link Plugin}type.
Plugin types may be annotated with any of the following constraints in order to ensure proper dependencies are satisfied at runtime: {@link RequiresFacet}, {@link RequiresPackagingType}, {@link RequiresResource}
@author
Lincoln Baxter, III
-
org.jboss.seam.wiki.core.plugin.metamodel.Plugin
Plugin metadata.
@author Christian Bauer
-
org.jivesoftware.openfire.container.Plugin
Plugin interface. Plugins enhance the functionality of Openfire. They can:
- Act as {@link org.xmpp.component.Component Components} to implementadditional features in the XMPP protocol.
- Dynamically modify the admin console.
- Use the Openfire API to add new functionality to the server.
Plugins live in the
plugins directory of
home. Plugins that are packaged as JAR files will be automatically expanded into directories. A plugin directory should have the following structure:
[pluginDir] |-- plugin.xml |-- classes/ |-- lib/
The
classes and
lib directory are optional. Any files in the
classes directory will be added to the classpath of the plugin, as well as any JAR files in the
lib directory. The
plugin.xml file is required, and specifies the className of the Plugin implementation. The XML file should resemble the following XML:
<?xml version="1.0" encoding="UTF-8"?> <plugin> <class>org.example.YourPlugin</class> <name>Example Plugin</name> <description>This is an example plugin.</description> <author>Foo Inc.</author> <version>1.0</version> <minServerVersion>3.0.0</minServerVersion> <licenseType>gpl</licenseType> </plugin>
Each plugin will be loaded in its own class loader, unless the plugin is configured with a parent plugin.
Please see the Plugin Developer Guide (available with the Openfire documentation) for additional details about plugin development.
@author Matt Tucker
-
org.jnode.plugin.Plugin
Abstract plugin class.
@author Ewout Prangsma (epr@users.sourceforge.net)
-
org.joget.plugin.base.Plugin
-
org.jtalks.jcommune.plugin.api.core.Plugin
-
org.molgenis.model.elements.Plugin
-
org.mybatis.generator.api.Plugin
This interface defines methods that will be called at different times during the code generation process. These methods can be used to extend or modify the generated code. Clients may implement this interface in its entirety, or extend the PluginAdapter (highly recommended).
Plugins have a lifecycle. In general, the lifecycle is this:
- The setXXX methods are called one time
- The validate method is called one time
- The initialized method is called for each introspected table
- The clientXXX methods are called for each introspected table
- The providerXXX methods are called for each introspected table
- The modelXXX methods are called for each introspected table
- The sqlMapXXX methods are called for each introspected table
- The contextGenerateAdditionalJavaFiles(IntrospectedTable) method is called for each introspected table
- The contextGenerateAdditionalXmlFiles(IntrospectedTable) method is called for each introspected table
- The contextGenerateAdditionalJavaFiles() method is called one time
- The contextGenerateAdditionalXmlFiles() method is called one time
Plugins are related to contexts - so each context will have its own set of plugins. If the same plugin is specified in multiple contexts, then each context will hold a unique instance of the plugin.
Plugins are called, and initialized, in the same order they are specified in the configuration.
The clientXXX, modelXXX, and sqlMapXXX methods are called by the code generators. If you replace the default code generators with other implementations, these methods may not be called.
@author Jeff Butler
@see PluginAdapter
-
org.openbp.jaspira.plugin.Plugin
Generic interface for plugins. A plugin is an encapsulation for a group of actions, options, and event handling modules.
@author Stephan Moritz
-
org.openxri.plugin.Plugin
Provides interface for extending the functionality of the server to respond to non-XRI specified requests. Provides access to Store object, non-XRI requests, startup, and shutdown of server
@author =chetan
-
org.opoo.press.Plugin
OpooPress Plugin.
@author Alex Lin
-
org.parosproxy.paros.core.scanner.Plugin
This interface must be implemented by a Plugin for running the checks. The AbstractHostPlugin, AbstractAppPlugin, AbstractAppParamPlugin implement this interface and is a good starting point for writing new plugins.
-
org.quorum.vm.interfaces.Plugin
-
org.rhq.core.domain.plugin.Plugin
An agent plugin. This object contains information about the plugin jar itself (e.g. its name and MD5). It may also contain the jar contents ( {@link #getContent()}).
-
org.saiku.service.util.dto.Plugin
Plugin.
-
org.socialmusicdiscovery.server.api.plugin.Plugin
Represents the interface which have to be implemented by all plugins
-
org.sonar.api.Plugin
A plugin is a group of extensions. See
org.sonar.api.Extension
interface to browse available extension points.
The manifest property Plugin-Class
must declare the name of the implementation class. It is automatically set by sonar-packaging-maven-plugin when building plugins.
@see org.sonar.api.Extension
@since 1.10
@deprecated in 2.8. Use {@link SonarPlugin} instead.
-
org.sonar.updatecenter.common.Plugin
-
org.sonar.wsclient.services.Plugin
@since 2.4
-
org.springframework.roo.project.Plugin
Simplified immutable representation of a maven build plugin.
Structured after the model used by Maven.
@author Alan Stewart
@since 1.1
-
org.springsource.ide.eclipse.commons.frameworks.core.internal.plugins.Plugin
Represents a published plugin model, which among other things, contains a list of published versions.
It specifies the latest version of the plugin as it would be installed IF the plugin were installed without specifying a version number. NOTE that this is NOT the same as being the most recent version of the plugin that is available. There may be newer milestone versions available OR newer versions that are only compatible with newer runtimes. Therefore this model provides two API for retrieving new versions:
- The latest version available for the given version of a runtime used by a project. This is the version that is installed if a user installs the plugin WITHOUT specifying a version number.
- The most recent version added, which may be a milestone or only available for newer versions of a runtime, which a user must manually specify when installing the plugin. As the list of versions are ORDERED, the most recent version added version should be the last version that was added to the list.
This model represents both a published plugin as well as an in-place plugin. In-place plugins usually only have one child version (i.e the only version that is available), and this version is considered the latest version.
@author Nieraj Singh
@author Andrew Eisenberg
-
org.syncany.plugins.Plugin
A plugin can be used to store Syncany's repository files on any remote location. Implementations of the
Plugin class identify a storage/transfer plugin.
Using the 'id' attribute, plugins can be loaded by the {@link Plugins} class. Once a plugin is loaded, a corresponding {@link TransferSettings} object must be created and initialized. From the connection object, a {@link TransferManager} can then be used toupload/download files to the repository.
Per naming convention, plugins must end by the name Plugin and extend this class. Furthermore, all plugin classes must reside in a package org.syncany.plugins.plugin-id, where plugin-id is the identifier specified by {@link #getId()}.
@author Philipp C. Heckel
-
plugin.common.Plugin
-
plugins.PluginManager.tools.command.Plugin
Plugin command used to list/load/unload/reload plugins at runtime.
@author Witlospock
@version 1.0
-
resources.digesters.Plugin
Un plug-in es una extensi�n que se puede agregar a EasyBot. Por ejemplo, un robot y todos los componentes que lo conforman, son definidos como plug-ins.
Un plug-in se crea a partir de un documento XML, y de un conjunto de reglas (tambi�n en formato XML) que permiten establecer los datos del estado del plug-in creado.
-
runjettyrun.Plugin
The activator class controls the plug-in life cycle.
@author hillenius