Struct Resolution

pub struct Resolution<'a> {
    pub assembly: Option<Assembly<'a>>,
    pub assembly_references: Vec<ExternalAssemblyReference<'a>>,
    pub entry_point: Option<EntryPoint>,
    pub exported_types: Vec<ExportedType<'a>>,
    pub field_references: Vec<ExternalFieldReference<'a>>,
    pub files: Vec<File<'a>>,
    pub manifest_resources: Vec<ManifestResource<'a>>,
    pub method_references: Vec<ExternalMethodReference<'a>>,
    pub module: Module<'a>,
    pub module_references: Vec<ExternalModuleReference<'a>>,
    pub type_definitions: Vec<TypeDefinition<'a>>,
    pub type_references: Vec<ExternalTypeReference<'a>>,
}

A structured representation of a .NET DLL file’s metadata, according to the ECMA-335 standard.

Resolution is the top-level data structure of dotnetdll. By working with a Resolution instance, you can access all the details of the assembly, modules, types, and other members defined or referenced in a DLL.

Fields

assembly: Option<Assembly<'a>>

Assembly metadata, if the DLL defines an assembly.

assembly_references: Vec<ExternalAssemblyReference<'a>>

All external assemblies referenced by the DLL.

entry_point: Option<EntryPoint>

Entry point for the DLL, if one is defined.

exported_types: Vec<ExportedType<'a>>

Types that this assembly exports, but are not defined in the assembly’s main module.

field_references: Vec<ExternalFieldReference<'a>>

References to fields defined in external assemblies.

files: Vec<File<'a>>

File resources that the DLL references or contains.

manifest_resources: Vec<ManifestResource<'a>>

Resources embedded within the DLL.

method_references: Vec<ExternalMethodReference<'a>>

References to methods defined in external assemblies.

module: Module<'a>

The module defined by the DLL. Note that this is a distinct object from an assembly.

module_references: Vec<ExternalModuleReference<'a>>

References to modules defined in external assemblies.

type_definitions: Vec<TypeDefinition<'a>>

Types defined within the DLL.

type_references: Vec<ExternalTypeReference<'a>>

References to types defined in external assemblies.

Implementations

impl<'a> Resolution<'a>

