examples added.

Author: dapper91

Cargo.toml

@@ -33,3 +33,11 @@ memory-limit = ["deepsize"]
 [[example]]
 name = "quickstart"
 required-features = ["bytesize", "env_logger"]
+
+[[example]]
+name = "custom_serializer"
+required-features = ["env_logger"]
+
+[[example]]
+name = "custom_type"
+required-features = ["env_logger"]

examples/custom_serializer.rs

@@ -0,0 +1,77 @@
+use std::fs;
+use std::fs::File;
+use std::io::{self, prelude::*, BufReader, BufWriter, Take};
+use std::path;
+
+use env_logger;
+use log;
+
+use ext_sort::{ExternalChunk, ExternalSorter, ExternalSorterBuilder, LimitedBufferBuilder};
+
+struct CustomExternalChunk {
+    reader: io::Take<io::BufReader<fs::File>>,
+}
+
+impl ExternalChunk<u32> for CustomExternalChunk {
+    type SerializationError = io::Error;
+    type DeserializationError = io::Error;
+
+    fn new(reader: Take<BufReader<File>>) -> Self {
+        CustomExternalChunk { reader }
+    }
+
+    fn dump(
+        chunk_writer: &mut BufWriter<File>,
+        items: impl IntoIterator<Item = u32>,
+    ) -> Result<(), Self::SerializationError> {
+        for item in items {
+            chunk_writer.write_all(&item.to_le_bytes())?;
+        }
+
+        return Ok(());
+    }
+}
+
+impl Iterator for CustomExternalChunk {
+    type Item = Result<u32, io::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.reader.limit() == 0 {
+            None
+        } else {
+            let mut buf: [u8; 4] = [0; 4];
+            match self.reader.read_exact(&mut buf.as_mut_slice()) {
+                Ok(_) => Some(Ok(u32::from_le_bytes(buf))),
+                Err(err) => Some(Err(err)),
+            }
+        }
+    }
+}
+
+fn main() {
+    env_logger::Builder::new().filter_level(log::LevelFilter::Debug).init();
+
+    let input_reader = io::BufReader::new(fs::File::open("input.txt").unwrap());
+    let mut output_writer = io::BufWriter::new(fs::File::create("output.txt").unwrap());
+
+    let sorter: ExternalSorter<u32, io::Error, LimitedBufferBuilder, CustomExternalChunk> =
+        ExternalSorterBuilder::new()
+            .with_tmp_dir(path::Path::new("./"))
+            .with_buffer(LimitedBufferBuilder::new(1_000_000, true))
+            .build()
+            .unwrap();
+
+    let sorted = sorter
+        .sort(input_reader.lines().map(|line| {
+            let line = line.unwrap();
+            let number = line.parse().unwrap();
+
+            return Ok(number);
+        }))
+        .unwrap();
+
+    for item in sorted.map(Result::unwrap) {
+        output_writer.write_all(format!("{}\n", item).as_bytes()).unwrap();
+    }
+    output_writer.flush().unwrap();
+}

examples/custom_type.rs

@@ -0,0 +1,100 @@
+use std::cmp::Ordering;
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+use std::fs;
+use std::io::{self, prelude::*};
+use std::path;
+
+use env_logger;
+use log;
+use serde;
+
+use ext_sort::{ExternalSorter, ExternalSorterBuilder, LimitedBufferBuilder};
+
+#[derive(Debug)]
+enum CsvParseError {
+    RowError(String),
+    ColumnError(String),
+}
+
+impl Display for CsvParseError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CsvParseError::ColumnError(err) => write!(f, "column format error: {}", err),
+            CsvParseError::RowError(err) => write!(f, "row format error: {}", err),
+        }
+    }
+}
+
+impl Error for CsvParseError {}
+
+#[derive(PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+struct Person {
+    name: String,
+    surname: String,
+    age: u8,
+}
+
+impl Person {
+    fn as_csv(&self) -> String {
+        format!("{},{},{}", self.name, self.surname, self.age)
+    }
+
+    fn from_str(s: &str) -> Result<Self, CsvParseError> {
+        let parts: Vec<&str> = s.split(',').collect();
+        if parts.len() != 3 {
+            Err(CsvParseError::RowError("wrong columns number".to_string()))
+        } else {
+            Ok(Person {
+                name: parts[0].to_string(),
+                surname: parts[1].to_string(),
+                age: parts[2]
+                    .parse()
+                    .map_err(|err| CsvParseError::ColumnError(format!("age field format error: {}", err)))?,
+            })
+        }
+    }
+}
+
+impl PartialOrd for Person {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(&other))
+    }
+}
+
+impl Ord for Person {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.surname
+            .cmp(&other.surname)
+            .then(self.name.cmp(&other.name))
+            .then(self.age.cmp(&other.age))
+    }
+}
+
+fn main() {
+    env_logger::Builder::new().filter_level(log::LevelFilter::Debug).init();
+
+    let input_reader = io::BufReader::new(fs::File::open("input.csv").unwrap());
+    let mut output_writer = io::BufWriter::new(fs::File::create("output.csv").unwrap());
+
+    let sorter: ExternalSorter<Person, io::Error, LimitedBufferBuilder> = ExternalSorterBuilder::new()
+        .with_tmp_dir(path::Path::new("./"))
+        .with_buffer(LimitedBufferBuilder::new(1_000_000, true))
+        .build()
+        .unwrap();
+
+    let sorted = sorter
+        .sort(
+            input_reader
+                .lines()
+                .map(|line| line.map(|line| Person::from_str(&line).unwrap())),
+        )
+        .unwrap();
+
+    for item in sorted.map(Result::unwrap) {
+        output_writer
+            .write_all(format!("{}\n", item.as_csv()).as_bytes())
+            .unwrap();
+    }
+    output_writer.flush().unwrap();
+}