NPLMsgIn_parser.h

#pragma once
#include "NPLMsgIn.h"
#include <boost/logic/tribool.hpp>
#include <boost/tuple/tuple.hpp>

namespace NPL
{
    struct NPLMsgIn;

    class NPLMsgIn_parser
    {
    public:
        enum Consume_Result
        {
            c_res_indeterminate,
            c_res_code_body,
            c_res_true,
            c_res_false,
        };

        NPLMsgIn_parser();

        void reset();

        template <typename InputIterator>
        boost::tuple<boost::tribool, InputIterator> parse(NPLMsgIn& req,
            InputIterator begin, InputIterator end)
        {
            Consume_Result result = c_res_indeterminate;
            while (begin != end && (result == c_res_indeterminate))
            {
                result = consume(req, *begin++);
            }
            if(begin != end && result == c_res_code_body)
            {
                // we can read to end or length instead of doing the lexical work one char at a time. 
                int nOldSize = req.m_code.size();
                int nByteCount = end-begin;
                if(req.m_nLength < (nOldSize+nByteCount))
                {
                    nByteCount = req.m_nLength - nOldSize;
                }
                req.m_code.resize(nOldSize+nByteCount);
                memcpy(&(req.m_code[nOldSize]), begin, nByteCount);
                begin = begin + nByteCount;
                if (req.m_nLength ==(int)req.m_code.size()) 
                {
                    result = c_res_true;
                }
            }
            if(result == c_res_true)
            {
                if(m_bCompressed)
                    Decompress(req);
                reset();
                boost::tribool result_ = true;
                return boost::make_tuple(result_, begin);
            }
            else if(result == c_res_false)
            {
                boost::tribool result_ = false;
                return boost::make_tuple(result_, begin);
            }
            else
            {
                boost::tribool result_ = boost::indeterminate;
                return boost::make_tuple(result_, begin);
            }
        }

    private:
        Consume_Result consume(NPLMsgIn& req, char input);

        void Decompress(NPLMsgIn& req);

        void Decode(NPLMsgIn& req);

        static bool is_char(int c);

        static bool is_ctl(int c);

        static bool is_tspecial(int c);

        static bool is_digit(int c);

        enum state
        {
            method_start,
            method,
            uri,
            uri_rts_name,
            npl_version_n,
            npl_version_p,
            npl_version_l,
            npl_version_slash,
            npl_version_major,
            npl_version_minor,
            header_line_start,
            header_lws,
            header_name,
            header_value,
            code_length,
            code_body,
            uri_http,
        } state_;
        bool m_bCompressed;
    };
}