updated tour

doc/00100-GuidedTour.page

@@ -50,9 +50,9 @@ Basic support for Unicode text is also available in the form of classes
 that convert text between different character encodings, including UTF-8
 and UTF-16. Support for formatting and parsing numbers is there,
 including a typesafe variant of sprintf. Regular expressions based on
-the well-known PCRE library (http://www.pcre.org) are provided as well. 
+the well-known PCRE library (http://www.pcre.org) are provided as well.
 
-POCO gives you classes for handling dates and times in various variants. 
+POCO gives you classes for handling dates and times in various variants.
 For accessing the file system, POCO has Poco::File and Poco::Path classes, as well as a
 Poco::DirectoryIterator class. In many applications, some parts of the
 application need to tell other parts that something has happened. In
@@ -67,21 +67,21 @@ and a pointer to a member function. The event can be fired by calling
     #include "Poco/BasicEvent.h"
     #include "Poco/Delegate.h"
     #include <iostream>
-    
+
     using Poco::BasicEvent;
-    using Poco::Delegate;
+    using Poco::delegate;
-    
+
     class Source
     {
     public:
         BasicEvent<int> theEvent;
-    
+
         void fireEvent(int n)
         {
             theEvent(this, n);
         }
     };
-    
+
     class Target
     {
     public:
@@ -90,20 +90,18 @@ and a pointer to a member function. The event can be fired by calling
             std::cout << "onEvent: " << arg << std::endl;
         }
     };
-    
+
     int main(int argc, char** argv)
     {
         Source source;
         Target target;
-    
+
-        source.theEvent += Delegate<Target, int>(
+        source.theEvent += delegate(&target, &Target::onEvent);
-            &target, &Target::onEvent);
+
-    
         source.fireEvent(42);
-    
+
-        source.theEvent -= Delegate<Target, int>(
+        source.theEvent -= delegate(&target, &Target::onEvent);
-            &target, &Target::onEvent);
+
-    
         return 0;
     }
 ----
@@ -111,7 +109,7 @@ and a pointer to a member function. The event can be fired by calling
 
 The stream classes available in POCO have already been mentioned. These are
 augmented by Poco::BinaryReader and Poco::BinaryWriter for writing binary data to
-streams, automatically and transparently handling byte order issues. 
+streams, automatically and transparently handling byte order issues.
 
 In complex multithreaded applications, the only way to find problems or
 bugs is by writing extensive logging information. POCO provides a
@@ -120,7 +118,7 @@ routing to different channels, and formatting of log messages. Log
 messages can be written to the console, a file, the Windows Event Log,
 the Unix syslog daemon, or to the network. If the channels provided by
 POCO are not sufficient, it is easy to extend the logging framework with
-new classes. 
+new classes.
 
 For loading (and unloading) shared libraries at runtime,
 POCO has a low-level Poco::SharedLibrary class. Based on it is the Poco::ClassLoader
@@ -128,13 +126,13 @@ class template and supporting framework, allowing dynamic loading and
 unloading of C++ classes at runtime, similar to what's available to Java
 and .NET developers. The class loader framework also makes it a breeze
 to implement plug-in support for applications in a platform-independent
-way. 
+way.
 
 Finally, POCO Foundation contains multithreading abstractions at
 different levels. Starting with a Poco::Thread class and the usual
-synchronization primitives (Poco::Mutex, Poco::ScopedLock, Poco::Event, 
+synchronization primitives (Poco::Mutex, Poco::ScopedLock, Poco::Event,
-Poco::Semaphore, Poco::RWLock), a Poco::ThreadPool class and support for 
+Poco::Semaphore, Poco::RWLock), a Poco::ThreadPool class and support for
-thread-local storage, also high level abstractions like active objects are 
+thread-local storage, also high level abstractions like active objects are
 available. Simply speaking, an active object is an object that has methods executing in
 their own thread. This makes asynchronous member function calls possible
 -- call a member function, while the function executes, do a bunch of
@@ -149,35 +147,35 @@ function's return value.
     #include "Poco/ActiveResult.h"
     #include <utility>
     #include <iostream>
-    
+
     using Poco::ActiveMethod;
     using Poco::ActiveResult;
-    
+
     class ActiveAdder
     {
     public:
         ActiveAdder(): add(this, &ActiveAdder::addImpl)
         {
         }
-    
+
         ActiveMethod<int, std::pair<int, int>, ActiveAdder> add;
-    
+
     private:
         int addImpl(const std::pair<int, int>& args)
         {
             return args.first + args.second;
         }
     };
-    
+
     int main(int argc, char** argv)
     {
         ActiveAdder adder;
-    
+
         ActiveResult<int> sum = adder.add(std::make_pair(1, 2));
         // do other things
         sum.wait();
         std::cout << sum.data() << std::endl;
-    
+
         return 0;
     }
 ----
@@ -196,14 +194,14 @@ reads through the XML document and notifies the application whenever it
 encounters an element, character data, or other XML artifact. A SAX
 parser does not need to load the complete XML document into memory, so
 it can be used to parse huge XML files efficiently. In contrast, DOM
-(Document Object Model, http://www.w3.org/DOM/) gives the application 
+(Document Object Model, http://www.w3.org/DOM/) gives the application
 complete access to an XML
 document, using a tree-style object hierarchy. For this to work, the DOM
 parser provided by POCO has to load the entire document into memory. To
 reduce the memory footprint of the DOM document, the POCO DOM
 implementation uses string pooling, storing frequently occuring strings
 such as element and attribute names only once. The XML library is based
-on the Expat open source XML parser library (http://www.libexpat.org). 
+on the Expat open source XML parser library (http://www.libexpat.org).
 Built on top of Expat
 are the SAX interfaces, and built on top of the SAX interfaces is the
 DOM implementation. For strings, the XML library uses <[std::string]>, with
@@ -220,7 +218,7 @@ Included is support for handling command line arguments (validation,
 binding to configuration properties, etc.) and managing configuration
 information. Different configuration file formats are supported --
 Windows-style INI files, Java-style property files, XML files and the
-Windows registry. 
+Windows registry.
 
 For server applications, the framework provides
 transparent support for Windows services and Unix daemons. Every server
@@ -234,18 +232,18 @@ executed from the command line, which makes testing and debugging easier.
 POCO's Net library makes it easy to write network-based applications. No
 matter whether your application simply needs to send data over a plain
 TCP socket, or whether your application needs a full-fledged built-in
-HTTP server, you will find something useful in the Net library. 
+HTTP server, you will find something useful in the Net library.
 
 At the lowest level, the Net library contains socket classes, supporting TCP
 stream and server sockets, UDP sockets, multicast sockets, ICMP and raw
 sockets. If your application needs secure sockets, these are available
-in the NetSSL library, implemented using OpenSSL (http://www.openssl.org). 
+in the NetSSL library, implemented using OpenSSL (http://www.openssl.org).
 Based on the socket classes are two frameworks for building TCP servers -- one for
 multithreaded servers (one thread per connection, taken from a thread
 pool), one for servers based on the Acceptor-Reactor pattern. The
 multithreaded Poco::Net::TCPServer class and its supporting framework are also the
-foundation for POCO's HTTP server implementation (Poco::Net::HTTPServer). 
+foundation for POCO's HTTP server implementation (Poco::Net::HTTPServer).
-On the client side, the Net library provides classes for talking to HTTP servers, 
+On the client side, the Net library provides classes for talking to HTTP servers,
 for sending and receiving files using the FTP protocol, for sending mail
 messages (including attachments) using SMTP and for receiving mail from
 a POP3 server.
@@ -289,7 +287,7 @@ server.
     #include "Poco/Util/OptionSet.h"
     #include "Poco/Util/HelpFormatter.h"
     #include <iostream>
-    
+
     using Poco::Net::ServerSocket;
     using Poco::Net::HTTPRequestHandler;
     using Poco::Net::HTTPRequestHandlerFactory;
@@ -307,27 +305,26 @@ server.
     using Poco::Util::OptionSet;
     using Poco::Util::OptionCallback;
     using Poco::Util::HelpFormatter;
-    
+
     class TimeRequestHandler: public HTTPRequestHandler
     {
     public:
         TimeRequestHandler(const std::string& format): _format(format)
         {
         }
-    
+
-        void handleRequest(HTTPServerRequest& request,
+        void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response)
-                           HTTPServerResponse& response)
         {
             Application& app = Application::instance();
-            app.logger().information("Request from "
+            app.logger().information("Request from %s",
-                + request.clientAddress().toString());
+                request.clientAddress().toString());
-    
+
             Timestamp now;
             std::string dt(DateTimeFormatter::format(now, _format));
-    
+
             response.setChunkedTransferEncoding(true);
             response.setContentType("text/html");
-    
+
             std::ostream& ostr = response.send();
             ostr << "<html><head><title>HTTPTimeServer powered by "
                     "POCO C++ Libraries</title>";
@@ -337,11 +334,11 @@ server.
             ostr << dt;
             ostr << "</p></body></html>";
         }
-    
+
     private:
         std::string _format;
     };
-    
+
     class TimeRequestHandlerFactory: public HTTPRequestHandlerFactory
     {
     public:
@@ -349,47 +346,32 @@ server.
             _format(format)
         {
         }
-    
+
-        HTTPRequestHandler* createRequestHandler(
+        HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request)
-            const HTTPServerRequest& request)
         {
             if (request.getURI() == "/")
                 return new TimeRequestHandler(_format);
             else
                 return 0;
         }
-    
+
     private:
         std::string _format;
     };
-    
+
     class HTTPTimeServer: public Poco::Util::ServerApplication
     {
-    public:
-        HTTPTimeServer(): _helpRequested(false)
-        {
-        }
-    
-        ~HTTPTimeServer()
-        {
-        }
-    
     protected:
         void initialize(Application& self)
         {
             loadConfiguration();
             ServerApplication::initialize(self);
         }
-    
+
-        void uninitialize()
-        {
-            ServerApplication::uninitialize();
-        }
-    
         void defineOptions(OptionSet& options)
         {
             ServerApplication::defineOptions(options);
-    
+
             options.addOption(
             Option("help", "h", "display argument help information")
                 .required(false)
@@ -397,9 +379,8 @@ server.
                 .callback(OptionCallback<HTTPTimeServer>(
                     this, &HTTPTimeServer::handleHelp)));
         }
-    
+
-        void handleHelp(const std::string& name, 
+        void handleHelp(const std::string& name, const std::string& value)
-                        const std::string& value)
         {
             HelpFormatter helpFormatter(options());
             helpFormatter.setCommand(commandName());
@@ -410,19 +391,20 @@ server.
             stopOptionsProcessing();
             _helpRequested = true;
         }
-    
+
         int main(const std::vector<std::string>& args)
         {
             if (!_helpRequested)
             {
-                unsigned short port = (unsigned short)
+                unsigned short port = static_cast<unsigned short>(
-                    config().getInt("HTTPTimeServer.port", 9980);
+                    config().getInt("HTTPTimeServer.port", 9980));
-                std::string format(
+                std::string format(config().getString(
-                    config().getString("HTTPTimeServer.format", 
+                    "HTTPTimeServer.format",
-                                       DateTimeFormat::SORTABLE_FORMAT));
+                    DateTimeFormat::SORTABLE_FORMAT));
-    
+
                 ServerSocket svs(port);
-                HTTPServer srv(new TimeRequestHandlerFactory(format), 
+                HTTPServer srv(
+                    new TimeRequestHandlerFactory(format),
                     svs, new HTTPServerParams);
                 srv.start();
                 waitForTerminationRequest();
@@ -430,11 +412,11 @@ server.
             }
             return Application::EXIT_OK;
         }
-    
+
     private:
-        bool _helpRequested;
+        bool _helpRequested = false;
     };
-    
+
     int main(int argc, char** argv)
     {
         HTTPTimeServer app;