summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/multimedia/opieplayer2/threadutil.cpp2
-rw-r--r--noncore/multimedia/opieplayer2/threadutil.h2
2 files changed, 2 insertions, 2 deletions
diff --git a/noncore/multimedia/opieplayer2/threadutil.cpp b/noncore/multimedia/opieplayer2/threadutil.cpp
index 63863b4..4055c74 100644
--- a/noncore/multimedia/opieplayer2/threadutil.cpp
+++ b/noncore/multimedia/opieplayer2/threadutil.cpp
@@ -1,194 +1,194 @@
/* This file is part of the KDE project
- Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
+ Copyright (C) 2002 Simon Hausmann <hausmann@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#include "threadutil.h"
#include <qsocketnotifier.h>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>
using namespace ThreadUtil;
struct Mutex::Data
{
Data()
{
pthread_mutex_init( &mutex, 0 );
}
~Data()
{
pthread_mutex_destroy( &mutex );
}
pthread_mutex_t mutex;
};
Mutex::Mutex()
: d( new Data )
{
}
Mutex::~Mutex()
{
delete d;
}
void Mutex::lock()
{
pthread_mutex_lock( &d->mutex );
}
void Mutex::unlock()
{
pthread_mutex_unlock( &d->mutex );
}
bool Mutex::tryLock()
{
return pthread_mutex_trylock( &d->mutex ) == 0;
}
bool Mutex::isLocked()
{
if ( !tryLock() )
return true;
unlock();
return false;
}
struct WaitCondition::Data
{
Data()
{
int result = pthread_cond_init( &waitCondition, 0 );
assert( result == 0 );
}
~Data()
{
pthread_cond_destroy( &waitCondition );
}
pthread_cond_t waitCondition;
};
WaitCondition::WaitCondition()
: d( new Data )
{
}
WaitCondition::~WaitCondition()
{
delete d;
}
bool WaitCondition::wait()
{
Mutex m;
m.lock();
return wait( m );
}
bool WaitCondition::wait( Mutex &mutex )
{
return pthread_cond_wait( &d->waitCondition, &mutex.d->mutex );
}
void WaitCondition::wakeOne()
{
pthread_cond_signal( &d->waitCondition );
}
void WaitCondition::wakeAll()
{
pthread_cond_broadcast( &d->waitCondition );
}
OnewayNotifier::OnewayNotifier()
{
int fds[ 2 ];
pipe( fds );
m_readFd = fds[ 0 ];
m_writeFd = fds[ 1 ];
m_notifier = new QSocketNotifier( m_readFd, QSocketNotifier::Read );
connect( m_notifier, SIGNAL( activated( int ) ),
this, SLOT( wakeUp() ) );
}
OnewayNotifier::~OnewayNotifier()
{
delete m_notifier;
::close( m_readFd );
::close( m_writeFd );
}
void OnewayNotifier::notify()
{
const char c = 42;
::write( m_writeFd, &c, 1 );
}
void OnewayNotifier::wakeUp()
{
char c = 0;
if ( ::read( m_readFd, &c, 1 ) != 1 )
return;
emit awake();
}
ChannelMessage::ChannelMessage( int type )
: m_type( type ), m_isCall( false ), m_replied( false ),
m_inEventHandler( false )
{
}
ChannelMessage::~ChannelMessage()
{
if ( m_guard.isLocked() )
m_guard.unlock();
}
void ChannelMessage::reply()
{
if ( !m_isCall )
{
qDebug( "ChannelMessage::reply() - can't reply oneway message!" );
return;
}
if ( m_inEventHandler )
{
m_replied = true;
return;
}
m_condition.wakeOne();
m_guard.unlock();
}
struct Channel::Private
{
Private()
{
diff --git a/noncore/multimedia/opieplayer2/threadutil.h b/noncore/multimedia/opieplayer2/threadutil.h
index bcb9db9..5cc4cdc 100644
--- a/noncore/multimedia/opieplayer2/threadutil.h
+++ b/noncore/multimedia/opieplayer2/threadutil.h
@@ -1,176 +1,176 @@
/* This file is part of the KDE project
- Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
+ Copyright (C) 2002 Simon Hausmann <hausmann@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#ifndef THREADUTIL_H
#define THREADUTIL_H
#include <qvaluelist.h>
#include <qobject.h>
#include <qguardedptr.h>
class QSocketNotifier;
namespace ThreadUtil
{
class Mutex
{
friend class WaitCondition;
public:
Mutex();
~Mutex();
void lock();
void unlock();
bool tryLock();
bool isLocked();
private:
struct Data;
Data *d;
Mutex( const Mutex & );
Mutex &operator=( const Mutex & );
};
class AutoLock
{
public:
AutoLock( Mutex &mutex ) : m_mutex( mutex ) { m_mutex.lock(); }
~AutoLock() { m_mutex.unlock(); }
Mutex *operator &() const { return &m_mutex; }
private:
Mutex &m_mutex;
};
class WaitCondition
{
public:
WaitCondition();
~WaitCondition();
bool wait();
bool wait( Mutex &mutex );
void wakeOne();
void wakeAll();
private:
struct Data;
Data *d;
WaitCondition( const WaitCondition & );
WaitCondition &operator=( const WaitCondition & );
};
class OnewayNotifier : public QObject
{
Q_OBJECT
public:
OnewayNotifier();
~OnewayNotifier();
void notify();
signals:
void awake();
private slots:
void wakeUp();
private:
int m_readFd;
int m_writeFd;
QSocketNotifier *m_notifier;
};
class Channel;
class ChannelMessage
{
friend class Channel;
public:
ChannelMessage( int type = -1 );
virtual ~ChannelMessage();
int type() const { return m_type; }
void reply();
private:
ChannelMessage( const ChannelMessage & );
ChannelMessage &operator=( const ChannelMessage );
int m_type;
bool m_isCall : 1;
bool m_replied : 1;
bool m_inEventHandler : 1;
Mutex m_guard;
WaitCondition m_condition;
QGuardedPtr<Channel> m_channel;
};
class Channel : public QObject
{
Q_OBJECT
public:
enum SendType { OneWay, WaitForReply };
Channel( QObject *parent = 0, const char *name = 0 );
virtual ~Channel();
void send( ChannelMessage *message, SendType type );
protected:
virtual void receiveMessage( ChannelMessage *message, SendType type ) = 0;
private slots:
void deliver();
private:
OnewayNotifier m_notifier;
struct MsgEnvelope
{
MsgEnvelope() : type( OneWay ), msg( 0 ) {}
MsgEnvelope( SendType _type , ChannelMessage *_msg )
: type( _type ), msg( _msg ) {}
SendType type;
ChannelMessage *msg;
};
void deliverOne( const MsgEnvelope &envelope );
typedef QValueList<MsgEnvelope> MsgEnvelopeList;
MsgEnvelopeList m_pendingMessages;
Mutex m_pendingMessagesGuard;
struct Private;
Private *d;
};
}
#endif // THREADUTIL_H
/* vim: et sw=4 ts=4
*/