Mercator/mercator_parser
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: Mercator:2566cac17fd55e69a5df3776bdb0aebb723fee4a
Branches Tags
Mercator:master Mercator:lts Mercator:gh-pages
...
compare: Mercator:master
Branches Tags
Mercator:master Mercator:lts Mercator:gh-pages

2 Commits
2566cac17f ... master

Author SHA1 Message Date
Lionel Sambuc
521f40e36e Fixed most tests 2024-08-11 14:34:45 +02:00
Lionel Sambuc
c14c6cb91a Updated compiler and dependencies 
* Upgraded to rustc 1.80
 * Updated dependencies
 * Fixed most linter warnings
 2024-08-11 08:15:20 +02:00
10 changed files with 248 additions and 264 deletions
Expand all files Collapse all files

9
Cargo.toml
View File

@@ -37,15 +37,16 @@ bin = ["measure_time", "pretty_env_logger"]
[dependencies] [dependencies]
mercator_db = "0.1" mercator_db = "0.1"
lalrpop-util = "0.19.0"
lalrpop-util = "0.20"
# Logging macros API # Logging macros API
#log = { version = "0.4", features = ["max_level_trace", "release_max_level_info"] } #log = { version = "0.4", features = ["max_level_trace", "release_max_level_info"] }
log = { version = "0.4", features = ["max_level_trace", "release_max_level_trace"] } log = { version = "0.4", features = ["max_level_trace", "release_max_level_trace"] }
# Used for main.rs # Used for main.rs
pretty_env_logger = { version = "0.3", optional = true } # Logger implementation pretty_env_logger = { version = "0.5", optional = true } # Logger implementation
measure_time = { version = "0.6", optional = true } # To mesure parsing time, only required by binary measure_time = { version = "0.8", optional = true } # To mesure parsing time, only required by binary
[build-dependencies] [build-dependencies]
lalrpop = { version = "0.19.0", features = ["lexer"] } lalrpop = "0.20"

2
rust-toolchain.toml Normal file
View File

@@ -0,0 +1,2 @@
[toolchain]
channel = "1.80.0"

9
src/executors.rs
View File

