src/MEDWrapper/Base/MED_Wrapper.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  File   : 
//  Author : 
//  Module : 
//  $Header: /home/server/cvs/MED/MED_SRC/src/MEDWrapper/Base/MED_Wrapper.hxx,v 1.7.2.1.6.2.2.1 2011-06-01 16:53:06 vsr Exp $
//
#ifndef MED_Wrapper_HeaderFile
#define MED_Wrapper_HeaderFile

#include "MED_WrapperBase.hxx"

#include "MED_Structures.hxx"
#include "MED_Algorithm.hxx"

#include <boost/thread/mutex.hpp>

namespace MED
{

  //----------------------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TWrapper
  {
    typedef boost::mutex TMutex;
    TMutex myMutex;

    virtual
    ~TWrapper();

    //----------------------------------------------------------------------------
    virtual 
    EVersion
    GetVersion() = 0;
    
    //----------------------------------------------------------------------------
    virtual 
    PMeshInfo 
    CrMeshInfo(TInt theDim = 0, TInt theSpaceDim = 0,
               const std::string& theValue = "",
               EMaillage theType = eNON_STRUCTURE,
               const std::string& theDesc = "") = 0;

    virtual 
    PMeshInfo 
    CrMeshInfo(const PMeshInfo& theInfo) = 0;

    virtual 
    TInt 
    GetNbMeshes(TErr* theErr = NULL) = 0;
    
    virtual 
    void 
    GetMeshInfo(TInt theMeshId, 
                TMeshInfo& theInfo,
                TErr* theErr = NULL) = 0;

    virtual 
    void
    SetMeshInfo(const TMeshInfo& theInfo,
                TErr* theErr = NULL) = 0;
    
    virtual 
    PMeshInfo
    GetPMeshInfo(TInt theId,
                 TErr* theErr = NULL);


    //----------------------------------------------------------------------------
    virtual 
    TInt
    GetNbFamilies(const TMeshInfo& theMeshInfo,
                  TErr* theErr = NULL) = 0;

    virtual 
    TInt
    GetNbFamAttr(TInt theFamId, 
                 const TMeshInfo& theInfo,
                 TErr* theErr = NULL) = 0;
    
    virtual
    TInt
    GetNbFamGroup(TInt theFamId, 
                  const TMeshInfo& theInfo,
                  TErr* theErr = NULL) = 0;
    
    virtual
    void
    GetFamilyInfo(TInt theFamId, 
                  TFamilyInfo& theInfo,
                  TErr* theErr = NULL) = 0;
    
    virtual
    void
    SetFamilyInfo(const TFamilyInfo& theInfo,
                  TErr* theErr = NULL) = 0;
    
    virtual 
    PFamilyInfo
    CrFamilyInfo(const PMeshInfo& theMeshInfo,
                 TInt theNbGroup = 0, 
                 TInt theNbAttr = 0,
                 TInt theId = 0,
                 const std::string& theValue = "") = 0;
    
    virtual 
    PFamilyInfo
    CrFamilyInfo(const PMeshInfo& theMeshInfo,
                 const std::string& theValue,
                 TInt theId,
                 const TStringSet& theGroupNames, 
                 const TStringVector& theAttrDescs = TStringVector(), 
                 const TIntVector& theAttrIds = TIntVector(), 
                 const TIntVector& theAttrVals = TIntVector()) = 0;
    
    virtual
    PFamilyInfo
    CrFamilyInfo(const PMeshInfo& theMeshInfo,
                 const PFamilyInfo& theInfo) = 0;
    
    PFamilyInfo
    GetPFamilyInfo(const PMeshInfo& theMeshInfo, 
                   TInt theId,
                   TErr* theErr = NULL);
    
    //----------------------------------------------------------------------------
    virtual
    void
    GetNames(TElemInfo& theInfo,
             TInt theNb,
             EEntiteMaillage theEntity, 
             EGeometrieElement theGeom,
             TErr* theErr = NULL)
    {}

    virtual
    void
    GetNumeration(TElemInfo& theInfo,
                  TInt theNb,
                  EEntiteMaillage theEntity, 
                  EGeometrieElement theGeom,
                  TErr* theErr = NULL)
    {}

    virtual
    void
    GetFamilies(TElemInfo& theInfo,
                TInt theNb,
                EEntiteMaillage theEntity, 
                EGeometrieElement theGeom,
                TErr* theErr = NULL)
    {}

    virtual
    void
    SetNames(const TElemInfo& theInfo,
             EEntiteMaillage theEntity, 
             EGeometrieElement theGeom,
             TErr* theErr = NULL)
    {}

    virtual
    void
    SetNumeration(const TElemInfo& theInfo,
                  EEntiteMaillage theEntity, 
                  EGeometrieElement theGeom,
                  TErr* theErr = NULL)
    {}

    virtual
    void
    SetFamilies(const TElemInfo& theInfo,
                EEntiteMaillage theEntity, 
                EGeometrieElement theGeom,
                TErr* theErr = NULL)
    {}

    PElemInfo
    GetPElemInfo(const PMeshInfo& theMeshInfo,
                 EEntiteMaillage theEntity = eNOEUD, 
                 EGeometrieElement theGeom = ePOINT1, 
                 EConnectivite theConnMode = eNOD,
                 TErr* theErr = NULL);

    //----------------------------------------------------------------------------
    virtual
    TInt
    GetNbNodes(const TMeshInfo& theMeshInfo,
               TErr* theErr = NULL) = 0;
    
    virtual
    TInt
    GetNbNodes(const TMeshInfo& theMeshInfo,
               ETable theTable,
               TErr* theErr = NULL)
    {
      return 0;
    }

    virtual
    void
    GetNodeInfo(TNodeInfo& theInfo,
                TErr* theErr = NULL) = 0;

    virtual 
    void
    SetNodeInfo(const TNodeInfo& theInfo,
                TErr* theErr = NULL) = 0;
    
    virtual 
    PElemInfo
    CrElemInfo(const PMeshInfo& theMeshInfo, 
               TInt theNbElem,
               EBooleen theIsElemNum = eVRAI,
               EBooleen theIsElemNames = eVRAI)
    {
      return PElemInfo();
    }

    virtual 
    PElemInfo
    CrElemInfo(const PMeshInfo& theMeshInfo, 
               TInt theNbElem,
               const TIntVector& theFamNum,
               const TIntVector& aElemNum,
               const TStringVector& aElemNames)
    {
      return PElemInfo();
    }

    virtual
    PNodeInfo
    CrNodeInfo(const PMeshInfo& theMeshInfo, 
               TInt theNbElem,
               EModeSwitch theMode = eFULL_INTERLACE,
               ERepere theSystem = eCART, 
               EBooleen theIsElemNum = eVRAI,
               EBooleen theIsElemNames = eVRAI) = 0;

    virtual 
    PNodeInfo
    CrNodeInfo(const PMeshInfo& theMeshInfo, 
               const TFloatVector& theNodeCoords,
               EModeSwitch theMode = eFULL_INTERLACE,
               ERepere theSystem = eCART, 
               const TStringVector& theCoordNames = TStringVector(),
               const TStringVector& theCoordUnits = TStringVector(),
               const TIntVector& theFamilyNums = TIntVector(),
               const TIntVector& theElemNums = TIntVector(),
               const TStringVector& theElemNames = TStringVector()) = 0;
    
    virtual
    PNodeInfo
    CrNodeInfo(const PMeshInfo& theMeshInfo,
               const PNodeInfo& theInfo) = 0;
    
    PNodeInfo
    GetPNodeInfo(const PMeshInfo& theMeshInfo,
                 TErr* theErr = NULL);
    
    //----------------------------------------------------------------------------

    virtual
    void
    GetPolygoneInfo(TPolygoneInfo& theInfo,
                    TErr* theErr = NULL) 
    {}


    virtual
    void
    SetPolygoneInfo(const TPolygoneInfo& theInfo,
                    TErr* theErr = NULL) 
    {}


    virtual
    TInt
    GetNbPolygones(const TMeshInfo& theMeshInfo,
                   EEntiteMaillage theEntity,
                   EGeometrieElement theGeom,
                   EConnectivite theConnMode = eNOD,
                   TErr* theErr = NULL) 
    { 
      return 0;
    }


    virtual
    TInt
    GetPolygoneConnSize(const TMeshInfo& theMeshInfo,
                        EEntiteMaillage theEntity,
                        EGeometrieElement theGeom,
                        EConnectivite theConnMode = eNOD,
                        TErr* theErr = NULL)
    { 
      return 0;
    }
    

    virtual 
    PPolygoneInfo
    CrPolygoneInfo(const PMeshInfo& theMeshInfo, 
                   EEntiteMaillage theEntity, 
                   EGeometrieElement theGeom,
                   TInt theNbElem,
                   TInt theConnSize,
                   EConnectivite theConnMode = eNOD,
                   EBooleen theIsElemNum = eVRAI,
                   EBooleen theIsElemNames = eVRAI)
    {
      return PPolygoneInfo();
    }
    

    virtual
    PPolygoneInfo 
    CrPolygoneInfo(const PMeshInfo& theMeshInfo, 
                   EEntiteMaillage theEntity, 
                   EGeometrieElement theGeom,
                   const TIntVector& theIndexes,
                   const TIntVector& theConnectivities,
                   EConnectivite theConnMode = eNOD,
                   const TIntVector& theFamilyNums = TIntVector(),
                   const TIntVector& theElemNums = TIntVector(),
                   const TStringVector& theElemNames = TStringVector())
    {
      return PPolygoneInfo();
    }

    virtual
    PPolygoneInfo
    CrPolygoneInfo(const PMeshInfo& theMeshInfo,
                   const PPolygoneInfo& theInfo)
    {
      return PPolygoneInfo();
    }
    

    PPolygoneInfo
    GetPPolygoneInfo(const PMeshInfo& theMeshInfo,
                     EEntiteMaillage theEntity, 
                     EGeometrieElement theGeom, 
                     EConnectivite theConnMode = eNOD);
    
    //----------------------------------------------------------------------------

    virtual 
    void
    GetPolyedreInfo(TPolyedreInfo& theInfo,
                    TErr* theErr = NULL) 
    {}


    virtual
    void
    SetPolyedreInfo(const TPolyedreInfo& theInfo,
                    TErr* theErr = NULL)
    {}
    

    virtual
    TInt
    GetNbPolyedres(const TMeshInfo& theMeshInfo,
                   EEntiteMaillage theEntity,
                   EGeometrieElement theGeom,
                   EConnectivite theConnMode = eNOD,
                   TErr* theErr = NULL)
    { 
      return 0;
    }


    virtual 
    void
    GetPolyedreConnSize(const TMeshInfo& theMeshInfo,
                        TInt& theNbFaces,
                        TInt& theConnSize,
                        EConnectivite theConnMode = eNOD,
                        TErr* theErr = NULL)
    {
      theNbFaces = theConnSize = 0;
    }
    
    virtual
    PPolyedreInfo
    CrPolyedreInfo(const PMeshInfo& theMeshInfo, 
                   EEntiteMaillage theEntity, 
                   EGeometrieElement theGeom,
                   TInt theNbElem,
                   TInt theNbFaces,
                   TInt theConnSize,
                   EConnectivite theConnMode = eNOD,
                   EBooleen theIsElemNum = eVRAI,
                   EBooleen theIsElemNames = eVRAI)
    {
      return PPolyedreInfo();
    }
    

    virtual
    PPolyedreInfo
    CrPolyedreInfo(const PMeshInfo& theMeshInfo, 
                   EEntiteMaillage theEntity, 
                   EGeometrieElement theGeom,
                   const TIntVector& theIndexes,
                   const TIntVector& theFaces,
                   const TIntVector& theConnectivities,
                   EConnectivite theConnMode = eNOD,
                   const TIntVector& theFamilyNums = TIntVector(),
                   const TIntVector& theElemNums = TIntVector(),
                   const TStringVector& theElemNames = TStringVector())
    {
      return PPolyedreInfo();
    }

    virtual
    PPolyedreInfo
    CrPolyedreInfo(const PMeshInfo& theMeshInfo,
                   const PPolyedreInfo& theInfo)
    {
      return PPolyedreInfo();
    }
    

    PPolyedreInfo
    GetPPolyedreInfo(const PMeshInfo& theMeshInfo,
                     EEntiteMaillage theEntity, 
                     EGeometrieElement theGeom, 
                     EConnectivite theConnMode = eNOD);
    
    //----------------------------------------------------------------------------
    virtual
    TEntityInfo
    GetEntityInfo(const TMeshInfo& theMeshInfo,
                  EConnectivite theConnMode = eNOD,
                  TErr* theErr = NULL) = 0;
    
    virtual
    TInt
    GetNbCells(const TMeshInfo& theMeshInfo, 
               EEntiteMaillage theEntity, 
               EGeometrieElement theGeom, 
               EConnectivite theConnMode = eNOD,
               TErr* theErr = NULL) = 0;
    
    virtual
    void
    GetCellInfo(TCellInfo& theInfo,
                TErr* theErr = NULL) = 0;
    
    virtual 
    void
    SetCellInfo(const TCellInfo& theInfo,
                TErr* theErr = NULL) = 0;
    
    virtual
    PCellInfo
    CrCellInfo(const PMeshInfo& theMeshInfo, 
               EEntiteMaillage theEntity, 
               EGeometrieElement theGeom,
               TInt theNbElem,
               EConnectivite theConnMode = eNOD,
               EBooleen theIsElemNum = eVRAI,
               EBooleen theIsElemNames = eVRAI,
               EModeSwitch theMode = eFULL_INTERLACE) = 0;
    
    virtual
    PCellInfo
    CrCellInfo(const PMeshInfo& theMeshInfo, 
               EEntiteMaillage theEntity, 
               EGeometrieElement theGeom,
               const TIntVector& theConnectivities,
               EConnectivite theConnMode = eNOD,
               const TIntVector& theFamilyNums = TIntVector(),
               const TIntVector& theElemNums = TIntVector(),
               const TStringVector& theElemNames = TStringVector(),
               EModeSwitch theMode = eFULL_INTERLACE) = 0;
    
    virtual
    PCellInfo
    CrCellInfo(const PMeshInfo& theMeshInfo,
               const PCellInfo& theInfo) = 0;
    
    PCellInfo
    GetPCellInfo(const PMeshInfo& theMeshInfo,
                 EEntiteMaillage theEntity, 
                 EGeometrieElement theGeom, 
                 EConnectivite theConnMode = eNOD,
                 TErr* theErr = NULL);


    //----------------------------------------------------------------------------
    virtual 
    TInt
    GetNbFields(TErr* theErr = NULL) = 0;
    
    virtual
    TInt
    GetNbComp(TInt theFieldId,
              TErr* theErr = NULL) = 0;
    
    virtual 
    void
    GetFieldInfo(TInt theFieldId, 
                 TFieldInfo& theInfo,
                 TErr* theErr = NULL) = 0;

    virtual 
    void
    SetFieldInfo(const TFieldInfo& theInfo,
                 TErr* theErr = NULL) = 0;
    

    virtual 
    PFieldInfo
    CrFieldInfo(const PMeshInfo& theMeshInfo, 
                TInt theNbComp = 0,
                ETypeChamp theType = eFLOAT64,
                const std::string& theValue = "",
                EBooleen theIsLocal = eVRAI,
                TInt theNbRef = 1) = 0;

    virtual 
    PFieldInfo
    CrFieldInfo(const PMeshInfo& theMeshInfo,
                const PFieldInfo& theInfo) = 0;
    
    PFieldInfo
    GetPFieldInfo(const PMeshInfo& theMeshInfo, 
                  TInt theId,
                  TErr* theErr = NULL);


    //----------------------------------------------------------------------------

    virtual 
    TInt
    GetNbGauss(TErr* theErr = NULL)
    { 
      return TInt();
    }


    virtual 
    TGaussInfo::TInfo
    GetGaussPreInfo(TInt theId, 
                    TErr* theErr = NULL)
    {
      return TGaussInfo::TInfo( TGaussInfo::TKey(ePOINT1,""),0 );
    }
    

    virtual 
    void
    GetGaussInfo(TInt theId, 
                 TGaussInfo& theInfo,
                 TErr* theErr = NULL)
    {}


    virtual
    PGaussInfo
    CrGaussInfo(const TGaussInfo::TInfo& theInfo,
                EModeSwitch theMode = eFULL_INTERLACE) = 0;


    //----------------------------------------------------------------------------

    virtual 
    TInt
    GetNbTimeStamps(const TFieldInfo& theInfo, 
                    const TEntityInfo& theEntityInfo,
                    EEntiteMaillage& theEntity,
                    TGeom2Size& theGeom2Size,
                    TErr* theErr = NULL) = 0;
    
    virtual 
    void
    GetTimeStampInfo(TInt theTimeStampId, 
                     TTimeStampInfo& theInfo,
                     TErr* theErr = NULL) = 0;

    virtual 
    PTimeStampInfo
    CrTimeStampInfo(const PFieldInfo& theFieldInfo, 
                    EEntiteMaillage theEntity,
                    const TGeom2Size& theGeom2Size,
                    const TGeom2NbGauss& theGeom2NbGauss = TGeom2NbGauss(),
                    TInt theNumDt = 0,
                    TInt theNumOrd = 0,
                    TFloat theDt = 0,
                    const std::string& theUnitDt = "",
                    const TGeom2Gauss& theGeom2Gauss = TGeom2Gauss()) = 0;

    virtual 
    PTimeStampInfo 
    CrTimeStampInfo(const PFieldInfo& theFieldInfo,
                    const PTimeStampInfo& theInfo) = 0;
    
    PTimeStampInfo
    GetPTimeStampInfo(const PFieldInfo& theFieldInfo,
                      EEntiteMaillage theEntity,
                      const TGeom2Size& theGeom2Size,
                      TInt theId,
                      TErr* theErr = NULL);
    

    //----------------------------------------------------------------------------
    virtual 
    TInt
    GetNbProfiles(TErr* theErr = NULL) = 0;

    virtual 
    TProfileInfo::TInfo
    GetProfilePreInfo(TInt theId, 
                      TErr* theErr = NULL) = 0;

    virtual 
    void
    GetProfileInfo(TInt theId, 
                   TProfileInfo& theInfo,
                   TErr* theErr = NULL) = 0;

    virtual
    PProfileInfo
    CrProfileInfo(const TProfileInfo::TInfo& theInfo,
                  EModeProfil theMode = eCOMPACT) = 0;

    virtual
    void
    SetProfileInfo(const TProfileInfo& theInfo,
                   TErr* theErr = NULL) = 0;

    PProfileInfo
    GetPProfileInfo(TInt theId,
                    EModeProfil theMode = eCOMPACT,
                    TErr* theErr = NULL);


    //----------------------------------------------------------------------------
    virtual 
    void
    GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
                      const TMKey2Profile& theMKey2Profile,
                      const TKey2Gauss& theKey2Gauss,
                      TErr* theErr = NULL) = 0;
    
