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{"Tue, 3 Feb 2026 00:30:06 +0000"};
 
  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{"http://dx.doi.org/10.1016/j.nima.2014.07.029"};
const std::string VERSION_FULL{"6.14.20260127.2059.dev78"};
const std::string VERSION_SHORT{"6.14"};
const std::string REVISION_SHORT{"g5ce2ef3fa27"};
const std::string REVISION_FULL{"5ce2ef3fa273feb1e9f4e5a5d3ed2fd61af7226c"};
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 {"6", "14", "20260127.2059", ".dev78"};
}
 
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);
  // For major/minor/patch/rc/local releases we point users to a specific release-notes.
  // For dev and nightly versions we point to the next main release notes.
  // We assume that the next main release version number will be one minor version higher.
 
  std::stringstream versionLabel;
 
  if ((patchVersion < 100 && version.tweak.empty()) || version.tweak[0] == '+' || version.tweak.substr(0, 2) == "rc") {
    versionLabel << version.major << "." << version.minor;
    versionLabel << "." << patchVersion;
  } else {
    const unsigned long minorVersion = std::stoul(version.minor);
    versionLabel << version.major << "." << minorVersion + 1 << "." << "0";
  }
 
  return versionLabel.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 = "http://dx.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>(20260127.2059);
 
  // 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(".dev78");
  // cppcheck-suppress knownConditionTrueFalse
  if (patchVersion > 100 || !tweakVersion.empty())
    return MAIN;
 
  std::stringstream doi;
  doi << MAIN << 6 << "." << 14;
 
  // 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