perThreadRef.h

/* Copyright (c) 2008-2011, 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_PERTHREADREF_H
#define COBASE_PERTHREADREF_H

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

namespace co
{
namespace base
{
    class PerThreadRefPrivate;

    template< typename T > class PerThreadRef : public NonCopyable
    {
    public:
        PerThreadRef();
        ~PerThreadRef();

        PerThreadRef<T>& operator = ( RefPtr< T > data );

        PerThreadRef<T>& operator = ( const PerThreadRef<T>& rhs );

        RefPtr< const T > get() const;
        RefPtr< T > get();

        T* getPointer();

        T* operator->();

        const T* operator->() const;

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

        bool operator == ( const RefPtr< T >& rhs ) const
            { return ( get()==rhs ); }

        bool operator != ( const RefPtr< T >& rhs ) const
            { return ( get()!=rhs ); }

        bool operator ! () const;

        bool isValid() const;

    private:
        PerThreadRefPrivate* _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

class PerThreadRefPrivate
{
public:
    pthread_key_t key;
};

template< typename T >
PerThreadRef<T>::PerThreadRef() 
        : _data( new PerThreadRefPrivate )
{
    const int error = pthread_key_create( &_data->key, 0 );
    if( error )
    {
        EQERROR << "Can't create thread-specific key: " 
                << strerror( error ) << std::endl;
        EQASSERT( !error );
    }
}

template< typename T >
PerThreadRef<T>::~PerThreadRef()
{
    RefPtr< T > object = get();

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

    object.unref();
}

template< typename T >
PerThreadRef<T>& PerThreadRef<T>::operator = ( RefPtr< T > data )
{ 
    data.ref(); // ref new

    RefPtr< T > object = get();
    pthread_setspecific( _data->key, static_cast<const void*>( data.get( )));

    object.unref(); // unref old
    return *this; 
}

template< typename T >
PerThreadRef<T>& PerThreadRef<T>::operator = ( const PerThreadRef<T>& rhs )
{
    RefPtr< T > newObject = rhs.get();
    newObject.ref(); // ref new

    RefPtr< T > object = get();
    pthread_setspecific( _data->key, pthread_getspecific( rhs._data->key ));

    object.unref(); // unref old
    return *this;
}

template< typename T >
RefPtr< const T > PerThreadRef<T>::get() const
{
    return static_cast< const T* >( pthread_getspecific( _data->key )); 
}

template< typename T >
RefPtr< T > PerThreadRef<T>::get()
{
    return static_cast< T* >( pthread_getspecific( _data->key )); 
}

template< typename T >
T* PerThreadRef<T>::getPointer()
{
    return static_cast< T* >( pthread_getspecific( _data->key )); 
}

template< typename T >
T* PerThreadRef<T>::operator->() 
{
    EQASSERT( pthread_getspecific( _data->key ));
    return static_cast< T* >( pthread_getspecific( _data->key )); 
}

template< typename T >
const T* PerThreadRef<T>::operator->() const 
{ 
    EQASSERT( pthread_getspecific( _data->key ));
    return static_cast< const T* >( pthread_getspecific( _data->key )); 
}

template< typename T >
bool PerThreadRef<T>::operator ! () const
{
    return pthread_getspecific( _data->key ) == 0;
}

template< typename T >
bool PerThreadRef<T>::isValid() const
{
    return pthread_getspecific( _data->key ) != 0;
}

#endif // HAVE_PTHREAD_H
}

}
#endif //COBASE_PERTHREADREF_H