sharedPtr.h

Go to the documentation of this file.

/*
 * i6engine
 * Copyright (2016) Daniel Bonrath, Michael Baer, All rights reserved.
 *
 * This file is part of i6engine; i6engine is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __I6ENGINE_UTILS_SHAREDPTR_H__
#define __I6ENGINE_UTILS_SHAREDPTR_H__

#include <atomic>
#include <list>
#include <memory>
#include <mutex>
#include <new>

namespace i6e {
namespace utils {

        template<typename T>
        struct sharedPtrWrapper {
                T * ptr;

                sharedPtrWrapper(T * p) : ptr(p) {
                }
                ~sharedPtrWrapper();
        };

        template<typename T, typename U>
        class sharedPtr;

        template<typename T, typename Base>
        class weakPtr;

        template<typename T1, typename T2, typename U>
        sharedPtr<T1, U> dynamic_pointer_cast(const sharedPtr<T2, U> &);

        template<typename T, typename U, typename... Args>
        sharedPtr<T, U> make_shared(Args && ...);

        template<typename T, typename U>
        class sharedPtr {
                template<typename T1, typename T2, typename U1>
                friend sharedPtr<T1, U1> dynamic_pointer_cast(const sharedPtr<T2, U1> &);
                template<typename T1, typename U2, typename... Args>
                friend sharedPtr<T1, U2> make_shared(Args && ...);
                friend class weakPtr<T, U>;
                template<typename V, typename W>
                friend class sharedPtr;
                template<typename V, typename W>
                friend class weakPtr;
                friend struct sharedPtrWrapper<T>;

        public:
                sharedPtr() : _sharedPtrWrapper(nullptr), _ptr(nullptr) {
                }

                explicit sharedPtr(T * ptr) : _sharedPtrWrapper(nullptr), _ptr(ptr) {
                        _sharedPtrWrapper = std::make_shared<sharedPtrWrapper<U>>(ptr);
                }

                sharedPtr(const sharedPtr & other) : _sharedPtrWrapper(other._sharedPtrWrapper), _ptr(other._ptr) {
                }

                sharedPtr(sharedPtr && other) : _sharedPtrWrapper(other._sharedPtrWrapper), _ptr(other._ptr) {
                        other._sharedPtrWrapper = nullptr;
                        other._ptr = nullptr;
                }

                template<typename V>
                sharedPtr(const sharedPtr<V, U> & other) : _sharedPtrWrapper(other._sharedPtrWrapper), _ptr(other._ptr) {
                }

                ~sharedPtr() {
                }

                const sharedPtr & operator=(const sharedPtr & other) {
                        if (*this == other) {
                                return *this;
                        }
                        _sharedPtrWrapper = other._sharedPtrWrapper;
                        _ptr = other._ptr;

                        return *this;
                }

                const sharedPtr & operator=(sharedPtr && other) {
                        if (*this == other) {
                                return *this;
                        }
                        _sharedPtrWrapper = other._sharedPtrWrapper;
                        _ptr = other._ptr;
                        other._sharedPtrWrapper = nullptr;
                        other._ptr = nullptr;

                        return *this;
                }

                template<typename V>
                const sharedPtr & operator=(const sharedPtr<V, U> & other) {
                        if (*this == other) {
                                return *this;
                        }
                        _sharedPtrWrapper = other._sharedPtrWrapper;
                        _ptr = other._ptr;

                        return *this;
                }

                T * operator->() const {
                        return _ptr;
                }

                bool operator==(const sharedPtr & other) const {
                        return _ptr == other._ptr;
                }

                bool operator==(const T * other) const {
                        return _ptr == other;
                }

                friend bool operator==(const T * other, const sharedPtr & self) {
                        return self == other;
                }

                bool operator!=(const sharedPtr & other) const {
                        return !(*this == other);
                }

                friend bool operator!=(const T * other, const sharedPtr & self) {
                        return self != other;
                }

                bool operator!=(const T * other) const {
                        return !(*this == other);
                }

                static void clear() {
                        std::lock_guard<std::mutex> lg(sharedPtr<U, U>::clearListLock);
                        for (U * ptr : sharedPtr<U, U>::clearList) {
                                delete ptr;
                        }
                        sharedPtr<U, U>::clearList.clear();
                }

                T * get() const {
                        return _ptr;
                }

        private:
                std::shared_ptr<sharedPtrWrapper<U>> _sharedPtrWrapper;
                T * _ptr;

                sharedPtr(T * ptr, std::shared_ptr<sharedPtrWrapper<U>> sC) : _sharedPtrWrapper(sC), _ptr(ptr) {
                }

                static std::mutex clearListLock;
                static std::list<U *> clearList;
        };

        template<typename T, typename U> std::mutex sharedPtr<T, U>::clearListLock;
        template<typename T, typename U> std::list<U *> sharedPtr<T, U>::clearList;

        template<typename T>
        sharedPtrWrapper<T>::~sharedPtrWrapper() {
                std::lock_guard<std::mutex> lg(sharedPtr<T, T>::clearListLock);
                sharedPtr<T, T>::clearList.push_back(reinterpret_cast<T *>(ptr));
        }

        template<typename T1, typename T2, typename U>
        sharedPtr<T1, U> dynamic_pointer_cast(const sharedPtr<T2, U> & base) {
                T1 * t1 = dynamic_cast<T1 *>(base._ptr);
                if (t1 != nullptr) {
                        return sharedPtr<T1, U>(t1, base._sharedPtrWrapper);
                } else {
                        return sharedPtr<T1, U>();
                }
        }

        template<typename T, typename U, typename... Args>
        sharedPtr<T, U> make_shared(Args && ... args) {
                /*char * memory = static_cast<char *>(::operator new(sizeof(T) + sizeof(sharedPtrWrapper)));
                T * ptr = new(memory) T(args...);
                sharedPtrWrapper * sC = new(memory + sizeof(T)) sharedPtrWrapper();*/
                T * ptr = new T(args...);
                std::shared_ptr<sharedPtrWrapper<U>> sC = std::make_shared<sharedPtrWrapper<U>>(ptr);
                return sharedPtr<T, U>(ptr, sC);
        }

        template<class T, class U> T * get_pointer(const sharedPtr<T, U> & p) {
                return p.get();
        }

} /* namespace utils */
} /* namespace i6e */

#endif /* __I6ENGINE_UTILS_SHAREDPTR_H__ */