nullable.h

Go to the documentation of this file.

#ifndef SENSESP_SRC_SENSESP_TYPES_NULLABLE_H_
#define SENSESP_SRC_SENSESP_TYPES_NULLABLE_H_
 
#include "ArduinoJson.h"
 
namespace sensesp {
 
template <typename T>
class Nullable {
  public:
    Nullable() : value_{} {}
    Nullable(T value) : value_{value} {}
    Nullable<T>& operator=(T& value) {
      value_ = value;
      return *this;
    }
    Nullable<T>& operator=(const Nullable<T>& other) {
      value_ = other.value_;
      return *this;
    }
    operator T() const {
      return value_;
    }
 
    bool is_valid() const {
      return value_ != invalid_value_;
    }
 
    T* ptr() {
      return &value_;
    }
 
    static T invalid() {
      return invalid_value_;
    }
 
    T value() const {
      return value_;
    }
 
  private:
    T value_;
    static T invalid_value_;
};
 
template <>
class Nullable<bool> {
  public:
    Nullable() : value_{false}, valid_{false} {}
    Nullable(bool value) : value_{value}, valid_{true} {}
    Nullable(const Nullable<bool>& other) = default;
    Nullable<bool>& operator=(bool value) {
      value_ = value;
      valid_ = true;
      return *this;
    }
    Nullable<bool>& operator=(const Nullable<bool>& other) = default;
    operator bool() const {
      return value_;
    }
 
    bool is_valid() const {
      return valid_;
    }
 
    // Mirrors the primary template's write-makes-valid behavior: handing out
    // mutable storage marks the value valid (it cannot clear validity).
    bool* ptr() {
      valid_ = true;
      return &value_;
    }
 
    static Nullable<bool> invalid() {
      return Nullable<bool>();
    }
 
    bool value() const {
      return value_;
    }
 
  private:
    bool value_;
    bool valid_;
};
 
typedef Nullable<int> NullableInt;
typedef Nullable<float> NullableFloat;
typedef Nullable<double> NullableDouble;
typedef Nullable<bool> NullableBool;
 
template <typename T>
void convertFromJson(JsonVariantConst src, Nullable<T> &dst) {
  if (src.isNull()) {
    dst = Nullable<T>::invalid();
  } else {
    dst = src.as<T>();
  }
}
 
template <typename T>
void convertToJson(const Nullable<T> &src, JsonVariant dst) {
  if (src.is_valid()) {
    dst.set(src.value());
  } else {
    dst.clear();
  }
}
 
}  // namespace sensesp
 
#endif  // SENSESP_SRC_SENSESP_TYPES_NULLABLE_H_