objstr 0.1.1

File stream abstraction for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::{fs::{File, OpenOptions}, io::{Error, ErrorKind, SeekFrom}, path::Path};

use crate::api::ObjStr;

use super::helpers::{cut, inner_len, jump_stream_end, jump_stream_start, len_calc, read, seek_backward_n, seek_forward, seek_forward_n, truncate, write, write_empty_byte};

pub struct FileObjStr {
    file: File
}

impl FileObjStr {
    pub fn new(path: &Path) -> Result<FileObjStr, Error> {
        let mut file: File;

        if path.exists() {
            file = OpenOptions::new()
                .read(true)
                .write(true)
                .open(path)?;
        } else {
            file = OpenOptions::new()
                .read(true)
                .write(true)
                .create(true)
                .open(path)?;
            truncate(&mut file);
        }     

        Ok(
            FileObjStr {
                file
            }
        )
    }
}

impl ObjStr for FileObjStr {

    fn seek(&mut self, pos: SeekFrom) -> Result<(), Error> {
        
        match pos {
            SeekFrom::Start(pos) => {
                jump_stream_start(&mut self.file);
                seek_forward_n(&mut self.file, pos)?;
            },
            SeekFrom::End(pos) => {
                jump_stream_end(&mut self.file);
                seek_backward_n(&mut self.file, pos.abs() as u64)?;
            },
            SeekFrom::Current(pos) => {
                let pos_abs = pos.abs() as u64;
                if pos < 0 {
                    seek_backward_n(&mut self.file, pos_abs)?;
                } else if pos > 0 {
                    seek_forward_n(&mut self.file, pos_abs)?;
                }
            }
        }

        Ok(())

    }

    fn read(&mut self) -> Result<Vec<u8>, Error> {
        Ok(read(&mut self.file)?)
    }

    fn len(&mut self, contents: u8, objs: u8) -> Result<u64, Error> {

        let mut inner_lens = Vec::new();

        for _ in 0..objs {
            inner_lens.push(
                inner_len(&mut self.file)?
            );
            seek_forward(&mut self.file)?;
        }

        seek_backward_n(&mut self.file, objs as u64)?;

        let len = len_calc(inner_lens, contents);

        if len < 0 {
            return Err(Error::new(ErrorKind::Other, "To small to fit that many objects"));
        }
        
        Ok(len.abs() as u64)
    }

    fn overwrite(&mut self, data: Vec<Vec<u8>>, objs: u8) -> Result<(), Error> {
        if data.len() > u8::MAX as usize {
            return Err(Error::new(ErrorKind::Other, "To many objects"));
        }

        let inner_len = self.len(data.len() as u8, objs)?;
        let actual_len = data.iter().fold(0, |acc, x| acc + x.len()) as u64;

        if inner_len != actual_len {
            return Err(Error::new(ErrorKind::Other, "Wrong length"));
        }

        for d in data {
            write(&mut self.file, d)?;
        }

        Ok(())
    }

    fn append(&mut self, data: Vec<u8>) -> Result<(), Error> {
        jump_stream_end(&mut self.file);
        write(&mut self.file, data)?;
        write_empty_byte(&mut self.file);
        Ok(())
    }

    fn cut(&mut self) -> Result<(), Error> {
        cut(&mut self.file);
        Ok(())
    }
}