types.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef TYPES_HPP_
#define TYPES_HPP_
 
#include "exiv2lib_export.h"
 
// included header files
#include "config.h"
#include "slice.hpp"
 
// standard includes
#include <algorithm>
#include <cstdint>
#include <limits>
#include <sstream>
#include <vector>
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// type definitions
 
using byte = uint8_t;
 
using URational = std::pair<uint32_t, uint32_t>;
using Rational = std::pair<int32_t, int32_t>;
 
enum ByteOrder {
  invalidByteOrder,
  littleEndian,
  bigEndian,
};
 
enum WriteMethod {
  wmIntrusive,
  wmNonIntrusive,
};
 
enum MetadataId {
  mdNone = 0,
  mdExif = 1,
  mdIptc = 2,
  mdComment = 4,
  mdXmp = 8,
  mdIccProfile = 16,
};
 
enum AccessMode {
  amNone = 0,
  amRead = 1,
  amWrite = 2,
  amReadWrite = 3,
};
 
enum TypeId {
  unsignedByte = 1,         
  asciiString = 2,          
  unsignedShort = 3,        
  unsignedLong = 4,         
  unsignedRational = 5,     
  signedByte = 6,           
  undefined = 7,            
  signedShort = 8,          
  signedLong = 9,           
  signedRational = 10,      
  tiffFloat = 11,           
  tiffDouble = 12,          
  tiffIfd = 13,             
  unsignedLongLong = 16,    
  signedLongLong = 17,      
  tiffIfd8 = 18,            
  string = 0x10000,         
  date = 0x10001,           
  time = 0x10002,           
  comment = 0x10003,        
  directory = 0x10004,      
  xmpText = 0x10005,        
  xmpAlt = 0x10006,         
  xmpBag = 0x10007,         
  xmpSeq = 0x10008,         
  langAlt = 0x10009,        
  invalidTypeId = 0x1fffe,  
  lastTypeId = 0x1ffff,     
};
 
using Blob = std::vector<byte>;
 
// *****************************************************************************
// class definitions
 
class EXIV2API TypeInfo {
 public:
  static const char* typeName(TypeId typeId);
  static TypeId typeId(const std::string& typeName);
  static size_t typeSize(TypeId typeId);
};
 
struct EXIV2API DataBuf {
 
 
  DataBuf() = default;
  explicit DataBuf(size_t size);
  DataBuf(const byte* pData, size_t size);
 
 
 
  void alloc(size_t size);
  void resize(size_t size);
 
  void reset();
 
  using iterator = std::vector<byte>::iterator;
  using const_iterator = std::vector<byte>::const_iterator;
 
  iterator begin() noexcept {
    return pData_.begin();
  }
  [[nodiscard]] const_iterator cbegin() const noexcept {
    return pData_.cbegin();
  }
  iterator end() noexcept {
    return pData_.end();
  }
  [[nodiscard]] const_iterator cend() const noexcept {
    return pData_.end();
  }
 
  [[nodiscard]] size_t size() const {
    return pData_.size();
  }
 
  [[nodiscard]] uint8_t read_uint8(size_t offset) const;
  void write_uint8(size_t offset, uint8_t x);
 
  [[nodiscard]] uint16_t read_uint16(size_t offset, ByteOrder byteOrder) const;
  void write_uint16(size_t offset, uint16_t x, ByteOrder byteOrder);
 
  [[nodiscard]] uint32_t read_uint32(size_t offset, ByteOrder byteOrder) const;
  void write_uint32(size_t offset, uint32_t x, ByteOrder byteOrder);
 
  [[nodiscard]] uint64_t read_uint64(size_t offset, ByteOrder byteOrder) const;
  void write_uint64(size_t offset, uint64_t x, ByteOrder byteOrder);
 
  int cmpBytes(size_t offset, const void* buf, size_t bufsize) const;
 
  [[nodiscard]] byte* data(size_t offset = 0);
 
  [[nodiscard]] const byte* c_data(size_t offset = 0) const;
 
  [[nodiscard]] const char* c_str(size_t offset = 0) const;
 
  [[nodiscard]] bool empty() const {
    return pData_.empty();
  }
 
 private:
  std::vector<byte> pData_;
};
 
EXIV2API Slice<byte*> makeSlice(DataBuf& buf, size_t begin, size_t end);
 
