value.hpp

Go to the documentation of this file.

// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2018 Exiv2 authors
 * This program is part of the Exiv2 distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
 */
#ifndef VALUE_HPP_
#define VALUE_HPP_

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

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

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

// *****************************************************************************
// namespace extensions
namespace Exiv2 {

// *****************************************************************************
// class definitions

    class EXIV2API Value {
    public:
        typedef std::auto_ptr<Value> AutoPtr;


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


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


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

        static AutoPtr create(TypeId typeId);

    protected:
        Value& operator=(const Value& rhs);
        // DATA
        mutable bool ok_;                

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

    }; // class Value

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

    class EXIV2API DataValue : public Value {
    public:
        typedef std::auto_ptr<DataValue> AutoPtr;

        explicit DataValue(TypeId typeId =undefined);

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

        virtual ~DataValue();



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


        AutoPtr clone() const { return AutoPtr(clone_()); }
        virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;
        virtual long count() const;
        virtual long size() const;
        virtual std::ostream& write(std::ostream& os) const;
        virtual std::string toString(long n) const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;

    private:
        virtual DataValue* clone_() const;

        typedef std::vector<byte> ValueType;
        // DATA
        ValueType value_;                       

    }; // class DataValue

    class EXIV2API StringValueBase : public Value {
    public:
        typedef std::auto_ptr<StringValueBase> AutoPtr;


        explicit StringValueBase(TypeId typeId);
        StringValueBase(TypeId typeId, const std::string& buf);
        StringValueBase(const StringValueBase& rhs);
        virtual ~StringValueBase();


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


        AutoPtr clone() const { return AutoPtr(clone_()); }
        virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;
        virtual long count() const;
        virtual long size() const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;
        virtual std::ostream& write(std::ostream& os) const;

    protected:
        StringValueBase& operator=(const StringValueBase& rhs);
        virtual StringValueBase* clone_() const =0;

    public:
        // DATA
        std::string value_;                     

    }; // class StringValueBase

    class EXIV2API StringValue : public StringValueBase {
    public:
        typedef std::auto_ptr<StringValue> AutoPtr;


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


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

    private:
        virtual StringValue* clone_() const;

    }; // class StringValue

    class EXIV2API AsciiValue : public StringValueBase {
    public:
        typedef std::auto_ptr<AsciiValue> AutoPtr;


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


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


        AutoPtr clone() const { return AutoPtr(clone_()); }
        virtual std::ostream& write(std::ostream& os) const;

    private:
        virtual AsciiValue* clone_() const;

    }; // class AsciiValue

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

        class EXIV2API CharsetInfo {
            CharsetInfo() {}
            CharsetInfo(const CharsetInfo&);
            CharsetInfo& operator=(const 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

        typedef std::auto_ptr<CommentValue> AutoPtr;


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



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


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

    private:
        virtual CommentValue* clone_() const;

    public:
        // DATA
        ByteOrder byteOrder_;      

    }; // class CommentValue

    class EXIV2API XmpValue : public Value {
    public:
        typedef std::auto_ptr<XmpValue> AutoPtr;

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


        explicit XmpValue(TypeId typeId);


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


        void setXmpArrayType(XmpArrayType xmpArrayType);
        void setXmpStruct(XmpStruct xmpStruct =xsStruct);
        virtual int read(const byte* buf,
                         long len,
                         ByteOrder byteOrder =invalidByteOrder);
        virtual int read(const std::string& buf) =0;

        static XmpArrayType xmpArrayType(TypeId typeId);

    protected:
        XmpValue& operator=(const XmpValue& rhs);

    private:
        // DATA
        XmpArrayType xmpArrayType_;             
        XmpStruct    xmpStruct_;                

    }; // class XmpValue

    class EXIV2API XmpTextValue : public XmpValue {
    public:
        typedef std::auto_ptr<XmpTextValue> AutoPtr;


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


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


        AutoPtr clone() const;
        long size() const;
        virtual long count() const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;
        virtual std::ostream& write(std::ostream& os) const;

    private:
        virtual XmpTextValue* clone_() const;

    public:
        // DATA
        std::string value_;                     

    }; // class XmpTextValue

    class EXIV2API XmpArrayValue : public XmpValue {
    public:
        typedef std::auto_ptr<XmpArrayValue> AutoPtr;


        explicit XmpArrayValue(TypeId typeId =xmpBag);


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


        AutoPtr clone() const;
        virtual long count() const;
        virtual std::string toString(long n) const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;
        virtual std::ostream& write(std::ostream& os) const;

