Struct reproto_backend::Environment

pub struct Environment {
    pub types: LinkedHashMap<RpTypeId, Loc<RpRegistered>>,
    pub decls: LinkedHashMap<RpTypeId, Rc<Loc<RpDecl>>>,
    pub used: LinkedHashMap<(RpVersionedPackage, String), RpVersionedPackage>,
    // some fields omitted
}

Fields

types: LinkedHashMap<RpTypeId, Loc<RpRegistered>>

decls: LinkedHashMap<RpTypeId, Rc<Loc<RpDecl>>>

used: LinkedHashMap<(RpVersionedPackage, String), RpVersionedPackage>

Methods

impl Environment

Environment containing all loaded declarations.

fn new(
    package_prefix: Option<RpPackage>,
    resolver: Box<Resolver>
) -> Environment

fn is_assignable_from(
    &self,
    package: &RpVersionedPackage,
    target: &RpType,
    source: &RpType
) -> Result<bool>

Check if source is assignable to target.

fn constant<'a>(
    &'a self,
    pos: &Pos,
    package: &'a RpVersionedPackage,
    constant: &RpName,
    target: &RpName
) -> Result<&'a RpRegistered>

Lookup registered constant.

fn instance<'a>(
    &'a self,
    pos: &Pos,
    package: &'a RpVersionedPackage,
    instance: &RpInstance,
    target: &RpName
) -> Result<(&'a RpRegistered, InitFields)>

Convert instance arguments to the known registered type of the instance, and a map containing the arguments being instantiated.

fn lookup<'a>(
    &'a self,
    lookup_package: &'a RpVersionedPackage,
    lookup_name: &RpName
) -> Result<LookupResult<'a>>

Lookup the declaration matching the custom type.

fn load_object<O: Into<Box<Object>>>(
    &mut self,
    object: O,
    version: Option<Version>,
    package: Option<RpPackage>
) -> Result<Option<(RpVersionedPackage, RpFile)>>

Load the provided Object into a RpFile.

fn process_uses(
    &mut self,
    package: &RpVersionedPackage,
    uses: Vec<Loc<RpUseDecl>>
) -> Result<()>

Process use declarations.

fn for_each_decl<F>(&self, f: F) -> Result<()> where
    F: FnMut(Rc<RpTypeId>, Rc<Loc<RpDecl>>) -> Result<()>, 

Walks the entire tree of declarations and emits them to the provided function.

fn process_decls<I>(
    &self,
    package: &RpVersionedPackage,
    input: I
) -> Result<LinkedHashMap<RpTypeId, Rc<Loc<RpDecl>>>> where
    I: IntoIterator<Item = Loc<RpDecl>>, 

Process and merge declarations.

Declarations are considered the same if they have the same type_id. The same declarations are merged using Merge.

fn process_types(
    &mut self,
    package: &RpVersionedPackage,
    decls: &LinkedHashMap<RpTypeId, Rc<Loc<RpDecl>>>
) -> Result<LinkedHashMap<RpTypeId, Loc<RpRegistered>>>

fn process_file(
    &mut self,
    package: &RpVersionedPackage,
    file: RpFile
) -> Result<()>

fn find_visited_by_required(
    &self,
    required: &RpRequiredPackage
) -> Option<RpVersionedPackage>

fn import_file<P: AsRef<Path>>(
    &mut self,
    path: P
) -> Result<Option<RpVersionedPackage>>

fn import(
    &mut self,
    required: &RpRequiredPackage
) -> Result<Option<RpVersionedPackage>>

fn verify(&mut self) -> Result<()>