shm_rs/static_scheme/

scheme.rs

/*-
 * shm-rs - a scheme serialization lib
 * Copyright (C) 2021  Aleksandr Morozov
 * 
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 *  file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

use std::borrow::Borrow;
use std::sync::Arc;
use std::fmt;
use std::path::PathBuf;
use indexmap::IndexSet;
use linked_hash_map::LinkedHashMap;
use std::collections::{HashSet, HashMap};
use std::collections::hash_map;
use std::cell::Cell;
use std::hash::{Hash, Hasher};

use serde::{Serialize, Deserialize};

use crate::common::{self, some_kind_of_lowercase_first_letter, prepare_enum_variant};
use crate::lexer::lexer_node::{NodeInteger, NodeLongInteger};
use crate::serializator::serializator::*;
use crate::static_scheme::generator::RustCodeEnumType;
use crate::LexerInfo;

use super::error::{self, StaticSchemeRes};
use super::generator::{RustCode, RustCodeDefineType, RustCodeFields, RustCodeItem, RustCodeItemDataType, RustCodeItemStruct};

bitflags! {
    /// Flags  which  control  the  operation  of openlog() and 
    /// subsequent calls to syslog.
    #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
    pub struct ProcFlags: u64
    {
        /// Allow the Procedure to be optional (args can not be optional)
        const FLAG_OPTIONAL = 1;

        /// Allow the procedure to be repeated (args can not be repeated)
        const FLAG_COLLECTION = 2;
    }
}



/// Defines a type of the (f/vector) field. Used by the `generator.rs`
/// in order to generate Rust structs and enums fields.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum VectorSerializType
{
    /// Generate field type as [Vec]
    Array, 
    /// Generate field type as [HashSet]
    Hashset,
    /// Generate field type as [IndexSet]
    Indexset
}

/// An argument data type.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum ArgDataType
{
    None,
    Symbol,
    String,
    Int,
    UInt,
    LongInt,
    LongUint,
    Boolean,
    Vector,
    Range,
    RangeInc,
    Variable,
    Entity,
    Enumerator,
    AutoType
}

impl Default for ArgDataType
{
    fn default() -> Self 
    {
        return Self::None;
    }
}

impl ArgDataType
{
    /// Returns true if the datatype requires an inner type (type of collected args)
    pub fn has_subtype(&self) -> bool
    {
        return 
            *self == Self::Vector || *self == Self::Range || 
            *self == Self::RangeInc || *self == Self::Symbol;
    }
}

impl fmt::Display for ArgDataType 
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result 
    {
        match *self 
        {
            Self::None => write!(f, "Not Defined"),
            Self::Symbol => write!(f, "Symbol"),
            Self::String => write!(f, "String"),
            Self::Int => write!(f, "Int"),
            Self::UInt => write!(f, "Uint"),
            Self::LongInt => write!(f, "LongInt"),
            Self::LongUint => write!(f, "LongUint"),
            Self::Boolean => write!(f, "Boolean"),
            Self::Vector => write!(f, "Vector"),
            Self::Range => write!(f, "Range"),
            Self::RangeInc => write!(f, "RangeInc"),
            Self::Variable => write!(f, "Variable"),
            Self::Entity => write!(f, "Entity"),
            Self::Enumerator => write!(f, "Enumerator"),
            Self::AutoType => write!(f, "Auto-type"),
        }
    }
}

/// A generic data type for dynamic scheme.
#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum GenericDataTypes
{
    None,
    Symbol(Box<GenericDataTypes>, LexerInfo),
    String(String, LexerInfo),
    Int(NodeInteger, LexerInfo),
    LongInt(NodeLongInteger, LexerInfo),
    Boolean(bool, LexerInfo),
    Variable(String, LexerInfo), // ext
    Entity(String, LexerInfo), // ext
    Enumerator(String, String, LexerInfo),
    Vector(Vec<GenericDataTypes>, LexerInfo),
    Range(Box<GenericDataTypes>, Box<GenericDataTypes>, LexerInfo),
    RangeIncl(Box<GenericDataTypes>, Box<GenericDataTypes>, LexerInfo),
    AnyValWrap(Box<GenericDataTypes>, LexerInfo)
}

impl Default for GenericDataTypes
{
    fn default() -> Self 
    {
        return Self::None;
    }
}

impl fmt::Display for GenericDataTypes 
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result 
    {
        match *self 
        {
            Self::None => 
                write!(f, "None"),
            Self::Symbol(ref r, ref li) => 
                write!(f, "Symbol({}: {})", r, li),
            Self::String(ref r, ref li) => 
                write!(f, "String({}: {})", r, li),
            Self::Int(ref r, ref li) => 
                write!(f, "Int({}: {})", r, li),
            Self::LongInt(ref r, ref li) => 
                write!(f, "LongInt({}: {})", r, li),
            Self::Boolean(ref r, ref li) => 
                write!(f, "Boolean({}: {})", r, li),
            Self::Vector(ref r, ref _li) => 
            {
                write!(f, "Vector(")?;
                for i in r.iter()
                {
                    write!(f, "{}", i)?;
                }
                write!(f, ")")
            },
            Self::Range(ref l, ref r, ref li) =>
                write!(f, "Range({}..{}): {}", l, r, li),
            Self::RangeIncl(ref l, ref r, ref li) =>
                write!(f, "RangeIncl({}..={}): {}", l, r, li),
            Self::Variable(ref var, ref li) => 
                write!(f, "Variable(${}): '{}'", var, li),
            Self::Entity(ref ent, ref li) => 
                write!(f, "Entity(@{}): '{}'", ent, li),
            Self::Enumerator(ref enum_name, ref enum_item, ref li) => 
                write!(f, "Enumerator({}::{}): '{}'", enum_name, enum_item, li),
            Self::AnyValWrap(ref anyval, ref li) =>
                write!(f, "AnyValue({}): '{}'", anyval, li),
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PathResolve
{
    Proc, 
    Struct,
}

/// This struct contains information about the [Serializator] instance
/// which is defined in scheme and starting with (serialization "name" ...).
#[derive(Debug, Serialize, Deserialize)]
pub struct Serializator
{
    /// Title of the serializator
    name: Arc<String>, 

    /// The document root
    root_proc: Option<Arc<Procedure>>,

    /// All declared procedures
    procedures: HashMap<Arc<String>, Arc<Procedure>>,

    /// All declared Defines
    defines: HashMap<Arc<String>, Arc<Define>>,

    /// All declared enums
    enum_defines: HashMap<Arc<String>, Arc<DefineEnum>>,

    /// A root structure of serializer
    root_ser_structure: Option<Arc<Structure>>,

    /// All enumerators serialization data
    enumeratos: Vec<Arc<Enumerator>>,

    /// All structures serialization data
    structs: Vec<Arc<Structure>>,

    /// A path to file which was used to generate this instance
    file_path: Option<PathBuf>,
}

impl fmt::Display for Serializator
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}", self.name)
    }
}

/// A dummy clone. This instance must never be clonned.
impl Clone for Serializator 
{
    fn clone(&self) -> Self 
    {
        panic!("Asserion trap: Serializator must never be cloned! \
                Implementation Clone for Serializator is used to comply \
                with compilter requirments.");
        /*return Self 
            {
                name: self.name.clone(), 
                root_proc: None, 
                procedures: HashMap::new(), 
                defines: HashMap::new(),
                root_ser_structure: None,    
                enumeratos: Vec::new(),
                structs: Vec::new(),
            };*/
    }
}

impl Serializator
{
    /// Returned instead of path when path is None
    pub const SERIALIZATOR_FROM_MEMORY_PATH: &'static str = "from memory";

    /// Creates new instance of serializator and sets the `name` 
    /// provided in the scheme.
    pub 
    fn new(name: String) -> Self
    {
        return 
            Self 
            {
                name: Arc::new(name), 
                root_proc: None, 
                procedures: HashMap::new(), 
                defines: HashMap::new(),
                enum_defines: HashMap::new(),
                root_ser_structure: None,
                enumeratos: Vec::new(),
                structs: Vec::new(),
                file_path: None,
            };
    }

    /// Sets to the created instance a path to the file which was used to 
    /// generate current instance.
    pub 
    fn set_file_path(&mut self, file_path: Option<PathBuf>)
    {
        self.file_path = file_path;
    }

    /// Returns a reference to [PathBuf] inside [Option]. It contains the path to the
    /// file which was used to build the instance.
    pub 
    fn get_file_path(&self) -> Option<&PathBuf>
    {
        return self.file_path.as_ref();
    }

