value.hpp

// SPDX-License-Identifier: GPL-2.0-or-later

#ifndef VALUE_HPP_
#define VALUE_HPP_

// *****************************************************************************
#include "exiv2lib_export.h"

// included header files
#include "types.hpp"

// + standard includes
#include <cmath>
#include <cstring>
#include <iomanip>
#include <map>
#include <memory>

// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class definitions

class EXIV2API Value {
 public:
  using UniquePtr = std::unique_ptr<Value>;


  explicit Value(TypeId typeId);
  virtual ~Value() = default;



  virtual int read(const byte* buf, size_t len, ByteOrder byteOrder) = 0;

  virtual int read(const std::string& buf) = 0;
  virtual int setDataArea(const byte* buf, size_t len);


  TypeId typeId() const {
    return type_;
  }
  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  virtual size_t copy(byte* buf, ByteOrder byteOrder) const = 0;
  virtual size_t count() const = 0;
  virtual size_t size() const = 0;
  virtual std::ostream& write(std::ostream& os) const = 0;
  std::string toString() const;
  virtual std::string toString(size_t n) const;
  virtual int64_t toInt64(size_t n = 0) const = 0;
  virtual uint32_t toUint32(size_t n = 0) const = 0;
  virtual float toFloat(size_t n = 0) const = 0;
  virtual Rational toRational(size_t n = 0) const = 0;
  virtual size_t sizeDataArea() const;
  virtual DataBuf dataArea() const;
  bool ok() const {
    return ok_;
  }

  static UniquePtr create(TypeId typeId);

 protected:
  Value(const Value&) = default;
  Value& operator=(const Value&) = default;
  // DATA
  mutable bool ok_{true};  

 private:
  virtual Value* clone_() const = 0;
  // DATA
  TypeId type_;  
};

inline std::ostream& operator<<(std::ostream& os, const Value& value) {
  return value.write(os);
}

class EXIV2API DataValue : public Value {
 public:
  using UniquePtr = std::unique_ptr<DataValue>;

  explicit DataValue(TypeId typeId = undefined);

  DataValue(const byte* buf, size_t len, ByteOrder byteOrder = invalidByteOrder, TypeId typeId = undefined);


  int read(const byte* buf, size_t len, ByteOrder byteOrder = invalidByteOrder) override;
  int read(const std::string& buf) override;


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  size_t copy(byte* buf, ByteOrder byteOrder = invalidByteOrder) const override;
  size_t count() const override;
  size_t size() const override;
  std::ostream& write(std::ostream& os) const override;
  std::string toString(size_t n) const override;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;

 private:
  DataValue* clone_() const override;

 public:
  using ValueType = std::vector<byte>;
  // DATA
  ValueType value_;  

};  // class DataValue

class EXIV2API StringValueBase : public Value {
  using Value::Value;

 public:
  using UniquePtr = std::unique_ptr<StringValueBase>;


  StringValueBase(TypeId typeId, const std::string& buf);


  int read(const std::string& buf) override;
  int read(const byte* buf, size_t len, ByteOrder byteOrder = invalidByteOrder) override;


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  size_t copy(byte* buf, ByteOrder byteOrder = invalidByteOrder) const override;
  size_t count() const override;
  size_t size() const override;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;
  std::ostream& write(std::ostream& os) const override;

 protected:
  StringValueBase* clone_() const override = 0;

 public:
  // DATA
  std::string value_;  

};  // class StringValueBase

class EXIV2API StringValue : public StringValueBase {
 public:
  using UniquePtr = std::unique_ptr<StringValue>;


  StringValue();
  explicit StringValue(const std::string& buf);


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }

 private:
  StringValue* clone_() const override;

};  // class StringValue

class EXIV2API AsciiValue : public StringValueBase {
 public:
  using UniquePtr = std::unique_ptr<AsciiValue>;


  AsciiValue();
  explicit AsciiValue(const std::string& buf);


  using StringValueBase::read;
  int read(const std::string& buf) override;


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  std::ostream& write(std::ostream& os) const override;

 private:
  AsciiValue* clone_() const override;

};  // class AsciiValue

class EXIV2API CommentValue : public StringValueBase {
 public:
  enum CharsetId { ascii, jis, unicode, undefined, invalidCharsetId, lastCharsetId };
  struct CharsetTable {
    CharsetId charsetId_;  
    const char* name_;     
    const char* code_;     
  };

