IdentityManager Class Reference

#include <IdentityManager.h>

Collaboration diagram for IdentityManager:

Public Member Functions
bool	loadMyIdentityFromFile ()
bool	saveMyIdentityToFile () const
void	setMyIdentity (const std::string &uniqueId, const std::string &username)
const std::string &	myUniqueId () const
const std::string &	myUsername () const
bool	loadAddressBookFromFile ()
bool	saveAddressBookToFile () const
void	bindPeer (const std::string &peerId, const std::string &uniqueId, const std::string &username)
std::string	usernameForUnique (const std::string &uniqueId) const
std::optional< std::string >	uniqueForPeer (const std::string &peerId) const
std::optional< std::string >	peerForUnique (const std::string &uniqueId) const
std::optional< std::string >	usernameForPeer (const std::string &peerId) const
void	setUsernameForUnique (const std::string &uniqueId, const std::string &username)
const std::unordered_map< std::string, PeerIdentity > &	all () const
void	erasePeer (const std::string &peerId)

Private Member Functions
bool	writeMeFile () const
bool	readMeFile ()
bool	writeBookFile () const
bool	readBookFile ()

Static Private Member Functions
static const char *	kMeFile ()
static const char *	kBookFile ()

Private Attributes
std::string	myUniqueId_
std::string	myUsername_
std::unordered_map< std::string, PeerIdentity >	byUnique_
std::unordered_map< std::string, std::string >	peerToUnique_

Detailed Description

Definition at line 16 of file IdentityManager.h.

Member Function Documentation

all()

const std::unordered_map< std::string, PeerIdentity > & IdentityManager::all ( ) const

inline

Definition at line 53 of file IdentityManager.h.

    {
        return byUnique_;
    }

bindPeer()

void IdentityManager::bindPeer	(	const std::string &	peerId,
		const std::string &	uniqueId,
		const std::string &	username )

Definition at line 96 of file IdentityManager.cpp.

{
    // 1) If this peerId was previously mapped to some unique, clear that first.
    if (auto it = peerToUnique_.find(peerId); it != peerToUnique_.end())
    {
        const std::string& oldUid = it->second;
        if (oldUid != uniqueId)
        {
            // Unlink old mapping (the old unique keeps its record, but without this peerId)
            auto bit = byUnique_.find(oldUid);
            if (bit != byUnique_.end() && bit->second.peerId == peerId)
                bit->second.peerId.clear();
        }
        peerToUnique_.erase(it);
    }
 
    // 2) If this uniqueId already had a different peerId, remove that stale reverse mapping.
    auto& pi = byUnique_[uniqueId];
    if (!pi.peerId.empty() && pi.peerId != peerId)
    {
        peerToUnique_.erase(pi.peerId); // remove old peerId -> uniqueId
    }
 
    // 3) Set the fresh links (one-to-one at a time)
    peerToUnique_[peerId] = uniqueId;
 
    pi.uniqueId = uniqueId;
    pi.peerId = peerId;
 
    if (!pi.username.empty() && pi.username != username)
    {
        pi.usernamesHistory.emplace_back(pi.username);
        if (pi.usernamesHistory.size() > 10)
            pi.usernamesHistory.erase(pi.usernamesHistory.begin());
    }
    pi.username = username;
 
    (void)saveAddressBookToFile();
}

Here is the call graph for this function:

erasePeer()

void IdentityManager::erasePeer

(

const std::string &

peerId

)

Definition at line 138 of file IdentityManager.cpp.

{
    if (auto it = peerToUnique_.find(peerId); it != peerToUnique_.end())
    {
        const std::string uid = it->second;
        peerToUnique_.erase(it);
        auto bit = byUnique_.find(uid);
        if (bit != byUnique_.end() && bit->second.peerId == peerId)
            bit->second.peerId.clear();
    }
}

kBookFile()

const char * IdentityManager::kBookFile ( )

staticprivate

Definition at line 22 of file IdentityManager.cpp.

