From 6c58f1e095f7dbe1e7e1654c1807a76276a2f3f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roman=20Smr=C5=BE?= Date: Sat, 5 Jun 2021 23:10:24 +0200 Subject: Contact list in shared state --- include/erebos/attach.h | 2 +- include/erebos/contact.h | 47 ++++++++++++++ include/erebos/identity.h | 6 ++ include/erebos/list.h | 116 +++++++++++++++++++++++++++++++++++ src/CMakeLists.txt | 1 + src/contact.cpp | 153 ++++++++++++++++++++++++++++++++++++++++++++++ src/contact.h | 42 +++++++++++++ src/identity.cpp | 12 ++++ src/identity.h | 3 +- 9 files changed, 379 insertions(+), 3 deletions(-) create mode 100644 include/erebos/contact.h create mode 100644 include/erebos/list.h create mode 100644 src/contact.cpp create mode 100644 src/contact.h diff --git a/include/erebos/attach.h b/include/erebos/attach.h index 14e6af3..dab0110 100644 --- a/include/erebos/attach.h +++ b/include/erebos/attach.h @@ -39,7 +39,7 @@ template class Signed; struct AttachIdentity { - Stored> identity; + Stored> identity; vector> keys; static AttachIdentity load(const Ref &); diff --git a/include/erebos/contact.h b/include/erebos/contact.h new file mode 100644 index 0000000..e56346a --- /dev/null +++ b/include/erebos/contact.h @@ -0,0 +1,47 @@ +#pragma once + +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace erebos { + +using std::optional; +using std::shared_ptr; +using std::string; +using std::vector; + +class Contact +{ +public: + Contact(const Contact &) = default; + Contact(Contact &&) = default; + Contact & operator=(const Contact &) = default; + Contact & operator=(Contact &&) = default; + + static List prepend(const Storage &, Identity, List); + + Identity identity() const; + optional name() const; + + bool operator==(const Contact &) const; + bool operator!=(const Contact &) const; + + static List loadList(const vector &); + vector refs() const; + +private: + struct Priv; + shared_ptr p; + Contact(shared_ptr p): p(p) {} +}; + +DECLARE_SHARED_TYPE(List) + +} diff --git a/include/erebos/identity.h b/include/erebos/identity.h index d0b60d5..888f162 100644 --- a/include/erebos/identity.h +++ b/include/erebos/identity.h @@ -6,6 +6,10 @@ namespace erebos { using std::optional; +using std::vector; + +template class Signed; +struct IdentityData; class Identity { @@ -17,8 +21,10 @@ public: static std::optional load(const Ref &); static std::optional load(const std::vector &); + static std::optional load(const std::vector>> &); std::vector store() const; std::vector store(const Storage & st) const; + const vector>> & data() const; std::optional name() const; std::optional owner() const; diff --git a/include/erebos/list.h b/include/erebos/list.h new file mode 100644 index 0000000..f5f2d3f --- /dev/null +++ b/include/erebos/list.h @@ -0,0 +1,116 @@ +#pragma once + +#include +#include +#include +#include + +namespace erebos { + +using std::function; +using std::make_shared; +using std::make_unique; +using std::move; +using std::shared_ptr; +using std::unique_ptr; +using std::variant; + +template +class List +{ +public: + struct Nil { bool operator==(const Nil &) const { return true; } }; + struct Cons { + T head; List tail; + bool operator==(const Cons & x) const { return head == x.head && tail == x.tail; } + }; + + List(); + List(const T head, List tail); + + const T & front() const; + const List & tail() const; + + bool empty() const; + + bool operator==(const List &) const; + bool operator!=(const List &) const; + + List push_front(T x) const; + +private: + struct Priv; + shared_ptr p; +}; + +template +struct List::Priv +{ + variant value; + + function eval = {}; + mutable std::once_flag once = {}; +}; + +template +List::List(): + p(shared_ptr(new Priv { Nil() })) +{ + std::call_once(p->once, [](){}); +} + +template +List::List(T head, List tail): + p(shared_ptr(new Priv { + Cons { move(head), move(tail) } + })) +{ + std::call_once(p->once, [](){}); +} + +template +const T & List::front() const +{ + std::call_once(p->once, p->eval); + return std::get(p->value).head; +} + +template +const List & List::tail() const +{ + std::call_once(p->once, p->eval); + return std::get(p->value).tail; +} + +template +bool List::empty() const +{ + std::call_once(p->once, p->eval); + return std::holds_alternative(p->value); +} + +template +bool List::operator==(const List & other) const +{ + if (p == other.p) + return true; + + std::call_once(p->once, p->eval); + std::call_once(other.p->once, other.p->eval); + return p->value == other.p->value; + +} + +template +bool List::operator!=(const List & other) const +{ + return !(*this == other); +} + +template +List List::push_front(T x) const +{ + return List(move(x), *this); +} + +} diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 8f65555..0fd7125 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -5,6 +5,7 @@ include_directories( add_library(erebos attach channel + contact frp identity message diff --git a/src/contact.cpp b/src/contact.cpp new file mode 100644 index 0000000..edc33ea --- /dev/null +++ b/src/contact.cpp @@ -0,0 +1,153 @@ +#include "contact.h" + +#include "identity.h" + +using namespace erebos; + +using std::move; + +DEFINE_SHARED_TYPE(List, + "34fbb61e-6022-405f-b1b3-a5a1abecd25e", + &Contact::loadList, + [](const List & list) { + if (list.empty()) + return vector(); + return list.front().refs(); + }) + + +List Contact::prepend(const Storage & st, Identity id, List list) +{ + auto cd = st.store(ContactData { + .prev = list.empty() ? vector>() : list.front().p->data, + .identity = id.data(), + .name = nullopt, + }); + return list.push_front( + Contact(shared_ptr(new Priv { + .data = { cd }, + .identity = move(id), + })) + ); +} + +Identity Contact::identity() const +{ + return p->identity; +} + +optional Contact::name() const +{ + p->init(); + return p->name; +} + +bool Contact::operator==(const Contact & other) const +{ + return p->data == other.p->data; +} + +bool Contact::operator!=(const Contact & other) const +{ + return p->data != other.p->data; +} + +List Contact::loadList(const vector & refs) +{ + vector> cdata; + cdata.reserve(refs.size()); + + for (const auto & r : refs) + cdata.push_back(Stored::load(r)); + return Priv::loadList(move(cdata), {}); +} + +List Contact::Priv::loadList(vector> && cdata, vector && seen) +{ + if (cdata.empty()) + return {}; + + filterAncestors(cdata); + + for (size_t i = 0; i < cdata.size(); i++) { + auto id = Identity::load(cdata[i]->identity); + if (!id) + continue; + + bool skip = false; + for (const auto & sid : seen) { + if (id->sameAs(sid)) { + skip = true; + break; + } + } + if (skip) + continue; + + vector> next; + next.reserve(cdata.size() - i - 1 + cdata[i]->prev.size()); + for (size_t j = i + 1; j < cdata.size(); j++) + next.push_back(cdata[j]); + for (const auto & x : cdata[i]->prev) + next.push_back(x); + + seen.push_back(*id); + auto p = shared_ptr(new Priv { .data = move(cdata), .identity = move(*id) }); + return List(Contact(p), loadList(move(next), move(seen))); + } + + return {}; +} + +vector Contact::refs() const +{ + vector res; + res.reserve(p->data.size()); + for (const auto & x : p->data) + res.push_back(x.ref()); + return res; +} + +void Contact::Priv::init() +{ + std::call_once(initFlag, [this]() { + name = identity.name(); + }); +} + +ContactData ContactData::load(const Ref & ref) +{ + auto rec = ref->asRecord(); + if (!rec) + return ContactData(); + + vector> prev; + for (const auto & x : rec->items("PREV")) + if (const auto & p = x.as()) + prev.push_back(*p); + + vector>> identity; + for (const auto & x : rec->items("identity")) + if (const auto & i = x.asRef()) + identity.push_back(*i); + + return ContactData { + .prev = std::move(prev), + .identity = std::move(identity), + .name = rec->item("name").asText(), + }; +} + +Ref ContactData::store(const Storage & st) const +{ + vector items; + + for (const auto & prev : prev) + items.emplace_back("PREV", prev.ref()); + for (const auto & idt : identity) + items.emplace_back("identity", idt); + if (name) + items.emplace_back("name", *name); + + return st.storeObject(Record(std::move(items))); +} diff --git a/src/contact.h b/src/contact.h new file mode 100644 index 0000000..31deceb --- /dev/null +++ b/src/contact.h @@ -0,0 +1,42 @@ +#pragma once + +#include + +#include +#include +#include +#include + +namespace erebos { + +using std::optional; +using std::string; +using std::vector; + +struct ContactData; +struct IdentityData; + +struct Contact::Priv +{ + vector> data; + Identity identity; + + void init(); + std::once_flag initFlag {}; + + optional name {}; + + static List loadList(vector> &&, vector &&); +}; + +struct ContactData +{ + static ContactData load(const Ref &); + Ref store(const Storage &) const; + + vector> prev; + vector>> identity; + optional name; +}; + +} diff --git a/src/identity.cpp b/src/identity.cpp index f55f6dd..0d35122 100644 --- a/src/identity.cpp +++ b/src/identity.cpp @@ -6,6 +6,8 @@ #include #include +#include + using namespace erebos; using std::async; @@ -38,6 +40,11 @@ optional Identity::load(const vector & refs) for (const auto & ref : refs) data.push_back(Stored>::load(ref)); + return load(data); +} + +optional Identity::load(const vector>> & data) +{ if (auto ptr = Priv::validate(data)) return Identity(ptr); return nullopt; @@ -61,6 +68,11 @@ vector Identity::store(const Storage & st) const return res; } +const vector>> & Identity::data() const +{ + return p->data; +} + optional Identity::name() const { return p->name.get(); diff --git a/src/identity.h b/src/identity.h index 1dfc193..98db80a 100644 --- a/src/identity.h +++ b/src/identity.h @@ -10,9 +10,8 @@ using std::vector; namespace erebos { -class IdentityData +struct IdentityData { -public: static IdentityData load(const Ref &); Ref store(const Storage & st) const; -- cgit v1.2.3