cow_wrapper.hxx

Go to the documentation of this file.

/* -*- 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 <optional>
#include <cstddef>
 
namespace o3tl
{
    struct UnsafeRefCountingPolicy
    {
        typedef std::size_t ref_count_t;
        static void incrementCount( ref_count_t& rCount ) { ++rCount; }
        static bool decrementCount( ref_count_t& rCount ) { return --rCount != 0; }
    };
 
    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 )
        {
            return osl_atomic_decrement(&rCount) != 0;
        }
    };
 
    template<typename T, class MTPolicy=UnsafeRefCountingPolicy> class cow_wrapper
    {
        struct impl_t
        {
            impl_t(const impl_t&) = delete;
            impl_t& operator=(const impl_t&) = delete;
 
            impl_t() :
                m_value(),
                m_ref_count(1)
            {
            }
 
            explicit impl_t( const T& v ) :
                m_value(v),
                m_ref_count(1)
            {
            }
 
            explicit impl_t( T&& v ) :
                m_value(std::move(v)),
                m_ref_count(1)
            {
            }
 
            T                              m_value;
            typename MTPolicy::ref_count_t m_ref_count;
        };
 
        void release()
        {
            if( m_pimpl && !MTPolicy::decrementCount(m_pimpl->m_ref_count) )
            {
                delete m_pimpl;
                m_pimpl = nullptr;
            }
        }
 
    public:
        typedef T        value_type;
        typedef T*       pointer;
        typedef const T* const_pointer;
        typedef MTPolicy mt_policy;
 
        cow_wrapper() :
            m_pimpl( new impl_t() )
        {
        }
 
        explicit cow_wrapper( const value_type& r ) :
            m_pimpl( new impl_t(r) )
        {
        }
 
        explicit cow_wrapper( value_type&& r ) :
            m_pimpl( new impl_t(std::move(r)) )
        {
        }
 
        explicit cow_wrapper( const cow_wrapper& rSrc ) : // nothrow
            m_pimpl( rSrc.m_pimpl )
        {
            MTPolicy::incrementCount( m_pimpl->m_ref_count );
        }
 
        explicit cow_wrapper( cow_wrapper&& rSrc ) noexcept :
            m_pimpl( rSrc.m_pimpl )
        {
            rSrc.m_pimpl = nullptr;
        }
 
        // Only intended to be used by std::optional specialisations
        explicit cow_wrapper( std::nullopt_t ) noexcept :
            m_pimpl( nullptr )
        {
        }
 
        // Only intended to be used by std::optional specialisations
        explicit cow_wrapper( const cow_wrapper& rSrc, std::nullopt_t ) : // nothrow
            m_pimpl( rSrc.m_pimpl )
        {
            if (m_pimpl)
                MTPolicy::incrementCount( m_pimpl->m_ref_count );
        }
 
        ~cow_wrapper() // nothrow, if ~T does not throw
        {
            release();
        }
 
        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;
        }
 
        cow_wrapper& operator=(cow_wrapper&& rSrc) noexcept
        {
            // self-movement guts ourself, see also 17.6.4.9
            release();
            m_pimpl = rSrc.m_pimpl;
 
            rSrc.m_pimpl = nullptr;
 
            return *this;
        }
 
        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;
        }
 
        bool is_unique() const // nothrow
        {
            return !m_pimpl || m_pimpl->m_ref_count == 1;
        }
 
        typename MTPolicy::ref_count_t use_count() const // nothrow
        {
            return m_pimpl ? m_pimpl->m_ref_count : 0;
        }
 
        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; }
 
        bool              same_object( const cow_wrapper& rOther ) const
        {
            return rOther.m_pimpl == m_pimpl;
        }
 
        // Only intended to be used by std::optional specialisations
        bool empty() const { return m_pimpl == nullptr; }
        // Only intended to be used by std::optional specialisations
        void set_empty()
        {
            if (m_pimpl)
            {
                release();
                m_pimpl = nullptr;
            }
        }
 
    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) || *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) && *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);
    }
 
}
 
#endif /* INCLUDED_O3TL_COW_WRAPPER_HXX */
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */