ScopedSmPtr.hxx

Go to the documentation of this file.

// Copyright 2022 Siemens Digital Industries Software
// ==================================================
// Copyright 2017.
// Siemens Product Lifecycle Management Software Inc.
// All Rights Reserved.
// ==================================================
// Copyright 2022 Siemens Digital Industries Software

#ifndef TEAMCENTER_BASE_UTILS_SCOPED_SM_PTR_HXX
#define TEAMCENTER_BASE_UTILS_SCOPED_SM_PTR_HXX

#include <cstdlib>
/*  */
#include <base_utils/Mem.h>

namespace Teamcenter
{
template < class T > struct scoped_smptr_my_deallocator
{
    void operator() (T* bucket) const { MEM_free(bucket); }
};
template <class T, class F=scoped_smptr_my_deallocator< T > > class scoped_smptr
{
public:
    explicit scoped_smptr( T* b = 0 ) : bucket( b ) {}

    virtual ~scoped_smptr() { F f; f( bucket ); }    /*  */


    scoped_smptr &  operator=(T *  ptr) { F f; f(bucket); bucket = ptr; return *this; }

    T** operator&() { return &bucket; }

    T& operator*() const { return *bucket; }

    T* operator->() const { return bucket; }

    const T& operator[](std::size_t inx) const { return bucket[inx]; }

    T& operator[](std::size_t inx)       { return bucket[inx]; }

    const T& operator[](int inx)    const { return bucket[inx]; }

    T& operator[](int inx)          { return bucket[inx]; }

    const T& operator[](unsigned int inx)    const { return bucket[inx]; }

    T& operator[](unsigned int inx)          { return bucket[inx]; }

    const T& operator[](short inx) const { return bucket[inx]; }

    T& operator[](short inx) { return bucket[inx]; }

    const T& operator[](long inx)   const { return bucket[inx]; }

    T& operator[](long inx)         { return bucket[inx]; }

    const T* getString() const { static const T s_empty = T(); return bucket ? bucket : &s_empty; }

    T*& getReference() { return bucket; }

    T* get() const { return bucket; }

    T* release() { T* tmp = bucket; bucket = 0; return tmp; }

    bool operator == (const T* t) const { return bucket == t; }

    bool operator != (const T* t) const { return bucket != t; }

    bool operator! () const
    {
        return bucket == 0;
    }

protected:
    T* bucket;

private:
    scoped_smptr( const scoped_smptr& );

    scoped_smptr& operator = ( const scoped_smptr& );
};

}

#endif