WIP: sequencer/BG95 driver

.gitmodules

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

include/cont/deque.h

@@ -33,8 +33,10 @@
 
 #include <core/core.h>
 #include <core/ring_iterator.h>
+#include <cont/range.h>
 
 #include <array>
+#include <atomic>
 
 namespace tbx {
 
@@ -50,16 +52,21 @@ namespace tbx {
  * We use a ring buffer of size \c N+1. We start the front iterator at the last location of the buffer
  * and the rear on the first. This way when the queue is full the iterators are pointing to the same location.
  *
- * \tparam Data_t   The char-like queued item type. Usually \c char
- * \tparam N        The size of deque
+ * \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>
+template <typename Data_t, size_t N, bool SemiAtomic =false>
 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>;
+        using iterator_t        = ring_iterator<Data_t*, N+1, SemiAtomic>;
+        using range_t           = range<iterator_t>;
 
         // STL
         using value_type        = Data_t;
@@ -103,9 +110,9 @@ class deque {
     //! \name Iterators
     //! @{
     public:
-        constexpr iterator begin() noexcept               { return f+1; }
-        constexpr const_iterator begin() const noexcept   { return f+1; }
-        constexpr const_iterator cbegin() const noexcept  { return f+1; }
+        constexpr iterator begin() noexcept               { iterator ret = f; return ++ret; }
+        constexpr const_iterator begin() const noexcept   { iterator ret = f; return ++ret; }
+        constexpr const_iterator cbegin() const noexcept  { iterator ret = f; return ++ret; }
 
         constexpr iterator end() noexcept                 { return r; }
         constexpr const_iterator end() const noexcept     { return r; }
@@ -115,9 +122,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                { return f+1; }
-        constexpr const_reverse_iterator rend() const noexcept    { return f+1; }
-        constexpr const_reverse_iterator crend() const noexcept   { return f+1; }
+        constexpr reverse_iterator rend() noexcept                { reverse_iterator ret = f; return ++ret; }
+        constexpr const_reverse_iterator rend() const noexcept    { reverse_iterator ret = f; return ++ret; }
+        constexpr const_reverse_iterator crend() const noexcept   { reverse_iterator ret = f; return ++ret; }
     //! @}
 
     //! \name Capacity
@@ -127,6 +134,9 @@ 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.
@@ -134,7 +144,11 @@ 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 { return (r == f) ? true : false; }
+        constexpr bool   full()     noexcept {
+            if constexpr (SemiAtomic)
+                std::atomic_thread_fence(std::memory_order_acquire);
+            return (r == f) ? true : false;
+        }
     //! @}
 
     //! \name Member access
@@ -145,41 +159,65 @@ 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 { return *(f+1); }
-        constexpr const Data_t& front() const noexcept { return *(f+1); }
+        constexpr Data_t& front() noexcept { iterator_t it = f; return *++it; }
+        constexpr const Data_t& front() const noexcept { iterator_t it = f; return *++it; }
 
         //! \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 { return *(r-1); }
-        constexpr const Data_t& back() const noexcept { return *(r-1); }
+        constexpr Data_t& back() noexcept { iterator_t it = r; return *--it; }
+        constexpr const Data_t& back() const noexcept { iterator_t it = r; return *--it; }
+
+        //! \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

@@ -55,17 +55,22 @@ namespace tbx {
  *  pushed or popped from the deque. If the criteria match we call call the callable of type
  *    \c Fn
  *
- * \tparam Data_t   The char-like queued item type. Usually \c char
- * \tparam N        The size of edeque
- * \tparam Fn       The type of Callable
+ * \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, typename Fn = std::function<void()>>
-class edeque : public deque<Data_t, N> {
+template <typename Data_t, size_t N, bool SemiAtomic =false, typename Fn = std::function<void()>>
+class edeque : public deque<Data_t, N, SemiAtomic> {
     public:
         // meta-identity types
-        using type                  = edeque<Data_t, N>;
-        using base_type             = deque<Data_t, N>;
+        using type                  = edeque<Data_t, N, SemiAtomic, Fn>;
+        using base_type             = deque<Data_t, N, SemiAtomic>;
         using callable_t            = Fn;
+        using range_t               = typename base_type::range_t;
 
         // STL
         using value_type            = typename base_type::value_type;
@@ -89,7 +94,11 @@ class edeque : public deque<Data_t, N> {
         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, MISMATCH};
+        enum class data_match { DISABLED =0, MATCH_PUSH, MATCH_POP, MISMATCH_PUSH, MISMATCH_POP};
+
+//        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 {
@@ -120,7 +129,7 @@ class edeque : public deque<Data_t, N> {
         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},
@@ -128,7 +137,7 @@ class edeque : public deque<Data_t, N> {
             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},
@@ -186,25 +195,25 @@ class edeque : public deque<Data_t, N> {
     //! @{
         void push_front (const Data_t& it) {
             base_type::push_front(it);
-            check_trigger_async_(it);
+            check_trigger_push_async_(it);
         }
         Data_t pop_front () {
             Data_t t = base_type::pop_front();
-            check_trigger_async_(t);
+            check_trigger_pop_async_(t);
             return t;
         }
         void push_back (const Data_t& it) {
             base_type::push_back(it);
-            check_trigger_async_(it);
+            check_trigger_push_async_(it);
         }
         Data_t pop_back () {
             Data_t t = base_type::pop_back();
-            check_trigger_async_(t);
+            check_trigger_pop_async_(t);
             return t;
         }
     //! @}
 
-    //! \name Public interface
+    //! \name Private functionality
     //! @{
     private:
         //! \brief
@@ -230,28 +239,53 @@ class edeque : public deque<Data_t, N> {
         }
 
         //! \brief
-        //!     Manually checks the data trigger and calls it we have match.
+        //!     Manually checks the data trigger on push and calls it we have match.
         //! \param  it  The item to check against
         //! \return     True if the callable has called.
-        bool check_trigger_value_ (const Data_t& it) {
+        bool check_trigger_push_value_ (const Data_t& it) {
             bool match;
             switch (trigger_.tdata.type) {
                 default:
-                case data_match::DISABLED:  match = false;  break;
-                case data_match::MATCH:     match = (it == trigger_.tdata.value); break;
-                case data_match::MISMATCH:  match = (it != trigger_.tdata.value); break;
+                case data_match::DISABLED:      match = false;  break;
+                case data_match::MATCH_PUSH:    match = (it == trigger_.tdata.value); break;
+                case data_match::MISMATCH_PUSH: match = (it != trigger_.tdata.value); break;
             }
             if (match)
                 callback_();
             return match;
         }
 
-        //! Wrapper for both triggers
-        bool check_trigger_async_ (const Data_t& it) {
+        //! \brief
+        //!     Manually checks the data trigger on pop and calls it we have match.
+        //! \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_value_(it);
+                case match_mode::DATA:  return check_trigger_push_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

@@ -49,16 +49,20 @@ namespace tbx {
  *
  * We also provide stream operators.
  *
- * \tparam Data_t   The char-like queued item type. Usually \c char
- * \tparam N        The size of edeque
- * \tparam Fn       The type of Callable
+ * \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, typename Fn = std::function<void()>>
-class equeue : public edeque<Data_t, N, Fn> {
+template <typename Data_t, size_t N, bool SemiAtomic =false, typename Fn = std::function<void()>>
+class equeue : public edeque<Data_t, N, SemiAtomic, Fn> {
     public:
         // meta-identity types
-        using equeue_t              = equeue<Data_t, N>;
-        using base_type             = edeque<Data_t, N, Fn>;
+        using equeue_t              = equeue<Data_t, N, SemiAtomic, Fn>;
+        using base_type             = edeque<Data_t, N, SemiAtomic, Fn>;
+        using range_t               = typename base_type::range_t;
 
         // STL
         using value_type            = typename base_type::value_type;
@@ -77,10 +81,7 @@ class equeue : public edeque<Data_t, N, Fn> {
         //! Default constructor
         constexpr equeue () noexcept : base_type() { }
 
-        //! fill contructor
-        constexpr equeue(const Data_t& value) noexcept : base_type(value) { }
-
-        //! Initializer list contructor
+        //! Forward constructor
         template <typename ...It>
         constexpr equeue(It&& ...it) noexcept : base_type(std::forward<It>(it)...) { }
 
@@ -125,16 +126,17 @@ class equeue : public edeque<Data_t, N, Fn> {
  *
  *  This definition enables the "data << equeue" syntax for pop operation
  *
- *  \tparam Data_t  The char-like queued item type. Usually \c char
- *  \tparam N       The size of queue
- *  \tparam Fn      The type of Callable
+ *  \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, typename Fn = std::function<void()>>
-Data_t& operator<< (Data_t& it, equeue<Data_t, N, Fn>& q) {
+template <typename Data_t, size_t N, bool SemiAtomic =false, typename Fn = std::function<void()>>
+Data_t& operator<< (Data_t& it, equeue<Data_t, N, SemiAtomic, Fn>& q) {
     it = q.pop();
     return it;
 }

include/cont/queue.h

@@ -48,15 +48,19 @@ namespace tbx {
  *
  * We also provide stream operators.
  *
- * \tparam Data_t   The char-like queued item type. Usually \c char
- * \tparam N        The size of queue
+ * \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>
-class queue : public deque<Data_t, N> {
+template <typename Data_t, size_t N, bool SemiAtomic =false>
+class queue : public deque<Data_t, N, SemiAtomic> {
     public:
         // meta-identity types
-        using queue_t               = queue<Data_t, N>;
-        using base_type             = deque<Data_t, N>;
+        using queue_t               = queue<Data_t, N, SemiAtomic>;
+        using base_type             = deque<Data_t, N, SemiAtomic>;
+        using range_t               = typename base_type::range_t;
 
         // STL
         using value_type            = typename base_type::value_type;
@@ -121,15 +125,16 @@ class queue : public deque<Data_t, N> {
  *
  *  This definition enables the "data << queue" syntax for pop operation
  *
- *  \tparam Data_t  The char-like queued item type. Usually \c char
- *  \tparam N       The size of queue
+ *  \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>
-constexpr Data_t& operator<< (Data_t& it, queue<Data_t, N>& q) {
+template <typename Data_t, size_t N, bool SemiAtomic =false>
+constexpr Data_t& operator<< (Data_t& it, queue<Data_t, N, SemiAtomic>& q) {
     it = q.pop();
     return it;
 }

include/cont/range.h

@@ -0,0 +1,64 @@
+/*!
+ * \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

@@ -0,0 +1,607 @@
+/*
+ * 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,10 +35,11 @@
 
 #include <iterator>
 #include <type_traits>
+#include <atomic>
 
 namespace tbx {
 
-template<typename Iter_t, size_t N>
+template<typename Iter_t, size_t N, bool Atomic=false>
 class ring_iterator {
     //! \name STL iterator traits "forwarding"
     //! @{
@@ -164,6 +165,9 @@ 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_;
@@ -226,6 +230,214 @@ 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

@@ -0,0 +1,321 @@
+/*!
+ * \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,14 +34,19 @@
 
 #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_t
+ * \class sequencer
  * \brief
  *      A CRTP base class to provide the sequencer functionality.
  *
@@ -59,14 +64,26 @@ 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 Data_t, size_t N>
-class sequencer_t {
+template <typename Impl_t, typename Cont_t, typename Data_t, size_t N>
+class sequencer {
     _CRTP_IMPL(Impl_t);
 
-    using str_view_t = std::basic_string_view<Data_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
     //! @{
@@ -88,8 +105,18 @@ class sequencer_t {
         //! \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
-            EXPECT  //!< Expects data from implementation
+            SEND,   //!< Send data to implementation through put()
+            EXPECT, //!< Expects data from implementation via get()
+            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
@@ -102,18 +129,18 @@ class sequencer_t {
          *  Match handler function pointer type.
          *  Expects a pointer to buffer and a size and returns status
          */
-        using handler_ft = status_t (*) (const Data_t*, size_t);
+        using handler_ft = void (*) (const Data_t*, size_t);
 
         /*!
-         * \struct block_t
+         * \struct handle_t
          * \brief
-         *      The script line block.
+         *      The script record handle block.
          *
-         * Each script "line" contains up to 2 blocks for matching functionality. Each block
+         * Each script record contains some 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 block_t {
+        struct handle_t {
             std::basic_string_view<Data_t>
                                 token;          //!< The token for the match
             match_t             match_type;     //!< The matching type functionality
@@ -129,6 +156,19 @@ class sequencer_t {
          *
          * 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
@@ -144,11 +184,8 @@ class sequencer_t {
          *  }};
          * \endcode
          */
-        struct record_t {
-            control_t               control;    //!< The type of the entry
-            std::array<block_t, 2>  block;      //!< The matching block
-            clock_t                 timeout;    //!< Timeout in CPU time
-        };
+        template <size_t Nrecords, size_t Nhandles =2>
+        using script_t = std::array<record_t<Nhandles>, Nrecords>;
     //! @}
 
 
@@ -156,10 +193,10 @@ class sequencer_t {
     //! \name Constructor / Destructor
     //!@{
     protected:
-       ~sequencer_t () = default;                               //!< \brief Allow destructor from derived only
-       sequencer_t () = default;                                //!< \brief A default constructor from derived only
-       sequencer_t(const sequencer_t&) = delete;                //!< No copies
-       sequencer_t& operator= (const sequencer_t&) = delete;    //!< No copy assignments
+       ~sequencer () = default;                               //!< \brief Allow destructor from derived only
+       sequencer () = default;                                //!< \brief A default constructor from derived only
+       sequencer(const sequencer&) = delete;                //!< No copies
+       sequencer& operator= (const sequencer&) = delete;    //!< No copy assignments
     //!@}
 
     //! \name Sequencer interface requirements for implementer
@@ -167,6 +204,7 @@ class sequencer_t {
     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(); }
     //! @}
 
@@ -180,7 +218,7 @@ class sequencer_t {
         * \param prefix     What we search
         * \return           True on success, false otherwise
         */
-       bool starts_with_ (const str_view_t stream, const str_view_t prefix) {
+       static bool starts_with_ (const str_view_t stream, const str_view_t prefix) {
            return (stream.rfind(prefix, 0) != str_view_t::npos);
        }
 
@@ -191,7 +229,9 @@ class sequencer_t {
         * \param postfix    What we search
         * \return           True on success, false otherwise
         */
-       bool ends_with_ (const str_view_t stream, const str_view_t postfix) {
+       static 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(),
@@ -207,7 +247,7 @@ class sequencer_t {
         * \param needle     What we search
         * \return           True on success, false otherwise
         */
-       bool contains_ (const str_view_t haystack, const str_view_t needle) {
+       static bool contains_ (const str_view_t haystack, const str_view_t needle) {
            return (haystack.find(needle) != str_view_t::npos);
        }
        /*!
@@ -221,7 +261,7 @@ class sequencer_t {
         * \param go_idx         The new value of the step in the case of GOTO type
         * \return               The new sequencer's step value
         */
-       size_t step_ (size_t current_idx, action_t action, size_t go_idx =0) {
+       static 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;
@@ -232,6 +272,27 @@ class sequencer_t {
                                     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.
@@ -241,7 +302,7 @@ class sequencer_t {
         * \param needle     The stream we search
         * \return           True on match
         */
-       bool match_(match_t type, const str_view_t haystack, const str_view_t needle) {
+       static bool match (const str_view_t haystack, const str_view_t needle, match_t type) {
            switch (type) {
                default:
                case match_t::NO:            return true;
@@ -253,10 +314,25 @@ class sequencer_t {
                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
@@ -264,28 +340,38 @@ class sequencer_t {
         * 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 block's token to send and executes the action after that.
+        * - If the entry is \c SEND it uses the first handle 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 blocks match.
+        *   of the handle blocks match.
         *   On match:
         *     - Calls the handler if there is one
         *     - Executes the action
-        *     - Skips the next block if there is one
+        *     - Skips the next handle blocks if there is any.
+        *   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>
-       status_t run (const std::array<record_t, Steps>& script) {
+       template <size_t Steps, size_t Nhandles>
+       bool run (const script_t<Steps, Nhandles>& 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& it = script[step];
+               const record_t<Nhandles>& it = script[step];
 
                if (step != p_step) {
                    p_step = step;
@@ -294,64 +380,63 @@ class sequencer_t {
                switch (it.control) {
                    default:
                    case control_t::NOP:
-                       if ((clock_() - mark) >= it.timeout) {
-                           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;
-                           }
-                       }
+                       if ((clock_() - mark) >= it.timeout)
+                           status = action_ (step, it.block[0]);
                        break;
 
                    case control_t::SEND:
-                       put_(it.block[0].token.data(), it.block[0].token.size());
-                       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;
-                       }
+                	   if (put_(it.block[0].token.data(), it.block[0].token.size()) != it.block[0].token.size())
+                	       return false;
+                       status = action_ (step, it.block[0]);
                        break;
 
                    case control_t::EXPECT:
                        resp_size = get_(buffer);
                        if (resp_size) {
                            for (auto& block : it.block) {
-                               if (match_(block.match_type, buffer, block.token)) {
-                                   if (block.handler != nullptr)
-                                       block.handler(buffer, resp_size);
-                                   switch (block.action) {
-                                       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;
-                                   }
+                               if (match(
+                                       {buffer, resp_size},
+                                       block.token,
+                                       block.match_type)) {
+                                   status = action_ (step, block, {buffer, resp_size});
                                    break;
                                }
                            }
                        }
-                       if ((clock_() - mark) >= it.timeout)
-                           return status_t::ERROR;
+                       if (it.timeout && (clock_() - mark) >= it.timeout)
+                           return false;
+                       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_t::OK;
+           return (status == status_t::OK);
        }
 };
 
 /*!
  * An "empty" block for convenience.
  */
-template <typename Impl_t, typename Data_t, size_t N>
-constexpr typename sequencer_t<Impl_t, Data_t, N>::block_t Sequencer_null_block = {
+template <typename Impl_t, typename Cont_t, typename Data_t, size_t N>
+constexpr typename sequencer<Impl_t, Cont_t, Data_t, N>::handle_t Sequencer_null_block = {
     "",
-    sequencer_t<Impl_t, Data_t, N>::match_t::NO,
+    sequencer<Impl_t, Cont_t, Data_t, N>::match_t::NO,
     nullptr,
-    sequencer_t<Impl_t, Data_t, N>::action_t::NO,
+    sequencer<Impl_t, Cont_t, Data_t, N>::action_t::NO,
     0
 };
 

test/.gitignore

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

test/Makefile

@@ -85,7 +85,9 @@ 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
 
@@ -104,10 +106,13 @@ ODUMP           := objdump
 OCOPY           := objcopy
 
 # Compiler flags for debug and release
-DEB_CFLAGS      := -std=c++17 -DDEBUG -g3 -Wall -Wextra
-REL_CFLAGS      := -std=c++17 -Wall -Wextra -O2
+DEB_CFLAGS      := -std=gnu++17 -DDEBUG -g3 -Wall -Wextra -fmessage-length=0
+REL_CFLAGS      := -std=gnu++17 -g3 -Wall -Wextra -O2 -fmessage-length=0
 # Pre-defines
-# PRE_DEFS := MYCAB=1729 SUPER_MODE
+PRE_DEFS        :=
+ifeq ($(OS), Windows_NT)
+	PRE_DEFS    += WIN_TRHEADS
+endif
 
 # ============== Linker settings ==============
 # Linker flags
@@ -183,8 +188,8 @@ $(BUILD_DIR)/$(TARGET): $(OBJ)
 	@mkdir -p $(@D)
 	@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) $(ODUMP) -h -S $(BUILD_DIR)/$(TARGET) > $(BUILD_DIR)/$(basename $(TARGET)).list
+#	$(DOCKER) $(OCOPY) -O ihex $(BUILD_DIR)/$(TARGET) $(BUILD_DIR)/$(basename $(TARGET)).hex
 	@echo
 	@echo Print size information
 	@$(CSIZE) $(@D)/$(TARGET)
@@ -217,8 +222,8 @@ build-clang: $(BUILD_DIR)/$(TARGET)
 debug: $(BUILD_DIR)/$(TARGET)
 
 .PHONY: release
-release: CFLAGS := $(REL_FLAGS)
-release: clean $(BUILD_DIR)/$(TARGET)
+release: CFLAGS := $(REL_CFLAGS)
+release: $(BUILD_DIR)/$(TARGET)
 
 .PHONY: all
 all: clean release

test/main.cpp

@@ -26,9 +26,191 @@
  *
  */
 #include <gtest/gtest.h>
+#include <exception>
 
-GTEST_API_ int main(int argc, char **argv) {
+//#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
+//
+//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

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

test/tests/BG95_base.cpp

@@ -0,0 +1,270 @@
+/*!
+ * \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,12 +29,44 @@
  *
  */
 #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;
@@ -192,5 +224,190 @@ 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 deque
+ *      Unit tests for edeque
  *
  * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net>
  *
@@ -33,7 +33,7 @@
 
 #include <functional>
 
-namespace Tdeque {
+namespace Tedeque {
     using namespace tbx;
 
     int global_flag =0;
@@ -132,15 +132,15 @@ namespace Tdeque {
         e1.check_trigger();         // manual trigger attempt
         EXPECT_EQ (false, flag);    // [SIZE triggers are auto clear]
 
-        Edeque e2(Edeque::data_match::MATCH, 42, [&](){ flag = true; });
+        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, 42, [&](){ flag = true; });
+        e2.set_trigger(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
         EXPECT_EQ (false, flag);    // no spurious triggers
-        e2.pop_back();              // pop 42, trigger
+        e2.push_back(42);           // push 42, trigger
         EXPECT_EQ (true, flag);
 
         flag = false;
@@ -236,8 +236,8 @@ namespace Tdeque {
         using Edeque = edeque<int, 8>;
         bool flag{};
 
-        // data_match::MATCH (item == 42)
-        Edeque ee(Edeque::data_match::MATCH, 42, [&](){ flag = true; });
+        // data_match::MATCH_PUSH (item == 42)
+        Edeque ee(Edeque::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
 
         flag = false;
         ee.push_back(7);            // 7
@@ -246,14 +246,28 @@ namespace Tdeque {
         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::MATCH (item != 42)
+        // 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, 42, [&](){ flag = true; });
+        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);
@@ -263,5 +277,279 @@ namespace Tdeque {
         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, 42, [&](){ flag = true; });
+        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, 42, [&](){ flag = true; });
+        e2.set_trigger(Equeue::data_match::MATCH_PUSH, 42, [&](){ flag = true; });
         EXPECT_EQ (false, flag);    // no spurious triggers
-        e2.pop_back();              // pop 42, trigger
+        e2.push_back(42);           // push 42, trigger
         EXPECT_EQ (true, flag);
 
         flag = false;
@@ -178,4 +178,140 @@ 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,4 +109,80 @@ 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,4 +228,197 @@ 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,18 +33,26 @@
 namespace test_sequencer {
    using namespace tbx;
 
-   // Sequencer implementer mock
-   class Seq : public sequencer_t<Seq, char, 128> {
+   struct seq_cont_t {
        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(msg_[msg]);
-               strcpy(data, msg_[msg++]);
+               size_t len = strlen(seq_cont.msg_[msg]);
+               strcpy(data, seq_cont.msg_[msg++]);
                if (msg >= 10) msg =0;
                return len;
            }
@@ -52,12 +60,14 @@ 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 status_t my_handler (const char* data, size_t size) {
+           static void my_handler (const char* data, size_t size) {
                (void)*data;
                (void)size;
-               return Seq::status_t::OK;
            }
    };
 
@@ -66,37 +76,37 @@ namespace test_sequencer {
     */
    TEST(Tsequencer, run_delay) {
        Seq s;
-       const std::array<Seq::record_t, 1> script = {{
+       const std::array<Seq::record_t<1>, 1> script = {{
            /* 0 */{Seq::control_t::NOP,  {"", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000}
        }};
-       EXPECT_EQ ((int)Seq::status_t::OK, (int)s.run(script));
+       EXPECT_EQ (s.run(script), true);
    }
 
    TEST(Tsequencer, run_dummy_output) {
        Seq s;
-       const std::array<Seq::record_t, 2> script = {{
+       const std::array<Seq::record_t<1>, 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 ((int)Seq::status_t::OK, (int)s.run(script));
+       EXPECT_EQ (s.run(script), true);
    }
 
    TEST(Tsequencer, run_exits) {
        Seq s;
-       const std::array<Seq::record_t, 1> script1 = {{
+       const std::array<Seq::record_t<1>, 1> script1 = {{
            /* 0 */{Seq::control_t::SEND, {"", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000},
        }};
-       EXPECT_EQ ((int)Seq::status_t::OK, (int)s.run(script1));
+       EXPECT_EQ (s.run(script1), true);
 
-       const std::array<Seq::record_t, 1> script2 = {{
+       const std::array<Seq::record_t<1>, 1> script2 = {{
            /* 0 */{Seq::control_t::SEND, {"", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_ERROR, 0}, 1000},
        }};
-       EXPECT_EQ ((int)Seq::status_t::ERROR, (int)s.run(script2));
+       EXPECT_EQ (s.run(script2), false);
    }
 
    TEST(Tsequencer, run_sequence) {
        Seq s;
-       const std::array<Seq::record_t, 8> script = {{
+       const std::array<Seq::record_t<2>, 9> 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, {{
@@ -104,20 +114,25 @@ namespace test_sequencer {
                        {"ERROR",  Seq::match_t::CONTAINS,    nullptr, Seq::action_t::EXIT_ERROR, 0} }},
                        1000
            },
-           /* 3 */{Seq::control_t::SEND, {"AT+CCLK?", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
-           /* 4 */{Seq::control_t::EXPECT, {{
+           /* 3 */{Seq::control_t::DETECT, {{
+                       {"+CCLK",  Seq::match_t::CONTAINS,   nullptr,  Seq::action_t::NEXT, 0},
+                       {"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
            },
-           /* 5 */{Seq::control_t::SEND, {"AT+CT?", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
-           /* 6 */{Seq::control_t::EXPECT, {{
+           /* 6 */{Seq::control_t::SEND, {"AT+CT?", Seq::match_t::NO, nullptr, Seq::action_t::NEXT, 0}, 1000},
+           /* 7 */{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
            },
-           /* 7 */{Seq::control_t::SEND, {"AT+POWD=0", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000}
+           /* 8 */{Seq::control_t::SEND, {"AT+POWD=0", Seq::match_t::NO, nullptr, Seq::action_t::EXIT_OK, 0}, 1000}
        }};
-       EXPECT_EQ ((int)Seq::status_t::ERROR, (int)s.run(script));
+       EXPECT_EQ (s.run(script), false);
    }
 }

test/tests/span.cpp

@@ -0,0 +1,274 @@
+/*!
+ * \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);
+//
+//   }
+
+}