document.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <QByteArray>
#include <QObject>
#include <QString>
#include <QStringList>
#include <QUndoStack>
#include <QVector>
#include <memory>
#include <vector>
 
#include "anpcpp/network.hpp"
 
struct ResearcherCell {
  QString command;
  QString html;
  bool ok = false;
};
 
struct ResearcherNotebook {
  QString name;
  QVector<ResearcherCell> cells;
};
 
struct LinkedGoogleForm {
  QString formId;
  QString title;
  QString responderUrl;
  QString editUrl;
  QString createdAtIso;  // Qt::ISODate
  QString structureFingerprint;
  QStringList questionTags;
  QStringList questionIds;
  QStringList mappedTags;
};
 
class Document : public QObject {
  Q_OBJECT
public:
  explicit Document(QObject* parent = nullptr);
  ~Document() override;
 
  [[nodiscard]] anpcpp::AnpNetwork& network();
  [[nodiscard]] const anpcpp::AnpNetwork& network() const;
  [[nodiscard]] anpcpp::AnpNetwork& root();
  [[nodiscard]] const anpcpp::AnpNetwork& root() const;
  [[nodiscard]] anpcpp::AnpNetwork* parentNetwork();
  [[nodiscard]] const anpcpp::AnpNetwork* parentNetwork() const;
 
  [[nodiscard]] QUndoStack* undoStack() { return &undo_; }
 
  [[nodiscard]] QString path() const { return path_; }
  [[nodiscard]] bool isDirty() const { return dirty_; }
  void setDirty(bool dirty);
 
  void newNetwork(bool create_alts = true);
  bool loadFromFile(const QString& path, QString* error = nullptr);
  bool saveToFile(const QString& path, QString* error = nullptr);
  void clearPath();
 
  [[nodiscard]] const QVector<ResearcherNotebook>& researcherNotebooks() const {
    return researcherNotebooks_;
  }
  [[nodiscard]] int researcherActiveIndex() const {
    return researcherActiveIndex_;
  }
  void setResearcherSession(QVector<ResearcherNotebook> notebooks,
                            int activeIndex);
  void clearResearcherSession();
 
  [[nodiscard]] const QVector<LinkedGoogleForm>& linkedGoogleForms() const {
    return linkedGoogleForms_;
  }
  void addLinkedGoogleForm(const LinkedGoogleForm& form);
  void removeLinkedGoogleForm(const QString& formId);
  [[nodiscard]] const LinkedGoogleForm* latestLinkedGoogleForm() const;
 
  void pushSubnet(const QString& nodeName);
  void popSubnet();
  void popToRoot();
  void popToDepth(int depth);
  [[nodiscard]] int subnetDepth() const;
  [[nodiscard]] QStringList breadcrumb() const;
  [[nodiscard]] QStringList networkPathOptions() const;
  [[nodiscard]] QString currentNetworkPath() const;
  bool navigateToNetworkPath(const QString& path);
  [[nodiscard]] anpcpp::AnpNetwork* networkAtPath(const QString& path) const;
 
  void notifyChanged();
  void flushModelChanged();
 
  void setSuppressLayoutPersist(bool suppress) {
    suppressLayoutPersist_ = suppress;
  }
  [[nodiscard]] bool suppressLayoutPersist() const {
    return suppressLayoutPersist_;
  }
 
  [[nodiscard]] QString selectedCluster() const { return selectedCluster_; }
  [[nodiscard]] QString selectedNode() const { return selectedNode_; }
  void setSelection(const QString& cluster, const QString& node);
 
  [[nodiscard]] bool hasResults() const { return hasResults_; }
  [[nodiscard]] bool resultsStale() const {
    return hasResults_ && resultsStale_;
  }
  void markResultsCurrent();
  void invalidateResults();
 
  // --- Multi-user judgment session -----------------------------------------
 
  [[nodiscard]] bool hasParticipants() const {
    return !root().participants().empty();
  }
  [[nodiscard]] const std::vector<anpcpp::JudgmentParticipant>& participants()
      const {
    return root().participants();
  }
  [[nodiscard]] const std::vector<anpcpp::JudgmentGroup>& judgmentGroups()
      const {
    return root().judgment_groups();
  }
  [[nodiscard]] anpcpp::JudgmentSession judgmentSession() const {
    return root().judgment_session();
  }
  void setJudgmentSession(const anpcpp::JudgmentSession& session);
 
  anpcpp::JudgmentParticipant& addParticipant(const QString& id,
                                              const QString& name,
                                              const QString& email = {});
  void removeParticipant(const QString& id);
  anpcpp::JudgmentGroup& setJudgmentGroup(const QString& id,
                                          const QString& name,
                                          const QStringList& memberIds);
  void removeJudgmentGroup(const QString& id);
 
  [[nodiscard]] QByteArray snapshotNetworkJson() const;
  void applyNetworkJson(const QByteArray& bytes);
 
  void rebuildEffectiveJudgments();
 
  [[nodiscard]] QString activeParticipantId() const;
  [[nodiscard]] bool judgmentReadOnly() const;
 
signals:
  void sessionChanged();
  void modelChanged();
  void dirtyChanged(bool dirty);
  void pathChanged(const QString& path);
  void viewNetworkChanged();
  void selectionChanged(const QString& cluster, const QString& node);
  void resultsFreshnessChanged();
  void researcherSessionChanged();
  void linkedFormsChanged();
 
private:
  struct Frame {
    anpcpp::AnpNetwork* net = nullptr;
    QString hostNode;
  };
 
  void replaceRoot(std::unique_ptr<anpcpp::AnpNetwork> net);
  void clearSelectionIfInvalid();
  void queueModelChanged();
  void emitViewSwitch();
 
  struct ResearcherSessionData {
    QVector<ResearcherNotebook> notebooks;
    int activeIndex = 0;
  };
 
  [[nodiscard]] static ResearcherSessionData parseResearcherSession(
      const QByteArray& fileBytes);
  [[nodiscard]] static QVector<LinkedGoogleForm> parseLinkedGoogleForms(
      const QByteArray& fileBytes);
  [[nodiscard]] QByteArray buildFileBytes() const;
  [[nodiscard]] bool researcherSessionIsTrivial() const;
 
  std::unique_ptr<anpcpp::AnpNetwork> root_;
  std::vector<Frame> stack_;
  QUndoStack undo_;
  QString path_;
  bool dirty_ = false;
  bool suppressLayoutPersist_ = false;
  bool modelChangedQueued_ = false;
  QString selectedCluster_;
  QString selectedNode_;
  bool hasResults_ = false;
  bool resultsStale_ = false;
  QVector<ResearcherNotebook> researcherNotebooks_;
  int researcherActiveIndex_ = 0;
  QVector<LinkedGoogleForm> linkedGoogleForms_;
};