weakptr.h

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2009 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
**    Harry Storbacka
*/



#pragma once


#include "../api_core.h"
#include "sharedptr.h"

template <typename Type>
class CL_WeakPtr : public CL_SharedPtr_Link
{
public:
        CL_WeakPtr()
        : ptr(0)
        {
                set_weak_link();
        }

        CL_WeakPtr(const CL_WeakPtr<Type> &copy)
        : ptr(0)
        {
                set_weak_link();
                connect(copy);
                ptr = copy.ptr;
        }

        explicit CL_WeakPtr(const CL_SharedPtr<Type> &copy)
        : ptr(0)
        {
                set_weak_link();
                connect(copy);
                ptr = copy.ptr;
        }

        explicit CL_WeakPtr(const CL_UnknownSharedPtr &copy)
        : ptr(0)
        {
                set_weak_link();
                connect(copy);
                ptr = (Type *) copy.ptr;
        }

        ~CL_WeakPtr()
        {
                disconnect();
        }

        CL_WeakPtr &operator =(const CL_UnknownSharedPtr &copy)
        {
                disconnect();
                connect(copy);
                ptr = (Type *) copy.ptr;
                set_weak_link();
                return *this;
        }

        CL_WeakPtr &operator =(const CL_SharedPtr<Type> &copy)
        {
                disconnect();
                connect(copy);
                ptr = copy.ptr;
                set_weak_link();
                return *this;
        }

        CL_WeakPtr &operator =(const CL_WeakPtr &copy)
        {
                if (this == &copy)
                        return *this;
                disconnect();
                connect(copy);
                ptr = copy.ptr;
                set_weak_link();
                return *this;
        }


        bool disconnect()
        {
                bool result = CL_SharedPtr_Link::disconnect();
                ptr = NULL;
                return result;
        }


        bool is_null() const { return is_invalid_weak_link() || ptr == 0; }


        Type *get() { return !is_invalid_weak_link() ? ptr : 0; }


        const Type *get() const { return !is_invalid_weak_link() ? ptr : 0; }

        CL_UnknownSharedPtr to_unknownptr() const
        {
                if (!is_invalid_weak_link())
                        return CL_UnknownSharedPtr(*this, (Type *) ptr);
                else
                        return CL_UnknownSharedPtr();
        }

        CL_SharedPtr<Type> to_sharedptr() const
        {
                if (!is_invalid_weak_link())
                        return CL_SharedPtr<Type>(*this, (Type *) ptr);
                else
                        return CL_SharedPtr<Type>();
        }

        operator Type *() { return get(); }

        operator const Type *() const { return get(); }

        operator CL_UnknownSharedPtr() { return to_unknownptr(); }

        operator CL_UnknownSharedPtr() const { return to_unknownptr(); }

        operator CL_SharedPtr<Type>() { return to_sharedptr(); }

        operator CL_SharedPtr<Type>() const { return to_sharedptr(); }

        Type *operator ->() { return get(); }

        const Type *operator ->() const { return get(); }

        template <typename OtherType>
        bool operator ==(OtherType *other) const { return ptr == other; }

        template <typename OtherType>
        bool operator !=(OtherType *other) const { return ptr != other; }

        template <typename OtherType>
        bool operator <(OtherType *other) const { return ptr < other; }

        template <typename OtherType>
        bool operator <=(OtherType *other) const { return ptr <= other; }

        template <typename OtherType>
        bool operator >(OtherType *other) const { return ptr > other; }

        template <typename OtherType>
        bool operator >=(OtherType *other) const { return ptr >= other; }

public:
        Type *ptr;
};

---