pub fn new(module: Module<'a>) -> Self

pub fn parse(bytes: &'a [u8], opts: ReadOptions) -> Result<Self>

pub fn write(&self, opts: WriteOptions) -> Result<Vec<u8>>

pub fn set_entry_point(&mut self, entry_point: impl Into<EntryPoint>)

impl<'a> Resolution<'a>

pub fn push_assembly_reference( &mut self, val: ExternalAssemblyReference<'a>, ) -> AssemblyRefIndex

pub fn assembly_reference_index(&self, index: usize) -> Option<AssemblyRefIndex>

pub fn enumerate_assembly_references( &self, ) -> impl Iterator<Item = (AssemblyRefIndex, &ExternalAssemblyReference<'a>)>

impl<'a> Resolution<'a>

pub fn push_exported_type(&mut self, val: ExportedType<'a>) -> ExportedTypeIndex

pub fn exported_type_index(&self, index: usize) -> Option<ExportedTypeIndex>

pub fn enumerate_exported_types( &self, ) -> impl Iterator<Item = (ExportedTypeIndex, &ExportedType<'a>)>

impl<'a> Resolution<'a>

pub fn push_field_reference( &mut self, val: ExternalFieldReference<'a>, ) -> FieldRefIndex

pub fn field_reference_index(&self, index: usize) -> Option<FieldRefIndex>

pub fn enumerate_field_references( &self, ) -> impl Iterator<Item = (FieldRefIndex, &ExternalFieldReference<'a>)>

impl<'a> Resolution<'a>

pub fn push_file(&mut self, val: File<'a>) -> FileIndex

pub fn file_index(&self, index: usize) -> Option<FileIndex>

pub fn enumerate_files(&self) -> impl Iterator<Item = (FileIndex, &File<'a>)>

impl<'a> Resolution<'a>

pub fn push_method_reference( &mut self, val: ExternalMethodReference<'a>, ) -> MethodRefIndex

pub fn method_reference_index(&self, index: usize) -> Option<MethodRefIndex>

pub fn enumerate_method_references( &self, ) -> impl Iterator<Item = (MethodRefIndex, &ExternalMethodReference<'a>)>

impl<'a> Resolution<'a>

pub fn push_module_reference( &mut self, val: ExternalModuleReference<'a>, ) -> ModuleRefIndex

pub fn module_reference_index(&self, index: usize) -> Option<ModuleRefIndex>

pub fn enumerate_module_references( &self, ) -> impl Iterator<Item = (ModuleRefIndex, &ExternalModuleReference<'a>)>

impl<'a> Resolution<'a>

pub fn push_type_definition(&mut self, val: TypeDefinition<'a>) -> TypeIndex

pub fn type_definition_index(&self, index: usize) -> Option<TypeIndex>

pub fn enumerate_type_definitions( &self, ) -> impl Iterator<Item = (TypeIndex, &TypeDefinition<'a>)>

impl<'a> Resolution<'a>

pub fn push_type_reference( &mut self, val: ExternalTypeReference<'a>, ) -> TypeRefIndex

pub fn type_reference_index(&self, index: usize) -> Option<TypeRefIndex>

pub fn enumerate_type_references( &self, ) -> impl Iterator<Item = (TypeRefIndex, &ExternalTypeReference<'a>)>

impl<'a> Resolution<'a>

pub fn push_field(&mut self, parent: TypeIndex, field: Field<'a>) -> FieldIndex

pub fn field_index(&self, parent: TypeIndex, index: usize) -> Option<FieldIndex>

pub fn enumerate_fields( &self, parent: TypeIndex, ) -> impl Iterator<Item = (FieldIndex, &Field<'a>)>

impl<'a> Resolution<'a>

pub fn push_property( &mut self, parent: TypeIndex, property: Property<'a>, ) -> PropertyIndex

pub fn property_index( &self, parent: TypeIndex, index: usize, ) -> Option<PropertyIndex>

pub fn enumerate_properties( &self, parent: TypeIndex, ) -> impl Iterator<Item = (PropertyIndex, &Property<'a>)>

impl<'a> Resolution<'a>

pub fn push_event(&mut self, parent: TypeIndex, event: Event<'a>) -> EventIndex

pub fn event_index(&self, parent: TypeIndex, index: usize) -> Option<EventIndex>

pub fn enumerate_events( &self, parent: TypeIndex, ) -> impl Iterator<Item = (EventIndex, &Event<'a>)>

impl<'a> Resolution<'a>

pub fn push_method( &mut self, parent: TypeIndex, method: Method<'a>, ) -> MethodIndex

pub fn method_index( &self, parent: TypeIndex, index: usize, ) -> Option<MethodIndex>

pub fn enumerate_methods( &self, parent: TypeIndex, ) -> impl Iterator<Item = (MethodIndex, &Method<'a>)>

pub fn set_property_getter( &mut self, property: PropertyIndex, method: Method<'a>, ) -> MethodIndex

pub fn property_getter_index( &self, property: PropertyIndex, ) -> Option<MethodIndex>

pub fn set_property_setter( &mut self, property: PropertyIndex, method: Method<'a>, ) -> MethodIndex

pub fn property_setter_index( &self, property: PropertyIndex, ) -> Option<MethodIndex>

pub fn push_property_other( &mut self, property: PropertyIndex, method: Method<'a>, ) -> MethodIndex

pub fn property_other_index( &self, property: PropertyIndex, index: usize, ) -> Option<MethodIndex>

pub fn event_add_index(&self, event: EventIndex) -> MethodIndex

pub fn event_remove_index(&self, event: EventIndex) -> MethodIndex

pub fn set_event_raise( &mut self, event: EventIndex, method: Method<'a>, ) -> MethodIndex

pub fn event_raise_index(&self, event: EventIndex) -> Option<MethodIndex>

pub fn push_event_other( &mut self, event: EventIndex, method: Method<'a>, ) -> MethodIndex

pub fn event_other_index( &self, event: EventIndex, index: usize, ) -> Option<MethodIndex>

Trait Implementations

impl<'a> Clone for Resolution<'a>

fn clone(&self) -> Resolution<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Resolution<'a>

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

Formats the value using the given formatter.

impl<'a> Index<AssemblyRefIndex> for Resolution<'a>

type Output = ExternalAssemblyReference<'a>

The returned type after indexing.

fn index(&self, index: AssemblyRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<EventIndex> for Resolution<'a>

type Output = Event<'a>

The returned type after indexing.

fn index(&self, index: EventIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<ExportedTypeIndex> for Resolution<'a>

type Output = ExportedType<'a>

The returned type after indexing.

fn index(&self, index: ExportedTypeIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<FieldIndex> for Resolution<'a>

type Output = Field<'a>

The returned type after indexing.

fn index(&self, index: FieldIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<FieldRefIndex> for Resolution<'a>

type Output = ExternalFieldReference<'a>

The returned type after indexing.

fn index(&self, index: FieldRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<FileIndex> for Resolution<'a>

type Output = File<'a>

The returned type after indexing.

fn index(&self, index: FileIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<MethodIndex> for Resolution<'a>

type Output = Method<'a>

The returned type after indexing.

fn index(&self, index: MethodIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<MethodRefIndex> for Resolution<'a>

type Output = ExternalMethodReference<'a>

The returned type after indexing.

fn index(&self, index: MethodRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<ModuleRefIndex> for Resolution<'a>

type Output = ExternalModuleReference<'a>

The returned type after indexing.

fn index(&self, index: ModuleRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<PropertyIndex> for Resolution<'a>

type Output = Property<'a>

The returned type after indexing.

fn index(&self, index: PropertyIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<TypeIndex> for Resolution<'a>

type Output = TypeDefinition<'a>

The returned type after indexing.

fn index(&self, index: TypeIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<TypeRefIndex> for Resolution<'a>

type Output = ExternalTypeReference<'a>

The returned type after indexing.

fn index(&self, index: TypeRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> IndexMut<AssemblyRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: AssemblyRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<EventIndex> for Resolution<'a>

fn index_mut(&mut self, index: EventIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<ExportedTypeIndex> for Resolution<'a>

fn index_mut(&mut self, index: ExportedTypeIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<FieldIndex> for Resolution<'a>

fn index_mut(&mut self, index: FieldIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<FieldRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: FieldRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<FileIndex> for Resolution<'a>

fn index_mut(&mut self, index: FileIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<MethodIndex> for Resolution<'_>

fn index_mut(&mut self, index: MethodIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<MethodRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: MethodRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<ModuleRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: ModuleRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<PropertyIndex> for Resolution<'a>

fn index_mut(&mut self, index: PropertyIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<TypeIndex> for Resolution<'a>

fn index_mut(&mut self, index: TypeIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<TypeRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: TypeRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.