    /// Returns a path or constant SERIALIZATOR_FROM_MEMORY_PATH if
    /// it was generated from memory.
    pub 
    fn get_file_path_string_safe(&self) -> String
    {
        return 
            self
                .file_path
                .as_ref()
                .map_or(
                    Self::SERIALIZATOR_FROM_MEMORY_PATH.to_string(), 
                    |s| s.display().to_string()
                );
    }

    /// Returns a list of references to the [Define] instance by the defined parameters.
    /// 
    /// The [Define] instance is defined to be used in `proc_name` procedure and contain
    /// data with the exact `arg_dt` data type.
    /// 
    /// # Arguments
    /// 
    /// * `proc_name` - a name of the procedure.
    /// 
    /// * `arg_dt` - a [ArgDataType] data type.
    /// 
    /// # Return
    /// 
    /// A [Vec] of [Rc][Define] items is returned.
    pub 
    fn get_defines_by_proc_dt(&self, proc_name: &String, arg_dt: ArgDataType) -> Vec<Arc<Define>>
    {
        let mut defs: Vec<Arc<Define>> = Vec::new();

        for (_defn, defk) in self.defines.iter()
        {
            if defk.is_in_proc_scope(proc_name) == true && defk.get_datatype() == arg_dt
            {
                defs.push(defk.clone());
            }
        }

        return defs;
    }

    pub 
    fn resolve_path_to(&self, source: Arc<Procedure>, path_to_label: &[String], 
        full_path_to_lbl: &[String], is_enum: bool, path_last_len: usize) -> Result<(Arc<Procedure>, Arc<ForegnProc>), String>
    {
        // current path item
        let p = &path_to_label[0];

        // get the [ForegnProc] by the path item
        match source.procs.get(p)
        {
            Some(r) => 
            {
                // if this is last item, then search for the serialization description
                if is_enum == true && path_to_label.len() == 1
                {
                    return Ok((source.clone(), r.clone()));
                }

                // structs must not have more than one `procedure` defined
                // in (proc) of `procedure`
                if r.foregn_names.len() > 1
                {
                    return Err(
                        format!("found item at: '{}', full path: '{}' is not a structure because allows \
                            more than one variant: '{}'", p, error::convert_list(full_path_to_lbl), 
                            error::convert_hashset(&r.foregn_names, " "))
                    );
                }

                // convert to list (to extract) item
                let foregn_names: Vec<String> = 
                    r.foregn_names.iter().map(|f| f.clone()).collect();

                // get [Procedure] from list by foreign_name
                // (resolving ForegnProc)
                let proc = 
                    self
                        .procedures
                        .get(&foregn_names[0])
                        .ok_or_else(|| 
                            format!("procedure named: '{}', label path: '{}' does not exist in list of \
                                procedures", &foregn_names[0], error::convert_list(full_path_to_lbl))
                        )?
                        .clone();

                // if not last item in the path then repeat operation
                if path_to_label.len() > path_last_len || is_enum == true
                {
                    return self.resolve_path_to(proc, &path_to_label[1..], full_path_to_lbl, is_enum, path_last_len);
                }
                else
                {
                    return Ok((proc, r.clone()));
                }  
            }
            None => 
            {
                // procedure was not found in current `source`.
                return Err(
                    format!("path label not found: '{}', on chain: '{}', procedure \
                        endpoint: '{}' for structure", p, error::convert_list(full_path_to_lbl), source.get_name())
                );
            },
        }
    }


    /// Searches for a [Structure] (and [Procedure]) from the point specified by
    /// argument `source` which is [Procedure]. 
    /// 
    /// This function is recursive!
    /// 
    /// # Arguments
    /// 
    /// * `source` - a point from where the item from argument `path_to_label`
    ///     is resolved.
    /// 
    /// * `path_to_label` - a path (by labels) to the target.
    /// 
    /// # Returns
    /// 
    /// Returns a [SchemeResult] where:
    /// * On success returns [Result::Ok] with reference to [Structure] and [Rc]
    ///  to [Procedure]
    /// 
    /// * On error, returns [Result::Err] with error description. 
    pub 
    fn resolve_path_to_struct(
        &self, 
        source: Arc<Procedure>, 
        path_to_label: &[String],
        full_path_to_lbl: &[String],
    ) -> Result<(Arc<Structure>,Arc<Procedure>), String>
    {
        let (proc, _) = self.resolve_path_to(source, path_to_label, full_path_to_lbl, false, 1)?;

        // return the tuple with struct info and Procedure
        return Ok(
            (self.get_serialization_struct_by_procname(proc.get_name())?, proc)
        );
    }

    /// Searches for the [Procedure] instance. A starting point is
    ///  `source`. A path is `full_path_to_lbl`. `path_to_label` is 
    ///  a recursivly modified list from where on each recursion
    ///  an item is removed.
    /// 
    /// # Returns
    /// 
    /// An optional reference to [Structure] is returned in case if
    ///  procedure is defined with structure.
    pub 
    fn resolve_path_to_proc(
        &self, 
        source:Arc<Procedure>, 
        path_to_label: &[String],
        full_path_to_lbl: &[String],
    ) -> Result<(Option<Arc<Structure>>,Arc<Procedure>), String>
    {
        let (proc, _) = self.resolve_path_to(source, path_to_label, full_path_to_lbl, false, 1)?;
                   
        // return the tuple with struct info and Procedure
        return Ok(
            (self.get_serialization_struct_by_procname_opt(proc.get_name()), proc)
        );
    }

    /// Searches for a [Enumerator] (and [Procedure]) from the point specified by
    /// argument `source` which is [Procedure]. 
    /// 
    /// This function is recursive!
    /// 
    /// # Arguments
    /// 
    /// * `source` - a point from where the item from argument `path_to_label`
    ///     is resolved.
    /// 
    /// * `path_to_label` - a path (by labels) to the target.
    /// 
    /// # Returns
    /// 
    /// Returns a [SchemeResult] where:
    /// * On success returns [Result::Ok] with reference to [Enumerator] and [Rc]
    ///  to [Procedure]
    /// 
    /// * On error, returns [Result::Err] with error description. 
    pub 
    fn resolve_path_to_enum(
        &self, 
        source:Arc<Procedure>, 
        path_to_label: &[String],
        full_path_to_lbl: &[String],
    ) -> Result<(Arc<Enumerator>,Arc<Procedure>), String>
    {
        let (proc, forn_proc) = self.resolve_path_to(source, path_to_label, full_path_to_lbl, true, 1)?;

        let enumer = self.find_enum_by_procs(&forn_proc)?;

        return Ok((enumer, proc));
    }

    /// Searches for the enumerator serialization description by the 
    /// [ForegnProc] `foreign_proc` names. Each serialization description
    /// of enums serializes only specified procedures. Also those procedures
    /// are specified in `(proc)` of the `(procedure)` which is a [ForegnProc].
    /// So, the procedures specified in `(proc)` must match what is serialized
    /// by the enum serialization description.
    /// 
    /// # Arguments
    /// 
    /// * `foreign_proc` - a reference to the [ForegnProc] which is paired to 
    ///     enum serialization description [Enumerator]
    /// 
    /// # Returns
    /// 
    /// A function returns [SchemeResult] with the following inner types:
    /// 
    /// * [Result::Ok] - with the reference to [Enumerator] if found
    /// 
    /// * [Result::Err] - with error description. 
    fn find_enum_by_procs(&self, foreign_proc: &ForegnProc) -> Result<Arc<Enumerator>, String>
    {
        let mut cnt: usize = 0;
        let mut last_found: Option<Arc<Enumerator>> = None;

        'ext: for enm_itm in self.enumeratos.iter()
        {
            let map: HashSet<String> = 
                enm_itm
                    .get_enum_procs_list()
                    .iter()
                    .map(|p| p.clone())
                    .collect();

            for for_proc_name in foreign_proc.foregn_names.iter()
            {
                if map.contains(for_proc_name) == false
                {
                    cnt = 0;
                    continue 'ext;
                }

                cnt += 1;
            }

            if cnt == map.len()
            {
                return Ok(enm_itm.clone());
            }
            else
            {
                cnt = 0;

                match last_found
                {
                    Some(ref r) => 
                    {
                        if r.get_enum_procs_list().len() > map.len()
                        {
                            last_found = Some(enm_itm.clone());
                        }
                    },
                    None => 
                    {
                        last_found = Some(enm_itm.clone());
                    }
                }
            }
        }

        if let Some(r) = last_found
        {
            return Ok(r);
        }
        else
        {
            return Err(
                format!("can not find enum which serializes: '{}'", 
                    error::convert_hashset(&foreign_proc.foregn_names, " "))
            );
        }  
    }

    

    /// Searches for a [Argument] from the point specified by
    /// argument `source` which is [Procedure]. 
    /// 
    /// This function is recursive!
    /// 
    /// # Arguments
    /// 
    /// * `source` - a point from where the item from argument `path_to_label`
    ///     is resolved.
    /// 
    /// * `path_to_label` - a path (by labels) to the target.
    /// 
    /// # Returns
    /// 
    /// Returns a [SchemeResult] where:
    /// * On success returns [Result::Ok] with reference to [Rc] [Argument] 
    /// 
    /// * On error, returns [Result::Err] with error description. 
    pub 
    fn resolve_path_to_arg(
        &self, 
        source:Arc<Procedure>, 
        path_to_label: &[String],
        full_path_to_lbl: &[String]
    ) -> Result<Arc<Argument>, String>
    {
        // current path item
        let p = &path_to_label[0];

        let (proc, _) = 
            self.resolve_path_to(source, path_to_label, full_path_to_lbl, false, 2)?;

        let p = path_to_label.last().unwrap();
        
        let arg = 
            proc
                .args
                .get(p)
                .ok_or_else(|| 
                    format!("argument labeled as: '{}' was not found on path: '{}'", 
                        p, error::convert_list(full_path_to_lbl))
                )?
                .clone();


        return Ok(arg);
    }

    /// Generates a Rust code (structures and enums) from the root of the document.
    /// 
    /// # Arguments
    /// 
    /// * `rust_code` - a mutable reference to [RustCode] instance which is used to 
    ///     collect result.
    /// 
    /// # Returns 
    /// 
    /// A [SchemeResult] is returned.
    /// 
    /// * [Result::Ok] - if operation is successful.
    /// 
    /// * [Result::Err] - if operation has failed and error is returned.
    pub 
    fn generate_rust_code(&self, rust_code: &mut RustCode) -> Result<(), String>
    {
        // generate all enums for arguments first
        for (_, de) in self.enum_defines.iter()
        {
            let items: Vec<RustCodeEnumType> = 
                de
                    .enum_defs
                    .iter()
                    .map(|itm| {
                            RustCodeEnumType::Empty(prepare_enum_variant(itm.as_str()), None)
                        }
                    )
                    .collect();
        
            rust_code
                .add_item(
                    RustCodeItem
                        ::new_enum_arg(de.get_enum_name().as_str(), de.get_rust_code_gen(), items)
                );
        }

        // generate all symbols as static definitions
        for (_, de) in self.defines.iter()
        {
            let def = 
                RustCodeDefineType::make_from(de.get_datatype(), de.get_data())?;
            
            rust_code.add_item(RustCodeItem::new_define(de.get_name().as_str(), def, de.comment.clone()));
        }

        // current (root) serialization structure
        let cur_set_int = 
            self
                .get_root_ser()
                .ok_or_else(|| 
                    format!( 
                        "in file: '{}', root serialization is empty, nothing to do in '{}'", 
                            self.get_file_path_string_safe(),self.get_name()
                    )
                )?;

                // current (root) procedure
        let cur_proc_int = 
            self
                .get_root_proc()
                .ok_or_else(|| 
                    format!( 
                        "in file: '{}', root procedure is empty, nothing to do in '{}'", 
                            self.get_file_path_string_safe(),self.get_name()
                    )
                )?;

        // calling generator
        self
            .generate_rust_struct(rust_code, cur_set_int.clone(), cur_proc_int, true)
            .map_err(|e| 
                format!("generating Rust formatted structs failed: {}", e)
            )?;

        return Ok(());
    }

    /// Builds a structure from provided arguments. 
    /// 
    /// This function is recursive.
    /// 
    /// # Arguments
    /// 
    /// * `rust_code` - a mutable reference to [RustCode] instance which
    ///     is used to build code.
    /// 
    /// * `cur_set_int` - a reference to [Structure] which describes the 
    ///     serialization of the [Procedure] provided in arg `cur_proc_int`.
    /// 
    /// * `cur_proc_int` - a [Rc] to [Procedure] which describes how to 
    ///     read the config and which has a [Structure] description which
    ///     is passed in arg `cur_set_int`.
    /// 
    /// # Returns
    /// 
    /// A [SchemeResult] is returned.
    /// 
    /// * [Result::Ok] - if operation is successful.
    /// 
    /// * [Result::Err] - if operation has failed and error is returned.
    fn generate_rust_struct(
        &self, 
        rust_code: &mut RustCode,
        cur_set_int: Arc<Structure>, 
        cur_proc_int: Arc<Procedure>,
        is_root: bool,
    ) -> Result<(), String>
    {
        let mut fields: Vec<RustCodeItemStruct> = Vec::with_capacity(cur_set_int.get_fields_len());

        let field_first = 
            match cur_set_int.get_first_field()
            {
                Some(fdecl) => 
                {
                    fdecl.get_data_type() == &FieldTypes::Enum && fdecl.get_field_name().is_none() == true
                },
                None => false
            };

        if is_root == true && 
            cur_set_int.get_fields_len() == 1 && 
            field_first == true
        {
            let field = cur_set_int.get_first_field().unwrap();

            // assertion check
            if field.is_optional() == true
            {
                return Err(
                    format!("(root) procedure: '{}', field path: '{}' is 'optional', but anonymous \
                        field can not be optional in this case", cur_proc_int.get_name(), 
                        error::convert_list(field.get_path_to_label()))
                );
            }

            // don't create root structure, create an enum with the title

            let _ = 
                self
                    .generate_field(rust_code, field, cur_proc_int.clone(), None)
                    .map_err(|e| 
                        format!("{} procedure: '{}', path to label: '{}'", e, cur_proc_int.get_name(), 
                            error::convert_list(field.get_path_to_label()))
                    )?;
            
        }
        else
        {
            // list all fields
            for root_field in cur_set_int.get_fields_iter()
            {
                let field = 
                    self
                        .generate_field(rust_code, root_field, cur_proc_int.clone(), None)
                        .map_err(|e| 
                            format!("{} procedure: '{}', path to label: '{}'", e, cur_proc_int.get_name(), 
                                error::convert_list(root_field.get_path_to_label()))
                        )?;

                fields.push(field);
            }

            let rci = 
                RustCodeItem::new_struct(
                    cur_set_int.as_ref(),
                    fields, 
                    is_root,
                );
            
            rust_code.add_item(rci);
        }

        return Ok(());
    }

    /// Generates a field's (Rust) datatype.
    /// 
    /// # Arguments
    /// 
    /// * `rust_code` - a mutable reference to [RustCode] instance which
    ///     is used to build code.
    /// 
    /// * `field` - a reference to [FieldDecl] with the field description
    ///     from serialization information.
    /// 
    /// * `cur_proc_int` - a related [Procedure] to the serialized data.
    /// 
    /// # Returns
    /// 
    /// A [SchemeResult] is returned.
    /// 
    /// * [Result::Ok] with the [RustCodeItemDataType] as inner type which 
    ///     contains a field data type information.
    /// 
    /// * [Result::Err] with error description.
    pub 
    fn generate_field_data_type(
        &self, 
        rust_code: &mut RustCode, 
        field: &FieldDecl, 
        cur_proc_int:Arc<Procedure>,
        cur_enumer: Option<Arc<Enumerator>>
    ) -> Result<RustCodeItemDataType, String>
    {
        let field_datatype = 
            match field.get_data_type()
            {
                FieldTypes::String => 
                    RustCodeItemDataType::String,
                FieldTypes::Boolean => 
                    RustCodeItemDataType::Bool,
                FieldTypes::Int => 
                    RustCodeItemDataType::Int(field.get_int_width()),
                FieldTypes::UInt => 
                    RustCodeItemDataType::Uint(field.get_int_width()),
                FieldTypes::LongInt =>
                    RustCodeItemDataType::Int(field.get_int_width()),
                FieldTypes::LongUInt =>
                    RustCodeItemDataType::Uint(field.get_int_width()),
                FieldTypes::AnyType => 
                {
                    /*let foreign_arg = 
                        self.resolve_path_to_arg(cur_proc_int.clone(), field.get_path_to_label(), 
                            field.get_path_to_label())?;

                    let int_width = 
                        match foreign_arg.get_collection_type()
                        {
                            ArgDataType::UInt => field.get_int_width(),
                            ArgDataType::Int => field.get_int_width(),
                            _ => 
                                static_throw_text!("unexpected inner type for <anytype>, type: '{}'", 
                                    foreign_arg.get_collection_type())
                        };*/

                    rust_code.set_field_any(8);

                    RustCodeItemDataType::AnyType
                }, 
                FieldTypes::Range => 
                {
                    let foreign_arg = 
                        self.resolve_path_to_arg(cur_proc_int.clone(), field.get_path_to_label(), 
                            field.get_path_to_label())?;

                        
                    let sd_type = 
                        match foreign_arg.get_collection_type()
                        {
                            ArgDataType::UInt => 
                                RustCodeItemDataType::Uint(field.get_int_width()),
                            ArgDataType::Int => 
                                RustCodeItemDataType::Int(field.get_int_width()),
                            _ => 
                                return Err(
                                    format!("unexpected inner type for <range>, type: '{}'", 
                                        foreign_arg.get_collection_type())
                                )
                        };

                    RustCodeItemDataType::Range(Box::new(sd_type))
                },
                FieldTypes::RangeInc =>
                {
                    let foreign_arg = 
                        self.resolve_path_to_arg(cur_proc_int.clone(), field.get_path_to_label(), 
                            field.get_path_to_label())?;

                    let sd_type = 
                        match foreign_arg.get_collection_type()
                        {
                            ArgDataType::UInt => 
                                RustCodeItemDataType::Uint(field.get_int_width()),
                            ArgDataType::Int => 
                                RustCodeItemDataType::Int(field.get_int_width()),
                            _ => 
                                return Err(
                                    format!("unexpected inner type for <rangeinc>, type: '{}'", 
                                        foreign_arg.get_collection_type())
                                )
                        };

                    RustCodeItemDataType::RangeInclusive(Box::new(sd_type))
                },
                FieldTypes::Struct =>
                {
                    let (foregn_struct, foregn_proc) = 
                        self.resolve_path_to_struct(cur_proc_int.clone(), field.get_path_to_label(), 
                            field.get_path_to_label())?;
                    
                    self.generate_rust_struct(
                        rust_code, 
                        foregn_struct.clone(), 
                        foregn_proc, 
                        false
                    )?;

                    RustCodeItemDataType::Struct(foregn_struct.get_struct_name().get_name_1().to_string())
                },
                FieldTypes::Vector =>
                {
                    let inner_type = 
                        match field.get_data_inner_type(1)
                        {
                            FieldTypes::AnyType =>
                            {
                                rust_code.set_field_any(8);

                                RustCodeItemDataType::AnyType
                            },
                            FieldTypes::Struct =>
                            {
                                let (foregn_struct, foregn_proc) = 
                                    self.resolve_path_to_struct(cur_proc_int.clone(), field.get_path_to_label(), 
                                        field.get_path_to_label())?;

                                self.generate_rust_struct(rust_code, foregn_struct.clone(), 
                                    foregn_proc, false)?;

                                RustCodeItemDataType::Struct(foregn_struct.get_struct_name().get_name_1().to_string())
                            },
                            FieldTypes::ArgEnum =>
                            {
                                let foreign_arg = 
                                    self.resolve_path_to_arg(cur_proc_int.clone(), field.get_path_to_label(), 
                                        field.get_path_to_label())?;

                                    
                                if *foreign_arg.get_data_type() == ArgDataType::Enumerator
                                {
                                    return Err(
                                        format!("argument on the path: '{}' is not defined as `enumerator`", 
                                            field.get_path_to_label().join("/"))
                                    );
                                }
                    
                                match field.get_arg_enum_title()
                                {
                                    Some(r) => 
                                    {   
                                        let _ = 
                                        self.enum_defines
                                            .get(r)
                                            .ok_or_else(|| 
                                                format!("can not find argument enum name: '{}'", r)
                                            );

                                        RustCodeItemDataType::Enum(r.clone())
                                    },
                                    None => 
                                    {
                                        return Err(
                                            format!("enum name was not set, field: '{}'", field.get_field_name_safe())
                                        );
                                    }
                                }
                            },
                            FieldTypes::Enum =>
                            {
                                let (enumer, proced) = 
                                    self.resolve_path_to_enum(cur_proc_int.clone(), field.get_path_to_label(), 
                                        field.get_path_to_label())?;

                                if cur_enumer.is_some() == true && enumer.as_ref() == cur_enumer.as_ref().unwrap().as_ref()
                                {
                                    RustCodeItemDataType::Enum(enumer.get_enum_label().clone())
                                }
                                else
                                {
                                // todo. do not resolve duplicates
                                    self.generate_rust_enum(rust_code, enumer.clone(), proced)?;

                                    RustCodeItemDataType::Enum(enumer.get_enum_label().clone())
                                }
                            },
                            FieldTypes::Range =>
                            {
                                let foreign_arg = 
                                    self.resolve_path_to_arg(cur_proc_int.clone(), field.get_path_to_label(), 
                                        field.get_path_to_label())?;

                                let sd_type = 
                                    match foreign_arg.get_collection_type()
                                    {
                                        ArgDataType::UInt => 
                                            RustCodeItemDataType::Uint(field.get_int_width()),
                                        ArgDataType::Int => 
                                            RustCodeItemDataType::Int(field.get_int_width()),
                                        _ => 
                                            return Err(
                                                format!("unexpected inner type for <range>, type: '{}'", 
                                                    foreign_arg.get_collection_type())
                                            )
                                    };

                                RustCodeItemDataType::Range(Box::new(sd_type))
                            },
                            FieldTypes::RangeInc =>
                            {
                                let foreign_arg = 
                                    self.resolve_path_to_arg(cur_proc_int.clone(), field.get_path_to_label(), 
                                        field.get_path_to_label())?;

                                let sd_type = 
                                    match foreign_arg.get_collection_type()
                                    {
                                        ArgDataType::UInt => 
                                            RustCodeItemDataType::Uint(field.get_int_width()),
                                        ArgDataType::Int => 
                                            RustCodeItemDataType::Int(field.get_int_width()),
                                        _ => 
                                            return Err(
                                                format!("unexpected inner type for <rangeinc>, type: '{}'", 
                                                    foreign_arg.get_collection_type())
                                            )
                                    };

                                RustCodeItemDataType::RangeInclusive(Box::new(sd_type))
                            },
                            FieldTypes::String => 
                                RustCodeItemDataType::String,
                            FieldTypes::Boolean => 
                                RustCodeItemDataType::Bool,
                            FieldTypes::Int => 
                                RustCodeItemDataType::Int(field.get_int_width()),
                            FieldTypes::UInt => 
                                RustCodeItemDataType::Uint(field.get_int_width()),
                            FieldTypes::LongInt => 
                                RustCodeItemDataType::Int(field.get_int_width()),
                            FieldTypes::LongUInt => 
                                RustCodeItemDataType::Uint(field.get_int_width()),
                            FieldTypes::None => 
                                return Err(format!("can not serialize field with type None")),
                            FieldTypes::Optional => 
                                return Err(format!("can not serialize field with type Optional")),
                            FieldTypes::Vector => 
                                return Err(format!("field with vector in vector is not allowed")),
                        };

                    RustCodeItemDataType::Vector(Box::new(inner_type), field.get_vector_serial_type())
                },
                FieldTypes::Enum =>
                {
                    // search the enumerator searilization infromation
                    let (enumer, proced) = 
                        self.resolve_path_to_enum(cur_proc_int.clone(), field.get_path_to_label(), 
                            field.get_path_to_label())?;

                    self.generate_rust_enum(rust_code, enumer.clone(), proced)?;

                    RustCodeItemDataType::Enum(enumer.get_enum_label().clone())
                },
                FieldTypes::ArgEnum =>
                {
                    let foreign_arg = 
                        self.resolve_path_to_arg(cur_proc_int.clone(), field.get_path_to_label(), 
                            field.get_path_to_label())?;
                    
                    if *foreign_arg.get_data_type() != ArgDataType::Enumerator
                    {
                        return Err(
                            format!("argument on the path: '{}' is not defined as `enumerator`", 
                                field.get_path_to_label().join("/"))
                        );
                    }

                    match field.get_arg_enum_title()
                    {
                        Some(r) => 
                        {   
                            let _ = 
                            self.enum_defines
                                .get(r)
                                .ok_or_else(|| 
                                    format!("can not find argument enum name: '{}'", r)
                                );

                            RustCodeItemDataType::Enum(r.clone())
                        },
                        None => 
                        {
                            return Err(
                                format!("enum name was not set, field: '{}'", field.get_field_name_safe())
                            );
                        }
                    }
                },
                FieldTypes::None => 
                    return Err(format!("can not serialize field with type None")),
                FieldTypes::Optional => 
                    return Err(format!("can not serialize field with type Optional")),
            };

        
        return Ok(field_datatype);
    }

