refactor: cell data parser

frontend/rust-lib/flowy-grid/src/services/cell/any_cell_data.rs

@@ -132,11 +132,11 @@ impl CellBytes {
         Ok(Self(bytes))
     }
 
-    pub fn with_parser<P>(&self, parser: P) -> FlowyResult<P::Object>
+    pub fn with_parser<P>(&self) -> FlowyResult<P::Object>
     where
         P: CellBytesParser,
     {
-        parser.parse(&self.0)
+        P::parse(&self.0)
     }
 
     // pub fn parse<'a, T: TryFrom<&'a [u8]>>(&'a self) -> FlowyResult<T>

frontend/rust-lib/flowy-grid/src/services/group/group_generator/generator.rs

@@ -1,14 +1,15 @@
-use crate::services::cell::{decode_any_cell_data, CellBytes};
+use crate::services::cell::{decode_any_cell_data, CellBytes, CellBytesParser};
 use bytes::Bytes;
 use flowy_error::FlowyResult;
 use flowy_grid_data_model::revision::{
     CellRevision, FieldRevision, GroupConfigurationRevision, RowRevision, TypeOptionDataDeserializer,
 };
+use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-pub trait GroupAction {
+pub trait GroupAction<CD> {
-    fn should_group(&mut self, content: &str, cell_bytes: CellBytes) -> bool;
+    fn should_group(&self, content: &str, cell_data: CD) -> bool;
 }
 
 pub trait GroupCellContentProvider {
@@ -24,15 +25,16 @@ pub trait GroupGenerator<C, T> {
         configuration: &Option<C>,
         type_option: &Option<T>,
         cell_content_provider: &dyn GroupCellContentProvider,
-    ) -> Vec<Group>;
+    ) -> HashMap<String, Group>;
 }
 
-pub struct GroupController<C, T, G> {
+pub struct GroupController<C, T, G, CP> {
     field_rev: Arc<FieldRevision>,
-    groups: Vec<Group>,
+    groups: HashMap<String, Group>,
     type_option: Option<T>,
     configuration: Option<C>,
-    phantom: PhantomData<G>,
+    group_action_phantom: PhantomData<G>,
+    cell_parser_phantom: PhantomData<CP>,
 }
 
 pub struct Group {
@@ -40,7 +42,7 @@ pub struct Group {
     content: String,
 }
 
-impl<C, T, G> GroupController<C, T, G>
+impl<C, T, G, CP> GroupController<C, T, G, CP>
 where
     C: TryFrom<Bytes, Error = protobuf::ProtobufError>,
     T: TypeOptionDataDeserializer,
@@ -62,27 +64,39 @@ where
             groups: G::gen_groups(&configuration, &type_option, cell_content_provider),
             type_option,
             configuration,
-            phantom: PhantomData,
+            group_action_phantom: PhantomData,
+            cell_parser_phantom: PhantomData,
         })
     }
 }
 
-impl<C, T, G> GroupController<C, T, G>
+impl<C, T, G, CP> GroupController<C, T, G, CP>
 where