@@ -260,8 +260,7 @@ impl Shape {
let (space_id, inside) = match self { let (space_id, inside) = match self {
Shape::Point(space_id, position) => { Shape::Point(space_id, position) => {
let position: Vec<f64> = position.into(); let position: Vec<f64> = position.into();
let mut positions = Vec::with_capacity(1); let positions = vec![position.into()];
positions.push(position.into());
let inside = core.get_by_positions(parameters, positions, space_id)?; let inside = core.get_by_positions(parameters, positions, space_id)?;
Ok((space_id, inside)) Ok((space_id, inside))
@@ -275,7 +274,7 @@ impl Shape {
// Smallest increment possible // Smallest increment possible
let mut increment = Vec::with_capacity(bounding_box[0].dimensions()); let mut increment = Vec::with_capacity(bounding_box[0].dimensions());
for _ in 0..bounding_box[0].dimensions() { for _ in 0..bounding_box[0].dimensions() {
increment.push(std::f64::EPSILON); increment.push(f64::EPSILON);
} }
// Add it to the lower bound // Add it to the lower bound
@@ -294,7 +293,7 @@ impl Shape {
Shape::HyperSphere(space_id, center, radius) => { Shape::HyperSphere(space_id, center, radius) => {
// Smallest decrement possible, to exclude the surface // Smallest decrement possible, to exclude the surface
let mut radius: f64 = radius.into(); let mut radius: f64 = radius.into();
radius -= std::f64::EPSILON; radius -= f64::EPSILON;
let center: space::Position = center.into(); let center: space::Position = center.into();
let inside = core.get_by_shape( let inside = core.get_by_shape(
@@ -353,7 +352,7 @@ impl<'e> Executor<'e> for Projection {
) -> Self::ResultSet { ) -> Self::ResultSet {
match self { match self {
Projection::Nifti(_, _, _bag) => Err("Proj-Nifti: not yet implemented".to_string()), Projection::Nifti(_, _, _bag) => Err("Proj-Nifti: not yet implemented".to_string()),
Projection::JSON(_, _format, bag) => { Projection::Json(_, _format, bag) => {
bag.execute(core_id, parameters) bag.execute(core_id, parameters)
// FIXME: Add projections here // FIXME: Add projections here
} }

14
src/lib.rs
View File

@@ -38,20 +38,20 @@ lalrpop_mod!(#[allow(clippy::all,unused_parens)] pub queries); // synthesized by
// as well. // as well.
// Instead we enable it per modules below, except for the tests. // Instead we enable it per modules below, except for the tests.
#[warn(missing_docs)] //#[warn(missing_docs)]
mod evaluators; mod evaluators;
#[warn(missing_docs)] //#[warn(missing_docs)]
mod executors; mod executors;
#[warn(missing_docs)] //#[warn(missing_docs)]
mod expressions; mod expressions;
#[warn(missing_docs)] //#[warn(missing_docs)]
mod predictors; mod predictors;
#[warn(missing_docs)] //#[warn(missing_docs)]
mod validators; mod validators;
#[warn(missing_docs)] //#[warn(missing_docs)]
mod symbols; mod symbols;
#[warn(missing_docs)] //#[warn(missing_docs)]
mod types; mod types;
pub use expressions::Executor; pub use expressions::Executor;

2
src/predictors.rs
View File

@@ -7,7 +7,7 @@ impl Predictor for Projection {
fn predict(&self, db: &DataBase) -> Result<f64, String> { fn predict(&self, db: &DataBase) -> Result<f64, String> {
match self { match self {
Projection::Nifti(_, _, bag) => bag.predict(db), Projection::Nifti(_, _, bag) => bag.predict(db),
Projection::JSON(_, _, bag) => bag.predict(db), Projection::Json(_, _, bag) => bag.predict(db),
} }
} }
} }

2
src/queries.lalrpop
View File

@@ -51,7 +51,7 @@ JsonOperator: symbols::Projection = {
None => Space::universe().name().clone(), None => Space::universe().name().clone(),
}; };
symbols::Projection::JSON(space_id, f, b) symbols::Projection::Json(space_id, f, b)
} }
}; };

14
src/symbols.rs
View File

@@ -11,14 +11,14 @@ pub use super::types::*;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum Projection { pub enum Projection {
Nifti(String, LiteralSelector, Bag), Nifti(String, LiteralSelector, Bag),
JSON(String, JsonValue, Bag), Json(String, JsonValue, Bag),
} }
impl Projection { impl Projection {
pub fn space(&self) -> &String { pub fn space(&self) -> &String {
match self { match self {
Projection::Nifti(space, _, _) => &space, Projection::Nifti(space, _, _) => space,
Projection::JSON(space, _, _) => &space, Projection::Json(space, _, _) => space,
} }
} }
} }
@@ -138,7 +138,7 @@ impl Shape {
pub fn volume(&self) -> f64 { pub fn volume(&self) -> f64 {
match self { match self {
Shape::Point(_, _) => std::f64::EPSILON, // The smallest non-zero volume possible Shape::Point(_, _) => f64::EPSILON, // The smallest non-zero volume possible
Shape::HyperRectangle(_space, pos) => { Shape::HyperRectangle(_space, pos) => {
//TODO: At this time, only aligned to the axes, defined by two points, hyperrectangles are supported. //TODO: At this time, only aligned to the axes, defined by two points, hyperrectangles are supported.
assert_eq!(pos.len(), 2); assert_eq!(pos.len(), 2);
@@ -202,7 +202,7 @@ impl Shape {
} }
Shape::Label(_, _) => { Shape::Label(_, _) => {
// FIXME: Needs to find a way to figure out the approximate volume of this specific ID, or return MAX or MIN.. // FIXME: Needs to find a way to figure out the approximate volume of this specific ID, or return MAX or MIN..
std::f64::EPSILON f64::EPSILON
} }
Shape::Nifti(_) => unimplemented!("Nifti"), Shape::Nifti(_) => unimplemented!("Nifti"),
} }
@@ -238,9 +238,7 @@ impl Position {
Ordering::Less => -1, Ordering::Less => -1,
}; };
let mut v = Vec::with_capacity(1); let v = vec![LiteralNumber::Int(x)];
v.push(LiteralNumber::Int(x));
LiteralPosition(v) LiteralPosition(v)
} }
} }

432
src/tests.rs
View File

@@ -16,7 +16,7 @@ mod parsing {
fn query() { fn query() {
let p = query_parser(); let p = query_parser();
let nifti = "nifti(point{[0]})"; let nifti = "nifti(inside(point{[0]}))";
// Option is Empty // Option is Empty
assert!(p.parse("").is_ok()); assert!(p.parse("").is_ok());
@@ -47,14 +47,14 @@ mod parsing {
let p = query_parser(); let p = query_parser();
// Check allowed forms of the operator // Check allowed forms of the operator
assert!(p.parse("nifti(point{[0]})").is_ok()); assert!(p.parse("nifti(inside(point{[0]}))").is_ok());
assert!(p.parse("nifti(.properties.id, point{[0]})").is_ok()); assert!(p.parse("nifti(.properties.id, inside(point{[0]}))").is_ok());
unimplemented!(); // TO REMEMBER SOME WORK IS DUE HERE. unimplemented!(); // TO REMEMBER SOME WORK IS DUE HERE.
//FIXME: THIS SHOULD BE ALLOWED //FIXME: THIS SHOULD BE ALLOWED
assert!(p.parse("nifti(2, point{[0]})").is_ok()); assert!(p.parse("nifti(2, inside(point{[0]}))").is_ok());
assert!(p.parse("nifti(2.23, point{[0]})").is_ok()); assert!(p.parse("nifti(2.23, inside(point{[0]}))").is_ok());
//FIXME: SYNTAX OK, TYPE NOT //FIXME: SYNTAX OK, TYPE NOT
assert!(p.parse("nifti(point{[0], \"space\"})").is_err()); assert!(p.parse("nifti(point{[0], \"space\"})").is_err());
@@ -64,16 +64,16 @@ mod parsing {
fn json_operator() { fn json_operator() {
let p = query_parser(); let p = query_parser();
assert!(p.parse("json(true, point{[0]})").is_ok()); assert!(p.parse("json(true, inside(point{[0]}))").is_ok());
assert!(p.parse("json(23, point{[0]})").is_ok()); assert!(p.parse("json(23, inside(point{[0]}))").is_ok());
assert!(p.parse("json([23, 24], point{[0]})").is_ok()); assert!(p.parse("json([23, 24], inside(point{[0]}))").is_ok());
assert!(p.parse("json([23, count(.)], point{[0]})").is_ok()); assert!(p.parse("json([23, count(.)], inside(point{[0]}))").is_ok());
assert!(p.parse("json(true)").is_err()); assert!(p.parse("json(true)").is_err());
assert!(p.parse("json(true,)").is_err()); assert!(p.parse("json(true,)").is_err());
assert!(p.parse("json(, point{[0]})").is_err()); assert!(p.parse("json(, inside(point{[0]}))").is_err());
assert!(p.parse("json(point{[0]})").is_err()); assert!(p.parse("json(inside(point{[0]}))").is_err());
assert!(p.parse("json(true, point)").is_err()); assert!(p.parse("json(true, point)").is_err());
} }
@@ -83,24 +83,24 @@ mod parsing {
let p = query_parser(); let p = query_parser();
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "true").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "true").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "false").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "false").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "null").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "null").as_str())
.is_ok()); .is_ok());
// Incorrect capitalisation // Incorrect capitalisation
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "True").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "True").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "False").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "False").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "Null").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "Null").as_str())
.is_err()); .is_err());
} }
@@ -109,24 +109,24 @@ mod parsing {
let p = query_parser(); let p = query_parser();
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{}").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"field\": 0}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"field\": 0}").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"field\": 0, \"field1\": 1}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"field\": 0, \"field1\": 1}").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"field\": [0, 1]}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"field\": [0, 1]}").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"field\": {\"field1\": 0}}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"field\": {\"field1\": 0}}").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse( .parse(
format!( format!(
"json({}, point{{[0]}})", "json({}, inside(point{{[0]}}))",
"{\"field\": [{\"field1\": 0}, {\"field1\": 1}]}" "{\"field\": [{\"field1\": 0}, {\"field1\": 1}]}"
) )
.as_str() .as_str()
@@ -139,25 +139,25 @@ mod parsing {
let p = query_parser(); let p = query_parser();
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{:}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{:}").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{field: 0}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{field: 0}").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{0: 0}").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{0: 0}").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"0\": }").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"0\": }").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"0\": 0 }").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"0\": 0 }").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"field\": 0 }").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"field\": 0 }").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "{\"field\": \"0\" }").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "{\"field\": \"0\" }").as_str())
.is_ok()); .is_ok());
} }
@@ -166,20 +166,20 @@ mod parsing {
let p = query_parser(); let p = query_parser();
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "[, 0]").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "[, 0]").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "[]").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "[]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "[0]").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "[0]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "[0, 1]").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "[0, 1]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse( .parse(
format!("json({}, point{{[0]}})", "[{\"field\": 0}, {\"field\": 1}]").as_str() format!("json({}, inside(point{{[0]}}))", "[{\"field\": 0}, {\"field\": 1}]").as_str()
) )
.is_ok()); .is_ok());
} }
@@ -190,40 +190,40 @@ mod parsing {
// count () // count ()
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "count()").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "count()").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "count(distinct)").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "count(distinct)").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "count(.)").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "count(.)").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "count(distinct .)").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "count(distinct .)").as_str())
.is_ok()); .is_ok());
// sum () // sum ()
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "sum()").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "sum()").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "sum(.)").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "sum(.)").as_str())
.is_ok()); .is_ok());
// min () // min ()
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "min()").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "min()").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "min(.)").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "min(.)").as_str())
.is_ok()); .is_ok());
// max () // max ()
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "max()").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "max()").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "max(.)").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "max(.)").as_str())
.is_ok()); .is_ok());
} }
@@ -233,42 +233,42 @@ mod parsing {
// Integers // Integers
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "0").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "+0").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "+0").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "-0").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "-0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "1").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "1").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "+1").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "+1").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "-1").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "-1").as_str())
.is_ok()); .is_ok());
// Floating point values // Floating point values
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "0.0").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "0.0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "+0.0").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "+0.0").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "-0.0").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "-0.0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "0.1").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "0.1").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "+0.01").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "+0.01").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("json({}, point{{[0]}})", "-0.01").as_str()) .parse(format!("json({}, inside(point{{[0]}}))", "-0.01").as_str())
.is_ok()); .is_ok());
} }
} }
@@ -290,7 +290,7 @@ mod parsing {
assert!(p.parse("").is_err()); assert!(p.parse("").is_err());
assert!(p.parse("point{[0]}").is_ok()); assert!(p.parse("inside(point{[0]})").is_ok());
} }
/* Not useful to test this rule /* Not useful to test this rule
@@ -305,7 +305,7 @@ mod parsing {
assert!(p.parse("distinct()").is_err()); assert!(p.parse("distinct()").is_err());
assert!(p.parse("distinct(point{[0]})").is_ok()); assert!(p.parse("distinct(inside(point{[0]}))").is_ok());
} }
#[test] #[test]
@@ -314,7 +314,7 @@ mod parsing {
assert!(p.parse("complement()").is_err()); assert!(p.parse("complement()").is_err());
assert!(p.parse("complement(point{[0]})").is_ok()); assert!(p.parse("complement(inside(point{[0]}))").is_ok());
} }
#[test] #[test]
@@ -322,12 +322,12 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p.parse("intersection()").is_err()); assert!(p.parse("intersection()").is_err());
assert!(p.parse("intersection(point{[0]})").is_err()); assert!(p.parse("intersection(inside(point{[0]}))").is_err());
assert!(p assert!(p
.parse("intersection(point{[0]}, point{[0]}, point{[0]})") .parse("intersection(inside(point{[0]}), inside(point{[0]}), inside(point{[0]}))")
.is_err()); .is_err());
assert!(p.parse("intersection(point{[0]}, point{[0]})").is_ok()); assert!(p.parse("intersection(inside(point{[0]}), inside(point{[0]}))").is_ok());
} }
#[test] #[test]
@@ -335,12 +335,12 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p.parse("union()").is_err()); assert!(p.parse("union()").is_err());
assert!(p.parse("union(point{[0]})").is_err()); assert!(p.parse("union(inside(point{[0]}))").is_err());
assert!(p assert!(p
.parse("union(point{[0]}, point{[0]}, point{[0]})") .parse("union(inside(point{[0]}), inside(point{[0]}), inside(point{[0]}))")
.is_err()); .is_err());
assert!(p.parse("union(point{[0]}, point{[0]})").is_ok()); assert!(p.parse("union(inside(point{[0]}), inside(point{[0]}))").is_ok());
} }
#[test] #[test]
@@ -348,10 +348,10 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p.parse("filter()").is_err()); assert!(p.parse("filter()").is_err());
assert!(p.parse("filter(point{[0]})").is_ok()); assert!(p.parse("filter(inside(point{[0]}))").is_ok());
assert!(p.parse("filter(=(., [0]))").is_ok()); assert!(p.parse("filter(=(., [0]))").is_ok());
assert!(p.parse("filter(=(., [0]), point{[0]})").is_ok()); assert!(p.parse("filter(=(., [0]), inside(point{[0]}))").is_ok());
} }
/* Not useful to test this rule /* Not useful to test this rule
@@ -365,17 +365,17 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "<(., [0])").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "<(., [0])").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "<(, [0])").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "<(, [0])").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "<(.)").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "<(.)").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "<()").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "<()").as_str())
.is_err()); .is_err());
} }
@@ -384,17 +384,17 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", ">(., [0])").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", ">(., [0])").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", ">(, [0])").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", ">(, [0])").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", ">(.)").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", ">(.)").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", ">()").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", ">()").as_str())
.is_err()); .is_err());
} }
@@ -403,17 +403,17 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "=(., [0])").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "=(., [0])").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "=(, [0])").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "=(, [0])").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "=(.)").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "=(.)").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "=()").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "=()").as_str())
.is_err()); .is_err());
} }
@@ -422,11 +422,11 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "!(=(., [0]))").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "!(=(., [0]))").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "!()").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "!()").as_str())
.is_err()); .is_err());
} }
@@ -435,17 +435,17 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "&(=(., [0]), =(., [0]))").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "&(=(., [0]), =(., [0]))").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "&(, =(., [0]))").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "&(, =(., [0]))").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "&(|(=(., [0])))").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "&(|(=(., [0])))").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "&()").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "&()").as_str())
.is_err()); .is_err());
} }
@@ -454,17 +454,17 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "|(=(., [0]), =(., [0]))").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "|(=(., [0]), =(., [0]))").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "|(, =(., [0]))").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "|(, =(., [0]))").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "|(|(=(., [0])))").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "|(|(=(., [0])))").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter({}, point{{[0]}})", "|()").as_str()) .parse(format!("filter({}, inside(point{{[0]}}))", "|()").as_str())
.is_err()); .is_err());
} }
@@ -474,11 +474,11 @@ mod parsing {
assert!(p.parse("bag{}").is_err()); assert!(p.parse("bag{}").is_err());
assert!(p.parse("bag{point{[0]}}").is_ok()); assert!(p.parse("bag{inside(point{[0]})}").is_ok());
assert!(p.parse("bag{point{[0]}, point{[0]}}").is_ok()); assert!(p.parse("bag{inside(point{[0]}), inside(point{[0]})}").is_ok());
assert!(p.parse("bag{point{[0]}, point{[0]}, point{[0]}}").is_ok()); assert!(p.parse("bag{inside(point{[0]}), inside(point{[0]}), inside(point{[0]})}").is_ok());
assert!(p assert!(p
.parse("bag{point{[0]}, hypersphere{[0], 1}, hyperrectangle{[0], [1]}}") .parse("bag{inside(point{[0]}), inside(hypersphere{[0], 1}), inside(hyperrectangle{[0], [1]})}")
.is_ok()); .is_ok());
} }
@@ -518,21 +518,21 @@ mod parsing {
// At least two positions when it is aligned with the axis, otherwise an even number // At least two positions when it is aligned with the axis, otherwise an even number
// of positions, as the number of vertices follows the rule 2**k, where k is the number // of positions, as the number of vertices follows the rule 2**k, where k is the number
// of dimensions of the space containing the hyperrectangle. // of dimensions of the space containing the hyperrectangle.
assert!(p.parse("hyperrectangle{}").is_err()); assert!(p.parse("inside(hyperrectangle{})").is_err());
assert!(p.parse("hyperrectangle{[]}").is_err()); assert!(p.parse("inside(hyperrectangle{[]})").is_err());
assert!(p.parse("hyperrectangle{[0]}").is_err()); assert!(p.parse("inside(hyperrectangle{[0]})").is_err());
assert!(p.parse("hyperrectangle{[0], [1], [2]}").is_err()); assert!(p.parse("inside(hyperrectangle{[0], [1], [2]})").is_err());
assert!(p.parse("hyperrectangle{[0], [1], [2], [3], [4]}").is_err()); assert!(p.parse("inside(hyperrectangle{[0], [1], [2], [3], [4]})").is_err());
assert!(p.parse("hyperrectangle{[0], [1]}").is_ok()); assert!(p.parse("inside(hyperrectangle{[0], [1]})").is_ok());
assert!(p.parse("hyperrectangle{[0], [1], \"space\"}").is_ok()); assert!(p.parse("inside(hyperrectangle{[0], [1], \"space\"})").is_ok());
assert!(p.parse("hyperrectangle{[0], [1], [2], [3]}").is_ok()); assert!(p.parse("inside(hyperrectangle{[0], [1], [2], [3]})").is_ok());
assert!(p.parse("hyperrectangle{[0], [1], [2], [3]}").is_ok()); assert!(p.parse("inside(hyperrectangle{[0], [1], [2], [3]})").is_ok());
assert!(p assert!(p
.parse("hyperrectangle{[0], [1], [2], [3], [4], [5]}") .parse("inside(hyperrectangle{[0], [1], [2], [3], [4], [5]})")
.is_ok()); .is_ok());
assert!(p assert!(p
.parse("hyperrectangle{[0], [1], [2], [3], [4], [5], \"space\"}") .parse("inside(hyperrectangle{[0], [1], [2], [3], [4], [5], \"space\"})")
.is_ok()); .is_ok());
} }
@@ -540,23 +540,23 @@ mod parsing {
fn hyperrsphere() { fn hyperrsphere() {
let p = filters_parser(); let p = filters_parser();
assert!(p.parse("hypersphere{}").is_err()); assert!(p.parse("inside(hypersphere{}").is_err());
assert!(p.parse("hypersphere{[]}").is_err()); assert!(p.parse("inside(hypersphere{[]})").is_err());
assert!(p.parse("hypersphere{[0]}").is_err()); assert!(p.parse("inside(hypersphere{[0]})").is_err());
assert!(p.parse("hypersphere{[0], 23}").is_ok()); assert!(p.parse("inside(hypersphere{[0], 23})").is_ok());
assert!(p.parse("hypersphere{[0], 23, \"space\"}").is_ok()); assert!(p.parse("inside(hypersphere{[0], 23, \"space\"})").is_ok());
} }
#[test] #[test]
fn point() { fn point() {
let p = filters_parser(); let p = filters_parser();
assert!(p.parse("point{}").is_err()); assert!(p.parse("inside(point{})").is_err());
assert!(p.parse("point{[]}").is_err()); assert!(p.parse("inside(point{[]})").is_err());
assert!(p.parse("point{[0]}").is_ok()); assert!(p.parse("inside(point{[0]})").is_ok());
assert!(p.parse("point{[0], \"space\"}").is_ok()); assert!(p.parse("inside(point{[0], \"space\"})").is_ok());
} }
#[test] #[test]
@@ -579,30 +579,30 @@ mod parsing {
assert!(p assert!(p
.parse( .parse(
format!( format!(
"filter(=({}, [1]), point{{[0]}})", "filter(=({}, [1]), inside(point{{[0]}}))",
"str_cmp_ignore_case(.field, \"\")" "str_cmp_ignore_case(.field, \"\")"
) )
.as_str() .as_str()
) )
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", "str_cmp(.field, \"\")").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", "str_cmp(.field, \"\")").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", ".field").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", ".field").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", "[0]").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", "[0]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", "point{[0]}").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", "inside(point{[0]})").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", "{0}").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", "{0}").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", "").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", "").as_str())
.is_err()); .is_err());
}*/ }*/
@@ -612,15 +612,15 @@ mod parsing {
assert!(p assert!(p
.parse( .parse(
format!("filter(=({}, [1]), point{{[0]}})", "str_cmp(.field, \"\")").as_str() format!("filter(=({}, [1]), inside(point{{[0]}}))", "str_cmp(.field, \"\")").as_str()
) )
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", "str_cmp(.field)").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", "str_cmp(.field)").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", "str_cmp(\"\")").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", "str_cmp(\"\")").as_str())
.is_err()); .is_err());
} }
@@ -631,7 +631,7 @@ mod parsing {
assert!(p assert!(p
.parse( .parse(
format!( format!(
"filter(=({}, [1]), point{{[0]}})", "filter(=({}, [1]), inside(point{{[0]}}))",
"str_cmp_ignore_case(.field, \"\")" "str_cmp_ignore_case(.field, \"\")"
) )
.as_str() .as_str()
@@ -641,7 +641,7 @@ mod parsing {
assert!(p assert!(p
.parse( .parse(
format!( format!(
"filter(=({}, [1]), point{{[0]}})", "filter(=({}, [1]), inside(point{{[0]}}))",
"str_cmp_ignore_case(.field)" "str_cmp_ignore_case(.field)"
) )
.as_str() .as_str()
@@ -650,7 +650,7 @@ mod parsing {
assert!(p assert!(p
.parse( .parse(
format!( format!(
"filter(=({}, [1]), point{{[0]}})", "filter(=({}, [1]), inside(point{{[0]}}))",
"str_cmp_ignore_case(\"\")" "str_cmp_ignore_case(\"\")"
) )
.as_str() .as_str()
@@ -663,19 +663,19 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", ".").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", ".").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", ".field").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", ".field").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", ".field.field").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", ".field.field").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", ".field[1].field").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", ".field[1].field").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(=({}, [1]), point{{[0]}})", ".field.field[1]").as_str()) .parse(format!("filter(=({}, [1]), inside(point{{[0]}}))", ".field.field[1]").as_str())
.is_ok()); .is_ok());
} }
@@ -684,26 +684,26 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
// Empty // Empty
assert!(p.parse(format!("point{{{}}}", "[]").as_str()).is_err()); assert!(p.parse(format!("inside(point{{{}}})", "[]").as_str()).is_err());
// Non-numerical coordinate: // Non-numerical coordinate:
assert!(p.parse(format!("point{{{}}}", "[aa]").as_str()).is_err()); assert!(p.parse(format!("inside(point{{{}}})", "[aa]").as_str()).is_err());
assert!(p assert!(p
.parse(format!("point{{{}}}", "[\"aa\"]").as_str()) .parse(format!("inside(point{{{}}})", "[\"aa\"]").as_str())
.is_err()); .is_err());
// One or more coordinates // One or more coordinates
assert!(p.parse(format!("point{{{}}}", "[0]").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{{}}})", "[0]").as_str()).is_ok());
assert!(p.parse(format!("point{{{}}}", "[0, 0]").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{{}}})", "[0, 0]").as_str()).is_ok());
assert!(p assert!(p
.parse(format!("point{{{}}}", "[0, 0, 0]").as_str()) .parse(format!("inside(point{{{}}})", "[0, 0, 0]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("point{{{}}}", "[0, 0, 0, 0]").as_str()) .parse(format!("inside(point{{{}}})", "[0, 0, 0, 0]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("point{{{}}}", "[0,0,0,0]").as_str()) .parse(format!("inside(point{{{}}})", "[0,0,0,0]").as_str())
.is_ok()); .is_ok());
} }
@@ -713,66 +713,66 @@ mod parsing {
// Single dot // Single dot
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".").as_str())
.is_ok()); .is_ok());
// Check first character is within allowed characters // Check first character is within allowed characters
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".a").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".a").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", "._").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", "._").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".2").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".2").as_str())
.is_err()); .is_err());
// Check second character is within allowed characters // Check second character is within allowed characters
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".fa").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".fa").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f2").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f2").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f_").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f_").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f2").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f2").as_str())
.is_ok()); .is_ok());
// Check we can add subscript // Check we can add subscript
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".[23]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".[23]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[0]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[0]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[2]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[2]").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[23]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[23]").as_str())
.is_ok()); .is_ok());
// Invalid index values // Invalid index values
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[2.3]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[2.3]").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[02]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[02]").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[-2]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[-2]").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[2e2]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[2e2]").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[2E2]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[2E2]").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("filter(<({}, [1]), point{{[0]}})", ".f[+2]").as_str()) .parse(format!("filter(<({}, [1]), inside(point{{[0]}}))", ".f[+2]").as_str())
.is_err()); .is_err());
} }
@@ -836,42 +836,42 @@ mod parsing {
// Integers // Integers
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "0").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "+0").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "+0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "-0").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "-0").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "1").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "1").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "+1").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "+1").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "-1").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "-1").as_str())
.is_err()); .is_err());
// Floating point values // Floating point values
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "0.0").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "0.0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "+0.0").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "+0.0").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "-0.0").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "-0.0").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "0.1").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "0.1").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "+0.01").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "+0.01").as_str())
.is_ok()); .is_ok());
assert!(p assert!(p
.parse(format!("hypersphere{{[0],{}}}", "-0.01").as_str()) .parse(format!("inside(hypersphere{{[0],{}}})", "-0.01").as_str())
.is_err()); .is_err());
} }
@@ -880,20 +880,20 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
// Integers // Integers
assert!(p.parse(format!("point{{[{}]}}", "0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "+0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "+0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "-0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "-0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "+1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "+1").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "-1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "-1").as_str()).is_ok());
// Floating point values // Floating point values
assert!(p.parse(format!("point{{[{}]}}", "0.0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "+0.0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "+0.0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "-0.0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "-0.0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "+0.01").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "+0.01").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "-0.01").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "-0.01").as_str()).is_ok());
} }
#[test] #[test]
@@ -901,54 +901,54 @@ mod parsing {
let p = filters_parser(); let p = filters_parser();
// Integers // Integers
assert!(p.parse(format!("point{{[{}]}}", "0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1e2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1e2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1e+2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1e+2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1e-2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1e-2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1E2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1E2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "100").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "100").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "010").as_str()).is_err()); assert!(p.parse(format!("inside(point{{[{}]}})", "010").as_str()).is_err());
// Floating point values (normalized) // Floating point values (normalized)
assert!(p.parse(format!("point{{[{}]}}", "0.0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1e0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1e0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1e2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1e2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1e+2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1e+2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1e-2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1e-2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1E2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1E2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.1E23").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.1E23").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.01").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.01").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "0.").as_str()).is_err()); assert!(p.parse(format!("inside(point{{[{}]}})", "0.").as_str()).is_err());
assert!(p assert!(p
.parse(format!("point{{[{}]}}", "0.1E03").as_str()) .parse(format!("inside(point{{[{}]}})", "0.1E03").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("point{{[{}]}}", "0.1E0.3").as_str()) .parse(format!("inside(point{{[{}]}})", "0.1E0.3").as_str())
.is_err()); .is_err());
// Floating point values (denormalized) // Floating point values (denormalized)
assert!(p.parse(format!("point{{[{}]}}", "1.0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.1").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.1e0").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.1e0").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.1e2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.1e2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.1e+2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.1e+2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.1e-2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.1e-2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.1E2").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.1E2").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.1E23").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.1E23").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.01").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.01").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "10.1").as_str()).is_ok()); assert!(p.parse(format!("inside(point{{[{}]}})", "10.1").as_str()).is_ok());
assert!(p.parse(format!("point{{[{}]}}", "1.").as_str()).is_err()); assert!(p.parse(format!("inside(point{{[{}]}})", "1.").as_str()).is_err());
assert!(p.parse(format!("point{{[{}]}}", "01.1").as_str()).is_err()); assert!(p.parse(format!("inside(point{{[{}]}})", "01.1").as_str()).is_err());
assert!(p assert!(p
.parse(format!("point{{[{}]}}", "1.1E03").as_str()) .parse(format!("inside(point{{[{}]}})", "1.1E03").as_str())
.is_err()); .is_err());
assert!(p assert!(p
.parse(format!("point{{[{}]}}", "1.1E0.3").as_str()) .parse(format!("inside(point{{[{}]}})", "1.1E0.3").as_str())
.is_err()); .is_err());
} }
} }

