Migrate from String to properly typed TiffUnsupportedError

src/decoder/mod.rs

@@ -3,7 +3,7 @@ use std::mem;
 use num_traits::{FromPrimitive, Num};
 use std::collections::HashMap;
 
-use ::{ColorType, TiffError, TiffFormatError, TiffResult};
+use ::{ColorType, TiffError, TiffFormatError, TiffUnsupportedError, TiffResult};
 
 use self::ifd::Directory;
 
@@ -35,8 +35,8 @@ enum DecodingBuffer<'a> {
     U16(&'a mut [u16])
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, FromPrimitive)]
-enum PhotometricInterpretation {
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
+pub enum PhotometricInterpretation {
     WhiteIsZero = 0,
     BlackIsZero = 1,
     RGB = 2,
@@ -47,8 +47,8 @@ enum PhotometricInterpretation {
     CIELab = 8,
 }
 
-#[derive(Clone, Copy, Debug, FromPrimitive)]
-enum CompressionMethod {
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
+pub enum CompressionMethod {
     None = 1,
     Huffman = 2,
     Fax3 = 3,
@@ -58,13 +58,13 @@ enum CompressionMethod {
     PackBits = 0x8005
 }
 
-#[derive(Clone, Copy, Debug, FromPrimitive)]
-enum PlanarConfiguration {
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
+pub enum PlanarConfiguration {
     Chunky = 1,
     Planar = 2
 }
 
-#[derive(Clone, Copy, Debug, FromPrimitive)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
 enum Predictor {
     None = 1,
     Horizontal = 2
@@ -125,9 +125,7 @@ fn rev_hpredict(image: DecodingResult, size: (u32, u32), color_type: ColorType)
         ColorType::Gray(8) | ColorType::Gray(16) => 1,
         ColorType::RGB(8) | ColorType::RGB(16) => 3,
         ColorType::RGBA(8) | ColorType::RGBA(16) | ColorType::CMYK(8) => 4,
-        _ => return Err(TiffError::UnsupportedError(format!(
-            "Horizontal predictor for {:?} is unsupported.", color_type
-        )))
+        _ => return Err(TiffError::UnsupportedError(TiffUnsupportedError::HorizontalPredictor(color_type)))
     };
     Ok(match image {
         DecodingResult::U8(buf) => {
@@ -171,9 +169,8 @@ impl<R: Read + Seek> Decoder<R> {
             PhotometricInterpretation::BlackIsZero | PhotometricInterpretation::WhiteIsZero
                                            if self.bits_per_sample.len() == 1 => Ok(ColorType::Gray(self.bits_per_sample[0])),
 
-            _ => Err(TiffError::UnsupportedError(format!(
-                "{:?} with {:?} bits per sample is unsupported", self.photometric_interpretation, self.bits_per_sample
-            ))) // TODO: this is bad we should not fail at this point}
+            // TODO: this is bad we should not fail at this point
+            _ => Err(TiffError::UnsupportedError(TiffUnsupportedError::InterpretationWithBits(self.photometric_interpretation, self.bits_per_sample.clone())))
         }
     }
 
@@ -216,18 +213,14 @@ impl<R: Read + Seek> Decoder<R> {
             try!(self.get_tag_u32(ifd::Tag::PhotometricInterpretation))
         ) {
             Some(val) => val,
-            None => return Err(TiffError::UnsupportedError(
-                "The image is using an unknown photometric interpretation.".to_string()
-            ))
+            None => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnknownInterpretation))
         };
         if let Some(val) = try!(self.find_tag_u32(ifd::Tag::Compression)) {
             match FromPrimitive::from_u32(val) {
                 Some(method) =>  {
                     self.compression_method = method
                 },
-                None => return Err(TiffError::UnsupportedError(
-                    "Unknown compression method.".to_string()
-                ))
+                None => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnknownCompressionMethod))
             }
         }
         if let Some(val) = try!(self.find_tag_u32(ifd::Tag::SamplesPerPixel)) {
@@ -245,9 +238,7 @@ impl<R: Read + Seek> Decoder<R> {
                 }
 
             }
-            _ => return Err(TiffError::UnsupportedError(
-                format!("{} samples per pixel is supported.", self.samples)
-            ))
+            _ => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedSampleDepth(self.samples)))
         }
         Ok(self)
     }
@@ -408,9 +399,7 @@ impl<R: Read + Seek> Decoder<R> {
                 let (bytes, reader) = try!(PackBitsReader::new(&mut self.reader, order, length as usize));
                 (bytes, Box::new(reader))
             },
-            method => return Err(TiffError::UnsupportedError(format!(
-                "Compression method {:?} is unsupported", method
-            )))
+            method => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedCompressionMethod(method)))
         };
         Ok(match (color_type, buffer) {
             (ColorType:: RGB(8), DecodingBuffer::U8(ref mut buffer)) |
@@ -443,9 +432,7 @@ impl<R: Read + Seek> Decoder<R> {
                 }
                 bytes
             }
-            (type_, _) => return Err(TiffError::UnsupportedError(format!(
-                "Color type {:?} is unsupported", type_
-            )))
+            (type_, _) => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedColorType(type_))),
         })
     }
 
@@ -463,18 +450,12 @@ impl<R: Read + Seek> Decoder<R> {
         let mut result = match self.bits_per_sample.iter().cloned().max().unwrap_or(8) {
             n if n <= 8 => DecodingResult::U8(Vec::with_capacity(buffer_size)),
             n if n <= 16 => DecodingResult::U16(Vec::with_capacity(buffer_size)),
-            n => return Err(
-                TiffError::UnsupportedError(
-                    format!("{} bits per channel not supported", n)
-                )
-            )
+            n => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedBitsPerChannel(n))),
         };
         if let Ok(config) = self.get_tag_u32(ifd::Tag::PlanarConfiguration) {
             match FromPrimitive::from_u32(config) {
                 Some(PlanarConfiguration::Chunky) => {},
-                config => return Err(TiffError::UnsupportedError(
-                    format!("Unsupported planar configuration “{:?}”.", config)
-                ))
+                config => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedPlanarConfig(config)))
             }
         }
         // Safe since the uninitialized values are never read.