Skip to content
Snippets Groups Projects
Commit c3bc3f22 authored by Daniel Stonier's avatar Daniel Stonier
Browse files

started clearing out

parent 1a3195f8
Branches
Tags
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 9 additions and 1801 deletions
CMakeLists.txt
+ 1
− 1
View file @ c3bc3f22
...@@ -3,7 +3,7 @@ project(rosjava_core) ...@@ -3,7 +3,7 @@ project(rosjava_core)
find_package(catkin REQUIRED rosjava_tools) find_package(catkin REQUIRED rosjava_tools)
catkin_rosjava_setup() catkin_rosjava_setup(uploadArchives)
catkin_package() catkin_package()
build.gradle
+ 5
− 17
View file @ c3bc3f22
...@@ -19,28 +19,16 @@ task wrapper(type: Wrapper) { ...@@ -19,28 +19,16 @@ task wrapper(type: Wrapper) {
} }
allprojects { allprojects {
group 'ros.rosjava_core' group 'org.ros.rosjava_core'
version = '0.0.0-SNAPSHOT' version = '0.1.0'
} }
subprojects { subprojects {
if (name != 'docs') { if (name != 'docs') {
apply plugin: 'java' apply plugin: 'ros'
apply plugin: 'osgi' apply plugin: 'ros-java'
apply plugin: 'eclipse'
apply plugin: 'maven'
sourceCompatibility = 1.6
targetCompatibility = 1.6
repositories {
mavenLocal()
maven {
url 'https://github.com/rosjava/rosjava_mvn_repo/raw/master'
}
}
} }
} }
defaultTasks 'install' defaultTasks 'uploadArchives'
package.xml
+ 3
− 1
View file @ c3bc3f22
...@@ -10,6 +10,8 @@ ...@@ -10,6 +10,8 @@
<license>Apache 2.0</license> <license>Apache 2.0</license>
<buildtool_depend>catkin</buildtool_depend> <buildtool_depend>catkin</buildtool_depend>
<build_depend>rosjava_tools</build_depend> <build_depend>rosjava_build_tools</build_depend>
<build_depend>rosjava_bootstrap</build_depend>
<build_depend>rosjava_messages</build_depend>
</package> </package>
rosjava_bootstrap/src/main/java/org/ros/internal/message/DefaultMessageDeserializer.java deleted 100644 → 0
+ 0
− 50
View file @ 1a3195f8
/*
* 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;
import org.jboss.netty.buffer.ChannelBuffer;
import org.ros.internal.message.field.Field;
import org.ros.message.MessageDeserializer;
import org.ros.message.MessageFactory;
import org.ros.message.MessageIdentifier;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class DefaultMessageDeserializer<T> implements MessageDeserializer<T> {
private final MessageIdentifier messageIdentifier;
private final MessageFactory messageFactory;
public DefaultMessageDeserializer(MessageIdentifier messageIdentifier,
MessageFactory messageFactory) {
this.messageIdentifier = messageIdentifier;
this.messageFactory = messageFactory;
}
@SuppressWarnings("unchecked")
@Override
public T deserialize(ChannelBuffer buffer) {
Message message = messageFactory.newFromType(messageIdentifier.getType());
for (Field field : message.toRawMessage().getFields()) {
if (!field.isConstant()) {
field.deserialize(buffer);
}
}
return (T) message;
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/DefaultMessageFactory.java deleted 100644 → 0
+ 0
− 51
View file @ 1a3195f8
/*
* 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;
import com.google.common.annotations.VisibleForTesting;
import org.ros.message.MessageDeclaration;
import org.ros.message.MessageDefinitionProvider;
import org.ros.message.MessageFactory;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class DefaultMessageFactory implements MessageFactory {
private final MessageDefinitionProvider messageDefinitionProvider;
private final DefaultMessageInterfaceClassProvider messageInterfaceClassProvider;
private final MessageProxyFactory messageProxyFactory;
public DefaultMessageFactory(MessageDefinitionProvider messageDefinitionProvider) {
this.messageDefinitionProvider = messageDefinitionProvider;
messageInterfaceClassProvider = new DefaultMessageInterfaceClassProvider();
messageProxyFactory = new MessageProxyFactory(getMessageInterfaceClassProvider(), this);
}
@Override
public <T> T newFromType(String messageType) {
String messageDefinition = messageDefinitionProvider.get(messageType);
MessageDeclaration messageDeclaration = MessageDeclaration.of(messageType, messageDefinition);
return messageProxyFactory.newMessageProxy(messageDeclaration);
}
@VisibleForTesting
DefaultMessageInterfaceClassProvider getMessageInterfaceClassProvider() {
return messageInterfaceClassProvider;
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/DefaultMessageInterfaceClassProvider.java deleted 100644 → 0
+ 0
− 55
View file @ 1a3195f8
/*
* 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;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Maps;
import java.util.Map;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class DefaultMessageInterfaceClassProvider implements MessageInterfaceClassProvider {
private final Map<String, Class<?>> cache;
public DefaultMessageInterfaceClassProvider() {
cache = Maps.newConcurrentMap();
}
@SuppressWarnings("unchecked")
@Override
public <T> Class<T> get(String messageType) {
if (cache.containsKey(messageType)) {
return (Class<T>) cache.get(messageType);
}
try {
String className = messageType.replace("/", ".");
Class<T> messageInterfaceClass = (Class<T>) getClass().getClassLoader().loadClass(className);
cache.put(messageType, messageInterfaceClass);
return messageInterfaceClass;
} catch (ClassNotFoundException e) {
return (Class<T>) RawMessage.class;
}
}
@VisibleForTesting
<T> void add(String messageType, Class<T> messageInterfaceClass) {
cache.put(messageType, messageInterfaceClass);
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/DefaultMessageSerializationFactory.java deleted 100644 → 0
+ 0
− 80
View file @ 1a3195f8
/*
* 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;
import org.ros.internal.message.service.ServiceRequestMessageFactory;
import org.ros.internal.message.service.ServiceResponseMessageFactory;
import org.ros.message.MessageDefinitionProvider;
import org.ros.message.MessageDeserializer;
import org.ros.message.MessageFactory;
import org.ros.message.MessageIdentifier;
import org.ros.message.MessageSerializationFactory;
import org.ros.message.MessageSerializer;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class DefaultMessageSerializationFactory implements MessageSerializationFactory {
private final MessageFactory topicMessageFactory;
private final ServiceRequestMessageFactory serviceRequestMessageFactory;
private final ServiceResponseMessageFactory serviceResponseMessageFactory;
public DefaultMessageSerializationFactory(MessageDefinitionProvider messageDefinitionProvider) {
topicMessageFactory = new DefaultMessageFactory(messageDefinitionProvider);
serviceRequestMessageFactory = new ServiceRequestMessageFactory(messageDefinitionProvider);
serviceResponseMessageFactory = new ServiceResponseMessageFactory(messageDefinitionProvider);
}
@SuppressWarnings("unchecked")
@Override
public <T> MessageSerializer<T> newMessageSerializer(String messageType) {
return (MessageSerializer<T>) new DefaultMessageSerializer();
}
@Override
public <T> MessageDeserializer<T> newMessageDeserializer(String messageType) {
return new DefaultMessageDeserializer<T>(MessageIdentifier.of(messageType),
topicMessageFactory);
}
@SuppressWarnings("unchecked")
@Override
public <T> MessageSerializer<T> newServiceRequestSerializer(String serviceType) {
return (MessageSerializer<T>) new DefaultMessageSerializer();
}
@Override
public <T> org.ros.message.MessageDeserializer<T>
newServiceRequestDeserializer(String serviceType) {
return new DefaultMessageDeserializer<T>(MessageIdentifier.of(serviceType),
serviceRequestMessageFactory);
}
@SuppressWarnings("unchecked")
@Override
public <T> org.ros.message.MessageSerializer<T> newServiceResponseSerializer(String serviceType) {
return (MessageSerializer<T>) new DefaultMessageSerializer();
}
@Override
public <T> org.ros.message.MessageDeserializer<T> newServiceResponseDeserializer(
String serviceType) {
return new DefaultMessageDeserializer<T>(MessageIdentifier.of(serviceType),
serviceResponseMessageFactory);
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/DefaultMessageSerializer.java deleted 100644 → 0
+ 0
− 36
View file @ 1a3195f8
/*
* 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;
import org.jboss.netty.buffer.ChannelBuffer;
import org.ros.internal.message.field.Field;
import org.ros.message.MessageSerializer;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class DefaultMessageSerializer implements MessageSerializer<Message> {
@Override
public void serialize(Message message, ChannelBuffer buffer) {
for (Field field : message.toRawMessage().getFields()) {
if (!field.isConstant()) {
field.serialize(buffer);
}
}
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/GenerateInterfaces.java deleted 100644 → 0
+ 0
− 172
View file @ 1a3195f8
/*
* 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;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.apache.commons.io.FileUtils;
import org.ros.EnvironmentVariables;
import org.ros.exception.RosRuntimeException;
import org.ros.internal.message.definition.MessageDefinitionProviderChain;
import org.ros.internal.message.definition.MessageDefinitionTupleParser;
import org.ros.internal.message.service.ServiceDefinitionFileProvider;
import org.ros.internal.message.topic.TopicDefinitionFileProvider;
import org.ros.message.MessageDeclaration;
import org.ros.message.MessageFactory;
import org.ros.message.MessageIdentifier;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class GenerateInterfaces {
private final TopicDefinitionFileProvider topicDefinitionFileProvider;
private final ServiceDefinitionFileProvider serviceDefinitionFileProvider;
private final MessageDefinitionProviderChain messageDefinitionProviderChain;
private final MessageFactory messageFactory;
public GenerateInterfaces() {
messageDefinitionProviderChain = new MessageDefinitionProviderChain();
topicDefinitionFileProvider = new TopicDefinitionFileProvider();
messageDefinitionProviderChain.addMessageDefinitionProvider(topicDefinitionFileProvider);
serviceDefinitionFileProvider = new ServiceDefinitionFileProvider();
messageDefinitionProviderChain.addMessageDefinitionProvider(serviceDefinitionFileProvider);
messageFactory = new DefaultMessageFactory(messageDefinitionProviderChain);
}
/**
* @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 writeTopicInterfaces(File outputDirectory, Collection<String> packages)
throws IOException {
Collection<MessageIdentifier> topicTypes = Sets.newHashSet();
if (packages.size() == 0) {
packages = topicDefinitionFileProvider.getPackages();
}
for (String pkg : packages) {
Collection<MessageIdentifier> messageIdentifiers =
topicDefinitionFileProvider.getMessageIdentifiersByPackage(pkg);
if (messageIdentifiers != null) {
topicTypes.addAll(messageIdentifiers);
}
}
for (MessageIdentifier topicType : topicTypes) {
String definition = messageDefinitionProviderChain.get(topicType.getType());
MessageDeclaration messageDeclaration = new MessageDeclaration(topicType, definition);
writeInterface(messageDeclaration, 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 writeServiceInterfaces(File outputDirectory, Collection<String> packages)
throws IOException {
Collection<MessageIdentifier> serviceTypes = Sets.newHashSet();
if (packages.size() == 0) {
packages = serviceDefinitionFileProvider.getPackages();
}
for (String pkg : packages) {
Collection<MessageIdentifier> messageIdentifiers =
serviceDefinitionFileProvider.getMessageIdentifiersByPackage(pkg);
if (messageIdentifiers != null) {
serviceTypes.addAll(messageIdentifiers);
}
}
for (MessageIdentifier serviceType : serviceTypes) {
String definition = messageDefinitionProviderChain.get(serviceType.getType());
MessageDeclaration serviceDeclaration =
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);
}
}
private void writeInterface(MessageDeclaration messageDeclaration, File outputDirectory,
boolean addConstantsAndMethods) {
MessageInterfaceBuilder builder = new MessageInterfaceBuilder();
builder.setPackageName(messageDeclaration.getPackage());
builder.setInterfaceName(messageDeclaration.getName());
builder.setMessageDeclaration(messageDeclaration);
builder.setAddConstantsAndMethods(addConstantsAndMethods);
try {
String content;
content = builder.build(messageFactory);
File file = new File(outputDirectory, messageDeclaration.getType() + ".java");
FileUtils.writeStringToFile(file, content);
} catch (Exception e) {
System.out.printf("Failed to generate interface for %s.\n", messageDeclaration.getType());
e.printStackTrace();
}
}
public void generate(File outputDirectory, Collection<String> packages,
Collection<File> packagePath) {
for (File directory : packagePath) {
topicDefinitionFileProvider.addDirectory(directory);
serviceDefinitionFileProvider.addDirectory(directory);
}
topicDefinitionFileProvider.update();
serviceDefinitionFileProvider.update();
try {
writeTopicInterfaces(outputDirectory, packages);
writeServiceInterfaces(outputDirectory, packages);
} catch (IOException e) {
throw new RosRuntimeException(e);
}
}
public static void main(String[] args) {
List<String> arguments = Lists.newArrayList(args);
if (arguments.size() == 0) {
arguments.add(".");
}
String rosPackagePath = System.getenv(EnvironmentVariables.ROS_PACKAGE_PATH);
Collection<File> packagePath = Lists.newArrayList();
for (String path : rosPackagePath.split(File.pathSeparator)) {
File packageDirectory = new File(path);
if (packageDirectory.exists()) {
packagePath.add(packageDirectory);
}
}
GenerateInterfaces generateInterfaces = new GenerateInterfaces();
File outputDirectory = new File(arguments.remove(0));
generateInterfaces.generate(outputDirectory, arguments, packagePath);
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/GetInstance.java deleted 100644 → 0
+ 0
− 25
View file @ 1a3195f8
/*
* 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;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
interface GetInstance {
public Object getInstance();
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/Md5Generator.java deleted 100644 → 0
+ 0
− 96
View file @ 1a3195f8
/*
* 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;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import org.ros.internal.message.definition.MessageDefinitionParser;
import org.ros.internal.message.definition.MessageDefinitionTupleParser;
import org.ros.internal.message.definition.MessageDefinitionParser.MessageDefinitionVisitor;
import org.apache.commons.codec.digest.DigestUtils;
import org.ros.internal.message.field.PrimitiveFieldType;
import org.ros.message.MessageDefinitionProvider;
import java.util.List;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class Md5Generator {
private final MessageDefinitionProvider messageDefinitionProvider;
public Md5Generator(MessageDefinitionProvider messageDefinitionProvider) {
this.messageDefinitionProvider = messageDefinitionProvider;
}
public String generate(String messageType) {
String messageDefinition = messageDefinitionProvider.get(messageType);
Preconditions.checkNotNull(messageDefinition, "No definition for message type: " + messageType);
List<String> parts = MessageDefinitionTupleParser.parse(messageDefinition, -1);
StringBuilder text = new StringBuilder();
for (String part : parts) {
text.append(generateText(messageType, part));
}
return DigestUtils.md5Hex(text.toString());
}
private String generateText(String messageType, String messageDefinition) {
final List<String> constants = Lists.newArrayList();
final List<String> variables = Lists.newArrayList();
MessageDefinitionVisitor visitor = new MessageDefinitionVisitor() {
@Override
public void variableValue(String type, String name) {
if (!PrimitiveFieldType.existsFor(type)) {
type = generate(type);
}
variables.add(String.format("%s %s\n", type, name));
}
@Override
public void variableList(String type, int size, String name) {
if (!PrimitiveFieldType.existsFor(type)) {
String md5Checksum = generate(type);
variables.add(String.format("%s %s\n", md5Checksum, name));
} else {
if (size != -1) {
variables.add(String.format("%s[%d] %s\n", type, size, name));
} else {
variables.add(String.format("%s[] %s\n", type, name));
}
}
}
@Override
public void constantValue(String type, String name, String value) {
constants.add(String.format("%s %s=%s\n", type, name, value));
}
};
MessageDefinitionParser messageDefinitionParser = new MessageDefinitionParser(visitor);
messageDefinitionParser.parse(messageType, messageDefinition);
String text = "";
for (String constant : constants) {
text += constant;
}
for (String variable : variables) {
text += variable;
}
return text.trim();
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/Message.java deleted 100644 → 0
+ 0
− 28
View file @ 1a3195f8
/*
* 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.
*/
package org.ros.internal.message;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public interface Message {
/**
* @return returns this {@link Message} as a {@link RawMessage}
*/
RawMessage toRawMessage();
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/MessageBufferPool.java deleted 100644 → 0
+ 0
− 91
View file @ 1a3195f8
/*
* 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.
*/
package org.ros.internal.message;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.commons.pool.impl.StackObjectPool;
import org.jboss.netty.buffer.ChannelBuffer;
import org.ros.exception.RosRuntimeException;
/**
* A pool of {@link ChannelBuffer}s for serializing and deserializing messages.
* <p>
* By contract, {@link ChannelBuffer}s provided by {@link #acquire()} must be
* returned using {@link #release(ChannelBuffer)}.
*
* @author damonkohler@google.com (Damon Kohler)
*/
public class MessageBufferPool {
private final ObjectPool<ChannelBuffer> pool;
public MessageBufferPool() {
pool = new StackObjectPool<ChannelBuffer>(new PoolableObjectFactory<ChannelBuffer>() {
@Override
public ChannelBuffer makeObject() throws Exception {
return MessageBuffers.dynamicBuffer();
}
@Override
public void destroyObject(ChannelBuffer channelBuffer) throws Exception {
}
@Override
public boolean validateObject(ChannelBuffer channelBuffer) {
return true;
}
@Override
public void activateObject(ChannelBuffer channelBuffer) throws Exception {
}
@Override
public void passivateObject(ChannelBuffer channelBuffer) throws Exception {
channelBuffer.clear();
}
});
}
/**
* Acquired {@link ChannelBuffer}s must be returned using
* {@link #release(ChannelBuffer)}.
*
* @return an unused {@link ChannelBuffer}
*/
public ChannelBuffer acquire() {
try {
return pool.borrowObject();
} catch (Exception e) {
throw new RosRuntimeException(e);
}
}
/**
* Release a previously acquired {@link ChannelBuffer}.
*
* @param channelBuffer
* the {@link ChannelBuffer} to release
*/
public void release(ChannelBuffer channelBuffer) {
try {
pool.returnObject(channelBuffer);
} catch (Exception e) {
throw new RosRuntimeException(e);
}
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/MessageBuffers.java deleted 100644 → 0
+ 0
− 44
View file @ 1a3195f8
/*
* 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.
*/
package org.ros.internal.message;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import java.nio.ByteOrder;
/**
* Provides {@link ChannelBuffer}s for serializing and deserializing messages.
*
* @author damonkohler@google.com (Damon Kohler)
*/
public class MessageBuffers {
static final int ESTIMATED_LENGTH = 256;
private MessageBuffers() {
// Utility class.
}
/**
* @return a new {@link ChannelBuffer} for {@link Message} serialization that
* grows dynamically
*/
public static ChannelBuffer dynamicBuffer() {
return ChannelBuffers.dynamicBuffer(ByteOrder.LITTLE_ENDIAN, ESTIMATED_LENGTH);
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/MessageImpl.java deleted 100644 → 0
+ 0
− 491
View file @ 1a3195f8
/*
* 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;
import org.jboss.netty.buffer.ChannelBuffer;
import org.ros.exception.RosRuntimeException;
import org.ros.internal.message.context.MessageContext;
import org.ros.internal.message.field.Field;
import org.ros.internal.message.field.MessageFieldType;
import org.ros.internal.message.field.MessageFields;
import org.ros.message.Duration;
import org.ros.message.MessageIdentifier;
import org.ros.message.Time;
import java.util.List;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
class MessageImpl implements RawMessage, GetInstance {
private final MessageContext messageContext;
private final MessageFields messageFields;
public MessageImpl(MessageContext messageContext) {
this.messageContext = messageContext;
messageFields = new MessageFields(messageContext);
}
public MessageContext getMessageContext() {
return messageContext;
}
public MessageFields getMessageFields() {
return messageFields;
}
@Override
public RawMessage toRawMessage() {
return (RawMessage) this;
}
@Override
public MessageIdentifier getIdentifier() {
return messageContext.getMessageIdentifer();
}
@Override
public String getType() {
return messageContext.getType();
}
@Override
public String getPackage() {
return messageContext.getPackage();
}
@Override
public String getName() {
return messageContext.getName();
}
@Override
public String getDefinition() {
return messageContext.getDefinition();
}
@Override
public List<Field> getFields() {
return messageFields.getFields();
}
@Override
public boolean getBool(String name) {
return (Boolean) messageFields.getFieldValue(name);
}
@Override
public boolean[] getBoolArray(String name) {
return (boolean[]) messageFields.getFieldValue(name);
}
@Override
public Duration getDuration(String name) {
return (Duration) messageFields.getFieldValue(name);
}
@SuppressWarnings("unchecked")
@Override
public List<Duration> getDurationList(String name) {
return (List<Duration>) messageFields.getFieldValue(name);
}
@Override
public float getFloat32(String name) {
return (Float) messageFields.getFieldValue(name);
}
@Override
public float[] getFloat32Array(String name) {
return (float[]) messageFields.getFieldValue(name);
}
@Override
public double getFloat64(String name) {
return (Double) messageFields.getFieldValue(name);
}
@Override
public double[] getFloat64Array(String name) {
return (double[]) messageFields.getFieldValue(name);
}
@Override
public short getInt16(String name) {
return (Short) messageFields.getFieldValue(name);
}
@Override
public short[] getInt16Array(String name) {
return (short[]) messageFields.getFieldValue(name);
}
@Override
public int getInt32(String name) {
return (Integer) messageFields.getFieldValue(name);
}
@Override
public int[] getInt32Array(String name) {
return (int[]) messageFields.getFieldValue(name);
}
@Override
public long getInt64(String name) {
return (Long) messageFields.getFieldValue(name);
}
@Override
public long[] getInt64Array(String name) {
return (long[]) messageFields.getFieldValue(name);
}
@Override
public byte getInt8(String name) {
return (Byte) messageFields.getFieldValue(name);
}
@Override
public byte[] getInt8Array(String name) {
return (byte[]) messageFields.getFieldValue(name);
}
@Override
public <T extends Message> T getMessage(String name) {
if (messageFields.getField(name).getType() instanceof MessageFieldType) {
return messageFields.getField(name).<T>getValue();
}
throw new RosRuntimeException("Failed to access message field: " + name);
}
@Override
public <T extends Message> List<T> getMessageList(String name) {
if (messageFields.getField(name).getType() instanceof MessageFieldType) {
return messageFields.getField(name).<List<T>>getValue();
}
throw new RosRuntimeException("Failed to access list field: " + name);
}
@Override
public String getString(String name) {
return (String) messageFields.getFieldValue(name);
}
@SuppressWarnings("unchecked")
@Override
public List<String> getStringList(String name) {
return (List<String>) messageFields.getFieldValue(name);
}
@Override
public Time getTime(String name) {
return (Time) messageFields.getFieldValue(name);
}
@SuppressWarnings("unchecked")
@Override
public List<Time> getTimeList(String name) {
return (List<Time>) messageFields.getFieldValue(name);
}
@Override
public short getUInt16(String name) {
return (Short) messageFields.getFieldValue(name);
}
@Override
public short[] getUInt16Array(String name) {
return (short[]) messageFields.getFieldValue(name);
}
@Override
public int getUInt32(String name) {
return (Integer) messageFields.getFieldValue(name);
}
@Override
public int[] getUInt32Array(String name) {
return (int[]) messageFields.getFieldValue(name);
}
@Override
public long getUInt64(String name) {
return (Long) messageFields.getFieldValue(name);
}
@Override
public long[] getUInt64Array(String name) {
return (long[]) messageFields.getFieldValue(name);
}
@Override
public short getUInt8(String name) {
return (Short) messageFields.getFieldValue(name);
}
@Override
public short[] getUInt8Array(String name) {
return (short[]) messageFields.getFieldValue(name);
}
@Override
public void setBool(String name, boolean value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setBoolArray(String name, boolean[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setDurationList(String name, List<Duration> value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setDuration(String name, Duration value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setFloat32(String name, float value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setFloat32Array(String name, float[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setFloat64(String name, double value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setFloat64Array(String name, double[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt16(String name, short value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt16Array(String name, short[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt32(String name, int value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt32Array(String name, int[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt64(String name, long value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt64Array(String name, long[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt8(String name, byte value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setInt8Array(String name, byte[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setMessage(String name, Message value) {
// TODO(damonkohler): Verify the type of the provided Message?
messageFields.setFieldValue(name, value);
}
@Override
public void setMessageList(String name, List<Message> value) {
// TODO(damonkohler): Verify the type of all Messages in the provided list?
messageFields.setFieldValue(name, value);
}
@Override
public void setString(String name, String value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setStringList(String name, List<String> value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setTime(String name, Time value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setTimeList(String name, List<Time> value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt16(String name, short value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt16Array(String name, short[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt32(String name, int value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt32Array(String name, int[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt64(String name, long value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt64Array(String name, long[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt8(String name, byte value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setUInt8Array(String name, byte[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public byte getByte(String name) {
return (Byte) messageFields.getFieldValue(name);
}
@Override
public short getChar(String name) {
return (Short) messageFields.getFieldValue(name);
}
@Override
public void setByte(String name, byte value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setChar(String name, short value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setByteArray(String name, byte[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public void setCharArray(String name, short[] value) {
messageFields.setFieldValue(name, value);
}
@Override
public byte[] getByteArray(String name) {
return (byte[]) messageFields.getFieldValue(name);
}
@Override
public short[] getCharArray(String name) {
return (short[]) messageFields.getFieldValue(name);
}
@Override
public ChannelBuffer getChannelBuffer(String name) {
return (ChannelBuffer) messageFields.getFieldValue(name);
}
@Override
public void setChannelBuffer(String name, ChannelBuffer value) {
messageFields.setFieldValue(name, value);
}
@Override
public Object getInstance() {
return this;
}
@Override
public String toString() {
return String.format("MessageImpl<%s>", getType());
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((messageContext == null) ? 0 : messageContext.hashCode());
result = prime * result + ((messageFields == null) ? 0 : messageFields.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof GetInstance))
return false;
obj = ((GetInstance) obj).getInstance();
if (getClass() != obj.getClass())
return false;
MessageImpl other = (MessageImpl) obj;
if (messageContext == null) {
if (other.messageContext != null)
return false;
} else if (!messageContext.equals(other.messageContext))
return false;
if (messageFields == null) {
if (other.messageFields != null)
return false;
} else if (!messageFields.equals(other.messageFields))
return false;
return true;
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/MessageInterfaceBuilder.java deleted 100644 → 0
+ 0
− 193
View file @ 1a3195f8
/*
* 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;
import com.google.common.base.Preconditions;
import com.google.common.collect.Sets;
import org.apache.commons.lang.StringEscapeUtils;
import org.ros.exception.RosRuntimeException;
import org.ros.internal.message.context.MessageContext;
import org.ros.internal.message.context.MessageContextProvider;
import org.ros.internal.message.field.Field;
import org.ros.internal.message.field.FieldType;
import org.ros.internal.message.field.MessageFields;
import org.ros.internal.message.field.PrimitiveFieldType;
import org.ros.message.MessageDeclaration;
import org.ros.message.MessageFactory;
import java.util.Set;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class MessageInterfaceBuilder {
private MessageDeclaration messageDeclaration;
private String packageName;
private String interfaceName;
private boolean addConstantsAndMethods;
private String nestedContent;
// TODO(damonkohler): Upgrade Apache Commons Lang. See
// https://issues.apache.org/jira/browse/LANG-437
private static String escapeJava(String str) {
return StringEscapeUtils.escapeJava(str).replace("\\/", "/").replace("'", "\\'");
}
public MessageDeclaration getMessageDeclaration() {
return messageDeclaration;
}
public MessageInterfaceBuilder setMessageDeclaration(MessageDeclaration messageDeclaration) {
Preconditions.checkNotNull(messageDeclaration);
this.messageDeclaration = messageDeclaration;
return this;
}
public String getPackageName() {
return packageName;
}
/**
* @param packageName
* the package name of the interface or {@code null} if no package
* name should be specified
* @return this {@link MessageInterfaceBuilder}
*/
public MessageInterfaceBuilder setPackageName(String packageName) {
this.packageName = packageName;
return this;
}
public String getInterfaceName() {
return interfaceName;
}
public MessageInterfaceBuilder setInterfaceName(String interfaceName) {
Preconditions.checkNotNull(interfaceName);
this.interfaceName = interfaceName;
return this;
}
public boolean getAddConstantsAndMethods() {
return addConstantsAndMethods;
}
public void setAddConstantsAndMethods(boolean enabled) {
addConstantsAndMethods = enabled;
}
public String getNestedContent() {
return nestedContent;
}
public void setNestedContent(String nestedContent) {
this.nestedContent = nestedContent;
}
public String build(MessageFactory messageFactory) {
Preconditions.checkNotNull(messageDeclaration);
Preconditions.checkNotNull(interfaceName);
StringBuilder builder = new StringBuilder();
if (packageName != null) {
builder.append(String.format("package %s;\n\n", packageName));
}
builder.append(String.format(
"public interface %s extends org.ros.internal.message.Message {\n", interfaceName));
builder.append(String.format(" static final java.lang.String _TYPE = \"%s\";\n",
messageDeclaration.getType()));
builder.append(String.format(" static final java.lang.String _DEFINITION = \"%s\";\n",
escapeJava(messageDeclaration.getDefinition())));
if (addConstantsAndMethods) {
MessageContextProvider messageContextProvider = new MessageContextProvider(messageFactory);
MessageContext messageContext = messageContextProvider.get(messageDeclaration);
appendConstants(messageContext, builder);
appendSettersAndGetters(messageContext, builder);
}
if (nestedContent != null) {
builder.append("\n");
builder.append(nestedContent);
}
builder.append("}\n");
return builder.toString();
}
@SuppressWarnings("deprecation")
private String getJavaValue(PrimitiveFieldType primitiveFieldType, String value) {
switch (primitiveFieldType) {
case BOOL:
return Boolean.valueOf(!value.equals("0") && !value.equals("false")).toString();
case FLOAT32:
return value + "f";
case STRING:
return "\"" + escapeJava(value) + "\"";
case BYTE:
case CHAR:
case INT8:
case UINT8:
case INT16:
case UINT16:
case INT32:
case UINT32:
case INT64:
case UINT64:
case FLOAT64:
return value;
default:
throw new RosRuntimeException("Unsupported PrimitiveFieldType: " + primitiveFieldType);
}
}
private void appendConstants(MessageContext messageContext, StringBuilder builder) {
MessageFields messageFields = new MessageFields(messageContext);
for (Field field : messageFields.getFields()) {
if (field.isConstant()) {
Preconditions.checkState(field.getType() instanceof PrimitiveFieldType);
// We use FieldType and cast back to PrimitiveFieldType below to avoid a
// bug in the Sun JDK: http://gs.sun.com/view_bug.do?bug_id=6522780
FieldType fieldType = (FieldType) field.getType();
String value = getJavaValue((PrimitiveFieldType) fieldType, field.getValue().toString());
builder.append(String.format(" static final %s %s = %s;\n", fieldType.getJavaTypeName(),
field.getName(), value));
}
}
}
private void appendSettersAndGetters(MessageContext messageContext, StringBuilder builder) {
MessageFields messageFields = new MessageFields(messageContext);
Set<String> getters = Sets.newHashSet();
for (Field field : messageFields.getFields()) {
if (field.isConstant()) {
continue;
}
String type = field.getJavaTypeName();
String getter = messageContext.getFieldGetterName(field.getName());
String setter = messageContext.getFieldSetterName(field.getName());
if (getters.contains(getter)) {
// In the case that two or more message fields have the same name except
// for capitalization, we only generate a getter and setter pair for the
// first one. The following fields will only be accessible via the
// RawMessage interface.
continue;
}
getters.add(getter);
builder.append(String.format(" %s %s();\n", type, getter));
builder.append(String.format(" void %s(%s value);\n", setter, type));
}
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/MessageInterfaceClassProvider.java deleted 100644 → 0
+ 0
− 32
View file @ 1a3195f8
/*
* 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;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public interface MessageInterfaceClassProvider {
/**
* @param <T>
* the message interface class type
* @param messageType
* the type of message to provide an interface class for
* @return the interface class for the specified message type
*/
<T> Class<T> get(String messageType);
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/MessageProxyFactory.java deleted 100644 → 0
+ 0
− 80
View file @ 1a3195f8
/*
* 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;
import com.google.common.base.Preconditions;
import org.ros.internal.message.context.MessageContext;
import org.ros.internal.message.context.MessageContextProvider;
import org.ros.message.MessageDeclaration;
import org.ros.message.MessageFactory;
import java.lang.reflect.Proxy;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class MessageProxyFactory {
// We can't use the constant here since the rosjava_messages package depends
// on rosjava_bootstrap.
private static final String HEADER_MESSAGE_TYPE = "std_msgs/Header";
private static final String SEQUENCE_FIELD_NAME = "seq";
private static final AtomicInteger SEQUENCE_NUMBER = new AtomicInteger(0);
private final MessageInterfaceClassProvider messageInterfaceClassProvider;
private final MessageContextProvider messageContextProvider;
public MessageProxyFactory(MessageInterfaceClassProvider messageInterfaceClassProvider,
MessageFactory messageFactory) {
this.messageInterfaceClassProvider = messageInterfaceClassProvider;
messageContextProvider = new MessageContextProvider(messageFactory);
}
@SuppressWarnings("unchecked")
public <T> T newMessageProxy(MessageDeclaration messageDeclaration) {
Preconditions.checkNotNull(messageDeclaration);
MessageContext messageContext = messageContextProvider.get(messageDeclaration);
MessageImpl messageImpl = new MessageImpl(messageContext);
// Header messages are automatically populated with a monotonically
// increasing sequence number.
if (messageImpl.getType().equals(HEADER_MESSAGE_TYPE)) {
messageImpl.setUInt32(SEQUENCE_FIELD_NAME, SEQUENCE_NUMBER.getAndIncrement());
}
Class<T> messageInterfaceClass =
(Class<T>) messageInterfaceClassProvider.get(messageDeclaration.getType());
return newProxy(messageInterfaceClass, messageImpl);
}
/**
* @param interfaceClass
* the interface class to provide
* @param messageImpl
* the instance to proxy
* @return a new proxy for {@code implementation} that implements
* {@code interfaceClass}
*/
@SuppressWarnings("unchecked")
private <T> T newProxy(Class<T> interfaceClass, final MessageImpl messageImpl) {
ClassLoader classLoader = messageImpl.getClass().getClassLoader();
Class<?>[] interfaces = new Class<?>[] { interfaceClass, GetInstance.class };
MessageProxyInvocationHandler invocationHandler =
new MessageProxyInvocationHandler(messageImpl);
return (T) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
}
}
rosjava_bootstrap/src/main/java/org/ros/internal/message/MessageProxyInvocationHandler.java deleted 100644 → 0
+ 0
− 51
View file @ 1a3195f8
/*
* 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.
*/
package org.ros.internal.message;
import org.ros.internal.message.field.Field;
import org.ros.internal.message.field.MessageFields;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public class MessageProxyInvocationHandler implements InvocationHandler {
private final MessageImpl messageImpl;
MessageProxyInvocationHandler(MessageImpl messageImpl) {
this.messageImpl = messageImpl;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
MessageFields mesageFields = messageImpl.getMessageFields();
Field getterField = mesageFields.getGetterField(methodName);
if (getterField != null) {
return getterField.getValue();
}
Field setterField = mesageFields.getSetterField(methodName);
if (setterField != null) {
setterField.setValue(args[0]);
return null;
}
return method.invoke(messageImpl, args);
}
}
\ No newline at end of file
rosjava_bootstrap/src/main/java/org/ros/internal/message/RawMessage.java deleted 100644 → 0
+ 0
− 207
View file @ 1a3195f8
/*
* 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;
import org.jboss.netty.buffer.ChannelBuffer;
import org.ros.internal.message.field.Field;
import org.ros.message.Duration;
import org.ros.message.MessageIdentifier;
import org.ros.message.Time;
import java.util.List;
/**
* @author damonkohler@google.com (Damon Kohler)
*/
public interface RawMessage extends Message {
boolean getBool(String name);
boolean[] getBoolArray(String name);
/**
* @deprecated replaced by {@link #getInt8(String)}
*/
byte getByte(String name);
/**
* @deprecated replaced by {@link #getInt8Array(String)}
*/
byte[] getByteArray(String name);
/**
* @deprecated replaced by {@link #getUInt8(String)}
*/
short getChar(String name);
/**
* @deprecated replaced by {@link #getUInt8Array(String)}
*/
short[] getCharArray(String name);
String getDefinition();
Duration getDuration(String name);
List<Duration> getDurationList(String name);
List<Field> getFields();
float getFloat32(String name);
float[] getFloat32Array(String name);
double getFloat64(String name);
double[] getFloat64Array(String name);
MessageIdentifier getIdentifier();
short getInt16(String name);
short[] getInt16Array(String name);
int getInt32(String name);
int[] getInt32Array(String name);
long getInt64(String name);
long[] getInt64Array(String name);
byte getInt8(String name);
byte[] getInt8Array(String name);
<T extends Message> T getMessage(String name);
<T extends Message> List<T> getMessageList(String name);
String getName();
String getPackage();
String getString(String name);
List<String> getStringList(String name);
Time getTime(String name);
List<Time> getTimeList(String name);
String getType();
short getUInt16(String name);
short[] getUInt16Array(String name);
int getUInt32(String name);
int[] getUInt32Array(String name);
long getUInt64(String name);
long[] getUInt64Array(String name);
short getUInt8(String name);
short[] getUInt8Array(String name);
void setBool(String name, boolean value);
void setBoolArray(String name, boolean[] value);
/**
* @deprecated replaced by {@link #setInt8(String, byte)}
*/
void setByte(String name, byte value);
/**
* @deprecated replaced by {@link #setInt8Array(String, byte[])}
*/
void setByteArray(String name, byte[] value);
/**
* @deprecated replaced by {@link #setUInt8(String, byte)}
*/
void setChar(String name, short value);
/**
* @deprecated replaced by {@link #setUInt8Array(String, byte[])}
*/
void setCharArray(String name, short[] value);
void setDuration(String name, Duration value);
void setDurationList(String name, List<Duration> value);
void setFloat32(String name, float value);
void setFloat32Array(String name, float[] value);
void setFloat64(String name, double value);
void setFloat64Array(String name, double[] value);
void setInt16(String name, short value);
void setInt16Array(String name, short[] value);
void setInt32(String name, int value);
void setInt32Array(String name, int[] value);
void setInt64(String name, long value);
void setInt64Array(String name, long[] value);
void setInt8(String name, byte value);
void setInt8Array(String name, byte[] value);
void setMessage(String name, Message value);
void setMessageList(String name, List<Message> value);
void setString(String name, String value);
void setStringList(String name, List<String> value);
void setTime(String name, Time value);
void setTimeList(String name, List<Time> value);
void setUInt16(String name, short value);
void setUInt16Array(String name, short[] value);
void setUInt32(String name, int value);
void setUInt32Array(String name, int[] value);
void setUInt64(String name, long value);
void setUInt64Array(String name, long[] value);
void setUInt8(String name, byte value);
void setUInt8Array(String name, byte[] value);
void setChannelBuffer(String name, ChannelBuffer value);
ChannelBuffer getChannelBuffer(String name);
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment