Struct Serializator

pub struct Serializator { /* private fields */ }

This struct contains information about the Serializator instance which is defined in scheme and starting with (serialization “name” …).

Implementations

impl Serializator

pub const SERIALIZATOR_FROM_MEMORY_PATH: &'static str = "from memory"

Returned instead of path when path is None

pub fn new(name: String) -> Self

Creates new instance of serializator and sets the name provided in the scheme.

pub fn set_file_path(&mut self, file_path: Option<PathBuf>)

Sets to the created instance a path to the file which was used to generate current instance.

pub fn get_file_path(&self) -> Option<&PathBuf>

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_string_safe(&self) -> String

Returns a path or constant SERIALIZATOR_FROM_MEMORY_PATH if it was generated from memory.

pub fn get_defines_by_proc_dt( &self, proc_name: &String, arg_dt: ArgDataType, ) -> Vec<Arc<Define>>

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 items is returned.

pub fn resolve_path_to_struct( &self, source: Arc<Procedure>, path_to_label: &[String], full_path_to_lbl: &[String], ) -> StaticSchemeRes<(Arc<Structure>, Arc<Procedure>)>

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_proc( &self, source: Arc<Procedure>, path_to_label: &[String], full_path_to_lbl: &[String], ) -> StaticSchemeRes<(Option<Arc<Structure>>, Arc<Procedure>)>

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_enum( &self, source: Arc<Procedure>, path_to_label: &[String], full_path_to_lbl: &[String], ) -> StaticSchemeRes<(Arc<Enumerator>, Arc<Procedure>)>

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_arg( &self, source: Arc<Procedure>, path_to_label: &[String], full_path_to_lbl: &[String], ) -> StaticSchemeRes<Arc<Argument>>

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 generate_rust_code( &self, rust_code: &mut RustCode, ) -> StaticSchemeRes<()>

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.

Examples found in repository

examples/define_test.rs (line 25)

fn main()
{
    let mut curdir = std::env::current_dir().unwrap();
    curdir.push("examples/defines_init.shm");

    println!("{}", curdir.display());
    
    let lex = lexer::Lexer::from_file(curdir).unwrap();
    let schm = init::SchemeInit::new().unwrap();

    let res = schm.run(&lex, None).unwrap();

    println!("{:?}", res);

    let resser = res.get("defines").unwrap().clone();

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);

    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            println!("{}", e);
        }
    }
}

examples/another/another.rs (line 23)

fn main()
{
    let curdir = std::env::current_dir().unwrap();

    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/another/init_l.shm", None).unwrap();

    let resser = res.get("logsmon").unwrap().clone();

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);
    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            println!("{}", e);
        }
    }

    let anres = resser.analyze().unwrap();

    println!("errors:\n{}", anres);

    let mut curdir = std::env::current_dir().unwrap();

    curdir.push("examples/another/data_l.shm");

    let (_, _dyn_res) = environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();

    let resser = res.get("logsmon").unwrap().clone();

    let anres = resser.analyze().unwrap();

    println!("errors:\n{}", anres);



}

examples/complex_example_1/init_networking1.rs (line 41)

fn main()
{
    let curdir = std::env::current_dir().unwrap();

    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/complex_example_1/init_networking.shm", None).unwrap();

    let resser = res.get("networking").unwrap().clone();

    let anres = resser.analyze().unwrap();

    println!("errors:\n{}", anres);

    let mut curdir = std::env::current_dir().unwrap();

    curdir.push("examples/complex_example_1/init_networking_dyn1.shm");

    let (_, dyn_res) = environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();

    let ret = serializator::Serialization::serialize(resser.clone(), dyn_res.clone()).unwrap();

    let serialized = serde_json::to_string(&ret).unwrap();

    println!("Result:\n{}", serialized);

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);

    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            println!("{}", e);
        }
    }

}

examples/scheme_enum/enumtest.rs (line 56)

fn main()
{
    let curdir = std::env::current_dir().unwrap();
    //curdir.push("examples/test3.shm");
    println!("{}", curdir.display());
   // let lex = lexer::Lexer::from_file(curdir).unwrap();
    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/scheme_enum/init_enum.shm", None).unwrap();

    let resser = res.get("test1").unwrap().clone();

    println!("{:?}", res);

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);

    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            panic!("{}", e);
        }
    }

    let mut curdir = std::env::current_dir().unwrap();
    curdir.push("examples/scheme_enum/enum.shm");

    let (_, dyn_res) = environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();

    let ret = serializator::Serialization::serialize(resser.clone(), dyn_res.clone()).unwrap();

    //println!("dynproc:\n{:?}\n", dyn_res);

    let serialized = serde_json::to_string(&ret).unwrap();

    println!("Result:\n{}", serialized);

    let _deserialized: CommonLevels = serde_json::from_str(&serialized).unwrap();

    let lvls = 
        CommonLevels
        {
            enum1: MyEnum::Item1,
            enum2: OurEnum::Item2,
            enum3: MyEnum::Item2,
            enum4: vec![OurEnum::HItem1, OurEnum::Item2, OurEnum::CItem],
        };

    let serialized_nat = serde_json::to_string(&lvls).unwrap();

    println!("nat:{}", serialized_nat);
    println!("ser:{}", serialized);

    if serialized != serialized_nat
    {
        panic!("not equal");
    }


}

