DanSandClaude Opus 5.5
d3fa09128e
The History tab copies every chat txid into a fresh set each frame to badge and filter chat transactions: M string allocations for M chat messages. ChatStore gains hasChatTxid(), an O(1) lookup in a txid index that is rebuilt only after the store changed (append, delivery update, erase, clear) and never built for an empty store. clear() also drops the index, so no chat txids linger after a lock. The History tab moves to it in the next commit. The chat note-buffer pump, which runs every frame while chat is idle, built the whole conversation-id list just to see whether the store was empty; it now asks store().empty(), O(1) instead of O(M). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
100 lines
4.6 KiB
C++
100 lines
4.6 KiB
C++
#pragma once
|
|
|
|
// DragonX Wallet - HushChat in-memory message store: the fast read model / dedup view. Durable
|
|
// persistence lives in ChatDatabase; ChatService rehydrates this store from it on unlock.
|
|
|
|
#include "chat_message.h"
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <string>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
namespace dragonx::chat {
|
|
|
|
// Threads messages by conversation_id (cid) and deduplicates by (txid, payload_position) so
|
|
// re-scanning the chain never double-inserts. Not thread-safe — drive from the main thread.
|
|
class ChatStore {
|
|
public:
|
|
// Returns true if newly inserted, false if a duplicate was ignored.
|
|
bool append(const ChatMessage& message);
|
|
|
|
// The dedup key of a message: "<txid>:<payload_position>".
|
|
static std::string messageKey(const std::string& txid, std::size_t payloadPosition);
|
|
// A message with this (txid, position) is in the store (append would refuse it).
|
|
bool contains(const std::string& txid, std::size_t payloadPosition) const {
|
|
return seen_.count(messageKey(txid, payloadPosition)) != 0;
|
|
}
|
|
|
|
// Messages in a conversation, in insertion order.
|
|
std::vector<ChatMessage> conversation(const std::string& conversationId) const;
|
|
|
|
// Update an outgoing echo's delivery status by its local txid. Returns a pointer to the updated
|
|
// message (for the caller to persist), or nullptr if no message has that txid.
|
|
const ChatMessage* updateDelivery(const std::string& txid, ChatDelivery delivery);
|
|
|
|
// Distinct conversation ids, in first-seen order.
|
|
std::vector<std::string> conversationIds() const;
|
|
|
|
// The set of on-chain txids that carried a chat message (sent or received, messages + contact
|
|
// requests). Builds a fresh COPY every call (O(messages) allocations) — prefer hasChatTxid() on hot paths.
|
|
std::unordered_set<std::string> chatTxids() const {
|
|
std::unordered_set<std::string> out;
|
|
out.reserve(messages_.size());
|
|
for (const auto& m : messages_)
|
|
if (!m.txid.empty()) out.insert(m.txid);
|
|
return out;
|
|
}
|
|
|
|
// True if an on-chain txid carried a chat message (History tab "Message" badge / Chat filter). Backed by a
|
|
// txid index rebuilt lazily when revision() moved (once per store mutation, O(messages)); O(1) on an empty
|
|
// store and per lookup. One txid may back several messages; a from-scratch rebuild handles erase correctly.
|
|
bool hasChatTxid(const std::string& txid) const {
|
|
if (messages_.empty() || txid.empty()) return false;
|
|
if (txid_index_rev_ != revision_) rebuildTxidIndex();
|
|
return txid_index_.count(txid) != 0;
|
|
}
|
|
|
|
// Remove every message in a conversation from the in-memory view and return the removed messages
|
|
// (so the caller can delete/tombstone their persisted rows). Re-appends are prevented by the ingest
|
|
// guard (blocked-cid predicate / DB tombstone), not here.
|
|
std::vector<ChatMessage> eraseConversation(const std::string& conversationId);
|
|
|
|
std::size_t size() const { return messages_.size(); }
|
|
bool empty() const { return messages_.empty(); }
|
|
void clear();
|
|
|
|
// Monotonic counter bumped on every mutation (append / updateDelivery change / eraseConversation /
|
|
// clear). Callers memoize expensive per-frame reads (conversation-list build, unread count) against it
|
|
// so they only rebuild when the store actually changed.
|
|
std::uint64_t revision() const { return revision_; }
|
|
|
|
// Count unread incoming messages in a SINGLE pass over the store: an incoming message counts when its
|
|
// cid is not `excluded` and its timestamp is newer than `seenFor(cid)`. Avoids the per-conversation
|
|
// copy+sort that conversation() does — the count doesn't need ordering.
|
|
int countUnread(const std::function<bool(const std::string&)>& excluded,
|
|
const std::function<std::int64_t(const std::string&)>& seenFor) const;
|
|
|
|
private:
|
|
static std::string dedupKey(const ChatMessage& message);
|
|
|
|
void rebuildTxidIndex() const {
|
|
txid_index_.clear();
|
|
txid_index_.reserve(messages_.size());
|
|
for (const auto& m : messages_)
|
|
if (!m.txid.empty()) txid_index_.insert(m.txid);
|
|
txid_index_rev_ = revision_;
|
|
}
|
|
|
|
std::vector<ChatMessage> messages_;
|
|
std::unordered_set<std::string> seen_;
|
|
std::uint64_t revision_ = 0;
|
|
// Lazy memo for hasChatTxid(): valid iff txid_index_rev_ == revision_. revision_ is monotonic and never reset,
|
|
// so append/updateDelivery/eraseConversation/clear all invalidate it (~0 = never built). Main thread only.
|
|
mutable std::unordered_set<std::string> txid_index_;
|
|
mutable std::uint64_t txid_index_rev_ = ~std::uint64_t{0};
|
|
};
|
|
|
|
} // namespace dragonx::chat
|