MantidVersion.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 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
 
/********** PLEASE NOTE! THIS FILE WAS AUTO-GENERATED FROM CMAKE.  ***********************/
/********** Source = MantidVersion.cpp.in *****************************************************/
 
#include "MantidKernel/MantidVersion.h"
#include <chrono>
#include <iostream>
#include <regex>
#include <sstream>
 
namespace Mantid::Kernel {
 
namespace {
 
std::chrono::month to_month(const std::string &month) {
  if (month == "Jan")
    return std::chrono::January;
  else if (month == "Feb")
    return std::chrono::February;
  else if (month == "Mar")
    return std::chrono::March;
  else if (month == "Apr")
    return std::chrono::April;
  else if (month == "May")
    return std::chrono::May;
  else if (month == "Jun")
    return std::chrono::June;
  else if (month == "Jul")
    return std::chrono::July;
  else if (month == "Aug")
    return std::chrono::August;
  else if (month == "Sep")
    return std::chrono::September;
  else if (month == "Oct")
    return std::chrono::October;
  else if (month == "Nov")
    return std::chrono::November;
  else if (month == "Dec")
    return std::chrono::December;
  else // should never get here
    throw std::runtime_error("Cannot convert \"" + month + "\" to a month object");
}
 
Types::Core::DateAndTime create_releaseDateAndTime() {
  const std::string REVISION_DATE{"Thu, 24 Sep 2026 15:49:33 +0100"};
 
  Types::Core::DateAndTime release;
  // cppcheck-suppress knownConditionTrueFalse
  if (REVISION_DATE == "UNKNOWN") {
    // something went wrong in VersionNumber.cmake so give the default constructor result
  } else {
    // pull apart string into year, month, and day objects
    // WARNING if the format changes this will break and default DateAndTime is returned
    std::regex format(R"(^.+,\s+(\d{1,2})\s+(\w{3})\s+(\d{4})\s+(.+)\s*$)");
    std::smatch matches;
    if (std::regex_search(REVISION_DATE, matches, format)) {
      constexpr size_t INDEX_DAY{1};
      constexpr size_t INDEX_MONTH{2};
      constexpr size_t INDEX_YEAR{3};
      constexpr size_t INDEX_TIME{4};
 
      // day is the next element by whitespace
      const auto day = std::chrono::day(std::stoi(matches[INDEX_DAY].str()));
      // then comes 3 character month
      const auto month = to_month(matches[INDEX_MONTH].str());
      // then 4 digit year
      const auto year = std::chrono::year(std::stoi(matches[INDEX_YEAR].str()));
      // everything past that is time
      std::string time = matches[INDEX_TIME].str();
      if (time.empty()) {
        time = "00:01"; // assume one minute past midnight
      } else {
        // remove whitespace that is internal to the time
        time.erase(find_if(time.begin(), time.end(), isspace));
      }
 
      // create a proper chrono from it
      std::chrono::year_month_day ymd(year, month, day);
 
      // convert to iso8601 string to get to DateAndTime
      std::stringstream isostr;
      isostr << ymd << "T" << time;
 
      // convert to a proper object
      release.setFromISO8601(isostr.str());
    } // otherwise it will remain the default value
  }
  return release;
}
 
const std::string DOI{"https://doi.org/10.1016/j.nima.2014.07.029"};
const std::string VERSION_FULL{"0.0.0"};
const std::string VERSION_SHORT{"0.0"};
const std::string REVISION_SHORT{"gd918b07b"};
const std::string REVISION_FULL{"d918b07b02c04ff17c2d0ba9f91279caf2f35820"};
const Types::Core::DateAndTime REVISION_DATE_AND_TIME = create_releaseDateAndTime();
 
} // namespace
 
const std::string &MantidVersion::version() { return VERSION_FULL; }
 
const std::string &MantidVersion::versionShort() { return VERSION_SHORT; }
 
const MantidVersion::VersionInfo MantidVersion::versionInfo() {
  return {"0", "0", "0", ""};
}
 
std::string MantidVersion::versionForReleaseNotes(const VersionInfo &version) {
  // Convert here in those cases where patch number is of the form "20131022.1356".
  const unsigned long patchVersion = std::stoul(version.patch);
 
  // A development/nightly version has either a .dev suffix or date-based patch.
  const bool isDevelopmentVersion = version.tweak.starts_with(".dev") || patchVersion > 100;
 
  // Released versions and release candidates point to their own release notes.
  if (!isDevelopmentVersion) {
    std::stringstream versionLabel;
    versionLabel << version.major << "." << version.minor << "." << patchVersion;
    return versionLabel.str();
  }
 
  // Development and nightly versions point to the next release's notes.
  // Normally this is the next minor version, except when the next release is a major version.
  if (version.major == "6" && version.minor == "16") {
    // The next release after 6.16 is 7.0, rather than 6.17.
    return "7.0.0";
  }
 
  const unsigned long minorVersion = std::stoul(version.minor);
  std::stringstream nextMinorVersionLabel;
  nextMinorVersionLabel << version.major << "." << minorVersion + 1 << ".0";
 
  return nextMinorVersionLabel.str();
}
 
std::string MantidVersion::releaseNotes() {
  const std::string STEM = "release/v";
  const std::string END = "/index.html";
 
  std::stringstream url;
 
  url << STEM << versionForReleaseNotes(versionInfo()) << END;
 
  return url.str();
}
 
const std::string &MantidVersion::revision() { return REVISION_SHORT; }
 
const std::string &MantidVersion::revisionFull() { return REVISION_FULL; }
 
Types::Core::DateAndTime MantidVersion::releaseDateAndTime() {
  return REVISION_DATE_AND_TIME;
}
 
std::string MantidVersion::releaseDate() {
  const std::string GIT_DATE_FMT("%a, %e %b %Y");
  const auto release = releaseDateAndTime();
  return release.toFormattedString(GIT_DATE_FMT);
}
 
std::string MantidVersion::doi() {
  const std::string MAIN = "https://doi.org/10.5286/Software/Mantid";
  // Cast here in those cases where patch number is of the form 20131022.1356.
  const unsigned int patchVersion = static_cast<unsigned int>(0);
 
  // For major/minor/patch releases we point users to a specific release-notes DOI, for
  // dev versions we just point to the main DOI.  A simple way to see whether or not
  // we're currently in a dev version is to check if the patch version is larger than
  // some arbitrarily low value.
  const std::string tweakVersion("");
  // cppcheck-suppress knownConditionTrueFalse
  if (patchVersion > 100 || !tweakVersion.empty())
    return MAIN;
 
  std::stringstream doi;
  doi << MAIN << 0 << "." << 0;
 
  // Keep to the convention where we write a version number like "3.0.0" as "3.0".
  if (patchVersion != 0)
    doi << "." << patchVersion;
 
  return doi.str();
}
 
const std::string &MantidVersion::paperCitation() { return DOI; }
 
} // namespace Mantid::Kernel