---

DynamicObject.h

/*
  File: DynamicObject.h

  Copyright(C) C. Kotterink, Computed Graphics
*/
#ifndef DYNAMICOBJECT_H
#define DYNAMICOBJECT_H

#include<Class.h>
#include<RefCount.h>

#include<string>
#include<map>
#include<iostream>

class Mutex;
class Token;

#define DYNAMIC_OBJECT                                          \
private: static Class classObject;                              \
public: static Class& myClass() { return classObject; };        \
        virtual Class& getClass() { return classObject; };

#define IMPLEMENT_DYNAMIC(CLASS, SUPER)                         \
static DynamicObject *create##CLASS() {                         \
    return new CLASS;                                           \
}                                                               \
Class CLASS::classObject(#CLASS, #SUPER, create##CLASS);

#define IMPLEMENT_SINGLETON(CLASS, SUPER)                       \
static CLASS instance;                                          \
static DynamicObject *create##CLASS() {                         \
    return &instance;                                           \
}                                                               \
Class CLASS::classObject(#CLASS, #SUPER, create##CLASS);

using namespace std;

class ObjectFile;
class DynamicObject;
typedef RefCount<DynamicObject> RefObject;

class DynamicObject
{
    DYNAMIC_OBJECT;

public:
    static bool find(RefObject &object, const string &name);

    static RefObject &store(RefObject &object, const string &name);

    static RefObject readRefObject(const string className, ObjectFile &file);

    virtual ~DynamicObject();

    const string &className() {
        return getClass().name();
    }
    bool isKindOf(const string aClass) {
        return getClass().isKindOf(aClass);
    }
    bool isKindOf(Class &aClass) {
        return getClass().isKindOf(&aClass);
    }

    void read(ObjectFile &file);

    void write(ostream &stream);

    void readParams(ObjectFile &file);

    virtual void writeParams(ostream &stream);

    virtual void parseSymbol(Token &t, ObjectFile &file);

protected:
    virtual void createSymbols();

    static Mutex mutex;

    static map<string, RefObject> objectPool;
};

// Stream functions

ObjectFile &operator>>(ObjectFile &file, DynamicObject *&obj);

ObjectFile &operator>>(ObjectFile &file, RefObject &obj);

inline ostream &operator<<(ostream &stream, DynamicObject &obj)
{
    obj.write(stream);
    return stream;
}
#endif

---

This documentation was generated using doxygen. If you have any comments or additions please mail me.