xmp_exiv2.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef XMP_HPP_
#define XMP_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "metadatum.hpp"
#include "properties.hpp"
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class declarations
class ExifData;
 
// *****************************************************************************
// class definitions
 
class EXIV2API Xmpdatum : public Metadatum {
 public:
 
 
  explicit Xmpdatum(const XmpKey& key, const Value* pValue = nullptr);
  Xmpdatum(const Xmpdatum& rhs);
  ~Xmpdatum() override;
 
 
 
  Xmpdatum& operator=(const Xmpdatum& rhs);
  Xmpdatum& operator=(const std::string& value);
  template <typename T>
  Xmpdatum& operator=(const T& value);
  Xmpdatum& operator=(const Value& value);
  void setValue(const Value* pValue) override;
  int setValue(const std::string& value) override;
 
 
 
  size_t copy(byte* buf, ByteOrder byteOrder) const override;
  std::ostream& write(std::ostream& os, const ExifData* pMetadata = nullptr) const override;
  [[nodiscard]] std::string key() const override;
  [[nodiscard]] const char* familyName() const override;
  [[nodiscard]] std::string groupName() const override;
  [[nodiscard]] std::string tagName() const override;
  [[nodiscard]] std::string tagLabel() const override;
  [[nodiscard]] std::string tagDesc() const override;
  [[nodiscard]] uint16_t tag() const override;
  [[nodiscard]] TypeId typeId() const override;
  [[nodiscard]] const char* typeName() const override;
  // Todo: Remove this method from the baseclass
  [[nodiscard]] size_t typeSize() const override;
  [[nodiscard]] size_t count() const override;
  [[nodiscard]] size_t size() const override;
  [[nodiscard]] std::string toString() const override;
  [[nodiscard]] std::string toString(size_t n) const override;
  [[nodiscard]] int64_t toInt64(size_t n = 0) const override;
  [[nodiscard]] float toFloat(size_t n = 0) const override;
  [[nodiscard]] Rational toRational(size_t n = 0) const override;
  [[nodiscard]] Value::UniquePtr getValue() const override;
  [[nodiscard]] const Value& value() const override;
 
 private:
  // Pimpl idiom
  struct Impl;
  std::unique_ptr<Impl> p_;
 
};  // class Xmpdatum
 
using XmpMetadata = std::vector<Xmpdatum>;
 
class EXIV2API XmpData {
 public:
  XmpData() = default;
 
  using iterator = XmpMetadata::iterator;
  using const_iterator = XmpMetadata::const_iterator;
 
 
 
  Xmpdatum& operator[](const std::string& key);
  int add(const XmpKey& key, const Value* value);
  int add(const Xmpdatum& xmpdatum);
  /*
  @brief Delete the Xmpdatum at iterator position pos, return the
          position of the next Xmpdatum.
 
  @note  Iterators into the metadata, including pos, are potentially
          invalidated by this call.
  @brief Delete the Xmpdatum at iterator position pos and update pos
  */
  iterator erase(XmpData::iterator pos);
  void eraseFamily(XmpData::iterator& pos);
  void clear();
  void sortByKey();
  iterator begin();
  iterator end();
  iterator findKey(const XmpKey& key);
 
 
 
  [[nodiscard]] const_iterator begin() const;
  [[nodiscard]] const_iterator end() const;
  [[nodiscard]] const_iterator findKey(const XmpKey& key) const;
  [[nodiscard]] bool empty() const;
  [[nodiscard]] long count() const;
 
  [[nodiscard]] bool usePacket() const {
    return usePacket_;
  }
 
  bool usePacket(bool b) {
    bool r = usePacket_;
    usePacket_ = b;
    return r;
  }
  void setPacket(std::string xmpPacket) {
    xmpPacket_ = std::move(xmpPacket);
    usePacket(false);
  }
  // ! getPacket
  [[nodiscard]] const std::string& xmpPacket() const {
    return xmpPacket_;
  }
 
 
 private:
  // DATA
  XmpMetadata xmpMetadata_;
  std::string xmpPacket_;
  bool usePacket_{};
};  // class XmpData
 
class EXIV2API XmpParser {
 public:
  enum XmpFormatFlags {
    omitPacketWrapper = 0x0010UL,    
    readOnlyPacket = 0x0020UL,       
    useCompactFormat = 0x0040UL,     
    includeThumbnailPad = 0x0100UL,  
    exactPacketLength = 0x0200UL,    
    writeAliasComments = 0x0400UL,   
    omitAllFormatting = 0x0800UL     
  };
  static int decode(XmpData& xmpData, const std::string& xmpPacket);
  static int encode(std::string& xmpPacket, const XmpData& xmpData, uint16_t formatFlags = useCompactFormat,
                    uint32_t padding = 0);
  using XmpLockFct = void (*)(void* pLockData, bool lockUnlock);
 
  static bool initialize(XmpParser::XmpLockFct xmpLockFct = nullptr, void* pLockData = nullptr);
  static void terminate();
 
 private:
  static void registerNs(const std::string& ns, const std::string& prefix);
  static void unregisterNs(const std::string& ns);
 
  static void registeredNamespaces(Exiv2::Dictionary&);
 
  // DATA
  static bool initialized_;  
  static XmpLockFct xmpLockFct_;
  static void* pLockData_;
 
  friend class XmpProperties;  // permit XmpProperties -> registerNs() and registeredNamespaces()
 
};  // class XmpParser
 
// *****************************************************************************
// free functions, template and inline definitions
 
template <typename T>
Xmpdatum& Xmpdatum::operator=(const T& value) {
#ifdef __cpp_if_constexpr
  if constexpr (std::is_same_v<T, bool>) {
#else
  if (std::is_same<T, bool>::value) {
#endif
    setValue(Exiv2::toString(value ? "True" : "False"));
    return *this;
  } else {
    setValue(Exiv2::toString(value));
    return *this;
  }
}
 
}  // namespace Exiv2
 
#endif  // #ifndef XMP_HPP_