aboutsummaryrefslogtreecommitdiff
path: root/butl
diff options
context:
space:
mode:
Diffstat (limited to 'butl')
-rw-r--r--butl/standard-version107
-rw-r--r--butl/standard-version.cxx178
-rw-r--r--butl/standard-version.ixx14
3 files changed, 279 insertions, 20 deletions
diff --git a/butl/standard-version b/butl/standard-version
index 0888900..c9637d8 100644
--- a/butl/standard-version
+++ b/butl/standard-version
@@ -12,6 +12,8 @@
#include <butl/export>
+#include <butl/optional>
+
namespace butl
{
// The build2 "standard version":
@@ -34,10 +36,13 @@ namespace butl
std::string snapshot_id; // Empty if not specified.
std::uint16_t revision = 0; // 0 if not specified.
- std::uint16_t major () const;
- std::uint16_t minor () const;
- std::uint16_t patch () const;
- std::uint16_t pre_release () const; // Note: 0 is ambiguous (-a.0.z).
+ std::uint16_t major () const noexcept;
+ std::uint16_t minor () const noexcept;
+ std::uint16_t patch () const noexcept;
+
+ // Note: 0 is ambiguous (-a.0.z).
+ //
+ std::uint16_t pre_release () const noexcept;
// Note: return empty if the corresponding component is unspecified.
//
@@ -47,14 +52,14 @@ namespace butl
std::string string_pre_release () const; // Pre-release part only (a.1).
std::string string_snapshot () const; // Snapshot part only (1234.1f23).
- bool empty () const {return version == 0;}
+ bool empty () const noexcept {return version == 0;}
- bool alpha () const;
- bool beta () const;
- bool snapshot () const {return snapshot_sn != 0;}
+ bool alpha () const noexcept;
+ bool beta () const noexcept;
+ bool snapshot () const noexcept {return snapshot_sn != 0;}
int
- compare (const standard_version&) const;
+ compare (const standard_version&) const noexcept;
// Parse the version. Throw std::invalid_argument if the format is not
// recognizable or components are invalid.
@@ -88,13 +93,37 @@ namespace butl
};
inline bool
- operator== (const standard_version& x, const standard_version& y)
+ operator< (const standard_version& x, const standard_version& y) noexcept
+ {
+ return x.compare (y) < 0;
+ }
+
+ inline bool
+ operator> (const standard_version& x, const standard_version& y) noexcept
+ {
+ return x.compare (y) > 0;
+ }
+
+ inline bool
+ operator== (const standard_version& x, const standard_version& y) noexcept
{
return x.compare (y) == 0;
}
inline bool
- operator!= (const standard_version& x, const standard_version& y)
+ operator<= (const standard_version& x, const standard_version& y) noexcept
+ {
+ return x.compare (y) <= 0;
+ }
+
+ inline bool
+ operator>= (const standard_version& x, const standard_version& y) noexcept
+ {
+ return x.compare (y) >= 0;
+ }
+
+ inline bool
+ operator!= (const standard_version& x, const standard_version& y) noexcept
{
return !(x == y);
}
@@ -104,6 +133,62 @@ namespace butl
{
return o << x.string ();
}
+
+ // The build2 "standard version" constraint:
+ //
+ // ('==' | '>' | '<' | '>=' | '<=') <version>
+ // ('(' | '[') <version> <version> (')' | ']')
+ //
+ struct LIBBUTL_EXPORT standard_version_constraint
+ {
+ butl::optional<standard_version> min_version;
+ butl::optional<standard_version> max_version;
+ bool min_open;
+ bool max_open;
+
+ // Parse the version constraint. Throw std::invalid_argument on error.
+ //
+ explicit
+ standard_version_constraint (const std::string&);
+
+ // Throw std::invalid_argument if the specified version range is invalid.
+ //
+ standard_version_constraint (
+ butl::optional<standard_version> min_version, bool min_open,
+ butl::optional<standard_version> max_version, bool max_open);
+
+ standard_version_constraint (const standard_version& v)
+ : standard_version_constraint (v, false, v, false) {}
+
+ standard_version_constraint () = default;
+
+ std::string
+ string () const;
+
+ bool
+ empty () const noexcept {return !min_version && !max_version;}
+ };
+
+ inline bool
+ operator== (const standard_version_constraint& x,
+ const standard_version_constraint& y)
+ {
+ return x.min_version == y.min_version && x.max_version == y.max_version &&
+ x.min_open == y.min_open && x.max_open == y.max_open;
+ }
+
+ inline bool
+ operator!= (const standard_version_constraint& x,
+ const standard_version_constraint& y)
+ {
+ return !(x == y);
+ }
+
+ inline std::ostream&
+ operator<< (std::ostream& o, const standard_version_constraint& x)
+ {
+ return o << x.string ();
+ }
}
#include <butl/standard-version.ixx>
diff --git a/butl/standard-version.cxx b/butl/standard-version.cxx
index 7e144a6..552aac8 100644
--- a/butl/standard-version.cxx
+++ b/butl/standard-version.cxx
@@ -4,8 +4,10 @@
#include <butl/standard-version>
+#include <cassert>
#include <cstdlib> // strtoull()
#include <cstddef> // size_t
+#include <utility> // move()
#include <stdexcept> // invalid_argument
#include <butl/utility> // alnum()
@@ -90,7 +92,7 @@ namespace butl
ep = *e == '~';
}
- size_t p (0), n (s.size ());
+ size_t p (0);
if (ep)
{
@@ -152,7 +154,7 @@ namespace butl
if (s[p] == '+')
revision = parse_num (s, ++p, "invalid revision", 1, uint16_t (~0));
- if (p != n)
+ if (p != s.size ())
bail ("junk after version");
if (ab != 0)
@@ -330,4 +332,176 @@ namespace butl
return r;
}
+
+ // standard_version_constraint
+ //
+ standard_version_constraint::
+ standard_version_constraint (const std::string& s)
+ {
+ using std::string; // Not to confuse with string().
+
+ auto bail = [] (const string& m) {throw invalid_argument (m);};
+ const char* spaces (" \t");
+
+ size_t p (0);
+ char c (s[p]);
+
+ if (c == '(' || c == '[') // Can be '\0'.
+ {
+ bool min_open = c == '(';
+
+ p = s.find_first_not_of (spaces, ++p);
+ if (p == string::npos)
+ bail ("no min version");
+
+ size_t e (s.find_first_of (spaces, p));
+
+ standard_version min_version;
+
+ try
+ {
+ min_version = standard_version (s.substr (p, e - p));
+ }
+ catch (const invalid_argument& e)
+ {
+ bail (string ("invalid min version: ") + e.what ());
+ }
+
+ p = s.find_first_not_of (spaces, e);
+ if (p == string::npos)
+ bail ("no max version");
+
+ e = s.find_first_of (" \t])", p);
+
+ standard_version max_version;
+
+ try
+ {
+ max_version = standard_version (s.substr (p, e - p));
+ }
+ catch (const invalid_argument& e)
+ {
+ bail (string ("invalid max version: ") + e.what ());
+ }
+
+ p = s.find_first_of ("])", e);
+ if (p == string::npos)
+ bail ("no closing bracket");
+
+ bool max_open = s[p] == ')';
+
+ if (++p != s.size ())
+ bail ("junk after constraint");
+
+ // Verify and copy the constraint.
+ //
+ *this = standard_version_constraint (min_version, min_open,
+ max_version, max_open);
+ }
+ else
+ {
+ enum comparison {eq, lt, gt, le, ge};
+ comparison operation (eq); // Uninitialized warning.
+
+ if (s.compare (0, p = 2, "==") == 0)
+ operation = eq;
+ else if (s.compare (0, p = 2, ">=") == 0)
+ operation = ge;
+ else if (s.compare (0, p = 2, "<=") == 0)
+ operation = le;
+ else if (s.compare (0, p = 1, ">") == 0)
+ operation = gt;
+ else if (s.compare (0, p = 1, "<") == 0)
+ operation = lt;
+ else
+ bail ("invalid constraint");
+
+ p = s.find_first_not_of (spaces, p);
+
+ if (p == string::npos)
+ bail ("no version");
+
+ standard_version v;
+
+ try
+ {
+ v = standard_version (s.substr (p));
+ }
+ catch (const invalid_argument& e)
+ {
+ bail (string ("invalid version: ") + e.what ());
+ }
+
+ // Verify and copy the constraint.
+ //
+ switch (operation)
+ {
+ case comparison::eq:
+ *this = standard_version_constraint (v);
+ break;
+ case comparison::lt:
+ *this = standard_version_constraint (nullopt, true, move (v), true);
+ break;
+ case comparison::le:
+ *this = standard_version_constraint (nullopt, true, move (v), false);
+ break;
+ case comparison::gt:
+ *this = standard_version_constraint (move (v), true, nullopt, true);
+ break;
+ case comparison::ge:
+ *this = standard_version_constraint (move (v), false, nullopt, true);
+ break;
+ }
+ }
+ }
+
+ standard_version_constraint::
+ standard_version_constraint (optional<standard_version> mnv, bool mno,
+ optional<standard_version> mxv, bool mxo)
+ : min_version (move (mnv)),
+ max_version (move (mxv)),
+ min_open (mno),
+ max_open (mxo)
+ {
+ assert (
+ // Min and max versions can't both be absent.
+ //
+ (min_version || max_version) &&
+
+ // Version should be non-empty.
+ //
+ (!min_version || !min_version->empty ()) &&
+ (!max_version || !max_version->empty ()) &&
+
+ // Absent version endpoint (infinity) should be open.
+ //
+ (min_version || min_open) && (max_version || max_open));
+
+ if (min_version && max_version)
+ {
+ if (*min_version > *max_version)
+ throw invalid_argument ("min version is greater than max version");
+
+ if (*min_version == *max_version && (min_open || max_open))
+ throw invalid_argument ("equal version endpoints not closed");
+ }
+ }
+
+ string standard_version_constraint::
+ string () const
+ {
+ assert (!empty ());
+
+ if (!min_version)
+ return (max_open ? "< " : "<= ") + max_version->string ();
+
+ if (!max_version)
+ return (min_open ? "> " : ">= ") + min_version->string ();
+
+ if (*min_version == *max_version)
+ return "== " + min_version->string ();
+
+ return (min_open ? '(' : '[') + min_version->string () + ' ' +
+ max_version->string () + (max_open ? ')' : ']');
+ }
}
diff --git a/butl/standard-version.ixx b/butl/standard-version.ixx
index e414deb..b01faef 100644
--- a/butl/standard-version.ixx
+++ b/butl/standard-version.ixx
@@ -18,7 +18,7 @@ namespace butl
}
inline std::uint16_t standard_version::
- major () const
+ major () const noexcept
{
std::uint64_t v (version / 10);
std::uint64_t ab (v % 1000);
@@ -29,7 +29,7 @@ namespace butl
}
inline std::uint16_t standard_version::
- minor () const
+ minor () const noexcept
{
std::uint64_t v (version / 10);
std::uint64_t ab (v % 1000);
@@ -40,7 +40,7 @@ namespace butl
}
inline std::uint16_t standard_version::
- patch () const
+ patch () const noexcept
{
std::uint64_t v (version / 10);
std::uint64_t ab (v % 1000);
@@ -51,7 +51,7 @@ namespace butl
}
inline std::uint16_t standard_version::
- pre_release () const
+ pre_release () const noexcept
{
std::uint64_t ab (version / 10 % 1000);
if (ab > 500)
@@ -61,21 +61,21 @@ namespace butl
}
inline bool standard_version::
- alpha () const
+ alpha () const noexcept
{
std::uint64_t abe (version % 10000);
return abe > 0 && abe < 5000;
}
inline bool standard_version::
- beta () const
+ beta () const noexcept
{
std::uint64_t abe (version % 10000);
return abe > 5000;
}
inline int standard_version::
- compare (const standard_version& v) const
+ compare (const standard_version& v) const noexcept
{
if (epoch != v.epoch)
return epoch < v.epoch ? -1 : 1;