From 9703cc63cea3c47d13afe5f9b0eb22c631000958 Mon Sep 17 00:00:00 2001 From: Stephan Bergmann Date: Wed, 24 Sep 2014 14:54:51 +0200 Subject: Remove o3tl/heap_ptr.hxx, use std::unique_ptr instead Change-Id: Iac70c9be13892a36bfb5975f62e5345b88d4f144 --- include/o3tl/heap_ptr.hxx | 283 ---------------------------------------------- 1 file changed, 283 deletions(-) delete mode 100644 include/o3tl/heap_ptr.hxx (limited to 'include/o3tl') diff --git a/include/o3tl/heap_ptr.hxx b/include/o3tl/heap_ptr.hxx deleted file mode 100644 index eca82a7c692d..000000000000 --- a/include/o3tl/heap_ptr.hxx +++ /dev/null @@ -1,283 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_O3TL_HEAP_PTR_HXX -#define INCLUDED_O3TL_HEAP_PTR_HXX - - -#include -#include -#include - -namespace o3tl -{ -/** heap_ptr<> owns an object on the heap, which will be automatically - deleted, when ~heap_ptr<>() is called. - - Applicability - ------------- - heap_ptr<> can be used for class members on the heap. - - One cannot forget to delete them in the destructor. - - Constness will be transferred from the owning instance. - - heap_ptr<> can also be used as smart pointer in function bodies to - ensure exception safety. - - Special Characteristics - ----------------------- - - heap_ptr<> transfers constness from the owning object to - the pointed to object. Such it behaves like if *get() would be - a normal member of the owning object, not a pointer member. - This is preferable to the normal pointer behaviour, because - if an object is owned by another one, it is normally part of - its state. - - - heap_ptr<> provides a ->release() function - - - For reasons of simplicity and portability ->is() - is preferred over the safe-bool idiom. - - Copyability - ----------- - heap_ptr is non copyable. - - It forbids the copyconstructor and operator=(self). - - - Owning classes will automatically be non copyable, if they do not - redefine those two functions themselves. - - Incomplete Types - ---------------- - heap_ptr<> also works with incomplete types. You only need to write - class T; - but need not include .hxx. - - If you use heap_ptr<> with an incomplete type, the owning class - needs to define a non-inline destructor. Else the compiler will - complain. -*/ -template > -class SAL_WARN_UNUSED heap_ptr -{ - public: - typedef T element_type; /// Provided for generic programming. - typedef heap_ptr self; - - typedef T * (self::* safe_bool )(); - - /// Now, pass_heapObject is owned by this. - explicit heap_ptr( - T * pass_heapObject = 0 ); - ~heap_ptr(); - - - /** Identical to reset(), except of the return value. - @see heap_ptr<>::reset() - */ - self & operator=( - T * pass_heapObject ); - const T & operator*() const; - T & operator*(); - const T * operator->() const; - T * operator->(); - - operator safe_bool() const; - - /** This deletes any prevoiusly existing ->pHeapObject. - Now, pass_heapObject, if != 0, is owned by this. - - @onerror - Ignores self-assignment. - Such, multiple assignment of the same pointer to the same - instance of heap_ptr<> is possible (though not recommended). - */ - void reset( - T * pass_heapObject ); - /** @return An object on the heap that must be deleted by the caller, - or 0. - - @postcond get() == 0; - */ - T * release(); - void swap( - self & io_other ); - - /// True, if pHeapObject != 0. - bool is() const; - const T * get() const; - T * get(); - - private: - // Forbidden functions: - heap_ptr( const self & ); /// Prevent copies. - self & operator=( const self & ); /// Prevent copies. - - /// @attention Does not set ->pHeapObject = 0. - void internal_delete(); - - // DATA - /// Will be deleted, when *this is destroyed. - T * pHeapObject; -}; - - -/** Supports the semantic of std::swap(). Provided as an aid to - generic programming. -*/ -template -inline void -swap( heap_ptr & io_a, - heap_ptr & io_b ) -{ - io_a.swap(io_b); -} - - - -// IMPLEMENTATION - -template -inline void -heap_ptr::internal_delete() -{ - ::boost::checked_delete(pHeapObject); - - // Do not set pHeapObject to 0, because - // that is reset to a value in all code - // where internal_delete() is used. -} - -template -inline -heap_ptr::heap_ptr( T * pass_heapObject ) - : pHeapObject(pass_heapObject) -{ -} - -template -inline -heap_ptr::~heap_ptr() -{ - internal_delete(); -} - -template -inline heap_ptr & -heap_ptr::operator=(T * pass_heapObject) -{ - reset(pass_heapObject); - return *this; -} - -template -inline const T & -heap_ptr::operator*() const -{ - BOOST_ASSERT( pHeapObject != 0 - && "Accessing a heap_ptr<>(0)." ); - return *pHeapObject; -} - -template -inline T & -heap_ptr::operator*() -{ - BOOST_ASSERT( pHeapObject != 0 - && "Accessing a heap_ptr<>(0)." ); - return *pHeapObject; -} - -template -inline const T * -heap_ptr::operator->() const -{ - return pHeapObject; -} - -template -inline T * -heap_ptr::operator->() -{ - return pHeapObject; -} - -template -inline -heap_ptr::operator typename heap_ptr::safe_bool() const -{ - return is() - ? safe_bool(&self::get) - : safe_bool(0); -} - -template -void -heap_ptr::reset(T * pass_heapObject) -{ - if ( pHeapObject != 0 - && pHeapObject == pass_heapObject) - return; - - internal_delete(); - pHeapObject = pass_heapObject; -} - -template -T * -heap_ptr::release() -{ - T * ret = pHeapObject; - pHeapObject = 0; - return ret; -} - -template -void -heap_ptr::swap(self & io_other) -{ - T * temp = io_other.pHeapObject; - io_other.pHeapObject = pHeapObject; - pHeapObject = temp; -} - -template -inline bool -heap_ptr::is() const -{ - return pHeapObject != 0; -} - -template -inline const T * -heap_ptr::get() const -{ - return pHeapObject; -} - -template -inline T * -heap_ptr::get() -{ - return pHeapObject; -} - - -} // namespace o3tl -#endif - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3