BxDataset.h

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

#ifndef BXDATASET_H
#define BXDATASET_H

#include "BxProtos.h"
#include "BxDataTypes.h"
#include "BxDataObjects.h"

class DECLSPEC BxDataset : public BxDataObject
{
public:
        // The default constructor
    BxDataset();

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

        // The destructor
    virtual ~BxDataset();
    virtual BxDataset* clone() const;
    virtual char* className() const {return "BxDataset";} //<Returns the null-terminated string "BxDataset".
    virtual void print();

    virtual void    setBinaryFilePtr(BxBinaryFile* fp);
    virtual char*   typeName() const;
    virtual char*   varName() const;   //returns the variable name
    virtual char*   testValue() const;
    virtual BxByteOrder byteOrder() const;
    virtual int blockSize() const;
    virtual void    setByteOrder(BxByteOrder bo);
    virtual void    setBlockSize(int blocksize);
    virtual void    setOffset(long offset);

    virtual byte* getDataPointer(); //return data pointer
    virtual void  readFromBuffer(const byte * buf);
    virtual bool  readFromFile();
    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); 

    // loop access methods
    void reset();
    bool next();    // set next data object in list and return true, or false if passed end
    BxDataObject* getDataObject() const;  // return the set object with next()
    BxByte8* getByte8();
    BxCharacter8* getCharacter8();
    BxUnicode16* getUnicode16();
    BxUnicode32* getUnicode32();
    BxShort16* getShort16();
    BxInteger32* getInteger32();
    BxLong64* getLong64();
    BxUnsignedShort16* getUnsignedShort16();
    BxUnsignedInteger32* getUnsignedInteger32();
    BxUnsignedLong64* getUnsignedLong64();
    BxFloat32* getFloat32();
    BxDouble64* getDouble64();
    BxDoubleExtended80* getDoubleExtended80();
    BxDoubleExtended96* getDoubleExtended96();
    BxQuadruple128* getQuadruple128();
    BxDataset* getDataset();
    BxArray* getArray();
    BxUnion* getUnion();
    BxString* getString();
    bool isByte8() const;
    bool isCharacter8() const;
    bool isUnicode16() const;
    bool isUnicode32() const;
    bool isShort16() const;
    bool isInteger32() const;
    bool isLong64() const;
    bool isUnsignedShort16() const;
    bool isUnsignedInteger32() const;
    bool isUnsignedLong64() const;
    bool isFloat32() const;
    bool isDouble64() const;
    bool isExtended80() const;
    bool isExtended96() const;
    bool isDoubleExtended() const;
    bool isQuadruple128() const;
    bool isVoid0() const;
    bool isDataset() const;
    bool isArray() const;
    bool isUnion() const;
    bool isString() const;

    int count() const;   //count number of elements in dataObjects_

    BxDataObject* getDataObject(int index) const;
    BxDataObject * getDataObject(const char* name) const;

    BxByte8* getByte8(int index);
    BxCharacter8* getCharacter8(int index);
    BxUnicode16* getUnicode16(int index);
    BxUnicode32* getUnicode32(int index);
    BxShort16* getShort16(int index);
    BxInteger32* getInteger32(int index);
    BxLong64* getLong64(int index);
    BxUnsignedShort16* getUnsignedShort16(int index);
    BxUnsignedInteger32* getUnsignedInteger32(int index);
    BxUnsignedLong64* getUnsignedLong64(int index);
    BxFloat32* getFloat32(int index);
    BxDouble64* getDouble64(int index);
    BxDoubleExtended80* getDoubleExtended80(int index);
    BxDoubleExtended96* getDoubleExtended96(int index);
    BxQuadruple128* getQuadruple128(int index);
    BxDataset* getDataset(int index);
    BxArray* getArray(int index);
    BxUnion* getUnion(int index);
    BxString* getString(int index);
    bool isByte8(int index) const;
    bool isCharacter8(int index) const;
    bool isUnicode16(int index) const;
    bool isUnicode32(int index) const;
    bool isShort16(int index) const;
    bool isInteger32(int index) const;
    bool isLong64(int index) const;
    bool isUnsignedShort16(int index) const;
    bool isUnsignedInteger32(int index) const;
    bool isUnsignedLong64(int index) const;
    bool isFloat32(int index) const;
    bool isDouble64(int index) const;
    bool isExtended80(int index) const;
    bool isExtended96(int index) const;
    bool isDoubleExtended(int index) const;
    bool isQuadruple128(int index) const;
    bool isVoid0(int index) const;
    bool isDataset(int index) const;
    bool isArray(int index) const;
    bool isUnion(int index) const;
    bool isString(int index) const;

    BxByte8* getByte8(const char* vname);
    BxCharacter8* getCharacter8(const char* vname);
    BxUnicode16* getUnicode16(const char* vname);
    BxUnicode32* getUnicode32(const char* vname);
    BxShort16* getShort16(const char* vname);
    BxInteger32* getInteger32(const char* vname);
    BxLong64* getLong64(const char* vname);
    BxUnsignedShort16* getUnsignedShort16(const char* vname);
    BxUnsignedInteger32* getUnsignedInteger32(const char* vname);
    BxUnsignedLong64* getUnsignedLong64(const char* vname);
    BxFloat32* getFloat32(const char* vname);
    BxDouble64* getDouble64(const char* vname);
    BxDoubleExtended80* getDoubleExtended80(const char* vname);
    BxDoubleExtended96* getDoubleExtended96(const char* vname);
    BxQuadruple128* getQuadruple128(const char* vname);
    BxDataset* getDataset(const char* vname);
    BxArray* getArray(const char* vname);
    BxUnion* getUnion(const char* vname);
    BxString* getString(const char* vname);
    bool isByte8(const char* vname) const;
    bool isCharacter8(const char* vname) const;
    bool isUnicode16(const char* vname) const;
    bool isUnicode32(const char* vname) const;
    bool isShort16(const char* vname) const;
    bool isInteger32(const char* vname) const;
    bool isLong64(const char* vname) const;
    bool isUnsignedShort16(const char* vname) const;
    bool isUnsignedInteger32(const char* vname) const;
    bool isUnsignedLong64(const char* vname) const;
    bool isFloat32(const char* vname) const;
    bool isDouble64(const char* vname) const;
    bool isExtended80(const char* vname) const;
    bool isExtended96(const char* vname) const;
    bool isDoubleExtended(const char* vname) const;
    bool isQuadruple128(const char* vname) const;
    bool isVoid0(const char* vname) const;
    bool isDataset(const char* vname) const;
    bool isArray(const char* vname) const;
    bool isUnion(const char* vname) const;
    bool isString(const char* vname) const;

    bool addDataObject(BxDataObject &); // add a object reference with copy to the list
    bool addDataObject(BxDataObject *); // add a pointer to a BxDataObject or deriatives

    int findObjectIndex(const char* name) const;

    void resize();  // calculate sizeInAll_ for this dataset

        // Set the number of times to repeat the elements using the dim attribute
    void repeat(int);

        // Return the number of times to repeat the elements using the dim attribute
    int repeat() const { return repeat_; }

protected:
        // Protected operations

    BxDataObject* findObject(const char* name) const;
    void copyDataObjects(const BxDataset& ds);
    byte* getBuffer(); // return the buffer


        // Protected data

    BxDataObjects dataObjects_;   //<a list of data elements
    byte* pBuffer_;    //<buffer to hold byte stream of all elements
private:
        // Private data

        // keep an index of the current referenced data object. to be used by next(), is*, get().
    int nCurrentObject_; 

        // Stores the number of times to repeat the elements using the dim attribute
    int repeat_;
};

#endif

---