examples/scheme_proc_enum/init_use1.rs (line 72)

fn main()
{
    let curdir = std::env::current_dir().unwrap();

    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/scheme_proc_enum/init_use1.shm", None).unwrap();

    let resser = res.get("use1").unwrap().clone();

    let mut curdir = std::env::current_dir().unwrap();

    curdir.push("examples/scheme_proc_enum/init_use_dyn1.shm");

   // let lex = lexer::Lexer::from_file(curdir).unwrap();
    let (_dynenv, dyn_res) = 
        environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();
   // let dynenv = environment::DynEnvironment::new_root(resser.clone());

    //let dyn_res = environment::DynEnvironment::run(&lex, dynenv).unwrap();

    let ret = serializator::Serialization::serialize(resser.clone(), dyn_res.clone()).unwrap();

    let serialized = serde_json::to_string(&ret).unwrap();

    println!("Result:\n{}", serialized);
    let local_inst = 
        TestUseEnum::ColorRgbaProfile
        {
            profile_name: "profile1".to_string(),
            col_r: 6,
            col_g: 5,
            col_b: 64,
            col_a: 100
        };

    let local_inst_ser = serde_json::to_string(&local_inst).unwrap();

    assert_eq!(local_inst_ser.as_str(), serialized.as_str());


    

    let deserialized: TestUseEnum = serde_json::from_str(&serialized).unwrap();

    println!("Deserialized result: \n{:?}", deserialized);

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);

    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            panic!("{}", e);
        }
    }

}

examples/test3.rs (line 90)

fn main()
{
    let curdir = std::env::current_dir().unwrap();
    //curdir.push("examples/test3.shm");
    println!("{}", curdir.display());
   // let lex = lexer::Lexer::from_file(curdir).unwrap();
    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/test3.shm", None).unwrap();

    println!("{:?}", res);

    let resser = res.get("test1").unwrap().clone();



    let mut curdir = std::env::current_dir().unwrap();
    curdir.push("examples/test2.shm");


    let dynenv = environment::DynEnvironment::new_root(resser.clone()).unwrap();

    let dyn_res = environment::DynEnvironment::run_from_file(curdir, dynenv).unwrap();

    let ret = serializator::Serialization::serialize(resser.clone(), dyn_res.clone()).unwrap();

    //println!("dynproc:\n{:?}\n", dyn_res);

    let serialized = serde_json::to_string(&ret).unwrap();

    println!("Result:\n{}", serialized);

    let _deserialized: CommonLevels = serde_json::from_str(&serialized).unwrap();

    let lvls = 
        Levels
        {
            name: "testing1234".to_string(),
            ch_a: Some(100),
            ch_b: 2,
            g_type: vec![GeomType::Line(4, 6, 5), GeomType::Ray{l: 56, w: 44}, GeomType::Test],
        };

    let cl = CommonLevels{lvl: lvls};

    let serialized_nat = serde_json::to_string(&cl).unwrap();

    println!("nat:{}", serialized_nat);
    println!("ser:{}", serialized);

    if serialized != serialized_nat
    {
        println!("not equal");
    }

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);

    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            println!("{}", e);
        }
    }
}

Additional examples can be found in:

• examples/common_search/common_search.rs
• examples/scheme_longint/test_longint.rs
• examples/scheme_use/use_test.rs
• examples/scheme_vector_proc/vector_proc.rs
• examples/scheme_auto/test_auto.rs
• examples/scheme_common_struct/test_com.rs

pub fn generate_field_data_type( &self, rust_code: &mut RustCode, field: &FieldDecl, cur_proc_int: Arc<Procedure>, cur_enumer: Option<Arc<Enumerator>>, ) -> StaticSchemeRes<RustCodeItemDataType>

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 get_name(&self) -> &String

Returns a title of the serializer.

pub fn clone_name(&self) -> Arc<String>

Clones a title of the serializer.

pub fn new_root_proc(&mut self, proc: Procedure) -> StaticSchemeRes<()>

Declares new procedure

pub fn new_proc(&mut self, proc: Procedure) -> StaticSchemeRes<()>

Declares new procedure.

pub fn symbol_define(&mut self, def: Define) -> StaticSchemeRes<()>

Declares symbol.

pub fn symbol_enum_define(&mut self, def: DefineEnum) -> StaticSchemeRes<()>

pub fn set_root_serialization_struct( &mut self, ser: Structure, ) -> StaticSchemeRes<()>

Sets the root serialization descriptor.

pub fn add_serialization_struct(&mut self, ser: Structure)

