PrivatePtr.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__PRIVATE_PTR_H
#define CAELUM__PRIVATE_PTR_H

#include "CaelumPrerequisites.h"

namespace Caelum
{
    template<class PointedT>
    struct DefaultPrivatePtrTraits
    {
        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 = DefaultPrivatePtrTraits<PointedT> >
    class PrivatePtr
    {
    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;
        }

        InnerPointerType release () {
            InnerPointerType result = mInner;
            mInner = TraitsT::getNullValue();
            return result;
        }

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

        PrivatePtr (const InnerPointerType& inner) { mInner = inner; }

        ~PrivatePtr () { setNull(); }

        PrivatePtr (PrivatePtr& rhs)
        {
            if (&rhs != this) {
                this->reset (rhs.mInner);
                rhs.mInner = TraitsT::getNullValue ();
            }
        }
        
        const PrivatePtr& operator= (PrivatePtr& 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);
            assert(this->isNull());
        }

        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 MovableObjectPrivatePtrTraits: public DefaultPrivatePtrTraits<MovableT>
    {
        typedef MovableT* InnerPointerType;

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

    typedef PrivatePtr<Ogre::MovableObject, MovableObjectPrivatePtrTraits<Ogre::MovableObject> > PrivateMovableObjectPtr;
    typedef PrivatePtr<Ogre::BillboardChain, MovableObjectPrivatePtrTraits<Ogre::BillboardChain> > PrivateBillboardChainPtr;
    typedef PrivatePtr<Ogre::BillboardSet, MovableObjectPrivatePtrTraits<Ogre::BillboardSet> > PrivateBillboardSetPtr;
    typedef PrivatePtr<Ogre::Entity, MovableObjectPrivatePtrTraits<Ogre::Entity> > PrivateEntityPtr;
    typedef PrivatePtr<Ogre::Light, MovableObjectPrivatePtrTraits<Ogre::Light> > PrivateLightPtr;
    typedef PrivatePtr<Ogre::ManualObject, MovableObjectPrivatePtrTraits<Ogre::ManualObject> > PrivateManualObjectPtr;
    typedef PrivatePtr<Ogre::ParticleSystem, MovableObjectPrivatePtrTraits<Ogre::ParticleSystem> > PrivateParticleSystemPtr;

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

    typedef PrivatePtr<Ogre::SceneNode, SceneNodePrivatePtrTraits> PrivateSceneNodePtr;

    template<class PointedT, class InnerT, class ManagerT>
    struct PrivateResourcePtrTraits
    {
        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 (
                //        "PrivateResourcePtrTraits: Destroying owned resource"
                //        " name=" + inner->getName () +
                //        " handle=" + Ogre::StringConverter::toString (inner->getHandle ()) );
                ManagerT::getSingletonPtr ()->remove (inner->getHandle ());
                assert (inner.unique () && "Resource pointer not unique after destruction");
                inner.setNull();
            }
        }
    };

    typedef PrivatePtr <
        Ogre::Material,
        PrivateResourcePtrTraits <
            Ogre::Material,
            Ogre::MaterialPtr,
            Ogre::MaterialManager
        >
    > PrivateMaterialPtr;

    typedef PrivatePtr <
        Ogre::Mesh,
        PrivateResourcePtrTraits <
            Ogre::Mesh,
            Ogre::MeshPtr,
            Ogre::MeshManager
        >
    > PrivateMeshPtr;
}

#endif // CAELUM__PRIVATE_PTR_H