Subject: [Boost-commit] svn:boost r49165 - sandbox/SOC/2008/graphs/trunk/boost
From: asutton_at_[hidden]
Date: 2008-10-07 10:54:19
Author: asutton
Date: 2008-10-07 10:54:18 EDT (Tue, 07 Oct 2008)
New Revision: 49165
URL: http://svn.boost.org/trac/boost/changeset/49165
Log:
Implemented a new optional_value class that allows the parameterization
of absent values - actual values that can be used to indicate the absence
of a value.
Added:
sandbox/SOC/2008/graphs/trunk/boost/optional_value.hpp (contents, props changed)
Added: sandbox/SOC/2008/graphs/trunk/boost/optional_value.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2008/graphs/trunk/boost/optional_value.hpp 2008-10-07 10:54:18 EDT (Tue, 07 Oct 2008)
@@ -0,0 +1,168 @@
+
+#ifndef BOOST_OPTIONAL_VALUE_HPP
+#define BOOST_OPTIONAL_VALUE_HPP
+
+#include <algorithm>
+#include <limits>
+#include <stdexcept>
+
+namespace boost {
+
+// Forward declarations
+template <typename> class absent;
+
+/**
+ * An optional value is like an optional class, but designates a particular
+ * value as an indicator for the absence of value. A common example is to use
+ * -1u to indicate the absence of values or infinity for unsigned integers.
+ *
+ * Note that T must equality comparable in order to reason about the presence
+ * or absence of its value.
+ */
+template <typename T, typename Absent = absent<T>>
+class optional_value
+{
+ typedef optional_value<T, Absent> this_type;
+ typedef T this_type::* unspecified_bool_type;
+public:
+ typedef T value_type;
+
+ /** @name Constructors */
+ //@{
+ optional_value(T const& x = absent())
+ : _val(x)
+ { }
+
+ optional_value(optional_value const& x)
+ : _val(x._val)
+ { }
+
+ optional_value(optional_value&& x)
+ : _val(std::move(x._val))
+ { }
+ //@}
+
+ /** @name Operators */
+ //@{
+ inline optional_value& operator=(optional_value const& x)
+ { return swap(optional_value(x)); }
+
+ inline optional_value& operator=(optional_value&& x)
+ { return swap(x); }
+
+ inline bool operator==(optional_value const& x) const
+ { return _val == x._val; }
+
+ inline bool operator!=(optional_value const& x) const
+ { return !(*this == x); }
+
+ inline T& operator*()
+ { return get(); }
+
+ inline T const& operator*() const
+ { return get(); }
+
+ inline T* operator->()
+ { return &get(); }
+
+ inline T const* operator->() const
+ { return &get(); }
+
+ inline operator unspecified_bool_type() const
+ { return valid() ? &this_type::_val : 0; }
+ //@}
+
+ inline bool valid() const
+ { return _val != absent(); }
+
+ inline T& get()
+ {
+ if(!valid()) throw std::runtime_error("Invalid object");
+ return _val;
+ }
+
+ inline T const& get() const
+ {
+ if(!valid()) throw std::runtime_error("Invalid object");
+ return _val;
+ }
+
+ inline optional_value& swap(optional_value&& x)
+ {
+ using namespace std;
+ std::swap(_val, x._val);
+ return *this;
+ }
+
+ static T absent()
+ { return Absent::value(); }
+
+ T _val;
+};
+
+// Canned absentee values
+
+/** Use a type's minimum value as an absentee. */
+template <typename T>
+struct absent_min
+{
+ static T value()
+ { return std::numeric_limits<T>::min(); }
+};
+
+/** Use 0 as an absentee value. */
+template <typename T>
+struct absent_zero
+{
+ static T value()
+ { return T(0); }
+};
+
+/** Use a type's maximum value as an absentee. */
+template <typename T>
+struct absent_max
+{
+ static T value()
+ { return std::numeric_limits<T>::max(); }
+};
+
+/**
+ * Use positive infinity as an absentee value. Here, T is essentially required
+ * to be a float, double, or long double. If we had concepts and a generic
+ * infinity() function, the requirements could be easily reduced.
+ */
+template <typename T>
+struct absent_inf
+{
+ static T value()
+ { return std::numeric_limits<T>::infinity(); }
+};
+
+/** Use negative infinity as an absentee value. See absent_inf for comments. */
+template <typename T>
+struct absent_neg_inf
+{
+ static T value()
+ { return -std::numeric_limits<T>::infinity(); }
+};
+
+/**
+ * The absent structure is used to provide default absent values for the
+ * optional_value template. There are two ways to extend this functionality.
+ * The first is to specialize this structure over your type and the second
+ * is to simply define a new one and use it as the Absent parameter for the
+ * optional_value class. This class provides a number of default specializations.
+ *
+ * Note that the default values of these simply inherit specific canned
+ * instances absent values.
+ */
+template <typename T> struct absent { static T value(); };
+template <typename T> struct absent<T*> : absent_zero<T*> { };
+template <> struct absent<int> : absent_max<int> { };
+template <> struct absent<unsigned int> : absent_max<unsigned int> { };
+template <> struct absent<float> : absent_inf<float> { };
+template <> struct absent<double> : absent_inf<double> { };
+
+} /* namespace boost */
+
+#endif
\ No newline at end of file