diff --git a/apps/ccam/statehandlerutils.h b/apps/ccam/statehandlerutils.h
index 3542842..332c996 100644
--- a/apps/ccam/statehandlerutils.h
+++ b/apps/ccam/statehandlerutils.h
@@ -1,229 +1,229 @@
 #ifndef STATEHANDLERUTILS_H
 #define STATEHANDLERUTILS_H
 #include "rosa/agent/Abstraction.hpp"
 #include "rosa/agent/Confidence.hpp"
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include <functional>
 #include <iostream>
 #include <tuple>
 #include <vector>
 
 #include "rosa/config/version.h"
 
 #include "rosa/agent/SignalStateDetector.hpp"
 #include "rosa/agent/SystemStateDetector.hpp"
 #include "rosa/app/Application.hpp"
 
 #include "rosa/support/csv/CSVReader.hpp"
 #include "rosa/support/csv/CSVWriter.hpp"
 
 #include <fstream>
 #include <limits>
 #include <memory>
 #include <streambuf>
 using namespace rosa;
 using namespace rosa::agent;
 using namespace rosa::app;
 using namespace rosa::terminal;
 
 // For the convinience to write a shorter data type name
 using SignalStateTuple =
     AppTuple<float, uint32_t, uint8_t, float, float, float, float, float, float,
