Struct Chunk 

pub struct Chunk<'a> {
    pub id: ChunkId,
    pub entry: bool,
    pub initial: bool,
    pub modules: Modules<'a>,
    pub files: Vec<SourceFilePath<'a>>,
    pub names: Vec<ChunkName<'a>>,
    pub origins: Vec<Origin<'a>>,
    pub parents: Vec<ChunkId>,
    pub siblings: Vec<ChunkId>,
    pub children: Vec<ChunkId>,
    pub rendered: bool,
    pub size: SizeBytes,
}

Fields

id: ChunkId

entry: bool

initial: bool

modules: Modules<'a>

files: Vec<SourceFilePath<'a>>

names: Vec<ChunkName<'a>>

origins: Vec<Origin<'a>>

parents: Vec<ChunkId>

siblings: Vec<ChunkId>

children: Vec<ChunkId>

rendered: bool

size: SizeBytes

Trait Implementations

impl<'a> Debug for Chunk<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for Chunk<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Edges<ChunkId, ChunkChild> for Chunk<'a>

fn next_edge( &self, previous_edge_index: Option<usize>, ) -> Option<Edge<ChunkId, ChunkChild>>

fn edges(&self) -> EdgeIterator<'_, I, D, Self>

where Self: Sized,

impl<'a> Edges<ChunkId, ChunkParentOrSibling> for Chunk<'a>

fn next_edge( &self, previous_edge_index: Option<usize>, ) -> Option<Edge<ChunkId, ChunkParentOrSibling>>

fn edges(&self) -> EdgeIterator<'_, I, D, Self>

where Self: Sized,

impl<'a> ExtractData<ChunkChildren> for Chunk<'a>

fn extract_data(&self) -> ChunkChildren

impl<'a> ExtractData<ChunkId> for Chunk<'a>

fn extract_data(&self) -> ChunkId

impl<'a> ExtractData<ChunkInitial> for Chunk<'a>

fn extract_data(&self) -> ChunkInitial

impl<'a> ExtractData<Files> for Chunk<'a>

fn extract_data(&self) -> Files

impl<'a> ExtractData<SizeBytes> for Chunk<'a>

fn extract_data(&self) -> SizeBytes

impl<'a> ExtractData<Vec<ModuleIdentifier>> for Chunk<'a>

fn extract_data(&self) -> ChunkModules

impl<'a> Identifiable<ChunkId> for Chunk<'a>

fn get_id(&self) -> ChunkId

impl<'a> Label for Chunk<'a>

type Label = ChunkId

fn label(&self) -> Self::Label

impl<'a> Query<ChunkId, Chunk<'a>> for Chunks<'a>

fn query(&self, identifier: &ChunkId) -> Option<&Chunk<'a>>

fn all(&self) -> Vec<&Chunk<'a>>

fn create_index(&self) -> HashMap<I, Link<'_, I, V>>

impl<'a> Chunk for Chunk<'a>

impl<'a> Chunks<Chunk<'a>> for Chunks<'a>