  class EXIV2API CharsetInfo {
   public:
    static const char* name(CharsetId charsetId);
    static const char* code(CharsetId charsetId);
    static CharsetId charsetIdByName(const std::string& name);
    static CharsetId charsetIdByCode(const std::string& code);

   private:
    static const CharsetTable charsetTable_[];
  };  // class CharsetInfo

  using UniquePtr = std::unique_ptr<CommentValue>;


  CommentValue();
  explicit CommentValue(const std::string& comment);



  int read(const std::string& comment) override;
  int read(const byte* buf, size_t len, ByteOrder byteOrder) override;


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  size_t copy(byte* buf, ByteOrder byteOrder) const override;
  std::ostream& write(std::ostream& os) const override;
  std::string comment(const char* encoding = nullptr) const;
  const char* detectCharset(std::string& c) const;
  CharsetId charsetId() const;

 private:
  CommentValue* clone_() const override;

 public:
  // DATA
  ByteOrder byteOrder_{littleEndian};  

};  // class CommentValue

class EXIV2API XmpValue : public Value {
  using Value::Value;

 public:
  using UniquePtr = std::unique_ptr<XmpValue>;

  enum XmpArrayType { xaNone, xaAlt, xaBag, xaSeq };
  enum XmpStruct { xsNone, xsStruct };


  XmpArrayType xmpArrayType() const;
  XmpStruct xmpStruct() const;
  size_t size() const override;
  size_t copy(byte* buf, ByteOrder byteOrder = invalidByteOrder) const override;


  void setXmpArrayType(XmpArrayType xmpArrayType);
  void setXmpStruct(XmpStruct xmpStruct = xsStruct);

  int read(const byte* buf, size_t len, ByteOrder byteOrder = invalidByteOrder) override;
  int read(const std::string& buf) override = 0;

  static XmpArrayType xmpArrayType(TypeId typeId);

 private:
  // DATA
  XmpArrayType xmpArrayType_{xaNone};  
  XmpStruct xmpStruct_{xsNone};        

};  // class XmpValue

class EXIV2API XmpTextValue : public XmpValue {
 public:
  using UniquePtr = std::unique_ptr<XmpTextValue>;


  XmpTextValue();
  explicit XmpTextValue(const std::string& buf);


  using XmpValue::read;
  int read(const std::string& buf) override;


  UniquePtr clone() const;
  size_t size() const override;
  size_t count() const override;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;
  std::ostream& write(std::ostream& os) const override;

 private:
  XmpTextValue* clone_() const override;

 public:
  // DATA
  std::string value_;  

};  // class XmpTextValue

class EXIV2API XmpArrayValue : public XmpValue {
 public:
  using UniquePtr = std::unique_ptr<XmpArrayValue>;


  explicit XmpArrayValue(TypeId typeId = xmpBag);


  using XmpValue::read;
  int read(const std::string& buf) override;


  UniquePtr clone() const;
  size_t count() const override;
  std::string toString(size_t n) const override;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;
  std::ostream& write(std::ostream& os) const override;

 private:
  XmpArrayValue* clone_() const override;

  std::vector<std::string> value_;  

};  // class XmpArrayValue

struct LangAltValueComparator {
  bool operator()(const std::string& str1, const std::string& str2) const {
    int result = str1.size() < str2.size() ? 1 : str1.size() > str2.size() ? -1 : 0;
    if (result == 0) {
      for (auto c1 = str1.begin(), c2 = str2.begin(); result == 0 && c1 != str1.end(); ++c1, ++c2) {
        result = tolower(*c1) < tolower(*c2) ? 1 : tolower(*c1) > tolower(*c2) ? -1 : 0;
      }
    }
    return result < 0;
  }
};

class EXIV2API LangAltValue : public XmpValue {
 public:
  using UniquePtr = std::unique_ptr<LangAltValue>;


  LangAltValue();
  explicit LangAltValue(const std::string& buf);


  using XmpValue::read;
  int read(const std::string& buf) override;


  UniquePtr clone() const;
  size_t count() const override;
  std::string toString(size_t n) const override;
  std::string toString(const std::string& qualifier) const;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;
  std::ostream& write(std::ostream& os) const override;

 private:
  LangAltValue* clone_() const override;

