execute move of global headers

see https://gerrit.libreoffice.org/#/c/3367/
and Change-Id: I00c96fa77d04b33a6f8c8cd3490dfcd9bdc9e84a for details

Change-Id: I199a75bc4042af20817265d5ef85b1134a96ff5a

9 files changed, 0 insertions, 1625 deletions

diff --git a/o3tl/Module_o3tl.mk b/o3tl/Module_o3tl.mk
index 7b9b3e5f4576..ba02bb76aa44 100644
--- a/o3tl/Module_o3tl.mk
+++ b/o3tl/Module_o3tl.mk
@@ -28,7 +28,6 @@
 $(eval $(call gb_Module_Module,o3tl))
 
 $(eval $(call gb_Module_add_targets,o3tl,\
-	Package_inc \
 ))
 
 $(eval $(call gb_Module_add_check_targets,o3tl,\
diff --git a/o3tl/Package_inc.mk b/o3tl/Package_inc.mk
deleted file mode 100644
index b4a6575b1088..000000000000
--- a/o3tl/Package_inc.mk
+++ /dev/null
@@ -1,38 +0,0 @@
-#*************************************************************************
-#
-# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-#
-# Copyright 2000, 2011 Oracle and/or its affiliates.
-#
-# OpenOffice.org - a multi-platform office productivity suite
-#
-# This file is part of OpenOffice.org.
-#
-# OpenOffice.org is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License version 3
-# only, as published by the Free Software Foundation.
-#
-# OpenOffice.org is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License version 3 for more details
-# (a copy is included in the LICENSE file that accompanied this code).
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with OpenOffice.org.  If not, see
-# <http://www.openoffice.org/license.html>
-# for a copy of the LGPLv3 License.
-#
-#*************************************************************************
-
-$(eval $(call gb_Package_Package,o3tl_inc,$(SRCDIR)/o3tl/inc))
-
-$(eval $(call gb_Package_add_file,o3tl_inc,inc/o3tl/compat_functional.hxx,o3tl/compat_functional.hxx))
-$(eval $(call gb_Package_add_file,o3tl_inc,inc/o3tl/cow_wrapper.hxx,o3tl/cow_wrapper.hxx))
-$(eval $(call gb_Package_add_file,o3tl_inc,inc/o3tl/heap_ptr.hxx,o3tl/heap_ptr.hxx))
-$(eval $(call gb_Package_add_file,o3tl_inc,inc/o3tl/lazy_update.hxx,o3tl/lazy_update.hxx))
-$(eval $(call gb_Package_add_file,o3tl_inc,inc/o3tl/range.hxx,o3tl/range.hxx))
-$(eval $(call gb_Package_add_file,o3tl_inc,inc/o3tl/vector_pool.hxx,o3tl/vector_pool.hxx))
-$(eval $(call gb_Package_add_file,o3tl_inc,inc/o3tl/sorted_vector.hxx,o3tl/sorted_vector.hxx))
-
-# vim: set noet sw=4:
diff --git a/o3tl/inc/o3tl/compat_functional.hxx b/o3tl/inc/o3tl/compat_functional.hxx
deleted file mode 100644
index 00ae33cb23bb..000000000000
--- a/o3tl/inc/o3tl/compat_functional.hxx
+++ /dev/null
@@ -1,151 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Copyright (c) 1996-1998
- * Silicon Graphics Computer Systems, Inc.
- *
- * Copyright (c) 1997
- * Moscow Center for SPARC Technology
- *
- * Copyright (c) 1999
- * Boris Fomitchev
- *
- * This material is provided "as is", with absolutely no warranty expressed
- * or implied. Any use is at your own risk.
- *
- * Permission to use or copy this software for any purpose is hereby granted
- * without fee, provided the above notices are retained on all copies.
- * Permission to modify the code and to distribute modified code is granted,
- * provided the above notices are retained, and a notice that the code was
- * modified is included with the above copyright notice.
- *
- */
-
-/*
- * Lifted and paraphrased from STLport - with additions from Fridrich
- * Strba and Thorsten Behrens
- */
-
-#ifndef INCLUDED_O3TL_COMPAT_FUNCTIONAL_HXX
-#define INCLUDED_O3TL_COMPAT_FUNCTIONAL_HXX
-
-#include <functional>
-
-namespace o3tl
-{
-
-/// Identity functor - return the input value
-template<class T>
-struct identity : public std::unary_function<T, T>
-{
-     T operator()(const T& y) const
-     {
-          return (y);
-     }
-};
-
-/// Functor, given two parameters, return the first
-template<class T1,class T2>
-struct project1st : public std::binary_function<T1, T2, T1>
-{
-    T1 operator()(const T1& y, const T2&) const
-    {
-        return (y);
-    }
-};
-
-/// Functor, given two parameters, return the second
-template<class T1,class T2>
-struct project2nd : public std::binary_function<T1, T2, T2>
-{
-    T2 operator()(const T1&, const T2& x) const
-    {
-        return (x);
-    }
-};
-
-/// Select first value of a pair
-template<class P>
-struct select1st : public std::unary_function<P, typename P::first_type>
-{
-    const typename P::first_type& operator()(const P& y) const
-    {
-        return (y.first);
-    }
-};
-
-/// Select second value of a pair
-template<class P>
-struct select2nd : public std::unary_function<P, typename P::second_type>
-{
-    const typename P::second_type& operator()(const P& y) const
-    {
-        return (y.second);
-    }
-};
-
-/// Call F1 with the result of F2 applied to the one input parameter
-template<class F1, class F2>
-class unary_compose : public std::unary_function<typename F2::argument_type, typename F1::result_type>
-{
-    public:
-        unary_compose(const F1& fnction1, const F2& fnction2) : ftor1(fnction1), ftor2(fnction2) {}
-
-        typename F1::result_type operator()(const typename F2::argument_type& y) const
-        {
-            return (ftor1(ftor2(y)));
-        }
-
-    protected:
-        F1 ftor1;
-        F2 ftor2;
-};
-
-/// Create functor that calls F1 with the result of F2 applied to the one input parameter
-template<class F1, class F2>
-inline unary_compose<F1, F2> compose1(const F1& fnction1, const F2& fnction2)
-{
-    return (unary_compose<F1, F2>(fnction1, fnction2));
-}
-
-/// Calls F2 and F3 for the two args of F1, respectively
-template<class F1, class F2, class F3>
-class binary_compose : public std::unary_function<typename F2::argument_type,typename F1::result_type>
-{
-    public:
-        binary_compose(const F1& fnction1, const F2& fnction2, const F3& fnction3) : ftor1(fnction1), ftor2(fnction2), ftor3(fnction3) {}
-
-        typename F1::result_type operator()(const typename F2::argument_type& y) const
-        {
-            return (ftor1(ftor2(y), ftor3(y)));
-        }
-
-    protected:
-        F1 ftor1;
-        F2 ftor2;
-        F3 ftor3;
-};
-
-/// Creates functor that calls F2 and F3 for the two args of F1, respectively
-template<class F1, class F2, class F3>
-inline binary_compose<F1, F2, F3> compose2(const F1& fnction1, const F2& fnction2, const F3& fnction3)
-{
-    return (binary_compose<F1, F2, F3>(fnction1, fnction2, fnction3));
-}
-
-/// Algo that assigns val, val+1, ... to the given range
-template<typename FwdIter, typename ValueType>
-inline void iota(FwdIter first, FwdIter last, ValueType val)
-{
-    while(first != last)
-        *first++ = val++;
-}
-
-}   // namespace o3tl
-
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/o3tl/inc/o3tl/cow_wrapper.hxx b/o3tl/inc/o3tl/cow_wrapper.hxx
deleted file mode 100644
index b54f99d0f190..000000000000
--- a/o3tl/inc/o3tl/cow_wrapper.hxx
+++ /dev/null
@@ -1,322 +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_COW_WRAPPER_HXX
-#define INCLUDED_O3TL_COW_WRAPPER_HXX
-
-#include <osl/interlck.h>
-
-#include <algorithm>
-
-#include <boost/utility.hpp>
-#include <boost/checked_delete.hpp>
-
-namespace o3tl
-{
-    /** Thread-unsafe refcounting
-
-        This is the default locking policy for cow_wrapper. No
-        locking/guarding against concurrent access is performed
-        whatsoever.
-     */
-    struct UnsafeRefCountingPolicy
-    {
-        typedef sal_uInt32 ref_count_t;
-        static void incrementCount( ref_count_t& rCount ) { ++rCount; }
-        static bool decrementCount( ref_count_t& rCount ) { return --rCount != 0; }
-    };
-
-    /** Thread-safe refcounting
-
-        Use this to have the cow_wrapper refcounting mechanisms employ
-        the thread-safe oslInterlockedCount .
-     */
-    struct ThreadSafeRefCountingPolicy
-    {
-        typedef oslInterlockedCount ref_count_t;
-        static void incrementCount( ref_count_t& rCount ) { osl_atomic_increment(&rCount); }
-        static bool decrementCount( ref_count_t& rCount )
-        {
-            if( rCount == 1 ) // caller is already the only/last reference
-                return false;
-            else
-                return osl_atomic_decrement(&rCount) != 0;
-        }
-    };
-
-    /** Copy-on-write wrapper.
-
-        This template provides copy-on-write semantics for the wrapped
-        type: when copying, the operation is performed shallow,
-        i.e. different cow_wrapper objects share the same underlying
-        instance. Only when accessing the underlying object via
-        non-const methods, a unique copy is provided.
-
-        The type parameter <code>T</code> must satisfy the following
-        requirements: it must be default-constructible, copyable (it
-        need not be assignable), and be of non-reference type. Note
-        that, despite the fact that this template provides access to
-        the wrapped type via pointer-like methods
-        (<code>operator->()</code> and <code>operator*()</code>), it does
-        <em>not</em> work like e.g. the boost pointer wrappers
-        (shared_ptr, scoped_ptr, etc.). Internally, the cow_wrapper
-        holds a by-value instance of the wrapped object. This is to
-        avoid one additional heap allocation, and providing access via
-        <code>operator->()</code>/<code>operator*()</code> is because
-        <code>operator.()</code> cannot be overridden.
-
-        Regarding thread safety: this wrapper is <em>not</em>
-        thread-safe per se, because cow_wrapper has no way of
-        syncronizing the potentially many different cow_wrapper
-        instances, that reference a single shared value_type
-        instance. That said, when passing
-        <code>ThreadSafeRefCountingPolicy</code> as the
-        <code>MTPolicy</code> parameter, accessing a thread-safe
-        pointee through multiple cow_wrapper instances might be
-        thread-safe, if the individual pointee methods are
-        thread-safe, <em>including</em> pointee's copy
-        constructor. Any wrapped object that needs external
-        synchronisation (e.g. via an external mutex, which arbitrates
-        access to object methods, and can be held across multiple
-        object method calls) cannot easily be dealt with in a
-        thread-safe way, because, as noted, objects are shared behind
-        the client's back.
-
-        @attention if one wants to use the pimpl idiom together with
-        cow_wrapper (i.e. put an opaque type into the cow_wrapper),
-        then <em>all<em> methods in the surrounding class needs to be
-        non-inline (<em>including</em> destructor, copy constructor
-        and assignment operator).
-
-        @example
-        <pre>
-class cow_wrapper_client_impl;
-
-class cow_wrapper_client
-{
-public:
-    cow_wrapper_client();
-    cow_wrapper_client( const cow_wrapper_client& );
-    ~cow_wrapper_client();
-
-    cow_wrapper_client& operator=( const cow_wrapper_client& );
-
-    void modify( int nVal );
-    int queryUnmodified() const;
-
-private:
-    otl::cow_wrapper< cow_wrapper_client_impl > maImpl;
-};
-        </pre>
-        and the implementation file would look like this:
-        <pre>
-class cow_wrapper_client_impl
-{
-public:
-    void setValue( int nVal ) { mnValue = nVal; }
-    int getValue() const { return mnValue; }
-
-private:
-    int mnValue;
-}
-
-cow_wrapper_client::cow_wrapper_client() :
-    maImpl()
-{
-}
-cow_wrapper_client::cow_wrapper_client( const cow_wrapper_client& rSrc ) :
-    maImpl( rSrc.maImpl )
-{
-}
-cow_wrapper_client::~cow_wrapper_client()
-{
-}
-cow_wrapper_client& cow_wrapper_client::operator=( const cow_wrapper_client& rSrc )
-{
-    maImpl = rSrc.maImpl;
-    return *this;
-}
-void cow_wrapper_client::modify( int nVal )
-{
-    maImpl->setValue( nVal );
-}
-int cow_wrapper_client::queryUnmodified() const
-{
-    return maImpl->getValue();
-}
-        </pre>
-     */
-    template<typename T, class MTPolicy=UnsafeRefCountingPolicy> class cow_wrapper
-    {
-        /** shared value object - gets cloned before cow_wrapper hands
-            out a non-const reference to it
-         */
-        struct impl_t : private boost::noncopyable
-        {
-            impl_t() :
-                m_value(),
-                m_ref_count(1)
-            {
-            }
-
-            explicit impl_t( const T& v ) :
-                m_value(v),
-                m_ref_count(1)
-            {
-            }
-
-            T                              m_value;
-            typename MTPolicy::ref_count_t m_ref_count;
-        };
-
-        void release()
-        {
-            if( !MTPolicy::decrementCount(m_pimpl->m_ref_count) )
-                boost::checked_delete(m_pimpl), m_pimpl=0;
-        }
-
-    public:
-        typedef T        value_type;
-        typedef T*       pointer;
-        typedef const T* const_pointer;
-        typedef MTPolicy mt_policy;
-
-        /** Default-construct wrapped type instance
-         */
-        cow_wrapper() :
-            m_pimpl( new impl_t() )
-        {
-        }
-
-        /** Copy-construct wrapped type instance from given object
-         */
-        explicit cow_wrapper( const value_type& r ) :
-            m_pimpl( new impl_t(r) )
-        {
-        }
-
-        /** Shallow-copy given cow_wrapper
-         */
-        explicit cow_wrapper( const cow_wrapper& rSrc ) : // nothrow
-            m_pimpl( rSrc.m_pimpl )
-        {
-            MTPolicy::incrementCount( m_pimpl->m_ref_count );
-        }
-
-        ~cow_wrapper() // nothrow, if ~T does not throw
-        {
-            release();
-        }
-
-        /// now sharing rSrc cow_wrapper instance with us
-        cow_wrapper& operator=( const cow_wrapper& rSrc ) // nothrow
-        {
-            // this already guards against self-assignment
-            MTPolicy::incrementCount( rSrc.m_pimpl->m_ref_count );
-
-            release();
-            m_pimpl = rSrc.m_pimpl;
-
-            return *this;
-        }
-
-        /// unshare with any other cow_wrapper instance
-        value_type& make_unique()
-        {
-            if( m_pimpl->m_ref_count > 1 )
-            {
-                impl_t* pimpl = new impl_t(m_pimpl->m_value);
-                release();
-                m_pimpl = pimpl;
-            }
-
-            return m_pimpl->m_value;
-        }
-
-        /// true, if not shared with any other cow_wrapper instance
-        bool is_unique() const // nothrow
-        {
-            return m_pimpl->m_ref_count == 1;
-        }
-
-        /// return number of shared instances (1 for unique object)
-        typename MTPolicy::ref_count_t use_count() const // nothrow
-        {
-            return m_pimpl->m_ref_count;
-        }
-
-        void swap(cow_wrapper& r) // never throws
-        {
-            std::swap(m_pimpl, r.m_pimpl);
-        }
-
-        pointer           operator->()       { return &make_unique(); }
-        value_type&       operator*()        { return make_unique(); }
-        const_pointer     operator->() const { return &m_pimpl->m_value; }
-        const value_type& operator*()  const { return m_pimpl->m_value; }
-
-        pointer           get()       { return &make_unique(); }
-        const_pointer     get() const { return &m_pimpl->m_value; }
-
-        /// true, if both cow_wrapper internally share the same object
-        bool              same_object( const cow_wrapper& rOther ) const
-        {
-            return rOther.m_pimpl == m_pimpl;
-        }
-
-    private:
-        impl_t* m_pimpl;
-    };
-
-
-    template<class T, class P> inline bool operator==( const cow_wrapper<T,P>& a,
-                                                       const cow_wrapper<T,P>& b )
-    {
-        return a.same_object(b) ? true : *a == *b;
-    }
-
-    template<class T, class P> inline bool operator!=( const cow_wrapper<T,P>& a,
-                                                       const cow_wrapper<T,P>& b )
-    {
-        return a.same_object(b) ? false : *a != *b;
-    }
-
-    template<class A, class B, class P> inline bool operator<( const cow_wrapper<A,P>& a,
-                                                               const cow_wrapper<B,P>& b )
-    {
-        return *a < *b;
-    }
-
-    template<class T, class P> inline void swap( cow_wrapper<T,P>& a,
-                                                 cow_wrapper<T,P>& b )
-    {
-        a.swap(b);
-    }
-
-    // to enable boost::mem_fn on cow_wrapper
-    template<class T, class P> inline T * get_pointer( const cow_wrapper<T,P>& r )
-    {
-        return r.get();
-    }
-
-}
-
-#endif /* INCLUDED_O3TL_COW_WRAPPER_HXX */
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/o3tl/inc/o3tl/heap_ptr.hxx b/o3tl/inc/o3tl/heap_ptr.hxx
deleted file mode 100644
index 713aa21c41b8..000000000000
--- a/o3tl/inc/o3tl/heap_ptr.hxx
+++ /dev/null
@@ -1,305 +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 <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-
-
-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 transfered 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 <T>.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 T>
-class heap_ptr
-{
-  public:
-    typedef T               element_type;       /// Provided for generic programming.
-    typedef heap_ptr<T>     self;
-
-#ifndef __SUNPRO_CC
-    typedef T * (self::*    safe_bool )();
-#endif
-
-    /// 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->();
-
-    /// True, if pHeapObject != 0.
-#ifndef __SUNPRO_CC
-                        operator safe_bool() const;
-#else // workaround opt bug of Sun C++ compiler, when compiling with -xO3
-                        operator bool() const;
-#endif
-
-
-    /** 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<class T>
-inline void
-swap( heap_ptr<T> &       io_a,
-      heap_ptr<T> &       io_b )
-{
-    io_a.swap(io_b);
-}
-
-
-
-// IMPLEMENTATION
-
-template <class T>
-inline void
-heap_ptr<T>::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 <class T>
-inline
-heap_ptr<T>::heap_ptr( T * pass_heapObject )
-    : pHeapObject(pass_heapObject)
-{
-}
-
-template <class T>
-inline
-heap_ptr<T>::~heap_ptr()
-{
-    internal_delete();
-}
-
-template <class T>
-inline heap_ptr<T> &
-heap_ptr<T>::operator=(T * pass_heapObject)
-{
-    reset(pass_heapObject);
-    return *this;
-}
-
-template <class T>
-inline const T &
-heap_ptr<T>::operator*() const
-{
-    BOOST_ASSERT( pHeapObject != 0
-                  && "Accessing a heap_ptr<>(0)." );
-    return *pHeapObject;
-}
-
-template <class T>
-inline T &
-heap_ptr<T>::operator*()
-{
-    BOOST_ASSERT( pHeapObject != 0
-                  && "Accessing a heap_ptr<>(0)." );
-    return *pHeapObject;
-}
-
-template <class T>
-inline const T *
-heap_ptr<T>::operator->() const
-{
-    return pHeapObject;
-}
-
-template <class T>
-inline T *
-heap_ptr<T>::operator->()
-{
-    return pHeapObject;
-}
-
-#ifndef __SUNPRO_CC
-
-template <class T>
-inline
-heap_ptr<T>::operator typename heap_ptr<T>::safe_bool() const
-{
-    return is()
-            ? safe_bool(&self::get)
-            : safe_bool(0);
-}
-
-#else
-
-template <class T>
-inline heap_ptr<T>::operator bool() const
-{
-    return is();
-}
-
-#endif // !defined(__SUNPRO_CC)
-
-
-
-template <class T>
-void
-heap_ptr<T>::reset(T * pass_heapObject)
-{
-    if (    pHeapObject != 0
-        &&  pHeapObject == pass_heapObject)
-        return;
-
-    internal_delete();
-    pHeapObject = pass_heapObject;
-}
-
-template <class T>
-T *
-heap_ptr<T>::release()
-{
-    T * ret = pHeapObject;
-    pHeapObject = 0;
-    return ret;
-}
-
-template <class T>
-void
-heap_ptr<T>::swap(self & io_other)
-{
-    T * temp = io_other.pHeapObject;
-    io_other.pHeapObject = pHeapObject;
-    pHeapObject = temp;
-}
-
-template <class T>
-inline bool
-heap_ptr<T>::is() const
-{
-    return pHeapObject != 0;
-}
-
-template <class T>
-inline const T *
-heap_ptr<T>::get() const
-{
-    return pHeapObject;
-}
-
-template <class T>
-inline T *
-heap_ptr<T>::get()
-{
-    return pHeapObject;
-}
-
-
-}   // namespace o3tl
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/o3tl/inc/o3tl/lazy_update.hxx b/o3tl/inc/o3tl/lazy_update.hxx
deleted file mode 100644
index b05bda37ba40..000000000000
--- a/o3tl/inc/o3tl/lazy_update.hxx
+++ /dev/null
@@ -1,265 +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_LAZY_UPDATE_HXX
-#define INCLUDED_O3TL_LAZY_UPDATE_HXX
-
-#include <sal/types.h>
-#include <boost/function.hpp>
-
-namespace o3tl
-{
-    /** Update output object lazily
-
-        This template collects data in input type, and updates the
-        output type with the given update functor, but only if the
-        output is requested. Usefúl if updating is expensive, or input
-        changes frequently, but output is only comparatively seldom
-        used.
-
-        @example
-        <pre>
-LazyUpdate<InType,OutType,LAZYUPDATE_DIRECT_TAG> myValue;
-*myValue = newInput;
-myValue->updateInput( this, that, those );
-
-output( *myValue );
-        </pre>
-        or
-        <pre>
-output( myValue.getOutValue() );
-        </pre>
-        if the compiler does not recognize the const context.
-     */
-    template< typename InputType, typename OutputType, typename Tag > class LazyUpdate;
-
-    /// LazyUpdate specialization takes boost::function argument
-    struct LAZYUPDATE_FUNCTOR_TAG       {};
-    /// LazyUpdate specialization takes OutputType (*FunctionType)( InputType const& ) argument
-    struct LAZYUPDATE_FUNCTION_TAG      {};
-    /// LazyUpdate specialization can directly convert, OutputType ctor must take InputType argument
-    struct LAZYUPDATE_DIRECT_TAG  {};
-
-    // -----------------------------------------------------------------------------------------------------
-
-    namespace detail
-    {
-        /// @internal
-        template< typename InputType, typename OutputType, typename Functor > class LazyUpdateImpl : private Functor
-        {
-        public:
-            typedef OutputType output_type;
-            typedef InputType  input_type;
-
-            LazyUpdateImpl() :
-                m_aInput()
-            {}
-
-            template< typename ParamType > explicit LazyUpdateImpl( ParamType const& rParm ) :
-                Functor(rParm),
-                m_aInput()
-            {}
-
-            enum UnaryConstructorTag{ UNARY_CONSTRUCTOR_TAG };
-            LazyUpdateImpl( const input_type& rInput, UnaryConstructorTag ) :
-                m_aInput(rInput)
-            {}
-
-            template< typename ParamType > LazyUpdateImpl( ParamType const&  rParm,
-                                                           const input_type& rInput ) :
-                Functor(rParm),
-                m_aInput(rInput)
-            {}
-
-            // default copy ctor/assignment operator are ok
-            // LazyUpdate( const LazyUpdate& );
-            // LazyUpdate& operator=( const LazyUpdate& );
-
-            void               setInValue( input_type const& rIn ) { Functor::m_bCacheDirty = true; m_aInput = rIn; }
-            input_type const&  getInValue()  const                 { return m_aInput; }
-            output_type const& getOutValue() const                 { return this->implUpdateValue(m_aInput); }
-
-            input_type& operator*()  { Functor::m_bCacheDirty = true; return m_aInput;  }
-            input_type* operator->() { Functor::m_bCacheDirty = true; return &m_aInput; }
-
-            output_type const& operator*() const  { return this->implUpdateValue(m_aInput);  }
-            output_type const* operator->() const { return &(this->implUpdateValue(m_aInput)); }
-
-        private:
-            input_type m_aInput;
-        };
-
-        template< typename InputType, typename OutputType > struct DefaultFunctor
-        {
-        protected:
-            typedef OutputType output_type;
-            typedef InputType  input_type;
-
-            DefaultFunctor() :
-                m_aOutput(),
-                m_bCacheDirty(true)
-            {}
-
-            OutputType const& implUpdateValue( input_type const& rIn ) const
-            {
-                if( m_bCacheDirty )
-                {
-                    m_aOutput = output_type( rIn );
-                    m_bCacheDirty = false;
-                }
-
-                return m_aOutput;
-            }
-
-            mutable output_type m_aOutput;
-            mutable bool        m_bCacheDirty; // when true, m_aOutput needs update
-        };
-
-        template< typename InputType, typename OutputType, typename FunctionType > struct FunctionPointer
-        {
-        protected:
-            typedef OutputType   output_type;
-            typedef InputType    input_type;
-            typedef FunctionType function_type;
-
-            FunctionPointer() :
-                m_pFunc(),
-                m_aOutput(),
-                m_bCacheDirty(true)
-
-            {}
-
-            explicit FunctionPointer( function_type const& pFunc ) :
-                m_pFunc(pFunc),
-                m_aOutput(),
-                m_bCacheDirty(true)
-
-            {}
-
-            output_type const& implUpdateValue( input_type const& rIn ) const
-            {
-                if( m_bCacheDirty )
-                {
-                    m_aOutput = m_pFunc( rIn );
-                    m_bCacheDirty = false;
-                }
-
-                return m_aOutput;
-            }
-
-            function_type       m_pFunc;
-            mutable output_type m_aOutput;
-            mutable bool        m_bCacheDirty; // when true, m_aOutput needs update
-        };
-    }
-
-    // -----------------------------------------------------------------------------------------------------
-
-    // partial specializations for the three LAZYUPDATE_* tags
-
-    template< typename InputType, typename OutputType > class LazyUpdate<InputType,
-                                                                         OutputType,
-                                                                         LAZYUPDATE_DIRECT_TAG> :
-        public detail::LazyUpdateImpl<InputType,
-                                      OutputType,
-                                      detail::DefaultFunctor<InputType, OutputType> >
-    {
-    public:
-        LazyUpdate() {}
-        explicit LazyUpdate( InputType const& rIn ) :
-            detail::LazyUpdateImpl<InputType,
-                                   OutputType,
-                                   detail::DefaultFunctor<InputType, OutputType> >(
-                                       rIn,
-                                       detail::LazyUpdateImpl<
-                                            InputType,
-                                            OutputType,
-                                            detail::DefaultFunctor<InputType, OutputType> >::UNARY_CONSTRUCTOR_TAG )
-        {}
-    };
-
-    // -----------------------------------------------------------------------------------------------------
-
-    template< typename InputType, typename OutputType > class LazyUpdate<InputType,
-                                                                         OutputType,
-                                                                         LAZYUPDATE_FUNCTION_TAG> :
-        public detail::LazyUpdateImpl<InputType,
-                                      OutputType,
-                                      detail::FunctionPointer<
-                                          InputType,
-                                          OutputType,
-                                          OutputType (*)( InputType const& ) > >
-    {
-    public:
-        explicit LazyUpdate( OutputType (*pFunc)( InputType const& ) ) :
-            detail::LazyUpdateImpl<InputType,
-                                   OutputType,
-                                   detail::FunctionPointer<
-                                       InputType,
-                                       OutputType,
-                                       OutputType (*)( InputType const& )> >(pFunc)
-        {}
-        LazyUpdate( OutputType (*pFunc)( InputType const& ),
-                    InputType const& rIn ) :
-            detail::LazyUpdateImpl<InputType,
-                                   OutputType,
-                                   detail::FunctionPointer<
-                                       InputType,
-                                       OutputType,
-                                       OutputType (*)( InputType const& )> >(pFunc,rIn)
-        {}
-    };
-
-    // -----------------------------------------------------------------------------------------------------
-
-    template< typename InputType, typename OutputType > class LazyUpdate<InputType,
-                                                                         OutputType,
-                                                                         LAZYUPDATE_FUNCTOR_TAG> :
-        public detail::LazyUpdateImpl<InputType,
-                                      OutputType,
-                                      detail::FunctionPointer<
-                                          InputType,
-                                          OutputType,
-                                          boost::function1<OutputType,InputType> > >
-    {
-    public:
-        explicit LazyUpdate( boost::function1<OutputType,InputType> const& rFunc ) :
-            detail::LazyUpdateImpl<InputType,
-                                   OutputType,
-                                   detail::FunctionPointer<
-                                       InputType,
-                                       OutputType,
-                                       boost::function1<OutputType,InputType> > >(rFunc)
-        {}
-        LazyUpdate( boost::function1<OutputType,InputType> const& rFunc,
-                    InputType const& rIn ) :
-            detail::LazyUpdateImpl<InputType,
-                                   OutputType,
-                                   detail::FunctionPointer<
-                                       InputType,
-                                       OutputType,
-                                       boost::function1<OutputType,InputType> > >(rFunc,rIn)
-        {}
-    };
-
-}
-
-#endif /* INCLUDED_O3TL_LAZY_UPDATE_HXX */
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/o3tl/inc/o3tl/range.hxx b/o3tl/inc/o3tl/range.hxx
deleted file mode 100644
index a5ebacb4c6b8..000000000000
--- a/o3tl/inc/o3tl/range.hxx
+++ /dev/null
@@ -1,183 +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_RANGE_HXX
-#define INCLUDED_O3TL_RANGE_HXX
-
-
-#include <cstring>  // for std::size_t
-#include <boost/assert.hpp>
-
-
-
-namespace o3tl
-{
-/** Represents a range of integer or iterator values.
-
-    @tpl T
-    Has to be assignable, add- and subtractable. That is:
-    either it is
-        - an integral type
-        - or a random access iterator.
-*/
-template <class T>
-class range
-{
-  public:
-    typedef T           element_type;       /// Provided for generic programming.
-    typedef range<T>    self;
-
-  // LIFECYCLE
-                        range(
-                            T                   i_inclusiveLowerBorder,
-                            T                   i_exclusiveUpperBorder );
-                        ~range();
-  // INQUIRY
-    T                   begin() const;
-    T                   end() const;
-    std::size_t         size() const;
-
-    bool                contains(
-                            T                   i_value ) const;
-    bool                contains(
-                            const self &        i_other ) const;
-    bool                overlaps(
-                            const self &        i_other ) const;
-    /// @return i_other.begin() - this->end()
-    long                distance_to(
-                            const self &        i_other ) const;
-  private:
-  // DATA
-    T                   nBegin;
-    T                   nEnd;
-};
-
-
-template <class T>
-inline range<T>
-make_range(T i1, T i2)
-{
-    return range<T>(i1, i2);
-}
-
-template <class T>
-inline range<typename T::const_iterator>
-range_of(const T & i_container)
-{
-    return make_range( i_container.begin(),
-                       i_container.end()
-                     );
-}
-
-template <class T>
-inline range<typename T::iterator>
-range_of(T & io_container)
-{
-    return make_range( io_container.begin(),
-                       io_container.end()
-                     );
-}
-
-
-
-
-
-// IMPLEMENTATION
-
-template <class T>
-range<T>::range( T i_inclusiveLowerBorder,
-                 T i_exclusiveUpperBorder )
-    :   nBegin(i_inclusiveLowerBorder),
-        nEnd(i_exclusiveUpperBorder)
-{
-    BOOST_ASSERT(   nBegin <= nEnd
-                 && "Invalid parameters for range<> constructor.");
-}
-
-template <class T>
-range<T>::~range()
-{
-}
-
-template <class T>
-inline T
-range<T>::begin() const
-{
-    return nBegin;
-}
-
-template <class T>
-inline T
-range<T>::end() const
-{
-    return nEnd;
-}
-
-template <class T>
-inline std::size_t
-range<T>::size() const
-{
-    BOOST_ASSERT(   nBegin <= nEnd
-                 && "Invalid range limits in range<>::size().");
-    return static_cast<std::size_t>( end() - begin() );
-}
-
-template <class T>
-bool
-range<T>::contains(T i_value ) const
-{
-    return      begin() <= i_value
-            &&  i_value < end();
-}
-
-template <class T>
-bool
-range<T>::contains(const self & i_other) const
-{
-    // This is subtle, because this would be wrong:
-    //      begin() <= i_other.begin()
-    //      &&  i_other.end() <= end();
-    // An empty range that begins and starts at my end()
-    // must not be contained.
-
-    return      contains(i_other.begin())
-            &&  i_other.end() <= end();
-}
-
-template <class T>
-bool
-range<T>::overlaps(const self & i_other) const
-{
-    return      contains(i_other.begin())
-            ||  i_other.contains(begin());
-}
-
-template <class T>
-long
-range<T>::distance_to(const self & i_other) const
-{
-    return i_other.begin() - end();
-}
-
-
-
-}   // namespace o3tl
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/o3tl/inc/o3tl/sorted_vector.hxx b/o3tl/inc/o3tl/sorted_vector.hxx
deleted file mode 100644
index 776fd5605e6f..000000000000
--- a/o3tl/inc/o3tl/sorted_vector.hxx
+++ /dev/null
@@ -1,237 +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/.
- */
-
-#ifndef INCLUDED_O3TL_SORTED_VECTOR_HXX
-#define INCLUDED_O3TL_SORTED_VECTOR_HXX
-
-#include <vector>
-#include <functional>
-#include <algorithm>
-
-namespace o3tl
-{
-
-// forward declared because it's default tempate arg for sorted_vector
-template<class Value, class Compare>
-struct find_unique;
-
-/** Represents a sorted vector of values.
-
-    @tpl Value class of item to be stored in container
-    @tpl Compare comparison method
-    @tpl Find   look up index of a Value in the array
-*/
-template<typename Value, typename Compare = std::less<Value>,
-     template<typename, typename> class Find = find_unique >
-class sorted_vector
-    : private std::vector<Value>
-{
-private:
-    typedef Find<Value, Compare> Find_t;
-    typedef typename std::vector<Value> base_t;
-    typedef typename std::vector<Value>::iterator  iterator;
-public:
-    typedef typename std::vector<Value>::const_iterator const_iterator;
-    typedef typename std::vector<Value>::size_type size_type;
-
-    using base_t::clear;
-    using base_t::empty;
-    using base_t::size;
-
-    // MODIFIERS
-
-    std::pair<const_iterator,bool> insert( const Value& x )
-    {
-        std::pair<const_iterator, bool> const ret(Find_t()(begin(), end(), x));
-        if (!ret.second)
-        {
-            const_iterator const it = base_t::insert(
-                            begin_nonconst() + (ret.first - begin()), x);
-            return std::make_pair(it, true);
-        }
-        return std::make_pair(ret.first, false);
-    }
-
-    size_type erase( const Value& x )
-    {
-        std::pair<const_iterator, bool> const ret(Find_t()(begin(), end(), x));
-        if (ret.second)
-        {
-            base_t::erase(begin_nonconst() + (ret.first - begin()));
-            return 1;
-        }
-        return 0;
-    }
-
-    void erase( size_t index )
-    {
-        base_t::erase( begin_nonconst() + index );
-    }
-
-    // like C++ 2011: erase with const_iterator (doesn't change sort order)
-    void erase(const_iterator const& position)
-    {   // C++98 has vector::erase(iterator), so call that
-        base_t::erase(begin_nonconst() + (position - begin()));
-    }
-
-    void erase(const_iterator const& first, const_iterator const& last)
-    {
-        base_t::erase(begin_nonconst() + (first - begin()),
-                      begin_nonconst() + (last  - begin()));
-    }
-
-    // ACCESSORS
-
-    // Only return a const iterator, so that the vector cannot be directly updated.
-    const_iterator begin() const
-    {
-        return base_t::begin();
-    }
-
-    // Only return a const iterator, so that the vector cannot be directly updated.
-    const_iterator end() const
-    {
-        return base_t::end();
-    }
-
-    const Value& front() const
-    {
-        return base_t::front();
-    }
-
-    const Value& back() const
-    {
-        return base_t::back();
-    }
-
-    const Value& operator[]( size_t index ) const
-    {
-        return base_t::operator[]( index );
-    }
-
-    // OPERATIONS
-
-    const_iterator lower_bound( const Value& x ) const
-    {
-        return std::lower_bound( base_t::begin(), base_t::end(), x, Compare() );
-    }
-
-    const_iterator upper_bound( const Value& x ) const
-    {
-        return std::upper_bound( base_t::begin(), base_t::end(), x, Compare() );
-    }
-
-    /* Searches the container for an element with a value of x
-     * and returns an iterator to it if found, otherwise it returns an
-     * iterator to sorted_vector::end (the element past the end of the container).
-     *
-     * Only return a const iterator, so that the vector cannot be directly updated.
-     */
-    const_iterator find( const Value& x ) const
-    {
-        std::pair<const_iterator, bool> const ret(Find_t()(begin(), end(), x));
-        return (ret.second) ? ret.first : end();
-    }
-
-    void insert(sorted_vector<Value,Compare,Find> const& rOther)
-    {
-       // optimisation for the rather common case that we are overwriting this with the contents
-       // of another sorted vector
-       if ( empty() )
-       {
-           base_t::insert(begin_nonconst(), rOther.begin(), rOther.end());
-       }
-       else
-           for( const_iterator it = rOther.begin(); it != rOther.end(); ++it )
-               insert( *it );
-    }
-
-    /* Clear() elements in the vector, and free them one by one. */
-    void DeleteAndDestroyAll()
-    {
-        for( const_iterator it = begin(); it != end(); ++it )
-            delete *it;
-        clear();
-    }
-
-    // fdo#58793: some existing code in Writer (SwpHintsArray)
-    // routinely modifies the members of the vector in a way that
-    // violates the sort order, and then re-sorts the array.
-    // This is a kludge to enable that code to work.
-    // If you are calling this function, you are Doing It Wrong!
-    void Resort()
-    {
-        std::stable_sort(begin_nonconst(), end_nonconst(), Compare());
-    }
-
-private:
-
-    typename base_t::iterator begin_nonconst() { return base_t::begin(); }
-    typename base_t::iterator end_nonconst()   { return base_t::end(); }
-
-};
-
-
-/** Implements an ordering function over a pointer, where the comparison uses the < operator on the pointed-to types.
-    Very useful for the cases where we put pointers to objects inside a sorted_vector.
-*/
-template <class T> struct less_ptr_to : public std::binary_function <T*,T*,bool>
-{
-    bool operator() ( T* const& lhs, T* const& rhs ) const
-    {
-        return (*lhs) < (*rhs);
-    }
-};
-
-/** the elements are totally ordered by Compare,
-    for no 2 elements !Compare(a,b) && !Compare(b,a) is true
-  */
-template<class Value, class Compare>
-struct find_unique
-{
-    typedef typename sorted_vector<Value, Compare,
-            o3tl::find_unique> ::const_iterator const_iterator;
-    std::pair<const_iterator, bool> operator()(
-            const_iterator first, const_iterator last,
-            Value const& v)
-    {
-        const_iterator const it = std::lower_bound(first, last, v, Compare());
-        return std::make_pair(it, (it != last && !Compare()(v, *it)));
-    }
-};
-
-/** the elements are partially ordered by Compare,
-    2 elements are allowed if they are not the same element (pointer equal)
-  */
-template<class Value, class Compare>
-struct find_partialorder_ptrequals
-{
-    typedef typename sorted_vector<Value, Compare,
-            o3tl::find_partialorder_ptrequals>::const_iterator const_iterator;
-    std::pair<const_iterator, bool> operator()(
-            const_iterator first, const_iterator last,
-            Value const& v)
-    {
-        std::pair<const_iterator, const_iterator> const its =
-            std::equal_range(first, last, v, Compare());
-        for (const_iterator it = its.first; it != its.second; ++it)
-        {
-            if (v == *it)
-            {
-                return std::make_pair(it, true);
-            }
-        }
-        return std::make_pair(its.first, false);
-    }
-};
-
-}   // namespace o3tl
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/o3tl/inc/o3tl/vector_pool.hxx b/o3tl/inc/o3tl/vector_pool.hxx
deleted file mode 100644
index b132289af3ab..000000000000
--- a/o3tl/inc/o3tl/vector_pool.hxx
+++ /dev/null
@@ -1,123 +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_VECTOR_POOL_HXX
-#define INCLUDED_O3TL_VECTOR_POOL_HXX
-
-#include <sal/types.h>
-#include <vector>
-
-namespace o3tl
-{
-    namespace detail
-    {
-        template<typename ValueType, class Container> class simple_pool_impl :
-            public Container
-        {
-            typedef typename Container::value_type value_type;
-            std::ptrdiff_t mnFirstFreeIndex;
-
-        public:
-            simple_pool_impl() :
-                mnFirstFreeIndex(-1)
-            {}
-
-            std::ptrdiff_t alloc()
-            {
-                return store(ValueType());
-            }
-
-            std::ptrdiff_t store(const ValueType& rCopy)
-            {
-                if( mnFirstFreeIndex != -1 )
-                {
-                    std::ptrdiff_t nIdx=mnFirstFreeIndex;
-                    mnFirstFreeIndex = this->at(mnFirstFreeIndex).nextFree;
-                    this->at(nIdx).value = rCopy;
-                    this->at(nIdx).nextFree = -1;
-
-                    return nIdx;
-                }
-                else
-                {
-                    this->push_back(value_type(rCopy));
-                    return this->size()-1;
-                }
-            }
-
-            void free( std::ptrdiff_t nIdx )
-            {
-                this->at(nIdx).nextFree = mnFirstFreeIndex;
-                mnFirstFreeIndex = nIdx;
-            }
-
-            const ValueType& get( std::ptrdiff_t nIdx ) const
-            {
-                return this->operator[](nIdx).value;
-            }
-            ValueType& get( std::ptrdiff_t nIdx )
-            {
-                return this->operator[](nIdx).value;
-            }
-        };
-
-        template< typename ValueType > struct struct_from_value
-        {
-            struct type
-            {
-                type() :
-                    value(),
-                    nextFree(-1)
-                {}
-                explicit type( const ValueType& val ) :
-                    value(val),
-                    nextFree(-1)
-                {}
-
-                ValueType      value;
-                std::ptrdiff_t nextFree;
-            };
-        };
-    }
-
-    /** Simple vector-based memory pool allocator
-
-        This template can be used to provide simple pooled memory
-        allocation from a container class that adheres to the stl
-        random access container concept. Note that alloc/free works
-        with _indices_ into the container!
-
-        @example
-        <pre>
-vector_pool<type> myPool;
-int nIdx=myPool.alloc();
-myPool[nIdx] = myVal;
- ... do stuff ...
-myPool.free(nIdx);
-        </pre>
-     */
-    template<typename ValueType> struct vector_pool :
-        public detail::simple_pool_impl<ValueType,
-                                       std::vector<typename detail::struct_from_value<ValueType>::type > >
-    {};
-}
-
-#endif /* INCLUDED_O3TL_VECTOR_POOL_HXX */
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */