ApplicationModule.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "CircularDependencyDetectionRecursionStopper.h"
#include "Logger.h"
#include "Model.h"
#include "VariableGroup.h"
 
#include <boost/thread.hpp>
 
#include <list>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class Application;
  class ModuleGroup;
  class ConfigReader;
 
  /********************************************************************************************************************/
 
  class ApplicationModule : public VariableGroup {
   public:
    ApplicationModule(ModuleGroup* owner, const std::string& name, const std::string& description,
        const std::unordered_set<std::string>& tags = {});
 
    ApplicationModule() = default;
 
    ApplicationModule(ApplicationModule&& other) noexcept { operator=(std::move(other)); }
 
    ApplicationModule& operator=(ApplicationModule&& other) noexcept;
 
    ~ApplicationModule() override;
 
    virtual void mainLoop() = 0;
 
    void run() override;
 
    void terminate() override;
 
    ModuleType getModuleType() const override { return ModuleType::ApplicationModule; }
 
    VersionNumber getCurrentVersionNumber() const override { return _currentVersionNumber; }
 
    DataValidity getDataValidity() const override;
 
    void incrementDataFaultCounter() override;
    void decrementDataFaultCounter() override;
 
    size_t getDataFaultCounter() const { return _dataFaultCounter; }
 
    void setCurrentVersionNumber(VersionNumber versionNumber) override;
 
    std::list<EntityOwner*> getInputModulesRecursively(std::list<EntityOwner*> startList) override;
 
    size_t getCircularNetworkHash() const override;
 
    void setCircularNetworkHash(size_t circularNetworkHash);
 
    ChimeraTK::Model::ApplicationModuleProxy getModel() { return _model; }
 
    void unregisterModule(Module* module) override;
 
    Logger::StreamProxy logger(Logger::Severity severity);
 
    Logger::StreamProxy trace();
 
    Logger::StreamProxy debug();
 
    Logger::StreamProxy info();
 
    Logger::StreamProxy warning();
 
    Logger::StreamProxy error();
 
   protected:
    void mainLoopWrapper();
 
    boost::thread _moduleThread;
 
    VersionNumber _currentVersionNumber{nullptr};
 
    std::atomic<size_t> _dataFaultCounter{0};
 
    size_t _circularNetworkHash{0};
 
    detail::CircularDependencyDetectionRecursionStopper _recursionStopper;
 
    std::string className() {
      auto name = boost::core::demangle(typeid(*this).name());
      return name.substr(name.find_last_of(':') + 1);
    }
 
    ChimeraTK::Model::ApplicationModuleProxy _model;
    friend class ChimeraTK::Model::Impl;
  };
 
  /********************************************************************************************************************/
 
  inline Logger::StreamProxy ApplicationModule::logger(Logger::Severity severity) {
    return ChimeraTK::logger(severity, className());
  }
 
  /********************************************************************************************************************/
 
  inline Logger::StreamProxy ApplicationModule::trace() {
    return logger(Logger::Severity::trace);
  }
 
  /********************************************************************************************************************/
 
  inline Logger::StreamProxy ApplicationModule::debug() {
    return logger(Logger::Severity::debug);
  }
 
  /********************************************************************************************************************/
 
  inline Logger::StreamProxy ApplicationModule::info() {
    return logger(Logger::Severity::info);
  }
  /********************************************************************************************************************/
 
  inline Logger::StreamProxy ApplicationModule::warning() {
    return logger(Logger::Severity::warning);
  }
 
  /********************************************************************************************************************/
 
  inline Logger::StreamProxy ApplicationModule::error() {
    return logger(Logger::Severity::error);
  }
} /* namespace ChimeraTK */