Bring into compliance with N2066, TR2 Diagnostics Enhancements. Tests passing on Win32, Linux, on most modern compilers.

[SVN r35823]
2006-11-03 16:57:30 +00:00
commit f3c8c74656
11 changed files with 1445 additions and 0 deletions
@@ -0,0 +1,147 @@
+//  boost/system/error_code.hpp  ---------------------------------------------//
+
+//  Copyright Beman Dawes 2006
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/filesystem
+
+#ifndef BOOST_SYSTEM_ERROR_CODE_HPP
+#define BOOST_SYSTEM_ERROR_CODE_HPP
+
+#include <boost/system/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/assert.hpp>
+#include <boost/operators.hpp>
+#include <boost/detail/identifier.hpp>
+#include <string>
+#include <stdexcept>
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+namespace boost
+{
+  namespace system
+  {
+# ifndef BOOST_NO_STD_WSTRING  // workaround Cygwin's lack of wstring_t
+    typedef std::wstring wstring_t;
+# else
+    typedef std::basic_string<wchar_t> wstring_t;
+# endif
+
+    class error_code;
+
+    // typedefs for registering additional decoders  -------------------------//
+
+    typedef int          (*errno_decoder)( const error_code & );
+    typedef std::string  (*message_decoder)( const error_code & );
+    typedef wstring_t    (*wmessage_decoder)( const error_code & );
+
+    //  class error_category  ------------------------------------------------//
+
+    class BOOST_SYSTEM_DECL error_category : public identifier< uint_least32_t, error_category >
+    {
+    public:
+      error_category()
+        : boost::identifier< uint_least32_t, error_category >(0){}
+      explicit error_category( value_type v )
+        : boost::identifier< uint_least32_t, error_category >(v){}
+    };
+
+    //  predefined error categories  -----------------------------------------//
+
+    const error_category  errno_ecat(0);  // unspecified value
+
+# ifdef BOOST_WINDOWS_API
+    const error_category  native_ecat(1); // unspecified value
+# else
+    const error_category  native_ecat(0); // unspecified value
+# endif
+
+    //  class error_code  ----------------------------------------------------//
+
+    class BOOST_SYSTEM_DECL error_code
+    {
+    public:
+      typedef boost::int_least32_t  value_type;
+
+      // constructors:
+      error_code()
+        : m_value(0), m_category(errno_ecat) {}
+      error_code( value_type val, error_category cat )
+        : m_value(val), m_category(cat) {}
+
+
+      // observers:
+      value_type      value() const         { return m_value; }
+      error_category  category() const      { return m_category; }
+      int             to_errno() const;  // name chosen to limit surprises
+                                         // see Kohlhoff Jun 28 '06
+      std::string     message() const;
+      wstring_t       wmessage() const;
+
+      void assign( value_type val, const error_category & cat )
+      { 
+        m_value = val;
+        m_category = cat;
+      }
+
+      // relationals:
+      bool operator==( const error_code & rhs ) const
+      {
+        return value() == rhs.value() && category() == rhs.category();
+      }
+      bool operator!=( const error_code & rhs ) const
+      {
+        return !(*this == rhs);
+      }
+      bool operator<( const error_code & rhs ) const
+      {
+        return category() < rhs.category() 
+          || ( category() == rhs.category() && value() < rhs.value() );
+      }
+      bool operator<=( const error_code & rhs ) const { return *this == rhs || *this < rhs; }
+      bool operator> ( const error_code & rhs ) const { return !(*this <= rhs); }
+      bool operator>=( const error_code & rhs ) const { return !(*this < rhs); }
+
+      typedef void (*unspecified_bool_type)();
+      static void unspecified_bool_true() {}
+
+      operator unspecified_bool_type() const  // true if error
+      { 
+        return m_value == value_type() ? 0 : unspecified_bool_true;
+      }
+
+      bool operator!() const  // true if no error
+      {
+        return m_value == value_type();
+      }
+
+      // statics:
+      static error_category new_category( errno_decoder ed = 0,
+        message_decoder md = 0, wmessage_decoder wmd = 0 );
+      static bool get_decoders( error_category cat, errno_decoder & ed,
+        message_decoder & md,  wmessage_decoder & wmd );
+
+    private:
+      value_type      m_value;
+      error_category  m_category;
+    };
+
+    //  non-member functions  ------------------------------------------------//
+
+    inline std::size_t hash_value( const error_code & ec )
+    {
+      return static_cast<std::size_t>(ec.value())
+        + (static_cast<std::size_t>(ec.category().value()) << 16 );
+    }
+
+  } // namespace system
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+
+#endif // BOOST_SYSTEM_ERROR_CODE_HPP
+
+