{
    static const std::string s_book = (PathManager::getConfigPath() / "identity_book.runic").string();
    return s_book.c_str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

kMeFile()

const char * IdentityManager::kMeFile ( )

staticprivate

Definition at line 17 of file IdentityManager.cpp.

{
    static const std::string s_me = (PathManager::getConfigPath() / "identity_me.runic").string();
    return s_me.c_str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

loadAddressBookFromFile()

bool IdentityManager::loadAddressBookFromFile

(

)

Definition at line 62 of file IdentityManager.cpp.

{
    byUnique_.clear();
    peerToUnique_.clear();
    return readBookFile();
}

Here is the call graph for this function:

loadMyIdentityFromFile()

bool IdentityManager::loadMyIdentityFromFile

(

)

Definition at line 29 of file IdentityManager.cpp.

{
    myUniqueId_.clear();
    myUsername_.clear();
    return readMeFile();
}

Here is the call graph for this function:

myUniqueId()

const std::string & IdentityManager::myUniqueId ( ) const

inline

Definition at line 25 of file IdentityManager.h.

    {
        return myUniqueId_;
    }

myUsername()

const std::string & IdentityManager::myUsername ( ) const

inline

Definition at line 29 of file IdentityManager.h.

    {
        return myUsername_;
    }

peerForUnique()

std::optional< std::string > IdentityManager::peerForUnique

(

const std::string &

uniqueId

)

const

Definition at line 196 of file IdentityManager.cpp.

{
    if (auto it = byUnique_.find(uniqueId); it != byUnique_.end() && !it->second.peerId.empty())
        return it->second.peerId;
    return std::nullopt;
}

readBookFile()

bool IdentityManager::readBookFile ( )

private

Definition at line 313 of file IdentityManager.cpp.

{
    namespace fs = std::filesystem;
    if (!fs::exists(kBookFile()))
        return true;
 
    try
    {
        std::ifstream is(kBookFile(), std::ios::binary);
        is.seekg(0, std::ios::end);
        auto sz = is.tellg();
        is.seekg(0, std::ios::beg);
        std::vector<uint8_t> buf(static_cast<size_t>(sz));
        if (sz > 0)
            is.read(reinterpret_cast<char*>(buf.data()), sz);
 
        size_t off = 0;
        if (Serializer::deserializeString(buf, off) != kBOOK_MAGIC)
            return false;
        (void)Serializer::deserializeInt(buf, off); // ver
 
        int n = Serializer::deserializeInt(buf, off);
        // NOTE: const method; we need to cast away const to fill the map or
        // make this non-const. Easiest: make readBookFile() non-const (done above).
        // So keep this implementation but ensure header declares it non-const.
        return false; // (safety: this should never compile with const)
    }
    catch (...)
    {
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

readMeFile()

bool IdentityManager::readMeFile ( )

private

Definition at line 250 of file IdentityManager.cpp.

{
    namespace fs = std::filesystem;
    if (!fs::exists(kMeFile()))
        return true; // first run is fine
 
    try
    {
        std::ifstream is(kMeFile(), std::ios::binary);
        is.seekg(0, std::ios::end);
        auto sz = is.tellg();
        is.seekg(0, std::ios::beg);
        std::vector<uint8_t> buf(static_cast<size_t>(sz));
        if (sz > 0)
            is.read(reinterpret_cast<char*>(buf.data()), sz);
 
        size_t off = 0;
        if (Serializer::deserializeString(buf, off) != kME_MAGIC)
            return false;
        (void)Serializer::deserializeInt(buf, off); // ver
        myUniqueId_ = Serializer::deserializeString(buf, off);
        myUsername_ = Serializer::deserializeString(buf, off);
        return true;
    }
    catch (...)
    {
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveAddressBookToFile()

bool IdentityManager::saveAddressBookToFile

(

)

const

Definition at line 69 of file IdentityManager.cpp.

{
    return writeBookFile();
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveMyIdentityToFile()

bool IdentityManager::saveMyIdentityToFile

(

)

const

Definition at line 36 of file IdentityManager.cpp.

{
    return writeMeFile();
}

Here is the call graph for this function:

Here is the caller graph for this function:

setMyIdentity()

void IdentityManager::setMyIdentity	(	const std::string &	uniqueId,
		const std::string &	username )

Definition at line 41 of file IdentityManager.cpp.

{
    myUniqueId_ = uniqueId;
    myUsername_ = username;
    (void)saveMyIdentityToFile();
 
    // also mirror into address book
    auto& pi = byUnique_[uniqueId];
    pi.uniqueId = uniqueId;
    if (!pi.username.empty() && pi.username != username)
    {
        pi.usernamesHistory.emplace_back(pi.username);
        if (pi.usernamesHistory.size() > 10) // cap
            pi.usernamesHistory.erase(pi.usernamesHistory.begin());
    }
    pi.username = username;
    (void)saveAddressBookToFile();
}

Here is the call graph for this function:

setUsernameForUnique()

void IdentityManager::setUsernameForUnique	(	const std::string &	uniqueId,
		const std::string &	username )

Definition at line 151 of file IdentityManager.cpp.

{
    if (uniqueId == myUniqueId_)
    {
        if (myUsername_ != username)
        {
            myUsername_ = username;
            (void)saveMyIdentityToFile();
        }
    }
 
    auto& pi = byUnique_[uniqueId];
    if (!pi.username.empty() && pi.username != username)
    {
        pi.usernamesHistory.emplace_back(pi.username);
        if (pi.usernamesHistory.size() > 10)
            pi.usernamesHistory.erase(pi.usernamesHistory.begin());
    }
    pi.uniqueId = uniqueId;
    pi.username = username;
    (void)saveAddressBookToFile();
}

Here is the call graph for this function:

uniqueForPeer()

std::optional< std::string > IdentityManager::uniqueForPeer

(

const std::string &

peerId

)

const

Definition at line 189 of file IdentityManager.cpp.

{
    if (auto it = peerToUnique_.find(peerId); it != peerToUnique_.end())
        return it->second;
    return std::nullopt;
}

usernameForPeer()

std::optional< std::string > IdentityManager::usernameForPeer

(

const std::string &

peerId

)

const

Definition at line 219 of file IdentityManager.cpp.

{
    for (const auto& kv : peerToUnique_)
        if (kv.first == peerId)
            return usernameForUnique(kv.second);
    return std::nullopt;
}

Here is the call graph for this function:

usernameForUnique()

std::string IdentityManager::usernameForUnique

(

const std::string &

uniqueId

)

const

Definition at line 174 of file IdentityManager.cpp.

{
    auto it = byUnique_.find(uniqueId);
    if (it != byUnique_.end() && !it->second.username.empty())
        return it->second.username;
 
    if (uniqueId == myUniqueId_ && !myUsername_.empty())
        return myUsername_;
 
    // fallback: show truncated uniqueId if unknown
    if (uniqueId.size() > 8)
        return uniqueId.substr(0, 8);
    return uniqueId;
}

Here is the caller graph for this function:

writeBookFile()

bool IdentityManager::writeBookFile ( ) const

private

Definition at line 280 of file IdentityManager.cpp.

{
    try
    {
        std::vector<uint8_t> buf;
        Serializer::serializeString(buf, kBOOK_MAGIC);
        Serializer::serializeInt(buf, kBOOK_VER);
 
        // count
        Serializer::serializeInt(buf, static_cast<int>(byUnique_.size()));
        for (const auto& [uid, pi] : byUnique_)
        {
            Serializer::serializeString(buf, pi.uniqueId);
            Serializer::serializeString(buf, pi.username);
            Serializer::serializeString(buf, pi.peerId);
 
            // history
            Serializer::serializeInt(buf, static_cast<int>(pi.usernamesHistory.size()));
            for (const auto& old : pi.usernamesHistory)
                Serializer::serializeString(buf, old);
        }
 
        std::ofstream os(kBookFile(), std::ios::binary | std::ios::trunc);
        os.write(reinterpret_cast<const char*>(buf.data()),
                 static_cast<std::streamsize>(buf.size()));
        return true;
    }
    catch (...)
    {
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

writeMeFile()

bool IdentityManager::writeMeFile ( ) const

private

Definition at line 229 of file IdentityManager.cpp.

{
    try
    {
        std::vector<uint8_t> buf;
        Serializer::serializeString(buf, kME_MAGIC);
        Serializer::serializeInt(buf, kME_VER);
        Serializer::serializeString(buf, myUniqueId_);
        Serializer::serializeString(buf, myUsername_);
 
        std::ofstream os(kMeFile(), std::ios::binary | std::ios::trunc);
        os.write(reinterpret_cast<const char*>(buf.data()),
                 static_cast<std::streamsize>(buf.size()));
        return true;
    }
    catch (...)
    {
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

byUnique_

std::unordered_map<std::string, PeerIdentity> IdentityManager::byUnique_

private

Definition at line 66 of file IdentityManager.h.

myUniqueId_

std::string IdentityManager::myUniqueId_

private

Definition at line 62 of file IdentityManager.h.

myUsername_

std::string IdentityManager::myUsername_

private

Definition at line 63 of file IdentityManager.h.

peerToUnique_

std::unordered_map<std::string, std::string> IdentityManager::peerToUnique_

private

Definition at line 69 of file IdentityManager.h.

---

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

• include/IdentityManager.h
• src/IdentityManager.cpp