Allow write() to return new value ID

Author: tmadden

src/alia/flow/actions.hpp

@@ -604,11 +604,11 @@ struct write_action_signal : signal_wrapper<
     {
         return this->wrapped_.ready_to_write() && on_write_.is_ready();
     }
-    void
+    id_interface const&
     write(typename Wrapped::value_type value) const
     {
         perform_action(on_write_, value);
-        this->wrapped_.write(std::move(value));
+        return this->wrapped_.write(std::move(value));
     }
 
  private:

src/alia/flow/for_each.hpp

@@ -354,10 +354,11 @@ struct list_item_signal : signal<
     {
         return list_signal_.ready_to_write();
     }
-    void
+    id_interface const&
     write(Item value) const
     {
         *item_ = std::move(value);
+        return null_id;
     }
 
  private:

src/alia/signals/adaptors.hpp

@@ -95,8 +95,9 @@ struct writability_faker : signal_wrapper<
     }
     // Since this is only faking writability, write() should never be called.
     // LCOV_EXCL_START
-    void write(typename Wrapped::value_type) const override
+    id_interface const& write(typename Wrapped::value_type) const override
     {
+        return null_id;
     }
     // LCOV_EXCL_STOP
 };
@@ -140,7 +141,7 @@ struct casting_signal : casting_signal_wrapper<
         value_ = this->move_out();
         return value_;
     }
-    void
+    id_interface const&
     write(To value) const override
     {
         return this->wrapped_.write(
@@ -591,10 +592,10 @@ struct unwrapper_signal : casting_signal_wrapper<
         else
             return null_id;
     }
-    void
+    id_interface const&
     write(typename Wrapped::value_type::value_type value) const override
     {
-        this->wrapped_.write(std::move(value));
+        return this->wrapped_.write(std::move(value));
     }
     void
     clear() const override

src/alia/signals/application.hpp

@@ -145,10 +145,10 @@ struct lazy_duplex_apply_signal
     {
         return arg_.ready_to_write();
     }
-    void
+    id_interface const&
     write(Result value) const
     {
-        arg_.write(reverse_(std::move(value)));
+        return arg_.write(reverse_(std::move(value)));
     }
 
  private:
@@ -429,24 +429,29 @@ struct duplex_apply_signal : signal<
     {
         return input_.ready_to_write();
     }
-    void
+    id_interface const&
     write(Value value) const
     {
-        input_.write(reverse_(value));
-        // This is sort of hackish, but the idea here is that if we do nothing
-        // right now, on the next refresh, we're going to detect that the input
-        // signal has changed, and then apply the forward mapping to convert
-        // that value back to the one we're writing right now, which is
-        // obviously wasted effort.
-        // To attempt to avoid this, we capture the value ID of the input after
-        // writing to it in the hopes that it has already changed. (That is the
-        // case for some signal types, but not all.)
-        // To do this properly, we should probably allow signal write()
-        // functions to return a new value ID.
-        data_->input_id.capture(input_.value_id());
-        ++data_->result.version;
-        data_->result.value = std::move(value);
-        data_->result.status = apply_status::READY;
+        id_interface const& new_value_id = input_.write(reverse_(value));
+        // If we stop here, then on the next refresh, we're going to detect
+        // that the input signal has changed (to what we just set it to), and
+        // then apply the forward mapping to convert that value back to the one
+        // we just received, which is obviously wasted effort. To avoid this,
+        // we need to just record the new value as our ouput and record the
+        // input's new value ID to go along with it. (This is only possible
+        // though if the input signal actually supplies its new value ID.)
+        if (new_value_id != null_id)
+        {
+            data_->input_id.capture(new_value_id);
+            ++data_->result.version;
+            data_->result.value = std::move(value);
+            data_->result.status = apply_status::READY;
+            return this->value_id();
+        }
+        else
+        {
+            return null_id;
+        }
     }
 
  private:

src/alia/signals/basic.hpp

@@ -58,8 +58,9 @@ struct empty_signal
     }
     // Since this is never ready to write, none of this should ever be called.
     // LCOV_EXCL_START
-    void write(Value) const override
+    id_interface const& write(Value) const override
     {
+        return null_id;
     }
     void
     clear() const override
@@ -236,10 +237,11 @@ struct direct_signal
     {
         return true;
     }
-    void
+    id_interface const&
     write(Value value) const override
     {
         *v_ = std::move(value);
+        return this->value_id();
     }
 
  private:

src/alia/signals/core.hpp

@@ -207,7 +207,10 @@ struct signal_interface : untyped_signal_base
     destructive_ref() const = 0;
 
     // Write the signal's value.
-    virtual void
+    // The signal can *optionally* return the new value ID of the signal (after
+    // taking on the value that was written in by this call). If this is
+    // impractical, it can just return null_id instead.
+    virtual id_interface const&
     write(Value value) const = 0;
 };
 
