a

* PyBuffer a = obj.getBuffer(PyBUF.SIMPLE);
@@ -253,11 +256,13 @@
      * ByteBuffer bb = a.getNIOBuffer();
      * 
+         * pair = parent.makePair();
+         * obj = pair.obj;
+         * 
+         * view = pair.view.getBufferSlice(flags, first, count, step);
+         * 
      * PyBuffer a = obj.getBuffer(PyBUF.SIMPLE);
@@ -259,18 +260,13 @@
      * the item with index k is in bb at positions
      * bb.pos()+k*itemsize to bb.pos()+(k+1)*itemsize - 1 inclusive. And
      * if itemsize==1, the item is simply the byte at position bb.pos()+k.
-     * The buffer limit is set to the first byte beyond the valid data. A block read or write will
-     * therefore access the contents sequentially. In a one-dimensional contiguous buffer (only) it
-     * is safe to rely on bb.remaining() to obtain the number of bytes representing the
-     * object state.
      * 
      * If the buffer is multidimensional or non-contiguous (strided), the buffer position is still
-     * the (first byte of) the item at index [0] or [0,...,0], and the
-     * limit is one item beyond the valid data. However, it is necessary to navigate bb
-     * using the shape, strides and maybe suboffsets provided
-     * by the API.
+     * the (first byte of) the item at index [0] or [0,...,0]. However, it
+     * is necessary to navigate bb using the shape, strides
+     * and maybe suboffsets provided by the API.
      *
-     * @return a ByteBuffer onto the exported data contents.
+     * @return a ByteBuffer onto the exported data contents.
      */
     ByteBuffer getNIOByteBuffer();
 
@@ -298,19 +294,18 @@
      */
     ByteBuffer getNIOByteBuffer(int... indices);
 
-    // Direct access to actual storage (deprecated)
-    //
-
     /**
-     * Determine whether the exporter is able to offer direct access to the exported storage as a
-     * Java byte array (through the API that involves class {@link Pointer}), or only supports the
+     * Report whether the exporter is able to offer direct access to the exported storage as a Java
+     * byte array (through the API that involves class {@link Pointer}), or only supports the
      * abstract API. See also {@link PyBUF#AS_ARRAY}.
      *
      * @return true if array access is supported, false if it is not.
      */
-    // XXX Pending: @Deprecated
     boolean hasArray();
 
