Struct CombinedLineSymbol 

pub struct CombinedLineSymbol {
    pub common: SymbolCommon,
    /* private fields */
}

A combined line symbol composed of multiple sub-symbols.

Fields

common: SymbolCommon

Common symbol properties.

Implementations

impl CombinedLineSymbol

pub fn components( &self, ) -> impl Iterator<Item = &PublicOrPrivateSymbol<WeakLinePathSymbol, Box<LineSymbol>>>

Iterate through the symbol component of the symbol

Examples found in repository

examples/default_write.rs (line 96)

fn main() -> Result<(), Error> {
    #[cfg(feature = "geo_ref")]
    let mut map = {
        let proj_center = Coord {
            x: 463_575.5,
            y: 6_833_849.6,
        };
        let map_center_elevation_meters = 2_469.;
        let crs_epsg_code = 25832;
        Omap::default_15_000_geo_referenced(
            proj_center,
            CrsType::Epsg(crs_epsg_code),
            map_center_elevation_meters,
        )?
    };
    #[cfg(not(feature = "geo_ref"))]
    let mut map = Omap::default_15_000()?;

    for color in map.colors.iter() {
        match color {
            Color::SpotColor(ref_cell) => {
                let b = ref_cell.try_borrow().unwrap();
                println!("{} with spot name {}", b.color_name, b.spotcolor_name);
            }
            Color::MixedColor(ref_cell) => {
                println!("{}", ref_cell.try_borrow().unwrap().color_name);
            }
        }
    }

    let erosion_gully = map
        .symbols
        .get_symbol_by_code(Code::new(107, 0, 0))
        .unwrap()
        .downgrade();

    let mut ls = LineObject::new(
        WeakLinePathSymbol::try_from(erosion_gully).unwrap(),
        // geometry coordinates are always in mm of paper
        LineString::new(vec![Coord { x: 0., y: 0. }, Coord { x: 200., y: 100. }]),
    );
    ls.tags.insert("Some Key".to_owned(), "My value".to_owned());

    map.parts.0[0].add_object(ls);

    println!("\nCombined Line symbols:");
    for symbol in map.symbols.iter() {
        if let Symbol::CombinedLine(s) = symbol {
            println!("{}", s.borrow().common.name);
        }
    }
    if let Some(s) = map.symbols.get_symbol_by_name("Railway, Olive background") {
        println!("{s:?}");
    }

    let mut num = 0;
    for symbol in map.symbols.iter() {
        if let Symbol::Line(s) = symbol {
            let borrowed = s.borrow();

            if let Some(_ss_) = &borrowed.start_symbol {
                num += 1;
            }
            if let Some(_ms_) = &borrowed.mid_symbol {
                num += 1;
            }
            if let Some(_ds_) = &borrowed.dash_symbol {
                num += 1;
            }
            if let Some(_es_) = &borrowed.end_symbol {
                num += 1;
            }
        }
        if let Symbol::CombinedLine(s) = symbol {
            let borrowed = s.borrow();

            for part in borrowed.components() {
                if let PublicOrPrivateSymbol::Private(s) = part {
                    if let Some(_ss_) = &s.start_symbol {
                        num += 1;
                    }
                    if let Some(_ms_) = &s.mid_symbol {
                        num += 1;
                    }
                    if let Some(_ds_) = &s.dash_symbol {
                        num += 1;
                    }
                    if let Some(_es_) = &s.end_symbol {
                        num += 1;
                    }
                }
            }
        }
    }
    println!("\nNumber of sub symbols in line symbols: {num}");

    map.write_to_file("./test_write.omap")
}

pub fn components_mut( &mut self, ) -> impl Iterator<Item = &mut PublicOrPrivateSymbol<WeakLinePathSymbol, Box<LineSymbol>>>

Iterate through the mutable symbol component of the symbol

pub fn remove_component( &mut self, index: usize, ) -> Option<PublicOrPrivateSymbol<WeakLinePathSymbol, Box<LineSymbol>>>

Remove and return the symbol component at position index in the component vec. This preserves the order of the components. O(N) run time

pub fn swap_remove_component( &mut self, index: usize, ) -> Option<PublicOrPrivateSymbol<WeakLinePathSymbol, Box<LineSymbol>>>

Remove and return the symbol component at position index in the component vec. This does not preserve the order of the components. O(1) run time

pub fn add_component( &mut self, new_component: PublicOrPrivateSymbol<WeakLinePathSymbol, Box<LineSymbol>>, ) -> Result<(), Error>

Adds a component to the symbol Fails if adding this component will create a cycle in the symbol component definitions

The cycle detection relies on run time borrow checking, meaning that if any of the sub-symbols refcells are already being borrowed (through any of the .(try_)borrow(), .(try_)borrow_mut() functions) it fails

Errors

Returns an error if the component would introduce a cycle or a child symbol cannot be borrowed during cycle detection.

pub fn new(code: Code, name: impl Into<String>) -> Self

Create a new empty combined line symbol with the given code and name.

pub fn get_name(&self) -> &str

Get the display name of this combined line symbol.

pub fn num_components(&self) -> usize

Get the number of components in this combined symbol.

pub fn as_helper_symbol(self) -> Self

Mark as a helper symbol (builder-style).

pub fn minimum_length(&self) -> Result<f64, Error>

Get the minimum length (in paper dimensions mm) among all line sub-symbols. The check fails if any child combined line symbols cannot be borrowed This will recurse forever if any cycles exist

Errors

Returns an error if a child line symbol cannot be borrowed.

pub fn contains_symbol(&self, other_symbol: &WeakSymbol) -> Result<bool, Error>

Check if the symbol references the other symbol. The check fails if any sub-symbol cannot be borrowed (is mutably borrowed somewhere else)

Errors

Returns an error if a referenced combined symbol cannot be borrowed.

Trait Implementations

impl Clone for CombinedLineSymbol

fn clone(&self) -> CombinedLineSymbol

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CombinedLineSymbol

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

Formats the value using the given formatter.

impl From<CombinedLineSymbol> for Symbol

fn from(value: CombinedLineSymbol) -> Self

Converts to this type from the input type.