    private:
        virtual XmpArrayValue* clone_() const;

        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
                       ;
            std::string::const_iterator c1 = str1.begin();
            std::string::const_iterator c2 = str2.begin();
            if (  result==0 ) for (
                ; 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:
        typedef std::auto_ptr<LangAltValue> AutoPtr;


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


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


        AutoPtr clone() const;
        virtual long count() const;
        virtual std::string toString(long n) const;
        std::string toString(const std::string& qualifier) const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;
        virtual std::ostream& write(std::ostream& os) const;

    private:
        virtual LangAltValue* clone_() const;

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

    }; // class LangAltValue

    class EXIV2API DateValue : public Value {
    public:
        typedef std::auto_ptr<DateValue> AutoPtr;


        DateValue();
        DateValue(int year, int month, int day);
        virtual ~DateValue();

        struct EXIV2API Date {
            Date() : year(0), month(0), day(0) {}
            int year;                           
            int month;                          
            int day;                            
        };



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


        AutoPtr clone() const { return AutoPtr(clone_()); }
        virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;
        virtual const Date& getDate() const;
        virtual long count() const;
        virtual long size() const;
        virtual std::ostream& write(std::ostream& os) const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;

    private:
        virtual DateValue* clone_() const;

        // DATA
        Date date_;

    }; // class DateValue

    class EXIV2API TimeValue : public Value {
    public:
        typedef std::auto_ptr<TimeValue> AutoPtr;


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

        virtual ~TimeValue();

        struct Time
        {
            Time() : hour(0), minute(0), second(0), tzHour(0), tzMinute(0) {}

            int hour;                           
            int minute;                         
            int second;                         
            int tzHour;                         
            int tzMinute;                       
        };



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


        AutoPtr clone() const { return AutoPtr(clone_()); }
        virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;
        virtual const Time& getTime() const;
        virtual long count() const;
        virtual long size() const;
        virtual std::ostream& write(std::ostream& os) const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;

    private:


        int scanTime3(const char* buf, const char* format);
        int scanTime6(const char* buf, const char* format);


        virtual TimeValue* clone_() const;

        // 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 {
    public:
        typedef std::auto_ptr<ValueType<T> > AutoPtr;


        ValueType();
        // The default c'tor and this one can be combined, but that causes MSVC 7.1 to fall on its nose
        explicit ValueType(TypeId typeId);
        ValueType(const byte* buf, long len, ByteOrder byteOrder, TypeId typeId =getType<T>());
        explicit ValueType(const T& val, TypeId typeId =getType<T>());
        ValueType(const ValueType<T>& rhs);
        virtual ~ValueType();


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


        AutoPtr clone() const { return AutoPtr(clone_()); }
        virtual long copy(byte* buf, ByteOrder byteOrder) const;
        virtual long count() const;
        virtual long size() const;
        virtual std::ostream& write(std::ostream& os) const;
        virtual std::string toString(long n) const;
        virtual long toLong(long n =0) const;
        virtual float toFloat(long n =0) const;
        virtual Rational toRational(long n =0) const;
        virtual long sizeDataArea() const;
        virtual DataBuf dataArea() const;

        typedef std::vector<T> ValueList;
        typedef typename std::vector<T>::iterator iterator;
        typedef typename std::vector<T>::const_iterator const_iterator;

        // DATA
        ValueList value_;

    private:
        virtual ValueType<T>* clone_() const;

        // DATA
        byte* pDataArea_;
        long sizeDataArea_;
    }; // class ValueType

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

// *****************************************************************************
// 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> long toData(byte* buf, T t, ByteOrder byteOrder);
    template<>
    inline long toData(byte* buf, uint16_t t, ByteOrder byteOrder)
    {
        return us2Data(buf, t, byteOrder);
    }
    template<>
    inline long toData(byte* buf, uint32_t t, ByteOrder byteOrder)
    {
        return ul2Data(buf, t, byteOrder);
    }
    template<>
    inline long toData(byte* buf, URational t, ByteOrder byteOrder)
    {
        return ur2Data(buf, t, byteOrder);
    }
    template<>
    inline long toData(byte* buf, int16_t t, ByteOrder byteOrder)
    {
        return s2Data(buf, t, byteOrder);
    }
    template<>
    inline long toData(byte* buf, int32_t t, ByteOrder byteOrder)
    {
        return l2Data(buf, t, byteOrder);
    }
    template<>
    inline long toData(byte* buf, Rational t, ByteOrder byteOrder)
    {
        return r2Data(buf, t, byteOrder);
    }
    template<>
    inline long toData(byte* buf, float t, ByteOrder byteOrder)
    {
        return f2Data(buf, t, byteOrder);
    }
    template<>
    inline long toData(byte* buf, double t, ByteOrder byteOrder)
    {
        return d2Data(buf, t, byteOrder);
    }

