.gitmodules

@@ -1,3 +0,0 @@
-[submodule "test/mingw-std-threads"]
-	path = test/mingw-std-threads
-	url = https://github.com/meganz/mingw-std-threads.git

include/cont/deque.h

@@ -33,10 +33,8 @@
 
 #include <core/core.h>
 #include <core/ring_iterator.h>
-#include <cont/range.h>
 
 #include <array>
-#include <atomic>
 
 namespace tbx {
 
@@ -54,19 +52,14 @@ namespace tbx {
  *
  * \tparam Data_t   The char-like queued item type. Usually \c char
  * \tparam N        The size of deque
- * \tparam SemiAtomic   True for semi-atomic operation. In that case the \c ring_iterator is also atomic.
- * \note
- *      SemiAtomic means it is safe to access different ends from different threads. For example one thread can
- *      push only from front and another can pop from back to implement a queue.
  */
-template <typename Data_t, size_t N, bool SemiAtomic =false>
+template <typename Data_t, size_t N>
 class deque {
     public:
         // meta-identity type
         using type              = deque<Data_t, N>;
         using buffer_t          = std::array<Data_t, N+1>;  // We need N+1 spaces ring buffer for N spaces deque
-        using iterator_t        = ring_iterator<Data_t*, N+1, SemiAtomic>;
+        using iterator_t        = ring_iterator<Data_t*, N+1>;
-        using range_t           = range<iterator_t>;
 
         // STL
         using value_type        = Data_t;
@@ -110,9 +103,9 @@ class deque {
     //! \name Iterators
     //! @{
     public:
-        constexpr iterator begin() noexcept               { iterator ret = f; return ++ret; }
+        constexpr iterator begin() noexcept               { return f+1; }
-        constexpr const_iterator begin() const noexcept   { iterator ret = f; return ++ret; }
+        constexpr const_iterator begin() const noexcept   { return f+1; }
-        constexpr const_iterator cbegin() const noexcept  { iterator ret = f; return ++ret; }
+        constexpr const_iterator cbegin() const noexcept  { return f+1; }
 
         constexpr iterator end() noexcept                 { return r; }
         constexpr const_iterator end() const noexcept     { return r; }
@@ -122,9 +115,9 @@ class deque {
         constexpr const_reverse_iterator rbegin() const noexcept  { return r; }
         constexpr const_reverse_iterator crbegin() const noexcept { return r; }
 
-        constexpr reverse_iterator rend() noexcept                { reverse_iterator ret = f; return ++ret; }
+        constexpr reverse_iterator rend() noexcept                { return f+1; }
-        constexpr const_reverse_iterator rend() const noexcept    { reverse_iterator ret = f; return ++ret; }
+        constexpr const_reverse_iterator rend() const noexcept    { return f+1; }
-        constexpr const_reverse_iterator crend() const noexcept   { reverse_iterator ret = f; return ++ret; }
+        constexpr const_reverse_iterator crend() const noexcept   { return f+1; }
     //! @}
 
     //! \name Capacity
@@ -134,9 +127,6 @@ class deque {
         constexpr size_t size() noexcept {
             return full() ? N: (r - f) -1;
         }
-        constexpr size_t size() const noexcept {
-            return full() ? N: (r - f) -1;
-        }
         //! \return The maximum size of the deque. The items the queue can hold.
         constexpr size_t max_size() noexcept { return N; }
         //! \return The capacity of the deque. The items the queue can hold.
@@ -144,11 +134,7 @@ class deque {
         //! \return True if the deque is empty
         constexpr bool   empty()    noexcept { return size() == 0 ? true : false; }
         //! \return True if the deque is full
-        constexpr bool   full()     noexcept {
+        constexpr bool   full()     noexcept { return (r == f) ? true : false; }
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_acquire);
-            return (r == f) ? true : false;
-        }
     //! @}
 
     //! \name Member access
@@ -159,65 +145,41 @@ class deque {
         constexpr void clear() noexcept {
             f = iterator_t(data_.data(), N);
             r = iterator_t(data_.data());
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_release);
         }
         //! \brief      Push an item in the front of the deque
         //! \param it   The item to push
         constexpr void push_front (const Data_t& it) {
             if (full())     return;
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_acquire);
             *f-- = it;
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_release);
         }
         //! \brief      Extract an item from the front of the deque and remove it from the deque
         //! \param it   The item to push
         constexpr Data_t pop_front () {
             if (empty())    return Data_t{};
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_acquire);
             return *++f;
         }
         //! \brief      Push an item in the back of the deque
         //! \param it   The item to push
         constexpr void push_back (const Data_t& it) {
             if (full())     return;
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_acquire);
             *r++ = it;
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_release);
         }
         //! \brief      Extract an item from the back of the deque and remove it from the deque
         //! \param it   The item to push
         constexpr Data_t pop_back () {
             if (empty())    return Data_t{};
-            if constexpr (SemiAtomic)
-                std::atomic_thread_fence(std::memory_order_acquire);
             return *--r;
         }
 
         //! \brief      Get a reference to the item in the front of the deque without extracting it.
         //! \return     Reference to the item
-        constexpr Data_t& front() noexcept { iterator_t it = f; return *++it; }
+        constexpr Data_t& front() noexcept { return *(f+1); }
-        constexpr const Data_t& front() const noexcept { iterator_t it = f; return *++it; }
+        constexpr const Data_t& front() const noexcept { return *(f+1); }
 
         //! \brief      Get a reference to the item in the front of the deque without extracting it.
         //! \return     Reference to the item
-        constexpr Data_t& back() noexcept { iterator_t it = r; return *--it; }
+        constexpr Data_t& back() noexcept { return *(r-1); }
-        constexpr const Data_t& back() const noexcept { iterator_t it = r; return *--it; }
+        constexpr const Data_t& back() const noexcept { return *(r-1); }
-
-        //! \brief      Get a pointer to the begin of the items on the deque
-        //! \return
-        constexpr Data_t* data() noexcept { return &front(); }
-        constexpr const Data_t* data() const noexcept { return &front(); }
-
-        //! \brief      Get a range for the data in queue
-        //! \return     A begin-end iterator pair struct
-        constexpr range_t contents () noexcept { iterator_t b = f; return {++b, r}; }
-        constexpr const range_t contents () const noexcept { iterator_t b = f; return {++b, r}; }
 
     //! @}
     private:

include/cont/edeque.h

@@ -57,20 +57,15 @@ namespace tbx {
  *
  * \tparam Data_t   The char-like queued item type. Usually \c char
  * \tparam N        The size of edeque
- * \tparam SemiAtomic   True for semi-atomic operation. In that case the \c ring_iterator is also atomic.
  * \tparam Fn       The type of Callable
- * \note
- *      SemiAtomic means it is safe to access different ends from different threads. For example one thread can
- *      push only from front and another can pop from back to implement a queue.
  */
-template <typename Data_t, size_t N, bool SemiAtomic =false, typename Fn = std::function<void()>>
+template <typename Data_t, size_t N, typename Fn = std::function<void()>>
-class edeque : public deque<Data_t, N, SemiAtomic> {
+class edeque : public deque<Data_t, N> {
     public:
         // meta-identity types
-        using type                  = edeque<Data_t, N, SemiAtomic, Fn>;
+        using type                  = edeque<Data_t, N>;
-        using base_type             = deque<Data_t, N, SemiAtomic>;
+        using base_type             = deque<Data_t, N>;
         using callable_t            = Fn;
-        using range_t               = typename base_type::range_t;
 
         // STL
         using value_type            = typename base_type::value_type;
@@ -94,11 +89,7 @@ class edeque : public deque<Data_t, N, SemiAtomic> {
         enum class size_match { DISABLED =0, EQ, NE, LT, LE, GT, GE };
         //! \enum data_match
         //! The type of matching for data based match
-        enum class data_match { DISABLED =0, MATCH_PUSH, MATCH_POP, MISMATCH_PUSH, MISMATCH_POP};
+        enum class data_match { DISABLED =0, MATCH, MISMATCH};
-
-//        TODO: trigger mode for one-shot or repeated functionality
-//        enum class trigger_mode { ONE_SHOT, REPEATED };
-
         //! \struct size_trigger
         //! Size trigger data type
         struct size_trigger {
@@ -129,7 +120,7 @@ class edeque : public deque<Data_t, N, SemiAtomic> {
         constexpr edeque () noexcept :
             base_type() { }
 
-        //! Size trigger constructor
+        //!
         constexpr edeque (size_match match, size_t size, callable_t&& fn) :
             base_type(),
             mode_{match_mode::SIZE},
@@ -137,7 +128,7 @@ class edeque : public deque<Data_t, N, SemiAtomic> {
             trigger_.tsize.type = match;
             trigger_.tsize.size = size;
         }
-        //! Data trigger constructor
+
         constexpr edeque (data_match match, Data_t value, callable_t&& fn) :
             base_type(),
             mode_{match_mode::DATA},
@@ -195,25 +186,25 @@ class edeque : public deque<Data_t, N, SemiAtomic> {
     //! @{
         void push_front (const Data_t& it) {
             base_type::push_front(it);
-            check_trigger_push_async_(it);
+            check_trigger_async_(it);
         }
         Data_t pop_front () {
             Data_t t = base_type::pop_front();
-            check_trigger_pop_async_(t);
+            check_trigger_async_(t);
             return t;
         }
         void push_back (const Data_t& it) {
             base_type::push_back(it);
-            check_trigger_push_async_(it);
+            check_trigger_async_(it);
         }
         Data_t pop_back () {
             Data_t t = base_type::pop_back();
-            check_trigger_pop_async_(t);
+            check_trigger_async_(t);
             return t;
         }
     //! @}
 
-    //! \name Private functionality
+    //! \name Public interface
     //! @{
     private:
         //! \brief
@@ -239,53 +230,28 @@ class edeque : public deque<Data_t, N, SemiAtomic> {
         }
 
         //! \brief
-        //!     Manually checks the data trigger on push and calls it we have match.
+        //!     Manually checks the data trigger and calls it we have match.
         //! \param  it  The item to check against
         //! \return     True if the callable has called.
-        bool check_trigger_push_value_ (const Data_t& it) {
+        bool check_trigger_value_ (const Data_t& it) {
             bool match;
             switch (trigger_.tdata.type) {
                 default:
                 case data_match::DISABLED:  match = false;  break;
-                case data_match::MATCH_PUSH:    match = (it == trigger_.tdata.value); break;
+                case data_match::MATCH:     match = (it == trigger_.tdata.value); break;
-                case data_match::MISMATCH_PUSH: match = (it != trigger_.tdata.value); break;
+                case data_match::MISMATCH:  match = (it != trigger_.tdata.value); break;
             }
             if (match)
                 callback_();
             return match;
         }
 
-        //! \brief
+        //! Wrapper for both triggers
-        //!     Manually checks the data trigger on pop and calls it we have match.
+        bool check_trigger_async_ (const Data_t& it) {
-        //! \param  it  The item to check against
-        //! \return     True if the callable has called.
-        bool check_trigger_pop_value_ (const Data_t& it) {
-            bool match;
-            switch (trigger_.tdata.type) {
-                default:
-                case data_match::DISABLED:      match = false;  break;
-                case data_match::MATCH_POP:     match = (it == trigger_.tdata.value); break;
-                case data_match::MISMATCH_POP:  match = (it != trigger_.tdata.value); break;
-            }
-            if (match)
-                callback_();
-            return match;
-        }
-
-        //! Wrapper for both triggers at push
-        bool check_trigger_push_async_ (const Data_t& it) {
             switch (mode_) {
                 default:
                 case match_mode::SIZE:  return check_trigger_size_();
-                case match_mode::DATA:  return check_trigger_push_value_(it);
+                case match_mode::DATA:  return check_trigger_value_(it);
-            }
-        }
-        //! Wrapper for both triggers at pop
-        bool check_trigger_pop_async_ (const Data_t& it) {
-            switch (mode_) {
-                default:
-                case match_mode::SIZE:  return check_trigger_size_();
-                case match_mode::DATA:  return check_trigger_pop_value_(it);
             }
         }
     //! @}

include/cont/equeue.h

@@ -51,18 +51,14 @@ namespace tbx {
  *
  * \tparam Data_t   The char-like queued item type. Usually \c char
  * \tparam N        The size of edeque
- * \tparam SemiAtomic   True for semi-atomic operation. In that case the \c ring_iterator is also atomic.
  * \tparam Fn       The type of Callable
- * \note
- *      SemiAtomic means it is safe to for one thread to  push only from front and another can pop.
  */
-template <typename Data_t, size_t N, bool SemiAtomic =false, typename Fn = std::function<void()>>
+template <typename Data_t, size_t N, typename Fn = std::function<void()>>
-class equeue : public edeque<Data_t, N, SemiAtomic, Fn> {
+class equeue : public edeque<Data_t, N, Fn> {
     public:
         // meta-identity types
-        using equeue_t              = equeue<Data_t, N, SemiAtomic, Fn>;
+        using equeue_t              = equeue<Data_t, N>;
-        using base_type             = edeque<Data_t, N, SemiAtomic, Fn>;
+        using base_type             = edeque<Data_t, N, Fn>;
-        using range_t               = typename base_type::range_t;
 
         // STL
         using value_type            = typename base_type::value_type;
@@ -81,7 +77,10 @@ class equeue : public edeque<Data_t, N, SemiAtomic, Fn> {
         //! Default constructor
         constexpr equeue () noexcept : base_type() { }
 
-        //! Forward constructor
+        //! fill contructor
+        constexpr equeue(const Data_t& value) noexcept : base_type(value) { }
+
+        //! Initializer list contructor
         template <typename ...It>
         constexpr equeue(It&& ...it) noexcept : base_type(std::forward<It>(it)...) { }
 
@@ -128,15 +127,14 @@ class equeue : public edeque<Data_t, N, SemiAtomic, Fn> {
  *
  *  \tparam Data_t  The char-like queued item type. Usually \c char
  *  \tparam N       The size of queue
- *  \tparam SemiAtomic  True for semi-atomic operation. In that case the \c ring_iterator is also atomic.
  *  \tparam Fn      The type of Callable
  *
  *  \param it       The item to write to
  *  \param q        The queue to read from
  *  \return         Reference to the returned item
  */
-template <typename Data_t, size_t N, bool SemiAtomic =false, typename Fn = std::function<void()>>
+template <typename Data_t, size_t N, typename Fn = std::function<void()>>
-Data_t& operator<< (Data_t& it, equeue<Data_t, N, SemiAtomic, Fn>& q) {
+Data_t& operator<< (Data_t& it, equeue<Data_t, N, Fn>& q) {
     it = q.pop();
     return it;
 }

include/cont/queue.h

@@ -50,17 +50,13 @@ namespace tbx {
  *
  * \tparam Data_t   The char-like queued item type. Usually \c char
  * \tparam N        The size of queue
- * \tparam SemiAtomic   True for semi-atomic operation. In that case the \c ring_iterator is also atomic.
- * \note
- *      SemiAtomic means it is safe to for one thread to  push only from front and another can pop.
  */
-template <typename Data_t, size_t N, bool SemiAtomic =false>
+template <typename Data_t, size_t N>
-class queue : public deque<Data_t, N, SemiAtomic> {
+class queue : public deque<Data_t, N> {
     public:
         // meta-identity types
-        using queue_t               = queue<Data_t, N, SemiAtomic>;
+        using queue_t               = queue<Data_t, N>;
-        using base_type             = deque<Data_t, N, SemiAtomic>;
+        using base_type             = deque<Data_t, N>;
-        using range_t               = typename base_type::range_t;
 
         // STL
         using value_type            = typename base_type::value_type;
@@ -127,14 +123,13 @@ class queue : public deque<Data_t, N, SemiAtomic> {
  *
  *  \tparam Data_t  The char-like queued item type. Usually \c char
  *  \tparam N       The size of queue
- *  \tparam SemiAtomic  True for semi-atomic operation. In that case the \c ring_iterator is also atomic.
  *
  *  \param it       The item to write to
  *  \param q        The queue to read from
  *  \return         Reference to the returned item
  */
-template <typename Data_t, size_t N, bool SemiAtomic =false>
+template <typename Data_t, size_t N>
-constexpr Data_t& operator<< (Data_t& it, queue<Data_t, N, SemiAtomic>& q) {
+constexpr Data_t& operator<< (Data_t& it, queue<Data_t, N>& q) {
     it = q.pop();
     return it;
 }

include/cont/range.h

@@ -1,64 +0,0 @@
-/*!
- * \file cont/range.h
- * \brief
- *      A plain definition of a range struct with agregate initialization
- *      and begin-end pairs.
- *
- * \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
- *
- * <dl class=\"section copyright\"><dt>License</dt><dd>
- * The MIT License (MIT)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * </dd></dl>
- */
-
-#ifndef TBX_CONT_RANGE_H_
-#define TBX_CONT_RANGE_H_
-
-#include <core/core.h>
-
-namespace tbx {
-
-/*!
- * \brief
- *  A plain definition of a range struct with begin-end pairs.
- *
- * \tparam Iter_t   The iterator type of the range
- */
-template <typename Iter_t>
-struct range {
-    Iter_t  b{}, e{};
-
-//    range () = default;
-//    range (const Iter_t& first, const Iter_t& last) noexcept :
-//        b(first), e(last) { }
-//    range (Iter_t first, Iter_t last) noexcept :
-//        b(first), e(last) { }
-
-    Iter_t begin()              { return b; }
-    const Iter_t begin() const  { return b; }
-    const Iter_t cbegin() const { return b; }
-    Iter_t end()                { return e; }
-    const Iter_t end() const    { return e; }
-    const Iter_t cend() const   { return e; }
-};
-
-}
-#endif /* TBX_CONT_RANGE_H_ */

include/cont/span.h

@@ -1,607 +0,0 @@
-/*
- * This is an implementation of C++20's std::span
- * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4820.pdf
- */
-
-//          Copyright Tristan Brindle 2018.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#ifndef TBX_CONT_SPAN_H_
-#define TBX_CONT_SPAN_H_
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-
-#ifndef TBX_SPAN_NO_EXCEPTIONS
-// Attempt to discover whether we're being compiled with exception support
-#if !(defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND))
-#define TBX_SPAN_NO_EXCEPTIONS
-#endif
-#endif
-
-#ifndef TBX_SPAN_NO_EXCEPTIONS
-#include <cstdio>
-#include <stdexcept>
-#endif
-
-// Various feature test macros
-
-#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#define TBX_SPAN_HAVE_CPP17
-#endif
-
-#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
-#define TBX_SPAN_HAVE_CPP14
-#endif
-
-namespace tbx {
-
-// Establish default contract checking behavior
-#if !defined(TBX_SPAN_THROW_ON_CONTRACT_VIOLATION) &&                          \
-    !defined(TBX_SPAN_TERMINATE_ON_CONTRACT_VIOLATION) &&                      \
-    !defined(TBX_SPAN_NO_CONTRACT_CHECKING)
-#if defined(NDEBUG) || !defined(TBX_SPAN_HAVE_CPP14)
-#define TBX_SPAN_NO_CONTRACT_CHECKING
-#else
-#define TBX_SPAN_TERMINATE_ON_CONTRACT_VIOLATION
-#endif
-#endif
-
-#if defined(TBX_SPAN_THROW_ON_CONTRACT_VIOLATION)
-struct contract_violation_error : std::logic_error {
-    explicit contract_violation_error(const char* msg) : std::logic_error(msg)
-    {}
-};
-
-inline void contract_violation(const char* msg)
-{
-    throw contract_violation_error(msg);
-}
-
-#elif defined(TBX_SPAN_TERMINATE_ON_CONTRACT_VIOLATION)
-[[noreturn]] inline void contract_violation(const char* /*unused*/)
-{
-    std::terminate();
-}
-#endif
-
-#if !defined(TBX_SPAN_NO_CONTRACT_CHECKING)
-#define TBX_SPAN_STRINGIFY(cond) #cond
-#define TBX_SPAN_EXPECT(cond)                                                  \
-    cond ? (void) 0 : contract_violation("Expected " TBX_SPAN_STRINGIFY(cond))
-#else
-#define TBX_SPAN_EXPECT(cond)
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_inline_variables)
-#define TBX_SPAN_INLINE_VAR inline
-#else
-#define TBX_SPAN_INLINE_VAR
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP14) ||                                            \
-    (defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
-#define TBX_SPAN_HAVE_CPP14_CONSTEXPR
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP14_CONSTEXPR)
-#define TBX_SPAN_CONSTEXPR14 constexpr
-#else
-#define TBX_SPAN_CONSTEXPR14
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP14_CONSTEXPR) &&                                  \
-    (!defined(_MSC_VER) || _MSC_VER > 1900)
-#define TBX_SPAN_CONSTEXPR_ASSIGN constexpr
-#else
-#define TBX_SPAN_CONSTEXPR_ASSIGN
-#endif
-
-#if defined(TBX_SPAN_NO_CONTRACT_CHECKING)
-#define TBX_SPAN_CONSTEXPR11 constexpr
-#else
-#define TBX_SPAN_CONSTEXPR11 TBX_SPAN_CONSTEXPR14
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_deduction_guides)
-#define TBX_SPAN_HAVE_DEDUCTION_GUIDES
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte)
-#define TBX_SPAN_HAVE_STD_BYTE
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_lib_array_constexpr)
-#define TBX_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC
-#endif
-
-#if defined(TBX_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC)
-#define TBX_SPAN_ARRAY_CONSTEXPR constexpr
-#else
-#define TBX_SPAN_ARRAY_CONSTEXPR
-#endif
-
-#ifdef TBX_SPAN_HAVE_STD_BYTE
-using byte = std::byte;
-#else
-using byte = unsigned char;
-#endif
-
-#if defined(TBX_SPAN_HAVE_CPP17)
-#define TBX_SPAN_NODISCARD [[nodiscard]]
-#else
-#define TBX_SPAN_NODISCARD
-#endif
-
-TBX_SPAN_INLINE_VAR constexpr std::size_t dynamic_extent = SIZE_MAX;
-
-template <typename ElementType, std::size_t Extent = dynamic_extent>
-class span;
-
-namespace detail {
-
-template <typename E, std::size_t S>
-struct span_storage {
-    constexpr span_storage() noexcept = default;
-
-    constexpr span_storage(E* p_ptr, std::size_t /*unused*/) noexcept
-       : ptr(p_ptr)
-    {}
-
-    E* ptr = nullptr;
-    static constexpr std::size_t size = S;
-};
-
-template <typename E>
-struct span_storage<E, dynamic_extent> {
-    constexpr span_storage() noexcept = default;
-
-    constexpr span_storage(E* p_ptr, std::size_t p_size) noexcept
-        : ptr(p_ptr), size(p_size)
-    {}
-
-    E* ptr = nullptr;
-    std::size_t size = 0;
-};
-
-// Reimplementation of C++17 std::size() and std::data()
-#if defined(TBX_SPAN_HAVE_CPP17) ||                \
-    defined(__cpp_lib_nonmember_container_access)
-using std::data;
-using std::size;
-#else
-template <class C>
-constexpr auto size(const C& c) -> decltype(c.size())
-{
-    return c.size();
-}
-
-template <class T, std::size_t N>
-constexpr std::size_t size(const T (&)[N]) noexcept
-{
-    return N;
-}
-
-template <class C>
-constexpr auto data(C& c) -> decltype(c.data())
-{
-    return c.data();
-}
-
-template <class C>
-constexpr auto data(const C& c) -> decltype(c.data())
-{
-    return c.data();
-}
-
-template <class T, std::size_t N>
-constexpr T* data(T (&array)[N]) noexcept
-{
-    return array;
-}
-
-template <class E>
-constexpr const E* data(std::initializer_list<E> il) noexcept
-{
-    return il.begin();
-}
-#endif // TBX_SPAN_HAVE_CPP17
-
-#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_lib_void_t)
-using std::void_t;
-#else
-template <typename...>
-using void_t = void;
-#endif
-
-template <typename T>
-using uncvref_t =
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-template <typename>
-struct is_span : std::false_type {};
-
-template <typename T, std::size_t S>
-struct is_span<span<T, S>> : std::true_type {};
-
-template <typename>
-struct is_std_array : std::false_type {};
-
-template <typename T, std::size_t N>
-struct is_std_array<std::array<T, N>> : std::true_type {};
-
-template <typename, typename = void>
-struct has_size_and_data : std::false_type {};
-
-template <typename T>
-struct has_size_and_data<T, void_t<decltype(detail::size(std::declval<T>())),
-                                   decltype(detail::data(std::declval<T>()))>>
-    : std::true_type {};
-
-template <typename C, typename U = uncvref_t<C>>
-struct is_container {
-    static constexpr bool value =
-        !is_span<U>::value && !is_std_array<U>::value &&
-        !std::is_array<U>::value && has_size_and_data<C>::value;
-};
-
-template <typename T>
-using remove_pointer_t = typename std::remove_pointer<T>::type;
-
-template <typename, typename, typename = void>
-struct is_container_element_type_compatible : std::false_type {};
-
-template <typename T, typename E>
-struct is_container_element_type_compatible<
-    T, E,
-    typename std::enable_if<
-        !std::is_same<typename std::remove_cv<decltype(
-                          detail::data(std::declval<T>()))>::type,
-                      void>::value>::type>
-    : std::is_convertible<
-          remove_pointer_t<decltype(detail::data(std::declval<T>()))> (*)[],
-          E (*)[]> {};
-
-template <typename, typename = size_t>
-struct is_complete : std::false_type {};
-
-template <typename T>
-struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
-
-} // namespace detail
-
-template <typename ElementType, std::size_t Extent>
-class span {
-    static_assert(std::is_object<ElementType>::value,
-                  "A span's ElementType must be an object type (not a "
-                  "reference type or void)");
-    static_assert(detail::is_complete<ElementType>::value,
-                  "A span's ElementType must be a complete type (not a forward "
-                  "declaration)");
-    static_assert(!std::is_abstract<ElementType>::value,
-                  "A span's ElementType cannot be an abstract class type");
-
-    using storage_type = detail::span_storage<ElementType, Extent>;
-
-public:
-    // constants and types
-    using element_type = ElementType;
-    using value_type = typename std::remove_cv<ElementType>::type;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
-    using pointer = element_type*;
-    using const_pointer = const element_type*;
-    using reference = element_type&;
-    using const_reference = const element_type&;
-    using iterator = pointer;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-
-    static constexpr size_type extent = Extent;
-
-    // [span.cons], span constructors, copy, assignment, and destructor
-    template <
-        std::size_t E = Extent,
-        typename std::enable_if<(E == dynamic_extent || E <= 0), int>::type = 0>
-    constexpr span() noexcept
-    {}
-
-    TBX_SPAN_CONSTEXPR11 span(pointer ptr, size_type count)
-        : storage_(ptr, count)
-    {
-        TBX_SPAN_EXPECT(extent == dynamic_extent || count == extent);
-    }
-
-    TBX_SPAN_CONSTEXPR11 span(pointer first_elem, pointer last_elem)
-        : storage_(first_elem, last_elem - first_elem)
-    {
-        TBX_SPAN_EXPECT(extent == dynamic_extent ||
-                        last_elem - first_elem ==
-                            static_cast<std::ptrdiff_t>(extent));
-    }
-
-    template <std::size_t N, std::size_t E = Extent,
-              typename std::enable_if<
-                  (E == dynamic_extent || N == E) &&
-                      detail::is_container_element_type_compatible<
-                          element_type (&)[N], ElementType>::value,
-                  int>::type = 0>
-    constexpr span(element_type (&arr)[N]) noexcept : storage_(arr, N)
-    {}
-
-    template <std::size_t N, std::size_t E = Extent,
-              typename std::enable_if<
-                  (E == dynamic_extent || N == E) &&
-                      detail::is_container_element_type_compatible<
-                          std::array<value_type, N>&, ElementType>::value,
-                  int>::type = 0>
-    TBX_SPAN_ARRAY_CONSTEXPR span(std::array<value_type, N>& arr) noexcept
-        : storage_(arr.data(), N)
-    {}
-
-    template <std::size_t N, std::size_t E = Extent,
-              typename std::enable_if<
-                  (E == dynamic_extent || N == E) &&
-                      detail::is_container_element_type_compatible<
-                          const std::array<value_type, N>&, ElementType>::value,
-                  int>::type = 0>
-    TBX_SPAN_ARRAY_CONSTEXPR span(const std::array<value_type, N>& arr) noexcept
-        : storage_(arr.data(), N)
-    {}
-
-    template <
-        typename Container, std::size_t E = Extent,
-        typename std::enable_if<
-            E == dynamic_extent && detail::is_container<Container>::value &&
-                detail::is_container_element_type_compatible<
-                    Container&, ElementType>::value,
-            int>::type = 0>
-    constexpr span(Container& cont)
-//        : storage_(detail::data(cont), detail::size(cont))
-        : storage_(cont.data(), cont.size())
-    {}
-
-    template <
-        typename Container, std::size_t E = Extent,
-        typename std::enable_if<
-            E == dynamic_extent && detail::is_container<Container>::value &&
-                detail::is_container_element_type_compatible<
-                    const Container&, ElementType>::value,
-            int>::type = 0>
-    constexpr span(const Container& cont)
-        : storage_(detail::data(cont), detail::size(cont))
-    {}
-
-    constexpr span(const span& other) noexcept = default;
-
-    template <typename OtherElementType, std::size_t OtherExtent,
-              typename std::enable_if<
-                  (Extent == OtherExtent || Extent == dynamic_extent) &&
-                      std::is_convertible<OtherElementType (*)[],
-                                          ElementType (*)[]>::value,
-                  int>::type = 0>
-    constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
-        : storage_(other.data(), other.size())
-    {}
-
-    ~span() noexcept = default;
-
-    TBX_SPAN_CONSTEXPR_ASSIGN span&
-    operator=(const span& other) noexcept = default;
-
-    // [span.sub], span subviews
-    template <std::size_t Count>
-    TBX_SPAN_CONSTEXPR11 span<element_type, Count> first() const
-    {
-        TBX_SPAN_EXPECT(Count <= size());
-        return {data(), Count};
-    }
-
-    template <std::size_t Count>
-    TBX_SPAN_CONSTEXPR11 span<element_type, Count> last() const
-    {
-        TBX_SPAN_EXPECT(Count <= size());
-        return {data() + (size() - Count), Count};
-    }
-
-    template <std::size_t Offset, std::size_t Count = dynamic_extent>
-    using subspan_return_t =
-        span<ElementType, Count != dynamic_extent
-                              ? Count
-                              : (Extent != dynamic_extent ? Extent - Offset
-                                                          : dynamic_extent)>;
-
-    template <std::size_t Offset, std::size_t Count = dynamic_extent>
-    TBX_SPAN_CONSTEXPR11 subspan_return_t<Offset, Count> subspan() const
-    {
-        TBX_SPAN_EXPECT(Offset <= size() &&
-                        (Count == dynamic_extent || Offset + Count <= size()));
-        return {data() + Offset,
-                Count != dynamic_extent ? Count : size() - Offset};
-    }
-
-    TBX_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
-    first(size_type count) const
-    {
-        TBX_SPAN_EXPECT(count <= size());
-        return {data(), count};
-    }
-
-    TBX_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
-    last(size_type count) const
-    {
-        TBX_SPAN_EXPECT(count <= size());
-        return {data() + (size() - count), count};
-    }
-
-    TBX_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
-    subspan(size_type offset, size_type count = dynamic_extent) const
-    {
-        TBX_SPAN_EXPECT(offset <= size() &&
-                        (count == dynamic_extent || offset + count <= size()));
-        return {data() + offset,
-                count == dynamic_extent ? size() - offset : count};
-    }
-
-    // [span.obs], span observers
-    constexpr size_type size() const noexcept { return storage_.size; }
-
-    constexpr size_type size_bytes() const noexcept
-    {
-        return size() * sizeof(element_type);
-    }
-
-    TBX_SPAN_NODISCARD constexpr bool empty() const noexcept
-    {
-        return size() == 0;
-    }
-
-    // [span.elem], span element access
-    TBX_SPAN_CONSTEXPR11 reference operator[](size_type idx) const
-    {
-        TBX_SPAN_EXPECT(idx < size());
-        return *(data() + idx);
-    }
-
-    TBX_SPAN_CONSTEXPR11 reference front() const
-    {
-        TBX_SPAN_EXPECT(!empty());
-        return *data();
-    }
-
-    TBX_SPAN_CONSTEXPR11 reference back() const
-    {
-        TBX_SPAN_EXPECT(!empty());
-        return *(data() + (size() - 1));
-    }
-
-    constexpr pointer data() const noexcept { return storage_.ptr; }
-
-    // [span.iterators], span iterator support
-    constexpr iterator begin() const noexcept { return data(); }
-
-    constexpr iterator end() const noexcept { return data() + size(); }
-
-    TBX_SPAN_ARRAY_CONSTEXPR reverse_iterator rbegin() const noexcept
-    {
-        return reverse_iterator(end());
-    }
-
-    TBX_SPAN_ARRAY_CONSTEXPR reverse_iterator rend() const noexcept
-    {
-        return reverse_iterator(begin());
-    }
-
-private:
-    storage_type storage_{};
-};
-
-#ifdef TBX_SPAN_HAVE_DEDUCTION_GUIDES
-
-/* Deduction Guides */
-template <class T, size_t N>
-span(T (&)[N])->span<T, N>;
-
-template <class T, size_t N>
-span(std::array<T, N>&)->span<T, N>;
-
-template <class T, size_t N>
-span(const std::array<T, N>&)->span<const T, N>;
-
-template <class Container>
-span(Container&)->span<typename Container::value_type>;
-
-template <class Container>
-span(const Container&)->span<const typename Container::value_type>;
-
-#endif // TCB_HAVE_DEDUCTION_GUIDES
-
-template <typename ElementType, std::size_t Extent>
-constexpr span<ElementType, Extent>
-make_span(span<ElementType, Extent> s) noexcept
-{
-    return s;
-}
-
-template <typename T, std::size_t N>
-constexpr span<T, N> make_span(T (&arr)[N]) noexcept
-{
-    return {arr};
-}
-
-template <typename T, std::size_t N>
-TBX_SPAN_ARRAY_CONSTEXPR span<T, N> make_span(std::array<T, N>& arr) noexcept
-{
-    return {arr};
-}
-
-template <typename T, std::size_t N>
-TBX_SPAN_ARRAY_CONSTEXPR span<const T, N>
-make_span(const std::array<T, N>& arr) noexcept
-{
-    return {arr};
-}
-
-template <typename Container>
-constexpr span<typename Container::value_type> make_span(Container& cont)
-{
-    return {cont};
-}
-
-template <typename Container>
-constexpr span<const typename Container::value_type>
-make_span(const Container& cont)
-{
-    return {cont};
-}
-
-template <typename ElementType, std::size_t Extent>
-span<const byte, ((Extent == dynamic_extent) ? dynamic_extent
-                                             : sizeof(ElementType) * Extent)>
-as_bytes(span<ElementType, Extent> s) noexcept
-{
-    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
-}
-
-template <
-    class ElementType, size_t Extent,
-    typename std::enable_if<!std::is_const<ElementType>::value, int>::type = 0>
-span<byte, ((Extent == dynamic_extent) ? dynamic_extent
-                                       : sizeof(ElementType) * Extent)>
-as_writable_bytes(span<ElementType, Extent> s) noexcept
-{
-    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
-}
-
-template <std::size_t N, typename E, std::size_t S>
-constexpr auto get(span<E, S> s) -> decltype(s[N])
-{
-    return s[N];
-}
-
-} // namespace tbx
-
-namespace std {
-
-template <typename ElementType, size_t Extent>
-class tuple_size<tbx::span<ElementType, Extent>>
-    : public integral_constant<size_t, Extent> {};
-
-template <typename ElementType>
-class tuple_size<tbx::span<
-    ElementType, tbx::dynamic_extent>>; // not defined
-
-template <size_t I, typename ElementType, size_t Extent>
-class tuple_element<I, tbx::span<ElementType, Extent>> {
-public:
-    static_assert(Extent != tbx::dynamic_extent &&
-                      I < Extent,
-                  "");
-    using type = ElementType;
-};
-
-} // end namespace std
-
-#endif // TBX_CONT_SPAN_H_

include/core/ring_iterator.h

@@ -35,11 +35,10 @@
 
 #include <iterator>
 #include <type_traits>
-#include <atomic>
 
 namespace tbx {
 
-template<typename Iter_t, size_t N, bool Atomic=false>
+template<typename Iter_t, size_t N>
 class ring_iterator {
     //! \name STL iterator traits "forwarding"
     //! @{
@@ -165,9 +164,6 @@ class ring_iterator {
             return N;
         }
 
-        constexpr operator Iter_t() noexcept { return iter_; }
-        constexpr operator const Iter_t() const noexcept { return iter_; }
-
     protected:
         Iter_t base_;
         Iter_t iter_;
@@ -230,214 +226,6 @@ noexcept {
 }
 
 
-
-
-
-
-template<typename Iter_t, size_t N>
-class ring_iterator<Iter_t, N, true> {
-    //! \name STL iterator traits "forwarding"
-    //! @{
-    protected:
-        using traits_type = std::iterator_traits<Iter_t>;
-
-    public:
-        using iterator_type     = Iter_t;
-        using iterator_category = typename traits_type::iterator_category;
-        using value_type        = typename traits_type::value_type;
-        using difference_type   = typename traits_type::difference_type;
-        using reference         = typename traits_type::reference;
-        using pointer           = typename traits_type::pointer;
-    //! @}
-
-
-    //! \name Constructor / Destructor
-    //! @{
-    public:
-        constexpr ring_iterator(const Iter_t base =nullptr) noexcept :
-            base_(base), iter_(base) { }
-
-        constexpr ring_iterator(const Iter_t base, size_t elem) noexcept :
-            base_(base), iter_(base + elem) { }
-
-        constexpr ring_iterator(const ring_iterator& it) noexcept :
-            base_(it.base_) {
-            iter_ =  it.iter_.load(std::memory_order_acquire);
-        }
-
-        constexpr ring_iterator& operator= (const ring_iterator& it) noexcept {
-            base_ = it.base_;
-            iter_ = it.iter_.load(std::memory_order_acquire);
-            return *this;
-        }
-    //! @}
-
-    //! \name Forward iterator requirements
-    //! @{
-    public:
-        constexpr reference operator*() const noexcept {
-            return *iter_.load(std::memory_order_acquire);
-        }
-
-        constexpr pointer operator->() const noexcept {
-            return iter_.load(std::memory_order_acquire);
-        }
-
-        constexpr ring_iterator& operator++() noexcept {
-            Iter_t itnew, it = iter_.load(std::memory_order_acquire);
-            do {
-                itnew = it;
-                if (static_cast<size_t>(++itnew - base_) >= N)
-                    itnew = base_;
-            } while (!iter_.compare_exchange_weak(it, itnew, std::memory_order_acq_rel));
-            return *this;
-        }
-        constexpr ring_iterator operator++(int) noexcept {
-            ring_iterator it = *this;
-            this->operator ++();
-            return it;
-        }
-    //! @}
-
-    //! \name Bidirectional iterator requirements
-    //! @{
-    public:
-        constexpr ring_iterator& operator--() noexcept {
-            Iter_t itnew, it = iter_.load(std::memory_order_acquire);
-            do {
-                itnew = it;
-                if (--itnew < base_)
-                    itnew = base_ + N -1;
-            } while (!iter_.compare_exchange_weak(it, itnew, std::memory_order_acq_rel));
-            return *this;
-        }
-        constexpr ring_iterator operator--(int) noexcept {
-            ring_iterator it = *this;
-            this->operator --();
-            return it;
-        }
-    //! @}
-
-    //! \name Random access iterator requirements
-    //! @{
-        constexpr reference operator[](difference_type n) const noexcept {
-            difference_type k = iter_.load(std::memory_order_acquire) - base_; // ptrdiff from base_
-            return (static_cast<size_t>(k + n) < N) ?
-                base_[k + n] :                          // on range
-                base_[k + n - N];                       // out of range, loop
-        }
-        constexpr ring_iterator& operator+=(difference_type n) noexcept {
-            Iter_t itnew, it = iter_.load(std::memory_order_acquire);
-            do {
-                itnew = it;
-                difference_type k = it - base_;         // ptrdiff from base_
-                itnew += (static_cast<size_t>(k + n) < N) ?
-                    n :                                 // on range
-                    n - N;                              // out of range, loop
-            } while (!iter_.compare_exchange_weak(it, itnew, std::memory_order_acquire));
-            return *this;
-        }
-        constexpr ring_iterator operator+(difference_type n) const noexcept {
-            difference_type k = iter_.load(std::memory_order_acquire) - base_; // ptrdiff from base_
-            return (static_cast<size_t>(k + n) < N) ?
-                ring_iterator(base_, k + n) :           // on range
-                ring_iterator(base_, k + n - N);        // out of range, loop
-        }
-        constexpr ring_iterator& operator-=(difference_type n) noexcept {
-            Iter_t itnew, it = iter_.load(std::memory_order_acquire);
-            do {
-                itnew = it;
-                difference_type k = it - base_;         // ptrdiff from base_
-                itnew -= ((k - n) < 0)?
-                    n - N:                              // out of range, loop
-                    n;                                  // on range
-            } while (!iter_.compare_exchange_weak(it, itnew, std::memory_order_acquire));
-            return *this;
-        }
-        constexpr ring_iterator operator-(difference_type n) const noexcept {
-            difference_type k = iter_.load(std::memory_order_acquire) - base_; // ptrdiff from base_
-            return ((k - n) < 0) ?
-                ring_iterator(base_, k - n + N) :       // out of range, loop
-                ring_iterator(base_, k - n);            // on range
-        }
-    //! @}
-
-    //! \name Data members and access
-    //! @{
-        constexpr const Iter_t& base() const noexcept {
-            return base_;
-        }
-        constexpr const Iter_t iter() const noexcept {
-            return iter_.load(std::memory_order_acquire);
-        }
-        constexpr size_t size() noexcept {
-            return N;
-        }
-
-        constexpr operator Iter_t() noexcept { return iter_.load(std::memory_order_acquire); }
-        constexpr operator const Iter_t() const noexcept { return iter_.load(std::memory_order_acquire); }
-
-    protected:
-        Iter_t base_;
-        std::atomic<Iter_t> iter_;
-    //! @}
-};
-
-// Forward iterator requirements
-template<typename Iter_L, typename Iter_R, size_t N>
-inline bool operator==(const ring_iterator<Iter_L, N, true>& lhs, const ring_iterator<Iter_R, N, true>& rhs)
-noexcept {
-    return lhs.iter() == rhs.iter();
-}
-
-template<typename Iter_L, typename Iter_R, size_t N>
-inline bool operator!=(const ring_iterator<Iter_L, N, true>& lhs, const ring_iterator<Iter_R, N, true>& rhs)
-noexcept {
-    return lhs.iter() != rhs.iter();
-}
-
-// Random access iterator requirements
-template<typename Iter_L, typename Iter_R, size_t N>
-inline bool operator<(const ring_iterator<Iter_L, N, true>& lhs, const ring_iterator<Iter_R, N, true>& rhs)
-noexcept {
-    return lhs.iter() < rhs.iter();
-}
-
-template<typename Iter_L, typename Iter_R, size_t N>
-inline bool operator<=(const ring_iterator<Iter_L, N, true>& lhs, const ring_iterator<Iter_R, N, true>& rhs)
-noexcept {
-    return lhs.iter() <= rhs.iter();
-}
-
-template<typename Iter_L, typename Iter_R, size_t N>
-inline bool operator>(const ring_iterator<Iter_L, N, true>& lhs, const ring_iterator<Iter_R, N, true>& rhs)
-noexcept {
-    return lhs.iter() > rhs.iter();
-}
-
-template<typename Iter_L, typename Iter_R, size_t N>
-inline bool operator>=(const ring_iterator<Iter_L, N, true>& lhs, const ring_iterator<Iter_R, N, true>& rhs)
-noexcept {
-    return lhs.iter() >= rhs.iter();
-}
-
-template<typename Iter_L, typename Iter_R, size_t N>
-inline auto operator-(const ring_iterator<Iter_L, N, true>& lhs, const ring_iterator<Iter_R, N, true>& rhs)
-noexcept
--> decltype(lhs.iter() - rhs.iter()) {
-    auto diff = lhs.iter() - rhs.iter();
-    return diff < 0 ?
-            diff + N :  // loop
-            diff;       // no loop
-}
-
-template<typename Iter, size_t N>
-inline ring_iterator<Iter, N, true> operator+(std::ptrdiff_t lhs, const ring_iterator<Iter, N, true>& rhs)
-noexcept {
-    ring_iterator<Iter, N, true> it(rhs.iter());
-    return it += lhs;
-}
-
 } //namespace tbx;
 
 #endif /* TBX_CORE_RING_ITERATOR_H_ */

include/drv/BG95_base.h

@@ -1,321 +0,0 @@
-/*!
- * \file cont/BG95_base.h
- * \brief
- *      BG95 driver functionality as CRTP base class
- *
- * \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
- *
- * <dl class=\"section copyright\"><dt>License</dt><dd>
- * The MIT License (MIT)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * </dd></dl>
- */
-
-#ifndef TBX_DRV_BG95_base_H_
-#define TBX_DRV_BG95_base_H_
-
-
-#include <core/core.h>
-#include <core/crtp.h>
-#include <cont/equeue.h>
-#include <cont/range.h>
-#include <utils/sequencer.h>
-
-#include <cstring>
-#include <cstdio>
-#include <algorithm>
-
-//#include <iostream>
-#include <atomic>
-
-namespace tbx {
-
-/*!
- * \class BG95_base
- * \brief
- *
- * \example implementation example
- * \code
- *    using Queue = equeue<char, 512, true>;
- *
- *    class BG95 :
- *      public BG95_base<BG95, Queue, 256> {
- *         using base_type = BG95_base<BG95, Queue, 256>;
- *         using range_t = typename Queue::range_t;
- *     private: // data
- *         Queue rx_q{};
- *         std::atomic<size_t> lines{};
- *     public:
- *         BG95() :
- *             rx_q(equeue<char, 512, true>::data_match::MATCH_PUSH, base_type::delimiter, [&](){
- *                 lines.fetch_add(1, std::memory_order_acq_rel);
- *             }), lines(0) {
- *             // init code here ...
- *         }
- *         // ISR handler
- *         void usart_isr_ (void) {
- *             rx_q << // char from ISR
- *         }
- *         // CRTP requirements
- *         size_t get(char* data, bool wait =false) {
- *             do {
- *                 if (lines.load(std::memory_order_acquire)) {
- *                     size_t n =0;
- *                     do{
- *                         *data << rx_q;
- *                         ++n;
- *                     } while (*data++ != base_type::delimiter);
- *                     lines.fetch_sub(1, std::memory_order_acq_rel);
- *                     return n;
- *                 }
- *             } while (wait);
- *             return 0;
- *         }
- *         size_t put (const char* data, size_t n) {
- *             // send data to UART
- *             return n;
- *         }
- *         const range_t contents() const { return range_t {rx_q.begin(), rx_q.end()}; }
- *         clock_t clock() { }  // return systems CPU time
- *    };
- * \endcode
- *
- * \tparam Impl_t
- * \tparam Cont_t
- * \tparam N
- * \tparam Delimiter
- */
-template<typename Impl_t, typename Cont_t, size_t N, char Delimiter ='\n'>
-class BG95_base
-        : public sequencer<BG95_base<Impl_t, Cont_t, N, Delimiter>, Cont_t, char, N>{
-        _CRTP_IMPL(Impl_t);
-
-        static_assert(
-            std::is_same_v<typename Cont_t::value_type, char>,
-            "Cont_t must be a container of type char"
-        );
-
-        // local type dispatch
-        using base_type     = sequencer<BG95_base, Cont_t, char, N>;
-        using str_view_t    = typename base_type::str_view_t;
-        using range_t       = typename Cont_t::range_t;
-        using status_t      = typename base_type::status_t;
-
-    //! \name Public types
-    //! @{
-    public:
-        using action_t          = typename base_type::action_t;
-        using control_t         = typename base_type::control_t;
-        using match_t           = typename base_type::match_t;
-        using handler_t         = typename base_type::handler_ft;
-        template<size_t Nr, size_t Nh =2>
-        using script_t          = typename base_type::template script_t<Nr, Nh>;
-
-        //! Publish delimiter
-        constexpr static char delimiter = Delimiter;
-
-        //! Required typenames for async operation
-        //! @{
-        template <size_t Nm>
-        using async_handlers    = std::array<typename base_type::handle_t, Nm>;
-        //! @}
-    //! @}
-
-    //! \name Constructor / Destructor
-    //!@{
-    protected:
-        //!< \brief A default constructor from derived only
-        BG95_base() = default;
-        ~BG95_base () = default;                            //!< \brief Allow destructor from derived only
-        BG95_base(const BG95_base&) = delete;               //!< No copies
-        BG95_base& operator= (const BG95_base&) = delete;   //!< No copy assignments
-    //!@}
-
-    //! \name Sequencer interface requirements
-    //!     Forwarded to implementer the calls and cascade the the incoming channel
-    //!     sequencer::get --resolved--> this->receive() --calls--> impl().get()
-    //! @{
-    friend base_type;
-
-    private:
-        size_t get_ (char* data) {
-            return impl().get (data);
-        }
-        size_t get (char* data) {
-            return receive (data);
-        }
-        size_t put (const char* data, size_t n) {
-            return impl().put (data, n);
-        }
-        const range_t contents () const {
-            return impl().contents();
-        }
-        clock_t clock () {
-            return impl().clock();
-        }
-    //! @}
-
-    //! \name Private functionality
-    //! @{
-    private:
-
-    //! @}
-
-    //! \name public functionality
-    //! @{
-    public:
-
-        /*!
-         * \brief
-         *   Transmit data to modem
-         * \param data   Pointer to data to send
-         * \param n      The size of data buffer
-         * \return       The number of transmitted chars
-         */
-        size_t transmit (const char* data, size_t n) {
-            return put (data, n);
-        }
-
-        size_t transmit (const char* data) {
-            return put (data, strlen(data));
-        }
-
-        /*!
-         * \brief
-         *   Try to receive data from modem. If there are data copy them to \c data pointer and retur
-         *   the size. Otherwise return zero. In the case \c wait is true block until there are data to get.
-         *
-         * \param data   Pointer to data buffer to write
-         * \param wait   Flag to select blocking / non-blocking functionality
-         * \return       The number of copied data.
-         */
-        size_t receive (char* data, bool wait =false) {
-            do {
-                if (streams_.load(std::memory_order_acquire)) {
-                    size_t n =0;
-                    do {
-                        *data << rx_q;
-                        ++n;
-                    } while (*data++ != delimiter);
-                    *data =0;
-                    streams_.fetch_sub(1, std::memory_order_acq_rel);
-                    return n;
-                }
-            } while (wait);  // on wait flag we block until available stream
-            return 0;
-        }
-
-        /*!
-         * \brief
-         *   inetd daemon functionality provided as member function of the driver. This should be running
-         *   in the background either as consecutive calls from an periodic ISR with \c loop = false, or
-         *   as a thread in an RTOS environment with \c loop = true.
-         *
-         * \tparam Nm            The number of handler array entries
-         *
-         * \param async_handles  Reference to asynchronous handler array
-         * \param loop           Flag to indicate blocking mode. If true blocking.
-         */
-        template <size_t Nm =0>
-        void inetd (bool loop =true, const async_handlers<Nm>* async_handles =nullptr) {
-            std::array<char, N> buffer;
-            size_t resp_size;
-            do {
-                if ((resp_size = get_(buffer.data())) != 0) {
-                    // on data check for async handlers
-                    bool match = false;
-                    if (async_handles != nullptr) {
-                        for (auto& h : *async_handles)
-                            match |= base_type::check_handle (h, buffer.data());
-                    }
-                    // if no match forward data to receive channel.
-                    if (!match) {
-                        char* it = buffer.data();
-                        do {
-                            rx_q << *it;
-                        } while (*it++ != delimiter);
-                        streams_.fetch_add(1, std::memory_order_acq_rel);
-                    }
-                }
-            } while (loop);
-        }
-
-        template <size_t Steps, size_t Nhandles>
-        bool configure (const script_t<Steps, Nhandles>& script) {
-            return base_type::run (script);
-        }
-
-//        // General API
-//        static constexpr typename base_type::handle_t error_handle_ = {
-//                "ERROR",  match_t::CONTAINS,    nullptr, action_t::EXIT_ERROR, 0
-//        };
-
-        template<typename T>
-        void parse (char* str, size_t n, char next, T value) {
-            auto next_ptr = std::find(str, &str[n], next);
-            char save = *next_ptr;
-            *next_ptr =0;
-
-            if constexpr (std::is_same_v<std::remove_cv<T>, int>) {
-                sscanf(str, "%d", &value);
-            } else if (std::is_same_v<std::remove_cv<T>, float>) {
-                sscanf(str, "%f", &value);
-            } else if (std::is_same_v<std::remove_cv<T>, double>) {
-                sscanf(str, "%lf", &value);
-            } else if (std::is_same_v<std::remove_cv<T>, char>) {
-                sscanf(str, "%c", &value);
-            } else if (std::is_same_v<std::remove_cv<T>, char*>) {
-                strcpy(value, str);
-            }
-            *next_ptr = save;
-        }
-
-        //      cmd: "AT+CREG?"
-        // expected: "\r\n+CREG: 0,%\r\nOK\r\n"
-        template <typename T, char Marker = '%'>
-        bool command (const str_view_t cmd, const str_view_t expected, T& t) {
-            char buffer[N];
-
-            transmit(cmd);
-
-            for (size_t pos =0 ; pos < expected.size(); ) {
-                str_view_t ex = expected.substr(pos);       // get starting point of expected
-                size_t sz = receive(buffer, 1);             // load the answer
-                for (size_t i ; i<sz ; ) {
-                    if (ex[i] == Marker)
-                        parse(buffer[i], sz, ex[i+1], t);   // parse and convert
-                    else if (ex[i] == buffer[i])
-                        ++i;                                // consume current character
-                    else
-                        return false;                       // Fail to parse
-                }
-            }
-            return true;
-        }
-    //! @}
-
-    private:
-        equeue<char, N>     rx_q{};
-        std::atomic<size_t> streams_{};
-};
-
-} // namespace tbx;
-
-#endif /* TBX_DRV_BG95_base_H_ */

include/utils/sequencer.h

@@ -34,19 +34,14 @@
 
 #include <core/core.h>
 #include <core/crtp.h>
-#include <cont/range.h>
-
 #include <ctime>
 #include <array>
 #include <string_view>
-#include <limits>
-#include <type_traits>
-#include <functional>
 
 namespace tbx {
 
 /*!
- * \class sequencer
+ * \class sequencer_t
  * \brief
  *      A CRTP base class to provide the sequencer functionality.
  *
@@ -64,26 +59,14 @@ namespace tbx {
  *     match the units in \c record_t::timeout field.
  *
  * \tparam Impl_t   The type of derived class
- * \tparam Cont_t   The container type holding the data of type \c Data_t for the derived class.
  * \tparam Data_t   The char-like stream item type. Usually \c char
  * \tparam N        The size of the sequence buffer to temporary store each line from get().
- *
- * \note
- *      We need access to derived class container to sneaky get a range of the data beside
- *      the normal data flow, in order to implement the \see control_t::DETECT operation.
  */
-template <typename Impl_t, typename Cont_t, typename Data_t, size_t N>
+template <typename Impl_t, typename Data_t, size_t N>
-class sequencer {
+class sequencer_t {
     _CRTP_IMPL(Impl_t);
 
-    static_assert(
-        std::is_same_v<typename Cont_t::value_type, Data_t>,
-        "Cont_t must be a container of type Data_t"
-    );
-
-    // local type dispatch
     using str_view_t = std::basic_string_view<Data_t>;
-    using range_t       = typename Cont_t::range_t;
 
     //! \name Public types
     //! @{
@@ -105,18 +88,8 @@ class sequencer {
         //! \brief The control type of the script entry.
         enum class control_t {
             NOP,    //!< No command, dont send or expect anything, used for delays
-            SEND,   //!< Send data to implementation through put()
+            SEND,   //!< Send data to implementation
-            EXPECT, //!< Expects data from implementation via get()
+            EXPECT  //!< Expects data from implementation
-            DETECT  //!< Detects data into rx buffer without receiving them via contents()
-
-            //! \note
-            //! The \c DETECT extra incoming channel serve the purpose of sneak into receive
-            //! buffer and check for data without getting them. This is useful when the receive driver
-            //! is buffered with a delimiter and we seek for data that don't follow the delimiter pattern.
-            //!
-            //! For example:
-            //! A modem sends reponses with '\n' termination but for some "special" command it opens a cursor
-            //! lets say ">$ " without '\n' at the end.
         };
 
         //! \enum match_t
@@ -129,18 +102,18 @@ class sequencer {
          *  Match handler function pointer type.
          *  Expects a pointer to buffer and a size and returns status
          */
-        using handler_ft = void (*) (const Data_t*, size_t);
+        using handler_ft = status_t (*) (const Data_t*, size_t);
 
         /*!
-         * \struct handle_t
+         * \struct block_t
          * \brief
-         *      The script record handle block.
+         *      The script line block.
          *
-         * Each script record contains some blocks for matching functionality. Each block
+         * Each script "line" contains up to 2 blocks for matching functionality. Each block
          * has a token and a matching type. If the response matches the token, the sequencer calls
          * the handler and perform the action.
          */
-        struct handle_t {
+        struct block_t {
             std::basic_string_view<Data_t>
                                 token;          //!< The token for the match
             match_t             match_type;     //!< The matching type functionality
@@ -156,19 +129,6 @@ class sequencer {
          *
          * Each line consist from a control, 2 blocks and a timeout. The control says if we send or receive data.
          * The blocks contain the data and the matching information. And the timeout guards the entire line.
-         */
-        template<size_t Nhandles =2>
-        struct record_t {
-            control_t   control;    //!< The type of the entry
-            std::array<handle_t, Nhandles>
-                        block;      //!< The matching blocks
-            clock_t     timeout;    //!< Timeout in CPU time
-        };
-
-        /*!
-         * \struct script_t
-         * \brief
-         *      Describes the sequencer's script.
          *
          * The user can create arrays as the example bellow to act as a script.
          * \code
@@ -184,8 +144,11 @@ class sequencer {
          *  }};
          * \endcode
          */
-        template <size_t Nrecords, size_t Nhandles =2>
+        struct record_t {
-        using script_t = std::array<record_t<Nhandles>, Nrecords>;
+            control_t               control;    //!< The type of the entry
+            std::array<block_t, 2>  block;      //!< The matching block
+            clock_t                 timeout;    //!< Timeout in CPU time
+        };
     //! @}
 
 
@@ -193,10 +156,10 @@ class sequencer {
     //! \name Constructor / Destructor
     //!@{
     protected:
-       ~sequencer () = default;                               //!< \brief Allow destructor from derived only
+       ~sequencer_t () = default;                               //!< \brief Allow destructor from derived only
-       sequencer () = default;                                //!< \brief A default constructor from derived only
+       sequencer_t () = default;                                //!< \brief A default constructor from derived only
-       sequencer(const sequencer&) = delete;                //!< No copies
+       sequencer_t(const sequencer_t&) = delete;                //!< No copies
-       sequencer& operator= (const sequencer&) = delete;    //!< No copy assignments
+       sequencer_t& operator= (const sequencer_t&) = delete;    //!< No copy assignments
     //!@}
 
     //! \name Sequencer interface requirements for implementer
@@ -204,7 +167,6 @@ class sequencer {
     private:
        size_t get_ (Data_t* data) { return impl().get (data); }
        size_t put_ (const Data_t* data, size_t n) { return impl().put (data, n); }
-       const range_t contents_ () const { return impl().contents(); }
        clock_t clock_ () { return impl().clock(); }
     //! @}
 
@@ -218,7 +180,7 @@ class sequencer {
         * \param prefix     What we search
         * \return           True on success, false otherwise
         */
-       static bool starts_with_ (const str_view_t stream, const str_view_t prefix) {
+       bool starts_with_ (const str_view_t stream, const str_view_t prefix) {
            return (stream.rfind(prefix, 0) != str_view_t::npos);
        }
 
@@ -229,9 +191,7 @@ class sequencer {
         * \param postfix    What we search
         * \return           True on success, false otherwise
         */
-       static bool ends_with_ (const str_view_t stream, const str_view_t postfix) {
+       bool ends_with_ (const str_view_t stream, const str_view_t postfix) {
-           if (stream.size() < postfix.size())
-               return false;
            return (
                stream.compare(
                    stream.size() - postfix.size(),
@@ -247,7 +207,7 @@ class sequencer {
         * \param needle     What we search
         * \return           True on success, false otherwise
         */
-       static bool contains_ (const str_view_t haystack, const str_view_t needle) {
+       bool contains_ (const str_view_t haystack, const str_view_t needle) {
            return (haystack.find(needle) != str_view_t::npos);
        }
        /*!
@@ -261,7 +221,7 @@ class sequencer {
         * \param go_idx         The new value of the step in the case of GOTO type
         * \return               The new sequencer's step value
         */
-       static size_t step_ (size_t current_idx, action_t action, size_t go_idx =0) {
+       size_t step_ (size_t current_idx, action_t action, size_t go_idx =0) {
            switch (action) {
                default:
                case action_t::NO:   return current_idx;
@@ -272,27 +232,6 @@ class sequencer {
                                     return 0;
            }
        }
-       static status_t action_ (size_t& step, const handle_t& block, const str_view_t buffer = str_view_t{}) {
-           if (block.handler != nullptr)
-               block.handler(buffer.begin(), buffer.size());
-           switch (block.action) {
-               case action_t::EXIT_OK:
-                   step = std::numeric_limits<size_t>::max();
-                   return status_t::OK;
-               case action_t::EXIT_ERROR:
-                   step = std::numeric_limits<size_t>::max();
-                   return status_t::ERROR;
-               default:
-                   step = step_(step, block.action, block.idx);
-                   return status_t::OK;
-           }
-
-       }
-
-    //! @}
-
-
-    public:
        /*!
         * \brief
         *   Checks if the \c needle matches the \c haystack.
@@ -302,7 +241,7 @@ class sequencer {
         * \param needle     The stream we search
         * \return           True on match
         */
-       static bool match (const str_view_t haystack, const str_view_t needle, match_t type) {
+       bool match_(match_t type, const str_view_t haystack, const str_view_t needle) {
            switch (type) {
                default:
                case match_t::NO:            return true;
@@ -314,25 +253,10 @@ class sequencer {
                case match_t::nCONTAINS:     return !contains_(haystack, needle);
            }
        }
+    //! @}
 
-       /*!
-        * \brief
-        *       A static functionality to provide access to sequencer's inner matching mechanism.
-        *       Checks the \c buffer against \c handle and calls its action if needed.
-        *
-        * \param handle     Reference to handle
-        * \param buffer     The buffer to check
-        * \return           True on match, false otherwise
-        */
-       static bool check_handle (const handle_t& handle, const str_view_t buffer) {
-           size_t tmp{};
-           if (match(buffer, handle.token, handle.match_type)) {
-               action_ (tmp, handle, buffer);
-               return true;
-           }
-           return false;
-       }
 
+    public:
        /*!
         * \brief
         *   Run the script array
@@ -340,38 +264,28 @@ class sequencer {
         * The main sequencer functionality. It starts with the first entry of the array.
         * - If the entry is \c NOP it executes the action after the timeout.
         *   \c token and \c handler are discarded.
-        * - If the entry is \c SEND it uses the first handle block's token to send and executes the action after that.
+        * - If the entry is \c SEND it uses the first block's token to send and executes the action after that.
         *   \c timeout is discarded.
         * - If the entry is \c EXCEPTS it continuously try to receive data using implementation's get until one
-        *   of the handle blocks match.
+        *   of the blocks match.
         *   On match:
         *     - Calls the handler if there is one
         *     - Executes the action
-        *     - Skips the next handle blocks if there is any.
+        *     - Skips the next block if there is one
-        *   If there is no match on timeout it return status_t::EXIT_ERROR
-        * - If the entry is \c DETECT it continuously try to detect data using implementation's contents until one
-        *   of the handle blocks match.
-        *   On match:
-        *     - Calls the handler if there is one
-        *     - Executes the action
-        *     - Skips the next handle blocks if there is any.
         *   If there is no match on timeout it return status_t::EXIT_ERROR
         *
         * \tparam Steps     The number of steps of the script
-        * \tparam Nhandles  The number of handle blocks in the each script record.
-        *
         * \param script     Reference to script to run
         * \return           The status of entire operation as described above
         */
-       template <size_t Steps, size_t Nhandles>
+       template <size_t Steps>
-       bool run (const script_t<Steps, Nhandles>& script) {
+       status_t run (const std::array<record_t, Steps>& script) {
            Data_t buffer[N];
-           size_t resp_size{};
+           size_t resp_size;
-           status_t status{};
 
            clock_t mark = clock_();
            for (size_t step =0, p_step =0 ; step < Steps ; ) {
-               const record_t<Nhandles>& it = script[step];
+               const record_t& it = script[step];
 
                if (step != p_step) {
                    p_step = step;
@@ -380,63 +294,64 @@ class sequencer {
                switch (it.control) {
                    default:
                    case control_t::NOP:
-                       if ((clock_() - mark) >= it.timeout)
+                       if ((clock_() - mark) >= it.timeout) {
-                           status = action_ (step, it.block[0]);
+                           switch (it.block[0].action) {
+                               case action_t::EXIT_OK:      return status_t::OK;
+                               case action_t::EXIT_ERROR:   return status_t::ERROR;
+                               default:
+                                   step = step_(step, it.block[0].action, it.block[0].idx);
+                                   break;
+                           }
+                       }
                        break;
 
                    case control_t::SEND:
-                	   if (put_(it.block[0].token.data(), it.block[0].token.size()) != it.block[0].token.size())
+                       put_(it.block[0].token.data(), it.block[0].token.size());
-                	       return false;
+                       switch (it.block[0].action) {
-                       status = action_ (step, it.block[0]);
+                           case action_t::EXIT_OK:      return status_t::OK;
+                           case action_t::EXIT_ERROR:   return status_t::ERROR;
+                           default:
+                               step = step_(step, it.block[0].action, it.block[0].idx);
+                               break;
+                       }
                        break;
 
                    case control_t::EXPECT:
                        resp_size = get_(buffer);
                        if (resp_size) {
                            for (auto& block : it.block) {
-                               if (match(
+                               if (match_(block.match_type, buffer, block.token)) {
-                                       {buffer, resp_size},
+                                   if (block.handler != nullptr)
-                                       block.token,
+                                       block.handler(buffer, resp_size);
-                                       block.match_type)) {
+                                   switch (block.action) {
-                                   status = action_ (step, block, {buffer, resp_size});
+                                       case action_t::EXIT_OK:      return status_t::OK;
+                                       case action_t::EXIT_ERROR:   return status_t::ERROR;
+                                       default:
+                                           step = step_(step, block.action, block.idx);
+                                           break;
+                                   }
                                    break;
                                }
                            }
                        }
-                       if (it.timeout && (clock_() - mark) >= it.timeout)
+                       if ((clock_() - mark) >= it.timeout)
-                           return false;
+                           return status_t::ERROR;
-                       break;
-                   case control_t::DETECT:
-                       auto data = contents_();
-                       if (data.begin() != data.end()) {
-                           for (auto& block : it.block) {
-                               if (match(
-                                       {data.begin(), static_cast<size_t>(data.end() - data.begin())},
-                                       block.token,
-                                       block.match_type)) {
-                                   status = action_ (step, block, {buffer, resp_size});
-                                   break;
-                               }
-                           }
-                       }
-                       if (it.timeout && (clock_() - mark) >= it.timeout)
-                           return false;
                        break;
                } // switch (it.control)
            }
-           return (status == status_t::OK);
+           return status_t::OK;
        }
 };
 
 /*!
  * An "empty" block for convenience.
  */
-template <typename Impl_t, typename Cont_t, typename Data_t, size_t N>
+template <typename Impl_t, typename Data_t, size_t N>
-constexpr typename sequencer<Impl_t, Cont_t, Data_t, N>::handle_t Sequencer_null_block = {
+constexpr typename sequencer_t<Impl_t, Data_t, N>::block_t Sequencer_null_block = {
     "",
-    sequencer<Impl_t, Cont_t, Data_t, N>::match_t::NO,
+    sequencer_t<Impl_t, Data_t, N>::match_t::NO,
     nullptr,
-    sequencer<Impl_t, Cont_t, Data_t, N>::action_t::NO,
+    sequencer_t<Impl_t, Data_t, N>::action_t::NO,
     0
 };
 

test/.gitignore

@@ -1,8 +0,0 @@
-# Binaries
-bin/
-# Eclipse related
-/Debug/
-.settings/
-.project
-.cproject
-

test/Makefile

@@ -85,9 +85,7 @@ SRC_FILES_LIST  :=
 
 # Include directories list(space seperated). Relative path
 INC_DIR_LIST    := ../include gtest
-ifeq ($(OS), Windows_NT)
+                   
-	INC_DIR_LIST += mingw-std-threads
-endif
 # Exclude files list(space seperated). Filenames only.
 # EXC_FILE_LIST := bad.cpp old.cpp
 
@@ -106,13 +104,10 @@ ODUMP           := objdump
 OCOPY           := objcopy
 
 # Compiler flags for debug and release
-DEB_CFLAGS      := -std=gnu++17 -DDEBUG -g3 -Wall -Wextra -fmessage-length=0
+DEB_CFLAGS      := -std=c++17 -DDEBUG -g3 -Wall -Wextra
-REL_CFLAGS      := -std=gnu++17 -g3 -Wall -Wextra -O2 -fmessage-length=0
+REL_CFLAGS      := -std=c++17 -Wall -Wextra -O2
 # Pre-defines
-PRE_DEFS        :=
+# PRE_DEFS := MYCAB=1729 SUPER_MODE
-ifeq ($(OS), Windows_NT)
-	PRE_DEFS    += WIN_TRHEADS
-endif
 
 # ============== Linker settings ==============
 # Linker flags
@@ -189,7 +184,7 @@ $(BUILD_DIR)/$(TARGET): $(OBJ)
 	@echo Linking to target: $(TARGET)
 	$(DOCKER) $(CXX) $(LDFLAGS) $(MAP_FLAG) -o $(@D)/$(TARGET) $(OBJ)
 	$(DOCKER) $(ODUMP) -h -S $(BUILD_DIR)/$(TARGET) > $(BUILD_DIR)/$(basename $(TARGET)).list 
-#	$(DOCKER) $(OCOPY) -O ihex $(BUILD_DIR)/$(TARGET) $(BUILD_DIR)/$(basename $(TARGET)).hex
+	$(DOCKER) $(OCOPY) -O ihex $(BUILD_DIR)/$(TARGET) $(BUILD_DIR)/$(basename $(TARGET)).hex
 	@echo
 	@echo Print size information
 	@$(CSIZE) $(@D)/$(TARGET)
@@ -222,8 +217,8 @@ build-clang: $(BUILD_DIR)/$(TARGET)
 debug: $(BUILD_DIR)/$(TARGET)
 
 .PHONY: release
-release: CFLAGS := $(REL_CFLAGS)
+release: CFLAGS := $(REL_FLAGS)
-release: $(BUILD_DIR)/$(TARGET)
+release: clean $(BUILD_DIR)/$(TARGET)
 
 .PHONY: all
 all: clean release

test/main.cpp

@@ -26,191 +26,9 @@
  *
  */
 #include <gtest/gtest.h>
-#include <exception>
 
-//#include <drv/BG95_base.h>
+GTEST_API_ int main(int argc, char **argv) {
-//#include <gtest/gtest.h>
-//#include <cont/equeue.h>
-////#include <map>
-//
-////#include <iostream>
-//#include <cstring>
-//#include <utility>
-//
-//#ifndef WIN_TRHEADS
-//#include <mutex>
-//#include <thread>
-//#else
-//#include <mingw.thread.h>
-//#include <mingw.mutex.h>
-//#endif
-//
-//using namespace tbx;
-//
-//using Q = equeue<char, 512, true>;
-//
-//// BG95 implementer mock
-//class BG95 : public BG95_base<BG95, Q, 256> {
-//       using base_type = BG95_base<BG95, Q, 256>;
-//
-//   public:
-//       enum class event {
-//           MQTT_DISCONNECT, MQTT_RXDATA
-//       };
-//   // simulated modem operation
-//   private:
-//       struct cmd_pair {
-//           const char *cmd;
-//           const char *resp;
-//       };
-//       struct event_pair {
-//           event e;
-//           const char* resp;
-//       };
-//
-//       std::array<cmd_pair, 19> cmd_map = {{
-//               {"ERROR",                                        "\r\nERROR\r\n"},
-//               {"ATE0\r\n",                                     "\r\nATE0\r\nOK\r\n"},
-//               {"AT\r\n",                                       "\r\nOK\r\n"},
-//               {"AT+QCFG=\"nwscanseq\"\r\n",                    "\r\n+QCFG: \"nwscanseq\",020301\r\n"},
-//               {"AT+QCFG=\"nwscanseq\",010302\r\n",             "\r\nOK\r\n"},
-//               {"AT+CREG?\r\n",                                 "\r\n+CREG: 0,5\r\n\r\nOK\r\n"},
-//               {"AT+CSQ\r\n",                                   "\r\n+CSQ: 19,99\r\n\r\nOK\r\n"},
-//               {"AT+QNWINFO\r\n",                               "\r\n+QNWINFO: \"EDGE\",\"20201\",\"GSM 1800\",865\r\n\r\nOK\r\n"},
-//               // Files
-//               {"AT+QFLST\r\n",                                 "\r\n+QFLST: \"cacert.pem\",1220\r\n+QFLST: \"security/\",2\r\nOK\r\n"},
-//               // MQTT config
-//               {"AT+QSSLCFG=\"ignorelocaltime\",2,1\r\n",       "\r\nOK\r\n"},
-//               {"AT+QSSLCFG=\"seclevel\",2,1\r\n",              "\r\nOK\r\n"},
-//               {"AT+QSSLCFG=\"sslversion\",2,4\r\n",            "\r\nOK\r\n"},
-//               {"AT+QSSLCFG=\"ciphersuite\",2\r\n",             "\r\n+QSSLCFG: \"ciphersuite\",2,0XFFFF\r\n\r\nOK\r\n"},
-//               {"AT+QMTCFG=\"ssl\",0,1,2\r\n",                  "\r\nOK\r\n"},
-//               {"AT+QMTCFG=\"keepalive\",0,3600\r\n",           "\r\nOK\r\n"},
-//               // MQTT
-//               {"AT+QMTOPEN=0,\"server.com\",8883\r\n",         "\r\nOK\r\n\r\n+QMTOPEN: 0,0\r\n"},
-//               {"AT+QMTCONN=0,\"myID\",\"user\",\"pass\"\r\n",  "\r\nOK\r\n\r\n+QMTCONN: 0,0,0\r\n"},
-//               {"AT+QMTSUB=0,1,\"/path/topic1\",2\r\n",         "\r\nOK\r\n\r\n+QMTSUB: 0,1,0,2\r\n"},
-//               {"AT+QMTPUB=0,0,0,0,\"/path/topic2\",9\r\n",     "\r\n> \r\nOK\r\n\r\n+QMTPUB: 0,0,0\r\n"},
-//       }};
-//       std::array<event_pair, 2> event_map {{
-//               {event::MQTT_DISCONNECT,     "\r\n+QMTSTAT: 0,1\r\n"},
-//               {event::MQTT_RXDATA,         "\r\n+QMTRECV: 0,1,\"/path/topic1\",\"BR: hello to all of my subscribers\""}
-//       }};
-//       const char* cmd_responce (const char* cmd) {
-//           for (auto& it : cmd_map) {
-//               if (!strcmp(it.cmd, cmd))
-//                   return it.resp;
-//           }
-//           return cmd_map[0].resp;
-//       }
-//       const char* event_responce (const event e) {
-//           for (auto& it : event_map) {
-//               if (e == it.e)
-//                   return it.resp;
-//           }
-//           return nullptr;  // non reachable
-//       }
-//
-//       // data
-//       Q rx_q{};
-//       std::atomic<size_t> lines{};
-//   public:
-//       using range_t = typename Q::range_t;
-//
-//   public:
-//       // BG95_base driver requirements
-//       BG95() :
-//           rx_q(Q::data_match::MATCH_PUSH, base_type::delimiter, [&](){
-//               lines.fetch_add(1, std::memory_order_acq_rel);
-//           }), lines(0) { }
-//
-//       size_t get(char* data, bool wait =false) {
-//           do {
-//               if (lines.load(std::memory_order_acquire)) {
-//                   size_t n =0;
-//                   do{
-//                       *data << rx_q;
-//                       ++n;
-//                   } while (*data++ != base_type::delimiter);
-//                   lines.fetch_sub(1, std::memory_order_acq_rel);
-//                   return n;
-//               }
-//           } while (wait);
-//           return 0;
-//       }
-//       size_t put (const char* data, size_t n) {
-//           const char* reply = cmd_responce (data);
-//           while (*reply)
-//               rx_q << *reply++;
-//           return n;
-//       }
-//       const range_t contents() const {
-//           return range_t {rx_q.begin(), rx_q.end()};
-//       }
-//       clock_t clock() { static clock_t t=0; return ++t; }
-//
-//       // extra helper for testing purposes
-//       void async (event e) {
-//           const char* reply =event_responce (e);
-//           while (*reply)
-//               rx_q << *reply++;
-//       }
-//};
-//
-//// Behavior flag
-//bool handler_flag = false;
-//void handler (const char* data, size_t n) {
-//   (void)*data;
-//   (void)n;
-////       std::cout << "* handler called\n";
-//   handler_flag = true;
-//}
-//void clear_flag () {
-//   handler_flag = false;
-//}
-//
-//int main(int argc, char **argv) try {
-//    BG95 modem;
-//
-//    const BG95::async_handlers<2> async = {{
-//        {"+QMTOPEN:", BG95::match_t::STARTS_WITH, handler, BG95::action_t::NO, 0},
-//        {"+QMT", BG95::match_t::STARTS_WITH, handler, BG95::action_t::NO, 0},
-//    }};
-//    const BG95::script_t<5, 2> script = {{
-//        /* 0 */{BG95::control_t::NOP,  {"",         BG95::match_t::NO, nullptr, BG95::action_t::GOTO, 1}, 1000},
-//        /* 1 */{BG95::control_t::SEND, {"ATE0\r\n", BG95::match_t::NO, nullptr, BG95::action_t::NEXT, 0}, 0},
-//        /* 2 */{BG95::control_t::EXPECT, {{
-//                    {"OK\r\n", BG95::match_t::ENDS_WITH,   nullptr, BG95::action_t::NEXT, 0},
-//                    {"ERROR",  BG95::match_t::CONTAINS,    nullptr, BG95::action_t::EXIT_ERROR, 0} }},
-//                    1000
-//        },
-//        /* 3 */{BG95::control_t::SEND, {"AT+CSQ\r\n", BG95::match_t::NO, nullptr, BG95::action_t::NEXT, 0}, 0},
-//        /* 4 */{BG95::control_t::EXPECT, {{
-//                    {"OK\r\n", BG95::match_t::ENDS_WITH,  nullptr, BG95::action_t::EXIT_OK, 0},
-//                    {"ERROR",  BG95::match_t::CONTAINS,   nullptr, BG95::action_t::EXIT_ERROR, 0} }},
-//                    1000
-//        },
-//    }};
-//
-//    std::atomic<bool> lock(true);
-//    std::thread th1 ([&](){
-//        do
-//            modem.inetd(async, false);
-//        while (lock.load(std::memory_order_acquire));
-//    });
-//    EXPECT_EQ (modem.run(script), true);
-//    lock.store(false, std::memory_order_acq_rel);
-//    th1.join();
-//
-//}
-//catch (std::exception& e) {
-//    std::cout << "Exception: " << e.what() << '\n';
-//}
-
-GTEST_API_ int main(int argc, char **argv) try {
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
 }
-catch (std::exception& e) {
+
-    std::cout << "Exception: " << e.what() << '\n';
-}

test/mingw-std-threads

@@ -1 +0,0 @@
-Subproject commit f6365f900fb9b1cd6014c8d1cf13ceacf8faf3de

test/tests/BG95_base.cpp

@@ -1,270 +0,0 @@
-/*!
- * \file sequencer.cpp
- *
- * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net>
- *
- * <dl class=\"section copyright\"><dt>License</dt><dd>
- * The MIT License (MIT)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * </dd></dl>
- *
- */
-#include <drv/BG95_base.h>
-#include <gtest/gtest.h>
-#include <cont/equeue.h>
-//#include <map>
-
-//#include <iostream>
-#include <cstring>
-#include <utility>
-
-#ifndef WIN_TRHEADS
-#include <mutex>
-#include <thread>
-#else
-#include <mingw.thread.h>
-#include <mingw.mutex.h>
-#endif
-
-namespace test_bg95_base {
-   using namespace tbx;
-
-   using Q = equeue<char, 512, true>;
-
-   // BG95 implementer mock
-   class BG95 : public BG95_base<BG95, Q, 256> {
-           using base_type = BG95_base<BG95, Q, 256>;
-
-       public:
-           enum class event {
-               MQTT_DISCONNECT, MQTT_RXDATA
-           };
-       // simulated modem operation
-       private:
-           struct cmd_pair {
-               const char *cmd;
-               const char *resp;
-           };
-           struct event_pair {
-               event e;
-               const char* resp;
-           };
-
-           std::array<cmd_pair, 19> cmd_map = {{
-                   {"ERROR",                                        "\r\nERROR\r\n"},
-                   {"ATE0\r\n",                                     "\r\nATE0\r\nOK\r\n"},
-                   {"AT\r\n",                                       "\r\nOK\r\n"},
-                   {"AT+QCFG=\"nwscanseq\"\r\n",                    "\r\n+QCFG: \"nwscanseq\",020301\r\n"},
-                   {"AT+QCFG=\"nwscanseq\",010302\r\n",             "\r\nOK\r\n"},
-                   {"AT+CREG?\r\n",                                 "\r\n+CREG: 0,5\r\n\r\nOK\r\n"},
-                   {"AT+CSQ\r\n",                                   "\r\n+CSQ: 19,99\r\n\r\nOK\r\n"},
-                   {"AT+QNWINFO\r\n",                               "\r\n+QNWINFO: \"EDGE\",\"20201\",\"GSM 1800\",865\r\n\r\nOK\r\n"},
-                   // Files
-                   {"AT+QFLST\r\n",                                 "\r\n+QFLST: \"cacert.pem\",1220\r\n+QFLST: \"security/\",2\r\nOK\r\n"},
-                   // MQTT config
-                   {"AT+QSSLCFG=\"ignorelocaltime\",2,1\r\n",       "\r\nOK\r\n"},
-                   {"AT+QSSLCFG=\"seclevel\",2,1\r\n",              "\r\nOK\r\n"},
-                   {"AT+QSSLCFG=\"sslversion\",2,4\r\n",            "\r\nOK\r\n"},
-                   {"AT+QSSLCFG=\"ciphersuite\",2\r\n",             "\r\n+QSSLCFG: \"ciphersuite\",2,0XFFFF\r\n\r\nOK\r\n"},
-                   {"AT+QMTCFG=\"ssl\",0,1,2\r\n",                  "\r\nOK\r\n"},
-                   {"AT+QMTCFG=\"keepalive\",0,3600\r\n",           "\r\nOK\r\n"},
-                   // MQTT
-                   {"AT+QMTOPEN=0,\"server.com\",8883\r\n",         "\r\nOK\r\n\r\n+QMTOPEN: 0,0\r\n"},
-                   {"AT+QMTCONN=0,\"myID\",\"user\",\"pass\"\r\n",  "\r\nOK\r\n\r\n+QMTCONN: 0,0,0\r\n"},
-                   {"AT+QMTSUB=0,1,\"/path/topic1\",2\r\n",         "\r\nOK\r\n\r\n+QMTSUB: 0,1,0,2\r\n"},
-                   {"AT+QMTPUB=0,0,0,0,\"/path/topic2\",9\r\n",     "\r\n> \r\nOK\r\n\r\n+QMTPUB: 0,0,0\r\n"},
-           }};
-           std::array<event_pair, 2> event_map {{
-                   {event::MQTT_DISCONNECT,     "\r\n+QMTSTAT: 0,1\r\n"},
-                   {event::MQTT_RXDATA,         "\r\n+QMTRECV: 0,1,\"/path/topic1\",\"BR: hello to all of my subscribers\""}
-           }};
-           const char* cmd_responce (const char* cmd) {
-               for (auto& it : cmd_map) {
-                   if (!strcmp(it.cmd, cmd))
-                       return it.resp;
-               }
-               return cmd_map[0].resp;
-           }
-           const char* event_responce (const event e) {
-               for (auto& it : event_map) {
-                   if (e == it.e)
-                       return it.resp;
-               }
-               return nullptr;  // non reachable
-           }
-
-           // data
-           Q rx_q{};
-           std::atomic<size_t> lines{};
-       public:
-           using range_t = typename Q::range_t;
-
-       public:
-           // BG95_base driver requirements
-           BG95() :
-               rx_q(Q::data_match::MATCH_PUSH, base_type::delimiter, [&](){
-                   lines.fetch_add(1, std::memory_order_acq_rel);
-               }), lines(0) { }
-
-           size_t get(char* data, bool wait =false) {
-               do {
-                   if (lines.load(std::memory_order_acquire)) {
-                       size_t n =0;
-                       do{
-                           *data << rx_q;
-                           ++n;
-                       } while (*data++ != base_type::delimiter);
-                       lines.fetch_sub(1, std::memory_order_acq_rel);
-                       return n;
-                   }
-               } while (wait);
-               return 0;
-           }
-           size_t put (const char* data, size_t n) {
-               std::cerr << " ";
-               const char* reply = cmd_responce (data);
-               while (*reply)
-                   rx_q << *reply++;
-               return n;
-           }
-           const range_t contents() const {
-               return range_t {rx_q.begin(), rx_q.end()};
-           }
-           clock_t clock() { static clock_t t=0; return ++t; }
-
-           // extra helper for testing purposes
-           void async (event e) {
-               const char* reply =event_responce (e);
-               while (*reply)
-                   rx_q << *reply++;
-           }
-   };
-
-   // Behavior flag
-   bool handler_flag = false;
-   void handler (const char* data, size_t n) {
-       (void)*data;
-       (void)n;
-//       std::cout << "* handler called\n";
-       handler_flag = true;
-   }
-   void clear_flag () {
-       handler_flag = false;
-   }
-   /*
-    * Test inetd in non blocking mode
-    */
-   TEST(TBG95_base, inetd_non_blocking) {
-       BG95 modem;
-       char buffer[256];
-
-       const BG95::async_handlers<2> async = {{
-           {"+QMTOPEN:", BG95::match_t::STARTS_WITH, handler, BG95::action_t::NO, 0},
-           {"+QMT", BG95::match_t::STARTS_WITH, handler, BG95::action_t::NO, 0},
-       }};
-
-       clear_flag();
-       modem.inetd(false, &async);
-       EXPECT_EQ (handler_flag, false);
-       modem.async(BG95::event::MQTT_DISCONNECT);
-       modem.inetd(false, &async);     // parse "\r\n"
-       EXPECT_EQ (handler_flag, false);
-       modem.inetd(false, &async);      // parse "+QMT*\r\n"  and dispatch to handler()
-       EXPECT_EQ (handler_flag, true);
-       clear_flag();                    // nothing to parse
-       modem.inetd(false, &async);
-       modem.inetd(false, &async);
-       modem.inetd(false, &async);
-       EXPECT_EQ (handler_flag, false);
-       EXPECT_NE (modem.receive(buffer), 0UL);  // "\r\n" in buffer
-       EXPECT_EQ (strcmp(buffer, "\r\n"), 0);
-
-       clear_flag();
-       modem.inetd(false, &async);
-       EXPECT_EQ (handler_flag, false);
-       modem.transmit("AT+CSQ\r\n", 8);
-       EXPECT_EQ (modem.receive(buffer), 0UL);
-       modem.inetd(false, &async);      // parse "\r\n"
-       EXPECT_NE (modem.receive(buffer), 0UL);
-       EXPECT_EQ (strcmp(buffer, "\r\n"), 0);
-       modem.inetd(false, &async);      // parse "+CSQ: 19,99\r\n"
-       EXPECT_NE (modem.receive(buffer), 0UL);
-       EXPECT_EQ (strcmp(buffer, "+CSQ: 19,99\r\n"), 0);
-       modem.inetd(false, &async);      // parse "\r\n"
-       EXPECT_NE (modem.receive(buffer), 0UL);
-       EXPECT_EQ (strcmp(buffer, "\r\n"), 0);
-       modem.inetd(false, &async);      // parse "OK\r\n"
-       EXPECT_NE (modem.receive(buffer), 0UL);
-       EXPECT_EQ (strcmp(buffer, "OK\r\n"), 0);
-       modem.inetd(false, &async);      // nothing to parse
-       modem.inetd(false, &async);
-       modem.inetd(false, &async);
-       EXPECT_EQ (modem.receive(buffer), 0UL);
-   }
-
-   TEST(TBG95_base, run) {
-	   BG95 modem;
-
-	   const BG95::async_handlers<2> async = {{
-           {"+QMTOPEN:", BG95::match_t::STARTS_WITH, handler, BG95::action_t::NO, 0},
-           {"+QMT", BG95::match_t::STARTS_WITH, handler, BG95::action_t::NO, 0},
-	   }};
-       const BG95::script_t<5> script = {{
-           /* 0 */{BG95::control_t::NOP,  {"",         BG95::match_t::NO, nullptr, BG95::action_t::GOTO, 1}, 1000},
-           /* 1 */{BG95::control_t::SEND, {"ATE0\r\n", BG95::match_t::NO, nullptr, BG95::action_t::NEXT, 0}, 0},
-           /* 2 */{BG95::control_t::EXPECT, {{
-                       {"OK\r\n", BG95::match_t::ENDS_WITH,   nullptr, BG95::action_t::NEXT, 0},
-                       {"ERROR",  BG95::match_t::CONTAINS,    nullptr, BG95::action_t::EXIT_ERROR, 0} }},
-                       1000
-                   },
-           /* 3 */{BG95::control_t::SEND, {"AT+CSQ\r\n", BG95::match_t::NO, nullptr, BG95::action_t::NEXT, 0}, 0},
-           /* 4 */{BG95::control_t::EXPECT, {{
-                       {"OK\r\n", BG95::match_t::ENDS_WITH,  nullptr, BG95::action_t::EXIT_OK, 0},
-                       {"ERROR",  BG95::match_t::CONTAINS,   nullptr, BG95::action_t::EXIT_ERROR, 0} }},
-                       1000
-           },
-       }};
-
-       std::atomic<bool> lock(true);
-       std::thread th1 ([&](){
-           do
-               modem.inetd(false, &async);
-           while (lock.load(std::memory_order_acquire));
-       });
-       EXPECT_EQ (modem.run(script), true);
-       lock.store(false, std::memory_order_acq_rel);
-       th1.join();
-   }
-
-   TEST(TBG95_base, command) {
-       BG95 modem;
-
-       std::atomic<bool> lock(true);
-       std::thread th1 ([&](){
-           do
-               modem.inetd(false);
-           while (lock.load(std::memory_order_acquire));
-       });
-       EXPECT_EQ (modem.registered(), true);
-       lock.store(false, std::memory_order_acq_rel);
-       th1.join();
-
-   }
-}

test/tests/deque.cpp

@@ -29,44 +29,12 @@
  *
  */
 #include <cont/deque.h>
-#include <cont/span.h>
 #include <gtest/gtest.h>
 
-#include <array>
-#include <type_traits>
-
 namespace Tdeque {
     using namespace tbx;
 
-    template <typename>
-    struct is_span : std::false_type {};
 
-    template <typename T, std::size_t S>
-    struct is_span<tbx::span<T, S>> : std::true_type {};
-
-    template <typename>
-    struct is_std_array : std::false_type {};
-
-    template <typename T, std::size_t N>
-    struct is_std_array<std::array<T, N>> : std::true_type {};
-
-    template <typename, typename = void>
-    struct has_size_and_data : std::false_type {};
-
-    template <typename T>
-    struct has_size_and_data<T, std::void_t<decltype(std::declval<T>().size()),
-                                            decltype(std::declval<T>().data())>>
-        : std::true_type {};
-
-    // Concept
-    TEST(Tdeque, concept) {
-        using deque_t = deque<int, 8>;
-
-        EXPECT_EQ (true, !is_span<deque_t>::value);
-        EXPECT_EQ (true, !is_std_array<deque_t>::value);
-        EXPECT_EQ (true, !std::is_array<deque_t>::value);
-        EXPECT_EQ (true,  has_size_and_data<deque_t>::value);
-    }
     // Test construction
     TEST(Tdeque, contruct) {
         deque<int, 8> q1;
@@ -224,190 +192,5 @@ namespace Tdeque {
         EXPECT_EQ(6, check_it);         // run through all
 
     }
-    TEST (Tdeque, range) {
-        deque<int, 8> q1{1, 2, 3, 4, 5, 6, 7, 8};
-        int check_it=1;
-
-        for (auto& it : q1.contents())
-            EXPECT_EQ(it, check_it++);
-
-        EXPECT_EQ(9, check_it);         // run through all
-    }
-
-
-    // Concept
-    TEST(Tdeque, concept_atomic) {
-        using deque_t = deque<int, 8, true>;
-
-        EXPECT_EQ (true, !is_span<deque_t>::value);
-        EXPECT_EQ (true, !is_std_array<deque_t>::value);
-        EXPECT_EQ (true, !std::is_array<deque_t>::value);
-        EXPECT_EQ (true,  has_size_and_data<deque_t>::value);
-    }
-    // Test construction
-    TEST(Tdeque, contruct_atomic) {
-        deque<int, 8, true> q1;
-        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};
-        deque<int, 8, true> q3{1, 2, 3, 4, 5};
-
-        EXPECT_EQ (8UL, q1.capacity());
-        EXPECT_EQ (0UL, q1.size());
-        EXPECT_EQ (8UL, q2.capacity());
-        EXPECT_EQ (8UL, q2.size());
-        EXPECT_EQ (8UL, q3.capacity());
-        EXPECT_EQ (5UL, q3.size());
-    }
-
-    // simple push-pop functionality
-    TEST(Tdeque, push_pop_atomic) {
-        deque<int, 8, true> q1;
-        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};
-
-        q1.push_front(1);
-        q1.push_front(2);
-        EXPECT_EQ (1, q1.pop_back());
-        EXPECT_EQ (2, q1.pop_back());
-
-        q1.push_back(1);
-        q1.push_back(2);
-        EXPECT_EQ (1, q1.pop_front());
-        EXPECT_EQ (2, q1.pop_front());
-
-        q1.push_front(2);
-        q1.push_back(3);
-        q1.push_front(1);
-        q1.push_back(4);
-
-        for (int i=1 ; i<= 4 ; ++i)
-            EXPECT_EQ ((int)i, q1.pop_front());
-    }
-
-    // front-back
-    TEST(Tdeque, front_back_atomic) {
-        deque<int, 8, true> q1;
-        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};
-
-        q1.push_front(2);
-        q1.push_front(1);
-        q1.push_back(3);
-        q1.push_back(4);
-
-        EXPECT_EQ (1, q1.front());
-        EXPECT_EQ (4, q1.back());
-        EXPECT_EQ (1, q2.front());
-        EXPECT_EQ (8, q2.back());
-    }
-
-    // capacity
-    TEST(Tdeque, capacity_atomic) {
-        deque<int, 8, true> q1;
-        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};
-
-        q1.push_back(1);
-        q1.clear();
-        EXPECT_EQ (true, q1.empty());
-        EXPECT_EQ (true, q2.full());
-
-        EXPECT_EQ (8UL, q1.capacity());
-        EXPECT_EQ (8UL, q2.capacity());
-
-        EXPECT_EQ (0UL, q1.size());
-        EXPECT_EQ (8UL, q2.size());
-
-        q1.push_back(2);
-        EXPECT_EQ (1UL, q1.size());
-        q1.push_front(1);
-        EXPECT_EQ (2UL, q1.size());
-
-        q1.pop_back();
-        EXPECT_EQ (1UL, q1.size());
-        q1.pop_front();
-        EXPECT_EQ (0UL, q1.size());
-    }
-
-    // push-pop limits
-    TEST (Tdeque, push_pop_limits_atomic) {
-        deque<int, 8, true> q1;
-        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};
-
-        EXPECT_EQ (int{}, q1.pop_back());
-        EXPECT_EQ (0UL, q1.size());
-        EXPECT_EQ (true, q1.empty());
-        EXPECT_EQ (false, q1.full());
-
-        EXPECT_EQ (int{}, q1.pop_front());
-        EXPECT_EQ (0UL, q1.size());
-        EXPECT_EQ (true, q1.empty());
-        EXPECT_EQ (false, q1.full());
-
-        q2.push_front(0);
-        EXPECT_EQ (1, q2.front());
-        EXPECT_EQ (8, q2.back());
-        EXPECT_EQ (8UL, q2.size());
-        EXPECT_EQ (false, q2.empty());
-        EXPECT_EQ (true, q2.full());
-
-        q2.push_back(9);
-        EXPECT_EQ (1, q2.front());
-        EXPECT_EQ (8, q2.back());
-        EXPECT_EQ (8UL, q2.size());
-        EXPECT_EQ (false, q2.empty());
-        EXPECT_EQ (true, q2.full());
-    }
-
-    // iterators
-    TEST (Tdeque, iterators_atomic) {
-        deque<int, 8, true> q1{1, 2, 3, 4, 5, 6, 7, 8};
-        int check_it=1;
-
-        EXPECT_EQ (q1.begin().base(), q1.end().base());
-        EXPECT_NE (q1.begin().iter(), q1.end().iter());
-        EXPECT_EQ (1, *q1.begin());
-        EXPECT_EQ (true, (q1.begin() == ++q1.end()));   // loop edge iterators
-
-        for (auto it = q1.begin() ; it != q1.end() ; ++it)
-            EXPECT_EQ(*it, check_it++);
-        EXPECT_EQ(9, check_it);         // run through all
-
-        EXPECT_EQ (1, q1.front());      // queue stays intact
-        EXPECT_EQ (8, q1.back());
-        EXPECT_EQ (8UL, q1.size());
-        EXPECT_EQ (false, q1.empty());
-        EXPECT_EQ (true, q1.full());
-
-        q1.pop_front();
-        q1.pop_back();
-
-        check_it=2;
-        for (auto& it : q1)
-            EXPECT_EQ(it, check_it++);
-        EXPECT_EQ(8, check_it);         // run through all
-
-        EXPECT_EQ (2, q1.front());      // queue stays intact
-        EXPECT_EQ (7, q1.back());
-        EXPECT_EQ (6UL, q1.size());
-        EXPECT_EQ (false, q1.empty());
-        EXPECT_EQ (false, q1.full());
-
-        deque<int, 8, true> q2;
-        q2.push_front(2);
-        q2.push_front(1);
-        q2.push_back(3);
-        q2.push_back(4);
-        q2.push_back(5);
-        check_it =1;
-        for (auto& it : q2)
-            EXPECT_EQ(it, check_it++);
-        EXPECT_EQ(6, check_it);         // run through all
 
 }
-    TEST (Tdeque, range_atomic) {
-        deque<int, 8, true> q1{1, 2, 3, 4, 5, 6, 7, 8};
-        int check_it=1;
-
-        for (auto& it : q1.contents())
-            EXPECT_EQ(it, check_it++);
-
-        EXPECT_EQ(9, check_it);         // run through all
-    }
-}

test/tests/edeque.cpp

@@ -1,7 +1,7 @@
 /*!
  * \file deque.cpp
  * \brief
- *      Unit tests for edeque
+ *      Unit tests for deque
  *
  * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net>
  *
@@ -33,7 +33,7 @@
 
 #include <functional>
 
-namespace Tedeque {
+namespace Tdeque {
     using namespace tbx;
 
     int global_flag =0;
@@ -132,15 +132,15 @@ namespace Tedeque {
         e1.check_trigger();         // manual trigger attempt
         EXPECT_EQ (false, flag);    // [SIZE triggers are auto clear]
 
-        Edeque e2(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
+        Edeque e2(Edeque::data_match::MATCH, 42, [&](){ flag = true; });
         flag = false;
         e2.clear_trigger();
         EXPECT_EQ (false, flag);
         e2.push_back(42);           // push 42, no-trigger cleared
         EXPECT_EQ (false, flag);
-        e2.set_trigger(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
+        e2.set_trigger(Edeque::data_match::MATCH, 42, [&](){ flag = true; });
         EXPECT_EQ (false, flag);    // no spurious triggers
-        e2.push_back(42);           // push 42, trigger
+        e2.pop_back();              // pop 42, trigger
         EXPECT_EQ (true, flag);
 
         flag = false;
@@ -236,8 +236,8 @@ namespace Tedeque {
         using Edeque = edeque<int, 8>;
         bool flag{};
 
-        // data_match::MATCH_PUSH (item == 42)
+        // data_match::MATCH (item == 42)
-        Edeque ee(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
+        Edeque ee(Edeque::data_match::MATCH, 42, [&](){ flag = true; });
 
         flag = false;
         ee.push_back(7);            // 7
@@ -246,28 +246,14 @@ namespace Tedeque {
         EXPECT_EQ (true, flag);
 
         flag = false;
-        ee.pop_back();              // pop:42, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.push_back(42);           // push:42, re-trigger
-        EXPECT_EQ (true, flag);
-
-        // data_match::MATCH_POP (item == 42)
-        flag = false;
-        ee.clear_trigger();
-        ee.set_trigger(Edeque::data_match::MATCH_POP, 42, [&](){ flag = true; });
-        ee.push_back(7);            // 7
-        EXPECT_EQ (false, flag);
-        ee.push_back(42);           // push:42, no-trigger
-        EXPECT_EQ (false, flag);
         ee.pop_back();              // pop:42, trigger
         EXPECT_EQ (true, flag);
 
-        // data_match::MISMATCH_PUSH (item != 42)
+        // data_match::MATCH (item != 42)
         flag = false;
         ee.clear();
-        ee.clear_trigger();
         ee.push_back(7);            // 7
-        ee.set_trigger(Edeque::data_match::MISMATCH_PUSH, 42, [&](){ flag = true; });
+        ee.set_trigger(Edeque::data_match::MISMATCH, 42, [&](){ flag = true; });
         EXPECT_EQ (false, flag);    // no spurious triggers
         ee.push_back(42);           // 42, no-trigger
         EXPECT_EQ (false, flag);
@@ -277,279 +263,5 @@ namespace Tedeque {
         flag = false;
         ee.push_back(1);            // 1, re-trigger
         EXPECT_EQ (true, flag);
-
-        // data_match::MISMATCH_POP (item != 42)
-        flag = false;
-        ee.clear();
-        ee.clear_trigger();
-        ee.push_back(7);            // ->7
-        ee.pop_back();              // <-7
-        ee.set_trigger(Edeque::data_match::MISMATCH_POP, 42, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        ee.push_back(42);           // ->42, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.push_back(0);            // ->0, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.pop_back();              // pop:0, trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        ee.push_back(0);
-        ee.pop_back();              // pop:0, re-trigger
-        EXPECT_EQ (true, flag);
-    }
-
-    // atomic
-    TEST (Tedeque, construct_atomic) {
-        using Edeque = edeque<int, 8, true>;
-        struct T { int a,b; };
-        int local{};
-
-        Edeque e1(Edeque::size_match::GE, 3, [](){
-            ++global_flag;
-        });
-        Edeque e2(Edeque::size_match::GE, 3, [&](){
-            ++local;
-        });
-        Edeque e3(Edeque::size_match::EQ, 7, vfun);
-        edeque<T, 8> e4(edeque<T, 8>::size_match::EQ, 2, vfoo{});
-
-        edeque<int, 8, true> q1;
-        edeque<int, 8, true> q2(edeque<int, 8, true>::size_match::DISABLED, 0, nullptr);
-
-        EXPECT_EQ (8UL, e1.capacity());
-        EXPECT_EQ (8UL, e2.capacity());
-        EXPECT_EQ (8UL, e3.capacity());
-        EXPECT_EQ (8UL, e4.capacity());
-
-        EXPECT_EQ (8UL, q1.capacity());
-        EXPECT_EQ (8UL, q2.capacity());
-    }
-
-    TEST (Tedeque, base_class_atomic) {
-        using Edeque = edeque<int, 8, true>;
-
-        Edeque e1(Edeque::size_match::GE, 3, [](){
-            ++global_flag;
-        });
-
-        // Access of base class functionality
-        EXPECT_EQ (8UL, e1.capacity());
-        EXPECT_EQ (0UL, e1.size());
-        EXPECT_EQ (true, e1.empty());
-        EXPECT_EQ (false, e1.full());
-
-        e1.push_back(7);
-        EXPECT_EQ (7, e1.front());
-        EXPECT_EQ (7, e1.back());
-        EXPECT_EQ (7, e1.pop_front());
-
-        e1.push_front(42);
-        EXPECT_EQ (42, e1.front());
-        EXPECT_EQ (42, e1.back());
-        EXPECT_EQ (42, e1.pop_back());
-
-        e1.push_back(1);
-        e1.push_back(2);
-        e1.push_back(3);
-
-        int check_it=1;
-        for (auto it = e1.begin() ; it != e1.end() ; ++it)
-            EXPECT_EQ(*it, check_it++);
-        EXPECT_EQ(4, check_it);         // run through all
-    }
-
-    TEST (Tedeque, set_clear_check_trigger_atomic) {
-        using Edeque = edeque<int, 8, true>;
-        bool flag{};
-
-        Edeque e1(Edeque::size_match::GE, 1, [&](){ flag = true; });
-
-        flag = false;
-        e1.clear_trigger();
-        EXPECT_EQ (false, flag);
-        e1.push_back(1);            // 1,  no-trigger cleared
-        EXPECT_EQ (false, flag);
-
-        flag = false;
-        e1.clear();
-        e1.clear_trigger();
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        e1.push_back(1);            // 1
-        e1.push_back(2);            // 2
-        e1.set_trigger(Edeque::size_match::GE, 1, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        e1.check_trigger();         // manual trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        e1.check_trigger();         // manual trigger attempt
-        EXPECT_EQ (false, flag);    // [SIZE triggers are auto clear]
-
-        Edeque e2(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
-        flag = false;
-        e2.clear_trigger();
-        EXPECT_EQ (false, flag);
-        e2.push_back(42);           // push 42, no-trigger cleared
-        EXPECT_EQ (false, flag);
-        e2.set_trigger(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        e2.push_back(42);           // push 42, trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        e2.push_back(42);           // push 42, re-trigger [DATA re-triggers]
-        EXPECT_EQ (true, flag);
-    }
-
-    TEST (Tedeque, size_triggers_atomic) {
-        using Edeque = edeque<int, 8, true>;
-        bool flag{};
-
-        // size_match::GE (size()>= 2)
-        Edeque ee(Edeque::size_match::GE, 2, [&](){ flag = true; });
-
-        flag = false;
-        ee.clear();
-        ee.push_back(1);            // 1
-        EXPECT_EQ (false, flag);
-        ee.push_back(2);            // 2, trigger
-        EXPECT_EQ (true, flag);
-        flag = false;
-        ee.push_back(3);            // 3, no-trigger cleared
-        EXPECT_EQ (false, flag);
-
-        // size_match::GT (size()> 1)
-        flag = false;
-        ee.clear();
-        ee.set_trigger(Edeque::size_match::GT, 1, [&](){ flag = true; });
-        ee.push_back(1);            // 1
-        EXPECT_EQ (false, flag);
-        ee.push_back(2);            // 2, trigger
-        EXPECT_EQ (true, flag);
-        flag = false;
-        ee.push_back(3);            // 3, no-trigger cleared
-        EXPECT_EQ (false, flag);
-
-        // size_match::LE (size()<= 1)
-        flag = false;
-        ee.clear();
-        ee.push_back(1);            // 1
-        ee.push_back(2);            // 2
-        ee.push_back(3);            // 3
-        ee.set_trigger(Edeque::size_match::LE, 1, [&](){ flag = true; });
-        ee.pop_front();             // 2
-        EXPECT_EQ (false, flag);
-        ee.pop_front();             // 1, trigger
-        EXPECT_EQ (true, flag);
-        flag = false;
-        ee.pop_front();             // 0, no-trigger cleared
-        EXPECT_EQ (false, flag);
-
-        // size_match::LT (size()< 2)
-        flag = false;
-        ee.clear();
-        ee.push_back(1);            // 1
-        ee.push_back(2);            // 2
-        ee.push_back(3);            // 3
-        ee.set_trigger(Edeque::size_match::LT, 2, [&](){ flag = true; });
-        ee.pop_front();             // 2
-        EXPECT_EQ (false, flag);
-        ee.pop_front();             // 1, trigger
-        EXPECT_EQ (true, flag);
-        flag = false;
-        ee.pop_front();             // 0, no-trigger cleared
-        EXPECT_EQ (false, flag);
-
-        // size_match::EQ (size()== 2)
-        flag = false;
-        ee.clear();
-        ee.set_trigger(Edeque::size_match::EQ, 2, [&](){ flag = true; });
-        ee.push_back(1);            // 1
-        EXPECT_EQ (false, flag);
-        ee.push_back(2);            // 2, trigger
-        EXPECT_EQ (true, flag);
-        flag = false;
-        ee.push_back(3);            // 3
-        ee.pop_front();             // 2, no-trigger cleared
-        EXPECT_EQ (false, flag);
-
-        // size_match::NE (size()!= 0)
-        flag = false;
-        ee.clear();
-        ee.set_trigger(Edeque::size_match::NE, 0, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);
-        ee.push_back(1);            // 1, trigger
-        EXPECT_EQ (true, flag);
-        flag = false;
-        ee.push_back(2);            // 2, no-trigger
-        EXPECT_EQ (false, flag);
-    }
-
-    TEST (Tedeque, data_triggers_atomic) {
-        using Edeque = edeque<int, 8, true>;
-        bool flag{};
-
-        // data_match::MATCH_PUSH (item == 42)
-        Edeque ee(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
-
-        flag = false;
-        ee.push_back(7);            // 7
-        EXPECT_EQ (false, flag);
-        ee.push_back(42);           // push:42, trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        ee.pop_back();              // pop:42, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.push_back(42);           // push:42, re-trigger
-        EXPECT_EQ (true, flag);
-
-        // data_match::MATCH_POP (item == 42)
-        flag = false;
-        ee.clear_trigger();
-        ee.set_trigger(Edeque::data_match::MATCH_POP, 42, [&](){ flag = true; });
-        ee.push_back(7);            // 7
-        EXPECT_EQ (false, flag);
-        ee.push_back(42);           // push:42, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.pop_back();              // pop:42, trigger
-        EXPECT_EQ (true, flag);
-
-        // data_match::MISMATCH_PUSH (item != 42)
-        flag = false;
-        ee.clear();
-        ee.clear_trigger();
-        ee.push_back(7);            // 7
-        ee.set_trigger(Edeque::data_match::MISMATCH_PUSH, 42, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        ee.push_back(42);           // 42, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.push_back(0);            // 0, trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        ee.push_back(1);            // 1, re-trigger
-        EXPECT_EQ (true, flag);
-
-        // data_match::MISMATCH_POP (item != 42)
-        flag = false;
-        ee.clear();
-        ee.clear_trigger();
-        ee.push_back(7);            // ->7
-        ee.pop_back();              // <-7
-        ee.set_trigger(Edeque::data_match::MISMATCH_POP, 42, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        ee.push_back(42);           // ->42, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.push_back(0);            // ->0, no-trigger
-        EXPECT_EQ (false, flag);
-        ee.pop_back();              // pop:0, trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        ee.push_back(0);
-        ee.pop_back();              // pop:0, re-trigger
-        EXPECT_EQ (true, flag);
     }
 }

test/tests/equeue.cpp

@@ -128,15 +128,15 @@ namespace Tequeue {
         e1.check_trigger();         // manual trigger attempt
         EXPECT_EQ (false, flag);    // [SIZE triggers are auto clear]
 
-        Equeue e2(Equeue::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
+        Equeue e2(Equeue::data_match::MATCH, 42, [&](){ flag = true; });
         flag = false;
         e2.clear_trigger();
         EXPECT_EQ (false, flag);
         e2.push_back(42);           // push 42, no-trigger cleared
         EXPECT_EQ (false, flag);
-        e2.set_trigger(Equeue::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
+        e2.set_trigger(Equeue::data_match::MATCH, 42, [&](){ flag = true; });
         EXPECT_EQ (false, flag);    // no spurious triggers
-        e2.push_back(42);           // push 42, trigger
+        e2.pop_back();              // pop 42, trigger
         EXPECT_EQ (true, flag);
 
         flag = false;
@@ -178,140 +178,4 @@ namespace Tequeue {
         EXPECT_EQ (int{}, check_it);
     }
 
-    // atomic
-    // Test construction
-    TEST(Tequeue, contruct_atomic) {
-        using Equeue = equeue<int, 8, true>;
-        struct T { int a,b; };
-        int local{};
-
-        Equeue e1(Equeue::size_match::GE, 3, [](){
-            ++global_flag;
-        });
-        Equeue e2(Equeue::size_match::GE, 3, [&](){
-            ++local;
-        });
-        Equeue e3(Equeue::size_match::EQ, 7, vfun);
-        equeue<T, 8> e4(equeue<T, 8>::size_match::EQ, 2, vfoo{});
-
-        equeue<int, 8, true> q1;
-        equeue<int, 8, true> q2(equeue<int, 8, true>::size_match::DISABLED, 0, nullptr);
-
-        EXPECT_EQ (8UL, e1.capacity());
-        EXPECT_EQ (8UL, e2.capacity());
-        EXPECT_EQ (8UL, e3.capacity());
-        EXPECT_EQ (8UL, e4.capacity());
-
-        EXPECT_EQ (8UL, q1.capacity());
-        EXPECT_EQ (8UL, q2.capacity());
-    }
-
-    // simple push-pop functionality
-    TEST(Tequeue, base_class_atomic) {
-        using Equeue = equeue<int, 8, true>;
-
-        Equeue e1(Equeue::size_match::GE, 3, [](){
-            ++global_flag;
-        });
-
-        // Access of base class functionality
-        EXPECT_EQ (8UL, e1.capacity());
-        EXPECT_EQ (0UL, e1.size());
-        EXPECT_EQ (true, e1.empty());
-        EXPECT_EQ (false, e1.full());
-
-        e1.push(42);
-        EXPECT_EQ (42, e1.front());
-        EXPECT_EQ (42, e1.back());
-        EXPECT_EQ (42, e1.pop());
-
-        e1.push(1);
-        e1.push(2);
-        e1.push(3);
-
-        int check_it=1;
-        for (auto it = e1.begin() ; it != e1.end() ; ++it)
-            EXPECT_EQ(*it, check_it++);
-        EXPECT_EQ(4, check_it);         // run through all
-
-    }
-
-    // trigger functionality
-    TEST (Tequeue, set_clear_check_trigger_atomic) {
-        using Equeue = equeue<int, 8, true>;
-        bool flag{};
-
-        Equeue e1(Equeue::size_match::GE, 1, [&](){ flag = true; });
-
-        flag = false;
-        e1.clear_trigger();
-        EXPECT_EQ (false, flag);
-        e1.push_back(1);            // 1,  no-trigger cleared
-        EXPECT_EQ (false, flag);
-
-        flag = false;
-        e1.clear();
-        e1.clear_trigger();
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        e1.push_back(1);            // 1
-        e1.push_back(2);            // 2
-        e1.set_trigger(Equeue::size_match::GE, 1, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        e1.check_trigger();         // manual trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        e1.check_trigger();         // manual trigger attempt
-        EXPECT_EQ (false, flag);    // [SIZE triggers are auto clear]
-
-        Equeue e2(Equeue::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
-        flag = false;
-        e2.clear_trigger();
-        EXPECT_EQ (false, flag);
-        e2.push_back(42);           // push 42, no-trigger cleared
-        EXPECT_EQ (false, flag);
-        e2.set_trigger(Equeue::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
-        EXPECT_EQ (false, flag);    // no spurious triggers
-        e2.push_back(42);           // push 42, trigger
-        EXPECT_EQ (true, flag);
-
-        flag = false;
-        e2.push_back(42);           // push 42, re-trigger [DATA re-triggers]
-        EXPECT_EQ (true, flag);
-    }
-
-    // stream push-pop
-    TEST(Tequeue, stream_push_pop_atomic) {
-        equeue<int, 8, true> q1;
-
-        q1 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8;
-        EXPECT_EQ (8UL, q1.capacity());
-        EXPECT_EQ (8UL, q1.size());
-        EXPECT_EQ (false, q1.empty());
-        EXPECT_EQ (true, q1.full());
-
-        q1 << 9;                        // try to insert in full queue
-        EXPECT_EQ (8UL, q1.capacity());
-        EXPECT_EQ (8UL, q1.size());
-        EXPECT_EQ (false, q1.empty());
-        EXPECT_EQ (true, q1.full());
-
-        int check_it=1;
-        for (auto it = q1.begin() ; it != q1.end() ; ++it)
-            EXPECT_EQ(*it, check_it++);
-        EXPECT_EQ(9, check_it);         // run through all
-
-        for (int i =1 ; i <= 8 ; ++i) {
-            check_it << q1;
-            EXPECT_EQ(i, check_it);
-        }
-        EXPECT_EQ (8UL, q1.capacity());
-        EXPECT_EQ (0UL, q1.size());
-        EXPECT_EQ (true, q1.empty());
-        EXPECT_EQ (false, q1.full());
-
-        q1 >> check_it;
-        EXPECT_EQ (int{}, check_it);
-    }
-
 }

test/tests/queue.cpp

@@ -109,80 +109,4 @@ namespace Tqueue {
         EXPECT_EQ (int{}, check_it);
     }
 
-
-
-    // Test construction
-     TEST(Tqueue, contruct_atomic) {
-         queue<int, 8, true> q1;
-         queue<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};
-         queue<int, 8, true> q3{1, 2, 3, 4, 5};
-
-         EXPECT_EQ (8UL, q1.capacity());
-         EXPECT_EQ (0UL, q1.size());
-         EXPECT_EQ (8UL, q2.capacity());
-         EXPECT_EQ (8UL, q2.size());
-         EXPECT_EQ (8UL, q3.capacity());
-         EXPECT_EQ (5UL, q3.size());
-     }
-
-     // base class functionality check
-     TEST(Tqueue, base_class_atomic) {
-
-         queue<int, 8, true> q1;
-
-         // Access of base class functionality
-         EXPECT_EQ (8UL, q1.capacity());
-         EXPECT_EQ (0UL, q1.size());
-         EXPECT_EQ (true, q1.empty());
-         EXPECT_EQ (false, q1.full());
-
-         q1.push(42);
-         EXPECT_EQ (42, q1.front());
-         EXPECT_EQ (42, q1.back());
-         EXPECT_EQ (42, q1.pop());
-
-         q1.push(1);
-         q1.push(2);
-         q1.push(3);
-
-         int check_it=1;
-         for (auto it = q1.begin() ; it != q1.end() ; ++it)
-             EXPECT_EQ(*it, check_it++);
-         EXPECT_EQ(4, check_it);         // run through all
-     }
-
-     // stream push-pop
-     TEST(Tqueue, stream_push_pop_atomic) {
-         queue<int, 8, true> q1;
-
-         q1 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8;
-         EXPECT_EQ (8UL, q1.capacity());
-         EXPECT_EQ (8UL, q1.size());
-         EXPECT_EQ (false, q1.empty());
-         EXPECT_EQ (true, q1.full());
-
-         q1 << 9;                        // try to insert in full queue
-         EXPECT_EQ (8UL, q1.capacity());
-         EXPECT_EQ (8UL, q1.size());
-         EXPECT_EQ (false, q1.empty());
-         EXPECT_EQ (true, q1.full());
-
-         int check_it=1;
-         for (auto it = q1.begin() ; it != q1.end() ; ++it)
-             EXPECT_EQ(*it, check_it++);
-         EXPECT_EQ(9, check_it);         // run through all
-
-         for (int i =1 ; i <= 8 ; ++i) {
-             check_it << q1;
-             EXPECT_EQ(i, check_it);
-         }
-         EXPECT_EQ (8UL, q1.capacity());
-         EXPECT_EQ (0UL, q1.size());
-         EXPECT_EQ (true, q1.empty());
-         EXPECT_EQ (false, q1.full());
-
-         q1 >> check_it;
-         EXPECT_EQ (int{}, check_it);
-     }
-
 }

test/tests/ring_iterator.cpp

@@ -228,197 +228,4 @@ namespace Tring_iterator {
         EXPECT_EQ (1, (i2 - i1));   // loop
 
     }
-
-    // Test construction atomic
-    TEST(Tring_iterator, construct_atomic) {
-        int A[10];
-
-        //default constructor
-        ring_iterator<int*, 10, true> i1;
-        EXPECT_EQ(nullptr, i1.base());
-        EXPECT_EQ(nullptr, i1.iter());
-        EXPECT_EQ(10UL, i1.size());
-
-        // implementation specific (you can remove it freely)
-        EXPECT_EQ(2*sizeof(int*), sizeof(i1));
-
-        // basic
-        ring_iterator<int*, 10, true> i2(A);
-        EXPECT_EQ(A, i2.base());
-        EXPECT_EQ(A, i2.iter());
-        EXPECT_EQ(10UL, i2.size());
-
-        // basic from assignment
-        ring_iterator<int*, 10, true> i3 = A;
-        EXPECT_EQ(A, i3.base());
-        EXPECT_EQ(A, i3.iter());
-        EXPECT_EQ(10UL, i3.size());
-
-        // basic with offset
-        ring_iterator<int*, 10, true> i4(A, 5);
-        EXPECT_EQ(A, i4.base());
-        EXPECT_EQ(&A[5], i4.iter());
-        EXPECT_EQ(10UL, i4.size());
-
-        // copy (Legacy iterator)
-        auto i5 = i2;
-        EXPECT_EQ(A, i5.base());
-        EXPECT_EQ(A, i5.iter());
-        EXPECT_EQ(10UL, i5.size());
-
-        // arbitrary type
-        struct TT { int a,b,c; };
-        std::array<TT, 10> t;
-        ring_iterator<TT*, 10, true> it(t.data(), 2);
-        EXPECT_EQ(t.begin(), it.base());
-        EXPECT_EQ(&t[2], it.iter());
-        EXPECT_EQ(10UL, it.size());
-    }
-
-    // Legacy iterator atomic
-    TEST(Tring_iterator, LegacyIterator_atomic) {
-
-        EXPECT_EQ(true, (std::is_same<int, typename ring_iterator<int*, 10, true>::value_type>::value));
-        EXPECT_EQ(true, (std::is_same<std::ptrdiff_t, typename ring_iterator<int*, 10, true>::difference_type>::value));
-        EXPECT_EQ(true, (std::is_same<int&, typename ring_iterator<int*, 10, true>::reference>::value));
-        EXPECT_EQ(true, (std::is_same<int*, typename ring_iterator<int*, 10, true>::pointer>::value));
-        EXPECT_EQ(true, (std::is_same<std::random_access_iterator_tag, typename ring_iterator<int*, 10, true>::iterator_category>::value));
-
-        int A[10] {0, 1, 2, 3, 4, 5, 6, 7, 8 , 9};
-        ring_iterator<int*, 10, true> i1(A);
-
-        // copy constructible/assignable
-        auto i2 = i1;
-        EXPECT_EQ(A, i2.base());
-        EXPECT_EQ(A, i2.iter());
-        EXPECT_EQ(10UL, i2.size());
-
-        // dereferenceable - incrementable
-        ring_iterator<int*, 10, true> i3(A);
-        EXPECT_EQ(true, (std::is_reference<decltype(*i3)>::value));
-        EXPECT_EQ(true, (std::is_same<ring_iterator<int*, 10, true>&, decltype(++i3)>::value));
-        EXPECT_EQ(true, (std::is_reference<decltype((*i3++))>::value));
-
-        // more practical
-        ring_iterator<int*, 10, true> i4(A);
-        ring_iterator<int*, 10, true> i5(A, 9);
-        EXPECT_EQ(A[0], *i4);
-        EXPECT_EQ(&A[1], (++i4).iter());
-        // check loop
-        EXPECT_EQ(A[9], *i5);
-        EXPECT_EQ(&A[0], (++i5).iter());
-    }
-
-    // Legacy input iterator atomic
-    TEST(Tring_iterator, LegacyInputIterator_atomic) {
-        int A[10] {0, 1, 2, 3, 4, 5, 6, 7, 8 , 9};
-        ring_iterator<int*, 10, true> i1(A), i2(A), i3(A, 1);
-
-        struct T { int m; };
-        T B[5] { {0}, {1}, {2}, {3}, {4}};
-        ring_iterator<T*, 5, true> it(B);
-
-        EXPECT_EQ (true, (std::is_same<bool, decltype(i1 == i2)>::value));
-        EXPECT_EQ (true, (std::is_same<bool, decltype(i1 != i2)>::value));
-        EXPECT_EQ (true, (std::is_same<int&, decltype(*i1)>::value));
-        EXPECT_EQ (true, (std::is_same<int, decltype(it->m)>::value));
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>&, decltype(++i1)>::value));
-        EXPECT_EQ (true, (std::is_same<int&, decltype(*i1++)>::value));
-
-        // more practical
-        EXPECT_EQ (true, i1 == i2);
-        EXPECT_EQ (true, i1 != i3);
-        EXPECT_EQ (0, *i1);
-        EXPECT_EQ (0, it->m);
-        EXPECT_EQ (true, (++i1 == i3));
-        EXPECT_EQ (1, *i1++);
-        EXPECT_EQ (2, *i1);
-    }
-
-    // Legacy input iterator atomic
-    TEST(Tring_iterator, LegacyOutputIterator_atomic) {
-        int A[10] {0, 1, 2, 3, 4, 5, 6, 7, 8 , 9};
-        ring_iterator<int*, 10, true> it(A);
-
-        EXPECT_EQ (true, (std::is_assignable<decltype(*it), int>::value));
-        EXPECT_EQ (true, (std::is_assignable<decltype(*it++), int>::value));
-
-        // more practical
-        *it = 42;
-        EXPECT_EQ (42, A[0]);
-        *it++ = 7;
-        EXPECT_EQ (7, A[0]);
-        EXPECT_EQ (&A[1], it.iter());
-    }
-
-    // Legacy forward iterator atomic
-    TEST(Tring_iterator, LegacyForwardIterator_atomic)
-     {
-        int A[10] {0, 1, 2, 3, 4, 5, 6, 7, 8 , 9};
-        ring_iterator<int*, 10, true> it(A);
-
-        EXPECT_EQ (0, *it++);
-        EXPECT_EQ (1, *it);
-    }
-
-    // Legacy bidirectional iterator atomic
-    TEST(Tring_iterator, LegacyBidirectionalIterator_atomic) {
-        int A[10] {0, 1, 2, 3, 4, 5, 6, 7, 8 , 9};
-        ring_iterator<int*, 10, true> it(A);
-
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>&, decltype(--it)>::value));
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>, decltype(it--)>::value));
-        EXPECT_EQ (true, (std::is_same<int&, decltype(*it--)>::value));
-
-        // more practical
-        ring_iterator<int*, 10, true> i1(A), i2(A, 9);
-        EXPECT_EQ (9, *i2--);   // check loop also
-        EXPECT_EQ (8, *i2);
-        EXPECT_EQ (0, *i1--);   // check loop also
-        EXPECT_EQ (9, *i1);
-    }
-
-    // Legacy random access iterator atomic
-    TEST(Tring_iterator, LegacyRandomAccessIterator_atomic) {
-        int A[10] {0, 1, 2, 3, 4, 5, 6, 7, 8 , 9};
-        ring_iterator<int*, 10, true> it1(A), it2(A, 7);
-
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>&, decltype(it1 += 7)>::value));
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>, decltype(it1 + 7)>::value));
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>, decltype(7 + it1)>::value));
-
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>&, decltype(it1 -= 7)>::value));
-        EXPECT_EQ (true, (std::is_same<ring_iterator<int*, 10, true>, decltype(it1 - 7)>::value));
-
-        EXPECT_EQ (true, (std::is_same<std::ptrdiff_t, decltype(it1 - it2)>::value));
-        EXPECT_EQ (true, (std::is_same<int&, decltype(it1[7])>::value));
-
-        EXPECT_EQ (true, (std::is_same<bool, decltype(it1 < it2)>::value));
-        EXPECT_EQ (true, (std::is_same<bool, decltype(it1 > it2)>::value));
-        EXPECT_EQ (true, (std::is_same<bool, decltype(it1 <= it2)>::value));
-        EXPECT_EQ (true, (std::is_same<bool, decltype(it1 >= it2)>::value));
-
-        // more practical
-        ring_iterator<int*, 10, true> i1(A), i2(A);
-        i1 += 7;
-        EXPECT_EQ (7, *i1);
-        i1 -= 7;
-        EXPECT_EQ (0, *i1);
-        i1 += 11;
-        EXPECT_EQ (1, *i1);
-        i1 -= 2;
-        EXPECT_EQ (9, *i1);
-
-        EXPECT_EQ (7, *(i2+7));
-        EXPECT_EQ (7, *(7+i2));
-        EXPECT_EQ (1, *(i2+11));
-        EXPECT_EQ (1, *(11+i2));
-        EXPECT_EQ (7, *(i1-2));
-        EXPECT_EQ (8, *(i2-2));
-
-        EXPECT_EQ (9, (i1 - i2));
-        EXPECT_EQ (1, (i2 - i1));   // loop
-
-    }
-
 }

test/tests/sequencer.cpp

@@ -33,26 +33,18 @@
 namespace test_sequencer {
    using namespace tbx;
 
-   struct seq_cont_t {
+   // Sequencer implementer mock
+   class Seq : public sequencer_t<Seq, char, 128> {
        const char *msg_[10] = {
            "", "", "", "\r\nOK\r\n",
            "", "", "+CCLK = \"21/08/26-12:16:30+12\"\r\nOK\r\n"
            "", "", "\r\nERROR\r\n"
        };
-       using value_type = char;
-       using range_t    = range<const char*>;
-   };
-   seq_cont_t seq_cont;
-
-   // Sequencer implementer mock
-   class Seq : public sequencer<Seq, seq_cont_t, char, 128> {
-           using range_t    = typename seq_cont_t::range_t;
-
        public:
            size_t get(char* data) {
                static int msg =0;
-               size_t len = strlen(seq_cont.msg_[msg]);
+               size_t len = strlen(msg_[msg]);
-               strcpy(data, seq_cont.msg_[msg++]);
+               strcpy(data, msg_[msg++]);
                if (msg >= 10) msg =0;
                return len;
            }
@@ -60,14 +52,12 @@ namespace test_sequencer {
                (void)*data;
                return n;
            }
-           const range_t contents () const {
-               return range_t {&seq_cont.msg_[6][0], &seq_cont.msg_[6][5]};
-           }
            clock_t clock() { static clock_t t=0; return ++t; }
 
-           static void my_handler (const char* data, size_t size) {
+           static status_t my_handler (const char* data, size_t size) {
                (void)*data;
                (void)size;
+               return Seq::status_t::OK;
            }
    };
 
@@ -76,37 +66,37 @@ namespace test_sequencer {
     */
    TEST(Tsequencer, run_delay) {
        Seq s;
-       const std::array<Seq::record_t<1>, 1> script = {{
+       const std::array<Seq::record_t, 1> script = {{
            /* 0 */{Seq::control_t::NOP,  {"", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000}
        }};
-       EXPECT_EQ (s.run(script), true);
+       EXPECT_EQ ((int)Seq::status_t::OK, (int)s.run(script));
    }
 
    TEST(Tsequencer, run_dummy_output) {
        Seq s;
-       const std::array<Seq::record_t<1>, 2> script = {{
+       const std::array<Seq::record_t, 2> script = {{
            /* 0 */{Seq::control_t::SEND, {"", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
            /* 1 */{Seq::control_t::SEND, {"", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000}
        }};
-       EXPECT_EQ (s.run(script), true);
+       EXPECT_EQ ((int)Seq::status_t::OK, (int)s.run(script));
    }
 
    TEST(Tsequencer, run_exits) {
        Seq s;
-       const std::array<Seq::record_t<1>, 1> script1 = {{
+       const std::array<Seq::record_t, 1> script1 = {{
            /* 0 */{Seq::control_t::SEND, {"", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000},
        }};
-       EXPECT_EQ (s.run(script1), true);
+       EXPECT_EQ ((int)Seq::status_t::OK, (int)s.run(script1));
 
-       const std::array<Seq::record_t<1>, 1> script2 = {{
+       const std::array<Seq::record_t, 1> script2 = {{
            /* 0 */{Seq::control_t::SEND, {"", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_ERROR, 0}, 1000},
        }};
-       EXPECT_EQ (s.run(script2), false);
+       EXPECT_EQ ((int)Seq::status_t::ERROR, (int)s.run(script2));
    }
 
    TEST(Tsequencer, run_sequence) {
        Seq s;
-       const std::array<Seq::record_t<2>, 9> script = {{
+       const std::array<Seq::record_t, 8> script = {{
            /* 0 */{Seq::control_t::NOP,  {"",         Seq::match_t::NO, nullptr, Seq::action_t::GOTO, 1}, 1000},
            /* 1 */{Seq::control_t::SEND, {"ATE0\r\n", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
            /* 2 */{Seq::control_t::EXPECT, {{
@@ -114,25 +104,20 @@ namespace test_sequencer {
                        {"ERROR",  Seq::match_t::CONTAINS,    nullptr, Seq::action_t::EXIT_ERROR, 0} }},
                        1000
            },
-           /* 3 */{Seq::control_t::DETECT, {{
+           /* 3 */{Seq::control_t::SEND, {"AT+CCLK?", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
-                       {"+CCLK",  Seq::match_t::CONTAINS,   nullptr,  Seq::action_t::NEXT, 0},
+           /* 4 */{Seq::control_t::EXPECT, {{
-                       {"ERROR",  Seq::match_t::CONTAINS,   nullptr,  Seq::action_t::EXIT_ERROR, 0} }},
-                       1000
-           },
-           /* 4 */{Seq::control_t::SEND, {"AT+CCLK?", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
-           /* 5 */{Seq::control_t::EXPECT, {{
                        {"OK\r\n", Seq::match_t::ENDS_WITH,   Seq::my_handler, Seq::action_t::NEXT, 0},
                        {"ERROR",  Seq::match_t::CONTAINS,    nullptr, Seq::action_t::EXIT_ERROR, 0} }},
                        1000
            },
-           /* 6 */{Seq::control_t::SEND, {"AT+CT?", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
+           /* 5 */{Seq::control_t::SEND, {"AT+CT?", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
-           /* 7 */{Seq::control_t::EXPECT, {{
+           /* 6 */{Seq::control_t::EXPECT, {{
                        {"OK\r\n", Seq::match_t::ENDS_WITH,   nullptr, Seq::action_t::NEXT, 0},
                        {"ERROR",  Seq::match_t::CONTAINS,    nullptr, Seq::action_t::EXIT_ERROR, 0} }},
                        1000
            },
-           /* 8 */{Seq::control_t::SEND, {"AT+POWD=0", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000}
+           /* 7 */{Seq::control_t::SEND, {"AT+POWD=0", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000}
        }};
-       EXPECT_EQ (s.run(script), false);
+       EXPECT_EQ ((int)Seq::status_t::ERROR, (int)s.run(script));
    }
 }

test/tests/span.cpp

@@ -1,274 +0,0 @@
-/*!
- * \file span.cpp
- * \brief
- *      Unit tests for span
- *
- * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net>
- *
- * <dl class=\"section copyright\"><dt>License</dt><dd>
- * The MIT License (MIT)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * </dd></dl>
- *
- */
-#include <cont/span.h>
-#include <gtest/gtest.h>
-
-#include <cont/deque.h>
-#include <vector>
-#include <type_traits>
-
-// tests from https://github.com/tcbrindle/span/blob/master/test/test_span.cpp
-
-namespace test_span {
-   using namespace tbx;
-
-   TEST (Tspan, default_constructors) {
-       EXPECT_EQ (true, ( std::is_nothrow_default_constructible<span<int>>::value));
-       EXPECT_EQ (true, ( std::is_nothrow_default_constructible<span<int, 0>>::value));
-       EXPECT_EQ (true, (!std::is_nothrow_default_constructible<span<int, 42>>::value));
-
-       constexpr span<int> s1{};
-
-       EXPECT_EQ (0UL, s1.size());
-       EXPECT_EQ (nullptr, s1.data());
-       EXPECT_EQ (s1.begin(), s1.end());
-
-       constexpr span<int, 0> s2{};
-
-       EXPECT_EQ (0UL, s2.size());
-       EXPECT_EQ (nullptr, s2.data());
-       EXPECT_EQ (s2.begin(), s2.end());
-   }
-
-   TEST (Tspan, pointer_constructors) {
-       // pointer length
-       EXPECT_EQ (true, (std::is_constructible<span<int>, int*, int>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<const int>, int*, int>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<const int>, const int*, int>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<int, 42>, int*, int>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<const int, 42>, int*, int>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<const int, 42>, const int*, int>::value));
-
-       int arr[] = {1, 2, 3};
-
-       // dynamic size
-       span<int> s1(arr, 3);
-       EXPECT_EQ (3UL, s1.size());
-       EXPECT_EQ (arr, s1.data());
-       EXPECT_EQ (std::begin(arr), s1.begin());
-       EXPECT_EQ (std::end(arr), s1.end());
-
-       // fixed size
-       span<int, 3> s2(arr, 3);
-       EXPECT_EQ (3UL, s2.size());
-       EXPECT_EQ (arr, s2.data());
-       EXPECT_EQ (std::begin(arr), s2.begin());
-       EXPECT_EQ (std::end(arr), s2.end());
-
-       // pointer pointer
-       EXPECT_EQ (true, (std::is_constructible<span<int>, int*, int*>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<float>, float*, float*>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<int, 42>, int*, int*>::value));
-       EXPECT_EQ (true, (std::is_constructible<span<float, 42>, float*, float*>::value));
-
-       // dynamic size
-       span<int> s3(arr, arr + 3);
-       EXPECT_EQ (3UL, s3.size());
-       EXPECT_EQ (arr, s3.data());
-       EXPECT_EQ (std::begin(arr), s3.begin());
-       EXPECT_EQ (std::end(arr), s3.end());
-
-       // fixed size
-       span<int, 3> s4(arr, arr + 3);
-       EXPECT_EQ (3UL, s4.size());
-       EXPECT_EQ (arr, s4.data());
-       EXPECT_EQ (std::begin(arr), s4.begin());
-       EXPECT_EQ (std::end(arr), s4.end());
-   }
-
-   TEST (Tspan, C_array_constructors) {
-       using int_array_t = int[3];
-       using float_array_t = float[3];
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<int>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int>, float_array_t>::value));
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int>, int_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int>, float_array_t>::value));
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<int, 3>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 3>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 3>, float_array_t&>::value));
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int, 3>, int_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int, 3>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 3>, float_array_t>::value));
-
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 42>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 42>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 42>, float_array_t&>::value));
-
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 42>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 42>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 42>, float_array_t&>::value));
-
-       int arr[] = {1, 2, 3};
-
-       // non-const dynamic size
-       span<int> s1{arr};
-       EXPECT_EQ (s1.size(), 3UL);
-       EXPECT_EQ (s1.data(), arr);
-       EXPECT_EQ (s1.begin(), std::begin(arr));
-       EXPECT_EQ (s1.end(), std::end(arr));
-
-       // non-const dynamic size
-       span<const int> s2{arr};
-       EXPECT_EQ (s2.size(), 3UL);
-       EXPECT_EQ (s2.data(), arr);
-       EXPECT_EQ (s2.begin(), std::begin(arr));
-       EXPECT_EQ (s2.end(), std::end(arr));
-
-       // non-const fixed size
-       span<int, 3> s3{arr};
-       EXPECT_EQ (s3.size(), 3UL);
-       EXPECT_EQ (s3.data(), arr);
-       EXPECT_EQ (s3.begin(), std::begin(arr));
-       EXPECT_EQ (s3.end(), std::end(arr));
-
-       // non-const fixed size
-       span<const int, 3> s4{arr};
-       EXPECT_EQ (s4.size(), 3UL);
-       EXPECT_EQ (s4.data(), arr);
-       EXPECT_EQ (s4.begin(), std::begin(arr));
-       EXPECT_EQ (s4.end(), std::end(arr));
-   }
-
-   TEST (Tspan, array_constructors) {
-       using int_array_t = std::array<int, 3>;
-       using float_array_t = std::array<float, 3>;
-       using zero_array_t = std::array<int, 0>;
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<int>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int>, float_array_t>::value));
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int>, int_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int>, float_array_t const&>::value));
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<int, 3>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 3>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 3>, float_array_t>::value));
-
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int, 3>, int_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_nothrow_constructible<span<const int, 3>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 3>, float_array_t const&>::value));
-
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 42>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 42>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 42>, float_array_t const&>::value));
-
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 42>, int_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 42>, int_array_t const&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<const int, 42>, float_array_t&>::value));
-
-       EXPECT_EQ (true, ( std::is_constructible<span<int>, zero_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int>, const zero_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_constructible<span<const int>, zero_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_constructible<span<const int>, const zero_array_t&>::value));
-
-       EXPECT_EQ (true, ( std::is_constructible<span<int, 0>, zero_array_t&>::value));
-       EXPECT_EQ (true, (!std::is_constructible<span<int, 0>, const zero_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_constructible<span<const int, 0>, zero_array_t&>::value));
-       EXPECT_EQ (true, ( std::is_constructible<span<const int, 0>, const zero_array_t&>::value));
-
-
-       int_array_t arr = {1, 2, 3};
-
-       // non-const, dynamic size
-       span<int> s1{arr};
-       EXPECT_EQ(s1.size(), 3UL);
-       EXPECT_EQ(s1.data(), arr.data());
-       EXPECT_EQ(s1.begin(), arr.data());
-       EXPECT_EQ(s1.end(), arr.data() + 3);
-
-
-       //const, dynamic size
-       span<int const> s2{arr};
-       EXPECT_EQ(s2.size(), 3UL);
-       EXPECT_EQ(s2.data(), arr.data());
-       EXPECT_EQ(s2.begin(), arr.data());
-       EXPECT_EQ(s2.end(), arr.data() + 3);
-
-
-       // non-const, static size
-       span<int, 3> s3{arr};
-       EXPECT_EQ(s3.size(), 3UL);
-       EXPECT_EQ(s3.data(), arr.data());
-       EXPECT_EQ(s3.begin(), arr.data());
-       EXPECT_EQ(s3.end(), arr.data() + 3);
-
-       // const, dynamic size
-       span<int const, 3> s4{arr};
-       EXPECT_EQ(s4.size(), 3UL);
-       EXPECT_EQ(s4.data(), arr.data());
-       EXPECT_EQ(s4.begin(), arr.data());
-       EXPECT_EQ(s4.end(), arr.data() + 3);
-   }
-
-//   TEST (Tspan, containter_constructors) {
-//       using container_t = tbx::deque<int, 3>;
-//
-//       EXPECT_EQ (true, ( std::is_constructible<span<int>, container_t&>::value));
-//       EXPECT_EQ (true, (!std::is_constructible<span<int>, const container_t&>::value));
-//
-//       EXPECT_EQ (true, ( std::is_constructible<span<const int>, container_t&>::value));
-//       EXPECT_EQ (true, ( std::is_constructible<span<const int>, const container_t&>::value));
-//
-//       EXPECT_EQ (true, (!std::is_constructible<span<int, 3>, container_t&>::value));
-//       EXPECT_EQ (true, (!std::is_constructible<span<int, 3>, const container_t&>::value));
-//
-//       EXPECT_EQ (true, (!std::is_constructible<span<const int, 3>, container_t&>::value));
-//       EXPECT_EQ (true, (!std::is_constructible<span<const int, 3>, const container_t&>::value));
-//
-//       container_t cont = {1, 2, 3};
-//       const container_t ccont = {1, 2, 3};
-//
-//       // non-const, dynamic size
-//       span<int> s1(cont);
-//       EXPECT_EQ(s1.size(), 3UL);
-//       EXPECT_EQ(s1.data(), cont.data());
-//       EXPECT_EQ(s1.begin(), cont.data());
-//       EXPECT_EQ(s1.end(), cont.data() + 3);
-//
-//
-//       //const, dynamic size
-//       span<int const> s2(cont);
-//       EXPECT_EQ(s2.size(), 3UL);
-//       EXPECT_EQ(s2.data(), cont.data());
-//       EXPECT_EQ(s2.begin(), cont.data());
-//       EXPECT_EQ(s2.end(), cont.data() + 3);
-//
-//   }
-
-}