common/ac/shared_ptr/aegis.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 2007, 2008 Peter Miller
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; either version 3 of the License, or
//      (at your option) any later version.
//
//      This program 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 General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program. If not, see
//      <http://www.gnu.org/licenses/>.
//

#ifndef COMMON_AC_SHARED_PTR_AEGIS_H
#define COMMON_AC_SHARED_PTR_AEGIS_H

#include <common/error.h> // for assert

template<class T>
class aegis_shared_ptr
{
private:
    long *reference_count;

    T *subject;

public:
    bool
    valid()
        const
    {
        return
            (
                (reference_count != 0)
            ?
                (*reference_count > 0 && subject != 0)
            :
                (subject == 0)
            );
    }

    ~aegis_shared_ptr()
    {
        assert(valid());
        if (reference_count)
        {
            --*reference_count;
            if (*reference_count <= 0)
            {
                delete subject;
                subject = 0;
                delete reference_count;
                reference_count = 0;
            }
        }
    }

    void
    swap(aegis_shared_ptr &rhs)
    {
        assert(valid());
        assert(rhs.valid());
        long *temp_reference_count = reference_count;
        T *temp_subject = subject;
        reference_count = rhs.reference_count;
        subject = rhs.subject;
        rhs.reference_count = temp_reference_count;
        rhs.subject = temp_subject;
    }

    void
    reset()
    {
        // swap with a NULL pointer
        aegis_shared_ptr tmp;
        this->swap(tmp);
    }

    aegis_shared_ptr() :
        reference_count(0),
        subject(0)
    {
        assert(valid());
    }

    template<class Y> explicit
    aegis_shared_ptr(Y *rhs) :
        reference_count(0),
        subject(0)
    {
        assert(valid());
        if (rhs)
        {
            reference_count = new long(1);
            subject = rhs;
        }
        assert(valid());
    }

    aegis_shared_ptr(const aegis_shared_ptr &rhs) :
        reference_count(0),
        subject(0)
    {
        assert(rhs.valid());
        if (rhs.subject)
        {
            assert(rhs.reference_count);
            reference_count = rhs.reference_count;
            subject = rhs.subject;
            ++*reference_count;
        }
        assert(valid());
    }

    template <class Y> friend class aegis_shared_ptr;

    template<class Y>
    aegis_shared_ptr(const aegis_shared_ptr<Y> &rhs) :
        reference_count(0),
        subject(0)
    {
        assert(rhs.valid());
        if (rhs.subject)
        {
            assert(rhs.reference_count);
            reference_count = rhs.reference_count;
            subject = rhs.subject;
            ++*reference_count;
        }
        assert(valid());
    }

    aegis_shared_ptr &
    operator=(const aegis_shared_ptr &rhs)
    {
        assert(valid());
        assert(rhs.valid());
        if (this != &rhs)
        {
            // In case you haven't seen the swap() technique to
            // implement copy assignment before, here's what it does:
            //
            // 1) Create a temporary aegis_shared_ptr<> instance via the
            //    copy constructor, thereby increasing the reference
            //    count of the source object.
            //
            // 2) Swap the internal object pointers of *this and the
            //    temporary aegis_shared_ptr<>.  After this step, *this
            //    already contains the new pointer, and the old pointer
            //    is now managed by temp.
            //
            // 3) The destructor of temp is executed, thereby
            //    unreferencing the old object pointer.
            //
            // This technique is described in Herb Sutter's "Exceptional
            // C++", and has a number of advantages over conventional
            // approaches:
            //
            // - Code reuse by calling the copy constructor.
            // - Strong exception safety for free.
            // - Self assignment is handled implicitly.
            // - Simplicity.
            // - It just works and is hard to get wrong; i.e. you can
            //   use it without even thinking about it to implement
            //   copy assignment where ever the object data is managed
            //   indirectly via a pointer, which is very common.
            //
            aegis_shared_ptr temp(rhs);
            this->swap(temp);
            assert(valid());
            assert(rhs.valid());
        }
        return *this;
    }

    template<class Y>
    aegis_shared_ptr &
    operator=(const aegis_shared_ptr<Y> &rhs)
    {
        assert(valid());
        assert(rhs.valid());
        if (this != (aegis_shared_ptr *)&rhs)
        {
            aegis_shared_ptr tmp(rhs);
            this->swap(tmp);
            assert(valid());
            assert(rhs.valid());
        }
        return *this;
    }

#if 0

    template<class Y> explicit
    aegis_shared_ptr(std::auto_ptr<Y> &rhs) :
        reference_count(0),
        subject(0)
    {
        Y *tmp = r.get();
        if (tmp)
        {
            reference_count = new long(1);
            subject = tmp;
        }
        assert(valid());
    }

    template<class Y>
    aegis_shared_ptr &
    operator=(std::auto_ptr<Y> &rhs)
    {
        assert(valid());
        reset();
        if (tmp)
        {
            reference_count = new long(1);
            subject = tmp;
        }
        assert(valid());
        return *this;
    }

#endif

    T &
    operator*()
        const
    {
        assert(subject != 0);
        return *subject;
    }

    T *
    operator->()
        const
    {
        assert(subject != 0);
        return subject;
    }

    T *
    get()
        const
    {
        return subject;
    }

    operator bool()
        const
    {
        return (subject != 0);
    }

    bool
    operator!()
        const
    {
        return (subject == 0);
    }

    inline bool
    operator==(const aegis_shared_ptr &rhs)
        const
    {
        return (subject == rhs.get());
    }

    template<class U>
    inline bool
    operator==(const aegis_shared_ptr<U> &rhs)
        const
    {
        return (subject == rhs.get());
    }

    inline bool
    operator!=(aegis_shared_ptr &rhs)
        const
    {
        return (subject != rhs.get());
    }

    template<class U>
    inline bool
    operator!=(aegis_shared_ptr<U> &rhs)
        const
    {
        return (subject != rhs.get());
    }

    inline bool
    operator<(aegis_shared_ptr &rhs)
        const
    {
        return (subject < rhs.get());
    }

    template<class U>
    inline bool
    operator<(aegis_shared_ptr<U> &rhs)
        const
    {
        return (subject < rhs.get());
    }
};

#endif // COMMON_AC_SHARED_PTR_AEGIS_H

---