PropertyRepository.h

Go to the documentation of this file.

#ifndef LOGGING_PROPERTYREPOSITORY_H
#define LOGGING_PROPERTYREPOSITORY_H
 
#include <memory>
#include <vector>
 
#include "lintel/core/configuration/Configuration.h"
#include "lintel/core/models/DataStorage.h"
#include "lintel/core/models/PropertyRepositoryType.h"
#include "lintel/features/property/configuration/PropertyRepositoryComponent.h"
#include "lintel/features/property/configuration/PropertyRepositoryEntry.h"
 
namespace lintel {
class PropertyBase;
 
class PropertyRepository
{
private:
  PropertyRepositoryType m_type;
  std::shared_ptr<PropertyRepositoryEntry> m_propertyRepositoryEntry;
 
  std::shared_ptr<PropertyRepositoryEntry> init(const std::vector<std::shared_ptr<Entry>> &entries)
  {
    std::shared_ptr<PropertyRepositoryEntry> propertyRepositoryEntry;
    for (const auto &entry : entries) {
      std::shared_ptr<PropertyRepositoryEntry> tmp = std::static_pointer_cast<PropertyRepositoryEntry>(entry);
      if (tmp->getType() != m_type) { continue; }
      propertyRepositoryEntry = tmp;
    }
    return propertyRepositoryEntry;
  }
 
public:
  PropertyRepository(PropertyRepositoryType type, const std::shared_ptr<Configuration> &configuration)
    : m_type(std::move(type)),
      m_propertyRepositoryEntry(init(configuration->configurationOf<PropertyRepositoryComponent>()))
  {}
 
  virtual ~PropertyRepository() = default;
 
  PropertyRepositoryType getType() const { return m_type; }
 
  bool isShadow() const
  {
    if (m_propertyRepositoryEntry == nullptr) { return false; }
    return m_propertyRepositoryEntry->isShadow();
  }
 
  bool isEnabled() const { return m_propertyRepositoryEntry != nullptr; }
 
  virtual DataStorage getDataStorage() = 0;
 
  bool isMutable() const
  {
    if (m_propertyRepositoryEntry == nullptr) { return false; }
    return m_propertyRepositoryEntry->isMutable();
  }
 
  virtual void save(const std::vector<std::shared_ptr<PropertyBase>> &properties) = 0;
 
  virtual void save(std::shared_ptr<PropertyBase> property) = 0;
 
  virtual void deleteOf(const std::vector<std::shared_ptr<PropertyBase>> &properties) {}
 
  virtual std::vector<std::shared_ptr<PropertyBase>> awake() = 0;
 
  virtual std::vector<std::shared_ptr<PropertyBase>> allOf(const std::string &processName = ".*",
    const std::string &className = ".*",
    const std::string &instanceName = ".*",
    const std::string &name = ".*")
  {
    return {};
  }
};
 
}// namespace lintel
#endif// LOGGING_PROPERTYREPOSITORY_H