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         // Getters and Setters
   3         public String getName();
   4         public String getDescription();
   5         
   6         public void setName(String name);
   7         public void setDescription(String description);
   8         
   9         // Arguments for commands are name-value pairs.
  10         public Map<String, Object> getParameter() throws IllegalArgumentException;
  11         public void setParameter(Map<String, Object> args) throws Exception;
  12         
  13         // Execute the command.
  14         public void execute() throws Exception;
  15 }
  16 

   1 @Retention(RetentionPolicy.RUNTIME)
   2 @Target(ElementType.FIELD)
   3 public @interface Tunable {
   4         String description();
   5         boolean required();
   6 }
   7 

   1 public abstract class AbstractCommand {
   2         protected String name;
   3         protected String description;
   4 
   5         public String getDescription() {
   6                 return description;
   7         }
   8 
   9         public String getName() {
  10                 return name;
  11         }
  12 
  13         public void setName(String name) {
  14                 this.name = name;
  15         }
  16 
  17         public void setDescription(String description) {
  18                 this.description = description;
  19         }
  20 
  21         public Map<String, Object> getParameter() throws IllegalArgumentException {
  22 
  23                 final Map<String, Object> parameter = new HashMap<String, Object>();
  24                 
  25                 for (Field f : this.getClass().getDeclaredFields()) {
  26                         if (f.isAnnotationPresent(Tunable.class)) {
  27                                 try {
  28                                         parameter.put(f.getName(), f.get(this));
  29                                 } catch (IllegalAccessException e) {
  30                                         // Accessing private fields are allowed here.
  31                                 }
  32                         }
  33                 }
  34                 return parameter;
  35         }
  36 
  37         public void setParameter(Map<String, Object> arg) throws Exception {
  38 
  39                 for (Field f : this.getClass().getDeclaredFields()) {
  40 
  41                         // See if the field is annotated as a Tunable.
  42                         if (f.isAnnotationPresent(Tunable.class)) {
  43                                 try {
  44                                         Tunable a = f.getAnnotation(Tunable.class);
  45                                         System.out.println("We're modifying Tunable:  "
  46                                                         + f.getName() + " : " + a.description());
  47                                         if (arg.containsKey(f.getName())) {
  48 
  49                                                 // Handle the Tunables here.
  50                                                 // Use handlers to process each data types.
  51 
  52                                         } else if (a.required()) {
  53                                                 // required field is missing. Throw exception.
  54                                         }
  55 
  56                                 } catch (Exception ex) {
  57                                         System.out.println("Modification failed: " + f.toString());
  58                                         throw ex;
  59                                 }
  60                         }
  61                 }
  62 
  63         }
  64 }
  65 

   1 public class ImportGraphFileCommand extends AbstractCommand {
   2 
   3         @Tunable(description = "Location of the network file to be imported.", required = true)
   4         private URI fileLocation;
   5 
   6         public void execute() throws Exception {
   7                 if(validate()) {
   8                         // execute the command
   9                 } else {
  10                         // Throw invalid argument exception
  11                 }
  12         }
  13         
  14         private boolean validate() {
  15                 // Check required fields and value ranges here.
  16                 return true;
  17         }
  18 }
  19 

   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 Command 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