The Simons     Component Library

           

---

Object.h

//
//  SCL : Simons Component Library
//
//
//  Filename:   Object.h
//  Contents:   Object class
//  Author:     Anthony J H Simons
//  Revised:    31 October 2005

// This software is distributed free in the hope that others will
// find it useful.  However, it comes WITHOUT ANY WARRANTY.  No
// liability can be accepted for software failure, merchantability
// or fitness for a particular purpose.  You can redistribute this
// software in its original form, or in a modified form, provided
// that this disclaimer is retained in the file banner.

#ifndef SCL_OBJECT
#define SCL_OBJECT

#include "Basic.h"      // Include the basic types
#include "ObjectID.h"   // Include my pointer type

#include "StringID.h"   // Depends on the pointer types
#include "TypeID.h"
#include "ReaderID.h"
#include "WriterID.h"

#if defined(__LP64__) || defined (LP64_)
#undef MEMORY_MODEL
#define MEMORY_MODEL 64
#endif


class Object {
private:
        static unsigned total;          // total number of objects
        unsigned referenceCount;        // the reference count
protected:
        Object(const Object&);
        Void nullPointer(StringID) const;
        Void typeFailure(StringID) const;
        Void undefined(StringID) const;
public:
        Object();
        virtual ~Object();
        Natural references() const;
        Natural acquire();
        Natural release();
        virtual ObjectID clone() const;
        virtual TypeID type() const;
        Natural identity() const;
        virtual Natural hash() const;
        virtual Order compare(ObjectID) const;
        virtual Void readOn(ReaderID);
        virtual Void writeOn(WriterID) const;
        virtual Boolean toBoolean() const;
        virtual Character toCharacter() const;
        virtual Natural toNatural() const;
        virtual Integer toInteger() const;
        virtual Decimal toDecimal() const;
};


class Null : public Object {
public:
        Null();
        virtual ~Null();
};


inline Natural Object::references() const {
        return referenceCount;
}

inline Natural Object::identity() const {
#if MEMORY_MODEL == 32 
        return reinterpret_cast<Natural>(this);
#elif MEMORY_MODEL == 64
        const Natural* ptr = reinterpret_cast<const Natural*>(this);
        return (*ptr) ^ ( *(ptr + 1));
#else
        throw("No memory model defined");
#endif
}


inline Null::Null() {}

inline Null::~Null() {}


inline ObjectID& ObjectID::operator=(const Object* object) {
        assign(object);
        return *this;
}

inline ObjectID& ObjectID::operator=(const ObjectID& pointer) {
        assign(pointer);
        return *this;
}

inline const Object* ObjectID::pointer() const {
        return basicPointer;
}



inline bool operator==(const ObjectID& first, const ObjectID& second) {
        return first.basicPointer == second.basicPointer;
}

inline bool operator!=(const ObjectID& first, const ObjectID& second) {
        return first.basicPointer != second.basicPointer;
}


template <class T>
T* toType(const ObjectID& pointer) {
        T* object = dynamic_cast<T*>(pointer.basicPointer);
        if (object == 0) pointer.typeFailure(new T);
        return object;
}

template <class T>
T* tryType(const ObjectID& pointer) {
        return dynamic_cast<T*>(pointer.basicPointer);
}

#endif

---