Re: Plugins with GUI

On Fri, 21 Jan 2011 02:42:51 -0800 (PST), Ross <rossclement@gmail.com>
wrote, quoted or indirectly quoted someone who said :


I have plug-ins in an some of my apps. You can see how I handled it
in http://mindprod.com/products1.html#HTMLMACROS

The core code looks like this. You could do it more simply without a
cache.

Each plugin extends the abstract class Macro with an expand method.

 // get the Macro-implementing class instance that will process the
macro.
        // It implements the Macro interface with the expand method.
        // Hopefully already loaded from previous use. Will throw
exception on trouble. Should not return null.
        final Macro macroDelegate =
LoadCodeToProcessMacro.getMacroProcessorInstance( macroName );
        assert macroDelegate != null : "null delegate to process macro
" + macroName;
        // F I N A L L Y ! _ E X P A N D _ T H E _ M A C R O !
        String expansion = macroDelegate.expandMacro( parms,
fileBeingProcessed, quiet, verbose );
 

---------------------------------------------

/*
 * @(#)LoadCodeToProcessMacro.java
 *
 * Summary: Loads code to process a given custom macro.
 *
 * Copyright: (c) 2008-2011 Roedy Green, Canadian Mind Products,
http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any
purpose but military.
 * http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.6+
 *
 * Created with: IntelliJ IDEA IDE.
 *
 * Version History:
 * 1.0 2008-07-26 - initial version. Extract and expand code in
Include and Replacer.
 * Now does cache and looks first in custom package.
 */
/**
 * Loads code to process a given custom macro.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2008-07-26 - initial version. Extract and expand code
in Include and Replacer.
 * Now does cache and looks first in custom package.
 * @since 2008-07-26
 */
package com.mindprod.htmlmacros;

import java.util.HashMap;

/**
 * Loads code to process a given custom macro.
 * <p/>
 * Deals with loading the Class to process a macro, creating a fresh
instance for each time a macro needs to be expanded.
 * It maintains a cache of previously loaded Macro Classes, not Macro
Instances.
 * Used by Include and Replacer only.
 * <p/>
 * created with Intellij Idea
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2008-07-26 initial version. Extract and expand code in
Include and Replacer.
 * Now does cache and looks first in custom package.
 */
class LoadCodeToProcessMacro
    {
    // ------------------------------ CONSTANTS
------------------------------

    /**
     * how many macros max we might load
     */
    private static final int MACRO_CACHE_CAPACITY = 200;

    /**
     * cache of previously loaded Macro processing code classes. We
create a fresh instance for each Macro processed.
     * Look up Class object(not Macro instance) via unqualified macro
name.
     * We could have used the System's cache of loaded classes
accessible via
     * ClassLoader.findLoadedClass(String) but the code would be a tad
more complicated.
     */
    private static final HashMap<String, Class<? extends Macro>>
macroClassCache = new HashMap<String, Class<? extends Macro>>(
MACRO_CACHE_CAPACITY );

    // -------------------------- STATIC METHODS
--------------------------

    /**
     * find class to process macro. Look in three places, cache,
custom package and main package.
     *
     * @param macroName Single word Macro name. Same as class name to
process macro.
     *
     * @return class handle to class to process the macro. Null if
does not exist.
     */
    private static Class<? extends Macro>
    findMacroClass( String macroName )
    {
    Class<? extends Macro> macroClass = getCachedMacroClass( macroName
);
    if ( macroClass != null )
        {
        return macroClass;
        }
    // not in custom package, look in main package.
    return loadMacroClass( macroName, "com.mindprod.htmlmacros" );
    // return with possibly null result.
    }

    /**
     * get class to process macro from cache of previously loaded
classes.
     *
     * @param macroName Single word Macro name. Same as class name to
process macro.
     *
     * @return class handle to class to process the macro. Null if not
in cache.
     */
    private static Class<? extends Macro> getCachedMacroClass( String
macroName )
    {
    return macroClassCache.get( macroName );
    }

    /**
     * get fresh instance of Class to process this macro. May have to
load the class dynamically.
     *
     * @param macroName Single word Macro name. Same as class name to
process macro.
     * Code may live in either
com.mindprod.htmlmacros package or CUSTOM_MACROS_PACKAGE.
     *
     * @return interface handle to instance of the class to process
the macro.
     * @throws InstantiationException if macro class refuses to
Instantiate.
     * @throws IllegalAccessException if class does not have public
access.
     * @throws ClassNotFoundException if code for class cannot be
found or if it does not implement Macro.
     */
    static Macro getMacroProcessorInstance( String macroName ) throws
InstantiationException, IllegalAccessException, ClassNotFoundException
    {
    Class<? extends Macro> macroClass = findMacroClass( macroName );
    if ( macroClass == null )
        {
        if ( !( macroName.length() > 0
                && Character.isUpperCase( macroName.charAt( 0 ) ) ) )
            {
            throw new IllegalArgumentException( "macro "
                                                +
                                                macroName
                                                +
                                                " should start with an
upper case letter. Possible missing macro name." );
            }
        else
            {
            throw new ClassNotFoundException( "No such macro " +
macroName + " or possible coding bug: The code that implements the
Macro interface to process " + macroName + " could not be found." );
            }
        }
    try
        {
        // This cast will fail if the loaded Macro code does not
implement Macro.
        return macroClass.newInstance();
        }
    catch ( ClassCastException e )
        {
        throw new ClassNotFoundException( "Coding bug: The code to
process macro " + macroName + " does not implement the Macro
interface." );
        }
    catch ( InstantiationException e )
        {
        // macro is screwed up if it won't instantiate.
        throw new InstantiationException( "Coding bug: The code to
process macro " + macroName + " would not instantiate. It needs a
public no-arg constructor." );
        }
    catch ( IllegalAccessException e )
        {
        // macro is screwed up if if does not have no-arg public
constructor.
        throw new IllegalAccessException( "Coding bug: The code to
process macro " + macroName + " refused access. It needs a public
no-arg constructor." );
        }
    }

    /**
     * load class to process macro.
     *
     * @param macroName Single word Macro name. Same as class name
to process macro.
     * @param packageName name of package where to look for code for
this Macro class.
     *
     * @return class handle to class to process the macro. Null if
does not exist.
     */
    private static Class<? extends Macro> loadMacroClass( String
macroName, String packageName )
    {
    try
        {
        // e.g. parm to Class.forName looks like:
"com.mindprod.htmlmacros.Measure"
        final String binaryClassName = packageName + "." + macroName;
        // Make sure the class we load implements Macro.
        final Class<? extends Macro> macroClass = Class.forName(
binaryClassName ).asSubclass( Macro.class );
        if ( macroClass != null )
            {
            // save copy of class object for future use.
            macroClassCache.put( macroName, macroClass );
            }
        return macroClass;
        }
    catch ( ClassCastException e )
        {
        // macro is screwed up, but the code exists.
        throw new ClassCastException( "Coding bug: The code to process
macro " + macroName + " refused access. It needs a public no-arg
constructor." );
        }
    catch ( Exception e )
        {
        // might have been ClassNotFoundException,
NoClassDefFoundException
        // Any problem is a failure.
        return null;
        }
    }
    }
--
Roedy Green Canadian Mind Products
http://mindprod.com
To err is human, but to really foul things up requires a computer.
~ Farmer's Almanac
It is breathtaking how a misplaced comma in a computer program can
shred megabytes of data in seconds.