Made this lib compatible with esp-idf components system

CMakeLists.txt

@@ -0,0 +1,15 @@
+set(headers
+    include/binary_semaphore.h
+    include/counting_semaphore.h
+    include/esprandom.h
+    include/event_group.h
+    include/http_client.h
+    include/lockhelper.h
+    include/lockingqueue.h
+    include/mutex_semaphore.h
+    include/recursivelockhelper.h
+    include/recursive_mutex_semaphore.h
+    include/websocket_client.h
+)
+
+idf_component_register(INCLUDE_DIRS include SRCS ${headers} REQUIRES freertos esp_system esp_http_client esp_websocket_client cpputils)

cleanuphelper.h

@@ -1,36 +0,0 @@
-#pragma once
-
-// system includes
-#include <utility>
-#include <optional>
-
-namespace espcpputils {
-template<typename T>
-class CleanupHelper
-{
-public:
-    CleanupHelper(T && cleanup) :
-        m_cleanup{std::move(cleanup)}
-    {}
-
-    ~CleanupHelper()
-    {
-        if (m_cleanup)
-            (*m_cleanup)();
-    }
-
-    void disarm()
-    {
-        m_cleanup = std::nullopt;
-    }
-
-private:
-    std::optional<T> m_cleanup;
-};
-
-template<typename T>
-CleanupHelper<T> makeCleanupHelper(T && cleanup)
-{
-    return CleanupHelper<T>(std::move(cleanup));
-}
-} // namespace espcpputils

delayedconstruction.h

@@ -1,99 +0,0 @@
-#pragma once
-
-// system includes
-#include <cassert>
-#include <type_traits>
-#include <utility>
-
-// local includes
-#include "esputils.h"
-
-namespace espcpputils {
-template<typename T>
-class DelayedConstruction
-{
-    ESP_DISABLE_COPY_MOVE(DelayedConstruction)
-
-public:
-    DelayedConstruction() = default;
-    ~DelayedConstruction()
-    {
-        if (m_constructed)
-            destruct();
-    }
-
-    template<typename ...Targs>
-    void construct(Targs &&...args)
-    {
-        assert(!m_constructed);
-        new (&helper.value) T {std::forward<Targs>(args)...};
-        m_constructed = true;
-    }
-
-    void destruct()
-    {
-        assert(m_constructed);
-        helper.value.~T();
-        m_constructed = false;
-    }
-
-    T &get()
-    {
-        assert(m_constructed);
-        return helper.value;
-    }
-
-    const T &get() const
-    {
-        assert(m_constructed);
-        return helper.value;
-    }
-
-    T *operator->()
-    {
-        assert(m_constructed);
-        return &helper.value;
-    }
-
-    const T *operator->() const
-    {
-        assert(m_constructed);
-        return &helper.value;
-    }
-
-    T &operator*()
-    {
-        assert(m_constructed);
-        return helper.value;
-    }
-
-    const T &operator*() const
-    {
-        assert(m_constructed);
-        return helper.value;
-    }
-
-    //! allows for getting the address before the object has been constructed
-    T &getUnsafe()
-    {
-        return helper.value;
-    }
-
-    //! allows for getting the address before the object has been constructed
-    const T &getUnsafe() const
-    {
-        return helper.value;
-    }
-
-    bool constructed() const { return m_constructed; }
-
-private:
-    bool m_constructed{};
-    union Helper
-    {
-        Helper() {}
-        ~Helper() {}
-        T value;
-    } helper;
-};
-} // namespace espcpputils

espflags.h

