source: NonGTP/FCollada/FUtils/FUObject.h @ 964

/*
        Copyright (C) 2005-2006 Feeling Software Inc.
        MIT License: http://www.opensource.org/licenses/mit-license.php
*/
/*
        The idea is simple: the object registers itself in the constructor, with one container.
        It may register/unregister itself with other containers subsequently.

        It keeps a list of the containers and a pointer to the main container so that the up-classes
        can easily access it. In the destructor, the object unregisters itself with the container(s).

        The object has a RTTI-like static class structure so that the container(s) know which
        object type list to remove this object from when it is deleted.
*/

/**
        @file FUObject.h
        This file contains the FUObject class, the FUObjectContainer class and the FUObjectType class.
*/

#ifndef _FU_OBJECT_H_
#define _FU_OBJECT_H_

class FUObjectContainer;

#include "FUtils/FUObjectType.h"

/**
        A contained object.
        Each object holds a pointer to the container that contains it.
        This pointer is useful so that the container can be notified if the object
        gets released by someone else.
        @ingroup FUtils
*/
class FCOLLADA_EXPORT FUObject
{
private:
        FUObjectContainer* container;
        static class FUObjectType* baseObjectType;

protected:
        /** Retrieves the container of the object.
                @return A pointer to the container. */
        inline FUObjectContainer* GetContainer() { return container; }
        inline const FUObjectContainer* GetContainer() const { return container; } /**< See above. */

public:
        /** Constructor.
                Although it is not an abstract class, class is
                not meant to be used directly. This constructor
                informs the container of the object's creation.
                @param container The container that contains this object. */
        FUObject(FUObjectContainer* container);

        /** Destructor.
                This function informs the container of this object's release. */
        ~FUObject();

        /** Retrieves the type of the base object class.
                @return The type of the base object class. */
        static const FUObjectType& GetClassType() { return *baseObjectType; }

        /** Retrieves the type of the object class.
                @return The type of the base object class. */
        virtual const FUObjectType& GetObjectType() const { return *baseObjectType; }
};

/** A dynamically-sized array of contained objects. */
typedef vector<FUObject*> FUObjectList;

/**
        An object container
        Each container holds a list of contained objects.
        It will release all the objects when it is released and the
        objects inform it of their creation/destruction.
        @ingroup FUtils
*/
class FCOLLADA_EXPORT FUObjectContainer
{
private:
        friend class FUObject;
        FUObjectList objects;

        void RegisterObject(FUObject* object);
        void UnregisterObject(FUObject* object);

public:
        /** Constructor: empty. */
        FUObjectContainer() {}

        /** Destructor.
                Releases all the objects contained within this container. */
        virtual ~FUObjectContainer();

protected:
        /** Retrieves the list of objects contained within the container.
                This list should be accessed for debugging and testing purposes only.
                @return The list of contained objects. */
        inline const FUObjectList& GetObjects() const { return objects; }
};

#endif // _FU_OBJECT_H_