Generating code for ros action files

message_generation/src/main/java/org/ros/internal/message/GenerateInterfaces.java

@@ -23,6 +23,7 @@ import org.apache.commons.io.FileUtils;
 import org.ros.exception.RosMessageRuntimeException;
 import org.ros.internal.message.definition.MessageDefinitionProviderChain;
 import org.ros.internal.message.definition.MessageDefinitionTupleParser;
+import org.ros.internal.message.action.ActionDefinitionFileProvider;
 import org.ros.internal.message.service.ServiceDefinitionFileProvider;
 import org.ros.internal.message.topic.TopicDefinitionFileProvider;
 import org.ros.message.MessageDeclaration;
@@ -42,6 +43,7 @@ public class GenerateInterfaces {
 
   private final TopicDefinitionFileProvider topicDefinitionFileProvider;
   private final ServiceDefinitionFileProvider serviceDefinitionFileProvider;
+  private final ActionDefinitionFileProvider actionDefinitionFileProvider;
   private final MessageDefinitionProviderChain messageDefinitionProviderChain;
   private final MessageFactory messageFactory;
   static private final String ROS_PACKAGE_PATH = "ROS_PACKAGE_PATH";
@@ -52,6 +54,8 @@ public class GenerateInterfaces {
     messageDefinitionProviderChain.addMessageDefinitionProvider(topicDefinitionFileProvider);
     serviceDefinitionFileProvider = new ServiceDefinitionFileProvider();
     messageDefinitionProviderChain.addMessageDefinitionProvider(serviceDefinitionFileProvider);
+    actionDefinitionFileProvider = new ActionDefinitionFileProvider();
+    messageDefinitionProviderChain.addMessageDefinitionProvider(actionDefinitionFileProvider);
     messageFactory = new DefaultMessageFactory(messageDefinitionProviderChain);
   }
 
@@ -110,15 +114,58 @@ public class GenerateInterfaces {
           MessageDeclaration.of(serviceType.getType(), definition);
       writeInterface(serviceDeclaration, outputDirectory, false);
       List<String> requestAndResponse = MessageDefinitionTupleParser.parse(definition, 2);
+
       MessageDeclaration requestDeclaration =
           MessageDeclaration.of(serviceType.getType() + "Request", requestAndResponse.get(0));
       MessageDeclaration responseDeclaration =
           MessageDeclaration.of(serviceType.getType() + "Response", requestAndResponse.get(1));
+
       writeInterface(requestDeclaration, outputDirectory, true);
       writeInterface(responseDeclaration, outputDirectory, true);
     }
   }
 
