front_processing/extern/TUIO_JAVA/src/com/illposed/osc/utility/OSCJavaToByteArrayConverter.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/front_processing/extern/TUIO_JAVA/src/com/illposed/osc/utility/OSCJavaToByteArrayConverter.java Fri Mar 09 14:52:11 2012 +0100
@@ -0,0 +1,310 @@
+/**
+ * @author cramakrishnan
+ *
+ * Copyright (C) 2003, C. Ramakrishnan / Illposed Software
+ * All rights reserved.
+ *
+ * See license.txt (or license.rtf) for license information.
+ *
+ *
+ * OSCJavaToByteArrayConverter is a helper class that translates
+ * from Java types to the format the OSC spec specifies for those
+ * types.
+ *
+ * This implementation is based on Markus Gaelli and
+ * Iannis Zannos' OSC implementation in Squeak:
+ * http://www.emergent.de/Goodies/
+ */
+
+package com.illposed.osc.utility;
+
+import java.io.IOException;
+import java.io.ByteArrayOutputStream;
+import java.math.BigInteger;
+import java.util.Enumeration;
+import java.util.Vector;
+
+
+public class OSCJavaToByteArrayConverter {
+
+ protected ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ private byte[] intBytes = new byte[4];
+
+ /*public OSCJavaToByteArrayConverter() {
+ super();
+ }*/
+
+ /**
+ * Creation date: (2/23/2001 2:43:25 AM)
+ * @param anArray java.lang.Object[]
+ *
+ */
+ public void appendNullCharToAlignStream() {
+ int mod = stream.size() % 4;
+ int pad = 4 - mod;
+ for (int i = 0; i < pad; i++)
+ stream.write(0);
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:21:53 AM)
+ * @return byte[]
+ */
+ public byte[] toByteArray() {
+ return stream.toByteArray();
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:14:23 AM)
+ * @param bytes byte[]
+ */
+ public void write(byte[] bytes) {
+ writeBigEndToFourByteBoundry(bytes);
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:21:04 AM)
+ * @param i int
+ */
+ public void write(int i) {
+ writeIntegerToByteArray(i);
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:03:57 AM)
+ * @param f java.lang.Float
+ */
+ public void write(Float f) {
+ writeIntegerToByteArray(Float.floatToIntBits(f.floatValue()));
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:08:36 AM)
+ * @param i java.lang.Integer
+ */
+ public void write(Integer i) {
+ writeIntegerToByteArray(i.intValue());
+ }
+
+ /**
+ * Creation date: (2/23/2001 1:57:35 AM)
+ * @param str java.lang.String
+ */
+ public void write(String str) {
+ writeLittleEndToFourByteBoundry(str.getBytes());
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:08:36 AM)
+ * @param c char
+ */
+ public void write(char c) {
+ stream.write(c);
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:02:54 AM)
+ * @param anObject java.lang.Object
+ */
+ public void write(Object anObject) {
+ // Can't do switch on class
+ if (null == anObject)
+ return;
+ if (anObject instanceof Float) {
+ write((Float) anObject);
+ return;
+ }
+ if (anObject instanceof String) {
+ write((String) anObject);
+ return;
+ }
+ if (anObject instanceof Integer) {
+ write((Integer) anObject);
+ return;
+ }
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:43:25 AM)
+ * @param aClass Class
+ */
+ public void writeType(Class c) {
+ // A big ol' case statement -- what's polymorphism mean, again?
+ // I really wish I could extend the base classes!
+
+ // use the appropriate flags to tell SuperCollider what kind of
+ // thing it is looking at
+
+ if (Integer.class.equals(c)) {
+ stream.write('i');
+ return;
+ }
+ if (java.math.BigInteger.class.equals(c)) {
+ stream.write('h');
+ return;
+ }
+ if (Float.class.equals(c)) {
+ stream.write('f');
+ return;
+ }
+ if (Double.class.equals(c)) {
+ stream.write('d');
+ return;
+ }
+ if (String.class.equals(c)) {
+ stream.write('s');
+ return;
+ }
+ if (Character.class.equals(c)) {
+ stream.write('c');
+ return;
+ }
+ }
+
+ /**
+ * Creation date: (2/23/2001 2:43:25 AM)
+ * @param anArray java.lang.Object[]
+ */
+ public void writeTypesArray(Object[] array) {
+ // A big ol' case statement in a for loop -- what's polymorphism mean, again?
+ // I really wish I could extend the base classes!
+
+ for (int i = 0; i < array.length; i++) {
+ if (null == array[i])
+ continue;
+ // if the array at i is a type of array write a [
+ // This is used for nested arguments
+ if (array[i].getClass().isArray()) {
+ stream.write('[');
+ // fill the [] with the SuperCollider types corresponding to the object
+ // (i.e. Object of type String needs -s).
+ writeTypesArray((Object[]) array[i]);
+ // close the array
+ stream.write(']');
+ continue;
+ }
+ // Create a way to deal with Boolean type objects
+ if (Boolean.TRUE.equals(array[i])) {
+ stream.write('T');
+ continue;
+ }
+ if (Boolean.FALSE.equals(array[i])) {
+ stream.write('F');
+ continue;
+ }
+ // go through the array and write the superCollider types as shown in the
+ // above method. the Classes derived here are used as the arg to the above method
+ writeType(array[i].getClass());
+ }
+ // align the stream with padded bytes
+ appendNullCharToAlignStream();
+ }
+
+ /**
+ * Same as writeSuperColliderTypes(Object[]), just that it takes a vector (for jdk1.1
+ * compatibility), rather than an array.
+ * @param vector the collection I am to write out types for
+ */
+ public void writeTypes(Vector vector) {
+ // A big ol' case statement in a for loop -- what's polymorphism mean, again?
+ // I really wish I could extend the base classes!
+
+ Enumeration enm = vector.elements();
+ Object nextObject;
+ while (enm.hasMoreElements()) {
+ nextObject = enm.nextElement();
+ if (null == nextObject)
+ continue;
+ // if the array at i is a type of array write a [
+ // This is used for nested arguments
+ if (nextObject.getClass().isArray()) {
+ stream.write('[');
+ // fill the [] with the SuperCollider types corresponding to the object
+ // (e.g., Object of type String needs -s).
+ writeTypesArray((Object[]) nextObject);
+ // close the array
+ stream.write(']');
+ continue;
+ }
+ // Create a way to deal with Boolean type objects
+ if (Boolean.TRUE.equals(nextObject)) {
+ stream.write('T');
+ continue;
+ }
+ if (Boolean.FALSE.equals(nextObject)) {
+ stream.write('F');
+ continue;
+ }
+ // go through the array and write the superCollider types as shown in the
+ // above method. the Classes derived here are used as the arg to the above method
+ writeType(nextObject.getClass());
+ }
+ // align the stream with padded bytes
+ appendNullCharToAlignStream();
+ }
+
+ /**
+ * convert an integer to byte array
+ *
+ * @param value int
+ */
+ private void writeIntegerToByteArray(int value) {
+ byte[] intBytes = new byte[4];
+
+ intBytes[3] = (byte)value; value>>>=8;
+ intBytes[2] = (byte)value; value>>>=8;
+ intBytes[1] = (byte)value; value>>>=8;
+ intBytes[0] = (byte)value;
+
+ try {
+ stream.write(intBytes);
+ } catch (IOException e) {
+ throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream");
+ }
+ }
+
+ /**
+ * Line up the BigEnd of the bytes to a 4 byte boundry
+ *
+ * @param bytes byte[]
+ */
+ private void writeBigEndToFourByteBoundry(byte[] bytes) {
+ int mod = bytes.length % 4;
+ // if the remainder == 0 write the bytes
+ if (mod == 0) {
+ try { stream.write(bytes); } catch (IOException e)
+ { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+ return;
+ }
+ // pad the bytes to lineup correctly
+ int pad = 4 - mod;
+ byte[] newBytes = new byte[pad + bytes.length];
+ System.arraycopy(bytes,0,newBytes,pad,bytes.length);
+
+ try { stream.write(newBytes); } catch (IOException e)
+ { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+ }
+
+ /**
+ * Line up the LittleEnd of the bytes to a 4 byte boundry
+ *
+ * @param bytes byte[]
+ */
+ private void writeLittleEndToFourByteBoundry(byte[] bytes) {
+ int mod = bytes.length % 4;
+ // if the remainder == 0 write the bytes
+ if (mod == 4) {
+ try { stream.write(bytes); } catch (IOException e)
+ { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+ return;
+ }
+ // pad the bytes to lineup correctly
+ int pad = 4 - mod;
+ byte[] newBytes = new byte[pad + bytes.length];
+ System.arraycopy(bytes,0,newBytes,0,bytes.length);
+
+ try { stream.write(newBytes); } catch (IOException e)
+ { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+ }
+
+}