src/globalsearch/optbase.h

/**********************************************************************
  OptBase - Base class for global search extensions

  Copyright (C) 2010-2011 by David C. Lonie

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation version 2 of the License.

  This program 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 General Public License for more details.
 ***********************************************************************/

#ifndef OPTBASE_H
#define OPTBASE_H

// Prevent redefinition of symbols on windows
#ifdef WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif // WIN32_LEAN_AND_MEAN
#ifndef NOMINMAX
#define NOMINMAX
#endif // NOMINMAX
#endif // WIN32

#include <QtCore/QObject>
#include <QtCore/QMutex>

namespace GlobalSearch {
  class Structure;
  class Tracker;
  class Optimizer;
  class QueueManager;
  class QueueInterface;
  class SSHManager;
  class AbstractDialog;

  class OptBase : public QObject
  {
    Q_OBJECT

   public:
    explicit OptBase(AbstractDialog *parent);

    virtual ~OptBase();

    enum FailActions {
      FA_DoNothing = 0,
      FA_KillIt,
      FA_Randomize,
      FA_NewOffspring
    };

    QString getIDString() {return m_idString;}

    virtual Structure* replaceWithRandom(Structure *s,
                                         const QString & reason = "")
    {return 0;}

    virtual Structure* replaceWithOffspring(Structure *s,
                                            const QString & reason = "")
    {return replaceWithRandom(s, reason);}

    virtual bool checkLimits() = 0;

    virtual bool checkStepOptimizedStructure(Structure *s, QString *err = NULL)
    {
      Q_UNUSED(s);
      Q_UNUSED(err);
      return true;
    }

    static QList<double> getProbabilityList(const QList<Structure*> &structures);

    virtual bool save(const QString & filename = "", bool notify = false);

    virtual bool postSave(const QString &filename) 
    {
      Q_UNUSED(filename);
      return true;
    }

    virtual bool load(const QString & filename,
                      const bool forceReadOnly = false) {
      Q_UNUSED(forceReadOnly);return false;};

    virtual QString interpretTemplate(const QString & templateString,
                                      Structure* structure);

    virtual QString getTemplateKeywordHelp() {
      return getTemplateKeywordHelp_base();};

    AbstractDialog* dialog() {return m_dialog;};

    Tracker* tracker() {return m_tracker;};

    QueueManager* queue() {return m_queue;};

    QueueInterface* queueInterface() {return m_queueInterface;};

    Optimizer* optimizer() {return m_optimizer;};

    SSHManager* ssh() {return m_ssh;};

    bool limitRunningJobs;

    uint runningJobLimit;

    uint contStructs;

    int cutoff;

    bool testingMode;

    uint test_nRunsStart;

    uint test_nRunsEnd;

    uint test_nStructs;

    uint failLimit;

    FailActions failAction;

    QString filePath;

    QString description;

    QString host;

    int port;

    QString username;

    QString rempath;

    QMutex *sOBMutex;

    QMutex *stateFileMutex;

    QMutex *backTraceMutex;

    bool usePreopt;

    bool savePending;

    bool isStarting;

    bool readOnly;

   signals:
    void startingSession();

    void sessionStarted();

    void readOnlySessionStarted();

    void queueInterfaceChanged(QueueInterface*);

    void optimizerChanged(Optimizer*);

    void debugStatement(const QString &s);

    void warningStatement(const QString &s);

    void errorStatement(const QString &s);

    void needBoolean(const QString &message, bool *ok);

    void needPassword(const QString &message, QString *newPassword, bool *ok);

    void refreshAllStructureInfo();

    // Omit the following from doxygen:
    void sig_setClipboard(const QString &text) const;

   public slots:

    virtual void reset();

#ifdef ENABLE_SSH

    virtual bool createSSHConnections();
#endif // ENABLE_SSH

    virtual void startSearch() = 0;

    virtual void generateNewStructure() {};

    virtual void preoptimizeStructure(Structure *s) {}

    void debug(const QString & s);

    void warning(const QString & s);

    void error(const QString & s);

    void emitSessionStarted() {emit sessionStarted();};

    void emitReadOnlySessionStarted() {emit readOnlySessionStarted();};

    void emitStartingSession() {emit startingSession();};

    void setIsStartingTrue() {isStarting = true;};

    void setIsStartingFalse() {isStarting = false;};

    void setReadOnlyTrue() {readOnly = true;};

    void setReadOnlyFalse() {readOnly = false;};

    void printBackTrace();

    void setQueueInterface(QueueInterface *q);

    void setOptimizer(Optimizer *o);

    void promptForBoolean(const QString &message, bool *ok = 0);

    void promptForPassword(const QString &message, QString *newPassword, bool *ok = 0);

    void setClipboard(const QString &text) const;

  protected slots:
    // Disable doxygen parser here:
    void setClipboard_(const QString &text) const;

#ifdef ENABLE_SSH
#ifndef USE_CLI_SSH

    bool createSSHConnections_libssh();

#else // not USE_CLI_SSH

    bool createSSHConnections_cli();

#endif // not USE_CLI_SSH
#endif // ENABLE_SSH
  protected:
    QString m_idString;

    SSHManager *m_ssh;

    AbstractDialog *m_dialog;

    Tracker *m_tracker;

    QThread *m_queueThread;

    QueueManager *m_queue;

    QueueInterface *m_queueInterface;

    Optimizer *m_optimizer;

    void interpretKeyword_base(QString &keyword, Structure* structure);

    QString getTemplateKeywordHelp_base();

    unsigned int m_schemaVersion;

    // Set true in destructors
    bool m_isDestroying;

  };

} // end namespace GlobalSearch

#endif

---