Removed EXTEND_METADATUM macro

Its contents have been put in more logical places, which makes
everything easier to read and maintain.

Author: jim-easterbrook

src/interface/exif.i

@@ -52,8 +52,6 @@ KEEP_REFERENCE_EX(Exiv2::ExifThumb*, args)
 
 INPUT_BUFFER_RO(const Exiv2::byte* buf, BUFLEN_T size)
 
-EXTEND_METADATUM(Exifdatum)
-
 METADATUM_WRAPPERS(ExifData, Exifdatum)
 
 // Get the current (or default if not set) type id of a datum

src/interface/image.i

@@ -67,6 +67,8 @@ WINDOWS_PATH(const std::string& path)
 
 // Declare metadatum wrapper classes
 DECLARE_METADATUM_WRAPPERS(ExifData, Exifdatum)
+DECLARE_METADATUM_WRAPPERS(IptcData, Iptcdatum)
+DECLARE_METADATUM_WRAPPERS(XmpData, Xmpdatum)
 
 // Simplify handling of default parameters
 %typemap(default) bool useCurl {$1 = true;}

src/interface/iptc.i

@@ -38,8 +38,6 @@ IMPORT_ENUM(TypeId)
 // Catch all C++ exceptions
 EXCEPTION()
 
-EXTEND_METADATUM(Iptcdatum)
-
 METADATUM_WRAPPERS(IptcData, Iptcdatum)
 
 // Get the current (or default if not set) type id of a datum

src/interface/metadatum.i

@@ -25,7 +25,6 @@
 
 %include "shared/preamble.i"
 %include "shared/containers.i"
-%include "shared/keep_reference.i"
 
 %import "value.i"
 
@@ -54,84 +53,6 @@ UNIQUE_PTR(key_type);
 
 EXTEND_KEY(Exiv2::Key);
 
-// Macro for Metadatum subclasses
-%define EXTEND_METADATUM(datum_type)
-// Ignore overloaded default parameter version
-%ignore Exiv2::datum_type::write(std::ostream &) const;
-// Keep a reference to Metadatum when calling value()
-KEEP_REFERENCE(const Exiv2::Value&)
-// Keep a reference to any object that returns a reference to a datum.
-KEEP_REFERENCE(Exiv2::datum_type&)
-// Set the datum's value from a Python object. The datum's current or default
-// type is used to create an Exiv2::Value object (via Python) from the Python
-// object.
-%fragment("set_value_from_py"{Exiv2::datum_type}, "header",
-          fragment="get_type_object",
-          fragment="get_type_id"{Exiv2::datum_type}) {
-static PyObject* set_value_from_py(Exiv2::datum_type* datum,
-                                   PyObject* py_value) {
-    swig_type_info* ty_info = get_type_object(get_type_id(datum));
-    SwigPyClientData *cl_data = (SwigPyClientData*)ty_info->clientdata;
-    // Call type object to invoke constructor
-    PyObject* swig_obj = PyObject_CallFunctionObjArgs(
-        (PyObject*)cl_data->pytype, py_value, NULL);
-    if (!swig_obj)
-        return NULL;
-    // Convert constructed object to Exiv2::Value
-    Exiv2::Value* value = 0;
-    if (!SWIG_IsOK(SWIG_ConvertPtr(swig_obj, (void**)&value, ty_info, 0))) {
-        PyErr_SetString(
-            PyExc_RuntimeError, "set_value_from_py: invalid conversion");
-        Py_DECREF(swig_obj);
-        return NULL;
-    }
-    // Set value
-    datum->setValue(value);
-    Py_DECREF(swig_obj);
-    return SWIG_Py_Void();
-};
-}
-%extend Exiv2::datum_type {
-    bool operator==(const Exiv2::datum_type &other) const {
-        return &other == self;
-    }
-    bool operator!=(const Exiv2::datum_type &other) const {
-        return &other != self;
-    }
-    // Extend Metadatum to allow getting value as a specific type.
-    Exiv2::Value::SMART_PTR getValue(Exiv2::TypeId as_type) {
-        // deprecated since 2023-12-07
-        PyErr_WarnEx(PyExc_DeprecationWarning, "Requested type ignored.", 1);
-        return $self->getValue();
-    }
-    const Exiv2::Value& value(Exiv2::TypeId as_type) {
-        // deprecated since 2023-12-07
-        PyErr_WarnEx(PyExc_DeprecationWarning, "Requested type ignored.", 1);
-        return $self->value();
-    }
-    // Set the value from a Python object. The datum's current or default
-    // type is used to create an Exiv2::Value object (via Python) from the
-    // Python object.
-    %fragment("set_value_from_py"{Exiv2::datum_type});
-    PyObject* setValue(PyObject* py_value) {
-        return set_value_from_py($self, py_value);
-    }
-    // Old _print method for compatibility
-    std::string _print(const Exiv2::ExifData* pMetadata) const {
-        // deprecated since 2024-01-29
-        PyErr_WarnEx(PyExc_DeprecationWarning,
-                     "'_print' has been replaced by 'print'", 1);
-        return $self->print(pMetadata);
-    }
-    // toString parameter does not default to 0, so bypass default typemap
-    std::string toString() const { return self->toString(); }
-    std::string toString(BUFLEN_T i) const { return self->toString(i); }
-}
-// Deprecate some methods since 2025-08-25
-DEPRECATE_FUNCTION(Exiv2::datum_type::copy, true)
-DEPRECATE_FUNCTION(Exiv2::datum_type::write, true)
-%enddef // EXTEND_METADATUM
-
 // Deprecate some base class methods since 2025-08-25
 DEPRECATE_FUNCTION(Exiv2::Metadatum::copy, true)
 DEPRECATE_FUNCTION(Exiv2::Metadatum::write, true)

