chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-06 19:20:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into defaults

Browse Source
This commit is contained in:
Seeker4 2019-07-14 20:28:06 -07:00
commit f6941843e8
6 changed files with 367 additions and 515 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

254
oscar/SleepLib/machine.cpp
View File

@ -38,6 +38,48 @@
extern MainWindow * mainwin; extern MainWindow * mainwin;
//void SaveThread::run()
//{
// bool running = true;
// while (running) {
// Session //sess = machine->popSaveList();
// if (sess) {
// if (machine->m_donetasks % 20 == 0) {
// int i = (float(machine->m_donetasks) / float(machine->m_totaltasks) * 100.0);
// emit UpdateProgress(i);
// }
// sess->UpdateSummaries();
// //machine->saveMutex.lock();
// sess->Store(path);
// //machine->saveMutex.unlock();
//
// sess->TrashEvents();
// } else {
// if (!machine->m_save_threads_running) {
// break; // done
// } else {
// yieldCurrentThread(); // go do something else for a while
// }
// }
// }
//
// machine->savelistSem->release(1);
//}
void SaveTask::run()
{
sess->UpdateSummaries();
mach->saveMutex.lock();
sess->Store(mach->getDataPath());
mach->saveMutex.unlock();
sess->TrashEvents();
}
void LoadTask::run()
{
sess->LoadSummary();
}
////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////
// Machine Base-Class implmementation // Machine Base-Class implmementation
////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////
@ -549,17 +591,10 @@ void Machine::setInfo(MachineInfo inf)
m_loader = GetLoader(inf.loadername); m_loader = GetLoader(inf.loadername);
} }
//const quint32 channel_version=1;
const QString Machine::getDataPath() const QString Machine::getDataPath()
{ {
m_dataPath = p_pref->Get("{home}/Profiles/")+profile->user->userName()+"/"+info.loadername + "_" m_dataPath = p_pref->Get("{home}/Profiles/")+profile->user->userName()+"/"+info.loadername + "_"
+ (info.serial.isEmpty() ? hexid() : info.serial) + "/"; + (info.serial.isEmpty() ? hexid() : info.serial) + "/";
//if (m_dataPath.isEmpty()) {
// m_dataPath = profile->Get("{" + STR_GEN_DataFolder + "}/" + info.loadername + "_" + (info.serial.isEmpty() ? hexid() : info.serial)) + "/";
// }
return m_dataPath; return m_dataPath;
} }
const QString Machine::getSummariesPath() const QString Machine::getSummariesPath()
@ -634,8 +669,6 @@ bool Machine::Load(ProgressDialog *progress)
progress->setProgressValue(0); progress->setProgressValue(0);
QApplication::processEvents(); QApplication::processEvents();
QTime time; QTime time;
time.start(); time.start();
dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks); dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
@ -752,147 +785,20 @@ bool Machine::SaveSession(Session *sess)
return true; return true;
} }
/*void Machine::queSaveList(Session * sess) //Session *Machine::popSaveList()
{ //{
if (!m_save_threads_running) { // Session *sess = nullptr;
// Threads aren't being used.. so run the actual immediately... // listMutex.lock();
//
int i = (float(m_donetasks) / float(m_totaltasks) * 100.0); // if (!m_savelist.isEmpty()) {
//qprogress->setValue(i); // sess = m_savelist.at(0);
//QApplication::processEvents(); // m_savelist.pop_front();
// m_donetasks++;
sess->UpdateSummaries(); // }
sess->Store(getDataPath()); //
// listMutex.unlock();
if (!AppSetting->cacheSessions()) { // return sess;
sess->TrashEvents(); //}
}
} else {
listMutex.lock();
m_savelist.append(sess);
listMutex.unlock();
}
}*/
Session *Machine::popSaveList()
{
Session *sess = nullptr;
listMutex.lock();
if (!m_savelist.isEmpty()) {
sess = m_savelist.at(0);
m_savelist.pop_front();
m_donetasks++;
}
listMutex.unlock();
return sess;
}
/*// Call any time queing starts
void Machine::StartSaveThreads()
{
m_savelist.clear();
if (!AppSetting->multithreading()) return;
QString path = getDataPath();
int threads = QThread::idealThreadCount();
savelistSem = new QSemaphore(threads);
savelistSem->acquire(threads);
m_save_threads_running = true;
m_donetasks=0;
m_totaltasks=0;
for (int i = 0; i < threads; i++) {
SaveThread * thr = new SaveThread(this, path);
QObject::connect(thr, SIGNAL(UpdateProgress(int)), qprogress, SLOT(setValue(int)));
thread.push_back(thr);
thread[i]->start();
}
}
// Call when all queing is completed
void Machine::FinishSaveThreads()
{
if (!m_save_threads_running)
return;
m_save_threads_running = false;
// Wait for all tasks to finish
while (!savelistSem->tryAcquire(thread.size(), 250)) {
if (qprogress) {
QApplication::processEvents();
}
}
for (int i = 0; i < thread.size(); ++i) {
while (thread[i]->isRunning()) {
SaveThread::msleep(250);
QApplication::processEvents();
}
QObject::disconnect(thread[i], SIGNAL(UpdateProgress(int)), qprogress, SLOT(setValue(int)));
delete thread[i];
}
delete savelistSem;
} */
void SaveThread::run()
{
bool running = true;
while (running) {
Session *sess = machine->popSaveList();
if (sess) {
if (machine->m_donetasks % 20 == 0) {
int i = (float(machine->m_donetasks) / float(machine->m_totaltasks) * 100.0);
emit UpdateProgress(i);
}
sess->UpdateSummaries();
//machine->saveMutex.lock();
sess->Store(path);
//machine->saveMutex.unlock();
sess->TrashEvents();
} else {
if (!machine->m_save_threads_running) {
break; // done
} else {
yieldCurrentThread(); // go do something else for a while
}
}
}
machine->savelistSem->release(1);
}
class SaveTask:public ImportTask
{
public:
SaveTask(Session * s, Machine * m): sess(s), mach(m) {}
virtual ~SaveTask() {}
virtual void run();
protected:
Session * sess;
Machine * mach;
};
void SaveTask::run()
{
sess->UpdateSummaries();
mach->saveMutex.lock();
sess->Store(mach->getDataPath());
mach->saveMutex.unlock();
sess->TrashEvents();
}
void Machine::queTask(ImportTask * task) void Machine::queTask(ImportTask * task)
{ {
@ -913,24 +819,23 @@ void Machine::runTasks()
QThreadPool * threadpool = QThreadPool::globalInstance(); QThreadPool * threadpool = QThreadPool::globalInstance();
/*********************************************************** /***********************************************************
int m_totaltasks=m_tasklist.size(); // int m_totaltasks=m_tasklist.size();
int m_currenttask=0; // int m_currenttask=0;
if (loader()) // if (loader())
emit loader()->setProgressMax(m_totaltasks); // emit loader()->setProgressMax(m_totaltasks);
***********************************************************/ ***********************************************************/
while (!m_tasklist.isEmpty()) { while (!m_tasklist.isEmpty()) {
if (threadpool->tryStart(m_tasklist.at(0))) { if (threadpool->tryStart(m_tasklist.at(0))) {
m_tasklist.pop_front(); m_tasklist.pop_front();
/************************************************************ /************************************************************
if (loader()) { // if (loader()) {
emit loader()->setProgressValue(++m_currenttask); // emit loader()->setProgressValue(++m_currenttask);
QApplication::processEvents(); // QApplication::processEvents();
} // }
***************************************************************/ ***************************************************************/
} }
} }
QThreadPool::globalInstance()->waitForDone(-1); QThreadPool::globalInstance()->waitForDone(-1);
} }
bool Machine::hasModifiedSessions() bool Machine::hasModifiedSessions()
@ -948,23 +853,6 @@ bool Machine::hasModifiedSessions()
const QString summaryFileName = "Summaries.xml"; const QString summaryFileName = "Summaries.xml";
const int summaryxml_version=1; const int summaryxml_version=1;
class LoadTask:public ImportTask
{
public:
LoadTask(Session * s, Machine * m): sess(s), mach(m) {}
virtual ~LoadTask() {}
virtual void run();
protected:
Session * sess;
Machine * mach;
};
void LoadTask::run()
{
sess->LoadSummary();
}
bool Machine::LoadSummary(ProgressDialog * progress) bool Machine::LoadSummary(ProgressDialog * progress)
{ {
QTime time; QTime time;
@ -1073,7 +961,6 @@ bool Machine::LoadSummary(ProgressDialog * progress)
} }
QMap<qint64, Session *>::iterator it_end = sess_order.end(); QMap<qint64, Session *>::iterator it_end = sess_order.end();
QMap<qint64, Session *>::iterator it; QMap<qint64, Session *>::iterator it;
int cnt = 0;
bool loadSummaries = profile->session->preloadSummaries(); bool loadSummaries = profile->session->preloadSummaries();
qDebug() << "PreloadSummaries is" << (loadSummaries ? "true" : "false"); qDebug() << "PreloadSummaries is" << (loadSummaries ? "true" : "false");
qDebug() << "Queue task loader is" << (loader() ? "" : "not ") << "available"; qDebug() << "Queue task loader is" << (loader() ? "" : "not ") << "available";
@ -1081,15 +968,16 @@ bool Machine::LoadSummary(ProgressDialog * progress)
// progress->setMessage(QObject::tr("Queueing Open Tasks")); // progress->setMessage(QObject::tr("Queueing Open Tasks"));
// QApplication::processEvents(); // QApplication::processEvents();
// int cnt = 0;
// progress->setMaximum(sess_order.size()); // progress->setMaximum(sess_order.size());
for (it = sess_order.begin(); it != it_end; ++it, ++cnt) { for (it = sess_order.begin(); it != it_end; ++it /*, ++cnt*/ ) {
/**************************************************************** /****************************************************************
if ((cnt % 100) == 0) { // if ((cnt % 100) == 0) {
progress->setValue(cnt); // progress->setValue(cnt);
//QApplication::processEvents(); // //QApplication::processEvents();
} // }
*****************************************************************/ *****************************************************************/
Session * sess = it.value(); Session * sess = it.value();
if (!AddSession(sess)) { if (!AddSession(sess)) {
@ -1212,7 +1100,7 @@ bool Machine::Save()
QHash<SessionID, Session *>::iterator s; QHash<SessionID, Session *>::iterator s;
m_savelist.clear(); // m_savelist.clear();
// store any event summaries.. // store any event summaries..
for (s = sessionlist.begin(); s != sessionlist.end(); s++) { for (s = sessionlist.begin(); s != sessionlist.end(); s++) {

188
oscar/SleepLib/machine.h
View File

@ -41,24 +41,24 @@ class Machine;
/*! \class SaveThread /*! \class SaveThread
\brief This class is used in the multithreaded save code.. It accelerates the indexing of summary data. \brief This class is used in the multithreaded save code.. It accelerates the indexing of summary data.
*/ */
class SaveThread: public QThread //class SaveThread: public QThread
{ //{
Q_OBJECT // Q_OBJECT
public: // public:
SaveThread(Machine *m, QString p) { machine = m; path = p; } // SaveThread(Machine *m, QString p) { machine = m; path = p; }
//
//! \brief Static millisecond sleep function.. Can be used from anywhere // //! \brief Static millisecond sleep function.. Can be used from anywhere
static void msleep(unsigned long msecs) { QThread::msleep(msecs); } // static void msleep(unsigned long msecs) { QThread::msleep(msecs); }
//
//! \brief Start Save processing thread running // //! \brief Start Save processing thread running
virtual void run(); // virtual void run();
protected: // protected:
Machine *machine; // Machine *machine;
QString path; // QString path;
signals: // signals:
//! \brief Signal sent to update the Progress Bar // //! \brief Signal sent to update the Progress Bar
void UpdateProgress(int i); // void UpdateProgress(int i);
}; //};
class ImportTask:public QRunnable class ImportTask:public QRunnable
{ {
@ -68,15 +68,39 @@ public:
virtual void run() {} virtual void run() {}
}; };
class MachineLoader; class SaveTask:public ImportTask
{
public:
SaveTask(Session * s, Machine * m): sess(s), mach(m) {}
virtual ~SaveTask() {}
virtual void run();
protected:
Session * sess;
Machine * mach;
};
class LoadTask:public ImportTask
{
public:
LoadTask(Session * s, Machine * m): sess(s), mach(m) {}
virtual ~LoadTask() {}
virtual void run();
protected:
Session * sess;
Machine * mach;
};
class MachineLoader; // forward
/*! \class Machine /*! \class Machine
\brief This Machine class is the Heart of SleepyLib, representing a single Machine and holding it's data \brief This Machine class is the Heart of SleepyLib, representing a single Machine and holding it's data
*/ */
class Machine class Machine
{ {
friend class SaveThread; friend class SaveThread;
friend class MachineLaoder; // friend class MachineLaoder;
public: public:
/*! \fn Machine(MachineID id=0); /*! \fn Machine(MachineID id=0);
@ -115,15 +139,6 @@ class Machine
return m_availableSettings.contains(code); return m_availableSettings.contains(code);
} }
//! \brief Contains a secondary index of day data, containing just this machines sessions
QMap<QDate, Day *> day;
//! \brief Contains all sessions for this machine, indexed by SessionID
QHash<SessionID, Session *> sessionlist;
//! \brief List of text machine properties, like brand, model, etc...
QHash<QString, QString> properties;
//! \brief Returns a pointer to a valid Session object if SessionID exists //! \brief Returns a pointer to a valid Session object if SessionID exists
Session *SessionExists(SessionID session); Session *SessionExists(SessionID session);
@ -160,50 +175,13 @@ class Machine
//! \brief Returns the date of the most recent loaded Session //! \brief Returns the date of the most recent loaded Session
const QDate &LastDay() { return lastday; } const QDate &LastDay() { return lastday; }
// //! \brief Add a new task to the multithreaded save code
//void queSaveList(Session * sess);
bool hasModifiedSessions(); bool hasModifiedSessions();
//! \brief Grab the next task in the multithreaded save code
Session *popSaveList();
// //! \brief Start the save threads which handle indexing, file storage and waveform processing
//void StartSaveThreads();
// //! \brief Finish the save threads and safely close them
//void FinishSaveThreads();
//! \brief The list of sessions that need saving (for multithreaded save code)
QList<Session *> m_savelist;
//yuck
QVector<SaveThread *>thread;
volatile int savelistCnt;
int savelistSize;
QMutex listMutex;
QSemaphore *savelistSem;
bool m_unsupported;
bool m_untested;
bool unsupported() { return m_unsupported; } bool unsupported() { return m_unsupported; }
void setUnsupported(bool b) { m_unsupported = b; } void setUnsupported(bool b) { m_unsupported = b; }
bool untested() { return m_untested; } bool untested() { return m_untested; }
void setUntested(bool b) { m_untested = b; } void setUntested(bool b) { m_untested = b; }
void lockSaveMutex() { listMutex.lock(); }
void unlockSaveMutex() { listMutex.unlock(); }
void skipSaveTask() { lockSaveMutex(); m_donetasks++; unlockSaveMutex(); }
void clearSkipped() { skipped_sessions = 0; }
int skippedSessions() { return skipped_sessions; }
inline int totalTasks() { return m_totaltasks; }
inline void setTotalTasks(int value) { m_totaltasks = value; }
inline int doneTasks() { return m_donetasks; }
inline MachineType type() const { return info.type; } inline MachineType type() const { return info.type; }
inline QString brand() const { return info.brand; } inline QString brand() const { return info.brand; }
inline QString loaderName() const { return info.loadername; } inline QString loaderName() const { return info.loadername; }
@ -231,23 +209,69 @@ class Machine
MachineLoader * loader() { return m_loader; } MachineLoader * loader() { return m_loader; }
// much more simpler multithreading...
void queTask(ImportTask * task);
void runTasks();
QMutex saveMutex;
void setInfo(MachineInfo inf); void setInfo(MachineInfo inf);
const MachineInfo getInfo() { return info; } const MachineInfo getInfo() { return info; }
void updateChannels(Session * sess); void updateChannels(Session * sess);
QString getPixmapPath(); QString getPixmapPath();
QPixmap & getPixmap(); QPixmap & getPixmap();
// //! \brief The multi-threading methods follow
// //! \brief Add a new task to the multithreaded save code
//void queSaveList(Session * sess);
//! \brief Grab the next task in the multithreaded save code
//Session *popSaveList();
// //! \brief Start the save threads which handle indexing, file storage and waveform processing
//void StartSaveThreads();
// //! \brief Finish the save threads and safely close them
//void FinishSaveThreads();
// void lockSaveMutex() { listMutex.lock(); }
// void unlockSaveMutex() { listMutex.unlock(); }
// void skipSaveTask() { lockSaveMutex(); m_donetasks++; unlockSaveMutex(); }
//
// void clearSkipped() { skipped_sessions = 0; }
// int skippedSessions() { return skipped_sessions; }
//
// inline int totalTasks() { return m_totaltasks; }
// inline void setTotalTasks(int value) { m_totaltasks = value; }
// inline int doneTasks() { return m_donetasks; }
// much more simpler multithreading...(no such thing - pholynyk)
void queTask(ImportTask * task);
void runTasks();
// Public Data Members follow
MachineInfo info; MachineInfo info;
protected: bool m_unsupported;
bool m_untested;
//! \brief Contains a secondary index of day data, containing just this machines sessions
QMap<QDate, Day *> day;
//! \brief Contains all sessions for this machine, indexed by SessionID
QHash<SessionID, Session *> sessionlist;
//! \brief List of text machine properties, like brand, model, etc...
QHash<QString, QString> properties;
//! \brief The list of sessions that need saving (for multithreaded save code)
// QList<Session *> m_savelist;
// Following are the items related to multi-threading
// QVector<SaveThread *>thread;
// volatile int savelistCnt;
// int savelistSize;
QMutex listMutex;
QMutex saveMutex;
// QSemaphore *savelistSem;
protected: // only Data Memebers here
QDate firstday, lastday; QDate firstday, lastday;
SessionID highest_sessionid; SessionID highest_sessionid;
MachineID m_id; MachineID m_id;
@ -258,13 +282,6 @@ class Machine
bool changed; bool changed;
bool firstsession; bool firstsession;
int m_totaltasks;
int m_donetasks;
int skipped_sessions;
volatile bool m_save_threads_running;
QList<ImportTask *> m_tasklist;
QHash<ChannelID, bool> m_availableChannels; QHash<ChannelID, bool> m_availableChannels;
QHash<ChannelID, bool> m_availableSettings; QHash<ChannelID, bool> m_availableSettings;
@ -274,6 +291,15 @@ class Machine
QString m_dataPath; QString m_dataPath;
Profile * profile; Profile * profile;
// The following are the multi-threading data members
int m_totaltasks;
int m_donetasks;
int skipped_sessions;
volatile bool m_save_threads_running;
QList<ImportTask *> m_tasklist;
}; };

331
oscar/SleepLib/machine_loader.cpp
View File

@ -1,5 +1,6 @@
/* SleepLib Machine Loader Class Implementation /* SleepLib Machine Loader Class Implementation
* *
* Copyright (c) 2019 The OSCAR Team
* Copyright (c) 2011-2018 Mark Watkins <mark@jedimark.net> * Copyright (c) 2011-2018 Mark Watkins <mark@jedimark.net>
* *
* This file is subject to the terms and conditions of the GNU General Public * This file is subject to the terms and conditions of the GNU General Public
@ -13,11 +14,139 @@
#include "machine_loader.h" #include "machine_loader.h"
// GLOBALS:
bool genpixmapinit = false; bool genpixmapinit = false;
QList<MachineLoader *> m_loaders;
QPixmap * MachineLoader::genericCPAPPixmap; QPixmap * MachineLoader::genericCPAPPixmap;
// This crap moves to Profile MachineLoader::MachineLoader() :QObject(nullptr)
QList<MachineLoader *> m_loaders; {
#ifndef UNITTEST_MODE // no QPixmap without a QGuiApplication
if (!genpixmapinit) {
genericCPAPPixmap = new QPixmap(genericPixmapPath);
genpixmapinit = true;
}
#endif
m_abort = false;
m_type = MT_UNKNOWN;
m_status = NEUTRAL;
}
MachineLoader::~MachineLoader()
{
}
void MachineLoader::unsupported(Machine * m)
{
if (m == nullptr) {
qCritical("MachineLoader::unsupported(Machine *) called with null machine object");
return;
}
m->setUnsupported(true);
emit machineUnsupported(m);
}
void MachineLoader::addSession(Session * sess)
{
sessionMutex.lock();
new_sessions[sess->session()] = sess;
sessionMutex.unlock();
}
void MachineLoader::finishAddingSessions()
{
// Using a map specifically so they are inserted in order.
for (auto it=new_sessions.begin(), end=new_sessions.end(); it != end; ++it) {
Session * sess = it.value();
Machine * mach = sess->machine();
mach->AddSession(sess);
}
new_sessions.clear();
}
QPixmap & MachineLoader::getPixmap(QString series)
{
QHash<QString, QPixmap>::iterator it = m_pixmaps.find(series);
if (it != m_pixmaps.end()) {
return it.value();
}
return *genericCPAPPixmap;
}
QString MachineLoader::getPixmapPath(QString series)
{
QHash<QString, QString>::iterator it = m_pixmap_paths.find(series);
if (it != m_pixmap_paths.end()) {
return it.value();
}
return genericPixmapPath;
}
void MachineLoader::queTask(ImportTask * task)
{
m_MLtasklist.push_back(task);
}
void MachineLoader::runTasks(bool threaded)
{
m_totalMLtasks=m_MLtasklist.size();
if (m_totalMLtasks == 0)
return;
emit setProgressMax(m_totalMLtasks);
m_currentMLtask=0;
threaded=AppSetting->multithreading();
if (!threaded) {
while (!m_MLtasklist.isEmpty() && !m_abort) {
ImportTask * task = m_MLtasklist.takeFirst();
task->run();
// update progress bar
m_currentMLtask++;
emit setProgressValue(m_currentMLtask);
QApplication::processEvents();
delete task;
}
} else {
ImportTask * task = m_MLtasklist[0];
QThreadPool * threadpool = QThreadPool::globalInstance();
while (!m_abort) {
if (threadpool->tryStart(task)) {
m_MLtasklist.pop_front();
if (!m_MLtasklist.isEmpty()) {
// next task to be run
task = m_MLtasklist[0];
// update progress bar
emit setProgressValue(++m_currentMLtask);
QApplication::processEvents();
} else {
// job list finished
break;
}
}
//QThread::sleep(100);
}
QThreadPool::globalInstance()->waitForDone(-1);
}
if (m_abort) {
// delete remaining tasks and clear task list
for (auto & task : m_MLtasklist) {
delete task;
}
m_MLtasklist.clear();
}
}
QList<MachineLoader *> GetLoaders(MachineType mt) QList<MachineLoader *> GetLoaders(MachineType mt)
{ {
@ -60,6 +189,7 @@ void RegisterLoader(MachineLoader *loader)
loader->initChannels(); loader->initChannels();
m_loaders.push_back(loader); m_loaders.push_back(loader);
} }
void DestroyLoaders() void DestroyLoaders()
{ {
for (auto & loader : m_loaders) { for (auto & loader : m_loaders) {
@ -69,32 +199,23 @@ void DestroyLoaders()
m_loaders.clear(); m_loaders.clear();
} }
MachineLoader::MachineLoader() :QObject(nullptr) QList<ChannelID> CPAPLoader::eventFlags(Day * day)
{ {
#ifndef UNITTEST_MODE // no QPixmap without a QGuiApplication Machine * mach = day->machine(MT_CPAP);
if (!genpixmapinit) {
genericCPAPPixmap = new QPixmap(genericPixmapPath); QList<ChannelID> list;
genpixmapinit = true;
} if (mach->loader() != this) {
#endif qDebug() << "Trying to ask" << loaderName() << "for" << mach->loaderName() << "data";
m_abort = false; return list;
m_type = MT_UNKNOWN;
m_status = NEUTRAL;
} }
MachineLoader::~MachineLoader() list.push_back(CPAP_ClearAirway);
{ list.push_back(CPAP_Obstructive);
} list.push_back(CPAP_Hypopnea);
list.push_back(CPAP_Apnea);
void MachineLoader::finishAddingSessions() return list;
{
// Using a map specifically so they are inserted in order.
for (auto it=new_sessions.begin(), end=new_sessions.end(); it != end; ++it) {
Session * sess = it.value();
Machine * mach = sess->machine();
mach->AddSession(sess);
}
new_sessions.clear();
} }
bool uncompressFile(QString infile, QString outfile) bool uncompressFile(QString infile, QString outfile)
@ -194,165 +315,3 @@ bool compressFile(QString infile, QString outfile)
return true; return true;
} }
void MachineLoader::queTask(ImportTask * task)
{
m_tasklist.push_back(task);
}
void MachineLoader::runTasks(bool threaded)
{
m_totaltasks=m_tasklist.size();
if (m_totaltasks == 0) return;
emit setProgressMax(m_totaltasks);
m_currenttask=0;
threaded=AppSetting->multithreading();
if (!threaded) {
while (!m_tasklist.isEmpty() && !m_abort) {
ImportTask * task = m_tasklist.takeFirst();
task->run();
// update progress bar
m_currenttask++;
emit setProgressValue(++m_currenttask);
QApplication::processEvents();
delete task;
}
} else {
ImportTask * task = m_tasklist[0];
QThreadPool * threadpool = QThreadPool::globalInstance();
while (!m_abort) {
if (threadpool->tryStart(task)) {
m_tasklist.pop_front();
if (!m_tasklist.isEmpty()) {
// next task to be run
task = m_tasklist[0];
// update progress bar
emit setProgressValue(++m_currenttask);
QApplication::processEvents();
} else {
// job list finished
break;
}
}
//QThread::sleep(100);
}
QThreadPool::globalInstance()->waitForDone(-1);
}
if (m_abort) {
// delete remaining tasks and clear task list
for (auto & task : m_tasklist) {
delete task;
}
m_tasklist.clear();
}
}
QList<ChannelID> CPAPLoader::eventFlags(Day * day)
{
Machine * mach = day->machine(MT_CPAP);
QList<ChannelID> list;
if (mach->loader() != this) {
qDebug() << "Trying to ask" << loaderName() << "for" << mach->loaderName() << "data";
return list;
}
list.push_back(CPAP_ClearAirway);
list.push_back(CPAP_Obstructive);
list.push_back(CPAP_Hypopnea);
list.push_back(CPAP_Apnea);
return list;
}
/*const QString machine_profile_name="MachineList.xml";
void MachineLoader::LoadMachineList()
{
}
void MachineLoader::StoreMachineList()
{
}
void MachineLoader::LoadSummary(Machine *m, QString &filename)
{
QFile f(filename);
if (!f.exists())
return;
f.open(QIODevice::ReadOnly);
if (!f.isReadable())
return;
}
void MachineLoader::LoadSummaries(Machine *m)
{
QString path=(*profile)["ProfileDirectory"]+"/"+m_classname+"/"+mach->hexid();
QDir dir(path);
if (!dir.exists() || !dir.isReadable())
return false;
dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Name);
QString fullpath,ext_s,sesstr;
int ext;
SessionID sessid;
bool ok;
QMap<SessionID, int> sessions;
QFileInfoList list=dir.entryInfoList();
for (int i=0;i<list.size();i++) {
QFileInfo fi=list.at(i);
fullpath=fi.canonicalFilePath();
ext_s=fi.fileName().section(".",-1);
ext=ext_s.toInt(&ok,10);
if (!ok) continue;
sesstr=fi.fileName().section(".",0,-2);
sessid=sesstr.toLong(&ok,16);
if (!ok) continue;
}
}
void MachineLoader::LoadAllSummaries()
{
for (int i=0;i<m_machlist.size();i++)
LoadSummaries(m_machlist[i]);
}
void MachineLoader::LoadAllEvents()
{
for (int i=0;i<m_machlist.size();i++)
LoadEvents(m_machlist[i]);
}
void MachineLoader::LoadAllWaveforms()
{
for (int i=0;i<m_machlist.size();i++)
LoadWaveforms(m_machlist[i]);
}
void MachineLoader::LoadAll()
{
LoadAllSummaries();
LoadAllEvents();
LoadAllWaveforms();
}
void MachineLoader::Save(Machine *m)
{
}
void MachineLoader::SaveAll()
{
for (int i=0;i<m_machlist.size();i++)
Save(m_machlist[i]);
}
*/

99
oscar/SleepLib/machine_loader.h
View File

@ -1,5 +1,6 @@
/* SleepLib MachineLoader Base Class Header /* SleepLib MachineLoader Base Class Header
* *
* Copyright (c) 2019 The OSCAR Team
* Copyright (c) 2018 Mark Watkins <mark@jedimark.net> * Copyright (c) 2018 Mark Watkins <mark@jedimark.net>
* *
* This file is subject to the terms and conditions of the GNU General Public * This file is subject to the terms and conditions of the GNU General Public
@ -27,7 +28,8 @@
#define protected public #define protected public
#endif #endif
class MachineLoader; class MachineLoader; // forward
enum DeviceStatus { NEUTRAL, IMPORTING, LIVE, DETECTING }; enum DeviceStatus { NEUTRAL, IMPORTING, LIVE, DETECTING };
const QString genericPixmapPath = ":/icons/mask.png"; const QString genericPixmapPath = ":/icons/mask.png";
@ -62,58 +64,33 @@ class MachineLoader: public QObject
//! \brief Override to returns the class name of this MachineLoader //! \brief Override to returns the class name of this MachineLoader
virtual const QString & loaderName() = 0; virtual const QString & loaderName() = 0;
inline MachineType type() { return m_type; }
void unsupported(Machine * m) {
if (m == nullptr) {
qCritical("MachineLoader::unsupported(Machine *) called with null machine object");
return;
}
m->setUnsupported(true);
emit machineUnsupported(m);
}
void queTask(ImportTask * task);
void addSession(Session * sess)
{
sessionMutex.lock();
new_sessions[sess->session()] = sess;
sessionMutex.unlock();
}
//! \brief Process Task list using all available threads.
void runTasks(bool threaded=true);
int countTasks() { return m_tasklist.size(); }
inline bool isAborted() { return m_abort; }
void abort() { m_abort = true; }
virtual void process() {} virtual void process() {}
DeviceStatus status() { return m_status; } virtual void initChannels() {}
void setStatus(DeviceStatus status) { m_status = status; }
void unsupported(Machine * m);
void addSession(Session * sess);
inline MachineType type() { return m_type; }
inline DeviceStatus status() { return m_status; }
inline void setStatus(DeviceStatus status) { m_status = status; }
QPixmap & getPixmap(QString series);
QString getPixmapPath(QString series);
void queTask(ImportTask * task);
//! \brief Process Task list using all available threads.
void runTasks(bool threaded = false);
inline int countTasks() { return m_MLtasklist.size(); }
inline bool isAborted() { return m_abort; }
inline void abort() { m_abort = true; }
QMutex sessionMutex; QMutex sessionMutex;
QMutex saveMutex; QMutex saveMutex;
virtual void initChannels() {}
QPixmap & getPixmap(QString series) {
QHash<QString, QPixmap>::iterator it = m_pixmaps.find(series);
if (it != m_pixmaps.end()) {
return it.value();
}
return *genericCPAPPixmap;
}
QString getPixmapPath(QString series) {
QHash<QString, QString>::iterator it = m_pixmap_paths.find(series);
if (it != m_pixmap_paths.end()) {
return it.value();
}
return genericPixmapPath;
}
public slots: public slots:
void abortImport() { abort(); } void abortImport() { abort(); }
@ -125,27 +102,26 @@ signals:
void machineUnsupported(Machine *); void machineUnsupported(Machine *);
protected: protected:
void finishAddingSessions();
static QPixmap * genericCPAPPixmap; static QPixmap * genericCPAPPixmap;
MachineType m_type; int m_currentMLtask;
QString m_class; int m_totalMLtasks;
int m_currenttask;
int m_totaltasks;
bool m_abort; bool m_abort;
DeviceStatus m_status; DeviceStatus m_status;
MachineType m_type;
QString m_class;
void finishAddingSessions();
QMap<SessionID, Session *> new_sessions; QMap<SessionID, Session *> new_sessions;
QHash<QString, QPixmap> m_pixmaps; QHash<QString, QPixmap> m_pixmaps;
QHash<QString, QString> m_pixmap_paths; QHash<QString, QString> m_pixmap_paths;
private: private:
QList<ImportTask *> m_tasklist; QList<ImportTask *> m_MLtasklist;
}; };
class CPAPLoader:public MachineLoader class CPAPLoader:public MachineLoader
@ -167,15 +143,17 @@ public:
}; };
struct ImportPath class ImportPath
{ {
public:
ImportPath() { ImportPath() {
path = QString();
loader = nullptr; loader = nullptr;
} }
ImportPath(const ImportPath & copy) { // ImportPath(const ImportPath & copy) {
loader = copy.loader; // loader = copy.loader;
path = copy.path; // path = copy.path;
} // }
ImportPath(QString path, MachineLoader * loader) : ImportPath(QString path, MachineLoader * loader) :
path(path), loader(loader) {} path(path), loader(loader) {}
@ -186,14 +164,15 @@ struct ImportPath
// Put in machine loader class as static?? // Put in machine loader class as static??
void RegisterLoader(MachineLoader *loader); void RegisterLoader(MachineLoader *loader);
QList<MachineLoader *> GetLoaders(MachineType mt = MT_UNKNOWN);
MachineLoader * lookupLoader(Machine * m); MachineLoader * lookupLoader(Machine * m);
MachineLoader * lookupLoader(QString loaderName); MachineLoader * lookupLoader(QString loaderName);
void DestroyLoaders(); void DestroyLoaders();
// Why here? Where are these called?
bool compressFile(QString inpath, QString outpath = ""); bool compressFile(QString inpath, QString outpath = "");
bool uncompressFile(QString infile, QString outfile); bool uncompressFile(QString infile, QString outfile);
QList<MachineLoader *> GetLoaders(MachineType mt = MT_UNKNOWN);
#endif //MACHINE_LOADER_H #endif //MACHINE_LOADER_H

2
oscar/main.cpp
View File

@ -308,7 +308,7 @@ int main(int argc, char *argv[]) {
QString datadir ; QString datadir ;
if ((i+1) < args.size()) { if ((i+1) < args.size()) {
datadir = args[++i]; datadir = args[++i];
if (datadir.length() < 2 || datadir.at(1) != ":") // Allow a Windows drive letter (but not UNC) if (datadir.length() < 2 || datadir.at(1) != QLatin1Char(':')) // Allow a Windows drive letter (but not UNC)
datadir = homeDocs+datadir; datadir = homeDocs+datadir;
settings.setValue("Settings/AppData", datadir); settings.setValue("Settings/AppData", datadir);
// force_data_dir = true; // force_data_dir = true;

6
oscar/tests/prs1tests.cpp
View File

@ -93,10 +93,10 @@ void parseAndEmitSessionYaml(const QString & path)
s_loader->ScanFiles(paths, sessionid_base, m); s_loader->ScanFiles(paths, sessionid_base, m);
// Each session now has a PRS1Import object in m_tasklist // Each session now has a PRS1Import object in m_MLtasklist
QList<ImportTask*>::iterator i; QList<ImportTask*>::iterator i;
while (!s_loader->m_tasklist.isEmpty()) { while (!s_loader->m_MLtasklist.isEmpty()) {
ImportTask* task = s_loader->m_tasklist.takeFirst(); ImportTask* task = s_loader->m_MLtasklist.takeFirst();
// Run the parser // Run the parser
PRS1Import* import = dynamic_cast<PRS1Import*>(task); PRS1Import* import = dynamic_cast<PRS1Import*>(task);