diff options
84 files changed, 2934 insertions, 2951 deletions
diff --git a/libadhocutil/buffer.cpp b/libadhocutil/buffer.cpp index 00c2b45..07a57ea 100644 --- a/libadhocutil/buffer.cpp +++ b/libadhocutil/buffer.cpp @@ -1,315 +1,295 @@ #include "buffer.h" -#include <cstring> #include <cstdio> +#include <cstring> namespace AdHoc { -// -// CString Fragment -// + // + // CString Fragment + // -Buffer::CStringFragment::CStringFragment(const char * b, CStringHandling h) : - len(strlen(b)), - buf(b), - handling(h) -{ -} + Buffer::CStringFragment::CStringFragment(const char * b, CStringHandling h) : + len(strlen(b)), buf(b), handling(h) { } -Buffer::CStringFragment::CStringFragment(const char * b, CStringHandling h, size_t l) : - len(l), - buf(b), - handling(h) -{ -} + Buffer::CStringFragment::CStringFragment(const char * b, CStringHandling h, size_t l) : len(l), buf(b), handling(h) + { + } -Buffer::CStringFragment::CStringFragment(char * b, CStringHandling h) : - len(strlen(b)), - buf(b), - handling(h) -{ -} + Buffer::CStringFragment::CStringFragment(char * b, CStringHandling h) : len(strlen(b)), buf(b), handling(h) { } -Buffer::CStringFragment::CStringFragment(char * b, CStringHandling h, size_t l) : - len(l), - buf(b), - handling(h) -{ -} + Buffer::CStringFragment::CStringFragment(char * b, CStringHandling h, size_t l) : len(l), buf(b), handling(h) { } -Buffer::CStringFragment::~CStringFragment() -{ - if (handling != Use) { // Copy or Free - // NOLINTNEXTLINE(hicpp-no-malloc) - free(const_cast<char *>(buf)); + Buffer::CStringFragment::~CStringFragment() + { + if (handling != Use) { // Copy or Free + // NOLINTNEXTLINE(hicpp-no-malloc) + free(const_cast<char *>(buf)); + } } -} -char -Buffer::CStringFragment::operator[](size_t x) const -{ - return buf[x]; -} + char + Buffer::CStringFragment::operator[](size_t x) const + { + return buf[x]; + } -size_t -Buffer::CStringFragment::length() const -{ - return len; -} + size_t + Buffer::CStringFragment::length() const + { + return len; + } -const char * -Buffer::CStringFragment::c_str() const -{ - return buf; -} + const char * + Buffer::CStringFragment::c_str() const + { + return buf; + } -std::string -Buffer::CStringFragment::str() const -{ - return buf; -} + std::string + Buffer::CStringFragment::str() const + { + return buf; + } -// -// Std::String Fragment -// + // + // Std::String Fragment + // -Buffer::StringFragment::StringFragment(std::string str) : - buf(std::move(str)) -{ -} + Buffer::StringFragment::StringFragment(std::string str) : buf(std::move(str)) { } -size_t -Buffer::StringFragment::length() const -{ - return buf.length(); -} + size_t + Buffer::StringFragment::length() const + { + return buf.length(); + } -const char * -Buffer::StringFragment::c_str() const -{ - return buf.c_str(); -} + const char * + Buffer::StringFragment::c_str() const + { + return buf.c_str(); + } -std::string -Buffer::StringFragment::str() const -{ - return buf; -} + std::string + Buffer::StringFragment::str() const + { + return buf; + } -char -Buffer::StringFragment::operator[](size_t x) const -{ - return buf[x]; -} + char + Buffer::StringFragment::operator[](size_t x) const + { + return buf[x]; + } -// -// Buffer :) -// + // + // Buffer :) + // -Buffer::Buffer(const char * src, CStringHandling h) -{ - append(src, h); -} + Buffer::Buffer(const char * src, CStringHandling h) + { + append(src, h); + } -Buffer::Buffer(char * src, CStringHandling h) -{ - append(src, h); -} + Buffer::Buffer(char * src, CStringHandling h) + { + append(src, h); + } -Buffer::Buffer(const std::string & str) -{ - append(str); -} + Buffer::Buffer(const std::string & str) + { + append(str); + } -Buffer & -Buffer::append(const char * str, CStringHandling h) -{ - if (str && *str) { - if (h == Copy) { - content.push_back(std::make_shared<StringFragment>(str)); + Buffer & + Buffer::append(const char * str, CStringHandling h) + { + if (str && *str) { + if (h == Copy) { + content.push_back(std::make_shared<StringFragment>(str)); + } + else { + content.push_back(std::make_shared<CStringFragment>(str, h)); + } } - else { - content.push_back(std::make_shared<CStringFragment>(str, h)); + return *this; + } + + Buffer & + Buffer::append(char * str, CStringHandling h) + { + if (str && *str) { + if (h == Copy) { + content.push_back(std::make_shared<StringFragment>(str)); + } + else { + content.push_back(std::make_shared<CStringFragment>(str, h)); + } } + return *this; } - return *this; -} -Buffer & -Buffer::append(char * str, CStringHandling h) -{ - if (str && *str) { - if (h == Copy) { + Buffer & + Buffer::append(const std::string & str) + { + if (!str.empty()) { content.push_back(std::make_shared<StringFragment>(str)); } - else { - content.push_back(std::make_shared<CStringFragment>(str, h)); - } + return *this; } - return *this; -} -Buffer & -Buffer::append(const std::string & str) -{ - if (!str.empty()) { - content.push_back(std::make_shared<StringFragment>(str)); + Buffer & + Buffer::appendf(const char * fmt, ...) + { + va_list v; + va_start(v, fmt); + vappendf(fmt, v); + va_end(v); + return *this; } - return *this; -} - -Buffer & -Buffer::appendf(const char * fmt, ...) -{ - va_list v; - va_start(v, fmt); - vappendf(fmt, v); - va_end(v); - return *this; -} -Buffer & -Buffer::vappendf(const char * fmt, va_list args) -{ - char * frag; - size_t len = vasprintf(&frag, fmt, args); - if (len > 0) { - content.push_back(std::make_shared<CStringFragment>(frag, Free, len)); - } - else { - // NOLINTNEXTLINE(hicpp-no-malloc) - free(frag); + Buffer & + Buffer::vappendf(const char * fmt, va_list args) + { + char * frag; + size_t len = vasprintf(&frag, fmt, args); + if (len > 0) { + content.push_back(std::make_shared<CStringFragment>(frag, Free, len)); + } + else { + // NOLINTNEXTLINE(hicpp-no-malloc) + free(frag); + } + return *this; } - return *this; -} -Buffer & -Buffer::appendbf(boost::format & fmt) -{ - append(fmt.str()); - return *this; -} + Buffer & + Buffer::appendbf(boost::format & fmt) + { + append(fmt.str()); + return *this; + } -Buffer & -Buffer::clear() -{ - content.clear(); - return *this; -} + Buffer & + Buffer::clear() + { + content.clear(); + return *this; + } -boost::format -Buffer::getFormat(const std::string & msgfmt) -{ - return boost::format(msgfmt); -} + boost::format + Buffer::getFormat(const std::string & msgfmt) + { + return boost::format(msgfmt); + } -void -Buffer::writeto(char * buf, size_t bufSize, size_t off) const -{ - auto f = content.begin(); - while (f != content.end() && (*f)->length() < off) { - off -= (*f)->length(); - ++f; - } - while (f != content.end() && bufSize) { - for (size_t c = 0; bufSize && c < (*f)->length(); bufSize--) { - *buf++ = (**f)[c++]; + void + Buffer::writeto(char * buf, size_t bufSize, size_t off) const + { + auto f = content.begin(); + while (f != content.end() && (*f)->length() < off) { + off -= (*f)->length(); + ++f; + } + while (f != content.end() && bufSize) { + for (size_t c = 0; bufSize && c < (*f)->length(); bufSize--) { + *buf++ = (**f)[c++]; + } + ++f; } - ++f; + *buf = '\0'; } - *buf = '\0'; -} -Buffer::operator std::string() const -{ - if (content.size() > 1) { - std::string res; - res.reserve(length()); - for (const auto & f : content) { - res.append(f->str()); + Buffer::operator std::string() const + { + if (content.size() > 1) { + std::string res; + res.reserve(length()); + for (const auto & f : content) { + res.append(f->str()); + } + return res; } - return res; - } - else if (content.size() == 1) { - return std::string(content.front()->str()); + else if (content.size() == 1) { + return std::string(content.front()->str()); + } + return std::string(); } - return std::string(); -} -Buffer::operator const char *() const -{ - if (content.empty()) { - return ""; + Buffer::operator const char *() const + { + if (content.empty()) { + return ""; + } + flatten(); + return content.front()->c_str(); } - flatten(); - return content.front()->c_str(); -} -void -Buffer::flatten() const -{ - if (content.size() > 1) { - content = { std::make_shared<StringFragment>(str()) }; + void + Buffer::flatten() const + { + if (content.size() > 1) { + content = {std::make_shared<StringFragment>(str())}; + } } -} -std::string -Buffer::str() const -{ - return *this; -} + std::string + Buffer::str() const + { + return *this; + } -size_t -Buffer::length() const -{ - size_t len = 0; - for (const Content::value_type & c : content) { - len += c->length(); + size_t + Buffer::length() const + { + size_t len = 0; + for (const Content::value_type & c : content) { + len += c->length(); + } + return len; } - return len; -} -Buffer & -Buffer::operator=(const char * str) -{ - content = { std::make_shared<StringFragment>(str) }; - return *this; -} + Buffer & + Buffer::operator=(const char * str) + { + content = {std::make_shared<StringFragment>(str)}; + return *this; + } -Buffer & -Buffer::operator=(const std::string & str) -{ - content = { std::make_shared<StringFragment>(str) }; - return *this; -} + Buffer & + Buffer::operator=(const std::string & str) + { + content = {std::make_shared<StringFragment>(str)}; + return *this; + } -Buffer::operator bool() const -{ - return !content.empty(); -} + Buffer::operator bool() const + { + return !content.empty(); + } -bool -Buffer::operator!() const -{ - return content.empty(); -} + bool + Buffer::operator!() const + { + return content.empty(); + } -bool -Buffer::empty() const -{ - return content.empty(); -} + bool + Buffer::empty() const + { + return content.empty(); + } -Buffer & -Buffer::operator+=(const char * str) -{ - return append(str); -} + Buffer & + Buffer::operator+=(const char * str) + { + return append(str); + } -Buffer & -Buffer::operator+=(const std::string & str) -{ - return append(str); -} + Buffer & + Buffer::operator+=(const std::string & str) + { + return append(str); + } } @@ -321,4 +301,3 @@ std::operator<<(std::ostream & os, const AdHoc::Buffer & b) } return os; } - diff --git a/libadhocutil/buffer.h b/libadhocutil/buffer.h index 62c8e38..373e799 100644 --- a/libadhocutil/buffer.h +++ b/libadhocutil/buffer.h @@ -1,12 +1,12 @@ #ifndef ADHOCUTIL_BUFFER_H #define ADHOCUTIL_BUFFER_H +#include "c++11Helpers.h" +#include "visibility.h" +#include <boost/format.hpp> +#include <cstdarg> #include <string> #include <vector> -#include <cstdarg> -#include <boost/format.hpp> -#include "visibility.h" -#include "c++11Helpers.h" namespace AdHoc { class DLL_PUBLIC Buffer; @@ -18,8 +18,8 @@ namespace std { namespace AdHoc { -/// High-speed text buffer for easy creation of programatically created strings. -class DLL_PUBLIC Buffer { + /// High-speed text buffer for easy creation of programatically created strings. + class DLL_PUBLIC Buffer { public: /** How should Buffer handle char * arguments? */ enum CStringHandling { @@ -85,19 +85,21 @@ class DLL_PUBLIC Buffer { /** Append the given std::string to the end of the buffer. */ Buffer & append(const std::string & str); /** Append the given printf style format string and arguments to the buffer. */ - Buffer & appendf(const char * fmt, ...) __attribute__((format (printf, 2, 3))); + Buffer & appendf(const char * fmt, ...) __attribute__((format(printf, 2, 3))); /** Append the given printf style format string and va_list to the buffer. */ Buffer & vappendf(const char * fmt, va_list args); /** Append the given boost::format style format string and arguments to the buffer. */ - template <typename ... Params> - Buffer & appendbf(const std::string & fmtstr, const Params & ... params) + template<typename... Params> + Buffer & + appendbf(const std::string & fmtstr, const Params &... params) { auto bf = getFormat(fmtstr); return appendbf(bf, params...); } /** Append the given boost::format and arguments to the buffer. */ - template <typename Param, typename ... Params> - Buffer & appendbf(boost::format & fmt, const Param & param, const Params & ... params) + template<typename Param, typename... Params> + Buffer & + appendbf(boost::format & fmt, const Param & param, const Params &... params) { fmt % param; return appendbf(fmt, params...); @@ -119,54 +121,54 @@ class DLL_PUBLIC Buffer { void DLL_PRIVATE flatten() const; class DLL_PRIVATE FragmentBase { - public: - FragmentBase() = default; - virtual ~FragmentBase() = default; - SPECIAL_MEMBERS_DEFAULT(FragmentBase); - - [[nodiscard]] virtual size_t length() const = 0; - [[nodiscard]] virtual char operator[](size_t) const = 0; - [[nodiscard]] virtual const char * c_str() const = 0; - [[nodiscard]] virtual std::string str() const = 0; + public: + FragmentBase() = default; + virtual ~FragmentBase() = default; + SPECIAL_MEMBERS_DEFAULT(FragmentBase); + + [[nodiscard]] virtual size_t length() const = 0; + [[nodiscard]] virtual char operator[](size_t) const = 0; + [[nodiscard]] virtual const char * c_str() const = 0; + [[nodiscard]] virtual std::string str() const = 0; }; class DLL_PRIVATE CStringFragment : public FragmentBase { - public: - CStringFragment(const char *, CStringHandling); - CStringFragment(const char *, CStringHandling, size_t); - CStringFragment(char *, CStringHandling); - CStringFragment(char *, CStringHandling, size_t); - SPECIAL_MEMBERS_DELETE(CStringFragment); - ~CStringFragment() override; - - [[nodiscard]] size_t length() const override; - [[nodiscard]] char operator[](size_t) const override; - [[nodiscard]] const char * c_str() const override; - [[nodiscard]] std::string str() const override; - - private: - const size_t len; // Excluding NULL term - const char * buf; - const CStringHandling handling; + public: + CStringFragment(const char *, CStringHandling); + CStringFragment(const char *, CStringHandling, size_t); + CStringFragment(char *, CStringHandling); + CStringFragment(char *, CStringHandling, size_t); + SPECIAL_MEMBERS_DELETE(CStringFragment); + ~CStringFragment() override; + + [[nodiscard]] size_t length() const override; + [[nodiscard]] char operator[](size_t) const override; + [[nodiscard]] const char * c_str() const override; + [[nodiscard]] std::string str() const override; + + private: + const size_t len; // Excluding NULL term + const char * buf; + const CStringHandling handling; }; class DLL_PRIVATE StringFragment : public FragmentBase { - public: - explicit StringFragment(std::string); + public: + explicit StringFragment(std::string); - [[nodiscard]] size_t length() const override; - [[nodiscard]] char operator[](size_t) const override; - [[nodiscard]] const char * c_str() const override; - [[nodiscard]] std::string str() const override; + [[nodiscard]] size_t length() const override; + [[nodiscard]] char operator[](size_t) const override; + [[nodiscard]] const char * c_str() const override; + [[nodiscard]] std::string str() const override; - private: - const std::string buf; + private: + const std::string buf; }; using FragmentPtr = std::shared_ptr<FragmentBase>; using Content = std::vector<FragmentPtr>; mutable Content content; -}; + }; } @@ -176,4 +178,3 @@ class DLL_PUBLIC Buffer { #define stringbf(...) AdHoc::Buffer().appendbf(__VA_ARGS__).str() #endif - diff --git a/libadhocutil/c++11Helpers.h b/libadhocutil/c++11Helpers.h index 9826189..74f0987 100644 --- a/libadhocutil/c++11Helpers.h +++ b/libadhocutil/c++11Helpers.h @@ -31,4 +31,3 @@ SPECIAL_MEMBERS_MOVE(T, default) #endif - diff --git a/libadhocutil/cache.h b/libadhocutil/cache.h index 20ef52e..5f606c2 100644 --- a/libadhocutil/cache.h +++ b/libadhocutil/cache.h @@ -1,22 +1,21 @@ #ifndef ADHOCUTIL_CACHE_H #define ADHOCUTIL_CACHE_H -#include <ctime> -#include <memory> -#include <functional> -#include <boost/multi_index_container.hpp> +#include "c++11Helpers.h" +#include "visibility.h" #include <boost/multi_index/member.hpp> #include <boost/multi_index/ordered_index.hpp> +#include <boost/multi_index_container.hpp> +#include <ctime> +#include <functional> +#include <memory> #include <shared_mutex> #include <variant> -#include "visibility.h" -#include "c++11Helpers.h" namespace AdHoc { -/// @cond -template <typename T, typename K> -class DLL_PUBLIC Cacheable { + /// @cond + template<typename T, typename K> class DLL_PUBLIC Cacheable { public: using Value = const std::shared_ptr<const T>; Cacheable(K k, time_t validUntil); @@ -28,10 +27,9 @@ class DLL_PUBLIC Cacheable { const time_t validUntil; [[nodiscard]] virtual Value item() const = 0; -}; + }; -template <typename T, typename K> -class DLL_PUBLIC ObjectCacheable : public Cacheable<T, K> { + template<typename T, typename K> class DLL_PUBLIC ObjectCacheable : public Cacheable<T, K> { public: ObjectCacheable(const T & t, const K & k, time_t validUtil); ObjectCacheable(typename Cacheable<T, K>::Value t, const K & k, time_t validUtil); @@ -40,10 +38,9 @@ class DLL_PUBLIC ObjectCacheable : public Cacheable<T, K> { private: typename Cacheable<T, K>::Value value; -}; + }; -template <typename T, typename K> -class DLL_PUBLIC CallCacheable : public Cacheable<T, K> { + template<typename T, typename K> class DLL_PUBLIC CallCacheable : public Cacheable<T, K> { public: using Factory = std::function<T()>; CallCacheable(const Factory & t, const K & k, time_t validUtil); @@ -53,10 +50,9 @@ class DLL_PUBLIC CallCacheable : public Cacheable<T, K> { private: mutable std::variant<std::shared_ptr<const T>, Factory> value; mutable std::shared_mutex lock; -}; + }; -template <typename T, typename K> -class DLL_PUBLIC PointerCallCacheable : public Cacheable<T, K> { + template<typename T, typename K> class DLL_PUBLIC PointerCallCacheable : public Cacheable<T, K> { public: using Factory = std::function<typename Cacheable<T, K>::Value()>; PointerCallCacheable(const Factory & t, const K & k, time_t validUtil); @@ -66,15 +62,16 @@ class DLL_PUBLIC PointerCallCacheable : public Cacheable<T, K> { private: mutable std::variant<std::shared_ptr<const T>, Factory> value; mutable std::shared_mutex lock; -}; + }; -struct byValidity {}; -struct byKey {}; -/// @endcond + struct byValidity { + }; + struct byKey { + }; + /// @endcond -/// In-memory cache of T, keyed by K. -template <typename T, typename K> -class DLL_PUBLIC Cache { + /// In-memory cache of T, keyed by K. + template<typename T, typename K> class DLL_PUBLIC Cache { public: /// @cond using Key = K; @@ -140,16 +137,13 @@ class DLL_PUBLIC Cache { mutable std::shared_mutex lock; using Cached = boost::multi_index::multi_index_container<Element, - boost::multi_index::indexed_by< - boost::multi_index::ordered_unique< - boost::multi_index::tag<byKey>, BOOST_MULTI_INDEX_MEMBER(Item, const K, key)>, - boost::multi_index::ordered_non_unique< - boost::multi_index::tag<byValidity>, BOOST_MULTI_INDEX_MEMBER(Item, const time_t, validUntil)> - > >; + boost::multi_index::indexed_by<boost::multi_index::ordered_unique<boost::multi_index::tag<byKey>, + BOOST_MULTI_INDEX_MEMBER(Item, const K, key)>, + boost::multi_index::ordered_non_unique<boost::multi_index::tag<byValidity>, + BOOST_MULTI_INDEX_MEMBER(Item, const time_t, validUntil)>>>; mutable Cached cached; -}; + }; } #endif - diff --git a/libadhocutil/cache.impl.h b/libadhocutil/cache.impl.h index 10c66a3..5200bce 100644 --- a/libadhocutil/cache.impl.h +++ b/libadhocutil/cache.impl.h @@ -2,190 +2,173 @@ #define ADHOCUTIL_CACHE_IMPL_H #include "cache.h" -#include <boost/lambda/lambda.hpp> #include "lockHelpers.h" +#include <boost/lambda/lambda.hpp> #include <shared_mutex> namespace AdHoc { -/// @cond -template<typename T, typename K> -Cacheable<T, K>::Cacheable(K k, time_t vu) : - key(std::move(k)), - validUntil(vu) -{ -} - -template<typename T, typename K> -ObjectCacheable<T, K>::ObjectCacheable(const T & t, const K & k, time_t vu) : - Cacheable<T, K>(k, vu), - value(std::make_shared<T>(t)) -{ -} + /// @cond + template<typename T, typename K> Cacheable<T, K>::Cacheable(K k, time_t vu) : key(std::move(k)), validUntil(vu) { } -template<typename T, typename K> -ObjectCacheable<T, K>::ObjectCacheable(typename Cacheable<T, K>::Value t, const K & k, time_t vu) : - Cacheable<T, K>(k, vu), - value(std::move(t)) -{ -} - -template<typename T, typename K> -typename Cacheable<T, K>::Value -ObjectCacheable<T, K>::item() const -{ - return value; -} + template<typename T, typename K> + ObjectCacheable<T, K>::ObjectCacheable(const T & t, const K & k, time_t vu) : + Cacheable<T, K>(k, vu), value(std::make_shared<T>(t)) + { + } -template<typename T, typename K> -CallCacheable<T, K>::CallCacheable(const Factory & t, const K & k, time_t vu) : - Cacheable<T, K>(k, vu), - value(t) -{ -} + template<typename T, typename K> + ObjectCacheable<T, K>::ObjectCacheable(typename Cacheable<T, K>::Value t, const K & k, time_t vu) : + Cacheable<T, K>(k, vu), value(std::move(t)) + { + } -template<typename T, typename K> -typename Cacheable<T, K>::Value -CallCacheable<T, K>::item() const -{ - Lock(lock); - if (auto t = std::get_if<0>(&value)) { - return *t; - } - const Factory & f = std::get<Factory>(value); - value = std::make_shared<T>(f()); - return std::get<0>(value); -} + template<typename T, typename K> + typename Cacheable<T, K>::Value + ObjectCacheable<T, K>::item() const + { + return value; + } + template<typename T, typename K> + CallCacheable<T, K>::CallCacheable(const Factory & t, const K & k, time_t vu) : Cacheable<T, K>(k, vu), value(t) + { + } -template<typename T, typename K> -PointerCallCacheable<T, K>::PointerCallCacheable(const Factory & t, const K & k, time_t vu) : - Cacheable<T, K>(k, vu), - value(t) -{ -} + template<typename T, typename K> + typename Cacheable<T, K>::Value + CallCacheable<T, K>::item() const + { + Lock(lock); + if (auto t = std::get_if<0>(&value)) { + return *t; + } + const Factory & f = std::get<Factory>(value); + value = std::make_shared<T>(f()); + return std::get<0>(value); + } -template<typename T, typename K> -typename Cacheable<T, K>::Value -PointerCallCacheable<T, K>::item() const -{ - Lock(lock); - if (auto t = std::get_if<0>(&value)) { - return *t; - } - const Factory & f = std::get<Factory>(value); - value = f(); - return std::get<0>(value); -} + template<typename T, typename K> + PointerCallCacheable<T, K>::PointerCallCacheable(const Factory & t, const K & k, time_t vu) : + Cacheable<T, K>(k, vu), value(t) + { + } + template<typename T, typename K> + typename Cacheable<T, K>::Value + PointerCallCacheable<T, K>::item() const + { + Lock(lock); + if (auto t = std::get_if<0>(&value)) { + return *t; + } + const Factory & f = std::get<Factory>(value); + value = f(); + return std::get<0>(value); + } -template<typename T, typename K> -Cache<T, K>::Cache() : - lastPruneTime(time(nullptr)) -{ -} + template<typename T, typename K> Cache<T, K>::Cache() : lastPruneTime(time(nullptr)) { } -template<typename T, typename K> -void -Cache<T, K>::add(const K & k, const T & t, time_t validUntil) -{ - Lock(lock); - cached.insert(std::make_shared<ObjectCacheable<T, K>>(t, k, validUntil)); -} + template<typename T, typename K> + void + Cache<T, K>::add(const K & k, const T & t, time_t validUntil) + { + Lock(lock); + cached.insert(std::make_shared<ObjectCacheable<T, K>>(t, k, validUntil)); + } -template<typename T, typename K> -void -Cache<T, K>::addPointer(const K & k, Value & t, time_t validUntil) -{ - Lock(lock); - cached.insert(std::make_shared<ObjectCacheable<T, K>>(t, k, validUntil)); -} + template<typename T, typename K> + void + Cache<T, K>::addPointer(const K & k, Value & t, time_t validUntil) + { + Lock(lock); + cached.insert(std::make_shared<ObjectCacheable<T, K>>(t, k, validUntil)); + } -template<typename T, typename K> -void -Cache<T, K>::addFactory(const K & k, const Factory & tf, time_t validUntil) -{ - Lock(lock); - cached.insert(std::make_shared<CallCacheable<T, K>>(tf, k, validUntil)); -} + template<typename T, typename K> + void + Cache<T, K>::addFactory(const K & k, const Factory & tf, time_t validUntil) + { + Lock(lock); + cached.insert(std::make_shared<CallCacheable<T, K>>(tf, k, validUntil)); + } -template<typename T, typename K> -void -Cache<T, K>::addPointerFactory(const K & k, const PointerFactory & tf, time_t validUntil) -{ - Lock(lock); - cached.insert(std::make_shared<PointerCallCacheable<T, K>>(tf, k, validUntil)); -} + template<typename T, typename K> + void + Cache<T, K>::addPointerFactory(const K & k, const PointerFactory & tf, time_t validUntil) + { + Lock(lock); + cached.insert(std::make_shared<PointerCallCacheable<T, K>>(tf, k, validUntil)); + } -template<typename T, typename K> -typename Cache<T, K>::Element -Cache<T, K>::getItem(const K & k) const -{ + template<typename T, typename K> + typename Cache<T, K>::Element + Cache<T, K>::getItem(const K & k) const { - SharedLock(lock); - auto & collection = cached.template get<byKey>(); - auto i = collection.find(k); - if (i == collection.end()) { - return Element(); - } - if ((*i)->validUntil > time(nullptr)) { - return (*i); + { + SharedLock(lock); + auto & collection = cached.template get<byKey>(); + auto i = collection.find(k); + if (i == collection.end()) { + return Element(); + } + if ((*i)->validUntil > time(nullptr)) { + return (*i); + } } + prune(); + return Element(); } - prune(); - return Element(); -} -template<typename T, typename K> -typename Cache<T, K>::Value -Cache<T, K>::get(const K & k) const -{ - auto i = getItem(k); - if (i) { - return i->item(); + template<typename T, typename K> + typename Cache<T, K>::Value + Cache<T, K>::get(const K & k) const + { + auto i = getItem(k); + if (i) { + return i->item(); + } + return nullptr; } - return nullptr; -} - -template<typename T, typename K> -size_t -Cache<T, K>::size() const -{ - return cached.size(); -} -template<typename T, typename K> -void -Cache<T, K>::remove(const K & k) -{ - Lock(lock); - cached.template get<byKey>().erase(k); -} + template<typename T, typename K> + size_t + Cache<T, K>::size() const + { + return cached.size(); + } -template<typename T, typename K> -void -Cache<T, K>::clear() -{ - Lock(lock); - cached.clear(); -} + template<typename T, typename K> + void + Cache<T, K>::remove(const K & k) + { + Lock(lock); + cached.template get<byKey>().erase(k); + } -template<typename T, typename K> -void -Cache<T, K>::prune() const -{ - auto now = time(nullptr); - if (lastPruneTime < now) { + template<typename T, typename K> + void + Cache<T, K>::clear() + { Lock(lock); - auto & collection = cached.template get<byValidity>(); - auto range = collection.range(boost::multi_index::unbounded, boost::lambda::_1 < now); - collection.erase(range.first, range.second); - lastPruneTime = now; + cached.clear(); } -} -/// @endcond + + template<typename T, typename K> + void + Cache<T, K>::prune() const + { + auto now = time(nullptr); + if (lastPruneTime < now) { + Lock(lock); + auto & collection = cached.template get<byValidity>(); + auto range = collection.range(boost::multi_index::unbounded, boost::lambda::_1 < now); + collection.erase(range.first, range.second); + lastPruneTime = now; + } + } + /// @endcond } #endif - diff --git a/libadhocutil/compileTimeFormatter.h b/libadhocutil/compileTimeFormatter.h index 5b39167..7e4eef1 100644 --- a/libadhocutil/compileTimeFormatter.h +++ b/libadhocutil/compileTimeFormatter.h @@ -1,59 +1,70 @@ #ifndef ADHOCUTIL_COMPILE_TIME_FORMATTER_H #define ADHOCUTIL_COMPILE_TIME_FORMATTER_H -#include <sstream> -#include <iostream> -#include <cstring> -#include <optional> #include <array> #include <boost/preprocessor/variadic/size.hpp> +#include <cstring> +#include <iostream> +#include <optional> +#include <sstream> namespace AdHoc { #ifdef __cpp_nontype_template_parameter_class -#define USE_FIXED_STRING +# define USE_FIXED_STRING #endif #ifdef USE_FIXED_STRING -#define CtfString const auto +# define CtfString const auto #else -#define CtfString const auto & +# define CtfString const auto & #endif // Template char utils template<typename char_type> - constexpr bool isdigit(const char_type & ch) + constexpr bool + isdigit(const char_type & ch) { return (ch >= '0' && ch <= '9'); } template<typename char_type> - constexpr bool ispositivedigit(const char_type & ch) + constexpr bool + ispositivedigit(const char_type & ch) { return (ch >= '1' && ch <= '9'); } // Template string utils template<CtfString S> - static constexpr auto strlen() + static constexpr auto + strlen() { auto off = 0U; - while (S[off]) { ++off; } + while (S[off]) { + ++off; + } return off; } template<typename char_type> - static constexpr auto strlen(const char_type * S) + static constexpr auto + strlen(const char_type * S) { auto off = 0U; - while (S[off]) { ++off; } + while (S[off]) { + ++off; + } return off; } template<CtfString S, auto n, auto start = 0U, auto L = strlen<S>()> - static constexpr std::optional<decltype(start)> strchr() + static constexpr std::optional<decltype(start)> + strchr() { static_assert(start <= L); decltype(start) off = start; - while (off < L && S[off] != n) { ++off; } + while (off < L && S[off] != n) { + ++off; + } if (off == L) { return {}; } @@ -61,51 +72,55 @@ namespace AdHoc { } template<CtfString S, auto n, auto start = 0U, auto L = strlen<S>()> - static constexpr decltype(L) strchrnul() + static constexpr decltype(L) + strchrnul() { decltype(start) off = start; - while (off < L && S[off] != n) { ++off; } + while (off < L && S[off] != n) { + ++off; + } return off; } template<CtfString S, const auto L> class FormatterDetail; /// Template used to apply parameters to a stream. - template<CtfString S, auto L, auto pos, typename stream, typename, auto ...> - struct StreamWriter { + template<CtfString S, auto L, auto pos, typename stream, typename, auto...> struct StreamWriter { /// Write parameters to stream. - template<typename ... Pn> - static void write(stream &, const Pn & ...) + template<typename... Pn> + static void + write(stream &, const Pn &...) { static_assert(!L, "invalid format string/arguments"); } }; /// Helper to simplify implementations of StreamWriter. - template<CtfString S, auto L, auto pos, typename stream> - struct StreamWriterBase { + template<CtfString S, auto L, auto pos, typename stream> struct StreamWriterBase { /// Continue processing parameters. - template<typename ... Pn> - static inline void next(stream & s, const Pn & ... pn) + template<typename... Pn> + static inline void + next(stream & s, const Pn &... pn) { FormatterDetail<S, L>::template Parser<stream, pos + 1, Pn...>::run(s, pn...); } }; #define StreamWriterT(C...) \ - template<CtfString S, auto L, auto pos, typename stream, auto ... sn> \ + template<CtfString S, auto L, auto pos, typename stream, auto... sn> \ struct StreamWriter<S, L, pos, stream, void, '%', C, sn...> : \ public StreamWriterBase<S, L, BOOST_PP_VARIADIC_SIZE(C) + pos, stream> #define StreamWriterTP(P, C...) \ - template<CtfString S, auto L, auto pos, typename stream, auto P, auto ... sn> \ + template<CtfString S, auto L, auto pos, typename stream, auto P, auto... sn> \ struct StreamWriter<S, L, pos, stream, void, '%', C, sn...> : \ public StreamWriterBase<S, L, BOOST_PP_VARIADIC_SIZE(C) + pos, stream> // Default stream writer formatter StreamWriterT('?') { - template<typename P, typename ... Pn> - static inline void write(stream & s, const P & p, const Pn & ... pn) + template<typename P, typename... Pn> + static inline void + write(stream & s, const P & p, const Pn &... pn) { s << p; StreamWriter::next(s, pn...); @@ -114,8 +129,9 @@ namespace AdHoc { // Escaped % stream writer formatter StreamWriterT('%') { - template<typename ... Pn> - static inline void write(stream & s, const Pn & ... pn) + template<typename... Pn> + static inline void + write(stream & s, const Pn &... pn) { s << '%'; StreamWriter::next(s, pn...); @@ -123,13 +139,15 @@ namespace AdHoc { }; template<typename stream, typename char_type> - static inline void appendStream(stream & s, const char_type * p, size_t n) + static inline void + appendStream(stream & s, const char_type * p, size_t n) { s.write(p, n); } template<typename stream> - static inline auto streamLength(stream & s) + static inline auto + streamLength(stream & s) { return s.tellp(); } @@ -138,186 +156,186 @@ namespace AdHoc { * Compile time string formatter. * @param S the format string. */ - template <CtfString S, const auto L> - class FormatterDetail { - private: - using strlen_t = decltype(strlen<S>()); - template<CtfString, auto, auto, typename> friend struct StreamWriterBase; + template<CtfString S, const auto L> class FormatterDetail { + private: + using strlen_t = decltype(strlen<S>()); + template<CtfString, auto, auto, typename> friend struct StreamWriterBase; + + public: + /// The derived charater type of the format string. + using char_type = typename std::decay<decltype(S[0])>::type; + /** + * Get a string containing the result of formatting. + * @param pn the format arguments. + * @return the formatted string. + */ + template<typename... Pn> + static inline auto + get(const Pn &... pn) + { + std::basic_stringstream<char_type> s; + return write(s, pn...).str(); + } + /** + * Get a string containing the result of formatting. + * @param pn the format arguments. + * @return the formatted string. + */ + template<typename... Pn> + inline auto + operator()(const Pn &... pn) const + { + return get(pn...); + } - public: - /// The derived charater type of the format string. - using char_type = typename std::decay<decltype(S[0])>::type; - /** - * Get a string containing the result of formatting. - * @param pn the format arguments. - * @return the formatted string. - */ - template<typename ... Pn> - static inline auto get(const Pn & ... pn) - { - std::basic_stringstream<char_type> s; - return write(s, pn...).str(); - } - /** - * Get a string containing the result of formatting. - * @param pn the format arguments. - * @return the formatted string. - */ - template<typename ... Pn> - inline auto operator()(const Pn & ... pn) const - { - return get(pn...); - } + /** + * Write the result of formatting to the given stream. + * @param s the stream to write to. + * @param pn the format arguments. + * @return the stream. + */ + template<typename stream, typename... Pn> + static inline stream & + write(stream & s, const Pn &... pn) + { + return Parser<stream, 0U, Pn...>::run(s, pn...); + } + /** + * Write the result of formatting to the given stream. + * @param s the stream to write to. + * @param pn the format arguments. + * @return the stream. + */ + template<typename stream, typename... Pn> + inline typename std::enable_if<(bool)&stream::write, stream>::type & + operator()(stream & s, const Pn &... pn) const + { + return write(s, pn...); + } - /** - * Write the result of formatting to the given stream. - * @param s the stream to write to. - * @param pn the format arguments. - * @return the stream. - */ - template<typename stream, typename ... Pn> - static inline stream & write(stream & s, const Pn & ... pn) + private: + template<typename stream, auto pos, typename... Pn> struct Parser { + static inline stream & + run(stream & s, const Pn &... pn) { - return Parser<stream, 0U, Pn...>::run(s, pn...); + if (pos != L) { + constexpr auto ph = strchrnul<S, '%', pos, L>(); + if constexpr (ph != pos) { + appendStream(s, &S[pos], ph - pos); + } + if constexpr (ph != L) { + packAndWrite<ph>(s, pn...); + } + } + return s; } - /** - * Write the result of formatting to the given stream. - * @param s the stream to write to. - * @param pn the format arguments. - * @return the stream. - */ - template<typename stream, typename ... Pn> - inline typename std::enable_if<(bool)&stream::write, stream>::type & - operator()(stream & s, const Pn & ... pn) const + template<strlen_t ph, strlen_t off = 0U, auto... Pck> + static inline void + packAndWrite(stream & s, const Pn &... pn) { - return write(s, pn...); - } - - private: - template<typename stream, auto pos, typename ... Pn> - struct Parser { - static inline stream & - run(stream & s, const Pn & ... pn) - { - if (pos != L) { - constexpr auto ph = strchrnul<S, '%', pos, L>(); - if constexpr (ph != pos) { - appendStream(s, &S[pos], ph - pos); - } - if constexpr (ph != L) { - packAndWrite<ph>(s, pn...); - } - } - return s; + if constexpr (ph + off == L || sizeof...(Pck) == 32) { + StreamWriter<S, L, ph, stream, void, Pck...>::write(s, pn...); } - template<strlen_t ph, strlen_t off = 0U, auto ... Pck> - static inline void packAndWrite(stream & s, const Pn & ... pn) - { - if constexpr (ph + off == L || sizeof...(Pck) == 32) { - StreamWriter<S, L, ph, stream, void, Pck...>::write(s, pn...); - } - else if constexpr (ph + off < L) { - packAndWrite<ph, off + 1, Pck..., S[ph + off]>(s, pn...); - } + else if constexpr (ph + off < L) { + packAndWrite<ph, off + 1, Pck..., S[ph + off]>(s, pn...); } - }; + } + }; }; #ifdef USE_FIXED_STRING // New C++20 implementation namespace support { - template<typename CharT, std::size_t N> - class basic_fixed_string : public std::array<CharT, N> { - public: - constexpr basic_fixed_string(const CharT (&str)[N + 1]) - { - for (decltype(N) x = 0; x < N; x++) { - this->at(x) = str[x]; - } + template<typename CharT, std::size_t N> class basic_fixed_string : public std::array<CharT, N> { + public: + constexpr basic_fixed_string(const CharT (&str)[N + 1]) + { + for (decltype(N) x = 0; x < N; x++) { + this->at(x) = str[x]; } - constexpr basic_fixed_string(const CharT * str, decltype(N) len) - { - for (decltype(N) x = 0; x < len; x++) { - this->at(x) = str[x]; - } + } + constexpr basic_fixed_string(const CharT * str, decltype(N) len) + { + for (decltype(N) x = 0; x < len; x++) { + this->at(x) = str[x]; } + } }; template<typename CharT, std::size_t N> basic_fixed_string(const CharT (&str)[N]) -> basic_fixed_string<CharT, N - 1>; } - template<const support::basic_fixed_string Str> - class LiteralFormatter : public FormatterDetail<Str, Str.size()> { }; + template<const support::basic_fixed_string Str> class LiteralFormatter : public FormatterDetail<Str, Str.size()> { + }; - template <const auto & S, decltype(strlen(S)) L = strlen(S)> - class Formatter : public FormatterDetail<support::basic_fixed_string< - typename std::decay<decltype(S[0])>::type, L>(S, L), L> { }; + template<const auto & S, decltype(strlen(S)) L = strlen(S)> + class Formatter : + public FormatterDetail<support::basic_fixed_string<typename std::decay<decltype(S[0])>::type, L>(S, L), L> { + }; -#define AdHocFormatter(name, str) \ - using name = ::AdHoc::LiteralFormatter<str> +# define AdHocFormatter(name, str) using name = ::AdHoc::LiteralFormatter<str> - template<const support::basic_fixed_string Str, typename ... Pn> - inline auto scprintf(const Pn & ... pn) + template<const support::basic_fixed_string Str, typename... Pn> + inline auto + scprintf(const Pn &... pn) { return FormatterDetail<Str, Str.size()>::get(pn...); } - template<const support::basic_fixed_string Str, typename stream, typename ... Pn> - inline auto & scprintf(stream & strm, const Pn & ... pn) + template<const support::basic_fixed_string Str, typename stream, typename... Pn> + inline auto & + scprintf(stream & strm, const Pn &... pn) { return FormatterDetail<Str, Str.size()>::write(strm, pn...); } - template<const support::basic_fixed_string Str, typename ... Pn> - inline auto & cprintf(const Pn & ... pn) + template<const support::basic_fixed_string Str, typename... Pn> + inline auto & + cprintf(const Pn &... pn) { return scprintf<Str>(std::cout, pn...); } #else // Classic pre-C++20 implementation -#include "unique.h" - template <const auto & S, decltype(strlen<S>()) L = strlen<S>()> - class Formatter : public FormatterDetail<S, L> { }; +# include "unique.h" + template<const auto & S, decltype(strlen<S>()) L = strlen<S>()> class Formatter : public FormatterDetail<S, L> { + }; -#define AdHocFormatterTypedef(name, str, id) \ - inline constexpr auto id = str; \ - using name = ::AdHoc::Formatter<id> -#define AdHocFormatter(name, str) \ - AdHocFormatterTypedef(name, str, MAKE_UNIQUE(name)) +# define AdHocFormatterTypedef(name, str, id) \ + inline constexpr auto id = str; \ + using name = ::AdHoc::Formatter<id> +# define AdHocFormatter(name, str) AdHocFormatterTypedef(name, str, MAKE_UNIQUE(name)) #endif namespace literals { #ifdef USE_FIXED_STRING - template<const support::basic_fixed_string Str> - constexpr inline auto operator""_fmt() noexcept + template<const support::basic_fixed_string Str> constexpr inline auto operator""_fmt() noexcept { return AdHoc::FormatterDetail<Str, Str.size()>(); } #else -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template" -#endif +# ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template" +# endif /// CTF format string holder - template<typename T, T ... t> struct FMT - { + template<typename T, T... t> struct FMT { /// CTF format string // NOLINTNEXTLINE(hicpp-avoid-c-arrays,modernize-avoid-c-arrays) static constexpr char __FMT[] = {t...}; }; - template<typename T, T ... t> inline auto operator""_fmt() noexcept + template<typename T, T... t> inline auto operator""_fmt() noexcept { return AdHoc::FormatterDetail<FMT<T, t...>::__FMT, sizeof...(t)>(); } #endif #ifdef __clang__ -#pragma clang diagnostic pop +# pragma clang diagnostic pop #endif } } #endif - diff --git a/libadhocutil/ctf-impl/printf-compat.h b/libadhocutil/ctf-impl/printf-compat.h index 4f93d4f..33223bf 100644 --- a/libadhocutil/ctf-impl/printf-compat.h +++ b/libadhocutil/ctf-impl/printf-compat.h @@ -3,19 +3,20 @@ #include "../compileTimeFormatter.h" #include <boost/assert.hpp> -#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/arithmetic/add.hpp> #include <boost/preprocessor/cat.hpp> -#include <boost/preprocessor/if.hpp> #include <boost/preprocessor/comma_if.hpp> -#include <boost/preprocessor/arithmetic/add.hpp> +#include <boost/preprocessor/if.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> #include <iomanip> #include <type_traits> namespace AdHoc { #define BASICCONV(PARAMTYPE, OP, ...) \ StreamWriterT(__VA_ARGS__) { \ - template<typename ... Pn> \ - static inline void write(stream & s, const PARAMTYPE & p, const Pn & ... pn) \ + template<typename... Pn> \ + static inline void \ + write(stream & s, const PARAMTYPE & p, const Pn &... pn) \ { \ OP; \ s.copyfmt(std::ios(nullptr)); \ @@ -68,23 +69,26 @@ namespace AdHoc { BASICCONV(wchar_t, s << p, 'l', 'c'); #undef BASICCONV StreamWriterT('p') { - template<typename Obj, typename ... Pn> - static inline void write(stream & s, Obj * const ptr, const Pn & ... pn) + template<typename Obj, typename... Pn> + static inline void + write(stream & s, Obj * const ptr, const Pn &... pn) { s << std::showbase << std::hex << (long unsigned int)ptr; s.copyfmt(std::ios(nullptr)); StreamWriter::next(s, pn...); } - template<typename Ptr, typename ... Pn> - static inline void write(stream & s, const Ptr & ptr, const Pn & ... pn) + template<typename Ptr, typename... Pn> + static inline void + write(stream & s, const Ptr & ptr, const Pn &... pn) { write(s, ptr.get(), pn...); } }; StreamWriterT('m') { - template<typename ... Pn> - static inline void write(stream & s, const Pn & ... pn) + template<typename... Pn> + static inline void + write(stream & s, const Pn &... pn) { s << strerror(errno); s.copyfmt(std::ios(nullptr)); @@ -92,8 +96,9 @@ namespace AdHoc { } }; StreamWriterT('n') { - template<typename ... Pn> - static inline void write(stream & s, int * n, const Pn & ... pn) + template<typename... Pn> + static inline void + write(stream & s, int * n, const Pn &... pn) { BOOST_ASSERT_MSG(n, "%n conversion requires non-null parameter"); *n = streamLength(s); @@ -104,24 +109,36 @@ namespace AdHoc { //// // Width/precision embedded in format string - template<auto ... chs> - constexpr auto decdigits() + template<auto... chs> + constexpr auto + decdigits() { static_assert((isdigit(chs) && ... && true)); int n = 0; - ([&n](auto ch) { - n = (n * 10) + (ch - '0'); - }(chs), ...); + ( + [&n](auto ch) { + n = (n * 10) + (ch - '0'); + }(chs), + ...); return n; } -#define AUTON(z, n, data) BOOST_PP_COMMA_IF(n) auto BOOST_PP_CAT(data, n) -#define NS(z, n, data) BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(data, n) -#define ISDIGIT(z, n, data) && isdigit(BOOST_PP_CAT(data, BOOST_PP_ADD(n, 1))) +#define AUTON(z, n, data) \ + BOOST_PP_COMMA_IF(n) \ + auto BOOST_PP_CAT(data, n) +#define NS(z, n, data) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_PP_CAT(data, n) +#define ISDIGIT(z, n, data) &&isdigit(BOOST_PP_CAT(data, BOOST_PP_ADD(n, 1))) #define FMTWIDTH(unused, d, data) \ - template<CtfString S, auto L, auto pos, typename stream, BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), AUTON, n), auto nn, auto ... sn> \ - struct StreamWriter<S, L, pos, stream, typename std::enable_if<ispositivedigit(n0) BOOST_PP_REPEAT(d, ISDIGIT, n) && !isdigit(nn)>::type, '%', BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), NS, n), nn, sn...> { \ - template<typename ... Pn> \ - static inline void write(stream & s, const Pn & ... pn) { \ + template<CtfString S, auto L, auto pos, typename stream, BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), AUTON, n), auto nn, \ + auto... sn> \ + struct StreamWriter<S, L, pos, stream, \ + typename std::enable_if<ispositivedigit(n0) BOOST_PP_REPEAT(d, ISDIGIT, n) && !isdigit(nn)>::type, '%', \ + BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), NS, n), nn, sn...> { \ + template<typename... Pn> \ + static inline void \ + write(stream & s, const Pn &... pn) \ + { \ constexpr auto p = decdigits<BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), NS, n)>(); \ s << std::setw(p); \ StreamWriter<S, L, pos + BOOST_PP_ADD(d, 1), stream, void, '%', nn, sn...>::write(s, pn...); \ @@ -129,10 +146,15 @@ namespace AdHoc { }; BOOST_PP_REPEAT(6, FMTWIDTH, void); #define FMTPRECISION(unused, d, data) \ - template<CtfString S, auto L, auto pos, typename stream, BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), AUTON, n), auto nn, auto ... sn> \ - struct StreamWriter<S, L, pos, stream, typename std::enable_if<isdigit(n0) BOOST_PP_REPEAT(d, ISDIGIT, n) && !isdigit(nn)>::type, '%', '.', BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), NS, n), nn, sn...> { \ - template<typename ... Pn> \ - static inline void write(stream & s, const Pn & ... pn) { \ + template<CtfString S, auto L, auto pos, typename stream, BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), AUTON, n), auto nn, \ + auto... sn> \ + struct StreamWriter<S, L, pos, stream, \ + typename std::enable_if<isdigit(n0) BOOST_PP_REPEAT(d, ISDIGIT, n) && !isdigit(nn)>::type, '%', '.', \ + BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), NS, n), nn, sn...> { \ + template<typename... Pn> \ + static inline void \ + write(stream & s, const Pn &... pn) \ + { \ constexpr auto p = decdigits<BOOST_PP_REPEAT(BOOST_PP_ADD(d, 1), NS, n)>(); \ s << std::setprecision(p); \ StreamWriter<S, L, pos + BOOST_PP_ADD(d, 2), stream, void, '%', nn, sn...>::write(s, pn...); \ @@ -145,16 +167,18 @@ namespace AdHoc { #undef FMTWIDTH StreamWriterT('.', '*') { - template<typename ... Pn> - static inline void write(stream & s, int l, const Pn & ... pn) + template<typename... Pn> + static inline void + write(stream & s, int l, const Pn &... pn) { s << std::setw(l); StreamWriter<S, L, pos + 2, stream, void, '%', sn...>::write(s, pn...); } }; StreamWriterT('.', '*', 's') { - template<typename ... Pn> - static inline void write(stream & s, int l, const std::string_view & p, const Pn & ... pn) + template<typename... Pn> + static inline void + write(stream & s, int l, const std::string_view & p, const Pn &... pn) { s << p.substr(0, l); s.copyfmt(std::ios(nullptr)); @@ -162,10 +186,13 @@ namespace AdHoc { } }; - // Flags + // Flags #define FLAGCONV(OP, ...) \ StreamWriterT(__VA_ARGS__) { \ - template<typename ... Pn> static inline void write(stream & s, const Pn & ... pn) { \ + template<typename... Pn> \ + static inline void \ + write(stream & s, const Pn &... pn) \ + { \ OP; \ StreamWriter<S, L, pos + 1, stream, void, '%', sn...>::write(s, pn...); \ } \ @@ -179,4 +206,3 @@ namespace AdHoc { } #endif - diff --git a/libadhocutil/curlHandle.cpp b/libadhocutil/curlHandle.cpp index a976410..3974f34 100644 --- a/libadhocutil/curlHandle.cpp +++ b/libadhocutil/curlHandle.cpp @@ -1,137 +1,136 @@ #include "curlHandle.h" -#include <net.h> -#include <boost/numeric/conversion/cast.hpp> #include "compileTimeFormatter.h" +#include <boost/numeric/conversion/cast.hpp> +#include <net.h> namespace AdHoc::Net { -static void cleanup() __attribute__((destructor)); -static void cleanup() -{ - curl_global_cleanup(); -} - -CurlHandle::CurlHandle(const std::string & url) : - curl_handle(curl_easy_init()), - curl_headers(nullptr), - postS(nullptr), postE(nullptr) -{ - curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str()); - curl_easy_setopt(curl_handle, CURLOPT_FAILONERROR, 1); -} + static void cleanup() __attribute__((destructor)); + static void + cleanup() + { + curl_global_cleanup(); + } -CurlHandle::~CurlHandle() -{ - if (curl_headers) { - curl_slist_free_all(curl_headers); + CurlHandle::CurlHandle(const std::string & url) : + curl_handle(curl_easy_init()), curl_headers(nullptr), postS(nullptr), postE(nullptr) + { + curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str()); + curl_easy_setopt(curl_handle, CURLOPT_FAILONERROR, 1); } - if (postS) { - curl_formfree(postS); + + CurlHandle::~CurlHandle() + { + if (curl_headers) { + curl_slist_free_all(curl_headers); + } + if (postS) { + curl_formfree(postS); + } + curl_easy_cleanup(curl_handle); } - curl_easy_cleanup(curl_handle); -} -template <> -void -CurlHandle::setopt(CURLoption opt, const void * val) -{ - curl_easy_setopt(curl_handle, opt, val); -} + template<> + void + CurlHandle::setopt(CURLoption opt, const void * val) + { + curl_easy_setopt(curl_handle, opt, val); + } -template <> -void -CurlHandle::setopt(CURLoption opt, int val) -{ - curl_easy_setopt(curl_handle, opt, val); -} + template<> + void + CurlHandle::setopt(CURLoption opt, int val) + { + curl_easy_setopt(curl_handle, opt, val); + } -template <> -void -CurlHandle::setopt(CURLoption opt, long val) -{ - curl_easy_setopt(curl_handle, opt, val); -} + template<> + void + CurlHandle::setopt(CURLoption opt, long val) + { + curl_easy_setopt(curl_handle, opt, val); + } -void -CurlHandle::getinfo(CURLINFO info, long & val) const -{ - curl_easy_getinfo(curl_handle, info, &val); -} + void + CurlHandle::getinfo(CURLINFO info, long & val) const + { + curl_easy_getinfo(curl_handle, info, &val); + } -void -CurlHandle::getinfo(CURLINFO info, int & ival) const -{ - long val; - curl_easy_getinfo(curl_handle, info, &val); - ival = boost::numeric_cast<int>(val); -} + void + CurlHandle::getinfo(CURLINFO info, int & ival) const + { + long val; + curl_easy_getinfo(curl_handle, info, &val); + ival = boost::numeric_cast<int>(val); + } -void -CurlHandle::getinfo(CURLINFO info, double & val) const -{ - curl_easy_getinfo(curl_handle, info, &val); -} + void + CurlHandle::getinfo(CURLINFO info, double & val) const + { + curl_easy_getinfo(curl_handle, info, &val); + } -void -CurlHandle::getinfo(CURLINFO info, char * & val) const -{ - curl_easy_getinfo(curl_handle, info, &val); -} + void + CurlHandle::getinfo(CURLINFO info, char *& val) const + { + curl_easy_getinfo(curl_handle, info, &val); + } -void -CurlHandle::appendHeader(const char * header) -{ - curl_headers = curl_slist_append(curl_headers, header); -} + void + CurlHandle::appendHeader(const char * header) + { + curl_headers = curl_slist_append(curl_headers, header); + } -void -CurlHandle::appendPost(const char * name, const char * value) -{ - CURLFORMcode r = curl_formadd(&postS, &postE, CURLFORM_PTRNAME, name, CURLFORM_PTRCONTENTS, value, CURLFORM_END); - if (r == 0) { - curl_easy_setopt(curl_handle, CURLOPT_HTTPPOST, postS); + void + CurlHandle::appendPost(const char * name, const char * value) + { + CURLFORMcode r + = curl_formadd(&postS, &postE, CURLFORM_PTRNAME, name, CURLFORM_PTRCONTENTS, value, CURLFORM_END); + if (r == 0) { + curl_easy_setopt(curl_handle, CURLOPT_HTTPPOST, postS); + } } -} -void -CurlHandle::perform() -{ - if (curl_headers) { - curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, curl_headers); + void + CurlHandle::perform() + { + if (curl_headers) { + curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, curl_headers); + } + checkCurlCode(curl_easy_perform(curl_handle)); } - checkCurlCode(curl_easy_perform(curl_handle)); -} -CurlHandle::operator CURL *() const -{ - return curl_handle; -} + CurlHandle::operator CURL *() const + { + return curl_handle; + } -void -CurlHandle::checkCurlCode(CURLcode res) const -{ - if (res != CURLE_OK) { - long http_code = 0; - if (curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &http_code) == CURLE_OK) { - throw AdHoc::Net::CurlException(res, curl_easy_strerror(res), http_code); + void + CurlHandle::checkCurlCode(CURLcode res) const + { + if (res != CURLE_OK) { + long http_code = 0; + if (curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &http_code) == CURLE_OK) { + throw AdHoc::Net::CurlException(res, curl_easy_strerror(res), http_code); + } + throw AdHoc::Net::CurlException(res, curl_easy_strerror(res), IceUtil::None); } - throw AdHoc::Net::CurlException(res, curl_easy_strerror(res), IceUtil::None); } -} -AdHocFormatter(CurlExceptionMsg, "Network operation failed: %? (%?)"); -AdHocFormatter(CurlExceptionMsgHttp, "HTTP operation failed: %?: %? (%?)"); + AdHocFormatter(CurlExceptionMsg, "Network operation failed: %? (%?)"); + AdHocFormatter(CurlExceptionMsgHttp, "HTTP operation failed: %?: %? (%?)"); -void -CurlException::ice_print(std::ostream & s) const -{ - if (httpcode) { - CurlExceptionMsgHttp::write(s, *httpcode, message, resultcode); - } - else { - CurlExceptionMsg::write(s, message, resultcode); + void + CurlException::ice_print(std::ostream & s) const + { + if (httpcode) { + CurlExceptionMsgHttp::write(s, *httpcode, message, resultcode); + } + else { + CurlExceptionMsg::write(s, message, resultcode); + } } -} } - diff --git a/libadhocutil/curlHandle.h b/libadhocutil/curlHandle.h index c9e8f58..dd8e595 100644 --- a/libadhocutil/curlHandle.h +++ b/libadhocutil/curlHandle.h @@ -1,76 +1,72 @@ #ifndef ADHOCUTIL_CURLHANDLE_H #define ADHOCUTIL_CURLHANDLE_H +#include "c++11Helpers.h" +#include "visibility.h" #include <curl/curl.h> #include <memory> -#include "visibility.h" -#include "c++11Helpers.h" namespace AdHoc { -namespace Net { + namespace Net { -/// libcurl handle wrapper. -/** Wraps a libcurl CURL * object in a C++ friendly manner. */ -class DLL_PUBLIC CurlHandle { - public: - /** - * Create a new CurlHandle. - * @param url Set the required CURLOPT_URL property to the given url. - */ - explicit CurlHandle(const std::string & url); - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(CurlHandle); - virtual ~CurlHandle(); + /// libcurl handle wrapper. + /** Wraps a libcurl CURL * object in a C++ friendly manner. */ + class DLL_PUBLIC CurlHandle { + public: + /** + * Create a new CurlHandle. + * @param url Set the required CURLOPT_URL property to the given url. + */ + explicit CurlHandle(const std::string & url); + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(CurlHandle); + virtual ~CurlHandle(); - /** Set option wrapper. */ - template <typename T> - void setopt(CURLoption opt, const T val); - /** Get info for long values */ - void getinfo(CURLINFO info, long & val) const; - /** Get info for int values (avoids ambiguous call errors for ease of use) */ - void getinfo(CURLINFO info, int & val) const; - /** Get info for double values */ - void getinfo(CURLINFO info, double & val) const; - /** Get info for char * values */ - void getinfo(CURLINFO info, char * & val) const; - /** Append the given HTTP header */ - void appendHeader(const char *); - /** Append the given HTTP post content */ - void appendPost(const char *, const char *); - /** Perform the CURL transfer. */ - void perform(); + /** Set option wrapper. */ + template<typename T> void setopt(CURLoption opt, const T val); + /** Get info for long values */ + void getinfo(CURLINFO info, long & val) const; + /** Get info for int values (avoids ambiguous call errors for ease of use) */ + void getinfo(CURLINFO info, int & val) const; + /** Get info for double values */ + void getinfo(CURLINFO info, double & val) const; + /** Get info for char * values */ + void getinfo(CURLINFO info, char *& val) const; + /** Append the given HTTP header */ + void appendHeader(const char *); + /** Append the given HTTP post content */ + void appendPost(const char *, const char *); + /** Perform the CURL transfer. */ + void perform(); - /** Get the underlying CURL * handle. @warning Make changes at your own risk. */ - // NOLINTNEXTLINE(hicpp-explicit-conversions) - operator CURL *() const; + /** Get the underlying CURL * handle. @warning Make changes at your own risk. */ + // NOLINTNEXTLINE(hicpp-explicit-conversions) + operator CURL *() const; - protected: - /// @cond - void checkCurlCode(CURLcode res) const; + protected: + /// @cond + void checkCurlCode(CURLcode res) const; - CURL * curl_handle; - curl_slist * curl_headers; - curl_httppost * postS, * postE; - /// @endcond -}; -using CurlHandlePtr = std::shared_ptr<CurlHandle>; + CURL * curl_handle; + curl_slist * curl_headers; + curl_httppost *postS, *postE; + /// @endcond + }; + using CurlHandlePtr = std::shared_ptr<CurlHandle>; -/// @cond -template <> -void CurlHandle::setopt(CURLoption opt, const void * val); -template <> -void CurlHandle::setopt(CURLoption opt, int val); -template <> -void CurlHandle::setopt(CURLoption opt, long val); -template <typename T> -void CurlHandle::setopt(CURLoption opt, const T val) -{ - setopt(opt, (const void *)val); -} -/// @endcond + /// @cond + template<> void CurlHandle::setopt(CURLoption opt, const void * val); + template<> void CurlHandle::setopt(CURLoption opt, int val); + template<> void CurlHandle::setopt(CURLoption opt, long val); + template<typename T> + void + CurlHandle::setopt(CURLoption opt, const T val) + { + setopt(opt, (const void *)val); + } + /// @endcond -} + } } #endif - diff --git a/libadhocutil/curlMultiHandle.cpp b/libadhocutil/curlMultiHandle.cpp index 5db8c3f..a4a3c0c 100644 --- a/libadhocutil/curlMultiHandle.cpp +++ b/libadhocutil/curlMultiHandle.cpp @@ -1,20 +1,20 @@ #include "curlMultiHandle.h" +#include "curlStream.h" +#include "runtimeContext.h" #include <boost/iostreams/stream.hpp> #include <map> -#include "runtimeContext.h" -#include "curlStream.h" namespace AdHoc::Net { -class RunningCurl : public CurlStreamSource { + class RunningCurl : public CurlStreamSource { public: RunningCurl(const std::string & url, std::function<void(std::istream &)> c) : - CurlStreamSource(url), - consumer(std::move(c)) + CurlStreamSource(url), consumer(std::move(c)) { } - void callback() override + void + callback() override { using rc_ref = boost::reference_wrapper<RunningCurl>; boost::iostreams::stream<rc_ref> curlstrm(std::ref(*this)); @@ -23,73 +23,72 @@ class RunningCurl : public CurlStreamSource { private: const std::function<void(std::istream &)> consumer; -}; + }; -CurlMultiHandle::CurlMultiHandle() = default; + CurlMultiHandle::CurlMultiHandle() = default; -CurlMultiHandle::~CurlMultiHandle() = default; + CurlMultiHandle::~CurlMultiHandle() = default; -CurlHandlePtr -CurlMultiHandle::addCurl(const std::string & url, const std::function<void(std::istream &)> & c) -{ - return *curls.insert(std::make_shared<RunningCurl>(url, c)).first; -} + CurlHandlePtr + CurlMultiHandle::addCurl(const std::string & url, const std::function<void(std::istream &)> & c) + { + return *curls.insert(std::make_shared<RunningCurl>(url, c)).first; + } -void -CurlMultiHandle::addRunner(CURLM * curlm, Running & running, CurlMultiHandle::CURLs & curls) -{ - auto runner = *curls.begin(); - curl_multi_add_handle(curlm, *runner); - running[*runner] = runner; - runner->swapContext(); - curls.erase(runner); -} + void + CurlMultiHandle::addRunner(CURLM * curlm, Running & running, CurlMultiHandle::CURLs & curls) + { + auto runner = *curls.begin(); + curl_multi_add_handle(curlm, *runner); + running[*runner] = runner; + runner->swapContext(); + curls.erase(runner); + } -void -CurlMultiHandle::performAll() -{ - if (!curls.empty()) { - Running running; - CURLM * curlm = curl_multi_init(); + void + CurlMultiHandle::performAll() + { + if (!curls.empty()) { + Running running; + CURLM * curlm = curl_multi_init(); - while (!curls.empty() && running.size() < 5) { - addRunner(curlm, running, curls); - } - int act = running.size(); - while (act) { - while (curl_multi_perform(curlm, &act) == CURLM_CALL_MULTI_PERFORM) {} - // Has anything finished - CURLMsg * msg; - int msgs = 0; - while ((msg = curl_multi_info_read(curlm, &msgs))) { - if (msg->msg == CURLMSG_DONE) { - curl_multi_remove_handle(curlm, msg->easy_handle); - auto ri = running.find(msg->easy_handle); - ri->second->res = msg->data.result; - ri->second->swapContext(); - running.erase(ri); - if (!curls.empty()) { - addRunner(curlm, running, curls); - act += 1; + while (!curls.empty() && running.size() < 5) { + addRunner(curlm, running, curls); + } + int act = running.size(); + while (act) { + while (curl_multi_perform(curlm, &act) == CURLM_CALL_MULTI_PERFORM) { } + // Has anything finished + CURLMsg * msg; + int msgs = 0; + while ((msg = curl_multi_info_read(curlm, &msgs))) { + if (msg->msg == CURLMSG_DONE) { + curl_multi_remove_handle(curlm, msg->easy_handle); + auto ri = running.find(msg->easy_handle); + ri->second->res = msg->data.result; + ri->second->swapContext(); + running.erase(ri); + if (!curls.empty()) { + addRunner(curlm, running, curls); + act += 1; + } } } + // Wait for something to happen + fd_set r, w, e; + int maxfd = 0; + struct timeval to = {0, 100000}; + // NOLINTNEXTLINE(hicpp-no-assembler) + FD_ZERO(&r); + // NOLINTNEXTLINE(hicpp-no-assembler) + FD_ZERO(&w); + // NOLINTNEXTLINE(hicpp-no-assembler) + FD_ZERO(&e); + curl_multi_fdset(curlm, &r, &w, &e, &maxfd); + select(act, &r, &w, &e, &to); } - // Wait for something to happen - fd_set r, w, e; - int maxfd = 0; - struct timeval to = { 0, 100000 }; - // NOLINTNEXTLINE(hicpp-no-assembler) - FD_ZERO(&r); - // NOLINTNEXTLINE(hicpp-no-assembler) - FD_ZERO(&w); - // NOLINTNEXTLINE(hicpp-no-assembler) - FD_ZERO(&e); - curl_multi_fdset(curlm, &r, &w, &e, &maxfd); - select(act, &r, &w, &e, &to); + curl_multi_cleanup(curlm); } - curl_multi_cleanup(curlm); } -} } - diff --git a/libadhocutil/curlMultiHandle.h b/libadhocutil/curlMultiHandle.h index 5308fb3..2116565 100644 --- a/libadhocutil/curlMultiHandle.h +++ b/libadhocutil/curlMultiHandle.h @@ -1,49 +1,48 @@ #ifndef ADHOCUTIL_CURLMULTIHANDLE_H #define ADHOCUTIL_CURLMULTIHANDLE_H +#include "c++11Helpers.h" +#include "curlHandle.h" +#include "visibility.h" #include <functional> -#include <set> #include <map> #include <memory> -#include "visibility.h" -#include "curlHandle.h" -#include "c++11Helpers.h" +#include <set> namespace AdHoc { -namespace Net { + namespace Net { -class RunningCurl; -using RunningCurlPtr = std::shared_ptr<RunningCurl>; + class RunningCurl; + using RunningCurlPtr = std::shared_ptr<RunningCurl>; -/// Perform multiple CURL operations at once. -class DLL_PUBLIC CurlMultiHandle { - public: - /** A function that should consume the inbound byte stream. */ - using Consumer = std::function<void(std::istream &)>; + /// Perform multiple CURL operations at once. + class DLL_PUBLIC CurlMultiHandle { + public: + /** A function that should consume the inbound byte stream. */ + using Consumer = std::function<void(std::istream &)>; - CurlMultiHandle(); - ~CurlMultiHandle(); + CurlMultiHandle(); + ~CurlMultiHandle(); - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(CurlMultiHandle); + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(CurlMultiHandle); - /** Adds a new consumer for the given URL to the set of operations to perform. */ - CurlHandlePtr addCurl(const std::string &, const Consumer &); - /** Perform all queued operations. */ - void performAll(); + /** Adds a new consumer for the given URL to the set of operations to perform. */ + CurlHandlePtr addCurl(const std::string &, const Consumer &); + /** Perform all queued operations. */ + void performAll(); - private: - using CURLs = std::set<RunningCurlPtr>; - using Running = std::map<CURL *, RunningCurlPtr>; + private: + using CURLs = std::set<RunningCurlPtr>; + using Running = std::map<CURL *, RunningCurlPtr>; - DLL_PRIVATE void addRunner(CURLM * curlm, Running & running, CURLs & curls); + DLL_PRIVATE void addRunner(CURLM * curlm, Running & running, CURLs & curls); - CURLs curls; -}; -using CurlMultiHandlePtr = std::shared_ptr<CurlMultiHandle>; + CURLs curls; + }; + using CurlMultiHandlePtr = std::shared_ptr<CurlMultiHandle>; -} + } } #endif - diff --git a/libadhocutil/curlStream.cpp b/libadhocutil/curlStream.cpp index 6784675..8f129d7 100644 --- a/libadhocutil/curlStream.cpp +++ b/libadhocutil/curlStream.cpp @@ -2,58 +2,54 @@ namespace AdHoc::Net { -CurlStreamSource::CurlStreamSource(const std::string & url) : - CurlHandle(url), - buflen(0), - buf(nullptr), - res(CURLE_OK) -{ - curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, &CurlStreamSource::recvWrapper); - curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, this); -} + CurlStreamSource::CurlStreamSource(const std::string & url) : + CurlHandle(url), buflen(0), buf(nullptr), res(CURLE_OK) + { + curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, &CurlStreamSource::recvWrapper); + curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, this); + } -AdHoc::Net::CurlStreamSource::~CurlStreamSource() = default; + AdHoc::Net::CurlStreamSource::~CurlStreamSource() = default; -std::streamsize -CurlStreamSource::read(char * target, std::streamsize targetSize) -{ - if (!buflen) { - swapContext(); - checkCurlCode(res); + std::streamsize + CurlStreamSource::read(char * target, std::streamsize targetSize) + { if (!buflen) { - return 0; + swapContext(); + checkCurlCode(res); + if (!buflen) { + return 0; + } } + size_t bytes = std::min<size_t>(buflen, targetSize); + memcpy(target, buf, bytes); + buflen -= bytes; + buf += bytes; + return bytes; } - size_t bytes = std::min<size_t>(buflen, targetSize); - memcpy(target, buf, bytes); - buflen -= bytes; - buf += bytes; - return bytes; -} -void -CurlStreamSource::callback() -{ - if (curl_headers) { - curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, curl_headers); + void + CurlStreamSource::callback() + { + if (curl_headers) { + curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, curl_headers); + } + res = curl_easy_perform(curl_handle); } - res = curl_easy_perform(curl_handle); -} -size_t -CurlStreamSource::recvWrapper(void * data, size_t sz, size_t nm, void * css) -{ - return static_cast<CurlStreamSource *>(css)->recv(data, sz * nm); -} + size_t + CurlStreamSource::recvWrapper(void * data, size_t sz, size_t nm, void * css) + { + return static_cast<CurlStreamSource *>(css)->recv(data, sz * nm); + } -size_t -CurlStreamSource::recv(void * data, size_t datalen) -{ - buf = (char *)data; - buflen = datalen; - swapContext(); - return datalen; -} + size_t + CurlStreamSource::recv(void * data, size_t datalen) + { + buf = (char *)data; + buflen = datalen; + swapContext(); + return datalen; + } } - diff --git a/libadhocutil/curlStream.h b/libadhocutil/curlStream.h index 9361fd8..64fb38e 100644 --- a/libadhocutil/curlStream.h +++ b/libadhocutil/curlStream.h @@ -1,45 +1,47 @@ #ifndef ADHOCUTIL_CURLSTREAM_H #define ADHOCUTIL_CURLSTREAM_H -#include <boost/iostreams/stream.hpp> +#include "c++11Helpers.h" +#include "curlHandle.h" #include "runtimeContext.h" -#include <string> -#include <curl/curl.h> #include "visibility.h" -#include "curlHandle.h" -#include "c++11Helpers.h" +#include <boost/iostreams/stream.hpp> +#include <curl/curl.h> +#include <string> namespace AdHoc { -namespace Net { - -/// boost::iostreams::source implementation for CURL downloads. -class DLL_PUBLIC CurlStreamSource : public boost::iostreams::source, public CurlHandle, ::AdHoc::System::RuntimeContext { - public: - /** Construct a new stream source for the given URL. */ - explicit CurlStreamSource(const std::string & url); - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(CurlStreamSource); - ~CurlStreamSource() override; - - /** Required member function for reading of the stream source by boost::iostreams::stream. */ - std::streamsize read(char * target, std::streamsize targetSize); - - private: - friend class CurlMultiHandle; - DLL_PRIVATE void callback() override; - - DLL_PRIVATE static size_t recvWrapper(void * data, size_t sz, size_t nm, void * css); - DLL_PRIVATE size_t recv(void * data, size_t datalen); - - size_t buflen; - char * buf; - CURLcode res; -}; - -using CurlStream = boost::iostreams::stream<boost::reference_wrapper<CurlStreamSource>>; - -} + namespace Net { + + /// boost::iostreams::source implementation for CURL downloads. + class DLL_PUBLIC CurlStreamSource : + public boost::iostreams::source, + public CurlHandle, + ::AdHoc::System::RuntimeContext { + public: + /** Construct a new stream source for the given URL. */ + explicit CurlStreamSource(const std::string & url); + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(CurlStreamSource); + ~CurlStreamSource() override; + + /** Required member function for reading of the stream source by boost::iostreams::stream. */ + std::streamsize read(char * target, std::streamsize targetSize); + + private: + friend class CurlMultiHandle; + DLL_PRIVATE void callback() override; + + DLL_PRIVATE static size_t recvWrapper(void * data, size_t sz, size_t nm, void * css); + DLL_PRIVATE size_t recv(void * data, size_t datalen); + + size_t buflen; + char * buf; + CURLcode res; + }; + + using CurlStream = boost::iostreams::stream<boost::reference_wrapper<CurlStreamSource>>; + + } } #endif - diff --git a/libadhocutil/definedDirs.h b/libadhocutil/definedDirs.h index accb663..d746891 100644 --- a/libadhocutil/definedDirs.h +++ b/libadhocutil/definedDirs.h @@ -4,7 +4,7 @@ #include <filesystem> #ifndef ROOT -#error "ROOT needs to be defined at compilation time" +# error "ROOT needs to be defined at compilation time" #endif #define XSTR(s) STR(s) @@ -14,4 +14,3 @@ const std::filesystem::path binDir = selfExe.parent_path(); const std::filesystem::path rootDir(XSTR(ROOT)); #endif - diff --git a/libadhocutil/exception.h b/libadhocutil/exception.h index 2152446..e41796c 100644 --- a/libadhocutil/exception.h +++ b/libadhocutil/exception.h @@ -2,35 +2,33 @@ #define ADHOCUTIL_EXCEPTION_H #include <exception> -#include <string> #include <optional> +#include <string> namespace AdHoc { /// Helper class for lazy creation of exception message text. - template <typename BaseException> - class Exception : public BaseException { - public: - /// Wrapper constructor to pass to BaseException - //@param t parameters to pass. - template <typename ... T> - explicit Exception(const T & ... t) : BaseException(t...) { } + template<typename BaseException> class Exception : public BaseException { + public: + /// Wrapper constructor to pass to BaseException + //@param t parameters to pass. + template<typename... T> explicit Exception(const T &... t) : BaseException(t...) { } - /// Override of std::exception::what() to create text as required. - inline const char * what() const noexcept override - { - if (!msg) { - msg = message(); - } - return msg->c_str(); + /// Override of std::exception::what() to create text as required. + inline const char * + what() const noexcept override + { + if (!msg) { + msg = message(); } + return msg->c_str(); + } - private: - /// Message text provider. - virtual std::string message() const noexcept = 0; - mutable std::optional<std::string> msg; + private: + /// Message text provider. + virtual std::string message() const noexcept = 0; + mutable std::optional<std::string> msg; }; using StdException = Exception<std::exception>; } #endif - diff --git a/libadhocutil/factory.h b/libadhocutil/factory.h index 3bd3f19..a2a49ed 100644 --- a/libadhocutil/factory.h +++ b/libadhocutil/factory.h @@ -8,51 +8,46 @@ namespace AdHoc { /** * Base class for factories creating instances of Base. */ - template <typename Base, typename ... Params> - class DLL_PUBLIC Factory : public virtual AbstractPluginImplementation { + template<typename Base, typename... Params> class DLL_PUBLIC Factory : public virtual AbstractPluginImplementation { + public: + /** + * Create a new instance of Base, overridden in a subclass to construct a new specific class. + * @param p The parameters passed to Impl constructor. + */ + [[nodiscard]] virtual std::shared_ptr<Base> create(const Params &... p) const = 0; + + /** + * A factory for a concrete implementation of Base + */ + template<typename Impl, typename _ = Factory<Base, Params...>> class DLL_PUBLIC For : public _ { public: /** - * Create a new instance of Base, overridden in a subclass to construct a new specific class. + * Create a new instance of Base implemented in Impl. * @param p The parameters passed to Impl constructor. */ - [[nodiscard]] virtual std::shared_ptr<Base> create(const Params & ... p) const = 0; - - /** - * A factory for a concrete implementation of Base - */ - template <typename Impl, typename _ = Factory<Base, Params...>> - class DLL_PUBLIC For : public _ + [[nodiscard]] std::shared_ptr<Base> + create(const Params &... p) const override { - public: - /** - * Create a new instance of Base implemented in Impl. - * @param p The parameters passed to Impl constructor. - */ - [[nodiscard]] std::shared_ptr<Base> create(const Params & ... p) const override - { - return std::make_shared<Impl>(p...); - } - }; - - /** - * Helper to get the factory for a specific implementation. - * @param name The name of the implementation. - */ - [[nodiscard]] static std::shared_ptr<const Factory> get(const std::string_view & name); - /** - * Helper to create a new instance from a specific factory. - * @param name The name of the implementation. - * @param p The parameters to pass to the constructor. - */ - [[nodiscard]] static std::shared_ptr<Base> createNew(const std::string_view & name, const Params & ... p); + return std::make_shared<Impl>(p...); + } + }; + + /** + * Helper to get the factory for a specific implementation. + * @param name The name of the implementation. + */ + [[nodiscard]] static std::shared_ptr<const Factory> get(const std::string_view & name); + /** + * Helper to create a new instance from a specific factory. + * @param name The name of the implementation. + * @param p The parameters to pass to the constructor. + */ + [[nodiscard]] static std::shared_ptr<Base> createNew(const std::string_view & name, const Params &... p); }; } -#define NAMEDFACTORY(Name, Implementation, BaseFactory) \ - NAMEDPLUGIN(Name, BaseFactory::For<Implementation>, BaseFactory) +#define NAMEDFACTORY(Name, Implementation, BaseFactory) NAMEDPLUGIN(Name, BaseFactory::For<Implementation>, BaseFactory) -#define FACTORY(Implementation, BaseFactory) \ - NAMEDFACTORY(#Implementation, Implementation, BaseFactory) +#define FACTORY(Implementation, BaseFactory) NAMEDFACTORY(#Implementation, Implementation, BaseFactory) #endif - diff --git a/libadhocutil/factory.impl.h b/libadhocutil/factory.impl.h index 6f3cb5a..2010836 100644 --- a/libadhocutil/factory.impl.h +++ b/libadhocutil/factory.impl.h @@ -5,16 +5,16 @@ #include "plugins.impl.h" namespace AdHoc { - template <typename Base, typename ... Params> + template<typename Base, typename... Params> std::shared_ptr<const Factory<Base, Params...>> Factory<Base, Params...>::get(const std::string_view & name) { return PluginManager::getDefault()->get<Factory>(name)->implementation(); } - template <typename Base, typename ... Params> + template<typename Base, typename... Params> std::shared_ptr<Base> - Factory<Base, Params...>::createNew(const std::string_view & name, const Params & ... p) + Factory<Base, Params...>::createNew(const std::string_view & name, const Params &... p) { return get(name)->create(p...); } @@ -29,4 +29,3 @@ namespace AdHoc { INSTANTIATEPLUGINOF(AdHoc::Factory<Base, __VA_ARGS__>) #endif - diff --git a/libadhocutil/fileUtils.cpp b/libadhocutil/fileUtils.cpp index b4d39b4..2d815a5 100644 --- a/libadhocutil/fileUtils.cpp +++ b/libadhocutil/fileUtils.cpp @@ -1,14 +1,15 @@ #include "fileUtils.h" #include "compileTimeFormatter.h" -#include <unistd.h> +#include <boost/assert.hpp> #include <sys.h> #include <sys/mman.h> -#include <boost/assert.hpp> +#include <unistd.h> namespace AdHoc::FileUtils { AdHocFormatter(FD, "FD %?"); - std::filesystem::path operator/(const std::filesystem::path & p, unsigned int n) + std::filesystem::path + operator/(const std::filesystem::path & p, unsigned int n) { auto pp = p.begin(); while (n--) { @@ -17,13 +18,9 @@ namespace AdHoc::FileUtils { return *pp; } - FileHandle::FileHandle(int d) noexcept : - fh(d) - { - } + FileHandle::FileHandle(int d) noexcept : fh(d) { } - FileHandle::FileHandle(FileHandle && o) noexcept : - fh(o.fh) + FileHandle::FileHandle(FileHandle && o) noexcept : fh(o.fh) { const_cast<int &>(o.fh) = -1; } @@ -36,8 +33,7 @@ namespace AdHoc::FileUtils { return *this; } - FileHandle::FileHandle(const std::filesystem::path & path, int flags) : - fh(open(path.c_str(), flags)) + FileHandle::FileHandle(const std::filesystem::path & path, int flags) : fh(open(path.c_str(), flags)) { if (fh < 0) { throw SystemExceptionOn("open(2) failed", strerror(errno), errno, path); @@ -64,23 +60,18 @@ namespace AdHoc::FileUtils { return fh; } - FileHandleStat::FileHandleStat(int fd) : - FileHandle(fd), - st({}) + FileHandleStat::FileHandleStat(int fd) : FileHandle(fd), st({}) { refreshStat(); } - FileHandleStat::FileHandleStat(const std::filesystem::path & path, int flags) : - FileHandle(path, flags), - st({}) + FileHandleStat::FileHandleStat(const std::filesystem::path & path, int flags) : FileHandle(path, flags), st({}) { refreshStat(path); } FileHandleStat::FileHandleStat(const std::filesystem::path & path, int flags, int mode) : - FileHandle(path, flags, mode), - st({}) + FileHandle(path, flags, mode), st({}) { refreshStat(path); } @@ -112,21 +103,15 @@ namespace AdHoc::FileUtils { } } - MemMap::MemMap(int d, int flags) : - FileHandleStat(d), - data(setupMap(flags)) - { - } + MemMap::MemMap(int d, int flags) : FileHandleStat(d), data(setupMap(flags)) { } MemMap::MemMap(const std::filesystem::path & path, int flags) : - FileHandleStat(path, flags), - data(setupMap(path, flags)) + FileHandleStat(path, flags), data(setupMap(path, flags)) { } MemMap::MemMap(const std::filesystem::path & path, int flags, int mode) : - FileHandleStat(path, flags, mode), - data(setupMap(path, flags)) + FileHandleStat(path, flags, mode), data(setupMap(path, flags)) { } @@ -161,4 +146,3 @@ namespace AdHoc::FileUtils { return data; } } - diff --git a/libadhocutil/fileUtils.h b/libadhocutil/fileUtils.h index 26093e5..c162677 100644 --- a/libadhocutil/fileUtils.h +++ b/libadhocutil/fileUtils.h @@ -1,12 +1,12 @@ #ifndef ADHOCUTIL_FILEUTILS_H #define ADHOCUTIL_FILEUTILS_H -#include <filesystem> -#include <sys/stat.h> +#include "c++11Helpers.h" +#include "visibility.h" #include <fcntl.h> +#include <filesystem> #include <string_view> -#include "visibility.h" -#include "c++11Helpers.h" +#include <sys/stat.h> namespace AdHoc { namespace FileUtils { @@ -22,164 +22,163 @@ namespace AdHoc { * File handle wrapper to ensure closure on scope exit */ class DLL_PUBLIC FileHandle { - public: - /** - * Move constructor. - */ - FileHandle(FileHandle &&) noexcept; - - /** - * Construct from an existing file descriptor. - * @param fd An open file descriptor. - */ - explicit FileHandle(int fd) noexcept; - - /** - * Open a new file handle. - * @param path Path of file to open. - * @param flags File handle flags - */ - explicit FileHandle(const std::filesystem::path & path, int flags = O_RDONLY); - - /** - * Open a new file handle. - * @param path Path of file to open. - * @param flags File handle flags - * @param mode File handle mode - */ - FileHandle(const std::filesystem::path & path, int flags, int mode); - - virtual ~FileHandle() noexcept; - - /// Standard move/copy support - SPECIAL_MEMBERS_COPY(FileHandle, delete); - - /// Standard move/copy support - FileHandle & operator=(FileHandle &&) noexcept; - - /** - * Implicit conversion back to raw Unix file descriptor. - * @return The container file descriptor. - */ - // NOLINTNEXTLINE(hicpp-explicit-conversions) - operator int() const noexcept; - - /// The file handle. - const int fh; + public: + /** + * Move constructor. + */ + FileHandle(FileHandle &&) noexcept; + + /** + * Construct from an existing file descriptor. + * @param fd An open file descriptor. + */ + explicit FileHandle(int fd) noexcept; + + /** + * Open a new file handle. + * @param path Path of file to open. + * @param flags File handle flags + */ + explicit FileHandle(const std::filesystem::path & path, int flags = O_RDONLY); + + /** + * Open a new file handle. + * @param path Path of file to open. + * @param flags File handle flags + * @param mode File handle mode + */ + FileHandle(const std::filesystem::path & path, int flags, int mode); + + virtual ~FileHandle() noexcept; + + /// Standard move/copy support + SPECIAL_MEMBERS_COPY(FileHandle, delete); + + /// Standard move/copy support + FileHandle & operator=(FileHandle &&) noexcept; + + /** + * Implicit conversion back to raw Unix file descriptor. + * @return The container file descriptor. + */ + // NOLINTNEXTLINE(hicpp-explicit-conversions) + operator int() const noexcept; + + /// The file handle. + const int fh; }; /** * An extension to FileHandle that automatically calls fstat on the opened handle. */ class DLL_PUBLIC FileHandleStat : public FileHandle { - public: - ~FileHandleStat() override = default; - - /** - * Construct from an existing file descriptor. - * @param fd An open file descriptor. - */ - explicit FileHandleStat(int fd); - - /** - * Open a new file handle (with the default flags). - * @param path Path of file to open. - * @param flags File handle flags - */ - explicit FileHandleStat(const std::filesystem::path & path, int flags = O_RDONLY); - - /** - * Open a new file handle. - * @param path Path of file to open. - * @param flags File handle flags - * @param mode File handle mode - */ - FileHandleStat(const std::filesystem::path & path, int flags, int mode); - - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(FileHandleStat); - - /** - * Get the stat structure. - * @return The stat structure. - */ - [[nodiscard]] const struct stat & getStat() const noexcept; - - /** - * Refresh and return the stat structure. - * @return The stat structure. - */ - const struct stat & refreshStat(); - - protected: - /// The stat structure. - struct stat st; - - private: - DLL_PRIVATE void refreshStat(const std::filesystem::path & path); + public: + ~FileHandleStat() override = default; + + /** + * Construct from an existing file descriptor. + * @param fd An open file descriptor. + */ + explicit FileHandleStat(int fd); + + /** + * Open a new file handle (with the default flags). + * @param path Path of file to open. + * @param flags File handle flags + */ + explicit FileHandleStat(const std::filesystem::path & path, int flags = O_RDONLY); + + /** + * Open a new file handle. + * @param path Path of file to open. + * @param flags File handle flags + * @param mode File handle mode + */ + FileHandleStat(const std::filesystem::path & path, int flags, int mode); + + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(FileHandleStat); + + /** + * Get the stat structure. + * @return The stat structure. + */ + [[nodiscard]] const struct stat & getStat() const noexcept; + + /** + * Refresh and return the stat structure. + * @return The stat structure. + */ + const struct stat & refreshStat(); + + protected: + /// The stat structure. + struct stat st; + + private: + DLL_PRIVATE void refreshStat(const std::filesystem::path & path); }; /** * Extension to FileHandle to automatically memmaps the file. */ class DLL_PUBLIC MemMap : public FileHandleStat { - public: - /** - * Move constructor. - */ - MemMap(MemMap &&) noexcept = default; - - /** - * Construct from an existing file descriptor. - * @param fd An open file descriptor. - * @param flags File handle flags - */ - explicit MemMap(int fd, int flags = O_RDONLY); - - /** - * Open a new file handle (with the default flags). - * @param path Path of file to open. - * @param flags File handle flags - */ - explicit MemMap(const std::filesystem::path & path, int flags = O_RDONLY); - - /** - * Open a new file handle. - * @param path Path of file to open. - * @param flags File handle flags - * @param mode File handle mode - */ - MemMap(const std::filesystem::path & path, int flags, int mode); - - ~MemMap() override; - - /// Standard move/copy support - SPECIAL_MEMBERS_COPY(MemMap, delete); - - MemMap & operator=(MemMap &&) = delete; - - /// The file data. - const void * const data; + public: + /** + * Move constructor. + */ + MemMap(MemMap &&) noexcept = default; + + /** + * Construct from an existing file descriptor. + * @param fd An open file descriptor. + * @param flags File handle flags + */ + explicit MemMap(int fd, int flags = O_RDONLY); + + /** + * Open a new file handle (with the default flags). + * @param path Path of file to open. + * @param flags File handle flags + */ + explicit MemMap(const std::filesystem::path & path, int flags = O_RDONLY); + + /** + * Open a new file handle. + * @param path Path of file to open. + * @param flags File handle flags + * @param mode File handle mode + */ + MemMap(const std::filesystem::path & path, int flags, int mode); + + ~MemMap() override; + + /// Standard move/copy support + SPECIAL_MEMBERS_COPY(MemMap, delete); + + MemMap & operator=(MemMap &&) = delete; + + /// The file data. + const void * const data; #ifdef __cpp_lib_string_view - /** - * Create a std::string_view of the mapped data. - */ - template<typename T = char> - [[nodiscard]] auto sv() const - { - return std::basic_string_view<T>((const T *)data, st.st_size / sizeof(T)); - } + /** + * Create a std::string_view of the mapped data. + */ + template<typename T = char> + [[nodiscard]] auto + sv() const + { + return std::basic_string_view<T>((const T *)data, st.st_size / sizeof(T)); + } #endif - private: - [[nodiscard]] DLL_PRIVATE void * setupMapInt(int flags) const; - [[nodiscard]] DLL_PRIVATE void * setupMap(int flags) const; - [[nodiscard]] DLL_PRIVATE void * setupMap(const std::filesystem::path & path, int flags) const; + private: + [[nodiscard]] DLL_PRIVATE void * setupMapInt(int flags) const; + [[nodiscard]] DLL_PRIVATE void * setupMap(int flags) const; + [[nodiscard]] DLL_PRIVATE void * setupMap(const std::filesystem::path & path, int flags) const; }; } } #endif - - diff --git a/libadhocutil/fprintbf.cpp b/libadhocutil/fprintbf.cpp index d46b211..db907bd 100644 --- a/libadhocutil/fprintbf.cpp +++ b/libadhocutil/fprintbf.cpp @@ -31,4 +31,3 @@ fopen(const std::filesystem::path & path, const char * mode) } return f; } - diff --git a/libadhocutil/fprintbf.h b/libadhocutil/fprintbf.h index 15366d2..63cba62 100644 --- a/libadhocutil/fprintbf.h +++ b/libadhocutil/fprintbf.h @@ -1,8 +1,8 @@ #ifndef ADHOCUTIL_FPRINTBF_H #define ADHOCUTIL_FPRINTBF_H -#include "visibility.h" #include "buffer.h" +#include "visibility.h" #include <boost/format.hpp> #include <filesystem> @@ -12,19 +12,17 @@ DLL_PUBLIC size_t fprintbf(FILE *, const boost::format &); DLL_PUBLIC FILE * fopen(const std::filesystem::path & path, const char * mode); -template <typename ... Params> -size_t inline fprintbf(FILE * f, const std::string & fmt, const Params & ... p) +template<typename... Params> size_t inline fprintbf(FILE * f, const std::string & fmt, const Params &... p) { auto bf = AdHoc::Buffer::getFormat(fmt); return fprintbf(f, bf, p...); } -template <typename Param, typename ... Params> -size_t inline fprintbf(FILE * f, boost::format & fmt, const Param & p, const Params & ... ps) +template<typename Param, typename... Params> +size_t inline fprintbf(FILE * f, boost::format & fmt, const Param & p, const Params &... ps) { fmt % p; return fprintbf(f, fmt, ps...); } #endif - diff --git a/libadhocutil/globalStatic.h b/libadhocutil/globalStatic.h index 3639237..f2443cb 100644 --- a/libadhocutil/globalStatic.h +++ b/libadhocutil/globalStatic.h @@ -8,23 +8,21 @@ namespace AdHoc { * Wrapper class for initialising/destroying a global static object via * __attribute__ constructor/destructor. */ - template<typename Object> - class GlobalStatic { - public: - /** - * Get the contained object. - * @return The object. - */ - static Object * get(); + template<typename Object> class GlobalStatic { + public: + /** + * Get the contained object. + * @return The object. + */ + static Object * get(); - private: - using Ptr = Object *; - static void createObject() __attribute__((constructor(101))); - static void deleteObject() __attribute__((destructor(101))); + private: + using Ptr = Object *; + static void createObject() __attribute__((constructor(101))); + static void deleteObject() __attribute__((destructor(101))); - inline static Ptr & instance(); + inline static Ptr & instance(); }; } #endif - diff --git a/libadhocutil/globalStatic.impl.h b/libadhocutil/globalStatic.impl.h index 13f2f72..ba121d1 100644 --- a/libadhocutil/globalStatic.impl.h +++ b/libadhocutil/globalStatic.impl.h @@ -5,26 +5,30 @@ namespace AdHoc { template<typename Object> - Object * GlobalStatic<Object>::get() + Object * + GlobalStatic<Object>::get() { return instance(); } template<typename Object> - void GlobalStatic<Object>::createObject() + void + GlobalStatic<Object>::createObject() { instance() = new Object(); } template<typename Object> - void GlobalStatic<Object>::deleteObject() + void + GlobalStatic<Object>::deleteObject() { delete instance(); instance() = nullptr; } template<typename Object> - typename GlobalStatic<Object>::Ptr & GlobalStatic<Object>::instance() + typename GlobalStatic<Object>::Ptr & + GlobalStatic<Object>::instance() { static Ptr _instance; return _instance; @@ -32,4 +36,3 @@ namespace AdHoc { }; #endif - diff --git a/libadhocutil/handle.h b/libadhocutil/handle.h index 7363183..a71859d 100644 --- a/libadhocutil/handle.h +++ b/libadhocutil/handle.h @@ -1,88 +1,110 @@ #ifndef ADHOCUTIL_HANDLE_H #define ADHOCUTIL_HANDLE_H -#include <utility> #include "c++11Helpers.h" +#include <utility> namespace AdHoc { /// A unique_ptr like construct for non-pointer objects. /// Implements RAII. - template<typename T, typename D> - class Handle { - public: - /// Constructs a Handle that owns t, to be tidied with d - Handle(T t, D d) noexcept : - inst(std::move(t)), - deleter(std::move(d)), - owning(true) - { - } + template<typename T, typename D> class Handle { + public: + /// Constructs a Handle that owns t, to be tidied with d + Handle(T t, D d) noexcept : inst(std::move(t)), deleter(std::move(d)), owning(true) { } - /// Constructs a Handle that takes over ownership of h - Handle(Handle && h) noexcept : - inst(std::move(h.inst)), - deleter(std::move(h.deleter)), - owning(h.owning) - { - h.owning = false; - } + /// Constructs a Handle that takes over ownership of h + Handle(Handle && h) noexcept : inst(std::move(h.inst)), deleter(std::move(h.deleter)), owning(h.owning) + { + h.owning = false; + } - ~Handle() - { - if (owning) { - deleter(inst); - } + ~Handle() + { + if (owning) { + deleter(inst); } + } - /// Standard special members - SPECIAL_MEMBERS_COPY(Handle, delete); + /// Standard special members + SPECIAL_MEMBERS_COPY(Handle, delete); - /// Takes over ownership of h - Handle & operator=(Handle && h) noexcept - { - if (owning) { - deleter(inst); - } - inst = std::move(h.inst); - deleter = std::move(h.deleter); - owning = h.owning; - h.owning = false; + /// Takes over ownership of h + Handle & + operator=(Handle && h) noexcept + { + if (owning) { + deleter(inst); } + inst = std::move(h.inst); + deleter = std::move(h.deleter); + owning = h.owning; + h.owning = false; + } - /// Returns a reference to the managed object. - [[nodiscard]] T & get() noexcept { return inst; } - /// Returns a const reference to the managed object. - [[nodiscard]] const T & get() const noexcept { return inst; } + /// Returns a reference to the managed object. + [[nodiscard]] T & + get() noexcept + { + return inst; + } + /// Returns a const reference to the managed object. + [[nodiscard]] const T & + get() const noexcept + { + return inst; + } - /// Returns a pointer to the managed object. - [[nodiscard]] T * operator->() noexcept { return inst; } - /// Returns a const pointer to the managed object. - [[nodiscard]] const T * operator->() const noexcept { return inst; } + /// Returns a pointer to the managed object. + [[nodiscard]] T * + operator->() noexcept + { + return inst; + } + /// Returns a const pointer to the managed object. + [[nodiscard]] const T * + operator->() const noexcept + { + return inst; + } - /// Returns a reference to the managed object. - [[nodiscard]] T & operator*() noexcept { return inst; } - /// Returns a const reference to the managed object. - [[nodiscard]] const T & operator*() const noexcept { return inst; } + /// Returns a reference to the managed object. + [[nodiscard]] T & + operator*() noexcept + { + return inst; + } + /// Returns a const reference to the managed object. + [[nodiscard]] const T & + operator*() const noexcept + { + return inst; + } - /// Returns a reference to the managed object. - // NOLINTNEXTLINE(hicpp-explicit-conversions) - operator T &() noexcept { return inst; } - /// Returns a const reference to the managed object. - // NOLINTNEXTLINE(hicpp-explicit-conversions) - operator const T &() const noexcept { return inst; } + /// Returns a reference to the managed object. + // NOLINTNEXTLINE(hicpp-explicit-conversions) + operator T &() noexcept + { + return inst; + } + /// Returns a const reference to the managed object. + // NOLINTNEXTLINE(hicpp-explicit-conversions) + operator const T &() const noexcept + { + return inst; + } - private: - T inst; - D deleter; - bool owning; + private: + T inst; + D deleter; + bool owning; }; template<typename T, typename D, typename... Args> - Handle<T, D> make_handle(D && d, Args && ... args) + Handle<T, D> + make_handle(D && d, Args &&... args) { - return { T(std::forward<Args>(args)...), std::forward<D>(d) }; + return {T(std::forward<Args>(args)...), std::forward<D>(d)}; } } #endif - diff --git a/libadhocutil/lazyPointer.h b/libadhocutil/lazyPointer.h index 9188d24..667d321 100644 --- a/libadhocutil/lazyPointer.h +++ b/libadhocutil/lazyPointer.h @@ -2,21 +2,20 @@ #define ADHOCUTIL_LAZYPOINTER_H #include <functional> -#include <variant> #include <memory> #include <ostream> +#include <variant> namespace AdHoc { -/// Smart pointer that initializes itself only if it has to. -/** - * LazyPointer behaves like a normal smarter for the most part. It's benefit - * is that it can be assigned a factory function which is only called on - * an attempt to dereference the pointer. All such operations will call - * this factory function as required prior to evaluating the pointer's value. - */ -template <typename T, typename P = std::shared_ptr<T>> -class LazyPointer { + /// Smart pointer that initializes itself only if it has to. + /** + * LazyPointer behaves like a normal smarter for the most part. It's benefit + * is that it can be assigned a factory function which is only called on + * an attempt to dereference the pointer. All such operations will call + * this factory function as required prior to evaluating the pointer's value. + */ + template<typename T, typename P = std::shared_ptr<T>> class LazyPointer { public: /// @cond using element_type = T; @@ -27,23 +26,14 @@ class LazyPointer { /** Construct pointer with a factory function. */ // NOLINTNEXTLINE(hicpp-explicit-conversions) - LazyPointer(Factory f) : - source(f) - { - } + LazyPointer(Factory f) : source(f) { } /** Construct pointer with an instance value. */ // NOLINTNEXTLINE(hicpp-explicit-conversions) - LazyPointer(P p) : - source(p) - { - } + LazyPointer(P p) : source(p) { } /** Construct pointer with no factory or value. */ - LazyPointer() : - source(P(NULL)) - { - } + LazyPointer() : source(P(NULL)) { } // Getters /// @cond @@ -52,17 +42,20 @@ class LazyPointer { return deref(); } - [[nodiscard]] T * operator->() const + [[nodiscard]] T * + operator->() const { return get(); } - [[nodiscard]] T & operator*() const + [[nodiscard]] T & + operator*() const { return *get(); } - [[nodiscard]] T * get() const + [[nodiscard]] T * + get() const { if constexpr (std::is_pointer<P>::value) { return deref(); @@ -72,7 +65,8 @@ class LazyPointer { } } - [[nodiscard]] P deref() const + [[nodiscard]] P + deref() const { if (Factory * f = std::get_if<Factory>(&source)) { P p = (*f)(); @@ -84,7 +78,8 @@ class LazyPointer { } } - bool operator!() const + bool + operator!() const { return get() == nullptr; } @@ -94,30 +89,35 @@ class LazyPointer { return get() != nullptr; } - bool operator==(const P & o) const + bool + operator==(const P & o) const { return (deref() == o); } - bool operator==(const T * o) const + bool + operator==(const T * o) const { return (deref().get() == o); } // Setters - LazyPointer<T, P> & operator=(const P & p) + LazyPointer<T, P> & + operator=(const P & p) { source = p; return *this; } - LazyPointer<T, P> & operator=(T * t) + LazyPointer<T, P> & + operator=(T * t) { source = P(t); return *this; } - LazyPointer<T, P> & operator=(const Factory & f) + LazyPointer<T, P> & + operator=(const Factory & f) { source = f; return *this; @@ -125,22 +125,24 @@ class LazyPointer { /// @endcond /** Does the lazy pointer have a value? (as opposed to a factory). */ - bool hasValue() const + bool + hasValue() const { return std::get_if<P>(&source); } private: mutable Source source; -}; + }; } namespace boost { - template <typename R, typename T, typename P> - R * dynamic_pointer_cast(const AdHoc::LazyPointer<T, P> & p) { - return dynamic_cast<R *>(p.get()); - } + template<typename R, typename T, typename P> + R * + dynamic_pointer_cast(const AdHoc::LazyPointer<T, P> & p) + { + return dynamic_cast<R *>(p.get()); + } } #endif - diff --git a/libadhocutil/lexer-regex.cpp b/libadhocutil/lexer-regex.cpp index 669bd16..7a490c5 100644 --- a/libadhocutil/lexer-regex.cpp +++ b/libadhocutil/lexer-regex.cpp @@ -2,72 +2,72 @@ namespace AdHoc::LexerMatchers { class Regex : public Lexer::Pattern { - public: - Regex(const Glib::ustring & pattern, GRegexCompileFlags compile, GRegexMatchFlags match) : - err(nullptr), - regex(g_regex_new(pattern.c_str(), compile, match, &err)), - info(nullptr), - str(nullptr) - { - if (!regex) { - auto msg = std::string("Failed to create GRegex: ") + err->message; - g_error_free(err); - throw std::runtime_error(msg); - } + public: + Regex(const Glib::ustring & pattern, GRegexCompileFlags compile, GRegexMatchFlags match) : + err(nullptr), regex(g_regex_new(pattern.c_str(), compile, match, &err)), info(nullptr), str(nullptr) + { + if (!regex) { + auto msg = std::string("Failed to create GRegex: ") + err->message; + g_error_free(err); + throw std::runtime_error(msg); } + } - SPECIAL_MEMBERS_DELETE(Regex); + SPECIAL_MEMBERS_DELETE(Regex); - ~Regex() override - { - if (err) { - g_error_free(err); - } - if (info) { - g_match_info_free(info); - } - g_regex_unref(regex); + ~Regex() override + { + if (err) { + g_error_free(err); } - - bool matches(const gchar * string, size_t length, size_t position) const override - { - if (info) { - g_match_info_free(info); - } - g_regex_match_full(regex, string, length, position, G_REGEX_MATCH_ANCHORED, &info, &err); - if (err) { - auto msg = std::string("Failed to create GRegex: ") + err->message; - g_error_free(err); - throw std::runtime_error(msg); - } - str = string; - return g_match_info_matches(info); + if (info) { + g_match_info_free(info); } + g_regex_unref(regex); + } - size_t matchedLength() const override - { - gint start, end; - g_match_info_fetch_pos(info, 0, &start, &end); - return end - start; + bool + matches(const gchar * string, size_t length, size_t position) const override + { + if (info) { + g_match_info_free(info); + } + g_regex_match_full(regex, string, length, position, G_REGEX_MATCH_ANCHORED, &info, &err); + if (err) { + auto msg = std::string("Failed to create GRegex: ") + err->message; + g_error_free(err); + throw std::runtime_error(msg); } + str = string; + return g_match_info_matches(info); + } - std::optional<Glib::ustring> match(int n) const override - { - gint start, end; - if (g_match_info_fetch_pos(info, n, &start, &end)) { - if (start == -1 && end == -1) { - return {}; - } - return Glib::ustring(str + start, str + end); + size_t + matchedLength() const override + { + gint start, end; + g_match_info_fetch_pos(info, 0, &start, &end); + return end - start; + } + + std::optional<Glib::ustring> + match(int n) const override + { + gint start, end; + if (g_match_info_fetch_pos(info, n, &start, &end)) { + if (start == -1 && end == -1) { + return {}; } - return {}; + return Glib::ustring(str + start, str + end); } + return {}; + } - private: - mutable GError * err; - GRegex * regex; - mutable GMatchInfo * info; - mutable const gchar * str; + private: + mutable GError * err; + GRegex * regex; + mutable GMatchInfo * info; + mutable const gchar * str; }; Lexer::PatternPtr @@ -76,4 +76,3 @@ namespace AdHoc::LexerMatchers { return std::make_shared<Regex>(pattern, compile, match); } } - diff --git a/libadhocutil/lexer-regex.h b/libadhocutil/lexer-regex.h index 5a141b9..8777418 100644 --- a/libadhocutil/lexer-regex.h +++ b/libadhocutil/lexer-regex.h @@ -12,9 +12,9 @@ namespace AdHoc { * @param match The regex match flags. * @return Pointer to the newly created pattern matcher. */ - DLL_PUBLIC Lexer::PatternPtr regex(const Glib::ustring & regex, GRegexCompileFlags compile = (GRegexCompileFlags)0, GRegexMatchFlags match = (GRegexMatchFlags)0); + DLL_PUBLIC Lexer::PatternPtr regex(const Glib::ustring & regex, + GRegexCompileFlags compile = (GRegexCompileFlags)0, GRegexMatchFlags match = (GRegexMatchFlags)0); } }; #endif - diff --git a/libadhocutil/lexer.cpp b/libadhocutil/lexer.cpp index 542a55f..6d16a46 100644 --- a/libadhocutil/lexer.cpp +++ b/libadhocutil/lexer.cpp @@ -6,9 +6,7 @@ namespace AdHoc { Lexer::Lexer() = default; - Lexer::Lexer(Rules r) : rules(std::move(r)) - { - } + Lexer::Lexer(Rules r) : rules(std::move(r)) { } AdHocFormatter(UnexpectedInputState, "Unexpected input in state (%?) at %?"); void @@ -85,4 +83,3 @@ namespace AdHoc { return pat; } } - diff --git a/libadhocutil/lexer.h b/libadhocutil/lexer.h index a32f3b1..5545525 100644 --- a/libadhocutil/lexer.h +++ b/libadhocutil/lexer.h @@ -1,95 +1,94 @@ #ifndef ADHOCUTIL_LEXER_H #define ADHOCUTIL_LEXER_H -#include <vector> -#include <glibmm/ustring.h> -#include <set> -#include <tuple> +#include "c++11Helpers.h" +#include "visibility.h" #include <functional> +#include <glibmm/ustring.h> #include <memory> #include <optional> -#include "visibility.h" -#include "c++11Helpers.h" +#include <set> +#include <tuple> +#include <vector> namespace AdHoc { /// An extensible lexer. class DLL_PUBLIC Lexer { + public: + /// Pattern matcher interface. + class Pattern { public: - /// Pattern matcher interface. - class Pattern { - public: - Pattern() = default; - virtual ~Pattern() = default; - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT(Pattern); + Pattern() = default; + virtual ~Pattern() = default; + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT(Pattern); - /// Test the pattern against the given input. - [[nodiscard]] virtual bool matches(const gchar *, size_t, size_t) const = 0; - /// Get the total amount of input matched. - [[nodiscard]] virtual size_t matchedLength() const = 0; - /// Get an extracted value from the pattern. - [[nodiscard]] virtual std::optional<Glib::ustring> match(int) const = 0; - }; - /// Smart pointer to Pattern. - using PatternPtr = std::shared_ptr<Pattern>; - /// Lexer state identifiers. - using State = std::string; - /// Collection of States. - using States = std::set<State>; + /// Test the pattern against the given input. + [[nodiscard]] virtual bool matches(const gchar *, size_t, size_t) const = 0; + /// Get the total amount of input matched. + [[nodiscard]] virtual size_t matchedLength() const = 0; + /// Get an extracted value from the pattern. + [[nodiscard]] virtual std::optional<Glib::ustring> match(int) const = 0; + }; + /// Smart pointer to Pattern. + using PatternPtr = std::shared_ptr<Pattern>; + /// Lexer state identifiers. + using State = std::string; + /// Collection of States. + using States = std::set<State>; - /// Class representing the runtime execution of the lexer. - class ExecuteState { - public: - /// Default constructor. - ExecuteState(); + /// Class representing the runtime execution of the lexer. + class ExecuteState { + public: + /// Default constructor. + ExecuteState(); - /// Push a new state to the stack. - void pushState(const State &); - /// Pop the top of the state stack off. - void popState(); - /// Replace the current top of the state stack. - void setState(const State &); - /// Get the current state. - [[nodiscard]] const State & getState() const; - /// Get the state stack depth. - [[nodiscard]] size_t depth() const; - /// Get the current position. - [[nodiscard]] size_t position() const; - /// Get the currently matched pattern. - [[nodiscard]] PatternPtr pattern() const; + /// Push a new state to the stack. + void pushState(const State &); + /// Pop the top of the state stack off. + void popState(); + /// Replace the current top of the state stack. + void setState(const State &); + /// Get the current state. + [[nodiscard]] const State & getState() const; + /// Get the state stack depth. + [[nodiscard]] size_t depth() const; + /// Get the current position. + [[nodiscard]] size_t position() const; + /// Get the currently matched pattern. + [[nodiscard]] PatternPtr pattern() const; - private: - friend class Lexer; - size_t pos { 0 }; - PatternPtr pat; + private: + friend class Lexer; + size_t pos {0}; + PatternPtr pat; - std::vector<State> stateStack; - }; + std::vector<State> stateStack; + }; - /// Callback for handling matched patterns. - using Handler = std::function<void(ExecuteState *)>; - /** - * Rule definition: - * States: in which states should the rule be considered? - * Pattern: the pattern matcher to test against the input. - * Handler: the callback to execute when a match succeeds. - */ - using Rule = std::tuple<States, PatternPtr, Handler>; - /// Collection of Rules that make up the lexer configuration. - using Rules = std::vector<Rule>; - /// The initial state of applied to the lexer. - static const State InitialState; - /// Default constructor (empty rule set) - Lexer(); - /// Construct with an initial set of rules. - explicit Lexer(Rules); - /// The lexer's current rule set. - Rules rules; + /// Callback for handling matched patterns. + using Handler = std::function<void(ExecuteState *)>; + /** + * Rule definition: + * States: in which states should the rule be considered? + * Pattern: the pattern matcher to test against the input. + * Handler: the callback to execute when a match succeeds. + */ + using Rule = std::tuple<States, PatternPtr, Handler>; + /// Collection of Rules that make up the lexer configuration. + using Rules = std::vector<Rule>; + /// The initial state of applied to the lexer. + static const State InitialState; + /// Default constructor (empty rule set) + Lexer(); + /// Construct with an initial set of rules. + explicit Lexer(Rules); + /// The lexer's current rule set. + Rules rules; - /// Execute the lexer to extract matches for the current rules. - void extract(const gchar * string, size_t length) const; + /// Execute the lexer to extract matches for the current rules. + void extract(const gchar * string, size_t length) const; }; } #endif - diff --git a/libadhocutil/lockHelpers.h b/libadhocutil/lockHelpers.h index 3e2a208..4bb285b 100644 --- a/libadhocutil/lockHelpers.h +++ b/libadhocutil/lockHelpers.h @@ -1,12 +1,12 @@ #ifndef ADHOCUTIL_LOCKHELPERS_H #define ADHOCUTIL_LOCKHELPERS_H -#define LIBADHOC_LOCK_CONCAT2(a, b) a ## b +#define LIBADHOC_LOCK_CONCAT2(a, b) a##b #define LIBADHOC_LOCK_CONCAT(a, b) LIBADHOC_LOCK_CONCAT2(a, b) -#define LIBADHOC_LOCK_WITHLINE(a) LIBADHOC_LOCK_CONCAT(a, __LINE__) +#define LIBADHOC_LOCK_WITHLINE(a) LIBADHOC_LOCK_CONCAT(a, __LINE__) -#define BaseLock(l,lt) lt LIBADHOC_LOCK_WITHLINE(_lck)(l) -#define BaseScopeLock(l,lt) if (auto LIBADHOC_LOCK_WITHLINE(_lck) = lt(l)) +#define BaseLock(l, lt) lt LIBADHOC_LOCK_WITHLINE(_lck)(l) +#define BaseScopeLock(l, lt) if (auto LIBADHOC_LOCK_WITHLINE(_lck) = lt(l)) #define Lock(l) BaseLock(l, std::unique_lock) #define SharedLock(l) BaseLock(l, std::shared_lock) @@ -15,4 +15,3 @@ #define SharedScopeLock(l) BaseScopeLock(l, std::shared_lock) #endif - diff --git a/libadhocutil/memstream.cpp b/libadhocutil/memstream.cpp index 4c83c14..282c5f7 100644 --- a/libadhocutil/memstream.cpp +++ b/libadhocutil/memstream.cpp @@ -1,12 +1,11 @@ #include "memstream.h" -#include <cstdlib> #include <cerrno> +#include <cstdlib> #include <cstring> #include <sys.h> namespace AdHoc { - MemStream::MemStream() : - strm(open_memstream(&buf, &len)) + MemStream::MemStream() : strm(open_memstream(&buf, &len)) { if (!strm) { // LCOV_EXCL_START no sensible way to make open_memstream fail @@ -15,10 +14,7 @@ namespace AdHoc { } } - MemStream::MemStream(MemStream && o) noexcept : - buf(o.buf), - len(o.len), - strm(o.strm) + MemStream::MemStream(MemStream && o) noexcept : buf(o.buf), len(o.len), strm(o.strm) { o.buf = nullptr; o.len = 0; @@ -34,7 +30,8 @@ namespace AdHoc { free(buf); } - MemStream & MemStream::operator=(MemStream && o) noexcept + MemStream & + MemStream::operator=(MemStream && o) noexcept { if (strm) { fclose(strm); @@ -53,36 +50,38 @@ namespace AdHoc { return *this; } - MemStream::operator FILE * () noexcept + MemStream::operator FILE *() noexcept { return strm; } - MemStream::operator const char * () const noexcept + MemStream::operator const char *() const noexcept { return buffer(); } MemStream::operator std::string_view() const noexcept { - return { buffer(), len }; + return {buffer(), len}; } - const char * MemStream::buffer() const noexcept + const char * + MemStream::buffer() const noexcept { fflush(strm); return buf; } - std::string_view MemStream::sv() const noexcept + std::string_view + MemStream::sv() const noexcept { - return { buffer(), len }; + return {buffer(), len}; } - size_t MemStream::length() const noexcept + size_t + MemStream::length() const noexcept { fflush(strm); return len; } } - diff --git a/libadhocutil/memstream.h b/libadhocutil/memstream.h index 4f9d280..43a06fb 100644 --- a/libadhocutil/memstream.h +++ b/libadhocutil/memstream.h @@ -1,52 +1,51 @@ #ifndef LIBADHOC_MEMSTREAM_H #define LIBADHOC_MEMSTREAM_H -#include <visibility.h> +#include "c++11Helpers.h" #include <cstdio> #include <string_view> -#include "c++11Helpers.h" +#include <visibility.h> namespace AdHoc { /** * Wrapper around open_memstream(3) */ class DLL_PUBLIC MemStream { - public: - MemStream(); - ~MemStream(); - - /// Standard move/copy support - SPECIAL_MEMBERS_COPY(MemStream, delete); - - /// Standard move constructor - MemStream(MemStream &&) noexcept; - - /// Standard move assignment - MemStream & operator=(MemStream &&) noexcept; - - /// Implicit conversion to use as FILE* for writes - // NOLINTNEXTLINE(hicpp-explicit-conversions) - operator FILE * () noexcept; - /// Implicit conversion to use as const char * for reads - // NOLINTNEXTLINE(hicpp-explicit-conversions) - operator const char * () const noexcept; - /// Implicit conversion to use as std::string_view for reads - // NOLINTNEXTLINE(hicpp-explicit-conversions) - operator std::string_view () const noexcept; - - /// Get buffer contents - [[nodiscard]] const char * buffer() const noexcept; - /// Get buffer contents view - [[nodiscard]] std::string_view sv() const noexcept; - /// Get buffer length - [[nodiscard]] size_t length() const noexcept; - - private: - char * buf { nullptr }; - size_t len { 0 }; - FILE * strm; + public: + MemStream(); + ~MemStream(); + + /// Standard move/copy support + SPECIAL_MEMBERS_COPY(MemStream, delete); + + /// Standard move constructor + MemStream(MemStream &&) noexcept; + + /// Standard move assignment + MemStream & operator=(MemStream &&) noexcept; + + /// Implicit conversion to use as FILE* for writes + // NOLINTNEXTLINE(hicpp-explicit-conversions) + operator FILE *() noexcept; + /// Implicit conversion to use as const char * for reads + // NOLINTNEXTLINE(hicpp-explicit-conversions) + operator const char *() const noexcept; + /// Implicit conversion to use as std::string_view for reads + // NOLINTNEXTLINE(hicpp-explicit-conversions) + operator std::string_view() const noexcept; + + /// Get buffer contents + [[nodiscard]] const char * buffer() const noexcept; + /// Get buffer contents view + [[nodiscard]] std::string_view sv() const noexcept; + /// Get buffer length + [[nodiscard]] size_t length() const noexcept; + + private: + char * buf {nullptr}; + size_t len {0}; + FILE * strm; }; } #endif - diff --git a/libadhocutil/nagios.cpp b/libadhocutil/nagios.cpp index 749e118..2007e7f 100644 --- a/libadhocutil/nagios.cpp +++ b/libadhocutil/nagios.cpp @@ -9,7 +9,8 @@ namespace AdHoc { /// LCOV_EXCL_START (calls real Nagios) bool - submitNagiosPassiveServiceCheck(const std::string_view & svc, NagiosStatusCode code, const std::string_view & output) + submitNagiosPassiveServiceCheck( + const std::string_view & svc, NagiosStatusCode code, const std::string_view & output) { std::ofstream command_file("/var/nagios/rw/nagios.cmd"); return submitNagiosPassiveServiceCheck(command_file, svc, code, output); @@ -17,11 +18,12 @@ namespace AdHoc { /// LCOV_EXCL_STOP bool - submitNagiosPassiveServiceCheck(std::ostream & command_file, const std::string_view & svc, - NagiosStatusCode code, const std::string_view & output) + submitNagiosPassiveServiceCheck(std::ostream & command_file, const std::string_view & svc, NagiosStatusCode code, + const std::string_view & output) { if (command_file.good()) { - struct utsname buf {}; + struct utsname buf { + }; uname(&buf); NagiosPassiveServiceCheck::write(command_file, time(nullptr), buf.nodename, svc, (uint8_t)code, output); command_file.flush(); @@ -29,4 +31,3 @@ namespace AdHoc { return command_file.good(); } } - diff --git a/libadhocutil/nagios.h b/libadhocutil/nagios.h index 144c27a..b6b140b 100644 --- a/libadhocutil/nagios.h +++ b/libadhocutil/nagios.h @@ -13,11 +13,10 @@ namespace AdHoc { Unknown = 3, }; - DLL_PUBLIC bool submitNagiosPassiveServiceCheck(const std::string_view &, - NagiosStatusCode, const std::string_view &); - DLL_PUBLIC bool submitNagiosPassiveServiceCheck(std::ostream &, const std::string_view &, - NagiosStatusCode, const std::string_view &); + DLL_PUBLIC bool submitNagiosPassiveServiceCheck( + const std::string_view &, NagiosStatusCode, const std::string_view &); + DLL_PUBLIC bool submitNagiosPassiveServiceCheck( + std::ostream &, const std::string_view &, NagiosStatusCode, const std::string_view &); } #endif - diff --git a/libadhocutil/nvpParse.h b/libadhocutil/nvpParse.h index bc06fbe..fe943dc 100644 --- a/libadhocutil/nvpParse.h +++ b/libadhocutil/nvpParse.h @@ -1,77 +1,77 @@ #ifndef ADHOCUTIL_REFLECTION_H #define ADHOCUTIL_REFLECTION_H -#include <string> -#include <map> -#include <istream> +#include <boost/lexical_cast.hpp> #include <functional> +#include <istream> +#include <map> #include <memory> -#include <boost/lexical_cast.hpp> +#include <string> #ifndef yyFlexLexer -#define yyFlexLexer nvpBaseFlexLexer -#include <FlexLexer.h> +# define yyFlexLexer nvpBaseFlexLexer +# include <FlexLexer.h> #endif -#include "visibility.h" #include "c++11Helpers.h" +#include "visibility.h" namespace AdHoc { -/// Name=Value parser. -/** - * Parses an input stream of the format Name=Value;Name2=Value2;... into a predefined object - * structure. - */ -class NvpParse : public yyFlexLexer { + /// Name=Value parser. + /** + * Parses an input stream of the format Name=Value;Name2=Value2;... into a predefined object + * structure. + */ + class NvpParse : public yyFlexLexer { public: /// @cond /// Thrown in the event of the input referring to a member that doesn't exist. class ValueNotFound : public std::runtime_error { - public: - explicit ValueNotFound(const std::string &); + public: + explicit ValueNotFound(const std::string &); }; using AssignFunc = std::function<void(const std::string &)>; using AssignMap = std::map<std::string, AssignFunc>; - template <typename T> - class TargetBase { - public: - TargetBase() = default; - virtual ~TargetBase() = default; - virtual AssignFunc assign(T *) const = 0; - SPECIAL_MEMBERS_DEFAULT(TargetBase); + template<typename T> class TargetBase { + public: + TargetBase() = default; + virtual ~TargetBase() = default; + virtual AssignFunc assign(T *) const = 0; + SPECIAL_MEMBERS_DEFAULT(TargetBase); }; - template <typename T, typename V> - class Target : public TargetBase<T> { - public: - explicit Target(V T::*t) : - target(t) - { - } - - AssignFunc assign(T * t) const override - { - return [t,this](const std::string & value) { - t->*target = boost::lexical_cast<V>(value); - }; - } - - private: - V T::*target; + template<typename T, typename V> class Target : public TargetBase<T> { + public: + explicit Target(V T::*t) : target(t) { } + + AssignFunc + assign(T * t) const override + { + return [t, this](const std::string & value) { + t->*target = boost::lexical_cast<V>(value); + }; + } + + private: + V T::*target; }; /// @endcond #define NvpTarget(T) std::map<std::string, std::shared_ptr<::AdHoc::NvpParse::TargetBase<T>>> -#define NvpValue(c, m) { #m, std::make_shared<::AdHoc::NvpParse::Target<c, decltype(c::m)>>(&c::m) } +#define NvpValue(c, m) \ + { \ +# m, std::make_shared < ::AdHoc::NvpParse::Target < c, decltype(c::m)>>(&c::m) \ + } /** Parse an input stream into the given object. * @param in The input stream. * @param tm The Target Map for the object. * @param t The target instance to populate. */ - template <typename T> - static void parse(std::istream & in, const NvpTarget(T) & tm, T & t) + template<typename T> + static void + parse(std::istream & in, const NvpTarget(T) & tm, T & t) { NvpParse::AssignMap am; for (const auto & v : tm) { @@ -94,9 +94,8 @@ class NvpParse : public yyFlexLexer { void process(const std::string & value) const; std::string name; const AssignMap values; -}; + }; } #endif - diff --git a/libadhocutil/optionalUtils.h b/libadhocutil/optionalUtils.h index f4d6b1a..0ba3cb7 100644 --- a/libadhocutil/optionalUtils.h +++ b/libadhocutil/optionalUtils.h @@ -4,27 +4,23 @@ #include <type_traits> namespace AdHoc { - template <typename A, typename B> + template<typename A, typename B> auto - operator/(const A & a, const B & b) -> typename std::enable_if< - std::is_constructible<bool, A>::value && - !std::is_pointer<B>::value && - std::is_convertible<decltype(*a), B>::value, - decltype(a ? *a : b)>::type + operator/(const A & a, const B & b) -> typename std::enable_if<std::is_constructible<bool, A>::value + && !std::is_pointer<B>::value && std::is_convertible<decltype(*a), B>::value, + decltype(a ? *a : b)>::type { return (a ? *a : b); } - template <typename A, typename B> + template<typename A, typename B> auto - operator/(const A & a, const B & b) -> typename std::enable_if< - std::is_constructible<bool, A>::value && - std::is_pointer<B>::value, - decltype(a ? &*a : b)>::type + operator/(const A & a, const B & b) -> + typename std::enable_if<std::is_constructible<bool, A>::value && std::is_pointer<B>::value, + decltype(a ? &*a : b)>::type { return (a ? &*a : b); } } #endif - diff --git a/libadhocutil/plugins.cpp b/libadhocutil/plugins.cpp index 86dc2c5..8c8f1b5 100644 --- a/libadhocutil/plugins.cpp +++ b/libadhocutil/plugins.cpp @@ -1,14 +1,14 @@ #include "plugins.h" -#include <cstring> -#include <dlfcn.h> -#include <boost/multi_index_container.hpp> -#include <boost/multi_index/ordered_index.hpp> -#include <boost/multi_index/member.hpp> -#include <boost/multi_index/mem_fun.hpp> -#include <boost/multi_index/composite_key.hpp> #include "compileTimeFormatter.h" #include "globalStatic.impl.h" +#include <boost/multi_index/composite_key.hpp> +#include <boost/multi_index/mem_fun.hpp> +#include <boost/multi_index/member.hpp> +#include <boost/multi_index/ordered_index.hpp> +#include <boost/multi_index_container.hpp> +#include <cstring> #include <cxxabi.h> +#include <dlfcn.h> namespace std { bool @@ -20,7 +20,8 @@ namespace std { std::ostream & operator<<(std::ostream & s, const std::type_info & t) { - auto buf = std::unique_ptr<char, decltype(&std::free)>(__cxxabiv1::__cxa_demangle(t.name(), nullptr, nullptr, nullptr), std::free); + auto buf = std::unique_ptr<char, decltype(&std::free)>( + __cxxabiv1::__cxa_demangle(t.name(), nullptr, nullptr, nullptr), std::free); s << buf.get(); return s; } @@ -31,12 +32,7 @@ namespace AdHoc { AbstractPluginImplementation::~AbstractPluginImplementation() = default; - Plugin::Plugin(const std::string_view & n, const std::string_view & f, int l) : - name(n), - filename(f), - lineno(l) - { - } + Plugin::Plugin(const std::string_view & n, const std::string_view & f, int l) : name(n), filename(f), lineno(l) { } AdHocFormatter(NoSuchPluginExceptionMsg, "No such plugin: %? of type %?"); NoSuchPluginException::NoSuchPluginException(const std::string_view & n, const std::type_info & t) : @@ -47,7 +43,7 @@ namespace AdHoc { AdHocFormatter(DuplicatePluginExceptionMsg, "Duplicate plugin %? for type %? at %?:%?, originally from %?:%?"); DuplicatePluginException::DuplicatePluginException(const PluginPtr & p1, const PluginPtr & p2) : std::runtime_error(DuplicatePluginExceptionMsg::get( - p1->name, p1->type(), p2->filename, p2->lineno, p1->filename, p1->lineno)) + p1->name, p1->type(), p2->filename, p2->lineno, p1->filename, p1->lineno)) { } @@ -63,25 +59,26 @@ namespace AdHoc { { } - class PluginManager::PluginStore : public boost::multi_index_container<PluginPtr, - boost::multi_index::indexed_by< - boost::multi_index::ordered_non_unique<boost::multi_index::member<Plugin, const std::string, &Plugin::name>, std::less<>>, - boost::multi_index::ordered_non_unique<boost::multi_index::const_mem_fun<Plugin, const std::type_info &, &Plugin::type>>, + class PluginManager::PluginStore : + public boost::multi_index_container<PluginPtr, + boost::multi_index::indexed_by< + boost::multi_index::ordered_non_unique< + boost::multi_index::member<Plugin, const std::string, &Plugin::name>, std::less<>>, + boost::multi_index::ordered_non_unique< + boost::multi_index::const_mem_fun<Plugin, const std::type_info &, &Plugin::type>>, boost::multi_index::ordered_unique< - boost::multi_index::composite_key< - Plugin, - boost::multi_index::member<Plugin, const std::string, &Plugin::name>, - boost::multi_index::const_mem_fun<Plugin, const std::type_info &, &Plugin::type> - >, std::less<>> - >> - { + boost::multi_index::composite_key<Plugin, + boost::multi_index::member<Plugin, const std::string, &Plugin::name>, + boost::multi_index::const_mem_fun<Plugin, const std::type_info &, + &Plugin::type>>, + std::less<>>>> { }; - class PluginManager::TypePluginResolvers : public std::map<size_t, PluginResolver> { }; + class PluginManager::TypePluginResolvers : public std::map<size_t, PluginResolver> { + }; PluginManager::PluginManager() : - plugins(std::make_unique<PluginStore>()), - resolvers(std::make_unique<TypePluginResolvers>()) + plugins(std::make_unique<PluginStore>()), resolvers(std::make_unique<TypePluginResolvers>()) { } @@ -140,14 +137,14 @@ namespace AdHoc { std::set<PluginPtr> PluginManager::getAll() const { - return { plugins->begin(), plugins->end() }; + return {plugins->begin(), plugins->end()}; } std::set<PluginPtr> PluginManager::getAll(const std::type_info & t) const { auto r = plugins->get<1>().equal_range(t); - return { r.first, r.second }; + return {r.first, r.second}; } size_t @@ -177,4 +174,3 @@ namespace AdHoc { return resolvers->size(); } } - diff --git a/libadhocutil/plugins.h b/libadhocutil/plugins.h index f8b1e8c..3502051 100644 --- a/libadhocutil/plugins.h +++ b/libadhocutil/plugins.h @@ -1,237 +1,242 @@ #ifndef ADHOCUTIL_PLUGINS_H #define ADHOCUTIL_PLUGINS_H -#include <memory> +#include "c++11Helpers.h" +#include "unique.h" +#include "visibility.h" +#include <algorithm> #include <functional> +#include <map> +#include <memory> #include <optional> -#include <typeinfo> #include <set> -#include <map> -#include <algorithm> #include <stdexcept> -#include "visibility.h" -#include "unique.h" -#include "c++11Helpers.h" +#include <typeinfo> namespace std { DLL_PUBLIC - std::ostream & - operator<<(std::ostream & s, const std::type_info & t); + std::ostream & operator<<(std::ostream & s, const std::type_info & t); } namespace AdHoc { /// Thrown when no matching plugin can be found. class NoSuchPluginException : public std::runtime_error { - public: - /// Constructor taking name and type of plugin requested. - NoSuchPluginException(const std::string_view &, const std::type_info &); + public: + /// Constructor taking name and type of plugin requested. + NoSuchPluginException(const std::string_view &, const std::type_info &); }; /// Base class for all plugin implementations. class DLL_PUBLIC AbstractPluginImplementation { - public: - AbstractPluginImplementation() = default; - virtual ~AbstractPluginImplementation() = 0; - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT(AbstractPluginImplementation); + public: + AbstractPluginImplementation() = default; + virtual ~AbstractPluginImplementation() = 0; + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT(AbstractPluginImplementation); }; /// Base class for untyped plugins. class DLL_PUBLIC Plugin { - public: - /// Constructor taking name, filename and line of install. - Plugin(const std::string_view &, const std::string_view &, int); - /// Standard move/copy support - SPECIAL_MEMBERS_DELETE(Plugin); - virtual ~Plugin() = default; - - /// Get the plugin type from the subclass. - [[nodiscard]] virtual const std::type_info & type() const = 0; - - /// Get the abstract base plugin implementation. - [[nodiscard]] virtual std::shared_ptr<AbstractPluginImplementation> instance() const = 0; - - /// The name the plugin was installed with. - const std::string name; - /// The filename the plugin was installed in. - const std::string filename; - /// The line of file the plugin was installed in. - const int lineno; + public: + /// Constructor taking name, filename and line of install. + Plugin(const std::string_view &, const std::string_view &, int); + /// Standard move/copy support + SPECIAL_MEMBERS_DELETE(Plugin); + virtual ~Plugin() = default; + + /// Get the plugin type from the subclass. + [[nodiscard]] virtual const std::type_info & type() const = 0; + + /// Get the abstract base plugin implementation. + [[nodiscard]] virtual std::shared_ptr<AbstractPluginImplementation> instance() const = 0; + + /// The name the plugin was installed with. + const std::string name; + /// The filename the plugin was installed in. + const std::string filename; + /// The line of file the plugin was installed in. + const int lineno; }; using PluginPtr = std::shared_ptr<const Plugin>; /// Thrown when a plugin with the same name and base is loaded into a manager. class DuplicatePluginException : public std::runtime_error { - public: - /// Constructor taking the original and offending plugin. - DuplicatePluginException(const PluginPtr & p1, const PluginPtr & p2); + public: + /// Constructor taking the original and offending plugin. + DuplicatePluginException(const PluginPtr & p1, const PluginPtr & p2); }; /// Thrown when a resolver function is added a second time. class DuplicateResolverException : public std::runtime_error { - public: - /// Constuctor taking resolver type. - explicit DuplicateResolverException(const std::type_info &); + public: + /// Constuctor taking resolver type. + explicit DuplicateResolverException(const std::type_info &); }; /// Thrown when an attempt to load a library fails. class LoadLibraryException : public std::runtime_error { - public: - /// Constuctor taking syscall error details. - LoadLibraryException(const std::string_view & f, const std::string_view & msg); + public: + /// Constuctor taking syscall error details. + LoadLibraryException(const std::string_view & f, const std::string_view & msg); }; - template <typename T> + template<typename T> /// Typed plugin and handle to implementation. class DLL_PUBLIC PluginOf : public Plugin { - public: - /// Constructor taking an instance and name, filename and line of install for Plugin. - PluginOf(std::shared_ptr<T> t, const std::string_view & n, const std::string_view & f, int l); + public: + /// Constructor taking an instance and name, filename and line of install for Plugin. + PluginOf(std::shared_ptr<T> t, const std::string_view & n, const std::string_view & f, int l); - /// Get the type of this plugin. - [[nodiscard]] const std::type_info & type() const override; - /// Get the implementation of this plugin. - [[nodiscard]] std::shared_ptr<T> implementation() const; + /// Get the type of this plugin. + [[nodiscard]] const std::type_info & type() const override; + /// Get the implementation of this plugin. + [[nodiscard]] std::shared_ptr<T> implementation() const; - [[nodiscard]] std::shared_ptr<AbstractPluginImplementation> instance() const override; + [[nodiscard]] std::shared_ptr<AbstractPluginImplementation> instance() const override; - private: - const std::shared_ptr<T> impl; + private: + const std::shared_ptr<T> impl; }; /// Container for loaded plugins. class DLL_PUBLIC PluginManager { - public: - /// Callback definition to resolve a plugin type and name to a potential library - /// containing an implementation. - using PluginResolver = std::function<std::optional<std::string> (const std::type_info &, const std::string_view &)>; - - PluginManager(); - virtual ~PluginManager(); - - /// Standard move/copy support - SPECIAL_MEMBERS_DELETE(PluginManager); - - /// Install a plugin. - void add(const PluginPtr &); - /// Uninstall a plugin. - void remove(const std::string_view &, const std::type_info &); - /// Get a specific plugin. - [[nodiscard]] PluginPtr get(const std::string_view &, const std::type_info &) const; - /// Get all plugins. - [[nodiscard]] std::set<PluginPtr> getAll() const; - /// Get all plugins of a specific type. - [[nodiscard]] std::set<PluginPtr> getAll(const std::type_info &) const; - - /** - * Install a plugin. - * @param i Implementation instance. - * @param n Name of plugin. - * @param f Filename of plugin. - * @param l Line number. - */ - template<typename T> void add(const std::shared_ptr<T> & i, const std::string_view & n, const std::string_view & f, int l); - - /** - * Create and install a plugin - * @tparam T Base type of plugin - * @tparam I Implementation type of plugin - * @tparam Args Constructor arguments types - * @param n Name of plugin. - * @param f Filename of plugin. - * @param l Line number. - * @param args Arguments to construct an instance of I with. - */ - template<typename T, typename I, typename ... Args> void create(const std::string_view & n, const std::string_view & f, int l, const Args & ... args) - { - add<T>(std::make_shared<I>(args...), n, f, l); - } - - /** - * Uninstall a plugin. - * @param n Name of plugin. - */ - template<typename T> void remove(const std::string_view & n); - - /** - * Get a specific plugin. - * @param n Name of plugin. - */ - template<typename T> [[nodiscard]] std::shared_ptr<const PluginOf<T>> get(const std::string_view & n) const; - - /** - * Get the implementation from specific plugin. - * @param n Name of plugin. - */ - template<typename T> [[nodiscard]] std::shared_ptr<T> getImplementation(const std::string_view & n) const; - - /** - * Get all plugins of a given time. - */ - template<typename T> [[nodiscard]] std::set<std::shared_ptr<const PluginOf<T>>> getAll() const; - - /** - * The number of installed plugins. - */ - [[nodiscard]] size_t count() const; - - /** - * Add a type plugin resolver function. - * @param t The resolver type. - * @param f The resolver function. - */ - void addResolver(const std::type_info & t, const PluginResolver & f); - - /** - * Add a type plugin resolver function. - * @param f The resolver function. - */ - template<typename T> void addResolver(const PluginResolver & f); - - /** - * Remove a type plugin resolver function. - * @param t The resolver type. - */ - void removeResolver(const std::type_info & t); - - /** - * Remove a type plugin resolver function. - */ - template<typename T> void removeResolver(); - - /** - * The number of installed plugins. - */ - [[nodiscard]] size_t countResolvers() const; - - /** - * Get the default plugin manager instance. - */ - static PluginManager * getDefault(); - - private: - static void loadLibrary(const std::string &); - - class PluginStore; - std::unique_ptr<PluginStore> plugins; - class TypePluginResolvers; - std::unique_ptr<TypePluginResolvers> resolvers; + public: + /// Callback definition to resolve a plugin type and name to a potential library + /// containing an implementation. + using PluginResolver + = std::function<std::optional<std::string>(const std::type_info &, const std::string_view &)>; + + PluginManager(); + virtual ~PluginManager(); + + /// Standard move/copy support + SPECIAL_MEMBERS_DELETE(PluginManager); + + /// Install a plugin. + void add(const PluginPtr &); + /// Uninstall a plugin. + void remove(const std::string_view &, const std::type_info &); + /// Get a specific plugin. + [[nodiscard]] PluginPtr get(const std::string_view &, const std::type_info &) const; + /// Get all plugins. + [[nodiscard]] std::set<PluginPtr> getAll() const; + /// Get all plugins of a specific type. + [[nodiscard]] std::set<PluginPtr> getAll(const std::type_info &) const; + + /** + * Install a plugin. + * @param i Implementation instance. + * @param n Name of plugin. + * @param f Filename of plugin. + * @param l Line number. + */ + template<typename T> + void add(const std::shared_ptr<T> & i, const std::string_view & n, const std::string_view & f, int l); + + /** + * Create and install a plugin + * @tparam T Base type of plugin + * @tparam I Implementation type of plugin + * @tparam Args Constructor arguments types + * @param n Name of plugin. + * @param f Filename of plugin. + * @param l Line number. + * @param args Arguments to construct an instance of I with. + */ + template<typename T, typename I, typename... Args> + void + create(const std::string_view & n, const std::string_view & f, int l, const Args &... args) + { + add<T>(std::make_shared<I>(args...), n, f, l); + } + + /** + * Uninstall a plugin. + * @param n Name of plugin. + */ + template<typename T> void remove(const std::string_view & n); + + /** + * Get a specific plugin. + * @param n Name of plugin. + */ + template<typename T>[[nodiscard]] std::shared_ptr<const PluginOf<T>> get(const std::string_view & n) const; + + /** + * Get the implementation from specific plugin. + * @param n Name of plugin. + */ + template<typename T>[[nodiscard]] std::shared_ptr<T> getImplementation(const std::string_view & n) const; + + /** + * Get all plugins of a given time. + */ + template<typename T>[[nodiscard]] std::set<std::shared_ptr<const PluginOf<T>>> getAll() const; + + /** + * The number of installed plugins. + */ + [[nodiscard]] size_t count() const; + + /** + * Add a type plugin resolver function. + * @param t The resolver type. + * @param f The resolver function. + */ + void addResolver(const std::type_info & t, const PluginResolver & f); + + /** + * Add a type plugin resolver function. + * @param f The resolver function. + */ + template<typename T> void addResolver(const PluginResolver & f); + + /** + * Remove a type plugin resolver function. + * @param t The resolver type. + */ + void removeResolver(const std::type_info & t); + + /** + * Remove a type plugin resolver function. + */ + template<typename T> void removeResolver(); + + /** + * The number of installed plugins. + */ + [[nodiscard]] size_t countResolvers() const; + + /** + * Get the default plugin manager instance. + */ + static PluginManager * getDefault(); + + private: + static void loadLibrary(const std::string &); + + class PluginStore; + std::unique_ptr<PluginStore> plugins; + class TypePluginResolvers; + std::unique_ptr<TypePluginResolvers> resolvers; }; } #define NAMEDPLUGIN(Name, Implementation, Base) \ - namespace MAKE_UNIQUE(__plugin__) { \ + namespace MAKE_UNIQUE(__plugin__) \ + { \ static void InstallPlugin() __attribute__((constructor(102))); \ - void InstallPlugin() { \ - ::AdHoc::PluginManager::getDefault()->add<Base>(std::make_shared<Implementation>(), Name, __FILE__, __LINE__); \ + void InstallPlugin() \ + { \ + ::AdHoc::PluginManager::getDefault()->add<Base>( \ + std::make_shared<Implementation>(), Name, __FILE__, __LINE__); \ } \ static void UninstallPlugin() __attribute__((destructor(102))); \ - void UninstallPlugin() { \ + void UninstallPlugin() \ + { \ ::AdHoc::PluginManager::getDefault()->remove<Base>(Name); \ } \ } -#define PLUGIN(Implementation, Base) \ - NAMEDPLUGIN(#Implementation, Implementation, Base) +#define PLUGIN(Implementation, Base) NAMEDPLUGIN(#Implementation, Implementation, Base) #endif - diff --git a/libadhocutil/plugins.impl.h b/libadhocutil/plugins.impl.h index e4b48d1..7757ea5 100644 --- a/libadhocutil/plugins.impl.h +++ b/libadhocutil/plugins.impl.h @@ -4,15 +4,14 @@ #include "plugins.h" namespace AdHoc { - template <typename T> + template<typename T> PluginOf<T>::PluginOf(std::shared_ptr<T> t, const std::string_view & n, const std::string_view & f, int l) : - Plugin(n, f, l), - impl(std::move(t)) + Plugin(n, f, l), impl(std::move(t)) { } /// Get the type of this plugin. - template <typename T> + template<typename T> const std::type_info & PluginOf<T>::type() const { @@ -20,54 +19,54 @@ namespace AdHoc { } /// Get the implementation of this plugin. - template <typename T> + template<typename T> std::shared_ptr<T> PluginOf<T>::implementation() const { return impl; } - template <typename T> + template<typename T> std::shared_ptr<AbstractPluginImplementation> PluginOf<T>::instance() const { return impl; } - template <typename T> + template<typename T> void PluginManager::add(const std::shared_ptr<T> & i, const std::string_view & n, const std::string_view & f, int l) { add(std::make_shared<PluginOf<T>>(i, n, f, l)); } - template <typename T> + template<typename T> void PluginManager::remove(const std::string_view & n) { remove(n, typeid(T)); } - template <typename T> + template<typename T> std::shared_ptr<const PluginOf<T>> PluginManager::get(const std::string_view & n) const { return std::dynamic_pointer_cast<const PluginOf<T>>(get(n, typeid(T))); } - template <typename T> + template<typename T> std::shared_ptr<T> PluginManager::getImplementation(const std::string_view & n) const { return std::static_pointer_cast<T>(get<T>(n)->implementation()); } - template <typename T> + template<typename T> std::set<std::shared_ptr<const PluginOf<T>>> PluginManager::getAll() const { std::set<std::shared_ptr<const PluginOf<T>>> all; - for(const auto & p : getAll(typeid(T))) { + for (const auto & p : getAll(typeid(T))) { if (auto tp = std::dynamic_pointer_cast<const PluginOf<T>>(p)) { all.insert(tp); } @@ -92,25 +91,32 @@ namespace AdHoc { #define INSTANTIATEPLUGINOF(...) \ template class AdHoc::PluginOf<__VA_ARGS__>; \ - template DLL_PUBLIC void AdHoc::PluginManager::add<__VA_ARGS__>(const std::shared_ptr<__VA_ARGS__> &, const std::string_view &, const std::string_view &, int); \ + template DLL_PUBLIC void AdHoc::PluginManager::add<__VA_ARGS__>( \ + const std::shared_ptr<__VA_ARGS__> &, const std::string_view &, const std::string_view &, int); \ template DLL_PUBLIC void AdHoc::PluginManager::remove<__VA_ARGS__>(const std::string_view &); \ - template DLL_PUBLIC std::shared_ptr<const AdHoc::PluginOf<__VA_ARGS__>> AdHoc::PluginManager::get<__VA_ARGS__>(const std::string_view &) const; \ - template DLL_PUBLIC std::shared_ptr<__VA_ARGS__> AdHoc::PluginManager::getImplementation<__VA_ARGS__>(const std::string_view &) const; \ - template DLL_PUBLIC std::set<std::shared_ptr<const AdHoc::PluginOf<__VA_ARGS__>>> AdHoc::PluginManager::getAll<__VA_ARGS__>() const; \ - template DLL_PUBLIC void AdHoc::PluginManager::addResolver<__VA_ARGS__>(const AdHoc::PluginManager::PluginResolver & f); \ - template DLL_PUBLIC void AdHoc::PluginManager::removeResolver<__VA_ARGS__>(); \ + template DLL_PUBLIC std::shared_ptr<const AdHoc::PluginOf<__VA_ARGS__>> AdHoc::PluginManager::get<__VA_ARGS__>( \ + const std::string_view &) const; \ + template DLL_PUBLIC std::shared_ptr<__VA_ARGS__> AdHoc::PluginManager::getImplementation<__VA_ARGS__>( \ + const std::string_view &) const; \ + template DLL_PUBLIC std::set<std::shared_ptr<const AdHoc::PluginOf<__VA_ARGS__>>> \ + AdHoc::PluginManager::getAll<__VA_ARGS__>() const; \ + template DLL_PUBLIC void AdHoc::PluginManager::addResolver<__VA_ARGS__>( \ + const AdHoc::PluginManager::PluginResolver & f); \ + template DLL_PUBLIC void AdHoc::PluginManager::removeResolver<__VA_ARGS__>(); #define PLUGINRESOLVER(T, F) \ - namespace MAKE_UNIQUE(__plugin__) { \ + namespace MAKE_UNIQUE(__plugin__) \ + { \ static void InstallResolver() __attribute__((constructor(102))); \ - void InstallResolver() { \ + void InstallResolver() \ + { \ ::AdHoc::PluginManager::getDefault()->addResolver<T>(F); \ } \ static void UninstallResolver() __attribute__((destructor(102))); \ - void UninstallResolver() { \ + void UninstallResolver() \ + { \ ::AdHoc::PluginManager::getDefault()->removeResolver<T>(); \ } \ } #endif - diff --git a/libadhocutil/processPipes.cpp b/libadhocutil/processPipes.cpp index efdcc88..59253bc 100644 --- a/libadhocutil/processPipes.cpp +++ b/libadhocutil/processPipes.cpp @@ -1,142 +1,146 @@ #include "processPipes.h" -#include <unistd.h> -#include <poll.h> +#include "c++11Helpers.h" #include <cstring> -#include <sys/resource.h> +#include <poll.h> #include <stdexcept> #include <sys.h> -#include "c++11Helpers.h" +#include <sys/resource.h> +#include <unistd.h> namespace AdHoc::System { -ProcessPipes::InitPipe -ProcessPipes::pipeSetup(bool setup, bool swap) -{ - if (setup) { - PipePair pair; - if (::pipe(&pair.first)) { - throw SystemException("pipe(2) failed", strerror(errno), errno); + ProcessPipes::InitPipe + ProcessPipes::pipeSetup(bool setup, bool swap) + { + if (setup) { + PipePair pair; + if (::pipe(&pair.first)) { + throw SystemException("pipe(2) failed", strerror(errno), errno); + } + if (swap) { + std::swap(pair.first, pair.second); + } + return pair; } - if (swap) { - std::swap(pair.first, pair.second); + return {}; + } + + void + ProcessPipes::closeChild(const InitPipe & pipe) noexcept + { + if (pipe) { + close(pipe->second); } - return pair; } - return {}; -} -void ProcessPipes::closeChild(const InitPipe & pipe) noexcept -{ - if (pipe) { - close(pipe->second); + void + ProcessPipes::dupChild(int fd, const InitPipe & pipe) noexcept + { + if (pipe) { + close(pipe->first); + dup2(pipe->second, fd); + } } -} -void ProcessPipes::dupChild(int fd, const InitPipe & pipe) noexcept -{ - if (pipe) { - close(pipe->first); - dup2(pipe->second, fd); + ProcessPipes::ProcessPipes(const std::vector<std::string> & args, bool i, bool o, bool e) : + ProcessPipes( + [&args]() { + if (args.empty()) { + throw std::invalid_argument("args is empty"); + } + return args; + }(), + pipeSetup(i, true), pipeSetup(o, false), pipeSetup(e, false)) + { } -} -ProcessPipes::ProcessPipes(const std::vector<std::string> & args, bool i, bool o, bool e) : - ProcessPipes([&args](){ - if (args.empty()) { - throw std::invalid_argument("args is empty"); + ProcessPipes::ProcessPipes( + const std::vector<std::string> & args, InitPipe && ipp, InitPipe && opp, InitPipe && epp) : + child([]() { + if (pid_t p = fork(); p != -1) { + return p; + } + /// LCOV_EXCL_START (fork won't fail) + throw SystemException("fork(2) failed", strerror(errno), errno); + /// LCOV_EXCL_STOP + }()), + in(ipp ? std::make_optional<FHandle>(ipp->first, &close) : OFHandle()), + out(opp ? std::make_optional<FHandle>(opp->first, &close) : OFHandle()), + error(epp ? std::make_optional<FHandle>(epp->first, &close) : OFHandle()) + { + switch (child) { + default: // parent + closeChild(ipp); + closeChild(opp); + closeChild(epp); + break; + case 0: // in child + dupChild(STDIN_FILENO, ipp); + dupChild(STDOUT_FILENO, opp); + dupChild(STDERR_FILENO, epp); + closeAllOpenFiles(); + std::vector<char *> buf(args.size() + 1); + auto w = buf.begin(); + for (const auto & p : args) { + *w++ = strdup(p.c_str()); + } + *w = nullptr; + if (buf[0]) { + execv(buf[0], buf.data()); + } + abort(); + break; } - return args; - }(), pipeSetup(i, true), pipeSetup(o, false), pipeSetup(e, false)) -{ -} + } -ProcessPipes::ProcessPipes(const std::vector<std::string> & args, InitPipe && ipp, InitPipe && opp, InitPipe && epp) : - child([]() { - if (pid_t p = fork(); p != -1) { - return p; + int + ProcessPipes::closeIn() + { + if (in) { + in.reset(); + return 0; } - /// LCOV_EXCL_START (fork won't fail) - throw SystemException("fork(2) failed", strerror(errno), errno); - /// LCOV_EXCL_STOP - }()), - in(ipp ? std::make_optional<FHandle>(ipp->first, &close) : OFHandle()), - out(opp ? std::make_optional<FHandle>(opp->first, &close) : OFHandle()), - error(epp ? std::make_optional<FHandle>(epp->first, &close) : OFHandle()) -{ - switch (child) { - default: // parent - closeChild(ipp); - closeChild(opp); - closeChild(epp); - break; - case 0: // in child - dupChild(STDIN_FILENO, ipp); - dupChild(STDOUT_FILENO, opp); - dupChild(STDERR_FILENO, epp); - closeAllOpenFiles(); - std::vector<char *> buf(args.size() + 1); - auto w = buf.begin(); - for (const auto & p : args) { - *w++ = strdup(p.c_str()); - } - *w = nullptr; - if (buf[0]) { - execv(buf[0], buf.data()); - } - abort(); - break; + return EBADF; } -} -int -ProcessPipes::closeIn() -{ - if (in) { - in.reset(); - return 0; + int + ProcessPipes::fdIn() const noexcept + { + return in ? *in : -1; } - return EBADF; -} - -int -ProcessPipes::fdIn() const noexcept -{ - return in ? *in : -1; -} - -int -ProcessPipes::fdOut() const noexcept -{ - return out ? *out : -1; -} -int -ProcessPipes::fdError() const noexcept -{ - return error ? *error : -1; -} + int + ProcessPipes::fdOut() const noexcept + { + return out ? *out : -1; + } -pid_t -ProcessPipes::pid() const noexcept -{ - return child; -} + int + ProcessPipes::fdError() const noexcept + { + return error ? *error : -1; + } -void -ProcessPipes::closeAllOpenFiles() noexcept -{ - rlimit lim { }; - getrlimit(RLIMIT_NOFILE, &lim); - std::vector<struct pollfd> fds; - fds.reserve(lim.rlim_max); - for (int n = 3; n < (int)lim.rlim_max; n += 1) { - fds.push_back({n, 0, 0}); + pid_t + ProcessPipes::pid() const noexcept + { + return child; } - poll(&fds.front(), fds.size(), 0); - for(const auto & pfd : fds) { - if (!(pfd.revents & POLLNVAL)) { - close(pfd.fd); + + void + ProcessPipes::closeAllOpenFiles() noexcept + { + rlimit lim {}; + getrlimit(RLIMIT_NOFILE, &lim); + std::vector<struct pollfd> fds; + fds.reserve(lim.rlim_max); + for (int n = 3; n < (int)lim.rlim_max; n += 1) { + fds.push_back({n, 0, 0}); + } + poll(&fds.front(), fds.size(), 0); + for (const auto & pfd : fds) { + if (!(pfd.revents & POLLNVAL)) { + close(pfd.fd); + } } } } -} - diff --git a/libadhocutil/processPipes.h b/libadhocutil/processPipes.h index 1b1a8fa..5ccc4c0 100644 --- a/libadhocutil/processPipes.h +++ b/libadhocutil/processPipes.h @@ -1,62 +1,61 @@ #ifndef ADHOCUTIL_PROCESSPIPES_H #define ADHOCUTIL_PROCESSPIPES_H -#include <vector> -#include <string> -#include <optional> -#include "visibility.h" #include "c++11Helpers.h" #include "handle.h" +#include "visibility.h" +#include <optional> +#include <string> +#include <vector> namespace AdHoc { -namespace System { - -/// Spawn a process and attach to its IO handles. -class DLL_PUBLIC ProcessPipes { - public: - /** - * Spawn a new process, providing (optional) access to its stdin, stdout and - * stderr file handles. - * @param args path and arguments to spawn (passed to execv) - * @param in Attach to stdin? - * @param out Attach to stdout? - * @param err Attach to stderr? - */ - ProcessPipes(const std::vector<std::string> & args, bool in, bool out, bool err); - - /// Close input pipe to process - int closeIn(); - - /** FD handle to child's stdin. */ - [[nodiscard]] int fdIn() const noexcept; - /** FD handle to child's stdout. */ - [[nodiscard]] int fdOut() const noexcept; - /** FD handle to child's stderr. */ - [[nodiscard]] int fdError() const noexcept; - /** Process id of child. */ - [[nodiscard]] pid_t pid() const noexcept; - - private: - using PipePair = std::pair<int, int>; - using InitPipe = std::optional<PipePair>; - - ProcessPipes(const std::vector<std::string> & args, InitPipe &&, InitPipe &&, InitPipe &&); - - static InitPipe pipeSetup(bool setup, bool swap); - static void closeChild(const InitPipe & child) noexcept; - static void dupChild(int, const InitPipe & child) noexcept; - static void closeAllOpenFiles() noexcept; - - using FHandle = ::AdHoc::Handle<int, int(*)(int)>; - using OFHandle = std::optional<FHandle>; - const pid_t child; - OFHandle in; - const OFHandle out, error; -}; - -} + namespace System { + + /// Spawn a process and attach to its IO handles. + class DLL_PUBLIC ProcessPipes { + public: + /** + * Spawn a new process, providing (optional) access to its stdin, stdout and + * stderr file handles. + * @param args path and arguments to spawn (passed to execv) + * @param in Attach to stdin? + * @param out Attach to stdout? + * @param err Attach to stderr? + */ + ProcessPipes(const std::vector<std::string> & args, bool in, bool out, bool err); + + /// Close input pipe to process + int closeIn(); + + /** FD handle to child's stdin. */ + [[nodiscard]] int fdIn() const noexcept; + /** FD handle to child's stdout. */ + [[nodiscard]] int fdOut() const noexcept; + /** FD handle to child's stderr. */ + [[nodiscard]] int fdError() const noexcept; + /** Process id of child. */ + [[nodiscard]] pid_t pid() const noexcept; + + private: + using PipePair = std::pair<int, int>; + using InitPipe = std::optional<PipePair>; + + ProcessPipes(const std::vector<std::string> & args, InitPipe &&, InitPipe &&, InitPipe &&); + + static InitPipe pipeSetup(bool setup, bool swap); + static void closeChild(const InitPipe & child) noexcept; + static void dupChild(int, const InitPipe & child) noexcept; + static void closeAllOpenFiles() noexcept; + + using FHandle = ::AdHoc::Handle<int, int (*)(int)>; + using OFHandle = std::optional<FHandle>; + const pid_t child; + OFHandle in; + const OFHandle out, error; + }; + + } } #endif - diff --git a/libadhocutil/resourcePool.cpp b/libadhocutil/resourcePool.cpp index 0724a81..cc2cec0 100644 --- a/libadhocutil/resourcePool.cpp +++ b/libadhocutil/resourcePool.cpp @@ -2,10 +2,7 @@ #include "compileTimeFormatter.h" namespace AdHoc { - TimeOutOnResourcePool::TimeOutOnResourcePool(const char * const n) : - name(n) - { - } + TimeOutOnResourcePool::TimeOutOnResourcePool(const char * const n) : name(n) { } AdHocFormatter(TimeOutOnResourcePoolMsg, "Timeout getting a resource from pool of %?"); std::string @@ -14,11 +11,7 @@ namespace AdHoc { return TimeOutOnResourcePoolMsg::get(name); } - NoCurrentResource::NoCurrentResource(const std::thread::id & id, const char * const n) : - threadId(id), - name(n) - { - } + NoCurrentResource::NoCurrentResource(const std::thread::id & id, const char * const n) : threadId(id), name(n) { } AdHocFormatter(NoCurrentResourceMsg, "Thread %? has no current resource handle of type %?"); std::string @@ -27,4 +20,3 @@ namespace AdHoc { return NoCurrentResourceMsg::get(threadId, name); } } - diff --git a/libadhocutil/resourcePool.h b/libadhocutil/resourcePool.h index 923565e..17694e8 100644 --- a/libadhocutil/resourcePool.h +++ b/libadhocutil/resourcePool.h @@ -1,156 +1,150 @@ #ifndef ADHOCUTIL_RESOURCEPOOL_H #define ADHOCUTIL_RESOURCEPOOL_H -#include <tuple> -#include <shared_mutex> +#include "c++11Helpers.h" +#include "exception.h" +#include "semaphore.h" +#include "visibility.h" #include <atomic> -#include <thread> #include <list> #include <map> -#include "semaphore.h" -#include "exception.h" -#include "visibility.h" -#include "c++11Helpers.h" +#include <shared_mutex> +#include <thread> +#include <tuple> namespace AdHoc { - template <typename Resource> - class ResourcePool; + template<typename Resource> class ResourcePool; /// A handle to a resource allocated from a ResourcePool. - template <typename Resource> - class DLL_PUBLIC ResourceHandle { - public: - /// Handle to an allocated resource, the pool it belongs to and a count of active references. - using Object = std::tuple<std::shared_ptr<Resource>, ResourcePool<Resource> *>; - - /// Create a reference to a new resource. - explicit ResourceHandle(std::shared_ptr<Object>) noexcept; - /// Standard move/copy support - SPECIAL_MEMBERS_CONS(ResourceHandle, default); - ~ResourceHandle() noexcept; - - /// Reference to an existing resource. - ResourceHandle & operator=(const ResourceHandle &) noexcept; - /// Move reference to an existing resource. - ResourceHandle & operator=(ResourceHandle &&) noexcept; - /// Access to the resource. - Resource * operator->() const noexcept; - /// Access to the resource. - Resource * get() const noexcept; - /// Release the resource back to the pool. - void release() noexcept; - /// Cast to bool. - explicit operator bool() const noexcept; - - /// Get number of handles to this resource. - [[nodiscard]] unsigned int handleCount() const; - - private: - DLL_PRIVATE void decRef() noexcept; - std::shared_ptr<Object> resource; + template<typename Resource> class DLL_PUBLIC ResourceHandle { + public: + /// Handle to an allocated resource, the pool it belongs to and a count of active references. + using Object = std::tuple<std::shared_ptr<Resource>, ResourcePool<Resource> *>; + + /// Create a reference to a new resource. + explicit ResourceHandle(std::shared_ptr<Object>) noexcept; + /// Standard move/copy support + SPECIAL_MEMBERS_CONS(ResourceHandle, default); + ~ResourceHandle() noexcept; + + /// Reference to an existing resource. + ResourceHandle & operator=(const ResourceHandle &) noexcept; + /// Move reference to an existing resource. + ResourceHandle & operator=(ResourceHandle &&) noexcept; + /// Access to the resource. + Resource * operator->() const noexcept; + /// Access to the resource. + Resource * get() const noexcept; + /// Release the resource back to the pool. + void release() noexcept; + /// Cast to bool. + explicit operator bool() const noexcept; + + /// Get number of handles to this resource. + [[nodiscard]] unsigned int handleCount() const; + + private: + DLL_PRIVATE void decRef() noexcept; + std::shared_ptr<Object> resource; }; /// A fully featured resource pool for sharing and reusing a finite set of /// resources, possibly across multiple threads. - template <typename Resource> - class DLL_PUBLIC ResourcePool { - public: - friend class ResourceHandle<Resource>; - - /// Create a new resource pool. - /// @param maxSize The upper limit of how many concurrent active resources there can be. - /// @param keep The number of resources to cache for reuse. - ResourcePool(unsigned int maxSize, unsigned int keep); - virtual ~ResourcePool(); - - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(ResourcePool); - - /// Get a resource from the pool (maybe cached, maybe constructed afresh) - ResourceHandle<Resource> get(); - /// Get a resource from the pool (with timeout on max size of pool) - /// @param ms Timeout in milliseconds. - ResourceHandle<Resource> get(unsigned int ms); - /// Get a new handle to the resource previous allocated to the current. - ResourceHandle<Resource> getMine(); - /// Go idle; destroy all cached resources, currently active instances are untouched. - void idle(); - - /// Get number of active resources. - unsigned int inUseCount() const; - /// Get number of available cached resources. - unsigned int availableCount() const; - /// Get number of free slots. - unsigned int freeCount() const; - - protected: - /// Create a new resource instance to add to the pool. - virtual std::shared_ptr<Resource> createResource() const = 0; - /// Test a cached resource is still suitable for use before re-use (defaults to no-op). - virtual void testResource(Resource const *) const; - /// Test a cached resource is still suitable for use on return (defaults to no-op). - virtual void returnTestResource(Resource const *) const; - - private: - using Available = std::list<std::shared_ptr<Resource>>; - using InUse = std::multimap<std::thread::id, std::shared_ptr<typename ResourceHandle<Resource>::Object>>; - - void putBack(const std::shared_ptr<Resource> &); - void discard(const std::shared_ptr<Resource> &); - - DLL_PRIVATE static void removeFrom(const std::shared_ptr<Resource> &, InUse &); - DLL_PRIVATE ResourceHandle<Resource> getOne(); - - mutable std::shared_mutex lock; - Semaphore poolSize; - unsigned int keep; - Available available; - InUse inUse; + template<typename Resource> class DLL_PUBLIC ResourcePool { + public: + friend class ResourceHandle<Resource>; + + /// Create a new resource pool. + /// @param maxSize The upper limit of how many concurrent active resources there can be. + /// @param keep The number of resources to cache for reuse. + ResourcePool(unsigned int maxSize, unsigned int keep); + virtual ~ResourcePool(); + + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(ResourcePool); + + /// Get a resource from the pool (maybe cached, maybe constructed afresh) + ResourceHandle<Resource> get(); + /// Get a resource from the pool (with timeout on max size of pool) + /// @param ms Timeout in milliseconds. + ResourceHandle<Resource> get(unsigned int ms); + /// Get a new handle to the resource previous allocated to the current. + ResourceHandle<Resource> getMine(); + /// Go idle; destroy all cached resources, currently active instances are untouched. + void idle(); + + /// Get number of active resources. + unsigned int inUseCount() const; + /// Get number of available cached resources. + unsigned int availableCount() const; + /// Get number of free slots. + unsigned int freeCount() const; + + protected: + /// Create a new resource instance to add to the pool. + virtual std::shared_ptr<Resource> createResource() const = 0; + /// Test a cached resource is still suitable for use before re-use (defaults to no-op). + virtual void testResource(Resource const *) const; + /// Test a cached resource is still suitable for use on return (defaults to no-op). + virtual void returnTestResource(Resource const *) const; + + private: + using Available = std::list<std::shared_ptr<Resource>>; + using InUse = std::multimap<std::thread::id, std::shared_ptr<typename ResourceHandle<Resource>::Object>>; + + void putBack(const std::shared_ptr<Resource> &); + void discard(const std::shared_ptr<Resource> &); + + DLL_PRIVATE static void removeFrom(const std::shared_ptr<Resource> &, InUse &); + DLL_PRIVATE ResourceHandle<Resource> getOne(); + + mutable std::shared_mutex lock; + Semaphore poolSize; + unsigned int keep; + Available available; + InUse inUse; }; /// Represents a failure to acquire a new resource within the given timeout. class DLL_PUBLIC TimeOutOnResourcePool : public AdHoc::StdException { - public: - /// Constrcut a new timeout exception for the given resource type. - explicit TimeOutOnResourcePool(const char * const type); + public: + /// Constrcut a new timeout exception for the given resource type. + explicit TimeOutOnResourcePool(const char * const type); - std::string message() const noexcept override; + std::string message() const noexcept override; - private: - const char * const name; + private: + const char * const name; }; /// Represents a failure to acquire a new resource of type R within the given timeout. - template <typename R> - class DLL_PUBLIC TimeOutOnResourcePoolT : public TimeOutOnResourcePool { - public: - TimeOutOnResourcePoolT(); + template<typename R> class DLL_PUBLIC TimeOutOnResourcePoolT : public TimeOutOnResourcePool { + public: + TimeOutOnResourcePoolT(); }; /// Represents a request for the current thread's previous allocated resource /// when one has not been allocated. class DLL_PUBLIC NoCurrentResource : public AdHoc::StdException { - public: - /// Construct for a specific thread and resource type. - NoCurrentResource(const std::thread::id &, const char * const type); + public: + /// Construct for a specific thread and resource type. + NoCurrentResource(const std::thread::id &, const char * const type); - std::string message() const noexcept override; + std::string message() const noexcept override; - private: - const std::thread::id threadId; - const char * const name; + private: + const std::thread::id threadId; + const char * const name; }; /// Represents a request for the current thread's previous allocated resource /// of type R when one has not been allocated. - template <typename R> - class DLL_PUBLIC NoCurrentResourceT : public NoCurrentResource { - public: - /// Construct for a specific thread and resource type R. - explicit NoCurrentResourceT(const std::thread::id &); + template<typename R> class DLL_PUBLIC NoCurrentResourceT : public NoCurrentResource { + public: + /// Construct for a specific thread and resource type R. + explicit NoCurrentResourceT(const std::thread::id &); }; } #endif - diff --git a/libadhocutil/resourcePool.impl.h b/libadhocutil/resourcePool.impl.h index a58de87..954a475 100644 --- a/libadhocutil/resourcePool.impl.h +++ b/libadhocutil/resourcePool.impl.h @@ -1,31 +1,28 @@ #ifndef ADHOCUTIL_RESOURCEPOOL_IMPL_H #define ADHOCUTIL_RESOURCEPOOL_IMPL_H -#include <boost/assert.hpp> -#include "resourcePool.h" #include "lockHelpers.h" +#include "resourcePool.h" #include "safeMapFind.h" +#include <boost/assert.hpp> namespace AdHoc { // // ResourceHandle // - template <typename R> - ResourceHandle<R>::ResourceHandle(std::shared_ptr<Object> o) noexcept : - resource(std::move(o)) + template<typename R> ResourceHandle<R>::ResourceHandle(std::shared_ptr<Object> o) noexcept : resource(std::move(o)) { } - template <typename R> - ResourceHandle<R>::~ResourceHandle() noexcept + template<typename R> ResourceHandle<R>::~ResourceHandle() noexcept { if (resource) { decRef(); } } - template <typename R> + template<typename R> unsigned int ResourceHandle<R>::handleCount() const { @@ -34,7 +31,7 @@ namespace AdHoc { return resource.use_count() - 1; } - template <typename R> + template<typename R> R * ResourceHandle<R>::get() const noexcept { @@ -42,20 +39,19 @@ namespace AdHoc { return std::get<0>(*resource).get(); } - template <typename R> + template<typename R> void ResourceHandle<R>::release() noexcept { decRef(); } - template <typename R> - ResourceHandle<R>::operator bool() const noexcept + template<typename R> ResourceHandle<R>::operator bool() const noexcept { return (bool)resource; } - template <typename R> + template<typename R> R * ResourceHandle<R>::operator->() const noexcept { @@ -63,7 +59,7 @@ namespace AdHoc { return std::get<0>(*resource).get(); } - template <typename R> + template<typename R> ResourceHandle<R> & ResourceHandle<R>::operator=(const ResourceHandle & rh) noexcept { @@ -76,7 +72,7 @@ namespace AdHoc { return *this; } - template <typename R> + template<typename R> ResourceHandle<R> & ResourceHandle<R>::operator=(ResourceHandle && rh) noexcept { @@ -89,7 +85,7 @@ namespace AdHoc { return *this; } - template <typename R> + template<typename R> void ResourceHandle<R>::decRef() noexcept { @@ -112,34 +108,28 @@ namespace AdHoc { // ResourcePool // - template <typename R> - ResourcePool<R>::ResourcePool(unsigned int max, unsigned int k) : - poolSize(max), - keep(k) - { - } + template<typename R> ResourcePool<R>::ResourcePool(unsigned int max, unsigned int k) : poolSize(max), keep(k) { } - template <typename R> - ResourcePool<R>::~ResourcePool() + template<typename R> ResourcePool<R>::~ResourcePool() { for (auto & r : inUse) { std::get<1>(*r.second) = nullptr; } } - template <typename R> + template<typename R> void ResourcePool<R>::testResource(R const *) const { } - template <typename R> + template<typename R> void ResourcePool<R>::returnTestResource(R const *) const { } - template <typename R> + template<typename R> unsigned int ResourcePool<R>::inUseCount() const { @@ -147,7 +137,7 @@ namespace AdHoc { return inUse.size(); } - template <typename R> + template<typename R> unsigned int ResourcePool<R>::availableCount() const { @@ -155,7 +145,7 @@ namespace AdHoc { return available.size(); } - template <typename R> + template<typename R> unsigned int ResourcePool<R>::freeCount() const { @@ -163,7 +153,7 @@ namespace AdHoc { return poolSize.freeCount(); } - template <typename R> + template<typename R> ResourceHandle<R> ResourcePool<R>::getMine() { @@ -171,7 +161,7 @@ namespace AdHoc { return ResourceHandle(safeMapLookup<NoCurrentResourceT<R>>(inUse, std::this_thread::get_id())); } - template <typename R> + template<typename R> void ResourcePool<R>::idle() { @@ -179,7 +169,7 @@ namespace AdHoc { available.clear(); } - template <typename R> + template<typename R> ResourceHandle<R> ResourcePool<R>::get() { @@ -187,13 +177,13 @@ namespace AdHoc { try { return ResourceHandle(getOne()); } - catch(...) { + catch (...) { poolSize.notify(); throw; } } - template <typename R> + template<typename R> ResourceHandle<R> ResourcePool<R>::get(unsigned int timeout) { @@ -203,13 +193,13 @@ namespace AdHoc { try { return getOne(); } - catch(...) { + catch (...) { poolSize.notify(); throw; } } - template <typename R> + template<typename R> ResourceHandle<R> ResourcePool<R>::getOne() { @@ -220,7 +210,7 @@ namespace AdHoc { testResource(r.get()); auto ro = std::make_shared<typename ResourceHandle<R>::Object>(r, this); available.pop_front(); - inUse.insert({ std::this_thread::get_id(), ro }); + inUse.insert({std::this_thread::get_id(), ro}); return ResourceHandle(ro); } catch (...) { @@ -228,11 +218,11 @@ namespace AdHoc { } } auto ro = std::make_shared<typename ResourceHandle<R>::Object>(createResource(), this); - inUse.insert({ std::this_thread::get_id(), ro }); + inUse.insert({std::this_thread::get_id(), ro}); return ResourceHandle(ro); } - template <typename R> + template<typename R> void ResourcePool<R>::putBack(const std::shared_ptr<R> & r) { @@ -249,7 +239,7 @@ namespace AdHoc { poolSize.notify(); } - template <typename R> + template<typename R> void ResourcePool<R>::discard(const std::shared_ptr<R> & r) { @@ -258,7 +248,7 @@ namespace AdHoc { poolSize.notify(); } - template <typename R> + template<typename R> void ResourcePool<R>::removeFrom(const std::shared_ptr<R> & r, InUse & inUse) { @@ -271,19 +261,15 @@ namespace AdHoc { } } - template <typename R> - TimeOutOnResourcePoolT<R>::TimeOutOnResourcePoolT() : - TimeOutOnResourcePool(typeid(R).name()) + template<typename R> TimeOutOnResourcePoolT<R>::TimeOutOnResourcePoolT() : TimeOutOnResourcePool(typeid(R).name()) { } - template <typename R> - NoCurrentResourceT<R>::NoCurrentResourceT(const std::thread::id & id) : - NoCurrentResource(id, typeid(R).name()) + template<typename R> + NoCurrentResourceT<R>::NoCurrentResourceT(const std::thread::id & id) : NoCurrentResource(id, typeid(R).name()) { } } #endif - diff --git a/libadhocutil/runtimeContext.cpp b/libadhocutil/runtimeContext.cpp index ba3e2f9..9eeee0d 100644 --- a/libadhocutil/runtimeContext.cpp +++ b/libadhocutil/runtimeContext.cpp @@ -5,44 +5,42 @@ namespace AdHoc::System { -RuntimeContext::RuntimeContext(size_t stacksize) : - stack(stacksize) -{ - if (getcontext(&ctxCallback) == -1) { - throw SystemException("getcontext(3) failed", strerror(errno), errno); + RuntimeContext::RuntimeContext(size_t stacksize) : stack(stacksize) + { + if (getcontext(&ctxCallback) == -1) { + throw SystemException("getcontext(3) failed", strerror(errno), errno); + } + ctxCallback.uc_stack.ss_sp = &stack.front(); + ctxCallback.uc_stack.ss_size = stacksize; + ctxCallback.uc_link = &ctxInitial; + makecontext(&ctxCallback, (void (*)()) & RuntimeContext::callbackWrapper, 1, this); } - ctxCallback.uc_stack.ss_sp = &stack.front(); - ctxCallback.uc_stack.ss_size = stacksize; - ctxCallback.uc_link = &ctxInitial; - makecontext(&ctxCallback, (void (*)())&RuntimeContext::callbackWrapper, 1, this); -} -void -RuntimeContext::swapContext() -{ - swapped = !swapped; - if (swapped) { - swapcontext(&ctxInitial, &ctxCallback); - } - else { - if (!completed) { - swapcontext(&ctxCallback, &ctxInitial); + void + RuntimeContext::swapContext() + { + swapped = !swapped; + if (swapped) { + swapcontext(&ctxInitial, &ctxCallback); + } + else { + if (!completed) { + swapcontext(&ctxCallback, &ctxInitial); + } } } -} -bool -RuntimeContext::hasCompleted() const -{ - return completed; -} + bool + RuntimeContext::hasCompleted() const + { + return completed; + } -void -RuntimeContext::callbackWrapper(RuntimeContext * rc) -{ - rc->callback(); - rc->completed = true; -} + void + RuntimeContext::callbackWrapper(RuntimeContext * rc) + { + rc->callback(); + rc->completed = true; + } } - diff --git a/libadhocutil/runtimeContext.h b/libadhocutil/runtimeContext.h index 4a0fada..64ee1e2 100644 --- a/libadhocutil/runtimeContext.h +++ b/libadhocutil/runtimeContext.h @@ -1,52 +1,51 @@ #ifndef ADHOCUTIL_RUNTIMECONTEXT_H #define ADHOCUTIL_RUNTIMECONTEXT_H +#include "c++11Helpers.h" +#include "visibility.h" #include <cstdlib> #include <ucontext.h> -#include "visibility.h" -#include "c++11Helpers.h" #include <vector> namespace AdHoc { -namespace System { - -/// Runtime Context -/** - * Create an alternate stack for processing. - */ -class DLL_PUBLIC RuntimeContext { - public: + namespace System { + + /// Runtime Context /** - * Create a new RuntimeContent - * @param stacksize The size in bytes of the new stack. + * Create an alternate stack for processing. */ - explicit RuntimeContext(size_t stacksize = 16384); - virtual ~RuntimeContext() = default; - /// Standard move/copy support - SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(RuntimeContext); - - /** Swap to/from the contained stack. */ - void swapContext(); - - /** Has the callback on the contained stack run to completion? */ - [[nodiscard]] bool hasCompleted() const; - - protected: - /** Overridden in a sub-class to implement functionality in the alternate stack */ - DLL_PRIVATE virtual void callback() = 0; - - private: - DLL_PRIVATE static void callbackWrapper(RuntimeContext * rc); - - std::vector<char> stack; - ucontext_t ctxInitial {}; - ucontext_t ctxCallback {}; - bool completed { false }; - bool swapped { false}; -}; - -} + class DLL_PUBLIC RuntimeContext { + public: + /** + * Create a new RuntimeContent + * @param stacksize The size in bytes of the new stack. + */ + explicit RuntimeContext(size_t stacksize = 16384); + virtual ~RuntimeContext() = default; + /// Standard move/copy support + SPECIAL_MEMBERS_DEFAULT_MOVE_NO_COPY(RuntimeContext); + + /** Swap to/from the contained stack. */ + void swapContext(); + + /** Has the callback on the contained stack run to completion? */ + [[nodiscard]] bool hasCompleted() const; + + protected: + /** Overridden in a sub-class to implement functionality in the alternate stack */ + DLL_PRIVATE virtual void callback() = 0; + + private: + DLL_PRIVATE static void callbackWrapper(RuntimeContext * rc); + + std::vector<char> stack; + ucontext_t ctxInitial {}; + ucontext_t ctxCallback {}; + bool completed {false}; + bool swapped {false}; + }; + + } } #endif - diff --git a/libadhocutil/safeMapFind.h b/libadhocutil/safeMapFind.h index 980c9b3..3a11f0c 100644 --- a/libadhocutil/safeMapFind.h +++ b/libadhocutil/safeMapFind.h @@ -5,59 +5,59 @@ namespace AdHoc { -/* - * Find the key and return the iterator to the pair, - * or throw Ex(key) if not found. - */ -template <class Ex, class Map> -typename Map::const_iterator -safeMapFind(const Map & map, const typename Map::key_type & key) -{ - if (auto i = map.find(key); i != map.end()) { - return i; + /* + * Find the key and return the iterator to the pair, + * or throw Ex(key) if not found. + */ + template<class Ex, class Map> + typename Map::const_iterator + safeMapFind(const Map & map, const typename Map::key_type & key) + { + if (auto i = map.find(key); i != map.end()) { + return i; + } + throw Ex(key); } - throw Ex(key); -} -/* - * Find the key and return the mapped value - * or the provided default value if not found. - */ -template <class Map> -typename Map::mapped_type -defaultMapLookup(const Map & map, const typename Map::key_type & key, const typename Map::mapped_type & def = typename Map::mapped_type()) -{ - if (auto i = map.find(key); i != map.end()) { - return i->second; + /* + * Find the key and return the mapped value + * or the provided default value if not found. + */ + template<class Map> + typename Map::mapped_type + defaultMapLookup(const Map & map, const typename Map::key_type & key, + const typename Map::mapped_type & def = typename Map::mapped_type()) + { + if (auto i = map.find(key); i != map.end()) { + return i->second; + } + return def; } - return def; -} -/* - * Find the key and return the mapped value - * or throw Ex(key) if not found. - */ -template <class Ex, class Map> -const typename Map::mapped_type & -safeMapLookup(const Map & map, const typename Map::key_type & key) -{ - if (auto i = map.find(key); i != map.end()) { - return i->second; + /* + * Find the key and return the mapped value + * or throw Ex(key) if not found. + */ + template<class Ex, class Map> + const typename Map::mapped_type & + safeMapLookup(const Map & map, const typename Map::key_type & key) + { + if (auto i = map.find(key); i != map.end()) { + return i->second; + } + throw Ex(key); } - throw Ex(key); -} -/* - * Simple search, true if found, false otherwise - */ -template <class Cont> -bool -containerContains(const Cont & c, const typename Cont::value_type & v) -{ - return (std::find(c.begin(), c.end(), v) != c.end()); -} + /* + * Simple search, true if found, false otherwise + */ + template<class Cont> + bool + containerContains(const Cont & c, const typename Cont::value_type & v) + { + return (std::find(c.begin(), c.end(), v) != c.end()); + } } #endif - diff --git a/libadhocutil/scopeExit.cpp b/libadhocutil/scopeExit.cpp index 0163aad..7384a66 100644 --- a/libadhocutil/scopeExit.cpp +++ b/libadhocutil/scopeExit.cpp @@ -2,43 +2,43 @@ namespace AdHoc { -ScopeExit::ScopeExit() = default; + ScopeExit::ScopeExit() = default; -ScopeExit::ScopeExit(const Event & onexitpre, const Event & onsuccess, const Event & onfailure, const Event & onexitpost) -{ - if (onexitpre) { - onExitPre.push_back(onexitpre); - } - if (onsuccess) { - onSuccess.push_back(onsuccess); - } - if (onfailure) { - onFailure.push_back(onfailure); - } - if (onexitpost) { - onExitPost.push_back(onexitpost); + ScopeExit::ScopeExit( + const Event & onexitpre, const Event & onsuccess, const Event & onfailure, const Event & onexitpost) + { + if (onexitpre) { + onExitPre.push_back(onexitpre); + } + if (onsuccess) { + onSuccess.push_back(onsuccess); + } + if (onfailure) { + onFailure.push_back(onfailure); + } + if (onexitpost) { + onExitPost.push_back(onexitpost); + } } -} -ScopeExit::~ScopeExit() -{ - for(const auto & e : onExitPre) { - e(); - } - if (std::uncaught_exceptions()) { - for(const auto & e : onFailure) { + ScopeExit::~ScopeExit() + { + for (const auto & e : onExitPre) { e(); } - } - else { - for(const auto & e : onSuccess) { + if (std::uncaught_exceptions()) { + for (const auto & e : onFailure) { + e(); + } + } + else { + for (const auto & e : onSuccess) { + e(); + } + } + for (const auto & e : onExitPost) { e(); } } - for(const auto & e : onExitPost) { - e(); - } -} } - diff --git a/libadhocutil/scopeExit.h b/libadhocutil/scopeExit.h index 9a632d4..1b50fa8 100644 --- a/libadhocutil/scopeExit.h +++ b/libadhocutil/scopeExit.h @@ -1,15 +1,15 @@ #ifndef ADHOCUTIL_SCOPEEXIT_H #define ADHOCUTIL_SCOPEEXIT_H +#include "c++11Helpers.h" +#include "visibility.h" #include <functional> #include <vector> -#include "visibility.h" -#include "c++11Helpers.h" namespace AdHoc { -/// Run code at scope exit. -class DLL_PUBLIC ScopeExit { + /// Run code at scope exit. + class DLL_PUBLIC ScopeExit { public: /** Callback for code to be run. */ using Event = std::function<void()>; @@ -24,7 +24,8 @@ class DLL_PUBLIC ScopeExit { * @param failure Only run this if the scope is exitted because of an uncaught exception. * @param post Run this code (unconditionally) last. */ - explicit ScopeExit(const Event & pre, const Event & success = Event(), const Event & failure = Event(), const Event & post = Event()); + explicit ScopeExit(const Event & pre, const Event & success = Event(), const Event & failure = Event(), + const Event & post = Event()); ~ScopeExit(); /// Standard move/copy support @@ -36,9 +37,8 @@ class DLL_PUBLIC ScopeExit { std::vector<Event> onFailure; std::vector<Event> onExitPost; /// @endcond -}; + }; } #endif - diff --git a/libadhocutil/semaphore.cpp b/libadhocutil/semaphore.cpp index 38ff0fe..b2354c2 100644 --- a/libadhocutil/semaphore.cpp +++ b/libadhocutil/semaphore.cpp @@ -1,9 +1,7 @@ #include "semaphore.h" namespace AdHoc { - Semaphore::Semaphore(unsigned int initial) : count(initial) - { - } + Semaphore::Semaphore(unsigned int initial) : count(initial) { } void Semaphore::notify() @@ -43,4 +41,3 @@ namespace AdHoc { return count; } } - diff --git a/libadhocutil/semaphore.h b/libadhocutil/semaphore.h index bb20324..b3633b0 100644 --- a/libadhocutil/semaphore.h +++ b/libadhocutil/semaphore.h @@ -4,33 +4,32 @@ // Borrowed from StackOverflow // http://stackoverflow.com/questions/4792449/c0x-has-no-semaphores-how-to-synchronize-threads +#include "visibility.h" #include <condition_variable> #include <mutex> -#include "visibility.h" namespace AdHoc { /// A portable semaphore with timeout support class DLL_PUBLIC Semaphore { - public: - /// Construct a new semaphore with optional initial count. - explicit Semaphore(unsigned int initial = 0); + public: + /// Construct a new semaphore with optional initial count. + explicit Semaphore(unsigned int initial = 0); - /// Notify one waiting thread. - void notify(); - /// Wait for a single count. - void wait(); - /// Wait for a single count with timeout. - /// @param ms Timeout in milliseconds. - bool wait(unsigned int ms); - /// Free - [[nodiscard]] unsigned int freeCount() const; + /// Notify one waiting thread. + void notify(); + /// Wait for a single count. + void wait(); + /// Wait for a single count with timeout. + /// @param ms Timeout in milliseconds. + bool wait(unsigned int ms); + /// Free + [[nodiscard]] unsigned int freeCount() const; - private: - std::mutex mutex; - std::condition_variable condition; - unsigned long count; + private: + std::mutex mutex; + std::condition_variable condition; + unsigned long count; }; } #endif - diff --git a/libadhocutil/sysImpl.cpp b/libadhocutil/sysImpl.cpp index 66ac6ea..c92b445 100644 --- a/libadhocutil/sysImpl.cpp +++ b/libadhocutil/sysImpl.cpp @@ -1,17 +1,19 @@ -#include <sys.h> #include "compileTimeFormatter.h" +#include <sys.h> namespace AdHoc { AdHocFormatter(SystemExceptionMsg, "%? (%?:%?)"); - void SystemException::ice_print(std::ostream & s) const + void + SystemException::ice_print(std::ostream & s) const { SystemExceptionMsg::write(s, task, errNo, message); } AdHocFormatter(SystemExceptionOnMsg, "%? on '%?' (%?:%?)"); - void SystemExceptionOn::ice_print(std::ostream & s) const + void + SystemExceptionOn::ice_print(std::ostream & s) const { SystemExceptionOnMsg::write(s, task, objectName, errNo, message); } diff --git a/libadhocutil/unique.h b/libadhocutil/unique.h index 5c77907..d64ac47 100644 --- a/libadhocutil/unique.h +++ b/libadhocutil/unique.h @@ -6,4 +6,3 @@ #define MAKE_UNIQUE(x) CONCATENATE(x, __COUNTER__) #endif - diff --git a/libadhocutil/unittests/testBuffer.cpp b/libadhocutil/unittests/testBuffer.cpp index f9f7726..6e58120 100644 --- a/libadhocutil/unittests/testBuffer.cpp +++ b/libadhocutil/unittests/testBuffer.cpp @@ -5,7 +5,7 @@ using namespace AdHoc; -BOOST_AUTO_TEST_CASE ( create ) +BOOST_AUTO_TEST_CASE(create) { Buffer empty; Buffer copy("const", Buffer::Copy); @@ -32,7 +32,7 @@ BOOST_AUTO_TEST_CASE ( create ) BOOST_REQUIRE_EQUAL("Nonconst", fre.str()); } -BOOST_AUTO_TEST_CASE( writestream ) +BOOST_AUTO_TEST_CASE(writestream) { std::stringstream buf; Buffer b; @@ -41,7 +41,7 @@ BOOST_AUTO_TEST_CASE( writestream ) BOOST_REQUIRE_EQUAL("Some text.And then some more.", buf.str()); } -BOOST_AUTO_TEST_CASE( appendempty ) +BOOST_AUTO_TEST_CASE(appendempty) { Buffer b; // These should not add content @@ -55,13 +55,10 @@ BOOST_AUTO_TEST_CASE( appendempty ) BOOST_REQUIRE(!b); } -BOOST_AUTO_TEST_CASE( appendthings ) +BOOST_AUTO_TEST_CASE(appendthings) { Buffer b; - b.append("string a") - .append(std::string(" b")) - .appendf(" num %d", 1) - .appendbf(" num %d", 2); + b.append("string a").append(std::string(" b")).appendf(" num %d", 1).appendbf(" num %d", 2); BOOST_REQUIRE_EQUAL(22, b.length()); BOOST_REQUIRE_EQUAL("string a b num 1 num 2", b.str()); const char * cstring = b; @@ -69,19 +66,16 @@ BOOST_AUTO_TEST_CASE( appendthings ) BOOST_REQUIRE_EQUAL("string a b num 1 num 2", cstring); } -BOOST_AUTO_TEST_CASE( writeto ) +BOOST_AUTO_TEST_CASE(writeto) { Buffer b; - b.append("string a") - .append(std::string(" b")) - .appendf(" num %d", 1) - .appendbf(" num %d", 2); + b.append("string a").append(std::string(" b")).appendf(" num %d", 1).appendbf(" num %d", 2); std::string buf(22, '\0'); b.writeto(buf.data(), 23, 0); BOOST_REQUIRE_EQUAL(buf, "string a b num 1 num 2"); } -BOOST_AUTO_TEST_CASE( operators ) +BOOST_AUTO_TEST_CASE(operators) { auto expected = "cstringstd::string"; Buffer a; @@ -102,7 +96,7 @@ BOOST_AUTO_TEST_CASE( operators ) BOOST_REQUIRE_EQUAL(expected, d.str()); } -BOOST_AUTO_TEST_CASE( clear ) +BOOST_AUTO_TEST_CASE(clear) { Buffer b("some"); BOOST_REQUIRE(b); @@ -110,7 +104,7 @@ BOOST_AUTO_TEST_CASE( clear ) BOOST_REQUIRE(!b); } -BOOST_AUTO_TEST_CASE( replacesstringbf ) +BOOST_AUTO_TEST_CASE(replacesstringbf) { auto str = Buffer().appendbf("something %d", 1234).str(); BOOST_REQUIRE_EQUAL("something 1234", str); @@ -120,4 +114,3 @@ BOOST_AUTO_TEST_CASE( replacesstringbf ) std::string macrostringbf = stringbf("something %d", 1234); BOOST_REQUIRE_EQUAL("something 1234", macrostringbf); } - diff --git a/libadhocutil/unittests/testCache.cpp b/libadhocutil/unittests/testCache.cpp index 8fba9cf..373d8d8 100644 --- a/libadhocutil/unittests/testCache.cpp +++ b/libadhocutil/unittests/testCache.cpp @@ -1,20 +1,22 @@ #define BOOST_TEST_MODULE Cache #include <boost/test/unit_test.hpp> -#include <functional> #include "cache.h" #include "cache.impl.h" +#include <functional> // NOLINTNEXTLINE(hicpp-special-member-functions) class Obj { - public: - // NOLINTNEXTLINE(hicpp-explicit-conversions) - Obj(int i) : v(i) { } - void operator=(const Obj &) = delete; - bool operator==(const int & i) const { - return v == i; - } - int v; +public: + // NOLINTNEXTLINE(hicpp-explicit-conversions) + Obj(int i) : v(i) { } + void operator=(const Obj &) = delete; + bool + operator==(const int & i) const + { + return v == i; + } + int v; }; bool @@ -25,7 +27,8 @@ operator==(const int & i, const Obj & o) namespace std { /// LCOV_EXCL_START (diagnostics) - ostream & operator<<(ostream & s, const Obj & o) + ostream & + operator<<(ostream & s, const Obj & o) { return s << o.v; } @@ -43,7 +46,7 @@ namespace AdHoc { using namespace AdHoc; -BOOST_AUTO_TEST_CASE( miss ) +BOOST_AUTO_TEST_CASE(miss) { TestCache tc; BOOST_REQUIRE_EQUAL(0, tc.size()); @@ -54,7 +57,7 @@ BOOST_AUTO_TEST_CASE( miss ) BOOST_REQUIRE_EQUAL(1, tc.size()); } -BOOST_AUTO_TEST_CASE( hit ) +BOOST_AUTO_TEST_CASE(hit) { TestCache tc; auto vu = time(nullptr) + 5; @@ -69,7 +72,7 @@ BOOST_AUTO_TEST_CASE( hit ) BOOST_REQUIRE_EQUAL(0, tc.size()); } -BOOST_AUTO_TEST_CASE( multivalues ) +BOOST_AUTO_TEST_CASE(multivalues) { TestCache tc; auto vu = time(nullptr) + 5; @@ -89,7 +92,7 @@ BOOST_AUTO_TEST_CASE( multivalues ) BOOST_REQUIRE_EQUAL(0, tc.size()); } -BOOST_AUTO_TEST_CASE( expired ) +BOOST_AUTO_TEST_CASE(expired) { TestCache tc; tc.add("miss", 3, time(nullptr) - 5); @@ -110,13 +113,19 @@ BOOST_AUTO_TEST_CASE( expired ) BOOST_REQUIRE_EQUAL(1, tc.size()); } -BOOST_AUTO_TEST_CASE( callcache ) +BOOST_AUTO_TEST_CASE(callcache) { TestCache tc; int callCount = 0; auto vu = time(nullptr) + 5; BOOST_REQUIRE_EQUAL(nullptr, tc.get("key")); - tc.addFactory("key", [&callCount]{ callCount++; return 3; }, vu); + tc.addFactory( + "key", + [&callCount] { + callCount++; + return 3; + }, + vu); BOOST_REQUIRE_EQUAL(0, callCount); BOOST_REQUIRE_EQUAL(3, *tc.get("key")); BOOST_REQUIRE_EQUAL(1, callCount); @@ -124,13 +133,19 @@ BOOST_AUTO_TEST_CASE( callcache ) BOOST_REQUIRE_EQUAL(1, callCount); } -BOOST_AUTO_TEST_CASE( pointercallcache ) +BOOST_AUTO_TEST_CASE(pointercallcache) { TestCache tc; int callCount = 0; auto vu = time(nullptr) + 5; BOOST_REQUIRE_EQUAL(nullptr, tc.get("key")); - tc.addPointerFactory("key", [&callCount]{ callCount++; return TestCache::Value(new Obj(3)); }, vu); + tc.addPointerFactory( + "key", + [&callCount] { + callCount++; + return TestCache::Value(new Obj(3)); + }, + vu); BOOST_REQUIRE_EQUAL(0, callCount); BOOST_REQUIRE_EQUAL(3, *tc.get("key")); BOOST_REQUIRE_EQUAL(1, callCount); @@ -138,7 +153,7 @@ BOOST_AUTO_TEST_CASE( pointercallcache ) BOOST_REQUIRE_EQUAL(1, callCount); } -BOOST_AUTO_TEST_CASE( hitThenRenove ) +BOOST_AUTO_TEST_CASE(hitThenRenove) { TestCache tc; tc.add("key", 3, time(nullptr) + 5); @@ -150,7 +165,7 @@ BOOST_AUTO_TEST_CASE( hitThenRenove ) BOOST_REQUIRE_EQUAL(3, *h); } -BOOST_AUTO_TEST_CASE( addPointer ) +BOOST_AUTO_TEST_CASE(addPointer) { TestCache tc; auto v = TestCache::Value(new Obj(3)); @@ -159,4 +174,3 @@ BOOST_AUTO_TEST_CASE( addPointer ) BOOST_REQUIRE(h); BOOST_REQUIRE_EQUAL(3, *h); } - diff --git a/libadhocutil/unittests/testCompileTimeFormatter.cpp b/libadhocutil/unittests/testCompileTimeFormatter.cpp index 2109e01..ad5adbf 100644 --- a/libadhocutil/unittests/testCompileTimeFormatter.cpp +++ b/libadhocutil/unittests/testCompileTimeFormatter.cpp @@ -1,10 +1,10 @@ #define BOOST_TEST_MODULE CompileTimeFormatter #include <boost/test/unit_test.hpp> +#include "memstream.h" #include <compileTimeFormatter.h> -#include <fileUtils.h> #include <definedDirs.h> -#include "memstream.h" +#include <fileUtils.h> #include <filesystem> @@ -22,7 +22,10 @@ constexpr const char * formatStringCustom = "custom %()"; constexpr const char * formatStringCustomParam1 = "custom %(\x3)"; constexpr const char * formatStringCustomParam2 = "custom %(\x9)"; constexpr const char * formatStringCustomLong = "custom %(longname)"; -constexpr const char * formatStringLong = " "; +constexpr const char * formatStringLong + = " " + " " + " "; constexpr const char * formatStringMultiArg = "value%ra"; constexpr const char * formatStringEscape1 = "literal %% percentage."; constexpr const char * formatStringEscape2 = "literal %%? percentage."; @@ -33,8 +36,9 @@ namespace AdHoc { // Custom stream writer formatter, formats as // -( bracketed expression )- StreamWriterT('(', ')') { - template<typename P, typename ... Pn> - static void write(stream & s, const P & p, const Pn & ... pn) + template<typename P, typename... Pn> + static void + write(stream & s, const P & p, const Pn &... pn) { s << "-( " << p << " )-"; StreamWriter::next(s, pn...); @@ -43,8 +47,9 @@ namespace AdHoc { // Custom stream writer formatter with a long identifier, formats as // ---( bracketed expression )--- StreamWriterT('(', 'l', 'o', 'n', 'g', 'n', 'a', 'm', 'e', ')') { - template<typename P, typename ... Pn> - static void write(stream & s, const P & p, const Pn & ... pn) + template<typename P, typename... Pn> + static void + write(stream & s, const P & p, const Pn &... pn) { s << "---( " << p << " )---"; StreamWriter::next(s, pn...); @@ -53,8 +58,9 @@ namespace AdHoc { // Custom stream writer formatter that has parameter in the format string, formats as // dashes*-( bracketed expression )dashes*- StreamWriterTP(dashes, '(', dashes, ')') { - template<typename P, typename ... Pn> - static void write(stream & s, const P & p, const Pn & ... pn) + template<typename P, typename... Pn> + static void + write(stream & s, const P & p, const Pn &... pn) { // NOLINTNEXTLINE(bugprone-string-constructor) std::string d(dashes, '-'); @@ -65,8 +71,9 @@ namespace AdHoc { // Custom stream writer formatter, formats // right-aligned by given width StreamWriterT('r', 'a') { - template<typename P, typename ... Pn> - static void write(stream & s, int width, const P & p, const Pn & ... pn) + template<typename P, typename... Pn> + static void + write(stream & s, int width, const P & p, const Pn &... pn) { std::stringstream buf; buf << p; @@ -116,137 +123,137 @@ static_assert(strchrnul<formatStringLiteral, 'e'>() == 3); static_assert(strchrnul<formatStringLiteral, 'f'>() == 7); #endif -BOOST_FIXTURE_TEST_SUITE( TestStreamWrite, std::stringstream ) +BOOST_FIXTURE_TEST_SUITE(TestStreamWrite, std::stringstream) -BOOST_AUTO_TEST_CASE ( empty ) +BOOST_AUTO_TEST_CASE(empty) { Formatter<formatEdgeCaseEmpty>::write(*this); BOOST_CHECK(this->str().empty()); } -BOOST_AUTO_TEST_CASE ( single ) +BOOST_AUTO_TEST_CASE(single) { Formatter<formatEdgeCaseSingle>::write(*this); BOOST_CHECK_EQUAL(this->str(), "1"); } -BOOST_AUTO_TEST_CASE ( start ) +BOOST_AUTO_TEST_CASE(start) { Formatter<formatEdgeCaseFormatStart>::write(*this, 10); BOOST_CHECK_EQUAL(this->str(), "10 after"); } -BOOST_AUTO_TEST_CASE ( end ) +BOOST_AUTO_TEST_CASE(end) { Formatter<formatEdgeCaseFormatEnd>::write(*this, 10); BOOST_CHECK_EQUAL(this->str(), "before 10"); } -BOOST_AUTO_TEST_CASE ( lonely ) +BOOST_AUTO_TEST_CASE(lonely) { Formatter<formatEdgeCaseFormatLonely>::write(*this, 10); BOOST_CHECK_EQUAL(this->str(), "10"); } -BOOST_AUTO_TEST_CASE ( literal ) +BOOST_AUTO_TEST_CASE(literal) { Formatter<formatStringLiteral>::write(*this); BOOST_CHECK_EQUAL(this->str(), "literal"); } -BOOST_AUTO_TEST_CASE ( singleInt ) +BOOST_AUTO_TEST_CASE(singleInt) { Formatter<formatStringSingle>::write(*this, 32); BOOST_CHECK_EQUAL(this->str(), "single 32."); } -BOOST_AUTO_TEST_CASE ( singleIntReturn ) +BOOST_AUTO_TEST_CASE(singleIntReturn) { BOOST_CHECK_EQUAL(Formatter<formatStringSingle>::write(*this, 32).str(), "single 32."); } -BOOST_AUTO_TEST_CASE ( singleDouble ) +BOOST_AUTO_TEST_CASE(singleDouble) { Formatter<formatStringSingle>::write(*this, 3.14); BOOST_CHECK_EQUAL(this->str(), "single 3.14."); } -BOOST_AUTO_TEST_CASE ( singlePath ) +BOOST_AUTO_TEST_CASE(singlePath) { std::filesystem::path p("/tmp/test/path"); Formatter<formatStringSingle>::write(*this, p); BOOST_CHECK_EQUAL(this->str(), R"(single "/tmp/test/path".)"); } -BOOST_AUTO_TEST_CASE ( multi ) +BOOST_AUTO_TEST_CASE(multi) { Formatter<formatStringMulti>::write(*this, "one", "two"); BOOST_CHECK_EQUAL(this->str(), "First one, then two."); } -BOOST_AUTO_TEST_CASE ( escape1 ) +BOOST_AUTO_TEST_CASE(escape1) { Formatter<formatStringEscape1>::write(*this); BOOST_CHECK_EQUAL(this->str(), "literal % percentage."); } -BOOST_AUTO_TEST_CASE ( escape2 ) +BOOST_AUTO_TEST_CASE(escape2) { Formatter<formatStringEscape2>::write(*this); BOOST_CHECK_EQUAL(this->str(), "literal %? percentage."); } -BOOST_AUTO_TEST_CASE ( escape3 ) +BOOST_AUTO_TEST_CASE(escape3) { Formatter<formatStringEscape3>::write(*this, 3); BOOST_CHECK_EQUAL(this->str(), "literal %3 percentage."); } -BOOST_AUTO_TEST_CASE ( escape4 ) +BOOST_AUTO_TEST_CASE(escape4) { Formatter<formatStringEscape4>::write(*this, 3); BOOST_CHECK_EQUAL(this->str(), "literal %3% percentage."); } -BOOST_AUTO_TEST_CASE ( customBracketted ) +BOOST_AUTO_TEST_CASE(customBracketted) { Formatter<formatStringCustom>::write(*this, "expr"); BOOST_CHECK_EQUAL(this->str(), "custom -( expr )-"); } -BOOST_AUTO_TEST_CASE ( customLongName ) +BOOST_AUTO_TEST_CASE(customLongName) { Formatter<formatStringCustomLong>::write(*this, "some text here"); BOOST_CHECK_EQUAL(this->str(), "custom ---( some text here )---"); } -BOOST_AUTO_TEST_CASE ( customParam1 ) +BOOST_AUTO_TEST_CASE(customParam1) { Formatter<formatStringCustomParam1>::write(*this, "some text here"); BOOST_CHECK_EQUAL(this->str(), "custom ---( some text here )---"); } -BOOST_AUTO_TEST_CASE ( customParam2 ) +BOOST_AUTO_TEST_CASE(customParam2) { Formatter<formatStringCustomParam2>::write(*this, "some text here"); BOOST_CHECK_EQUAL(this->str(), "custom ---------( some text here )---------"); } using TestFormat = Formatter<formatStringCustom>; -BOOST_AUTO_TEST_CASE ( typedefFormat ) +BOOST_AUTO_TEST_CASE(typedefFormat) { TestFormat::write(*this, "expr"); BOOST_CHECK_EQUAL(this->str(), "custom -( expr )-"); } AdHocFormatter(TypedefWrapper, "Typedef wrapper %?."); -BOOST_AUTO_TEST_CASE ( typedefWrapper ) +BOOST_AUTO_TEST_CASE(typedefWrapper) { TypedefWrapper::write(*this, "expr"); BOOST_CHECK_EQUAL(this->str(), "Typedef wrapper expr."); } -BOOST_AUTO_TEST_CASE ( longFormatString ) +BOOST_AUTO_TEST_CASE(longFormatString) { Formatter<formatStringLong>::write(*this); BOOST_CHECK_EQUAL(this->str().length(), 246); @@ -254,7 +261,7 @@ BOOST_AUTO_TEST_CASE ( longFormatString ) BOOST_AUTO_TEST_SUITE_END(); -BOOST_AUTO_TEST_CASE ( customMultiArgRightAlign ) +BOOST_AUTO_TEST_CASE(customMultiArgRightAlign) { std::stringstream buf1, buf2, buf3; const int width = 20; @@ -266,7 +273,7 @@ BOOST_AUTO_TEST_CASE ( customMultiArgRightAlign ) BOOST_CHECK_EQUAL(buf3.str(), "value 123.45"); } -BOOST_AUTO_TEST_CASE ( get ) +BOOST_AUTO_TEST_CASE(get) { auto s = Formatter<formatStringMultiArg>::get(20, "something else"); BOOST_CHECK_EQUAL(s, "value something else"); @@ -274,7 +281,7 @@ BOOST_AUTO_TEST_CASE ( get ) constexpr #include <lorem-ipsum.h> -BOOST_AUTO_TEST_CASE( lorem_ipsum ) + BOOST_AUTO_TEST_CASE(lorem_ipsum) { using LIF = Formatter<lorem_ipsum_txt, sizeof(lorem_ipsum_txt)>; auto s = LIF::get(); @@ -286,7 +293,8 @@ BOOST_AUTO_TEST_CASE( lorem_ipsum ) namespace AdHoc { template<> - inline void appendStream(FILE & strm, const char * const p, size_t n) + inline void + appendStream(FILE & strm, const char * const p, size_t n) { BOOST_VERIFY(fwrite(p, n, 1, &strm) == 1); } @@ -299,7 +307,7 @@ operator<<(FILE & strm, const char * const p) return strm; } -BOOST_AUTO_TEST_CASE( filestar ) +BOOST_AUTO_TEST_CASE(filestar) { MemStream strm; // NOLINTNEXTLINE(misc-non-copyable-objects) @@ -330,10 +338,11 @@ static_assert(419 == decdigits<'0', '4', '1', '9'>()); // The following tests represent CTF's [partial] emulation of many // POSIX formatting features #define GLIBC_FMT_TEST(NAME, FMT, ...) \ - AdHocFormatter(NAME ## fmtr, FMT); \ - BOOST_AUTO_TEST_CASE(NAME ## t) { \ + AdHocFormatter(NAME##fmtr, FMT); \ + BOOST_AUTO_TEST_CASE(NAME##t) \ + { \ BOOST_TEST_CONTEXT(FMT) { \ - auto str = NAME ## fmtr::get(__VA_ARGS__); \ + auto str = NAME##fmtr::get(__VA_ARGS__); \ char * buf = NULL; \ int len = asprintf(&buf, FMT, __VA_ARGS__); \ auto bufp = std::unique_ptr<char, decltype(&std::free)>(buf, std::free); \ @@ -351,8 +360,8 @@ GLIBC_FMT_TEST(s5, "in %.*s.", 7, "other"); GLIBC_FMT_TEST(s35, "in %3s.", "other"); GLIBC_FMT_TEST(s55, "in %5s.", "other"); GLIBC_FMT_TEST(s115, "in %11s.", "other"); -//std::setw does not truncate strings -//GLIBC_FMT_TEST(sd35, "in %.3s.", "other"); +// std::setw does not truncate strings +// GLIBC_FMT_TEST(sd35, "in %.3s.", "other"); GLIBC_FMT_TEST(sd55, "in %.5s.", "other"); GLIBC_FMT_TEST(sd115, "in %.11s.", "other"); @@ -421,8 +430,7 @@ GLIBC_FMT_TEST(g6, "in %G.", -123.456789); GLIBC_FMT_TEST(g7, "in %g.", 123456789.123); GLIBC_FMT_TEST(g8, "in %g.", -123456789.123); -GLIBC_FMT_TEST(fmtlibt_fmt, "%0.10f:%04d:%+g:%s:%p:%c:%%\n", - 1.234, 42, 3.13, "str", (void*)1000, (int)'X'); +GLIBC_FMT_TEST(fmtlibt_fmt, "%0.10f:%04d:%+g:%s:%p:%c:%%\n", 1.234, 42, 3.13, "str", (void *)1000, (int)'X'); AdHocFormatter(chars_written_fmt, "%n %s %n %d %n"); BOOST_AUTO_TEST_CASE(chars_written) @@ -514,4 +522,3 @@ BOOST_AUTO_TEST_CASE(user_defined_literal_fmt_write) "foo %?"_fmt(str, 42); BOOST_CHECK_EQUAL("foo 42", str.str()); } - diff --git a/libadhocutil/unittests/testContext.cpp b/libadhocutil/unittests/testContext.cpp index 0447beb..edc5668 100644 --- a/libadhocutil/unittests/testContext.cpp +++ b/libadhocutil/unittests/testContext.cpp @@ -6,34 +6,35 @@ using namespace AdHoc::System; class TestRuntimeContext : public RuntimeContext { - public: - void run() - { - log += "a"; - swapContext(); - log += "b"; - swapContext(); - log += "c"; - swapContext(); - log += "d"; - } +public: + void + run() + { + log += "a"; + swapContext(); + log += "b"; + swapContext(); + log += "c"; + swapContext(); + log += "d"; + } - void callback() override - { - log += "e"; - swapContext(); - log += "f"; - swapContext(); - } + void + callback() override + { + log += "e"; + swapContext(); + log += "f"; + swapContext(); + } - std::string log; + std::string log; }; -BOOST_AUTO_TEST_CASE ( basic ) +BOOST_AUTO_TEST_CASE(basic) { TestRuntimeContext trc; trc.run(); BOOST_REQUIRE_EQUAL("aebfcd", trc.log); BOOST_REQUIRE(trc.hasCompleted()); } - diff --git a/libadhocutil/unittests/testCurl.cpp b/libadhocutil/unittests/testCurl.cpp index 977bbfd..5110c75 100644 --- a/libadhocutil/unittests/testCurl.cpp +++ b/libadhocutil/unittests/testCurl.cpp @@ -1,19 +1,18 @@ #define BOOST_TEST_MODULE Curl #include <boost/test/unit_test.hpp> -#include <functional> +#include "compileTimeFormatter.h" #include "curlHandle.h" #include "curlMultiHandle.h" #include "curlStream.h" -#include "compileTimeFormatter.h" #include "definedDirs.h" #include "net.h" #include <boost/algorithm/string/predicate.hpp> +#include <functional> using namespace AdHoc::Net; -static -size_t +static size_t discard(void *, size_t sz, size_t nm, void *) { return sz * nm; @@ -24,7 +23,7 @@ const auto urlGen = [](const std::string_view & url) { return FileUrl::get(rootDir.string(), url); }; -BOOST_AUTO_TEST_CASE( fetch_file ) +BOOST_AUTO_TEST_CASE(fetch_file) { auto url = urlGen("testCurl.cpp"); BOOST_TEST_CONTEXT(url) { @@ -34,7 +33,7 @@ BOOST_AUTO_TEST_CASE( fetch_file ) } } -BOOST_AUTO_TEST_CASE( setAndGetOptions ) +BOOST_AUTO_TEST_CASE(setAndGetOptions) { auto url = urlGen("testCurl.cpp"); CurlHandle ch(url); @@ -58,14 +57,14 @@ BOOST_AUTO_TEST_CASE( setAndGetOptions ) BOOST_REQUIRE_LT(totalTime, 50); } -BOOST_AUTO_TEST_CASE( fetch_missing ) +BOOST_AUTO_TEST_CASE(fetch_missing) { auto url = urlGen("nothere"); CurlHandle ch(url); BOOST_REQUIRE_THROW(ch.perform(), AdHoc::Net::CurlException); } -BOOST_AUTO_TEST_CASE( fetch_http_stream ) +BOOST_AUTO_TEST_CASE(fetch_http_stream) { CurlStreamSource css("https://sys.randomdan.homeip.net/env.cgi"); css.appendHeader("X-POWERED-BY: mature-cheddar"); @@ -82,7 +81,7 @@ BOOST_AUTO_TEST_CASE( fetch_http_stream ) BOOST_REQUIRE_EQUAL(1, expected); } -BOOST_AUTO_TEST_CASE( fetch_file_stream ) +BOOST_AUTO_TEST_CASE(fetch_file_stream) { auto url = urlGen("testCurl.cpp"); CurlStreamSource css(url); @@ -99,7 +98,7 @@ BOOST_AUTO_TEST_CASE( fetch_file_stream ) } } -BOOST_AUTO_TEST_CASE( fetch_missing_stream ) +BOOST_AUTO_TEST_CASE(fetch_missing_stream) { auto url = urlGen("nothere"); CurlStreamSource css(url); @@ -110,8 +109,7 @@ BOOST_AUTO_TEST_CASE( fetch_missing_stream ) BOOST_REQUIRE(!curlstrm.good()); } -static -void +static void mapFileToName(std::map<std::string, std::string> & map, const std::string & file, std::istream & curlstrm) { std::string tok; @@ -121,17 +119,20 @@ mapFileToName(std::map<std::string, std::string> & map, const std::string & file map[file] = tok; } -BOOST_AUTO_TEST_CASE( fetch_multi ) +BOOST_AUTO_TEST_CASE(fetch_multi) { using std::placeholders::_1; CurlMultiHandle cmh; std::map<std::string, std::string> files; - cmh.addCurl(urlGen("/testBuffer.cpp"), - [&files](auto && PH1) { return mapFileToName(files, "testBuffer.cpp", PH1); }); - cmh.addCurl(urlGen("/testCurl.cpp"), - [&files](auto && PH1) { return mapFileToName(files, "testCurl.cpp", PH1); }); - cmh.addCurl(urlGen("/testLocks.cpp"), - [&files](auto && PH1) { return mapFileToName(files, "testLocks.cpp", PH1); }); + cmh.addCurl(urlGen("/testBuffer.cpp"), [&files](auto && PH1) { + return mapFileToName(files, "testBuffer.cpp", PH1); + }); + cmh.addCurl(urlGen("/testCurl.cpp"), [&files](auto && PH1) { + return mapFileToName(files, "testCurl.cpp", PH1); + }); + cmh.addCurl(urlGen("/testLocks.cpp"), [&files](auto && PH1) { + return mapFileToName(files, "testLocks.cpp", PH1); + }); cmh.performAll(); BOOST_REQUIRE_EQUAL(3, files.size()); BOOST_REQUIRE_EQUAL("Locks", files["testLocks.cpp"]); @@ -139,7 +140,7 @@ BOOST_AUTO_TEST_CASE( fetch_multi ) BOOST_REQUIRE_EQUAL("Curl", files["testCurl.cpp"]); } -BOOST_AUTO_TEST_CASE( fetch_multi_fail ) +BOOST_AUTO_TEST_CASE(fetch_multi_fail) { CurlMultiHandle cmh; bool errored = false; @@ -161,4 +162,3 @@ BOOST_AUTO_TEST_CASE( fetch_multi_fail ) BOOST_REQUIRE(!finished); BOOST_REQUIRE(errored); } - diff --git a/libadhocutil/unittests/testDirs.cpp b/libadhocutil/unittests/testDirs.cpp index 08284ee..3073897 100644 --- a/libadhocutil/unittests/testDirs.cpp +++ b/libadhocutil/unittests/testDirs.cpp @@ -4,7 +4,7 @@ #include <definedDirs.h> #include <filesystem> -BOOST_AUTO_TEST_CASE( iexist ) +BOOST_AUTO_TEST_CASE(iexist) { BOOST_REQUIRE(std::filesystem::exists(selfExe)); BOOST_REQUIRE(selfExe.is_absolute()); @@ -13,4 +13,3 @@ BOOST_AUTO_TEST_CASE( iexist ) BOOST_REQUIRE(std::filesystem::is_directory(binDir)); BOOST_REQUIRE_EQUAL("libadhocutil", rootDir.parent_path().filename()); } - diff --git a/libadhocutil/unittests/testException.cpp b/libadhocutil/unittests/testException.cpp index 63fc2a3..ade3617 100644 --- a/libadhocutil/unittests/testException.cpp +++ b/libadhocutil/unittests/testException.cpp @@ -1,68 +1,75 @@ #define BOOST_TEST_MODULE Excetion #include <boost/test/unit_test.hpp> -#include <exception.h> #include <buffer.h> +#include <exception.h> using namespace AdHoc; class Ex1 : public AdHoc::StdException { - public: - Ex1(const char * f, int l) : file(f), line(l) { } - - private: - std::string message() const noexcept override - { - return stringf("Something something at %s:%d", file, line); - } +public: + Ex1(const char * f, int l) : file(f), line(l) { } + +private: + std::string + message() const noexcept override + { + return stringf("Something something at %s:%d", file, line); + } - const char * file; - const int line; + const char * file; + const int line; }; -class OtherBaseException : public std::exception { }; +class OtherBaseException : public std::exception { +}; class Ex2 : public AdHoc::Exception<OtherBaseException> { - public: - Ex2(const char * f, int l) : file(f), line(l) { } - - private: - std::string message() const noexcept override - { - return stringf("Something other something at %s:%d", file, line); - } +public: + Ex2(const char * f, int l) : file(f), line(l) { } + +private: + std::string + message() const noexcept override + { + return stringf("Something other something at %s:%d", file, line); + } - const char * file; - const int line; + const char * file; + const int line; }; class Ex3 : public AdHoc::StdException { - private: - // LCOV_EXCL_START - std::string message() const noexcept override - { - // Never called - std::abort(); - } - // LCOV_EXCL_STOP +private: + // LCOV_EXCL_START + std::string + message() const noexcept override + { + // Never called + std::abort(); + } + // LCOV_EXCL_STOP }; -void failing1() +void +failing1() { throw Ex1(__PRETTY_FUNCTION__, 1); } -void failing2() +void +failing2() { throw Ex2(__PRETTY_FUNCTION__, 2); } -void failing3() +void +failing3() { throw Ex3(); } -BOOST_AUTO_TEST_CASE( throwCatch ) +BOOST_AUTO_TEST_CASE(throwCatch) { BOOST_REQUIRE_THROW(failing1(), Ex1); BOOST_REQUIRE_THROW(failing1(), std::exception); @@ -75,7 +82,7 @@ BOOST_AUTO_TEST_CASE( throwCatch ) BOOST_REQUIRE_THROW(failing3(), std::exception); } -BOOST_AUTO_TEST_CASE( message1 ) +BOOST_AUTO_TEST_CASE(message1) { try { failing1(); @@ -85,7 +92,7 @@ BOOST_AUTO_TEST_CASE( message1 ) } } -BOOST_AUTO_TEST_CASE( message2 ) +BOOST_AUTO_TEST_CASE(message2) { try { failing2(); @@ -94,4 +101,3 @@ BOOST_AUTO_TEST_CASE( message2 ) BOOST_REQUIRE_EQUAL("Something other something at void failing2():2", ex.what()); } } - diff --git a/libadhocutil/unittests/testFactory.cpp b/libadhocutil/unittests/testFactory.cpp index 868e5b8..58ed9f7 100644 --- a/libadhocutil/unittests/testFactory.cpp +++ b/libadhocutil/unittests/testFactory.cpp @@ -10,35 +10,34 @@ using namespace AdHoc; // NOLINTNEXTLINE(hicpp-special-member-functions) class BaseThing { - public: - BaseThing(int, std::string * n) : - name(n) - { - } +public: + BaseThing(int, std::string * n) : name(n) { } - virtual ~BaseThing() = default; + virtual ~BaseThing() = default; - virtual void execute() const = 0; + virtual void execute() const = 0; - protected: - std::string * name; +protected: + std::string * name; }; class ImplOfThing : public BaseThing { - public: - ImplOfThing(int i, std::string * s) : BaseThing(i, s) {} - void execute() const override - { - *name = typeid(this).name(); - } +public: + ImplOfThing(int i, std::string * s) : BaseThing(i, s) { } + void + execute() const override + { + *name = typeid(this).name(); + } }; class OtherImplOfThing : public BaseThing { - public: - OtherImplOfThing(int i, std::string * s) : BaseThing(i, s) {} - void execute() const override - { - *name = typeid(this).name(); - } +public: + OtherImplOfThing(int i, std::string * s) : BaseThing(i, s) { } + void + execute() const override + { + *name = typeid(this).name(); + } }; using BaseThingFactory = AdHoc::Factory<BaseThing, int, std::string *>; @@ -52,12 +51,12 @@ INSTANTIATEFACTORY(BaseThing, std::string, std::string); // Factories of things with commas INSTANTIATEFACTORY(BaseThing, std::map<std::string, std::string>); -BOOST_AUTO_TEST_CASE( ready ) +BOOST_AUTO_TEST_CASE(ready) { BOOST_REQUIRE_EQUAL(2, PluginManager::getDefault()->count()); } -BOOST_AUTO_TEST_CASE( get ) +BOOST_AUTO_TEST_CASE(get) { auto all = PluginManager::getDefault()->getAll(); auto factory1 = PluginManager::getDefault()->get<BaseThingFactory>("a")->implementation(); @@ -69,7 +68,7 @@ BOOST_AUTO_TEST_CASE( get ) BOOST_REQUIRE_NE(factory1, factory3); } -BOOST_AUTO_TEST_CASE( create ) +BOOST_AUTO_TEST_CASE(create) { auto factory1 = BaseThingFactory::get("a"); auto factory2 = BaseThingFactory::get("OtherImplOfThing"); @@ -91,10 +90,9 @@ BOOST_AUTO_TEST_CASE( create ) BOOST_REQUIRE(i2 != i3); } -BOOST_AUTO_TEST_CASE( createNew ) +BOOST_AUTO_TEST_CASE(createNew) { std::string n; auto i = BaseThingFactory::createNew("a", 1, &n); BOOST_REQUIRE(i); } - diff --git a/libadhocutil/unittests/testFileUtils.cpp b/libadhocutil/unittests/testFileUtils.cpp index f92d03e..d8cf46a 100644 --- a/libadhocutil/unittests/testFileUtils.cpp +++ b/libadhocutil/unittests/testFileUtils.cpp @@ -1,18 +1,17 @@ #define BOOST_TEST_MODULE FileUtils #include <boost/test/unit_test.hpp> -#include <fileUtils.h> #include <definedDirs.h> +#include <fileUtils.h> #include <sys.h> -#define REQUIRE_INVALID_FH(fh) \ - BOOST_REQUIRE_EQUAL(fcntl(fh, F_GETFD), -1) +#define REQUIRE_INVALID_FH(fh) BOOST_REQUIRE_EQUAL(fcntl(fh, F_GETFD), -1) -#define REQUIRE_VALID_FH(fh) \ - BOOST_REQUIRE_NE(fcntl(fh, F_GETFD), -1) +#define REQUIRE_VALID_FH(fh) BOOST_REQUIRE_NE(fcntl(fh, F_GETFD), -1) -template <typename T> -void testRaw() +template<typename T> +void +testRaw() { int f = open("/proc/self/exe", O_RDONLY); BOOST_REQUIRE_NE(f, -1); @@ -20,22 +19,24 @@ void testRaw() BOOST_REQUIRE_EQUAL(f, fh); } -BOOST_AUTO_TEST_CASE( raw ) +BOOST_AUTO_TEST_CASE(raw) { testRaw<AdHoc::FileUtils::FileHandle>(); testRaw<AdHoc::FileUtils::FileHandleStat>(); testRaw<AdHoc::FileUtils::MemMap>(); } -template <typename T, typename ... P> -T openfh(P ... p) +template<typename T, typename... P> +T +openfh(P... p) { T fh(rootDir / "testFileUtils.cpp", p...); return fh; } -template <typename T, typename ... P> -T moveTest(P ... p) +template<typename T, typename... P> +T +moveTest(P... p) { T fh = openfh<T>(p...); REQUIRE_VALID_FH(fh); @@ -45,17 +46,17 @@ T moveTest(P ... p) } class Base { - public: - explicit Base(AdHoc::FileUtils::FileHandle h) : fh(std::move(h)) { } - AdHoc::FileUtils::FileHandle fh; +public: + explicit Base(AdHoc::FileUtils::FileHandle h) : fh(std::move(h)) { } + AdHoc::FileUtils::FileHandle fh; }; class Sub : public Base { - public: - explicit Sub(AdHoc::FileUtils::FileHandle h) : Base(std::move(h)) { } +public: + explicit Sub(AdHoc::FileUtils::FileHandle h) : Base(std::move(h)) { } }; -BOOST_AUTO_TEST_CASE( movePassThrough ) +BOOST_AUTO_TEST_CASE(movePassThrough) { auto f = openfh<AdHoc::FileUtils::FileHandle>(); int ffd = f.fh; @@ -69,8 +70,7 @@ BOOST_AUTO_TEST_CASE( movePassThrough ) REQUIRE_INVALID_FH(ffd); } - -BOOST_AUTO_TEST_CASE( moveFileHandle ) +BOOST_AUTO_TEST_CASE(moveFileHandle) { auto f = moveTest<AdHoc::FileUtils::FileHandle>(); REQUIRE_VALID_FH(f.fh); @@ -78,7 +78,7 @@ BOOST_AUTO_TEST_CASE( moveFileHandle ) moveTest<AdHoc::FileUtils::FileHandle>(O_RDONLY, O_NONBLOCK); } -BOOST_AUTO_TEST_CASE( moveFileHandleStat ) +BOOST_AUTO_TEST_CASE(moveFileHandleStat) { auto f = moveTest<AdHoc::FileUtils::FileHandleStat>(); REQUIRE_VALID_FH(f.fh); @@ -87,7 +87,7 @@ BOOST_AUTO_TEST_CASE( moveFileHandleStat ) moveTest<AdHoc::FileUtils::FileHandleStat>(O_RDONLY, O_NONBLOCK); } -BOOST_AUTO_TEST_CASE( moveMemMap ) +BOOST_AUTO_TEST_CASE(moveMemMap) { auto f = moveTest<AdHoc::FileUtils::MemMap>(); REQUIRE_VALID_FH(f.fh); @@ -97,7 +97,7 @@ BOOST_AUTO_TEST_CASE( moveMemMap ) moveTest<AdHoc::FileUtils::MemMap>(O_RDONLY, O_NONBLOCK); } -BOOST_AUTO_TEST_CASE( memmap ) +BOOST_AUTO_TEST_CASE(memmap) { AdHoc::FileUtils::MemMap f(rootDir / "testFileUtils.cpp"); BOOST_REQUIRE(f.fh); @@ -114,49 +114,42 @@ BOOST_AUTO_TEST_CASE( memmap ) BOOST_REQUIRE_EQUAL(i.length(), f.getStat().st_size / sizeof(int)); } -BOOST_AUTO_TEST_CASE( openmode ) +BOOST_AUTO_TEST_CASE(openmode) { std::filesystem::remove(binDir / "test.file"); - BOOST_REQUIRE_THROW({ - AdHoc::FileUtils::FileHandle fh(binDir / "test.file", O_RDONLY, S_IRWXU); - }, AdHoc::SystemExceptionOn); + BOOST_REQUIRE_THROW( + { AdHoc::FileUtils::FileHandle fh(binDir / "test.file", O_RDONLY, S_IRWXU); }, AdHoc::SystemExceptionOn); AdHoc::FileUtils::FileHandle fh(binDir / "test.file", O_CREAT, S_IRWXU); std::filesystem::remove(binDir / "test.file"); } -BOOST_AUTO_TEST_CASE( openfail ) +BOOST_AUTO_TEST_CASE(openfail) { - BOOST_REQUIRE_THROW({ - AdHoc::FileUtils::MemMap f("/tmp/nothere"); - }, AdHoc::SystemException); + BOOST_REQUIRE_THROW({ AdHoc::FileUtils::MemMap f("/tmp/nothere"); }, AdHoc::SystemException); } -BOOST_AUTO_TEST_CASE( mapfail ) +BOOST_AUTO_TEST_CASE(mapfail) { - BOOST_REQUIRE_THROW({ - AdHoc::FileUtils::MemMap f("/dev/null"); - }, AdHoc::SystemException); + BOOST_REQUIRE_THROW({ AdHoc::FileUtils::MemMap f("/dev/null"); }, AdHoc::SystemException); auto fd = open("/dev/null", O_RDWR); REQUIRE_VALID_FH(fd); - BOOST_REQUIRE_THROW({ - AdHoc::FileUtils::MemMap f(fd, O_RDWR); - }, AdHoc::SystemException); + BOOST_REQUIRE_THROW({ AdHoc::FileUtils::MemMap f(fd, O_RDWR); }, AdHoc::SystemException); REQUIRE_INVALID_FH(fd); } -BOOST_AUTO_TEST_CASE( msg ) +BOOST_AUTO_TEST_CASE(msg) { AdHoc::SystemException x("verb", "No such file or directory", ENOENT); BOOST_REQUIRE_EQUAL(x.what(), "verb (2:No such file or directory)"); } -BOOST_AUTO_TEST_CASE( msgOn ) +BOOST_AUTO_TEST_CASE(msgOn) { AdHoc::SystemExceptionOn x("verb", "No such file or directory", ENOENT, "noun"); BOOST_REQUIRE_EQUAL(x.what(), "verb on 'noun' (2:No such file or directory)"); } -BOOST_AUTO_TEST_CASE( pathPart ) +BOOST_AUTO_TEST_CASE(pathPart) { using namespace AdHoc::FileUtils; std::filesystem::path p("/this/is/some/path"); @@ -166,4 +159,3 @@ BOOST_AUTO_TEST_CASE( pathPart ) BOOST_REQUIRE_EQUAL(p / 3, "some"); BOOST_REQUIRE_EQUAL(p / 4, "path"); } - diff --git a/libadhocutil/unittests/testFprintbf.cpp b/libadhocutil/unittests/testFprintbf.cpp index 1f4e55a..233a3f7 100644 --- a/libadhocutil/unittests/testFprintbf.cpp +++ b/libadhocutil/unittests/testFprintbf.cpp @@ -1,11 +1,11 @@ #define BOOST_TEST_MODULE fprintbf #include <boost/test/unit_test.hpp> -#include "fprintbf.h" #include "definedDirs.h" +#include "fprintbf.h" #include <system_error> -BOOST_AUTO_TEST_CASE( writestring ) +BOOST_AUTO_TEST_CASE(writestring) { FILE * f = fopen(binDir / "writestring", "w"); BOOST_REQUIRE(f); @@ -13,7 +13,7 @@ BOOST_AUTO_TEST_CASE( writestring ) fclose(f); } -BOOST_AUTO_TEST_CASE( writestringerror ) +BOOST_AUTO_TEST_CASE(writestringerror) { FILE * f = fopen(binDir / "writestring", "r"); BOOST_REQUIRE(f); @@ -21,7 +21,7 @@ BOOST_AUTO_TEST_CASE( writestringerror ) fclose(f); } -BOOST_AUTO_TEST_CASE( writeformatNoArgs ) +BOOST_AUTO_TEST_CASE(writeformatNoArgs) { FILE * f = fopen(binDir / "writeformatNoArgs", "w"); BOOST_REQUIRE(f); @@ -29,7 +29,7 @@ BOOST_AUTO_TEST_CASE( writeformatNoArgs ) fclose(f); } -BOOST_AUTO_TEST_CASE( writeformatOneArg ) +BOOST_AUTO_TEST_CASE(writeformatOneArg) { FILE * f = fopen(binDir / "writeformatOneArg", "w"); BOOST_REQUIRE(f); @@ -37,7 +37,7 @@ BOOST_AUTO_TEST_CASE( writeformatOneArg ) fclose(f); } -BOOST_AUTO_TEST_CASE( writeformatTwoArgs ) +BOOST_AUTO_TEST_CASE(writeformatTwoArgs) { FILE * f = fopen(binDir / "writeformatTwoArgs", "w"); BOOST_REQUIRE(f); @@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE( writeformatTwoArgs ) fclose(f); } -BOOST_AUTO_TEST_CASE( writeformatError ) +BOOST_AUTO_TEST_CASE(writeformatError) { FILE * f = fopen(binDir / "writeformatTwoArgs", "r"); BOOST_REQUIRE(f); @@ -53,8 +53,7 @@ BOOST_AUTO_TEST_CASE( writeformatError ) fclose(f); } -BOOST_AUTO_TEST_CASE( fopenerror ) +BOOST_AUTO_TEST_CASE(fopenerror) { BOOST_REQUIRE_THROW(fopen(binDir / "missing" / "folder", "r"), std::system_error); } - diff --git a/libadhocutil/unittests/testHandle.cpp b/libadhocutil/unittests/testHandle.cpp index e7f52af..6fccaa7 100644 --- a/libadhocutil/unittests/testHandle.cpp +++ b/libadhocutil/unittests/testHandle.cpp @@ -1,9 +1,9 @@ #define BOOST_TEST_MODULE Handle #include <boost/test/unit_test.hpp> -#include <type_traits> -#include <fcntl.h> #include "handle.h" +#include <fcntl.h> +#include <type_traits> // Test case base on a file handle using T = decltype(STDIN_FILENO); @@ -20,7 +20,7 @@ static_assert(!std::is_copy_assignable_v<TestHandle>); BOOST_AUTO_TEST_CASE(values) { - TestHandle th { open("/dev/null", O_RDWR), &close }; + TestHandle th {open("/dev/null", O_RDWR), &close}; static_assert(std::is_same_v<T, std::remove_reference_t<decltype(th.get())>>); static_assert(std::is_same_v<T, std::remove_reference_t<decltype(*th)>>); BOOST_REQUIRE_EQUAL(1, write(th, "1", 1)); @@ -28,7 +28,7 @@ BOOST_AUTO_TEST_CASE(values) BOOST_AUTO_TEST_CASE(values_const) { - const TestHandle cth { open("/dev/null", O_RDWR), &close }; + const TestHandle cth {open("/dev/null", O_RDWR), &close}; static_assert(std::is_same_v<const T, std::remove_reference_t<decltype(cth.get())>>); static_assert(std::is_same_v<const T, std::remove_reference_t<decltype(*cth)>>); BOOST_REQUIRE_EQUAL(1, write(cth, "1", 1)); @@ -57,4 +57,3 @@ BOOST_AUTO_TEST_CASE(make) BOOST_REQUIRE_EQUAL(-1, write(fd, "1", 1)); BOOST_REQUIRE_EQUAL(errno, EBADF); } - diff --git a/libadhocutil/unittests/testLazyPointer.cpp b/libadhocutil/unittests/testLazyPointer.cpp index 31b92a5..df9c257 100644 --- a/libadhocutil/unittests/testLazyPointer.cpp +++ b/libadhocutil/unittests/testLazyPointer.cpp @@ -6,12 +6,9 @@ using namespace AdHoc; class Test { - public: - explicit Test(int v) : - val(v) - { - } - const int val; +public: + explicit Test(int v) : val(v) { } + const int val; }; using TestLazyPointer = LazyPointer<Test>; @@ -22,23 +19,23 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(TestLazyPointer); BOOST_TEST_DONT_PRINT_LOG_VALUE(RawLazyPointer); /// LCOV_EXCL_STOP -static -TestLazyPointer::pointer_type +static TestLazyPointer::pointer_type factory() { return std::make_shared<Test>(3); } -static -TestLazyPointer::pointer_type +static TestLazyPointer::pointer_type paramFactory(const std::string & str) { return std::make_shared<Test>(str.length()); } -BOOST_AUTO_TEST_CASE ( islazy ) +BOOST_AUTO_TEST_CASE(islazy) { - TestLazyPointer p([]{ return factory(); }); + TestLazyPointer p([] { + return factory(); + }); BOOST_REQUIRE_EQUAL(false, p.hasValue()); Test * t = p.get(); BOOST_REQUIRE(t); @@ -49,40 +46,44 @@ BOOST_AUTO_TEST_CASE ( islazy ) BOOST_REQUIRE_EQUAL(3, p->val); } -BOOST_AUTO_TEST_CASE ( preinit ) +BOOST_AUTO_TEST_CASE(preinit) { Test * t = new Test(4); - TestLazyPointer p(TestLazyPointer::pointer_type{ t }); + TestLazyPointer p(TestLazyPointer::pointer_type {t}); BOOST_REQUIRE_EQUAL(true, p.hasValue()); BOOST_REQUIRE_EQUAL(p, t); BOOST_REQUIRE_EQUAL(4, p->val); } -BOOST_AUTO_TEST_CASE ( reset ) +BOOST_AUTO_TEST_CASE(reset) { Test * t = new Test(4); - TestLazyPointer p(TestLazyPointer::pointer_type{ t }); + TestLazyPointer p(TestLazyPointer::pointer_type {t}); BOOST_REQUIRE_EQUAL(true, p.hasValue()); BOOST_REQUIRE_EQUAL(4, p->val); p = nullptr; BOOST_REQUIRE_EQUAL(true, p.hasValue()); BOOST_REQUIRE_EQUAL(true, !p); - p = []{ return factory(); }; + p = [] { + return factory(); + }; BOOST_REQUIRE_EQUAL(false, p.hasValue()); BOOST_REQUIRE(p.get()); BOOST_REQUIRE_EQUAL(true, p.hasValue()); BOOST_REQUIRE_EQUAL(3, p->val); } -BOOST_AUTO_TEST_CASE ( nondefault ) +BOOST_AUTO_TEST_CASE(nondefault) { - TestLazyPointer p([]{ return paramFactory("some string"); }); + TestLazyPointer p([] { + return paramFactory("some string"); + }); BOOST_REQUIRE_EQUAL(false, p.hasValue()); BOOST_REQUIRE_EQUAL(11, (*p).val); BOOST_REQUIRE_EQUAL(true, p.hasValue()); } -BOOST_AUTO_TEST_CASE( rawPointerNull ) +BOOST_AUTO_TEST_CASE(rawPointerNull) { RawLazyPointer null; BOOST_REQUIRE(null.hasValue()); @@ -90,7 +91,7 @@ BOOST_AUTO_TEST_CASE( rawPointerNull ) BOOST_REQUIRE(!null.get()); } -BOOST_AUTO_TEST_CASE( rawPointerNonNull ) +BOOST_AUTO_TEST_CASE(rawPointerNonNull) { RawLazyPointer value(new int(3)); BOOST_REQUIRE(value.hasValue()); @@ -108,12 +109,13 @@ rawFactory(const std::string & s) return new int(s.length()); } -BOOST_AUTO_TEST_CASE( rawPointerFactory ) +BOOST_AUTO_TEST_CASE(rawPointerFactory) { - RawLazyPointer value([]{ return rawFactory(std::string("four")); }); + RawLazyPointer value([] { + return rawFactory(std::string("four")); + }); BOOST_REQUIRE(!value.hasValue()); BOOST_REQUIRE_EQUAL(*value, 4); BOOST_REQUIRE(value.hasValue()); delete (int *)value; } - diff --git a/libadhocutil/unittests/testLexer.cpp b/libadhocutil/unittests/testLexer.cpp index f58b002..3484e78 100644 --- a/libadhocutil/unittests/testLexer.cpp +++ b/libadhocutil/unittests/testLexer.cpp @@ -1,83 +1,79 @@ #define BOOST_TEST_MODULE Lexer #include <boost/test/unit_test.hpp> -#include <lexer.h> #include <lexer-regex.h> +#include <lexer.h> using namespace AdHoc; using namespace AdHoc::LexerMatchers; -BOOST_AUTO_TEST_CASE( defaultConstructor ) +BOOST_AUTO_TEST_CASE(defaultConstructor) { AdHoc::Lexer l; - l.rules.push_back({ { AdHoc::Lexer::InitialState }, regex("a"), [](auto) { } }); + l.rules.push_back({{AdHoc::Lexer::InitialState}, regex("a"), [](auto) {}}); } -BOOST_AUTO_TEST_CASE( simple ) +BOOST_AUTO_TEST_CASE(simple) { int m = 0; - AdHoc::Lexer l({ - { { AdHoc::Lexer::InitialState }, regex("a"), [&](auto) { m += 1; } } - }); + AdHoc::Lexer l({{{AdHoc::Lexer::InitialState}, regex("a"), [&](auto) { + m += 1; + }}}); BOOST_REQUIRE_EQUAL(0, m); l.extract("aaaa", 4); BOOST_REQUIRE_EQUAL(4, m); - BOOST_REQUIRE_THROW({ - l.extract("abcd", 4); - }, std::runtime_error); + BOOST_REQUIRE_THROW({ l.extract("abcd", 4); }, std::runtime_error); } -BOOST_AUTO_TEST_CASE( state ) +BOOST_AUTO_TEST_CASE(state) { int m = 0; std::string s; - AdHoc::Lexer l({ - { { AdHoc::Lexer::InitialState }, regex("a"), [&](auto es) - { - m += 1; - BOOST_REQUIRE_EQUAL(1, es->depth()); - es->pushState("2"); - BOOST_REQUIRE_EQUAL(2, es->depth()); - } }, - { { "2" }, regex("a"), [&](auto es) - { - m += 2; - BOOST_REQUIRE_EQUAL("2", es->getState()); - BOOST_REQUIRE_EQUAL(2, es->depth()); - es->pushState("3"); - BOOST_REQUIRE_EQUAL("3", es->getState()); - BOOST_REQUIRE_EQUAL(3, es->depth()); - } }, - { { "3" }, regex("a"), [&](auto es) - { - m += 3; - s += *es->pattern()->match(0); - BOOST_REQUIRE_EQUAL(3, es->depth()); - es->setState("4"); - BOOST_REQUIRE_EQUAL(3, es->depth()); - BOOST_REQUIRE_EQUAL("4", es->getState()); - BOOST_REQUIRE_EQUAL(3, es->depth()); - BOOST_REQUIRE(!es->pattern()->match(1)); - BOOST_REQUIRE(!es->pattern()->match(2)); - es->popState(); - BOOST_REQUIRE_EQUAL(2, es->depth()); - BOOST_REQUIRE_EQUAL("2", es->getState()); - es->pushState("3"); - BOOST_REQUIRE_EQUAL(3, es->depth()); - BOOST_REQUIRE_EQUAL("3", es->getState()); - } } - }); + AdHoc::Lexer l({{{AdHoc::Lexer::InitialState}, regex("a"), + [&](auto es) { + m += 1; + BOOST_REQUIRE_EQUAL(1, es->depth()); + es->pushState("2"); + BOOST_REQUIRE_EQUAL(2, es->depth()); + }}, + {{"2"}, regex("a"), + [&](auto es) { + m += 2; + BOOST_REQUIRE_EQUAL("2", es->getState()); + BOOST_REQUIRE_EQUAL(2, es->depth()); + es->pushState("3"); + BOOST_REQUIRE_EQUAL("3", es->getState()); + BOOST_REQUIRE_EQUAL(3, es->depth()); + }}, + {{"3"}, regex("a"), [&](auto es) { + m += 3; + s += *es->pattern()->match(0); + BOOST_REQUIRE_EQUAL(3, es->depth()); + es->setState("4"); + BOOST_REQUIRE_EQUAL(3, es->depth()); + BOOST_REQUIRE_EQUAL("4", es->getState()); + BOOST_REQUIRE_EQUAL(3, es->depth()); + BOOST_REQUIRE(!es->pattern()->match(1)); + BOOST_REQUIRE(!es->pattern()->match(2)); + es->popState(); + BOOST_REQUIRE_EQUAL(2, es->depth()); + BOOST_REQUIRE_EQUAL("2", es->getState()); + es->pushState("3"); + BOOST_REQUIRE_EQUAL(3, es->depth()); + BOOST_REQUIRE_EQUAL("3", es->getState()); + }}}); BOOST_REQUIRE_EQUAL(0, m); l.extract("aaaa", 4); BOOST_REQUIRE_EQUAL(9, m); BOOST_REQUIRE_EQUAL("aa", s); } -BOOST_AUTO_TEST_CASE( multibyte ) +BOOST_AUTO_TEST_CASE(multibyte) { - AdHoc::Lexer::PatternPtr maskHead = AdHoc::LexerMatchers::regex( - "^# ([^<\n]+)? ?(<(.+?@[^\n>]+)>?)? \\((\\d+ *(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\w* \\d+)\\)$", - (GRegexCompileFlags)(G_REGEX_OPTIMIZE | G_REGEX_CASELESS | G_REGEX_UNGREEDY)); + AdHoc::Lexer::PatternPtr maskHead + = AdHoc::LexerMatchers::regex("^# ([^<\n]+)? ?(<(.+?@[^\n>]+)>?)? \\((\\d+ " + "*(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\w* \\d+)\\)$", + (GRegexCompileFlags)(G_REGEX_OPTIMIZE | G_REGEX_CASELESS | G_REGEX_UNGREEDY)); Glib::ustring input("# Michał Górny <mgorny@gentoo.org> (28 Mar 2015)"); BOOST_REQUIRE_GT(input.bytes(), input.length()); BOOST_REQUIRE(maskHead->matches(input.c_str(), input.bytes(), 0)); @@ -92,8 +88,7 @@ BOOST_AUTO_TEST_CASE( multibyte ) BOOST_REQUIRE_EQUAL("28 Mar 2015", *maskHead->match(4)); } -BOOST_AUTO_TEST_CASE( badre ) +BOOST_AUTO_TEST_CASE(badre) { BOOST_REQUIRE_THROW(regex("["), std::runtime_error); } - diff --git a/libadhocutil/unittests/testLocks.cpp b/libadhocutil/unittests/testLocks.cpp index 0c93d99..a7a506a 100644 --- a/libadhocutil/unittests/testLocks.cpp +++ b/libadhocutil/unittests/testLocks.cpp @@ -4,7 +4,7 @@ #include "lockHelpers.h" #include <shared_mutex> -BOOST_AUTO_TEST_CASE ( lock ) +BOOST_AUTO_TEST_CASE(lock) { std::shared_mutex _lock; { @@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE ( lock ) _lock.unlock_shared(); } -BOOST_AUTO_TEST_CASE ( sharedlock ) +BOOST_AUTO_TEST_CASE(sharedlock) { std::shared_mutex _lock; { @@ -35,7 +35,7 @@ BOOST_AUTO_TEST_CASE ( sharedlock ) _lock.unlock_shared(); } -BOOST_AUTO_TEST_CASE ( scopelock ) +BOOST_AUTO_TEST_CASE(scopelock) { std::shared_mutex _lock; ScopeLock(_lock) { @@ -49,7 +49,7 @@ BOOST_AUTO_TEST_CASE ( scopelock ) _lock.unlock_shared(); } -BOOST_AUTO_TEST_CASE ( sharedscopelock ) +BOOST_AUTO_TEST_CASE(sharedscopelock) { std::shared_mutex _lock; SharedScopeLock(_lock) { @@ -63,4 +63,3 @@ BOOST_AUTO_TEST_CASE ( sharedscopelock ) BOOST_CHECK(_lock.try_lock_shared()); _lock.unlock_shared(); } - diff --git a/libadhocutil/unittests/testMapFinds.cpp b/libadhocutil/unittests/testMapFinds.cpp index d3d0e34..bcbb69e 100644 --- a/libadhocutil/unittests/testMapFinds.cpp +++ b/libadhocutil/unittests/testMapFinds.cpp @@ -1,31 +1,22 @@ #define BOOST_TEST_MODULE MapFinds #include <boost/test/unit_test.hpp> -#include <boost/lexical_cast.hpp> #include "safeMapFind.h" +#include <boost/lexical_cast.hpp> +#include <map> #include <stdexcept> #include <string> -#include <map> using namespace AdHoc; class NotFound : std::runtime_error { - public: - explicit NotFound(int key) : - std::runtime_error(boost::lexical_cast<std::string>("Key not found: %d", key)) - { - } +public: + explicit NotFound(int key) : std::runtime_error(boost::lexical_cast<std::string>("Key not found: %d", key)) { } }; -const std::map<int, std::string> sample { - { 1, "one" }, - { 2, "two" }, - { 4, "four" }, - { 8, "eight" }, - { 16, "sixteen" } -}; +const std::map<int, std::string> sample {{1, "one"}, {2, "two"}, {4, "four"}, {8, "eight"}, {16, "sixteen"}}; -BOOST_AUTO_TEST_CASE ( testSafeMapFind ) +BOOST_AUTO_TEST_CASE(testSafeMapFind) { BOOST_REQUIRE_EQUAL(safeMapFind<NotFound>(sample, 1)->first, 1); BOOST_REQUIRE_EQUAL(safeMapFind<NotFound>(sample, 1)->second, "one"); @@ -34,7 +25,7 @@ BOOST_AUTO_TEST_CASE ( testSafeMapFind ) BOOST_REQUIRE_THROW(safeMapFind<NotFound>(sample, 5), NotFound); } -BOOST_AUTO_TEST_CASE ( testDefaultMapLookup ) +BOOST_AUTO_TEST_CASE(testDefaultMapLookup) { BOOST_REQUIRE_EQUAL(defaultMapLookup(sample, 1), "one"); BOOST_REQUIRE_EQUAL(defaultMapLookup(sample, 4), "four"); @@ -42,18 +33,17 @@ BOOST_AUTO_TEST_CASE ( testDefaultMapLookup ) BOOST_REQUIRE_EQUAL(defaultMapLookup(sample, 5, "default"), "default"); } -BOOST_AUTO_TEST_CASE ( testSafeMapLookup ) +BOOST_AUTO_TEST_CASE(testSafeMapLookup) { BOOST_REQUIRE_EQUAL(safeMapLookup<NotFound>(sample, 1), "one"); BOOST_REQUIRE_EQUAL(safeMapLookup<NotFound>(sample, 4), "four"); BOOST_REQUIRE_THROW(safeMapLookup<NotFound>(sample, 5), NotFound); } -BOOST_AUTO_TEST_CASE ( testContainerContains ) +BOOST_AUTO_TEST_CASE(testContainerContains) { BOOST_REQUIRE_EQUAL(true, containerContains(sample, {1, "one"})); BOOST_REQUIRE_EQUAL(false, containerContains(sample, {2, "one"})); BOOST_REQUIRE_EQUAL(false, containerContains(sample, {1, "two"})); BOOST_REQUIRE_EQUAL(true, containerContains(sample, {2, "two"})); } - diff --git a/libadhocutil/unittests/testMemStream.cpp b/libadhocutil/unittests/testMemStream.cpp index 79100ee..5d26c42 100644 --- a/libadhocutil/unittests/testMemStream.cpp +++ b/libadhocutil/unittests/testMemStream.cpp @@ -1,6 +1,6 @@ #define BOOST_TEST_MODULE NvpParse -#include <boost/test/unit_test.hpp> #include <boost/mpl/list.hpp> +#include <boost/test/unit_test.hpp> #include "memstream.h" @@ -17,9 +17,9 @@ BOOST_AUTO_TEST_CASE(empty) } using cast_types = boost::mpl::list<const char *, std::string_view, FILE *>; -BOOST_AUTO_TEST_CASE_TEMPLATE(casts, T, cast_types ) +BOOST_AUTO_TEST_CASE_TEMPLATE(casts, T, cast_types) { - auto dummy = [](const T &) { }; + auto dummy = [](const T &) {}; dummy(*this); } @@ -44,4 +44,3 @@ BOOST_AUTO_TEST_CASE(move_assign) MemStream ms2; ms2 = std::move(ms1); } - diff --git a/libadhocutil/unittests/testNagios.cpp b/libadhocutil/unittests/testNagios.cpp index 8e8e025..0af6b25 100644 --- a/libadhocutil/unittests/testNagios.cpp +++ b/libadhocutil/unittests/testNagios.cpp @@ -4,7 +4,7 @@ #include <nagios.h> /// LCOV_EXCL_START (calls real Nagios) -BOOST_AUTO_TEST_CASE(test_write_cmd, * boost::unit_test::disabled()) +BOOST_AUTO_TEST_CASE(test_write_cmd, *boost::unit_test::disabled()) { BOOST_REQUIRE(AdHoc::submitNagiosPassiveServiceCheck("some service", AdHoc::NagiosStatusCode::OK, "bar")); } @@ -15,4 +15,3 @@ BOOST_AUTO_TEST_CASE(test_fmtrite_cmd) std::stringstream strm; BOOST_REQUIRE(AdHoc::submitNagiosPassiveServiceCheck(strm, "some service", AdHoc::NagiosStatusCode::OK, "bar")); } - diff --git a/libadhocutil/unittests/testNvpParse.cpp b/libadhocutil/unittests/testNvpParse.cpp index 678f468..fa955e1 100644 --- a/libadhocutil/unittests/testNvpParse.cpp +++ b/libadhocutil/unittests/testNvpParse.cpp @@ -6,25 +6,25 @@ using namespace AdHoc; class TestTarget { - public: - std::string a; - std::string b; - int c {0}; - double d {0}; +public: + std::string a; + std::string b; + int c {0}; + double d {0}; }; NvpTarget(TestTarget) TestTargetMap { - NvpValue(TestTarget, a), - NvpValue(TestTarget, b), - NvpValue(TestTarget, c), - NvpValue(TestTarget, d), + NvpValue(TestTarget, a), + NvpValue(TestTarget, b), + NvpValue(TestTarget, c), + NvpValue(TestTarget, d), }; /// LCOV_EXCL_START (diagnostics) BOOST_TEST_DONT_PRINT_LOG_VALUE(decltype(TestTargetMap.find(""))); /// LCOV_EXCL_STOP -BOOST_AUTO_TEST_CASE ( targetmap ) +BOOST_AUTO_TEST_CASE(targetmap) { BOOST_REQUIRE_NE(TestTargetMap.find("a"), TestTargetMap.end()); BOOST_REQUIRE_NE(TestTargetMap.find("b"), TestTargetMap.end()); @@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE ( targetmap ) BOOST_REQUIRE_EQUAL(TestTargetMap.find("e"), TestTargetMap.end()); } -BOOST_AUTO_TEST_CASE ( parse ) +BOOST_AUTO_TEST_CASE(parse) { TestTarget tt; std::stringstream i("a = foo;b=bar; c=3;d=3.14"); @@ -44,17 +44,16 @@ BOOST_AUTO_TEST_CASE ( parse ) BOOST_REQUIRE_CLOSE(3.14, tt.d, 0.01); } -BOOST_AUTO_TEST_CASE ( missing ) +BOOST_AUTO_TEST_CASE(missing) { TestTarget tt; std::stringstream i("missing=nothing;"); BOOST_REQUIRE_THROW(NvpParse::parse(i, TestTargetMap, tt), NvpParse::ValueNotFound); } -BOOST_AUTO_TEST_CASE ( bad ) +BOOST_AUTO_TEST_CASE(bad) { TestTarget tt; std::stringstream i("{bad="); BOOST_REQUIRE_THROW(NvpParse::parse(i, TestTargetMap, tt), std::runtime_error); } - diff --git a/libadhocutil/unittests/testOptionals.cpp b/libadhocutil/unittests/testOptionals.cpp index f6dc371..600c972 100644 --- a/libadhocutil/unittests/testOptionals.cpp +++ b/libadhocutil/unittests/testOptionals.cpp @@ -1,14 +1,14 @@ #define BOOST_TEST_MODULE Buffer #include <boost/test/unit_test.hpp> -#include <optionalUtils.h> -#include <optional> #include <Ice/Exception.h> #include <Ice/Optional.h> +#include <optional> +#include <optionalUtils.h> using namespace AdHoc; -BOOST_AUTO_TEST_CASE ( general ) +BOOST_AUTO_TEST_CASE(general) { std::optional<int> x; std::optional<double> y = 2.3; @@ -26,9 +26,9 @@ BOOST_AUTO_TEST_CASE ( general ) BOOST_REQUIRE_EQUAL(2.3, *a1); auto a2 = x / 10; BOOST_REQUIRE_EQUAL(10, a2); - auto a3 = ix / 11; + auto a3 = ix / 11; BOOST_REQUIRE_EQUAL(11, a3); - auto a4 = iy / 11; + auto a4 = iy / 11; BOOST_REQUIRE_EQUAL(4, a4); auto s1 = p / s / r; @@ -43,4 +43,3 @@ BOOST_AUTO_TEST_CASE ( general ) delete q; } - diff --git a/libadhocutil/unittests/testPlugins.cpp b/libadhocutil/unittests/testPlugins.cpp index 9a6cc7e..a05469e 100644 --- a/libadhocutil/unittests/testPlugins.cpp +++ b/libadhocutil/unittests/testPlugins.cpp @@ -7,22 +7,22 @@ using namespace AdHoc; -BOOST_AUTO_TEST_CASE( ready ) +BOOST_AUTO_TEST_CASE(ready) { BOOST_REQUIRE(PluginManager::getDefault()); } -BOOST_AUTO_TEST_CASE( registered ) +BOOST_AUTO_TEST_CASE(registered) { BOOST_REQUIRE_EQUAL(1, PluginManager::getDefault()->count()); } -BOOST_AUTO_TEST_CASE( private_instance ) +BOOST_AUTO_TEST_CASE(private_instance) { std::make_unique<PluginManager>(); } -BOOST_AUTO_TEST_CASE( get ) +BOOST_AUTO_TEST_CASE(get) { auto implOfThingPlugin = PluginManager::getDefault()->get<BaseThing>("ImplOfThing"); BOOST_REQUIRE(implOfThingPlugin); @@ -32,7 +32,7 @@ BOOST_AUTO_TEST_CASE( get ) BOOST_REQUIRE_EQUAL(implOfThing, implOfThingDirect); } -BOOST_AUTO_TEST_CASE( getAll ) +BOOST_AUTO_TEST_CASE(getAll) { auto all = PluginManager::getDefault()->getAll(); BOOST_REQUIRE_EQUAL(1, all.size()); @@ -44,10 +44,11 @@ BOOST_AUTO_TEST_CASE( getAll ) BOOST_REQUIRE_EQUAL(1, allOf.size()); } -BOOST_AUTO_TEST_CASE( addManual ) +BOOST_AUTO_TEST_CASE(addManual) { auto o1 = PluginManager::getDefault()->get<BaseThing>("ImplOfThing"); - PluginManager::getDefault()->add(std::make_shared<PluginOf<BaseThing>>(std::make_shared<ImplOfThing>(), "custom1", __FILE__, __LINE__)); + PluginManager::getDefault()->add( + std::make_shared<PluginOf<BaseThing>>(std::make_shared<ImplOfThing>(), "custom1", __FILE__, __LINE__)); BOOST_REQUIRE_EQUAL(2, PluginManager::getDefault()->count()); auto c1 = PluginManager::getDefault()->get<BaseThing>("custom1"); PluginManager::getDefault()->add<BaseThing>(std::make_shared<ImplOfThing>(), "custom2", __FILE__, __LINE__); @@ -63,7 +64,7 @@ BOOST_AUTO_TEST_CASE( addManual ) BOOST_REQUIRE_NE(c2, o1); } -BOOST_AUTO_TEST_CASE( removeManual ) +BOOST_AUTO_TEST_CASE(removeManual) { BOOST_REQUIRE_EQUAL(3, PluginManager::getDefault()->count()); PluginManager::getDefault()->remove<BaseThing>("custom1"); @@ -77,7 +78,7 @@ BOOST_AUTO_TEST_CASE( removeManual ) BOOST_REQUIRE(PluginManager::getDefault()->get<BaseThing>("ImplOfThing")); } -BOOST_AUTO_TEST_CASE( createAndRemove ) +BOOST_AUTO_TEST_CASE(createAndRemove) { PluginManager::getDefault()->create<BaseThing, ImplOfThing>("custom1", __FILE__, __LINE__); BOOST_REQUIRE_EQUAL(2, PluginManager::getDefault()->count()); @@ -86,19 +87,21 @@ BOOST_AUTO_TEST_CASE( createAndRemove ) PluginManager::getDefault()->remove<BaseThing>("custom1"); } -BOOST_AUTO_TEST_CASE( nameAndTypeClash ) +BOOST_AUTO_TEST_CASE(nameAndTypeClash) { // Same name, different type PluginManager::getDefault()->add<OtherBase>(std::make_shared<OtherImpl>(), "ImplOfThing", __FILE__, __LINE__); // Different name, same type PluginManager::getDefault()->add<BaseThing>(std::make_shared<ImplOfThing>(), "Different", __FILE__, __LINE__); // Same name, same thing, should error - BOOST_REQUIRE_THROW(PluginManager::getDefault()->add<BaseThing>(std::make_shared<OtherImplOfThing>(), "ImplOfThing", __FILE__, __LINE__), DuplicatePluginException); + BOOST_REQUIRE_THROW(PluginManager::getDefault()->add<BaseThing>( + std::make_shared<OtherImplOfThing>(), "ImplOfThing", __FILE__, __LINE__), + DuplicatePluginException); PluginManager::getDefault()->remove<OtherBase>("ImplOfThing"); PluginManager::getDefault()->remove<BaseThing>("Different"); } -BOOST_AUTO_TEST_CASE( otherTypes ) +BOOST_AUTO_TEST_CASE(otherTypes) { PluginManager::getDefault()->add<OtherBase>(std::make_shared<OtherImpl>(), "ImplOfThing", __FILE__, __LINE__); BOOST_REQUIRE_EQUAL(2, PluginManager::getDefault()->count()); @@ -114,4 +117,3 @@ BOOST_AUTO_TEST_CASE( otherTypes ) BOOST_REQUIRE_EQUAL(1, PluginManager::getDefault()->count()); BOOST_REQUIRE(PluginManager::getDefault()->get<BaseThing>("ImplOfThing")); } - diff --git a/libadhocutil/unittests/testPluginsRuntime.cpp b/libadhocutil/unittests/testPluginsRuntime.cpp index c3ecf34..7836ed5 100644 --- a/libadhocutil/unittests/testPluginsRuntime.cpp +++ b/libadhocutil/unittests/testPluginsRuntime.cpp @@ -23,18 +23,18 @@ static std::optional<std::string> nullResolver(const std::type_info &, const std static std::optional<std::string> badResolver(const std::type_info &, const std::string_view &); static std::optional<std::string> goodResolver(const std::type_info &, const std::string_view &); -BOOST_AUTO_TEST_CASE( ready ) +BOOST_AUTO_TEST_CASE(ready) { BOOST_REQUIRE(PluginManager::getDefault()); BOOST_REQUIRE(std::filesystem::exists(lib)); } -BOOST_AUTO_TEST_CASE( clean ) +BOOST_AUTO_TEST_CASE(clean) { BOOST_REQUIRE_EQUAL(0, AdHoc::PluginManager::getDefault()->getAll<BaseThing>().size()); } -BOOST_AUTO_TEST_CASE( loadAndUnloadlib ) +BOOST_AUTO_TEST_CASE(loadAndUnloadlib) { void * handle = dlopen(lib.c_str(), RTLD_NOW); BOOST_REQUIRE(handle); @@ -63,7 +63,7 @@ goodResolver(const std::type_info & t, const std::string_view & n) return lib; } -BOOST_AUTO_TEST_CASE( addAndRemoveResolver ) +BOOST_AUTO_TEST_CASE(addAndRemoveResolver) { auto pm = AdHoc::PluginManager::getDefault(); BOOST_REQUIRE_EQUAL(0, pm->countResolvers()); @@ -75,7 +75,7 @@ BOOST_AUTO_TEST_CASE( addAndRemoveResolver ) BOOST_REQUIRE_EQUAL(0, pm->countResolvers()); } -BOOST_AUTO_TEST_CASE( null ) +BOOST_AUTO_TEST_CASE(null) { auto pm = AdHoc::PluginManager::getDefault(); pm->addResolver<BaseThing>(nullResolver); @@ -83,7 +83,7 @@ BOOST_AUTO_TEST_CASE( null ) pm->removeResolver<BaseThing>(); } -BOOST_AUTO_TEST_CASE( bad ) +BOOST_AUTO_TEST_CASE(bad) { auto pm = AdHoc::PluginManager::getDefault(); pm->addResolver<BaseThing>(badResolver); @@ -91,11 +91,10 @@ BOOST_AUTO_TEST_CASE( bad ) pm->removeResolver<BaseThing>(); } -BOOST_AUTO_TEST_CASE( good ) +BOOST_AUTO_TEST_CASE(good) { auto pm = AdHoc::PluginManager::getDefault(); pm->addResolver<BaseThing>(goodResolver); BOOST_REQUIRE(pm->get<BaseThing>("ImplOfThing")); pm->removeResolver<BaseThing>(); } - diff --git a/libadhocutil/unittests/testProcessPipes.cpp b/libadhocutil/unittests/testProcessPipes.cpp index 968ac2a..6251022 100644 --- a/libadhocutil/unittests/testProcessPipes.cpp +++ b/libadhocutil/unittests/testProcessPipes.cpp @@ -1,13 +1,13 @@ #define BOOST_TEST_MODULE ProcessPipes #include <boost/test/unit_test.hpp> -#include "processPipes.h" #include "definedDirs.h" +#include "processPipes.h" #include <sys/wait.h> using namespace AdHoc::System; -BOOST_AUTO_TEST_CASE( readfind ) +BOOST_AUTO_TEST_CASE(readfind) { ProcessPipes pp({"/usr/bin/find", rootDir, "-maxdepth", "1"}, false, true, true); BOOST_REQUIRE_EQUAL(pp.fdIn(), -1); @@ -23,7 +23,7 @@ BOOST_AUTO_TEST_CASE( readfind ) waitpid(pp.pid(), &status, 0); } -BOOST_AUTO_TEST_CASE( readwrite ) +BOOST_AUTO_TEST_CASE(readwrite) { ProcessPipes pp({"/usr/bin/md5sum"}, true, true, false); BOOST_REQUIRE_NE(pp.fdIn(), -1); @@ -38,10 +38,7 @@ BOOST_AUTO_TEST_CASE( readwrite ) waitpid(pp.pid(), &status, 0); } -BOOST_AUTO_TEST_CASE( noargs ) +BOOST_AUTO_TEST_CASE(noargs) { - BOOST_CHECK_THROW({ - ProcessPipes({}, false, false, false); - }, std::invalid_argument); + BOOST_CHECK_THROW({ ProcessPipes({}, false, false, false); }, std::invalid_argument); } - diff --git a/libadhocutil/unittests/testResourcePool.cpp b/libadhocutil/unittests/testResourcePool.cpp index 4fd1f72..5f67424 100644 --- a/libadhocutil/unittests/testResourcePool.cpp +++ b/libadhocutil/unittests/testResourcePool.cpp @@ -4,59 +4,75 @@ #include <resourcePool.impl.h> class MockResource { - public: - MockResource() : id(ids++) { count += 1; } - ~MockResource() { count -= 1; } +public: + MockResource() : id(ids++) + { + count += 1; + } + ~MockResource() + { + count -= 1; + } - SPECIAL_MEMBERS_DELETE(MockResource); + SPECIAL_MEMBERS_DELETE(MockResource); - [[ nodiscard ]] bool valid() const { return true; } + [[nodiscard]] bool + valid() const + { + return true; + } - const unsigned int id; - static std::atomic<unsigned int> ids; - static std::atomic<unsigned int> count; + const unsigned int id; + static std::atomic<unsigned int> ids; + static std::atomic<unsigned int> count; }; std::atomic<unsigned int> MockResource::ids; std::atomic<unsigned int> MockResource::count; class TRP : public AdHoc::ResourcePool<MockResource> { - public: - TRP() : AdHoc::ResourcePool<MockResource>(10, 10) { } - protected: - std::shared_ptr<MockResource> createResource() const override - { - return std::make_shared<MockResource>(); - } +public: + TRP() : AdHoc::ResourcePool<MockResource>(10, 10) { } + +protected: + std::shared_ptr<MockResource> + createResource() const override + { + return std::make_shared<MockResource>(); + } }; class TRPSmall : public AdHoc::ResourcePool<MockResource> { - public: - TRPSmall() : AdHoc::ResourcePool<MockResource>(3, 1) { } - protected: - std::shared_ptr<MockResource> createResource() const override - { - return std::make_shared<MockResource>(); - } +public: + TRPSmall() : AdHoc::ResourcePool<MockResource>(3, 1) { } + +protected: + std::shared_ptr<MockResource> + createResource() const override + { + return std::make_shared<MockResource>(); + } }; class TRPCreateFail : public TRPSmall { - protected: - std::shared_ptr<MockResource> createResource() const override - { - throw std::exception(); - } +protected: + std::shared_ptr<MockResource> + createResource() const override + { + throw std::exception(); + } }; class TRPReturnFail : public TRPSmall { - protected: - void returnTestResource(MockResource const *) const override - { - throw std::exception(); - } +protected: + void + returnTestResource(MockResource const *) const override + { + throw std::exception(); + } }; -BOOST_AUTO_TEST_CASE ( get ) +BOOST_AUTO_TEST_CASE(get) { { TRP pool; @@ -109,7 +125,7 @@ BOOST_AUTO_TEST_CASE ( get ) BOOST_REQUIRE_EQUAL(0, MockResource::count); } -BOOST_AUTO_TEST_CASE( destroyPoolWhenInUse ) +BOOST_AUTO_TEST_CASE(destroyPoolWhenInUse) { auto rp = new TRP(); auto rh1 = rp->get(); @@ -122,7 +138,7 @@ BOOST_AUTO_TEST_CASE( destroyPoolWhenInUse ) BOOST_REQUIRE(rh3->valid()); } -BOOST_AUTO_TEST_CASE ( getMine ) +BOOST_AUTO_TEST_CASE(getMine) { TRP pool; auto r1 = pool.get(); @@ -133,7 +149,7 @@ BOOST_AUTO_TEST_CASE ( getMine ) BOOST_REQUIRE_EQUAL(2, r2.handleCount()); } -BOOST_AUTO_TEST_CASE( getMineNoCurrent ) +BOOST_AUTO_TEST_CASE(getMineNoCurrent) { TRP pool; BOOST_REQUIRE_THROW(pool.getMine(), AdHoc::NoCurrentResourceT<MockResource>); @@ -145,7 +161,7 @@ BOOST_AUTO_TEST_CASE( getMineNoCurrent ) BOOST_REQUIRE_THROW(pool.getMine(), AdHoc::NoCurrentResource); } -BOOST_AUTO_TEST_CASE( move ) +BOOST_AUTO_TEST_CASE(move) { TRP pool; { @@ -177,7 +193,7 @@ BOOST_AUTO_TEST_CASE( move ) BOOST_CHECK_EQUAL(pool.inUseCount(), 0); } -BOOST_AUTO_TEST_CASE( discard ) +BOOST_AUTO_TEST_CASE(discard) { TRP pool; try { @@ -193,7 +209,7 @@ BOOST_AUTO_TEST_CASE( discard ) } } -BOOST_AUTO_TEST_CASE( keepSome1 ) +BOOST_AUTO_TEST_CASE(keepSome1) { TRPSmall pool; { @@ -228,7 +244,7 @@ BOOST_AUTO_TEST_CASE( keepSome1 ) BOOST_REQUIRE_EQUAL(1, MockResource::count); } -BOOST_AUTO_TEST_CASE( keepSome2 ) +BOOST_AUTO_TEST_CASE(keepSome2) { TRPSmall pool; { @@ -244,7 +260,7 @@ BOOST_AUTO_TEST_CASE( keepSome2 ) BOOST_REQUIRE_EQUAL(1, MockResource::count); } -BOOST_AUTO_TEST_CASE( idle ) +BOOST_AUTO_TEST_CASE(idle) { TRP pool; { @@ -270,12 +286,12 @@ BOOST_AUTO_TEST_CASE( idle ) BOOST_REQUIRE_EQUAL(0, MockResource::count); } -BOOST_AUTO_TEST_CASE( threading1, * boost::unit_test::timeout(10) ) +BOOST_AUTO_TEST_CASE(threading1, *boost::unit_test::timeout(10)) { TRPSmall pool; std::list<std::thread> threads; for (int x = 0; x < 100; x += 1) { - threads.emplace_back([&pool](){ + threads.emplace_back([&pool]() { auto r = pool.get(); usleep(50000); }); @@ -283,15 +299,14 @@ BOOST_AUTO_TEST_CASE( threading1, * boost::unit_test::timeout(10) ) // pool size never exceeds 3 BOOST_REQUIRE_LE(pool.inUseCount(), 3); } - for(auto & thread : threads) { + for (auto & thread : threads) { thread.join(); } // pool keep returns to 1 BOOST_REQUIRE_EQUAL(1, pool.availableCount()); } -static -void +static void acquireAndKeepFor1Second(TRPSmall * pool, AdHoc::Semaphore & s) { auto r = pool->get(); @@ -299,13 +314,19 @@ acquireAndKeepFor1Second(TRPSmall * pool, AdHoc::Semaphore & s) sleep(1); } -BOOST_AUTO_TEST_CASE( threading2 ) +BOOST_AUTO_TEST_CASE(threading2) { TRPSmall pool; AdHoc::Semaphore s; - std::thread t1([&pool, &s]() { acquireAndKeepFor1Second(&pool, s); }); - std::thread t2([&pool, &s]() { acquireAndKeepFor1Second(&pool, s); }); - std::thread t3([&pool, &s]() { acquireAndKeepFor1Second(&pool, s); }); + std::thread t1([&pool, &s]() { + acquireAndKeepFor1Second(&pool, s); + }); + std::thread t2([&pool, &s]() { + acquireAndKeepFor1Second(&pool, s); + }); + std::thread t3([&pool, &s]() { + acquireAndKeepFor1Second(&pool, s); + }); s.wait(); s.wait(); @@ -325,19 +346,21 @@ BOOST_AUTO_TEST_CASE( threading2 ) } class TTRP : public TRP { - public: - void testResource(MockResource const *) const override - { - n += 1; - if (n % 2) { - throw std::exception(); - } +public: + void + testResource(MockResource const *) const override + { + n += 1; + if (n % 2) { + throw std::exception(); } - private: - mutable int n{0}; + } + +private: + mutable int n {0}; }; -BOOST_AUTO_TEST_CASE( test ) +BOOST_AUTO_TEST_CASE(test) { TTRP pool; unsigned int rpId; @@ -360,7 +383,7 @@ BOOST_AUTO_TEST_CASE( test ) } } -BOOST_AUTO_TEST_CASE( createFail ) +BOOST_AUTO_TEST_CASE(createFail) { TRPCreateFail pool; BOOST_REQUIRE_EQUAL(0, MockResource::count); @@ -382,7 +405,7 @@ BOOST_AUTO_TEST_CASE( createFail ) BOOST_REQUIRE_EQUAL(3, pool.freeCount()); } -BOOST_AUTO_TEST_CASE( returnFail ) +BOOST_AUTO_TEST_CASE(returnFail) { TRPReturnFail pool; { @@ -396,9 +419,8 @@ BOOST_AUTO_TEST_CASE( returnFail ) BOOST_REQUIRE_EQUAL(3, pool.freeCount()); } -BOOST_AUTO_TEST_CASE( exception_msgs ) +BOOST_AUTO_TEST_CASE(exception_msgs) { BOOST_CHECK_NO_THROW(AdHoc::TimeOutOnResourcePool("foo").message()); BOOST_CHECK_NO_THROW(AdHoc::NoCurrentResource(std::this_thread::get_id(), "foo").message()); } - diff --git a/libadhocutil/unittests/testScopeExit.cpp b/libadhocutil/unittests/testScopeExit.cpp index 66f4c48..edb8f99 100644 --- a/libadhocutil/unittests/testScopeExit.cpp +++ b/libadhocutil/unittests/testScopeExit.cpp @@ -6,24 +6,49 @@ using namespace AdHoc; -BOOST_AUTO_TEST_CASE ( cleanexit ) +BOOST_AUTO_TEST_CASE(cleanexit) { std::string log; { - ScopeExit se([&log]{ log += "before"; }, [&log]{ log += "clean"; }, [&log]{ log += "error"; }, [&log]{ log += "after"; }); + ScopeExit se( + [&log] { + log += "before"; + }, + [&log] { + log += "clean"; + }, + [&log] { + log += "error"; + }, + [&log] { + log += "after"; + }); } BOOST_REQUIRE_EQUAL(log, "beforecleanafter"); } -BOOST_AUTO_TEST_CASE ( uncaught ) +BOOST_AUTO_TEST_CASE(uncaught) { - BOOST_REQUIRE_THROW({ - std::string log; - { - ScopeExit se([&log]{ log += "before"; }, [&log]{ log += "clean"; }, [&log]{ log += "error"; }, [&log]{ log += "after"; }); - throw std::runtime_error("test unclean exit"); - } - BOOST_REQUIRE_EQUAL(log, "beforeerrorafter"); - }, std::runtime_error); + BOOST_REQUIRE_THROW( + { + std::string log; + { + ScopeExit se( + [&log] { + log += "before"; + }, + [&log] { + log += "clean"; + }, + [&log] { + log += "error"; + }, + [&log] { + log += "after"; + }); + throw std::runtime_error("test unclean exit"); + } + BOOST_REQUIRE_EQUAL(log, "beforeerrorafter"); + }, + std::runtime_error); } - diff --git a/libadhocutil/unittests/testSemaphore.cpp b/libadhocutil/unittests/testSemaphore.cpp index 38f9b8f..e2cdb7a 100644 --- a/libadhocutil/unittests/testSemaphore.cpp +++ b/libadhocutil/unittests/testSemaphore.cpp @@ -1,17 +1,17 @@ #define BOOST_TEST_MODULE Semaphore #include <boost/test/unit_test.hpp> -#include <thread> #include <semaphore.h> +#include <thread> -BOOST_AUTO_TEST_CASE( addRemoveOne ) +BOOST_AUTO_TEST_CASE(addRemoveOne) { AdHoc::Semaphore s; s.notify(); s.wait(); } -BOOST_AUTO_TEST_CASE( initial ) +BOOST_AUTO_TEST_CASE(initial) { AdHoc::Semaphore s(2); s.wait(); @@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE( initial ) BOOST_REQUIRE_EQUAL(false, s.wait(0)); } -BOOST_AUTO_TEST_CASE( addRemoveSome ) +BOOST_AUTO_TEST_CASE(addRemoveSome) { AdHoc::Semaphore s; BOOST_REQUIRE_EQUAL(0, s.freeCount()); @@ -37,7 +37,7 @@ BOOST_AUTO_TEST_CASE( addRemoveSome ) BOOST_REQUIRE_EQUAL(0, s.freeCount()); } -BOOST_AUTO_TEST_CASE( addRemoveTimeOut ) +BOOST_AUTO_TEST_CASE(addRemoveTimeOut) { AdHoc::Semaphore s; s.notify(); @@ -46,14 +46,16 @@ BOOST_AUTO_TEST_CASE( addRemoveTimeOut ) BOOST_REQUIRE_EQUAL(false, s.wait(0)); } -BOOST_AUTO_TEST_CASE( addRemoveWait ) +BOOST_AUTO_TEST_CASE(addRemoveWait) { AdHoc::Semaphore s; s.notify(); s.wait(); - std::thread th([&s]() { usleep(100000); s.notify(); }); + std::thread th([&s]() { + usleep(100000); + s.notify(); + }); BOOST_REQUIRE_EQUAL(false, s.wait(1)); s.wait(); th.join(); } - diff --git a/libadhocutil/unittests/testUriParse.cpp b/libadhocutil/unittests/testUriParse.cpp index 600f0f0..5e54e46 100644 --- a/libadhocutil/unittests/testUriParse.cpp +++ b/libadhocutil/unittests/testUriParse.cpp @@ -3,7 +3,7 @@ #include "uriParse.h" -BOOST_AUTO_TEST_CASE( simple ) +BOOST_AUTO_TEST_CASE(simple) { AdHoc::Uri u("http://localhost"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -16,7 +16,7 @@ BOOST_AUTO_TEST_CASE( simple ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( lowerScheme ) +BOOST_AUTO_TEST_CASE(lowerScheme) { AdHoc::Uri u("HtTP://localhost"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -29,7 +29,7 @@ BOOST_AUTO_TEST_CASE( lowerScheme ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( simpleTrailingSlash ) +BOOST_AUTO_TEST_CASE(simpleTrailingSlash) { AdHoc::Uri u("ssh+git://localhost/"); BOOST_REQUIRE_EQUAL("ssh+git", u.scheme); @@ -43,7 +43,7 @@ BOOST_AUTO_TEST_CASE( simpleTrailingSlash ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( simpleWithPort ) +BOOST_AUTO_TEST_CASE(simpleWithPort) { AdHoc::Uri u("http://localhost:80"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE( simpleWithPort ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( simpleTrailingSlashWithPort ) +BOOST_AUTO_TEST_CASE(simpleTrailingSlashWithPort) { AdHoc::Uri u("http://localhost:80/"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE( simpleTrailingSlashWithPort ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( username ) +BOOST_AUTO_TEST_CASE(username) { AdHoc::Uri u("http://user@localhost"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -85,7 +85,7 @@ BOOST_AUTO_TEST_CASE( username ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( usernameAndPassword ) +BOOST_AUTO_TEST_CASE(usernameAndPassword) { AdHoc::Uri u("http://user:pass@localhost"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -99,7 +99,7 @@ BOOST_AUTO_TEST_CASE( usernameAndPassword ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( path ) +BOOST_AUTO_TEST_CASE(path) { AdHoc::Uri u("http://localhost/path/to/resource"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -112,7 +112,7 @@ BOOST_AUTO_TEST_CASE( path ) BOOST_REQUIRE(!u.fragment); } -BOOST_AUTO_TEST_CASE( query0 ) +BOOST_AUTO_TEST_CASE(query0) { AdHoc::Uri u("http://localhost/?"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE( query0 ) BOOST_REQUIRE_EQUAL(0, u.query.size()); } -BOOST_AUTO_TEST_CASE( query1 ) +BOOST_AUTO_TEST_CASE(query1) { AdHoc::Uri u("http://localhost/?var=val"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -130,7 +130,7 @@ BOOST_AUTO_TEST_CASE( query1 ) BOOST_REQUIRE_EQUAL("val", u.query.begin()->second); } -BOOST_AUTO_TEST_CASE( query2 ) +BOOST_AUTO_TEST_CASE(query2) { AdHoc::Uri u("http://localhost/?var=val&name=value"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -142,7 +142,7 @@ BOOST_AUTO_TEST_CASE( query2 ) BOOST_REQUIRE_EQUAL("val", u.query.rbegin()->second); } -BOOST_AUTO_TEST_CASE( queryMany ) +BOOST_AUTO_TEST_CASE(queryMany) { AdHoc::Uri u("http://localhost/?name=val&name=value"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE( queryMany ) BOOST_REQUIRE_EQUAL("value", u.query.rbegin()->second); } -BOOST_AUTO_TEST_CASE( queryNoValue1 ) +BOOST_AUTO_TEST_CASE(queryNoValue1) { AdHoc::Uri u("http://localhost/?n1"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -164,7 +164,7 @@ BOOST_AUTO_TEST_CASE( queryNoValue1 ) BOOST_REQUIRE_EQUAL("", u.query.begin()->second); } -BOOST_AUTO_TEST_CASE( queryNoValue1eq ) +BOOST_AUTO_TEST_CASE(queryNoValue1eq) { AdHoc::Uri u("http://localhost/?n1="); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -174,7 +174,7 @@ BOOST_AUTO_TEST_CASE( queryNoValue1eq ) BOOST_REQUIRE_EQUAL("", u.query.begin()->second); } -BOOST_AUTO_TEST_CASE( queryNoValue2 ) +BOOST_AUTO_TEST_CASE(queryNoValue2) { AdHoc::Uri u("http://localhost/?n1=&n2"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -186,7 +186,7 @@ BOOST_AUTO_TEST_CASE( queryNoValue2 ) BOOST_REQUIRE_EQUAL("", u.query.rbegin()->second); } -BOOST_AUTO_TEST_CASE( fragment ) +BOOST_AUTO_TEST_CASE(fragment) { AdHoc::Uri u("http://localhost/path/to/resource#someFrag"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -200,7 +200,7 @@ BOOST_AUTO_TEST_CASE( fragment ) BOOST_REQUIRE_EQUAL("someFrag", *u.fragment); } -BOOST_AUTO_TEST_CASE( ipv6 ) +BOOST_AUTO_TEST_CASE(ipv6) { AdHoc::Uri u("http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html"); BOOST_REQUIRE_EQUAL("http", u.scheme); @@ -211,7 +211,7 @@ BOOST_AUTO_TEST_CASE( ipv6 ) BOOST_REQUIRE_EQUAL("index.html", *u.path); } -BOOST_AUTO_TEST_CASE( bad ) +BOOST_AUTO_TEST_CASE(bad) { BOOST_REQUIRE_THROW(AdHoc::Uri(""), AdHoc::InvalidUri); BOOST_REQUIRE_THROW(AdHoc::Uri("localhost"), AdHoc::InvalidUri); @@ -227,4 +227,3 @@ BOOST_AUTO_TEST_CASE( bad ) AdHoc::InvalidUri ui("message", "http://localhost"); BOOST_REQUIRE_EQUAL("InvalidUri (message) parsing [http://localhost]", ui.what()); } - diff --git a/libadhocutil/unittests/utilTestClasses.cpp b/libadhocutil/unittests/utilTestClasses.cpp index cb31104..4ae241c 100644 --- a/libadhocutil/unittests/utilTestClasses.cpp +++ b/libadhocutil/unittests/utilTestClasses.cpp @@ -2,4 +2,3 @@ #include "plugins.impl.h" PLUGIN(ImplOfThing, BaseThing); - diff --git a/libadhocutil/unittests/utilTestClasses.h b/libadhocutil/unittests/utilTestClasses.h index 18ddbef..1fbe766 100644 --- a/libadhocutil/unittests/utilTestClasses.h +++ b/libadhocutil/unittests/utilTestClasses.h @@ -19,4 +19,3 @@ class OtherImpl : public OtherBase { }; #endif - diff --git a/libadhocutil/uriParse.cpp b/libadhocutil/uriParse.cpp index ba507c8..df19abc 100644 --- a/libadhocutil/uriParse.cpp +++ b/libadhocutil/uriParse.cpp @@ -1,11 +1,12 @@ #include "uriParse.h" +#include "compileTimeFormatter.h" #include <boost/algorithm/string/case_conv.hpp> #include <boost/lexical_cast.hpp> #include <utility> -#include "compileTimeFormatter.h" namespace AdHoc { - static inline int _is_scheme_char(int c) + static inline int + _is_scheme_char(int c) { return (!isalpha(c) && '+' != c && '-' != c && '.' != c) ? 0 : 1; } @@ -13,7 +14,7 @@ namespace AdHoc { Uri::Uri(const std::string & uri) { auto * puri = this; - const char *curstr; + const char * curstr; int userpass_flag; int bracket_flag; @@ -47,7 +48,8 @@ namespace AdHoc { if ('@' == *tmpstr) { userpass_flag = 1; break; - } else if ('/' == *tmpstr) { + } + else if ('/' == *tmpstr) { userpass_flag = 0; break; } @@ -69,7 +71,7 @@ namespace AdHoc { tmpstr++; } len = tmpstr - curstr; - puri->password = std::string(curstr, len); + puri->password = std::string(curstr, len); curstr = tmpstr; } if ('@' != *curstr) { @@ -80,7 +82,8 @@ namespace AdHoc { if ('[' == *curstr) { bracket_flag = 1; - } else { + } + else { bracket_flag = 0; } @@ -89,7 +92,8 @@ namespace AdHoc { if (bracket_flag && ']' == *tmpstr) { tmpstr++; break; - } else if (!bracket_flag && (':' == *tmpstr || '/' == *tmpstr)) { + } + else if (!bracket_flag && (':' == *tmpstr || '/' == *tmpstr)) { break; } tmpstr++; @@ -123,7 +127,7 @@ namespace AdHoc { curstr++; tmpstr = curstr; - while ('\0' != *tmpstr && '#' != *tmpstr && '?' != *tmpstr) { + while ('\0' != *tmpstr && '#' != *tmpstr && '?' != *tmpstr) { tmpstr++; } len = tmpstr - curstr; @@ -138,7 +142,7 @@ namespace AdHoc { tmpstr++; } len = tmpstr - curstr; - auto q = puri->query.insert({ std::string(curstr, len), std::string() }); + auto q = puri->query.insert({std::string(curstr, len), std::string()}); curstr = tmpstr; if ('=' == *curstr) { curstr++; @@ -171,10 +175,8 @@ namespace AdHoc { } } - InvalidUri::InvalidUri(std::string e, std::string u) : - Exception<std::invalid_argument>(std::string()), - err(std::move(e)), - uri(std::move(u)) + InvalidUri::InvalidUri(std::string e, std::string u) : + Exception<std::invalid_argument>(std::string()), err(std::move(e)), uri(std::move(u)) { } @@ -186,4 +188,3 @@ namespace AdHoc { return InvalidUriMsg::get(err, uri); } } - diff --git a/libadhocutil/uriParse.h b/libadhocutil/uriParse.h index e6fd0cb..f0c3d49 100644 --- a/libadhocutil/uriParse.h +++ b/libadhocutil/uriParse.h @@ -1,57 +1,56 @@ #ifndef ADHOCUTIL_URIPARSE_H #define ADHOCUTIL_URIPARSE_H -#include "visibility.h" #include "exception.h" -#include <optional> +#include "visibility.h" #include <filesystem> -#include <string> #include <map> +#include <optional> +#include <string> namespace AdHoc { /** * Class representing a broken down URI. */ class DLL_PUBLIC Uri { - public: - /// Constructor accepting a URI to parse. - /// @param uri the URI to parse. - explicit Uri(const std::string & uri); - - /// The scheme. - std::string scheme; - /// The optional username. - std::optional<std::string> username; - /// The optional password. - std::optional<std::string> password; - /// The host. - std::string host; - /// The optional port. - std::optional<uint16_t> port; - /// The optional path. - std::optional<std::filesystem::path> path; - /// The parsed components of the query string. - std::multimap<std::string, std::string> query; - /// The optional fragment. - std::optional<std::string> fragment; + public: + /// Constructor accepting a URI to parse. + /// @param uri the URI to parse. + explicit Uri(const std::string & uri); + + /// The scheme. + std::string scheme; + /// The optional username. + std::optional<std::string> username; + /// The optional password. + std::optional<std::string> password; + /// The host. + std::string host; + /// The optional port. + std::optional<uint16_t> port; + /// The optional path. + std::optional<std::filesystem::path> path; + /// The parsed components of the query string. + std::multimap<std::string, std::string> query; + /// The optional fragment. + std::optional<std::string> fragment; }; /** * Exception representing a failure attempting to parse a URI. */ class DLL_PUBLIC InvalidUri : public Exception<std::invalid_argument> { - public: - /// Constructor accepting what went wrong and the URI being parsed. - InvalidUri(std::string err, std::string uri); + public: + /// Constructor accepting what went wrong and the URI being parsed. + InvalidUri(std::string err, std::string uri); - std::string message() const noexcept override; + std::string message() const noexcept override; - /// The parse error. - const std::string err; - /// The URI being parsed when the error occurred. - const std::string uri; + /// The parse error. + const std::string err; + /// The URI being parsed when the error occurred. + const std::string uri; }; } #endif - diff --git a/libadhocutil/visibility.h b/libadhocutil/visibility.h index 63378b7..c049b82 100644 --- a/libadhocutil/visibility.h +++ b/libadhocutil/visibility.h @@ -1,8 +1,7 @@ #ifndef DLL_PUBLIC -#define DLL_PUBLIC __attribute__ ((visibility ("default"))) +#define DLL_PUBLIC __attribute__((visibility("default"))) #endif #ifndef DLL_PRIVATE -#define DLL_PRIVATE __attribute__ ((visibility ("hidden"))) +#define DLL_PRIVATE __attribute__((visibility("hidden"))) #endif - |