src/interface/preview.i

@@ -61,6 +61,8 @@ WINDOWS_PATH_OUT(extension)
 
 // Declare metadatum wrapper classes
 DECLARE_METADATUM_WRAPPERS(ExifData, Exifdatum)
+DECLARE_METADATUM_WRAPPERS(IptcData, Iptcdatum)
+DECLARE_METADATUM_WRAPPERS(XmpData, Xmpdatum)
 
 // Convert getPreviewProperties result to a Python tuple
 %template() std::vector<Exiv2::PreviewProperties>;

src/interface/shared/containers.i

@@ -37,7 +37,6 @@
     base_class::__contains__;
 %extend base_class {
     %fragment("get_type_id"{datum_type});
-    %fragment("set_value_from_py"{datum_type});
     datum_type& __getitem__(const std::string& key) {
         return (*$self)[key];
     }
@@ -56,10 +55,6 @@
                 value.c_str());
         return SWIG_Py_Void();
     }
-    PyObject* __setitem__(const std::string& key, PyObject* py_value) {
-        datum_type* datum = &(*$self)[key];
-        return set_value_from_py(datum, py_value);
-    }
 #if SWIG_VERSION >= 0x040400
     PyObject* __setitem__(PyObject* py_self, const std::string& key) {
 #else
@@ -80,4 +75,47 @@
         return $self->findKey(key_type(key)) != $self->end();
     }
 }
