diff options
Diffstat (limited to 'benoit-cli/src/config')
| -rw-r--r-- | benoit-cli/src/config/config/load.rs | 50 | ||||
| -rw-r--r-- | benoit-cli/src/config/config/load_from.rs | 89 | ||||
| -rw-r--r-- | benoit-cli/src/config/config/mod.rs | 124 | ||||
| -rw-r--r-- | benoit-cli/src/config/config/print_help.rs | 45 | ||||
| -rw-r--r-- | benoit-cli/src/config/field/mod.rs | 68 | ||||
| -rw-r--r-- | benoit-cli/src/config/mod.rs | 31 | ||||
| -rw-r--r-- | benoit-cli/src/config/section/mod.rs | 86 | ||||
| -rw-r--r-- | benoit-cli/src/config/take/mod.rs | 282 |
8 files changed, 775 insertions, 0 deletions
diff --git a/benoit-cli/src/config/config/load.rs b/benoit-cli/src/config/config/load.rs new file mode 100644 index 0000000..8ac0165 --- /dev/null +++ b/benoit-cli/src/config/config/load.rs @@ -0,0 +1,50 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in the hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +use crate::config::Config; +use crate::error::Error; + +use std::env::args; + +impl Config { + /// Loads the configuration file as specified on the command line. + /// + /// # Errors + /// + /// Returns an error depending on the command line arguments and validity of the configuration file. + pub fn load() -> Result<Self, Error> { + let mut args = args().skip(0x1); + + let Some(config_path) = args.next() else { + return Err(Error::MissingConfigPath); + }; + + if args.next().is_some() { return Err(Error::TooManyCliArguments) }; + + let config = Self::load_from(config_path)?; + config.validate()?; + + Ok(config) + } +} diff --git a/benoit-cli/src/config/config/load_from.rs b/benoit-cli/src/config/config/load_from.rs new file mode 100644 index 0000000..61ae5cd --- /dev/null +++ b/benoit-cli/src/config/config/load_from.rs @@ -0,0 +1,89 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in (the) hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +use crate::config::{Config, Section, Take}; +use crate::error::Error; +use crate::keyframe::Keyframe; + +use std::path::Path; + +macro_rules! take_field { + ($name:ident in ($section:expr)) => {{ + $section.get_child(stringify!($name)).take()? + }}; + + ($name:ident in ($section:expr) str) => {{ + $section.get_child(stringify!($name)).take_from_str()?? + }}; +} + +impl Config { + /// Loads the configuration file at `path`. + /// + /// # Errors + /// + /// If the configuration file could not be read or parsed, an error message is returned. + pub fn load_from<P: AsRef<Path>>(path: P) -> Result<Self, Error> { + let root_section = Section::create_root(path)?; + + let render_section: Section = root_section.get_child("render").take()?; + let final_section: Section = root_section.get_child("final").take()?; + let output_section: Section = root_section.get_child("output").take()?; + + let render_start_section: Section = render_section.get_child("start").take()?; + let render_stop_section: Section = render_section.get_child("stop").take()?; + + let render_width = take_field!(width in (render_section)); + let render_height = take_field!(height in (render_section)); + + Ok(Self { + frame_count: take_field!(count in (render_section)), + render_size: (render_width, render_height), + fractal: take_field!(fractal in (render_section) str), + inverse: take_field!(inverse in (render_section)), + julia: take_field!(julia in (render_section)), + + start: Keyframe { + frame: take_field!(frame in (render_start_section)), + max_iter_count: take_field!(max_iter_count in (render_start_section)), + centre: take_field!(centre in (render_start_section)), + seed: take_field!(seed in (render_start_section)), + zoom: take_field!(zoom in (render_start_section)), + colour_range: take_field!(colour_range in (render_start_section)), + }, + stop: Keyframe { + frame: take_field!(frame in (render_stop_section)), + max_iter_count: take_field!(max_iter_count in (render_stop_section)), + centre: take_field!(centre in (render_stop_section)), + seed: take_field!(seed in (render_stop_section)), + zoom: take_field!(zoom in (render_stop_section)), + colour_range: take_field!(colour_range in (render_stop_section)), + }, + + palette: take_field!(palette in (final_section) str), + + output_directory: take_field!(directory in (output_section)), + }) + } +} diff --git a/benoit-cli/src/config/config/mod.rs b/benoit-cli/src/config/config/mod.rs new file mode 100644 index 0000000..e10c25e --- /dev/null +++ b/benoit-cli/src/config/config/mod.rs @@ -0,0 +1,124 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in the hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +mod load; +mod load_from; +mod print_help; + +use crate::error::Error; +use crate::keyframe::Keyframe; + +use benoit::fractal::Fractal; +use benoit::palette::Palette; +use std::path::PathBuf; + +/// For configuring animations. +/// +/// A configuration can be loaded from a file using [`load_from`](Config::load_from). +/// +/// An example of a configuration is the following: +/// +/// ```toml +/// # This renders a single frame. +/// +/// [render] +/// count = 1 +/// width = 1024 +/// height = 1024 +/// +/// fractal = "mandelbrot" # multibrot2 +/// inverse = false +/// julia = false +/// +/// [render.start] +/// frame = 0 +/// +/// max_iter_count = 0x100 +/// +/// centre = "0.0+0.0i" +/// seed = "0.0+0.0i" +/// zoom = "1.0" +/// +/// colour_range = 64.0 +/// +/// [render.stop] +/// frame = 0 +/// +/// max_iter_count = 0x100 +/// +/// centre = "0.0+0.0i" +/// seed = "0.0+0.0i" +/// zoom = "1.0" +/// +/// colour_range = 64.0 +/// +/// [final] +/// palette = "fire" +/// +/// [output] +/// directory = "render/" +/// ``` +#[derive(Clone, Debug)] +pub struct Config { + pub frame_count: u32, + pub render_size: (u32, u32), + pub fractal: Fractal, + pub inverse: bool, + pub julia: bool, + + pub start: Keyframe, + pub stop: Keyframe, + + pub palette: Palette, + + pub output_directory: PathBuf, +} + +impl Config { + /// Tries to validate `self`. + /// + /// # Errors + /// + /// If any configuration field couldn't be validated, an `Err` object is returned. + pub fn validate(&self) -> Result<(), Error> { + self.start.validate()?; + self.stop.validate()?; + + if self.start.frame > self.stop.frame { + Err( + Error::InvalidConfig { + message: format!("start frame ({}) cannot be after stop frame ({})", self.start.frame, self.stop.frame), + }, + ) + } else if self.stop.frame >= self.frame_count { + Err( + Error::InvalidConfig { + message: format!("stop frame ({}) cannot be after last frame ({})", self.stop.frame, self.frame_count - 0x1), + }, + ) + } else { + Ok(()) + } + } +} diff --git a/benoit-cli/src/config/config/print_help.rs b/benoit-cli/src/config/config/print_help.rs new file mode 100644 index 0000000..b16d6f8 --- /dev/null +++ b/benoit-cli/src/config/config/print_help.rs @@ -0,0 +1,45 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in the hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +use crate::config::Config; + +use benoit::VERSION; +use std::process::exit; + +impl Config { + /// Prints help to `stdout`. + /// + /// This function marks the end of execution and does therefore not return. + pub fn print_help() -> ! { + println!("Benoit {}.{}.{}", VERSION.0, VERSION.1, VERSION.2); + println!(); + println!("Usage:"); + println!(" benoit <path>"); + println!(); + println!("Wherein <path> denotes the path to the configuration file."); + println!(); + + exit(0x0); + } +} diff --git a/benoit-cli/src/config/field/mod.rs b/benoit-cli/src/config/field/mod.rs new file mode 100644 index 0000000..489dc7a --- /dev/null +++ b/benoit-cli/src/config/field/mod.rs @@ -0,0 +1,68 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in the hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +use crate::error::Error; + +use std::str::FromStr; +use toml::Value; + +/// Denotes a configuration field. +/// +/// By default, these fields are typeless. +/// They can, however, be "transformed" to a given type using the [`Take`](crate::config::Take) trait. +pub struct Field<'a> { + pub(in super) name: String, + pub(in super) value: Option<&'a Value>, +} + +impl<'a> Field<'a> { + /// Borows the contained value. + /// + /// The returned reference is still considered "typeless," as is defined by `toml`'s own [`Value`] type. + /// + /// # Errors + /// + /// Returns an error if the field could not be found. + pub(in super) fn borrow_value(&mut self) -> Result<&'a Value, Error> { + self.value + .take() + .ok_or_else(|| Error::MissingConfigField { name: self.name.clone() }) + } +} + +impl Field<'_> { + /// Transforms the field into the given type `T`. + /// The result of [`FromStr`] implementation is passed on. + /// + /// # Errors + /// + /// Returns an error if the field doesn't exist, or is a different type, or if the [`FromStr`] implementation failed. + pub fn take_from_str<T: FromStr>(mut self) -> Result<Result<T, <T as FromStr>::Err>, Error> { + let Value::String(ref s) = *self.borrow_value()? else { + return Err(Error::WrongFieldType { name: self.name, ok_type: "string" }) + }; + + Ok(FromStr::from_str(s)) + } +} diff --git a/benoit-cli/src/config/mod.rs b/benoit-cli/src/config/mod.rs new file mode 100644 index 0000000..aeba3b4 --- /dev/null +++ b/benoit-cli/src/config/mod.rs @@ -0,0 +1,31 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in the hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +//! Animation configuration. + +use crate::use_mod; +use_mod!(pub, config); +use_mod!(pub, field); +use_mod!(pub, section); +use_mod!(pub, take); diff --git a/benoit-cli/src/config/section/mod.rs b/benoit-cli/src/config/section/mod.rs new file mode 100644 index 0000000..59d716a --- /dev/null +++ b/benoit-cli/src/config/section/mod.rs @@ -0,0 +1,86 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in the hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +use crate::config::Field; +use crate::error::Error; + +use std::borrow::Cow; +use std::fs::read_to_string; +use std::path::Path; +use std::str::FromStr; +use toml::Table; + +/// Denotes a configuration section. +pub struct Section<'a> { + pub(in super) name: Option<String>, + pub(in super) table: Cow<'a, Table>, +} + +impl<'a> Section<'a> { + /// Creates a new root section. + /// + /// This is done by parsing the configuration file at `path`. + /// + /// # Errors + /// + /// Returns an error if unable to read and parse the configuration file. + pub fn create_root<P: AsRef<Path>>(path: P) -> Result<Self, Error> { + let path = path.as_ref(); + + let config = read_to_string(path) + .map_err(|e| Error::ConfigReadFailure { path: path.to_owned(), source: e })?; + + let table = Table::from_str(&config) + .map_err(|e| Error::ConfigParseFailure { path: path.to_owned(), source: e })?; + + Ok(Self { + name: None, + table: Cow::Owned(table) + }) + } + + /// Searches the section's table for children. + /// + /// The returned child will reference its parent section. + /// + /// The child isn't guaranteed to exist, and in the event that it does, is typeless. + /// See the [`Field`] type for more information. + #[must_use] + pub fn get_child(&'a self, name: &str) -> Field<'a> { + let value = self.table.get(name); + + let name = self.name + .as_ref() + .map_or_else( + || name.to_owned(), + + |parent| format!("{parent}.{name}"), + ); + + Field { + name, + value, + } + } +} diff --git a/benoit-cli/src/config/take/mod.rs b/benoit-cli/src/config/take/mod.rs new file mode 100644 index 0000000..4580e5b --- /dev/null +++ b/benoit-cli/src/config/take/mod.rs @@ -0,0 +1,282 @@ +/* + Copyright 2021, 2023-2024 Gabriel Bjørnager Jen- + sen. + + This file is part of benoit-cli. + + benoit-cli is free software: you can redistrib- + ute it and/or modify it under the terms of the + GNU General Public License as published by the + Free Software Foundation, either version 3 of + the License, or (at your option) any later ver- + sion. + + benoit-cli is distributed in the hope that it + will be useful, but WITHOUT ANY WARRANTY; with- + out even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Gene- + ral Public License along with benoit-cli. If + not, see <https://www.gnu.org/licenses/>. +*/ + +use crate::config::{Field, Section}; +use crate::error::Error; + +use benoit::PRECISION; +use benoit::complex::Complex; +use rug::Float; +use std::borrow::Cow; +use std::fs::canonicalize; +use std::path::PathBuf; +use std::str::FromStr; +use toml::Value; + +/// Used for loading configuration fields. +/// +/// More specifically, this is to be used with the untyped [`Field`] type, where using [`take`](Take::take) collapses the field into a definitively typed object. +pub trait Take<T> { + /// Collapses the field into the given type `T`. + /// + /// # Errors + /// + /// Returns an error if the field doesn't exist or is a different type. + + fn take(self) -> Result<T, Error>; +} + +fn test_field_domain<T, U>(name: &str, value: &T, min: U, max: U) -> Result<(), Error> +where + T: PartialOrd + ToString, + U: Copy + Into<T> + ToString, { + if *value < min.into() { + Err(Error::FieldLowerBounds { + name: name.to_owned(), + value: value.to_string(), + limit: min.to_string(), + }) + } else if *value > max.into() { + Err(Error::FieldUpperBounds { + name: name.to_owned(), + value: value.to_string(), + limit: max.to_string(), + }) + } else { + Ok(()) + } +} + +impl Take<bool> for Field<'_> { + fn take(mut self) -> Result<bool, Error> { + let Value::Boolean(value) = *self.borrow_value()? else { + return Err(Error::WrongFieldType { name: self.name, ok_type: "bool" }); + }; + + Ok(value) + } +} + +impl Take<Complex> for Field<'_> { + fn take(mut self) -> Result<Complex, Error> { + let s = if let Value::String(ref s) = *self.borrow_value()? { + Ok(s) + } else { + Err(Error::WrongFieldType { name: self.name, ok_type: "complex" }) + }?; + + FromStr::from_str(s).map_err(Into::into) + } +} + +impl Take<f32> for Field<'_> { + fn take(mut self) -> Result<f32, Error> { + if let Value::Float(value) = *self.borrow_value()? { + // Is this even possible? + if value.is_nan() { + return Err(Error::NonNumberField { name: self.name }); + } + + if value.is_infinite() { + return Err(Error::InfiniteField { name: self.name }); + } + + test_field_domain(&self.name, &value, -f32::MAX, f32::MAX)?; + + Ok(value as f32) + } else { + Err(Error::WrongFieldType { name: self.name, ok_type: "float" }) + } + } +} + +impl Take<f64> for Field<'_> { + fn take(mut self) -> Result<f64, Error> { + if let Value::Float(value) = *self.borrow_value()? { + // Is this even possible? + if value.is_nan() { + return Err(Error::NonNumberField { name: self.name }); + } + + if value.is_infinite() { + return Err(Error::InfiniteField { name: self.name }); + } + + Ok(value) + } else { + Err(Error::WrongFieldType { name: self.name, ok_type: "float" }) + } + } +} + +impl Take<Float> for Field<'_> { + fn take(mut self) -> Result<Float, Error> { + if let Value::String(ref value) = *self.borrow_value()? { + if let Ok(value) = Float::parse(value) { + return Ok(Float::with_val(PRECISION, value)); + } + } + + Err(Error::WrongFieldType { name: self.name, ok_type: "bigfloat" }) + } +} + +impl Take<i16> for Field<'_> { + fn take(mut self) -> Result<i16, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + test_field_domain(&self.name, &value, i16::MIN, i16::MAX)?; + + return Ok(TryFrom::try_from(value).unwrap()); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} + +impl Take<i32> for Field<'_> { + fn take(mut self) -> Result<i32, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + test_field_domain(&self.name, &value, i32::MIN, i32::MAX)?; + + return Ok(TryFrom::try_from(value).unwrap()); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} + +impl Take<i64> for Field<'_> { + fn take(mut self) -> Result<i64, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + return Ok(value); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} + +impl Take<i8> for Field<'_> { + fn take(mut self) -> Result<i8, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + test_field_domain(&self.name, &value, i8::MIN, i8::MAX)?; + + return Ok(TryFrom::try_from(value).unwrap()); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} + +impl Take<PathBuf> for Field<'_> { + fn take(self) -> Result<PathBuf, Error> { + let s = <Self as Take<String>>::take(self)?; + + canonicalize(&s).map_err(|e| Error::InvalidPath { path: s, source: e }) + } +} + +impl<'a> Take<Section<'a>> for Field<'a> { + fn take(mut self) -> Result<Section<'a>, Error> { + if let Value::Table(ref table) = *self.borrow_value()? { + return Ok(Section { + name: Some(self.name), + table: Cow::Borrowed(table), + }); + } + + Err(Error::WrongFieldType { name: self.name, ok_type: "section" }) + } +} + +impl Take<String> for Field<'_> { + fn take(mut self) -> Result<String, Error> { + if let Value::String(ref s) = *self.borrow_value()? { + Ok(s.to_owned()) + } else { + Err(Error::WrongFieldType { name: self.name, ok_type: "string" }) + } + } +} + +impl Take<u16> for Field<'_> { + fn take(mut self) -> Result<u16, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + if value.is_negative() { + return Err(Error::NegativeField { name: self.name }); + } + + test_field_domain(&self.name, &value, u16::MIN, u16::MAX)?; + + return Ok(TryFrom::try_from(value).unwrap()); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} + +impl Take<u32> for Field<'_> { + fn take(mut self) -> Result<u32, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + if value.is_negative() { + return Err(Error::NegativeField { name: self.name }); + } + + test_field_domain(&self.name, &value, u32::MIN, u32::MAX)?; + + return Ok(TryFrom::try_from(value).unwrap()); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} + +impl Take<u64> for Field<'_> { + fn take(mut self) -> Result<u64, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + if value.is_negative() { + return Err(Error::NegativeField { name: self.name }) + } + + return Ok(TryFrom::try_from(value).unwrap()); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} + +impl Take<u8> for Field<'_> { + fn take(mut self) -> Result<u8, Error> { + if let Value::Integer(value) = *self.borrow_value()? { + if value.is_negative() { + return Err(Error::NegativeField { name: self.name }); + } + + test_field_domain(&self.name, &value, u8::MIN, u8::MAX)?; + + return Ok(TryFrom::try_from(value).unwrap()); + }; + + Err(Error::WrongFieldType { name: self.name, ok_type: "integer" }) + } +} |