Clean up and refactor; make sure loader releases on destructor (PROPMAN-29)

bweir · bweir · commit e0ebd8d547d0 · 2016-01-26T05:30:01.000-08:00
diff --git a/src/loader/propellerloader.cpp b/src/loader/propellerloader.cpp
@@ -7,8 +7,7 @@
 
 #include "../util/logging.h"
 
-PropellerLoader::PropellerLoader(PropellerManager * manager,
-                                 const QString & portname,
+PropellerLoader::PropellerLoader(PropellerManager * manager, const QString & portname,
                                  QObject * parent)
     : QObject(parent)
 {
@@ -113,6 +112,7 @@ PropellerLoader::PropellerLoader(PropellerManager * manager,
 
 PropellerLoader::~PropellerLoader()
 {
+    session->release();
     delete session;
 }
 
diff --git a/src/manager/propellermanager.cpp b/src/manager/propellermanager.cpp
@@ -141,7 +141,6 @@ void PropellerManager::removeConnection(PropellerSession * session, PropellerDev
 
     if (!_active_sessions[device])
     {
-//        qCDebug(pmanager) << "closing" << _devices.key(device);
         device->close();
     }
 }
@@ -159,18 +158,18 @@ void PropellerManager::removeDevice(QString port)
     _devices.remove(port);
 }
 
-bool PropellerManager::portIsBusy(PropellerSession * session, const QString & name)
+bool PropellerManager::portIsBusy(PropellerSession * session)
 {
-    if (isPaused(session)) return true;
+    QString port = session->portName();
 
-    PropellerDevice * device = getDevice(name, false);
-    if (!_connections.contains(session) || _connections[session] != device) return true;
+    if (isPaused(session)) return true;
 
-//    qDebug() << "CONNECTION" << session << name << device << _connections[session];
+    PropellerDevice * device = getDevice(port, false);
 
+    if (!_connections.contains(session)) return true;
     if (_busy.contains(device) && _busy[device] != session) return true;
 
-    addConnectionByName(session, name);
+    addConnectionByName(session, port);
     return false;
 }
 
@@ -195,10 +194,10 @@ void PropellerManager::restoreConnections(PropellerDevice * device)
     }
 }
 
-bool PropellerManager::reserve(PropellerSession * session, QString port)
+bool PropellerManager::reserve(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return false;
-    PropellerDevice * device = getDevice(port);
+    if (portIsBusy(session)) return false;
+    PropellerDevice * device = getDevice(session->portName());
     _active_sessions[device]++; // prevent port from closing while reserving device
 
     saveConnections(device);
@@ -210,23 +209,23 @@ bool PropellerManager::reserve(PropellerSession * session, QString port)
     return true;
 }
 
-bool PropellerManager::isReserved(PropellerSession * session, QString port)
+bool PropellerManager::isReserved(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return false;
+    if (portIsBusy(session)) return false;
 
-    PropellerDevice * device = getDevice(port);
+    PropellerDevice * device = getDevice(session->portName());
     if (!_busy.contains(device) || _busy[device] != session)
         return false;
 
     return true;
 }
 
 
-void PropellerManager::release(PropellerSession * session, QString port)
+void PropellerManager::release(PropellerSession * session)
 {
-    if (!isReserved(session, port)) return;
+    if (!isReserved(session)) return;
 
-    PropellerDevice * device = getDevice(port);
+    PropellerDevice * device = getDevice(session->portName());
     _active_sessions[device]++;                 // prevent port from closing while releasing device
 
     removeConnection(session, device);
@@ -251,112 +250,112 @@ void PropellerManager::unpause(PropellerSession * session)
     _paused.remove(session);
 }
 
-bool PropellerManager::clear(PropellerSession * session, QString port)
+bool PropellerManager::clear(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return false;
-    return getDevice(port)->clear();
+    if (portIsBusy(session)) return false;
+    return getDevice(session->portName())->clear();
 }
 
