Diff for "Outdated_Cytoscape_3.0/CommandDiscussions"

   1 // Java
   2 Command c = CommandService.getCommand("command_name");
   3 Object result = c.execute( parameters );
   4 
   5 // Ruby
   6 c = CommandService.getCommand("command_name")
   7 result = c.execute( parameters )
   8 

   1 package org.apache.felix.shell;
   2 
   3 public interface ShellService
   4 {
   5     public String[] getCommands();
   6     public String getCommandUsage(String name);
   7     public String getCommandDescription(String name);
   8     public ServiceReference getCommandReference(String name);
   9     public void executeCommand(
  10         String commandLine, PrintStream out, PrintStream err)
  11         throws Exception;
  12 }
  13 

   1 public class CommandServiceManager {
   2     public static Command getCommand(String command_name) {}
   3     public static List<String> getAvailableCommand() {}
   4 }
   5 

   1 public interface Command {
   2         
   3         public String getName();
   4         public String getDescription();
   5         
   6         public List<Object> execute(List<Object> args, List<Class<?>> argTypes) throws Exception;
   7 }
   8 

   1 public abstract class AbstractCommand {
   2 
   3         private String name;
   4         private String description;
   5 
   6         // Arguments will be stored in this data structure.     
   7         private Tunable arguments;
   8         
   9         public AbstractCommand(String name, String description) {
  10                 this.name = name;
  11                 this.description = description;
  12         }
  13 
  14         public String getDescription() {
  15                 return description;
  16         }
  17 
  18         public String getName() {
  19                 return name;
  20         }
  21 
  22         public List<Object> execute(List<Object> args, List<Class<?>> argTypes) throws Exception {
  23                 if(validate(args, argTypes) == false) {
  24                         throw new Exception();
  25                 }
  26                 
  27                 List<Object> result = new ArrayList<Object>();
  28                 
  29                 // Execute.  If necessary, put the result to the list.
  30                 
  31                 return result;
  32         }
  33         
  34         private Boolean validate(List<Object> args, List<Class<?>> argTypes) {
  35                 // Validate parameters
  36                 
  37                 // Then set parameters to Tunable.
  38                 return true;
  39         }
  40 }
  41 

   1 public class ImportGraphFileCommand extends AbstractCommand {
   2     // Wrapping CytoscapeActions with Command
   3 }
   4 

   1 public abstract class AbstractCommand implements Command {
   2 
   3         protected String name;
   4         protected String description;
   5 
   6         public String getName() {
   7                 return name;
   8         }
   9 
  10         public String getDescription() {
  11                 return description;
  12         }
  13         
  14         public void setName(String name) {
  15                 this.name = name;
  16         }
  17         
  18         public void setDescription(String description) {
  19                 this.description = description;
  20         }
  21 
  22 }
  23 

   1 @RunWith(SpringJUnit4ClassRunner.class)
   2 @ContextConfiguration(locations={"/META-INF/spring/bundle-context.xml"})
   3 public class ExampleBeanIntegrationTest extends
   4                 AbstractDependencyInjectionSpringContextTests {
   5         
   6         @Autowired
   7         private ImportGraphFileCommand command1;
   8 
   9         @Autowired
  10         private LayoutCommand command2;
  11 
  12         ...
  13 
  14         @Test
  15         public void testWorkflow() throws Exception {
  16                 List<Object> parameter = new ArrayList<Object>();
  17                 List<Class<?>> parameterType = new ArrayList<Class<?>>();
  18                 
  19                 parameter.add("testData/galFiltered.sif");
  20                 parameterType.add(String.class);
  21                 
  22                 List<Object> result = command1.execute(parameter, parameterType);
  23                 
  24                 //Do something with other commands
  25                 
  26         }
  27 }
  28 

   1 public final class CommandManager implements BundleActivator {
   2 
   3         private ServiceTracker commandServiceTracker;
   4 
   5         public Command getCommand(final String commandName){
   6             //returns the command using Service Tracker
   7         }
   8 
   9         public void start(BundleContext bundleContext) throws Exception {
  10                 commandServiceTracker = new ServiceTracker(bundleContext, Command.class
  11                                 .getName(), null) {
  12                         @Override
  13                         public Object addingService(ServiceReference serviceReference) {
  14                                 Command command = (Command) super.addingService(serviceReference);
  15                                 return command;
  16                         }
  17                 };
  18 
  19                 commandServiceTracker.open();
  20                 
  21         }
  22 
  23         public void stop(BundleContext bundleContext) throws Exception {
  24                 commandServiceTracker.close();
  25         }
  26 }
  27