+    // Direct access to actual storage (deprecated)
+    //
+
     /**
      * A class that references a byte[] array and a particular offset within it, as the
      * return type for methods that give direct access to byte-oriented data exported by a Python
@@ -410,7 +405,7 @@
      * free to navigate the underlying buffer b.storage without respecting these
      * boundaries. If the buffer is non-contiguous, the above description is still valid (since a
      * multi-byte item must itself be contiguously stored), but in any additional navigation of
-     * b.storage[] to other units, the client must use the shape, strides and
+     * b.storage[] to other items, the client must use the shape, strides and
      * sub-offsets provided by the API. Normally one starts b = a.getBuf() in order to
      * establish the offset of index [0,...,0].
      *

diff --git a/src/org/python/core/buffer/BaseArrayBuffer.java b/src/org/python/core/buffer/BaseArrayBuffer.java
new file mode 100644
--- /dev/null
+++ b/src/org/python/core/buffer/BaseArrayBuffer.java
@@ -0,0 +1,279 @@
+package org.python.core.buffer;
+
+import java.nio.ByteBuffer;
+
+import org.python.core.PyBUF;
+import org.python.core.PyBuffer;
+import org.python.core.PyException;
+
+/**
+ * Base implementation of the Buffer API for when the storage implementation is byte[].
+ * The description of {@link BaseBuffer} mostly applies. Methods provided or overridden here are
+ * appropriate to 1-dimensional arrays backed by byte[].
+ *
+ */
+public abstract class BaseArrayBuffer extends BaseBuffer implements PyBuffer {
+
+    /**
+     * Reference to the underlying byte[] storage that the exporter is sharing with the
+     * consumer. The data need not occupy the whole array: in the constructor of a particular type
+     * of buffer, the exporter usually indicates an offset to the first significant byte and length
+     * (contiguous cases) or the index in storage that should be treated as the item
+     * with index zero (retrieved say by buf.byteAt(0)).
+     */
+    protected byte[] storage;
+
+    /**
+     * Construct an instance of BaseArrayBuffer in support of a sub-class, specifying
+     * the 'feature flags', or at least a starting set to be adjusted later. These are the features
+     * of the buffer exported, not the flags that form the consumer's request. The buffer will be
+     * read-only unless {@link PyBUF#WRITABLE} is set in the feature flags. {@link PyBUF#FORMAT} and
+     * {@link PyBUF#AS_ARRAY} are implicitly added to the feature flags. The navigation arrays are
+     * all null, awaiting action by the sub-class constructor. To complete initialisation, the
+     * sub-class normally must assign: the buffer ( {@link #storage}, {@link #index0}), and the
+     * navigation arrays ({@link #shape}, {@link #strides}), and call
+     * {@link #checkRequestFlags(int)} passing the consumer's request flags.
+     *
+     * @param featureFlags bit pattern that specifies the actual features allowed/required
+     */
+    protected BaseArrayBuffer(int featureFlags) {
+        super(featureFlags | AS_ARRAY);
+    }
+
+    @Override
+    protected int getSize() {
+        return shape[0];
+    }
+
+    @Override
+    public int getLen() {
+        return shape[0] * getItemsize();
+    }
+
+    @Override
+    protected byte byteAtImpl(int byteIndex) throws IndexOutOfBoundsException {
+        return storage[byteIndex];
+    }
+
+    @Override
+    protected void storeAtImpl(byte value, int byteIndex) throws IndexOutOfBoundsException,
+            PyException {
+        checkWritable();
+        storage[byteIndex] = value;
+    }
+
+    @Override
+    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
+        // BaseBuffer implementation can be simplified since if indices.length!=1 we error.
+        checkDimension(indices.length); // throws if != 1
+        return byteIndex(indices[0]);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised to one-dimensional, possibly strided buffer.
+     */
+    @Override
+    protected int calcGreatestIndex() {
+        int stride = strides[0];
+        if (stride == 1) {
+            return index0 + shape[0] - 1;
+        } else if (stride > 0) {
+            return index0 + (shape[0] - 1) * stride;
+        } else {
+            return index0 - 1;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised to one-dimensional, possibly strided buffer.
+     */
+    @Override
+    protected int calcLeastIndex() {
+        int stride = strides[0];
+        if (stride < 0) {
+            return index0 + (shape[0] - 1) * stride;
+        } else {
+            return index0;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The implementation in BaseArrayBuffer deals with the general one-dimensional
+     * case of arbitrary item size and stride.
+     */
+    @Override
+    public void copyTo(int srcIndex, byte[] dest, int destPos, int count)
+            throws IndexOutOfBoundsException {
+
+        if (count > 0) {
+            // Pick up attributes necessary to choose an efficient copy strategy
+            int itemsize = getItemsize();
+            int stride = getStrides()[0];
+            int skip = stride - itemsize;
+            int s = byteIndex(srcIndex);
+
+            // Strategy depends on whether items are laid end-to-end contiguously or there are gaps
+            if (skip == 0) {
+                // stride == itemsize: straight copy of contiguous bytes
+                System.arraycopy(storage, s, dest, destPos, count * itemsize);
+            } else {
+                int limit = s + count * stride, d = destPos;
+                if (itemsize == 1) {
+                    // Non-contiguous copy: single byte items
+                    for (; s != limit; s += stride) {
+                        dest[d++] = storage[s];
+                    }
+                } else {
+                    // Non-contiguous copy: each time, copy itemsize bytes then skip
+                    for (; s != limit; s += skip) {
+                        int t = s + itemsize;
+                        while (s < t) {
+                            dest[d++] = storage[s++];
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The default implementation in BaseArrayBuffer deals with the general
+     * one-dimensional case of arbitrary item size and stride.
+     */
+    @Override
+    public void copyFrom(byte[] src, int srcPos, int destIndex, int count)
+            throws IndexOutOfBoundsException, PyException {
+
+        checkWritable();
+
+        if (count > 0) {
+            // Pick up attributes necessary to choose an efficient copy strategy
+            int itemsize = getItemsize();
+            int stride = getStrides()[0];
+            int skip = stride - itemsize;
+            int d = byteIndex(destIndex);
+
+            // Strategy depends on whether items are laid end-to-end or there are gaps
+            if (skip == 0) {
+                // Straight copy of contiguous bytes
+                System.arraycopy(src, srcPos, storage, d, count * itemsize);
+            } else {
+                // Non-contiguous copy: single byte items
+                int limit = d + count * stride, s = srcPos;
+                if (itemsize == 1) {
+                    for (; d != limit; d += stride) {
+                        storage[d] = src[s++];
+                    }
+                } else {
+                    // Non-contiguous copy: itemsize bytes then skip to next item
+                    for (; d != limit; d += skip) {
+                        int t = d + itemsize;
+                        while (d < t) {
+                            storage[d++] = src[s++];
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void copyFrom(PyBuffer src) throws IndexOutOfBoundsException, PyException {
+        if (src instanceof BaseArrayBuffer) {
+            copyFromArrayBuffer((BaseArrayBuffer)src);
+        } else {
+            super.copyFrom(src);
+        }
+    }
+
+    private void copyFromArrayBuffer(BaseArrayBuffer src) throws IndexOutOfBoundsException,
+            PyException {
+
+        checkWritable();
+        src.checkDimension(1);
+
+        int itemsize = getItemsize();
+        int count = getSize();
+
+        // Block operation if different item or overall size (permit reshape)
+        if (src.getItemsize() != itemsize || src.getSize() != count) {
+            throw differentStructure();
+        }
+
+        for (int i = 0; i < count; i++) {
+            int s = src.byteIndex(i), d = byteIndex(i);
+            for (int j = 0; j < itemsize; j++) {
+                storage[d++] = src.byteAtImpl(s++);
+            }
+        }
+    }
+
+    /**
+     * Copy blocks of bytes, equally spaced in the source array, to locations equally spaced in the
+     * destination array, which may be the same array. The byte at
+     * src[srcPos+k*srcStride+j] will be copied to
+     * dst[dstPos+k*dstStride+j] for 0≤k<count and
+     * 0≤j<size. When the source and destination are the same array, the method
+     * deals correctly with the risk that a byte gets written under the alias dst[x]
+     * before it should have been copied referenced as src[y].
+     *
+     * @param size of the blocks of bytes
+     * @param src the source array
+     * @param srcPos the position of the first block in the source
+     * @param srcStride the interval between the start of each block in the source
+     * @param dst the destination array
+     * @param dstPos the position of the first block in the destination
+     * @param dstStride the interval between the start of each block in the destination
+     * @param count the number of blocks to copy
+     */
+    private static void slicedArrayCopy(int size, byte[] src, int srcPos, int srcStride,
+            byte[] dst, int dstPos, int dstStride, int count) {}
+
+    @Override
+    protected ByteBuffer getNIOByteBufferImpl() {
+        // The buffer spans the whole storage, which may include data not in the view
+        ByteBuffer b = ByteBuffer.wrap(storage);
+        // Return as read-only if it is.
+        return isReadonly() ? b.asReadOnlyBuffer() : b;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * BaseArrayBuffer provides a reference to the storage array even when the buffer
+     * is intended not to be writable. There can be no enforcement of read-only character once a
+     * reference to the byte array has been handed out.
+     */
+    @SuppressWarnings("deprecation")
+    @Override
+    public Pointer getBuf() {
+        return new Pointer(storage, index0);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised in BaseArrayBuffer to one dimension.
+     */
+    @Override
+    public boolean isContiguous(char order) {
+        if ("CFA".indexOf(order) < 0) {
+            return false;
+        } else {
+            if (getShape()[0] < 2) {
+                return true;
+            } else {
+                return getStrides()[0] == getItemsize();
+            }
+        }
+    }
+
+}
diff --git a/src/org/python/core/buffer/BaseBuffer.java b/src/org/python/core/buffer/BaseBuffer.java
--- a/src/org/python/core/buffer/BaseBuffer.java
+++ b/src/org/python/core/buffer/BaseBuffer.java
@@ -9,34 +9,35 @@
 import org.python.core.PyException;
 
 /**
- * Base implementation of the Buffer API providing variables and accessors for the navigational
+ * Base implementation of the Buffer API providing variables and accessors for the navigation
  * arrays, methods for expressing and checking the buffer request flags, methods and mechanism for
  * get-release counting, boilerplate error checks and their associated exceptions, and default
  * implementations of some methods for access to the buffer content. The design aim is to ensure
  * unglamorous common code need only be implemented once.
  * 

- * Where provided, the buffer access methods are appropriate to 1-dimensional arrays where the units
- * are single bytes, stored contiguously. Sub-classes that deal with N-dimensional arrays,
- * non-contiguous storage and items that are not single bytes must override the default
- * implementations.
+ * This class leaves undefined the storage mechanism for the bytes (typically byte[] or
+ * java.nio.ByteBuffer). A concrete class that extends this one must provide elementary
+ * accessors {@link #byteAtImpl(int)}, {@link #storeAtImpl(byte, int)} that abstract this storage, a
+ * factory {@link #getNIOByteBufferImpl()} for ByteBuffers that wrap the storage, and a
+ * factory for slices {@link #getBufferSlice(int, int, int, int)}. The constructor must specify the
+ * feature flags (see {@link #BaseBuffer(int)}), set {@link #index0}, {@link #shape} and
+ * {@link #strides}, and finally check the client capabilities with {@link #checkRequestFlags(int)}.
+ * Sub-classes intended to represent slices of exporters that must count their exports as part of a
+ * locking protocol, as does bytearray, must override {@link #getRoot()} so that a
+ * buffer view {@link #release()} on a slice, propagates to the buffer view that provided it.
+ * 

+ * Access methods provided here necessarily work with the abstracted {@link #byteAtImpl(int)},
+ * {@link #storeAtImpl(byte, int)} interface, but subclasses are able to override them with more
+ * efficient versions that employ knowledge of the particular storage type used. The provided buffer
+ * access methods may be restricted to 1-dimensional arrays where the units are single bytes, stored
+ * contiguously. Sub-classes that deal with N-dimensional arrays, non-contiguous storage and items
+ * that are not single bytes must sometimes override the default implementations.
  * 

  * This base implementation is writable only if {@link PyBUF#WRITABLE} is in the feature flags
- * passed to the constructor. Otherwise, all methods for write access raise a
- * BufferError read-only exception and {@link #isReadonly()} returns true.
- * Sub-classes can follow the same pattern, setting {@link PyBUF#WRITABLE} in the constructor and,
- * if they have to, overriding the operations that write (storeAt and
- * copyFrom). The recommended pattern is:
- *
- * 
- * if (isReadonly()) {
- *     throw notWritable();
- * }
- * // ... implementation of the write operation
- * 
- * Another approach, used in the standard library, is to have distinct classes for the writable and
- * read-only variants. The implementors of simple buffers will find it efficient to override the
- * generic access methods to which performance might be sensitive, with a calculation specific to
- * their actual type.
+ * passed to the constructor. Otherwise, all methods for write access raise a TypeError
+ * and {@link #isReadonly()} returns true. However, a client intending to write should
+ * have presented {@link PyBUF#WRITABLE} in its client request flags when getting the buffer, and
+ * been prevented by a BufferError exception at that point.
  * 
  * At the time of writing, only one-dimensional buffers of item size one are used in the Jython
  * core.
@@ -59,20 +60,16 @@
     protected int[] strides;
 
     /**
-     * Reference to the underlying byte[] storage that the exporter is sharing with the
-     * consumer. The data need not occupy the whole array: in the constructor of a particular type
-     * of buffer, the exporter usually indicates an offset to the first significant byte and length
-     * (contiguous cases) or the index in storage that should be treated as the item
-     * with index zero (retrieved say by {@link #byteAt(int)}).
+     * The strides array for a contiguous byte buffer..
      */
-    // XXX Pending change of implementation to ByteBuffer
-    protected byte[] storage;
+    protected static final int[] CONTIG_STRIDES = {1};
 
     /**
-     * Absolute index in storage of item[0]. In one dimension, for a
-     * positive stride this is equal to the offset of the first byte used in
-     * {@link #storage}, and for a negative stride it is the last. In an N-dimensional
-     * buffer with strides of mixed sign, it could be anywhere in the data.
+     * Absolute byte-index in the storage of item[0]. In one dimension, for a positive
+     * stride this is equal to the offset of the first byte used in whatever
+     * byte-storage is provided, and for a negative stride it is the first byte of the
+     * last item. In an N-dimensional buffer with strides of mixed sign, it could be anywhere in the
+     * data.
      */
     protected int index0;
 
@@ -92,8 +89,8 @@
      * the consumer does not specify that it will use a navigation array the buffer requires.
      * 

      * In order to support efficient checking with {@link #checkRequestFlags(int)} we store a
-     * mutilated version of the apparent featureFlags in which the non-navigational
-     * flags are inverted. The syndrome S of the error is computed as follows. Let
+     * mutilated version of the apparent featureFlags in which the non-navigation flags
+     * are inverted. The syndrome S of the error is computed as follows. Let
      * N=1 where we are dealing with a navigation flag, let F be a buffer
      * feature flag, and let X be the consumer request flags.
      *
@@ -126,20 +123,20 @@
     private int gFeatureFlags = ~NAVIGATION; // featureFlags = 0
 
     /**
-     * Construct an instance of BaseBuffer in support of a sub-class, specifying the 'feature
-     * flags', or at least a starting set to be adjusted later. These are the features of the buffer
-     * exported, not the flags that form the consumer's request. The buffer will be read-only unless
-     * {@link PyBUF#WRITABLE} is set in the feature flags. {@link PyBUF#FORMAT} and
-     * {@link PyBUF#AS_ARRAY} are implicitly added to the feature flags. The navigation arrays are
-     * all null, awaiting action by the sub-class constructor. To complete initialisation, the
-     * sub-class normally must assign: the buffer ( {@link #storage}, {@link #index0}), and the
-     * navigation arrays ({@link #shape}, {@link #strides}), and call
-     * {@link #checkRequestFlags(int)} passing the consumer's request flags.
+     * Construct an instance of BaseBuffer in support of a sub-class, specifying the
+     * 'feature flags', or at least a starting set to be adjusted later. These are the features of
+     * the buffer exported, not the flags that form the consumer's request. The buffer will be
+     * read-only unless {@link PyBUF#WRITABLE} is set in the feature flags. {@link PyBUF#FORMAT} is
+     * implicitly added to the feature flags. The navigation arrays are all null, awaiting action by
+     * the sub-class constructor. To complete initialisation, the sub-class normally must create its
+     * own wrapped byte-storage, assign {@link #index0}) and the navigation arrays ( {@link #shape},
+     * {@link #strides}), and call {@link #checkRequestFlags(int)} passing the consumer's request
+     * flags.
      *
      * @param featureFlags bit pattern that specifies the actual features allowed/required
      */
     protected BaseBuffer(int featureFlags) {
-        setFeatureFlags(featureFlags | FORMAT | AS_ARRAY);
+        setFeatureFlags(featureFlags | FORMAT);
     }
 
     /**
@@ -176,6 +173,17 @@
     }
 
     /**
+     * Remove features from this buffer expressed using the constants defined in {@link PyBUF},
+     * clearing individual flags specified while leaving others already set. Equivalent to
+     * setFeatureFlags(~flags & getFeatureFlags()).
+     *
+     * @param flags to clear within the feature flags
+     */
+    protected final void removeFeatureFlags(int flags) {
+        setFeatureFlags(~flags & getFeatureFlags());
+    }
+
+    /**
      * General purpose method to check the consumer request flags (typically the argument to
      * {@link BufferProtocol#getBuffer(int)}) against the feature flags (see
      * {@link #getFeatureFlags()}) that characterise the features of the buffer, and to raise an
@@ -188,7 +196,7 @@
      * capabilities this type (or instance) buffer actually has. It is an error, for the consumer to
      * specify in its request a feature that the buffer does not offer.
      * 

-     * In a subset of the flags, the consumer specifies the set of navigational arrays (
+     * In a subset of the flags, the consumer specifies the set of navigation arrays (
      * shape, strides, and suboffsets) it intends to use in
      * navigating the buffer. When the buffer implementation calls this check method, it has already
      * specified in {@link #setFeatureFlags(int)} what navigation is necessary for the consumer to
@@ -211,17 +219,11 @@
 
     @Override
     public boolean isReadonly() {
-        // WRITABLE is a non-navigational flag, so is inverted in gFeatureFlags
+        // WRITABLE is a non-navigation flag, so is inverted in gFeatureFlags
         return (gFeatureFlags & WRITABLE) != 0; // i.e. featureFlags & WRITABLE is false
     }
 
     @Override
-    public boolean hasArray() {
-        // AS_ARRAY is a non-navigational flag, so is inverted in gFeatureFlags
-        return (gFeatureFlags & AS_ARRAY) == 0; // i.e. featureFlags & AS_ARRAY is true
-    }
-
-    @Override
     public int getNdim() {
         return shape.length;
     }
@@ -232,64 +234,137 @@
         return shape;
     }
 
+    // XXX Consider making this part of the PyBUF interface
+    protected int getSize() {
+        final int N = shape.length;
+        int size = shape[0];
+        for (int k = 1; k < N; k++) {
+            size *= shape[k];
+        }
+        return size;
+    }
+
+    @Override
+    public int getLen() {
+        final int N = shape.length;
+        int len = getItemsize();
+        for (int k = 0; k < N; k++) {
+            len *= shape[k];
+        }
+        return len;
+    }
+
+    /**
+     * Retrieve the byte at the given index in the underlying storage treated as a flat sequence of
+     * bytes. This byte-index will have been computed from the item index (which may have been
+     * multi-dimensional), taking into account {@link #index0}, {@link #shape}, {@link #strides},
+     * and the item size. The caller is responsible for validating the original item-index and
+     * raising (typically) an IndexOutOfBoundsException. Misuse of this method may
+     * still result in unchecked exceptions characteristic of the storage implementation.
+     *
+     * @param byteIndex byte-index of location to retrieve
+     * @return the byte at byteIndex
+     */
+    abstract protected byte byteAtImpl(int byteIndex) throws IndexOutOfBoundsException;
+
+    /**
+     * Store the byte at the given index in the underlying storage treated as a flat sequence of
+     * bytes. This byte-index will have been computed from the item index (which may have been
+     * multi-dimensional), taking into account {@link #index0}, {@link #shape}, {@link #strides},
+     * and the item size. The caller is responsible for validating the original item-index and
+     * raising (typically) an IndexOutOfBoundsException. Misuse of this method may
+     * still result in unchecked exceptions characteristic of the storage implementation. This
+     * method must implement the check for read-only character, raising a BufferError
+     * in the case of a violation.
+     *
+     * @param value to store
+     * @param byteIndex byte-index of location to retrieve
+     * @throws PyException(BufferError) if this object is read-only.
+     */
+    abstract protected void storeAtImpl(byte value, int byteIndex)
+            throws IndexOutOfBoundsException, PyException;
+
     /**
      * {@inheritDoc}
      * 

-     * The default implementation in BaseBuffer deals with the general one-dimensional
-     * case, with any item size and stride.
+     * The BaseBuffer implementation delegates to {@link #byteAtImpl(int)} via
+     * byteAtImpl(byteIndex(index)).
      */
     @Override
-    public int getLen() {
-        // Correct if one-dimensional. Override with itemsize*product(shape).
-        return shape[0] * getItemsize();
-    }
-
-    @Override
     public byte byteAt(int index) throws IndexOutOfBoundsException {
-        return storage[calcIndex(index)];
-    }
-
-    @Override
-    public int intAt(int index) throws IndexOutOfBoundsException {
-        return 0xff & byteAt(index);
-    }
-
-    @Override
-    public void storeAt(byte value, int index) throws IndexOutOfBoundsException, PyException {
-        if (isReadonly()) {
-            throw notWritable();
-        }
-        storage[calcIndex(index)] = value;
+        return byteAtImpl(byteIndex(index));
     }
 
     /**
-     * Convert an item index (for a one-dimensional buffer) to an absolute byte index in the actual
-     * storage being shared by the exporter. See {@link #calcIndex(int...)} for discussion.
-     *
-     * @param index from consumer
-     * @return index in actual storage
+     * {@inheritDoc}
+     * 

+     * The BaseBuffer implementation delegates to {@link #byteAtImpl(int)} via
+     * byteAtImpl(byteIndex(index)), cast unsigned to an int.
      */
-    protected int calcIndex(int index) throws IndexOutOfBoundsException {
-        // Treat as one-dimensional
-        return index0 + index * getStrides()[0];
+    @Override
+    public int intAt(int index) throws IndexOutOfBoundsException {
+        return 0xff & byteAtImpl(byteIndex(index));
     }
 
+    /**
+     * {@inheritDoc}
+     * 

+     * The BaseBuffer implementation delegates to {@link #storeAtImpl(byte, int)} via
+     * storeAtImpl(value, byteIndex(index)).
+     */
+    @Override
+    public void storeAt(byte value, int index) throws IndexOutOfBoundsException, PyException {
+        storeAtImpl(value, byteIndex(index));
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The BaseBuffer implementation delegates to {@link #byteAtImpl(int)} via
+     * byteAtImpl(byteIndex(indices)).
+     */
     @Override
     public byte byteAt(int... indices) throws IndexOutOfBoundsException {
-        return storage[calcIndex(indices)];
+        return byteAtImpl(byteIndex(indices));
     }
 
+    /**
+     * {@inheritDoc}
+     * 

+     * The BaseBuffer implementation delegates to {@link #byteAtImpl(int)} via
+     * byteAtImpl(byteIndex(indices)), cast unsigned to an int.
+     */
     @Override
     public int intAt(int... indices) throws IndexOutOfBoundsException {
         return 0xff & byteAt(indices);
     }
 
+    /**
+     * {@inheritDoc}
+     * 

+     * The BaseBuffer implementation delegates to {@link #storeAtImpl(byte, int)} via
+     * storeAtImpl(value, byteIndex(indices)).
+     */
     @Override
     public void storeAt(byte value, int... indices) throws IndexOutOfBoundsException, PyException {
-        if (isReadonly()) {
-            throw notWritable();
+        storeAtImpl(value, byteIndex(indices));
+    }
+
+    /**
+     * Convert an item index (for a one-dimensional buffer) to a checked absolute byte index in the
+     * actual storage being shared by the exporter. See {@link #byteIndex(int[])} for discussion.
+     *
+     * @param index item-index from consumer
+     * @return corresponding byte-index in actual storage
+     * @throws IndexOutOfBoundsException if the index <0 or ≥shape[0]
+     */
+    // XXX Consider making this part of the PyBuffer interface
+    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+        // Treat as one-dimensional
+        if (index < 0 || index >= shape[0]) {
+            throw new IndexOutOfBoundsException();
         }
-        storage[calcIndex(indices)] = value;
+        return index0 + index * strides[0];
     }
 
     /**
@@ -298,25 +373,28 @@
      * to allow a sub-class to define, in one place, an indexing calculation that maps the index as
      * provided by the consumer into an index in the storage known to the buffer.
      * 

-     * In the usual case where the storage is referenced via the {@link #storage} and
-     * {@link #index0} members, the buffer implementation may use storage[calcIndex(i)]
+     * In the usual case where the storage is referenced via a storage member and
+     * {@link #index0} member, the buffer implementation may use storage[byteIndex(i)]
      * to reference the (first byte of) the item x[i]. This is what the default implementation of
-     * accessors in BaseBuffer will do. In the simplest cases, calling
-     * calcIndex may be an overhead to avoid, and an implementation will specialise the
+     * accessors in BaseArrayBuffer will do. In the simplest cases, calling
+     * byteIndex may be an overhead to avoid, and an implementation will specialise the
      * accessors. The default implementation here is suited to N-dimensional arrays.
      *
-     * @param indices of the item from the consumer
-     * @return corresponding absolute index in storage
+     * @param indices n-dimensional item-index from consumer
+     * @return corresponding byte-index in actual storage
+     * @throws IndexOutOfBoundsException if any index <0 or ≥shape[i]
      */
-    protected int calcIndex(int... indices) throws IndexOutOfBoundsException {
+    // XXX Consider making this part of the PyBuffer interface
+    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
         final int N = checkDimension(indices);
         // In general: index0 + sum(k=0,N-1) indices[k]*strides[k]
         int index = index0;
-        if (N > 0) {
-            int[] strides = getStrides();
-            for (int k = 0; k < N; k++) {
-                index += indices[k] * strides[k];
+        for (int k = 0; k < N; k++) {
+            int ik = indices[k];
+            if (ik < 0 || ik >= shape[k]) {
+                throw new IndexOutOfBoundsException();
             }
+            index += ik * strides[k];
         }
         return index;
     }
@@ -324,24 +402,22 @@
     /**
      * Calculate the absolute byte index in the storage array of the last item of the exported data
      * (if we are not using indirection). This is the greatest value attained by
-     * {@link #calcIndex(int...)}. The first byte not used will be one itemsize more
+     * {@link #byteIndex(int...)}. The first byte not used will be one itemsize more
      * than the returned value.
      *
      * @return greatest absolute index in storage
      */
-    protected int calcGreatestIndex() throws IndexOutOfBoundsException {
+    protected int calcGreatestIndex() {
         final int N = shape.length;
         // If all the strides are positive, the maximal value is found from:
         // index = index0 + sum(k=0,N-1) (shape[k]-1)*strides[k]
         // but in general, for any k where strides[k]<=0, the term should be zero.
         int index = index0;
-        if (N > 0) {
-            int[] strides = getStrides();
-            for (int k = 0; k < N; k++) {
-                int stride = strides[k];
-                if (stride > 0) {
-                    index += (shape[k] - 1) * stride;
-                }
+        int[] strides = getStrides();
+        for (int k = 0; k < N; k++) {
+            int stride = strides[k];
+            if (stride > 0) {
+                index += (shape[k] - 1) * stride;
             }
         }
         return index;
@@ -350,23 +426,21 @@
     /**
      * Calculate the absolute byte index in the storage array of the first item of the exported data
      * (if we are not using indirection). This is the least value attained by
-     * {@link #calcIndex(int...)}.
+     * {@link #byteIndex(int...)}.
      *
      * @return least absolute index in storage
      */
-    protected int calcLeastIndex() throws IndexOutOfBoundsException {
+    protected int calcLeastIndex() {
         final int N = shape.length;
         // If all the strides are positive, the maximal value is just index0,
         // but in general, we must allow strides[k]<=0 for some k:
         // index = index0 + sum(k=0,N-1) (strides[k]<0) ? (shape[k]-1)*strides[k] : 0
         int index = index0;
-        if (N > 0) {
-            int[] strides = getStrides();
-            for (int k = 0; k < N; k++) {
-                int stride = strides[k];
-                if (stride < 0) {
-                    index += (shape[k] - 1) * stride;
-                }
+        int[] strides = getStrides();
+        for (int k = 0; k < N; k++) {
+            int stride = strides[k];
+            if (stride < 0) {
+                index += (shape[k] - 1) * stride;
             }
         }
         return index;
@@ -381,147 +455,97 @@
     @Override
     public void copyTo(byte[] dest, int destPos) throws IndexOutOfBoundsException {
         // Note shape[0] is the number of items in the array
-        copyTo(0, dest, destPos, shape[0]);
+        copyTo(0, dest, destPos, getSize());
     }
 
     /**
      * {@inheritDoc}
      * 

      * The default implementation in BaseBuffer deals with the general one-dimensional
-     * case of arbitrary item size and stride.
+     * case of arbitrary item size and stride, but is unable to optimise access to sequential bytes.
      */
     @Override
-    public void copyTo(int srcIndex, byte[] dest, int destPos, int length)
-            throws IndexOutOfBoundsException {
+    public void copyTo(int srcIndex, byte[] dest, int destPos, int count)
+            throws IndexOutOfBoundsException, PyException {
 
-        // Data is here in the buffers
-        int s = calcIndex(srcIndex);
-        int d = destPos;
+        checkDimension(1);
 
-        // Pick up attributes necessary to choose an efficient copy strategy
         int itemsize = getItemsize();
-        int stride = getStrides()[0];
-        int skip = stride - itemsize;
+        int s = srcIndex, d = destPos;
 
-        // Strategy depends on whether items are laid end-to-end contiguously or there are gaps
-        if (skip == 0) {
-            // stride == itemsize: straight copy of contiguous bytes
-            System.arraycopy(storage, s, dest, d, length * itemsize);
-
-        } else if (itemsize == 1) {
-            // Non-contiguous copy: single byte items
-            int limit = s + length * stride;
-            for (; s < limit; s += stride) {
-                dest[d++] = storage[s];
+        if (itemsize == 1) {
+            // Single byte items
+            for (int i = 0; i < count; i++) {
+                dest[d++] = byteAt(s++);
             }
-
         } else {
-            // Non-contiguous copy: each time, copy itemsize bytes then skip
-            int limit = s + length * stride;
-            for (; s < limit; s += skip) {
-                int t = s + itemsize;
-                while (s < t) {
-                    dest[d++] = storage[s++];
+            // Multi-byte items
+            for (int i = 0; i < count; i++) {
+                int p = byteIndex(s++);
+                for (int j = 0; j < itemsize; j++) {
+                    dest[d++] = byteAtImpl(p + j);
                 }
             }
         }
-
     }
 
     /**
      * {@inheritDoc}
      * 

      * The default implementation in BaseBuffer deals with the general one-dimensional
-     * case of arbitrary item size and stride.
+     * case of arbitrary item size and stride, but is unable to optimise access to sequential bytes.
      */
     @Override
-    public void copyFrom(byte[] src, int srcPos, int destIndex, int length)
+    public void copyFrom(byte[] src, int srcPos, int destIndex, int count)
             throws IndexOutOfBoundsException, PyException {
 
-        // Block operation if read-only
-        if (isReadonly()) {
-            throw notWritable();
-        }
+        checkDimension(1);
+        checkWritable();
 
-        // Data is here in the buffers
-        int s = srcPos;
-        int d = calcIndex(destIndex);
+        int itemsize = getItemsize();
+        int d = destIndex, s = srcPos;
 
-        // Pick up attributes necessary to choose an efficient copy strategy
-        int itemsize = getItemsize();
-        int stride = getStrides()[0];
-        int skip = stride - itemsize;
-
-        // Strategy depends on whether items are laid end-to-end or there are gaps
-        if (skip == 0) {
-            // Straight copy of contiguous bytes
-            System.arraycopy(src, srcPos, storage, d, length * itemsize);
-
-        } else if (itemsize == 1) {
-            // Non-contiguous copy: single byte items
-            int limit = d + length * stride;
-            for (; d != limit; d += stride) {
-                storage[d] = src[s++];
+        if (itemsize == 1) {
+            // Single byte items
+            for (int i = 0; i < count; i++) {
+                storeAt(src[s++], d++);
             }
-
         } else {
-            // Non-contiguous copy: each time, copy itemsize bytes then skip
-            int limit = d + length * stride;
-            for (; d != limit; d += skip) {
-                int t = d + itemsize;
-                while (d < t) {
-                    storage[d++] = src[s++];
+            // Multi-byte items
+            for (int i = 0; i < count; i++) {
+                int p = byteIndex(d++);
+                for (int j = 0; j < itemsize; j++) {
+                    storeAtImpl(src[s++], p++);
                 }
             }
         }
-
     }
 
     /**
      * {@inheritDoc}
      * 

      * The default implementation in BaseBuffer deals with the general one-dimensional
-     * case.
+     * case of arbitrary item size and stride, but is unable to optimise access to sequential bytes.
      */
     @Override
     public void copyFrom(PyBuffer src) throws IndexOutOfBoundsException, PyException {
 
-        // Block operation if read-only and same length
-        if (isReadonly()) {
-            throw notWritable();
-        } else if (src.getLen() != getLen() || src.getItemsize() != getItemsize()) {
+        checkWritable();
+
+        int itemsize = getItemsize();
+        int count = getSize();
+
+        // Block operation if different item or overall size (permit reshape)
+        if (src.getItemsize() != itemsize || src.getLen() != count * itemsize) {
             throw differentStructure();
         }
 
-        // Data is here in the buffers
-        int s = 0;
-        int d = calcIndex(0);
-
-        // Pick up attributes necessary to choose an efficient copy strategy
-        int itemsize = getItemsize();
-        int stride = getStrides()[0];
-
-        // Strategy depends on whether items are laid end-to-end or there are gaps
-        if (stride == itemsize) {
-            // Straight copy to contiguous bytes
-            src.copyTo(storage, d);
-
-        } else if (itemsize == 1) {
-            // Non-contiguous copy: single byte items
-            int limit = d + src.getLen() * stride;
-            for (; d != limit; d += stride) {
-                storage[d] = src.byteAt(s++);
-            }
-
-        } else {
-            // Non-contiguous copy: each time, copy itemsize bytes then skip
-            int limit = d + src.getShape()[0] * stride;
-            for (; d != limit; d += stride) {
-                Pointer srcItem = src.getPointer(s++);
-                System.arraycopy(srcItem.storage, srcItem.offset, storage, d, itemsize);
-            }
+        // XXX Re-think this using ByteBuffer when the API provides a byteIndex() method
+        assert itemsize == 1;
+        // XXX This only moves the first byte of each item
+        for (int i = 0; i < count; i++) {
+            storeAt(src.byteAt(i), i);
         }
-
     }
 
     @Override
@@ -536,7 +560,7 @@
     }
 
     /**
-     * Allow an exporter to re-use a BaseBytes even if it has been "finally" released. Many
+     * Allow an exporter to re-use this object again even if it has been "finally" released. Many
      * sub-classes of BaseBytes can be re-used even after a final release by consumers,
      * simply by incrementing the exports count again: the navigation arrays and the
      * buffer view of the exporter's state all remain valid. We do not let consumers do this through
@@ -574,6 +598,7 @@
         if (--exports == 0) {
             // This is a final release.
             releaseAction();
+            // XXX Consider adding release of root if root!=this so sliced need not
         } else if (exports < 0) {
             // Buffer already had 0 exports. (Put this right, in passing.)
             exports = 0;
@@ -592,55 +617,79 @@
     }
 
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length) {
-        return getBufferSlice(flags, start, length, 1);
+    public PyBuffer getBufferSlice(int flags, int start, int count) {
+        return getBufferSlice(flags, start, count, 1);
     }
 
     // Let the sub-class implement
-    // @Override public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {}
+    // @Override public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {}
+
+    /**
+     * Create a new java.nio.ByteBuffer on the underlying storage, such that
+     * positioning this buffer to a particular byte using {@link #byteIndex(int)} or
+     * {@link #byteIndex(int[])} positions it at the first byte of the item so indexed.
+     */
+    abstract protected ByteBuffer getNIOByteBufferImpl();
 
     @Override
     public ByteBuffer getNIOByteBuffer() {
-        // The buffer spans the whole storage, which may include data not in the view
-        ByteBuffer b = ByteBuffer.wrap(storage);
-        b.limit(calcGreatestIndex() + getItemsize()).position(index0);
-        // Return as read-only if it is.
-        return isReadonly() ? b.asReadOnlyBuffer() : b;
+        // The buffer spans the whole storage
+        ByteBuffer b = getNIOByteBufferImpl();
+        // For the one-dimensional contiguous case it makes sense to set the limit:
+        if (shape.length == 1) {
+            int stride = strides[0];
+            if (getItemsize() == stride) {
+                b.limit(index0 + shape[0] * stride);
+            }
+        }
+        // The buffer is positioned at item[0]
+        b.position(index0);
+        return b;
     }
 
     @Override
     public ByteBuffer getNIOByteBuffer(int index) {
         // The buffer spans the whole storage but is positioned at index
-        ByteBuffer b = getNIOByteBuffer();
-        b.position(calcIndex(index));
+        ByteBuffer b = getNIOByteBufferImpl();
+        b.position(byteIndex(index));
         return b;
     }
 
     @Override
     public ByteBuffer getNIOByteBuffer(int... indices) {
         // The buffer spans the whole storage but is positioned at indices[]
-        ByteBuffer b = getNIOByteBuffer();
-        b.position(calcIndex(indices));
-        // Return as read-only if it is.
+        ByteBuffer b = getNIOByteBufferImpl();
+        b.position(byteIndex(indices));
         return b;
     }
 
+    @Override
+    public boolean hasArray() {
+        // AS_ARRAY is a non-navigation flag, so is inverted in gFeatureFlags
+        return (gFeatureFlags & AS_ARRAY) == 0; // i.e. featureFlags & AS_ARRAY is true
+    }
+
     @SuppressWarnings("deprecation")
     @Override
     public Pointer getBuf() {
-        return new Pointer(storage, index0);
+        checkHasArray();
+        return new Pointer(getNIOByteBuffer().array(), index0);
     }
 
     @SuppressWarnings("deprecation")
     @Override
     public Pointer getPointer(int index) throws IndexOutOfBoundsException {
-        return new Pointer(storage, calcIndex(index));
+        Pointer p = getBuf();
+        p.offset = byteIndex(index);
+        return p;
     }
 
     @SuppressWarnings("deprecation")
     @Override
     public Pointer getPointer(int... indices) throws IndexOutOfBoundsException {
-        return new Pointer(storage, calcIndex(indices));
+        Pointer p = getBuf();
+        p.offset = byteIndex(indices);
+        return p;
     }
 
     @Override
@@ -654,10 +703,73 @@
         return null;
     }
 
+    private boolean isCContiguous() {
+        /*
+         * If we were to compute the strides array for a C-contiguous array, the last stride would
+         * equal the item size, and generally stride[k-1] = shape[k]*stride[k]. This is the basis of
+         * the test. However, note that for any k where shape[k]==1 there is no "next sub-array"
+         * and no discontiguity.
+         */
+        final int N = shape.length;
+        /*
+         * size is the stride in bytes-index from item[i0,i1,...,ik,0,...,0] to
+         * item[i0,i1,...,ik+1,0,...,0]. Start the iteration at the largest k. An increment of one
+         * in the last index makes a stride of the item size.
+         */
+        int size = getItemsize();
+        for (int k = N - 1; k >= 0; k--) {
+            int nk = shape[k];
+            if (nk > 1) {
+                if (strides[k] != size) {
+                    return false;
+                }
+                size *= nk;
+            }
+        }
+        return true;
+    }
+
+    private boolean isFortranContiguous() {
+        /*
+         * If we were to compute the strides array for a Fortran-contiguous array, the first stride would
+         * equal the item size, and generally stride[k+1] = shape[k]*stride[k]. This is the basis of
+         * the test. However, note that for any k where shape[k]==1 there is no "next sub-array"
+         * and no discontiguity.
+         */
+        final int N = shape.length;
+        /*
+         * size is the stride in bytes-index from item[0,...,0,ik,0,...,0] to
+         * item[0,...,0,ik+1,0,...,0]. Start the iteration at k=0. An increment of one
+         * in the first index makes a stride of the item size.
+         */
+        int size = getItemsize();
+        for (int k = 0; k < N; k++) {
+            int nk = shape[k];
+            if (nk > 1) {
+                if (strides[k] != size) {
+                    return false;
+                }
+                size *= nk;
+            }
+        }
+        return true;
+    }
+
     @Override
     public boolean isContiguous(char order) {
-        // Correct for one-dimensional buffers
-        return true;
+        if (getSuboffsets() != null) {
+            return false;
+        }
+        switch (order) {
+            case 'C':
+                return isCContiguous();
+            case 'F':
+                return isFortranContiguous();
+            case 'A':
+                return isCContiguous() || isFortranContiguous();
+            default:
+                return false;
+        }
     }
 
     @Override
@@ -683,7 +795,7 @@
     protected void releaseAction() {}
 
     /**
-     * Some PyBuffers, those created by slicing a PyBuffer are related to
+     * Some PyBuffers, those created by slicing a PyBuffer, are related to
      * a root PyBuffer. During creation of such a slice, we need to supply a value for
      * this root. If the present object is not itself a slice, this root is the object itself; if
      * the buffer is already a slice, it is the root it was given at creation time. Often this is
@@ -697,6 +809,20 @@
     }
 
     /**
+     * The toString() method of a buffer reproduces the values in the buffer (as unsigned integers)
+     * as the character codes of a String.
+     */
+    @Override
+    public String toString() {
+        int n = getLen();
+        StringBuilder sb = new StringBuilder(n);
+        for (int i = 0; i < n; i++) {
+            sb.appendCodePoint(intAt(i));
+        }
+        return sb.toString();
+    }
+
+    /**
      * Check the number of indices (but not their values), raising a Python BufferError if this does
      * not match the number of dimensions. This is a helper for N-dimensional arrays.
      *
@@ -728,17 +854,25 @@
     }
 
     /**
-     * The toString() method of a buffer reproduces the values in the buffer (as unsigned integers)
-     * as the character codes of a String.
+     * Check that the buffer is writable.
+     *
+     * @throws PyException (TypeError) if not
      */
-    @Override
-    public String toString() {
-        int n = getLen();
-        StringBuilder sb = new StringBuilder(n);
-        for (int i = 0; i < n; i++) {
-            sb.appendCodePoint(intAt(i));
+    protected void checkWritable() throws PyException {
+        if (isReadonly()) {
+            throw notWritable();
         }
-        return sb.toString();
+    }
+
+    /**
+     * Check that the buffer is backed by an array the client can access as byte[].
+     *
+     * @throws PyException (BufferError) if not
+     */
+    protected void checkHasArray() throws PyException {
+        if (!hasArray()) {
+            throw bufferIsNot("accessible as a Java array");
+        }
     }
 
     /**
diff --git a/src/org/python/core/buffer/SimpleBuffer.java b/src/org/python/core/buffer/SimpleBuffer.java
--- a/src/org/python/core/buffer/SimpleBuffer.java
+++ b/src/org/python/core/buffer/SimpleBuffer.java
@@ -1,7 +1,5 @@
 package org.python.core.buffer;
 
-import java.nio.ByteBuffer;
-
 import org.python.core.PyBuffer;
 import org.python.core.PyException;
 import org.python.core.util.StringUtil;
@@ -9,12 +7,7 @@
 /**
  * Buffer API over a read-only one-dimensional array of one-byte items.
  */
-public class SimpleBuffer extends BaseBuffer {
-
-    /**
-     * The strides array for this type is always a single element array with a 1 in it.
-     */
-    protected static final int[] SIMPLE_STRIDES = {1};
+public class SimpleBuffer extends BaseArrayBuffer {
 
     /**
      * Provide an instance of SimpleBuffer with navigation variables partly
@@ -27,7 +20,7 @@
         super(CONTIGUITY | SIMPLE);
         // Initialise navigation
         shape = new int[1];
-        strides = SIMPLE_STRIDES;
+        strides = CONTIG_STRIDES;
         // suboffsets is always null for this type.
     }
 
@@ -54,8 +47,9 @@
             ArrayIndexOutOfBoundsException {
         this();
         this.storage = storage;         // Exported data
+        // Initialise navigation
         this.index0 = index0;           // Index to be treated as item[0]
-        this.shape[0] = size;           // Number of items in exported data
+        shape[0] = size;                // Number of items in exported data
 
         // Check arguments using the "all non-negative" trick
         if ((index0 | size | storage.length - (index0 + size)) < 0) {
@@ -92,11 +86,8 @@
      * @param storage the array of bytes storing the implementation of the exporting object
      * @throws NullPointerException if storage is null
      */
-    // XXX: "for sub-class use" = should be protected?
-    public SimpleBuffer(byte[] storage) throws NullPointerException {
-        this();
-        this.storage = storage;         // Exported data (index0=0 from initialisation)
-        this.shape[0] = storage.length; // Number of units in whole array
+    protected SimpleBuffer(byte[] storage) throws NullPointerException {
+        this(storage, 0, storage.length);
     }
 
     /**
@@ -114,11 +105,6 @@
         checkRequestFlags(flags);       // Check request is compatible with type
     }
 
-    @Override
-    public boolean isReadonly() {
-        return true;
-    }
-
     /**
      * {@inheritDoc}
      * 

@@ -134,72 +120,26 @@
     /**
      * {@inheritDoc}
      * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
+     * In SimpleBuffer the calculation is specialised for one dimension, no striding,
+     * and an item size of 1.
      */
     @Override
-    public byte byteAt(int index) throws IndexOutOfBoundsException {
-        // Implement directly: a bit quicker than the default
-        return storage[index0 + index];
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
-     */
-    @Override
-    public int intAt(int index) throws IndexOutOfBoundsException {
-        // Implement directly: a bit quicker than the default
-        return 0xff & storage[index0 + index];
+    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+        if (index < 0 || index >= shape[0]) {
+            throw new IndexOutOfBoundsException();
+        }
+        return index0 + index;
     }
 
     @Override
-    protected int calcIndex(int index) throws IndexOutOfBoundsException {
-        return index0 + index;
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
-     */
-    @Override
-    public byte byteAt(int... indices) throws IndexOutOfBoundsException {
-        checkDimension(indices.length);
-        return byteAt(indices[0]);
-    }
-
-    @Override
-    protected int calcIndex(int... indices) throws IndexOutOfBoundsException {
-        // BaseBuffer implementation can be simplified since if indices.length!=1 we error.
-        checkDimension(indices.length); // throws if != 1
-        return calcIndex(indices[0]);
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
-     */
-    @Override
-    public void copyTo(int srcIndex, byte[] dest, int destPos, int length)
-            throws IndexOutOfBoundsException {
-        System.arraycopy(storage, index0 + srcIndex, dest, destPos, length);
-    }
-
-    @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length) {
-        if (length > 0) {
+    public PyBuffer getBufferSlice(int flags, int start, int count) {
+        if (count > 0) {
             // Translate relative to underlying buffer
             int compIndex0 = index0 + start;
             // Create the slice from the sub-range of the buffer
-            return new SimpleView(getRoot(), flags, storage, compIndex0, length);
+            return new SimpleView(getRoot(), flags, storage, compIndex0, count);
         } else {
-            // Special case for length==0 where above logic would fail. Efficient too.
+            // Special case for count==0 where above logic would fail. Efficient too.
             return new ZeroByteBuffer.View(getRoot(), flags);
         }
     }
@@ -209,22 +149,22 @@
      * 

      * SimpleBuffer provides an implementation for slicing contiguous bytes in one
      * dimension. In that case, x(i) = u(r+i) for i = 0..L-1 where u is the underlying
-     * buffer, and r and L are the start and length with which x was created
+     * buffer, and r and L are the start and count with which x was created
      * from u. Thus y(k) = u(r+s+km), that is, the composite offset is r+s and
      * the stride is m.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
 
-        if (stride == 1 || length < 2) {
+        if (stride == 1 || count < 2) {
             // Unstrided slice of simple buffer is itself simple
-            return getBufferSlice(flags, start, length);
+            return getBufferSlice(flags, start, count);
 
         } else {
             // Translate relative to underlying buffer
             int compIndex0 = index0 + start;
             // Construct a view, taking a lock on the root object (this or this.root)
-            return new Strided1DBuffer.SlicedView(getRoot(), flags, storage, compIndex0, length,
+            return new Strided1DBuffer.SlicedView(getRoot(), flags, storage, compIndex0, count,
                     stride);
         }
     }
diff --git a/src/org/python/core/buffer/SimpleStringBuffer.java b/src/org/python/core/buffer/SimpleStringBuffer.java
--- a/src/org/python/core/buffer/SimpleStringBuffer.java
+++ b/src/org/python/core/buffer/SimpleStringBuffer.java
@@ -30,6 +30,11 @@
      * @param flags consumer requirements
      */
     public SimpleStringBuffer(int flags, String bufString) {
+        /*
+         * Leaving storage=null is ok because we carefully override every method that uses it,
+         * deferring creation of the storage byte array until we absolutely must have one.
+         */
+        super();
         // Save the backing string
         this.bufString = bufString;
         shape[0] = bufString.length();
@@ -54,32 +59,31 @@
      * This method uses {@link String#charAt(int)} rather than create an actual byte buffer.
      */
     @Override
-    public byte byteAt(int index) throws IndexOutOfBoundsException {
-        // Avoid creating buf by using String.charAt
+    public final byte byteAtImpl(int index) {
         return (byte)bufString.charAt(index);
     }
 
     /**
      * {@inheritDoc}
      * 

+     * In SimpleStringBuffer we can simply return the argument.
+     */
+    @Override
+    protected final int byteIndex(int index) {
+        // We do not check the index because String will do it for us.
+        return index;
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

      * This method uses {@link String#charAt(int)} rather than create an actual byte buffer.
      */
     @Override
-    public int intAt(int index) throws IndexOutOfBoundsException {
-        // Avoid creating buf by using String.charAt
-        return bufString.charAt(index);
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * This method uses {@link String#charAt(int)} rather than create an actual byte buffer.
-     */
-    @Override
-    public void copyTo(int srcIndex, byte[] dest, int destPos, int length)
+    public void copyTo(int srcIndex, byte[] dest, int destPos, int count)
             throws IndexOutOfBoundsException {
         // Avoid creating buf by using String.charAt
-        int endIndex = srcIndex + length, p = destPos;
+        int endIndex = srcIndex + count, p = destPos;
         for (int i = srcIndex; i < endIndex; i++) {
             dest[p++] = (byte)bufString.charAt(i);
         }
@@ -91,13 +95,13 @@
      * The SimpleStringBuffer implementation avoids creation of a byte buffer.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length) {
-        if (length > 0) {
-            // The new string content is just a sub-string. (Non-copy operation in Java.)
+    public PyBuffer getBufferSlice(int flags, int start, int count) {
+        if (count > 0) {
+            // The new string content is just a sub-string.
             return new SimpleStringView(getRoot(), flags,
-                    bufString.substring(start, start + length));
+                    bufString.substring(start, start + count));
         } else {
-            // Special case for length==0 where start out of bounds sometimes raises exception.
+            // Special case for count==0 where start out of bounds sometimes raises exception.
             return new ZeroByteBuffer.View(getRoot(), flags);
         }
     }
@@ -108,23 +112,26 @@
      * The SimpleStringBuffer implementation creates an actual byte buffer.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
         if (stride == 1) {
             // Unstrided slice of a SimpleStringBuffer is itself a SimpleStringBuffer.
-            return getBufferSlice(flags, start, length);
+            return getBufferSlice(flags, start, count);
         } else {
             // Force creation of the actual byte array from the String.
             ensureHaveBytes();
             // Now we are effectively a SimpleBuffer, return the strided view.
-            return super.getBufferSlice(flags, start, length, stride);
+            return super.getBufferSlice(flags, start, count, stride);
         }
     }
 
     @Override
-    public ByteBuffer getNIOByteBuffer() {
+    protected ByteBuffer getNIOByteBufferImpl() {
         // Force creation of the actual byte array from the String.
         ensureHaveBytes();
-        return super.getNIOByteBuffer();
+        // The buffer spans the whole storage, which may include data not in the view
+        ByteBuffer b = ByteBuffer.wrap(storage);
+        // Return as read-only.
+        return b.asReadOnlyBuffer();
     }
 
     /**
diff --git a/src/org/python/core/buffer/SimpleWritableBuffer.java b/src/org/python/core/buffer/SimpleWritableBuffer.java
--- a/src/org/python/core/buffer/SimpleWritableBuffer.java
+++ b/src/org/python/core/buffer/SimpleWritableBuffer.java
@@ -36,64 +36,28 @@
      * @throws PyException (BufferError) when expectations do not correspond with the type
      */
     public SimpleWritableBuffer(int flags, byte[] storage) throws PyException, NullPointerException {
-        super(storage);                 // Construct SimpleBuffer on whole array
-        addFeatureFlags(WRITABLE);
-        checkRequestFlags(flags);       // Check request is compatible with type
-    }
-
-    @Override
-    public boolean isReadonly() {
-        return false;
+        this(flags, storage, 0, storage.length);
     }
 
     /**
      * {@inheritDoc}
      * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
+     * Declared final returning true in SimpleWritableBuffer
+     * to make checks unnecessary.
      */
     @Override
-    public void storeAt(byte value, int index) {
-        // Implement directly and don't ask whether read-only
-        storage[index0 + index] = value;
+    public final boolean isReadonly() {
+        return false;
     }
 
-    /**
-     * {@inheritDoc}
-     * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
-     */
+    /** Do nothing: the buffer is writable. */
     @Override
-    public void storeAt(byte value, int... indices) {
-        checkDimension(indices.length);
-        storeAt(value, indices[0]);
-    }
+    protected final void checkWritable() {}
 
-    /**
-     * {@inheritDoc}
-     * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
-     */
     @Override
-    public void copyFrom(byte[] src, int srcPos, int destIndex, int length) {
-        System.arraycopy(src, srcPos, storage, index0 + destIndex, length);
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * SimpleBuffer provides an implementation optimised for contiguous bytes in
-     * one-dimension.
-     */
-    @Override
-    public void copyFrom(PyBuffer src) throws IndexOutOfBoundsException, PyException {
-        if (src.getLen() != getLen()) {
-            throw differentStructure();
-        }
-        // Get the source to deliver efficiently to our byte storage
-        src.copyTo(storage, index0);
+    protected void storeAtImpl(byte value, int byteIndex) {
+        // Implement directly and don't ask whether read-only
+        storage[byteIndex] = value;
     }
 
     /**
@@ -103,14 +67,14 @@
      * writable.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length) {
-        if (length > 0) {
+    public PyBuffer getBufferSlice(int flags, int start, int count) {
+        if (count > 0) {
             // Translate relative to underlying buffer
             int compIndex0 = index0 + start;
             // Create the slice from the sub-range of the buffer
-            return new SimpleView(getRoot(), flags, storage, compIndex0, length);
+            return new SimpleView(getRoot(), flags, storage, compIndex0, count);
         } else {
-            // Special case for length==0 where above logic would fail. Efficient too.
+            // Special case for count==0 where above logic would fail. Efficient too.
             return new ZeroByteBuffer.View(getRoot(), flags);
         }
     }
@@ -122,18 +86,18 @@
      * writable.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
 
-        if (stride == 1 || length < 2) {
+        if (stride == 1 || count < 2) {
             // Unstrided slice of simple buffer is itself simple
-            return getBufferSlice(flags, start, length);
+            return getBufferSlice(flags, start, count);
 
         } else {
             // Translate relative to underlying buffer
             int compIndex0 = index0 + start;
             // Construct a view, taking a lock on the root object (this or this.root)
             return new Strided1DWritableBuffer.SlicedView(getRoot(), flags, storage, compIndex0,
-                    length, stride);
+                    count, stride);
         }
     }
 
diff --git a/src/org/python/core/buffer/Strided1DBuffer.java b/src/org/python/core/buffer/Strided1DBuffer.java
--- a/src/org/python/core/buffer/Strided1DBuffer.java
+++ b/src/org/python/core/buffer/Strided1DBuffer.java
@@ -5,7 +5,7 @@
 
 /**
  * Read-only buffer API over a one-dimensional array of one-byte items, that are evenly-spaced in a
- * storage array. The buffer has storage, index0 and length
+ * storage array. The buffer has storage, index0 and count
  * properties in the usual way, designating a slice (or all) of a byte array, but also a
  * stride property (equal to getStrides()[0]).
  * 

@@ -14,7 +14,7 @@
  * Designate by x(j), for j=0..L-1, the byte at index j, that is, the byte
  * retrieved by x.byteAt(j). Thus, we store x(j) at u(a+pj), that is,
  * x(0) = u(a). When we construct such a buffer, we have to supply a =
- * index0, L = length, and p = stride as the
+ * index0, L = count, and p = stride as the
  * constructor arguments. The last item in the slice x(L-1) is stored at u(a+p(L-1)).
  * For the simple case of positive stride, constructor argument index0 is the low index
  * of the range occupied by the data. When the stride is negative, that is to say p<0, and
@@ -28,7 +28,7 @@
  * create the memoryview that is returned as an extended slice of a
  * memoryview.
  */
-public class Strided1DBuffer extends BaseBuffer {
+public class Strided1DBuffer extends BaseArrayBuffer {
 
     /**
      * Step size in the underlying buffer essential to correct translation of an index (or indices)
@@ -38,30 +38,6 @@
     protected int stride;
 
     /**
-     * Provide an instance of Strided1DBuffer with navigation variables partly
-     * initialised, for sub-class use. To complete initialisation, the sub-class normally must
-     * assign the navigational properties and call {@link #checkRequestFlags(int)} passing the
-     * consumer's request flags.
-     *
-     * 
-     * this.storage = storage;          // Exported data
-     * this.index0 = index0;            // Index to be treated as item[0]
-     * this.shape[0] = length;          // Number of items in exported data
-     * this.stride = stride;            // Between items
-     * 
-     *
-     * The pre-defined {@link #strides} field remains null until {@link #getStrides} is
-     * called.
-     */
-    protected Strided1DBuffer() {
-        super(STRIDES);
-        // Initialise navigation
-        shape = new int[1];
-        // strides is created on demand;
-        // suboffsets is always null for this type.
-    }
-
-    /**
      * Provide an instance of Strided1DBuffer with navigation variables initialised,
      * for sub-class use. The buffer ({@link #storage}, {@link #index0}), and the navigation (
      * {@link #shape} array and {@link #stride}) will be initialised from the arguments (which are
@@ -69,27 +45,27 @@
      * 
      * The sub-class constructor should check that the intended access is compatible with this
      * object by calling {@link #checkRequestFlags(int)}. (See the source of
-     * {@link Strided1DWritableBuffer#Strided1DWritableBuffer(int, byte[], int, int, int)}
-     * for an example of this use.)
+     * {@link Strided1DWritableBuffer#Strided1DWritableBuffer(int, byte[], int, int, int)} for an
+     * example of this use.)
      *
      * @param storage raw byte array containing exported data
      * @param index0 index into storage of item[0]
-     * @param length number of items in the slice
+     * @param count number of items in the slice
      * @param stride in between successive elements of the new PyBuffer
      * @throws NullPointerException if storage is null
-     * @throws ArrayIndexOutOfBoundsException if index0, length and
+     * @throws ArrayIndexOutOfBoundsException if index0, count and
      *             stride are inconsistent with storage.length
      */
-    // XXX: "for sub-class use" = should be protected?
-    public Strided1DBuffer(byte[] storage, int index0, int length, int stride)
+    protected Strided1DBuffer(byte[] storage, int index0, int count, int stride)
             throws ArrayIndexOutOfBoundsException, NullPointerException {
-        this();
+        super(STRIDES);
         this.storage = storage;         // Exported data
         this.index0 = index0;           // Index to be treated as item[0]
-        this.shape[0] = length;         // Number of items in exported data
+        this.shape = new int[] {count}; // Number of items in exported data
         this.stride = stride;           // Between items
+        this.strides = new int[] {stride};
 
-        if (length == 0) {
+        if (count == 0) {
             // Nothing to check as we'll make no accesses
             addFeatureFlags(CONTIGUITY);
 
@@ -99,20 +75,20 @@
 
             if (stride == 1) {
                 lo = index0;                                // First byte of item[0]
-                hi = index0 + length;                       // Last byte of item[L-1] + 1
+                hi = index0 + count;                        // Last byte of item[L-1] + 1
                 addFeatureFlags(CONTIGUITY);
 
             } else if (stride > 1) {
                 lo = index0;                                // First byte of item[0]
-                hi = index0 + (length - 1) * stride + 1;    // Last byte of item[L-1] + 1
+                hi = index0 + (count - 1) * stride + 1;     // Last byte of item[L-1] + 1
 
             } else {
                 hi = index0 + 1;                            // Last byte of item[0] + 1
-                lo = index0 + (length - 1) * stride;        // First byte of item[L-1]
+                lo = index0 + (count - 1) * stride;         // First byte of item[L-1]
             }
 
             // Check indices using "all non-negative" trick
-            if ((length | lo | (storage.length - lo) | hi | (storage.length - hi)) < 0) {
+            if ((count | lo | (storage.length - lo) | hi | (storage.length - hi)) < 0) {
                 throw new ArrayIndexOutOfBoundsException();
             }
         }
@@ -122,31 +98,31 @@
      * Provide an instance of Strided1DBuffer on a particular array of bytes specifying
      * a starting index, the number of items in the result, and a byte-indexing stride. The result
      * of byteAt(i) will be equal to storage[index0+stride*i] (whatever
-     * the sign of stride), valid for 0<=i<length. The constructor
+     * the sign of stride), valid for 0<=i<count. The constructor
      * checks that all these indices lie within the storage array (unless
-     * length=0).
+     * count=0).
      * 

      * The constructed PyBuffer meets the consumer's expectations as expressed in the
      * flags argument, or an exception will be thrown if these are incompatible with
      * the type (e.g. the consumer does not specify that it understands the strides array). Note
      * that the actual range in the storage array, the lowest and highest index, is not
-     * explicitly passed, but is implicit in index0, length and
+     * explicitly passed, but is implicit in index0, count and
      * stride. The constructor checks that these indices lie within the
-     * storage array (unless length=0).
+     * storage array (unless count=0).
      *
      * @param flags consumer requirements
      * @param storage raw byte array containing exported data
      * @param index0 index into storage of item[0]
-     * @param length number of items in the slice
+     * @param count number of items in the slice
      * @param stride in between successive elements of the new PyBuffer
      * @throws NullPointerException if storage is null
-     * @throws ArrayIndexOutOfBoundsException if index0, length and
+     * @throws ArrayIndexOutOfBoundsException if index0, count and
      *             stride are inconsistent with storage.length
      * @throws PyException (BufferError) when expectations do not correspond with the type
      */
-    public Strided1DBuffer(int flags, byte[] storage, int index0, int length, int stride)
+    public Strided1DBuffer(int flags, byte[] storage, int index0, int count, int stride)
             throws ArrayIndexOutOfBoundsException, NullPointerException, PyException {
-        this(storage, index0, length, stride);
+        this(storage, index0, count, stride);
         checkRequestFlags(flags);   // Check request is compatible with type
 
     }
@@ -157,69 +133,35 @@
     }
 
     @Override
-    public byte byteAt(int index) throws IndexOutOfBoundsException {
-        return storage[index0 + index * stride];
-    }
-
-    @Override
-    protected int calcIndex(int index) throws IndexOutOfBoundsException {
+    protected final int byteIndex(int index) throws IndexOutOfBoundsException {
+        if (index < 0 || index >= shape[0]) {
+            throw new IndexOutOfBoundsException();
+        }
         return index0 + index * stride;
     }
 
-    @Override
-    protected int calcIndex(int... indices) throws IndexOutOfBoundsException {
-        // BaseBuffer implementation can be simplified since if indices.length!=1 we error.
-        checkDimension(indices.length); // throws if != 1
-        return calcIndex(indices[0]);
-    }
-
-    /**
-     * {@inheritDoc} Strided1DBuffer provides a version optimised for strided bytes in
-     * one dimension.
-     */
-    @Override
-    public void copyTo(int srcIndex, byte[] dest, int destPos, int length)
-            throws IndexOutOfBoundsException {
-        // Data is here in the buffers
-        int s = index0 + srcIndex * stride;
-        int d = destPos;
-
-        // Strategy depends on whether items are laid end-to-end contiguously or there are gaps
-        if (stride == 1) {
-            // stride == itemsize: straight copy of contiguous bytes
-            System.arraycopy(storage, s, dest, d, length);
-
-        } else {
-            // Non-contiguous copy: single byte items
-            int limit = s + length * stride;
-            for (; s != limit; s += stride) {
-                dest[d++] = storage[s];
-            }
-        }
-    }
-
     /**
      * {@inheritDoc}
      * 

      * Strided1DBuffer provides an implementation for slicing already-strided bytes in
      * one dimension. In that case, x(i) = u(r+ip) for i = 0..L-1 where u is the
-     * underlying buffer, and r, p and L are the start, stride and length with
+     * underlying buffer, and r, p and L are the start, stride and count with
      * which x was created from u. Thus y(k) = u(r+sp+kmp), that is, the
      * composite index0 is r+sp and the composite stride is
      * mp.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
 
-        if (length > 0) {
+        if (count > 0) {
             // Translate start relative to underlying buffer
             int compStride = this.stride * stride;
             int compIndex0 = index0 + start * this.stride;
             // Construct a view, taking a lock on the root object (this or this.root)
-            return new SlicedView(getRoot(), flags, storage, compIndex0, length, compStride);
+            return new SlicedView(getRoot(), flags, storage, compIndex0, count, compStride);
 
         } else {
-            // Special case for length==0 where above logic would fail. Efficient too.
+            // Special case for count==0 where above logic would fail. Efficient too.
             return new ZeroByteBuffer.View(getRoot(), flags);
         }
     }
@@ -238,15 +180,6 @@
         return getPointer(indices[0]);
     }
 
-    @Override
-    public int[] getStrides() {
-        if (strides == null) {
-            strides = new int[1];
-            strides[0] = stride;
-        }
-        return strides;
-    }
-
     /**
      * A Strided1DBuffer.SlicedView represents a non-contiguous subsequence of a simple
      * buffer.
@@ -282,6 +215,7 @@
 
         @Override
         public void releaseAction() {
+            // XXX Consider making this automatic within BaseBuffer.release() when getRoot()!=this
             // We have to release the root too if ours was final.
             root.release();
         }
diff --git a/src/org/python/core/buffer/Strided1DWritableBuffer.java b/src/org/python/core/buffer/Strided1DWritableBuffer.java
--- a/src/org/python/core/buffer/Strided1DWritableBuffer.java
+++ b/src/org/python/core/buffer/Strided1DWritableBuffer.java
@@ -14,67 +14,52 @@
      * Provide an instance of Strided1DWritableBuffer on a particular array of bytes
      * specifying a starting index, the number of items in the result, and a byte-indexing stride.
      * The result of byteAt(i) will be equal to storage[index0+stride*i]
-     * (whatever the sign of stride>0), valid for 0<=i<length.
+     * (whatever the sign of stride>0), valid for 0<=i<count.
      * 

      * The constructed PyBuffer meets the consumer's expectations as expressed in the
      * flags argument, or an exception will be thrown if these are incompatible with
      * the type (e.g. the consumer does not specify that it understands the strides array). Note
      * that the actual range in the storage array, the lowest and highest index, is not
-     * explicitly passed, but is implicit in index0, length and
+     * explicitly passed, but is implicit in index0, count and
      * stride. The caller is responsible for checking these fall within the array, or
      * the sub-range the caller is allowed to use.
      *
      * @param flags consumer requirements
      * @param storage raw byte array containing exported data
      * @param index0 index into storage of item[0]
-     * @param length number of items in the slice
+     * @param count number of items in the slice
      * @param stride in between successive elements of the new PyBuffer
      * @throws NullPointerException if storage is null
-     * @throws ArrayIndexOutOfBoundsException if index0, length and
+     * @throws ArrayIndexOutOfBoundsException if index0, count and
      *             stride are inconsistent with storage.length
      * @throws PyException (BufferError) when expectations do not correspond with the type
      */
-    public Strided1DWritableBuffer(int flags, byte[] storage, int index0, int length, int stride)
+    public Strided1DWritableBuffer(int flags, byte[] storage, int index0, int count, int stride)
             throws ArrayIndexOutOfBoundsException, NullPointerException, PyException {
-        super(storage, index0, length, stride);
+        super(storage, index0, count, stride);
         addFeatureFlags(WRITABLE);
         checkRequestFlags(flags);   // Check request is compatible with type
     }
 
+    /**
+     * {@inheritDoc}
+     * 

+     * Declared final returning true in
+     * Strided1DWritableBuffer to make checks unnecessary.
+     */
     @Override
-    public boolean isReadonly() {
+    public final boolean isReadonly() {
         return false;
     }
 
+    /** Do nothing: the buffer is writable. */
     @Override
-    public void storeAt(byte value, int index) throws IndexOutOfBoundsException, PyException {
-        storage[index0 + index * stride] = value;
-    }
+    protected final void checkWritable() {}
 
-    /**
-     * {@inheritDoc} Strided1DWritableBuffer provides a version optimised for strided
-     * bytes in one dimension.
-     */
     @Override
-    public void copyFrom(byte[] src, int srcPos, int destIndex, int length)
-            throws IndexOutOfBoundsException, PyException {
-
-        // Data is here in the buffers
-        int s = srcPos;
-        int d = index0 + destIndex * stride;
-
-        // Strategy depends on whether items are laid end-to-end or there are gaps
-        if (stride == 1) {
-            // Straight copy of contiguous bytes
-            System.arraycopy(src, srcPos, storage, d, length);
-
-        } else {
-            // Non-contiguous copy: single byte items
-            int limit = d + length * stride;
-            for (; d != limit; d += stride) {
-                storage[d] = src[s++];
-            }
-        }
+    protected void storeAtImpl(byte value, int byteIndex) {
+        // Implement directly and don't ask whether read-only
+        storage[byteIndex] = value;
     }
 
     /**
@@ -84,17 +69,17 @@
      * slice.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
 
-        if (length > 0) {
+        if (count > 0) {
             // Translate start relative to underlying buffer
             int compStride = this.stride * stride;
             int compIndex0 = index0 + start * this.stride;
             // Construct a view, taking a lock on the root object (this or this.root)
-            return new SlicedView(getRoot(), flags, storage, compIndex0, length, compStride);
+            return new SlicedView(getRoot(), flags, storage, compIndex0, count, compStride);
 
         } else {
-            // Special case for length==0 where above logic would fail. Efficient too.
+            // Special case for count==0 where above logic would fail. Efficient too.
             return new ZeroByteBuffer.View(getRoot(), flags);
         }
     }
diff --git a/src/org/python/core/buffer/ZeroByteBuffer.java b/src/org/python/core/buffer/ZeroByteBuffer.java
--- a/src/org/python/core/buffer/ZeroByteBuffer.java
+++ b/src/org/python/core/buffer/ZeroByteBuffer.java
@@ -12,7 +12,7 @@
  * operations like {@link #copyTo(byte[], int)}) and {@link #toString()} efficiently do nothing,
  * instead of calling complicated logic that finally does nothing.
  */
-public class ZeroByteBuffer extends BaseBuffer {
+public class ZeroByteBuffer extends BaseArrayBuffer {
 
     /** Shared instance of a zero-length storage. */
     private static final byte[] EMPTY = new byte[0];
@@ -22,19 +22,25 @@
 
     /**
      * Construct an instance of a zero-length buffer, choosing whether it should report itself to be
-     * read-only through {@link #isReadonly()}. This is moot, as any attempt to write to it produces
-     * an {@link IndexOutOfBoundsException}, but it is less surprising for client code that may ask,
-     * if the readability follows that of the object from which the buffer is derived.
+     * read-only through {@link #isReadonly()} or as having a backing array through
+     * {@link #hasArray()}. These properties are moot, as any attempt to write to the pretended
+     * backing array produces an {@link IndexOutOfBoundsException}, but it is less surprising for
+     * client code that may ask, if the results are customary for the exporting object.
      *
      * @param flags consumer requirements
-     * @param readonly set true if readonly
-     * @throws PyException (BufferError) when expectations do not correspond with the type
+     * @param readonly set true if not to be considered writable
+     * @param hasArray set true if to be considered as backed by an array
+     * @throws PyException (BufferError) when client expectations do not correspond with the type
      */
-    public ZeroByteBuffer(int flags, boolean readonly) throws PyException {
-        super(CONTIGUITY | SIMPLE | (readonly ? 0 : WRITABLE));
+    public ZeroByteBuffer(int flags, boolean readonly, boolean hasArray) throws PyException {
+        super(CONTIGUITY | (readonly ? 0 : WRITABLE));
         this.storage = EMPTY;                       // Empty array
         this.shape = SHAPE;                         // {0}
-        this.strides = SimpleBuffer.SIMPLE_STRIDES; // {1}
+        this.strides = BaseBuffer.CONTIG_STRIDES; // {1}
+        if (!hasArray) {
+            // super() knows we have an array, but this truth is inconvenient here.
+            removeFeatureFlags(AS_ARRAY);
+        }
         checkRequestFlags(flags);
     }
 
@@ -47,7 +53,7 @@
      * In a ZeroByteBuffer, the index is always out of bounds.
      */
     @Override
-    protected int calcIndex(int index) throws IndexOutOfBoundsException {
+    protected int byteIndex(int index) throws IndexOutOfBoundsException {
         // This causes all access to the bytes in to throw (since BaseBuffer calls it).
         throw new IndexOutOfBoundsException();
     }
@@ -56,7 +62,7 @@
      * In a ZeroByteBuffer, if the dimensions are right, the index is out of bounds anyway.
      */
     @Override
-    protected int calcIndex(int... indices) throws IndexOutOfBoundsException {
+    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
         // Bootless dimension check takes precedence (for consistency with other buffers)
         checkDimension(indices);
         // This causes all access to the bytes to throw (since BaseBuffer calls it).
@@ -79,28 +85,28 @@
      * In a ZeroByteBuffer, there is simply nothing to copy.
      */
     @Override
-    public void copyTo(int srcIndex, byte[] dest, int destPos, int length)
+    public void copyTo(int srcIndex, byte[] dest, int destPos, int count)
             throws IndexOutOfBoundsException, PyException {
         // Nothing to copy
     }
 
     /**
-     * In a ZeroByteBuffer, there is no room for anything, so this throws unless the source length
-     * is zero.
+     * In a ZeroByteBuffer, there is no room for anything, so this throws unless the source count is
+     * zero.
      */
     @Override
-    public void copyFrom(byte[] src, int srcPos, int destIndex, int length)
+    public void copyFrom(byte[] src, int srcPos, int destIndex, int count)
             throws IndexOutOfBoundsException, PyException {
         if (this.isReadonly()) {
             throw notWritable();
-        } else if (length > 0) {
+        } else if (count > 0) {
             throw new IndexOutOfBoundsException();
         }
     }
 
     /**
-     * In a ZeroByteBuffer, there is no room for anything, so this throws unless the source length
-     * is zero.
+     * In a ZeroByteBuffer, there is no room for anything, so this throws unless the source count is
+     * zero.
      */
     @Override
     public void copyFrom(PyBuffer src) throws IndexOutOfBoundsException, PyException {
@@ -116,8 +122,8 @@
      * as a result, with the export count incremented.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length) {
-        if (start == 0 && length <= 0) {
+    public PyBuffer getBufferSlice(int flags, int start, int count) {
+        if (start == 0 && count <= 0) {
             return this.getBuffer(flags);
         } else {
             throw new IndexOutOfBoundsException();
@@ -129,9 +135,9 @@
      * as a result, with the export count incremented.
      */
     @Override
-    public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
-        // It can't matter what the stride is since length is zero, or there's an error.
-        return getBufferSlice(flags, start, length);
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
+        // It can't matter what the stride is since count is zero, or there's an error.
+        return getBufferSlice(flags, start, count);
     }
 
     /**
@@ -175,7 +181,7 @@
          */
         public View(PyBuffer root, int flags) {
             // Create a new ZeroByteBuffer on who-cares-what byte array
-            super(flags, root.isReadonly());
+            super(flags, root.isReadonly(), root.hasArray());
             // But we still have to get a lease on the root PyBuffer
             this.root = root.getBuffer(FULL_RO);
         }
diff --git a/tests/java/org/python/core/PyBufferTest.java b/tests/java/org/python/core/PyBufferTest.java
--- a/tests/java/org/python/core/PyBufferTest.java
+++ b/tests/java/org/python/core/PyBufferTest.java
@@ -71,13 +71,13 @@
     protected static final int[] sliceSteps = {1, 2, 3, 7};
 
     /** Exception raising requires the Jython interpreter to be initialised **/
-    protected PythonInterpreter interp = new PythonInterpreter();
+    protected static PythonInterpreter interp = new PythonInterpreter();
 
     /** The test material and a buffer created by the test-runner. */
-    private TestSpec spec;
-    ByteMaterial ref;
-    BufferProtocol obj;
-    PyBuffer view;
+    protected TestSpec spec;
+    protected ByteMaterial ref;
+    protected BufferProtocol obj;
+    protected PyBuffer view;
 
     /**
      * Construct an instance to run one test, using one set of test data.
@@ -103,11 +103,11 @@
     /*
      * Values for initialising the exporters.
      */
-    private static final ByteMaterial byteMaterial = new ByteMaterial(10, 16, 3);
-    private static final ByteMaterial abcMaterial = new ByteMaterial("abcdefgh");
-    private static final ByteMaterial stringMaterial = new ByteMaterial("Mon c?t? f?cheux");
-    private static final ByteMaterial emptyMaterial = new ByteMaterial(new byte[0]);
-    private static final ByteMaterial longMaterial = new ByteMaterial(0, LONG, 5);
+    protected static final ByteMaterial byteMaterial = new ByteMaterial(10, 16, 3);
+    protected static final ByteMaterial abcMaterial = new ByteMaterial("abcdefgh");
+    protected static final ByteMaterial stringMaterial = new ByteMaterial("Mon c?t? f?cheux");
+    protected static final ByteMaterial emptyMaterial = new ByteMaterial(new byte[0]);
+    protected static final ByteMaterial longMaterial = new ByteMaterial(0, LONG, 5);
 
     /**
      * Generate test data to be held in the testing framework and used to construct tests. This
@@ -161,6 +161,19 @@
         };
         s.add(stringExporter, stringMaterial);
 
+        // Tests with an buffer implementation directly extending BaseBuffer
+
+        ExporterFactory rollYourOwnExporter = new WritableExporterFactory() {
+
+            @Override
+            public BufferProtocol make(ByteMaterial m) {
+                return new RollYourOwnExporter(m.getBytes());
+            }
+
+        };
+        s.add(rollYourOwnExporter, byteMaterial);
+        s.add(rollYourOwnExporter, emptyMaterial);
+
         // Tests with PyByteArray
 
         ExporterFactory pyByteArrayExporter = new WritableExporterFactory() {
@@ -990,10 +1003,12 @@
     @Test
     public void testIsContiguous() {
         announce("isContiguous");
-        // True for all test material and orders (since 1-dimensional)
+        // All test material is 1-dimensional so it's fairly simple and same for all orders
+        int ndim = spec.shape[0], stride = spec.getStride(), itemsize = spec.getItemsize();
+        boolean contig = ndim < 2 || stride == itemsize;
         for (String orderMsg : validOrders) {
             char order = orderMsg.charAt(0);
-            assertTrue(orderMsg, view.isContiguous(order));
+            assertEquals(orderMsg, view.isContiguous(order), contig);
         }
     }
 
@@ -1069,17 +1084,17 @@
     }
 
     /*
-     * ------------------------------------------------------------------------------------------- A
-     * series of custom exporters to permit testing abstracted from the Jython interpreter. These
+     * --------------------------------------------------------------------------------------------
+     * A series of custom exporters to permit testing abstracted from the Jython interpreter. These
      * use the implementation classes in org.python.core.buffer in ways very similar to the
      * implementations of bytearray and str.
-     * -------------------------------------------------------------------------------------------
+     * --------------------------------------------------------------------------------------------
      */
     /**
-     * A class to act as an exporter that uses the SimpleReadonlyBuffer. The exporter exports a new
-     * PyBuffer object to each consumer (although each references the same internal storage) and it
-     * does not track their fate. You are most likely to use this approach with an exporting object
-     * that is immutable (or at least fixed in size).
+     * A class to act as an exporter that uses the SimpleBuffer. The exporter exports a new PyBuffer
+     * object to each consumer (although each references the same internal storage) and it does not
+     * track their fate. You are most likely to use this approach with an exporting object that is
+     * immutable (or at least fixed in size).
      */
     static class SimpleExporter implements BufferProtocol {
 
@@ -1109,7 +1124,8 @@
         protected Reference export;
 
         /**
-         * Try to re-use existing exported buffer, or return null if can't.
+         * Try to re-use existing exported buffer, or return null if can't: modelled after the
+         * buffer re-use strategy in {@link PyByteArray}.
          */
         protected BaseBuffer getExistingBuffer(int flags) {
             BaseBuffer pybuf = null;
@@ -1191,7 +1207,7 @@
      * avoiding the cost of duplicate buffers. This is the case with PyByteArray, which prohibits
      * operations that would resize it, while there are outstanding exports.
      */
-    static class SimpleWritableExporter extends TestableExporter {
+    private static class SimpleWritableExporter extends TestableExporter {
 
         protected byte[] storage;
 
@@ -1226,4 +1242,131 @@
 
     }
 
+    /** A class to act as an exporter that uses the RollYourOwnBuffer. */
+    private static class RollYourOwnExporter extends TestableExporter {
+
+        protected byte[] storage;
+
+        public RollYourOwnExporter(byte[] storage) {
+            this.storage = storage;
+        }
+
+        @Override
+        public PyBuffer getBuffer(int flags) {
+            // If we have already exported a buffer it may still be available for re-use
+            BaseBuffer pybuf = getExistingBuffer(flags);
+            if (pybuf == null) {
+                // No existing export we can re-use
+                pybuf = new RollYourOwnArrayBuffer(flags, storage);
+                // Hold a reference for possible re-use
+                export = new WeakReference(pybuf);
+            }
+            return pybuf;
+        }
+
+    }
+
+    /**
+     * Minimal extension of BaseBuffer in order to test the default implementations there. They're
+     * slow, so mostly we override them in the implementations BaseArrayBuffer and BaseNIOBuffer,
+     * but they still have to be correct. The class represents a one-dimensional, strided array of
+     * bytes, so it can represent a slice of itself.
+     */
+    private static class RollYourOwnArrayBuffer extends BaseBuffer {
+
+        final static int FEATURES = PyBUF.WRITABLE | PyBUF.AS_ARRAY;
+
+        final byte[] storage;
+        final PyBuffer root;
+
+        /**
+         * Create a buffer view of the entire array.
+         *
+         * @param flags consumer requirements
+         * @param storage byte array exported in its entirety
+         */
+        public RollYourOwnArrayBuffer(int flags, byte[] storage) {
+            this(null /* =this */, flags, storage, 0, storage.length, 1);
+        }
+
+        /**
+         * Construct a slice of a one-dimensional byte buffer.
+         *
+         * @param root on which release must be called when this is released
+         * @param flags consumer requirements
+         * @param storage raw byte array containing exported data
+         * @param index0 index into storage of item[0]
+         * @param length number of items in the slice
+         * @param stride in between successive elements of the new PyBuffer
+         * @throws PyException (BufferError) when expectations do not correspond with the type
+         */
+        public RollYourOwnArrayBuffer(PyBuffer root, int flags, byte[] storage, int index0,
+                int length, int stride) throws ArrayIndexOutOfBoundsException,
+                NullPointerException, PyException {
+            // Client will need to navigate using shape and strides if this is a slice
+            super(FEATURES | ((index0 == 0 && stride == 1) ? 0 : PyBUF.STRIDES));
+            this.storage = storage;
+            this.index0 = index0;
+            shape = new int[] {length};
+            strides = new int[] {stride};
+            // Check the potential index range
+            if (length > 0) {
+                int end = index0 + (length - 1) * stride;
+                final int END = storage.length - 1;
+                if (index0 < 0 || index0 > END || end < 0 || end > END) {
+                    throw new IndexOutOfBoundsException();
+                }
+            }
+            // Check client is compatible
+            checkRequestFlags(flags);
+            // Get a lease on the root PyBuffer (read-only). Last in case a check above fails.
+            if (root == null) {
+                this.root = this;
+            } else {
+                this.root = root.getBuffer(FULL_RO);
+            }
+        }
+
+        @Override
+        protected PyBuffer getRoot() {
+            return root;
+        }
+
+        @Override
+        public void releaseAction() {
+            // XXX Consider making this automatic within BaseBuffer.release() when getRoot()!=this
+            /*
+             * ... so that {@link #release()} takes care of this: sub-classes should not propagate
+             * the release themselves when overriding {@link #releaseAction()}.
+             */
+            // We have to release the root too if ours was final and we are not that root.
+            if (root != this) {
+                root.release();
+            }
+        }
+
+        @Override
+        public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
+            int newStart = index0 + start * strides[0];
+            int newStride = strides[0] * stride;
+            return new RollYourOwnArrayBuffer(root, flags, storage, newStart, length, newStride);
+        }
+
+        @Override
+        public ByteBuffer getNIOByteBufferImpl() {
+            return ByteBuffer.wrap(storage);
+        }
+
+        @Override
+        protected byte byteAtImpl(int byteIndex) {
+            return storage[byteIndex];
+        }
+
+        @Override
+        protected void storeAtImpl(byte value, int byteIndex) throws IndexOutOfBoundsException,
+                PyException {
+            storage[byteIndex] = value;
+        }
+
+    }
 }
diff --git a/tests/java/org/python/core/PyBufferTestSupport.java b/tests/java/org/python/core/PyBufferTestSupport.java
--- a/tests/java/org/python/core/PyBufferTestSupport.java
+++ b/tests/java/org/python/core/PyBufferTestSupport.java
@@ -260,7 +260,7 @@
         /** Either {@link PyBUF#FULL_RO} or {@link PyBUF#FULL} according to {@link #readonly}. */
         final int flags;
 
-        /** Allowable basic flag combinations, such as */
+        /** Allowable basic flag combinations, such as {@link PyBUF#STRIDES}. */
         final int[] validFlags;
 
         /** Allowable additional flag combinations, such as {@link PyBUF#FORMAT} */

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sat Aug 27 09:12:25 2016
From: jython-checkins at python.org (jeff.allen)
Date: Sat, 27 Aug 2016 13:12:25 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Add_PyBuffer=2EbyteIndex_me?=
 =?utf-8?q?thods=2E?=
Message-ID: <20160827131225.45636.42843.8DD0C532@psf.io>

https://hg.python.org/jython/rev/1cb1ab1e53f3
changeset:   7946:1cb1ab1e53f3
user:        Jeff Allen 
date:        Thu Jun 30 10:02:08 2016 +0100
summary:
  Add PyBuffer.byteIndex methods.

Allow buffers to provide their indexing polynomial. This makes
unnecessary methods returning a Pointer or ByteBuffer ready-positioned
at a particular index. Minor impacts throughout the buffer
implementations.

files:
  src/org/python/core/PyBuffer.java                  |  55 +++++----
  src/org/python/core/buffer/BaseArrayBuffer.java    |   2 +-
  src/org/python/core/buffer/BaseBuffer.java         |  53 +-------
  src/org/python/core/buffer/BaseNIOBuffer.java      |  15 +-
  src/org/python/core/buffer/SimpleBuffer.java       |   2 +-
  src/org/python/core/buffer/SimpleNIOBuffer.java    |   2 +-
  src/org/python/core/buffer/SimpleStringBuffer.java |   5 +-
  src/org/python/core/buffer/Strided1DBuffer.java    |   2 +-
  src/org/python/core/buffer/Strided1DNIOBuffer.java |   2 +-
  src/org/python/core/buffer/ZeroByteBuffer.java     |   4 +-
  tests/java/org/python/core/PyBufferTest.java       |  53 ---------
  11 files changed, 56 insertions(+), 139 deletions(-)


diff --git a/src/org/python/core/PyBuffer.java b/src/org/python/core/PyBuffer.java
--- a/src/org/python/core/PyBuffer.java
+++ b/src/org/python/core/PyBuffer.java
@@ -238,10 +238,39 @@
      */
     public PyBuffer getBufferSlice(int flags, int start, int count, int stride);
 
-    // java.nio access to actual storage
+    // Access to underlying byte-oriented storage
     //
 
     /**
+     * Convert an item index (for a one-dimensional buffer) to an absolute byte index in the storage
+     * shared by the exporter. The storage exported as a PyBuffer is a linearly-indexed
+     * sequence of bytes, although it may not actually be a heap-allocated Java byte[]
+     * object. The purpose of this method is to allow the exporter to define the relationship
+     * between the item index (as used in {@link #byteAt(int)}) and the byte-index (as used with the
+     * ByteBuffer returned by {@link #getNIOByteBuffer()}). See
+     * {@link #byteIndex(int[])} for discussion of the multi-dimensional case.
+     *
+     * @param index item-index from consumer
+     * @return corresponding byte-index in actual storage
+     */
+    // Should it throw IndexOutOfBoundsException if the index <0 or ≥shape[0]PyBuffer is a linearly-indexed sequence of
+     * bytes, although it may not actually be a heap-allocated Java byte[] object. The
+     * purpose of this method is to allow the exporter to define the relationship between the item
+     * index (as used in {@link #byteAt(int...)} and the byte-index (as used with the
+     * ByteBuffer returned by {@link #getNIOByteBuffer()}).
+     *
+     * @param indices n-dimensional item-index from consumer
+     * @return corresponding byte-index in actual storage
+     */
+    // Should it throw IndexOutOfBoundsException if any index <0 or ≥shape[i]?
+    int byteIndex(int... indices);
+
+    /**
      * Obtain a {@link java.nio.ByteBuffer} giving access to the bytes that hold the data being
      * exported by the original object. The position of the buffer is at the first byte of the item
      * with zero index (quite possibly not the lowest valid byte-index), the limit of the buffer is
@@ -271,30 +300,6 @@
     ByteBuffer getNIOByteBuffer();
 
     /**
-     * Obtain a {@link java.nio.ByteBuffer} giving access to the bytes that hold the data being
-     * exported to the consumer, and positioned at a particular index.
-     * 

-     * Essentially this saves the client from computing the byte offset of a particular index. The
-     * client is free to navigate the underlying byte data through the ByteBuffer.
-     *
-     * @param index in the buffer to position the pointer
-     * @return a ByteBuffer onto the exported data contents, positioned at the indexed item.
-     */
-    ByteBuffer getNIOByteBuffer(int index);
-
-    /**
-     * Obtain a {@link java.nio.ByteBuffer} giving access to the bytes that hold the data being
-     * exported to the consumer, and positioned at a particular multi-dimensional index.
-     * 

-     * Essentially this saves the client from computing the byte offset of a particular index. The
-     * client is free to navigate the underlying byte data through the ByteBuffer.
-     *
-     * @param indices multidimensional index at which to position the pointer
-     * @return a ByteBuffer onto the exported data contents, positioned at the indexed item.
-     */
-    ByteBuffer getNIOByteBuffer(int... indices);
-
-    /**
      * Report whether the exporter is able to offer direct access to the exported storage as a Java
      * byte array (through the API that involves class {@link Pointer}), or only supports the
      * abstract API. See also {@link PyBUF#AS_ARRAY}.
diff --git a/src/org/python/core/buffer/BaseArrayBuffer.java b/src/org/python/core/buffer/BaseArrayBuffer.java
--- a/src/org/python/core/buffer/BaseArrayBuffer.java
+++ b/src/org/python/core/buffer/BaseArrayBuffer.java
@@ -57,7 +57,7 @@
     }
 
     @Override
-    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
+    public int byteIndex(int... indices) throws IndexOutOfBoundsException {
         // BaseBuffer implementation can be simplified since if indices.length!=1 we error.
         checkDimension(indices.length); // throws if != 1
         return byteIndex(indices[0]);
diff --git a/src/org/python/core/buffer/BaseBuffer.java b/src/org/python/core/buffer/BaseBuffer.java
--- a/src/org/python/core/buffer/BaseBuffer.java
+++ b/src/org/python/core/buffer/BaseBuffer.java
@@ -351,16 +351,13 @@
         storeAtImpl(value, byteIndex(indices));
     }
 
-    /**
-     * Convert an item index (for a one-dimensional buffer) to a checked absolute byte index in the
-     * actual storage being shared by the exporter. See {@link #byteIndex(int[])} for discussion.
-     *
-     * @param index item-index from consumer
-     * @return corresponding byte-index in actual storage
-     * @throws IndexOutOfBoundsException if the index <0 or ≥shape[0]
+    /*
+     * In this implementation, we throw IndexOutOfBoundsException if index < 0 or > shape[0], but we
+     * could rely on the array or ByteBuffer checks when indexing, especially the latter since
+     * position is checked against limit.
      */
-    // XXX Consider making this part of the PyBuffer interface
-    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+    @Override
+    public int byteIndex(int index) throws IndexOutOfBoundsException {
         // Treat as one-dimensional
         if (index < 0 || index >= shape[0]) {
             throw new IndexOutOfBoundsException();
@@ -368,25 +365,11 @@
         return index0 + index * strides[0];
     }
 
-    /**
-     * Convert a multi-dimensional item index (if we are not using indirection) to an absolute byte
-     * index in the actual storage array being shared by the exporter. The purpose of this method is
-     * to allow a sub-class to define, in one place, an indexing calculation that maps the index as
-     * provided by the consumer into an index in the storage known to the buffer.
-     * 

-     * In the usual case where the storage is referenced via a storage member and
-     * {@link #index0} member, the buffer implementation may use storage[byteIndex(i)]
-     * to reference the (first byte of) the item x[i]. This is what the default implementation of
-     * accessors in BaseArrayBuffer will do. In the simplest cases, calling
-     * byteIndex may be an overhead to avoid, and an implementation will specialise the
-     * accessors. The default implementation here is suited to N-dimensional arrays.
-     *
-     * @param indices n-dimensional item-index from consumer
-     * @return corresponding byte-index in actual storage
-     * @throws IndexOutOfBoundsException if any index <0 or ≥shape[i]
+    /*
+     * In this implementation, we throw IndexOutOfBoundsException if any index[i] < 0 or > shape[i].
      */
-    // XXX Consider making this part of the PyBuffer interface
-    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
+    @Override
+    public int byteIndex(int... indices) throws IndexOutOfBoundsException {
         final int N = checkDimension(indices);
         // In general: index0 + sum(k=0,N-1) indices[k]*strides[k]
         int index = index0;
@@ -653,22 +636,6 @@
     }
 
     @Override
-    public ByteBuffer getNIOByteBuffer(int index) {
-        // The buffer spans the whole storage but is positioned at index
-        ByteBuffer b = getNIOByteBufferImpl();
-        b.position(byteIndex(index));
-        return b;
-    }
-
-    @Override
-    public ByteBuffer getNIOByteBuffer(int... indices) {
-        // The buffer spans the whole storage but is positioned at indices[]
-        ByteBuffer b = getNIOByteBufferImpl();
-        b.position(byteIndex(indices));
-        return b;
-    }
-
-    @Override
     public boolean hasArray() {
         // AS_ARRAY is a non-navigation flag, so is inverted in gFeatureFlags
         return (gFeatureFlags & AS_ARRAY) == 0; // i.e. featureFlags & AS_ARRAY is true
diff --git a/src/org/python/core/buffer/BaseNIOBuffer.java b/src/org/python/core/buffer/BaseNIOBuffer.java
--- a/src/org/python/core/buffer/BaseNIOBuffer.java
+++ b/src/org/python/core/buffer/BaseNIOBuffer.java
@@ -78,7 +78,7 @@
     }
 
     @Override
-    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
+    public int byteIndex(int... indices) throws IndexOutOfBoundsException {
         // BaseBuffer implementation can be simplified since if indices.length!=1 we error.
         checkDimension(indices.length); // throws if != 1
         return byteIndex(indices[0]);
@@ -123,7 +123,8 @@
 
         if (count > 0) {
 
-            ByteBuffer src = getNIOByteBuffer(srcIndex);
+            ByteBuffer src = getNIOByteBuffer();
+            int pos = byteIndex(srcIndex);
 
             // Pick up attributes necessary to choose an efficient copy strategy
             int itemsize = getItemsize();
@@ -132,12 +133,11 @@
             // Strategy depends on whether items are laid end-to-end contiguously or there are gaps
             if (stride == itemsize) {
                 // stride == itemsize: straight copy of contiguous bytes
-                src.limit(src.position() + count * itemsize);
+                src.limit(pos + count * itemsize).position(pos);
                 dest.put(src);
 
             } else if (itemsize == 1) {
                 // Non-contiguous copy: single byte items
-                int pos = src.position();
                 for (int i = 0; i < count; i++) {
                     src.position(pos);
                     dest.put(src.get());
@@ -146,7 +146,6 @@
 
             } else {
                 // Non-contiguous copy: each time, copy itemsize bytes then skip
-                int pos = src.position();
                 for (int i = 0; i < count; i++) {
                     src.limit(pos + itemsize).position(pos);
                     dest.put(src);
@@ -184,7 +183,8 @@
 
         if (count > 0) {
 
-            ByteBuffer dst = getNIOByteBuffer(dstIndex);
+            ByteBuffer dst = getNIOByteBuffer();
+            int pos = byteIndex(dstIndex);
 
             // Pick up attributes necessary to choose an efficient copy strategy
             int itemsize = getItemsize();
@@ -194,11 +194,11 @@
             // Strategy depends on whether items are laid end-to-end or there are gaps
             if (skip == 0) {
                 // Straight copy of contiguous bytes
+                dst.position(pos);
                 dst.put(src);
 
             } else if (itemsize == 1) {
                 // Non-contiguous copy: single byte items
-                int pos = dst.position();
                 for (int i = 0; i < count; i++) {
                     dst.position(pos);
                     dst.put(src.get());
@@ -208,7 +208,6 @@
 
             } else {
                 // Non-contiguous copy: each time, copy itemsize bytes at a time
-                int pos = dst.position();
                 for (int i = 0; i < count; i++) {
                     dst.position(pos);
                     // Delineate the next itemsize bytes in the src
diff --git a/src/org/python/core/buffer/SimpleBuffer.java b/src/org/python/core/buffer/SimpleBuffer.java
--- a/src/org/python/core/buffer/SimpleBuffer.java
+++ b/src/org/python/core/buffer/SimpleBuffer.java
@@ -104,7 +104,7 @@
      * and an item size of 1.
      */
     @Override
-    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+    public int byteIndex(int index) throws IndexOutOfBoundsException {
         if (index < 0 || index >= shape[0]) {
             throw new IndexOutOfBoundsException();
         }
diff --git a/src/org/python/core/buffer/SimpleNIOBuffer.java b/src/org/python/core/buffer/SimpleNIOBuffer.java
--- a/src/org/python/core/buffer/SimpleNIOBuffer.java
+++ b/src/org/python/core/buffer/SimpleNIOBuffer.java
@@ -112,7 +112,7 @@
     }
 
     @Override
-    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+    public final int byteIndex(int index) throws IndexOutOfBoundsException {
         return index0 + index;
     }
 
diff --git a/src/org/python/core/buffer/SimpleStringBuffer.java b/src/org/python/core/buffer/SimpleStringBuffer.java
--- a/src/org/python/core/buffer/SimpleStringBuffer.java
+++ b/src/org/python/core/buffer/SimpleStringBuffer.java
@@ -68,7 +68,7 @@
      * In SimpleStringBuffer we can simply return the argument.
      */
     @Override
-    protected final int byteIndex(int index) {
+    public final int byteIndex(int index) {
         // We do not check the index because String will do it for us.
         return index;
     }
@@ -97,8 +97,7 @@
     public PyBuffer getBufferSlice(int flags, int start, int count) {
         if (count > 0) {
             // The new string content is just a sub-string.
-            return new SimpleStringView(getRoot(), flags,
-                    bufString.substring(start, start + count));
+            return new SimpleStringView(getRoot(), flags, bufString.substring(start, start + count));
         } else {
             // Special case for count==0 where start out of bounds sometimes raises exception.
             return new ZeroByteBuffer.View(getRoot(), flags);
diff --git a/src/org/python/core/buffer/Strided1DBuffer.java b/src/org/python/core/buffer/Strided1DBuffer.java
--- a/src/org/python/core/buffer/Strided1DBuffer.java
+++ b/src/org/python/core/buffer/Strided1DBuffer.java
@@ -129,7 +129,7 @@
     }
 
     @Override
-    protected final int byteIndex(int index) throws IndexOutOfBoundsException {
+    public final int byteIndex(int index) throws IndexOutOfBoundsException {
         if (index < 0 || index >= shape[0]) {
             throw new IndexOutOfBoundsException();
         }
diff --git a/src/org/python/core/buffer/Strided1DNIOBuffer.java b/src/org/python/core/buffer/Strided1DNIOBuffer.java
--- a/src/org/python/core/buffer/Strided1DNIOBuffer.java
+++ b/src/org/python/core/buffer/Strided1DNIOBuffer.java
@@ -138,7 +138,7 @@
     }
 
     @Override
-    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+    public final int byteIndex(int index) throws IndexOutOfBoundsException {
         return index0 + index * stride;
     }
 
diff --git a/src/org/python/core/buffer/ZeroByteBuffer.java b/src/org/python/core/buffer/ZeroByteBuffer.java
--- a/src/org/python/core/buffer/ZeroByteBuffer.java
+++ b/src/org/python/core/buffer/ZeroByteBuffer.java
@@ -47,7 +47,7 @@
      * In a ZeroByteBuffer, the index is always out of bounds.
      */
     @Override
-    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+    public int byteIndex(int index) throws IndexOutOfBoundsException {
         // This causes all access to the bytes in to throw (since BaseBuffer calls it).
         throw new IndexOutOfBoundsException();
     }
@@ -56,7 +56,7 @@
      * In a ZeroByteBuffer, if the dimensions are right, the index is out of bounds anyway.
      */
     @Override
-    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
+    public int byteIndex(int... indices) throws IndexOutOfBoundsException {
         // Bootless dimension check takes precedence (for consistency with other buffers)
         checkDimension(indices);
         // This causes all access to the bytes to throw (since BaseBuffer calls it).
diff --git a/tests/java/org/python/core/PyBufferTest.java b/tests/java/org/python/core/PyBufferTest.java
--- a/tests/java/org/python/core/PyBufferTest.java
+++ b/tests/java/org/python/core/PyBufferTest.java
@@ -1061,59 +1061,6 @@
 
     }
 
-    /** Test method for {@link org.python.core.PyBuffer#getNIOByteBuffer(int)}. */
-    @Test
-    public void testGetNIOByteBufferInt() {
-        announce("getNIOByteBuffer (int)");
-
-        int n = ref.length, itemsize = view.getItemsize();
-        byte[] exp = new byte[itemsize], bytes = ref.bytes;
-
-        for (int i = 0; i < n; i++) {
-            // Expected result is one item (allow for itemsize)
-            int p = i * itemsize;
-            for (int j = 0; j < itemsize; j++) {
-                exp[j] = bytes[p + j];
-            }
-            // Get buffer and check for correct data at bb.position()
-            ByteBuffer bb = view.getNIOByteBuffer(i);
-            ByteBufferTestSupport.assertBytesEqual("getNIOByteBuffer(int) value", exp, bb);
-        }
-    }
-
-    /** Test method for {@link org.python.core.PyBuffer#getNIOByteBuffer(int[])}. */
-    @Test
-    public void testGetNIOByteBufferIntArray() {
-        int[] index = new int[1];
-        announce("getNIOByteBuffer (n-dim)");
-
-        int n = ref.length, itemsize = view.getItemsize();
-        byte[] exp = new byte[itemsize], bytes = ref.bytes;
-
-        for (int i = 0; i < n; i++) {
-            // Expected result is one item (allow for itemsize)
-            int p = i * itemsize;
-            for (int j = 0; j < itemsize; j++) {
-                exp[j] = bytes[p + j];
-            }
-
-            // Get buffer and check for correct data at bb.position()
-            index[0] = i;
-            ByteBuffer bb = view.getNIOByteBuffer(index);
-            ByteBufferTestSupport.assertBytesEqual("getNIOByteBuffer(int[]) value", exp, bb);
-        }
-
-        // Check 2D index throws
-        try {
-            view.getNIOByteBuffer(0, 0);
-            fail("Use of 2D index did not raise exception");
-        } catch (PyException pye) {
-            // Expect BufferError
-            // XXX ... but should it be TypeError here?
-            assertEquals(Py.BufferError, pye.type);
-        }
-    }
-
     /** Test method for {@link org.python.core.PyBuffer#hasArray()}. */
     @Test
     public void testHasArray() {

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sat Aug 27 09:12:24 2016
From: jython-checkins at python.org (jeff.allen)
Date: Sat, 27 Aug 2016 13:12:24 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Add_a_test_of_PyBuffer=2Eco?=
 =?utf-8?q?pyFrom=28PyBuffer=29?=
Message-ID: <20160827131224.18012.24802.7A7EF9FC@psf.io>

https://hg.python.org/jython/rev/f02de625933c
changeset:   7944:f02de625933c
user:        Jeff Allen 
date:        Sat Jun 25 10:32:17 2016 +0100
summary:
  Add a test of PyBuffer.copyFrom(PyBuffer)

Simply missing previously, but also a prelude to fixing the bug in the
overlap-copy in memoryview.

files:
  src/org/python/core/buffer/BaseBuffer.java          |    1 +
  tests/java/org/python/core/PyBufferTest.java        |  148 +++++++++-
  tests/java/org/python/core/PyBufferTestSupport.java |    8 +-
  3 files changed, 145 insertions(+), 12 deletions(-)


diff --git a/src/org/python/core/buffer/BaseBuffer.java b/src/org/python/core/buffer/BaseBuffer.java
--- a/src/org/python/core/buffer/BaseBuffer.java
+++ b/src/org/python/core/buffer/BaseBuffer.java
@@ -531,6 +531,7 @@
     @Override
     public void copyFrom(PyBuffer src) throws IndexOutOfBoundsException, PyException {
 
+        checkDimension(1);
         checkWritable();
 
         int itemsize = getItemsize();
diff --git a/tests/java/org/python/core/PyBufferTest.java b/tests/java/org/python/core/PyBufferTest.java
--- a/tests/java/org/python/core/PyBufferTest.java
+++ b/tests/java/org/python/core/PyBufferTest.java
@@ -21,6 +21,7 @@
 import org.python.core.PyBufferTestSupport.ReadonlyExporterFactory;
 import org.python.core.PyBufferTestSupport.SlicedTestSpec;
 import org.python.core.PyBufferTestSupport.TestSpec;
+import org.python.core.PyBufferTestSupport.TestSpec.ObjectAndView;
 import org.python.core.PyBufferTestSupport.WritableExporterFactory;
 import org.python.core.buffer.BaseBuffer;
 import org.python.core.buffer.SimpleBuffer;
@@ -130,14 +131,7 @@
 
         // Tests using local types of exporter
 
-        ExporterFactory simpleExporter = new ReadonlyExporterFactory() {
-
-            @Override
-            public BufferProtocol make(ByteMaterial m) {
-                return new SimpleExporter(m.getBytes());
-            }
-
-        };
+        ExporterFactory simpleExporter = new SimpleExporterFactory();
         s.add(simpleExporter, byteMaterial);
 
         ExporterFactory simpleWritableExporter = new WritableExporterFactory() {
@@ -562,6 +556,134 @@
         }
     }
 
+    /** Test method for {@link org.python.core.PyBuffer#copyFrom(byte[], int, int, int)}. */
+    @Test
+    public void testCopyFromPyBuffer() {
+        announce("copyFrom");
+
+        /*
+         * The test material (this time) presents a view that has n items of size i, that are spaced
+         * in the underlying buffer with stride s.
+         */
+        int n = spec.ref.length;
+        int s = spec.getStride();
+        int i = spec.getItemsize(); // = 1 in all test cases at time of writing
+
+        // The material we copy to it should have these strides:
+        int[] srcStrides;
+        if (n < 2) {
+            srcStrides = new int[] {i};
+        } else if (s > 2 * i || s < -2 * i) {
+            srcStrides = new int[] {i, s - i, s, s + i, -s + i, -s, -s - i};
+        } else if (s == 2 * i || s == -2 * i) {
+            srcStrides = new int[] {i, 2 * i, 3 * i, -i, -2 * i, -3 * i};
+        } else { // ( s==i || s==-i )
+            srcStrides = new int[] {i, 2 * i, -i, -2 * i};
+        }
+
+        // Also need the maximum absolute value
+        int maxStride = 0;
+        for (int t : srcStrides) {
+            if (t > maxStride) {
+                maxStride = t;
+            } else if (-t > maxStride) {
+                maxStride = -t;
+            }
+        }
+
+        // And these offsets to the lowest-indexed source item
+        int maxOffset = n + 1;
+        int[] srcOffsets = new int[] {0, (maxOffset + 1) / 3, maxOffset};
+
+        // Make the source material to copy from, big enough to accommodate n strides
+        int srcMaterialSize = n * maxStride + maxOffset;
+        ByteMaterial srcMaterial = new ByteMaterial(48, srcMaterialSize, i);
+
+        /*
+         * Now we need a series of PyBuffer views on the source data, sliced and offset according to
+         * the offset and stride values we have enumerated. We'd like to use the same factory as the
+         * current test view (this.view), because copy from its own type might be optimised, and a
+         * different, bog-standard factory to test the general case.
+         */
+        ExporterFactory[] factories = {spec.factory, new SimpleExporterFactory()};
+
+        for (ExporterFactory factory : factories) {
+
+            /*
+             * We'll use the same apparatus to create the source buffer as we use to make the test
+             * cases. The specifications for them will all be derived from this one:
+             */
+            TestSpec original = new TestSpec(factory, srcMaterial);
+
+            /*
+             * Do this where the pattern of indices constituting src overlaps (or not) the pattern
+             * of view in challenging ways, including greater and smaller strides.
+             */
+
+            for (int stride : srcStrides) {
+                for (int offset : srcOffsets) {
+                    int start = (stride > 0) ? offset : srcMaterialSize - offset - i;
+                    doTestCopyFrom(original, start, n, stride);
+                }
+            }
+        }
+
+    }
+
+    // XXX Separately test where src is a view on is the same object.
+
+
+
+    /** Helper function for {@link #testCopyFromPyBuffer()}
+     */
+    private void doTestCopyFrom(TestSpec original, int start, int n, int stride) {
+
+        // Derive sliced test material from the original
+        TestSpec srcSpec = new SlicedTestSpec(original, 1, start, n, stride);
+        ObjectAndView pair = srcSpec.makePair();
+        PyBuffer src = pair.view;
+        byte[] srcBytes = srcSpec.ref.bytes;
+
+        // And for the test object
+        int s = spec.getStart();
+        int p = spec.getStride();
+        String srcName = pair.obj.getClass().getSimpleName();
+        if (verbosity > 1) {
+            System.out.printf("  copy src[%d:%d:%d] %s(%d) to obj[%d:%d:%d]\n",
+                    start, start+n*stride, stride, srcName,
+                    n, s, s + n * p, p);
+        }
+
+        // Initialise the destination object and view (have to do each time) from spec
+        createObjAndView();
+
+        // Our test is against the underlying object of which the view may be a slice
+        TestSpec underlying = spec.getOriginal();
+        PyBuffer underlyingView = obj.getBuffer(underlying.flags & ~PyBUF.WRITABLE);
+        byte[] before = bytesFromByteAt(underlyingView);
+
+        if (!spec.readonly) {
+            // This is the call we are testing (a write operation).
+            view.copyFrom(src);
+
+            // Our test is against the underlying object of which the view may be a slice
+            byte[] after = bytesFromByteAt(underlyingView);
+
+            // Test that the corresponding bytes of the underlying object match data copied in
+            ByteBufferTestSupport.checkWriteCorrect(before, after, srcBytes, 0, n, 1, s, p);
+
+        } else {
+            // Should fail (write operation)
+            try {
+                view.copyFrom(src);
+                fail("Write access not prevented: " + spec);
+            } catch (PyException pye) {
+                // Expect TypeError only if the buffer was readonly
+                assertEquals(Py.TypeError, pye.type);
+            }
+        }
+    }
+
     /**
      * Test method for {@link org.python.core.BufferProtocol#getBuffer()} and
      * {@link org.python.core.PyBuffer#getBuffer()}.
@@ -1116,6 +1238,16 @@
 
     }
 
+    /** A factory for SimpleBuffer objects used in genTestSpects and some tests. */
+    private static class SimpleExporterFactory extends ReadonlyExporterFactory {
+
+        @Override
+        public BufferProtocol make(ByteMaterial m) {
+            return new SimpleExporter(m.getBytes());
+        }
+
+    }
+
     /**
      * Base class of certain exporters that permit testing abstracted from the Jython interpreter.
      */
diff --git a/tests/java/org/python/core/PyBufferTestSupport.java b/tests/java/org/python/core/PyBufferTestSupport.java
--- a/tests/java/org/python/core/PyBufferTestSupport.java
+++ b/tests/java/org/python/core/PyBufferTestSupport.java
@@ -467,19 +467,19 @@
          * specification.
          *
          * @param parent specification of byte buffer to slice
-         * @param size number of consecutive bytes forming one item
+         * @param itemsize number of consecutive bytes forming one item
          * @param first byte-index in the parent of byte 0 of item 0 the result
          * @param count number of items in the slice
          * @param step byte-index increment in the parent between items
          */
-        SlicedTestSpec(TestSpec parent, int size, int first, int count, int step) {
-            super(parent, parent.ref.slice(size, first, count, step), new int[] {count},
+        SlicedTestSpec(TestSpec parent, int itemsize, int first, int count, int step) {
+            super(parent, parent.ref.slice(itemsize, first, count, step), new int[] {count},
                     new int[1], strided1DFlags, strided1DTassles);
             // It only seems to make sense for byte-array parent (or does all scale?)
             if (parent.getItemsize() != 1) {
                 throw new IllegalArgumentException("Only byte-array parent supported");
             }
-            this.itemsize = size;
+            this.itemsize = itemsize;
             // Write these down verbatim for subsequent call to getBufferSlice
             this.first = first;
             this.count = count;

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sat Aug 27 09:12:24 2016
From: jython-checkins at python.org (jeff.allen)
Date: Sat, 27 Aug 2016 13:12:24 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Refactor_to_introduce_Base1?=
 =?utf-8?q?DBuffer=2E?=
Message-ID: <20160827131224.18218.73282.89AB4D53@psf.io>

https://hg.python.org/jython/rev/a3abfca10951
changeset:   7943:a3abfca10951
user:        Jeff Allen 
date:        Thu Jun 23 12:52:53 2016 +0100
summary:
  Refactor to introduce Base1DBuffer.

Reduces duplication between Array and NIO. BaseBuffer is now distinctly
the home of generic implementations and Base1DBuffer is the home of all
one-dimensional specialisation. Constructors low in the stack now take
navigation arrays as arguments, favouring clarity of purpose over minor
(illusory?) speed gains.

files:
  src/org/python/core/buffer/Base1DBuffer.java            |  117 ++++++++++
  src/org/python/core/buffer/BaseArrayBuffer.java         |   89 +------
  src/org/python/core/buffer/BaseBuffer.java              |   75 +++---
  src/org/python/core/buffer/BaseNIOBuffer.java           |   89 +------
  src/org/python/core/buffer/SimpleBuffer.java            |   38 +--
  src/org/python/core/buffer/SimpleNIOBuffer.java         |   19 +-
  src/org/python/core/buffer/SimpleStringBuffer.java      |    3 +-
  src/org/python/core/buffer/Strided1DBuffer.java         |   16 +-
  src/org/python/core/buffer/Strided1DNIOBuffer.java      |   64 ++---
  src/org/python/core/buffer/Strided1DWritableBuffer.java |   10 +-
  src/org/python/core/buffer/ZeroByteBuffer.java          |    8 +-
  tests/java/org/python/core/PyBufferNIOTest.java         |    8 +-
  tests/java/org/python/core/PyBufferTest.java            |    6 +-
  13 files changed, 249 insertions(+), 293 deletions(-)


diff --git a/src/org/python/core/buffer/Base1DBuffer.java b/src/org/python/core/buffer/Base1DBuffer.java
new file mode 100644
--- /dev/null
+++ b/src/org/python/core/buffer/Base1DBuffer.java
@@ -0,0 +1,117 @@
+package org.python.core.buffer;
+
+import org.python.core.PyBUF;
+
+/**
+ * Base implementation of the Buffer API appropriate to 1-dimensional arrays, of any item size,
+ * independent of the storage implementation. The description of {@link BaseBuffer} mostly applies.
+ */
+public abstract class Base1DBuffer extends BaseBuffer {
+
+    /** The strides array for a contiguous 1D byte buffer. */
+    protected static final int[] ONE = {1};
+
+    /** The shape array for a zero length 1D buffer. */
+    protected static final int[] ZERO = {0};
+
+    /**
+     * Construct an instance of Base1DBuffer in support of a sub-class, specifying the
+     * 'feature flags', or at least a starting set to be adjusted later. Also specify the navigation
+     * ( {@link #index0}, number of elements, and {@link #strides} array. These 'feature flags' are
+     * the features of the buffer exported, not the flags that form the consumer's request. The
+     * buffer will be read-only unless {@link PyBUF#WRITABLE} is set. {@link PyBUF#FORMAT} is
+     * implicitly added to the feature flags.
+     * 

+     * To complete initialisation, the sub-class normally must create its own wrapped byte-storage,
+     * and call {@link #checkRequestFlags(int)} passing the consumer's request flags.
+     *
+     * @param featureFlags bit pattern that specifies the features allowed
+     * @param index0 index into storage of item[0]
+     * @param size number of elements in the view
+     * @param strides an array of length 1 providing index stride between successive elements
+     */
+    protected Base1DBuffer(int featureFlags, int index0, int size, int[] strides) {
+        super(featureFlags, index0, size == 0 ? ZERO : new int[] {size}, strides);
+    }
+
+    /**
+     * Construct an instance of Base1DBuffer in support of a sub-class, specifying the
+     * 'feature flags', or at least a starting set to be adjusted later. Also specify the navigation
+     * ( {@link #index0}, number of elements, and byte-index distance from one to the next. These
+     * 'feature flags' are the features of the buffer exported, not the flags that form the
+     * consumer's request. The buffer will be read-only unless {@link PyBUF#WRITABLE} is set.
+     * {@link PyBUF#FORMAT} is implicitly added to the feature flags.
+     * 

+     * To complete initialisation, the sub-class normally must create its own wrapped byte-storage,
+     * and call {@link #checkRequestFlags(int)} passing the consumer's request flags.
+     *
+     * @param featureFlags bit pattern that specifies the features allowed
+     * @param index0 index into storage of item[0]
+     * @param size number of elements in the view
+     * @param stride byte-index distance from one element to the next
+     */
+    protected Base1DBuffer(int featureFlags, int index0, int size, int stride) {
+        this(featureFlags, index0, size, stride == 1 ? ONE : new int[] {stride});
+    }
+
+    @Override
+    protected int getSize() {
+        return shape[0];
+    }
+
+    @Override
+    public int getLen() {
+        return shape[0] * getItemsize();
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised to one-dimensional, possibly strided buffer.
+     */
+    @Override
+    protected int calcGreatestIndex() {
+        int stride = strides[0];
+        if (stride == 1) {
+            return index0 + shape[0] - 1;
+        } else if (stride > 0) {
+            return index0 + (shape[0] - 1) * stride;
+        } else {
+            return index0 - 1;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised to one-dimensional, possibly strided buffer.
+     */
+    @Override
+    protected int calcLeastIndex() {
+        int stride = strides[0];
+        if (stride < 0) {
+            return index0 + (shape[0] - 1) * stride;
+        } else {
+            return index0;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised in BaseArrayBuffer to one dimension.
+     */
+    @Override
+    public boolean isContiguous(char order) {
+        if ("CFA".indexOf(order) < 0) {
+            return false;
+        } else {
+            if (getShape()[0] < 2) {
+                return true;
+            } else {
+                return getStrides()[0] == getItemsize();
+            }
+        }
+    }
+
+}
diff --git a/src/org/python/core/buffer/BaseArrayBuffer.java b/src/org/python/core/buffer/BaseArrayBuffer.java
--- a/src/org/python/core/buffer/BaseArrayBuffer.java
+++ b/src/org/python/core/buffer/BaseArrayBuffer.java
@@ -11,7 +11,7 @@
  * The description of {@link BaseBuffer} mostly applies. Methods provided or overridden here are
  * appropriate to 1-dimensional arrays, of any item size, backed by byte[].
  */
-public abstract class BaseArrayBuffer extends BaseBuffer implements PyBuffer {
+public abstract class BaseArrayBuffer extends Base1DBuffer {
 
     /**
      * Reference to the underlying byte[] storage that the exporter is sharing with the
@@ -24,29 +24,24 @@
 
     /**
      * Construct an instance of BaseArrayBuffer in support of a sub-class, specifying
-     * the 'feature flags', or at least a starting set to be adjusted later. These are the features
-     * of the buffer exported, not the flags that form the consumer's request. The buffer will be
-     * read-only unless {@link PyBUF#WRITABLE} is set in the feature flags. {@link PyBUF#FORMAT} and
-     * {@link PyBUF#AS_ARRAY} are implicitly added to the feature flags. The navigation arrays are
-     * all null, awaiting action by the sub-class constructor. To complete initialisation, the
-     * sub-class normally must assign: the buffer ( {@link #storage}, {@link #index0}), and the
-     * navigation arrays ({@link #shape}, {@link #strides}), and call
-     * {@link #checkRequestFlags(int)} passing the consumer's request flags.
+     * the 'feature flags', or at least a starting set to be adjusted later. Also specify the
+     * navigation ( {@link #index0}, number of elements, and stride. These 'feature flags' are the
+     * features of the buffer exported, not the flags that form the consumer's request. The buffer
+     * will be read-only unless {@link PyBUF#WRITABLE} is set. {@link PyBUF#FORMAT} and
+     * {@link PyBUF#AS_ARRAY} are implicitly added to the feature flags.
+     * 

+     * To complete initialisation, the sub-class normally must call {@link #checkRequestFlags(int)}
+     * passing the consumer's request flags.
      *
-     * @param featureFlags bit pattern that specifies the actual features allowed/required
+     * @param storage the array of bytes storing the implementation of the exporting object
+     * @param featureFlags bit pattern that specifies the features allowed
+     * @param index0 index into storage of item[0]
+     * @param size number of elements in the view
+     * @param stride byte-index distance from one element to the next
      */
-    protected BaseArrayBuffer(int featureFlags) {
-        super(featureFlags | AS_ARRAY);
-    }
-
-    @Override
-    protected int getSize() {
-        return shape[0];
-    }
-
-    @Override
-    public int getLen() {
-        return shape[0] * getItemsize();
+    protected BaseArrayBuffer(byte[] storage, int featureFlags, int index0, int size, int stride) {
+        super(featureFlags | AS_ARRAY, index0, size, stride);
+        this.storage = storage;
     }
 
     @Override
@@ -71,38 +66,6 @@
     /**
      * {@inheritDoc}
      * 

-     * Specialised to one-dimensional, possibly strided buffer.
-     */
-    @Override
-    protected int calcGreatestIndex() {
-        int stride = strides[0];
-        if (stride == 1) {
-            return index0 + shape[0] - 1;
-        } else if (stride > 0) {
-            return index0 + (shape[0] - 1) * stride;
-        } else {
-            return index0 - 1;
-        }
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * Specialised to one-dimensional, possibly strided buffer.
-     */
-    @Override
-    protected int calcLeastIndex() {
-        int stride = strides[0];
-        if (stride < 0) {
-            return index0 + (shape[0] - 1) * stride;
-        } else {
-            return index0;
-        }
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

      * The implementation in BaseArrayBuffer deals with the general one-dimensional
      * case of arbitrary item size and stride.
      */
@@ -256,22 +219,4 @@
     public Pointer getBuf() {
         return new Pointer(storage, index0);
     }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * Specialised in BaseArrayBuffer to one dimension.
-     */
-    @Override
-    public boolean isContiguous(char order) {
-        if ("CFA".indexOf(order) < 0) {
-            return false;
-        } else {
-            if (getShape()[0] < 2) {
-                return true;
-            } else {
-                return getStrides()[0] == getItemsize();
-            }
-        }
-    }
 }
diff --git a/src/org/python/core/buffer/BaseBuffer.java b/src/org/python/core/buffer/BaseBuffer.java
--- a/src/org/python/core/buffer/BaseBuffer.java
+++ b/src/org/python/core/buffer/BaseBuffer.java
@@ -16,22 +16,22 @@
  * unglamorous common code need only be implemented once.
  * 

  * This class leaves undefined the storage mechanism for the bytes (typically byte[] or
- * java.nio.ByteBuffer). A concrete class that extends this one must provide elementary
- * accessors {@link #byteAtImpl(int)}, {@link #storeAtImpl(byte, int)} that abstract this storage, a
- * factory {@link #getNIOByteBufferImpl()} for ByteBuffers that wrap the storage, and a
- * factory for slices {@link #getBufferSlice(int, int, int, int)}. The constructor must specify the
- * feature flags (see {@link #BaseBuffer(int)}), set {@link #index0}, {@link #shape} and
- * {@link #strides}, and finally check the client capabilities with {@link #checkRequestFlags(int)}.
- * Sub-classes intended to represent slices of exporters that must count their exports as part of a
- * locking protocol, as does bytearray, must override {@link #getRoot()} so that a
- * buffer view {@link #release()} on a slice, propagates to the buffer view that provided it.
+ * java.nio.ByteBuffer), while remaining definite that it is an indexable sequence of
+ * bytes. A concrete class that extends this one must provide elementary accessors
+ * {@link #byteAtImpl(int)}, {@link #storeAtImpl(byte, int)} that abstract this storage, a factory
+ * {@link #getNIOByteBufferImpl()} for ByteBuffers that wrap the storage, and a factory
+ * for slices {@link #getBufferSlice(int, int, int, int)}.
+ * 

+ * The sub-class constructor must specify the feature flags (see {@link #BaseBuffer(int)}), set
+ * {@link #index0}, {@link #shape} and {@link #strides}, and finally check the client capabilities
+ * with {@link #checkRequestFlags(int)}. Sub-classes intended to represent slices of exporters that
+ * must count their exports as part of a locking protocol, as does bytearray, must
+ * override {@link #getRoot()} so that a buffer view {@link #release()} on a slice, propagates to
+ * the buffer view that provided it.
  * 

  * Access methods provided here necessarily work with the abstracted {@link #byteAtImpl(int)},
  * {@link #storeAtImpl(byte, int)} interface, but subclasses are able to override them with more
- * efficient versions that employ knowledge of the particular storage type used. The provided buffer
- * access methods may be restricted to 1-dimensional arrays where the units are single bytes, stored
- * contiguously. Sub-classes that deal with N-dimensional arrays, non-contiguous storage and items
- * that are not single bytes must sometimes override the default implementations.
+ * efficient versions that employ knowledge of the particular storage type used.
  * 

  * This base implementation is writable only if {@link PyBUF#WRITABLE} is in the feature flags
  * passed to the constructor. Otherwise, all methods for write access raise a TypeError
@@ -60,11 +60,6 @@
     protected int[] strides;
 
     /**
-     * The strides array for a contiguous byte buffer..
-     */
-    protected static final int[] CONTIG_STRIDES = {1};
-
-    /**
      * Absolute byte-index in the storage of item[0]. In one dimension, for a positive
      * stride this is equal to the offset of the first byte used in whatever
      * byte-storage is provided, and for a negative stride it is the first byte of the
@@ -124,19 +119,25 @@
 
     /**
      * Construct an instance of BaseBuffer in support of a sub-class, specifying the
-     * 'feature flags', or at least a starting set to be adjusted later. These are the features of
-     * the buffer exported, not the flags that form the consumer's request. The buffer will be
-     * read-only unless {@link PyBUF#WRITABLE} is set in the feature flags. {@link PyBUF#FORMAT} is
-     * implicitly added to the feature flags. The navigation arrays are all null, awaiting action by
-     * the sub-class constructor. To complete initialisation, the sub-class normally must create its
-     * own wrapped byte-storage, assign {@link #index0}) and the navigation arrays ( {@link #shape},
-     * {@link #strides}), and call {@link #checkRequestFlags(int)} passing the consumer's request
-     * flags.
+     * 'feature flags', or at least a starting set to be adjusted later. Also specify the navigation
+     * ( {@link #index0}, {@link #shape}, and {@link #strides}). These 'feature flags' are the
+     * features of the buffer exported, not the flags that form the consumer's request. The buffer
+     * will be read-only unless {@link PyBUF#WRITABLE} is set. {@link PyBUF#FORMAT} is implicitly
+     * added to the feature flags.
+     * 

+     * To complete initialisation, the sub-class normally must create its own wrapped byte-storage,
+     * and call {@link #checkRequestFlags(int)} passing the consumer's request flags.
      *
-     * @param featureFlags bit pattern that specifies the actual features allowed/required
+     * @param featureFlags bit pattern that specifies the features allowed
+     * @param index0 index into storage of item[0,...,0]
+     * @param shape elements in each dimension
+     * @param strides between successive elements in each dimension
      */
-    protected BaseBuffer(int featureFlags) {
+    protected BaseBuffer(int featureFlags, int index0, int[] shape, int[] strides) {
         setFeatureFlags(featureFlags | FORMAT);
+        this.index0 = index0;
+        this.shape = shape;
+        this.strides = strides;
     }
 
     /**
@@ -636,7 +637,7 @@
         // The buffer spans the whole storage
         ByteBuffer b = getNIOByteBufferImpl();
         // For the one-dimensional contiguous case it makes sense to set the limit:
-        if (shape.length == 1) {
+        if (shape.length == 1 && isContiguous('A')) {
             int stride = strides[0];
             if (getItemsize() == stride) {
                 b.limit(index0 + shape[0] * stride);
@@ -707,8 +708,8 @@
         /*
          * If we were to compute the strides array for a C-contiguous array, the last stride would
          * equal the item size, and generally stride[k-1] = shape[k]*stride[k]. This is the basis of
-         * the test. However, note that for any k where shape[k]==1 there is no "next sub-array"
-         * and no discontiguity.
+         * the test. However, note that for any k where shape[k]==1 there is no "next sub-array" and
+         * no discontiguity.
          */
         final int N = shape.length;
         /*
@@ -731,16 +732,16 @@
 
     private boolean isFortranContiguous() {
         /*
-         * If we were to compute the strides array for a Fortran-contiguous array, the first stride would
-         * equal the item size, and generally stride[k+1] = shape[k]*stride[k]. This is the basis of
-         * the test. However, note that for any k where shape[k]==1 there is no "next sub-array"
-         * and no discontiguity.
+         * If we were to compute the strides array for a Fortran-contiguous array, the first stride
+         * would equal the item size, and generally stride[k+1] = shape[k]*stride[k]. This is the
+         * basis of the test. However, note that for any k where shape[k]==1 there is no
+         * "next sub-array" and no discontiguity.
          */
         final int N = shape.length;
         /*
          * size is the stride in bytes-index from item[0,...,0,ik,0,...,0] to
-         * item[0,...,0,ik+1,0,...,0]. Start the iteration at k=0. An increment of one
-         * in the first index makes a stride of the item size.
+         * item[0,...,0,ik+1,0,...,0]. Start the iteration at k=0. An increment of one in the first
+         * index makes a stride of the item size.
          */
         int size = getItemsize();
         for (int k = 0; k < N; k++) {
diff --git a/src/org/python/core/buffer/BaseNIOBuffer.java b/src/org/python/core/buffer/BaseNIOBuffer.java
--- a/src/org/python/core/buffer/BaseNIOBuffer.java
+++ b/src/org/python/core/buffer/BaseNIOBuffer.java
@@ -14,7 +14,7 @@
  * provided or overridden here are appropriate to 1-dimensional arrays, of any item size, backed by
  * a ByteBuffer.
  */
-public abstract class BaseNIOBuffer extends BaseBuffer implements PyBuffer {
+public abstract class BaseNIOBuffer extends Base1DBuffer {
 
     /**
      * A {@link java.nio.ByteBuffer} (possibly a direct buffer) wrapping the storage that the
@@ -32,22 +32,27 @@
     protected ByteBuffer storage;
 
     /**
-     * Partially construct an instance of BaseNIOBuffer in support of a sub-class,
-     * specifying the 'feature flags', or at least a starting set to be adjusted later. These are
-     * the features of the buffer exported, not the flags that form the consumer's request. The
-     * buffer will be read-only and/or backed by a (heap) array according to the properties of the
-     * ByteBuffer passed in. {@link PyBUF#FORMAT} is implicitly added to the feature
-     * flags. To complete initialisation, the sub-class normally must assign: {@link #index0}) and
-     * the navigation arrays ({@link #shape}, {@link #strides}), and call
-     * {@link #checkRequestFlags(int)} passing the consumer's request flags.
+     * Construct an instance of BaseNIOBuffer in support of a sub-class, specifying the
+     * 'feature flags', or at least a starting set to be adjusted later. Also specify the navigation
+     * ( {@link #index0}, number of elements, and stride. These 'feature flags' are the features of
+     * the buffer exported, not the flags that form the consumer's request. The buffer will be
+     * read-only unless {@link PyBUF#WRITABLE} is set. {@link PyBUF#FORMAT} and
+     * {@link PyBUF#AS_ARRAY} are implicitly added to the feature flags.
+     * 

+     * To complete initialisation, the sub-class normally must call {@link #checkRequestFlags(int)}
+     * passing the consumer's request flags.
      *
      * @param storage the ByteBuffer wrapping the exported object state. NOTE: this
      *            PyBuffer keeps a reference and may manipulate the position, mark and
      *            limit hereafter. Use {@link ByteBuffer#duplicate()} to give it an isolated copy.
-     * @param featureFlags bit pattern that specifies the actual features allowed/required
+     * @param featureFlags bit pattern that specifies the features allowed
+     * @param index0 index into storage of item[0]
+     * @param size number of elements in the view
+     * @param stride byte-index step between successive elements
      */
-    protected BaseNIOBuffer(ByteBuffer storage, int featureFlags) {
-        super(featureFlags & ~(WRITABLE | AS_ARRAY));
+
+    protected BaseNIOBuffer(ByteBuffer storage, int featureFlags, int index0, int size, int stride) {
+        super(featureFlags & ~(WRITABLE | AS_ARRAY), index0, size, stride);
         this.storage = storage;
 
         // Deduce other feature flags from the client's ByteBuffer
@@ -60,16 +65,6 @@
     }
 
     @Override
-    protected int getSize() {
-        return shape[0];
-    }
-
-    @Override
-    public int getLen() {
-        return shape[0] * getItemsize();
-    }
-
-    @Override
     protected byte byteAtImpl(int byteIndex) throws IndexOutOfBoundsException {
         return storage.get(byteIndex);
     }
@@ -92,38 +87,6 @@
     /**
      * {@inheritDoc}
      * 

-     * Specialised to one-dimensional, possibly strided buffer.
-     */
-    @Override
-    protected int calcGreatestIndex() {
-        int stride = strides[0];
-        if (stride == 1) {
-            return index0 + shape[0] - 1;
-        } else if (stride > 0) {
-            return index0 + (shape[0] - 1) * stride;
-        } else {
-            return index0 - 1;
-        }
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * Specialised to one-dimensional, possibly strided buffer.
-     */
-    @Override
-    protected int calcLeastIndex() {
-        int stride = strides[0];
-        if (stride < 0) {
-            return index0 + (shape[0] - 1) * stride;
-        } else {
-            return index0;
-        }
-    }
-
-    /**
-     * {@inheritDoc}
-     * 

      * The default implementation in BaseNIOBuffer deals with the general
      * one-dimensional case of arbitrary item size and stride.
      */
@@ -324,22 +287,4 @@
         checkHasArray();
         return new Pointer(storage.array(), index0);
     }
-
-    /**
-     * {@inheritDoc}
-     * 

-     * Specialised in BaseArrayBuffer to one dimension.
-     */
-    @Override
-    public boolean isContiguous(char order) {
-        if ("CFA".indexOf(order) < 0) {
-            return false;
-        } else {
-            if (getShape()[0] < 2) {
-                return true;
-            } else {
-                return getStrides()[0] == getItemsize();
-            }
-        }
-    }
 }
diff --git a/src/org/python/core/buffer/SimpleBuffer.java b/src/org/python/core/buffer/SimpleBuffer.java
--- a/src/org/python/core/buffer/SimpleBuffer.java
+++ b/src/org/python/core/buffer/SimpleBuffer.java
@@ -9,27 +9,14 @@
  */
 public class SimpleBuffer extends BaseArrayBuffer {
 
-    /**
-     * Provide an instance of SimpleBuffer with navigation variables partly
-     * initialised, for sub-class use. One-dimensional arrays without strides are C- and
-     * F-contiguous. To complete initialisation, the sub-class must normally assign the buffer (
-     * {@link #storage}, {@link #index0}), and the navigation ({@link #shape} array), and then call
-     * {@link #checkRequestFlags(int)} passing the consumer's request flags.
-     */
-    protected SimpleBuffer() {
-        super(CONTIGUITY | SIMPLE);
-        // Initialise navigation
-        shape = new int[1];
-        strides = CONTIG_STRIDES;
-        // suboffsets is always null for this type.
-    }
 
     /**
      * Provide an instance of SimpleBuffer with navigation variables initialised, for
      * sub-class use. The buffer ({@link #storage}, {@link #index0}), and the {@link #shape} array
-     * will be initialised from the arguments (which are checked for range). The {@link #strides} is
-     * set for (one-byte) unit stride. Only the call to {@link #checkRequestFlags(int)}, passing the
-     * consumer's request flags really remains for the sub-class constructor to do.
+     * will be initialised from the arguments (which are not checked for range). The
+     * {@link #strides} is set for a one-byte stride. Only the call to
+     * {@link #checkRequestFlags(int)}, passing the consumer's request flags really remains for the
+     * sub-class constructor to do.
      *
      * 
      * super(storage, index0, size);
@@ -40,21 +27,10 @@
      * @param index0 offset where the data starts in that array (item[0])
      * @param size the number of bytes occupied
      * @throws NullPointerException if storage is null
-     * @throws ArrayIndexOutOfBoundsException if index0 and size are
-     *             inconsistent with storage.length
      */
     protected SimpleBuffer(byte[] storage, int index0, int size) throws PyException,
             ArrayIndexOutOfBoundsException {
-        this();
-        this.storage = storage;         // Exported data
-        // Initialise navigation
-        this.index0 = index0;           // Index to be treated as item[0]
-        shape[0] = size;                // Number of items in exported data
-
-        // Check arguments using the "all non-negative" trick
-        if ((index0 | size | storage.length - (index0 + size)) < 0) {
-            throw new ArrayIndexOutOfBoundsException();
-        }
+        super(storage, CONTIGUITY | SIMPLE, index0, size, 1);
     }
 
     /**
@@ -75,6 +51,10 @@
             ArrayIndexOutOfBoundsException, NullPointerException {
         this(storage, index0, size);    // Construct checked SimpleBuffer
         checkRequestFlags(flags);       // Check request is compatible with type
+        // Check arguments using the "all non-negative" trick
+        if ((index0 | size | storage.length - (index0 + size)) < 0) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
     }
 
     /**
diff --git a/src/org/python/core/buffer/SimpleNIOBuffer.java b/src/org/python/core/buffer/SimpleNIOBuffer.java
--- a/src/org/python/core/buffer/SimpleNIOBuffer.java
+++ b/src/org/python/core/buffer/SimpleNIOBuffer.java
@@ -6,7 +6,7 @@
 import org.python.core.PyException;
 
 /**
- * Buffer API over a read-only one-dimensional array of one-byte items.
+ * Buffer API over a read-only one-dimensional java.nio.ByteBuffer of one-byte items.
  */
 
 public class SimpleNIOBuffer extends BaseNIOBuffer {
@@ -40,16 +40,7 @@
      */
     protected SimpleNIOBuffer(ByteBuffer storage, int index0, int size) throws PyException,
             ArrayIndexOutOfBoundsException {
-        super(storage, CONTIGUITY | SIMPLE);
-
-        // Initialise navigation
-        shape = new int[] {size};       // Number of items in exported data
-        strides = SIMPLE_STRIDES;
-        // suboffsets is always null for this type.
-
-        this.storage = storage;         // Exported data
-        this.index0 = index0;           // Index to be treated as item[0]
-
+        super(storage, CONTIGUITY | SIMPLE, index0, size, 1);
         // Check arguments using the "all non-negative" trick
         if ((index0 | size | storage.capacity() - (index0 + size)) < 0) {
             throw new ArrayIndexOutOfBoundsException();
@@ -181,11 +172,11 @@
          * @param flags the request flags of the consumer that requested the slice
          * @param storage ByteBuffer wrapping exported data (no reference kept)
          * @param offset where the data starts in that buffer (item[0])
-         * @param size the number of bytes occupied
+         * @param count the number of items in the sliced view
          */
-        public SimpleView(PyBuffer root, int flags, ByteBuffer storage, int offset, int size) {
+        public SimpleView(PyBuffer root, int flags, ByteBuffer storage, int offset, int count) {
             // Create a new SimpleNIOBuffer on the buffer passed in (part of the root)
-            super(flags, storage, offset, size);
+            super(flags, storage, offset, count);
             // Get a lease on the root PyBuffer
             this.root = root.getBuffer(FULL_RO);
         }
diff --git a/src/org/python/core/buffer/SimpleStringBuffer.java b/src/org/python/core/buffer/SimpleStringBuffer.java
--- a/src/org/python/core/buffer/SimpleStringBuffer.java
+++ b/src/org/python/core/buffer/SimpleStringBuffer.java
@@ -34,10 +34,9 @@
          * Leaving storage=null is ok because we carefully override every method that uses it,
          * deferring creation of the storage byte array until we absolutely must have one.
          */
-        super();
+        super(null, 0, bufString.length());
         // Save the backing string
         this.bufString = bufString;
-        shape[0] = bufString.length();
         // Check request is compatible with type
         checkRequestFlags(flags);
     }
diff --git a/src/org/python/core/buffer/Strided1DBuffer.java b/src/org/python/core/buffer/Strided1DBuffer.java
--- a/src/org/python/core/buffer/Strided1DBuffer.java
+++ b/src/org/python/core/buffer/Strided1DBuffer.java
@@ -58,12 +58,8 @@
      */
     protected Strided1DBuffer(byte[] storage, int index0, int count, int stride)
             throws ArrayIndexOutOfBoundsException, NullPointerException {
-        super(STRIDES);
-        this.storage = storage;         // Exported data
-        this.index0 = index0;           // Index to be treated as item[0]
-        this.shape = new int[] {count}; // Number of items in exported data
+        super(storage, STRIDES, index0, count, stride);
         this.stride = stride;           // Between items
-        this.strides = new int[] {stride};
 
         if (count == 0) {
             // Nothing to check as we'll make no accesses
@@ -114,7 +110,7 @@
      * @param storage raw byte array containing exported data
      * @param index0 index into storage of item[0]
      * @param count number of items in the slice
-     * @param stride in between successive elements of the new PyBuffer
+     * @param stride byte-index distance from one element to the next in the new PyBuffer
      * @throws NullPointerException if storage is null
      * @throws ArrayIndexOutOfBoundsException if index0, count and
      *             stride are inconsistent with storage.length
@@ -196,14 +192,14 @@
          * @param flags consumer requirements
          * @param storage raw byte array containing exported data
          * @param index0 index into storage of item[0]
-         * @param len number of items in the slice
+         * @param count number of items in the sliced view
          * @param stride in between successive elements of the new PyBuffer
          * @throws PyException (BufferError) when expectations do not correspond with the type
          */
-        public SlicedView(PyBuffer root, int flags, byte[] storage, int index0, int len, int stride)
-                throws PyException {
+        public SlicedView(PyBuffer root, int flags, byte[] storage, int index0, int count,
+                int stride) throws PyException {
             // Create a new on the buffer passed in (part of the root)
-            super(flags, storage, index0, len, stride);
+            super(flags, storage, index0, count, stride);
             // Get a lease on the root PyBuffer (read-only)
             this.root = root.getBuffer(FULL_RO);
         }
diff --git a/src/org/python/core/buffer/Strided1DNIOBuffer.java b/src/org/python/core/buffer/Strided1DNIOBuffer.java
--- a/src/org/python/core/buffer/Strided1DNIOBuffer.java
+++ b/src/org/python/core/buffer/Strided1DNIOBuffer.java
@@ -5,18 +5,17 @@
 import org.python.core.PyBuffer;
 import org.python.core.PyException;
 
-
 /**
- * Read-only buffer API over a one-dimensional array of one-byte items, that are evenly-spaced in a
- * storage array. The buffer has storage, index0 and length
- * properties in the usual way, designating a slice (or all) of a byte array, but also a
- * stride property (equal to getStrides()[0]).
+ * Read-only buffer API over a one-dimensional java.nio.ByteBuffer of one-byte items,
+ * that are evenly-spaced in that store. The buffer has storage, index0
+ * and length properties in the usual way, designating a slice (or all) of a byte
+ * array, but also a stride property (equal to getStrides()[0]).
  * 
- * Let the underlying buffer be the byte array u(i) for i=0..N-1, let x be the
- * Strided1DNIOBuffer, and let the stride be p. The storage works as follows.
- * Designate by x(j), for j=0..L-1, the byte at index j, that is, the byte
- * retrieved by x.byteAt(j). Thus, we store x(j) at u(a+pj), that is,
- * x(0) = u(a). When we construct such a buffer, we have to supply a =
+ * Let the underlying buffer be the byte sequence u(i) for i=0..N-1, let x be
+ * the Strided1DNIOBuffer, and let the stride be p. The storage works as
+ * follows. Designate by x(j), for j=0..L-1, the byte at index j, that is, the
+ * byte retrieved by x.byteAt(j). Thus, we store x(j) at u(a+pj), that
+ * is, x(0) = u(a). When we construct such a buffer, we have to supply a =
  * index0, L = count, and p = stride as the
  * constructor arguments. The last item in the slice x(L-1) is stored at u(a+p(L-1)).
  * For the simple case of positive stride, constructor argument index0 is the low index
@@ -40,7 +39,6 @@
      */
     protected int stride;
 
-
     /**
      * Provide an instance of Strided1DNIOBuffer with navigation variables initialised,
      * for sub-class use. The buffer ({@link #storage}, {@link #index0}), and the navigation (
@@ -49,8 +47,8 @@
      * 

      * The sub-class constructor should check that the intended access is compatible with this
      * object by calling {@link #checkRequestFlags(int)}. (See the source of
-     * {@link Strided1DWritableBuffer#Strided1DWritableBuffer(int, ByteBuffer, int, int, int)}
-     * for an example of this use.)
+     * {@link Strided1DWritableBuffer#Strided1DWritableBuffer(int, ByteBuffer, int, int, int)} for
+     * an example of this use.)
      *
      * @param storage the ByteBuffer wrapping the exported object state. NOTE: this
      *            PyBuffer keeps a reference and may manipulate the position, mark and
@@ -64,11 +62,8 @@
      */
     protected Strided1DNIOBuffer(ByteBuffer storage, int index0, int count, int stride)
             throws ArrayIndexOutOfBoundsException, NullPointerException {
-        super(storage, STRIDES);
-        this.index0 = index0;           // Index to be treated as item[0]
-        shape = new int[]{count};       // Number of items in exported data
+        super(storage, STRIDES, index0, count, stride);
         this.stride = stride;           // Between items
-        this.strides = new int[] {stride};
 
         if (count == 0) {
             // Nothing to check as we'll make no accesses
@@ -108,16 +103,14 @@
         }
     }
 
-   /**
+    /**
      * Provide an instance of Strided1DNIOBuffer on a particular {@link ByteBuffer}
-     *  specifying
-     * a starting index, the number of items in the result, and a byte-indexing stride. The result
-     * of byteAt(i) will be equal to storage.get(index0+stride*i)
-     * (whatever
-     * the sign of stride), valid for 0<=i<count. The constructor
-     * checks that all these indices lie within the storage (unless
-     * count=0).
-     * No reference will be kept to the ByteBuffer passed in. (It is duplicated.)
+     * specifying a starting index, the number of items in the result, and a byte-indexing stride.
+     * The result of byteAt(i) will be equal to
+     * storage.get(index0+stride*i) (whatever the sign of stride), valid
+     * for 0<=i<count. The constructor checks that all these indices lie within
+     * the storage (unless count=0). No reference will be kept to the
+     * ByteBuffer passed in. (It is duplicated.)
      * 

      * The constructed PyBuffer meets the consumer's expectations as expressed in the
      * flags argument, or an exception will be thrown if these are incompatible with
@@ -149,11 +142,11 @@
         return index0 + index * stride;
     }
 
-     /**
+    /**
      * {@inheritDoc}
      * 

-     * Strided1DNIOBuffer provides an implementation for slicing already-strided bytes in
-     * one dimension. In that case, x(i) = u(r+ip) for i = 0..L-1 where u is the
+     * Strided1DNIOBuffer provides an implementation for slicing already-strided bytes
+     * in one dimension. In that case, x(i) = u(r+ip) for i = 0..L-1 where u is the
      * underlying buffer, and r, p and L are the start, stride and count with
      * which x was created from u. Thus y(k) = u(r+sp+kmp), that is, the
      * composite index0 is r+sp and the composite stride is
@@ -175,10 +168,9 @@
         }
     }
 
-
     /**
-     * A Strided1DNIOBuffer.SlicedView represents a non-contiguous subsequence of a simple
-     * buffer.
+     * A Strided1DNIOBuffer.SlicedView represents a non-contiguous subsequence of a
+     * simple buffer.
      */
     static class SlicedView extends Strided1DNIOBuffer {
 
@@ -192,14 +184,14 @@
          * @param flags consumer requirements
          * @param storage ByteBuffer wrapping exported data (no reference kept)
          * @param index0 index into storage of item[0]
-         * @param len number of items in the slice
+         * @param count the number of items in the sliced view
          * @param stride in between successive elements of the new PyBuffer
          * @throws PyException (BufferError) when expectations do not correspond with the type
          */
-        public SlicedView(PyBuffer root, int flags, ByteBuffer storage, int index0, int len, int stride)
-                throws PyException {
+        public SlicedView(PyBuffer root, int flags, ByteBuffer storage, int index0, int count,
+                int stride) throws PyException {
             // Create a new slice on the buffer passed in (part of the root)
-            super(flags, storage, index0, len, stride);
+            super(flags, storage, index0, count, stride);
             // Get a lease on the root PyBuffer (read-only)
             this.root = root.getBuffer(FULL_RO);
         }
diff --git a/src/org/python/core/buffer/Strided1DWritableBuffer.java b/src/org/python/core/buffer/Strided1DWritableBuffer.java
--- a/src/org/python/core/buffer/Strided1DWritableBuffer.java
+++ b/src/org/python/core/buffer/Strided1DWritableBuffer.java
@@ -28,7 +28,7 @@
      * @param storage raw byte array containing exported data
      * @param index0 index into storage of item[0]
      * @param count number of items in the slice
-     * @param stride in between successive elements of the new PyBuffer
+     * @param stride byte-index distance from one element to the next in the new PyBuffer
      * @throws NullPointerException if storage is null
      * @throws ArrayIndexOutOfBoundsException if index0, count and
      *             stride are inconsistent with storage.length
@@ -100,14 +100,14 @@
          * @param flags consumer requirements
          * @param storage raw byte array containing exported data
          * @param index0 index into storage of item[0]
-         * @param len number of items in the slice
+         * @param count number of items in the sliced view
          * @param stride in between successive elements of the new PyBuffer
          * @throws PyException (BufferError) when expectations do not correspond with the type
          */
-        public SlicedView(PyBuffer root, int flags, byte[] storage, int index0, int len, int stride)
-                throws PyException {
+        public SlicedView(PyBuffer root, int flags, byte[] storage, int index0, int count,
+                int stride) throws PyException {
             // Create a new on the buffer passed in (part of the root)
-            super(flags, storage, index0, len, stride);
+            super(flags, storage, index0, count, stride);
             // Get a lease on the root PyBuffer (writable)
             this.root = root.getBuffer(FULL);
         }
diff --git a/src/org/python/core/buffer/ZeroByteBuffer.java b/src/org/python/core/buffer/ZeroByteBuffer.java
--- a/src/org/python/core/buffer/ZeroByteBuffer.java
+++ b/src/org/python/core/buffer/ZeroByteBuffer.java
@@ -17,9 +17,6 @@
     /** Shared instance of a zero-length storage. */
     private static final byte[] EMPTY = new byte[0];
 
-    /** Array containing a single zero for the length */
-    protected static final int[] SHAPE = {0};
-
     /**
      * Construct an instance of a zero-length buffer, choosing whether it should report itself to be
      * read-only through {@link #isReadonly()} or as having a backing array through
@@ -33,10 +30,7 @@
      * @throws PyException (BufferError) when client expectations do not correspond with the type
      */
     public ZeroByteBuffer(int flags, boolean readonly, boolean hasArray) throws PyException {
-        super(CONTIGUITY | (readonly ? 0 : WRITABLE));
-        this.storage = EMPTY;                       // Empty array
-        this.shape = SHAPE;                         // {0}
-        this.strides = BaseBuffer.CONTIG_STRIDES; // {1}
+        super(EMPTY, CONTIGUITY | (readonly ? 0 : WRITABLE), 0, 0, 1);
         if (!hasArray) {
             // super() knows we have an array, but this truth is inconvenient here.
             removeFeatureFlags(AS_ARRAY);
diff --git a/tests/java/org/python/core/PyBufferNIOTest.java b/tests/java/org/python/core/PyBufferNIOTest.java
--- a/tests/java/org/python/core/PyBufferNIOTest.java
+++ b/tests/java/org/python/core/PyBufferNIOTest.java
@@ -7,7 +7,6 @@
 
 import org.junit.runners.Parameterized.Parameters;
 import org.python.core.ByteBufferTestSupport.ByteMaterial;
-import org.python.core.PyBufferTest.TestableExporter;
 import org.python.core.PyBufferTestSupport.ExporterFactory;
 import org.python.core.PyBufferTestSupport.TestSpec;
 import org.python.core.PyBufferTestSupport.WritableExporterFactory;
@@ -249,11 +248,10 @@
                 int count, int stride) throws IndexOutOfBoundsException, NullPointerException,
                 PyException {
             // Client will need to navigate using shape and strides if this is a slice
-            super(FEATURES | ((index0 == 0 && stride == 1) ? 0 : PyBUF.STRIDES));
+            super(FEATURES | ((index0 == 0 && stride == 1) ? 0 : STRIDES), //
+                    index0, new int[] {count}, new int[] {stride});
             this.storage = storage.duplicate();
-            this.index0 = index0;
-            shape = new int[] {count};
-            strides = new int[] {stride};
+
             // Check the potential index range
             if (count > 0) {
                 int end = index0 + (count - 1) * stride;
diff --git a/tests/java/org/python/core/PyBufferTest.java b/tests/java/org/python/core/PyBufferTest.java
--- a/tests/java/org/python/core/PyBufferTest.java
+++ b/tests/java/org/python/core/PyBufferTest.java
@@ -1304,11 +1304,9 @@
                 int count, int stride) throws IndexOutOfBoundsException, NullPointerException,
                 PyException {
             // Client will need to navigate using shape and strides if this is a slice
-            super(FEATURES | ((index0 == 0 && stride == 1) ? 0 : PyBUF.STRIDES));
+            super(FEATURES | ((index0 == 0 && stride == 1) ? 0 : STRIDES), //
+                    index0, new int[] {count}, new int[] {stride});
             this.storage = storage;
-            this.index0 = index0;
-            shape = new int[] {count};
-            strides = new int[] {stride};
             // Check the potential index range
             if (count > 0) {
                 int end = index0 + (count - 1) * stride;

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sat Aug 27 09:12:24 2016
From: jython-checkins at python.org (jeff.allen)
Date: Sat, 27 Aug 2016 13:12:24 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Add_implementations_of_PyBu?=
 =?utf-8?q?ffer_based_on_java=2Enio=2EByteBuffer?=
Message-ID: <20160827131224.63903.41018.55FFD710@psf.io>

https://hg.python.org/jython/rev/369b40954d96
changeset:   7942:369b40954d96
user:        Jeff Allen 
date:        Sat Jun 11 07:39:53 2016 +0100
summary:
  Add implementations of PyBuffer based on java.nio.ByteBuffer

Implementations and a test using the recent refactoring of the array-
based buffer implementation. More refactoring and API change is pending,
see comments for a start.

files:
  src/org/python/core/buffer/BaseArrayBuffer.java    |    4 +-
  src/org/python/core/buffer/BaseNIOBuffer.java      |  345 ++++++++++
  src/org/python/core/buffer/SimpleBuffer.java       |    2 +
  src/org/python/core/buffer/SimpleNIOBuffer.java    |  206 +++++
  src/org/python/core/buffer/Strided1DNIOBuffer.java |  219 ++++++
  tests/java/org/python/core/PyBufferNIOTest.java    |  316 +++++++++
  tests/java/org/python/core/PyBufferTest.java       |   17 +-
  7 files changed, 1097 insertions(+), 12 deletions(-)


diff --git a/src/org/python/core/buffer/BaseArrayBuffer.java b/src/org/python/core/buffer/BaseArrayBuffer.java
--- a/src/org/python/core/buffer/BaseArrayBuffer.java
+++ b/src/org/python/core/buffer/BaseArrayBuffer.java
@@ -9,8 +9,7 @@
 /**
  * Base implementation of the Buffer API for when the storage implementation is byte[].
  * The description of {@link BaseBuffer} mostly applies. Methods provided or overridden here are
- * appropriate to 1-dimensional arrays backed by byte[].
- *
+ * appropriate to 1-dimensional arrays, of any item size, backed by byte[].
  */
 public abstract class BaseArrayBuffer extends BaseBuffer implements PyBuffer {
 
@@ -275,5 +274,4 @@
             }
         }
     }
-
 }
diff --git a/src/org/python/core/buffer/BaseNIOBuffer.java b/src/org/python/core/buffer/BaseNIOBuffer.java
new file mode 100644
--- /dev/null
+++ b/src/org/python/core/buffer/BaseNIOBuffer.java
@@ -0,0 +1,345 @@
+package org.python.core.buffer;
+
+import java.nio.BufferOverflowException;
+import java.nio.ByteBuffer;
+import java.nio.ReadOnlyBufferException;
+
+import org.python.core.PyBUF;
+import org.python.core.PyBuffer;
+import org.python.core.PyException;
+
+/**
+ * Base implementation of the Buffer API for when the storage implementation is
+ * java.nio.ByteBuffer. The description of {@link BaseBuffer} mostly applies. Methods
+ * provided or overridden here are appropriate to 1-dimensional arrays, of any item size, backed by
+ * a ByteBuffer.
+ */
+public abstract class BaseNIOBuffer extends BaseBuffer implements PyBuffer {
+
+    /**
+     * A {@link java.nio.ByteBuffer} (possibly a direct buffer) wrapping the storage that the
+     * exporter is sharing with the consumer. The data to be exposed may be only a subset of the
+     * bytes in the buffer, defined by the navigation information index0,
+     * shape, strides, etc., usually defined in the constructor.
+     * 

+     * Implementations must not adjust the position and limit of storage after
+     * construction. It will generally be a duplicate of (not a reference to) a ByteBuffer held by
+     * the client code. The capacity and backing store are fixed in construction, and the position
+     * will always be {@link #index0}. The limit is always higher than any valid data, and in the
+     * case of a contiguous buffer (with positive stride), is exactly just beyond the last item, so
+     * that a series of ByteBuffer.get operations will yield the data.
+     */
+    protected ByteBuffer storage;
+
+    /**
+     * Partially construct an instance of BaseNIOBuffer in support of a sub-class,
+     * specifying the 'feature flags', or at least a starting set to be adjusted later. These are
+     * the features of the buffer exported, not the flags that form the consumer's request. The
+     * buffer will be read-only and/or backed by a (heap) array according to the properties of the
+     * ByteBuffer passed in. {@link PyBUF#FORMAT} is implicitly added to the feature
+     * flags. To complete initialisation, the sub-class normally must assign: {@link #index0}) and
+     * the navigation arrays ({@link #shape}, {@link #strides}), and call
+     * {@link #checkRequestFlags(int)} passing the consumer's request flags.
+     *
+     * @param storage the ByteBuffer wrapping the exported object state. NOTE: this
+     *            PyBuffer keeps a reference and may manipulate the position, mark and
+     *            limit hereafter. Use {@link ByteBuffer#duplicate()} to give it an isolated copy.
+     * @param featureFlags bit pattern that specifies the actual features allowed/required
+     */
+    protected BaseNIOBuffer(ByteBuffer storage, int featureFlags) {
+        super(featureFlags & ~(WRITABLE | AS_ARRAY));
+        this.storage = storage;
+
+        // Deduce other feature flags from the client's ByteBuffer
+        if (!storage.isReadOnly()) {
+            addFeatureFlags(WRITABLE);
+        }
+        if (storage.hasArray()) {
+            addFeatureFlags(AS_ARRAY);
+        }
+    }
+
+    @Override
+    protected int getSize() {
+        return shape[0];
+    }
+
+    @Override
+    public int getLen() {
+        return shape[0] * getItemsize();
+    }
+
+    @Override
+    protected byte byteAtImpl(int byteIndex) throws IndexOutOfBoundsException {
+        return storage.get(byteIndex);
+    }
+
+    @Override
+    protected void storeAtImpl(byte value, int byteIndex) throws IndexOutOfBoundsException,
+            PyException {
+        // XXX consider catching ReadonlyBufferException instead of checking (and others: index?)
+        checkWritable();
+        storage.put(byteIndex, value);
+    }
+
+    @Override
+    protected int byteIndex(int... indices) throws IndexOutOfBoundsException {
+        // BaseBuffer implementation can be simplified since if indices.length!=1 we error.
+        checkDimension(indices.length); // throws if != 1
+        return byteIndex(indices[0]);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised to one-dimensional, possibly strided buffer.
+     */
+    @Override
+    protected int calcGreatestIndex() {
+        int stride = strides[0];
+        if (stride == 1) {
+            return index0 + shape[0] - 1;
+        } else if (stride > 0) {
+            return index0 + (shape[0] - 1) * stride;
+        } else {
+            return index0 - 1;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised to one-dimensional, possibly strided buffer.
+     */
+    @Override
+    protected int calcLeastIndex() {
+        int stride = strides[0];
+        if (stride < 0) {
+            return index0 + (shape[0] - 1) * stride;
+        } else {
+            return index0;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The default implementation in BaseNIOBuffer deals with the general
+     * one-dimensional case of arbitrary item size and stride.
+     */
+    @Override
+    public void copyTo(int srcIndex, byte[] dest, int destPos, int count)
+            throws IndexOutOfBoundsException {
+        // Wrap the destination, taking care to reflect the necessary range we shall write.
+        ByteBuffer destBuf = ByteBuffer.wrap(dest, destPos, count * getItemsize());
+        copyTo(srcIndex, destBuf, count);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The default implementation in BaseBuffer deals with the general one-dimensional
+     * case of arbitrary item size and stride.
+     */
+    // XXX Should this become part of the PyBUffer interface?
+    public void copyTo(ByteBuffer dest) throws BufferOverflowException, ReadOnlyBufferException,
+            PyException {
+        // Note shape[0] is the number of items in the buffer
+        copyTo(0, dest, shape[0]);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The default implementation in BaseNIOBuffer deals with the general
+     * one-dimensional case of arbitrary item size and stride.
+     */
+    // XXX Should this become part of the PyBuffer interface?
+    protected void copyTo(int srcIndex, ByteBuffer dest, int count) throws BufferOverflowException,
+            ReadOnlyBufferException, IndexOutOfBoundsException, PyException {
+
+        if (count > 0) {
+
+            ByteBuffer src = getNIOByteBuffer(srcIndex);
+
+            // Pick up attributes necessary to choose an efficient copy strategy
+            int itemsize = getItemsize();
+            int stride = getStrides()[0];
+
+            // Strategy depends on whether items are laid end-to-end contiguously or there are gaps
+            if (stride == itemsize) {
+                // stride == itemsize: straight copy of contiguous bytes
+                src.limit(src.position() + count * itemsize);
+                dest.put(src);
+
+            } else if (itemsize == 1) {
+                // Non-contiguous copy: single byte items
+                int pos = src.position();
+                for (int i = 0; i < count; i++) {
+                    src.position(pos);
+                    dest.put(src.get());
+                    pos += stride;
+                }
+
+            } else {
+                // Non-contiguous copy: each time, copy itemsize bytes then skip
+                int pos = src.position();
+                for (int i = 0; i < count; i++) {
+                    src.limit(pos + itemsize).position(pos);
+                    dest.put(src);
+                    pos += stride;
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The default implementation in BaseNIOBuffer deals with the general
+     * one-dimensional case of arbitrary item size and stride.
+     */
+    @Override
+    public void copyFrom(byte[] src, int srcPos, int destIndex, int count)
+            throws IndexOutOfBoundsException, PyException {
+        // Wrap the source, taking care to reflect the range we shall read.
+        ByteBuffer srcBuf = ByteBuffer.wrap(src, srcPos, count * getItemsize());
+        copyFrom(srcBuf, destIndex, count);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The default implementation in BaseNIOBuffer deals with the general
+     * one-dimensional case of arbitrary item size and stride.
+     */
+    // XXX Should this become part of the PyBUffer interface?
+    protected void copyFrom(ByteBuffer src, int dstIndex, int count)
+            throws IndexOutOfBoundsException, PyException {
+
+        checkWritable();
+
+        if (count > 0) {
+
+            ByteBuffer dst = getNIOByteBuffer(dstIndex);
+
+            // Pick up attributes necessary to choose an efficient copy strategy
+            int itemsize = getItemsize();
+            int stride = getStrides()[0];
+            int skip = stride - itemsize;
+
+            // Strategy depends on whether items are laid end-to-end or there are gaps
+            if (skip == 0) {
+                // Straight copy of contiguous bytes
+                dst.put(src);
+
+            } else if (itemsize == 1) {
+                // Non-contiguous copy: single byte items
+                int pos = dst.position();
+                for (int i = 0; i < count; i++) {
+                    dst.position(pos);
+                    dst.put(src.get());
+                    // Next byte written will be here
+                    pos += stride;
+                }
+
+            } else {
+                // Non-contiguous copy: each time, copy itemsize bytes at a time
+                int pos = dst.position();
+                for (int i = 0; i < count; i++) {
+                    dst.position(pos);
+                    // Delineate the next itemsize bytes in the src
+                    src.limit(src.position() + itemsize);
+                    dst.put(src);
+                    // Next byte written will be here
+                    pos += stride;
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * The default implementation in BaseNIOBuffer deals with the general
+     * one-dimensional case.
+     */
+    @Override
+    public void copyFrom(PyBuffer src) throws IndexOutOfBoundsException, PyException {
+
+        int length = getLen();
+        int itemsize = getItemsize();
+
+        // Valid operation only if writable and same length and itemsize
+        checkWritable();
+        if (src.getLen() != length || src.getItemsize() != itemsize) {
+            throw differentStructure();
+        }
+
+        if (length > 0) {
+            // Pick up attributes necessary to choose an efficient copy strategy
+            int stride = getStrides()[0];
+            int skip = stride - itemsize;
+
+            ByteBuffer dst = getNIOByteBuffer();
+
+            // Strategy depends on whether destination items are laid end-to-end or there are gaps
+            if (skip == 0) {
+                // Straight copy to contiguous bytes
+                for (int i = 0; i < length; i++) {
+                    dst.put(src.byteAt(i));
+                }
+
+            } else if (itemsize == 1) {
+                // Non-contiguous copy: single byte items
+                int pos = dst.position();
+                for (int i = 0; i < length; i++) {
+                    dst.put(pos, src.byteAt(i));
+                    pos += stride;
+                }
+
+            } else {
+                // Non-contiguous copy: each time, and itemsize > 1
+                int pos = dst.position();
+                int s = 0;
+                for (int i = 0; i < length; i++) {
+                    for (int j = 0; j < itemsize; j++) {
+                        dst.put(pos++, src.byteAt(s++));
+                    }
+                    pos += skip;
+                }
+            }
+        }
+
+    }
+
+    @Override
+    protected ByteBuffer getNIOByteBufferImpl() {
+        return storage.duplicate();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public Pointer getBuf() {
+        checkHasArray();
+        return new Pointer(storage.array(), index0);
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * Specialised in BaseArrayBuffer to one dimension.
+     */
+    @Override
+    public boolean isContiguous(char order) {
+        if ("CFA".indexOf(order) < 0) {
+            return false;
+        } else {
+            if (getShape()[0] < 2) {
+                return true;
+            } else {
+                return getStrides()[0] == getItemsize();
+            }
+        }
+    }
+}
diff --git a/src/org/python/core/buffer/SimpleBuffer.java b/src/org/python/core/buffer/SimpleBuffer.java
--- a/src/org/python/core/buffer/SimpleBuffer.java
+++ b/src/org/python/core/buffer/SimpleBuffer.java
@@ -131,6 +131,8 @@
         return index0 + index;
     }
 
+    // XXX Consider moving to clauses in getBufferSlice(int, int, int, int)
+    // to avoid delegation loop where that delegates to this but in BaseBuffer the reverse.
     @Override
     public PyBuffer getBufferSlice(int flags, int start, int count) {
         if (count > 0) {
diff --git a/src/org/python/core/buffer/SimpleNIOBuffer.java b/src/org/python/core/buffer/SimpleNIOBuffer.java
new file mode 100644
--- /dev/null
+++ b/src/org/python/core/buffer/SimpleNIOBuffer.java
@@ -0,0 +1,206 @@
+package org.python.core.buffer;
+
+import java.nio.ByteBuffer;
+
+import org.python.core.PyBuffer;
+import org.python.core.PyException;
+
+/**
+ * Buffer API over a read-only one-dimensional array of one-byte items.
+ */
+
+public class SimpleNIOBuffer extends BaseNIOBuffer {
+
+    /**
+     * The strides array for this type is always a single element array with a 1 in it.
+     */
+    protected static final int[] SIMPLE_STRIDES = {1}; // XXX Push up?
+
+    /**
+     * Provide an instance of SimpleNIOBuffer with navigation variables initialised,
+     * for sub-class use. The buffer ({@link #storage}, {@link #index0}), and the {@link #shape}
+     * array will be initialised from the arguments (which are checked for range). The
+     * {@link #strides} is set for (one-byte) unit stride. Only the call to
+     * {@link #checkRequestFlags(int)}, passing the consumer's request flags, really remains for the
+     * sub-class constructor to do.
+     *
+     * 
+     * super(storage.duplicate(), index0, size);
+     * checkRequestFlags(flags);        // Check request is compatible with type
+     * 
+     *
+     * @param storage the ByteBuffer wrapping the exported object state. NOTE: this
+     *            PyBuffer keeps a reference and may manipulate the position, mark and
+     *            limit hereafter. Use {@link ByteBuffer#duplicate()} to give it an isolated copy.
+     * @param index0 offset where the data starts in that array (item[0])
+     * @param size the number of bytes occupied
+     * @throws NullPointerException if storage is null
+     * @throws ArrayIndexOutOfBoundsException if index0 and size are
+     *             inconsistent with storage.capacity()
+     */
+    protected SimpleNIOBuffer(ByteBuffer storage, int index0, int size) throws PyException,
+            ArrayIndexOutOfBoundsException {
+        super(storage, CONTIGUITY | SIMPLE);
+
+        // Initialise navigation
+        shape = new int[] {size};       // Number of items in exported data
+        strides = SIMPLE_STRIDES;
+        // suboffsets is always null for this type.
+
+        this.storage = storage;         // Exported data
+        this.index0 = index0;           // Index to be treated as item[0]
+
+        // Check arguments using the "all non-negative" trick
+        if ((index0 | size | storage.capacity() - (index0 + size)) < 0) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+    }
+
+    /**
+     * Provide an instance of SimpleNIOBuffer, on a slice of a {@link ByteBuffer},
+     * meeting the consumer's expectations as expressed in the flags argument, which is
+     * checked against the capabilities of the buffer type. No reference will be kept to the
+     * ByteBuffer passed in. (It is duplicated.)
+     *
+     * @param flags consumer requirements
+     * @param storage the ByteBuffer wrapping the exported object state
+     * @param index0 offset where the data starts in that buffer (item[0])
+     * @param size the number of bytes occupied
+     * @throws NullPointerException if storage is null
+     * @throws ArrayIndexOutOfBoundsException if index0 and size are
+     *             inconsistent with storage.length
+     * @throws PyException (BufferError) when expectations do not correspond with the type
+     */
+    public SimpleNIOBuffer(int flags, ByteBuffer storage, int index0, int size) throws PyException,
+            ArrayIndexOutOfBoundsException, NullPointerException {
+        this(storage.duplicate(), index0, size);    // Construct checked SimpleNIOBuffer
+        checkRequestFlags(flags);                   // Check request is compatible with type
+    }
+
+    /**
+     * Provide an instance of SimpleNIOBuffer, on the entirety of a {@link ByteBuffer},
+     * with navigation variables initialised, for sub-class use. The buffer ( {@link #storage},
+     * {@link #index0}), and the navigation ({@link #shape} array) will be initialised from the
+     * argument.
+     *
+     * @param storage the ByteBuffer wrapping the exported object state. NOTE: this
+     *            PyBuffer keeps a reference and may manipulate the position, mark and
+     *            limit hereafter. Use {@link ByteBuffer#duplicate()} to give it an isolated copy.
+     * @throws NullPointerException if storage is null
+     */
+    protected SimpleNIOBuffer(ByteBuffer storage) throws NullPointerException {
+        this(storage, 0, storage.capacity());
+    }
+
+    /**
+     * Provide an instance of SimpleNIOBuffer, on the entirety of a {@link ByteBuffer},
+     * meeting the consumer's expectations as expressed in the flags argument, which is
+     * checked against the capabilities of the buffer type. No reference will be kept to the
+     * ByteBuffer passed in. (It is duplicated.)
+     *
+     * @param flags consumer requirements
+     * @param storage the ByteBuffer wrapping the exported object state
+     * @throws NullPointerException if storage is null
+     * @throws PyException (BufferError) when expectations do not correspond with the type
+     */
+    public SimpleNIOBuffer(int flags, ByteBuffer storage) throws PyException, NullPointerException {
+        this(storage.duplicate());      // Construct SimpleNIOBuffer on whole ByteBuffer
+        checkRequestFlags(flags);       // Check request is compatible with type
+    }
+
+    /**
+     * {@inheritDoc}
+     * 
+     * SimpleNIOBuffer provides an implementation optimised for contiguous bytes in
+     * one-dimension.
+     */
+    @Override
+    public int getLen() {
+        // Simplify for one-dimensional contiguous bytes
+        return shape[0];
+    }
+
+    @Override
+    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+        return index0 + index;
+    }
+
+    // XXX Consider moving to clauses in getBufferSlice(int, int, int, int)
+    // to avoid delegation loop where that delegates to this but in BaseBuffer the reverse.
+    @Override
+    public PyBuffer getBufferSlice(int flags, int start, int count) {
+        if (count > 0) {
+            // Translate relative to underlying buffer
+            int compIndex0 = index0 + start;
+            // Create the slice from the sub-range of the buffer
+            return new SimpleView(getRoot(), flags, storage, compIndex0, count);
+        } else {
+            // Special case for count==0 where above logic would fail. Efficient too.
+            return new ZeroByteBuffer.View(getRoot(), flags);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * 

+     * SimpleNIOBuffer provides an implementation for slicing contiguous bytes in one
+     * dimension. In that case, x(i) = u(r+i) for i = 0..L-1 where u is the underlying
+     * buffer, and r and L are the start and count with which x was created
+     * from u. Thus y(k) = u(r+s+km), that is, the composite offset is r+s and
+     * the stride is m.
+     */
+    @Override
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
+
+        if (stride == 1 || count < 2) {
+            // Unstrided slice of simple buffer is special case
+            return getBufferSlice(flags, start, count);
+
+        } else {
+            // Translate relative to underlying buffer
+            int compIndex0 = index0 + start;
+            // Construct a view, taking a lock on the root object (this or this.root)
+            return new Strided1DNIOBuffer.SlicedView(getRoot(), flags, storage, compIndex0, count,
+                    stride);
+        }
+    }
+
+    /**
+     * A SimpleNIOBuffer.SimpleView represents a contiguous subsequence of another
+     * SimpleNIOBuffer.
+     */
+    static class SimpleView extends SimpleNIOBuffer {
+
+        /** The buffer on which this is a slice view */
+        PyBuffer root;
+
+        /**
+         * Construct a slice of a SimpleNIOBuffer.
+         *
+         * @param root buffer which will be acquired and must be released ultimately
+         * @param flags the request flags of the consumer that requested the slice
+         * @param storage ByteBuffer wrapping exported data (no reference kept)
+         * @param offset where the data starts in that buffer (item[0])
+         * @param size the number of bytes occupied
+         */
+        public SimpleView(PyBuffer root, int flags, ByteBuffer storage, int offset, int size) {
+            // Create a new SimpleNIOBuffer on the buffer passed in (part of the root)
+            super(flags, storage, offset, size);
+            // Get a lease on the root PyBuffer
+            this.root = root.getBuffer(FULL_RO);
+        }
+
+        @Override
+        protected PyBuffer getRoot() {
+            return root;
+        }
+
+        @Override
+        public void releaseAction() {
+            // We have to release the root too if ours was final.
+            root.release();
+        }
+
+    }
+
+}
diff --git a/src/org/python/core/buffer/Strided1DNIOBuffer.java b/src/org/python/core/buffer/Strided1DNIOBuffer.java
new file mode 100644
--- /dev/null
+++ b/src/org/python/core/buffer/Strided1DNIOBuffer.java
@@ -0,0 +1,219 @@
+package org.python.core.buffer;
+
+import java.nio.ByteBuffer;
+
+import org.python.core.PyBuffer;
+import org.python.core.PyException;
+
+
+/**
+ * Read-only buffer API over a one-dimensional array of one-byte items, that are evenly-spaced in a
+ * storage array. The buffer has storage, index0 and length
+ * properties in the usual way, designating a slice (or all) of a byte array, but also a
+ * stride property (equal to getStrides()[0]).
+ * 

+ * Let the underlying buffer be the byte array u(i) for i=0..N-1, let x be the
+ * Strided1DNIOBuffer, and let the stride be p. The storage works as follows.
+ * Designate by x(j), for j=0..L-1, the byte at index j, that is, the byte
+ * retrieved by x.byteAt(j). Thus, we store x(j) at u(a+pj), that is,
+ * x(0) = u(a). When we construct such a buffer, we have to supply a =
+ * index0, L = count, and p = stride as the
+ * constructor arguments. The last item in the slice x(L-1) is stored at u(a+p(L-1)).
+ * For the simple case of positive stride, constructor argument index0 is the low index
+ * of the range occupied by the data. When the stride is negative, that is to say p<0, and
+ * L>1, this will be to the left of u(a), and the constructor argument
+ * index0 is not then the low index of the range occupied by the data. Clearly both
+ * these indexes must be in the range 0 to N-1 inclusive, a rule enforced by the constructors
+ * (unless L=0, when it is assumed no array access will take place).
+ * 

+ * The class may be used by exporters to create a strided slice (e.g. to export the diagonal of a
+ * matrix) and in particular by other buffers to create strided slices of themselves, such as to
+ * create the memoryview that is returned as an extended slice of a
+ * memoryview.
+ */
+public class Strided1DNIOBuffer extends BaseNIOBuffer {
+
+    /**
+     * Step size in the underlying buffer essential to correct translation of an index (or indices)
+     * into an index into the storage. The value is returned by {@link #getStrides()} is an array
+     * with this as the only element.
+     */
+    protected int stride;
+
+
+    /**
+     * Provide an instance of Strided1DNIOBuffer with navigation variables initialised,
+     * for sub-class use. The buffer ({@link #storage}, {@link #index0}), and the navigation (
+     * {@link #shape} array and {@link #stride}) will be initialised from the arguments (which are
+     * checked for range).
+     * 

+     * The sub-class constructor should check that the intended access is compatible with this
+     * object by calling {@link #checkRequestFlags(int)}. (See the source of
+     * {@link Strided1DWritableBuffer#Strided1DWritableBuffer(int, ByteBuffer, int, int, int)}
+     * for an example of this use.)
+     *
+     * @param storage the ByteBuffer wrapping the exported object state. NOTE: this
+     *            PyBuffer keeps a reference and may manipulate the position, mark and
+     *            limit hereafter. Use {@link ByteBuffer#duplicate()} to give it an isolated copy.
+     * @param index0 index into storage of item[0]
+     * @param count number of items in the slice
+     * @param stride in between successive elements of the new PyBuffer
+     * @throws NullPointerException if storage is null
+     * @throws ArrayIndexOutOfBoundsException if index0, count and
+     *             stride are inconsistent with storage.length
+     */
+    protected Strided1DNIOBuffer(ByteBuffer storage, int index0, int count, int stride)
+            throws ArrayIndexOutOfBoundsException, NullPointerException {
+        super(storage, STRIDES);
+        this.index0 = index0;           // Index to be treated as item[0]
+        shape = new int[]{count};       // Number of items in exported data
+        this.stride = stride;           // Between items
+        this.strides = new int[] {stride};
+
+        if (count == 0) {
+            // Nothing to check as we'll make no accesses
+            addFeatureFlags(CONTIGUITY);
+
+        } else {
+            // Need to check lowest and highest index against array
+            int lo, hi;
+
+            if (stride == 1) {
+                lo = index0;                                // First byte of item[0]
+                hi = index0 + count;                        // Last byte of item[L-1] + 1
+                addFeatureFlags(CONTIGUITY);
+
+            } else if (stride > 1) {
+                lo = index0;                                // First byte of item[0]
+                hi = index0 + (count - 1) * stride + 1;     // Last byte of item[L-1] + 1
+
+            } else {
+                hi = index0 + 1;                            // Last byte of item[0] + 1
+                lo = index0 + (count - 1) * stride;         // First byte of item[L-1]
+            }
+
+            // Check indices using "all non-negative" trick
+            int cap = storage.capacity();
+            if ((count | lo | (cap - lo) | hi | (cap - hi)) < 0) {
+                throw new ArrayIndexOutOfBoundsException();
+            }
+        }
+
+        // Deduce feature flags from the client's ByteBuffer
+        if (!storage.isReadOnly()) {
+            addFeatureFlags(WRITABLE);
+        }
+        if (storage.hasArray()) {
+            addFeatureFlags(AS_ARRAY);
+        }
+    }
+
+   /**
+     * Provide an instance of Strided1DNIOBuffer on a particular {@link ByteBuffer}
+     *  specifying
+     * a starting index, the number of items in the result, and a byte-indexing stride. The result
+     * of byteAt(i) will be equal to storage.get(index0+stride*i)
+     * (whatever
+     * the sign of stride), valid for 0<=i<count. The constructor
+     * checks that all these indices lie within the storage (unless
+     * count=0).
+     * No reference will be kept to the ByteBuffer passed in. (It is duplicated.)
+     * 

+     * The constructed PyBuffer meets the consumer's expectations as expressed in the
+     * flags argument, or an exception will be thrown if these are incompatible with
+     * the type (e.g. the consumer does not specify that it understands the strides array). Note
+     * that the actual range in the storage array, the lowest and highest index, is not
+     * explicitly passed, but is implicit in index0, count and
+     * stride. The constructor checks that these indices lie within the
+     * storage array (unless count=0).
+     *
+     * @param flags consumer requirements
+     * @param storage ByteBuffer wrapping exported data
+     * @param index0 index into storage of item[0]
+     * @param count number of items in the slice
+     * @param stride in between successive elements of the new PyBuffer
+     * @throws NullPointerException if storage is null
+     * @throws ArrayIndexOutOfBoundsException if index0, count and
+     *             stride are inconsistent with storage.length
+     * @throws PyException (BufferError) when expectations do not correspond with the type
+     */
+    public Strided1DNIOBuffer(int flags, ByteBuffer storage, int index0, int count, int stride)
+            throws ArrayIndexOutOfBoundsException, NullPointerException, PyException {
+        this(storage.duplicate(), index0, count, stride);
+        checkRequestFlags(flags);   // Check request is compatible with type
+
+    }
+
+    @Override
+    protected int byteIndex(int index) throws IndexOutOfBoundsException {
+        return index0 + index * stride;
+    }
+
+     /**
+     * {@inheritDoc}
+     * 

+     * Strided1DNIOBuffer provides an implementation for slicing already-strided bytes in
+     * one dimension. In that case, x(i) = u(r+ip) for i = 0..L-1 where u is the
+     * underlying buffer, and r, p and L are the start, stride and count with
+     * which x was created from u. Thus y(k) = u(r+sp+kmp), that is, the
+     * composite index0 is r+sp and the composite stride is
+     * mp.
+     */
+    @Override
+    public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
+
+        if (count > 0) {
+            // Translate start relative to underlying buffer
+            int compStride = this.stride * stride;
+            int compIndex0 = index0 + start * this.stride;
+            // Construct a view, taking a lock on the root object (this or this.root)
+            return new SlicedView(getRoot(), flags, storage, compIndex0, count, compStride);
+
+        } else {
+            // Special case for count==0 where above logic would fail. Efficient too.
+            return new ZeroByteBuffer.View(getRoot(), flags);
+        }
+    }
+
+
+    /**
+     * A Strided1DNIOBuffer.SlicedView represents a non-contiguous subsequence of a simple
+     * buffer.
+     */
+    static class SlicedView extends Strided1DNIOBuffer {
+
+        /** The buffer on which this is a slice view */
+        PyBuffer root;
+
+        /**
+         * Construct a slice of a one-dimensional byte buffer.
+         *
+         * @param root on which release must be called when this is released
+         * @param flags consumer requirements
+         * @param storage ByteBuffer wrapping exported data (no reference kept)
+         * @param index0 index into storage of item[0]
+         * @param len number of items in the slice
+         * @param stride in between successive elements of the new PyBuffer
+         * @throws PyException (BufferError) when expectations do not correspond with the type
+         */
+        public SlicedView(PyBuffer root, int flags, ByteBuffer storage, int index0, int len, int stride)
+                throws PyException {
+            // Create a new slice on the buffer passed in (part of the root)
+            super(flags, storage, index0, len, stride);
+            // Get a lease on the root PyBuffer (read-only)
+            this.root = root.getBuffer(FULL_RO);
+        }
+
+        @Override
+        protected PyBuffer getRoot() {
+            return root;
+        }
+
+        @Override
+        public void releaseAction() {
+            // We have to release the root too if ours was final.
+            root.release();
+        }
+
+    }
+}
diff --git a/tests/java/org/python/core/PyBufferNIOTest.java b/tests/java/org/python/core/PyBufferNIOTest.java
new file mode 100644
--- /dev/null
+++ b/tests/java/org/python/core/PyBufferNIOTest.java
@@ -0,0 +1,316 @@
+package org.python.core;
+
+import java.lang.ref.WeakReference;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.runners.Parameterized.Parameters;
+import org.python.core.ByteBufferTestSupport.ByteMaterial;
+import org.python.core.PyBufferTest.TestableExporter;
+import org.python.core.PyBufferTestSupport.ExporterFactory;
+import org.python.core.PyBufferTestSupport.TestSpec;
+import org.python.core.PyBufferTestSupport.WritableExporterFactory;
+import org.python.core.buffer.BaseBuffer;
+import org.python.core.buffer.SimpleNIOBuffer;
+
+public class PyBufferNIOTest extends PyBufferTest {
+
+    public PyBufferNIOTest(TestSpec spec) {
+        super(spec);
+    }
+
+    /**
+     * Generate test data to be held in the testing framework and used to construct tests. This
+     * method is called once by the test framework. Each element of the returned collection is a
+     * specification that becomes the arguments to the constructor when JUnit prepares to invoke a
+     * test.
+     * 

+     * Internally, this method creates a small number of instances of the object types whose
+     * PyBuffer export mechanism is to be tested. Each is paired with a reference value
+     * represented in several forms. The PyBufferTestSupport class then multiplies
+     * these by creating a selection of feasible sliced views, the whole collection of root and
+     * slice objects being returned.
+     *
+     * @return generated list of test data
+     */
+    @Parameters
+    public static Collection genTestSpecs() {
+
+        PyBufferTestSupport s = new PyBufferTestSupport(sliceLengths, sliceSteps);
+
+        // Tests using local types of exporter
+
+        ExporterFactory rollYourOwnExporter = new WritableExporterFactory() {
+
+            @Override
+            public BufferProtocol make(ByteMaterial m) {
+                return new RollYourOwnExporter(m.getBuffer());
+            }
+
+        };
+        s.add(rollYourOwnExporter, byteMaterial);
+        s.add(rollYourOwnExporter, emptyMaterial);
+
+        // All combinations of heap/direct, writable and empty/small/large (I'm so thorough!)
+
+        ExporterFactory readonlyHeapNIOExporter = new TestNIOExporterFactory(false, false);
+        s.add(readonlyHeapNIOExporter, emptyMaterial);
+        s.add(readonlyHeapNIOExporter, byteMaterial);
+        s.add(readonlyHeapNIOExporter, longMaterial);
+
+        ExporterFactory writableHeapNIOExporter = new TestNIOExporterFactory(true, false);
+        s.add(writableHeapNIOExporter, emptyMaterial);
+        s.add(writableHeapNIOExporter, byteMaterial);
+        s.add(writableHeapNIOExporter, longMaterial);
+
+        ExporterFactory readonlyDirectNIOExporter = new TestNIOExporterFactory(false, true);
+        s.add(readonlyDirectNIOExporter, emptyMaterial);
+        s.add(readonlyDirectNIOExporter, byteMaterial);
+        s.add(readonlyDirectNIOExporter, longMaterial);
+
+        ExporterFactory writableDirectNIOExporter = new TestNIOExporterFactory(true, true);
+        s.add(writableDirectNIOExporter, emptyMaterial);
+        s.add(writableDirectNIOExporter, byteMaterial);
+        s.add(writableDirectNIOExporter, longMaterial);
+
+        // Return the generated test data
+
+        List ret = s.getTestData();
+        if (PRINT_KEY) {
+            int key = 0;
+            for (TestSpec[] r : ret) {
+                TestSpec spec = r[0];
+                System.out.printf("%6d : %s\n", key++, spec.toString());
+            }
+        }
+        return ret;
+    }
+
+    /*
+     * --------------------------------------------------------------------------------------------
+     * A series of custom exporters that use a java.nio.ByteBuffer to store and export their
+     * implementation data.
+     * --------------------------------------------------------------------------------------------
+     */
+    /**
+     * A class to act as an exporter that uses the SimpleBuffer. The exporter shares a single
+     * exported buffer between all consumers and needs to take any action immediately when that
+     * buffer is finally released. You are most likely to use this approach with an exporting object
+     * type that modifies its behaviour while there are active exports, but where it is worth
+     * avoiding the cost of duplicate buffers. This is the case with PyByteArray, which prohibits
+     * operations that would resize it, while there are outstanding exports.
+     */
+    private static class TestNIOExporter extends TestableExporter {
+
+        protected ByteBuffer storage;
+
+        /**
+         * Construct a simple exporter from the bytes supplied.
+         *
+         * @param storage
+         */
+        public TestNIOExporter(ByteBuffer storage) {
+            this.storage = storage;
+        }
+
+        @Override
+        public PyBuffer getBuffer(int flags) {
+            // If we have already exported a buffer it may still be available for re-use
+            BaseBuffer pybuf = getExistingBuffer(flags);
+            if (pybuf == null) {
+                // No existing export we can re-use
+                pybuf = new SimpleNIOBuffer(flags, storage) {
+
+                    @Override
+                    protected void releaseAction() {
+                        export = null; // Final release really is final (not reusable)
+                    }
+                };
+
+                // Hold a reference for possible re-use
+                export = new WeakReference(pybuf);
+            }
+            return pybuf;
+        }
+
+    }
+
+    /**
+     * A factory for exporting objects to be used in the tests. These objects use a
+     * ByteBuffer for their exported representation, and the factory is programmed on
+     * creation to whether these buffers should be writable or direct.
+     */
+    static class TestNIOExporterFactory implements ExporterFactory {
+
+        final boolean writable;
+        final boolean isDirect;
+
+        TestNIOExporterFactory(boolean writable, boolean isDirect) {
+            this.writable = writable;
+            this.isDirect = isDirect;
+        }
+
+        public boolean isWritable() {
+            return writable;
+        }
+
+        public boolean isDirect() {
+            return isDirect;
+        }
+
+        @Override
+        public BufferProtocol make(ByteMaterial m) {
+            ByteBuffer bb = m.getBuffer();
+            if (isDirect) {
+                // Replace bb with a direct buffer containing the same bytes
+                ByteBuffer direct = ByteBuffer.allocateDirect(bb.capacity());
+                direct.put(bb).flip();
+                bb = direct;
+            }
+            if (!writable) {
+                bb = bb.asReadOnlyBuffer();
+            }
+            return new TestNIOExporter(bb);
+        }
+
+        @Override
+        public boolean isReadonly() {
+            return !writable;
+        }
+
+        @Override
+        public boolean hasArray() {
+            return !isDirect && writable;
+        }
+
+    }
+
+    /** A class to act as an exporter that uses the RollYourOwnNIOBuffer class. */
+    private static class RollYourOwnExporter extends TestableExporter {
+
+        protected ByteBuffer storage;
+
+        public RollYourOwnExporter(ByteBuffer storage) {
+            this.storage = storage;
+        }
+
+        @Override
+        public PyBuffer getBuffer(int flags) {
+            // If we have already exported a buffer it may still be available for re-use
+            BaseBuffer pybuf = getExistingBuffer(flags);
+            if (pybuf == null) {
+                // No existing export we can re-use
+                pybuf = new RollYourOwnNIOBuffer(flags, storage);
+                // Hold a reference for possible re-use
+                export = new WeakReference(pybuf);
+            }
+            return pybuf;
+        }
+
+    }
+
+    /**
+     * Minimal extension of BaseBuffer in order to test the default implementations there. They're
+     * slow, so mostly we override them in the implementations BaseArrayBuffer and BaseNIOBuffer,
+     * but they still have to be correct. The class represents a one-dimensional, strided array of
+     * bytes, so it can represent a slice of itself.
+     */
+    private static class RollYourOwnNIOBuffer extends BaseBuffer {
+
+        final static int FEATURES = PyBUF.WRITABLE | PyBUF.AS_ARRAY;
+
+        final ByteBuffer storage;
+        final PyBuffer root;
+
+        /**
+         * Create a buffer view of a given ByteBuffer in which the data is the
+         * contiguous sequence of bytes from the position to the limit.
+         *
+         * @param flags consumer requirements
+         * @param storage buffer exported (from the position to the limit)
+         */
+        public RollYourOwnNIOBuffer(int flags, ByteBuffer storage) {
+            this(null /* =this */, flags, storage, storage.position(), storage.remaining(), 1);
+        }
+
+        /**
+         * Construct a slice of a one-dimensional byte buffer.
+         *
+         * @param root on which release must be called when this is released
+         * @param flags consumer requirements
+         * @param storage buffer containing exported data
+         * @param index0 index into storage of item[0]
+         * @param count number of items in the slice
+         * @param stride in between successive elements of the new PyBuffer
+         * @throws PyException (BufferError) when expectations do not correspond with the type
+         */
+        public RollYourOwnNIOBuffer(PyBuffer root, int flags, ByteBuffer storage, int index0,
+                int count, int stride) throws IndexOutOfBoundsException, NullPointerException,
+                PyException {
+            // Client will need to navigate using shape and strides if this is a slice
+            super(FEATURES | ((index0 == 0 && stride == 1) ? 0 : PyBUF.STRIDES));
+            this.storage = storage.duplicate();
+            this.index0 = index0;
+            shape = new int[] {count};
+            strides = new int[] {stride};
+            // Check the potential index range
+            if (count > 0) {
+                int end = index0 + (count - 1) * stride;
+                final int END = storage.capacity() - 1;
+                if (index0 < 0 || index0 > END || end < 0 || end > END) {
+                    throw new IndexOutOfBoundsException();
+                }
+            }
+            // Check client is compatible
+            checkRequestFlags(flags);
+            // Get a lease on the root PyBuffer (read-only). Last in case a check above fails.
+            if (root == null) {
+                this.root = this;
+            } else {
+                this.root = root.getBuffer(FULL_RO);
+            }
+        }
+
+        @Override
+        protected PyBuffer getRoot() {
+            return root;
+        }
+
+        @Override
+        public void releaseAction() {
+            // XXX Consider making this automatic within BaseBuffer.release() when getRoot()!=this
+            /*
+             * ... so that {@link #release()} takes care of this: sub-classes should not propagate
+             * the release themselves when overriding {@link #releaseAction()}.
+             */
+            // We have to release the root too if ours was final and we are not that root.
+            if (root != this) {
+                root.release();
+            }
+        }
+
+        @Override
+        public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
+            int newStart = index0 + start * strides[0];
+            int newStride = strides[0] * stride;
+            return new RollYourOwnNIOBuffer(root, flags, storage, newStart, count, newStride);
+        }
+
+        @Override
+        public ByteBuffer getNIOByteBufferImpl() {
+            return storage.duplicate();
+        }
+
+        @Override
+        protected byte byteAtImpl(int byteIndex) {
+            return storage.get(byteIndex);
+        }
+
+        @Override
+        protected void storeAtImpl(byte value, int byteIndex) throws IndexOutOfBoundsException,
+                PyException {
+            storage.put(byteIndex, value);
+        }
+    }
+}
diff --git a/tests/java/org/python/core/PyBufferTest.java b/tests/java/org/python/core/PyBufferTest.java
--- a/tests/java/org/python/core/PyBufferTest.java
+++ b/tests/java/org/python/core/PyBufferTest.java
@@ -1242,7 +1242,7 @@
 
     }
 
-    /** A class to act as an exporter that uses the RollYourOwnBuffer. */
+    /** A class to act as an exporter that uses the RollYourOwnArrayBuffer class. */
     private static class RollYourOwnExporter extends TestableExporter {
 
         protected byte[] storage;
@@ -1290,28 +1290,28 @@
         }
 
         /**
-         * Construct a slice of a one-dimensional byte buffer.
+         * Construct a slice of a one-dimensional byte array.
          *
          * @param root on which release must be called when this is released
          * @param flags consumer requirements
          * @param storage raw byte array containing exported data
          * @param index0 index into storage of item[0]
-         * @param length number of items in the slice
+         * @param count number of items in the slice
          * @param stride in between successive elements of the new PyBuffer
          * @throws PyException (BufferError) when expectations do not correspond with the type
          */
         public RollYourOwnArrayBuffer(PyBuffer root, int flags, byte[] storage, int index0,
-                int length, int stride) throws ArrayIndexOutOfBoundsException,
-                NullPointerException, PyException {
+                int count, int stride) throws IndexOutOfBoundsException, NullPointerException,
+                PyException {
             // Client will need to navigate using shape and strides if this is a slice
             super(FEATURES | ((index0 == 0 && stride == 1) ? 0 : PyBUF.STRIDES));
             this.storage = storage;
             this.index0 = index0;
-            shape = new int[] {length};
+            shape = new int[] {count};
             strides = new int[] {stride};
             // Check the potential index range
-            if (length > 0) {
-                int end = index0 + (length - 1) * stride;
+            if (count > 0) {
+                int end = index0 + (count - 1) * stride;
                 final int END = storage.length - 1;
                 if (index0 < 0 || index0 > END || end < 0 || end > END) {
                     throw new IndexOutOfBoundsException();
@@ -1367,6 +1367,5 @@
                 PyException {
             storage[byteIndex] = value;
         }
-
     }
 }

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sat Aug 27 09:12:25 2016
From: jython-checkins at python.org (jeff.allen)
Date: Sat, 27 Aug 2016 13:12:25 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_BaseBuffer_implementation_t?=
 =?utf-8?q?akes_care_of_cascading_release=28=29=2E?=
Message-ID: <20160827131225.18237.1860.EB342CD1@psf.io>

https://hg.python.org/jython/rev/4a92b336647a
changeset:   7947:4a92b336647a
user:        Jeff Allen 
date:        Thu Jun 30 12:45:54 2016 +0100
summary:
  BaseBuffer implementation takes care of cascading release().

No longer have to override releaseAction() to cascade a release
notification from a sliced view of a PyBuffer.

files:
  src/org/python/core/buffer/BaseBuffer.java              |  11 +++++-
  src/org/python/core/buffer/SimpleBuffer.java            |   9 -----
  src/org/python/core/buffer/SimpleNIOBuffer.java         |   8 ----
  src/org/python/core/buffer/SimpleStringBuffer.java      |   7 ----
  src/org/python/core/buffer/SimpleWritableBuffer.java    |   8 ----
  src/org/python/core/buffer/Strided1DBuffer.java         |   9 -----
  src/org/python/core/buffer/Strided1DNIOBuffer.java      |   7 ----
  src/org/python/core/buffer/Strided1DWritableBuffer.java |   8 ----
  src/org/python/core/buffer/ZeroByteBuffer.java          |   6 ---
  tests/java/org/python/core/PyBufferNIOTest.java         |  13 -------
  tests/java/org/python/core/PyBufferTest.java            |  17 +--------
  11 files changed, 12 insertions(+), 91 deletions(-)


diff --git a/src/org/python/core/buffer/BaseBuffer.java b/src/org/python/core/buffer/BaseBuffer.java
--- a/src/org/python/core/buffer/BaseBuffer.java
+++ b/src/org/python/core/buffer/BaseBuffer.java
@@ -580,13 +580,22 @@
      * equals the number of getBuffer calls), the implementation here calls
      * {@link #releaseAction()}, which the implementer of a specific buffer type should override if
      * it needs specific actions to take place.
+     * 

+     * Note that, when this is a sliced view obtained from another PyBuffer the
+     * implementation in BaseBuffer automatically sends one release()
+     * Sub-classes should not propagate the release themselves when overriding
+     * {@link #releaseAction()}.
      */
     @Override
     public void release() {
         if (--exports == 0) {
             // This is a final release.
             releaseAction();
-            // XXX Consider adding release of root if root!=this so sliced need not
+            // We have to release the root too if we are not a root.
+            PyBuffer root = getRoot();
+            if (root != this) {
+                root.release();
+            }
         } else if (exports < 0) {
             // Buffer already had 0 exports. (Put this right, in passing.)
             exports = 0;
diff --git a/src/org/python/core/buffer/SimpleBuffer.java b/src/org/python/core/buffer/SimpleBuffer.java
--- a/src/org/python/core/buffer/SimpleBuffer.java
+++ b/src/org/python/core/buffer/SimpleBuffer.java
@@ -9,7 +9,6 @@
  */
 public class SimpleBuffer extends BaseArrayBuffer {
 
-
     /**
      * Provide an instance of SimpleBuffer with navigation variables initialised, for
      * sub-class use. The buffer ({@link #storage}, {@link #index0}), and the {@link #shape} array
@@ -199,13 +198,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // We have to release the root too if ours was final.
-            root.release();
-        }
-
     }
-
 }
diff --git a/src/org/python/core/buffer/SimpleNIOBuffer.java b/src/org/python/core/buffer/SimpleNIOBuffer.java
--- a/src/org/python/core/buffer/SimpleNIOBuffer.java
+++ b/src/org/python/core/buffer/SimpleNIOBuffer.java
@@ -185,13 +185,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // We have to release the root too if ours was final.
-            root.release();
-        }
-
     }
-
 }
diff --git a/src/org/python/core/buffer/SimpleStringBuffer.java b/src/org/python/core/buffer/SimpleStringBuffer.java
--- a/src/org/python/core/buffer/SimpleStringBuffer.java
+++ b/src/org/python/core/buffer/SimpleStringBuffer.java
@@ -214,12 +214,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // We have to release the root too if ours was final.
-            root.release();
-        }
-
     }
 }
diff --git a/src/org/python/core/buffer/SimpleWritableBuffer.java b/src/org/python/core/buffer/SimpleWritableBuffer.java
--- a/src/org/python/core/buffer/SimpleWritableBuffer.java
+++ b/src/org/python/core/buffer/SimpleWritableBuffer.java
@@ -130,13 +130,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // We have to release the root too if ours was final.
-            root.release();
-        }
-
     }
-
 }
diff --git a/src/org/python/core/buffer/Strided1DBuffer.java b/src/org/python/core/buffer/Strided1DBuffer.java
--- a/src/org/python/core/buffer/Strided1DBuffer.java
+++ b/src/org/python/core/buffer/Strided1DBuffer.java
@@ -208,14 +208,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // XXX Consider making this automatic within BaseBuffer.release() when getRoot()!=this
-            // We have to release the root too if ours was final.
-            root.release();
-        }
-
     }
-
 }
diff --git a/src/org/python/core/buffer/Strided1DNIOBuffer.java b/src/org/python/core/buffer/Strided1DNIOBuffer.java
--- a/src/org/python/core/buffer/Strided1DNIOBuffer.java
+++ b/src/org/python/core/buffer/Strided1DNIOBuffer.java
@@ -200,12 +200,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // We have to release the root too if ours was final.
-            root.release();
-        }
-
     }
 }
diff --git a/src/org/python/core/buffer/Strided1DWritableBuffer.java b/src/org/python/core/buffer/Strided1DWritableBuffer.java
--- a/src/org/python/core/buffer/Strided1DWritableBuffer.java
+++ b/src/org/python/core/buffer/Strided1DWritableBuffer.java
@@ -116,13 +116,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // We have to release the root too if ours was final.
-            root.release();
-        }
-
     }
-
 }
diff --git a/src/org/python/core/buffer/ZeroByteBuffer.java b/src/org/python/core/buffer/ZeroByteBuffer.java
--- a/src/org/python/core/buffer/ZeroByteBuffer.java
+++ b/src/org/python/core/buffer/ZeroByteBuffer.java
@@ -184,11 +184,5 @@
         protected PyBuffer getRoot() {
             return root;
         }
-
-        @Override
-        public void releaseAction() {
-            // We have to release the root too if ours was final.
-            root.release();
-        }
     }
 }
diff --git a/tests/java/org/python/core/PyBufferNIOTest.java b/tests/java/org/python/core/PyBufferNIOTest.java
--- a/tests/java/org/python/core/PyBufferNIOTest.java
+++ b/tests/java/org/python/core/PyBufferNIOTest.java
@@ -276,19 +276,6 @@
         }
 
         @Override
-        public void releaseAction() {
-            // XXX Consider making this automatic within BaseBuffer.release() when getRoot()!=this
-            /*
-             * ... so that {@link #release()} takes care of this: sub-classes should not propagate
-             * the release themselves when overriding {@link #releaseAction()}.
-             */
-            // We have to release the root too if ours was final and we are not that root.
-            if (root != this) {
-                root.release();
-            }
-        }
-
-        @Override
         public PyBuffer getBufferSlice(int flags, int start, int count, int stride) {
             int newStart = index0 + start * strides[0];
             int newStride = strides[0] * stride;
diff --git a/tests/java/org/python/core/PyBufferTest.java b/tests/java/org/python/core/PyBufferTest.java
--- a/tests/java/org/python/core/PyBufferTest.java
+++ b/tests/java/org/python/core/PyBufferTest.java
@@ -945,8 +945,8 @@
         } else if (subject instanceof PyByteArray) {
             // Size-changing access should fail
             try {
-                ((PyByteArray)subject).bytearray_extend(Py.One); // Appends one zero byte
-                fail("bytearray_extend with exports should fail");
+                ((PyByteArray)subject).bytearray_append(Py.One); // Appends one zero byte
+                fail("bytearray_append with exports should fail");
             } catch (Exception e) {
                 // Success
             }
@@ -1509,19 +1509,6 @@
         }
 
         @Override
-        public void releaseAction() {
-            // XXX Consider making this automatic within BaseBuffer.release() when getRoot()!=this
-            /*
-             * ... so that {@link #release()} takes care of this: sub-classes should not propagate
-             * the release themselves when overriding {@link #releaseAction()}.
-             */
-            // We have to release the root too if ours was final and we are not that root.
-            if (root != this) {
-                root.release();
-            }
-        }
-
-        @Override
         public PyBuffer getBufferSlice(int flags, int start, int length, int stride) {
             int newStart = index0 + start * strides[0];
             int newStride = strides[0] * stride;

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sat Aug 27 09:12:26 2016
From: jython-checkins at python.org (jeff.allen)
Date: Sat, 27 Aug 2016 13:12:26 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Minor_additions_to_PyBuffer?=
 =?utf-8?q?_implementations_and_add_NEWS=2E?=
Message-ID: <20160827131225.27675.35035.69AEF207@psf.io>

https://hg.python.org/jython/rev/92b8a1f732f1
changeset:   7949:92b8a1f732f1
user:        Jeff Allen 
date:        Sat Aug 27 07:56:23 2016 +0100
summary:
  Minor additions to PyBuffer implementations and add NEWS.

This change tidies up some comments and variable names, adds some
bounds-checks. Finally, flag up the API change in NEWS.

files:
  NEWS                                                |   6 +
  src/org/python/core/PyBuffer.java                   |   6 +-
  src/org/python/core/buffer/BaseNIOBuffer.java       |  75 ++++++---
  src/org/python/core/buffer/SimpleNIOBuffer.java     |   6 -
  tests/java/org/python/core/PyBufferTestSupport.java |   1 +
  5 files changed, 56 insertions(+), 38 deletions(-)


diff --git a/NEWS b/NEWS
--- a/NEWS
+++ b/NEWS
@@ -9,6 +9,12 @@
   New Features
     - Use latest upstream bundled wheels for ensurepip: pip (7.1.2), setuptools (18.4),
       replacing wheels patched specifically for Jython
+    - Buffer API changes allow java.nio.ByteBuffer to provide the storage when a PyBuffer
+      is exported. This is to support CPython extensions via JyNI, but has other uses too
+      (including access to direct memory buffers from Python). There is no change at the
+      Python level or for client code using PyBuffer via the "fully encapsulated" API. It
+      risks breaking code that makes direct access to a byte array via PyBuffer, implements
+      the PyBuffer interface, or extends implementation classes in org.python.core.buffer.
 
 Jython 2.7.1b2
   Bugs fixed
diff --git a/src/org/python/core/PyBuffer.java b/src/org/python/core/PyBuffer.java
--- a/src/org/python/core/PyBuffer.java
+++ b/src/org/python/core/PyBuffer.java
@@ -151,9 +151,9 @@
             throws IndexOutOfBoundsException, PyException;
 
     /**
-     * Copy the whole of another PyBuffer into this buffer. This may validly be done only for
-     * buffers that are consistent in their dimensions. When it is necessary to copy partial
-     * buffers, this may be achieved using a buffer slice on the source or destination.
+     * Copy the whole of another PyBuffer into this buffer. This may validly be done
+     * only for buffers that are consistent in their dimensions. When it is necessary to copy
+     * partial buffers, this may be achieved using a buffer slice on the source or destination.
      *
      * @param src source buffer
      * @throws IndexOutOfBoundsException if access out of bounds in source or destination
diff --git a/src/org/python/core/buffer/BaseNIOBuffer.java b/src/org/python/core/buffer/BaseNIOBuffer.java
--- a/src/org/python/core/buffer/BaseNIOBuffer.java
+++ b/src/org/python/core/buffer/BaseNIOBuffer.java
@@ -68,11 +68,12 @@
     }
 
     @Override
-    protected void storeAtImpl(byte value, int byteIndex) throws IndexOutOfBoundsException,
-            PyException {
-        // XXX consider catching ReadonlyBufferException instead of checking (and others: index?)
-        checkWritable();
-        storage.put(byteIndex, value);
+    protected void storeAtImpl(byte value, int byteIndex) throws PyException {
+        try {
+            storage.put(byteIndex, value);
+        } catch (ReadOnlyBufferException rbe) {
+            throw notWritable();
+        }
     }
 
     @Override
@@ -97,27 +98,33 @@
     }
 
     /**
-     * {@inheritDoc}
-     * 

-     * The default implementation in BaseBuffer deals with the general one-dimensional
-     * case of arbitrary item size and stride.
+     * Copy all items in this buffer into a ByteBuffer, starting at its current
+     * position.
+     *
+     * @param dest destination buffer
+     * @throws BufferOverflowException
+     * @throws ReadOnlyBufferException
      */
     // XXX Should this become part of the PyBUffer interface?
-    public void copyTo(ByteBuffer dest) throws BufferOverflowException, ReadOnlyBufferException,
-            PyException {
+    public void copyTo(ByteBuffer dest) throws BufferOverflowException, ReadOnlyBufferException {
         // Note shape[0] is the number of items in the buffer
         copyTo(0, dest, shape[0]);
     }
 
     /**
-     * {@inheritDoc}
-     * 

-     * The default implementation in BaseNIOBuffer deals with the general
-     * one-dimensional case of arbitrary item size and stride.
+     * Copy a specified number of items from a particular location in this buffer into a
+     * ByteBuffer, starting at its current position. .
+     *
+     * @param srcIndex index of the first item to copy
+     * @param dest destination buffer
+     * @param count number of items to copy
+     * @throws BufferOverflowException
+     * @throws ReadOnlyBufferException
+     * @throws IndexOutOfBoundsException
      */
     // XXX Should this become part of the PyBuffer interface?
     protected void copyTo(int srcIndex, ByteBuffer dest, int count) throws BufferOverflowException,
-            ReadOnlyBufferException, IndexOutOfBoundsException, PyException {
+            ReadOnlyBufferException, IndexOutOfBoundsException {
 
         if (count > 0) {
 
@@ -168,38 +175,48 @@
     }
 
     /**
-     * {@inheritDoc}
-     * 

-     * The default implementation in BaseNIOBuffer deals with the general
-     * one-dimensional case of arbitrary item size and stride.
+     * Copy a specified number of items from a ByteBuffer into this buffer at a
+     * particular location.
+     *
+     * @param src source ByteBuffer
+     * @param destIndex starting item-index in the destination (i.e. this)
+     * @param count number of items to copy in
+     * @throws IndexOutOfBoundsException if access out of bounds in source or destination
+     * @throws PyException (TypeError) if read-only buffer
      */
     // XXX Should this become part of the PyBUffer interface?
-    protected void copyFrom(ByteBuffer src, int dstIndex, int count)
+    protected void copyFrom(ByteBuffer src, int destIndex, int count)
             throws IndexOutOfBoundsException, PyException {
 
         checkWritable();
 
         if (count > 0) {
 
-            ByteBuffer dst = getNIOByteBuffer();
-            int pos = byteIndex(dstIndex);
+            ByteBuffer dest = getNIOByteBuffer();
+            int pos = byteIndex(destIndex);
 
             // Pick up attributes necessary to choose an efficient copy strategy
             int itemsize = getItemsize();
             int stride = getStrides()[0];
             int skip = stride - itemsize;
+            int size = getSize();
+
+            // Check indexes in destination (this) using the "all non-negative" trick
+            if ((destIndex | count | size - (destIndex + count)) < 0) {
+                throw new IndexOutOfBoundsException();
+            }
 
             // Strategy depends on whether items are laid end-to-end or there are gaps
             if (skip == 0) {
                 // Straight copy of contiguous bytes
-                dst.position(pos);
-                dst.put(src);
+                dest.position(pos);
+                dest.put(src);
 
             } else if (itemsize == 1) {
                 // Non-contiguous copy: single byte items
                 for (int i = 0; i < count; i++) {
-                    dst.position(pos);
-                    dst.put(src.get());
+                    dest.position(pos);
+                    dest.put(src.get());
                     // Next byte written will be here
                     pos += stride;
                 }
@@ -207,10 +224,10 @@
             } else {
                 // Non-contiguous copy: each time, copy itemsize bytes at a time
                 for (int i = 0; i < count; i++) {
-                    dst.position(pos);
+                    dest.position(pos);
                     // Delineate the next itemsize bytes in the src
                     src.limit(src.position() + itemsize);
-                    dst.put(src);
+                    dest.put(src);
                     // Next byte written will be here
                     pos += stride;
                 }
diff --git a/src/org/python/core/buffer/SimpleNIOBuffer.java b/src/org/python/core/buffer/SimpleNIOBuffer.java
--- a/src/org/python/core/buffer/SimpleNIOBuffer.java
+++ b/src/org/python/core/buffer/SimpleNIOBuffer.java
@@ -9,15 +9,9 @@
 /**
  * Buffer API over a read-only one-dimensional java.nio.ByteBuffer of one-byte items.
  */
-
 public class SimpleNIOBuffer extends BaseNIOBuffer {
 
     /**
-     * The strides array for this type is always a single element array with a 1 in it.
-     */
-    protected static final int[] SIMPLE_STRIDES = {1}; // XXX Push up?
-
-    /**
      * Provide an instance of SimpleNIOBuffer with navigation variables initialised,
      * for sub-class use. The buffer ({@link #storage}, {@link #index0}), and the {@link #shape}
      * array will be initialised from the arguments (which are checked for range). The
diff --git a/tests/java/org/python/core/PyBufferTestSupport.java b/tests/java/org/python/core/PyBufferTestSupport.java
--- a/tests/java/org/python/core/PyBufferTestSupport.java
+++ b/tests/java/org/python/core/PyBufferTestSupport.java
@@ -425,6 +425,7 @@
             while (sb.length() < 30) {
                 sb.append(' ');
             }
+            sb.append(view.isReadonly()?"R ":"W ");
             sb.append("ref = ").append(ref.toString());
 
             return sb.toString();

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sat Aug 27 09:12:25 2016
From: jython-checkins at python.org (jeff.allen)
Date: Sat, 27 Aug 2016 13:12:25 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Add_to_PyBuffer_a_reference?=
 =?utf-8?q?_to_the_exporting_object=2E?=
Message-ID: <20160827131225.113279.72620.10ECBA63@psf.io>

https://hg.python.org/jython/rev/59e3bae3c519
changeset:   7948:59e3bae3c519
user:        Jeff Allen 
date:        Mon Jul 11 13:33:02 2016 +0100
summary:
  Add to PyBuffer a reference to the exporting object.

A getObj() method is added to the interface (emulating the CPython obj
member), and is added to constructors for concrete implementations
provided in the org.python.core.buffer package.

files:
  src/org/python/core/PyArray.java                        |   9 +-
  src/org/python/core/PyBuffer.java                       |   8 ++
  src/org/python/core/PyByteArray.java                    |   2 +-
  src/org/python/core/PyMemoryView.java                   |  17 +++-
  src/org/python/core/PyString.java                       |   2 +-
  src/org/python/core/buffer/BaseBuffer.java              |  11 +++
  src/org/python/core/buffer/BaseNIOBuffer.java           |   2 -
  src/org/python/core/buffer/SimpleBuffer.java            |  29 +++++---
  src/org/python/core/buffer/SimpleNIOBuffer.java         |  29 +++++---
  src/org/python/core/buffer/SimpleStringBuffer.java      |  10 +-
  src/org/python/core/buffer/SimpleWritableBuffer.java    |  16 ++-
  src/org/python/core/buffer/Strided1DBuffer.java         |  12 ++-
  src/org/python/core/buffer/Strided1DNIOBuffer.java      |  17 +++-
  src/org/python/core/buffer/Strided1DWritableBuffer.java |  11 ++-
  src/org/python/core/buffer/ZeroByteBuffer.java          |   8 +-
  src/org/python/modules/_io/PyIOBase.java                |   9 +-
  tests/java/org/python/core/BaseBytesTest.java           |   7 +-
  tests/java/org/python/core/PyBufferNIOTest.java         |  22 +++--
  tests/java/org/python/core/PyBufferTest.java            |  34 ++++++---
  19 files changed, 163 insertions(+), 92 deletions(-)


diff --git a/src/org/python/core/PyArray.java b/src/org/python/core/PyArray.java
--- a/src/org/python/core/PyArray.java
+++ b/src/org/python/core/PyArray.java
@@ -2081,10 +2081,10 @@
                 // This is byte data, so we are within the state of the art
                 byte[] storage = (byte[])data;
                 int size = delegate.getSize();
-                pybuf = new SimpleWritableBuffer(flags, storage, 0, size);
+                pybuf = new SimpleWritableBuffer(flags, this, storage, 0, size);
             } else if ((flags & PyBUF.WRITABLE) == 0) {
                 // As the client only intends to read, fake the answer with a String
-                pybuf = new SimpleStringBuffer(flags, tostring());
+                pybuf = new SimpleStringBuffer(flags, this, tostring());
             } else {
                 // For the time being ...
                 throw Py.NotImplementedError("only array('b') can export a writable buffer");
@@ -2163,7 +2163,6 @@
             return buf.remaining();
         }
 
-
         @Override
         public int read() {
             return buf.hasRemaining() ? buf.get() & 0xff : -1;
@@ -2187,7 +2186,6 @@
         }
     }
 
-
     /* Traverseproc implementation */
     @Override
     public int traverse(Visitproc visit, Object arg) {
@@ -2198,8 +2196,7 @@
     }
 
     @Override
-    public boolean refersDirectlyTo(PyObject ob)
-            throws UnsupportedOperationException {
+    public boolean refersDirectlyTo(PyObject ob) throws UnsupportedOperationException {
         if (data == null || !gc.canLinkToPyObject(data.getClass(), true)) {
             return false;
         }
diff --git a/src/org/python/core/PyBuffer.java b/src/org/python/core/PyBuffer.java
--- a/src/org/python/core/PyBuffer.java
+++ b/src/org/python/core/PyBuffer.java
@@ -30,6 +30,14 @@
     // int getLen();
 
     /**
+     * Return the underlying exporting object (or null if no object implementing the
+     * {@link BufferProtocol} is in that role). This will often be a PyObject.
+     *
+     * @return exporting object (or null)
+     */
+    BufferProtocol getObj();
+
+    /**
      * Return the byte indexed from a one-dimensional buffer with item size one. This is part of the
      * fully-encapsulated API: the buffer implementation exported takes care of navigating the
      * structure of the buffer. Results are undefined where the number of dimensions is not one or
diff --git a/src/org/python/core/PyByteArray.java b/src/org/python/core/PyByteArray.java
--- a/src/org/python/core/PyByteArray.java
+++ b/src/org/python/core/PyByteArray.java
@@ -228,7 +228,7 @@
 
         if (pybuf == null) {
             // No existing export we can re-use: create a new one
-            pybuf = new SimpleWritableBuffer(flags, storage, offset, size);
+            pybuf = new SimpleWritableBuffer(flags, this, storage, offset, size);
             // Hold a reference for possible re-use
             export = new WeakReference(pybuf);
         }
diff --git a/src/org/python/core/PyMemoryView.java b/src/org/python/core/PyMemoryView.java
--- a/src/org/python/core/PyMemoryView.java
+++ b/src/org/python/core/PyMemoryView.java
@@ -75,6 +75,13 @@
         }
     }
 
+    // @ExposedGet(doc = obj_doc) // Not exposed in Python 2.7
+    public PyObject obj() {
+        checkNotReleased();
+        BufferProtocol obj = backing.getObj();
+        return (obj instanceof PyObject) ? (PyObject)obj : Py.None;
+    }
+
     @ExposedGet(doc = format_doc)
     public String format() {
         checkNotReleased();
@@ -843,19 +850,18 @@
         }
     }
 
-
     /* Traverseproc implementation */
     @Override
     public int traverse(Visitproc visit, Object arg) {
         int retVal;
         if (backing != null) {
             if (backing instanceof PyObject) {
-                retVal = visit.visit((PyObject) backing, arg);
+                retVal = visit.visit((PyObject)backing, arg);
                 if (retVal != 0) {
                     return retVal;
                 }
             } else if (backing instanceof Traverseproc) {
-                retVal = ((Traverseproc) backing).traverse(visit, arg);
+                retVal = ((Traverseproc)backing).traverse(visit, arg);
                 if (retVal != 0) {
                     return retVal;
                 }
@@ -878,11 +884,10 @@
 
     @Override
     public boolean refersDirectlyTo(PyObject ob) {
-        if (ob != null && (ob == backing || ob == shape || ob == strides
-            || ob == suboffsets)) {
+        if (ob != null && (ob == backing || ob == shape || ob == strides || ob == suboffsets)) {
             return true;
         } else if (suboffsets instanceof Traverseproc) {
-            return ((Traverseproc) suboffsets).refersDirectlyTo(ob);
+            return ((Traverseproc)suboffsets).refersDirectlyTo(ob);
         } else {
             return false;
         }
diff --git a/src/org/python/core/PyString.java b/src/org/python/core/PyString.java
--- a/src/org/python/core/PyString.java
+++ b/src/org/python/core/PyString.java
@@ -204,7 +204,7 @@
              * No existing export we can re-use. Return a buffer, but specialised to defer
              * construction of the buf object, and cache a soft reference to it.
              */
-            pybuf = new SimpleStringBuffer(flags, getString());
+            pybuf = new SimpleStringBuffer(flags, this, getString());
             export = new SoftReference(pybuf);
         }
         return pybuf;
diff --git a/src/org/python/core/buffer/BaseBuffer.java b/src/org/python/core/buffer/BaseBuffer.java
--- a/src/org/python/core/buffer/BaseBuffer.java
+++ b/src/org/python/core/buffer/BaseBuffer.java
@@ -45,6 +45,12 @@
 public abstract class BaseBuffer implements PyBuffer {
 
     /**
+     * The object that exported this buffer (or null if the subclass or exporter
+     * chooses not to supply a reference).
+     */
+    protected BufferProtocol obj;
+
+    /**
      * The dimensions of the array represented by the buffer. The length of the shape
      * array is the number of dimensions. The shape array should always be created and
      * filled (difference from CPython). This value is returned by {@link #getShape()}.
@@ -255,6 +261,11 @@
         return len;
     }
 
+    @Override
+    public final BufferProtocol getObj() {
+        return obj;
+    }
+
     /**
      * Retrieve the byte at the given index in the underlying storage treated as a flat sequence of
      * bytes. This byte-index will have been computed from the item index (which may have been
diff --git a/src/org/python/core/buffer/BaseNIOBuffer.java b/src/org/python/core/buffer/BaseNIOBuffer.java
--- a/src/org/python/core/buffer/BaseNIOBuffer.java
+++ b/src/org/python/core/buffer/BaseNIOBuffer.java
@@ -5,7 +5,6 @@
 import java.nio.ReadOnlyBufferException;
 
 import org.python.core.PyBUF;
-import org.python.core.PyBuffer;
 import org.python.core.PyException;
 
 /**
@@ -50,7 +49,6 @@
      * @param size number of elements in the view
      * @param stride byte-index step between successive elements
      */
-
     protected BaseNIOBuffer(ByteBuffer storage, int featureFlags, int index0, int size, int stride) {
         super(featureFlags & ~(WRITABLE | AS_ARRAY), index0, size, stride);
         this.storage = storage;
diff --git a/src/org/python/core/buffer/SimpleBuffer.java b/src/org/python/core/buffer/SimpleBuffer.java
--- a/src/org/python/core/buffer/SimpleBuffer.java
+++ b/src/org/python/core/buffer/SimpleBuffer.java
@@ -1,5 +1,6 @@
 package org.python.core.buffer;
 
+import org.python.core.BufferProtocol;
 import org.python.core.PyBuffer;
 import org.python.core.PyException;
 import org.python.core.util.StringUtil;
@@ -22,14 +23,16 @@
      * checkRequestFlags(flags);        // Check request is compatible with type
      * 
      *
+     * @param obj exporting object (or null)
      * @param storage the array of bytes storing the implementation of the exporting object
      * @param index0 offset where the data starts in that array (item[0])
      * @param size the number of bytes occupied
      * @throws NullPointerException if storage is null
      */
-    protected SimpleBuffer(byte[] storage, int index0, int size) throws PyException,
-            ArrayIndexOutOfBoundsException {
+    protected SimpleBuffer(BufferProtocol obj, byte[] storage, int index0, int size)
+            throws PyException, ArrayIndexOutOfBoundsException {
         super(storage, CONTIGUITY | SIMPLE, index0, size, 1);
+        this.obj = obj;
     }
 
     /**
@@ -38,6 +41,7 @@
      * against the capabilities of the buffer type.
      *
      * @param flags consumer requirements
+     * @param obj exporting object (or null)
      * @param storage the array of bytes storing the implementation of the exporting object
      * @param index0 offset where the data starts in that array (item[0])
      * @param size the number of bytes occupied
@@ -46,10 +50,10 @@
      *             inconsistent with storage.length
      * @throws PyException (BufferError) when expectations do not correspond with the type
      */
-    public SimpleBuffer(int flags, byte[] storage, int index0, int size) throws PyException,
-            ArrayIndexOutOfBoundsException, NullPointerException {
-        this(storage, index0, size);    // Construct checked SimpleBuffer
-        checkRequestFlags(flags);       // Check request is compatible with type
+    public SimpleBuffer(int flags, BufferProtocol obj, byte[] storage, int index0, int size)
+            throws PyException, ArrayIndexOutOfBoundsException, NullPointerException {
+        this(obj, storage, index0, size);   // Construct checked SimpleBuffer
+        checkRequestFlags(flags);           // Check request is compatible with type
         // Check arguments using the "all non-negative" trick
         if ((index0 | size | storage.length - (index0 + size)) < 0) {
             throw new ArrayIndexOutOfBoundsException();
@@ -62,11 +66,12 @@
      * {@link #index0}), and the navigation ({@link #shape} array) will be initialised from the
      * array argument.
      *
+     * @param obj exporting object (or null)
      * @param storage the array of bytes storing the implementation of the exporting object
      * @throws NullPointerException if storage is null
      */
-    protected SimpleBuffer(byte[] storage) throws NullPointerException {
-        this(storage, 0, storage.length);
+    protected SimpleBuffer(BufferProtocol obj, byte[] storage) throws NullPointerException {
+        this(obj, storage, 0, storage.length);
     }
 
     /**
@@ -75,12 +80,14 @@
      * against the capabilities of the buffer type.
      *
      * @param flags consumer requirements
+     * @param obj exporting object (or null)
      * @param storage the array of bytes storing the implementation of the exporting object
      * @throws NullPointerException if storage is null
      * @throws PyException (BufferError) when expectations do not correspond with the type
      */
-    public SimpleBuffer(int flags, byte[] storage) throws PyException, NullPointerException {
-        this(storage);                  // Construct SimpleBuffer on whole array
+    public SimpleBuffer(int flags, BufferProtocol obj, byte[] storage) throws PyException,
+            NullPointerException {
+        this(obj, storage);             // Construct SimpleBuffer on whole array
         checkRequestFlags(flags);       // Check request is compatible with type
     }
 
@@ -189,7 +196,7 @@
          */
         public SimpleView(PyBuffer root, int flags, byte[] storage, int offset, int size) {
             // Create a new SimpleBuffer on the buffer passed in (part of the root)
-            super(flags, storage, offset, size);
+            super(flags, root.getObj(), storage, offset, size);
             // Get a lease on the root PyBuffer
             this.root = root.getBuffer(FULL_RO);
         }
diff --git a/src/org/python/core/buffer/SimpleNIOBuffer.java b/src/org/python/core/buffer/SimpleNIOBuffer.java
--- a/src/org/python/core/buffer/SimpleNIOBuffer.java
+++ b/src/org/python/core/buffer/SimpleNIOBuffer.java
@@ -2,6 +2,7 @@
 
 import java.nio.ByteBuffer;
 
+import org.python.core.BufferProtocol;
 import org.python.core.PyBuffer;
 import org.python.core.PyException;
 
@@ -29,6 +30,7 @@
      * checkRequestFlags(flags);        // Check request is compatible with type
      * 
      * PyBuffer a = obj.getBuffer(PyBUF.SIMPLE);
@@ -253,34 +294,31 @@
      * ByteBuffer bb = a.getNIOBuffer();
      * 
- * if (isReadonly()) {
- *     throw notWritable();
- * }
- * // ... implementation of the write operation
- * 
      * super(storage, index0, size);
      * checkRequestFlags(flags);        // Check request is compatible with type
      * 
+     * super(storage.duplicate(), index0, size);
+     * checkRequestFlags(flags);        // Check request is compatible with type
+     * 
-     * this.storage = storage;          // Exported data
-     * this.index0 = index0;            // Index to be treated as item[0]
-     * this.shape[0] = length;          // Number of items in exported data
-     * this.stride = stride;            // Between items
-     * 
+         * pair = parent.makePair();
+         * obj = pair.obj;
+         * 
+         * view = pair.view.getBufferSlice(flags, first, count, step);
+         * 