    virtual 
    void
    SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
                      TErr* theErr = NULL) = 0;
    
    virtual
    PTimeStampValueBase
    CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
                     ETypeChamp theTypeChamp,
                     const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
                     EModeSwitch theMode = eFULL_INTERLACE) = 0;

    virtual
    PTimeStampValueBase
    CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
                     const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
                     EModeSwitch theMode = eFULL_INTERLACE);

    virtual 
    PTimeStampValueBase
    CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
                     const PTimeStampValueBase& theInfo,
                     ETypeChamp theTypeChamp) = 0;
    
    virtual 
    PTimeStampValueBase
    CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
                     const PTimeStampValueBase& theInfo);
    
    PTimeStampValueBase
    GetPTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
                       const TMKey2Profile& theMKey2Profile,
                       const TKey2Gauss& theKey2Gauss,
                       TErr* theErr = NULL);
    
    //----------------------------------------------------------------------------
    // Backward compatibility  declarations
    virtual 
    void
    GetTimeStampVal(const PTimeStampVal& theVal,
                    const TMKey2Profile& theMKey2Profile,
                    const TKey2Gauss& theKey2Gauss,
                    TErr* theErr = NULL);
    
    virtual 
    void
    SetTimeStamp(const PTimeStampVal& theVal,
                 TErr* theErr = NULL);
    
    virtual
    PTimeStampVal
    CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
                   const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
                   EModeSwitch theMode = eFULL_INTERLACE);

    virtual 
    PTimeStampVal
    CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
                   const PTimeStampVal& theInfo);
    
    PTimeStampVal
    GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
                     const TMKey2Profile& theMKey2Profile,
                     const TKey2Gauss& theKey2Gauss,
                     TErr* theErr = NULL);

    //----------------------------------------------------------------------------

    PGrilleInfo
    GetPGrilleInfo(const PMeshInfo& theMeshInfo);


    PGrilleInfo
    GetPGrilleInfo(const PMeshInfo& theMeshInfo,
                   const PGrilleInfo& theInfo);


    virtual
    void
    GetGrilleInfo(TGrilleInfo& theInfo,
                  TErr* theErr = NULL)
    {}


    virtual 
    void
    SetGrilleInfo(const TGrilleInfo& theInfo,
                  TErr* theErr = NULL)
    {}

    virtual
    PGrilleInfo
    CrGrilleInfo(const PMeshInfo& theMeshInfo,
                 const PGrilleInfo& theGrilleInfo)
    {
      return PGrilleInfo();
    }

    virtual
    PGrilleInfo
    CrGrilleInfo(const PMeshInfo& theMeshInfo)
    {
      return PGrilleInfo();
    }
    
    virtual
    PGrilleInfo
    CrGrilleInfo(const PMeshInfo& theMeshInfo,
                 const EGrilleType& type)
    {
      return PGrilleInfo();
    }
    
    virtual
    PGrilleInfo
    CrGrilleInfo(const PMeshInfo& theMeshInfo,
                 const EGrilleType& type,
                 const TInt& nbNodes)
    {
      return PGrilleInfo();
    }

    virtual
    PGrilleInfo
    CrGrilleInfo(const PMeshInfo& theMeshInfo,
                 const EGrilleType& type,
                 const MED::TIntVector& nbNodeVec)
    {
      return PGrilleInfo();
    }

    virtual
    void
    GetGrilleType(const TMeshInfo& theMeshInfo,
                  EGrilleType& type,
                  TErr* theErr = NULL)
    {
    }
    
  };


  //----------------------------------------------------------------------------
  class MEDWRAPPER_EXPORT TLockProxy
  {
    TLockProxy& operator=(const TLockProxy& );
    TWrapper* myWrapper;

  public:
    TLockProxy(TWrapper* theWrapper);

    ~TLockProxy();

    TWrapper * operator-> () const;
  };


  //----------------------------------------------------------------------------
  template<> 
  class MEDWRAPPER_EXPORT SharedPtr<TWrapper>: public boost::shared_ptr<TWrapper>
  {
  public:
    SharedPtr() {}

    template<class Y>
    explicit SharedPtr(Y * p): 
      boost::shared_ptr<TWrapper>(p) 
    {}

    template<class Y>
    SharedPtr(SharedPtr<Y> const & r):
      boost::shared_ptr<TWrapper>(r,boost::detail::dynamic_cast_tag())
    {}

    template<class Y>
    SharedPtr& 
    operator=(SharedPtr<Y> const & r)
    {
      boost::shared_ptr<TWrapper>(r,boost::detail::dynamic_cast_tag()).swap(*this);
      return *this;
    }

    template<class Y> 
    SharedPtr& 
    operator()(Y * p) // Y must be complete
    {
      return operator=<Y>(SharedPtr<Y>(p));
    }

    template<class Y> 
    SharedPtr& 
    operator()(SharedPtr<Y> const & r) // Y must be complete
    {
      return operator=<Y>(SharedPtr<Y>(r));
    }

    TLockProxy operator-> () const // never throws
    {
      return TLockProxy(this->get());
    }
    
  protected:
    operator const TWrapper& () const;

    operator TWrapper& ();

    TWrapper& operator* () const;

    TWrapper * get() const // never throws
    {
      return boost::shared_ptr<TWrapper>::get();
    }
  };

  //----------------------------------------------------------------------------
  typedef SharedPtr<TWrapper> PWrapper;
}

#endif