Ticket #408: pserror-stream.patch

trunk/source/ps/Errors.cpp

@@ -448 +448 @@
 PSRETURN PSERROR_Xeromyces_XMLParseError::getCode() const { return 0x0d000002; }
 
 
-PSERROR::PSERROR(const char* msg) : m_msg(msg) { }
+PSERROR::PSERROR(const char* msg)
+{
+    if (msg)
+        m_msg = msg;
+    m_os << m_msg;
+}
 
 const char* PSERROR::what() const throw ()
 {
-    return m_msg ? m_msg : GetErrorString(getCode());
+    if (m_msg.empty())
+        return GetErrorString(getCode());
+    return m_msg.c_str();
+}
+
+PSERROR::PSERROR(const PSERROR &a) : m_msg(a.m_msg)
+{
+    m_os << m_msg;
 }
 
 const char* GetErrorString(PSRETURN code)

trunk/source/ps/Errors.h

@@ -56 +56 @@
 
     void bar() { throw PSERROR_ModuleName_FrobnificationFailed("More informative message"); }
 
+    void foobar() { throw PSERROR_ModuleName_FrobnificationFailed("More informative message") << something << " more text"; }
+
     try {
         foo();
     } catch (PSERROR_ModuleName_FrobnificationFailed& e) {
@@ -71 +73 @@
 */
 
 #include <exception>
+#include <sstream>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+#include "lib/utf8.h"
 
 typedef u32 PSRETURN;
 
@@ -80 +88 @@
     PSERROR(const char* msg);
     virtual const char* what() const throw ();
     virtual PSRETURN getCode() const = 0; // for functions that catch exceptions then return error codes
+
+    PSERROR(const PSERROR &a);
+    ~PSERROR() throw () {}
 private:
-    const char* m_msg;
+    std::string m_msg;
+    std::ostringstream m_os;
+    
+    template <typename T, typename U>
+    friend
+    typename boost::enable_if<boost::is_base_of<PSERROR, T>, T>::type
+    operator<<(T err, const U& a)
+    {
+        err.m_os << a;
+        err.m_msg = err.m_os.str();
+        return err;
+    }
+    template <typename T>
+    friend
+    typename boost::enable_if<boost::is_base_of<PSERROR, T>, T>::type
+    operator<<(T err, const std::wstring& a)
+    {
+        err.m_os << utf8_from_wstring(a, NULL);
+        err.m_msg = err.m_os.str();
+        return err;
+    }
 };
 
 #define ERROR_GROUP(a) class PSERROR_##a : public PSERROR { protected: PSERROR_##a(const char* msg); }; \

trunk/source/ps/tests/test_Errors.h

@@ +1 @@
+/* Copyright (C) 2013 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "lib/self_test.h"
+
+#include "ps/Errors.h"
+#include "ps/Errors.cpp"
+
+class TestPSERROR : public CxxTest::TestSuite 
+{
+public:
+    void test_throwcatch()
+    {
+        int cnt = 0;
+        
+        try
+        {
+            cnt--;
+            throw PSERROR_File_OpenFailed();
+        }
+        catch (PSERROR_File_OpenFailed &e)
+        {
+            TS_ASSERT_STR_EQUALS(e.what(), "File_OpenFailed");
+            cnt++;
+        }
+
+        try
+        {
+            cnt--;
+            throw PSERROR_File_OpenFailed("test") << 123 << "abc";
+        }
+        catch (PSERROR_File_OpenFailed &e) // exact match
+        {
+            TS_ASSERT_STR_EQUALS(e.what(), "test123abc");
+            cnt++;
+        }
+
+        try
+        {
+            cnt--;
+            throw PSERROR_File_OpenFailed("test") << 123 << "abc";
+        }
+        catch (PSERROR &e) // parent
+        {
+            TS_ASSERT_STR_EQUALS(e.what(), "test123abc");
+            cnt++;
+        }
+
+        try
+        {
+            cnt--;
+            std::wstring wstr(L"äöü");
+            throw PSERROR_File_OpenFailed("test") << 123 << wstr;
+        }
+        catch (PSERROR_File_OpenFailed &e)
+        {
+            TS_ASSERT_STR_EQUALS(e.what(), "test123äöü");
+            cnt++;
+        }
+        
+        TS_ASSERT_EQUALS(cnt, 0);
+    }
+};