diff --git a/include/rosa/deluxe/DeluxeContext.hpp b/include/rosa/deluxe/DeluxeContext.hpp
index 646e866..730d0ab 100755
--- a/include/rosa/deluxe/DeluxeContext.hpp
+++ b/include/rosa/deluxe/DeluxeContext.hpp
@@ -1,333 +1,358 @@
 //===-- rosa/deluxe/DeluxeContext.hpp ---------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/deluxe/DeluxeContext.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Public interface for the *deluxe interface* for working with agent
 ///        systems.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_DELUXE_DELUXECONTEXT_HPP
 #define ROSA_DELUXE_DELUXECONTEXT_HPP
 
 #include "rosa/deluxe/DeluxeSystem.hpp"
 
 #include "rosa/support/types.hpp"
 
 #include <iterator>
 #include <memory>
 #include <set>
 
 /// Local helper macro to log and return a
 /// \c rosa::deluxe::DeluxeContext::ErrorCode value.
 ///
 /// Creates a debug message with the stringified value and returns the value.
 ///
 /// \param Err \c rosa::deluxe::DeluxeContext::ErrorCode value to log and
 /// return
 #define DCRETERROR(Err)                                                        \
   {                                                                            \
     LOG_DEBUG(#Err);                                                           \
     return Err;                                                                \
   }
 
 namespace rosa {
 namespace deluxe {
 
 /// Defines the *deluxe interface*.
 class DeluxeContext {
 
   /// A system owned by \p this object.
   ///
   /// \note The reference is kept in a \c std::shared_ptr because of the member
   /// function \c rosa::deluxe::DeluxeContext::getSystem.
   std::shared_ptr<DeluxeSystem> System;
 
   /// References to all *sensors* and *agents* created by \p this object.
   std::set<AgentHandle> DeluxeUnits;
 
 public:
 
   /// Errors that may be resulted by some of the member functions of the class.
   enum struct ErrorCode {
     NoError,
     TypeMismatch,
     NotSensor,
     NotAgent,
     WrongPosition,
     AlreadyHasSlave,
     AlreadyHasMaster,
     AlreadyHasValueStream
   };
 
   /// Returns a new instance of \c rosa::deluxe::DeluxeContext.
   ///
   /// \param Name name of the underlying \c rosa::DeluxeSystem
   ///
   /// \return \c std::unique_ptr for the new instance of
   /// \c rosa::deluxe::DeluxeContext with a new, empty \c rosa::DeluxeSystem
   static std::unique_ptr<DeluxeContext>
   create(const std::string &Name) noexcept;
 
 private:
   /// Creates a new instance.
   ///
   /// \note Private constructor restricts instantiation to member functions of
   /// the class.
   ///
   /// \param Name name of the underlying \c rosa::MessagingSystem
   DeluxeContext(const std::string &Name) noexcept;
 
 public:
   /// Destroys \p this object.
   ~DeluxeContext(void) noexcept;
 
   /// Returns a reference for the underlying \c rosa::MessagingSystem.
   ///
   /// \note One cannot do much with a \c rosa::MessagingSystem currently, this
   /// is for future use.
   ///
   /// \return reference for the underlying \c rosa::MessagingSystem.
   std::weak_ptr<MessagingSystem> getSystem(void) const noexcept;
 
   /// Creates a new *sensor* in the context of \p this object.
   ///
   /// \tparam T type of data the new *sensor* operates on
   ///
   /// \todo The current implementation is an intermediate state, handles
   /// built-in types and std::tuple, but the latter with with one element only.
   /// Fix it when merging with DeluxeTuple.
   ///
   /// \param Name name of the new *sensor*
   /// \param F function for the new *sensor* to generate the next value with
   /// during normal operation
   ///
   /// \note \p F is not used during simulation, in which case
   /// \c rosa::deluxe::DeluxeContext::registerSensorValues is used to register
   /// an alternative simulation data source with
   /// \c rosa::deluxe::DeluxeSensor::registerSimulationDataSource. One may
   /// safely keep relying on the default value of \p F as long as only
   /// simulation of the system is to be done.
   ///
   /// \return \c rosa::AgentHandle for the new *sensor*
   template <typename T>
   AgentHandle createSensor(const std::string &Name,
                            DeluxeSensor::D<T> &&F = [](void) {
                              return T();
                            }) noexcept;
 
   /// Creates a new *agent* in the context of \p this object.
   ///
   /// \tparam T type of data the new *agent* outputs
   /// \tparam As types of inputs the new *agent* takes
   ///
   /// \param Name name of the new *agent*
   /// \param F function for the new *agent* to process input values and
   /// generate output with
   ///
   /// \return \c rosa::AgentHandle for the new *agent*
   template <typename T, typename... As>
   AgentHandle createAgent(const std::string &Name,
                           DeluxeAgent::D<T, As...> &&F) noexcept;
 
   /// Connectes a *sensor* to an *agent* in the context of \p this object.
   ///
   /// \param Agent the *agent* to connect to
   /// \param Pos the index of slot of \p Agent to connect \p Sensor to
   /// \param Sensor the *sensor* to connect
   /// \param Description optional textual description of the connection
   ///
   /// \return how successfull connecting \p Sensor to \p Agent at slot index
   /// \p Pos was
   ///
   /// \note The function may return the following
   /// \c rosa::deluxe::DeluxeContext::ErrorCode values:
   /// `ErrorCode`        | Comment
   /// -----------        | -------
   /// `NoError`          | Success
   /// `NotAgent`         | Referred \p Agent is not \c rosa::deluxe::DeluxeAgent
   /// `NotSensor`        | Referred \p Sensor is not \c rosa::deluxe::DeluxeSensor
   /// `WrongPosition`    | \p Pos is not a valid input position of \p Agent
   /// `TypeMismatch`     | Expected input type at position \p Pos of \p Agent is other than the output type of \p Sensor
   /// `AlreadyHasSlave`  | \p Agent at position \p Pos already has a *slave* registered
   /// `AlreadyHasMaster` | \p Sensor already has a *master* registered
   ErrorCode connectSensor(AgentHandle Agent, const size_t Pos,
                           AgentHandle Sensor,
                           const std::string &Description = "") noexcept;
 
   /// Connectes two *agents* in the context of \p this object.
   ///
   /// \param Master the *agent* to connect to
   /// \param Pos the index of slot of \p Master to connect \p Slave to
   /// \param Slave the *agent* to connect
   /// \param Description optional textual description of the connection
   ///
   /// \return how succesfull connecting \p Slave to \p Master at slot index
   /// \p Pos was
   ///
   /// \note The function may return the following
   /// \c rosa::deluxe::DeluxeContext::ErrorCode values:
   /// `ErrorCode`        | Comment
   /// -----------        | -------
   /// `NoError`          | Success
   /// `NotAgent`         | Referred \p Master or \p Slave is not \c rosa::deluxe::DeluxeAgent
   /// `WrongPosition`    | \p Pos is not a valid input position of \p Master
   /// `TypeMismatch`     | Expected input type at position \p Pos of \p Master is other than the output type of \p Slave
   /// `AlreadyHasSlave`  | \p Master at position \p Pos already has a *slave* registered
   /// `AlreadyHasMaster` | \p Slave already has a *master* registered
   ErrorCode connectAgents(AgentHandle Master, const size_t Pos,
                           AgentHandle Slave,
                           const std::string &Description = "") noexcept;
 
   /// Initializes \c this object and others managed by \p this object for
   /// setting up and performing simulation.
   ///
   /// \see \c rosa::deluxe::DeluxeContext::registerSensorValues,
   /// \c rosa::deluxe::DeluxeContext::simulate
   ///
   /// Need to clear simulation data sources from all the *sensors*.
   void initializeSimulation(void) noexcept;
 
   /// Registers a stream providing values for a *sensor* during simulation.
   ///
   /// \tparam Iterator type of iterator providing values for \p Sensor
   /// \tparam T type of values \p Sensor is operating on, always use default!
   ///
   /// \param Sensor the *sensor* to register values for
   /// \param Start provides values for \p Sensor
   /// \param End denotes the end of stream of values
   /// \param Default value to be used when input stream is depleted during
   /// simulation
   ///
   /// \return how successful registering \p Source for \p Sensor
   ///
   /// \note The function may return the following
   /// \c rosa::deluxe::DeluxeContext::ErrorCode values:
   /// `ErrorCode`             | Comment
   /// -----------             | -------
   /// `NoError`               | Success
   /// `TypeMismatch`          | \p Sensor generates values of a type other than \p T
   /// `NotSensor`             | Referred \p Sensor is not \c rosa::deluxe::DeluxeSensor
   /// `AlreadyHasValueStream` | \p Sensor already has simulation data source set
   template <typename Iterator, typename T = typename Iterator::value_type>
   ErrorCode registerSensorValues(AgentHandle Sensor, Iterator &&Start,
                                  const Iterator &End, T Default = {}) noexcept;
 
   /// Performs the system contained by \p this object.
   ///
   /// The function performs \p NumCycles cycle of simulation. In each cycle,
   /// all the *agents* and *sensors* registered in
   /// \c rosa::deluxe::DeluxeContext::DeluxeUnits are trigged for execution.
   ///
   /// \param NumCycles number of cycles to perform
   ///
   /// \pre All the *sensors* in the system contained by \p this object generate
   /// their output from simulation data sources.
   void simulate(const size_t NumCycles) const noexcept;
 };
 
 template <typename T>
 AgentHandle DeluxeContext::createSensor(const std::string &Name,
                                         DeluxeSensor::D<T> &&F) noexcept {
   AgentHandle H = System->createSensor<T>(Name, std::move(F));
   DeluxeUnits.emplace(H);
   return H;
 }
 
 template <typename T, typename... As>
 AgentHandle DeluxeContext::createAgent(const std::string &Name,
                                        DeluxeAgent::D<T, As...> &&F) noexcept {
   AgentHandle H = System->createAgent(Name, std::move(F));
   DeluxeUnits.emplace(H);
   return H;
 }
 
 /// Anonymous namespace for helper facilities, consider it private.
 namespace {
 
-/// \todo Document...
-template <typename T> struct UnwrapSensorType { using Type = T; };
+///\defgroup UnwrapSensorType Type helper for implementing \c
+/// rosa::deluxe::DeluxeContext::registerSensorValue()
+///
+///@{
+
+/// Template declaration.
+///
+/// \tparam T type to obtain matching sensor type for
+///
+/// Obtain a sensor type for a type \p T by: \code
+/// typename UnwrapSensorType<T>::Type
+/// \endcode
+template <typename T> struct UnwrapSensorType;
+
+/// Implementation for the general case.
+template <typename T> struct UnwrapSensorType {
+  /// The type to use is the \p T itself.
+  using Type = T;
+};
 
+/// Template specialization for \c std::tuple.
 template <typename... Ts> struct UnwrapSensorType<std::tuple<Ts...>> {
+  /// The type to use is the type of the first element of the tuple
   using Type = typename std::tuple_element<0, std::tuple<Ts...>>::type;
 };
 
+///@}
+
+/// Convenience template alias to use \c UnwrapSensorType easily.
+template <typename T>
+using sensor_t = typename UnwrapSensorType<T>::Type;
+
 } // End namespace
 
 template <typename Iterator, typename T>
 DeluxeContext::ErrorCode
 DeluxeContext::registerSensorValues(AgentHandle Sensor, Iterator &&Start,
                                     const Iterator &End, T Default) noexcept {
   // Get the type of values provided by \p Iterator.
   STATIC_ASSERT((std::is_same<T, typename Iterator::value_type>::value),
                 "type mismatch");
   constexpr bool isBuiltin = TypeListContains<BuiltinTypes, T>::Value;
   if constexpr (!isBuiltin) {
     // T must be a std::tuple.
     STATIC_ASSERT(std::tuple_size<T>::value == 1, "Wrong tuple type");
     STATIC_ASSERT(
         (TypeListContains<BuiltinTypes,
                           typename std::tuple_element<0, T>::type>::Value),
         "Wrong element type in tuple");
   }
-  using TT = typename UnwrapSensorType<T>::Type;
+  using TT = sensor_t<T>;
 
   // Make sure preconditions are met.
   if (!System->isDeluxeSensor(Sensor)) {
     DCRETERROR(ErrorCode::NotSensor);
   }
   auto S = System->getDeluxeSensor(Sensor);
   ASSERT(S); // Sanity check.
   if (S->OutputType != TypeNumberOf<TT>::Value) {
     DCRETERROR(ErrorCode::TypeMismatch);
   } else if (S->simulationDataSourceIsSet()) {
     DCRETERROR(ErrorCode::AlreadyHasValueStream);
   }
 
   // Register input stream.
   // \note Need to capture parameters by value so having local copies.
   S->registerSimulationDataSource(
       DeluxeSensor::D<TT>([=](void) mutable noexcept {
         if (Start != End) {
           TT Value;
           if constexpr (isBuiltin) {
             Value = *Start;
           } else {
             Value = std::get<0>(*Start);
           }
           ++Start;
           LOG_TRACE_STREAM << "Reading next value for sensor '" << S->FullName
                            << "': " << Value << '\n';
           return Value;
         } else {
           TT Value;
           if constexpr (isBuiltin) {
             Value = Default;
           } else {
             Value = std::get<0>(Default);
           }
           LOG_TRACE_STREAM << "Providing default value for sensor '"
                            << S->FullName << "': " << Value << '\n';
           return Value;
         }
       }));
   return ErrorCode::NoError;
 }
 
 } // End namespace deluxe
 } // End namespace rosa
 
 // Undef local macro if not used in the corresponding implementation.
 #ifndef ROSA_LIB_DELUXE_DELUXECONTEXT_CPP
 #undef DCRETERROR
 #endif
 
 #endif // ROSA_DELUXE_DELUXECONTEXT_HPP
diff --git a/include/rosa/support/csv/CSVReader.hpp b/include/rosa/support/csv/CSVReader.hpp
index 45c6e20..6c707ba 100755
--- a/include/rosa/support/csv/CSVReader.hpp
+++ b/include/rosa/support/csv/CSVReader.hpp
@@ -1,307 +1,314 @@
 //===-- rosa/support/csv/CSVReader.hpp --------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/csv/CSVReader.hpp
 ///
 /// \authors David Juhasz (david.juhasz@tuwien.ac.at), Edwin Willegger (edwin.willegger@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Facitilities to read CSV files.
 ///
 /// \note The implementation is based on the solution at
 /// https://stackoverflow.com/a/1120224
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_CSV_CSVREADER_HPP
 #define ROSA_SUPPORT_CSV_CSVREADER_HPP
 
 #include "rosa/support/debug.hpp"
 #include "rosa/support/sequence.hpp"
 
 #include <istream>
+#include <type_traits>
 #include <sstream>
-#include <vector>
-#include <map>
-#include <algorithm>
-#include <set>
 
 namespace rosa {
 namespace csv {
 
 /// Indicating it the CSV file contains any header or not
 enum class HeaderInformation {
     HasHeader,
     HasNoHeader
 };
 
 /// Anonymous namespace providing implementation details for
 /// \c rosa::csv::CSVIterator, consider it private.
 namespace {
 
+///\defgroup ValueParser Helper template struct to parse a value
+///
+///@{
+
 /// Provides facility for parsing one value from a string.
 ///
 /// \tparam T type of value to parse
 /// \tparam IsSignedInt if \p T is a signed integral type, always use default
 /// \tparam IsUnsignedInt if \p T is an unsigned integral type, always use
 /// default
 /// \tparam IsFloat if \p T is a floating-point type, always use default
 /// \tparam IsString if \p T is \c std::string, always use default
 ///
 /// \note Specializations of this struct are provided for arithmentic types
 /// and \c std::string.
 template <typename T,
           bool IsSignedInt =
               (std::is_integral<T>::value && std::is_signed<T>::value),
           bool IsUnsignedInt =
               (std::is_integral<T>::value && std::is_unsigned<T>::value),
           bool IsFloat = std::is_floating_point<T>::value,
           bool IsString = std::is_same<T, std::string>::value>
 struct ValueParser {
 
-  ///
+  /// Parses one value from \p Cell
   ///
   /// \param Cell the \c std::string to parse
   ///
   /// \return the parsed value
   ///
   /// \note The function silently fails if cannot parse \p Cell for type \p T.
   static T parse(const std::string &Cell) noexcept;
 };
 
+/// Template specialization for signed integral types.
 template <typename T>
 struct ValueParser<T, true, false, false, false> {
   STATIC_ASSERT((std::is_integral<T>::value && std::is_signed<T>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept {
     return static_cast<T>(std::stoll(Cell));
   }
 };
 
+/// Template specialization for unsigned integral types.
 template <typename T>
 struct ValueParser<T, false, true, false, false> {
   STATIC_ASSERT((std::is_integral<T>::value && std::is_unsigned<T>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept {
     return static_cast<T>(std::stoull(Cell));
   }
 };
 
+/// Template specialization for floating-point types.
 template <typename T>
 struct ValueParser<T, false, false, true, false> {
   STATIC_ASSERT((std::is_floating_point<T>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept {
     return static_cast<T>(std::stold(Cell));
   }
 };
 
+/// Template specialization for \c std::string.
 template <typename T>
 struct ValueParser<T, false, false, false, true> {
   STATIC_ASSERT((std::is_same<T, std::string>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept { return Cell; }
 };
 
+///@}
+
 /// Parses and stores entries from a row of CSV data.
 ///
 /// \tparam Ts types of values to parse and store, i.e. entries in the row
 ///
 /// \note The implementation relies on \c rosa::csv::CSVRowParser, which is
 /// implemented only for `arithmetic` types -- signed and unsigned integral
 /// and floating-point types -- and for \c std::string. Those are the valid
 /// values for \p Ts.
 template <typename... Ts> class CSVRow {
 private:
   /// Parses a given row of CSV data into \c CSVRow::Data.
   ///
   /// \ CSVRow::Data is filled with values parsed from \p LineStream. Entries
   /// in the line are to be separated by commas, the character `,`.
   ///
   /// \note Parsed values are silently converted to types \p Ts.
   ///
   /// \note Parsing silently fails if values do not match \p Ts.
   ///
   /// \tparam S0 indices to access tuple elements.
   ///
   /// \param [in,out] LineStream the line to parse
   ///
   /// \note The last argument is used only to get \p S0, the actual value of
   /// the parameter is ignored.
   template <size_t... S0>
   void parseRow(std::stringstream &LineStream, Seq<S0...>) {
     STATIC_ASSERT(sizeof...(Ts) == sizeof...(S0),
                   "Not matching template arguments.");
     std::string Cell;
     // Get fields and parse the values into the proper element of the tuple
     // one by one in a fold expression.
     ((std::getline(LineStream, Cell, ','),
       std::get<S0>(Data) = ValueParser<Ts>::parse(Cell)),
      ...);
   }
 
 public:
   /// Parses and stores one row of CSV data.
   ///
   /// The function reads one line from \p Str and parses it into
   /// \c rosa::csv::CSVRow::Data using \c rosa::csv::CSVRowParser.
   ///
   /// \param [in,out] Str input stream of a CSV file
   void readNextRow(std::istream &Str) {
     std::string Line;
     std::getline(Str, Line);
     std::stringstream LineStream(Line);
     parseRow(LineStream, seq_t<sizeof...(Ts)>());
   }
 
   /// Gives a constant references for the \c std::tuple containing the values
   /// read by \p this object.
   ///
   /// \return \c CSVRow::Data
   const std::tuple<Ts...> &tuple(void) const noexcept { return Data; }
 
 private:
   std::tuple<Ts...> Data; ///< Stores parsed entries
 };
 
 /// Reads a row of CSV data into \c rosa::csv::CSVRow.
 ///
 /// The next line is read from \p Str by calling
 /// \c rosa::csv::CSVRow::readNextRow on \p Data.
 ///
 /// \tparam Ts type of values to read from the row
 ///
 /// \note The CSV file should contain a line with fields matching \p Ts...
 ///
 /// \param [in,out] Str input stream of a CSV file
 /// \param [in,out] Data object to read the next line into
 ///
 /// \return \p Str after reading one line from it
 template <typename... Ts>
 std::istream &operator>>(std::istream &Str, CSVRow<Ts...> &Data) {
   Data.readNextRow(Str);
   return Str;
 }
 
 } // End namespace
 
 /// Provides `InputIterator` features for iterating over a CSV file.
 ///
 /// The iterator parses rows into `std::tuple` values and iterates over the
 /// file row by row.
 ///
 /// \tparam Ts types of values stored in one row of the CSV file
 ///
 /// \note The iterator expects each row to consists of fields matching \p Ts.
 ///
 /// \note The implementation relies on \c rosa::csv::CSVRow, which in turn
 /// relies on \c rosa::csv::CSVRowParser, which is implemented only for
 /// `arithmetic` types -- signed and unsigned integral types and floating-point
 /// types -- and for \c std::string. Those are the valid values for \p Ts
 template <typename... Ts> class CSVIterator {
 public:
   /// \defgroup CSVIteratorTypedefs Typedefs of rosa::csv::CSVIterator
   ///
   /// Standard `typedef`s for iterators.
   ///
   ///@{
   typedef std::input_iterator_tag
       iterator_category;                ///< Category of the iterator.
   typedef std::tuple<Ts...> value_type; ///< Type of values iterated over.
   typedef std::size_t difference_type;  ///< Type to identify distance.
   typedef std::tuple<Ts...> *pointer;   ///< Pointer to the type iterated over.
   typedef std::tuple<Ts...>
       &reference; ///< Reference to the type iterated over.
   ///@}
 
   /// Creates a new instance.
   ///
   /// \param [in,out] S input stream to iterate over
   CSVIterator(std::istream &S) : Str(S.good() ? &S : nullptr), Row() {
     // \c rosa::csv::CSVIterator::Row is initialized empty so the first
     // incrementation here will read the first row.
     ++(*this);
   }
 
   /// Creates an empty new instance.
   CSVIterator(void) noexcept : Str(nullptr) {}
 
   /// Pre-increment operator.
   ///
   /// The implementation reads the next row. If the end of the input stream is
   /// reached, the operator becomes empty and has no further effect.
   ///
   /// \return \p this object after incrementing it.
   CSVIterator &operator++() {
     if (Str) {
       if (!((*Str) >> Row)) {
         Str = nullptr;
       }
     }
     return *this;
   }
 
   /// Post-increment operator.
   ///
   /// The implementation uses the pre-increment operator and returns a copy of
   /// the original state of \p this object.
   ///
   /// \return \p this object before incrementing it.
   CSVIterator operator++(int) {
     CSVIterator Tmp(*this);
     ++(*this);
     return Tmp;
   }
 
   /// Returns a constant reference to the current entry.
   ///
   /// \note Should not dereference the iterator when it is empty.
   ///
   /// \return constant reference to the current entry.
   const std::tuple<Ts...> &operator*(void)const noexcept { return Row.tuple(); }
 
   /// Returns a constant pointer to the current entry.
   ///
   /// \note Should not dereference the iterator when it is empty.
   ///
   /// \return constant pointer to the current entry.
   const std::tuple<Ts...> *operator->(void)const noexcept {
     return &Row.tuple();
   }
 
   /// Tells if \p this object is equal to another one.
   ///
   /// Two \c rosa::csv::CSVReader instances are equal if and only if they are
   /// the same or both are empty.
   ///
   /// \param RHS other object to compare to
   ///
   /// \return whether \p this object is equal with \p RHS
   bool operator==(const CSVIterator &RHS) const noexcept {
     return ((this == &RHS) || ((this->Str == nullptr) && (RHS.Str == nullptr)));
   }
 
   /// Tells if \p this object is not equal to another one.
   ///
   /// \see rosa::csv::CSVReader::operator==
   ///
   /// \param RHS other object to compare to
   ///
   /// \return whether \p this object is not equal with \p RHS.
   bool operator!=(const CSVIterator &RHS) const noexcept {
     return !((*this) == RHS);
   }
 
 private:
   std::istream *Str; ///< Input stream of a CSV file to iterate over.
   CSVRow<Ts...> Row; ///< Content of the current row.
 };
 
 } // End namespace csv
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_CSV_CSVREADER_HPP