    /// Forms a field of the structure with field name and datatype.
    /// 
    /// Calls `generate_field_data_type()` to generate the field type.
    /// 
    /// # Arguments
    /// 
    /// * `rust_code` - a mutable reference to [RustCode] instance which
    ///     is used to build code.
    /// 
    /// * `field` - a reference to [FieldDecl] with the field description
    ///     from serialization information.
    /// 
    /// * `cur_proc_int` - a related [Procedure] to the serialized data.
    /// 
    /// * `cur_enumer` - 
    /// 
    /// # Returns
    /// 
    /// A [SchemeResult] is returned.
    /// 
    /// * [Result::Ok] with the [RustCodeItemStruct] as inner type which 
    ///     contains a field data type information.
    /// 
    /// * [Result::Err] with error description.
    fn generate_field(
        &self, 
        rust_code: &mut RustCode, 
        field: &FieldDecl, 
        cur_proc_int: Arc<Procedure>,
        cur_enumer: Option<Arc<Enumerator>>
    ) -> Result<RustCodeItemStruct, String>
    {
        let is_enum = cur_enumer.is_some();
        let field_datatype = self.generate_field_data_type(rust_code, field, cur_proc_int, cur_enumer)?;

        return Ok(
            RustCodeItemStruct
                ::new(field.get_field_name(), field.is_optional(), field.get_field_comment(),
                    field_datatype, is_enum
                )
        );
    }

    /// Builds an enumertator from provided arguments. 
    /// 
    /// This function is recursive.
    /// 
    /// # Arguments
    /// 
    /// * `rust_code` - a mutable reference to [RustCode] instance which
    ///     is used to build code.
    /// 
    /// * `enumer` - a reference to [Enumerator] which describes the 
    ///     serialization of the [Procedure] provided in arg `proced`
    ///     as an enum.
    /// 
    /// * `proced` - a [Rc] to [Procedure] which describes how to 
    ///     read the config and which has a [Structure] description which
    ///     is passed in arg `cur_set_int`.
    /// 
    /// # Returns
    /// 
    /// A [SchemeResult] is returned.
    /// 
    /// * [Result::Ok] - if operation is successful.
    /// 
    /// * [Result::Err] - if operation has failed and error is returned.
    fn generate_rust_enum(
        &self, 
        rust_code: &mut RustCode, 
        enumer:Arc<Enumerator>, 
        _proced:Arc<Procedure>
    ) -> Result<(), String>
    {
        // reserve memory for the fields
        let mut enums: Vec<RustCodeEnumType> = Vec::with_capacity(enumer.get_enum_opts_len());

        // each enumerator options
        for enm in enumer.get_enum_opts_iter()
        {
            match enm
            {
                // An enum option without inner data.
                EnumOpt::Anonymous{ proc_rename, comment, .. } => 
                {
                    let rcet = RustCodeEnumType::new_anon(proc_rename, comment.clone());

                    enums.push(rcet);
                },
                // An enum option with tuple data.
                EnumOpt::Vector{ proc_name, proc_rename, fields, comment } => 
                {
                    // reserve memory for the tuple items
                    let mut items: Vec<RustCodeItemDataType> = Vec::with_capacity(fields.len());

                    // get the [Procedure] by `proc_name` from the all known procedures
                    let proc_loc = 
                        self
                            .procedures
                            .get(proc_name)
                            .ok_or_else(|| 
                                format!("procedure named: '{}', does not exist in list of \
                                    procedures while serializing enum {} -> {}", proc_name, proc_name, proc_rename)
                            )?
                            .clone();

                    for field in fields.iter()
                    {
                        let field = 
                            self.generate_field_data_type(rust_code, field, proc_loc.clone(), Some(enumer.clone()))?;

                        items.push(field);
                    }

                    let rcet = RustCodeEnumType::new_vec(proc_rename, items, comment.clone());

                    enums.push(rcet);
                },
                // An enum option with structure data.
                EnumOpt::Structure { proc_name, proc_rename, structure, comment } => 
                {
                    // reserve memory for the fields
                    let mut items: Vec<RustCodeItemStruct> = Vec::with_capacity(structure.get_fields_len());

                    // get the [Procedure] by `proc_name` from the all known procedures
                    let proc_loc = 
                        self
                            .procedures
                            .get(proc_name)
                            .ok_or_else(|| 
                                format!("procedure named: '{}', does not exist in list of \
                                    procedures while serializing enum {} -> {}", proc_name, proc_name, proc_rename)
                            )?
                            .clone();

                    for root_field in structure.get_fields_iter()
                    {
                        let field = 
                            self
                                .generate_field(rust_code, root_field, proc_loc.clone(), Some(enumer.clone()))
                                .map_err(|e| 
                                    format!("{} procedure: '{}', path to label: '{}'", e, proc_name, 
                                        error::convert_list(root_field.get_path_to_label()))
                                )?;

                        items.push(field);
                    }
                    
                    let rcet = RustCodeEnumType::new_fields(proc_rename, items, comment.clone());
                    //self.generate_rust_struct_anon(str_buffers, &mut str_buffer, structure, proc_loc.clone())?;

                    enums.push(rcet);
                }
            }
        }

        rust_code.add_item(
            RustCodeItem::new_enum(enumer.as_ref(),enums)
        );

        return Ok(());
    }

    /// Returns a title of the serializer.
    pub 
    fn get_name(&self) -> &String
    {
        return &self.name;
    }

    /// Clones a title of the serializer.
    pub 
    fn clone_name(&self) ->Arc<String>
    {
        return self.name.clone();
    }

    /// Declares new procedure
    pub 
    fn new_root_proc(&mut self, proc: Procedure) -> Result<(), String>
    {
        if self.root_proc.is_none() == false
        {
            return Err(
                format!("procedure: '{}' already exists in root of serializer: '{}'", 
                    proc.get_name(), self.name)
            );
        }

        self.root_proc = Some(Arc::new(proc));

        return Ok(());
    }

    /// Declares new procedure.
    pub 
    fn new_proc(&mut self, proc: Procedure) -> Result<(), String>
    { 
        if self.procedures.contains_key(proc.get_name()) == true
        {
            return Err(
                format!("procedure: '{}' already exists in serializer: '{}'", 
                    proc.get_name(), self.name)
            );
        }

        self.procedures.insert(proc.clone_name(), Arc::new(proc));

        return Ok(());
    }

    /// Declares symbol.
    pub 
    fn symbol_define(&mut self, def: Define) -> Result<(), String>
    {
        if self.defines.contains_key(def.get_name()) == true
        {
            return Err(
                format!("redefinition of the define label: '{}' in serializer: '{}'", 
                    def.get_name(), self.name)
            );
        }

        self.defines.insert(def.clone_name(), Arc::new(def));

        return Ok(());
    }

    pub 
    fn symbol_enum_define(&mut self, def: DefineEnum) -> Result<(), String>
    {
        if self.enum_defines.contains_key(def.get_enum_name()) == true
        {
            return Err(
                format!("redefinition of the enum-define label: '{}' in serializer: '{}'", 
                    def.get_enum_name(), self.name)
            );
        }

        self.enum_defines.insert(def.clone_enum_name(), Arc::new(def));

        return Ok(());
    }

    /// Sets the root serialization descriptor.
    pub 
    fn set_root_serialization_struct(&mut self, ser: Structure) -> Result<(), String>
    {
        if self.root_ser_structure.is_some() == true
        {
            return Err(
                format!("redefinition of the root struct: '{}' in serializer: '{}'", 
                    ser.get_struct_name(), self.name)
            );
        }
        let rc_ser = Arc::new(ser);

        self.root_ser_structure = Some(rc_ser.clone());
        self.structs.push(rc_ser);

        return Ok(());
    }
    
    /// Declares serialization information for structure.
    pub 
    fn add_serialization_struct(&mut self, ser: Structure)
    {
        self.structs.push(Arc::new(ser));
    }

    /// Declares a serialization information for enum.
    pub 
    fn add_serialization_enum(&mut self, enm: Enumerator)
    {
        self.enumeratos.push(Arc::new(enm));
    }

