---

oscl_mem_auto_ptr.h

Go to the documentation of this file.

/* -*- c++ -*- */
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

//           O S C L _ M E M _ A U T O _ P T R

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

#ifndef OSCL_MEM_AUTO_PTR_H
#define OSCL_MEM_AUTO_PTR_H

#ifndef OSCLCONFIG_MEMORY_H_INCLUDED
#include "osclconfig_memory.h"
#endif

#ifndef OSCL_MEM_H_INCLUDED
#include "oscl_mem.h"
#endif

#define OSCL_DISABLE_WARNING_TRUNCATE_DEBUG_MESSAGE
#define OSCL_DISABLE_WARNING_RETURN_TYPE_NOT_UDT
#include "osclconfig_compiler_warnings.h"
template < class T, class _Allocator = Oscl_TAlloc<T, OsclMemAllocator> > class OSCLMemAutoPtr
{
    private:
        T* _Ptr;


    public:
        bool _Ownership;


        explicit OSCLMemAutoPtr(T* inPtr = 0) : _Ptr(inPtr), _Ownership(inPtr != 0) {};

        OSCLMemAutoPtr(const OSCLMemAutoPtr<T>& _Y): _Ownership(_Y._Ownership),
                _Ptr(_Y.release()) {};


        OSCLMemAutoPtr<T, _Allocator>& operator=(const OSCLMemAutoPtr<T, _Allocator>& _Y)
        {
            if (this != &_Y)
            {
                if (_Ptr != _Y.get())
                {
                    if (_Ownership)
                    {
                        _Allocator alloc;
                        alloc.destroy(_Ptr);
                        alloc.deallocate(_Ptr, 1);
                    }
                    _Ownership = _Y._Ownership;
                }
                else if (_Y._Ownership)
                {
                    _Ownership = true;
                }
                _Ptr = _Y.release();
            }
            return (*this);
        }

        ~OSCLMemAutoPtr()
        {
            if (_Ownership)
            {
                _Allocator alloc;
                alloc.destroy(_Ptr);
                alloc.deallocate(_Ptr, 1);
            }
        }

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

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


        void takeOwnership(T* ptr)
        {
            if (_Ptr != ptr)
            {
                if (_Ownership)
                {
                    _Allocator alloc;
                    alloc.destroy(_Ptr);
                    alloc.deallocate(_Ptr, 1);
                }
                _Ptr = ptr;
            }

            if (_Ptr)
            {
                _Ownership = true;
            }
        }

        static void deallocate(T* ptr)
        {
            _Allocator alloc;
            alloc.destroy(ptr);
            alloc.deallocate(ptr, 1);
        }

        void allocate(oscl_memsize_t size)
        {
            _Allocator alloc;
            if (_Ptr && _Ownership)
            {
                alloc.destroy(_Ptr);
                alloc.deallocate(_Ptr, 1);
            }
            _Ptr = alloc.ALLOCATE(size);
            _Ownership = true;
        }

        void setWithoutOwnership(T* ptr)
        {
            if (_Ptr != ptr)
            {
                if (_Ownership)
                {
                    _Allocator alloc;
                    alloc.destroy(_Ptr);
                    alloc.deallocate(_Ptr, 1);
                }
                _Ptr = ptr;
            }

            _Ownership = false;
        }

        T *get() const
        {
            return (_Ptr);
        }

        T *release() const
        {
            ((OSCLMemAutoPtr<T> *)this)->_Ownership = false;
            return (_Ptr);
        }

};

#endif //OSCL_MEM_AUTO_PTR_H

---