NotesManager Class Reference

#include <NotesManager.h>

Collaboration diagram for NotesManager:

Public Member Functions
	NotesManager (NotesManagerConfig cfg, std::shared_ptr< ImGuiToaster > toaster)
void	loadAllFromDisk ()
void	loadFromGlobal ()
void	loadFromTable (const std::string &tableName)
std::string	createNote (std::string title, std::string author, std::optional< std::string > tableName=std::nullopt)
bool	saveNote (const std::string &uuid)
bool	saveNoteAs (const std::string &uuid, const std::filesystem::path &absolutePath)
bool	deleteNote (const std::string &uuid, bool deleteFromDisk)
std::shared_ptr< Note >	getNote (const std::string &uuid)
std::shared_ptr< const Note >	getNote (const std::string &uuid) const
std::vector< std::shared_ptr< Note > >	listAll ()
std::vector< std::shared_ptr< Note > >	listMyNotes ()
std::vector< std::shared_ptr< Note > >	listInbox ()
void	setTitle (const std::string &uuid, std::string title)
void	setContent (const std::string &uuid, std::string md)
void	setAuthor (const std::string &uuid, std::string author)
std::string	upsertSharedIncoming (std::string uuid, std::string title, std::string author, std::string markdown, std::optional< std::string > fromPeerName)
bool	saveInboxToLocal (const std::string &uuid, std::optional< std::string > tableName=std::nullopt)
std::filesystem::path	defaultSavePath (const Note &note) const
std::shared_ptr< Note >	getByUuid (const std::string &uuid) const
std::string	resolveRef (const std::string &ref) const
void	indexNote (const std::shared_ptr< Note > &n)
void	removeFromIndex (const std::string &uuid)

Static Public Member Functions
static std::string	generateUUID ()
static std::string	slugify (const std::string &title)
static int64_t	toEpochMillis (std::chrono::system_clock::time_point tp)
static std::chrono::system_clock::time_point	fromEpochMillis (int64_t ms)
static bool	parseMarkdownFile (const std::filesystem::path &path, Note &outNote)
static bool	writeMarkdownFile (const std::filesystem::path &path, const Note &note)

Private Member Functions
void	scanFolderForMd_ (const std::filesystem::path &dir, std::optional< std::string > tableName)
void	toastInfo (const std::string &msg) const
void	toastGood (const std::string &msg) const
void	toastWarn (const std::string &msg) const
void	toastError (const std::string &msg) const

Static Private Member Functions
static bool	looksLikeUuid_ (const std::string &s)
static bool	looksLikeShortHex_ (const std::string &s)
static std::string	toLower_ (const std::string &s)

Private Attributes
std::unordered_map< std::string, std::shared_ptr< Note > >	notesByUuid_
std::unordered_map< std::string, std::string >	titleToUuid_
NotesManagerConfig	cfg_
std::shared_ptr< ImGuiToaster >	toaster_
std::mutex	mtx_
std::unordered_map< std::string, std::shared_ptr< Note > >	notesById_

Detailed Description

Definition at line 49 of file NotesManager.h.

Constructor & Destructor Documentation

NotesManager()

NotesManager::NotesManager	(	NotesManagerConfig	cfg,
		std::shared_ptr< ImGuiToaster >	toaster )

Definition at line 20 of file NotesManager.cpp.

                                                                                      :
    cfg_(std::move(cfg)), toaster_(std::move(toaster))
{
    std::error_code ec;
    if (!cfg_.globalNotesDir.empty())
        std::filesystem::create_directories(cfg_.globalNotesDir, ec);
    if (!cfg_.gameTablesRootDir.empty())
        std::filesystem::create_directories(cfg_.gameTablesRootDir, ec);
}

Member Function Documentation

createNote()

std::string NotesManager::createNote	(	std::string	title,
		std::string	author,
		std::optional< std::string >	tableName = std::nullopt )

Definition at line 95 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
 
    auto n = std::make_shared<Note>();
    n->uuid = generateUUID();
    n->title = std::move(title);
    n->author = std::move(author);
    n->table_name = std::move(tableName);
    n->creation_ts = Clock::now();
    n->last_update_ts = n->creation_ts;
    n->saved_locally = false;
    n->dirty = true;
    n->shared = false;
    n->inbox = false;
    n->open_editor = true;
 
    auto id = n->uuid;
    notesById_.emplace(id, std::move(n));
    toastGood("Note created: " + id);
    return id;
}

