Struct Memory 

pub struct Memory {
    pub id: MemoryId,
    pub content: String,
    pub tags: Vec<String>,
    pub source: String,
    pub created_ns: u64,
    pub updated_ns: u64,
    pub pinned: bool,
}

A content-addressable memory record: a piece of content plus tag metadata, source identity, and a pinned flag.

Memories differ structurally from super::super::tasks::Task in two ways that exercise the CortEX adapter pattern:

• tags: Vec<String> — multi-valued field with set-like query semantics (where_tag, where_any_tag, where_all_tags).
• pinned: bool — toggled via explicit events rather than as a terminal state like TaskStatus::Completed.

Fields

id: MemoryId

Stable identifier.

content: String

Free-form payload. RedEX stores the raw bytes; the adapter makes no assumption about structure.

tags: Vec<String>

Tag set. Insertion order is preserved; duplicates are not enforced as unique by the adapter (fold relies on the event stream to keep it sane).

source: String

Producer / origin label. Free-form string chosen by callers.

created_ns: u64

Wall-clock creation time (unix nanos).

updated_ns: u64

Wall-clock last-update time (unix nanos).

pinned: bool

Whether the memory is pinned (callers decide what “pinned” means for their domain — typically “keep prominent in queries”).

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Memory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Memory

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Memory

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Memory

impl PartialEq for Memory

fn eq(&self, other: &Memory) -> 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 Serialize for Memory

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Memory