Adding HTML snapshot of documentation for 0.7.

Author: deanberris

libs/network/doc/html/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 294e91682c0e3ff7b18061aac92d5585
+tags: fbb0d17656682115ca4d033fb2f83ba1

libs/network/doc/html/_images/boost.png

@@ -0,0 +1,92 @@
+Directives
+==========
+
+The :mod:`cpp-netlib` uses a technique for allowing message-passing
+semantics in a chainable fashion in the form of directives. The basic
+concept for directives is, in a general sense, an encapsulated
+transformation that can be applied to objects that abide by the
+directive protocol.
+
+Using the object-oriented notion of message passing, where an object
+accepts a message (usually a function call) we define a simple DSEL in
+order for the protocol to be supported by certain object types. In the
+:mod:`cpp-netlib` the protocol implemented is similar to that of the
+standard iostream formatting system:
+
+.. code-block:: c++
+
+    object << directive1(...)
+           << directive2(...)
+           ...
+           << directiveN(...);
+
+In :mod:`cpp-netlib` the directives are simple function objects that
+take a target object as reference and returns a reference to the same
+object as a result. In code the directive pattern looks like the
+following:
+
+.. code-block:: c++
+
+    struct directive_type {
+        template <class Input>
+        Input & operator()(Input & input) const {
+            // do something to input
+            return input;
+        }
+    };
+
+To simplify directive creation, usually factory or generator functions
+are defined to return concrete objects of the directive's type.
+
+.. code-block:: c++
+
+    inline
+    directive_type directive(...) {
+        return directive_type();
+    }
+
+The trivial implementation of the directive protocol then boils down
+to the specialization of the shift-left operator on the target type.
+
+.. code-block:: c++
+
+    template <class Directive>
+    inline target_type & operator<< 
+    (target_type & x, Directive const & f) {
+        return f(x);
+    }
+
+.. todo::
+
+    An example using a directive.
+
+The rationale for implementing directives include the following:
+
+  * **Encapsulation** - by moving logic into the directive types the
+    target object's interface can remain rudimentary and even hidden
+    to the user's immediate attention. Adding this layer of
+    indirection also allows for changing the underlying
+    implementations while maintaining the same syntactic and semantic
+    properties.
+  * **Flexibility** - by allowing the creation of directives that are
+    independent from the target object's type, generic operations can
+    be applied based on the concept being modeled by the target
+    type. The flexibility also afforded comes in the directive's
+    generator function, which can also generate different concrete
+    directive specializations based on parameters to the function.
+  * **Extensibility** - because the directives are independent of the
+    target object's type, new directives can be added and supported
+    without having to change the target object at all.
+  * **Reuse** - truly generic directives can then be used for a broad
+    set of target object types that model the same concepts supported
+    by the directive.  Because the directives are self-contained
+    objects, the state and other object references it keeps are only
+    accessible to it and can be re-used in different contexts as well.
+
+Extending a system that uses directives is trivial in header-only
+systems because new directives are simply additive. The protocol is
+simple and can be applied to a broad class of situations.
+
+In a header-only library, the static nature of the wiring and chaining
+of the operations lends itself to compiler abuse. A deep enough
+nesting of the directives can lead to prolonged compilation times.

libs/network/doc/html/_sources/directives.txt

@@ -0,0 +1,14 @@
+Examples
+========
+
+The :mod:`cpp-netlib` is a practical library that is designed to aid
+the development of applications for that need to communicate using
+common networking protocols.  The following set of examples describe a
+series of realistic examples that use the :mod:`cpp-netlib` for these
+kinds of application.
+
+.. toctree::
+   :maxdepth: 2
+
+   examples_http.rst
+..   examples_xmpp.rst

libs/network/doc/html/_sources/examples.txt

@@ -0,0 +1,13 @@
+HTTP examples
+=============
+
+The HTTP component of the :mod:`cpp-netlib` contains a client and server.
+The examples that follow show how to use both for programs that can be
+embedded into larger applications.
+
+.. toctree::
+   :maxdepth: 2
+
+   http_client.rst
+   hello_world_server.rst
+   hello_world_client.rst

libs/network/doc/html/_sources/examples_http.txt

@@ -0,0 +1,6 @@
+Generic message
+===============
+
+.. todo::
+
+    Is this section repeated?

libs/network/doc/html/_sources/generic_message.txt