Here is the call graph for this function:

defaultSavePath()

std::filesystem::path NotesManager::defaultSavePath

(

const Note &

note

)

const

Definition at line 347 of file NotesManager.cpp.

{
    auto slug = slugify(n.title.empty() ? "note" : n.title);
    auto fname = slug + "__" + n.uuid + ".md";
    if (n.table_name)
        return cfg_.gameTablesRootDir / *n.table_name / "Notes" / fname;
    return cfg_.globalNotesDir / fname;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deleteNote()

bool NotesManager::deleteNote	(	const std::string &	uuid,
		bool	deleteFromDisk )

Definition at line 173 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
        return false;
 
    if (deleteFromDisk && !it->second->file_path.empty())
    {
        std::error_code ec;
        std::filesystem::remove(it->second->file_path, ec);
    }
    notesById_.erase(it);
    toastWarn("Note deleted");
    return true;
}

Here is the call graph for this function:

fromEpochMillis()

std::chrono::system_clock::time_point NotesManager::fromEpochMillis ( int64_t ms )

static

Definition at line 390 of file NotesManager.cpp.

{
    return std::chrono::system_clock::time_point(std::chrono::milliseconds(ms));
}

Here is the caller graph for this function:

generateUUID()

std::string NotesManager::generateUUID ( )

static

Definition at line 357 of file NotesManager.cpp.

{
    std::random_device rd;
    std::mt19937_64 gen(rd());
    uint64_t a = gen(), b = gen();
    std::ostringstream oss;
    oss << std::hex << std::nouppercase << std::setfill('0')
        << std::setw(16) << a << std::setw(16) << b;
    return oss.str();
}

Here is the caller graph for this function:

getByUuid()

std::shared_ptr< Note > NotesManager::getByUuid

(

const std::string &

uuid

)

const

Definition at line 551 of file NotesManager.cpp.

{
    auto it = notesByUuid_.find(uuid);
    return (it != notesByUuid_.end()) ? it->second : nullptr;
}

getNote() [1/2]

std::shared_ptr< Note > NotesManager::getNote

(

const std::string &

uuid

)

Definition at line 190 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    return (it == notesById_.end() ? nullptr : it->second);
}

getNote() [2/2]

std::shared_ptr< const Note > NotesManager::getNote

(

const std::string &

uuid

)

const

Definition at line 197 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    return (it == notesById_.end() ? nullptr : it->second);
}

indexNote()

void NotesManager::indexNote

(

const std::shared_ptr< Note > &

n

)

Definition at line 557 of file NotesManager.cpp.

{
    if (!n)
        return;
    notesByUuid_[n->uuid] = n;
 
    // exact, case-insensitive index for title
    if (!n->title.empty())
    {
        titleToUuid_[toLower_(n->title)] = n->uuid;
    }
}

Here is the call graph for this function:

listAll()

std::vector< std::shared_ptr< Note > > NotesManager::listAll

(

)

Definition at line 204 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    std::vector<std::shared_ptr<Note>> v;
    v.reserve(notesById_.size());
    for (auto& kv : notesById_)
        v.push_back(kv.second);
    return v;
}

listInbox()

std::vector< std::shared_ptr< Note > > NotesManager::listInbox

(

)

Definition at line 227 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    std::vector<std::shared_ptr<Note>> v;
    v.reserve(notesById_.size());
    for (auto& kv : notesById_)
    {
        if (kv.second->inbox)
            v.push_back(kv.second);
    }
    return v;
}

listMyNotes()

std::vector< std::shared_ptr< Note > > NotesManager::listMyNotes

(

)

Definition at line 214 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    std::vector<std::shared_ptr<Note>> v;
    v.reserve(notesById_.size());
    for (auto& kv : notesById_)
    {
        if (!kv.second->inbox)
            v.push_back(kv.second);
    }
    return v;
}

loadAllFromDisk()

void NotesManager::loadAllFromDisk

(

)

