Clean up api

src/encoder/writer.rs

@@ -1,48 +1,51 @@
 use std::io::{self, Write, Seek, SeekFrom};
-use byteorder::{WriteBytesExt, BigEndian, LittleEndian};
+use byteorder::{ByteOrder, WriteBytesExt, BigEndian, LittleEndian, NativeEndian};
+use crate::error::TiffResult;
 
-/// Byte order of the TIFF file.
-#[derive(Clone, Copy, Debug)]
-pub enum ByteOrder {
-    /// little endian byte order
-    LittleEndian,
-    /// big endian byte order
-    BigEndian
+pub trait TiffByteOrder: ByteOrder {
+    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()>;
+}
+
+impl TiffByteOrder for LittleEndian {
+    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.writer.write_u16::<LittleEndian>(0x4949)?;
+        writer.writer.write_u16::<LittleEndian>(42)?;
+        writer.offset += 4;
+
+        Ok(())
+    }
+}
+
+impl TiffByteOrder for BigEndian {
+    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.writer.write_u16::<BigEndian>(0x4d4d)?;
+        writer.writer.write_u16::<BigEndian>(42)?;
+        writer.offset += 4;
+
+        Ok(())
+    }
 }
 
 pub struct TiffWriter<W> {
     writer: W,
-    byte_order: ByteOrder,
-    offset: u32,
+    offset: u64,
 }
 
 impl<W: Write> TiffWriter<W> {
-    pub fn new(writer: W, byte_order: ByteOrder) -> Self {
+    pub fn new(writer: W) -> Self {
         Self {
             writer,
-            byte_order,
             offset: 0,
         }
     }
-    pub fn new_le(writer: W) -> Self {
-        Self::new(writer, ByteOrder::LittleEndian)
-    }
 
-    pub fn new_be(writer: W) -> Self {
-        Self::new(writer, ByteOrder::BigEndian)
-    }
-
-    pub fn byte_order(&self) -> ByteOrder {
-        self.byte_order
-    }
-
-    pub fn offset(&self) -> u32 {
+    pub fn offset(&self) -> u64 {
         self.offset
     }
 
     pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), io::Error> {
         self.writer.write_all(bytes)?;
-        self.offset += bytes.len() as u32;
+        self.offset += bytes.len() as u64;
         Ok(())
     }
 
@@ -53,27 +56,26 @@ impl<W: Write> TiffWriter<W> {
     }
 
     pub fn write_u16(&mut self, n: u16) -> Result<(), io::Error> {
-        match self.byte_order {
-            ByteOrder::LittleEndian => self.writer.write_u16::<LittleEndian>(n),
-            ByteOrder::BigEndian => self.writer.write_u16::<BigEndian>(n),
-        }?;
-
+        self.writer.write_u16::<NativeEndian>(n)?;
         self.offset += 2;
 
         Ok(())
     }
 
     pub fn write_u32(&mut self, n: u32) -> Result<(), io::Error> {
-        match self.byte_order {
-            ByteOrder::LittleEndian => self.writer.write_u32::<LittleEndian>(n),
-            ByteOrder::BigEndian => self.writer.write_u32::<BigEndian>(n),
-        }?;
-        
+        self.writer.write_u32::<NativeEndian>(n)?;
         self.offset += 4;
 
         Ok(())
     }
 
+    pub fn write_u64(&mut self, n: u64) -> Result<(), io::Error> {
+        self.writer.write_u64::<NativeEndian>(n)?;
+        self.offset += 8;
+
+        Ok(())
+    }
+
     pub fn pad_word_boundary(&mut self) -> Result<(), io::Error> {
         while self.offset % 4 != 0 {
             self.writer.write_u8(0)?;
@@ -84,7 +86,7 @@ impl<W: Write> TiffWriter<W> {
 }
 
 impl<W: Seek> TiffWriter<W> {
-    pub fn too_offset(&mut self, offset: u32) -> Result<(), io::Error> {
+    pub fn goto_offset(&mut self, offset: u64) -> Result<(), io::Error> {
         self.offset = offset;
         self.writer.seek(SeekFrom::Start(offset as u64))?;
         Ok(())