Merge pull request #737 from Exiv2/EnumClassForImageTypes

Enum class for image types

include/exiv2/CMakeLists.txt

@@ -15,6 +15,7 @@ install(FILES
             gifimage.hpp
             http.hpp
             image.hpp
+            image_types.hpp
             ini.hpp
             iptc.hpp
             jp2image.hpp

include/exiv2/bigtiffimage.hpp

@@ -5,11 +5,6 @@
 namespace Exiv2
 {
 
-namespace ImageType
-{
-    const int bigtiff = 25;
-}
-
 Image::UniquePtr newBigTiffInstance(BasicIo::UniquePtr, bool);
 bool isBigTiffType(BasicIo &, bool);
 

include/exiv2/bmpimage.hpp

@@ -40,11 +40,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add Windows Bitmap (BMP) to the supported image formats
-    namespace ImageType {
-        const int bmp = 14; //!< Windows bitmap (bmp) image type (see class BmpImage)
-    }
-
     /*!
       @brief Class to access Windows bitmaps. This is just a stub - we only
           read width and height.

include/exiv2/cr2image.hpp

@@ -40,11 +40,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add CR2 to the supported image formats
-    namespace ImageType {
-        const int cr2 = 7;          //!< CR2 image type (see class Cr2Image)
-    }
-
     /*!
       @brief Class to access raw Canon CR2 images.  Exif metadata
           is supported directly, IPTC is read from the Exif data, if present.

include/exiv2/crwimage.hpp

@@ -47,11 +47,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add CRW to the supported image formats
-    namespace ImageType {
-        const int crw = 3;          //!< CRW image type (see class CrwImage)
-    }
-
     /*!
       @brief Class to access raw Canon CRW images. Only Exif metadata and a
              comment are supported. CRW format does not contain IPTC metadata.

include/exiv2/gifimage.hpp

@@ -41,11 +41,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add GIF to the supported image formats
-    namespace ImageType {
-        const int gif = 11;          //!< GIF image type (see class GifImage)
-    }
-
     /*!
       @brief Class to access raw GIF images. Exif/IPTC metadata are supported
              directly.

include/exiv2/image.hpp

@@ -30,6 +30,7 @@
 #include "basicio.hpp"
 #include "exif.hpp"
 #include "iptc.hpp"
+#include "image_types.hpp"
 #include "xmp_exiv2.hpp"
 
 // + standard includes
@@ -43,11 +44,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    //! Supported image formats
-    namespace ImageType {
-        const int none = 0;         //!< Not an image
-    }
-
     //! Native preview information. This is meant to be used only by the PreviewManager.
     struct NativePreview {
         long position_;                         //!< Position
@@ -90,9 +86,7 @@ namespace Exiv2 {
               metadata types and an auto-pointer that owns an IO instance.
               See subclass constructor doc.
          */
-        Image(int              imageType,
-              uint16_t         supportedMetadata,
-              BasicIo::UniquePtr io);
+        Image(ImageType type, uint16_t supportedMetadata, BasicIo::UniquePtr io);
         //! Virtual Destructor
         virtual ~Image();
         //@}
@@ -471,16 +465,14 @@ namespace Exiv2 {
         //@}
 
         //! set type support for this image format
-        void setTypeSupported(
-            int              imageType,
-            uint16_t         supportedMetadata
-        ) {
+        void setTypeSupported(ImageType imageType, uint16_t supportedMetadata)
+        {
             imageType_         = imageType;
             supportedMetadata_ = supportedMetadata;
         }
 
         //! set type support for this image format
-        int imageType() const { return imageType_; }
+        ImageType imageType() const { return imageType_; }
 
     protected:
         // DATA
@@ -509,7 +501,7 @@ namespace Exiv2 {
 
     private:
         // DATA
-        int               imageType_;         //!< Image type
+        ImageType        imageType_;         //!< Image type
         uint16_t          supportedMetadata_; //!< Bitmap with all supported metadata types
         bool              writeXmpFromPacket_;//!< Determines the source when writing XMP
         ByteOrder         byteOrder_;         //!< Byte order
@@ -614,13 +606,13 @@ namespace Exiv2 {
               type.
           @throw Error If the image type is not supported.
          */
-        static Image::UniquePtr create(int type, const std::string& path);
+        static Image::UniquePtr create(ImageType type, const std::string& path);
 #ifdef EXV_UNICODE_PATH
         /*!
           @brief Like create() but accepts a unicode path in an std::wstring.
           @note This function is only available on Windows.
          */
-        static Image::UniquePtr create(int type, const std::wstring& wpath);
+        static Image::UniquePtr create(ImageType type, const std::wstring& wpath);
 #endif
         /*!
           @brief Create an Image subclass of the requested type by creating a
@@ -630,7 +622,8 @@ namespace Exiv2 {
               type.
           @throw Error If the image type is not supported
          */
-        static Image::UniquePtr create(int type);
+        static Image::UniquePtr create(ImageType type);
+
         /*!
           @brief Create an Image subclass of the requested type by writing a
               new image to a BasicIo instance. If the BasicIo instance already
@@ -645,20 +638,22 @@ namespace Exiv2 {
           @return An auto-pointer that owns an Image instance of the requested
               type. If the image type is not supported, the pointer is 0.
          */
-        static Image::UniquePtr create(int type, BasicIo::UniquePtr io);
+
+        static Image::UniquePtr create(ImageType type, BasicIo::UniquePtr io);
         /*!
           @brief Returns the image type of the provided file.
           @param path %Image file. The contents of the file are tested to
               determine the image type. File extension is ignored.
           @return %Image type or Image::none if the type is not recognized.
          */
-        static int getType(const std::string& path);
+        static ImageType getType(const std::string& path);
+
 #ifdef EXV_UNICODE_PATH
         /*!
           @brief Like getType() but accepts a unicode path in an std::wstring.
           @note This function is only available on Windows.
          */
-        static int getType(const std::wstring& wpath);
+        static ImageType getType(const std::wstring& wpath);
 #endif
         /*!
           @brief Returns the image type of the provided data buffer.
@@ -667,15 +662,15 @@ namespace Exiv2 {
           @param size Number of bytes pointed to by \em data.
           @return %Image type or Image::none if the type is not recognized.
          */
-        static int getType(const byte* data, long size);
+        static ImageType getType(const byte* data, long size);
         /*!
           @brief Returns the image type of data provided by a BasicIo instance.
               The passed in \em io instance is (re)opened by this method.
           @param io A BasicIo instance that provides image data. The contents
               of the image data are tested to determine the type.
           @return %Image type or Image::none if the type is not recognized.
          */
-        static int getType(BasicIo& io);
+        static ImageType getType(BasicIo& io);
         /*!
           @brief Returns the access mode or supported metadata functions for an
               image type and a metadata type.
@@ -684,7 +679,7 @@ namespace Exiv2 {
           @return Access mode for the requested image type and metadata identifier.
           @throw Error(kerUnsupportedImageType) if the image type is not supported.
          */
-        static AccessMode checkMode(int type, MetadataId metadataId);
+        static AccessMode checkMode(ImageType type, MetadataId metadataId);
         /*!
           @brief Determine if the content of \em io is an image of \em type.
 
@@ -705,12 +700,10 @@ namespace Exiv2 {
           @return  true  if the data matches the type of this class;<BR>
                    false if the data does not match
         */
-        static bool checkType(int type, BasicIo& io, bool advance);
+        static bool checkType(ImageType type, BasicIo& io, bool advance);
 
         ImageFactory& operator=(const ImageFactory& rhs) = delete;
-        ImageFactory& operator=(const ImageFactory&& rhs) = delete;
         ImageFactory(const ImageFactory& rhs) = delete;
-        ImageFactory(const ImageFactory&& rhs) = delete;
     };  // class ImageFactory
 
 // *****************************************************************************

include/exiv2/image_types.hpp

@@ -0,0 +1,58 @@
+// ***************************************************************** -*- C++ -*-
+/*
+ * Copyright (C) 2004-2019 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 INCLUDE_EXIV2_IMAGE_TYPES_H
+#define INCLUDE_EXIV2_IMAGE_TYPES_H
+
+namespace Exiv2
+{
+    /// Supported Image Formats
+    enum class ImageType
+    {
+        none,
+        arw,
+        bigtiff,
+        bmp,        ///< Windows bitmap
+        cr2,
+        crw,
+        dng,
+        exv,
+        gif,        ///< GIF
+        jp2,        ///< JPEG-2000
+        jpeg,
+        mrw,
+        nef,
+        orf,
+        pef,
+        png,
+        pgf,
+        psd,        ///< Photoshop (PSD)
+        raf,
+        rw2,
+        sr2,
+        srw,
+        tga,
+        tiff,
+        webp,
+        xmp,        ///< XMP sidecar files
+    };
+}  // namespace Exiv2
+
+#endif  // INCLUDE_EXIV2_IMAGE_TYPES_H

include/exiv2/jp2image.hpp

@@ -39,12 +39,6 @@ namespace Exiv2
 // *****************************************************************************
 // class definitions
 
-    // Add JPEG-2000 to the supported image formats
-    namespace ImageType
-    {
-        const int jp2 = 15;                     //!< JPEG-2000 image type
-    }
-
     /*!
       @brief Class to access JPEG-2000 images.
      */

include/exiv2/jpgimage.hpp

@@ -46,12 +46,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Supported JPEG image formats
-    namespace ImageType {
-        const int jpeg = 1;         //!< JPEG image type (see class JpegImage)
-        const int exv  = 2;         //!< EXV image type (see class ExvImage)
-    }
-
     /*!
       @brief Helper class, has methods to deal with %Photoshop "Information
              Resource Blocks" (IRBs).
@@ -178,7 +172,7 @@ namespace Exiv2 {
               valid image of the calling subclass.
           @param dataSize Size of initData in bytes.
          */
-        JpegBase(int              type,
+        JpegBase(ImageType       type,
                  BasicIo::UniquePtr io,
                  bool             create,
                  const byte       initData[],

include/exiv2/mrwimage.hpp

@@ -41,11 +41,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add MRW to the supported image formats
-    namespace ImageType {
-        const int mrw = 5;          //!< MRW image type (see class MrwImage)
-    }
-
     /*!
       @brief Class to access raw Minolta MRW images. Exif metadata is supported
              directly, IPTC is read from the Exif data, if present.

include/exiv2/orfimage.hpp

@@ -40,11 +40,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add ORF to the supported image formats
-    namespace ImageType {
-        const int orf = 9;          //!< ORF image type (see class OrfImage)
-    }
-
     /*!
       @brief Class to access raw Olympus ORF images. Exif metadata is supported
              directly, IPTC is read from the Exif data, if present.

include/exiv2/pgfimage.hpp

@@ -44,12 +44,6 @@ namespace Exiv2
 // *****************************************************************************
 // class definitions
 
-    // Add PGF to the supported image formats
-    namespace ImageType
-    {
-        const int pgf = 17;          //!< PGF image type (see class PgfImage)
-    }
-
     /*!
       @brief Class to access PGF images. Exif and IPTC metadata are supported
           directly.

include/exiv2/pngimage.hpp

@@ -45,12 +45,6 @@ namespace Exiv2
 // *****************************************************************************
 // class definitions
 
-    // Add PNG to the supported image formats
-    namespace ImageType
-    {
-        const int png = 6;          //!< PNG image type (see class PngImage)
-    }
-
     /*!
       @brief Class to access PNG images. Exif and IPTC metadata are supported
           directly.

include/exiv2/psdimage.hpp

@@ -43,11 +43,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add PSD to the supported image formats
-    namespace ImageType {
-        const int psd = 12; //!< Photoshop (PSD) image type (see class PsdImage)
-    }
-
     /*!
       @brief Class to access raw Photoshop images.
      */

include/exiv2/rafimage.hpp

@@ -45,11 +45,6 @@ namespace Exiv2 {
 // *****************************************************************************
 // class definitions
 
-    // Add RAF to the supported image formats
-    namespace ImageType {
-        const int raf = 8;          //!< RAF image type (see class RafImage)
-    }
-
     /*!
       @brief Class to access raw Fujifilm RAF images. Exif metadata is
           supported directly, IPTC is read from the Exif data, if present.