@@ -0,0 +1,176 @@
+.. _getting_started:
+
+*****************
+ Getting Started
+*****************
+
+Downloading an official release
+===============================
+
+All stable versions of :mod:`cpp-netlib` can be downloaded from
+Github_ from this url:
+
+    http://github.com/cpp-netlib/cpp-netlib/downloads
+
+Each release is available as gzipped (Using the command
+``tar xzf cpp-netlib.tar.gz``) or bzipped (Using ``tar xjf
+cpp-netlib.tar.bz2``) tarball, or as a zipfile (``unzip
+cpp-netlib.zip``, or on Windows using a tool such as 7zip_).
+
+.. _Github: http://github.com/cpp-netlib/cpp-netlib/downloads
+.. _7zip: http://www.7-zip.org/
+
+Downloading a development version
+=================================
+
+The :mod:`cpp-netlib` uses Git_ for source control, so to use any
+development versions Git must be installed on your system.
+
+Using the command line, the command to get the latest code is:
+
+::
+
+    shell$ git clone git://github.com/mikhailberis/cpp-netlib.git
+
+This should be enough information get to started.  To do more complex
+things with Git, such as pulling changes or checking out a new branch,
+refer to the `Git documentation`_.
+
+.. note:: If you look at the Git repository closely, this is the repository of
+   *mikhailberis* instead of *cpp-netlib*. The reason is that the main developer
+   and maintainer of the project is Dean Michael Berris, who goes by the alias
+   *mikhailberis* on the Internet.
+
+   Dean does the merging and maintenance of the whole library, similar to how
+   `Linus Torvalds`_ of the Linux project acts as the gatekeeper of the project.
+
+.. _`Linus Torvalds`: http://en.wikipedia.org/wiki/Linus_Torvalds
+
+Windows users need to use msysGit_, and to invoke the command above
+from a shell.
+
+For fans of Subversion_, the same code can be checked out from
+http://svn.github.com/mikhailberis/cpp-netlib.git.
+
+.. _Git: http://git-scm.com/
+.. _`Git documentation`: http://git-scm.com/documentation
+.. _msysGit: http://code.google.com/p/msysgit/downloads/list
+.. _Subversion: http://subversion.tigris.org/
+
+.. note:: The :mod:`cpp-netlib` project is hosted on GitHub_ and follows the 
+   prescribed development model for GitHub_ based projects. This means in case
+   you want to submit patches, you will have to create a fork of the project
+   (read up on forking_) and then submit a pull request (read up on submitting
+   `pull requests`_).
+
+.. _forking: http://help.github.com/forking/
+.. _`pull requests`: http://help.github.com/pull-requests/
+
+Getting Boost
+=============
+
+:mod:`cpp-netlib` depends on Boost_.  It should work for any version
+of Boost above 1.41.0.  If Boost is not installed on your system, the
+latest package can be found on the `Boost web-site`_.  The environment
+variable ``BOOST_ROOT`` must be defined, which must be the full path
+name of the top directory of the Boost distribution.  Although Boost
+is mostly header only, applications built using :mod:`cpp-netlib`
+still requires linking with `Boost.System`_, `Boost.Date_time`_, and
+`Boost.Regex`_.
+
+.. _Boost: http://www.boost.org/doc/libs/release/more/getting_started/index.html
+.. _`Boost web-site`: http://www.boost.org/users/download/
+.. _`Boost.System`: http://www.boost.org/libs/system/index.html
+.. _`Boost.Date_time`: http://www.boost.org/libs/date_time/index.html
+.. _`Boost.Regex`: http://www.boost.org/libs/regex/index.html
+
+.. note:: You can follow the steps in the `Boost Getting Started`_ guide to
+   install Boost into your development system.
+
+.. _`Boost Getting Started`:
+   http://www.boost.org/doc/libs/release/more/getting_started/index.html
+
+Getting CMake
+=============
+
+The :mod:`cpp-netlib` uses CMake_ to generate platform-specific build files. If
+you intend to run the test suite, you can follow the instructions below.
+Otherwise, you don't need CMake to use :mod:`cpp-netlib` in your project. The
+:mod:`cpp-netlib` requires CMake version 2.8 or higher.
+
+.. _CMake: http://www.cmake.org/
+
+Let's assume that you have unpacked the :mod:`cpp-netlib` at the top of your
+HOME directory. On Unix-like systems you will typically be able to change into
+your HOME directory using the command ``cd ~``. This sample below assumes that
+the ``~/cpp-netlib`` directory exists, and is the top-level directory of the
+:mod:`cpp-netlib` release.
+
+Building with CMake
+===================
+
+To build the tests that come with cpp-netlib, we first need to configure the
+build system to use our compiler of choice. This is done by running the
+``cmake`` command at the top-level directory of :mod:`cpp-netlib` with
+additional parameters::
+
+    $ cd ~/cpp-netlib
+    $ cmake -DCMAKE_BUILD_TYPE=Debug \
+    >       -DCMAKE_C_COMPILER=gcc   \
+    >       -DCMAKE_CXX_COMPILER=g++ \
+    >       .
+
+Building on Linux
+~~~~~~~~~~~~~~~~~
+
+On Linux, this will generate the appropriate Makefiles that will enable you to
+build and run the tests and examples that come with :mod:`cpp-netlib`. To build
+the tests, you can run ``make`` in the same top-level directory of
+:mod:`cpp-netlib`::
+
+    $ make
+
+.. note:: Just like with traditional GNU Make, you can add the ``-j`` parameter
+   to specify how many parallel builds to run. In case you're in a sufficiently
+   powerful system and would like to parallelize the build into 4 jobs, you can
+   do this with::
+
+       make -j4
+
+   As a caveat, :mod:`cpp-netlib` is heavy on template metaprogramming and will
+   require a lot of computing and memory resources to build the individual
+   tests. Do this at the risk of thrashing_ your system.
+
+.. _thrashing: http://en.wikipedia.org/wiki/Thrashing_(computer_science)
+
+Once the build has completed, you can now run the test suite by issuing::
+
+    $ make test
+
+Building On Windows
+~~~~~~~~~~~~~~~~~~~
+
+If you're using the Microsoft Visual C++ compiler or the Microsoft Visual Studio
+IDE and you would like to build cpp-netlib from within Visual Studio, you can
+look for the solution and project files as the artifacts of the call to
+``cmake`` -- the file should be named ``cpp-netlib.sln`` (the solution) along
+with a number of project files for Visual Studio.
+
+Reporting Issues, Getting Support
+=================================
+
+In case you find yourself stuck or if you've found a bug (or you want to just
+join the discussion) you have a few options to choose from.
+
+For reporting bugs, feature requests, and asking questions about the
+implementation and/or the documentation, you can go to the GitHub issues page
+for the project at http://github.com/mikhailberis/cpp-netlib/issues.
+
+You can also opt to join the developers mailing list for a more personal
+interaction with the developers of the project. You can join the mailing list
+through https://lists.sourceforge.net/lists/listinfo/cpp-netlib-devel.
+
+You may also choose to get commercial support from:
+
+    Dean Michael Berris - <[email protected]>
+