PrivateImplementation.h

Go to the documentation of this file.

#ifndef SimTK_PRIVATE_IMPLEMENTATION_H_
#define SimTK_PRIVATE_IMPLEMENTATION_H_

/* -------------------------------------------------------------------------- *
 *                      SimTK Core: SimTKcommon                               *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK Core 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.               *
 *                                                                            *
 * Portions copyright (c) 2007 Stanford University and the Authors.           *
 * Authors: Michael Sherman                                                   *
 * Contributors: Chris Bruns and Peter Eastman                                *
 *                                                                            *
 * Permission is hereby granted, free of charge, to any person obtaining a    *
 * copy of this software and associated documentation files (the "Software"), *
 * to deal in the Software without restriction, including without limitation  *
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
 * and/or sell copies of the Software, and to permit persons to whom the      *
 * Software is furnished to do so, subject to the following conditions:       *
 *                                                                            *
 * The above copyright notice and this permission notice shall be included in *
 * all copies or substantial portions of the Software.                        *
 *                                                                            *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
 * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
 * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
 * -------------------------------------------------------------------------- */


#include "SimTKcommon/internal/common.h"
#include "SimTKcommon/internal/ExceptionMacros.h"

#include <cassert>
#include <iosfwd>

namespace SimTK {


template <class HANDLE, class IMPL, bool PTR=false> 
class PIMPLHandle {
private:
    IMPL *impl;

public:
    typedef PIMPLHandle<HANDLE, IMPL, PTR> HandleBase;
    typedef HandleBase                     ParentHandle;

    bool isEmptyHandle() const {return impl==0;}

    bool isOwnerHandle() const;

    bool isSameHandle(const HANDLE& other) const;

    void disown(HANDLE& newOwner);


    PIMPLHandle& referenceAssign(const HANDLE& source);

    PIMPLHandle& copyAssign(const HANDLE& source);

    void clearHandle();

    const IMPL& getImpl() const {assert(!isEmptyHandle()); return *impl;}

    IMPL& updImpl() {assert(!isEmptyHandle()); return *impl;}

    int getImplHandleCount() const;

protected:
    explicit PIMPLHandle(IMPL* p=0);

    ~PIMPLHandle();

    PIMPLHandle(const PIMPLHandle& source);

    PIMPLHandle& operator=(const PIMPLHandle& source);

    void setImpl(IMPL* p);

    bool hasSameImplementation(const HANDLE& other) const;

private:
    const HANDLE& downcastToHandle() const {return static_cast<const HANDLE&>(*this);}
    HANDLE& updDowncastToHandle() {return static_cast<HANDLE&>(*this);}
};

template <class HANDLE, class IMPL> 
class PIMPLImplementation {
    HANDLE*     ownerHandle;
    mutable int handleCount; // ref count determining when this is destructed 
public:
    explicit PIMPLImplementation(HANDLE* h=0);

    int getHandleCount() const;

    void incrementHandleCount() const;

    int decrementHandleCount() const;

    ~PIMPLImplementation();

    PIMPLImplementation(const PIMPLImplementation&);

    PIMPLImplementation& operator=(const PIMPLImplementation& src);

    void setOwnerHandle(HANDLE& p);

    int removeOwnerHandle();

    void replaceOwnerHandle(HANDLE& p);

    bool hasOwnerHandle() const;

    bool isOwnerHandle(const HANDLE& p) const;

    const HANDLE& getOwnerHandle() const;
};

template <class H, class IMPL, bool PTR>
std::ostream& operator<<(std::ostream& o, const PIMPLHandle<H,IMPL,PTR>& h);

// This macro declares methods to be included in classes derived from a PIMPLHandle subclass.

#define SimTK_INSERT_DERIVED_HANDLE_DECLARATIONS(DERIVED, DERIVED_IMPL, PARENT) \
const DERIVED_IMPL& getImpl() const;\
DERIVED_IMPL& updImpl();\
const PARENT& upcast() const;\
PARENT& updUpcast();\
static bool isInstanceOf(const PARENT& p);\
static const DERIVED& downcast(const PARENT& p);\
static DERIVED& updDowncast(PARENT& p);

// This macro provides the definitions for the above declarations.

#define SimTK_INSERT_DERIVED_HANDLE_DEFINITIONS(DERIVED, DERIVED_IMPL, PARENT) \
const DERIVED_IMPL& DERIVED::getImpl() const {\
    return dynamic_cast<const DERIVED_IMPL&>(PARENT::getImpl());\
}\
DERIVED_IMPL& DERIVED::updImpl() {\
    return dynamic_cast<DERIVED_IMPL&>(PARENT::updImpl());\
}\
const PARENT& DERIVED::upcast() const {\
    return static_cast<const PARENT&>(*this);\
}\
PARENT& DERIVED::updUpcast() {\
    return static_cast<PARENT&>(*this);\
}\
bool DERIVED::isInstanceOf(const PARENT& p) {\
    return dynamic_cast<const DERIVED_IMPL*>(&p.getImpl()) != 0;\
}\
const DERIVED& DERIVED::downcast(const PARENT& p) {\
    assert(isInstanceOf(p));\
    return static_cast<const DERIVED&>(p);\
}\
DERIVED& DERIVED::updDowncast(PARENT& p) {\
    assert(isInstanceOf(p));\
    return static_cast<DERIVED&>(p);\
}\

} // namespace SimTK

#endif // SimTK_PRIVATE_IMPLEMENTATION_H_