@@ -243,8 +246,9 @@ struct signal : signal_base<Derived, Value, Capabilities>
     {                                                                         \
         return false;                                                         \
     }                                                                         \
-    void write(Value) const override                                          \
+    id_interface const& write(Value) const override                           \
     {                                                                         \
+        return null_id;                                                       \
     }
 
 #define ALIA_DEFINE_UNUSED_SIGNAL_MOVE_INTERFACE(Value)                       \
@@ -387,10 +391,10 @@ struct signal_ref
     {
         return ref_->ready_to_write();
     }
-    void
+    id_interface const&
     write(Value value) const override
     {
-        ref_->write(std::move(value));
+        return ref_->write(std::move(value));
     }
     bool
     invalidate(std::exception_ptr error) const override
@@ -518,14 +522,14 @@ signal_ready_to_write(Signal const& signal)
 // error if the signal's type doesn't support writing.
 // Note that if the signal isn't ready to write, this is a no op.
 template<class Signal, class Value>
-std::enable_if_t<signal_is_writable<Signal>::value>
+std::enable_if_t<signal_is_writable<Signal>::value, id_interface const&>
 write_signal(Signal const& signal, Value value)
 {
     if (signal.ready_to_write())
     {
         try
         {
-            signal.write(std::move(value));
+            return signal.write(std::move(value));
         }
         catch (validation_error&)
         {
@@ -537,6 +541,7 @@ write_signal(Signal const& signal, Value value)
                 std::rethrow_exception(e);
         }
     }
+    return null_id;
 }
 
 // signal_is_duplex<Signal>::value yields a compile-time boolean indicating

src/alia/signals/lambdas.hpp

@@ -274,10 +274,11 @@ struct lambda_duplex_signal
     {
         return ready_to_write_();
     }
-    void
+    id_interface const&
     write(Value value) const override
     {
         write_(std::move(value));
+        return null_id;
     }
 
  private:
@@ -369,10 +370,11 @@ struct lambda_duplex_signal_with_id : signal<
     {
         return ready_to_write_();
     }
-    void
+    id_interface const&
     write(Value value) const override
     {
         write_(std::move(value));
+        return null_id;
     }
 
  private:

src/alia/signals/numeric.hpp

@@ -48,10 +48,11 @@ struct scaled_signal
     {
         return this->wrapped_.ready_to_write() && scale_factor_.has_value();
     }
-    void
+    id_interface const&
     write(typename N::value_type value) const override
     {
         this->wrapped_.write(value / forward_signal(scale_factor_));
+        return null_id;
     }
 
  private:
@@ -108,10 +109,11 @@ struct offset_signal
     {
         return this->wrapped_.ready_to_write() && offset_.has_value();
     }
-    void
+    id_interface const&
     write(typename N::value_type value) const override
     {
         this->wrapped_.write(value - forward_signal(offset_));
+        return null_id;
     }
 
  private:
@@ -147,12 +149,13 @@ struct rounding_signal_wrapper
     {
         return this->wrapped_.ready_to_write() && step_.has_value();
     }
-    void
+    id_interface const&
     write(typename N::value_type value) const override
     {
         typename N::value_type step = step_.read();
         this->wrapped_.write(
             std::floor(value / step + typename N::value_type(0.5)) * step);
+        return null_id;
     }
 
  private:

src/alia/signals/operators.hpp

@@ -383,13 +383,14 @@ struct signal_mux : signal<
                && (condition_.read() ? t_.ready_to_write()
                                      : f_.ready_to_write());
     }
-    void
+    id_interface const&
     write(typename T::value_type value) const override
     {
         if (condition_.read())
             t_.write(value);
         else
             f_.write(value);
+        return null_id;
     }
     void
     clear() const override
@@ -493,12 +494,13 @@ struct field_signal : preferred_id_signal<
     {
         return structure_.has_value() && structure_.ready_to_write();
     }
-    void
+    id_interface const&
     write(Field x) const override
     {
         structure_type s = forward_signal(alia::move(structure_));
         s.*field_ = std::move(x);
         structure_.write(std::move(s));
+        return null_id;
     }
 
  private:
@@ -773,10 +775,11 @@ struct subscript_signal
         return container_.has_value() && index_.has_value()
                && container_.ready_to_write();
     }
-    void
+    id_interface const&
     write(typename subscript_signal::value_type x) const override
     {
         write_subscript(container_, index_, std::move(x));
+        return null_id;
     }
 
  private:

src/alia/signals/state.hpp

@@ -186,10 +186,11 @@ struct state_signal
     {
         return true;
     }
-    void
+    id_interface const&
     write(Value value) const override
     {
         data_->set(std::move(value));
+        return this->value_id();
     }
     void
     clear() const override