#pragma once

#include <assert.h>
#include <vector>
#include <string>

//-------------------------------------------------------------------------

template<class T>
class sco_reference;

template<class T>
class sco_object;


//-------------------------------------------------------------------------

template<class T>
class sco_reference
{
    friend sco_object<T>;

    sco_object<T>* m_to;

    void remove_from_object();

public:

     sco_reference() : m_to(NULL) {}

     sco_reference(const sco_reference<T>& a) 
     {
         *this = a;
     }

     sco_reference(sco_object<T>* ob) : m_to(NULL) 
     {
         assign_reference(ob);
     }

     ~sco_reference() 
     {
         remove_from_object();
     }


    
    bool has_object() const
    {
        return m_to != NULL;
    }

    sco_object<T>* operator -> ();

    sco_reference& operator = (const sco_reference& a)
    {
        assign_reference(a.m_to);
        return *this;
    }

    void assign_reference(sco_object<T>* ob);
    void assign_reference(sco_object<T>& ob);

};

//-------------------------------------------------------------------------

template<class T>
class sco_object 
{
    friend sco_reference<T>;

    std::vector< sco_reference<T>* > m_references;

public:

    sco_object() 
    {

    }

    ~sco_object() 
    {
        for( std::vector<sco_reference<T>*>::iterator it=m_references.begin(); it != m_references.end(); ++it )
        {
            sco_reference<T>* pr = *it;
            pr->m_to = NULL; 
        }
    }


};