21
src/types.rs
View File

@@ -11,23 +11,10 @@ pub enum LiteralTypes {
impl PartialEq for LiteralTypes { impl PartialEq for LiteralTypes {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
match self { match self {
LiteralTypes::String => match other { LiteralTypes::String => matches!(other, LiteralTypes::String),
LiteralTypes::String => true, LiteralTypes::Int => matches!(other, LiteralTypes::Int),
_ => false, LiteralTypes::Float => matches!(other, LiteralTypes::Float | LiteralTypes::Int),
}, LiteralTypes::Bag(_) => matches!(other, LiteralTypes::Bag(_)),
LiteralTypes::Int => match other {
LiteralTypes::Int => true,
_ => false,
},
LiteralTypes::Float => match other {
LiteralTypes::Float => true,
LiteralTypes::Int => true,
_ => false,
},
LiteralTypes::Bag(_) => match other {
LiteralTypes::Bag(_) => true,
_ => false,
},
LiteralTypes::Vector(v) => match other { LiteralTypes::Vector(v) => match other {
LiteralTypes::Vector(ov) => { LiteralTypes::Vector(ov) => {
let n = v.len(); let n = v.len();

7
src/validators.rs
View File

@@ -9,7 +9,7 @@ impl Validator for Projection {
fn validate(&self) -> ValidationResult { fn validate(&self) -> ValidationResult {
match self { match self {
Projection::Nifti(_, _, _) => Err("not yet implemented".to_string()), Projection::Nifti(_, _, _) => Err("not yet implemented".to_string()),
Projection::JSON(_, _format, bag) => bag.validate(), Projection::Json(_, _format, bag) => bag.validate(),
//FIXME: Add support for projections //FIXME: Add support for projections
/* match format.validate() { /* match format.validate() {
Ok(_) => bag.validate(), Ok(_) => bag.validate(),
@@ -61,10 +61,7 @@ impl Validator for Bag {
Bag::Union(lh, rh) => compare_bag_types(lh, rh), Bag::Union(lh, rh) => compare_bag_types(lh, rh),
Bag::Bag(bags) => { Bag::Bag(bags) => {
for b in bags { for b in bags {
let t = b.validate(); b.validate()?;
if t.is_err() {
return t;
}
} }
Ok(get_type()) Ok(get_type())