[Android] DirectBuffer cleanup and code tidy

Author: csoroiu

main/android/uk/co/real_logic/sbe/codec/java/BitUtil.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright 2013 Real Logic Ltd.
+ *
+ * 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 uk.co.real_logic.sbe.codec.java;
 
 import java.lang.reflect.Field;
@@ -41,6 +56,7 @@ final class BitUtil
  Field positionField = getField(Buffer.class, "position");
  POSITION_FIELD_OFFSET = UNSAFE.objectFieldOffset(positionField);
  Field effectiveDirectAddressField = getField(Buffer.class, "effectiveDirectAddress");
+
  EFFECTIVE_DIRECT_ADDRESS_FIELD_OFFSET = UNSAFE.objectFieldOffset(effectiveDirectAddressField);
  USE_LONG_ADDRESS = effectiveDirectAddressField.getType() == long.class;
  MEMORY_ACCESS = USE_LONG_ADDRESS ? new MemoryAccessLongAddress() : new MemoryAccessIntAddress();
@@ -78,11 +94,24 @@ static Unsafe getUnsafe()
  return UNSAFE;
  }
 
+ /**
+ * Get the instance of {@link MemoryAccess}.
+ *
+ * @return the instance of MemoryAccess
+ */
  public static MemoryAccess getMemoryAccess()
  {
  return MEMORY_ACCESS;
  }
 
+ /**
+ * Gets the value of a static field.
+ * 
+ * @param clazz from which to get the field value
+ * @param name the name of the field
+ * @return the value of the field.
+ * @throws PrivilegedActionException
+ */
  static <T> T getStaticFieldValue(final Class<?> clazz, final String name) throws PrivilegedActionException
  {
  final PrivilegedExceptionAction<T> action = new PrivilegedExceptionAction<T>()
@@ -98,6 +127,14 @@ public T run() throws Exception
  return AccessController.doPrivileged(action);
  }
 
