uobject.h

Go to the documentation of this file.

/*
******************************************************************************
*
*   Copyright (C) 2002-2012, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
******************************************************************************
*   file name:  uobject.h
*   encoding:   US-ASCII
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2002jun26
*   created by: Markus W. Scherer
*/
 
#ifndef __UOBJECT_H__
#define __UOBJECT_H__
 
#include "unicode/utypes.h"


#ifndef U_NO_THROW
#define U_NO_THROW throw()
#endif

 
/*===========================================================================*/
/* UClassID-based RTTI */
/*===========================================================================*/

typedef void* UClassID;
 
U_NAMESPACE_BEGIN

class U_COMMON_API UMemory {
public:
 
/* test versions for debugging shaper heap memory problems */
#ifdef SHAPER_MEMORY_DEBUG  
    static void * NewArray(int size, int count);
    static void * GrowArray(void * array, int newSize );
    static void   FreeArray(void * array );
#endif
 
#if U_OVERRIDE_CXX_ALLOCATION
    static void * U_EXPORT2 operator new(size_t size) U_NO_THROW;

    static void * U_EXPORT2 operator new[](size_t size) U_NO_THROW;

    static void U_EXPORT2 operator delete(void *p) U_NO_THROW;

    static void U_EXPORT2 operator delete[](void *p) U_NO_THROW;
 
#if U_HAVE_PLACEMENT_NEW
    static inline void * U_EXPORT2 operator new(size_t, void *ptr) U_NO_THROW { return ptr; }

    static inline void U_EXPORT2 operator delete(void *, void *) U_NO_THROW {}
#endif /* U_HAVE_PLACEMENT_NEW */
#if U_HAVE_DEBUG_LOCATION_NEW 
    static void * U_EXPORT2 operator new(size_t size, const char* file, int line) U_NO_THROW; 
    static void U_EXPORT2 operator delete(void* p, const char* file, int line) U_NO_THROW;
#endif /* U_HAVE_DEBUG_LOCATION_NEW */
#endif /* U_OVERRIDE_CXX_ALLOCATION */
 
    /*
     * Assignment operator not declared. The compiler will provide one
     * which does nothing since this class does not contain any data members.
     * API/code coverage may show the assignment operator as present and
     * untested - ignore.
     * Subclasses need this assignment operator if they use compiler-provided
     * assignment operators of their own. An alternative to not declaring one
     * here would be to declare and empty-implement a protected or public one.
    UMemory &UMemory::operator=(const UMemory &);
     */
};

class U_COMMON_API UObject : public UMemory {
public:
    virtual ~UObject();

    virtual UClassID getDynamicClassID() const = 0;
 
protected:
    // the following functions are protected to prevent instantiation and
    // direct use of UObject itself
 
    // default constructor
    // commented out because UObject is abstract (see getDynamicClassID)
    // inline UObject() {}
 
    // copy constructor
    // commented out because UObject is abstract (see getDynamicClassID)
    // inline UObject(const UObject &other) {}
 
#if 0
    // TODO Sometime in the future. Implement operator==().
    // (This comment inserted in 2.2)
    // some or all of the following "boilerplate" functions may be made public
    // in a future ICU4C release when all subclasses implement them
 
    // assignment operator
    // (not virtual, see "Taligent's Guide to Designing Programs" pp.73..74)
    // commented out because the implementation is the same as a compiler's default
    // UObject &operator=(const UObject &other) { return *this; }
 
    // comparison operators
    virtual inline UBool operator==(const UObject &other) const { return this==&other; }
    inline UBool operator!=(const UObject &other) const { return !operator==(other); }
 
    // clone() commented out from the base class:
    // some compilers do not support co-variant return types
    // (i.e., subclasses would have to return UObject * as well, instead of SubClass *)
    // see also UObject class documentation.
    // virtual UObject *clone() const;
#endif
 
    /*
     * Assignment operator not declared. The compiler will provide one
     * which does nothing since this class does not contain any data members.
     * API/code coverage may show the assignment operator as present and
     * untested - ignore.
     * Subclasses need this assignment operator if they use compiler-provided
     * assignment operators of their own. An alternative to not declaring one
     * here would be to declare and empty-implement a protected or public one.
    UObject &UObject::operator=(const UObject &);
     */
 
// Future implementation for RTTI that support subtyping. [alan]
// 
//  public:
//     /**
//      * @internal
//      */
//     static UClassID getStaticClassID();
// 
//     /**
//      * @internal
//      */
//     UBool instanceOf(UClassID type) const;
};
 
#ifndef U_HIDE_INTERNAL_API
#define UOBJECT_DEFINE_RTTI_IMPLEMENTATION(myClass) \
    UClassID U_EXPORT2 myClass::getStaticClassID() { \
        static char classID = 0; \
        return (UClassID)&classID; \
    } \
    UClassID myClass::getDynamicClassID() const \
    { return myClass::getStaticClassID(); }
 

#define UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(myClass) \
    UClassID U_EXPORT2 myClass::getStaticClassID() { \
        static char classID = 0; \
        return (UClassID)&classID; \
    }

#define UOBJECT_DEFINE_NO_RTTI_IMPLEMENTATION(myClass) \
    UClassID myClass::getDynamicClassID() const { return NULL; }
 
// /**
//  * This macro adds ICU RTTI to an ICU concrete class implementation.
//  * This macro should be invoked in *.cpp files.  The corresponding
//  * header should declare getDynamicClassID and getStaticClassID.
//  *
//  * @param myClass The name of the class that needs RTTI defined.
//  * @param myParent The name of the myClass's parent.
//  * @internal
//  */
/*#define UOBJECT_DEFINE_RTTI_IMPLEMENTATION(myClass, myParent) \
    UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(myClass, myParent) \
    UClassID myClass::getDynamicClassID() const { \
        return myClass::getStaticClassID(); \
    }
*/
#endif  /* U_HIDE_INTERNAL_API */
 
U_NAMESPACE_END
 
#endif