gras: compiles now with separate data struct

1 files changed, 37 insertions, 37 deletions

diff --git a/lib/task_main.cpp b/lib/task_main.cpp
index 01e38ce..2178b73 100644
--- a/lib/task_main.cpp
+++ b/lib/task_main.cpp
@@ -7,7 +7,7 @@ using namespace gras;
 
 void BlockActor::task_main(void)
 {
-    TimerAccumulate ta_prep(this->stats.total_time_prep);
+    TimerAccumulate ta_prep(data->stats.total_time_prep);
 
     //------------------------------------------------------------------
     //-- Decide if its possible to continue any processing:
@@ -23,33 +23,33 @@ void BlockActor::task_main(void)
     //-- initialize input buffers before work
     //------------------------------------------------------------------
     size_t output_inline_index = 0;
-    this->input_items.min() = ~0;
-    this->input_items.max() = 0;
+    data->input_items.min() = ~0;
+    data->input_items.max() = 0;
     for (size_t i = 0; i < num_inputs; i++)
     {
         this->sort_tags(i);
-        this->num_input_msgs_read[i] = 0;
+        data->num_input_msgs_read[i] = 0;
 
-        ASSERT(this->input_queues.ready(i));
-        const SBuffer &buff = this->input_queues.front(i);
+        ASSERT(data->input_queues.ready(i));
+        const SBuffer &buff = data->input_queues.front(i);
         const void *mem = buff.get();
-        size_t items = buff.length/this->input_configs[i].item_size;
+        size_t items = buff.length/data->input_configs[i].item_size;
 
-        this->input_items.vec()[i] = mem;
-        this->input_items[i].get() = mem;
-        this->input_items[i].size() = items;
-        this->input_items.min() = std::min(this->input_items.min(), items);
-        this->input_items.max() = std::max(this->input_items.max(), items);
+        data->input_items.vec()[i] = mem;
+        data->input_items[i].get() = mem;
+        data->input_items[i].size() = items;
+        data->input_items.min() = std::min(data->input_items.min(), items);
+        data->input_items.max() = std::max(data->input_items.max(), items);
 
         //inline dealings, how and when input buffers can be inlined into output buffers
         //*
         if GRAS_UNLIKELY(
             buff.unique() and
-            input_configs[i].inline_buffer and
+            data->input_configs[i].inline_buffer and
             output_inline_index < num_outputs and
-            buff.get_affinity() == this->buffer_affinity
+            buff.get_affinity() == data->buffer_affinity
         ){
-            this->output_queues.set_inline(output_inline_index++, buff);
+            data->output_queues.set_inline(output_inline_index++, buff);
         }
         //*/
     }
@@ -57,41 +57,41 @@ void BlockActor::task_main(void)
     //------------------------------------------------------------------
     //-- initialize output buffers before work
     //------------------------------------------------------------------
-    this->output_items.min() = ~0;
-    this->output_items.max() = 0;
+    data->output_items.min() = ~0;
+    data->output_items.max() = 0;
     for (size_t i = 0; i < num_outputs; i++)
     {
-        ASSERT(this->output_queues.ready(i));
-        SBuffer &buff = this->output_queues.front(i);
+        ASSERT(data->output_queues.ready(i));
+        SBuffer &buff = data->output_queues.front(i);
         ASSERT(buff.length == 0); //assumes it was flushed last call
         void *mem = buff.get();
         const size_t bytes = buff.get_actual_length() - buff.offset;
-        size_t items = bytes/this->output_configs[i].item_size;
+        size_t items = bytes/data->output_configs[i].item_size;
 
-        this->output_items.vec()[i] = mem;
-        this->output_items[i].get() = mem;
-        this->output_items[i].size() = items;
-        this->output_items.min() = std::min(this->output_items.min(), items);
-        this->output_items.max() = std::max(this->output_items.max(), items);
+        data->output_items.vec()[i] = mem;
+        data->output_items[i].get() = mem;
+        data->output_items[i].size() = items;
+        data->output_items.min() = std::min(data->output_items.min(), items);
+        data->output_items.max() = std::max(data->output_items.max(), items);
     }
 
     //------------------------------------------------------------------
     //-- the work
     //------------------------------------------------------------------
     ta_prep.done();
-    this->stats.work_count++;
-    if GRAS_UNLIKELY(this->interruptible_thread)
+    data->stats.work_count++;
+    if GRAS_UNLIKELY(data->interruptible_thread)
     {
-        TimerAccumulate ta_work(this->stats.total_time_work);
-        this->interruptible_thread->call();
+        TimerAccumulate ta_work(data->stats.total_time_work);
+        data->interruptible_thread->call();
     }
     else
     {
-        TimerAccumulate ta_work(this->stats.total_time_work);
+        TimerAccumulate ta_work(data->stats.total_time_work);
         this->task_work();
     }
-    this->stats.time_last_work = time_now();
-    TimerAccumulate ta_post(this->stats.total_time_post);
+    data->stats.time_last_work = time_now();
+    TimerAccumulate ta_post(data->stats.total_time_post);
 
     //------------------------------------------------------------------
     //-- Post-work output tasks
@@ -99,18 +99,18 @@ void BlockActor::task_main(void)
     for (size_t i = 0; i < num_outputs; i++)
     {
         //buffer may be popped by one of the special buffer api hooks
-        if GRAS_UNLIKELY(this->output_queues.empty(i)) continue;
+        if GRAS_UNLIKELY(data->output_queues.empty(i)) continue;
 
         //grab a copy of the front buffer then consume from the queue
         InputBufferMessage buff_msg;
-        buff_msg.buffer = this->output_queues.front(i);
-        this->output_queues.consume(i);
+        buff_msg.buffer = data->output_queues.front(i);
+        data->output_queues.consume(i);
 
         //Post a buffer message downstream only if the produce flag was marked.
         //So this explicitly after consuming the output queues so pop is called.
         //This is because pop may have special hooks in it to prepare the buffer.
-        if GRAS_LIKELY(this->produce_outputs[i]) this->post_downstream(i, buff_msg);
-        this->produce_outputs[i] = false;
+        if GRAS_LIKELY(data->produce_outputs[i]) this->post_downstream(i, buff_msg);
+        data->produce_outputs[i] = false;
     }
 
     //------------------------------------------------------------------