-bool PropellerManager::isOpen(PropellerSession * session, QString port)
+bool PropellerManager::isOpen(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return false;
-    return getDevice(port, false)->isOpen();
+    if (portIsBusy(session)) return false;
+    return getDevice(session->portName(), false)->isOpen();
 }
 
-bool PropellerManager::setBaudRate(PropellerSession * session, QString port, quint32 baudRate)
+bool PropellerManager::setBaudRate(PropellerSession * session, quint32 baudRate)
 {
-    if (portIsBusy(session, port)) return false;
-    return getDevice(port)->setBaudRate(baudRate);
+    if (portIsBusy(session)) return false;
+    return getDevice(session->portName())->setBaudRate(baudRate);
 }
 
-qint64 PropellerManager::bytesToWrite(PropellerSession * session, QString port)
+qint64 PropellerManager::bytesToWrite(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return 0;
-    return getDevice(port)->bytesToWrite();
+    if (portIsBusy(session)) return 0;
+    return getDevice(session->portName())->bytesToWrite();
 }
 
-qint64 PropellerManager::bytesAvailable(PropellerSession * session, QString port)
+qint64 PropellerManager::bytesAvailable(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return 0;
+    if (portIsBusy(session)) return 0;
     return _buffers[session]->bytesAvailable();
 }
 
-QByteArray PropellerManager::read(PropellerSession * session, QString port, qint64 maxSize)
+QByteArray PropellerManager::read(PropellerSession * session, qint64 maxSize)
 {
-    if (portIsBusy(session, port)) return QByteArray();
+    if (portIsBusy(session)) return QByteArray();
     return _buffers[session]->read(maxSize);
 }
 
-QByteArray PropellerManager::readAll(PropellerSession * session, QString port)
+QByteArray PropellerManager::readAll(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return QByteArray();
+    if (portIsBusy(session)) return QByteArray();
     return _buffers[session]->readAll();
 }
 
-bool PropellerManager::putChar(PropellerSession * session, QString port, char c)
+bool PropellerManager::putChar(PropellerSession * session, char c)
 {
-    if (portIsBusy(session, port)) return false;
-    return getDevice(port)->putChar(c);
+    if (portIsBusy(session)) return false;
+    return getDevice(session->portName())->putChar(c);
 }
 
-qint64 PropellerManager::write(PropellerSession * session, QString port, const QByteArray & byteArray)
+qint64 PropellerManager::write(PropellerSession * session, const QByteArray & byteArray)
 {
-    if (portIsBusy(session, port)) return -1;
-    return getDevice(port)->write(byteArray);
+    if (portIsBusy(session)) return -1;
+    return getDevice(session->portName())->write(byteArray);
 }
 
-quint32 PropellerManager::minimumTimeout(PropellerSession * session, QString port)
+quint32 PropellerManager::minimumTimeout(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return 0;
-    return getDevice(port)->minimumTimeout();
+    if (portIsBusy(session)) return 0;
+    return getDevice(session->portName())->minimumTimeout();
 }
 
-void PropellerManager::setMinimumTimeout(PropellerSession * session, QString port, quint32 milliseconds)
+void PropellerManager::setMinimumTimeout(PropellerSession * session, quint32 milliseconds)
 {
-    if (portIsBusy(session, port)) return;
-    getDevice(port)->setMinimumTimeout(milliseconds);
+    if (portIsBusy(session)) return;
+    getDevice(session->portName())->setMinimumTimeout(milliseconds);
 }
 
-quint32 PropellerManager::calculateTimeout(PropellerSession * session, QString port, quint32 bytes)
+quint32 PropellerManager::calculateTimeout(PropellerSession * session, quint32 bytes)
 {
-    if (portIsBusy(session, port)) return 0;
-    return getDevice(port)->calculateTimeout(bytes);
+    if (portIsBusy(session)) return 0;
+    return getDevice(session->portName())->calculateTimeout(bytes);
 }
 
