icptrholder_cxx.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2001, Critical Path
 * SPDX-License-Identifier: LGPL-2.1-only OR MPL-2.0
 */

#ifndef ICPTRHOLDER_CXX_H
#define ICPTRHOLDER_CXX_H

#include <cassert>

template<class T>
class ICPointerHolder
{
public:
    ICPointerHolder()
        : ptr(0)
    {
    }

    /* cppcheck-suppress noExplicitConstructor */
    ICPointerHolder(T *p) // NOLINT(runtime/explicit)
        : ptr(p)
    {
    }

    // copy constructor to support assignment
    ICPointerHolder(const ICPointerHolder &ip)
        : ptr(ip.ptr)
    {
        // We need to transfer ownership of ptr to this object by setting
        // ip's ptr to null. Otherwise, ptr will de deleted twice.
        // const ugliness requires us to do the const_cast.
        ICPointerHolder *ipp = const_cast<ICPointerHolder *>(&ip);

        ipp->ptr = 0;
    };

    ~ICPointerHolder()
    {
        release();
    }

    ICPointerHolder &operator=(T *p)
    {
        this->release();
        ptr = p;
        return *this;
    }

    ICPointerHolder &operator=(ICPointerHolder &p) //NOLINT(misc-unconventional-assign-operator)
    {
        if (this == &p) {
            return *this;
        }
        this->release();
        ptr = p.ptr; // this transfer ownership of the pointer
        p.ptr = 0;   // set it to null so the pointer won't get delete twice.
        return *this;
    }

    /* cppcheck-suppress constParameterPointer */
    bool operator!=(T *p)
    {
        return (ptr != p);
    }

    /* cppcheck-suppress constParameterPointer */
    bool operator==(T *p)
    {
        return (ptr == p);
    }

    operator T *() const
    {
        return ptr;
    }

    T *operator->() const
    {
        icalassert(ptr);
        return ptr;
    }

    T &operator*()
    {
        icalassert(ptr);
        return *ptr;
    }

private:
    void release()
    {
        if (ptr != 0) {
            ptr->detach();
            delete ptr;

            ptr = 0;
        }
    }

    T *ptr;
};

#endif