This is an automated email from the ASF dual-hosted git repository. leerho pushed a commit to branch CreateInternal2 in repository https://gitbox.apache.org/repos/asf/datasketches-memory.git
commit aa960a26f4fa7588b63cc4b838fb6d701a56e815 Author: Lee Rhodes <[email protected]> AuthorDate: Sun May 16 16:00:12 2021 -0700 Interim commit. All tests pass. Successfully created interface proxies in memory package for the Map-Handle hierarchy. The real work is done in *Impl classes in the internal package. --- .../memory/DefaultMemoryRequestServer.java | 2 +- .../org/apache/datasketches/memory/MapHandle.java | 19 +-------- .../datasketches/memory/MemoryRequestServer.java | 1 - .../{MapHandle.java => WritableDirectHandle.java} | 23 ++-------- .../{MapHandle.java => WritableMapHandle.java} | 27 +++--------- .../memory/internal/AllocateDirect.java | 2 +- .../memory/internal/AllocateDirectMap.java | 2 +- .../memory/internal/BaseWritableMemoryImpl.java | 6 ++- .../memory/internal/MapHandleImpl.java | 2 +- .../datasketches/memory/internal/Memory.java | 2 +- ...ctHandle.java => WritableDirectHandleImpl.java} | 8 ++-- ...leMapHandle.java => WritableMapHandleImpl.java} | 10 ++--- .../memory/internal/WritableMemory.java | 49 ++++++++++++---------- .../datasketches/memory/internal/package-info.java | 10 ++--- .../memory/test/AllocateDirectMemoryTest.java | 4 +- .../test/AllocateDirectWritableMapMemoryTest.java | 12 +++--- .../datasketches/memory/test/Buffer2Test.java | 2 +- .../datasketches/memory/test/BufferTest.java | 4 +- .../datasketches/memory/test/CopyMemoryTest.java | 4 +- .../datasketches/memory/test/LeafImplTest.java | 11 ++--- .../datasketches/memory/test/MemoryTest.java | 48 ++++++++++----------- .../test/NonNativeWritableBufferImplTest.java | 28 ++++++------- .../test/NonNativeWritableMemoryImplTest.java | 28 ++++++------- .../datasketches/memory/test/ReflectUtil.java | 2 +- .../datasketches/memory/test/SpecificLeafTest.java | 6 +-- .../apache/datasketches/memory/test/Utf8Test.java | 2 +- .../memory/test/WritableBufferImplTest.java | 22 +++++----- .../memory/test/WritableMemoryImplTest.java | 32 +++++++------- .../memory/test/WritableMemoryTest.java | 12 +++--- .../memory/test/XxHash64LoopingTest.java | 2 +- .../datasketches/memory/test/XxHash64Test.java | 4 +- 31 files changed, 171 insertions(+), 215 deletions(-) diff --git a/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java index 8f789f6..607995f 100644 --- a/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java +++ b/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java @@ -51,7 +51,7 @@ import org.apache.datasketches.memory.internal.WritableMemory; * moveAndResize(mem, newMem); * * //You are done with the old memory, so request close. - * //Note that it is up to the owner of the WritableDirectHandle whether or not to + * //Note that it is up to the owner of the WritableDirectHandleImpl whether or not to * // actually close the resource. * memReqSvr.requestClose(mem, newMem); * diff --git a/src/main/java/org/apache/datasketches/memory/MapHandle.java b/src/main/java/org/apache/datasketches/memory/MapHandle.java index fc61ec5..aa7fcb9 100644 --- a/src/main/java/org/apache/datasketches/memory/MapHandle.java +++ b/src/main/java/org/apache/datasketches/memory/MapHandle.java @@ -17,12 +17,8 @@ * under the License. */ - package org.apache.datasketches.memory; -import org.apache.datasketches.memory.internal.Memory; - - /** * A Handle for a memory-mapped, read-only file resource. This * joins a Read-only Handle with an AutoCloseable Map resource. @@ -31,17 +27,4 @@ import org.apache.datasketches.memory.internal.Memory; * @author Lee Rhodes * @author Roman Leventov */ -public interface MapHandle extends Map, Handle { - - @Override - Memory get(); - - @Override - void close(); - - @Override - void load(); - - @Override - boolean isLoaded(); -} +public interface MapHandle extends Map, Handle { } diff --git a/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java index 977664c..297a95c 100644 --- a/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java +++ b/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java @@ -19,7 +19,6 @@ package org.apache.datasketches.memory; -import org.apache.datasketches.memory.internal.WritableDirectHandle; import org.apache.datasketches.memory.internal.WritableMemory; /** diff --git a/src/main/java/org/apache/datasketches/memory/MapHandle.java b/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java similarity index 69% copy from src/main/java/org/apache/datasketches/memory/MapHandle.java copy to src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java index fc61ec5..d1f3473 100644 --- a/src/main/java/org/apache/datasketches/memory/MapHandle.java +++ b/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java @@ -17,31 +17,16 @@ * under the License. */ - package org.apache.datasketches.memory; -import org.apache.datasketches.memory.internal.Memory; - /** - * A Handle for a memory-mapped, read-only file resource. This - * joins a Read-only Handle with an AutoCloseable Map resource. - * Please read Javadocs for {@link Handle}. + * A Handle for a writable direct memory resource. + * Joins a WritableMemory with a writable, AutoCloseable AllocateDirect resource. + * Please read Javadocs for {@link Handle}. * * @author Lee Rhodes * @author Roman Leventov */ -public interface MapHandle extends Map, Handle { +public interface WritableDirectHandle extends WritableHandle { } - @Override - Memory get(); - - @Override - void close(); - - @Override - void load(); - - @Override - boolean isLoaded(); -} diff --git a/src/main/java/org/apache/datasketches/memory/MapHandle.java b/src/main/java/org/apache/datasketches/memory/WritableMapHandle.java similarity index 69% copy from src/main/java/org/apache/datasketches/memory/MapHandle.java copy to src/main/java/org/apache/datasketches/memory/WritableMapHandle.java index fc61ec5..7cf9f18 100644 --- a/src/main/java/org/apache/datasketches/memory/MapHandle.java +++ b/src/main/java/org/apache/datasketches/memory/WritableMapHandle.java @@ -17,31 +17,14 @@ * under the License. */ - package org.apache.datasketches.memory; -import org.apache.datasketches.memory.internal.Memory; - - /** - * A Handle for a memory-mapped, read-only file resource. This - * joins a Read-only Handle with an AutoCloseable Map resource. - * Please read Javadocs for {@link Handle}. + * A Handle for a memory-mapped, writable file resource. + * Joins a WritableHandle with an AutoCloseable WritableMap resource + * Please read Javadocs for {@link Handle}. * - * @author Lee Rhodes * @author Roman Leventov + * @author Lee Rhodes */ -public interface MapHandle extends Map, Handle { - - @Override - Memory get(); - - @Override - void close(); - - @Override - void load(); - - @Override - boolean isLoaded(); -} +public interface WritableMapHandle extends WritableMap, WritableHandle { } diff --git a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java index 423c02c..97cdaf1 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java +++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java @@ -129,7 +129,7 @@ final class AllocateDirect implements AutoCloseable { if (valid.change()) { if (calledFromCleaner) { // Warn about non-deterministic resource cleanup. - LOG.warn("A WritableDirectHandle was not closed manually"); + LOG.warn("A WritableDirectHandleImpl was not closed manually"); } unsafe.freeMemory(nativeAddress); NioBits.unreserveMemory(allocationSize, capacity); diff --git a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java index 324c89e..eaa2d38 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java +++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java @@ -281,7 +281,7 @@ class AllocateDirectMap implements Map { if (valid.change()) { if (calledFromCleaner) { // Warn about non-deterministic resource cleanup. - LOG.warn("A WritableMapHandle was not closed manually"); + LOG.warn("A WritableMapHandleImpl was not closed manually"); } try { unmap(); diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java index 7ab8494..f7aba4e 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java +++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java @@ -37,6 +37,8 @@ import java.nio.ByteOrder; import java.nio.channels.WritableByteChannel; import org.apache.datasketches.memory.MemoryRequestServer; +import org.apache.datasketches.memory.WritableMapHandle; +import org.apache.datasketches.memory.WritableDirectHandle; /* * Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill, @@ -113,7 +115,7 @@ abstract class BaseWritableMemoryImpl extends WritableMemory { typeId, dirWMap.getValid()) : new MapNonNativeWritableMemoryImpl(dirWMap.nativeBaseOffset, 0L, capacityBytes, typeId, dirWMap.getValid()); - return new WritableMapHandle(dirWMap, wmem); + return new WritableMapHandleImpl(dirWMap, wmem); } @SuppressWarnings("resource") @@ -131,7 +133,7 @@ abstract class BaseWritableMemoryImpl extends WritableMemory { : new DirectNonNativeWritableMemoryImpl(direct.getNativeBaseOffset(), 0L, capacityBytes, typeId, direct.getValid(), memReqSvr); - final WritableDirectHandle handle = new WritableDirectHandle(direct, wmem); + final WritableDirectHandle handle = new WritableDirectHandleImpl(direct, wmem); return handle; } diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java index 075b577..e9741b8 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java +++ b/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java @@ -21,7 +21,7 @@ package org.apache.datasketches.memory.internal; import org.apache.datasketches.memory.MapHandle; -public class MapHandleImpl implements MapHandle { +class MapHandleImpl implements MapHandle { /** * Having at least one final field makes this class safe for concurrent publication. diff --git a/src/main/java/org/apache/datasketches/memory/internal/Memory.java b/src/main/java/org/apache/datasketches/memory/internal/Memory.java index a369977..2802aef 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/Memory.java +++ b/src/main/java/org/apache/datasketches/memory/internal/Memory.java @@ -119,7 +119,7 @@ public abstract class Memory extends BaseState { zeroCheck(capacityBytes, "Capacity"); nullCheck(file, "file is null"); negativeCheck(fileOffsetBytes, "File offset is negative"); - return BaseWritableMemoryImpl.wrapMap(file, fileOffsetBytes, capacityBytes, true, byteOrder); + return (MapHandle) BaseWritableMemoryImpl.wrapMap(file, fileOffsetBytes, capacityBytes, true, byteOrder); } //REGIONS diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandleImpl.java similarity index 82% rename from src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java rename to src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandleImpl.java index 8e490b8..aaedf42 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java +++ b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandleImpl.java @@ -20,17 +20,17 @@ package org.apache.datasketches.memory.internal; import org.apache.datasketches.memory.Handle; -import org.apache.datasketches.memory.WritableHandle; +import org.apache.datasketches.memory.WritableDirectHandle; /** * A Handle for a writable direct memory resource. + * Joins a WritableMemory with a writable, AutoCloseable AllocateDirect resource. * Please read Javadocs for {@link Handle}. * * @author Lee Rhodes * @author Roman Leventov */ -//Joins a WritableMemory with a writable, AutoCloseable AllocateDirect resource -public final class WritableDirectHandle implements WritableHandle { +public final class WritableDirectHandleImpl implements WritableDirectHandle { /** * Having at least one final field makes this class safe for concurrent publication. @@ -38,7 +38,7 @@ public final class WritableDirectHandle implements WritableHandle { final AllocateDirect direct; private WritableMemory wMem; - WritableDirectHandle(final AllocateDirect allocatedDirect, final WritableMemory wMem) { + WritableDirectHandleImpl(final AllocateDirect allocatedDirect, final WritableMemory wMem) { direct = allocatedDirect; this.wMem = wMem; } diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandleImpl.java similarity index 79% rename from src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java rename to src/main/java/org/apache/datasketches/memory/internal/WritableMapHandleImpl.java index 0cefbd6..e30c2ab 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java +++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandleImpl.java @@ -20,20 +20,20 @@ package org.apache.datasketches.memory.internal; import org.apache.datasketches.memory.Handle; -import org.apache.datasketches.memory.WritableHandle; -import org.apache.datasketches.memory.WritableMap; +import org.apache.datasketches.memory.WritableMapHandle; /** * A Handle for a memory-mapped, writable file resource. + * Joins a WritableHandle with an AutoCloseable WritableMap resource * Please read Javadocs for {@link Handle}. * * @author Roman Leventov * @author Lee Rhodes */ -//Joins a WritableHandle with an AutoCloseable WritableMap resource -public final class WritableMapHandle extends MapHandleImpl implements WritableMap, WritableHandle { +public final class WritableMapHandleImpl extends MapHandleImpl + implements WritableMapHandle { - WritableMapHandle(final AllocateDirectWritableMap dirWmap, + WritableMapHandleImpl(final AllocateDirectWritableMap dirWmap, final BaseWritableMemoryImpl wMem) { super(dirWmap, wMem); } diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java index 6f9d8fd..85b8875 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java +++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java @@ -32,6 +32,9 @@ import org.apache.datasketches.memory.DefaultMemoryRequestServer; import org.apache.datasketches.memory.Handle; import org.apache.datasketches.memory.MemoryRequestServer; import org.apache.datasketches.memory.WritableHandle; +import org.apache.datasketches.memory.WritableMapHandle; +import org.apache.datasketches.memory.WritableDirectHandle; + /** * Provides read and write primitive and primitive array access to any of the four resources @@ -60,7 +63,7 @@ public abstract class WritableMemory extends Memory { * @param byteBuf the given ByteBuffer * @return a new WritableMemory for write operations on the given ByteBuffer. */ - public static WritableMemory wrap(final ByteBuffer byteBuf) { + public static WritableMemory writableWrap(final ByteBuffer byteBuf) { return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteBuf.order()); } @@ -77,15 +80,15 @@ public abstract class WritableMemory extends Memory { * state of the given ByteBuffer * @return a new WritableMemory for write operations on the given ByteBuffer. */ - public static WritableMemory wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) { + public static WritableMemory writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) { return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteOrder); } //MAP /** - * Maps the entire given file into native-ordered Memory for write operations + * Maps the entire given file into native-ordered WritableMemory for write operations * (including those > 2GB). Calling this method is equivalent to calling - * {@link #map(File, long, long, ByteOrder) map(file, 0, file.length(), ByteOrder.nativeOrder())}. + * {@link #writableMap(File, long, long, ByteOrder) map(file, 0, file.length(), ByteOrder.nativeOrder())}. * * <p><b>Note:</b> Always qualify this method with the class name, e.g., * <i>WritableMemory.map(...)</i>. @@ -94,8 +97,8 @@ public abstract class WritableMemory extends Memory { * Please read Javadocs for {@link Handle}. * @throws IOException file not found or a RuntimeException. */ - public static WritableMapHandle map(final File file) throws IOException { - return map(file, 0, file.length(), Util.nativeByteOrder); + public static WritableMapHandle writableMap(final File file) throws IOException { + return WritableMemory.writableMap(file, 0, file.length(), Util.nativeByteOrder); } /** @@ -108,11 +111,11 @@ public abstract class WritableMemory extends Memory { * @param fileOffsetBytes the position in the given file in bytes. It may not be negative. * @param capacityBytes the size of the mapped Memory. It may not be negative or zero. * @param byteOrder the byte order to be used for the given file. It may not be null. - * @return WritableMapHandle for managing the mapped Memory. + * @return WritableMapHandleImpl for managing the mapped Memory. * Please read Javadocs for {@link Handle}. * @throws IOException file not found or RuntimeException, etc. */ - public static WritableMapHandle map(final File file, final long fileOffsetBytes, + public static WritableMapHandle writableMap(final File file, final long fileOffsetBytes, final long capacityBytes, final ByteOrder byteOrder) throws IOException { zeroCheck(capacityBytes, "Capacity"); nullCheck(file, "file is null"); @@ -137,7 +140,7 @@ public abstract class WritableMemory extends Memory { * and to call <i>close()</i> when done.</p> * * @param capacityBytes the size of the desired memory in bytes. - * @return WritableDirectHandle for this off-heap resource. + * @return WritableDirectHandleImpl for this off-heap resource. * Please read Javadocs for {@link Handle}. */ public static WritableDirectHandle allocateDirect(final long capacityBytes) { @@ -248,7 +251,7 @@ public abstract class WritableMemory extends Memory { */ public static WritableMemory allocate(final int capacityBytes) { final byte[] arr = new byte[capacityBytes]; - return wrap(arr, Util.nativeByteOrder); + return writableWrap(arr, Util.nativeByteOrder); } /** @@ -261,7 +264,7 @@ public abstract class WritableMemory extends Memory { */ public static WritableMemory allocate(final int capacityBytes, final ByteOrder byteOrder) { final byte[] arr = new byte[capacityBytes]; - return wrap(arr, byteOrder); + return writableWrap(arr, byteOrder); } //ACCESS PRIMITIVE HEAP ARRAYS for write @@ -275,7 +278,7 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final boolean[] arr) { + public static WritableMemory writableWrap(final boolean[] arr) { final long lengthBytes = arr.length << Prim.BOOLEAN.shift(); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder); } @@ -290,8 +293,8 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final byte[] arr) { - return WritableMemory.wrap(arr, 0, arr.length, Util.nativeByteOrder); + public static WritableMemory writableWrap(final byte[] arr) { + return WritableMemory.writableWrap(arr, 0, arr.length, Util.nativeByteOrder); } /** @@ -305,8 +308,8 @@ public abstract class WritableMemory extends Memory { * @param byteOrder the byte order to be used * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final byte[] arr, final ByteOrder byteOrder) { - return WritableMemory.wrap(arr, 0, arr.length, byteOrder); + public static WritableMemory writableWrap(final byte[] arr, final ByteOrder byteOrder) { + return WritableMemory.writableWrap(arr, 0, arr.length, byteOrder); } /** @@ -322,7 +325,7 @@ public abstract class WritableMemory extends Memory { * @param byteOrder the byte order to be used * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final byte[] arr, final int offsetBytes, final int lengthBytes, + public static WritableMemory writableWrap(final byte[] arr, final int offsetBytes, final int lengthBytes, final ByteOrder byteOrder) { UnsafeUtil.checkBounds(offsetBytes, lengthBytes, arr.length); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, byteOrder); @@ -338,7 +341,7 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final char[] arr) { + public static WritableMemory writableWrap(final char[] arr) { final long lengthBytes = arr.length << Prim.CHAR.shift(); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder); } @@ -353,7 +356,7 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final short[] arr) { + public static WritableMemory writableWrap(final short[] arr) { final long lengthBytes = arr.length << Prim.SHORT.shift(); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder); } @@ -368,7 +371,7 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final int[] arr) { + public static WritableMemory writableWrap(final int[] arr) { final long lengthBytes = arr.length << Prim.INT.shift(); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder); } @@ -383,7 +386,7 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final long[] arr) { + public static WritableMemory writableWrap(final long[] arr) { final long lengthBytes = arr.length << Prim.LONG.shift(); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder); } @@ -398,7 +401,7 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final float[] arr) { + public static WritableMemory writableWrap(final float[] arr) { final long lengthBytes = arr.length << Prim.FLOAT.shift(); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder); } @@ -413,7 +416,7 @@ public abstract class WritableMemory extends Memory { * @param arr the given primitive array. * @return a new WritableMemory for write operations on the given primitive array. */ - public static WritableMemory wrap(final double[] arr) { + public static WritableMemory writableWrap(final double[] arr) { final long lengthBytes = arr.length << Prim.DOUBLE.shift(); return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder); } diff --git a/src/main/java/org/apache/datasketches/memory/internal/package-info.java b/src/main/java/org/apache/datasketches/memory/internal/package-info.java index 1ca7aef..78a6a35 100644 --- a/src/main/java/org/apache/datasketches/memory/internal/package-info.java +++ b/src/main/java/org/apache/datasketches/memory/internal/package-info.java @@ -93,11 +93,11 @@ * <p>When a handle is extended for an AutoCloseable resource and then joined with an access API * it becomes an <i>implementation handle</i>. There are 3 implementation handles:</p> * - * <ul><li>{@link org.apache.datasketches.memory.internal.MapHandleImpl} + * <ul><li>{@link org.apache.datasketches.memory.MapHandle} * for read-only access to a memory-mapped file</li> - * <li>{@link org.apache.datasketches.memory.internal.WritableMapHandle} + * <li>{@link org.apache.datasketches.memory.WritableMapHandle} * for writable access to a memory-mapped file</li> - * <li>{@link org.apache.datasketches.memory.internal.WritableDirectHandle} + * <li>{@link org.apache.datasketches.memory.WritableDirectHandle} * for writable access to off-heap memory.</li> * </ul> * @@ -116,7 +116,7 @@ * } * * //Using explicit close(): - * WritableMapHandle handle = WritableMemory.map(File file); + * WritableMapHandleImpl handle = WritableMemory.map(File file); * WritableMemory wMem = handle.get(); * doWork(wMem) // read and write to memory mapped file. * handle.close(); @@ -125,7 +125,7 @@ * <p>Where it is desirable to pass ownership of the resource (and the {@code close()} * responsibility) one can not use the TWR block. Instead:</p> * <blockquote><pre> - * WritableMapHandle handler = WritableMemory.map(File file); + * WritableMapHandleImpl handler = WritableMemory.map(File file); * doWorkAndClose(handle); //passes the handle to object that closes the resource. * </pre></blockquote> * diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java index 5618423..68de819 100644 --- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java @@ -27,9 +27,9 @@ import static org.testng.Assert.fail; import java.lang.reflect.InvocationTargetException; import org.apache.datasketches.memory.MemoryRequestServer; +import org.apache.datasketches.memory.WritableDirectHandle; import org.apache.datasketches.memory.WritableHandle; import org.apache.datasketches.memory.internal.Util; -import org.apache.datasketches.memory.internal.WritableDirectHandle; import org.apache.datasketches.memory.internal.WritableMemory; import org.testng.annotations.AfterClass; import org.testng.annotations.Test; @@ -123,7 +123,7 @@ public class AllocateDirectMemoryTest { @SuppressWarnings("static-access") @AfterClass public void checkDirectCounter() { - WritableMemory mem = WritableMemory.wrap(new byte[8]); + WritableMemory mem = WritableMemory.writableWrap(new byte[8]); long count = mem.getCurrentDirectMemoryAllocations(); if (count != 0) { println(""+count); diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java index 735f52c..f58caa4 100644 --- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java @@ -42,8 +42,8 @@ import org.apache.datasketches.memory.WritableHandle; import org.apache.datasketches.memory.internal.Memory; import org.apache.datasketches.memory.internal.ReadOnlyException; import org.apache.datasketches.memory.internal.Util; -import org.apache.datasketches.memory.internal.WritableMapHandle; import org.apache.datasketches.memory.internal.WritableMemory; +import org.apache.datasketches.memory.WritableMapHandle; import org.testng.annotations.AfterClass; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; @@ -117,7 +117,7 @@ public class AllocateDirectWritableMapMemoryTest { try ( WritableMapHandle dstHandle - = WritableMemory.map(file, 0, bytes, ByteOrder.nativeOrder()); + = WritableMemory.writableMap(file, 0, bytes, ByteOrder.nativeOrder()); WritableHandle srcHandle = WritableMemory.allocateDirect(bytes)) { WritableMemory dstMem = dstHandle.get(); @@ -152,7 +152,7 @@ public class AllocateDirectWritableMapMemoryTest { file.deleteOnExit(); //comment out if you want to examine the file. final long bytes = 8; - try (WritableMapHandle h = WritableMemory.map(file, 0L, bytes, Util.nonNativeByteOrder)) { + try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nonNativeByteOrder)) { WritableMemory wmem = h.get(); wmem.putChar(0, (char) 1); assertEquals(wmem.getByte(1), (byte) 1); @@ -171,7 +171,7 @@ public class AllocateDirectWritableMapMemoryTest { public void simpleMap2() throws IOException { File file = getResourceFile("GettysburgAddress.txt"); assertTrue(isFileReadOnly(file)); - try (WritableMapHandle rh = WritableMemory.map(file)) { //throws + try (WritableMapHandle rh = WritableMemory.writableMap(file)) { //throws // } } @@ -179,7 +179,7 @@ public class AllocateDirectWritableMapMemoryTest { @Test(expectedExceptions = IllegalArgumentException.class) public void checkOverLength() { File file = getResourceFile("GettysburgAddress.txt"); - try (WritableMapHandle rh = WritableMemory.map(file, 0, 1 << 20, ByteOrder.nativeOrder())) { + try (WritableMapHandle rh = WritableMemory.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) { // } catch (IOException e) { throw new RuntimeException(e); @@ -207,7 +207,7 @@ public class AllocateDirectWritableMapMemoryTest { assertEquals(bufStr, origStr); } - try (WritableMapHandle wrh = WritableMemory.map(origFile, 0, corrBytes, + try (WritableMapHandle wrh = WritableMemory.writableMap(origFile, 0, corrBytes, ByteOrder.nativeOrder())) { WritableMemory wMap = wrh.get(); wrh.load(); diff --git a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java index 0f9b680..b1cb7aa 100644 --- a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java +++ b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java @@ -408,7 +408,7 @@ public class Buffer2Test { @Test public void testWritableDuplicate() { - WritableMemory wmem = WritableMemory.wrap(new byte[1]); + WritableMemory wmem = WritableMemory.writableWrap(new byte[1]); WritableBuffer wbuf = wmem.asWritableBuffer(); WritableBuffer wbuf2 = wbuf.writableDuplicate(); assertEquals(wbuf2.getCapacity(), 1); diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java index 86b379e..9c1481a 100644 --- a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java @@ -71,7 +71,7 @@ public class BufferTest { public void checkArrayWrap() { int n = 1024; //longs byte[] arr = new byte[n * 8]; - WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer(); for (int i = 0; i < n; i++) { wbuf.putLong(i); } @@ -264,7 +264,7 @@ public class BufferTest { int n2 = n / 2; long[] arr = new long[n]; for (int i = 0; i < n; i++) { arr[i] = i; } - WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer(); for (int i = 0; i < n; i++) { assertEquals(wbuf.getLong(), i); //write all //println("" + wmem.getLong(i * 8)); diff --git a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java index dc6a162..b322a1e 100644 --- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java @@ -124,7 +124,7 @@ public class CopyMemoryTest { ThreadLocalRandom.current().nextBytes(bytes); byte[] referenceBytes = bytes.clone(); Memory referenceMem = Memory.wrap(referenceBytes); - WritableMemory mem = WritableMemory.wrap(bytes); + WritableMemory mem = WritableMemory.writableWrap(bytes); long copyLen = UNSAFE_COPY_THRESHOLD_BYTES * 2; mem.copyTo(0, mem, UNSAFE_COPY_THRESHOLD_BYTES / 2, copyLen); Assert.assertEquals(0, mem.compareTo(UNSAFE_COPY_THRESHOLD_BYTES / 2, copyLen, referenceMem, 0, @@ -137,7 +137,7 @@ public class CopyMemoryTest { ThreadLocalRandom.current().nextBytes(bytes); byte[] referenceBytes = bytes.clone(); Memory referenceMem = Memory.wrap(referenceBytes); - WritableMemory mem = WritableMemory.wrap(bytes); + WritableMemory mem = WritableMemory.writableWrap(bytes); long copyLen = UNSAFE_COPY_THRESHOLD_BYTES * 2; mem.copyTo(UNSAFE_COPY_THRESHOLD_BYTES / 2, mem, 0, copyLen); Assert.assertEquals(0, mem.compareTo(0, copyLen, referenceMem, UNSAFE_COPY_THRESHOLD_BYTES / 2, diff --git a/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java b/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java index be17b82..58bc367 100644 --- a/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java @@ -30,11 +30,12 @@ import java.io.IOException; import java.nio.ByteBuffer; import java.nio.ByteOrder; +import org.apache.datasketches.memory.WritableDirectHandle; import org.apache.datasketches.memory.internal.Util; import org.apache.datasketches.memory.internal.WritableBuffer; -import org.apache.datasketches.memory.internal.WritableDirectHandle; -import org.apache.datasketches.memory.internal.WritableMapHandle; + import org.apache.datasketches.memory.internal.WritableMemory; +import org.apache.datasketches.memory.WritableMapHandle; import org.testng.annotations.Test; /** @@ -133,7 +134,7 @@ public class LeafImplTest { assertTrue(file.isFile()); file.deleteOnExit(); //comment out if you want to examine the file. - try (WritableMapHandle wmh = WritableMemory.map(file, off, cap, Util.nativeByteOrder)) { + try (WritableMapHandle wmh = WritableMemory.writableMap(file, off, cap, Util.nativeByteOrder)) { WritableMemory mem = wmh.get(); mem.putShort(0, (short) 1); assertEquals(mem.getByte(0), (byte) 1); @@ -208,13 +209,13 @@ public class LeafImplTest { ByteBuffer bb = ByteBuffer.allocate((int)cap); bb.order(ByteOrder.nativeOrder()); bb.putShort(0, (short) 1); - WritableMemory mem = WritableMemory.wrap(bb); + WritableMemory mem = WritableMemory.writableWrap(bb); checkByteBufferImpl(mem, off, cap, false); ByteBuffer dbb = ByteBuffer.allocateDirect((int)cap); dbb.order(ByteOrder.nativeOrder()); dbb.putShort(0, (short) 1); - mem = WritableMemory.wrap(dbb); + mem = WritableMemory.writableWrap(dbb); checkByteBufferImpl(mem, off, cap, true); } diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java index 1281b26..bbe3e24 100644 --- a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java @@ -36,10 +36,10 @@ import java.nio.ByteOrder; import java.util.List; import org.apache.datasketches.memory.MapHandle; +import org.apache.datasketches.memory.WritableDirectHandle; import org.apache.datasketches.memory.WritableHandle; import org.apache.datasketches.memory.internal.Memory; import org.apache.datasketches.memory.internal.Util; -import org.apache.datasketches.memory.internal.WritableDirectHandle; import org.apache.datasketches.memory.internal.WritableMemory; import org.testng.Assert; import org.testng.annotations.BeforeClass; @@ -87,7 +87,7 @@ public class MemoryTest { public void checkArrayWrap() { int n = 1024; //longs byte[] arr = new byte[n * 8]; - WritableMemory wmem = WritableMemory.wrap(arr); + WritableMemory wmem = WritableMemory.writableWrap(arr); for (int i = 0; i < n; i++) { wmem.putLong(i * 8, i); } @@ -101,14 +101,14 @@ public class MemoryTest { assertEquals(v, i); } // check 0 length array wraps - Memory memZeroLengthArrayBoolean = WritableMemory.wrap(new boolean[0]); - Memory memZeroLengthArrayByte = WritableMemory.wrap(new byte[0]); - Memory memZeroLengthArrayChar = WritableMemory.wrap(new char[0]); - Memory memZeroLengthArrayShort = WritableMemory.wrap(new short[0]); - Memory memZeroLengthArrayInt = WritableMemory.wrap(new int[0]); - Memory memZeroLengthArrayLong = WritableMemory.wrap(new long[0]); - Memory memZeroLengthArrayFloat = WritableMemory.wrap(new float[0]); - Memory memZeroLengthArrayDouble = WritableMemory.wrap(new double[0]); + Memory memZeroLengthArrayBoolean = WritableMemory.writableWrap(new boolean[0]); + Memory memZeroLengthArrayByte = WritableMemory.writableWrap(new byte[0]); + Memory memZeroLengthArrayChar = WritableMemory.writableWrap(new char[0]); + Memory memZeroLengthArrayShort = WritableMemory.writableWrap(new short[0]); + Memory memZeroLengthArrayInt = WritableMemory.writableWrap(new int[0]); + Memory memZeroLengthArrayLong = WritableMemory.writableWrap(new long[0]); + Memory memZeroLengthArrayFloat = WritableMemory.writableWrap(new float[0]); + Memory memZeroLengthArrayDouble = WritableMemory.writableWrap(new double[0]); assertEquals(memZeroLengthArrayBoolean.getCapacity(), 0); assertEquals(memZeroLengthArrayByte.getCapacity(), 0); assertEquals(memZeroLengthArrayChar.getCapacity(), 0); @@ -121,15 +121,15 @@ public class MemoryTest { // check 0 length array wraps List<Memory> memoryToCheck = Lists.newArrayList(); memoryToCheck.add(WritableMemory.allocate(0)); - memoryToCheck.add(WritableMemory.wrap(ByteBuffer.allocate(0))); - memoryToCheck.add(WritableMemory.wrap(new boolean[0])); - memoryToCheck.add(WritableMemory.wrap(new byte[0])); - memoryToCheck.add(WritableMemory.wrap(new char[0])); - memoryToCheck.add(WritableMemory.wrap(new short[0])); - memoryToCheck.add(WritableMemory.wrap(new int[0])); - memoryToCheck.add(WritableMemory.wrap(new long[0])); - memoryToCheck.add(WritableMemory.wrap(new float[0])); - memoryToCheck.add(WritableMemory.wrap(new double[0])); + memoryToCheck.add(WritableMemory.writableWrap(ByteBuffer.allocate(0))); + memoryToCheck.add(WritableMemory.writableWrap(new boolean[0])); + memoryToCheck.add(WritableMemory.writableWrap(new byte[0])); + memoryToCheck.add(WritableMemory.writableWrap(new char[0])); + memoryToCheck.add(WritableMemory.writableWrap(new short[0])); + memoryToCheck.add(WritableMemory.writableWrap(new int[0])); + memoryToCheck.add(WritableMemory.writableWrap(new long[0])); + memoryToCheck.add(WritableMemory.writableWrap(new float[0])); + memoryToCheck.add(WritableMemory.writableWrap(new double[0])); memoryToCheck.add(Memory.wrap(ByteBuffer.allocate(0))); memoryToCheck.add(Memory.wrap(new boolean[0])); memoryToCheck.add(Memory.wrap(new byte[0])); @@ -151,7 +151,7 @@ public class MemoryTest { byte[] arr = new byte[n * 8]; ByteBuffer bb = ByteBuffer.wrap(arr); bb.order(ByteOrder.nativeOrder()); - WritableMemory wmem = WritableMemory.wrap(bb); + WritableMemory wmem = WritableMemory.writableWrap(bb); for (int i = 0; i < n; i++) { //write to wmem wmem.putLong(i * 8, i); } @@ -181,7 +181,7 @@ public class MemoryTest { int n = 1024; //longs ByteBuffer bb = ByteBuffer.allocateDirect(n * 8); bb.order(ByteOrder.nativeOrder()); - WritableMemory wmem = WritableMemory.wrap(bb); + WritableMemory wmem = WritableMemory.writableWrap(bb); for (int i = 0; i < n; i++) { //write to wmem wmem.putLong(i * 8, i); } @@ -282,7 +282,7 @@ public class MemoryTest { int n2 = n / 2; long[] arr = new long[n]; for (int i = 0; i < n; i++) { arr[i] = i; } - WritableMemory wmem = WritableMemory.wrap(arr); + WritableMemory wmem = WritableMemory.writableWrap(arr); for (int i = 0; i < n; i++) { assertEquals(wmem.getLong(i * 8), i); //println("" + wmem.getLong(i * 8)); @@ -302,7 +302,7 @@ public class MemoryTest { int n2 = n / 2; long[] arr = new long[n]; for (int i = 0; i < n; i++) { arr[i] = i; } - WritableMemory wmem = WritableMemory.wrap(arr); + WritableMemory wmem = WritableMemory.writableWrap(arr); for (int i = 0; i < n; i++) { assertEquals(wmem.getLong(i * 8), i); //println("" + wmem.getLong(i * 8)); @@ -430,7 +430,7 @@ public class MemoryTest { @Test public void checkNullMemReqSvr() { - WritableMemory wmem = WritableMemory.wrap(new byte[16]); + WritableMemory wmem = WritableMemory.writableWrap(new byte[16]); assertNull(wmem.getMemoryRequestServer()); try (WritableDirectHandle wdh = WritableMemory.allocateDirect(16)) { WritableMemory wmem2 = wdh.get(); diff --git a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java index a70e315..199539f 100644 --- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java @@ -41,7 +41,7 @@ public class NonNativeWritableBufferImplTest { int m = Character.BYTES; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf = wmem.asWritableBuffer(); char ch = 'a'; for (int i = 0; i < n; i++) { wbuf.putChar(i * m, ch++); } @@ -62,7 +62,7 @@ public class NonNativeWritableBufferImplTest { wbuf.setPosition(0); wbuf.getCharArray(cArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf2 = wmem2.asWritableBuffer(); wbuf2.putCharArray(cArr, 0, n); assertEquals(arr2, arr1); @@ -74,7 +74,7 @@ public class NonNativeWritableBufferImplTest { int m = Double.BYTES; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf = wmem.asWritableBuffer(); double dbl = 1.0; for (int i = 0; i < n; i++) { wbuf.putDouble(i * m, dbl++); } @@ -95,7 +95,7 @@ public class NonNativeWritableBufferImplTest { wbuf.setPosition(0); wbuf.getDoubleArray(dblArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf2 = wmem2.asWritableBuffer(); wbuf2.putDoubleArray(dblArr, 0, n); assertEquals(arr2, arr1); @@ -107,7 +107,7 @@ public class NonNativeWritableBufferImplTest { int m = Float.BYTES; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf = wmem.asWritableBuffer(); float flt = 1.0F; for (int i = 0; i < n; i++) { wbuf.putFloat(i * m, flt++); } @@ -128,7 +128,7 @@ public class NonNativeWritableBufferImplTest { wbuf.setPosition(0); wbuf.getFloatArray(fltArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf2 = wmem2.asWritableBuffer(); wbuf2.putFloatArray(fltArr, 0, n); assertEquals(arr2, arr1); @@ -140,7 +140,7 @@ public class NonNativeWritableBufferImplTest { int m = Integer.BYTES; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf = wmem.asWritableBuffer(); int intg = 1; for (int i = 0; i < n; i++) { wbuf.putInt(i * m, intg++); } @@ -161,7 +161,7 @@ public class NonNativeWritableBufferImplTest { wbuf.setPosition(0); wbuf.getIntArray(intArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf2 = wmem2.asWritableBuffer(); wbuf2.putIntArray(intArr, 0, n); assertEquals(arr2, arr1); @@ -173,7 +173,7 @@ public class NonNativeWritableBufferImplTest { int m = Long.BYTES; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf = wmem.asWritableBuffer(); long lng = 1; for (int i = 0; i < n; i++) { wbuf.putLong(i * m, lng++); } @@ -194,7 +194,7 @@ public class NonNativeWritableBufferImplTest { wbuf.setPosition(0); wbuf.getLongArray(longArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf2 = wmem2.asWritableBuffer(); wbuf2.putLongArray(longArr, 0, n); assertEquals(arr2, arr1); @@ -206,7 +206,7 @@ public class NonNativeWritableBufferImplTest { int m = Short.BYTES; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf = wmem.asWritableBuffer(); short sht = 1; for (int i = 0; i < n; i++) { wbuf.putShort(i * m, sht++); } @@ -227,7 +227,7 @@ public class NonNativeWritableBufferImplTest { wbuf.setPosition(0); wbuf.getShortArray(shortArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf2 = wmem2.asWritableBuffer(); wbuf2.putShortArray(shortArr, 0, n); assertEquals(arr2, arr1); @@ -237,7 +237,7 @@ public class NonNativeWritableBufferImplTest { @Test public void checkDuplicate() { byte[] bArr = new byte[8]; - WritableMemory wmem = WritableMemory.wrap(bArr, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN); WritableBuffer wbuf = wmem.asWritableBuffer(); WritableBuffer wdup = wbuf.writableDuplicate(); assertEquals(wdup.getTypeByteOrder(), ByteOrder.BIG_ENDIAN); @@ -249,7 +249,7 @@ public class NonNativeWritableBufferImplTest { @Test public void checkDuplicateZeros() { byte[] bArr = new byte[0]; - WritableMemory wmem = WritableMemory.wrap(bArr, ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN); Buffer buf = wmem.asBuffer(); Buffer dup = buf.duplicate(); assertEquals(dup.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN); diff --git a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java index 6388718..a71a610 100644 --- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java @@ -33,7 +33,7 @@ import org.testng.annotations.Test; @SuppressWarnings("javadoc") public class NonNativeWritableMemoryImplTest { private byte[] bArr = new byte[8]; - private final WritableMemory wmem = WritableMemory.wrap(bArr, ByteOrder.BIG_ENDIAN); + private final WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN); //Check primitives @Test @@ -42,7 +42,7 @@ public class NonNativeWritableMemoryImplTest { int n = ((1 << 20) / m) + m; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem1 = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); for (int i = 0; i < n; i++) { wmem1.putChar(i * m, (char) i++); } for (int i = 0; i < n; i++) { assertEquals(wmem1.getChar(i * m), (char) i++); @@ -51,7 +51,7 @@ public class NonNativeWritableMemoryImplTest { char[] cArr = new char[n]; //native wmem1.getCharArray(0, cArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); wmem2.putCharArray(0, cArr, 0, n); assertEquals(arr2, arr1); } @@ -62,7 +62,7 @@ public class NonNativeWritableMemoryImplTest { int n = ((1 << 20) / m) + m; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem1 = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); double dbl = 1.0; for (int i = 0; i < n; i++) { wmem1.putDouble(i * m, dbl++); } dbl = 1.0; @@ -73,7 +73,7 @@ public class NonNativeWritableMemoryImplTest { double[] dblArr = new double[n]; //native wmem1.getDoubleArray(0, dblArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); wmem2.putDoubleArray(0, dblArr, 0, n); assertEquals(arr2, arr1); } @@ -84,7 +84,7 @@ public class NonNativeWritableMemoryImplTest { int n = ((1 << 20) / m) + m; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem1 = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); float flt = 1.0F; for (int i = 0; i < n; i++) { wmem1.putFloat(i * m, flt++); } flt = 1.0F; @@ -95,7 +95,7 @@ public class NonNativeWritableMemoryImplTest { float[] fltArr = new float[n]; //native wmem1.getFloatArray(0, fltArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); wmem2.putFloatArray(0, fltArr, 0, n); assertEquals(arr2, arr1); } @@ -106,7 +106,7 @@ public class NonNativeWritableMemoryImplTest { int n = ((1 << 20) / m) + m; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem1 = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); int intg = 1; for (int i = 0; i < n; i++) { wmem1.putInt(i * m, intg++); } intg = 1; @@ -117,7 +117,7 @@ public class NonNativeWritableMemoryImplTest { int[] intArr = new int[n]; //native wmem1.getIntArray(0, intArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); wmem2.putIntArray(0, intArr, 0, n); assertEquals(arr2, arr1); } @@ -128,7 +128,7 @@ public class NonNativeWritableMemoryImplTest { int n = ((1 << 20) / m) + m; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem1 = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); long lng = 1; for (int i = 0; i < n; i++) { wmem1.putLong(i * m, lng++); } lng = 1; @@ -139,7 +139,7 @@ public class NonNativeWritableMemoryImplTest { long[] longArr = new long[n]; //native wmem1.getLongArray(0, longArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); wmem2.putLongArray(0, longArr, 0, n); assertEquals(arr2, arr1); } @@ -150,7 +150,7 @@ public class NonNativeWritableMemoryImplTest { int n = ((1 << 20) / m) + m; byte[] arr1 = new byte[n * m]; //non-native //put & get - WritableMemory wmem1 = WritableMemory.wrap(arr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN); short sht = 1; for (int i = 0; i < n; i++) { wmem1.putShort(i * m, sht++); } sht = 1; @@ -161,7 +161,7 @@ public class NonNativeWritableMemoryImplTest { short[] shortArr = new short[n]; //native wmem1.getShortArray(0, shortArr, 0, n); //wmem is non-native byte[] arr2 = new byte[n * m]; - WritableMemory wmem2 = WritableMemory.wrap(arr2, ByteOrder.BIG_ENDIAN); + WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN); wmem2.putShortArray(0, shortArr, 0, n); assertEquals(arr2, arr1); } @@ -212,7 +212,7 @@ public class NonNativeWritableMemoryImplTest { @Test public void checkRegionZeros() { byte[] bArr1 = new byte[0]; - WritableMemory wmem1 = WritableMemory.wrap(bArr1, ByteOrder.BIG_ENDIAN); + WritableMemory wmem1 = WritableMemory.writableWrap(bArr1, ByteOrder.BIG_ENDIAN); Memory reg = wmem1.region(0, wmem1.getCapacity()); assertEquals(reg.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN); } diff --git a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java index d57af89..b567aae 100644 --- a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java +++ b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java @@ -24,7 +24,7 @@ import java.lang.reflect.*; import java.nio.ByteOrder; import org.apache.datasketches.memory.MemoryRequestServer; -import org.apache.datasketches.memory.internal.WritableDirectHandle; +import org.apache.datasketches.memory.WritableDirectHandle; public final class ReflectUtil { diff --git a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java index b0bb764..f1c8794 100644 --- a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java @@ -29,9 +29,9 @@ import java.nio.ByteBuffer; import org.apache.datasketches.memory.internal.Buffer; import org.apache.datasketches.memory.internal.Memory; import org.apache.datasketches.memory.internal.Util; -import org.apache.datasketches.memory.internal.WritableDirectHandle; -import org.apache.datasketches.memory.internal.WritableMapHandle; import org.apache.datasketches.memory.internal.WritableMemory; +import org.apache.datasketches.memory.WritableMapHandle; +import org.apache.datasketches.memory.WritableDirectHandle; import org.testng.annotations.Test; /** @@ -107,7 +107,7 @@ public class SpecificLeafTest { final long bytes = 128; - try (WritableMapHandle h = WritableMemory.map(file, 0L, bytes, Util.nativeByteOrder)) { + try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nativeByteOrder)) { WritableMemory mem = h.get(); //native mem assertTrue(ReflectUtil.isMapType(mem)); assertFalse(mem.isReadOnly()); diff --git a/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java b/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java index 8a38b39..2b8b92e 100644 --- a/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java +++ b/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java @@ -302,7 +302,7 @@ public class Utf8Test { String refStr = "Quizdeltagerne spiste jordb\u00e6r med fl\u00f8de, mens cirkusklovnen"; byte[] refByteArr = refStr.getBytes(UTF_8); int addBytes = refByteArr.length; - WritableMemory refMem = WritableMemory.wrap(refByteArr); + WritableMemory refMem = WritableMemory.writableWrap(refByteArr); int decodedChars = refMem.getCharsFromUtf8(0, addBytes, sb); String finalStr = sb.toString(); int finalChars = finalStr.toCharArray().length; diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java index bdb0354..99dfd13 100644 --- a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java @@ -70,7 +70,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getBooleanArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -89,7 +89,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getByteArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -107,7 +107,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getCharArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -125,7 +125,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getShortArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -143,7 +143,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getIntArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -161,7 +161,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getLongArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -179,7 +179,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getFloatArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -197,7 +197,7 @@ public class WritableBufferImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); wbuf.getDoubleArray(dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -358,7 +358,7 @@ public class WritableBufferImplTest { public void checkIsReadOnly() { long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 }; - WritableBuffer wbuf = WritableMemory.wrap(srcArray).asWritableBuffer(); + WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer(); assertFalse(wbuf.isReadOnly()); Buffer buf = wbuf; @@ -486,8 +486,8 @@ public class WritableBufferImplTest { @Test public void checkIsSameResource() { byte[] byteArr = new byte[64]; - WritableBuffer wbuf1 = WritableMemory.wrap(byteArr).asWritableBuffer(); - WritableBuffer wbuf2 = WritableMemory.wrap(byteArr).asWritableBuffer(); + WritableBuffer wbuf1 = WritableMemory.writableWrap(byteArr).asWritableBuffer(); + WritableBuffer wbuf2 = WritableMemory.writableWrap(byteArr).asWritableBuffer(); assertTrue(wbuf1.isSameResource(wbuf2)); } diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java index 292ba0a..78ba991 100644 --- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java @@ -69,7 +69,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getBooleanArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -88,7 +88,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getByteArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -106,7 +106,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getCharArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -124,7 +124,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getShortArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -142,7 +142,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getIntArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -160,7 +160,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getLongArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -178,7 +178,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getFloatArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -196,7 +196,7 @@ public class WritableMemoryImplTest { assertEquals(dstArray[i], srcArray[i]); } - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); wmem.getDoubleArray(0, dstArray, 0, 8); for (int i=0; i<8; i++) { assertEquals(dstArray[i], srcArray[i]); @@ -446,7 +446,7 @@ public class WritableMemoryImplTest { byteBuf.put(i, (byte) i); } - WritableMemory wmem = WritableMemory.wrap(byteBuf); + WritableMemory wmem = WritableMemory.writableWrap(byteBuf); for (int i=0; i<memCapacity; i++) { assertEquals(wmem.getByte(i), byteBuf.get(i)); @@ -468,7 +468,7 @@ public class WritableMemoryImplTest { byteBuf.put(i, (byte) i); } - Memory mem = WritableMemory.wrap(byteBuf); + Memory mem = WritableMemory.writableWrap(byteBuf); for (int i = 0; i < memCapacity; i++) { assertEquals(mem.getByte(i), byteBuf.get(i)); @@ -484,7 +484,7 @@ public class WritableMemoryImplTest { byteBuf.order(ByteOrder.nativeOrder()); ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer(); - WritableMemory.wrap(byteBufRO); + WritableMemory.writableWrap(byteBufRO); } @Test @@ -515,7 +515,7 @@ public class WritableMemoryImplTest { ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer(); byteBufRO.order(ByteOrder.nativeOrder()); - WritableMemory.wrap(byteBufRO); + WritableMemory.writableWrap(byteBufRO); } @Test @@ -553,7 +553,7 @@ public class WritableMemoryImplTest { public void checkIsReadOnly() { long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 }; - WritableMemory wmem = WritableMemory.wrap(srcArray); + WritableMemory wmem = WritableMemory.writableWrap(srcArray); assertFalse(wmem.isReadOnly()); Memory memRO = wmem; @@ -667,8 +667,8 @@ public class WritableMemoryImplTest { @Test public void checkIsSameResource() { byte[] byteArr = new byte[64]; - WritableMemory wmem1 = WritableMemory.wrap(byteArr); - WritableMemory wmem2 = WritableMemory.wrap(byteArr); + WritableMemory wmem1 = WritableMemory.writableWrap(byteArr); + WritableMemory wmem2 = WritableMemory.writableWrap(byteArr); assertTrue(wmem1.isSameResource(wmem2)); } @@ -677,7 +677,7 @@ public class WritableMemoryImplTest { ByteBuffer byteBuf = ByteBuffer.allocate(64); byteBuf.position(16); byteBuf.limit(48); - WritableMemory wmem = WritableMemory.wrap(byteBuf); + WritableMemory wmem = WritableMemory.writableWrap(byteBuf); WritableBuffer wbuf = wmem.asWritableBuffer(); assertEquals(wbuf.getCapacity(), 64); assertEquals(wbuf.getPosition(), 0); diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java index bbbb7ca..54c9515 100644 --- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java @@ -39,7 +39,7 @@ public class WritableMemoryTest { @Test public void wrapBigEndian() { ByteBuffer bb = ByteBuffer.allocate(64); //big endian - WritableMemory wmem = WritableMemory.wrap(bb); + WritableMemory wmem = WritableMemory.writableWrap(bb); assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN); } @@ -47,7 +47,7 @@ public class WritableMemoryTest { public void wrapBigEndianAsLittle() { ByteBuffer bb = ByteBuffer.allocate(64); bb.putChar(0, (char)1); //as BE - WritableMemory wmem = WritableMemory.wrap(bb, ByteOrder.LITTLE_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(bb, ByteOrder.LITTLE_ENDIAN); assertEquals(wmem.getChar(0), 256); } @@ -62,7 +62,7 @@ public class WritableMemoryTest { @Test public void checkGetArray() { byte[] byteArr = new byte[64]; - WritableMemory wmem = WritableMemory.wrap(byteArr); + WritableMemory wmem = WritableMemory.writableWrap(byteArr); assertTrue(wmem.getArray() == byteArr); WritableBuffer wbuf = wmem.asWritableBuffer(); assertTrue(wbuf.getArray() == byteArr); @@ -71,7 +71,7 @@ public class WritableMemoryTest { @Test(expectedExceptions = IllegalArgumentException.class) public void checkSelfArrayCopy() { byte[] srcAndDst = new byte[128]; - WritableMemory wmem = WritableMemory.wrap(srcAndDst); + WritableMemory wmem = WritableMemory.writableWrap(srcAndDst); wmem.getByteArray(0, srcAndDst, 64, 64); //non-overlapping } @@ -160,11 +160,11 @@ public class WritableMemoryTest { @Test public void checkWrapWithBO() { - WritableMemory wmem = WritableMemory.wrap(new byte[0], ByteOrder.BIG_ENDIAN); + WritableMemory wmem = WritableMemory.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN); boolean nativeBO = wmem.getTypeByteOrder() == Util.nativeByteOrder; assertTrue(nativeBO); //remains true for ZeroSizeMemory println("" + nativeBO); - wmem = WritableMemory.wrap(new byte[8], ByteOrder.BIG_ENDIAN); + wmem = WritableMemory.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN); nativeBO = wmem.getTypeByteOrder() == Util.nativeByteOrder; assertFalse(nativeBO); println("" + nativeBO); diff --git a/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java b/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java index 7554996..6d5cd76 100644 --- a/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java +++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java @@ -42,7 +42,7 @@ public class XxHash64LoopingTest { for (int i = 0; i < 1025; i++) { byte[] byteArr = new byte[i]; for (int j = 0; j < byteArr.length; j++) { byteArr[j] = (byte) j; } - WritableMemory wmem = WritableMemory.wrap(byteArr); + WritableMemory wmem = WritableMemory.writableWrap(byteArr); long hash = wmem.xxHash64(0, byteArr.length, seed); assertEquals(hash, HASHES_OF_LOOPING_BYTES_WITH_SEED_42[i]); } diff --git a/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java index b0f6339..81f6c82 100644 --- a/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java +++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java @@ -65,7 +65,7 @@ public class XxHash64Test { for (int j = 1; j < bytes; j++) { byte[] in = new byte[bytes]; - WritableMemory wmem = WritableMemory.wrap(in); + WritableMemory wmem = WritableMemory.writableWrap(in); for (int i = 0; i < j; i++) { wmem.putByte(i, (byte) (-128 + i)); } long hash =wmem.xxHash64(offset, bytes, seed); @@ -126,7 +126,7 @@ public class XxHash64Test { @Test public void testArrHashes() { - WritableMemory wmem = WritableMemory.wrap(barr); + WritableMemory wmem = WritableMemory.writableWrap(barr); long hash0 = wmem.xxHash64(8, 8, 0); long hash1 = hashBytes(barr, 8, 8, 0); assertEquals(hash1, hash0); --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
