Object.h

#pragma once


UTL_NS_BEGIN;


class Stream;
class String;



class Object
{
    UTL_CLASS_DECL_ABC(Object, Object);
    UTL_CLASS_DEFID;

public:
    void clear();

    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void vclone(const Object& rhs);

    virtual void steal(Object& rhs);

    virtual void dump(Stream& os, uint_t level = uint_t_max) const;

    void dumpWithClassName(Stream& os, uint_t indent = 4, uint_t level = uint_t_max) const;

    virtual const Object& getKey() const;

    bool
    hasKey() const
    {
        return (&(getKey()) != this);
    }

    virtual const Object& getProxiedObject() const;

    virtual Object& getProxiedObject();

    virtual size_t hash(size_t size) const;

    bool
    _isA(const RunTimeClass* runTimeClass) const
    {
        return getClass()->_isA(runTimeClass);
    }



    void
    serializeIn(Stream& is, uint_t mode = ser_default)
    {
        serialize(is, io_rd, mode);
    }

    void
    serializeOut(Stream& os, uint_t mode = ser_default) const
    {
        const_cast_this->serialize(os, io_wr, mode);
    }

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    static Object* serializeInNullable(Stream& is, uint_t mode = ser_default);

    static void serializeOutNullable(const Object* object, Stream& os, uint_t mode = ser_default);

    static void
    serializeNullable(Object*& object, Stream& stream, uint_t io, uint_t mode = ser_default);

    static Object* serializeInBoxed(Stream& is, uint_t mode = ser_default);

    void serializeOutBoxed(Stream& os, uint_t mode = ser_default) const;

    static void
    serializeBoxed(Object*& object, Stream& stream, uint_t io, uint_t mode = ser_default)
    {
        if (io == io_rd)
            object = serializeInBoxed(stream, mode);
        else
            object->serializeOutBoxed(stream, mode);
    }

    virtual String toString() const;

    operator String() const;

    size_t allocatedSize() const;

    virtual size_t innerAllocatedSize() const;



    bool operator<(const Object& rhs) const
    {
        return (compare(rhs) < 0);
    }
    bool operator<=(const Object& rhs) const
    {
        return (compare(rhs) <= 0);
    }
    bool operator>(const Object& rhs) const
    {
        return (compare(rhs) > 0);
    }
    bool operator>=(const Object& rhs) const
    {
        return (compare(rhs) >= 0);
    }
    bool operator==(const Object& rhs) const
    {
        return (compare(rhs) == 0);
    }
    bool operator!=(const Object& rhs) const
    {
        return (compare(rhs) != 0);
    }

#ifdef DEBUG

    virtual void addOwnedIt(const class FwdIt* it) const;

    virtual void removeOwnedIt(const class FwdIt* it) const;
#endif
};


UTL_NS_END;