-void PropellerManager::useReset(PropellerSession * session, QString port, QString name, int pin)
+void PropellerManager::useReset(PropellerSession * session, QString name, int pin)
 {
-    if (portIsBusy(session, port)) return;
-    getDevice(port)->useReset(name, pin);
+    if (portIsBusy(session)) return;
+    getDevice(session->portName())->useReset(name, pin);
 }
 
-void PropellerManager::useDefaultReset(PropellerSession * session, QString port)
+void PropellerManager::useDefaultReset(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return;
-    return getDevice(port)->useDefaultReset();
+    if (portIsBusy(session)) return;
+    return getDevice(session->portName())->useDefaultReset();
 }
 
-bool PropellerManager::reset(PropellerSession * session, QString port)
+bool PropellerManager::reset(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return false;
-    return getDevice(port)->reset();
+    if (portIsBusy(session)) return false;
+    return getDevice(session->portName())->reset();
 }
 
-quint32 PropellerManager::resetPeriod(PropellerSession * session, QString port)
+quint32 PropellerManager::resetPeriod(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return 0;
-    return getDevice(port)->resetPeriod();
+    if (portIsBusy(session)) return 0;
+    return getDevice(session->portName())->resetPeriod();
 }
 
-int PropellerManager::error(PropellerSession * session, QString port)
+int PropellerManager::error(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return 0;
-    return getDevice(port)->error();
+    if (portIsBusy(session)) return 0;
+    return getDevice(session->portName())->error();
 }
 
-QString PropellerManager::errorString(PropellerSession * session, QString port)
+QString PropellerManager::errorString(PropellerSession * session)
 {
-    if (portIsBusy(session, port)) return QString();
-    return getDevice(port)->errorString();
+    if (portIsBusy(session)) return QString();
+    return getDevice(session->portName())->errorString();
 }
 
 QStringList PropellerManager::listPorts()
diff --git a/src/manager/propellermanager.h b/src/manager/propellermanager.h
@@ -107,7 +107,7 @@ class PropellerManager : public QObject
     void addConnection (PropellerSession * session, PropellerDevice * device);
     void addConnectionByName (PropellerSession * session, QString port);
     void removeConnection (PropellerSession * session, PropellerDevice * device);
-    bool portIsBusy (PropellerSession * session, const QString & name);
+    bool portIsBusy (PropellerSession * session);
 
     void saveConnections (PropellerDevice * device);
     void restoreConnections (PropellerDevice * device);
@@ -129,33 +129,33 @@ private slots:
     bool        beginSession(PropellerSession * session);
     void        endSession(PropellerSession * session);
 
-    bool        isOpen(PropellerSession * session, QString port);
-    bool        clear(PropellerSession * session, QString port);
+    bool        isOpen(PropellerSession * session);
+    bool        clear(PropellerSession * session);
 
-    bool        setBaudRate(PropellerSession * session, QString port, quint32 baudRate);
+    bool        setBaudRate(PropellerSession * session, quint32 baudRate);
 
-    qint64      bytesToWrite(PropellerSession * session, QString port);
-    qint64      bytesAvailable(PropellerSession * session, QString port);
+    qint64      bytesToWrite(PropellerSession * session);
+    qint64      bytesAvailable(PropellerSession * session);
 
-    QByteArray  read(PropellerSession * session, QString port, qint64 maxSize);
-    QByteArray  readAll(PropellerSession * session, QString port);
+    QByteArray  read(PropellerSession * session, qint64 maxSize);
+    QByteArray  readAll(PropellerSession * session);
 
-    bool        putChar(PropellerSession * session, QString port, char c);
-    qint64      write(PropellerSession * session, QString port, const QByteArray & byteArray);
-    QString     errorString(PropellerSession * session, QString port);
-    int         error(PropellerSession * session, QString port);
+    bool        putChar(PropellerSession * session, char c);
+    qint64      write(PropellerSession * session, const QByteArray & byteArray);
+    QString     errorString(PropellerSession * session);
+    int         error(PropellerSession * session);
 
