ClonePtr.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_CLONE_PTR_H_
#define SimTK_SimTKCOMMON_CLONE_PTR_H_

/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2005-12 Stanford University and the Authors.        *
 * Authors: Michael Sherman                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */

namespace SimTK {

template <class T> class ClonePtr {
public:
    typedef T  element_type;
    typedef T* pointer;
    typedef T& reference;

    ClonePtr() : p(0) { }
    explicit ClonePtr(T*  obj) : p(obj) { }
    explicit ClonePtr(T** obj) : p(*obj) { *obj=0; }
    explicit ClonePtr(const T* obj) : p(obj?obj->clone():0) { }
    explicit ClonePtr(const T& obj) : p(&obj?obj.clone():0) { }
    ClonePtr(const ClonePtr& c) : p(c.p?c.p->clone():0) { }
    ClonePtr& operator=(const ClonePtr& c) 
    {   reset(c.p?c.p->clone():0); return *this; }
    ClonePtr& operator=(const T& t)          
    {   reset(&t ? t.clone()  :0); return *this; }
    ClonePtr& operator=(T* tp)               
    {   reset(tp); return *this; }
    
    ~ClonePtr() { delete p; }

    bool operator==(const ClonePtr& other) const {
        if (p == other.p) return true; // same object or both empty
        if (empty() || other.empty()) return false;
        return getRef()==other.getRef();
    }
    bool operator!=(const ClonePtr& other) const {return !((*this)==other);}

    bool operator<(const ClonePtr& other) const {
        if (p == other.p)  return false;    // same object or both empty
        if (empty())       return true;     //  empty < !empty
        if (other.empty()) return false;    // !empty > empty
        return getRef() < other.getRef();
    }
    
    const T* operator->() const { return &getRef(); }
    T*       operator->()       { return &updRef(); }

    const T& operator*() const { return getRef(); }
    T&       operator*()       { return updRef(); }

    const T* operator&() const { return p; }
    T*       operator&()       { return p; }
    
    operator const T&() const { return getRef(); }
    operator T&()             { return updRef(); } 

    operator bool() const { return !empty(); }

    T* updPtr() { return p; }
    const T* getPtr()  const  { return p; }

    T& updRef() { 
        SimTK_ERRCHK(p!=0, "ClonePtr::updRef()", 
                    "An attempt was made to dereference a null pointer."); 
        return *p; 
    }
    const T& getRef() const { 
        SimTK_ERRCHK(p!=0, "ClonePtr::getRef()", 
                    "An attempt was made to dereference a null pointer."); 
        return *p; 
    }    

    bool     empty() const    { return p==0; }
    void     clear()          { delete p; p=0; }
    T*       release()        { T* x=p; p=0; return x; }
    void     reset(T* tp)     { if (tp!=p) {delete p; p=tp;} }
    void reset(T** tpp) { 
        if (*tpp!=p) {delete p; p=*tpp;} 
        *tpp=0; 
    }
    void swap(ClonePtr& other) {
        T* otherp = other.release();
        other.reset(p);
        reset(otherp);
    }
     
private:
    // Warning: ClonePtr must be exactly the same size as type T*. That way
    // one can reinterpret_cast a T* to a ClonePtr<T> when needed.
    T*    p;  
};    
    
} // namespace SimTK

namespace std {
template <class T> inline void
swap(SimTK::ClonePtr<T>& p1, SimTK::ClonePtr<T>& p2) {
    p1.swap(p2);
}

} // namespace std

#endif // SimTK_SimTKCOMMON_CLONE_PTR_H_