jeff-format 0.2.0

Rust bindings for the jeff exchange format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! Wire values representing typed hyperedges in dataflow regions.

use super::ValueId;
use crate::capnp::jeff_capnp;
use crate::reader::metadata::sealed::HasMetadataSealed;
use crate::reader::string_table::StringTable;

use crate::types::Type;

/// Wire type and associated metadata.
///
/// Ports in the dataflow graph reference these values by their index in the
/// function's value array.
///
/// This corresponds to a jeff format `WireValue`, with a defined ID identifying
/// it in a [`ValueTable`][super::ValueTable].
#[derive(Clone, Copy, Debug)]
pub struct WireValue<'a> {
    /// The ID of this value in the function's [`ValueTable`][super::ValueTable].
    id: ValueId,
    /// Type of the hyperedge.
    pub(super) value_type: Type,
    /// Metadata associated with the value.
    pub(super) metadata: capnp::struct_list::Reader<'a, jeff_capnp::meta::Owned>,
    /// Module-level register of reused strings.
    pub(super) strings: StringTable<'a>,
}

impl<'a> WireValue<'a> {
    /// Create a new function view from a capnp reader.
    pub(crate) fn read_capnp(
        id: super::ValueId,
        value: jeff_capnp::value::Reader<'a>,
        strings: StringTable<'a>,
    ) -> Self {
        let value_type = value
            .get_type()
            .map(Type::read_capnp)
            .expect("Type should be present");
        let metadata = value.get_metadata().expect("Metadata should be present");
        Self {
            id,
            value_type,
            metadata,
            strings,
        }
    }

    /// Returns the ID of this value in the containing function's [`ValueTable`][super::ValueTable].
    pub fn id(&self) -> ValueId {
        self.id
    }

    /// Returns the type of this value.
    pub fn ty(&self) -> Type {
        self.value_type
    }
}

impl<'a> HasMetadataSealed for WireValue<'a> {
    fn strings(&self) -> StringTable<'a> {
        self.strings
    }

    fn metadata_reader(&self) -> capnp::struct_list::Reader<'a, jeff_capnp::meta::Owned> {
        self.metadata
    }
}