devel/libmdw/trunk/libmdw/src/SharedPtr.h

/***************************************************************************
 *   Copyright (C) 2010 by Jean-Baptiste Wons   *
 *   wonsjb@gmail.com   *
 *                                                                         *
 *   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 2 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef __SHARED_PTR_H
#define __SHARED_PTR_H

#include <iostream>

namespace mdw
{
template <class T>
class SharedPtr
{
public:
    SharedPtr()
    {
        _internal = 0;
        _counter = 0;
    }
    SharedPtr (T* pointer)
    {
        _internal = pointer;
        _counter = new int;
        _released = new bool;
        *_counter = 1;
        *_released = false;
    }
    SharedPtr (const SharedPtr & other)
    {
        if (other._internal != 0 && other._counter != 0)
        {
            _internal = other._internal;
            _counter = other._counter;
            _released = other._released;
            ++ (*_counter);
        }
        else
        {
            _internal = 0;
            _counter = 0;
            _released = 0;
        }
    }
    ~SharedPtr()
    {
        if (_internal != 0 && _counter != 0)
        {
            -- (*_counter);
            if (*_counter == 0)
            {
                if (!*_released)
                {
                    delete _internal;
                }
                delete _counter;
                delete _released;
            }
        }
    }
    SharedPtr & operator= (const SharedPtr & other)
    {
        if (this == &other)
        {
            return;
        }
        if (other._internal != 0 && other._counter != 0)
        {
            _internal = other._internal;
            _counter = other._counter;
            _released = other._released;
            ++ (*_counter);
        }
        else
        {
            _internal = 0;
            _counter = 0;
            _released = 0;
        }
        return *this;
    }
    SharedPtr & operator= (T* pointer)
    {
        if (_internal != NULL && _counter != NULL)
        {
            -- (*_counter);
            if (*_counter == 0)
            {
                delete _internal;
            }
            else
            {
                _counter = new int;
                _released = new bool;
            }
            *_counter = 1;
            _released = false;
            _internal = pointer;
        }
        else
        {
            _internal = pointer;
            _counter = new int;
            *_counter = 1;
        }
        return *this;
    }
    T & operator*()
    {
        return *_internal;
    }
    T * operator->()
    {
        return _internal;
    }
    const T & operator*() const
    {
        return *_internal;
    }
    const T* operator->() const
    {
        return _internal;
    }
    const T* get() const
    {
        return _internal;
    }
    T* release()
    {
        if (_internal != NULL && _counter != NULL)
        {
            -- (*_counter);
            if (*_counter == 0)
            {
                delete _counter;
                _counter = 0;
                delete _released;
                _released = 0;
            }
            else
            {
                _released = true;
            }
        }
        T* res = _internal;
        _internal = 0;
        return res;
    }
    int getCount() const
    {
        return *_counter;
    }
    bool isNull() const
    {
        return _internal == 0;
    }
private:
    T *_internal;
    int * _counter;
    bool * _released;
};
}

#endif

---