include/transaction.h

Go to the documentation of this file.

// Copyright (C) 2009-2011 by Konrad Rosenbaum <konrad@silmor.de>
// protected under the GNU LGPL version 3 or at your option any newer.
// See COPYING.LGPL file that comes with this distribution.
//

#ifndef WOLF_TRANSACTION_H
#define WOLF_TRANSACTION_H

#include <QObject>
#include <QList>
#include <QString>

#include "nullable.h"
#include "WHelper"
#include <QPointer>

class WTransaction_Private;

class WTransaction:public WHelper
{
        Q_OBJECT
        Q_ENUMS(Stage)
        Q_PROPERTY(Stage stage READ stage)
        Q_PROPERTY(bool isInProgress READ isInProgress)
        Q_PROPERTY(bool isFinished READ isFinished)
        Q_PROPERTY(bool isUnstarted READ isUnstarted)
        Q_PROPERTY(bool hasError READ hasError)
        Q_PROPERTY(QString errorType READ errorType)
        Q_PROPERTY(QString errorString READ errorString)
        Q_PROPERTY(QString interfaceName READ interface)
        public:
                enum Stage {
                        Uninitialized=0,
                        Request=1,
                        Success=6,
                        Error=10,
                };
                
                virtual Stage stage()const;
                virtual bool isInProgress()const{return stage()==Request;}
                virtual bool isFinished()const{return stage()&2;}
                virtual bool isUnstarted()const{return stage()==Uninitialized;}
                
                virtual bool hasError()const;
                virtual QString errorType()const;
                virtual QString errorString()const;
                
                virtual QString interface()const;
                
                virtual ~WTransaction();
                
                class Log;
                class LogWrap;
                
                class WaitFor_Private {
                        public:
                                virtual ~WaitFor_Private(){}
                                WaitFor_Private& operator<<(WTransaction&);
                                WaitFor_Private& operator<<(WTransaction*);
                        protected:
                                WaitFor_Private(int t){m_tmout=t;}
                                virtual void loop()=0;
                                QList<QPointer<WTransaction> > m_trn;
                                int m_tmout;
                };
                
                class WaitForAny:public WaitFor_Private{
                        public:
                                WaitForAny(int tmout=0):WaitFor_Private(tmout){}
                                virtual ~WaitForAny(){loop();}
                        protected:
                                void loop();
                };
                class WaitForAll:public WaitFor_Private{
                        public:
                                WaitForAll(int tmout=0):WaitFor_Private(tmout){}
                                virtual ~WaitForAll(){loop();}
                        protected:
                                void loop();
                };
                
        public slots:
                virtual bool waitForFinished(int tmout=30000);
                
        protected:
                WTransaction(QString iface=QString());
                WTransaction(const WTransaction&);
                
                virtual WTransaction& operator=(const WTransaction&);
                
                virtual QByteArray executeQuery(QString,QByteArray);
                
                virtual void startQuery(QString,QByteArray);
                
                virtual QByteArray encodeError()const;
                
        protected slots:
                virtual void endQuery();
        signals:
                void finished();
        protected:
                friend class WTransaction::Log;
                friend class WTransaction::LogWrap;
                friend class WTransaction_Private;
                WTransaction_Private *d;
};

#endif