+ /**
+ * Extracts a field from a class using reflection.
+ * 
+ * @param clazz from which to get the field object
+ * @param name the name of the field object
+ * @return the field object.
+ * @throws PrivilegedActionException
+ */
  static Field getField(final Class<?> clazz, final String name) throws PrivilegedActionException
  {
  final PrivilegedExceptionAction<Field> action = new PrivilegedExceptionAction<Field>()

main/android/uk/co/real_logic/sbe/codec/java/DirectBuffer.java

@@ -419,6 +419,7 @@ public int getBytes(final int index, final byte[] dst, final int offset, final i
  {
  int count = Math.min(length, capacity - index);
  count = Math.min(count, dst.length - offset);
+
  if (hasArray)
  {
  System.arraycopy(byteArray, this.offset + index, dst, offset, count);
@@ -428,6 +429,7 @@ public int getBytes(final int index, final byte[] dst, final int offset, final i
  final long address = effectiveDirectAddress + index;
  MEMORY_ACCESS.peekByteArray(address, dst, offset, count);
  }
+
  return count;
  }
 
@@ -442,44 +444,34 @@ public int getBytes(final int index, final byte[] dst, final int offset, final i
  */
  public int getBytes(final int index, final DirectBuffer dst, final int offset, final int length)
  {
+ int count = Math.min(length, capacity - index);
+ count = Math.min(count, dst.capacity - offset);
+
  if (hasArray)
  {
- int srcOffset = this.offset + index;
- int count = Math.min(length, dst.capacity - offset);
- count = Math.min(count, capacity - index);
-
  if (dst.hasArray)
  {
- System.arraycopy(byteArray, srcOffset, dst.byteArray, dst.offset + offset, count);
+ System.arraycopy(byteArray, this.offset + index, dst.byteArray, dst.offset + offset, count);
  }
  else
  {
  final long address = dst.effectiveDirectAddress + offset;
- DirectBuffer.MEMORY_ACCESS.pokeByteArray(address, byteArray, srcOffset, count);
+ DirectBuffer.MEMORY_ACCESS.pokeByteArray(address, byteArray, this.offset + index, count);
  }
-
- return count;
  }
- else if (dst.hasArray)
- {
- byte[] dstArray = dst.byteArray;
- int dstOffset = dst.offset + offset;
- 
- int count = Math.min(length, capacity - index);
- count = Math.min(count, dst.capacity - offset);
- final long address = effectiveDirectAddress + index;
- MEMORY_ACCESS.peekByteArray(address, dstArray, dstOffset, count);
-
- return count;
+ else {
+ if (dst.hasArray)
+ {
+ final long address = effectiveDirectAddress + index;
+ MEMORY_ACCESS.peekByteArray(address, dst.byteArray, dst.offset + offset, count);
+ }
+ else
+ {
+ Memory.memmove(dst.byteBuffer, dst.offset + offset, byteBuffer, this.offset + index, count);
+ }
  }
- else
- {
- int count = Math.min(length, capacity - index);
- count = Math.min(count, dst.capacity - offset);
- Memory.memmove(dst.byteBuffer, dst.offset + offset, byteBuffer, this.offset + index, count);
 
- return count;
- }
+ return count;
  }
 
  /**
@@ -492,8 +484,9 @@ else if (dst.hasArray)
  */
  public int getBytes(final int index, final ByteBuffer dstBuffer, final int length)
  {
- int count = Math.min(dstBuffer.remaining(), capacity - index);
- count = Math.min(count, length);
+ int count = Math.min(length, capacity - index);
+ count = Math.min(count, dstBuffer.remaining());
+
  if (hasArray)
  {
  getBytesFromByteArray(index, dstBuffer, count);
@@ -502,7 +495,9 @@ public int getBytes(final int index, final ByteBuffer dstBuffer, final int lengt
  {
  getBytesFromMemory(index, dstBuffer, count);
  }
+
  BitUtil.setBufferPosition(dstBuffer, dstBuffer.position() + count);
+
  return count;
  }
 
@@ -531,6 +526,7 @@ public int putBytes(final int index, final byte[] src, final int offset, final i
  {
  int count = Math.min(length, capacity - index);
  count = Math.min(count, src.length - offset);
+
  if (hasArray)
  {
  System.arraycopy(src, offset, byteArray, this.offset + index, count);
@@ -569,8 +565,8 @@ public int putBytes(final int index, final DirectBuffer src, final int offset, f
  */
  public int putBytes(final int index, final ByteBuffer srcBuffer, final int length)
  {
- int count = Math.min(srcBuffer.remaining(), capacity - index);
- count = Math.min(count, length);
+ int count = Math.min(length, capacity - index);
+ count = Math.min(count, srcBuffer.remaining());
 
  if (hasArray)
  {
@@ -580,71 +576,68 @@ public int putBytes(final int index, final ByteBuffer srcBuffer, final int lengt
  {
  putBytesToMemory(index, srcBuffer, count);
  }
+
  BitUtil.setBufferPosition(srcBuffer, srcBuffer.position() + count);
 
  return count;
  }
 
  private void getBytesFromMemory(final int index, final ByteBuffer dstBuffer, final int count)
  {
- final int dstBufferPosition = dstBuffer.position();
  if (dstBuffer.hasArray())
  {
  final byte[] dst = dstBuffer.array();
- final int dstOffset = dstBuffer.arrayOffset() + dstBufferPosition;
+ final int dstOffset = dstBuffer.arrayOffset() + dstBuffer.position();
  final long address = effectiveDirectAddress + index;
  MEMORY_ACCESS.peekByteArray(address, dst, dstOffset, count);
  }
  else
  {
- Memory.memmove(dstBuffer, dstBufferPosition, byteBuffer, index, count);
+ Memory.memmove(dstBuffer, dstBuffer.position(), byteBuffer, index, count);
  }
  }
 
  private void putBytesToMemory(final int index, final ByteBuffer srcBuffer, final int count)
  {
- final int srcBufferPosition = srcBuffer.position();
  if (srcBuffer.hasArray())
  {
  final byte[] src = srcBuffer.array();
- final int srcOffset = srcBuffer.arrayOffset() + srcBufferPosition;
+ final int srcOffset = srcBuffer.arrayOffset() + srcBuffer.position();
  final long address = effectiveDirectAddress + index;
  MEMORY_ACCESS.pokeByteArray(address, src, srcOffset, count);
  }
  else
  {
- Memory.memmove(byteBuffer, index, srcBuffer, srcBufferPosition, count);
+ Memory.memmove(byteBuffer, index, srcBuffer, srcBuffer.position(), count);
  }
  }
 
  private void getBytesFromByteArray(final int index, final ByteBuffer dstBuffer, final int count)
  {
- final int dstBufferPosition = dstBuffer.position();
  if (dstBuffer.hasArray())
  {
  final byte[] dst = dstBuffer.array();
- final int dstOffset = dstBuffer.arrayOffset() + dstBufferPosition;
+ final int dstOffset = dstBuffer.arrayOffset() + dstBuffer.position();
  System.arraycopy(byteArray, this.offset + index, dst, dstOffset, count);
  }
  else
  {
- final long address = BitUtil.getEffectiveDirectAddress(dstBuffer) + dstBufferPosition;
+ final long address = BitUtil.getEffectiveDirectAddress(dstBuffer) + dstBuffer.position();
  MEMORY_ACCESS.pokeByteArray(address, byteArray, offset + index, count);
  }
  }
 
  private void putBytesToByteArray(final int index, final ByteBuffer srcBuffer, final int count)
  {
- final int srcBufferPosition = srcBuffer.position();
  if (srcBuffer.hasArray())
  {
  final byte[] src = srcBuffer.array();
- final int srcOffset = srcBuffer.arrayOffset() + srcBufferPosition;
+ final int srcOffset = srcBuffer.arrayOffset() + srcBuffer.position();
  System.arraycopy(src, srcOffset, byteArray, this.offset + index, count);
  }
  else
  {
- final long address = BitUtil.getEffectiveDirectAddress(srcBuffer) + srcBufferPosition;
+ final long address = BitUtil.getEffectiveDirectAddress(srcBuffer) + srcBuffer.position();
  MEMORY_ACCESS.peekByteArray(address, byteArray, offset + index, count);
  }
  }

main/android/uk/co/real_logic/sbe/codec/java/MemoryAccess.java

@@ -1,5 +1,26 @@
+/*
+ * Copyright 2013 Real Logic Ltd.
+ *
+ * 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 uk.co.real_logic.sbe.codec.java;
 
+/**
+ * This class is used to access memory addresses.
+ * The 2 implementations that exists are proxies for the libcore.io.Memory class
+ * which was changed in Android 4.3 (API 18) to use longs as addresses instead of integers.
+ * The libcore.io.Memory class is available starting with Android 4.0 (API 14).
+ */
 interface MemoryAccess {
 
  byte peekByte(long address);

main/android/uk/co/real_logic/sbe/codec/java/MemoryAccessIntAddress.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright 2013 Real Logic Ltd.
+ *
+ * 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 uk.co.real_logic.sbe.codec.java;
 
 import libcore.io.Memory;

main/android/uk/co/real_logic/sbe/codec/java/MemoryAccessLongAddress.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright 2013 Real Logic Ltd.
+ *
+ * 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 uk.co.real_logic.sbe.codec.java;
 
 import libcore.io.Memory;

test/android/uk/co/real_logic/sbe/codec/java/DirectBufferTest.java

@@ -23,6 +23,8 @@
 import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 
+import android.util.Log;
+
 import java.io.File;
 import java.io.IOException;
 import java.io.RandomAccessFile;
@@ -43,10 +45,10 @@ public class DirectBufferTest
  private static final int INDEX = 8;
 
  private static final byte BYTE_VALUE = 1;
- private static final short SHORT_VALUE = 2;
- private static final int INT_VALUE = 4;
+ private static final short SHORT_VALUE = 22345;
+ private static final int INT_VALUE = 41244325;
  private static final float FLOAT_VALUE = 5.0f;
- private static final long LONG_VALUE = 6;
+ private static final long LONG_VALUE = 1234567890123L;
  private static final double DOUBLE_VALUE = 7.0d;
 
  @Rule
@@ -533,6 +535,7 @@ private static ByteBuffer createMemoryMappedBuffer()
  }
  catch (IOException e)
  {
+ Log.e(DirectBufferTest.class.getName(), "Exception encountered", e);
  e.printStackTrace();
  }
  return null;
@@ -554,6 +557,7 @@ public static void cleanup()
  }
  catch (Exception e)
  {
+ Log.e(DirectBufferTest.class.getName(), "Exception encountered", e);
  e.printStackTrace();
  }
  }