+
+// Set the datum's value from a Python object. The datum's current or default
+// type is used to create an Exiv2::Value object (via Python) from the Python
+// object.
+%fragment("set_value_from_py"{datum_type}, "header",
+          fragment="get_type_object",
+          fragment="get_type_id"{datum_type}) {
+static PyObject* set_value_from_py(datum_type* datum,
+                                   PyObject* py_value) {
+    swig_type_info* ty_info = get_type_object(get_type_id(datum));
+    SwigPyClientData *cl_data = (SwigPyClientData*)ty_info->clientdata;
+    // Call type object to invoke constructor
+    PyObject* swig_obj = PyObject_CallFunctionObjArgs(
+        (PyObject*)cl_data->pytype, py_value, NULL);
+    if (!swig_obj)
+        return NULL;
+    // Convert constructed object to Exiv2::Value
+    Exiv2::Value* value = 0;
+    if (!SWIG_IsOK(SWIG_ConvertPtr(swig_obj, (void**)&value, ty_info, 0))) {
+        PyErr_SetString(
+            PyExc_RuntimeError, "set_value_from_py: invalid conversion");
+        Py_DECREF(swig_obj);
+        return NULL;
+    }
+    // Set value
+    datum->setValue(value);
+    Py_DECREF(swig_obj);
+    return SWIG_Py_Void();
+};
+}
+%extend datum_type {
+    %fragment("set_value_from_py"{datum_type});
+    PyObject* setValue(PyObject* py_value) {
+        return set_value_from_py($self, py_value);
+    }
+}
+%extend base_class {
+    %fragment("set_value_from_py"{datum_type});
+    PyObject* __setitem__(const std::string& key, PyObject* py_value) {
+        datum_type* datum = &(*$self)[key];
+        return set_value_from_py(datum, py_value);
+    }
+}
 %enddef // DATA_CONTAINER

src/interface/shared/metadatum_wrappers.i

@@ -36,6 +36,9 @@ class datum_type##_reference;
 // Macro to wrap metadatum iterators and pointers
 %define METADATUM_WRAPPERS(container_type, datum_type)
 
+// Keep a reference to any object that returns a reference to a datum.
+KEEP_REFERENCE(Exiv2::datum_type&)
+
 // Invalidate pointers when data is deleted
 POINTER_STORE(container_type, datum_type)
 
@@ -158,6 +161,31 @@ public:
     }
 };
 %}
