Omit derived classes of BasicIo

The complications of dealing with compile options such as EXV_USE_CURL
are not needed as the derived classes all have the same interface.
ImageFactory.createIo() can be used to create an object of a BasicIo
drived class if needed.

Author: jim-easterbrook

CHANGELOG.txt

@@ -16,6 +16,9 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see
 <http://www.gnu.org/licenses/>.
 
+Changes in v0.17.0:
+  1/ API change: derived classes of BasicIo are omitted from Python.
+
 Changes in v0.16.3:
   1/ Binary wheels incorporate libexiv2 v0.28.2.
 

README.rst

@@ -1,4 +1,4 @@
-python-exiv2 v\ 0.16.4
+python-exiv2 v\ 0.17.0
 ======================
 
 python-exiv2 is a low level interface (or binding) to the exiv2_ C++ library.

src/doc/_templates/module.rst

@@ -15,11 +15,6 @@
        :top-classes: exiv2.value.Value
    {% endif %}
 
-   {% if fullname == "exiv2._basicio" %}
-   .. inheritance-diagram:: {{ classes | join(" ") }}
-       :top-classes: exiv2.basicio.BasicIo
-   {% endif %}
-
    {% if fullname in ["exiv2._datasets", "exiv2._metadatum", "exiv2._properties", "exiv2._tags"] %}
    .. inheritance-diagram:: exiv2.ExifKey exiv2.IptcKey exiv2.XmpKey
        :top-classes: exiv2.metadatum.Key

src/doc/requirements.txt

@@ -1,3 +1,3 @@
-exiv2 <= 0.16.4
+exiv2 <= 0.17.0
 sphinx == 7.2.6
 sphinx-rtd-theme == 2.0.0

src/interface/basicio.i

@@ -19,7 +19,8 @@
 %nothread;
 
 #ifndef SWIGIMPORTED
-%constant char* __doc__ = "Classes to access files, memory and remote data.";
+%constant char* __doc__ =
+    "Class interface to access files, memory and remote data.";
 #endif
 
 #pragma SWIG nowarn=321 // 'open' conflicts with a built-in name in python
@@ -29,7 +30,6 @@
 %include "shared/enum.i"
 %include "shared/exception.i"
 %include "shared/keep_reference.i"
-%include "shared/remoteio_derived.i"
 %include "shared/unique_ptr.i"
 %include "shared/windows_path.i"
 
@@ -48,81 +48,54 @@ UNIQUE_PTR(Exiv2::BasicIo);
 %thread Exiv2::BasicIo::mmap;
 %thread Exiv2::BasicIo::munmap;
 %thread Exiv2::BasicIo::read;
-%thread Exiv2::MemIo::read;
 %thread Exiv2::BasicIo::seek;
-%thread Exiv2::FileIo::size;
-%thread Exiv2::FileIo::tell;
 %thread Exiv2::BasicIo::transfer;
 %thread Exiv2::BasicIo::write;
-%thread Exiv2::MemIo::write;
 
 // Some calls don't raise exceptions
-%noexception Exiv2::MemIo::close;
 %noexception Exiv2::BasicIo::eof;
 %noexception Exiv2::BasicIo::error;
 %noexception Exiv2::BasicIo::isopen;
-%noexception Exiv2::MemIo::mmap;
-%noexception Exiv2::MemIo::munmap;
-%noexception Exiv2::RemoteIo::munmap;
-%noexception Exiv2::MemIo::open;
 %noexception Exiv2::BasicIo::path;
-%noexception Exiv2::MemIo::read;
-%noexception Exiv2::MemIo::seek;
-%noexception Exiv2::RemoteIo::seek;
-%noexception Exiv2::MemIo::size;
-%noexception Exiv2::RemoteIo::size;
-%noexception Exiv2::MemIo::tell;
-%noexception Exiv2::RemoteIo::tell;
-%noexception Exiv2::MemIo::write;
 
 // Convert path encoding on Windows
 WINDOWS_PATH(const std::string& path)
 WINDOWS_PATH(const std::string& orgPath)
 WINDOWS_PATH(const std::string& url)
 WINDOWS_PATH_OUT(path)
 
