src/common/object.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        object.cpp
   3 // Purpose:     wxObject implementation
   4 // Author:      Julian Smart
   5 // Modified by: Ron Lee
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Julian Smart and Markus Holzem
   9 //              (c) 2001 Ron Lee <ron@debian.org>
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  14 #pragma implementation "object.h"
  15 #endif
  16
  17     // For compilers that support precompilation, includes "wx.h".
  18
  19 #include "wx/wxprec.h"
  20
  21 #ifdef __BORLANDC__
  22 #pragma hdrstop
  23 #endif
  24
  25 #ifndef WX_PRECOMP
  26 #include "wx/hash.h"
  27 #endif
  28
  29 #include <string.h>
  30 #include <assert.h>
  31
  32 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
  33 #include "wx/memory.h"
  34 #endif
  35
  36 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
  37     // for wxObject::Dump
  38 #include "wx/ioswrap.h"
  39
  40 #if defined(__VISAGECPP__)
  41 #define DEBUG_PRINTF(NAME) { static int raz=0; \
  42  printf( #NAME " %i\n",raz); fflush(stdout); raz++; }
  43 #else
  44 #define DEBUG_PRINTF(NAME)
  45 #endif
  46
  47 #endif
  48
  49
  50 wxClassInfo wxObject::sm_classwxObject( wxT("wxObject"), 0, 0,
  51                                         (int) sizeof(wxObject),
  52                                         (wxObjectConstructorFn) 0 );
  53 wxClassInfo* wxClassInfo::sm_first = 0;
  54 wxHashTable* wxClassInfo::sm_classTable = 0;
  55
  56     // These are here so we can avoid 'always true/false' warnings
  57     // by referring to these instead of TRUE/FALSE
  58
  59 const bool wxTrue = TRUE;
  60 const bool wxFalse = FALSE;
  61
  62     // Is this object a kind of (a subclass of) 'info'?
  63     // E.g. is wxWindow a kind of wxObject?
  64     // Go from this class to superclass, taking into account
  65     // two possible base classes.
  66
  67 bool wxObject::IsKindOf(wxClassInfo *info) const
  68 {
  69     wxClassInfo *thisInfo = GetClassInfo();
  70     return (thisInfo) ? thisInfo->IsKindOf(info) : FALSE ;
  71 }
  72
  73 #if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
  74 void wxObject::Dump(wxSTD ostream& str)
  75 {
  76     if (GetClassInfo() && GetClassInfo()->GetClassName())
  77         str << GetClassInfo()->GetClassName();
  78     else
  79         str << "unknown object class";
  80 }
  81 #endif
  82
  83 #if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
  84
  85 #ifdef new
  86 #undef new
  87 #endif
  88
  89 void *wxObject::operator new (size_t size, wxChar *fileName, int lineNum)
  90 {
  91     return wxDebugAlloc(size, fileName, lineNum, TRUE);
  92 }
  93
  94 #ifndef __VISAGECPP__
  95 void wxObject::operator delete (void *buf)
  96 {
  97     wxDebugFree(buf);
  98 }
  99 #elif __DEBUG_ALLOC__
 100 void wxObject::operator delete (void *buf, const char *_fname, size_t _line)
 101 {
 102     wxDebugFree(buf);
 103 }
 104 #endif
 105
 106     // VC++ 6.0
 107
 108 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 109 void wxObject::operator delete(void *pData, wxChar *WXUNUSED(fileName), int WXUNUSED(lineNum))
 110 {
 111     ::operator delete(pData);
 112 }
 113 #endif
 114
 115     // Cause problems for VC++ - crashes
 116
 117 #if (!defined(__VISUALC__) && wxUSE_ARRAY_MEMORY_OPERATORS ) || defined(__MWERKS__)
 118 void *wxObject::operator new[] (size_t size, wxChar *fileName, int lineNum)
 119 {
 120     return wxDebugAlloc(size, fileName, lineNum, TRUE, TRUE);
 121 }
 122
 123 void wxObject::operator delete[] (void *buf)
 124 {
 125     wxDebugFree(buf, TRUE);
 126 }
 127 #endif
 128
 129 #endif  // __WXDEBUG__  && wxUSE_MEMORY_TRACING
 130
 131
 132 // ----------------------------------------------------------------------------
 133 // wxClassInfo
 134 // ----------------------------------------------------------------------------
 135
 136 wxClassInfo *wxClassInfo::FindClass(const wxChar *className)
 137 {
 138     if ( sm_classTable )
 139     {
 140         return (wxClassInfo *)wxClassInfo::sm_classTable->Get(className);
 141     }
 142     else
 143     {
 144         for ( wxClassInfo *info = sm_first; info ; info = info->m_next )
 145         {
 146             if ( wxStrcmp(info->GetClassName(), className) == 0 )
 147                 return info;
 148         }
 149
 150         return NULL;
 151     }
 152 }
 153
 154 // a tiny InitializeClasses() helper
 155 /* static */
 156 inline wxClassInfo *wxClassInfo::GetBaseByName(const wxChar *name)
 157 {
 158     if ( !name )
 159         return NULL;
 160
 161     wxClassInfo *classInfo = (wxClassInfo *)sm_classTable->Get(name);
 162
 163     // this must be fixed, other things risk work wrongly later if you get this
 164     wxASSERT_MSG( classInfo,
 165                   wxString::Format
 166                   (
 167                     _T("base class '%s' is unknown to wxWindows RTTI"),
 168                     name
 169                   ) );
 170
 171     return classInfo;
 172 }
 173
 174 // Set pointers to base class(es) to speed up IsKindOf
 175 void wxClassInfo::InitializeClasses()
 176 {
 177     // using IMPLEMENT_DYNAMIC_CLASS() macro twice (which may happen if you
 178     // link any object module twice mistakenly) will break this function
 179     // because it will enter an infinite loop and eventually die with "out of
 180     // memory" - as this is quite hard to detect if you're unaware of this,
 181     // try to do some checks here
 182
 183 #ifdef __WXDEBUG__
 184     static const size_t nMaxClasses = 10000;    // more than we'll ever have
 185     size_t nClass = 0;
 186 #endif
 187
 188     wxClassInfo::sm_classTable = new wxHashTable(wxKEY_STRING);
 189
 190         // Index all class infos by their class name
 191
 192     wxClassInfo *info;
 193     for(info = sm_first; info; info = info->m_next)
 194     {
 195         if (info->m_className)
 196         {
 197             wxASSERT_MSG( ++nClass < nMaxClasses,
 198                           _T("an infinite loop detected - have you used IMPLEMENT_DYNAMIC_CLASS() twice (may be by linking some object module(s) twice)?") );
 199             sm_classTable->Put(info->m_className, (wxObject *)info);
 200         }
 201     }
 202
 203         // Set base pointers for each wxClassInfo
 204
 205     for(info = sm_first; info; info = info->m_next)
 206     {
 207         info->m_baseInfo1 = GetBaseByName(info->GetBaseClassName1());
 208         info->m_baseInfo2 = GetBaseByName(info->GetBaseClassName2());
 209     }
 210 }
 211
 212 void wxClassInfo::CleanUpClasses()
 213 {
 214     delete wxClassInfo::sm_classTable;
 215     wxClassInfo::sm_classTable = 0;
 216 }
 217
 218
 219 wxObject *wxCreateDynamicObject(const wxChar *name)
 220 {
 221 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
 222  DEBUG_PRINTF(wxObject *wxCreateDynamicObject)
 223 #endif
 224
 225     if (wxClassInfo::sm_classTable)
 226     {
 227         wxClassInfo *info = (wxClassInfo *)wxClassInfo::sm_classTable->Get(name);
 228         return info != 0 ? info->CreateObject() : 0;
 229     }
 230     else
 231     {
 232         for(wxClassInfo *info = wxClassInfo::sm_first; info; info = info->m_next)
 233             if (info->m_className && wxStrcmp(info->m_className, name) == 0)
 234                 return info->CreateObject();
 235         return 0;
 236     }
 237 }
 238
 239
 240 // ----------------------------------------------------------------------------
 241 // wxClassInfo
 242 // ----------------------------------------------------------------------------
 243
 244 void wxObject::Ref(const wxObject& clone)
 245 {
 246 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
 247     DEBUG_PRINTF(wxObject::Ref)
 248 #endif
 249
 250     // nothing to be done
 251     if (m_refData == clone.m_refData)
 252         return;
 253
 254     // delete reference to old data
 255     UnRef();
 256
 257     // reference new data
 258     if ( clone.m_refData )
 259     {
 260         m_refData = clone.m_refData;
 261         ++(m_refData->m_count);
 262     }
 263 }
 264
 265 void wxObject::UnRef()
 266 {
 267     if ( m_refData )
 268     {
 269         wxASSERT_MSG( m_refData->m_count > 0, _T("invalid ref data count") );
 270
 271         if ( !--m_refData->m_count )
 272             delete m_refData;
 273         m_refData = NULL;
 274     }
 275 }
 276
 277 void wxObject::AllocExclusive()
 278 {
 279     if ( !m_refData )
 280     {
 281         m_refData = CreateRefData();
 282     }
 283     else if ( m_refData->GetRefCount() > 1 )
 284     {
 285         // note that ref is not going to be destroyed in this case
 286         const wxObjectRefData* ref = m_refData;
 287         UnRef();
 288
 289         // ... so we can still access it
 290         m_refData = CloneRefData(ref);
 291     }
 292     //else: ref count is 1, we are exclusive owners of m_refData anyhow
 293
 294     wxASSERT_MSG( m_refData && m_refData->GetRefCount() == 1,
 295                   _T("wxObject::AllocExclusive() failed.") );
 296 }
 297
 298 wxObjectRefData *wxObject::CreateRefData() const
 299 {
 300     // if you use AllocExclusive() you must override this method
 301     wxFAIL_MSG( _T("CreateRefData() must be overridden if called!") );
 302
 303     return NULL;
 304 }
 305
 306 wxObjectRefData *
 307 wxObject::CloneRefData(const wxObjectRefData * WXUNUSED(data)) const
 308 {
 309     // if you use AllocExclusive() you must override this method
 310     wxFAIL_MSG( _T("CloneRefData() must be overridden if called!") );
 311
 312     return NULL;
 313 }
 314
 315 // ----------------------------------------------------------------------------
 316 // misc
 317 // ----------------------------------------------------------------------------
 318
 319 #if defined(__DARWIN__) && defined(DYLIB_INIT)
 320
 321 extern "C" {
 322     void __initialize_Cplusplus(void);
 323     void wxWindowsDylibInit(void);
 324 };
 325
 326     // Dynamic shared library (dylib) initialization routine
 327     //   required to initialize static C++ objects bacause of lazy dynamic linking
 328     //   http://developer.apple.com/techpubs/macosx/Essentials/
 329     //          SystemOverview/Frameworks/Dynamic_Shared_Libraries.html
 330
 331 void wxWindowsDylibInit()
 332 {
 333     // The function __initialize_Cplusplus() must be called from the shared
 334     // library initialization routine to cause the static C++ objects in
 335     // the library to be initialized (reference number 2441683).
 336
 337     __initialize_Cplusplus();
 338 }
 339
 340 #endif
 341
 342 // vi:sts=4:sw=4:et