PropertyService.h

Go to the documentation of this file.

#ifndef LOGGING_PROPERTYSERVICE_H
#define LOGGING_PROPERTYSERVICE_H
 
#include <functional>
#include <map>
#include <optional>
#include <ostream>
#include <vector>
 
#include "lintel/core/models/ProcessName.h"
#include "lintel/core/models/Property.h"
#include "lintel/core/models/PropertyRepositoryType.h"
#include "lintel/core/services/AbstractService.h"
#include "lintel/core/services/LoggerService.h"
#include "lintel/core/services/PersistableBean.h"
#include "lintel/features/base/events/EventBus.h"
#include "lintel/features/property/events/PropertyChange.h"
#include "lintel/features/property/exceptions/PropertyNoRuntimeChangeSupported.h"
#include "lintel/features/property/exceptions/PropertyNotFoundException.h"
#include "lintel/features/property/repositories/PropertyRepository.h"
 
#define DEFINE_PROPERTY(name, type, defaultValue, description, runtime) \
  std::shared_ptr<lintel::Property<type>> name =                        \
    registerProperty<type>(std::string(#name), defaultValue, description, runtime, __FILE__, __LINE__)
#define LOAD_PROPERTIES() \
  if (propertyService != nullptr) { propertyService->getOrCreate(m_properties); }
 
namespace lintel {
class PropertyService : public PersistableBean
{
private:
  std::vector<std::shared_ptr<PropertyRepository>> m_propertyRepositories;
  std::vector<std::shared_ptr<PropertyRepository>> m_mutablePropertyRepositories;
  std::vector<std::shared_ptr<PropertyRepository>> m_shadowPropertyRepositories;
  std::vector<std::shared_ptr<AbstractServiceInterface>> m_abstractServices;
  // variables
  std::map<std::string, std::shared_ptr<PropertyBase>>
    m_properties;// identifier (name_instanceName_processName), Property
  std::map<PropertyRepositoryType, std::shared_ptr<PropertyRepository>> m_typeRepositoryMap;
  std::shared_ptr<IEventBus> m_changeBus;
  std::string m_changeSubscriber;
 
  // functions
  static std::string createIdentifier(const std::string &name,
    const std::string &instanceName,
    const std::string &className,
    const std::string &processName);
 
  static std::map<std::string, std::shared_ptr<PropertyBase>> init(
    const std::vector<std::shared_ptr<PropertyRepository>> &repoProperties,
    std::map<PropertyRepositoryType, std::vector<std::shared_ptr<PropertyBase>>> &propertiesMap);
 
  static std::vector<std::shared_ptr<PropertyRepository>> filterEnabledRepositories(
    const std::vector<std::shared_ptr<PropertyRepository>> &propertyRepositories);
 
  static std::vector<std::shared_ptr<PropertyRepository>> filterMutableRepositories(
    const std::vector<std::shared_ptr<PropertyRepository>> &propertyRepository);
 
  static std::vector<std::shared_ptr<PropertyRepository>> filterShadowRepositories(
    const std::vector<std::shared_ptr<PropertyRepository>> &propertyRepository);
 
  void getOrCreate(const std::vector<std::shared_ptr<PropertyBase>> &propertiesVec,
    std::map<PropertyRepositoryType, std::vector<std::shared_ptr<PropertyBase>>> &map);
 
  void publishChange(const std::shared_ptr<PropertyBase> &property);
 
  bool applyChange(const PropertyChange &change);
 
  std::optional<std::string> resolveChangeValue(const PropertyChange &change);
 
public:
  static constexpr std::string_view PROPERTY_CHANGES_TOPIC = "property_changes";
  static constexpr std::string_view PROPERTY_CHANGES_TYPE = "property_change";
  PropertyService(const std::vector<std::shared_ptr<PropertyRepository>> &propertyRepositories,
    std::vector<std::shared_ptr<AbstractServiceInterface>> abstractServices);
 
  virtual ~PropertyService() = default;
 
  void onAwake() override;
 
  void getOrCreate(const std::vector<std::shared_ptr<PropertyBase>> &propertiesVec)
  {
    std::map<PropertyRepositoryType, std::vector<std::shared_ptr<PropertyBase>>> map;
    return getOrCreate(propertiesVec, map);
  }
 
  template<class T>
  std::shared_ptr<Property<T>> getOrCreate(const std::string &name,
    const std::string &instanceName,
    const std::string &className,
    const std::string &processName,
    const std::string &description,
    bool runtimeChange,
    const T &defaultValue = T());
 
  std::shared_ptr<PropertyBase> &get(const std::string &name,
    const std::string &instanceName,
    const std::string &className,
    const std::string &processName);
 
  std::vector<std::shared_ptr<PropertyBase>> allOf();
 
  std::vector<std::shared_ptr<PropertyBase>> allOf(const std::string &processName);
 
  std::vector<std::shared_ptr<PropertyBase>> allOf(const std::string &processName, const std::string &className);
 
  std::vector<std::shared_ptr<PropertyBase>>
    allOf(const std::string &processName, const std::string &className, const std::string &instanceName);
 
  template<class T> void changeValueOf(const std::shared_ptr<PropertyBase> &property, const T &value);
 
  void changeStringValueOf(const std::shared_ptr<PropertyBase> &property, const std::string &value);
 
  void setPropertyChangeBus(const std::shared_ptr<IEventBus> &bus, const std::string &subscriberName);
 
  std::size_t applyChangeNotifications();
 
  std::map<PropertyRepositoryType, std::shared_ptr<PropertyRepository>> buildMap(
    const std::vector<std::shared_ptr<PropertyRepository>> &vector);
};
 
// template functions implementations
template<class T>
std::shared_ptr<Property<T>> PropertyService::getOrCreate(const std::string &name,
  const std::string &instanceName,
  const std::string &className,
  const std::string &processName,
  const std::string &description,
  bool runtimeChange,
  const T &defaultValue /* T() default Value */)
{
  auto id = createIdentifier(name, instanceName, className, processName);
  try {
    auto propertyBase = get(name, instanceName, className, processName);
    return std::static_pointer_cast<Property<T>>(propertyBase);
  } catch (PropertyNotFoundException &exception) {
    auto property = std::make_shared<Property<T>>(
      name, instanceName, className, processName, defaultValue, description, runtimeChange);
    m_properties.insert({ property->getIdentifier(), property });
    if (m_mutablePropertyRepositories.empty()) {
      LOG_ERROR("no mutable property repositories available");
      return property;
    }
    for (const auto &item : m_mutablePropertyRepositories) { item->save(property); }
    return property;
  }
}
 
template<class T> void PropertyService::changeValueOf(const std::shared_ptr<PropertyBase> &property, const T &value)
{
  std::shared_ptr<PropertyBase> propertyBase =
    get(property->getName(), property->getInstanceName(), property->getClassName(), property->getProcessName());
  if (!propertyBase->isRuntimeChange()) { throw PropertyNoRuntimeChangeSupported(propertyBase); }
  std::static_pointer_cast<Property<T>>(propertyBase)->setValue(value);
  if (m_mutablePropertyRepositories.empty()) {
    LOG_ERROR("no mutable property repositories available");
  } else {
    std::static_pointer_cast<Property<T>>(propertyBase)
      ->setDataStorage(m_mutablePropertyRepositories[0]->getDataStorage());
    for (const auto &item : m_mutablePropertyRepositories) { item->save(propertyBase); }
  }
  // publish after the repositories are updated, so that receivers resolving
  // a truncated value from shared memory read the new value
  publishChange(propertyBase);
}
 
}// namespace lintel
#endif// LOGGING_PROPERTYSERVICE_H