SharedPtr.h

/* mbed Microcontroller Library
 * Copyright (c) 2006-2018 ARM Limited
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed 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
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __SHAREDPTR_H__
#define __SHAREDPTR_H__
 
#include <stdlib.h>
 
#include <stdint.h>
#include <stddef.h>
 
#include "platform/mbed_atomic.h"
 
namespace mbed {
 
/** Shared pointer class.
  *
  * A shared pointer is a "smart" pointer that retains ownership of an object using
  * reference counting across all smart pointers referencing that object.
  *
  * @code
  * #include "platform/SharedPtr.h"
  *
  * void test() {
  *     struct MyStruct { int a; };
  *
  *     // Create shared pointer
  *     SharedPtr<MyStruct> ptr( new MyStruct );
  *
  *     // Increase reference count
  *     SharedPtr<MyStruct> ptr2( ptr );
  *
  *     ptr = nullptr; // Reference to the struct instance is still held by ptr2
  *
  *     ptr2 = nullptr; // The raw pointer is freed
  * }
  * @endcode
  *
  *
  * It is similar to the std::shared_ptr class introduced in C++11;
  * however, this is not a compatible implementation (no weak pointer, no make_shared, no custom deleters and so on.)
  *
  * Usage: SharedPtr<Class> ptr(new Class())
  *
  * When ptr is passed around by value, the copy constructor and
  * destructor manages the reference count of the raw pointer.
  * If the counter reaches zero, delete is called on the raw pointer.
  *
  * To avoid loops, use "weak" references by calling the original
  * pointer directly through ptr.get().
  */
 
template <class T>
class SharedPtr {
public:
    /**
     * @brief Create empty SharedPtr not pointing to anything.
     * @details Used for variable declaration.
     */
    constexpr SharedPtr(): _ptr(), _counter()
    {
    }
 
    /**
     * @brief Create empty SharedPtr not pointing to anything.
     */
    constexpr SharedPtr(std::nullptr_t) : SharedPtr()
    {
    }
 
    /**
     * @brief Create new SharedPtr
     * @param ptr Pointer to take control over
     */
    SharedPtr(T *ptr): _ptr(ptr), _counter()
    {
        // Allocate counter on the heap, so it can be shared
        if (_ptr != nullptr) {
            _counter = new uint32_t(1);
        }
    }
 
    /**
     * @brief Destructor.
     * @details Decrement reference counter, and delete object if no longer pointed to.
     */
    ~SharedPtr()
    {
        decrement_counter();
    }
 
    /**
     * @brief Copy constructor.
     * @details Create new SharedPtr from other SharedPtr by
     *          copying pointer to original object and pointer to counter.
     * @param source Object being copied from.
     */
    SharedPtr(const SharedPtr &source): _ptr(source._ptr), _counter(source._counter)
    {
        // Increment reference counter
        if (_ptr != nullptr) {
            core_util_atomic_incr_u32(_counter, 1);
        }
    }
 
    /**
     * @brief Move constructor.
     * @details Create new SharedPtr from other SharedPtr by
     *          moving pointer to original object and pointer to counter.
     * @param source Object being copied from.
     */
    SharedPtr(SharedPtr &&source): _ptr(source._ptr), _counter(source._counter)
    {
        source._ptr = nullptr;
        source._counter = nullptr;
    }
 
    /**
     * @brief Copy assignment operator.
     * @details Cleanup previous reference and assign new pointer and counter.
     * @param source Object being assigned from.
     * @return Object being assigned.
     */
    SharedPtr operator=(const SharedPtr &source)
    {
        if (this != &source) {
            // Clean up by decrementing counter
            decrement_counter();
 
            // Assign new values
            _ptr = source.get();
            _counter = source.get_counter();
 
            // Increment new counter
            if (_ptr != nullptr) {
                core_util_atomic_incr_u32(_counter, 1);
            }
        }
 
        return *this;
    }
 