-    quint32     minimumTimeout(PropellerSession * session, QString port);
-    void        setMinimumTimeout(PropellerSession * session, QString port, quint32 milliseconds);
-    quint32     calculateTimeout(PropellerSession * session, QString port, quint32 bytes);
-    void        useReset(PropellerSession * session, QString port, QString name, int pin);
-    void        useDefaultReset(PropellerSession * session, QString port);
-    bool        reset(PropellerSession * session, QString port);
-    quint32     resetPeriod(PropellerSession * session, QString port);
+    quint32     minimumTimeout(PropellerSession * session);
+    void        setMinimumTimeout(PropellerSession * session, quint32 milliseconds);
+    quint32     calculateTimeout(PropellerSession * session, quint32 bytes);
+    void        useReset(PropellerSession * session, QString name, int pin);
+    void        useDefaultReset(PropellerSession * session);
+    bool        reset(PropellerSession * session);
+    quint32     resetPeriod(PropellerSession * session);
 
-    bool        reserve(PropellerSession * session, QString port);
-    bool        isReserved(PropellerSession * session, QString port);
-    void        release(PropellerSession * session, QString port);
+    bool        reserve(PropellerSession * session);
+    bool        isReserved(PropellerSession * session);
+    void        release(PropellerSession * session);
 
     void        pause(PropellerSession * session);
     bool        isPaused(PropellerSession * session);
diff --git a/src/session/propellersession.cpp b/src/session/propellersession.cpp

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,7 @@`
`7`	`7`
`8`	`8`	`#include "../util/logging.h"`
`9`	`9`
`10`		`-PropellerLoader::PropellerLoader(PropellerManager * manager,`
`11`		`- const QString & portname,`
	`10`	`+PropellerLoader::PropellerLoader(PropellerManager * manager, const QString & portname,`
`12`	`11`	`QObject * parent)`
`13`	`12`	`: QObject(parent)`
`14`	`13`	`{`
`@@ -113,6 +112,7 @@ PropellerLoader::PropellerLoader(PropellerManager * manager,`
`113`	`112`
`114`	`113`	`PropellerLoader::~PropellerLoader()`
`115`	`114`	`{`
	`115`	`+ session->release();`
