RTObject_class.h

/*
 * Licensed Materials - Property of HCL and/or IBM
 * Copyright HCL Technologies Ltd. 2016, 2021. All Rights Reserved.
 * Copyright IBM Corporation 1999, 2016. All Rights Reserved.
 *
 * U.S. Government Users Restricted Rights -  Use, duplication or 
 * disclosure restricted by GSA ADP Schedule.
 */
 
#ifndef __RTObject_class_h__
#define __RTObject_class_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTFieldOffset_h__
#include <RTFieldOffset.h>
#endif
 
#ifndef __RTVersionId_h__
#include <RTVersionId.h>
#endif
 
struct RTFieldDescriptor;
struct RTObject_class;
 
typedef void * ( * RTSuperAccessFunction )( void * derived );
 
typedef void ( * RTInitFunction    )( const RTObject_class * type,
                      void                 * target );
 
typedef void ( * RTCopyFunction    )( const RTObject_class *,
                      void                 * target,
                      const void           * source );
 
typedef void ( * RTMoveFunction    )( const RTObject_class *,
                      void                  * target,
                      void                  * source );
 
typedef void ( * RTDestroyFunction )( const RTObject_class * type,
                      void                 * target );
 
#if OBJECT_DECODE
    class RTDecoding;
    typedef int ( * RTDecodeFunction )( const RTObject_class * type,
                    void                 * target,
                    RTDecoding           * );
#endif
 
#if OBJECT_ENCODE
    class RTEncoding;
    typedef int ( * RTEncodeFunction )( const RTObject_class * type,
                    const void           * source,
                    RTEncoding           * );
#endif
 
struct RTObject_class
{
    enum DestroyOption
    {
        DestroyOnly,
        DestroyAndDeallocate
    };
 
    // access functions
 
    RTS_INLINE const RTObject_class * super  ( void ) const;
 
    RTS_INLINE const char * name ( void ) const;
 
    RTS_INLINE RTVersionId version( void ) const;
 
    int isKindOf( const RTObject_class * other) const;
 
    void * allocate( void ) const;
 
    RTS_INLINE void init( void * data) const;
 
    RTS_INLINE void copy( void * to, const void * from) const;
 
    RTS_INLINE void move( void * to, void * from) const;
 
#if OBJECT_DECODE
 
    RTS_INLINE int decode( void * data, RTDecoding * decoder) const;
#endif
#if OBJECT_ENCODE
 
    RTS_INLINE int encode( const void * data, RTEncoding * encoder) const;
#endif
 
    void destroy( void * inst, DestroyOption opt) const;
 
    void                              install( bool warnForDuplicates = true ) const;
#if OBJECT_DECODE
 
    static const RTObject_class     * lookup( const char * className );
#endif
 
    template <typename TYPE> static const RTObject_class * fromType();
 
    // implementation
 
    const RTObject_class            * _super;
 
    RTSuperAccessFunction             _super_accessor;
 
    const char                      * _name;
 
    RTVersionId                       _version;
 
    RTFieldOffset                     _size;
 
    // These function pointers must all be non-nil.
 
    RTInitFunction                    _init_func;
 
    RTCopyFunction                    _copy_func;
 
    RTMoveFunction                    _move_func;
 
 
#if OBJECT_DECODE
 
    RTDecodeFunction                  _decode_func;
#endif
#if OBJECT_ENCODE
 
    RTEncodeFunction                  _encode_func;
#endif
 
    RTDestroyFunction                 _destroy_func;
 
    int                               _num_fields;
 
    const RTFieldDescriptor         * _fields;
};
 
// Trivial (no-op) init, copy and destroy functions.
    extern void RTnop_init( const RTObject_class *, void * );
    extern void RTnop_copy( const RTObject_class *, void *, const void * );
    extern void RTnop_move( const RTObject_class *, void *, void * );
    extern void RTnop_destroy( const RTObject_class *, void * );
 
// Functions for instances describing struct or class types
    extern void RTstruct_init( const RTObject_class *, void * );
    extern void RTstruct_copy( const RTObject_class *, void *, const void * );
#if OBJECT_DECODE
    extern int  RTstruct_decode( const RTObject_class * type,
                 void                 * target,
                 RTDecoding           * );
#endif
#if OBJECT_ENCODE
    extern int  RTstruct_encode( const RTObject_class * type,
                 const void           * target,
                 RTEncoding           * );
#endif
    extern void RTstruct_destroy( const RTObject_class *, void * );
 
// Functions for instances describing enum types
#if OBJECT_DECODE
    extern int  RTenum_decode( const RTObject_class * type,
                   void                 * target,
                   RTDecoding           * );
#endif
#if OBJECT_ENCODE
    extern int  RTenum_encode( const RTObject_class * type,
                   const void           * target,
                   RTEncoding           * );
#endif
 