 public:
  using ValueType = std::map<std::string, std::string, LangAltValueComparator>;
  // DATA
  ValueType value_;

};  // class LangAltValue

class EXIV2API DateValue : public Value {
 public:
  using UniquePtr = std::unique_ptr<DateValue>;


  DateValue();
  DateValue(int32_t year, int32_t month, int32_t day);

  struct EXIV2API Date {
    int32_t year;   
    int32_t month;  
    int32_t day;    
  };



  int read(const byte* buf, size_t len, ByteOrder byteOrder = invalidByteOrder) override;
  int read(const std::string& buf) override;
  void setDate(const Date& src);


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  size_t copy(byte* buf, ByteOrder byteOrder = invalidByteOrder) const override;

  virtual const Date& getDate() const;
  size_t count() const override;
  size_t size() const override;
  std::ostream& write(std::ostream& os) const override;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;

 private:
  DateValue* clone_() const override;

  // DATA
  Date date_;

};  // class DateValue

class EXIV2API TimeValue : public Value {
 public:
  using UniquePtr = std::unique_ptr<TimeValue>;


  TimeValue();
  TimeValue(int32_t hour, int32_t minute, int32_t second = 0, int32_t tzHour = 0, int32_t tzMinute = 0);

  struct Time {
    int32_t hour;      
    int32_t minute;    
    int32_t second;    
    int32_t tzHour;    
    int32_t tzMinute;  
  };



  int read(const byte* buf, size_t len, ByteOrder byteOrder = invalidByteOrder) override;
  int read(const std::string& buf) override;
  void setTime(const Time& src);


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  size_t copy(byte* buf, ByteOrder byteOrder = invalidByteOrder) const override;
  virtual const Time& getTime() const;
  size_t count() const override;
  size_t size() const override;
  std::ostream& write(std::ostream& os) const override;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;

 private:

  TimeValue* clone_() const override;

  // DATA
  Time time_;

};  // class TimeValue

template <typename T>
TypeId getType();

template <>
inline TypeId getType<uint16_t>() {
  return unsignedShort;
}
template <>
inline TypeId getType<uint32_t>() {
  return unsignedLong;
}
template <>
inline TypeId getType<URational>() {
  return unsignedRational;
}
template <>
inline TypeId getType<int16_t>() {
  return signedShort;
}
template <>
inline TypeId getType<int32_t>() {
  return signedLong;
}
template <>
inline TypeId getType<Rational>() {
  return signedRational;
}
template <>
inline TypeId getType<float>() {
  return tiffFloat;
}
template <>
inline TypeId getType<double>() {
  return tiffDouble;
}

// No default implementation: let the compiler/linker complain
// template<typename T> inline TypeId getType() { return invalid; }

template <typename T>
class ValueType : public Value {
  using Value::Value;

 public:
  using UniquePtr = std::unique_ptr<ValueType<T>>;


  ValueType();
  ValueType(const byte* buf, size_t len, ByteOrder byteOrder, TypeId typeId = getType<T>());
  explicit ValueType(const T& val, TypeId typeId = getType<T>());
  ValueType(const ValueType<T>& rhs);
  ~ValueType() override;


  ValueType<T>& operator=(const ValueType<T>& rhs);
  int read(const byte* buf, size_t len, ByteOrder byteOrder) override;
  int read(const std::string& buf) override;
  int setDataArea(const byte* buf, size_t len) override;


  UniquePtr clone() const {
    return UniquePtr(clone_());
  }
  size_t copy(byte* buf, ByteOrder byteOrder) const override;
  size_t count() const override;
  size_t size() const override;
  std::ostream& write(std::ostream& os) const override;
  std::string toString(size_t n) const override;
  int64_t toInt64(size_t n = 0) const override;
  uint32_t toUint32(size_t n = 0) const override;
  float toFloat(size_t n = 0) const override;
  Rational toRational(size_t n = 0) const override;
  size_t sizeDataArea() const override;
  DataBuf dataArea() const override;

  using ValueList = std::vector<T>;
  using iterator = typename std::vector<T>::iterator;
  using const_iterator = typename std::vector<T>::const_iterator;

  // DATA
  ValueList value_;

 private:
  template <typename I>
  inline I float_to_integer_helper(size_t n) const {
    const auto v = value_.at(n);
    if (static_cast<decltype(v)>(std::numeric_limits<I>::min()) <= v &&
        v <= static_cast<decltype(v)>(std::numeric_limits<I>::max())) {
      return static_cast<I>(std::lround(v));
    }
    return 0;
  }

