trunk/branch integration: new files

Foundation/src/Event_VX.cpp

@@ -0,0 +1,101 @@
+//
+// Event_POSIX.cpp
+//
+// $Id: //poco/1.4/Foundation/src/Event_VX.cpp#1 $
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/Event_VX.h"
+#include <sysLib.h>
+
+
+namespace Poco {
+
+
+EventImpl::EventImpl(bool autoReset): _auto(autoReset), _state(false)
+{
+        _sem = semCCreate(SEM_Q_PRIORITY, 0);
+        if (_sem == 0)
+                throw Poco::SystemException("cannot create event");
+}
+
+
+EventImpl::~EventImpl()
+{
+        semDelete(_sem);
+}
+
+
+void EventImpl::setImpl()
+{
+        if (_auto)
+        {
+                if (semGive(_sem) != OK)
+                        throw SystemException("cannot set event");
+        }
+        else
+        {
+                _state = true;
+                if (semFlush(_sem) != OK)
+                        throw SystemException("cannot set event");
+        }
+}
+
+
+void EventImpl::resetImpl()
+{
+        _state = false;
+}
+
+
+void EventImpl::waitImpl()
+{
+        if (!_state)
+        {
+                if (semTake(_sem, WAIT_FOREVER) != OK)
+                        throw SystemException("cannot wait for event");
+        }
+}
+
+
+bool EventImpl::waitImpl(long milliseconds)
+{
+        if (!_state)
+        {
+                int ticks = milliseconds*sysClkRateGet()/1000;
+                return semTake(_sem, ticks) == OK;
+        }
+        else return true;
+}
+
+
+} // namespace Poco

Foundation/src/Mutex_VX.cpp

@@ -0,0 +1,90 @@
+//
+// Mutex_VX.cpp
+//
+// $Id: //poco/1.4/Foundation/src/Mutex_VX.cpp#1 $
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/Mutex_VX.h"
+#include <sysLib.h>
+
+
+namespace Poco {
+
+
+MutexImpl::MutexImpl()
+{
+        _sem = semMCreate(SEM_INVERSION_SAFE | SEM_Q_PRIORITY);
+        if (_sem == 0)
+                throw Poco::SystemException("cannot create mutex");
+}
+
+
+MutexImpl::MutexImpl(bool fast)
+{
+        if (fast)
+        {
+                _sem = semBCreate(SEM_Q_PRIORITY, SEM_FULL);
+        }
+        else
+        {
+                _sem = semMCreate(SEM_INVERSION_SAFE | SEM_Q_PRIORITY);
+        }
+        if (_sem == 0)
+                throw Poco::SystemException("cannot create mutex");
+}
+
+
+MutexImpl::~MutexImpl()
+{
+        semDelete(_sem);
+}
+
+
+bool MutexImpl::tryLockImpl(long milliseconds)
+{
+        int ticks = milliseconds*sysClkRateGet()/1000;
+        return semTake(_sem, ticks) == OK;
+}
+
+
+FastMutexImpl::FastMutexImpl(): MutexImpl(true)
+{
+}
+
+
+FastMutexImpl::~FastMutexImpl()
+{
+}
+
+
+} // namespace Poco

Foundation/src/NamedEvent_Android.cpp

@@ -0,0 +1,66 @@
+//
+// NamedEvent_Android.cpp
+//
+// $Id: //poco/1.4/Foundation/src/NamedEvent_Android.cpp#1 $
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/NamedEvent_Android.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+NamedEventImpl::NamedEventImpl(const std::string&)
+{
+}
+
+
+NamedEventImpl::~NamedEventImpl()
+{
+}
+
+
+void NamedEventImpl::setImpl()
+{
+        throw NotImplementedException("NamedEvent::set() not available on Android");
+}
+
+
+void NamedEventImpl::waitImpl()
+{
+        throw NotImplementedException("NamedEvent::wait() not available on Android");
+}
+
+
+} // namespace Poco

Foundation/src/NamedMutex_Android.cpp

@@ -0,0 +1,72 @@
+//
+// NamedMutex_Android.cpp
+//
+// $Id: //poco/1.4/Foundation/src/NamedMutex_Android.cpp#1 $
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/NamedMutex_Android.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+NamedMutexImpl::NamedMutexImpl(const std::string&)
+{
+}
+
+
+NamedMutexImpl::~NamedMutexImpl()
+{
+}
+
+
+void NamedMutexImpl::lockImpl()
+{
+        throw NotImplementedException("NamedMutex::lock() is not supported on Android");
+}
+
+
+bool NamedMutexImpl::tryLockImpl()
+{
+        throw NotImplementedException("NamedMutex::tryLock() is not supported on Android");
+}
+
+
+void NamedMutexImpl::unlockImpl()
+{
+        throw NotImplementedException("NamedMutex::unlock() is not supported on Android");
+}
+
+
+} // namespace Poco

Foundation/src/RWLock_Android.cpp