Declares serialization information for structure.

pub fn add_serialization_enum(&mut self, enm: Enumerator)

Declares a serialization information for enum.

pub fn get_serialization_struct_by_procname( &self, proc_name: &String, ) -> StaticSchemeRes<Arc<Structure>>

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_opt( &self, proc_name: &String, ) -> Option<Arc<Structure>>

pub fn get_serialization_struct_by_name( &self, struct_name: &str, ) -> StaticSchemeRes<Arc<Structure>>

pub fn get_serialization_enum_by_procname( &self, proc_name: &String, ) -> SerializationPartialRes<&Enumerator>

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_procedure_by_name( &self, proc_name: &String, ) -> Option<&Arc<Procedure>>

pub fn get_root_ser(&self) -> Option<Arc<Structure>>

Returns root serialization structure if was defined

pub fn get_root_proc(&self) -> Option<Arc<Procedure>>

Returns root procedure.

The [Rc] inside Option is cloned.

pub fn get_define_list_iter(&self) -> Iter<'_, Arc<String>, Arc<Define>>

Returns iterator to defined symbols.

pub fn get_enum_define_list_iter( &self, ) -> Iter<'_, Arc<String>, Arc<DefineEnum>>

Returns iterator to defined enum symbols.

pub fn get_enum_define_value_by_key( &self, key: &String, ) -> Option<&Arc<DefineEnum>>

pub fn get_procedure_list_iter(&self) -> Iter<'_, Arc<String>, Arc<Procedure>>

Returns iterator to all defined procedures.

impl Serializator

pub fn analyze(&self) -> SerializationPartialRes<AnalyzerErrors>

Performs analysis of static scheme. At the moment it is able to find unused procedures and arguments.

Returns

Function returns Result as SerializationPartialRes.

• Result::Ok with instance AnalyzerErrors is returned. This instance contains all found problems.

• Result::Err is returned if fatal error happens.

Examples found in repository

examples/analyzer_error/test_err.rs (line 19)

fn main()
{
    let curdir = std::env::current_dir().unwrap();

    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = 
        schm.run_from_file("examples/analyzer_error/schm_init.shm", None).unwrap();

    let scheme = res.get("test_auto").unwrap();

    let anres = scheme.analyze().unwrap();

    println!("{}", anres);

}

examples/another/another.rs (line 35)

fn main()
{
    let curdir = std::env::current_dir().unwrap();

    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/another/init_l.shm", None).unwrap();

    let resser = res.get("logsmon").unwrap().clone();

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);
    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            println!("{}", e);
        }
    }

    let anres = resser.analyze().unwrap();

    println!("errors:\n{}", anres);

    let mut curdir = std::env::current_dir().unwrap();

    curdir.push("examples/another/data_l.shm");

    let (_, _dyn_res) = environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();

    let resser = res.get("logsmon").unwrap().clone();

    let anres = resser.analyze().unwrap();

    println!("errors:\n{}", anres);



}

examples/complex_example_1/init_networking1.rs (line 22)

fn main()
{
    let curdir = std::env::current_dir().unwrap();

    println!("{}", curdir.display());

    let schm = init::SchemeInit::new_with_path(curdir).unwrap();

    let res = schm.run_from_file("examples/complex_example_1/init_networking.shm", None).unwrap();

    let resser = res.get("networking").unwrap().clone();

    let anres = resser.analyze().unwrap();

    println!("errors:\n{}", anres);

    let mut curdir = std::env::current_dir().unwrap();

    curdir.push("examples/complex_example_1/init_networking_dyn1.shm");

    let (_, dyn_res) = environment::DynEnvironment::from_file(curdir, resser.clone()).unwrap();

    let ret = serializator::Serialization::serialize(resser.clone(), dyn_res.clone()).unwrap();

    let serialized = serde_json::to_string(&ret).unwrap();

    println!("Result:\n{}", serialized);

    let mut rc = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);

    println!("Structures: ");
    match resser.generate_rust_code(&mut rc)
    {
        Ok(_) => 
        {
            println!("{}", rc);
        },
        Err(e) => 
        {
            println!("{}", e);
        }
    }

}

Trait Implementations

impl Clone for Serializator

A dummy clone. This instance must never be clonned.

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Serializator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Serializator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Serializator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for Serializator

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'nr> StaticProcedureParser<'nr> for Serializator

type RetType = Serializator

A return type for the parse function.

type RetTypeArg = Serializator

An argument for the helper function.

type RetTypeInt = Serializator

A return type for the parse_internal function.

fn parse_internal( si: &'nr SchemeInit<'nr>, nodes: NodesReader<'nr>, serializ: Self::RetTypeArg, ) -> StaticSchemeRes<Self::RetTypeInt>

An additional function for the recursion.

fn parse( si: &'nr SchemeInit<'nr>, nodes: NodesReader<'nr>, ) -> StaticSchemeRes<Self::RetType>

A main entry function.