anatawa12 · July 10, 2024 04:45
diff --git a/main.cpp b/main.cpp
 #include <iostream>

 using namespace std::string_view_literals;

 #define THROW_HR_IF(error, condition) if (condition) throw std::runtime_error(#error);

 // region Utility shim

 namespace Utility {
  constexpr std::string_view s_SpaceChars = " \f\n\r\t\v"sv;

  // original foldCase will make lowercase chars
  std::string FoldCase(std::string_view input)
  {
    std::string result(input);
    std::transform(result.begin(), result.end(), result.begin(),
                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return result;
  }

  std::string& Trim(std::string& str)
  {
    if (!str.empty())
    {
      size_t begin = str.find_first_not_of(s_SpaceChars);
      size_t end = str.find_last_not_of(s_SpaceChars);

      if (begin == std::string_view::npos || end == std::string_view::npos)
      {
        str.clear();
      }
      else if (begin != 0 || end != str.length() - 1)
      {
        str = str.substr(begin, (end - begin) + 1);
      }
    }

    return str;
  }

  std::string Trim(std::string&& str)
  {
    std::string result = std::move(str);
    Utility::Trim(result);
    return result;
  }
 }

 // endregion

 namespace Utility {
 // region https://github.com/microsoft/winget-cli/blob/43425fe97d237e03026fca4530dbc422ab445595/src/AppInstallerSharedLib/AppInstallerStrings.cpp#L393-L399

  std::string ToLower(std::string_view in) {
    std::string result(in);
    std::transform(result.begin(), result.end(), result.begin(),
                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return result;
  }

 // endregion

 // region https://github.com/microsoft/winget-cli/blob/43425fe97d237e03026fca4530dbc422ab445595/src/AppInstallerSharedLib/AppInstallerStrings.cpp#L118-L121

  bool CaseInsensitiveEquals(std::string_view a, std::string_view b) {
    return ToLower(a) == ToLower(b);
  }

  bool CaseInsensitiveStartsWith(std::string_view a, std::string_view b) {
    return a.length() >= b.length() && CaseInsensitiveEquals(a.substr(0, b.length()), b);
  }

 // endregion
 }

 using namespace Utility;

 // region https://github.com/microsoft/winget-cli/blob/ae566c7bf21cfcc75be7ec30e4036a30eede8396/src/AppInstallerSharedLib/Public/AppInstallerVersions.h#L12-L127

 // Creates a comparable version object from a string.
 // Versions are parsed by:
 //  1. Parse approximate comparator sign if applicable
 //  2. Splitting the string based on the given splitChars (or DefaultSplitChars)
 //  3. Parsing a leading, positive integer from each split part
 //  4. Saving any remaining, non-digits as a supplemental value
 //
 // Versions are compared by:
 //  for each part in each version
 //      if both sides have no more parts, return equal
 //      else if one side has no more parts, it is less
 //      else if integers not equal, return comparison of integers
 //      else if only one side has a non-empty string part, it is less
 //      else if string parts not equal, return comparison of strings
 //  if all parts are same, use approximate comparator if applicable
 //
 //  Note: approximate to another approximate version is invalid.
 //        approximate to Unknown is invalid.
 struct Version
 {
  // Used in approximate version to indicate the relation to the base version.
  enum class ApproximateComparator
  {
    None,
    LessThan,
    GreaterThan,
  };


  // The default characters to split a version string on.
  constexpr static std::string_view DefaultSplitChars = "."sv;


  Version() = default;


  Version(const std::string& version, std::string_view splitChars = DefaultSplitChars) :
          Version(std::string(version), splitChars) {}
  Version(std::string&& version, std::string_view splitChars = DefaultSplitChars);


  // Constructing an approximate version from a base version.
  Version(Version baseVersion, ApproximateComparator approximateComparator);


  // Resets the version's value to the input.
  virtual void Assign(std::string version, std::string_view splitChars = DefaultSplitChars);


  // Gets the full version string used to construct the Version.
  const std::string& ToString() const { return m_version; }


  bool operator<(const Version& other) const;
  bool operator>(const Version& other) const;
  bool operator<=(const Version& other) const;
  bool operator>=(const Version& other) const;
  bool operator==(const Version& other) const;
  bool operator!=(const Version& other) const;


  // Determines if this version is the sentinel value defining the 'Latest' version
  bool IsLatest() const;


  // Returns a Version that will return true for IsLatest
  static Version CreateLatest();


  // Determines if this version is the sentinel value defining an 'Unknown' version
  bool IsUnknown() const;


  // Returns a Version that will return true for IsUnknown
  static Version CreateUnknown();


  // Gets a bool indicating whether the full version string is empty.
  // Does not indicate that Parts is empty; for instance when "0.0" is given,
  // this will be false while GetParts().empty() would be true.
  bool IsEmpty() const { return m_version.empty(); }


  // An individual version part in between split characters.
  struct Part
  {
    Part() = default;
    Part(uint64_t integer) : Integer(integer) {}
    Part(const std::string& part);
    Part(uint64_t integer, std::string other);


    bool operator<(const Part& other) const;
    bool operator==(const Part& other) const;
    bool operator!=(const Part& other) const;


    uint64_t Integer = 0;
    std::string Other;


  private:
    std::string m_foldedOther;
  };


  // Gets the part breakdown for a given version.
  const std::vector<Part>& GetParts() const { return m_parts; }


  // Gets the part at the given index; or the implied zero part if past the end.
  const Part& PartAt(size_t index) const;

  // Returns if the version is an approximate version.
  bool IsApproximate() const { return m_approximateComparator != ApproximateComparator::None; }


  // Get the base version from approximate version, or return a copy if the version is not approximate.
  Version GetBaseVersion() const;


 protected:


  bool IsBaseVersionLatest() const;
  bool IsBaseVersionUnknown() const;
  // Called by overloaded less than operator implementation when base version already compared and equal, less than determined by approximate comparator.
  bool ApproximateCompareLessThan(const Version& other) const;


  std::string m_version;
  std::vector<Part> m_parts;
  bool m_trimPrefix = true;
  ApproximateComparator m_approximateComparator = ApproximateComparator::None;


  // Remove trailing empty parts (0 or empty)
  void Trim();
 };

 // endregion

 // region https://github.com/microsoft/winget-cli/blob/ae566c7bf21cfcc75be7ec30e4036a30eede8396/src/AppInstallerSharedLib/Versions.cpp#L9-L362
 using namespace std::string_view_literals;


 static constexpr std::string_view s_Digit_Characters = "0123456789"sv;
 static constexpr std::string_view s_Version_Part_Latest = "Latest"sv;
 static constexpr std::string_view s_Version_Part_Unknown = "Unknown"sv;


 static constexpr std::string_view s_Approximate_Less_Than = "< "sv;
 static constexpr std::string_view s_Approximate_Greater_Than = "> "sv;


 Version::Version(std::string&& version, std::string_view splitChars)
 {
  Assign(std::move(version), splitChars);
 }

 /*
 RawVersion::RawVersion(std::string version, std::string_view splitChars)
 {
  m_trimPrefix = false;
  Assign(std::move(version), splitChars);
 }


 Version::Version(Version baseVersion, ApproximateComparator approximateComparator) : Version(std::move(baseVersion))
 {
  if (approximateComparator == ApproximateComparator::None)
  {
    return;
  }


  THROW_HR_IF(E_INVALIDARG, this->IsApproximate() || this->IsUnknown());


  m_approximateComparator = approximateComparator;
  if (approximateComparator == ApproximateComparator::LessThan)
  {
    m_version = std::string{ s_Approximate_Less_Than } + m_version;
  }
  else if (approximateComparator == ApproximateComparator::GreaterThan)
  {
    m_version = std::string{ s_Approximate_Greater_Than } + m_version;
  }
 }
 */

 void Version::Assign(std::string version, std::string_view splitChars)
 {
  m_version = std::move(Utility::Trim(version));


  // Process approximate comparator if applicable
  std::string baseVersion = m_version;
  if (CaseInsensitiveStartsWith(m_version, s_Approximate_Less_Than))
  {
    m_approximateComparator = ApproximateComparator::LessThan;
    baseVersion = m_version.substr(s_Approximate_Less_Than.length(), m_version.length() - s_Approximate_Less_Than.length());
  }
  else if (CaseInsensitiveStartsWith(m_version, s_Approximate_Greater_Than))
  {
    m_approximateComparator = ApproximateComparator::GreaterThan;
    baseVersion = m_version.substr(s_Approximate_Greater_Than.length(), m_version.length() - s_Approximate_Greater_Than.length());
  }


  // If there is a digit before the split character, or no split characters exist, trim off all leading non-digit characters
  size_t digitPos = baseVersion.find_first_of(s_Digit_Characters);
  size_t splitPos = baseVersion.find_first_of(splitChars);
  if (m_trimPrefix && digitPos != std::string::npos && (splitPos == std::string::npos || digitPos < splitPos))
  {
    baseVersion.erase(0, digitPos);
  }


  // Then parse the base version
  size_t pos = 0;


  while (pos < baseVersion.length())
  {
    size_t newPos = baseVersion.find_first_of(splitChars, pos);


    size_t length = (newPos == std::string::npos ? baseVersion.length() : newPos) - pos;
    m_parts.emplace_back(baseVersion.substr(pos, length));


    pos += length + 1;
  }


  // Trim version parts
  Trim();


  THROW_HR_IF(E_INVALIDARG, m_approximateComparator != ApproximateComparator::None && IsBaseVersionUnknown());
 }


 void Version::Trim()
 {
  while (!m_parts.empty())
  {
    const Part& part = m_parts.back();
    if (part.Integer == 0 && part.Other.empty())
    {
      m_parts.pop_back();
    }
    else
    {
      return;
    }
  }
 }


 bool Version::operator<(const Version& other) const
 {
  // Sort Latest higher than any other values
  bool thisIsLatest = IsBaseVersionLatest();
  bool otherIsLatest = other.IsBaseVersionLatest();


  if (thisIsLatest && otherIsLatest)
  {
    return ApproximateCompareLessThan(other);
  }
  else if (thisIsLatest || otherIsLatest)
  {
    // If only one is latest, this can only be less than if the other is and this is not.
    return (otherIsLatest && !thisIsLatest);
  }


  // Sort Unknown lower than any known values
  bool thisIsUnknown = IsBaseVersionUnknown();
  bool otherIsUnknown = other.IsBaseVersionUnknown();


  if (thisIsUnknown && otherIsUnknown)
  {
    // This code path should always return false as we disable approximate version for Unknown for now
    return ApproximateCompareLessThan(other);
  }
  else if (thisIsUnknown || otherIsUnknown)
  {
    // If at least one is unknown, this can only be less than if it is and the other is not.
    return (thisIsUnknown && !otherIsUnknown);
  }


  for (size_t i = 0; i < m_parts.size(); ++i)
  {
    if (i >= other.m_parts.size())
    {
      // All parts equal to this point
      break;
    }


    const Part& partA = m_parts[i];
    const Part& partB = other.m_parts[i];


    if (partA < partB)
    {
      return true;
    }
    else if (partB < partA)
    {
      return false;
    }
    // else parts are equal, so continue to next part
  }


  // All parts tested were equal
  if (m_parts.size() == other.m_parts.size())
  {
    return ApproximateCompareLessThan(other);
  }
  else
  {
    // Else this is only less if there are more parts in other.
    return m_parts.size() < other.m_parts.size();
  }

 }


 bool Version::operator>(const Version& other) const
 {
  return other < *this;
 }


 bool Version::operator<=(const Version& other) const
 {
  return !(*this > other);
 }


 bool Version::operator>=(const Version& other) const
 {
  return !(*this < other);
 }


 bool Version::operator==(const Version& other) const
 {
  if (m_approximateComparator != other.m_approximateComparator)
  {
    return false;
  }


  if ((IsBaseVersionLatest() && other.IsBaseVersionLatest()) ||
      (IsBaseVersionUnknown() && other.IsBaseVersionUnknown()))
  {
    return true;
  }


  if (m_parts.size() != other.m_parts.size())
  {
    return false;
  }


  for (size_t i = 0; i < m_parts.size(); ++i)
  {
    if (m_parts[i] != other.m_parts[i])
    {
      return false;
    }
  }


  return true;
 }


 bool Version::operator!=(const Version& other) const
 {
  return !(*this == other);
 }


 bool Version::IsLatest() const
 {
  return (m_approximateComparator != ApproximateComparator::LessThan && IsBaseVersionLatest());
 }


 Version Version::CreateLatest()
 {
  Version result;
  result.m_version = s_Version_Part_Latest;
  result.m_parts.emplace_back(0, std::string{ s_Version_Part_Latest });
  return result;
 }


 bool Version::IsUnknown() const
 {
  return IsBaseVersionUnknown();
 }


 Version Version::CreateUnknown()
 {
  Version result;
  result.m_version = s_Version_Part_Unknown;
  result.m_parts.emplace_back(0, std::string{ s_Version_Part_Unknown });
  return result;
 }


 const Version::Part& Version::PartAt(size_t index) const
 {
  static Part s_zero{};


  if (index < m_parts.size())
  {
    return m_parts[index];
  }
  else
  {
    return s_zero;
  }
 }


 Version Version::GetBaseVersion() const
 {
  Version baseVersion = *this;
  baseVersion.m_approximateComparator = ApproximateComparator::None;
  if (m_approximateComparator == ApproximateComparator::LessThan)
  {
    baseVersion.m_version = m_version.substr(s_Approximate_Less_Than.size());
  }
  else if (m_approximateComparator == ApproximateComparator::GreaterThan)
  {
    baseVersion.m_version = m_version.substr(s_Approximate_Greater_Than.size());
  }

  return baseVersion;
 }

 bool Version::IsBaseVersionLatest() const
 {
  return (m_parts.size() == 1 && m_parts[0].Integer == 0 && Utility::CaseInsensitiveEquals(m_parts[0].Other, s_Version_Part_Latest));
 }


 bool Version::IsBaseVersionUnknown() const
 {
  return (m_parts.size() == 1 && m_parts[0].Integer == 0 && Utility::CaseInsensitiveEquals(m_parts[0].Other, s_Version_Part_Unknown));
 }


 bool Version::ApproximateCompareLessThan(const Version& other) const
 {
  // Only true if this is less than, other is not, OR this is none, other is greater than
  return (m_approximateComparator == ApproximateComparator::LessThan && other.m_approximateComparator != ApproximateComparator::LessThan) ||
         (m_approximateComparator == ApproximateComparator::None && other.m_approximateComparator == ApproximateComparator::GreaterThan);
 }


 Version::Part::Part(const std::string& part)
 {
  std::string interimPart = Utility::Trim(part.c_str());
  const char* begin = interimPart.c_str();
  char* end = nullptr;
  errno = 0;
  Integer = strtoull(begin, &end, 10);


  if (errno == ERANGE)
  {
    Integer = 0;
    Other = interimPart;
  }
  else if (static_cast<size_t>(end - begin) != interimPart.length())
  {
    Other = end;
  }


  m_foldedOther = Utility::FoldCase(static_cast<std::string_view>(Other));
 }


 Version::Part::Part(uint64_t integer, std::string other) :
        Integer(integer), Other(std::move(Utility::Trim(other)))
 {
  m_foldedOther = Utility::FoldCase(static_cast<std::string_view>(Other));
 }


 bool Version::Part::operator<(const Part& other) const
 {
  if (Integer < other.Integer)
  {
    return true;
  }
  else if (Integer > other.Integer)
  {
    return false;
  }
  else if (Other.empty())
  {
    // If this Other is empty, it is at least >=
    return false;
  }
  else if (!Other.empty() && other.Other.empty())
  {
    // If the other Other is empty and this is not, this is less.
    return true;
  }
  else if (m_foldedOther < other.m_foldedOther)
  {
    // Compare the folded versions
    return true;
  }


  // else Other >= other.Other
  return false;
 }


 bool Version::Part::operator==(const Part& other) const
 {
  return Integer == other.Integer && m_foldedOther == other.m_foldedOther;
 }


 bool Version::Part::operator!=(const Part& other) const
 {
  return !(*this == other);
 }

 // endregion

 // https://github.com/badges/shields/pull/10245#discussion_r1670870831
 // https://github.com/microsoft/winget-pkgs/tree/c939ca136ff33f217db1de99f1a1839790287a16/manifests/j/JetBrains/MPS/EAP

 int main() {
  Version v_213_6461_785 {"213.6461.785"};
  Version v_mps_241_18034_990 {"MPS-241.18034.990"};

  std::cout << "213.6461.785 < MPS-241.18034.990: " << (v_213_6461_785 < v_mps_241_18034_990) << std::endl;
  return 0;
 }
	#include <iostream>

	using namespace std::string_view_literals;

	#define THROW_HR_IF(error, condition) if (condition) throw std::runtime_error(#error);

	// region Utility shim

	namespace Utility {
	constexpr std::string_view s_SpaceChars = " \f\n\r\t\v"sv;

	// original foldCase will make lowercase chars
	std::string FoldCase(std::string_view input)
	{
	std::string result(input);
	std::transform(result.begin(), result.end(), result.begin(),
	[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
	return result;
	}

	std::string& Trim(std::string& str)
	{
	if (!str.empty())
	{
	size_t begin = str.find_first_not_of(s_SpaceChars);
	size_t end = str.find_last_not_of(s_SpaceChars);

	if (begin == std::string_view::npos \|\| end == std::string_view::npos)
	{
	str.clear();
	}
	else if (begin != 0 \|\| end != str.length() - 1)
	{
	str = str.substr(begin, (end - begin) + 1);
	}
	}

	return str;
	}

	std::string Trim(std::string&& str)
	{
	std::string result = std::move(str);
	Utility::Trim(result);
	return result;
	}
	}

	// endregion

	namespace Utility {
	// region https://github.com/microsoft/winget-cli/blob/43425fe97d237e03026fca4530dbc422ab445595/src/AppInstallerSharedLib/AppInstallerStrings.cpp#L393-L399

	std::string ToLower(std::string_view in) {
	std::string result(in);
	std::transform(result.begin(), result.end(), result.begin(),
	[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
	return result;
	}

	// endregion

	// region https://github.com/microsoft/winget-cli/blob/43425fe97d237e03026fca4530dbc422ab445595/src/AppInstallerSharedLib/AppInstallerStrings.cpp#L118-L121

	bool CaseInsensitiveEquals(std::string_view a, std::string_view b) {
	return ToLower(a) == ToLower(b);
	}

	bool CaseInsensitiveStartsWith(std::string_view a, std::string_view b) {
	return a.length() >= b.length() && CaseInsensitiveEquals(a.substr(0, b.length()), b);
	}

	// endregion
	}

	using namespace Utility;

	// region https://github.com/microsoft/winget-cli/blob/ae566c7bf21cfcc75be7ec30e4036a30eede8396/src/AppInstallerSharedLib/Public/AppInstallerVersions.h#L12-L127

	// Creates a comparable version object from a string.
	// Versions are parsed by:
	// 1. Parse approximate comparator sign if applicable
	// 2. Splitting the string based on the given splitChars (or DefaultSplitChars)
	// 3. Parsing a leading, positive integer from each split part
	// 4. Saving any remaining, non-digits as a supplemental value
	//
	// Versions are compared by:
	// for each part in each version
	// if both sides have no more parts, return equal
	// else if one side has no more parts, it is less
	// else if integers not equal, return comparison of integers
	// else if only one side has a non-empty string part, it is less
	// else if string parts not equal, return comparison of strings
	// if all parts are same, use approximate comparator if applicable
	//
	// Note: approximate to another approximate version is invalid.
	// approximate to Unknown is invalid.
	struct Version
	{
	// Used in approximate version to indicate the relation to the base version.
	enum class ApproximateComparator
	{
	None,
	LessThan,
	GreaterThan,
	};


	// The default characters to split a version string on.
	constexpr static std::string_view DefaultSplitChars = "."sv;


	Version() = default;


	Version(const std::string& version, std::string_view splitChars = DefaultSplitChars) :
	Version(std::string(version), splitChars) {}
	Version(std::string&& version, std::string_view splitChars = DefaultSplitChars);


	// Constructing an approximate version from a base version.
	Version(Version baseVersion, ApproximateComparator approximateComparator);


	// Resets the version's value to the input.
	virtual void Assign(std::string version, std::string_view splitChars = DefaultSplitChars);


	// Gets the full version string used to construct the Version.
	const std::string& ToString() const { return m_version; }


	bool operator<(const Version& other) const;
	bool operator>(const Version& other) const;
	bool operator<=(const Version& other) const;
	bool operator>=(const Version& other) const;
	bool operator==(const Version& other) const;
	bool operator!=(const Version& other) const;


	// Determines if this version is the sentinel value defining the 'Latest' version
	bool IsLatest() const;


	// Returns a Version that will return true for IsLatest
	static Version CreateLatest();


	// Determines if this version is the sentinel value defining an 'Unknown' version
	bool IsUnknown() const;


	// Returns a Version that will return true for IsUnknown
	static Version CreateUnknown();


	// Gets a bool indicating whether the full version string is empty.
	// Does not indicate that Parts is empty; for instance when "0.0" is given,
	// this will be false while GetParts().empty() would be true.
	bool IsEmpty() const { return m_version.empty(); }


	// An individual version part in between split characters.
	struct Part
	{
	Part() = default;
	Part(uint64_t integer) : Integer(integer) {}
	Part(const std::string& part);
	Part(uint64_t integer, std::string other);


	bool operator<(const Part& other) const;
	bool operator==(const Part& other) const;
	bool operator!=(const Part& other) const;


	uint64_t Integer = 0;
	std::string Other;


	private:
	std::string m_foldedOther;
	};


	// Gets the part breakdown for a given version.
	const std::vector<Part>& GetParts() const { return m_parts; }


	// Gets the part at the given index; or the implied zero part if past the end.
	const Part& PartAt(size_t index) const;

	// Returns if the version is an approximate version.
	bool IsApproximate() const { return m_approximateComparator != ApproximateComparator::None; }


	// Get the base version from approximate version, or return a copy if the version is not approximate.
	Version GetBaseVersion() const;


	protected:


	bool IsBaseVersionLatest() const;
	bool IsBaseVersionUnknown() const;
	// Called by overloaded less than operator implementation when base version already compared and equal, less than determined by approximate comparator.
	bool ApproximateCompareLessThan(const Version& other) const;


	std::string m_version;
	std::vector<Part> m_parts;
	bool m_trimPrefix = true;
	ApproximateComparator m_approximateComparator = ApproximateComparator::None;


	// Remove trailing empty parts (0 or empty)
	void Trim();
	};

	// endregion

	// region https://github.com/microsoft/winget-cli/blob/ae566c7bf21cfcc75be7ec30e4036a30eede8396/src/AppInstallerSharedLib/Versions.cpp#L9-L362
	using namespace std::string_view_literals;


	static constexpr std::string_view s_Digit_Characters = "0123456789"sv;
	static constexpr std::string_view s_Version_Part_Latest = "Latest"sv;
	static constexpr std::string_view s_Version_Part_Unknown = "Unknown"sv;


	static constexpr std::string_view s_Approximate_Less_Than = "< "sv;
	static constexpr std::string_view s_Approximate_Greater_Than = "> "sv;


	Version::Version(std::string&& version, std::string_view splitChars)
	{
	Assign(std::move(version), splitChars);
	}

	/*
	RawVersion::RawVersion(std::string version, std::string_view splitChars)
	{
	m_trimPrefix = false;
	Assign(std::move(version), splitChars);
	}


	Version::Version(Version baseVersion, ApproximateComparator approximateComparator) : Version(std::move(baseVersion))
	{
	if (approximateComparator == ApproximateComparator::None)
	{
	return;
	}


	THROW_HR_IF(E_INVALIDARG, this->IsApproximate() \|\| this->IsUnknown());


	m_approximateComparator = approximateComparator;
	if (approximateComparator == ApproximateComparator::LessThan)
	{
	m_version = std::string{ s_Approximate_Less_Than } + m_version;
	}
	else if (approximateComparator == ApproximateComparator::GreaterThan)
	{
	m_version = std::string{ s_Approximate_Greater_Than } + m_version;
	}
	}
	*/

	void Version::Assign(std::string version, std::string_view splitChars)
	{
	m_version = std::move(Utility::Trim(version));


	// Process approximate comparator if applicable
	std::string baseVersion = m_version;
	if (CaseInsensitiveStartsWith(m_version, s_Approximate_Less_Than))
	{
	m_approximateComparator = ApproximateComparator::LessThan;
	baseVersion = m_version.substr(s_Approximate_Less_Than.length(), m_version.length() - s_Approximate_Less_Than.length());
	}
	else if (CaseInsensitiveStartsWith(m_version, s_Approximate_Greater_Than))
	{
	m_approximateComparator = ApproximateComparator::GreaterThan;
	baseVersion = m_version.substr(s_Approximate_Greater_Than.length(), m_version.length() - s_Approximate_Greater_Than.length());
	}


	// If there is a digit before the split character, or no split characters exist, trim off all leading non-digit characters
	size_t digitPos = baseVersion.find_first_of(s_Digit_Characters);
	size_t splitPos = baseVersion.find_first_of(splitChars);
	if (m_trimPrefix && digitPos != std::string::npos && (splitPos == std::string::npos \|\| digitPos < splitPos))
	{
	baseVersion.erase(0, digitPos);
	}


	// Then parse the base version
	size_t pos = 0;


	while (pos < baseVersion.length())
	{
	size_t newPos = baseVersion.find_first_of(splitChars, pos);


	size_t length = (newPos == std::string::npos ? baseVersion.length() : newPos) - pos;
	m_parts.emplace_back(baseVersion.substr(pos, length));


	pos += length + 1;
	}


	// Trim version parts
	Trim();


	THROW_HR_IF(E_INVALIDARG, m_approximateComparator != ApproximateComparator::None && IsBaseVersionUnknown());
	}


	void Version::Trim()
	{
	while (!m_parts.empty())
	{
	const Part& part = m_parts.back();
	if (part.Integer == 0 && part.Other.empty())
	{
	m_parts.pop_back();
	}
	else
	{
	return;
	}
	}
	}


	bool Version::operator<(const Version& other) const
	{
	// Sort Latest higher than any other values
	bool thisIsLatest = IsBaseVersionLatest();
	bool otherIsLatest = other.IsBaseVersionLatest();


	if (thisIsLatest && otherIsLatest)
	{
	return ApproximateCompareLessThan(other);
	}
	else if (thisIsLatest \|\| otherIsLatest)
	{
	// If only one is latest, this can only be less than if the other is and this is not.
	return (otherIsLatest && !thisIsLatest);
	}


	// Sort Unknown lower than any known values
	bool thisIsUnknown = IsBaseVersionUnknown();
	bool otherIsUnknown = other.IsBaseVersionUnknown();


	if (thisIsUnknown && otherIsUnknown)
	{
	// This code path should always return false as we disable approximate version for Unknown for now
	return ApproximateCompareLessThan(other);
	}
	else if (thisIsUnknown \|\| otherIsUnknown)
	{
	// If at least one is unknown, this can only be less than if it is and the other is not.
	return (thisIsUnknown && !otherIsUnknown);
	}


	for (size_t i = 0; i < m_parts.size(); ++i)
	{
	if (i >= other.m_parts.size())
	{
	// All parts equal to this point
	break;
	}


	const Part& partA = m_parts[i];
	const Part& partB = other.m_parts[i];


	if (partA < partB)
	{
	return true;
	}
	else if (partB < partA)
	{
	return false;
	}
	// else parts are equal, so continue to next part
	}


	// All parts tested were equal
	if (m_parts.size() == other.m_parts.size())
	{
	return ApproximateCompareLessThan(other);
	}
	else
	{
	// Else this is only less if there are more parts in other.
	return m_parts.size() < other.m_parts.size();
	}

	}


	bool Version::operator>(const Version& other) const
	{
	return other < *this;
	}


	bool Version::operator<=(const Version& other) const
	{
	return !(*this > other);
	}


	bool Version::operator>=(const Version& other) const
	{
	return !(*this < other);
	}


	bool Version::operator==(const Version& other) const
	{
	if (m_approximateComparator != other.m_approximateComparator)
	{
	return false;
	}


	if ((IsBaseVersionLatest() && other.IsBaseVersionLatest()) \|\|
	(IsBaseVersionUnknown() && other.IsBaseVersionUnknown()))
	{
	return true;
	}


	if (m_parts.size() != other.m_parts.size())
	{
	return false;
	}


	for (size_t i = 0; i < m_parts.size(); ++i)
	{
	if (m_parts[i] != other.m_parts[i])
	{
	return false;
	}
	}


	return true;
	}


	bool Version::operator!=(const Version& other) const
	{
	return !(*this == other);
	}


	bool Version::IsLatest() const
	{
	return (m_approximateComparator != ApproximateComparator::LessThan && IsBaseVersionLatest());
	}


	Version Version::CreateLatest()
	{
	Version result;
	result.m_version = s_Version_Part_Latest;
	result.m_parts.emplace_back(0, std::string{ s_Version_Part_Latest });
	return result;
	}


	bool Version::IsUnknown() const
	{
	return IsBaseVersionUnknown();
	}


	Version Version::CreateUnknown()
	{
	Version result;
	result.m_version = s_Version_Part_Unknown;
	result.m_parts.emplace_back(0, std::string{ s_Version_Part_Unknown });
	return result;
	}


	const Version::Part& Version::PartAt(size_t index) const
	{
	static Part s_zero{};


	if (index < m_parts.size())
	{
	return m_parts[index];
	}
	else
	{
	return s_zero;
	}
	}


	Version Version::GetBaseVersion() const
	{
	Version baseVersion = *this;
	baseVersion.m_approximateComparator = ApproximateComparator::None;
	if (m_approximateComparator == ApproximateComparator::LessThan)
	{
	baseVersion.m_version = m_version.substr(s_Approximate_Less_Than.size());
	}
	else if (m_approximateComparator == ApproximateComparator::GreaterThan)
	{
	baseVersion.m_version = m_version.substr(s_Approximate_Greater_Than.size());
	}

	return baseVersion;
	}

	bool Version::IsBaseVersionLatest() const
	{
	return (m_parts.size() == 1 && m_parts[0].Integer == 0 && Utility::CaseInsensitiveEquals(m_parts[0].Other, s_Version_Part_Latest));
	}


	bool Version::IsBaseVersionUnknown() const
	{
	return (m_parts.size() == 1 && m_parts[0].Integer == 0 && Utility::CaseInsensitiveEquals(m_parts[0].Other, s_Version_Part_Unknown));
	}


	bool Version::ApproximateCompareLessThan(const Version& other) const
	{
	// Only true if this is less than, other is not, OR this is none, other is greater than
	return (m_approximateComparator == ApproximateComparator::LessThan && other.m_approximateComparator != ApproximateComparator::LessThan) \|\|
	(m_approximateComparator == ApproximateComparator::None && other.m_approximateComparator == ApproximateComparator::GreaterThan);
	}


	Version::Part::Part(const std::string& part)
	{
	std::string interimPart = Utility::Trim(part.c_str());
	const char* begin = interimPart.c_str();
	char* end = nullptr;
	errno = 0;
	Integer = strtoull(begin, &end, 10);


	if (errno == ERANGE)
	{
	Integer = 0;
	Other = interimPart;
	}
	else if (static_cast<size_t>(end - begin) != interimPart.length())
	{
	Other = end;
	}


	m_foldedOther = Utility::FoldCase(static_cast<std::string_view>(Other));
	}


	Version::Part::Part(uint64_t integer, std::string other) :
	Integer(integer), Other(std::move(Utility::Trim(other)))
	{
	m_foldedOther = Utility::FoldCase(static_cast<std::string_view>(Other));
	}


	bool Version::Part::operator<(const Part& other) const
	{
	if (Integer < other.Integer)
	{
	return true;
	}
	else if (Integer > other.Integer)
	{
	return false;
	}
	else if (Other.empty())
	{
	// If this Other is empty, it is at least >=
	return false;
	}
	else if (!Other.empty() && other.Other.empty())
	{
	// If the other Other is empty and this is not, this is less.
	return true;
	}
	else if (m_foldedOther < other.m_foldedOther)
	{
	// Compare the folded versions
	return true;
	}


	// else Other >= other.Other
	return false;
	}


	bool Version::Part::operator==(const Part& other) const
	{
	return Integer == other.Integer && m_foldedOther == other.m_foldedOther;
	}


	bool Version::Part::operator!=(const Part& other) const
	{
	return !(*this == other);
	}

	// endregion

	// https://github.com/badges/shields/pull/10245#discussion_r1670870831
	// https://github.com/microsoft/winget-pkgs/tree/c939ca136ff33f217db1de99f1a1839790287a16/manifests/j/JetBrains/MPS/EAP

	int main() {
	Version v_213_6461_785 {"213.6461.785"};
	Version v_mps_241_18034_990 {"MPS-241.18034.990"};

	std::cout << "213.6461.785 < MPS-241.18034.990: " << (v_213_6461_785 < v_mps_241_18034_990) << std::endl;
	return 0;
	}