macosthread.cpp

"More for C++" is a class library that provides some features that are usually common for object ori

//
//  This file is part of the "More for C++" library
//
//  Copyright (c) 1999-2003 by Thorsten Goertz ([e-mail])
//
//  The "More for C++" library is free software; you can redistribute it and/or
//  modify it under the terms of the license that comes with this package.
//
//  Read "license.txt" for more details.
//
//  THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
//  WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
//  OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

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

#include <MacHeadersPPC>
#include <more/create.hpp>
#include "macosthread.hpp"

using namespace more::macos;

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

void MacOSThread::initialize( )
{
  GetCurrentThread( &nMainThreadId );
}

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

void MacOSThread::joinRemainingMacOSThreads( )
{
}

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

MacOSThread::MacOSThread( )
{
  m_nThreadId = kNoThreadID;
  m_nLastTick = 0;
  m_bShouldTerminate = false;
}

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

void MacOSThread::execute
(
  const p<Runnable>& pRunnable
)
{
  if( m_pRunnable == 0 && pRunnable != 0 )
  {
    OSErr nErrorCode = noErr;

    m_pRunnable = pRunnable;

    nErrorCode = NewThread( kCooperativeThread,
                ThreadEntryProcPtr( MacOSThread::runRunnable ),
                this, 0, kCreateIfNeeded, 0, &m_nThreadId );

    if( nErrorCode == noErr )
    {
      nErrorCode = YieldToThread( m_nThreadId );
    }
  }
}

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

void MacOSThread::terminate( )
{
  m_bShouldTerminate = true;
}

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

void MacOSThread::join( )
{
  if( m_nThreadId != kNoThreadID )
  {
    ThreadID  nCurrentThreadId;
    OSErr    nErrorCode = GetCurrentThread( &nCurrentThreadId );

    if( nErrorCode == noErr && nCurrentThreadId != m_nThreadId )
    {
      if( nCurrentThreadId == MacOSThread::nMainThreadId )
      {
        UInt32 nLastTick = 0;

        while( m_nThreadId != kNoThreadID )
        {
          OSErr  nErrorCode = YieldToAnyThread( );
          UInt32  nTick = TickCount( );

          if( nTick > nLastTick + 2 )
          {
            EventRecord eventRecord;

            WaitNextEvent( everyEvent, &eventRecord, 0, nil );

            nLastTick = nTick;
          }
        }
      }
      else
      {
        m_joiningThreads.push_back( nCurrentThreadId );

        SetThreadState( nCurrentThreadId, kStoppedThreadState, m_nThreadId );
      }
    }
  }
}

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

void MacOSThread::sleep( long nMilliseconds )
{
  UInt32 nTick = TickCount( ) + nMilliseconds / 20;

  while( m_bShouldTerminate == false && nTick >= TickCount( ) )
  {
    OSErr nErrorCode = YieldToAnyThread( );
  }
}

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

bool MacOSThread::schedule( )
{
  UInt32 nTick = TickCount( );

  if( m_bShouldTerminate == false && nTick > m_nLastTick )
  {
    OSErr nErrorCode = YieldToAnyThread( );

    m_nLastTick = nTick;
  }

  return m_bShouldTerminate == false;
}

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

void MacOSThread::finalize( )
{
  if( m_nThreadId != kNoThreadID )
  {
    OSErr nErrorCode = DisposeThread( m_nThreadId, 0, TRUE );
  }
}

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

MacOSThread::MacOSThreadController::MacOSThreadController
(
  const p<MacOSThread>& pMacOSThread
)
:  m_pMacOSThread( pMacOSThread )
{
}

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

void MacOSThread::MacOSThreadController::sleep
(
  long nMilliseconds
)
{
  m_pMacOSThread -> sleep( nMilliseconds );
}

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

bool MacOSThread::MacOSThreadController::schedule( )
{
  return m_pMacOSThread -> schedule( );
}

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

pascal void* MacOSThread::runRunnable
(
  MacOSThread* pMacOSThread
)
{
  p<MacOSThread>      pLockingRootPtr( pMacOSThread );
  p<Thread::Controller>  pController = CREATE MacOSThreadController( pMacOSThread );

  pMacOSThread -> m_pRunnable -> run( pController );

  pMacOSThread -> m_nThreadId = kNoThreadID;

  pMacOSThread -> restartJoiningThreads( );

  return 0;
}

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

void MacOSThread::restartJoiningThreads( )
{
  while( m_joiningThreads.size( ) > 0 )
  {
    OSErr      nErrorCode;
    ThreadState    nThreadState;
    ThreadID    nJoiningThreadId = m_joiningThreads.front( );

    nErrorCode = GetThreadState( nJoiningThreadId, &nThreadState );

    if( nErrorCode == noErr && nThreadState == kStoppedThreadState )
    {
      SetThreadState( nJoiningThreadId, kReadyThreadState, m_nThreadId );
    }

    m_joiningThreads.pop_front( );
  }
}

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

ThreadID MacOSThread::nMainThreadId = kNoThreadID;

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

size_t MacOSThread::nNoOfRemainingThreads = 0;

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