0001-special-rule-for-binary-attachements.patch

     import com.google.protobuf.ByteString;
     import java.nio.ByteBuffer;
     import java.util.Iterator;
     import java.util.logging.Logger;
     import rsb.transport.XOP;
     import rsb.transport.XOP.SyntaxException;
     import rst.xml.XOPType;
     /**
      * RSB converter for {@link rsb.xml.XOP} objects.
+     *
      * RSB converter for {@link rsb.xml.XOP} objects. This converter is independent
      * of the data that is set to the XOP's attachment. Is is expected that the
      * attachment's data is convertible as well.
+     *
      * @author lkettenb
      */
     public class XOPConverter implements Converter<ByteBuffer> {
         private static final Logger LOG = Logger.getLogger(XOPConverter.class
                 .getName());
         private ConverterSignature signatur = new ConverterSignature(".rst.xml.XOP", XOP.class);
         private ProtocolBufferConverter<XOPType.XOP> pbc;
         private ConverterSelectionStrategy<ByteBuffer> serializationConverters = null;
         private ConverterSelectionStrategy<ByteBuffer> deserializationConverters = null;
         /**
          * Signature for binary attachments.
          */
         private final ConverterSignature byteSignature = new ConverterSignature(
                 "bytes", ByteBuffer.class);
         public XOPConverter() {
             pbc = new ProtocolBufferConverter<XOPType.XOP>
                 (XOPType.XOP.getDefaultInstance());
-...
+        }
         @Override
         public UserData deserialize(String wireSchema, ByteBuffer buffer)
             throws ConversionException {
         public UserData<XOPType.XOP> deserialize(String wireSchema, ByteBuffer buffer) throws ConversionException {
             UserData<XOPType.XOP> result = pbc.deserialize(wireSchema, buffer);
             XOPType.XOP data = (XOPType.XOP) result.getData();
             XOP xop = convertRSTtoRSB(data);
-...
+            }
             for (XOPType.Attachment attachment : data.getAttachmentsList()) {
                 if (attachment.hasUrl() && attachment.hasData()) {
                 if (!attachment.hasUrl() || !attachment.hasData()) {
                     LOG.warning("received incomplete attachement!");
                     continue;
+                }
                 String wireSchema = attachment.getWireSchema().toStringUtf8();
                 ByteBuffer dataBuffer = ByteBuffer.wrap(attachment.getData()
                         .toByteArray());
                 rsb.transport.Attachment att;
                 if (wireSchema.equals(byteSignature.getSchema())) {
                     att = new rsb.transport.Attachment(dataBuffer,
                             byteSignature.getDataType());
                 } else {
                     Converter<ByteBuffer> c = deserializationConverters
                         .getConverter(attachment.getWireSchema().toStringUtf8());
                             .getConverter(wireSchema);
                     ByteBuffer dataBuffer
                         = ByteBuffer.wrap(attachment.getData().toByteArray());
                     UserData deserializedAttachment
                         = c.deserialize(c.getSignature().getSchema(), dataBuffer);
                     @SuppressWarnings("rawtypes")
                     UserData deserializedAttachment = c.deserialize(c
                             .getSignature().getSchema(), dataBuffer);
                     rsb.transport.Attachment att
                         = new rsb.transport.Attachment(deserializedAttachment.getData(),
                                                        deserializedAttachment.getTypeInfo());
                     xop.setAttachment(attachment.getUrl(), att);
                     att = new rsb.transport.Attachment(
                             deserializedAttachment.getData(),
                             deserializedAttachment.getTypeInfo());
+                }
                 xop.setAttachment(attachment.getUrl(), att);
+            }
             return xop;
+        }
-...
                 XOPType.Attachment.Builder attachmentBuilder
                     = XOPType.Attachment.newBuilder();
                 Converter<ByteBuffer> c
                     = serializationConverters
                     .getConverter(attachment.getType().getName());
                 WireContents<ByteBuffer> result
                     = c.serialize(attachment.getType(), attachment.getData());
                 attachmentBuilder.setWireSchema(ByteString.copyFrom(result.getWireSchema().getBytes()));
                 attachmentBuilder.setData(ByteString.copyFrom(result.getSerialization().asReadOnlyBuffer()));
                 if (attachment.getType().equals(byteSignature.getDataType())) {
                     ByteBuffer bb = (ByteBuffer) attachment.getData();
                     attachmentBuilder.setWireSchema(ByteString
                             .copyFrom(byteSignature.getSchema().getBytes()));
                     attachmentBuilder.setData(ByteString.copyFrom(bb
                             .asReadOnlyBuffer()));
                 } else {
                     Converter<ByteBuffer> c = serializationConverters
                             .getConverter(attachment.getType().getName());
                     WireContents<ByteBuffer> result = c.serialize(
                             attachment.getType(), attachment.getData());
                     attachmentBuilder.setWireSchema(ByteString.copyFrom(result
                             .getWireSchema().getBytes()));
                     attachmentBuilder.setData(ByteString.copyFrom(result
                             .getSerialization().asReadOnlyBuffer()));
+                }
                 attachmentBuilder.setUrl(url);
                 xopBuilder.addAttachments(attachmentBuilder.build());
+            }

     package rsb.transport;
     import java.nio.ByteBuffer;
     import java.util.Arrays;
     import java.util.logging.Level;
     import java.util.logging.Logger;
-...
     	private UserData data;
         /**
          * Construct an {@link Attachment} containing the data.
+         *
          * Constructs an {@link Attachment} containing the data. Attention: For
          * transferring binary data use {@link ByteBuffer}.
+         *
          * @param data The piece of data which should be stored in the attachment.
          * This can be any Java object, but the same restrictions as for event
          * payloads apply.
          * payloads apply. Use {@link ByteBuffer} for transferring binary data.
          * @param type Data type which can be interpreted by RSB's event handling
          * machinery.
+         *
-...
          * Copy constructor.
          * @param a
          */
         @SuppressWarnings("unchecked")
         @SuppressWarnings({ "unchecked", "rawtypes" })
     	public Attachment(Attachment a) {
         	data = new UserData(a.data.getData(), a.data.getTypeInfo());
+        }
         /**
          * Returns the type of this attachment. Use {@link Class#getName()} when
          * looking for the appropirate converter of this attachment.
          * looking for the appropriate converter of this attachment.
+         *
          * @return Type of this attachment.
          */

test/rsb/transport/XOMXOPTest.java
90	90	}
91	91
92	92	@Test
93		@SuppressWarnings("deprecation")
94	93	public void testNonXML() {
95	94	XOMXOP xop = new XOMXOP();
96	95	try {

         public void setUp() {
             // Register default converters (including String converter).
             DefaultConverters.register();
             ConverterRepository rep = DefaultConverterRepository.getDefaultConverterRepository();
             ConverterRepository<ByteBuffer> rep = DefaultConverterRepository.getDefaultConverterRepository();
             rep.addConverter(
                     new ProtocolBufferConverter<Gaussian1DType.Gaussian1D>(
                     Gaussian1DType.Gaussian1D.getDefaultInstance()));
-...
             WireContents<ByteBuffer> serializedData = converter.serialize(XOP.class, xop1);
             UserData<String> deserializedUserData =
             UserData<rst.xml.XOPType.XOP> deserializedUserData =
                     converter.deserialize(
                     serializedData.getWireSchema(),
                     serializedData.getSerialization());
-...
+        }
         @Test
         public void testDeSerializeBinaryAttachment() throws ConversionException, SyntaxException {
             String xml1 = "<?xml version=\"1.0\"?>" + "<node1 attr1=\"val1\">"
                     + "  <node2 attr2=\"val2\"/>" + "  <node3 attr3=\"val3\"/>"
                     + "</node1>";
             long id = 156546546;
             XOP xop1 = new XOP(xml1, id);
             // create data
             float[] floatData = {0.0f,1.0f,2.0f};
             ByteBuffer bb = ByteBuffer.allocate(4 * floatData.length);
             for (int i = 0; i < floatData.length; i++) {
                 bb.putFloat(floatData[i]);
+            }
             rsb.transport.Attachment a1 = new rsb.transport.Attachment(bb, ByteBuffer.class);
             xop1.setAttachment("attachment", a1);
             WireContents<ByteBuffer> serializedData = converter.serialize(XOP.class, xop1);
             UserData<rst.xml.XOPType.XOP> deserializedUserData =
                     converter.deserialize(
                     serializedData.getWireSchema(),
                     serializedData.getSerialization());
             assertTrue(deserializedUserData.getTypeInfo().equals(xop1.getClass()));
             XOP deserializedXOP = (XOP) deserializedUserData.getData();
             assertTrue(deserializedXOP.getID() == xop1.getID());
             assertTrue(deserializedXOP.getID() != 156546545);
             assertTrue(deserializedXOP.hasID());
             assertTrue(deserializedXOP.hasAttachment("attachment"));
             rsb.transport.Attachment a2 = deserializedXOP.getAttachment("attachment");
             ByteBuffer a1bb = (ByteBuffer) a1.getData();
             ByteBuffer a2bb = (ByteBuffer) a2.getData();
             assertTrue(a1bb.equals(a2bb));
             assertTrue(a1.equals(a2));
             assertTrue(deserializedXOP.equals(xop1));
+        }
         @Test
         public void testDeSerializeUint64() throws ConversionException, SyntaxException {
             String xml1 = "<?xml version=\"1.0\"?>" + "<node1 attr1=\"val1\">"
                     + "  <node2 attr2=\"val2\"/>" + "  <node3 attr3=\"val3\"/>"
-...
             WireContents<ByteBuffer> serializedData = converter.serialize(XOP.class, xop1);
             UserData<String> deserializedUserData =
             UserData<rst.xml.XOPType.XOP> deserializedUserData =
                     converter.deserialize(
                     serializedData.getWireSchema(),
                     serializedData.getSerialization());
-...
             WireContents<ByteBuffer> serializedData = converter.serialize(XOP.class, xop1);
             UserData<String> deserializedUserData =
             UserData<rst.xml.XOPType.XOP> deserializedUserData =
                     converter.deserialize(
                     serializedData.getWireSchema(),
                     serializedData.getSerialization());
-...
             WireContents<ByteBuffer> serializedData =
                     xopsConverter.serialize(XOPs.class, xops);
             UserData<String> deserializedUserData =
             @SuppressWarnings("rawtypes")
     		UserData deserializedUserData =
                     xopsConverter.deserialize(
                     serializedData.getWireSchema(),
                     serializedData.getSerialization());

         @Test
         public void testInValidDoc() {
             try {
                 XOP xop = new XOP("test");
                 @SuppressWarnings("unused")
     			XOP xop = new XOP("test");
             } catch (SyntaxException ex) {
                 assertTrue(true);
+            }
+    -

Robotics Service Bus » RSB XML Support