@@ -1,114 +0,0 @@
-#pragma once
-
-// system includes
-#include <type_traits>
-#include <cstddef>
-#include <utility>
-#include <cstdint>
-
-namespace espcpputils {
-class EspFlag
-{
-    using uint = unsigned int;
-    using ushort = unsigned short;
-
-    int i;
-public:
-    constexpr inline EspFlag(int value) noexcept : i(value) {}
-    constexpr inline operator int() const noexcept { return i; }
-
-    constexpr inline EspFlag(uint value) noexcept : i(int(value)) {}
-    constexpr inline EspFlag(short value) noexcept : i(int(value)) {}
-    constexpr inline EspFlag(ushort value) noexcept : i(int(uint(value))) {}
-    constexpr inline operator uint() const noexcept { return uint(i); }
-};
-
-template<typename Enum>
-class EspFlags
-{
-    static_assert((sizeof(Enum) <= sizeof(int)),
-                      "EspFlags uses an int as storage, so an enum with underlying "
-                      "long long will overflow.");
-    static_assert((std::is_enum<Enum>::value), "EspFlags is only usable on enumeration types.");
-
-    using uint = unsigned int;
-    using ushort = unsigned short;
-
-public:
-    typedef typename std::conditional<
-            std::is_unsigned<typename std::underlying_type<Enum>::type>::value,
-            unsigned int,
-            signed int
-        >::type Int;
-
-    typedef Enum enum_type;
-
-    constexpr inline EspFlags() noexcept : i(0) {}
-    constexpr inline EspFlags(Enum flags) noexcept : i(Int(flags)) {}
-
-    constexpr inline EspFlags(EspFlag flag) noexcept : i(flag) {}
-
-    constexpr inline EspFlags(std::initializer_list<Enum> flags) noexcept
-        : i(initializer_list_helper(flags.begin(), flags.end())) {}
-
-    constexpr inline EspFlags &operator&=(int mask) noexcept { i &= mask; return *this; }
-    constexpr inline EspFlags &operator&=(uint mask) noexcept { i &= mask; return *this; }
-    constexpr inline EspFlags &operator&=(Enum mask) noexcept { i &= Int(mask); return *this; }
-    constexpr inline EspFlags &operator|=(EspFlags other) noexcept { i |= other.i; return *this; }
-    constexpr inline EspFlags &operator|=(Enum other) noexcept { i |= Int(other); return *this; }
-    constexpr inline EspFlags &operator^=(EspFlags other) noexcept { i ^= other.i; return *this; }
-    constexpr inline EspFlags &operator^=(Enum other) noexcept { i ^= Int(other); return *this; }
-
-    constexpr inline operator Int() const noexcept { return i; }
-
-    constexpr inline EspFlags operator|(EspFlags other) const noexcept { return EspFlags(EspFlag(i | other.i)); }
-    constexpr inline EspFlags operator|(Enum other) const noexcept { return EspFlags(EspFlag(i | Int(other))); }
-    constexpr inline EspFlags operator^(EspFlags other) const noexcept { return EspFlags(EspFlag(i ^ other.i)); }
-    constexpr inline EspFlags operator^(Enum other) const noexcept { return EspFlags(EspFlag(i ^ Int(other))); }
-    constexpr inline EspFlags operator&(int mask) const noexcept { return EspFlags(EspFlag(i & mask)); }
-    constexpr inline EspFlags operator&(uint mask) const noexcept { return EspFlags(EspFlag(i & mask)); }
-    constexpr inline EspFlags operator&(Enum other) const noexcept { return EspFlags(EspFlag(i & Int(other))); }
-    constexpr inline EspFlags operator~() const noexcept { return EspFlags(EspFlag(~i)); }
-
-    constexpr inline bool operator!() const noexcept { return !i; }
-
-    constexpr inline bool testFlag(Enum flag) const noexcept { return (i & Int(flag)) == Int(flag) && (Int(flag) != 0 || i == Int(flag) ); }
-    constexpr inline EspFlags &setFlag(Enum flag, bool on = true) noexcept
-    {
-        return on ? (*this |= flag) : (*this &= ~Int(flag));
-    }
-
-private:
-    constexpr static inline Int initializer_list_helper(typename std::initializer_list<Enum>::const_iterator it,
-                                                               typename std::initializer_list<Enum>::const_iterator end)
-    noexcept
-    {
-        return (it == end ? Int(0) : (Int(*it) | initializer_list_helper(it + 1, end)));
-    }
-
-    Int i;
-};
-
-class EspIncompatibleFlag
-{
-    int i;
-public:
-    constexpr inline explicit EspIncompatibleFlag(int i) noexcept;
-    constexpr inline operator int() const noexcept { return i; }
-};
-
-constexpr inline EspIncompatibleFlag::EspIncompatibleFlag(int value) noexcept : i(value) {}
-} // namespace espcpputils
-
-#define ESP_DECLARE_FLAGS(Flags, Enum)\
-typedef ::espcpputils::EspFlags<Enum> Flags;
-
-#define ESP_DECLARE_INCOMPATIBLE_FLAGS(Flags) \
-constexpr inline ::espcpputils::EspIncompatibleFlag operator|(Flags::enum_type f1, int f2) noexcept \
-{ return ::espcpputils::EspIncompatibleFlag(int(f1) | f2); }
-
-#define ESP_DECLARE_OPERATORS_FOR_FLAGS(Flags) \
-constexpr inline ::espcpputils::EspFlags<Flags::enum_type> operator|(Flags::enum_type f1, Flags::enum_type f2) noexcept \
-{ return ::espcpputils::EspFlags<Flags::enum_type>(f1) | f2; } \
-constexpr inline ::espcpputils::EspFlags<Flags::enum_type> operator|(Flags::enum_type f1, ::espcpputils::EspFlags<Flags::enum_type> f2) noexcept \
-{ return f2 | f1; } ESP_DECLARE_INCOMPATIBLE_FLAGS(Flags)

