chore: Remove useless `Fst` prefixes

src/bin/raptor-cli.rs

@@ -12,7 +12,7 @@ use std::io::{BufReader, BufRead};
 
 use serde_json::from_str;
 
-use raptor::{FstMapBuilder, FstMap};
+use raptor::{MapBuilder, Map};
 
 #[derive(Debug, Deserialize)]
 struct Product {
@@ -41,7 +41,7 @@ fn main() {
         set
     };
 
-    let mut builder = FstMapBuilder::new();
+    let mut builder = MapBuilder::new();
     for line in data.lines() {
         let line = line.unwrap();
 
@@ -65,5 +65,5 @@ fn main() {
     let (map, values) = builder.build(map, values).unwrap();
 
     eprintln!("Checking the dump consistency...");
-    unsafe { FstMap::<u64>::from_paths("map.fst", "values.vecs").unwrap() };
+    unsafe { Map::<u64>::from_paths("map.fst", "values.vecs").unwrap() };
 }

src/bin/raptor.rs

@@ -8,10 +8,7 @@ extern crate tokio_proto;
 extern crate tokio_service;
 extern crate url;
 
-use std::io;
-use std::path::Path;
-use std::fs::{self, File};
-use std::io::{Read, BufReader};
+use std::{io, fs};
 
 use fst::Streamer;
 use futures::future;
@@ -20,15 +17,15 @@ use tokio_minihttp::{Request, Response, Http};
 use tokio_proto::TcpServer;
 use tokio_service::Service;
 
-use raptor::{FstMap, OpWithStateBuilder};
+use raptor::{Map, OpWithStateBuilder};
 
-static mut MAP: Option<FstMap<u64>> = None;
+static mut MAP: Option<Map<u64>> = None;
 static mut LEV_BUILDER_0: Option<LevBuilder> = None;
 static mut LEV_BUILDER_1: Option<LevBuilder> = None;
 static mut LEV_BUILDER_2: Option<LevBuilder> = None;
 
 struct MainService<'a> {
-    map: &'a FstMap<u64>,
+    map: &'a Map<u64>,
     lev_builder_0: &'a LevBuilder,
     lev_builder_1: &'a LevBuilder,
     lev_builder_2: &'a LevBuilder,
@@ -109,7 +106,7 @@ fn main() {
             let map = fs::read("map.fst").unwrap();
             let values = fs::read("values.vecs").unwrap();
 
-            Some(FstMap::from_bytes(map, &values).unwrap())
+            Some(Map::from_bytes(map, &values).unwrap())
         };
         LEV_BUILDER_0 = Some(LevBuilder::new(0, false));
         LEV_BUILDER_1 = Some(LevBuilder::new(1, false));

src/lib.rs

@@ -3,16 +3,15 @@ extern crate bincode;
 extern crate fst;
 extern crate serde;
 
-mod fst_map;
+mod map;
 
 use fst::Automaton;
 
-pub use self::fst_map::{FstMap, FstMapBuilder};
-pub use self::fst_map::{
+pub use self::map::{Map, MapBuilder, Values};
+pub use self::map::{
     OpBuilder, IndexedValues,
     OpWithStateBuilder, IndexedValuesWithState,
 };
-use self::fst_map::Values;
 
 pub struct StreamBuilder<'m, 'v, T: 'v, A> {
     inner: fst::map::StreamBuilder<'m, A>,

src/map.rs

@@ -9,12 +9,12 @@ use std::path::Path;
 use {StreamBuilder, Stream};
 
 #[derive(Debug)]
-pub struct FstMap<T> {
+pub struct Map<T> {
     inner: fst::Map,
     values: Values<T>,
 }
 
-impl<T> FstMap<T> {
+impl<T> Map<T> {
     pub unsafe fn from_paths<P, Q>(map: P, values: Q) -> fst::Result<Self>
     where
         T: DeserializeOwned,
@@ -63,11 +63,6 @@ impl<T> FstMap<T> {
         }
     }
 
-    pub fn op(&self) -> OpBuilder<T> {
-        // OpBuilder::new(&self.values).add(self.as_inner())
-        unimplemented!()
-    }
-
     pub fn as_map(&self) -> &fst::Map {
         &self.inner
     }
@@ -114,14 +109,14 @@ impl<T> Values<T> {
 }
 
 #[derive(Debug)]
-pub struct FstMapBuilder<T> {
+pub struct MapBuilder<T> {
     map: Vec<(String, u64)>,
     // This makes many memory indirections but it is only used
     // at index time, not kept for query time.
     values: Vec<Vec<T>>,
 }
 
-impl<T> FstMapBuilder<T> {
+impl<T> MapBuilder<T> {
     pub fn new() -> Self {
         Self {
             map: Vec::new(),
@@ -148,8 +143,8 @@ impl<T> FstMapBuilder<T> {
         }
     }
 
-    pub fn build_memory(self) -> fst::Result<FstMap<T>> {
-        Ok(FstMap {
+    pub fn build_in_memory(self) -> fst::Result<Map<T>> {
+        Ok(Map {
             inner: fst::Map::from_iter(self.map)?,
             values: Values::new(self.values),
         })