Optimal technique to parse a real-time char* data received from a buffer for text content in C++

I have created a live continuous mjpeg stream. A crude illustration is like this

....[image (jpeg)]->[text "content-length"]->[image (jpeg)]->[text "content-length"]->.... 

As you can see I receive data from gstreamer media pipe line which contains image and my own injected text (Note: Although I am using Gstreamer, my question is only related to C++ principles.)

In order to parse this real-time data, I am trying to receive and push it into the queue. Subsequently I plan to parse the data for the word "content-length" after queue contains a certain number of packets.

My code looks like the following:

void clear( std::queue<char> &q )
{
   std::queue<char> empty;
   std::swap( q, empty );
}


static GstFlowReturn new_buffer (GstAppSink *app_sink, gpointer user_data)
{

  GstBuffer* buffer = gst_app_sink_pull_buffer(app_sink);

  //create queue
  std::queue<char> q;

  g_print("The input buffer contents are\n");

  gint i=0;
  for(i=0; buffer->data[i];i++)
  {  
      //g_print("\n%d",i);
      q.push(buffer->data[i]);
  }
  //g_print("\nsize of inbuf is %d\n",GST_BUFFER_SIZE(buffer)); 
  g_print("\n");  
  gst_buffer_unref(buffer);

  //#####################
  //parsing method here???
  //#####################

  clear(q);
  return GST_FLOW_OK;
}

I have used circular queues/ ring buffer in C/C++ before. Is that the best option? Or is the C++ STL queues would be more appropriate in th开发者_如何转开发is scenario like above?

---

I ended up using ringbuffer class

In header file declare

 //queue size
enum { rb_size = 5 };       // ---->element1 -> element2 -> .... -> elementN -> gap ->
                            // ^                                                     |
                            // |                                                     |  
                            // <--------------------<------------------<-------------V
typedef struct 
{
 char * data[rb_size];
 int head, tail;
} ring_buffer_struct; 

namespace myspace{
class ring_buffer{

    private:

    protected:          

    public: 
    //========= constructor ============
    ring_buffer()  
    {
    //If necessary initialization can happen here.

    }
    //========== destructor =============
    virtual ~ring_buffer()
    {

    }
    //===================================
    virtual void rb_start(ring_buffer_struct *b);
    virtual bool rb_empty(ring_buffer_struct const *b);
    virtual char *  rb_front(ring_buffer_struct const *b);
    virtual char *  rb_rear(ring_buffer_struct const *b);
    virtual void rb_pop_front(ring_buffer_struct *b);
    virtual ring_buffer_struct* rb_push_back(ring_buffer_struct *b);

}; //end of class
}

In cpp file

//start
void myspace::ring_buffer::rb_start(ring_buffer_struct *b)
{
b->head = 0; b->tail = 0;
}

//clear
bool myspace::ring_buffer::rb_empty(ring_buffer_struct const *b)
{
    return b->head == b->tail;
}

//front element
char *  myspace::ring_buffer::rb_front(ring_buffer_struct const *b)
{
return b->data[b->head]; //data gets popped
}

//rear element
    char *  myspace::ring_buffer::rb_rear(ring_buffer_struct const *b)
{
return b->data[b->tail]; //data gets pushed
}

//pop out front element
void myspace::ring_buffer::rb_pop_front(ring_buffer_struct *b)
{ 

    if(b->head < b->tail)  
{
      ++b->head; 
    }      
    if(b->head > b->tail)
{     
  b->head = 0;        
}

}

//push in rear element
ring_buffer_struct* myspace::ring_buffer::rb_push_back(ring_buffer_struct *b)
{
int new_tail = b->tail;

if (++new_tail >= rb_size)
{   //beginning of the queue
    new_tail = 0;      
}
if (new_tail != b->head)
{             
   //middle of the queue
    b->tail = new_tail;       
}
 if (new_tail <= b->head) 
     {
       b->tail = 0;           
     }

return b;
}

And to use in the main()

  ...

char element1[10] = "abcdefghi";
char element2[10] = "bcdefghij";
char element3[10] = "cdefghijk";

ring_buffer_struct rb;
myspace::ring_buffer q;
q.rb_empty(&rb); //make sure empty
q.rb_start(&rb); //start - initialize

    //initialize
    uint16_t i;
    for(i=0;i<rb_size;i++)
    {
     rb.data[rb.tail] = (char *)"000000000";
     q.rb_push_back(&rb);
    }

    rb.data[rb.tail] = element1;
    q.rb_push_back(&rb);
    q.rb_pop_front(&rb);         //now parse    


    rb.data[rb.tail] = element2;
    q.rb_push_back(&rb);
    q.rb_pop_front(&rb);    //now parse

      ...

For parsing: I looked at this post

Simple string parsing with C++

---

Off topic suggestion:

When using the swap trick to clear out an STL container, don't call std::swap explicitly, as you may end up not getting a better-optimized version. The better way is:

void clear( std::queue<char> &q )
{
   std::queue<char> empty;
   using std::swap;
   swap( q, empty );
}

This allows the compiler to choose a specialized version of swap that's optimized for the type of container you're using. You could also try q.swap(empty);, but I'm not sure all STL implementations offer that.