untypedSharedPtr.h

 
#ifndef UNTYPED_SHARED_PTR_H
#define UNTYPED_SHARED_PTR_H
 
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
 
namespace Data {
 
    class UntypedSharedPtr
    {
      public:
        struct Concept
        {
            virtual ~Concept() = default;
            virtual const std::type_info& getType() const = 0;
            virtual const std::type_info& getPtrType() const = 0;
        };
 
        template <typename T> struct Model : Concept
        {
            using ELEM_TYPE = typename std::remove_all_extents<T>::type;
 
          public:
            template <typename Deleter>
            Model(T* t, Deleter func) : sharedPtr(t, func)
            {
            }
 
            template <typename U, typename _ = typename std::enable_if<
                                      std::is_array<T>::value, U>::type>
            Model(U* p) : sharedPtr(p, std::default_delete<T>()){};
 
            const std::type_info& getType() const override
            {
                return typeid(T);
            }
 
            const std::type_info& getPtrType() const override
            {
                return typeid(sharedPtr.get());
            }
 
            std::shared_ptr<ELEM_TYPE> sharedPtr;
        };
 
        UntypedSharedPtr() = delete;
 
        template <typename T, class Deleter = std::default_delete<T>>
        UntypedSharedPtr(T* obj, Deleter func = Deleter())
            : sharedPtrContainer(std::make_shared<Model<T>>(obj, func)){};
 
        UntypedSharedPtr(std::shared_ptr<Concept> concept)
            : sharedPtrContainer(concept){};
 
        const std::type_info& getType() const
        {
            return sharedPtrContainer->getType();
        }
 
        const std::type_info& getPtrType() const
        {
            return sharedPtrContainer->getPtrType();
        }
 
        template <typename T>
        std::shared_ptr<std::remove_all_extents_t<T>> getSharedPointer() const
        {
            const auto& templateType = typeid(T);
            const auto& templateTypeNoConst = typeid(std::remove_const_t<T>);
            const auto& ownType = this->getType();
            const auto& templatePtrType = typeid(T*);
            const auto& templatePtrTypeNoConst =
                typeid(std::remove_const_t<T>*);
            const auto& ownPtrType = this->getPtrType();
 
            // If pointer types are identical (which includes const qualifier),
            // go for it. Unless non-pointers types are different, which may be
            // the case for arrays
            if (ownPtrType == templatePtrType && templateType == ownType) {
                std::shared_ptr<const Model<T>> typedPtr =
                    std::dynamic_pointer_cast<const Model<T>>(
                        this->sharedPtrContainer);
                if (typedPtr != NULL) {
                    return typedPtr->sharedPtr;
                }
            }
 
            // If pointer types are identical when loosing const qualifier of
            // function template type, go for it. Unless non-pointers types are
            // different, which may be the case for arrays
            if (ownPtrType == templatePtrTypeNoConst &&
                templateType == ownType) {
                std::shared_ptr<const Model<std::remove_const_t<T>>> typedPtr =
                    std::dynamic_pointer_cast<
                        const Model<std::remove_const_t<T>>>(
                        this->sharedPtrContainer);
                if (typedPtr != NULL) {
                    return typedPtr->sharedPtr;
                }
            }
 
            // If template type and owntype are the same, go for it.
            // (it is not the first tested case because constness is lost in
            // template type and own type.
            if (templateType == ownType) {
                std::shared_ptr<const Model<T>> typedPtr =
                    std::dynamic_pointer_cast<const Model<T>>(
                        this->sharedPtrContainer);
                if (typedPtr != NULL) {
                    return typedPtr->sharedPtr;
                }
            }
 
            // If template type and owntype are identical when loosing const
            // qualifier of function template type, go for it. (it is not the
            // first tested case because constness is lost in template type and
            // own type.
            if (templateTypeNoConst == ownType) {
                std::shared_ptr<const Model<std::remove_const_t<T>>> typedPtr =
                    std::dynamic_pointer_cast<
                        const Model<std::remove_const_t<T>>>(
                        this->sharedPtrContainer);
                if (typedPtr != NULL) {
                    return typedPtr->sharedPtr;
                }
            }
 
            // Type mismatch
            std::string msg("Cannot convert ");
            msg.append(ownPtrType.name());
            msg.append(" into ");
            msg.append(templatePtrType.name());
            msg.append(".");
 
            throw std::runtime_error(msg);
        }
 
        template <typename T> static std::function<void(T*)> emptyDestructor()
        {
            return [](T* ptr) {};
        };
 
        std::shared_ptr<const Concept> sharedPtrContainer;
    };
} // namespace Data
#endif // !UNTYPED_SHARED_PTR_H