diff --git a/apps/ccam/ccam.cpp b/apps/ccam/ccam.cpp
index 4f6a659..4313d2b 100644
--- a/apps/ccam/ccam.cpp
+++ b/apps/ccam/ccam.cpp
@@ -1,335 +1,342 @@
 //===-- apps/ccam/ccam.cpp --------------------------------------*- C++ -*-===//
 //
 //                 The RoSA Framework -- Application CCAM
 //
+// Distributed under the terms and conditions of the Boost Software
+///License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file apps/ccam/ccam.cpp
 ///
 /// \author Maximilian Goetzinger (maximilian.goetzinger@tuwien.ac.at)
 /// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief The application CCAM implements the case study from the paper:
 /// M. Goetzinger, N. TaheriNejad, H. A. Kholerdi, A. Jantsch, E. Willegger,
 /// T. Glatzl, A.M. Rahmani, T.Sauter, P. Liljeberg: Model - Free Condition
 /// Monitoring with Confidence
 //===----------------------------------------------------------------------===//
 #include "rosa/agent/Abstraction.hpp"
 #include "rosa/agent/Confidence.hpp"
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include <iostream>
 
 #include "rosa/config/version.h"
 
 #include "rosa/agent/SignalStateDetector.hpp"
 #include "rosa/agent/SystemStateDetector.hpp"
 #include "rosa/deluxe/DeluxeContext.hpp"
 
 #include "rosa/support/csv/CSVReader.hpp"
 #include "rosa/support/csv/CSVWriter.hpp"
 
 #include <fstream>
 #include <limits>
 #include <memory>
 #include <streambuf>
 
 #include "configuration.h"
 #include "statehandlerutils.h"
 
 using namespace rosa;
 using namespace rosa::agent;
 using namespace rosa::deluxe;
 using namespace rosa::terminal;
 
 const std::string AppName = "CCAM";
 
 int main(int argc, char **argv) {
 
   LOG_INFO_STREAM << '\n'
                   << library_string() << " -- " << Color::Red << AppName
                   << "app" << Color::Default << '\n';
 
   if (argc < 2) {
     LOG_ERROR("Specify config File!\nUsage:\n\tccam config.json");
     return 1;
   }
   std::string ConfigPath = argv[1];
 
   if (!readConfigFile(ConfigPath)) {
     LOG_ERROR_STREAM << "Could not read config from \"" << ConfigPath << "\"\n";
     return 2;
   }
 
   std::string InputFilePath, OutputFilePath;
 
   LOG_INFO("Creating Context");
   std::unique_ptr<DeluxeContext> C = DeluxeContext::create(AppName);
 
   std::shared_ptr<PartialFunction<uint32_t, float>> BrokenDelayFunction(
       new PartialFunction<uint32_t, float>(
           {{{0, AppConfig.BrokenCounter},
             std::make_shared<LinearFunction<uint32_t, float>>(
                 0, 0.f, AppConfig.BrokenCounter, 1.f)},
            {{AppConfig.BrokenCounter, std::numeric_limits<uint32_t>::max()},
             std::make_shared<LinearFunction<uint32_t, float>>(1.f, 0.f)}},
           0.f));
 
   std::shared_ptr<PartialFunction<uint32_t, float>> OkDelayFunction(
       new PartialFunction<uint32_t, float>(
           {{{0, AppConfig.BrokenCounter},
             std::make_shared<LinearFunction<uint32_t, float>>(
                 0, 1.f, AppConfig.BrokenCounter, 0.f)},
            {{AppConfig.BrokenCounter, std::numeric_limits<uint32_t>::max()},
             std::make_shared<LinearFunction<uint32_t, float>>(0.f, 0.f)}},
           1.f));
 
   //
   // Create a DeluxeAgent with SystemStateDetector functionality.
   //
   LOG_INFO("Create SystemStateDetector agent.");
   AgentHandle SystemStateDetectorAgent = createSystemStateDetectorAgent(
       C, "SystemStateDetector", AppConfig.SignalConfigurations.size(),
       BrokenDelayFunction, OkDelayFunction);
 
   std::set<size_t> pos;
   for (size_t i = 0; i < AppConfig.SignalConfigurations.size(); ++i)
     pos.insert(pos.end(), i);
 
   C->setExecutionPolicy(SystemStateDetectorAgent,
                         DeluxeExecutionPolicy::awaitAll(pos));
 
   LOG_INFO("Creating sensors, SignalStateDetector functionalities and their "
            "Abstractions.");
   std::vector<AgentHandle> Sensors;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SampleMatchesFunctions;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SampleMismatchesFunctions;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SignalIsStableFunctions;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SignalIsDriftingFunctions;
   std::vector<std::shared_ptr<StepFunction<float, float>>>
       NumOfSamplesMatchFunctions;
   std::vector<std::shared_ptr<StepFunction<float, float>>>
       NumOfSamplesMismatchFunctions;
   std::vector<std::shared_ptr<
       SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>>
       SignalStateDetectors;
   std::vector<AgentHandle> SignalStateDetectorAgents;
   std::vector<std::ifstream> DataFiles;
 
   for (auto SignalConfiguration : AppConfig.SignalConfigurations) {
     //
     // Create deluxe sensors.
     //
     Sensors.emplace_back(
         C->createSensor<float>(SignalConfiguration.Name + "_Sensor"));
 
     //
     // Create functionalities for SignalStateDetector.
     //
     SampleMatchesFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBound, 0.f,
                  -SignalConfiguration.InnerBound, 1.f)},
             {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(1.f, 0.f)},
             {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBound, 1.f,
                  SignalConfiguration.OuterBound, 0.f)},
         },
         0));
 
     SampleMismatchesFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBound, 1.f,
                  -SignalConfiguration.InnerBound, 0.f)},
             {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(0.f, 0.f)},
             {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBound, 0.f,
                  SignalConfiguration.OuterBound, 1.f)},
         },
         1));
 
     SignalIsStableFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBoundDrift,
               -SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBoundDrift, 0.f,
                  -SignalConfiguration.InnerBoundDrift, 1.f)},
             {{-SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(1.f, 0.f)},
             {{SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.OuterBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBoundDrift, 1.f,
                  SignalConfiguration.OuterBoundDrift, 0.f)},
         },
         0));
 
     SignalIsDriftingFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBoundDrift,
               -SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBoundDrift, 1.f,
                  -SignalConfiguration.InnerBoundDrift, 0.f)},
             {{-SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(0.f, 0.f)},
             {{SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.OuterBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBoundDrift, 0.f,
                  SignalConfiguration.OuterBoundDrift, 1.f)},
         },
         1));
 
     NumOfSamplesMatchFunctions.emplace_back(new StepFunction<float, float>(
         1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepUp));
 
     NumOfSamplesMismatchFunctions.emplace_back(new StepFunction<float, float>(
         1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepDown));
 
     //
     // Create SignalStateDetector functionality
     //
     SignalStateDetectors.emplace_back(
         new SignalStateDetector<float, float, float, HistoryPolicy::FIFO>(
             SignalConfiguration.Output ? SignalProperties::OUTPUT
                                        : SignalProperties::INPUT,
             std::numeric_limits<int>::max(), SampleMatchesFunctions.back(),
             SampleMismatchesFunctions.back(), NumOfSamplesMatchFunctions.back(),
             NumOfSamplesMismatchFunctions.back(),
             SignalIsDriftingFunctions.back(), SignalIsStableFunctions.back(),
             SignalConfiguration.SampleHistorySize, SignalConfiguration.DABSize,
             SignalConfiguration.DABHistorySize));
 
     //
     // Create low-level deluxe agents
     //
     SignalStateDetectorAgents.push_back(createSignalStateDetectorAgent(
         C, SignalConfiguration.Name, SignalStateDetectors.back()));
 
     C->setExecutionPolicy(
         SignalStateDetectorAgents.back(),
         DeluxeExecutionPolicy::decimation(AppConfig.DownsamplingRate));
     //
     // Connect sensors to low-level agents.
     //
     LOG_INFO("Connect sensors to their corresponding low-level agents.");
 
     C->connectSensor(SignalStateDetectorAgents.back(), 0, Sensors.back(),
                      SignalConfiguration.Name + "_Sensor ->" +
                          SignalConfiguration.Name +
                          "_SignalStateDetector_Agent-Channel");
 
     C->connectAgents(
         SystemStateDetectorAgent, SignalStateDetectors.size() - 1,
         SignalStateDetectorAgents.back(),
         SignalConfiguration.Name +
             "_SignalStateDetector_Agent->SystemStateDetector_Agent_Channel");
   }
 
   //
   // For simulation output, create a logger agent writing the output of the
   // high-level agent into a CSV file.
   //
   LOG_INFO("Create a logger agent.");
 
   // Create CSV writer.
   std::ofstream OutputCSV(AppConfig.OutputFilePath);
 
   for (auto SignalConfiguration : AppConfig.SignalConfigurations) {
     OutputCSV << SignalConfiguration.Name + ",";
   }
   OutputCSV << "StateID,";
   OutputCSV << "Confidence State Valid,";
   OutputCSV << "Confidence State Invalid,";
   OutputCSV << "Confidence Inputs Matching,";
   OutputCSV << "Confidence Outputs Matching,";
   OutputCSV << "Confidence Inputs Mismatching,";
   OutputCSV << "Confidence Outputs Mismatching,";
   OutputCSV << "State Condition,";
   OutputCSV << "Confidence System Functioning,";
   OutputCSV << "Confidence System Malfunctioning,";
   OutputCSV << "Overall Confidence,";
   OutputCSV << "\n";
 
   // The agent writes each new input value into a CSV file and produces
   // nothing.
   using Input = std::pair<SystemStateTuple, bool>;
   using Result = Optional<DeluxeTuple<unit_t>>;
   using Handler = std::function<Result(Input)>;
   std::string Name = "Logger Agent";
 
   AgentHandle LoggerAgent =
       C->createAgent("Logger Agent", Handler([&OutputCSV](Input I) -> Result {
                        OutputCSV << std::get<0>(I.first) << std::endl;
                        return Result();
                      }));
   //
   // Connect the high-level agent to the logger agent.
   //
   LOG_INFO("Connect the high-level agent to the logger agent.");
 
   C->connectAgents(LoggerAgent, 0, SystemStateDetectorAgent,
                    "SystemStateDetector Channel");
 
   //
   // Only log if the SystemStateDetector actually ran
   //
   C->setExecutionPolicy(LoggerAgent, DeluxeExecutionPolicy::awaitAll({0}));
 
   //
   // Do simulation.
   //
   LOG_INFO("Setting up and performing simulation.");
 
   //
   // Initialize deluxe context for simulation.
   //
   C->initializeSimulation();
 
   //
   // Open CSV files and register them for their corresponding sensors.
   //
   // Make sure DataFiles will not change capacity while adding elements to it.
   // Changing capacity moves elements away, which invalidates references
   // captured by CSVIterator.
   DataFiles.reserve(AppConfig.SignalConfigurations.size());
   uint32_t i = 0;
   for (auto SignalConfiguration : AppConfig.SignalConfigurations) {
     DataFiles.emplace_back(SignalConfiguration.InputPath);
     if (!DataFiles.at(i)) {
       LOG_ERROR_STREAM << "Cannot open Input File \""
                        << SignalConfiguration.InputPath << "\" for Signal \""
                        << SignalConfiguration.Name << "\"" << std::endl;
       return 3;
     }
 
     C->registerSensorValues(Sensors.at(i),
                             csv::CSVIterator<float>(DataFiles.at(i)),
                             csv::CSVIterator<float>());
     i++;
   }
 
   //
   // Simulate.
   //
   C->simulate(AppConfig.NumberOfSimulationCycles);
 
   return 0;
 }
