perThread.h

/* Copyright (c) 2005-2009, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef COBASE_PERTHREAD_H
#define COBASE_PERTHREAD_H

#include <errno.h>
#include <string.h>

#include <co/base/nonCopyable.h>

namespace co
{
namespace base
{
    class PerThreadPrivate;

    template< class T > void perThreadDelete( T* object ) { delete object; }

    template< class T > void perThreadNoDelete( T* object ) {}

    template< class T, void (*D)( T* ) = perThreadDelete< T > >
    class PerThread : public NonCopyable
    {
    public:
        PerThread();
        ~PerThread();

        PerThread<T, D>& operator = ( const T* data );
        PerThread<T, D>& operator = ( const PerThread<T, D>& rhs );

        T* get();
        const T* get() const;
        T* operator->();
        const T* operator->() const;

        T& operator*()
            { EQASSERTINFO( get(), className( this )); return *get(); }
        const T& operator*() const
            { EQASSERTINFO( get(), className( this )); return *get(); }

        bool operator == ( const PerThread& rhs ) const 
            { return ( get() == rhs.get( )); }

        bool operator == ( const T* rhs ) const { return ( get()==rhs ); }

        bool operator != ( const T* rhs ) const { return ( get()!=rhs ); }

        bool operator ! () const;

        bool isValid() const;

    private:
        PerThreadPrivate* _data;
    };
}
}

//----------------------------------------------------------------------
// implementation
//----------------------------------------------------------------------

// Crude test if pthread.h was included
#ifdef PTHREAD_MUTEX_INITIALIZER
#  ifndef HAVE_PTHREAD_H
#    define HAVE_PTHREAD_H
#  endif
#endif

#ifdef HAVE_PTHREAD_H

#include <co/base/debug.h>
#include <co/base/thread.h>

namespace co
{
namespace base
{

class PerThreadPrivate
{
public:
    pthread_key_t key;
};

template< class T, void (*D)( T* ) >
PerThread<T, D>::PerThread() 
        : _data( new PerThreadPrivate )
{
    typedef void (*PThreadDtor_t)(void*);
    const int error = pthread_key_create( &_data->key, (PThreadDtor_t)( D ));
    if( error )
    {
        EQERROR << "Can't create thread-specific key: " 
                << strerror( error ) << std::endl;
        EQASSERT( !error );
    }
}

template< class T, void (*D)( T* ) >
PerThread<T, D>::~PerThread()
{
    T* object = get();
    if( object )
        D( object );

    pthread_key_delete( _data->key );
    delete _data;
    _data = 0;
}

template< class T, void (*D)( T* ) >
PerThread<T, D>& PerThread<T, D>::operator = ( const T* data )
{ 
    pthread_setspecific( _data->key, static_cast<const void*>( data ));
    return *this; 
}

template< class T, void (*D)( T* ) >
PerThread<T, D>& PerThread<T, D>::operator = ( const PerThread<T, D>& rhs )
{ 
    pthread_setspecific( _data->key, pthread_getspecific( rhs._data->key ));
    return *this;
}

template< class T, void (*D)( T* ) >
T* PerThread<T, D>::get()
{
    return static_cast< T* >( pthread_getspecific( _data->key )); 
}
template< class T, void (*D)( T* ) >
const T* PerThread<T, D>::get() const
{
    return static_cast< const T* >( pthread_getspecific( _data->key )); 
}

template< class T, void (*D)( T* ) >
T* PerThread<T, D>::operator->() 
{
    return static_cast< T* >( pthread_getspecific( _data->key )); 
}
template< class T, void (*D)( T* ) >
const T* PerThread<T, D>::operator->() const 
{ 
    return static_cast< const T* >( pthread_getspecific( _data->key )); 
}

template< class T, void (*D)( T* ) >
bool PerThread<T, D>::operator ! () const
{
    return pthread_getspecific( _data->key ) == 0;
}

template< class T, void (*D)( T* ) >
bool PerThread<T, D>::isValid() const
{
    return pthread_getspecific( _data->key ) != 0;
}


}
}
#endif // HAVE_PTHREAD_H

#endif //COBASE_PERTHREAD_H