---

RefCount

/*
 * NOTE: "zlib/libpng" style License
 *
 *                 ----=== s t d n e t ===----
 *
 * Copyright (c) 2002 Warwick Molloy   w-molloy@users.sf.net
 *
 * Copyright (c) 2002 Stdnet Community
 * HTTP://Sourceforge.net/projects/stdnet
 *
 * All references to "software" refer to the stdnet.
 *
 * This software is provided 'as-is', without any express or
 * implied warranty. In no event will the authors be held liable
 * for any damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it
 * and redistribute it freely, subject to the following
 * restrictions:
 *
 * 1.  The origin of this software must not be misrepresented;
 *     you must not claim that you wrote the original software.
 *     If you use this software in a product, an acknowledgment
 *     in the product documentation would be appreciated but
 *     is not required.
 *
 * 2.  Altered source versions must be plainly marked as such,
 *     and must not be misrepresented as being the original
 *     software.
 *
 * 3.  This notice may not be removed or altered from any source
 *     distribution.
 */

#ifndef __system_RefCount__
#define __system_RefCount__

#include <stdnet/system/Abstract>

namespace stdbase {
    namespace system {

//  Let the world know that a reference type has been
//  defined.
//
#define     __system_Reference_Type__


class Object;

class ObjectRef
{
private:
    mutable Abstract * pointer;
    
public:
    ObjectRef( Object * obj);

    ObjectRef( Abstract * obj);

    ObjectRef( const ObjectRef & r);

    ~ObjectRef( void );
    
    const ObjectRef &
        operator =( const ObjectRef & r) const;

    bool
        operator == ( const ObjectRef & r) const;

    bool
        operator != ( const ObjectRef & r) const;

    Object * get();

    const Object *  get() const;
};

template < class derived_object >
class reference
{
public:
    typedef derived_object  object_class;

private:
    mutable ObjectRef       ref;
    
public:
    reference( object_class * p)
        : ref( dynamic_cast<Object *>(p) )
    {};

    reference( Object * p)
        : ref( p )
    {};

    reference( const reference<object_class> & r)
        : ref( r.get() )
    {};

    reference( const ObjectRef & o)
        : ref( o )
    {};

    ~reference()
    {};

    const reference<object_class> &
        operator = ( const reference<object_class> & r)
    {
        ref = r.ref;
        return *this;
    }

    object_class *
        operator -> ()
    {   return dynamic_cast<object_class*>( ref.get() ); }

    const object_class *
        operator -> () const
    {   return dynamic_cast<const object_class *>( ref.get() ); }

    bool
        operator ==( const reference & r) const
    {   return ref == r.ref; }

    bool
        operator ==( const ObjectRef & object_ref) const
    {   return ref == object_ref; }

    bool
        operator !=( const reference & r) const
    {   return ref != r.ref; }

    bool
        operator !=( const ObjectRef & object_ref) const
    {   return ref != object_ref; }

    const ObjectRef &
        get() const
    { return ref; }
};

    } // -- namespace system --
} // ------ namespace stdbase --

//  ----- Global Operators ------
//  

template <class obj_dst, class ref_src>
stdbase::system::reference< obj_dst>
    ref_cast(
        const ref_src & original
    )
{
    return stdbase::system::
            reference< obj_dst>( original.get() );
}

extern const stdbase::system::ObjectRef null;

#endif  //  __system_RefCount__

---