    template<typename T>
    ValueType<T>::ValueType()
        : Value(getType<T>()), pDataArea_(0), sizeDataArea_(0)
    {
    }

    template<typename T>
    ValueType<T>::ValueType(TypeId typeId)
        : Value(typeId), pDataArea_(0), sizeDataArea_(0)
    {
    }

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

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

    template<typename T>
    ValueType<T>::ValueType(const ValueType<T>& rhs)
        : Value(rhs), value_(rhs.value_), pDataArea_(0), sizeDataArea_(0)
    {
        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 = 0;
        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, long len, ByteOrder byteOrder)
    {
        value_.clear();
        long ts = TypeInfo::typeSize(typeId());
        if (ts != 0)
            if (len % ts != 0) len = (len / ts) * ts;
        for (long 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;
        ValueList val;
        while (!(is.eof())) {
            is >> tmp;
            if (is.fail()) return 1;
            val.push_back(tmp);
        }
        value_.swap(val);
        return 0;
    }

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

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

    template<typename T>
    long ValueType<T>::size() const
    {
        return static_cast<long>(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
    {
        typename ValueList::const_iterator end = value_.end();
        typename ValueList::const_iterator 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(long n) const
    {
        ok_ = true;
        return Exiv2::toString<T>(value_[n]);
    }

    // Default implementation
    template<typename T>
    long ValueType<T>::toLong(long n) const
    {
        ok_ = true;
        return static_cast<long>(value_[n]);
    }
// #55 crash when value_[n].first == LONG_MIN
#define LARGE_INT 1000000
    // Specialization for rational
    template<>
    inline long ValueType<Rational>::toLong(long n) const
    {
        ok_ = (value_[n].second != 0 && INT_MIN < value_[n].first && value_[n].first < INT_MAX );
        if (!ok_) return 0;
        return value_[n].first / value_[n].second;
    }
    // Specialization for unsigned rational
    template<>
    inline long ValueType<URational>::toLong(long n) const
    {
        ok_ = (value_[n].second != 0 && value_[n].first < LARGE_INT);
        if (!ok_) return 0;
        return value_[n].first / value_[n].second;
    }
    // Default implementation
    template<typename T>
    float ValueType<T>::toFloat(long n) const
    {
        ok_ = true;
        return static_cast<float>(value_[n]);
    }
    // Specialization for rational
    template<>
    inline float ValueType<Rational>::toFloat(long n) const
    {
        ok_ = (value_[n].second != 0);
        if (!ok_) return 0.0f;
        return static_cast<float>(value_[n].first) / value_[n].second;
    }
    // Specialization for unsigned rational
    template<>
    inline float ValueType<URational>::toFloat(long n) const
    {
        ok_ = (value_[n].second != 0);
        if (!ok_) return 0.0f;
        return static_cast<float>(value_[n].first) / value_[n].second;
    }
    // Default implementation
    template<typename T>
    Rational ValueType<T>::toRational(long n) const
    {
        ok_ = true;
        return Rational(value_[n], 1);
    }
    // Specialization for rational
    template<>
    inline Rational ValueType<Rational>::toRational(long n) const
    {
        ok_ = true;
        return Rational(value_[n].first, value_[n].second);
    }
    // Specialization for unsigned rational
    template<>
    inline Rational ValueType<URational>::toRational(long n) const
    {
        ok_ = true;
        return Rational(value_[n].first, value_[n].second);
    }
    // Specialization for float.
    template<>
    inline Rational ValueType<float>::toRational(long n) const
    {
        ok_ = true;
        // Warning: This is a very simple conversion, see floatToRationalCast()
        return floatToRationalCast(value_[n]);
    }
    // Specialization for double.
    template<>
    inline Rational ValueType<double>::toRational(long n) const
    {
        ok_ = true;
        // Warning: This is a very simple conversion, see floatToRationalCast()
        return floatToRationalCast(static_cast<float>(value_[n]));
    }

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

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

    template<typename T>
    int ValueType<T>::setDataArea(const byte* buf, long len)
    {
        byte* tmp = 0;
        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_