| /* |
| * Copyright (c) 2009-2010 jMonkeyEngine |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * * Neither the name of 'jMonkeyEngine' nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| package com.jme3.export.binary; |
| |
| import com.jme3.export.OutputCapsule; |
| import com.jme3.export.Savable; |
| import com.jme3.util.IntMap; |
| import com.jme3.util.IntMap.Entry; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.nio.ByteBuffer; |
| import java.nio.FloatBuffer; |
| import java.nio.IntBuffer; |
| import java.nio.ShortBuffer; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.BitSet; |
| import java.util.Map; |
| |
| /** |
| * @author Joshua Slack |
| */ |
| final class BinaryOutputCapsule implements OutputCapsule { |
| |
| public static final int NULL_OBJECT = -1; |
| public static final int DEFAULT_OBJECT = -2; |
| |
| public static byte[] NULL_BYTES = new byte[] { (byte) -1 }; |
| public static byte[] DEFAULT_BYTES = new byte[] { (byte) -2 }; |
| |
| protected ByteArrayOutputStream baos; |
| protected byte[] bytes; |
| protected BinaryExporter exporter; |
| protected BinaryClassObject cObj; |
| |
| public BinaryOutputCapsule(BinaryExporter exporter, BinaryClassObject bco) { |
| this.baos = new ByteArrayOutputStream(); |
| this.exporter = exporter; |
| this.cObj = bco; |
| } |
| |
| public void write(byte value, String name, byte defVal) throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BYTE); |
| write(value); |
| } |
| |
| public void write(byte[] value, String name, byte[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BYTE_1D); |
| write(value); |
| } |
| |
| public void write(byte[][] value, String name, byte[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BYTE_2D); |
| write(value); |
| } |
| |
| public void write(int value, String name, int defVal) throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.INT); |
| write(value); |
| } |
| |
| public void write(int[] value, String name, int[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.INT_1D); |
| write(value); |
| } |
| |
| public void write(int[][] value, String name, int[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.INT_2D); |
| write(value); |
| } |
| |
| public void write(float value, String name, float defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.FLOAT); |
| write(value); |
| } |
| |
| public void write(float[] value, String name, float[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.FLOAT_1D); |
| write(value); |
| } |
| |
| public void write(float[][] value, String name, float[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.FLOAT_2D); |
| write(value); |
| } |
| |
| public void write(double value, String name, double defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.DOUBLE); |
| write(value); |
| } |
| |
| public void write(double[] value, String name, double[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.DOUBLE_1D); |
| write(value); |
| } |
| |
| public void write(double[][] value, String name, double[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.DOUBLE_2D); |
| write(value); |
| } |
| |
| public void write(long value, String name, long defVal) throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.LONG); |
| write(value); |
| } |
| |
| public void write(long[] value, String name, long[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.LONG_1D); |
| write(value); |
| } |
| |
| public void write(long[][] value, String name, long[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.LONG_2D); |
| write(value); |
| } |
| |
| public void write(short value, String name, short defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SHORT); |
| write(value); |
| } |
| |
| public void write(short[] value, String name, short[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SHORT_1D); |
| write(value); |
| } |
| |
| public void write(short[][] value, String name, short[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SHORT_2D); |
| write(value); |
| } |
| |
| public void write(boolean value, String name, boolean defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BOOLEAN); |
| write(value); |
| } |
| |
| public void write(boolean[] value, String name, boolean[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BOOLEAN_1D); |
| write(value); |
| } |
| |
| public void write(boolean[][] value, String name, boolean[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BOOLEAN_2D); |
| write(value); |
| } |
| |
| public void write(String value, String name, String defVal) |
| throws IOException { |
| if (value == null ? defVal == null : value.equals(defVal)) |
| return; |
| writeAlias(name, BinaryClassField.STRING); |
| write(value); |
| } |
| |
| public void write(String[] value, String name, String[] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.STRING_1D); |
| write(value); |
| } |
| |
| public void write(String[][] value, String name, String[][] defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.STRING_2D); |
| write(value); |
| } |
| |
| public void write(BitSet value, String name, BitSet defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BITSET); |
| write(value); |
| } |
| |
| public void write(Savable object, String name, Savable defVal) |
| throws IOException { |
| if (object == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SAVABLE); |
| write(object); |
| } |
| |
| public void write(Savable[] objects, String name, Savable[] defVal) |
| throws IOException { |
| if (objects == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SAVABLE_1D); |
| write(objects); |
| } |
| |
| public void write(Savable[][] objects, String name, Savable[][] defVal) |
| throws IOException { |
| if (objects == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SAVABLE_2D); |
| write(objects); |
| } |
| |
| public void write(FloatBuffer value, String name, FloatBuffer defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.FLOATBUFFER); |
| write(value); |
| } |
| |
| public void write(IntBuffer value, String name, IntBuffer defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.INTBUFFER); |
| write(value); |
| } |
| |
| public void write(ByteBuffer value, String name, ByteBuffer defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BYTEBUFFER); |
| write(value); |
| } |
| |
| public void write(ShortBuffer value, String name, ShortBuffer defVal) |
| throws IOException { |
| if (value == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SHORTBUFFER); |
| write(value); |
| } |
| |
| public void writeFloatBufferArrayList(ArrayList<FloatBuffer> array, |
| String name, ArrayList<FloatBuffer> defVal) throws IOException { |
| if (array == defVal) |
| return; |
| writeAlias(name, BinaryClassField.FLOATBUFFER_ARRAYLIST); |
| writeFloatBufferArrayList(array); |
| } |
| |
| public void writeByteBufferArrayList(ArrayList<ByteBuffer> array, |
| String name, ArrayList<ByteBuffer> defVal) throws IOException { |
| if (array == defVal) |
| return; |
| writeAlias(name, BinaryClassField.BYTEBUFFER_ARRAYLIST); |
| writeByteBufferArrayList(array); |
| } |
| |
| public void writeSavableArrayList(ArrayList array, String name, |
| ArrayList defVal) throws IOException { |
| if (array == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SAVABLE_ARRAYLIST); |
| writeSavableArrayList(array); |
| } |
| |
| public void writeSavableArrayListArray(ArrayList[] array, String name, |
| ArrayList[] defVal) throws IOException { |
| if (array == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SAVABLE_ARRAYLIST_1D); |
| writeSavableArrayListArray(array); |
| } |
| |
| public void writeSavableArrayListArray2D(ArrayList[][] array, String name, |
| ArrayList[][] defVal) throws IOException { |
| if (array == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SAVABLE_ARRAYLIST_2D); |
| writeSavableArrayListArray2D(array); |
| } |
| |
| public void writeSavableMap(Map<? extends Savable, ? extends Savable> map, |
| String name, Map<? extends Savable, ? extends Savable> defVal) |
| throws IOException { |
| if (map == defVal) |
| return; |
| writeAlias(name, BinaryClassField.SAVABLE_MAP); |
| writeSavableMap(map); |
| } |
| |
| public void writeStringSavableMap(Map<String, ? extends Savable> map, |
| String name, Map<String, ? extends Savable> defVal) |
| throws IOException { |
| if (map == defVal) |
| return; |
| writeAlias(name, BinaryClassField.STRING_SAVABLE_MAP); |
| writeStringSavableMap(map); |
| } |
| |
| public void writeIntSavableMap(IntMap<? extends Savable> map, |
| String name, IntMap<? extends Savable> defVal) |
| throws IOException { |
| if (map == defVal) |
| return; |
| writeAlias(name, BinaryClassField.INT_SAVABLE_MAP); |
| writeIntSavableMap(map); |
| } |
| |
| protected void writeAlias(String name, byte fieldType) throws IOException { |
| if (cObj.nameFields.get(name) == null) |
| generateAlias(name, fieldType); |
| |
| byte alias = cObj.nameFields.get(name).alias; |
| write(alias); |
| } |
| |
| // XXX: The generation of aliases is limited to 256 possible values. |
| // If we run into classes with more than 256 fields, we need to expand this. |
| // But I mean, come on... |
| protected void generateAlias(String name, byte type) { |
| byte alias = (byte) cObj.nameFields.size(); |
| cObj.nameFields.put(name, new BinaryClassField(name, alias, type)); |
| } |
| |
| @Override |
| public boolean equals(Object arg0) { |
| if (!(arg0 instanceof BinaryOutputCapsule)) |
| return false; |
| |
| byte[] other = ((BinaryOutputCapsule) arg0).bytes; |
| if (bytes.length != other.length) |
| return false; |
| return Arrays.equals(bytes, other); |
| } |
| |
| @Override |
| public int hashCode() { |
| int hash = 7; |
| hash = 23 * hash + Arrays.hashCode(this.bytes); |
| return hash; |
| } |
| |
| public void finish() { |
| // renamed to finish as 'finalize' in java.lang.Object should not be |
| // overridden like this |
| // - finalize should not be called directly but is called by garbage |
| // collection!!! |
| bytes = baos.toByteArray(); |
| baos = null; |
| } |
| |
| // byte primitive |
| |
| protected void write(byte value) throws IOException { |
| baos.write(value); |
| } |
| |
| protected void writeForBuffer(byte value) throws IOException { |
| baos.write(value); |
| } |
| |
| protected void write(byte[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| baos.write(value); |
| } |
| |
| protected void write(byte[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // int primitive |
| |
| protected void write(int value) throws IOException { |
| baos.write(deflate(ByteUtils.convertToBytes(value))); |
| } |
| |
| protected void writeForBuffer(int value) throws IOException { |
| byte[] byteArray = new byte[4]; |
| byteArray[0] = (byte) value; |
| byteArray[1] = (byte) (value >> 8); |
| byteArray[2] = (byte) (value >> 16); |
| byteArray[3] = (byte) (value >> 24); |
| baos.write(byteArray); |
| } |
| |
| protected void write(int[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| protected void write(int[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // float primitive |
| |
| protected void write(float value) throws IOException { |
| baos.write(ByteUtils.convertToBytes(value)); |
| } |
| |
| protected void writeForBuffer(float value) throws IOException { |
| int integer = Float.floatToIntBits(value); |
| writeForBuffer(integer); |
| } |
| |
| protected void write(float[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| protected void write(float[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // double primitive |
| |
| protected void write(double value) throws IOException { |
| baos.write(ByteUtils.convertToBytes(value)); |
| } |
| |
| protected void write(double[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| protected void write(double[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // long primitive |
| |
| protected void write(long value) throws IOException { |
| baos.write(deflate(ByteUtils.convertToBytes(value))); |
| } |
| |
| protected void write(long[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| protected void write(long[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // short primitive |
| |
| protected void write(short value) throws IOException { |
| baos.write(ByteUtils.convertToBytes(value)); |
| } |
| |
| protected void writeForBuffer(short value) throws IOException { |
| byte[] byteArray = new byte[2]; |
| byteArray[0] = (byte) value; |
| byteArray[1] = (byte) (value >> 8); |
| baos.write(byteArray); |
| } |
| |
| protected void write(short[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| protected void write(short[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // boolean primitive |
| |
| protected void write(boolean value) throws IOException { |
| baos.write(ByteUtils.convertToBytes(value)); |
| } |
| |
| protected void write(boolean[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| protected void write(boolean[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // String |
| |
| protected void write(String value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| // write our output as UTF-8. Java misspells UTF-8 as UTF8 for official use in java.lang |
| byte[] bytes = value.getBytes("UTF8"); |
| write(bytes.length); |
| baos.write(bytes); |
| } |
| |
| protected void write(String[] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| protected void write(String[][] value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.length); |
| for (int x = 0; x < value.length; x++) |
| write(value[x]); |
| } |
| |
| // BitSet |
| |
| protected void write(BitSet value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(value.size()); |
| // TODO: MAKE THIS SMALLER |
| for (int x = 0, max = value.size(); x < max; x++) |
| write(value.get(x)); |
| } |
| |
| // DEFLATOR for int and long |
| |
| protected static byte[] deflate(byte[] bytes) { |
| int size = bytes.length; |
| if (size == 4) { |
| int possibleMagic = ByteUtils.convertIntFromBytes(bytes); |
| if (possibleMagic == NULL_OBJECT) |
| return NULL_BYTES; |
| else if (possibleMagic == DEFAULT_OBJECT) |
| return DEFAULT_BYTES; |
| } |
| for (int x = 0; x < bytes.length; x++) { |
| if (bytes[x] != 0) |
| break; |
| size--; |
| } |
| if (size == 0) |
| return new byte[1]; |
| |
| byte[] rVal = new byte[1 + size]; |
| rVal[0] = (byte) size; |
| for (int x = 1; x < rVal.length; x++) |
| rVal[x] = bytes[bytes.length - size - 1 + x]; |
| |
| return rVal; |
| } |
| |
| // BinarySavable |
| |
| protected void write(Savable object) throws IOException { |
| if (object == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| int id = exporter.processBinarySavable(object); |
| write(id); |
| } |
| |
| // BinarySavable array |
| |
| protected void write(Savable[] objects) throws IOException { |
| if (objects == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(objects.length); |
| for (int x = 0; x < objects.length; x++) { |
| write(objects[x]); |
| } |
| } |
| |
| protected void write(Savable[][] objects) throws IOException { |
| if (objects == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(objects.length); |
| for (int x = 0; x < objects.length; x++) { |
| write(objects[x]); |
| } |
| } |
| |
| // ArrayList<BinarySavable> |
| |
| protected void writeSavableArrayList(ArrayList array) throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.size()); |
| for (Object bs : array) { |
| write((Savable) bs); |
| } |
| } |
| |
| protected void writeSavableArrayListArray(ArrayList[] array) |
| throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.length); |
| for (ArrayList bs : array) { |
| writeSavableArrayList(bs); |
| } |
| } |
| |
| protected void writeSavableArrayListArray2D(ArrayList[][] array) |
| throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.length); |
| for (ArrayList[] bs : array) { |
| writeSavableArrayListArray(bs); |
| } |
| } |
| |
| // Map<BinarySavable, BinarySavable> |
| |
| protected void writeSavableMap( |
| Map<? extends Savable, ? extends Savable> array) throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.size()); |
| for (Savable key : array.keySet()) { |
| write(new Savable[] { key, array.get(key) }); |
| } |
| } |
| |
| protected void writeStringSavableMap(Map<String, ? extends Savable> array) |
| throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.size()); |
| |
| // write String array for keys |
| String[] keys = array.keySet().toArray(new String[] {}); |
| write(keys); |
| |
| // write Savable array for values |
| Savable[] values = array.values().toArray(new Savable[] {}); |
| write(values); |
| } |
| |
| protected void writeIntSavableMap(IntMap<? extends Savable> array) |
| throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.size()); |
| |
| int[] keys = new int[array.size()]; |
| Savable[] values = new Savable[keys.length]; |
| int i = 0; |
| for (Entry<? extends Savable> entry : array){ |
| keys[i] = entry.getKey(); |
| values[i] = entry.getValue(); |
| i++; |
| } |
| |
| // write String array for keys |
| write(keys); |
| |
| // write Savable array for values |
| write(values); |
| } |
| |
| // ArrayList<FloatBuffer> |
| |
| protected void writeFloatBufferArrayList(ArrayList<FloatBuffer> array) |
| throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.size()); |
| for (FloatBuffer buf : array) { |
| write(buf); |
| } |
| } |
| |
| // ArrayList<FloatBuffer> |
| |
| protected void writeByteBufferArrayList(ArrayList<ByteBuffer> array) |
| throws IOException { |
| if (array == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| write(array.size()); |
| for (ByteBuffer buf : array) { |
| write(buf); |
| } |
| } |
| |
| // NIO BUFFERS |
| // float buffer |
| |
| protected void write(FloatBuffer value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| value.rewind(); |
| int length = value.limit(); |
| write(length); |
| for (int x = 0; x < length; x++) { |
| writeForBuffer(value.get()); |
| } |
| value.rewind(); |
| } |
| |
| // int buffer |
| |
| protected void write(IntBuffer value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| value.rewind(); |
| int length = value.limit(); |
| write(length); |
| |
| for (int x = 0; x < length; x++) { |
| writeForBuffer(value.get()); |
| } |
| value.rewind(); |
| } |
| |
| // byte buffer |
| |
| protected void write(ByteBuffer value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| value.rewind(); |
| int length = value.limit(); |
| write(length); |
| for (int x = 0; x < length; x++) { |
| writeForBuffer(value.get()); |
| } |
| value.rewind(); |
| } |
| |
| // short buffer |
| |
| protected void write(ShortBuffer value) throws IOException { |
| if (value == null) { |
| write(NULL_OBJECT); |
| return; |
| } |
| value.rewind(); |
| int length = value.limit(); |
| write(length); |
| for (int x = 0; x < length; x++) { |
| writeForBuffer(value.get()); |
| } |
| value.rewind(); |
| } |
| |
| public void write(Enum value, String name, Enum defVal) throws IOException { |
| if (value == defVal) |
| return; |
| if (value == null) { |
| return; |
| } else { |
| write(value.name(), name, null); |
| } |
| } |
| } |
