Search  

---

C:/temp/src/j2k/Fred/Serialize.hpp

Go to the documentation of this file.

#ifndef __J2K__Serialize_HPP__
#define __J2K__Serialize_HPP__

////////////////////////////////////////////////////////////////////////////
/// Serialize Macro Part Version 2.0  ( Contain Class Info )             ///
////////////////////////////////////////////////////////////////////////////
// ULONG is used to have a large possibility range
// You could add more if you wish and get the proper OFFSET for them.
// They must be PUBLIC members and with the Offset technique
// it works fine with virtual functions and single/multi/diamond inheritance
// Just make sure that you don't get out of User Memory space by reading
// TOO FAR in memory, that's why the offset is set close to 0.
// It's normally equal to 4 bytes.

    typedef  unsigned long   serial_t;
    typedef  unsigned long   hashCode_t;

    class JObject;
    class JString;

////////////////////////////////////////////////////////////////////////////
// Make sure this is the first thing in your class.
// The last line must be private,
// since normally a class default is private,
// if not mentionned.

#define MC_SerializeHeader()                          \
    public:                                           \
      serial_t  SerializationID;                      \
      char*     ClassName;                            \
      char*     ClassAuthor;                          \
      char*     ClassVersion;                         \
      char*     ClassInherited;                       \
    private:                                          


#define MC_printSerialInfo( CLASS )                   \
   if ( CLASS ## ClassName       != NULL )            \
     printf("The class %s",   CLASS ## ClassName   ); \
   if ( CLASS ## ClassAuthor     != NULL )            \
     printf("Build by %s.\n", CLASS ## ClassAuthor ); \
   if ( CLASS ## ClassVersion    != NULL )            \
    printf("The current version is %s.\n",  CLASS ## ClassVersion ); \
   if ( CLASS ## ClassInherited  != NULL )            \
    printf("List of Inherited components [%s].\n", CLASS ## ClassInherited );


////////////////////////////////////////////////////////////////////////////
// Destroy char*, if you don't use strdup( ) don't use destructor !

#define MC_SerializeDestructor()                                \
  if ( ClassName      != NULL ) {  delete [] ClassName;      }  \
  if ( ClassAuthor    != NULL ) {  delete [] ClassAuthor;    }  \
  if ( ClassVersion   != NULL ) {  delete [] ClassVersion;   }  \
  if ( ClassInherited != NULL ) {  delete [] ClassInherited; }  \


////////////////////////////////////////////////////////////////////////////
// Serial: The Serial Number optimize macro for Constructor

#define MC_SerializeConstructor( Serial, Name, Author, Version, Inherited ) \
    SerializationID( Serial ),     ClassName(    strdup( Name )    ),       \
    ClassAuthor( strdup(Author) ), ClassVersion( strdup( Version ) ),       \
    ClassInherited( strdup(Inherited) )                                     


#define MC_SerializeInit( Name, Author, Version, Inherited ) \
    ClassName      = Name;      \
    ClassAuthor    = Author;    \
    ClassVersion   = Version;   \
    ClassInherited = Inherited; 


// Get the offset for that Class
#define MC_getSerialOffset( CLASS )  (size_t)&( ((CLASS *)0)->SerializationID )


////////////////////////////////////////////////////////////////////////////
//  ptr:    The void* pointer
//  OFFSET: The offset for the Serialization ID

#define MC_getSerial( ptr, OFFSET )   (  *(serial_t*)((char*)ptr + OFFSET)  )

#define MC_testSerial( ptr, OFFSET, Arg )  (  (MC_getSerial(ptr, OFFSET) & Arg) == Arg  )

#define MC_SerializeTools( HASHCODE )                          \
    JString  getClass() const {                                \
       return JString( ClassName );                            \
    }                                                          \
                                                               \
    JString  toString() {                                      \
       char* buf = new char[128];                              \
       sprintf( buf, "%s@%.8x", ClassName, hashCode() );       \
       return JString( buf );                                  \
    }                                                          \
                                                               \
    hashCode_t hashCode() const {                              \
      return HASHCODE;                                         \
    }                                                          \
                                                               \
    void  notify() {                                           \
    }                                                          \
                                                               \
    void  notifyAll() {                                        \
    }                                                          \
                                                               \
    BOOL equals( const JObject& obj ) {                        \
      if ( isKindOf( obj ) == FALSE ) {                        \
        return FALSE;                                          \
      }                                                        \
      return ( hashCode() == obj.hashCode() );                 \
    }                                                          \
                                                               \
    BOOL isKindOf( const JObject& obj ) const {                \
       return ( !strcmp( ClassName, obj.ClassName ) );         \
    }                                                          \
                                                               \
    BOOL isDerivedFrom( const JObject& obj ) const {           \
       char* pDest = strstr( obj.ClassName, ClassInherited );  \
                                                               \
       long result = pDest - obj.ClassInherited + 1;           \
                                                               \
       return (result > 0);                                    \
    }                                                          \
                                                               \
    BOOL isRelatedTo( JObject& obj ) const {                   \
       return ( isKindOf( obj ) || isDerivedFrom( obj ) );     \
    }                                                          

////////////////////////////////////////////////////////////////////////////



#endif

---