kopete/protocols/oscar/liboscar/tasks/task.cpp

   1 /*
   2     task.cpp - Kopete Groupwise Protocol
   3
   4     Copyright (c) 2004      SUSE Linux AG                http://www.suse.com
   5
   6     Based on Iris, Copyright (C) 2003  Justin Karneges
   7
   8     Kopete (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>
   9
  10     *************************************************************************
  11     *                                                                       *
  12     * This library is free software; you can redistribute it and/or         *
  13     * modify it under the terms of the GNU Lesser General Public            *
  14     * License as published by the Free Software Foundation; either          *
  15     * version 2 of the License, or (at your option) any later version.      *
  16     *                                                                       *
  17     *************************************************************************
  18 */
  19
  20 #include <qtimer.h>
  21 #include <qstring.h>
  22 #include <kdebug.h>
  23
  24 #include "connection.h"
  25 #include "transfer.h"
  26 #include "safedelete.h"
  27 #include "buffer.h"
  28 #include "task.h"
  29
  30
  31 class Task::TaskPrivate
  32 {
  33 public:
  34         TaskPrivate() {}
  35
  36         quint32 id;
  37         bool success;
  38         int statusCode;
  39         QString statusString;
  40         Connection* client;
  41         bool insignificant, deleteme, autoDelete;
  42         bool done;
  43         Transfer* transfer;
  44 };
  45
  46 Task::Task(Task *parent)
  47 :QObject(parent)
  48 {
  49         init();
  50         d->client = parent->client();
  51         connect(d->client, SIGNAL(disconnected()), SLOT(clientDisconnected()));
  52 }
  53
  54 Task::Task(Connection* parent, bool)
  55 :QObject(parent)
  56 {
  57         init();
  58         d->client = parent;
  59         connect(d->client, SIGNAL(disconnected()), SLOT(clientDisconnected()));
  60 }
  61
  62 Task::~Task()
  63 {
  64         delete d->transfer;
  65         delete d;
  66 }
  67
  68 void Task::init()
  69 {
  70         d = new TaskPrivate;
  71         d->success = false;
  72         d->insignificant = false;
  73         d->deleteme = false;
  74         d->autoDelete = false;
  75         d->done = false;
  76         d->transfer = 0;
  77         d->id = 0;
  78 }
  79
  80 Task *Task::parent() const
  81 {
  82         return (Task *)QObject::parent();
  83 }
  84
  85 Connection *Task::client() const
  86 {
  87         return d->client;
  88 }
  89
  90 Transfer * Task::transfer() const
  91 {
  92         return d->transfer;
  93 }
  94
  95 void Task::setTransfer( Transfer * transfer )
  96 {
  97         d->transfer = transfer;
  98 }
  99
 100 quint32 Task::id() const
 101 {
 102         return d->id;
 103 }
 104
 105 bool Task::success() const
 106 {
 107         return d->success;
 108 }
 109
 110 int Task::statusCode() const
 111 {
 112         return d->statusCode;
 113 }
 114
 115 const QString & Task::statusString() const
 116 {
 117         return d->statusString;
 118 }
 119
 120 void Task::go(bool autoDelete)
 121 {
 122         d->autoDelete = autoDelete;
 123
 124         onGo();
 125 }
 126
 127 bool Task::take( Transfer * transfer)
 128 {
 129         const QList<Task*> p = findChildren<Task*>();
 130
 131         // pass along the transfer to our children
 132         foreach( Task* t, p)
 133         {
 134                 if ( t->take( transfer ) )
 135                         return true;
 136         }
 137
 138         return false;
 139 }
 140
 141 void Task::safeDelete()
 142 {
 143         if(d->deleteme)
 144                 return;
 145
 146         d->deleteme = true;
 147         if(!d->insignificant)
 148                 SafeDelete::deleteSingle(this);
 149 }
 150
 151 void Task::onGo()
 152 {
 153         qDebug( "ERROR: calling default NULL onGo() for this task, you should reimplement this!");
 154 }
 155
 156 void Task::onDisconnect()
 157 {
 158         if(!d->done) {
 159                 d->success = false;
 160                 d->statusCode = ErrDisc;
 161                 d->statusString = tr("Disconnected");
 162
 163                 // delay this so that tasks that react don't block the shutdown
 164                 QTimer::singleShot(0, this, SLOT(done()));
 165         }
 166 }
 167
 168 void Task::send( Transfer * request )
 169 {
 170         client()->send( request );
 171 }
 172
 173 void Task::setSuccess(int code, const QString &str)
 174 {
 175         if(!d->done) {
 176                 d->success = true;
 177                 d->statusCode = code;
 178                 d->statusString = str;
 179                 done();
 180         }
 181 }
 182
 183 void Task::setError(int code, const QString &str)
 184 {
 185         if(!d->done) {
 186                 d->success = false;
 187                 d->statusCode = code;
 188                 d->statusString = str;
 189                 done();
 190         }
 191 }
 192
 193 void Task::done()
 194 {
 195         kDebug(OSCAR_RAW_DEBUG) << k_funcinfo << endl;
 196         if(d->done || d->insignificant)
 197                 return;
 198         d->done = true;
 199
 200         if(d->deleteme || d->autoDelete)
 201                 d->deleteme = true;
 202
 203         d->insignificant = true;
 204         kDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "emitting finished" << endl;
 205         finished();
 206         d->insignificant = false;
 207
 208         if(d->deleteme)
 209                 SafeDelete::deleteSingle(this);
 210 }
 211
 212 void Task::clientDisconnected()
 213 {
 214         onDisconnect();
 215 }
 216
 217 Transfer* Task::createTransfer( struct FLAP f, struct SNAC s, Buffer* buffer )
 218 {
 219         return new SnacTransfer( f, s, buffer );
 220 }
 221
 222 Transfer* Task::createTransfer( struct FLAP f, Buffer* buffer )
 223 {
 224         return new FlapTransfer( f, buffer );
 225 }
 226
 227 Transfer* Task::createTransfer( Buffer* buffer )
 228 {
 229         return new Transfer( buffer );
 230 }
 231
 232 bool Task::forMe( const Transfer * transfer ) const
 233 {
 234         Q_UNUSED( transfer );
 235         return false;
 236 }
 237
 238 void Task::setId( quint32 id )
 239 {
 240         d->id = id;
 241 }
 242
 243 #include "task.moc"
 244
 245 //kate: tab-width 4; indent-mode csands;
 246