DerivedValue.h

#pragma once
 
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/Library.h>
 
#include <optional>
#include <type_traits>
 
namespace CesiumUtility {

template <typename TInput, typename TDerivation>
class CESIUMUTILITY_API DerivedValue {
public:
  using TOutput = std::invoke_result_t<TDerivation, TInput>;

  DerivedValue(const TDerivation& derivation)
      : _derivation(derivation), _lastInput(), _lastOutput() {}

  DerivedValue(TDerivation&& derivation)
      : _derivation(std::move(derivation)), _lastInput(), _lastOutput() {}

  template <typename T> TOutput operator()(T&& input) {
    if (input != this->_lastInput) {
      this->_lastInput.emplace(std::forward<T>(input));
      this->_lastOutput.emplace(this->_derivation(*this->_lastInput));
    }
 
    CESIUM_ASSERT(this->_lastOutput);
    return *this->_lastOutput;
  }
 
private:
  TDerivation _derivation;
  std::optional<TInput> _lastInput;
  std::optional<TOutput> _lastOutput;
};

template <typename TInput, typename TDerivation>
auto makeDerivedValue(TDerivation&& derivation)
    -> DerivedValue<TInput, std::decay_t<TDerivation>> {
  static_assert(
      std::is_invocable_r_v<
          std::invoke_result_t<std::decay_t<TDerivation>, TInput>,
          std::decay_t<TDerivation>,
          TInput>,
      "Callable provided to makeDerivedValue is not invocable with the "
      "specified TInput.");
  return DerivedValue<TInput, std::decay_t<TDerivation>>(
      std::forward<TDerivation>(derivation));
}
 
} // namespace CesiumUtility