//Purpose:
//  See how easy it is to create a dangling pointer problem.
//
#include "obj_id.cpp"

#include <memory>
#include <rich_typed_ptr.hpp>
namespace rtp = rich_typed_ptr;

enum sp_enum
{ sp_std //smart pointers from std::
, sp_rtp //smart pointers from rtp::
};

template
< sp_enum
>
struct test_adapt
;
template
<
>
struct test_adapt
< sp_std
>
{
    template<typename T>
    using ow_ptr = std::shared_ptr<T>;
    
    template<typename T>
    using wk_ptr = std::weak_ptr<T>;
    
    static obj_id* make_obj()
    { return new obj_id;}
    
    template<typename T>
    static bool empty(wk_ptr<T>const& wp)
    { return wp.expired();}
    
    template<typename T>
    static T& deref(wk_ptr<T>const& wp)
    { auto op=wp.lock();
      return *op;
    }
    
};

template
<
>
struct test_adapt
< sp_rtp
>
{
    template<typename T>
    using ow_ptr = rtp::owner_ptr<T>;
    
    template<typename T>
    using wk_ptr = rtp::weak_ptr<T>;
    
    static ow_ptr<obj_id> make_obj()
    { return rtp::make<obj_id>();}
    
    template<typename T>
    static bool empty(wk_ptr<T>const& wp)
    { return wp==nullptr;}

    template<typename T>
    static T& deref(wk_ptr<T>const& wp)
    { return *wp;}
    
};

template
< sp_enum Sp=sp_std
>
struct test_run
: test_adapt<Sp>
{
    using super_t = test_adapt<Sp>;
    using super_t::make_obj;
    using super_t::empty;
    using super_t::deref;
    template<typename T>
    using ow_ptr = typename super_t::template ow_ptr<T>;
    template<typename T>
    using wk_ptr = typename super_t::template wk_ptr<T>;
    
    static void run()
    {
        std::cout<<"***test_run<"<<Sp<<">::run()\n";
        {
            ow_ptr<obj_id> outer_op(make_obj());
            wk_ptr<obj_id> wp(outer_op);
            {
                ow_ptr<obj_id> inner_op(make_obj());
                wp=inner_op;
                std::cout<<"inner empty(wp)="<<empty(wp)<<"\n";
                std::cout<<"inner deref(wp).my_id="<<deref(wp).my_id<<"\n";
            }
            std::cout<<"exited inner\n";
            std::cout<<"outer empty(wp)="<<empty(wp)<<"\n";
            std::cout<<"outer deref(wp).my_id="<<deref(wp).my_id<<"\n";
        }
        std::cout<<"exited outer\n";
    }
};

int main()
{
    test_run<sp_rtp>::run();
    test_run<sp_std>::run();
    return 0;
}