`116`	`116`	`delete session;`
`117`	`117`	`}`
`118`	`118`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,6 @@ void PropellerManager::removeConnection(PropellerSession * session, PropellerDev`
`141`	`141`
`142`	`142`	`if (!_active_sessions[device])`
`143`	`143`	`{`
`144`		`-// qCDebug(pmanager) << "closing" << _devices.key(device);`
`145`	`144`	`device->close();`
`146`	`145`	`}`
`147`	`146`	`}`
`@@ -159,18 +158,18 @@ void PropellerManager::removeDevice(QString port)`
`159`	`158`	`_devices.remove(port);`
`160`	`159`	`}`
`161`	`160`
`162`		`-bool PropellerManager::portIsBusy(PropellerSession * session, const QString & name)`
	`161`	`+bool PropellerManager::portIsBusy(PropellerSession * session)`
`163`	`162`	`{`
`164`		`- if (isPaused(session)) return true;`
	`163`	`+ QString port = session->portName();`
`165`	`164`
`166`		`- PropellerDevice * device = getDevice(name, false);`
`167`		`- if (!_connections.contains(session) \|\| _connections[session] != device) return true;`
	`165`	`+ if (isPaused(session)) return true;`
`168`	`166`
`169`		`-// qDebug() << "CONNECTION" << session << name << device << _connections[session];`
	`167`	`+ PropellerDevice * device = getDevice(port, false);`
`170`	`168`
	`169`	`+ if (!_connections.contains(session)) return true;`
`171`	`170`	`if (_busy.contains(device) && _busy[device] != session) return true;`
`172`	`171`
`173`		`- addConnectionByName(session, name);`
	`172`	`+ addConnectionByName(session, port);`
`174`	`173`	`return false;`
`175`	`174`	`}`
`176`	`175`
`@@ -195,10 +194,10 @@ void PropellerManager::restoreConnections(PropellerDevice * device)`
`195`	`194`	`}`
`196`	`195`	`}`
`197`	`196`
`198`		`-bool PropellerManager::reserve(PropellerSession * session, QString port)`
	`197`	`+bool PropellerManager::reserve(PropellerSession * session)`
`199`	`198`	`{`
`200`		`- if (portIsBusy(session, port)) return false;`
`201`		`- PropellerDevice * device = getDevice(port);`
	`199`	`+ if (portIsBusy(session)) return false;`
	`200`	`+ PropellerDevice * device = getDevice(session->portName());`
`202`	`201`	`_active_sessions[device]++; // prevent port from closing while reserving device`
`203`	`202`
`204`	`203`	`saveConnections(device);`
`@@ -210,23 +209,23 @@ bool PropellerManager::reserve(PropellerSession * session, QString port)`
`210`	`209`	`return true;`
`211`	`210`	`}`
`212`	`211`
`213`		`-bool PropellerManager::isReserved(PropellerSession * session, QString port)`
	`212`	`+bool PropellerManager::isReserved(PropellerSession * session)`
`214`	`213`	`{`
`215`		`- if (portIsBusy(session, port)) return false;`
	`214`	`+ if (portIsBusy(session)) return false;`
`216`	`215`
`217`		`- PropellerDevice * device = getDevice(port);`
	`216`	`+ PropellerDevice * device = getDevice(session->portName());`
`218`	`217`	`if (!_busy.contains(device) \|\| _busy[device] != session)`
`219`	`218`	`return false;`
`220`	`219`
`221`	`220`	`return true;`
`222`	`221`	`}`
`223`	`222`
`224`	`223`
`225`		`-void PropellerManager::release(PropellerSession * session, QString port)`
	`224`	`+void PropellerManager::release(PropellerSession * session)`
`226`	`225`	`{`
`227`		`- if (!isReserved(session, port)) return;`
	`226`	`+ if (!isReserved(session)) return;`
`228`	`227`
`229`		`- PropellerDevice * device = getDevice(port);`
	`228`	`+ PropellerDevice * device = getDevice(session->portName());`
`230`	`229`	`_active_sessions[device]++; // prevent port from closing while releasing device`
`231`	`230`
`232`	`231`	`removeConnection(session, device);`
`@@ -251,112 +250,112 @@ void PropellerManager::unpause(PropellerSession * session)`
`251`	`250`	`_paused.remove(session);`
`252`	`251`	`}`
`253`	`252`
`254`		`-bool PropellerManager::clear(PropellerSession * session, QString port)`
	`253`	`+bool PropellerManager::clear(PropellerSession * session)`
`255`	`254`	`{`
`256`		`- if (portIsBusy(session, port)) return false;`
`257`		`- return getDevice(port)->clear();`
	`255`	`+ if (portIsBusy(session)) return false;`
	`256`	`+ return getDevice(session->portName())->clear();`
`258`	`257`	`}`
`259`	`258`
`260`		`-bool PropellerManager::isOpen(PropellerSession * session, QString port)`
	`259`	`+bool PropellerManager::isOpen(PropellerSession * session)`
`261`	`260`	`{`
`262`		`- if (portIsBusy(session, port)) return false;`
`263`		`- return getDevice(port, false)->isOpen();`
	`261`	`+ if (portIsBusy(session)) return false;`
	`262`	`+ return getDevice(session->portName(), false)->isOpen();`
`264`	`263`	`}`
`265`	`264`
`266`		`-bool PropellerManager::setBaudRate(PropellerSession * session, QString port, quint32 baudRate)`
	`265`	`+bool PropellerManager::setBaudRate(PropellerSession * session, quint32 baudRate)`
`267`	`266`	`{`
`268`		`- if (portIsBusy(session, port)) return false;`
`269`		`- return getDevice(port)->setBaudRate(baudRate);`
	`267`	`+ if (portIsBusy(session)) return false;`
	`268`	`+ return getDevice(session->portName())->setBaudRate(baudRate);`
`270`	`269`	`}`
`271`	`270`
`272`		`-qint64 PropellerManager::bytesToWrite(PropellerSession * session, QString port)`
	`271`	`+qint64 PropellerManager::bytesToWrite(PropellerSession * session)`
`273`	`272`	`{`
`274`		`- if (portIsBusy(session, port)) return 0;`
`275`		`- return getDevice(port)->bytesToWrite();`
	`273`	`+ if (portIsBusy(session)) return 0;`
	`274`	`+ return getDevice(session->portName())->bytesToWrite();`
`276`	`275`	`}`
`277`	`276`
`278`		`-qint64 PropellerManager::bytesAvailable(PropellerSession * session, QString port)`
	`277`	`+qint64 PropellerManager::bytesAvailable(PropellerSession * session)`
`279`	`278`	`{`
`280`		`- if (portIsBusy(session, port)) return 0;`
	`279`	`+ if (portIsBusy(session)) return 0;`
`281`	`280`	`return _buffers[session]->bytesAvailable();`
`282`	`281`	`}`
`283`	`282`
`284`		`-QByteArray PropellerManager::read(PropellerSession * session, QString port, qint64 maxSize)`
	`283`	`+QByteArray PropellerManager::read(PropellerSession * session, qint64 maxSize)`
`285`	`284`	`{`
`286`		`- if (portIsBusy(session, port)) return QByteArray();`
	`285`	`+ if (portIsBusy(session)) return QByteArray();`
`287`	`286`	`return _buffers[session]->read(maxSize);`
`288`	`287`	`}`
`289`	`288`
`290`		`-QByteArray PropellerManager::readAll(PropellerSession * session, QString port)`
	`289`	`+QByteArray PropellerManager::readAll(PropellerSession * session)`
`291`	`290`	`{`
`292`		`- if (portIsBusy(session, port)) return QByteArray();`
	`291`	`+ if (portIsBusy(session)) return QByteArray();`
`293`	`292`	`return _buffers[session]->readAll();`
`294`	`293`	`}`
`295`	`294`
`296`		`-bool PropellerManager::putChar(PropellerSession * session, QString port, char c)`
	`295`	`+bool PropellerManager::putChar(PropellerSession * session, char c)`
`297`	`296`	`{`
`298`		`- if (portIsBusy(session, port)) return false;`
`299`		`- return getDevice(port)->putChar(c);`
	`297`	`+ if (portIsBusy(session)) return false;`
	`298`	`+ return getDevice(session->portName())->putChar(c);`
`300`	`299`	`}`
`301`	`300`
`302`		`-qint64 PropellerManager::write(PropellerSession * session, QString port, const QByteArray & byteArray)`
	`301`	`+qint64 PropellerManager::write(PropellerSession * session, const QByteArray & byteArray)`
`303`	`302`	`{`
`304`		`- if (portIsBusy(session, port)) return -1;`
`305`		`- return getDevice(port)->write(byteArray);`
	`303`	`+ if (portIsBusy(session)) return -1;`
	`304`	`+ return getDevice(session->portName())->write(byteArray);`
`306`	`305`	`}`
`307`	`306`
`308`		`-quint32 PropellerManager::minimumTimeout(PropellerSession * session, QString port)`
	`307`	`+quint32 PropellerManager::minimumTimeout(PropellerSession * session)`
`309`	`308`	`{`
`310`		`- if (portIsBusy(session, port)) return 0;`
`311`		`- return getDevice(port)->minimumTimeout();`
	`309`	`+ if (portIsBusy(session)) return 0;`
	`310`	`+ return getDevice(session->portName())->minimumTimeout();`
`312`	`311`	`}`
`313`	`312`
`314`		`-void PropellerManager::setMinimumTimeout(PropellerSession * session, QString port, quint32 milliseconds)`
	`313`	`+void PropellerManager::setMinimumTimeout(PropellerSession * session, quint32 milliseconds)`
`315`	`314`	`{`
`316`		`- if (portIsBusy(session, port)) return;`
`317`		`- getDevice(port)->setMinimumTimeout(milliseconds);`
	`315`	`+ if (portIsBusy(session)) return;`
	`316`	`+ getDevice(session->portName())->setMinimumTimeout(milliseconds);`
`318`	`317`	`}`
`319`	`318`
`320`		`-quint32 PropellerManager::calculateTimeout(PropellerSession * session, QString port, quint32 bytes)`
	`319`	`+quint32 PropellerManager::calculateTimeout(PropellerSession * session, quint32 bytes)`
`321`	`320`	`{`
`322`		`- if (portIsBusy(session, port)) return 0;`
`323`		`- return getDevice(port)->calculateTimeout(bytes);`
	`321`	`+ if (portIsBusy(session)) return 0;`
	`322`	`+ return getDevice(session->portName())->calculateTimeout(bytes);`
`324`	`323`	`}`
`325`	`324`
`326`		`-void PropellerManager::useReset(PropellerSession * session, QString port, QString name, int pin)`
	`325`	`+void PropellerManager::useReset(PropellerSession * session, QString name, int pin)`
`327`	`326`	`{`
`328`		`- if (portIsBusy(session, port)) return;`
`329`		`- getDevice(port)->useReset(name, pin);`
	`327`	`+ if (portIsBusy(session)) return;`
	`328`	`+ getDevice(session->portName())->useReset(name, pin);`
`330`	`329`	`}`
`331`	`330`
`332`		`-void PropellerManager::useDefaultReset(PropellerSession * session, QString port)`
	`331`	`+void PropellerManager::useDefaultReset(PropellerSession * session)`
`333`	`332`	`{`
`334`		`- if (portIsBusy(session, port)) return;`
`335`		`- return getDevice(port)->useDefaultReset();`
	`333`	`+ if (portIsBusy(session)) return;`
	`334`	`+ return getDevice(session->portName())->useDefaultReset();`
`336`	`335`	`}`
`337`	`336`
`338`		`-bool PropellerManager::reset(PropellerSession * session, QString port)`
	`337`	`+bool PropellerManager::reset(PropellerSession * session)`
`339`	`338`	`{`
`340`		`- if (portIsBusy(session, port)) return false;`
`341`		`- return getDevice(port)->reset();`
	`339`	`+ if (portIsBusy(session)) return false;`
	`340`	`+ return getDevice(session->portName())->reset();`
`342`	`341`	`}`
`343`	`342`
`344`		`-quint32 PropellerManager::resetPeriod(PropellerSession * session, QString port)`
	`343`	`+quint32 PropellerManager::resetPeriod(PropellerSession * session)`
`345`	`344`	`{`
`346`		`- if (portIsBusy(session, port)) return 0;`
`347`		`- return getDevice(port)->resetPeriod();`
	`345`	`+ if (portIsBusy(session)) return 0;`
	`346`	`+ return getDevice(session->portName())->resetPeriod();`
`348`	`347`	`}`
`349`	`348`
`350`		`-int PropellerManager::error(PropellerSession * session, QString port)`
	`349`	`+int PropellerManager::error(PropellerSession * session)`
`351`	`350`	`{`
`352`		`- if (portIsBusy(session, port)) return 0;`
`353`		`- return getDevice(port)->error();`
	`351`	`+ if (portIsBusy(session)) return 0;`
	`352`	`+ return getDevice(session->portName())->error();`
`354`	`353`	`}`
`355`	`354`
`356`		`-QString PropellerManager::errorString(PropellerSession * session, QString port)`
	`355`	`+QString PropellerManager::errorString(PropellerSession * session)`
`357`	`356`	`{`
`358`		`- if (portIsBusy(session, port)) return QString();`
`359`		`- return getDevice(port)->errorString();`
	`357`	`+ if (portIsBusy(session)) return QString();`
	`358`	`+ return getDevice(session->portName())->errorString();`
`360`	`359`	`}`
`361`	`360`
`362`	`361`	`QStringList PropellerManager::listPorts()`