BxArray.h

// ##################################################################
// Binx
// $Id: BxArray_8h-source.html,v 1.1.1.1 2006/04/19 14:19:02 edikt2 Exp $
//
// Base class for all three array types.
// ##################################################################
/*

//  edikt::BinX
//  www.edikt.org
//  support@edikt.org

// Copyright (c) 2004 The University of Edinburgh.

*/

#ifndef __BxArray__
#define __BxArray__

#include "BxDataObject.h"
#include "BxArrayBuffer.h"
#include "BxDimension.h"

class DECLSPEC BxArray : public BxDataObject
{
protected:
    long    arrayOffset_;   //<absolute offset of the array in the binary file
    int     dimensions_;  //<number of dimensions in this array
    BxDimension ** dims_;   //<collection of dimension descriptions, one per dimension
    BxDataObject * elementType_;  //<type of element contained in the array
    BxArrayBuffer * arraybuf_;    //<array buffer window

    void deleteDims();    //delete all dims_ instances and the list itself
    void allocateBuffer(); //allocate array buffer for the dimension elements
    char * toArrayHeader(bool); //used by toString and toStream
    void toStreamOfDimensions(int dim, FILE* stream);
    void toStreamOfDimensionsBinary(int, FILE*);
    void toStreamOfDimensionsBinary(int, FILE*, BxByteOrder);

public:
    BxArray();
    BxArray(int dim);
    BxArray(const BxArray& copy);
    virtual ~BxArray();

    virtual char* className() const { return "BxArray"; }
    virtual BxArray* clone() const;
    int count(); //Returns the number of elements for all dimension
    virtual void resize();  //calculate the size of the array including blockSize
    virtual void setByteOrder(BxByteOrder bo);
    virtual char * toString(bool xml);
    virtual bool toStream(FILE*);
    virtual bool toStreamBinary(FILE*);

        // Write out the binary data with the specified byte order
    virtual bool toStreamBinary(FILE*, BxByteOrder);
    virtual void readFromBuffer(const byte * buf);
    virtual bool readFromFile();

    int getDimensions() const { return dimensions_; }   //how many dimensions
    int getIndexFrom(int dim) const;
    int getIndexTo(int dim) const;
    int getCount(int dim) const;                        //records per dimension
    char * getDimName(int dim) const;
    int getElementSize() const;    //datatype of element
    BxDataObject * getElementType() const { return elementType_; }

    BxDataObject * get(int d1, int d2); //two-dimensional
    BxDataObject * get(int d1, int d2, int d3);  //three-dimensional
    BxDataObject * get(int d1, int d2, int d3, int d4); //four-D
    BxDataObject * getMore(int d1, ...);
    virtual BxDataObject * get(int index);    //one-dimensional access
    virtual BxDataObject * getNext();   //flat visit of cells

    void setElementType(BxDataObject * elemObj);
    void setDimensions(int dims);
    bool setDimension(int, BxDimension *);
    void setIndexFrom(int dim, int from);
    void setIndexTo(int dim, int to);
    void setCount(int dim, int count);

    void addDimension(BxDimension *);
    void addDimensionInFront(BxDimension *);
    bool addElement(BxDataObject *); //append an element to the array data

    void toFirst();  //move pointer to 0 for getNext()

    void writeDimensions(int n, bool checkIndex, FILE * stream);
    void flushBuffer();
};

#endif

---