  template <typename I>
  inline I rational_to_integer_helper(size_t n) const {
    auto a = value_.at(n).first;
    auto b = value_.at(n).second;

    // Protect against divide-by-zero.
    if (b <= 0) {
      return 0;
    }

    // Check for integer overflow.
#ifdef __cpp_if_constexpr
    if constexpr (std::is_signed_v<I> == std::is_signed_v<decltype(a)>) {
#else
    if (std::is_signed<I>::value == std::is_signed<decltype(a)>::value) {
#endif
      // conversion does not change sign
      const auto imin = std::numeric_limits<I>::min();
      const auto imax = std::numeric_limits<I>::max();
      if (imax < b || a < imin || imax < a) {
        return 0;
      }
#ifdef __cpp_if_constexpr
    } else if constexpr (std::is_signed_v<I>) {
#else
    } else if (std::is_signed<I>::value) {
#endif
      // conversion is from unsigned to signed
#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201402L))
      const auto imax = static_cast<std::make_unsigned_t<I>>(std::numeric_limits<I>::max());
#else
      const auto imax = static_cast<typename std::make_unsigned<I>::type>(std::numeric_limits<I>::max());
#endif
      if (imax < b || imax < a) {
        return 0;
      }
    } else {
      // conversion is from signed to unsigned
      const auto imax = std::numeric_limits<I>::max();
      if (a < 0) {
        return 0;
      }
      // Inputs are not negative so convert them to unsigned.
#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201402L))
      const auto a_u = static_cast<std::make_unsigned_t<decltype(a)>>(a);
      const auto b_u = static_cast<std::make_unsigned_t<decltype(b)>>(b);
#else
      const auto a_u = static_cast<typename std::make_unsigned<decltype(a)>::type>(a);
      const auto b_u = static_cast<typename std::make_unsigned<decltype(b)>::type>(b);
#endif
      if (imax < b_u || imax < a_u) {
        return 0;
      }
    }

    return static_cast<I>(a) / static_cast<I>(b);
  }

  ValueType<T>* clone_() const override;

  // DATA
  byte* pDataArea_{nullptr};
  size_t sizeDataArea_{0};
};  // class ValueType

using UShortValue = ValueType<uint16_t>;
using ULongValue = ValueType<uint32_t>;
using URationalValue = ValueType<URational>;
using ShortValue = ValueType<int16_t>;
using LongValue = ValueType<int32_t>;
using RationalValue = ValueType<Rational>;
using FloatValue = ValueType<float>;
using DoubleValue = ValueType<double>;

// *****************************************************************************
// free functions, template and inline definitions

template <typename T>
T getValue(const byte* buf, ByteOrder byteOrder);
// Specialization for a 2 byte unsigned short value.
template <>
inline uint16_t getValue(const byte* buf, ByteOrder byteOrder) {
  return getUShort(buf, byteOrder);
}
// Specialization for a 4 byte unsigned long value.
template <>
inline uint32_t getValue(const byte* buf, ByteOrder byteOrder) {
  return getULong(buf, byteOrder);
}
// Specialization for an 8 byte unsigned rational value.
template <>
inline URational getValue(const byte* buf, ByteOrder byteOrder) {
  return getURational(buf, byteOrder);
}
// Specialization for a 2 byte signed short value.
template <>
inline int16_t getValue(const byte* buf, ByteOrder byteOrder) {
  return getShort(buf, byteOrder);
}
// Specialization for a 4 byte signed long value.
template <>
inline int32_t getValue(const byte* buf, ByteOrder byteOrder) {
  return getLong(buf, byteOrder);
}
// Specialization for an 8 byte signed rational value.
template <>
inline Rational getValue(const byte* buf, ByteOrder byteOrder) {
  return getRational(buf, byteOrder);
}
// Specialization for a 4 byte float value.
template <>
inline float getValue(const byte* buf, ByteOrder byteOrder) {
  return getFloat(buf, byteOrder);
}
// Specialization for a 8 byte double value.
template <>
inline double getValue(const byte* buf, ByteOrder byteOrder) {
  return getDouble(buf, byteOrder);
}

template <typename T>
size_t toData(byte* buf, T t, ByteOrder byteOrder);
template <>
inline size_t toData(byte* buf, uint16_t t, ByteOrder byteOrder) {
  return us2Data(buf, t, byteOrder);
}
template <>
inline size_t toData(byte* buf, uint32_t t, ByteOrder byteOrder) {
  return ul2Data(buf, t, byteOrder);
}
template <>
inline size_t toData(byte* buf, URational t, ByteOrder byteOrder) {
  return ur2Data(buf, t, byteOrder);
}
template <>
inline size_t toData(byte* buf, int16_t t, ByteOrder byteOrder) {
  return s2Data(buf, t, byteOrder);
}
template <>
inline size_t toData(byte* buf, int32_t t, ByteOrder byteOrder) {
  return l2Data(buf, t, byteOrder);
}
template <>
inline size_t toData(byte* buf, Rational t, ByteOrder byteOrder) {
  return r2Data(buf, t, byteOrder);
}
template <>
inline size_t toData(byte* buf, float t, ByteOrder byteOrder) {
  return f2Data(buf, t, byteOrder);
}
template <>
inline size_t toData(byte* buf, double t, ByteOrder byteOrder) {
  return d2Data(buf, t, byteOrder);
}

template <typename T>
ValueType<T>::ValueType() : Value(getType<T>()) {
}

template <typename T>
ValueType<T>::ValueType(const byte* buf, size_t len, ByteOrder byteOrder, TypeId typeId) : Value(typeId) {
  read(buf, len, byteOrder);
}

template <typename T>
ValueType<T>::ValueType(const T& val, TypeId typeId) : Value(typeId) {
  value_.push_back(val);
}

template <typename T>
ValueType<T>::ValueType(const ValueType<T>& rhs) :
    Value(rhs.typeId()),
    value_(rhs.value_)

{
  if (rhs.sizeDataArea_ > 0) {
    pDataArea_ = new byte[rhs.sizeDataArea_];
    std::memcpy(pDataArea_, rhs.pDataArea_, rhs.sizeDataArea_);
    sizeDataArea_ = rhs.sizeDataArea_;
  }
}

template <typename T>
ValueType<T>::~ValueType() {
  delete[] pDataArea_;
}

template <typename T>
ValueType<T>& ValueType<T>::operator=(const ValueType<T>& rhs) {
  if (this == &rhs)
    return *this;
  Value::operator=(rhs);
  value_ = rhs.value_;

  byte* tmp = nullptr;
  if (rhs.sizeDataArea_ > 0) {
    tmp = new byte[rhs.sizeDataArea_];
    std::memcpy(tmp, rhs.pDataArea_, rhs.sizeDataArea_);
  }
  delete[] pDataArea_;
  pDataArea_ = tmp;
  sizeDataArea_ = rhs.sizeDataArea_;

  return *this;
}

template <typename T>
int ValueType<T>::read(const byte* buf, size_t len, ByteOrder byteOrder) {
  value_.clear();
  size_t ts = TypeInfo::typeSize(typeId());
  if (ts > 0 && len % ts != 0)
    len = (len / ts) * ts;
  for (size_t i = 0; i < len; i += ts) {
    value_.push_back(getValue<T>(buf + i, byteOrder));
  }
  return 0;
}

template <typename T>
int ValueType<T>::read(const std::string& buf) {
  std::istringstream is(buf);
  T tmp = T();
  ValueList val;
  while (!(is.eof())) {
    is >> tmp;
    if (is.fail())
      return 1;
    val.push_back(tmp);
  }
  value_.swap(val);
  return 0;
}

template <typename T>
size_t ValueType<T>::copy(byte* buf, ByteOrder byteOrder) const {
  size_t offset = 0;
  for (auto i = value_.begin(); i != value_.end(); ++i) {
    offset += toData(buf + offset, *i, byteOrder);
  }
  return offset;
}

template <typename T>
size_t ValueType<T>::count() const {
  return value_.size();
}

template <typename T>
size_t ValueType<T>::size() const {
  return TypeInfo::typeSize(typeId()) * value_.size();
}

template <typename T>
ValueType<T>* ValueType<T>::clone_() const {
  return new ValueType<T>(*this);
}

template <typename T>
std::ostream& ValueType<T>::write(std::ostream& os) const {
  auto end = value_.end();
  auto i = value_.begin();
  while (i != end) {
    os << std::setprecision(15) << *i;
    if (++i != end)
      os << " ";
  }
  return os;
}

template <typename T>
std::string ValueType<T>::toString(size_t n) const {
  ok_ = true;
  return Exiv2::toString<T>(value_.at(n));
}

// Default implementation
template <typename T>
int64_t ValueType<T>::toInt64(size_t n) const {
  ok_ = true;
  return static_cast<int64_t>(value_.at(n));
}
template <typename T>
uint32_t ValueType<T>::toUint32(size_t n) const {
  ok_ = true;
  return static_cast<uint32_t>(value_.at(n));
}
// #55 crash when value_.at(n).first == LONG_MIN
#define LARGE_INT 1000000
// Specialization for double
template <>
inline int64_t ValueType<double>::toInt64(size_t n) const {
  return float_to_integer_helper<int64_t>(n);
}

template <>
inline uint32_t ValueType<double>::toUint32(size_t n) const {
  return float_to_integer_helper<uint32_t>(n);
}
// Specialization for float
template <>
inline int64_t ValueType<float>::toInt64(size_t n) const {
  return float_to_integer_helper<int64_t>(n);
}
template <>
inline uint32_t ValueType<float>::toUint32(size_t n) const {
  return float_to_integer_helper<uint32_t>(n);
}
// Specialization for rational
template <>
inline int64_t ValueType<Rational>::toInt64(size_t n) const {
  return rational_to_integer_helper<int64_t>(n);
}
template <>
inline uint32_t ValueType<Rational>::toUint32(size_t n) const {
  return rational_to_integer_helper<uint32_t>(n);
}
// Specialization for unsigned rational
template <>
inline int64_t ValueType<URational>::toInt64(size_t n) const {
  return rational_to_integer_helper<int64_t>(n);
}
template <>
inline uint32_t ValueType<URational>::toUint32(size_t n) const {
  return rational_to_integer_helper<uint32_t>(n);
}
// Default implementation
template <typename T>
float ValueType<T>::toFloat(size_t n) const {
  ok_ = true;
  return static_cast<float>(value_.at(n));
}
// Specialization for rational
template <>
inline float ValueType<Rational>::toFloat(size_t n) const {
  ok_ = (value_.at(n).second != 0);
  if (!ok_)
    return 0.0f;
  return static_cast<float>(value_.at(n).first) / value_.at(n).second;
}
// Specialization for unsigned rational
template <>
inline float ValueType<URational>::toFloat(size_t n) const {
  ok_ = (value_.at(n).second != 0);
  if (!ok_)
    return 0.0f;
  return static_cast<float>(value_.at(n).first) / value_.at(n).second;
}
// Default implementation
template <typename T>
Rational ValueType<T>::toRational(size_t n) const {
  ok_ = true;
  return {value_.at(n), 1};
}
// Specialization for rational
template <>
inline Rational ValueType<Rational>::toRational(size_t n) const {
  ok_ = true;
  return {value_.at(n).first, value_.at(n).second};
}
// Specialization for unsigned rational
template <>
inline Rational ValueType<URational>::toRational(size_t n) const {
  ok_ = true;
  return {value_.at(n).first, value_.at(n).second};
}
// Specialization for float.
template <>
inline Rational ValueType<float>::toRational(size_t n) const {
  ok_ = true;
  // Warning: This is a very simple conversion, see floatToRationalCast()
  return floatToRationalCast(value_.at(n));
}
// Specialization for double.
template <>
inline Rational ValueType<double>::toRational(size_t n) const {
  ok_ = true;
  // Warning: This is a very simple conversion, see floatToRationalCast()
  return floatToRationalCast(static_cast<float>(value_.at(n)));
}

template <typename T>
size_t ValueType<T>::sizeDataArea() const {
  return sizeDataArea_;
}

template <typename T>
DataBuf ValueType<T>::dataArea() const {
  return {pDataArea_, sizeDataArea_};
}

template <typename T>
int ValueType<T>::setDataArea(const byte* buf, size_t len) {
  byte* tmp = nullptr;
  if (len > 0) {
    tmp = new byte[len];
    std::memcpy(tmp, buf, len);
  }
  delete[] pDataArea_;
  pDataArea_ = tmp;
  sizeDataArea_ = len;
  return 0;
}
}  // namespace Exiv2

#endif  // #ifndef VALUE_HPP_