Struct RustCode

pub struct RustCode { /* private fields */ }

A root instance which contains generated items and static information to generate the rust structs/enums.

Implementations

impl RustCode

pub const SERDE_PATH: &'static str = "serde::{Serialize, Deserialize}"

pub const ANY_TYPE_ENUM: &'static str = "ShmTypeAnyField"

pub const ANY_TYPE_ENUM_STR: &'static str = "String"

pub const ANY_TYPE_ENUM_ENTITY: &'static str = "Entity"

pub const ANY_TYPE_ENUM_VARIABLE: &'static str = "Variable"

pub const ANY_TYPE_ENUM_UINT: &'static str = "UInt"

pub const ANY_TYPE_ENUM_LONGUINT: &'static str = "LongUInt"

pub const ANY_TYPE_ENUM_INT: &'static str = "Int"

pub const ANY_TYPE_ENUM_LONGINT: &'static str = "LongInt"

pub const ANY_TYPE_ENUM_BOOL: &'static str = "Bool"

pub fn new( any_type_derives: Vec<RustCodeDerives>, any_type_jails: Vec<String>, serde_use_path: Option<String>, ) -> Self

Examples found in repository

examples/define_test.rs (line 22)

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 21)

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 38)

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 53)

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 69)

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 87)

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 contains(&self, item_name: &str) -> bool

Examples found in repository

examples/common_search/common_search.rs (line 52)

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

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

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

    // read a static scheme which describes our data structures i.e files filters.shm and logsmon.shm
    let mut res = schm.run_from_file("examples/common_search/filters.shm", None).unwrap();
    res.merge(schm.run_from_file("examples/common_search/logsmon.shm", None).unwrap());

    // get our serializator instance which was parsed from static file
    let resser = res.get("filters").unwrap().clone();

    // creating new `RustCode` instance where the data structs from serializator `filters` will be placed
    let mut rc1 = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);
    resser.generate_rust_code(&mut rc1).unwrap();

    // creating new `RustCode` instance where the data structs from serializator `logsmon` will be placed
    let resser = res.get("logsmon").unwrap().clone();
    let mut rc2 = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);
    resser.generate_rust_code(&mut rc2).unwrap();

    println!("after removing commons");

    // search for common structs/enums between RustCode instances for filter.shm and logsmon.shm
    let t = std::time::Instant::now();
    let com_res = RustCode::search_common("super::structs::struct_common", vec!(&mut rc1, &mut rc2), vec![RustCodeDerives::Debug], vec![], None);
    let s = t.elapsed();
    println!("time taken: {:?}", s);
    println!("{}", rc1);

    println!("{}", rc2);
    
    // if something was found, then it will be stored in inner type of Option
    if com_res.is_some() == true
    {
        let com = com_res.unwrap();
        
        println!("Common structs: \n\n{}", com);

        assert_eq!(com.contains("LdFilterSets"), true);
    }
}

impl RustCode

pub fn search_common( common_file_usepath: &'static str, items: Vec<&mut RustCode>, any_type_derives: Vec<RustCodeDerives>, any_type_jails: Vec<String>, serde_use_path: Option<String>, ) -> Option<RustCode>

A static method which can be used to search for the common strucutures/enums in generated Rust code. A structures and enums are searched by its title and its content. All found common structures are removed from the instances and returned in RustCode instance. The RustCodeDerivRepl and serde_path and serde_crate_path are not derived. It is possible to set it later.

Arguments

• common_file_usepath - a str path to the location with common structures. i.e super::structs::common_structs where common_structs is a rs file.

• items - a Vec with mut references to initialized instances of RustCode where the common structs will be searched.

• deriv_enum - an array with items for #[derive] for enum.

• deriv_struct - an array with items for #derive` for structs.

Returns

An Option is returned where:

• Some is returned with instance

• None is returned if no repeating structures/enums where found.

Examples found in repository

examples/common_search/common_search.rs (line 38)

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

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

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

    // read a static scheme which describes our data structures i.e files filters.shm and logsmon.shm
    let mut res = schm.run_from_file("examples/common_search/filters.shm", None).unwrap();
    res.merge(schm.run_from_file("examples/common_search/logsmon.shm", None).unwrap());

    // get our serializator instance which was parsed from static file
    let resser = res.get("filters").unwrap().clone();

    // creating new `RustCode` instance where the data structs from serializator `filters` will be placed
    let mut rc1 = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);
    resser.generate_rust_code(&mut rc1).unwrap();

    // creating new `RustCode` instance where the data structs from serializator `logsmon` will be placed
    let resser = res.get("logsmon").unwrap().clone();
    let mut rc2 = RustCode::new(vec![RustCodeDerives::Debug], vec![], None);
    resser.generate_rust_code(&mut rc2).unwrap();

    println!("after removing commons");

    // search for common structs/enums between RustCode instances for filter.shm and logsmon.shm
    let t = std::time::Instant::now();
    let com_res = RustCode::search_common("super::structs::struct_common", vec!(&mut rc1, &mut rc2), vec![RustCodeDerives::Debug], vec![], None);
    let s = t.elapsed();
    println!("time taken: {:?}", s);
    println!("{}", rc1);

    println!("{}", rc2);
    
    // if something was found, then it will be stored in inner type of Option
    if com_res.is_some() == true
    {
        let com = com_res.unwrap();
        
        println!("Common structs: \n\n{}", com);

        assert_eq!(com.contains("LdFilterSets"), true);
    }
}

Trait Implementations

impl Display for RustCode

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

Formats the value using the given formatter.