BxArrayBuffer.h

/********************************************************************
 * Binx
 * $Id: BxArrayBuffer_8h-source.html,v 1.1.1.1 2006/04/19 14:19:02 edikt2 Exp $
 *
 * Class for the array buffer
 *
 *
 * edikt::BinX
 * www.edikt.org
 * support@edikt.org
 *
 * Copyright (c) 2005 The University of Edinburgh.
 *
 ********************************************************************/

#ifndef BXARRAYBUFFER_H
#define BXARRAYBUFFER_H

#include "BxObject.h"

class BxBinaryFile;

/*
 * Class implementing array-knowledgable buffer management for BxArray.
 * An array buffer object encapsulates a physical memory-resident buffer and a set of
 * attributes describing that buffer. Descriptive attributes include:
 * <UL>
 * <li> the physical size of the buffer</li>
 * <li> the number of array data elements held in the buffer at a given time</li>
 * <li> the current buffer position with respect to sequent access to the buffer</li>
 * </UL>
 * The buffer serves as a window over a binary file that contains data element values.
 * As such, it holds a memory-resident chunk of a persistent binary array. 
 * This class works with the class BxBinaryFile to provide services for
 * reading and writing data element values between the buffer and a binary file.
 * <BR>This class encapsulates limited understanding of the semantics of arrays.
 * Multi-dimensional arrays are viewed as flat one-dimensional arrays.
 * An array element is identified by a one-dimensional, zero-based index value,
 * representing the elements relative position in the total, flattened array.
 * The buffer manager maps the index value into a real byte-offset with the buffer
 * or within the file (which contains other array chunks not currently in memory.
 * Byte offsets are calculated based on the size of a single data element stored
 * by the array.
 * <BR><B>Since:</B>  BinX version 1.0.
*/
class DECLSPEC BxArrayBuffer : public BxObject
{
public:
        // The constructor
    BxArrayBuffer(BxBinaryFile* pBFile, long arOffset, int elements, int elemSize);

        // The copy constructor
    BxArrayBuffer(const BxArrayBuffer& copy);

        // The destructor
    virtual ~BxArrayBuffer();

    byte* getElement(int elemIndex);
    byte* getNextElement();
    byte* getBuffer() const { return buffer_; }
    long getArrayOffset() { return arrayOffset_; }
    int  getElementSize() { return elementSize_; }

    void setBuffer(byte* buf);
    void setBuffer(byte* buf, int bytes);

    bool putNextElement(byte* pBuffer);

        // Reset buffer pointer to the beginning
    void reset() { currentElementInBuffer_ = -1; }

        // This function can be used to flush the buffer
    void writeBuffer();

private:
        // Private operations

    bool readBuffer();


        // Private data

        // The binary file pointer
    BxBinaryFile* bfile_;

        // The offset of the array in the binary file
    long arrayOffset_;

        // The total number of elements in the array
    int elementCountTotal_;

        // The total number of elements in this buffer
    int elementCountInBuffer_;

        // The size in bytes of an individual element
    int elementSize_;

        // The current element in the buffer (0 based array)
    int currentElementInBuffer_;

        // A flag to indicate whether the data file has been read into the buffer
    bool read_;

        // The buffer containing the array chunk
    byte* buffer_;
};

#endif

---