Definition at line 30 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    notesById_.clear();
 
    scanFolderForMd_(cfg_.globalNotesDir, std::nullopt);
 
    if (!cfg_.gameTablesRootDir.empty() && std::filesystem::exists(cfg_.gameTablesRootDir))
    {
        for (auto& dir : std::filesystem::directory_iterator(cfg_.gameTablesRootDir))
        {
            if (!dir.is_directory())
                continue;
            auto tableName = dir.path().filename().string();
            auto notesDir = dir.path() / "Notes";
            scanFolderForMd_(notesDir, tableName);
        }
    }
    toastInfo("Notes loaded from disk.");
}

Here is the call graph for this function:

loadFromGlobal()

void NotesManager::loadFromGlobal

(

)

Definition at line 51 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    scanFolderForMd_(cfg_.globalNotesDir, std::nullopt);
    toastInfo("Global notes loaded.");
}

Here is the call graph for this function:

loadFromTable()

void NotesManager::loadFromTable

(

const std::string &

tableName

)

Definition at line 58 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto notesDir = cfg_.gameTablesRootDir / tableName / "Notes";
    scanFolderForMd_(notesDir, tableName);
    toastInfo("Table notes loaded: " + tableName);
}

Here is the call graph for this function:

looksLikeShortHex_()

bool NotesManager::looksLikeShortHex_ ( const std::string & s )

staticprivate

Definition at line 666 of file NotesManager.cpp.

{
    if (s.size() < 8)
        return false; // minimum 8 for usefulness
    for (char c : s)
    {
        if (c == '-')
            return false;
        if (!std::isxdigit((unsigned char)c))
            return false;
    }
    return true;
}

Here is the caller graph for this function:

looksLikeUuid_()

bool NotesManager::looksLikeUuid_ ( const std::string & s )

staticprivate

Definition at line 645 of file NotesManager.cpp.

{
    // Very loose: 8-4-4-4-12 hex + dashes
    if (s.size() != 36)
        return false;
    const int dashPos[4] = {8, 13, 18, 23};
    for (int i = 0; i < 36; ++i)
    {
        if (i == dashPos[0] || i == dashPos[1] || i == dashPos[2] || i == dashPos[3])
        {
            if (s[i] != '-')
                return false;
        }
        else if (!std::isxdigit((unsigned char)s[i]))
        {
            return false;
        }
    }
    return true;
}

Here is the caller graph for this function:

parseMarkdownFile()

bool NotesManager::parseMarkdownFile ( const std::filesystem::path & path, Note & outNote )

static

Definition at line 396 of file NotesManager.cpp.

{
    std::ifstream in(path, std::ios::binary);
    if (!in)
        return false;
    std::string text((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
    in.close();
 
    size_t pos = 0;
    auto startsWith = [&](const char* s)
    { return text.compare(pos, std::strlen(s), s) == 0; };
 
    std::unordered_map<std::string, std::string> meta;
    std::string body;
 
    if (startsWith("---"))
    {
        pos += 3;
        while (pos < text.size() && (text[pos] == '\r' || text[pos] == '\n'))
            ++pos;
        while (pos < text.size())
        {
            if (text.compare(pos, 3, "---") == 0)
            {
                pos += 3;
                while (pos < text.size() && (text[pos] == '\r' || text[pos] == '\n'))
                    ++pos;
                break;
            }
            size_t lineEnd = text.find_first_of("\r\n", pos);
            std::string line = (lineEnd == std::string::npos) ? text.substr(pos)
                                                              : text.substr(pos, lineEnd - pos);
            if (lineEnd == std::string::npos)
                pos = text.size();
            else
            {
                pos = lineEnd;
                while (pos < text.size() && (text[pos] == '\r' || text[pos] == '\n'))
                    ++pos;
            }
            auto colon = line.find(':');
            if (colon != std::string::npos)
            {
                auto k = line.substr(0, colon);
                auto v = line.substr(colon + 1);
                auto ltrim = [](std::string& s)
                { s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch)
                                                  { return !std::isspace(ch); })); };
                auto rtrim = [](std::string& s)
                { s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch)
                                       { return !std::isspace(ch); })
                              .base(),
                          s.end()); };
                auto trim = [&](std::string& s)
                { ltrim(s); rtrim(s); };
                trim(k);
                trim(v);
                meta[k] = v;
            }
        }
        body = (pos < text.size()) ? text.substr(pos) : std::string{};
    }
    else
    {
        body = text;
    }
 
    Note n;
    n.uuid = meta.count("uuid") ? meta["uuid"] : generateUUID();
    n.title = meta.count("title") ? meta["title"] : path.stem().string();
    n.author = meta.count("author") ? meta["author"] : "unknown";
    if (meta.count("creation_ts"))
    {
        try
        {
            n.creation_ts = fromEpochMillis(std::stoll(meta["creation_ts"]));
        }
        catch (...)
        {
            n.creation_ts = Clock::now();
        }
    }
    else
        n.creation_ts = Clock::now();
    if (meta.count("last_update_ts"))
    {
        try
        {
            n.last_update_ts = fromEpochMillis(std::stoll(meta["last_update_ts"]));
        }
        catch (...)
        {
            n.last_update_ts = n.creation_ts;
        }
    }
    else
        n.last_update_ts = n.creation_ts;
 
    if (meta.count("table") && !meta["table"].empty())
        n.table_name = meta["table"];
    if (meta.count("shared"))
        n.shared = (meta["shared"] == "1");
    if (meta.count("shared_from") && !meta["shared_from"].empty())
        n.shared_from = meta["shared_from"];
 
    n.markdown_text = std::move(body);
    outNote = std::move(n);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

