Struct Attribute 

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

A typed reference to an attribute: a rooted Fragment carrying the identity-determining facts, tagged with a phantom value-schema marker.

The root id is cached alongside the fragment so .id() is a field read — entity!{} codegen calls it once per attribute per fact, and walking the fragment’s exports PATCH each time dominated the pre-0.40 entities/union benches.

Implementations

impl<S: InlineEncoding> Attribute<S>

pub fn id(&self) -> Id

The attribute’s id, equal to the wrapped fragment’s root.

pub fn raw(&self) -> RawId

Return the underlying raw id bytes.

pub fn fragment(&self) -> &Fragment

The identity-determining fragment.

pub fn inline_from<T: IntoInline<S>>(&self, v: T) -> Inline<S>

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

pub fn encoded_from<V>(&self, v: V) -> Encoded<S>

where V: IntoEncoded<<S as InlineEncoding>::Encoding>, <V as IntoEncoded<<S as InlineEncoding>::Encoding>>::Output: ToEncoded<S>,

Macro-side entry point: produce the Encoded<S> the entity!{} codegen folds into a Fragment.

Dispatches via IntoEncoded, parameterised by the schema’s Encoding — S itself for inline schemas, the inner BlobEncoding for Handle<T>. The resulting Output is lifted into a Encoded via ToEncoded.

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/UnknownInline 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.

Trait Implementations

impl<S: InlineEncoding> 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 + InlineEncoding> 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: InlineEncoding,

fn describe(&self) -> Fragment

Produces a Fragment describing this instance, with any long-form bytes embedded in its local blob store.

fn id(&self) -> Id

Returns the id of this instance. Default: derive from self.describe().root(). Override when the id is cheaper to compute directly (e.g. Attribute<S> reads it from its stored fragment).

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

impl<S: InlineEncoding> From<Fragment> for Attribute<S>

Wrap a rooted fragment as a typed attribute.

The fragment’s root() is the attribute id; its facts (typically metadata::iri | metadata::name together with metadata::value_encoding) are carried through to [Describe] so the attribute remains queryable in the metadata registry by its originating identity attribute.

Pinning a schema’s attribute ids (so local renames don’t churn the schema) is what the [attributes!] macro is for — declare them with explicit hex literals there.

fn from(fragment: Fragment) -> Self

Converts to this type from the input type.

impl<S: PartialEq + InlineEncoding> 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: InlineEncoding> StructuralPartialEq for Attribute<S>