reset

1 files changed, 0 insertions, 176 deletions

diff --git a/snapshot/src/storage.rs b/snapshot/src/storage.rs
deleted file mode 100644
index c445d04..0000000
--- a/snapshot/src/storage.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-use format;
-use snap::Builder;
-use snap::Delta;
-use snap::Snap;
-use snap;
-use std::collections::VecDeque;
-use warn::Warn;
-use warn::wrap;
-
-// TODO: Separate server storage from client storage.
-// TODO: Delete snapshots over time.
-
-#[derive(Clone)]
-struct StoredSnap {
-    snap: Snap,
-    tick: i32,
-}
-
-const MAX_STORED_SNAPSHOT: usize = 100;
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct UnknownSnap;
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct WeirdNegativeDeltaTick;
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum Error {
-    OldDelta,
-    UnknownSnap,
-    InvalidCrc,
-    Unpack(snap::Error),
-}
-
-impl From<snap::Error> for Error {
-    fn from(err: snap::Error) -> Error {
-        Error::Unpack(err)
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum Warning {
-    WeirdNegativeDeltaTick,
-    Unpack(format::Warning),
-}
-
-impl From<format::Warning> for Warning {
-    fn from(w: format::Warning) -> Warning {
-        Warning::Unpack(w)
-    }
-}
-
-#[derive(Clone, Default)]
-pub struct Storage {
-    /// Queue that stores received snaps.
-    ///
-    /// The newest elements are in the front.
-    snaps: VecDeque<StoredSnap>,
-    free: Vec<Snap>,
-    ack_tick: Option<i32>,
-    delta: Delta,
-    delta_tick: Option<i32>,
-}
-
-impl Storage {
-    pub fn new() -> Storage {
-        Default::default()
-    }
-    pub fn reset(&mut self) {
-        let self_free = &mut self.free;
-        // FIXME: Replace with something like `exhaust`.
-        self.snaps.drain(..).map(|s| self_free.push(s.snap)).count();
-        self.ack_tick = None;
-    }
-    pub fn ack_tick(&self) -> Option<i32> {
-        self.ack_tick
-    }
-    pub fn add_delta<W>(&mut self, warn: &mut W, crc: Option<i32>, delta_tick: i32, tick: i32, delta: &Delta)
-        -> Result<&Snap, Error>
-        where W: Warn<Warning>,
-    {
-        if self.snaps.front().map(|s| s.tick).unwrap_or(-1) >= tick {
-            return Err(Error::OldDelta);
-        }
-        {
-            let empty = Snap::empty();
-            let delta_snap;
-            if delta_tick >= 0 {
-                if let Some(i) = self.snaps.iter().position(|s| s.tick < delta_tick) {
-                    let self_free = &mut self.free;
-                    // FIXME: Replace with something like `exhaust`.
-                    self.snaps.drain(i..).map(|s| self_free.push(s.snap)).count();
-                }
-                if let Some(d) = self.snaps.back() {
-                    if d.tick == delta_tick {
-                        delta_snap = &d.snap;
-                    } else {
-                        self.ack_tick = None;
-                        return Err(Error::UnknownSnap);
-                    }
-                } else {
-                    self.ack_tick = None;
-                    return Err(Error::UnknownSnap);
-                }
-            } else {
-                delta_snap = &empty;
-                if delta_tick != -1 {
-                    warn.warn(Warning::WeirdNegativeDeltaTick);
-                }
-            }
-            if self.free.is_empty() {
-                self.free.push(Snap::empty());
-            }
-
-            let new_snap: &mut Snap = self.free.last_mut().unwrap();
-            new_snap.read_with_delta(wrap(warn), delta_snap, delta)?;
-            if crc.map(|crc| crc != new_snap.crc()).unwrap_or(false) {
-                self.ack_tick = None;
-                return Err(Error::InvalidCrc);
-            }
-            self.ack_tick = Some(tick);
-        }
-        self.snaps.push_front(StoredSnap {
-            tick: tick,
-            snap: self.free.pop().unwrap(),
-        });
-        if self.snaps.len() > MAX_STORED_SNAPSHOT {
-            self.free.push(self.snaps.pop_back().unwrap().snap);
-        }
-        Ok(&self.snaps.front().unwrap().snap)
-    }
-    pub fn new_builder(&mut self) -> Builder {
-        self.free.pop().unwrap_or_default().recycle()
-    }
-    pub fn set_delta_tick<W>(&mut self, warn: &mut W, tick: i32)
-        -> Result<(), UnknownSnap>
-        where W: Warn<WeirdNegativeDeltaTick>,
-    {
-        if tick < 0 {
-            if tick != -1 {
-                warn.warn(WeirdNegativeDeltaTick);
-            }
-            self.delta_tick = None;
-            return Ok(());
-        }
-        if let Some(i) = self.snaps.iter().position(|s| s.tick < tick) {
-            let self_free = &mut self.free;
-            // FIXME: Replace with something like `exhaust`.
-            self.snaps.drain(i..).map(|s| self_free.push(s.snap)).count();
-        }
-        if !self.snaps.back().map(|s| s.tick == tick).unwrap_or(false) {
-            self.delta_tick = None;
-            return Err(UnknownSnap);
-        }
-        self.delta_tick = Some(tick);
-        Ok(())
-    }
-    pub fn delta_tick(&self) -> Option<i32> {
-        self.delta_tick
-    }
-    pub fn add_snap(&mut self, tick: i32, snap: Snap) -> &Delta {
-        self.snaps.push_front(StoredSnap {
-            snap: snap,
-            tick: tick,
-        });
-        let tmp;
-        let delta_snap = if self.delta_tick.is_some() {
-            &self.snaps.back().unwrap().snap
-        } else {
-            tmp = Snap::empty();
-            &tmp
-        };
-        self.delta.create(delta_snap, &self.snaps.front().unwrap().snap);
-        &self.delta
-    }
-}