C / C++ / MFC

; KOYOCE.def : Declares the module parameters.
 
LIBRARY      "KOYO32.DLL"
 
EXPORTS
;	DllCanUnloadNow       @1 PRIVATE
;	DllGetClassObject     @2 PRIVATE
;	DllRegisterServer     @3 PRIVATE
;	DllUnregisterServer   @4 PRIVATE
;	DllzenOnGetClassCLSID @5 PRIVATE
 
	DllCanUnloadNow       PRIVATE
	DllGetClassObject     PRIVATE
	DllRegisterServer     PRIVATE
	DllUnregisterServer   PRIVATE
	DllzenOnGetClassCLSID PRIVATE

/*---------------------------------------------------------*/
/*
** ThreadLocal.h - Thread Local Storage 

  Written by Purush Rudrakshala,
*/

#if !defined (__THREADLOCAL_H__)
#define __THREADLOCAL_H__

#include < list >

class TlsException
{
public:
   explicit TlsException (DWORD error) : m_error (error) {}

private:
   DWORD m_error;                        

   // not implemented
   TlsException ();
};

template < class T > class CISThreadLocal
{
public:
   explicit CISThreadLocal () : m_index (::TlsAlloc ())
   {
      if (m_index == ~0)
      {
#ifdef _DEBUG
         throw TlsException (GetLastError ());
#endif
      }

      // Initialize the critical section.
      InitializeCriticalSection(&g_CritSection); 
   } // cons

   ~CISThreadLocal ()
   {
      if (m_index != ~0)  
      {
         ::TlsFree (m_index);
      }

      m_index = 0;

      // make sure no-one is playing with this data before we yank it away      
      EnterCriticalSection(&g_CritSection); 

      // free thread local objects allocated for all threads
      for (std::list< T *>::iterator it = m_tsdList.begin(); it!=m_tsdList.end(); it++)
      {
          delete (*it);
      }

      m_tsdList.clear();

      // done
      LeaveCriticalSection(&g_CritSection);

      // Delete the critical section.
      DeleteCriticalSection(&g_CritSection);
   } // ~

   inline T* operator -> ()
   {
      return GetThreadLocal ();
   } // ->

   T* GetThreadLocal ()
   {
      T* tsd = 0;

      try
      {
         if (m_index != ~0) 
         {
            tsd = reinterpret_cast <T*> (::TlsGetValue (m_index));
            if (tsd == 0) 
            {
               // thread local storage has not been allocated 
               // for this thread yet, allocate an object and keep
               // it in the list
               tsd = new T;
               BOOL success = ::TlsSetValue (m_index, tsd);
               if (!success)
                  throw TlsException (::GetLastError ());

               EnterCriticalSection(&g_CritSection); 

               m_tsdList.push_back(tsd);
 
               // done
               LeaveCriticalSection(&g_CritSection);
            }
         }
      }
      catch (...)
      {
         tsd = NULL;
      }

      return tsd;
   } // GetThreadLocal

   ///////////////////////////////////////
   // have we allocated anything for this thread?

   bool HasTLS()
   {
      T* tsd = 0;

      try
      {
         if (m_index != ~0) 
         {
            tsd = reinterpret_cast <T*> (::TlsGetValue (m_index));
         }
      }
      catch (...)
      {
         tsd = NULL;
      }

      return (tsd != 0);
   }

   //////////////////////////////////////
   // remove this TLS from the list
   void DeleteThreadTLS()
   {
      try
      {
         if (m_index != ~0) 
         {
            T* tsd = reinterpret_cast <T*> (::TlsGetValue (m_index));

            if (tsd)
            {
               // ok this thread has TLS - kill it
               BOOL success = ::TlsSetValue (m_index, 0);
               if (!success)
                  throw TlsException (::GetLastError ());

               // make sure no-one is playing with this data before we yank it away      
               EnterCriticalSection(&g_CritSection); 

               m_tsdList.remove(tsd);

               delete tsd;

               // done
               LeaveCriticalSection(&g_CritSection);
            }
         }
      }
      catch (...)
      {
      }
   }

private:
   DWORD m_index;  // key to thread specific storage

   // Win32 does not provide a simple way to cleanup
   // resources allocated by a thread when a thread dies
   // So, keep track of thread local objects allocated by
   // various threads in a simple list and destroy
   // when the application exits
   std::list<T *> m_tsdList;

   CRITICAL_SECTION g_CritSection;

   // not implemented
   CISThreadLocal (const CISThreadLocal&);
   void operator = (const CISThreadLocal&);
};

class CMyThreadSafeData
{
 ...
int m_foo;
....
};

// in a header
extern CISThreadLocal < CMyThreadSafeData > threadSafeData;

// in a cpp
CISThreadLocal < CMyThreadSafeData > threadSafeData;

void MyProgress(unsigned char percentage)
{
  ...
}

...
SetCallBackProcFor3rdPartyLib(MyProgress); //make the lib call MyProgress to report its progress
Do3rdPartyLibProcessing(); //make the lib do its magic
...

void MyProgress(unsigned char percentage, HWND control)
{
  ...
}

HWND the_control = NULL;

void MyProgress(unsigned char percentage)
{
  CString str;
  str.Format("%d %%", percentage);
  SetWindowText(the_control, str);
}

...
the_control = handle_of_the_control;
SetCallBackProcFor3rdPartyLib(MyProgress); //make the lib call MyProgress to report its progress
Do3rdPartyLibProcessing(); //make the lib do its magic
...

{
  int* pInt = new int[20];
  pInt = new int[10];
  pInt = new int[30];
  pInt = new int[10];
}

variable | chunk of heap start | chunk of heap end | length of heap | allocated by (method signature)
pFoo       0x00002000            0x20000000          536862720        heapcrusher

{
  int* pInt = new int[30];
  delete pInt;
  for (int i = 0; i < 100; i++) {
    int* pChar = new char[1024];
    delete pChar;
    delete pChar;
  }
  delete pInt;
}