diff --git a/include/rosa/agent/SystemState.hpp b/include/rosa/agent/SystemState.hpp
index 568fdbd..e73c62a 100644
--- a/include/rosa/agent/SystemState.hpp
+++ b/include/rosa/agent/SystemState.hpp
@@ -1,127 +1,146 @@
 //===-- rosa/agent/SystemState.hpp ------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \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/support/debug.hpp"
 
 #include <vector>
 
 namespace rosa {
 namespace agent {
 
 // System state conditions defining how the condition of a \c
 /// rosa::agent::SystemState is saved in \c rosa::agent::SystemStateInformation.
 enum class SystemStateCondition {
   STABLE,         ///< The system state is stable
   DRIFTING,       ///< The system state is drifting
   MALFUNCTIONING, ///< The system state is malfunctioning
   UNKNOWN         ///< The system state is unknown
 };
 
 /// TODO: write description
 template <typename CONFDATATYPE> struct SystemStateInformation {
   // Make sure the actual type arguments are matching our expectations.
   STATIC_ASSERT((std::is_arithmetic<CONFDATATYPE>::value),
                 "confidence type is not to arithmetic");
 
   /// The system state ID saved as an uint32_teger number
   uint32_t SystemStateID;
   /// The SystemStateConfidence shows the overall confidence value of the system
   /// state.
   CONFDATATYPE OverallDetectionConfidence;
   /// The SystemStateCondition shows the condition of a system state (stable,
   /// drifting, malfunctioning, or unknown)
   SystemStateCondition SystemStateCondition;
   /// The SystemStateIsValid saves the number of samples which have been
   /// inserted into the state after entering it.
   uint32_t NumberOfInsertedSamplesAfterEntrance;
   /// The SystemStateIsValid 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 SystemStateIsValid;
   /// The SystemStateJustGotValid shows whether a system state got valid
   /// (toggled from invalid to valid) during the current inserted sample.
   bool SystemStateJustGotValid;
   /// The SystemStateIsValidAfterReentrance shows whether a system state is
   /// valid after the variable changed back to it again.
   bool SystemStateIsValidAfterReentrance;
 };
 
 // todo: do we need PROCDATATYPE?
 /// TODO TEXT
 template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE>
 class SystemState : public Functionality {
 
   // 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:
   SystemStateInformation<CONFDATATYPE> SystemStateInfo;
 
   std::vector<SignalStateInformation<CONFDATATYPE>> Signals;
 
 public:
   /// TODO write
   SystemState(uint32_t SignalStateID, uint32_t NumberOfSignals) noexcept
       : SystemStateInfo{
             SignalStateID, 0,    SystemStateCondition::UNKNOWN, 0, false,
             false,         false} {
     Signals.resize(NumberOfSignals);
   }
 
   /// Destroys \p this object.
   ~SystemState(void) = default;
 
+#if false
   //@Daniel: I try to insert system state infos with these two functions (copied
   //from fuzzyOR) into the vector Signals. However, I do not know how to do
   //that.
   /// TODO: describe
   template <typename CONFDATATYPE, std::size_t size>
   CONFDATATYPE
   insertSignalStateInfos(const std::array<CONFDATATYPE, size> &Data) noexcept {
     STATIC_ASSERT(std::is_arithmetic<CONFDATATYPE>::value,
                   "Type of FuzzyAnd is not arithmetic");
     STATIC_ASSERT(size > 1, "Number of Arguments is to little");
     ASSERT(std::all_of(Data.begin(), Data.end(),
                        [](const auto &v) { return v <= 1 && v >= 0; }));
     return *std::max_element(Data.begin(), Data.end());
   }
   /// TODO: describe
   template <typename CONFDATATYPE, typename... _CONFDATATYPE>
   std::enable_if_t<
       std::conjunction_v<std::is_same<CONFDATATYPE, _CONFDATATYPE>...>,
       CONFDATATYPE>
   insertSignalStateInfos(const CONFDATATYPE Data,
                          const _CONFDATATYPE... Datan) noexcept {
     return insertSignalStateInfos(
         std::array<CONFDATATYPE, sizeof...(Datan) + 1>{Data, Datan...});
   }
+#endif
+
+  template <std::size_t size>
+  void
+  insertSignalStateInfos(const std::array<SystemStateInformation<CONFDATATYPE>,
+                                          size> &Data) noexcept {
+    Signals.insert(Signals.end(), Data.begin(), Data.end());
+  }
+
+  template <typename... Types>
+  std::enable_if_t<std::conjunction_v<std::is_same<
+                       Types, SystemStateInformation<CONFDATATYPE>>...>,
+      void>
+  insertSignalStateInfos(Types... Data) {
+    insertSignalStateInfos(
+        std::array<SystemStateInformation<CONFDATATYPE>, sizeof...(Data)>(
+            {Data...}));
+  }
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_SYSTEMSTATE_HPP