BxQuadruple128.h

// ##################################################################
// Binx
// $Id: BxQuadruple128_8h-source.html,v 1.1.1.1 2006/04/19 14:19:02 edikt2 Exp $
//
// Class for 128-bit floating point numbers.
// ##################################################################
/*

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

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

*/

#ifndef __BxQuadruple128__
#define __BxQuadruple128__

#include "BxFloat.h"

/*
 * Class implementing the BinX data type 128-bit floating point numbers.
 * Instances of this class hold and perform operations on the BinX XML Schema
 * type <quadruple-128>.
 * <BR>The implementation of quadruple precision floating point operations 
 * is highly and compiler platform dependent.
 * On little endian system (such as processors designed by Intel Corporation)
 * quadruple precision is supported as follows:
 * <UL>
 * <li>The GNU C language Compiler uses 96-bit extended floating point numbers</li>
 * <li>The Borland C language Compiler uses 80-bit extended floating point numbers</li>
 * </UL>
 * On big endian systems (such processors desgined by Sun Microsystems)
 * quadruple precision is supported as follows:
 * <UL>
 * <li>Under the operating system SunOS, the GNU C language Compiler
 * uses 128-bit floating point numbers</li>
 * </UL>
 * <BR>Machines that support extended floating point number formats
 * may support 80-bit extensions, 96-bit extensions, or 128-bit extensions.
 * BinX defines all of these as primitive data types,
 * but individual platforms will support only a subset of these data types.
 * This can result in incompatibilities between floating point numbers
 * contained in binary data files written by one machine
 * and the ability to properly process those values on another machine.
 * The BinX library implements methods for converting between floating point numbers
 * having 80-bit and 96-bit precision.
 * The BinX library does <B>not</B> implement methods for converting between
 * 128-bit precision and 80-bit or 96-bit precision.
 * <BR>It is possible for a binary data file to contain
 * quadruple precision floating point numbers
 * and the target host machine does not support quadruple precision.
 * When attempting to read these 128-bit floating point values,
 * the BinX library returns raises an error condition and returns the value zero.
 * <BR>This class also implements methods to:
 * <UL>
 * <li>Serialize a floating point value to a file stream</li>
 * <li>Parse and store an individual floating point value from a file or a stream buffer</li>
 * </UL>
 * <BR><B>Implementation Notes:</B><BR>
 * BinX implements quadruple floating point numbers
 * using the C-language type "long double". 
 * <BR><B>Since:</B>  BinX version 1.0.
 */
class DECLSPEC BxQuadruple128 : public BxFloat
{
public:
    BxQuadruple128();
    BxQuadruple128(const bx_quadruple128);
    BxQuadruple128(const BxQuadruple128& copy);
    virtual ~BxQuadruple128();

    virtual char* className() const { return "BxQuadruple128"; } //<Returns the null-terminated string "BxQuadruple128".
    virtual BxQuadruple128* clone() const;
    virtual void print();
    virtual bool equals(const BxDataObject&) const;
    virtual char * toString(bool xml); //new a string for the value
    virtual bool parseValue(const char *);
    virtual bool readFromFile();
    virtual void readFromBuffer(const byte *);  //read data from a buffer
    
    BxQuadruple128& operator=(const bx_quadruple128);
};

#endif

---