diff --git a/include/rosa/core/System.hpp b/include/rosa/core/System.hpp index 38fde7b..7ae02e0 100644 --- a/include/rosa/core/System.hpp +++ b/include/rosa/core/System.hpp @@ -1,134 +1,135 @@ /******************************************************************************* * * File: System.hpp * * Contents: Declaration of System interface. * * Copyright 2017 * * Author: David Juhasz (david.juhasz@tuwien.ac.at) * ******************************************************************************/ #ifndef ROSA_CORE_SYSTEM_HPP #define ROSA_CORE_SYSTEM_HPP #include "rosa/config/config.h" #include "rosa/core/forward_declarations.h" #include "rosa/support/debug.hpp" #include "rosa/support/log.h" +#include #include #include namespace rosa { // Base interface for actual agent-systems, the class provides facilities to // keep track of Units of the system. // NOTE: Any subclasses are supposed to provide thread-safe implementation. // NOTE: The class declares only an interface to avoid trouble with multiple // inheritance in various subclasses as in derived interfaces and derived // implementations. // NOTE: Actual implementations are supposed to derive from SystemBase // implenenting a base feature-set. class System { public: // Signature of creator functions for Units. template using UnitCreator = std::function; // Returns an object implementing the interface defined by the class. static std::unique_ptr createSystem(const std::string &Name) noexcept; protected: // Protected ctor, only subclasses can instantiate. System(void) noexcept = default; // No copy and move. System(const System&) = delete; System(System&&) = delete; System &operator=(const System&) = delete; System &operator=(System&&) = delete; public: // Dtor. // NOTE: Any implementation makes sure that only a cleaned System can be // destroyed. virtual ~System(void) = default; protected: // Tells the next Id to be used for a newly created Unit. // NOTE: Never returs nthe same value twice. virtual id_t nextId(void) noexcept = 0; // Tells if the System has been marked clean and ready for destruction. virtual bool isSystemCleaned(void) const noexcept = 0; // Marks the System cleaned. Can be called only once when the System does not // have any live Units. // PRE: !isSystemCleaned() && empty() // POST: isSystemCleaned() virtual void markCleaned(void) noexcept = 0; // Registers the given Unit instance to the System. // PRE: !isUnitRegistered(U) // POST: isUnitRegistered(U) virtual void registerUnit(Unit &U) noexcept = 0; // Unregisters and destroys the given Unit. // PRE: isUnitRegistered(U) // POST: !isUnitRegistered(U) && 'U is destroyed' virtual void destroyUnit(Unit &U) noexcept = 0; // Returns if the given Unit is registered in the System. virtual bool isUnitRegistered(const Unit &U) const noexcept = 0; // Creates a Unit instance with the given UnitCreator and registers the new // Unit instance // NOTE: The type argument S must be the actual subclass whose instance // creates the Unit. That cannot be statically enforced, it is the // reponsibility of the caller to provide the proper System subclass. // STATIC PRE: // std::is_base_of::value && std::is_base_of::value // PRE: !isSystemCleaned() template T &createUnit(UnitCreator C) noexcept; public: // Tells the textual name of the System. // NOTE: The returned reference remains valid as long as the originating // System is not destroyed. virtual const std::string &name(void) const noexcept = 0; // Returns the number of Units constructed in the System so far, // including those being already destroyed. virtual size_t numberOfConstructedUnits(void) const noexcept = 0; // Returns the number of live Units, that have been constructed and not // destroyed yet. virtual size_t numberOfLiveUnits(void) const noexcept = 0; // Returns if the System has no live Units. virtual bool empty(void) const noexcept = 0; }; template T &System::createUnit(UnitCreator C) noexcept { STATIC_ASSERT((std::is_base_of::value), "not a Unit"); STATIC_ASSERT((std::is_base_of::value), "not a System"); if (isSystemCleaned()) { ROSA_CRITICAL("Trying to create a Unit in a cleaned System (" + name() + ")"); } const id_t Id = nextId(); T *U = C(Id, static_cast(*this)); registerUnit(*U); LOG_TRACE("Unit created and registered (" + U->FullName + ")"); return *U; } } // End namespace rosa #endif // ROSA_CORE_SYSTEM_HPP diff --git a/lib/gen_agent_test2/CSVreaderModule.cpp b/lib/gen_agent_test2/CSVreaderModule.cpp index 83913e9..dc3d41e 100644 --- a/lib/gen_agent_test2/CSVreaderModule.cpp +++ b/lib/gen_agent_test2/CSVreaderModule.cpp @@ -1,155 +1,155 @@ #include "CSVreaderModule.h" -#include +#include #include #define STRINGLENGTH 5000 void CSVreaderModule::initialize_csvreader(FILE *fpointer, unsigned int column, unsigned int start_row) { // fpointer_read = fopen(filepath_read, "r"); // TODO: file ponter schon aus CSV-Reader Creator Funktion übergeben.. dann // kann man nämlich ausgeben, wenn da was nicht erstellt werden kann // bool file_opened = fopen_s(&fpointer_read, filepath_read, "r"); // TODO: etwas mit flag this->fpointer = fpointer; this->row = 1; this->column = column; this->start_row = start_row; flag_csv_reader_configured = true; } CSVreaderModule::CSVreaderModule() { set_name(NO_NAME); flag_csv_reader_configured = false; } CSVreaderModule::CSVreaderModule(const char *name) { set_name(name); flag_csv_reader_configured = false; } CSVreaderModule::CSVreaderModule(FILE *fpointer, unsigned int column, unsigned int start_row) { set_name(NO_NAME); if (fpointer) { initialize_csvreader(fpointer, column, start_row); } else { flag_csv_reader_configured = false; } } CSVreaderModule::CSVreaderModule(const char *name, FILE *fpointer, unsigned int column, unsigned int start_row) { set_name(name); if (fpointer) { initialize_csvreader(fpointer, column, start_row); } else { flag_csv_reader_configured = false; } } /* CSV_Reader :: CSV_Reader(char* name, char* filepath_read, int column, int start_row) { } */ // XXX: Wird nicht mehr benutzt // TODO: überarbeiten nach folgendem Beispiel // https://msdn.microsoft.com/en-us/library/ftsafwz3.aspx bool CSVreaderModule::read_one_row() { if (fpointer) { char readrow[STRINGLENGTH] = "" /*, electedfield[STRINGLENGTH] = ""*/; // TODO: move following for-loop to "initialize_csvreader(...) for (; row < start_row; row++) { if (!fgets(readrow, STRINGLENGTH, fpointer)) return false; } if (fgets(readrow, STRINGLENGTH, fpointer)) { char *ptr; // TODO: make delimiter configurable! ptr = strtok(readrow, ",;"); // OLD: unsigned int dataset_counter = 0; dataset_counter = 0; if (list_of_datasets[dataset_counter] == 1) { data_read[dataset_counter] = std::stof(ptr, NULL); dataset_counter++; } else { ptr = strtok(NULL, ",;"); } for (; dataset_counter < num_of_datasets; dataset_counter++) { for (unsigned int c_ix = list_of_datasets[dataset_counter - 1]; c_ix < list_of_datasets[dataset_counter]; c_ix++) { ptr = strtok(NULL, ",;"); } data_read[dataset_counter] = std::stof(ptr, NULL); } return true; } } return false; } float CSVreaderModule::get_value_of_field(unsigned int field) { // TODO: Bessere Fehlerbehandlung.. also nciht einfach 0 returnen, wenn kein // richtiges FEld!!! if (field < num_of_datasets) { return data_read[field]; } return 0.0; } // TODO: überarbeiten nach folgendem Beispiel // https://msdn.microsoft.com/en-us/library/ftsafwz3.aspx bool CSVreaderModule::read_field() { if (fpointer) { char readrow[STRINGLENGTH] = "" /*, electedfield[STRINGLENGTH] = ""*/; // TODO: move following for-loop to "initialize_csvreader(...) for (; row < start_row; row++) { if (!fgets(readrow, STRINGLENGTH, fpointer)) return false; } if (fgets(readrow, STRINGLENGTH, fpointer)) { char *ptr; // TODO: make delimiter configurable! ptr = strtok(readrow, ",;"); for (unsigned int d_ix = 1; d_ix < column; d_ix++) { ptr = strtok(NULL, ",;"); } input_data = std::stof(ptr, NULL); return true; } } return false; } bool CSVreaderModule::get_next_value(float *value) { if (flag_csv_reader_configured) { if (read_field()) { *value = input_data; return true; } } return false; } // TODO: flag_csv_reader_configured abfragen void CSVreaderModule::close_file() { fclose(fpointer); }