Comparison and streaming operators for base::Version

base/version.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/version.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 15 matching lines @@
                          std::vector<uint32_t>* parsed) {
   std::vector<StringPiece> numbers =
       SplitStringPiece(version_str, ".", KEEP_WHITESPACE, SPLIT_WANT_ALL);
   if (numbers.empty())
     return false;
 
   for (auto it = numbers.begin(); it != numbers.end(); ++it) {
     if (StartsWith(*it, "+", CompareCase::SENSITIVE))
       return false;
 
-    // TODO(brettw) when we have a StringPiece version of StringToUint, delete
-    // this string conversion.
     unsigned int num;
     if (!StringToUint(*it, &num))
       return false;
 
     // This throws out leading zeros for the first item only.
     if (it == numbers.begin() && UintToString(num) != *it)
       return false;
 
     // StringToUint returns unsigned int but Version fields are uint32_t.
     static_assert(sizeof (uint32_t) == sizeof (unsigned int),
@@ skipping 52 matching lines @@
 // static
 bool Version::IsValidWildcardString(const std::string& wildcard_string) {
   std::string version_string = wildcard_string;
   if (EndsWith(version_string, ".*", CompareCase::SENSITIVE))
     version_string.resize(version_string.size() - 2);
 
   Version version(version_string);
   return version.IsValid();
 }
 
-bool Version::IsOlderThan(const std::string& version_str) const {
-  Version proposed_ver(version_str);
-  if (!proposed_ver.IsValid())
-    return false;
-  return (CompareTo(proposed_ver) < 0);
-}
-
 int Version::CompareToWildcardString(const std::string& wildcard_string) const {
   DCHECK(IsValid());
   DCHECK(Version::IsValidWildcardString(wildcard_string));
 
   // Default behavior if the string doesn't end with a wildcard.
   if (!EndsWith(wildcard_string, ".*", CompareCase::SENSITIVE)) {
     Version version(wildcard_string);
     DCHECK(version.IsValid());
     return CompareTo(version);
   }
@@ skipping 17 matching lines @@
   // components is greater (e.g. 3.2.3 vs 1.*).
   DCHECK_GT(parsed.size(), 0UL);
   const size_t min_num_comp = std::min(components_.size(), parsed.size());
   for (size_t i = 0; i < min_num_comp; ++i) {
     if (components_[i] != parsed[i])
       return 1;
   }
   return 0;
 }
 
-bool Version::Equals(const Version& that) const {
-  DCHECK(IsValid());
-  DCHECK(that.IsValid());
-  return (CompareTo(that) == 0);
-}
-
 int Version::CompareTo(const Version& other) const {
   DCHECK(IsValid());
   DCHECK(other.IsValid());
   return CompareVersionComponents(components_, other.components_);
 }
 
 const std::string Version::GetString() const {
   DCHECK(IsValid());
   std::string version_str;
   size_t count = components_.size();
   for (size_t i = 0; i < count - 1; ++i) {
     version_str.append(UintToString(components_[i]));
     version_str.append(".");
   }
   version_str.append(UintToString(components_[count - 1]));
   return version_str;
 }
 
+bool operator==(const Version& v1, const Version& v2) {
+  return v1.CompareTo(v2) == 0;
+}
+
+bool operator!=(const Version& v1, const Version& v2) {
+  return !(v1 == v2);
+}
+
+bool operator<(const Version& v1, const Version& v2) {
+  return v1.CompareTo(v2) < 0;
+}
+
+bool operator<=(const Version& v1, const Version& v2) {
+  return v1.CompareTo(v2) <= 0;
+}
+
+bool operator>(const Version& v1, const Version& v2) {
+  return v1.CompareTo(v2) > 0;
+}
+
+bool operator>=(const Version& v1, const Version& v2) {
+  return v1.CompareTo(v2) >= 0;
+}
+
+std::ostream& operator<<(std::ostream& stream, const Version& v) {
+  return stream << v.GetString();
+}
+
 }  // namespace base