start implementing header reading + accessor methods

Cargo.toml

@@ -4,3 +4,5 @@ version = "0.1.0"
 authors = ["lifning <lifning+git@pm.me>"]
 
 [dependencies]
+byteorder = "1"
+prs-rust = { path = "../prs-rust" }

src/lib.rs

@@ -0,0 +1,97 @@
+extern crate byteorder;
+extern crate prs_rust;
+
+use std::io::{Read, Seek};
+use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian, LittleEndian};
+use std::str;
+
+struct OneJod<R: Read + Seek> {
+    read_handle: R,
+    header: OneJodHead,
+}
+
+impl<R> OneJod<R>
+where
+    R: Read + Seek,
+{
+    fn from_archive(mut input: R) -> OneJod<R> {
+        let mut head = OneJodHead {
+            magic: [0; 16],
+            _unknown1: 0,
+            category: [0; 32],
+            file_count: 0,
+            reserved: [0; 128],
+        };
+        input.read_exact(&mut head.magic);
+        head._unknown1 = input.read_u32::<byteorder::LittleEndian>().unwrap();
+        input.read_exact(&mut head.category);
+        head.file_count = input.read_u32::<byteorder::LittleEndian>().unwrap();
+        input.read_exact(&mut head.reserved);
+        OneJod{
+            read_handle: input,
+            header: head,
+        }
+    }
+}
+
+struct OneJodHead {
+    magic: [u8; 16],
+    _unknown1: u32,
+    category: [u8; 32],
+    file_count: u32,
+    reserved: [u8; 128],
+}
+
+impl OneJodHead {
+    fn magic(&self) -> &[u8] { &self.magic }
+    fn magic_mut(&mut self) -> &mut [u8] { &mut self.magic }
+
+    fn _unknown1(&self) -> u32 { self._unknown1 }
+    fn set_unknown1(&mut self, n: u32) { self._unknown1 = n; }
+
+    // NB: may not really be utf8?  should probably be ascii, though...
+    fn category(&self) -> &str { str::from_utf8(&self.category).unwrap() }
+    fn category_mut(&mut self) -> &mut str { str::from_utf8_mut(&mut self.category).unwrap() }
+    fn set_category(&mut self, n: &str) { self.category.copy_from_slice(n.as_bytes()); }
+
+    fn file_count(&self) -> u32 { self.file_count }
+    fn set_file_count(&mut self, n: u32) { self.file_count = n; }
+
+    fn reserved(&self) -> &[u8] { &self.reserved }
+    fn reserved_mut(&mut self) -> &mut [u8] { &mut self.reserved }
+}
+
+struct OneJodEntry {
+    _unknown1: u32,
+    id: u32,
+    size_cmp: u32,
+    _unknown2: u32,
+    size_dec: u32,
+    id_again: u32,
+    offset: u32,
+    file_name: [u8; 188],
+}
+
+impl OneJodEntry {
+    fn _unknown1(&self) -> u32 { self._unknown1 }
+    fn set_unknown1(&mut self, n: u32) { self._unknown1 = n; }
+
+    fn id(&self) -> u32 { assert_eq!(self.id, self.id_again); self.id }
+    fn set_id(&mut self, n: u32) { self.id = n; self.id_again = n; }
+
+    fn size_cmp(&self) -> u32 { self.size_cmp }
+    fn set_size_cmp(&mut self, n: u32) { self.size_cmp = n; }
+
+    fn _unknown2(&self) -> u32 { self._unknown2 }
+    fn set_unknown2(&mut self, n: u32) { self._unknown2 = n; }
+
+    fn size_dec(&self) -> u32 { self.size_dec }
+    fn set_size_dec(&mut self, n: u32) { self.size_dec = n; }
+
+    fn offset(&self) -> u32 { self.offset }
+    fn set_offset(&mut self, n: u32) { self.offset = n; }
+
+    fn file_name(&self) -> &str { str::from_utf8(&self.file_name).unwrap() }
+    fn file_name_mut(&mut self) -> &mut str { str::from_utf8_mut(&mut self.file_name).unwrap() }
+    fn set_file_name(&mut self, n: &str) { self.file_name.copy_from_slice(n.as_bytes()); }
+}

src/main.rs

@@ -1,48 +0,0 @@
-use std::io::{Read, Seek};
-
-struct OneJod<R: Read + Seek> {
-    read_handle: R,
-    header: OneJodHead,
-}
-
-impl<R> OneJod<R>
-where
-    R: Read + Seek,
-{
-    fn honk() {
-        println!("honk");
-    }
-}
-
-struct OneJodHead {
-    magic: [u8; 16],
-    _unknown1: u32,
-    category: [u8; 32],
-    file_count: u32,
-    reserved: [u8; 128],
-}
-
-impl OneJodHead {
-    fn category(&self) -> &str { category }
-    fn category_mut(&mut self) -> &mut str { category }
-}
-
-struct OneJodEntry {
-    _unknown1: u32,
-    id: u32,
-    size_cmp: u32,
-    _unknown2: u32,
-    size_dec: u32,
-    id_again: u32,
-    offset: u32,
-    file_name: [u8; 188],
-}
-
-impl OneJodEntry {
-    fn asdf() { }
-}
-
-fn main() {
-    let x = String::from("56");
-    println!("Hello, world! {}", x);
-}