Documentation Overview Building ASL Documentation Library Wiki Docs Indices Browse Perforce More Info Release Notes Wiki Site Search License Success Stories Contributors Media Download Perforce Depots Support ASL SourceForge Home Mailing Lists Discussion Forums Report Bugs Suggest Features Contribute to ASL RSS Short-text news Full-text news File releases Other Adobe Projects Adobe Air Adobe GIL C++ Benchmarks Adobe Labs Adobe Media Gallery Adobe XMP Tamarin project (Mozilla Foundation) Other Resources Boost RIAForge SGI STL

copy_on_write.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt or a copy at http://stlab.adobe.com/licenses.html) */ /**************************************************************************************************/ #ifndef ADOBE_COPY_ON_WRITE_HPP #define ADOBE_COPY_ON_WRITE_HPP /**************************************************************************************************/ #include <adobe/config.hpp> #include <algorithm> #include <cassert> #include <cstdlib> #include <boost/noncopyable.hpp> #include <boost/operators.hpp> #include <boost/static_assert.hpp> #include <adobe/counter.hpp> #include <adobe/memory.hpp> #include <adobe/move.hpp> #include <adobe/once.hpp> #include <adobe/typeinfo.hpp> /**************************************************************************************************/ namespace adobe { /**************************************************************************************************/ namespace version_1 { /**************************************************************************************************/ template <typename T, // T models Regular typename A = adobe::capture_allocator<T> > // A models Allocator class copy_on_write { public: typedef T value_type; typedef A allocator_type; #if !defined(ADOBE_NO_DOCUMENTATION) private: struct implementation_t; typedef typename allocator_type::template rebind<implementation_t>::other implementation_allocator_type; public: #endif copy_on_write() { adobe::call_once(init_default, flag_s); object_m = default_s; object_m->header_m.get().count_m.increment(); } explicit copy_on_write(const allocator_type& a) : object_m(0) { implementation_allocator_type other_allocator(a); object_m = allocate(other_allocator); } template <typename U> copy_on_write(U x, typename move_sink<U, T>::type = 0) : object_m(0) { /* NOTE : This should not move to the initializer; in case the allocation or the move should fail (throw) we want to keep the copy_on_write instance in a valid state. */ object_m = allocate_move(0, move(x)); } template <typename U> copy_on_write(const U& x, typename copy_sink<U, T>::type = 0) : object_m(0) { /* NOTE : This should not move to the initializer; in case the allocation or the move should fail (throw) we want to keep the copy_on_write instance in a valid state. */ object_m = allocate(static_cast<implementation_t*>(0), x); } copy_on_write(const copy_on_write& x) : object_m(x.object_m) { if (object_m) object_m->header_m.get().count_m.increment(); } copy_on_write(move_from<copy_on_write> x) : object_m(x.source.object_m) { x.source.object_m = 0; } ~copy_on_write() { release(object_m); } copy_on_write& operator=(copy_on_write x) { swap(*this, x); return *this; } template<typename U> typename move_sink<U, T, copy_on_write&>::type operator=(U x) { if (!object_m) object_m = allocate_move(0, move(x)); else if (object_m->header_m.get().count_m.is_one()) object_m->value_m = move(x); else reset(allocate_move(object_m, move(x))); return *this; } /* Doxygen has a bug where documentation is used only from the last item in the group. */ template<typename U> typename copy_sink<U, T, copy_on_write&>::type operator=(const U& x) { if (!object_m) object_m = allocate(0, x); else if (object_m->header_m.get().count_m.is_one()) object_m->value_m = x; else reset(allocate(object_m, x)); return *this; } value_type& write() { assert(object_m && "FATAL (sparent) : using a moved copy_on_write object"); if (!object_m->header_m.get().count_m.is_one()) reset(allocate(object_m, object_m->value_m)); return object_m->value_m; } const value_type& read() const { assert(object_m && "FATAL (sparent) : using a moved copy_on_write object"); return object_m->value_m; } operator const value_type& () const { return read(); } const value_type& operator*() const { return read(); } const value_type* operator->() const { return &read(); } bool unique_instance() const { return !object_m || object_m->header_m.get().count_m.is_one(); } bool identity(const copy_on_write& x) const { return object_m == x.object_m; } friend inline void swap(copy_on_write& x, copy_on_write& y) { std::swap(x.object_m, y.object_m); } friend inline bool operator<(const copy_on_write& x, const copy_on_write& y) { return y.object_m && (!x.object_m || (!x.identity(y) && *x < *y)); } friend inline bool operator>(const copy_on_write& x, const copy_on_write& y) { return y < x; } friend inline bool operator<=(const copy_on_write& x, const copy_on_write& y) { return !(y < x); } friend inline bool operator>=(const copy_on_write& x, const copy_on_write& y) { return !(x < y); } friend inline bool operator==(const copy_on_write& x, const copy_on_write& y) { return x.identity(y) || (x.object_m && y.object_m && *x == *y); } friend inline bool operator!=(const copy_on_write& x, const copy_on_write& y) { return !(x == y); } allocator_type get_allocator() const { return object_m ? allocator_type(object_m->get_allocator()) : allocator_type(); } private: #if !defined(ADOBE_NO_DOCUMENTATION) static implementation_t* allocate(const implementation_t* alloc_src, const T& x = T()) { implementation_allocator_type allocator(alloc_src ? alloc_src->get_allocator() : implementation_allocator_type()); return allocate(allocator, x); } static implementation_t* allocate(implementation_allocator_type& allocator, const T& x = T()) { implementation_t* tmp(allocator.allocate(1)); try { ::new(static_cast<void*>(tmp)) implementation_t(x); } catch (...) { tmp->get_allocator().deallocate(tmp, 1); throw; } return tmp; } template <typename U> static implementation_t* allocate_move(const implementation_t* alloc_src, U x) { implementation_allocator_type allocator(alloc_src ? alloc_src->get_allocator() : implementation_allocator_type()); implementation_t* tmp(allocator.allocate(1)); try { ::new(static_cast<void*>(tmp)) implementation_t(move_from<U>(x)); } catch (...) { tmp->get_allocator().deallocate(tmp, 1); throw; } return tmp; } static void release(implementation_t* x) { /* I thought about returning a bool from this routine (denoting whether or not a deallocation took place) but decided not to in the end. Release's semantics are that of giving up ownership of the implementation instance, so you are not allowed to subsequently interact with the implementation instance you've released. Thus, notifying the caller of a deallocation is a moot point. */ if (x == 0 || x->header_m.get().count_m.decrement() == false) return; implementation_allocator_type allocator(x->get_allocator()); destroy(x); allocator.deallocate(x, 1); } void reset(implementation_t* to) { release(object_m); object_m = to; } implementation_t* object_m; static once_flag flag_s; static implementation_t* default_s; static void release_default(); static void init_default(); #endif }; /**************************************************************************************************/ #if !defined(ADOBE_NO_DOCUMENTATION) /**************************************************************************************************/ template <typename T, typename A> once_flag copy_on_write<T, A>::flag_s = ADOBE_ONCE_INIT; template <typename T, typename A> typename copy_on_write<T, A>::implementation_t* copy_on_write<T, A>::default_s; template <typename T, typename A> struct copy_on_write<T, A>::implementation_t : private boost::noncopyable { // Assert proper size for counter_t BOOST_STATIC_ASSERT((sizeof(counter_t) == sizeof(std::size_t))); // Assert proper alignment for counter_t BOOST_STATIC_ASSERT((sizeof(counter_t) == sizeof(void*))); struct header_t { counter_t count_m; allocator_type allocator_m; }; template <typename U> explicit implementation_t(const U& x, typename copy_sink<U, T>::type = 0) : value_m(x) { } template <typename U> explicit implementation_t(U x, typename move_sink<U, T>::type = 0) : value_m(move(x)) { } implementation_allocator_type get_allocator() const { return implementation_allocator_type(header_m.get().allocator_m); } aligned_storage<header_t> header_m; value_type value_m; }; template <typename T, typename A> void copy_on_write<T, A>::init_default() { implementation_allocator_type allocator; default_s = allocate(allocator); std::atexit(release_default); // ignore failure } template <typename T, typename A> void copy_on_write<T, A>::release_default() { release(default_s); } #endif /**************************************************************************************************/ } // namespace version_1 /**************************************************************************************************/ using version_1::copy_on_write; /**************************************************************************************************/ template <typename T, typename A> struct is_movable<copy_on_write<T, A> > : boost::mpl::true_ { }; /**************************************************************************************************/ } // namespace adobe /**************************************************************************************************/ ADOBE_NAME_TYPE_1("copy_on_write:version_1:adobe", adobe::version_1::copy_on_write<T0, adobe::capture_allocator<T0> >) ADOBE_NAME_TYPE_2("copy_on_write:version_1:adobe", adobe::version_1::copy_on_write<T0, T1>) /**************************************************************************************************/ #endif /**************************************************************************************************/

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google