如何优化解析数据流算法？

Question

I need to implement some abstract protocol client-server conversation parsing library with C++. I don't have file containing the whole client-server conversation, but have to parse it on the fly. I have to implement following interface:

class parsing_class
{
  public:
  void on_data( const char* data, size_t len );
  //other functions
  private:
  size_t pos_;// current position in the data flow
  bool first_part_parsed_;
  bool second_part_parsed_;
  //... some more bool markers or something like vector< bool >
};

The data is passed to my class through on_data function. Data chunk length varies from one call to another. I know protocol's packet format and know how conversation should be organized, so I can judge by current pos_ whether i have enough data to parse Nth part. Now the implementation is like following:

void parsing_class::on_data( const char* data, size_t len )
{
   pos_ += len;
   if( pos > FIRST_PART_SIZE and !first_part_parsed_ )
     parse_first_part( data, len );
   if( pos > SECOND_PART_SIZE and !second_part_parsed_ )
     parse_second_part( data, len );
   //and so on..  
}

What I want is some tips how to optimize this algorithm. Maybe to avoid these numerous if ( on_data may be called very many times and each time it will have to go through all switches ).

Answer 1

You don't need all those bool and pos_ , as they seem to only keep the state of what of the conversation has passed so that you can continue with the next part.

How about the following: write yourself a parse function for each of the parts of the conversation

bool parse_part_one(const char *data) {
    ... // parse the data
    next_fun = parse_part_two;
    return true;
}
bool parse_part_two(const char *data) {
    ... // parse the data
    next_fun = parse_part_thee;
    return true;
}
...

and in your class you add a pointer to the current parse function, starting at one. Now, in on_data all you do is to call the next parse function

bool success = next_fun(data);

Because each function sets the pointer to the next parse function, the next call of on_data will invoke the next parse function automatically. No tests required of where in the conversation you are.

If the value of len is critical (which I assume it would be) then pass that along as well and return false to indicate that the part could not be parsed (don't update next_fun in that case either).