implemented collector for find_method

native_api_1c_macro/src/function_processing/collectors/find_method.rs

@@ -0,0 +1,51 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::function_processing::FuncDesc;
+
+use super::empty_func_collector_error;
+
+pub struct FindMethodCollector {
+    generated: Result<TokenStream, darling::Error>,
+}
+
+impl Default for FindMethodCollector {
+    fn default() -> Self {
+        Self {
+            generated: Err(empty_func_collector_error()),
+        }
+    }
+}
+
+impl<'a> FromIterator<(usize, &'a FuncDesc)> for FindMethodCollector {
+    fn from_iter<T: IntoIterator<Item = (usize, &'a FuncDesc)>>(iter: T) -> Self {
+        let mut find_method_body = TokenStream::new();
+
+        for (func_index, func_desc) in iter {
+            let name_literal = func_desc.name_literal.clone();
+            let name_ru_literal = func_desc.name_ru_literal.clone();
+
+            find_method_body.extend(quote! {
+                if native_api_1c::native_api_1c_core::ffi::string_utils::os_string_nil(#name_literal) == name { return Some(#func_index) };
+                if native_api_1c::native_api_1c_core::ffi::string_utils::os_string_nil(#name_ru_literal) == name { return Some(#func_index) };
+            });
+        }
+
+        let find_method_definition = quote! {
+            fn find_method(&self, name: &[u16]) -> Option<usize> {
+                #find_method_body
+                None
+            }
+        };
+
+        Self {
+            generated: Ok(find_method_definition),
+        }
+    }
+}
+
+impl FindMethodCollector {
+    pub fn generated(self) -> Result<TokenStream, darling::Error> {
+        self.generated
+    }
+}

native_api_1c_macro/src/function_processing/collectors/mod.rs

@@ -0,0 +1,14 @@
+use proc_macro2::TokenStream;
+
+use super::FuncDesc;
+use crate::utils::macros::tkn_err_inner;
+
+pub mod find_method;
+
+pub trait FunctionCollector<'a>: FromIterator<(usize, &'a FuncDesc)> + Default {
+    fn release(&self) -> Result<TokenStream, darling::Error>;
+}
+
+pub fn empty_func_collector_error() -> darling::Error {
+    tkn_err_inner!("No functions found", &proc_macro2::Span::call_site())
+}

native_api_1c_macro/src/function_processing/mod.rs

@@ -7,6 +7,7 @@ use crate::{
     constants::{BLOB_TYPE, BOOL_TYPE, DATE_TYPE, F64_TYPE, I32_TYPE, STRING_TYPE, UNTYPED_TYPE},
 };
 
+pub mod collectors;
 pub mod generate;
 pub mod parse;
 

native_api_1c_macro/src/function_processing/parse.rs

@@ -99,8 +99,8 @@ impl FromField for FuncDesc {
             };
         };
 
-        let name_literal = str_literal_token(&func_meta.name, &field_ident)?;
+        let name_literal = str_literal_token(&func_meta.name, field_ident)?;
-        let name_ru_literal = str_literal_token(&func_meta.name_ru, &field_ident)?;
+        let name_ru_literal = str_literal_token(&func_meta.name_ru, field_ident)?;
 
         Ok(Self {
             ident: field_ident.to_owned(),

native_api_1c_macro/src/lib.rs

@@ -3,7 +3,10 @@ use proc_macro2::{Ident, TokenStream};
 use quote::{quote, ToTokens};
 use syn::{parse_macro_input, DeriveInput};
 
-use function_processing::{generate::func_call_tkn, parse::parse_functions, ParamType, ReturnType};
+use function_processing::{
+    collectors::find_method::FindMethodCollector, generate::func_call_tkn, parse::parse_functions,
+    ParamType, ReturnType,
+};
 use props_processing::{generate::param_ty_to_ffi_set, parse::parse_props};
 use utils::{
     macros::{tkn_err, tkn_err_inner},
@@ -122,7 +125,10 @@ fn build_impl_block(input: &DeriveInput) -> Result<proc_macro2::TokenStream, dar
         }
     }
 
-    let mut find_func_body = quote! {};
+    let func_iter = functions.iter().enumerate();
+
+    let find_method_definition = func_iter.collect::<FindMethodCollector>().generated()?;
+
     let mut get_func_name_body = quote! {};
     let mut has_ret_val_body = quote! {};
     let mut get_n_params_body = quote! {};
@@ -252,13 +258,10 @@ fn build_impl_block(input: &DeriveInput) -> Result<proc_macro2::TokenStream, dar
                 #is_prop_writable_body
                 false
             }
+            #find_method_definition
             fn get_n_methods(&self) -> usize {
                 #number_of_func
             }
-            fn find_method(&self, name: &[u16]) -> Option<usize> {
-                #find_func_body
-                None
-            }
             fn get_method_name(&self, num: usize, alias: usize) -> Option<Vec<u16>> {
                 #get_func_name_body
                 None