Struct BrdbInterned 

pub struct BrdbInterned(/* private fields */);

Implementations

impl BrdbInterned

pub fn get(self, schema: &BrdbSchema) -> Option<&str>

Examples found in repository

examples/read_all_schemas.rs (line 44)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // world file from argv
    let filename = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "world.brdb".to_string());
    let path = PathBuf::from(filename);
    if !path.exists() {
        eprintln!("File does not exist: {}", path.display());
        std::process::exit(1);
    }

    let db = Brdb::open(&path)?.into_reader();

    let schemas_dir = path.with_extension("schemas");
    if schemas_dir.exists() {
        std::fs::remove_dir_all(&schemas_dir)?;
    }
    std::fs::create_dir_all(&schemas_dir)?;

    db.get_fs()?.for_each(&mut |f| {
        if !f.is_file() || !f.name().ends_with(".schema") {
            return;
        }
        println!("Reading schema file: {}... ", f.name());

        let Ok(buf) = f.read(&*db) else {
            eprintln!("Failed to read schema file: {}", f.name());
            return;
        };

        let Ok(schema) = BrdbSchema::read(buf.as_slice()) else {
            eprintln!("Failed to parse schema file: {}", f.name());
            return;
        };
        let soa = schema
            .structs
            .last()
            .unwrap()
            .0
            .get(&schema)
            .unwrap()
            .to_string();

        if let Err(e) = std::fs::write(
            schemas_dir.join(soa).with_extension("schema"),
            schema.to_string(),
        ) {
            eprintln!("Failed to write schema file: {}: {}", f.name(), e);
        }
    });

    Ok(())
}

pub fn get_or<'b, 'a: 'b>(self, schema: &'a BrdbSchema, or: &'b str) -> &'b str

pub fn get_or_else( self, schema: &BrdbSchema, or: impl FnMut() -> String, ) -> String

pub fn get_ok( self, schema: &BrdbSchema, or: impl FnMut() -> BrdbSchemaError, ) -> Result<&str, BrdbSchemaError>

Trait Implementations

impl Clone for BrdbInterned

fn clone(&self) -> BrdbInterned

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BrdbInterned

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

Formats the value using the given formatter.

impl Hash for BrdbInterned

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BrdbInterned

fn eq(&self, other: &BrdbInterned) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for BrdbInterned

impl Eq for BrdbInterned

impl StructuralPartialEq for BrdbInterned