Changeset 7444


Ignore:
Timestamp:
12/20/10 01:25:02 (9 years ago)
Author:
aivar
Message:

Hooking in PluginLinker to PluginComponent. See PluginComponent TODO for issues.

Location:
branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/ComponentFactory.java

    r7440 r7444  
    4646 
    4747        } 
    48         else if (WorkFlow.COMPONENT.equals(tag.getName())) { 
    49             component = new Component(); 
     48        else if (PluginComponent.PLUGIN.equals(tag.getName())) { 
     49            component = new PluginComponent(); 
    5050            component.fromXML(xml); 
    5151        } 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/PluginComponent.java

    r7440 r7444  
    33 * and open the template in the editor. 
    44 */ 
     5//TODO 
     6/* 
     7 * Is the name a short name or the full path, i.e. loci.plugin.Whatever?  Why have a set name? 
     8 * Need to instantiate the plugin. 
     9 * Feeding in the image should work; how to set up listener? 
     10 * How to do the linking?  IComponent could have chain() method, delegates to m_linkedPlugin.  How do WorkFlows get 
     11 * chained? 
     12 */ 
    513 
    614package loci.workflow; 
     
    816import java.util.HashMap; 
    917import java.util.Map; 
    10  
     18import java.util.Set; 
     19 
     20import loci.multiinstanceplugin.AbstractPlugin; 
     21import loci.multiinstanceplugin.ILinkedPlugin; 
     22import loci.multiinstanceplugin.IPlugin; 
     23import loci.multiinstanceplugin.LinkedPlugin; 
     24import loci.multiinstanceplugin.PluginClassException; 
    1125import loci.plugin.ImageWrapper; 
    1226import loci.plugin.annotations.Input; 
    1327import loci.plugin.annotations.Output; 
     28import loci.util.xmllight.XMLException; 
     29import loci.util.xmllight.XMLParser; 
     30import loci.util.xmllight.XMLTag; 
     31import loci.util.xmllight.XMLWriter; 
    1432 
    1533/** 
     
    1735 * @author Aivar Grislis 
    1836 */ 
    19 public class Component implements IComponent { 
     37public class PluginComponent implements IComponent { 
     38    public static final String PLUGIN = "plugin"; 
     39    ILinkedPlugin m_linkedPlugin; 
     40    Set<String> m_inputNames; 
     41    Set<String> m_outputNames; 
     42 
     43 
    2044    String m_name; 
    21     String[] m_inputNames; 
    22     String[] m_outputNames; 
    2345    Map<String, IOutputListener> m_listenerMap = new HashMap<String, IOutputListener>(); 
     46 
     47    public PluginComponent() { 
     48    } 
     49 
     50    /** 
     51     * Create an instance for a given plugin class name. 
     52     * 
     53     * @param pluginClassName 
     54     */ 
     55    public PluginComponent(String pluginClassName) throws PluginClassException { 
     56        init(pluginClassName); 
     57    } 
     58 
     59    /** 
     60     * Create an instance for a given plugin class. 
     61     * 
     62     * @param className 
     63     */ 
     64    public PluginComponent(Class pluginClass) { 
     65        init(pluginClass); 
     66    } 
     67 
     68    /** 
     69     * Initializes given a plugin class name. 
     70     * 
     71     * @param className 
     72     */ 
     73    private void init(String pluginClassName) { 
     74 
     75        // get associated class 
     76        Class pluginClass = null; 
     77        try { 
     78            pluginClass = Class.forName(pluginClassName); 
     79        } 
     80        catch (ClassNotFoundException e) { 
     81            // class cannot be located 
     82            System.out.println("Can't find " + pluginClassName); 
     83        } 
     84        catch (ExceptionInInitializerError e) { 
     85            // initialization provoked by this method fails 
     86            System.out.println("Error initializing " + pluginClassName + " " + e.getStackTrace()); 
     87        } 
     88        catch (LinkageError e) { 
     89            // linkage fails 
     90            System.out.println("Linkage error " + pluginClassName + " " + e.getStackTrace()); 
     91        } 
     92 
     93        // validate class 
     94        boolean success = false; 
     95        if (null != pluginClass) { 
     96            success = true; 
     97 
     98            if (!pluginClass.isAssignableFrom(AbstractPlugin.class)) { 
     99                success = false; 
     100                System.out.println("Plugin should extend AbstractPlugin"); 
     101            } 
     102 
     103            if (!pluginClass.isAssignableFrom(IPlugin.class)) { 
     104                success = false; 
     105                System.out.println("Plugin should implement IPlugin"); 
     106            } 
     107        } 
     108 
     109        if (success) { 
     110            init(pluginClass); 
     111        } 
     112        else { 
     113            throw new PluginClassException("Plugin class is invalid " + pluginClassName); 
     114        } 
     115    } 
     116 
     117    /** 
     118     * Initializes given a plugin class. 
     119     * 
     120     * @param pluginClass 
     121     */ 
     122    private void init(Class pluginClass) { 
     123        m_linkedPlugin = new LinkedPlugin(pluginClass); 
     124        m_inputNames = m_linkedPlugin.getInputNames(); 
     125        m_outputNames = m_linkedPlugin.getOutputNames(); 
     126    } 
    24127 
    25128    /** 
     
    47150     */ 
    48151    public String toXML() { 
    49         return null; 
     152        StringBuilder xmlBuilder = new StringBuilder(); 
     153        XMLWriter xmlHelper = new XMLWriter(xmlBuilder); 
     154 
     155        // add workflow tag and name 
     156        xmlHelper.addTag(PLUGIN); 
     157        xmlHelper.addTagWithContent(WorkFlow.NAME, getName()); 
     158 
     159        // add inputs 
     160        xmlHelper.addTag(WorkFlow.INPUTS); 
     161        for (String name : m_inputNames) { 
     162            xmlHelper.addTag(WorkFlow.INPUT); 
     163            xmlHelper.addTagWithContent(WorkFlow.NAME, name); 
     164            xmlHelper.addEndTag(WorkFlow.INPUT); 
     165        } 
     166        xmlHelper.addEndTag(WorkFlow.INPUTS); 
     167 
     168        // add outputs 
     169        xmlHelper.addTag(WorkFlow.OUTPUTS); 
     170        for (String name : m_outputNames) { 
     171            xmlHelper.addTag(WorkFlow.OUTPUT); 
     172            xmlHelper.addTagWithContent(WorkFlow.NAME, name); 
     173            xmlHelper.addEndTag(WorkFlow.OUTPUT); 
     174        } 
     175        xmlHelper.addEndTag(WorkFlow.OUTPUTS); 
     176 
     177        // end workflow 
     178        xmlHelper.addEndTag(PLUGIN); 
     179 
     180        return xmlBuilder.toString(); 
     181 
    50182    } 
    51183 
     
    57189     */ 
    58190    public boolean fromXML(String xml) { 
    59         return true; 
     191        boolean success = false; 
     192        XMLParser xmlHelper = new XMLParser(); 
     193 
     194        try { 
     195            // handle test tag and name 
     196            // 
     197            // <testcomponent> 
     198            //   <name>A</name> 
     199 
     200            XMLTag tag = xmlHelper.getNextTag(xml); 
     201            if (!PLUGIN.equals(tag.getName())) { 
     202                throw new XMLException("Missing <plugin> tag"); 
     203            } 
     204            xml = tag.getContent(); 
     205            tag = xmlHelper.getNextTag(xml); 
     206            if (!WorkFlow.NAME.equals(tag.getName())) { 
     207                throw new XMLException("Missing <name> for <plugin>"); 
     208            } 
     209            setName(tag.getContent()); 
     210            xml = tag.getRemainder(); 
     211 
     212            // handle inputs 
     213            // 
     214            //  <inputs> 
     215            //    <input> 
     216            //      <name>RED</name> 
     217            //   </input> 
     218            // </inputs> 
     219 
     220            tag = xmlHelper.getNextTag(xml); 
     221            if (!WorkFlow.INPUTS.equals(tag.getName())) { 
     222                throw new XMLException("Missing <inputs> within <plugin>"); 
     223            } 
     224            String inputsXML = tag.getContent(); 
     225            xml = tag.getRemainder(); 
     226            while (!inputsXML.isEmpty()) { 
     227                tag = xmlHelper.getNextTag(inputsXML); 
     228                inputsXML = tag.getRemainder(); 
     229 
     230                if (tag.getName().isEmpty()) { //TODO don't think these are necessary 
     231                    break; 
     232                } 
     233 
     234                if (!WorkFlow.INPUT.equals(tag.getName())) { 
     235                    throw new XMLException("Missing <input> within <inputs>"); 
     236                } 
     237                String inputXML = tag.getContent(); 
     238 
     239                tag = xmlHelper.getNextTag(inputXML); 
     240                inputXML = tag.getRemainder(); 
     241 
     242                if (!WorkFlow.NAME.equals(tag.getName())) { 
     243                    throw new XMLException("Missing <name> within <input>"); 
     244                } 
     245                String inName = tag.getContent(); 
     246 
     247                m_inputNames.add(inName); 
     248            } 
     249 
     250            // handle outputs 
     251            //  <outputs> 
     252            //    <output> 
     253            //      <name>OUTPUT</name> 
     254            //    </output> 
     255            //  </outputs> 
     256            tag = xmlHelper.getNextTag(xml); 
     257            if (!WorkFlow.OUTPUTS.equals(tag.getName())) { 
     258                throw new XMLException("Missing <outputs> within <plugin>"); 
     259            } 
     260            String outputsXML = tag.getContent(); 
     261            xml = tag.getRemainder(); 
     262            while (!outputsXML.isEmpty()) { 
     263                tag = xmlHelper.getNextTag(outputsXML); 
     264                outputsXML = tag.getRemainder(); 
     265 
     266                if (tag.getName().isEmpty()) { //TODO don't think these are necessary 
     267                    break; 
     268                } 
     269 
     270                if (!WorkFlow.OUTPUT.equals(tag.getName())) { 
     271                    throw new XMLException("Missing <output> within <outputs>"); 
     272                } 
     273                String outputXML = tag.getContent(); 
     274 
     275                tag = xmlHelper.getNextTag(outputXML); 
     276                outputXML = tag.getRemainder(); 
     277 
     278                if (!WorkFlow.NAME.equals(tag.getName())) { 
     279                    throw new XMLException("Missing <name> within <output>"); 
     280                } 
     281                String outName = tag.getContent(); 
     282                m_outputNames.add(outName); 
     283            } 
     284            success = true; 
     285        } 
     286        catch (XMLException e) { 
     287            System.out.println("XML Exception"); 
     288        } 
     289        return success; 
    60290    } 
    61291 
     
    66296     */ 
    67297    public String[] getInputNames() { 
    68         return m_inputNames; 
     298        return m_inputNames.toArray(new String[0]); 
    69299    } 
    70300 
     
    75305     */ 
    76306    public String[] getOutputNames() { 
    77         return m_outputNames; 
     307        return m_outputNames.toArray(new String[0]); 
    78308    } 
    79309 
     
    94324     */ 
    95325    public void input(ImageWrapper image, String name) { 
    96  
     326        m_linkedPlugin.externalPut(name, image); //TODO inconsistency! 
    97327    } 
    98328 
     
    114344    public void setOutputListener(String name, IOutputListener listener) { 
    115345        m_listenerMap.put(name, listener); 
     346        //TODO hook up the listener 
    116347    } 
    117348 
Note: See TracChangeset for help on using the changeset viewer.