CoinSmartPtr.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: CoinSmartPtr.hpp 1520 2012-01-29 00:43:31Z tkr $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
// Removed lots of debugging stuff and reformatted: Laszlo Ladanyi, IBM
#ifndef CoinSmartPtr_hpp
#define CoinSmartPtr_hpp

#include <list>
#include <cassert>
#include <cstddef>
#include <cstring>

namespace Coin {

    //#########################################################################

    class ReferencedObject {
    public:
        ReferencedObject() : reference_count_(0) {}
        virtual ~ReferencedObject()       { assert(reference_count_ == 0); }
        inline int ReferenceCount() const { return reference_count_; }
        inline void AddRef() const        { ++reference_count_; }
        inline void ReleaseRef() const    { --reference_count_; }

    private:
        mutable int reference_count_;
    };

    //#########################################################################


//#define IP_DEBUG_SMARTPTR
#if COIN_IPOPT_CHECKLEVEL > 2
# define IP_DEBUG_SMARTPTR
#endif
#ifdef IP_DEBUG_SMARTPTR
# include "IpDebug.hpp"
#endif

    template <class T>
    class SmartPtr {
    public:
        T* GetRawPtr() const { return ptr_; }

        bool IsValid() const { return ptr_ != NULL; }

        bool IsNull() const { return ptr_ == NULL; }

    private:
        T* ptr_;

        void ReleasePointer_() {
            if (ptr_) {
                ptr_->ReleaseRef();
                if (ptr_->ReferenceCount() == 0) {
                    delete ptr_;
                }
                ptr_ = NULL;
            }
        }

        SmartPtr<T>& SetFromRawPtr_(T* rhs){
            ReleasePointer_(); // Release any old pointer
            if (rhs != NULL) {
                rhs->AddRef();
                ptr_ = rhs;
            }
            return *this;
        }

        inline SmartPtr<T>& SetFromSmartPtr_(const SmartPtr<T>& rhs) {
            SetFromRawPtr_(rhs.GetRawPtr());
            return (*this);
        }
            

    public:
#define dbg_smartptr_verbosity 0

        SmartPtr() : ptr_(NULL) {}

        SmartPtr(const SmartPtr<T>& copy) : ptr_(NULL) {
            (void) SetFromSmartPtr_(copy);
        }

        SmartPtr(T* ptr) :  ptr_(NULL) {
            (void) SetFromRawPtr_(ptr);
        }

        ~SmartPtr() {
            ReleasePointer_();
        }

        T* operator->() const {
#if COIN_COINUTILS_CHECKLEVEL > 0
            assert(ptr_);
#endif
            return ptr_;
        }

        T& operator*() const {
#if COIN_IPOPT_CHECKLEVEL > 0
            assert(ptr_);
#endif
            return *ptr_;
        }

        SmartPtr<T>& operator=(T* rhs) {
            return SetFromRawPtr_(rhs);
        }

        SmartPtr<T>& operator=(const SmartPtr<T>& rhs) {
             return SetFromSmartPtr_(rhs);
        }

        template <class U1, class U2>
        friend
        bool operator==(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs);

        template <class U1, class U2>
        friend
        bool operator==(const SmartPtr<U1>& lhs, U2* raw_rhs);

        template <class U1, class U2>
        friend
        bool operator==(U1* lhs, const SmartPtr<U2>& raw_rhs);

        template <class U1, class U2>
        friend
        bool operator!=(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs);

        template <class U1, class U2>
        friend
        bool operator!=(const SmartPtr<U1>& lhs, U2* raw_rhs);

        template <class U1, class U2>
        friend
        bool operator!=(U1* lhs, const SmartPtr<U2>& raw_rhs);

    };

    template <class U1, class U2>
    bool ComparePointers(const U1* lhs, const U2* rhs) {
        if (lhs == rhs) {
            return true;
        }
        // If lhs and rhs point to the same object with different interfaces
        // U1 and U2, we cannot guarantee that the value of the pointers will
        // be equivalent. We can guarantee this if we convert to void*.
        return static_cast<const void*>(lhs) == static_cast<const void*>(rhs);
    }

} // namespace Coin

//#############################################################################

template <class U1, class U2>
bool operator==(const Coin::SmartPtr<U1>& lhs, const Coin::SmartPtr<U2>& rhs) {
    return Coin::ComparePointers(lhs.GetRawPtr(), rhs.GetRawPtr());
}

template <class U1, class U2>
bool operator==(const Coin::SmartPtr<U1>& lhs, U2* raw_rhs) {
    return Coin::ComparePointers(lhs.GetRawPtr(), raw_rhs);
}

template <class U1, class U2>
bool operator==(U1* raw_lhs, const Coin::SmartPtr<U2>& rhs) {
    return Coin::ComparePointers(raw_lhs, rhs.GetRawPtr());
}

template <class U1, class U2>
bool operator!=(const Coin::SmartPtr<U1>& lhs, const Coin::SmartPtr<U2>& rhs) {
    return ! operator==(lhs, rhs);
}

template <class U1, class U2>
bool operator!=(const Coin::SmartPtr<U1>& lhs, U2* raw_rhs) {
    return ! operator==(lhs, raw_rhs);
}

template <class U1, class U2>
bool operator!=(U1* raw_lhs, const Coin::SmartPtr<U2>& rhs) {
    return ! operator==(raw_lhs, rhs);
}

#define CoinReferencedObject Coin::ReferencedObject
#define CoinSmartPtr         Coin::SmartPtr
#define CoinComparePointers  Coin::ComparePointers

#endif