use std::fs::File;
use std::vec::Vec;
use std::io::Read;
use memmap::Mmap;
fn consume_str(buf: &[u8]) -> (String, usize) {
let nulp = buf.iter().position(|x| *x == 0u8).unwrap();
let s = String::from_utf8_lossy(&buf[..nulp]);
(s.to_string(), nulp)
}
#[derive(Debug)]
pub enum MediaInstance {
Image {thmb: String, orig: String},
Video
}
impl MediaInstance {
fn consume(buf: &[u8]) -> (MediaInstance, usize) {
match buf[0] as char {
'I' => {
let b = &buf[1..];
let (thmb, p1) = consume_str(b);
let b = &b[p1 + 1..];
let (orig, p2) = consume_str(b);
(MediaInstance::Image{thmb, orig}, p1 + p2 + 3)
},
'V' => {
(MediaInstance::Video, 1)
}
_ => panic!("Invalid media type")
}
}
}
#[derive(Debug)]
pub struct Post {
pub content: String,
pub date: i64,
pub media: Vec<MediaInstance>,
pub tags: Vec<String>
}
pub fn test_print_post(p: &Post) {
println!("{}", p.content);
println!("{}", p.date);
for m in &p.media {
match m {
MediaInstance::Image{thmb, orig} => println!("Image {} {}", thmb, orig),
MediaInstance::Video => println!("Video")
}
}
for t in &p.tags {
println!("{}", t);
}
}
impl Post {
fn consume(buf: &[u8]) -> (Post, usize) {
let (content, p) = consume_str(buf);
let mut l = p + 1;
let b = &buf[p + 1..];
let date = i64::from_le_bytes(b[..8].try_into().unwrap());
l += 8;
let b = &b[8..];
let mut media = vec![];
let mut tags = vec![];
let nmedia = b[0];
let mut b = &b[1..];
l += 1;
for _ in 0..nmedia {
let (m, ml) = MediaInstance::consume(b);
media.push(m);
b = &b[ml..];
l += ml;
}
let ntags = b[0];
let mut b = &b[1..];
l += 1;
for _ in 0..ntags {
let (t, p) = consume_str(b);
tags.push(t);
b = &b[p + 1..];
l+= p + 1;
}
(Post{content, date, media, tags}, l)
}
}
pub struct Monolith {
filen: String,
idxfn: String,
pdxfn: String,
post_ranges: Vec<(i64, usize, usize)>,
}
impl Monolith {
pub fn new(filen: String) -> Monolith {
let idxfn = filen.clone() + ".idx";
let pdxfn = filen.clone() + ".pdx";
Monolith {
filen,
idxfn,
pdxfn,
post_ranges: vec![]
}
}
pub fn load_index(&mut self) {
let mut f = File::open(&self.idxfn).unwrap();
let mut last_r: u64 = 0;
self.post_ranges.clear();
loop {
let mut buf: [u8; 16] = [0; 16];
match f.read_exact(&mut buf) {
Ok(_) => (),
Err(e) => match e.kind() {
std::io::ErrorKind::UnexpectedEof => break,
_ => panic!("unexpected error {}", e)
}
}
let t = i64::from_le_bytes(buf[..8].try_into().unwrap());
let l = last_r;
let r = u64::from_le_bytes(buf[8..].try_into().unwrap());
self.post_ranges.push((t, l as usize, r as usize));
last_r = r;
}
}
fn find_post(&self, date: i64) -> Option<(usize, usize)> {
if let Ok(p) = self.post_ranges.binary_search_by(|p| p.0.cmp(&date)) {
let (_, l, r) = self.post_ranges[p];
Some((l, r))
} else { None }
}
fn find_post_2(&self, date: i64) -> Option<(usize, usize)> {
let f = File::open(&self.idxfn).unwrap();
let map = unsafe { Mmap::map(&f) }.unwrap();
let len = map.len();
let nposts = len / 16;
let mut l = 0;
let mut r = nposts;
let mut s = r;
let mut postidx = None;
while l < r {
let m = l + s / 2;
let b = &map[m * 16..];
let cdate = i64::from_le_bytes(b[..8].try_into().unwrap());
l = if cdate < date { m + 1 } else { l };
r = if cdate > date { m } else { r };
s = r - l;
if cdate == date {
postidx = Some(m);
break;
}
}
if let Some(postidx) = postidx {
let b = &map[postidx * 16 + 8..];
let r = u64::from_le_bytes(b[..8].try_into().unwrap());
let l = if postidx == 0 {
0
} else {
let b = &map[postidx * 16 - 8..];
u64::from_le_bytes(b[..8].try_into().unwrap())
};
Some((l as usize, r as usize))
} else { None }
}
fn get_page_range(&self, page: usize) -> Option<(usize, usize)> {
let f = File::open(&self.pdxfn).unwrap();
let map = unsafe { Mmap::map(&f) }.unwrap();
let len = map.len();
let npages = len / 8;
if page >= npages {
return None;
}
let b = &map[page * 8..];
let r = u64::from_le_bytes(b[..8].try_into().unwrap());
let l = if page == npages - 1 {
0
} else {
let b = &map[(page + 1) * 8..];
u64::from_le_bytes(b[..8].try_into().unwrap())
};
Some((l as usize, r as usize))
}
fn get_posts_in_range(&self, l: usize, r: usize) -> Vec<Post> {
let f = File::open(&self.filen).unwrap();
let map = unsafe { Mmap::map(&f) }.unwrap();
let mut remaining = &map[l..r];
let mut ret = vec![];
loop {
if remaining.len() == 0 {
break;
}
let (post, len) = Post::consume(remaining);
ret.push(post);
remaining = &remaining[len + 1..];
}
ret
}
pub fn get_all_dates(&self) -> Vec<i64> {
self.post_ranges.iter().map(|x| x.0).collect()
}
pub fn get_post(&self, date: i64) -> Option<Post> {
if let Some((l, r)) = self.find_post(date) {
let f = File::open(&self.filen).unwrap();
let map = unsafe { Mmap::map(&f) }.unwrap();
Some(Post::consume(&map[l..r]).0)
} else { None }
}
pub fn get_post_2(&self, date: i64) -> Option<Post> {
if let Some((l, r)) = self.find_post_2(date) {
let f = File::open(&self.filen).unwrap();
let map = unsafe { Mmap::map(&f) }.unwrap();
Some(Post::consume(&map[l..r]).0)
} else { None }
}
pub fn get_page_posts(&self, page: usize) -> Option<Vec<Post>> {
if let Some((l, r)) = self.get_page_range(page) {
Some(self.get_posts_in_range(l, r))
} else {
None
}
}
pub fn get_page_count(&self) -> usize {
let m = std::fs::metadata(&self.pdxfn).unwrap();
(m.len() / 8) as usize
}
}
