smlm_hawk_core/io/version_1/

mod.rs

use crate::config::{Config as CoreConfig, 
					Threading as CoreThreading, 
					Memory as CoreMemory, 
					RunStyle as CoreRunStyle,
					NegativeHandling as CoreNegativeHandling,
					OutputStyle as CoreOutputStyle,
					AlgorithmConfig as CoreAlgorithm,
					Validation as CoreValidation};

use serde_json;

use std::fmt::{Display, Formatter, Error as FmtError};

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub enum OutputStyle 
{
	Sequential,
	Interleaved,
}

impl From<CoreOutputStyle> for OutputStyle
{
	fn from(os: CoreOutputStyle) -> OutputStyle
	{
		match os
		{
			CoreOutputStyle::Sequential => Self::Sequential,
			CoreOutputStyle::Interleaved => Self::Interleaved
		}
	}
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum NegativeHandling 
{
	Absolute,
	Separate,
}

impl From<CoreNegativeHandling> for NegativeHandling
{
	fn from(nh: CoreNegativeHandling) -> Self
	{
		match nh
		{
			CoreNegativeHandling::Absolute => Self::Absolute,
			CoreNegativeHandling::Separate => Self::Separate
		}
	}
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct AlgorithmConfig 
{
	n_levels: u64,
	output_style: OutputStyle,
	negative_handling : NegativeHandling
}

impl AlgorithmConfig
{
	pub fn to_algorithm(&self) -> CoreAlgorithm
	{

		CoreAlgorithm::new(self.n_levels, self.to_core_style(), self.to_core_negative_handling())
	}

	fn to_core_style(&self) -> CoreOutputStyle
	{
		match self.output_style
		{
			OutputStyle::Sequential => CoreOutputStyle::Sequential,
			OutputStyle::Interleaved => CoreOutputStyle::Interleaved
		}
	}

	fn to_core_negative_handling(&self) -> CoreNegativeHandling
	{
		match self.negative_handling
		{
			NegativeHandling::Absolute => CoreNegativeHandling::Absolute,
			NegativeHandling::Separate => CoreNegativeHandling::Separate
		}
	}
}

impl From<&CoreAlgorithm> for AlgorithmConfig
{
	fn from(config: &CoreAlgorithm) -> Self
	{
		Self
		{
			n_levels: config.n_levels(),
			output_style : OutputStyle::from(config.output_style()),
			negative_handling: NegativeHandling::from(config.negative_handling())
		}
	}
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum RunStyle 
{
	InMemory,
	Stream,
	PStream,
}

impl RunStyle
{
	pub fn to_runstyle(&self) -> CoreRunStyle
	{
		match self
		{
			Self::InMemory => CoreRunStyle::InMemory,
			Self::Stream => CoreRunStyle::Stream,
			Self::PStream => CoreRunStyle::PStream
		}
	}
}

impl From<&CoreRunStyle> for RunStyle
{
	fn from(run_style: &CoreRunStyle) -> Self 
	{ 
		match run_style 
		{
			CoreRunStyle::InMemory => Self::InMemory,
			CoreRunStyle::Stream => Self::Stream,
			CoreRunStyle::PStream => Self::PStream
		}
	}
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum Memory 
{
	Fragmented,
	Contiguous,
}

impl Memory
{
	pub fn to_memory(&self) -> CoreMemory
	{
		match self
		{
			Self::Fragmented => CoreMemory::Fragmented,
			Self::Contiguous => CoreMemory::Contiguous
		}
	}
}

impl From<&CoreMemory> for Memory
{
	fn from(memory: &CoreMemory) -> Self
	{
		match memory
		{
			CoreMemory::Fragmented => Self::Fragmented,
			CoreMemory::Contiguous => Self::Contiguous
		}
	}
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum Threading 
{
	Parallel,
	Series,
}

impl Threading
{
	pub fn to_threading(&self) -> CoreThreading
	{
		match self
		{
			Self::Parallel => CoreThreading::parallel(),
			Self::Series => CoreThreading::series()
		}
	}
}

impl From<&CoreThreading> for Threading
{
	fn from(threading: &CoreThreading) -> Self
	{
		if threading.is_parallel() {Threading::Parallel} else{Threading::Series}
	}
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Validation 
{
	LimitOutputsToUnder32Bits(bool),
}

impl Validation
{
	fn to_validation(&self) -> CoreValidation
	{
		match self
		{
			Self::LimitOutputsToUnder32Bits(value) => CoreValidation::LimitOutputsToUnder32Bits(*value)
		}
	}
}

impl From<&CoreValidation> for Validation
{
	fn from(validation: &CoreValidation) -> Self
	{
		let value = validation.limit_to_under_32();
		Validation::LimitOutputsToUnder32Bits(value)
	}
}


#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Config 
{
	threading: Threading,
	memory: Memory,
	run_style: RunStyle,
	algorithm: AlgorithmConfig,
	validation: Option<Validation>
}

impl Config
{
	fn new(threading: Threading, memory: Memory, run_style: RunStyle, algorithm_config: AlgorithmConfig, validation: Option<Validation>) -> Self
	{
		Self{threading, memory, run_style, algorithm: algorithm_config, validation}
	}

	pub fn to_config(&self) -> CoreConfig
	{
		CoreConfig::new(
			self.threading.to_threading(),
			self.memory.to_memory(),
			self.run_style.to_runstyle(),
			self.algorithm.to_algorithm(),
			self.validation.as_ref().map(|v| v.to_validation())
		)
	}

	pub fn to_json(&self) -> String
	{
		match serde_json::to_string(self)
		{
			Ok(s) => s,
			Err(e) => e.to_string()
		}
	}
}

impl From<&CoreConfig> for Config
{
	fn from(config: &CoreConfig) -> Self
	{
		Self::new(
			Threading::from(config.threading()),
			Memory::from(config.memory()),
			RunStyle::from(config.run_style()),
			AlgorithmConfig::from(config.algorithm_config()),
			config.validation().map(Validation::from)
			)
	}
}

impl Display for Config
{
	fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError>
	{
		write!(f, "{}", self.to_json())
	}
}

#[cfg(test)]
mod tests 
{
	use super::*;

	const EXPECTED : &str = "{\"threading\":\"Parallel\",\"memory\":\"Contiguous\",\"run_style\":\"InMemory\",\"algorithm\":{\"n_levels\":3,\"output_style\":\"Sequential\",\"negative_handling\":\"Absolute\"},\"validation\":null}";
	
	#[test]
	fn to_string_test()
	{
		let config = CoreConfig::default();
		assert_eq!(Config::from(&config).to_string(), EXPECTED)
	}

	#[test]
	fn validation_string_test()
	{
		let validation = CoreValidation::LimitOutputsToUnder32Bits(true);
		let config = CoreConfig::new(CoreThreading::default(), CoreMemory::default(), CoreRunStyle::default(), CoreAlgorithm::default(), Some(validation));
		let expected = "{\"threading\":\"Parallel\",\"memory\":\"Contiguous\",\"run_style\":\"InMemory\",\"algorithm\":{\"n_levels\":3,\"output_style\":\"Sequential\",\"negative_handling\":\"Absolute\"},\"validation\":{\"LimitOutputsToUnder32Bits\":true}}";
		assert_eq!(Config::from(&config).to_string(), expected)
	}

	#[test]
	fn from_str_test()
	{
		let config = serde_json::from_str::<Config>(EXPECTED).unwrap();
		let expected = Config::from(&CoreConfig::default());
		assert_eq!(config, expected);
	}
}