---

Object

/*
 * 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_Object__
#define __system_Object__

#ifndef __system_Reference_Type__
#   error   Must include a reference implementation before this file.
#endif

#ifndef __platform_Lock_Type__
#   error   Must include a lock implementation before this file.
#endif

#include <stdnet/system/Abstract>

namespace stdbase {

    namespace system {

class String;

class Object : public Abstract
{
protected:
    Object( void );

    virtual ~Object( void );

public:

    class synchronized
    {
    private:
        friend class Object;

        platform::Lock    * object_lock;
        
        synchronized( platform::Lock & l)
            : object_lock( & l )
        {};

    public:
        synchronized( const synchronized & s)
            : object_lock( s. object_lock )
        { object_lock -> seize(); }

        ~synchronized()
        { object_lock -> release(); }
    };

protected:
    friend class ObjectRef;
    
    mutable unsigned        count;
    mutable platform::Lock  lock;
    
    //  inc() and dec() used internally by ObjectRef.
    virtual void        inc() const;
    virtual unsigned    dec() const;

public:
    synchronized        synchronize()
    { return synchronized( lock ); }

public:
    virtual bool        equals( ObjectRef object );

    virtual system::reference<String>
        toString() const;

    //virtual ClassRef    getClass() = 0;

    /*
    void    wait();
    bool    wait( unsigned delay);
    void    notify();
    void    notifyAll();
    */
};

    } // -- end namespace system --

    //  Bring the synchronized type into the stdbase space
    //  where it can be best used.
    //
typedef stdbase::system::Object::synchronized    synchronized;
} //------- end namespace stdbase --


#endif  // __system_Object__

---