Added EngineSerializer trait

Author: boocmp

Cargo.toml

@@ -80,6 +80,10 @@ harness = false
 name = "bench_memory"
 harness = false
 
+[[bench]]
+name = "bench_serialization"
+harness = false
+
 # Currently disabled, as cosmetic filter internals
 # are no longer part of the crate's public API
 #[[bench]]

benches/bench_matching.rs

@@ -205,81 +205,6 @@ fn rule_match_parsed_elep_slimlist(c: &mut Criterion) {
     group.finish();
 }
 
-fn serialization(c: &mut Criterion) {
-    let mut group = c.benchmark_group("blocker-serialization");
-
-    group.sample_size(20);
-
-    group.bench_function("el+ep", move |b| {
-        let full_rules = rules_from_lists(&[
-            "data/easylist.to/easylist/easylist.txt",
-            "data/easylist.to/easylist/easyprivacy.txt",
-        ]);
-
-        let engine = Engine::from_rules(full_rules, Default::default());
-        b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
-    });
-    group.bench_function("el", move |b| {
-        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
-
-        let engine = Engine::from_rules(full_rules, Default::default());
-        b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
-    });
-    group.bench_function("slimlist", move |b| {
-        let full_rules = rules_from_lists(&["data/slim-list.txt"]);
-
-        let engine = Engine::from_rules(full_rules, Default::default());
-        b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
-    });
-
-    group.finish();
-}
-
-fn deserialization(c: &mut Criterion) {
-    let mut group = c.benchmark_group("blocker-deserialization");
-
-    group.sample_size(20);
-
-    group.bench_function("el+ep", move |b| {
-        let full_rules = rules_from_lists(&[
-            "data/easylist.to/easylist/easylist.txt",
-            "data/easylist.to/easylist/easyprivacy.txt",
-        ]);
-
-        let engine = Engine::from_rules(full_rules, Default::default());
-        let serialized = engine.serialize_raw().unwrap();
-
-        b.iter(|| {
-            let mut deserialized = Engine::default();
-            assert!(deserialized.deserialize(&serialized).is_ok());
-        })
-    });
-    group.bench_function("el", move |b| {
-        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
-
-        let engine = Engine::from_rules(full_rules, Default::default());
-        let serialized = engine.serialize_raw().unwrap();
-
-        b.iter(|| {
-            let mut deserialized = Engine::default();
-            assert!(deserialized.deserialize(&serialized).is_ok());
-        })
-    });
-    group.bench_function("slimlist", move |b| {
-        let full_rules = rules_from_lists(&["data/slim-list.txt"]);
-
-        let engine = Engine::from_rules(full_rules, Default::default());
-        let serialized = engine.serialize_raw().unwrap();
-
-        b.iter(|| {
-            let mut deserialized = Engine::default();
-            assert!(deserialized.deserialize(&serialized).is_ok());
-        })
-    });
-
-    group.finish();
-}
-
 fn rule_match_browserlike_comparable(c: &mut Criterion) {
     let mut group = c.benchmark_group("rule-match-browserlike");
 
@@ -395,7 +320,5 @@ criterion_group!(
     rule_match_parsed_elep_slimlist,
     rule_match_browserlike_comparable,
     rule_match_first_request,
-    serialization,
-    deserialization
 );
 criterion_main!(benches);

benches/bench_serialization.rs

@@ -0,0 +1,85 @@
+use criterion::*;
+
+use adblock::{Engine, EngineSerializer};
+
+#[path = "../tests/test_utils.rs"]
+mod test_utils;
+use test_utils::rules_from_lists;
+
+fn serialization(c: &mut Criterion) {
+    let mut group = c.benchmark_group("blocker-serialization");
+
+    group.sample_size(20);
+
+    group.bench_function("el+ep", move |b| {
+        let full_rules = rules_from_lists(&[
+            "data/easylist.to/easylist/easylist.txt",
+            "data/easylist.to/easylist/easyprivacy.txt",
+        ]);
+
+        let engine = Engine::from_rules(full_rules, Default::default());
+        b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
+    });
+    group.bench_function("el", move |b| {
+        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
+
+        let engine = Engine::from_rules(full_rules, Default::default());
+        b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
+    });
+    group.bench_function("slimlist", move |b| {
+        let full_rules = rules_from_lists(&["data/slim-list.txt"]);
+
+        let engine = Engine::from_rules(full_rules, Default::default());
+        b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
+    });
+
+    group.finish();
+}
+
+fn deserialization(c: &mut Criterion) {
+    let mut group = c.benchmark_group("blocker-deserialization");
+
+    group.sample_size(20);
+
+    group.bench_function("el+ep", move |b| {
+        let full_rules = rules_from_lists(&[
+            "data/easylist.to/easylist/easylist.txt",
+            "data/easylist.to/easylist/easyprivacy.txt",
+        ]);
+
+        let engine = Engine::from_rules(full_rules, Default::default());
+        let serialized = engine.serialize_raw().unwrap();
+
+        b.iter(|| {
+            let mut deserialized = Engine::default();
+            assert!(deserialized.deserialize(&serialized).is_ok());
+        })
+    });
+    group.bench_function("el", move |b| {
+        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
+
+        let engine = Engine::from_rules(full_rules, Default::default());
+        let serialized = engine.serialize_raw().unwrap();
+
+        b.iter(|| {
+            let mut deserialized = Engine::default();
+            assert!(deserialized.deserialize(&serialized).is_ok());
+        })
+    });
+    group.bench_function("slimlist", move |b| {
+        let full_rules = rules_from_lists(&["data/slim-list.txt"]);
+
+        let engine = Engine::from_rules(full_rules, Default::default());
+        let serialized = engine.serialize_raw().unwrap();
+
+        b.iter(|| {
+            let mut deserialized = Engine::default();
+            assert!(deserialized.deserialize(&serialized).is_ok());
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, serialization, deserialization);
+criterion_main!(benches);

examples/deserialization.rs

@@ -1,4 +1,4 @@
-use adblock::{request::Request, Engine};
+use adblock::{request::Request, Engine, EngineSerializer};
 
 use serde::Deserialize;
 

examples/generate-dat.rs

@@ -1,4 +1,4 @@
-use adblock::{request::Request, Engine};
+use adblock::{request::Request, Engine, EngineSerializer};
 
 use std::fs::File;
 use std::io::prelude::*;

examples/use-dat.rs

@@ -1,4 +1,4 @@
-use adblock::{request::Request, Engine};
+use adblock::{request::Request, Engine, EngineSerializer};
 
 use std::fs::File;
 use std::io::prelude::*;

js/src/lib.rs

@@ -5,6 +5,7 @@ use std::cell::RefCell;
 use std::sync::Mutex;
 use std::path::Path;
 use adblock::Engine as EngineInternal;
+use adblock::EngineSerializer as EngineSerializerInternal;
 use adblock::lists::{RuleTypes, FilterFormat, FilterListMetadata, FilterSet as FilterSetInternal, ParseOptions};
 use adblock::resources::Resource;
 use adblock::resources::resource_assembler::assemble_web_accessible_resources;

src/data_format/mod.rs

@@ -5,6 +5,8 @@
 //! serialization/deserialization implementations and can automatically dispatch to the appropriate
 //! one.
 
+#![allow(dead_code)]
+
 mod v0;
 
 pub(crate) mod utils;

src/engine.rs

@@ -43,8 +43,8 @@ use std::collections::HashSet;
 /// [`Engine::hidden_class_id_selectors`] on an ongoing basis to determine additional elements that
 /// should be hidden dynamically.
 pub struct Engine {
-    blocker: Blocker,
-    cosmetic_cache: CosmeticFilterCache,
+    pub(crate) blocker: Blocker,
+    pub(crate) cosmetic_cache: CosmeticFilterCache,
     resources: ResourceStorage,
 }
 
@@ -121,32 +121,6 @@ impl Engine {
         }
     }
 
-    /// Serializes the `Engine` into a binary format so that it can be quickly reloaded later.
-    pub fn serialize_raw(&self) -> Result<Vec<u8>, crate::data_format::SerializationError> {
-        use crate::data_format::SerializeFormat;
-
-        let serialize_format = SerializeFormat::build(&self.blocker, &self.cosmetic_cache);
-
-        serialize_format.serialize()
-    }
-
-    /// Deserialize the `Engine` from the binary format generated by `Engine::serialize_raw`. The
-    /// method will automatically select the correct deserialization implementation.
-    pub fn deserialize(
-        &mut self,
-        serialized: &[u8],
-    ) -> Result<(), crate::data_format::DeserializationError> {
-        use crate::data_format::DeserializeFormat;
-        let current_tags = self.blocker.tags_enabled();
-        let deserialize_format = DeserializeFormat::deserialize(serialized)?;
-        let (blocker, cosmetic_cache) = deserialize_format.build();
-        self.blocker = blocker;
-        self.blocker
-            .use_tags(&current_tags.iter().map(|s| &**s).collect::<Vec<_>>());
-        self.cosmetic_cache = cosmetic_cache;
-        Ok(())
-    }
-
     /// Check if a request for a network resource from `url`, of type `request_type`, initiated by
     /// `source_url`, should be blocked.
     pub fn check_network_request(&self, request: &Request) -> BlockerResult {

src/engine_serializer.rs

@@ -0,0 +1,82 @@
+use crate::engine::Engine;
+
+#[derive(Debug)]
+#[cfg(not(feature = "flatbuffers-storage"))]
+pub enum SerializeError {
+    DataFormatError(crate::data_format::SerializationError),
+}
+
+#[derive(Debug)]
+#[cfg(feature = "flatbuffers-storage")]
+pub enum SerializeError {
+    FlatbuffersError(),
+}
+
+#[derive(Debug)]
+#[cfg(not(feature = "flatbuffers-storage"))]
+pub enum DeserializeError {
+    DataFormatError(crate::data_format::DeserializationError),
+}
+
+#[derive(Debug)]
+#[cfg(feature = "flatbuffers-storage")]
+pub enum DeserializeError {
+    FlatbuffersError(),
+}
+
+#[cfg(not(feature = "flatbuffers-storage"))]
+impl From<crate::data_format::SerializationError> for SerializeError {
+    fn from(value: crate::data_format::SerializationError) -> Self {
+        SerializeError::DataFormatError(value)
+    }
+}
+
+#[cfg(not(feature = "flatbuffers-storage"))]
+impl From<crate::data_format::DeserializationError> for DeserializeError {
+    fn from(value: crate::data_format::DeserializationError) -> Self {
+        DeserializeError::DataFormatError(value)
+    }
+}
+
+pub trait EngineSerializer {
+    fn serialize_raw(&self) -> Result<Vec<u8>, SerializeError>;
+    fn deserialize(&mut self, serialized: &[u8]) -> Result<(), DeserializeError>;
+}
+
+#[cfg(feature = "flatbuffers-storage")]
+impl EngineSerializer for Engine {
+    fn serialize_raw(&self) -> Result<Vec<u8>, SerializeError> {
+        Err(SerializeError::FlatbuffersError())
+    }
+
+    fn deserialize(&mut self, _serialized: &[u8]) -> Result<(), DeserializeError> {
+        Err(DeserializeError::FlatbuffersError())
+    }
+}
+
+#[cfg(not(feature = "flatbuffers-storage"))]
+impl EngineSerializer for Engine {
+    /// Serializes the `Engine` into a binary format so that it can be quickly reloaded later.
+    fn serialize_raw(&self) -> Result<Vec<u8>, SerializeError> {
+        use crate::data_format::SerializeFormat;
+
+        let serialize_format = SerializeFormat::build(&self.blocker, &self.cosmetic_cache);
+
+        let result = serialize_format.serialize()?;
+        Ok(result)
+    }
+
+    /// Deserialize the `Engine` from the binary format generated by `Engine::serialize_raw`. The
+    /// method will automatically select the correct deserialization implementation.
+    fn deserialize(&mut self, serialized: &[u8]) -> Result<(), DeserializeError> {
+        use crate::data_format::DeserializeFormat;
+        let current_tags = self.blocker.tags_enabled();
+        let deserialize_format = DeserializeFormat::deserialize(serialized)?;
+        let (blocker, cosmetic_cache) = deserialize_format.build();
+        self.blocker = blocker;
+        self.blocker
+            .use_tags(&current_tags.iter().map(|s| &**s).collect::<Vec<_>>());
+        self.cosmetic_cache = cosmetic_cache;
+        Ok(())
+    }
+}

src/flat_network_filter_list.rs

@@ -72,7 +72,7 @@ impl NetworkFilterListTrait for FlatNetworkFilterList {
 
         if optimize {
             for (token, v) in optimizable {
-                let optimized = optimizer::optimize_by_groupping_patterns(v);
+                let optimized = optimizer::optimize(v);
 
                 for filter in optimized {
                     let index = flat_builder.add(&filter);

src/lib.rs

@@ -22,6 +22,7 @@ pub mod content_blocking;
 pub mod cosmetic_filter_cache;
 mod data_format;
 mod engine;
+mod engine_serializer;
 pub mod filters;
 pub mod lists;
 mod network_filter_list;
@@ -39,6 +40,7 @@ pub mod utils;
 
 #[doc(inline)]
 pub use engine::Engine;
+pub use engine_serializer::EngineSerializer;
 #[doc(inline)]
 pub use lists::FilterSet;
 

src/optimizer.rs

@@ -18,21 +18,6 @@ pub fn is_filter_optimizable_by_patterns(filter: &NetworkFilter) -> bool {
         && !filter.is_csp()
 }
 
-pub fn optimize_by_groupping_patterns(filters: Vec<NetworkFilter>) -> Vec<NetworkFilter> {
-    let mut optimized: Vec<NetworkFilter> = Vec::new();
-
-    let simple_pattern_group = SimplePatternGroup {};
-    let (mut fused, mut unfused) = apply_optimisation(&simple_pattern_group, filters);
-    optimized.append(&mut fused);
-
-    // Append whatever is still left unfused
-    optimized.append(&mut unfused);
-
-    // Re-sort the list, now that the order has been perturbed
-    optimized.sort_by_key(|f| f.id);
-    optimized
-}
-
 /// Fuse `NetworkFilter`s together by applying optimizations sequentially.
 pub fn optimize(filters: Vec<NetworkFilter>) -> Vec<NetworkFilter> {
     let mut optimized: Vec<NetworkFilter> = Vec::new();