// Copyright (c) 2013, Kenton Varda <temporal@gmail.com> // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, this // list of conditions and the following disclaimer. // 2. Redistributions in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR // ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "memory.h" #ifndef KJ_REFCOUNT_H_ #define KJ_REFCOUNT_H_ namespace kj { class Refcounted: private Disposer { // Subclass this to create a class that contains an atomic reference count. Then, use // `kj::refcounted<T>()` to allocate a new refcounted pointer. // // Do NOT use this lightly. Refcounting is a crutch. Good designs should strive to make object // ownership clear, so that refcounting is not necessary. All that said, reference counting can // sometimes simplify code that would otherwise become convoluted with explicit ownership, even // when ownership relationships are clear at an abstract level. // // NOT THREADSAFE: This refcounting implementation assumes that an object's references are // manipulated only in one thread, because atomic (thread-safe) refcounting is surprisingly slow. // // In general, abstract classes should _not_ subclass this. The concrete class at the bottom // of the heirarchy should be the one to decide how it implements refcounting. Interfaces should // expose only an `addRef()` method that returns `Own<InterfaceType>`. There are two reasons for // this rule: // 1. Interfaces would need to virtually inherit Refcounted, otherwise two refcounted interfaces // could not be inherited by the same subclass. Virtual inheritance is awkward and // inefficient. // 2. An implementation may decide that it would rather return a copy than a refcount, or use // some other strategy. // // TODO(cleanup): Rethink above. Virtual inheritance is not necessarily that bad. OTOH, a // virtual function call for every refcount is sad in its own way. A Ref<T> type to replace // Own<T> could also be nice. public: virtual ~Refcounted() noexcept(false); private: mutable uint refcount = 0; // "mutable" because disposeImpl() is const. Bleh. void disposeImpl(void* pointer) const override; template <typename T> static Own<T> addRefInternal(T* object); template <typename T> friend Own<T> addRef(T& object); template <typename T, typename... Params> friend Own<T> refcounted(Params&&... params); }; template <typename T, typename... Params> inline Own<T> refcounted(Params&&... params) { // Allocate a new refcounted instance of T, passing `params` to its constructor. Returns an // initial reference to the object. More references can be created with `kj::addRef()`. return Refcounted::addRefInternal(new T(kj::fwd<Params>(params)...)); } template <typename T> Own<T> addRef(T& object) { // Return a new reference to `object`, which must subclass Refcounted and have been allocated // using `kj::refcounted<>()`. It is suggested that subclasses implement a non-static addRef() // method which wraps this and returns the appropriate type. KJ_IREQUIRE(object.Refcounted::refcount > 0, "Object not allocated with kj::refcounted()."); return Refcounted::addRefInternal(&object); } template <typename T> Own<T> Refcounted::addRefInternal(T* object) { Refcounted* refcounted = object; ++refcounted->refcount; return Own<T>(object, *refcounted); } } // namespace kj #endif // KJ_REFCOUNT_H_