+
+// Metadata reference wrapper
+%ignore datum_type##_reference::##datum_type##_reference;
+%ignore datum_type##_reference::operator*;
+%feature("docstring") datum_type##_reference "
+Python wrapper for an :class:`" #datum_type "` reference. It has most of
+the methods of :class:`" #datum_type "` allowing easy access to the
+data it points to."
+%inline %{
+class datum_type##_reference: public datum_type##_pointer {
+private:
+    Exiv2::datum_type* ptr;
+public:
+    datum_type##_reference(Exiv2::datum_type* ptr): ptr(ptr) {
+        name = "pointer";
+    }
+    Exiv2::datum_type* operator*() const {
+        if (invalidated)
+            throw std::runtime_error("datum_type reference is invalid");
+        return ptr;
+    }
+};
+%}
+
+// typemaps
 %typemap(in) Exiv2::container_type::iterator
         (container_type##_iterator *argp=NULL) %{
     {
@@ -178,6 +206,15 @@ public:
     it = argp->_ptr();
     $1 = ⁢
 }
+%typemap(in) const Exiv2::datum_type& {
+    datum_type##_pointer* tmp = NULL;
+    if (SWIG_IsOK(SWIG_ConvertPtr(
+            $input, (void**)&tmp, $descriptor(datum_type##_pointer*), 0)))
+        $1 = **tmp;
+    else {
+        $typemap(in, Exiv2::datum_type&)
+    }
+}
 %typemap(out) Exiv2::container_type::iterator {
     $result = SWIG_NewPointerObj(
         SWIG_as_voidptr(new container_type##_iterator($1, arg1->end())),
@@ -189,40 +226,6 @@ public:
     }
 #endif // SWIG_VERSION
 }
-
-// Metadata reference wrapper
-%ignore datum_type##_reference::##datum_type##_reference;
-%ignore datum_type##_reference::operator*;
-%feature("docstring") datum_type##_reference "
-Python wrapper for an :class:`" #datum_type "` reference. It has most of
-the methods of :class:`" #datum_type "` allowing easy access to the
-data it points to."
-// Keep a reference to the data being referred to
-KEEP_REFERENCE(Exiv2::datum_type&)
-%inline %{
-class datum_type##_reference: public datum_type##_pointer {
-private:
-    Exiv2::datum_type* ptr;
-public:
-    datum_type##_reference(Exiv2::datum_type* ptr): ptr(ptr) {
-        name = "pointer";
-    }
-    Exiv2::datum_type* operator*() const {
-        if (invalidated)
-            throw std::runtime_error("datum_type reference is invalid");
-        return ptr;
-    }
-};
-%}
-%typemap(in) const Exiv2::datum_type& {
-    datum_type##_reference* tmp = NULL;
-    if (SWIG_IsOK(SWIG_ConvertPtr(
-            $input, (void**)&tmp, $descriptor(datum_type##_reference*), 0)))
-        $1 = **tmp;
-    else {
-        $typemap(in, Exiv2::datum_type&)
-    }
-}
 %typemap(out) Exiv2::datum_type& {
     $result = SWIG_NewPointerObj(
         SWIG_as_voidptr(new datum_type##_reference($1)),
@@ -235,4 +238,41 @@ public:
 #endif // SWIG_VERSION
 }
 
+// Deprecate some methods since 2025-08-25
+DEPRECATE_FUNCTION(Exiv2::datum_type::copy, true)
+DEPRECATE_FUNCTION(Exiv2::datum_type::write, true)
+// Ignore overloaded default parameter version
+%ignore Exiv2::datum_type::write(std::ostream &) const;
+
+// Extend datum type
+%extend Exiv2::datum_type {
+    bool operator==(const Exiv2::datum_type &other) const {
+        return &other == self;
+    }
+    bool operator!=(const Exiv2::datum_type &other) const {
+        return &other != self;
+    }
+    // Extend Metadatum to allow getting value as a specific type.
+    Exiv2::Value::SMART_PTR getValue(Exiv2::TypeId as_type) {
+        // deprecated since 2023-12-07
+        PyErr_WarnEx(PyExc_DeprecationWarning, "Requested type ignored.", 1);
+        return $self->getValue();
+    }
+    const Exiv2::Value& value(Exiv2::TypeId as_type) {
+        // deprecated since 2023-12-07
+        PyErr_WarnEx(PyExc_DeprecationWarning, "Requested type ignored.", 1);
+        return $self->value();
+    }
+    // Old _print method for compatibility
+    std::string _print(const Exiv2::ExifData* pMetadata) const {
+        // deprecated since 2024-01-29
+        PyErr_WarnEx(PyExc_DeprecationWarning,
+                     "'_print' has been replaced by 'print'", 1);
+        return $self->print(pMetadata);
+    }
+    // toString parameter does not default to 0, so bypass default typemap
+    std::string toString() const { return self->toString(); }
+    std::string toString(BUFLEN_T i) const { return self->toString(i); }
+}
+
 %enddef // METADATUM_WRAPPERS

src/interface/value.i

@@ -27,6 +27,7 @@
 
 %include "shared/preamble.i"
 %include "shared/buffers.i"
+%include "shared/keep_reference.i"
 %include "shared/private_data.i"
 %include "shared/struct_dict.i"
 
@@ -46,6 +47,9 @@ EXCEPTION()
 
 UNIQUE_PTR(Exiv2::Value);
 
+// Keep a reference to any object that returns a reference to a value.
+KEEP_REFERENCE(const Exiv2::Value&)
+
 // Remove exception handler for some methods known to be safe
 %noexception Exiv2::Value::~Value;
 %noexception Exiv2::Value::count;

src/interface/xmp.i

@@ -38,8 +38,6 @@ IMPORT_ENUM(TypeId)
 // Catch all C++ exceptions
 EXCEPTION()
 
-EXTEND_METADATUM(Xmpdatum)
-
 METADATUM_WRAPPERS(XmpData, Xmpdatum)
 
 // Get the current (or default if not set) type id of a datum