Loading...
Searching...
No Matches
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_
Exiv2::TypeInfo
Type information lookup functions. Implemented as a static class.
Definition types.hpp:108
Exiv2
Class CrwImage to access Canon CRW images. References: The Canon RAW (CRW) File Format by Phil Harv...
Definition asfvideo.hpp:15
Exiv2::Rational
std::pair< int32_t, int32_t > Rational
8 byte signed rational type.
Definition types.hpp:31
Exiv2::operator<<
EXIV2API std::ostream & operator<<(std::ostream &os, const DataSet &dataSet)
Output operator for dataSet.
Definition datasets.cpp:590
Exiv2::getDouble
EXIV2API double getDouble(const byte *buf, ByteOrder byteOrder)
Read an 8 byte double precision floating point value (IEEE 754 binary64) from the data buffer.
Definition types.cpp:308
Exiv2::ul2Data
EXIV2API size_t ul2Data(byte *buf, uint32_t l, ByteOrder byteOrder)
Convert an unsigned long to data, write the data to the buffer, return number of bytes written.
Definition types.cpp:342
Exiv2::find
const T * find(T(&src)[N], const K &key)
Find an element that matches key in the array src.
Definition types.hpp:449
Exiv2::getFloat
EXIV2API float getFloat(const byte *buf, ByteOrder byteOrder)
Read a 4 byte single precision floating point value (IEEE 754 binary32) from the data buffer.
Definition types.cpp:296
Exiv2::parseFloat
EXIV2API float parseFloat(const std::string &s, bool &ok)
Return a float set to the value represented by s.
Definition types.cpp:564
Exiv2::isHex
EXIV2API bool isHex(const std::string &str, size_t size=0, const std::string &prefix="")
Return true if str is a hex number starting with prefix followed by size hex digits,...
Definition types.cpp:475
Exiv2::d2Data
EXIV2API size_t d2Data(byte *buf, double d, ByteOrder byteOrder)
Convert a double precision floating point (IEEE 754 binary64) double to data, write the data to the b...
Definition types.cpp:422
Exiv2::floatToRationalCast
EXIV2API Rational floatToRationalCast(float f)
Very simple conversion of a float to a Rational.
Definition types.cpp:607
Exiv2::f2Data
EXIV2API size_t f2Data(byte *buf, float f, ByteOrder byteOrder)
Convert a single precision floating point (IEEE 754 binary32) float to data, write the data to the bu...
Definition types.cpp:410
Exiv2::hexdump
EXIV2API void hexdump(std::ostream &os, const byte *buf, size_t len, size_t offset=0)
Print len bytes from buf in hex and ASCII format to the given stream, prefixed with the position in t...
Definition types.cpp:454
Exiv2::exvGettext
EXIV2API const char * exvGettext(const char *str)
Translate a string using the gettext framework. This wrapper hides all the implementation details fro...
Definition types.cpp:504
Exiv2::getShort
EXIV2API int16_t getShort(const byte *buf, ByteOrder byteOrder)
Read a 2 byte signed short value from the data buffer.
Definition types.cpp:276
Exiv2::byte
uint8_t byte
1 byte unsigned integer type.
Definition types.hpp:26
Exiv2::getULong
EXIV2API uint32_t getULong(const byte *buf, ByteOrder byteOrder)
Read a 4 byte unsigned long value from the data buffer.
Definition types.cpp:250
Exiv2::makeSlice
Slice< T > makeSlice(T &cont, size_t begin, size_t end)
Return a new slice with the given bounds.
Definition slice.hpp:533
Exiv2::URational
std::pair< uint32_t, uint32_t > URational
8 byte unsigned rational type.
Definition types.hpp:29
Exiv2::TypeId
TypeId
Exiv2 value type identifiers.
Definition types.hpp:70
Exiv2::unsignedShort
@ unsignedShort
Exif SHORT type, 16-bit (2-byte) unsigned integer.
Definition types.hpp:73
Exiv2::date
@ date
IPTC date type.
Definition types.hpp:88
Exiv2::signedRational
@ signedRational
Exif SRATIONAL type, two SLONGs: numerator and denominator of a fraction.
Definition types.hpp:80
Exiv2::tiffIfd8
@ tiffIfd8
TIFF IFD type, 64-bit (8-byte) unsigned integer.
Definition types.hpp:86
Exiv2::lastTypeId
@ lastTypeId
Last type id.
Definition types.hpp:98
Exiv2::unsignedLongLong
@ unsignedLongLong
Exif LONG LONG type, 64-bit (8-byte) unsigned integer.
Definition types.hpp:84
Exiv2::unsignedLong
@ unsignedLong
Exif LONG type, 32-bit (4-byte) unsigned integer.
Definition types.hpp:74
Exiv2::signedShort
@ signedShort
Exif SSHORT type, a 16-bit (2-byte) signed (twos-complement) integer.
Definition types.hpp:78
Exiv2::signedLongLong
@ signedLongLong
Exif LONG LONG type, 64-bit (8-byte) signed integer.
Definition types.hpp:85
Exiv2::signedLong
@ signedLong
Exif SLONG type, a 32-bit (4-byte) signed (twos-complement) integer.
Definition types.hpp:79
Exiv2::langAlt
@ langAlt
XMP language alternative type.
Definition types.hpp:96
Exiv2::xmpAlt
@ xmpAlt
XMP alternative type.
Definition types.hpp:93
Exiv2::unsignedByte
@ unsignedByte
Exif BYTE type, 8-bit unsigned integer.
Definition types.hpp:71
Exiv2::signedByte
@ signedByte
Exif SBYTE type, an 8-bit signed (twos-complement) integer.
Definition types.hpp:76
Exiv2::asciiString
@ asciiString
Exif ASCII type, 8-bit byte.
Definition types.hpp:72
Exiv2::xmpText
@ xmpText
XMP text type.
Definition types.hpp:92
Exiv2::time
@ time
IPTC time type.
Definition types.hpp:89
Exiv2::xmpSeq
@ xmpSeq
XMP sequence type.
Definition types.hpp:95
Exiv2::comment
@ comment
Exiv2 type for the Exif user comment.
Definition types.hpp:90
Exiv2::tiffDouble
@ tiffDouble
TIFF DOUBLE type, double precision (8-byte) IEEE format.
Definition types.hpp:82
Exiv2::undefined
@ undefined
Exif UNDEFINED type, an 8-bit byte that may contain anything.
Definition types.hpp:77
Exiv2::xmpBag
@ xmpBag
XMP bag type.
Definition types.hpp:94
Exiv2::tiffFloat
@ tiffFloat
TIFF FLOAT type, single precision (4-byte) IEEE format.
Definition types.hpp:81
Exiv2::unsignedRational
@ unsignedRational
Exif RATIONAL type, two LONGs: numerator and denominator of a fraction.
Definition types.hpp:75
Exiv2::tiffIfd
@ tiffIfd
TIFF IFD type, 32-bit (4-byte) unsigned integer.
Definition types.hpp:83
Exiv2::invalidTypeId
@ invalidTypeId
Invalid type id.
Definition types.hpp:97
Exiv2::directory
@ directory
Exiv2 type for a CIFF directory.
Definition types.hpp:91
Exiv2::stringTo< bool >
bool stringTo< bool >(const std::string &s, bool &ok)
Specialization of stringTo(const std::string& s, bool& ok) for bool.
Definition types.cpp:513
Exiv2::getUShort
EXIV2API uint16_t getUShort(const byte *buf, ByteOrder byteOrder)
Read a 2 byte unsigned short value from the data buffer.
Definition types.cpp:246
Exiv2::ur2Data
EXIV2API size_t ur2Data(byte *buf, URational l, ByteOrder byteOrder)
Convert an unsigned rational to data, write the data to the buffer, return number of bytes written.
Definition types.cpp:372
Exiv2::exifTime
EXIV2API int exifTime(const char *buf, tm *tm)
Converts a string in the form "%Y:%m:%d %H:%M:%S", e.g., "2007:05:24 12:31:55" to broken down time fo...
Definition types.cpp:484
Exiv2::parseRational
EXIV2API Rational parseRational(const std::string &s, bool &ok)
Return a Rational set to the value represented by s.
Definition types.cpp:586
Exiv2::parseUint32
EXIV2API uint32_t parseUint32(const std::string &s, bool &ok)
Return a uint32_t set to the value represented by s.
Definition types.cpp:556
Exiv2::s2Data
EXIV2API size_t s2Data(byte *buf, int16_t s, ByteOrder byteOrder)
Convert a signed short to data, write the data to the buffer, return number of bytes written.
Definition types.cpp:378
Exiv2::ByteOrder
ByteOrder
Type to express the byte order (little or big endian)
Definition types.hpp:34
Exiv2::stringTo
T stringTo(const std::string &s, bool &ok)
Utility function to convert a string to a value of type T.
Definition types.hpp:483
Exiv2::getULongLong
EXIV2API uint64_t getULongLong(const byte *buf, ByteOrder byteOrder)
Read a 8 byte unsigned long value from the data buffer.
Definition types.cpp:257
Exiv2::l2Data
EXIV2API size_t l2Data(byte *buf, int32_t l, ByteOrder byteOrder)
Convert a signed long to data, write the data to the buffer, return number of bytes written.
Definition types.cpp:389
Exiv2::WriteMethod
WriteMethod
Type to indicate write method used by TIFF parsers.
Definition types.hpp:41
Exiv2::getRational
EXIV2API Rational getRational(const byte *buf, ByteOrder byteOrder)
Read an 8 byte signed rational value from the data buffer.
Definition types.cpp:290
Exiv2::r2Data
EXIV2API size_t r2Data(byte *buf, Rational l, ByteOrder byteOrder)
Convert a signed rational to data, write the data to the buffer, return number of bytes written.
Definition types.cpp:404
Exiv2::ull2Data
EXIV2API size_t ull2Data(byte *buf, uint64_t l, ByteOrder byteOrder)
Convert an uint64_t to data, write the data to the buffer, return number of bytes written.
Definition types.cpp:357
Exiv2::MetadataId
MetadataId
An identifier for each type of metadata.
Definition types.hpp:47
Exiv2::parseInt64
EXIV2API int64_t parseInt64(const std::string &s, bool &ok)
Return a int64_t set to the value represented by s.
Definition types.cpp:530
Exiv2::operator>>
EXIV2API std::istream & operator>>(std::istream &is, Rational &r)
Input operator for our fake rational.
Definition types.cpp:234
Exiv2::getLong
EXIV2API int32_t getLong(const byte *buf, ByteOrder byteOrder)
Read a 4 byte signed long value from the data buffer.
Definition types.cpp:283
Exiv2::toStringHelper
std::string toStringHelper(const T &arg, std::true_type)
Utility function to convert the argument of any type to a string.
Definition types.hpp:456
Exiv2::Blob
std::vector< byte > Blob
Container for binary data.
Definition types.hpp:102
Exiv2::getURational
EXIV2API URational getURational(const byte *buf, ByteOrder byteOrder)
Read an 8 byte unsigned rational value from the data buffer.
Definition types.cpp:270
Exiv2::us2Data
EXIV2API size_t us2Data(byte *buf, uint16_t s, ByteOrder byteOrder)
Convert an unsigned short to data, write the data to the buffer, return number of bytes written.
Definition types.cpp:331
Exiv2::AccessMode
AccessMode
An identifier for each mode of metadata support.
Definition types.hpp:57
Exiv2::DataBuf
Utility class containing a character array. All it does is to take care of memory allocation and dele...
Definition types.hpp:124
Exiv2::DataBuf::DataBuf
DataBuf()=default
Default constructor.
Exiv2::Internal::MutableSliceBase::at
value_type & at(size_t index)
Definition slice.hpp:174
Exiv2::Slice
Slice (= view) for STL containers.
Definition slice.hpp:421