---

ByteFIFO.cpp

#define TRACE_NAME "ByteFIFO"
#include "ByteFIFO.h"
#include <string.h>
#include <cassert>
// $Id: ByteFIFO_8cpp-source.html,v 1.9 2001/10/10 20:40:58 sandro Exp $

//
//  Standard Member Functions
//

ByteFIFO::ByteFIFO(const size_t initialAllocation)
{
    bytesAllocated=initialAllocation;
    buffer=new char [bytesAllocated];
    nextToWrite=buffer;
    nextToRead=buffer;
}

#if 0  /* omit definitions until they are implemented */

ByteFIFO::ByteFIFO(const ByteFIFO& other)
{
    NOT_IMPLEMENTED
}

const ByteFIFO& ByteFIFO::operator=(const ByteFIFO& other)
{
    NOT_IMPLEMENTED
}

bool ByteFIFO::operator==(const ByteFIFO& other) const
{
    NOT_IMPLEMENTED
}

bool ByteFIFO::operator<(const ByteFIFO& other) const
{
    NOT_IMPLEMENTED
}

size_t ByteFIFO::hash() const
{
    NOT_IMPLEMENTED
}

std::ostream& ByteFIFO::print_to(std::ostream& stream) const
{
    NOT_IMPLEMENTED
}

#endif /* omit definitions until they are implemented */
    
ByteFIFO::~ByteFIFO()
{
    delete[] buffer;
}

//
//  Additional Public Member Functions
//

void ByteFIFO::write(const void* const byteBuffer, const size_t numBytes)
{
    size_t bytesRemaining = bytesAllocated - (nextToWrite-buffer);
    if (numBytes > bytesRemaining) {
    makeRoom(numBytes - bytesRemaining);
    }
    memcpy(nextToWrite, byteBuffer, numBytes);
    nextToWrite += numBytes;
}


size_t ByteFIFO::read(void* const byteBuffer, const size_t maxBytes)
{
    size_t bytes = nextToWrite - nextToRead;
    if (bytes > maxBytes) bytes = maxBytes;
    if (bytes > 0) {
    memcpy(byteBuffer, nextToRead, bytes);
    nextToRead += bytes;
    }
    return bytes;
}

void* ByteFIFO::peek() 
{
    return nextToRead;
}

void ByteFIFO::skip(size_t bytes) 
{
    size_t bytes_possible = nextToWrite - nextToRead;
    assert(bytes <= bytes_possible);
    nextToRead += bytes_possible;
}


//
//  Additional Private Member Functions
//

void ByteFIFO::makeRoom(size_t numAdditionalBytes)
{
    // we may be able to slide all the bytes back, if some
    // have been read.  (if we were to do this a lot, it might
    // be worthwhile to implement a ring-buffer.)  while this
    // involves copying all the data, we'd have to do that 
    // anyway in copying to a newly allocated buffer.

    size_t starting_gap = nextToRead - buffer;
    size_t numBytesHeld = nextToWrite-nextToRead;
    if (starting_gap >= numAdditionalBytes) {
    if (numBytesHeld) memmove(buffer, nextToRead, numBytesHeld);
    nextToWrite -= starting_gap;
    nextToRead = buffer;
    } else {
    size_t newAllocation = bytesAllocated;
    while (newAllocation < bytesAllocated + numAdditionalBytes) {
        // there's probably a clever non-loop for this...
        newAllocation += newAllocation;
    }
    char *newBuf = new char [newAllocation];
    if (numBytesHeld) memmove(newBuf, nextToRead, numBytesHeld);
    delete [] buffer;
    buffer = newBuf;
    nextToRead = buffer;
    nextToWrite = buffer + numBytesHeld;
    bytesAllocated = newAllocation;
    }
}

#undef TRACE_NAME

---

Home to blindfold. This page generated via doxygen 1.2.11.1 Wed Oct 10 16:40:33 2001.