Update SENF to compile using g++ 4.3.2 (Ubuntu 8.10)

Examples/Sniffer/Sniffer.cc

@@ -114,11 +114,12 @@ int main(int argc, char const * argv[])
     std::cout << "Registered packets:\n\n";
     senf::dumpPacketRegistries(std::cout);
 
-    if (argc >= 3)
+    if (argc >= 3) {
         if (std::string(argv[1]) == "loop")
             return loop_main(argc,argv);
         else if (std::string(argv[1]) == "scheduler")
             return scheduler_main(argc,argv);
+    }
 
     std::cerr << "Usage: sniffer { loop | scheduler } [interface]" << std::endl;
     return 1;

PPI/IntervalTimer.test.cc

@@ -65,7 +65,7 @@ namespace {
     };
 
     bool is_close_clock(senf::ClockService::clock_type a, senf::ClockService::clock_type b,
-                        unsigned long delta = senf::ClockService::milliseconds(100))
+                        unsigned long delta)
     {
         return (a<b ? b-a : a-b ) < delta;
     }
@@ -78,7 +78,8 @@ BOOST_AUTO_UNIT_TEST(intervalTimer)
     senf::ppi::run();
     BOOST_CHECK_PREDICATE( is_close_clock,
                            (senf::ClockService::now())
-                           (start+senf::ClockService::milliseconds(400)) );
+                           (start+senf::ClockService::milliseconds(400))
+                           (senf::ClockService::milliseconds(100)) );
 }
 
 ///////////////////////////////cc.e////////////////////////////////////////

Packets/Packet.test.cc

@@ -290,7 +290,7 @@ COMPILE_FAIL(invalidAnnotation)
 
 #   else
 
-    BOOST_STATIC_ASSERT(( false ));
+    invalid_annotation_check_disabled();
 
 #   endif
 }

Scheduler/ClockService.test.cc

@@ -39,13 +39,7 @@
 namespace {
 
     bool is_close_clock(senf::ClockService::clock_type a, senf::ClockService::clock_type b, 
-                        unsigned long delta = senf::ClockService::milliseconds(100))
-    {
-        return (a<b ? b-a : a-b ) < delta;
-    }
-
-    bool is_close_pt(boost::posix_time::ptime a, boost::posix_time::ptime b,
-                     boost::posix_time::time_duration delta = boost::posix_time::milliseconds(100) )
+                        unsigned long delta)
     {
         return (a<b ? b-a : a-b ) < delta;
     }
@@ -69,7 +63,8 @@ BOOST_AUTO_UNIT_TEST(clockService)
     senf::ClockService::clock_type t2 (senf::ClockService::now());
     BOOST_CHECK_PREDICATE( is_close_clock,
                            (t1 + senf::ClockService::milliseconds(200)) 
-                           (t2) );
+                           (t2)
+                           (senf::ClockService::milliseconds(100)) );
 
     t1 = t2;
 
@@ -87,14 +82,16 @@ BOOST_AUTO_UNIT_TEST(clockService)
     delay(200);
     BOOST_CHECK_PREDICATE( is_close_clock,
                            (t1 + senf::ClockService::milliseconds(200))
-                           (senf::ClockService::now()) );
+                           (senf::ClockService::now())
+                           (senf::ClockService::milliseconds(100)) );
 
     // The next check validates that the clock service itimer/heartbeat_ is correctly reset after a
     // clock-skew is detected
 
     BOOST_CHECK_PREDICATE( is_close_clock,
                            (t1 + senf::ClockService::milliseconds(200))
-                           (senf::ClockService::now()) );
+                           (senf::ClockService::now()) 
+                           (senf::ClockService::milliseconds(100)) );
 }
 
 ///////////////////////////////cc.e////////////////////////////////////////

Scheduler/Console/Config.test.cc

@@ -77,7 +77,7 @@ BOOST_AUTO_UNIT_TEST(configBundle)
     TempFile cfg ("test.cfg");
     cfg << "dir1/fun1 foo; fun2;" << TempFile::close;
 
-    char * argv[] = { "", "--dir1-fun1=bar" };
+    char const * argv[] = { "", "--dir1-fun1=bar" };
 
     senf::console::ConfigBundle bundle(root);
     bundle.add( senf::console::FileConfig(cfg.name()) );

Scheduler/Console/Parse.ih