    /**
     * @brief Move assignment operator.
     * @details Cleanup previous reference and assign new pointer and counter.
     * @param source Object being assigned from.
     * @return Object being assigned.
     */
    SharedPtr operator=(SharedPtr &&source)
    {
        if (this != &source) {
            // Clean up by decrementing counter
            decrement_counter();
 
            // Assign new values
            _ptr = source._ptr;
            _counter = source._counter;
 
            source._ptr = nullptr;
            source._counter = nullptr;
        }
 
        return *this;
    }
 
    /**
     * @brief Replaces the managed pointer with a new unmanaged pointer.
     * @param[in] ptr the new raw pointer to manage.
     */
    void reset(T *ptr)
    {
        // Clean up by decrementing counter
        decrement_counter();
 
        _ptr = ptr;
        if (ptr != nullptr) {
            // Allocate counter on the heap, so it can be shared
            _counter = new uint32_t(1);
        } else {
            _counter = nullptr;
        }
    }
 
    /**
     * @brief Replace the managed pointer with a null pointer.
     */
    void reset()
    {
        // Clean up by decrementing counter
        decrement_counter();
 
        _ptr = nullptr;
        _counter = nullptr;
    }
 
    /**
     * @brief Raw pointer accessor.
     * @details Get raw pointer to object pointed to.
     * @return Pointer.
     */
    T *get() const
    {
        return _ptr;
    }
 
    /**
     * @brief Reference count accessor.
     * @return Reference count.
     */
    uint32_t use_count() const
    {
        if (_ptr != nullptr) {
            return core_util_atomic_load_u32(_counter);
        } else {
            return 0;
        }
    }
 
    /**
     * @brief Dereference object operator.
     * @details Override to return the object pointed to.
     */
    T &operator*() const
    {
        return *_ptr;
    }
 
    /**
     * @brief Dereference object member operator.
     * @details Override to return return member in object pointed to.
     */
    T *operator->() const
    {
        return _ptr;
    }
 
    /**
     * @brief Boolean conversion operator.
     * @return Whether or not the pointer is null.
     */
    operator bool() const
    {
        return _ptr != nullptr;
    }
 
private:
    /**
     * @brief Get pointer to reference counter.
     * @return Pointer to reference counter.
     */
    uint32_t *get_counter() const
    {
        return _counter;
    }
 
    /**
     * @brief Decrement reference counter.
     * @details If count reaches zero, free counter and delete object pointed to.
     * Does not modify our own pointers - assumption is they will be overwritten
     * or destroyed immediately afterwards.
     */
    void decrement_counter()
    {
        if (_ptr != nullptr) {
            if (core_util_atomic_decr_u32(_counter, 1) == 0) {
                delete _counter;
                delete _ptr;
            }
        }
    }
 
private:
    // Pointer to shared object
    T *_ptr;
 
    // Pointer to shared reference counter
    uint32_t *_counter;
};
 
/** Non-member relational operators.
  */
template <class T, class U>
bool operator== (const SharedPtr<T> &lhs, const SharedPtr<U> &rhs)
{
    return (lhs.get() == rhs.get());
}
 
template <class T, typename U>
bool operator== (const SharedPtr<T> &lhs, U rhs)
{
    return (lhs.get() == (T *) rhs);
}
 
template <class T, typename U>
bool operator== (U lhs, const SharedPtr<T> &rhs)
{
    return ((T *) lhs == rhs.get());
}
 
/** Non-member relational operators.
  */
template <class T, class U>
bool operator!= (const SharedPtr<T> &lhs, const SharedPtr<U> &rhs)
{
    return (lhs.get() != rhs.get());
}
 
template <class T, typename U>
bool operator!= (const SharedPtr<T> &lhs, U rhs)
{
    return (lhs.get() != (T *) rhs);
}
 
template <class T, typename U>
bool operator!= (U lhs, const SharedPtr<T> &rhs)
{
    return ((T *) lhs != rhs.get());
}
 
} /* namespace mbed */
 
#ifndef MBED_NO_GLOBAL_USING_DIRECTIVE
using mbed::SharedPtr;
#endif
 
#endif // __SHAREDPTR_H__