AnalysisDataService.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/WorkspaceGroup.h"
#include <iterator>
#include <random>
#include <sstream>
 
namespace Mantid::API {
 
//-------------------------------------------------------------------------
// Nested class methods
//-------------------------------------------------------------------------
AnalysisDataServiceImpl::GroupUpdatedNotification::GroupUpdatedNotification(const std::string &name)
    : DataServiceNotification(name, AnalysisDataService::Instance().retrieve(name)) {}
std::shared_ptr<const WorkspaceGroup> AnalysisDataServiceImpl::GroupUpdatedNotification::getWorkspaceGroup() const {
  return std::dynamic_pointer_cast<const WorkspaceGroup>(this->object());
}
 
//-------------------------------------------------------------------------
// Public methods
//-------------------------------------------------------------------------
const std::string AnalysisDataServiceImpl::isValid(const std::string &name) const {
  std::string error;
  const std::string &illegal = illegalCharacters();
  if (illegal.empty())
    return error; // Quick route out.
  const size_t length = name.size();
  for (size_t i = 0; i < length; ++i) {
    if (illegal.find_first_of(name[i]) != std::string::npos) {
      std::ostringstream strm;
      strm << "Invalid object name '" << name << "'. Names cannot contain any of the following characters: " << illegal;
      error = strm.str();
      break;
    }
  }
  return error;
}
 
void AnalysisDataServiceImpl::add(const std::string &name, const std::shared_ptr<API::Workspace> &workspace) {
  auto group = std::dynamic_pointer_cast<WorkspaceGroup>(workspace);
  verifyName(name, group);
 
  // Attach the name to the workspace
  if (workspace)
    workspace->setName(name);
  Kernel::DataService<API::Workspace>::add(name, workspace);
 
  // if a group is added add its members as well
  if (!group)
    return;
 
  group->observeADSNotifications(true);
  for (size_t i = 0; i < group->size(); ++i) {
    auto ws = group->getItem(i);
    std::string wsName = ws->getName();
    // if anonymous make up a name and add
    if (wsName.empty()) {
      wsName = name + "_" + std::to_string(i + 1);
    } else if (doesExist(wsName)) { // if ws is already there do nothing
      wsName.clear();
    }
    // add member workspace if needed
    if (!wsName.empty()) {
      add(wsName, ws);
    }
  }
}
 
void AnalysisDataServiceImpl::addOrReplace(const std::string &name, const std::shared_ptr<API::Workspace> &workspace) {
  auto group = std::dynamic_pointer_cast<WorkspaceGroup>(workspace);
  verifyName(name, group);
 
  // Attach the name to the workspace
  if (workspace)
    workspace->setName(name);
  Kernel::DataService<API::Workspace>::addOrReplace(name, workspace);
 
  if (!group)
    return;
  group->observeADSNotifications(true);
  for (size_t i = 0; i < group->size(); ++i) {
    auto ws = group->getItem(i);
    std::string wsName = ws->getName();
    // make up a name for an anonymous workspace
    if (wsName.empty()) {
      wsName = name + "_" + std::to_string(i + 1);
    } else if (doesExist(wsName)) { // if ws is already there do nothing
      wsName.clear();
    }
    // add member workspace if needed
    if (!wsName.empty()) {
      addOrReplace(wsName, ws);
    }
  }
}
 
void AnalysisDataServiceImpl::rename(const std::string &oldName, const std::string &newName) {
 
  auto oldWorkspace = retrieve(oldName);
  auto group = std::dynamic_pointer_cast<WorkspaceGroup>(oldWorkspace);
  if (group && group->containsInChildren(newName)) {
    throw std::invalid_argument("Unable to rename group as the new name matches its members");
  }
 
  Kernel::DataService<API::Workspace>::rename(oldName, newName);
  // Attach the new name to the workspace
  auto ws = retrieve(newName);
  ws->setName(newName);
}
 
Workspace_sptr AnalysisDataServiceImpl::remove(const std::string &name) {
  Workspace_sptr ws;
  try {
    ws = retrieve(name);
  } catch (const Kernel::Exception::NotFoundError &) {
    // do nothing - remove will do what's needed
  }
  Kernel::DataService<API::Workspace>::remove(name);
  if (ws) {
    ws->setName("");
  }
 
  auto group = std::dynamic_pointer_cast<WorkspaceGroup>(ws);
  if (group) {
    group->observeADSNotifications(false);
  }
  return ws;
}
 
char AnalysisDataServiceImpl::getRandomLowercaseLetter() {
  static const std::string alphabet = "abcdefghijklmnopqrstuvwxyz";
  static std::random_device rd;
  static std::mt19937 gen(rd());
  static std::uniform_int_distribution<> dis(0, int(alphabet.size() - 1));
  return alphabet[dis(gen)];
}
 
const std::string AnalysisDataServiceImpl::uniqueName(const int n, const std::string &prefix,
                                                      const std::string &suffix) {
  if (n <= 0) {
    throw std::invalid_argument("n must be a positive number");
  }
  auto randomNameGenerator = [n]() {
    std::string name;
    for (int i = 0; i < n; ++i) {
      name += getRandomLowercaseLetter();
    }
    return name;
  };
 
  // limit of (n * 10 * size of alphabet) to avoid infinite loop in case we can't find name that doesn't collide
  for (int i = 0; i < (n * 260); i++) {
    std::string wsName = prefix + randomNameGenerator() + suffix;
    if (!doesExist(wsName)) {
      return wsName;
    }
  }
  throw std::runtime_error("Unable to generate unique workspace of length " + std::to_string(n));
}
 
const std::string AnalysisDataServiceImpl::uniqueHiddenName() { return AnalysisDataServiceImpl::uniqueName(9, "__"); }
 
std::vector<Workspace_sptr> AnalysisDataServiceImpl::retrieveWorkspaces(const std::vector<std::string> &names,
                                                                        bool unrollGroups) const {
  using WorkspacesVector = std::vector<Workspace_sptr>;
  WorkspacesVector workspaces;
  workspaces.reserve(names.size());
  std::transform(std::begin(names), std::end(names), std::back_inserter(workspaces),
                 [this](const std::string &name) { return this->retrieve(name); });
  assert(names.size() == workspaces.size());
  if (unrollGroups) {
    using IteratorDifference = std::iterator_traits<WorkspacesVector::iterator>::difference_type;
 
    bool done{workspaces.size() == 0};
    size_t i{0};
    while (!done) {
      if (auto group = std::dynamic_pointer_cast<WorkspaceGroup>(workspaces.at(i))) {
        const auto groupLength(group->size());
        workspaces.erase(std::next(std::begin(workspaces), static_cast<IteratorDifference>(i)));
        for (size_t j = 0; j < groupLength; ++j) {
          workspaces.insert(std::next(std::begin(workspaces), static_cast<IteratorDifference>(i + j)),
                            group->getItem(j));
        }
        i += groupLength;
      } else {
        ++i;
      }
 
      if (i == workspaces.size()) {
        done = true;
      }
    }
  }
  return workspaces;
}
 
void AnalysisDataServiceImpl::sortGroupByName(const std::string &groupName) {
  WorkspaceGroup_sptr group = retrieveWS<WorkspaceGroup>(groupName);
  if (!group) {
    throw std::runtime_error("Workspace " + groupName + " is not a workspace group.");
  }
  group->sortMembersByName();
  notificationCenter.postNotification(new GroupUpdatedNotification(groupName));
}
 
void AnalysisDataServiceImpl::addToGroup(const std::string &groupName, const std::string &wsName) {
  WorkspaceGroup_sptr group = retrieveWS<WorkspaceGroup>(groupName);
  if (!group) {
    throw std::runtime_error("Workspace " + groupName + " is not a workspace group.");
  }
 
  if (groupName == wsName) {
    throw std::runtime_error("The group name and workspace name are the same");
  }
 
  auto ws = retrieve(wsName);
  group->addWorkspace(ws);
  notificationCenter.postNotification(new GroupUpdatedNotification(groupName));
}
 
void AnalysisDataServiceImpl::deepRemoveGroup(const std::string &name) {
  WorkspaceGroup_sptr group = retrieveWS<WorkspaceGroup>(name);
  if (!group) {
    throw std::runtime_error("Workspace " + name + " is not a workspace group.");
  }
  group->observeADSNotifications(false);
  for (size_t i = 0; i < group->size(); ++i) {
    auto ws = group->getItem(i);
    WorkspaceGroup_sptr gws = std::dynamic_pointer_cast<WorkspaceGroup>(ws);
    if (gws) {
      // if a member is a group remove its items as well
      deepRemoveGroup(gws->getName());
    } else {
      remove(ws->getName());
    }
  }
  remove(name);
}
 
void AnalysisDataServiceImpl::removeFromGroup(const std::string &groupName, const std::string &wsName) {
  WorkspaceGroup_sptr group = retrieveWS<WorkspaceGroup>(groupName);
  if (!group) {
    throw std::runtime_error("Workspace " + groupName + " is not a workspace group.");
  }
  if (!group->contains(wsName)) {
    throw std::runtime_error("WorkspaceGroup " + groupName + " does not containt workspace " + wsName);
  }
  group->removeByADS(wsName);
  notificationCenter.postNotification(new GroupUpdatedNotification(groupName));
}
 
std::map<std::string, Workspace_sptr> AnalysisDataServiceImpl::topLevelItems() const {
  std::map<std::string, Workspace_sptr> topLevel;
  auto topLevelNames = this->getObjectNames();
  std::set<Workspace_sptr> groupMembers;
 
  for (const auto &topLevelName : topLevelNames) {
    try {
      const std::string &name = topLevelName;
      auto ws = this->retrieve(topLevelName);
      topLevel.emplace(name, ws);
      if (auto group = std::dynamic_pointer_cast<WorkspaceGroup>(ws)) {
        group->reportMembers(groupMembers);
      }
    } catch (const std::exception &) {
    }
  }
 
  // Prune members
  for (auto it = topLevel.begin(); it != topLevel.end();) {
    const Workspace_sptr &item = it->second;
    if (groupMembers.count(item) == 1) {
      topLevel.erase(it++);
    } else {
      ++it;
    }
  }
 
  return topLevel;
}
 
//-------------------------------------------------------------------------
// Private methods
//-------------------------------------------------------------------------
 
AnalysisDataServiceImpl::AnalysisDataServiceImpl()
    : Mantid::Kernel::DataService<Mantid::API::Workspace>("AnalysisDataService"), m_illegalChars() {}
 
// The following is commented using /// rather than /** to stop the compiler
// complaining
// about the special characters in the comment fields.
const std::string &AnalysisDataServiceImpl::illegalCharacters() const { return m_illegalChars; }
 
void AnalysisDataServiceImpl::setIllegalCharacterList(const std::string &illegalChars) {
  m_illegalChars = illegalChars;
}
 
void AnalysisDataServiceImpl::verifyName(const std::string &name, const std::shared_ptr<API::WorkspaceGroup> &group) {
  const std::string error = isValid(name);
  if (!error.empty()) {
    throw std::invalid_argument(error);
  }
 
  if (group && group->containsInChildren(name)) {
    throw std::invalid_argument("Unable to add group as name matches its members");
  }
}
 
} // namespace Mantid::API