@@ -0,0 +1,61 @@
+//
+// RWLock_Android.cpp
+//
+// $Id: //poco/1.4/Foundation/src/RWLock_Android.cpp#1 $
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/RWLock_Android.h"
+
+
+namespace Poco {
+
+
+RWLockImpl::RWLockImpl()
+{
+        pthread_mutexattr_t attr;
+        pthread_mutexattr_init(&attr);
+        if (pthread_mutex_init(&_mutex, &attr))
+        {
+                pthread_mutexattr_destroy(&attr);
+                throw SystemException("cannot create mutex");
+        }
+        pthread_mutexattr_destroy(&attr);}
+
+
+RWLockImpl::~RWLockImpl()
+{
+        pthread_mutex_destroy(&_mutex);
+}
+
+
+} // namespace Poco

Foundation/src/Semaphore_VX.cpp

@@ -0,0 +1,74 @@
+//
+// Semaphore_VX.cpp
+//
+// $Id: //poco/1.4/Foundation/src/Semaphore_VX.cpp#1 $
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/Semaphore_VX.h"
+#include <sysLib.h>
+
+
+namespace Poco {
+
+
+SemaphoreImpl::SemaphoreImpl(int n, int max)
+{
+        poco_assert (n >= 0 && max > 0 && n <= max);
+
+        _sem = semCCreate(SEM_Q_PRIORITY, n);
+        if (_sem == 0)
+                throw Poco::SystemException("cannot create semaphore");
+}
+
+
+SemaphoreImpl::~SemaphoreImpl()
+{
+        semDelete(_sem);
+}
+
+
+void SemaphoreImpl::waitImpl()
+{
+        if (semTake(_sem, WAIT_FOREVER) != OK)
+                throw SystemException("cannot wait for semaphore");
+}
+
+
+bool SemaphoreImpl::waitImpl(long milliseconds)
+{
+        int ticks = milliseconds*sysClkRateGet()/1000;
+        return semTake(_sem, ticks) == OK;
+}
+
+
+} // namespace Poco

Foundation/src/Thread_VX.cpp

