summaryrefslogtreecommitdiff
authorsimon <simon>2002-12-02 19:31:37 (UTC)
committer simon <simon>2002-12-02 19:31:37 (UTC)
commita45bd312c97a83fef9b3d93c7caedb1f302c6ebe (patch) (side-by-side diff)
tree0258962981573e1d9fd5e5453026b068136e4839
parent618f271eff61003b66eb4a216826d8d52e1be627 (diff)
downloadopie-a45bd312c97a83fef9b3d93c7caedb1f302c6ebe.zip
opie-a45bd312c97a83fef9b3d93c7caedb1f302c6ebe.tar.gz
opie-a45bd312c97a83fef9b3d93c7caedb1f302c6ebe.tar.bz2
- copyright fixlet
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,284 +1,284 @@
/* 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()
{
ownerThread = pthread_self();
}
pthread_t ownerThread;
};
Channel::Channel( QObject *parent, const char *name )
: QObject( parent, name ), d( new Private )
{
connect( &m_notifier, SIGNAL( awake() ),
this, SLOT( deliver() ) );
}
Channel::~Channel()
{
delete d;
}
void Channel::send( ChannelMessage *message, SendType type )
{
if ( type == WaitForReply )
{
message->m_guard.lock();
message->m_isCall = true;
}
m_pendingMessagesGuard.lock();
m_pendingMessages << MsgEnvelope( type, message );
m_pendingMessagesGuard.unlock();
if ( d->ownerThread == pthread_self() ) {
assert( type != WaitForReply );
deliver();
}
else
m_notifier.notify();
//QThread::postEvent( this, new QCustomEvent( QEvent::User, envelope ) );
if ( type == WaitForReply )
{
message->m_condition.wait( message->m_guard );
message->m_guard.unlock();
}
}
void Channel::deliver()
{
AutoLock lock( m_pendingMessagesGuard );
while ( !m_pendingMessages.isEmpty() ) {
MsgEnvelope envelope = m_pendingMessages.first();
m_pendingMessages.remove( m_pendingMessages.begin() );
m_pendingMessagesGuard.unlock();
deliverOne( envelope );
m_pendingMessagesGuard.lock();
}
}
void Channel::deliverOne( const MsgEnvelope &envelope )
{
ChannelMessage *msg = envelope.msg;
assert( msg );
if ( envelope.type == WaitForReply )
{
msg->m_guard.lock();
msg->m_inEventHandler = true;
}
receiveMessage( msg, envelope.type );
if ( envelope.type == WaitForReply )
{
msg->m_inEventHandler = false;
if ( msg->m_replied )
{
msg->m_condition.wakeOne();
// this is a bit tricky. we unlock only when we reply.
// reply() does an unlock as well.
msg->m_guard.unlock();
}
}
}
/* vim: et sw=4 ts=4
*/
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
*/