// Functions for instances which can inherit implementations
#if OBJECT_DECODE
    extern int  RTinherit_decode( const RTObject_class * type,
                  void                 * target,
                  RTDecoding           * );
#endif
#if OBJECT_ENCODE
    extern int  RTinherit_encode( const RTObject_class * type,
                  const void           * target,
                  RTEncoding           * );
#endif
 
// Functions for instances of RTObject_class describing arrays.
    extern void RTarray_init( const RTObject_class *, void * );
    extern void RTarray_copy( const RTObject_class *, void *, const void * );
#if OBJECT_DECODE
    extern int  RTarray_decode( const RTObject_class * type,
                void                 * target,
                RTDecoding           * );
#endif
#if OBJECT_ENCODE
    extern int  RTarray_encode( const RTObject_class * type,
                const void           * target,
                RTEncoding           * );
#endif
    extern void RTarray_destroy( const RTObject_class *, void * );
 
// Init and copy functions for abstract classes: these simply panic.
    extern void RTabstract_init( const RTObject_class *, void * );
    extern void RTabstract_copy( const RTObject_class *, void *, const void * );
    extern void RTabstract_move( const RTObject_class *, void *, void * );
 
// Reusable basic type descriptors. The convention is that for a type called T,
// one may refer to its type descriptor using the name RTType_T.
// In some cases the name RTType_T will refer to a macro.
 
    extern const RTObject_class RTType_void;
    extern const RTObject_class RTType_bool;
    extern const RTObject_class RTType_char;
#if RTUseFloatingPoint
    extern const RTObject_class RTType_double;
    extern const RTObject_class RTType_float;
#endif
    extern const RTObject_class RTType_int;
    extern const RTObject_class RTType_long;
    extern const RTObject_class RTType_longlong;
    extern const RTObject_class RTType_short;
    extern const RTObject_class RTType_unsigned;
 
    extern const RTObject_class RTType_unsignedint;
    extern const RTObject_class RTType_unsignedlong;
    extern const RTObject_class RTType_unsignedlonglong;
    extern const RTObject_class RTType_unsignedshort;
    extern const RTObject_class RTType_unsignedchar;
    typedef char           * RTpchar;
    typedef void           * RTpvoid;
    typedef unsigned char    RTuchar;
    typedef unsigned long    RTulong;
    typedef unsigned short   RTushort;
 
    extern const RTObject_class RTType_RTpchar;
    extern const RTObject_class RTType_RTpvoid;
    extern const RTObject_class RTType_RTuchar;
    extern const RTObject_class RTType_RTulong;
    extern const RTObject_class RTType_RTushort;
 
    // Template specializations for mapping built-in types to type descriptors
    template <> inline const RTObject_class* RTObject_class::fromType<int>() { return &RTType_int; }
    template <> inline const RTObject_class* RTObject_class::fromType<char>() { return &RTType_char; }
    template <> inline const RTObject_class* RTObject_class::fromType<float>() { return &RTType_float; }
    template <> inline const RTObject_class* RTObject_class::fromType<bool>() { return &RTType_bool; }
    template <> inline const RTObject_class* RTObject_class::fromType<double>() { return &RTType_double; }
    template <> inline const RTObject_class* RTObject_class::fromType<short>() { return &RTType_short; }
    template <> inline const RTObject_class* RTObject_class::fromType<long>() { return &RTType_long; }
    template <> inline const RTObject_class* RTObject_class::fromType<long long>() { return &RTType_longlong; }
    template <> inline const RTObject_class* RTObject_class::fromType<unsigned int>() { return &RTType_unsignedint; } // Same as RTType_unsigned
    template <> inline const RTObject_class* RTObject_class::fromType<unsigned char>() { return &RTType_unsignedchar; } // Same as RTType_RTuchar
    template <> inline const RTObject_class* RTObject_class::fromType<unsigned long>() { return &RTType_unsignedlong; } // Same as RTType_RTulong
    template <> inline const RTObject_class* RTObject_class::fromType<unsigned long long>() { return &RTType_unsignedlonglong; }
    template <> inline const RTObject_class* RTObject_class::fromType<unsigned short>() { return &RTType_unsignedshort; } // Same as RTType_RTushort
    template <> inline const RTObject_class* RTObject_class::fromType<char*>() { return &RTType_RTpchar; }
 
 
#if OBJECT_DECODE
class RTTypeInstaller
{
public:
    explicit    RTTypeInstaller( const RTObject_class & );
 
    static void installAll( void );
 
private:
    static RTTypeInstaller * _head;
    RTTypeInstaller        * _next;
    const RTObject_class   * _type;
 
    // unavailable methods
    RTTypeInstaller( const RTTypeInstaller & );
    RTTypeInstaller & operator=( const RTTypeInstaller & );
}; //lint !e1712
#endif // OBJECT_DECODE
 
#if RTS_INLINES
#include <RTObject_class.inl>
#endif
 
#endif // __RTObject_class_h__