Struct NoteInMemory 

pub struct NoteInMemory<T = HashMap<String, Value>>
where
    T: Clone,
{ /* private fields */ }

In-memory representation of an Obsidian note file

This struct provides full access to parsed note content, properties, and path. It stores the entire file contents in memory, making it suitable for:

• Frequent access to note content
• Transformation or analysis workflows
• Environments with fast storage (SSD/RAM disks)

Performance Considerations

• Uses ~2x memory of original file size (UTF-8 + deserialized properties)
• Preferred for small-to-medium vaults (<10k notes)

For large vaults or read-heavy workflows, consider NoteOnDisk.

Implementations

impl<T> NoteInMemory<T>

where T: Clone,

pub fn set_path(&mut self, path: Option<PathBuf>)

Set path to note

Trait Implementations

impl<T> Clone for NoteInMemory<T>

where T: Clone + Clone,

fn clone(&self) -> NoteInMemory<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for NoteInMemory<T>

where T: Clone + Debug,

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

Formats the value using the given formatter.

impl<T> Default for NoteInMemory<T>

where T: Clone + Default,

fn default() -> NoteInMemory<T>

Returns the “default value” for a type.

impl<T> Note for NoteInMemory<T>

where T: Clone,

fn properties(&self) -> Result<Option<Cow<'_, T>>, Self::Error>

Get Self::Properties

fn content(&self) -> Result<Cow<'_, str>, Self::Error>

Get contents

fn path(&self) -> Option<Cow<'_, Path>>

Get path to file

type Properties = T

Frontmatter properties type

type Error = Error

Error type

fn note_name(&self) -> Option<String>

Get note name

fn count_words_from_content(&self) -> Result<usize, Self::Error>

Get count words from content

fn count_symbols_from_content(&self) -> Result<usize, Self::Error>

Get count symbols from content

impl<T> NoteFromFile for NoteInMemory<T>

where T: DeserializeOwned + Clone,

Available on non-target_family=wasm only.

fn from_file(path: impl AsRef<Path>) -> Result<Self, Self::Error>

Parses an Obsidian note from a file

impl<T> NoteFromString for NoteInMemory<T>

where T: DeserializeOwned + Clone,

fn from_string(raw_text: impl AsRef<str>) -> Result<Self, Self::Error>

Parses a string into an in-memory Obsidian note representation

Arguments

• raw_text - Full note text including optional frontmatter
• path - Optional source path for reference

Process

1. Splits text into frontmatter/content sections
2. Parses YAML frontmatter if present
3. Stores content without frontmatter delimiters

Errors

• Error::InvalidFormat for malformed frontmatter
• Error::Yaml for invalid YAML syntax

Example

use obsidian_parser::prelude::*;
use serde::Deserialize;

#[derive(Deserialize, Clone, Default)]
struct NoteProperties {
    title: String
}

let text = r#"---
title: Example
---
Content"#;

let note: NoteInMemory<NoteProperties> = NoteInMemory::from_string(text).unwrap();
let properties = note.properties().unwrap().unwrap();

assert_eq!(properties.title, "Example");
assert_eq!(note.content().unwrap(), "Content");

impl<T> PartialEq for NoteInMemory<T>

where T: Clone + PartialEq,

fn eq(&self, other: &NoteInMemory<T>) -> 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<T> Eq for NoteInMemory<T>

where T: Clone + Eq,

impl<T> StructuralPartialEq for NoteInMemory<T>

where T: Clone,