You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by le...@apache.org on 2021/05/18 19:57:07 UTC
[datasketches-memory] branch CreateInternal2 created (now f686454)
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a change to branch CreateInternal2
in repository https://gitbox.apache.org/repos/asf/datasketches-memory.git.
at f686454 Refactoring complete.
This branch includes the following new commits:
new 625ffa0 Initial rename of ../memory to ../memory/internal
new 6ccfa2d Interim changes
new aa960a2 Interim commit. All tests pass.
new 4d357ed Refactored BaseState to BaseStateImpl, created interface BaseState.
new 16511d0 Interim. Completed refactoring of Memory Hierarch.
new a43140d Interim commit. Completed refactoring of Memory hierarchy.
new 8a57026 Finished refactoring Buffer tree, which completes main.
new f686454 Refactoring complete.
The 8 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 02/08: Interim changes
Posted by le...@apache.org.
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 6ccfa2dccfd61f50dd897395b7e3c636c248d5ce
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Sat May 15 15:23:11 2021 -0700
Interim changes
Created MapHandleImpl
---
.../{internal => }/DefaultMemoryRequestServer.java | 4 +++-
.../datasketches/memory/{internal => }/Handle.java | 4 +++-
.../datasketches/memory/{internal => }/Map.java | 4 ++--
.../WritableHandle.java => MapHandle.java} | 28 +++++++++++++++-------
.../memory/{internal => }/MemoryRequestServer.java | 5 +++-
.../memory/{internal => }/WritableHandle.java | 4 +++-
.../memory/{internal => }/WritableMap.java | 4 ++--
.../memory/internal/AllocateDirectMap.java | 1 +
.../memory/internal/AllocateDirectWritableMap.java | 2 ++
.../datasketches/memory/internal/BaseState.java | 3 +++
.../memory/internal/BaseWritableMemoryImpl.java | 2 ++
.../DirectNonNativeWritableBufferImpl.java | 2 ++
.../DirectNonNativeWritableMemoryImpl.java | 2 ++
.../memory/internal/DirectWritableBufferImpl.java | 2 ++
.../memory/internal/DirectWritableMemoryImpl.java | 2 ++
.../{MapHandle.java => MapHandleImpl.java} | 15 ++++--------
.../datasketches/memory/internal/Memory.java | 3 +++
.../memory/internal/WritableBuffer.java | 3 +++
.../memory/internal/WritableDirectHandle.java | 3 +++
.../memory/internal/WritableMapHandle.java | 6 ++++-
.../memory/internal/WritableMemory.java | 5 ++++
.../datasketches/memory/internal/package-info.java | 4 ++--
.../WritableHandle.java => package-info.java} | 17 ++-----------
.../memory/test/AllocateDirectMapMemoryTest.java | 2 +-
.../memory/test/AllocateDirectMemoryTest.java | 4 ++--
.../test/AllocateDirectWritableMapMemoryTest.java | 4 ++--
.../datasketches/memory/test/BaseBufferTest.java | 2 +-
.../memory/test/BufferInvariantsTest.java | 2 +-
.../datasketches/memory/test/BufferTest.java | 2 +-
.../datasketches/memory/test/CommonBufferTest.java | 2 +-
.../datasketches/memory/test/CommonMemoryTest.java | 2 +-
.../memory/test/CopyMemoryOverlapTest.java | 2 +-
.../datasketches/memory/test/CopyMemoryTest.java | 2 +-
.../test/ExampleMemoryRequestServerTest.java | 4 ++--
.../memory/test/IgnoredArrayOverflowTest.java | 2 +-
.../memory/test/MemoryReadWriteSafetyTest.java | 2 +-
.../datasketches/memory/test/MemoryTest.java | 4 ++--
.../memory/test/MemoryWriteToTest.java | 2 +-
.../datasketches/memory/test/ReflectUtil.java | 2 +-
.../memory/test/WritableBufferImplTest.java | 2 +-
.../memory/test/WritableDirectCopyTest.java | 2 +-
.../memory/test/WritableMemoryImplTest.java | 2 +-
42 files changed, 103 insertions(+), 68 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DefaultMemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
similarity index 96%
rename from src/main/java/org/apache/datasketches/memory/internal/DefaultMemoryRequestServer.java
rename to src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
index 20c481a..8f789f6 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DefaultMemoryRequestServer.java
+++ b/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
@@ -17,7 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory;
+
+import org.apache.datasketches.memory.internal.WritableMemory;
/**
* This is a simple implementation of the MemoryRequestServer that creates space on the Java heap
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Handle.java b/src/main/java/org/apache/datasketches/memory/Handle.java
similarity index 96%
rename from src/main/java/org/apache/datasketches/memory/internal/Handle.java
rename to src/main/java/org/apache/datasketches/memory/Handle.java
index dc5493f..f92b284 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Handle.java
+++ b/src/main/java/org/apache/datasketches/memory/Handle.java
@@ -17,7 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory;
+
+import org.apache.datasketches.memory.internal.Memory;
/**
* A handle for read-only resource.
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Map.java b/src/main/java/org/apache/datasketches/memory/Map.java
similarity index 93%
rename from src/main/java/org/apache/datasketches/memory/internal/Map.java
rename to src/main/java/org/apache/datasketches/memory/Map.java
index f17a24f..6b99059 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Map.java
+++ b/src/main/java/org/apache/datasketches/memory/Map.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory;
/**
* Read only interface for a memory mapped file
@@ -26,7 +26,7 @@ package org.apache.datasketches.memory.internal;
* @author Lee Rhodes
* @author Praveenkumar Venkatesan
*/
-interface Map extends AutoCloseable {
+public interface Map extends AutoCloseable {
/**
* @see <a href="https://docs.oracle.com/javase/8/docs/api/java/nio/MappedByteBuffer.html#load--">
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java b/src/main/java/org/apache/datasketches/memory/MapHandle.java
similarity index 67%
copy from src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
copy to src/main/java/org/apache/datasketches/memory/MapHandle.java
index e9361ad..fc61ec5 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/MapHandle.java
@@ -17,21 +17,31 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+
+package org.apache.datasketches.memory;
+
+import org.apache.datasketches.memory.internal.Memory;
+
/**
- * A Handle for writable direct memory or a memory-mapped, writable file resource.
- * Please read Javadocs for {@link Handle}.
+ * 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}.
*
* @author Lee Rhodes
* @author Roman Leventov
*/
-public interface WritableHandle extends Handle {
+public interface MapHandle extends Map, Handle {
- /**
- * Gets a WritableMemory
- * @return a WritableMemory
- */
@Override
- WritableMemory get();
+ Memory get();
+
+ @Override
+ void close();
+
+ @Override
+ void load();
+
+ @Override
+ boolean isLoaded();
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
similarity index 91%
rename from src/main/java/org/apache/datasketches/memory/internal/MemoryRequestServer.java
rename to src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
index d98ab78..977664c 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MemoryRequestServer.java
+++ b/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
@@ -17,7 +17,10 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory;
+
+import org.apache.datasketches.memory.internal.WritableDirectHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
/**
* The MemoryRequestServer is a callback interface to provide a means for a direct (off-heap),
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java b/src/main/java/org/apache/datasketches/memory/WritableHandle.java
similarity index 91%
copy from src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
copy to src/main/java/org/apache/datasketches/memory/WritableHandle.java
index e9361ad..8b2aaa7 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableHandle.java
@@ -17,7 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory;
+
+import org.apache.datasketches.memory.internal.WritableMemory;
/**
* A Handle for writable direct memory or a memory-mapped, writable file resource.
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMap.java b/src/main/java/org/apache/datasketches/memory/WritableMap.java
similarity index 92%
rename from src/main/java/org/apache/datasketches/memory/internal/WritableMap.java
rename to src/main/java/org/apache/datasketches/memory/WritableMap.java
index 5c35c43..21502a7 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMap.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableMap.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory;
/**
* Writable interface for a memory mapped file
@@ -26,7 +26,7 @@ package org.apache.datasketches.memory.internal;
* @author Lee Rhodes
* @author Praveenkumar Venkatesan
*/
-interface WritableMap extends Map {
+public interface WritableMap extends Map {
/**
* @see <a href="https://docs.oracle.com/javase/8/docs/api/java/nio/MappedByteBuffer.html#force--">
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 6272b5b..324c89e 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
@@ -30,6 +30,7 @@ import java.lang.reflect.Method;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
+import org.apache.datasketches.memory.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
diff --git a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
index 588dbef..0d7d609 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
@@ -21,6 +21,8 @@ package org.apache.datasketches.memory.internal;
import java.io.File;
+import org.apache.datasketches.memory.WritableMap;
+
/**
* Allocates direct memory used to memory map files for write operations
* (including those > 2GB).
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseState.java b/src/main/java/org/apache/datasketches/memory/internal/BaseState.java
index 9bb685b..791a31d 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseState.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseState.java
@@ -28,6 +28,9 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.atomic.AtomicLong;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+
/**
* Keeps key configuration state for Memory and Buffer plus some common static variables
* and check methods.
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 5ba6c27..7ab8494 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
@@ -36,6 +36,8 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.WritableByteChannel;
+import org.apache.datasketches.memory.MemoryRequestServer;
+
/*
* Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill,
* compareTo, etc., use hard checks (checkValid*() and checkBounds()), which execute at runtime and
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
index 442768c..6d8f159 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
@@ -21,6 +21,8 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.MemoryRequestServer;
+
/**
* Implementation of {@link WritableBuffer} for direct memory, non-native byte order.
*
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
index 9d38861..e8f5a64 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
@@ -21,6 +21,8 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.MemoryRequestServer;
+
/**
* Implementation of {@link WritableMemory} for direct memory, non-native byte order.
*
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
index bc54da4..c6cd0e6 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
@@ -21,6 +21,8 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.MemoryRequestServer;
+
/**
* Implementation of {@link WritableBuffer} for direct memory, native byte order.
*
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
index a377782..21eb03c 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
@@ -21,6 +21,8 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.MemoryRequestServer;
+
/**
* Implementation of {@link WritableMemory} for direct memory, native byte order.
*
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapHandle.java b/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java
similarity index 79%
rename from src/main/java/org/apache/datasketches/memory/internal/MapHandle.java
rename to src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java
index 5e8114c..075b577 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java
@@ -19,22 +19,17 @@
package org.apache.datasketches.memory.internal;
-/**
- * A Handle for a memory-mapped, read-only file resource.
- * Please read Javadocs for {@link Handle}.
- *
- * @author Lee Rhodes
- * @author Roman Leventov
- */
-//Joins a Read-only Handle with an AutoCloseable Map resource.
-public class MapHandle implements Map, Handle {
+import org.apache.datasketches.memory.MapHandle;
+
+public class MapHandleImpl implements MapHandle {
+
/**
* Having at least one final field makes this class safe for concurrent publication.
*/
final AllocateDirectMap dirMap;
private BaseWritableMemoryImpl wMem;
- MapHandle(final AllocateDirectMap dirMap, final BaseWritableMemoryImpl wMem) {
+ MapHandleImpl(final AllocateDirectMap dirMap, final BaseWritableMemoryImpl wMem) {
this.dirMap = dirMap;
this.wMem = wMem;
}
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 a5d3751..a369977 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Memory.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Memory.java
@@ -29,6 +29,9 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.WritableByteChannel;
+import org.apache.datasketches.memory.Handle;
+import org.apache.datasketches.memory.MapHandle;
+
/**
* Provides read-only primitive and primitive array methods to any of the four resources
* mentioned in the package level documentation.
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java b/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
index cafa879..d6f5e88 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
@@ -22,6 +22,9 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+
/**
* Provides read and write, positional primitive and primitive array access to any of the four
* resources mentioned at the package level.
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java
index 4689191..8e490b8 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java
@@ -19,6 +19,9 @@
package org.apache.datasketches.memory.internal;
+import org.apache.datasketches.memory.Handle;
+import org.apache.datasketches.memory.WritableHandle;
+
/**
* A Handle for a writable direct memory resource.
* Please read Javadocs for {@link Handle}.
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java
index 8404855..0cefbd6 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java
@@ -19,6 +19,10 @@
package org.apache.datasketches.memory.internal;
+import org.apache.datasketches.memory.Handle;
+import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.WritableMap;
+
/**
* A Handle for a memory-mapped, writable file resource.
* Please read Javadocs for {@link Handle}.
@@ -27,7 +31,7 @@ package org.apache.datasketches.memory.internal;
* @author Lee Rhodes
*/
//Joins a WritableHandle with an AutoCloseable WritableMap resource
-public final class WritableMapHandle extends MapHandle implements WritableMap, WritableHandle {
+public final class WritableMapHandle extends MapHandleImpl implements WritableMap, WritableHandle {
WritableMapHandle(final AllocateDirectWritableMap dirWmap,
final BaseWritableMemoryImpl 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 e442eb0..6f9d8fd 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java
@@ -28,6 +28,11 @@ import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.Handle;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableHandle;
+
/**
* Provides read and write primitive and primitive array access to any of the four resources
* mentioned at the package level.
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 45ef820..1ca7aef 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
@@ -84,7 +84,7 @@
*
* <p>An access API is joined with
* a resource either with a static factory method or in combination with a
- * {@link org.apache.datasketches.memory.internal.Handle}, which is used exclusively for resources that are
+ * {@link org.apache.datasketches.memory.Handle}, which is used exclusively for resources that are
* external to the JVM, such as allocation of direct memory and memory-mapped files.</p>
*
* <p>The role of a Handle is to hold onto the reference of a resource that is outside the control
@@ -93,7 +93,7 @@
* <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.MapHandle}
+ * <ul><li>{@link org.apache.datasketches.memory.internal.MapHandleImpl}
* for read-only access to a memory-mapped file</li>
* <li>{@link org.apache.datasketches.memory.internal.WritableMapHandle}
* for writable access to a memory-mapped file</li>
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java b/src/main/java/org/apache/datasketches/memory/package-info.java
similarity index 68%
rename from src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
rename to src/main/java/org/apache/datasketches/memory/package-info.java
index e9361ad..0474617 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/package-info.java
@@ -17,21 +17,8 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
-
/**
- * A Handle for writable direct memory or a memory-mapped, writable file resource.
- * Please read Javadocs for {@link Handle}.
+ * @author lrhodes
*
- * @author Lee Rhodes
- * @author Roman Leventov
*/
-public interface WritableHandle extends Handle {
-
- /**
- * Gets a WritableMemory
- * @return a WritableMemory
- */
- @Override
- WritableMemory get();
-}
+package org.apache.datasketches.memory;
diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
index c5b7c9f..bfe2d05 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
@@ -32,7 +32,7 @@ import static org.testng.Assert.fail;
import java.io.File;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.MapHandle;
+import org.apache.datasketches.memory.MapHandle;
import org.apache.datasketches.memory.internal.Memory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
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 2f9b8e0..5618423 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
@@ -26,10 +26,10 @@ import static org.testng.Assert.fail;
import java.lang.reflect.InvocationTargetException;
-import org.apache.datasketches.memory.internal.MemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
+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.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
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 b8a9b74..735f52c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
@@ -37,11 +37,11 @@ import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.MapHandle;
+import org.apache.datasketches.memory.MapHandle;
+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.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMapHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.AfterClass;
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
index 6815fd9..51b2ded 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
@@ -21,9 +21,9 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.fail;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
index d08ef0d..50b6557 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
@@ -24,9 +24,9 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
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 e80b2a0..86b379e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
@@ -25,10 +25,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.Memory;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
import org.testng.collections.Lists;
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
index 023270e..f3b78ee 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
@@ -21,8 +21,8 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
index f28a301..5cde091 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
@@ -27,7 +27,7 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
-import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
index 67da58a..f82561a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
@@ -21,8 +21,8 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
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 03b4bec..dc6a162 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
@@ -24,8 +24,8 @@ import static org.testng.Assert.assertEquals;
import java.util.concurrent.ThreadLocalRandom;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
index 446a825..cbff8d5 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertFalse;
import java.util.IdentityHashMap;
-import org.apache.datasketches.memory.internal.MemoryRequestServer;
-import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
index 462de6c..2b6b36a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
@@ -19,7 +19,7 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
index 572d019..b712060 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
@@ -25,7 +25,7 @@ import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.MapHandle;
+import org.apache.datasketches.memory.MapHandle;
import org.apache.datasketches.memory.internal.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.WritableMemory;
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 3166a12..1281b26 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
@@ -35,11 +35,11 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
-import org.apache.datasketches.memory.internal.MapHandle;
+import org.apache.datasketches.memory.MapHandle;
+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.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
index d6c10a9..01f06e0 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
@@ -27,8 +27,8 @@ import java.nio.channels.Channels;
import java.nio.channels.WritableByteChannel;
import java.util.concurrent.ThreadLocalRandom;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
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 266ea8e..d57af89 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
@@ -23,7 +23,7 @@ import java.io.File;
import java.lang.reflect.*;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.MemoryRequestServer;
+import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.internal.WritableDirectHandle;
public final class ReflectUtil {
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 e3eb97d..bdb0354 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
@@ -26,13 +26,13 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
index f351c0c..cd3e7ad 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
@@ -22,8 +22,8 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
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 afd52fd..292ba0a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
@@ -27,13 +27,13 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableHandle;
import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 06/08: Interim commit. Completed refactoring
of Memory hierarchy.
Posted by le...@apache.org.
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 a43140dabcafa4f97f112282d1a06e28db1ea059
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Mon May 17 16:48:52 2021 -0700
Interim commit. Completed refactoring of Memory hierarchy.
Buffer hierarchy is not done, many errors in test. Main compiles clean,
no warnings.
---
.../memory/DefaultMemoryRequestServer.java | 4 +-
.../org/apache/datasketches/memory/Handle.java | 4 -
.../org/apache/datasketches/memory/Memory.java | 525 ++++++++++++++++++++-
.../datasketches/memory/MemoryRequestServer.java | 2 -
.../datasketches/memory/WritableDirectHandle.java | 2 +-
.../apache/datasketches/memory/WritableHandle.java | 5 +-
...WritableMemoryImpl.java => WritableMemory.java} | 216 ++++-----
.../memory/internal/AllocateDirect.java | 2 +-
.../memory/internal/AllocateDirectMap.java | 5 +-
.../memory/internal/AllocateDirectWritableMap.java | 6 +-
.../internal/BBNonNativeWritableMemoryImpl.java | 2 +-
.../memory/internal/BBWritableMemoryImpl.java | 4 +-
.../memory/internal/BaseStateImpl.java | 20 +-
.../memory/internal/BaseWritableBufferImpl.java | 8 +-
.../memory/internal/BaseWritableMemoryImpl.java | 30 +-
.../datasketches/memory/internal/Buffer.java | 30 +-
.../memory/internal/CompareAndCopy.java | 2 +-
.../DirectNonNativeWritableBufferImpl.java | 2 +-
.../DirectNonNativeWritableMemoryImpl.java | 4 +-
.../memory/internal/DirectWritableBufferImpl.java | 2 +-
.../memory/internal/DirectWritableMemoryImpl.java | 4 +-
.../internal/HeapNonNativeWritableMemoryImpl.java | 2 +-
.../memory/internal/HeapWritableMemoryImpl.java | 4 +-
.../memory/internal/MapHandleImpl.java | 6 +-
.../internal/MapNonNativeWritableBufferImpl.java | 2 +-
.../internal/MapNonNativeWritableMemoryImpl.java | 4 +-
.../memory/internal/MapWritableBufferImpl.java | 2 +-
.../memory/internal/MapWritableMemoryImpl.java | 6 +-
.../datasketches/memory/internal/MemoryImpl.java | 446 ++---------------
.../memory/internal/NativeWritableMemoryImpl.java | 6 +-
.../internal/NonNativeWritableMemoryImpl.java | 4 +-
.../apache/datasketches/memory/internal/Utf8.java | 8 +-
.../memory/internal/Utf8CodingException.java | 2 +-
.../apache/datasketches/memory/internal/Util.java | 6 +-
.../memory/internal/WritableBuffer.java | 34 +-
.../memory/internal/WritableDirectHandleImpl.java | 15 +-
.../memory/internal/WritableMapHandleImpl.java | 5 +-
.../memory/internal/WritableMemoryImpl.java | 520 +++-----------------
.../datasketches/memory/internal/package-info.java | 36 +-
.../memory/test/AllocateDirectMapMemoryTest.java | 26 +-
.../memory/test/AllocateDirectMemoryTest.java | 22 +-
.../test/AllocateDirectWritableMapMemoryTest.java | 36 +-
.../datasketches/memory/test/BaseBufferTest.java | 14 +-
.../datasketches/memory/test/BaseStateTest.java | 14 +-
.../datasketches/memory/test/Buffer2Test.java | 32 +-
.../memory/test/BufferBoundaryCheckTest.java | 4 +-
.../memory/test/BufferInvariantsTest.java | 12 +-
.../memory/test/BufferReadWriteSafetyTest.java | 8 +-
.../datasketches/memory/test/BufferTest.java | 56 +--
.../datasketches/memory/test/CommonBufferTest.java | 22 +-
.../datasketches/memory/test/CommonMemoryTest.java | 44 +-
.../memory/test/CopyMemoryOverlapTest.java | 26 +-
.../datasketches/memory/test/CopyMemoryTest.java | 56 +--
.../test/ExampleMemoryRequestServerTest.java | 28 +-
.../memory/test/IgnoredArrayOverflowTest.java | 6 +-
.../datasketches/memory/test/LeafImplTest.java | 32 +-
.../memory/test/MemoryBoundaryCheckTest.java | 4 +-
.../memory/test/MemoryReadWriteSafetyTest.java | 42 +-
.../datasketches/memory/test/MemoryTest.java | 156 +++---
.../memory/test/MemoryWriteToTest.java | 22 +-
.../datasketches/memory/test/NioBitsTest.java | 2 +-
.../test/NonNativeWritableBufferImplTest.java | 30 +-
.../test/NonNativeWritableMemoryImplTest.java | 36 +-
.../datasketches/memory/test/SpecificLeafTest.java | 44 +-
.../apache/datasketches/memory/test/Utf8Test.java | 50 +-
.../apache/datasketches/memory/test/UtilTest.java | 4 +-
.../memory/test/WritableBufferImplTest.java | 104 ++--
.../memory/test/WritableDirectCopyTest.java | 66 +--
.../memory/test/WritableMemoryImplTest.java | 176 +++----
.../memory/test/WritableMemoryTest.java | 48 +-
.../memory/test/XxHash64LoopingTest.java | 4 +-
.../datasketches/memory/test/XxHash64Test.java | 14 +-
.../datasketches/memory/test/ZeroCapacityTest.java | 16 +-
73 files changed, 1483 insertions(+), 1760 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
index 607995f..a870b9b 100644
--- a/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
+++ b/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
@@ -19,7 +19,7 @@
package org.apache.datasketches.memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
/**
* This is a simple implementation of the MemoryRequestServer that creates space on the Java heap
@@ -75,7 +75,7 @@ public final class DefaultMemoryRequestServer implements MemoryRequestServer {
*/
@Override
public WritableMemory request(final long capacityBytes) {
- final WritableMemory wmem = WritableMemory.allocate((int)capacityBytes);
+ final WritableMemory wmem = WritableMemoryImpl.allocate((int)capacityBytes);
return wmem;
}
diff --git a/src/main/java/org/apache/datasketches/memory/Handle.java b/src/main/java/org/apache/datasketches/memory/Handle.java
index f92b284..c541282 100644
--- a/src/main/java/org/apache/datasketches/memory/Handle.java
+++ b/src/main/java/org/apache/datasketches/memory/Handle.java
@@ -19,8 +19,6 @@
package org.apache.datasketches.memory;
-import org.apache.datasketches.memory.internal.Memory;
-
/**
* A handle for read-only resource.
*
@@ -58,6 +56,4 @@ public interface Handle extends AutoCloseable {
*/
Memory get();
- @Override
- void close();
}
diff --git a/src/main/java/org/apache/datasketches/memory/Memory.java b/src/main/java/org/apache/datasketches/memory/Memory.java
index b170ad9..01d7891 100644
--- a/src/main/java/org/apache/datasketches/memory/Memory.java
+++ b/src/main/java/org/apache/datasketches/memory/Memory.java
@@ -20,8 +20,531 @@
package org.apache.datasketches.memory;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.WritableByteChannel;
-public interface Memory {
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.Utf8CodingException;
+import org.apache.datasketches.memory.internal.Util;
+
+public interface Memory extends BaseState {
+
+ //BYTE BUFFER
+
+ /**
+ * Accesses the given ByteBuffer for read-only operations. The returned <i>MemoryImpl</i> object has
+ * the same byte order, as the given ByteBuffer, unless the capacity of the given ByteBuffer is
+ * zero, then byte order of the returned <i>Memory</i> object (as well as backing storage) is
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param byteBuf the given ByteBuffer, must not be null
+ * @return a new <i>Memory</i> for read-only operations on the given ByteBuffer.
+ */
+ static Memory wrap(final ByteBuffer byteBuf) {
+ return MemoryImpl.wrap(byteBuf);
+ }
+
+ /**
+ * Accesses the given ByteBuffer for read-only operations. The returned <i>Memory</i> object has
+ * the given byte order, ignoring the byte order of the given ByteBuffer. If the capacity of the
+ * given ByteBuffer is zero the byte order of the returned <i>Memory</i> object (as well as
+ * backing storage) is unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param byteBuf the given ByteBuffer, must not be null
+ * @param byteOrder the byte order to be used, whicn may be independent of the byte order
+ * state of the given ByteBuffer.
+ * @return a new <i>Memory</i> for read-only operations on the given ByteBuffer.
+ */
+ static Memory wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ return MemoryImpl.wrap(byteBuf, byteOrder);
+ }
+
+ //MAP
+ /**
+ * Maps the entire given file into native-ordered Memory for read operations
+ * (including those > 2GB).
+ * Calling this method is equivalent to calling {@link #map(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>Memory.map(...)</i>.
+ * @param file the given file to map
+ * @return <i>MapHandle</i> for managing the mapped Memory.
+ * Please read Javadocs for {@link Handle}.
+ */
+ static MapHandle map(final File file) {
+ return MemoryImpl.map(file, 0, file.length(), ByteOrder.nativeOrder());
+ }
+
+ /**
+ * Maps the specified portion of the given file into Memory for read operations
+ * (including those > 2GB).
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.map(...)</i>.
+ * @param file the given file to map. It may not be null.
+ * @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 mapped Memory. It may not be null.
+ * @return <i>MapHandle</i> for managing the mapped Memory.
+ * Please read Javadocs for {@link Handle}.
+ */
+ static MapHandle map(final File file, final long fileOffsetBytes, final long capacityBytes,
+ final ByteOrder byteOrder) {
+ return MemoryImpl.map(file, fileOffsetBytes, capacityBytes, byteOrder);
+ }
+
+ //REGIONS
+ /**
+ * A region is a read-only view of this object.
+ * <ul>
+ * <li>Returned object's origin = this object's origin + offsetBytes</li>
+ * <li>Returned object's capacity = capacityBytes</li>
+ * </ul>
+ * If the given capacityBytes is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ * @param offsetBytes the starting offset with respect to the origin of this Memory.
+ * @param capacityBytes the capacity of the region in bytes
+ * @return a new <i>Memory</i> representing the defined region based on the given
+ * offsetBytes and capacityBytes.
+ */
+ MemoryImpl region(long offsetBytes, long capacityBytes);
+
+ /**
+ * A region is a read-only view of this object.
+ * <ul>
+ * <li>Returned object's origin = this object's origin + <i>offsetBytes</i></li>
+ * <li>Returned object's capacity = <i>capacityBytes</i></li>
+ * <li>Returned object's byte order = <i>byteOrder</i></li>
+ * </ul>
+ * If the given capacityBytes is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ * @param offsetBytes the starting offset with respect to the origin of this Memory.
+ * @param capacityBytes the capacity of the region in bytes
+ * @param byteOrder the given byte order
+ * @return a new <i>Memory</i> representing the defined region based on the given
+ * offsetBytes, capacityBytes and byteOrder.
+ */
+ MemoryImpl region(long offsetBytes, long capacityBytes, ByteOrder byteOrder);
+
+ //AS BUFFER
+ /**
+ * Returns a new <i>Buffer</i> view of this object.
+ * <ul>
+ * <li>Returned object's origin = this object's origin</li>
+ * <li>Returned object's <i>start</i> = 0</li>
+ * <li>Returned object's <i>position</i> = 0</li>
+ * <li>Returned object's <i>end</i> = this object's capacity</li>
+ * <li>Returned object's <i>capacity</i> = this object's capacity</li>
+ * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
+ * </ul>
+ * If this object's capacity is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ * @return a new <i>Buffer</i>
+ */
+ Buffer asBuffer();
+
+ /**
+ * Returns a new <i>Buffer</i> view of this object, with the given
+ * byte order.
+ * <ul>
+ * <li>Returned object's origin = this object's origin</li>
+ * <li>Returned object's <i>start</i> = 0</li>
+ * <li>Returned object's <i>position</i> = 0</li>
+ * <li>Returned object's <i>end</i> = this object's capacity</li>
+ * <li>Returned object's <i>capacity</i> = this object's capacity</li>
+ * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
+ * </ul>
+ * If this object's capacity is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ * @param byteOrder the given byte order
+ * @return a new <i>Buffer</i> with the given byteOrder.
+ */
+ Buffer asBuffer(ByteOrder byteOrder);
+
+ //UNSAFE BYTE BUFFER VIEW
+ /**
+ * Returns the specified region of this Memory object as a new read-only {@link ByteBuffer}
+ * object. The {@link ByteOrder} of the returned {@code ByteBuffer} corresponds to the {@linkplain
+ * #getTypeByteOrder() byte order of this Memory}. The returned ByteBuffer's position is 0 and
+ * the limit is equal to the capacity.
+ *
+ * <p>If this Memory object is the result of wrapping non-byte Java arrays ({@link
+ * Memory#wrap(int[])}, {@link Memory#wrap(long[])}, etc.) this methods throws an {@link
+ * UnsupportedOperationException}.
+ *
+ * <p>The name of this method starts with "unsafe" because if this is a native managed Memory
+ * (e. g. obtained via {@link #map(File)} or {@link WritableMemory#allocateDirect(long)})), and
+ * the returned {@code ByteBuffer} object is used after the Memory is freed, it may cause a JVM
+ * crash. This is also possible for Memory objects themselves with some methods,
+ * but Memory's use-after-free is caught as an AssertionError, if assertions are enabled.
+ *
+ * @param offsetBytes the starting offset with respect to the origin of this Memory
+ * @param capacityBytes the capacity of the returned ByteBuffer
+ * @return a new read-only {@code ByteBuffer} to access the specified region.
+ * @throws UnsupportedOperationException if this method couldn't be viewed as ByteBuffer, because
+ * when it wraps a non-byte Java array.
+ */
+ ByteBuffer unsafeByteBufferView(long offsetBytes, int capacityBytes);
+
+ //ACCESS PRIMITIVE HEAP ARRAYS for readOnly
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final boolean[] arr) {
+ return MemoryImpl.wrap(arr);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>MemoryImpl</i> object are
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final byte[] arr) {
+ return MemoryImpl.wrap(arr, 0, arr.length, Util.nativeByteOrder);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations with the given byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @param byteOrder the byte order to be used
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final byte[] arr, final ByteOrder byteOrder) {
+ return MemoryImpl.wrap(arr, 0, arr.length, byteOrder);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations with the given byte order. If the given
+ * lengthBytes is zero, backing storage and byte order of the returned <i>Memory</i> object are
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @param offsetBytes the byte offset into the given array
+ * @param lengthBytes the number of bytes to include from the given array
+ * @param byteOrder the byte order to be used
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final byte[] arr, final int offsetBytes, final int lengthBytes,
+ final ByteOrder byteOrder) {
+ return MemoryImpl.wrap(arr, offsetBytes, lengthBytes, byteOrder);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final char[] arr) {
+ return MemoryImpl.wrap(arr);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final short[] arr) {
+ return MemoryImpl.wrap(arr);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final int[] arr) {
+ return MemoryImpl.wrap(arr);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final long[] arr) {
+ return MemoryImpl.wrap(arr);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final float[] arr) {
+ return MemoryImpl.wrap(arr);
+ }
+
+ /**
+ * Wraps the given primitive array for read operations assuming native byte order. If the array
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
+ * unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>Memory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new <i>Memory</i> for read operations
+ */
+ static Memory wrap(final double[] arr) {
+ return MemoryImpl.wrap(arr);
+ }
+
+ //PRIMITIVE getX() and getXArray()
+ /**
+ * Gets the boolean value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the boolean at the given offset
+ */
+ boolean getBoolean(long offsetBytes);
+
+ /**
+ * Gets the boolean array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetBooleans offset in array units
+ * @param lengthBooleans number of array units to transfer
+ */
+ void getBooleanArray(long offsetBytes, boolean[] dstArray, int dstOffsetBooleans, int lengthBooleans);
+
+ /**
+ * Gets the byte value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the byte at the given offset
+ */
+ byte getByte(long offsetBytes);
+
+ /**
+ * Gets the byte array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetBytes offset in array units
+ * @param lengthBytes number of array units to transfer
+ */
+ void getByteArray(long offsetBytes, byte[] dstArray, int dstOffsetBytes, int lengthBytes);
+
+ /**
+ * Gets the char value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the char at the given offset
+ */
+ char getChar(long offsetBytes);
+
+ /**
+ * Gets the char array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetChars offset in array units
+ * @param lengthChars number of array units to transfer
+ */
+ void getCharArray(long offsetBytes, char[] dstArray, int dstOffsetChars, int lengthChars);
+
+ /**
+ * Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of
+ * utf8LengthBytes, decodes them into characters and appends them to the given Appendable.
+ * This is specifically designed to reduce the production of intermediate objects (garbage),
+ * thus significantly reducing pressure on the JVM Garbage Collector.
+ * @param offsetBytes offset bytes relative to the Memory start
+ * @param utf8LengthBytes the number of encoded UTF-8 bytes to decode. It is assumed that the
+ * caller has the correct number of utf8 bytes required to decode the number of characters
+ * to be appended to dst. Characters outside the ASCII range can require 2, 3 or 4 bytes per
+ * character to decode.
+ * @param dst the destination Appendable to append the decoded characters to.
+ * @return the number of characters decoded
+ * @throws IOException if dst.append() throws IOException
+ * @throws Utf8CodingException in case of malformed or illegal UTF-8 input
+ */
+ int getCharsFromUtf8(long offsetBytes, int utf8LengthBytes, Appendable dst)
+ throws IOException, Utf8CodingException;
+
+ /**
+ * Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of
+ * utf8LengthBytes, decodes them into characters and appends them to the given StringBuilder.
+ * This method does *not* reset the length of the destination StringBuilder before appending
+ * characters to it.
+ * This is specifically designed to reduce the production of intermediate objects (garbage),
+ * thus significantly reducing pressure on the JVM Garbage Collector.
+ * @param offsetBytes offset bytes relative to the Memory start
+ * @param utf8LengthBytes the number of encoded UTF-8 bytes to decode. It is assumed that the
+ * caller has the correct number of utf8 bytes required to decode the number of characters
+ * to be appended to dst. Characters outside the ASCII range can require 2, 3 or 4 bytes per
+ * character to decode.
+ * @param dst the destination StringBuilder to append decoded characters to.
+ * @return the number of characters decoded.
+ * @throws Utf8CodingException in case of malformed or illegal UTF-8 input
+ */
+ int getCharsFromUtf8(final long offsetBytes, final int utf8LengthBytes,
+ final StringBuilder dst) throws Utf8CodingException;
+
+ /**
+ * Gets the double value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the double at the given offset
+ */
+ double getDouble(long offsetBytes);
+
+ /**
+ * Gets the double array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetDoubles offset in array units
+ * @param lengthDoubles number of array units to transfer
+ */
+ void getDoubleArray(long offsetBytes, double[] dstArray, int dstOffsetDoubles, int lengthDoubles);
+
+ /**
+ * Gets the float value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the float at the given offset
+ */
+ float getFloat(long offsetBytes);
+
+ /**
+ * Gets the float array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetFloats offset in array units
+ * @param lengthFloats number of array units to transfer
+ */
+ void getFloatArray(long offsetBytes, float[] dstArray, int dstOffsetFloats, int lengthFloats);
+
+ /**
+ * Gets the int value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the int at the given offset
+ */
+ int getInt(long offsetBytes);
+
+ /**
+ * Gets the int array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetInts offset in array units
+ * @param lengthInts number of array units to transfer
+ */
+ void getIntArray(long offsetBytes, int[] dstArray, int dstOffsetInts, int lengthInts);
+
+ /**
+ * Gets the long value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the long at the given offset
+ */
+ long getLong(long offsetBytes);
+
+ /**
+ * Gets the long array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetLongs offset in array units
+ * @param lengthLongs number of array units to transfer
+ */
+ void getLongArray(long offsetBytes, long[] dstArray, int dstOffsetLongs, int lengthLongs);
+
+ /**
+ * Gets the short value at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @return the short at the given offset
+ */
+ short getShort(long offsetBytes);
+
+ /**
+ * Gets the short array at the given offset
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param dstArray The preallocated destination array.
+ * @param dstOffsetShorts offset in array units
+ * @param lengthShorts number of array units to transfer
+ */
+ void getShortArray(long offsetBytes, short[] dstArray, int dstOffsetShorts, int lengthShorts);
+
+ //SPECIAL PRIMITIVE READ METHODS: compareTo, copyTo, writeTo
+ /**
+ * Compares the bytes of this Memory to <i>that</i> Memory.
+ * Returns <i>(this < that) ? (some negative value) : (this > that) ? (some positive value)
+ * : 0;</i>.
+ * If all bytes are equal up to the shorter of the two lengths, the shorter length is considered
+ * to be less than the other.
+ * @param thisOffsetBytes the starting offset for <i>this Memory</i>
+ * @param thisLengthBytes the length of the region to compare from <i>this Memory</i>
+ * @param that the other Memory to compare with
+ * @param thatOffsetBytes the starting offset for <i>that Memory</i>
+ * @param thatLengthBytes the length of the region to compare from <i>that Memory</i>
+ * @return <i>(this < that) ? (some negative value) : (this > that) ? (some positive value)
+ * : 0;</i>
+ */
+ int compareTo(long thisOffsetBytes, long thisLengthBytes, Memory that,
+ long thatOffsetBytes, long thatLengthBytes);
+
+ /**
+ * Copies bytes from a source range of this Memory to a destination range of the given Memory
+ * with the same semantics when copying between overlapping ranges of bytes as method
+ * {@link java.lang.System#arraycopy(Object, int, Object, int, int)} has. However, if the source
+ * and the destination ranges are exactly the same, this method throws {@link
+ * IllegalArgumentException}, because it should never be needed in real-world scenarios and
+ * therefore indicates a bug.
+ * @param srcOffsetBytes the source offset for this Memory
+ * @param destination the destination Memory, which may not be Read-Only.
+ * @param dstOffsetBytes the destination offset
+ * @param lengthBytes the number of bytes to copy
+ */
+ void copyTo(long srcOffsetBytes, WritableMemory destination, long dstOffsetBytes, long lengthBytes);
+
+ /**
+ * Writes bytes from a source range of this Memory to the given {@code WritableByteChannel}.
+ * @param offsetBytes the source offset for this Memory
+ * @param lengthBytes the number of bytes to copy
+ * @param out the destination WritableByteChannel
+ * @throws IOException may occur while writing to the WritableByteChannel
+ */
+ void writeTo(long offsetBytes, long lengthBytes, WritableByteChannel out)
+ throws IOException;
}
diff --git a/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
index 297a95c..3d1bd69 100644
--- a/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
+++ b/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
@@ -19,8 +19,6 @@
package org.apache.datasketches.memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
-
/**
* The MemoryRequestServer is a callback interface to provide a means for a direct (off-heap),
* dynamic WritableMemory object to request more memory from the owner of the
diff --git a/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java b/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java
index d1f3473..10ae261 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java
@@ -28,5 +28,5 @@ package org.apache.datasketches.memory;
* @author Lee Rhodes
* @author Roman Leventov
*/
-public interface WritableDirectHandle extends WritableHandle { }
+public interface WritableDirectHandle extends WritableHandle { }
diff --git a/src/main/java/org/apache/datasketches/memory/WritableHandle.java b/src/main/java/org/apache/datasketches/memory/WritableHandle.java
index 8b2aaa7..5546d5e 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableHandle.java
@@ -19,8 +19,6 @@
package org.apache.datasketches.memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
-
/**
* A Handle for writable direct memory or a memory-mapped, writable file resource.
* Please read Javadocs for {@link Handle}.
@@ -34,6 +32,5 @@ public interface WritableHandle extends Handle {
* Gets a WritableMemory
* @return a WritableMemory
*/
- @Override
- WritableMemory get();
+ WritableMemory getWritable();
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/WritableMemory.java
similarity index 74%
copy from src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
copy to src/main/java/org/apache/datasketches/memory/WritableMemory.java
index 85b8875..9b53b65 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableMemory.java
@@ -17,39 +17,17 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.internal.Util.negativeCheck;
-import static org.apache.datasketches.memory.internal.Util.nullCheck;
-import static org.apache.datasketches.memory.internal.Util.zeroCheck;
+package org.apache.datasketches.memory;
import java.io.File;
-import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-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;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
-
-/**
- * Provides read and write primitive and primitive array access to any of the four resources
- * mentioned at the package level.
- *
- * @author Roman Leventov
- * @author Lee Rhodes
- */
-public abstract class WritableMemory extends Memory {
-
- //Pass-through ctor
- WritableMemory(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
- final long capacityBytes) {
- super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
- }
+public interface WritableMemory extends Memory {
//BYTE BUFFER
/**
@@ -63,10 +41,10 @@ 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 writableWrap(final ByteBuffer byteBuf) {
- return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteBuf.order());
+ static WritableMemory writableWrap(final ByteBuffer byteBuf) {
+ return WritableMemoryImpl.writableWrap(byteBuf);
}
-
+
/**
* Accesses the given ByteBuffer for write operations. The returned WritableMemory object has
* the given byte order, ignoring the byte order of the given ByteBuffer. If the capacity of
@@ -80,10 +58,10 @@ 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 writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
- return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteOrder);
+ static WritableMemory writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ return WritableMemoryImpl.writableWrap(byteBuf, byteOrder);
}
-
+
//MAP
/**
* Maps the entire given file into native-ordered WritableMemory for write operations
@@ -95,12 +73,11 @@ public abstract class WritableMemory extends Memory {
* @param file the given file to map
* @return WritableMapHandle for managing the mapped Memory.
* Please read Javadocs for {@link Handle}.
- * @throws IOException file not found or a RuntimeException.
*/
- public static WritableMapHandle writableMap(final File file) throws IOException {
- return WritableMemory.writableMap(file, 0, file.length(), Util.nativeByteOrder);
+ static WritableMapHandle writableMap(final File file) {
+ return WritableMemoryImpl.writableMap(file);
}
-
+
/**
* Maps the specified portion of the given file into Memory for write operations
* (including those > 2GB).
@@ -111,19 +88,14 @@ 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 WritableMapHandleImpl for managing the mapped Memory.
+ * @return WritableMapHandle for managing the mapped Memory.
* Please read Javadocs for {@link Handle}.
- * @throws IOException file not found or RuntimeException, etc.
- */
- 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");
- negativeCheck(fileOffsetBytes, "File offset is negative");
- return BaseWritableMemoryImpl
- .wrapMap(file, fileOffsetBytes, capacityBytes, false, byteOrder);
+ */
+ static WritableMapHandle writableMap(final File file, final long fileOffsetBytes,
+ final long capacityBytes, final ByteOrder byteOrder) {
+ return WritableMemoryImpl.writableMap(file, fileOffsetBytes, capacityBytes, byteOrder);
}
-
+
//ALLOCATE DIRECT
/**
* Allocates and provides access to capacityBytes directly in native (off-heap) memory
@@ -140,13 +112,13 @@ 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 WritableDirectHandleImpl for this off-heap resource.
+ * @return WritableDirectHandle for this off-heap resource.
* Please read Javadocs for {@link Handle}.
*/
- public static WritableDirectHandle allocateDirect(final long capacityBytes) {
- return allocateDirect(capacityBytes, null);
+ static WritableDirectHandle allocateDirect(final long capacityBytes) {
+ return WritableMemoryImpl.allocateDirect(capacityBytes);
}
-
+
/**
* Allocates and provides access to capacityBytes directly in native (off-heap) memory
* leveraging the WritableMemory API. The allocated memory will be 8-byte aligned, but may not
@@ -163,11 +135,10 @@ public abstract class WritableMemory extends Memory {
* @return WritableHandle for this off-heap resource.
* Please read Javadocs for {@link Handle}.
*/
- public static WritableDirectHandle allocateDirect(final long capacityBytes,
- final MemoryRequestServer memReqSvr) {
- return BaseWritableMemoryImpl.wrapDirect(capacityBytes, Util.nativeByteOrder, memReqSvr);
+ static WritableDirectHandle allocateDirect(final long capacityBytes, final MemoryRequestServer memReqSvr) {
+ return WritableMemoryImpl.allocateDirect(capacityBytes, memReqSvr);
}
-
+
//REGIONS
/**
* A writable region is a writable view of this object.
@@ -184,7 +155,7 @@ public abstract class WritableMemory extends Memory {
* @param capacityBytes the capacity of the returned object in bytes.
* @return a new <i>WritableMemory</i> representing the defined writable region.
*/
- public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes);
+ WritableMemory writableRegion(long offsetBytes, long capacityBytes);
/**
* A writable region is a writable view of this object.
@@ -203,8 +174,7 @@ public abstract class WritableMemory extends Memory {
* @param byteOrder the given byte order
* @return a new <i>WritableMemory</i> representing the defined writable region.
*/
- public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes,
- ByteOrder byteOrder);
+ WritableMemory writableRegion(long offsetBytes, long capacityBytes, ByteOrder byteOrder);
//AS BUFFER
/**
@@ -221,7 +191,7 @@ public abstract class WritableMemory extends Memory {
* the backing storage and byte order are unspecified.
* @return a new <i>WritableBuffer</i> with a view of this WritableMemory
*/
- public abstract WritableBuffer asWritableBuffer();
+ WritableBuffer asWritableBuffer();
/**
* Returns a new <i>WritableBuffer</i> with a writable view of this object
@@ -239,8 +209,9 @@ public abstract class WritableMemory extends Memory {
* @param byteOrder the given byte order
* @return a new <i>WritableBuffer</i> with a view of this WritableMemory
*/
- public abstract WritableBuffer asWritableBuffer(ByteOrder byteOrder);
+ WritableBuffer asWritableBuffer(ByteOrder byteOrder);
+
//ALLOCATE HEAP VIA AUTOMATIC BYTE ARRAY
/**
* Creates on-heap WritableMemory with the given capacity and the native byte order. If the given
@@ -249,9 +220,8 @@ public abstract class WritableMemory extends Memory {
* @param capacityBytes the given capacity in bytes.
* @return a new WritableMemory for write operations on a new byte array.
*/
- public static WritableMemory allocate(final int capacityBytes) {
- final byte[] arr = new byte[capacityBytes];
- return writableWrap(arr, Util.nativeByteOrder);
+ static WritableMemory allocate(final int capacityBytes) {
+ return WritableMemoryImpl.allocate(capacityBytes);
}
/**
@@ -262,9 +232,8 @@ public abstract class WritableMemory extends Memory {
* @param byteOrder the given byte order to allocate new Memory object with.
* @return a new WritableMemory for write operations on a new byte array.
*/
- public static WritableMemory allocate(final int capacityBytes, final ByteOrder byteOrder) {
- final byte[] arr = new byte[capacityBytes];
- return writableWrap(arr, byteOrder);
+ static WritableMemory allocate(final int capacityBytes, final ByteOrder byteOrder) {
+ return WritableMemoryImpl.allocate(capacityBytes, byteOrder);
}
//ACCESS PRIMITIVE HEAP ARRAYS for write
@@ -278,9 +247,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 writableWrap(final boolean[] arr) {
- final long lengthBytes = arr.length << Prim.BOOLEAN.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final boolean[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
/**
@@ -293,8 +261,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 writableWrap(final byte[] arr) {
- return WritableMemory.writableWrap(arr, 0, arr.length, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final byte[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
/**
@@ -308,8 +276,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 writableWrap(final byte[] arr, final ByteOrder byteOrder) {
- return WritableMemory.writableWrap(arr, 0, arr.length, byteOrder);
+ static WritableMemory writableWrap(final byte[] arr, final ByteOrder byteOrder) {
+ return WritableMemoryImpl.writableWrap(arr, byteOrder);
}
/**
@@ -325,10 +293,9 @@ 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 writableWrap(final byte[] arr, final int offsetBytes, final int lengthBytes,
+ 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);
+ return WritableMemoryImpl.writableWrap(arr, offsetBytes, lengthBytes, byteOrder);
}
/**
@@ -341,9 +308,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 writableWrap(final char[] arr) {
- final long lengthBytes = arr.length << Prim.CHAR.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final char[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
/**
@@ -356,9 +322,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 writableWrap(final short[] arr) {
- final long lengthBytes = arr.length << Prim.SHORT.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final short[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
/**
@@ -371,9 +336,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 writableWrap(final int[] arr) {
- final long lengthBytes = arr.length << Prim.INT.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final int[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
/**
@@ -386,9 +350,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 writableWrap(final long[] arr) {
- final long lengthBytes = arr.length << Prim.LONG.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final long[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
/**
@@ -401,9 +364,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 writableWrap(final float[] arr) {
- final long lengthBytes = arr.length << Prim.FLOAT.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final float[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
/**
@@ -416,9 +378,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 writableWrap(final double[] arr) {
- final long lengthBytes = arr.length << Prim.DOUBLE.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
+ static WritableMemory writableWrap(final double[] arr) {
+ return WritableMemoryImpl.writableWrap(arr);
}
//END OF CONSTRUCTOR-TYPE METHODS
@@ -428,7 +389,7 @@ public abstract class WritableMemory extends Memory {
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putBoolean(long offsetBytes, boolean value);
+ void putBoolean(long offsetBytes, boolean value);
/**
* Puts the boolean array at the given offset
@@ -437,7 +398,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetBooleans offset in array units
* @param lengthBooleans number of array units to transfer
*/
- public abstract void putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffsetBooleans,
+ void putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffsetBooleans,
int lengthBooleans);
/**
@@ -445,7 +406,7 @@ public abstract class WritableMemory extends Memory {
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putByte(long offsetBytes, byte value);
+ void putByte(long offsetBytes, byte value);
/**
* Puts the byte array at the given offset
@@ -454,7 +415,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetBytes offset in array units
* @param lengthBytes number of array units to transfer
*/
- public abstract void putByteArray(long offsetBytes, byte[] srcArray, int srcOffsetBytes,
+ void putByteArray(long offsetBytes, byte[] srcArray, int srcOffsetBytes,
int lengthBytes);
/**
@@ -462,7 +423,7 @@ public abstract class WritableMemory extends Memory {
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putChar(long offsetBytes, char value);
+ void putChar(long offsetBytes, char value);
/**
* Puts the char array at the given offset
@@ -471,7 +432,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetChars offset in array units
* @param lengthChars number of array units to transfer
*/
- public abstract void putCharArray(long offsetBytes, char[] srcArray, int srcOffsetChars,
+ void putCharArray(long offsetBytes, char[] srcArray, int srcOffsetChars,
int lengthChars);
/**
@@ -486,14 +447,14 @@ public abstract class WritableMemory extends Memory {
* require 2, 3 or 4 bytes per character to encode.
* @return the number of bytes encoded
*/
- public abstract long putCharsToUtf8(long offsetBytes, CharSequence src);
+ long putCharsToUtf8(long offsetBytes, CharSequence src);
/**
* Puts the double value at the given offset
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putDouble(long offsetBytes, double value);
+ void putDouble(long offsetBytes, double value);
/**
* Puts the double array at the given offset
@@ -502,7 +463,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetDoubles offset in array units
* @param lengthDoubles number of array units to transfer
*/
- public abstract void putDoubleArray(long offsetBytes, double[] srcArray,
+ void putDoubleArray(long offsetBytes, double[] srcArray,
final int srcOffsetDoubles, final int lengthDoubles);
/**
@@ -510,7 +471,7 @@ public abstract class WritableMemory extends Memory {
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putFloat(long offsetBytes, float value);
+ void putFloat(long offsetBytes, float value);
/**
* Puts the float array at the given offset
@@ -519,7 +480,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetFloats offset in array units
* @param lengthFloats number of array units to transfer
*/
- public abstract void putFloatArray(long offsetBytes, float[] srcArray,
+ void putFloatArray(long offsetBytes, float[] srcArray,
final int srcOffsetFloats, final int lengthFloats);
/**
@@ -527,7 +488,7 @@ public abstract class WritableMemory extends Memory {
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putInt(long offsetBytes, int value);
+ void putInt(long offsetBytes, int value);
/**
* Puts the int array at the given offset
@@ -536,7 +497,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetInts offset in array units
* @param lengthInts number of array units to transfer
*/
- public abstract void putIntArray(long offsetBytes, int[] srcArray,
+ void putIntArray(long offsetBytes, int[] srcArray,
final int srcOffsetInts, final int lengthInts);
/**
@@ -544,7 +505,7 @@ public abstract class WritableMemory extends Memory {
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putLong(long offsetBytes, long value);
+ void putLong(long offsetBytes, long value);
/**
* Puts the long array at the given offset
@@ -553,7 +514,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetLongs offset in array units
* @param lengthLongs number of array units to transfer
*/
- public abstract void putLongArray(long offsetBytes, long[] srcArray,
+ void putLongArray(long offsetBytes, long[] srcArray,
final int srcOffsetLongs, final int lengthLongs);
/**
@@ -561,7 +522,7 @@ public abstract class WritableMemory extends Memory {
* @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putShort(long offsetBytes, short value);
+ void putShort(long offsetBytes, short value);
/**
* Puts the short array at the given offset
@@ -570,7 +531,7 @@ public abstract class WritableMemory extends Memory {
* @param srcOffsetShorts offset in array units
* @param lengthShorts number of array units to transfer
*/
- public abstract void putShortArray(long offsetBytes, short[] srcArray,
+ void putShortArray(long offsetBytes, short[] srcArray,
final int srcOffsetShorts, final int lengthShorts);
//Atomic Methods
@@ -580,7 +541,7 @@ public abstract class WritableMemory extends Memory {
* @param delta the amount to add
* @return the the previous value
*/
- public abstract long getAndAddLong(long offsetBytes, long delta);
+ long getAndAddLong(long offsetBytes, long delta);
/**
* Atomically sets the current value at the memory location to the given updated value
@@ -591,7 +552,7 @@ public abstract class WritableMemory extends Memory {
* @return {@code true} if successful. False return indicates that
* the current value at the memory location was not equal to the expected value.
*/
- public abstract boolean compareAndSwapLong(long offsetBytes, long expect, long update);
+ boolean compareAndSwapLong(long offsetBytes, long expect, long update);
/**
* Atomically exchanges the given value with the current value located at offsetBytes.
@@ -599,39 +560,39 @@ public abstract class WritableMemory extends Memory {
* @param newValue new value
* @return the previous value
*/
- public abstract long getAndSetLong(long offsetBytes, long newValue);
+ long getAndSetLong(long offsetBytes, long newValue);
//OTHER WRITE METHODS
/**
* Returns the primitive backing array, otherwise null.
* @return the primitive backing array, otherwise null.
*/
- public abstract Object getArray();
+ Object getArray();
/**
* Clears all bytes of this Memory to zero
*/
- public abstract void clear();
+ void clear();
/**
* Clears a portion of this Memory to zero.
* @param offsetBytes offset bytes relative to this Memory start
* @param lengthBytes the length in bytes
*/
- public abstract void clear(long offsetBytes, long lengthBytes);
+ void clear(long offsetBytes, long lengthBytes);
/**
* Clears the bits defined by the bitMask
* @param offsetBytes offset bytes relative to this Memory start.
* @param bitMask the bits set to one will be cleared
*/
- public abstract void clearBits(long offsetBytes, byte bitMask);
+ void clearBits(long offsetBytes, byte bitMask);
/**
* Fills all bytes of this Memory region to the given byte value.
* @param value the given byte value
*/
- public abstract void fill(byte value);
+ void fill(byte value);
/**
* Fills a portion of this Memory region to the given byte value.
@@ -639,14 +600,14 @@ public abstract class WritableMemory extends Memory {
* @param lengthBytes the length in bytes
* @param value the given byte value
*/
- public abstract void fill(long offsetBytes, long lengthBytes, byte value);
+ void fill(long offsetBytes, long lengthBytes, byte value);
/**
* Sets the bits defined by the bitMask
* @param offsetBytes offset bytes relative to this Memory start
* @param bitMask the bits set to one will be set
*/
- public abstract void setBits(long offsetBytes, byte bitMask);
+ void setBits(long offsetBytes, byte bitMask);
//OTHER WRITABLE API METHODS
@@ -658,9 +619,14 @@ public abstract class WritableMemory extends Memory {
* If not explicity set, this returns the {@link DefaultMemoryRequestServer}.
* @return the MemoryRequestServer object (if direct memory) or null.
*/
- @Override
- public MemoryRequestServer getMemoryRequestServer() {
- return null;
- }
+ MemoryRequestServer getMemoryRequestServer();
+
+
+
+
+
+
}
+
+
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 aef0b98..bc47f57 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
@@ -44,7 +44,7 @@ final class AllocateDirect implements AutoCloseable {
* Base Constructor for allocate native memory.
*
* <p>Allocates and provides access to capacityBytes directly in native (off-heap) memory
- * leveraging the Memory interface.
+ * leveraging the MemoryImpl interface.
* The allocated memory will be 8-byte aligned, but may not be page aligned.
* @param capacityBytes the the requested capacity of off-heap memory. Cannot be zero.
*/
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 b5528a5..de0dde0 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
@@ -122,6 +122,8 @@ class AllocateDirectMap implements Map {
cleaner = Cleaner.create(this, deallocator);
}
+ //Map Interface
+
@Override
public void load() {
madvise();
@@ -150,7 +152,8 @@ class AllocateDirectMap implements Map {
String.format("Encountered %s exception while loading", e.getClass()));
}
}
-
+ // End Map Interface
+
@Override
public void close() {
doClose();
diff --git a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
index 0d7d609..8a64a27 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
@@ -31,7 +31,7 @@ import org.apache.datasketches.memory.WritableMap;
* @author Roman Leventov
* @author Praveenkumar Venkatesan
*/
-//Called from WritableMemory, implements combo of WritableMemory with WritableMap resource
+//Called from WritableMemoryImpl, implements combo of WritableMemoryImpl with WritableMap resource
final class AllocateDirectWritableMap extends AllocateDirectMap implements WritableMap {
AllocateDirectWritableMap(final File file, final long fileOffsetBytes,
@@ -39,10 +39,12 @@ final class AllocateDirectWritableMap extends AllocateDirectMap implements Writa
super(file, fileOffsetBytes, capacityBytes, localReadOnly);
}
+ //Added by WritableMap Interface
+
@Override
public void force() {
if (resourceReadOnly) {
- throw new ReadOnlyException("Memory Mapped File is Read Only.");
+ throw new ReadOnlyException("MemoryImpl Mapped File is Read Only.");
}
try {
MAPPED_BYTE_BUFFER_FORCE0_METHOD
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableMemoryImpl.java
index 3c1c3e7..ff3f3c5 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableMemoryImpl.java
@@ -23,7 +23,7 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableMemory} for ByteBuffer, non-native byte order.
+ * Implementation of {@link WritableMemoryImpl} for ByteBuffer, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BBWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBWritableMemoryImpl.java
index 364bc8e..4a9e4ca 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BBWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBWritableMemoryImpl.java
@@ -23,12 +23,12 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableMemory} for ByteBuffer, native byte order.
+ * Implementation of {@link WritableMemoryImpl} for ByteBuffer, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class BBWritableMemoryImpl extends WritableMemoryImpl {
+final class BBWritableMemoryImpl extends NativeWritableMemoryImpl {
private static final int id = MEMORY | NATIVE | BYTEBUF;
private final Object unsafeObj;
private final long nativeBaseOffset; //used to compute cumBaseOffset
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
index caa3e99..8855c99 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
@@ -33,7 +33,7 @@ import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.BaseState;
/**
- * Keeps key configuration state for Memory and Buffer plus some common static variables
+ * Keeps key configuration state for MemoryImpl and Buffer plus some common static variables
* and check methods.
*
* @author Lee Rhodes
@@ -73,8 +73,8 @@ public abstract class BaseStateImpl implements BaseState {
/**
* This becomes the base offset used by all Unsafe calls. It is cumulative in that in includes
- * all offsets from regions, user-defined offsets when creating Memory, and the array object
- * header offset when creating Memory from primitive arrays.
+ * all offsets from regions, user-defined offsets when creating MemoryImpl, and the array object
+ * header offset when creating MemoryImpl from primitive arrays.
*/
private final long cumBaseOffset_;
@@ -162,7 +162,7 @@ public abstract class BaseStateImpl implements BaseState {
return cumBaseOffset_ + offsetBytes;
}
- //made public in WritableMemory and WritableBuffer, only implemented in Direct Leafs
+ //made public in WritableMemoryImpl and WritableBuffer, only implemented in Direct Leafs
abstract MemoryRequestServer getMemoryRequestServer();
//Overridden by ByteBuffer, Direct and Map leafs
@@ -186,7 +186,7 @@ public abstract class BaseStateImpl implements BaseState {
//Overridden by all leafs
abstract int getTypeId();
- //Overridden by Heap and ByteBuffer Leafs. Made public as getArray() in WritableMemory and
+ //Overridden by Heap and ByteBuffer Leafs. Made public as getArray() in WritableMemoryImpl and
// WritableBuffer
Object getUnsafeObject() {
return null;
@@ -248,12 +248,12 @@ public abstract class BaseStateImpl implements BaseState {
//ASSERTS AND CHECKS
final void assertValid() {
- assert isValid() : "Memory not valid.";
+ assert isValid() : "MemoryImpl not valid.";
}
void checkValid() {
if (!isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
@@ -271,7 +271,7 @@ public abstract class BaseStateImpl implements BaseState {
// because the later can make JVM to not inline the assert code path (and entirely remove it)
// even though it does nothing in production code path.
assertBounds(offsetBytes, lengthBytes, capacityBytes_);
- assert !isReadOnly() : "Memory is read-only.";
+ assert !isReadOnly() : "MemoryImpl is read-only.";
}
@Override
@@ -286,7 +286,7 @@ public abstract class BaseStateImpl implements BaseState {
//read capacityBytes_ directly to eliminate extra checkValid() call
checkBounds(offsetBytes, lengthBytes, capacityBytes_);
if (isReadOnly()) {
- throw new ReadOnlyException("Memory is read-only.");
+ throw new ReadOnlyException("MemoryImpl is read-only.");
}
}
@@ -386,7 +386,7 @@ public abstract class BaseStateImpl implements BaseState {
* Used primarily for testing.
* @param state the BaseStateImpl
* @param preamble a descriptive header
- * @param offsetBytes offset bytes relative to the Memory start
+ * @param offsetBytes offset bytes relative to the MemoryImpl start
* @param lengthBytes number of bytes to convert to a hex string
* @return a formatted hex string in a human readable array
*/
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
index 0402e0a..935b364 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
@@ -147,14 +147,14 @@ abstract class BaseWritableBufferImpl extends WritableBuffer {
//MEMORY
@Override
- public Memory asMemory() {
+ public MemoryImpl asMemory() {
return originMemory;
}
@Override
- public WritableMemory asWritableMemory() {
+ public WritableMemoryImpl asWritableMemory() {
if (isReadOnly()) {
- throw new ReadOnlyException("Converting a read-only Buffer to a writable Memory is not allowed.");
+ throw new ReadOnlyException("Converting a read-only Buffer to a writable MemoryImpl is not allowed.");
}
return originMemory;
}
@@ -271,7 +271,7 @@ abstract class BaseWritableBufferImpl extends WritableBuffer {
/*
* Develper notes: There is no copyTo for Buffers because of the ambiguity of what to do with
- * the positional values. Switch to Memory view to do copyTo.
+ * the positional values. Switch to MemoryImpl view to do copyTo.
*/
//PRIMITIVE putX() and putXArray()
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 f7aba4e..872cc05 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
@@ -36,8 +36,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.WritableByteChannel;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMapHandle;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.WritableDirectHandle;
/*
@@ -53,11 +55,11 @@ import org.apache.datasketches.memory.WritableDirectHandle;
*/
/**
- * Common base of native-ordered and non-native-ordered {@link WritableMemory} implementations.
+ * Common base of native-ordered and non-native-ordered {@link WritableMemoryImpl} implementations.
* Contains methods which are agnostic to the byte order.
*/
@SuppressWarnings({"restriction"})
-abstract class BaseWritableMemoryImpl extends WritableMemory {
+abstract class BaseWritableMemoryImpl extends WritableMemoryImpl {
//1KB of empty bytes for speedy clear()
private final static byte[] EMPTY_BYTES;
@@ -152,7 +154,7 @@ abstract class BaseWritableMemoryImpl extends WritableMemory {
.slice().asReadOnlyBuffer();
} else {
throw new UnsupportedOperationException(
- "This Memory object is the result of wrapping a "
+ "This MemoryImpl object is the result of wrapping a "
+ unsafeObj.getClass().getSimpleName()
+ " array, it could not be viewed as a ByteBuffer.");
}
@@ -162,31 +164,31 @@ abstract class BaseWritableMemoryImpl extends WritableMemory {
//REGIONS
@Override
- public Memory region(final long offsetBytes, final long capacityBytes) {
+ public MemoryImpl region(final long offsetBytes, final long capacityBytes) {
return writableRegionImpl(offsetBytes, capacityBytes, true, getTypeByteOrder());
}
@Override
- public Memory region(final long offsetBytes, final long capacityBytes, final ByteOrder byteOrder) {
+ public MemoryImpl region(final long offsetBytes, final long capacityBytes, final ByteOrder byteOrder) {
return writableRegionImpl(offsetBytes, capacityBytes, true, byteOrder);
}
@Override
- public WritableMemory writableRegion(final long offsetBytes, final long capacityBytes) {
+ public WritableMemoryImpl writableRegion(final long offsetBytes, final long capacityBytes) {
return writableRegionImpl(offsetBytes, capacityBytes, false, getTypeByteOrder());
}
@Override
- public WritableMemory writableRegion(final long offsetBytes, final long capacityBytes,
+ public WritableMemoryImpl writableRegion(final long offsetBytes, final long capacityBytes,
final ByteOrder byteOrder) {
return writableRegionImpl(offsetBytes, capacityBytes, false, byteOrder);
}
- WritableMemory writableRegionImpl(final long offsetBytes, final long capacityBytes,
+ WritableMemoryImpl writableRegionImpl(final long offsetBytes, final long capacityBytes,
final boolean localReadOnly, final ByteOrder byteOrder) {
if (capacityBytes == 0) { return ZERO_SIZE_MEMORY; }
if (isReadOnly() && !localReadOnly) {
- throw new ReadOnlyException("Writable region of a read-only Memory is not allowed.");
+ throw new ReadOnlyException("Writable region of a read-only MemoryImpl is not allowed.");
}
final boolean readOnly = isReadOnly() || localReadOnly;
checkValidAndBounds(offsetBytes, capacityBytes);
@@ -220,7 +222,7 @@ abstract class BaseWritableMemoryImpl extends WritableMemory {
WritableBuffer asWritableBufferImpl(final boolean localReadOnly, final ByteOrder byteOrder) {
if (isReadOnly() && !localReadOnly) {
throw new ReadOnlyException(
- "Converting a read-only Memory to a writable Buffer is not allowed.");
+ "Converting a read-only MemoryImpl to a writable Buffer is not allowed.");
}
final boolean readOnly = isReadOnly() || localReadOnly;
final WritableBuffer wbuf = toWritableBuffer(readOnly, byteOrder);
@@ -316,14 +318,14 @@ abstract class BaseWritableMemoryImpl extends WritableMemory {
@Override
public final int compareTo(final long thisOffsetBytes, final long thisLengthBytes,
final Memory thatMem, final long thatOffsetBytes, final long thatLengthBytes) {
- return CompareAndCopy.compare(this, thisOffsetBytes, thisLengthBytes,
- thatMem, thatOffsetBytes, thatLengthBytes);
+ return CompareAndCopy.compare((BaseStateImpl)this, thisOffsetBytes, thisLengthBytes,
+ (BaseStateImpl)thatMem, thatOffsetBytes, thatLengthBytes);
}
@Override
public final void copyTo(final long srcOffsetBytes, final WritableMemory destination,
final long dstOffsetBytes, final long lengthBytes) {
- CompareAndCopy.copy(this, srcOffsetBytes, destination,
+ CompareAndCopy.copy((BaseStateImpl)this, srcOffsetBytes, (BaseStateImpl)destination,
dstOffsetBytes, lengthBytes);
}
@@ -336,7 +338,7 @@ abstract class BaseWritableMemoryImpl extends WritableMemory {
} else if (getUnsafeObject() == null) {
writeDirectMemoryTo(offsetBytes, lengthBytes, out);
} else {
- // Memory is backed by some array that is not byte[], for example int[], long[], etc.
+ // MemoryImpl is backed by some array that is not byte[], for example int[], long[], etc.
// We don't have other choice as to do extra intermediate copy.
writeToWithExtraCopy(offsetBytes, lengthBytes, out);
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Buffer.java b/src/main/java/org/apache/datasketches/memory/internal/Buffer.java
index 5380e56..824a4a5 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Buffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Buffer.java
@@ -70,7 +70,7 @@ public abstract class Buffer extends BaseBuffer {
}
//MAP
- //Use Memory for mapping files and the asBuffer()
+ //Use MemoryImpl for mapping files and the asBuffer()
//DUPLICATES
/**
@@ -146,8 +146,8 @@ public abstract class Buffer extends BaseBuffer {
* If this object's capacity is zero, the returned object is effectively immutable and
* the backing storage and byte order are unspecified.
*
- * <p><b>Note: The Memory returned with </b><i>asMemory()</i> will have the originating
- * <i>Memory</i> byte order.</p>
+ * <p><b>Note: The MemoryImpl returned with </b><i>asMemory()</i> will have the originating
+ * <i>MemoryImpl</i> byte order.</p>
*
* @param offsetBytes the starting offset with respect to the origin of this <i>WritableBuffer</i>
* @param capacityBytes the <i>capacity</i> of the returned region in bytes
@@ -160,16 +160,16 @@ public abstract class Buffer extends BaseBuffer {
//MEMORY
/**
- * Convert this Buffer to a Memory. The current <i>start</i>, <i>position</i> and <i>end</i>
+ * Convert this Buffer to a MemoryImpl. The current <i>start</i>, <i>position</i> and <i>end</i>
* are ignored.
* If this object's capacity is zero, the returned object is effectively immutable and
* the backing resource and byte order are unspecified.
- * @return Memory
+ * @return MemoryImpl
*/
- public abstract Memory asMemory();
+ public abstract MemoryImpl asMemory();
//ACCESS PRIMITIVE HEAP ARRAYS for readOnly
- // use Memory or WritableMemory and then asBuffer().
+ // use MemoryImpl or WritableMemoryImpl and then asBuffer().
//END OF CONSTRUCTOR-TYPE METHODS
//PRIMITIVE getX() and getXArray()
@@ -183,7 +183,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the boolean value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the boolean at the given offset
*/
public abstract boolean getBoolean(long offsetBytes);
@@ -208,7 +208,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the byte value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the byte at the given offset
*/
public abstract byte getByte(long offsetBytes);
@@ -232,7 +232,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the char value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the char at the given offset
*/
public abstract char getChar(long offsetBytes);
@@ -256,7 +256,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the double value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the double at the given offset
*/
public abstract double getDouble(long offsetBytes);
@@ -280,7 +280,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the float value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the float at the given offset
*/
public abstract float getFloat(long offsetBytes);
@@ -304,7 +304,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the int value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the int at the given offset
*/
public abstract int getInt(long offsetBytes);
@@ -328,7 +328,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the long value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the long at the given offset
*/
public abstract long getLong(long offsetBytes);
@@ -352,7 +352,7 @@ public abstract class Buffer extends BaseBuffer {
/**
* Gets the short value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this Memory start
+ * @param offsetBytes offset bytes relative to this MemoryImpl start
* @return the short at the given offset
*/
public abstract short getShort(long offsetBytes);
diff --git a/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
index 0baf90a..089e576 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
@@ -124,7 +124,7 @@ final class CompareAndCopy {
lengthBytes);
}
- //Used by all of the get/put array methods in Buffer and Memory classes
+ //Used by all of the get/put array methods in Buffer and MemoryImpl classes
static final void copyMemoryCheckingDifferentObject(final Object srcUnsafeObj,
final long srcAdd, final Object dstUnsafeObj, final long dstAdd, final long lengthBytes) {
if (srcUnsafeObj != dstUnsafeObj) {
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
index 6d8f159..4358d6b 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
@@ -101,7 +101,7 @@ final class DirectNonNativeWritableBufferImpl extends NonNativeWritableBufferImp
@Override
void checkValid() {
if (!this.isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
index e8f5a64..9c0ee47 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
@@ -24,7 +24,7 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.MemoryRequestServer;
/**
- * Implementation of {@link WritableMemory} for direct memory, non-native byte order.
+ * Implementation of {@link WritableMemoryImpl} for direct memory, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
@@ -99,7 +99,7 @@ final class DirectNonNativeWritableMemoryImpl extends NonNativeWritableMemoryImp
@Override
void checkValid() {
if (!this.isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
index c6cd0e6..9b1a287 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
@@ -101,7 +101,7 @@ final class DirectWritableBufferImpl extends WritableBufferImpl {
@Override
void checkValid() {
if (!this.isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
index 21eb03c..9fbb834 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
@@ -24,12 +24,12 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.MemoryRequestServer;
/**
- * Implementation of {@link WritableMemory} for direct memory, native byte order.
+ * Implementation of {@link WritableMemoryImpl} for direct memory, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class DirectWritableMemoryImpl extends WritableMemoryImpl {
+final class DirectWritableMemoryImpl extends NativeWritableMemoryImpl {
private static final int id = MEMORY | NATIVE | DIRECT;
private final long nativeBaseOffset; //used to compute cumBaseOffset
private final StepBoolean valid; //a reference only
diff --git a/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableMemoryImpl.java
index 89d223b..04b3033 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableMemoryImpl.java
@@ -22,7 +22,7 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableMemory} for heap-based, non-native byte order.
+ * Implementation of {@link WritableMemoryImpl} for heap-based, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
diff --git a/src/main/java/org/apache/datasketches/memory/internal/HeapWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableMemoryImpl.java
index ead8a7b..4aa398a 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/HeapWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableMemoryImpl.java
@@ -22,12 +22,12 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableMemory} for heap-based, native byte order.
+ * Implementation of {@link WritableMemoryImpl} for heap-based, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class HeapWritableMemoryImpl extends WritableMemoryImpl {
+final class HeapWritableMemoryImpl extends NativeWritableMemoryImpl {
private static final int id = MEMORY | NATIVE | HEAP;
private final Object unsafeObj;
private final byte typeId;
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 e9741b8..a6bf6fa 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapHandleImpl.java
@@ -20,14 +20,12 @@
package org.apache.datasketches.memory.internal;
import org.apache.datasketches.memory.MapHandle;
+import org.apache.datasketches.memory.Memory;
class MapHandleImpl implements MapHandle {
- /**
- * Having at least one final field makes this class safe for concurrent publication.
- */
final AllocateDirectMap dirMap;
- private BaseWritableMemoryImpl wMem;
+ BaseWritableMemoryImpl wMem;
MapHandleImpl(final AllocateDirectMap dirMap, final BaseWritableMemoryImpl wMem) {
this.dirMap = dirMap;
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
index 28e1e98..59ca32d 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
@@ -89,7 +89,7 @@ final class MapNonNativeWritableBufferImpl extends NonNativeWritableBufferImpl {
@Override
void checkValid() {
if (!this.isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableMemoryImpl.java
index 9d9e42d..9920c2d 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableMemoryImpl.java
@@ -22,7 +22,7 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableMemory} for map memory, non-native byte order.
+ * Implementation of {@link WritableMemoryImpl} for map memory, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
@@ -88,7 +88,7 @@ final class MapNonNativeWritableMemoryImpl extends NonNativeWritableMemoryImpl {
@Override
void checkValid() {
if (!this.isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
index cde1289..4a9be74 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
@@ -89,7 +89,7 @@ final class MapWritableBufferImpl extends WritableBufferImpl {
@Override
void checkValid() {
if (!this.isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapWritableMemoryImpl.java
index 839c23f..5c9377a 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapWritableMemoryImpl.java
@@ -22,12 +22,12 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableMemory} for map memory, native byte order.
+ * Implementation of {@link WritableMemoryImpl} for map memory, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class MapWritableMemoryImpl extends WritableMemoryImpl {
+final class MapWritableMemoryImpl extends NativeWritableMemoryImpl {
private static final int id = MEMORY | NATIVE | MAP;
private final long nativeBaseOffset; //used to compute cumBaseOffset
private final StepBoolean valid; //a reference only
@@ -88,7 +88,7 @@ final class MapWritableMemoryImpl extends WritableMemoryImpl {
@Override
void checkValid() {
if (!this.isValid()) {
- throw new IllegalStateException("Memory not valid.");
+ throw new IllegalStateException("MemoryImpl not valid.");
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
index 25fbdbb..4761ec6 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
@@ -29,8 +29,9 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.WritableByteChannel;
-import org.apache.datasketches.memory.Handle;
import org.apache.datasketches.memory.MapHandle;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
/**
* Provides read-only primitive and primitive array methods to any of the four resources
@@ -41,81 +42,30 @@ import org.apache.datasketches.memory.MapHandle;
*
* @see org.apache.datasketches.memory.internal
*/
-public abstract class Memory extends BaseStateImpl {
+public abstract class MemoryImpl extends BaseStateImpl implements Memory {
//Pass-through ctor
- Memory(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
+ MemoryImpl(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
final long capacityBytes) {
super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
}
//BYTE BUFFER
- /**
- * Accesses the given ByteBuffer for read-only operations. The returned <i>Memory</i> object has
- * the same byte order, as the given ByteBuffer, unless the capacity of the given ByteBuffer is
- * zero, then byte order of the returned <i>Memory</i> object (as well as backing storage) is
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param byteBuf the given ByteBuffer, must not be null
- * @return a new <i>Memory</i> for read-only operations on the given ByteBuffer.
- */
- public static Memory wrap(final ByteBuffer byteBuf) {
+ public static MemoryImpl wrap(final ByteBuffer byteBuf) {
return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, true, byteBuf.order());
}
- /**
- * Accesses the given ByteBuffer for read-only operations. The returned <i>Memory</i> object has
- * the given byte order, ignoring the byte order of the given ByteBuffer. If the capacity of the
- * given ByteBuffer is zero the byte order of the returned <i>Memory</i> object (as well as
- * backing storage) is unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param byteBuf the given ByteBuffer, must not be null
- * @param byteOrder the byte order to be used, whicn may be independent of the byte order
- * state of the given ByteBuffer.
- * @return a new <i>Memory</i> for read-only operations on the given ByteBuffer.
- */
- public static Memory wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ public static MemoryImpl wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, true, byteOrder);
}
//MAP
- /**
- * Maps the entire given file into native-ordered Memory for read operations
- * (including those > 2GB).
- * Calling this method is equivalent to calling {@link #map(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>Memory.map(...)</i>.
- * @param file the given file to map
- * @return <i>MapHandle</i> for managing the mapped Memory.
- * Please read Javadocs for {@link Handle}.
- * @throws IOException if file not found or a RuntimeException.
- */
- public static MapHandle map(final File file) throws IOException {
+ public static MapHandle map(final File file) {
return map(file, 0, file.length(), ByteOrder.nativeOrder());
}
- /**
- * Maps the specified portion of the given file into Memory for read operations
- * (including those > 2GB).
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.map(...)</i>.
- * @param file the given file to map. It may not be null.
- * @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 mapped Memory. It may not be null.
- * @return <i>MapHandle</i> for managing the mapped Memory.
- * Please read Javadocs for {@link Handle}.
- * @throws IOException if file not found or a RuntimeException.
- */
public static MapHandle map(final File file, final long fileOffsetBytes, final long capacityBytes,
- final ByteOrder byteOrder) throws IOException {
+ final ByteOrder byteOrder) {
zeroCheck(capacityBytes, "Capacity");
nullCheck(file, "file is null");
negativeCheck(fileOffsetBytes, "File offset is negative");
@@ -123,465 +73,151 @@ public abstract class Memory extends BaseStateImpl {
}
//REGIONS
- /**
- * A region is a read-only view of this object.
- * <ul>
- * <li>Returned object's origin = this object's origin + offsetBytes</li>
- * <li>Returned object's capacity = capacityBytes</li>
- * </ul>
- * If the given capacityBytes is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @param offsetBytes the starting offset with respect to the origin of this Memory.
- * @param capacityBytes the capacity of the region in bytes
- * @return a new <i>Memory</i> representing the defined region based on the given
- * offsetBytes and capacityBytes.
- */
- public abstract Memory region(long offsetBytes, long capacityBytes);
-
- /**
- * A region is a read-only view of this object.
- * <ul>
- * <li>Returned object's origin = this object's origin + <i>offsetBytes</i></li>
- * <li>Returned object's capacity = <i>capacityBytes</i></li>
- * <li>Returned object's byte order = <i>byteOrder</i></li>
- * </ul>
- * If the given capacityBytes is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @param offsetBytes the starting offset with respect to the origin of this Memory.
- * @param capacityBytes the capacity of the region in bytes
- * @param byteOrder the given byte order
- * @return a new <i>Memory</i> representing the defined region based on the given
- * offsetBytes, capacityBytes and byteOrder.
- */
- public abstract Memory region(long offsetBytes, long capacityBytes, ByteOrder byteOrder);
+ @Override
+ public abstract MemoryImpl region(long offsetBytes, long capacityBytes);
+
+ @Override
+ public abstract MemoryImpl region(long offsetBytes, long capacityBytes, ByteOrder byteOrder);
//AS BUFFER
- /**
- * Returns a new <i>Buffer</i> view of this object.
- * <ul>
- * <li>Returned object's origin = this object's origin</li>
- * <li>Returned object's <i>start</i> = 0</li>
- * <li>Returned object's <i>position</i> = 0</li>
- * <li>Returned object's <i>end</i> = this object's capacity</li>
- * <li>Returned object's <i>capacity</i> = this object's capacity</li>
- * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
- * </ul>
- * If this object's capacity is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @return a new <i>Buffer</i>
- */
+ @Override
public abstract Buffer asBuffer();
- /**
- * Returns a new <i>Buffer</i> view of this object, with the given
- * byte order.
- * <ul>
- * <li>Returned object's origin = this object's origin</li>
- * <li>Returned object's <i>start</i> = 0</li>
- * <li>Returned object's <i>position</i> = 0</li>
- * <li>Returned object's <i>end</i> = this object's capacity</li>
- * <li>Returned object's <i>capacity</i> = this object's capacity</li>
- * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
- * </ul>
- * If this object's capacity is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @param byteOrder the given byte order
- * @return a new <i>Buffer</i> with the given byteOrder.
- */
+ @Override
public abstract Buffer asBuffer(ByteOrder byteOrder);
-
//UNSAFE BYTE BUFFER VIEW
- /**
- * Returns the specified region of this Memory object as a new read-only {@link ByteBuffer}
- * object. The {@link ByteOrder} of the returned {@code ByteBuffer} corresponds to the {@linkplain
- * #getTypeByteOrder() byte order of this Memory}. The returned ByteBuffer's position is 0 and
- * the limit is equal to the capacity.
- *
- * <p>If this Memory object is the result of wrapping non-byte Java arrays ({@link
- * Memory#wrap(int[])}, {@link Memory#wrap(long[])}, etc.) this methods throws an {@link
- * UnsupportedOperationException}.
- *
- * <p>The name of this method starts with "unsafe" because if this is a native managed Memory
- * (e. g. obtained via {@link #map(File)} or {@link WritableMemory#allocateDirect(long)})), and
- * the returned {@code ByteBuffer} object is used after the Memory is freed, it may cause a JVM
- * crash. This is also possible for Memory objects themselves with some methods,
- * but Memory's use-after-free is caught as an AssertionError, if assertions are enabled.
- *
- * @param offsetBytes the starting offset with respect to the origin of this Memory
- * @param capacityBytes the capacity of the returned ByteBuffer
- * @return a new read-only {@code ByteBuffer} to access the specified region.
- * @throws UnsupportedOperationException if this method couldn't be viewed as ByteBuffer, because
- * when it wraps a non-byte Java array.
- */
+ @Override
public abstract ByteBuffer unsafeByteBufferView(long offsetBytes, int capacityBytes);
//ACCESS PRIMITIVE HEAP ARRAYS for readOnly
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final boolean[] arr) {
final long lengthBytes = arr.length << Prim.BOOLEAN.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true,
Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final byte[] arr) {
- return Memory.wrap(arr, 0, arr.length, Util.nativeByteOrder);
+ return MemoryImpl.wrap(arr, 0, arr.length, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for read operations with the given byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @param byteOrder the byte order to be used
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final byte[] arr, final ByteOrder byteOrder) {
- return Memory.wrap(arr, 0, arr.length, byteOrder);
+ return MemoryImpl.wrap(arr, 0, arr.length, byteOrder);
}
- /**
- * Wraps the given primitive array for read operations with the given byte order. If the given
- * lengthBytes is zero, backing storage and byte order of the returned <i>Memory</i> object are
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @param offsetBytes the byte offset into the given array
- * @param lengthBytes the number of bytes to include from the given array
- * @param byteOrder the byte order to be used
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final byte[] arr, final int offsetBytes, final int lengthBytes,
final ByteOrder byteOrder) {
UnsafeUtil.checkBounds(offsetBytes, lengthBytes, arr.length);
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true, byteOrder);
}
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final char[] arr) {
final long lengthBytes = arr.length << Prim.CHAR.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final short[] arr) {
final long lengthBytes = arr.length << Prim.SHORT.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final int[] arr) {
final long lengthBytes = arr.length << Prim.INT.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final long[] arr) {
final long lengthBytes = arr.length << Prim.LONG.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final float[] arr) {
final long lengthBytes = arr.length << Prim.FLOAT.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
- * unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>Memory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new <i>Memory</i> for read operations
- */
public static Memory wrap(final double[] arr) {
final long lengthBytes = arr.length << Prim.DOUBLE.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, true, Util.nativeByteOrder);
}
//PRIMITIVE getX() and getXArray()
- /**
- * Gets the boolean value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the boolean at the given offset
- */
+
+ @Override
public abstract boolean getBoolean(long offsetBytes);
- /**
- * Gets the boolean array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetBooleans offset in array units
- * @param lengthBooleans number of array units to transfer
- */
+ @Override
public abstract void getBooleanArray(long offsetBytes, boolean[] dstArray, int dstOffsetBooleans,
int lengthBooleans);
- /**
- * Gets the byte value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the byte at the given offset
- */
+ @Override
public abstract byte getByte(long offsetBytes);
- /**
- * Gets the byte array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetBytes offset in array units
- * @param lengthBytes number of array units to transfer
- */
+ @Override
public abstract void getByteArray(long offsetBytes, byte[] dstArray, int dstOffsetBytes,
int lengthBytes);
- /**
- * Gets the char value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the char at the given offset
- */
+ @Override
public abstract char getChar(long offsetBytes);
- /**
- * Gets the char array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetChars offset in array units
- * @param lengthChars number of array units to transfer
- */
+ @Override
public abstract void getCharArray(long offsetBytes, char[] dstArray, int dstOffsetChars,
int lengthChars);
- /**
- * Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of
- * utf8LengthBytes, decodes them into characters and appends them to the given Appendable.
- * This is specifically designed to reduce the production of intermediate objects (garbage),
- * thus significantly reducing pressure on the JVM Garbage Collector.
- * @param offsetBytes offset bytes relative to the Memory start
- * @param utf8LengthBytes the number of encoded UTF-8 bytes to decode. It is assumed that the
- * caller has the correct number of utf8 bytes required to decode the number of characters
- * to be appended to dst. Characters outside the ASCII range can require 2, 3 or 4 bytes per
- * character to decode.
- * @param dst the destination Appendable to append the decoded characters to.
- * @return the number of characters decoded
- * @throws IOException if dst.append() throws IOException
- * @throws Utf8CodingException in case of malformed or illegal UTF-8 input
- */
+ @Override
public abstract int getCharsFromUtf8(long offsetBytes, int utf8LengthBytes, Appendable dst)
throws IOException, Utf8CodingException;
- /**
- * Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of
- * utf8LengthBytes, decodes them into characters and appends them to the given StringBuilder.
- * This method does *not* reset the length of the destination StringBuilder before appending
- * characters to it.
- * This is specifically designed to reduce the production of intermediate objects (garbage),
- * thus significantly reducing pressure on the JVM Garbage Collector.
- * @param offsetBytes offset bytes relative to the Memory start
- * @param utf8LengthBytes the number of encoded UTF-8 bytes to decode. It is assumed that the
- * caller has the correct number of utf8 bytes required to decode the number of characters
- * to be appended to dst. Characters outside the ASCII range can require 2, 3 or 4 bytes per
- * character to decode.
- * @param dst the destination StringBuilder to append decoded characters to.
- * @return the number of characters decoded.
- * @throws Utf8CodingException in case of malformed or illegal UTF-8 input
- */
+ @Override
public abstract int getCharsFromUtf8(final long offsetBytes, final int utf8LengthBytes,
final StringBuilder dst) throws Utf8CodingException;
- /**
- * Gets the double value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the double at the given offset
- */
+ @Override
public abstract double getDouble(long offsetBytes);
- /**
- * Gets the double array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetDoubles offset in array units
- * @param lengthDoubles number of array units to transfer
- */
+ @Override
public abstract void getDoubleArray(long offsetBytes, double[] dstArray, int dstOffsetDoubles,
int lengthDoubles);
- /**
- * Gets the float value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the float at the given offset
- */
+ @Override
public abstract float getFloat(long offsetBytes);
- /**
- * Gets the float array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetFloats offset in array units
- * @param lengthFloats number of array units to transfer
- */
+ @Override
public abstract void getFloatArray(long offsetBytes, float[] dstArray, int dstOffsetFloats,
int lengthFloats);
- /**
- * Gets the int value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the int at the given offset
- */
+ @Override
public abstract int getInt(long offsetBytes);
- /**
- * Gets the int array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetInts offset in array units
- * @param lengthInts number of array units to transfer
- */
+ @Override
public abstract void getIntArray(long offsetBytes, int[] dstArray, int dstOffsetInts,
int lengthInts);
- /**
- * Gets the long value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the long at the given offset
- */
+ @Override
public abstract long getLong(long offsetBytes);
- /**
- * Gets the long array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetLongs offset in array units
- * @param lengthLongs number of array units to transfer
- */
+ @Override
public abstract void getLongArray(long offsetBytes, long[] dstArray, int dstOffsetLongs,
int lengthLongs);
- /**
- * Gets the short value at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @return the short at the given offset
- */
+ @Override
public abstract short getShort(long offsetBytes);
- /**
- * Gets the short array at the given offset
- * @param offsetBytes offset bytes relative to this Memory start
- * @param dstArray The preallocated destination array.
- * @param dstOffsetShorts offset in array units
- * @param lengthShorts number of array units to transfer
- */
+ @Override
public abstract void getShortArray(long offsetBytes, short[] dstArray, int dstOffsetShorts,
int lengthShorts);
//SPECIAL PRIMITIVE READ METHODS: compareTo, copyTo, writeTo
- /**
- * Compares the bytes of this Memory to <i>that</i> Memory.
- * Returns <i>(this < that) ? (some negative value) : (this > that) ? (some positive value)
- * : 0;</i>.
- * If all bytes are equal up to the shorter of the two lengths, the shorter length is considered
- * to be less than the other.
- * @param thisOffsetBytes the starting offset for <i>this Memory</i>
- * @param thisLengthBytes the length of the region to compare from <i>this Memory</i>
- * @param that the other Memory to compare with
- * @param thatOffsetBytes the starting offset for <i>that Memory</i>
- * @param thatLengthBytes the length of the region to compare from <i>that Memory</i>
- * @return <i>(this < that) ? (some negative value) : (this > that) ? (some positive value)
- * : 0;</i>
- */
+ @Override
public abstract int compareTo(long thisOffsetBytes, long thisLengthBytes, Memory that,
long thatOffsetBytes, long thatLengthBytes);
- /**
- * Copies bytes from a source range of this Memory to a destination range of the given Memory
- * with the same semantics when copying between overlapping ranges of bytes as method
- * {@link java.lang.System#arraycopy(Object, int, Object, int, int)} has. However, if the source
- * and the destination ranges are exactly the same, this method throws {@link
- * IllegalArgumentException}, because it should never be needed in real-world scenarios and
- * therefore indicates a bug.
- * @param srcOffsetBytes the source offset for this Memory
- * @param destination the destination Memory, which may not be Read-Only.
- * @param dstOffsetBytes the destination offset
- * @param lengthBytes the number of bytes to copy
- */
+ @Override
public abstract void copyTo(long srcOffsetBytes, WritableMemory destination, long dstOffsetBytes,
long lengthBytes);
- /**
- * Writes bytes from a source range of this Memory to the given {@code WritableByteChannel}.
- * @param offsetBytes the source offset for this Memory
- * @param lengthBytes the number of bytes to copy
- * @param out the destination WritableByteChannel
- * @throws IOException may occur while writing to the WritableByteChannel
- */
+
+ @Override
public abstract void writeTo(long offsetBytes, long lengthBytes, WritableByteChannel out)
throws IOException;
diff --git a/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
index 7c416b0..88723eb 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
@@ -50,16 +50,16 @@ import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
*/
/**
- * Implementation of {@link WritableMemory} for native endian byte order. Non-native variant is
+ * Implementation of {@link WritableMemoryImpl} for native endian byte order. Non-native variant is
* {@link NonNativeWritableMemoryImpl}.
* @author Roman Leventov
* @author Lee Rhodes
*/
@SuppressWarnings({"restriction"})
-abstract class WritableMemoryImpl extends BaseWritableMemoryImpl {
+abstract class NativeWritableMemoryImpl extends BaseWritableMemoryImpl {
//Pass-through ctor
- WritableMemoryImpl(final Object unsafeObj, final long nativeBaseOffset,
+ NativeWritableMemoryImpl(final Object unsafeObj, final long nativeBaseOffset,
final long regionOffset, final long capacityBytes) {
super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
index 440403b..658a1dd 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
@@ -43,8 +43,8 @@ import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
*/
/**
- * Implementation of {@link WritableMemory} for non-native endian byte order. Native variant is
- * {@link WritableMemoryImpl}.
+ * Implementation of {@link WritableMemoryImpl} for non-native endian byte order. Native variant is
+ * {@link NativeWritableMemoryImpl}.
* @author Roman Leventov
* @author Lee Rhodes
*/
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Utf8.java b/src/main/java/org/apache/datasketches/memory/internal/Utf8.java
index eb0d978..a8365df 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Utf8.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Utf8.java
@@ -29,8 +29,8 @@ import java.nio.BufferOverflowException;
import java.nio.CharBuffer;
/**
- * Encoding and decoding implementations of {@link WritableMemory#putCharsToUtf8} and
- * {@link Memory#getCharsFromUtf8}.
+ * Encoding and decoding implementations of {@link WritableMemoryImpl#putCharsToUtf8} and
+ * {@link MemoryImpl#getCharsFromUtf8}.
*
* <p>This is specifically designed to reduce the production of intermediate objects (garbage),
* thus significantly reducing pressure on the JVM Garbage Collector.
@@ -345,7 +345,7 @@ final class Utf8 {
// characters remaining, at least 4 bytes of memory space remaining, and the next 2
// characters must be a valid surrogate pair.
//
- // 2) There is insufficient Memory space to encode the current character from one of the
+ // 2) There is insufficient MemoryImpl space to encode the current character from one of the
// ifs above.
//
// We proceed assuming (1). If the following test fails, we move to an exception.
@@ -379,7 +379,7 @@ final class Utf8 {
}
if (bIdx > (byteLimit - 4)) {
- //4 Memory bytes required to encode a surrogate pair.
+ //4 MemoryImpl bytes required to encode a surrogate pair.
final int remaining = (int) ((bIdx - byteLimit) + 4L);
throw Utf8CodingException.shortUtf8EncodeByteLength(remaining);
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Utf8CodingException.java b/src/main/java/org/apache/datasketches/memory/internal/Utf8CodingException.java
index 2929d7a..1b2cdde 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Utf8CodingException.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Utf8CodingException.java
@@ -63,7 +63,7 @@ public final class Utf8CodingException extends RuntimeException {
}
static Utf8CodingException shortUtf8EncodeByteLength(final int remaining) {
- final String s = "Too few Memory bytes to encode a surrogate pair: " + remaining;
+ final String s = "Too few MemoryImpl bytes to encode a surrogate pair: " + remaining;
return new Utf8CodingException(s);
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Util.java b/src/main/java/org/apache/datasketches/memory/internal/Util.java
index 7a250c7..f44c52d 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Util.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Util.java
@@ -47,7 +47,7 @@ public final class Util {
* threshold, because internally it doesn't have safepoint polls, that may cause long
* "Time To Safe Point" pauses in the application. This has been fixed in JDK 9 (see
* https://bugs.openjdk.java.net/browse/JDK-8149596 and
- * https://bugs.openjdk.java.net/browse/JDK-8141491), but not in JDK 8, so the Memory library
+ * https://bugs.openjdk.java.net/browse/JDK-8141491), but not in JDK 8, so the MemoryImpl library
* should keep having this boilerplate as long as it supports Java 8.
*
* <p>A reference to this can be found in java.nio.Bits.</p>
@@ -84,7 +84,7 @@ public final class Util {
* search algorithm. The range must be sorted method) prior to making this call.
* If it is not sorted, the results are undefined. If the range contains
* multiple elements with the specified value, there is no guarantee which one will be found.
- * @param mem the Memory to be searched
+ * @param mem the MemoryImpl to be searched
* @param fromLongIndex the index of the first element (inclusive) to be searched
* @param toLongIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
@@ -94,7 +94,7 @@ public final class Util {
* than the key, or toIndex if all elements in the range are less than the specified key.
* Note that this guarantees that the return value will be ≥ 0 if and only if the key is found.
*/
- public static long binarySearchLongs(final Memory mem, final long fromLongIndex,
+ public static long binarySearchLongs(final MemoryImpl mem, final long fromLongIndex,
final long toLongIndex, final long key) {
checkBounds(fromLongIndex << 3, (toLongIndex - fromLongIndex) << 3, mem.getCapacity());
long low = fromLongIndex;
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java b/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
index d6f5e88..5911ca9 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
@@ -72,10 +72,10 @@ public abstract class WritableBuffer extends Buffer {
}
//MAP
- //Use WritableMemory for mapping files and then asWritableBuffer()
+ //Use WritableMemoryImpl for mapping files and then asWritableBuffer()
//ALLOCATE DIRECT
- //Use WritableMemory to allocate direct memory and then asWritableBuffer().
+ //Use WritableMemoryImpl to allocate direct memory and then asWritableBuffer().
//DUPLICATES
/**
@@ -152,7 +152,7 @@ public abstract class WritableBuffer extends Buffer {
* the backing storage and byte order are unspecified.
*
* <p><b>Note: </b><i>asWritableMemory()</i> and <i>asMemory()</i>
- * will return the originating <i>Memory</i> byte order.</p>
+ * will return the originating <i>MemoryImpl</i> byte order.</p>
* @param offsetBytes the starting offset with respect to the origin of this <i>WritableBuffer</i>
* @param capacityBytes the <i>capacity</i> of the returned region in bytes
* @param byteOrder the given byte order
@@ -164,15 +164,15 @@ public abstract class WritableBuffer extends Buffer {
//AS MEMORY
/**
- * Convert this WritableBuffer to a WritableMemory.
+ * Convert this WritableBuffer to a WritableMemoryImpl.
* If this object's capacity is zero, the returned object is effectively immutable and
* the backing storage and byte order are unspecified.
- * @return WritableMemory
+ * @return WritableMemoryImpl
*/
- public abstract WritableMemory asWritableMemory();
+ public abstract WritableMemoryImpl asWritableMemory();
//ACCESS PRIMITIVE HEAP ARRAYS for write
- //use WritableMemory and then asWritableBuffer().
+ //use WritableMemoryImpl and then asWritableBuffer().
//END OF CONSTRUCTOR-TYPE METHODS
//PRIMITIVE putX() and putXArray()
@@ -186,7 +186,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the boolean value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start.
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start.
* @param value the value to put
*/
public abstract void putBoolean(long offsetBytes, boolean value);
@@ -211,7 +211,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the byte value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
* @param value the value to put
*/
public abstract void putByte(long offsetBytes, byte value);
@@ -235,7 +235,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the char value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
* @param value the value to put
*/
public abstract void putChar(long offsetBytes, char value);
@@ -259,7 +259,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the double value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
* @param value the value to put
*/
public abstract void putDouble(long offsetBytes, double value);
@@ -283,7 +283,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the float value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
* @param value the value to put
*/
public abstract void putFloat(long offsetBytes, float value);
@@ -307,7 +307,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the int value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
* @param value the value to put
*/
public abstract void putInt(long offsetBytes, int value);
@@ -331,7 +331,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the long value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
* @param value the value to put
*/
public abstract void putLong(long offsetBytes, long value);
@@ -355,7 +355,7 @@ public abstract class WritableBuffer extends Buffer {
/**
* Puts the short value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
* @param value the value to put
*/
public abstract void putShort(long offsetBytes, short value);
@@ -390,10 +390,10 @@ public abstract class WritableBuffer extends Buffer {
//OTHER WRITABLE API METHODS
/**
- * For Direct Memory only. Other types of backing resources will return null.
+ * For Direct MemoryImpl only. Other types of backing resources will return null.
* Gets the MemoryRequestServer object used by dynamic off-heap (Direct) memory objects
* to request additional memory.
- * Set using {@link WritableMemory#allocateDirect(long, MemoryRequestServer)}.
+ * Set using {@link WritableMemoryImpl#allocateDirect(long, MemoryRequestServer)}.
* If not explicity set, this returns the {@link DefaultMemoryRequestServer}.
* @return the MemoryRequestServer object (if direct memory) or null.
*/
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandleImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandleImpl.java
index aaedf42..b62a1a0 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandleImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandleImpl.java
@@ -20,11 +20,13 @@
package org.apache.datasketches.memory.internal;
import org.apache.datasketches.memory.Handle;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableMemory;
/**
* A Handle for a writable direct memory resource.
- * Joins a WritableMemory with a writable, AutoCloseable AllocateDirect resource.
+ * Joins a WritableMemoryImpl with a writable, AutoCloseable AllocateDirect resource.
* Please read Javadocs for {@link Handle}.
*
* @author Lee Rhodes
@@ -36,15 +38,20 @@ public final class WritableDirectHandleImpl implements WritableDirectHandle {
* Having at least one final field makes this class safe for concurrent publication.
*/
final AllocateDirect direct;
- private WritableMemory wMem;
+ private BaseWritableMemoryImpl wMem;
- WritableDirectHandleImpl(final AllocateDirect allocatedDirect, final WritableMemory wMem) {
+ WritableDirectHandleImpl(final AllocateDirect allocatedDirect, final BaseWritableMemoryImpl wMem) {
direct = allocatedDirect;
this.wMem = wMem;
}
@Override
- public WritableMemory get() {
+ public Memory get() {
+ return wMem;
+ }
+
+ @Override
+ public WritableMemory getWritable() {
return wMem;
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandleImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandleImpl.java
index e30c2ab..3a77ca5 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandleImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandleImpl.java
@@ -21,6 +21,7 @@ package org.apache.datasketches.memory.internal;
import org.apache.datasketches.memory.Handle;
import org.apache.datasketches.memory.WritableMapHandle;
+import org.apache.datasketches.memory.WritableMemory;
/**
* A Handle for a memory-mapped, writable file resource.
@@ -39,8 +40,8 @@ public final class WritableMapHandleImpl extends MapHandleImpl
}
@Override
- public WritableMemory get() {
- return (WritableMemory) super.get();
+ public WritableMemory getWritable() {
+ return wMem;
}
@Override
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
index 85b8875..4bc97c4 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
@@ -24,16 +24,13 @@ import static org.apache.datasketches.memory.internal.Util.nullCheck;
import static org.apache.datasketches.memory.internal.Util.zeroCheck;
import java.io.File;
-import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-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;
+import org.apache.datasketches.memory.WritableMapHandle;
+import org.apache.datasketches.memory.WritableMemory;
/**
@@ -43,80 +40,30 @@ import org.apache.datasketches.memory.WritableDirectHandle;
* @author Roman Leventov
* @author Lee Rhodes
*/
-public abstract class WritableMemory extends Memory {
+public abstract class WritableMemoryImpl extends MemoryImpl implements WritableMemory {
//Pass-through ctor
- WritableMemory(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
+ WritableMemoryImpl(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
final long capacityBytes) {
super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
}
//BYTE BUFFER
- /**
- * Accesses the given ByteBuffer for write operations. The returned WritableMemory object has
- * the same byte order, as the given ByteBuffer, unless the capacity of the given ByteBuffer is
- * zero, then byte order of the returned WritableMemory object, as well as backing storage and
- * read-only status are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param byteBuf the given ByteBuffer
- * @return a new WritableMemory for write operations on the given ByteBuffer.
- */
- public static WritableMemory writableWrap(final ByteBuffer byteBuf) {
+ public static WritableMemoryImpl writableWrap(final ByteBuffer byteBuf) {
return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteBuf.order());
}
- /**
- * Accesses the given ByteBuffer for write operations. The returned WritableMemory object has
- * the given byte order, ignoring the byte order of the given ByteBuffer. If the capacity of
- * the given ByteBuffer is zero the byte order of the returned WritableMemory object
- * (as well as backing storage) is unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param byteBuf the given ByteBuffer, must not be null
- * @param byteOrder the byte order to be used, which may be independent of the byte order
- * state of the given ByteBuffer
- * @return a new WritableMemory for write operations on the given ByteBuffer.
- */
- public static WritableMemory writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ public static WritableMemoryImpl writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteOrder);
}
//MAP
- /**
- * Maps the entire given file into native-ordered WritableMemory for write operations
- * (including those > 2GB). Calling this method is equivalent to calling
- * {@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>.
- * @param file the given file to map
- * @return WritableMapHandle for managing the mapped Memory.
- * Please read Javadocs for {@link Handle}.
- * @throws IOException file not found or a RuntimeException.
- */
- public static WritableMapHandle writableMap(final File file) throws IOException {
- return WritableMemory.writableMap(file, 0, file.length(), Util.nativeByteOrder);
+ public static WritableMapHandle writableMap(final File file) {
+ return WritableMemoryImpl.writableMap(file, 0, file.length(), Util.nativeByteOrder);
}
- /**
- * Maps the specified portion of the given file into Memory for write operations
- * (including those > 2GB).
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.map(...)</i>.
- * @param file the given file to map. It may not be null.
- * @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 WritableMapHandleImpl for managing the mapped Memory.
- * Please read Javadocs for {@link Handle}.
- * @throws IOException file not found or RuntimeException, etc.
- */
public static WritableMapHandle writableMap(final File file, final long fileOffsetBytes,
- final long capacityBytes, final ByteOrder byteOrder) throws IOException {
+ final long capacityBytes, final ByteOrder byteOrder) {
zeroCheck(capacityBytes, "Capacity");
nullCheck(file, "file is null");
negativeCheck(fileOffsetBytes, "File offset is negative");
@@ -125,539 +72,186 @@ public abstract class WritableMemory extends Memory {
}
//ALLOCATE DIRECT
- /**
- * Allocates and provides access to capacityBytes directly in native (off-heap) memory
- * leveraging the WritableMemory API. Native byte order is assumed.
- * The allocated memory will be 8-byte aligned, but may not be page aligned.
- * If capacityBytes is zero, byte order, backing storage and read-only status
- * of the WritableMemory object, returned from {@link WritableHandle#get()} are unspecified.
- *
- * <p>The default MemoryRequestServer, which allocates any request for memory onto the heap,
- * will be used.</p>
- *
- * <p><b>NOTE:</b> Native/Direct memory acquired using Unsafe may have garbage in it.
- * It is the responsibility of the using class to clear this memory, if required,
- * and to call <i>close()</i> when done.</p>
- *
- * @param capacityBytes the size of the desired memory in bytes.
- * @return WritableDirectHandleImpl for this off-heap resource.
- * Please read Javadocs for {@link Handle}.
- */
public static WritableDirectHandle allocateDirect(final long capacityBytes) {
return allocateDirect(capacityBytes, null);
}
- /**
- * Allocates and provides access to capacityBytes directly in native (off-heap) memory
- * leveraging the WritableMemory API. The allocated memory will be 8-byte aligned, but may not
- * be page aligned. If capacityBytes is zero, byte order, backing storage and read-only status
- * of the WritableMemory object, returned from {@link WritableHandle#get()} are unspecified.
- *
- * <p><b>NOTE:</b> Native/Direct memory acquired using Unsafe may have garbage in it.
- * It is the responsibility of the using class to clear this memory, if required,
- * and to call <i>close()</i> when done.</p>
- *
- * @param capacityBytes the size of the desired memory in bytes.
- * @param memReqSvr A user-specified MemoryRequestServer.
- * This is a callback mechanism for a user client of direct memory to request more memory.
- * @return WritableHandle for this off-heap resource.
- * Please read Javadocs for {@link Handle}.
- */
public static WritableDirectHandle allocateDirect(final long capacityBytes,
final MemoryRequestServer memReqSvr) {
return BaseWritableMemoryImpl.wrapDirect(capacityBytes, Util.nativeByteOrder, memReqSvr);
}
//REGIONS
- /**
- * A writable region is a writable view of this object.
- * This returns a new <i>WritableMemory</i> representing the defined writable region with the
- * given offsetBytes and capacityBytes.
- * <ul>
- * <li>Returned object's origin = this objects' origin + <i>offsetBytes</i></li>
- * <li>Returned object's capacity = <i>capacityBytes</i></li>
- * </ul>
- * If the given capacityBytes is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- *
- * @param offsetBytes the starting offset with respect to this object.
- * @param capacityBytes the capacity of the returned object in bytes.
- * @return a new <i>WritableMemory</i> representing the defined writable region.
- */
- public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes);
-
- /**
- * A writable region is a writable view of this object.
- * This returns a new <i>WritableMemory</i> representing the defined writable region with the
- * given offsetBytes, capacityBytes and byte order.
- * <ul>
- * <li>Returned object's origin = this objects' origin + <i>offsetBytes</i></li>
- * <li>Returned object's capacity = <i>capacityBytes</i></li>
- * <li>Returned object's byte order = <i>byteOrder</i></li>
- * </ul>
- * If the given capacityBytes is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- *
- * @param offsetBytes the starting offset with respect to this object.
- * @param capacityBytes the capacity of the returned object in bytes.
- * @param byteOrder the given byte order
- * @return a new <i>WritableMemory</i> representing the defined writable region.
- */
- public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes,
+ @Override
+ public abstract WritableMemoryImpl writableRegion(long offsetBytes, long capacityBytes);
+
+ @Override
+ public abstract WritableMemoryImpl writableRegion(long offsetBytes, long capacityBytes,
ByteOrder byteOrder);
//AS BUFFER
- /**
- * Returns a new <i>WritableBuffer</i> with a writable view of this object.
- * <ul>
- * <li>Returned object's origin = this object's origin</li>
- * <li>Returned object's <i>start</i> = 0</li>
- * <li>Returned object's <i>position</i> = 0</li>
- * <li>Returned object's <i>end</i> = this object's capacity</li>
- * <li>Returned object's <i>capacity</i> = this object's capacity</li>
- * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
- * </ul>
- * If this object's capacity is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @return a new <i>WritableBuffer</i> with a view of this WritableMemory
- */
+ @Override
public abstract WritableBuffer asWritableBuffer();
- /**
- * Returns a new <i>WritableBuffer</i> with a writable view of this object
- * with the given byte order.
- * <ul>
- * <li>Returned object's origin = this object's origin</li>
- * <li>Returned object's <i>start</i> = 0</li>
- * <li>Returned object's <i>position</i> = 0</li>
- * <li>Returned object's <i>end</i> = this object's capacity</li>
- * <li>Returned object's <i>capacity</i> = this object's capacity</li>
- * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
- * </ul>
- * If this object's capacity is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @param byteOrder the given byte order
- * @return a new <i>WritableBuffer</i> with a view of this WritableMemory
- */
+ @Override
public abstract WritableBuffer asWritableBuffer(ByteOrder byteOrder);
//ALLOCATE HEAP VIA AUTOMATIC BYTE ARRAY
- /**
- * Creates on-heap WritableMemory with the given capacity and the native byte order. If the given
- * capacityBytes is zero, backing storage, byte order and read-only status of the returned
- * WritableMemory object are unspecified.
- * @param capacityBytes the given capacity in bytes.
- * @return a new WritableMemory for write operations on a new byte array.
- */
- public static WritableMemory allocate(final int capacityBytes) {
+ public static WritableMemoryImpl allocate(final int capacityBytes) {
final byte[] arr = new byte[capacityBytes];
return writableWrap(arr, Util.nativeByteOrder);
}
- /**
- * Creates on-heap WritableMemory with the given capacity and the given byte order. If the given
- * capacityBytes is zero, backing storage, byte order and read-only status of the returned
- * WritableMemory object are unspecified.
- * @param capacityBytes the given capacity in bytes.
- * @param byteOrder the given byte order to allocate new Memory object with.
- * @return a new WritableMemory for write operations on a new byte array.
- */
- public static WritableMemory allocate(final int capacityBytes, final ByteOrder byteOrder) {
+ public static WritableMemoryImpl allocate(final int capacityBytes, final ByteOrder byteOrder) {
final byte[] arr = new byte[capacityBytes];
return writableWrap(arr, byteOrder);
}
//ACCESS PRIMITIVE HEAP ARRAYS for write
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final boolean[] arr) {
+ public static WritableMemoryImpl writableWrap(final boolean[] arr) {
final long lengthBytes = arr.length << Prim.BOOLEAN.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final byte[] arr) {
- return WritableMemory.writableWrap(arr, 0, arr.length, Util.nativeByteOrder);
+ public static WritableMemoryImpl writableWrap(final byte[] arr) {
+ return WritableMemoryImpl.writableWrap(arr, 0, arr.length, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for write operations with the given byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @param byteOrder the byte order to be used
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final byte[] arr, final ByteOrder byteOrder) {
- return WritableMemory.writableWrap(arr, 0, arr.length, byteOrder);
+ public static WritableMemoryImpl writableWrap(final byte[] arr, final ByteOrder byteOrder) {
+ return WritableMemoryImpl.writableWrap(arr, 0, arr.length, byteOrder);
}
- /**
- * Wraps the given primitive array for write operations with the given byte order. If the given
- * lengthBytes is zero, backing storage, byte order and read-only status of the returned
- * WritableMemory object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @param offsetBytes the byte offset into the given array
- * @param lengthBytes the number of bytes to include from the given array
- * @param byteOrder the byte order to be used
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final byte[] arr, final int offsetBytes, final int lengthBytes,
+ public static WritableMemoryImpl 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);
}
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final char[] arr) {
+ public static WritableMemoryImpl writableWrap(final char[] arr) {
final long lengthBytes = arr.length << Prim.CHAR.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final short[] arr) {
+ public static WritableMemoryImpl writableWrap(final short[] arr) {
final long lengthBytes = arr.length << Prim.SHORT.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final int[] arr) {
+ public static WritableMemoryImpl writableWrap(final int[] arr) {
final long lengthBytes = arr.length << Prim.INT.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final long[] arr) {
+ public static WritableMemoryImpl writableWrap(final long[] arr) {
final long lengthBytes = arr.length << Prim.LONG.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final float[] arr) {
+ public static WritableMemoryImpl writableWrap(final float[] arr) {
final long lengthBytes = arr.length << Prim.FLOAT.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final double[] arr) {
+ public static WritableMemoryImpl writableWrap(final double[] arr) {
final long lengthBytes = arr.length << Prim.DOUBLE.shift();
return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
//END OF CONSTRUCTOR-TYPE METHODS
//PRIMITIVE putX() and putXArray()
- /**
- * Puts the boolean value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putBoolean(long offsetBytes, boolean value);
- /**
- * Puts the boolean array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetBooleans offset in array units
- * @param lengthBooleans number of array units to transfer
- */
+ @Override
public abstract void putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffsetBooleans,
int lengthBooleans);
- /**
- * Puts the byte value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putByte(long offsetBytes, byte value);
- /**
- * Puts the byte array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetBytes offset in array units
- * @param lengthBytes number of array units to transfer
- */
+ @Override
public abstract void putByteArray(long offsetBytes, byte[] srcArray, int srcOffsetBytes,
int lengthBytes);
- /**
- * Puts the char value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putChar(long offsetBytes, char value);
- /**
- * Puts the char array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetChars offset in array units
- * @param lengthChars number of array units to transfer
- */
+ @Override
public abstract void putCharArray(long offsetBytes, char[] srcArray, int srcOffsetChars,
int lengthChars);
- /**
- * Encodes characters from the given CharSequence into UTF-8 bytes and puts them into this
- * <i>WritableMemory</i> begining at the given offsetBytes.
- * This is specifically designed to reduce the production of intermediate objects (garbage),
- * thus significantly reducing pressure on the JVM Garbage Collector.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param src The source CharSequence to be encoded and put into this WritableMemory. It is
- * the responsibility of the caller to provide sufficient capacity in this
- * <i>WritableMemory</i> for the encoded Utf8 bytes. Characters outside the ASCII range can
- * require 2, 3 or 4 bytes per character to encode.
- * @return the number of bytes encoded
- */
+ @Override
public abstract long putCharsToUtf8(long offsetBytes, CharSequence src);
- /**
- * Puts the double value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putDouble(long offsetBytes, double value);
- /**
- * Puts the double array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetDoubles offset in array units
- * @param lengthDoubles number of array units to transfer
- */
+ @Override
public abstract void putDoubleArray(long offsetBytes, double[] srcArray,
final int srcOffsetDoubles, final int lengthDoubles);
- /**
- * Puts the float value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putFloat(long offsetBytes, float value);
- /**
- * Puts the float array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetFloats offset in array units
- * @param lengthFloats number of array units to transfer
- */
+ @Override
public abstract void putFloatArray(long offsetBytes, float[] srcArray,
final int srcOffsetFloats, final int lengthFloats);
- /**
- * Puts the int value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putInt(long offsetBytes, int value);
- /**
- * Puts the int array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetInts offset in array units
- * @param lengthInts number of array units to transfer
- */
+ @Override
public abstract void putIntArray(long offsetBytes, int[] srcArray,
final int srcOffsetInts, final int lengthInts);
- /**
- * Puts the long value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putLong(long offsetBytes, long value);
- /**
- * Puts the long array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetLongs offset in array units
- * @param lengthLongs number of array units to transfer
- */
+ @Override
public abstract void putLongArray(long offsetBytes, long[] srcArray,
final int srcOffsetLongs, final int lengthLongs);
- /**
- * Puts the short value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
+ @Override
public abstract void putShort(long offsetBytes, short value);
- /**
- * Puts the short array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetShorts offset in array units
- * @param lengthShorts number of array units to transfer
- */
+ @Override
public abstract void putShortArray(long offsetBytes, short[] srcArray,
final int srcOffsetShorts, final int lengthShorts);
//Atomic Methods
- /**
- * Atomically adds the given value to the long located at offsetBytes.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param delta the amount to add
- * @return the the previous value
- */
+ @Override
public abstract long getAndAddLong(long offsetBytes, long delta);
- /**
- * Atomically sets the current value at the memory location to the given updated value
- * if and only if the current value {@code ==} the expected value.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param expect the expected value
- * @param update the new value
- * @return {@code true} if successful. False return indicates that
- * the current value at the memory location was not equal to the expected value.
- */
+ @Override
public abstract boolean compareAndSwapLong(long offsetBytes, long expect, long update);
- /**
- * Atomically exchanges the given value with the current value located at offsetBytes.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param newValue new value
- * @return the previous value
- */
+ @Override
public abstract long getAndSetLong(long offsetBytes, long newValue);
//OTHER WRITE METHODS
- /**
- * Returns the primitive backing array, otherwise null.
- * @return the primitive backing array, otherwise null.
- */
+ @Override
public abstract Object getArray();
- /**
- * Clears all bytes of this Memory to zero
- */
+ @Override
public abstract void clear();
- /**
- * Clears a portion of this Memory to zero.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param lengthBytes the length in bytes
- */
+ @Override
public abstract void clear(long offsetBytes, long lengthBytes);
- /**
- * Clears the bits defined by the bitMask
- * @param offsetBytes offset bytes relative to this Memory start.
- * @param bitMask the bits set to one will be cleared
- */
+ @Override
public abstract void clearBits(long offsetBytes, byte bitMask);
- /**
- * Fills all bytes of this Memory region to the given byte value.
- * @param value the given byte value
- */
+ @Override
public abstract void fill(byte value);
- /**
- * Fills a portion of this Memory region to the given byte value.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param lengthBytes the length in bytes
- * @param value the given byte value
- */
+ @Override
public abstract void fill(long offsetBytes, long lengthBytes, byte value);
- /**
- * Sets the bits defined by the bitMask
- * @param offsetBytes offset bytes relative to this Memory start
- * @param bitMask the bits set to one will be set
- */
+ @Override
public abstract void setBits(long offsetBytes, byte bitMask);
//OTHER WRITABLE API METHODS
- /**
- * For Direct Memory only. Other types of backing resources will return null.
- * Gets the MemoryRequestServer object used by dynamic off-heap (Direct) memory objects
- * to request additional memory.
- * Set using {@link WritableMemory#allocateDirect(long, MemoryRequestServer)}.
- * If not explicity set, this returns the {@link DefaultMemoryRequestServer}.
- * @return the MemoryRequestServer object (if direct memory) or null.
- */
@Override
public MemoryRequestServer getMemoryRequestServer() {
return null;
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 78a6a35..2f8471a 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
@@ -26,8 +26,8 @@
*
* <p>In addition, this package provides:</p>
*
- * <ul><li>Two different access APIs: read-only {@link org.apache.datasketches.memory.internal.Memory} and
- * {@link org.apache.datasketches.memory.internal.WritableMemory} for absolute offset access,
+ * <ul><li>Two different access APIs: read-only {@link org.apache.datasketches.memory.internal.MemoryImpl} and
+ * {@link org.apache.datasketches.memory.internal.WritableMemoryImpl} for absolute offset access,
* and read-only {@link org.apache.datasketches.memory.internal.Buffer} and
* {@link org.apache.datasketches.memory.internal.WritableBuffer}
* for relative positional access (similar to ByteBuffer).</li>
@@ -38,8 +38,8 @@
* <li>The conversion from Writable to read-only is just a cast, so no unnecessary objects are
* created. For example:
* <blockquote><pre>
- * WritableMemory wMem = ...
- * Memory mem = wMem;
+ * WritableMemoryImpl wMem = ...
+ * MemoryImpl mem = wMem;
* </pre></blockquote>
* </li>
*
@@ -51,7 +51,7 @@
* This virtually eliminates the possibility of accidentally writing into the memory space
* previously owned by a closed resource.</li>
*
- * <li>Improved performance over the prior Memory implementation.</li>
+ * <li>Improved performance over the prior MemoryImpl implementation.</li>
*
* <li>Cleaner internal architecture, which will make it easier to extend in the future.</li>
*
@@ -64,13 +64,13 @@
* byte-level read and write access. The four resources are:</p>
*
* <ul><li>Direct (a.k.a. Native) off-heap memory allocated by the user.</li>
- * <li>Memory-mapped files, both writable and read-only.</li>
+ * <li>MemoryImpl-mapped files, both writable and read-only.</li>
* <li>{@code ByteBuffers}, both heap-based and direct, writable and read-only.</li>
* <li>Heap-based primitive arrays, which can be accessed as writable or read-only.</li>
* </ul>
*
* <p>The two different access APIs are:</p>
- * <ul><li><i>Memory, WritableMemory</i>: Absolute offset addressing into a resource.</li>
+ * <ul><li><i>MemoryImpl, WritableMemoryImpl</i>: Absolute offset addressing into a resource.</li>
* <li><i>Buffer, WritableBuffer</i>: Position relative addressing into a resource.</li>
* </ul>
*
@@ -110,14 +110,14 @@
* The resource can also be explicitly closed by the user by calling {@code Handle.close()}.</p>
* <blockquote><pre>
* //Using try-with-resources block:
- * try (WritableyMapHandle handle = WritableMemory.map(File file)) {
- * WritableMemory wMem = handle.get();
+ * try (WritableyMapHandle handle = WritableMemoryImpl.map(File file)) {
+ * WritableMemoryImpl wMem = handle.get();
* doWork(wMem) // read and write to memory mapped file.
* }
*
* //Using explicit close():
- * WritableMapHandleImpl handle = WritableMemory.map(File file);
- * WritableMemory wMem = handle.get();
+ * WritableMapHandleImpl handle = WritableMemoryImpl.map(File file);
+ * WritableMemoryImpl wMem = handle.get();
* doWork(wMem) // read and write to memory mapped file.
* handle.close();
* </pre></blockquote>
@@ -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>
- * WritableMapHandleImpl handler = WritableMemory.map(File file);
+ * WritableMapHandleImpl handler = WritableMemoryImpl.map(File file);
* doWorkAndClose(handle); //passes the handle to object that closes the resource.
* </pre></blockquote>
*
@@ -149,20 +149,20 @@
* hard-to-find bug.</li>
* </ul>
*
- *<p>Moving back and forth between <i>Memory</i> and <i>Buffer</i>:</p>
+ *<p>Moving back and forth between <i>MemoryImpl</i> and <i>Buffer</i>:</p>
*<blockquote><pre>
- * Memory mem = ...
+ * MemoryImpl mem = ...
* Buffer buf = mem.asBuffer();
* ...
- * Memory mem2 = buf.asMemory();
+ * MemoryImpl mem2 = buf.asMemory();
* ...
* </pre></blockquote>
*
* <p>Hierarchical memory regions can be easily created:</p>
* <blockquote><pre>
- * WritableMemory wMem = ...
- * WritableMemory wReg = wMem.writableRegion(offset, length); //OR
- * Memory reg = wMem.region(offset, length);
+ * WritableMemoryImpl wMem = ...
+ * WritableMemoryImpl wReg = wMem.writableRegion(offset, length); //OR
+ * MemoryImpl reg = wMem.region(offset, length);
* </pre></blockquote>
*
* <p>With asserts enabled in the JVM, all methods are checked for bounds and
diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
index bfe2d05..a78e27f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
@@ -33,7 +33,7 @@ import java.io.File;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -51,7 +51,7 @@ public class AllocateDirectMapMemoryTest {
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle rh = Memory.map(file)) {
+ try (MapHandle rh = MemoryImpl.map(file)) {
rh.close();
}
}
@@ -59,13 +59,13 @@ public class AllocateDirectMapMemoryTest {
@Test
public void testIllegalArguments() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle rh = Memory.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = MemoryImpl.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Position was negative.");
} catch (IllegalArgumentException e) {
//ok
}
- try (MapHandle rh = Memory.map(file, 0, -1, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = MemoryImpl.map(file, 0, -1, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Size was negative.");
} catch (IllegalArgumentException e) {
//ok
@@ -76,8 +76,8 @@ public class AllocateDirectMapMemoryTest {
public void testMapAndMultipleClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
- Memory map = rh.get();
+ try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ MemoryImpl map = rh.get();
assertEquals(memCapacity, map.getCapacity());
rh.close();
rh.close();
@@ -91,8 +91,8 @@ public class AllocateDirectMapMemoryTest {
public void testReadFailAfterClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
- Memory mmf = rh.get();
+ try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ MemoryImpl mmf = rh.get();
rh.close();
mmf.getByte(0);
} catch (AssertionError e) {
@@ -104,7 +104,7 @@ public class AllocateDirectMapMemoryTest {
public void testLoad() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
rh.close();
@@ -115,8 +115,8 @@ public class AllocateDirectMapMemoryTest {
public void testHandlerHandoffWithTWR() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- Memory mem;
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ MemoryImpl mem;
+ try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
@@ -130,7 +130,7 @@ public class AllocateDirectMapMemoryTest {
public void testHandoffWithoutClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder());
+ MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder());
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
@@ -140,7 +140,7 @@ public class AllocateDirectMapMemoryTest {
@AfterClass
public void afterAllTests() {
if (hand != null) {
- Memory mem = hand.get();
+ MemoryImpl mem = hand.get();
if ((mem != null) && mem.isValid()) {
hand.close();
assertFalse(mem.isValid());
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 68de819..c487b91 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
@@ -30,7 +30,7 @@ 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.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
@@ -40,8 +40,8 @@ public class AllocateDirectMemoryTest {
@Test
public void simpleAllocateDirect() {
int longs = 32;
- WritableMemory wMem;
- try (WritableHandle wh = WritableMemory.allocateDirect(longs << 3)) {
+ WritableMemoryImpl wMem;
+ try (WritableHandle wh = WritableMemoryImpl.allocateDirect(longs << 3)) {
wMem = wh.get();
for (int i = 0; i<longs; i++) {
wMem.putLong(i << 3, i);
@@ -70,8 +70,8 @@ public class AllocateDirectMemoryTest {
public void checkDefaultMemoryRequestServer() {
int longs1 = 32;
int bytes1 = longs1 << 3;
- try (WritableHandle wh = WritableMemory.allocateDirect(bytes1)) {
- WritableMemory origWmem = wh.get();
+ try (WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes1)) {
+ WritableMemoryImpl origWmem = wh.get();
for (int i = 0; i<longs1; i++) { //puts data in wMem1
origWmem.putLong(i << 3, i);
assertEquals(origWmem.getLong(i << 3), i);
@@ -81,7 +81,7 @@ public class AllocateDirectMemoryTest {
int longs2 = 64;
int bytes2 = longs2 << 3;
MemoryRequestServer memReqSvr = origWmem.getMemoryRequestServer();
- WritableMemory newWmem = memReqSvr.request(bytes2);
+ WritableMemoryImpl newWmem = memReqSvr.request(bytes2);
assertFalse(newWmem.isDirect()); //on heap by default
for (int i = 0; i < longs2; i++) {
newWmem.putLong(i << 3, i);
@@ -95,8 +95,8 @@ public class AllocateDirectMemoryTest {
@Test
public void checkNullMemoryRequestServer() {
- try (WritableHandle wh = WritableMemory.allocateDirect(128, null)) {
- WritableMemory wmem = wh.get();
+ try (WritableHandle wh = WritableMemoryImpl.allocateDirect(128, null)) {
+ WritableMemoryImpl wmem = wh.get();
assertNotNull(wmem.getMemoryRequestServer());
}
}
@@ -106,7 +106,7 @@ public class AllocateDirectMemoryTest {
public void checkNonNativeDirect() { //not allowed in public API
try (WritableDirectHandle h = ReflectUtil.wrapDirect(8, Util.nonNativeByteOrder, null)) {
//BaseWritableMemoryImpl.wrapDirect(8, Util.nonNativeByteOrder, null)) {
- WritableMemory wmem = h.get();
+ WritableMemoryImpl wmem = h.get();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
}
@@ -115,7 +115,7 @@ public class AllocateDirectMemoryTest {
@Test
public void checkExplicitClose() {
final long cap = 128;
- try (WritableDirectHandle wdh = WritableMemory.allocateDirect(cap)) {
+ try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(cap)) {
wdh.close(); //explicit close. Does the work of closing
} //end of scope call to Cleaner/Deallocator also will be redundant
}
@@ -123,7 +123,7 @@ public class AllocateDirectMemoryTest {
@SuppressWarnings("static-access")
@AfterClass
public void checkDirectCounter() {
- WritableMemory mem = WritableMemory.writableWrap(new byte[8]);
+ WritableMemoryImpl mem = WritableMemoryImpl.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 a6b8640..5761068 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
@@ -39,10 +39,10 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.MapHandle;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.apache.datasketches.memory.WritableMapHandle;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
@@ -82,8 +82,8 @@ public class AllocateDirectWritableMapMemoryTest {
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle h = Memory.map(file); WritableMapHandle wh = (WritableMapHandle) h) {
- Memory mem = h.get();
+ try (MapHandle h = MemoryImpl.map(file); WritableMapHandle wh = (WritableMapHandle) h) {
+ MemoryImpl mem = h.get();
byte[] bytes = new byte[(int)mem.getCapacity()];
mem.getByteArray(0, bytes, 0, bytes.length);
String text = new String(bytes, UTF_8);
@@ -117,11 +117,11 @@ public class AllocateDirectWritableMapMemoryTest {
try (
WritableMapHandle dstHandle
- = WritableMemory.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
- WritableHandle srcHandle = WritableMemory.allocateDirect(bytes)) {
+ = WritableMemoryImpl.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
+ WritableHandle srcHandle = WritableMemoryImpl.allocateDirect(bytes)) {
- WritableMemory dstMem = dstHandle.get();
- WritableMemory srcMem = srcHandle.get();
+ WritableMemoryImpl dstMem = dstHandle.get();
+ WritableMemoryImpl srcMem = srcHandle.get();
for (long i = 0; i < longs; i++) {
srcMem.putLong(i << 3, i); //load source with consecutive longs
@@ -152,8 +152,8 @@ public class AllocateDirectWritableMapMemoryTest {
file.deleteOnExit(); //comment out if you want to examine the file.
final long bytes = 8;
- try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nonNativeByteOrder)) {
- WritableMemory wmem = h.get();
+ try (WritableMapHandle h = WritableMemoryImpl.writableMap(file, 0L, bytes, Util.nonNativeByteOrder)) {
+ WritableMemoryImpl wmem = h.get();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
}
@@ -164,14 +164,14 @@ public class AllocateDirectWritableMapMemoryTest {
public void testMapException() throws IOException {
File dummy = createFile("dummy.txt", ""); //zero length
//throws java.lang.reflect.InvocationTargetException
- Memory.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
+ MemoryImpl.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
}
@Test(expectedExceptions = ReadOnlyException.class)
public void simpleMap2() throws IOException {
File file = getResourceFile("GettysburgAddress.txt");
assertTrue(isFileReadOnly(file));
- try (WritableMapHandle rh = WritableMemory.writableMap(file)) { //throws
+ try (WritableMapHandle rh = WritableMemoryImpl.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.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
+ try (WritableMapHandle rh = WritableMemoryImpl.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
//
} catch (IOException e) {
throw new RuntimeException(e);
@@ -196,8 +196,8 @@ public class AllocateDirectWritableMapMemoryTest {
byte[] correctByteArr = correctStr.getBytes(UTF_8);
long corrBytes = correctByteArr.length;
- try (MapHandle rh = Memory.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
- Memory map = rh.get();
+ try (MapHandle rh = MemoryImpl.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
+ MemoryImpl map = rh.get();
rh.load();
assertTrue(rh.isLoaded());
//confirm orig string
@@ -207,9 +207,9 @@ public class AllocateDirectWritableMapMemoryTest {
assertEquals(bufStr, origStr);
}
- try (WritableMapHandle wrh = WritableMemory.writableMap(origFile, 0, corrBytes,
+ try (WritableMapHandle wrh = WritableMemoryImpl.writableMap(origFile, 0, corrBytes,
ByteOrder.nativeOrder())) {
- WritableMemory wMap = wrh.get();
+ WritableMemoryImpl wMap = wrh.get();
wrh.load();
assertTrue(wrh.isLoaded());
// over write content
@@ -240,7 +240,7 @@ public class AllocateDirectWritableMapMemoryTest {
@Test
public void checkExplicitClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle wmh = Memory.map(file)) {
+ try (MapHandle wmh = MemoryImpl.map(file)) {
wmh.close(); //explicit close.
} //end of scope call to Cleaner/Deallocator also will be redundant
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
index 51b2ded..0f5f44e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -35,7 +35,7 @@ public class BaseBufferTest {
@Test
public void checkLimits() {
- Buffer buf = Memory.wrap(new byte[100]).asBuffer();
+ Buffer buf = MemoryImpl.wrap(new byte[100]).asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -48,7 +48,7 @@ public class BaseBufferTest {
@Test
public void checkLimitsAndCheck() {
- Buffer buf = Memory.wrap(new byte[100]).asBuffer();
+ Buffer buf = MemoryImpl.wrap(new byte[100]).asBuffer();
buf.setAndCheckStartPositionEnd(40, 45, 50);
buf.setAndCheckStartPositionEnd(0, 0, 100);
try {
@@ -76,13 +76,13 @@ public class BaseBufferTest {
@Test
public void checkCheckValid() {
- WritableMemory wmem;
+ WritableMemoryImpl wmem;
Buffer buf;
- try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
+ try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
wmem = hand.get();
buf = wmem.asBuffer();
}
@SuppressWarnings("unused")
- Memory mem = buf.asMemory();
+ MemoryImpl mem = buf.asMemory();
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
index 2ba50b8..919265c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
@@ -28,12 +28,12 @@ import static org.testng.Assert.fail;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Prim;
import org.apache.datasketches.memory.internal.StepBoolean;
import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -47,8 +47,8 @@ public class BaseStateTest {
@Test
public void checkIsSameResource() {
- WritableMemory wmem = WritableMemory.allocate(16);
- Memory mem = wmem;
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(16);
+ MemoryImpl mem = wmem;
assertFalse(wmem.isSameResource(null));
assertTrue(wmem.isSameResource(mem));
@@ -61,7 +61,7 @@ public class BaseStateTest {
@Test
public void checkNotEqualTo() {
byte[] arr = new byte[8];
- Memory mem = Memory.wrap(arr);
+ MemoryImpl mem = MemoryImpl.wrap(arr);
assertFalse(mem.equalTo(0, arr, 0, 8));
}
@@ -90,14 +90,14 @@ public class BaseStateTest {
@Test
public void checkGetNativeBaseOffset_Heap() throws Exception {
- WritableMemory wmem = WritableMemory.allocate(8); //heap
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8); //heap
final long offset = ReflectUtil.getNativeBaseOffset(wmem);
assertEquals(offset, 0L);
}
@Test
public void checkIsByteOrderCompatible() {
- WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
assertTrue(wmem.isByteOrderCompatible(ByteOrder.nativeOrder()));
}
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 b1cb7aa..4a19f56 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
@@ -27,10 +27,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -84,7 +84,7 @@ public class Buffer2Test {
byteArray[i] = i;
}
- Buffer buffer = Memory.wrap(byteArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(byteArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(byteArray[i++], buffer.getByte());
@@ -107,7 +107,7 @@ public class Buffer2Test {
charArray[i] = i;
}
- Buffer buffer = Memory.wrap(charArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(charArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(charArray[i++], buffer.getChar());
@@ -127,7 +127,7 @@ public class Buffer2Test {
shortArray[i] = i;
}
- Buffer buffer = Memory.wrap(shortArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(shortArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(shortArray[i++], buffer.getShort());
@@ -147,7 +147,7 @@ public class Buffer2Test {
intArray[i] = i;
}
- Buffer buffer = Memory.wrap(intArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(intArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(intArray[i++], buffer.getInt());
@@ -167,7 +167,7 @@ public class Buffer2Test {
longArray[i] = i;
}
- Buffer buffer = Memory.wrap(longArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(longArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(longArray[i++], buffer.getLong());
@@ -187,7 +187,7 @@ public class Buffer2Test {
floatArray[i] = i;
}
- Buffer buffer = Memory.wrap(floatArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(floatArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(floatArray[i++], buffer.getFloat());
@@ -207,7 +207,7 @@ public class Buffer2Test {
doubleArray[i] = i;
}
- Buffer buffer = Memory.wrap(doubleArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(doubleArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(doubleArray[i++], buffer.getDouble());
@@ -229,7 +229,7 @@ public class Buffer2Test {
}
}
- Buffer buffer = Memory.wrap(booleanArray).asBuffer();
+ Buffer buffer = MemoryImpl.wrap(booleanArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(booleanArray[i++], buffer.getBoolean());
@@ -348,7 +348,7 @@ public class Buffer2Test {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Memory mem = Memory.wrap(arr);
+ MemoryImpl mem = MemoryImpl.wrap(arr);
Buffer buf = mem.asBuffer();
Buffer reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
for (int i = 0; i < n2; i++) {
@@ -370,7 +370,7 @@ public class Buffer2Test {
bb.position(10);
Buffer buffer = Buffer.wrap(bb);
- Memory memory = buffer.asMemory();
+ MemoryImpl memory = buffer.asMemory();
assertEquals(buffer.getCapacity(), memory.getCapacity());
@@ -408,7 +408,7 @@ public class Buffer2Test {
@Test
public void testWritableDuplicate() {
- WritableMemory wmem = WritableMemory.writableWrap(new byte[1]);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[1]);
WritableBuffer wbuf = wmem.asWritableBuffer();
WritableBuffer wbuf2 = wbuf.writableDuplicate();
assertEquals(wbuf2.getCapacity(), 1);
@@ -419,14 +419,14 @@ public class Buffer2Test {
@Test
public void checkIndependence() {
int cap = 64;
- WritableMemory wmem = WritableMemory.allocate(cap);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(cap);
WritableBuffer wbuf1 = wmem.asWritableBuffer();
WritableBuffer wbuf2 = wmem.asWritableBuffer();
assertFalse(wbuf1 == wbuf2);
assertTrue(wbuf1.isSameResource(wbuf2));
- WritableMemory reg1 = wmem.writableRegion(0, cap);
- WritableMemory reg2 = wmem.writableRegion(0, cap);
+ WritableMemoryImpl reg1 = wmem.writableRegion(0, cap);
+ WritableMemoryImpl reg2 = wmem.writableRegion(0, cap);
assertFalse(reg1 == reg2);
assertTrue(reg1.isSameResource(reg2));
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
index 0970ffb..356862d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
@@ -19,13 +19,13 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class BufferBoundaryCheckTest {
- private final WritableMemory writableMemory = WritableMemory.allocate(8);
+ private final WritableMemoryImpl writableMemory = WritableMemoryImpl.allocate(8);
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
index 50b6557..d71419a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
@@ -27,7 +27,7 @@ import java.nio.ByteBuffer;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -93,7 +93,7 @@ public class BufferInvariantsTest {
@Test
public void testBuf() {
int n = 25;
- WritableBuffer buf = WritableMemory.allocate(n).asWritableBuffer();
+ WritableBuffer buf = WritableMemoryImpl.allocate(n).asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -162,8 +162,8 @@ public class BufferInvariantsTest {
@Test
public void checkLimitsDirect() {
- try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
- WritableMemory wmem = hand.get();
+ try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
+ WritableMemoryImpl wmem = hand.get();
Buffer buf = wmem.asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
@@ -233,8 +233,8 @@ public class BufferInvariantsTest {
@Test
public void testBufDirect() {
int n = 25;
- try (WritableHandle whand = WritableMemory.allocateDirect(n)) {
- WritableMemory wmem = whand.get();
+ try (WritableHandle whand = WritableMemoryImpl.allocateDirect(n)) {
+ WritableMemoryImpl wmem = whand.get();
WritableBuffer buf = wmem.asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
index 24f195f..6d67e67 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
@@ -24,7 +24,7 @@ import java.nio.ByteBuffer;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -158,19 +158,19 @@ public class BufferReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryAsBuffer() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asBuffer();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemoryImpl.allocate(8).asBuffer();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferRegion() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().region();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemoryImpl.allocate(8).asWritableBuffer().region();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferDuplicate() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().duplicate();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemoryImpl.allocate(8).asWritableBuffer().duplicate();
buf1.putInt(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 9c1481a..38a4f31 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
@@ -27,9 +27,9 @@ import java.util.List;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
import org.testng.collections.Lists;
@@ -39,8 +39,8 @@ public class BufferTest {
@Test
public void checkDirectRoundTrip() {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
- WritableMemory wmem = wh.get();
+ try (WritableHandle wh = WritableMemoryImpl.allocateDirect(n * 8)) {
+ WritableMemoryImpl wmem = wh.get();
WritableBuffer wbuf = wmem.asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
@@ -56,7 +56,7 @@ public class BufferTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -71,7 +71,7 @@ public class BufferTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -80,29 +80,29 @@ public class BufferTest {
long v = wbuf.getLong();
assertEquals(v, i);
}
- Buffer buf = Memory.wrap(arr).asBuffer();
+ Buffer buf = MemoryImpl.wrap(arr).asBuffer();
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
assertEquals(v, i);
}
// Check Zero length array wraps
- Memory mem = Memory.wrap(new byte[0]);
+ MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
Buffer buffZeroLengthArrayWrap = mem.asBuffer();
assertEquals(buffZeroLengthArrayWrap.getCapacity(), 0);
// check 0 length array wraps
List<Buffer> buffersToCheck = Lists.newArrayList();
- buffersToCheck.add(WritableMemory.allocate(0).asBuffer());
+ buffersToCheck.add(WritableMemoryImpl.allocate(0).asBuffer());
buffersToCheck.add(WritableBuffer.wrap(ByteBuffer.allocate(0)));
buffersToCheck.add(Buffer.wrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(Memory.wrap(new boolean[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new byte[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new char[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new short[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new int[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new long[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new float[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new double[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new boolean[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new byte[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new char[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new short[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new int[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new long[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new float[0]).asBuffer());
+ buffersToCheck.add(MemoryImpl.wrap(new double[0]).asBuffer());
//Check the buffer lengths
for (Buffer buffer : buffersToCheck) {
assertEquals(buffer.getCapacity(), 0);
@@ -151,7 +151,7 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Buffer buf1 = Memory.wrap(arr).asBuffer();
+ Buffer buf1 = MemoryImpl.wrap(arr).asBuffer();
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = buf1.getLong();
assertEquals(v, i);
@@ -231,7 +231,7 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
wbuf.putLongArray(arr, 0, n);
long[] arr2 = new long[n];
wbuf.resetPosition();
@@ -248,7 +248,7 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Buffer buf = Memory.wrap(arr).asBuffer();
+ Buffer buf = MemoryImpl.wrap(arr).asBuffer();
buf.setPosition(n2 * 8);
Buffer reg = buf.region();
for (int i = 0; i < n2; 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.writableWrap(arr).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
assertEquals(wbuf.getLong(), i); //write all
//println("" + wmem.getLong(i * 8));
@@ -284,11 +284,11 @@ public class BufferTest {
public void checkParentUseAfterFree() {
int bytes = 64 * 8;
@SuppressWarnings("resource") //intentionally not using try-with-resources here
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
- WritableMemory wmem = wh.get();
+ WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
+ WritableMemoryImpl wmem = wh.get();
WritableBuffer wbuf = wmem.asWritableBuffer();
wh.close();
- //with -ea assert: Memory not valid.
+ //with -ea assert: MemoryImpl not valid.
//with -da sometimes segfaults, sometimes passes!
wbuf.getLong();
}
@@ -297,19 +297,19 @@ public class BufferTest {
@Test(expectedExceptions = AssertionError.class)
public void checkRegionUseAfterFree() {
int bytes = 64;
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
- Memory wmem = wh.get();
+ WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
+ MemoryImpl wmem = wh.get();
Buffer reg = wmem.asBuffer().region();
wh.close();
- //with -ea assert: Memory not valid.
+ //with -ea assert: MemoryImpl not valid.
//with -da sometimes segfaults, sometimes passes!
reg.getByte();
}
@Test(expectedExceptions = AssertionError.class)
public void checkBaseBufferInvariants() {
- WritableBuffer wbuf = WritableMemory.allocate(64).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.allocate(64).asWritableBuffer();
wbuf.setStartPositionEnd(1, 0, 2); //out of order
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
index f3b78ee..2f7f4fb 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
@@ -23,7 +23,7 @@ import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -32,8 +32,8 @@ public class CommonBufferTest {
@Test
public void checkSetGet() {
int memCapacity = 60; //must be at least 60
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetTests(buf);
@@ -134,8 +134,8 @@ public class CommonBufferTest {
@Test
public void checkSetGetArrays() {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetArraysTests(buf);
@@ -231,8 +231,8 @@ public class CommonBufferTest {
@Test
public void checkSetGetPartialArraysWithOffset() {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetPartialArraysWithOffsetTests(buf);
@@ -325,8 +325,8 @@ public class CommonBufferTest {
@Test
public void checkSetClearMemoryRegions() {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh1.get();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
@@ -414,8 +414,8 @@ public class CommonBufferTest {
@Test
public void checkToHexStringAllMem() {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh1.get();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
toHexStringAllMemTests(buf); //requires println enabled to visually check
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
index 5cde091..5e237b6 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
@@ -28,7 +28,7 @@ import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -37,14 +37,14 @@ public class CommonMemoryTest {
@Test
public void checkSetGet() {
int memCapacity = 16; //must be at least 8
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
assertEquals(mem.getCapacity(), memCapacity);
setGetTests(mem);
}
}
- public static void setGetTests(WritableMemory mem) {
+ public static void setGetTests(WritableMemoryImpl mem) {
mem.putBoolean(0, true);
assertEquals(mem.getBoolean(0), true);
mem.putBoolean(0, false);
@@ -89,14 +89,14 @@ public class CommonMemoryTest {
@Test
public void checkSetGetArrays() {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
assertEquals(memCapacity, mem.getCapacity());
setGetArraysTests(mem);
}
}
- public static void setGetArraysTests(WritableMemory mem) {
+ public static void setGetArraysTests(WritableMemoryImpl mem) {
int accessCapacity = (int)mem.getCapacity();
int words = 4;
@@ -169,14 +169,14 @@ public class CommonMemoryTest {
@Test
public void checkSetGetPartialArraysWithOffset() {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
assertEquals(memCapacity, mem.getCapacity());
setGetPartialArraysWithOffsetTests(mem);
}
}
- public static void setGetPartialArraysWithOffsetTests(WritableMemory mem) {
+ public static void setGetPartialArraysWithOffsetTests(WritableMemoryImpl mem) {
int items= 4;
boolean[] srcArray1 = {true, false, true, false};
boolean[] dstArray1 = new boolean[items];
@@ -246,15 +246,15 @@ public class CommonMemoryTest {
@Test
public void checkSetClearIsBits() {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
assertEquals(memCapacity, mem.getCapacity());
mem.clear();
setClearIsBitsTests(mem);
}
}
- public static void setClearIsBitsTests(WritableMemory mem) {
+ public static void setClearIsBitsTests(WritableMemoryImpl mem) {
//single bits
for (int i = 0; i < 8; i++) {
long bitMask = (1 << i);
@@ -287,14 +287,14 @@ public class CommonMemoryTest {
@Test
public void checkAtomicMethods() {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
assertEquals(mem.getCapacity(), memCapacity);
atomicMethodTests(mem);
}
}
- public static void atomicMethodTests(WritableMemory mem) {
+ public static void atomicMethodTests(WritableMemoryImpl mem) {
mem.putLong(0, 500);
mem.getAndAddLong(0, 1);
assertEquals(mem.getLong(0), 501);
@@ -314,8 +314,8 @@ public class CommonMemoryTest {
@Test
public void checkSetClearMemoryRegions() {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh1.get();
setClearMemoryRegionsTests(mem); //requires println enabled to visually check
for (int i = 0; i < memCapacity; i++) {
@@ -325,7 +325,7 @@ public class CommonMemoryTest {
}
//enable println stmts to visually check
- public static void setClearMemoryRegionsTests(WritableMemory mem) {
+ public static void setClearMemoryRegionsTests(WritableMemoryImpl mem) {
int accessCapacity = (int)mem.getCapacity();
//define regions
@@ -385,14 +385,14 @@ public class CommonMemoryTest {
@Test
public void checkToHexStringAllMem() {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh1.get();
toHexStringAllMemTests(mem); //requires println enabled to visually check
}
}
//enable println to visually check
- public static void toHexStringAllMemTests(WritableMemory mem) {
+ public static void toHexStringAllMemTests(WritableMemoryImpl mem) {
int memCapacity = (int)mem.getCapacity();
for (int i = 0; i < memCapacity; i++) {
diff --git a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
index f82561a..e81d369 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
@@ -22,8 +22,8 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -65,7 +65,7 @@ public class CopyMemoryOverlapTest {
}
private static final void copyUsingDirectMemory(long copyLongs, double overlap, boolean copyUp) {
- println("Copy Using Direct Memory");
+ println("Copy Using Direct MemoryImpl");
long overlapLongs = (long) (overlap * copyLongs);
long backingLongs = (2 * copyLongs) - overlapLongs;
@@ -93,8 +93,8 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
- WritableMemory backingMem = backHandle.get();
+ try (WritableHandle backHandle = WritableMemoryImpl.allocateDirect(backingBytes)) {
+ WritableMemoryImpl backingMem = backHandle.get();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
backingMem.copyTo(fromOffsetBytes, backingMem, toOffsetBytes, copyBytes);
@@ -105,7 +105,7 @@ public class CopyMemoryOverlapTest {
}
private static final void copyUsingDirectRegions(long copyLongs, double overlap, boolean copyUp) {
- println("Copy Using Direct Memory");
+ println("Copy Using Direct MemoryImpl");
long overlapLongs = (long) (overlap * copyLongs);
long backingLongs = (2 * copyLongs) - overlapLongs;
@@ -133,12 +133,12 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
- WritableMemory backingMem = backHandle.get();
+ try (WritableHandle backHandle = WritableMemoryImpl.allocateDirect(backingBytes)) {
+ WritableMemoryImpl backingMem = backHandle.get();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
- WritableMemory reg1 = backingMem.writableRegion(fromOffsetBytes, copyBytes);
- WritableMemory reg2 = backingMem.writableRegion(toOffsetBytes, copyBytes);
+ WritableMemoryImpl reg1 = backingMem.writableRegion(fromOffsetBytes, copyBytes);
+ WritableMemoryImpl reg2 = backingMem.writableRegion(toOffsetBytes, copyBytes);
reg1.copyTo(0, reg2, 0, copyBytes);
//listMem(backingMem, "After");
@@ -147,13 +147,13 @@ public class CopyMemoryOverlapTest {
println("");
}
- private static final void fill(WritableMemory wmem) {
+ private static final void fill(WritableMemoryImpl wmem) {
long longs = wmem.getCapacity() >>> 3;
for (long i = 0; i < longs; i++) { wmem.putLong(i << 3, i); } //fill with 0 .. (longs - 1)
//checkMemLongs(wmem, 0L, 0L, longs);
}
- private static final void checkMemLongs(Memory mem, long fromOffsetLongs, long toOffsetLongs, long copyLongs) {
+ private static final void checkMemLongs(MemoryImpl mem, long fromOffsetLongs, long toOffsetLongs, long copyLongs) {
for (long i = 0; i < copyLongs; i++) {
long memVal = mem.getLong((toOffsetLongs + i) << 3);
assertEquals(memVal, fromOffsetLongs + i);
@@ -161,7 +161,7 @@ public class CopyMemoryOverlapTest {
}
@SuppressWarnings("unused")
- private static final void listMem(Memory mem, String comment) {
+ private static final void listMem(MemoryImpl mem, String comment) {
println(comment);
println("Idx\tValue");
long longs = mem.getCapacity() >>> 3;
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 b322a1e..4a760bc 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
@@ -25,8 +25,8 @@ import static org.testng.Assert.assertEquals;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -37,9 +37,9 @@ public class CopyMemoryTest {
public void heapWSource() {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
- WritableMemory srcMem = genMem(k1, false); //!empty
+ WritableMemoryImpl srcMem = genMem(k1, false); //!empty
//println(srcMem.toHexString("src: ", 0, k1 << 3));
- WritableMemory dstMem = genMem(k2, true);
+ WritableMemoryImpl dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
//println(dstMem.toHexString("dst: ", 0, k2 << 3));
check(dstMem, k1, k1, 1);
@@ -49,8 +49,8 @@ public class CopyMemoryTest {
public void heapROSource() {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
- Memory srcMem = genMem(k1, false); //!empty
- WritableMemory dstMem = genMem(k2, true);
+ MemoryImpl srcMem = genMem(k1, false); //!empty
+ WritableMemoryImpl dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
@@ -60,8 +60,8 @@ public class CopyMemoryTest {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
try (WritableHandle wrh = genWRH(k1, false)) {
- WritableMemory srcMem = wrh.get();
- WritableMemory dstMem = genMem(k2, true);
+ WritableMemoryImpl srcMem = wrh.get();
+ WritableMemoryImpl dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
@@ -72,8 +72,8 @@ public class CopyMemoryTest {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
try (WritableHandle wrh = genWRH(k1, false)) {
- Memory srcMem = wrh.get();
- WritableMemory dstMem = genMem(k2, true);
+ MemoryImpl srcMem = wrh.get();
+ WritableMemoryImpl dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
@@ -83,10 +83,10 @@ public class CopyMemoryTest {
public void heapWSrcRegion() {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data
- WritableMemory baseMem = genMem(k1, false); //!empty
+ WritableMemoryImpl baseMem = genMem(k1, false); //!empty
//gen src region of k1/2 longs, off= k1/2
- WritableMemory srcReg = baseMem.writableRegion((k1/2) << 3, (k1/2) << 3);
- WritableMemory dstMem = genMem(2 * k1, true); //empty
+ WritableMemoryImpl srcReg = baseMem.writableRegion((k1/2) << 3, (k1/2) << 3);
+ WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
//println(dstMem.toHexString("dstMem: ", k1 << 3, (k1/2) << 3));
check(dstMem, k1, k1/2, (k1/2) + 1);
@@ -96,10 +96,10 @@ public class CopyMemoryTest {
public void heapROSrcRegion() {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data
- WritableMemory baseMem = genMem(k1, false); //!empty
+ WritableMemoryImpl baseMem = genMem(k1, false); //!empty
//gen src region of k1/2 longs, off= k1/2
- Memory srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
- WritableMemory dstMem = genMem(2 * k1, true); //empty
+ MemoryImpl srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
+ WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
check(dstMem, k1, k1/2, (k1/2) + 1);
}
@@ -109,10 +109,10 @@ public class CopyMemoryTest {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data, direct
try (WritableHandle wrh = genWRH(k1, false)) {
- Memory baseMem = wrh.get();
+ MemoryImpl baseMem = wrh.get();
//gen src region of k1/2 longs, off= k1/2
- Memory srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
- WritableMemory dstMem = genMem(2 * k1, true); //empty
+ MemoryImpl srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
+ WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
check(dstMem, k1, k1/2, (k1/2) + 1);
}
@@ -123,8 +123,8 @@ public class CopyMemoryTest {
byte[] bytes = new byte[((UNSAFE_COPY_THRESHOLD_BYTES * 5) / 2) + 1];
ThreadLocalRandom.current().nextBytes(bytes);
byte[] referenceBytes = bytes.clone();
- Memory referenceMem = Memory.wrap(referenceBytes);
- WritableMemory mem = WritableMemory.writableWrap(bytes);
+ MemoryImpl referenceMem = MemoryImpl.wrap(referenceBytes);
+ WritableMemoryImpl mem = WritableMemoryImpl.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,
@@ -136,15 +136,15 @@ public class CopyMemoryTest {
byte[] bytes = new byte[((UNSAFE_COPY_THRESHOLD_BYTES * 5) / 2) + 1];
ThreadLocalRandom.current().nextBytes(bytes);
byte[] referenceBytes = bytes.clone();
- Memory referenceMem = Memory.wrap(referenceBytes);
- WritableMemory mem = WritableMemory.writableWrap(bytes);
+ MemoryImpl referenceMem = MemoryImpl.wrap(referenceBytes);
+ WritableMemoryImpl mem = WritableMemoryImpl.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,
copyLen));
}
- private static void check(Memory mem, int offsetLongs, int lengthLongs, int startValue) {
+ private static void check(MemoryImpl mem, int offsetLongs, int lengthLongs, int startValue) {
int offBytes = offsetLongs << 3;
for (long i = 0; i < lengthLongs; i++) {
assertEquals(mem.getLong(offBytes + (i << 3)), i + startValue);
@@ -152,8 +152,8 @@ public class CopyMemoryTest {
}
private static WritableHandle genWRH(int longs, boolean empty) {
- WritableHandle wrh = WritableMemory.allocateDirect(longs << 3);
- WritableMemory mem = wrh.get();
+ WritableHandle wrh = WritableMemoryImpl.allocateDirect(longs << 3);
+ WritableMemoryImpl mem = wrh.get();
if (empty) {
mem.clear();
} else {
@@ -163,8 +163,8 @@ public class CopyMemoryTest {
}
- private static WritableMemory genMem(int longs, boolean empty) {
- WritableMemory mem = WritableMemory.allocate(longs << 3);
+ private static WritableMemoryImpl genMem(int longs, boolean empty) {
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(longs << 3);
if (!empty) {
for (int i = 0; i < longs; i++) { mem.putLong(i << 3, i + 1); }
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
index cbff8d5..c0438a7 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
@@ -25,7 +25,7 @@ import java.util.IdentityHashMap;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -43,7 +43,7 @@ public class ExampleMemoryRequestServerTest {
public void checkExampleMemoryRequestServer1() {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- WritableMemory wMem = svr.request(bytes);
+ WritableMemoryImpl wMem = svr.request(bytes);
MemoryClient client = new MemoryClient(wMem);
client.process();
svr.cleanup();
@@ -60,8 +60,8 @@ public class ExampleMemoryRequestServerTest {
public void checkExampleMemoryRequestServer2() {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- try (WritableHandle handle = WritableMemory.allocateDirect(bytes, svr)) {
- WritableMemory wMem = handle.get();
+ try (WritableHandle handle = WritableMemoryImpl.allocateDirect(bytes, svr)) {
+ WritableMemoryImpl wMem = handle.get();
MemoryClient client = new MemoryClient(wMem);
client.process();
svr.cleanup();
@@ -72,7 +72,7 @@ public class ExampleMemoryRequestServerTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkZeroCapacity() {
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- WritableMemory.allocateDirect(0, svr);
+ WritableMemoryImpl.allocateDirect(0, svr);
}
/**
@@ -83,10 +83,10 @@ public class ExampleMemoryRequestServerTest {
* <p>In reality, these memory requests should be quite rare.</p>
*/
static class MemoryClient {
- WritableMemory smallMem;
+ WritableMemoryImpl smallMem;
MemoryRequestServer svr;
- MemoryClient(WritableMemory wmem) {
+ MemoryClient(WritableMemoryImpl wmem) {
smallMem = wmem;
svr = wmem.getMemoryRequestServer();
}
@@ -96,7 +96,7 @@ public class ExampleMemoryRequestServerTest {
smallMem.fill((byte) 1); //fill it, but not big enough
println(smallMem.toHexString("Small", 0, (int)cap1));
- WritableMemory bigMem = svr.request(2 * cap1); //get bigger mem
+ WritableMemoryImpl bigMem = svr.request(2 * cap1); //get bigger mem
long cap2 = bigMem.getCapacity();
smallMem.copyTo(0, bigMem, 0, cap1); //copy data from small to big
svr.requestClose(smallMem, bigMem); //done with smallMem, release it
@@ -104,7 +104,7 @@ public class ExampleMemoryRequestServerTest {
bigMem.fill(cap1, cap1, (byte) 2); //fill the rest of bigMem, still not big enough
println(bigMem.toHexString("Big", 0, (int)cap2));
- WritableMemory giantMem = svr.request(2 * cap2); //get giant mem
+ WritableMemoryImpl giantMem = svr.request(2 * cap2); //get giant mem
long cap3 = giantMem.getCapacity();
bigMem.copyTo(0, giantMem, 0, cap2); //copy data from small to big
svr.requestClose(bigMem, giantMem); //done with bigMem, release it
@@ -120,13 +120,13 @@ public class ExampleMemoryRequestServerTest {
* possibly manage the continuous requests for larger memory.
*/
public static class ExampleMemoryRequestServer implements MemoryRequestServer {
- IdentityHashMap<WritableMemory, WritableHandle> map = new IdentityHashMap<>();
+ IdentityHashMap<WritableMemoryImpl, WritableHandle> map = new IdentityHashMap<>();
@SuppressWarnings("resource")
@Override
- public WritableMemory request(long capacityBytes) {
- WritableHandle handle = WritableMemory.allocateDirect(capacityBytes, this);
- WritableMemory wmem = handle.get();
+ public WritableMemoryImpl request(long capacityBytes) {
+ WritableHandle handle = WritableMemoryImpl.allocateDirect(capacityBytes, this);
+ WritableMemoryImpl wmem = handle.get();
map.put(wmem, handle); //We track the newly allocated memory and its handle.
return wmem;
}
@@ -134,7 +134,7 @@ public class ExampleMemoryRequestServerTest {
@SuppressWarnings("resource")
@Override
//here we actually release it, in reality it might be a lot more complex.
- public void requestClose(WritableMemory memToRelease, WritableMemory newMemory) {
+ public void requestClose(WritableMemoryImpl memToRelease, WritableMemoryImpl newMemory) {
if (memToRelease != null) {
WritableHandle handle = map.get(memToRelease);
if (handle != null && handle.get() == memToRelease) {
diff --git a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
index 2b6b36a..1653bc6 100644
--- a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
@@ -20,7 +20,7 @@
package org.apache.datasketches.memory.test;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Ignore;
@@ -31,11 +31,11 @@ import org.testng.annotations.Test;
public class IgnoredArrayOverflowTest {
private WritableHandle h;
- private WritableMemory memory;
+ private WritableMemoryImpl memory;
@BeforeClass
public void allocate() {
- h = WritableMemory.allocateDirect(Integer.MAX_VALUE + 100L);
+ h = WritableMemoryImpl.allocateDirect(Integer.MAX_VALUE + 100L);
memory = h.get();
}
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 58bc367..c25ea06 100644
--- a/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
@@ -34,7 +34,7 @@ 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.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.apache.datasketches.memory.WritableMapHandle;
import org.testng.annotations.Test;
@@ -50,14 +50,14 @@ public class LeafImplTest {
public void checkDirectLeafs() {
long off = 0;
long cap = 128;
- try (WritableDirectHandle wdh = WritableMemory.allocateDirect(cap)) {
- WritableMemory memLE = wdh.get();
+ try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(cap)) {
+ WritableMemoryImpl memLE = wdh.get();
memLE.putShort(0, (short) 1);
checkDirectImpl(memLE, off, cap);
}
}
- private static void checkDirectImpl(WritableMemory mem, long off, long cap) {
+ private static void checkDirectImpl(WritableMemoryImpl mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -86,7 +86,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() == null);
assertTrue(buf.isValid() == true);
- WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -134,15 +134,15 @@ public class LeafImplTest {
assertTrue(file.isFile());
file.deleteOnExit(); //comment out if you want to examine the file.
- try (WritableMapHandle wmh = WritableMemory.writableMap(file, off, cap, Util.nativeByteOrder)) {
- WritableMemory mem = wmh.get();
+ try (WritableMapHandle wmh = WritableMemoryImpl.writableMap(file, off, cap, Util.nativeByteOrder)) {
+ WritableMemoryImpl mem = wmh.get();
mem.putShort(0, (short) 1);
assertEquals(mem.getByte(0), (byte) 1);
checkMapImpl(mem, off, cap);
}
}
- private static void checkMapImpl(WritableMemory mem, long off, long cap) {
+ private static void checkMapImpl(WritableMemoryImpl mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -171,7 +171,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() == null);
assertTrue(buf.isValid() == true);
- WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -209,17 +209,17 @@ public class LeafImplTest {
ByteBuffer bb = ByteBuffer.allocate((int)cap);
bb.order(ByteOrder.nativeOrder());
bb.putShort(0, (short) 1);
- WritableMemory mem = WritableMemory.writableWrap(bb);
+ WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(bb);
checkByteBufferImpl(mem, off, cap, false);
ByteBuffer dbb = ByteBuffer.allocateDirect((int)cap);
dbb.order(ByteOrder.nativeOrder());
dbb.putShort(0, (short) 1);
- mem = WritableMemory.writableWrap(dbb);
+ mem = WritableMemoryImpl.writableWrap(dbb);
checkByteBufferImpl(mem, off, cap, true);
}
- private static void checkByteBufferImpl(WritableMemory mem, long off, long cap, boolean direct) {
+ private static void checkByteBufferImpl(WritableMemoryImpl mem, long off, long cap, boolean direct) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -260,7 +260,7 @@ public class LeafImplTest {
}
assertTrue(buf.isValid() == true);
- WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -307,12 +307,12 @@ public class LeafImplTest {
public void checkHeapLeafs() {
long off = 0;
long cap = 128;
- WritableMemory mem = WritableMemory.allocate((int)cap);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate((int)cap);
mem.putShort(0, (short) 1);
checkHeapImpl(mem, off, cap);
}
- private static void checkHeapImpl(WritableMemory mem, long off, long cap) {
+ private static void checkHeapImpl(WritableMemoryImpl mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -341,7 +341,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() != null);
assertTrue(buf.isValid() == true);
- WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
index ade4ec4..4137c71 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
@@ -20,13 +20,13 @@
package org.apache.datasketches.memory.test;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class MemoryBoundaryCheckTest {
- private final WritableBuffer writableBuffer = WritableMemory.allocate(8).asWritableBuffer();
+ private final WritableBuffer writableBuffer = WritableMemoryImpl.allocate(8).asWritableBuffer();
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
index b712060..ece9cdf 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
@@ -26,17 +26,17 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class MemoryReadWriteSafetyTest {
- // Test various operations with read-only Memory
+ // Test various operations with read-only MemoryImpl
- final WritableMemory mem = (WritableMemory) Memory.wrap(new byte[8]);
+ final WritableMemoryImpl mem = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8]);
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -122,73 +122,73 @@ public class MemoryReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryRegion() {
- WritableMemory mem1 = (WritableMemory) WritableMemory.allocate(8).region(0, 8);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) WritableMemoryImpl.allocate(8).region(0, 8);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithBO() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], ByteOrder.nativeOrder());
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8], ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithOffsetsAndBO() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testBooleanArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new boolean[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new boolean[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testShortArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new short[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new short[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testCharArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new char[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new char[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testIntArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new int[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new int[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testLongArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new long[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new long[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testFloatArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new float[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new float[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testDoubleArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new double[8]);
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new double[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteBufferWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(ByteBuffer.allocate(8));
+ WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(ByteBuffer.allocate(8));
mem1.putInt(0, 1);
}
@@ -200,8 +200,8 @@ public class MemoryReadWriteSafetyTest {
try (RandomAccessFile raf = new RandomAccessFile(tempFile, "rw")) {
raf.setLength(8);
//System.out.println(UtilTest.getFileAttributes(tempFile));
- try (MapHandle h = Memory.map(tempFile)) {
- ((WritableMemory) h.get()).putInt(0, 1);
+ try (MapHandle h = MemoryImpl.map(tempFile)) {
+ ((WritableMemoryImpl) h.get()).putInt(0, 1);
}
}
}
@@ -212,8 +212,8 @@ public class MemoryReadWriteSafetyTest {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle h = Memory.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
- ((WritableMemory) h.get()).putInt(0, 1);
+ try (MapHandle h = MemoryImpl.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
+ ((WritableMemoryImpl) h.get()).putInt(0, 1);
}
}
@@ -223,7 +223,7 @@ public class MemoryReadWriteSafetyTest {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle unused = Memory.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
+ try (MapHandle unused = MemoryImpl.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
}
}
}
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 bbe3e24..e882209 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
@@ -38,9 +38,9 @@ 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.MemoryImpl;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -58,8 +58,8 @@ public class MemoryTest {
@Test
public void checkDirectRoundTrip() {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
- WritableMemory mem = wh.get();
+ try (WritableHandle wh = WritableMemoryImpl.allocateDirect(n * 8)) {
+ WritableMemoryImpl mem = wh.get();
for (int i = 0; i < n; i++) {
mem.putLong(i * 8, i);
}
@@ -73,7 +73,7 @@ public class MemoryTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableMemory wmem = WritableMemory.allocate(n * 8);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(n * 8);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -87,7 +87,7 @@ public class MemoryTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableMemory wmem = WritableMemory.writableWrap(arr);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -95,20 +95,20 @@ public class MemoryTest {
long v = wmem.getLong(i * 8);
assertEquals(v, i);
}
- Memory mem = Memory.wrap(arr, ByteOrder.nativeOrder());
+ MemoryImpl mem = MemoryImpl.wrap(arr, ByteOrder.nativeOrder());
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
}
// check 0 length array wraps
- 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]);
+ MemoryImpl memZeroLengthArrayBoolean = WritableMemoryImpl.writableWrap(new boolean[0]);
+ MemoryImpl memZeroLengthArrayByte = WritableMemoryImpl.writableWrap(new byte[0]);
+ MemoryImpl memZeroLengthArrayChar = WritableMemoryImpl.writableWrap(new char[0]);
+ MemoryImpl memZeroLengthArrayShort = WritableMemoryImpl.writableWrap(new short[0]);
+ MemoryImpl memZeroLengthArrayInt = WritableMemoryImpl.writableWrap(new int[0]);
+ MemoryImpl memZeroLengthArrayLong = WritableMemoryImpl.writableWrap(new long[0]);
+ MemoryImpl memZeroLengthArrayFloat = WritableMemoryImpl.writableWrap(new float[0]);
+ MemoryImpl memZeroLengthArrayDouble = WritableMemoryImpl.writableWrap(new double[0]);
assertEquals(memZeroLengthArrayBoolean.getCapacity(), 0);
assertEquals(memZeroLengthArrayByte.getCapacity(), 0);
assertEquals(memZeroLengthArrayChar.getCapacity(), 0);
@@ -119,28 +119,28 @@ public class MemoryTest {
assertEquals(memZeroLengthArrayDouble.getCapacity(), 0);
// check 0 length array wraps
- List<Memory> memoryToCheck = Lists.newArrayList();
- memoryToCheck.add(WritableMemory.allocate(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]));
- memoryToCheck.add(Memory.wrap(new char[0]));
- memoryToCheck.add(Memory.wrap(new short[0]));
- memoryToCheck.add(Memory.wrap(new int[0]));
- memoryToCheck.add(Memory.wrap(new long[0]));
- memoryToCheck.add(Memory.wrap(new float[0]));
- memoryToCheck.add(Memory.wrap(new double[0]));
- //Check the Memory lengths
- for (Memory memory : memoryToCheck) {
+ List<MemoryImpl> memoryToCheck = Lists.newArrayList();
+ memoryToCheck.add(WritableMemoryImpl.allocate(0));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(ByteBuffer.allocate(0)));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new boolean[0]));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new byte[0]));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new char[0]));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new short[0]));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new int[0]));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new long[0]));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new float[0]));
+ memoryToCheck.add(WritableMemoryImpl.writableWrap(new double[0]));
+ memoryToCheck.add(MemoryImpl.wrap(ByteBuffer.allocate(0)));
+ memoryToCheck.add(MemoryImpl.wrap(new boolean[0]));
+ memoryToCheck.add(MemoryImpl.wrap(new byte[0]));
+ memoryToCheck.add(MemoryImpl.wrap(new char[0]));
+ memoryToCheck.add(MemoryImpl.wrap(new short[0]));
+ memoryToCheck.add(MemoryImpl.wrap(new int[0]));
+ memoryToCheck.add(MemoryImpl.wrap(new long[0]));
+ memoryToCheck.add(MemoryImpl.wrap(new float[0]));
+ memoryToCheck.add(MemoryImpl.wrap(new double[0]));
+ //Check the MemoryImpl lengths
+ for (MemoryImpl memory : memoryToCheck) {
assertEquals(memory.getCapacity(), 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.writableWrap(bb);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -163,13 +163,13 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Memory mem1 = Memory.wrap(arr);
+ MemoryImpl mem1 = MemoryImpl.wrap(arr);
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = mem1.getLong(i * 8);
assertEquals(v, i);
}
//convert to RO
- Memory mem = wmem;
+ MemoryImpl mem = wmem;
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, 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.writableWrap(bb);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -193,13 +193,13 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Memory mem1 = Memory.wrap(bb);
+ MemoryImpl mem1 = MemoryImpl.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = mem1.getLong(i * 8);
assertEquals(v, i);
}
//convert to RO
- Memory mem = wmem;
+ MemoryImpl mem = wmem;
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
@@ -211,7 +211,7 @@ public class MemoryTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- Memory mem = Memory.wrap(bb);
+ MemoryImpl mem = MemoryImpl.wrap(bb);
assertFalse(mem.getTypeByteOrder() == Util.nativeByteOrder);
assertEquals(mem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -224,7 +224,7 @@ public class MemoryTest {
bb.position(64);
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- Memory mem = Memory.wrap(slice);
+ MemoryImpl mem = MemoryImpl.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(mem.getByte(i), 64 + i);
}
@@ -237,7 +237,7 @@ public class MemoryTest {
int n = 1024; //longs
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemory wmem = WritableMemory.allocate(n * 8);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(n * 8);
wmem.putLongArray(0, arr, 0, n);
long[] arr2 = new long[n];
wmem.getLongArray(0, arr2, 0, n);
@@ -252,8 +252,8 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Memory mem = Memory.wrap(arr);
- Memory reg = mem.region(n2 * 8, n2 * 8); //top half
+ MemoryImpl mem = MemoryImpl.wrap(arr);
+ MemoryImpl reg = mem.region(n2 * 8, n2 * 8); //top half
for (int i = 0; i < n2; i++) {
long v = reg.getLong(i * 8);
long e = i + n2;
@@ -267,8 +267,8 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Memory mem = Memory.wrap(arr);
- Memory reg = mem.region(n2 * 8, n2 * 8, Util.nonNativeByteOrder); //top half
+ MemoryImpl mem = MemoryImpl.wrap(arr);
+ MemoryImpl reg = mem.region(n2 * 8, n2 * 8, Util.nonNativeByteOrder); //top half
for (int i = 0; i < n2; i++) {
long v = Long.reverseBytes(reg.getLong(i * 8));
long e = i + n2;
@@ -282,13 +282,13 @@ 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.writableWrap(arr);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
}
//println("");
- WritableMemory reg = wmem.writableRegion(n2 * 8, n2 * 8);
+ WritableMemoryImpl reg = wmem.writableRegion(n2 * 8, n2 * 8);
for (int i = 0; i < n2; i++) { reg.putLong(i * 8, i); }
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i % 8);
@@ -302,13 +302,13 @@ 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.writableWrap(arr);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
}
//println("");
- WritableMemory reg = wmem.writableRegion(n2 * 8, n2 * 8, Util.nonNativeByteOrder);
+ WritableMemoryImpl reg = wmem.writableRegion(n2 * 8, n2 * 8, Util.nonNativeByteOrder);
for (int i = 0; i < n2; i++) { reg.putLong(i * 8, i); }
for (int i = 0; i < n; i++) {
long v = wmem.getLong(i * 8);
@@ -325,10 +325,10 @@ public class MemoryTest {
public void checkParentUseAfterFree() {
int bytes = 64 * 8;
@SuppressWarnings("resource") //intentionally not using try-with-resouces here
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
- WritableMemory wmem = wh.get();
+ WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
+ WritableMemoryImpl wmem = wh.get();
wh.close();
- //with -ea assert: Memory not valid.
+ //with -ea assert: MemoryImpl not valid.
//with -da sometimes segfaults, sometimes passes!
wmem.getLong(0);
}
@@ -337,36 +337,36 @@ public class MemoryTest {
public void checkRegionUseAfterFree() {
int bytes = 64;
@SuppressWarnings("resource") //intentionally not using try-with-resouces here
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
- Memory wmem = wh.get();
- Memory region = wmem.region(0L, bytes);
+ WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
+ MemoryImpl wmem = wh.get();
+ MemoryImpl region = wmem.region(0L, bytes);
wh.close();
- //with -ea assert: Memory not valid.
+ //with -ea assert: MemoryImpl not valid.
//with -da sometimes segfaults, sometimes passes!
region.getByte(0);
}
@Test
public void checkUnsafeByteBufferView() {
- try (WritableDirectHandle wmemDirectHandle = WritableMemory.allocateDirect(2)) {
- WritableMemory wmemDirect = wmemDirectHandle.get();
+ try (WritableDirectHandle wmemDirectHandle = WritableMemoryImpl.allocateDirect(2)) {
+ WritableMemoryImpl wmemDirect = wmemDirectHandle.get();
wmemDirect.putByte(0, (byte) 1);
wmemDirect.putByte(1, (byte) 2);
checkUnsafeByteBufferView(wmemDirect);
}
- checkUnsafeByteBufferView(Memory.wrap(new byte[] {1, 2}));
+ checkUnsafeByteBufferView(MemoryImpl.wrap(new byte[] {1, 2}));
try {
@SuppressWarnings("unused")
- ByteBuffer unused = Memory.wrap(new int[]{1}).unsafeByteBufferView(0, 1);
+ ByteBuffer unused = MemoryImpl.wrap(new int[]{1}).unsafeByteBufferView(0, 1);
Assert.fail();
} catch (UnsupportedOperationException ingore) {
// expected
}
}
- private static void checkUnsafeByteBufferView(final Memory mem) {
+ private static void checkUnsafeByteBufferView(final MemoryImpl mem) {
ByteBuffer emptyByteBuffer = mem.unsafeByteBufferView(0, 0);
Assert.assertEquals(emptyByteBuffer.capacity(), 0);
ByteBuffer bb = mem.unsafeByteBufferView(1, 1);
@@ -387,9 +387,9 @@ public class MemoryTest {
@Test
public void checkMonitorDirectStats() {
int bytes = 1024;
- WritableHandle wh1 = WritableMemory.allocateDirect(bytes);
- WritableHandle wh2 = WritableMemory.allocateDirect(bytes);
- WritableMemory wMem2 = wh2.get();
+ WritableHandle wh1 = WritableMemoryImpl.allocateDirect(bytes);
+ WritableHandle wh2 = WritableMemoryImpl.allocateDirect(bytes);
+ WritableMemoryImpl wMem2 = wh2.get();
assertEquals(wMem2.getCurrentDirectMemoryAllocations(), 2L);
assertEquals(wMem2.getCurrentDirectMemoryAllocated(), 2 * bytes);
@@ -410,9 +410,9 @@ public class MemoryTest {
File file = getResourceFile("GettysburgAddress.txt");
long bytes = file.length();
- MapHandle mmh1 = Memory.map(file);
- MapHandle mmh2 = Memory.map(file);
- Memory wmem2 = mmh2.get();
+ MapHandle mmh1 = MemoryImpl.map(file);
+ MapHandle mmh2 = MemoryImpl.map(file);
+ MemoryImpl wmem2 = mmh2.get();
assertEquals(wmem2.getCurrentDirectMemoryMapAllocations(), 2L);
assertEquals(wmem2.getCurrentDirectMemoryMapAllocated(), 2 * bytes);
@@ -430,10 +430,10 @@ public class MemoryTest {
@Test
public void checkNullMemReqSvr() {
- WritableMemory wmem = WritableMemory.writableWrap(new byte[16]);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[16]);
assertNull(wmem.getMemoryRequestServer());
- try (WritableDirectHandle wdh = WritableMemory.allocateDirect(16)) {
- WritableMemory wmem2 = wdh.get();
+ try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(16)) {
+ WritableMemoryImpl wmem2 = wdh.get();
assertNotNull(wmem2.getMemoryRequestServer());
}
println(wmem.toHexString("Test", 0, 16));
@@ -441,7 +441,7 @@ public class MemoryTest {
@Test
public void checkHashCode() {
- WritableMemory wmem = WritableMemory.allocate(32 + 7);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(32 + 7);
int hc = wmem.hashCode();
assertEquals(hc, -1895166923);
}
@@ -449,7 +449,7 @@ public class MemoryTest {
@Test
public void checkSelfEqualsToAndCompareTo() {
int len = 64;
- WritableMemory wmem = WritableMemory.allocate(len);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(len);
for (int i = 0; i < len; i++) { wmem.putByte(i, (byte) i); }
assertTrue(wmem.equalTo(0, wmem, 0, len));
assertFalse(wmem.equalTo(0, wmem, len/2, len/2));
@@ -461,7 +461,7 @@ public class MemoryTest {
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as BE
- Memory mem = Memory.wrap(bb, ByteOrder.LITTLE_ENDIAN);
+ MemoryImpl mem = MemoryImpl.wrap(bb, ByteOrder.LITTLE_ENDIAN);
assertEquals(mem.getChar(0), 256);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
index 01f06e0..08e8bf8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
@@ -28,8 +28,8 @@ import java.nio.channels.WritableByteChannel;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -59,8 +59,8 @@ public class MemoryWriteToTest {
@Test
public void testOffHeap() throws IOException {
try (WritableHandle handle =
- WritableMemory.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
- WritableMemory mem = handle.get();
+ WritableMemoryImpl.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
+ WritableMemoryImpl mem = handle.get();
testWriteTo(mem.region(0, 0));
testOffHeap(mem, 7);
testOffHeap(mem, 1023);
@@ -70,28 +70,28 @@ public class MemoryWriteToTest {
}
}
- private static void testOffHeap(WritableMemory mem, int size) throws IOException {
+ private static void testOffHeap(WritableMemoryImpl mem, int size) throws IOException {
createRandomBytesMemory(size).copyTo(0, mem, 0, size);
testWriteTo(mem.region(0, size));
}
- private static Memory createRandomBytesMemory(int size) {
+ private static MemoryImpl createRandomBytesMemory(int size) {
byte[] bytes = new byte[size];
ThreadLocalRandom.current().nextBytes(bytes);
- return Memory.wrap(bytes);
+ return MemoryImpl.wrap(bytes);
}
- private static Memory createRandomIntsMemory(int size) {
+ private static MemoryImpl createRandomIntsMemory(int size) {
int[] ints = ThreadLocalRandom.current().ints(size).toArray();
- return Memory.wrap(ints);
+ return MemoryImpl.wrap(ints);
}
- private static void testWriteTo(Memory mem) throws IOException {
+ private static void testWriteTo(MemoryImpl mem) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (WritableByteChannel out = Channels.newChannel(baos)) {
mem.writeTo(0, mem.getCapacity(), out);
}
byte[] result = baos.toByteArray();
- Assert.assertTrue(mem.equals(Memory.wrap(result)));
+ Assert.assertTrue(mem.equals(MemoryImpl.wrap(result)));
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/NioBitsTest.java b/src/test/java/org/apache/datasketches/memory/test/NioBitsTest.java
index 31c0d3a..8f0d125 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NioBitsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NioBitsTest.java
@@ -31,7 +31,7 @@ public class NioBitsTest {
@Test
public void checkVMParams() {
- println("Max Memory: " + ReflectUtil.getMaxDirectByteBufferMemory());
+ println("Max MemoryImpl: " + ReflectUtil.getMaxDirectByteBufferMemory());
println("Page Aligned: " + ReflectUtil.isPageAligned());
println("Page Size: " + ReflectUtil.pageSize());
}
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 199539f..aa22700 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
@@ -25,7 +25,7 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -41,7 +41,7 @@ public class NonNativeWritableBufferImplTest {
int m = Character.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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 a71a610..f9e60f6 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -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.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ private final WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.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.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putShortArray(0, shortArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -205,15 +205,15 @@ public class NonNativeWritableMemoryImplTest {
//check Region
@Test
public void checkRegion() {
- WritableMemory wreg = wmem.writableRegion(0, wmem.getCapacity());
+ WritableMemoryImpl wreg = wmem.writableRegion(0, wmem.getCapacity());
assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkRegionZeros() {
byte[] bArr1 = new byte[0];
- WritableMemory wmem1 = WritableMemory.writableWrap(bArr1, ByteOrder.BIG_ENDIAN);
- Memory reg = wmem1.region(0, wmem1.getCapacity());
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(bArr1, ByteOrder.BIG_ENDIAN);
+ MemoryImpl reg = wmem1.region(0, wmem1.getCapacity());
assertEquals(reg.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
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 f1c8794..6436164 100644
--- a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
@@ -27,9 +27,9 @@ import java.io.IOException;
import java.nio.ByteBuffer;
import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.apache.datasketches.memory.WritableMapHandle;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.testng.annotations.Test;
@@ -46,14 +46,14 @@ public class SpecificLeafTest {
ByteBuffer bb = ByteBuffer.allocate(bytes);
bb.order(Util.nativeByteOrder);
- Memory mem = Memory.wrap(bb).region(0, bytes, Util.nativeByteOrder);
+ MemoryImpl mem = MemoryImpl.wrap(bb).region(0, bytes, Util.nativeByteOrder);
assertTrue(ReflectUtil.isBBType(mem));
assertTrue(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
bb.order(Util.nonNativeByteOrder);
- Memory mem2 = Memory.wrap(bb).region(0, bytes, Util.nonNativeByteOrder);
+ MemoryImpl mem2 = MemoryImpl.wrap(bb).region(0, bytes, Util.nonNativeByteOrder);
Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
Buffer buf3 = buf2.duplicate();
@@ -67,18 +67,18 @@ public class SpecificLeafTest {
@Test
public void checkDirectLeafs() {
int bytes = 128;
- try (WritableDirectHandle h = WritableMemory.allocateDirect(bytes)) {
- WritableMemory wmem = h.get(); //native mem
+ try (WritableDirectHandle h = WritableMemoryImpl.allocateDirect(bytes)) {
+ WritableMemoryImpl wmem = h.get(); //native mem
assertTrue(ReflectUtil.isDirectType(wmem));
assertFalse(wmem.isReadOnly());
checkCrossLeafTypeIds(wmem);
- WritableMemory nnwmem = wmem.writableRegion(0, bytes, Util.nonNativeByteOrder);
+ WritableMemoryImpl nnwmem = wmem.writableRegion(0, bytes, Util.nonNativeByteOrder);
- Memory mem = wmem.region(0, bytes, Util.nativeByteOrder);
+ MemoryImpl mem = wmem.region(0, bytes, Util.nativeByteOrder);
Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
- Memory mem2 = nnwmem.region(0, bytes, Util.nonNativeByteOrder);
+ MemoryImpl mem2 = nnwmem.region(0, bytes, Util.nonNativeByteOrder);
Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
Buffer buf3 = buf2.duplicate();
@@ -107,18 +107,18 @@ public class SpecificLeafTest {
final long bytes = 128;
- try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nativeByteOrder)) {
- WritableMemory mem = h.get(); //native mem
+ try (WritableMapHandle h = WritableMemoryImpl.writableMap(file, 0L, bytes, Util.nativeByteOrder)) {
+ WritableMemoryImpl mem = h.get(); //native mem
assertTrue(ReflectUtil.isMapType(mem));
assertFalse(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
- Memory nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
+ MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
- Memory reg = mem.region(0, bytes, Util.nativeByteOrder);
+ MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
Buffer buf4 = buf.duplicate();
- Memory reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
+ MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
Buffer buf3 = buf2.duplicate();
@@ -134,17 +134,17 @@ public class SpecificLeafTest {
@Test
public void checkHeapLeafs() {
int bytes = 128;
- Memory mem = Memory.wrap(new byte[bytes]);
+ MemoryImpl mem = MemoryImpl.wrap(new byte[bytes]);
assertTrue(ReflectUtil.isHeapType(mem));
assertTrue(ReflectUtil.isReadOnlyType(mem));
checkCrossLeafTypeIds(mem);
- Memory nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
+ MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
- Memory reg = mem.region(0, bytes, Util.nativeByteOrder);
+ MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
Buffer buf4 = buf.duplicate();
- Memory reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
+ MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
Buffer buf3 = buf2.duplicate();
@@ -156,8 +156,8 @@ public class SpecificLeafTest {
assertTrue(ReflectUtil.isDuplicateType(buf4));
}
- private static void checkCrossLeafTypeIds(Memory mem) {
- Memory reg1 = mem.region(0, mem.getCapacity());
+ private static void checkCrossLeafTypeIds(MemoryImpl mem) {
+ MemoryImpl reg1 = mem.region(0, mem.getCapacity());
assertTrue(ReflectUtil.isRegionType(reg1));
Buffer buf1 = reg1.asBuffer();
@@ -169,7 +169,7 @@ public class SpecificLeafTest {
assertTrue(ReflectUtil.isBufferType(buf2));
assertTrue(ReflectUtil.isDuplicateType(buf2));
- Memory mem2 = buf1.asMemory();
+ MemoryImpl mem2 = buf1.asMemory();
assertTrue(ReflectUtil.isRegionType(mem2));
assertFalse(ReflectUtil.isBufferType(mem2));
assertFalse(ReflectUtil.isDuplicateType(mem2));
@@ -180,7 +180,7 @@ public class SpecificLeafTest {
assertTrue(ReflectUtil.isDuplicateType(buf3));
assertTrue(ReflectUtil.isNonNativeType(buf3));
- Memory mem3 = buf3.asMemory();
+ MemoryImpl mem3 = buf3.asMemory();
assertTrue(ReflectUtil.isRegionType(mem3));
assertFalse(ReflectUtil.isBufferType(mem3));
assertFalse(ReflectUtil.isDuplicateType(mem3));
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 2b8b92e..0a710c8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
@@ -28,9 +28,9 @@ import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.List;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Utf8CodingException;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.apache.datasketches.memory.internal.Util.RandomCodePoints;
import org.testng.annotations.Test;
@@ -59,15 +59,15 @@ public class Utf8Test {
@Test
public void testPutInvalidChars() { //The surrogates must be a pair, thus invalid alone
- WritableMemory mem = WritableMemory.allocate(10);
- WritableMemory emptyMem = WritableMemory.allocate(0);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(10);
+ WritableMemoryImpl emptyMem = WritableMemoryImpl.allocate(0);
for (int c = Character.MIN_SURROGATE; c <= Character.MAX_SURROGATE; c++) {
assertSurrogate(mem, (char) c);
assertSurrogate(emptyMem, (char) c);
}
}
- private static void assertSurrogate(WritableMemory mem, char c) {
+ private static void assertSurrogate(WritableMemoryImpl mem, char c) {
try {
mem.putCharsToUtf8(0, new String(new char[] {c}));
fail();
@@ -78,7 +78,7 @@ public class Utf8Test {
@Test
public void testPutInvaidSurrogatePairs() {
- WritableMemory mem = WritableMemory.allocate(4);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MAX_HIGH_SURROGATE);
@@ -91,7 +91,7 @@ public class Utf8Test {
@Test
public void testPutHighBMP() {
- WritableMemory mem = WritableMemory.allocate(2);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(2);
StringBuilder sb = new StringBuilder();
sb.append("\uE000");
try {
@@ -103,7 +103,7 @@ public class Utf8Test {
@Test
public void testPutExtendedAscii() {
- WritableMemory mem = WritableMemory.allocate(1);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(1);
StringBuilder sb = new StringBuilder();
sb.append("\u07FF");
try {
@@ -115,7 +115,7 @@ public class Utf8Test {
@Test
public void testPutOneAsciiToEmpty() {
- WritableMemory mem = WritableMemory.allocate(0);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(0);
StringBuilder sb = new StringBuilder();
sb.append("a");
try {
@@ -127,7 +127,7 @@ public class Utf8Test {
@Test
public void testPutValidSurrogatePair() {
- WritableMemory mem = WritableMemory.allocate(4);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MIN_LOW_SURROGATE);
@@ -218,7 +218,7 @@ public class Utf8Test {
rcp.fillCodePointArray(cpArr, 0, minPlane2CP);
String rcpStr = new String(cpArr, 0, numCP);
//println(rcpStr);
- WritableMemory wmem = WritableMemory.allocate(4 * numCP);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(4 * numCP);
int utf8Bytes = (int) wmem.putCharsToUtf8(0, rcpStr);
StringBuilder sb = new StringBuilder();
@@ -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.writableWrap(refByteArr);
+ WritableMemoryImpl refMem = WritableMemoryImpl.writableWrap(refByteArr);
int decodedChars = refMem.getCharsFromUtf8(0, addBytes, sb);
String finalStr = sb.toString();
int finalChars = finalStr.toCharArray().length;
@@ -318,7 +318,7 @@ public class Utf8Test {
byte[] refByteArr = refStr.getBytes(UTF_8);
int refBytes = refByteArr.length;
int offset = 100;
- WritableMemory tgtMem = WritableMemory.allocate(refBytes + offset);
+ WritableMemoryImpl tgtMem = WritableMemoryImpl.allocate(refBytes + offset);
long bytesEncoded = tgtMem.putCharsToUtf8(offset, refStr);
assertEquals(bytesEncoded, refBytes);
}
@@ -370,7 +370,7 @@ public class Utf8Test {
}
@Test
- public void testInvalidBufferSlice() { //these are pure Memory bounds violations
+ public void testInvalidBufferSlice() { //these are pure MemoryImpl bounds violations
byte[] bytes = "The quick brown fox jumps over the lazy dog".getBytes(UTF_8);
assertInvalidSlice(bytes, bytes.length - 3, 4);
assertInvalidSlice(bytes, bytes.length, 1);
@@ -389,14 +389,14 @@ public class Utf8Test {
private static void assertInvalid(byte[] bytes) {
int bytesLen = bytes.length;
try {
- Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
+ MemoryImpl.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
fail();
} catch (Utf8CodingException e) {
// Expected.
}
try {
CharBuffer cb = CharBuffer.allocate(bytesLen);
- Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
+ MemoryImpl.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
fail();
} catch (Utf8CodingException | IOException e) {
// Expected.
@@ -405,7 +405,7 @@ public class Utf8Test {
private static void assertInvalidSlice(byte[] bytes, int index, int size) {
try {
- Memory mem = Memory.wrap(bytes);
+ MemoryImpl mem = MemoryImpl.wrap(bytes);
mem.getCharsFromUtf8(index, size, new StringBuilder());
fail();
} catch (IllegalArgumentException e) { //Pure bounds violation
@@ -436,17 +436,17 @@ public class Utf8Test {
if (utf8LengthBytes == -1) {
utf8LengthBytes = refByteArr.length;
}
- Memory refMem = Memory.wrap(refByteArr);
+ MemoryImpl refMem = MemoryImpl.wrap(refByteArr);
byte[] refByteArr2 = new byte[refByteArr.length + 1];
System.arraycopy(refByteArr, 0, refByteArr2, 1, refByteArr.length);
- Memory refReg = Memory.wrap(refByteArr2).region(1, refByteArr.length);
+ MemoryImpl refReg = MemoryImpl.wrap(refByteArr2).region(1, refByteArr.length);
- WritableMemory dstMem = WritableMemory.allocate(refByteArr.length);
- WritableMemory dstMem2 =
- WritableMemory.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
+ WritableMemoryImpl dstMem = WritableMemoryImpl.allocate(refByteArr.length);
+ WritableMemoryImpl dstMem2 =
+ WritableMemoryImpl.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
- // Test with Memory objects, where base offset != 0
+ // Test with MemoryImpl objects, where base offset != 0
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refMem, dstMem);
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refMem, dstMem2);
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refReg, dstMem);
@@ -454,7 +454,7 @@ public class Utf8Test {
}
private static void assertRoundTrips(String refStr, int refSubCharLen, int offsetBytes,
- int utf8LengthBytes, byte[] refByteArr, Memory refMem, WritableMemory dstMem)
+ int utf8LengthBytes, byte[] refByteArr, MemoryImpl refMem, WritableMemoryImpl dstMem)
throws IOException {
StringBuilder sb = new StringBuilder();
@@ -476,7 +476,7 @@ public class Utf8Test {
assertEquals(0, dstMem.compareTo(0, refByteArr.length, refMem, 0, refByteArr.length));
// Test write overflow
- WritableMemory writeMem2 = WritableMemory.allocate(refByteArr.length - 1);
+ WritableMemoryImpl writeMem2 = WritableMemoryImpl.allocate(refByteArr.length - 1);
try {
writeMem2.putCharsToUtf8(0, refStr);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
index 83228bf..fbc2962 100644
--- a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
@@ -44,7 +44,7 @@ import java.nio.file.attribute.PosixFilePermissions;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -55,7 +55,7 @@ public class UtilTest {
@Test
public void checkBinarySearch() {
int k = 1024; //longs
- WritableMemory wMem = WritableMemory.allocate(k << 3); //1024 longs
+ WritableMemoryImpl wMem = WritableMemoryImpl.allocate(k << 3); //1024 longs
for (int i = 0; i < k; i++) { wMem.putLong(i << 3, i); }
long idx = Util.binarySearchLongs(wMem, 0, k - 1, k / 2);
long val = wMem.getLong(idx << 3);
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 99dfd13..7593be8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
@@ -28,12 +28,12 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -46,8 +46,8 @@ public class WritableBufferImplTest {
@Test
public void checkNativeCapacityAndClose() {
int memCapacity = 64;
- WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
- WritableMemory wmem = wmh.get();
+ WritableHandle wmh = WritableMemoryImpl.allocateDirect(memCapacity);
+ WritableMemoryImpl wmem = wmh.get();
WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), memCapacity);
@@ -64,13 +64,13 @@ public class WritableBufferImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -83,13 +83,13 @@ public class WritableBufferImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -101,13 +101,13 @@ public class WritableBufferImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -119,13 +119,13 @@ public class WritableBufferImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -137,13 +137,13 @@ public class WritableBufferImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -155,13 +155,13 @@ public class WritableBufferImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -173,13 +173,13 @@ public class WritableBufferImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -191,13 +191,13 @@ public class WritableBufferImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -207,8 +207,8 @@ public class WritableBufferImplTest {
@Test
public void checkNativeBaseBound() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory wmem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl wmem = wrh.get();
WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
@@ -219,8 +219,8 @@ public class WritableBufferImplTest {
@Test
public void checkNativeSrcArrayBound() {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory wmem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl wmem = wrh.get();
WritableBuffer wbuf = wmem.asWritableBuffer();
byte[] srcArray = { 1, -2, 3, -4 };
wbuf.putByteArray(srcArray, 0, 5); //wrong!
@@ -233,8 +233,8 @@ public class WritableBufferImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkRegionBounds() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory wmem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl wmem = wrh.get();
WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.writableRegion(1, 64, wbuf.getTypeByteOrder()); //wrong!
}
@@ -344,10 +344,10 @@ public class WritableBufferImplTest {
@Test
public void checkIsDirect() {
int memCapacity = 64;
- WritableBuffer mem = WritableMemory.allocate(memCapacity).asWritableBuffer();
+ WritableBuffer mem = WritableMemoryImpl.allocate(memCapacity).asWritableBuffer();
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem2 = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem2 = wrh.get();
WritableBuffer wbuf = mem2.asWritableBuffer();
assertTrue(wbuf.isDirect());
wrh.close();
@@ -358,7 +358,7 @@ public class WritableBufferImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
assertFalse(wbuf.isReadOnly());
Buffer buf = wbuf;
@@ -380,9 +380,9 @@ public class WritableBufferImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- Buffer buf1 = Memory.wrap(arr1).asBuffer();
- Buffer buf2 = Memory.wrap(arr2).asBuffer();
- Buffer buf3 = Memory.wrap(arr3).asBuffer();
+ Buffer buf1 = MemoryImpl.wrap(arr1).asBuffer();
+ Buffer buf2 = MemoryImpl.wrap(arr2).asBuffer();
+ Buffer buf3 = MemoryImpl.wrap(arr3).asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -403,17 +403,17 @@ public class WritableBufferImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemory.allocateDirect(4);
- WritableHandle h2 = WritableMemory.allocateDirect(4);
- WritableHandle h3 = WritableMemory.allocateDirect(5))
+ try (WritableHandle h1 = WritableMemoryImpl.allocateDirect(4);
+ WritableHandle h2 = WritableMemoryImpl.allocateDirect(4);
+ WritableHandle h3 = WritableMemoryImpl.allocateDirect(5))
{
- WritableMemory mem1 = h1.get();
+ WritableMemoryImpl mem1 = h1.get();
mem1.putByteArray(0, arr1, 0, 4);
- WritableMemory mem2 = h2.get();
+ WritableMemoryImpl mem2 = h2.get();
mem2.putByteArray(0, arr2, 0, 4);
- WritableMemory mem3 = h3.get();
+ WritableMemoryImpl mem3 = h3.get();
mem3.putByteArray(0, arr3, 0, 5);
Buffer buf1 = mem1.asBuffer();
@@ -436,7 +436,7 @@ public class WritableBufferImplTest {
@Test
public void checkAsBuffer() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
@@ -451,7 +451,7 @@ public class WritableBufferImplTest {
@Test
public void checkDuplicate() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
for (int i = 0; i < 64; i++) { wmem.putByte(i, (byte)i); }
WritableBuffer wbuf = wmem.asWritableBuffer().writableDuplicate();
@@ -464,18 +464,18 @@ public class WritableBufferImplTest {
assertEquals(buf.getByte(), i);
}
- WritableMemory wmem2 = wbuf.asWritableMemory();
+ WritableMemoryImpl wmem2 = wbuf.asWritableMemory();
for (int i = 0; i < 64; i++) {
assertEquals(wmem2.getByte(i), i);
}
- WritableMemory wmem3 = wbuf.asWritableMemory();
+ WritableMemoryImpl wmem3 = wbuf.asWritableMemory();
wmem3.checkValidAndBounds(0, 64);
}
@Test
public void checkCumAndRegionOffset() {
- WritableMemory wmem = WritableMemory.allocate(64);
- WritableMemory reg = wmem.writableRegion(32, 32);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemoryImpl reg = wmem.writableRegion(32, 32);
WritableBuffer buf = reg.asWritableBuffer();
assertEquals(buf.getRegionOffset(), 32);
assertEquals(buf.getRegionOffset(0), 32);
@@ -486,14 +486,14 @@ public class WritableBufferImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableBuffer wbuf1 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
- WritableBuffer wbuf2 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf1 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf2 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
assertTrue(wbuf1.isSameResource(wbuf2));
}
@Test
public void checkDegenerateRegionReturn() {
- Memory mem = Memory.wrap(new byte[0]);
+ MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
Buffer buf = mem.asBuffer();
Buffer reg = buf.region();
assertEquals(reg.getCapacity(), 0);
@@ -504,13 +504,13 @@ public class WritableBufferImplTest {
ByteBuffer bb = ByteBuffer.allocate(64);
WritableBuffer wbuf = WritableBuffer.wrap(bb);
@SuppressWarnings("unused")
- WritableMemory wmem = wbuf.asWritableMemory();
+ WritableMemoryImpl wmem = wbuf.asWritableMemory();
try {
Buffer buf = Buffer.wrap(bb);
wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableMemory wmem2 = wbuf.asWritableMemory();
+ WritableMemoryImpl wmem2 = wbuf.asWritableMemory();
Assert.fail();
} catch (ReadOnlyException expected) {
// expected
@@ -573,7 +573,7 @@ public class WritableBufferImplTest {
@Test
public void checkZeroBuffer() {
- WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
WritableBuffer wbuf = wmem.asWritableBuffer();
WritableBuffer reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
assertEquals(reg.getCapacity(), 0);
@@ -581,7 +581,7 @@ public class WritableBufferImplTest {
@Test
public void checkDuplicateNonNative() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
wmem.putShort(0, (short) 1);
Buffer buf = wmem.asWritableBuffer().duplicate(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
index cd3e7ad..d29dff3 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -39,8 +39,8 @@ public class WritableDirectCopyTest {
public void checkCopyWithinNativeSmall() {
int memCapacity = 64;
int half = memCapacity / 2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.clear();
for (int i = 0; i < half; i++) { //fill first half
@@ -61,8 +61,8 @@ public class WritableDirectCopyTest {
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.clear();
for (int i = 0; i < halfLongs; i++) {
@@ -80,8 +80,8 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyWithinNativeOverlap() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.clear();
//println(mem.toHexString("Clear 64", 0, memCapacity));
@@ -96,8 +96,8 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyWithinNativeSrcBound() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
} catch (IllegalArgumentException e) {
@@ -108,8 +108,8 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyWithinNativeDstBound() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
} catch (IllegalArgumentException e) {
@@ -121,10 +121,10 @@ public class WritableDirectCopyTest {
public void checkCopyCrossNativeSmall() {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
- WritableMemory mem2 = wrh2.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
+ WritableMemoryImpl mem2 = wrh2.get();
for (int i = 0; i < memCapacity; i++) {
mem1.putByte(i, (byte) i);
@@ -145,10 +145,10 @@ public class WritableDirectCopyTest {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
- WritableMemory mem2 = wrh2.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
+ WritableMemoryImpl mem2 = wrh2.get();
for (int i = 0; i < memCapLongs; i++) {
mem1.putLong(i * 8, i);
@@ -166,14 +166,14 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyCrossNativeAndByteArray() {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
for (int i = 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i = 0; i < 16; i++) {
@@ -187,18 +187,18 @@ public class WritableDirectCopyTest {
public void checkCopyCrossRegionsSameNative() {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
for (int i = 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- Memory reg1 = mem1.region(8, 16);
+ MemoryImpl reg1 = mem1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
- WritableMemory reg2 = mem1.writableRegion(24, 16);
+ WritableMemoryImpl reg2 = mem1.writableRegion(24, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
reg1.copyTo(0, reg2, 0, 16);
@@ -213,22 +213,22 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyCrossNativeArrayAndHierarchicalRegions() {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
for (int i = 0; i < mem1.getCapacity(); i++) { //fill with numbers
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
- Memory reg1 = mem1.region(8, 32);
- Memory reg1B = reg1.region(8, 16);
+ MemoryImpl reg1 = mem1.region(8, 32);
+ MemoryImpl reg1B = reg1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
//println(reg1B.toHexString("Reg1B", 0, (int)reg1B.getCapacity()));
- WritableMemory reg2 = mem2.writableRegion(32, 16);
+ WritableMemoryImpl reg2 = mem2.writableRegion(32, 16);
reg1B.copyTo(0, reg2, 0, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
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 78ba991..ccf994e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
@@ -29,12 +29,12 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -46,8 +46,8 @@ public class WritableMemoryImplTest {
@Test
public void checkNativeCapacityAndClose() {
int memCapacity = 64;
- WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
- WritableMemory mem = wmh.get();
+ WritableHandle wmh = WritableMemoryImpl.allocateDirect(memCapacity);
+ WritableMemoryImpl mem = wmh.get();
assertEquals(memCapacity, mem.getCapacity());
wmh.close(); //intentional
@@ -63,13 +63,13 @@ public class WritableMemoryImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -82,13 +82,13 @@ public class WritableMemoryImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -100,13 +100,13 @@ public class WritableMemoryImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -118,13 +118,13 @@ public class WritableMemoryImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -136,13 +136,13 @@ public class WritableMemoryImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -154,13 +154,13 @@ public class WritableMemoryImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -172,13 +172,13 @@ public class WritableMemoryImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -190,13 +190,13 @@ public class WritableMemoryImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- Memory mem = Memory.wrap(srcArray);
+ MemoryImpl mem = MemoryImpl.wrap(srcArray);
mem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
wmem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -206,8 +206,8 @@ public class WritableMemoryImplTest {
@Test
public void checkNativeBaseBound() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
//ok
@@ -217,8 +217,8 @@ public class WritableMemoryImplTest {
@Test
public void checkNativeSrcArrayBound() {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
byte[] srcArray = { 1, -2, 3, -4 };
mem.putByteArray(0L, srcArray, 0, 5);
} catch (IllegalArgumentException e) {
@@ -230,7 +230,7 @@ public class WritableMemoryImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkDegenerateCopyTo() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
wmem.copyTo(0, wmem, 0, 64);
}
@@ -238,8 +238,8 @@ public class WritableMemoryImplTest {
public void checkCopyWithinNativeSmall() {
int memCapacity = 64;
int half = memCapacity/2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.clear();
for (int i=0; i<half; i++) { //fill first half
@@ -260,8 +260,8 @@ public class WritableMemoryImplTest {
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.clear();
for (int i=0; i < halfLongs; i++) {
@@ -279,8 +279,8 @@ public class WritableMemoryImplTest {
@Test
public void checkCopyWithinNativeSrcBound() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
}
@@ -292,8 +292,8 @@ public class WritableMemoryImplTest {
@Test
public void checkCopyWithinNativeDstBound() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
}
@@ -306,11 +306,11 @@ public class WritableMemoryImplTest {
public void checkCopyCrossNativeSmall() {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity))
{
- WritableMemory mem1 = wrh1.get();
- WritableMemory mem2 = wrh2.get();
+ WritableMemoryImpl mem1 = wrh1.get();
+ WritableMemoryImpl mem2 = wrh2.get();
for (int i=0; i < memCapacity; i++) {
mem1.putByte(i, (byte) i);
@@ -331,11 +331,11 @@ public class WritableMemoryImplTest {
int memCapacity = (2<<20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity))
{
- WritableMemory mem1 = wrh1.get();
- WritableMemory mem2 = wrh2.get();
+ WritableMemoryImpl mem1 = wrh1.get();
+ WritableMemoryImpl mem2 = wrh2.get();
for (int i=0; i < memCapLongs; i++) {
mem1.putLong(i*8, i);
@@ -353,14 +353,14 @@ public class WritableMemoryImplTest {
@Test
public void checkCopyCrossNativeAndByteArray() {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
for (int i= 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i=0; i<16; i++) {
@@ -374,18 +374,18 @@ public class WritableMemoryImplTest {
public void checkCopyCrossRegionsSameNative() {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
for (int i= 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- Memory reg1 = mem1.region(8, 16);
+ MemoryImpl reg1 = mem1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
- WritableMemory reg2 = mem1.writableRegion(24, 16);
+ WritableMemoryImpl reg2 = mem1.writableRegion(24, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
reg1.copyTo(0, reg2, 0, 16);
@@ -400,22 +400,22 @@ public class WritableMemoryImplTest {
@Test
public void checkCopyCrossNativeArrayAndHierarchicalRegions() {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem1 = wrh1.get();
for (int i= 0; i < mem1.getCapacity(); i++) { //fill with numbers
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
- Memory reg1 = mem1.region(8, 32);
- Memory reg1B = reg1.region(8, 16);
+ MemoryImpl reg1 = mem1.region(8, 32);
+ MemoryImpl reg1B = reg1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
//println(reg1B.toHexString("Reg1B", 0, (int)reg1B.getCapacity()));
- WritableMemory reg2 = mem2.writableRegion(32, 16);
+ WritableMemoryImpl reg2 = mem2.writableRegion(32, 16);
reg1B.copyTo(0, reg2, 0, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
@@ -430,8 +430,8 @@ public class WritableMemoryImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkRegionBounds() {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
- WritableMemory mem = wrh.get();
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
+ WritableMemoryImpl mem = wrh.get();
mem.writableRegion(1, 64);
}
}
@@ -446,7 +446,7 @@ public class WritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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.writableWrap(byteBuf);
+ MemoryImpl mem = WritableMemoryImpl.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.writableWrap(byteBufRO);
+ WritableMemoryImpl.writableWrap(byteBufRO);
}
@Test
@@ -499,7 +499,7 @@ public class WritableMemoryImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- Memory mem = Memory.wrap(byteBufRO);
+ MemoryImpl mem = MemoryImpl.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -515,7 +515,7 @@ public class WritableMemoryImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableMemory.writableWrap(byteBufRO);
+ WritableMemoryImpl.writableWrap(byteBufRO);
}
@Test
@@ -528,7 +528,7 @@ public class WritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- Memory mem = Memory.wrap(byteBuf);
+ MemoryImpl mem = MemoryImpl.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -540,9 +540,9 @@ public class WritableMemoryImplTest {
@Test
public void checkIsDirect() {
int memCapacity = 64;
- WritableMemory mem = WritableMemory.allocate(memCapacity);
+ WritableMemoryImpl mem = WritableMemoryImpl.allocate(memCapacity);
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
mem = wrh.get();
assertTrue(mem.isDirect());
wrh.close();
@@ -553,10 +553,10 @@ public class WritableMemoryImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
assertFalse(wmem.isReadOnly());
- Memory memRO = wmem;
+ MemoryImpl memRO = wmem;
assertFalse(memRO.isReadOnly());
for (int i = 0; i < wmem.getCapacity(); i++) {
@@ -575,10 +575,10 @@ public class WritableMemoryImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- Memory mem1 = Memory.wrap(arr1);
- Memory mem2 = Memory.wrap(arr2);
- Memory mem3 = Memory.wrap(arr3);
- Memory mem4 = Memory.wrap(arr3); //same resource
+ MemoryImpl mem1 = MemoryImpl.wrap(arr1);
+ MemoryImpl mem2 = MemoryImpl.wrap(arr2);
+ MemoryImpl mem3 = MemoryImpl.wrap(arr3);
+ MemoryImpl mem4 = MemoryImpl.wrap(arr3); //same resource
int comp = mem1.compareTo(0, 3, mem2, 0, 3);
assertEquals(comp, 0);
@@ -604,17 +604,17 @@ public class WritableMemoryImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemory.allocateDirect(4);
- WritableHandle h2 = WritableMemory.allocateDirect(4);
- WritableHandle h3 = WritableMemory.allocateDirect(5))
+ try (WritableHandle h1 = WritableMemoryImpl.allocateDirect(4);
+ WritableHandle h2 = WritableMemoryImpl.allocateDirect(4);
+ WritableHandle h3 = WritableMemoryImpl.allocateDirect(5))
{
- WritableMemory mem1 = h1.get();
+ WritableMemoryImpl mem1 = h1.get();
mem1.putByteArray(0, arr1, 0, 4);
- WritableMemory mem2 = h2.get();
+ WritableMemoryImpl mem2 = h2.get();
mem2.putByteArray(0, arr2, 0, 4);
- WritableMemory mem3 = h3.get();
+ WritableMemoryImpl mem3 = h3.get();
mem3.putByteArray(0, arr3, 0, 5);
int comp = mem1.compareTo(0, 3, mem2, 0, 3);
@@ -633,7 +633,7 @@ public class WritableMemoryImplTest {
@Test
public void testCompareToSameStart() {
- Memory mem = WritableMemory.allocate(3);
+ MemoryImpl mem = WritableMemoryImpl.allocate(3);
assertEquals(-1, mem.compareTo(0, 1, mem, 0, 2));
assertEquals(0, mem.compareTo(1, 1, mem, 1, 1));
assertEquals(1, mem.compareTo(1, 2, mem, 1, 1));
@@ -641,7 +641,7 @@ public class WritableMemoryImplTest {
@Test
public void checkAsBuffer() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
@@ -656,8 +656,8 @@ public class WritableMemoryImplTest {
@Test
public void checkCumAndRegionOffset() {
- WritableMemory wmem = WritableMemory.allocate(64);
- WritableMemory reg = wmem.writableRegion(32, 32);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemoryImpl reg = wmem.writableRegion(32, 32);
assertEquals(reg.getRegionOffset(), 32);
assertEquals(reg.getRegionOffset(0), 32);
assertEquals(reg.getCumulativeOffset(), 32 + 16);
@@ -667,8 +667,8 @@ public class WritableMemoryImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableMemory wmem1 = WritableMemory.writableWrap(byteArr);
- WritableMemory wmem2 = WritableMemory.writableWrap(byteArr);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(byteArr);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.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.writableWrap(byteBuf);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteBuf);
WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), 64);
assertEquals(wbuf.getPosition(), 0);
@@ -687,26 +687,26 @@ public class WritableMemoryImplTest {
@Test(expectedExceptions = ReadOnlyException.class)
public void checkAsWritableRegionRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
+ WritableMemoryImpl wmem = (WritableMemoryImpl) MemoryImpl.wrap(byteBuf);
wmem.writableRegion(0, 1);
}
@Test(expectedExceptions = ReadOnlyException.class)
public void checkAsWritableBufferRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
+ WritableMemoryImpl wmem = (WritableMemoryImpl) MemoryImpl.wrap(byteBuf);
wmem.asWritableBuffer();
}
@Test void checkZeroMemory() {
- WritableMemory wmem = WritableMemory.allocate(8);
- WritableMemory reg = wmem.writableRegion(0, 0);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
+ WritableMemoryImpl reg = wmem.writableRegion(0, 0);
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkAsBufferNonNative() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
wmem.putShort(0, (short) 1);
Buffer buf = wmem.asBuffer(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
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 54c9515..988d2ee 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
@@ -27,10 +27,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.internal.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -39,7 +39,7 @@ public class WritableMemoryTest {
@Test
public void wrapBigEndian() {
ByteBuffer bb = ByteBuffer.allocate(64); //big endian
- WritableMemory wmem = WritableMemory.writableWrap(bb);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -47,22 +47,22 @@ public class WritableMemoryTest {
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as BE
- WritableMemory wmem = WritableMemory.writableWrap(bb, ByteOrder.LITTLE_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb, ByteOrder.LITTLE_ENDIAN);
assertEquals(wmem.getChar(0), 256);
}
@Test
public void allocateWithByteOrder() {
- WritableMemory wmem = WritableMemory.allocate(64, ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64, ByteOrder.BIG_ENDIAN);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- wmem = WritableMemory.allocate(64, ByteOrder.LITTLE_ENDIAN);
+ wmem = WritableMemoryImpl.allocate(64, ByteOrder.LITTLE_ENDIAN);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
@Test
public void checkGetArray() {
byte[] byteArr = new byte[64];
- WritableMemory wmem = WritableMemory.writableWrap(byteArr);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteArr);
assertTrue(wmem.getArray() == byteArr);
WritableBuffer wbuf = wmem.asWritableBuffer();
assertTrue(wbuf.getArray() == byteArr);
@@ -71,26 +71,26 @@ public class WritableMemoryTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkSelfArrayCopy() {
byte[] srcAndDst = new byte[128];
- WritableMemory wmem = WritableMemory.writableWrap(srcAndDst);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcAndDst);
wmem.getByteArray(0, srcAndDst, 64, 64); //non-overlapping
}
@Test
public void checkEquals() {
int len = 7;
- WritableMemory wmem1 = WritableMemory.allocate(len);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.allocate(len);
//@SuppressWarnings({"EqualsWithItself", "SelfEquals"}) //unsupported
//SelfEquals for Plexus, EqualsWithItself for IntelliJ
//boolean eq1 = wmem1.equals(wmem1); //strict profile complains
//assertTrue(eq1);
- WritableMemory wmem2 = WritableMemory.allocate(len + 1);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
- WritableMemory reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
+ WritableMemoryImpl reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
assertTrue(wmem1.equals(reg1));
- wmem2 = WritableMemory.allocate(len);
+ wmem2 = WritableMemoryImpl.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -102,8 +102,8 @@ public class WritableMemoryTest {
assertTrue(wmem1.equalTo(0, reg1, 0, len));
len = 24;
- wmem1 = WritableMemory.allocate(len);
- wmem2 = WritableMemory.allocate(len);
+ wmem1 = WritableMemoryImpl.allocate(len);
+ wmem2 = WritableMemoryImpl.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -120,14 +120,14 @@ public class WritableMemoryTest {
@Test
public void checkEquals2() {
int len = 23;
- WritableMemory wmem1 = WritableMemory.allocate(len);
+ WritableMemoryImpl wmem1 = WritableMemoryImpl.allocate(len);
assertFalse(wmem1.equals(null));
//@SuppressWarnings({"EqualsWithItself", "SelfEquals"}) //unsupported
//SelfEquals for Plexus, EqualsWithItself for IntelliJ
//boolean eq1 = wmem1.equals(wmem1); //strict profile complains
//assertTrue(eq1);
- WritableMemory wmem2 = WritableMemory.allocate(len + 1);
+ WritableMemoryImpl wmem2 = WritableMemoryImpl.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
for (int i = 0; i < len; i++) {
@@ -146,8 +146,8 @@ public class WritableMemoryTest {
byte[] bytes1 = new byte[(thresh * 2) + 7];
ThreadLocalRandom.current().nextBytes(bytes1);
byte[] bytes2 = bytes1.clone();
- Memory mem1 = Memory.wrap(bytes1);
- Memory mem2 = Memory.wrap(bytes2);
+ MemoryImpl mem1 = MemoryImpl.wrap(bytes1);
+ MemoryImpl mem2 = MemoryImpl.wrap(bytes2);
assertTrue(mem1.equals(mem2));
bytes2[thresh + 10] = (byte) (bytes1[thresh + 10] + 1);
@@ -160,11 +160,11 @@ public class WritableMemoryTest {
@Test
public void checkWrapWithBO() {
- WritableMemory wmem = WritableMemory.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN);
boolean nativeBO = wmem.getTypeByteOrder() == Util.nativeByteOrder;
assertTrue(nativeBO); //remains true for ZeroSizeMemory
println("" + nativeBO);
- wmem = WritableMemory.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
+ wmem = WritableMemoryImpl.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
nativeBO = wmem.getTypeByteOrder() == Util.nativeByteOrder;
assertFalse(nativeBO);
println("" + nativeBO);
@@ -173,11 +173,11 @@ public class WritableMemoryTest {
@Test
@SuppressWarnings("unused")
public void checkOwnerClientCase() {
- WritableMemory owner = WritableMemory.allocate(64);
- Memory client1 = owner; //Client1 cannot write (no API)
+ WritableMemoryImpl owner = WritableMemoryImpl.allocate(64);
+ MemoryImpl client1 = owner; //Client1 cannot write (no API)
owner.putInt(0, 1); //But owner can write
- ((WritableMemory)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
- Memory client2 = owner.region(0, owner.getCapacity()); //client2 cannot write (no API)
+ ((WritableMemoryImpl)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
+ MemoryImpl client2 = owner.region(0, owner.getCapacity()); //client2 cannot write (no API)
owner.putInt(0, 3); //But Owner should be able to write
}
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 6d5cd76..6d1f6c1 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
@@ -21,7 +21,7 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
/**
@@ -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.writableWrap(byteArr);
+ WritableMemoryImpl wmem = WritableMemoryImpl.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 bf7924e..50f44c4 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
@@ -26,8 +26,8 @@ import static org.testng.Assert.assertTrue;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
import net.openhft.hashing.LongHashFunction;
@@ -46,7 +46,7 @@ public class XxHash64Test {
long hash;
- WritableMemory wmem = WritableMemory.allocate(cap);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(cap);
for (int i = 0; i < cap; i++) { wmem.putByte(i, (byte)(-128 + i)); }
for (int offset = 0; offset < 16; offset++) {
@@ -65,7 +65,7 @@ public class XxHash64Test {
for (int j = 1; j < bytes; j++) {
byte[] in = new byte[bytes];
- WritableMemory wmem = WritableMemory.writableWrap(in);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(in);
for (int i = 0; i < j; i++) { wmem.putByte(i, (byte) (-128 + i)); }
long hash =wmem.xxHash64(offset, bytes, seed);
@@ -81,7 +81,7 @@ public class XxHash64Test {
*/
@Test
public void collisionTest() {
- WritableMemory wmem = WritableMemory.allocate(128);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(128);
wmem.putLong(0, 1);
wmem.putLong(16, 42);
wmem.putLong(32, 2);
@@ -115,7 +115,7 @@ public class XxHash64Test {
byte[] bytes = new byte[len];
for (int i = 0; i < 10; i++) {
long zahXxHash = LongHashFunction.xx().hashBytes(bytes);
- long memoryXxHash = Memory.wrap(bytes).xxHash64(0, len, 0);
+ long memoryXxHash = MemoryImpl.wrap(bytes).xxHash64(0, len, 0);
assertEquals(memoryXxHash, zahXxHash);
random.nextBytes(bytes);
}
@@ -126,7 +126,7 @@ public class XxHash64Test {
@Test
public void testArrHashes() {
- WritableMemory wmem = WritableMemory.writableWrap(barr);
+ WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(barr);
long hash0 = wmem.xxHash64(8, 8, 0);
long hash1 = hashBytes(barr, 8, 8, 0);
assertEquals(hash1, hash0);
diff --git a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
index b8b3e3d..fea92ae 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.Memory;
-import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -37,15 +37,15 @@ public class ZeroCapacityTest {
@SuppressWarnings({ "unused", "resource" })
@Test
public void checkZeroCapacity() {
- WritableMemory wmem = WritableMemory.allocate(0);
+ WritableMemoryImpl wmem = WritableMemoryImpl.allocate(0);
assertEquals(wmem.getCapacity(), 0);
- Memory mem1 = Memory.wrap(new byte[0]);
- Memory mem2 = Memory.wrap(ByteBuffer.allocate(0));
- Memory mem3 = Memory.wrap(ByteBuffer.allocateDirect(0));
- Memory reg = mem3.region(0, 0);
+ MemoryImpl mem1 = MemoryImpl.wrap(new byte[0]);
+ MemoryImpl mem2 = MemoryImpl.wrap(ByteBuffer.allocate(0));
+ MemoryImpl mem3 = MemoryImpl.wrap(ByteBuffer.allocateDirect(0));
+ MemoryImpl reg = mem3.region(0, 0);
try {
- WritableMemory.allocateDirect(0);
+ WritableMemoryImpl.allocateDirect(0);
Assert.fail();
} catch (IllegalArgumentException ignore) {
// expected
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 07/08: Finished refactoring Buffer tree,
which completes main.
Posted by le...@apache.org.
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 8a570265dbf3b159a65279390a605c9065e113db
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Mon May 17 20:55:06 2021 -0700
Finished refactoring Buffer tree, which completes main.
Next to refactor the tests. Lots of errors, which is expected.
---
.../org/apache/datasketches/memory/BaseBuffer.java | 126 ++++++++
.../org/apache/datasketches/memory/BaseState.java | 21 +-
.../datasketches/memory/{internal => }/Buffer.java | 125 +++-----
.../memory/DefaultMemoryRequestServer.java | 2 +-
.../org/apache/datasketches/memory/Memory.java | 44 ++-
.../memory/{internal => }/WritableBuffer.java | 142 ++++-----
.../apache/datasketches/memory/WritableMemory.java | 74 ++---
.../internal/BBNonNativeWritableBufferImpl.java | 2 +-
.../memory/internal/BBWritableBufferImpl.java | 4 +-
.../{BaseBuffer.java => BaseBufferImpl.java} | 109 ++-----
.../memory/internal/BaseStateImpl.java | 6 +-
.../memory/internal/BaseWritableBufferImpl.java | 46 +--
.../memory/internal/BaseWritableMemoryImpl.java | 22 +-
.../datasketches/memory/internal/BufferImpl.java | 161 ++++++++++
.../memory/internal/CompareAndCopy.java | 2 +-
.../DirectNonNativeWritableBufferImpl.java | 2 +-
.../memory/internal/DirectWritableBufferImpl.java | 4 +-
.../internal/HeapNonNativeWritableBufferImpl.java | 2 +-
.../memory/internal/HeapWritableBufferImpl.java | 4 +-
.../internal/MapNonNativeWritableBufferImpl.java | 2 +-
.../memory/internal/MapWritableBufferImpl.java | 4 +-
.../datasketches/memory/internal/MemoryImpl.java | 4 +-
...fferImpl.java => NativeWritableBufferImpl.java} | 6 +-
.../internal/NonNativeWritableBufferImpl.java | 4 +-
.../memory/internal/WritableBufferImpl.java | 343 +++++----------------
.../memory/internal/WritableMemoryImpl.java | 4 +-
.../datasketches/memory/internal/package-info.java | 10 +-
.../datasketches/memory/test/BaseBufferTest.java | 8 +-
.../datasketches/memory/test/BaseStateTest.java | 8 +-
.../datasketches/memory/test/Buffer2Test.java | 70 ++---
.../memory/test/BufferInvariantsTest.java | 40 +--
.../memory/test/BufferReadWriteSafetyTest.java | 14 +-
.../datasketches/memory/test/BufferTest.java | 56 ++--
.../datasketches/memory/test/CommonBufferTest.java | 24 +-
.../datasketches/memory/test/LeafImplTest.java | 18 +-
.../memory/test/MemoryBoundaryCheckTest.java | 4 +-
.../test/NonNativeWritableBufferImplTest.java | 40 +--
.../datasketches/memory/test/SpecificLeafTest.java | 36 +--
.../memory/test/WritableBufferImplTest.java | 136 ++++----
.../memory/test/WritableMemoryImplTest.java | 12 +-
.../memory/test/WritableMemoryTest.java | 4 +-
41 files changed, 852 insertions(+), 893 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/BaseBuffer.java b/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
new file mode 100644
index 0000000..68c18c3
--- /dev/null
+++ b/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
@@ -0,0 +1,126 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.datasketches.memory;
+
+public interface BaseBuffer {
+
+ /**
+ * Increments the current position by the given increment.
+ * Asserts that the resource is valid and that the positional invariants are not violated,
+ * otherwise, if asserts are enabled throws an {@link AssertionError}.
+ * @param increment the given increment
+ * @return BaseBuffer
+ */
+ BaseBuffer incrementPosition(long increment);
+
+ /**
+ * Increments the current position by the given increment.
+ * Checks that the resource is valid and that the positional invariants are not violated,
+ * otherwise throws an {@link IllegalArgumentException}.
+ * @param increment the given increment
+ * @return BaseBuffer
+ */
+ BaseBuffer incrementAndCheckPosition(final long increment);
+
+ /**
+ * Gets the end position
+ * @return the end position
+ */
+ long getEnd();
+
+ /**
+ * Gets the current position
+ * @return the current position
+ */
+ long getPosition();
+
+ /**
+ * Gets start position
+ * @return start position
+ */
+ long getStart();
+
+ /**
+ * The number of elements remaining between the current position and the end position
+ * @return {@code (end - position)}
+ */
+ long getRemaining();
+
+ /**
+ * Returns true if there are elements remaining between the current position and the end position
+ * @return {@code (end - position) > 0}
+ */
+ boolean hasRemaining();
+
+ /**
+ * Resets the current position to the start position,
+ * This does not modify any data.
+ * @return BaseBuffer
+ */
+ BaseBuffer resetPosition();
+
+ /**
+ * Sets the current position.
+ * Asserts that the positional invariants are not violated,
+ * otherwise, if asserts are enabled throws an {@link AssertionError}.
+ * @param position the given current position.
+ * @return BaseBuffer
+ */
+ BaseBuffer setPosition(long position);
+
+ /**
+ * Sets the current position.
+ * Checks that the positional invariants are not violated,
+ * otherwise, throws an {@link IllegalArgumentException}.
+ * @param position the given current position.
+ * @return BaseBuffer
+ */
+ BaseBuffer setAndCheckPosition(long position);
+
+ /**
+ * Sets start position, current position, and end position.
+ * Asserts that the positional invariants are not violated,
+ * otherwise, if asserts are enabled throws an {@link AssertionError}.
+ * @param start the start position in the buffer
+ * @param position the current position between the start and end
+ * @param end the end position in the buffer
+ * @return BaseBuffer
+ */
+ BaseBuffer setStartPositionEnd(long start, long position, long end);
+
+ /**
+ * Sets start position, current position, and end position.
+ * Checks that the positional invariants are not violated,
+ * otherwise, throws an {@link IllegalArgumentException}.
+ * @param start the start position in the buffer
+ * @param position the current position between the start and end
+ * @param end the end position in the buffer
+ * @return BaseBuffer
+ */
+ BaseBuffer setAndCheckStartPositionEnd(long start, long position, long end);
+
+
+
+
+
+
+
+
+}
diff --git a/src/main/java/org/apache/datasketches/memory/BaseState.java b/src/main/java/org/apache/datasketches/memory/BaseState.java
index ac1e4f2..0734fbd 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseState.java
+++ b/src/main/java/org/apache/datasketches/memory/BaseState.java
@@ -49,7 +49,7 @@ public interface BaseState {
* @return true if the Native ByteOrder is the same as the ByteOrder of the
* current Buffer or Memory and the same ByteOrder as the given byteOrder.
*/
- boolean isByteOrderCompatible(final ByteOrder byteOrder);
+ boolean isByteOrderCompatible(ByteOrder byteOrder);
/**
* Returns true if the given object is an instance of this class and has equal data contents.
@@ -57,7 +57,7 @@ public interface BaseState {
* @return true if the given Object is an instance of this class and has equal data contents.
*/
@Override
- boolean equals(final Object that);
+ boolean equals(Object that);
/**
* Returns true if the given object is an instance of this class and has equal contents to
@@ -70,8 +70,8 @@ public interface BaseState {
* @return true if the given object has equal contents to this object in the given range of
* bytes.
*/
- boolean equalTo(final long thisOffsetBytes, final Object that,
- final long thatOffsetBytes, final long lengthBytes);
+ boolean equalTo(long thisOffsetBytes, Object that,
+ long thatOffsetBytes, long lengthBytes);
/**
* Gets the backing ByteBuffer if it exists, otherwise returns null.
@@ -103,7 +103,7 @@ public interface BaseState {
* @return the cumulative offset in bytes of this object from the backing resource including the
* given offsetBytes.
*/
- long getCumulativeOffset(final long offsetBytes);
+ long getCumulativeOffset(long offsetBytes);
/**
* Returns the offset of address zero of this object relative to the address zero of the
@@ -122,7 +122,7 @@ public interface BaseState {
* backing resource plus the given offsetBytes but not including the size of any Java object
* header.
*/
- long getRegionOffset(final long offsetBytes);
+ long getRegionOffset(long offsetBytes);
/**
* Returns true if this object is backed by an on-heap primitive array
@@ -156,7 +156,7 @@ public interface BaseState {
* @return the 64-bit hash of the sequence of bytes in this object specified by
* <i>offsetBytes</i> and <i>lengthBytes</i>.
*/
- long xxHash64(final long offsetBytes, final long lengthBytes, final long seed);
+ long xxHash64(long offsetBytes, long lengthBytes, long seed);
/**
* Returns true if this Memory is backed by a ByteBuffer.
@@ -185,7 +185,7 @@ public interface BaseState {
* @return true if the backing resource of <i>this</i> is the same as the backing resource
* of <i>that</i>.
*/
- boolean isSameResource(final Object that);
+ boolean isSameResource(Object that);
/**
* Returns true if this object is valid and has not been closed.
@@ -201,7 +201,7 @@ public interface BaseState {
* @param offsetBytes the given offset in bytes of this object
* @param lengthBytes the given length in bytes of this object
*/
- void checkValidAndBounds(final long offsetBytes, final long lengthBytes);
+ void checkValidAndBounds(long offsetBytes, long lengthBytes);
//Monitoring
@@ -247,7 +247,6 @@ public interface BaseState {
* @param lengthBytes number of bytes to convert to a hex string
* @return a formatted hex string in a human readable array
*/
- String toHexString(final String header, final long offsetBytes,
- final int lengthBytes);
+ String toHexString(String header, long offsetBytes, int lengthBytes);
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Buffer.java b/src/main/java/org/apache/datasketches/memory/Buffer.java
similarity index 76%
rename from src/main/java/org/apache/datasketches/memory/internal/Buffer.java
rename to src/main/java/org/apache/datasketches/memory/Buffer.java
index 824a4a5..c3389bf 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Buffer.java
+++ b/src/main/java/org/apache/datasketches/memory/Buffer.java
@@ -17,27 +17,15 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+
+package org.apache.datasketches.memory;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-/**
- * Provides read-only, positional primitive and primitive array methods to any of the four resources
- * mentioned in the package level documentation.
- *
- * @author Roman Leventov
- * @author Lee Rhodes
- *
- * @see org.apache.datasketches.memory.internal
- */
-public abstract class Buffer extends BaseBuffer {
+import org.apache.datasketches.memory.internal.BufferImpl;
- //Pass-through ctor
- Buffer(final Object unsafeObj, final long nativeBaseOffset,
- final long regionOffset, final long capacityBytes) {
- super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
- }
+public interface Buffer extends BaseBuffer {
//BYTE BUFFER
/**
@@ -47,8 +35,8 @@ public abstract class Buffer extends BaseBuffer {
* @param byteBuf the given ByteBuffer, must not be null.
* @return a new Buffer for read-only operations on the given ByteBuffer.
*/
- public static Buffer wrap(final ByteBuffer byteBuf) {
- return wrap(byteBuf, byteBuf.order());
+ static Buffer wrap(ByteBuffer byteBuf) {
+ return BufferImpl.wrap(byteBuf);
}
/**
@@ -61,17 +49,10 @@ public abstract class Buffer extends BaseBuffer {
* state of the given ByteBuffer
* @return a new Buffer for read-only operations on the given ByteBuffer.
*/
- public static Buffer wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
- final BaseWritableMemoryImpl wmem =
- BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, true, byteOrder);
- final WritableBuffer wbuf = wmem.asWritableBufferImpl(true, byteOrder);
- wbuf.setStartPositionEnd(0, byteBuf.position(), byteBuf.limit());
- return wbuf;
+ static Buffer wrap(ByteBuffer byteBuf, ByteOrder byteOrder) {
+ return BufferImpl.wrap(byteBuf, byteOrder);
}
-
- //MAP
- //Use MemoryImpl for mapping files and the asBuffer()
-
+
//DUPLICATES
/**
* Returns a read-only duplicate view of this Buffer with the same but independent values of
@@ -90,7 +71,7 @@ public abstract class Buffer extends BaseBuffer {
* @return a read-only duplicate view of this Buffer with the same but independent values of
* <i>start</i>, <i>position</i> and <i>end</i>.
*/
- public abstract Buffer duplicate();
+ Buffer duplicate();
/**
* Returns a read-only duplicate view of this Buffer with the same but independent values of
@@ -110,7 +91,7 @@ public abstract class Buffer extends BaseBuffer {
* @return a read-only duplicate view of this Buffer with the same but independent values of
* <i>start</i>, <i>position</i> and <i>end</i>.
*/
- public abstract Buffer duplicate(ByteOrder byteOrder);
+ Buffer duplicate(ByteOrder byteOrder);
//REGIONS
/**
@@ -129,7 +110,7 @@ public abstract class Buffer extends BaseBuffer {
* @return a new <i>Buffer</i> representing the defined region based on the current
* <i>position</i> and <i>end</i>.
*/
- public abstract Buffer region();
+ Buffer region();
/**
* A region is a read-only view of this object.
@@ -146,8 +127,8 @@ public abstract class Buffer extends BaseBuffer {
* If this object's capacity is zero, the returned object is effectively immutable and
* the backing storage and byte order are unspecified.
*
- * <p><b>Note: The MemoryImpl returned with </b><i>asMemory()</i> will have the originating
- * <i>MemoryImpl</i> byte order.</p>
+ * <p><b>Note: The Memory returned with </b><i>asMemory()</i> will have the originating
+ * <i>Memory</i> byte order.</p>
*
* @param offsetBytes the starting offset with respect to the origin of this <i>WritableBuffer</i>
* @param capacityBytes the <i>capacity</i> of the returned region in bytes
@@ -155,22 +136,18 @@ public abstract class Buffer extends BaseBuffer {
* @return a new <i>Buffer</i> representing the defined writable region
* based on the current <i>position</i>, <i>end</i> and byteOrder.
*/
- public abstract Buffer region(long offsetBytes, long capacityBytes,
+ Buffer region(long offsetBytes, long capacityBytes,
ByteOrder byteOrder);
//MEMORY
/**
- * Convert this Buffer to a MemoryImpl. The current <i>start</i>, <i>position</i> and <i>end</i>
+ * Convert this Buffer to a Memory. The current <i>start</i>, <i>position</i> and <i>end</i>
* are ignored.
* If this object's capacity is zero, the returned object is effectively immutable and
* the backing resource and byte order are unspecified.
- * @return MemoryImpl
+ * @return Memory
*/
- public abstract MemoryImpl asMemory();
-
- //ACCESS PRIMITIVE HEAP ARRAYS for readOnly
- // use MemoryImpl or WritableMemoryImpl and then asBuffer().
- //END OF CONSTRUCTOR-TYPE METHODS
+ Memory asMemory();
//PRIMITIVE getX() and getXArray()
/**
@@ -178,15 +155,15 @@ public abstract class Buffer extends BaseBuffer {
* Increments the position by 1.
* @return the boolean at the current position
*/
- public abstract boolean getBoolean();
+ boolean getBoolean();
/**
* Gets the boolean value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the boolean at the given offset
*/
- public abstract boolean getBoolean(long offsetBytes);
+ boolean getBoolean(long offsetBytes);
/**
* Gets the boolean array at the current position.
@@ -195,7 +172,7 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetBooleans offset in array units
* @param lengthBooleans number of array units to transfer
*/
- public abstract void getBooleanArray(boolean[] dstArray, int dstOffsetBooleans,
+ void getBooleanArray(boolean[] dstArray, int dstOffsetBooleans,
int lengthBooleans);
/**
@@ -203,15 +180,15 @@ public abstract class Buffer extends BaseBuffer {
* Increments the position by <i>Byte.BYTES</i>.
* @return the byte at the current position
*/
- public abstract byte getByte();
+ byte getByte();
/**
* Gets the byte value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the byte at the given offset
*/
- public abstract byte getByte(long offsetBytes);
+ byte getByte(long offsetBytes);
/**
* Gets the byte array at the current position.
@@ -220,22 +197,22 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetBytes offset in array units
* @param lengthBytes number of array units to transfer
*/
- public abstract void getByteArray(byte[] dstArray, int dstOffsetBytes, int lengthBytes);
+ void getByteArray(byte[] dstArray, int dstOffsetBytes, int lengthBytes);
/**
* Gets the char value at the current position.
* Increments the position by <i>Character.BYTES</i>.
* @return the char at the current position
*/
- public abstract char getChar();
+ char getChar();
/**
* Gets the char value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the char at the given offset
*/
- public abstract char getChar(long offsetBytes);
+ char getChar(long offsetBytes);
/**
* Gets the char array at the current position.
@@ -244,22 +221,22 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetChars offset in array units
* @param lengthChars number of array units to transfer
*/
- public abstract void getCharArray(char[] dstArray, int dstOffsetChars, int lengthChars);
+ void getCharArray(char[] dstArray, int dstOffsetChars, int lengthChars);
/**
* Gets the double value at the current position.
* Increments the position by <i>Double.BYTES</i>.
* @return the double at the current position
*/
- public abstract double getDouble();
+ double getDouble();
/**
* Gets the double value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the double at the given offset
*/
- public abstract double getDouble(long offsetBytes);
+ double getDouble(long offsetBytes);
/**
* Gets the double array at the current position.
@@ -268,22 +245,22 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetDoubles offset in array units
* @param lengthDoubles number of array units to transfer
*/
- public abstract void getDoubleArray(double[] dstArray, int dstOffsetDoubles, int lengthDoubles);
+ void getDoubleArray(double[] dstArray, int dstOffsetDoubles, int lengthDoubles);
/**
* Gets the float value at the current position.
* Increments the position by <i>Float.BYTES</i>.
* @return the float at the current position
*/
- public abstract float getFloat();
+ float getFloat();
/**
* Gets the float value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the float at the given offset
*/
- public abstract float getFloat(long offsetBytes);
+ float getFloat(long offsetBytes);
/**
* Gets the float array at the current position.
@@ -292,22 +269,22 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetFloats offset in array units
* @param lengthFloats number of array units to transfer
*/
- public abstract void getFloatArray(float[] dstArray, int dstOffsetFloats, int lengthFloats);
+ void getFloatArray(float[] dstArray, int dstOffsetFloats, int lengthFloats);
/**
* Gets the int value at the current position.
* Increments the position by <i>Integer.BYTES</i>.
* @return the int at the current position
*/
- public abstract int getInt();
+ int getInt();
/**
* Gets the int value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the int at the given offset
*/
- public abstract int getInt(long offsetBytes);
+ int getInt(long offsetBytes);
/**
* Gets the int array at the current position.
@@ -316,22 +293,22 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetInts offset in array units
* @param lengthInts number of array units to transfer
*/
- public abstract void getIntArray(int[] dstArray, int dstOffsetInts, int lengthInts);
+ void getIntArray(int[] dstArray, int dstOffsetInts, int lengthInts);
/**
* Gets the long value at the current position.
* Increments the position by <i>Long.BYTES</i>.
* @return the long at the current position
*/
- public abstract long getLong();
+ long getLong();
/**
* Gets the long value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the long at the given offset
*/
- public abstract long getLong(long offsetBytes);
+ long getLong(long offsetBytes);
/**
* Gets the long array at the current position.
@@ -340,22 +317,22 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetLongs offset in array units
* @param lengthLongs number of array units to transfer
*/
- public abstract void getLongArray(long[] dstArray, int dstOffsetLongs, int lengthLongs);
+ void getLongArray(long[] dstArray, int dstOffsetLongs, int lengthLongs);
/**
* Gets the short value at the current position.
* Increments the position by <i>Short.BYTES</i>.
* @return the short at the current position
*/
- public abstract short getShort();
+ short getShort();
/**
* Gets the short value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this MemoryImpl start
+ * @param offsetBytes offset bytes relative to this Memory start
* @return the short at the given offset
*/
- public abstract short getShort(long offsetBytes);
+ short getShort(long offsetBytes);
/**
* Gets the short array at the current position.
@@ -364,7 +341,7 @@ public abstract class Buffer extends BaseBuffer {
* @param dstOffsetShorts offset in array units
* @param lengthShorts number of array units to transfer
*/
- public abstract void getShortArray(short[] dstArray, int dstOffsetShorts, int lengthShorts);
+ void getShortArray(short[] dstArray, int dstOffsetShorts, int lengthShorts);
//SPECIAL PRIMITIVE READ METHODS: compareTo
/**
@@ -382,7 +359,7 @@ public abstract class Buffer extends BaseBuffer {
* @return <i>(this < that) ? (some negative value) : (this > that) ? (some positive value)
* : 0;</i>
*/
- public abstract int compareTo(long thisOffsetBytes, long thisLengthBytes, Buffer that,
+ int compareTo(long thisOffsetBytes, long thisLengthBytes, Buffer that,
long thatOffsetBytes, long thatLengthBytes);
}
diff --git a/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
index a870b9b..851c4c8 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.WritableMemoryImpl;
* moveAndResize(mem, newMem);
*
* //You are done with the old memory, so request close.
- * //Note that it is up to the owner of the WritableDirectHandleImpl whether or not to
+ * //Note that it is up to the owner of the WritableDirectHandle whether or not to
* // actually close the resource.
* memReqSvr.requestClose(mem, newMem);
*
diff --git a/src/main/java/org/apache/datasketches/memory/Memory.java b/src/main/java/org/apache/datasketches/memory/Memory.java
index 01d7891..1457376 100644
--- a/src/main/java/org/apache/datasketches/memory/Memory.java
+++ b/src/main/java/org/apache/datasketches/memory/Memory.java
@@ -26,7 +26,6 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.WritableByteChannel;
-import org.apache.datasketches.memory.internal.Buffer;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Utf8CodingException;
import org.apache.datasketches.memory.internal.Util;
@@ -36,7 +35,7 @@ public interface Memory extends BaseState {
//BYTE BUFFER
/**
- * Accesses the given ByteBuffer for read-only operations. The returned <i>MemoryImpl</i> object has
+ * Accesses the given ByteBuffer for read-only operations. The returned <i>Memory</i> object has
* the same byte order, as the given ByteBuffer, unless the capacity of the given ByteBuffer is
* zero, then byte order of the returned <i>Memory</i> object (as well as backing storage) is
* unspecified.
@@ -46,7 +45,7 @@ public interface Memory extends BaseState {
* @param byteBuf the given ByteBuffer, must not be null
* @return a new <i>Memory</i> for read-only operations on the given ByteBuffer.
*/
- static Memory wrap(final ByteBuffer byteBuf) {
+ static Memory wrap(ByteBuffer byteBuf) {
return MemoryImpl.wrap(byteBuf);
}
@@ -63,7 +62,7 @@ public interface Memory extends BaseState {
* state of the given ByteBuffer.
* @return a new <i>Memory</i> for read-only operations on the given ByteBuffer.
*/
- static Memory wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ static Memory wrap(ByteBuffer byteBuf, ByteOrder byteOrder) {
return MemoryImpl.wrap(byteBuf, byteOrder);
}
@@ -80,7 +79,7 @@ public interface Memory extends BaseState {
* @return <i>MapHandle</i> for managing the mapped Memory.
* Please read Javadocs for {@link Handle}.
*/
- static MapHandle map(final File file) {
+ static MapHandle map(File file) {
return MemoryImpl.map(file, 0, file.length(), ByteOrder.nativeOrder());
}
@@ -97,8 +96,7 @@ public interface Memory extends BaseState {
* @return <i>MapHandle</i> for managing the mapped Memory.
* Please read Javadocs for {@link Handle}.
*/
- static MapHandle map(final File file, final long fileOffsetBytes, final long capacityBytes,
- final ByteOrder byteOrder) {
+ static MapHandle map(File file, long fileOffsetBytes, long capacityBytes, ByteOrder byteOrder) {
return MemoryImpl.map(file, fileOffsetBytes, capacityBytes, byteOrder);
}
@@ -116,7 +114,7 @@ public interface Memory extends BaseState {
* @return a new <i>Memory</i> representing the defined region based on the given
* offsetBytes and capacityBytes.
*/
- MemoryImpl region(long offsetBytes, long capacityBytes);
+ Memory region(long offsetBytes, long capacityBytes);
/**
* A region is a read-only view of this object.
@@ -133,7 +131,7 @@ public interface Memory extends BaseState {
* @return a new <i>Memory</i> representing the defined region based on the given
* offsetBytes, capacityBytes and byteOrder.
*/
- MemoryImpl region(long offsetBytes, long capacityBytes, ByteOrder byteOrder);
+ Memory region(long offsetBytes, long capacityBytes, ByteOrder byteOrder);
//AS BUFFER
/**
@@ -206,13 +204,13 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final boolean[] arr) {
+ static Memory wrap(boolean[] arr) {
return MemoryImpl.wrap(arr);
}
/**
* Wraps the given primitive array for read operations assuming native byte order. If the array
- * size is zero, backing storage and byte order of the returned <i>MemoryImpl</i> object are
+ * size is zero, backing storage and byte order of the returned <i>Memory</i> object are
* unspecified.
*
* <p><b>Note:</b> Always qualify this method with the class name, e.g.,
@@ -220,7 +218,7 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final byte[] arr) {
+ static Memory wrap(byte[] arr) {
return MemoryImpl.wrap(arr, 0, arr.length, Util.nativeByteOrder);
}
@@ -235,7 +233,7 @@ public interface Memory extends BaseState {
* @param byteOrder the byte order to be used
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final byte[] arr, final ByteOrder byteOrder) {
+ static Memory wrap(byte[] arr, ByteOrder byteOrder) {
return MemoryImpl.wrap(arr, 0, arr.length, byteOrder);
}
@@ -252,8 +250,8 @@ public interface Memory extends BaseState {
* @param byteOrder the byte order to be used
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final byte[] arr, final int offsetBytes, final int lengthBytes,
- final ByteOrder byteOrder) {
+ static Memory wrap(byte[] arr, int offsetBytes, int lengthBytes,
+ ByteOrder byteOrder) {
return MemoryImpl.wrap(arr, offsetBytes, lengthBytes, byteOrder);
}
@@ -266,7 +264,7 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final char[] arr) {
+ static Memory wrap(char[] arr) {
return MemoryImpl.wrap(arr);
}
@@ -279,7 +277,7 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final short[] arr) {
+ static Memory wrap(short[] arr) {
return MemoryImpl.wrap(arr);
}
@@ -292,7 +290,7 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final int[] arr) {
+ static Memory wrap(int[] arr) {
return MemoryImpl.wrap(arr);
}
@@ -306,7 +304,7 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final long[] arr) {
+ static Memory wrap(long[] arr) {
return MemoryImpl.wrap(arr);
}
@@ -320,7 +318,7 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final float[] arr) {
+ static Memory wrap(float[] arr) {
return MemoryImpl.wrap(arr);
}
@@ -334,7 +332,7 @@ public interface Memory extends BaseState {
* @param arr the given primitive array.
* @return a new <i>Memory</i> for read operations
*/
- static Memory wrap(final double[] arr) {
+ static Memory wrap(double[] arr) {
return MemoryImpl.wrap(arr);
}
@@ -421,8 +419,8 @@ public interface Memory extends BaseState {
* @return the number of characters decoded.
* @throws Utf8CodingException in case of malformed or illegal UTF-8 input
*/
- int getCharsFromUtf8(final long offsetBytes, final int utf8LengthBytes,
- final StringBuilder dst) throws Utf8CodingException;
+ int getCharsFromUtf8(long offsetBytes, int utf8LengthBytes, StringBuilder dst)
+ throws Utf8CodingException;
/**
* Gets the double value at the given offset
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
similarity index 75%
rename from src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
rename to src/main/java/org/apache/datasketches/memory/WritableBuffer.java
index 5911ca9..0a4e282 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
@@ -17,28 +17,15 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+
+package org.apache.datasketches.memory;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.DefaultMemoryRequestServer;
-import org.apache.datasketches.memory.MemoryRequestServer;
-
-/**
- * Provides read and write, positional primitive and primitive array access to any of the four
- * resources mentioned at the package level.
- *
- * @author Roman Leventov
- * @author Lee Rhodes
- */
-public abstract class WritableBuffer extends Buffer {
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
- //Pass-through ctor
- WritableBuffer(final Object unsafeObj, final long nativeBaseOffset,
- final long regionOffset, final long capacityBytes) {
- super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
- }
+public interface WritableBuffer {
//BYTE BUFFER
/**
@@ -49,8 +36,8 @@ public abstract class WritableBuffer extends Buffer {
* @param byteBuf the given ByteBuffer, must not be null.
* @return a new WritableBuffer for write operations on the given ByteBuffer.
*/
- public static WritableBuffer wrap(final ByteBuffer byteBuf) {
- return wrap(byteBuf, byteBuf.order());
+ static WritableBuffer writableWrap(ByteBuffer byteBuf) {
+ return WritableBufferImpl.writableWrap(byteBuf, byteBuf.order());
}
/**
@@ -63,20 +50,10 @@ public abstract class WritableBuffer extends Buffer {
* state of the given ByteBuffer
* @return a new WritableBuffer for write operations on the given ByteBuffer.
*/
- public static WritableBuffer wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
- final BaseWritableMemoryImpl wmem =
- BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteOrder);
- final WritableBuffer wbuf = wmem.asWritableBufferImpl(false, byteOrder);
- wbuf.setStartPositionEnd(0, byteBuf.position(), byteBuf.limit());
- return wbuf;
- }
-
- //MAP
- //Use WritableMemoryImpl for mapping files and then asWritableBuffer()
-
- //ALLOCATE DIRECT
- //Use WritableMemoryImpl to allocate direct memory and then asWritableBuffer().
-
+ static WritableBuffer writableWrap(ByteBuffer byteBuf, ByteOrder byteOrder) {
+ return WritableBufferImpl.writableWrap(byteBuf, byteOrder);
+ }
+
//DUPLICATES
/**
* Returns a duplicate writable view of this Buffer with the same but independent values of
@@ -95,7 +72,7 @@ public abstract class WritableBuffer extends Buffer {
* @return a duplicate writable view of this Buffer with the same but independent values of
* <i>start</i>, <i>position</i> and <i>end</i>.
*/
- public abstract WritableBuffer writableDuplicate();
+ WritableBuffer writableDuplicate();
/**
* Returns a duplicate writable view of this Buffer with the same but independent values of
@@ -115,7 +92,7 @@ public abstract class WritableBuffer extends Buffer {
* @return a duplicate writable view of this Buffer with the same but independent values of
* <i>start</i>, <i>position</i> and <i>end</i>.
*/
- public abstract WritableBuffer writableDuplicate(ByteOrder byteOrder);
+ WritableBuffer writableDuplicate(ByteOrder byteOrder);
//REGIONS
@@ -134,7 +111,7 @@ public abstract class WritableBuffer extends Buffer {
* the backing storage and byte order are unspecified.
* @return a new <i>WritableBuffer</i> representing the defined writable region.
*/
- public abstract WritableBuffer writableRegion();
+ WritableBuffer writableRegion();
/**
* A writable region is a writable view of this object.
@@ -152,28 +129,24 @@ public abstract class WritableBuffer extends Buffer {
* the backing storage and byte order are unspecified.
*
* <p><b>Note: </b><i>asWritableMemory()</i> and <i>asMemory()</i>
- * will return the originating <i>MemoryImpl</i> byte order.</p>
+ * will return the originating <i>Memory</i> byte order.</p>
* @param offsetBytes the starting offset with respect to the origin of this <i>WritableBuffer</i>
* @param capacityBytes the <i>capacity</i> of the returned region in bytes
* @param byteOrder the given byte order
* @return a new <i>WritableBuffer</i> representing the defined writable region
* with the given offsetBytes, capacityBytes and byte order.
*/
- public abstract WritableBuffer writableRegion(long offsetBytes, long capacityBytes,
+ WritableBuffer writableRegion(long offsetBytes, long capacityBytes,
ByteOrder byteOrder);
//AS MEMORY
/**
- * Convert this WritableBuffer to a WritableMemoryImpl.
+ * Convert this WritableBuffer to a WritableMemory.
* If this object's capacity is zero, the returned object is effectively immutable and
* the backing storage and byte order are unspecified.
- * @return WritableMemoryImpl
+ * @return WritableMemory
*/
- public abstract WritableMemoryImpl asWritableMemory();
-
- //ACCESS PRIMITIVE HEAP ARRAYS for write
- //use WritableMemoryImpl and then asWritableBuffer().
- //END OF CONSTRUCTOR-TYPE METHODS
+ WritableMemory asWritableMemory();
//PRIMITIVE putX() and putXArray()
/**
@@ -181,15 +154,15 @@ public abstract class WritableBuffer extends Buffer {
* Increments the position by 1.
* @param value the value to put
*/
- public abstract void putBoolean(boolean value);
+ void putBoolean(boolean value);
/**
* Puts the boolean value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start.
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start.
* @param value the value to put
*/
- public abstract void putBoolean(long offsetBytes, boolean value);
+ void putBoolean(long offsetBytes, boolean value);
/**
* Puts the boolean array at the current position.
@@ -198,7 +171,7 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetBooleans offset in array units
* @param lengthBooleans number of array units to transfer
*/
- public abstract void putBooleanArray(boolean[] srcArray, int srcOffsetBooleans,
+ void putBooleanArray(boolean[] srcArray, int srcOffsetBooleans,
int lengthBooleans);
/**
@@ -206,15 +179,15 @@ public abstract class WritableBuffer extends Buffer {
* Increments the position by <i>Byte.BYTES</i>.
* @param value the value to put
*/
- public abstract void putByte(byte value);
+ void putByte(byte value);
/**
* Puts the byte value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putByte(long offsetBytes, byte value);
+ void putByte(long offsetBytes, byte value);
/**
* Puts the byte array at the current position.
@@ -223,22 +196,22 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetBytes offset in array units
* @param lengthBytes number of array units to transfer
*/
- public abstract void putByteArray(byte[] srcArray, int srcOffsetBytes, int lengthBytes);
+ void putByteArray(byte[] srcArray, int srcOffsetBytes, int lengthBytes);
/**
* Puts the char value at the current position.
* Increments the position by <i>Character.BYTES</i>.
* @param value the value to put
*/
- public abstract void putChar(char value);
+ void putChar(char value);
/**
* Puts the char value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putChar(long offsetBytes, char value);
+ void putChar(long offsetBytes, char value);
/**
* Puts the char array at the current position.
@@ -247,22 +220,22 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetChars offset in array units
* @param lengthChars number of array units to transfer
*/
- public abstract void putCharArray(char[] srcArray, int srcOffsetChars, int lengthChars);
+ void putCharArray(char[] srcArray, int srcOffsetChars, int lengthChars);
/**
* Puts the double value at the current position.
* Increments the position by <i>Double.BYTES</i>.
* @param value the value to put
*/
- public abstract void putDouble(double value);
+ void putDouble(double value);
/**
* Puts the double value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putDouble(long offsetBytes, double value);
+ void putDouble(long offsetBytes, double value);
/**
* Puts the double array at the current position.
@@ -271,22 +244,22 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetDoubles offset in array units
* @param lengthDoubles number of array units to transfer
*/
- public abstract void putDoubleArray(double[] srcArray, int srcOffsetDoubles, int lengthDoubles);
+ void putDoubleArray(double[] srcArray, int srcOffsetDoubles, int lengthDoubles);
/**
* Puts the float value at the current position.
* Increments the position by <i>Float.BYTES</i>.
* @param value the value to put
*/
- public abstract void putFloat(float value);
+ void putFloat(float value);
/**
* Puts the float value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putFloat(long offsetBytes, float value);
+ void putFloat(long offsetBytes, float value);
/**
* Puts the float array at the current position.
@@ -295,22 +268,22 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetFloats offset in array units
* @param lengthFloats number of array units to transfer
*/
- public abstract void putFloatArray(float[] srcArray, int srcOffsetFloats, int lengthFloats);
+ void putFloatArray(float[] srcArray, int srcOffsetFloats, int lengthFloats);
/**
* Puts the int value at the current position.
* Increments the position by <i>Integer.BYTES</i>.
* @param value the value to put
*/
- public abstract void putInt(int value);
+ void putInt(int value);
/**
* Puts the int value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putInt(long offsetBytes, int value);
+ void putInt(long offsetBytes, int value);
/**
* Puts the int array at the current position.
@@ -319,22 +292,22 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetInts offset in array units
* @param lengthInts number of array units to transfer
*/
- public abstract void putIntArray(int[] srcArray, int srcOffsetInts, int lengthInts);
+ void putIntArray(int[] srcArray, int srcOffsetInts, int lengthInts);
/**
* Puts the long value at the current position.
* Increments the position by <i>Long.BYTES</i>.
* @param value the value to put
*/
- public abstract void putLong(long value);
+ void putLong(long value);
/**
* Puts the long value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putLong(long offsetBytes, long value);
+ void putLong(long offsetBytes, long value);
/**
* Puts the long array at the current position.
@@ -343,22 +316,22 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetLongs offset in array units
* @param lengthLongs number of array units to transfer
*/
- public abstract void putLongArray(long[] srcArray, int srcOffsetLongs, int lengthLongs);
+ void putLongArray(long[] srcArray, int srcOffsetLongs, int lengthLongs);
/**
* Puts the short value at the current position.
* Increments the position by <i>Short.BYTES</i>.
* @param value the value to put
*/
- public abstract void putShort(short value);
+ void putShort(short value);
/**
* Puts the short value at the given offset.
* This does not change the position.
- * @param offsetBytes offset bytes relative to this <i>WritableMemoryImpl</i> start
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
* @param value the value to put
*/
- public abstract void putShort(long offsetBytes, short value);
+ void putShort(long offsetBytes, short value);
/**
* Puts the short array at the current position.
@@ -367,39 +340,36 @@ public abstract class WritableBuffer extends Buffer {
* @param srcOffsetShorts offset in array units
* @param lengthShorts number of array units to transfer
*/
- public abstract void putShortArray(short[] srcArray, int srcOffsetShorts, int lengthShorts);
+ void putShortArray(short[] srcArray, int srcOffsetShorts, int lengthShorts);
//OTHER WRITE METHODS
/**
* Returns the primitive backing array, otherwise null.
* @return the primitive backing array, otherwise null.
*/
- public abstract Object getArray();
+ Object getArray();
/**
* Clears all bytes of this Buffer from position to end to zero. The position will be set to end.
*/
- public abstract void clear();
+ void clear();
/**
* Fills this Buffer from position to end with the given byte value.
* The position will be set to <i>end</i>.
* @param value the given byte value
*/
- public abstract void fill(byte value);
+ void fill(byte value);
//OTHER WRITABLE API METHODS
/**
- * For Direct MemoryImpl only. Other types of backing resources will return null.
+ * For Direct Memory only. Other types of backing resources will return null.
* Gets the MemoryRequestServer object used by dynamic off-heap (Direct) memory objects
* to request additional memory.
- * Set using {@link WritableMemoryImpl#allocateDirect(long, MemoryRequestServer)}.
+ * Set using {@link WritableMemory#allocateDirect(long, MemoryRequestServer)}.
* If not explicity set, this returns the {@link DefaultMemoryRequestServer}.
* @return the MemoryRequestServer object (if direct memory) or null.
*/
- @Override
- public MemoryRequestServer getMemoryRequestServer() {
- return null;
- }
+ public MemoryRequestServer getMemoryRequestServer();
}
diff --git a/src/main/java/org/apache/datasketches/memory/WritableMemory.java b/src/main/java/org/apache/datasketches/memory/WritableMemory.java
index 9b53b65..1f96323 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableMemory.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableMemory.java
@@ -24,7 +24,6 @@ import java.io.File;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.WritableBuffer;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
public interface WritableMemory extends Memory {
@@ -41,8 +40,8 @@ public interface WritableMemory extends Memory {
* @param byteBuf the given ByteBuffer
* @return a new WritableMemory for write operations on the given ByteBuffer.
*/
- static WritableMemory writableWrap(final ByteBuffer byteBuf) {
- return WritableMemoryImpl.writableWrap(byteBuf);
+ static WritableMemory writableWrap(ByteBuffer byteBuf) {
+ return WritableMemoryImpl.writableWrap(byteBuf, byteBuf.order());
}
/**
@@ -58,7 +57,7 @@ public interface WritableMemory extends Memory {
* state of the given ByteBuffer
* @return a new WritableMemory for write operations on the given ByteBuffer.
*/
- static WritableMemory writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ static WritableMemory writableWrap(ByteBuffer byteBuf, ByteOrder byteOrder) {
return WritableMemoryImpl.writableWrap(byteBuf, byteOrder);
}
@@ -74,7 +73,7 @@ public interface WritableMemory extends Memory {
* @return WritableMapHandle for managing the mapped Memory.
* Please read Javadocs for {@link Handle}.
*/
- static WritableMapHandle writableMap(final File file) {
+ static WritableMapHandle writableMap(File file) {
return WritableMemoryImpl.writableMap(file);
}
@@ -91,8 +90,7 @@ public interface WritableMemory extends Memory {
* @return WritableMapHandle for managing the mapped Memory.
* Please read Javadocs for {@link Handle}.
*/
- static WritableMapHandle writableMap(final File file, final long fileOffsetBytes,
- final long capacityBytes, final ByteOrder byteOrder) {
+ static WritableMapHandle writableMap(File file, long fileOffsetBytes, long capacityBytes, ByteOrder byteOrder) {
return WritableMemoryImpl.writableMap(file, fileOffsetBytes, capacityBytes, byteOrder);
}
@@ -115,7 +113,7 @@ public interface WritableMemory extends Memory {
* @return WritableDirectHandle for this off-heap resource.
* Please read Javadocs for {@link Handle}.
*/
- static WritableDirectHandle allocateDirect(final long capacityBytes) {
+ static WritableDirectHandle allocateDirect(long capacityBytes) {
return WritableMemoryImpl.allocateDirect(capacityBytes);
}
@@ -135,7 +133,7 @@ public interface WritableMemory extends Memory {
* @return WritableHandle for this off-heap resource.
* Please read Javadocs for {@link Handle}.
*/
- static WritableDirectHandle allocateDirect(final long capacityBytes, final MemoryRequestServer memReqSvr) {
+ static WritableDirectHandle allocateDirect(long capacityBytes, MemoryRequestServer memReqSvr) {
return WritableMemoryImpl.allocateDirect(capacityBytes, memReqSvr);
}
@@ -220,7 +218,7 @@ public interface WritableMemory extends Memory {
* @param capacityBytes the given capacity in bytes.
* @return a new WritableMemory for write operations on a new byte array.
*/
- static WritableMemory allocate(final int capacityBytes) {
+ static WritableMemory allocate(int capacityBytes) {
return WritableMemoryImpl.allocate(capacityBytes);
}
@@ -232,7 +230,7 @@ public interface WritableMemory extends Memory {
* @param byteOrder the given byte order to allocate new Memory object with.
* @return a new WritableMemory for write operations on a new byte array.
*/
- static WritableMemory allocate(final int capacityBytes, final ByteOrder byteOrder) {
+ static WritableMemory allocate(int capacityBytes, ByteOrder byteOrder) {
return WritableMemoryImpl.allocate(capacityBytes, byteOrder);
}
@@ -247,7 +245,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final boolean[] arr) {
+ static WritableMemory writableWrap(boolean[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
@@ -261,7 +259,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final byte[] arr) {
+ static WritableMemory writableWrap(byte[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
@@ -276,7 +274,7 @@ public interface WritableMemory extends Memory {
* @param byteOrder the byte order to be used
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final byte[] arr, final ByteOrder byteOrder) {
+ static WritableMemory writableWrap(byte[] arr, ByteOrder byteOrder) {
return WritableMemoryImpl.writableWrap(arr, byteOrder);
}
@@ -293,8 +291,8 @@ public interface WritableMemory extends Memory {
* @param byteOrder the byte order to be used
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final byte[] arr, final int offsetBytes, final int lengthBytes,
- final ByteOrder byteOrder) {
+ static WritableMemory writableWrap(byte[] arr, int offsetBytes, int lengthBytes,
+ ByteOrder byteOrder) {
return WritableMemoryImpl.writableWrap(arr, offsetBytes, lengthBytes, byteOrder);
}
@@ -308,7 +306,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final char[] arr) {
+ static WritableMemory writableWrap(char[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
@@ -322,7 +320,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final short[] arr) {
+ static WritableMemory writableWrap(short[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
@@ -336,7 +334,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final int[] arr) {
+ static WritableMemory writableWrap(int[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
@@ -350,7 +348,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final long[] arr) {
+ static WritableMemory writableWrap(long[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
@@ -364,7 +362,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final float[] arr) {
+ static WritableMemory writableWrap(float[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
@@ -378,7 +376,7 @@ public interface WritableMemory extends Memory {
* @param arr the given primitive array.
* @return a new WritableMemory for write operations on the given primitive array.
*/
- static WritableMemory writableWrap(final double[] arr) {
+ static WritableMemory writableWrap(double[] arr) {
return WritableMemoryImpl.writableWrap(arr);
}
//END OF CONSTRUCTOR-TYPE METHODS
@@ -398,8 +396,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetBooleans offset in array units
* @param lengthBooleans number of array units to transfer
*/
- void putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffsetBooleans,
- int lengthBooleans);
+ void putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffsetBooleans, int lengthBooleans);
/**
* Puts the byte value at the given offset
@@ -415,8 +412,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetBytes offset in array units
* @param lengthBytes number of array units to transfer
*/
- void putByteArray(long offsetBytes, byte[] srcArray, int srcOffsetBytes,
- int lengthBytes);
+ void putByteArray(long offsetBytes, byte[] srcArray, int srcOffsetBytes, int lengthBytes);
/**
* Puts the char value at the given offset
@@ -432,8 +428,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetChars offset in array units
* @param lengthChars number of array units to transfer
*/
- void putCharArray(long offsetBytes, char[] srcArray, int srcOffsetChars,
- int lengthChars);
+ void putCharArray(long offsetBytes, char[] srcArray, int srcOffsetChars, int lengthChars);
/**
* Encodes characters from the given CharSequence into UTF-8 bytes and puts them into this
@@ -463,8 +458,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetDoubles offset in array units
* @param lengthDoubles number of array units to transfer
*/
- void putDoubleArray(long offsetBytes, double[] srcArray,
- final int srcOffsetDoubles, final int lengthDoubles);
+ void putDoubleArray(long offsetBytes, double[] srcArray, int srcOffsetDoubles, int lengthDoubles);
/**
* Puts the float value at the given offset
@@ -480,8 +474,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetFloats offset in array units
* @param lengthFloats number of array units to transfer
*/
- void putFloatArray(long offsetBytes, float[] srcArray,
- final int srcOffsetFloats, final int lengthFloats);
+ void putFloatArray(long offsetBytes, float[] srcArray, int srcOffsetFloats, int lengthFloats);
/**
* Puts the int value at the given offset
@@ -497,8 +490,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetInts offset in array units
* @param lengthInts number of array units to transfer
*/
- void putIntArray(long offsetBytes, int[] srcArray,
- final int srcOffsetInts, final int lengthInts);
+ void putIntArray(long offsetBytes, int[] srcArray, int srcOffsetInts, int lengthInts);
/**
* Puts the long value at the given offset
@@ -514,8 +506,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetLongs offset in array units
* @param lengthLongs number of array units to transfer
*/
- void putLongArray(long offsetBytes, long[] srcArray,
- final int srcOffsetLongs, final int lengthLongs);
+ void putLongArray(long offsetBytes, long[] srcArray, int srcOffsetLongs, int lengthLongs);
/**
* Puts the short value at the given offset
@@ -531,8 +522,7 @@ public interface WritableMemory extends Memory {
* @param srcOffsetShorts offset in array units
* @param lengthShorts number of array units to transfer
*/
- void putShortArray(long offsetBytes, short[] srcArray,
- final int srcOffsetShorts, final int lengthShorts);
+ void putShortArray(long offsetBytes, short[] srcArray, int srcOffsetShorts, int lengthShorts);
//Atomic Methods
/**
@@ -621,12 +611,4 @@ public interface WritableMemory extends Memory {
*/
MemoryRequestServer getMemoryRequestServer();
-
-
-
-
-
-
}
-
-
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableBufferImpl.java
index 2e631e7..1c798c3 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableBufferImpl.java
@@ -23,7 +23,7 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableBuffer} for ByteBuffer, non-native byte order.
+ * Implementation of {@link WritableBufferImpl} for ByteBuffer, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BBWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBWritableBufferImpl.java
index bf0d2ee..d924f9a 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BBWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBWritableBufferImpl.java
@@ -23,12 +23,12 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableBuffer} for ByteBuffer, native byte order.
+ * Implementation of {@link WritableBufferImpl} for ByteBuffer, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class BBWritableBufferImpl extends WritableBufferImpl {
+final class BBWritableBufferImpl extends NativeWritableBufferImpl {
private static final int id = BUFFER | NATIVE | BYTEBUF;
private final Object unsafeObj;
private final long nativeBaseOffset; //used to compute cumBaseOffset
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java b/src/main/java/org/apache/datasketches/memory/internal/BaseBufferImpl.java
similarity index 64%
rename from src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
rename to src/main/java/org/apache/datasketches/memory/internal/BaseBufferImpl.java
index 901002b..1b58501 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseBufferImpl.java
@@ -19,8 +19,10 @@
package org.apache.datasketches.memory.internal;
+import org.apache.datasketches.memory.BaseBuffer;
+
/**
- * A new positional API. This is different from and simpler than Java Buffer positional approach.
+ * A new positional API. This is different from and simpler than Java BufferImpl positional approach.
* <ul><li>All based on longs instead of ints.</li>
* <li>Eliminated "mark". Rarely used and confusing with its silent side effects.</li>
* <li>The invariants are {@code 0 <= start <= position <= end <= capacity}.</li>
@@ -36,129 +38,78 @@ package org.apache.datasketches.memory.internal;
*
* @author Lee Rhodes
*/
-public abstract class BaseBuffer extends BaseStateImpl {
+public abstract class BaseBufferImpl extends BaseStateImpl implements BaseBuffer {
private long capacity;
private long start = 0;
private long pos = 0;
private long end;
//Pass-through ctor
- BaseBuffer(final Object unsafeObj, final long nativeBaseOffset,
+ BaseBufferImpl(final Object unsafeObj, final long nativeBaseOffset,
final long regionOffset, final long capacityBytes) {
super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
capacity = end = capacityBytes;
}
- /**
- * Increments the current position by the given increment.
- * Asserts that the resource is valid and that the positional invariants are not violated,
- * otherwise, if asserts are enabled throws an {@link AssertionError}.
- * @param increment the given increment
- * @return BaseBuffer
- */
- public final BaseBuffer incrementPosition(final long increment) {
+ @Override
+ public final BaseBufferImpl incrementPosition(final long increment) {
incrementAndAssertPositionForRead(pos, increment);
return this;
}
- /**
- * Increments the current position by the given increment.
- * Checks that the resource is valid and that the positional invariants are not violated,
- * otherwise throws an {@link IllegalArgumentException}.
- * @param increment the given increment
- * @return BaseBuffer
- */
- public final BaseBuffer incrementAndCheckPosition(final long increment) {
+ @Override
+ public final BaseBufferImpl incrementAndCheckPosition(final long increment) {
incrementAndCheckPositionForRead(pos, increment);
return this;
}
- /**
- * Gets the end position
- * @return the end position
- */
+ @Override
public final long getEnd() {
return end;
}
- /**
- * Gets the current position
- * @return the current position
- */
+ @Override
public final long getPosition() {
return pos;
}
- /**
- * Gets start position
- * @return start position
- */
+ @Override
public final long getStart() {
return start;
}
- /**
- * The number of elements remaining between the current position and the end position
- * @return {@code (end - position)}
- */
+ @Override
public final long getRemaining() {
return end - pos;
}
- /**
- * Returns true if there are elements remaining between the current position and the end position
- * @return {@code (end - position) > 0}
- */
+ @Override
public final boolean hasRemaining() {
return (end - pos) > 0;
}
- /**
- * Resets the current position to the start position,
- * This does not modify any data.
- * @return BaseBuffer
- */
- public final BaseBuffer resetPosition() {
+ @Override
+ public final BaseBufferImpl resetPosition() {
pos = start;
return this;
}
- /**
- * Sets the current position.
- * Asserts that the positional invariants are not violated,
- * otherwise, if asserts are enabled throws an {@link AssertionError}.
- * @param position the given current position.
- * @return BaseBuffer
- */
- public final BaseBuffer setPosition(final long position) {
+ @Override
+ public final BaseBufferImpl setPosition(final long position) {
assertInvariants(start, position, end, capacity);
pos = position;
return this;
}
- /**
- * Sets the current position.
- * Checks that the positional invariants are not violated,
- * otherwise, throws an {@link IllegalArgumentException}.
- * @param position the given current position.
- * @return BaseBuffer
- */
- public final BaseBuffer setAndCheckPosition(final long position) {
+ @Override
+ public final BaseBufferImpl setAndCheckPosition(final long position) {
checkInvariants(start, position, end, capacity);
pos = position;
return this;
}
- /**
- * Sets start position, current position, and end position.
- * Asserts that the positional invariants are not violated,
- * otherwise, if asserts are enabled throws an {@link AssertionError}.
- * @param start the start position in the buffer
- * @param position the current position between the start and end
- * @param end the end position in the buffer
- * @return BaseBuffer
- */
- public final BaseBuffer setStartPositionEnd(final long start, final long position,
+ @Override
+ public final BaseBufferImpl setStartPositionEnd(final long start, final long position,
final long end) {
assertInvariants(start, position, end, capacity);
this.start = start;
@@ -167,16 +118,8 @@ public abstract class BaseBuffer extends BaseStateImpl {
return this;
}
- /**
- * Sets start position, current position, and end position.
- * Checks that the positional invariants are not violated,
- * otherwise, throws an {@link IllegalArgumentException}.
- * @param start the start position in the buffer
- * @param position the current position between the start and end
- * @param end the end position in the buffer
- * @return BaseBuffer
- */
- public final BaseBuffer setAndCheckStartPositionEnd(final long start, final long position,
+ @Override
+ public final BaseBufferImpl setAndCheckStartPositionEnd(final long start, final long position,
final long end) {
checkInvariants(start, position, end, capacity);
this.start = start;
@@ -195,7 +138,7 @@ public abstract class BaseBuffer extends BaseStateImpl {
final void incrementAndAssertPositionForWrite(final long position, final long increment) {
assertValid();
- assert !isReadOnly() : "Buffer is read-only.";
+ assert !isReadOnly() : "BufferImpl is read-only.";
final long newPos = position + increment;
assertInvariants(start, newPos, end, capacity);
pos = newPos;
@@ -218,7 +161,7 @@ public abstract class BaseBuffer extends BaseStateImpl {
final void checkValidForWrite() {
checkValid();
if (isReadOnly()) {
- throw new ReadOnlyException("Buffer is read-only.");
+ throw new ReadOnlyException("BufferImpl is read-only.");
}
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
index 8855c99..d0c3524 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
@@ -33,7 +33,7 @@ import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.BaseState;
/**
- * Keeps key configuration state for MemoryImpl and Buffer plus some common static variables
+ * Keeps key configuration state for MemoryImpl and BufferImpl plus some common static variables
* and check methods.
*
* @author Lee Rhodes
@@ -162,7 +162,7 @@ public abstract class BaseStateImpl implements BaseState {
return cumBaseOffset_ + offsetBytes;
}
- //made public in WritableMemoryImpl and WritableBuffer, only implemented in Direct Leafs
+ //made public in WritableMemoryImpl and WritableBufferImpl, only implemented in Direct Leafs
abstract MemoryRequestServer getMemoryRequestServer();
//Overridden by ByteBuffer, Direct and Map leafs
@@ -187,7 +187,7 @@ public abstract class BaseStateImpl implements BaseState {
abstract int getTypeId();
//Overridden by Heap and ByteBuffer Leafs. Made public as getArray() in WritableMemoryImpl and
- // WritableBuffer
+ // WritableBufferImpl
Object getUnsafeObject() {
return null;
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
index 935b364..bfc3233 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
@@ -30,6 +30,8 @@ import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_IND
import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
+import org.apache.datasketches.memory.Buffer;
+
import java.nio.ByteOrder;
/*
@@ -46,15 +48,15 @@ import java.nio.ByteOrder;
*/
/**
- * Common base of native-ordered and non-native-ordered {@link WritableBuffer} implementations.
+ * Common base of native-ordered and non-native-ordered {@link WritableBufferImpl} implementations.
* Contains methods which are agnostic to the byte order.
*/
@SuppressWarnings({"restriction"})
-abstract class BaseWritableBufferImpl extends WritableBuffer {
+abstract class BaseWritableBufferImpl extends WritableBufferImpl {
final BaseWritableMemoryImpl originMemory;
//Static variable for cases where byteBuf/array sizes are zero
- final static WritableBufferImpl ZERO_SIZE_BUFFER;
+ final static NativeWritableBufferImpl ZERO_SIZE_BUFFER;
static {
final BaseWritableMemoryImpl mem = BaseWritableMemoryImpl.ZERO_SIZE_MEMORY;
@@ -71,40 +73,40 @@ abstract class BaseWritableBufferImpl extends WritableBuffer {
//REGIONS
@Override
- public Buffer region() {
+ public BufferImpl region() {
return writableRegionImpl(getPosition(), getEnd() - getPosition(), true, getTypeByteOrder());
}
@Override
- public Buffer region(final long offsetBytes, final long capacityBytes,
+ public BufferImpl region(final long offsetBytes, final long capacityBytes,
final ByteOrder byteOrder) {
- final Buffer buf = writableRegionImpl(offsetBytes, capacityBytes, true, byteOrder);
+ final BufferImpl buf = writableRegionImpl(offsetBytes, capacityBytes, true, byteOrder);
buf.setAndCheckStartPositionEnd(0, 0, capacityBytes);
return buf;
}
@Override
- public WritableBuffer writableRegion() {
+ public WritableBufferImpl writableRegion() {
return writableRegionImpl(getPosition(), getEnd() - getPosition(), false, getTypeByteOrder());
}
@Override
- public WritableBuffer writableRegion(final long offsetBytes, final long capacityBytes,
+ public WritableBufferImpl writableRegion(final long offsetBytes, final long capacityBytes,
final ByteOrder byteOrder) {
- final WritableBuffer wbuf = writableRegionImpl(offsetBytes, capacityBytes, false, byteOrder);
+ final WritableBufferImpl wbuf = writableRegionImpl(offsetBytes, capacityBytes, false, byteOrder);
wbuf.setAndCheckStartPositionEnd(0, 0, capacityBytes);
return wbuf;
}
- WritableBuffer writableRegionImpl(final long offsetBytes, final long capacityBytes,
+ WritableBufferImpl writableRegionImpl(final long offsetBytes, final long capacityBytes,
final boolean localReadOnly, final ByteOrder byteOrder) {
if (capacityBytes == 0) { return ZERO_SIZE_BUFFER; }
if (isReadOnly() && !localReadOnly) {
- throw new ReadOnlyException("Writable region of a read-only Buffer is not allowed.");
+ throw new ReadOnlyException("Writable region of a read-only BufferImpl is not allowed.");
}
checkValidAndBounds(offsetBytes, capacityBytes);
final boolean readOnly = isReadOnly() || localReadOnly;
- final WritableBuffer wbuf = toWritableRegion(offsetBytes, capacityBytes, readOnly, byteOrder);
+ final WritableBufferImpl wbuf = toWritableRegion(offsetBytes, capacityBytes, readOnly, byteOrder);
wbuf.setStartPositionEnd(0, 0, capacityBytes);
return wbuf;
}
@@ -114,31 +116,31 @@ abstract class BaseWritableBufferImpl extends WritableBuffer {
//DUPLICATES
@Override
- public Buffer duplicate() {
+ public BufferImpl duplicate() {
return writableDuplicateImpl(true, getTypeByteOrder());
}
@Override
- public Buffer duplicate(final ByteOrder byteOrder) {
+ public BufferImpl duplicate(final ByteOrder byteOrder) {
return writableDuplicateImpl(true, byteOrder);
}
@Override
- public WritableBuffer writableDuplicate() {
+ public WritableBufferImpl writableDuplicate() {
return writableDuplicateImpl(false, getTypeByteOrder());
}
@Override
- public WritableBuffer writableDuplicate(final ByteOrder byteOrder) {
+ public WritableBufferImpl writableDuplicate(final ByteOrder byteOrder) {
return writableDuplicateImpl(false, byteOrder);
}
- WritableBuffer writableDuplicateImpl(final boolean localReadOnly, final ByteOrder byteOrder) {
+ WritableBufferImpl writableDuplicateImpl(final boolean localReadOnly, final ByteOrder byteOrder) {
if (isReadOnly() && !localReadOnly) {
- throw new ReadOnlyException("Writable duplicate of a read-only Buffer is not allowed.");
+ throw new ReadOnlyException("Writable duplicate of a read-only BufferImpl is not allowed.");
}
final boolean readOnly = isReadOnly() || localReadOnly;
- final WritableBuffer wbuf = toDuplicate(readOnly, byteOrder);
+ final WritableBufferImpl wbuf = toDuplicate(readOnly, byteOrder);
wbuf.setStartPositionEnd(getStart(), getPosition(), getEnd());
return wbuf;
}
@@ -154,7 +156,7 @@ abstract class BaseWritableBufferImpl extends WritableBuffer {
@Override
public WritableMemoryImpl asWritableMemory() {
if (isReadOnly()) {
- throw new ReadOnlyException("Converting a read-only Buffer to a writable MemoryImpl is not allowed.");
+ throw new ReadOnlyException("Converting a read-only BufferImpl to a writable MemoryImpl is not allowed.");
}
return originMemory;
}
@@ -265,8 +267,8 @@ abstract class BaseWritableBufferImpl extends WritableBuffer {
@Override
public final int compareTo(final long thisOffsetBytes, final long thisLengthBytes,
final Buffer thatBuf, final long thatOffsetBytes, final long thatLengthBytes) {
- return CompareAndCopy.compare(this, thisOffsetBytes, thisLengthBytes,
- thatBuf, thatOffsetBytes, thatLengthBytes);
+ return CompareAndCopy.compare((BaseStateImpl)this, thisOffsetBytes, thisLengthBytes,
+ (BaseStateImpl)thatBuf, thatOffsetBytes, thatLengthBytes);
}
/*
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 872cc05..07df6b0 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
@@ -200,32 +200,32 @@ abstract class BaseWritableMemoryImpl extends WritableMemoryImpl {
//AS BUFFER
@Override
- public Buffer asBuffer() {
- return asWritableBufferImpl(true, getTypeByteOrder());
+ public BufferImpl asBuffer() {
+ return asWritableBuffer(true, getTypeByteOrder());
}
@Override
- public Buffer asBuffer(final ByteOrder byteOrder) {
- return asWritableBufferImpl(true, byteOrder);
+ public BufferImpl asBuffer(final ByteOrder byteOrder) {
+ return asWritableBuffer(true, byteOrder);
}
@Override
- public WritableBuffer asWritableBuffer() {
- return asWritableBufferImpl(false, getTypeByteOrder());
+ public WritableBufferImpl asWritableBuffer() {
+ return asWritableBuffer(false, getTypeByteOrder());
}
@Override
- public WritableBuffer asWritableBuffer(final ByteOrder byteOrder) {
- return asWritableBufferImpl(false, byteOrder);
+ public WritableBufferImpl asWritableBuffer(final ByteOrder byteOrder) {
+ return asWritableBuffer(false, byteOrder);
}
- WritableBuffer asWritableBufferImpl(final boolean localReadOnly, final ByteOrder byteOrder) {
+ WritableBufferImpl asWritableBuffer(final boolean localReadOnly, final ByteOrder byteOrder) {
if (isReadOnly() && !localReadOnly) {
throw new ReadOnlyException(
- "Converting a read-only MemoryImpl to a writable Buffer is not allowed.");
+ "Converting a read-only MemoryImpl to a writable BufferImpl is not allowed.");
}
final boolean readOnly = isReadOnly() || localReadOnly;
- final WritableBuffer wbuf = toWritableBuffer(readOnly, byteOrder);
+ final WritableBufferImpl wbuf = toWritableBuffer(readOnly, byteOrder);
wbuf.setStartPositionEnd(0, 0, getCapacity());
return wbuf;
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BufferImpl.java
new file mode 100644
index 0000000..482db82
--- /dev/null
+++ b/src/main/java/org/apache/datasketches/memory/internal/BufferImpl.java
@@ -0,0 +1,161 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.datasketches.memory.internal;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import org.apache.datasketches.memory.Buffer;
+
+/**
+ * Provides read-only, positional primitive and primitive array methods to any of the four resources
+ * mentioned in the package level documentation.
+ *
+ * @author Roman Leventov
+ * @author Lee Rhodes
+ *
+ * @see org.apache.datasketches.memory.internal
+ */
+public abstract class BufferImpl extends BaseBufferImpl implements Buffer {
+
+ //Pass-through ctor
+ BufferImpl(final Object unsafeObj, final long nativeBaseOffset,
+ final long regionOffset, final long capacityBytes) {
+ super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
+ }
+
+ //BYTE BUFFER
+ public static BufferImpl wrap(final ByteBuffer byteBuf) {
+ return wrap(byteBuf, byteBuf.order());
+ }
+
+ public static BufferImpl wrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ final BaseWritableMemoryImpl wmem =
+ BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, true, byteOrder);
+ final WritableBufferImpl wbuf = wmem.asWritableBuffer(true, byteOrder);
+ wbuf.setStartPositionEnd(0, byteBuf.position(), byteBuf.limit());
+ return wbuf;
+ }
+
+ //MAP
+ //Use MemoryImpl for mapping files and the asBuffer()
+
+ //DUPLICATES
+ @Override
+ public abstract BufferImpl duplicate();
+
+ @Override
+ public abstract BufferImpl duplicate(ByteOrder byteOrder);
+
+ //REGIONS
+ @Override
+ public abstract BufferImpl region();
+
+ @Override
+ public abstract BufferImpl region(long offsetBytes, long capacityBytes,
+ ByteOrder byteOrder);
+
+ //MEMORY
+ @Override
+ public abstract MemoryImpl asMemory();
+
+ //ACCESS PRIMITIVE HEAP ARRAYS for readOnly
+ // use MemoryImpl or WritableMemoryImpl and then asBuffer().
+ //END OF CONSTRUCTOR-TYPE METHODS
+
+ //PRIMITIVE getX() and getXArray()
+ @Override
+ public abstract boolean getBoolean();
+
+ @Override
+ public abstract boolean getBoolean(long offsetBytes);
+
+ @Override
+ public abstract void getBooleanArray(boolean[] dstArray, int dstOffsetBooleans,
+ int lengthBooleans);
+
+ @Override
+ public abstract byte getByte();
+
+ @Override
+ public abstract byte getByte(long offsetBytes);
+
+ @Override
+ public abstract void getByteArray(byte[] dstArray, int dstOffsetBytes, int lengthBytes);
+
+ @Override
+ public abstract char getChar();
+
+ @Override
+ public abstract char getChar(long offsetBytes);
+
+ @Override
+ public abstract void getCharArray(char[] dstArray, int dstOffsetChars, int lengthChars);
+
+ @Override
+ public abstract double getDouble();
+
+ @Override
+ public abstract double getDouble(long offsetBytes);
+
+ @Override
+ public abstract void getDoubleArray(double[] dstArray, int dstOffsetDoubles, int lengthDoubles);
+
+ @Override
+ public abstract float getFloat();
+
+ @Override
+ public abstract float getFloat(long offsetBytes);
+
+ @Override
+ public abstract void getFloatArray(float[] dstArray, int dstOffsetFloats, int lengthFloats);
+
+ @Override
+ public abstract int getInt();
+
+ @Override
+ public abstract int getInt(long offsetBytes);
+
+ @Override
+ public abstract void getIntArray(int[] dstArray, int dstOffsetInts, int lengthInts);
+
+ @Override
+ public abstract long getLong();
+
+ @Override
+ public abstract long getLong(long offsetBytes);
+
+ @Override
+ public abstract void getLongArray(long[] dstArray, int dstOffsetLongs, int lengthLongs);
+
+ @Override
+ public abstract short getShort();
+
+ @Override
+ public abstract short getShort(long offsetBytes);
+
+ @Override
+ public abstract void getShortArray(short[] dstArray, int dstOffsetShorts, int lengthShorts);
+
+ //SPECIAL PRIMITIVE READ METHODS: compareTo
+ @Override
+ public abstract int compareTo(long thisOffsetBytes, long thisLengthBytes, Buffer that,
+ long thatOffsetBytes, long thatLengthBytes);
+
+}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
index 089e576..b49e739 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
@@ -124,7 +124,7 @@ final class CompareAndCopy {
lengthBytes);
}
- //Used by all of the get/put array methods in Buffer and MemoryImpl classes
+ //Used by all of the get/put array methods in BufferImpl and MemoryImpl classes
static final void copyMemoryCheckingDifferentObject(final Object srcUnsafeObj,
final long srcAdd, final Object dstUnsafeObj, final long dstAdd, final long lengthBytes) {
if (srcUnsafeObj != dstUnsafeObj) {
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
index 4358d6b..5957fc6 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
@@ -24,7 +24,7 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.MemoryRequestServer;
/**
- * Implementation of {@link WritableBuffer} for direct memory, non-native byte order.
+ * Implementation of {@link WritableBufferImpl} for direct memory, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
diff --git a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
index 9b1a287..b5c3609 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
@@ -24,12 +24,12 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.MemoryRequestServer;
/**
- * Implementation of {@link WritableBuffer} for direct memory, native byte order.
+ * Implementation of {@link WritableBufferImpl} for direct memory, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class DirectWritableBufferImpl extends WritableBufferImpl {
+final class DirectWritableBufferImpl extends NativeWritableBufferImpl {
private static final int id = BUFFER | NATIVE | DIRECT;
private final long nativeBaseOffset; //used to compute cumBaseOffset
private final StepBoolean valid; //a reference only
diff --git a/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableBufferImpl.java
index f0f1fef..5a74126 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableBufferImpl.java
@@ -22,7 +22,7 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableBuffer} for heap-based, non-native byte order.
+ * Implementation of {@link WritableBufferImpl} for heap-based, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
diff --git a/src/main/java/org/apache/datasketches/memory/internal/HeapWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableBufferImpl.java
index e2d35b8..5a9316f 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/HeapWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableBufferImpl.java
@@ -22,12 +22,12 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableBuffer} for heap-based, native byte order.
+ * Implementation of {@link WritableBufferImpl} for heap-based, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class HeapWritableBufferImpl extends WritableBufferImpl {
+final class HeapWritableBufferImpl extends NativeWritableBufferImpl {
private static final int id = BUFFER | NATIVE | HEAP;
private final Object unsafeObj;
private final byte typeId;
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
index 59ca32d..0f135d5 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
@@ -22,7 +22,7 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableBuffer} for map memory, non-native byte order.
+ * Implementation of {@link WritableBufferImpl} for map memory, non-native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
index 4a9be74..eafe417 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
@@ -22,12 +22,12 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
/**
- * Implementation of {@link WritableBuffer} for map memory, native byte order.
+ * Implementation of {@link WritableBufferImpl} for map memory, native byte order.
*
* @author Roman Leventov
* @author Lee Rhodes
*/
-final class MapWritableBufferImpl extends WritableBufferImpl {
+final class MapWritableBufferImpl extends NativeWritableBufferImpl {
private static final int id = BUFFER | NATIVE | MAP;
private final long nativeBaseOffset; //used to compute cumBaseOffset
private final StepBoolean valid; //a reference only
diff --git a/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
index 4761ec6..e758318 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
@@ -81,10 +81,10 @@ public abstract class MemoryImpl extends BaseStateImpl implements Memory {
//AS BUFFER
@Override
- public abstract Buffer asBuffer();
+ public abstract BufferImpl asBuffer();
@Override
- public abstract Buffer asBuffer(ByteOrder byteOrder);
+ public abstract BufferImpl asBuffer(ByteOrder byteOrder);
//UNSAFE BYTE BUFFER VIEW
@Override
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java
similarity index 98%
copy from src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
copy to src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java
index fb84563..d3f5f59 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java
@@ -50,16 +50,16 @@ import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
*/
/**
- * Implementation of {@link WritableBuffer} for native endian byte order. Non-native variant is
+ * Implementation of {@link WritableBufferImpl} for native endian byte order. Non-native variant is
* {@link NonNativeWritableBufferImpl}.
* @author Roman Leventov
* @author Lee Rhodes
*/
@SuppressWarnings({"restriction"})
-abstract class WritableBufferImpl extends BaseWritableBufferImpl {
+abstract class NativeWritableBufferImpl extends BaseWritableBufferImpl {
//Pass-through ctor
- WritableBufferImpl(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
+ NativeWritableBufferImpl(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
final long capacityBytes, final BaseWritableMemoryImpl originMemory) {
super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes, originMemory);
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
index 818a6ee..6073fce 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
@@ -43,8 +43,8 @@ import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
*/
/**
- * Implementation of {@link WritableBuffer} for non-native endian byte order. Native variant is
- * {@link WritableBufferImpl}.
+ * Implementation of {@link WritableBufferImpl} for non-native endian byte order. Native variant is
+ * {@link NativeWritableBufferImpl}.
* @author Roman Leventov
* @author Lee Rhodes
*/
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
index fb84563..4f53d40 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
@@ -19,356 +19,157 @@
package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
-/*
- * Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill,
- * compareTo, etc., use hard checks (check*() and incrementAndCheck*() methods), which execute at
- * runtime and throw exceptions if violated. The cost of the runtime checks are minor compared to
- * the rest of the work these methods are doing.
- *
- * <p>The light weight methods, such as put/get primitives, use asserts (assert*() and
- * incrementAndAssert*() methods), which only execute when asserts are enabled and JIT will remove
- * them entirely from production runtime code. The offset versions of the light weight methods will
- * simplify to a single unsafe call, which is further simplified by JIT to an intrinsic that is
- * often a single CPU instruction.
- */
+import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.WritableBuffer;
/**
- * Implementation of {@link WritableBuffer} for native endian byte order. Non-native variant is
- * {@link NonNativeWritableBufferImpl}.
+ * Provides read and write, positional primitive and primitive array access to any of the four
+ * resources mentioned at the package level.
+ *
* @author Roman Leventov
* @author Lee Rhodes
*/
-@SuppressWarnings({"restriction"})
-abstract class WritableBufferImpl extends BaseWritableBufferImpl {
+public abstract class WritableBufferImpl extends BufferImpl implements WritableBuffer {
//Pass-through ctor
- WritableBufferImpl(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
- final long capacityBytes, final BaseWritableMemoryImpl originMemory) {
- super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes, originMemory);
+ WritableBufferImpl(final Object unsafeObj, final long nativeBaseOffset,
+ final long regionOffset, final long capacityBytes) {
+ super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
}
- //PRIMITIVE getX() and getXArray()
- @Override
- public char getChar() {
- return getNativeOrderedChar();
+ //BYTE BUFFER
+ public static WritableBufferImpl writableWrap(final ByteBuffer byteBuf) {
+ return writableWrap(byteBuf, byteBuf.order());
}
- @Override
- public char getChar(final long offsetBytes) {
- return getNativeOrderedChar(offsetBytes);
+ public static WritableBufferImpl writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ final BaseWritableMemoryImpl wmem =
+ BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteOrder);
+ final WritableBufferImpl wbuf = wmem.asWritableBuffer(false, byteOrder);
+ wbuf.setStartPositionEnd(0, byteBuf.position(), byteBuf.limit());
+ return wbuf;
}
- @Override
- public void getCharArray(final char[] dstArray, final int dstOffsetChars, final int lengthChars) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- incrementAndCheckPositionForRead(pos, copyBytes);
- checkBounds(dstOffsetChars, lengthChars, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(pos),
- dstArray,
- ARRAY_CHAR_BASE_OFFSET + (((long) dstOffsetChars) << CHAR_SHIFT),
- copyBytes);
- }
+ //MAP
+ //Use WritableMemoryImpl for mapping files and then asWritableBuffer()
+
+ //ALLOCATE DIRECT
+ //Use WritableMemoryImpl to allocate direct memory and then asWritableBuffer().
+ //DUPLICATES
@Override
- public double getDouble() {
- final long pos = getPosition();
- incrementAndAssertPositionForRead(pos, ARRAY_DOUBLE_INDEX_SCALE);
- return unsafe.getDouble(getUnsafeObject(), getCumulativeOffset(pos));
- }
+ public abstract WritableBufferImpl writableDuplicate();
@Override
- public double getDouble(final long offsetBytes) {
- assertValidAndBoundsForRead(offsetBytes, ARRAY_DOUBLE_INDEX_SCALE);
- return unsafe.getDouble(getUnsafeObject(), getCumulativeOffset(offsetBytes));
- }
+ public abstract WritableBufferImpl writableDuplicate(ByteOrder byteOrder);
+ //REGIONS
@Override
- public void getDoubleArray(final double[] dstArray, final int dstOffsetDoubles,
- final int lengthDoubles) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- incrementAndCheckPositionForRead(pos, copyBytes);
- checkBounds(dstOffsetDoubles, lengthDoubles, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(pos),
- dstArray,
- ARRAY_DOUBLE_BASE_OFFSET + (((long) dstOffsetDoubles) << DOUBLE_SHIFT),
- copyBytes);
- }
+ public abstract WritableBufferImpl writableRegion();
@Override
- public float getFloat() {
- final long pos = getPosition();
- incrementAndAssertPositionForRead(pos, ARRAY_FLOAT_INDEX_SCALE);
- return unsafe.getFloat(getUnsafeObject(), getCumulativeOffset(pos));
- }
+ public abstract WritableBufferImpl writableRegion(long offsetBytes, long capacityBytes,
+ ByteOrder byteOrder);
+ //AS MEMORY
@Override
- public float getFloat(final long offsetBytes) {
- assertValidAndBoundsForRead(offsetBytes, ARRAY_FLOAT_INDEX_SCALE);
- return unsafe.getFloat(getUnsafeObject(), getCumulativeOffset(offsetBytes));
- }
+ public abstract WritableMemoryImpl asWritableMemory();
+
+ //ACCESS PRIMITIVE HEAP ARRAYS for write
+ //use WritableMemoryImpl and then asWritableBuffer().
+ //END OF CONSTRUCTOR-TYPE METHODS
+ //PRIMITIVE putX() and putXArray()
@Override
- public void getFloatArray(final float[] dstArray, final int dstOffsetFloats,
- final int lengthFloats) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- incrementAndCheckPositionForRead(pos, copyBytes);
- checkBounds(dstOffsetFloats, lengthFloats, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(pos),
- dstArray,
- ARRAY_FLOAT_BASE_OFFSET + (((long) dstOffsetFloats) << FLOAT_SHIFT),
- copyBytes);
- }
+ public abstract void putBoolean(boolean value);
@Override
- public int getInt() {
- return getNativeOrderedInt();
- }
+ public abstract void putBoolean(long offsetBytes, boolean value);
@Override
- public int getInt(final long offsetBytes) {
- return getNativeOrderedInt(offsetBytes);
- }
+ public abstract void putBooleanArray(boolean[] srcArray, int srcOffsetBooleans,
+ int lengthBooleans);
@Override
- public void getIntArray(final int[] dstArray, final int dstOffsetInts, final int lengthInts) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- incrementAndCheckPositionForRead(pos, copyBytes);
- checkBounds(dstOffsetInts, lengthInts, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(pos),
- dstArray,
- ARRAY_INT_BASE_OFFSET + (((long) dstOffsetInts) << INT_SHIFT),
- copyBytes);
- }
+ public abstract void putByte(byte value);
@Override
- public long getLong() {
- return getNativeOrderedLong();
- }
+ public abstract void putByte(long offsetBytes, byte value);
@Override
- public long getLong(final long offsetBytes) {
- return getNativeOrderedLong(offsetBytes);
- }
+ public abstract void putByteArray(byte[] srcArray, int srcOffsetBytes, int lengthBytes);
@Override
- public void getLongArray(final long[] dstArray, final int dstOffsetLongs, final int lengthLongs) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- incrementAndCheckPositionForRead(pos, copyBytes);
- checkBounds(dstOffsetLongs, lengthLongs, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(pos),
- dstArray,
- ARRAY_LONG_BASE_OFFSET + (((long) dstOffsetLongs) << LONG_SHIFT),
- copyBytes);
- }
+ public abstract void putChar(char value);
@Override
- public short getShort() {
- return getNativeOrderedShort();
- }
+ public abstract void putChar(long offsetBytes, char value);
@Override
- public short getShort(final long offsetBytes) {
- return getNativeOrderedShort(offsetBytes);
- }
+ public abstract void putCharArray(char[] srcArray, int srcOffsetChars, int lengthChars);
@Override
- public void getShortArray(final short[] dstArray, final int dstOffsetShorts,
- final int lengthShorts) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- incrementAndCheckPositionForRead(pos, copyBytes);
- checkBounds(dstOffsetShorts, lengthShorts, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(pos),
- dstArray,
- ARRAY_SHORT_BASE_OFFSET + (((long) dstOffsetShorts) << SHORT_SHIFT),
- copyBytes);
- }
+ public abstract void putDouble(double value);
- //PRIMITIVE putX() and putXArray()
@Override
- public void putChar(final char value) {
- putNativeOrderedChar(value);
- }
+ public abstract void putDouble(long offsetBytes, double value);
@Override
- public void putChar(final long offsetBytes, final char value) {
- putNativeOrderedChar(offsetBytes, value);
- }
+ public abstract void putDoubleArray(double[] srcArray, int srcOffsetDoubles, int lengthDoubles);
@Override
- public void putCharArray(final char[] srcArray, final int srcOffsetChars, final int lengthChars) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- incrementAndCheckPositionForWrite(pos, copyBytes);
- checkBounds(srcOffsetChars, lengthChars, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_CHAR_BASE_OFFSET + (((long) srcOffsetChars) << CHAR_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(pos),
- copyBytes);
- }
+ public abstract void putFloat(float value);
@Override
- public void putDouble(final double value) {
- final long pos = getPosition();
- incrementAndAssertPositionForWrite(pos, ARRAY_DOUBLE_INDEX_SCALE);
- unsafe.putDouble(getUnsafeObject(), getCumulativeOffset(pos), value);
- }
+ public abstract void putFloat(long offsetBytes, float value);
@Override
- public void putDouble(final long offsetBytes, final double value) {
- assertValidAndBoundsForWrite(offsetBytes, ARRAY_DOUBLE_INDEX_SCALE);
- unsafe.putDouble(getUnsafeObject(), getCumulativeOffset(offsetBytes), value);
- }
+ public abstract void putFloatArray(float[] srcArray, int srcOffsetFloats, int lengthFloats);
@Override
- public void putDoubleArray(final double[] srcArray, final int srcOffsetDoubles,
- final int lengthDoubles) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- incrementAndCheckPositionForWrite(pos, copyBytes);
- checkBounds(srcOffsetDoubles, lengthDoubles, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_DOUBLE_BASE_OFFSET + (((long) srcOffsetDoubles) << DOUBLE_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(pos),
- copyBytes);
- }
+ public abstract void putInt(int value);
@Override
- public void putFloat(final float value) {
- final long pos = getPosition();
- incrementAndAssertPositionForWrite(pos, ARRAY_FLOAT_INDEX_SCALE);
- unsafe.putFloat(getUnsafeObject(), getCumulativeOffset(pos), value);
- }
+ public abstract void putInt(long offsetBytes, int value);
@Override
- public void putFloat(final long offsetBytes, final float value) {
- assertValidAndBoundsForWrite(offsetBytes, ARRAY_FLOAT_INDEX_SCALE);
- unsafe.putFloat(getUnsafeObject(), getCumulativeOffset(offsetBytes), value);
- }
+ public abstract void putIntArray(int[] srcArray, int srcOffsetInts, int lengthInts);
@Override
- public void putFloatArray(final float[] srcArray, final int srcOffsetFloats,
- final int lengthFloats) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- incrementAndCheckPositionForWrite(pos, copyBytes);
- checkBounds(srcOffsetFloats, lengthFloats, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_FLOAT_BASE_OFFSET + (((long) srcOffsetFloats) << FLOAT_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(pos),
- copyBytes);
- }
+ public abstract void putLong(long value);
@Override
- public void putInt(final int value) {
- putNativeOrderedInt(value);
- }
+ public abstract void putLong(long offsetBytes, long value);
@Override
- public void putInt(final long offsetBytes, final int value) {
- putNativeOrderedInt(offsetBytes, value);
- }
+ public abstract void putLongArray(long[] srcArray, int srcOffsetLongs, int lengthLongs);
@Override
- public void putIntArray(final int[] srcArray, final int srcOffsetInts, final int lengthInts) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- incrementAndCheckPositionForWrite(pos, copyBytes);
- checkBounds(srcOffsetInts, lengthInts, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_INT_BASE_OFFSET + (((long) srcOffsetInts) << INT_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(pos),
- copyBytes);
- }
+ public abstract void putShort(short value);
@Override
- public void putLong(final long value) {
- putNativeOrderedLong(value);
- }
+ public abstract void putShort(long offsetBytes, short value);
@Override
- public void putLong(final long offsetBytes, final long value) {
- putNativeOrderedLong(offsetBytes, value);
- }
+ public abstract void putShortArray(short[] srcArray, int srcOffsetShorts, int lengthShorts);
+ //OTHER WRITE METHODS
@Override
- public void putLongArray(final long[] srcArray, final int srcOffsetLongs, final int lengthLongs) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- incrementAndCheckPositionForWrite(pos, copyBytes);
- checkBounds(srcOffsetLongs, lengthLongs, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_LONG_BASE_OFFSET + (((long) srcOffsetLongs) << LONG_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(pos),
- copyBytes);
- }
+ public abstract Object getArray();
@Override
- public void putShort(final short value) {
- putNativeOrderedShort(value);
- }
+ public abstract void clear();
@Override
- public void putShort(final long offsetBytes, final short value) {
- putNativeOrderedShort(offsetBytes, value);
- }
+ public abstract void fill(byte value);
+ //OTHER WRITABLE API METHODS
@Override
- public void putShortArray(final short[] srcArray, final int srcOffsetShorts,
- final int lengthShorts) {
- final long pos = getPosition();
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- incrementAndCheckPositionForWrite(pos, copyBytes);
- checkBounds(srcOffsetShorts, lengthShorts, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_SHORT_BASE_OFFSET + (((long) srcOffsetShorts) << SHORT_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(pos),
- copyBytes);
+ public MemoryRequestServer getMemoryRequestServer() {
+ return null;
}
+
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
index 4bc97c4..696d765 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
@@ -91,10 +91,10 @@ public abstract class WritableMemoryImpl extends MemoryImpl implements WritableM
//AS BUFFER
@Override
- public abstract WritableBuffer asWritableBuffer();
+ public abstract WritableBufferImpl asWritableBuffer();
@Override
- public abstract WritableBuffer asWritableBuffer(ByteOrder byteOrder);
+ public abstract WritableBufferImpl asWritableBuffer(ByteOrder byteOrder);
//ALLOCATE HEAP VIA AUTOMATIC BYTE ARRAY
public static WritableMemoryImpl allocate(final int capacityBytes) {
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 2f8471a..d1ed819 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
@@ -28,8 +28,8 @@
*
* <ul><li>Two different access APIs: read-only {@link org.apache.datasketches.memory.internal.MemoryImpl} and
* {@link org.apache.datasketches.memory.internal.WritableMemoryImpl} for absolute offset access,
- * and read-only {@link org.apache.datasketches.memory.internal.Buffer} and
- * {@link org.apache.datasketches.memory.internal.WritableBuffer}
+ * and read-only {@link org.apache.datasketches.memory.internal.BufferImpl} and
+ * {@link org.apache.datasketches.memory.internal.WritableBufferImpl}
* for relative positional access (similar to ByteBuffer).</li>
*
* <li>Clean separation of Read-only API from Writable API, which makes writable versus read-only
@@ -71,7 +71,7 @@
*
* <p>The two different access APIs are:</p>
* <ul><li><i>MemoryImpl, WritableMemoryImpl</i>: Absolute offset addressing into a resource.</li>
- * <li><i>Buffer, WritableBuffer</i>: Position relative addressing into a resource.</li>
+ * <li><i>BufferImpl, WritableBufferImpl</i>: Position relative addressing into a resource.</li>
* </ul>
*
* <p>In addition, all combinations of access APIs and backing resources can be accessed via
@@ -149,10 +149,10 @@
* hard-to-find bug.</li>
* </ul>
*
- *<p>Moving back and forth between <i>MemoryImpl</i> and <i>Buffer</i>:</p>
+ *<p>Moving back and forth between <i>MemoryImpl</i> and <i>BufferImpl</i>:</p>
*<blockquote><pre>
* MemoryImpl mem = ...
- * Buffer buf = mem.asBuffer();
+ * BufferImpl buf = mem.asBuffer();
* ...
* MemoryImpl mem2 = buf.asMemory();
* ...
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
index 0f5f44e..ac2579a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
@@ -22,7 +22,7 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -35,7 +35,7 @@ public class BaseBufferTest {
@Test
public void checkLimits() {
- Buffer buf = MemoryImpl.wrap(new byte[100]).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(new byte[100]).asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -48,7 +48,7 @@ public class BaseBufferTest {
@Test
public void checkLimitsAndCheck() {
- Buffer buf = MemoryImpl.wrap(new byte[100]).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(new byte[100]).asBuffer();
buf.setAndCheckStartPositionEnd(40, 45, 50);
buf.setAndCheckStartPositionEnd(0, 0, 100);
try {
@@ -77,7 +77,7 @@ public class BaseBufferTest {
@Test
public void checkCheckValid() {
WritableMemoryImpl wmem;
- Buffer buf;
+ BufferImpl buf;
try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
wmem = hand.get();
buf = wmem.asBuffer();
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
index 919265c..598710f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
@@ -27,12 +27,12 @@ import static org.testng.Assert.fail;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Prim;
import org.apache.datasketches.memory.internal.StepBoolean;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -52,8 +52,8 @@ public class BaseStateTest {
assertFalse(wmem.isSameResource(null));
assertTrue(wmem.isSameResource(mem));
- WritableBuffer wbuf = wmem.asWritableBuffer();
- Buffer buf = wbuf;
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ BufferImpl buf = wbuf;
assertFalse(wbuf.isSameResource(null));
assertTrue(wbuf.isSameResource(buf));
}
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 4a19f56..b2a7f1d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
@@ -26,10 +26,10 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -47,7 +47,7 @@ public class Buffer2Test {
}
bb.position(0);
- Buffer buffer = Buffer.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
+ BufferImpl buffer = BufferImpl.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -67,7 +67,7 @@ public class Buffer2Test {
}
bb.position(0);
- Buffer buffer = Buffer.wrap(bb);
+ BufferImpl buffer = BufferImpl.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -84,7 +84,7 @@ public class Buffer2Test {
byteArray[i] = i;
}
- Buffer buffer = MemoryImpl.wrap(byteArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(byteArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(byteArray[i++], buffer.getByte());
@@ -107,7 +107,7 @@ public class Buffer2Test {
charArray[i] = i;
}
- Buffer buffer = MemoryImpl.wrap(charArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(charArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(charArray[i++], buffer.getChar());
@@ -127,7 +127,7 @@ public class Buffer2Test {
shortArray[i] = i;
}
- Buffer buffer = MemoryImpl.wrap(shortArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(shortArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(shortArray[i++], buffer.getShort());
@@ -147,7 +147,7 @@ public class Buffer2Test {
intArray[i] = i;
}
- Buffer buffer = MemoryImpl.wrap(intArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(intArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(intArray[i++], buffer.getInt());
@@ -167,7 +167,7 @@ public class Buffer2Test {
longArray[i] = i;
}
- Buffer buffer = MemoryImpl.wrap(longArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(longArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(longArray[i++], buffer.getLong());
@@ -187,7 +187,7 @@ public class Buffer2Test {
floatArray[i] = i;
}
- Buffer buffer = MemoryImpl.wrap(floatArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(floatArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(floatArray[i++], buffer.getFloat());
@@ -207,7 +207,7 @@ public class Buffer2Test {
doubleArray[i] = i;
}
- Buffer buffer = MemoryImpl.wrap(doubleArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(doubleArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(doubleArray[i++], buffer.getDouble());
@@ -229,7 +229,7 @@ public class Buffer2Test {
}
}
- Buffer buffer = MemoryImpl.wrap(booleanArray).asBuffer();
+ BufferImpl buffer = MemoryImpl.wrap(booleanArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(booleanArray[i++], buffer.getBoolean());
@@ -254,7 +254,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ BufferImpl buffer = BufferImpl.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -271,7 +271,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ BufferImpl buffer = BufferImpl.wrap(bb);
assertEquals(bb.hasRemaining(), buffer.hasRemaining());
assertEquals(bb.remaining(), buffer.getRemaining());
}
@@ -287,7 +287,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ BufferImpl buffer = BufferImpl.wrap(bb);
assertEquals(bb.position(), buffer.getPosition());
assertEquals(30, buffer.setPosition(30).getPosition());
assertEquals(40, buffer.incrementPosition(10).getPosition());
@@ -305,7 +305,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder()));
+ BufferImpl buffer = BufferImpl.wrap(bb.slice().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -327,10 +327,10 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
+ BufferImpl buffer = BufferImpl.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
buffer.setPosition(30);//remaining = 24
- Buffer dupBuffer = buffer.duplicate(); //all 54
- Buffer regionBuffer = buffer.region(); //24
+ BufferImpl dupBuffer = buffer.duplicate(); //all 54
+ BufferImpl regionBuffer = buffer.region(); //24
assertEquals(dupBuffer.getStart(), buffer.getStart());
assertEquals(regionBuffer.getStart(), buffer.getStart());
@@ -349,8 +349,8 @@ public class Buffer2Test {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
MemoryImpl mem = MemoryImpl.wrap(arr);
- Buffer buf = mem.asBuffer();
- Buffer reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
+ BufferImpl buf = mem.asBuffer();
+ BufferImpl reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
for (int i = 0; i < n2; i++) {
long v = reg.getLong(i * 8);
long e = i + n2;
@@ -369,7 +369,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ BufferImpl buffer = BufferImpl.wrap(bb);
MemoryImpl memory = buffer.asMemory();
assertEquals(buffer.getCapacity(), memory.getCapacity());
@@ -383,8 +383,8 @@ public class Buffer2Test {
public void testROByteBuffer() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- Buffer buf = Buffer.wrap(roBB);
- WritableBuffer wbuf = (WritableBuffer) buf;
+ BufferImpl buf = BufferImpl.wrap(roBB);
+ WritableBufferImpl wbuf = (WritableBufferImpl) buf;
wbuf.putByte(0, (byte) 1);
}
@@ -392,8 +392,8 @@ public class Buffer2Test {
public void testROByteBuffer2() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- Buffer buf = Buffer.wrap(roBB);
- WritableBuffer wbuf = (WritableBuffer) buf;
+ BufferImpl buf = BufferImpl.wrap(roBB);
+ WritableBufferImpl wbuf = (WritableBufferImpl) buf;
wbuf.putByteArray(arr, 0, 64);
}
@@ -401,18 +401,18 @@ public class Buffer2Test {
public void testIllegalFill() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- Buffer buf = Buffer.wrap(roBB);
- WritableBuffer wbuf = (WritableBuffer) buf;
+ BufferImpl buf = BufferImpl.wrap(roBB);
+ WritableBufferImpl wbuf = (WritableBufferImpl) buf;
wbuf.fill((byte)0);
}
@Test
public void testWritableDuplicate() {
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[1]);
- WritableBuffer wbuf = wmem.asWritableBuffer();
- WritableBuffer wbuf2 = wbuf.writableDuplicate();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wbuf.writableDuplicate();
assertEquals(wbuf2.getCapacity(), 1);
- Buffer buf = wmem.asBuffer();
+ BufferImpl buf = wmem.asBuffer();
assertEquals(buf.getCapacity(), 1);
}
@@ -420,8 +420,8 @@ public class Buffer2Test {
public void checkIndependence() {
int cap = 64;
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(cap);
- WritableBuffer wbuf1 = wmem.asWritableBuffer();
- WritableBuffer wbuf2 = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf1 = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wmem.asWritableBuffer();
assertFalse(wbuf1 == wbuf2);
assertTrue(wbuf1.isSameResource(wbuf2));
@@ -431,8 +431,8 @@ public class Buffer2Test {
assertTrue(reg1.isSameResource(reg2));
- WritableBuffer wbuf3 = wbuf1.writableRegion();
- WritableBuffer wbuf4 = wbuf1.writableRegion();
+ WritableBufferImpl wbuf3 = wbuf1.writableRegion();
+ WritableBufferImpl wbuf4 = wbuf1.writableRegion();
assertFalse(wbuf3 == wbuf4);
assertTrue(wbuf3.isSameResource(wbuf4));
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
index d71419a..46f340d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
@@ -25,8 +25,8 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -40,10 +40,10 @@ public class BufferInvariantsTest {
public void testRegion() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
+ BufferImpl buff = BufferImpl.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
- Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
+ BufferImpl copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
assertEquals(copyBuff.getEnd(), 6);
assertEquals(copyBuff.getCapacity(), 6);
assertEquals(copyBuff.getStart(), 0);
@@ -51,7 +51,7 @@ public class BufferInvariantsTest {
buff.setStartPositionEnd(1, 1, 5);
buff.getByte();
- Buffer copyBuff2 = buff.region();
+ BufferImpl copyBuff2 = buff.region();
assertEquals(copyBuff2.getEnd(), 3);
assertEquals(copyBuff2.getCapacity(), 3);
assertEquals(copyBuff2.getStart(), 0);
@@ -93,7 +93,7 @@ public class BufferInvariantsTest {
@Test
public void testBuf() {
int n = 25;
- WritableBuffer buf = WritableMemoryImpl.allocate(n).asWritableBuffer();
+ WritableBufferImpl buf = WritableMemoryImpl.allocate(n).asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -110,7 +110,7 @@ public class BufferInvariantsTest {
// print("Set : ");
// printbuf(buf);
- Buffer dup = buf.duplicate();
+ BufferImpl dup = buf.duplicate();
assertEquals(dup.getRemaining(), 15);
assertEquals(dup.getCapacity(), 25);
assertEquals(dup.getByte(), 5);
@@ -119,7 +119,7 @@ public class BufferInvariantsTest {
// printbuf(dup);
- Buffer reg = buf.region();
+ BufferImpl reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -139,7 +139,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- Buffer buf = Buffer.wrap(bb);
+ BufferImpl buf = BufferImpl.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
@@ -149,7 +149,7 @@ public class BufferInvariantsTest {
// print("Buf.wrap: ");
// printbuf(buf);
- Buffer reg = buf.region();
+ BufferImpl reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -164,7 +164,7 @@ public class BufferInvariantsTest {
public void checkLimitsDirect() {
try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
WritableMemoryImpl wmem = hand.get();
- Buffer buf = wmem.asBuffer();
+ BufferImpl buf = wmem.asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -180,10 +180,10 @@ public class BufferInvariantsTest {
public void testRegionDirect() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
+ BufferImpl buff = BufferImpl.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
- Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
+ BufferImpl copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
assertEquals(copyBuff.getEnd(), 6);
assertEquals(copyBuff.getCapacity(), 6);
assertEquals(copyBuff.getStart(), 0);
@@ -191,7 +191,7 @@ public class BufferInvariantsTest {
buff.setStartPositionEnd(1, 1, 5);
buff.getByte();
- Buffer copyBuff2 = buff.region();
+ BufferImpl copyBuff2 = buff.region();
assertEquals(copyBuff2.getEnd(), 3);
assertEquals(copyBuff2.getCapacity(), 3);
assertEquals(copyBuff2.getStart(), 0);
@@ -235,7 +235,7 @@ public class BufferInvariantsTest {
int n = 25;
try (WritableHandle whand = WritableMemoryImpl.allocateDirect(n)) {
WritableMemoryImpl wmem = whand.get();
- WritableBuffer buf = wmem.asWritableBuffer();
+ WritableBufferImpl buf = wmem.asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -252,7 +252,7 @@ public class BufferInvariantsTest {
// print("Set : ");
// printbuf(buf);
- Buffer dup = buf.duplicate();
+ BufferImpl dup = buf.duplicate();
assertEquals(dup.getRemaining(), 15);
assertEquals(dup.getCapacity(), 25);
assertEquals(dup.getByte(), 5);
@@ -261,7 +261,7 @@ public class BufferInvariantsTest {
// printbuf(dup);
- Buffer reg = buf.region();
+ BufferImpl reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -282,7 +282,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- Buffer buf = Buffer.wrap(bb);
+ BufferImpl buf = BufferImpl.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
@@ -292,7 +292,7 @@ public class BufferInvariantsTest {
// print("Buf.wrap: ");
// printbuf(buf);
- Buffer reg = buf.region();
+ BufferImpl reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -315,7 +315,7 @@ public class BufferInvariantsTest {
println(bb.get(i + pos) + "\n");
}
- static void printbuf(Buffer buf) {
+ static void printbuf(BufferImpl buf) {
println("pos: " + buf.getPosition() + ", end: " + buf.getEnd() + ", cap: " + buf.getCapacity());
long rem = buf.getRemaining();
long pos = buf.getPosition();
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
index 6d67e67..b076dee 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
@@ -21,18 +21,18 @@ package org.apache.datasketches.memory.test;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class BufferReadWriteSafetyTest {
- // Test various operations with read-only Buffer
+ // Test various operations with read-only BufferImpl
- private final WritableBuffer buf = (WritableBuffer) Buffer.wrap(ByteBuffer.allocate(8));
+ private final WritableBufferImpl buf = (WritableBufferImpl) BufferImpl.wrap(ByteBuffer.allocate(8));
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -158,19 +158,19 @@ public class BufferReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryAsBuffer() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemoryImpl.allocate(8).asBuffer();
+ WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asBuffer();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferRegion() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemoryImpl.allocate(8).asWritableBuffer().region();
+ WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asWritableBuffer().region();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferDuplicate() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemoryImpl.allocate(8).asWritableBuffer().duplicate();
+ WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asWritableBuffer().duplicate();
buf1.putInt(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 38a4f31..123bbbf 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
@@ -26,9 +26,9 @@ import java.nio.ByteOrder;
import java.util.List;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
import org.testng.collections.Lists;
@@ -41,7 +41,7 @@ public class BufferTest {
int n = 1024; //longs
try (WritableHandle wh = WritableMemoryImpl.allocateDirect(n * 8)) {
WritableMemoryImpl wmem = wh.get();
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -56,7 +56,7 @@ public class BufferTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableBuffer wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -71,7 +71,7 @@ public class BufferTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -80,7 +80,7 @@ public class BufferTest {
long v = wbuf.getLong();
assertEquals(v, i);
}
- Buffer buf = MemoryImpl.wrap(arr).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(arr).asBuffer();
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
@@ -88,13 +88,13 @@ public class BufferTest {
}
// Check Zero length array wraps
MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
- Buffer buffZeroLengthArrayWrap = mem.asBuffer();
+ BufferImpl buffZeroLengthArrayWrap = mem.asBuffer();
assertEquals(buffZeroLengthArrayWrap.getCapacity(), 0);
// check 0 length array wraps
- List<Buffer> buffersToCheck = Lists.newArrayList();
+ List<BufferImpl> buffersToCheck = Lists.newArrayList();
buffersToCheck.add(WritableMemoryImpl.allocate(0).asBuffer());
- buffersToCheck.add(WritableBuffer.wrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(Buffer.wrap(ByteBuffer.allocate(0)));
+ buffersToCheck.add(WritableBufferImpl.writableWrap(ByteBuffer.allocate(0)));
+ buffersToCheck.add(BufferImpl.wrap(ByteBuffer.allocate(0)));
buffersToCheck.add(MemoryImpl.wrap(new boolean[0]).asBuffer());
buffersToCheck.add(MemoryImpl.wrap(new byte[0]).asBuffer());
buffersToCheck.add(MemoryImpl.wrap(new char[0]).asBuffer());
@@ -104,7 +104,7 @@ public class BufferTest {
buffersToCheck.add(MemoryImpl.wrap(new float[0]).asBuffer());
buffersToCheck.add(MemoryImpl.wrap(new double[0]).asBuffer());
//Check the buffer lengths
- for (Buffer buffer : buffersToCheck) {
+ for (BufferImpl buffer : buffersToCheck) {
assertEquals(buffer.getCapacity(), 0);
}
}
@@ -116,7 +116,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBuffer wbuf = WritableBuffer.wrap(bb);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -138,7 +138,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBuffer wbuf = WritableBuffer.wrap(bb);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -151,13 +151,13 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Buffer buf1 = MemoryImpl.wrap(arr).asBuffer();
+ BufferImpl buf1 = MemoryImpl.wrap(arr).asBuffer();
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = buf1.getLong();
assertEquals(v, i);
}
//convert to wbuf to RO
- Buffer buf = wbuf;
+ BufferImpl buf = wbuf;
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
@@ -171,7 +171,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
bb.order(ByteOrder.nativeOrder());
- WritableBuffer wbuf = WritableBuffer.wrap(bb);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wbuf.putLong(i);
}
@@ -184,13 +184,13 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Buffer buf1 = Buffer.wrap(bb);
+ BufferImpl buf1 = BufferImpl.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = buf1.getLong();
assertEquals(v, i);
}
//convert to RO
- Buffer buf = wbuf;
+ BufferImpl buf = wbuf;
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
@@ -203,7 +203,7 @@ public class BufferTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- Buffer buf = Buffer.wrap(bb);
+ BufferImpl buf = BufferImpl.wrap(bb);
assertEquals(buf.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -217,7 +217,7 @@ public class BufferTest {
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- Buffer buf = Buffer.wrap(slice);
+ BufferImpl buf = BufferImpl.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(buf.getByte(), 64 + i);
}
@@ -231,7 +231,7 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBuffer wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
wbuf.putLongArray(arr, 0, n);
long[] arr2 = new long[n];
wbuf.resetPosition();
@@ -248,9 +248,9 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Buffer buf = MemoryImpl.wrap(arr).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(arr).asBuffer();
buf.setPosition(n2 * 8);
- Buffer reg = buf.region();
+ BufferImpl reg = buf.region();
for (int i = 0; i < n2; i++) {
long v = reg.getLong();
assertEquals(v, i + n2);
@@ -264,14 +264,14 @@ public class BufferTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
assertEquals(wbuf.getLong(), i); //write all
//println("" + wmem.getLong(i * 8));
}
//println("");
wbuf.setPosition(n2 * 8);
- WritableBuffer reg = wbuf.writableRegion();
+ WritableBufferImpl reg = wbuf.writableRegion();
for (int i = 0; i < n2; i++) { reg.putLong(i); } //rewrite top half
wbuf.resetPosition();
for (int i = 0; i < n; i++) {
@@ -286,7 +286,7 @@ public class BufferTest {
@SuppressWarnings("resource") //intentionally not using try-with-resources here
WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
WritableMemoryImpl wmem = wh.get();
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
wh.close();
//with -ea assert: MemoryImpl not valid.
//with -da sometimes segfaults, sometimes passes!
@@ -300,7 +300,7 @@ public class BufferTest {
WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
MemoryImpl wmem = wh.get();
- Buffer reg = wmem.asBuffer().region();
+ BufferImpl reg = wmem.asBuffer().region();
wh.close();
//with -ea assert: MemoryImpl not valid.
//with -da sometimes segfaults, sometimes passes!
@@ -309,7 +309,7 @@ public class BufferTest {
@Test(expectedExceptions = AssertionError.class)
public void checkBaseBufferInvariants() {
- WritableBuffer wbuf = WritableMemoryImpl.allocate(64).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.allocate(64).asWritableBuffer();
wbuf.setStartPositionEnd(1, 0, 2); //out of order
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
index 2f7f4fb..1e12d32 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
@@ -22,7 +22,7 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -34,14 +34,14 @@ public class CommonBufferTest {
int memCapacity = 60; //must be at least 60
try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl mem = wrh.get();
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetTests(buf);
setGetTests2(buf);
}
}
- public static void setGetTests(WritableBuffer buf) {
+ public static void setGetTests(WritableBufferImpl buf) {
buf.putBoolean(true);
buf.putBoolean(false);
buf.putByte((byte) -1);
@@ -95,7 +95,7 @@ public class CommonBufferTest {
assertEquals(buf.getDouble(), Double.MIN_VALUE);
}
- public static void setGetTests2(WritableBuffer buf) {
+ public static void setGetTests2(WritableBufferImpl buf) {
buf.putBoolean(0, true);
buf.putBoolean(1, false);
buf.putByte(2, (byte) -1);
@@ -136,13 +136,13 @@ public class CommonBufferTest {
int memCapacity = 32;
try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl mem = wrh.get();
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetArraysTests(buf);
}
}
- public static void setGetArraysTests(WritableBuffer buf) {
+ public static void setGetArraysTests(WritableBufferImpl buf) {
int words = 4;
boolean[] srcArray1 = {true, false, true, false};
@@ -233,13 +233,13 @@ public class CommonBufferTest {
int memCapacity = 32;
try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl mem = wrh.get();
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetPartialArraysWithOffsetTests(buf);
}
}
- public static void setGetPartialArraysWithOffsetTests(WritableBuffer buf) {
+ public static void setGetPartialArraysWithOffsetTests(WritableBufferImpl buf) {
int items= 4;
boolean[] srcArray1 = {true, false, true, false};
boolean[] dstArray1 = new boolean[items];
@@ -327,7 +327,7 @@ public class CommonBufferTest {
int memCapacity = 64; //must be 64
try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl mem = wrh1.get();
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setClearMemoryRegionsTests(buf); //requires println enabled to visually check
@@ -339,7 +339,7 @@ public class CommonBufferTest {
}
//enable println statements to visually check
- public static void setClearMemoryRegionsTests(WritableBuffer buf) {
+ public static void setClearMemoryRegionsTests(WritableBufferImpl buf) {
int accessCapacity = (int)buf.getCapacity();
//define regions
@@ -416,14 +416,14 @@ public class CommonBufferTest {
int memCapacity = 48; //must be 48
try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl mem = wrh1.get();
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
toHexStringAllMemTests(buf); //requires println enabled to visually check
}
}
//enable println to visually check
- public static void toHexStringAllMemTests(WritableBuffer buf) {
+ public static void toHexStringAllMemTests(WritableBufferImpl buf) {
int memCapacity = (int)buf.getCapacity();
for (int i=0; i<memCapacity; i++) {
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 c25ea06..19f8b8c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
@@ -32,7 +32,7 @@ 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.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.apache.datasketches.memory.WritableMapHandle;
@@ -71,7 +71,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() == null);
assertTrue(mem.isValid() == true);
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -101,7 +101,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() == null);
assertTrue(nnMem.isValid() == true);
- WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -156,7 +156,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() == null);
assertTrue(mem.isValid() == true);
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -186,7 +186,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() == null);
assertTrue(nnMem.isValid() == true);
- WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -239,7 +239,7 @@ public class LeafImplTest {
}
assertTrue(mem.isValid() == true);
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -281,7 +281,7 @@ public class LeafImplTest {
}
assertTrue(nnMem.isValid() == true);
- WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -326,7 +326,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() != null);
assertTrue(mem.isValid() == true);
- WritableBuffer buf = mem.asWritableBuffer();
+ WritableBufferImpl buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -356,7 +356,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() != null);
assertTrue(nnMem.isValid() == true);
- WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
index 4137c71..7654af8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
@@ -19,14 +19,14 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class MemoryBoundaryCheckTest {
- private final WritableBuffer writableBuffer = WritableMemoryImpl.allocate(8).asWritableBuffer();
+ private final WritableBufferImpl writableBuffer = WritableMemoryImpl.allocate(8).asWritableBuffer();
@Test
public void testGetBoolean() {
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 aa22700..84c2f1c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.Buffer;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -42,7 +42,7 @@ public class NonNativeWritableBufferImplTest {
byte[] arr1 = new byte[n * m]; //non-native
//put & get
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
char ch = 'a';
for (int i = 0; i < n; i++) { wbuf.putChar(i * m, ch++); }
ch = 'a';
@@ -63,7 +63,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.getCharArray(cArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
wbuf2.putCharArray(cArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -75,7 +75,7 @@ public class NonNativeWritableBufferImplTest {
byte[] arr1 = new byte[n * m]; //non-native
//put & get
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
double dbl = 1.0;
for (int i = 0; i < n; i++) { wbuf.putDouble(i * m, dbl++); }
dbl = 1.0;
@@ -96,7 +96,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.getDoubleArray(dblArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
wbuf2.putDoubleArray(dblArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -108,7 +108,7 @@ public class NonNativeWritableBufferImplTest {
byte[] arr1 = new byte[n * m]; //non-native
//put & get
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
float flt = 1.0F;
for (int i = 0; i < n; i++) { wbuf.putFloat(i * m, flt++); }
flt = 1.0F;
@@ -129,7 +129,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.getFloatArray(fltArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
wbuf2.putFloatArray(fltArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -141,7 +141,7 @@ public class NonNativeWritableBufferImplTest {
byte[] arr1 = new byte[n * m]; //non-native
//put & get
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
int intg = 1;
for (int i = 0; i < n; i++) { wbuf.putInt(i * m, intg++); }
intg = 1;
@@ -162,7 +162,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.getIntArray(intArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
wbuf2.putIntArray(intArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -174,7 +174,7 @@ public class NonNativeWritableBufferImplTest {
byte[] arr1 = new byte[n * m]; //non-native
//put & get
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
long lng = 1;
for (int i = 0; i < n; i++) { wbuf.putLong(i * m, lng++); }
lng = 1;
@@ -195,7 +195,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.getLongArray(longArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
wbuf2.putLongArray(longArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -207,7 +207,7 @@ public class NonNativeWritableBufferImplTest {
byte[] arr1 = new byte[n * m]; //non-native
//put & get
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
short sht = 1;
for (int i = 0; i < n; i++) { wbuf.putShort(i * m, sht++); }
sht = 1;
@@ -228,7 +228,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.getShortArray(shortArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf2 = wmem2.asWritableBuffer();
+ WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
wbuf2.putShortArray(shortArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -238,11 +238,11 @@ public class NonNativeWritableBufferImplTest {
public void checkDuplicate() {
byte[] bArr = new byte[8];
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
- WritableBuffer wbuf = wmem.asWritableBuffer();
- WritableBuffer wdup = wbuf.writableDuplicate();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wdup = wbuf.writableDuplicate();
assertEquals(wdup.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- WritableBuffer wreg = wbuf.writableRegion();
+ WritableBufferImpl wreg = wbuf.writableRegion();
assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -250,11 +250,11 @@ public class NonNativeWritableBufferImplTest {
public void checkDuplicateZeros() {
byte[] bArr = new byte[0];
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
- Buffer buf = wmem.asBuffer();
- Buffer dup = buf.duplicate();
+ BufferImpl buf = wmem.asBuffer();
+ BufferImpl dup = buf.duplicate();
assertEquals(dup.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
- Buffer reg = buf.region();
+ BufferImpl reg = buf.region();
assertEquals(reg.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
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 6436164..a1e5ce7 100644
--- a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
@@ -26,7 +26,7 @@ import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Util;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
@@ -50,12 +50,12 @@ public class SpecificLeafTest {
assertTrue(ReflectUtil.isBBType(mem));
assertTrue(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
- Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ BufferImpl buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
bb.order(Util.nonNativeByteOrder);
MemoryImpl mem2 = MemoryImpl.wrap(bb).region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf3 = buf2.duplicate();
+ BufferImpl buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ BufferImpl buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(mem2));
@@ -75,12 +75,12 @@ public class SpecificLeafTest {
WritableMemoryImpl nnwmem = wmem.writableRegion(0, bytes, Util.nonNativeByteOrder);
MemoryImpl mem = wmem.region(0, bytes, Util.nativeByteOrder);
- Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ BufferImpl buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
MemoryImpl mem2 = nnwmem.region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf3 = buf2.duplicate();
+ BufferImpl buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ BufferImpl buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(mem2));
@@ -115,12 +115,12 @@ public class SpecificLeafTest {
MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
- Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
- Buffer buf4 = buf.duplicate();
+ BufferImpl buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ BufferImpl buf4 = buf.duplicate();
MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf3 = buf2.duplicate();
+ BufferImpl buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ BufferImpl buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(reg));
assertTrue(ReflectUtil.isRegionType(reg2));
@@ -141,12 +141,12 @@ public class SpecificLeafTest {
MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
- Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
- Buffer buf4 = buf.duplicate();
+ BufferImpl buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ BufferImpl buf4 = buf.duplicate();
MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- Buffer buf3 = buf2.duplicate();
+ BufferImpl buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ BufferImpl buf3 = buf2.duplicate();
assertFalse(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(reg2));
@@ -160,11 +160,11 @@ public class SpecificLeafTest {
MemoryImpl reg1 = mem.region(0, mem.getCapacity());
assertTrue(ReflectUtil.isRegionType(reg1));
- Buffer buf1 = reg1.asBuffer();
+ BufferImpl buf1 = reg1.asBuffer();
assertTrue(ReflectUtil.isRegionType(buf1));
assertTrue(ReflectUtil.isBufferType(buf1));
- Buffer buf2 = buf1.duplicate();
+ BufferImpl buf2 = buf1.duplicate();
assertTrue(ReflectUtil.isRegionType(buf2));
assertTrue(ReflectUtil.isBufferType(buf2));
assertTrue(ReflectUtil.isDuplicateType(buf2));
@@ -174,7 +174,7 @@ public class SpecificLeafTest {
assertFalse(ReflectUtil.isBufferType(mem2));
assertFalse(ReflectUtil.isDuplicateType(mem2));
- Buffer buf3 = buf1.duplicate(Util.nonNativeByteOrder);
+ BufferImpl buf3 = buf1.duplicate(Util.nonNativeByteOrder);
assertTrue(ReflectUtil.isRegionType(buf3));
assertTrue(ReflectUtil.isBufferType(buf3));
assertTrue(ReflectUtil.isDuplicateType(buf3));
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 7593be8..18a43da 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
@@ -27,12 +27,12 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -48,7 +48,7 @@ public class WritableBufferImplTest {
int memCapacity = 64;
WritableHandle wmh = WritableMemoryImpl.allocateDirect(memCapacity);
WritableMemoryImpl wmem = wmh.get();
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), memCapacity);
wmh.close(); //intentional
@@ -64,13 +64,13 @@ public class WritableBufferImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -83,13 +83,13 @@ public class WritableBufferImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -101,13 +101,13 @@ public class WritableBufferImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -119,13 +119,13 @@ public class WritableBufferImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -137,13 +137,13 @@ public class WritableBufferImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -155,13 +155,13 @@ public class WritableBufferImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -173,13 +173,13 @@ public class WritableBufferImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -191,13 +191,13 @@ public class WritableBufferImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- Buffer buf = MemoryImpl.wrap(srcArray).asBuffer();
+ BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
buf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
wbuf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -209,7 +209,7 @@ public class WritableBufferImplTest {
int memCapacity = 64;
try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl wmem = wrh.get();
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
wbuf.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
//ok
@@ -221,7 +221,7 @@ public class WritableBufferImplTest {
long memCapacity = 64;
try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl wmem = wrh.get();
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
byte[] srcArray = { 1, -2, 3, -4 };
wbuf.putByteArray(srcArray, 0, 5); //wrong!
} catch (IllegalArgumentException e) {
@@ -235,7 +235,7 @@ public class WritableBufferImplTest {
int memCapacity = 64;
try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl wmem = wrh.get();
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
wbuf.writableRegion(1, 64, wbuf.getTypeByteOrder()); //wrong!
}
}
@@ -250,7 +250,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- WritableBuffer wbuf = WritableBuffer.wrap(byteBuf);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(wbuf.getByte(), byteBuf.get(i));
@@ -272,7 +272,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- Buffer buf = WritableBuffer.wrap(byteBuf);
+ BufferImpl buf = WritableBufferImpl.writableWrap(byteBuf);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -288,7 +288,7 @@ public class WritableBufferImplTest {
byteBuf.order(ByteOrder.nativeOrder());
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
- WritableBuffer.wrap(byteBufRO);
+ WritableBufferImpl.writableWrap(byteBufRO);
}
@Test
@@ -303,7 +303,7 @@ public class WritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- Buffer buf = Buffer.wrap(byteBufRO);
+ BufferImpl buf = BufferImpl.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -319,7 +319,7 @@ public class WritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableBuffer.wrap(byteBufRO);
+ WritableBufferImpl.writableWrap(byteBufRO);
}
@Test
@@ -332,7 +332,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- Buffer buf = Buffer.wrap(byteBuf);
+ BufferImpl buf = BufferImpl.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -344,11 +344,11 @@ public class WritableBufferImplTest {
@Test
public void checkIsDirect() {
int memCapacity = 64;
- WritableBuffer mem = WritableMemoryImpl.allocate(memCapacity).asWritableBuffer();
+ WritableBufferImpl mem = WritableMemoryImpl.allocate(memCapacity).asWritableBuffer();
assertFalse(mem.isDirect());
try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
WritableMemoryImpl mem2 = wrh.get();
- WritableBuffer wbuf = mem2.asWritableBuffer();
+ WritableBufferImpl wbuf = mem2.asWritableBuffer();
assertTrue(wbuf.isDirect());
wrh.close();
}
@@ -358,10 +358,10 @@ public class WritableBufferImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableBuffer wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
assertFalse(wbuf.isReadOnly());
- Buffer buf = wbuf;
+ BufferImpl buf = wbuf;
assertFalse(buf.isReadOnly());
for (int i = 0; i < srcArray.length; i++) {
@@ -380,9 +380,9 @@ public class WritableBufferImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- Buffer buf1 = MemoryImpl.wrap(arr1).asBuffer();
- Buffer buf2 = MemoryImpl.wrap(arr2).asBuffer();
- Buffer buf3 = MemoryImpl.wrap(arr3).asBuffer();
+ BufferImpl buf1 = MemoryImpl.wrap(arr1).asBuffer();
+ BufferImpl buf2 = MemoryImpl.wrap(arr2).asBuffer();
+ BufferImpl buf3 = MemoryImpl.wrap(arr3).asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -416,9 +416,9 @@ public class WritableBufferImplTest {
WritableMemoryImpl mem3 = h3.get();
mem3.putByteArray(0, arr3, 0, 5);
- Buffer buf1 = mem1.asBuffer();
- Buffer buf2 = mem2.asBuffer();
- Buffer buf3 = mem3.asBuffer();
+ BufferImpl buf1 = mem1.asBuffer();
+ BufferImpl buf2 = mem2.asBuffer();
+ BufferImpl buf3 = mem3.asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -437,12 +437,12 @@ public class WritableBufferImplTest {
@Test
public void checkAsBuffer() {
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
//println(wbuf.toHexString("Buf", 0, (int)wbuf.getCapacity()));
- Buffer buf = wmem.asBuffer();
+ BufferImpl buf = wmem.asBuffer();
buf.setPosition(32);
for (int i = 32; i < 64; i++) {
assertEquals(buf.getByte(), i);
@@ -454,12 +454,12 @@ public class WritableBufferImplTest {
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
for (int i = 0; i < 64; i++) { wmem.putByte(i, (byte)i); }
- WritableBuffer wbuf = wmem.asWritableBuffer().writableDuplicate();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer().writableDuplicate();
wbuf.checkValidAndBounds(0, 64);
for (int i = 0; i < 64; i++) {
assertEquals(wbuf.getByte(), i);
}
- Buffer buf = wmem.asBuffer().duplicate();
+ BufferImpl buf = wmem.asBuffer().duplicate();
for (int i = 0; i < 64; i++) {
assertEquals(buf.getByte(), i);
}
@@ -476,7 +476,7 @@ public class WritableBufferImplTest {
public void checkCumAndRegionOffset() {
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
WritableMemoryImpl reg = wmem.writableRegion(32, 32);
- WritableBuffer buf = reg.asWritableBuffer();
+ WritableBufferImpl buf = reg.asWritableBuffer();
assertEquals(buf.getRegionOffset(), 32);
assertEquals(buf.getRegionOffset(0), 32);
assertEquals(buf.getCumulativeOffset(), 32 + 16);
@@ -486,29 +486,29 @@ public class WritableBufferImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableBuffer wbuf1 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
- WritableBuffer wbuf2 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
+ WritableBufferImpl wbuf1 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
+ WritableBufferImpl wbuf2 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
assertTrue(wbuf1.isSameResource(wbuf2));
}
@Test
public void checkDegenerateRegionReturn() {
MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
- Buffer buf = mem.asBuffer();
- Buffer reg = buf.region();
+ BufferImpl buf = mem.asBuffer();
+ BufferImpl reg = buf.region();
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkAsWritableMemoryRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.wrap(bb);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
@SuppressWarnings("unused")
WritableMemoryImpl wmem = wbuf.asWritableMemory();
try {
- Buffer buf = Buffer.wrap(bb);
- wbuf = (WritableBuffer) buf;
+ BufferImpl buf = BufferImpl.wrap(bb);
+ wbuf = (WritableBufferImpl) buf;
@SuppressWarnings("unused")
WritableMemoryImpl wmem2 = wbuf.asWritableMemory();
Assert.fail();
@@ -520,15 +520,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableDuplicateRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.wrap(bb);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBuffer wdup = wbuf.writableDuplicate();
+ WritableBufferImpl wdup = wbuf.writableDuplicate();
try {
- Buffer buf = Buffer.wrap(bb);
- wbuf = (WritableBuffer) buf;
+ BufferImpl buf = BufferImpl.wrap(bb);
+ wbuf = (WritableBufferImpl) buf;
@SuppressWarnings("unused")
- WritableBuffer wdup2 = wbuf.writableDuplicate();
+ WritableBufferImpl wdup2 = wbuf.writableDuplicate();
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -538,15 +538,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableRegionRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.wrap(bb);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBuffer wreg = wbuf.writableRegion();
+ WritableBufferImpl wreg = wbuf.writableRegion();
try {
- Buffer buf = Buffer.wrap(bb);
- wbuf = (WritableBuffer) buf;
+ BufferImpl buf = BufferImpl.wrap(bb);
+ wbuf = (WritableBufferImpl) buf;
@SuppressWarnings("unused")
- WritableBuffer wreg2 = wbuf.writableRegion();
+ WritableBufferImpl wreg2 = wbuf.writableRegion();
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -556,15 +556,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableRegionWithParamsRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.wrap(bb);
+ WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBuffer wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBufferImpl wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
try {
- Buffer buf = Buffer.wrap(bb);
- wbuf = (WritableBuffer) buf;
+ BufferImpl buf = BufferImpl.wrap(bb);
+ wbuf = (WritableBufferImpl) buf;
@SuppressWarnings("unused")
- WritableBuffer wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBufferImpl wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -574,8 +574,8 @@ public class WritableBufferImplTest {
@Test
public void checkZeroBuffer() {
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
- WritableBuffer wbuf = wmem.asWritableBuffer();
- WritableBuffer reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
assertEquals(reg.getCapacity(), 0);
}
@@ -583,7 +583,7 @@ public class WritableBufferImplTest {
public void checkDuplicateNonNative() {
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
wmem.putShort(0, (short) 1);
- Buffer buf = wmem.asWritableBuffer().duplicate(Util.nonNativeByteOrder);
+ BufferImpl buf = wmem.asWritableBuffer().duplicate(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
}
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 ccf994e..2cb8460 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
@@ -28,12 +28,12 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.BufferImpl;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -642,12 +642,12 @@ public class WritableMemoryImplTest {
@Test
public void checkAsBuffer() {
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
//println(wbuf.toHexString("Buf", 0, (int)wbuf.getCapacity()));
- Buffer buf = wmem.asBuffer();
+ BufferImpl buf = wmem.asBuffer();
buf.setPosition(32);
for (int i = 32; i < 64; i++) {
assertEquals(buf.getByte(), i);
@@ -678,7 +678,7 @@ public class WritableMemoryImplTest {
byteBuf.position(16);
byteBuf.limit(48);
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteBuf);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), 64);
assertEquals(wbuf.getPosition(), 0);
assertEquals(wbuf.getEnd(), 64);
@@ -708,7 +708,7 @@ public class WritableMemoryImplTest {
public void checkAsBufferNonNative() {
WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
wmem.putShort(0, (short) 1);
- Buffer buf = wmem.asBuffer(Util.nonNativeByteOrder);
+ BufferImpl buf = wmem.asBuffer(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
}
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 988d2ee..e0765a9 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
@@ -29,7 +29,7 @@ import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.internal.MemoryImpl;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableBufferImpl;
import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.Test;
@@ -64,7 +64,7 @@ public class WritableMemoryTest {
byte[] byteArr = new byte[64];
WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteArr);
assertTrue(wmem.getArray() == byteArr);
- WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBufferImpl wbuf = wmem.asWritableBuffer();
assertTrue(wbuf.getArray() == byteArr);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 04/08: Refactored BaseState to BaseStateImpl,
created interface BaseState.
Posted by le...@apache.org.
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 4d357ed5dfa84193d855553047124242dc3a7dc2
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Mon May 17 10:04:25 2021 -0700
Refactored BaseState to BaseStateImpl, created interface BaseState.
---
.../org/apache/datasketches/memory/BaseState.java | 253 +++++++++++++++++++++
.../org/apache/datasketches/memory/Memory.java | 28 +++
.../memory/internal/AllocateDirect.java | 10 +-
.../memory/internal/AllocateDirectMap.java | 10 +-
.../datasketches/memory/internal/BaseBuffer.java | 2 +-
.../{BaseState.java => BaseStateImpl.java} | 182 +++------------
.../memory/internal/CompareAndCopy.java | 14 +-
.../datasketches/memory/internal/Memory.java | 2 +-
.../test/AllocateDirectWritableMapMemoryTest.java | 2 +-
.../datasketches/memory/test/ReflectUtil.java | 26 +--
.../datasketches/memory/test/XxHash64Test.java | 2 +-
11 files changed, 349 insertions(+), 182 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/BaseState.java b/src/main/java/org/apache/datasketches/memory/BaseState.java
new file mode 100644
index 0000000..ac1e4f2
--- /dev/null
+++ b/src/main/java/org/apache/datasketches/memory/BaseState.java
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.datasketches.memory;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.apache.datasketches.memory.internal.BaseStateImpl;
+
+/**
+ * Keeps key configuration state for Memory and Buffer plus some common static variables
+ * and check methods.
+ *
+ * @author Lee Rhodes
+ */
+public interface BaseState {
+
+ //Byte Order Related
+
+ /**
+ * Gets the current Type ByteOrder.
+ * This may be different from the ByteOrder of the backing resource and of the Native Byte Order.
+ * @return the current Type ByteOrder.
+ */
+ ByteOrder getTypeByteOrder();
+
+ /**
+ * Returns true if the Native ByteOrder is the same as the ByteOrder of the
+ * current Buffer or Memory and the same ByteOrder as the given byteOrder.
+ * @param byteOrder the given ByteOrder
+ * @return true if the Native ByteOrder is the same as the ByteOrder of the
+ * current Buffer or Memory and the same ByteOrder as the given byteOrder.
+ */
+ boolean isByteOrderCompatible(final ByteOrder byteOrder);
+
+ /**
+ * Returns true if the given object is an instance of this class and has equal data contents.
+ * @param that the given object
+ * @return true if the given Object is an instance of this class and has equal data contents.
+ */
+ @Override
+ boolean equals(final Object that);
+
+ /**
+ * Returns true if the given object is an instance of this class and has equal contents to
+ * this object in the given range of bytes. This will also check two distinct ranges within the
+ * same object for eauals.
+ * @param thisOffsetBytes the starting offset in bytes for this object.
+ * @param that the given object
+ * @param thatOffsetBytes the starting offset in bytes for the given object
+ * @param lengthBytes the size of the range in bytes
+ * @return true if the given object has equal contents to this object in the given range of
+ * bytes.
+ */
+ boolean equalTo(final long thisOffsetBytes, final Object that,
+ final long thatOffsetBytes, final long lengthBytes);
+
+ /**
+ * Gets the backing ByteBuffer if it exists, otherwise returns null.
+ * @return the backing ByteBuffer if it exists, otherwise returns null.
+ */
+ ByteBuffer getByteBuffer();
+
+ /**
+ * Gets the capacity of this object in bytes
+ * @return the capacity of this object in bytes
+ */
+ long getCapacity();
+
+ /**
+ * Gets the cumulative offset in bytes of this object from the backing resource.
+ * This offset may also include other offset components such as the native off-heap
+ * memory address, DirectByteBuffer split offsets, region offsets, and unsafe arrayBaseOffsets.
+ *
+ * @return the cumulative offset in bytes of this object from the backing resource.
+ */
+ long getCumulativeOffset();
+
+ /**
+ * Gets the cumulative offset in bytes of this object from the backing resource including the given
+ * offsetBytes. This offset may also include other offset components such as the native off-heap
+ * memory address, DirectByteBuffer split offsets, region offsets, and unsafe arrayBaseOffsets.
+ *
+ * @param offsetBytes offset to be added to the cumulative offset.
+ * @return the cumulative offset in bytes of this object from the backing resource including the
+ * given offsetBytes.
+ */
+ long getCumulativeOffset(final long offsetBytes);
+
+ /**
+ * Returns the offset of address zero of this object relative to the address zero of the
+ * backing resource but not including the size of any Java object header.
+ * @return the offset of address zero of this object relative to the address zero of the
+ * backing resource but not including the size of any Java object header.
+ */
+ long getRegionOffset();
+
+ /**
+ * Returns the offset of address zero of this object relative to the address zero of the
+ * backing resource plus the given offsetBytes but not including the size of any Java object
+ * header.
+ * @param offsetBytes the given offsetBytes
+ * @return the offset of address zero of this object relative to the address zero of the
+ * backing resource plus the given offsetBytes but not including the size of any Java object
+ * header.
+ */
+ long getRegionOffset(final long offsetBytes);
+
+ /**
+ * Returns true if this object is backed by an on-heap primitive array
+ * @return true if this object is backed by an on-heap primitive array
+ */
+ boolean hasArray();
+
+ /**
+ * Returns the hashCode of this object.
+ *
+ * <p>The hash code of this object depends upon all of its contents.
+ * Because of this, it is inadvisable to use these objects as keys in hash maps
+ * or similar data structures unless it is known that their contents will not change.</p>
+ *
+ * <p>If it is desirable to use these objects in a hash map depending only on object identity,
+ * than the {@link java.util.IdentityHashMap} can be used.</p>
+ *
+ * @return the hashCode of this object.
+ */
+ @Override
+ int hashCode();
+
+ /**
+ * Returns the 64-bit hash of the sequence of bytes in this object specified by
+ * <i>offsetBytes</i>, <i>lengthBytes</i> and a <i>seed</i>. Note that the sequence of bytes is
+ * always processed in the same order independent of endianness.
+ *
+ * @param offsetBytes the given offset in bytes to the first byte of the byte sequence.
+ * @param lengthBytes the given length in bytes of the byte sequence.
+ * @param seed the given long seed.
+ * @return the 64-bit hash of the sequence of bytes in this object specified by
+ * <i>offsetBytes</i> and <i>lengthBytes</i>.
+ */
+ long xxHash64(final long offsetBytes, final long lengthBytes, final long seed);
+
+ /**
+ * Returns true if this Memory is backed by a ByteBuffer.
+ * @return true if this Memory is backed by a ByteBuffer.
+ */
+ boolean hasByteBuffer();
+
+ /**
+ * Returns true if the backing resource is direct (off-heap) memory.
+ * This is the case for allocated direct memory, memory mapped files,
+ * @return true if the backing resource is direct (off-heap) memory.
+ */
+ boolean isDirect();
+
+ /**
+ * Returns true if this object or the backing resource is read-only.
+ * @return true if this object or the backing resource is read-only.
+ */
+ boolean isReadOnly();
+
+ /**
+ * Returns true if the backing resource of <i>this</i> is identical with the backing resource
+ * of <i>that</i>. The capacities must be the same. If <i>this</i> is a region,
+ * the region offset must also be the same.
+ * @param that A different non-null object
+ * @return true if the backing resource of <i>this</i> is the same as the backing resource
+ * of <i>that</i>.
+ */
+ boolean isSameResource(final Object that);
+
+ /**
+ * Returns true if this object is valid and has not been closed.
+ * This is relevant only for direct (off-heap) memory and Mapped Files.
+ * @return true if this object is valid and has not been closed.
+ */
+ boolean isValid();
+
+ /**
+ * Checks that the specified range of bytes is within bounds of this object, throws
+ * {@link IllegalArgumentException} if it's not: i. e. if offsetBytes < 0, or length < 0,
+ * or offsetBytes + length > {@link #getCapacity()}.
+ * @param offsetBytes the given offset in bytes of this object
+ * @param lengthBytes the given length in bytes of this object
+ */
+ void checkValidAndBounds(final long offsetBytes, final long lengthBytes);
+
+ //Monitoring
+
+ /**
+ * Gets the current number of active direct memory allocations.
+ * @return the current number of active direct memory allocations.
+ */
+ static long getCurrentDirectMemoryAllocations() {
+ return BaseStateImpl.getCurrentDirectMemoryAllocations();
+ }
+
+ /**
+ * Gets the current size of active direct memory allocated.
+ * @return the current size of active direct memory allocated.
+ */
+ static long getCurrentDirectMemoryAllocated() {
+ return BaseStateImpl.getCurrentDirectMemoryAllocated();
+ }
+
+ /**
+ * Gets the current number of active direct memory map allocations.
+ * @return the current number of active direct memory map allocations.
+ */
+ static long getCurrentDirectMemoryMapAllocations() {
+ return BaseStateImpl.getCurrentDirectMemoryMapAllocations();
+ }
+
+ /**
+ * Gets the current size of active direct memory map allocated.
+ * @return the current size of active direct memory map allocated.
+ */
+ static long getCurrentDirectMemoryMapAllocated() {
+ return BaseStateImpl.getCurrentDirectMemoryMapAllocated();
+ }
+
+ //TO STRING
+
+ /**
+ * Returns a formatted hex string of a range of this object.
+ * Used primarily for testing.
+ * @param header a descriptive header
+ * @param offsetBytes offset bytes relative to this object start
+ * @param lengthBytes number of bytes to convert to a hex string
+ * @return a formatted hex string in a human readable array
+ */
+ String toHexString(final String header, final long offsetBytes,
+ final int lengthBytes);
+
+}
diff --git a/src/main/java/org/apache/datasketches/memory/Memory.java b/src/main/java/org/apache/datasketches/memory/Memory.java
new file mode 100644
index 0000000..b170ad9
--- /dev/null
+++ b/src/main/java/org/apache/datasketches/memory/Memory.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.datasketches.memory;
+
+
+public interface Memory {
+
+}
+
+
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 97cdaf1..aef0b98 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
@@ -88,7 +88,7 @@ final class AllocateDirect implements AutoCloseable {
return false;
} finally {
- BaseState.reachabilityFence(this);
+ BaseStateImpl.reachabilityFence(this);
}
}
@@ -108,8 +108,8 @@ final class AllocateDirect implements AutoCloseable {
private final StepBoolean valid = new StepBoolean(true); //only place for this
private Deallocator(final long nativeAddress, final long allocationSize, final long capacity) {
- BaseState.currentDirectMemoryAllocations_.incrementAndGet();
- BaseState.currentDirectMemoryAllocated_.addAndGet(capacity);
+ BaseStateImpl.currentDirectMemoryAllocations_.incrementAndGet();
+ BaseStateImpl.currentDirectMemoryAllocated_.addAndGet(capacity);
this.nativeAddress = nativeAddress;
this.allocationSize = allocationSize;
this.capacity = capacity;
@@ -133,8 +133,8 @@ final class AllocateDirect implements AutoCloseable {
}
unsafe.freeMemory(nativeAddress);
NioBits.unreserveMemory(allocationSize, capacity);
- BaseState.currentDirectMemoryAllocations_.decrementAndGet();
- BaseState.currentDirectMemoryAllocated_.addAndGet(-capacity);
+ BaseStateImpl.currentDirectMemoryAllocations_.decrementAndGet();
+ BaseStateImpl.currentDirectMemoryAllocated_.addAndGet(-capacity);
return true;
}
return false;
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 eaa2d38..b5528a5 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
@@ -167,7 +167,7 @@ class AllocateDirectMap implements Map {
}
return false;
} finally {
- BaseState.reachabilityFence(this);
+ BaseStateImpl.reachabilityFence(this);
}
}
@@ -257,8 +257,8 @@ class AllocateDirectMap implements Map {
Deallocator(final long nativeBaseOffset, final long capacityBytes,
final RandomAccessFile raf) {
- BaseState.currentDirectMemoryMapAllocations_.incrementAndGet();
- BaseState.currentDirectMemoryMapAllocated_.addAndGet(capacityBytes);
+ BaseStateImpl.currentDirectMemoryMapAllocations_.incrementAndGet();
+ BaseStateImpl.currentDirectMemoryMapAllocated_.addAndGet(capacityBytes);
myRaf = raf;
assert myRaf != null;
myFc = myRaf.getChannel();
@@ -287,8 +287,8 @@ class AllocateDirectMap implements Map {
unmap();
}
finally {
- BaseState.currentDirectMemoryMapAllocations_.decrementAndGet();
- BaseState.currentDirectMemoryMapAllocated_.addAndGet(-myCapacity);
+ BaseStateImpl.currentDirectMemoryMapAllocations_.decrementAndGet();
+ BaseStateImpl.currentDirectMemoryMapAllocated_.addAndGet(-myCapacity);
}
return true;
}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java b/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
index 1b04f21..901002b 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
@@ -36,7 +36,7 @@ package org.apache.datasketches.memory.internal;
*
* @author Lee Rhodes
*/
-public abstract class BaseBuffer extends BaseState {
+public abstract class BaseBuffer extends BaseStateImpl {
private long capacity;
private long start = 0;
private long pos = 0;
diff --git a/src/main/java/org/apache/datasketches/memory/internal/BaseState.java b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
similarity index 66%
rename from src/main/java/org/apache/datasketches/memory/internal/BaseState.java
rename to src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
index 791a31d..caa3e99 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/BaseState.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseStateImpl.java
@@ -30,6 +30,7 @@ import java.util.concurrent.atomic.AtomicLong;
import org.apache.datasketches.memory.DefaultMemoryRequestServer;
import org.apache.datasketches.memory.MemoryRequestServer;
+import org.apache.datasketches.memory.BaseState;
/**
* Keeps key configuration state for Memory and Buffer plus some common static variables
@@ -38,7 +39,7 @@ import org.apache.datasketches.memory.MemoryRequestServer;
* @author Lee Rhodes
*/
@SuppressWarnings({"restriction"})
-abstract class BaseState {
+public abstract class BaseStateImpl implements BaseState {
//Monitoring
static final AtomicLong currentDirectMemoryAllocations_ = new AtomicLong();
@@ -88,7 +89,7 @@ abstract class BaseState {
* This offset does not include the size of an object array header, if there is one.
* @param capacityBytes the capacity of this object. Used by all methods when checking bounds.
*/
- BaseState(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
+ BaseStateImpl(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
final long capacityBytes) {
capacityBytes_ = capacityBytes;
cumBaseOffset_ = regionOffset + (unsafeObj == null
@@ -98,11 +99,7 @@ abstract class BaseState {
//Byte Order Related
- /**
- * Gets the current Type ByteOrder.
- * This may be different from the ByteOrder of the backing resource and of the Native Byte Order.
- * @return the current Type ByteOrder.
- */
+ @Override
public final ByteOrder getTypeByteOrder() {
return isNonNativeType() ? Util.nonNativeByteOrder : Util.nativeByteOrder;
}
@@ -119,88 +116,47 @@ abstract class BaseState {
return Util.nativeByteOrder == byteOrder;
}
- /**
- * Returns true if the Native ByteOrder is the same as the ByteOrder of the
- * current Buffer or Memory and the same ByteOrder as the given byteOrder.
- * @param byteOrder the given ByteOrder
- * @return true if the Native ByteOrder is the same as the ByteOrder of the
- * current Buffer or Memory and the same ByteOrder as the given byteOrder.
- */
+ @Override
public final boolean isByteOrderCompatible(final ByteOrder byteOrder) {
final ByteOrder typeBO = getTypeByteOrder();
return typeBO == Util.nativeByteOrder && typeBO == byteOrder;
}
- /**
- * Returns true if the given object is an instance of this class and has equal data contents.
- * @param that the given object
- * @return true if the given Object is an instance of this class and has equal data contents.
- */
@Override
public final boolean equals(final Object that) {
if (this == that) { return true; }
- return that instanceof BaseState
- ? CompareAndCopy.equals(this, (BaseState) that)
+ return that instanceof BaseStateImpl
+ ? CompareAndCopy.equals(this, (BaseStateImpl) that)
: false;
}
- /**
- * Returns true if the given object is an instance of this class and has equal contents to
- * this object in the given range of bytes. This will also check two distinct ranges within the
- * same object for eauals.
- * @param thisOffsetBytes the starting offset in bytes for this object.
- * @param that the given object
- * @param thatOffsetBytes the starting offset in bytes for the given object
- * @param lengthBytes the size of the range in bytes
- * @return true if the given object has equal contents to this object in the given range of
- * bytes.
- */
+ @Override
public final boolean equalTo(final long thisOffsetBytes, final Object that,
final long thatOffsetBytes, final long lengthBytes) {
- return that instanceof BaseState
- ? CompareAndCopy.equals(this, thisOffsetBytes, (BaseState) that, thatOffsetBytes, lengthBytes)
+ return that instanceof BaseStateImpl
+ ? CompareAndCopy.equals(this, thisOffsetBytes, (BaseStateImpl) that, thatOffsetBytes, lengthBytes)
: false;
}
- /**
- * Gets the backing ByteBuffer if it exists, otherwise returns null.
- * @return the backing ByteBuffer if it exists, otherwise returns null.
- */
//Overridden by ByteBuffer Leafs
+ @Override
public ByteBuffer getByteBuffer() {
return null;
}
- /**
- * Gets the capacity of this object in bytes
- * @return the capacity of this object in bytes
- */
+ @Override
public final long getCapacity() {
assertValid();
return capacityBytes_;
}
- /**
- * Gets the cumulative offset in bytes of this object from the backing resource.
- * This offset may also include other offset components such as the native off-heap
- * memory address, DirectByteBuffer split offsets, region offsets, and unsafe arrayBaseOffsets.
- *
- * @return the cumulative offset in bytes of this object from the backing resource.
- */
+ @Override
public final long getCumulativeOffset() {
assertValid();
return cumBaseOffset_;
}
- /**
- * Gets the cumulative offset in bytes of this object from the backing resource including the given
- * offsetBytes. This offset may also include other offset components such as the native off-heap
- * memory address, DirectByteBuffer split offsets, region offsets, and unsafe arrayBaseOffsets.
- *
- * @param offsetBytes offset to be added to the cumulative offset.
- * @return the cumulative offset in bytes of this object from the backing resource including the
- * given offsetBytes.
- */
+ @Override
public final long getCumulativeOffset(final long offsetBytes) {
assertValid();
return cumBaseOffset_ + offsetBytes;
@@ -214,12 +170,7 @@ abstract class BaseState {
return 0;
}
- /**
- * Returns the offset of address zero of this object relative to the address zero of the
- * backing resource but not including the size of any Java object header.
- * @return the offset of address zero of this object relative to the address zero of the
- * backing resource but not including the size of any Java object header.
- */
+ @Override
public final long getRegionOffset() {
final Object unsafeObj = getUnsafeObject();
return unsafeObj == null
@@ -227,15 +178,7 @@ abstract class BaseState {
: cumBaseOffset_ - UnsafeUtil.getArrayBaseOffset(unsafeObj.getClass());
}
- /**
- * Returns the offset of address zero of this object relative to the address zero of the
- * backing resource plus the given offsetBytes but not including the size of any Java object
- * header.
- * @param offsetBytes the given offsetBytes
- * @return the offset of address zero of this object relative to the address zero of the
- * backing resource plus the given offsetBytes but not including the size of any Java object
- * header.
- */
+ @Override
public final long getRegionOffset(final long offsetBytes) {
return getRegionOffset() + offsetBytes;
}
@@ -249,87 +192,45 @@ abstract class BaseState {
return null;
}
- /**
- * Returns true if this object is backed by an on-heap primitive array
- * @return true if this object is backed by an on-heap primitive array
- */
+ @Override
public final boolean hasArray() {
assertValid();
return getUnsafeObject() != null;
}
- /**
- * Returns the hashCode of this object.
- *
- * <p>The hash code of this object depends upon all of its contents.
- * Because of this, it is inadvisable to use these objects as keys in hash maps
- * or similar data structures unless it is known that their contents will not change.</p>
- *
- * <p>If it is desirable to use these objects in a hash map depending only on object identity,
- * than the {@link java.util.IdentityHashMap} can be used.</p>
- *
- * @return the hashCode of this object.
- */
@Override
public final int hashCode() {
return (int) xxHash64(0, capacityBytes_, 0); //xxHash64() calls checkValid()
}
- /**
- * Returns the 64-bit hash of the sequence of bytes in this object specified by
- * <i>offsetBytes</i>, <i>lengthBytes</i> and a <i>seed</i>. Note that the sequence of bytes is
- * always processed in the same order independent of endianness.
- *
- * @param offsetBytes the given offset in bytes to the first byte of the byte sequence.
- * @param lengthBytes the given length in bytes of the byte sequence.
- * @param seed the given long seed.
- * @return the 64-bit hash of the sequence of bytes in this object specified by
- * <i>offsetBytes</i> and <i>lengthBytes</i>.
- */
+ @Override
public final long xxHash64(final long offsetBytes, final long lengthBytes, final long seed) {
checkValid();
return XxHash64.hash(getUnsafeObject(), cumBaseOffset_ + offsetBytes, lengthBytes, seed);
}
- /**
- * Returns true if this Memory is backed by a ByteBuffer.
- * @return true if this Memory is backed by a ByteBuffer.
- */
+ @Override
public final boolean hasByteBuffer() {
assertValid();
return getByteBuffer() != null;
}
- /**
- * Returns true if the backing resource is direct (off-heap) memory.
- * This is the case for allocated direct memory, memory mapped files,
- * @return true if the backing resource is direct (off-heap) memory.
- */
+ @Override
public final boolean isDirect() {
return getUnsafeObject() == null;
}
- /**
- * Returns true if this object or the backing resource is read-only.
- * @return true if this object or the backing resource is read-only.
- */
+ @Override
public final boolean isReadOnly() {
assertValid();
return isReadOnlyType();
}
- /**
- * Returns true if the backing resource of <i>this</i> is identical with the backing resource
- * of <i>that</i>. The capacities must be the same. If <i>this</i> is a region,
- * the region offset must also be the same.
- * @param that A different non-null object
- * @return true if the backing resource of <i>this</i> is the same as the backing resource
- * of <i>that</i>.
- */
+ @Override
public final boolean isSameResource(final Object that) {
checkValid();
if (that == null) { return false; }
- final BaseState that1 = (BaseState) that;
+ final BaseStateImpl that1 = (BaseStateImpl) that;
that1.checkValid();
if (this == that1) { return true; }
@@ -339,12 +240,8 @@ abstract class BaseState {
&& getByteBuffer() == that1.getByteBuffer();
}
- /**
- * Returns true if this object is valid and has not been closed.
- * This is relevant only for direct (off-heap) memory and Mapped Files.
- * @return true if this object is valid and has not been closed.
- */
//Overridden by Direct and Map leafs
+ @Override
public boolean isValid() {
return true;
}
@@ -377,13 +274,7 @@ abstract class BaseState {
assert !isReadOnly() : "Memory is read-only.";
}
- /**
- * Checks that the specified range of bytes is within bounds of this object, throws
- * {@link IllegalArgumentException} if it's not: i. e. if offsetBytes < 0, or length < 0,
- * or offsetBytes + length > {@link #getCapacity()}.
- * @param offsetBytes the given offset in bytes of this object
- * @param lengthBytes the given length in bytes of this object
- */
+ @Override
public final void checkValidAndBounds(final long offsetBytes, final long lengthBytes) {
checkValid();
//read capacityBytes_ directly to eliminate extra checkValid() call
@@ -437,12 +328,13 @@ abstract class BaseState {
}
//MONITORING
+
/**
* Gets the current number of active direct memory allocations.
* @return the current number of active direct memory allocations.
*/
public static final long getCurrentDirectMemoryAllocations() {
- return BaseState.currentDirectMemoryAllocations_.get();
+ return BaseStateImpl.currentDirectMemoryAllocations_.get();
}
/**
@@ -450,7 +342,7 @@ abstract class BaseState {
* @return the current size of active direct memory allocated.
*/
public static final long getCurrentDirectMemoryAllocated() {
- return BaseState.currentDirectMemoryAllocated_.get();
+ return BaseStateImpl.currentDirectMemoryAllocated_.get();
}
/**
@@ -458,7 +350,7 @@ abstract class BaseState {
* @return the current number of active direct memory map allocations.
*/
public static final long getCurrentDirectMemoryMapAllocations() {
- return BaseState.currentDirectMemoryMapAllocations_.get();
+ return BaseStateImpl.currentDirectMemoryMapAllocations_.get();
}
/**
@@ -466,21 +358,15 @@ abstract class BaseState {
* @return the current size of active direct memory map allocated.
*/
public static final long getCurrentDirectMemoryMapAllocated() {
- return BaseState.currentDirectMemoryMapAllocated_.get();
+ return BaseStateImpl.currentDirectMemoryMapAllocated_.get();
}
//REACHABILITY FENCE
static void reachabilityFence(@SuppressWarnings("unused") final Object obj) { }
//TO STRING
- /**
- * Returns a formatted hex string of a range of this object.
- * Used primarily for testing.
- * @param header a descriptive header
- * @param offsetBytes offset bytes relative to this object start
- * @param lengthBytes number of bytes to convert to a hex string
- * @return a formatted hex string in a human readable array
- */
+
+ @Override
public final String toHexString(final String header, final long offsetBytes,
final int lengthBytes) {
checkValid();
@@ -498,13 +384,13 @@ abstract class BaseState {
/**
* Returns a formatted hex string of an area of this object.
* Used primarily for testing.
- * @param state the BaseState
+ * @param state the BaseStateImpl
* @param preamble a descriptive header
* @param offsetBytes offset bytes relative to the Memory start
* @param lengthBytes number of bytes to convert to a hex string
* @return a formatted hex string in a human readable array
*/
- static final String toHex(final BaseState state, final String preamble, final long offsetBytes,
+ static final String toHex(final BaseStateImpl state, final String preamble, final long offsetBytes,
final int lengthBytes) {
final long capacity = state.getCapacity();
UnsafeUtil.checkBounds(offsetBytes, lengthBytes, capacity);
diff --git a/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
index fa6662a..0baf90a 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
@@ -38,8 +38,8 @@ final class CompareAndCopy {
private CompareAndCopy() { }
static int compare(
- final BaseState state1, final long offsetBytes1, final long lengthBytes1,
- final BaseState state2, final long offsetBytes2, final long lengthBytes2) {
+ final BaseStateImpl state1, final long offsetBytes1, final long lengthBytes1,
+ final BaseStateImpl state2, final long offsetBytes2, final long lengthBytes2) {
state1.checkValid();
checkBounds(offsetBytes1, lengthBytes1, state1.getCapacity());
state2.checkValid();
@@ -60,7 +60,7 @@ final class CompareAndCopy {
return Long.compare(lengthBytes1, lengthBytes2);
}
- static boolean equals(final BaseState state1, final BaseState state2) {
+ static boolean equals(final BaseStateImpl state1, final BaseStateImpl state2) {
final long cap1 = state1.getCapacity();
final long cap2 = state2.getCapacity();
return (cap1 == cap2) && equals(state1, 0, state2, 0, cap1);
@@ -70,8 +70,8 @@ final class CompareAndCopy {
// stop if the arrays and offsets are the same as there is only one length. Also this can take
// advantage of chunking with longs, while compare cannot.
static boolean equals(
- final BaseState state1, final long offsetBytes1,
- final BaseState state2, final long offsetBytes2, long lengthBytes) {
+ final BaseStateImpl state1, final long offsetBytes1,
+ final BaseStateImpl state2, final long offsetBytes2, long lengthBytes) {
state1.checkValid();
checkBounds(offsetBytes1, lengthBytes, state1.getCapacity());
state2.checkValid();
@@ -112,8 +112,8 @@ final class CompareAndCopy {
return true;
}
- static void copy(final BaseState srcState, final long srcOffsetBytes,
- final BaseState dstState, final long dstOffsetBytes, final long lengthBytes) {
+ static void copy(final BaseStateImpl srcState, final long srcOffsetBytes,
+ final BaseStateImpl dstState, final long dstOffsetBytes, final long lengthBytes) {
srcState.checkValid();
checkBounds(srcOffsetBytes, lengthBytes, srcState.getCapacity());
dstState.checkValid();
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 2802aef..25fbdbb 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Memory.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Memory.java
@@ -41,7 +41,7 @@ import org.apache.datasketches.memory.MapHandle;
*
* @see org.apache.datasketches.memory.internal
*/
-public abstract class Memory extends BaseState {
+public abstract class Memory extends BaseStateImpl {
//Pass-through ctor
Memory(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
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 f58caa4..a6b8640 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
@@ -248,7 +248,7 @@ public class AllocateDirectWritableMapMemoryTest {
@AfterClass
public void checkDirectCounter() {
long count = getCurrentDirectMemoryMapAllocations();
- //final long count = BaseState.getCurrentDirectMemoryMapAllocations();
+ //final long count = BaseStateImpl.getCurrentDirectMemoryMapAllocations();
if (count != 0) {
println(""+count);
fail();
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 b567aae..daea055 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
@@ -35,24 +35,24 @@ public final class ReflectUtil {
static final Class<?> ALLOCATE_DIRECT_MAP;
static final Class<?> NIO_BITS;
- static final Method CHECK_VALID; //BaseState
+ static final Method CHECK_VALID; //BaseStateImpl
static final Method GET_DIRECT_ALLOCATIONS_COUNT; //NioBits
static final Method GET_MAX_DIRECT_BYTE_BUFFER_MEMORY; //NioBits
- static final Method GET_NATIVE_BASE_OFFSET; //BaseState
+ static final Method GET_NATIVE_BASE_OFFSET; //BaseStateImpl
static final Method GET_RESERVED_MEMORY; //NioBits
static final Method GET_TOTAL_CAPACITY; //NioBits
- static final Method GET_UNSAFE_OBJECT; //BaseState
- static final Method IS_BB_TYPE; //BaseState
- static final Method IS_BUFFER_TYPE; //BaseState
- static final Method IS_DIRECT_TYPE; //BaseState
- static final Method IS_DUPLICATE_TYPE; //BaseState
+ static final Method GET_UNSAFE_OBJECT; //BaseStateImpl
+ static final Method IS_BB_TYPE; //BaseStateImpl
+ static final Method IS_BUFFER_TYPE; //BaseStateImpl
+ static final Method IS_DIRECT_TYPE; //BaseStateImpl
+ static final Method IS_DUPLICATE_TYPE; //BaseStateImpl
static final Method IS_FILE_READ_ONLY; //AllocateDirectMap
- static final Method IS_HEAP_TYPE; //BaseState
- static final Method IS_MAP_TYPE; //BaseState
- static final Method IS_NON_NATIVE_TYPE; //BaseState
+ static final Method IS_HEAP_TYPE; //BaseStateImpl
+ static final Method IS_MAP_TYPE; //BaseStateImpl
+ static final Method IS_NON_NATIVE_TYPE; //BaseStateImpl
static final Method IS_PAGE_ALIGHED; //NioBits
- static final Method IS_READ_ONLY_TYPE; //BaseState
- static final Method IS_REGION_TYPE; //BaseState
+ static final Method IS_READ_ONLY_TYPE; //BaseStateImpl
+ static final Method IS_REGION_TYPE; //BaseStateImpl
static final Method PAGE_COUNT; //NioBits
static final Method PAGE_SIZE; //NioBits
static final Method RESERVE_MEMORY; //NioBits
@@ -61,7 +61,7 @@ public final class ReflectUtil {
static {
BASE_STATE =
- getClass("org.apache.datasketches.memory.internal.BaseState");
+ getClass("org.apache.datasketches.memory.internal.BaseStateImpl");
BASE_WRITABLE_MEMORY_IMPL =
getClass("org.apache.datasketches.memory.internal.BaseWritableMemoryImpl");
ALLOCATE_DIRECT_MAP =
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 81f6c82..bf7924e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
@@ -100,7 +100,7 @@ public class XxHash64Test {
}
/**
- * This simple test compares the output of {@link BaseState#xxHash64(long, long, long)} with the
+ * This simple test compares the output of {@link BaseStateImpl#xxHash64(long, long, long)} with the
* output of {@link net.openhft.hashing.LongHashFunction}, that itself is tested against the
* reference implementation in C. This increase confidence that the xxHash function implemented
* in this package is in fact the same xxHash function implemented in C.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 01/08: Initial rename of ../memory to
../memory/internal
Posted by le...@apache.org.
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 625ffa0b036ccb41d394b942e8d77d097d205f35
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Fri May 14 14:12:15 2021 -0700
Initial rename of ../memory to ../memory/internal
---
.../java/org/apache/datasketches/memory/Prim.java | 88 ----------------------
.../memory/{ => internal}/AccessByteBuffer.java | 4 +-
.../memory/{ => internal}/AllocateDirect.java | 4 +-
.../memory/{ => internal}/AllocateDirectMap.java | 4 +-
.../{ => internal}/AllocateDirectWritableMap.java | 2 +-
.../BBNonNativeWritableBufferImpl.java | 2 +-
.../BBNonNativeWritableMemoryImpl.java | 2 +-
.../{ => internal}/BBWritableBufferImpl.java | 2 +-
.../{ => internal}/BBWritableMemoryImpl.java | 2 +-
.../memory/{ => internal}/BaseBuffer.java | 2 +-
.../memory/{ => internal}/BaseState.java | 10 +--
.../{ => internal}/BaseWritableBufferImpl.java | 24 +++---
.../{ => internal}/BaseWritableMemoryImpl.java | 24 +++---
.../datasketches/memory/{ => internal}/Buffer.java | 4 +-
.../memory/{ => internal}/CompareAndCopy.java | 22 +++---
.../{ => internal}/DefaultMemoryRequestServer.java | 2 +-
.../DirectNonNativeWritableBufferImpl.java | 2 +-
.../DirectNonNativeWritableMemoryImpl.java | 2 +-
.../{ => internal}/DirectWritableBufferImpl.java | 2 +-
.../{ => internal}/DirectWritableMemoryImpl.java | 2 +-
.../datasketches/memory/{ => internal}/Handle.java | 2 +-
.../HeapNonNativeWritableBufferImpl.java | 2 +-
.../HeapNonNativeWritableMemoryImpl.java | 2 +-
.../{ => internal}/HeapWritableBufferImpl.java | 2 +-
.../{ => internal}/HeapWritableMemoryImpl.java | 2 +-
.../datasketches/memory/{ => internal}/Ints.java | 2 +-
.../datasketches/memory/{ => internal}/Map.java | 2 +-
.../memory/{ => internal}/MapHandle.java | 2 +-
.../MapNonNativeWritableBufferImpl.java | 2 +-
.../MapNonNativeWritableMemoryImpl.java | 2 +-
.../{ => internal}/MapWritableBufferImpl.java | 2 +-
.../{ => internal}/MapWritableMemoryImpl.java | 2 +-
.../datasketches/memory/{ => internal}/Memory.java | 10 +--
.../memory/{ => internal}/MemoryRequestServer.java | 2 +-
.../memory/{ => internal}/NioBits.java | 4 +-
.../NonNativeWritableBufferImpl.java | 22 +++---
.../NonNativeWritableMemoryImpl.java | 24 +++---
.../apache/datasketches/memory/internal/Prim.java | 88 ++++++++++++++++++++++
.../memory/{ => internal}/ReadOnlyException.java | 2 +-
.../memory/{ => internal}/StepBoolean.java | 2 +-
.../memory/{ => internal}/UnsafeUtil.java | 2 +-
.../datasketches/memory/{ => internal}/Utf8.java | 4 +-
.../memory/{ => internal}/Utf8CodingException.java | 2 +-
.../datasketches/memory/{ => internal}/Util.java | 4 +-
.../memory/{ => internal}/WritableBuffer.java | 2 +-
.../memory/{ => internal}/WritableBufferImpl.java | 36 ++++-----
.../{ => internal}/WritableDirectHandle.java | 2 +-
.../memory/{ => internal}/WritableHandle.java | 2 +-
.../memory/{ => internal}/WritableMap.java | 2 +-
.../memory/{ => internal}/WritableMapHandle.java | 2 +-
.../memory/{ => internal}/WritableMemory.java | 8 +-
.../memory/{ => internal}/WritableMemoryImpl.java | 38 +++++-----
.../memory/{ => internal}/XxHash64.java | 34 ++++-----
.../memory/{ => internal}/package-info.java | 18 ++---
.../memory/test/AllocateDirectMapMemoryTest.java | 6 +-
.../memory/test/AllocateDirectMemoryTest.java | 10 +--
.../test/AllocateDirectWritableMapMemoryTest.java | 16 ++--
.../datasketches/memory/test/BaseBufferTest.java | 8 +-
.../datasketches/memory/test/BaseStateTest.java | 16 ++--
.../datasketches/memory/test/Buffer2Test.java | 10 +--
.../memory/test/BufferBoundaryCheckTest.java | 2 +-
.../memory/test/BufferInvariantsTest.java | 8 +-
.../memory/test/BufferReadWriteSafetyTest.java | 8 +-
.../datasketches/memory/test/BufferTest.java | 10 +--
.../datasketches/memory/test/CommonBufferTest.java | 6 +-
.../datasketches/memory/test/CommonMemoryTest.java | 12 +--
.../memory/test/CopyMemoryOverlapTest.java | 6 +-
.../datasketches/memory/test/CopyMemoryTest.java | 8 +-
.../test/ExampleMemoryRequestServerTest.java | 6 +-
.../memory/test/IgnoredArrayOverflowTest.java | 4 +-
.../datasketches/memory/test/LeafImplTest.java | 10 +--
.../memory/test/MemoryBoundaryCheckTest.java | 4 +-
.../memory/test/MemoryReadWriteSafetyTest.java | 8 +-
.../datasketches/memory/test/MemoryTest.java | 14 ++--
.../memory/test/MemoryWriteToTest.java | 9 ++-
.../test/NonNativeWritableBufferImplTest.java | 6 +-
.../test/NonNativeWritableMemoryImplTest.java | 4 +-
.../datasketches/memory/test/ReflectUtil.java | 12 +--
.../datasketches/memory/test/SpecificLeafTest.java | 12 +--
.../datasketches/memory/test/UnsafeUtilTest.java | 4 +-
.../apache/datasketches/memory/test/Utf8Test.java | 9 +--
.../apache/datasketches/memory/test/UtilTest.java | 20 ++---
.../memory/test/WritableBufferImplTest.java | 16 ++--
.../memory/test/WritableDirectCopyTest.java | 6 +-
.../memory/test/WritableMemoryImplTest.java | 16 ++--
.../memory/test/WritableMemoryTest.java | 8 +-
.../memory/test/XxHash64LoopingTest.java | 2 +-
.../datasketches/memory/test/XxHash64Test.java | 13 +---
.../datasketches/memory/test/ZeroCapacityTest.java | 4 +-
89 files changed, 423 insertions(+), 430 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/Prim.java b/src/main/java/org/apache/datasketches/memory/Prim.java
deleted file mode 100644
index 9b956bd..0000000
--- a/src/main/java/org/apache/datasketches/memory/Prim.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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 org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BOOLEAN_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BYTE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_CHAR_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_INT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_OBJECT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_OBJECT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_SHORT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.BOOLEAN_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.BYTE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.OBJECT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.SHORT_SHIFT;
-
-/**
- * Creates easy to access association between the major Unsafe constants.
- *
- * @author Lee Rhodes
- */
-public enum Prim {
- BOOLEAN(ARRAY_BOOLEAN_BASE_OFFSET, ARRAY_BOOLEAN_INDEX_SCALE, BOOLEAN_SHIFT),
- BYTE(ARRAY_BYTE_BASE_OFFSET, ARRAY_BYTE_INDEX_SCALE, BYTE_SHIFT),
- CHAR(ARRAY_CHAR_BASE_OFFSET, ARRAY_CHAR_INDEX_SCALE, CHAR_SHIFT),
- SHORT(ARRAY_SHORT_BASE_OFFSET, ARRAY_SHORT_INDEX_SCALE, SHORT_SHIFT),
- INT(ARRAY_INT_BASE_OFFSET, ARRAY_INT_INDEX_SCALE, INT_SHIFT),
- LONG(ARRAY_LONG_BASE_OFFSET, ARRAY_LONG_INDEX_SCALE, LONG_SHIFT),
- FLOAT(ARRAY_FLOAT_BASE_OFFSET, ARRAY_FLOAT_INDEX_SCALE, FLOAT_SHIFT),
- DOUBLE(ARRAY_DOUBLE_BASE_OFFSET, ARRAY_DOUBLE_INDEX_SCALE, DOUBLE_SHIFT),
- OBJECT(ARRAY_OBJECT_BASE_OFFSET, ARRAY_OBJECT_INDEX_SCALE, OBJECT_SHIFT);
-
- private final long arrBaseOff_;
- private final long arrIdxScale_;
- private final long sizeShift_;
-
- private Prim(final long arrBaseOff, final long arrIdxScale, final long sizeShift) {
- this.arrBaseOff_ = arrBaseOff;
- this.arrIdxScale_ = arrIdxScale;
- this.sizeShift_ = sizeShift;
- }
-
- public long off() {
- return arrBaseOff_;
- }
-
- public long scale() {
- return arrIdxScale_;
- }
-
- public long shift() {
- return sizeShift_;
- }
-
-}
diff --git a/src/main/java/org/apache/datasketches/memory/AccessByteBuffer.java b/src/main/java/org/apache/datasketches/memory/internal/AccessByteBuffer.java
similarity index 96%
rename from src/main/java/org/apache/datasketches/memory/AccessByteBuffer.java
rename to src/main/java/org/apache/datasketches/memory/internal/AccessByteBuffer.java
index 697bbe8..9004beb 100644
--- a/src/main/java/org/apache/datasketches/memory/AccessByteBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AccessByteBuffer.java
@@ -17,9 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/AllocateDirect.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
similarity index 97%
rename from src/main/java/org/apache/datasketches/memory/AllocateDirect.java
rename to src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
index b031ce0..423c02c 100644
--- a/src/main/java/org/apache/datasketches/memory/AllocateDirect.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
@@ -17,9 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
diff --git a/src/main/java/org/apache/datasketches/memory/AllocateDirectMap.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/AllocateDirectMap.java
rename to src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
index 25bfef7..6272b5b 100644
--- a/src/main/java/org/apache/datasketches/memory/AllocateDirectMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectMap.java
@@ -17,9 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import java.io.File;
import java.io.FileDescriptor;
diff --git a/src/main/java/org/apache/datasketches/memory/AllocateDirectWritableMap.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
similarity index 97%
rename from src/main/java/org/apache/datasketches/memory/AllocateDirectWritableMap.java
rename to src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
index d0b1046..588dbef 100644
--- a/src/main/java/org/apache/datasketches/memory/AllocateDirectWritableMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirectWritableMap.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.io.File;
diff --git a/src/main/java/org/apache/datasketches/memory/BBNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/BBNonNativeWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableBufferImpl.java
index cc01a7e..2e631e7 100644
--- a/src/main/java/org/apache/datasketches/memory/BBNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/BBNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/BBNonNativeWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableMemoryImpl.java
index 4f83901..3c1c3e7 100644
--- a/src/main/java/org/apache/datasketches/memory/BBNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBNonNativeWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/BBWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/BBWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/BBWritableBufferImpl.java
index 20802b9..bf0d2ee 100644
--- a/src/main/java/org/apache/datasketches/memory/BBWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/BBWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BBWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/BBWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/BBWritableMemoryImpl.java
index dd06c0b..364bc8e 100644
--- a/src/main/java/org/apache/datasketches/memory/BBWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BBWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/BaseBuffer.java b/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
similarity index 99%
rename from src/main/java/org/apache/datasketches/memory/BaseBuffer.java
rename to src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
index 30e1ea7..1b04f21 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseBuffer.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* A new positional API. This is different from and simpler than Java Buffer positional approach.
diff --git a/src/main/java/org/apache/datasketches/memory/BaseState.java b/src/main/java/org/apache/datasketches/memory/internal/BaseState.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/BaseState.java
rename to src/main/java/org/apache/datasketches/memory/internal/BaseState.java
index 82f4e7d..9bb685b 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseState.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseState.java
@@ -17,12 +17,12 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.UnsafeUtil.LS;
-import static org.apache.datasketches.memory.UnsafeUtil.assertBounds;
-import static org.apache.datasketches.memory.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LS;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.assertBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/BaseWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
similarity index 94%
rename from src/main/java/org/apache/datasketches/memory/BaseWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
index 32e43ec..0402e0a 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableBufferImpl.java
@@ -17,18 +17,18 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BOOLEAN_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BYTE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_CHAR_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_INT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_SHORT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BOOLEAN_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BYTE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/BaseWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
similarity index 95%
rename from src/main/java/org/apache/datasketches/memory/BaseWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
index 184c1f3..5ba6c27 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/BaseWritableMemoryImpl.java
@@ -17,18 +17,18 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BOOLEAN_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BYTE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_CHAR_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_INT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_SHORT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BOOLEAN_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BYTE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import java.io.File;
import java.io.IOException;
diff --git a/src/main/java/org/apache/datasketches/memory/Buffer.java b/src/main/java/org/apache/datasketches/memory/internal/Buffer.java
similarity index 99%
rename from src/main/java/org/apache/datasketches/memory/Buffer.java
rename to src/main/java/org/apache/datasketches/memory/internal/Buffer.java
index 6877057..5380e56 100644
--- a/src/main/java/org/apache/datasketches/memory/Buffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Buffer.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
@@ -29,7 +29,7 @@ import java.nio.ByteOrder;
* @author Roman Leventov
* @author Lee Rhodes
*
- * @see org.apache.datasketches.memory
+ * @see org.apache.datasketches.memory.internal
*/
public abstract class Buffer extends BaseBuffer {
diff --git a/src/main/java/org/apache/datasketches/memory/CompareAndCopy.java b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
similarity index 97%
rename from src/main/java/org/apache/datasketches/memory/CompareAndCopy.java
rename to src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
index 75cbf0f..fa6662a 100644
--- a/src/main/java/org/apache/datasketches/memory/CompareAndCopy.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/CompareAndCopy.java
@@ -17,17 +17,17 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
-import static org.apache.datasketches.memory.Util.UNSAFE_COPY_THRESHOLD_BYTES;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.Util.UNSAFE_COPY_THRESHOLD_BYTES;
/**
* @author Lee Rhodes
diff --git a/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/internal/DefaultMemoryRequestServer.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
rename to src/main/java/org/apache/datasketches/memory/internal/DefaultMemoryRequestServer.java
index 616f59b..20c481a 100644
--- a/src/main/java/org/apache/datasketches/memory/DefaultMemoryRequestServer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DefaultMemoryRequestServer.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* This is a simple implementation of the MemoryRequestServer that creates space on the Java heap
diff --git a/src/main/java/org/apache/datasketches/memory/DirectNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/DirectNonNativeWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
index db02695..442768c 100644
--- a/src/main/java/org/apache/datasketches/memory/DirectNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/DirectNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/DirectNonNativeWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
index 6649830..9d38861 100644
--- a/src/main/java/org/apache/datasketches/memory/DirectNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectNonNativeWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/DirectWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/DirectWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
index 076910f..bc54da4 100644
--- a/src/main/java/org/apache/datasketches/memory/DirectWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/DirectWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/DirectWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
index 7295e1c..a377782 100644
--- a/src/main/java/org/apache/datasketches/memory/DirectWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/DirectWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/Handle.java b/src/main/java/org/apache/datasketches/memory/internal/Handle.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/Handle.java
rename to src/main/java/org/apache/datasketches/memory/internal/Handle.java
index 7575253..dc5493f 100644
--- a/src/main/java/org/apache/datasketches/memory/Handle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Handle.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* A handle for read-only resource.
diff --git a/src/main/java/org/apache/datasketches/memory/HeapNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/HeapNonNativeWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableBufferImpl.java
index f7e2838..f0f1fef 100644
--- a/src/main/java/org/apache/datasketches/memory/HeapNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/HeapNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/HeapNonNativeWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableMemoryImpl.java
index 359a8c6..89d223b 100644
--- a/src/main/java/org/apache/datasketches/memory/HeapNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapNonNativeWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/HeapWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/HeapWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/HeapWritableBufferImpl.java
index 0e3cb56..e2d35b8 100644
--- a/src/main/java/org/apache/datasketches/memory/HeapWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/HeapWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/HeapWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/HeapWritableMemoryImpl.java
index 147702e..ead8a7b 100644
--- a/src/main/java/org/apache/datasketches/memory/HeapWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/HeapWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/Ints.java b/src/main/java/org/apache/datasketches/memory/internal/Ints.java
similarity index 95%
rename from src/main/java/org/apache/datasketches/memory/Ints.java
rename to src/main/java/org/apache/datasketches/memory/internal/Ints.java
index 455f579..4a80336 100644
--- a/src/main/java/org/apache/datasketches/memory/Ints.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Ints.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/** Equivalent of Guava's Ints. */
public final class Ints {
diff --git a/src/main/java/org/apache/datasketches/memory/Map.java b/src/main/java/org/apache/datasketches/memory/internal/Map.java
similarity index 96%
rename from src/main/java/org/apache/datasketches/memory/Map.java
rename to src/main/java/org/apache/datasketches/memory/internal/Map.java
index 339ed07..f17a24f 100644
--- a/src/main/java/org/apache/datasketches/memory/Map.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Map.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* Read only interface for a memory mapped file
diff --git a/src/main/java/org/apache/datasketches/memory/MapHandle.java b/src/main/java/org/apache/datasketches/memory/internal/MapHandle.java
similarity index 97%
rename from src/main/java/org/apache/datasketches/memory/MapHandle.java
rename to src/main/java/org/apache/datasketches/memory/internal/MapHandle.java
index 181c818..5e8114c 100644
--- a/src/main/java/org/apache/datasketches/memory/MapHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapHandle.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* A Handle for a memory-mapped, read-only file resource.
diff --git a/src/main/java/org/apache/datasketches/memory/MapNonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/MapNonNativeWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
index 2ab9c58..28e1e98 100644
--- a/src/main/java/org/apache/datasketches/memory/MapNonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/MapNonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/MapNonNativeWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableMemoryImpl.java
index 05f6989..9d9e42d 100644
--- a/src/main/java/org/apache/datasketches/memory/MapNonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapNonNativeWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/MapWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/MapWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
index 6aab451..cde1289 100644
--- a/src/main/java/org/apache/datasketches/memory/MapWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapWritableBufferImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/MapWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/MapWritableMemoryImpl.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/MapWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/MapWritableMemoryImpl.java
index 1448947..839c23f 100644
--- a/src/main/java/org/apache/datasketches/memory/MapWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MapWritableMemoryImpl.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/Memory.java b/src/main/java/org/apache/datasketches/memory/internal/Memory.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/Memory.java
rename to src/main/java/org/apache/datasketches/memory/internal/Memory.java
index c6c9ba1..a5d3751 100644
--- a/src/main/java/org/apache/datasketches/memory/Memory.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Memory.java
@@ -17,11 +17,11 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.Util.negativeCheck;
-import static org.apache.datasketches.memory.Util.nullCheck;
-import static org.apache.datasketches.memory.Util.zeroCheck;
+import static org.apache.datasketches.memory.internal.Util.negativeCheck;
+import static org.apache.datasketches.memory.internal.Util.nullCheck;
+import static org.apache.datasketches.memory.internal.Util.zeroCheck;
import java.io.File;
import java.io.IOException;
@@ -36,7 +36,7 @@ import java.nio.channels.WritableByteChannel;
* @author Roman Leventov
* @author Lee Rhodes
*
- * @see org.apache.datasketches.memory
+ * @see org.apache.datasketches.memory.internal
*/
public abstract class Memory extends BaseState {
diff --git a/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java b/src/main/java/org/apache/datasketches/memory/internal/MemoryRequestServer.java
similarity index 97%
rename from src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
rename to src/main/java/org/apache/datasketches/memory/internal/MemoryRequestServer.java
index 3d1bd69..d98ab78 100644
--- a/src/main/java/org/apache/datasketches/memory/MemoryRequestServer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/MemoryRequestServer.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* The MemoryRequestServer is a callback interface to provide a means for a direct (off-heap),
diff --git a/src/main/java/org/apache/datasketches/memory/NioBits.java b/src/main/java/org/apache/datasketches/memory/internal/NioBits.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/NioBits.java
rename to src/main/java/org/apache/datasketches/memory/internal/NioBits.java
index d3ef10b..a25985e 100644
--- a/src/main/java/org/apache/datasketches/memory/NioBits.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/NioBits.java
@@ -17,9 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
diff --git a/src/main/java/org/apache/datasketches/memory/NonNativeWritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
similarity index 93%
rename from src/main/java/org/apache/datasketches/memory/NonNativeWritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
index c2ed3bd..818a6ee 100644
--- a/src/main/java/org/apache/datasketches/memory/NonNativeWritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImpl.java
@@ -17,17 +17,17 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
/*
* Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill,
diff --git a/src/main/java/org/apache/datasketches/memory/NonNativeWritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
similarity index 92%
rename from src/main/java/org/apache/datasketches/memory/NonNativeWritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
index 8a26156..440403b 100644
--- a/src/main/java/org/apache/datasketches/memory/NonNativeWritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImpl.java
@@ -17,18 +17,18 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
/*
* Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill,
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Prim.java b/src/main/java/org/apache/datasketches/memory/internal/Prim.java
new file mode 100644
index 0000000..411be5b
--- /dev/null
+++ b/src/main/java/org/apache/datasketches/memory/internal/Prim.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BOOLEAN_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BYTE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_OBJECT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_OBJECT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.BOOLEAN_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.BYTE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.OBJECT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
+
+/**
+ * Creates easy to access association between the major Unsafe constants.
+ *
+ * @author Lee Rhodes
+ */
+public enum Prim {
+ BOOLEAN(ARRAY_BOOLEAN_BASE_OFFSET, ARRAY_BOOLEAN_INDEX_SCALE, BOOLEAN_SHIFT),
+ BYTE(ARRAY_BYTE_BASE_OFFSET, ARRAY_BYTE_INDEX_SCALE, BYTE_SHIFT),
+ CHAR(ARRAY_CHAR_BASE_OFFSET, ARRAY_CHAR_INDEX_SCALE, CHAR_SHIFT),
+ SHORT(ARRAY_SHORT_BASE_OFFSET, ARRAY_SHORT_INDEX_SCALE, SHORT_SHIFT),
+ INT(ARRAY_INT_BASE_OFFSET, ARRAY_INT_INDEX_SCALE, INT_SHIFT),
+ LONG(ARRAY_LONG_BASE_OFFSET, ARRAY_LONG_INDEX_SCALE, LONG_SHIFT),
+ FLOAT(ARRAY_FLOAT_BASE_OFFSET, ARRAY_FLOAT_INDEX_SCALE, FLOAT_SHIFT),
+ DOUBLE(ARRAY_DOUBLE_BASE_OFFSET, ARRAY_DOUBLE_INDEX_SCALE, DOUBLE_SHIFT),
+ OBJECT(ARRAY_OBJECT_BASE_OFFSET, ARRAY_OBJECT_INDEX_SCALE, OBJECT_SHIFT);
+
+ private final long arrBaseOff_;
+ private final long arrIdxScale_;
+ private final long sizeShift_;
+
+ private Prim(final long arrBaseOff, final long arrIdxScale, final long sizeShift) {
+ this.arrBaseOff_ = arrBaseOff;
+ this.arrIdxScale_ = arrIdxScale;
+ this.sizeShift_ = sizeShift;
+ }
+
+ public long off() {
+ return arrBaseOff_;
+ }
+
+ public long scale() {
+ return arrIdxScale_;
+ }
+
+ public long shift() {
+ return sizeShift_;
+ }
+
+}
diff --git a/src/main/java/org/apache/datasketches/memory/ReadOnlyException.java b/src/main/java/org/apache/datasketches/memory/internal/ReadOnlyException.java
similarity index 96%
rename from src/main/java/org/apache/datasketches/memory/ReadOnlyException.java
rename to src/main/java/org/apache/datasketches/memory/internal/ReadOnlyException.java
index ebced06..5bc8391 100644
--- a/src/main/java/org/apache/datasketches/memory/ReadOnlyException.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/ReadOnlyException.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* The exception thrown when attempting to write into a read-only Resource.
diff --git a/src/main/java/org/apache/datasketches/memory/StepBoolean.java b/src/main/java/org/apache/datasketches/memory/internal/StepBoolean.java
similarity index 97%
rename from src/main/java/org/apache/datasketches/memory/StepBoolean.java
rename to src/main/java/org/apache/datasketches/memory/internal/StepBoolean.java
index e614d4c..b678516 100644
--- a/src/main/java/org/apache/datasketches/memory/StepBoolean.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/StepBoolean.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
diff --git a/src/main/java/org/apache/datasketches/memory/UnsafeUtil.java b/src/main/java/org/apache/datasketches/memory/internal/UnsafeUtil.java
similarity index 99%
rename from src/main/java/org/apache/datasketches/memory/UnsafeUtil.java
rename to src/main/java/org/apache/datasketches/memory/internal/UnsafeUtil.java
index ffe2414..ecd2ed5 100644
--- a/src/main/java/org/apache/datasketches/memory/UnsafeUtil.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/UnsafeUtil.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
diff --git a/src/main/java/org/apache/datasketches/memory/Utf8.java b/src/main/java/org/apache/datasketches/memory/internal/Utf8.java
similarity index 99%
rename from src/main/java/org/apache/datasketches/memory/Utf8.java
rename to src/main/java/org/apache/datasketches/memory/internal/Utf8.java
index 7cf3c28..eb0d978 100644
--- a/src/main/java/org/apache/datasketches/memory/Utf8.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Utf8.java
@@ -17,12 +17,12 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import static java.lang.Character.isSurrogate;
import static java.lang.Character.isSurrogatePair;
import static java.lang.Character.toCodePoint;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
import java.io.IOException;
import java.nio.BufferOverflowException;
diff --git a/src/main/java/org/apache/datasketches/memory/Utf8CodingException.java b/src/main/java/org/apache/datasketches/memory/internal/Utf8CodingException.java
similarity index 98%
rename from src/main/java/org/apache/datasketches/memory/Utf8CodingException.java
rename to src/main/java/org/apache/datasketches/memory/internal/Utf8CodingException.java
index a90e01a..2929d7a 100644
--- a/src/main/java/org/apache/datasketches/memory/Utf8CodingException.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Utf8CodingException.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* This exception will be thrown for errors encountered during either the encoding of characters
diff --git a/src/main/java/org/apache/datasketches/memory/Util.java b/src/main/java/org/apache/datasketches/memory/internal/Util.java
similarity index 99%
rename from src/main/java/org/apache/datasketches/memory/Util.java
rename to src/main/java/org/apache/datasketches/memory/internal/Util.java
index bfdc710..7a250c7 100644
--- a/src/main/java/org/apache/datasketches/memory/Util.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Util.java
@@ -17,9 +17,9 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.UnsafeUtil.checkBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
import java.io.File;
import java.io.IOException;
diff --git a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java b/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
similarity index 99%
rename from src/main/java/org/apache/datasketches/memory/WritableBuffer.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
index 6d00607..cafa879 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableBuffer.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
diff --git a/src/main/java/org/apache/datasketches/memory/WritableBufferImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
similarity index 90%
rename from src/main/java/org/apache/datasketches/memory/WritableBufferImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
index 3fbd565..fb84563 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableBufferImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java
@@ -17,24 +17,24 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
/*
* Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill,
diff --git a/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java
similarity index 97%
rename from src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java
index 79246b0..4689191 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableDirectHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableDirectHandle.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* A Handle for a writable direct memory resource.
diff --git a/src/main/java/org/apache/datasketches/memory/WritableHandle.java b/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
similarity index 95%
rename from src/main/java/org/apache/datasketches/memory/WritableHandle.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
index f778bf6..e9361ad 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableHandle.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* A Handle for writable direct memory or a memory-mapped, writable file resource.
diff --git a/src/main/java/org/apache/datasketches/memory/WritableMap.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMap.java
similarity index 95%
rename from src/main/java/org/apache/datasketches/memory/WritableMap.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableMap.java
index ee95578..5c35c43 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableMap.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMap.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* Writable interface for a memory mapped file
diff --git a/src/main/java/org/apache/datasketches/memory/WritableMapHandle.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java
similarity index 96%
rename from src/main/java/org/apache/datasketches/memory/WritableMapHandle.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java
index d6cdb30..8404855 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableMapHandle.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMapHandle.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
/**
* A Handle for a memory-mapped, writable file resource.
diff --git a/src/main/java/org/apache/datasketches/memory/WritableMemory.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java
similarity index 99%
rename from src/main/java/org/apache/datasketches/memory/WritableMemory.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java
index 84f3d85..e442eb0 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableMemory.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java
@@ -17,11 +17,11 @@
* under the License.
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.Util.negativeCheck;
-import static org.apache.datasketches.memory.Util.nullCheck;
-import static org.apache.datasketches.memory.Util.zeroCheck;
+import static org.apache.datasketches.memory.internal.Util.negativeCheck;
+import static org.apache.datasketches.memory.internal.Util.nullCheck;
+import static org.apache.datasketches.memory.internal.Util.zeroCheck;
import java.io.File;
import java.io.IOException;
diff --git a/src/main/java/org/apache/datasketches/memory/WritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
similarity index 88%
rename from src/main/java/org/apache/datasketches/memory/WritableMemoryImpl.java
rename to src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
index d85fecc..7c416b0 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
@@ -17,25 +17,25 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
/*
* Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill,
diff --git a/src/main/java/org/apache/datasketches/memory/XxHash64.java b/src/main/java/org/apache/datasketches/memory/internal/XxHash64.java
similarity index 88%
rename from src/main/java/org/apache/datasketches/memory/XxHash64.java
rename to src/main/java/org/apache/datasketches/memory/internal/XxHash64.java
index dd0715c..1942403 100644
--- a/src/main/java/org/apache/datasketches/memory/XxHash64.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/XxHash64.java
@@ -17,23 +17,23 @@
* under the License.
*/
-package org.apache.datasketches.memory;
-
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
-import static org.apache.datasketches.memory.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
+package org.apache.datasketches.memory.internal;
+
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BOOLEAN_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_BYTE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
/**
* The XxHash is a fast, non-cryptographic, 64-bit hash function that has
diff --git a/src/main/java/org/apache/datasketches/memory/package-info.java b/src/main/java/org/apache/datasketches/memory/internal/package-info.java
similarity index 92%
rename from src/main/java/org/apache/datasketches/memory/package-info.java
rename to src/main/java/org/apache/datasketches/memory/internal/package-info.java
index 6cfbe5f..45ef820 100644
--- a/src/main/java/org/apache/datasketches/memory/package-info.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/package-info.java
@@ -26,10 +26,10 @@
*
* <p>In addition, this package provides:</p>
*
- * <ul><li>Two different access APIs: read-only {@link org.apache.datasketches.memory.Memory} and
- * {@link org.apache.datasketches.memory.WritableMemory} for absolute offset access,
- * and read-only {@link org.apache.datasketches.memory.Buffer} and
- * {@link org.apache.datasketches.memory.WritableBuffer}
+ * <ul><li>Two different access APIs: read-only {@link org.apache.datasketches.memory.internal.Memory} and
+ * {@link org.apache.datasketches.memory.internal.WritableMemory} for absolute offset access,
+ * and read-only {@link org.apache.datasketches.memory.internal.Buffer} and
+ * {@link org.apache.datasketches.memory.internal.WritableBuffer}
* for relative positional access (similar to ByteBuffer).</li>
*
* <li>Clean separation of Read-only API from Writable API, which makes writable versus read-only
@@ -84,7 +84,7 @@
*
* <p>An access API is joined with
* a resource either with a static factory method or in combination with a
- * {@link org.apache.datasketches.memory.Handle}, which is used exclusively for resources that are
+ * {@link org.apache.datasketches.memory.internal.Handle}, which is used exclusively for resources that are
* external to the JVM, such as allocation of direct memory and memory-mapped files.</p>
*
* <p>The role of a Handle is to hold onto the reference of a resource that is outside the control
@@ -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.MapHandle}
+ * <ul><li>{@link org.apache.datasketches.memory.internal.MapHandle}
* for read-only access to a memory-mapped file</li>
- * <li>{@link org.apache.datasketches.memory.WritableMapHandle}
+ * <li>{@link org.apache.datasketches.memory.internal.WritableMapHandle}
* for writable access to a memory-mapped file</li>
- * <li>{@link org.apache.datasketches.memory.WritableDirectHandle}
+ * <li>{@link org.apache.datasketches.memory.internal.WritableDirectHandle}
* for writable access to off-heap memory.</li>
* </ul>
*
@@ -170,4 +170,4 @@
*
* @author Lee Rhodes
*/
-package org.apache.datasketches.memory;
+package org.apache.datasketches.memory.internal;
diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
index c5fae90..c5b7c9f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
@@ -23,7 +23,7 @@
package org.apache.datasketches.memory.test;
-import static org.apache.datasketches.memory.Util.*;
+import static org.apache.datasketches.memory.internal.Util.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -32,8 +32,8 @@ import static org.testng.Assert.fail;
import java.io.File;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.internal.MapHandle;
+import org.apache.datasketches.memory.internal.Memory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
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 66fc0e9..2f9b8e0 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
@@ -26,11 +26,11 @@ import static org.testng.Assert.fail;
import java.lang.reflect.InvocationTargetException;
-import org.apache.datasketches.memory.MemoryRequestServer;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableDirectHandle;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryRequestServer;
+import org.apache.datasketches.memory.internal.Util;
+import org.apache.datasketches.memory.internal.WritableDirectHandle;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
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 1669e22..b8a9b74 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
@@ -24,7 +24,7 @@
package org.apache.datasketches.memory.test;
import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.memory.Util.*;
+import static org.apache.datasketches.memory.internal.Util.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
@@ -37,13 +37,13 @@ import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMapHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.MapHandle;
+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.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMapHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
index ed02c79..6815fd9 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
@@ -21,10 +21,10 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.fail;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
index 8829271..2ba50b8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
@@ -19,7 +19,7 @@
package org.apache.datasketches.memory.test;
-import static org.apache.datasketches.memory.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -27,13 +27,13 @@ import static org.testng.Assert.fail;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.Prim;
-import org.apache.datasketches.memory.StepBoolean;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.Prim;
+import org.apache.datasketches.memory.internal.StepBoolean;
+import org.apache.datasketches.memory.internal.Util;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
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 cf984b8..0f9b680 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
@@ -26,11 +26,11 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.ReadOnlyException;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
index 03d428d..0970ffb 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
@@ -19,7 +19,7 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
index aa4754e..d08ef0d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
@@ -24,10 +24,10 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
index 91e0465..24f195f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
@@ -21,10 +21,10 @@ package org.apache.datasketches.memory.test;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.ReadOnlyException;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.ReadOnlyException;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
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 b825659..e80b2a0 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
@@ -25,11 +25,11 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
import org.testng.collections.Lists;
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
index 1b7308d..023270e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
@@ -21,9 +21,9 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
index 41f2b2f..f28a301 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
@@ -19,16 +19,16 @@
package org.apache.datasketches.memory.test;
-import static org.apache.datasketches.memory.Util.isAllBitsClear;
-import static org.apache.datasketches.memory.Util.isAllBitsSet;
-import static org.apache.datasketches.memory.Util.isAnyBitsClear;
-import static org.apache.datasketches.memory.Util.isAnyBitsSet;
+import static org.apache.datasketches.memory.internal.Util.isAllBitsClear;
+import static org.apache.datasketches.memory.internal.Util.isAllBitsSet;
+import static org.apache.datasketches.memory.internal.Util.isAnyBitsClear;
+import static org.apache.datasketches.memory.internal.Util.isAnyBitsSet;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
diff --git a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
index 0f2f027..67da58a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
@@ -21,9 +21,9 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
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 a1f21e8..03b4bec 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
@@ -19,14 +19,14 @@
package org.apache.datasketches.memory.test;
-import static org.apache.datasketches.memory.Util.UNSAFE_COPY_THRESHOLD_BYTES;
+import static org.apache.datasketches.memory.internal.Util.UNSAFE_COPY_THRESHOLD_BYTES;
import static org.testng.Assert.assertEquals;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
index 3934c0e..446a825 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
@@ -23,9 +23,9 @@ import static org.testng.Assert.assertFalse;
import java.util.IdentityHashMap;
-import org.apache.datasketches.memory.MemoryRequestServer;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.MemoryRequestServer;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
diff --git a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
index 2344beb..462de6c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
@@ -19,8 +19,8 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Ignore;
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 5b266be..be17b82 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,11 @@ import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableDirectHandle;
-import org.apache.datasketches.memory.WritableMapHandle;
-import org.apache.datasketches.memory.WritableMemory;
-import org.apache.datasketches.memory.Util;
+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.testng.annotations.Test;
/**
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
index c45387f..ade4ec4 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
@@ -19,8 +19,8 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
index 443bb7f..572d019 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
@@ -25,10 +25,10 @@ import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.MapHandle;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.ReadOnlyException;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
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 d099261..3166a12 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
@@ -23,7 +23,7 @@
package org.apache.datasketches.memory.test;
-import static org.apache.datasketches.memory.Util.*;
+import static org.apache.datasketches.memory.internal.Util.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
@@ -35,12 +35,12 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
-import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableDirectHandle;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.MapHandle;
+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.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
index 09ce3f7..d6c10a9 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
@@ -19,16 +19,17 @@
package org.apache.datasketches.memory.test;
+import static org.apache.datasketches.memory.internal.Util.UNSAFE_COPY_THRESHOLD_BYTES;
+
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.channels.Channels;
import java.nio.channels.WritableByteChannel;
import java.util.concurrent.ThreadLocalRandom;
-import static org.apache.datasketches.memory.Util.UNSAFE_COPY_THRESHOLD_BYTES;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
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 8830c23..a70e315 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
@@ -23,9 +23,9 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
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 dab4eb1..6388718 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
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 78f45a2..266ea8e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
@@ -23,8 +23,8 @@ import java.io.File;
import java.lang.reflect.*;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.MemoryRequestServer;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.internal.MemoryRequestServer;
+import org.apache.datasketches.memory.internal.WritableDirectHandle;
public final class ReflectUtil {
@@ -61,13 +61,13 @@ public final class ReflectUtil {
static {
BASE_STATE =
- getClass("org.apache.datasketches.memory.BaseState");
+ getClass("org.apache.datasketches.memory.internal.BaseState");
BASE_WRITABLE_MEMORY_IMPL =
- getClass("org.apache.datasketches.memory.BaseWritableMemoryImpl");
+ getClass("org.apache.datasketches.memory.internal.BaseWritableMemoryImpl");
ALLOCATE_DIRECT_MAP =
- getClass("org.apache.datasketches.memory.AllocateDirectMap");
+ getClass("org.apache.datasketches.memory.internal.AllocateDirectMap");
NIO_BITS =
- getClass("org.apache.datasketches.memory.NioBits");
+ getClass("org.apache.datasketches.memory.internal.NioBits");
CHECK_VALID =
getMethod(BASE_STATE, "checkValid", (Class<?>[])null); //not static
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 a102e46..b0bb764 100644
--- a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
@@ -26,12 +26,12 @@ import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableDirectHandle;
-import org.apache.datasketches.memory.WritableMapHandle;
-import org.apache.datasketches.memory.WritableMemory;
+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.testng.annotations.Test;
/**
diff --git a/src/test/java/org/apache/datasketches/memory/test/UnsafeUtilTest.java b/src/test/java/org/apache/datasketches/memory/test/UnsafeUtilTest.java
index 4966449..b27b995 100644
--- a/src/test/java/org/apache/datasketches/memory/test/UnsafeUtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/UnsafeUtilTest.java
@@ -26,8 +26,8 @@ import static org.testng.Assert.fail;
import java.util.ArrayList;
import java.util.List;
-import org.apache.datasketches.memory.Ints;
-import org.apache.datasketches.memory.UnsafeUtil;
+import org.apache.datasketches.memory.internal.Ints;
+import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.testng.annotations.Test;
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 6c01235..8a38b39 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
@@ -28,15 +28,14 @@ import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.List;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.Utf8CodingException;
+import org.apache.datasketches.memory.internal.WritableMemory;
+import org.apache.datasketches.memory.internal.Util.RandomCodePoints;
import org.testng.annotations.Test;
import com.google.protobuf.ByteString;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.Utf8CodingException;
-import org.apache.datasketches.memory.WritableMemory;
-import org.apache.datasketches.memory.Util.RandomCodePoints;
-
/**
* Adapted version of
* https://github.com/protocolbuffers/protobuf/blob/master/java/core/src/test/java/com/google/protobuf/DecodeUtf8Test.java
diff --git a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
index a44d9ec..83228bf 100644
--- a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
@@ -23,13 +23,13 @@
package org.apache.datasketches.memory.test;
-import static org.apache.datasketches.memory.Util.characterPad;
-import static org.apache.datasketches.memory.Util.getResourceFile;
-import static org.apache.datasketches.memory.Util.getResourceBytes;
-import static org.apache.datasketches.memory.Util.negativeCheck;
-import static org.apache.datasketches.memory.Util.nullCheck;
-import static org.apache.datasketches.memory.Util.zeroCheck;
-import static org.apache.datasketches.memory.Util.zeroPad;
+import static org.apache.datasketches.memory.internal.Util.characterPad;
+import static org.apache.datasketches.memory.internal.Util.getResourceBytes;
+import static org.apache.datasketches.memory.internal.Util.getResourceFile;
+import static org.apache.datasketches.memory.internal.Util.negativeCheck;
+import static org.apache.datasketches.memory.internal.Util.nullCheck;
+import static org.apache.datasketches.memory.internal.Util.zeroCheck;
+import static org.apache.datasketches.memory.internal.Util.zeroPad;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
@@ -42,9 +42,9 @@ import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.PosixFilePermissions;
-import org.apache.datasketches.memory.UnsafeUtil;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.UnsafeUtil;
+import org.apache.datasketches.memory.internal.Util;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
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 0899336..e3eb97d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
@@ -26,14 +26,14 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
-import org.apache.datasketches.memory.UnsafeUtil;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.ReadOnlyException;
+import org.apache.datasketches.memory.internal.UnsafeUtil;
+import org.apache.datasketches.memory.internal.Util;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
index 4907e5a..f351c0c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
@@ -22,9 +22,9 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
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 561e7d2..afd52fd 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
@@ -27,14 +27,14 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
-import org.apache.datasketches.memory.UnsafeUtil;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Buffer;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.ReadOnlyException;
+import org.apache.datasketches.memory.internal.UnsafeUtil;
+import org.apache.datasketches.memory.internal.Util;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableHandle;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
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 63c3291..bbbb7ca 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
@@ -27,10 +27,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.Util;
-import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.Util;
+import org.apache.datasketches.memory.internal.WritableBuffer;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
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 e1df579..7554996 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
@@ -21,7 +21,7 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
/**
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 f12f78a..b0f6339 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
@@ -19,22 +19,15 @@
package org.apache.datasketches.memory.test;
-import static org.apache.datasketches.memory.XxHash64.hashBooleans;
-import static org.apache.datasketches.memory.XxHash64.hashBytes;
-import static org.apache.datasketches.memory.XxHash64.hashChars;
-import static org.apache.datasketches.memory.XxHash64.hashDoubles;
-import static org.apache.datasketches.memory.XxHash64.hashFloats;
-import static org.apache.datasketches.memory.XxHash64.hashInts;
-import static org.apache.datasketches.memory.XxHash64.hashLongs;
-import static org.apache.datasketches.memory.XxHash64.*;
+import static org.apache.datasketches.memory.internal.XxHash64.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.annotations.Test;
import net.openhft.hashing.LongHashFunction;
diff --git a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
index 1c2c7b7..b8b3e3d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.Memory;
+import org.apache.datasketches.memory.internal.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 08/08: Refactoring complete.
Posted by le...@apache.org.
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 f686454a3520004993a2a67220efd4a1c13e7db9
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Tue May 18 12:55:42 2021 -0700
Refactoring complete.
Move all main classes to internal package. Create interface proxies for
the memory package. This creates possibility to restrict access to
internal package using JPMS in JDK 9+.
All tests pass and the vast majority of tests are black-box tests.
---
.../org/apache/datasketches/memory/BaseBuffer.java | 2 +-
.../apache/datasketches/memory/WritableBuffer.java | 2 +-
.../memory/internal/AllocateDirect.java | 2 +-
.../apache/datasketches/memory/internal/Util.java | 8 +-
.../memory/test/AllocateDirectMapMemoryTest.java | 29 +--
.../memory/test/AllocateDirectMemoryTest.java | 41 ++--
.../test/AllocateDirectWritableMapMemoryTest.java | 59 +++---
.../datasketches/memory/test/BaseBufferTest.java | 22 +-
.../datasketches/memory/test/BaseStateTest.java | 22 +-
.../datasketches/memory/test/Buffer2Test.java | 86 ++++----
.../memory/test/BufferBoundaryCheckTest.java | 4 +-
.../memory/test/BufferInvariantsTest.java | 54 ++---
.../memory/test/BufferReadWriteSafetyTest.java | 16 +-
.../datasketches/memory/test/BufferTest.java | 102 +++++-----
.../datasketches/memory/test/CommonBufferTest.java | 56 +++---
.../datasketches/memory/test/CommonMemoryTest.java | 58 +++---
.../memory/test/CopyMemoryOverlapTest.java | 34 ++--
.../datasketches/memory/test/CopyMemoryTest.java | 62 +++---
.../test/ExampleMemoryRequestServerTest.java | 45 +++--
.../memory/test/IgnoredArrayOverflowTest.java | 13 +-
.../datasketches/memory/test/LeafImplTest.java | 64 +++---
.../memory/test/MemoryBoundaryCheckTest.java | 6 +-
.../memory/test/MemoryReadWriteSafetyTest.java | 49 +++--
.../datasketches/memory/test/MemoryTest.java | 199 +++++++++---------
.../memory/test/MemoryWriteToTest.java | 24 +--
...Test.java => NativeWritableBufferImplTest.java} | 210 +++++++++----------
...Test.java => NativeWritableMemoryImplTest.java} | 222 ++++++++++-----------
.../test/NonNativeWritableBufferImplTest.java | 70 +++----
.../test/NonNativeWritableMemoryImplTest.java | 36 ++--
.../datasketches/memory/test/ReflectUtil.java | 24 ---
.../datasketches/memory/test/SpecificLeafTest.java | 84 ++++----
.../apache/datasketches/memory/test/Utf8Test.java | 50 ++---
.../apache/datasketches/memory/test/UtilTest.java | 4 +-
.../memory/test/WritableDirectCopyTest.java | 86 ++++----
.../memory/test/WritableMemoryTest.java | 52 ++---
.../memory/test/XxHash64LoopingTest.java | 4 +-
.../datasketches/memory/test/XxHash64Test.java | 16 +-
.../datasketches/memory/test/ZeroCapacityTest.java | 16 +-
38 files changed, 959 insertions(+), 974 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/BaseBuffer.java b/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
index 68c18c3..220092d 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
@@ -19,7 +19,7 @@
package org.apache.datasketches.memory;
-public interface BaseBuffer {
+public interface BaseBuffer extends BaseState {
/**
* Increments the current position by the given increment.
diff --git a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
index 0a4e282..bfb3834 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
@@ -25,7 +25,7 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.internal.WritableBufferImpl;
-public interface WritableBuffer {
+public interface WritableBuffer extends Buffer {
//BYTE BUFFER
/**
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 bc47f57..f5c1bdf 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
@@ -59,7 +59,7 @@ final class AllocateDirect implements AutoCloseable {
nativeAddress = unsafe.allocateMemory(allocationSize);
} catch (final OutOfMemoryError err) {
NioBits.unreserveMemory(allocationSize, capacityBytes);
- throw err;
+ throw new RuntimeException(err);
}
if (pageAligned && ((nativeAddress % pageSize) != 0)) {
//Round up to page boundary
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Util.java b/src/main/java/org/apache/datasketches/memory/internal/Util.java
index f44c52d..1c6758f 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Util.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Util.java
@@ -31,6 +31,8 @@ import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Random;
+import org.apache.datasketches.memory.Memory;
+
/**
* @author Lee Rhodes
*/
@@ -47,7 +49,7 @@ public final class Util {
* threshold, because internally it doesn't have safepoint polls, that may cause long
* "Time To Safe Point" pauses in the application. This has been fixed in JDK 9 (see
* https://bugs.openjdk.java.net/browse/JDK-8149596 and
- * https://bugs.openjdk.java.net/browse/JDK-8141491), but not in JDK 8, so the MemoryImpl library
+ * https://bugs.openjdk.java.net/browse/JDK-8141491), but not in JDK 8, so the Memory library
* should keep having this boilerplate as long as it supports Java 8.
*
* <p>A reference to this can be found in java.nio.Bits.</p>
@@ -84,7 +86,7 @@ public final class Util {
* search algorithm. The range must be sorted method) prior to making this call.
* If it is not sorted, the results are undefined. If the range contains
* multiple elements with the specified value, there is no guarantee which one will be found.
- * @param mem the MemoryImpl to be searched
+ * @param mem the Memory to be searched
* @param fromLongIndex the index of the first element (inclusive) to be searched
* @param toLongIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
@@ -94,7 +96,7 @@ public final class Util {
* than the key, or toIndex if all elements in the range are less than the specified key.
* Note that this guarantees that the return value will be ≥ 0 if and only if the key is found.
*/
- public static long binarySearchLongs(final MemoryImpl mem, final long fromLongIndex,
+ public static long binarySearchLongs(final Memory mem, final long fromLongIndex,
final long toLongIndex, final long key) {
checkBounds(fromLongIndex << 3, (toLongIndex - fromLongIndex) << 3, mem.getCapacity());
long low = fromLongIndex;
diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
index a78e27f..f044453 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
@@ -33,7 +33,7 @@ import java.io.File;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -51,7 +51,8 @@ public class AllocateDirectMapMemoryTest {
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle rh = MemoryImpl.map(file)) {
+ assertTrue(ReflectUtil.isFileReadOnly(file));
+ try (MapHandle rh = Memory.map(file)) {
rh.close();
}
}
@@ -59,13 +60,13 @@ public class AllocateDirectMapMemoryTest {
@Test
public void testIllegalArguments() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle rh = MemoryImpl.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = Memory.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Position was negative.");
} catch (IllegalArgumentException e) {
//ok
}
- try (MapHandle rh = MemoryImpl.map(file, 0, -1, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = Memory.map(file, 0, -1, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Size was negative.");
} catch (IllegalArgumentException e) {
//ok
@@ -76,8 +77,8 @@ public class AllocateDirectMapMemoryTest {
public void testMapAndMultipleClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
- MemoryImpl map = rh.get();
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ Memory map = rh.get();
assertEquals(memCapacity, map.getCapacity());
rh.close();
rh.close();
@@ -91,8 +92,8 @@ public class AllocateDirectMapMemoryTest {
public void testReadFailAfterClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
- MemoryImpl mmf = rh.get();
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ Memory mmf = rh.get();
rh.close();
mmf.getByte(0);
} catch (AssertionError e) {
@@ -104,7 +105,7 @@ public class AllocateDirectMapMemoryTest {
public void testLoad() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
rh.close();
@@ -115,8 +116,8 @@ public class AllocateDirectMapMemoryTest {
public void testHandlerHandoffWithTWR() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- MemoryImpl mem;
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ Memory mem;
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
@@ -130,7 +131,7 @@ public class AllocateDirectMapMemoryTest {
public void testHandoffWithoutClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder());
+ MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder());
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
@@ -138,9 +139,9 @@ public class AllocateDirectMapMemoryTest {
}
@AfterClass
- public void afterAllTests() {
+ public void afterAllTests() throws Exception {
if (hand != null) {
- MemoryImpl mem = hand.get();
+ Memory mem = hand.get();
if ((mem != null) && mem.isValid()) {
hand.close();
assertFalse(mem.isValid());
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 c487b91..a70098f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
@@ -26,11 +26,12 @@ import static org.testng.Assert.fail;
import java.lang.reflect.InvocationTargetException;
+import org.apache.datasketches.memory.BaseState;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
@@ -38,11 +39,11 @@ import org.testng.annotations.Test;
public class AllocateDirectMemoryTest {
@Test
- public void simpleAllocateDirect() {
+ public void simpleAllocateDirect() throws Exception {
int longs = 32;
- WritableMemoryImpl wMem;
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(longs << 3)) {
- wMem = wh.get();
+ WritableMemory wMem;
+ try (WritableHandle wh = WritableMemory.allocateDirect(longs << 3)) {
+ wMem = wh.getWritable();
for (int i = 0; i<longs; i++) {
wMem.putLong(i << 3, i);
assertEquals(wMem.getLong(i << 3), i);
@@ -67,11 +68,11 @@ public class AllocateDirectMemoryTest {
}
@Test
- public void checkDefaultMemoryRequestServer() {
+ public void checkDefaultMemoryRequestServer() throws Exception {
int longs1 = 32;
int bytes1 = longs1 << 3;
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes1)) {
- WritableMemoryImpl origWmem = wh.get();
+ try (WritableHandle wh = WritableMemory.allocateDirect(bytes1)) {
+ WritableMemory origWmem = wh.getWritable();
for (int i = 0; i<longs1; i++) { //puts data in wMem1
origWmem.putLong(i << 3, i);
assertEquals(origWmem.getLong(i << 3), i);
@@ -81,7 +82,7 @@ public class AllocateDirectMemoryTest {
int longs2 = 64;
int bytes2 = longs2 << 3;
MemoryRequestServer memReqSvr = origWmem.getMemoryRequestServer();
- WritableMemoryImpl newWmem = memReqSvr.request(bytes2);
+ WritableMemory newWmem = memReqSvr.request(bytes2);
assertFalse(newWmem.isDirect()); //on heap by default
for (int i = 0; i < longs2; i++) {
newWmem.putLong(i << 3, i);
@@ -94,37 +95,37 @@ public class AllocateDirectMemoryTest {
}
@Test
- public void checkNullMemoryRequestServer() {
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(128, null)) {
- WritableMemoryImpl wmem = wh.get();
+ public void checkNullMemoryRequestServer() throws Exception {
+ try (WritableHandle wh = WritableMemory.allocateDirect(128, null)) {
+ WritableMemory wmem = wh.getWritable();
assertNotNull(wmem.getMemoryRequestServer());
}
}
@Test
- public void checkNonNativeDirect() { //not allowed in public API
+ public void checkNonNativeDirect() throws Exception { //not allowed in public API
try (WritableDirectHandle h = ReflectUtil.wrapDirect(8, Util.nonNativeByteOrder, null)) {
- //BaseWritableMemoryImpl.wrapDirect(8, Util.nonNativeByteOrder, null)) {
- WritableMemoryImpl wmem = h.get();
+ //BaseWritableMemory.wrapDirect(8, Util.nonNativeByteOrder, null)) {
+ WritableMemory wmem = h.getWritable();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
}
}
@Test
- public void checkExplicitClose() {
+ public void checkExplicitClose() throws Exception {
final long cap = 128;
- try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(cap)) {
+ try (WritableDirectHandle wdh = WritableMemory.allocateDirect(cap)) {
wdh.close(); //explicit close. Does the work of closing
} //end of scope call to Cleaner/Deallocator also will be redundant
}
- @SuppressWarnings("static-access")
+
@AfterClass
public void checkDirectCounter() {
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(new byte[8]);
- long count = mem.getCurrentDirectMemoryAllocations();
+ WritableMemory.writableWrap(new byte[8]);
+ long count = BaseState.getCurrentDirectMemoryAllocations();
if (count != 0) {
println(""+count);
fail();
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 5761068..23c915c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
@@ -24,7 +24,7 @@
package org.apache.datasketches.memory.test;
import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.memory.internal.Util.*;
+import static org.apache.datasketches.memory.internal.Util.getResourceFile;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
@@ -37,13 +37,14 @@ import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.BaseState;
import org.apache.datasketches.memory.MapHandle;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.WritableMapHandle;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
-import org.apache.datasketches.memory.WritableMapHandle;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -53,13 +54,10 @@ public class AllocateDirectWritableMapMemoryTest {
private static final String LS = System.getProperty("line.separator");
static final Method IS_FILE_READ_ONLY;
- static final Method GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS;
static {
IS_FILE_READ_ONLY =
ReflectUtil.getMethod(ReflectUtil.ALLOCATE_DIRECT_MAP, "isFileReadOnly", File.class);
- GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS =
- ReflectUtil.getMethod(ReflectUtil.BASE_STATE, "getCurrentDirectMemoryMapAllocations", (Class<?>[])null); //static
}
private static boolean isFileReadOnly(final File file) {
@@ -67,12 +65,6 @@ public class AllocateDirectWritableMapMemoryTest {
return (boolean) IS_FILE_READ_ONLY.invoke(null, file);
} catch (Exception e) { throw new RuntimeException(e); }
}
-
- private static long getCurrentDirectMemoryMapAllocations() {
- try {
- return (long) GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS.invoke(null);
- } catch (Exception e) { throw new RuntimeException(e); }
- }
@BeforeClass
public void setReadOnly() {
@@ -82,8 +74,8 @@ public class AllocateDirectWritableMapMemoryTest {
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle h = MemoryImpl.map(file); WritableMapHandle wh = (WritableMapHandle) h) {
- MemoryImpl mem = h.get();
+ try (MapHandle h = Memory.map(file); WritableMapHandle wh = (WritableMapHandle) h) {
+ Memory mem = h.get();
byte[] bytes = new byte[(int)mem.getCapacity()];
mem.getByteArray(0, bytes, 0, bytes.length);
String text = new String(bytes, UTF_8);
@@ -117,11 +109,11 @@ public class AllocateDirectWritableMapMemoryTest {
try (
WritableMapHandle dstHandle
- = WritableMemoryImpl.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
- WritableHandle srcHandle = WritableMemoryImpl.allocateDirect(bytes)) {
+ = WritableMemory.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
+ WritableHandle srcHandle = WritableMemory.allocateDirect(bytes)) {
- WritableMemoryImpl dstMem = dstHandle.get();
- WritableMemoryImpl srcMem = srcHandle.get();
+ WritableMemory dstMem = dstHandle.getWritable();
+ WritableMemory srcMem = srcHandle.getWritable();
for (long i = 0; i < longs; i++) {
srcMem.putLong(i << 3, i); //load source with consecutive longs
@@ -137,7 +129,7 @@ public class AllocateDirectWritableMapMemoryTest {
}
@Test
- public void checkNonNativeFile() throws IOException {
+ public void checkNonNativeFile() throws Exception {
File file = new File("TestFile2.bin");
if (file.exists()) {
try {
@@ -152,8 +144,8 @@ public class AllocateDirectWritableMapMemoryTest {
file.deleteOnExit(); //comment out if you want to examine the file.
final long bytes = 8;
- try (WritableMapHandle h = WritableMemoryImpl.writableMap(file, 0L, bytes, Util.nonNativeByteOrder)) {
- WritableMemoryImpl wmem = h.get();
+ try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nonNativeByteOrder)) {
+ WritableMemory wmem = h.getWritable();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
}
@@ -164,22 +156,22 @@ public class AllocateDirectWritableMapMemoryTest {
public void testMapException() throws IOException {
File dummy = createFile("dummy.txt", ""); //zero length
//throws java.lang.reflect.InvocationTargetException
- MemoryImpl.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
+ Memory.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
}
@Test(expectedExceptions = ReadOnlyException.class)
- public void simpleMap2() throws IOException {
+ public void simpleMap2() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
assertTrue(isFileReadOnly(file));
- try (WritableMapHandle rh = WritableMemoryImpl.writableMap(file)) { //throws
+ try (WritableMapHandle rh = WritableMemory.writableMap(file)) { //throws
//
}
}
@Test(expectedExceptions = IllegalArgumentException.class)
- public void checkOverLength() {
+ public void checkOverLength() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (WritableMapHandle rh = WritableMemoryImpl.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
+ try (WritableMapHandle rh = WritableMemory.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
//
} catch (IOException e) {
throw new RuntimeException(e);
@@ -196,8 +188,8 @@ public class AllocateDirectWritableMapMemoryTest {
byte[] correctByteArr = correctStr.getBytes(UTF_8);
long corrBytes = correctByteArr.length;
- try (MapHandle rh = MemoryImpl.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
- MemoryImpl map = rh.get();
+ try (MapHandle rh = Memory.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
+ Memory map = rh.get();
rh.load();
assertTrue(rh.isLoaded());
//confirm orig string
@@ -207,9 +199,9 @@ public class AllocateDirectWritableMapMemoryTest {
assertEquals(bufStr, origStr);
}
- try (WritableMapHandle wrh = WritableMemoryImpl.writableMap(origFile, 0, corrBytes,
+ try (WritableMapHandle wrh = WritableMemory.writableMap(origFile, 0, corrBytes,
ByteOrder.nativeOrder())) {
- WritableMemoryImpl wMap = wrh.get();
+ WritableMemory wMap = wrh.getWritable();
wrh.load();
assertTrue(wrh.isLoaded());
// over write content
@@ -240,15 +232,14 @@ public class AllocateDirectWritableMapMemoryTest {
@Test
public void checkExplicitClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle wmh = MemoryImpl.map(file)) {
+ try (MapHandle wmh = Memory.map(file)) {
wmh.close(); //explicit close.
} //end of scope call to Cleaner/Deallocator also will be redundant
}
@AfterClass
public void checkDirectCounter() {
- long count = getCurrentDirectMemoryMapAllocations();
- //final long count = BaseStateImpl.getCurrentDirectMemoryMapAllocations();
+ long count = BaseState.getCurrentDirectMemoryMapAllocations();
if (count != 0) {
println(""+count);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
index ac2579a..659bdf4 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
@@ -22,9 +22,9 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -35,7 +35,7 @@ public class BaseBufferTest {
@Test
public void checkLimits() {
- BufferImpl buf = MemoryImpl.wrap(new byte[100]).asBuffer();
+ Buffer buf = Memory.wrap(new byte[100]).asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -48,7 +48,7 @@ public class BaseBufferTest {
@Test
public void checkLimitsAndCheck() {
- BufferImpl buf = MemoryImpl.wrap(new byte[100]).asBuffer();
+ Buffer buf = Memory.wrap(new byte[100]).asBuffer();
buf.setAndCheckStartPositionEnd(40, 45, 50);
buf.setAndCheckStartPositionEnd(0, 0, 100);
try {
@@ -75,14 +75,14 @@ public class BaseBufferTest {
}
@Test
- public void checkCheckValid() {
- WritableMemoryImpl wmem;
- BufferImpl buf;
- try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
- wmem = hand.get();
+ public void checkCheckValid() throws Exception {
+ WritableMemory wmem;
+ Buffer buf;
+ try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
+ wmem = hand.getWritable();
buf = wmem.asBuffer();
}
@SuppressWarnings("unused")
- MemoryImpl mem = buf.asMemory();
+ Memory mem = buf.asMemory();
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
index 598710f..550e378 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
@@ -27,13 +27,13 @@ import static org.testng.Assert.fail;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Prim;
import org.apache.datasketches.memory.internal.StepBoolean;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -47,13 +47,13 @@ public class BaseStateTest {
@Test
public void checkIsSameResource() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(16);
- MemoryImpl mem = wmem;
+ WritableMemory wmem = WritableMemory.allocate(16);
+ Memory mem = wmem;
assertFalse(wmem.isSameResource(null));
assertTrue(wmem.isSameResource(mem));
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- BufferImpl buf = wbuf;
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ Buffer buf = wbuf;
assertFalse(wbuf.isSameResource(null));
assertTrue(wbuf.isSameResource(buf));
}
@@ -61,7 +61,7 @@ public class BaseStateTest {
@Test
public void checkNotEqualTo() {
byte[] arr = new byte[8];
- MemoryImpl mem = MemoryImpl.wrap(arr);
+ Memory mem = Memory.wrap(arr);
assertFalse(mem.equalTo(0, arr, 0, 8));
}
@@ -90,14 +90,14 @@ public class BaseStateTest {
@Test
public void checkGetNativeBaseOffset_Heap() throws Exception {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8); //heap
+ WritableMemory wmem = WritableMemory.allocate(8); //heap
final long offset = ReflectUtil.getNativeBaseOffset(wmem);
assertEquals(offset, 0L);
}
@Test
public void checkIsByteOrderCompatible() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
+ WritableMemory wmem = WritableMemory.allocate(8);
assertTrue(wmem.isByteOrderCompatible(ByteOrder.nativeOrder()));
}
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 b2a7f1d..73660a4 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
@@ -26,11 +26,11 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -47,7 +47,7 @@ public class Buffer2Test {
}
bb.position(0);
- BufferImpl buffer = BufferImpl.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
+ Buffer buffer = Buffer.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -67,7 +67,7 @@ public class Buffer2Test {
}
bb.position(0);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -84,7 +84,7 @@ public class Buffer2Test {
byteArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(byteArray).asBuffer();
+ Buffer buffer = Memory.wrap(byteArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(byteArray[i++], buffer.getByte());
@@ -107,7 +107,7 @@ public class Buffer2Test {
charArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(charArray).asBuffer();
+ Buffer buffer = Memory.wrap(charArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(charArray[i++], buffer.getChar());
@@ -127,7 +127,7 @@ public class Buffer2Test {
shortArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(shortArray).asBuffer();
+ Buffer buffer = Memory.wrap(shortArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(shortArray[i++], buffer.getShort());
@@ -147,7 +147,7 @@ public class Buffer2Test {
intArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(intArray).asBuffer();
+ Buffer buffer = Memory.wrap(intArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(intArray[i++], buffer.getInt());
@@ -167,7 +167,7 @@ public class Buffer2Test {
longArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(longArray).asBuffer();
+ Buffer buffer = Memory.wrap(longArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(longArray[i++], buffer.getLong());
@@ -187,7 +187,7 @@ public class Buffer2Test {
floatArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(floatArray).asBuffer();
+ Buffer buffer = Memory.wrap(floatArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(floatArray[i++], buffer.getFloat());
@@ -207,7 +207,7 @@ public class Buffer2Test {
doubleArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(doubleArray).asBuffer();
+ Buffer buffer = Memory.wrap(doubleArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(doubleArray[i++], buffer.getDouble());
@@ -229,7 +229,7 @@ public class Buffer2Test {
}
}
- BufferImpl buffer = MemoryImpl.wrap(booleanArray).asBuffer();
+ Buffer buffer = Memory.wrap(booleanArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(booleanArray[i++], buffer.getBoolean());
@@ -254,7 +254,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -271,7 +271,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
assertEquals(bb.hasRemaining(), buffer.hasRemaining());
assertEquals(bb.remaining(), buffer.getRemaining());
}
@@ -287,7 +287,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
assertEquals(bb.position(), buffer.getPosition());
assertEquals(30, buffer.setPosition(30).getPosition());
assertEquals(40, buffer.incrementPosition(10).getPosition());
@@ -305,7 +305,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb.slice().order(ByteOrder.nativeOrder()));
+ Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -327,10 +327,10 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
+ Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
buffer.setPosition(30);//remaining = 24
- BufferImpl dupBuffer = buffer.duplicate(); //all 54
- BufferImpl regionBuffer = buffer.region(); //24
+ Buffer dupBuffer = buffer.duplicate(); //all 54
+ Buffer regionBuffer = buffer.region(); //24
assertEquals(dupBuffer.getStart(), buffer.getStart());
assertEquals(regionBuffer.getStart(), buffer.getStart());
@@ -348,9 +348,9 @@ public class Buffer2Test {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- MemoryImpl mem = MemoryImpl.wrap(arr);
- BufferImpl buf = mem.asBuffer();
- BufferImpl reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
+ Memory mem = Memory.wrap(arr);
+ Buffer buf = mem.asBuffer();
+ Buffer reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
for (int i = 0; i < n2; i++) {
long v = reg.getLong(i * 8);
long e = i + n2;
@@ -369,8 +369,8 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
- MemoryImpl memory = buffer.asMemory();
+ Buffer buffer = Buffer.wrap(bb);
+ Memory memory = buffer.asMemory();
assertEquals(buffer.getCapacity(), memory.getCapacity());
@@ -383,8 +383,8 @@ public class Buffer2Test {
public void testROByteBuffer() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- BufferImpl buf = BufferImpl.wrap(roBB);
- WritableBufferImpl wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(roBB);
+ WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.putByte(0, (byte) 1);
}
@@ -392,8 +392,8 @@ public class Buffer2Test {
public void testROByteBuffer2() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- BufferImpl buf = BufferImpl.wrap(roBB);
- WritableBufferImpl wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(roBB);
+ WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.putByteArray(arr, 0, 64);
}
@@ -401,38 +401,38 @@ public class Buffer2Test {
public void testIllegalFill() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- BufferImpl buf = BufferImpl.wrap(roBB);
- WritableBufferImpl wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(roBB);
+ WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.fill((byte)0);
}
@Test
public void testWritableDuplicate() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[1]);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- WritableBufferImpl wbuf2 = wbuf.writableDuplicate();
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[1]);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBuffer wbuf2 = wbuf.writableDuplicate();
assertEquals(wbuf2.getCapacity(), 1);
- BufferImpl buf = wmem.asBuffer();
+ Buffer buf = wmem.asBuffer();
assertEquals(buf.getCapacity(), 1);
}
@Test
public void checkIndependence() {
int cap = 64;
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(cap);
- WritableBufferImpl wbuf1 = wmem.asWritableBuffer();
- WritableBufferImpl wbuf2 = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(cap);
+ WritableBuffer wbuf1 = wmem.asWritableBuffer();
+ WritableBuffer wbuf2 = wmem.asWritableBuffer();
assertFalse(wbuf1 == wbuf2);
assertTrue(wbuf1.isSameResource(wbuf2));
- WritableMemoryImpl reg1 = wmem.writableRegion(0, cap);
- WritableMemoryImpl reg2 = wmem.writableRegion(0, cap);
+ WritableMemory reg1 = wmem.writableRegion(0, cap);
+ WritableMemory reg2 = wmem.writableRegion(0, cap);
assertFalse(reg1 == reg2);
assertTrue(reg1.isSameResource(reg2));
- WritableBufferImpl wbuf3 = wbuf1.writableRegion();
- WritableBufferImpl wbuf4 = wbuf1.writableRegion();
+ WritableBuffer wbuf3 = wbuf1.writableRegion();
+ WritableBuffer wbuf4 = wbuf1.writableRegion();
assertFalse(wbuf3 == wbuf4);
assertTrue(wbuf3.isSameResource(wbuf4));
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
index 356862d..03d428d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
@@ -19,13 +19,13 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class BufferBoundaryCheckTest {
- private final WritableMemoryImpl writableMemory = WritableMemoryImpl.allocate(8);
+ private final WritableMemory writableMemory = WritableMemory.allocate(8);
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
index 46f340d..73acaa9 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
@@ -25,9 +25,9 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -40,10 +40,10 @@ public class BufferInvariantsTest {
public void testRegion() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- BufferImpl buff = BufferImpl.wrap(byteBuffer); //assuming buff has cap of 8
+ Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
- BufferImpl copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
+ Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
assertEquals(copyBuff.getEnd(), 6);
assertEquals(copyBuff.getCapacity(), 6);
assertEquals(copyBuff.getStart(), 0);
@@ -51,7 +51,7 @@ public class BufferInvariantsTest {
buff.setStartPositionEnd(1, 1, 5);
buff.getByte();
- BufferImpl copyBuff2 = buff.region();
+ Buffer copyBuff2 = buff.region();
assertEquals(copyBuff2.getEnd(), 3);
assertEquals(copyBuff2.getCapacity(), 3);
assertEquals(copyBuff2.getStart(), 0);
@@ -93,7 +93,7 @@ public class BufferInvariantsTest {
@Test
public void testBuf() {
int n = 25;
- WritableBufferImpl buf = WritableMemoryImpl.allocate(n).asWritableBuffer();
+ WritableBuffer buf = WritableMemory.allocate(n).asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -110,7 +110,7 @@ public class BufferInvariantsTest {
// print("Set : ");
// printbuf(buf);
- BufferImpl dup = buf.duplicate();
+ Buffer dup = buf.duplicate();
assertEquals(dup.getRemaining(), 15);
assertEquals(dup.getCapacity(), 25);
assertEquals(dup.getByte(), 5);
@@ -119,7 +119,7 @@ public class BufferInvariantsTest {
// printbuf(dup);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -139,7 +139,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- BufferImpl buf = BufferImpl.wrap(bb);
+ Buffer buf = Buffer.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
@@ -149,7 +149,7 @@ public class BufferInvariantsTest {
// print("Buf.wrap: ");
// printbuf(buf);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -161,10 +161,10 @@ public class BufferInvariantsTest {
}
@Test
- public void checkLimitsDirect() {
- try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
- WritableMemoryImpl wmem = hand.get();
- BufferImpl buf = wmem.asBuffer();
+ public void checkLimitsDirect() throws Exception {
+ try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
+ WritableMemory wmem = hand.getWritable();
+ Buffer buf = wmem.asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -180,10 +180,10 @@ public class BufferInvariantsTest {
public void testRegionDirect() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- BufferImpl buff = BufferImpl.wrap(byteBuffer); //assuming buff has cap of 8
+ Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
- BufferImpl copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
+ Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
assertEquals(copyBuff.getEnd(), 6);
assertEquals(copyBuff.getCapacity(), 6);
assertEquals(copyBuff.getStart(), 0);
@@ -191,7 +191,7 @@ public class BufferInvariantsTest {
buff.setStartPositionEnd(1, 1, 5);
buff.getByte();
- BufferImpl copyBuff2 = buff.region();
+ Buffer copyBuff2 = buff.region();
assertEquals(copyBuff2.getEnd(), 3);
assertEquals(copyBuff2.getCapacity(), 3);
assertEquals(copyBuff2.getStart(), 0);
@@ -231,11 +231,11 @@ public class BufferInvariantsTest {
}
@Test
- public void testBufDirect() {
+ public void testBufDirect() throws Exception {
int n = 25;
- try (WritableHandle whand = WritableMemoryImpl.allocateDirect(n)) {
- WritableMemoryImpl wmem = whand.get();
- WritableBufferImpl buf = wmem.asWritableBuffer();
+ try (WritableHandle whand = WritableMemory.allocateDirect(n)) {
+ WritableMemory wmem = whand.getWritable();
+ WritableBuffer buf = wmem.asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -252,7 +252,7 @@ public class BufferInvariantsTest {
// print("Set : ");
// printbuf(buf);
- BufferImpl dup = buf.duplicate();
+ Buffer dup = buf.duplicate();
assertEquals(dup.getRemaining(), 15);
assertEquals(dup.getCapacity(), 25);
assertEquals(dup.getByte(), 5);
@@ -261,7 +261,7 @@ public class BufferInvariantsTest {
// printbuf(dup);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -282,7 +282,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- BufferImpl buf = BufferImpl.wrap(bb);
+ Buffer buf = Buffer.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
@@ -292,7 +292,7 @@ public class BufferInvariantsTest {
// print("Buf.wrap: ");
// printbuf(buf);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -315,7 +315,7 @@ public class BufferInvariantsTest {
println(bb.get(i + pos) + "\n");
}
- static void printbuf(BufferImpl buf) {
+ static void printbuf(Buffer buf) {
println("pos: " + buf.getPosition() + ", end: " + buf.getEnd() + ", cap: " + buf.getCapacity());
long rem = buf.getRemaining();
long pos = buf.getPosition();
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
index b076dee..de56ca3 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
@@ -21,18 +21,18 @@ package org.apache.datasketches.memory.test;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.BufferImpl;
+import org.apache.datasketches.memory.Buffer;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class BufferReadWriteSafetyTest {
- // Test various operations with read-only BufferImpl
+ // Test various operations with read-only Buffer
- private final WritableBufferImpl buf = (WritableBufferImpl) BufferImpl.wrap(ByteBuffer.allocate(8));
+ private final WritableBuffer buf = (WritableBuffer) Buffer.wrap(ByteBuffer.allocate(8));
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -158,19 +158,19 @@ public class BufferReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryAsBuffer() {
- WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asBuffer();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asBuffer();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferRegion() {
- WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asWritableBuffer().region();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().region();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferDuplicate() {
- WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asWritableBuffer().duplicate();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().duplicate();
buf1.putInt(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 123bbbf..267f5ab 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
@@ -26,10 +26,10 @@ import java.nio.ByteOrder;
import java.util.List;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import org.testng.collections.Lists;
@@ -37,11 +37,11 @@ import org.testng.collections.Lists;
public class BufferTest {
@Test
- public void checkDirectRoundTrip() {
+ public void checkDirectRoundTrip() throws Exception {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(n * 8)) {
- WritableMemoryImpl wmem = wh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
+ WritableMemory wmem = wh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -56,7 +56,7 @@ public class BufferTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableBufferImpl wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -71,7 +71,7 @@ public class BufferTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -80,31 +80,31 @@ public class BufferTest {
long v = wbuf.getLong();
assertEquals(v, i);
}
- BufferImpl buf = MemoryImpl.wrap(arr).asBuffer();
+ Buffer buf = Memory.wrap(arr).asBuffer();
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
assertEquals(v, i);
}
// Check Zero length array wraps
- MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
- BufferImpl buffZeroLengthArrayWrap = mem.asBuffer();
+ Memory mem = Memory.wrap(new byte[0]);
+ Buffer buffZeroLengthArrayWrap = mem.asBuffer();
assertEquals(buffZeroLengthArrayWrap.getCapacity(), 0);
// check 0 length array wraps
- List<BufferImpl> buffersToCheck = Lists.newArrayList();
- buffersToCheck.add(WritableMemoryImpl.allocate(0).asBuffer());
- buffersToCheck.add(WritableBufferImpl.writableWrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(BufferImpl.wrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(MemoryImpl.wrap(new boolean[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new byte[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new char[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new short[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new int[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new long[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new float[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new double[0]).asBuffer());
+ List<Buffer> buffersToCheck = Lists.newArrayList();
+ buffersToCheck.add(WritableMemory.allocate(0).asBuffer());
+ buffersToCheck.add(WritableBuffer.writableWrap(ByteBuffer.allocate(0)));
+ buffersToCheck.add(Buffer.wrap(ByteBuffer.allocate(0)));
+ buffersToCheck.add(Memory.wrap(new boolean[0]).asBuffer());
+ buffersToCheck.add(Memory.wrap(new byte[0]).asBuffer());
+ buffersToCheck.add(Memory.wrap(new char[0]).asBuffer());
+ buffersToCheck.add(Memory.wrap(new short[0]).asBuffer());
+ buffersToCheck.add(Memory.wrap(new int[0]).asBuffer());
+ buffersToCheck.add(Memory.wrap(new long[0]).asBuffer());
+ buffersToCheck.add(Memory.wrap(new float[0]).asBuffer());
+ buffersToCheck.add(Memory.wrap(new double[0]).asBuffer());
//Check the buffer lengths
- for (BufferImpl buffer : buffersToCheck) {
+ for (Buffer buffer : buffersToCheck) {
assertEquals(buffer.getCapacity(), 0);
}
}
@@ -116,7 +116,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -138,7 +138,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -151,13 +151,13 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- BufferImpl buf1 = MemoryImpl.wrap(arr).asBuffer();
+ Buffer buf1 = Memory.wrap(arr).asBuffer();
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = buf1.getLong();
assertEquals(v, i);
}
//convert to wbuf to RO
- BufferImpl buf = wbuf;
+ Buffer buf = wbuf;
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
@@ -171,7 +171,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
bb.order(ByteOrder.nativeOrder());
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wbuf.putLong(i);
}
@@ -184,13 +184,13 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- BufferImpl buf1 = BufferImpl.wrap(bb);
+ Buffer buf1 = Buffer.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = buf1.getLong();
assertEquals(v, i);
}
//convert to RO
- BufferImpl buf = wbuf;
+ Buffer buf = wbuf;
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
@@ -203,7 +203,7 @@ public class BufferTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- BufferImpl buf = BufferImpl.wrap(bb);
+ Buffer buf = Buffer.wrap(bb);
assertEquals(buf.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -217,7 +217,7 @@ public class BufferTest {
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- BufferImpl buf = BufferImpl.wrap(slice);
+ Buffer buf = Buffer.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(buf.getByte(), 64 + i);
}
@@ -231,7 +231,7 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBufferImpl wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
wbuf.putLongArray(arr, 0, n);
long[] arr2 = new long[n];
wbuf.resetPosition();
@@ -248,9 +248,9 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- BufferImpl buf = MemoryImpl.wrap(arr).asBuffer();
+ Buffer buf = Memory.wrap(arr).asBuffer();
buf.setPosition(n2 * 8);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
for (int i = 0; i < n2; i++) {
long v = reg.getLong();
assertEquals(v, i + n2);
@@ -264,14 +264,14 @@ public class BufferTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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));
}
//println("");
wbuf.setPosition(n2 * 8);
- WritableBufferImpl reg = wbuf.writableRegion();
+ WritableBuffer reg = wbuf.writableRegion();
for (int i = 0; i < n2; i++) { reg.putLong(i); } //rewrite top half
wbuf.resetPosition();
for (int i = 0; i < n; i++) {
@@ -281,35 +281,35 @@ public class BufferTest {
}
@Test(expectedExceptions = AssertionError.class)
- public void checkParentUseAfterFree() {
+ public void checkParentUseAfterFree() throws Exception {
int bytes = 64 * 8;
@SuppressWarnings("resource") //intentionally not using try-with-resources here
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- WritableMemoryImpl wmem = wh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableMemory wmem = wh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wh.close();
- //with -ea assert: MemoryImpl not valid.
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
wbuf.getLong();
}
@SuppressWarnings("resource")
@Test(expectedExceptions = AssertionError.class)
- public void checkRegionUseAfterFree() {
+ public void checkRegionUseAfterFree() throws Exception {
int bytes = 64;
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- MemoryImpl wmem = wh.get();
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ Memory wmem = wh.get();
- BufferImpl reg = wmem.asBuffer().region();
+ Buffer reg = wmem.asBuffer().region();
wh.close();
- //with -ea assert: MemoryImpl not valid.
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
reg.getByte();
}
@Test(expectedExceptions = AssertionError.class)
public void checkBaseBufferInvariants() {
- WritableBufferImpl wbuf = WritableMemoryImpl.allocate(64).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.allocate(64).asWritableBuffer();
wbuf.setStartPositionEnd(1, 0, 2); //out of order
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
index 1e12d32..9633b3d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
@@ -22,26 +22,26 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class CommonBufferTest {
@Test
- public void checkSetGet() {
+ public void checkSetGet() throws Exception {
int memCapacity = 60; //must be at least 60
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetTests(buf);
setGetTests2(buf);
}
}
- public static void setGetTests(WritableBufferImpl buf) {
+ public static void setGetTests(WritableBuffer buf) {
buf.putBoolean(true);
buf.putBoolean(false);
buf.putByte((byte) -1);
@@ -95,7 +95,7 @@ public class CommonBufferTest {
assertEquals(buf.getDouble(), Double.MIN_VALUE);
}
- public static void setGetTests2(WritableBufferImpl buf) {
+ public static void setGetTests2(WritableBuffer buf) {
buf.putBoolean(0, true);
buf.putBoolean(1, false);
buf.putByte(2, (byte) -1);
@@ -132,17 +132,17 @@ public class CommonBufferTest {
}
@Test
- public void checkSetGetArrays() {
+ public void checkSetGetArrays() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetArraysTests(buf);
}
}
- public static void setGetArraysTests(WritableBufferImpl buf) {
+ public static void setGetArraysTests(WritableBuffer buf) {
int words = 4;
boolean[] srcArray1 = {true, false, true, false};
@@ -229,17 +229,17 @@ public class CommonBufferTest {
}
@Test
- public void checkSetGetPartialArraysWithOffset() {
+ public void checkSetGetPartialArraysWithOffset() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetPartialArraysWithOffsetTests(buf);
}
}
- public static void setGetPartialArraysWithOffsetTests(WritableBufferImpl buf) {
+ public static void setGetPartialArraysWithOffsetTests(WritableBuffer buf) {
int items= 4;
boolean[] srcArray1 = {true, false, true, false};
boolean[] dstArray1 = new boolean[items];
@@ -323,11 +323,11 @@ public class CommonBufferTest {
}
@Test
- public void checkSetClearMemoryRegions() {
+ public void checkSetClearMemoryRegions() throws Exception {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setClearMemoryRegionsTests(buf); //requires println enabled to visually check
@@ -339,7 +339,7 @@ public class CommonBufferTest {
}
//enable println statements to visually check
- public static void setClearMemoryRegionsTests(WritableBufferImpl buf) {
+ public static void setClearMemoryRegionsTests(WritableBuffer buf) {
int accessCapacity = (int)buf.getCapacity();
//define regions
@@ -412,18 +412,18 @@ public class CommonBufferTest {
}
@Test
- public void checkToHexStringAllMem() {
+ public void checkToHexStringAllMem() throws Exception {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
toHexStringAllMemTests(buf); //requires println enabled to visually check
}
}
//enable println to visually check
- public static void toHexStringAllMemTests(WritableBufferImpl buf) {
+ public static void toHexStringAllMemTests(WritableBuffer buf) {
int memCapacity = (int)buf.getCapacity();
for (int i=0; i<memCapacity; i++) {
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
index 5e237b6..51f1407 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
@@ -28,23 +28,23 @@ import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class CommonMemoryTest {
@Test
- public void checkSetGet() {
+ public void checkSetGet() throws Exception {
int memCapacity = 16; //must be at least 8
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(mem.getCapacity(), memCapacity);
setGetTests(mem);
}
}
- public static void setGetTests(WritableMemoryImpl mem) {
+ public static void setGetTests(WritableMemory mem) {
mem.putBoolean(0, true);
assertEquals(mem.getBoolean(0), true);
mem.putBoolean(0, false);
@@ -87,16 +87,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetGetArrays() {
+ public void checkSetGetArrays() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
setGetArraysTests(mem);
}
}
- public static void setGetArraysTests(WritableMemoryImpl mem) {
+ public static void setGetArraysTests(WritableMemory mem) {
int accessCapacity = (int)mem.getCapacity();
int words = 4;
@@ -167,16 +167,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetGetPartialArraysWithOffset() {
+ public void checkSetGetPartialArraysWithOffset() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
setGetPartialArraysWithOffsetTests(mem);
}
}
- public static void setGetPartialArraysWithOffsetTests(WritableMemoryImpl mem) {
+ public static void setGetPartialArraysWithOffsetTests(WritableMemory mem) {
int items= 4;
boolean[] srcArray1 = {true, false, true, false};
boolean[] dstArray1 = new boolean[items];
@@ -244,17 +244,17 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetClearIsBits() {
+ public void checkSetClearIsBits() throws Exception {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
mem.clear();
setClearIsBitsTests(mem);
}
}
- public static void setClearIsBitsTests(WritableMemoryImpl mem) {
+ public static void setClearIsBitsTests(WritableMemory mem) {
//single bits
for (int i = 0; i < 8; i++) {
long bitMask = (1 << i);
@@ -285,16 +285,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkAtomicMethods() {
+ public void checkAtomicMethods() throws Exception {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(mem.getCapacity(), memCapacity);
atomicMethodTests(mem);
}
}
- public static void atomicMethodTests(WritableMemoryImpl mem) {
+ public static void atomicMethodTests(WritableMemory mem) {
mem.putLong(0, 500);
mem.getAndAddLong(0, 1);
assertEquals(mem.getLong(0), 501);
@@ -312,10 +312,10 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetClearMemoryRegions() {
+ public void checkSetClearMemoryRegions() throws Exception {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
setClearMemoryRegionsTests(mem); //requires println enabled to visually check
for (int i = 0; i < memCapacity; i++) {
@@ -325,7 +325,7 @@ public class CommonMemoryTest {
}
//enable println stmts to visually check
- public static void setClearMemoryRegionsTests(WritableMemoryImpl mem) {
+ public static void setClearMemoryRegionsTests(WritableMemory mem) {
int accessCapacity = (int)mem.getCapacity();
//define regions
@@ -383,16 +383,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkToHexStringAllMem() {
+ public void checkToHexStringAllMem() throws Exception {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
toHexStringAllMemTests(mem); //requires println enabled to visually check
}
}
//enable println to visually check
- public static void toHexStringAllMemTests(WritableMemoryImpl mem) {
+ public static void toHexStringAllMemTests(WritableMemory mem) {
int memCapacity = (int)mem.getCapacity();
for (int i = 0; i < memCapacity; i++) {
diff --git a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
index e81d369..771cdd8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
@@ -22,8 +22,8 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -33,7 +33,7 @@ import org.testng.annotations.Test;
public class CopyMemoryOverlapTest {
@Test
- public void checkOverlapUsingMemory() {
+ public void checkOverlapUsingMemory() throws Exception {
long copyLongs = 1 << 20;
double overlap = 0.5;
long start_mS = System.currentTimeMillis();
@@ -49,7 +49,7 @@ public class CopyMemoryOverlapTest {
}
@Test
- public void checkOverlapUsingRegions() {
+ public void checkOverlapUsingRegions() throws Exception {
long copyLongs = 1 << 20;
double overlap = 0.5;
long start_mS = System.currentTimeMillis();
@@ -64,8 +64,8 @@ public class CopyMemoryOverlapTest {
println("CopyDn Time Sec: " + ((end2_mS - end1_mS)/1000.0));
}
- private static final void copyUsingDirectMemory(long copyLongs, double overlap, boolean copyUp) {
- println("Copy Using Direct MemoryImpl");
+ private static final void copyUsingDirectMemory(long copyLongs, double overlap, boolean copyUp) throws Exception {
+ println("Copy Using Direct Memory");
long overlapLongs = (long) (overlap * copyLongs);
long backingLongs = (2 * copyLongs) - overlapLongs;
@@ -93,8 +93,8 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemoryImpl.allocateDirect(backingBytes)) {
- WritableMemoryImpl backingMem = backHandle.get();
+ try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
+ WritableMemory backingMem = backHandle.getWritable();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
backingMem.copyTo(fromOffsetBytes, backingMem, toOffsetBytes, copyBytes);
@@ -104,8 +104,8 @@ public class CopyMemoryOverlapTest {
println("");
}
- private static final void copyUsingDirectRegions(long copyLongs, double overlap, boolean copyUp) {
- println("Copy Using Direct MemoryImpl");
+ private static final void copyUsingDirectRegions(long copyLongs, double overlap, boolean copyUp) throws Exception {
+ println("Copy Using Direct Memory");
long overlapLongs = (long) (overlap * copyLongs);
long backingLongs = (2 * copyLongs) - overlapLongs;
@@ -133,12 +133,12 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemoryImpl.allocateDirect(backingBytes)) {
- WritableMemoryImpl backingMem = backHandle.get();
+ try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
+ WritableMemory backingMem = backHandle.getWritable();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
- WritableMemoryImpl reg1 = backingMem.writableRegion(fromOffsetBytes, copyBytes);
- WritableMemoryImpl reg2 = backingMem.writableRegion(toOffsetBytes, copyBytes);
+ WritableMemory reg1 = backingMem.writableRegion(fromOffsetBytes, copyBytes);
+ WritableMemory reg2 = backingMem.writableRegion(toOffsetBytes, copyBytes);
reg1.copyTo(0, reg2, 0, copyBytes);
//listMem(backingMem, "After");
@@ -147,13 +147,13 @@ public class CopyMemoryOverlapTest {
println("");
}
- private static final void fill(WritableMemoryImpl wmem) {
+ private static final void fill(WritableMemory wmem) {
long longs = wmem.getCapacity() >>> 3;
for (long i = 0; i < longs; i++) { wmem.putLong(i << 3, i); } //fill with 0 .. (longs - 1)
//checkMemLongs(wmem, 0L, 0L, longs);
}
- private static final void checkMemLongs(MemoryImpl mem, long fromOffsetLongs, long toOffsetLongs, long copyLongs) {
+ private static final void checkMemLongs(Memory mem, long fromOffsetLongs, long toOffsetLongs, long copyLongs) {
for (long i = 0; i < copyLongs; i++) {
long memVal = mem.getLong((toOffsetLongs + i) << 3);
assertEquals(memVal, fromOffsetLongs + i);
@@ -161,7 +161,7 @@ public class CopyMemoryOverlapTest {
}
@SuppressWarnings("unused")
- private static final void listMem(MemoryImpl mem, String comment) {
+ private static final void listMem(Memory mem, String comment) {
println(comment);
println("Idx\tValue");
long longs = mem.getCapacity() >>> 3;
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 4a760bc..f2cc2c8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
@@ -25,8 +25,8 @@ import static org.testng.Assert.assertEquals;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -37,9 +37,9 @@ public class CopyMemoryTest {
public void heapWSource() {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
- WritableMemoryImpl srcMem = genMem(k1, false); //!empty
+ WritableMemory srcMem = genMem(k1, false); //!empty
//println(srcMem.toHexString("src: ", 0, k1 << 3));
- WritableMemoryImpl dstMem = genMem(k2, true);
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
//println(dstMem.toHexString("dst: ", 0, k2 << 3));
check(dstMem, k1, k1, 1);
@@ -49,31 +49,31 @@ public class CopyMemoryTest {
public void heapROSource() {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
- MemoryImpl srcMem = genMem(k1, false); //!empty
- WritableMemoryImpl dstMem = genMem(k2, true);
+ Memory srcMem = genMem(k1, false); //!empty
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
@Test
- public void directWSource() {
+ public void directWSource() throws Exception {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
try (WritableHandle wrh = genWRH(k1, false)) {
- WritableMemoryImpl srcMem = wrh.get();
- WritableMemoryImpl dstMem = genMem(k2, true);
+ WritableMemory srcMem = wrh.getWritable();
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
}
@Test
- public void directROSource() {
+ public void directROSource() throws Exception {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
try (WritableHandle wrh = genWRH(k1, false)) {
- MemoryImpl srcMem = wrh.get();
- WritableMemoryImpl dstMem = genMem(k2, true);
+ Memory srcMem = wrh.get();
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
@@ -83,10 +83,10 @@ public class CopyMemoryTest {
public void heapWSrcRegion() {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data
- WritableMemoryImpl baseMem = genMem(k1, false); //!empty
+ WritableMemory baseMem = genMem(k1, false); //!empty
//gen src region of k1/2 longs, off= k1/2
- WritableMemoryImpl srcReg = baseMem.writableRegion((k1/2) << 3, (k1/2) << 3);
- WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
+ WritableMemory srcReg = baseMem.writableRegion((k1/2) << 3, (k1/2) << 3);
+ WritableMemory dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
//println(dstMem.toHexString("dstMem: ", k1 << 3, (k1/2) << 3));
check(dstMem, k1, k1/2, (k1/2) + 1);
@@ -96,23 +96,23 @@ public class CopyMemoryTest {
public void heapROSrcRegion() {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data
- WritableMemoryImpl baseMem = genMem(k1, false); //!empty
+ WritableMemory baseMem = genMem(k1, false); //!empty
//gen src region of k1/2 longs, off= k1/2
- MemoryImpl srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
- WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
+ Memory srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
+ WritableMemory dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
check(dstMem, k1, k1/2, (k1/2) + 1);
}
@Test
- public void directROSrcRegion() {
+ public void directROSrcRegion() throws Exception {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data, direct
try (WritableHandle wrh = genWRH(k1, false)) {
- MemoryImpl baseMem = wrh.get();
+ Memory baseMem = wrh.get();
//gen src region of k1/2 longs, off= k1/2
- MemoryImpl srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
- WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
+ Memory srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
+ WritableMemory dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
check(dstMem, k1, k1/2, (k1/2) + 1);
}
@@ -123,8 +123,8 @@ public class CopyMemoryTest {
byte[] bytes = new byte[((UNSAFE_COPY_THRESHOLD_BYTES * 5) / 2) + 1];
ThreadLocalRandom.current().nextBytes(bytes);
byte[] referenceBytes = bytes.clone();
- MemoryImpl referenceMem = MemoryImpl.wrap(referenceBytes);
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(bytes);
+ Memory referenceMem = Memory.wrap(referenceBytes);
+ 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,
@@ -136,15 +136,15 @@ public class CopyMemoryTest {
byte[] bytes = new byte[((UNSAFE_COPY_THRESHOLD_BYTES * 5) / 2) + 1];
ThreadLocalRandom.current().nextBytes(bytes);
byte[] referenceBytes = bytes.clone();
- MemoryImpl referenceMem = MemoryImpl.wrap(referenceBytes);
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(bytes);
+ Memory referenceMem = Memory.wrap(referenceBytes);
+ 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,
copyLen));
}
- private static void check(MemoryImpl mem, int offsetLongs, int lengthLongs, int startValue) {
+ private static void check(Memory mem, int offsetLongs, int lengthLongs, int startValue) {
int offBytes = offsetLongs << 3;
for (long i = 0; i < lengthLongs; i++) {
assertEquals(mem.getLong(offBytes + (i << 3)), i + startValue);
@@ -152,8 +152,8 @@ public class CopyMemoryTest {
}
private static WritableHandle genWRH(int longs, boolean empty) {
- WritableHandle wrh = WritableMemoryImpl.allocateDirect(longs << 3);
- WritableMemoryImpl mem = wrh.get();
+ WritableHandle wrh = WritableMemory.allocateDirect(longs << 3);
+ WritableMemory mem = wrh.getWritable();
if (empty) {
mem.clear();
} else {
@@ -163,8 +163,8 @@ public class CopyMemoryTest {
}
- private static WritableMemoryImpl genMem(int longs, boolean empty) {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(longs << 3);
+ private static WritableMemory genMem(int longs, boolean empty) {
+ WritableMemory mem = WritableMemory.allocate(longs << 3);
if (!empty) {
for (int i = 0; i < longs; i++) { mem.putLong(i << 3, i + 1); }
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
index c0438a7..398409a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
@@ -25,7 +25,7 @@ import java.util.IdentityHashMap;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -43,7 +43,7 @@ public class ExampleMemoryRequestServerTest {
public void checkExampleMemoryRequestServer1() {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- WritableMemoryImpl wMem = svr.request(bytes);
+ WritableMemory wMem = svr.request(bytes);
MemoryClient client = new MemoryClient(wMem);
client.process();
svr.cleanup();
@@ -55,13 +55,14 @@ public class ExampleMemoryRequestServerTest {
* by the MemoryClient when it is done with the new memory allocations.
* The initial allocation stays open until the end where it is closed at the end of the
* TWR scope.
+ * @throws Exception
*/
@Test
- public void checkExampleMemoryRequestServer2() {
+ public void checkExampleMemoryRequestServer2() throws Exception {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- try (WritableHandle handle = WritableMemoryImpl.allocateDirect(bytes, svr)) {
- WritableMemoryImpl wMem = handle.get();
+ try (WritableHandle handle = WritableMemory.allocateDirect(bytes, svr)) {
+ WritableMemory wMem = handle.getWritable();
MemoryClient client = new MemoryClient(wMem);
client.process();
svr.cleanup();
@@ -72,7 +73,7 @@ public class ExampleMemoryRequestServerTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkZeroCapacity() {
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- WritableMemoryImpl.allocateDirect(0, svr);
+ WritableMemory.allocateDirect(0, svr);
}
/**
@@ -83,10 +84,10 @@ public class ExampleMemoryRequestServerTest {
* <p>In reality, these memory requests should be quite rare.</p>
*/
static class MemoryClient {
- WritableMemoryImpl smallMem;
+ WritableMemory smallMem;
MemoryRequestServer svr;
- MemoryClient(WritableMemoryImpl wmem) {
+ MemoryClient(WritableMemory wmem) {
smallMem = wmem;
svr = wmem.getMemoryRequestServer();
}
@@ -96,7 +97,7 @@ public class ExampleMemoryRequestServerTest {
smallMem.fill((byte) 1); //fill it, but not big enough
println(smallMem.toHexString("Small", 0, (int)cap1));
- WritableMemoryImpl bigMem = svr.request(2 * cap1); //get bigger mem
+ WritableMemory bigMem = svr.request(2 * cap1); //get bigger mem
long cap2 = bigMem.getCapacity();
smallMem.copyTo(0, bigMem, 0, cap1); //copy data from small to big
svr.requestClose(smallMem, bigMem); //done with smallMem, release it
@@ -104,7 +105,7 @@ public class ExampleMemoryRequestServerTest {
bigMem.fill(cap1, cap1, (byte) 2); //fill the rest of bigMem, still not big enough
println(bigMem.toHexString("Big", 0, (int)cap2));
- WritableMemoryImpl giantMem = svr.request(2 * cap2); //get giant mem
+ WritableMemory giantMem = svr.request(2 * cap2); //get giant mem
long cap3 = giantMem.getCapacity();
bigMem.copyTo(0, giantMem, 0, cap2); //copy data from small to big
svr.requestClose(bigMem, giantMem); //done with bigMem, release it
@@ -120,13 +121,13 @@ public class ExampleMemoryRequestServerTest {
* possibly manage the continuous requests for larger memory.
*/
public static class ExampleMemoryRequestServer implements MemoryRequestServer {
- IdentityHashMap<WritableMemoryImpl, WritableHandle> map = new IdentityHashMap<>();
+ IdentityHashMap<WritableMemory, WritableHandle> map = new IdentityHashMap<>();
@SuppressWarnings("resource")
@Override
- public WritableMemoryImpl request(long capacityBytes) {
- WritableHandle handle = WritableMemoryImpl.allocateDirect(capacityBytes, this);
- WritableMemoryImpl wmem = handle.get();
+ public WritableMemory request(long capacityBytes) {
+ WritableHandle handle = WritableMemory.allocateDirect(capacityBytes, this);
+ WritableMemory wmem = handle.getWritable();
map.put(wmem, handle); //We track the newly allocated memory and its handle.
return wmem;
}
@@ -134,11 +135,15 @@ public class ExampleMemoryRequestServerTest {
@SuppressWarnings("resource")
@Override
//here we actually release it, in reality it might be a lot more complex.
- public void requestClose(WritableMemoryImpl memToRelease, WritableMemoryImpl newMemory) {
+ public void requestClose(WritableMemory memToRelease, WritableMemory newMemory) {
if (memToRelease != null) {
WritableHandle handle = map.get(memToRelease);
- if (handle != null && handle.get() == memToRelease) {
- handle.close();
+ if (handle != null && handle.getWritable() == memToRelease) {
+ try {
+ handle.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
}
}
}
@@ -146,7 +151,11 @@ public class ExampleMemoryRequestServerTest {
public void cleanup() {
map.forEach((k,v) -> {
assertFalse(k.isValid()); //all entries in the map should be invalid
- v.close(); //harmless
+ try {
+ v.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ } //harmless
});
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
index 1653bc6..2af7572 100644
--- a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
@@ -20,27 +20,26 @@
package org.apache.datasketches.memory.test;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Ignore;
import org.testng.annotations.Test;
-@Ignore("Test causes OutOfMemoryError in Travis CI, run only locally")
@SuppressWarnings("javadoc")
public class IgnoredArrayOverflowTest {
private WritableHandle h;
- private WritableMemoryImpl memory;
+ private WritableMemory memory;
+ private static final long MAX_SIZE = (1L << 10); // use 1L << 31 to test int overrange
@BeforeClass
public void allocate() {
- h = WritableMemoryImpl.allocateDirect(Integer.MAX_VALUE + 100L);
- memory = h.get();
+ h = WritableMemory.allocateDirect(MAX_SIZE);
+ memory = h.getWritable();
}
@AfterClass
- public void close() {
+ public void close() throws Exception {
h.close();
}
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 19f8b8c..c8f739c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
@@ -32,9 +32,9 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
+import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.WritableMapHandle;
import org.testng.annotations.Test;
@@ -47,17 +47,17 @@ public class LeafImplTest {
static final ByteOrder BE = ByteOrder.BIG_ENDIAN;
@Test
- public void checkDirectLeafs() {
+ public void checkDirectLeafs() throws Exception {
long off = 0;
long cap = 128;
- try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(cap)) {
- WritableMemoryImpl memLE = wdh.get();
+ try (WritableDirectHandle wdh = WritableMemory.allocateDirect(cap)) {
+ WritableMemory memLE = wdh.getWritable();
memLE.putShort(0, (short) 1);
- checkDirectImpl(memLE, off, cap);
+ checkDirect(memLE, off, cap);
}
}
- private static void checkDirectImpl(WritableMemoryImpl mem, long off, long cap) {
+ private static void checkDirect(WritableMemory mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -71,7 +71,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() == null);
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -86,7 +86,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() == null);
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -101,7 +101,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() == null);
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -118,7 +118,7 @@ public class LeafImplTest {
}
@Test
- public void checkMapLeafs() throws IOException {
+ public void checkMapLeafs() throws Exception {
long off = 0;
long cap = 128;
File file = new File("TestFile2.bin");
@@ -134,15 +134,15 @@ public class LeafImplTest {
assertTrue(file.isFile());
file.deleteOnExit(); //comment out if you want to examine the file.
- try (WritableMapHandle wmh = WritableMemoryImpl.writableMap(file, off, cap, Util.nativeByteOrder)) {
- WritableMemoryImpl mem = wmh.get();
+ try (WritableMapHandle wmh = WritableMemory.writableMap(file, off, cap, Util.nativeByteOrder)) {
+ WritableMemory mem = wmh.getWritable();
mem.putShort(0, (short) 1);
assertEquals(mem.getByte(0), (byte) 1);
- checkMapImpl(mem, off, cap);
+ checkMap(mem, off, cap);
}
}
- private static void checkMapImpl(WritableMemoryImpl mem, long off, long cap) {
+ private static void checkMap(WritableMemory mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -156,7 +156,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() == null);
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -171,7 +171,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() == null);
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -186,7 +186,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() == null);
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -209,17 +209,17 @@ public class LeafImplTest {
ByteBuffer bb = ByteBuffer.allocate((int)cap);
bb.order(ByteOrder.nativeOrder());
bb.putShort(0, (short) 1);
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(bb);
- checkByteBufferImpl(mem, off, cap, false);
+ WritableMemory mem = WritableMemory.writableWrap(bb);
+ checkByteBuffer(mem, off, cap, false);
ByteBuffer dbb = ByteBuffer.allocateDirect((int)cap);
dbb.order(ByteOrder.nativeOrder());
dbb.putShort(0, (short) 1);
- mem = WritableMemoryImpl.writableWrap(dbb);
- checkByteBufferImpl(mem, off, cap, true);
+ mem = WritableMemory.writableWrap(dbb);
+ checkByteBuffer(mem, off, cap, true);
}
- private static void checkByteBufferImpl(WritableMemoryImpl mem, long off, long cap, boolean direct) {
+ private static void checkByteBuffer(WritableMemory mem, long off, long cap, boolean direct) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -239,7 +239,7 @@ public class LeafImplTest {
}
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -260,7 +260,7 @@ public class LeafImplTest {
}
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -281,7 +281,7 @@ public class LeafImplTest {
}
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -307,12 +307,12 @@ public class LeafImplTest {
public void checkHeapLeafs() {
long off = 0;
long cap = 128;
- WritableMemoryImpl mem = WritableMemoryImpl.allocate((int)cap);
+ WritableMemory mem = WritableMemory.allocate((int)cap);
mem.putShort(0, (short) 1);
- checkHeapImpl(mem, off, cap);
+ checkHeap(mem, off, cap);
}
- private static void checkHeapImpl(WritableMemoryImpl mem, long off, long cap) {
+ private static void checkHeap(WritableMemory mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -326,7 +326,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() != null);
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -341,7 +341,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() != null);
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -356,7 +356,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() != null);
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
index 7654af8..c45387f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
@@ -19,14 +19,14 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class MemoryBoundaryCheckTest {
- private final WritableBufferImpl writableBuffer = WritableMemoryImpl.allocate(8).asWritableBuffer();
+ private final WritableBuffer writableBuffer = WritableMemory.allocate(8).asWritableBuffer();
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
index ece9cdf..9181f94 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
@@ -20,23 +20,22 @@
package org.apache.datasketches.memory.test;
import java.io.File;
-import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class MemoryReadWriteSafetyTest {
- // Test various operations with read-only MemoryImpl
+ // Test various operations with read-only Memory
- final WritableMemoryImpl mem = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8]);
+ final WritableMemory mem = (WritableMemory) Memory.wrap(new byte[8]);
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -122,108 +121,108 @@ public class MemoryReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryRegion() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) WritableMemoryImpl.allocate(8).region(0, 8);
+ WritableMemory mem1 = (WritableMemory) WritableMemory.allocate(8).region(0, 8);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithBO() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8], ByteOrder.nativeOrder());
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithOffsetsAndBO() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testBooleanArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new boolean[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new boolean[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testShortArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new short[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new short[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testCharArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new char[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new char[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testIntArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new int[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new int[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testLongArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new long[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new long[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testFloatArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new float[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new float[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testDoubleArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new double[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new double[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteBufferWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(ByteBuffer.allocate(8));
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(ByteBuffer.allocate(8));
mem1.putInt(0, 1);
}
//@SuppressWarnings("resource")
@Test(expectedExceptions = AssertionError.class)
- public void testMapFile() throws IOException {
+ public void testMapFile() throws Exception {
File tempFile = File.createTempFile("test", null);
tempFile.deleteOnExit();
try (RandomAccessFile raf = new RandomAccessFile(tempFile, "rw")) {
raf.setLength(8);
//System.out.println(UtilTest.getFileAttributes(tempFile));
- try (MapHandle h = MemoryImpl.map(tempFile)) {
- ((WritableMemoryImpl) h.get()).putInt(0, 1);
+ try (MapHandle h = Memory.map(tempFile)) {
+ ((WritableMemory) h.get()).putInt(0, 1);
}
}
}
@SuppressWarnings("resource")
@Test(expectedExceptions = AssertionError.class)
- public void testMapFileWithOffsetsAndBO() throws IOException {
+ public void testMapFileWithOffsetsAndBO() throws Exception {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle h = MemoryImpl.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
- ((WritableMemoryImpl) h.get()).putInt(0, 1);
+ try (MapHandle h = Memory.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
+ ((WritableMemory) h.get()).putInt(0, 1);
}
}
@SuppressWarnings("resource")
@Test(expectedExceptions = IllegalArgumentException.class)
- public void testMapFileBeyondTheFileSize() throws IOException {
+ public void testMapFileBeyondTheFileSize() throws Exception {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle unused = MemoryImpl.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
+ try (MapHandle unused = Memory.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
}
}
}
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 e882209..ed6b210 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
@@ -35,12 +35,13 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
+import org.apache.datasketches.memory.BaseState;
import org.apache.datasketches.memory.MapHandle;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -56,10 +57,10 @@ public class MemoryTest {
}
@Test
- public void checkDirectRoundTrip() {
+ public void checkDirectRoundTrip() throws Exception {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(n * 8)) {
- WritableMemoryImpl mem = wh.get();
+ try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
+ WritableMemory mem = wh.getWritable();
for (int i = 0; i < n; i++) {
mem.putLong(i * 8, i);
}
@@ -73,7 +74,7 @@ public class MemoryTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(n * 8);
+ WritableMemory wmem = WritableMemory.allocate(n * 8);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -87,7 +88,7 @@ public class MemoryTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -95,20 +96,20 @@ public class MemoryTest {
long v = wmem.getLong(i * 8);
assertEquals(v, i);
}
- MemoryImpl mem = MemoryImpl.wrap(arr, ByteOrder.nativeOrder());
+ Memory mem = Memory.wrap(arr, ByteOrder.nativeOrder());
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
}
// check 0 length array wraps
- MemoryImpl memZeroLengthArrayBoolean = WritableMemoryImpl.writableWrap(new boolean[0]);
- MemoryImpl memZeroLengthArrayByte = WritableMemoryImpl.writableWrap(new byte[0]);
- MemoryImpl memZeroLengthArrayChar = WritableMemoryImpl.writableWrap(new char[0]);
- MemoryImpl memZeroLengthArrayShort = WritableMemoryImpl.writableWrap(new short[0]);
- MemoryImpl memZeroLengthArrayInt = WritableMemoryImpl.writableWrap(new int[0]);
- MemoryImpl memZeroLengthArrayLong = WritableMemoryImpl.writableWrap(new long[0]);
- MemoryImpl memZeroLengthArrayFloat = WritableMemoryImpl.writableWrap(new float[0]);
- MemoryImpl memZeroLengthArrayDouble = WritableMemoryImpl.writableWrap(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);
@@ -119,28 +120,28 @@ public class MemoryTest {
assertEquals(memZeroLengthArrayDouble.getCapacity(), 0);
// check 0 length array wraps
- List<MemoryImpl> memoryToCheck = Lists.newArrayList();
- memoryToCheck.add(WritableMemoryImpl.allocate(0));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(ByteBuffer.allocate(0)));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new boolean[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new byte[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new char[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new short[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new int[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new long[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new float[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new double[0]));
- memoryToCheck.add(MemoryImpl.wrap(ByteBuffer.allocate(0)));
- memoryToCheck.add(MemoryImpl.wrap(new boolean[0]));
- memoryToCheck.add(MemoryImpl.wrap(new byte[0]));
- memoryToCheck.add(MemoryImpl.wrap(new char[0]));
- memoryToCheck.add(MemoryImpl.wrap(new short[0]));
- memoryToCheck.add(MemoryImpl.wrap(new int[0]));
- memoryToCheck.add(MemoryImpl.wrap(new long[0]));
- memoryToCheck.add(MemoryImpl.wrap(new float[0]));
- memoryToCheck.add(MemoryImpl.wrap(new double[0]));
- //Check the MemoryImpl lengths
- for (MemoryImpl memory : memoryToCheck) {
+ List<Memory> memoryToCheck = Lists.newArrayList();
+ memoryToCheck.add(WritableMemory.allocate(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]));
+ memoryToCheck.add(Memory.wrap(new char[0]));
+ memoryToCheck.add(Memory.wrap(new short[0]));
+ memoryToCheck.add(Memory.wrap(new int[0]));
+ memoryToCheck.add(Memory.wrap(new long[0]));
+ memoryToCheck.add(Memory.wrap(new float[0]));
+ memoryToCheck.add(Memory.wrap(new double[0]));
+ //Check the Memory lengths
+ for (Memory memory : memoryToCheck) {
assertEquals(memory.getCapacity(), 0);
}
}
@@ -151,7 +152,7 @@ public class MemoryTest {
byte[] arr = new byte[n * 8];
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -163,13 +164,13 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- MemoryImpl mem1 = MemoryImpl.wrap(arr);
+ Memory mem1 = Memory.wrap(arr);
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = mem1.getLong(i * 8);
assertEquals(v, i);
}
//convert to RO
- MemoryImpl mem = wmem;
+ Memory mem = wmem;
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
@@ -181,7 +182,7 @@ public class MemoryTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
bb.order(ByteOrder.nativeOrder());
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -193,13 +194,13 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- MemoryImpl mem1 = MemoryImpl.wrap(bb);
+ Memory mem1 = Memory.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = mem1.getLong(i * 8);
assertEquals(v, i);
}
//convert to RO
- MemoryImpl mem = wmem;
+ Memory mem = wmem;
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
@@ -211,7 +212,7 @@ public class MemoryTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- MemoryImpl mem = MemoryImpl.wrap(bb);
+ Memory mem = Memory.wrap(bb);
assertFalse(mem.getTypeByteOrder() == Util.nativeByteOrder);
assertEquals(mem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -224,7 +225,7 @@ public class MemoryTest {
bb.position(64);
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- MemoryImpl mem = MemoryImpl.wrap(slice);
+ Memory mem = Memory.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(mem.getByte(i), 64 + i);
}
@@ -237,7 +238,7 @@ public class MemoryTest {
int n = 1024; //longs
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(n * 8);
+ WritableMemory wmem = WritableMemory.allocate(n * 8);
wmem.putLongArray(0, arr, 0, n);
long[] arr2 = new long[n];
wmem.getLongArray(0, arr2, 0, n);
@@ -252,8 +253,8 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- MemoryImpl mem = MemoryImpl.wrap(arr);
- MemoryImpl reg = mem.region(n2 * 8, n2 * 8); //top half
+ Memory mem = Memory.wrap(arr);
+ Memory reg = mem.region(n2 * 8, n2 * 8); //top half
for (int i = 0; i < n2; i++) {
long v = reg.getLong(i * 8);
long e = i + n2;
@@ -267,8 +268,8 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- MemoryImpl mem = MemoryImpl.wrap(arr);
- MemoryImpl reg = mem.region(n2 * 8, n2 * 8, Util.nonNativeByteOrder); //top half
+ Memory mem = Memory.wrap(arr);
+ Memory reg = mem.region(n2 * 8, n2 * 8, Util.nonNativeByteOrder); //top half
for (int i = 0; i < n2; i++) {
long v = Long.reverseBytes(reg.getLong(i * 8));
long e = i + n2;
@@ -282,13 +283,13 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
}
//println("");
- WritableMemoryImpl reg = wmem.writableRegion(n2 * 8, n2 * 8);
+ WritableMemory reg = wmem.writableRegion(n2 * 8, n2 * 8);
for (int i = 0; i < n2; i++) { reg.putLong(i * 8, i); }
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i % 8);
@@ -302,13 +303,13 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
}
//println("");
- WritableMemoryImpl reg = wmem.writableRegion(n2 * 8, n2 * 8, Util.nonNativeByteOrder);
+ WritableMemory reg = wmem.writableRegion(n2 * 8, n2 * 8, Util.nonNativeByteOrder);
for (int i = 0; i < n2; i++) { reg.putLong(i * 8, i); }
for (int i = 0; i < n; i++) {
long v = wmem.getLong(i * 8);
@@ -325,10 +326,14 @@ public class MemoryTest {
public void checkParentUseAfterFree() {
int bytes = 64 * 8;
@SuppressWarnings("resource") //intentionally not using try-with-resouces here
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- WritableMemoryImpl wmem = wh.get();
- wh.close();
- //with -ea assert: MemoryImpl not valid.
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableMemory wmem = wh.getWritable();
+ try {
+ wh.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
wmem.getLong(0);
}
@@ -337,36 +342,40 @@ public class MemoryTest {
public void checkRegionUseAfterFree() {
int bytes = 64;
@SuppressWarnings("resource") //intentionally not using try-with-resouces here
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- MemoryImpl wmem = wh.get();
- MemoryImpl region = wmem.region(0L, bytes);
- wh.close();
- //with -ea assert: MemoryImpl not valid.
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ Memory wmem = wh.get();
+ Memory region = wmem.region(0L, bytes);
+ try {
+ wh.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
region.getByte(0);
}
@Test
- public void checkUnsafeByteBufferView() {
- try (WritableDirectHandle wmemDirectHandle = WritableMemoryImpl.allocateDirect(2)) {
- WritableMemoryImpl wmemDirect = wmemDirectHandle.get();
+ public void checkUnsafeByteBufferView() throws Exception {
+ try (WritableDirectHandle wmemDirectHandle = WritableMemory.allocateDirect(2)) {
+ WritableMemory wmemDirect = wmemDirectHandle.getWritable();
wmemDirect.putByte(0, (byte) 1);
wmemDirect.putByte(1, (byte) 2);
checkUnsafeByteBufferView(wmemDirect);
}
- checkUnsafeByteBufferView(MemoryImpl.wrap(new byte[] {1, 2}));
+ checkUnsafeByteBufferView(Memory.wrap(new byte[] {1, 2}));
try {
@SuppressWarnings("unused")
- ByteBuffer unused = MemoryImpl.wrap(new int[]{1}).unsafeByteBufferView(0, 1);
+ ByteBuffer unused = Memory.wrap(new int[]{1}).unsafeByteBufferView(0, 1);
Assert.fail();
} catch (UnsupportedOperationException ingore) {
// expected
}
}
- private static void checkUnsafeByteBufferView(final MemoryImpl mem) {
+ private static void checkUnsafeByteBufferView(final Memory mem) {
ByteBuffer emptyByteBuffer = mem.unsafeByteBufferView(0, 0);
Assert.assertEquals(emptyByteBuffer.capacity(), 0);
ByteBuffer bb = mem.unsafeByteBufferView(1, 1);
@@ -385,23 +394,22 @@ public class MemoryTest {
@SuppressWarnings({ "resource", "static-access" })
@Test
- public void checkMonitorDirectStats() {
+ public void checkMonitorDirectStats() throws Exception {
int bytes = 1024;
- WritableHandle wh1 = WritableMemoryImpl.allocateDirect(bytes);
- WritableHandle wh2 = WritableMemoryImpl.allocateDirect(bytes);
- WritableMemoryImpl wMem2 = wh2.get();
- assertEquals(wMem2.getCurrentDirectMemoryAllocations(), 2L);
- assertEquals(wMem2.getCurrentDirectMemoryAllocated(), 2 * bytes);
+ WritableHandle wh1 = WritableMemory.allocateDirect(bytes);
+ WritableHandle wh2 = WritableMemory.allocateDirect(bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 2L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocated(), 2 * bytes);
wh1.close();
- assertEquals(wMem2.getCurrentDirectMemoryAllocations(), 1L);
- assertEquals(wMem2.getCurrentDirectMemoryAllocated(), bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 1L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocated(), bytes);
wh2.close();
wh2.close(); //check that it doesn't go negative.
//even though the handles are closed, these methods are static access
- assertEquals(wMem2.getCurrentDirectMemoryAllocations(), 0L);
- assertEquals(wMem2.getCurrentDirectMemoryAllocated(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocated(), 0L);
}
@SuppressWarnings({ "resource", "static-access" })
@@ -410,30 +418,29 @@ public class MemoryTest {
File file = getResourceFile("GettysburgAddress.txt");
long bytes = file.length();
- MapHandle mmh1 = MemoryImpl.map(file);
- MapHandle mmh2 = MemoryImpl.map(file);
- MemoryImpl wmem2 = mmh2.get();
+ MapHandle mmh1 = Memory.map(file);
+ MapHandle mmh2 = Memory.map(file);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocations(), 2L);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocated(), 2 * bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 2L);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), 2 * bytes);
mmh1.close();
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocations(), 1L);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocated(), bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 1L);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), bytes);
mmh2.close();
mmh2.close(); //check that it doesn't go negative.
//even though the handles are closed, these methods are static access
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocations(), 0L);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocated(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), 0L);
}
@Test
- public void checkNullMemReqSvr() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[16]);
+ public void checkNullMemReqSvr() throws Exception {
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[16]);
assertNull(wmem.getMemoryRequestServer());
- try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(16)) {
- WritableMemoryImpl wmem2 = wdh.get();
+ try (WritableDirectHandle wdh = WritableMemory.allocateDirect(16)) {
+ WritableMemory wmem2 = wdh.getWritable();
assertNotNull(wmem2.getMemoryRequestServer());
}
println(wmem.toHexString("Test", 0, 16));
@@ -441,7 +448,7 @@ public class MemoryTest {
@Test
public void checkHashCode() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(32 + 7);
+ WritableMemory wmem = WritableMemory.allocate(32 + 7);
int hc = wmem.hashCode();
assertEquals(hc, -1895166923);
}
@@ -449,7 +456,7 @@ public class MemoryTest {
@Test
public void checkSelfEqualsToAndCompareTo() {
int len = 64;
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(len);
+ WritableMemory wmem = WritableMemory.allocate(len);
for (int i = 0; i < len; i++) { wmem.putByte(i, (byte) i); }
assertTrue(wmem.equalTo(0, wmem, 0, len));
assertFalse(wmem.equalTo(0, wmem, len/2, len/2));
@@ -461,7 +468,7 @@ public class MemoryTest {
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as BE
- MemoryImpl mem = MemoryImpl.wrap(bb, ByteOrder.LITTLE_ENDIAN);
+ Memory mem = Memory.wrap(bb, ByteOrder.LITTLE_ENDIAN);
assertEquals(mem.getChar(0), 256);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
index 08e8bf8..f65374c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
@@ -28,8 +28,8 @@ import java.nio.channels.WritableByteChannel;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -57,10 +57,10 @@ public class MemoryWriteToTest {
}
@Test
- public void testOffHeap() throws IOException {
+ public void testOffHeap() throws Exception {
try (WritableHandle handle =
- WritableMemoryImpl.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
- WritableMemoryImpl mem = handle.get();
+ WritableMemory.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
+ WritableMemory mem = handle.getWritable();
testWriteTo(mem.region(0, 0));
testOffHeap(mem, 7);
testOffHeap(mem, 1023);
@@ -70,28 +70,28 @@ public class MemoryWriteToTest {
}
}
- private static void testOffHeap(WritableMemoryImpl mem, int size) throws IOException {
+ private static void testOffHeap(WritableMemory mem, int size) throws IOException {
createRandomBytesMemory(size).copyTo(0, mem, 0, size);
testWriteTo(mem.region(0, size));
}
- private static MemoryImpl createRandomBytesMemory(int size) {
+ private static Memory createRandomBytesMemory(int size) {
byte[] bytes = new byte[size];
ThreadLocalRandom.current().nextBytes(bytes);
- return MemoryImpl.wrap(bytes);
+ return Memory.wrap(bytes);
}
- private static MemoryImpl createRandomIntsMemory(int size) {
+ private static Memory createRandomIntsMemory(int size) {
int[] ints = ThreadLocalRandom.current().ints(size).toArray();
- return MemoryImpl.wrap(ints);
+ return Memory.wrap(ints);
}
- private static void testWriteTo(MemoryImpl mem) throws IOException {
+ private static void testWriteTo(Memory mem) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (WritableByteChannel out = Channels.newChannel(baos)) {
mem.writeTo(0, mem.getCapacity(), out);
}
byte[] result = baos.toByteArray();
- Assert.assertTrue(mem.equals(MemoryImpl.wrap(result)));
+ Assert.assertTrue(mem.equals(Memory.wrap(result)));
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NativeWritableBufferImplTest.java
similarity index 66%
rename from src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
rename to src/test/java/org/apache/datasketches/memory/test/NativeWritableBufferImplTest.java
index 18a43da..06f6697 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NativeWritableBufferImplTest.java
@@ -27,28 +27,28 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
-public class WritableBufferImplTest {
+public class NativeWritableBufferImplTest {
//Simple Native direct
@SuppressWarnings("resource")
@Test
- public void checkNativeCapacityAndClose() {
+ public void checkNativeCapacityAndClose() throws Exception {
int memCapacity = 64;
- WritableHandle wmh = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableMemoryImpl wmem = wmh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
+ WritableMemory wmem = wmh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), memCapacity);
wmh.close(); //intentional
@@ -64,13 +64,13 @@ public class WritableBufferImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -83,13 +83,13 @@ public class WritableBufferImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -101,13 +101,13 @@ public class WritableBufferImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -119,13 +119,13 @@ public class WritableBufferImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -137,13 +137,13 @@ public class WritableBufferImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -155,13 +155,13 @@ public class WritableBufferImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -173,13 +173,13 @@ public class WritableBufferImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -191,13 +191,13 @@ public class WritableBufferImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(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]);
@@ -205,11 +205,11 @@ public class WritableBufferImplTest {
}
@Test
- public void checkNativeBaseBound() {
+ public void checkNativeBaseBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl wmem = wrh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory wmem = wrh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
//ok
@@ -217,11 +217,11 @@ public class WritableBufferImplTest {
}
@Test
- public void checkNativeSrcArrayBound() {
+ public void checkNativeSrcArrayBound() throws Exception {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl wmem = wrh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory wmem = wrh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
byte[] srcArray = { 1, -2, 3, -4 };
wbuf.putByteArray(srcArray, 0, 5); //wrong!
} catch (IllegalArgumentException e) {
@@ -231,11 +231,11 @@ public class WritableBufferImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
- public void checkRegionBounds() {
+ public void checkRegionBounds() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl wmem = wrh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory wmem = wrh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.writableRegion(1, 64, wbuf.getTypeByteOrder()); //wrong!
}
}
@@ -250,7 +250,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(byteBuf);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(wbuf.getByte(), byteBuf.get(i));
@@ -272,7 +272,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- BufferImpl buf = WritableBufferImpl.writableWrap(byteBuf);
+ Buffer buf = WritableBuffer.writableWrap(byteBuf);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -288,7 +288,7 @@ public class WritableBufferImplTest {
byteBuf.order(ByteOrder.nativeOrder());
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
- WritableBufferImpl.writableWrap(byteBufRO);
+ WritableBuffer.writableWrap(byteBufRO);
}
@Test
@@ -303,7 +303,7 @@ public class WritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- BufferImpl buf = BufferImpl.wrap(byteBufRO);
+ Buffer buf = Buffer.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -319,7 +319,7 @@ public class WritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableBufferImpl.writableWrap(byteBufRO);
+ WritableBuffer.writableWrap(byteBufRO);
}
@Test
@@ -332,7 +332,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- BufferImpl buf = BufferImpl.wrap(byteBuf);
+ Buffer buf = Buffer.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -342,15 +342,15 @@ public class WritableBufferImplTest {
}
@Test
- public void checkIsDirect() {
+ public void checkIsDirect() throws Exception {
int memCapacity = 64;
- WritableBufferImpl mem = WritableMemoryImpl.allocate(memCapacity).asWritableBuffer();
+ WritableBuffer mem = WritableMemory.allocate(memCapacity).asWritableBuffer();
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem2 = wrh.get();
- WritableBufferImpl wbuf = mem2.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem2 = wrh.getWritable();
+ WritableBuffer wbuf = mem2.asWritableBuffer();
assertTrue(wbuf.isDirect());
- wrh.close();
+ wrh.close(); //immediate close
}
}
@@ -358,10 +358,10 @@ public class WritableBufferImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
assertFalse(wbuf.isReadOnly());
- BufferImpl buf = wbuf;
+ Buffer buf = wbuf;
assertFalse(buf.isReadOnly());
for (int i = 0; i < srcArray.length; i++) {
@@ -380,9 +380,9 @@ public class WritableBufferImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- BufferImpl buf1 = MemoryImpl.wrap(arr1).asBuffer();
- BufferImpl buf2 = MemoryImpl.wrap(arr2).asBuffer();
- BufferImpl buf3 = MemoryImpl.wrap(arr3).asBuffer();
+ Buffer buf1 = Memory.wrap(arr1).asBuffer();
+ Buffer buf2 = Memory.wrap(arr2).asBuffer();
+ Buffer buf3 = Memory.wrap(arr3).asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -398,27 +398,27 @@ public class WritableBufferImplTest {
}
@Test
- public void checkCompareToDirect() {
+ public void checkCompareToDirect() throws Exception {
byte[] arr1 = new byte[] {0, 1, 2, 3};
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h2 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h3 = WritableMemoryImpl.allocateDirect(5))
+ try (WritableHandle h1 = WritableMemory.allocateDirect(4);
+ WritableHandle h2 = WritableMemory.allocateDirect(4);
+ WritableHandle h3 = WritableMemory.allocateDirect(5))
{
- WritableMemoryImpl mem1 = h1.get();
+ WritableMemory mem1 = h1.getWritable();
mem1.putByteArray(0, arr1, 0, 4);
- WritableMemoryImpl mem2 = h2.get();
+ WritableMemory mem2 = h2.getWritable();
mem2.putByteArray(0, arr2, 0, 4);
- WritableMemoryImpl mem3 = h3.get();
+ WritableMemory mem3 = h3.getWritable();
mem3.putByteArray(0, arr3, 0, 5);
- BufferImpl buf1 = mem1.asBuffer();
- BufferImpl buf2 = mem2.asBuffer();
- BufferImpl buf3 = mem3.asBuffer();
+ Buffer buf1 = mem1.asBuffer();
+ Buffer buf2 = mem2.asBuffer();
+ Buffer buf3 = mem3.asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -436,13 +436,13 @@ public class WritableBufferImplTest {
@Test
public void checkAsBuffer() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
//println(wbuf.toHexString("Buf", 0, (int)wbuf.getCapacity()));
- BufferImpl buf = wmem.asBuffer();
+ Buffer buf = wmem.asBuffer();
buf.setPosition(32);
for (int i = 32; i < 64; i++) {
assertEquals(buf.getByte(), i);
@@ -451,32 +451,32 @@ public class WritableBufferImplTest {
@Test
public void checkDuplicate() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
for (int i = 0; i < 64; i++) { wmem.putByte(i, (byte)i); }
- WritableBufferImpl wbuf = wmem.asWritableBuffer().writableDuplicate();
+ WritableBuffer wbuf = wmem.asWritableBuffer().writableDuplicate();
wbuf.checkValidAndBounds(0, 64);
for (int i = 0; i < 64; i++) {
assertEquals(wbuf.getByte(), i);
}
- BufferImpl buf = wmem.asBuffer().duplicate();
+ Buffer buf = wmem.asBuffer().duplicate();
for (int i = 0; i < 64; i++) {
assertEquals(buf.getByte(), i);
}
- WritableMemoryImpl wmem2 = wbuf.asWritableMemory();
+ WritableMemory wmem2 = wbuf.asWritableMemory();
for (int i = 0; i < 64; i++) {
assertEquals(wmem2.getByte(i), i);
}
- WritableMemoryImpl wmem3 = wbuf.asWritableMemory();
+ WritableMemory wmem3 = wbuf.asWritableMemory();
wmem3.checkValidAndBounds(0, 64);
}
@Test
public void checkCumAndRegionOffset() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableMemoryImpl reg = wmem.writableRegion(32, 32);
- WritableBufferImpl buf = reg.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory reg = wmem.writableRegion(32, 32);
+ WritableBuffer buf = reg.asWritableBuffer();
assertEquals(buf.getRegionOffset(), 32);
assertEquals(buf.getRegionOffset(0), 32);
assertEquals(buf.getCumulativeOffset(), 32 + 16);
@@ -486,31 +486,31 @@ public class WritableBufferImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableBufferImpl wbuf1 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
- WritableBufferImpl wbuf2 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf1 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf2 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
assertTrue(wbuf1.isSameResource(wbuf2));
}
@Test
public void checkDegenerateRegionReturn() {
- MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
- BufferImpl buf = mem.asBuffer();
- BufferImpl reg = buf.region();
+ Memory mem = Memory.wrap(new byte[0]);
+ Buffer buf = mem.asBuffer();
+ Buffer reg = buf.region();
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkAsWritableMemoryRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableMemoryImpl wmem = wbuf.asWritableMemory();
+ WritableMemory wmem = wbuf.asWritableMemory();
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableMemoryImpl wmem2 = wbuf.asWritableMemory();
+ WritableMemory wmem2 = wbuf.asWritableMemory();
Assert.fail();
} catch (ReadOnlyException expected) {
// expected
@@ -520,15 +520,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableDuplicateRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBufferImpl wdup = wbuf.writableDuplicate();
+ WritableBuffer wdup = wbuf.writableDuplicate();
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableBufferImpl wdup2 = wbuf.writableDuplicate();
+ WritableBuffer wdup2 = wbuf.writableDuplicate();
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -538,15 +538,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableRegionRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBufferImpl wreg = wbuf.writableRegion();
+ WritableBuffer wreg = wbuf.writableRegion();
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableBufferImpl wreg2 = wbuf.writableRegion();
+ WritableBuffer wreg2 = wbuf.writableRegion();
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -556,15 +556,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableRegionWithParamsRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBufferImpl wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBuffer wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableBufferImpl wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBuffer wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -573,17 +573,17 @@ public class WritableBufferImplTest {
@Test
public void checkZeroBuffer() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- WritableBufferImpl reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
+ WritableMemory wmem = WritableMemory.allocate(8);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBuffer reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkDuplicateNonNative() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
wmem.putShort(0, (short) 1);
- BufferImpl buf = wmem.asWritableBuffer().duplicate(Util.nonNativeByteOrder);
+ Buffer buf = wmem.asWritableBuffer().duplicate(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NativeWritableMemoryImplTest.java
similarity index 71%
rename from src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
rename to src/test/java/org/apache/datasketches/memory/test/NativeWritableMemoryImplTest.java
index 2cb8460..017d4e2 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NativeWritableMemoryImplTest.java
@@ -28,26 +28,26 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
-public class WritableMemoryImplTest {
+public class NativeWritableMemoryImplTest {
//Simple Native direct
@SuppressWarnings("resource")
@Test
- public void checkNativeCapacityAndClose() {
+ public void checkNativeCapacityAndClose() throws Exception {
int memCapacity = 64;
- WritableHandle wmh = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableMemoryImpl mem = wmh.get();
+ WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
+ WritableMemory mem = wmh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
wmh.close(); //intentional
@@ -63,13 +63,13 @@ public class WritableMemoryImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -82,13 +82,13 @@ public class WritableMemoryImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -100,13 +100,13 @@ public class WritableMemoryImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -118,13 +118,13 @@ public class WritableMemoryImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -136,13 +136,13 @@ public class WritableMemoryImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -154,13 +154,13 @@ public class WritableMemoryImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -172,13 +172,13 @@ public class WritableMemoryImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -190,13 +190,13 @@ public class WritableMemoryImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -204,10 +204,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkNativeBaseBound() {
+ public void checkNativeBaseBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
//ok
@@ -215,10 +215,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkNativeSrcArrayBound() {
+ public void checkNativeSrcArrayBound() throws Exception {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
byte[] srcArray = { 1, -2, 3, -4 };
mem.putByteArray(0L, srcArray, 0, 5);
} catch (IllegalArgumentException e) {
@@ -230,16 +230,16 @@ public class WritableMemoryImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkDegenerateCopyTo() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
wmem.copyTo(0, wmem, 0, 64);
}
@Test
- public void checkCopyWithinNativeSmall() {
+ public void checkCopyWithinNativeSmall() throws Exception {
int memCapacity = 64;
int half = memCapacity/2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i=0; i<half; i++) { //fill first half
@@ -255,13 +255,13 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyWithinNativeLarge() {
+ public void checkCopyWithinNativeLarge() throws Exception {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i=0; i < halfLongs; i++) {
@@ -277,10 +277,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyWithinNativeSrcBound() {
+ public void checkCopyWithinNativeSrcBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
}
@@ -290,10 +290,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyWithinNativeDstBound() {
+ public void checkCopyWithinNativeDstBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
}
@@ -303,14 +303,14 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeSmall() {
+ public void checkCopyCrossNativeSmall() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
{
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i=0; i < memCapacity; i++) {
mem1.putByte(i, (byte) i);
@@ -327,15 +327,15 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeLarge() {
+ public void checkCopyCrossNativeLarge() throws Exception {
int memCapacity = (2<<20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
{
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i=0; i < memCapLongs; i++) {
mem1.putLong(i*8, i);
@@ -351,16 +351,16 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeAndByteArray() {
+ public void checkCopyCrossNativeAndByteArray() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i=0; i<16; i++) {
@@ -371,21 +371,21 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossRegionsSameNative() {
+ public void checkCopyCrossRegionsSameNative() throws Exception {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- MemoryImpl reg1 = mem1.region(8, 16);
+ Memory reg1 = mem1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
- WritableMemoryImpl reg2 = mem1.writableRegion(24, 16);
+ WritableMemory reg2 = mem1.writableRegion(24, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
reg1.copyTo(0, reg2, 0, 16);
@@ -398,24 +398,24 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeArrayAndHierarchicalRegions() {
+ public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) { //fill with numbers
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
- MemoryImpl reg1 = mem1.region(8, 32);
- MemoryImpl reg1B = reg1.region(8, 16);
+ Memory reg1 = mem1.region(8, 32);
+ Memory reg1B = reg1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
//println(reg1B.toHexString("Reg1B", 0, (int)reg1B.getCapacity()));
- WritableMemoryImpl reg2 = mem2.writableRegion(32, 16);
+ WritableMemory reg2 = mem2.writableRegion(32, 16);
reg1B.copyTo(0, reg2, 0, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
@@ -428,10 +428,10 @@ public class WritableMemoryImplTest {
}
@Test(expectedExceptions = IllegalArgumentException.class)
- public void checkRegionBounds() {
+ public void checkRegionBounds() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.writableRegion(1, 64);
}
}
@@ -446,7 +446,7 @@ public class WritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(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);
}
- MemoryImpl mem = WritableMemoryImpl.writableWrap(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();
- WritableMemoryImpl.writableWrap(byteBufRO);
+ WritableMemory.writableWrap(byteBufRO);
}
@Test
@@ -499,7 +499,7 @@ public class WritableMemoryImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- MemoryImpl mem = MemoryImpl.wrap(byteBufRO);
+ Memory mem = Memory.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -515,7 +515,7 @@ public class WritableMemoryImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableMemoryImpl.writableWrap(byteBufRO);
+ WritableMemory.writableWrap(byteBufRO);
}
@Test
@@ -528,7 +528,7 @@ public class WritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- MemoryImpl mem = MemoryImpl.wrap(byteBuf);
+ Memory mem = Memory.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -538,12 +538,12 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkIsDirect() {
+ public void checkIsDirect() throws Exception {
int memCapacity = 64;
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem = WritableMemory.allocate(memCapacity);
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ mem = wrh.getWritable();
assertTrue(mem.isDirect());
wrh.close();
}
@@ -553,10 +553,10 @@ public class WritableMemoryImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
assertFalse(wmem.isReadOnly());
- MemoryImpl memRO = wmem;
+ Memory memRO = wmem;
assertFalse(memRO.isReadOnly());
for (int i = 0; i < wmem.getCapacity(); i++) {
@@ -575,10 +575,10 @@ public class WritableMemoryImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- MemoryImpl mem1 = MemoryImpl.wrap(arr1);
- MemoryImpl mem2 = MemoryImpl.wrap(arr2);
- MemoryImpl mem3 = MemoryImpl.wrap(arr3);
- MemoryImpl mem4 = MemoryImpl.wrap(arr3); //same resource
+ Memory mem1 = Memory.wrap(arr1);
+ Memory mem2 = Memory.wrap(arr2);
+ Memory mem3 = Memory.wrap(arr3);
+ Memory mem4 = Memory.wrap(arr3); //same resource
int comp = mem1.compareTo(0, 3, mem2, 0, 3);
assertEquals(comp, 0);
@@ -599,22 +599,22 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCompareToDirect() {
+ public void checkCompareToDirect() throws Exception {
byte[] arr1 = new byte[] {0, 1, 2, 3};
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h2 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h3 = WritableMemoryImpl.allocateDirect(5))
+ try (WritableHandle h1 = WritableMemory.allocateDirect(4);
+ WritableHandle h2 = WritableMemory.allocateDirect(4);
+ WritableHandle h3 = WritableMemory.allocateDirect(5))
{
- WritableMemoryImpl mem1 = h1.get();
+ WritableMemory mem1 = h1.getWritable();
mem1.putByteArray(0, arr1, 0, 4);
- WritableMemoryImpl mem2 = h2.get();
+ WritableMemory mem2 = h2.getWritable();
mem2.putByteArray(0, arr2, 0, 4);
- WritableMemoryImpl mem3 = h3.get();
+ WritableMemory mem3 = h3.getWritable();
mem3.putByteArray(0, arr3, 0, 5);
int comp = mem1.compareTo(0, 3, mem2, 0, 3);
@@ -633,7 +633,7 @@ public class WritableMemoryImplTest {
@Test
public void testCompareToSameStart() {
- MemoryImpl mem = WritableMemoryImpl.allocate(3);
+ Memory mem = WritableMemory.allocate(3);
assertEquals(-1, mem.compareTo(0, 1, mem, 0, 2));
assertEquals(0, mem.compareTo(1, 1, mem, 1, 1));
assertEquals(1, mem.compareTo(1, 2, mem, 1, 1));
@@ -641,13 +641,13 @@ public class WritableMemoryImplTest {
@Test
public void checkAsBuffer() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
//println(wbuf.toHexString("Buf", 0, (int)wbuf.getCapacity()));
- BufferImpl buf = wmem.asBuffer();
+ Buffer buf = wmem.asBuffer();
buf.setPosition(32);
for (int i = 32; i < 64; i++) {
assertEquals(buf.getByte(), i);
@@ -656,8 +656,8 @@ public class WritableMemoryImplTest {
@Test
public void checkCumAndRegionOffset() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableMemoryImpl reg = wmem.writableRegion(32, 32);
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory reg = wmem.writableRegion(32, 32);
assertEquals(reg.getRegionOffset(), 32);
assertEquals(reg.getRegionOffset(0), 32);
assertEquals(reg.getCumulativeOffset(), 32 + 16);
@@ -667,8 +667,8 @@ public class WritableMemoryImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(byteArr);
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(byteArr);
+ WritableMemory wmem1 = WritableMemory.writableWrap(byteArr);
+ WritableMemory wmem2 = WritableMemory.writableWrap(byteArr);
assertTrue(wmem1.isSameResource(wmem2));
}
@@ -677,8 +677,8 @@ public class WritableMemoryImplTest {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
byteBuf.position(16);
byteBuf.limit(48);
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteBuf);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), 64);
assertEquals(wbuf.getPosition(), 0);
assertEquals(wbuf.getEnd(), 64);
@@ -687,28 +687,28 @@ public class WritableMemoryImplTest {
@Test(expectedExceptions = ReadOnlyException.class)
public void checkAsWritableRegionRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemoryImpl wmem = (WritableMemoryImpl) MemoryImpl.wrap(byteBuf);
+ WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
wmem.writableRegion(0, 1);
}
@Test(expectedExceptions = ReadOnlyException.class)
public void checkAsWritableBufferRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemoryImpl wmem = (WritableMemoryImpl) MemoryImpl.wrap(byteBuf);
+ WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
wmem.asWritableBuffer();
}
@Test void checkZeroMemory() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
- WritableMemoryImpl reg = wmem.writableRegion(0, 0);
+ WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemory reg = wmem.writableRegion(0, 0);
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkAsBufferNonNative() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
wmem.putShort(0, (short) 1);
- BufferImpl buf = wmem.asBuffer(Util.nonNativeByteOrder);
+ Buffer buf = wmem.asBuffer(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
}
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 84c2f1c..7753e6e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
@@ -23,9 +23,9 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -41,8 +41,8 @@ public class NonNativeWritableBufferImplTest {
int m = Character.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ 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++); }
ch = 'a';
@@ -62,8 +62,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getCharArray(cArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putCharArray(cArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -74,8 +74,8 @@ public class NonNativeWritableBufferImplTest {
int m = Double.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ 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++); }
dbl = 1.0;
@@ -95,8 +95,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getDoubleArray(dblArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putDoubleArray(dblArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -107,8 +107,8 @@ public class NonNativeWritableBufferImplTest {
int m = Float.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ 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++); }
flt = 1.0F;
@@ -128,8 +128,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getFloatArray(fltArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putFloatArray(fltArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -140,8 +140,8 @@ public class NonNativeWritableBufferImplTest {
int m = Integer.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ 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++); }
intg = 1;
@@ -161,8 +161,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getIntArray(intArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putIntArray(intArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -173,8 +173,8 @@ public class NonNativeWritableBufferImplTest {
int m = Long.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ 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++); }
lng = 1;
@@ -194,8 +194,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getLongArray(longArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putLongArray(longArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -206,8 +206,8 @@ public class NonNativeWritableBufferImplTest {
int m = Short.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ 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++); }
sht = 1;
@@ -227,8 +227,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getShortArray(shortArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putShortArray(shortArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -237,24 +237,24 @@ public class NonNativeWritableBufferImplTest {
@Test
public void checkDuplicate() {
byte[] bArr = new byte[8];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- WritableBufferImpl wdup = wbuf.writableDuplicate();
+ WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBuffer wdup = wbuf.writableDuplicate();
assertEquals(wdup.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wreg = wbuf.writableRegion();
+ WritableBuffer wreg = wbuf.writableRegion();
assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkDuplicateZeros() {
byte[] bArr = new byte[0];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
- BufferImpl buf = wmem.asBuffer();
- BufferImpl dup = buf.duplicate();
+ WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ Buffer buf = wmem.asBuffer();
+ Buffer dup = buf.duplicate();
assertEquals(dup.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.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 f9e60f6..c6351dc 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -33,7 +33,7 @@ import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class NonNativeWritableMemoryImplTest {
private byte[] bArr = new byte[8];
- private final WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(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
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(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
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(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
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(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
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(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
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(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
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putShortArray(0, shortArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -205,15 +205,15 @@ public class NonNativeWritableMemoryImplTest {
//check Region
@Test
public void checkRegion() {
- WritableMemoryImpl wreg = wmem.writableRegion(0, wmem.getCapacity());
+ WritableMemory wreg = wmem.writableRegion(0, wmem.getCapacity());
assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkRegionZeros() {
byte[] bArr1 = new byte[0];
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(bArr1, ByteOrder.BIG_ENDIAN);
- MemoryImpl reg = wmem1.region(0, wmem1.getCapacity());
+ 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 daea055..1947316 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
@@ -221,30 +221,6 @@ public final class ReflectUtil {
CHECK_VALID.invoke(target);
}
-// static long getCurrentDirectMemoryAllocated() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_ALLOCATED.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-//
-// static long getCurrentDirectMemoryAllocations() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_ALLOCATIONS.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-//
-// static long getCurrentDirectMemoryMapAllocated() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATED.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-//
-// static long getCurrentDirectMemoryMapAllocations() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-
static long getDirectAllocationsCount() {
try {
return (long) GET_DIRECT_ALLOCATIONS_COUNT.invoke(null);
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 a1e5ce7..5b342d9 100644
--- a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
@@ -26,10 +26,10 @@ import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.WritableMapHandle;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.testng.annotations.Test;
@@ -46,16 +46,16 @@ public class SpecificLeafTest {
ByteBuffer bb = ByteBuffer.allocate(bytes);
bb.order(Util.nativeByteOrder);
- MemoryImpl mem = MemoryImpl.wrap(bb).region(0, bytes, Util.nativeByteOrder);
+ Memory mem = Memory.wrap(bb).region(0, bytes, Util.nativeByteOrder);
assertTrue(ReflectUtil.isBBType(mem));
assertTrue(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
- BufferImpl buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
bb.order(Util.nonNativeByteOrder);
- MemoryImpl mem2 = MemoryImpl.wrap(bb).region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory mem2 = Memory.wrap(bb).region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(mem2));
@@ -65,22 +65,22 @@ public class SpecificLeafTest {
}
@Test
- public void checkDirectLeafs() {
+ public void checkDirectLeafs() throws Exception {
int bytes = 128;
- try (WritableDirectHandle h = WritableMemoryImpl.allocateDirect(bytes)) {
- WritableMemoryImpl wmem = h.get(); //native mem
+ try (WritableDirectHandle h = WritableMemory.allocateDirect(bytes)) {
+ WritableMemory wmem = h.getWritable(); //native mem
assertTrue(ReflectUtil.isDirectType(wmem));
assertFalse(wmem.isReadOnly());
checkCrossLeafTypeIds(wmem);
- WritableMemoryImpl nnwmem = wmem.writableRegion(0, bytes, Util.nonNativeByteOrder);
+ WritableMemory nnwmem = wmem.writableRegion(0, bytes, Util.nonNativeByteOrder);
- MemoryImpl mem = wmem.region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Memory mem = wmem.region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
- MemoryImpl mem2 = nnwmem.region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory mem2 = nnwmem.region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(mem2));
@@ -91,7 +91,7 @@ public class SpecificLeafTest {
}
@Test
- public void checkMapLeafs() throws IOException {
+ public void checkMapLeafs() throws Exception {
File file = new File("TestFile2.bin");
if (file.exists()) {
try {
@@ -107,20 +107,20 @@ public class SpecificLeafTest {
final long bytes = 128;
- try (WritableMapHandle h = WritableMemoryImpl.writableMap(file, 0L, bytes, Util.nativeByteOrder)) {
- WritableMemoryImpl mem = h.get(); //native mem
+ try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nativeByteOrder)) {
+ WritableMemory mem = h.getWritable(); //native mem
assertTrue(ReflectUtil.isMapType(mem));
assertFalse(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
- MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
+ Memory nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
- MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf4 = buf.duplicate();
+ Memory reg = mem.region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Buffer buf4 = buf.duplicate();
- MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(reg));
assertTrue(ReflectUtil.isRegionType(reg2));
@@ -134,19 +134,19 @@ public class SpecificLeafTest {
@Test
public void checkHeapLeafs() {
int bytes = 128;
- MemoryImpl mem = MemoryImpl.wrap(new byte[bytes]);
+ Memory mem = Memory.wrap(new byte[bytes]);
assertTrue(ReflectUtil.isHeapType(mem));
assertTrue(ReflectUtil.isReadOnlyType(mem));
checkCrossLeafTypeIds(mem);
- MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
+ Memory nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
- MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf4 = buf.duplicate();
+ Memory reg = mem.region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Buffer buf4 = buf.duplicate();
- MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertFalse(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(reg2));
@@ -156,31 +156,31 @@ public class SpecificLeafTest {
assertTrue(ReflectUtil.isDuplicateType(buf4));
}
- private static void checkCrossLeafTypeIds(MemoryImpl mem) {
- MemoryImpl reg1 = mem.region(0, mem.getCapacity());
+ private static void checkCrossLeafTypeIds(Memory mem) {
+ Memory reg1 = mem.region(0, mem.getCapacity());
assertTrue(ReflectUtil.isRegionType(reg1));
- BufferImpl buf1 = reg1.asBuffer();
+ Buffer buf1 = reg1.asBuffer();
assertTrue(ReflectUtil.isRegionType(buf1));
assertTrue(ReflectUtil.isBufferType(buf1));
- BufferImpl buf2 = buf1.duplicate();
+ Buffer buf2 = buf1.duplicate();
assertTrue(ReflectUtil.isRegionType(buf2));
assertTrue(ReflectUtil.isBufferType(buf2));
assertTrue(ReflectUtil.isDuplicateType(buf2));
- MemoryImpl mem2 = buf1.asMemory();
+ Memory mem2 = buf1.asMemory();
assertTrue(ReflectUtil.isRegionType(mem2));
assertFalse(ReflectUtil.isBufferType(mem2));
assertFalse(ReflectUtil.isDuplicateType(mem2));
- BufferImpl buf3 = buf1.duplicate(Util.nonNativeByteOrder);
+ Buffer buf3 = buf1.duplicate(Util.nonNativeByteOrder);
assertTrue(ReflectUtil.isRegionType(buf3));
assertTrue(ReflectUtil.isBufferType(buf3));
assertTrue(ReflectUtil.isDuplicateType(buf3));
assertTrue(ReflectUtil.isNonNativeType(buf3));
- MemoryImpl mem3 = buf3.asMemory();
+ Memory mem3 = buf3.asMemory();
assertTrue(ReflectUtil.isRegionType(mem3));
assertFalse(ReflectUtil.isBufferType(mem3));
assertFalse(ReflectUtil.isDuplicateType(mem3));
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 0a710c8..96c3921 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
@@ -28,9 +28,9 @@ import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.List;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Utf8CodingException;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.internal.Util.RandomCodePoints;
import org.testng.annotations.Test;
@@ -59,15 +59,15 @@ public class Utf8Test {
@Test
public void testPutInvalidChars() { //The surrogates must be a pair, thus invalid alone
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(10);
- WritableMemoryImpl emptyMem = WritableMemoryImpl.allocate(0);
+ WritableMemory mem = WritableMemory.allocate(10);
+ WritableMemory emptyMem = WritableMemory.allocate(0);
for (int c = Character.MIN_SURROGATE; c <= Character.MAX_SURROGATE; c++) {
assertSurrogate(mem, (char) c);
assertSurrogate(emptyMem, (char) c);
}
}
- private static void assertSurrogate(WritableMemoryImpl mem, char c) {
+ private static void assertSurrogate(WritableMemory mem, char c) {
try {
mem.putCharsToUtf8(0, new String(new char[] {c}));
fail();
@@ -78,7 +78,7 @@ public class Utf8Test {
@Test
public void testPutInvaidSurrogatePairs() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(4);
+ WritableMemory mem = WritableMemory.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MAX_HIGH_SURROGATE);
@@ -91,7 +91,7 @@ public class Utf8Test {
@Test
public void testPutHighBMP() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(2);
+ WritableMemory mem = WritableMemory.allocate(2);
StringBuilder sb = new StringBuilder();
sb.append("\uE000");
try {
@@ -103,7 +103,7 @@ public class Utf8Test {
@Test
public void testPutExtendedAscii() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(1);
+ WritableMemory mem = WritableMemory.allocate(1);
StringBuilder sb = new StringBuilder();
sb.append("\u07FF");
try {
@@ -115,7 +115,7 @@ public class Utf8Test {
@Test
public void testPutOneAsciiToEmpty() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(0);
+ WritableMemory mem = WritableMemory.allocate(0);
StringBuilder sb = new StringBuilder();
sb.append("a");
try {
@@ -127,7 +127,7 @@ public class Utf8Test {
@Test
public void testPutValidSurrogatePair() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(4);
+ WritableMemory mem = WritableMemory.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MIN_LOW_SURROGATE);
@@ -218,7 +218,7 @@ public class Utf8Test {
rcp.fillCodePointArray(cpArr, 0, minPlane2CP);
String rcpStr = new String(cpArr, 0, numCP);
//println(rcpStr);
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(4 * numCP);
+ WritableMemory wmem = WritableMemory.allocate(4 * numCP);
int utf8Bytes = (int) wmem.putCharsToUtf8(0, rcpStr);
StringBuilder sb = new StringBuilder();
@@ -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;
- WritableMemoryImpl refMem = WritableMemoryImpl.writableWrap(refByteArr);
+ WritableMemory refMem = WritableMemory.writableWrap(refByteArr);
int decodedChars = refMem.getCharsFromUtf8(0, addBytes, sb);
String finalStr = sb.toString();
int finalChars = finalStr.toCharArray().length;
@@ -318,7 +318,7 @@ public class Utf8Test {
byte[] refByteArr = refStr.getBytes(UTF_8);
int refBytes = refByteArr.length;
int offset = 100;
- WritableMemoryImpl tgtMem = WritableMemoryImpl.allocate(refBytes + offset);
+ WritableMemory tgtMem = WritableMemory.allocate(refBytes + offset);
long bytesEncoded = tgtMem.putCharsToUtf8(offset, refStr);
assertEquals(bytesEncoded, refBytes);
}
@@ -370,7 +370,7 @@ public class Utf8Test {
}
@Test
- public void testInvalidBufferSlice() { //these are pure MemoryImpl bounds violations
+ public void testInvalidBufferSlice() { //these are pure Memory bounds violations
byte[] bytes = "The quick brown fox jumps over the lazy dog".getBytes(UTF_8);
assertInvalidSlice(bytes, bytes.length - 3, 4);
assertInvalidSlice(bytes, bytes.length, 1);
@@ -389,14 +389,14 @@ public class Utf8Test {
private static void assertInvalid(byte[] bytes) {
int bytesLen = bytes.length;
try {
- MemoryImpl.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
+ Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
fail();
} catch (Utf8CodingException e) {
// Expected.
}
try {
CharBuffer cb = CharBuffer.allocate(bytesLen);
- MemoryImpl.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
+ Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
fail();
} catch (Utf8CodingException | IOException e) {
// Expected.
@@ -405,7 +405,7 @@ public class Utf8Test {
private static void assertInvalidSlice(byte[] bytes, int index, int size) {
try {
- MemoryImpl mem = MemoryImpl.wrap(bytes);
+ Memory mem = Memory.wrap(bytes);
mem.getCharsFromUtf8(index, size, new StringBuilder());
fail();
} catch (IllegalArgumentException e) { //Pure bounds violation
@@ -436,17 +436,17 @@ public class Utf8Test {
if (utf8LengthBytes == -1) {
utf8LengthBytes = refByteArr.length;
}
- MemoryImpl refMem = MemoryImpl.wrap(refByteArr);
+ Memory refMem = Memory.wrap(refByteArr);
byte[] refByteArr2 = new byte[refByteArr.length + 1];
System.arraycopy(refByteArr, 0, refByteArr2, 1, refByteArr.length);
- MemoryImpl refReg = MemoryImpl.wrap(refByteArr2).region(1, refByteArr.length);
+ Memory refReg = Memory.wrap(refByteArr2).region(1, refByteArr.length);
- WritableMemoryImpl dstMem = WritableMemoryImpl.allocate(refByteArr.length);
- WritableMemoryImpl dstMem2 =
- WritableMemoryImpl.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
+ WritableMemory dstMem = WritableMemory.allocate(refByteArr.length);
+ WritableMemory dstMem2 =
+ WritableMemory.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
- // Test with MemoryImpl objects, where base offset != 0
+ // Test with Memory objects, where base offset != 0
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refMem, dstMem);
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refMem, dstMem2);
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refReg, dstMem);
@@ -454,7 +454,7 @@ public class Utf8Test {
}
private static void assertRoundTrips(String refStr, int refSubCharLen, int offsetBytes,
- int utf8LengthBytes, byte[] refByteArr, MemoryImpl refMem, WritableMemoryImpl dstMem)
+ int utf8LengthBytes, byte[] refByteArr, Memory refMem, WritableMemory dstMem)
throws IOException {
StringBuilder sb = new StringBuilder();
@@ -476,7 +476,7 @@ public class Utf8Test {
assertEquals(0, dstMem.compareTo(0, refByteArr.length, refMem, 0, refByteArr.length));
// Test write overflow
- WritableMemoryImpl writeMem2 = WritableMemoryImpl.allocate(refByteArr.length - 1);
+ WritableMemory writeMem2 = WritableMemory.allocate(refByteArr.length - 1);
try {
writeMem2.putCharsToUtf8(0, refStr);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
index fbc2962..144618f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
@@ -44,7 +44,7 @@ import java.nio.file.attribute.PosixFilePermissions;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -55,7 +55,7 @@ public class UtilTest {
@Test
public void checkBinarySearch() {
int k = 1024; //longs
- WritableMemoryImpl wMem = WritableMemoryImpl.allocate(k << 3); //1024 longs
+ WritableMemory wMem = WritableMemory.allocate(k << 3); //1024 longs
for (int i = 0; i < k; i++) { wMem.putLong(i << 3, i); }
long idx = Util.binarySearchLongs(wMem, 0, k - 1, k / 2);
long val = wMem.getLong(idx << 3);
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
index d29dff3..e93352b 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -36,11 +36,11 @@ public class WritableDirectCopyTest {
//Copy Within tests
@Test
- public void checkCopyWithinNativeSmall() {
+ public void checkCopyWithinNativeSmall() throws Exception {
int memCapacity = 64;
int half = memCapacity / 2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i = 0; i < half; i++) { //fill first half
@@ -56,13 +56,13 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeLarge() {
+ public void checkCopyWithinNativeLarge() throws Exception {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i = 0; i < halfLongs; i++) {
@@ -78,10 +78,10 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeOverlap() {
+ public void checkCopyWithinNativeOverlap() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
//println(mem.toHexString("Clear 64", 0, memCapacity));
@@ -94,10 +94,10 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeSrcBound() {
+ public void checkCopyWithinNativeSrcBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
} catch (IllegalArgumentException e) {
@@ -106,10 +106,10 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeDstBound() {
+ public void checkCopyWithinNativeDstBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
} catch (IllegalArgumentException e) {
@@ -118,13 +118,13 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeSmall() {
+ public void checkCopyCrossNativeSmall() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i = 0; i < memCapacity; i++) {
mem1.putByte(i, (byte) i);
@@ -141,14 +141,14 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeLarge() {
+ public void checkCopyCrossNativeLarge() throws Exception {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i = 0; i < memCapLongs; i++) {
mem1.putLong(i * 8, i);
@@ -164,16 +164,16 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeAndByteArray() {
+ public void checkCopyCrossNativeAndByteArray() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i = 0; i < 16; i++) {
@@ -184,21 +184,21 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossRegionsSameNative() {
+ public void checkCopyCrossRegionsSameNative() throws Exception {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- MemoryImpl reg1 = mem1.region(8, 16);
+ Memory reg1 = mem1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
- WritableMemoryImpl reg2 = mem1.writableRegion(24, 16);
+ WritableMemory reg2 = mem1.writableRegion(24, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
reg1.copyTo(0, reg2, 0, 16);
@@ -211,24 +211,24 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeArrayAndHierarchicalRegions() {
+ public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) { //fill with numbers
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
- MemoryImpl reg1 = mem1.region(8, 32);
- MemoryImpl reg1B = reg1.region(8, 16);
+ Memory reg1 = mem1.region(8, 32);
+ Memory reg1B = reg1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
//println(reg1B.toHexString("Reg1B", 0, (int)reg1B.getCapacity()));
- WritableMemoryImpl reg2 = mem2.writableRegion(32, 16);
+ WritableMemory reg2 = mem2.writableRegion(32, 16);
reg1B.copyTo(0, reg2, 0, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
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 e0765a9..ea49e69 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
@@ -27,10 +27,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -39,7 +39,7 @@ public class WritableMemoryTest {
@Test
public void wrapBigEndian() {
ByteBuffer bb = ByteBuffer.allocate(64); //big endian
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -47,50 +47,50 @@ public class WritableMemoryTest {
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as BE
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb, ByteOrder.LITTLE_ENDIAN);
+ WritableMemory wmem = WritableMemory.writableWrap(bb, ByteOrder.LITTLE_ENDIAN);
assertEquals(wmem.getChar(0), 256);
}
@Test
public void allocateWithByteOrder() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = WritableMemory.allocate(64, ByteOrder.BIG_ENDIAN);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- wmem = WritableMemoryImpl.allocate(64, ByteOrder.LITTLE_ENDIAN);
+ wmem = WritableMemory.allocate(64, ByteOrder.LITTLE_ENDIAN);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
@Test
public void checkGetArray() {
byte[] byteArr = new byte[64];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteArr);
+ WritableMemory wmem = WritableMemory.writableWrap(byteArr);
assertTrue(wmem.getArray() == byteArr);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
assertTrue(wbuf.getArray() == byteArr);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkSelfArrayCopy() {
byte[] srcAndDst = new byte[128];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcAndDst);
+ WritableMemory wmem = WritableMemory.writableWrap(srcAndDst);
wmem.getByteArray(0, srcAndDst, 64, 64); //non-overlapping
}
@Test
public void checkEquals() {
int len = 7;
- WritableMemoryImpl wmem1 = WritableMemoryImpl.allocate(len);
+ WritableMemory wmem1 = WritableMemory.allocate(len);
//@SuppressWarnings({"EqualsWithItself", "SelfEquals"}) //unsupported
//SelfEquals for Plexus, EqualsWithItself for IntelliJ
//boolean eq1 = wmem1.equals(wmem1); //strict profile complains
//assertTrue(eq1);
- WritableMemoryImpl wmem2 = WritableMemoryImpl.allocate(len + 1);
+ WritableMemory wmem2 = WritableMemory.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
- WritableMemoryImpl reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
+ WritableMemory reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
assertTrue(wmem1.equals(reg1));
- wmem2 = WritableMemoryImpl.allocate(len);
+ wmem2 = WritableMemory.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -102,8 +102,8 @@ public class WritableMemoryTest {
assertTrue(wmem1.equalTo(0, reg1, 0, len));
len = 24;
- wmem1 = WritableMemoryImpl.allocate(len);
- wmem2 = WritableMemoryImpl.allocate(len);
+ wmem1 = WritableMemory.allocate(len);
+ wmem2 = WritableMemory.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -120,14 +120,14 @@ public class WritableMemoryTest {
@Test
public void checkEquals2() {
int len = 23;
- WritableMemoryImpl wmem1 = WritableMemoryImpl.allocate(len);
+ WritableMemory wmem1 = WritableMemory.allocate(len);
assertFalse(wmem1.equals(null));
//@SuppressWarnings({"EqualsWithItself", "SelfEquals"}) //unsupported
//SelfEquals for Plexus, EqualsWithItself for IntelliJ
//boolean eq1 = wmem1.equals(wmem1); //strict profile complains
//assertTrue(eq1);
- WritableMemoryImpl wmem2 = WritableMemoryImpl.allocate(len + 1);
+ WritableMemory wmem2 = WritableMemory.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
for (int i = 0; i < len; i++) {
@@ -146,8 +146,8 @@ public class WritableMemoryTest {
byte[] bytes1 = new byte[(thresh * 2) + 7];
ThreadLocalRandom.current().nextBytes(bytes1);
byte[] bytes2 = bytes1.clone();
- MemoryImpl mem1 = MemoryImpl.wrap(bytes1);
- MemoryImpl mem2 = MemoryImpl.wrap(bytes2);
+ Memory mem1 = Memory.wrap(bytes1);
+ Memory mem2 = Memory.wrap(bytes2);
assertTrue(mem1.equals(mem2));
bytes2[thresh + 10] = (byte) (bytes1[thresh + 10] + 1);
@@ -160,11 +160,11 @@ public class WritableMemoryTest {
@Test
public void checkWrapWithBO() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(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 = WritableMemoryImpl.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
+ wmem = WritableMemory.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
nativeBO = wmem.getTypeByteOrder() == Util.nativeByteOrder;
assertFalse(nativeBO);
println("" + nativeBO);
@@ -173,11 +173,11 @@ public class WritableMemoryTest {
@Test
@SuppressWarnings("unused")
public void checkOwnerClientCase() {
- WritableMemoryImpl owner = WritableMemoryImpl.allocate(64);
- MemoryImpl client1 = owner; //Client1 cannot write (no API)
+ WritableMemory owner = WritableMemory.allocate(64);
+ Memory client1 = owner; //Client1 cannot write (no API)
owner.putInt(0, 1); //But owner can write
- ((WritableMemoryImpl)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
- MemoryImpl client2 = owner.region(0, owner.getCapacity()); //client2 cannot write (no API)
+ ((WritableMemory)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
+ Memory client2 = owner.region(0, owner.getCapacity()); //client2 cannot write (no API)
owner.putInt(0, 3); //But Owner should be able to write
}
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 6d1f6c1..76a2e59 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
@@ -21,7 +21,7 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -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; }
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(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 50f44c4..13e77ed 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
@@ -26,8 +26,8 @@ import static org.testng.Assert.assertTrue;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import net.openhft.hashing.LongHashFunction;
@@ -46,7 +46,7 @@ public class XxHash64Test {
long hash;
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(cap);
+ WritableMemory wmem = WritableMemory.allocate(cap);
for (int i = 0; i < cap; i++) { wmem.putByte(i, (byte)(-128 + i)); }
for (int offset = 0; offset < 16; offset++) {
@@ -65,7 +65,7 @@ public class XxHash64Test {
for (int j = 1; j < bytes; j++) {
byte[] in = new byte[bytes];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(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);
@@ -81,7 +81,7 @@ public class XxHash64Test {
*/
@Test
public void collisionTest() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(128);
+ WritableMemory wmem = WritableMemory.allocate(128);
wmem.putLong(0, 1);
wmem.putLong(16, 42);
wmem.putLong(32, 2);
@@ -100,7 +100,7 @@ public class XxHash64Test {
}
/**
- * This simple test compares the output of {@link BaseStateImpl#xxHash64(long, long, long)} with the
+ * This simple test compares the output of {@link BaseState#xxHash64(long, long, long)} with the
* output of {@link net.openhft.hashing.LongHashFunction}, that itself is tested against the
* reference implementation in C. This increase confidence that the xxHash function implemented
* in this package is in fact the same xxHash function implemented in C.
@@ -115,7 +115,7 @@ public class XxHash64Test {
byte[] bytes = new byte[len];
for (int i = 0; i < 10; i++) {
long zahXxHash = LongHashFunction.xx().hashBytes(bytes);
- long memoryXxHash = MemoryImpl.wrap(bytes).xxHash64(0, len, 0);
+ long memoryXxHash = Memory.wrap(bytes).xxHash64(0, len, 0);
assertEquals(memoryXxHash, zahXxHash);
random.nextBytes(bytes);
}
@@ -126,7 +126,7 @@ public class XxHash64Test {
@Test
public void testArrHashes() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(barr);
+ WritableMemory wmem = WritableMemory.writableWrap(barr);
long hash0 = wmem.xxHash64(8, 8, 0);
long hash1 = hashBytes(barr, 8, 8, 0);
assertEquals(hash1, hash0);
diff --git a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
index fea92ae..1c2c7b7 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -37,15 +37,15 @@ public class ZeroCapacityTest {
@SuppressWarnings({ "unused", "resource" })
@Test
public void checkZeroCapacity() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(0);
+ WritableMemory wmem = WritableMemory.allocate(0);
assertEquals(wmem.getCapacity(), 0);
- MemoryImpl mem1 = MemoryImpl.wrap(new byte[0]);
- MemoryImpl mem2 = MemoryImpl.wrap(ByteBuffer.allocate(0));
- MemoryImpl mem3 = MemoryImpl.wrap(ByteBuffer.allocateDirect(0));
- MemoryImpl reg = mem3.region(0, 0);
+ Memory mem1 = Memory.wrap(new byte[0]);
+ Memory mem2 = Memory.wrap(ByteBuffer.allocate(0));
+ Memory mem3 = Memory.wrap(ByteBuffer.allocateDirect(0));
+ Memory reg = mem3.region(0, 0);
try {
- WritableMemoryImpl.allocateDirect(0);
+ WritableMemory.allocateDirect(0);
Assert.fail();
} catch (IllegalArgumentException ignore) {
// expected
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 05/08: Interim. Completed refactoring of
Memory Hierarch.
Posted by le...@apache.org.
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 16511d00e97cbf60301c642787330a51f63d7b05
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Mon May 17 16:47:22 2021 -0700
Interim. Completed refactoring of Memory Hierarch.
Buffer hierarchy is not done. Many Errors in Test. Main compiles clean,
no warnings.
---
.../internal/{Memory.java => MemoryImpl.java} | 0
...moryImpl.java => NativeWritableMemoryImpl.java} | 0
.../memory/internal/WritableMemory.java | 666 ----------------
.../memory/internal/WritableMemoryImpl.java | 855 ++++++++++++++-------
4 files changed, 596 insertions(+), 925 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Memory.java b/src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
similarity index 100%
rename from src/main/java/org/apache/datasketches/memory/internal/Memory.java
rename to src/main/java/org/apache/datasketches/memory/internal/MemoryImpl.java
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
similarity index 100%
copy from src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
copy to src/main/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImpl.java
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java
deleted file mode 100644
index 85b8875..0000000
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMemory.java
+++ /dev/null
@@ -1,666 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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 org.apache.datasketches.memory.internal;
-
-import static org.apache.datasketches.memory.internal.Util.negativeCheck;
-import static org.apache.datasketches.memory.internal.Util.nullCheck;
-import static org.apache.datasketches.memory.internal.Util.zeroCheck;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-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
- * mentioned at the package level.
- *
- * @author Roman Leventov
- * @author Lee Rhodes
- */
-public abstract class WritableMemory extends Memory {
-
- //Pass-through ctor
- WritableMemory(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
- final long capacityBytes) {
- super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
- }
-
- //BYTE BUFFER
- /**
- * Accesses the given ByteBuffer for write operations. The returned WritableMemory object has
- * the same byte order, as the given ByteBuffer, unless the capacity of the given ByteBuffer is
- * zero, then byte order of the returned WritableMemory object, as well as backing storage and
- * read-only status are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param byteBuf the given ByteBuffer
- * @return a new WritableMemory for write operations on the given ByteBuffer.
- */
- public static WritableMemory writableWrap(final ByteBuffer byteBuf) {
- return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteBuf.order());
- }
-
- /**
- * Accesses the given ByteBuffer for write operations. The returned WritableMemory object has
- * the given byte order, ignoring the byte order of the given ByteBuffer. If the capacity of
- * the given ByteBuffer is zero the byte order of the returned WritableMemory object
- * (as well as backing storage) is unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param byteBuf the given ByteBuffer, must not be null
- * @param byteOrder the byte order to be used, which may be independent of the byte order
- * state of the given ByteBuffer
- * @return a new WritableMemory for write operations on the given ByteBuffer.
- */
- 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 WritableMemory for write operations
- * (including those > 2GB). Calling this method is equivalent to calling
- * {@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>.
- * @param file the given file to map
- * @return WritableMapHandle for managing the mapped Memory.
- * Please read Javadocs for {@link Handle}.
- * @throws IOException file not found or a RuntimeException.
- */
- public static WritableMapHandle writableMap(final File file) throws IOException {
- return WritableMemory.writableMap(file, 0, file.length(), Util.nativeByteOrder);
- }
-
- /**
- * Maps the specified portion of the given file into Memory for write operations
- * (including those > 2GB).
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.map(...)</i>.
- * @param file the given file to map. It may not be null.
- * @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 WritableMapHandleImpl for managing the mapped Memory.
- * Please read Javadocs for {@link Handle}.
- * @throws IOException file not found or RuntimeException, etc.
- */
- 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");
- negativeCheck(fileOffsetBytes, "File offset is negative");
- return BaseWritableMemoryImpl
- .wrapMap(file, fileOffsetBytes, capacityBytes, false, byteOrder);
- }
-
- //ALLOCATE DIRECT
- /**
- * Allocates and provides access to capacityBytes directly in native (off-heap) memory
- * leveraging the WritableMemory API. Native byte order is assumed.
- * The allocated memory will be 8-byte aligned, but may not be page aligned.
- * If capacityBytes is zero, byte order, backing storage and read-only status
- * of the WritableMemory object, returned from {@link WritableHandle#get()} are unspecified.
- *
- * <p>The default MemoryRequestServer, which allocates any request for memory onto the heap,
- * will be used.</p>
- *
- * <p><b>NOTE:</b> Native/Direct memory acquired using Unsafe may have garbage in it.
- * It is the responsibility of the using class to clear this memory, if required,
- * and to call <i>close()</i> when done.</p>
- *
- * @param capacityBytes the size of the desired memory in bytes.
- * @return WritableDirectHandleImpl for this off-heap resource.
- * Please read Javadocs for {@link Handle}.
- */
- public static WritableDirectHandle allocateDirect(final long capacityBytes) {
- return allocateDirect(capacityBytes, null);
- }
-
- /**
- * Allocates and provides access to capacityBytes directly in native (off-heap) memory
- * leveraging the WritableMemory API. The allocated memory will be 8-byte aligned, but may not
- * be page aligned. If capacityBytes is zero, byte order, backing storage and read-only status
- * of the WritableMemory object, returned from {@link WritableHandle#get()} are unspecified.
- *
- * <p><b>NOTE:</b> Native/Direct memory acquired using Unsafe may have garbage in it.
- * It is the responsibility of the using class to clear this memory, if required,
- * and to call <i>close()</i> when done.</p>
- *
- * @param capacityBytes the size of the desired memory in bytes.
- * @param memReqSvr A user-specified MemoryRequestServer.
- * This is a callback mechanism for a user client of direct memory to request more memory.
- * @return WritableHandle for this off-heap resource.
- * Please read Javadocs for {@link Handle}.
- */
- public static WritableDirectHandle allocateDirect(final long capacityBytes,
- final MemoryRequestServer memReqSvr) {
- return BaseWritableMemoryImpl.wrapDirect(capacityBytes, Util.nativeByteOrder, memReqSvr);
- }
-
- //REGIONS
- /**
- * A writable region is a writable view of this object.
- * This returns a new <i>WritableMemory</i> representing the defined writable region with the
- * given offsetBytes and capacityBytes.
- * <ul>
- * <li>Returned object's origin = this objects' origin + <i>offsetBytes</i></li>
- * <li>Returned object's capacity = <i>capacityBytes</i></li>
- * </ul>
- * If the given capacityBytes is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- *
- * @param offsetBytes the starting offset with respect to this object.
- * @param capacityBytes the capacity of the returned object in bytes.
- * @return a new <i>WritableMemory</i> representing the defined writable region.
- */
- public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes);
-
- /**
- * A writable region is a writable view of this object.
- * This returns a new <i>WritableMemory</i> representing the defined writable region with the
- * given offsetBytes, capacityBytes and byte order.
- * <ul>
- * <li>Returned object's origin = this objects' origin + <i>offsetBytes</i></li>
- * <li>Returned object's capacity = <i>capacityBytes</i></li>
- * <li>Returned object's byte order = <i>byteOrder</i></li>
- * </ul>
- * If the given capacityBytes is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- *
- * @param offsetBytes the starting offset with respect to this object.
- * @param capacityBytes the capacity of the returned object in bytes.
- * @param byteOrder the given byte order
- * @return a new <i>WritableMemory</i> representing the defined writable region.
- */
- public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes,
- ByteOrder byteOrder);
-
- //AS BUFFER
- /**
- * Returns a new <i>WritableBuffer</i> with a writable view of this object.
- * <ul>
- * <li>Returned object's origin = this object's origin</li>
- * <li>Returned object's <i>start</i> = 0</li>
- * <li>Returned object's <i>position</i> = 0</li>
- * <li>Returned object's <i>end</i> = this object's capacity</li>
- * <li>Returned object's <i>capacity</i> = this object's capacity</li>
- * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
- * </ul>
- * If this object's capacity is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @return a new <i>WritableBuffer</i> with a view of this WritableMemory
- */
- public abstract WritableBuffer asWritableBuffer();
-
- /**
- * Returns a new <i>WritableBuffer</i> with a writable view of this object
- * with the given byte order.
- * <ul>
- * <li>Returned object's origin = this object's origin</li>
- * <li>Returned object's <i>start</i> = 0</li>
- * <li>Returned object's <i>position</i> = 0</li>
- * <li>Returned object's <i>end</i> = this object's capacity</li>
- * <li>Returned object's <i>capacity</i> = this object's capacity</li>
- * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
- * </ul>
- * If this object's capacity is zero, the returned object is effectively immutable and
- * the backing storage and byte order are unspecified.
- * @param byteOrder the given byte order
- * @return a new <i>WritableBuffer</i> with a view of this WritableMemory
- */
- public abstract WritableBuffer asWritableBuffer(ByteOrder byteOrder);
-
- //ALLOCATE HEAP VIA AUTOMATIC BYTE ARRAY
- /**
- * Creates on-heap WritableMemory with the given capacity and the native byte order. If the given
- * capacityBytes is zero, backing storage, byte order and read-only status of the returned
- * WritableMemory object are unspecified.
- * @param capacityBytes the given capacity in bytes.
- * @return a new WritableMemory for write operations on a new byte array.
- */
- public static WritableMemory allocate(final int capacityBytes) {
- final byte[] arr = new byte[capacityBytes];
- return writableWrap(arr, Util.nativeByteOrder);
- }
-
- /**
- * Creates on-heap WritableMemory with the given capacity and the given byte order. If the given
- * capacityBytes is zero, backing storage, byte order and read-only status of the returned
- * WritableMemory object are unspecified.
- * @param capacityBytes the given capacity in bytes.
- * @param byteOrder the given byte order to allocate new Memory object with.
- * @return a new WritableMemory for write operations on a new byte array.
- */
- public static WritableMemory allocate(final int capacityBytes, final ByteOrder byteOrder) {
- final byte[] arr = new byte[capacityBytes];
- return writableWrap(arr, byteOrder);
- }
-
- //ACCESS PRIMITIVE HEAP ARRAYS for write
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final boolean[] arr) {
- final long lengthBytes = arr.length << Prim.BOOLEAN.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final byte[] arr) {
- return WritableMemory.writableWrap(arr, 0, arr.length, Util.nativeByteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations with the given byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @param byteOrder the byte order to be used
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final byte[] arr, final ByteOrder byteOrder) {
- return WritableMemory.writableWrap(arr, 0, arr.length, byteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations with the given byte order. If the given
- * lengthBytes is zero, backing storage, byte order and read-only status of the returned
- * WritableMemory object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @param offsetBytes the byte offset into the given array
- * @param lengthBytes the number of bytes to include from the given array
- * @param byteOrder the byte order to be used
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- 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);
- }
-
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final char[] arr) {
- final long lengthBytes = arr.length << Prim.CHAR.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final short[] arr) {
- final long lengthBytes = arr.length << Prim.SHORT.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final int[] arr) {
- final long lengthBytes = arr.length << Prim.INT.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final long[] arr) {
- final long lengthBytes = arr.length << Prim.LONG.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final float[] arr) {
- final long lengthBytes = arr.length << Prim.FLOAT.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
- }
-
- /**
- * Wraps the given primitive array for write operations assuming native byte order. If the array
- * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
- * object are unspecified.
- *
- * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
- * <i>WritableMemory.wrap(...)</i>.
- * @param arr the given primitive array.
- * @return a new WritableMemory for write operations on the given primitive array.
- */
- public static WritableMemory writableWrap(final double[] arr) {
- final long lengthBytes = arr.length << Prim.DOUBLE.shift();
- return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
- }
- //END OF CONSTRUCTOR-TYPE METHODS
-
- //PRIMITIVE putX() and putXArray()
- /**
- * Puts the boolean value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putBoolean(long offsetBytes, boolean value);
-
- /**
- * Puts the boolean array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetBooleans offset in array units
- * @param lengthBooleans number of array units to transfer
- */
- public abstract void putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffsetBooleans,
- int lengthBooleans);
-
- /**
- * Puts the byte value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putByte(long offsetBytes, byte value);
-
- /**
- * Puts the byte array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetBytes offset in array units
- * @param lengthBytes number of array units to transfer
- */
- public abstract void putByteArray(long offsetBytes, byte[] srcArray, int srcOffsetBytes,
- int lengthBytes);
-
- /**
- * Puts the char value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putChar(long offsetBytes, char value);
-
- /**
- * Puts the char array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetChars offset in array units
- * @param lengthChars number of array units to transfer
- */
- public abstract void putCharArray(long offsetBytes, char[] srcArray, int srcOffsetChars,
- int lengthChars);
-
- /**
- * Encodes characters from the given CharSequence into UTF-8 bytes and puts them into this
- * <i>WritableMemory</i> begining at the given offsetBytes.
- * This is specifically designed to reduce the production of intermediate objects (garbage),
- * thus significantly reducing pressure on the JVM Garbage Collector.
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param src The source CharSequence to be encoded and put into this WritableMemory. It is
- * the responsibility of the caller to provide sufficient capacity in this
- * <i>WritableMemory</i> for the encoded Utf8 bytes. Characters outside the ASCII range can
- * require 2, 3 or 4 bytes per character to encode.
- * @return the number of bytes encoded
- */
- public abstract long putCharsToUtf8(long offsetBytes, CharSequence src);
-
- /**
- * Puts the double value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putDouble(long offsetBytes, double value);
-
- /**
- * Puts the double array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetDoubles offset in array units
- * @param lengthDoubles number of array units to transfer
- */
- public abstract void putDoubleArray(long offsetBytes, double[] srcArray,
- final int srcOffsetDoubles, final int lengthDoubles);
-
- /**
- * Puts the float value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putFloat(long offsetBytes, float value);
-
- /**
- * Puts the float array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetFloats offset in array units
- * @param lengthFloats number of array units to transfer
- */
- public abstract void putFloatArray(long offsetBytes, float[] srcArray,
- final int srcOffsetFloats, final int lengthFloats);
-
- /**
- * Puts the int value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putInt(long offsetBytes, int value);
-
- /**
- * Puts the int array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetInts offset in array units
- * @param lengthInts number of array units to transfer
- */
- public abstract void putIntArray(long offsetBytes, int[] srcArray,
- final int srcOffsetInts, final int lengthInts);
-
- /**
- * Puts the long value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putLong(long offsetBytes, long value);
-
- /**
- * Puts the long array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetLongs offset in array units
- * @param lengthLongs number of array units to transfer
- */
- public abstract void putLongArray(long offsetBytes, long[] srcArray,
- final int srcOffsetLongs, final int lengthLongs);
-
- /**
- * Puts the short value at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param value the value to put
- */
- public abstract void putShort(long offsetBytes, short value);
-
- /**
- * Puts the short array at the given offset
- * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
- * @param srcArray The source array.
- * @param srcOffsetShorts offset in array units
- * @param lengthShorts number of array units to transfer
- */
- public abstract void putShortArray(long offsetBytes, short[] srcArray,
- final int srcOffsetShorts, final int lengthShorts);
-
- //Atomic Methods
- /**
- * Atomically adds the given value to the long located at offsetBytes.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param delta the amount to add
- * @return the the previous value
- */
- public abstract long getAndAddLong(long offsetBytes, long delta);
-
- /**
- * Atomically sets the current value at the memory location to the given updated value
- * if and only if the current value {@code ==} the expected value.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param expect the expected value
- * @param update the new value
- * @return {@code true} if successful. False return indicates that
- * the current value at the memory location was not equal to the expected value.
- */
- public abstract boolean compareAndSwapLong(long offsetBytes, long expect, long update);
-
- /**
- * Atomically exchanges the given value with the current value located at offsetBytes.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param newValue new value
- * @return the previous value
- */
- public abstract long getAndSetLong(long offsetBytes, long newValue);
-
- //OTHER WRITE METHODS
- /**
- * Returns the primitive backing array, otherwise null.
- * @return the primitive backing array, otherwise null.
- */
- public abstract Object getArray();
-
- /**
- * Clears all bytes of this Memory to zero
- */
- public abstract void clear();
-
- /**
- * Clears a portion of this Memory to zero.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param lengthBytes the length in bytes
- */
- public abstract void clear(long offsetBytes, long lengthBytes);
-
- /**
- * Clears the bits defined by the bitMask
- * @param offsetBytes offset bytes relative to this Memory start.
- * @param bitMask the bits set to one will be cleared
- */
- public abstract void clearBits(long offsetBytes, byte bitMask);
-
- /**
- * Fills all bytes of this Memory region to the given byte value.
- * @param value the given byte value
- */
- public abstract void fill(byte value);
-
- /**
- * Fills a portion of this Memory region to the given byte value.
- * @param offsetBytes offset bytes relative to this Memory start
- * @param lengthBytes the length in bytes
- * @param value the given byte value
- */
- public abstract void fill(long offsetBytes, long lengthBytes, byte value);
-
- /**
- * Sets the bits defined by the bitMask
- * @param offsetBytes offset bytes relative to this Memory start
- * @param bitMask the bits set to one will be set
- */
- public abstract void setBits(long offsetBytes, byte bitMask);
-
-
- //OTHER WRITABLE API METHODS
- /**
- * For Direct Memory only. Other types of backing resources will return null.
- * Gets the MemoryRequestServer object used by dynamic off-heap (Direct) memory objects
- * to request additional memory.
- * Set using {@link WritableMemory#allocateDirect(long, MemoryRequestServer)}.
- * If not explicity set, this returns the {@link DefaultMemoryRequestServer}.
- * @return the MemoryRequestServer object (if direct memory) or null.
- */
- @Override
- public MemoryRequestServer getMemoryRequestServer() {
- return null;
- }
-
-}
diff --git a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
index 7c416b0..85b8875 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/WritableMemoryImpl.java
@@ -19,311 +19,648 @@
package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_CHAR_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_FLOAT_INDEX_SCALE;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_INT_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_LONG_INDEX_SCALE;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_SHORT_BASE_OFFSET;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.CHAR_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.DOUBLE_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.FLOAT_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.INT_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.LONG_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.SHORT_SHIFT;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.checkBounds;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.unsafe;
+import static org.apache.datasketches.memory.internal.Util.negativeCheck;
+import static org.apache.datasketches.memory.internal.Util.nullCheck;
+import static org.apache.datasketches.memory.internal.Util.zeroCheck;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+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;
-/*
- * Developer notes: The heavier methods, such as put/get arrays, duplicate, region, clear, fill,
- * compareTo, etc., use hard checks (checkValid*() and checkBounds()), which execute at runtime and
- * throw exceptions if violated. The cost of the runtime checks are minor compared to the rest of
- * the work these methods are doing.
- *
- * <p>The light weight methods, such as put/get primitives, use asserts (assertValid*()), which only
- * execute when asserts are enabled and JIT will remove them entirely from production runtime code.
- * The light weight methods will simplify to a single unsafe call, which is further simplified by
- * JIT to an intrinsic that is often a single CPU instruction.
- */
/**
- * Implementation of {@link WritableMemory} for native endian byte order. Non-native variant is
- * {@link NonNativeWritableMemoryImpl}.
+ * Provides read and write primitive and primitive array access to any of the four resources
+ * mentioned at the package level.
+ *
* @author Roman Leventov
* @author Lee Rhodes
*/
-@SuppressWarnings({"restriction"})
-abstract class WritableMemoryImpl extends BaseWritableMemoryImpl {
+public abstract class WritableMemory extends Memory {
//Pass-through ctor
- WritableMemoryImpl(final Object unsafeObj, final long nativeBaseOffset,
- final long regionOffset, final long capacityBytes) {
+ WritableMemory(final Object unsafeObj, final long nativeBaseOffset, final long regionOffset,
+ final long capacityBytes) {
super(unsafeObj, nativeBaseOffset, regionOffset, capacityBytes);
}
- ///PRIMITIVE getX() and getXArray()
- @Override
- public char getChar(final long offsetBytes) {
- return getNativeOrderedChar(offsetBytes);
- }
-
- @Override
- public void getCharArray(final long offsetBytes, final char[] dstArray, final int dstOffsetChars,
- final int lengthChars) {
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- checkValidAndBounds(offsetBytes, copyBytes);
- checkBounds(dstOffsetChars, lengthChars, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- dstArray,
- ARRAY_CHAR_BASE_OFFSET + (((long) dstOffsetChars) << CHAR_SHIFT),
- copyBytes);
- }
-
- @Override
- public double getDouble(final long offsetBytes) {
- assertValidAndBoundsForRead(offsetBytes, ARRAY_DOUBLE_INDEX_SCALE);
- return unsafe.getDouble(getUnsafeObject(), getCumulativeOffset(offsetBytes));
- }
-
- @Override
- public void getDoubleArray(final long offsetBytes, final double[] dstArray,
- final int dstOffsetDoubles, final int lengthDoubles) {
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- checkValidAndBounds(offsetBytes, copyBytes);
- checkBounds(dstOffsetDoubles, lengthDoubles, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- dstArray,
- ARRAY_DOUBLE_BASE_OFFSET + (((long) dstOffsetDoubles) << DOUBLE_SHIFT),
- copyBytes);
- }
-
- @Override
- public float getFloat(final long offsetBytes) {
- assertValidAndBoundsForRead(offsetBytes, ARRAY_FLOAT_INDEX_SCALE);
- return unsafe.getFloat(getUnsafeObject(), getCumulativeOffset(offsetBytes));
- }
-
- @Override
- public void getFloatArray(final long offsetBytes, final float[] dstArray,
- final int dstOffsetFloats, final int lengthFloats) {
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- checkValidAndBounds(offsetBytes, copyBytes);
- checkBounds(dstOffsetFloats, lengthFloats, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- dstArray,
- ARRAY_FLOAT_BASE_OFFSET + (((long) dstOffsetFloats) << FLOAT_SHIFT),
- copyBytes);
- }
-
- @Override
- public int getInt(final long offsetBytes) {
- return getNativeOrderedInt(offsetBytes);
- }
-
- @Override
- public void getIntArray(final long offsetBytes, final int[] dstArray, final int dstOffsetInts,
- final int lengthInts) {
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- checkValidAndBounds(offsetBytes, copyBytes);
- checkBounds(dstOffsetInts, lengthInts, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- dstArray,
- ARRAY_INT_BASE_OFFSET + (((long) dstOffsetInts) << INT_SHIFT),
- copyBytes);
+ //BYTE BUFFER
+ /**
+ * Accesses the given ByteBuffer for write operations. The returned WritableMemory object has
+ * the same byte order, as the given ByteBuffer, unless the capacity of the given ByteBuffer is
+ * zero, then byte order of the returned WritableMemory object, as well as backing storage and
+ * read-only status are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param byteBuf the given ByteBuffer
+ * @return a new WritableMemory for write operations on the given ByteBuffer.
+ */
+ public static WritableMemory writableWrap(final ByteBuffer byteBuf) {
+ return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteBuf.order());
}
- @Override
- public long getLong(final long offsetBytes) {
- return getNativeOrderedLong(offsetBytes);
+ /**
+ * Accesses the given ByteBuffer for write operations. The returned WritableMemory object has
+ * the given byte order, ignoring the byte order of the given ByteBuffer. If the capacity of
+ * the given ByteBuffer is zero the byte order of the returned WritableMemory object
+ * (as well as backing storage) is unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param byteBuf the given ByteBuffer, must not be null
+ * @param byteOrder the byte order to be used, which may be independent of the byte order
+ * state of the given ByteBuffer
+ * @return a new WritableMemory for write operations on the given ByteBuffer.
+ */
+ public static WritableMemory writableWrap(final ByteBuffer byteBuf, final ByteOrder byteOrder) {
+ return BaseWritableMemoryImpl.wrapByteBuffer(byteBuf, false, byteOrder);
}
- @Override
- public void getLongArray(final long offsetBytes, final long[] dstArray,
- final int dstOffsetLongs, final int lengthLongs) {
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- checkValidAndBounds(offsetBytes, copyBytes);
- checkBounds(dstOffsetLongs, lengthLongs, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- dstArray,
- ARRAY_LONG_BASE_OFFSET + (((long) dstOffsetLongs) << LONG_SHIFT),
- copyBytes);
+ //MAP
+ /**
+ * Maps the entire given file into native-ordered WritableMemory for write operations
+ * (including those > 2GB). Calling this method is equivalent to calling
+ * {@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>.
+ * @param file the given file to map
+ * @return WritableMapHandle for managing the mapped Memory.
+ * Please read Javadocs for {@link Handle}.
+ * @throws IOException file not found or a RuntimeException.
+ */
+ public static WritableMapHandle writableMap(final File file) throws IOException {
+ return WritableMemory.writableMap(file, 0, file.length(), Util.nativeByteOrder);
}
- @Override
- public short getShort(final long offsetBytes) {
- return getNativeOrderedShort(offsetBytes);
+ /**
+ * Maps the specified portion of the given file into Memory for write operations
+ * (including those > 2GB).
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.map(...)</i>.
+ * @param file the given file to map. It may not be null.
+ * @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 WritableMapHandleImpl for managing the mapped Memory.
+ * Please read Javadocs for {@link Handle}.
+ * @throws IOException file not found or RuntimeException, etc.
+ */
+ 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");
+ negativeCheck(fileOffsetBytes, "File offset is negative");
+ return BaseWritableMemoryImpl
+ .wrapMap(file, fileOffsetBytes, capacityBytes, false, byteOrder);
}
- @Override
- public void getShortArray(final long offsetBytes, final short[] dstArray,
- final int dstOffsetShorts, final int lengthShorts) {
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- checkValidAndBounds(offsetBytes, copyBytes);
- checkBounds(dstOffsetShorts, lengthShorts, dstArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- dstArray,
- ARRAY_SHORT_BASE_OFFSET + (((long) dstOffsetShorts) << SHORT_SHIFT),
- copyBytes);
+ //ALLOCATE DIRECT
+ /**
+ * Allocates and provides access to capacityBytes directly in native (off-heap) memory
+ * leveraging the WritableMemory API. Native byte order is assumed.
+ * The allocated memory will be 8-byte aligned, but may not be page aligned.
+ * If capacityBytes is zero, byte order, backing storage and read-only status
+ * of the WritableMemory object, returned from {@link WritableHandle#get()} are unspecified.
+ *
+ * <p>The default MemoryRequestServer, which allocates any request for memory onto the heap,
+ * will be used.</p>
+ *
+ * <p><b>NOTE:</b> Native/Direct memory acquired using Unsafe may have garbage in it.
+ * It is the responsibility of the using class to clear this memory, if required,
+ * and to call <i>close()</i> when done.</p>
+ *
+ * @param capacityBytes the size of the desired memory in bytes.
+ * @return WritableDirectHandleImpl for this off-heap resource.
+ * Please read Javadocs for {@link Handle}.
+ */
+ public static WritableDirectHandle allocateDirect(final long capacityBytes) {
+ return allocateDirect(capacityBytes, null);
}
- //PRIMITIVE putX() and putXArray() implementations
- @Override
- public void putChar(final long offsetBytes, final char value) {
- putNativeOrderedChar(offsetBytes, value);
+ /**
+ * Allocates and provides access to capacityBytes directly in native (off-heap) memory
+ * leveraging the WritableMemory API. The allocated memory will be 8-byte aligned, but may not
+ * be page aligned. If capacityBytes is zero, byte order, backing storage and read-only status
+ * of the WritableMemory object, returned from {@link WritableHandle#get()} are unspecified.
+ *
+ * <p><b>NOTE:</b> Native/Direct memory acquired using Unsafe may have garbage in it.
+ * It is the responsibility of the using class to clear this memory, if required,
+ * and to call <i>close()</i> when done.</p>
+ *
+ * @param capacityBytes the size of the desired memory in bytes.
+ * @param memReqSvr A user-specified MemoryRequestServer.
+ * This is a callback mechanism for a user client of direct memory to request more memory.
+ * @return WritableHandle for this off-heap resource.
+ * Please read Javadocs for {@link Handle}.
+ */
+ public static WritableDirectHandle allocateDirect(final long capacityBytes,
+ final MemoryRequestServer memReqSvr) {
+ return BaseWritableMemoryImpl.wrapDirect(capacityBytes, Util.nativeByteOrder, memReqSvr);
}
- @Override
- public void putCharArray(final long offsetBytes, final char[] srcArray,
- final int srcOffsetChars, final int lengthChars) {
- final long copyBytes = ((long) lengthChars) << CHAR_SHIFT;
- checkValidAndBoundsForWrite(offsetBytes, copyBytes);
- checkBounds(srcOffsetChars, lengthChars, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_CHAR_BASE_OFFSET + (((long) srcOffsetChars) << CHAR_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- copyBytes
- );
+ //REGIONS
+ /**
+ * A writable region is a writable view of this object.
+ * This returns a new <i>WritableMemory</i> representing the defined writable region with the
+ * given offsetBytes and capacityBytes.
+ * <ul>
+ * <li>Returned object's origin = this objects' origin + <i>offsetBytes</i></li>
+ * <li>Returned object's capacity = <i>capacityBytes</i></li>
+ * </ul>
+ * If the given capacityBytes is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ *
+ * @param offsetBytes the starting offset with respect to this object.
+ * @param capacityBytes the capacity of the returned object in bytes.
+ * @return a new <i>WritableMemory</i> representing the defined writable region.
+ */
+ public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes);
+
+ /**
+ * A writable region is a writable view of this object.
+ * This returns a new <i>WritableMemory</i> representing the defined writable region with the
+ * given offsetBytes, capacityBytes and byte order.
+ * <ul>
+ * <li>Returned object's origin = this objects' origin + <i>offsetBytes</i></li>
+ * <li>Returned object's capacity = <i>capacityBytes</i></li>
+ * <li>Returned object's byte order = <i>byteOrder</i></li>
+ * </ul>
+ * If the given capacityBytes is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ *
+ * @param offsetBytes the starting offset with respect to this object.
+ * @param capacityBytes the capacity of the returned object in bytes.
+ * @param byteOrder the given byte order
+ * @return a new <i>WritableMemory</i> representing the defined writable region.
+ */
+ public abstract WritableMemory writableRegion(long offsetBytes, long capacityBytes,
+ ByteOrder byteOrder);
+
+ //AS BUFFER
+ /**
+ * Returns a new <i>WritableBuffer</i> with a writable view of this object.
+ * <ul>
+ * <li>Returned object's origin = this object's origin</li>
+ * <li>Returned object's <i>start</i> = 0</li>
+ * <li>Returned object's <i>position</i> = 0</li>
+ * <li>Returned object's <i>end</i> = this object's capacity</li>
+ * <li>Returned object's <i>capacity</i> = this object's capacity</li>
+ * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
+ * </ul>
+ * If this object's capacity is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ * @return a new <i>WritableBuffer</i> with a view of this WritableMemory
+ */
+ public abstract WritableBuffer asWritableBuffer();
+
+ /**
+ * Returns a new <i>WritableBuffer</i> with a writable view of this object
+ * with the given byte order.
+ * <ul>
+ * <li>Returned object's origin = this object's origin</li>
+ * <li>Returned object's <i>start</i> = 0</li>
+ * <li>Returned object's <i>position</i> = 0</li>
+ * <li>Returned object's <i>end</i> = this object's capacity</li>
+ * <li>Returned object's <i>capacity</i> = this object's capacity</li>
+ * <li>Returned object's <i>start</i>, <i>position</i> and <i>end</i> are mutable</li>
+ * </ul>
+ * If this object's capacity is zero, the returned object is effectively immutable and
+ * the backing storage and byte order are unspecified.
+ * @param byteOrder the given byte order
+ * @return a new <i>WritableBuffer</i> with a view of this WritableMemory
+ */
+ public abstract WritableBuffer asWritableBuffer(ByteOrder byteOrder);
+
+ //ALLOCATE HEAP VIA AUTOMATIC BYTE ARRAY
+ /**
+ * Creates on-heap WritableMemory with the given capacity and the native byte order. If the given
+ * capacityBytes is zero, backing storage, byte order and read-only status of the returned
+ * WritableMemory object are unspecified.
+ * @param capacityBytes the given capacity in bytes.
+ * @return a new WritableMemory for write operations on a new byte array.
+ */
+ public static WritableMemory allocate(final int capacityBytes) {
+ final byte[] arr = new byte[capacityBytes];
+ return writableWrap(arr, Util.nativeByteOrder);
}
- @Override
- public void putDouble(final long offsetBytes, final double value) {
- assertValidAndBoundsForWrite(offsetBytes, ARRAY_DOUBLE_INDEX_SCALE);
- unsafe.putDouble(getUnsafeObject(), getCumulativeOffset(offsetBytes), value);
+ /**
+ * Creates on-heap WritableMemory with the given capacity and the given byte order. If the given
+ * capacityBytes is zero, backing storage, byte order and read-only status of the returned
+ * WritableMemory object are unspecified.
+ * @param capacityBytes the given capacity in bytes.
+ * @param byteOrder the given byte order to allocate new Memory object with.
+ * @return a new WritableMemory for write operations on a new byte array.
+ */
+ public static WritableMemory allocate(final int capacityBytes, final ByteOrder byteOrder) {
+ final byte[] arr = new byte[capacityBytes];
+ return writableWrap(arr, byteOrder);
}
- @Override
- public void putDoubleArray(final long offsetBytes, final double[] srcArray,
- final int srcOffsetDoubles, final int lengthDoubles) {
- final long copyBytes = ((long) lengthDoubles) << DOUBLE_SHIFT;
- checkValidAndBoundsForWrite(offsetBytes, copyBytes);
- checkBounds(srcOffsetDoubles, lengthDoubles, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_DOUBLE_BASE_OFFSET + (((long) srcOffsetDoubles) << DOUBLE_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- copyBytes
- );
+ //ACCESS PRIMITIVE HEAP ARRAYS for write
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final boolean[] arr) {
+ final long lengthBytes = arr.length << Prim.BOOLEAN.shift();
+ return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- @Override
- public void putFloat(final long offsetBytes, final float value) {
- assertValidAndBoundsForWrite(offsetBytes, ARRAY_FLOAT_INDEX_SCALE);
- unsafe.putFloat(getUnsafeObject(), getCumulativeOffset(offsetBytes), value);
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final byte[] arr) {
+ return WritableMemory.writableWrap(arr, 0, arr.length, Util.nativeByteOrder);
}
- @Override
- public void putFloatArray(final long offsetBytes, final float[] srcArray,
- final int srcOffsetFloats, final int lengthFloats) {
- final long copyBytes = ((long) lengthFloats) << FLOAT_SHIFT;
- checkValidAndBoundsForWrite(offsetBytes, copyBytes);
- checkBounds(srcOffsetFloats, lengthFloats, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_FLOAT_BASE_OFFSET + (((long) srcOffsetFloats) << FLOAT_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- copyBytes
- );
+ /**
+ * Wraps the given primitive array for write operations with the given byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @param byteOrder the byte order to be used
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final byte[] arr, final ByteOrder byteOrder) {
+ return WritableMemory.writableWrap(arr, 0, arr.length, byteOrder);
}
- @Override
- public void putInt(final long offsetBytes, final int value) {
- putNativeOrderedInt(offsetBytes, value);
- }
-
- @Override
- public void putIntArray(final long offsetBytes, final int[] srcArray, final int srcOffsetInts,
- final int lengthInts) {
- final long copyBytes = ((long) lengthInts) << INT_SHIFT;
- checkValidAndBoundsForWrite(offsetBytes, copyBytes);
- checkBounds(srcOffsetInts, lengthInts, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_INT_BASE_OFFSET + (((long) srcOffsetInts) << INT_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- copyBytes
- );
+ /**
+ * Wraps the given primitive array for write operations with the given byte order. If the given
+ * lengthBytes is zero, backing storage, byte order and read-only status of the returned
+ * WritableMemory object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @param offsetBytes the byte offset into the given array
+ * @param lengthBytes the number of bytes to include from the given array
+ * @param byteOrder the byte order to be used
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ 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);
}
- @Override
- public void putLong(final long offsetBytes, final long value) {
- putNativeOrderedLong(offsetBytes, value);
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final char[] arr) {
+ final long lengthBytes = arr.length << Prim.CHAR.shift();
+ return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- @Override
- public void putLongArray(final long offsetBytes, final long[] srcArray, final int srcOffsetLongs,
- final int lengthLongs) {
- final long copyBytes = ((long) lengthLongs) << LONG_SHIFT;
- checkValidAndBoundsForWrite(offsetBytes, copyBytes);
- checkBounds(srcOffsetLongs, lengthLongs, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_LONG_BASE_OFFSET + (((long) srcOffsetLongs) << LONG_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- copyBytes
- );
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final short[] arr) {
+ final long lengthBytes = arr.length << Prim.SHORT.shift();
+ return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- @Override
- public void putShort(final long offsetBytes, final short value) {
- putNativeOrderedShort(offsetBytes, value);
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final int[] arr) {
+ final long lengthBytes = arr.length << Prim.INT.shift();
+ return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- @Override
- public void putShortArray(final long offsetBytes, final short[] srcArray,
- final int srcOffsetShorts, final int lengthShorts) {
- final long copyBytes = ((long) lengthShorts) << SHORT_SHIFT;
- checkValidAndBoundsForWrite(offsetBytes, copyBytes);
- checkBounds(srcOffsetShorts, lengthShorts, srcArray.length);
- CompareAndCopy.copyMemoryCheckingDifferentObject(
- srcArray,
- ARRAY_SHORT_BASE_OFFSET + (((long) srcOffsetShorts) << SHORT_SHIFT),
- getUnsafeObject(),
- getCumulativeOffset(offsetBytes),
- copyBytes
- );
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final long[] arr) {
+ final long lengthBytes = arr.length << Prim.LONG.shift();
+ return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- //Atomic Write Methods
- @Override
- public long getAndAddLong(final long offsetBytes, final long delta) { //JDK 8+
- assertValidAndBoundsForWrite(offsetBytes, ARRAY_LONG_INDEX_SCALE);
- final long addr = getCumulativeOffset(offsetBytes);
- return unsafe.getAndAddLong(getUnsafeObject(), addr, delta);
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final float[] arr) {
+ final long lengthBytes = arr.length << Prim.FLOAT.shift();
+ return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
- @Override
- public long getAndSetLong(final long offsetBytes, final long newValue) { //JDK 8+
- assertValidAndBoundsForWrite(offsetBytes, ARRAY_LONG_INDEX_SCALE);
- final long addr = getCumulativeOffset(offsetBytes);
- return unsafe.getAndSetLong(getUnsafeObject(), addr, newValue);
+ /**
+ * Wraps the given primitive array for write operations assuming native byte order. If the array
+ * size is zero, backing storage, byte order and read-only status of the returned WritableMemory
+ * object are unspecified.
+ *
+ * <p><b>Note:</b> Always qualify this method with the class name, e.g.,
+ * <i>WritableMemory.wrap(...)</i>.
+ * @param arr the given primitive array.
+ * @return a new WritableMemory for write operations on the given primitive array.
+ */
+ public static WritableMemory writableWrap(final double[] arr) {
+ final long lengthBytes = arr.length << Prim.DOUBLE.shift();
+ return BaseWritableMemoryImpl.wrapHeapArray(arr, 0L, lengthBytes, false, Util.nativeByteOrder);
}
-
+ //END OF CONSTRUCTOR-TYPE METHODS
+
+ //PRIMITIVE putX() and putXArray()
+ /**
+ * Puts the boolean value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putBoolean(long offsetBytes, boolean value);
+
+ /**
+ * Puts the boolean array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetBooleans offset in array units
+ * @param lengthBooleans number of array units to transfer
+ */
+ public abstract void putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffsetBooleans,
+ int lengthBooleans);
+
+ /**
+ * Puts the byte value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putByte(long offsetBytes, byte value);
+
+ /**
+ * Puts the byte array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetBytes offset in array units
+ * @param lengthBytes number of array units to transfer
+ */
+ public abstract void putByteArray(long offsetBytes, byte[] srcArray, int srcOffsetBytes,
+ int lengthBytes);
+
+ /**
+ * Puts the char value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putChar(long offsetBytes, char value);
+
+ /**
+ * Puts the char array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetChars offset in array units
+ * @param lengthChars number of array units to transfer
+ */
+ public abstract void putCharArray(long offsetBytes, char[] srcArray, int srcOffsetChars,
+ int lengthChars);
+
+ /**
+ * Encodes characters from the given CharSequence into UTF-8 bytes and puts them into this
+ * <i>WritableMemory</i> begining at the given offsetBytes.
+ * This is specifically designed to reduce the production of intermediate objects (garbage),
+ * thus significantly reducing pressure on the JVM Garbage Collector.
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param src The source CharSequence to be encoded and put into this WritableMemory. It is
+ * the responsibility of the caller to provide sufficient capacity in this
+ * <i>WritableMemory</i> for the encoded Utf8 bytes. Characters outside the ASCII range can
+ * require 2, 3 or 4 bytes per character to encode.
+ * @return the number of bytes encoded
+ */
+ public abstract long putCharsToUtf8(long offsetBytes, CharSequence src);
+
+ /**
+ * Puts the double value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putDouble(long offsetBytes, double value);
+
+ /**
+ * Puts the double array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetDoubles offset in array units
+ * @param lengthDoubles number of array units to transfer
+ */
+ public abstract void putDoubleArray(long offsetBytes, double[] srcArray,
+ final int srcOffsetDoubles, final int lengthDoubles);
+
+ /**
+ * Puts the float value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putFloat(long offsetBytes, float value);
+
+ /**
+ * Puts the float array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetFloats offset in array units
+ * @param lengthFloats number of array units to transfer
+ */
+ public abstract void putFloatArray(long offsetBytes, float[] srcArray,
+ final int srcOffsetFloats, final int lengthFloats);
+
+ /**
+ * Puts the int value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putInt(long offsetBytes, int value);
+
+ /**
+ * Puts the int array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetInts offset in array units
+ * @param lengthInts number of array units to transfer
+ */
+ public abstract void putIntArray(long offsetBytes, int[] srcArray,
+ final int srcOffsetInts, final int lengthInts);
+
+ /**
+ * Puts the long value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putLong(long offsetBytes, long value);
+
+ /**
+ * Puts the long array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetLongs offset in array units
+ * @param lengthLongs number of array units to transfer
+ */
+ public abstract void putLongArray(long offsetBytes, long[] srcArray,
+ final int srcOffsetLongs, final int lengthLongs);
+
+ /**
+ * Puts the short value at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param value the value to put
+ */
+ public abstract void putShort(long offsetBytes, short value);
+
+ /**
+ * Puts the short array at the given offset
+ * @param offsetBytes offset bytes relative to this <i>WritableMemory</i> start
+ * @param srcArray The source array.
+ * @param srcOffsetShorts offset in array units
+ * @param lengthShorts number of array units to transfer
+ */
+ public abstract void putShortArray(long offsetBytes, short[] srcArray,
+ final int srcOffsetShorts, final int lengthShorts);
+
+ //Atomic Methods
+ /**
+ * Atomically adds the given value to the long located at offsetBytes.
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param delta the amount to add
+ * @return the the previous value
+ */
+ public abstract long getAndAddLong(long offsetBytes, long delta);
+
+ /**
+ * Atomically sets the current value at the memory location to the given updated value
+ * if and only if the current value {@code ==} the expected value.
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param expect the expected value
+ * @param update the new value
+ * @return {@code true} if successful. False return indicates that
+ * the current value at the memory location was not equal to the expected value.
+ */
+ public abstract boolean compareAndSwapLong(long offsetBytes, long expect, long update);
+
+ /**
+ * Atomically exchanges the given value with the current value located at offsetBytes.
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param newValue new value
+ * @return the previous value
+ */
+ public abstract long getAndSetLong(long offsetBytes, long newValue);
+
+ //OTHER WRITE METHODS
+ /**
+ * Returns the primitive backing array, otherwise null.
+ * @return the primitive backing array, otherwise null.
+ */
+ public abstract Object getArray();
+
+ /**
+ * Clears all bytes of this Memory to zero
+ */
+ public abstract void clear();
+
+ /**
+ * Clears a portion of this Memory to zero.
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param lengthBytes the length in bytes
+ */
+ public abstract void clear(long offsetBytes, long lengthBytes);
+
+ /**
+ * Clears the bits defined by the bitMask
+ * @param offsetBytes offset bytes relative to this Memory start.
+ * @param bitMask the bits set to one will be cleared
+ */
+ public abstract void clearBits(long offsetBytes, byte bitMask);
+
+ /**
+ * Fills all bytes of this Memory region to the given byte value.
+ * @param value the given byte value
+ */
+ public abstract void fill(byte value);
+
+ /**
+ * Fills a portion of this Memory region to the given byte value.
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param lengthBytes the length in bytes
+ * @param value the given byte value
+ */
+ public abstract void fill(long offsetBytes, long lengthBytes, byte value);
+
+ /**
+ * Sets the bits defined by the bitMask
+ * @param offsetBytes offset bytes relative to this Memory start
+ * @param bitMask the bits set to one will be set
+ */
+ public abstract void setBits(long offsetBytes, byte bitMask);
+
+
+ //OTHER WRITABLE API METHODS
+ /**
+ * For Direct Memory only. Other types of backing resources will return null.
+ * Gets the MemoryRequestServer object used by dynamic off-heap (Direct) memory objects
+ * to request additional memory.
+ * Set using {@link WritableMemory#allocateDirect(long, MemoryRequestServer)}.
+ * If not explicity set, this returns the {@link DefaultMemoryRequestServer}.
+ * @return the MemoryRequestServer object (if direct memory) or null.
+ */
@Override
- public boolean compareAndSwapLong(final long offsetBytes, final long expect, final long update) {
- assertValidAndBoundsForWrite(offsetBytes, ARRAY_LONG_INDEX_SCALE);
- return unsafe.compareAndSwapLong(
- getUnsafeObject(), getCumulativeOffset(offsetBytes), expect, update);
+ public MemoryRequestServer getMemoryRequestServer() {
+ return null;
}
-
+
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org
[datasketches-memory] 03/08: Interim commit. All tests pass.
Posted by le...@apache.org.
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 <le...@users.noreply.github.com>
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: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org