ByteBuffer.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/common/ByteBuffer.h#9 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
//
// 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 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// 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, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_ByteBuffer_Included
#define Fennel_ByteBuffer_Included

#include "fennel/common/CommonPreamble.h"

#include <boost/shared_array.hpp>

FENNEL_BEGIN_NAMESPACE

typedef uint8_t UnsignedByte;

class FENNEL_COMMON_EXPORT ByteBuffer
{
    boost::shared_array<PBuffer> ppBuffers;
    uint nBuffers;
    uint bufferSize;
    uint bufferMask;
    uint bufferShift;

    inline uint getI(uint pos)
    {
        uint i = pos >> bufferShift;
        assert(i < nBuffers);
        return i;
    }

    inline uint getJ(uint pos)
    {
        uint j = pos & bufferMask;
        assert(j < bufferSize);
        return j;
    }

    static void memmerge(PBuffer dest, PConstBuffer src, uint len)
    {
        PBuffer end = dest + len;
        while (dest < end) {
            *dest++ |= *src++;
        }
    }

public:
    explicit ByteBuffer();

    void init(
        boost::shared_array<PBuffer> ppBuffers, uint nBuffers, uint bufSize);

    uint getSize();

    inline UnsignedByte getByte(uint pos)
    {
        return ppBuffers[getI(pos)][getJ(pos)];
    }

    inline void setByte(uint pos, UnsignedByte b)
    {
        ppBuffers[getI(pos)][getJ(pos)] = b;
    }

    inline void mergeByte(uint pos, UnsignedByte b)
    {
        ppBuffers[getI(pos)][getJ(pos)] |= b;
    }

    inline PBuffer getMem(uint pos, uint &size)
    {
        size = bufferSize - getJ(pos);
        return &ppBuffers[getI(pos)][getJ(pos)];
    }

    void setMem(uint pos, UnsignedByte value, uint len);

    void copyMem(uint pos, PConstBuffer mem, uint len);

    void mergeMem(uint pos, PConstBuffer mem, uint len);
};

template <class IndexT>
class ByteWindow
{
    SharedByteBuffer pBuffer;

    uint windowSize;

    uint startOffset;

    IndexT start;

    IndexT end;

    inline uint getOffset(IndexT index)  const
    {
        assert(index >= start);
        assert(index < start + windowSize);
        uint pos = index - start + startOffset;
        if (pos >= windowSize) {
            pos -= windowSize;
        }
        return pos;
    }

    inline uint getUnwrappedMemSize(IndexT index)
    {
        assert(start <= index && index <= start + windowSize);
        return windowSize - getOffset(index);
    }

public:
    void init(SharedByteBuffer pBuffer)
    {
        this->pBuffer = pBuffer;
        windowSize = pBuffer->getSize();
        reset();
    }

    void reset()
    {
        startOffset = 0;
        start = end = 0;
    }

    inline uint getCapacity() const
    {
        return windowSize;
    }

    inline IndexT getStart() const
    {
        return start;
    }

    inline IndexT getEnd() const
    {
        return end;
    }

    inline IndexT getLimit()
    {
        return start + windowSize;
    }

    PBuffer getMem(IndexT index, uint &size)
    {
        return pBuffer->getMem(getOffset(index), size);
    }

    void advance(IndexT pos)
    {
        assert (pos >= start);

        // If we not keeping any data, reset the start pointer to the
        // beginning of the internal buffer. Otherwise, advance it.
        if (pos >= end) {
            startOffset = 0;
            end = pos;
        } else {
            startOffset = getOffset(pos);
        }
        start = pos;
    }

    void advanceEnd(IndexT pos)
    {
        assert(pos > end);
        assert(pos <= getLimit());

        uint len = pos - end;
        uint chunkSize = std::min(len, getUnwrappedMemSize(end));
        pBuffer->setMem(getOffset(end), 0, chunkSize);
        if (len > chunkSize) {
            pBuffer->setMem(0, 0, len - chunkSize);
        }
        end = pos;
    }

    inline UnsignedByte getByte(IndexT index) const
    {
        assert(index >= start && index < end);
        return pBuffer->getByte(getOffset(index));
    }

    void mergeByte(IndexT index, UnsignedByte val)
    {
        assert(index >= start);
        assert(index < getLimit());
        if (index >= end) {
            advanceEnd(index + 1);
        }
        pBuffer->mergeByte(getOffset(index), val);
    }

    void mergeMem(IndexT index, PConstBuffer byteSeg, uint len)
    {
        assert(index >= start);
        assert(len < windowSize);
        assert(index + len <= getLimit());
        assert(len > 0);

        // zero from end to index
        IndexT writeEnd = index + len;
        if (writeEnd > end) {
            advanceEnd(writeEnd);
        }

        uint chunkSize = std::min(len, getUnwrappedMemSize(index));
        pBuffer->mergeMem(getOffset(index), byteSeg, chunkSize);
        if (len > chunkSize) {
            pBuffer->mergeMem(0, byteSeg + chunkSize, len - chunkSize);
        }
    }
};

FENNEL_END_NAMESPACE

#endif

// End ByteBuffer.h

---