Enum ImportKind 

#[repr(u8)]
pub enum ImportKind {
    ImportNamespace = 1,
    ImportAssemblyNamespace = 2,
    ImportType = 3,
    ImportXmlNamespace = 4,
    ImportAssemblyReferenceAlias = 5,
    DefineAssemblyAlias = 6,
    DefineNamespaceAlias = 7,
    DefineAssemblyNamespaceAlias = 8,
    DefineTypeAlias = 9,
}

Import declaration kinds as defined in the Portable PDB format specification.

These constants define the different types of import declarations that can appear in an imports blob. Each kind determines the structure and parameters of the following import data.

Format Specification

Each import kind corresponds to a specific binary format in the imports blob:

• Values 1-9 are defined by the Portable PDB specification
• Each kind has different parameter requirements (namespace, assembly, type, alias)
• Kind values are encoded as compressed unsigned integers in the blob

Examples

use dotscope::metadata::importscope::ImportKind;

// Convert from blob data
let kind = ImportKind::from_u32(1);
assert_eq!(kind, Some(ImportKind::ImportNamespace));

// Check kind values
assert_eq!(ImportKind::ImportType as u8, 3);

Thread Safety

ImportKind is std::marker::Send and std::marker::Sync as it contains only primitive data. Instances can be safely shared across threads and accessed concurrently.

Variants

ImportNamespace = 1

Import namespace members

ImportAssemblyNamespace = 2

Import namespace members from specific assembly

ImportType = 3

Import type members

ImportXmlNamespace = 4

Import XML namespace with prefix

ImportAssemblyReferenceAlias = 5

Import assembly reference alias from ancestor scope

DefineAssemblyAlias = 6

Define assembly alias

DefineNamespaceAlias = 7

Define namespace alias

DefineAssemblyNamespaceAlias = 8

Define namespace alias from specific assembly

DefineTypeAlias = 9

Define type alias

Implementations

impl ImportKind

pub fn from_u32(value: u32) -> Option<Self>

Create an ImportKind from a compressed unsigned integer value.

This method accepts u32 to match the output of compressed integer parsing functions used in the binary parser, even though valid values (1-9) fit in a u8.

Arguments

• value - The kind value from the imports blob. Valid values are 1-9; values outside this range return None.

Returns

• Some - Valid import kind for values 1-9
• None - Invalid or unsupported kind value (0, or 10+)

pub fn from_u8(value: u8) -> Option<Self>

Create an ImportKind from a u8 value.

Convenience method for creating an import kind from a single byte value. This is useful when working with raw byte data directly.

Arguments

• value - The kind value (1-9 are valid)

Returns

• Some - Valid import kind for values 1-9
• None - Invalid or unsupported kind value

Trait Implementations

impl Clone for ImportKind

fn clone(&self) -> ImportKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ImportKind

impl Debug for ImportKind

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

Formats the value using the given formatter.

impl Eq for ImportKind

impl PartialEq for ImportKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ImportKind