file_api 0.1.0

Library to abstract read. Based on prefix URL, it select the adapted reader (HTTP or local file system).
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


use std::fs::File;
use std::io::SeekFrom;

use file_system;
use http;

#[derive(Debug)]
pub enum ReaderKind {
  Http,
  FileSystem
}

#[derive(Debug)]
pub struct Reader {
  pub filename: String,
  pub mode: ReaderKind,
  pub file: Option<File>,
  pub http_reader: Option<http::HttpReader>,
  pub cache_size: Option<usize>
}

fn detect_kind(filename: &String) -> ReaderKind {
  if filename.starts_with("http://") ||
     filename.starts_with("https://") {
    return ReaderKind::Http;
  }
  return ReaderKind::FileSystem;
}

pub fn exists(filename: &String) -> bool {
  match detect_kind(&filename) {
    ReaderKind::Http => http::exists(&filename),
    ReaderKind::FileSystem => file_system::exists(&filename)
  }
}

pub fn open(filename: String) -> Result<Reader, String> {
  match detect_kind(&filename) {
    ReaderKind::Http => http::open(&filename),
    ReaderKind::FileSystem => file_system::open(&filename)
  }
}

impl Reader {
  pub fn get_type(&self) -> ReaderKind {
    match self.mode {
      ReaderKind::Http => ReaderKind::Http,
      ReaderKind::FileSystem => ReaderKind::FileSystem
    }
  }

  pub fn get_cache_size(&self) -> Option<usize> {
    self.cache_size
  }

  pub fn set_cache_size(&mut self, cache_size: Option<usize>) {
    self.cache_size = cache_size;
  }

  pub fn read(&mut self, size: usize) -> Result<Vec<u8>, String> {
    match self.mode {
      ReaderKind::Http => http::read(self, size),
      ReaderKind::FileSystem => file_system::read(self, size)
    }
  }

  pub fn get_position(&self) -> Result<u64, String> {
    match self.mode {
      ReaderKind::Http => http::get_position(self),
      ReaderKind::FileSystem => file_system::get_position(self)
    }
  }

  pub fn get_size(&mut self) -> Result<u64, String> {
    match self.mode {
      ReaderKind::Http => http::get_size(self),
      ReaderKind::FileSystem => file_system::get_size(self)
    }
  }

  pub fn seek(&mut self, seek: SeekFrom) -> Result<u64, String> {
    match self.mode {
      ReaderKind::Http => http::seek(self, seek),
      ReaderKind::FileSystem => file_system::seek(self, seek)
    }
  }
}