PrivateImplementation.h

Go to the documentation of this file.

#ifndef SimTK_PRIVATE_IMPLEMENTATION_H_
#define SimTK_PRIVATE_IMPLEMENTATION_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) 2007-12 Stanford University and the Authors.        *
 * Authors: Michael Sherman                                                   *
 * Contributors: Christopher Bruns, Peter Eastman                             *
 *                                                                            *
 * 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.                                             *
 * -------------------------------------------------------------------------- */
 
#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:
    PIMPLHandle() : impl(0) {}
 
    explicit PIMPLHandle(IMPL* p);
 
    ~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 SimTK_DYNAMIC_CAST_DEBUG<const DERIVED_IMPL&>(PARENT::getImpl());\
}\
DERIVED_IMPL& DERIVED::updImpl() {\
    return SimTK_DYNAMIC_CAST_DEBUG<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_