Add OPLIST for buffer & an example. Still a WIP for the constness of the BUFFER source.

example/ex-multi04.c

@@ -4,6 +4,7 @@
 #include "m-array.h"
 #include "m-string.h"
 #include "m-list.h"
+#include "m-buffer.h"
 
 TUPLE_DEF2(symbol, (type, int), (name, string_t))
 #define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_DEFAULT_OPLIST, STRING_OPLIST)
@@ -29,7 +30,12 @@ LIST_DEF(list_of_tuple_of_tuple, my_tuple_of_tuple_t)
 TUPLE_DEF2(my_triple_tuple, (name, string_t), (inner_tuple, my_tuple_t), (list, list_of_tuple_of_tuple_t) )
 #define M_OPL_my_triple_tuple_t() TUPLE_OPLIST(my_triple_tuple, STRING_OPLIST, M_OPL_my_tuple_t(), M_OPL_list_of_tuple_of_tuple_t())
 
+BUFFER_DEF(trbuff, my_triple_tuple_t, 100, BUFFER_QUEUE)
+#define M_OPL_trbuff_t() BUFFER_OPLIST(trbuff, M_OPL_my_triple_tuple_t())
 
+TUPLE_DEF2(my_junction, (active, bool), (buffer, trbuff_t))
+#define M_OPL_my_junction_t() TUPLE_OPLIST(my_junction, M_DEFAULT_OPLIST, M_OPL_trbuff_t())
+           
 static void let(void)
 {
   M_LET(s, symbol_t)
@@ -40,6 +46,7 @@ static void let(void)
     M_LET(tuptup, my_tuple_of_tuple_t)
     M_LET(ltuptup, list_of_tuple_of_tuple_t)
     M_LET(tuptuptup, my_triple_tuple_t)
+    M_LET(junc, my_junction_t)
     {
       printf("Init ok\n");
     }

m-buffer.h

@@ -54,16 +54,23 @@ typedef enum {
    USAGE: BUFFER_DEF(name, type, size_of_buffer_or_0, policy[, oplist]) */
 #define BUFFER_DEF(name, type, m_size, ... )                            \
   BUFFERI_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
-              ((name, type, m_size,__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t)), \
+              ((name, type, m_size,__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
                (name, type, m_size,__VA_ARGS__,                                      M_C(name,_t))))
 
+/* Define the oplist of a lock based buffer given its name and its oplist.
+   USAGE: BUFFER_OPLIST(name[, oplist of the type]) */
+#define BUFFER_OPLIST(...)                                              \
+  BUFFERI_OPLIST(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
+                 ((__VA_ARGS__, M_DEFAULT_OPLIST),			\
+                  (__VA_ARGS__ )))
+
 /* Define a lock-free queue for Many Producer Many Consummer
    Much faster than queue of BUFFER_DEF in heavy communication scenario
    Size of created queue can only a power of 2.
 */
 #define QUEUE_MPMC_DEF(name, type, ...)					\
   QUEUEI_MPMC_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
-                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t)), \
+                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
                    (name, type, __VA_ARGS__,                                      M_C(name,_t))))
 
 /* Define a wait-free queue for Single Producer Single Consummer
@@ -72,7 +79,7 @@ typedef enum {
 */
 #define QUEUE_SPSC_DEF(name, type, ...)					\
   QUEUEI_SPSC_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
-                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t)), \
+                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
                    (name, type, __VA_ARGS__,                                      M_C(name,_t))))
 
 
@@ -117,6 +124,7 @@ typedef enum {
                                                                         \
   typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
   typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
+  typedef type M_C(name, _type_t);                                      \
                                                                         \
 static inline void                                                      \
 M_C(name, _init)(buffer_t v, size_t size)                               \
@@ -150,7 +158,7 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
                                                                         \
  BUFFERI_IF_CTE_SIZE(m_size)(                                           \
  static inline void                                                     \
- M_C(name, _init1)(buffer_t v)                                          \
+ M_C(name, _int_init)(buffer_t v)                                       \
  {                                                                      \
    M_C(name, _init)(v, m_size);                                         \
  }                                                                      \
@@ -549,6 +557,22 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
  }                                                                      \
 
 
+// Deferred evaluation for the oplist definition.
+#define BUFFERI_OPLIST(arg) BUFFERI_OPLIST2 arg
+
+/* OPLIST defininition of a buffer */
+#define BUFFERI_OPLIST2(name, oplist)					\
+  (INIT(M_C(name, _int_init))                                           \
+   ,INIT_SET(M_C(name, _init_set))					\
+   ,SET(M_C(name, _set))						\
+   ,CLEAR(M_C(name, _clear))						\
+   ,TYPE(M_C(name,_t))							\
+   ,SUBTYPE(M_C(name, _type_t))						\
+   ,CLEAN(M_C(name,_clean))						\
+   ,PUSH(M_C(name,_push))						\
+   ,POP(M_C(name,_pop))                                                 \
+   ,OPLIST(oplist)                                                      \
+   )