@@ -120,8 +120,8 @@ namespace detail {
 
                 // Invalid characters: All chars below \x20 (space) which are not space_p
                 // (don't put a \0 in the chset<> argument *string* ...)
-                invalid_p (
-                    boost::spirit::chset<>('\0') | boost::spirit::chset<>("\x01-\x20") - space_p ),
+                invalid_p ( (boost::spirit::chset<>('\0') 
+                             | boost::spirit::chset<>("\x01-\x20")) - space_p ),
 
                 // Valid word characters
                 word_p (

Scheduler/Console/ProgramOptions.cc

@@ -49,7 +49,7 @@ prefix_ void senf::console::detail::ProgramOptionsSource::v_parse(RestrictedExec
         nonOptions_->clear();
     if (argc_ <= 1)
         return;
-    char ** argp (argv_+1);
+    char const ** argp (argv_+1);
     int n (argc_-1);
     for (; n; --n, ++argp) {
         std::string arg (*argp);
@@ -151,7 +151,7 @@ senf::console::detail::ProgramOptionsSource::parseNonOption(std::string const &
 
 ///////////////////////////////////////////////////////////////////////////
 
-prefix_ void senf::console::parseOptions(int argc, char ** argv, DirectoryNode & root)
+prefix_ void senf::console::parseOptions(int argc, char const ** argv, DirectoryNode & root)
 {
     ProgramOptions opts (argc, argv, root);
     opts.parse();

Scheduler/Console/ProgramOptions.cci

@@ -34,13 +34,13 @@
 // senf::console::detail::ProgramOptionsSource
 
 prefix_ senf::console::detail::ProgramOptionsSource::ptr
-senf::console::detail::ProgramOptionsSource::create(int argc, char ** argv)
+senf::console::detail::ProgramOptionsSource::create(int argc, char const ** argv)
 {
     return ptr(new ProgramOptionsSource(argc,argv));
 }
 
 prefix_ senf::console::detail::ProgramOptionsSource::ProgramOptionsSource(int argc,
-                                                                          char ** argv)
+                                                                          char const ** argv)
     : argc_ (argc), argv_ (argv)
 {}
 
@@ -63,7 +63,7 @@ ShortOption(bool withArg_, std::string const & longOpt_)
 ///////////////////////////////////////////////////////////////////////////
 // senf::console::ProgramOptions
 
-prefix_ senf::console::ProgramOptions::ProgramOptions(int argc, char ** argv,
+prefix_ senf::console::ProgramOptions::ProgramOptions(int argc, char const ** argv,
                                                       DirectoryNode & root)
     : detail::BundleMixin (root), config_ (add(detail::ProgramOptionsSource::create(argc, argv)))
 {}
@@ -78,7 +78,7 @@ senf::console::ProgramOptions::alias(char letter, std::string const & longOpt, b
 ///////////////////////////////////////////////////////////////////////////
 
 prefix_ senf::console::detail::ProgramOptionsSource::ptr
-senf::console::OptionsConfig(int argc, char ** argv)
+senf::console::OptionsConfig(int argc, char const ** argv)
 {
     return detail::ProgramOptionsSource::create(argc, argv);
 }

Scheduler/Console/ProgramOptions.hh

@@ -72,7 +72,7 @@ namespace console {
         ///\name Structors and default members
         ///@{
         
-        ProgramOptions(int argc, char ** argv, DirectoryNode & root = root());
+        ProgramOptions(int argc, char const ** argv, DirectoryNode & root = root());
                                         ///< Create ProgramOptions parser for given options
                                         /**< The given argc/argv values are those passed to main by
                                              the operating system. Especially argv[0] is \e not an
@@ -113,7 +113,7 @@ namespace console {
 
         \related ProgramOptions
      */
-    void parseOptions(int argc, char ** argv, DirectoryNode & root = root());
+    void parseOptions(int argc, char const ** argv, DirectoryNode & root = root());
 
     /** \brief ConfigBundle source reading command line options
 
@@ -122,7 +122,7 @@ namespace console {
 
         \related ProgramOptions
      */
-    detail::ProgramOptionsSource::ptr OptionsConfig(int argc, char ** argv);
+    detail::ProgramOptionsSource::ptr OptionsConfig(int argc, char const ** argv);
 }}
 
 ///////////////////////////////hh.e////////////////////////////////////////

Scheduler/Console/ProgramOptions.ih

@@ -43,14 +43,14 @@ namespace detail {
     public:
         typedef boost::intrusive_ptr<ProgramOptionsSource> ptr;
 
-        static ptr create(int argc, char ** argv);
+        static ptr create(int argc, char const ** argv);
 
         template <class Container>
         ProgramOptionsSource & nonOptions(Container & container);
         ProgramOptionsSource & alias(char letter, std::string const & longOpt, bool withArg=false);
         
     private:
-        ProgramOptionsSource(int argc, char ** argv);
+        ProgramOptionsSource(int argc, char const ** argv);
         
         virtual void v_parse(RestrictedExecutor & executor);
 
@@ -86,7 +86,7 @@ namespace detail {
         typedef std::map<char, ShortOption> ShortOptions;
         
         int argc_;
-        char ** argv_;
+        char const ** argv_;
         CommandParser parser_;
         ShortOptions shortOptions_;
         boost::scoped_ptr<NonOptionContainer> nonOptions_;

Scheduler/Console/ProgramOptions.test.cc

@@ -58,7 +58,7 @@ BOOST_AUTO_UNIT_TEST(programOptions)
     root.mkdir("name-with-dashes").add("fun-2", &fun2);
 
     {
-        char * argv[] = { "", "--dir1-fun1=foo","--fun2" };
+        char const * argv[] = { "", "--dir1-fun1=foo","--fun2" };
         senf::console::ProgramOptions opts (sizeof(argv)/sizeof(argv[0]), argv, root);
 
         SENF_CHECK_NO_THROW( opts.parse() );
@@ -67,7 +67,7 @@ BOOST_AUTO_UNIT_TEST(programOptions)
     }
 
     {
-        char * argv[] = { "", "--d-f=foo","--fun" };
+        char const * argv[] = { "", "--d-f=foo","--fun" };
         senf::console::ProgramOptions opts (sizeof(argv)/sizeof(argv[0]), argv, root);
 
         val1 = "";
@@ -79,7 +79,7 @@ BOOST_AUTO_UNIT_TEST(programOptions)
     }
 
     {
-        char * argv[] = { "", "--name-w-fun" };
+        char const * argv[] = { "", "--name-w-fun" };
         senf::console::ProgramOptions opts (sizeof(argv)/sizeof(argv[0]), argv, root);
 
         val1 = "";
@@ -91,7 +91,7 @@ BOOST_AUTO_UNIT_TEST(programOptions)
     }
     
     {
-        char * argv[] = { "", "-ab" };
+        char const * argv[] = { "", "-ab" };
         senf::console::ProgramOptions opts(sizeof(argv)/sizeof(argv[0]), argv, root);
         opts
             .alias('a', "--dir1-fun1=baz")
@@ -106,7 +106,7 @@ BOOST_AUTO_UNIT_TEST(programOptions)
     }
 
     {
-        char * argv[] = { "", "-badoo" };
+        char const * argv[] = { "", "-badoo" };
         senf::console::ProgramOptions opts(sizeof(argv)/sizeof(argv[0]), argv, root);
         opts
             .alias('a', "--dir1-fun1", true)
@@ -121,7 +121,7 @@ BOOST_AUTO_UNIT_TEST(programOptions)
     }
 
     {
-        char * argv[] = { "", "-a","dii","-b" };
+        char const * argv[] = { "", "-a","dii","-b" };
         senf::console::ProgramOptions opts(sizeof(argv)/sizeof(argv[0]), argv, root);
         opts
             .alias('a', "--dir1-fun1", true)

Scheduler/Console/Server.cc

@@ -99,7 +99,7 @@ prefix_ senf::console::Server::Server(ServerHandle handle)
 
 prefix_ void senf::console::Server::newClient(int event)
 {
-    ServerHandle::ClientSocketHandle client (handle_.accept());
+    ServerHandle::ClientHandle client (handle_.accept());
     boost::intrusive_ptr<Client> p (new Client(*this, client));
     clients_.insert( p );
     SENF_LOG(( "Registered new client " << p.get() ));

Scheduler/Console/Server.hh

@@ -161,7 +161,7 @@ namespace console {
         static const unsigned INTERACTIVE_TIMEOUT = 500; // milliseconds;
 
     public:
-        typedef Server::ServerHandle::ClientSocketHandle ClientHandle;
+        typedef Server::ServerHandle::ClientHandle ClientHandle;
 
         ~Client();
 

Scheduler/Console/Server.ih

@@ -98,7 +98,7 @@ namespace detail {
     class ClientReader
     {
     public:
-        typedef ServerHandle::ClientSocketHandle ClientHandle;
+        typedef ServerHandle::ClientHandle ClientHandle;
 
         virtual ~ClientReader() = 0;
 

Socket/ClientSocketHandle.hh

@@ -106,7 +106,7 @@ namespace senf {
         /** This class will probably only be usable, if the \c CommunicationPolicy is \c
             ConnectedCommunicationPolicy and the \c AddressingPolicy is not \c
             NoAddressingPolicy. */
-        typedef ServerSocketHandle<SPolicy> ServerSocketHandle;
+        typedef ServerSocketHandle<SPolicy> ServerHandle;
 
         ///////////////////////////////////////////////////////////////////////////
         ///\name Structors and default members

Socket/ProtocolServerSocketHandle.test.cc

@@ -62,7 +62,7 @@ BOOST_AUTO_UNIT_TEST(protocolServerSocketHandle)
         OtherSocketHandle osh (h);
         h = senf::static_socket_cast<MySocketHandle>(osh);
 
-        MySocketHandle::ClientSocketHandle client = h.accept();
+        MySocketHandle::ClientHandle client = h.accept();
         BOOST_CHECK_EQUAL( client.fd(), -1 );
 
         BOOST_CHECK_EQUAL( h.dumpState(),

Socket/Protocols/INet/INet6Address.cci

@@ -127,7 +127,7 @@ prefix_ bool senf::INet6Address::inet4Mapped()
 prefix_ bool senf::INet6Address::multicast()
     const
 {
-    return (*this)[0] == 0xFFu || inet4Mapped() && inet4address().multicast();
+    return (*this)[0] == 0xFFu || (inet4Mapped() && inet4address().multicast());
 }
 
 prefix_ senf::INet6Address::ScopeId senf::INet6Address::scope()

Socket/ServerSocketHandle.cti

@@ -92,30 +92,30 @@ prefix_ void senf::ServerSocketHandle<SPolicy>::local(Address & addr)
 }
 
 template <class SPolicy>
-prefix_ typename senf::ServerSocketHandle<SPolicy>::ClientSocketHandle
+prefix_ typename senf::ServerSocketHandle<SPolicy>::ClientHandle
 senf::ServerSocketHandle<SPolicy>::accept()
 {
-    return ClientSocketHandle(this->body().clone(
-                                  SPolicy::CommunicationPolicy::accept(*this), false));
+    return ClientHandle(this->body().clone(
+                            SPolicy::CommunicationPolicy::accept(*this), false));
 }
 
 template <class SPolicy>
-prefix_ std::pair<typename senf::ServerSocketHandle<SPolicy>::ClientSocketHandle,
+prefix_ std::pair<typename senf::ServerSocketHandle<SPolicy>::ClientHandle,
                   typename senf::ServerSocketHandle<SPolicy>::Address>
 senf::ServerSocketHandle<SPolicy>::acceptfrom()
 {
 
     Address address;
-    ClientSocketHandle handle = acceptfrom(address);
+    ClientHandle handle = acceptfrom(address);
     return std::make_pair(handle,address);
 }
 
 template <class SPolicy>
-prefix_ typename senf::ServerSocketHandle<SPolicy>::ClientSocketHandle
+prefix_ typename senf::ServerSocketHandle<SPolicy>::ClientHandle
 senf::ServerSocketHandle<SPolicy>::acceptfrom(Address & addr)
 {
-    return ClientSocketHandle(this->protocol().clone(),
-                              SPolicy::CommunicationPolicy::accept(*this,addr));
+    return ClienttHandle(this->protocol().clone(),
+                         SPolicy::CommunicationPolicy::accept(*this,addr));
 }
 
 ///////////////////////////////////////////////////////////////////////////

Socket/ServerSocketHandle.hh

@@ -90,7 +90,7 @@ namespace senf {
          */
         typedef typename boost::call_traits<Address>::param_type AddressParam;
         /// Corresponding client socket handle with the same policy
-        typedef ClientSocketHandle<SPolicy> ClientSocketHandle;
+        typedef ClientSocketHandle<SPolicy> ClientHandle;
 
         ///////////////////////////////////////////////////////////////////////////
         ///\name Structors and default members
@@ -171,17 +171,15 @@ namespace senf {
 
             \returns handle of new client connection
          */
-        ClientSocketHandle
-                     accept       ();
-        std::pair<ClientSocketHandle, Address>
+        ClientHandle accept       ();
+        std::pair<ClientHandle, Address>
                      acceptfrom   ();   ///< Accept new connection
                                         /**< This variant will additionally return the remote
                                            address of the client
                                            \returns \c std::pair with client handle and client
                                            address.
                                            \see \ref accept() */
-        ClientSocketHandle
-                     acceptfrom   (Address & addr);
+        ClientHandle acceptfrom   (Address & addr);
                                         ///< Accept new connection
                                         /**< This variant will additionally return the remote
                                            address of the client

Socket/ServerSocketHandle.test.cc

@@ -84,7 +84,7 @@ BOOST_AUTO_UNIT_TEST(serverSocketHandle)
     BOOST_CHECK_EQUAL( myh.local(), 2u );
 
     {
-        MySocketHandle::ClientSocketHandle client = myh.accept();
+        MySocketHandle::ClientHandle client = myh.accept();
         BOOST_CHECK_EQUAL( client.fd(), -1 );
     }