Property.h

Go to the documentation of this file.

#ifndef PROPERTY_H
#define PROPERTY_H
 
#include <chrono>
#include <memory>
#include <string>
#include <type_traits>
 
#include "lintel/core/models/PropertyBase.h"
#include "lintel/core/models/PropertyValueStorage.h"
#include "lintel/core/services/StringifyService.h"
#include "lintel/core/utils/TypeName.h"
 
namespace lintel {
class PropertyService;
 
template<class T> class Property : public PropertyBase
{
private:
  PropertyValueStorage<T> m_storage;
 
  static constexpr std::string_view getTypeName()
  {
    if constexpr (std::is_same_v<T, int8_t>)
      return "int8_t";
    else if constexpr (std::is_same_v<T, int16_t>)
      return "int16_t";
    else if constexpr (std::is_same_v<T, int32_t>)
      return "int32_t";
    else if constexpr (std::is_same_v<T, int64_t>)
      return "int64_t";
    else if constexpr (std::is_same_v<T, uint8_t>)
      return "uint8_t";
    else if constexpr (std::is_same_v<T, uint16_t>)
      return "uint16_t";
    else if constexpr (std::is_same_v<T, uint32_t>)
      return "uint32_t";
    else if constexpr (std::is_same_v<T, uint64_t>)
      return "uint64_t";
    else if constexpr (std::is_same_v<T, std::string>)
      return "std::string";
    else if constexpr (std::is_same_v<T, std::chrono::milliseconds>)
      return "std::chrono::milliseconds";
    else if constexpr (std::is_same_v<T, std::chrono::seconds>)
      return "std::chrono::seconds";
    else if constexpr (std::is_same_v<T, std::chrono::minutes>)
      return "std::chrono::minutes";
    else
      return type_name<T>();
  }
 
public:
  Property(const std::string &name,
    const std::string &instanceName,
    const std::string &className,
    const std::string &processName,
    T value,
    const std::string &description,
    bool runtimeChange)
    : PropertyBase(name, instanceName, className, processName, description, runtimeChange), m_storage(std::move(value))
  {}
 
  Property() : PropertyBase("", "", "", "", "", false), m_storage() {}
 
  [[nodiscard]] std::string getType() const override { return std::string(getTypeName()); }
 
  T getValue() { return m_storage.load(); }
 
  [[nodiscard]] static constexpr bool isLockFree() { return PropertyValueStorage<T>::isLockFree(); }
 
  std::string toString() override { return StringifyService<T>::serializeToString(m_storage.load()); }
 
  void setValue(const T &value) { m_storage.store(value); }
 
  void setValueString(const std::string &value) override
  {
    m_storage.store(StringifyService<T>::deserializeFromString(value));
  }
 
  friend class PropertyService;
};
 
}// namespace lintel
#endif// PROPERTY_H