Subject: [Boost-commit] svn:boost r49164 - sandbox/SOC/2008/graphs/trunk/boost
From: asutton_at_[hidden]
Date: 2008-10-07 10:53:07
Author: asutton
Date: 2008-10-07 10:53:06 EDT (Tue, 07 Oct 2008)
New Revision: 49164
URL: http://svn.boost.org/trac/boost/changeset/49164
Log:
- Added specialization on T*
- Rewrote operator bool() to use unspecified-bool idiom.
- Implemented equality operators that are probably wrong.
Text files modified:
sandbox/SOC/2008/graphs/trunk/boost/optional.hpp | 104 ++++++++++++++++++++++++++++++++++++---
1 files changed, 96 insertions(+), 8 deletions(-)
Modified: sandbox/SOC/2008/graphs/trunk/boost/optional.hpp
==============================================================================
--- sandbox/SOC/2008/graphs/trunk/boost/optional.hpp (original)
+++ sandbox/SOC/2008/graphs/trunk/boost/optional.hpp 2008-10-07 10:53:06 EDT (Tue, 07 Oct 2008)
@@ -1,6 +1,6 @@
-#ifndef BOOST_WEAK_OPTIONAL_HPP
-#define BOOST_WEAK_OPTIONAL_HPP
+#ifndef BOOST_OPTIONAL_HPP
+#define BOOST_OPTIONAL_HPP
#include <utility>
@@ -13,8 +13,13 @@
* isn't nearly as graceful.
*/
template <typename T>
-struct optional
+class optional
{
+ typedef optional<T> this_type;
+ typedef T* this_type::* unspecified_bool_type;
+public:
+ typedef T value_type;
+
// Does not initialize the optional.
optional()
: _ptr(0)
@@ -42,12 +47,18 @@
optional& operator=(optional const& x)
{ return swap(optional(x)); }
- optional& operator=(optional&& x)
+ inline optional& operator=(optional&& x)
{ return swap(optional().swap(x)); }
- optional& operator=(T const& x)
+ inline optional& operator=(T const& x)
{ return swap(optional(x)); }
+ inline bool operator==(optional const& x) const
+ { return get() != x.get(); }
+
+ inline bool operator!=(optional const& x) const
+ { return !(*this == x); }
+
T& operator*()
{ return get(); }
@@ -60,8 +71,8 @@
T const* operator->() const
{ return _ptr; }
- operator bool() const
- { return _ptr != 0; }
+ operator unspecified_bool_type() const
+ { return _ptr ? &this_type::_ptr : 0; }
bool valid() const
{ return _ptr != 0; }
@@ -115,6 +126,83 @@
T* _ptr;
};
-}
+/**
+ * Specialize the optional type for pointers. This basically removes the
+ * encoding of the object into the character buffer. The reason that this is
+ * specilized on pointers is that the null pointer is a built-in indicator of
+ * optionality. If null, the pointer does not exist.
+ *
+ * The purpose of this overload is to make optional ptrs work mostly just like
+ * regular pointers.
+ *
+ * @todo Should this include ptr math to make it look like an iterable ptr?
+ */
+template <typename T>
+class optional<T*>
+{
+ typedef optional<T*> this_type;
+ typedef T* this_type::* unspecified_bool_type;
+public:
+ typedef T* value_type;
+
+ optional() : _ptr(0) { }
+ optional(optional const& x) : _ptr(x._ptr) { }
+ optional(optional&& x) : _ptr(std::move(x._ptr)) { }
+ optional(T* x) : _ptr(x) { }
+
+ optional& operator=(optional const& x)
+ { return swap(optional(x)); }
+
+ optional& operator=(optional&& x)
+ { return swap(x); }
+
+ optional& operator=(T* x)
+ { return swap(optional(x)); }
+
+ inline bool operator==(optional const& x) const
+ { return _ptr == x._ptr; }
+
+ inline bool operator!=(optional const& x) const
+ { return _ptr != x._ptr; }
+
+ T& operator*()
+ { return get(); }
+
+ T const& operator*() const
+ { return get(); }
+
+ T* operator->()
+ { return _ptr; }
+
+ T const* operator->() const
+ { return _ptr; }
+
+ operator unspecified_bool_type() const
+ { return _ptr ? &this_type::_ptr : 0; }
+
+ bool valid() const
+ { return _ptr != 0; }
+
+ T& get()
+ { return *_ptr; }
+
+ T const& get() const
+ { return *_ptr; }
+
+ // Reset the internal pointer to indicate uninitialized.
+ void reset()
+ { _ptr = 0; }
+
+ optional& swap(optional&& x)
+ {
+ using std::swap;
+ swap(_ptr, x._ptr);
+ return *this;
+ }
+
+ T* _ptr;
+};
+
+} /* namespace boost */
#endif