    /// Searches for the [Structure] by the `proc_name` which is a procedure 
    /// name.
    /// 
    /// # Arguments
    /// 
    /// * `proc_name` - a reference to [String] which contains title of the
    ///     procedure.
    /// 
    /// # Returns
    /// 
    /// A [SchemeResult] with result is returned.
    /// 
    /// - [Result::Ok] with reference to [Structure] is returned on success.
    /// 
    /// - [Result::Err] with error description is returned.
    pub 
    fn get_serialization_struct_by_procname(&self, proc_name: &String) -> Result<Arc<Structure>, String>
    {
        for i in self.structs.iter()
        {
            if i.contain_proc_name(proc_name) == true
            {
                return Ok(i.clone());
            }
        }

        return Err(
            format!("no struct serializes procedure: '{}' was found in serializer: '{}'", 
                proc_name, self.get_name())
        );
    }

    pub 
    fn get_serialization_struct_by_procname_opt(&self, proc_name: &String) -> Option<Arc<Structure>>
    {
        for i in self.structs.iter()
        {
            if i.contain_proc_name(proc_name) == true
            {
                return Some(i.clone());
            }
        }

        return None;
    }

    pub 
    fn get_serialization_struct_by_name(&self, struct_name: &str) -> Result<Arc<Structure>, String>
    {
        for i in self.structs.iter()
        {
            if i.get_struct_name() == struct_name
            {
                return Ok(i.clone());
            }
        }

        return Err(
            format!("no struct with name: '{}' was found in serializer: '{}'", 
                struct_name, self.get_name())
        );
    }

    /// Searches for the [Enumerator] serialization information for enum
    /// by the `procedure name` which `enumerator` instance is serializing.
    /// 
    /// # Arguments
    /// 
    /// * `proc_name` - a reference to [String] which points to procedure name.
    /// 
    /// # Returns
    /// 
    /// A [SchemeResult] is returned with:
    /// 
    /// * [Result::Ok] on success with the reference to [Enumerator]
    /// 
    /// * [Result::Err] on error with the error description
    pub 
    fn get_serialization_enum_by_procname(&self, proc_name: &String) -> Result<&Enumerator, String>
    {
        for i in self.enumeratos.iter()
        {
            if i.is_proc_name_presents(proc_name) == true
            {
                return Ok(i);
            }
        }

        return Err(format!("no enum serializes procedure: '{}' was found in serializer: '{}'", proc_name, self.get_name()));
    }

    pub 
    fn get_procedure_by_name(&self, proc_name: &String) -> Option<&Arc<Procedure>>
    {
        return self.procedures.get(proc_name);
    }

   /* pub 
    fn get_serialization_enum_by_rename_procname(&self, proc_rename: &String) -> SerializationPartialRes<&Enumerator>
    {
        for i in self.enumeratos.iter()
        {
            if i.
            if i.get_enum_opt_by_rename_procname(proc_rename).is_some() == true
            {
                return Ok(i);
            }
        }

        ser_partial_throw!("no enum serializes procedure: '{}' was found in serializer: '{}'", proc_name, self.get_name());
    }*/

    /// Returns root serialization structure if was defined
    pub 
    fn get_root_ser(&self) -> Option<Arc<Structure>>
    {
        return self.root_ser_structure.clone();
    }

    /// Returns root procedure.
    /// 
    /// The [Rc] inside Option is cloned.
    pub 
    fn get_root_proc(&self) -> Option<Arc<Procedure>>
    {
        return self.root_proc.clone();
    }

    /// Returns iterator to defined symbols.
    pub 
    fn get_define_list_iter(&self) -> hash_map::Iter<'_, Arc<String>, Arc<Define>>
    {
        return self.defines.iter();
    }

    /// Returns iterator to defined enum symbols.
    pub 
    fn get_enum_define_list_iter(&self) -> hash_map::Iter<'_, Arc<String>, Arc<DefineEnum>>
    {
        return self.enum_defines.iter();
    }

    pub 
    fn get_enum_define_value_by_key(&self, key: &String) -> Option<&Arc<DefineEnum>>
    {
        return self.enum_defines.get(key);
    }

    /// Returns iterator to all defined procedures.
    pub 
    fn get_procedure_list_iter(&self) -> hash_map::Iter<'_,Arc<String>, Arc<Procedure>>
    {
        return self.procedures.iter();
    }
}

/// A struct which holds information about definitions.
#[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct DefineEnum
{
    /// An symbol name
    enum_name:Arc<String>,  

    /// Enum fields
    enum_defs: IndexSet<String>,

    /// An items related to code generation
    rust_code_gen: RustCodeFields,
}

impl Hash for DefineEnum
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.enum_name.hash(state);
    }
}

impl PartialEq<str> for DefineEnum
{
    fn eq(&self, other: &str) -> bool 
    {
        return self.enum_name.as_str() == other;
    }
}

impl PartialEq<String> for DefineEnum
{
    fn eq(&self, other: &String) -> bool 
    {
        return self.enum_name.as_str() == other.as_str();
    }
}

impl Borrow<str> for DefineEnum
{
    fn borrow(&self) -> &str 
    {
        return &self.enum_name;
    }
}

impl Borrow<String> for DefineEnum
{
    fn borrow(&self) -> &String 
    {
        return &self.enum_name;
    }
}

impl fmt::Display for DefineEnum
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "enum_name: '{}', enum_defs: '{}'", 
            self.enum_name, 
            self.enum_defs.iter().map(|f| f.as_str()).collect::<Vec<&str>>().join(","), 
        )
    }
}

impl Clone for DefineEnum 
{
    fn clone(&self) -> Self 
    {
        panic!("Asserion trap: Define must never be cloned! \
                Implementation Clone for Define is used to comply \
                with compilter requirments.");
    }
}

impl DefineEnum
{
    pub 
    fn new(enum_name: String, enum_defs: IndexSet<String>) -> Result<Self, String>
    {
        if enum_defs.len() == 0
        {
            return Err(format!("(define-enum \"{}\") is empty!", enum_name));
        }

        return Ok( 
            Self
            { 
                enum_name: 
                    Arc::new(enum_name), 
                enum_defs: 
                    enum_defs,
                rust_code_gen: 
                    RustCodeFields::default(),
            } 
        );
    }

    
    pub 
    fn get_enum_name(&self) -> &String
    {
        return self.enum_name.as_ref();
    }

    pub 
    fn get_rust_code_gen(&self) -> &RustCodeFields
    {
        return &self.rust_code_gen;
    }

    pub 
    fn get_rust_code_gen_mut(&mut self) -> &mut RustCodeFields
    {
        return &mut self.rust_code_gen;
    }
    

    pub 
    fn clone_enum_name(&self) ->Arc<String>
    {
        return self.enum_name.clone();
    }

    pub 
    fn generate_enum_pairs(&self) -> (Vec<Arc<String>>, Vec<Arc<String>>)
    {
        let mut enum_symbol_pair: Vec<Arc<String>> = Vec::with_capacity(self.enum_defs.len());
        let mut enum_symbol: Vec<Arc<String>> = Vec::with_capacity(self.enum_defs.len());

        for ed in self.enum_defs.iter()
        {
            let upper_c = prepare_enum_variant(ed);
            let lower_c = some_kind_of_lowercase_first_letter(ed);

            enum_symbol_pair.push(Arc::new([self.enum_name.as_ref(), "::", upper_c.as_str()].concat()));
            enum_symbol_pair.push(Arc::new([self.enum_name.as_ref(), "::", lower_c.as_str()].concat()));
            enum_symbol.push(Arc::new(upper_c.to_string()));
            enum_symbol.push(Arc::new(lower_c.to_string()));
        }

        return (enum_symbol_pair, enum_symbol);
    }

    pub 
    fn present(&self, itm: &str) -> bool
    {
        return self.enum_defs.contains(itm);
    }

    pub 
    fn convert_to_dyn_scheme_def(&self, itm: &str) -> Option<&str>
    {
        for d in self.enum_defs.iter()
        {
            if prepare_enum_variant(d.as_str()) == itm
            {
                return Some(d.as_str());
            }
        }

        return None;
    }
}

/// A struct which holds information about definitions.
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct Define
{
    /// An symbol name
    name: Arc<String>, 

    /// Data it defines
    data: GenericDataTypes, 

    /// A data type
    data_type: ArgDataType,

    /// In which procedures can be used
    proc_binds: Option<HashSet<String>>,

    /// A comment for the const value in Rust code
    comment: Option<String>,
}

impl fmt::Display for Define
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "symbol: '{}', data: '{}', binds: '{}'", 
            self.name, self.data, 
            self.proc_binds
                .as_ref()
                .map_or(
                    "UNBIND".to_string(), 
                    |f| f.iter().map(|v| v.as_str()).collect::<Vec<&str>>().join(", ")
                )
        )
    }
}

