Struct ObFileInMemory

pub struct ObFileInMemory<T = HashMap<String, Value>>
where
    T: DeserializeOwned + 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 ObFileOnDisk.

Trait Implementations

impl<T> Clone for ObFileInMemory<T>

where T: DeserializeOwned + Clone + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ObFileInMemory<T>

where T: DeserializeOwned + Clone + Debug,

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

Formats the value using the given formatter.

impl<T> Default for ObFileInMemory<T>

where T: DeserializeOwned + Clone + Default,

fn default() -> ObFileInMemory<T>

Returns the “default value” for a type.

impl<T: DeserializeOwned + Clone> ObFile<T> for ObFileInMemory<T>

fn from_string<P: AsRef<Path>>( raw_text: &str, path: Option<P>, ) -> Result<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 note = r#"---
title: Example
---
Content"#;

let file: ObFileInMemory<NoteProperties> = ObFileInMemory::from_string(note, None::<&str>).unwrap();
let properties = file.properties().unwrap().unwrap();

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

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

Returns the main content body of the note (excluding frontmatter)

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

Returns the source file path if available

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

Returns the parsed properties of frontmatter

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

Get note name

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

Parses an Obsidian note from a file

impl<T> PartialEq for ObFileInMemory<T>

where T: DeserializeOwned + Clone + PartialEq,

fn eq(&self, other: &ObFileInMemory<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 ObFileInMemory<T>

where T: DeserializeOwned + Clone + Eq,

impl<T> StructuralPartialEq for ObFileInMemory<T>

where T: DeserializeOwned + Clone,