WorkspaceGroup.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2009 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/WorkspaceGroup_fwd.h"
#include "MantidAPI/Workspace_fwd.h"
 
#include <Poco/NObserver.h>
#include <iterator>
#include <mutex>
 
namespace Mantid {
 
namespace API {
//----------------------------------------------------------------------
// Forward Declarations
//----------------------------------------------------------------------
class Algorithm;
 
class MANTID_API_DLL WorkspaceGroup : public Workspace {
public:
  WorkspaceGroup(const Parallel::StorageMode storageMode = Parallel::StorageMode::Cloned);
  ~WorkspaceGroup() override;
  const std::string id() const override { return "WorkspaceGroup"; }
  const std::string toString() const override;
 
  size_t getMemorySize() const override;
  void sortMembersByName();
  void addWorkspace(const Workspace_sptr &workspace);
  int getNumberOfEntries() const { return static_cast<int>(this->size()); }
  size_t size() const { return m_workspaces.size(); }
  Workspace_sptr getItem(const size_t index) const;
  Workspace_sptr getItem(const std::string &wsName) const;
  std::vector<Workspace_sptr> getAllItems() const;
  void removeItem(const size_t index);
  void removeAll();
  bool isGroup() const override { return true; }
  bool isEmpty() const;
  bool areNamesSimilar() const;
  bool isMultiperiod() const;
  bool isInGroup(const Workspace &workspaceToCheck, size_t level = 0) const;
  void print() const;
  void throwIndexOutOfRangeError(int index) const;
 
  std::vector<Workspace_sptr>::iterator begin();
  std::vector<Workspace_sptr>::iterator end();
  std::vector<Workspace_sptr>::const_iterator begin() const;
  std::vector<Workspace_sptr>::const_iterator end() const;
 
 
 
  void sortByName() { AnalysisDataService::Instance().sortGroupByName(this->getName()); }
 
  void add(const std::string &wsName) { AnalysisDataService::Instance().addToGroup(this->getName(), wsName); }
  void remove(const std::string &wsName) { AnalysisDataService::Instance().removeFromGroup(this->getName(), wsName); }
  bool containsInChildren(const std::string &wsName) const;
  bool contains(const std::string &wsName) const;
  bool contains(const Workspace_sptr &workspace) const;
  void reportMembers(std::set<Workspace_sptr> &memberList) const;
  std::vector<std::string> getNames() const;
 
  WorkspaceGroup(const WorkspaceGroup &ref) = delete;
  WorkspaceGroup &operator=(const WorkspaceGroup &) = delete;
 
private:
  WorkspaceGroup *doClone() const override {
    throw std::runtime_error("Cloning of WorkspaceGroup is not implemented.");
  }
  WorkspaceGroup *doCloneEmpty() const override {
    throw std::runtime_error("Cloning of WorkspaceGroup is not implemented.");
  }
  void removeByADS(const std::string &wsName);
  void observeADSNotifications(const bool observeADS);
  bool isInChildGroup(const Workspace &workspaceToCheck) const;
 
  void workspaceDeleteHandle(Mantid::API::WorkspacePostDeleteNotification_ptr notice);
 
  void workspaceBeforeReplaceHandle(Mantid::API::WorkspaceBeforeReplaceNotification_ptr notice);
 
  Poco::NObserver<WorkspaceGroup, Mantid::API::WorkspacePostDeleteNotification> m_deleteObserver;
  Poco::NObserver<WorkspaceGroup, Mantid::API::WorkspaceBeforeReplaceNotification> m_beforeReplaceObserver;
  std::vector<Workspace_sptr> m_workspaces;
  bool m_observingADS;
  mutable std::recursive_mutex m_mutex;
 
  friend class AnalysisDataServiceImpl;
  friend class Algorithm;
};
 
} // namespace API
} // namespace Mantid