Packets: Add introductory parse helper documentation

Utils: Implement ErrnoException

Packets/MPEGDVBBundle/DSMCCSection.hh

@@ -60,7 +60,7 @@ namespace senf {
 
         SENF_PARSER_FIELD    ( sec_num             , Parse_UInt8   );
         SENF_PARSER_FIELD    ( last_sec_num        , Parse_UInt8   );
-        
+
         SENF_PARSER_FINALIZE( Parse_DSMCCSection );
 
         Parse_UInt32 crc() const { return parse<Parse_UInt32>( data().size()-4 ); }

Packets/ParseInt.hh

@@ -299,6 +299,8 @@ namespace senf {
         ///////////////////////////////////////////////////////////////////////////
 
         typedef boost::int32_t value_type;
+        static size_type const start_bit = Start;
+        static size_type const end_bit = End;
         static size_type const fixed_bytes = (End-1)/8+1;
 
         value_type value() const {
@@ -352,6 +354,8 @@ namespace senf {
         ///////////////////////////////////////////////////////////////////////////
 
         typedef boost::uint32_t value_type;
+        static size_type const start_bit = Start;
+        static size_type const end_bit = End;
         static size_type const fixed_bytes = (End-1)/8+1;
 
         value_type value() const { return detail::packet::parse_bitfield<Start,End>::parse(i()); }
@@ -393,6 +397,7 @@ namespace senf {
         ///////////////////////////////////////////////////////////////////////////
 
         typedef bool value_type;
+        static size_type const bit = Bit;
         static size_type const fixed_bytes = Bit/8+1;
 
         value_type value() const { return i()[Bit/8] & (1<<(7-(Bit%8))); }

Scheduler/ReadHelper.ct

@@ -85,7 +85,7 @@ prefix_ void senf::ReadHelper<Handle>::process(Handle handle,
         }
     }
     catch (senf::SystemException const & ex) {
-        errno_ = ex.err;
+        errno_ = ex.code();
         done();
         return;
     }

Scheduler/WriteHelper.ct

@@ -87,7 +87,7 @@ prefix_ void senf::WriteHelper<Handle>::process(Handle handle,
         }
     }
     catch (senf::SystemException const & ex) {
-        errno_ = ex.err;
+        errno_ = ex.code();
         done();
         return;
     }

Utils/Exception.cc

@@ -39,16 +39,40 @@ prefix_ void senf::SystemException::init()
     // however all other solutions to format the message are terribly
     // ugly (since thay must use a static and shared buffer ...)
     std::stringstream s;
-    if (where)
-        s << where << ": ";
-    s << "(" << err << ") " << std::strerror(err);
+    if (where_)
+        s << where_ << ": ";
+    s << "(" << code_ << ") " << description();
     buffer_ = s.str();
 }
 
-prefix_ char const * senf::SystemException::what()
-    const throw()
+prefix_ void senf::throwErrno(char const * where, int code)
 {
-    return buffer_.c_str();
+    switch (code) {
+
+    // BOOST_PP_REPEAT is limited to 256 repetitions. The max errno value I found in any header file
+    // was somewhere around 530 or so. I assume going to 1024 will be good enough. This explicit
+    // code will be optimized into a jump table by g++ (which is more efficient than trying to do
+    // the table oneself)
+
+#   define ExceptionCase(z, n, data) case n: throw ErrnoException<n>(where);
+    BOOST_PP_REPEAT(256, ExceptionCase, _) ;
+#   undef ExceptionCase
+
+#   define ExceptionCase(z, n, data) case 256+n: throw ErrnoException<256+n>(where);
+    BOOST_PP_REPEAT(256, ExceptionCase, _) ;
+#   undef ExceptionCase
+
+#   define ExceptionCase(z, n, data) case 512+n: throw ErrnoException<512+n>(where);
+    BOOST_PP_REPEAT(256, ExceptionCase, _) ;
+#   undef ExceptionCase
+
+#   define ExceptionCase(z, n, data) case 768+n: throw ErrnoException<768+n>(where);
+    BOOST_PP_REPEAT(256, ExceptionCase, _) ;
+#   undef ExceptionCase
+
+    default:
+        throw SystemException(where, code);
+    }
 }
 
 ///////////////////////////////cc.e////////////////////////////////////////

Utils/Exception.cci

@@ -21,26 +21,95 @@
     \brief Exception inline non-template implementation */
 
 // Custom includes
+#include <errno.h>
+#include <cstring>
 
 #define prefix_ inline
 ///////////////////////////////cci.p///////////////////////////////////////
 
-prefix_  senf::SystemException::SystemException(int err_)
-    : where(0), err(err_)
+prefix_ senf::SystemException::SystemException()
+    : where_(0), code_(errno)
 {
     init();
 }
 
-prefix_ senf::SystemException::SystemException(char const * where_, int err_)
-    : where(where_), err(err_)
+prefix_  senf::SystemException::SystemException(int code)
+    : where_(0), code_(code)
 {
     init();
 }
 
+prefix_ senf::SystemException::SystemException(char const * where)
+    : where_(where), code_(errno)
+{
+    init();
+}
+
+prefix_ senf::SystemException::SystemException(char const * where, int code)
+    : where_(where), code_(code)
+{
+    init();
+}
+
+prefix_ char const * senf::SystemException::what()
+    const throw()
+{
+    return buffer_.c_str();
+}
+
+prefix_ char const * senf::SystemException::where()
+    const
+{
+    return where_;
+}
+
+prefix_ int senf::SystemException::code()
+    const
+{
+    return code_;
+}
+
+prefix_ char const * senf::SystemException::description()
+    const
+{
+    return std::strerror(code_);
+}
+
+prefix_ bool senf::SystemException::anyOf(int c0, int c1, int c2, int c3, int c4, int c5,
+                                          int c6, int c7, int c8, int c9)
+{
+    return 
+        (c0 && code_ == c0) ||
+        (c1 && code_ == c1) ||
+        (c2 && code_ == c2) ||
+        (c3 && code_ == c3) ||
+        (c4 && code_ == c4) ||
+        (c5 && code_ == c5) ||
+        (c6 && code_ == c6) ||
+        (c7 && code_ == c7) ||
+        (c8 && code_ == c8) ||
+        (c9 && code_ == c9);
+}
+
 prefix_  senf::SystemException::~SystemException()
     throw()
 {}
 
+prefix_ void senf::throwErrno()
+{
+    throwErrno(0, errno);
+}
+
+prefix_ void senf::throwErrno(char const * where)
+{
+    throwErrno(where, errno);
+}
+
+prefix_ void senf::throwErrno(int code)
+{
+    throwErrno(0, code);
+}
+
 ///////////////////////////////cci.e///////////////////////////////////////
 #undef prefix_
 

Utils/Exception.cti

+// $Id$
+//
+// Copyright (C) 2007 
+// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
+// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
+//     Stefan Bund <g0dil@berlios.de>
+//
+// This program 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.
+//
+// This program 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 this program; if not, write to the
+// Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+/** \file
+    \brief Exception inline template implementation */
+
+//#include "Exception.ih"
+
+// Custom includes
+
+#define prefix_ inline
+///////////////////////////////cti.p///////////////////////////////////////
+
+template <int Code>
+prefix_ senf::ErrnoException<Code>::ErrnoException()
+    : SystemException(fixed_code)
+{}
+
+template <int Code>
+prefix_ senf::ErrnoException<Code>::ErrnoException(char const * where)
+    : SystemException(where,fixed_code)
+{}
+
+/////////////////////////////cti.e///////////////////////////////////////
+#undef prefix_
+
+
+// Local Variables:
+// mode: c++
+// fill-column: 100
+// comment-column: 40
+// c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// End:

Utils/Exception.hh

@@ -29,6 +29,8 @@
 // Custom includes
 #include <exception>
 #include <string>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/preprocessor/cat.hpp>
 
 //#include "Exception.mpp"
 ///////////////////////////////hh.p////////////////////////////////////////
@@ -39,39 +41,69 @@ namespace senf {
 
         This exception is thrown to signal generic errno failures.
 
-        \todo make where and err accessors and make the member vars private
+        \todo make where and err accessors and make the member variables private
 
-        \idea Add a template class derived from SystemException which
-        takes the error number as a numeric argument. This allows
-        catching specific errno conditions: ErrnoException<EPIPE> etc.
+        \idea Add a template class derived from SystemException which takes the error number as a
+        numeric argument. This allows catching specific errno conditions: ErrnoException<EPIPE> etc.
 
-        \idea Add a generic error thrower which takes the origin
-        string and errno value as an argument and will throw a
-        corresponding template class instance. This would just be a
-        big switch statement containing all possible errno values,
-        probably created using some macro metaprogramming.
+        \idea Add a generic error thrower which takes the origin string and errno value as an
+        argument and will throw a corresponding template class instance. This would just be a big
+        switch statement containing all possible errno values, probably created using some macro
+        meta-programming.
      */
     class SystemException : public std::exception
     {
     public:
-        explicit SystemException(int err); ///< SystemException without error lokus info
-                                        /**< \param[in] err error number (the errno value) */
-        SystemException(char const * where, int err); ///< SystemException with error location info
+        SystemException();              ///< SystemException without error location infor
+                                        /**< The error code is taken from the current value of the
+                                             global 'errno' variable  */
+
+        explicit SystemException(int code); ///< SystemException without error location info
+                                        /**< \param[in] code error number (the errno value) */
+
+        explicit SystemException(char const * where); ///< SystemException with error location info
+                                        /**< The error code is taken from the current value of the
+                                             global 'errno' variable 
+                                             \param[in] where description of error origin */
+
+        SystemException(char const * where, int code); ///< SystemException with error location info 
                                         /**< \param[in] where description of error origin
-                                             \param[in] err error number (the errno value) */
+                                             \param[in] code error number (the errno value) */
 
         virtual char const * what() const throw(); ///< Return verbose error description
 
-        char const * where; ///< Error origin
-        int err; ///< Error number
+        char const * where() const;     ///< Error origin
+        int code() const;               ///< Error code (errno number)
+        char const * description() const; ///< Error description (strerror() value)
+
+        bool anyOf(int c0, int c1=0, int c2=0, int c3=0, int c4=0, int c5=0, 
+                   int c6=0, int c7=0, int c8=0, int c9=0);
 
         virtual ~SystemException() throw();
 
     private:
         void init();
+
+        char const * const where_;
+        int const code_;
         std::string buffer_;
     };
 
+    template <int Code>
+    class ErrnoException : public SystemException
+    {
+    public:
+        static int const fixed_code = Code;
+
+        ErrnoException();
+        explicit ErrnoException(char const * where);
+    };
+
+    void throwErrno();
+    void throwErrno(char const * where);
+    void throwErrno(int code);
+    void throwErrno(char const * where, int code);
+
     enum NoThrow_t { nothrow };
 
 }
@@ -79,7 +111,7 @@ namespace senf {
 ///////////////////////////////hh.e////////////////////////////////////////
 #include "Exception.cci"
 //#include "Exception.ct"
-//#include "Exception.cti"
+#include "Exception.cti"
 #endif
 
 

Utils/Exception.test.cc

+// $Id$
+//
+// Copyright (C) 2007 
+// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
+// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
+//     Stefan Bund <g0dil@berlios.de>
+//
+// This program 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.
+//
+// This program 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 this program; if not, write to the
+// Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+/** \file
+    \brief Exception.test unit tests */
+
+//#include "Exception.test.hh"
+//#include "Exception.test.ih"
+
+// Custom includes
+#include "Exception.hh"
+
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_tools.hpp>
+
+#define prefix_
+///////////////////////////////cc.p////////////////////////////////////////
+
+BOOST_AUTO_UNIT_TEST(errnoException)
+{}
+
+///////////////////////////////cc.e////////////////////////////////////////
+#undef prefix_
+
+
+// Local Variables:
+// mode: c++
+// fill-column: 100
+// comment-column: 40
+// c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// End:

senf.dict

@@ -59,6 +59,9 @@ ElementParser
 endcode
 enum
 eof
+EPIPE
+errno
+ErrnoException
 ErrorException
 eth
 ethernet
@@ -195,6 +198,7 @@ ParseList
 ParseListB
 ParseListN
 parseNextAs
+parserlanguage
 ParseVec
 PassiveConnector
 PassiveInput
@@ -260,6 +264,7 @@ someVector
 std
 stefan
 STL
+strerror
 struct
 structors
 SyntaxException