Revert "Simplify experimental validation"

This reverts commit 73046b5.

Author: tmadden

src/alia/signals/core.hpp

@@ -162,6 +162,27 @@ struct untyped_signal_base
     // Clear the signal.
     virtual void
     clear() const = 0;
+
+    // WARNING: EXPERIMENTAL VALIDATION STUFF FOLLOWS...
+
+    // Handle a validation error.
+    //
+    // This is called when there's an attempt to write to the signal and a
+    // validation_error is thrown. (The argument is the error.)
+    //
+    // The return value should be true iff the validation error was handled.
+    //
+    virtual bool invalidate(std::exception_ptr) const
+    {
+        return false;
+    }
+
+    // Is this signal currently invalidated?
+    virtual bool
+    is_invalidated() const
+    {
+        return false;
+    }
 };
 
 template<class Value>
@@ -371,6 +392,16 @@ struct signal_ref
     {
         ref_->write(std::move(value));
     }
+    bool
+    invalidate(std::exception_ptr error) const override
+    {
+        return ref_->invalidate(error);
+    }
+    bool
+    is_invalidated() const override
+    {
+        return ref_->is_invalidated();
+    }
 
  private:
     signal_interface<Value> const* ref_;
@@ -441,37 +472,6 @@ read_signal(Signal const& signal)
     return signal.read();
 }
 
-// signal_is_clearable<Signal>::value yields a compile-time boolean indicating
-// whether or not the given signal type supports clearing.
-template<class Signal>
-struct signal_is_clearable : signal_capability_level_is_compatible<
-                                 signal_clearable,
-                                 Signal::capabilities::writing>
-{
-};
-
-// is_clearable_signal_type<T>::value yields a compile-time boolean indicating
-// whether or not T is an alia signal that supports clearing.
-template<class T>
-struct is_clearable_signal_type : std::conditional_t<
-                                      is_signal_type<T>::value,
-                                      signal_is_clearable<T>,
-                                      std::false_type>
-{
-};
-
-// Clear a signal's value.
-// Unlike calling signal.clear() directly, this will generate a compile-time
-// error if the signal's type doesn't support clearing.
-// Note that if the signal isn't ready to write, this is a no op.
-template<class Signal>
-std::enable_if_t<signal_is_clearable<Signal>::value>
-clear_signal(Signal const& signal)
-{
-    if (signal.ready_to_write())
-        signal.clear();
-}
-
 // When a value is written to a signal, the signal is allowed to throw a
 // validation_error if the value isn't acceptable.
 struct validation_error : exception
@@ -529,9 +529,12 @@ write_signal(Signal const& signal, Value value)
         }
         catch (validation_error&)
         {
-            // EXPERIMENTAL VALIDATION LOGIC
-            if constexpr (signal_is_clearable<Signal>::value)
-                clear_signal(signal);
+            // EXPERIMENTAL VALIDATION LOGIC: Try to let the signal handle the
+            // validation error (at some level). If it can't, rethrow the
+            // exception.
+            auto e = std::current_exception();
+            if (!signal.invalidate(e))
+                std::rethrow_exception(e);
         }
     }
 }
@@ -627,6 +630,37 @@ forward_signal(Signal const& signal)
     return signal.read();
 }
 
+// signal_is_clearable<Signal>::value yields a compile-time boolean indicating
+// whether or not the given signal type supports clearing.
+template<class Signal>
+struct signal_is_clearable : signal_capability_level_is_compatible<
+                                 signal_clearable,
+                                 Signal::capabilities::writing>
+{
+};
+
+// is_clearable_signal_type<T>::value yields a compile-time boolean indicating
+// whether or not T is an alia signal that supports clearing.
+template<class T>
+struct is_clearable_signal_type : std::conditional_t<
+                                      is_signal_type<T>::value,
+                                      signal_is_clearable<T>,
+                                      std::false_type>
+{
+};
+
+// Clear a signal's value.
+// Unlike calling signal.clear() directly, this will generate a compile-time
+// error if the signal's type doesn't support clearing.
+// Note that if the signal isn't ready to write, this is a no op.
+template<class Signal>
+std::enable_if_t<signal_is_clearable<Signal>::value>
+clear_signal(Signal const& signal)
+{
+    if (signal.ready_to_write())
+        signal.clear();
+}
+
 } // namespace alia
 
 #endif

src/alia/signals/operators.hpp

@@ -399,6 +399,22 @@ struct signal_mux : signal<
         else
             f_.clear();
     }
+    bool
+    invalidate(std::exception_ptr error) const override
+    {
+        if (condition_.read())
+            return t_.invalidate(error);
+        else
+            return f_.invalidate(error);
+    }
+    bool
+    is_invalidated() const override
+    {
+        if (condition_.read())
+            return t_.is_invalidated();
+        else
+            return f_.is_invalidated();
+    }
 
  private:
     Condition condition_;

src/alia/signals/utilities.hpp

@@ -191,6 +191,16 @@ struct signal_wrapper : signal<Derived, Value, Capabilities>
     {
         wrapped_.clear();
     }
+    bool
+    invalidate(std::exception_ptr error) const override
+    {
+        return wrapped_.invalidate(error);
+    }
+    bool
+    is_invalidated() const override
+    {
+        return wrapped_.is_invalidated();
+    }
 
  protected:
     Wrapped wrapped_;
@@ -231,6 +241,16 @@ struct casting_signal_wrapper : signal<Derived, Value, Capabilities>
     {
         wrapped_.clear();
     }
+    bool
+    invalidate(std::exception_ptr error) const override
+    {
+        return wrapped_.invalidate(error);
+    }
+    bool
+    is_invalidated() const override
+    {
+        return wrapped_.is_invalidated();
+    }
 
  protected:
     Wrapped wrapped_;

src/alia/signals/validation.hpp

@@ -0,0 +1,72 @@
+#ifndef ALIA_SIGNALS_VALIDATION_HPP
+#define ALIA_SIGNALS_VALIDATION_HPP
+
+#include <alia/signals/core.hpp>
+
+namespace alia {
+
+struct signal_validation_data
+{
+    captured_id value_id;
+    std::exception_ptr error;
+};
+
+template<class Wrapped>
+struct validated_signal : signal_wrapper<validated_signal<Wrapped>, Wrapped>
+{
+    validated_signal()
+    {
+    }
+    validated_signal(signal_validation_data* data, Wrapped wrapped)
+        : validated_signal::signal_wrapper(wrapped), data_(data)
+    {
+    }
+    bool
+    has_value() const override
+    {
+        return !data_->error && this->wrapped_.has_value();
+    }
+    bool
+    invalidate(std::exception_ptr error) const override
+    {
+        data_->error = error;
+        this->wrapped_.invalidate(error);
+        return true;
+    }
+    bool
+    is_invalidated() const override
+    {
+        return data_->error || this->wrapped_.is_invalidated();
+    }
+
+ private:
+    signal_validation_data* data_;
+};
+
+template<class Signal>
+auto
+enforce_validity(
+    dataless_context ctx, Signal signal, signal_validation_data& data)
+{
+    refresh_handler(ctx, [&](auto) {
+        if (!signal.is_invalidated()
+            && !data.value_id.matches(signal.value_id()))
+        {
+            data.error = nullptr;
+            data.value_id.capture(signal.value_id());
+        }
+    });
+    return validated_signal<Signal>(&data, signal);
+}
+
+template<class Signal>
+auto
+enforce_validity(context ctx, Signal signal)
+{
+    auto& data = get_cached_data<signal_validation_data>(ctx);
+    return enforce_validity(ctx, signal, data);
+}
+
+} // namespace alia
+
+#endif