removeFromIndex()

void NotesManager::removeFromIndex

(

const std::string &

uuid

)

Definition at line 570 of file NotesManager.cpp.

{
    auto it = notesByUuid_.find(uuid);
    if (it == notesByUuid_.end())
        return;
 
    // erase title index if it points to this uuid
    if (!it->second->title.empty())
    {
        auto key = toLower_(it->second->title);
        auto jt = titleToUuid_.find(key);
        if (jt != titleToUuid_.end() && jt->second == uuid)
        {
            titleToUuid_.erase(jt);
        }
    }
    notesByUuid_.erase(it);
}

Here is the call graph for this function:

resolveRef()

std::string NotesManager::resolveRef

(

const std::string &

ref

)

const

Definition at line 589 of file NotesManager.cpp.

{
    if (ref.empty())
        return {};
 
    // 1) full UUID? (very loose validation) and it exists
    if (looksLikeUuid_(ref))
    {
        if (notesByUuid_.find(ref) != notesByUuid_.end())
            return ref;
        // if it "looks like uuid" but doesn't exist, fall through to title (user may have typed a title with dashes)
    }
 
    // 2) title (case-insensitive exact match)
    {
        auto it = titleToUuid_.find(toLower_(ref));
        if (it != titleToUuid_.end())
            return it->second;
    }
 
    // 3) short id (>=8 hex chars, no dashes) — optional bonus
    if (looksLikeShortHex_(ref))
    {
        std::string matchUuid;
        bool ambig = false;
        for (const auto& kv : notesByUuid_)
        {
            const std::string& uuid = kv.first; // canonical 36-char UUID
            // compare only hex chars (ignore dashes) at the front
            std::string compact;
            compact.reserve(32);
            for (char c : uuid)
                if (c != '-')
                    compact.push_back((char)std::tolower((unsigned char)c));
 
            std::string needle = toLower_(ref);
            if (compact.rfind(needle, 0) == 0)
            { // prefix match
                if (matchUuid.empty())
                    matchUuid = uuid;
                else
                {
                    ambig = true;
                    break;
                }
            }
        }
        if (!ambig && !matchUuid.empty())
            return matchUuid;
        // ambiguous or not found → fall through
    }
 
    return {};
}

Here is the call graph for this function:

saveInboxToLocal()

bool NotesManager::saveInboxToLocal	(	const std::string &	uuid,
		std::optional< std::string >	tableName = std::nullopt )

Definition at line 316 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
        return false;
    auto& n = *it->second;
 
    if (tableName)
        n.table_name = tableName;
 
    std::error_code ec;
    if (n.file_path.empty())
    {
        n.file_path = defaultSavePath(n);
    }
    std::filesystem::create_directories(n.file_path.parent_path(), ec);
 
    n.last_update_ts = Clock::now();
    if (!writeMarkdownFile(n.file_path, n))
    {
        toastError("Failed to save inbox note.");
        return false;
    }
    n.saved_locally = true;
    n.inbox = false;
    toastGood("Saved to disk: " + n.title);
    return true;
}

Here is the call graph for this function:

saveNote()

bool NotesManager::saveNote

(

const std::string &

uuid

)