EXIV2API Slice<const byte*> makeSlice(const DataBuf& buf, size_t begin, size_t end);
 
// *****************************************************************************
// free functions
 
EXIV2API uint16_t getUShort(const byte* buf, ByteOrder byteOrder);
template <typename T>
uint16_t getUShort(const Slice<T>& buf, ByteOrder byteOrder) {
  if (byteOrder == littleEndian) {
    return static_cast<byte>(buf.at(1)) << 8 | static_cast<byte>(buf.at(0));
  }
  return static_cast<byte>(buf.at(0)) << 8 | static_cast<byte>(buf.at(1));
}
 
EXIV2API uint32_t getULong(const byte* buf, ByteOrder byteOrder);
EXIV2API uint64_t getULongLong(const byte* buf, ByteOrder byteOrder);
EXIV2API URational getURational(const byte* buf, ByteOrder byteOrder);
EXIV2API int16_t getShort(const byte* buf, ByteOrder byteOrder);
EXIV2API int32_t getLong(const byte* buf, ByteOrder byteOrder);
EXIV2API Rational getRational(const byte* buf, ByteOrder byteOrder);
EXIV2API float getFloat(const byte* buf, ByteOrder byteOrder);
EXIV2API double getDouble(const byte* buf, ByteOrder byteOrder);
 
EXIV2API std::ostream& operator<<(std::ostream& os, const Rational& r);
EXIV2API std::istream& operator>>(std::istream& is, Rational& r);
EXIV2API std::ostream& operator<<(std::ostream& os, const URational& r);
EXIV2API std::istream& operator>>(std::istream& is, URational& r);
 
EXIV2API size_t us2Data(byte* buf, uint16_t s, ByteOrder byteOrder);
EXIV2API size_t ul2Data(byte* buf, uint32_t l, ByteOrder byteOrder);
EXIV2API size_t ull2Data(byte* buf, uint64_t l, ByteOrder byteOrder);
EXIV2API size_t ur2Data(byte* buf, URational l, ByteOrder byteOrder);
EXIV2API size_t s2Data(byte* buf, int16_t s, ByteOrder byteOrder);
EXIV2API size_t l2Data(byte* buf, int32_t l, ByteOrder byteOrder);
EXIV2API size_t r2Data(byte* buf, Rational l, ByteOrder byteOrder);
EXIV2API size_t f2Data(byte* buf, float f, ByteOrder byteOrder);
EXIV2API size_t d2Data(byte* buf, double d, ByteOrder byteOrder);
 
EXIV2API void hexdump(std::ostream& os, const byte* buf, size_t len, size_t offset = 0);
 
EXIV2API bool isHex(const std::string& str, size_t size = 0, const std::string& prefix = "");
 
EXIV2API int exifTime(const char* buf, tm* tm);
 
EXIV2API const char* exvGettext(const char* str);
 
EXIV2API int64_t parseInt64(const std::string& s, bool& ok);
 
EXIV2API uint32_t parseUint32(const std::string& s, bool& ok);
 
EXIV2API float parseFloat(const std::string& s, bool& ok);
 
EXIV2API Rational parseRational(const std::string& s, bool& ok);
 
EXIV2API Rational floatToRationalCast(float f);
 
// *****************************************************************************
// template and inline definitions
 
template <typename T, typename K, int N>
const T* find(T (&src)[N], const K& key) {
  auto rc = std::find(src, src + N, key);
  return rc == src + N ? nullptr : rc;
}
 
template <typename T>
std::string toStringHelper(const T& arg, std::true_type) {
  return std::to_string(arg);
}
 
template <typename T>
std::string toStringHelper(const T& arg, std::false_type) {
  std::ostringstream os;
  os << arg;
  return os.str();
}
template <typename T>
std::string toString(const T& arg) {
  return toStringHelper(arg, std::is_integral<T>());
}
 
template <typename T>
T stringTo(const std::string& s, bool& ok) {
  std::istringstream is(s);
  T tmp = T();
  ok = static_cast<bool>(is >> tmp);
  std::string rest;
  is >> std::skipws >> rest;
  if (!rest.empty())
    ok = false;
  return tmp;
}
 
template <>
bool stringTo<bool>(const std::string& s, bool& ok);
 
}  // namespace Exiv2
 
#endif  // #ifndef TYPES_HPP_