// ***************************************************************** -*- 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.

 */

/*!

  @file    value.hpp

  @brief   Value interface and concrete subclasses

  @author  Andreas Huggel (ahu)

           ahuggel@gmx.net

  @date    09-Jan-04, ahu: created

           11-Feb-04, ahu: isolated as a component

           31-Jul-04, brad: added Time, Data and String values

 */

#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

    /*!

      @brief Common interface for all types of values used with metadata.

      The interface provides a uniform way to access values independent of

      their actual C++ type for simple tasks like reading the values from a

      string or data buffer.  For other tasks, like modifying values you may

      need to downcast it to a specific subclass to access its interface.

     */

    class EXIV2API Value {

    public:

        //! Shortcut for a %Value auto pointer.

        typedef std::auto_ptr<Value> AutoPtr;

        //! @name Creators

        //@{

        //! Constructor, taking a type id to initialize the base class with

        explicit Value(TypeId typeId);

        //! Virtual destructor.

        virtual ~Value();

        //@}

        //! @name Manipulators

        //@{

        /*!

          @brief Read the value from a character buffer.

          @param buf Pointer to the data buffer to read from

          @param len Number of bytes in the data buffer

          @param byteOrder Applicable byte order (little or big endian).

          @return 0 if successful.

         */

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

        /*!

          @brief Set the value from a string buffer. The format of the string

                 corresponds to that of the write() method, i.e., a string

                 obtained through the write() method can be read by this

                 function.

          @param buf The string to read from.

          @return 0 if successful.

         */

        virtual int read(const std::string& buf) =0;

        /*!

          @brief Set the data area, if the value has one by copying (cloning)

                 the buffer pointed to by buf.

          Values may have a data area, which can contain additional

          information besides the actual value. This method is used to set such

          a data area.

          @param buf Pointer to the source data area

          @param len Size of the data area

          @return Return -1 if the value has no data area, else 0.

         */

        virtual int setDataArea(const byte* buf, long len);

        //@}

        //! @name Accessors

        //@{

        //! Return the type identifier (Exif data format type).

        TypeId typeId() const { return type_; }

        /*!

          @brief Return an auto-pointer to a copy of itself (deep copy).

                 The caller owns this copy and the auto-pointer ensures that

                 it will be deleted.

         */

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

        /*!

          @brief Write value to a data buffer.

          The user must ensure that the buffer has enough memory. Otherwise

          the call results in undefined behaviour.

          @param buf Data buffer to write to.

          @param byteOrder Applicable byte order (little or big endian).

          @return Number of bytes written.

        */

        virtual long copy(byte* buf, ByteOrder byteOrder) const =0;

        //! Return the number of components of the value

        virtual long count() const =0;

        //! Return the size of the value in bytes

        virtual long size() const =0;

        /*!

          @brief Write the value to an output stream. You do not usually have

                 to use this function; it is used for the implementation of

                 the output operator for %Value,

                 operator<<(std::ostream &os, const Value &value).

        */

        virtual std::ostream& write(std::ostream& os) const =0;

        /*!

          @brief Return the value as a string. Implemented in terms of

                 write(std::ostream& os) const of the concrete class.

         */

        std::string toString() const;

        /*!

          @brief Return the n-th component of the value as a string.

                 The default implementation returns toString(). The behaviour

                 of this method may be undefined if there is no n-th

                 component.

         */

        virtual std::string toString(long n) const;

        /*!

          @brief Convert the n-th component of the value to a long.

                 The behaviour of this method may be undefined if there is no

                 n-th component.

          @return The converted value.

         */

        virtual long toLong(long n =0) const =0;

        /*!

          @brief Convert the n-th component of the value to a float.

                 The behaviour of this method may be undefined if there is no

                 n-th component.

          @return The converted value.

         */

        virtual float toFloat(long n =0) const =0;

        /*!

          @brief Convert the n-th component of the value to a Rational.

                 The behaviour of this method may be undefined if there is no

                 n-th component.

          @return The converted value.

         */

        virtual Rational toRational(long n =0) const =0;

        //! Return the size of the data area, 0 if there is none.

        virtual long sizeDataArea() const;

        /*!

          @brief Return a copy of the data area if the value has one. The

                 caller owns this copy and DataBuf ensures that it will be

                 deleted.

          Values may have a data area, which can contain additional

          information besides the actual value. This method is used to access

          such a data area.

          @return A DataBuf containing a copy of the data area or an empty

                  DataBuf if the value does not have a data area assigned.

         */

        virtual DataBuf dataArea() const;

        /*!

          @brief Check the \em ok status indicator. After a to<Type> conversion,

                 this indicator shows whether the conversion was successful.

         */

        bool ok() const { return ok_; }

        //@}

        /*!

          @brief A (simple) factory to create a Value type.

          The following Value subclasses are created depending on typeId:

          typeId%Value subclass

          invalidTypeId%DataValue(invalidTypeId)

          unsignedByte%DataValue(unsignedByte)

          asciiString%AsciiValue

          string%StringValue

          unsignedShort%ValueType < uint16_t >

          unsignedLong%ValueType < uint32_t >

          unsignedRational%ValueType < URational >

          invalid6%DataValue(invalid6)

          undefined%DataValue

          signedShort%ValueType < int16_t >

          signedLong%ValueType < int32_t >

          signedRational%ValueType < Rational >

          tiffFloat%ValueType < float >

          tiffDouble%ValueType < double >

          tiffIfd%ValueType < uint32_t >

          date%DateValue

          time%TimeValue

          comment%CommentValue

          xmpText%XmpTextValue

          xmpBag%XmpArrayValue

          xmpSeq%XmpArrayValue

          xmpAlt%XmpArrayValue

          langAlt%LangAltValue

          default%DataValue(typeId)

          @param typeId Type of the value.

          @return Auto-pointer to the newly created Value. The caller owns this

                  copy and the auto-pointer ensures that it will be deleted.

         */

        static AutoPtr create(TypeId typeId);

    protected:

        /*!

          @brief Assignment operator. Protected so that it can only be used

                 by subclasses but not directly.

         */

        Value& operator=(const Value& rhs);

        // DATA

        mutable bool ok_;                //!< Indicates the status of the previous to<Type> conversion

    private:

        //! Internal virtual copy constructor.

        virtual Value* clone_() const =0;

        // DATA

        TypeId type_;                    //!< Type of the data

    }; // class Value

    //! Output operator for Value types

    inline std::ostream& operator<<(std::ostream& os, const Value& value)

    {

        return value.write(os);

    }

    //! %Value for an undefined data type.

    class EXIV2API DataValue : public Value {

    public:

        //! Shortcut for a %DataValue auto pointer.

        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();

        //! @name Manipulators

        //@{

        /*!

          @brief Read the value from a character buffer.

          @note The byte order is required by the interface but not

                used by this method, so just use the default.

          @param buf Pointer to the data buffer to read from

          @param len Number of bytes in the data buffer

          @param byteOrder Byte order. Not needed.

          @return 0 if successful.

         */

        virtual int read(const byte* buf,

                          long len,

                          ByteOrder byteOrder =invalidByteOrder);

        //! Set the data from a string of integer values (e.g., "0 1 2 3")

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

        //@}

        //! @name Accessors

        //@{

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

        /*!

          @brief Write value to a character data buffer.

          @note The byte order is required by the interface but not used by this

                method, so just use the default.

          The user must ensure that the buffer has enough memory. Otherwise

          the call results in undefined behaviour.

          @param buf Data buffer to write to.

          @param byteOrder Byte order. Not needed.

          @return Number of characters written.

        */

        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;

        /*!

          @brief Return the n-th component of the value as a string.

                 The behaviour of this method may be undefined if there is no

                 n-th component.

         */

        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:

        //! Internal virtual copy constructor.

        virtual DataValue* clone_() const;

        //! Type used to store the data.

        typedef std::vector<byte> ValueType;

        // DATA

        ValueType value_;                       //!< Stores the data value

    }; // class DataValue

    /*!

      @brief Abstract base class for a string based %Value type.

      Uses a std::string to store the value and implements defaults for

      most operations.

     */

    class EXIV2API StringValueBase : public Value {

    public:

        //! Shortcut for a %StringValueBase auto pointer.

        typedef std::auto_ptr<StringValueBase> AutoPtr;

        //! @name Creators

        //@{

        //! Constructor for subclasses

        explicit StringValueBase(TypeId typeId);

        //! Constructor for subclasses

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

        //! Copy constructor

        StringValueBase(const StringValueBase& rhs);

        //! Virtual destructor.

        virtual ~StringValueBase();

        //@}

        //! @name Manipulators

        //@{

        //! Read the value from buf. This default implementation uses buf as it is.

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

        /*!

          @brief Read the value from a character buffer.

          @note The byte order is required by the interface but not used by this

                method, so just use the default.

          @param buf Pointer to the data buffer to read from

          @param len Number of bytes in the data buffer

          @param byteOrder Byte order. Not needed.

          @return 0 if successful.

         */

        virtual int read(const byte* buf,

                         long len,

                         ByteOrder byteOrder =invalidByteOrder);

        //@}

        //! @name Accessors

        //@{

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

        /*!

          @brief Write value to a character data buffer.

          The user must ensure that the buffer has enough memory. Otherwise

          the call results in undefined behaviour.

          @note The byte order is required by the interface but not used by this

                method, so just use the default.

          @param buf Data buffer to write to.

          @param byteOrder Byte order. Not used.

          @return Number of characters written.

        */

        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:

        //! Assignment operator.

        StringValueBase& operator=(const StringValueBase& rhs);

        //! Internal virtual copy constructor.

        virtual StringValueBase* clone_() const =0;

    public:

        // DATA

        std::string value_;                     //!< Stores the string value.

    }; // class StringValueBase

    /*!

      @brief %Value for string type.

      This can be a plain Ascii string or a multipe byte encoded string. It is

      left to caller to decode and encode the string to and from readable

      text if that is required.

    */

    class EXIV2API StringValue : public StringValueBase {

    public:

        //! Shortcut for a %StringValue auto pointer.

        typedef std::auto_ptr<StringValue> AutoPtr;

        //! @name Creators

        //@{

        //! Default constructor.

        StringValue();

        //! Constructor

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

        //! Virtual destructor.

        virtual ~StringValue();

        //@}

        //! @name Accessors

        //@{

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

        //@}

    private:

        //! Internal virtual copy constructor.

        virtual StringValue* clone_() const;

    }; // class StringValue

    /*!

      @brief %Value for an Ascii string type.

      This class is for null terminated single byte Ascii strings.

      This class also ensures that the string is null terminated.

     */

    class EXIV2API AsciiValue : public StringValueBase {

    public:

        //! Shortcut for a %AsciiValue auto pointer.

        typedef std::auto_ptr<AsciiValue> AutoPtr;

        //! @name Creators

        //@{

        //! Default constructor.

        AsciiValue();

        //! Constructor

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

        //! Virtual destructor.

        virtual ~AsciiValue();

        //@}

        //! @name Manipulators

        //@{

        using StringValueBase::read;

        /*!

          @brief Set the value to that of the string buf. Overrides base class

                 to append a terminating '\\0' character if buf doesn't end

                 with '\\0'.

         */

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

        //@}

        //! @name Accessors

        //@{

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

        /*!

          @brief Write the ASCII value up to the the first '\\0' character to an

                 output stream.  Any further characters are ignored and not

                 written to the output stream.

        */

        virtual std::ostream& write(std::ostream& os) const;

        //@}

    private:

        //! Internal virtual copy constructor.

        virtual AsciiValue* clone_() const;

    }; // class AsciiValue

    /*!

      @brief %Value for an Exif comment.

      This can be a plain Ascii string or a multipe byte encoded string. The

      comment is expected to be encoded in the character set indicated (default

      undefined), but this is not checked. It is left to caller to decode and

      encode the string to and from readable text if that is required.

    */

    class EXIV2API CommentValue : public StringValueBase {

    public:

        //! Character set identifiers for the character sets defined by %Exif

        enum CharsetId { ascii, jis, unicode, undefined,

                         invalidCharsetId, lastCharsetId };

        //! Information pertaining to the defined character sets

        struct CharsetTable {

            //! Constructor

            CharsetTable(CharsetId charsetId,

                         const char* name,

                         const char* code);

            CharsetId charsetId_;                   //!< Charset id

            const char* name_;                      //!< Name of the charset

            const char* code_;                      //!< Code of the charset

        }; // struct CharsetTable

        //! Charset information lookup functions. Implemented as a static class.

        class EXIV2API CharsetInfo {

            //! Prevent construction: not implemented.

            CharsetInfo() {}

            //! Prevent copy-construction: not implemented.

            CharsetInfo(const CharsetInfo&);

            //! Prevent assignment: not implemented.

            CharsetInfo& operator=(const CharsetInfo&);

        public:

            //! Return the name for a charset id

            static const char* name(CharsetId charsetId);

            //! Return the code for a charset id

            static const char* code(CharsetId charsetId);

            //! Return the charset id for a name

            static CharsetId charsetIdByName(const std::string& name);

            //! Return the charset id for a code

            static CharsetId charsetIdByCode(const std::string& code);

        private:

            static const CharsetTable charsetTable_[];

        }; // class CharsetInfo

        //! Shortcut for a %CommentValue auto pointer.

        typedef std::auto_ptr<CommentValue> AutoPtr;

        //! @name Creators

        //@{

        //! Default constructor.

        CommentValue();

        //! Constructor, uses read(const std::string& comment)

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

        //! Virtual destructor.

        virtual ~CommentValue();

        //@}

        //! @name Manipulators

        //@{

        /*!

          @brief Read the value from a comment

          The format of \em comment is:

          [charset=["]Ascii|Jis|Unicode|Undefined["] ]comment

          The default charset is Undefined.

          @return 0 if successful

                  1 if an invalid character set is encountered

        */

        int read(const std::string& comment);

        /*!

          @brief Read the comment from a byte buffer.

         */

        int read(const byte* buf, long len, ByteOrder byteOrder);

        //@}

        //! @name Accessors

        //@{

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

        long copy(byte* buf, ByteOrder byteOrder) const;

        /*!

          @brief Write the comment in a format which can be read by

          read(const std::string& comment).

         */

        std::ostream& write(std::ostream& os) const;

        /*!

          @brief Return the comment (without a charset="..." prefix)

          The comment is decoded to UTF-8. For Exif UNICODE comments, the

          function makes an attempt to correctly determine the character

          encoding of the value. Alternatively, the optional \em encoding

          parameter can be used to specify it.

          @param encoding Optional argument to specify the character encoding

              that the comment is encoded in, as an iconv(3) name. Only used

              for Exif UNICODE comments.

          @return A string containing the comment converted to UTF-8.

         */

        std::string comment(const char* encoding =0) const;

        /*!

          @brief Determine the character encoding that was used to encode the

              UNICODE comment value as an iconv(3) name.

          If the comment \em c starts with a BOM, the BOM is interpreted and

          removed from the string.

          Todo: Implement rules to guess if the comment is UTF-8 encoded.

         */

        const char* detectCharset(std::string& c) const;

        //! Return the Exif charset id of the comment

        CharsetId charsetId() const;

        //@}

    private:

        //! Internal virtual copy constructor.

        virtual CommentValue* clone_() const;

    public:

        // DATA

        ByteOrder byteOrder_;      //!< Byte order of the comment string that was read

    }; // class CommentValue

    /*!

      @brief Base class for all Exiv2 values used to store XMP property values.

     */

    class EXIV2API XmpValue : public Value {

    public:

        //! Shortcut for a %XmpValue auto pointer.

        typedef std::auto_ptr<XmpValue> AutoPtr;

        //! XMP array types.

        enum XmpArrayType { xaNone, xaAlt, xaBag, xaSeq };

        //! XMP structure indicator.

        enum XmpStruct { xsNone, xsStruct };

        //! @name Creators

        //@{

        explicit XmpValue(TypeId typeId);

        //@}

        //! @name Accessors

        //@{

        //! Return XMP array type, indicates if an XMP value is an array.

        XmpArrayType xmpArrayType() const;

        //! Return XMP struct, indicates if an XMP value is a structure.

        XmpStruct xmpStruct() const;

        virtual long size() const;

        /*!

          @brief Write value to a character data buffer.

          The user must ensure that the buffer has enough memory. Otherwise

          the call results in undefined behaviour.

          @note The byte order is required by the interface but not used by this

                method, so just use the default.

          @param buf Data buffer to write to.

          @param byteOrder Byte order. Not used.

          @return Number of characters written.

        */

        virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;

        //@}

        //! @name Manipulators

        //@{

        //! Set the XMP array type to indicate that an XMP value is an array.

        void setXmpArrayType(XmpArrayType xmpArrayType);

        //! Set the XMP struct type to indicate that an XMP value is a structure.

        void setXmpStruct(XmpStruct xmpStruct =xsStruct);

        /*!

          @brief Read the value from a character buffer.

          Uses read(const std::string& buf)

          @note The byte order is required by the interface but not used by this

                method, so just use the default.

          @param buf Pointer to the data buffer to read from

          @param len Number of bytes in the data buffer

          @param byteOrder Byte order. Not needed.

          @return 0 if successful.

         */

        virtual int read(const byte* buf,

                         long len,

                         ByteOrder byteOrder =invalidByteOrder);

        virtual int read(const std::string& buf) =0;

        //@}

        /*!

          @brief Return XMP array type for an array Value TypeId, xaNone if

                 \em typeId is not an XMP array value type.

         */

        static XmpArrayType xmpArrayType(TypeId typeId);

    protected:

        /*!

          @brief Assignment operator. Protected so that it can only be used

                 by subclasses but not directly.

         */

        XmpValue& operator=(const XmpValue& rhs);

    private:

        // DATA

        XmpArrayType xmpArrayType_;             //!< Type of XMP array

        XmpStruct    xmpStruct_;                //!< XMP structure indicator

    }; // class XmpValue

    /*!

      @brief %Value type suitable for simple XMP properties and

             XMP nodes of complex types which are not parsed into

             specific values.

      Uses a std::string to store the value.

     */

    class EXIV2API XmpTextValue : public XmpValue {

    public:

        //! Shortcut for a %XmpTextValue auto pointer.

        typedef std::auto_ptr<XmpTextValue> AutoPtr;

        //! @name Creators

        //@{

        //! Constructor.

        XmpTextValue();

        //! Constructor, reads the value from a string.

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

        //@}

        //! @name Manipulators

        //@{

        using XmpValue::read;

        /*!

          @brief Read a simple property value from \em buf to set the value.

          Sets the value to the contents of \em buf. A optional keyword,

          \em type is supported to set the XMP value type. This is useful for

          complex value types for which Exiv2 does not have direct support.

          The format of \em buf is:

          [type=["]Alt|Bag|Seq|Struct["] ]text

          @return 0 if successful.

         */

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

        //@}

        //! @name Accessors

        //@{

        AutoPtr clone() const;

        long size() const;

        virtual long count() const;

        /*!

          @brief Convert the value to a long.

                 The optional parameter \em n is not used and is ignored.

          @return The converted value.

         */

        virtual long toLong(long n =0) const;

        /*!

          @brief Convert the value to a float.

                 The optional parameter \em n is not used and is ignored.

          @return The converted value.

         */

        virtual float toFloat(long n =0) const;

        /*!

          @brief Convert the value to a Rational.

                 The optional parameter \em n is not used and is ignored.

          @return The converted value.

         */

        virtual Rational toRational(long n =0) const;

        virtual std::ostream& write(std::ostream& os) const;

        //@}

    private:

        //! Internal virtual copy constructor.

        virtual XmpTextValue* clone_() const;

    public:

        // DATA

        std::string value_;                     //!< Stores the string values.

    }; // class XmpTextValue

    /*!

      @brief %Value type for simple arrays. Each item in the array is a simple

             value, without qualifiers. The array may be an ordered (\em seq),

             unordered (\em bag) or alternative array (\em alt). The array

             items must not contain qualifiers. For language alternatives use

             LangAltValue.

      Uses a vector of std::string to store the value(s).

     */

    class EXIV2API XmpArrayValue : public XmpValue {

    public:

        //! Shortcut for a %XmpArrayValue auto pointer.

        typedef std::auto_ptr<XmpArrayValue> AutoPtr;

        //! @name Creators

        //@{

        //! Constructor. \em typeId can be one of xmpBag, xmpSeq or xmpAlt.

        explicit XmpArrayValue(TypeId typeId =xmpBag);

        //@}

        //! @name Manipulators

        //@{

        using XmpValue::read;

        /*!

          @brief Read a simple property value from \em buf and append it

                 to the value.

          Appends \em buf to the value after the last existing array element.

          Subsequent calls will therefore populate multiple array elements in

          the order they are read.

          @return 0 if successful.

         */

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

        //@}

        //! @name Accessors

        //@{

        AutoPtr clone() const;

        virtual long count() const;

        /*!

          @brief Return the n-th component of the value as a string.

                 The behaviour of this method may be undefined if there is no

                 n-th component.

         */

        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;

        /*!

          @brief Write all elements of the value to \em os, separated by commas.

          @note The output of this method cannot directly be used as the parameter

                for read().

         */

        virtual std::ostream& write(std::ostream& os) const;

        //@}

    private:

        //! Internal virtual copy constructor.

        virtual XmpArrayValue* clone_() const;

        std::vector<std::string> value_;        //!< Stores the string values.

    }; // class XmpArrayValue

    /*!

      @brief %LangAltValueComparator

      #1058

      https://www.adobe.com/content/dam/Adobe/en/devnet/xmp/pdfs/XMPSpecificationPart1.pdf

      XMP spec chapter B.4 (page 42) the xml:lang qualifier is to be compared case insensitive.

      */

    struct LangAltValueComparator {

        //! LangAltValueComparator comparison case insensitive function

        bool operator() (const std::string& str1, const std::string& str2) const

        {

            int result = str1.size() < str2.size() ?  1