Definition at line 120 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
        return false;
    auto& n = *it->second;
 
    std::error_code ec;
    if (n.file_path.empty())
    {
        n.file_path = defaultSavePath(n);
    }
    std::filesystem::create_directories(n.file_path.parent_path(), ec);
 
    n.last_update_ts = Clock::now();
    if (!writeMarkdownFile(n.file_path, n))
    {
        toastError("Failed to save: " + n.title);
        return false;
    }
    n.saved_locally = true;
    n.dirty = false;
    n.inbox = false;
    toastGood("Saved: " + n.title);
    return true;
}

Here is the call graph for this function:

saveNoteAs()

bool NotesManager::saveNoteAs	(	const std::string &	uuid,
		const std::filesystem::path &	absolutePath )

Definition at line 148 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
        return false;
    auto& n = *it->second;
 
    std::error_code ec;
    std::filesystem::create_directories(absolutePath.parent_path(), ec);
 
    n.last_update_ts = Clock::now();
    if (!writeMarkdownFile(absolutePath, n))
    {
        toastError("Failed to save as: " + absolutePath.string());
        return false;
    }
    n.file_path = absolutePath;
    n.saved_locally = true;
    n.dirty = false;
    n.inbox = false;
    toastGood("Saved as: " + absolutePath.filename().string());
    return true;
}

Here is the call graph for this function:

scanFolderForMd_()

void NotesManager::scanFolderForMd_ ( const std::filesystem::path & dir, std::optional< std::string > tableName )

private

Definition at line 66 of file NotesManager.cpp.

{
    std::error_code ec;
    if (dir.empty() || !std::filesystem::exists(dir, ec))
        return;
 
    for (auto& entry : std::filesystem::directory_iterator(dir, ec))
    {
        if (!entry.is_regular_file(ec))
            continue;
        if (!isMarkdownExt(entry.path()))
            continue;
 
        Note temp;
        if (parseMarkdownFile(entry.path(), temp))
        {
            auto n = std::make_shared<Note>(std::move(temp));
            n->file_path = entry.path();
            n->saved_locally = true;
            n->dirty = false;
            n->inbox = false;
            if (tableName)
                n->table_name = tableName;
            notesById_[n->uuid] = std::move(n);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setAuthor()

void NotesManager::setAuthor	(	const std::string &	uuid,
		std::string	author )

Definition at line 262 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
        return;
    it->second->author = std::move(author);
    it->second->dirty = true;
    it->second->last_update_ts = Clock::now();
}

setContent()

void NotesManager::setContent	(	const std::string &	uuid,
		std::string	md )

Definition at line 251 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
        return;
    it->second->markdown_text = std::move(md);
    it->second->dirty = true;
    it->second->last_update_ts = Clock::now();
}

setTitle()

void NotesManager::setTitle	(	const std::string &	uuid,
		std::string	title )

Definition at line 240 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
        return;
    it->second->title = std::move(title);
    it->second->dirty = true;
    it->second->last_update_ts = Clock::now();
}

slugify()

std::string NotesManager::slugify ( const std::string & title )

static

Definition at line 368 of file NotesManager.cpp.

{
    std::string out;
    out.reserve(s.size());
    for (unsigned char c : s)
    {
        if (std::isalnum(c))
            out.push_back((char)std::tolower(c));
        else if (c == ' ' || c == '-' || c == '_')
            out.push_back('-');
    }
    while (!out.empty() && out.back() == '-')
        out.pop_back();
    if (out.empty())
        out = "note";
    return out;
}

Here is the caller graph for this function:

toastError()

void NotesManager::toastError ( const std::string & msg ) const

private

Definition at line 545 of file NotesManager.cpp.

{
    if (toaster_)
        toaster_->Push(ImGuiToaster::Level::Error, msg);
}

Here is the caller graph for this function:

toastGood()

void NotesManager::toastGood ( const std::string & msg ) const

private

Definition at line 535 of file NotesManager.cpp.

{
    if (toaster_)
        toaster_->Push(ImGuiToaster::Level::Good, msg);
}

Here is the caller graph for this function:

toastInfo()

void NotesManager::toastInfo ( const std::string & msg ) const

private

Definition at line 530 of file NotesManager.cpp.

{
    if (toaster_)
        toaster_->Push(ImGuiToaster::Level::Info, msg);
}

