Package org.barrelorgandiscovery.extensions

provide a Plugin Capability to the framework.

See: Description

Interface Summary

Interface	Description
ExtensionFactory
ExtensionPoint
IExtension	Extension Definition (for adding external functionnalities in APrint or other software)
IExtensionName	The Interface IExtensionName define a smart naming of an extension (with a version)
IExtensionPoint	Marking interface for extension points

Class Summary

Class	Description
ChildFirstClassLoader	Class loader for providing child class first loading
ClassLoaderExtensionFactory
ExtensionManager	Class for managing extensions
ExtensionPointProvider	Helper class for providing an extension point in an application development
ExtensionRepository	This class manage a repository of extensions, by reading an xml containing all the extension in the repository
JarExtensionFactory	A factory for creating Extension objects from jar files contained in a folder.
SimpleExtensionPoint

Package org.barrelorgandiscovery.extensions Description

provide a Plugin Capability to the framework. This permit to implement new functionnalities when the application permit it. It drastically simplify the functionalities implementation and reduce the amount of knowledge to do it.

Extension first point are a class implementing IExtension interface, this interface define :

- a name to the plugin.
- a list of extension points

Extension Points:

Extension point are entry points that can be used by the main application to call the plugin when needed. Extension Point is defined by the ExtensionPoint interface, this contain :
- a TypeID (type java interface type)
- a pointer to the interface that provide the entry point


a bag implementation of an entry point is proposed in the SeimplExtensionPoint class (taking type typeid and pointer in the constructor)

Extension Point Example

Here is an example of the usage of the extension point in a plugin example ...

Implementing an Extension Point

public class AdvancedImporterExtension implements IExtension,
                ImportersExtensionPoint, InformRepositoryExtensionPoint {

        private static Logger logger = Logger
                        .getLogger(AdvancedImporterExtension.class);

        public AdvancedImporterExtension() {
                logger.debug("AdvancedImporterExtension");
        }

        public ExtensionPoint[] getExtensionPoints() {
                return new ExtensionPoint[] {
                                new SimpleExtensionPoint(ImportersExtensionPoint.class, this),
                                new SimpleExtensionPoint(InformRepositoryExtensionPoint.class,
                                                this) };
        }

        public String getName() {
                return "Advanced Midi Importer";
        }

        public ArrayList<AbstractMidiImporter> getExtensionImporterInstance(
                        Scale destinationscale) {

                logger.debug("getExtensionImporterInstance");

                // get midi correspondance ...
                if (rep == null) {
                        logger.warn("Rep is null ...");
                        return null;
                }

                Scale gmidi = Scale.getGammeMidiInstance();
                ArrayList trans = rep.getTranspositionManager()
                                .findTransposition(gmidi, destinationscale);

                if (trans == null || trans.size() == 0) {
                        logger.warn("no midi transposition for " + destinationscale);
                        return null;
                }

                if (!(trans.get(0) instanceof LinearTransposition))
                {
                        logger.warn ("transposition is not a linear one");
                        return null;
                }
                LinearTransposition lt = (LinearTransposition)trans.get(0);

                ArrayList<AbstractMidiImporter> l = new ArrayList<AbstractMidiImporter>();
                l.add(new TranslatorImporter(destinationscale, lt));

                return l;
        }

        private Repository rep = null;

        public void informRepository(Repository repository) {
                this.rep = repository;
        }

In this example, the plugin provide two extension points, one for getting a repository reference from the main application (the InformRepositoryExtensionPoint interface), and one for proposing a new importer. (thanks to the ImportersExtensionPoint interface)

Using a plugin Extension Point

on the main application side, the usage of the ExtensionManager help a lot. This Class manage an Extension array of all the plugins loaded with the application. so in the main application, we have an ExtensionManager member

private ExtensionManager extm;

this member is initialized some where in the application.


When you want to call a plugin capability, do it that way :

InitExtensionPoint[] allInitPoints = ExtensionPointProvider
                                .getAllPoints(InitExtensionPoint.class, extm.getExtensions());
                for (int i = 0; i < allInitPoints.length; i++) {
                        InitExtensionPoint init = allInitPoints[i];
                        init.init(this);
                }

ExtensionPointProvider is a helper class that filter the ExtensionPoint by type and automatically cast in with the proper interface