impl Hash for Define
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.name.as_ref().hash(state);
    }
}

impl Eq for Define {}

impl PartialEq for Define 
{
    fn eq(&self, other: &Self) -> bool 
    {
        return 
            self.name.as_ref() == other.name.as_ref();
    }
}

impl Borrow<String> for Define
{
    fn borrow(&self) -> &String
    {
        return &self.name;
    }
}

impl Borrow<str> for Define
{
    fn borrow(&self) -> &str
    {
        return &self.name;
    }
}

impl Clone for Define 
{
    fn clone(&self) -> Self 
    {
        panic!("Asserion trap: Define must never be cloned! \
                Implementation Clone for Define is used to comply \
                with compilter requirments.");
    }
}

impl Define
{
    pub 
    fn new(name: String, dt_type: ArgDataType, data: GenericDataTypes, proc_binds_set: HashSet<String>) -> Self
    {
        let proc_binds = 
            if proc_binds_set.len() > 0
            {
                Some(proc_binds_set)
            }
            else
            {
                None
            };
    
        return Self{ name: Arc::new(name), data_type: dt_type, data, proc_binds, comment: None };
    }

    pub 
    fn clone_name(&self) -> Arc<String>
    {
        return self.name.clone();
    }

    pub 
    fn clone_data(&self) -> GenericDataTypes
    {
        return self.data.clone();
    }
    pub 
    fn set_comment(&mut self, comment: String)
    {
        self.comment.replace(comment);
    }

    pub 
    fn get_name(&self) -> &String
    {
        return &self.name;
    }

    pub 
    fn get_data(&self) -> &GenericDataTypes
    {
        return &self.data;
    }

    pub 
    fn get_binds(&self) -> Option<&HashSet<String>>
    {
        return self.proc_binds.as_ref();
    }

    pub 
    fn get_datatype(&self) -> ArgDataType
    {
        return self.data_type;
    }

    /// Returns `true` if `proc_name` is defined in the list
    /// of binded procedures or if instance is not limited to any
    /// procedure.
    pub 
    fn is_in_proc_scope(&self, proc_name: &String) -> bool
    {
        if let Some(ref p) = self.proc_binds
        {
            return p.contains(proc_name);
        }
        else
        {
            return true;
        }
    }
}

/// A strucure which holds information about `procedure` 
/// read from init (static scheme) scheme files.
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct Procedure
{
    /// A title of the procedure
    name: Arc<String>,

    /// Arguments of the procedure (in strict order)
    args: LinkedHashMap<Arc<String>, Arc<Argument>>,

    /// A procedures which may appear in current instance
    procs: LinkedHashMap<Arc<String>, Arc<ForegnProc>>,

    /// Explicitly define procedure as empty
    is_empty: bool,
}

impl PartialEq<str> for Procedure
{
    fn eq(&self, other: &str) -> bool 
    {
        return self.name.as_str() == other;
    }
}

impl Hash for Procedure
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.name.hash(state);
    }
}

impl Borrow<str> for Procedure
{
    fn borrow(&self) -> &str 
    {
        return &self.name;
    }
}

impl Borrow<String> for Procedure
{
    fn borrow(&self) -> &String 
    {
        return &self.name;
    }
}

impl fmt::Display for Procedure
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "name: {}, is_empty: {}, porcs: {}", self.name, self.is_empty, 
            self.procs.keys().map(|k| k.as_ref().clone()).collect::<Vec<String>>().join(", "))
    }
}

impl Clone for Procedure 
{
    fn clone(&self) -> Self 
    {
        panic!("Asserion trap: Procedure must never be cloned! \
            Implementation Clone for Procedure is used to comply \
            with compilter requirments.");
    }
}

impl Procedure
{
    pub const ROOT_PROC_NAME: &'static str = "root_procedure_0000";

    pub 
    fn new(name: String, li: LexerInfo) -> Result<Self, String>
    {
        if common::contains_printable_all(&name) == false
        {
            return Err(
                format!("in procedure: 'N?A', near: '{}' the procedure name contains non-printable character!", li)
            );
        }

        return Ok(
            Self
            {
                name: Arc::new(name), 
                args: LinkedHashMap::new(), 
                procs: LinkedHashMap::new(), 
                is_empty: false,
            }
        );
    }

    pub 
    fn new_root() -> Self
    {
        return 
            Self
            {
                name: Arc::new(Self::ROOT_PROC_NAME.to_string()), 
                args: LinkedHashMap::new(), 
                procs: LinkedHashMap::new(), 
                is_empty: false,
            };
    }

    pub
    fn is_root(&self) -> bool
    {
        return self.name.as_str() == Self::ROOT_PROC_NAME;
    }

    pub 
    fn clone_name(&self) ->Arc<String>
    {
        return self.name.clone();
    }

    pub 
    fn get_arg_by_label(&self, arg_level: &String) -> Option<&Arc<Argument>>
    {
        return self.args.get(arg_level);
    }
    
    pub 
    fn get_proc_by_label(&self, proc_name: &String) -> Option<&Arc<ForegnProc>>
    {
        return self.procs.get(proc_name);
    }

    pub 
    fn get_name(&self) -> &String
    {
        return &self.name;
    }

    pub 
    fn get_args_iter(&self) -> linked_hash_map::Iter<'_,Arc<String>,Arc<Argument>>
    {
        return self.args.iter();
    }

    pub 
    fn get_args_len(&self) -> usize
    {
        return self.args.len();
    }

    pub 
    fn get_procs_iter(&self) -> linked_hash_map::Iter<'_,Arc<String>,Arc<ForegnProc>>
    {
        return self.procs.iter();
    }

    pub 
    fn get_procs_len(&self) -> usize
    {
        return self.procs.len();
    }

    pub 
    fn get_proc(&self) -> &LinkedHashMap<Arc<String>,Arc<ForegnProc>>
    {
        return &self.procs;
    }

    /// Adds a procedure's argument.
    /// (arg ...)
    pub 
    fn add_arg(&mut self, arg: Argument) -> Result<(), String>
    {
        if self.is_empty == true
        {
            return Err(
                format!("(procedure \"{}\") was explicitly set to empty but expects \
                    (arg \"{}\") to appear", self.get_name(), arg.get_label())
            );
        }

        let res = 
            self.args.insert(arg.clone_label(), Arc::new(arg));

        if let Some(r) = res
        {
            return Err(
                format!("redefinition of the (arg \"{}\" {:?}) in \
                    (procedure \"{}\")", r.get_label(), r.arg_data_types, self.get_name())
            );
        }

        return Ok(());
    }

    /// Adds a foreign procedure to current procedure instance.
    /// 
    /// # Arguments
    /// 
    /// * `proc_label` - [String] a label to the foreign procedure/s
    /// 
    /// * `proc_names` - [HashSet] [String] an allowed foreign procedures to appear in 
    ///     current procedure instance.
    /// 
    /// * `proc_allowed_flags` - [ProcFlags] a control flags like collection, optional
    pub 
    fn add_proc(
        &mut self, 
        proc_label: String, 
        proc_names: HashSet<String>, 
        proc_allowed_flags: ProcFlags
    ) -> Result<(), String>
    {
        if self.is_empty == true
        {
            return Err(
                format!("procedure: '{}' was explicitly set to be empty, but a \
                    foreign procedure is added: '{}", self.get_name(), proc_label)
            );
        }

        let label = Arc::new(proc_label);
        let fp = ForegnProc::new(label.clone(), proc_names, proc_allowed_flags);

        let res = self.procs.insert(label, Arc::new(fp));

        if let Some(r) = res
        {
            return Err(
                format!("redefinition of the foreign proc: '{}' in procedure: '{}'",
                        r.get_label(), self.get_name())
            );
        }

        return Ok(());
    }

    /// Sets the current procedure instance as empty i.e no args or 
    /// procedures.
    pub 
    fn set_empty(&mut self)
    {
        self.is_empty = true;
    }

    /// Returns the true if procedure does not have args or procedures
    pub 
    fn is_empty(&self) -> bool
    {
        return self.is_empty;
    }

    /// Searches (by `procedure name`) for the [ForegnProc] which has been added previously to
    /// current instance.
    /// 
    /// # Arguments
    /// 
    /// * `proc_name` - a name of the foreign process to lookup.
    /// 
    /// # Returns
    /// 
    /// The [Option] is returned with:
    /// 
    /// * [Option::Some] with [Rc] to [ForegnProc] reference clonned instance.
    /// 
    /// * [Option::None] with nothing if not found.
    pub 
    fn lookup_procedure(&self, proc_name: &String) -> Option<Arc<ForegnProc>>
    {
        for (_, p) in self.procs.iter()
        {
            if p.contains_proc(proc_name) == true
            {
                return Some(p.clone());
            }
        }

        return None;
    }

