Struct Attribute 

pub struct Attribute<S: ValueSchema> { /* private fields */ }

A typed reference to an attribute id together with its value schema.

Implementations

impl<S: ValueSchema> Attribute<S>

pub const fn from_id_with_usage(raw: RawId, usage: AttributeUsage) -> Self

Construct a Field from a raw 16-byte id and a fully specified usage.

pub const fn from_id(raw: RawId) -> Self

Construct a Field from a raw 16-byte id without attaching a static name. Prefer Attribute::from_id_with_usage when a static usage is available.

pub const fn raw(&self) -> RawId

Return the underlying raw id bytes.

pub fn id(&self) -> Id

Convert to a runtime Id value. This performs the nil check and will panic if the raw id is the nil id (all zeros).

pub fn value_from<T: ToValue<S>>(&self, v: T) -> Value<S>

Convert a host value into a typed Value<S> using the Field’s schema. This is a small convenience wrapper around the ToValue trait and simplifies macro expansion: af.value_from(expr) preserves the schema S for type inference.

pub fn as_variable(&self, v: Variable<S>) -> Variable<S>

Coerce an existing variable of any schema into a variable typed with this field’s schema. This is a convenience for macros: they can allocate an untyped/UnknownValue variable and then annotate it with the field’s schema using af.as_variable(raw_var).

The operation is a zero-cost conversion as variables are simply small integer indexes; the implementation uses an unsafe transmute to change the type parameter without moving the underlying data.

pub fn name(&self) -> Option<&str>

Returns the declared name of this attribute, if any.

pub const fn with_usage(self, usage: AttributeUsage) -> Self

Attach usage metadata to an attribute.

pub fn from_name(name: &str) -> Self

Derive an attribute id from a dynamic name and this schema’s metadata.

The identifier is computed by hashing the field name handle produced as a Handle<Blake3, crate::blob::schemas::longstring::LongString> together with the schema’s crate::metadata::ConstId::ID. The resulting 32-byte Blake3 digest uses its rightmost 16 bytes to match the RawId layout used by Attribute::from_id.

Trait Implementations

impl<S: ValueSchema> Clone for Attribute<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + ValueSchema> Debug for Attribute<S>

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

Formats the value using the given formatter.

impl<S> Describe for Attribute<S>

where S: ValueSchema + ConstDescribe,

fn describe<B>(&self, blobs: &mut B) -> Result<Fragment, B::PutError>

where B: BlobStore<Blake3>,

Produces a Fragment describing this item, storing any long-form content as blobs.

impl<S: Hash + ValueSchema> Hash for Attribute<S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S: PartialEq + ValueSchema> PartialEq for Attribute<S>

fn eq(&self, other: &Attribute<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Eq + ValueSchema> Eq for Attribute<S>

impl<S: ValueSchema> StructuralPartialEq for Attribute<S>