Make background validation performed by Services configurable #2060

crates/fj-core/src/objects/object.rs

@@ -4,7 +4,7 @@ use crate::{
         Surface, Vertex,
     },
     storage::{Handle, HandleWrapper, ObjectId},
-    validate::{Validate, ValidationError},
+    validate::{Validate, ValidationConfig, ValidationError},
 };
 
 macro_rules! object {
@@ -40,6 +40,15 @@ macro_rules! object {
                     )*
                 }
             }
+
+            /// Validate the object with a pre-defined validation configuration
+            pub fn validate_with_config(&self, config: &ValidationConfig, errors: &mut Vec<ValidationError>) {
+                match self {
+                    $(
+                        Self::$ty(object) => object.validate_with_config(config, errors),
+                    )*
+                }
+            }
         }
 
         impl Object<WithHandle> {

crates/fj-core/src/services/mod.rs

@@ -8,7 +8,7 @@ mod validation;
 
 use crate::{
     objects::{Object, Objects, WithHandle},
-    validate::ValidationErrors,
+    validate::{ValidationConfig, ValidationErrors},
 };
 
 pub use self::{
@@ -42,6 +42,18 @@ impl Services {
         }
     }
 
+    /// Construct an instance of `Services` with a pre-defined configuration for the validation service
+    pub fn with_validation_config(config: &ValidationConfig) -> Self {
+        let objects = Service::<Objects>::default();
+        let mut validation = Service::<Validation>::default();
+        validation
+            .evolve(&ValidationEvent::ConfigurationDefined { config: *config });
+        Self {
+            objects,
+            validation,
+        }
+    }
+
     /// Insert an object into the stores
     pub fn insert_object(&mut self, object: Object<WithHandle>) {
         let mut object_events = Vec::new();

crates/fj-core/src/services/service.rs

@@ -1,4 +1,4 @@
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 /// A service that controls access to some state
 ///
@@ -62,6 +62,12 @@ impl<S: State> Deref for Service<S> {
     }
 }
 
+impl<S: State> DerefMut for Service<S> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.state
+    }
+}
+
 impl<S: State> Default for Service<S>
 where
     S: Default,

crates/fj-core/src/services/validation.rs

@@ -3,16 +3,34 @@ use std::{collections::BTreeMap, error::Error, thread};
 use crate::{
     objects::{BehindHandle, Object},
     storage::ObjectId,
-    validate::ValidationError,
+    validate::{ValidationConfig, ValidationError},
 };
 
 use super::State;
 
 /// Errors that occurred while validating the objects inserted into the stores
-#[derive(Default)]
 pub struct Validation {
     /// All unhandled validation errors
     pub errors: BTreeMap<ObjectId, ValidationError>,
+    /// Optional validation config
+    config: Option<ValidationConfig>,
+}
+
+impl Validation {
+    fn with_validation_config(&mut self, config: &ValidationConfig) -> &Self {
+        self.config = Some(*config);
+        self
+    }
+}
+
+impl Default for Validation {
+    fn default() -> Self {
+        let errors = BTreeMap::new();
+        Self {
+            errors,
+            config: None,
+        }
+    }
 }
 
 impl Drop for Validation {
@@ -54,6 +72,10 @@ impl State for Validation {
 
         match command {
             ValidationCommand::ValidateObject { object } => {
+                match self.config {
+                    Some(c) => object.validate_with_config(&c, &mut errors),
+                    None => object.validate(&mut errors),
+                }
                 object.validate(&mut errors);
 
                 for err in errors {
@@ -71,6 +93,9 @@ impl State for Validation {
             ValidationEvent::ValidationFailed { object, err } => {
                 self.errors.insert(object.id(), err.clone());
             }
+            ValidationEvent::ConfigurationDefined { config } => {
+                self.with_validation_config(config);
+            }
         }
     }
 }
@@ -95,4 +120,9 @@ pub enum ValidationEvent {
         /// The validation error
         err: ValidationError,
     },
+    /// A validation configuration has been defined
+    ConfigurationDefined {
+        /// The predefined validation configuration
+        config: ValidationConfig,
+    },
 }