diff --git a/examples/agent-modules/agent-modules.cpp b/examples/agent-modules/agent-modules.cpp index d50ad83..18fee82 100644 --- a/examples/agent-modules/agent-modules.cpp +++ b/examples/agent-modules/agent-modules.cpp @@ -1,111 +1,109 @@ //===-- examples/agent-modules/agent-modules.cpp ----------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file examples/agent-modules/agent-modules.cpp /// /// \author David Juhasz (david.juhasz@tuwien.ac.at) /// /// \date 2017 /// /// \brief A simple example on defining \c rosa::Agent instances using /// \c rosa::agent::Module object as components. /// //===----------------------------------------------------------------------===// #include "rosa/agent/Abstraction.hpp" #include "rosa/agent/Confidence.hpp" #include "rosa/config/version.h" #include "rosa/core/Agent.hpp" #include "rosa/core/MessagingSystem.hpp" #include "rosa/support/log.h" #include "rosa/support/terminal_colors.h" #include #include using namespace rosa; using namespace rosa::agent; using namespace rosa::terminal; /// A dummy wrapper for testing \c rosa::MessagingSystem. /// /// \note Since we test \c rosa::MessagingSystem directly here, we need to get /// access to its protected members. That we do by imitating to be a decent /// subclass of \c rosa::MessagingSystem, while calling protected member /// functions on an object of a type from which we actually don't inherit. struct SystemTester : protected MessagingSystem { template static AgentHandle createMyAgent(MessagingSystem *S, const std::string &Name, Funs &&... Fs) { return ((SystemTester *)S)->createAgent(Name, std::move(Fs)...); } static void destroyMyAgent(MessagingSystem *S, const AgentHandle &H) { ((SystemTester *)S)->destroyUnit(unwrapAgent(H)); } }; /// A special \c rosa::Agent with its own state. class MyAgent : public Agent { public: using Tick = AtomConstant; private: enum class Categories { Bad, Normal, Good }; static const std::map CategoryNames; History H; Confidence C; RangeAbstraction A; public: void handler(Tick, uint8_t V) noexcept { // Record \p V to the \c rosa::agent::History, then print state info. H << V; ASSERT(H.entry() == V); // Sanity check. - LOG_INFO_STREAM << std::endl - << "Next value: " << PRINTABLE(V) + LOG_INFO_STREAM << "\nNext value: " << PRINTABLE(V) << ", confidence: " << C(H) - << ", category: " << CategoryNames.at(A(H.entry())) - << std::endl; + << ", category: " << CategoryNames.at(A(H.entry())) << '\n'; } MyAgent(const AtomValue Kind, const rosa::id_t Id, const std::string &Name, MessagingSystem &S) : Agent(Kind, Id, Name, S, THISMEMBER(handler)), H(), C(5, 20, 1), A({{{10, 14}, Categories::Normal}, {{15, 17}, Categories::Good}, {{18, 19}, Categories::Normal}}, Categories::Bad) {} }; const std::map MyAgent::CategoryNames{ {Categories::Bad, "Bad"}, {Categories::Normal, "Normal"}, {Categories::Good, "Good"}}; int main(void) { LOG_INFO_STREAM << library_string() << " -- " << Color::Red - << "agent-modules example" << Color::Default << std::endl; + << "agent-modules example" << Color::Default << '\n'; std::unique_ptr S = MessagingSystem::createSystem("Sys"); MessagingSystem *SP = S.get(); AgentHandle A = SystemTester::createMyAgent(SP, "MyAgent"); std::vector Vs{4, 5, 6, 7, 9, 10, 11, 13, 15, 14, 15, 16, 19, 20, 21}; for (auto I = Vs.begin(); I != Vs.end(); ++I) { A.send(MyAgent::Tick::Value, *I); } SystemTester::destroyMyAgent(SP, A); return 0; } diff --git a/examples/basic-system/basic-system.cpp b/examples/basic-system/basic-system.cpp index 4adc37e..ef5731e 100644 --- a/examples/basic-system/basic-system.cpp +++ b/examples/basic-system/basic-system.cpp @@ -1,72 +1,72 @@ //===-- examples/basic-system/basic-system.cpp ------------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file examples/basic-system/basic-system.cpp /// /// \author David Juhasz (david.juhasz@tuwien.ac.at) /// /// \date 2017 /// /// \brief A simple example on the basic \c rosa::System and \c rosa::Unit /// classes. /// //===----------------------------------------------------------------------===// #include "rosa/config/version.h" #include "rosa/core/System.hpp" #include "rosa/core/Unit.h" #include "rosa/support/log.h" #include "rosa/support/terminal_colors.h" #include using namespace rosa; using namespace rosa::terminal; /// A dummy wrapper for testing \c rosa::System. /// /// \note Since we test \c rosa::System directly here, we need to get access to /// its protected members. That we do by imitating to be a decent subclass of /// \c rosa::System, while calling protected member functions on an object of a /// type from which we actually don't inherit. struct SystemTester : protected System { static constexpr AtomValue UnitKind = atom("unit"); static Unit &createMyUnit(System *S, const std::string &Name = std::string()) { return ((SystemTester *)S) ->createUnit([&Name](const rosa::id_t Id, System &S) noexcept { const std::string N( Name.empty() ? "Unit_" + std::to_string(S.numberOfConstructedUnits()) : Name); return new Unit(UnitKind, Id, N, S); }); } static void destroyMyUnit(System *S, Unit &U) { ((SystemTester *)S)->destroyUnit(U); } }; int main(void) { LOG_INFO_STREAM << library_string() << " -- " << Color::Red - << "basic-system example" << Color::Default << std::endl; + << "basic-system example" << Color::Default << '\n'; std::unique_ptr S = System::createSystem("Sys"); System *SP = S.get(); Unit &Unit1 = SystemTester::createMyUnit(SP), &Unit2 = SystemTester::createMyUnit(SP, "Second"), &Unit3 = SystemTester::createMyUnit(SP); SystemTester::destroyMyUnit(SP, Unit1); SystemTester::destroyMyUnit(SP, Unit3); - LOG_INFO_STREAM << "Dumping Unit2" << std::endl << Unit2 << std::endl; + LOG_INFO_STREAM << "Dumping Unit2\n" << Unit2 << '\n'; SystemTester::destroyMyUnit(SP, Unit2); return 0; } diff --git a/examples/messaging-system/messaging-system.cpp b/examples/messaging-system/messaging-system.cpp index d3843dd..ea4b2b4 100644 --- a/examples/messaging-system/messaging-system.cpp +++ b/examples/messaging-system/messaging-system.cpp @@ -1,146 +1,138 @@ //===-- examples/messaging-system/messaging-system.cpp ----------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file examples/messaging-system/messaging-system.cpp /// /// \author David Juhasz (david.juhasz@tuwien.ac.at) /// /// \date 2017 /// /// \brief A simple example on the \c rosa::MessagingSystem and \c rosa::Agent /// classes. //===----------------------------------------------------------------------===// #include "rosa/config/version.h" #include "rosa/core/Agent.hpp" #include "rosa/core/MessagingSystem.hpp" #include "rosa/support/log.h" #include "rosa/support/terminal_colors.h" #include using namespace rosa; using namespace rosa::terminal; /// A dummy wrapper for testing \c rosa::MessagingSystem. /// /// \note Since we test \c rosa::MessagingSystem directly here, we need to get /// access to its protected members. That we do by imitating to be a decent /// subclass of \c rosa::MessagingSystem, while calling protected member /// functions on an object of a type from which we actually don't inherit. struct SystemTester : protected MessagingSystem { template static AgentHandle createMyAgent(MessagingSystem *S, const std::string &Name, Funs &&... Fs) { return ((SystemTester *)S)->createAgent(Name, std::move(Fs)...); } static void destroyMyAgent(MessagingSystem *S, const AgentHandle &H) { ((SystemTester *)S)->destroyUnit(unwrapAgent(H)); } }; /// A special \c rosa::Agent subclass with its own state. class MyAgent : public Agent { public: using Tick = AtomConstant; using Report = AtomConstant; private: size_t Counter; public: void handler(Tick) noexcept { - LOG_INFO_STREAM << "MyAgent Tick count: " << ++Counter << std::endl; + LOG_INFO_STREAM << "MyAgent Tick count: " << ++Counter << '\n'; } MyAgent(const AtomValue Kind, const rosa::id_t Id, const std::string &Name, MessagingSystem &S) : Agent(Kind, Id, Name, S, Invoker::F([this](Report) noexcept { - LOG_INFO_STREAM << "MyAgent count: " << Counter << std::endl; + LOG_INFO_STREAM << "MyAgent count: " << Counter << '\n'; }), THISMEMBER(handler)), Counter(0) {} }; int main(void) { LOG_INFO_STREAM << library_string() << " -- " << Color::Red - << "messaging-system example" << Color::Default << std::endl; + << "messaging-system example" << Color::Default << '\n'; std::unique_ptr S = MessagingSystem::createSystem("Sys"); MessagingSystem *SP = S.get(); - LOG_INFO_STREAM << std::endl - << std::endl - << "** Stateless Agents" << std::endl - << std::endl; + LOG_INFO_STREAM << "\n\n** Stateless Agents\n\n"; AgentHandle Agent1 = SystemTester::createMyAgent( SP, "Agent1", Invoker::F([](const std::string &M) noexcept { LOG_INFO("Agent1: " + M); })); using Print = AtomConstant; using Forward = AtomConstant; AgentHandle Agent2 = SystemTester::createMyAgent( SP, "Agent2", Invoker::F([](Print, uint8_t N) noexcept { LOG_INFO("Agent2: " + std::to_string(N)); }), Invoker::F([&Agent1](Forward, uint8_t N) noexcept { if (Agent1) { Agent1.send(std::to_string(N)); } else { LOG_INFO("Agent2 cannot forward: Agent1 is not valid"); } })); - LOG_INFO_STREAM << std::endl - << "Agent1 is valid: " << bool(Agent1) << std::endl - << "Agent2 is valid: " << bool(Agent2) << std::endl; + LOG_INFO_STREAM << "\nAgent1 is valid: " << bool(Agent1) + << "\nAgent2 is valid: " << bool(Agent2) << '\n'; LOG_INFO("Sending a print-message to Agent2..."); SP->send(Agent2, Print::Value, 42); LOG_INFO("Sending a forward-message to Agent2..."); SP->send(Agent2, Forward::Value, 42); LOG_INFO("Sending an unexpected message to Agent2..."); SP->send(Agent2, unit); SystemTester::destroyMyAgent(SP, Agent1); - LOG_INFO_STREAM << std::endl - << "Agent1 is valid: " << bool(Agent1) << std::endl - << "Agent2 is valid: " << bool(Agent2) << std::endl; + LOG_INFO_STREAM << "\nAgent1 is valid: " << bool(Agent1) + << "\nAgent2 is valid: " << bool(Agent2) << '\n'; LOG_INFO("Sending a forward-message to Agent2..."); SP->send(Agent2, Forward::Value, 42); SystemTester::destroyMyAgent(SP, Agent2); - LOG_INFO_STREAM << std::endl - << std::endl - << "** Stateful Agents" << std::endl - << std::endl; + LOG_INFO_STREAM << "\n\n** Stateful Agents\n\n"; AgentHandle Agent3 = SystemTester::createMyAgent(SP, "Agent3"); for (size_t I = 0; I < 2; ++I) { LOG_INFO("Sending report-message to Agent3..."); Agent3.send(MyAgent::Report::Value); LOG_INFO("Sending tick-message to Agent3..."); Agent3.send(MyAgent::Tick::Value); } SystemTester::destroyMyAgent(SP, Agent3); - LOG_INFO_STREAM << std::endl << std::endl; + LOG_INFO_STREAM << "\n\n"; return 0; } diff --git a/examples/messaging/messaging.cpp b/examples/messaging/messaging.cpp index e40e55e..48dba36 100644 --- a/examples/messaging/messaging.cpp +++ b/examples/messaging/messaging.cpp @@ -1,146 +1,128 @@ //===-- examples/messaging/messaging.cpp ------------------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file examples/messaging/messaging.cpp /// /// \author David Juhasz (david.juhasz@tuwien.ac.at) /// /// \date 2017 /// /// \brief An example showcasing features related to the \c rosa::Message class. /// //===----------------------------------------------------------------------===// #include "rosa/config/version.h" #include "rosa/core/MessageHandler.hpp" #include "rosa/support/log.h" #include "rosa/support/terminal_colors.h" #include using namespace rosa; using namespace rosa::terminal; int main(void) { LOG_INFO_STREAM << library_string() << " -- " << Color::Red << "messaging" - << Color::Default << std::endl; + << Color::Default << '\n'; - auto &Log = LOG_INFO_STREAM << std::endl; + auto &Log = LOG_INFO_STREAM << '\n'; // Message interface. auto PMsg = Message::create(1, 2); auto &Msg = *PMsg; Log << "Checking on a 'Message with TypeList<>':" - << std::endl - << " Size: " << Msg.Size << std::endl - << " Pos 0 is uint8_t: " << Msg.isTypeAt(0) << std::endl - << " Pos 1 is uint16_t: " << Msg.isTypeAt(1) << std::endl - << " Pos 2 is uint32_t: " << Msg.isTypeAt(1) << std::endl - << " Value at pos 0: " << PRINTABLE(Msg.valueAt(0)) << std::endl - << " Value at pos 1: " << Msg.valueAt(1) << std::endl - << std::endl; + << "\n Size: " << Msg.Size + << "\n Pos 0 is uint8_t: " << Msg.isTypeAt(0) + << "\n Pos 1 is uint16_t: " << Msg.isTypeAt(1) + << "\n Pos 2 is uint32_t: " << Msg.isTypeAt(1) + << "\n Value at pos 0: " << PRINTABLE(Msg.valueAt(0)) + << "\n Value at pos 1: " << Msg.valueAt(1) << "\n\n"; // MessageMatcher. using MyMatcher = MsgMatcher; - Log << "Matching against 'TypeList':" << std::endl - << " matching: " << MyMatcher::doesStronglyMatch(Msg) << std::endl; + Log << "Matching against 'TypeList':" + << "\n matching: " << MyMatcher::doesStronglyMatch(Msg); auto Vs = MyMatcher::extractedValues(Msg); - Log << " value: '(" << PRINTABLE(std::get<0>(Vs)) << ", " << std::get<1>(Vs) - << ")'" << std::endl - << std::endl; + Log << "\n value: '(" << PRINTABLE(std::get<0>(Vs)) << ", " + << std::get<1>(Vs) << ")'\n\n"; using MyWrongMatcher = MsgMatcher; - Log << "Matching against 'TypeList':" << std::endl - << " matching: " << MyWrongMatcher::doesStronglyMatch(Msg) << std::endl - << std::endl; + Log << "Matching against 'TypeList':" + << "\n matching: " << MyWrongMatcher::doesStronglyMatch(Msg) << "\n\n"; using MyAtom = AtomConstant; const MyAtom &A = MyAtom::Value; using MyNAtom = AtomConstant; auto PAMsg = Message::create(A); auto &AMsg = *PAMsg; Log << "Checking on a 'Message with TypeList>':" - << std::endl - << " Size: " << AMsg.Size << std::endl - << " Pos 0 is 'AtomValue': " << AMsg.isTypeAt(0) << std::endl - << " Pos 0 is 'AtomConstant': " - << AMsg.isTypeAt(0) << std::endl - << std::endl; + << "\n Size: " << AMsg.Size + << "\n Pos 0 is 'AtomValue': " << AMsg.isTypeAt(0) + << "\n Pos 0 is 'AtomConstant': " + << AMsg.isTypeAt(0) << "\n\n"; using MyAtomMatcher = MsgMatcher; Log << "Matching against 'TypeList>':" - << std::endl - << " matching: " << MyAtomMatcher::doesStronglyMatch(AMsg) << std::endl - << " value: '(" + << "\n matching: " << MyAtomMatcher::doesStronglyMatch(AMsg) + << "\n value: '(" << to_string(std::get<0>(MyAtomMatcher::extractedValues(AMsg))) << ")'" - << std::endl - << std::endl; + << "\n\n"; using MyWrongAtomMatcher = MsgMatcher; Log << "Matching against 'TypeList>':" - << std::endl - << " matching: " << MyWrongAtomMatcher::doesStronglyMatch(AMsg) - << std::endl - << std::endl; + << "\n matching: " << MyWrongAtomMatcher::doesStronglyMatch(AMsg) + << "\n\n"; // Invoker. auto IP = Invoker::wrap(Invoker::F([&Log](MyAtom) noexcept->void { - Log << "** Handling 'Message with TypeList>'." - << std::endl; + Log << "** Handling 'Message with " + "TypeList>'.\n"; })); auto &I = *IP; // Get a reference from the pointer. Log << "Invoking a function of signature 'void(AtomConstant) " "noexcept':" - << std::endl - << " with 'Message with TypeList'" << std::endl - << " does Message match Invoker: " << I.match(Msg) << std::endl - << " invoking..." << std::endl; + << "\n with 'Message with TypeList'" + << "\n does Message match Invoker: " << I.match(Msg) + << "\n invoking..."; I(Msg); - Log << " with 'Message with TypeList>'..." - << std::endl - << " does Message match Invoker: " << I.match(AMsg) << std::endl - << " invoking..." << std::endl; + Log << "\n with 'Message with TypeList>'..." + << "\n does Message match Invoker: " << I.match(AMsg) + << "\n invoking..."; I(AMsg); - Log << std::endl; + Log << "\n\n"; // MessageHandler. MessageHandler Handler{ Invoker::F([&Log](uint8_t, uint16_t) { - Log << "** Handling 'Message with TypeList'" - << std::endl; + Log << "** Handling 'Message with TypeList'\n"; }), Invoker::F([&Log](MyAtom) { Log << "** Handling 'Message with " - "TypeList>'" - << std::endl; + "TypeList>'\n"; })}; auto PANMsg = Message::create(MyNAtom::Value); auto &ANMsg = *PANMsg; Log << "Handling Messages with 'MessageHandler " "{ Invoker::F, " "Invoker::F> }':" - << std::endl - << " 'Message with TypeList'" << std::endl - << " can handle: " << Handler.canHandle(Msg) << std::endl - << " handling..." << std::endl; + << "\n 'Message with TypeList'" + << "\n can handle: " << Handler.canHandle(Msg) << "\n handling..."; Handler(Msg); - Log << " 'Message with TypeList>'" << std::endl - << " can handle: " << Handler.canHandle(AMsg) << std::endl - << " handling..." << std::endl; + Log << "\n 'Message with TypeList>'" + << "\n can handle: " << Handler.canHandle(AMsg) << "\n handling..."; Handler(AMsg); - Log << " 'Message with TypeList>'" - << std::endl - << " can handle: " << Handler.canHandle(ANMsg) << std::endl - << " handling..." << std::endl; + Log << "\n 'Message with TypeList>'" + << "\n can handle: " << Handler.canHandle(ANMsg) + << "\n handling..."; Handler(ANMsg); - Log << std::endl; + Log << "\n\n"; - Log << "Terminating, destroying automatic variables." << std::endl; + Log << "Terminating, destroying automatic variables.\n"; return 0; } diff --git a/examples/type-facilities/type-facilities.cpp b/examples/type-facilities/type-facilities.cpp index 731c276..44b7379 100644 --- a/examples/type-facilities/type-facilities.cpp +++ b/examples/type-facilities/type-facilities.cpp @@ -1,100 +1,90 @@ //===-- examples/type-facilities/type-facilities.cpp ------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file examples/type-facilities/type-facilities.cpp /// /// \author David Juhasz (david.juhasz@tuwien.ac.at) /// /// \date 2017 /// /// \brief An example showcasing various type-related support facilities. /// //===----------------------------------------------------------------------===// #include "rosa/config/version.h" #include "rosa/support/log.h" #include "rosa/support/terminal_colors.h" #include "rosa/support/type_token.hpp" #include using namespace rosa; using namespace rosa::terminal; int main(void) { LOG_INFO_STREAM << library_string() << " -- " << Color::Red - << "type facilities" << Color::Default << std::endl; + << "type facilities" << Color::Default << '\n'; - auto &Log = LOG_TRACE_STREAM << std::endl; - Log << "NumberOfBuiltinTypes: " << NumberOfBuiltinTypes << std::endl - << "TokenBits: " << token::TokenBits << std::endl - << "RepresentationBits: " << token::RepresentationBits << std::endl - << "MaxTokenizableListSize: " << token::MaxTokenizableListSize - << std::endl - << std::endl; + auto &Log = LOG_TRACE_STREAM; + Log << "\nNumberOfBuiltinTypes: " << NumberOfBuiltinTypes + << "\nTokenBits: " << token::TokenBits + << "\nRepresentationBits: " << token::RepresentationBits + << "\nMaxTokenizableListSize: " << token::MaxTokenizableListSize + << "\n\n"; - Log << "Type number information on 'uint8_t':" << std::endl; + Log << "Type number information on 'uint8_t':"; constexpr TypeNumber TN = TypeNumberOf::Value; - Log << " type number: " << PRINTABLE_TN(TN) << std::endl - << " size: " << TypeForNumber::Size << std::endl - << " name: " << TypeForNumber::Name << std::endl - << std::endl; + Log << "\n type number: " << PRINTABLE_TN(TN) + << "\n size: " << TypeForNumber::Size + << "\n name: " << TypeForNumber::Name << "\n\n"; - Log << "Type number information on 'std::string':" << std::endl; + Log << "Type number information on 'std::string':"; constexpr TypeNumber TNS = TypeNumberOf::Value; - Log << " type number: " << PRINTABLE_TN(TNS) << std::endl - << " size: " << TypeForNumber::Size << std::endl - << " name: " << TypeForNumber::Name << std::endl - << std::endl; + Log << "\n type number: " << PRINTABLE_TN(TNS) + << "\n size: " << TypeForNumber::Size + << "\n name: " << TypeForNumber::Name << "\n\n"; - Log << "Type number information of AtomConstants:" << std::endl; + Log << "Type number information of AtomConstants:"; using Atom1 = AtomConstant; using Atom2 = AtomConstant; - Log << " std::is_same::value: " - << std::is_same::value << std::endl - << " TypeNumberOf::Value: " - << PRINTABLE_TN(TypeNumberOf::Value) << std::endl - << " TypeNumberOf::Value: " - << PRINTABLE_TN(TypeNumberOf::Value) << std::endl - << " name: " << TypeForNumber::Value>::Name - << std::endl - << std::endl; + Log << "\n std::is_same::value: " + << std::is_same::value << "\n TypeNumberOf::Value: " + << PRINTABLE_TN(TypeNumberOf::Value) + << "\n TypeNumberOf::Value: " + << PRINTABLE_TN(TypeNumberOf::Value) + << "\n name: " << TypeForNumber::Value>::Name + << "\n\n"; - Log << "Type token information on 'TypeList':" - << std::endl; + Log << "Type token information on 'TypeList':"; // \c rosa::Token is generated statically. constexpr Token T = TypeToken::Value; STATIC_ASSERT( (T == TypeListToken>::Value), "alias template definition is wrong"); Token T_ = T; // We need a non-const value for dropping head later. // Iterate over encoded entries in \c T_. while (!emptyToken(T_)) { - Log << " token: " << PRINTABLE_TOKEN(T_) << std::endl - << " valid: " << validToken(T_) << std::endl - << " empty: " << emptyToken(T_) << std::endl - << " length: " << lengthOfToken(T_) << std::endl - << " full size: " << sizeOfValuesOfToken(T_) << std::endl - << " head type number: " << PRINTABLE_TN(typeNumberOfHeadOfToken(T_)) - << std::endl - << " size of head: " << sizeOfHeadOfToken(T_) << std::endl - << " name of head: " << nameOfHeadOfToken(T_) << std::endl - << " is head uint8_t: " << isHeadOfTokenTheSameType(T_) - << std::endl - << " is head uint16_t: " << isHeadOfTokenTheSameType(T_) - << std::endl - << " is head std::string: " - << isHeadOfTokenTheSameType(T_) << std::endl - << "Dropping head..." << std::endl; + Log << "\n token: " << PRINTABLE_TOKEN(T_) + << "\n valid: " << validToken(T_) << "\n empty: " << emptyToken(T_) + << "\n length: " << lengthOfToken(T_) + << "\n full size: " << sizeOfValuesOfToken(T_) + << "\n head type number: " << PRINTABLE_TN(typeNumberOfHeadOfToken(T_)) + << "\n size of head: " << sizeOfHeadOfToken(T_) + << "\n name of head: " << nameOfHeadOfToken(T_) + << "\n is head uint8_t: " << isHeadOfTokenTheSameType(T_) + << "\n is head uint16_t: " << isHeadOfTokenTheSameType(T_) + << "\n is head std::string: " + << isHeadOfTokenTheSameType(T_) << "\nDropping head..."; dropHeadOfToken(T_); } // Here when Token became empty. - Log << " token: " << PRINTABLE_TOKEN(T_) << std::endl - << " empty: " << emptyToken(T_) << std::endl; + Log << "\n token: " << PRINTABLE_TOKEN(T_) << "\n empty: " << emptyToken(T_) + << '\n'; return 0; } diff --git a/include/rosa/support/log.h b/include/rosa/support/log.h index 1ed7b02..4dded39 100644 --- a/include/rosa/support/log.h +++ b/include/rosa/support/log.h @@ -1,259 +1,259 @@ //===-- rosa/support/log.h --------------------------------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file rosa/support/log.h /// /// \author David Juhasz (david.juhasz@tuwien.ac.at) /// /// \date 2017 /// /// \brief Facility for logging. /// /// \note One call for the various logging macros is supposed to be used /// for registering one log entry. That goes natural with the non-stream /// implementations, which accept one string as argument. A more flexible way /// for printing log entries, for example for colorizing text, is to use macros /// providing a log stream. It is important to note, however, that the stream /// obtained from one macro evaluation fits for printing one log entry, without /// nested/overlapping log entry emissions and the entry being closed with a /// newline. Should this simple recommendation not being followed, the result /// becomes hard to read due to missing line breaks and overlapping entries. /// /// \todo Thread-safety is another issue, which need to be addressed for proper /// logging. /// //===----------------------------------------------------------------------===// #ifndef ROSA_SUPPORT_LOG_H #define ROSA_SUPPORT_LOG_H #include "rosa/config/config.h" #include "rosa/support/terminal_colors.h" #include #include /* **************************************************************************** * Log Levels * * ****************************************************************************/ namespace rosa { /// Type-safe definition of log levels, use this in code. /// \note Keep values in sync with the corresponding preprocessor definitions. enum class LogLevel { Error, ///< Log errors only Warning, ///< Like \c rosa::LogLevel::Error and also log warnings Info, ///< Like \c rosa::LogLevel::Warning and also log general infos Debug, ///< Like \c rosa::LogLevel::Info and also log debug infos Trace, ///< Like \c rosa::LogLevel::Debug and also log trace infos NumLogLevels ///< Number of log levels }; /// Converts a \c rosa::LogLevel to its textual representation. /// /// \param logLevel \c rosa::LogLevel to convert /// /// \return \c std::string representing \p logLevel /// /// \pre `logLevel` is valid:\code /// logLevel != LogLevel::NumLogLevels /// \endcode std::string logLevelToString(const LogLevel logLevel); /// Prints colorized tag for the given \c rosa::LogLevel. /// /// \param [in,out] OS \c std::ostream to print to /// \param logLevel \c rosa::LogLevel to print tag for /// /// \return \p OS after printing a tag for \p logLevel /// /// \pre \p logLevel is valid:\code /// logLevel != LogLevel::NumLogLevels /// \endcode std::ostream &operator<<(std::ostream &OS, const LogLevel logLevel); } // End namespace rosa /// \name Valid log level constants /// \note Only for preprocessor definitions in this file. /// \note Keep the defintions in sync with the values of \c rosa::LogLevel. ///@{ #define ROSA_LOG_LEVEL_ERROR \ 0 ///< Value corresponding to \c rosa::LogLevel::Error #define ROSA_LOG_LEVEL_WARNING \ 1 ///< Value corresponding to \c rosa::LogLevel::Warning #define ROSA_LOG_LEVEL_INFO \ 2 ///< Value corresponding to \c rosa::LogLevel::Info #define ROSA_LOG_LEVEL_DEBUG \ 3 ///< Value corresponding to \c rosa::LogLevel::Debug #define ROSA_LOG_LEVEL_TRACE \ 4 ///< Value corresponding to \c rosa::LogLevel::Trace ///@} /* **************************************************************************** * Logger Implementation * * ****************************************************************************/ /// Stream to print logs to /// /// \todo Make it configurable, e.g. printing into a file. #define ROSA_LOG_OSTREAM std::clog /// Prints a log message to \c ROSA_LOG_OSTREAM. /// /// \param level \c rosa::LogLevel of the log entry /// \param output message to print #define ROSA_LOG_IMPL(level, output) \ do { \ ROSA_LOG_OSTREAM << (level) << " " << __func__ << "@" << __FILENAME__ \ - << ":" << __LINE__ << ": " << (output) << std::endl; \ + << ":" << __LINE__ << ": " << (output) << '\n'; \ } while (false) /// Returns a stream to print a log message to. /// /// \param level \c rosa::LogLevel of the log entry that is about to be printed #define ROSA_LOG_STREAM_IMPL(level) \ ([](void) -> std::ostream & { \ return ROSA_LOG_OSTREAM << (level) << " " << __func__ << "@" \ << __FILENAME__ << ":" << __LINE__ << ": "; \ }()) namespace rosa { /// Dummy \c std::ostream printing to nowhere. extern std::ostream LogSink; } // End namespace rosa /// An output stream ignoring all its input. #define ROSA_LOG_STREAM_IGNORE rosa::LogSink /* **************************************************************************** * Logging Interface * * ****************************************************************************/ /// \name Logging interface /// /// Preprocesser macros for convenience. ///@{ /// \def LOG_ERROR_STREAM /// \brief Returns a stream to print a log entry of level /// \c rosa::LogLevel::Error. /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Error. /// \def LOG_ERROR(output) /// \brief Prints a log entry of level \c rosa::LogLevel::Error. /// \param output the message to print /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Error. /// \def LOG_WARNING_STREAM /// \brief Returns a stream to print a log entry of level /// \c rosa::LogLevel::Warning. /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Warning. /// \def LOG_WARNING(output) /// \brief Prints a log entry of level \c rosa::LogLevel::Warning. /// \param output the message to print /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Warning. /// \def LOG_INFO_STREAM /// \brief Returns a stream to print a log entry of level /// \c rosa::LogLevel::Info. /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Info. /// \def LOG_INFO(output) /// \brief Prints a log entry of level \c rosa::LogLevel::Info. /// \param output the message to print /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Info. /// \def LOG_DEBUG_STREAM /// \brief Returns a stream to print a log entry of level /// \c rosa::LogLevel::Debug. /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Debug. /// \def LOG_DEBUG(output) /// \brief Prints a log entry of level \c rosa::LogLevel::Debug. /// \param output the message to print /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Debug. /// \def LOG_TRACE_STREAM /// \brief Returns a stream to print a log entry of level /// \c rosa::LogLevel::Trace. /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Trace. /// \def LOG_TRACE(output) /// \brief Prints a log entry of level \c rosa::LogLevel::Trace. /// \param output the message to print /// \note Takes effect only if RoSA is built with a log level not smaller than /// \c rosa::LogLevel::Trace. ///@} // Define logging macros if logging is enabled. #ifdef ROSA_LOG_LEVEL #define LOG_ERROR_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Error) #define LOG_ERROR(output) ROSA_LOG_IMPL(rosa::LogLevel::Error, output) #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_WARNING #define LOG_WARNING_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Warning) #define LOG_WARNING(output) ROSA_LOG_IMPL(rosa::LogLevel::Warning, output) #endif #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_INFO #define LOG_INFO_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Info) #define LOG_INFO(output) ROSA_LOG_IMPL(rosa::LogLevel::Info, output) #endif #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_DEBUG #define LOG_DEBUG_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Debug) #define LOG_DEBUG(output) ROSA_LOG_IMPL(rosa::LogLevel::Debug, output) #endif #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_TRACE #define LOG_TRACE_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Trace) #define LOG_TRACE(output) ROSA_LOG_IMPL(rosa::LogLevel::Trace, output) #endif #endif // defined ROSA_LOG_LEVEL // Define all disabled logging features as void. #ifndef LOG_ERROR #define LOG_ERROR_STREAM ROSA_LOG_STREAM_IGNORE #define LOG_ERROR(output) ROSA_IGNORE_UNUSED(output) #endif #ifndef LOG_WARNING #define LOG_WARNING_STREAM ROSA_LOG_STREAM_IGNORE #define LOG_WARNING(output) ROSA_IGNORE_UNUSED(output) #endif #ifndef LOG_INFO #define LOG_INFO_STREAM ROSA_LOG_STREAM_IGNORE #define LOG_INFO(output) ROSA_IGNORE_UNUSED(output) #endif #ifndef LOG_DEBUG #define LOG_DEBUG_STREAM ROSA_LOG_STREAM_IGNORE #define LOG_DEBUG(output) ROSA_IGNORE_UNUSED(output) #endif #ifndef LOG_TRACE #define LOG_TRACE_STREAM ROSA_LOG_STREAM_IGNORE #define LOG_TRACE(output) ROSA_IGNORE_UNUSED(output) #endif #endif // ROSA_SUPPORT_LOG_H diff --git a/lib/config/version.cpp b/lib/config/version.cpp index 4a96cfa..73bc786 100644 --- a/lib/config/version.cpp +++ b/lib/config/version.cpp @@ -1,40 +1,38 @@ //===-- config/version.cpp --------------------------------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file config/version.cpp /// /// \author David Juhasz (david.juhasz@tuwien.ac.at) /// /// \date 2017 /// /// \brief Implementation for rosa/config/version.h. /// //===----------------------------------------------------------------------===// #include "rosa/config/version.h" #include namespace rosa { std::string library_string(void) { return PACKAGE_STRING; } std::string version(void) { return PACKAGE_VERSION; } std::string verbose_version(void) { std::stringstream SS; - SS << PACKAGE_STRING << std::endl - << "Built by " << CMAKE_GENERATOR << " with " << CMAKE_CXX_COMPILER_ID - << ' ' << CMAKE_CXX_COMPILER_VERSION << std::endl - << "on a(n) " << CMAKE_SYSTEM << " system." << std::endl - << "Build date: " << BUILD_DATE << std::endl - << "Package name: " << PACKAGE_NAME << std::endl - << "Package version: " << PACKAGE_VERSION << std::endl - << "Report issues: " << PACKAGE_BUGREPORT << std::endl; + SS << PACKAGE_STRING << "\nBuilt by " << CMAKE_GENERATOR << " with " + << CMAKE_CXX_COMPILER_ID << ' ' << CMAKE_CXX_COMPILER_VERSION + << "\non a(n) " << CMAKE_SYSTEM << " system." + << "\nBuild date: " << BUILD_DATE << "\nPackage name: " << PACKAGE_NAME + << "\nPackage version: " << PACKAGE_VERSION + << "\nReport issues: " << PACKAGE_BUGREPORT; return SS.str(); } } // End namespace rosa