Here is the caller graph for this function:

toastWarn()

void NotesManager::toastWarn ( const std::string & msg ) const

private

Definition at line 540 of file NotesManager.cpp.

{
    if (toaster_)
        toaster_->Push(ImGuiToaster::Level::Warning, msg);
}

Here is the caller graph for this function:

toEpochMillis()

int64_t NotesManager::toEpochMillis ( std::chrono::system_clock::time_point tp )

static

Definition at line 386 of file NotesManager.cpp.

{
    return std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch()).count();
}

Here is the caller graph for this function:

toLower_()

std::string NotesManager::toLower_ ( const std::string & s )

staticprivate

Definition at line 680 of file NotesManager.cpp.

{
    std::string out;
    out.resize(s.size());
    std::transform(s.begin(), s.end(), out.begin(),
                   [](unsigned char c)
                   { return (char)std::tolower(c); });
    return out;
}

Here is the caller graph for this function:

upsertSharedIncoming()

std::string NotesManager::upsertSharedIncoming	(	std::string	uuid,
		std::string	title,
		std::string	author,
		std::string	markdown,
		std::optional< std::string >	fromPeerName )

Definition at line 273 of file NotesManager.cpp.

{
    std::lock_guard<std::mutex> lk(mtx_);
    if (uuid.empty())
        uuid = generateUUID();
 
    auto it = notesById_.find(uuid);
    if (it == notesById_.end())
    {
        auto n = std::make_shared<Note>();
        n->uuid = uuid;
        n->title = std::move(title);
        n->author = std::move(author);
        n->markdown_text = std::move(markdown);
        n->creation_ts = Clock::now();
        n->last_update_ts = n->creation_ts;
        n->saved_locally = false;
        n->dirty = false;
        n->shared = true;
        n->inbox = true;
        n->shared_from = std::move(fromPeerName);
        n->open_editor = false;
        notesById_.emplace(uuid, std::move(n));
    }
    else
    {
        auto& n = *it->second;
        n.title = std::move(title);
        n.author = std::move(author);
        n.markdown_text = std::move(markdown);
        n.last_update_ts = Clock::now();
        n.shared = true;
        n.inbox = true;
        n.shared_from = std::move(fromPeerName);
        n.dirty = false;
    }
    return uuid;
}

Here is the call graph for this function:

writeMarkdownFile()

bool NotesManager::writeMarkdownFile ( const std::filesystem::path & path, const Note & note )

static

Definition at line 506 of file NotesManager.cpp.

{
    std::ofstream out(path, std::ios::binary);
    if (!out)
        return false;
 
    auto c_ms = toEpochMillis(note.creation_ts);
    auto u_ms = toEpochMillis(note.last_update_ts);
 
    out << "---\n";
    out << "uuid: " << note.uuid << "\n";
    out << "title: " << note.title << "\n";
    out << "author: " << note.author << "\n";
    out << "creation_ts: " << c_ms << "\n";
    out << "last_update_ts: " << u_ms << "\n";
    out << "table: " << (note.table_name ? *note.table_name : "") << "\n";
    out << "shared: " << (note.shared ? "1" : "0") << "\n";
    out << "shared_from: " << (note.shared_from ? *note.shared_from : "") << "\n";
    out << "---\n";
    out << note.markdown_text;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cfg_

NotesManagerConfig NotesManager::cfg_

private

Definition at line 123 of file NotesManager.h.

mtx_

std::mutex NotesManager::mtx_

mutableprivate

Definition at line 126 of file NotesManager.h.

notesById_

std::unordered_map<std::string, std::shared_ptr<Note> > NotesManager::notesById_

private

Definition at line 127 of file NotesManager.h.

notesByUuid_

std::unordered_map<std::string, std::shared_ptr<Note> > NotesManager::notesByUuid_

private

Definition at line 113 of file NotesManager.h.

titleToUuid_

std::unordered_map<std::string, std::string> NotesManager::titleToUuid_

private

Definition at line 116 of file NotesManager.h.

toaster_

std::shared_ptr<ImGuiToaster> NotesManager::toaster_

private

Definition at line 124 of file NotesManager.h.

---

The documentation for this class was generated from the following files:

• include/note_editor/NotesManager.h
• src/note_editor/NotesManager.cpp