Changeset 7495


Ignore:
Timestamp:
01/10/11 16:14:14 (9 years ago)
Author:
aivar
Message:

Added proper ComponentFactory. Renamed chain -> wire, component -> module.

Location:
branches/maven/projects/deep-zoom-plugin/src
Files:
1 added
1 deleted
8 edited
1 copied
3 moved

Legend:

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

    r7444 r7495  
    66package loci.workflow; 
    77 
    8 import loci.util.xmllight.XMLParser; 
    9 import loci.util.xmllight.XMLException; 
    10 import loci.util.xmllight.XMLTag; 
    11  
    128/** 
    139 * 
    14  * @author Aivar Grislis 
     10 * @author aivar 
    1511 */ 
    16 public class ComponentFactory { 
    17     private static ComponentFactory s_instance; 
    18      
     12public class ComponentFactory implements IModuleFactory { 
     13    private static ComponentFactory s_instance = null; 
     14 
    1915    private ComponentFactory() { 
    2016    } 
    2117 
    22     /** 
    23      * Gets singleton instance. 
    24      * 
    25      * @return instance 
    26      */ 
    2718    public static synchronized ComponentFactory getInstance() { 
    2819        if (null == s_instance) { 
     
    3829     * @return 
    3930     */ 
    40     public static IComponent create(String xml) throws XMLException { 
    41         IComponent component = null; 
    42         XMLParser xmlHelper = new XMLParser(); 
    43         XMLTag tag = xmlHelper.getNextTag(xml); 
    44         if (WorkFlow.WORKFLOW.equals(tag.getName())) { 
    45             component = WorkFlowFactory.getInstance().create(xml); 
    46  
    47         } 
    48         else if (PluginComponent.PLUGIN.equals(tag.getName())) { 
    49             component = new PluginComponent(); 
    50             component.fromXML(xml); 
    51         } 
    52         else { 
    53             throw new XMLException("Invalid tag " + tag.getName()); 
    54         } 
     31    public IModule create(String xml) { 
     32        Component component = new Component(); 
     33        component.fromXML(xml); 
    5534        return component; 
    5635    } 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/IModule.java

    r7440 r7495  
    1212 * @author Aivar Grislis 
    1313 */ 
    14 public interface IComponent { 
     14public interface IModule { 
    1515 
    1616    /** 
    17      * Gets name of component. 
     17     * Gets name of module. 
    1818     * 
    1919     * @return 
     
    2222 
    2323    /** 
    24      * Sets name of component. 
     24     * Sets name of module. 
    2525     * 
    2626     * @param name 
     
    2929 
    3030    /** 
    31      * Saves component as XML string representation. 
     31     * Saves module as XML string representation. 
    3232     * 
    3333     * @return 
     
    3636 
    3737    /** 
    38      * Restores component from XML string representation. 
     38     * Restores module from XML string representation. 
    3939     * 
    4040     * @param xml 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/IModuleFactory.java

    r7440 r7495  
    1212 * @author Aivar Grislis 
    1313 */ 
    14 public interface IComponentFactory { 
     14public interface IModuleFactory { 
    1515 
    1616    /** 
    17      * Creates a component from XML. 
     17     * Creates a module from XML. 
    1818     * 
    1919     * @param xml 
    2020     * @return 
    2121     */ 
    22     public IComponent create(String xml) throws XMLException; 
     22    public IModule create(String xml) throws XMLException; 
    2323} 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/IWorkFlow.java

    r7440 r7495  
    1212 * Building a workflow should take place in three phases: 
    1313 *   I.    Add components 
    14  *   II.   Chain components together 
    15  *   III.  Chain workflow inputs and outputs. 
     14 *   II.   Wire components together 
     15 *   III.  Wire workflow inputs and outputs 
     16 *           -or- 
     17 *   III.  Finalize: leftover inputs and outputs become workflow inputs and outputs 
    1618 * 
    1719 * @author Aivar Grislis 
    1820 */ 
    19 public interface IWorkFlow extends IComponent { 
     21public interface IWorkFlow extends IModule { 
    2022 
    2123    /** 
     
    2426     * @param component 
    2527     */ 
    26     void add(IComponent component); 
     28    void add(IModule component); 
    2729 
    2830    /** 
     
    3335     * @param dest 
    3436     */ 
    35     void chain(IComponent source, IComponent dest); 
     37    void wire(IModule source, IModule dest); 
    3638 
    3739    /** 
     
    4345     * @param dest 
    4446     */ 
    45     void chain(IComponent source, String sourceName, IComponent dest); 
     47    void wire(IModule source, String sourceName, IModule dest); 
    4648 
    4749    /** 
     
    5355     * @param destName 
    5456     */ 
    55     void chain(IComponent source, IComponent dest, String destName); 
     57    void wire(IModule source, IModule dest, String destName); 
    5658 
    5759    /** 
     
    6466     * @param destName 
    6567     */ 
    66     void chain(IComponent source, String sourceName, IComponent dest, String destName); 
     68    void wire(IModule source, String sourceName, IModule dest, String destName); 
    6769 
    6870    /** 
     
    7173     * @return array of chains 
    7274     */ 
    73     Chain[] getChains(); 
     75    Wire[] getWires(); 
     76 
     77    /** 
     78     * Leftover, un-wired module inputs and outputs become workflow inputs and 
     79     * outputs. 
     80     */ 
     81    void finalize(); 
    7482 
    7583    /** 
     
    7987     * @param dest 
    8088     */ 
    81     void chainInput(IComponent dest); 
     89    void wireInput(IModule dest); 
    8290 
    8391    /** 
     
    8896     * @param destName 
    8997     */ 
    90     void chainInput(IComponent dest, String destName); 
     98    void wireInput(IModule dest, String destName); 
    9199 
    92100    /** 
     
    97105     * @param dest 
    98106     */ 
    99     void chainInput(String inName, IComponent dest); 
     107    void wireInput(String inName, IModule dest); 
    100108 
    101109    /** 
     
    107115     * @param destName 
    108116     */ 
    109     void chainInput(String inName, IComponent dest, String destName); 
     117    void wireInput(String inName, IModule dest, String destName); 
    110118 
    111119    /** 
     
    115123     * @param source 
    116124     */ 
    117     void chainOutput(IComponent source); 
     125    void wireOutput(IModule source); 
    118126 
    119127    /** 
     
    124132     * @param sourceName 
    125133     */ 
    126     void chainOutput(IComponent source, String sourceName); 
     134    void wireOutput(IModule source, String sourceName); 
    127135 
    128136    /** 
     
    133141     * @param source 
    134142     */ 
    135     void chainOutput(String outName, IComponent source); 
     143    void wireOutput(String outName, IModule source); 
    136144 
    137145    /** 
     
    143151     * @param sourceName 
    144152     */ 
    145     void chainOutput(String outName, IComponent source, String sourceName); 
     153    void wireOutput(String outName, IModule source, String sourceName); 
    146154 
    147155    /** 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/ModuleFactory.java

    r7440 r7495  
    1414 * @author Aivar Grislis 
    1515 */ 
    16 public class ComponentFactory { 
    17     private static ComponentFactory s_instance; 
     16public class ModuleFactory { 
     17    private static ModuleFactory s_instance; 
    1818     
    19     private ComponentFactory() { 
     19    private ModuleFactory() { 
    2020    } 
    2121 
     
    2525     * @return instance 
    2626     */ 
    27     public static synchronized ComponentFactory getInstance() { 
     27    public static synchronized ModuleFactory getInstance() { 
    2828        if (null == s_instance) { 
    29             s_instance = new ComponentFactory(); 
     29            s_instance = new ModuleFactory(); 
    3030        } 
    3131        return s_instance; 
     
    3838     * @return 
    3939     */ 
    40     public static IComponent create(String xml) throws XMLException { 
    41         IComponent component = null; 
     40    public static IModule create(String xml) throws XMLException { 
     41        IModule module = null; 
    4242        XMLParser xmlHelper = new XMLParser(); 
    4343        XMLTag tag = xmlHelper.getNextTag(xml); 
    4444        if (WorkFlow.WORKFLOW.equals(tag.getName())) { 
    45             component = WorkFlowFactory.getInstance().create(xml); 
     45            module = WorkFlowFactory.getInstance().create(xml); 
    4646 
    4747        } 
    48         else if (WorkFlow.COMPONENT.equals(tag.getName())) { 
    49             component = new Component(); 
    50             component.fromXML(xml); 
     48        else if (Component.COMPONENT.equals(tag.getName())) { 
     49            module = ComponentFactory.getInstance().create(xml); 
    5150        } 
    5251        else { 
    5352            throw new XMLException("Invalid tag " + tag.getName()); 
    5453        } 
    55         return component; 
     54        return module; 
    5655    } 
    5756} 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/PluginComponent.java

    r7444 r7495  
    3535 * @author Aivar Grislis 
    3636 */ 
    37 public class PluginComponent implements IComponent { 
     37public class PluginComponent implements IModule { 
    3838    public static final String PLUGIN = "plugin"; 
    3939    ILinkedPlugin m_linkedPlugin; 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/Wire.java

    r7440 r7495  
    1111 * @author Aivar Grislis 
    1212 */ 
    13 public class Chain { 
    14     final IComponent m_source; 
     13public class Wire { 
     14    final IModule m_source; 
    1515    final String m_sourceName; 
    16     final IComponent m_dest; 
     16    final IModule m_dest; 
    1717    final String m_destName; 
    1818 
    19     Chain(IComponent source, String sourceName, IComponent dest, String destName) { 
     19    Wire(IModule source, String sourceName, IModule dest, String destName) { 
    2020        m_source = source; 
    2121        m_sourceName = sourceName; 
     
    2424    } 
    2525 
    26     IComponent getSource() { 
     26    IModule getSource() { 
    2727        return m_source; 
    2828    } 
     
    3232    } 
    3333 
    34     IComponent getDest() { 
     34    IModule getDest() { 
    3535        return m_dest; 
    3636    } 
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/WorkFlow.java

    r7440 r7495  
    2626 * @author Aivar Grislis 
    2727 */ 
    28 public class WorkFlow implements IComponent, IWorkFlow { 
     28public class WorkFlow implements IModule, IWorkFlow { 
    2929    public static final String WORKFLOW = "workflow"; 
    3030    public static final String NAME = "name"; 
    31     public static final String COMPONENTS = "components"; 
    32     public static final String COMPONENT = "component"; 
    33     public static final String CHAINS = "chains"; 
    34     public static final String CHAIN = "chain"; 
    35     public static final String DEST = "dest"; 
     31    public static final String MODULES = "modules"; 
     32    public static final String MODULE = "module"; 
     33    public static final String WIRES = "wires"; 
     34    public static final String WIRE = "wire"; 
     35    public static final String DST = "dst"; 
    3636    public static final String SRC = "src"; 
    3737    public static final String INPUTS = "inputs"; 
     
    4040    public static final String OUTPUT = "output"; 
    4141 
    42     static IComponentFactory s_componentFactory; 
     42    static IModuleFactory s_moduleFactory; 
    4343    String m_name; 
    44     Map<String, IComponent> m_componentMap = new HashMap<String, IComponent>(); 
     44    Map<String, IModule> m_moduleMap = new HashMap<String, IModule>(); 
    4545    List<String> m_inputNames = new ArrayList<String>(); 
    4646    List<String> m_outputNames = new ArrayList<String>(); 
    47     List<Chain> m_chains = new ArrayList<Chain>(); 
    48     Map<String, IComponent> m_inputComponents = new HashMap<String, IComponent>(); 
    49     Map<String, String> m_inputComponentNames = new HashMap<String, String>(); 
     47    List<Wire> m_wires = new ArrayList<Wire>(); 
     48    Map<String, IModule> m_inputModules = new HashMap<String, IModule>(); 
     49    Map<String, String> m_inputModuleNames = new HashMap<String, String>(); 
    5050    Map<String, IOutputListener> m_listeners = new HashMap<String, IOutputListener>(); 
    51     Map<String, IComponent> m_outputComponents = new HashMap<String, IComponent>(); 
    52     Map<String, String> m_outputComponentNames = new HashMap<String, String>(); 
     51    Map<String, IModule> m_outputModules = new HashMap<String, IModule>(); 
     52    Map<String, String> m_outputModuleNames = new HashMap<String, String>(); 
    5353    IOutputListener m_listener = new OutputListener(); 
    5454    Object m_synchObject = new Object(); 
     
    7070    } 
    7171 
    72     public void setComponentFactory(IComponentFactory componentFactory) { 
    73         System.out.println("in set component factory"); 
    74         s_componentFactory = componentFactory; 
    75         if (s_componentFactory == null) { 
    76             System.out.println("its null"); 
    77         } 
     72    public void setModuleFactory(IModuleFactory moduleFactory) { 
     73        s_moduleFactory = moduleFactory; 
    7874    } 
    7975 
     
    10096            xml = tag.getRemainder(); 
    10197             
    102             // handle components 
     98            // handle modules 
    10399            // 
    104             //  <components> 
    105             //    <component> 
     100            //  <modules> 
     101            //    <module> 
    106102            //      <name>A</name> 
    107103            //      <testA>whatever</testA> 
    108             //    </component> 
    109             //    <component> 
     104            //    </module> 
     105            //    <module> 
    110106            //      <name>B</name> 
    111107            //      <testB>whatever</testB> 
    112             //    </component> 
    113             //  </components> 
     108            //    </module> 
     109            //  </modules> 
    114110 
    115111            tag = xmlHelper.getNextTag(xml); 
    116             if (!COMPONENTS.equals(tag.getName())) { 
    117                 throw new XMLException("Missing <components> for <workflow>"); 
    118             } 
    119             String componentsXML = tag.getContent(); 
     112            if (!MODULES.equals(tag.getName())) { 
     113                throw new XMLException("Missing <modules> for <workflow>"); 
     114            } 
     115            String modulesXML = tag.getContent(); 
    120116            xml = tag.getRemainder(); 
    121             while (!componentsXML.isEmpty()) { 
    122                 tag = xmlHelper.getNextTag(componentsXML); 
    123                 componentsXML = tag.getRemainder(); 
     117            while (!modulesXML.isEmpty()) { 
     118                tag = xmlHelper.getNextTag(modulesXML); 
     119                modulesXML = tag.getRemainder(); 
    124120 
    125121                if (tag.getName().isEmpty()) { 
    126122                    break; 
    127123                } 
    128                 if (!COMPONENT.equals(tag.getName())) { 
    129                     throw new XMLException("Missing <component> within <components>"); 
    130                 } 
    131                 String componentXML = tag.getContent(); 
    132                 tag = xmlHelper.getNextTag(componentXML); 
     124                if (!MODULE.equals(tag.getName())) { 
     125                    throw new XMLException("Missing <module> within <modules>"); 
     126                } 
     127                String moduleXML = tag.getContent(); 
     128                tag = xmlHelper.getNextTag(moduleXML); 
    133129                if (!NAME.equals(tag.getName())) { 
    134                     throw new XMLException("Missing <name> within <component>"); 
    135                 } 
    136                 System.out.println("component XML is [" + tag.getRemainder() + "]"); 
    137                 if (null == s_componentFactory) { 
    138                     System.out.println("Component Factory is null"); 
    139                 } 
    140                 IComponent component = s_componentFactory.create(tag.getRemainder()); 
    141                 add(component); 
    142             } 
    143  
    144             // handle chains 
     130                    throw new XMLException("Missing <name> within <module>"); 
     131                } 
     132                System.out.println("module XML is [" + tag.getRemainder() + "]"); 
     133                if (null == s_moduleFactory) { 
     134                    System.out.println("Module Factory is null"); 
     135                } 
     136                IModule module = s_moduleFactory.create(tag.getRemainder()); 
     137                add(module); 
     138            } 
     139 
     140            // handle wires 
    145141            // 
    146             //  <chains> 
    147             //    <chain> 
     142            //  <wires> 
     143            //    <wire> 
    148144            //      <src> 
    149             //        <component>A</component> 
     145            //        <module>A</module> 
    150146            //        <name>OUTPUT</name> 
    151147            //      </src> 
    152             //      <dest> 
    153             //        <component>B</component> 
     148            //      <dst> 
     149            //        <module>B</module> 
    154150            //        <name>INPUT</name> 
    155             //      </dest> 
    156             //    </chain> 
    157             //  </chains> 
     151            //      </dst> 
     152            //    </wire> 
     153            //  </wires> 
    158154 
    159155            tag = xmlHelper.getNextTag(xml); 
    160             if (!CHAINS.equals(tag.getName())) { 
    161                 throw new XMLException("Missing <chains> within <workflow>"); 
    162             } 
    163             String chainsXML = tag.getContent(); 
     156            if (!WIRES.equals(tag.getName())) { 
     157                throw new XMLException("Missing <wires> within <workflow>"); 
     158            } 
     159            String wiresXML = tag.getContent(); 
    164160            xml = tag.getRemainder(); 
    165             while (!chainsXML.isEmpty()) { 
    166                 tag = xmlHelper.getNextTag(chainsXML); 
    167                 chainsXML = tag.getRemainder(); 
     161            while (!wiresXML.isEmpty()) { 
     162                tag = xmlHelper.getNextTag(wiresXML); 
     163                wiresXML = tag.getRemainder(); 
    168164 
    169165                if (tag.getName().isEmpty()) { 
    170166                    break; 
    171167                } 
    172                 if (!CHAIN.equals(tag.getName())) { 
    173                     throw new XMLException("Missing <chain> within <chains>"); 
    174                 } 
    175                 String chainXML = tag.getContent(); 
    176                 tag = xmlHelper.getNextTag(chainXML); 
    177                 chainXML = tag.getRemainder(); 
     168                if (!WIRE.equals(tag.getName())) { 
     169                    throw new XMLException("Missing <wire> within <wires>"); 
     170                } 
     171                String wireXML = tag.getContent(); 
     172                tag = xmlHelper.getNextTag(wireXML); 
     173                wireXML = tag.getRemainder(); 
    178174                if (!SRC.equals(tag.getName())) { 
    179                     throw new XMLException("Missing <src> within <chain>"); 
     175                    throw new XMLException("Missing <src> within <wire>"); 
    180176                } 
    181177                String srcXML = tag.getContent(); 
    182                 ComponentAndName srcCAN = parseComponentAndName(xmlHelper, srcXML); 
     178                ModuleAndName srcCAN = parseModuleAndName(xmlHelper, srcXML); 
    183179                 
    184                 tag = xmlHelper.getNextTag(chainXML); 
    185                 if (!DEST.equals(tag.getName())) { 
    186                     throw new XMLException("Missing <dest> within <chain>"); 
     180                tag = xmlHelper.getNextTag(wireXML); 
     181                if (!DST.equals(tag.getName())) { 
     182                    throw new XMLException("Missing <dst> within <wire>"); 
    187183                } 
    188184                String dstXML = tag.getContent(); 
    189                 ComponentAndName dstCAN = parseComponentAndName(xmlHelper, dstXML); 
    190  
    191                 // do the chaining 
    192                 chain(srcCAN.getComponent(), srcCAN.getName(), dstCAN.getComponent(), dstCAN.getName()); 
     185                ModuleAndName dstCAN = parseModuleAndName(xmlHelper, dstXML); 
     186 
     187                // do the wiring 
     188                wire(srcCAN.getModule(), srcCAN.getName(), dstCAN.getModule(), dstCAN.getName()); 
    193189            } 
    194190             
     
    198194            //    <input> 
    199195            //      <name>RED</name> 
    200             //      <dest> 
    201             //        <component>A</component> 
     196            //      <dst> 
     197            //        <module>A</module> 
    202198            //        <name>ONE</name> 
    203             //      </dest> 
     199            //      </dst> 
    204200            //   </input> 
    205201            // </inputs> 
     
    233229 
    234230                tag = xmlHelper.getNextTag(inputXML); 
    235                 if (!DEST.equals(tag.getName())) { 
     231                if (!DST.equals(tag.getName())) { 
    236232                    throw new XMLException("Missing <dest> within <input>"); 
    237233                } 
    238234                String destXML = tag.getContent(); 
    239                 ComponentAndName destCAN = parseComponentAndName(xmlHelper, destXML); 
    240  
    241                 chainInput(inName, destCAN.getComponent(), destCAN.getName()); 
     235                ModuleAndName destCAN = parseModuleAndName(xmlHelper, destXML); 
     236 
     237                wireInput(inName, destCAN.getModule(), destCAN.getName()); 
    242238            } 
    243239 
     
    248244            //      <name>OUTPUT</name> 
    249245            //      <src> 
    250             //        <component>B</component> 
     246            //        <module>B</module> 
    251247            //        <name>OUTPUT</name> 
    252248            //      </src> 
     
    285281                } 
    286282                String srcXML = tag.getContent(); 
    287                 ComponentAndName srcCAN = parseComponentAndName(xmlHelper, srcXML); 
    288  
    289                 chainOutput(outName, srcCAN.getComponent(), srcCAN.getName()); 
     283                ModuleAndName srcMAN = parseModuleAndName(xmlHelper, srcXML); 
     284 
     285                wireOutput(outName, srcMAN.getModule(), srcMAN.getName()); 
    290286            } 
    291287            success = true; 
     
    297293    } 
    298294     
    299     private ComponentAndName parseComponentAndName(XMLParser xmlHelper, String xml) throws XMLException { 
     295    private ModuleAndName parseModuleAndName(XMLParser xmlHelper, String xml) throws XMLException { 
    300296        XMLTag tag = xmlHelper.getNextTag(xml); 
    301         if (!COMPONENT.equals(tag.getName())) { 
     297        if (!MODULE.equals(tag.getName())) { 
    302298            throw new XMLException("Missing <component> tag"); 
    303299        } 
    304         String componentName = tag.getContent(); 
     300        String moduleName = tag.getContent(); 
    305301        xml = tag.getRemainder(); 
    306302        tag = xmlHelper.getNextTag(xml); 
     
    310306        String name = tag.getContent(); 
    311307 
    312         return new ComponentAndName(m_componentMap.get(componentName), name); 
     308        return new ModuleAndName(m_moduleMap.get(moduleName), name); 
    313309    } 
    314310 
     
    321317        xmlHelper.addTagWithContent(NAME, getName()); 
    322318 
    323         // add components 
    324         xmlHelper.addTag(COMPONENTS); 
    325         for (String name: m_componentMap.keySet()) { 
    326             xmlHelper.addTag(COMPONENT); 
     319        // add modules 
     320        xmlHelper.addTag(MODULES); 
     321        for (String name: m_moduleMap.keySet()) { 
     322            xmlHelper.addTag(MODULE); 
    327323            xmlHelper.addTagWithContent(NAME, name); 
    328             String componentXML = m_componentMap.get(name).toXML(); 
    329             xmlHelper.add(m_componentMap.get(name).toXML()); 
    330             xmlHelper.addEndTag(COMPONENT); 
    331         } 
    332         xmlHelper.addEndTag(COMPONENTS); 
    333  
    334         // add chains 
    335         xmlHelper.addTag(CHAINS); 
    336         for (Chain chain: m_chains) { 
    337             xmlHelper.addTag(CHAIN); 
     324            String moduleXML = m_moduleMap.get(name).toXML(); 
     325            xmlHelper.add(moduleXML); 
     326            xmlHelper.addEndTag(MODULE); 
     327        } 
     328        xmlHelper.addEndTag(MODULES); 
     329 
     330        // add wires 
     331        xmlHelper.addTag(WIRES); 
     332        for (Wire wire: m_wires) { 
     333            xmlHelper.addTag(WIRE); 
    338334            xmlHelper.addTag(SRC); 
    339             xmlHelper.addTagWithContent(COMPONENT, chain.getSource().getName()); 
    340             xmlHelper.addTagWithContent(NAME, chain.getSourceName()); 
     335            xmlHelper.addTagWithContent(MODULE, wire.getSource().getName()); 
     336            xmlHelper.addTagWithContent(NAME, wire.getSourceName()); 
    341337            xmlHelper.addEndTag(SRC); 
    342             xmlHelper.addTag(DEST); 
    343             xmlHelper.addTagWithContent(COMPONENT, chain.getDest().getName()); 
    344             xmlHelper.addTagWithContent(NAME, chain.getDestName()); 
    345             xmlHelper.addEndTag(DEST); 
    346             xmlHelper.addEndTag(CHAIN); 
    347         } 
    348         xmlHelper.addEndTag(CHAINS); 
     338            xmlHelper.addTag(DST); 
     339            xmlHelper.addTagWithContent(MODULE, wire.getDest().getName()); 
     340            xmlHelper.addTagWithContent(NAME, wire.getDestName()); 
     341            xmlHelper.addEndTag(DST); 
     342            xmlHelper.addEndTag(WIRE); 
     343        } 
     344        xmlHelper.addEndTag(WIRES); 
    349345 
    350346        // add inputs 
     
    353349            xmlHelper.addTag(INPUT); 
    354350            xmlHelper.addTagWithContent(NAME, name); 
    355             xmlHelper.addTag(DEST); 
    356             xmlHelper.addTagWithContent(COMPONENT, m_inputComponents.get(name).getName()); 
    357             xmlHelper.addTagWithContent(NAME, m_inputComponentNames.get(name)); 
    358             xmlHelper.addEndTag(DEST); 
     351            xmlHelper.addTag(DST); 
     352            xmlHelper.addTagWithContent(MODULE, m_inputModules.get(name).getName()); 
     353            xmlHelper.addTagWithContent(NAME, m_inputModuleNames.get(name)); 
     354            xmlHelper.addEndTag(DST); 
    359355            xmlHelper.addEndTag(INPUT); 
    360356        } 
     
    367363            xmlHelper.addTagWithContent(NAME, name); 
    368364            xmlHelper.addTag(SRC); 
    369             xmlHelper.addTagWithContent(COMPONENT, m_outputComponents.get(name).getName()); 
    370             xmlHelper.addTagWithContent(NAME, m_outputComponentNames.get(name)); 
     365            xmlHelper.addTagWithContent(MODULE, m_outputModules.get(name).getName()); 
     366            xmlHelper.addTagWithContent(NAME, m_outputModuleNames.get(name)); 
    371367            xmlHelper.addEndTag(SRC); 
    372368            xmlHelper.addEndTag(OUTPUT); 
     
    380376    } 
    381377 
    382     public void add(IComponent component) { 
    383         m_componentMap.put(component.getName(), component); 
    384     } 
    385  
    386     public void chain(IComponent source, IComponent dest) { 
    387         chain(source, Output.DEFAULT, dest, Input.DEFAULT); 
    388     } 
    389  
    390     public void chain(IComponent source, String sourceName, IComponent dest) { 
    391         chain(source, sourceName, dest, Input.DEFAULT); 
    392     } 
    393  
    394     public void chain(IComponent source, IComponent dest, String destName) { 
    395         chain(source, Output.DEFAULT, dest, destName); 
    396     } 
    397  
    398     public void chain(IComponent source, String sourceName, IComponent dest, String destName) { 
    399         Chain chain = new Chain(source, sourceName, dest, destName); 
    400         m_chains.add(chain); 
    401     } 
    402  
    403     public Chain[] getChains() { 
    404         return m_chains.toArray(new Chain[0]); 
    405     } 
    406  
    407     public void chainInput(IComponent dest) { 
    408         chainInput(Input.DEFAULT, dest, Input.DEFAULT); 
    409     } 
    410  
    411     public void chainInput(IComponent dest, String destName) { 
    412         chainInput(Input.DEFAULT, dest, destName); 
    413     } 
    414  
    415     public void chainInput(String inName, IComponent dest) { 
    416         chainInput(inName, dest, Input.DEFAULT); 
    417     } 
    418  
    419     public void chainInput(String inName, IComponent dest, String destName) { 
     378    public void add(IModule component) { 
     379        m_moduleMap.put(component.getName(), component); 
     380    } 
     381 
     382    public void wire(IModule source, IModule dest) { 
     383        wire(source, Output.DEFAULT, dest, Input.DEFAULT); 
     384    } 
     385 
     386    public void wire(IModule source, String sourceName, IModule dest) { 
     387        wire(source, sourceName, dest, Input.DEFAULT); 
     388    } 
     389 
     390    public void wire(IModule source, IModule dest, String destName) { 
     391        wire(source, Output.DEFAULT, dest, destName); 
     392    } 
     393 
     394    public void wire(IModule source, String sourceName, IModule dest, String destName) { 
     395        Wire wire = new Wire(source, sourceName, dest, destName); 
     396        m_wires.add(wire); 
     397    } 
     398 
     399    public Wire[] getWires() { 
     400        return m_wires.toArray(new Wire[0]); 
     401    } 
     402 
     403    public void finalize() { 
     404    } 
     405 
     406    public void wireInput(IModule dest) { 
     407        wireInput(Input.DEFAULT, dest, Input.DEFAULT); 
     408    } 
     409 
     410    public void wireInput(IModule dest, String destName) { 
     411        wireInput(Input.DEFAULT, dest, destName); 
     412    } 
     413 
     414    public void wireInput(String inName, IModule dest) { 
     415        wireInput(inName, dest, Input.DEFAULT); 
     416    } 
     417 
     418    public void wireInput(String inName, IModule dest, String destName) { 
    420419        // note new input name 
    421420        m_inputNames.add(inName); 
    422421 
    423         // save associated component 
    424         m_inputComponents.put(inName, dest); 
     422        // save associated module 
     423        m_inputModules.put(inName, dest); 
    425424 
    426425        // associate dest name with input name 
    427         m_inputComponentNames.put(inName, destName); 
    428     } 
    429  
    430     public void chainOutput(IComponent source) { 
    431         chainOutput(Output.DEFAULT, source, Output.DEFAULT); 
    432     } 
    433  
    434     public void chainOutput(IComponent source, String sourceName) { 
    435         chainOutput(Output.DEFAULT, source, sourceName); 
    436     } 
    437  
    438     public void chainOutput(String outName, IComponent source) { 
    439         chainOutput(Output.DEFAULT, source, outName); 
    440     } 
    441  
    442     public void chainOutput(String outName, IComponent source, String sourceName) { 
     426        m_inputModuleNames.put(inName, destName); 
     427    } 
     428 
     429    public void wireOutput(IModule source) { 
     430        wireOutput(Output.DEFAULT, source, Output.DEFAULT); 
     431    } 
     432 
     433    public void wireOutput(IModule source, String sourceName) { 
     434        wireOutput(Output.DEFAULT, source, sourceName); 
     435    } 
     436 
     437    public void wireOutput(String outName, IModule source) { 
     438        wireOutput(Output.DEFAULT, source, outName); 
     439    } 
     440 
     441    public void wireOutput(String outName, IModule source, String sourceName) { 
    443442        // note new output name 
    444443        m_outputNames.add(outName); 
    445444 
    446         // save associated component 
    447         m_outputComponents.put(outName, source); 
     445        // save associated module 
     446        m_outputModules.put(outName, source); 
    448447 
    449448        // associate source name with output name 
    450         m_outputComponentNames.put(sourceName, outName); 
    451  
    452         // listen for source name from source component 
     449        m_outputModuleNames.put(sourceName, outName); 
     450 
     451        // listen for source name from source module 
    453452        source.setOutputListener(sourceName, m_listener); 
    454453    } 
     
    460459    public void input(ImageWrapper image, String name) { 
    461460        if (m_inputNames.contains(name)) { 
    462             IComponent dest = m_inputComponents.get(name); 
    463             String destName = m_inputComponentNames.get(name); 
     461            IModule dest = m_inputModules.get(name); 
     462            String destName = m_inputModuleNames.get(name); 
    464463            dest.input(image, destName); 
    465464        } 
     
    488487        public void outputImage(String name, ImageWrapper image) { 
    489488            // get output name associated with this source name 
    490             String outName = m_outputComponentNames.get(name); 
     489            String outName = m_outputModuleNames.get(name); 
    491490            IOutputListener listener = m_listeners.get(outName); 
    492491            if (null != listener) { 
     
    497496 
    498497    /** 
    499      * Data structure that keeps track of IComponent and name. 
     498     * Data structure that keeps track of IModule and name. 
    500499     */ 
    501     private class ComponentAndName { 
    502         final IComponent m_component; 
     500    private class ModuleAndName { 
     501        final IModule m_module; 
    503502        final String m_name; 
    504503         
    505         ComponentAndName(IComponent component, String name) { 
    506             m_component = component; 
     504        ModuleAndName(IModule module, String name) { 
     505            m_module = module; 
    507506            m_name = name; 
    508507        } 
    509508         
    510         public IComponent getComponent() { 
    511             return m_component; 
     509        public IModule getModule() { 
     510            return m_module; 
    512511        } 
    513512         
  • branches/maven/projects/deep-zoom-plugin/src/main/java/loci/workflow/WorkFlowFactory.java

    r7440 r7495  
    1010 * @author Aivar Grislis 
    1111 */ 
    12 public class WorkFlowFactory { 
     12public class WorkFlowFactory implements IModuleFactory { 
    1313    private static WorkFlowFactory s_instance = null; 
    1414 
  • branches/maven/projects/deep-zoom-plugin/src/test/java/loci/workflow/SerializeDeserializeTest.java

    r7439 r7495  
    5555        WorkFlow workFlow1 = new WorkFlow(); 
    5656        workFlow1.setName("workFlow1"); 
    57         workFlow1.setComponentFactory(componentFactory); 
     57        workFlow1.setModuleFactory(componentFactory); 
    5858        workFlow1.add(testComponentA); 
    5959        workFlow1.add(testComponentB); 
    60         workFlow1.chain(testComponentA, testComponentB); 
    61         workFlow1.chainInput("RED", testComponentA, "ONE"); 
    62         workFlow1.chainInput("BLUE", testComponentA, "TWO"); 
    63         workFlow1.chainOutput(testComponentB); 
     60        workFlow1.wire(testComponentA, testComponentB); 
     61        workFlow1.wireInput("RED", testComponentA, "ONE"); 
     62        workFlow1.wireInput("BLUE", testComponentA, "TWO"); 
     63        workFlow1.wireOutput(testComponentB); 
    6464 
    6565        String xml1 = workFlow1.toXML(); 
  • branches/maven/projects/deep-zoom-plugin/src/test/java/loci/workflow/TestComponent.java

    r7439 r7495  
    2222 * @author aivar 
    2323 */ 
    24 public class TestComponent implements IComponent { 
     24public class TestComponent implements IModule { 
    2525    public static final String TESTCOMPONENT = "testcomponent"; 
    2626    String m_name; 
  • branches/maven/projects/deep-zoom-plugin/src/test/java/loci/workflow/TestComponentFactory.java

    r7439 r7495  
    1414 * @author Aivar Grislis 
    1515 */ 
    16 public class TestComponentFactory implements IComponentFactory { 
     16public class TestComponentFactory implements IModuleFactory { 
    1717    private static TestComponentFactory s_instance = null; 
    1818     
     
    2727    } 
    2828 
    29     public IComponent create(String xml) throws XMLException { 
    30         IComponent component = null; 
     29    public IModule create(String xml) throws XMLException { 
     30        IModule component = null; 
    3131        XMLParser xmlHelper = new XMLParser(); 
    3232        XMLTag tag = xmlHelper.getNextTag(xml); 
Note: See TracChangeset for help on using the changeset viewer.