From ff4aecf759ce565b77575ad8eabcf60c94ee6a29 Mon Sep 17 00:00:00 2001 From: olpc user Date: Thu, 26 Dec 2019 08:25:31 -0800 Subject: added crucialness to inner level0 --- starts/meaning-vm/level-0/baseref.hpp | 22 +++++++++++++-- starts/meaning-vm/level-0/concept.cpp | 45 +++++++++++++++++++++++++++++-- starts/meaning-vm/level-0/concept.hpp | 26 ++++++++++++++++++ starts/meaning-vm/level-0/errors.hpp | 24 +++++++++++++++++ starts/meaning-vm/level-0/memorystore.cpp | 2 ++ 5 files changed, 115 insertions(+), 4 deletions(-) (limited to 'starts/meaning-vm/level-0') diff --git a/starts/meaning-vm/level-0/baseref.hpp b/starts/meaning-vm/level-0/baseref.hpp index 9244492..b6e98e8 100644 --- a/starts/meaning-vm/level-0/baseref.hpp +++ b/starts/meaning-vm/level-0/baseref.hpp @@ -13,8 +13,8 @@ namespace level0 { template class baseref { - struct array; struct links_t; public: + struct array; struct links_t; baseref(concept *p) : p(p) { @@ -63,6 +63,9 @@ public: T& val() { return p->val(); } template void val(T const & v) { p->val(v); } + bool hasval() { return p->hasval(); } + template + bool hasvalof() { return p->hasvalof(); } operator concept*() const { return p; } concept*& ptr() { return p; } @@ -91,9 +94,15 @@ public: operator level9::ref &() { return *reinterpret_cast(this); } bool operator==(ref const & other) const { return self.p == other.p; } - bool operator!=(ref const & other) const { return self.p == other.p; } + bool operator!=(ref const & other) const { return self.p != other.p; } bool operator<(ref const & other) const { return self.p < other.p; } + bool crucial() { return self.p->crucial(); } + bool crucial(ref type, ref target) { return self.p->crucial(type.p, target.p); } + + void setcrucial() { self.p->setcrucial(); } + void setcrucial(ref type, ref target) { self.p->setcrucial(type.p, target.p); } + protected: concept * p; @@ -107,16 +116,21 @@ private: mutit & operator++() { ++ self.it; return self; } mutit operator++(int i) { return self.it.operator++(i); } + mutit & operator--() { -- self.it; return self; } + mutit operator--(int i) { return self.it.operator--(i); } bool operator==(mutit const & other) const { return self.it == other.it; } bool operator!=(mutit const & other) const { return self.it != other.it; } val & operator*() { return *(val*)&self.it.operator*(); } val * operator->() { return (val*)self.it.operator->(); } + It & underlying() { return it; } + private: It it; }; +public: struct array { using iterator = mutated_it; @@ -134,6 +148,10 @@ private: decltype(concept::links) & links; }; + + void unlink(typename links_t::iterator & it) { p->unlink(it.underlying()); } + bool crucial(typename links_t::iterator it) { return self.p->crucial(it.underlying()); } + void setcrucial(typename links_t::iterator it) { self.p->setcrucial(it.underlying()); } }; template diff --git a/starts/meaning-vm/level-0/concept.cpp b/starts/meaning-vm/level-0/concept.cpp index 0661edd..373b3b7 100644 --- a/starts/meaning-vm/level-0/concept.cpp +++ b/starts/meaning-vm/level-0/concept.cpp @@ -16,16 +16,49 @@ void concept::link(concept* type, concept* target) links.insert({type, target}); } +bool concept::crucial(concept* type, concept* target) +{ + auto ls = links.equal_range(type); + bool wascrucial = false; + bool wasnotcrucial = false; + for (auto l = ls.first; l != ls.second; ++ l) { + if (l->second == target) { + if (crucialparts.count(l)) { wascrucial = true; } + else { wasnotcrucial = true; } + } + } + if (wascrucial && wasnotcrucial) { throw link_type_not_unique(selfref, type); } + if ((!wascrucial) && (!wasnotcrucial)) { throw no_such_link_type(selfref, type); } + return wascrucial; +} + +void concept::setcrucial(concept* type, concept* target) +{ + auto ls = links.equal_range(type); + for (auto l = ls.first; l != ls.second; ++ l) { + if (l->second == target) { + if (!crucialparts.count(l)) { + setcrucial(l); + return; + } + } + } + throw no_such_link_type(selfref, type); +} + void concept::unlink(concept* type, concept* target) { auto ls = links.equal_range(type); + bool wascrucial = false; for (auto l = ls.first; l != ls.second; ++ l) { if (l->second == target) { + if (crucialparts.count(l)) { wascrucial = true; continue; } links.erase(l); return; } } - throw no_such_link_type_target(selfref, type, target); + if (wascrucial) { throw crucial_link_type_target(selfref, type, target); } + throw no_such_link_type_target(selfref, type, target); } void concept::unlink(concept* type) @@ -39,7 +72,15 @@ void concept::unlink(concept* type) if (mid != ls.second) { throw link_type_not_unique(selfref, type); } - links.erase(ls.first); + unlink(ls.first); +} + +void concept::unlink(decltype(links)::iterator & it) +{ + if (crucialparts.count(it)) { + throw crucial_link_type_target(selfref, it->first, it->second); + } + links.erase(it++); } bool concept::linked(concept* type) const diff --git a/starts/meaning-vm/level-0/concept.hpp b/starts/meaning-vm/level-0/concept.hpp index d42d36b..e885ccf 100644 --- a/starts/meaning-vm/level-0/concept.hpp +++ b/starts/meaning-vm/level-0/concept.hpp @@ -4,6 +4,7 @@ #include #include +#include #include namespace intellect { @@ -23,6 +24,14 @@ struct concept void link(concept* type, concept* target); void unlink(concept* type, concept* target); void unlink(concept* type); + void unlink(decltype(links)::iterator & it); + + bool crucial() { return iscrucial || crucialparts.size(); } + bool crucial(concept* type, concept* target); + bool crucial(decltype(links)::iterator it) { return crucialparts.count(it); } + void setcrucial() { iscrucial = true; } + void setcrucial(concept* type, concept* target); + void setcrucial(decltype(links)::iterator it) { crucialparts.insert(it); } bool linked(concept* type) const; bool linked(concept* type, concept* target) const; @@ -41,6 +50,23 @@ struct concept template void val(T const & v) { data = v; } + + bool hasval() { return data.has_value(); } + + template + bool hasvalof() { return hasval() && data.type() == typeid(T); } + +private: + // for permanence + bool iscrucial; + struct linksit_hash + { + size_t operator()(decltype(links)::iterator const &it) const + { + return std::hash()(&*it); + } + }; + std::unordered_set crucialparts; }; } diff --git a/starts/meaning-vm/level-0/errors.hpp b/starts/meaning-vm/level-0/errors.hpp index d46eef7..e599261 100644 --- a/starts/meaning-vm/level-0/errors.hpp +++ b/starts/meaning-vm/level-0/errors.hpp @@ -32,6 +32,30 @@ struct no_such_link_type_target : public std::out_of_range concept* const target; }; +struct crucial_link_type_target : public std::out_of_range +{ + crucial_link_type_target(concept* source, concept* type, concept* target) + : std::out_of_range("concept part is crucial"), + source(source), + type(type), + target(type) + { } + + concept* const source; + concept* const type; + concept* const target; +}; + +struct crucial_concept : public std::invalid_argument +{ + crucial_concept(concept* topic) + : std::invalid_argument("concept is crucial"), + topic(topic) + { } + + concept* const topic; +}; + struct link_type_not_unique : public std::invalid_argument { link_type_not_unique(concept* source, concept* type) diff --git a/starts/meaning-vm/level-0/memorystore.cpp b/starts/meaning-vm/level-0/memorystore.cpp index 04aadd5..1d9e9f6 100644 --- a/starts/meaning-vm/level-0/memorystore.cpp +++ b/starts/meaning-vm/level-0/memorystore.cpp @@ -89,6 +89,7 @@ static concept* referenced(ref r, concept* source = 0) { void basic_dealloc(ref r) { + if (r.crucial()) { throw crucial_concept(r); } auto it = index().find(r); if (it == index().end()) { throw no_such_concept(r); } @@ -106,6 +107,7 @@ void dealloc_from(ref source) auto ours = source.getAll(concepts::allocates()); for (auto allocation : ours) { + if (allocation.crucial()) { throw crucial_concept(allocation); } source.unlink(concepts::allocates(), allocation); allocation.unlink(concepts::allocator(), source); if (allocation.linked(concepts::allocator())) { continue; } -- cgit v1.2.3