@@ -0,0 +1,295 @@
+//
+// Thread_VX.cpp
+//
+// $Id: //poco/1.4/Foundation/src/Thread_VX.cpp#1 $
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+// 
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+
+#include "Poco/Thread_VX.h"
+#include "Poco/ErrorHandler.h"
+#include "Poco/Exception.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include <timers.h>
+
+
+namespace Poco {
+
+
+ThreadImpl* ThreadImpl::_pCurrent(0);
+
+
+ThreadImpl::ThreadImpl():
+        _pData(new ThreadData)
+{
+}
+
+                        
+ThreadImpl::~ThreadImpl()
+{
+}
+
+
+void ThreadImpl::setPriorityImpl(int prio)
+{
+        if (prio != _pData->prio)
+        {
+                _pData->prio   = prio;
+                _pData->osPrio = mapPrio(_pData->prio);
+                if (isRunningImpl())
+                {
+                        if (taskPrioritySet(_pData->task, _pData->osPrio) != OK)
+                                throw SystemException("cannot set task priority");
+                }
+        }
+}
+
+
+void ThreadImpl::setOSPriorityImpl(int prio)
+{
+        if (prio != _pData->osPrio)
+        {
+                _pData->prio   = reverseMapPrio(prio);
+                _pData->osPrio = prio;
+                if (_pData->pRunnableTarget || _pData->pCallbackTarget)
+                {
+                        if (taskPrioritySet(_pData->task, prio) != OK)
+                                throw SystemException("cannot set task priority");
+                }
+        }
+}
+
+
+int ThreadImpl::getMinOSPriorityImpl()
+{
+        return 255;
+}
+
+
+int ThreadImpl::getMaxOSPriorityImpl()
+{
+        return 0;
+}
+
+
+void ThreadImpl::setStackSizeImpl(int size)
+{
+        _pData->stackSize = size;
+}
+
+
+void ThreadImpl::startImpl(Runnable& target)
+{
+        if (_pData->pRunnableTarget)
+                throw SystemException("thread already running");
+
+        _pData->pRunnableTarget = &target;
+        
+        int stackSize = _pData->stackSize == 0 ? DEFAULT_THREAD_STACK_SIZE : _pData->stackSize;
+        int id = taskSpawn(NULL, _pData->osPrio, VX_FP_TASK, stackSize, reinterpret_cast<FUNCPTR>(runnableEntry), reinterpret_cast<int>(this), 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        if (id == ERROR)
+                throw SystemException("cannot spawn task");
+
+        _pData->task = id;
+}
+
+
+void ThreadImpl::startImpl(Callable target, void* pData)
+{
+        if (_pData->pCallbackTarget && _pData->pCallbackTarget->callback)
+                throw SystemException("thread already running");
+
+        if (0 == _pData->pCallbackTarget.get())
+                _pData->pCallbackTarget = new CallbackData;
+
+        _pData->pCallbackTarget->callback = target;
+        _pData->pCallbackTarget->pData = pData;
+
+        int stackSize = _pData->stackSize == 0 ? DEFAULT_THREAD_STACK_SIZE : _pData->stackSize;
+        int id = taskSpawn(NULL, _pData->osPrio, VX_FP_TASK, stackSize, reinterpret_cast<FUNCPTR>(callableEntry), reinterpret_cast<int>(this), 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        if (id == ERROR)
+                throw SystemException("cannot spawn task");
+
+        _pData->task = id;
+}
+
+
+void ThreadImpl::joinImpl()
+{
+        _pData->done.wait();
+}
+
+
+bool ThreadImpl::joinImpl(long milliseconds)
+{
+        return _pData->done.tryWait(milliseconds);
+}
+
+
+ThreadImpl* ThreadImpl::currentImpl()
+{
+        return _pCurrent;
+}
+
+
+ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
+{
+    return taskIdSelf();
+}
+
+
+void ThreadImpl::sleepImpl(long milliseconds)
+{
+        Poco::Timespan remainingTime(1000*Poco::Timespan::TimeDiff(milliseconds));
+        int rc;
+        do
+        {
+                struct timespec ts;
+                ts.tv_sec  = (long) remainingTime.totalSeconds();
+                ts.tv_nsec = (long) remainingTime.useconds()*1000;
+                Poco::Timestamp start;
+                rc = ::nanosleep(&ts, 0);
+                if (rc < 0 && errno == EINTR)
+                {
+                        Poco::Timestamp end;
+                        Poco::Timespan waited = start.elapsed();
+                        if (waited < remainingTime)
+                                remainingTime -= waited;
+                        else
+                                remainingTime = 0;
+                }
+        }
+        while (remainingTime > 0 && rc < 0 && errno == EINTR);
+        if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): nanosleep() failed");
+}
+
+
+void ThreadImpl::runnableEntry(void* pThread, int, int, int, int, int, int, int, int, int)
+{
+        taskVarAdd(0, reinterpret_cast<int*>(&_pCurrent));
+        _pCurrent = reinterpret_cast<ThreadImpl*>(pThread);
+
+        AutoPtr<ThreadData> pData = _pCurrent->_pData;
+        try
+        {
+                pData->pRunnableTarget->run();
+        }
+        catch (Exception& exc)
+        {
+                ErrorHandler::handle(exc);
+        }
+        catch (std::exception& exc)
+        {
+                ErrorHandler::handle(exc);
+        }
+        catch (...)
+        {
+                ErrorHandler::handle();
+        }
+
+        pData->pRunnableTarget = 0;
+        pData->done.set();
+}
+
+
+void ThreadImpl::callableEntry(void* pThread, int, int, int, int, int, int, int, int, int)
+{
+        taskVarAdd(0, reinterpret_cast<int*>(&_pCurrent));
+        _pCurrent = reinterpret_cast<ThreadImpl*>(pThread);
+
+        AutoPtr<ThreadData> pData = _pCurrent->_pData;
+        try
+        {
+                pData->pCallbackTarget->callback(pData->pCallbackTarget->pData);
+        }
+        catch (Exception& exc)
+        {
+                ErrorHandler::handle(exc);
+        }
+        catch (std::exception& exc)
+        {
+                ErrorHandler::handle(exc);
+        }
+        catch (...)
+        {
+                ErrorHandler::handle();
+        }
+
+        pData->pCallbackTarget->callback = 0;
+        pData->pCallbackTarget->pData = 0;
+        pData->done.set();
+}
+
+
+int ThreadImpl::mapPrio(int prio)
+{
+        int pmin = getMinOSPriorityImpl();
+        int pmax = getMaxOSPriorityImpl();
+
+        switch (prio)
+        {
+        case PRIO_LOWEST_IMPL:
+                return pmin;
+        case PRIO_LOW_IMPL:
+                return pmin + (pmax - pmin)/4;
+        case PRIO_NORMAL_IMPL:
+                return pmin + (pmax - pmin)/2;
+        case PRIO_HIGH_IMPL:
+                return pmin + 3*(pmax - pmin)/4;
+        case PRIO_HIGHEST_IMPL:
+                return pmax;
+        default:
+                poco_bugcheck_msg("invalid thread priority");
+        }
+        return -1; // just to satisfy compiler - we'll never get here anyway
+}
+
+
+int ThreadImpl::reverseMapPrio(int prio)
+{
+        int pmin = getMinOSPriorityImpl();
+        int pmax = getMaxOSPriorityImpl();
+        int normal = pmin + (pmax - pmin)/2;
+        if (prio == pmax)
+                return PRIO_HIGHEST_IMPL;
+        if (prio > normal)
+                return PRIO_HIGH_IMPL;
+        else if (prio == normal)
+                return PRIO_NORMAL_IMPL;
+        else if (prio > pmin)
+                return PRIO_LOW_IMPL;
+        else
+                return PRIO_LOWEST_IMPL;
+}
+
+
+} // namespace Poco