message-buffer.cpp

Go to the documentation of this file.

/*
 * message-buffer.cpp
 *
 * Copyright (C) 2007  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of a simple message buffer object.  See message-buffer.h
 */

// includes --------------------------------------------------------------------
#include "message-buffer.h"


namespace netlib {

typedef std::vector<char> buffer_t;


// interface destructor implementation
MessageBuffer::~MessageBuffer(void) throw() { }


////////////////////////////////////////////////////////////////////////////////
//
//      private helper methods
//
////////////////////////////////////////////////////////////////////////////////

class Buffer : public MessageBuffer {
public:
        Buffer(void) throw() : m_closed(false) { }
        ~Buffer(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(void) throw() { }

        // netlib::MessageBuffer class interface methods -----------------------
        long getBytes(void) const throw();
        const char * getData(void) const throw();
        bool isClosed(void) const throw() { return m_closed; }
        void reserve(IN long bytes);
        void appendData(IN const char * data, IN long bytes);
        void appendToken(IN const char * token);
        void close(void);

private:
        // private member data -------------------------------------------------
        buffer_t                m_buffer;
        bool                    m_closed;
};



long
Buffer::getBytes
(
void
)
const
throw()
{
        ASSERT(m_closed, "read operation not allowed: message buffer not closed!");
        long bytes = m_buffer.size();
        ASSERT(bytes > 0, "should be at least 1, even for empty message!");
        return bytes - 1;
}



const char *
Buffer::getData
(
void
)
const
throw()
{
        ASSERT(m_closed, "read operation not allowed: message buffer not closed!");
        return &m_buffer[0];
}



void
Buffer::reserve
(
IN long bytes
)
{
        ASSERT(!m_closed, "write operation not allowed: message buffer is closed!");
        m_buffer.reserve(bytes + 1);    // add one for final null-termination
}



void
Buffer::appendData
(
IN const char * data,
IN long bytes
)
{
        // timer itself impacts timing!
        // perf::Timer timer("Buffer::appendData");
        ASSERT(!m_closed, "write operation not allowed: message buffer is closed!");
        ASSERT(data, "null");
        ASSERT(bytes > 0, "bad byte count: %ld", bytes);

        long curr = m_buffer.size();
        long required = curr + bytes;
        m_buffer.resize(required);
        char * dst = &m_buffer[0] + curr;
        memcpy(dst, data, bytes);
}



void
Buffer::close
(
void
)
{
        ASSERT(!m_closed, "message buffer is already closed!");

        m_closed = true;
        m_buffer.push_back(0);  // force a null termination
}



void
Buffer::appendToken
(
IN const char * token
)
{
        ASSERT(token, "null");
        int bytes = strlen(token);
        this->appendData(token, bytes);
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<MessageBuffer>
MessageBuffer::create
(
void
)
{
        smart_ptr<Buffer> local = new Buffer;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



};      // netlib namespace