#[macro_use]
extern crate nom;
#[macro_use]
pub mod basic;
pub mod model;
pub mod parser;
pub mod writer;
use std::io;
use std::path::Path;
pub use buffer::call_numeric_buffer_fn;
pub type IOBuffer = buffer::DataBuffer;
#[derive(Debug)]
pub enum Error {
IO(io::Error),
Write(writer::Error),
Parse(nom::ErrorKind<u32>),
Unknown,
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Error::IO(source) => write!(f, "IO error: {:?}", source),
Error::Write(source) => write!(f, "Write error: {:?}", source),
Error::Parse(source) => write!(f, "Parse error: {:?}", source),
Error::Unknown => write!(f, "Unknown error"),
}
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Error::IO(source) => Some(source),
Error::Write(_) => None, Error::Parse(_) => None,
Error::Unknown => None,
}
}
}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Error {
Error::IO(e)
}
}
impl From<Error> for io::Error {
fn from(err: Error) -> io::Error {
match err {
Error::IO(e) => e,
_ => io::Error::new(io::ErrorKind::Other, format!("{:?}", err)),
}
}
}
impl From<writer::Error> for Error {
fn from(e: writer::Error) -> Error {
Error::Write(e)
}
}
fn import_impl<F>(file_path: &Path, parse: F) -> Result<model::Vtk, Error>
where
F: Fn(&[u8]) -> nom::IResult<&[u8], model::Vtk>,
{
use crate::io::Read;
use nom::IResult;
use std::fs::File;
let mut file = File::open(file_path)?;
let mut buf = Vec::new();
file.read_to_end(&mut buf)?;
match parse(&buf) {
IResult::Done(_, vtk) => Ok(vtk),
IResult::Error(e) => Err(Error::Parse(e.into_error_kind())),
IResult::Incomplete(_) => Err(Error::Unknown),
}
}
pub fn import(file_path: &Path) -> Result<model::Vtk, Error> {
import_impl(file_path, parser::parse)
}
pub fn import_le(file_path: &Path) -> Result<model::Vtk, Error> {
import_impl(file_path, parser::parse_le)
}
pub fn import_be(file_path: &Path) -> Result<model::Vtk, Error> {
import_impl(file_path, parser::parse_be)
}
pub fn export(data: model::Vtk, file_path: &Path) -> Result<(), Error> {
use crate::io::Write;
use crate::writer::WriteVtk;
let mut file = ::std::fs::File::create(file_path)?;
file.write_all(Vec::<u8>::new().write_vtk(data)?.as_slice())?;
Ok(())
}
pub fn export_le(data: model::Vtk, file_path: &Path) -> Result<(), Error> {
use crate::io::Write;
use crate::writer::WriteVtk;
let mut file = ::std::fs::File::create(file_path)?;
file.write_all(Vec::<u8>::new().write_vtk_le(data)?.as_slice())?;
Ok(())
}
pub fn export_be(data: model::Vtk, file_path: &Path) -> Result<(), Error> {
use crate::io::Write;
use crate::writer::WriteVtk;
let mut file = ::std::fs::File::create(file_path)?;
file.write_all(Vec::<u8>::new().write_vtk_be(data)?.as_slice())?;
Ok(())
}
pub fn export_ascii(data: model::Vtk, file_path: &Path) -> Result<(), Error> {
use crate::io::Write;
use crate::writer::WriteVtk;
use std::fs::File;
let mut out_str = String::new();
out_str.write_vtk(data)?;
{
let mut file = File::create(file_path)?;
file.write_all(out_str.as_bytes())?;
}
Ok(())
}