happyhttp::Response Class Reference

#include <happyhttp.h>

Public Member Functions
const char *	getheader (const char *name) const
bool	completed () const
int	getstatus () const
const char *	getreason () const
bool	willclose () const

Protected Member Functions
	Response (const char *method, Connection &conn)
int	pump (const unsigned char *data, int datasize)
void	notifyconnectionclosed ()

Friends
class	Connection

Detailed Description

Definition at line 244 of file happyhttp.h.

Constructor & Destructor Documentation

Response()

happyhttp::Response::Response ( const char *  method, Connection &  conn  )

protected

Definition at line 498 of file happyhttp.cpp.

                                                         :
        m_Connection( conn ),
        m_State( STATUSLINE ),
        m_Method( method ),
        m_Version( 0 ),
        m_Status(0),
        m_BytesRead(0),
        m_Chunked(false),
        m_ChunkLeft(0),
        m_Length(-1),
        m_WillClose(false)
{
}

Member Function Documentation

completed()

bool happyhttp::Response::completed ( ) const

inline

Definition at line 252 of file happyhttp.h.

                { return m_State == COMPLETE; }

Referenced by happyhttp::Connection::pump().

getheader()

const char * happyhttp::Response::getheader

(

const char *

name

)

const

Definition at line 513 of file happyhttp.cpp.

{
        std::string lname( name );
//      std::transform( lname.begin(), lname.end(), lname.begin(), tolower );
 
        std::map< std::string, std::string >::const_iterator it = m_Headers.find( lname );
        if( it == m_Headers.end() )
                return 0;
        else
                return it->second.c_str();
}

getreason()

const char * happyhttp::Response::getreason

(

)

const

Definition at line 534 of file happyhttp.cpp.

{
        // only valid once we've got the statusline
        assert( m_State != STATUSLINE );
        return m_Reason.c_str();
}

Referenced by OnBegin().

getstatus()

int happyhttp::Response::getstatus

(

)

const

Definition at line 526 of file happyhttp.cpp.

{
        // only valid once we've got the statusline
        assert( m_State != STATUSLINE );
        return m_Status;
}

Referenced by OnBegin().

notifyconnectionclosed()

void happyhttp::Response::notifyconnectionclosed ( )

protected

Definition at line 544 of file happyhttp.cpp.

{
        if( m_State == COMPLETE )
                return;
 
        // eof can be valid...
        if( m_State == BODY &&
                !m_Chunked &&
                m_Length == -1 )
        {
                Finish();       // we're all done!
        }
        else
        {
                throw Wobbly( "Connection closed unexpectedly" );
        }
}

Referenced by happyhttp::Connection::pump().

pump()

int happyhttp::Response::pump ( const unsigned char *  data, int  datasize  )

protected

Definition at line 564 of file happyhttp.cpp.

{
        assert( datasize != 0 );
        int count = datasize;
 
        while( count > 0 && m_State != COMPLETE )
        {
                if( m_State == STATUSLINE ||
                        m_State == HEADERS ||
                        m_State == TRAILERS ||
                        m_State == CHUNKLEN ||
                        m_State == CHUNKEND )
                {
                        // we want to accumulate a line
                        while( count > 0 )
                        {
                                char c = (char)*data++;
                                --count;
                                if( c == '\n' )
                                {
                                        // now got a whole line!
                                        switch( m_State )
                                        {
                                                case STATUSLINE:
                                                        ProcessStatusLine( m_LineBuf );
                                                        break;
                                                case HEADERS:
                                                        ProcessHeaderLine( m_LineBuf );
                                                        break;
                                                case TRAILERS:
                                                        ProcessTrailerLine( m_LineBuf );
                                                        break;
                                                case CHUNKLEN:
                                                        ProcessChunkLenLine( m_LineBuf );
                                                        break;
                                                case CHUNKEND:
                                                        // just soak up the crlf after body and go to next state
                                                        assert( m_Chunked == true );
                                                        m_State = CHUNKLEN;
                                                        break;
                                                default:
                                                        break;
                                        }
                                        m_LineBuf.clear();
                                        break;          // break out of line accumulation!
                                }
                                else
                                {
                                        if( c != '\r' )         // just ignore CR
                                                m_LineBuf += c;
                                }
                        }
                }
                else if( m_State == BODY )
                {
                        int bytesused = 0;
                        if( m_Chunked )
                                bytesused = ProcessDataChunked( data, count );
                        else
                                bytesused = ProcessDataNonChunked( data, count );
                        data += bytesused;
                        count -= bytesused;
                }
        }
 
        // return number of bytes used
        return datasize - count;
}

References count.

Referenced by happyhttp::Connection::pump().

willclose()

bool happyhttp::Response::willclose ( ) const

inline

Definition at line 263 of file happyhttp.h.

                { return m_WillClose; }

Friends And Related Symbol Documentation

Connection

friend class Connection

friend

Definition at line 246 of file happyhttp.h.

---

The documentation for this class was generated from the following files:

• happyhttp.h
• happyhttp.cpp