    pub 
    fn validate(&self, li: LexerInfo) -> Result<(), String>
    {
        if self.args.is_empty() == true && self.procs.is_empty() == true &&
            self.is_empty() == false
        {
            return Err(
                format!("in procedure: '{}', near: '{}' the procedure should either contain \
                    foreign procs or arg or to be set to empty (procedure_empty)", self.get_name(), li)
            );
        }
        else if (self.args.is_empty() == false || self.procs.is_empty() == false) && 
            self.is_empty() == true
        {
            return Err(
                format!("in procedure: '{}', near: '{}' the procedure both contains \
                    foreign procs or arg and set to be empty (procedure_empty)",
                    self.get_name(), li)
            );
        }

        return Ok(());
    }
}


/// A struct which holds information about procedures which are
/// declared in procedure, which are allowed to appear there.
/// 
/// i.e 
/// (procedure
///  (foreign_proc)...
/// )
#[derive(Debug, Serialize, Deserialize)]
pub struct ForegnProc
{
    /// A label which used to find the path to item
    label: Arc<String>,

    /// A names of procedures which from which one or many is expected to appear
    /// in procedure.
    foregn_names: HashSet<String>,

    /// A modification flags.
    flags: ProcFlags,
}

impl fmt::Display for ForegnProc
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "[foregn proc] label: '{}'", self.label)
    }
}

impl Eq for ForegnProc {}

impl PartialEq for ForegnProc
{
    fn eq(&self, other: &Self) -> bool 
    {
        self.label == other.label
    }
}

impl Hash for ForegnProc 
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.label.hash(state);
    }
}

impl ForegnProc
{
    pub 
    fn new(label: Arc<String>, foregn_names: HashSet<String>, flags: ProcFlags,) -> Self
    {
        return Self {label: label, foregn_names: foregn_names, flags: flags};
    }

    pub 
    fn clone_label(&self) -> Arc<String>
    {
        return self.label.clone();
    }

    pub 
    fn get_label(&self) -> &String
    {
        return &self.label;
    }

    /// Verifies if procedure with name `proc_name` exists in the
    /// list of `foregn_names` - declared.
    pub 
    fn contains_proc(&self, proc_name: &String) -> bool
    {
        return self.foregn_names.contains(proc_name);
    }

    /// Checks if modifier is set.
    pub 
    fn is_flag_set(&self, flag: ProcFlags) -> bool
    {
        return self.flags.intersects(flag);
    }

    pub 
    fn get_proc_iter(&self) -> std::collections::hash_set::Iter<'_, String>
    {
        return self.foregn_names.iter();
    }
}

/// A struct for temporary storage of the argument datatypes which
/// is used in `environment.rs` for data type extraction.
#[derive(Clone, Debug)]
pub struct Arg<'t>
{
    /// A reference to the arguments datatypes [Argument].
    arg_data_types: &'t [ArgDataType],
    
    /// An argument `arg_data_types` read index.
    index: Cell<usize>,

    /// A enum bind (if any)
    set_enum_bind: Option<&'t String>
}

impl<'t> Arg<'t>
{
    fn new(args: &'t [ArgDataType], set_enum_b: Option<&'t String>) -> Arg<'t>
    {
        return 
            Self
            { 
                arg_data_types: args, 
                index: Cell::new(0),
                set_enum_bind: set_enum_b
            };
    }

    /// Pop argument data type. Does not check bounds. On first returned 
    /// [Option::None] means the end of list was reached.
    pub 
    fn pop_arg(&self) -> Option<&'t ArgDataType>
    {
        let arg = self.arg_data_types.get(self.index.get());
        self.index.set( self.index.get() + 1 );

        return arg;
    }

    pub 
    fn is_arg_enum_bind(&self) -> bool
    {
        return self.set_enum_bind.is_some();
    }

    pub 
    fn get_arg_enum_bind(&self) -> &String
    {
        return self.set_enum_bind.as_ref().unwrap();
    }
}

/// A structure which hold information about procedure's argument.
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct Argument
{
    /// A label which is used to find the item by path.
    label: Arc<String>,
    //arg_data_type: ArgDataType, 
    //arg_collection_type: ArgDataType,
    
    /// A data type of the argument.
    arg_data_types: Vec<ArgDataType>,

    /// A validator of argument (not implemented at the moment).
    //validators: Vec<Validator>,

    /// An arg enumerator name
    set_enum_bind: Option<String>,
}

impl fmt::Display for Argument
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "label: '{}', datatypes: '{}'", 
            self.label, self.arg_data_types.iter().map(|d| d.to_string()).collect::<Vec<String>>().join("::"))
    }
}

impl Argument
{
    /// Validates that the data types chain is correct.
    /// This function is recursive.
    fn validate_arg_datatypes(arg_data_types: &[ArgDataType]) -> Result<(), String>
    {
        let arg0_opt = arg_data_types.get(0);
        if arg0_opt.is_none() == true || arg0_opt.unwrap() == &ArgDataType::None
        {
            return Err(format!("argument validation problem: data type is mising"));
        }

        if arg0_opt.unwrap().has_subtype() == true
        {
            return Self::validate_arg_datatypes(&arg_data_types[1..]);
        }

        return Ok(());
    }

    pub 
    fn new(label: Arc<String>, arg_data_types: Vec<ArgDataType>) -> Result<Self, String>
    {
        // validate ard_data_types
        Self::validate_arg_datatypes(arg_data_types.as_slice())?;

        return Ok(
            Self
            { 
                label, 
                arg_data_types, 
                set_enum_bind: None,
            }
        );
    }

    pub 
    fn clone_label(&self) ->Arc<String>
    {
        return self.label.clone();
    }

    pub 
    fn get_args(&self) -> Arg<'_>
    {
        return 
            Arg::new(
                self.arg_data_types.as_slice(),
                self.set_enum_bind.as_ref()
            );
    }

    pub 
    fn set_enum_bind(&mut self, enum_bind: Option<String>) -> Result<(), String>
    {
        if self.arg_data_types.iter().any(|f| f == &ArgDataType::Enumerator) == true 
        {
            if enum_bind.is_some() == true
            {
                self.set_enum_bind = enum_bind;
            }
            else
            {
                return Err(format!("enum_bind is none, but should be set for emumerator in argument"));
            }

            return Ok(());
        }
        else
        {
            if enum_bind.is_some() == true
            {
                return Err(format!("enum_bind can only be set to procedure's field of type enum"));
            }

            return Ok(());
        }
    }

    pub 
    fn get_label(&self) -> &String
    {
        return &self.label;
    }

    pub 
    fn get_data_base_type(&self) -> &ArgDataType
    {
        return &self.arg_data_types[0];
    }

    pub 
    fn get_data_type(&self) -> &ArgDataType
    {
        return &self.arg_data_types[0];
    }

    pub 
    fn get_collection_type(&self) -> &ArgDataType
    {
        return &self.arg_data_types[1];
    }

    pub 
    fn get_collection_type_sub(&self) -> &ArgDataType
    {
        return &self.arg_data_types[2];
    }

    pub 
    fn get_arg_index(&self, idx: usize) -> Option<&ArgDataType>
    {
        return self.arg_data_types.get(idx);
    }

    pub 
    fn get_enum_bind(&self) -> Option<&String>
    {
        return self.set_enum_bind.as_ref();
    }
}

/*
/// A validation of arguemnts of procedure. Not implemented yet.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Validator
{
    validator: ValidatorType, 
    val_data: GenericDataTypes, 
    descr: String,
}

impl Validator
{
    pub fn new<D: Into<String>>(validator: ValidatorType, val_data: GenericDataTypes, descr: D) -> Self
    {
        return Self {validator, val_data, descr: descr.into()};
    }
}
*/

//let proc = Procedure::new("test");
// let arg = proc.add_arg("name", ArgDataType::Vector, ArgDataType::i64);
//  arg.add_validate(Validator::NoDup, ValidatorData::None, "duplicate val");
//  arg.add_validate(Validator::LessEqual, ValidatorData::I64(100), "more than 100");
// drop(arg);
// proc.add_proc("proctest", ProcDataType::Struct, ProcDataType::None);
//
// serializator.add_proc("acls", proc, Serializator::AsHashMap("name", SerHashMap::Struct));