diff --git a/include/rosa/agent/SignalStateDetector.hpp b/include/rosa/agent/SignalStateDetector.hpp
index 53f2684..7b05bc4 100644
--- a/include/rosa/agent/SignalStateDetector.hpp
+++ b/include/rosa/agent/SignalStateDetector.hpp
@@ -1,272 +1,278 @@
 //===-- rosa/agent/SignalStateDetector.hpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SignalStateDetector.hpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Definition of *signal state detector* *functionality*.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_SIGNALSTATEDETECTOR_HPP
 #define ROSA_AGENT_SIGNALSTATEDETECTOR_HPP
 
 #include "rosa/agent/Functionality.h"
 #include "rosa/agent/SignalState.hpp"
 #include "rosa/agent/StateDetector.hpp"
 
 #include <vector>
 
 namespace rosa {
 namespace agent {
 
 /// Implements \c rosa::agent::SignalStateDetector as a functionality that
 /// detects signal states given on input samples.
 ///
 /// \note This implementation is supposed to be used for samples of an
 /// arithmetic type.
 ///
 /// \tparam INDATATYPE type of input data, \tparam CONFDATATYPE type of
 /// data in that the confidence values are given, \tparam PROCDATATYPE type of
 /// the relative distance and the type of data in which DABs are saved.
 template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE,
           HistoryPolicy HP>
 class SignalStateDetector
     : public StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP> {
 
   // @maxi added them so it is compilable is this what you intended?
   using StateDetector =
       StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP>;
   using PartFuncPointer = typename StateDetector::PartFuncPointer;
   using StepFuncPointer = typename StateDetector::StepFuncPointer;
 
 private:
   // For the convinience to write a shorter data type name
   using SignalStatePtr =
       std::shared_ptr<SignalState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>>;
 
   /// The SignalProperty saves whether the monitored signal is an input our
   /// output signal.
   SignalProperties SignalProperty;
 
   /// The CurrentSignalState is a pointer to the (saved) signal state in which
   /// the actual variable (signal) of the observed system is.
   SignalStatePtr CurrentSignalState;
 
   /// The DetectedSignalStates is a history in that all detected signal states
   /// are saved.
   DynamicLengthHistory<SignalStatePtr, HP> DetectedSignalStates;
 
   /// The FuzzyFunctionSampleMatches is the fuzzy function that gives the
   /// confidence how good the new sample matches another sample in the sample
   /// history.
   PartFuncPointer FuzzyFunctionSampleMatches;
 
   /// The FuzzyFunctionSampleMismatches is the fuzzy function that gives the
   /// confidence how bad the new sample matches another sample in the sample
   /// history.
   PartFuncPointer FuzzyFunctionSampleMismatches;
 
   /// The FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the
   /// confidence how many samples from the sampe history match the new sample.
   StepFuncPointer FuzzyFunctionNumOfSamplesMatches;
 
   /// The FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives
   /// the confidence how many samples from the sampe history mismatch the new
   /// sample.
   StepFuncPointer FuzzyFunctionNumOfSamplesMismatches;
 
   /// The FuzzyFunctionSignalIsDrifting is the fuzzy function that gives the
   /// confidence how likely it is that the signal is drifting.
   PartFuncPointer FuzzyFunctionSignalIsDrifting;
 
   /// The FuzzyFunctionSignalIsStable is the fuzzy function that gives the
   /// confidence how likely it is that the signal is stable (not drifting).
   PartFuncPointer FuzzyFunctionSignalIsStable;
 
   /// SampleHistorySize is the (maximum) size of the sample history.
   uint32_t SampleHistorySize;
   /// DABSize the size of a DAB (Discrete Average Block).
   uint32_t DABSize;
   /// DABHistorySize is the (maximum) size of the DAB history.
   uint32_t DABHistorySize;
 
 public:
   /// Creates an instance by setting all parameters
   /// \param FuzzyFunctionSampleMatches The FuzzyFunctionSampleMatches is the
   /// fuzzy function that gives the confidence how good the new sample matches
   /// another sample in the sample history.
   ///
   /// \param FuzzyFunctionSampleMismatches The FuzzyFunctionSampleMismatches is
   /// the fuzzy function that gives the confidence how bad the new sample
   /// matches another sample in the sample history.
   ///
   /// \param FuzzyFunctionNumOfSamplesMatches The
   /// FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the
   /// confidence how many samples from the sampe history match the new sample.
   ///
   /// \param FuzzyFunctionNumOfSamplesMismatches The
   /// FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives the
   /// confidence how many samples from the sampe history mismatch the new
   /// sample.
   ///
   /// \param FuzzyFunctionSignalIsDrifting The FuzzyFunctionSignalIsDrifting is
   /// the fuzzy function that gives the confidence how likely it is that the
   /// signal (resp. the state of a signal) is drifting.
   ///
   /// \param FuzzyFunctionSignalIsStable The FuzzyFunctionSignalIsStable is the
   /// fuzzy function that gives the confidence how likely it is that the signal
   /// (resp. the state of a signal) is stable (not drifting).
   ///
   /// \param SampleHistorySize Sets the History size which will be used by \c
   /// SignalState.
   ///
   /// \param DABSize Sets the DAB size which will be used by \c SignalState.
   ///
   /// \param DABHistorySize Sets the size which will be used by \c SignalState.
   ///
   SignalStateDetector(SignalProperties SignalProperty,
                       uint32_t MaximumNumberOfSignalStates,
                       PartFuncPointer FuzzyFunctionSampleMatches,
                       PartFuncPointer FuzzyFunctionSampleMismatches,
                       StepFuncPointer FuzzyFunctionNumOfSamplesMatches,
                       StepFuncPointer FuzzyFunctionNumOfSamplesMismatches,
                       PartFuncPointer FuzzyFunctionSignalIsDrifting,
                       PartFuncPointer FuzzyFunctionSignalIsStable,
                       uint32_t SampleHistorySize, uint32_t DABSize,
                       uint32_t DABHistorySize) noexcept
       : SignalProperty(SignalProperty), CurrentSignalState(nullptr),
         DetectedSignalStates(MaximumNumberOfSignalStates),
         FuzzyFunctionSampleMatches(FuzzyFunctionSampleMatches),
         FuzzyFunctionSampleMismatches(FuzzyFunctionSampleMismatches),
         FuzzyFunctionNumOfSamplesMatches(FuzzyFunctionNumOfSamplesMatches),
         FuzzyFunctionNumOfSamplesMismatches(
             FuzzyFunctionNumOfSamplesMismatches),
         FuzzyFunctionSignalIsDrifting(FuzzyFunctionSignalIsDrifting),
         FuzzyFunctionSignalIsStable(FuzzyFunctionSignalIsStable),
         SampleHistorySize(SampleHistorySize), DABSize(DABSize),
         DABHistorySize(DABHistorySize) {
     this->NextStateID = 1;
     this->StateHasChanged = false;
   }
 
   /// Destroys \p this object.
   ~SignalStateDetector(void) = default;
 
   /// Detects the signal state to which the new sample belongs or create a new
   /// signal state if the new sample does not match to any of the saved states.
   ///
   /// \param Sample is the actual sample of the observed signal.
   ///
   /// \return the information of the current signal state (signal state ID and
   /// other parameters).
   // TODO (future): change to operator()
   SignalStateInformation<CONFDATATYPE>
   detectSignalState(INDATATYPE Sample) noexcept {
 
     if (!CurrentSignalState) {
       ASSERT(DetectedSignalStates.empty());
       SignalStatePtr S = createNewSignalState();
       CurrentSignalState = S;
     } else {
       CONFDATATYPE ConfidenceSampleMatchesSignalState =
           CurrentSignalState->confidenceSampleMatchesSignalState(Sample);
       CONFDATATYPE ConfidenceSampleMismatchesSignalState =
           CurrentSignalState->confidenceSampleMismatchesSignalState(Sample);
 
       this->StateHasChanged = ConfidenceSampleMatchesSignalState <=
                               ConfidenceSampleMismatchesSignalState;
 
       if (this->StateHasChanged) {
 
         if (CurrentSignalState->signalStateInformation().StateIsValid)
           CurrentSignalState->leaveSignalState();
         else
           DetectedSignalStates.deleteEntry(CurrentSignalState);
 
         // TODO (future): additionally save averages to enable fast iteration
         // through recorded signl state history (maybe sort vector based on
         // these average values)
         CurrentSignalState = nullptr;
 
         for (auto &SavedSignalState : DetectedSignalStates) {
           ConfidenceSampleMatchesSignalState =
               SavedSignalState->confidenceSampleMatchesSignalState(Sample);
           ConfidenceSampleMismatchesSignalState =
               SavedSignalState->confidenceSampleMismatchesSignalState(Sample);
 
           if (ConfidenceSampleMatchesSignalState >
               ConfidenceSampleMismatchesSignalState) {
             // TODO (future): maybe it would be better to compare
             // ConfidenceSampleMatchesSignalState of all signal states in the
             // vector in order to find the best matching signal state.
             CurrentSignalState = SavedSignalState;
             break;
           }
         }
 
         if (!CurrentSignalState) {
           SignalStatePtr S = createNewSignalState();
           CurrentSignalState = S;
         }
       }
     }
 
     SignalStateInformation<CONFDATATYPE> SignalStateInfo =
         CurrentSignalState->insertSample(Sample);
 
     if (SignalStateInfo.StateJustGotValid) {
       this->NextStateID++;
     }
 
     return SignalStateInfo;
   }
 
   /// Gives information about the current signal state.
   ///
   /// \return a struct SignalStateInformation that contains information about
   /// the current signal state or NULL if no current signal state exists.
   SignalStateInformation<CONFDATATYPE>
   currentSignalStateInformation(void) noexcept {
     if (CurrentSignalState) {
       return CurrentSignalState->signalStateInformation();
     } else {
       return NULL;
     }
   }
 
   /// Gives information whether a signal state change has happened or not.
   ///
   /// \return true if a signal state change has happened, and false if not.
   bool stateHasChanged(void) noexcept { return this->StateHasChanged; }
 
 private:
   /// Creates a new signal state and adds it to the signal state vector in which
   /// all known states are saved.
   ///
   /// \return a pointer to the newly created signal state or NULL if no state
   /// could be created.
   SignalStatePtr createNewSignalState(void) noexcept {
     SignalStatePtr S(new SignalState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>(
         this->NextStateID, SignalProperty, SampleHistorySize, DABSize,
         DABHistorySize, *FuzzyFunctionSampleMatches,
         *FuzzyFunctionSampleMismatches, *FuzzyFunctionNumOfSamplesMatches,
         *FuzzyFunctionNumOfSamplesMismatches, *FuzzyFunctionSignalIsDrifting,
         *FuzzyFunctionSignalIsStable));
 
     DetectedSignalStates.addEntry(S);
 
     return S;
   }
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_SIGNALSTATEDETECTOR_HPP
diff --git a/include/rosa/agent/State.hpp b/include/rosa/agent/State.hpp
index d3568a3..0a1abd4 100644
--- a/include/rosa/agent/State.hpp
+++ b/include/rosa/agent/State.hpp
@@ -1,87 +1,93 @@
 //===-- rosa/agent/State.hpp ------------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/State.hpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Definition of *state* *functionality*.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_STATE_HPP
 #define ROSA_AGENT_STATE_HPP
 
 #include "rosa/agent/Functionality.h"
 //#include "rosa/agent/FunctionAbstractions.hpp"
 //#include "rosa/agent/History.hpp"
 
 #include "rosa/support/debug.hpp"
 
 #include <stdint.h>
 
 //#include <vector>
 
 namespace rosa {
 namespace agent {
 
 /// State conditions defining how the condition of a \c rosa::agent::State is
 /// saved in \c rosa::agent::StateInformation.
 enum StateConditions : uint8_t {
   UNKNOWN = 0,       ///< The state is unknown
   STABLE = 1,        ///< The state is stable
   DRIFTING = 2,      ///< The state is drifting
   MALFUNCTIONING = 3 ///< Malfunction
 };
 
 template <typename CONFDATATYPE> struct StateInformation {
   // Make sure the actual type arguments are matching our expectations.
   STATIC_ASSERT((std::is_arithmetic<CONFDATATYPE>::value),
                 "confidence type is not to arithmetic");
   /// The StateID stores the ID of the state.
   unsigned int StateID;
   /// The StateCondition shows the condition of a state (stable, drifting, or
   /// unknown)
   StateConditions StateCondition;
   /// The StateIsValid shows whether a state is valid or invalid. In this
   /// context, valid means that enough samples which are in close proximitry
   /// have been inserted into the state.
   bool StateIsValid;
   /// The StateJustGotValid shows whether a state got valid (toggled from
   /// invalid to valid) during the current inserted sample.
   bool StateJustGotValid;
   /// The StateIsValidAfterReentrance shows whether a state is valid after the
   /// variable changed back to it again.
   bool StateIsValidAfterReentrance;
 
   /// TODO: describe
   CONFDATATYPE ConfidenceStateIsValid;
   CONFDATATYPE ConfidenceStateIsInvalid;
 
   CONFDATATYPE ConfidenceStateIsStable;
   CONFDATATYPE ConfidenceStateIsDrifting;
 };
 
 template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE>
 class State : public Functionality {
 
   // Make sure the actual type arguments are matching our expectations.
   STATIC_ASSERT((std::is_arithmetic<INDATATYPE>::value),
                 "input data type not arithmetic");
   STATIC_ASSERT((std::is_arithmetic<CONFDATATYPE>::value),
                 "confidence abstraction type is not to arithmetic");
   STATIC_ASSERT((std::is_arithmetic<PROCDATATYPE>::value),
                 "process type is not to arithmetic");
 
 protected:
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_SIGNALSTATEDETECTOR_HPP
diff --git a/include/rosa/agent/StateDetector.hpp b/include/rosa/agent/StateDetector.hpp
index 34b5298..6f3d7ce 100644
--- a/include/rosa/agent/StateDetector.hpp
+++ b/include/rosa/agent/StateDetector.hpp
@@ -1,58 +1,64 @@
 //===-- rosa/agent/StateDetector.hpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/StateDetector.hpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Definition of *state detector* *functionality*.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_STATEDETECTOR_HPP
 #define ROSA_AGENT_STATEDETECTOR_HPP
 
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include "rosa/agent/History.hpp"
 
 #include <vector>
 
 namespace rosa {
 namespace agent {
 
 template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE,
           HistoryPolicy HP>
 class StateDetector : public Functionality {
 
   // Make sure the actual type arguments are matching our expectations.
   STATIC_ASSERT((std::is_arithmetic<INDATATYPE>::value),
                 "input data type not arithmetic");
   STATIC_ASSERT((std::is_arithmetic<CONFDATATYPE>::value),
                 "confidence abstraction type is not to arithmetic");
   STATIC_ASSERT((std::is_arithmetic<PROCDATATYPE>::value),
                 "process type is not to arithmetic");
 
 protected:
   using PartFuncPointer =
       std::shared_ptr<PartialFunction<INDATATYPE, CONFDATATYPE>>;
   using StepFuncPointer =
       std::shared_ptr<StepFunction<INDATATYPE, CONFDATATYPE>>;
 
   /// The NextSignalStateID is a counter variable which stores the ID which the
   /// next signal state shall have.
   uint32_t NextStateID;
 
   /// The SignalStateHasChanged is a flag that show whether a signal has changed
   /// its state.
   bool StateHasChanged;
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_SIGNALSTATEDETECTOR_HPP
diff --git a/include/rosa/agent/SystemState.hpp b/include/rosa/agent/SystemState.hpp
index ff02e15..af63c17 100644
--- a/include/rosa/agent/SystemState.hpp
+++ b/include/rosa/agent/SystemState.hpp
@@ -1,291 +1,297 @@
 //===-- rosa/agent/SystemState.hpp ------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SystemState.hpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Definition of *system state* *functionality*.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_SYSTEMSTATE_HPP
 #define ROSA_AGENT_SYSTEMSTATE_HPP
 
 #include "rosa/agent/Functionality.h"
 #include "rosa/agent/SignalState.hpp"
 #include "rosa/agent/State.hpp"
 
 #include "rosa/support/debug.hpp"
 
 #include <vector>
 
 namespace rosa {
 namespace agent {
 
 enum class SystemStateRelation : uint8_t {
   STATEISMATCHING = 0,      ///< The system state is matching
   ONLYINPUTISMATCHING = 1,  ///< Only inputs of the system state are matching
   ONLYOUTPUTISMATCHING = 2, ///< Only outputs of the system state are matching
   STATEISMISMATCHING = 3    ///< The system state is mismatching
 };
 
 /// TODO: write description
 template <typename CONFDATATYPE>
 struct SystemStateInformation : StateInformation<CONFDATATYPE> {
   /// TODO: describe
   CONFDATATYPE ConfidenceOfInputsMatchingState;
   CONFDATATYPE ConfidenceOfInputsMismatchingState;
   CONFDATATYPE ConfidenceOfOutputsMatchingState;
   CONFDATATYPE ConfidenceOfOutputsMismatchingState;
   CONFDATATYPE ConfidenceSystemIsFunctioning;
   CONFDATATYPE ConfidenceSystemIsMalfunctioning;
   CONFDATATYPE ConfidenceOfAllDecisions;
 
 public:
   SystemStateInformation() {}
 
   SystemStateInformation(unsigned int _SystemStateID,
                          StateConditions _StateCondition) {
     this->StateID = _SystemStateID;
     this->StateCondition = _StateCondition;
     this->StateIsValid = false;
     this->StateJustGotValid = false;
     this->StateIsValidAfterReentrance = false;
     this->ConfidenceOfInputsMatchingState = 0;
     this->ConfidenceOfInputsMismatchingState = 0;
     this->ConfidenceOfOutputsMatchingState = 0;
     this->ConfidenceOfOutputsMismatchingState = 0;
     this->ConfidenceSystemIsFunctioning = 0;
     this->ConfidenceSystemIsMalfunctioning = 0;
     this->ConfidenceOfAllDecisions = 0;
   }
 };
 
 // todo: do we need PROCDATATYPE?
 /// TODO TEXT
 template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE>
 class SystemState : public State<INDATATYPE, CONFDATATYPE, PROCDATATYPE> {
 
   // Make sure the actual type arguments are matching our expectations.
   STATIC_ASSERT(std::is_arithmetic<INDATATYPE>::value,
                 "input data type is not to arithmetic");
   STATIC_ASSERT(std::is_arithmetic<CONFDATATYPE>::value,
                 "confidence abstraction type is not to arithmetic");
   STATIC_ASSERT(std::is_arithmetic<PROCDATATYPE>::value,
                 "process data type is not to arithmetic");
 
 private:
   /// SignalStateInfo is a struct of SignalStateInformation that contains
   /// information about the current signal state.
   SystemStateInformation<CONFDATATYPE> SystemStateInfo;
 
   std::vector<SignalStateInformation<CONFDATATYPE>> SignalStateInfos;
 
   uint32_t NumberOfSignals;
 
 public:
   /// TODO: write description
   SystemState(uint32_t StateID, uint32_t NumberOfSignals) noexcept
       : SystemStateInfo(StateID, StateConditions::UNKNOWN),
         NumberOfSignals(NumberOfSignals) {
     SignalStateInfos.resize(NumberOfSignals);
   }
 
   /// Destroys \p this object.
   ~SystemState(void) = default;
 
   /// TODO: write description
   SystemStateInformation<CONFDATATYPE> insertSignalStateInformation(
       const std::vector<SignalStateInformation<CONFDATATYPE>>
           _SignalStateInfos) noexcept {
     ASSERT(_SignalStateInfos.size() == NumberOfSignals);
 
     bool AllSignalsAreValid = true;
     bool AtLeastOneSignalJustGotValid = false;
     bool AllSignalsAreValidAfterReentrance = true;
 
     bool AtLeastOneSignalIsUnknown = false;
     bool AllSignalsAreStable = true;
 
     // TODO: change this
     SystemStateInfo.ConfidenceOfInputsMatchingState = 1;
     SystemStateInfo.ConfidenceOfInputsMismatchingState = 0;
     SystemStateInfo.ConfidenceOfOutputsMatchingState = 1;
     SystemStateInfo.ConfidenceOfOutputsMismatchingState = 0;
     SystemStateInfo.ConfidenceStateIsValid = 1;
     SystemStateInfo.ConfidenceStateIsInvalid = 0;
     SystemStateInfo.ConfidenceStateIsStable = 1;
     SystemStateInfo.ConfidenceStateIsDrifting = 0;
 
     std::size_t counter = 0;
     for (auto SSI : _SignalStateInfos) {
 
       if (!SSI.StateIsValid)
         AllSignalsAreValid = false;
       if (SSI.StateJustGotValid)
         AtLeastOneSignalJustGotValid = true;
       if (!SSI.StateIsValidAfterReentrance)
         AllSignalsAreValidAfterReentrance = false;
 
       if (SSI.StateCondition == StateConditions::UNKNOWN)
         AtLeastOneSignalIsUnknown = true;
       if (SSI.StateCondition == StateConditions::DRIFTING)
         AllSignalsAreStable = false;
 
       if (SSI.SignalProperty == SignalProperties::INPUT) {
         //printf("AAAAAAAAAAAAAAAA 6\n");
         printf("SystemStateInfo.ConfidenceOfInputsMatchingState = %f\nSSI."
                "ConfidenceOfMatchingState = %f\n",
                SystemStateInfo.ConfidenceOfInputsMatchingState,
                SSI.ConfidenceOfMatchingState);
         SystemStateInfo.ConfidenceOfInputsMatchingState =
             fuzzyAND(SystemStateInfo.ConfidenceOfInputsMatchingState,
                      SSI.ConfidenceOfMatchingState);
         SystemStateInfo.ConfidenceOfInputsMismatchingState =
             fuzzyOR(SystemStateInfo.ConfidenceOfInputsMismatchingState,
                     SSI.ConfidenceOfMismatchingState);
       } else {
         //printf("AAAAAAAAAAAAAAAA 7\n");
         SystemStateInfo.ConfidenceOfOutputsMatchingState =
             fuzzyAND(SystemStateInfo.ConfidenceOfOutputsMatchingState,
                      SSI.ConfidenceOfMatchingState);
         SystemStateInfo.ConfidenceOfOutputsMismatchingState =
             fuzzyOR(SystemStateInfo.ConfidenceOfOutputsMismatchingState,
                     SSI.ConfidenceOfMismatchingState);
       }
 
       //printf("AAAAAAAAAAAAAAAA 8\n");
       SystemStateInfo.ConfidenceStateIsValid = fuzzyAND(
           SystemStateInfo.ConfidenceStateIsValid, SSI.ConfidenceStateIsValid);
       //printf("AAAAAAAAAAAAAAAA 9\n");
       SystemStateInfo.ConfidenceStateIsInvalid =
           fuzzyOR(SystemStateInfo.ConfidenceStateIsInvalid,
                   SSI.ConfidenceStateIsInvalid);
       SystemStateInfo.ConfidenceStateIsStable = fuzzyAND(
           SystemStateInfo.ConfidenceStateIsStable, SSI.ConfidenceStateIsStable);
       SystemStateInfo.ConfidenceStateIsDrifting =
           fuzzyOR(SystemStateInfo.ConfidenceStateIsDrifting,
                   SSI.ConfidenceStateIsDrifting);
 
       this->SignalStateInfos.at(counter) = SSI;
       counter++;
     }
 
     SystemStateInfo.StateIsValid = AllSignalsAreValid;
     SystemStateInfo.StateJustGotValid =
         AllSignalsAreValid && AtLeastOneSignalJustGotValid;
     SystemStateInfo.StateIsValidAfterReentrance =
         AllSignalsAreValidAfterReentrance;
 
     if (AtLeastOneSignalIsUnknown)
       SystemStateInfo.StateCondition = StateConditions::UNKNOWN;
     else if (AllSignalsAreStable)
       SystemStateInfo.StateCondition = StateConditions::STABLE;
     else
       SystemStateInfo.StateCondition = StateConditions::DRIFTING;
 
     return SystemStateInfo;
   }
 
   /// TODO: write description
   // TODO (future): think about saving the state information in a history
   SystemStateRelation compareSignalStateInformation(
       const std::vector<SignalStateInformation<CONFDATATYPE>>
           _SignalStateInfos) noexcept {
     bool inputsAreMatching = true;
     bool outputsAreMatching = true;
     std::size_t counter = 0;
     for (auto SSI : _SignalStateInfos) {
       if (this->SignalStateInfos.at(counter).StateID != SSI.StateID) {
         if (SSI.SignalProperty == SignalProperties::INPUT)
           inputsAreMatching = false;
         else // SignalProperties::OUTPUT
           outputsAreMatching = false;
       }
       counter++;
     }
 
     if (inputsAreMatching && outputsAreMatching)
       return SystemStateRelation::STATEISMATCHING;
     else if (inputsAreMatching && !outputsAreMatching)
       return SystemStateRelation::ONLYINPUTISMATCHING;
     else if (!inputsAreMatching && outputsAreMatching)
       return SystemStateRelation::ONLYOUTPUTISMATCHING;
     else
       return SystemStateRelation::STATEISMISMATCHING;
   }
 
 #ifdef ADDITIONAL_FUNCTIONS
   /// TODO: write description
   template <std::size_t size>
   void insertSignalStateInformation(
       const std::array<SystemStateInformation<CONFDATATYPE>, size>
           &Data) noexcept {
     ASSERT(size <= NumberOfSignals);
     std::size_t counter = 0;
     for (auto tmp : Data) {
       Signals.at(counter) = tmp;
       counter++;
     }
   }
 
   /// TODO: write description
   template <typename... Types>
   std::enable_if_t<std::conjunction_v<std::is_same<
                        Types, SystemStateInformation<CONFDATATYPE>>...>,
                    void>
   insertSignalStateInformation(Types... Data) {
     // TODO (future): think about saving the state information in a history
     insertSignalStateInfos(
         std::array<SystemStateInformation<CONFDATATYPE>, sizeof...(Data)>(
             {Data...}));
   }
 
   // returns true if they are identical
   /// TODO: write description
   template <std::size_t size>
   bool compareSignalStateInformation(
       const std::array<SystemStateInformation<CONFDATATYPE>, size>
           &Data) noexcept {
     // TODO (future): think about saving the state information in a history
     std::size_t counter = 0;
     for (auto tmp : Data) {
       if (Signals.at(counter) != tmp)
         return false;
       counter++;
     }
     return true;
   }
 
   // checks only the given amount
   /// TODO: write description
   template <typename... Types>
   std::enable_if_t<std::conjunction_v<std::is_same<
                        Types, SystemStateInformation<CONFDATATYPE>>...>,
                    bool>
   compareSignalStateInformation(Types... Data) {
     return compareSignalStateInfos(
         std::array<SystemStateInformation<CONFDATATYPE>, sizeof...(Data)>(
             {Data...}));
   }
 #endif
 
   /// Gives information about the current signal state.
   ///
   /// \return a struct SignalStateInformation that contains information about
   /// the current signal state.
   SystemStateInformation<CONFDATATYPE> systemStateInformation(void) noexcept {
     return SystemStateInfo;
   }
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_SYSTEMSTATE_HPP
diff --git a/include/rosa/agent/SystemStateDetector.hpp b/include/rosa/agent/SystemStateDetector.hpp
index 05ec0f4..a25fa82 100644
--- a/include/rosa/agent/SystemStateDetector.hpp
+++ b/include/rosa/agent/SystemStateDetector.hpp
@@ -1,239 +1,245 @@
 //===-- rosa/agent/SystemStateDetector.hpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SystemStateDetector.hpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Definition of *system state detector* *functionality*.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
 #define ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
 
 #include "rosa/agent/Functionality.h"
 #include "rosa/agent/SignalState.hpp"
 #include "rosa/agent/StateDetector.hpp"
 #include "rosa/agent/SystemState.hpp"
 
 #include "rosa/support/debug.hpp"
 
 namespace rosa {
 namespace agent {
 
 /// TODO: write description
 template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE,
           HistoryPolicy HP>
 class SystemStateDetector
     : public StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP> {
 
   using StateDetector =
       StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP>;
   using PartFuncPointer = typename StateDetector::PartFuncPointer;
 
 private:
   // For the convinience to write a shorter data type name
   using SystemStatePtr =
       std::shared_ptr<SystemState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>>;
 
   /// TODO: description
   uint32_t NumberOfSignals;
 
   /// The CurrentSystemState is a pointer to the (saved) system state in which
   /// the actual state of the observed system is.
   SystemStatePtr CurrentSystemState;
 
   /// The DetectedSystemStates is a history in that all detected system states
   /// are saved.
   DynamicLengthHistory<SystemStatePtr, HP> DetectedSystemStates;
 
   /// TODO: description
   unsigned int TimeOfDisparity;
 
   /// The FuzzyFunctionDelayTimeToBeWorking is the fuzzy function that gives
   /// the
   /// confidence whether the system is still OK allthough an input change
   /// without an output change or vice versa.
   PartFuncPointer FuzzyFunctionTimeSystemFunctioning;
 
   /// The FuzzyFunctionDelayTimeToGetBroken is the fuzzy function that gives
   /// the confidence whether the system is Broken because of an input change
   /// without an output change or vice versa. A small time gap between the two
   /// shall be allowed.
   PartFuncPointer FuzzyFunctionTimeSystemMalfunctioning;
 
 public:
   // todo zwei parameter für variablen anzahl
   /// TODO: write description
   SystemStateDetector(
       uint32_t MaximumNumberOfSystemStates, uint32_t NumberOfSignals,
       PartFuncPointer FuzzyFunctionTimeSystemMalfunctioning,
       PartFuncPointer FuzzyFunctionTimeSystemFunctioning) noexcept
       : NumberOfSignals(NumberOfSignals), CurrentSystemState(nullptr),
         DetectedSystemStates(MaximumNumberOfSystemStates), TimeOfDisparity(0),
         FuzzyFunctionTimeSystemFunctioning(FuzzyFunctionTimeSystemFunctioning),
         FuzzyFunctionTimeSystemMalfunctioning(
             FuzzyFunctionTimeSystemMalfunctioning) {
     //@Benedikt: if I write "NextStateID(1), StateHasChanged(false)" before the
     //{}-brackets, the compiler tells me: "SystemStateDetector.hpp:72:9: error:
     // member initializer 'NextStateID'/'StateHasChanged' does not name a
     // non-static data member or base class"
     this->NextStateID = 1;
     this->StateHasChanged = false;
   }
 
   /// Destroys \p this object.
   ~SystemStateDetector(void) = default;
 
   /// TODO: write description
   SystemStateInformation<CONFDATATYPE>
   detectSystemState(std::vector<SignalStateInformation<CONFDATATYPE>>
                         SignalStateInfos) noexcept {
 
     SystemStateInformation<CONFDATATYPE> SystemStateInfo;
 
     if (!CurrentSystemState) {
       ASSERT(DetectedSystemStates.empty());
       SystemStatePtr S = createNewSystemState();
       CurrentSystemState = S;
 
       SystemStateInfo =
           CurrentSystemState->insertSignalStateInformation(SignalStateInfos);
     } else {
 
       SystemStateRelation SysStateRel =
           CurrentSystemState->compareSignalStateInformation(SignalStateInfos);
 
       if (SysStateRel == SystemStateRelation::STATEISMATCHING) {
         TimeOfDisparity = 0;
 
         SystemStateInfo =
             CurrentSystemState->insertSignalStateInformation(SignalStateInfos);
       } else { // ONLYINPUTISMATCHING, ONLYOUTPUTISMATCHING, STATEISMISMATCHING
 
         if (!CurrentSystemState->systemStateInformation().StateIsValid)
           DetectedSystemStates.deleteEntry(CurrentSystemState);
         CurrentSystemState = nullptr;
 
         SystemStatePtr potentialSystemState = nullptr;
 
         // search all saved system states
         for (auto &SavedSystemState : DetectedSystemStates) {
           SysStateRel =
               SavedSystemState->compareSignalStateInformation(SignalStateInfos);
           if (SysStateRel == SystemStateRelation::STATEISMATCHING) {
             CurrentSystemState = SavedSystemState;
             break;
           } else if (SysStateRel == SystemStateRelation::ONLYINPUTISMATCHING ||
                      SysStateRel == SystemStateRelation::ONLYOUTPUTISMATCHING) {
             // TODO: choose best matching
             potentialSystemState = SavedSystemState;
           }
         }
 
         // actions depending whether state is matchin fully or only half
         if (CurrentSystemState) {
           TimeOfDisparity = 0;
 
           SystemStateInfo = CurrentSystemState->insertSignalStateInformation(
               SignalStateInfos);
 
         } else if (potentialSystemState) {
           TimeOfDisparity++;
 
           CurrentSystemState = potentialSystemState;
 
           SystemStateInfo = CurrentSystemState->systemStateInformation();
 
         } else {
           SystemStatePtr S = createNewSystemState();
           TimeOfDisparity = 0;
 
           CurrentSystemState = S;
 
           SystemStateInfo = CurrentSystemState->insertSignalStateInformation(
               SignalStateInfos);
         }
       }
     }
 
     // TODO: is this right? if i don't insert if broke, it will never be valid?!
     // right?
     if (!SystemStateInfo.StateIsValidAfterReentrance) {
       TimeOfDisparity = 0;
     }
 
     // TODO: maybe make reference instead of pointer
     SystemStateInfo.ConfidenceSystemIsFunctioning =
         (*FuzzyFunctionTimeSystemFunctioning)(
             static_cast<INDATATYPE>(TimeOfDisparity));
     SystemStateInfo.ConfidenceSystemIsMalfunctioning =
         (*FuzzyFunctionTimeSystemMalfunctioning)(
             static_cast<INDATATYPE>(TimeOfDisparity));
 
     if (SystemStateInfo.ConfidenceSystemIsMalfunctioning >
         SystemStateInfo.ConfidenceSystemIsFunctioning)
       SystemStateInfo.StateCondition = StateConditions::MALFUNCTIONING;
 
     if (SystemStateInfo.StateCondition == StateConditions::UNKNOWN)
       // TODO: think about a Confidence calculation when system state is unkown
       SystemStateInfo.ConfidenceOfAllDecisions = 0;
     else if (SystemStateInfo.StateCondition == StateConditions::STABLE) {
       //printf("AAAAAAAAAAAAAAAA 10\n");
       SystemStateInfo.ConfidenceOfAllDecisions = fuzzyAND(
           fuzzyOR(
               fuzzyAND(SystemStateInfo.ConfidenceOfInputsMatchingState,
                        SystemStateInfo.ConfidenceOfOutputsMatchingState),
               fuzzyAND(SystemStateInfo.ConfidenceOfInputsMismatchingState,
                        SystemStateInfo.ConfidenceOfOutputsMismatchingState)),
           SystemStateInfo.ConfidenceSystemIsFunctioning,
           SystemStateInfo.ConfidenceStateIsStable,
           SystemStateInfo.ConfidenceStateIsValid);
     } else if (SystemStateInfo.StateCondition == StateConditions::DRIFTING) {
       //printf("AAAAAAAAAAAAAAAA 11\n");
       SystemStateInfo.ConfidenceOfAllDecisions =
           fuzzyAND(SystemStateInfo.ConfidenceOfInputsMatchingState,
                    SystemStateInfo.ConfidenceOfOutputsMatchingState,
                    SystemStateInfo.ConfidenceStateIsDrifting,
                    SystemStateInfo.ConfidenceStateIsValid);
     } else if (SystemStateInfo.StateCondition ==
                StateConditions::MALFUNCTIONING) {
       //printf("AAAAAAAAAAAAAAAA 12\n");
       SystemStateInfo.ConfidenceOfAllDecisions =
           fuzzyAND(SystemStateInfo.ConfidenceOfInputsMismatchingState,
                    SystemStateInfo.ConfidenceOfOutputsMismatchingState,
                    SystemStateInfo.ConfidenceSystemIsMalfunctioning,
                    SystemStateInfo.ConfidenceStateIsValid);
     }
     if (SystemStateInfo.StateJustGotValid) {
       this->NextStateID++;
     }
 
     return SystemStateInfo;
   }
 
 private:
   /// Creates a new system state and adds it to the system state vector in
   /// which
   /// all known states are saved.
   ///
   /// \return a pointer to the newly created signal state or NULL if no state
   /// could be created.
   SystemStatePtr createNewSystemState(void) noexcept {
     SystemStatePtr S(new SystemState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>(
         this->NextStateID, this->NumberOfSignals));
     DetectedSystemStates.addEntry(S);
     return S;
   }
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
diff --git a/lib/agent/SignalState.cpp b/lib/agent/SignalState.cpp
index ec6b7bd..62a2390 100644
--- a/lib/agent/SignalState.cpp
+++ b/lib/agent/SignalState.cpp
@@ -1,20 +1,26 @@
 //===-- rosa/agent/SignalState.cpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SignalState.cpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Implementation for rosa/agent/SignalState.hpp.
 ///
 /// \note Empty implementation, source file here to have a compile database
 ///       entry for rosa/agent/SignalState.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "rosa/agent/SignalState.hpp"
diff --git a/lib/agent/SignalStateDetector.cpp b/lib/agent/SignalStateDetector.cpp
index 3f45910..6678a8c 100644
--- a/lib/agent/SignalStateDetector.cpp
+++ b/lib/agent/SignalStateDetector.cpp
@@ -1,20 +1,26 @@
 //===-- rosa/agent/SignalStateDetector.cpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SignalStateDetector.cpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Implementation for rosa/agent/SignalStateDetector.hpp.
 ///
 /// \note Empty implementation, source file here to have a compile database
 ///       entry for rosa/agent/SignalStateDetector.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "rosa/agent/SignalStateDetector.hpp"
diff --git a/lib/agent/State.cpp b/lib/agent/State.cpp
index c3ae669..7a68700 100644
--- a/lib/agent/State.cpp
+++ b/lib/agent/State.cpp
@@ -1,20 +1,26 @@
 //===-- agent/State.cpp -----------------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file agent/State.cpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Implementation for rosa/agent/State.hpp.
 ///
 /// \note Empty implementation, source file here to have a compile database
 ///       entry for rosa/agent/State.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "rosa/agent/State.hpp"
diff --git a/lib/agent/StateDetector.cpp b/lib/agent/StateDetector.cpp
index 74e2dcb..493f23c 100644
--- a/lib/agent/StateDetector.cpp
+++ b/lib/agent/StateDetector.cpp
@@ -1,20 +1,26 @@
 //===-- agent/StateDetector.cpp -------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file agent/StateDetector.cpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Implementation for rosa/agent/StateDetector.hpp.
 ///
 /// \note Empty implementation, source file here to have a compile database
 ///       entry for rosa/agent/StateDetector.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "rosa/agent/StateDetector.hpp"
diff --git a/lib/agent/SystemState.cpp b/lib/agent/SystemState.cpp
index 86662c2..2bb1abd 100644
--- a/lib/agent/SystemState.cpp
+++ b/lib/agent/SystemState.cpp
@@ -1,20 +1,26 @@
 //===-- rosa/agent/SystemState.cpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SystemState.cpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Implementation for rosa/agent/SystemState.hpp.
 ///
 /// \note Empty implementation, source file here to have a compile database
 ///       entry for rosa/agent/SystemState.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "rosa/agent/SystemState.hpp"
diff --git a/lib/agent/SystemStateDetector.cpp b/lib/agent/SystemStateDetector.cpp
index e5ec9d5..e8d237d 100644
--- a/lib/agent/SystemStateDetector.cpp
+++ b/lib/agent/SystemStateDetector.cpp
@@ -1,20 +1,26 @@
 //===-- rosa/agent/SystemStateDetector.cpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
+// Distributed under the terms and conditions of the Boost Software License 1.0.
+// See accompanying file LICENSE.
+//
+// If you did not receive a copy of the license file, see
+// http://www.boost.org/LICENSE_1_0.txt.
+//
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SystemStateDetector.cpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Implementation for rosa/agent/SystemStateDetector.hpp.
 ///
 /// \note Empty implementation, source file here to have a compile database
 ///       entry for rosa/agent/SystemStateDetector.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "rosa/agent/SystemStateDetector.hpp"