Changeset 5c14030 for src/Common

Timestamp:

Jul 11, 2018, 4:26:22 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env

Children:

d318a18

Parents:

184557e

git-author:

Aaron Moss <a3moss@…> (07/11/18 16:10:36)

git-committer:

Aaron Moss <a3moss@…> (07/11/18 16:26:22)

Message:

Persistent-array environment compiles

Location:

src/Common

Files:

• GC.h (modified) (1 diff)
• PersistentDisjointSet.h (modified) (7 diffs)
• PersistentMap.h (modified) (5 diffs)
• option.h (modified) (2 diffs)

src/Common/GC.h

@@ -69 +69 @@
         bool mark;                     ///< The current collection's mark bit
         unsigned g;                    ///< The current number generation in use
+
+        /// Trace a traceable object (enabled by SFINAE)
+        template<typename T>
+        static inline auto do_trace(const GC& gc, T& obj, int) -> decltype(gc << obj, void()) {
+                gc << obj;
+        }
+
+        /// Do not trace an untraceable object
+        template<typename T>
+        static inline auto do_trace(const GC&, T&, long) -> void {}
+
+        /// Base case for maybe_trace
+        void maybe_trace() const {}
+
+public:
+        /// Trace any objects that are traceable
+        template<typename T, typename... Args>
+        void maybe_trace(T& obj, Args&... args) const {
+                // uses SFINAE trick to select proper overload; prefers actually tracing version 
+                // (because of int->long conversion), but will fall back to non-tracing
+                do_trace(*this, obj, 0);
+                maybe_trace(args...);
+        }
 };
 

src/Common/PersistentDisjointSet.h

@@ -129 +129 @@
         }
 
+        /// reset as base
+        void reset_as_base() {
+                assertf( mode == BASE, "can only reset_as_base() on BASE" );
+                as<Base>().~Base();
+        }
+
         /// Non-initializing constructor; should call init() before use
         PersistentDisjointSet( Mode m ) : data(), mode(m) {}
@@ -165 +171 @@
                         case BASE: {
                                 for (const auto& entry : as<Base>()) {
-                                        gc << entry.first;
+                                        gc.maybe_trace( entry.first );
                                 }
                                 return;
@@ -171 +177 @@
                         case ADD: case REM: {
                                 const Add& self = as<Add>();
-                                gc << self.base << self.root;
+                                gc << self.base; 
+                                gc.maybe_trace( self.root );
                                 return;
                         }
                         case ADDTO: case REMFROM: {
                                 const AddTo& self = as<AddTo>();
-                                gc << self.base << self.root << self.child;
+                                gc << self.base;
+                                gc.maybe_trace( self.root, self.child );
                                 return;
                         }
@@ -210 +218 @@
                 // take map out of base
                 Base base_map = base->take_as<Base>();
-                base->reset();
+                base->reset_as_base();
 
                 // switch base to inverse of self and mutate base map
@@ -331 +339 @@
                 // transfer map to new node
                 Self* ret = new Self{ BASE, take_as<Base>() };
-                reset();
+                reset_as_base();
 
                 // set self to REM node
@@ -352 +360 @@
                 // transfer map to new node
                 Self* ret = new Self{ BASE, take_as<Base>() };
-                reset();
+                reset_as_base();
 
                 // find set nodes
@@ -449 +457 @@
         /// `f` should take members by const reference or copy
         template<typename F>
-        void apply_to_class(Elm i, F&& f) const {
+        void for_class(Elm i, F&& f) const {
                 const Base& self = rerooted();
 

src/Common/PersistentMap.h

@@ -139 +139 @@
                         case BASE: {
                                 for (const auto& entry : as<Base>()) {
-                                        gc << entry.first << entry.second;
+                                        gc.maybe_trace( entry.first, entry.second );
                                 }
                                 return;
@@ -145 +145 @@
                         case REM: {
                                 const Rem& self = as<Rem>();
-                                gc << self.base << self.key;
+                                gc << self.base;
+                                gc.maybe_trace( self.key );
                                 return;
                         }
                         case INS: case UPD: {
                                 const Ins& self = as<Ins>();
-                                gc << self.base << self.key << self.val;
+                                gc << self.base;
+                                gc.maybe_trace( self.key, self.val );
                                 return;
                         }
@@ -424 +426 @@
         }
 
+        /// Applies the function `f` to all elements of the map.
+        /// `f` should take two parameters, `const Key&` and `const Val&`.
+        template<typename F>
+        void for_each(F&& f) const {
+                for ( const auto& entry : rerooted() ) { f( entry.first, entry.second ); }
+        }
+
         /// Applies the function `f` to all elements of the map, returning a pointer to the updated map.
         /// `f` should take two parameters, `const Key&` and `Val&`, returning option<Val> filled with 
@@ -429 +438 @@
         /// NOTE: when porting to C++17, this should work fine with std::optional
         template<typename F>
-        Self* apply_to_all(F&& f) {
+        Self* mutate_each(F&& f) {
                 // reset to root and exit early if no change
                 if ( rerooted().empty() ) return this;
@@ -454 +463 @@
                 return next_edit;
         }
-
-        /// Applies the function `f` to all elements of the map.
-        /// `f` should take two parameters, `const Key&` and `const Val&`.
-        template<typename F>
-        void apply_to_all(F&& f) const {
-                for ( const auto& entry : rerooted() ) { f( entry.first, entry.second ); }
-        }
 };
 

src/Common/option.h

@@ -16 +16 @@
 #pragma once
 
+#include <cassert>
 #include <functional>
 #include <type_traits>
 #include <utility>
-
-#include "debug.h"
 
 using std::move;
@@ -121 +120 @@
 
     /// Get contained value (checked)
-    T& value() & { assume(filled, "checked get failed"); return get(); }
-    const T& value() const& { assume(filled, "checked get failed"); return get(); }
-    T&& value() && { assume(filled, "checked get failed"); return move(get()); }
-    const T&& value() const&& { assume(filled, "checked get failed"); return move(get()); }
+    T& value() & { assertf(filled, "checked get failed"); return get(); }
+    const T& value() const& { assertf(filled, "checked get failed"); return get(); }
+    T&& value() && { assertf(filled, "checked get failed"); return move(get()); }
+    const T&& value() const&& { assertf(filled, "checked get failed"); return move(get()); }
 
     /// Get contained or default value