-// Convert BasicIo return values to actual subclass
-%fragment("basicio_subtype", "header") {
-static swig_type_info* basicio_subtype(Exiv2::BasicIo* ptr) {
-    if (dynamic_cast<Exiv2::MemIo*>(ptr))
-        return $descriptor(Exiv2::MemIo*);
-    else if (dynamic_cast<Exiv2::FileIo*>(ptr)) {
-        if (dynamic_cast<Exiv2::XPathIo*>(ptr))
-            return $descriptor(Exiv2::XPathIo*);
-        else
-            return $descriptor(Exiv2::FileIo*);
+// Add method to get the subclass type
+%feature("docstring") Exiv2::BasicIo::ioType "Return the derived class type.
+
+You shouldn't usually need to know the type of IO as they all have
+the same interface.
+:rtype: str
+:return: A class name such as ""FileIo""."
+%extend Exiv2::BasicIo {
+    const char* ioType() {
+        if (dynamic_cast<Exiv2::MemIo*>($self))
+            return "MemIo";
+        else if (dynamic_cast<Exiv2::FileIo*>($self)) {
+            if (dynamic_cast<Exiv2::XPathIo*>($self))
+                return "XPathIo";
+            return "FileIo";
+        }
+        else if (dynamic_cast<Exiv2::RemoteIo*>($self)) {
+            if (dynamic_cast<Exiv2::HttpIo*>($self))
+                return "HttpIo";
+%#ifdef EXV_USE_CURL
+            else if (dynamic_cast<Exiv2::CurlIo*>($self))
+                return "CurlIo";
+%#endif
+%#ifdef EXV_USE_SSH
+            else if (dynamic_cast<Exiv2::SshIo*>($self))
+                return "SshIo";
+%#endif
+            return "RemoteIo";
+        }
+        return "unknown";
     }
-    else if (dynamic_cast<Exiv2::RemoteIo*>(ptr)) {
-        if (dynamic_cast<Exiv2::HttpIo*>(ptr))
-            return $descriptor(Exiv2::HttpIo*);
-#ifdef EXV_USE_CURL
-        else if (dynamic_cast<Exiv2::CurlIo*>(ptr))
-            return $descriptor(Exiv2::CurlIo*);
-#endif
-        else
-            return $descriptor(Exiv2::RemoteIo*);
-    }
-    return $descriptor(Exiv2::BasicIo*);
-};
-}
-%typemap(out, fragment="basicio_subtype") Exiv2::BasicIo& {
-    $result = SWIG_NewPointerObj($1, basicio_subtype($1), 0);
-}
-%typemap(out, fragment="basicio_subtype") Exiv2::BasicIo::SMART_PTR {
-    Exiv2::BasicIo* ptr = (&$1)->release();
-    $result = SWIG_NewPointerObj(
-        ptr, basicio_subtype(ptr), SWIG_POINTER_OWN);
-}
-
-// CurlIo destructor isn't seen by SWIG in v0.27.x
-#if EXIV2_VERSION_HEX < 0x001c0000
-#ifdef EXV_USE_CURL
-%extend Exiv2::CurlIo {
-    ~CurlIo() {};
 }
-%ignore Exiv2::CurlIo::~CurlIo;
-#endif
-#endif
 
 // readOrThrow & seekOrThrow use ErrorCode internally without Exiv2:: prefix
 // as if SWIG doesn't realise ErrorCode is in the Exiv2 namespace
@@ -143,10 +116,6 @@ KEEP_REFERENCE(Exiv2::BasicIo&)
 INPUT_BUFFER_RO(const Exiv2::byte* data, long wcount)
 INPUT_BUFFER_RO(const Exiv2::byte* data, size_t wcount)
 
-// Allow MemIo to be ceated from a buffer
-INPUT_BUFFER_RO_EX(const Exiv2::byte* data, long size)
-INPUT_BUFFER_RO_EX(const Exiv2::byte* data, size_t size)
-
 // BasicIo::read can write to a Python buffer
 OUTPUT_BUFFER_RW(Exiv2::byte* buf, long rcount)
 OUTPUT_BUFFER_RW(Exiv2::byte* buf, size_t rcount)
@@ -159,12 +128,12 @@ OUTPUT_BUFFER_RW(Exiv2::byte* buf, size_t rcount)
 RETURN_VIEW(Exiv2::byte* mmap, $1 ? arg1->size() : 0,
             arg2 ? PyBUF_WRITE : PyBUF_READ,)
 
-%define EXTEND_BASICIO(io_type)
-// Enable len(io_type)
-%feature("python:slot", "sq_length", functype="lenfunc") io_type::size;
-// Expose io_type contents as a Python buffer
-%fragment("get_ptr_size"{io_type}, "header") {
-static bool get_ptr_size(io_type* self, bool is_writeable,
+// Enable len(Exiv2::BasicIo)
+%feature("python:slot", "sq_length", functype="lenfunc")
+    Exiv2::BasicIo::size;
+// Expose Exiv2::BasicIo contents as a Python buffer
+%fragment("get_ptr_size"{Exiv2::BasicIo}, "header") {
+static bool get_ptr_size(Exiv2::BasicIo* self, bool is_writeable,
                          Exiv2::byte*& ptr, Py_ssize_t& size) {
     if (self->open())
         return false;
@@ -183,20 +152,15 @@ static bool get_ptr_size(io_type* self, bool is_writeable,
     return true;
 };
 }
-%fragment("release_ptr"{io_type}, "header") {
-static void release_ptr(io_type* self) {
+%fragment("release_ptr"{Exiv2::BasicIo}, "header") {
+static void release_ptr(Exiv2::BasicIo* self) {
     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
     self->munmap();
     self->close();
     SWIG_PYTHON_THREAD_END_ALLOW;
 };
 }
-EXPOSE_OBJECT_BUFFER(io_type, true, true)
-%enddef // EXTEND_BASICIO
-
-EXTEND_BASICIO(Exiv2::FileIo)
-EXTEND_BASICIO(Exiv2::MemIo)
-EXTEND_BASICIO(Exiv2::RemoteIo)
+EXPOSE_OBJECT_BUFFER(Exiv2::BasicIo, true, true)
 
 // Make enum more Pythonic
 DEFINE_CLASS_ENUM(BasicIo, Position, "Seek starting positions.",
@@ -210,21 +174,21 @@ DEPRECATED_ENUM(BasicIo, Position, "Seek starting positions.",
         "cur", Exiv2::BasicIo::cur,
         "end", Exiv2::BasicIo::end);
 
-%ignore Exiv2::BasicIo::~BasicIo;
 %ignore Exiv2::BasicIo::bigBlock_;
+%ignore Exiv2::BasicIo::operator=;
 %ignore Exiv2::BasicIo::populateFakeData;
 %ignore Exiv2::curlWriter;
 %ignore Exiv2::IoCloser;
 %ignore Exiv2::ReplaceStringInPlace;
 %ignore Exiv2::readFile;
 %ignore Exiv2::writeFile;
-%ignore Exiv2::XPathIo::GEN_FILE_EXT;
-%ignore Exiv2::XPathIo::TEMP_FILE_EXT;
-%ignore Exiv2::CurlIo::operator=;
-%ignore Exiv2::FileIo::operator=;
-%ignore Exiv2::HttpIo::operator=;
-%ignore Exiv2::MemIo::operator=;
-%ignore Exiv2::SshIo::operator=;
+%ignore Exiv2::CurlIo;
+%ignore Exiv2::FileIo;
+%ignore Exiv2::HttpIo;
+%ignore Exiv2::MemIo;
+%ignore Exiv2::RemoteIo;
+%ignore Exiv2::SshIo;
+%ignore Exiv2::XPathIo;
 %ignore EXV_XPATH_MEMIO;
 
 %include "exiv2/basicio.hpp"

src/interface/image.i

@@ -29,7 +29,6 @@
 %include "shared/enum.i"
 %include "shared/exception.i"
 %include "shared/keep_reference.i"
-%include "shared/remoteio_derived.i"
 %include "shared/windows_path.i"
 
 %include "std_string.i"

src/interface/preview.i

@@ -30,7 +30,6 @@ For Exif thumbnail images see the :py:class:`ExifThumb` class.";
 %include "shared/buffers.i"
 %include "shared/exception.i"
 %include "shared/keep_reference.i"
-%include "shared/remoteio_derived.i"
 %include "shared/struct_dict.i"
 %include "shared/windows_path.i"
 

src/interface/shared/remoteio_derived.i

@@ -37,7 +37,7 @@
         SWIG_exception_fail(SWIG_ValueError, "failed to transcode result");
     }
 %#endif
-    $result = SWIG_From_std_string($1);
+    $result = SWIG_FromCharPtrAndSize($1.data(), $1.size());
 }
 %typemap(out, fragment="utf8_to_wcp") const std::string& function {
     std::string copy = *$1;
@@ -46,6 +46,6 @@
         SWIG_exception_fail(SWIG_ValueError, "failed to transcode result");
     }
 %#endif
-    $result = SWIG_From_std_string(copy);
+    $result = SWIG_FromCharPtrAndSize(copy.data(), copy.size());
 }
 %enddef // WINDOWS_PATH_OUT

src/interface/shared/windows_path.i

@@ -39,11 +39,6 @@ EXCEPTION()
 
 // Function to report build options used
 %feature("docstring") versionInfo "Return a dict of libexiv2 build options."
-#ifndef EXV_USE_CURL
-%{
-#undef EXV_USE_CURL
-%}
-#endif
 %inline %{
 static PyObject* versionInfo() {
     bool nls = false;