dbobjptr.h

Go to the documentation of this file.

#pragma once
 
//
// (C) Copyright 2005-2024 by Graebert GmbH.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
 
#include "../_impl_include/GeneratedCommonHeader.h"
template <class T> 
class AcDbObjectPointerBase
{
 
public:
    AcDbObjectPointerBase( ):m_ptr(0),m_status( Acad::eNullObjectPointer)
    {
    }
    ~AcDbObjectPointerBase( )
    {
 
    }
 
    const T*  object( ) const
    {
        return m_ptr;
    }
    T* object( )
    {
        return m_ptr;
    }
    const T *  operator->( ) const
    {
        return m_ptr;
    }
    T* operator->( )
    {
        return m_ptr;
    }
    operator const T*( ) const
    {
        return m_ptr;
    }
    operator T*( )
    {
        return m_ptr;
    }
 
    Acad::ErrorStatus openStatus( ) const
    {
        return m_status;
    }
 
    Acad::ErrorStatus open( AcDbObjectId   objId ,
        AcDb::OpenMode mode = AcDb::kForRead ,
        bool           openErased = false )
    {
        m_status = acdbOpenObject(m_ptr,objId, mode , openErased );
        return m_status;
    }
 
    Acad::ErrorStatus acquire( T*& pObj )
    {
        if ( pObj == 0 )
            return Acad::eNullObjectPointer;
        if ( m_ptr != NULL ) 
        {
            Acad::ErrorStatus status = closeIt( );
            if ( status != Acad::eOk )
                return status;
        }
        m_ptr = pObj;
        m_status = Acad::eOk;
        pObj = 0;
        return Acad::eOk;
    }
    Acad::ErrorStatus release( T*& pObj )
    {
        if ( m_ptr == 0 )
            return Acad::eNullObjectPointer;
        m_status = Acad::eNullObjectPointer;
        pObj = m_ptr;
        m_ptr = 0;
        return Acad::eOk;
    }
 
    Acad::ErrorStatus close( )
    {
        return closeIt( );
    }
 
    Acad::ErrorStatus create( )
    {
        T* pObj = new T();
        
        if ( m_ptr != 0 ) 
        {
            Acad::ErrorStatus status = closeIt( );
            if ( status != Acad::eOk ) 
            {
                delete pObj;
                return status;
            }
        }
        m_ptr = pObj;
        m_status = Acad::eOk;
        return m_status;
    }
 
protected:
    AcDbObjectPointerBase( AcDbObjectId   objId ,
        AcDb::OpenMode mode ,
        bool           openErased )
    {
        m_status = acdbOpenObject( m_ptr , objId , mode , openErased );
    }
 
    T *        m_ptr;
    Acad::ErrorStatus m_status;
 
 
private:
    AcDbObjectPointerBase( const AcDbObjectPointerBase & ) = delete;
    AcDbObjectPointerBase& operator=( const AcDbObjectPointerBase & ) = delete;
 
    Acad::ErrorStatus closeIt( )
    {
        if ( m_ptr == 0 )
            return Acad::eOk;
        Acad::ErrorStatus status = Acad::eOk;
        if ( m_ptr->objectId( ).isNull( ) )
        {
            delete m_ptr;
            status = Acad::eOk;
        }
        else
        {
            status = m_ptr->close( );
        }
        m_ptr = 0;
        m_status = Acad::eNullObjectPointer;
        return this->es;
    }
 
};