LibreOffice Module o3tl (master)
1
|
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 T
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 (operator->()
and operator*()
), it does not work like e.g. the std smart pointer wrappers (shared_ptr, unique_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 operator->()
/operator*()
is because operator.()
cannot be overridden.
Regarding thread safety: this wrapper is not thread-safe per se, because cow_wrapper has no way of synchronizing the potentially many different cow_wrapper instances, that reference a single shared value_type instance. That said, when passing ThreadSafeRefCountingPolicy
as the MTPolicy
parameter, accessing a thread-safe pointee through multiple cow_wrapper instances might be thread-safe, if the individual pointee methods are thread-safe, including 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.
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&& ); ~cow_wrapper_client();
cow_wrapper_client& operator=( const cow_wrapper_client& ); cow_wrapper_client& operator=( cow_wrapper_client&& );
void modify( int nVal ); int queryUnmodified() const;
private: o3tl::cow_wrapper< cow_wrapper_client_impl > maImpl; }; and the implementation file would look like this: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& rSrc ) : maImpl( std::move( 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; } cow_wrapper_client& cow_wrapper_client::operator=( cow_wrapper_client&& rSrc ) { maImpl = std::move( rSrc.maImpl ); return *this; } void cow_wrapper_client::modify( int nVal ) { maImpl->setValue( nVal ); } int cow_wrapper_client::queryUnmodified() const { return maImpl->getValue(); }
/* -*- 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 <memory>#include <osl/interlck.h>#include <utility>#include <cstddef>namespace o3tl{struct UnsafeRefCountingPolicy{};struct ThreadSafeRefCountingPolicy{{if( rCount == 1 ) // caller is already the only/last referencereturn false;elsereturn osl_atomic_decrement(&rCount) != 0;}};template<typename T, class MTPolicy=UnsafeRefCountingPolicy> class cow_wrapper{struct impl_t{impl_t() :m_value(),m_ref_count(1){}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;};{{delete m_pimpl;m_pimpl = nullptr;}}public:cow_wrapper() :m_pimpl( new impl_t() ){}m_pimpl( new impl_t(r) ){}explicit cow_wrapper( value_type&& r ) :m_pimpl( new impl_t(std::move(r)) ){}m_pimpl( rSrc.m_pimpl ){MTPolicy::incrementCount( m_pimpl->m_ref_count );}m_pimpl( rSrc.m_pimpl ){rSrc.m_pimpl = nullptr;}{release();}{// this already guards against self-assignmentMTPolicy::incrementCount( rSrc.m_pimpl->m_ref_count );release();m_pimpl = rSrc.m_pimpl;return *this;}{// self-movement guts ourself, see also 17.6.4.9release();m_pimpl = rSrc.m_pimpl;rSrc.m_pimpl = nullptr;return *this;}value_type& make_unique(){{release();m_pimpl = pimpl;}}{}{}{}{return rOther.m_pimpl == m_pimpl;}private:impl_t* m_pimpl;};const cow_wrapper<T,P>& b ){return a.same_object(b) || *a == *b;}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;}cow_wrapper<T,P>& b ){a.swap(b);}}#endif /* INCLUDED_O3TL_COW_WRAPPER_HXX *//* vim:set shiftwidth=4 softtabstop=4 expandtab: */