esputils.h

@@ -1,232 +0,0 @@
-#pragma once
-
-// system includes
-#include <algorithm>
-#include <cstdint>
-#include <functional>
-#include <vector>
-#include <cstring>
-#include <string>
-#include <string_view>
-
-/*
-   Avoid "unused parameter" warnings
-*/
-#define ESP_UNUSED(x) (void)x;
-
-/* These two macros make it possible to turn the builtin line expander into a
- * string literal. */
-#define ESP_STRINGIFY2(x) #x
-#define ESP_STRINGIFY(x) ESP_STRINGIFY2(x)
-
-/*
-   Some classes do not permit copies to be made of an object. These
-   classes contains a private copy constructor and assignment
-   operator to disable copying (the compiler gives an error message).
-*/
-#define ESP_DISABLE_COPY(Class) \
-    Class(const Class &) = delete;\
-    Class &operator=(const Class &) = delete;
-#define ESP_DISABLE_MOVE(Class) \
-    Class(Class &&) = delete; \
-    Class &operator=(Class &&) = delete;
-#define ESP_DISABLE_COPY_MOVE(Class) \
-    ESP_DISABLE_COPY(Class) \
-    ESP_DISABLE_MOVE(Class)
-
-
-/* These two macros make it possible to define a typesafe enum with parse and
- * toString methods */
-#define DECLARE_TYPESAFE_ENUM_HELPER1(name) name,
-#define DECLARE_TYPESAFE_ENUM_HELPER2(name) case TheEnum::name: return #name;
-#define DECLARE_TYPESAFE_ENUM_HELPER3(name) else if (str == ESP_STRINGIFY(name)) return TheEnum::name;
-
-#define DECLARE_TYPESAFE_ENUM(Name, Derivation, Values) \
-    enum class Name Derivation \
-    { \
-        Values(DECLARE_TYPESAFE_ENUM_HELPER1) \
-    }; \
-    std::string toString(Name value); \
-    std::optional<Name> parse##Name(std::string_view str);
-
-#define IMPLEMENT_TYPESAFE_ENUM(Name, Derivation, Values) \
-    std::string toString(Name value) \
-    { \
-        switch (value) \
-        { \
-        using TheEnum = Name; \
-        Values(DECLARE_TYPESAFE_ENUM_HELPER2) \
-        } \
-        return std::string{"Unknown " #Name "("} + std::to_string(int(value)) + ')'; \
-    } \
-    std::optional<Name> parse##Name(std::string_view str) \
-    { \
-    using TheEnum = Name; \
-    if (false) {} \
-    Values(DECLARE_TYPESAFE_ENUM_HELPER3) \
-    return std::nullopt; \
-    }
-
-namespace espcpputils {
-
-template<typename... T>
-class Signal
-{
-public:
-    using Slot = std::function<void(T...)>;
-
-    Signal &operator+=(Slot &&slot)
-    {
-        m_slots.emplace_back(std::move(slot));
-        return *this;
-    }
-
-    Signal &operator+=(const Slot &slot)
-    {
-        m_slots.emplace_back(slot);
-        return *this;
-    }
-
-    template<typename ...Targs>
-    void operator()(Targs && ...args) const
-    {
-        for (const auto &slot : m_slots)
-            slot(std::forward<Targs>(args)...);
-    }
-
-private:
-    std::vector<Slot> m_slots;
-};
-
-namespace literals {
-namespace {
-/**
- * User-defined Literals
- *  usage:
- *
- *   uint32_t = test = 10_MHz; // --> 10000000
- */
-
-constexpr unsigned long long operator"" _kHz(unsigned long long x)
-{
-    return x * 1000;
-}
-
-constexpr unsigned long long operator"" _MHz(unsigned long long x)
-{
-    return x * 1000 * 1000;
-}
-
-constexpr unsigned long long operator"" _GHz(unsigned long long x)
-{
-    return x * 1000 * 1000 * 1000;
-}
-
-constexpr unsigned long long operator"" _kBit(unsigned long long x)
-{
-    return x * 1024;
-}
-
-constexpr unsigned long long operator"" _MBit(unsigned long long x)
-{
-    return x * 1024 * 1024;
-}
-
-constexpr unsigned long long operator"" _GBit(unsigned long long x)
-{
-    return x * 1024 * 1024 * 1024;
-}
-
-constexpr unsigned long long operator"" _kB(unsigned long long x)
-{
-    return x * 1024;
-}
-
-constexpr unsigned long long operator"" _MB(unsigned long long x)
-{
-    return x * 1024 * 1024;
-}
-
-constexpr unsigned long long operator"" _GB(unsigned long long x)
-{
-    return x * 1024 * 1024 * 1024;
-}
-} // namespace
-} // namespace literals
-
-namespace {
-template<typename T>
-T vmin(T&&t)
-{
-    return std::forward<T>(t);
-}
-
-template<typename T0, typename T1, typename... Ts>
-typename std::common_type<T0, T1, Ts...>::type vmin(T0&& val1, T1&& val2, Ts&&... vs)
-{
-    if (val1 < val2)
-        return vmin(val1, std::forward<Ts>(vs)...);
-    else
-        return vmin(val2, std::forward<Ts>(vs)...);
-}
-
-template<class T>
-constexpr const T& clamp( const T& v, const T& lo, const T& hi )
-{
-    // assert( !(hi < lo) );
-    return (v < lo) ? lo : (hi < v) ? hi : v;
-}
-
-template<typename T>
-T mapValue(T x, T in_min, T in_max, T out_min, T out_max)
-{
-    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}
-
-template <typename... Args>
-struct EspNonConstOverload
-{
-    template <typename R, typename T>
-    constexpr auto operator()(R (T::*ptr)(Args...)) const noexcept -> decltype(ptr)
-    { return ptr; }
-    template <typename R, typename T>
-    static constexpr auto of(R (T::*ptr)(Args...)) noexcept -> decltype(ptr)
-    { return ptr; }
-};
-template <typename... Args>
-struct EspConstOverload
-{
-    template <typename R, typename T>
-    constexpr auto operator()(R (T::*ptr)(Args...) const) const noexcept -> decltype(ptr)
-    { return ptr; }
-    template <typename R, typename T>
-    static constexpr auto of(R (T::*ptr)(Args...) const) noexcept -> decltype(ptr)
-    { return ptr; }
-};
-template <typename... Args>
-struct EspOverload : EspConstOverload<Args...>, EspNonConstOverload<Args...>
-{
-    using EspConstOverload<Args...>::of;
-    using EspConstOverload<Args...>::operator();
-    using EspNonConstOverload<Args...>::of;
-    using EspNonConstOverload<Args...>::operator();
-    template <typename R>
-    constexpr auto operator()(R (*ptr)(Args...)) const noexcept -> decltype(ptr)
-    { return ptr; }
-    template <typename R>
-    static constexpr auto of(R (*ptr)(Args...)) noexcept -> decltype(ptr)
-    { return ptr; }
-};
-
-template <typename... Args> constexpr __attribute__((__unused__)) EspOverload<Args...> espOverload = {};
-template <typename... Args> constexpr __attribute__((__unused__)) EspConstOverload<Args...> espConstOverload = {};
-template <typename... Args> constexpr __attribute__((__unused__)) EspNonConstOverload<Args...> espNonConstOverload = {};
-
-template<typename First, typename ... T>
-bool is_in(First &&first, T && ... t)
-{
-    return ((first == t) || ...);
-}
-
-} // namespace
-} // namespace espcpputils

include/binary_semaphore.h

@@ -6,12 +6,12 @@
 #include <freertos/task.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class binary_semaphore
 {
-    ESP_DISABLE_COPY_MOVE(binary_semaphore)
+    CPP_DISABLE_COPY_MOVE(binary_semaphore)
 
 public:
     binary_semaphore() :

include/counting_semaphore.h

@@ -6,12 +6,12 @@
 #include <freertos/task.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class counting_semaphore
 {
-    ESP_DISABLE_COPY_MOVE(counting_semaphore)
+    CPP_DISABLE_COPY_MOVE(counting_semaphore)
 
 public:
     counting_semaphore(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount) :

include/esprandom.h

@@ -3,6 +3,7 @@
 // system includes
 #include <limits>
 #include <random>
+#include <iterator>
 
 // esp-idf includes
 #include <esp_system.h>
@@ -24,14 +25,14 @@ public:
 
 std::string randomString(std::size_t length)
 {
-    static constexpr auto chars =
+    static constexpr const char chars[] =
         "0123456789"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         "abcdefghijklmnopqrstuvwxyz";
 
     auto rng = esp_random_device{};
 
-    auto dist = std::uniform_int_distribution{{}, std::strlen(chars) - 1};
+    auto dist = std::uniform_int_distribution{{}, std::size(chars) - 1};
 
     auto result = std::string(length, '\0');
     std::generate_n(std::begin(result), length, [&]() { return chars[dist(rng)]; });

include/event_group.h

@@ -5,12 +5,12 @@
 #include <freertos/event_groups.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class event_group
 {
-    ESP_DISABLE_COPY_MOVE(event_group)
+    CPP_DISABLE_COPY_MOVE(event_group)
 
 public:
     event_group() :

include/http_client.h

@@ -4,12 +4,12 @@
 #include <esp_http_client.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class http_client
 {
-    ESP_DISABLE_COPY_MOVE(http_client)
+    CPP_DISABLE_COPY_MOVE(http_client)
 
 public:
     http_client(const esp_http_client_config_t *config) :

include/lockhelper.h

@@ -5,12 +5,12 @@
 #include <freertos/semphr.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class LockHelper
 {
-    ESP_DISABLE_COPY_MOVE(LockHelper)
+    CPP_DISABLE_COPY_MOVE(LockHelper)
 
 public:
     LockHelper(QueueHandle_t _xMutex, TickType_t xTicksToWait=portMAX_DELAY) :

include/lockingqueue.h

@@ -9,7 +9,6 @@
 #include <freertos/semphr.h>
 
 // local includes
-#include "esputils.h"
 #include "delayedconstruction.h"
 #include "recursive_mutex_semaphore.h"
 #include "recursivelockhelper.h"

include/mutex_semaphore.h

@@ -6,12 +6,12 @@
 #include <freertos/task.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class mutex_semaphore
 {
-    ESP_DISABLE_COPY_MOVE(mutex_semaphore)
+    CPP_DISABLE_COPY_MOVE(mutex_semaphore)
 
 public:
     mutex_semaphore() :

include/recursive_mutex_semaphore.h

@@ -6,12 +6,12 @@
 #include <freertos/task.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class recursive_mutex_semaphore
 {
-    ESP_DISABLE_COPY_MOVE(recursive_mutex_semaphore)
+    CPP_DISABLE_COPY_MOVE(recursive_mutex_semaphore)
 
 public:
     recursive_mutex_semaphore() :

include/recursivelockhelper.h

@@ -5,12 +5,12 @@
 #include <freertos/semphr.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class RecursiveLockHelper
 {
-    ESP_DISABLE_COPY_MOVE(RecursiveLockHelper)
+    CPP_DISABLE_COPY_MOVE(RecursiveLockHelper)
 
 public:
     RecursiveLockHelper(QueueHandle_t _xMutex, TickType_t xTicksToWait=portMAX_DELAY) :

include/websocket_client.h

@@ -4,12 +4,12 @@
 #include <esp_websocket_client.h>
 
 // local includes
-#include "esputils.h"
+#include "cppmacros.h"
 
 namespace espcpputils {
 class websocket_client
 {
-    ESP_DISABLE_COPY_MOVE(websocket_client)
+    CPP_DISABLE_COPY_MOVE(websocket_client)
 
 public:
     websocket_client(const esp_websocket_client_config_t &config) :