Struct tpnote_lib::content::ContentString

#[repr(transparent)]
pub struct ContentString { /* private fields */ }

Holds the notes content in a string and two string slices header and body. This struct is self referencial. It deals with operating system specific handling of newlines. The content of a note is stored as UTF-8 string with one \n character as newline. If present, a Byte Order Mark BOM is removed while reading with new().

Implementations

impl ContentString

pub fn new(
    owner: String,
    dependent_builder: impl for<'_q> FnOnce(&'_q String) -> ContentRef<'_q>
) -> Self

Examples found in repository

src/content.rs (lines 361-364)

    fn from(input: String) -> Self {
        ContentString::new(input, |owner: &String| {
            let (header, body) = ContentString::split(owner);
            ContentRef { header, body }
        })
    }

pub fn try_new<Err>(
    owner: String,
    dependent_builder: impl for<'_q> FnOnce(&'_q String) -> Result<ContentRef<'_q>, Err>
) -> Result<Self, Err>

pub fn try_new_or_recover<Err>(
    owner: String,
    dependent_builder: impl for<'_q> FnOnce(&'_q String) -> Result<ContentRef<'_q>, Err>
) -> Result<Self, (String, Err)>

pub fn borrow_owner<'_q>(&'_q self) -> &'_q String

Examples found in repository

src/content.rs (line 392)

    fn as_ref(&self) -> &str {
        self.borrow_owner()
    }

pub fn with_dependent<'outer_fn, Ret>(
    &'outer_fn self,
    func: impl for<'_q> FnOnce(&'_q String, &'outer_fn ContentRef<'_q>) -> Ret
) -> Ret

pub fn with_dependent_mut<'outer_fn, Ret>(
    &'outer_fn mut self,
    func: impl for<'_q> FnOnce(&'_q String, &'outer_fn mut ContentRef<'_q>) -> Ret
) -> Ret

pub fn borrow_dependent<'_q>(&'_q self) -> &'_q ContentRef<'_q>

Examples found in repository

src/content.rs (line 372)

    fn header(&self) -> &str {
        self.borrow_dependent().header
    }

    /// Cheap access to the note's body.
    fn body(&self) -> &str {
        self.borrow_dependent().body
    }
}

/// Default is the empty string.
impl Default for ContentString {
    fn default() -> Self {
        Self::from(String::new())
    }
}

/// Returns the whole raw content with header and body.
/// Possible `\r\n` in the input are replaced by `\n`.
impl AsRef<str> for ContentString {
    fn as_ref(&self) -> &str {
        self.borrow_owner()
    }
}

/// Concatenates the header and the body and prints the content.
/// This function is expensive as it involves copying the
/// whole content.
impl<'a> fmt::Display for ContentRef<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = if self.header.is_empty() {
            self.body.to_string()
        } else {
            format!("\u{feff}---\n{}\n---\n{}", &self.header, &self.body)
        };
        write!(f, "{}", s)
    }
}

/// Delegates the printing to `Display for ContentRef`.
impl fmt::Display for ContentString {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        std::fmt::Display::fmt(&self.borrow_dependent(), f)
    }

pub fn into_owner(self) -> String

Trait Implementations

impl AsRef<str> for ContentString

Returns the whole raw content with header and body. Possible \r\n in the input are replaced by \n.

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Content for ContentString

Add header() and body() implementation.

fn header(&self) -> &str

Cheap access to the note’s header.

fn body(&self) -> &str

Cheap access to the note’s body.

fn open(path: &Path) -> Result<Self, Error>where
    Self: Sized,

Reads the file at path and stores the content Content. Possible \r\n are replaced by \n. This trait has a default implementation, the empty content.

fn from_string_with_cr(input: String) -> Self

Constructor that reads a structured document with a YAML header and body. All \r\n are converted to \n if there are any. If not, no memory allocation occurs and the buffer remains untouched.

fn save_as(&self, new_file_path: &Path) -> Result<(), Error>

Writes the note to disk with new_file_path as filename. If new_file_path contains missing directories, they will be created on the fly.

fn as_str(&self) -> &str

Accesses the whole content with all ---. Contract: The content does not contain any \r\n. If your content contains \r\n use the from_string_with_cr() constructor. Possible BOM at the first position is not returned.

fn is_empty(&self) -> bool

True if the header and body is empty.

fn split(content: &str) -> (&str, &str)

Helper function that splits the content into header and body. The header, if present, is trimmed (trim()), the body is kept as it is. Any BOM (byte order mark) at the beginning is ignored.

impl Debug for ContentString

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

Formats the value using the given formatter.

impl Default for ContentString

Default is the empty string.

fn default() -> Self

Returns the “default value” for a type.

impl Display for ContentString

Delegates the printing to Display for ContentRef.

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

Formats the value using the given formatter.

impl Drop for ContentString

fn drop(&mut self)

Executes the destructor for this type.

impl From<String> for ContentString

Constructor that parses a Tp-Note document. A valid document is UTF-8 encoded and starts with an optional BOM (byte order mark) followed by ---. When the start marker --- does not follow directly the BOM, it must be prepended by an empty line. In this case all text before is ignored: BOM + ignored text + empty line + ---. Contract: the imput string does not contain \r\n. If it may, use Content::from_string_with_cr() instead.

use tpnote_lib::content::Content;
use tpnote_lib::content::ContentString;
let input = "---\ntitle: \"My note\"\n---\nMy body";
let c = ContentString::from(input.to_string());

assert_eq!(c.header(), r#"title: "My note""#);
assert_eq!(c.body(), "My body");

// A test without front matter leads to an empty header:
let c = ContentString::from("No header".to_string());

assert_eq!(c.header(), "");
assert_eq!(c.body(), "No header");

fn from(input: String) -> Self

Self referential. The constructor splits the content in header and body.

impl PartialEq<ContentString> for ContentString

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for ContentString