glinebuffer.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_LINE_BUFFER_H
#define G_LINE_BUFFER_H

#include "gdef.h"
#include "gnet.h"
#include "gexception.h"
#include <string>

namespace GNet
{
        class LineBuffer ;
        class LineBufferIterator ;
}

class GNet::LineBuffer 
{
public:
        G_EXCEPTION( Overflow , "line buffer overflow: maximum input line length exceeded" ) ;

        explicit LineBuffer( const std::string & eol = std::string("\n") , bool do_throw_on_overflow = false ) ;

        void add( const std::string & segment ) ;

        void add( const char * p , std::string::size_type n ) ;

        bool more() const ;

        const std::string & current() const ;

        void discard() ;

        std::string line() ;

private:
        friend class LineBufferIterator ;
        LineBuffer( const LineBuffer & ) ;
        void operator=( const LineBuffer & ) ;
        void fix( std::string::size_type ) ;
        void check( std::string::size_type ) ;
        void lock() ;
        void unlock( std::string::size_type ) ;

private:
        static unsigned long m_limit ;
        std::string m_eol ;
        std::string::size_type m_eol_length ;
        std::string m_store ;
        std::string::size_type m_p ;
        bool m_current_valid ; // mutable
        std::string m_current ; // mutable
        bool m_throw ;
        bool m_locked ;
} ;

class GNet::LineBufferIterator 
{
public:
        explicit LineBufferIterator( LineBuffer & ) ;

        ~LineBufferIterator() ;

        bool more() const ;

        const std::string & line() ;

private:
        LineBufferIterator( const LineBufferIterator & ) ; // not implemented
        void operator=( const LineBufferIterator & ) ; // not implemented

private:
        LineBuffer & m_b ;
        std::string::size_type m_n ;
        std::string::size_type m_store_length ;
} ;

inline
GNet::LineBufferIterator::LineBufferIterator( LineBuffer & b ) :
        m_b(b) ,
        m_n(0U) ,
        m_store_length(b.m_store.length())
{
        m_b.lock() ;
}

inline
GNet::LineBufferIterator::~LineBufferIterator()
{
        m_b.unlock( m_n ) ;
}

#endif