Replaced context object with simple data() method

This is much simpler, and takes advantage of the callback used to call
munmap when the memoryview is deleted.

Author: jim-easterbrook

USAGE.rst

@@ -384,19 +384,29 @@ Doing so will invalidate the memoryview and may cause a segmentation fault:
 
 .. code:: python
 
-    buf = exiv2.DataBuf(b'fred')
-    data = buf.data()
-    print(bytes(data))              # Prints b'fred'
-    buf.alloc(128)
-    print(bytes(data))              # Prints random values, may segfault
+    >>> buf = exiv2.DataBuf(b'fred')
+    >>> data = buf.data()
+    >>> print(bytes(data))
+    b'fred'
+    >>> del buf
+    >>> print(bytes(data))
+    b'en_G'
 
-A good way to ensure the memoryview_ object is ephemeral is to use it in a ``with`` statement:
+Since version 0.18.0 python-exiv2 releases the memoryview (when the memory block is resized) to prevent problems:
 
 .. code:: python
 
-    buf = exiv2.DataBuf(b'fred')
-    with buf.data() as data:
-        print(bytes(data))              # Prints b'fred'
+    >>> buf = exiv2.DataBuf(b'fred')
+    >>> data = buf.data()
+    >>> print(bytes(data))
+    b'fred'
+    >>> buf.alloc(128)
+    >>> print(bytes(data))
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+    ValueError: operation forbidden on released memoryview object
+
+Unfortunately I haven't been able to make this work for memory block deletion.
 
 Buffer interface
 ----------------
@@ -425,7 +435,7 @@ The ``Image::io`` method returns an `Exiv2::BasicIo`_ object that provides acces
 The ``BasicIo::mmap`` method allows access to the image file data without unnecessary copying.
 However it is rather error prone, crashing your Python program with a segmentation fault if anything goes wrong.
 
-The ``Exiv2::BasicIo`` object must be opened before calling ``mmap()``.
+The ``Exiv2::BasicIo`` object must be open when ``mmap()`` is called.
 A Python `context manager`_ can be used to ensure that the ``open()`` and ``mmap()`` calls are paired with ``munmap()`` and ``close()`` calls:
 
 .. code:: python
@@ -447,15 +457,14 @@ A Python `context manager`_ can be used to ensure that the ``open()`` and ``mmap
     with get_file_data(image) as data:
         rsp = requests.post(url, files={'file': io.BytesIO(data)})
 
-Since python-exiv2 v0.18.0 the ``exiv2.BasicIo.data()`` method provides a context manager that calls ``open``, ``mmap``, ``munmap``, and ``close`` for you:
+Since v0.18.0 python-exiv2 has a ``exiv2.BasicIo.data()`` method that is easier to use:
 
 .. code:: python
 
     # after setting some metadata
     image.writeMetadata()
     exiv_io = image.io()
-    with exiv_io.data() as data:
-        rsp = requests.post(url, files={'file': io.BytesIO(data)})
+    rsp = requests.post(url, files={'file': io.BytesIO(exiv_io.data())})
 
 The ``exiv2.BasicIo`` Python type also exposes a `buffer interface`_.
 It allows the ``exiv2.BasicIo`` object to be used anywhere that a `bytes-like object`_ is expected:

src/interface/basicio.i

@@ -146,7 +146,7 @@ RETURN_VIEW_CB(Exiv2::byte* mmap, $1 ? arg1->size() : 0,
     };
 }
 
-// Release memoryviews when mmap is called
+// Release memoryviews when mmap or data is called
 %typemap(check, fragment="memoryview_funcs") bool isWriteable {
     release_views(self);
 }
@@ -157,6 +157,18 @@ RETURN_VIEW_CB(Exiv2::byte* mmap, $1 ? arg1->size() : 0,
     release_views(self);
 %}
 
+// Add data() method for easy access
+RETURN_VIEW_CB(Exiv2::byte* data, $1 ? arg1->size() : 0,
+               arg2 ? PyBUF_WRITE : PyBUF_READ, self,)
+%extend Exiv2::BasicIo {
+    Exiv2::byte* data(bool isWriteable) {
+        if (!self->isopen())
+            self->open();
+        self->munmap();
+        return self->mmap(isWriteable);
+    };
+}
+
 // Enable len(Exiv2::BasicIo)
 %feature("python:slot", "sq_length", functype="lenfunc")
     Exiv2::BasicIo::size;
@@ -191,64 +203,6 @@ static void release_ptr(Exiv2::BasicIo* self) {
 }
 EXPOSE_OBJECT_BUFFER(Exiv2::BasicIo, true, true)
 
-// Wrapper class to provide a context manager for Exiv2::BasicIo::mmap
-%feature("docstring") DataContext "Data context manager.
-
-A simple context manager for *mmap* / *munmap* data access. The
-*__enter__* method returns a :py:class:`memoryview` of the data."
-%ignore DataContext::DataContext;
-%thread DataContext::~DataContext;
-%inline %{
-class DataContext {
-private:
-    Exiv2::BasicIo* parent;
-    bool isWriteable;
-    char* ptr;
-public:
-    DataContext(Exiv2::BasicIo* parent, bool isWriteable) {
-        ptr = NULL;
-        this->parent = parent;
-        this->isWriteable = isWriteable;
-        if (parent->open())
-            throw std::runtime_error("BasicIo.open() failed");
-        ptr = (char*)parent->mmap(isWriteable);
-    };
-    ~DataContext() {
-        if (ptr) {
-            parent->munmap();
-            parent->close();
-        }
-    };
-    PyObject* __enter__() {
-        return PyMemoryView_FromMemory(
-            ptr, ptr ? parent->size() : 0,
-            isWriteable ? PyBUF_WRITE : PyBUF_READ);
-    };
-    bool __exit__(PyObject* exc_type, PyObject* exc_val, PyObject* exc_tb) {
-        return false;
-    };
-};
-%}
-KEEP_REFERENCE(DataContext*);
-
-// Add Exiv2::BasicIo::data() method to return a context manager
-%feature("docstring") Exiv2::BasicIo::data "Return a data context manager.
-
-This allows easy access to the data using a ``with`` statement.
-The context manager calls *mmap* when the context is entered and
-*munmap* when the context is exited.
-:type isWriteable: bool, optional
-:param isWriteable: Set to true if the data should be writeable
-    (default is false).
-:rtype: object
-:return: A context manager"
-%newobject Exiv2::BasicIo::data;
-%extend Exiv2::BasicIo {
-    DataContext* data(bool isWriteable) {
-        return new DataContext($self, isWriteable);
-    }
-}
-
 // Make enum more Pythonic
 DEFINE_CLASS_ENUM(BasicIo, Position, "Seek starting positions.",
     "beg", Exiv2::BasicIo::beg,