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_