-             uint8_t, uint32_t, uint8_t>;
+             char, uint32_t, uint8_t>;
 
 AgentHandle createSignalStateDetectorAgent(
     std::unique_ptr<Application> &C, const std::string &Name,
     std::shared_ptr<
         SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>
         SigSD) {
 
   using Input = std::pair<AppTuple<float>, bool>;
 
   using Result = Optional<SignalStateTuple>;
   using Handler = std::function<Result(Input)>;
 
   return C->createAgent(
       Name, Handler([&, Name, SigSD](Input I) -> Result {
         LOG_INFO_STREAM << "\n******\n"
                         << Name << " " << (I.second ? "<New>" : "<Old>")
                         << " value: "
                         << std::get<0>(
                                static_cast<std::tuple<float> &>(I.first))
                         << "\n******\n";
 
         auto StateInfo = SigSD->detectSignalState(
             std::get<0>(static_cast<std::tuple<float> &>(I.first)));
 
         if (I.second) {
           SignalStateTuple Res = {
               std::get<0>(static_cast<std::tuple<float> &>(I.first)),
               StateInfo.StateID,
               StateInfo.SignalProperty,
               StateInfo.ConfidenceOfMatchingState,
               StateInfo.ConfidenceOfMismatchingState,
               StateInfo.ConfidenceStateIsValid,
               StateInfo.ConfidenceStateIsInvalid,
               StateInfo.ConfidenceStateIsStable,
               StateInfo.ConfidenceStateIsDrifting,
               StateInfo.StateCondition,
               StateInfo.NumberOfInsertedSamplesAfterEntrance,
               static_cast<uint8_t>(
                   (StateInfo.StateIsValid ? 4 : 0) +
                   (StateInfo.StateJustGotValid ? 2 : 0) +
                   (StateInfo.StateIsValidAfterReentrance ? 1 : 0))};
 
           return Result(Res);
         }
         return Result();
       }));
 }
 
 // System State
 using SystemStateTuple = AppTuple<std::string>;
 
 template <std::size_t size, typename ret, typename functype, typename... A>
 struct Handler_helper;
 
 template <typename B, typename func, typename A, typename... As>
 struct function_helper {
   static_assert(std::conjunction_v<std::is_same<A, As>...>,
                 "All types need to be identical");
 
   static B function(A valA, As... valAs) {
     std::vector<A> ar({valA, valAs...});
     return func()(ar);
   }
 };
 
 template <typename ret, typename typeA, typename functype, typename... B>
 struct Handler_helper<0, ret, functype, typeA, B...> {
   using handler = function_helper<ret, functype, B...>;
 };
 
 template <std::size_t size, typename ret, typename typeA, typename functype,
           typename... B>
 struct Handler_helper<size, ret, functype, typeA, B...> {
   using handler =
       typename Handler_helper<size - 1, ret, functype, typeA,
                               std::pair<typeA, bool>, B...>::handler;
 };
 
 template <std::size_t size, typename ret, typename functype, typename typeA>
 using Handler = typename Handler_helper<size, ret, functype, typeA>::handler;
 
 // TODO: Change it from global to local variable if possible
 std::shared_ptr<
     SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>>
     SysSD;
 
 template <typename ret, typename A> struct function {
   ret operator()(A a) {
     std::vector<SignalStateInformation<float>> SignalStateInfos;
     std::stringstream OutString;
 
     for (auto _SignalStateTuple : a) {
       // convert tuple to info struct out.push_back({});
       OutString << std::get<0>(_SignalStateTuple.first) << ",";
       SignalStateInformation<float> Info;
       Info.StateID = std::get<1>(_SignalStateTuple.first);
       Info.SignalProperty =
           static_cast<SignalProperties>(std::get<2>(_SignalStateTuple.first));
       Info.ConfidenceOfMatchingState = std::get<3>(_SignalStateTuple.first);
       Info.ConfidenceOfMismatchingState = std::get<4>(_SignalStateTuple.first);
       Info.ConfidenceStateIsValid = std::get<5>(_SignalStateTuple.first);
       Info.ConfidenceStateIsInvalid = std::get<6>(_SignalStateTuple.first);
       Info.ConfidenceStateIsStable = std::get<7>(_SignalStateTuple.first);
       Info.ConfidenceStateIsDrifting = std::get<8>(_SignalStateTuple.first);
       Info.StateCondition =
           static_cast<StateConditions>(std::get<9>(_SignalStateTuple.first));
       Info.NumberOfInsertedSamplesAfterEntrance =
           std::get<10>(_SignalStateTuple.first);
       Info.StateIsValid = (std::get<11>(_SignalStateTuple.first) & 4) > 0;
       Info.StateJustGotValid = (std::get<11>(_SignalStateTuple.first) & 2) > 0;
       Info.StateIsValidAfterReentrance =
           (std::get<11>(_SignalStateTuple.first) & 1) > 0;
       SignalStateInfos.push_back(Info);
     }
     SystemStateInformation<float> SystemStateInfo =
         SysSD->detectSystemState(SignalStateInfos);
 
     OutString << SystemStateInfo.StateID << ",";
     OutString << SystemStateInfo.ConfidenceStateIsValid << ",";
     OutString << SystemStateInfo.ConfidenceStateIsInvalid << ",";
     OutString << SystemStateInfo.ConfidenceOfInputsMatchingState << ",";
     OutString << SystemStateInfo.ConfidenceOfInputsMismatchingState << ",";
     OutString << SystemStateInfo.ConfidenceOfOutputsMatchingState << ",";
     OutString << SystemStateInfo.ConfidenceOfOutputsMismatchingState << ",";
     OutString << SystemStateInfo.StateCondition << ",";
     OutString << SystemStateInfo.ConfidenceSystemIsFunctioning << ",";
     OutString << SystemStateInfo.ConfidenceSystemIsMalfunctioning << ",";
     OutString << SystemStateInfo.ConfidenceOfAllDecisions << ",";
 
     return ret(std::make_tuple<std::string>(OutString.str()));
   }
 };
 
 using arr = std::vector<std::pair<SignalStateTuple, bool>>;
 
 template <size_t NumOfSlaves>
 AgentHandle createSystemStateDetectorAgent(
     std::unique_ptr<Application> &C, const std::string &Name,
     std::shared_ptr<PartialFunction<uint32_t, float>> BrokenDelayFunction,
     std::shared_ptr<PartialFunction<uint32_t, float>> OkDelayFunction) {
   LOG_TRACE("Creating fixed SystemStateDetectorAgent");
   using Input = SignalStateTuple;
   using Result = Optional<SystemStateTuple>;
 
   std::shared_ptr<
       SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>>
       _SysSD(
           new SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>(
               std::numeric_limits<uint32_t>::max(), NumOfSlaves,
               BrokenDelayFunction, OkDelayFunction));
   SysSD = _SysSD;
 
   auto HandlerFunction =
       Handler<NumOfSlaves, Result, function<Optional<SystemStateTuple>, arr>,
               Input>::function;
 
   return C->createAgent(Name, std::function(HandlerFunction));
 }
 
 AgentHandle createSystemStateDetectorAgent(
     std::unique_ptr<Application> &C, const std::string &Name,
     size_t NumOfSlaves,
     std::shared_ptr<PartialFunction<uint32_t, float>> BrokenDelayFunction,
     std::shared_ptr<PartialFunction<uint32_t, float>> OkDelayFunction) {
   LOG_TRACE("Creating dynamic SystemStateDetectorAgent");
   switch (NumOfSlaves) {
   // clang-format off
   case  2: return createSystemStateDetectorAgent< 2>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  3: return createSystemStateDetectorAgent< 3>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  4: return createSystemStateDetectorAgent< 4>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  5: return createSystemStateDetectorAgent< 5>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  6: return createSystemStateDetectorAgent< 6>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  7: return createSystemStateDetectorAgent< 7>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  8: return createSystemStateDetectorAgent< 8>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  9: return createSystemStateDetectorAgent< 9>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 10: return createSystemStateDetectorAgent<10>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 11: return createSystemStateDetectorAgent<11>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 12: return createSystemStateDetectorAgent<12>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 13: return createSystemStateDetectorAgent<13>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 14: return createSystemStateDetectorAgent<14>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 15: return createSystemStateDetectorAgent<15>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 16: return createSystemStateDetectorAgent<16>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 17: return createSystemStateDetectorAgent<17>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 18: return createSystemStateDetectorAgent<18>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 19: return createSystemStateDetectorAgent<19>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 20: return createSystemStateDetectorAgent<20>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 21: return createSystemStateDetectorAgent<21>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 22: return createSystemStateDetectorAgent<22>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 23: return createSystemStateDetectorAgent<23>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 24: return createSystemStateDetectorAgent<24>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 25: return createSystemStateDetectorAgent<25>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 1:
   default: return createSystemStateDetectorAgent<1>(C, Name, BrokenDelayFunction, OkDelayFunction);
     // clang-format on
   }
 }
 #endif // STATEHANDLERUTILS_H
diff --git a/include/rosa/agent/State.hpp b/include/rosa/agent/State.hpp
index 0a1abd4..cd29062 100644
--- a/include/rosa/agent/State.hpp
+++ b/include/rosa/agent/State.hpp
@@ -1,93 +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
+enum StateConditions : char {
+  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