-    Self: GroupAction,
+    CP: CellBytesParser,
+    Self: GroupAction<CP::Object>,
 {
     pub fn group_row(&mut self, row: &RowRevision) {
         if self.configuration.is_none() {
             return;
         }
         if let Some(cell_rev) = row.cells.get(&self.field_rev.id) {
-            for group in self.groups.iter_mut() {
+            let mut group_row_id = None;
+            let cell_bytes = decode_any_cell_data(cell_rev.data.clone(), &self.field_rev);
+            // let cell_data = cell_bytes.with_parser(CP);
+            for group in self.groups.values() {
                 let cell_rev: CellRevision = cell_rev.clone();
-                let cell_bytes = decode_any_cell_data(cell_rev.data, &self.field_rev);
+
                 // if self.should_group(&group.content, cell_bytes) {
-                //     group.row_ids.push(row.id.clone());
+                //     group_row_id = Some(row.id.clone());
+                //     break;
                 // }
             }
+
+            if let Some(group_row_id) = group_row_id {
+                self.groups.get_mut(&group_row_id).map(|group| {
+                    group.row_ids.push(group_row_id);
+                });
+            }
         }
     }
 }

frontend/rust-lib/flowy-grid/src/services/group/group_generator/select_option_group.rs

@@ -1,44 +1,52 @@
 use crate::entities::SelectOptionGroupConfigurationPB;
 use crate::services::cell::CellBytes;
-use crate::services::field::{MultiSelectTypeOptionPB, SelectedSelectOptions, SingleSelectTypeOptionPB};
+use crate::services::field::{
+    MultiSelectTypeOptionPB, SelectOptionCellDataPB, SelectOptionCellDataParser, SelectedSelectOptions,
+    SingleSelectTypeOptionPB,
+};
 use crate::services::group::{Group, GroupAction, GroupCellContentProvider, GroupController, GroupGenerator};
+use std::collections::HashMap;
 
-pub type SingleSelectGroupController =
+pub type SingleSelectGroupController = GroupController<
-    GroupController<SelectOptionGroupConfigurationPB, SingleSelectTypeOptionPB, SingleSelectGroupGen>;
+    SelectOptionGroupConfigurationPB,
+    SingleSelectTypeOptionPB,
+    SingleSelectGroupGenerator,
+    SelectOptionCellDataParser,
+>;
 
-pub struct SingleSelectGroupGen();
+pub struct SingleSelectGroupGenerator();
-impl GroupGenerator<SelectOptionGroupConfigurationPB, SingleSelectTypeOptionPB> for SingleSelectGroupGen {
+impl GroupGenerator<SelectOptionGroupConfigurationPB, SingleSelectTypeOptionPB> for SingleSelectGroupGenerator {
     fn gen_groups(
         configuration: &Option<SelectOptionGroupConfigurationPB>,
         type_option: &Option<SingleSelectTypeOptionPB>,
         cell_content_provider: &dyn GroupCellContentProvider,
-    ) -> Vec<Group> {
+    ) -> HashMap<String, Group> {
         todo!()
     }
 }
 
-impl GroupAction for SingleSelectGroupController {
+impl GroupAction<SelectOptionCellDataPB> for SingleSelectGroupController {
-    fn should_group(&mut self, content: &str, cell_bytes: CellBytes) -> bool {
+    fn should_group(&self, content: &str, cell_data: SelectOptionCellDataPB) -> bool {
         todo!()
     }
 }
 
-pub type MultiSelectGroupController =
+// pub type MultiSelectGroupController =
-    GroupController<SelectOptionGroupConfigurationPB, MultiSelectTypeOptionPB, MultiSelectGroupGen>;
+//     GroupController<SelectOptionGroupConfigurationPB, MultiSelectTypeOptionPB, MultiSelectGroupGenerator>;
-
+//
-pub struct MultiSelectGroupGen();
+// pub struct MultiSelectGroupGenerator();
-impl GroupGenerator<SelectOptionGroupConfigurationPB, MultiSelectTypeOptionPB> for MultiSelectGroupGen {
+// impl GroupGenerator<SelectOptionGroupConfigurationPB, MultiSelectTypeOptionPB> for MultiSelectGroupGenerator {
-    fn gen_groups(
+//     fn gen_groups(
-        configuration: &Option<SelectOptionGroupConfigurationPB>,
+//         configuration: &Option<SelectOptionGroupConfigurationPB>,
-        type_option: &Option<MultiSelectTypeOptionPB>,
+//         type_option: &Option<MultiSelectTypeOptionPB>,
-        cell_content_provider: &dyn GroupCellContentProvider,
+//         cell_content_provider: &dyn GroupCellContentProvider,
-    ) -> Vec<Group> {
+//     ) -> HashMap<String, Group> {
-        todo!()
+//         todo!()
-    }
+//     }
-}
+// }
-
+//
-impl GroupAction for MultiSelectGroupController {
+// impl GroupAction for MultiSelectGroupController {
-    fn should_group(&mut self, content: &str, cell_bytes: CellBytes) -> bool {
+//     fn should_group(&self, content: &str, cell_bytes: CellBytes) -> bool {
-        todo!()
+//         todo!()
-    }
+//     }
-}
+// }