BxDataObject.h

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

#ifndef BXDATAOBJECT_H
#define BXDATAOBJECT_H

#include "BxObject.h"
#include "BxBinaryFile.h"

#include <string.h>

union BxDataUnion
{
    bx_byte8    b_;     // Provides storage for 8-bit, a single byte, and a single unsigned byte data values.
    bx_ubyte8   ub_;    // Provides storage for 8-bit, unsigned.
    bx_char8    c_;     // Provides storage for single character data values.
    bx_short16  s_;     // Provides storage for 16-bit integer data values.
    bx_ushort16 us_;    // Provides storage for 16-bit unsigned integer, and 16-bit unicode data values.
    bx_int32    i_;     // Provides storage for 32-bit integer data values.
    bx_uint32   ui_;    // Provides storage for 32-bit unsigned integer, and 32-bit unicode data values.
    bx_long64   l_;     // Provides storage for 64-bit integer values. When using C++Builder, this is restricted to 32-bit representations.
    bx_ulong64  ul_;    // Provides storage for 64-bit unsigned integer data values. When using C++Builder this is restricted to 32-bit representations.
    bx_float32       f_;   // Provides storage for 32-bit floating point numbers.
    bx_double64      d_;   // Provides storage for 64-bit floating point numbers.
    bx_extended80    e_;   // Provides storage for 80-bit floating point numbers.
    bx_quadruple128  q_; // Provides storage for 128-bit floating point numbers.
    byte  block_[16]; // Provides maximum storage size of 128-bit (16 bytes) for quadruple floating point numbers or future large data types.
    void* ptr_;   // Provides a pointer reference to any BinX primitive or abstract data type.
};

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

        // The default copy constructor
    BxDataObject(const BxDataObject& copy);

        // The destructor
    virtual ~BxDataObject();

    virtual char* className() const { return "BxDataObject"; }   //Get class name for this object.
    virtual BxDataObject* clone() const;      //make a copy of the object

    int dataClass() const { return dataClass_; }    
    int bits() const { return sizeInBits_; }    //<Get the number of bits used to store the primary data value of this object.
    int bytes() const { return sizeInBytes_; }  
    int size() const { return sizeInAll_; }     
    long offset() const { return offsetInFile_; }   
    BxByteOrder byteOrder() const { return byteOrder_; }    
    BxDataUnion getDataValue() const { return dataValue_; } 

    BxBinaryFile* binaryFile() const { return bfile_; }
    bool loaded() const { return loaded_; }     

    virtual char* typeName() const { return typeName_; }    
    virtual char* varName() const;   //returns the variable name
    virtual char* testValue() const { return testValue_; }  //<Get the test value for this object.
    virtual int   blockSize() const { return blockSize_; }  
    virtual void  setByteOrder(BxByteOrder bo) { byteOrder_ = bo; } 
    virtual void  setBlockSize(int blocksize) { blockSize_ = blocksize; }   
    virtual void  setOffset(long offset) { offsetInFile_ = offset; }    //<Set the byte offset to locate the primary data value in the associated binary file.

    virtual bool  parseValue(const char*);

        //read data value from binary file for this data object - should make pure virtual
    virtual bool  readFromFile();
    virtual void  readFromBuffer(const byte*);  //read data from a buffer
    virtual void  setBinaryFilePtr(BxBinaryFile* fp);
    virtual bool  save();    //save the object in the binary file.
    virtual void  print();   //print the attributes and value.
    virtual bool  equals(const BxDataObject&) const;
    virtual char* toString(bool xml); //new a string for the value
    virtual bool  toStream(FILE*);
    virtual bool  toStreamBinary(FILE*);

        // Write out the binary data with the specified byte order
    virtual bool  toStreamBinary(FILE*, BxByteOrder);
    virtual long  locate() const; //seek file pointer to the object offset

    virtual byte* getDataPointer(); //return data pointer

    bx_byte8    getByte();      //return the value as a byte
    bx_ubyte8   getUnsignedByte();  //return the value as an unsigned byte
    bx_char8    getChar();    //return the data value as a char
    bx_short16   getShort();   //return the data value as a short int
    bx_int32     getInt();     //return the data value as an int
    bx_long64    getLong();    //return the data value as a long
    bx_float32   getFloat();   // return the data value as a float
    bx_double64  getDouble();  // return the data value as a double
    bx_extended80   getExtended80();  // return extended floating point value
    bx_extended96   getExtended96();
    bx_quadruple128 getQuadruple(); // return data value as a quaduple floating number
    bx_ushort16 getUnsignedShort();    //return unsigned short
    bx_ushort16 getUnicode16();
    bx_uint32 getUnicode32();
    bx_uint32 getUnsignedInt();    //return unsigned int
    bx_ulong64 getUnsignedLong();  //return unsigned long

    void copyTypeName(const char* typeName);
    void copyVarName(const char* vname);
    void setTypeName(char* typeName);
    void setVarName(char* vname);
    void setTestValue(char* testValue);

    bool needChangeByteOrder() const;

    void setByte(bx_byte8 b);
    void setChar(bx_char8 c);
    void setShort(bx_short16 s);
    void setInt32(bx_int32 i);
    void setLong64(bx_long64 l);
    void setFloat(bx_float32 f);
    void setDouble(bx_double64 d);
    void setExtended(bx_extended80 e);
    void setQuadruple(bx_quadruple128 q);
    void setUnsignedByte(bx_ubyte8 ub);
    void setUnsignedShort(bx_ushort16 us);
    void setUnsignedInt32(bx_uint32 ui);
    void setUnsignedLong64(bx_ulong64 ul);

protected:
        // Protected operations

    int computeElementSize(int elem);
    void fillElementHead(char* buf, int elem);
    void fillElementTail(char* buf, int elem);


        // Protected data

    int dataClass_;     // data class for this object, e.g., BXINTEGER32, etc.
    int sizeInBits_;    // number of bits for this data object, used for primitive data types only
    int sizeInBytes_;   // number of bytes for this data object
    int sizeInAll_;     // real size in bytes, inlcuding block size adjustment and padding ofr alignment
    long offsetInFile_;  // offset of this data element in the binary file
    int  blockSize_;     // number of bits for this block, if specified
    bool loaded_;        // indicates whether a data value is loaded from the binary file
    char* typeName_;     // data type name, used mainly for user-defined types
    char* varName_;      // name of the variable, user-defined in the BinX document
    char* testValue_;    // used for testing purpose only
    BxByteOrder byteOrder_; // byte order of the data element, if applicable
    BxBinaryFile* bfile_;   // pointer to the open binary file
    BxDataUnion dataValue_; // the application data value, read from or to be written to a binary file
};

#endif

---