main/include/OwnedPtr.h

/*
This file is part of Caelum.
See http://www.ogre3d.org/wiki/index.php/Caelum 

Copyright (c) 2008 Caelum team. See Contributors.txt for details.

Caelum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Caelum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CAELUM__OWNED_PTR_H
#define CAELUM__OWNED_PTR_H

#include "CaelumPrerequisites.h"

namespace Caelum
{
    template<class PointedT>
    struct DefaultOwnedPtrTraits
    {
        typedef PointedT* InnerPointerType;

        static inline const InnerPointerType getNullValue() {
            return 0;
        }

        static inline PointedT* getPointer (const InnerPointerType& inner) {
            return inner;
        }

        static void destroy (InnerPointerType& inner)
        {
            delete inner;
            inner = 0;
        }
    };
    
    template<class PointedT, typename TraitsT = DefaultOwnedPtrTraits<PointedT> >
    class OwnedPtr
    {
    private:
        typedef typename TraitsT::InnerPointerType InnerPointerType;

        InnerPointerType mInner;

    public:
        void reset (const InnerPointerType& newInner = TraitsT::getNullValue()) {
            if (mInner == newInner) {
                return;
            }
            TraitsT::destroy (mInner);
            mInner = newInner;
        }

        OwnedPtr() { mInner = TraitsT::getNullValue (); }

        ~OwnedPtr() { setNull(); }

        OwnedPtr(OwnedPtr& rhs)
        {
            if (&rhs != this) {
                this->reset (rhs.mInner);
                rhs.mInner = TraitsT::getNullValue ();
            }
        }
        
        const OwnedPtr& operator=(OwnedPtr& rhs)
        {
            if (&rhs != this) {
                this->reset (rhs.mInner);
                rhs.mInner = TraitsT::getNullValue ();
            }
            return *this;
        }

        bool isNull () const { return mInner != TraitsT::getNullValue (); }

        void setNull () { TraitsT::destroy (mInner); }

        PointedT* getPointer () const { return TraitsT::getPointer (mInner); }
        PointedT* get () const { return getPointer (); }
        PointedT* operator-> () const { return getPointer (); }
        PointedT& operator* () const{ return *getPointer (); }
    };

    template<class MovableT>
    struct MovableObjectOwnedPtrTraits: public DefaultOwnedPtrTraits<MovableT>
    {
        typedef MovableT* InnerPointerType;

        static void destroy (InnerPointerType& inner)
        {
            if (inner != 0) {
                //Ogre::LogManager::getSingletonPtr ()->logMessage (
                //        "OwnedPtr: Destroying movable object " + inner->getName ());
                inner->_getManager ()->destroyMovableObject (inner);
                inner = 0;
            }
        }
    };

    typedef OwnedPtr<Ogre::MovableObject, MovableObjectOwnedPtrTraits<Ogre::MovableObject> > MovableObjectPtr;
    typedef OwnedPtr<Ogre::BillboardChain, MovableObjectOwnedPtrTraits<Ogre::BillboardChain> > BillboardChainPtr;
    typedef OwnedPtr<Ogre::BillboardSet, MovableObjectOwnedPtrTraits<Ogre::BillboardSet> > BillboardSetPtr;
    typedef OwnedPtr<Ogre::Entity, MovableObjectOwnedPtrTraits<Ogre::Entity> > EntityPtr;
    typedef OwnedPtr<Ogre::Light, MovableObjectOwnedPtrTraits<Ogre::Light> > LightPtr;
    typedef OwnedPtr<Ogre::ManualObject, MovableObjectOwnedPtrTraits<Ogre::ManualObject> > ManualObjectPtr;
    typedef OwnedPtr<Ogre::ParticleSystem, MovableObjectOwnedPtrTraits<Ogre::ParticleSystem> > ParticleSystemPtr;

    struct SceneNodeOwnedPtrTraits: public DefaultOwnedPtrTraits<Ogre::SceneNode>
    {
        static void destroy (InnerPointerType& inner)
        {
            if (inner) {
                //Ogre::LogManager::getSingletonPtr ()->logMessage (
                //        "OwnedPtr: Destroying scene node " + inner->getName ());
                inner->getCreator ()->destroySceneNode (inner->getName ());
                inner = 0;
            }
        }
    };

    typedef OwnedPtr<Ogre::SceneNode, SceneNodeOwnedPtrTraits> SceneNodePtr;

    template<class PointedT, class InnerT, class ManagerT>
    struct OwnedResourcePtrTraits
    {
        typedef InnerT InnerPointerType;

        static const InnerT getNullValue () {
            return InnerT();
        }

        static PointedT* getPointer (const InnerPointerType& inner) {
            return inner.getPointer ();
        }

        static void destroy (InnerPointerType& inner) {
            if (!inner.isNull ()) {
                //Ogre::LogManager::getSingletonPtr ()->logMessage (
                //        "OwnedPtr: Destroying owned resource " + inner->getName ());
                ManagerT::getSingletonPtr ()->remove (inner->getHandle ());
                assert (inner.unique () && "Resource pointer not unique after destruction");
            }
        }
    };

    typedef OwnedPtr <
        Ogre::Material,
        OwnedResourcePtrTraits <
            Ogre::Material,
            Ogre::MaterialPtr,
            Ogre::MaterialManager
        >
    > OwnedMaterialPtr;

    typedef OwnedPtr <
        Ogre::Mesh,
        OwnedResourcePtrTraits <
            Ogre::Mesh,
            Ogre::MeshPtr,
            Ogre::MeshManager
        >
    > OwnedMeshPtr;
}

#endif // CAELUM__OWNED_PTR_H

---