+  /**
+   * @param packages
+   *          a list of packages containing the topic types to generate
+   *          interfaces for
+   * @param outputDirectory
+   *          the directory to write the generated interfaces to
+   * @throws IOException
+   */
+  private void writeActionInterfaces(File outputDirectory, Collection<String> packages)
+          throws IOException {
+    Collection<MessageIdentifier> actionTypes = Sets.newHashSet();
+    if (packages.size() == 0) {
+      packages = actionDefinitionFileProvider.getPackages();
+    }
+    for (String pkg : packages) {
+      Collection<MessageIdentifier> messageIdentifiers =
+              actionDefinitionFileProvider.getMessageIdentifiersByPackage(pkg);
+      if (messageIdentifiers != null) {
+        actionTypes.addAll(messageIdentifiers);
+      }
+    }
+    for (MessageIdentifier actionType : actionTypes) {
+      String definition = messageDefinitionProviderChain.get(actionType.getType());
+      MessageDeclaration actionDeclaration =
+              MessageDeclaration.of(actionType.getType(), definition);
+      writeInterface(actionDeclaration, outputDirectory, false);
+      List<String> goalResultAndFeedback = MessageDefinitionTupleParser.parse(definition, 3);
+
+      MessageDeclaration goalDeclaration =
+              MessageDeclaration.of(actionType.getType() + "Goal", goalResultAndFeedback.get(0));
+      MessageDeclaration resultDeclaration =
+              MessageDeclaration.of(actionType.getType() + "Response", goalResultAndFeedback.get(1));
+      MessageDeclaration feedbackDeclaration =
+              MessageDeclaration.of(actionType.getType() + "Feedback", goalResultAndFeedback.get(2));
+
+      writeInterface(goalDeclaration, outputDirectory, true);
+      writeInterface(resultDeclaration, outputDirectory, true);
+      writeInterface(feedbackDeclaration, outputDirectory, true);
+    }
+  }
+
   private void writeInterface(MessageDeclaration messageDeclaration, File outputDirectory,
       boolean addConstantsAndMethods) {
     MessageInterfaceBuilder builder = new MessageInterfaceBuilder();
@@ -142,12 +189,15 @@ public class GenerateInterfaces {
     for (File directory : packagePath) {
       topicDefinitionFileProvider.addDirectory(directory);
       serviceDefinitionFileProvider.addDirectory(directory);
+      actionDefinitionFileProvider.addDirectory(directory);
     }
     topicDefinitionFileProvider.update();
     serviceDefinitionFileProvider.update();
+    actionDefinitionFileProvider.update();
     try {
       writeTopicInterfaces(outputDirectory, packages);
       writeServiceInterfaces(outputDirectory, packages);
+      writeActionInterfaces(outputDirectory, packages);
     } catch (IOException e) {
       throw new RosMessageRuntimeException(e);
     }
@@ -158,6 +208,7 @@ public class GenerateInterfaces {
     if (arguments.size() == 0) {
       arguments.add(".");
     }
+
     String rosPackagePath = System.getenv(ROS_PACKAGE_PATH);
     // Overwrite with a supplied package path if specified (--package-path=)
     for (ListIterator<String> iter = arguments.listIterator(); iter.hasNext(); ) {
@@ -168,6 +219,7 @@ public class GenerateInterfaces {
         break;
       }
     }
+
     Collection<File> packagePath = Lists.newArrayList();
     for (String path : rosPackagePath.split(File.pathSeparator)) {
       File packageDirectory = new File(path);
@@ -175,6 +227,7 @@ public class GenerateInterfaces {
         packagePath.add(packageDirectory);
       }
     }
+
     GenerateInterfaces generateInterfaces = new GenerateInterfaces();
     File outputDirectory = new File(arguments.remove(0));
     generateInterfaces.generate(outputDirectory, arguments, packagePath);

message_generation/src/main/java/org/ros/internal/message/action/ActionDefinitionFileProvider.java

+/*
+ * Copyright (C) 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.internal.message.action;
+
+import org.ros.internal.message.definition.MessageDefinitionFileProvider;
+
+import org.apache.commons.io.filefilter.FileFilterUtils;
+import org.apache.commons.io.filefilter.IOFileFilter;
+import org.ros.internal.message.StringFileProvider;
+
+import java.io.File;
+import java.io.FileFilter;
+
+/**
+ * @author arne.peters@tum.de (Arne Peters)
+ */
+public class ActionDefinitionFileProvider extends MessageDefinitionFileProvider {
+
+  private static final String PARENT = "action";
+  private static final String SUFFIX = "action";
+
+  private static StringFileProvider newStringFileProvider() {
+    IOFileFilter extensionFilter = FileFilterUtils.suffixFileFilter(SUFFIX);
+    IOFileFilter parentBaseNameFilter = FileFilterUtils.asFileFilter(new FileFilter() {
+      @Override
+      public boolean accept(File file) {
+        return getParentBaseName(file.getAbsolutePath()).equals(PARENT);
+      }
+    });
+    IOFileFilter fileFilter = FileFilterUtils.andFileFilter(extensionFilter, parentBaseNameFilter);
+    return new StringFileProvider(fileFilter);
+  }
+
+  public ActionDefinitionFileProvider() {
+    super(newStringFileProvider());
+  }
+}

message_generation/src/main/java/org/ros/internal/message/action/package-info.java

+/*
+ * Copyright (C) 2012 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+/**
+ * Provides internal classes for representing action messages.
+ * <p>
+ * These classes should _not_ be used directly outside of the org.ros package.
+ */
+package org.ros.internal.message.action;
\ No newline at end of file