AECSubPtr.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance").
// All rights reserved.
//
// This software and its documentation and related materials are owned by
// the Alliance. The software may only be incorporated into application
// programs owned by members of the Alliance, subject to a signed
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable
// trade secrets of the Alliance and its suppliers. The software is also
// protected by copyright law and international treaty provisions. Application
// programs incorporating this software must include the following statement
// with their copyright notices:
//
//   This application incorporates Open Design Alliance software pursuant to a
//   license agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance.
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you
// acknowledge and accept the above terms.
 
#ifndef __AECSUBPTR_H__
#define __AECSUBPTR_H__
 
#include <SmartPtr.h>
#include "Subobjects/AECImpObj.h"
#include "Subobjects/AECSubObj.h"
 
template<class B>
class AECBASE_API AECSubPtrBase
{
    public:
        inline bool isNull() const
        {
            return m_pObject == 0;
        }
 
        inline B* get() const
        {
            return m_pObject;
        }
 
    protected:
        inline  AECSubPtrBase() : m_pObject(0)
        {
        }
 
        // Pointer to sub-object.
        B* m_pObject;
};
 
template <class T, class B = AECImpObj, class TBase = AECSubPtrBase<B> > class AECSubPtr : public TBase
{
    private:
        inline void internalAddRef()
        {
            if( TBase::m_pObject )
            {
                // New in AECSubPtr:
                // Add reference to the object and it`s owners.
                TBase::m_pObject->addRefSubPtr();
            }
        }
        inline void internalQueryX( const OdRxObject* pObj )
        {
            if( pObj )
            {
                T* pImp = T::cast( pObj ).get();
                if( pImp )
                {
                    TBase::m_pObject = pImp;
                    internalAddRef();
                }
                else
                    throw OdError( eNotThatKindOfClass );
            }
        }
 
        inline void release()
        {
            if (TBase::m_pObject)
            {
                // New in AECSubPtr:
                // Release the object and it`s owners.
                TBase::m_pObject->releaseSubPtr();
                TBase::m_pObject = 0;
            }
        }
 
        inline void assign( const T* pObj )
        {
            release();
            TBase::m_pObject = const_cast<T*>(pObj);
            internalAddRef();
        }
 
        inline void assign( const OdRxObject* pObj )
        {
            release();
            internalQueryX( pObj );
        }
  
        bool operator !() const
        {
            ODA_FAIL();
            return false;
        }
  
        operator bool() const
        {
            ODA_FAIL();
            return false;
        }
 
        operator bool()
        {
            ODA_FAIL();
            return false;
        }
  
    public:
        inline AECSubPtr()
        {
            TBase::m_pObject = 0;
        }
 
        inline AECSubPtr( const T* pObj )
        {
            TBase::m_pObject = const_cast<T*>(pObj);
            internalAddRef();
        }
 
    private:
        inline operator OdSmartPtr<T>()
        {
            return OdSmartPtr<T>( TBase::m_pObject );
        }
 
    public:
        inline AECSubPtr( const OdRxObject* pObj )
        {
            internalQueryX( pObj );
        }
 
        inline AECSubPtr(const AECSubPtr& pObj)
        {
            TBase::m_pObject = const_cast<T*>(pObj.get());
            internalAddRef();
        }
 
        inline AECSubPtr(const TBase& pObj)
        {
            internalQueryX( pObj.get() );
        }
 
        inline AECSubPtr( const OdBaseObjectPtr& pObj )
        {
            internalQueryX( pObj.get() );
        }
  
        inline ~AECSubPtr()
        {
            release();
        }
 
        inline AECSubPtr& operator = (const AECSubPtr& pObj)
        {
            release();
            TBase::m_pObject = const_cast<T*>(pObj.get());
            internalAddRef();
            return *this;
        }
 
        inline AECSubPtr& operator = (const TBase& pObj)
        {
            assign( pObj.get() );
            return *this;
        }
 
        inline AECSubPtr& operator = (const OdBaseObjectPtr& pObj)
        {
            assign( pObj.get() );
            return *this;
        }
 
        inline AECSubPtr& operator = (const T* pObj)
        {
            assign(pObj);
            return *this;
        }
 
        inline const T* get() const
        {
            return static_cast<T*>(TBase::m_pObject);
        }
 
        inline T* get()
        {
            return static_cast<T*>(TBase::m_pObject);
        }
 
        inline T* operator ->()
        {
            return static_cast<T*>(TBase::m_pObject);
        }
 
        inline const T* operator ->() const
        {
            return static_cast<T*>(TBase::m_pObject);
        }
 
#ifdef ODA_GCC_2_95
        inline operator T*() const
        {
            return static_cast<T*>(TBase::m_pObject);
        }
#else
        inline operator T*()
        {
            return static_cast<T*>(TBase::m_pObject);
        }
 
        inline operator const T*() const
        {
            return static_cast<T*>(TBase::m_pObject);
        }
#endif
        inline bool operator==(const T* pObj) const
        {
            return ( TBase::m_pObject == pObj );
        }
 
        inline bool operator==(const AECSubPtr& ptr) const
        {
            return operator==(ptr.get());
        }
 
        inline bool operator!=(const T* pObj) const
        {
            return ( TBase::m_pObject != pObj );
        }
 
        inline bool operator!=(const AECSubPtr& ptr) const
        {
            return operator!=(ptr.get());
        }
};
 
typedef OdSmartPtr<AECImpObj> AECImpObjPtr;
typedef AECSubPtr<AECImpObj> AECImpObjSubPtr;
 
typedef OdSmartPtr<AECSubObj> AECSubObjPtr;
typedef AECSubPtr<AECSubObj,AECSubObj> AECSubObjSubPtr;
 
#endif // __AECSUBPTR_H__