iptc.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef IPTC_HPP_
#define IPTC_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "datasets.hpp"
#include "metadatum.hpp"
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class declarations
class ExifData;
 
// *****************************************************************************
// class definitions
 
class EXIV2API Iptcdatum : public Metadatum {
 public:
 
 
  explicit Iptcdatum(const IptcKey& key, const Value* pValue = nullptr);
  Iptcdatum(const Iptcdatum& rhs);
  ~Iptcdatum() override = default;
 
 
 
  Iptcdatum& operator=(const Iptcdatum& rhs);
  Iptcdatum& operator=(const uint16_t& value);
  Iptcdatum& operator=(const std::string& value);
  Iptcdatum& 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]] std::string recordName() const;
  [[nodiscard]] uint16_t record() const;
  [[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;
  [[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:
  // DATA
  IptcKey::UniquePtr key_;  
  Value::UniquePtr value_;  
 
};  // class Iptcdatum
 
using IptcMetadata = std::vector<Iptcdatum>;
 
class EXIV2API IptcData {
 public:
  using iterator = IptcMetadata::iterator;
  using const_iterator = IptcMetadata::const_iterator;
 
  // Use the compiler generated constructors and assignment operator
 
 
 
  Iptcdatum& operator[](const std::string& key);
  int add(const IptcKey& key, const Value* value);
  int add(const Iptcdatum& iptcdatum);
  iterator erase(iterator pos);
  void clear() {
    iptcMetadata_.clear();
  }
  void sortByKey();
  void sortByTag();
  iterator begin() {
    return iptcMetadata_.begin();
  }
  iterator end() {
    return iptcMetadata_.end();
  }
  iterator findKey(const IptcKey& key);
  iterator findId(uint16_t dataset, uint16_t record = IptcDataSets::application2);
 
 
 
  [[nodiscard]] const_iterator begin() const {
    return iptcMetadata_.begin();
  }
  [[nodiscard]] const_iterator end() const {
    return iptcMetadata_.end();
  }
  [[nodiscard]] const_iterator findKey(const IptcKey& key) const;
  [[nodiscard]] const_iterator findId(uint16_t dataset, uint16_t record = IptcDataSets::application2) const;
  [[nodiscard]] bool empty() const {
    return iptcMetadata_.empty();
  }
 
  [[nodiscard]] size_t count() const {
    return iptcMetadata_.size();
  }
 
  [[nodiscard]] size_t size() const;
 
  [[nodiscard]] const char* detectCharset() const;
 
  static void printStructure(std::ostream& out, const Slice<byte*>& bytes, size_t depth);
 
 private:
  // DATA
  IptcMetadata iptcMetadata_;
};  // class IptcData
 
class EXIV2API IptcParser {
 public:
  static int decode(IptcData& iptcData, const byte* pData, size_t size);
 
  static DataBuf encode(const IptcData& iptcData);
 
 private:
  // Constant data
  static constexpr byte marker_ = 0x1C;  // Dataset marker
 
};  // class IptcParser
 
}  // namespace Exiv2
 
#endif  // #ifndef IPTC_HPP_