pax_global_header00006660000000000000000000000064124033134720014511gustar00rootroot0000000000000052 comment=c56a463af8d3668f825e1e2ac4289f97c8786822 cpp-netlib-cpp-netlib-0.11.1RC1/000077500000000000000000000000001240331347200161675ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/.clang-format000066400000000000000000000022441240331347200205440ustar00rootroot00000000000000BasedOnStyle: Google AccessModifierOffset: -1 ConstructorInitializerIndentWidth: 4 AlignEscapedNewlinesLeft: true AlignTrailingComments: true AllowAllParametersOfDeclarationOnNextLine: true AllowShortIfStatementsOnASingleLine: true AllowShortLoopsOnASingleLine: true AlwaysBreakTemplateDeclarations: true AlwaysBreakBeforeMultilineStrings: true BreakBeforeBinaryOperators: false BreakConstructorInitializersBeforeComma: false BinPackParameters: true ColumnLimit: 80 ConstructorInitializerAllOnOneLineOrOnePerLine: true DerivePointerBinding: true ExperimentalAutoDetectBinPacking: false IndentCaseLabels: true MaxEmptyLinesToKeep: 1 ObjCSpaceBeforeProtocolList: false PenaltyBreakComment: 60 PenaltyBreakString: 1000 PenaltyBreakFirstLessLess: 120 PenaltyExcessCharacter: 1000000 PenaltyReturnTypeOnItsOwnLine: 200 PointerBindsToType: true SpacesBeforeTrailingComments: 2 Cpp11BracedListStyle: true Standard: Auto IndentWidth: 2 TabWidth: 4 UseTab: false BreakBeforeBraces: Attach IndentFunctionDeclarationAfterType: true SpacesInParentheses: false SpaceInEmptyParentheses: false SpacesInCStyleCastParentheses: false SpaceAfterControlStatementKeyword: true cpp-netlib-cpp-netlib-0.11.1RC1/.gitignore000066400000000000000000000001561240331347200201610ustar00rootroot00000000000000*.cmake *.swp *.pyc CMakeCache.txt CMakeFiles Makefile Testing *.gch libs/mime/test/mime-roundtrip *.a _build cpp-netlib-cpp-netlib-0.11.1RC1/.travis.yml000066400000000000000000000032011240331347200202740ustar00rootroot00000000000000language: - cpp compiler: - gcc - clang env: - BOOST_VER=1.54.0 BUILD_SHARED_LIBS="ON" CMAKE_BUILD_TYPE="Release" - BOOST_VER=1.54.0 BUILD_SHARED_LIBS="OFF" CMAKE_BUILD_TYPE="Release" - BOOST_VER=1.54.0 BUILD_SHARED_LIBS="ON" CMAKE_BUILD_TYPE="Debug" - BOOST_VER=1.54.0 BUILD_SHARED_LIBS="OFF" CMAKE_BUILD_TYPE="Debug" - BOOST_VER=1.55.0 BUILD_SHARED_LIBS="ON" CMAKE_BUILD_TYPE="Release" - BOOST_VER=1.55.0 BUILD_SHARED_LIBS="OFF" CMAKE_BUILD_TYPE="Release" - BOOST_VER=1.55.0 BUILD_SHARED_LIBS="ON" CMAKE_BUILD_TYPE="Debug" - BOOST_VER=1.55.0 BUILD_SHARED_LIBS="OFF" CMAKE_BUILD_TYPE="Debug" before_install: - if [ "${CXX}" == "g++" ] || [ ${BUILD_SHARED_LIBS} = "OFF" ]; then sudo add-apt-repository ppa:boost-latest/ppa --yes; sudo apt-get update; fi - if [ "${CXX}" == "clang++" ] && [ ${BUILD_SHARED_LIBS} = "ON" ]; then curl -s http://cznic.dl.sourceforge.net/project/boost/boost/${BOOST_VER}/boost_${BOOST_VER//./_}.tar.bz2|tar xfj - -C ..; export BOOST_ROOT=$TRAVIS_BUILD_DIR/../boost_${BOOST_VER//./_}; fi install: - if [ "${CXX}" == "g++" ] || [ ${BUILD_SHARED_LIBS} = "OFF" ]; then sudo apt-get install libboost${BOOST_VER/%.0/}-all-dev; fi - if [ "${CXX}" == "clang++" ] && [ ${BUILD_SHARED_LIBS} = "ON" ]; then cd $BOOST_ROOT; ./bootstrap.sh --with-toolset=$CC; ./b2 -j4 --stagedir=.; cd -; fi script: - cmake -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS} - make - make test after_failure: - cat Testing/Temporary/LastTest.log cpp-netlib-cpp-netlib-0.11.1RC1/.ycm_extra_conf.py000066400000000000000000000037431240331347200216260ustar00rootroot00000000000000# Copyright 2013 Google, Inc. # Copyright 2013 Dean Michael Berris # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # # Project-wide configuration for YouCompleteMe Vim plugin. # # Based off of Valloric's .ycm_conf_extra.py for YouCompleteMe: # https://github.com/Valloric/YouCompleteMe/blob/master/cpp/ycm/.ycm_extra_conf.py # import os import ycm_core flags = [ '-Wall', '-Wextra', '-Werror', '-std=c++03', '-isystem', '.', '-isystem', '/usr/include', '-isystem', '/usr/include/c++/4.6', '-isystem', '/usr/include/clang/3.0/include', '-isystem', '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/c++/v1', '-I', os.environ['BOOST_ROOT'], # Always enable debugging for the project when building for semantic # completion. '-DBOOST_NETWORK_DEBUG', ] def DirectoryOfThisScript(): return os.path.dirname(os.path.abspath(__file__)) def MakeRelativePathsInFlagsAbsolute(flags, working_directory): if not working_directory: return list(flags) new_flags = [] make_next_absolute = False path_flags = ['-isystem', '-I', '-iquote', '--sysroot='] for flag in flags: new_flag = flag if make_next_absolute: make_next_absolute = False if not flag.startswith('/'): new_flag = os.path.join(working_directory, flag) for path_flag in path_flags: if flag == path_flag: make_next_absolute = True break if flag.startswith(path_flag): path = flag[len(path_flag):] new_flag = path_flag + os.path.join(working_directory, path) break if new_flag: new_flags.append(new_flag) return new_flags def FlagsForFile(filename): relative_to = DirectoryOfThisScript() final_flags = MakeRelativePathsInFlagsAbsolute(flags, relative_to) return {'flags': final_flags, 'do_cache': True } cpp-netlib-cpp-netlib-0.11.1RC1/CMakeLists.txt000066400000000000000000000120031240331347200207230ustar00rootroot00000000000000# Copyright (c) Dean Michael Berris 2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) cmake_minimum_required(VERSION 2.8) project(CPP-NETLIB) option( CPP-NETLIB_BUILD_SHARED_LIBS "Build cpp-netlib as shared libraries." OFF ) option( CPP-NETLIB_BUILD_TESTS "Build the cpp-netlib project tests." ON) option( CPP-NETLIB_BUILD_EXAMPLES "Build the cpp-netlib project examples." ON) include(GNUInstallDirs) # determine install path for CMake config files if(WIN32 AND NOT CYGWIN) set(DEF_INSTALL_CMAKE_DIR CMake) else() set(DEF_INSTALL_CMAKE_DIR lib/CMake/cppnetlib) endif() set(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files") # Make relative cmake install path absolute (needed later on) if(NOT IS_ABSOLUTE "${INSTALL_CMAKE_DIR}") set(INSTALL_CMAKE_DIR "${CMAKE_INSTALL_PREFIX}/${INSTALL_CMAKE_DIR}") endif() if(CPP-NETLIB_BUILD_SHARED_LIBS OR BUILD_SHARED_LIBS) message (STATUS "Linking boost testing libs dynamically...") set(Boost_USE_STATIC_LIBS OFF) set(CPP-NETLIB_BUILD_SHARED_LIBS ON) set(BUILD_SHARED_LIBS ON) add_definitions(-DBOOST_TEST_DYN_LINK) else() set(Boost_USE_STATIC_LIBS ON) set(CPP-NETLIB_BUILD_SHARED_LIBS OFF) set(BUILD_SHARED_LIBS OFF) endif() set(Boost_USE_MULTI_THREADED ON) find_package( Boost 1.54.0 REQUIRED unit_test_framework system regex date_time thread filesystem program_options chrono atomic ) find_package( OpenSSL ) find_package( Threads ) set(CMAKE_VERBOSE_MAKEFILE true) set(CPPNETLIB_VERSION_MAJOR 0) # MUST bump this whenever we make ABI-incompatible changes set(CPPNETLIB_VERSION_MINOR 11) set(CPPNETLIB_VERSION_PATCH 0) set(CPPNETLIB_VERSION_STRING ${CPPNETLIB_VERSION_MAJOR}.${CPPNETLIB_VERSION_MINOR}.${CPPNETLIB_VERSION_PATCH}) if (CMAKE_BUILD_TYPE MATCHES Debug) add_definitions(-DBOOST_NETWORK_DEBUG) endif() if (OPENSSL_FOUND) add_definitions(-DBOOST_NETWORK_ENABLE_HTTPS) include_directories(${OPENSSL_INCLUDE_DIR}) endif() if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU) set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") elseif (${CMAKE_CXX_COMPILER_ID} MATCHES Clang) if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") # We want to link in C++11 mode if we're using Clang and on OS X. set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -ftemplate-depth=256 -std=c++11 -stdlib=libc++") else() # We just add the -Wall and a high enough template depth # flag for Clang in other systems. set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -ftemplate-depth=256") endif() endif() if (Boost_FOUND) if (MSVC) add_definitions(-D_SCL_SECURE_NO_WARNINGS) endif(MSVC) if (WIN32) add_definitions(-D_WIN32_WINNT=0x0501) endif(WIN32) include_directories(${Boost_INCLUDE_DIRS}) enable_testing() add_subdirectory(libs/network/src) if (CPP-NETLIB_BUILD_TESTS) add_subdirectory(libs/network/test) endif (CPP-NETLIB_BUILD_TESTS) add_subdirectory(libs/network/experiment) if (NOT MSVC AND CPP-NETLIB_BUILD_TESTS) add_subdirectory(libs/mime/test) endif(NOT MSVC AND CPP-NETLIB_BUILD_TESTS) if (CPP-NETLIB_BUILD_EXAMPLES) add_subdirectory(libs/network/example) endif (CPP-NETLIB_BUILD_EXAMPLES) endif(Boost_FOUND) if (MSVC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") endif() enable_testing() install(DIRECTORY boost DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) ### ## Export Targets # (so cpp-netlib can be easily used by other CMake projects) # [see http://www.cmake.org/Wiki/CMake/Tutorials/How_to_create_a_ProjectConfig.cmake_file] # Add all targets to the build-tree export set export(TARGETS cppnetlib-client-connections cppnetlib-server-parsers cppnetlib-uri FILE "${PROJECT_BINARY_DIR}/cppnetlibTargets.cmake") # Export the package for use from the build-tree # (this registers the build-tree with a global CMake-registry) export(PACKAGE cppnetlib) # Create the cppnetlibConfig.cmake and cppnetlibConfigVersion files file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}" "${CMAKE_INSTALL_FULL_INCLUDEDIR}") # ... for the build tree set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}") configure_file(cppnetlibConfig.cmake.in "${PROJECT_BINARY_DIR}/cppnetlibConfig.cmake" @ONLY) # ... for the install tree set(CONF_INCLUDE_DIRS "\${CPPNETLIB_CMAKE_DIR}/${REL_INCLUDE_DIR}") configure_file(cppnetlibConfig.cmake.in "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cppnetlibConfig.cmake" @ONLY) # ... for both configure_file(cppnetlibConfigVersion.cmake.in "${PROJECT_BINARY_DIR}/cppnetlibConfigVersion.cmake" @ONLY) # Install the cppnetlibConfig.cmake and cppnetlibConfigVersion.cmake install(FILES "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cppnetlibConfig.cmake" "${PROJECT_BINARY_DIR}/cppnetlibConfigVersion.cmake" DESTINATION "${INSTALL_CMAKE_DIR}" COMPONENT dev) # Install the export set for use with the install-tree install(EXPORT cppnetlibTargets DESTINATION "${INSTALL_CMAKE_DIR}" COMPONENT dev) cpp-netlib-cpp-netlib-0.11.1RC1/LICENSE_1_0.txt000066400000000000000000000024721240331347200204560ustar00rootroot00000000000000Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. cpp-netlib-cpp-netlib-0.11.1RC1/RATIONALE.txt000066400000000000000000000035411240331347200202510ustar00rootroot00000000000000C++ Networking Library Goals and Scope Objectives ---------- o Develop a high quality, portable, easy to use C++ networking library o Enable users to easily extend the library o Lower the barrier to entry for cross-platform network-aware C++ applications Goals ----- * Implement a simple message implementation which can be used in network protocol-specific routines for inter-operability and to provide a generic interface to manipulating network-oriented messages. * Implement easy to use protocol client libraries such as (but not limited to): - HTTP 1.0/1.1 - (E)SMTP - SNMP - ICMP * Implement an easy to embed HTTP server container type that supports most modern HTTP 1.1 features. * Implement an efficient easy to use URI class/parser. * Implement a fully compliant cross-platform asynchronous DNS resolver either as a wrapper to external (C) libraries, or as hand-rolled implementation. * Implement a MIME handler which builds message objects from either data retrieved from the network or other sources and create text/binary representations from existing message objects intended for transport over the network. Scope ----- * The library will provide a generic message class which is intended to be the common message type used by the protocol libraries. * The library will only contain client implementations for the various supported protocols. * The library will use only STL and Boost C++ library components, utilities, and libraries throughout the implementation. * The library will strive to use C++ templates and template metaprogramming techniques in order to not require the building of external shared/static libraries. In other words, the library will be header-only and compliant with the C++ standard. cpp-netlib-cpp-netlib-0.11.1RC1/README.rst000066400000000000000000000134131240331347200176600ustar00rootroot00000000000000C++ Network Library =================== Introduction ------------ cpp-netlib is a collection of network related routines/implementations geared towards providing a robust cross-platform networking library. cpp-netlib offers the following implementations: * Common Message Type -- A generic message type which can be used to encapsulate and store message related information, used by all network implementations as the primary means of data exchange. * Network protocol message parsers -- A collection of parsers which generate message objects from strings. * Adapters and Wrappers -- A collection of Adapters and wrappers aimed towards making the message type STL friendly. * Network protocol client and server implementations -- A collection of network protocol implementations that include embeddable client and server types. This library is released under the Boost Software License (please see http://boost.org/LICENSE_1_0.txt or the accompanying LICENSE_1_0.txt file for the full text. Downloading cpp-netlib ---------------------- You can find official release packages of the library at:: http://github.com/cpp-netlib/cpp-netlib/downloads Building and Installing ----------------------- Building with CMake ~~~~~~~~~~~~~~~~~~~ To build the libraries and run the tests with CMake, you will need to have CMake version 2.8 or higher installed appropriately in your system. :: $ cmake --version cmake version 2.8.1 Inside the cpp-netlib directory, you can issue the following statements to configure and generate the Makefiles, and build the tests:: $ cd ~/cpp-netlib # we're assuming it's where cpp-netlib is $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=clang \ > -DCMAKE_CXX_COMPILER=clang++ \ > . Once CMake is done with generating the Makefiles and configuring the project, you can now build the tests and run them:: $ cd ~/cpp-netlib $ make $ make test If for some reason some of the tests fail, you can send the files in ``Testing/Temporary/`` as attachments to the cpp-netlib `developers mailing list`_. .. _`developers mailing list`: cpp-netlib@googlegroups.com Building with Boost.Build ~~~~~~~~~~~~~~~~~~~~~~~~~ If you don't already have Boost.Build set up on your system, follow the steps indicated in the Boost Getting Started Guide [#]_ -- you will particularly want to copy the ``bjam`` executable to a directory that is already in your ``PATH`` so that you don't have to go hunting for it all the time. A good place to put it is in ``/usr/local/bin``. .. [#] http://www.boost.org/doc/libs/release/more/getting_started/ Building and running the tests can be as simple as doing the following:: $ cd ~/cpp-netlib $ bjam Doing this will already build all the tests and run them as they are built. In case you encounter any problems and would like to report it to the developers, please do the following:: $ cd ~/cpp-netlib $ bjam 2>&1 >build-test.log And then attach the ``build-test.log`` file to the email you will send to the cpp-netlib `developers mailing list`_. .. _`developers mailing list`: cpp-netlib@googlegroups.com Running Tests ------------- If you want to run the tests that come with cpp-netlib, there are a few things you will need. These are: * A compiler (GCC 4.x, Clang 2.8, MSVC 2008) * A build tool (CMake [#]_ recommended, Boost.Build also an option) * OpenSSL headers (optional) .. note:: This assumes that you have cpp-netlib at the top-level of your home directory. [#] http://www.cmake.org/ Hacking on cpp-netlib --------------------- cpp-netlib is being developed with the git_ distributed SCM system. cpp-netlib is hosted on GitHub_ following the GitHub recommended practice of forking the repository and submitting pull requests to the source repository. You can read more about the forking_ process and submitting `pull requests`_ if you're not familiar with either process yet. .. _git: http://git-scm.com/ .. _GitHub: http://github.com/ .. _forking: http://help.github.com/forking/ .. _`pull requests`: http://help.github.com/pull-requests/ Because cpp-netlib is released under the `Boost Software License`_ it is recommended that any file you make changes to bear your copyright notice alongside the original authors' copyright notices on the file. Typically the copyright notices are at the top of each file in the project. .. _`Boost Software License`: http://www.boost.org/LICENSE_1_0.txt At the time of writing, there are no coding conventions being followed but if you write in the general style that is already existing in the project that would be greatly appreciated. Copious amounts of comments will be called out, but code that is not self-explanatory typically at least requires a rationale documentation in comments explaining "why" the code is written that way. The main "upstream" repository is the one hosted by the original maintainer of the project (Dean Michael Berris) at http://github.com/mikhailberis/cpp-netlib. The "official" release repository is maintained at http://github.com/cpp-netlib/cpp-netlib -- which is a fork of the upstream repository. It is recommended that forks be made against the upstream repostory and pull requests be submitted against the upstream repository so that patches and other implementations can be curated by the original maintainer. Contact and Support ------------------- In case you have any questions or would like to make feature requests, you can contact the development team through the `developers mailing list`_ or by filing issues at http://github.com/cpp-netlib/cpp-netlib/issues. .. _`developers mailing list`: cpp-netlib@googlegroups.com You can reach the maintainers of the project through:: Dean Michael Berris (dberris@google.com) Glyn Matthews (glyn.matthews@gmail.com) cpp-netlib-cpp-netlib-0.11.1RC1/boost/000077500000000000000000000000001240331347200173155ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/mime.hpp000066400000000000000000000722561240331347200207710ustar00rootroot00000000000000// // Copyright Marshall Clow 2009-2010 // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // #ifndef _BOOST_MIME_HPP #define _BOOST_MIME_HPP #include #include #include #include #include #include #include // pulls in all of Phoenix #include #include #include #include #include #include // #define DUMP_MIME_DATA 1 namespace boost { namespace mime { // Errors are reported using this exception class class mime_parsing_error : public std::runtime_error { public: explicit mime_parsing_error(const std::string &msg) : std::runtime_error(msg) {} }; template class basic_mime; namespace detail { static const char *k_crlf = "\015\012"; static const char *k_package_name = "Proposed.Boost.Mime"; static const char *k_package_version = "0.1"; static const char *k_content_type_header = "Content-Type"; static const char *k_mime_version_header = "Mime-Version"; struct default_types { typedef std::string string_type; // typedef std::pair < std::string, string_type > header_type; typedef std::vector body_type; }; template struct find_mime_header { find_mime_header(const char *str) : searchFor(str) {} bool operator()(const std::pair &val) const { return boost::iequals(val.first, searchFor); } private: const char *searchFor; }; #ifdef DUMP_MIME_DATA struct tracer { tracer(const char *fn) : fn_(fn) { std::cout << "->" << fn_ << std::endl; } ~tracer() { std::cout << "<-" << fn_ << std::endl; } const char *fn_; }; #else struct tracer { tracer(const char *) {} ~tracer() {} }; #endif // Parsing a Content-Type header typedef std::pair phrase_t; typedef std::vector phrase_container_t; struct mime_content_type { std::string type; std::string sub_type; phrase_container_t phrases; }; namespace qi = boost::spirit::qi; namespace phx = boost::phoenix; using boost::spirit::_val; using boost::spirit::_1; template struct mime_header_parser : qi::grammar { mime_header_parser() : mime_header_parser::base_type(mime_headerList) { mime_headerList = *(mime_header) >> crlf; mime_header = token >> qi::lit(':') >> value >> crlf; token = qi::char_("a-zA-Z") >> *qi::char_("a-zA-Z_0-9\\-"); // In Classifieds/000001, a header begins with a CRLF value = (valuePart[_val = _1] | qi::eps) >> *(valueCont[_val += "\015\012" + _1]); valueCont = crlf >> contWS[_val += _1] >> valuePart[_val += _1]; valuePart = +qi::char_("\t -~"); contWS = +qi::char_(" \t"); crlf = qi::lit(k_crlf); /* mime_headerList.name("mime-header-list"); mime_header.name ("mime-header"); token.name ("mime-token"); valuePart.name ("mime-value-part"); value.name ("mime-value"); qi::on_error ( mime_headerList, std::cout << phoenix::val("Error! Expecting ") << qi::labels::_4 << phoenix::val(" here: \"") << phoenix::construct(qi::labels::_3, qi::labels::_2) << phoenix::val("\"") << std::endl ); */ } qi::rule mime_headerList; qi::rule mime_header; qi::rule token, value, valueCont, valuePart, contWS; qi::rule crlf; }; template static Container read_headers(Iterator &begin, Iterator end) { tracer t(__func__); Container retVal; mime_header_parser mh_parser; bool b = qi::parse(begin, end, mh_parser, retVal); if (!b) throw mime_parsing_error("Failed to parse headers"); #ifdef DUMP_MIME_DATA std::cout << "******Headers*******" << std::endl; for (typename Container::const_iterator iter = retVal.begin(); iter != retVal.end(); ++iter) { std::string val = iter->second; size_t idx; while (std::string::npos != (idx = val.find(k_crlf))) val.replace(idx, std::strlen(k_crlf), "\n"); std::cout << iter->first << ": " << val << std::endl; } std::cout << std::endl << "******Headers*******" << std::endl; #endif return retVal; } // The structure of a Content-Type mime header is taken from RFC 2045 // http://www.ietf.org/rfc/rfc2045.txt, section 5.1 template struct mime_content_type_parser : qi::grammar { mime_content_type_parser() : mime_content_type_parser::base_type(content_type_header) { content_type_header = *qi::lit(' ') >> part >> '/' >> sub_part >> *phrase; part = token | extension_token; sub_part = token | extension_token; phrase = qi::lit(';') >> +ws >> attribute >> '=' >> value >> *ws; ws = qi::char_(" \t") | line_sep | comment; line_sep = qi::lexeme[qi::lit(k_crlf)]; attribute = token.alias(); value = token | quoted_string; token = +(qi::char_(" -~") - qi::char_(" ()<>@,;:\\\"/[]?=")); comment = qi::lit('(') >> +(qi::char_(" -~") - ')') >> qi::lit(')'); quoted_string = qi::lit('"') >> +(qi::char_(" -~") - '"') >> qi::lit('"'); extension_token = qi::char_("Xx") >> qi::lit('-') >> token; } qi::rule content_type_header; qi::rule phrase; qi::rule part, sub_part, token, attribute, value, quoted_string, extension_token; qi::rule ws, line_sep, comment; }; template mime_content_type parse_content_type(const string_type &theHeader) { tracer t(__func__); mime_content_type retVal; typename string_type::const_iterator first = theHeader.begin(); mime_content_type_parser ct_parser; bool b = qi::parse(first, theHeader.end(), ct_parser, retVal); if (!b) throw mime_parsing_error("Failed to parse the 'Content-Type' header"); return retVal; } template static string_type get_ct_value(const string_type &ctString, const char *key) { tracer t(__func__); mime_content_type mc = parse_content_type(ctString); for (phrase_container_t::const_iterator iter = mc.phrases.begin(); iter != mc.phrases.end(); ++iter) if (boost::iequals(iter->first, key)) return iter->second; throw std::runtime_error( str(boost::format("Couldn't find Content-Type phrase (%s)") % key)); } // Replace this with a spirit thing later. // we're looking for '; boundary="".*' std::string get_boundary(const std::string &ctString) { tracer t(__func__); return get_ct_value(ctString, "boundary"); } // Read the body of a multipart // Return a Container of containers, where the first is the actual // body, // and the rest are the sub-parts. // Note that the body of the multipart can be empty. // If this is the case, then the first separator need not have a crlf // if the marker is "abcde", we could have: // Note that the separators are really CRLF--abcdeCRLF and // CRLF--abcde--CRLF // // multipart body // --abcde // sub part #1 // --abcde // sub part #2 // --abcde-- // // ** or ** // In this case, the first separator is --abcdeCRLF // // --abcde (no multipart body!) // sub part #1 // --abcde // sub part #2 // --abcde-- typedef std::vector sub_part_t; typedef std::vector sub_parts_t; template struct multipart_body_type { bool prolog_is_missing; bodyContainer body_prolog; sub_parts_t sub_parts; bodyContainer body_epilog; }; // Parse a mulitpart body. // Either "--boundaryCRLF" -- in which case the body is empty // or "CRLF--boundaryCRLF" -- in which // case we return the sequence // // I am deliberately not checking for a termination separator here template struct multipart_body_parser : qi::grammar { multipart_body_parser(const std::string &boundary, bool &isMissing) : multipart_body_parser::base_type(mimeBody), m_is_missing(isMissing) { m_is_missing = false; // Thanks to Michael Caisse for the hint to get this working mimeBody %= bareSep[phx::ref(m_is_missing) = true] | (+(qi::char_ - sep) >> sep); bareSep = qi::lit("--") >> boundary >> crlf; sep = crlf >> bareSep; crlf = qi::lit(k_crlf); } bool &m_is_missing; qi::rule mimeBody; qi::rule bareSep, sep, crlf; }; // Break up a multi-part into its' constituent sub parts. template struct multipart_part_parser : qi::grammar { multipart_part_parser(const std::string &boundary) : multipart_part_parser::base_type(mimeParts) { mimeParts = (+(qi::char_ - sep) % (sep >> crlf)) > terminator; sep = crlf >> qi::lit("--") >> boundary; terminator = sep >> qi::lit("--") >> crlf; crlf = qi::lit(k_crlf); } qi::rule mimeParts; qi::rule sep, terminator, crlf; }; template static void read_multipart_body(Iterator &begin, Iterator end, multipart_body_type &mp_body, const std::string &separator) { tracer t(__func__); typedef bodyContainer innerC; innerC mpBody; multipart_body_parser mb_parser(separator, mp_body.prolog_is_missing); if (!qi::parse(begin, end, mb_parser, mp_body.body_prolog)) throw mime_parsing_error("Failed to parse mime body(1)"); multipart_part_parser mp_parser(separator); if (!qi::parse(begin, end, mp_parser, mp_body.sub_parts)) throw mime_parsing_error("Failed to parse mime body(2)"); std::copy(begin, end, std::back_inserter(mp_body.body_epilog)); #ifdef DUMP_MIME_DATA std::cout << std::endl << ">>****Multipart Body*******" << std::endl; std::cout << str(boost::format( "Body size %d, sub part count = %d, trailer size " "= %d %s") % mp_body.body_prolog.size() % mp_body.sub_parts.size() % mp_body.body_epilog.size() % (mp_body.prolog_is_missing ? "(missing)" : "")) << std::endl; std::cout << std::endl << "****** Multipart Body Prolog *******" << std::endl; std::copy(mp_body.body_prolog.begin(), mp_body.body_prolog.end(), std::ostream_iterator(std::cout)); std::cout << std::endl << "****** Multipart Body Epilog *******" << std::endl; std::copy(mp_body.body_epilog.begin(), mp_body.body_epilog.end(), std::ostream_iterator(std::cout)); std::cout << std::endl << "<<****Multipart Body*******" << std::endl; #endif } template static Container read_simplepart_body(Iterator &begin, Iterator end) { tracer t(__func__); Container retVal; std::copy(begin, end, std::back_inserter(retVal)); #ifdef DUMP_MIME_DATA std::cout << std::endl << ">>****SinglePart Body*******" << std::endl; std::cout << str(boost::format("Body size %d") % retVal.size()) << std::endl; std::copy(retVal.begin(), retVal.end(), std::ostream_iterator(std::cout)); std::cout << std::endl << "<<****SinglePart Body*******" << std::endl; #endif return retVal; } // FIXME: Need to break the headers at 80 chars... template void write_headers(std::ostream &out, const headerList &headers) { if (headers.size() > 0) { for (typename headerList::const_iterator iter = headers.begin(); iter != headers.end(); ++iter) out << iter->first << ':' << iter->second << detail::k_crlf; } out << detail::k_crlf; } template void write_body(std::ostream &out, const bodyContainer &body) { std::copy(body.begin(), body.end(), std::ostream_iterator(out)); } inline void write_boundary(std::ostream &out, std::string boundary, bool isLast, bool leadingCR = true) { if (leadingCR) out << detail::k_crlf; out << "--" << boundary; if (isLast) out << "--"; out << detail::k_crlf; } template static boost::shared_ptr > parse_mime( Iterator &begin, Iterator end, const char *default_content_type = "text/plain"); } template class basic_mime { public: typedef enum { simple_part, multi_part, message_part } part_kind; // Types for headers typedef typename traits::string_type string_type; typedef std::pair headerEntry; typedef std::list headerList; typedef typename headerList::iterator headerIter; typedef typename headerList::const_iterator constHeaderIter; // Types for the parts typedef boost::shared_ptr mimePtr; typedef std::vector partList; typedef typename partList::iterator partIter; typedef typename partList::const_iterator constPartIter; // Type for the body typedef typename traits::body_type bodyContainer; typedef boost::shared_ptr mimeBody; // ----------------------------------------------------------- // Constructors, destructor, assignment, and swap // ----------------------------------------------------------- basic_mime(const char *type, const char *subtype) : m_body_prolog_is_missing(false), m_body(new bodyContainer), m_body_epilog(new bodyContainer) { if (NULL == type || NULL == subtype || 0 == std::strlen(type) || 0 == std::strlen(subtype)) throw std::runtime_error( "Can't create a mime part w/o a type or subtype"); // We start with just two headers, "Content-Type:" and "Mime-Version" // Everything else is optional. m_part_kind = part_kind_from_string_pair(type, subtype); std::string ctString = str(boost::format("%s/%s") % type % subtype); set_header_value(detail::k_content_type_header, ctString); set_header_value(detail::k_mime_version_header, str(boost::format("1.0 (%s %s)") % detail::k_package_name % detail::k_package_version)); } basic_mime(const headerList &theHeaders, const string_type &default_content_type) : m_body_prolog_is_missing(false), m_body(new bodyContainer), m_body_epilog(new bodyContainer), m_default_content_type(default_content_type) { string_type ct = m_default_content_type; constHeaderIter found = std::find_if( theHeaders.begin(), theHeaders.end(), detail::find_mime_header(detail::k_content_type_header)); if (found != theHeaders.end()) ct = found->second; detail::mime_content_type mct = detail::parse_content_type(ct); m_part_kind = part_kind_from_string_pair(mct.type, mct.sub_type); m_headers = theHeaders; } basic_mime(const basic_mime &rhs) : m_part_kind(rhs.m_part_kind), m_headers(rhs.m_headers), m_body_prolog_is_missing(rhs.m_body_prolog_is_missing), m_body(new bodyContainer(*rhs.m_body)), m_body_epilog(new bodyContainer(*rhs.m_body_epilog)), /* m_subparts ( rhs.m_subparts ), */ m_default_content_type( rhs.m_default_content_type) { // Copy the parts -- not just the shared pointers for (typename partList::const_iterator iter = rhs.subpart_begin(); iter != rhs.subpart_end(); ++iter) m_subparts.push_back(mimePtr(new basic_mime(**iter))); } // Simple, copy constructor-based assignment // If this is not efficient enough, then I can optimize it later basic_mime &operator=(const basic_mime &rhs) { basic_mime temp(rhs); this->swap(temp); return *this; } void swap(basic_mime &rhs) throw() { std::swap(m_part_kind, rhs.m_part_kind); std::swap(m_headers, rhs.m_headers); std::swap(m_body_prolog_is_missing, rhs.m_body_prolog_is_missing); std::swap(m_body, rhs.m_body); std::swap(m_body_epilog, rhs.m_body_epilog); std::swap(m_subparts, rhs.m_subparts); std::swap(m_default_content_type, rhs.m_default_content_type); } ~basic_mime() {} // What kind of part is this (simple, multi, message) part_kind get_part_kind() const { return m_part_kind; } // Sub-part information // FIXME: Need some error checking here // No sub-parts for simple parts, for example. size_t part_count() const { return m_subparts.size(); } boost::shared_ptr operator[](std::size_t idx) const { check_subpart_index(idx); return m_subparts[idx]; } void append_part(boost::shared_ptr newPart) { check_subpart_append(); m_subparts.push_back(newPart); } partIter subpart_begin() { return m_subparts.begin(); } partIter subpart_end() { return m_subparts.end(); } constPartIter subpart_begin() const { return m_subparts.begin(); } constPartIter subpart_end() const { return m_subparts.end(); } // Reading the raw headers headerIter header_begin() { return m_headers.begin(); } headerIter header_end() { return m_headers.end(); } constHeaderIter header_begin() const { return m_headers.begin(); } constHeaderIter header_end() const { return m_headers.end(); } // ----------------------------------------------------------- // Header manipulation // ----------------------------------------------------------- // The 'tag' part of the header is still a std::string bool header_exists(const char *key) const { return header_end() != find_header(key); } string_type header_value(const char *key) const { constHeaderIter found = find_header(key); if (found == header_end()) throw std::runtime_error("'header_value' not found"); return found->second; } void set_header_value(const char *key, const string_type &value, bool replace = false) { if (!replace) m_headers.push_back(std::make_pair(std::string(key), value)); else { headerIter found = find_header(key); if (found == m_headers.end()) throw std::runtime_error("'header_value' not found - can't replace"); found->second = value; } } string_type get_content_type_header() const { constHeaderIter found = find_header(detail::k_content_type_header); return found != header_end() ? found->second : m_default_content_type; } string_type get_content_type() const { detail::mime_content_type mct = detail::parse_content_type(get_content_type_header()); return string_type(mct.type) + '/' + mct.sub_type; } // Special purpose helper routine void append_phrase_to_content_type(const char *key, const string_type &value) { headerIter found = find_header(detail::k_content_type_header); // Create a Content-Type header if there isn't one if (m_headers.end() == found) { m_headers.push_back(std::make_pair( std::string(detail::k_content_type_header), m_default_content_type)); found = find_header(detail::k_content_type_header); } detail::mime_content_type mct = detail::parse_content_type(found->second); detail::phrase_container_t::const_iterator p_found = std::find_if(mct.phrases.begin(), mct.phrases.end(), detail::find_mime_header(key)); if (p_found != mct.phrases.end()) throw std::runtime_error("phrase already exists"); found->second += str(boost::format("; %s=\"%s\"") % key % value); } // Body get/set methods mimeBody body() const { return m_body; } mimeBody body_prolog() const { return m_body; } mimeBody body_epilog() const { return m_body_epilog; } std::size_t body_size() const { return m_body->size(); } template void set_body(Iterator begin, Iterator end) { bodyContainer temp; std::copy(begin, end, std::back_inserter(temp)); m_body->swap(temp); } void set_body(const char *contents, size_t sz) { set_body(contents, contents + sz); } void set_body(std::istream &in) { set_body(std::istream_iterator(in), std::istream_iterator()); } void set_body(const bodyContainer &new_body) { *m_body = new_body; } void set_multipart_prolog_is_missing(bool isMissing) { m_body_prolog_is_missing = isMissing; } void set_body_prolog(const bodyContainer &new_body_prolog) { *m_body = new_body_prolog; } void set_body_epilog(const bodyContainer &new_body_epilog) { *m_body_epilog = new_body_epilog; } // ----------------------------------------------------------- // Output // ----------------------------------------------------------- void stream_out(std::ostream &out) { // called by operator << if (m_part_kind == simple_part) { detail::write_headers(out, m_headers); detail::write_body(out, *m_body); } else if (m_part_kind == message_part) { if (m_subparts.size() != 1) throw std::runtime_error( "message part w/wrong number of sub-parts - should be 1"); detail::write_headers(out, m_headers); m_subparts[0]->stream_out(out); } else { // multi-part // Find or invent a boundary string std::string boundary; try { boundary = detail::get_boundary(get_content_type_header()); } catch (std::runtime_error &) { // FIXME: Make boundary strings (more?) unique boundary = str(boost::format("------=_NextPart-%s.%08ld") % detail::k_package_name % std::clock()); append_phrase_to_content_type("boundary", boundary); } // If the body prolog is missing, we don't want a CRLF on the front // of the first sub-part. // Note that there's a (subtle) difference between an zero length // body and a missing one. // See the comments in the parser code for more information. detail::write_headers(out, m_headers); bool writeCR = body_prolog()->size() > 0 || !m_body_prolog_is_missing; detail::write_body(out, *body_prolog()); for (typename partList::const_iterator iter = m_subparts.begin(); iter != m_subparts.end(); ++iter) { detail::write_boundary(out, boundary, false, writeCR); (*iter)->stream_out(out); writeCR = true; } detail::write_boundary(out, boundary, true); detail::write_body(out, *body_epilog()); } // out << detail::k_crlf; } // Build a simple mime part template static basic_mime make_simple_part(const char *type, const char *subtype, Iterator begin, Iterator end) { basic_mime retval(type, subtype); retval.set_body(begin, end); return retval; } // Build a mime part from a pair of iterators template static boost::shared_ptr > parse_mime(Iterator &begin, Iterator end) { return detail::parse_mime(begin, end); } // Build a mime part from a stream static boost::shared_ptr parse_mime(std::istream &in) { boost::spirit::istream_iterator first(in); boost::spirit::istream_iterator last; return parse_mime(first, last); } private: basic_mime(); // Can't create a part w/o a type headerIter find_header(const char *key) { return std::find_if(header_begin(), header_end(), detail::find_mime_header(key)); } constHeaderIter find_header(const char *key) const { return std::find_if(header_begin(), header_end(), detail::find_mime_header(key)); } static part_kind part_kind_from_string_pair(const std::string &type, const std::string &sub_type) { if (boost::iequals(type, "multipart")) return multi_part; part_kind retVal = simple_part; // I expect that this will get more complicated as time goes on.... // // message/delivery-status is a simple type. // RFC 3464 defines message/delivery-status // // The body of a message/delivery-status consists of one or more // "fields" formatted according to the ABNF of RFC 822 header //"fields" // (see [RFC822]). if (boost::iequals(type, "message")) if (!boost::iequals(sub_type, "delivery-status")) retVal = message_part; return retVal; } void check_subpart_index(size_t idx) const { if (get_part_kind() == simple_part) throw std::runtime_error("Simple Mime parts don't have sub-parts"); else if (get_part_kind() == multi_part) { if (idx >= m_subparts.size()) throw std::runtime_error( str(boost::format( "Trying to access part %d (of %d) sub-part to a " "multipart/xxx mime part") % idx % m_subparts.size())); } else { // message-part if (get_part_kind() == message_part) if (m_subparts.size() > 1) throw std::runtime_error( "How did a message/xxx mime parts get more than one " "sub-part?"); if (idx >= m_subparts.size()) throw std::runtime_error( str(boost::format( "Trying to access part %d (of %d) sub-part to a " "message/xxx mime part") % idx % m_subparts.size())); } } void check_subpart_append() const { if (get_part_kind() == simple_part) throw std::runtime_error("Simple Mime parts don't have sub-parts"); else if (get_part_kind() == message_part) { if (m_subparts.size() > 0) throw std::runtime_error( "Can't add a second sub-part to a message/xxx mime part"); } // else { /* Multi-part */ } // We can always add to a multi-part } part_kind m_part_kind; headerList m_headers; bool m_body_prolog_is_missing; // only for multiparts mimeBody m_body; mimeBody m_body_epilog; // only for multiparts partList m_subparts; // only for multiparts or message string_type m_default_content_type; }; namespace detail { template static boost::shared_ptr > parse_mime( Iterator &begin, Iterator end, const char *default_content_type) { tracer t(__func__); typedef typename boost::mime::basic_mime mime_part; shared_ptr retVal(new mime_part( detail::read_headers(begin, end), default_content_type)); std::string content_type = retVal->get_content_type(); #ifdef DUMP_MIME_DATA std::cout << "Content-Type: " << content_type << std::endl; std::cout << str(boost::format("retVal->get_part_kind () = %d") % ((int)retVal->get_part_kind())) << std::endl; #endif if (retVal->get_part_kind() == mime_part::simple_part) retVal->set_body(detail::read_simplepart_body< typename mime_part::bodyContainer, Iterator>(begin, end)); else if (retVal->get_part_kind() == mime_part::message_part) { // If we've got a message/xxxx, then there is no body, and we have // a single // embedded mime_part (which, of course, could be a multipart) retVal->append_part(parse_mime(begin, end)); } else /* multi_part */ { // Find or invent a boundary string std::string part_separator = detail::get_boundary(retVal->get_content_type_header()); const char *cont_type = boost::iequals(content_type, "multipart/digest") ? "message/rfc822" : "text/plain"; detail::multipart_body_type body_and_subParts; detail::read_multipart_body(begin, end, body_and_subParts, part_separator); retVal->set_body_prolog(body_and_subParts.body_prolog); retVal->set_multipart_prolog_is_missing( body_and_subParts.prolog_is_missing); for (typename sub_parts_t::const_iterator iter = body_and_subParts.sub_parts.begin(); iter != body_and_subParts.sub_parts.end(); ++iter) { typedef typename sub_part_t::const_iterator iter_type; iter_type b = iter->begin(); iter_type e = iter->end(); retVal->append_part(parse_mime(b, e, cont_type)); } retVal->set_body_epilog(body_and_subParts.body_epilog); } return retVal; } } // ----------------------------------------------------------- // // Streaming // // ----------------------------------------------------------- template inline std::ostream &operator<<(std::ostream &stream, basic_mime &part) { part.stream_out(stream); return stream; } template inline std::ostream &operator<<(std::ostream &stream, boost::shared_ptr > part) { return stream << *part; } } } BOOST_FUSION_ADAPT_STRUCT(boost::mime::detail::mime_content_type, (std::string, type)(std::string, sub_type)( boost::mime::detail::phrase_container_t, phrases)) #endif // _BOOST_MIME_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network.hpp000066400000000000000000000010111240331347200215100ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_HPP__ #define __NETWORK_HPP__ // Include all headers in network/ // Author: Dean Michael Berris // Date: May 20, 2007 #include // message type implementation #include // protocols implementation #endif // __NETWORK_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/000077500000000000000000000000001240331347200210065ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/constants.hpp000066400000000000000000000067001240331347200235360ustar00rootroot00000000000000#ifndef BOOST_NETWORK_CONSTANTS_HPP_20100808 #define BOOST_NETWORK_CONSTANTS_HPP_20100808 // Copyright 2010 (C) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace impl { template struct constants_narrow { static char const* crlf() { static char crlf_[] = {'\r', '\n', 0}; return crlf_; } static char const* dot() { static char dot_[] = {'.', 0}; return dot_; } static char dot_char() { return '.'; } static char const* http_slash() { static char http_slash_[] = {'H', 'T', 'T', 'P', '/', 0}; return http_slash_; } static char const* space() { static char space_[] = {' ', 0}; return space_; } static char space_char() { return ' '; } static char const* slash() { static char slash_[] = {'/', 0}; return slash_; } static char slash_char() { return '/'; } static char const* host() { static char host_[] = {'H', 'o', 's', 't', 0}; return host_; } static char const* colon() { static char colon_[] = {':', 0}; return colon_; } static char colon_char() { return ':'; } static char const* accept() { static char accept_[] = {'A', 'c', 'c', 'e', 'p', 't', 0}; return accept_; } static char const* default_accept_mime() { static char mime_[] = {'*', '/', '*', 0}; return mime_; } static char const* accept_encoding() { static char accept_encoding_[] = {'A', 'c', 'c', 'e', 'p', 't', '-', 'E', 'n', 'c', 'o', 'd', 'i', 'n', 'g', 0}; return accept_encoding_; } static char const* default_accept_encoding() { static char default_accept_encoding_[] = { 'i', 'd', 'e', 'n', 't', 'i', 't', 'y', ';', 'q', '=', '1', '.', '0', ',', ' ', '*', ';', 'q', '=', '0', 0}; return default_accept_encoding_; } static char const* user_agent() { static char user_agent_[] = {'U', 's', 'e', 'r', '-', 'A', 'g', 'e', 'n', 't', 0}; return user_agent_; } static char const* cpp_netlib_slash() { static char cpp_netlib_slash_[] = {'c', 'p', 'p', '-', 'n', 'e', 't', 'l', 'i', 'b', '/', 0}; return cpp_netlib_slash_; } static char question_mark_char() { return '?'; } static char hash_char() { return '#'; } static char const* connection() { static char connection_[] = {'C', 'o', 'n', 'n', 'e', 'c', 't', 'i', 'o', 'n', 0}; return connection_; } static char const* close() { static char close_[] = {'C', 'l', 'o', 's', 'e', 0}; return close_; } static char const* https() { static char https_[] = "https"; return https_; } }; template struct constants_wide { static wchar_t const* https() { static wchar_t https_[] = L"https"; return https_; } }; } template struct constants : mpl::if_< is_default_string, impl::constants_narrow, typename mpl::if_, impl::constants_wide, unsupported_tag >::type>::type {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_CONSTANTS_HPP_20100808 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/detail/000077500000000000000000000000001240331347200222505ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/detail/debug.hpp000066400000000000000000000016471240331347200240570ustar00rootroot00000000000000#ifndef BOOST_NETWORK_DEBUG_HPP_20110410 #define BOOST_NETWORK_DEBUG_HPP_20110410 // (c) Copyright 2011 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) /** BOOST_NETWORK_MESSAGE is a debugging macro used by cpp-netlib to print out network-related errors through standard error. This is only useful when BOOST_NETWORK_DEBUG is turned on. Otherwise the macro amounts to a no-op. */ #ifdef BOOST_NETWORK_DEBUG #include #ifndef BOOST_NETWORK_MESSAGE #define BOOST_NETWORK_MESSAGE(msg) \ std::cerr << "[DEBUG " << __FILE__ << ':' << __LINE__ << "]: " << msg \ << std::endl; #endif #else #ifndef BOOST_NETWORK_MESSAGE #define BOOST_NETWORK_MESSAGE(msg) #endif #endif #endif /* end of include guard: BOOST_NETWORK_DEBUG_HPP_20110410 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/detail/directive_base.hpp000066400000000000000000000015651240331347200257400ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_DETAIL_DIRECTIVE_BASE_HPP__ #define __NETWORK_DETAIL_DIRECTIVE_BASE_HPP__ /** Defines the base type from which all directives inherit * to allow friend access to message and other types' internals. */ namespace boost { namespace network { namespace detail { template struct directive_base { typedef Tag tag; // explicit directive_base(basic_message & message_) // : _message(message_) protected: ~directive_base() {}; // can only be extended // mutable basic_message & _message; }; } // namespace detail } // namespace network } // namespace boost #endif // __NETWORK_DETAIL_DIRECTIVE_BASE_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/detail/wrapper_base.hpp000066400000000000000000000016461240331347200254420ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_DETAIL_WRAPPER_BASE_HPP__ #define __NETWORK_DETAIL_WRAPPER_BASE_HPP__ namespace boost { namespace network { namespace detail { template struct wrapper_base { explicit wrapper_base(Message& message_) : _message(message_) {}; protected: ~wrapper_base() {}; // for extending only Message& _message; }; template struct wrapper_base_const { explicit wrapper_base_const(Message const& message_) : _message(message_) {} protected: ~wrapper_base_const() {}; // for extending only Message const& _message; }; } // namespace detail } // namespace network } // namespace boost #endif // __NETWORK_DETAIL_WRAPPER_BASE_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/include/000077500000000000000000000000001240331347200224315ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/include/http/000077500000000000000000000000001240331347200234105ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/include/http/client.hpp000066400000000000000000000007101240331347200253750ustar00rootroot00000000000000#ifndef BOOST_NETWORK_INCLUDE_HTTP_CLIENT_HPP_ #define BOOST_NETWORK_INCLUDE_HTTP_CLIENT_HPP_ // Copyright 2009 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // This is the modular include file for using the HTTP Client #include #endif // BOOST_NETWORK_INCLUDE_HTTP_CLIENT_HPP_ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/include/http/server.hpp000066400000000000000000000006351240331347200254330ustar00rootroot00000000000000#ifndef BOOST_NETWORK_INCLUDE_HTTP_SERVER_HPP_ #define BOOST_NETWORK_INCLUDE_HTTP_SERVER_HPP_ // Copyright 2010 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // This is the modular include file for using the HTTP Client #include #endif cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/include/message.hpp000066400000000000000000000007301240331347200245660ustar00rootroot00000000000000#ifndef BOOST_NETWORK_INCLUDE_MESSAGE_HPP_ #define BOOST_NETWORK_INCLUDE_MESSAGE_HPP_ // Copyright 2009 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // This is the modular include file for using the basic message type #include #include #endif // BOOST_NETWORK_INCLUDE_MESSAGE_HPP_ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message.hpp000066400000000000000000000100641240331347200231440ustar00rootroot00000000000000// Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_HPP__ #define __NETWORK_MESSAGE_HPP__ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /** message.hpp * * This header file implements the common message type which * all networking implementations under the boost::network * namespace. The common message type allows for easy message * construction and manipulation suited for networked * application development. */ namespace boost { namespace network { /** The common message type. */ template struct basic_message { public: typedef Tag tag; typedef typename headers_container::type headers_container_type; typedef typename headers_container_type::value_type header_type; typedef typename string::type string_type; basic_message() : _headers(), _body(), _source(), _destination() {} basic_message(const basic_message& other) : _headers(other._headers), _body(other._body), _source(other._source), _destination(other._destination) {} basic_message& operator=(basic_message rhs) { rhs.swap(*this); return *this; } void swap(basic_message& other) { std::swap(other._headers, _headers); std::swap(other._body, _body); std::swap(other._source, _source); std::swap(other._destination, _destination); } headers_container_type& headers() { return _headers; } void headers(headers_container_type const& headers_) const { _headers = headers_; } void add_header(typename headers_container_type::value_type const& pair_) const { _headers.insert(pair_); } void remove_header(typename headers_container_type::key_type const& key) const { _headers.erase(key); } headers_container_type const& headers() const { return _headers; } string_type& body() { return _body; } void body(string_type const& body_) const { _body = body_; } string_type const& body() const { return _body; } string_type& source() { return _source; } void source(string_type const& source_) const { _source = source_; } string_type const& source() const { return _source; } string_type& destination() { return _destination; } void destination(string_type const& destination_) const { _destination = destination_; } string_type const& destination() const { return _destination; } private: friend struct detail::directive_base; friend struct detail::wrapper_base >; mutable headers_container_type _headers; mutable string_type _body; mutable string_type _source; mutable string_type _destination; }; template inline void swap(basic_message& left, basic_message& right) { // swap for ADL left.swap(right); } // Commenting this out as we don't need to do this anymore. // BOOST_CONCEPT_ASSERT((Message // >)); // BOOST_CONCEPT_ASSERT((Message // >)); typedef basic_message message; typedef basic_message wmessage; } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/000077500000000000000000000000001240331347200224325ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/directives.hpp000066400000000000000000000024121240331347200253030ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_DIRECTIVES_HPP__ #define __NETWORK_MESSAGE_DIRECTIVES_HPP__ #include #include #include namespace boost { namespace network { template inline basic_message& operator<<(basic_message& message_, Directive const& directive) { directive(message_); return message_; } BOOST_NETWORK_STRING_DIRECTIVE(source, source_, message.source(source_), message.source = source_); BOOST_NETWORK_STRING_DIRECTIVE(destination, destination_, message.destination(destination_), message.destination = destination_); BOOST_NETWORK_STRING_DIRECTIVE(body, body_, message.body(body_), message.body = body_); } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_DIRECTIVES_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/directives/000077500000000000000000000000001240331347200245735ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/directives/detail/000077500000000000000000000000001240331347200260355ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/directives/detail/string_directive.hpp000066400000000000000000000060031240331347200321110ustar00rootroot00000000000000#ifndef BOOST_NETWORK_MESSAGE_DIRECTIVES_DETAIL_STRING_DIRECTIVE_HPP_20100915 #define BOOST_NETWORK_MESSAGE_DIRECTIVES_DETAIL_STRING_DIRECTIVE_HPP_20100915 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include /** * * To create your own string directive, you can use the preprocessor macro * BOOST_NETWORK_STRING_DIRECTIVE which takes three parameters: the name of * the directive, a name for the variable to use in the directive visitor, * and the body to be implemented in the visitor. An example directive for * setting the source of a message would look something like this given the * BOOST_NETWORK_STRING_DIRECTIVE macro: * * BOOST_NETWORK_STRING_DIRECTIVE(source, source_, * message.source(source_) * , message.source=source_); * */ #ifndef BOOST_NETWORK_STRING_DIRECTIVE #define BOOST_NETWORK_STRING_DIRECTIVE(name, value, body, pod_body) \ template \ struct name##_directive { \ ValueType const& value; \ explicit name##_directive(ValueType const& value_) : value(value_) {} \ name##_directive(name##_directive const& other) : value(other.value) {} \ template class Message> \ typename enable_if, void>::type operator()( \ Message& message) const { \ pod_body; \ } \ template class Message> \ typename enable_if >, void>::type operator()( \ Message& message) const { \ body; \ } \ }; \ \ template \ inline name##_directive name(T const& input) { \ return name##_directive(input); \ } #endif /* BOOST_NETWORK_STRING_DIRECTIVE */ #endif /* BOOST_NETWORK_MESSAGE_DIRECTIVES_DETAIL_STRING_DIRECTIVE_HPP_20100915 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/directives/detail/string_value.hpp000066400000000000000000000022561240331347200312550ustar00rootroot00000000000000#ifndef BOOST_NETWORK_MESSAGE_DIRECTIVES_DETAIL_STRING_VALUE_HPP_20100915 #define BOOST_NETWORK_MESSAGE_DIRECTIVES_DETAIL_STRING_VALUE_HPP_20100915 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace detail { template struct string_value : mpl::if_, boost::shared_future::type>, typename mpl::if_< mpl::or_, is_same, is_same >, typename string::type, unsupported_tag >::type> {}; } /* detail */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_MESSAGE_DIRECTIVES_DETAIL_STRING_VALUE_HPP_20100915 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/directives/header.hpp000066400000000000000000000047131240331347200265410ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007-2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_DIRECTIVES_HEADER_HPP__ #define __NETWORK_MESSAGE_DIRECTIVES_HEADER_HPP__ #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace impl { template struct header_directive { explicit header_directive(KeyType const& header_name, ValueType const& header_value) : _header_name(header_name), _header_value(header_value) {}; template struct pod_directive { template static void eval(Message const& message, T1 const& key, T2 const& value) { typedef typename Message::headers_container_type::value_type value_type; value_type value_ = {key, value}; message.headers.insert(message.headers.end(), value_); } }; template struct normal_directive { template static void eval(Message const& message, T1 const& key, T2 const& value) { typedef typename Message::headers_container_type::value_type value_type; message.add_header(value_type(key, value)); } }; template struct directive_impl : mpl::if_, pod_directive, normal_directive >::type {}; template void operator()(Message const& msg) const { typedef typename Message::headers_container_type::value_type value_type; directive_impl::eval(msg, _header_name, _header_value); } private: KeyType const& _header_name; ValueType const& _header_value; }; } // namespace impl template inline impl::header_directive header(T1 const& header_name, T2 const& header_value) { return impl::header_directive(header_name, header_value); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_DIRECTIVES_HEADER_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/directives/remove_header.hpp000066400000000000000000000023301240331347200301070ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef NETWORK_MESSAGE_DIRECTIVES_REMOVE_HEADER_HPP #define NETWORK_MESSAGE_DIRECTIVES_REMOVE_HEADER_HPP #include namespace boost { namespace network { template struct basic_message; namespace impl { template struct remove_header_directive { explicit remove_header_directive(T header_name) : header_name_(header_name) {}; template void operator()(basic_message& msg) const { msg.headers().erase(header_name_); } private: mutable T header_name_; }; } // namespace impl inline impl::remove_header_directive remove_header( std::string header_name) { return impl::remove_header_directive(header_name); } inline impl::remove_header_directive remove_header( std::wstring header_name) { return impl::remove_header_directive(header_name); } } // namespace network } // namespace boost #endif // NETWORK_MESSAGE_DIRECTIVES_REMOVE_HEADER_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/message_concept.hpp000066400000000000000000000042741240331347200263110ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_MESSAGE_CONCEPT_HPP_20100903 #define BOOST_NETWORK_MESSAGE_MESSAGE_CONCEPT_HPP_20100903 // Copyright (c) Glyn Matthews 2010. // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include namespace boost { namespace network { template struct Message : DefaultConstructible, CopyConstructible, Assignable { typedef typename M::string_type string_type; typedef typename M::headers_container_type headers_container_type; BOOST_CONCEPT_USAGE(Message) { M message_; swap(message, message_); typedef typename traits::body::type body_type; typedef typename traits::source::type source_type; typedef typename traits::destination::type destination_type; typedef typename traits::header_key::type header_key_type; typedef typename traits::header_value::type header_value_type; headers_container_type headers_ = headers(message); string_type body_ = body(message); string_type source_ = source(message); string_type destination_ = destination(message); message << source(source_type()) << destination(destination_type()) << header(string_type(), string_type()) << body(body_type()); add_header(message, string_type(), string_type()); remove_header(message, string_type()); clear_headers(message); source(message, source_type()); destination(message, destination_type()); body(message, body_type()); (void)headers_; (void)body_; (void)source_; (void)destination_; } private: M message; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_MESSAGE_MESSAGE_CONCEPT_HPP_20100903 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/modifiers/000077500000000000000000000000001240331347200244135ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/modifiers/add_header.hpp000066400000000000000000000036341240331347200271720ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_MODIFIER_ADD_HEADER_HPP_20100824 #define BOOST_NETWORK_MESSAGE_MODIFIER_ADD_HEADER_HPP_20100824 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { namespace impl { template inline typename enable_if< mpl::and_ >, mpl::not_ > >, void>::type add_header(Message& message, KeyType const& key, ValueType const& value, Tag) { message.headers().insert(std::make_pair(key, value)); } template inline typename enable_if >, is_async >, void>::type add_header(Message& message, KeyType const& key, ValueType const& value, Tag) { typedef typename Message::header_type header_type; message.add_header(header_type(key, value)); } template inline typename enable_if, void>::type add_header( Message& message, KeyType const& key, ValueType const& value, Tag) { typename Message::header_type header = {key, value}; message.headers.insert(message.headers.end(), header); } } template class Message, class KeyType, class ValueType> inline void add_header(Message& message, KeyType const& key, ValueType const& value) { impl::add_header(message, key, value, Tag()); } } // namespace network } // namespace boost #endif // BOOST_NETWORK_MESSAGE_MODIFIER_ADD_HEADER_HPP_20100824 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/modifiers/body.hpp000066400000000000000000000021261240331347200260620ustar00rootroot00000000000000#ifndef BOOST_NETWORK_MODIFIERS_BODY_HPP_20100824 #define BOOST_NETWORK_MODIFIERS_BODY_HPP_20100824 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template class Message, class ValueType> inline void body_impl(Message& message, ValueType const& body, tags::pod) { message.body = body; } template class Message, class ValueType> inline void body_impl(Message& message, ValueType const& body, tags::normal) { message.body(body); } template class Message, class ValueType> inline void body(Message& message, ValueType const& body_) { body_impl(message, body_, typename pod_or_normal::type()); } } // namespace network } // namespace boost #endif // BOOST_NETWORK_MODIFIERS_BODY_HPP_20100824 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/modifiers/clear_headers.hpp000066400000000000000000000035521240331347200277120ustar00rootroot00000000000000#ifndef BOOST_NETWORK_MESSAGE_MODIFIER_CLEAR_HEADERS_HPP_20100824 #define BOOST_NETWORK_MESSAGE_MODIFIER_CLEAR_HEADERS_HPP_20100824 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace impl { template inline typename enable_if< mpl::and_ >, mpl::not_ > >, void>::type clear_headers(Message const &message, Tag const &) { (typename Message::headers_container_type()).swap(message.headers()); } template inline typename enable_if, void>::type clear_headers( Message const &message, Tag const &) { (typename Message::headers_container_type()).swap(message.headers); } template inline typename enable_if >, is_async >, void>::type clear_headers(Message const &message, Tag const &) { boost::promise header_promise; boost::shared_future headers_future( header_promise.get_future()); message.headers(headers_future); header_promise.set_value(typename Message::headers_container_type()); } } // namespace impl template class Message> inline void clear_headers(Message const &message) { impl::clear_headers(message, Tag()); } } // namespace network } // namespace boost #endif // BOOST_NETWORK_MESSAGE_MODIFIER_CLEAR_HEADERS_HPP_20100824 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/modifiers/destination.hpp000066400000000000000000000024231240331347200274460ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_MODIFIER_DESTINATION_HPP_20100824 #define BOOST_NETWORK_MESSAGE_MODIFIER_DESTINATION_HPP_20100824 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace impl { template inline void destination(Message const &message, ValueType const &destination_, Tag const &, mpl::false_ const &) { message.destination(destination_); } template inline void destination(Message const &message, ValueType const &destination_, Tag const &, mpl::true_ const &) { message.destination(destination_); } } template class Message, class ValueType> inline void destination(Message const &message, ValueType const &destination_) { impl::destination(message, destination_, Tag(), is_async()); } } // namespace network } // namespace boost #endif // BOOST_NETWORK_MESSAGE_MODIFIER_DESTINATION_HPP_20100824 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/modifiers/remove_header.hpp000066400000000000000000000040271240331347200277340ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_MODIFIER_REMOVE_HEADER_HPP_20100824 #define BOOST_NETWORK_MESSAGE_MODIFIER_REMOVE_HEADER_HPP_20100824 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace impl { template inline typename enable_if< mpl::and_ >, mpl::not_ > >, void>::type remove_header(Message& message, KeyType const& key, Tag) { message.headers().erase(key); } template inline typename enable_if >, is_async >, void>::type remove_header(Message& message, KeyType const& key, Tag) { message.remove_header(key); } template struct iequals_pred { KeyType const& key; iequals_pred(KeyType const& key) : key(key) {} template bool operator()(Header& other) const { return boost::iequals(key, name(other)); } }; template inline typename enable_if, void>::type remove_header( Message& message, KeyType const& key, Tag) { typedef typename Message::headers_container_type headers; message.headers.erase( boost::remove_if(message.headers, iequals_pred(key)), message.headers.end()); } } // namespace impl template class Message, class KeyType> inline void remove_header(Message& message, KeyType const& key) { impl::remove_header(message, key, Tag()); } } // namespace network } // namespace boost #endif // BOOST_NETWORK_MESSAGE_MODIFIER_REMOVE_HEADER_HPP_20100824 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/modifiers/source.hpp000066400000000000000000000022271240331347200264270ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_MODIFIER_SOURCE_HPP_20100824 #define BOOST_NETWORK_MESSAGE_MODIFIER_SOURCE_HPP_20100824 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace impl { template inline void source(Message const &message, ValueType const &source_, Tag const &, mpl::false_ const &) { message.source(source_); } template inline void source(Message const &message, ValueType const &source_, Tag const &, mpl::true_ const &) { message.source(source_); } } // namespace impl template class Message, class ValueType> inline void source(Message const &message, ValueType const &source_) { impl::source(message, source_, Tag(), is_async()); } } // namespace network } // namespace boost #endif // BOOST_NETWORK_MESSAGE_MODIFIER_SOURCE_HPP_20100824 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/traits/000077500000000000000000000000001240331347200237405ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/traits/body.hpp000066400000000000000000000024151240331347200254100ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_TRAITS_BODY_HPP_20100903 #define BOOST_NETWORK_MESSAGE_TRAITS_BODY_HPP_20100903 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace traits { template struct unsupported_tag; template struct body : mpl::if_< is_async, boost::shared_future::type>, typename mpl::if_< mpl::or_, is_same, is_same >, typename string::type, unsupported_tag >::type> {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_BODY_HPP_20100903 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/traits/destination.hpp000066400000000000000000000024151240331347200267740ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_TRAITS_DESTINATION_HPP_20100903 #define BOOST_NETWORK_MESSAGE_TRAITS_DESTINATION_HPP_20100903 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { namespace traits { template struct unsupported_tag; template struct destination : mpl::if_< is_async, boost::shared_future::type>, typename mpl::if_< mpl::or_, is_same, is_same >, typename string::type, unsupported_tag >::type> {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_DESTINATION_HPP_20100903 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/traits/headers.hpp000066400000000000000000000035461240331347200260740ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_MESSAGE_TRAITS_HEADERS_HPP_20100903 #define BOOST_NETWORK_MESSAGE_TRAITS_HEADERS_HPP_20100903 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace traits { template struct unsupported_tag; template struct header_key : mpl::if_< is_async, boost::shared_future::type>, typename mpl::if_< mpl::or_, is_same, is_same >, typename string::type, unsupported_tag >::type> {}; template struct header_value : mpl::if_< is_async, boost::shared_future::type>, typename mpl::if_< mpl::or_, is_same, is_same >, typename string::type, unsupported_tag >::type> {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_HEADERS_HPP_20100903 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/traits/source.hpp000066400000000000000000000023701240331347200257530ustar00rootroot00000000000000#ifndef BOOST_NETWORK_MESSAGE_TRAITS_SOURCE_HPP_20100903 #define BOOST_NETWORK_MESSAGE_TRAITS_SOURCE_HPP_20100903 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { namespace traits { template struct unsupported_tag; template struct source : mpl::if_< is_async, boost::shared_future::type>, typename mpl::if_< mpl::or_, is_same, is_same >, typename string::type, unsupported_tag >::type> {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_SOURCE_HPP_20100903 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/transformers.hpp000066400000000000000000000032141240331347200256700ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_TRANSFORMERS_HPP__ #define __NETWORK_MESSAGE_TRANSFORMERS_HPP__ /** transformers.hpp * * Pulls in all the transformers files. */ #include #include #include #include namespace boost { namespace network { namespace impl { template struct get_real_algorithm { typedef typename boost::function_traits< typename boost::remove_pointer::type>::result_type:: template type::type>::result_type> type; }; template struct transform_impl : public get_real_algorithm::type {}; } // namspace impl template inline impl::transform_impl transform(Algorithm, Selector) { return impl::transform_impl(); } template inline basic_message& operator<<( basic_message& msg_, impl::transform_impl const& transformer) { transformer(msg_); return msg_; } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_TRANSFORMERS_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/transformers/000077500000000000000000000000001240331347200251575ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/transformers/selectors.hpp000066400000000000000000000031141240331347200276720ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_TRANSFORMERS_SELECTORS_HPP__ #define __NETWORK_MESSAGE_TRANSFORMERS_SELECTORS_HPP__ namespace boost { namespace network { namespace selectors { struct source_selector; struct destination_selector; } // namespace selectors selectors::source_selector source_(selectors::source_selector); selectors::destination_selector destination_(selectors::destination_selector); namespace selectors { struct source_selector { private: source_selector() {}; source_selector(source_selector const &) {}; friend source_selector boost::network::source_(source_selector); }; struct destination_selector { private: destination_selector() {}; destination_selector(destination_selector const &) {}; friend destination_selector boost::network::destination_( destination_selector); }; } // namespace selectors typedef selectors::source_selector (*source_selector_t)( selectors::source_selector); typedef selectors::destination_selector (*destination_selector_t)( selectors::destination_selector); inline selectors::source_selector source_(selectors::source_selector) { return selectors::source_selector(); } inline selectors::destination_selector destination_( selectors::destination_selector) { return selectors::destination_selector(); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_TRANSFORMERS_SELECTORS_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/transformers/to_lower.hpp000066400000000000000000000041541240331347200275260ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_TRANSFORMERS_TO_LOWER_HPP__ #define __NETWORK_MESSAGE_TRANSFORMERS_TO_LOWER_HPP__ #include /** to_lower.hpp * * Implements the to_lower transformer. This applies * the to_lower string algorithm to a string, which * is selected by the appropriate selector. * * This defines a type, to be applied using template * metaprogramming on the selected string target. */ namespace boost { namespace network { namespace impl { template struct to_lower_transformer {}; template <> struct to_lower_transformer { template void operator()(basic_message &message_) const { boost::to_lower(message_.source()); } protected: ~to_lower_transformer() {} }; template <> struct to_lower_transformer { template void operator()(basic_message &message_) const { boost::to_lower(message_.destination()); } protected: ~to_lower_transformer() {}; }; } // namespace impl namespace detail { struct to_lower_placeholder_helper; } detail::to_lower_placeholder_helper to_lower_( detail::to_lower_placeholder_helper); namespace detail { struct to_lower_placeholder_helper { template struct type : public impl::to_lower_transformer {}; private: to_lower_placeholder_helper() {} to_lower_placeholder_helper(to_lower_placeholder_helper const &) {} friend to_lower_placeholder_helper boost::network::to_lower_( to_lower_placeholder_helper); }; } typedef detail::to_lower_placeholder_helper (*to_lower_placeholder)( detail::to_lower_placeholder_helper); inline detail::to_lower_placeholder_helper to_lower_( detail::to_lower_placeholder_helper) { return detail::to_lower_placeholder_helper(); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_TRANSFORMERS_TO_LOWER_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/transformers/to_upper.hpp000066400000000000000000000041551240331347200275320ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_TRANSFORMERS_TO_UPPER_HPP__ #define __NETWORK_MESSAGE_TRANSFORMERS_TO_UPPER_HPP__ #include /** to_upper.hpp * * Implements the to_upper transformer. This applies * the to_upper string algorithm to a string, which * is selected by the appropriate selector. * * This defines a type, to be applied using template * metaprogramming on the selected string target. */ namespace boost { namespace network { namespace impl { template struct to_upper_transformer {}; template <> struct to_upper_transformer { template void operator()(basic_message &message_) const { boost::to_upper(message_.source()); } protected: ~to_upper_transformer() {}; }; template <> struct to_upper_transformer { template void operator()(basic_message &message_) const { boost::to_upper(message_.destination()); } protected: ~to_upper_transformer() {}; }; } // namespace impl namespace detail { struct to_upper_placeholder_helper; } detail::to_upper_placeholder_helper to_upper_( detail::to_upper_placeholder_helper); namespace detail { struct to_upper_placeholder_helper { template struct type : public impl::to_upper_transformer {}; private: to_upper_placeholder_helper() {} to_upper_placeholder_helper(to_upper_placeholder_helper const &) {} friend to_upper_placeholder_helper boost::network::to_upper_( to_upper_placeholder_helper); }; } typedef detail::to_upper_placeholder_helper (*to_upper_placeholder)( detail::to_upper_placeholder_helper); inline detail::to_upper_placeholder_helper to_upper_( detail::to_upper_placeholder_helper) { return detail::to_upper_placeholder_helper(); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_TRANSFORMERS_TO_UPPER_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/wrappers.hpp000066400000000000000000000011641240331347200250100ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_WRAPPERS_HPP__ #define __NETWORK_MESSAGE_WRAPPERS_HPP__ /** wrappers.hpp * * Pulls in all the wrapper header files. */ #include #include #include #include #endif // __NETWORK_MESSAGE_WRAPPERS_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/wrappers/000077500000000000000000000000001240331347200242755ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/wrappers/body.hpp000066400000000000000000000061001240331347200257400ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_WRAPPERS_BODY_HPP__ #define __NETWORK_MESSAGE_WRAPPERS_BODY_HPP__ #include #include #include namespace boost { namespace network { template struct body_range { typedef typename boost::iterator_range< typename Message::string_type::const_iterator> type; }; namespace impl { template struct body_wrapper : public detail::wrapper_base > { typedef basic_message message_type; typedef typename string::type string_type; typedef detail::wrapper_base > wrapper_base; explicit body_wrapper(basic_message& message_) : wrapper_base(message_) {}; operator string_type() const { return string_type(wrapper_base::_message.body()); }; std::size_t size() const { return wrapper_base::_message.body().size(); } operator boost::iterator_range< typename boost::range_iterator::type>() const { return boost::make_iterator_range(wrapper_base::_message.body()); } typename string_type::const_iterator begin() const { return wrapper_base::_message.body().begin(); } typename string_type::const_iterator end() const { return wrapper_base::_message.body().end(); } }; template struct body_wrapper_const : public detail::wrapper_base_const > { typedef basic_message message_type; typedef typename string::type string_type; typedef detail::wrapper_base_const > wrapper_base; explicit body_wrapper_const(basic_message const& message_) : wrapper_base(message_) {}; operator string_type() const { return string_type(wrapper_base::_message.body()); } std::size_t size() const { return wrapper_base::_message.body().size(); } operator boost::range_iterator() const { return boost::make_iterator_range(wrapper_base::_message.body()); } }; template inline std::ostream& operator<<(std::ostream& os, body_wrapper const& body) { os << static_cast::string_type>(body); return os; } template inline std::ostream& operator<<(std::ostream& os, body_wrapper_const const& body) { os << static_cast::string_type>(body); return os; } } // namespace impl template inline impl::body_wrapper const body(basic_message& message_) { return impl::body_wrapper(message_); } template inline impl::body_wrapper_const const body( basic_message const& message_) { return impl::body_wrapper_const(message_); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_WRAPPERS_BODY_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/wrappers/destination.hpp000066400000000000000000000022501240331347200273260ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_WRAPPERS_DESTINATION_HPP__ #define __NETWORK_MESSAGE_WRAPPERS_DESTINATION_HPP__ #include namespace boost { namespace network { namespace impl { template struct destination_wrapper : public detail::wrapper_base > { typedef Tag tag; typedef basic_message message_type; typedef typename string::type string_type; typedef detail::wrapper_base > wrapper_base; explicit destination_wrapper(message_type& message_) : wrapper_base(message_) {}; operator string_type() const { return string_type(wrapper_base::_message.destination()); }; }; } // namespace impl template inline typename string::type destination(basic_message& message_) { return impl::destination_wrapper(message_); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_WRAPPERS_DESTINATION_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/wrappers/headers.hpp000066400000000000000000000063051240331347200264250ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_WRAPPERS_HEADERS_HPP__ #define __NETWORK_MESSAGE_WRAPPERS_HEADERS_HPP__ #include #include #include #include #include namespace boost { namespace network { /// Template metaprogram to get the range type for a message template struct headers_range { typedef typename headers_container::type headers_container_type; typedef typename boost::iterator_range< typename headers_container_type::const_iterator> type; }; template struct basic_message; /** headers wrapper for messages. * * This exposes an interface similar to a map, indexable * using operator[] taking a string as the index and returns * a range of iterators (std::pair) * whose keys are all equal to the index string. * * This type is also convertible to a * headers_range >::type * Which allows for full range support. * * The type is also convertible to a * headers_container::type * Which copies the headers from the wrapped message. * */ namespace impl { template struct headers_wrapper : public detail::wrapper_base_const > { typedef Tag tag; typedef basic_message message_type; typedef typename string::type string_type; typedef typename headers_range::type range_type; typedef typename headers_container::type headers_container_type; typedef typename headers_container_type::const_iterator const_iterator; typedef typename headers_container_type::iterator iterator; typedef detail::wrapper_base_const > wrapper_base; explicit headers_wrapper(basic_message const& message_) : wrapper_base(message_) {}; range_type operator[](string_type const& key) const { return headers_wrapper::_message.headers().equal_range(key); }; typename message_type::headers_container_type::size_type count( string_type const& key) const { return headers_wrapper::_message.headers().count(key); }; const_iterator begin() const { return headers_wrapper::_message.headers().begin(); }; const_iterator end() const { return headers_wrapper::_message.headers().end(); }; operator range_type() { return make_iterator_range(headers_wrapper::_message.headers().begin(), headers_wrapper::_message.headers().end()); }; operator headers_container_type() { return headers_wrapper::_message.headers(); } }; } // namespace impl /// Factory method to create the right wrapper object template inline impl::headers_wrapper headers(basic_message const& message_) { return impl::headers_wrapper(message_); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_WRAPPERS_HEADERS_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message/wrappers/source.hpp000066400000000000000000000022021240331347200263020ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_MESSAGE_WRAPPERS_SOURCE_HPP__ #define __NETWORK_MESSAGE_WRAPPERS_SOURCE_HPP__ #include namespace boost { namespace network { namespace impl { template struct source_wrapper : public detail::wrapper_base > { typedef Tag tag; typedef basic_message message_type; typedef typename string::type string_type; typedef detail::wrapper_base > wrapper_base; explicit source_wrapper(basic_message& message_) : wrapper_base(message_) {}; operator string_type() const { return string_type(wrapper_base::_message.source()); }; }; } // namespace impl template inline typename string::type source(basic_message& message_) { return impl::source_wrapper(message_); } } // namespace network } // namespace boost #endif // __NETWORK_MESSAGE_WRAPPERS_SOURCE_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/message_fwd.hpp000066400000000000000000000007101240331347200240010ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __2008817MESSAGE_FWD_INC__ #define __2008817MESSAGE_FWD_INC__ namespace boost { namespace network { template struct basic_message; } // namespace boost } // namespace network #endif // __2008817MESSAGE_FWD_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol.hpp000066400000000000000000000010551240331347200233610ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_PROTOCOLS_20070908_1_HPP__ #define __NETWORK_PROTOCOLS_20070908_1_HPP__ // Include all protocol implementation headers in protocol/* // Author: Dean Michael Berris // Date Created: Oct. 08, 2007 #include // include HTTP implementation #endif // __NETWORK_PROTOCOLS_20070908-1_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/000077500000000000000000000000001240331347200226475ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http.hpp000066400000000000000000000012511240331347200243360ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007, 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_PROTOCOL_HTTP_20070908_1_HPP__ #define __NETWORK_PROTOCOL_HTTP_20070908_1_HPP__ // Include HTTP implementation headers // Author: Dean Michael Berris // Date Created: Oct. 08, 2007 #include #include #include #include #endif // __NETWORK_PROTOCOL_HTTP_20070908-1_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/000077500000000000000000000000001240331347200236265ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/algorithms/000077500000000000000000000000001240331347200257775ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/algorithms/linearize.hpp000066400000000000000000000150261240331347200304760ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_ALGORITHMS_LINEARIZE_HPP_20101028 #define BOOST_NETWORK_PROTOCOL_HTTP_ALGORITHMS_LINEARIZE_HPP_20101028 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct linearize_header { typedef typename string::type string_type; template struct result; template struct result { typedef string_type type; }; template BOOST_CONCEPT_REQUIRES(((Header::type>)), (string_type)) operator()(ValueType& header) { typedef typename ostringstream::type output_stream; typedef constants consts; output_stream header_line; header_line << name(header) << consts::colon() << consts::space() << value(header) << consts::crlf(); return header_line.str(); } }; template BOOST_CONCEPT_REQUIRES(((ClientRequest)), (OutputIterator)) linearize(Request const& request, typename Request::string_type const& method, unsigned version_major, unsigned version_minor, OutputIterator oi) { typedef typename Request::tag Tag; typedef constants consts; typedef typename string::type string_type; static string_type http_slash = consts::http_slash(), accept = consts::accept(), accept_mime = consts::default_accept_mime(), accept_encoding = consts::accept_encoding(), default_accept_encoding = consts::default_accept_encoding(), crlf = consts::crlf(), host = consts::host(), connection = consts::connection(), close = consts::close(); boost::copy(method, oi); *oi = consts::space_char(); if (request.path().empty() || request.path()[0] != consts::slash_char()) *oi = consts::slash_char(); boost::copy(request.path(), oi); if (!request.query().empty()) { *oi = consts::question_mark_char(); boost::copy(request.query(), oi); } if (!request.anchor().empty()) { *oi = consts::hash_char(); boost::copy(request.anchor(), oi); } *oi = consts::space_char(); boost::copy(http_slash, oi); string_type version_major_str = boost::lexical_cast(version_major), version_minor_str = boost::lexical_cast(version_minor); boost::copy(version_major_str, oi); *oi = consts::dot_char(); boost::copy(version_minor_str, oi); boost::copy(crlf, oi); // We need to determine whether we've seen any of the following headers // before setting the defaults. We use a bitset to keep track of the // defaulted headers. enum { ACCEPT, ACCEPT_ENCODING, HOST, CONNECTION, MAX }; std::bitset found_headers; static char const* defaulted_headers[][2] = { {consts::accept(), consts::accept() + std::strlen(consts::accept())}, {consts::accept_encoding(), consts::accept_encoding() + std::strlen(consts::accept_encoding())}, {consts::host(), consts::host() + std::strlen(consts::host())}, {consts::connection(), consts::connection() + std::strlen(consts::connection())}}; typedef typename headers_range::type headers_range; typedef typename range_value::type headers_value; BOOST_FOREACH(const headers_value & header, headers(request)) { string_type header_name = name(header), header_value = value(header); // Here we check that we have not seen an override to the defaulted // headers. for (int header_index = 0; header_index < MAX; ++header_index) if (std::distance(header_name.begin(), header_name.end()) == std::distance(defaulted_headers[header_index][0], defaulted_headers[header_index][1]) && std::equal(header_name.begin(), header_name.end(), defaulted_headers[header_index][0], algorithm::is_iequal())) found_headers.set(header_index, true); // We ignore empty headers. if (header_value.empty()) continue; boost::copy(header_name, oi); *oi = consts::colon_char(); *oi = consts::space_char(); boost::copy(header_value, oi); boost::copy(crlf, oi); } if (!found_headers[HOST]) { boost::copy(host, oi); *oi = consts::colon_char(); *oi = consts::space_char(); boost::copy(request.host(), oi); boost::optional port_ = port(request); if (port_) { string_type port_str = boost::lexical_cast(*port_); *oi = consts::colon_char(); boost::copy(port_str, oi); } boost::copy(crlf, oi); } if (!found_headers[ACCEPT]) { boost::copy(accept, oi); *oi = consts::colon_char(); *oi = consts::space_char(); boost::copy(accept_mime, oi); boost::copy(crlf, oi); } if (version_major == 1u && version_minor == 1u && !found_headers[ACCEPT_ENCODING]) { boost::copy(accept_encoding, oi); *oi = consts::colon_char(); *oi = consts::space_char(); boost::copy(default_accept_encoding, oi); boost::copy(crlf, oi); } if (!connection_keepalive::value && !found_headers[CONNECTION]) { boost::copy(connection, oi); *oi = consts::colon_char(); *oi = consts::space_char(); boost::copy(close, oi); boost::copy(crlf, oi); } boost::copy(crlf, oi); typename body_range::type body_data = body(request).range(); return boost::copy(body_data, oi); } } /* http */ } /* net */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_ALGORITHMS_LINEARIZE_HPP_20101028 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client.hpp000066400000000000000000000045221240331347200256200ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_20091215 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_20091215 // Copyright Dean Michael Berris 2007-2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_client : basic_client_facade { private: typedef basic_client_facade base_facade_type; public: typedef basic_request request; typedef basic_response response; typedef typename string::type string_type; typedef Tag tag_type; typedef client_options options; // Constructors // ================================================================= // This constructor takes a single options argument of type // client_options. See boost/network/protocol/http/client/options.hpp // for more details. explicit basic_client(options const& options) : base_facade_type(options) {} // This default constructor sets up the default options. basic_client() : base_facade_type(options()) {} // // ================================================================= }; #ifndef BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG #define BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG tags::http_async_8bit_udp_resolve #endif typedef basic_client client; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_20091215 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/000077500000000000000000000000001240331347200251045ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/async_impl.hpp000066400000000000000000000076321240331347200277630ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_ASYNC_IMPL_HPP_20100623 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_ASYNC_IMPL_HPP_20100623 // Copyright Dean Michael Berris 2010. // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_client_impl; namespace impl { template struct async_client : connection_policy::type { typedef typename connection_policy::type connection_base; typedef typename resolver::type resolver_type; typedef typename string::type string_type; typedef function const&, system::error_code const&)> body_callback_function_type; typedef function body_generator_function_type; async_client(bool cache_resolved, bool follow_redirect, bool always_verify_peer, int timeout, boost::shared_ptr service, optional const& certificate_filename, optional const& verify_path, optional const& certificate_file, optional const& private_key_file) : connection_base(cache_resolved, follow_redirect, timeout), service_ptr(service.get() ? service : boost::make_shared()), service_(*service_ptr), resolver_(service_), sentinel_(new boost::asio::io_service::work(service_)), certificate_filename_(certificate_filename), verify_path_(verify_path), certificate_file_(certificate_file), private_key_file_(private_key_file), always_verify_peer_(always_verify_peer) { connection_base::resolver_strand_.reset( new boost::asio::io_service::strand(service_)); if (!service) lifetime_thread_.reset(new boost::thread( boost::bind(&boost::asio::io_service::run, &service_))); } ~async_client() throw() { sentinel_.reset(); } void wait_complete() { sentinel_.reset(); if (lifetime_thread_.get()) { lifetime_thread_->join(); lifetime_thread_.reset(); } } basic_response const request_skeleton( basic_request const& request_, string_type const& method, bool get_body, body_callback_function_type callback, body_generator_function_type generator) { typename connection_base::connection_ptr connection_; connection_ = connection_base::get_connection( resolver_, request_, always_verify_peer_, certificate_filename_, verify_path_, certificate_file_, private_key_file_); return connection_->send_request(method, request_, get_body, callback, generator); } boost::shared_ptr service_ptr; boost::asio::io_service& service_; resolver_type resolver_; boost::shared_ptr sentinel_; boost::shared_ptr lifetime_thread_; optional certificate_filename_; optional verify_path_; optional certificate_file_; optional private_key_file_; bool always_verify_peer_; }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_ASYNC_IMPL_HPP_20100623 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/000077500000000000000000000000001240331347200272435ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/async_base.hpp000066400000000000000000000063241240331347200320700ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_ASYNC_CONNECTION_BASE_20100529 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_ASYNC_CONNECTION_BASE_20100529 // Copryight 2013 Google, Inc. // Copyright 2010 Dean Michael Berris // Copyright 2010 (C) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include namespace boost { namespace network { namespace http { namespace impl { template struct async_connection_base { typedef async_connection_base this_type; typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef typename resolver_base::resolve_function resolve_function; typedef typename string::type string_type; typedef basic_request request; typedef basic_response response; typedef iterator_range char_const_range; typedef function body_callback_function_type; typedef function body_generator_function_type; typedef shared_ptr connection_ptr; // This is the factory function which constructs the appropriate async // connection implementation with the correct delegate chosen based on // the // tag. static connection_ptr new_connection( resolve_function resolve, resolver_type &resolver, bool follow_redirect, bool always_verify_peer, bool https, int timeout, optional certificate_filename = optional(), optional const &verify_path = optional(), optional certificate_file = optional(), optional private_key_file = optional()) { typedef http_async_connection async_connection; typedef typename delegate_factory::type delegate_factory_type; connection_ptr temp; temp.reset(new async_connection( resolver, resolve, follow_redirect, timeout, delegate_factory_type::new_connection_delegate( resolver.get_io_service(), https, always_verify_peer, certificate_filename, verify_path, certificate_file, private_key_file))); BOOST_ASSERT(temp.get() != 0); return temp; } // This is the pure virtual entry-point for all asynchronous // connections. virtual response start(request const &request, string_type const &method, bool get_body, body_callback_function_type callback, body_generator_function_type generator) = 0; virtual ~async_connection_base() {} }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_ASYNC_CONNECTION_BASE_20100529 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/async_normal.hpp000066400000000000000000000506721240331347200324530ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_CONNECTION_HPP_20100601 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_CONNECTION_HPP_20100601 // Copyright 2010 (C) Dean Michael Berris // Copyright 2010 (C) Sinefunc, Inc. // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google,Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { namespace impl { template struct async_connection_base; namespace placeholders = boost::asio::placeholders; template struct http_async_connection : async_connection_base, protected http_async_protocol_handler, boost::enable_shared_from_this< http_async_connection > { typedef async_connection_base base; typedef http_async_protocol_handler protocol_base; typedef typename base::resolver_type resolver_type; typedef typename base::resolver_base::resolver_iterator resolver_iterator; typedef typename base::resolver_base::resolver_iterator_pair resolver_iterator_pair; typedef typename base::response response; typedef typename base::string_type string_type; typedef typename base::request request; typedef typename base::resolver_base::resolve_function resolve_function; typedef typename base::body_callback_function_type body_callback_function_type; typedef typename base::body_generator_function_type body_generator_function_type; typedef http_async_connection this_type; typedef typename delegate_factory::type delegate_factory_type; typedef typename delegate_factory_type::connection_delegate_ptr connection_delegate_ptr; http_async_connection(resolver_type& resolver, resolve_function resolve, bool follow_redirect, int timeout, connection_delegate_ptr delegate) : timeout_(timeout), timer_(resolver.get_io_service()), is_timedout_(false), follow_redirect_(follow_redirect), resolver_(resolver), resolve_(resolve), request_strand_(resolver.get_io_service()), delegate_(delegate) {} // This is the main entry point for the connection/request pipeline. // We're // overriding async_connection_base<...>::start(...) here which is // called // by the client. virtual response start(request const& request, string_type const& method, bool get_body, body_callback_function_type callback, body_generator_function_type generator) { response response_; this->init_response(response_, get_body); linearize(request, method, version_major, version_minor, std::ostreambuf_iterator::type>( &command_streambuf)); this->method = method; boost::uint16_t port_ = port(request); resolve_( resolver_, host(request), port_, request_strand_.wrap(boost::bind( &this_type::handle_resolved, this_type::shared_from_this(), port_, get_body, callback, generator, boost::arg<1>(), boost::arg<2>()))); if (timeout_ > 0) { timer_.expires_from_now(boost::posix_time::seconds(timeout_)); timer_.async_wait(request_strand_.wrap( boost::bind(&this_type::handle_timeout, this_type::shared_from_this(), boost::arg<1>()))); } return response_; } private: http_async_connection(http_async_connection const&); // = delete void set_errors(boost::system::error_code const& ec) { boost::system::system_error error(ec); this->version_promise.set_exception(boost::copy_exception(error)); this->status_promise.set_exception(boost::copy_exception(error)); this->status_message_promise.set_exception(boost::copy_exception(error)); this->headers_promise.set_exception(boost::copy_exception(error)); this->source_promise.set_exception(boost::copy_exception(error)); this->destination_promise.set_exception(boost::copy_exception(error)); this->body_promise.set_exception(boost::copy_exception(error)); this->timer_.cancel(); } void handle_timeout(boost::system::error_code const& ec) { if (!ec) delegate_->disconnect(); is_timedout_ = true; } void handle_resolved(boost::uint16_t port, bool get_body, body_callback_function_type callback, body_generator_function_type generator, boost::system::error_code const& ec, resolver_iterator_pair endpoint_range) { if (!ec && !boost::empty(endpoint_range)) { // Here we deal with the case that there was an error encountered // and // that there's still more endpoints to try connecting to. resolver_iterator iter = boost::begin(endpoint_range); asio::ip::tcp::endpoint endpoint(iter->endpoint().address(), port); delegate_->connect( endpoint, request_strand_.wrap(boost::bind( &this_type::handle_connected, this_type::shared_from_this(), port, get_body, callback, generator, std::make_pair(++iter, resolver_iterator()), placeholders::error))); } else { set_errors(ec ? ec : boost::asio::error::host_not_found); boost::iterator_range range; if (callback) callback(range, ec); } } void handle_connected(boost::uint16_t port, bool get_body, body_callback_function_type callback, body_generator_function_type generator, resolver_iterator_pair endpoint_range, boost::system::error_code const& ec) { if (is_timedout_) { set_errors(asio::error::timed_out); } else if (!ec) { BOOST_ASSERT(delegate_.get() != 0); delegate_->write( command_streambuf, request_strand_.wrap(boost::bind( &this_type::handle_sent_request, this_type::shared_from_this(), get_body, callback, generator, placeholders::error, placeholders::bytes_transferred))); } else { if (!boost::empty(endpoint_range)) { resolver_iterator iter = boost::begin(endpoint_range); asio::ip::tcp::endpoint endpoint(iter->endpoint().address(), port); delegate_->connect( endpoint, request_strand_.wrap(boost::bind( &this_type::handle_connected, this_type::shared_from_this(), port, get_body, callback, generator, std::make_pair(++iter, resolver_iterator()), placeholders::error))); } else { set_errors(ec ? ec : boost::asio::error::host_not_found); boost::iterator_range range; if (callback) callback(range, ec); } } } enum state_t { version, status, status_message, headers, body }; void handle_sent_request(bool get_body, body_callback_function_type callback, body_generator_function_type generator, boost::system::error_code const& ec, std::size_t bytes_transferred) { if (!is_timedout_ && !ec) { if (generator) { // Here we write some more data that the generator provides, // before // we wait for data from the server. string_type chunk; if (generator(chunk)) { // At this point this means we have more data to write, so we // write // it out. std::copy(chunk.begin(), chunk.end(), std::ostreambuf_iterator::type>( &command_streambuf)); delegate_->write( command_streambuf, request_strand_.wrap(boost::bind( &this_type::handle_sent_request, this_type::shared_from_this(), get_body, callback, generator, placeholders::error, placeholders::bytes_transferred))); return; } } delegate_->read_some( boost::asio::mutable_buffers_1(this->part.c_array(), this->part.size()), request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), version, get_body, callback, placeholders::error, placeholders::bytes_transferred))); } else { set_errors(is_timedout_ ? asio::error::timed_out : ec); } } void handle_received_data(state_t state, bool get_body, body_callback_function_type callback, boost::system::error_code const& ec, std::size_t bytes_transferred) { static const long short_read_error = 335544539; bool is_ssl_short_read_error = #ifdef BOOST_NETWORK_ENABLE_HTTPS ec.category() == asio::error::ssl_category && ec.value() == short_read_error; #else false && short_read_error; #endif if (!is_timedout_ && (!ec || ec == boost::asio::error::eof || is_ssl_short_read_error)) { logic::tribool parsed_ok; size_t remainder; switch (state) { case version: parsed_ok = this->parse_version( delegate_, request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), version, get_body, callback, placeholders::error, placeholders::bytes_transferred)), bytes_transferred); if (!parsed_ok || indeterminate(parsed_ok)) return; case status: parsed_ok = this->parse_status( delegate_, request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), status, get_body, callback, placeholders::error, placeholders::bytes_transferred)), bytes_transferred); if (!parsed_ok || indeterminate(parsed_ok)) return; case status_message: parsed_ok = this->parse_status_message( delegate_, request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), status_message, get_body, callback, placeholders::error, placeholders::bytes_transferred)), bytes_transferred); if (!parsed_ok || indeterminate(parsed_ok)) return; case headers: // In the following, remainder is the number of bytes that // remain // in the buffer. We need this in the body processing to make // sure // that the data remaining in the buffer is dealt with before // another call to get more data for the body is scheduled. fusion::tie(parsed_ok, remainder) = this->parse_headers( delegate_, request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), headers, get_body, callback, placeholders::error, placeholders::bytes_transferred)), bytes_transferred); if (!parsed_ok || indeterminate(parsed_ok)) return; if (!get_body) { // We short-circuit here because the user does not // want to get the body (in the case of a HEAD // request). this->body_promise.set_value(""); this->destination_promise.set_value(""); this->source_promise.set_value(""); this->part.assign('\0'); this->response_parser_.reset(); return; } if (callback) { // Here we deal with the spill-over data from the // headers processing. This means the headers data // has already been parsed appropriately and we're // looking to treat everything that remains in the // buffer. typename protocol_base::buffer_type::const_iterator begin = this->part_begin; typename protocol_base::buffer_type::const_iterator end = begin; std::advance(end, remainder); // We're setting the body promise here to an empty string // because // this can be used as a signaling mechanism for the user to // determine that the body is now ready for processing, even // though the callback is already provided. this->body_promise.set_value(""); // The invocation of the callback is synchronous to allow us // to // wait before scheduling another read. callback(make_iterator_range(begin, end), ec); delegate_->read_some( boost::asio::mutable_buffers_1(this->part.c_array(), this->part.size()), request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), body, get_body, callback, placeholders::error, placeholders::bytes_transferred))); } else { // Here we handle the body data ourself and append to an // ever-growing string buffer. this->parse_body( delegate_, request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), body, get_body, callback, placeholders::error, placeholders::bytes_transferred)), remainder); } return; case body: if (ec == boost::asio::error::eof || is_ssl_short_read_error) { // Here we're handling the case when the connection has been // closed from the server side, or at least that the end of // file // has been reached while reading the socket. This signals // the end // of the body processing chain. if (callback) { typename protocol_base::buffer_type::const_iterator begin = this->part.begin(), end = begin; std::advance(end, bytes_transferred); // We call the callback function synchronously passing the // error // condition (in this case, end of file) so that it can // handle // it appropriately. callback(make_iterator_range(begin, end), ec); } else { string_type body_string; std::swap(body_string, this->partial_parsed); body_string.append(this->part.begin(), bytes_transferred); if (this->is_chunk_encoding) this->body_promise.set_value(parse_chunk_encoding(body_string)); else this->body_promise.set_value(body_string); } // TODO set the destination value somewhere! this->destination_promise.set_value(""); this->source_promise.set_value(""); this->part.assign('\0'); this->response_parser_.reset(); this->timer_.cancel(); } else { // This means the connection has not been closed yet and we // want // to get more // data. if (callback) { // Here we have a body_handler callback. Let's invoke the // callback from here and make sure we're getting more // data // right after. typename protocol_base::buffer_type::const_iterator begin = this->part.begin(); typename protocol_base::buffer_type::const_iterator end = begin; std::advance(end, bytes_transferred); callback(make_iterator_range(begin, end), ec); delegate_->read_some( boost::asio::mutable_buffers_1(this->part.c_array(), this->part.size()), request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), body, get_body, callback, placeholders::error, placeholders::bytes_transferred))); } else { // Here we don't have a body callback. Let's // make sure that we deal with the remainder // from the headers part in case we do have data // that's still in the buffer. this->parse_body( delegate_, request_strand_.wrap(boost::bind( &this_type::handle_received_data, this_type::shared_from_this(), body, get_body, callback, placeholders::error, placeholders::bytes_transferred)), bytes_transferred); } } return; default: BOOST_ASSERT(false && "Bug, report this to the developers!"); } } else { boost::system::system_error error(is_timedout_ ? asio::error::timed_out : ec); this->source_promise.set_exception(boost::copy_exception(error)); this->destination_promise.set_exception(boost::copy_exception(error)); switch (state) { case version: this->version_promise.set_exception(boost::copy_exception(error)); case status: this->status_promise.set_exception(boost::copy_exception(error)); case status_message: this->status_message_promise.set_exception( boost::copy_exception(error)); case headers: this->headers_promise.set_exception(boost::copy_exception(error)); case body: this->body_promise.set_exception(boost::copy_exception(error)); break; default: BOOST_ASSERT(false && "Bug, report this to the developers!"); } } } string_type parse_chunk_encoding(string_type& body_string) { string_type body; string_type crlf = "\r\n"; typename string_type::iterator begin = body_string.begin(); for (typename string_type::iterator iter = std::search(begin, body_string.end(), crlf.begin(), crlf.end()); iter != body_string.end(); iter = std::search(begin, body_string.end(), crlf.begin(), crlf.end())) { string_type line(begin, iter); if (line.empty()) break; std::stringstream stream(line); int len; stream >> std::hex >> len; std::advance(iter, 2); if (!len) break; if (len <= body_string.end() - iter) { body.insert(body.end(), iter, iter + len); std::advance(iter, len + 2); } begin = iter; } return body; } int timeout_; boost::asio::deadline_timer timer_; bool is_timedout_; bool follow_redirect_; resolver_type& resolver_; resolve_function resolve_; boost::asio::io_service::strand request_strand_; connection_delegate_ptr delegate_; boost::asio::streambuf command_streambuf; string_type method; }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_CONNECTION_HPP_20100601 async_protocol_handler.hpp000066400000000000000000000346661240331347200344470ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_PROTOCOL_HANDLER_HPP_ #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_PROTOCOL_HANDLER_HPP_ // Copyright 2010 (C) Dean Michael Berris // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { namespace impl { template struct http_async_protocol_handler { protected: typedef typename string::type string_type; #ifdef BOOST_NETWORK_DEBUG struct debug_escaper { string_type& string; explicit debug_escaper(string_type& string_) : string(string_) {} debug_escaper(debug_escaper const& other) : string(other.string) {} void operator()(typename string_type::value_type input) { if (!algorithm::is_print()(input)) { typename ostringstream::type escaped_stream; if (input == '\r') { string.append("\\r"); } else if (input == '\n') { string.append("\\n"); } else { escaped_stream << "\\x" << static_cast(input); string.append(escaped_stream.str()); } } else { string.push_back(input); } } }; #endif template void init_response(ResponseType& response_, bool get_body) { boost::shared_future source_future( source_promise.get_future()); source(response_, source_future); boost::shared_future destination_future( destination_promise.get_future()); destination(response_, destination_future); boost::shared_future::type> headers_future( headers_promise.get_future()); headers(response_, headers_future); boost::shared_future body_future(body_promise.get_future()); body(response_, body_future); boost::shared_future version_future( version_promise.get_future()); version(response_, version_future); boost::shared_future status_future( status_promise.get_future()); status(response_, status_future); boost::shared_future status_message_future( status_message_promise.get_future()); status_message(response_, status_message_future); } struct to_http_headers { typedef typename string::type string_type; template string_type const operator()(U const& pair) const { typedef typename ostringstream::type ostringstream_type; typedef constants constants; ostringstream_type header_line; header_line << pair.first << constants::colon() << constants::space() << pair.second << constants::crlf(); return header_line.str(); } }; template logic::tribool parse_version(Delegate& delegate_, Callback callback, size_t bytes) { logic::tribool parsed_ok; part_begin = part.begin(); typename buffer_type::const_iterator part_end = part.begin(); std::advance(part_end, bytes); typename boost::iterator_range result_range, input_range = boost::make_iterator_range(part_begin, part_end); fusion::tie(parsed_ok, result_range) = response_parser_.parse_until( response_parser_type::http_version_done, input_range); if (parsed_ok == true) { string_type version; std::swap(version, partial_parsed); version.append(boost::begin(result_range), boost::end(result_range)); algorithm::trim(version); version_promise.set_value(version); part_begin = boost::end(result_range); } else if (parsed_ok == false) { #ifdef BOOST_NETWORK_DEBUG string_type escaped; debug_escaper escaper(escaped); std::for_each(part_begin, part_end, escaper); BOOST_NETWORK_MESSAGE("[parser:" << response_parser_.state() << "] buffer contents: \"" << escaped << "\""); #endif std::runtime_error error("Invalid Version Part."); version_promise.set_exception(boost::copy_exception(error)); status_promise.set_exception(boost::copy_exception(error)); status_message_promise.set_exception(boost::copy_exception(error)); headers_promise.set_exception(boost::copy_exception(error)); source_promise.set_exception(boost::copy_exception(error)); destination_promise.set_exception(boost::copy_exception(error)); body_promise.set_exception(boost::copy_exception(error)); } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); part_begin = part.begin(); delegate_->read_some( boost::asio::mutable_buffers_1(part.c_array(), part.size()), callback); } return parsed_ok; } template logic::tribool parse_status(Delegate& delegate_, Callback callback, size_t bytes) { logic::tribool parsed_ok; typename buffer_type::const_iterator part_end = part.begin(); std::advance(part_end, bytes); typename boost::iterator_range result_range, input_range = boost::make_iterator_range(part_begin, part_end); fusion::tie(parsed_ok, result_range) = response_parser_.parse_until( response_parser_type::http_status_done, input_range); if (parsed_ok == true) { string_type status; std::swap(status, partial_parsed); status.append(boost::begin(result_range), boost::end(result_range)); trim(status); boost::uint16_t status_int = lexical_cast(status); status_promise.set_value(status_int); part_begin = boost::end(result_range); } else if (parsed_ok == false) { #ifdef BOOST_NETWORK_DEBUG string_type escaped; debug_escaper escaper(escaped); std::for_each(part_begin, part_end, escaper); BOOST_NETWORK_MESSAGE("[parser:" << response_parser_.state() << "] buffer contents: \"" << escaped << "\""); #endif std::runtime_error error("Invalid status part."); status_promise.set_exception(boost::copy_exception(error)); status_message_promise.set_exception(boost::copy_exception(error)); headers_promise.set_exception(boost::copy_exception(error)); source_promise.set_exception(boost::copy_exception(error)); destination_promise.set_exception(boost::copy_exception(error)); body_promise.set_exception(boost::copy_exception(error)); } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); part_begin = part.begin(); delegate_->read_some( boost::asio::mutable_buffers_1(part.c_array(), part.size()), callback); } return parsed_ok; } template logic::tribool parse_status_message(Delegate& delegate_, Callback callback, size_t bytes) { logic::tribool parsed_ok; typename buffer_type::const_iterator part_end = part.begin(); std::advance(part_end, bytes); typename boost::iterator_range result_range, input_range = boost::make_iterator_range(part_begin, part_end); fusion::tie(parsed_ok, result_range) = response_parser_.parse_until( response_parser_type::http_status_message_done, input_range); if (parsed_ok == true) { string_type status_message; std::swap(status_message, partial_parsed); status_message.append(boost::begin(result_range), boost::end(result_range)); algorithm::trim(status_message); status_message_promise.set_value(status_message); part_begin = boost::end(result_range); } else if (parsed_ok == false) { #ifdef BOOST_NETWORK_DEBUG string_type escaped; debug_escaper escaper(escaped); std::for_each(part_begin, part_end, escaper); BOOST_NETWORK_MESSAGE("[parser:" << response_parser_.state() << "] buffer contents: \"" << escaped << "\""); #endif std::runtime_error error("Invalid status message part."); status_message_promise.set_exception(boost::copy_exception(error)); headers_promise.set_exception(boost::copy_exception(error)); source_promise.set_exception(boost::copy_exception(error)); destination_promise.set_exception(boost::copy_exception(error)); body_promise.set_exception(boost::copy_exception(error)); } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); part_begin = part.begin(); delegate_->read_some( boost::asio::mutable_buffers_1(part.c_array(), part.size()), callback); } return parsed_ok; } void parse_headers_real(string_type& headers_part) { typename boost::iterator_range input_range = boost::make_iterator_range(headers_part), result_range; logic::tribool parsed_ok; response_parser_type headers_parser( response_parser_type::http_header_line_done); typename headers_container::type headers; std::pair header_pair; while (!boost::empty(input_range)) { fusion::tie(parsed_ok, result_range) = headers_parser.parse_until( response_parser_type::http_header_colon, input_range); if (headers_parser.state() != response_parser_type::http_header_colon) break; header_pair.first = string_type(boost::begin(result_range), boost::end(result_range)); input_range.advance_begin(boost::distance(result_range)); fusion::tie(parsed_ok, result_range) = headers_parser.parse_until( response_parser_type::http_header_line_done, input_range); header_pair.second = string_type(boost::begin(result_range), boost::end(result_range)); input_range.advance_begin(boost::distance(result_range)); trim(header_pair.first); if (header_pair.first.size() > 1) { header_pair.first.erase(header_pair.first.size() - 1); } trim(header_pair.second); headers.insert(header_pair); } // determine if the body parser will need to handle chunked encoding typename headers_range >::type transfer_encoding_range = headers.equal_range("Transfer-Encoding"); is_chunk_encoding = !empty(transfer_encoding_range) && boost::iequals(boost::begin(transfer_encoding_range)->second, "chunked"); headers_promise.set_value(headers); } template fusion::tuple parse_headers(Delegate& delegate_, Callback callback, size_t bytes) { logic::tribool parsed_ok; typename buffer_type::const_iterator part_end = part.begin(); std::advance(part_end, bytes); typename boost::iterator_range result_range, input_range = boost::make_iterator_range(part_begin, part_end); fusion::tie(parsed_ok, result_range) = response_parser_.parse_until( response_parser_type::http_headers_done, input_range); if (parsed_ok == true) { string_type headers_string; std::swap(headers_string, partial_parsed); headers_string.append(boost::begin(result_range), boost::end(result_range)); part_begin = boost::end(result_range); this->parse_headers_real(headers_string); } else if (parsed_ok == false) { // We want to output the contents of the buffer that caused // the error in debug builds. #ifdef BOOST_NETWORK_DEBUG string_type escaped; debug_escaper escaper(escaped); std::for_each(part_begin, part_end, escaper); BOOST_NETWORK_MESSAGE("[parser:" << response_parser_.state() << "] buffer contents: \"" << escaped << "\" consumed length: " << boost::distance(result_range)); #endif std::runtime_error error("Invalid header part."); headers_promise.set_exception(boost::copy_exception(error)); body_promise.set_exception(boost::copy_exception(error)); source_promise.set_exception(boost::copy_exception(error)); destination_promise.set_exception(boost::copy_exception(error)); } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); part_begin = part.begin(); delegate_->read_some( boost::asio::mutable_buffers_1(part.c_array(), part.size()), callback); } return fusion::make_tuple( parsed_ok, std::distance(boost::end(result_range), part_end)); } template void parse_body(Delegate& delegate_, Callback callback, size_t bytes) { // TODO: we should really not use a string for the partial body // buffer. partial_parsed.append(part_begin, bytes); part_begin = part.begin(); delegate_->read_some( boost::asio::mutable_buffers_1(part.c_array(), part.size()), callback); } typedef response_parser response_parser_type; // TODO: make 1024 go away and become a configurable value. typedef boost::array::type, 1024> buffer_type; response_parser_type response_parser_; boost::promise version_promise; boost::promise status_promise; boost::promise status_message_promise; boost::promise::type> headers_promise; boost::promise source_promise; boost::promise destination_promise; boost::promise body_promise; buffer_type part; typename buffer_type::const_iterator part_begin; string_type partial_parsed; bool is_chunk_encoding; }; } /* impl */ } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_PROTOCOL_HANDLER_HPP_20101015 \ */ connection_delegate.hpp000066400000000000000000000022061240331347200336660ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_CONNECTION_DELEGATE_HPP_ #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_CONNECTION_DELEGATE_HPP_ // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { namespace impl { struct connection_delegate { virtual void connect(asio::ip::tcp::endpoint &endpoint, function handler) = 0; virtual void write( asio::streambuf &command_streambuf, function handler) = 0; virtual void read_some( asio::mutable_buffers_1 const &read_buffer, function handler) = 0; virtual void disconnect() = 0; virtual ~connection_delegate() {} }; } /* impl */ } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_CONNECTION_DELEGATE_HPP_ \ */ connection_delegate_factory.hpp000066400000000000000000000042271240331347200354220ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_DELEGATE_FACTORY_HPP_20110819 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_DELEGATE_FACTORY_HPP_20110819 // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #ifdef BOOST_NETWORK_ENABLE_HTTPS #include #endif /* BOOST_NETWORK_ENABLE_HTTPS */ namespace boost { namespace network { namespace http { namespace impl { struct ssl_delegate; struct normal_delegate; template struct connection_delegate_factory { typedef shared_ptr connection_delegate_ptr; typedef typename string::type string_type; // This is the factory method that actually returns the delegate // instance. // TODO Support passing in proxy settings when crafting connections. static connection_delegate_ptr new_connection_delegate( asio::io_service& service, bool https, bool always_verify_peer, optional certificate_filename, optional verify_path, optional certificate_file, optional private_key_file) { connection_delegate_ptr delegate; if (https) { #ifdef BOOST_NETWORK_ENABLE_HTTPS delegate.reset(new ssl_delegate(service, always_verify_peer, certificate_filename, verify_path, certificate_file, private_key_file)); #else BOOST_THROW_EXCEPTION(std::runtime_error("HTTPS not supported.")); #endif /* BOOST_NETWORK_ENABLE_HTTPS */ } else { delegate.reset(new normal_delegate(service)); } return delegate; } }; } /* impl */ } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_DELEGATE_FACTORY_HPP_20110819 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/normal_delegate.hpp000066400000000000000000000032351240331347200331010ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_20110819 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_20110819 // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { namespace impl { struct normal_delegate : connection_delegate { normal_delegate(asio::io_service &service); virtual void connect(asio::ip::tcp::endpoint &endpoint, function handler); virtual void write( asio::streambuf &command_streambuf, function handler); virtual void read_some( asio::mutable_buffers_1 const &read_buffer, function handler); virtual void disconnect(); ~normal_delegate(); private: asio::io_service &service_; scoped_ptr socket_; normal_delegate(normal_delegate const &); // = delete normal_delegate &operator=(normal_delegate); // = delete }; } /* impl */ } /* http */ } /* network */ } /* boost */ #ifdef BOOST_NETWORK_NO_LIB #include #endif /* BOOST_NETWORK_NO_LIB */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_20110819 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/normal_delegate.ipp000066400000000000000000000036331240331347200331040ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_IPP_20110819 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_IPP_20110819 // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include boost::network::http::impl::normal_delegate::normal_delegate( asio::io_service &service) : service_(service) {} void boost::network::http::impl::normal_delegate::connect( asio::ip::tcp::endpoint &endpoint, function handler) { socket_.reset(new asio::ip::tcp::socket(service_)); socket_->async_connect(endpoint, handler); } void boost::network::http::impl::normal_delegate::write( asio::streambuf &command_streambuf, function handler) { asio::async_write(*socket_, command_streambuf, handler); } void boost::network::http::impl::normal_delegate::read_some( asio::mutable_buffers_1 const &read_buffer, function handler) { socket_->async_read_some(read_buffer, handler); } void boost::network::http::impl::normal_delegate::disconnect() { if (socket_.get() && socket_->is_open()) { boost::system::error_code ignored; socket_->shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored); if (!ignored) { socket_->close(ignored); } } } boost::network::http::impl::normal_delegate::~normal_delegate() {} #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_IPP_20110819 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/ssl_delegate.hpp000066400000000000000000000047551240331347200324220ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_20110819 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_20110819 // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { namespace impl { struct ssl_delegate : connection_delegate, enable_shared_from_this { ssl_delegate(asio::io_service &service, bool always_verify_peer, optional certificate_filename, optional verify_path, optional certificate_file, optional private_key_file); virtual void connect(asio::ip::tcp::endpoint &endpoint, function handler); virtual void write( asio::streambuf &command_streambuf, function handler); virtual void read_some( asio::mutable_buffers_1 const &read_buffer, function handler); virtual void disconnect(); ~ssl_delegate(); private: asio::io_service &service_; optional certificate_filename_; optional verify_path_; optional certificate_file_; optional private_key_file_; scoped_ptr context_; scoped_ptr > socket_; bool always_verify_peer_; ssl_delegate(ssl_delegate const &); // = delete ssl_delegate &operator=(ssl_delegate); // = delete void handle_connected(system::error_code const &ec, function handler); }; } /* impl */ } /* http */ } /* network */ } /* boost */ #ifdef BOOST_NETWORK_NO_LIB #include #endif /* BOOST_NETWORK_NO_LIB */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_20110819 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/ssl_delegate.ipp000066400000000000000000000070761240331347200324220ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_IPP_20110819 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_IPP_20110819 // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include boost::network::http::impl::ssl_delegate::ssl_delegate( asio::io_service &service, bool always_verify_peer, optional certificate_filename, optional verify_path, optional certificate_file, optional private_key_file) : service_(service), certificate_filename_(certificate_filename), verify_path_(verify_path), certificate_file_(certificate_file), private_key_file_(private_key_file), always_verify_peer_(always_verify_peer) {} void boost::network::http::impl::ssl_delegate::connect( asio::ip::tcp::endpoint &endpoint, function handler) { context_.reset( new asio::ssl::context(service_, asio::ssl::context::sslv23_client)); if (certificate_filename_ || verify_path_) { context_->set_verify_mode(asio::ssl::context::verify_peer); if (certificate_filename_) context_->load_verify_file(*certificate_filename_); if (verify_path_) context_->add_verify_path(*verify_path_); } else { if (always_verify_peer_) context_->set_verify_mode(asio::ssl::context::verify_peer); else context_->set_verify_mode(asio::ssl::context::verify_none); } if (certificate_file_) context_->use_certificate_file(*certificate_file_, boost::asio::ssl::context::pem); if (private_key_file_) context_->use_private_key_file(*private_key_file_, boost::asio::ssl::context::pem); socket_.reset( new asio::ssl::stream(service_, *context_)); socket_->lowest_layer().async_connect( endpoint, ::boost::bind( &boost::network::http::impl::ssl_delegate::handle_connected, boost::network::http::impl::ssl_delegate::shared_from_this(), asio::placeholders::error, handler)); } void boost::network::http::impl::ssl_delegate::handle_connected( system::error_code const &ec, function handler) { if (!ec) { socket_->async_handshake(asio::ssl::stream_base::client, handler); } else { handler(ec); } } void boost::network::http::impl::ssl_delegate::write( asio::streambuf &command_streambuf, function handler) { asio::async_write(*socket_, command_streambuf, handler); } void boost::network::http::impl::ssl_delegate::read_some( asio::mutable_buffers_1 const &read_buffer, function handler) { socket_->async_read_some(read_buffer, handler); } void boost::network::http::impl::ssl_delegate::disconnect() { if (socket_.get() && socket_->lowest_layer().is_open()) { boost::system::error_code ignored; socket_->lowest_layer().shutdown( boost::asio::ip::tcp::socket::shutdown_both, ignored); if (!ignored) { socket_->lowest_layer().close(ignored); } } } boost::network::http::impl::ssl_delegate::~ssl_delegate() {} #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_IPP_20110819 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/sync_base.hpp000066400000000000000000000300151240331347200317210ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_SYNC_CONNECTION_BASE_20091217 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_SYNC_CONNECTION_BASE_20091217 // Copyright 2013 Google, Inc. // Copyright 2009 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include #ifdef BOOST_NETWORK_ENABLE_HTTPS #include #endif namespace boost { namespace network { namespace http { namespace impl { template struct sync_connection_base_impl { protected: typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef typename string::type string_type; typedef function resolver_function_type; template void init_socket(Socket& socket_, resolver_type& resolver_, string_type const& hostname, string_type const& port, resolver_function_type resolve_) { using boost::asio::ip::tcp; boost::system::error_code error = boost::asio::error::host_not_found; typename resolver_type::iterator endpoint_iterator, end; boost::tie(endpoint_iterator, end) = resolve_(resolver_, hostname, port); while (error && endpoint_iterator != end) { socket_.close(); socket_.connect(tcp::endpoint(endpoint_iterator->endpoint().address(), endpoint_iterator->endpoint().port()), error); ++endpoint_iterator; } if (error) throw boost::system::system_error(error); } template void read_status(Socket& socket_, basic_response& response_, boost::asio::streambuf& response_buffer) { boost::asio::read_until(socket_, response_buffer, "\r\n"); std::istream response_stream(&response_buffer); string_type http_version; unsigned int status_code; string_type status_message; response_stream >> http_version >> status_code; std::getline(response_stream, status_message); trim_left(status_message); trim_right_if(status_message, boost::is_space() || boost::is_any_of("\r")); if (!response_stream || http_version.substr(0, 5) != "HTTP/") throw std::runtime_error("Invalid response"); response_ << http::version(http_version) << http::status(status_code) << http::status_message(status_message); } template void read_headers(Socket& socket_, basic_response& response_, boost::asio::streambuf& response_buffer) { boost::asio::read_until(socket_, response_buffer, "\r\n\r\n"); std::istream response_stream(&response_buffer); string_type header_line, name; while (std::getline(response_stream, header_line) && header_line != "\r") { trim_right_if(header_line, boost::is_space() || boost::is_any_of("\r")); typename string_type::size_type colon_offset; if (header_line.size() && header_line[0] == ' ') { assert(!name.empty()); if (name.empty()) throw std::runtime_error(std::string("Malformed header: ") + header_line); response_ << header(name, trim_left_copy(header_line)); } else if ((colon_offset = header_line.find_first_of(':')) != string_type::npos) { name = header_line.substr(0, colon_offset); response_ << header(name, header_line.substr(colon_offset + 2)); } } } template void send_request_impl(Socket& socket_, string_type const& method, boost::asio::streambuf& request_buffer) { write(socket_, request_buffer); } template void read_body_normal(Socket& socket_, basic_response& response_, boost::asio::streambuf& response_buffer, typename ostringstream::type& body_stream) { boost::system::error_code error; if (response_buffer.size() > 0) body_stream << &response_buffer; while (boost::asio::read(socket_, response_buffer, boost::asio::transfer_at_least(1), error)) { body_stream << &response_buffer; } } template void read_body_transfer_chunk_encoding( Socket& socket_, basic_response& response_, boost::asio::streambuf& response_buffer, typename ostringstream::type& body_stream) { boost::system::error_code error; // look for the content-length header typename headers_range >::type content_length_range = headers(response_)["Content-Length"]; if (empty(content_length_range)) { typename headers_range >::type transfer_encoding_range = headers(response_)["Transfer-Encoding"]; if (empty(transfer_encoding_range)) { read_body_normal(socket_, response_, response_buffer, body_stream); return; } if (boost::iequals(boost::begin(transfer_encoding_range)->second, "chunked")) { bool stopping = false; do { std::size_t chunk_size_line = read_until(socket_, response_buffer, "\r\n", error); if ((chunk_size_line == 0) && (error != boost::asio::error::eof)) throw boost::system::system_error(error); std::size_t chunk_size = 0; string_type data; { std::istream chunk_stream(&response_buffer); std::getline(chunk_stream, data); typename istringstream::type chunk_size_stream(data); chunk_size_stream >> std::hex >> chunk_size; } if (chunk_size == 0) { stopping = true; if (!read_until(socket_, response_buffer, "\r\n", error) && (error != boost::asio::error::eof)) throw boost::system::system_error(error); } else { bool stopping_inner = false; do { if (response_buffer.size() < (chunk_size + 2)) { std::size_t bytes_to_read = (chunk_size + 2) - response_buffer.size(); std::size_t chunk_bytes_read = read(socket_, response_buffer, boost::asio::transfer_at_least(bytes_to_read), error); if (chunk_bytes_read == 0) { if (error != boost::asio::error::eof) throw boost::system::system_error(error); stopping_inner = true; } } std::istreambuf_iterator eos; std::istreambuf_iterator stream_iterator(&response_buffer); for (; chunk_size > 0 && stream_iterator != eos; --chunk_size) body_stream << *stream_iterator++; response_buffer.consume(2); } while (!stopping_inner && chunk_size != 0); if (chunk_size != 0) throw std::runtime_error( "Size mismatch between tranfer encoding chunk data " "size and declared chunk size."); } } while (!stopping); } else throw std::runtime_error("Unsupported Transfer-Encoding."); } else { size_t already_read = response_buffer.size(); if (already_read) body_stream << &response_buffer; size_t length = lexical_cast(boost::begin(content_length_range)->second) - already_read; if (length == 0) return; size_t bytes_read = 0; while ((bytes_read = boost::asio::read(socket_, response_buffer, boost::asio::transfer_at_least(1), error))) { body_stream << &response_buffer; length -= bytes_read; if ((length <= 0) || error) break; } } } template void read_body(Socket& socket_, basic_response& response_, boost::asio::streambuf& response_buffer) { typename ostringstream::type body_stream; // TODO tag dispatch based on whether it's HTTP 1.0 or HTTP 1.1 if (version_major == 1 && version_minor == 0) { read_body_normal(socket_, response_, response_buffer, body_stream); } else if (version_major == 1 && version_minor == 1) { if (response_.version() == "HTTP/1.0") read_body_normal(socket_, response_, response_buffer, body_stream); else read_body_transfer_chunk_encoding(socket_, response_, response_buffer, body_stream); } else { throw std::runtime_error("Unsupported HTTP version number."); } response_ << network::body(body_stream.str()); } }; template struct sync_connection_base { typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef typename string::type string_type; typedef function resolver_function_type; typedef function body_generator_function_type; // FIXME make the certificate filename and verify path parameters be // optional // ranges static sync_connection_base* new_connection( resolver_type& resolver, resolver_function_type resolve, bool https, bool always_verify_peer, int timeout, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) { if (https) { #ifdef BOOST_NETWORK_ENABLE_HTTPS return dynamic_cast< sync_connection_base*>( new https_sync_connection( resolver, resolve, always_verify_peer, timeout, certificate_filename, verify_path, certificate_file, private_key_file)); #else throw std::runtime_error("HTTPS not supported."); #endif } return dynamic_cast< sync_connection_base*>( new http_sync_connection( resolver, resolve, timeout)); } virtual void init_socket(string_type const& hostname, string_type const& port) = 0; virtual void send_request_impl(string_type const& method, basic_request const& request_, body_generator_function_type generator) = 0; virtual void read_status(basic_response& response_, boost::asio::streambuf& response_buffer) = 0; virtual void read_headers(basic_response& response_, boost::asio::streambuf& response_buffer) = 0; virtual void read_body(basic_response& response_, boost::asio::streambuf& response_buffer) = 0; virtual bool is_open() = 0; virtual void close_socket() = 0; virtual ~sync_connection_base() {} protected: sync_connection_base() {} }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_SYNC_CONNECTION_BASE_20091217 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/sync_normal.hpp000066400000000000000000000115441240331347200323050ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_SYNC_CONNECTION_20100601 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_SYNC_CONNECTION_20100601 // Copyright 2013 Google, Inc. // Copyright 2010 (C) Dean Michael Berris // Copyright 2010 (C) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { namespace impl { template struct sync_connection_base_impl; template struct sync_connection_base; template struct http_sync_connection : public virtual sync_connection_base, sync_connection_base_impl, boost::enable_shared_from_this< http_sync_connection > { typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef typename string::type string_type; typedef function resolver_function_type; typedef http_sync_connection this_type; typedef sync_connection_base_impl connection_base; typedef function body_generator_function_type; http_sync_connection(resolver_type& resolver, resolver_function_type resolve, int timeout) : connection_base(), timeout_(timeout), timer_(resolver.get_io_service()), resolver_(resolver), resolve_(resolve), socket_(resolver.get_io_service()) {} void init_socket(string_type const& hostname, string_type const& port) { connection_base::init_socket(socket_, resolver_, hostname, port, resolve_); } void send_request_impl(string_type const& method, basic_request const& request_, body_generator_function_type generator) { boost::asio::streambuf request_buffer; linearize( request_, method, version_major, version_minor, std::ostreambuf_iterator::type>(&request_buffer)); connection_base::send_request_impl(socket_, method, request_buffer); if (generator) { string_type chunk; while (generator(chunk)) { std::copy(chunk.begin(), chunk.end(), std::ostreambuf_iterator::type>( &request_buffer)); chunk.clear(); connection_base::send_request_impl(socket_, method, request_buffer); } } if (timeout_ > 0) { timer_.expires_from_now(boost::posix_time::seconds(timeout_)); timer_.async_wait(boost::bind(&this_type::handle_timeout, this_type::shared_from_this(), boost::arg<1>())); } } void read_status(basic_response& response_, boost::asio::streambuf& response_buffer) { connection_base::read_status(socket_, response_, response_buffer); } void read_headers(basic_response& response, boost::asio::streambuf& response_buffer) { connection_base::read_headers(socket_, response, response_buffer); } void read_body(basic_response& response_, boost::asio::streambuf& response_buffer) { connection_base::read_body(socket_, response_, response_buffer); typename headers_range >::type connection_range = headers(response_)["Connection"]; if (version_major == 1 && version_minor == 1 && !empty(connection_range) && boost::iequals(boost::begin(connection_range)->second, "close")) { close_socket(); } else if (version_major == 1 && version_minor == 0) { close_socket(); } } bool is_open() { return socket_.is_open(); } void close_socket() { timer_.cancel(); if (!is_open()) return; boost::system::error_code ignored; socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored); if (ignored) return; socket_.close(ignored); } private: void handle_timeout(boost::system::error_code const& ec) { if (!ec) close_socket(); } int timeout_; boost::asio::deadline_timer timer_; resolver_type& resolver_; resolver_function_type resolve_; boost::asio::ip::tcp::socket socket_; }; } // namespace impl } // nmaespace http } // namespace network } // nmaespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_SYNC_CONNECTION_20100 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/connection/sync_ssl.hpp000066400000000000000000000155531240331347200316220ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTPS_SYNC_CONNECTION_HTTP_20100601 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTPS_SYNC_CONNECTION_HTTP_20100601 // Copyright 2013 Google, Inc. // Copyright 2010 (C) Dean Michael Berris // Copyright 2010 (C) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { namespace impl { template struct sync_connection_base_impl; template struct sync_connection_base; template struct https_sync_connection : public virtual sync_connection_base, sync_connection_base_impl, boost::enable_shared_from_this< https_sync_connection > { typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef typename string::type string_type; typedef function resolver_function_type; typedef https_sync_connection this_type; typedef sync_connection_base_impl connection_base; typedef function body_generator_function_type; // FIXME make the certificate filename and verify path parameters be // optional ranges https_sync_connection( resolver_type& resolver, resolver_function_type resolve, bool always_verify_peer, int timeout, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) : connection_base(), timeout_(timeout), timer_(resolver.get_io_service()), resolver_(resolver), resolve_(resolve), context_(resolver.get_io_service(), boost::asio::ssl::context::sslv23_client), socket_(resolver.get_io_service(), context_) { if (certificate_filename || verify_path) { context_.set_verify_mode(boost::asio::ssl::context::verify_peer); // FIXME make the certificate filename and verify path parameters // be // optional ranges if (certificate_filename) context_.load_verify_file(*certificate_filename); if (verify_path) context_.add_verify_path(*verify_path); } else { if (always_verify_peer) context_.set_verify_mode(boost::asio::ssl::context_base::verify_peer); else context_.set_verify_mode(boost::asio::ssl::context_base::verify_none); } if (certificate_file) context_.use_certificate_file(*certificate_file, boost::asio::ssl::context::pem); if (private_key_file) context_.use_private_key_file(*private_key_file, boost::asio::ssl::context::pem); } void init_socket(string_type const& hostname, string_type const& port) { connection_base::init_socket(socket_.lowest_layer(), resolver_, hostname, port, resolve_); socket_.handshake(boost::asio::ssl::stream_base::client); } void send_request_impl(string_type const& method, basic_request const& request_, body_generator_function_type generator) { boost::asio::streambuf request_buffer; linearize( request_, method, version_major, version_minor, std::ostreambuf_iterator::type>(&request_buffer)); connection_base::send_request_impl(socket_, method, request_buffer); if (generator) { string_type chunk; while (generator(chunk)) { std::copy(chunk.begin(), chunk.end(), std::ostreambuf_iterator::type>( &request_buffer)); chunk.clear(); connection_base::send_request_impl(socket_, method, request_buffer); } } if (timeout_ > 0) { timer_.expires_from_now(boost::posix_time::seconds(timeout_)); timer_.async_wait(boost::bind(&this_type::handle_timeout, this_type::shared_from_this(), boost::arg<1>())); } } void read_status(basic_response& response_, boost::asio::streambuf& response_buffer) { connection_base::read_status(socket_, response_, response_buffer); } void read_headers(basic_response& response_, boost::asio::streambuf& response_buffer) { connection_base::read_headers(socket_, response_, response_buffer); } void read_body(basic_response& response_, boost::asio::streambuf& response_buffer) { connection_base::read_body(socket_, response_, response_buffer); typename headers_range >::type connection_range = headers(response_)["Connection"]; if (version_major == 1 && version_minor == 1 && !empty(connection_range) && boost::iequals(boost::begin(connection_range)->second, "close")) { close_socket(); } else if (version_major == 1 && version_minor == 0) { close_socket(); } } bool is_open() { return socket_.lowest_layer().is_open(); } void close_socket() { timer_.cancel(); boost::system::error_code ignored; socket_.lowest_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored); if (ignored) return; socket_.lowest_layer().close(ignored); } ~https_sync_connection() { close_socket(); } private: void handle_timeout(boost::system::error_code const& ec) { if (!ec) close_socket(); } int timeout_; boost::asio::deadline_timer timer_; resolver_type& resolver_; resolver_function_type resolve_; boost::asio::ssl::context context_; boost::asio::ssl::stream socket_; }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTPS_SYNC_CONNECTION_HTTP_20100601 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/facade.hpp000066400000000000000000000155631240331347200270320ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_FACADE_HPP_20100623 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_FACADE_HPP_20100623 // Copyright 2013 Google, Inc. // Copyright 2010 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; template struct basic_response; template struct basic_client_facade { typedef typename string::type string_type; typedef basic_request request; typedef basic_response response; typedef basic_client_impl pimpl_type; typedef function const&, system::error_code const&)> body_callback_function_type; typedef function body_generator_function_type; explicit basic_client_facade(client_options const& options) { init_pimpl(options); } ~basic_client_facade() { pimpl->wait_complete(); } response head(request const& request) { return pimpl->request_skeleton(request, "HEAD", false, body_callback_function_type(), body_generator_function_type()); } response get(request const& request, body_callback_function_type body_handler = body_callback_function_type()) { return pimpl->request_skeleton(request, "GET", true, body_handler, body_generator_function_type()); } response post(request request, string_type const& body = string_type(), string_type const& content_type = string_type(), body_callback_function_type body_handler = body_callback_function_type(), body_generator_function_type body_generator = body_generator_function_type()) { if (body != string_type()) { request << remove_header("Content-Length") << header("Content-Length", boost::lexical_cast(body.size())) << boost::network::body(body); } typename headers_range >::type content_type_headers = headers(request)["Content-Type"]; if (content_type != string_type()) { if (!boost::empty(content_type_headers)) request << remove_header("Content-Type"); request << header("Content-Type", content_type); } else { if (boost::empty(content_type_headers)) { typedef typename char_::type char_type; static char_type content_type[] = "x-application/octet-stream"; request << header("Content-Type", content_type); } } return pimpl->request_skeleton(request, "POST", true, body_handler, body_generator); } response post(request const& request, body_generator_function_type body_generator, body_callback_function_type callback = body_generator_function_type()) { return pimpl->request_skeleton(request, "POST", true, callback, body_generator); } response post(request const& request, body_callback_function_type callback, body_generator_function_type body_generator = body_generator_function_type()) { return post(request, string_type(), string_type(), callback, body_generator); } response post(request const& request, string_type const& body, body_callback_function_type callback, body_generator_function_type body_generator = body_generator_function_type()) { return post(request, body, string_type(), callback, body_generator); } response put(request request, string_type const& body = string_type(), string_type const& content_type = string_type(), body_callback_function_type body_handler = body_callback_function_type(), body_generator_function_type body_generator = body_generator_function_type()) { if (body != string_type()) { request << remove_header("Content-Length") << header("Content-Length", boost::lexical_cast(body.size())) << boost::network::body(body); } typename headers_range >::type content_type_headers = headers(request)["Content-Type"]; if (content_type != string_type()) { if (!boost::empty(content_type_headers)) request << remove_header("Content-Type"); request << header("Content-Type", content_type); } else { if (boost::empty(content_type_headers)) { typedef typename char_::type char_type; static char_type content_type[] = "x-application/octet-stream"; request << header("Content-Type", content_type); } } return pimpl->request_skeleton(request, "PUT", true, body_handler, body_generator); } response put(request const& request, body_callback_function_type callback, body_generator_function_type body_generator = body_generator_function_type()) { return put(request, string_type(), string_type(), callback, body_generator); } response put(request const& request, string_type body, body_callback_function_type callback, body_generator_function_type body_generator = body_generator_function_type()) { return put(request, body, string_type(), callback, body_generator); } response delete_(request const& request, body_callback_function_type body_handler = body_callback_function_type()) { return pimpl->request_skeleton(request, "DELETE", true, body_handler, body_generator_function_type()); } void clear_resolved_cache() { pimpl->clear_resolved_cache(); } protected: boost::shared_ptr pimpl; void init_pimpl(client_options const& options) { pimpl.reset(new pimpl_type( options.cache_resolved(), options.follow_redirects(), options.always_verify_peer(), options.openssl_certificate(), options.openssl_verify_path(), options.openssl_certificate_file(), options.openssl_private_key_file(), options.io_service(), options.timeout())); } }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_FACADE_HPP_20100623 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/macros.hpp000066400000000000000000000015141240331347200271020ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_MACROS_HPP_20110430 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_MACROS_HPP_20110430 // Copyright 2011 Dean Michael Berris . // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #ifndef BOOST_NETWORK_HTTP_BODY_CALLBACK #define BOOST_NETWORK_HTTP_BODY_CALLBACK(function_name, range_name, \ error_name) \ void function_name(boost::iterator_range const& range_name, \ boost::system::error_code const& error_name) #endif #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_MACROS_HPP_20110430 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/options.hpp000066400000000000000000000104601240331347200273110ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_OPTIONS_HPP_20130128 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_OPTIONS_HPP_20130128 #include #include #include #include // Copyright 2013 Google, Inc. // Copyright 2013 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct client_options { typedef typename string::type string_type; client_options() : cache_resolved_(false), follow_redirects_(false), openssl_certificate_(), openssl_verify_path_(), openssl_certificate_file_(), openssl_private_key_file_(), io_service_(), always_verify_peer_(false), timeout_(0) {} client_options(client_options const& other) : cache_resolved_(other.cache_resolved_), follow_redirects_(other.follow_redirects_), openssl_certificate_(other.openssl_certificate_), openssl_verify_path_(other.openssl_verify_path_), openssl_certificate_file_(other.openssl_certificate_file_), openssl_private_key_file_(other.openssl_private_key_file_), io_service_(other.io_service_), always_verify_peer_(other.always_verify_peer_), timeout_(other.timeout_) {} client_options& operator=(client_options other) { other.swap(*this); return *this; } void swap(client_options& other) { using std::swap; swap(cache_resolved_, other.cache_resolved_); swap(follow_redirects_, other.follow_redirects_); swap(openssl_certificate_, other.openssl_certificate_); swap(openssl_verify_path_, other.openssl_verify_path_); swap(openssl_certificate_file_, other.openssl_certificate_file_); swap(openssl_private_key_file_, other.openssl_private_key_file_); swap(io_service_, other.io_service_); swap(always_verify_peer_, other.always_verify_peer_); swap(timeout_, other.timeout_); } client_options& cache_resolved(bool v) { cache_resolved_ = v; return *this; } client_options& follow_redirects(bool v) { follow_redirects_ = v; return *this; } client_options& openssl_certificate(string_type const& v) { openssl_certificate_ = v; return *this; } client_options& openssl_verify_path(string_type const& v) { openssl_verify_path_ = v; return *this; } client_options& openssl_certificate_file(string_type const& v) { openssl_certificate_file_ = v; return *this; } client_options& openssl_private_key_file(string_type const& v) { openssl_private_key_file_ = v; return *this; } client_options& io_service(boost::shared_ptr v) { io_service_ = v; return *this; } client_options& timeout(int v) { timeout_ = v; return *this; } bool cache_resolved() const { return cache_resolved_; } bool follow_redirects() const { return follow_redirects_; } boost::optional openssl_certificate() const { return openssl_certificate_; } boost::optional openssl_verify_path() const { return openssl_verify_path_; } boost::optional openssl_certificate_file() const { return openssl_certificate_file_; } boost::optional openssl_private_key_file() const { return openssl_private_key_file_; } boost::shared_ptr io_service() const { return io_service_; } bool always_verify_peer() const { return always_verify_peer_; } int timeout() const { return timeout_; } private: bool cache_resolved_; bool follow_redirects_; boost::optional openssl_certificate_; boost::optional openssl_verify_path_; boost::optional openssl_certificate_file_; boost::optional openssl_private_key_file_; boost::shared_ptr io_service_; bool always_verify_peer_; int timeout_; }; template inline void swap(client_options& a, client_options& b) { a.swap(b); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_OPTIONS_HPP_20130128 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/pimpl.hpp000066400000000000000000000060421240331347200267400ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_PIMPL_HPP_20100623 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_PIMPL_HPP_20100623 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_client_impl; namespace impl { template struct async_client; template struct sync_client; template struct client_base { typedef unsupported_tag type; }; template struct client_base >::type> { typedef async_client type; }; template struct client_base >::type> { typedef sync_client type; }; } // namespace impl template struct basic_client; template struct basic_client_impl : impl::client_base::type { BOOST_STATIC_ASSERT( (mpl::not_, is_sync > >::value)); typedef typename impl::client_base::type base_type; typedef typename base_type::string_type string_type; basic_client_impl(bool cache_resolved, bool follow_redirect, bool always_verify_peer, optional const& certificate_filename, optional const& verify_path, optional const& certificate_file, optional const& private_key_file, boost::shared_ptr service, int timeout) : base_type(cache_resolved, follow_redirect, always_verify_peer, timeout, service, certificate_filename, verify_path, certificate_file, private_key_file) {} ~basic_client_impl() {} }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_PIMPL_HPP_20100623 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/client/sync_impl.hpp000066400000000000000000000073731240331347200276240ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_SYNC_IMPL_HPP_20100623 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_SYNC_IMPL_HPP_20100623 #include #include #include #include #include #include #include #include #include // Copyright 2013 Google, Inc. // Copyright 2010 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_client_impl; namespace impl { template struct sync_client : connection_policy::type { typedef typename string::type string_type; typedef typename connection_policy::type connection_base; typedef typename resolver::type resolver_type; typedef function const&, system::error_code const&)> body_callback_function_type; typedef function body_generator_function_type; friend struct basic_client_impl; boost::shared_ptr service_ptr; boost::asio::io_service& service_; resolver_type resolver_; optional certificate_filename_; optional verify_path_; optional certificate_file_; optional private_key_file_; bool always_verify_peer_; sync_client( bool cache_resolved, bool follow_redirect, bool always_verify_peer, int timeout, boost::shared_ptr service, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) : connection_base(cache_resolved, follow_redirect, timeout), service_ptr(service.get() ? service : make_shared()), service_(*service_ptr), resolver_(service_), certificate_filename_(certificate_filename), verify_path_(verify_path), certificate_file_(certificate_file), private_key_file_(private_key_file), always_verify_peer_(always_verify_peer) {} ~sync_client() { connection_base::cleanup(); service_ptr.reset(); } void wait_complete() {} basic_response request_skeleton(basic_request const& request_, string_type method, bool get_body, body_callback_function_type callback, body_generator_function_type generator) { typename connection_base::connection_ptr connection_; connection_ = connection_base::get_connection( resolver_, request_, always_verify_peer_, certificate_filename_, verify_path_, certificate_file_, private_key_file_); return connection_->send_request(method, request_, get_body, callback, generator); } }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_SYNC_IMPL_HPP_20100623 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/errors.hpp000066400000000000000000000014461240331347200256600ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007, 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_PROTOCOL_HTTP_ERRORS_20080516_HPP__ #define __NETWORK_PROTOCOL_HTTP_ERRORS_20080516_HPP__ #include #include namespace boost { namespace network { namespace http { namespace errors { template struct connection_timeout_exception : std::runtime_error {}; typedef connection_timeout_exception<> connection_timeout; } // namespace errors } // namespace http } // namespace network } // namespace boost #endif // __NETWORK_PROTOCOL_HTTP_20080516_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/impl/000077500000000000000000000000001240331347200245675ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/impl/message.ipp000066400000000000000000000230431240331347200267270ustar00rootroot00000000000000// This file is part of the Boost Network library // Based on the Pion Network Library (r421) // Copyright Atomic Labs, Inc. 2007-2008 // See http://cpp-netlib.sourceforge.net for library home page. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_IPP #include #include #include #include namespace boost { namespace network { namespace http { // static member functions of boost::network::http::message template typename message_impl::string_type const message_impl::url_decode( typename message_impl::string_type const &str) { char decode_buf[3]; typename message_impl::string_type result; result.reserve(str.size()); for (typename message_impl::string_type::size_type pos = 0; pos < str.size(); ++pos) { switch (str[pos]) { case '+': // convert to space character result += ' '; break; case '%': // decode hexidecimal value if (pos + 2 < str.size()) { decode_buf[0] = str[++pos]; decode_buf[1] = str[++pos]; decode_buf[2] = '\0'; result += static_cast(strtol(decode_buf, 0, 16)); } else { // recover from error by not decoding character result += '%'; } break; default: // character does not need to be escaped result += str[pos]; } }; return result; } template typename message_impl::string_type const message_impl::url_encode( typename message_impl::string_type const &str) { char encode_buf[4]; typename message_impl::string_type result; encode_buf[0] = '%'; result.reserve(str.size()); // character selection for this algorithm is based on the following url: // http://www.blooberry.com/indexdot/html/topics/urlencoding.htm for (typename message_impl::string_type::size_type pos = 0; pos < str.size(); ++pos) { switch (str[pos]) { default: if (str[pos] >= 32 && str[pos] < 127) { // character does not need to be escaped result += str[pos]; break; } // else pass through to next case case '$': case '&': case '+': case ',': case '/': case ':': case ';': case '=': case '?': case '@': case '"': case '<': case '>': case '#': case '%': case '{': case '}': case '|': case '\\': case '^': case '~': case '[': case ']': case '`': // the character needs to be encoded sprintf(encode_buf + 1, "%02X", str[pos]); result += encode_buf; break; } }; return result; } template typename message_impl::string_type const message_impl::make_query_string( typename query_container::type const &query_params) { typename message_impl::string_type query_string; for (typename query_container::type::const_iterator i = query_params.begin(); i != query_params.end(); ++i) { if (i != query_params.begin()) query_string += '&'; query_string += url_encode(i->first); query_string += '='; query_string += url_encode(i->second); } return query_string; } template typename message_impl::string_type const message_impl::make_set_cookie_header( typename message_impl::string_type const &name, typename message_impl::string_type const &value, typename message_impl::string_type const &path, bool const has_max_age, unsigned long const max_age) { typename message_impl::string_type set_cookie_header(name); set_cookie_header += "=\""; set_cookie_header += value; set_cookie_header += "\"; Version=\"1\""; if (!path.empty()) { set_cookie_header += "; Path=\""; set_cookie_header += path; set_cookie_header += '\"'; } if (has_max_age) { set_cookie_header += "; Max-Age=\""; set_cookie_header += boost::lexical_cast::string_type>(max_age); set_cookie_header += '\"'; } return set_cookie_header; } template bool message_impl::base64_decode( const typename message_impl::string_type &input, typename message_impl::string_type &output) { static const char nop = -1; static const char decoding_data[] = { nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, 62, nop, nop, nop, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, nop, nop, nop, nop, nop, nop, nop, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, nop, nop, nop, nop, nop, nop, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop, nop}; unsigned int input_length = input.size(); const char *input_ptr = input.data(); // allocate space for output string output.clear(); output.reserve(((input_length + 2) / 3) * 4); // for each 4-bytes sequence from the input, extract 4 6-bits sequences // by droping first two bits // and regenerate into 3 8-bits sequence for (unsigned int i = 0; i < input_length; i++) { char base64code0; char base64code1; char base64code2 = 0; // initialized to 0 to suppress warnings char base64code3; base64code0 = decoding_data[static_cast(input_ptr[i])]; if (base64code0 == nop) // non base64 character return false; if (!(++i < input_length)) // we need at least two input bytes for // first byte output return false; base64code1 = decoding_data[static_cast(input_ptr[i])]; if (base64code1 == nop) // non base64 character return false; output += ((base64code0 << 2) | ((base64code1 >> 4) & 0x3)); if (++i < input_length) { char c = input_ptr[i]; if (c == '=') { // padding , end of input BOOST_ASSERT((base64code1 & 0x0f) == 0); return true; } base64code2 = decoding_data[static_cast(input_ptr[i])]; if (base64code2 == nop) // non base64 character return false; output += ((base64code1 << 4) & 0xf0) | ((base64code2 >> 2) & 0x0f); } if (++i < input_length) { char c = input_ptr[i]; if (c == '=') { // padding , end of input BOOST_ASSERT((base64code2 & 0x03) == 0); return true; } base64code3 = decoding_data[static_cast(input_ptr[i])]; if (base64code3 == nop) // non base64 character return false; output += (((base64code2 << 6) & 0xc0) | base64code3); } } return true; } template bool message_impl::base64_encode( typename message_impl::string_type const &input, typename message_impl::string_type &output) { static const char encoding_data[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; unsigned int input_length = input.size(); const char *input_ptr = input.data(); // allocate space for output string output.clear(); output.reserve(((input_length + 2) / 3) * 4); // for each 3-bytes sequence from the input, extract 4 6-bits sequences // and encode using // encoding_data lookup table. // if input do not contains enough chars to complete 3-byte sequence,use // pad char '=' for (unsigned int i = 0; i < input_length; i++) { int base64code0 = 0; int base64code1 = 0; int base64code2 = 0; int base64code3 = 0; base64code0 = (input_ptr[i] >> 2) & 0x3f; // 1-byte 6 bits output += encoding_data[base64code0]; base64code1 = (input_ptr[i] << 4) & 0x3f; // 1-byte 2 bits + if (++i < input_length) { base64code1 |= (input_ptr[i] >> 4) & 0x0f; // 2-byte 4 bits output += encoding_data[base64code1]; base64code2 = (input_ptr[i] << 2) & 0x3f; // 2-byte 4 bits + if (++i < input_length) { base64code2 |= (input_ptr[i] >> 6) & 0x03; // 3-byte 2 bits base64code3 = input_ptr[i] & 0x3f; // 3-byte 6 bits output += encoding_data[base64code2]; output += encoding_data[base64code3]; } else { output += encoding_data[base64code2]; output += '='; } } else { output += encoding_data[base64code1]; output += '='; output += '='; } } return true; } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/impl/parser.ipp000066400000000000000000000711141240331347200266010ustar00rootroot00000000000000// This file is part of the Boost Network library // Based on the Pion Network Library (r421) // Copyright Atomic Labs, Inc. 2007-2008 // See http://cpp-netlib.sourceforge.net for library home page. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_IPP #include namespace boost { namespace network { namespace http { // member functions for class basic_parser template boost::tribool basic_parser::parse_http_headers( basic_message& http_msg) { // // note that boost::tribool may have one of THREE states: // // false: encountered an error while parsing HTTP headers // true: finished successfully parsing the HTTP headers // indeterminate: parsed bytes, but the HTTP headers are not yet // finished // const char* read_start_ptr = m_read_ptr; m_bytes_last_read = 0; while (m_read_ptr < m_read_end_ptr) { switch (m_headers_parse_state) { case PARSE_METHOD_START: // we have not yet started parsing the HTTP method string if (*m_read_ptr != ' ' && *m_read_ptr != '\r' && *m_read_ptr != '\n') { // ignore leading whitespace if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) return false; m_headers_parse_state = PARSE_METHOD; m_method.erase(); m_method.push_back(*m_read_ptr); } break; case PARSE_METHOD: // we have started parsing the HTTP method string if (*m_read_ptr == ' ') { m_resource.erase(); m_headers_parse_state = PARSE_URI_STEM; } else if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) { return false; } else if (m_method.size() >= ParserTraits::METHOD_MAX) { return false; } else { m_method.push_back(*m_read_ptr); } break; case PARSE_URI_STEM: // we have started parsing the URI stem (or resource name) if (*m_read_ptr == ' ') { m_headers_parse_state = PARSE_HTTP_VERSION_H; } else if (*m_read_ptr == '?') { m_query_string.erase(); m_headers_parse_state = PARSE_URI_QUERY; } else if (is_control(*m_read_ptr)) { return false; } else if (m_resource.size() >= ParserTraits::RESOURCE_MAX) { return false; } else { m_resource.push_back(*m_read_ptr); } break; case PARSE_URI_QUERY: // we have started parsing the URI query string if (*m_read_ptr == ' ') { m_headers_parse_state = PARSE_HTTP_VERSION_H; } else if (is_control(*m_read_ptr)) { return false; } else if (m_query_string.size() >= ParserTraits::QUERY_STRING_MAX) { return false; } else { m_query_string.push_back(*m_read_ptr); } break; case PARSE_HTTP_VERSION_H: // parsing "HTTP" if (*m_read_ptr != 'H') return false; m_headers_parse_state = PARSE_HTTP_VERSION_T_1; break; case PARSE_HTTP_VERSION_T_1: // parsing "HTTP" if (*m_read_ptr != 'T') return false; m_headers_parse_state = PARSE_HTTP_VERSION_T_2; break; case PARSE_HTTP_VERSION_T_2: // parsing "HTTP" if (*m_read_ptr != 'T') return false; m_headers_parse_state = PARSE_HTTP_VERSION_P; break; case PARSE_HTTP_VERSION_P: // parsing "HTTP" if (*m_read_ptr != 'P') return false; m_headers_parse_state = PARSE_HTTP_VERSION_SLASH; break; case PARSE_HTTP_VERSION_SLASH: // parsing slash after "HTTP" if (*m_read_ptr != '/') return false; m_headers_parse_state = PARSE_HTTP_VERSION_MAJOR_START; break; case PARSE_HTTP_VERSION_MAJOR_START: // parsing the first digit of the major version number if (!is_digit(*m_read_ptr)) return false; http_msg.setVersionMajor(*m_read_ptr - '0'); m_headers_parse_state = PARSE_HTTP_VERSION_MAJOR; break; case PARSE_HTTP_VERSION_MAJOR: // parsing the major version number (not first digit) if (*m_read_ptr == '.') { m_headers_parse_state = PARSE_HTTP_VERSION_MINOR_START; } else if (is_digit(*m_read_ptr)) { http_msg.setVersionMajor((http_msg.getVersionMajor() * 10) + (*m_read_ptr - '0')); } else { return false; } break; case PARSE_HTTP_VERSION_MINOR_START: // parsing the first digit of the minor version number if (!is_digit(*m_read_ptr)) return false; http_msg.setVersionMinor(*m_read_ptr - '0'); m_headers_parse_state = PARSE_HTTP_VERSION_MINOR; break; case PARSE_HTTP_VERSION_MINOR: // parsing the major version number (not first digit) if (*m_read_ptr == ' ') { // should only happen for responses if (m_is_request) return false; m_headers_parse_state = PARSE_STATUS_CODE_START; } else if (*m_read_ptr == '\r') { // should only happen for requests if (!m_is_request) return false; m_headers_parse_state = PARSE_EXPECTING_NEWLINE; } else if (*m_read_ptr == '\n') { // should only happen for requests if (!m_is_request) return false; m_headers_parse_state = PARSE_EXPECTING_CR; } else if (is_digit(*m_read_ptr)) { http_msg.setVersionMinor((http_msg.getVersionMinor() * 10) + (*m_read_ptr - '0')); } else { return false; } break; case PARSE_STATUS_CODE_START: // parsing the first digit of the response status code if (!is_digit(*m_read_ptr)) return false; m_status_code = (*m_read_ptr - '0'); m_headers_parse_state = PARSE_STATUS_CODE; break; case PARSE_STATUS_CODE: // parsing the response status code (not first digit) if (*m_read_ptr == ' ') { m_status_message.erase(); m_headers_parse_state = PARSE_STATUS_MESSAGE; } else if (is_digit(*m_read_ptr)) { m_status_code = ((m_status_code * 10) + (*m_read_ptr - '0')); } else { return false; } break; case PARSE_STATUS_MESSAGE: // parsing the response status message if (*m_read_ptr == '\r') { m_headers_parse_state = PARSE_EXPECTING_NEWLINE; } else if (*m_read_ptr == '\n') { m_headers_parse_state = PARSE_EXPECTING_CR; } else if (is_control(*m_read_ptr)) { return false; } else if (m_status_message.size() >= ParserTraits::STATUS_MESSAGE_MAX) { return false; } else { m_status_message.push_back(*m_read_ptr); } break; case PARSE_EXPECTING_NEWLINE: // we received a CR; expecting a newline to follow if (*m_read_ptr == '\n') { m_headers_parse_state = PARSE_HEADER_START; } else if (*m_read_ptr == '\r') { // we received two CR's in a row // assume CR only is (incorrectly) being used for line // termination // therefore, the message is finished ++m_read_ptr; m_bytes_last_read = (m_read_ptr - read_start_ptr); m_bytes_total_read += m_bytes_last_read; return true; } else if (*m_read_ptr == '\t' || *m_read_ptr == ' ') { m_headers_parse_state = PARSE_HEADER_WHITESPACE; } else if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) { return false; } else { // assume it is the first character for the name of a header m_header_name.erase(); m_header_name.push_back(*m_read_ptr); m_headers_parse_state = PARSE_HEADER_NAME; } break; case PARSE_EXPECTING_CR: // we received a newline without a CR if (*m_read_ptr == '\r') { m_headers_parse_state = PARSE_HEADER_START; } else if (*m_read_ptr == '\n') { // we received two newlines in a row // assume newline only is (incorrectly) being used for line // termination // therefore, the message is finished ++m_read_ptr; m_bytes_last_read = (m_read_ptr - read_start_ptr); m_bytes_total_read += m_bytes_last_read; return true; } else if (*m_read_ptr == '\t' || *m_read_ptr == ' ') { m_headers_parse_state = PARSE_HEADER_WHITESPACE; } else if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) { return false; } else { // assume it is the first character for the name of a header m_header_name.erase(); m_header_name.push_back(*m_read_ptr); m_headers_parse_state = PARSE_HEADER_NAME; } break; case PARSE_HEADER_WHITESPACE: // parsing whitespace before a header name if (*m_read_ptr == '\r') { m_headers_parse_state = PARSE_EXPECTING_NEWLINE; } else if (*m_read_ptr == '\n') { m_headers_parse_state = PARSE_EXPECTING_CR; } else if (*m_read_ptr != '\t' && *m_read_ptr != ' ') { if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) return false; // assume it is the first character for the name of a header m_header_name.erase(); m_header_name.push_back(*m_read_ptr); m_headers_parse_state = PARSE_HEADER_NAME; } break; case PARSE_HEADER_START: // parsing the start of a new header if (*m_read_ptr == '\r') { m_headers_parse_state = PARSE_EXPECTING_FINAL_NEWLINE; } else if (*m_read_ptr == '\n') { m_headers_parse_state = PARSE_EXPECTING_FINAL_CR; } else if (*m_read_ptr == '\t' || *m_read_ptr == ' ') { m_headers_parse_state = PARSE_HEADER_WHITESPACE; } else if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) { return false; } else { // first character for the name of a header m_header_name.erase(); m_header_name.push_back(*m_read_ptr); m_headers_parse_state = PARSE_HEADER_NAME; } break; case PARSE_HEADER_NAME: // parsing the name of a header if (*m_read_ptr == ':') { m_header_value.erase(); m_headers_parse_state = PARSE_SPACE_BEFORE_HEADER_VALUE; } else if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) { return false; } else if (m_header_name.size() >= ParserTraits::HEADER_NAME_MAX) { return false; } else { // character (not first) for the name of a header m_header_name.push_back(*m_read_ptr); } break; case PARSE_SPACE_BEFORE_HEADER_VALUE: // parsing space character before a header's value if (*m_read_ptr == ' ') { m_headers_parse_state = PARSE_HEADER_VALUE; } else if (*m_read_ptr == '\r') { http_msg.addHeader(m_header_name, m_header_value); m_headers_parse_state = PARSE_EXPECTING_NEWLINE; } else if (*m_read_ptr == '\n') { http_msg.addHeader(m_header_name, m_header_value); m_headers_parse_state = PARSE_EXPECTING_CR; } else if (!is_char(*m_read_ptr) || is_control(*m_read_ptr) || is_special(*m_read_ptr)) { return false; } else { // assume it is the first character for the value of a header m_header_value.push_back(*m_read_ptr); m_headers_parse_state = PARSE_HEADER_VALUE; } break; case PARSE_HEADER_VALUE: // parsing the value of a header if (*m_read_ptr == '\r') { http_msg.addHeader(m_header_name, m_header_value); m_headers_parse_state = PARSE_EXPECTING_NEWLINE; } else if (*m_read_ptr == '\n') { http_msg.addHeader(m_header_name, m_header_value); m_headers_parse_state = PARSE_EXPECTING_CR; } else if (is_control(*m_read_ptr)) { return false; } else if (m_header_value.size() >= ParserTraits::HEADER_VALUE_MAX) { return false; } else { // character (not first) for the value of a header m_header_value.push_back(*m_read_ptr); } break; case PARSE_EXPECTING_FINAL_NEWLINE: if (*m_read_ptr == '\n') ++m_read_ptr; m_bytes_last_read = (m_read_ptr - read_start_ptr); m_bytes_total_read += m_bytes_last_read; return true; case PARSE_EXPECTING_FINAL_CR: if (*m_read_ptr == '\r') ++m_read_ptr; m_bytes_last_read = (m_read_ptr - read_start_ptr); m_bytes_total_read += m_bytes_last_read; return true; } ++m_read_ptr; } m_bytes_last_read = (m_read_ptr - read_start_ptr); m_bytes_total_read += m_bytes_last_read; return boost::indeterminate; } template boost::tribool basic_parser::parse_chunks( types::chunk_cache_t& chunk_buffers) { // // note that boost::tribool may have one of THREE states: // // false: encountered an error while parsing message // true: finished successfully parsing the message // indeterminate: parsed bytes, but the message is not yet finished // const char* read_start_ptr = m_read_ptr; m_bytes_last_read = 0; while (m_read_ptr < m_read_end_ptr) { switch (m_chunked_content_parse_state) { case PARSE_CHUNK_SIZE_START: // we have not yet started parsing the next chunk size if (is_hex_digit(*m_read_ptr)) { m_chunk_size_str.erase(); m_chunk_size_str.push_back(*m_read_ptr); m_chunked_content_parse_state = PARSE_CHUNK_SIZE; } else if (*m_read_ptr == ' ' || *m_read_ptr == '\x09' || *m_read_ptr == '\x0D' || *m_read_ptr == '\x0A') { // Ignore leading whitespace. Technically, the standard // probably doesn't allow white space here, // but we'll be flexible, since there's no ambiguity. break; } else { return false; } break; case PARSE_CHUNK_SIZE: if (is_hex_digit(*m_read_ptr)) { m_chunk_size_str.push_back(*m_read_ptr); } else if (*m_read_ptr == '\x0D') { m_chunked_content_parse_state = PARSE_EXPECTING_LF_AFTER_CHUNK_SIZE; } else if (*m_read_ptr == ' ' || *m_read_ptr == '\x09') { // Ignore trailing tabs or spaces. Technically, the standard // probably doesn't allow this, // but we'll be flexible, since there's no ambiguity. m_chunked_content_parse_state = PARSE_EXPECTING_CR_AFTER_CHUNK_SIZE; } else { return false; } break; case PARSE_EXPECTING_CR_AFTER_CHUNK_SIZE: if (*m_read_ptr == '\x0D') { m_chunked_content_parse_state = PARSE_EXPECTING_LF_AFTER_CHUNK_SIZE; } else if (*m_read_ptr == ' ' || *m_read_ptr == '\x09') { // Ignore trailing tabs or spaces. Technically, the standard // probably doesn't allow this, // but we'll be flexible, since there's no ambiguity. break; } else { return false; } break; case PARSE_EXPECTING_LF_AFTER_CHUNK_SIZE: // We received a CR; expecting LF to follow. We can't be flexible // here because // if we see anything other than LF, we can't be certain where the // chunk starts. if (*m_read_ptr == '\x0A') { m_bytes_read_in_current_chunk = 0; m_size_of_current_chunk = strtol(m_chunk_size_str.c_str(), 0, 16); if (m_size_of_current_chunk == 0) { m_chunked_content_parse_state = PARSE_EXPECTING_FINAL_CR_AFTER_LAST_CHUNK; } else { m_current_chunk.clear(); m_chunked_content_parse_state = PARSE_CHUNK; } } else { return false; } break; case PARSE_CHUNK: if (m_bytes_read_in_current_chunk < m_size_of_current_chunk) { m_current_chunk.push_back(*m_read_ptr); m_bytes_read_in_current_chunk++; } if (m_bytes_read_in_current_chunk == m_size_of_current_chunk) { chunk_buffers.push_back(m_current_chunk); m_current_chunk.clear(); m_chunked_content_parse_state = PARSE_EXPECTING_CR_AFTER_CHUNK; } break; case PARSE_EXPECTING_CR_AFTER_CHUNK: // we've read exactly m_size_of_current_chunk bytes since starting // the current chunk if (*m_read_ptr == '\x0D') { m_chunked_content_parse_state = PARSE_EXPECTING_LF_AFTER_CHUNK; } else { return false; } break; case PARSE_EXPECTING_LF_AFTER_CHUNK: // we received a CR; expecting LF to follow if (*m_read_ptr == '\x0A') { m_chunked_content_parse_state = PARSE_CHUNK_SIZE_START; } else { return false; } break; case PARSE_EXPECTING_FINAL_CR_AFTER_LAST_CHUNK: // we've read the final chunk; expecting final CRLF if (*m_read_ptr == '\x0D') { m_chunked_content_parse_state = PARSE_EXPECTING_FINAL_LF_AFTER_LAST_CHUNK; } else { return false; } break; case PARSE_EXPECTING_FINAL_LF_AFTER_LAST_CHUNK: // we received the final CR; expecting LF to follow if (*m_read_ptr == '\x0A') { ++m_read_ptr; m_bytes_last_read = (m_read_ptr - read_start_ptr); m_bytes_total_read += m_bytes_last_read; return true; } else { return false; } } ++m_read_ptr; } m_bytes_last_read = (m_read_ptr - read_start_ptr); m_bytes_total_read += m_bytes_last_read; return boost::indeterminate; } template std::size_t basic_parser::consume_content( basic_message& http_msg) { // get the payload content length from the HTTP headers http_msg.updateContentLengthUsingHeader(); // read the post content std::size_t content_bytes_to_read = http_msg.getContentLength(); char* post_buffer = http_msg.createContentBuffer(); if (m_read_ptr < m_read_end_ptr) { // there are extra bytes left from the last read operation // copy them into the beginning of the content buffer const std::size_t bytes_left_in_read_buffer = bytes_available(); if (bytes_left_in_read_buffer >= http_msg.getContentLength()) { // the last read operation included all of the payload content memcpy(post_buffer, m_read_ptr, http_msg.getContentLength()); content_bytes_to_read = 0; m_read_ptr += http_msg.getContentLength(); } else { // only some of the post content has been read so far memcpy(post_buffer, m_read_ptr, bytes_left_in_read_buffer); content_bytes_to_read -= bytes_left_in_read_buffer; m_read_ptr = m_read_end_ptr; } } m_bytes_last_read = (http_msg.getContentLength() - content_bytes_to_read); m_bytes_total_read += m_bytes_last_read; return m_bytes_last_read; } template std::size_t basic_parser::consume_content_as_next_chunk( types::chunk_cache_t& chunk_buffers) { if (bytes_available() == 0) { m_bytes_last_read = 0; } else { std::vector next_chunk; while (m_read_ptr < m_read_end_ptr) { next_chunk.push_back(*m_read_ptr); ++m_read_ptr; } chunk_buffers.push_back(next_chunk); m_bytes_last_read = next_chunk.size(); m_bytes_total_read += m_bytes_last_read; } return m_bytes_last_read; } template void basic_parser::finish(basic_request& http_request) { http_request.setIsValid(true); http_request.setMethod(m_method); http_request.setResource(m_resource); http_request.setQueryString(m_query_string); // parse query pairs from the URI query string if (!m_query_string.empty()) { if (!parseURLEncoded(http_request.getQueryParams(), m_query_string.c_str(), m_query_string.size())) } // parse query pairs from post content (x-www-form-urlencoded) if (http_request.getHeader(types::HEADER_CONTENT_TYPE) == types::CONTENT_TYPE_URLENCODED) { if (!parseURLEncoded(http_request.getQueryParams(), http_request.getContent(), http_request.getContentLength())) } // parse "Cookie" headers std::pair cookie_pair = http_request.getHeaders().equal_range(types::HEADER_COOKIE); for (types::headers::const_iterator cookie_iterator = cookie_pair.first; cookie_iterator != http_request.getHeaders().end() && cookie_iterator != cookie_pair.second; ++cookie_iterator) { if (!parseCookieHeader(http_request.getCookieParams(), cookie_iterator->second)) } } template void basic_parser::finish(basic_response& http_response) { http_response.setIsValid(true); http_response.setStatusCode(m_status_code); http_response.setStatusMessage(m_status_message); } template inline void basic_parser::reset(void) { m_headers_parse_state = (m_is_request ? PARSE_METHOD_START : PARSE_HTTP_VERSION_H); m_chunked_content_parse_state = PARSE_CHUNK_SIZE_START; m_status_code = 0; m_status_message.erase(); m_method.erase(); m_resource.erase(); m_query_string.erase(); m_current_chunk.clear(); m_bytes_last_read = m_bytes_total_read = 0; } template static bool basic_parser::parse_url_encoded( types::query_params& params, const char* ptr, const std::size_t len) { // used to track whether we are parsing the name or value enum query_parse_state_t { QUERY_PARSE_NAME, QUERY_PARSE_VALUE } parse_state = QUERY_PARSE_NAME; // misc other variables used for parsing const char* const end = ptr + len; string_type query_name; string_type query_value; // iterate through each encoded character while (ptr < end) { switch (parse_state) { case QUERY_PARSE_NAME: // parsing query name if (*ptr == '=') { // end of name found if (query_name.empty()) return false; parse_state = QUERY_PARSE_VALUE; } else if (*ptr == '&') { // value is empty (OK) if (query_name.empty()) return false; params.insert(std::make_pair(query_name, query_value)); query_name.erase(); } else if (is_control(*ptr) || query_name.size() >= ParserTraits::QUERY_NAME_MAX) { // control character detected, or max sized exceeded return false; } else { // character is part of the name query_name.push_back(*ptr); } break; case QUERY_PARSE_VALUE: // parsing query value if (*ptr == '&') { // end of value found (OK if empty) params.insert(std::make_pair(query_name, query_value)); query_name.erase(); query_value.erase(); parse_state = QUERY_PARSE_NAME; } else if (is_control(*ptr) || query_value.size() >= ParserTraits::QUERY_VALUE_MAX) { // control character detected, or max sized exceeded return false; } else { // character is part of the value query_value.push_back(*ptr); } break; } ++ptr; } // handle last pair in string if (!query_name.empty()) params.insert(std::make_pair(query_name, query_value)); return true; } template static bool basic_parser::parse_cookie_header( types::cookie_params& params, const string_type& cookie_header) { // BASED ON RFC 2109 // // The current implementation ignores cookie attributes which begin with // '$' // (i.e. $Path=/, $Domain=, etc.) // used to track what we are parsing enum cookie_parse_state_t { COOKIE_PARSE_NAME, COOKIE_PARSE_VALUE, COOKIE_PARSE_IGNORE } parse_state = COOKIE_PARSE_NAME; // misc other variables used for parsing string_type cookie_name; string_type cookie_value; char value_quote_character = '\0'; // iterate through each character for (string_type::const_iterator string_iterator = cookie_header.begin(); string_iterator != cookie_header.end(); ++string_iterator) { switch (parse_state) { case COOKIE_PARSE_NAME: // parsing cookie name if (*string_iterator == '=') { // end of name found if (cookie_name.empty()) return false; value_quote_character = '\0'; parse_state = COOKIE_PARSE_VALUE; } else if (*string_iterator == ';' || *string_iterator == ',') { // ignore empty cookie names since this may occur naturally // when quoted values are encountered if (!cookie_name.empty()) { // value is empty (OK) if (cookie_name[0] != '$') params.insert(std::make_pair(cookie_name, cookie_value)); cookie_name.erase(); } } else if (*string_iterator != ' ') { // ignore whitespace // check if control character detected, or max sized exceeded if (is_control(*string_iterator) || cookie_name.size() >= ParserTraits::COOKIE_NAME_MAX) return false; // character is part of the name // cookie names are case insensitive -> convert to lowercase cookie_name.push_back(tolower(*string_iterator)); } break; case COOKIE_PARSE_VALUE: // parsing cookie value if (value_quote_character == '\0') { // value is not (yet) quoted if (*string_iterator == ';' || *string_iterator == ',') { // end of value found (OK if empty) if (cookie_name[0] != '$') params.insert(std::make_pair(cookie_name, cookie_value)); cookie_name.erase(); cookie_value.erase(); parse_state = COOKIE_PARSE_NAME; } else if (*string_iterator == '\'' || *string_iterator == '"') { if (cookie_value.empty()) { // begin quoted value value_quote_character = *string_iterator; } else if (cookie_value.size() >= ParserTraits::COOKIE_VALUE_MAX) { // max size exceeded return false; } else { // assume character is part of the (unquoted) value cookie_value.push_back(*string_iterator); } } else if (*string_iterator != ' ') { // ignore unquoted whitespace // check if control character detected, or max sized exceeded if (is_control(*string_iterator) || cookie_value.size() >= ParserTraits::COOKIE_VALUE_MAX) return false; // character is part of the (unquoted) value cookie_value.push_back(*string_iterator); } } else { // value is quoted if (*string_iterator == value_quote_character) { // end of value found (OK if empty) if (cookie_name[0] != '$') params.insert(std::make_pair(cookie_name, cookie_value)); cookie_name.erase(); cookie_value.erase(); parse_state = COOKIE_PARSE_IGNORE; } else if (cookie_value.size() >= ParserTraits::COOKIE_VALUE_MAX) { // max size exceeded return false; } else { // character is part of the (quoted) value cookie_value.push_back(*string_iterator); } } break; case COOKIE_PARSE_IGNORE: // ignore everything until we reach a comma "," or semicolon ";" if (*string_iterator == ';' || *string_iterator == ',') parse_state = COOKIE_PARSE_NAME; break; } } // handle last cookie in string if (!cookie_name.empty() && cookie_name[0] != '$') params.insert(std::make_pair(cookie_name, cookie_value)); return true; } }; // namespace http }; // namespace network }; // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/impl/request.hpp000066400000000000000000000160321240331347200267720ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007,2009,2010. // Copyright Michael Dickey 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_PROTOCOL_HTTP_REQUEST_IMPL_20070908_1_HPP__ #define __NETWORK_PROTOCOL_HTTP_REQUEST_IMPL_20070908_1_HPP__ #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { /** Specialize the traits for the http_server tag. */ template <> struct headers_container< http::tags::http_server> : vector:: apply::type> {}; template <> struct headers_container< http::tags:: http_async_server> : vector:: apply::type> {}; namespace http { /** request.hpp * * This file implements the basic request object required * by the HTTP client implementation. The basic_request * object encapsulates a URI which is parsed at runtime. */ template struct basic_request : public basic_message { mutable boost::network::uri::uri uri_; typedef basic_message base_type; public: typedef typename sync_only::type tag; typedef typename string::type string_type; typedef boost::uint16_t port_type; explicit basic_request(string_type const& uri_) : uri_(uri_) {} explicit basic_request(boost::network::uri::uri const& uri_) : uri_(uri_) {} void uri(string_type const& new_uri) { uri_ = new_uri; } void uri(boost::network::uri::uri const& new_uri) { uri_ = new_uri; } basic_request() : base_type() {} basic_request(basic_request const& other) : base_type(other), uri_(other.uri_) {} basic_request& operator=(basic_request rhs) { rhs.swap(*this); return *this; } void swap(basic_request& other) { base_type& base_ref(other); basic_request& this_ref(*this); base_ref.swap(this_ref); boost::swap(other.uri_, this->uri_); } string_type const host() const { return uri_.host(); } port_type port() const { boost::optional port = uri::port_us(uri_); if (!port) { typedef constants consts; return boost::iequals(uri_.scheme(), string_type(consts::https())) ? 443 : 80; } return *port; } string_type const path() const { return uri_.path(); } string_type const query() const { return uri_.query(); } string_type const anchor() const { return uri_.fragment(); } string_type const protocol() const { return uri_.scheme(); } void uri(string_type const& new_uri) const { uri_ = new_uri; } boost::network::uri::uri const& uri() const { return uri_; } }; /** This is the implementation of a POD request type * that is specificially used by the HTTP server * implementation. This fully specializes the * basic_request template above to be * primarily and be solely a POD for performance * reasons. * * Reality check: This is not a POD because it contains a non-POD * member, the headers vector. :( */ template struct not_quite_pod_request_base { typedef Tag tag; typedef typename string::type string_type; typedef typename request_header::type header_type; typedef typename vector::template apply::type vector_type; typedef vector_type headers_container_type; typedef boost::uint16_t port_type; mutable string_type source; mutable port_type source_port; mutable string_type method; mutable string_type destination; mutable boost::uint8_t http_version_major; mutable boost::uint8_t http_version_minor; mutable vector_type headers; mutable string_type body; void swap(not_quite_pod_request_base& r) const { using std::swap; swap(method, r.method); swap(source, r.source); swap(source_port, r.source_port); swap(destination, r.destination); swap(http_version_major, r.http_version_major); swap(http_version_minor, r.http_version_minor); swap(headers, r.headers); swap(body, r.body); } }; template <> struct basic_request : not_quite_pod_request_base< tags::http_async_server> {}; template <> struct basic_request : not_quite_pod_request_base< tags::http_server> {}; template struct ServerRequest; BOOST_CONCEPT_ASSERT((ServerRequest >)); BOOST_CONCEPT_ASSERT((ServerRequest >)); template inline void swap(basic_request& lhs, basic_request& rhs) { lhs.swap(rhs); } } // namespace http namespace http { namespace impl { template <> struct request_headers_wrapper { basic_request const& request_; request_headers_wrapper(basic_request const& request_) : request_(request_) {} typedef headers_container::type headers_container_type; operator headers_container_type() { return request_.headers; } }; template <> struct body_wrapper > { typedef string::type string_type; basic_request const& request_; body_wrapper(basic_request const& request_) : request_(request_) {} operator string_type() { return request_.body; } }; template <> struct request_headers_wrapper { basic_request const& request_; request_headers_wrapper( basic_request const& request_) : request_(request_) {} typedef headers_container::type headers_container_type; operator headers_container_type() { return request_.headers; } }; template <> struct body_wrapper > { typedef string::type string_type; basic_request const& request_; body_wrapper(basic_request const& request_) : request_(request_) {} operator string_type() { return request_.body; } }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // __NETWORK_PROTOCOL_HTTP_REQUEST_IMPL_20070908_1_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/impl/request_parser.ipp000066400000000000000000000155761240331347200303630ustar00rootroot00000000000000// // request_parser.ipp // ~~~~~~~~~~~~~~~~~~ // // Implementation file for the header-only version of the request_parser. // // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2009 Dean Michael Berris (mikhailberis@gmail.com) // Copyright (c) 2009 Tarroo, Inc. // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NETWORK_HTTP_REQUEST_PARSER_IPP #define BOOST_NETWORK_HTTP_REQUEST_PARSER_IPP #include namespace boost { namespace network { namespace http { template boost::tribool basic_request_parser::consume(basic_request& req, char input) { switch (state_) { case method_start: if (!is_char(input) || is_ctl(input) || is_tspecial(input)) { return false; } else { state_ = method; req.method.push_back(input); return boost::indeterminate; } case method: if (input == ' ') { state_ = uri; return boost::indeterminate; } else if (!is_char(input) || is_ctl(input) || is_tspecial(input)) { return false; } else { req.method.push_back(input); return boost::indeterminate; } case uri_start: if (is_ctl(input)) { return false; } else { state_ = uri; req.destination.push_back(input); return boost::indeterminate; } case uri: if (input == ' ') { state_ = http_version_h; return boost::indeterminate; } else if (is_ctl(input)) { return false; } else { req.destination.push_back(input); return boost::indeterminate; } case http_version_h: if (input == 'H') { state_ = http_version_t_1; return boost::indeterminate; } else { return false; } case http_version_t_1: if (input == 'T') { state_ = http_version_t_2; return boost::indeterminate; } else { return false; } case http_version_t_2: if (input == 'T') { state_ = http_version_p; return boost::indeterminate; } else { return false; } case http_version_p: if (input == 'P') { state_ = http_version_slash; return boost::indeterminate; } else { return false; } case http_version_slash: if (input == '/') { req.http_version_major = 0; req.http_version_minor = 0; state_ = http_version_major_start; return boost::indeterminate; } else { return false; } case http_version_major_start: if (is_digit(input)) { req.http_version_major = req.http_version_major * 10 + input - '0'; state_ = http_version_major; return boost::indeterminate; } else { return false; } case http_version_major: if (input == '.') { state_ = http_version_minor_start; return boost::indeterminate; } else if (is_digit(input)) { req.http_version_major = req.http_version_major * 10 + input - '0'; return boost::indeterminate; } else { return false; } case http_version_minor_start: if (is_digit(input)) { req.http_version_minor = req.http_version_minor * 10 + input - '0'; state_ = http_version_minor; return boost::indeterminate; } else { return false; } case http_version_minor: if (input == '\r') { state_ = expecting_newline_1; return boost::indeterminate; } else if (is_digit(input)) { req.http_version_minor = req.http_version_minor * 10 + input - '0'; return boost::indeterminate; } else { return false; } case expecting_newline_1: if (input == '\n') { state_ = header_line_start; return boost::indeterminate; } else { return false; } case header_line_start: if (input == '\r') { state_ = expecting_newline_3; return boost::indeterminate; } else if (!req.headers.empty() && (input == ' ' || input == '\t')) { state_ = header_lws; return boost::indeterminate; } else if (!is_char(input) || is_ctl(input) || is_tspecial(input)) { return false; } else { req.headers.push_back(typename request_header::type()); req.headers.back().name.push_back(input); state_ = header_name; return boost::indeterminate; } case header_lws: if (input == '\r') { state_ = expecting_newline_2; return boost::indeterminate; } else if (input == ' ' || input == '\t') { return boost::indeterminate; } else if (is_ctl(input)) { return false; } else { state_ = header_value; req.headers.back().value.push_back(input); return boost::indeterminate; } case header_name: if (input == ':') { state_ = space_before_header_value; return boost::indeterminate; } else if (!is_char(input) || is_ctl(input) || is_tspecial(input)) { return false; } else { req.headers.back().name.push_back(input); return boost::indeterminate; } case space_before_header_value: if (input == ' ') { state_ = header_value; return boost::indeterminate; } else { return false; } case header_value: if (input == '\r') { state_ = expecting_newline_2; return boost::indeterminate; } else if (is_ctl(input)) { return false; } else { req.headers.back().value.push_back(input); return boost::indeterminate; } case expecting_newline_2: if (input == '\n') { state_ = header_line_start; return boost::indeterminate; } else { return false; } case expecting_newline_3: return (input == '\n'); default: return false; } } template bool basic_request_parser::is_char(int c) { return c >= 0 && c <= 127; } template bool basic_request_parser::is_ctl(int c) { return (c >= 0 && c <= 31) || (c == 127); } template bool basic_request_parser::is_tspecial(int c) { switch (c) { case '(': case ')': case '<': case '>': case '@': case ',': case ';': case ':': case '\\': case '"': case '/': case '[': case ']': case '?': case '=': case '{': case '}': case ' ': case '\t': return true; default: return false; } } template bool basic_request_parser::is_digit(int c) { return c >= '0' && c <= '9'; } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_HTTP_REQUEST_PARSER_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/impl/response.ipp000066400000000000000000000371421240331347200271460ustar00rootroot00000000000000// // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2009 Dean Michael Berris (mikhailberis@gmail.com) // Copyright (c) 2009 Tarroo, Inc. // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Note: This implementation has significantly changed from the original example // from a plain header file into a header-only implementation using C++ // templates // to reduce the dependence on building an external library. // #ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_RESPONSE_RESPONSE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_RESPONSE_RESPONSE_IPP #include #include #include #include #include #include namespace boost { namespace network { namespace http { /// A reply to be sent to a client. template <> struct basic_response { typedef tags::http_server tag; typedef response_header::type header_type; /*! The status of the reply. Represent all the status codes of HTTP v1.1 * from http://tools.ietf.org/html/rfc2616#page-39 and * http://tools.ietf.org/html/rfc6585 */ enum status_type { continue_http = 100, switching_protocols = 101, ok = 200, created = 201, accepted = 202, non_authoritative_information = 203, no_content = 204, reset_content = 205, partial_content = 206, multiple_choices = 300, moved_permanently = 301, moved_temporarily = 302, ///< \deprecated Not HTTP standard found = 302, see_other = 303, not_modified = 304, use_proxy = 305, temporary_redirect = 307, bad_request = 400, unauthorized = 401, payment_required = 402, forbidden = 403, not_found = 404, not_supported = 405, ///< \deprecated Not HTTP standard method_not_allowed = 405, not_acceptable = 406, proxy_authentication_required = 407, request_timeout = 408, conflict = 409, gone = 410, length_required = 411, precondition_failed = 412, request_entity_too_large = 413, request_uri_too_large = 414, unsupported_media_type = 415, unsatisfiable_range = 416, ///< \deprecated Not HTTP standard requested_range_not_satisfiable = 416, expectation_failed = 417, precondition_required = 428, too_many_requests = 429, request_header_fields_too_large = 431, internal_server_error = 500, not_implemented = 501, bad_gateway = 502, service_unavailable = 503, gateway_timeout = 504, http_version_not_supported = 505, space_unavailable = 507, network_authentication_required = 511 } status; /// The headers to be included in the reply. typedef vector::apply::type headers_vector; headers_vector headers; /// The content to be sent in the reply. typedef string::type string_type; string_type content; /// Convert the reply into a vector of buffers. The buffers do not own /// the /// underlying memory blocks, therefore the reply object must remain /// valid and /// not be changed until the write operation has completed. std::vector to_buffers() { using boost::asio::const_buffer; using boost::asio::buffer; static const char name_value_separator[] = {':', ' '}; static const char crlf[] = {'\r', '\n'}; std::vector buffers; buffers.push_back(to_buffer(status)); for (std::size_t i = 0; i < headers.size(); ++i) { header_type &h = headers[i]; buffers.push_back(buffer(h.name)); buffers.push_back(buffer(name_value_separator)); buffers.push_back(buffer(h.value)); buffers.push_back(buffer(crlf)); } buffers.push_back(buffer(crlf)); buffers.push_back(buffer(content)); return buffers; } /// Get a stock reply. static basic_response stock_reply(status_type status) { return stock_reply(status, to_string(status)); } /// Get a stock reply with custom plain text data. static basic_response stock_reply(status_type status, string_type content) { using boost::lexical_cast; basic_response rep; rep.status = status; rep.content = content; rep.headers.resize(2); rep.headers[0].name = "Content-Length"; rep.headers[0].value = lexical_cast(rep.content.size()); rep.headers[1].name = "Content-Type"; rep.headers[1].value = "text/html"; return rep; } /// Swap response objects void swap(basic_response &r) { using std::swap; swap(headers, r.headers); swap(content, r.content); } private: static string_type to_string(status_type status) { static const char ok[] = ""; static const char created[] = "" "Created" "

201 Created

" ""; static const char accepted[] = "" "Accepted" "

202 Accepted

" ""; static const char no_content[] = "" "No Content" "

204 Content

" ""; static const char multiple_choices[] = "" "Multiple Choices" "

300 Multiple Choices

" ""; static const char moved_permanently[] = "" "Moved Permanently" "

301 Moved Permanently

" ""; static const char moved_temporarily[] = "" "Moved Temporarily" "

302 Moved Temporarily

" ""; static const char not_modified[] = "" "Not Modified" "

304 Not Modified

" ""; static const char bad_request[] = "" "Bad Request" "

400 Bad Request

" ""; static const char unauthorized[] = "" "Unauthorized" "

401 Unauthorized

" ""; static const char forbidden[] = "" "Forbidden" "

403 Forbidden

" ""; static const char not_found[] = "" "Not Found" "

404 Not Found

" ""; static const char not_supported[] = "" "Method Not Supported" "

Method Not Supported

" ""; static const char not_acceptable[] = "" "Request Not Acceptable" "

Request Not Acceptable

" ""; static const char internal_server_error[] = "" "Internal Server Error" "

500 Internal Server Error

" ""; static const char not_implemented[] = "" "Not Implemented" "

501 Not Implemented

" ""; static const char bad_gateway[] = "" "Bad Gateway" "

502 Bad Gateway

" ""; static const char service_unavailable[] = "" "Service Unavailable" "

503 Service Unavailable

" ""; static const char space_unavailable[] = "" "Space Unavailable" "

HTTP/1.0 507 Insufficient Space to Store " "Resource

" ""; static const char partial_content[] = "" "Partial Content" "

HTTP/1.1 206 Partial Content

" ""; static const char request_timeout[] = "" "Request Timeout" "

HTTP/1.1 408 Request Timeout

" ""; static const char precondition_failed[] = "" "Precondition Failed" "

HTTP/1.1 412 Precondition Failed

" ""; static const char unsatisfiable_range[] = "" "Unsatisfiable Range" "

HTTP/1.1 416 Requested Range Not " "Satisfiable

" ""; switch (status) { case basic_response::ok: return ok; case basic_response::created: return created; case basic_response::accepted: return accepted; case basic_response::no_content: return no_content; case basic_response::multiple_choices: return multiple_choices; case basic_response::moved_permanently: return moved_permanently; case basic_response::moved_temporarily: return moved_temporarily; case basic_response::not_modified: return not_modified; case basic_response::bad_request: return bad_request; case basic_response::unauthorized: return unauthorized; case basic_response::forbidden: return forbidden; case basic_response::not_found: return not_found; case basic_response::not_supported: return not_supported; case basic_response::not_acceptable: return not_acceptable; case basic_response::internal_server_error: return internal_server_error; case basic_response::not_implemented: return not_implemented; case basic_response::bad_gateway: return bad_gateway; case basic_response::service_unavailable: return service_unavailable; case basic_response::space_unavailable: return space_unavailable; case basic_response::partial_content: return partial_content; case basic_response::request_timeout: return request_timeout; case basic_response::unsatisfiable_range: return unsatisfiable_range; case basic_response::precondition_failed: return precondition_failed; default: return internal_server_error; } } boost::asio::const_buffer to_buffer(status_type status) { using boost::asio::buffer; static const string_type ok = "HTTP/1.0 200 OK\r\n"; static const string_type created = "HTTP/1.0 201 Created\r\n"; static const string_type accepted = "HTTP/1.0 202 Accepted\r\n"; static const string_type no_content = "HTTP/1.0 204 No Content\r\n"; static const string_type multiple_choices = "HTTP/1.0 300 Multiple Choices\r\n"; static const string_type moved_permanently = "HTTP/1.0 301 Moved Permanently\r\n"; static const string_type moved_temporarily = "HTTP/1.0 302 Moved Temporarily\r\n"; static const string_type not_modified = "HTTP/1.0 304 Not Modified\r\n"; static const string_type bad_request = "HTTP/1.0 400 Bad Request\r\n"; static const string_type unauthorized = "HTTP/1.0 401 Unauthorized\r\n"; static const string_type forbidden = "HTTP/1.0 403 Forbidden\r\n"; static const string_type not_found = "HTTP/1.0 404 Not Found\r\n"; static const string_type not_supported = "HTTP/1.0 405 Method Not Supported\r\n"; static const string_type not_acceptable = "HTTP/1.0 406 Method Not Acceptable\r\n"; static const string_type internal_server_error = "HTTP/1.0 500 Internal Server Error\r\n"; static const string_type not_implemented = "HTTP/1.0 501 Not Implemented\r\n"; static const string_type bad_gateway = "HTTP/1.0 502 Bad Gateway\r\n"; static const string_type service_unavailable = "HTTP/1.0 503 Service Unavailable\r\n"; static const string_type space_unavailable = "HTTP/1.0 507 Insufficient Space to Store Resource\r\n"; static const string_type partial_content = "HTTP/1.1 206 Partial Content\r\n"; static const string_type request_timeout = "HTTP/1.1 408 Request Timeout\r\n"; static const string_type precondition_failed = "HTTP/1.1 412 Precondition Failed\r\n"; static const string_type unsatisfiable_range = "HTTP/1.1 416 Requested Range Not Satisfiable\r\n"; switch (status) { case basic_response::ok: return buffer(ok); case basic_response::created: return buffer(created); case basic_response::accepted: return buffer(accepted); case basic_response::no_content: return buffer(no_content); case basic_response::multiple_choices: return buffer(multiple_choices); case basic_response::moved_permanently: return buffer(moved_permanently); case basic_response::moved_temporarily: return buffer(moved_temporarily); case basic_response::not_modified: return buffer(not_modified); case basic_response::bad_request: return buffer(bad_request); case basic_response::unauthorized: return buffer(unauthorized); case basic_response::forbidden: return buffer(forbidden); case basic_response::not_found: return buffer(not_found); case basic_response::not_supported: return buffer(not_supported); case basic_response::not_acceptable: return buffer(not_acceptable); case basic_response::internal_server_error: return buffer(internal_server_error); case basic_response::not_implemented: return buffer(not_implemented); case basic_response::bad_gateway: return buffer(bad_gateway); case basic_response::service_unavailable: return buffer(service_unavailable); case basic_response::space_unavailable: return buffer(space_unavailable); case basic_response::partial_content: return buffer(partial_content); case basic_response::request_timeout: return buffer(request_timeout); case basic_response::unsatisfiable_range: return buffer(unsatisfiable_range); case basic_response::precondition_failed: return buffer(precondition_failed); default: return buffer(internal_server_error); } } }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_RESPONSE_RESPONSE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message.hpp000066400000000000000000000103061240331347200257630ustar00rootroot00000000000000// This file is part of the Boost Network library // Based on the Pion Network Library (r421) // Copyright Atomic Labs, Inc. 2007-2008 // See http://cpp-netlib.sourceforge.net for library home page. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Some changes Copyright (c) Dean Michael Berris 2008 #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HPP #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { /// base class for HTTP messages (requests and responses) template struct message_impl : public basic_message { typedef typename string::type string_type; /// escapes URL-encoded strings (a%20value+with%20spaces) static string_type const url_decode(string_type const &str); /// encodes strings so that they are safe for URLs (with%20spaces) static string_type const url_encode(string_type const &str); /// builds an HTTP query string from a collection of query parameters static string_type const make_query_string( typename query_container::type const &query_params); /** * creates a "Set-Cookie" header * * @param name the name of the cookie * @param value the value of the cookie * @param path the path of the cookie * @param has_max_age true if the max_age value should be set * @param max_age the life of the cookie, in seconds (0 = discard) * * @return the new "Set-Cookie" header */ static string_type const make_set_cookie_header( string_type const &name, string_type const &value, string_type const &path, bool const has_max_age = false, unsigned long const max_age = 0); /** decodes base64-encoded strings * * @param input base64 encoded string * @param output decoded string ( may include non-text chars) * @return true if successful, false if input string contains non-base64 *symbols */ static bool base64_decode(string_type const &input, string_type &output); /** encodes strings using base64 * * @param input arbitrary string ( may include non-text chars) * @param output base64 encoded string * @return true if successful */ static bool base64_encode(string_type const &input, string_type &output); protected: mutable string_type version_; mutable boost::uint16_t status_; mutable string_type status_message_; private: typedef basic_message base_type; public: message_impl() : base_type(), version_(), status_(0u), status_message_() {} message_impl(message_impl const &other) : base_type(other), version_(other.version_), status_(other.status_), status_message_(other.status_message_) {} void version(string_type const &version) const { version_ = version; } string_type const version() const { return version_; } void status(boost::uint16_t status) const { status_ = status; } boost::uint16_t status() const { return status_; } void status_message(string_type const &status_message) const { status_message_ = status_message; } string_type const status_message() const { return status_message_; } message_impl &operator=(message_impl rhs) { rhs.swap(*this); return *this; } void swap(message_impl &other) { base_type &base_ref(other), &this_ref(*this); std::swap(this_ref, base_ref); std::swap(status_, other.status_); std::swap(status_message_, other.status_message_); std::swap(version_, other.version_); } }; template inline void swap(message_impl &lhs, message_impl &rhs) { lhs.swap(rhs); } typedef message_impl message; } // namespace http } // namespace network } // namespace boost // import implementation file #include #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/000077500000000000000000000000001240331347200252525ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/async_message.hpp000066400000000000000000000106671240331347200306160ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_ASYNC_MESSAGE_HPP_20100622 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_ASYNC_MESSAGE_HPP_20100622 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include // FIXME move this out to a trait #include #include #include namespace boost { namespace network { namespace http { namespace impl { template struct ready_wrapper; } /* impl */ template struct async_message { typedef typename string::type string_type; typedef typename headers_container::type headers_container_type; typedef typename headers_container_type::value_type header_type; async_message() : status_message_(), version_(), source_(), destination_(), status_(), headers_(), body_() {} async_message(async_message const& other) : status_message_(other.status_message_), version_(other.version_), source_(other.source_), destination_(other.destination_), status_(other.status_), headers_(other.headers_), body_(other.body_) {} string_type const status_message() const { return status_message_.get(); } void status_message(boost::shared_future const& future) const { status_message_ = future; } string_type const version() const { return version_.get(); } void version(boost::shared_future const& future) const { version_ = future; } boost::uint16_t status() const { return status_.get(); } void status(boost::shared_future const& future) const { status_ = future; } string_type const source() const { return source_.get(); } void source(boost::shared_future const& future) const { source_ = future; } string_type const destination() const { return destination_.get(); } void destination(boost::shared_future const& future) const { destination_ = future; } headers_container_type const& headers() const { if (retrieved_headers_) return *retrieved_headers_; headers_container_type raw_headers = headers_.get(); raw_headers.insert(added_headers.begin(), added_headers.end()); BOOST_FOREACH(string_type const & key, removed_headers) { raw_headers.erase(key); } retrieved_headers_ = raw_headers; return *retrieved_headers_; } void headers(boost::shared_future const& future) const { headers_ = future; } void add_header(typename headers_container_type::value_type const& pair_) const { added_headers.insert(added_headers.end(), pair_); } void remove_header(typename headers_container_type::key_type const& key_) const { removed_headers.insert(key_); } string_type const body() const { return body_.get(); } void body(boost::shared_future const& future) const { body_ = future; } void swap(async_message& other) { std::swap(status_message_, other.status_message_); std::swap(status_, other.status_); std::swap(version_, other.version_); std::swap(source_, other.source_); std::swap(destination_, other.destination_); std::swap(headers_, other.headers_); std::swap(body_, other.body_); } async_message& operator=(async_message other) { other.swap(*this); return *this; } private: mutable boost::shared_future status_message_, version_, source_, destination_; mutable boost::shared_future status_; mutable boost::shared_future headers_; mutable headers_container_type added_headers; mutable std::set removed_headers; mutable boost::shared_future body_; mutable boost::optional retrieved_headers_; friend struct boost::network::http::impl::ready_wrapper; }; template inline void swap(async_message& lhs, async_message& rhs) { lhs.swap(rhs); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_ASYNC_MESSAGE_HPP_20100622 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/000077500000000000000000000000001240331347200274135ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/major_version.hpp000066400000000000000000000022231240331347200330000ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_MAJOR_VERSION_HPP_20101120 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_MAJOR_VERSION_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; struct major_version_directive { boost::uint8_t major_version; explicit major_version_directive(boost::uint8_t major_version) : major_version(major_version) {} template void operator()(basic_request& request) const { request.http_version_major = major_version; } }; inline major_version_directive major_version(boost::uint8_t major_version_) { return major_version_directive(major_version_); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_MAJOR_VERSION_HPP_20101120 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/method.hpp000066400000000000000000000012411240331347200314020ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_METHOD_HPP_20101120 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_METHOD_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { BOOST_NETWORK_STRING_DIRECTIVE(method, method_, message.method(method_), message.method = method_); } /* http */ } /* network */ } /* booet */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_METHOD_HPP_20101120 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/minor_version.hpp000066400000000000000000000022231240331347200330140ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_MINOR_VERSION_HPP_20101120 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_MINOR_VERSION_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; struct minor_version_directive { boost::uint8_t minor_version; explicit minor_version_directive(boost::uint8_t minor_version) : minor_version(minor_version) {} template void operator()(basic_request& request) const { request.http_version_minor = minor_version; } }; inline minor_version_directive minor_version(boost::uint8_t minor_version_) { return minor_version_directive(minor_version_); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_MINOR_VERSION_HPP_20101120 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/status.hpp000066400000000000000000000042121240331347200314460ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_STATUS_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_STATUS_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_response; struct status_directive { boost::variant > status_; explicit status_directive(boost::uint16_t status) : status_(status) {} explicit status_directive(boost::shared_future const &status) : status_(status) {} status_directive(status_directive const &other) : status_(other.status_) {} template struct value : mpl::if_, boost::shared_future, boost::uint16_t> {}; template struct status_visitor : boost::static_visitor<> { basic_response const &response; status_visitor(basic_response const &response) : response(response) {} void operator()(typename value::type const &status_) const { response.status(status_); } template void operator()(T const &) const { // FIXME fail here! } }; template basic_response const &operator()(basic_response const &response) const { apply_visitor(status_visitor(response), status_); return response; } }; template inline status_directive const status(T const &status_) { return status_directive(status_); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_STATUS_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/status_message.hpp000066400000000000000000000016451240331347200331610ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_STATUS_MESSAGE_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_STATUS_MESSAGE_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { BOOST_NETWORK_STRING_DIRECTIVE(status_message, status_message_, message.status_message(status_message_), message.status_message = status_message_); } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_STATUS_MESSAGE_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/uri.hpp000066400000000000000000000014431240331347200307250ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_URI_HPP_20100620 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_URI_HPP_20100620 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { BOOST_NETWORK_STRING_DIRECTIVE(uri, uri_, message.uri(uri_), message.uri = uri_); } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_URI_HPP_20100620 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/directives/version.hpp000066400000000000000000000015071240331347200316140ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_VERSION_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_VERSION_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { BOOST_NETWORK_STRING_DIRECTIVE(version, version_, message.version(version_), message.version = version_); } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DIRECTIVES_VERSION_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/header.hpp000066400000000000000000000056141240331347200272210ustar00rootroot00000000000000// // header.hpp // ~~~~~~~~~~ // // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2009,2010 Dean Michael Berris (mikhailberis@gmail.com) // Copyright (c) 2009 Tarroo, Inc. // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_HPP_20101122 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_HPP_20101122 #include #include #include #include #include namespace boost { namespace network { namespace http { template struct unsupported_tag; struct request_header_narrow { typedef std::string string_type; std::string name, value; }; struct request_header_wide { typedef std::wstring string_type; std::wstring name, value; }; template struct request_header : mpl::if_, request_header_narrow, typename mpl::if_, request_header_wide, unsupported_tag >::type> {}; inline void swap(request_header_narrow& l, request_header_narrow& r) { swap(l.name, r.name); swap(l.value, r.value); } inline void swap(request_header_wide& l, request_header_wide& r) { swap(l.name, r.name); swap(l.value, r.value); } struct response_header_narrow { typedef std::string string_type; std::string name, value; }; struct response_header_wide { typedef std::wstring string_type; std::wstring name, value; }; template struct response_header : mpl::if_, response_header_narrow, typename mpl::if_, response_header_wide, unsupported_tag >::type> {}; inline void swap(response_header_narrow& l, response_header_narrow& r) { std::swap(l.name, r.name); std::swap(l.value, r.value); } inline void swap(response_header_wide& l, response_header_wide& r) { std::swap(l.name, r.name); std::swap(l.value, r.value); } } // namespace http } // namespace network } // namespace boost BOOST_FUSION_ADAPT_STRUCT(boost::network::http::request_header_narrow, (std::string, name)(std::string, value)) BOOST_FUSION_ADAPT_STRUCT(boost::network::http::request_header_wide, (std::wstring, name)(std::wstring, value)) BOOST_FUSION_ADAPT_STRUCT(boost::network::http::response_header_narrow, (std::string, name)(std::string, value)) BOOST_FUSION_ADAPT_STRUCT(boost::network::http::response_header_wide, (std::wstring, name)(std::wstring, value)) #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_HPP_20101122 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/header/000077500000000000000000000000001240331347200265025ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/header/name.hpp000066400000000000000000000017711240331347200301410ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_NAME_HPP_20101028 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_NAME_HPP_20101028 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template T1 &name(std::pair const &p) { return p.first; } inline std::string const &name(request_header_narrow const &h) { return h.name; } inline std::wstring const &name(request_header_wide const &h) { return h.name; } inline std::string const &name(response_header_narrow const &h) { return h.name; } inline std::wstring const &name(response_header_wide const &h) { return h.name; } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_NAME_HPP_20101028 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/header/value.hpp000066400000000000000000000022611240331347200303300ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_VALUE_HPP_20101028 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_VALUE_HPP_20101028 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { struct request_header_narrow; struct request_header_wide; struct response_header_narrow; struct response_header_wide; template T1& value(std::pair const& p) { return p.second; } inline request_header_narrow::string_type const& value( request_header_narrow const& h) { return h.value; } inline request_header_wide::string_type const& value( request_header_wide const& h) { return h.value; } inline response_header_narrow::string_type const& value( response_header_narrow const& h) { return h.value; } inline response_header_wide::string_type const& value( response_header_wide const& h) { return h.value; } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_VALUE_HPP_20101028 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/header_concept.hpp000066400000000000000000000016461240331347200307350ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_CONCEPT_HPP_20101028 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_CONCEPT_HPP_20101028 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { template struct Header : DefaultConstructible, Assignable, CopyConstructible { BOOST_CONCEPT_USAGE(Header) { typedef typename H::string_type string_type; string_type name_ = name(header); string_type value_ = value(header); H h1, h2; swap(h1, h2); // ADL Swap! (void)name_; (void)value_; } private: H header; }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HEADER_CONCEPT_HPP_20101028 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/message_base.hpp000066400000000000000000000015041240331347200304010ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_BASE_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_BASE_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct async_message; template struct message_impl; template struct message_base : mpl::if_, async_message, message_impl > {}; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_BASE_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/000077500000000000000000000000001240331347200272335ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/body.hpp000066400000000000000000000041061240331347200307020ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_BODY_HPP_20100624 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_BODY_HPP_20100624 // Copyright 2010 (C) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_response; template struct basic_request; namespace impl { template void body(basic_response &response, T const &value, mpl::false_ const &) { response << ::boost::network::body(value); } template void body(basic_response &response, T const &future, mpl::true_ const &) { response.body(future); } } template inline void body(basic_response &response, T const &value) { impl::body(response, value, is_async()); } template inline void body_impl(basic_request &request, T const &value, tags::server) { request.body = value; } template inline void body_impl(basic_request &request, T const &value, tags::client) { request << ::boost::network::body(value); } template inline void body(basic_request &request, T const &value) { body_impl(request, value, typename client_or_server::type()); } } // namespace http namespace impl { template inline void body(Message const &message, ValueType const &body_, http::tags::http_server, Async) { message.body = body_; } } /* impl */ } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_BODY_HPP_20100624 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/clear_headers.hpp000066400000000000000000000032441240331347200325300ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_CLEAR_HEADER_HPP_20101128 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_CLEAR_HEADER_HPP_20101128 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include namespace boost { namespace network { namespace http { template inline void clear_headers_impl(basic_request& request, tags::pod) { typedef typename basic_request::headers_container_type headers_container; headers_container().swap(request.headers); } template inline void clear_headers_impl(basic_request& request, tags::normal) { request.headers(typename basic_request::headers_container_type()); } template inline void clear_headers_impl(basic_request& request, tags::client) { clear_headers_impl(request, typename pod_or_normal::type()); } template inline void clear_headers_impl(basic_request& request, tags::server) { typedef typename basic_request::headers_container_type headers_container; headers_container().swap(request.headers); } template inline void clear_headers(basic_request& request) { clear_headers_impl(request, typename client_or_server::type()); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_CLEAR_HEADER_HPP_20101128 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/destination.hpp000066400000000000000000000052731240331347200322740ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_DESTINATION_HPP_20100624 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_DESTINATION_HPP_20100624 // Copyright 2010 (C) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_response; template struct basic_request; namespace impl { template void destination(basic_response &response, T const &value, mpl::false_ const &) { response << ::boost::network::destination(value); } template void destination(basic_response &response, T const &future, mpl::true_ const &) { response.destination(future); } } template inline void destination(basic_response &response, T const &value) { impl::destination(response, value, is_async()); } template struct ServerRequest; template inline void destination_impl(basic_request &request, T const &value, tags::server) { request.destination = value; } template inline void destination_impl(basic_request &request, T const &value, tags::pod) { request.destination = value; } template inline void destination_impl(basic_request &request, T const &value, tags::normal) { request.destination(value); } template inline void destination_impl(basic_request &request, T const &value, tags::client) { destination_impl(request, value, typename pod_or_normal::type()); } template inline void destination(basic_request &request, T const &value) { destination_impl(request, value, typename client_or_server::type()); } } // namespace http namespace impl { template inline void destination(Message const &message, ValueType const &destination_, http::tags::http_server, Async) { message.destination = destination_; } } /* impl */ } // namespace network } // namespace boost #include #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_DESTINATION_HPP_20100624 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/headers.hpp000066400000000000000000000030101240331347200313510ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_HEADERS_HPP_20100624 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_HEADERS_HPP_20100624 // Copyright 2010 (C) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_response; template struct basic_request; namespace impl { template void headers(basic_response &response, T const &value, mpl::false_ const &) { response << headers(value); } template void headers(basic_response &response, T const &future, mpl::true_ const &) { response.headers(future); } template void headers(basic_request &request, T const &value, tags::server const &) { request.headers = value; } } template inline void headers(basic_response &response, T const &value) { impl::headers(response, value, is_async()); } template inline void headers(basic_request &request, T const &value) { impl::headers(request, value, Tag()); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_HEADERS_HPP_20100624 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/major_version.hpp000066400000000000000000000016531240331347200326260ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_MAJOR_VERSION_HPP_20101120 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_MAJOR_VERSION_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; template inline typename enable_if, void>::type major_version( basic_request& request, boost::uint8_t major_version_) { request.http_version_major = major_version_; } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_MAJOR_VERSION_HPP_20101120 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/method.hpp000066400000000000000000000015151240331347200312260ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_METHOD_HPP_20101118 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_METHOD_HPP_20101118 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct basic_request; template inline typename enable_if, void>::type method( basic_request& request, typename string::type const& method_) { request.method = method_; } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_METHOD_HPP_20101118 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/minor_version.hpp000066400000000000000000000016531240331347200326420ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_MINOR_VERSION_HPP_20101120 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_MINOR_VERSION_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; template inline typename enable_if, void>::type minor_version( basic_request& request, boost::uint8_t minor_version_) { request.http_version_minor = minor_version_; } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_MINOR_VERSION_HPP_20101120 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/source.hpp000066400000000000000000000047261240331347200312550ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_SOURCE_HPP_20100624 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_SOURCE_HPP_20100624 // Copyright 2010 (C) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_response; namespace impl { template void source(basic_response &response, T const &value, mpl::false_ const &) { response << ::boost::network::source(value); } template void source(basic_response &response, T const &future, mpl::true_ const &) { response.source(future); } template void source(basic_request &request, T const &value, tags::server const &) { request.source = value; } template void source(basic_request &request, T const &value, tags::client const &) { request << ::boost::network::source(value); } } template inline void source(basic_response &response, T const &value) { impl::source(response, value, is_async()); } template inline void source_impl(basic_request &request, T const &value, tags::server) { impl::source(request, value, Tag()); } template inline void source_impl(basic_request &request, T const &value, tags::client) { impl::source(request, value, Tag()); } template inline void source(basic_request &request, T const &value) { source_impl(request, value, typename client_or_server::type()); } } // namespace http namespace impl { template inline void source(Message const &message, ValueType const &source_, http::tags::http_server const &, Async const &) { message.source = source_; } } /* impl */ } // namespace network } // namespace boost #include #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIER_SOURCE_HPP_20100624 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/status.hpp000066400000000000000000000023171240331347200312720ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_STATUS_HPP_20100608 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_STATUS_HPP_20100608 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct basic_response; namespace impl { template void status(basic_response &response, T const &value, mpl::false_ const &) { response << boost::network::http::status(value); } template void status(basic_response &response, T const &future, mpl::true_ const &) { response.status(future); } } // namespace impl template void status(basic_response &response, T const &value) { impl::status(response, value, is_async()); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_STATUS_HPP_20100608 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/status_message.hpp000066400000000000000000000024471240331347200330020ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_STATUS_MESSAGE_HPP_20100608 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_STATUS_MESSAGE_HPP_20100608 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct basic_response; namespace impl { template void status_message(basic_response &response, T const &value, mpl::false_ const &) { response << boost::network::http::status_message(value); } template void status_message(basic_response &response, T const &future, mpl::true_ const &) { response.status_message(future); } } // namespace impl template void status_message(basic_response &response, T const &value) { impl::status_message(response, value, is_async()); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_STATUS_MESSAGE_HPP_20100608 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/uri.hpp000066400000000000000000000014601240331347200305440ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_URI_HPP_20100621 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_URI_HPP_20100621 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct basic_request; template void uri(basic_request& request, T const& value) { request.uri(value); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_URI_HPP_20100621 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/modifiers/version.hpp000066400000000000000000000024431240331347200314340ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_VERSION_HPP_20100608 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_VERSION_HPP_20100608 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_response; namespace impl { template void version(basic_response &response, T const &value, mpl::false_ const &) { response << boost::network::http::version(value); } template void version(basic_response &response, T const &future, mpl::true_ const &) { response.version(future); } } // namespace impl template void version(basic_response &response, T const &value) { impl::version(response, value, is_async()); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_MODIFIERS_VERSION_HPP_20100608 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/traits/000077500000000000000000000000001240331347200265605ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/traits/status.hpp000066400000000000000000000016571240331347200306250ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_STATUS_HPP_20100903 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_STATUS_HPP_20100903 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { namespace traits { template struct unsupported_tag; template struct status : mpl::if_< is_async, boost::shared_future, typename mpl::if_, boost::uint16_t, unsupported_tag >::type> {}; } /* traits */ } /* http */ } /* network */ } /* boost */ #endif cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/traits/status_message.hpp000066400000000000000000000023041240331347200323170ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_STATUS_MESSAGE_HPP_20100903 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_STATUS_MESSAGE_HPP_20100903 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { namespace traits { template struct unsupported_tag; template struct status_message : mpl::if_< is_async, boost::shared_future::type>, typename mpl::if_< mpl::or_, is_same, is_same >, typename string::type, unsupported_tag >::type> {}; } /* traits */ } /* http */ } /* network */ } /* boost */ #endif cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/traits/version.hpp000066400000000000000000000026511240331347200307620ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_VERSION_HPP_20100903 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_VERSION_HPP_20100903 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace http { namespace traits { template struct unsupported_tag; template struct version { typedef unsupported_tag type; }; template struct version >::type> { typedef boost::shared_future::type> type; }; template struct version< Message, typename enable_if< mpl::or_, is_default_string, is_default_wstring > >::type> { typedef typename string::type type; }; } /* traits */ } /* http */ } /* network */ } /* boost */ #endif cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/000077500000000000000000000000001240331347200271155ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/anchor.hpp000066400000000000000000000020641240331347200311020ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_ANCHOR_HPP_20100618 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_ANCHOR_HPP_20100618 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_request; namespace impl { template struct anchor_wrapper { basic_request const& message_; anchor_wrapper(basic_request const& message) : message_(message) {} typedef typename basic_request::string_type string_type; operator string_type() { return message_.anchor(); } }; } template inline impl::anchor_wrapper anchor(basic_request const& request) { return impl::anchor_wrapper(request); } } // namespace http } // namespace network } // nmaespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_ANCHOR_HPP_20100618 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/body.hpp000066400000000000000000000034401240331347200305640ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_BODY_HPP_20100622 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_BODY_HPP_20100622 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_response; template struct basic_request; namespace impl { template struct body_wrapper { typedef typename string::type string_type; Message const& message_; explicit body_wrapper(Message const& message) : message_(message) {} body_wrapper(body_wrapper const& other) : message_(other.message_) {} operator string_type() const { return message_.body(); } size_t size() const { return message_.body().size(); } boost::iterator_range range() const { return boost::make_iterator_range(message_.body()); } }; template inline std::ostream& operator<<(std::ostream& os, body_wrapper const& body) { os << static_cast::string_type>(body); return os; } } // namespace impl template inline typename impl::body_wrapper > body( basic_response const& message) { return impl::body_wrapper >(message); } template inline typename impl::body_wrapper > body( basic_request const& message) { return impl::body_wrapper >(message); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_BODY_HPP_20100622 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/destination.hpp000066400000000000000000000015121240331347200321460ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DESTINATION_HPP_20100624 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DESTINATION_HPP_20100624 // Copyright 2010 (c) Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { template struct basic_response; template struct basic_request; template struct Request; template struct Response; BOOST_NETWORK_DEFINE_HTTP_WRAPPER(destination, destination, destination); } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_DESTINATION_HPP_20100624 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/headers.hpp000066400000000000000000000071011240331347200312400ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPER_HEADERS_HPP_20100811 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPER_HEADERS_HPP_20100811 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct headers_range { typedef typename headers_container::type headers_container_type; typedef typename boost::iterator_range< typename headers_container_type::const_iterator> type; }; template struct basic_request; template struct basic_response; namespace impl { template struct request_headers_wrapper { typedef typename string::type string_type; typedef typename headers_range >::type range_type; typedef typename headers_container::type headers_container_type; typedef typename headers_container_type::const_iterator const_iterator; typedef typename headers_container_type::iterator iterator; explicit request_headers_wrapper(basic_request const& message) : message_(message) {} range_type operator[](string_type const& key) const { return message_.headers().equal_range(key); } typename headers_container_type::size_type count(string_type const& key) const { return message_.headers().count(key); } const_iterator begin() const { return message_.headers().begin(); } const_iterator end() const { return message_.headers().end(); } operator range_type() { return make_iterator_range(message_.headers().begin(), message_.headers().end()); } operator headers_container_type() { return message_.headers(); } private: basic_request const& message_; }; template struct response_headers_wrapper { typedef typename string::type string_type; typedef typename headers_range >::type range_type; typedef typename headers_container::type headers_container_type; typedef typename headers_container_type::const_iterator const_iterator; typedef typename headers_container_type::iterator iterator; explicit response_headers_wrapper(basic_response const& message) : message_(message) {} range_type operator[](string_type const& key) const { return message_.headers().equal_range(key); } typename headers_container_type::size_type count(string_type const& key) const { return message_.headers().count(key); } const_iterator begin() const { return message_.headers().begin(); } const_iterator end() const { return message_.headers().end(); } operator range_type() { return make_iterator_range(message_.headers().begin(), message_.headers().end()); } operator headers_container_type() { return message_.headers(); } private: basic_response const& message_; }; } // namespace impl template inline impl::request_headers_wrapper headers( basic_request const& request_) { return impl::request_headers_wrapper(request_); } template inline impl::response_headers_wrapper headers( basic_response const& response_) { return impl::response_headers_wrapper(response_); } } // namepace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPER_HEADERS_HPP_20100811 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/helper.hpp000066400000000000000000000074701240331347200311150ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_HELPER_20101013 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_HELPER_20101013 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #ifndef BOOST_NETWORK_DEFINE_HTTP_WRAPPER #define BOOST_NETWORK_DEFINE_HTTP_WRAPPER(name, accessor, pod_field) \ struct name##_pod_accessor { \ protected: \ template \ typename Message::string_type const& get_value(Message const& message) \ const { \ return message.pod_field; \ } \ }; \ \ struct name##_member_accessor { \ protected: \ template \ typename Message::string_type get_value(Message const& message) const { \ return message.accessor(); \ } \ }; \ \ template \ struct name##_wrapper_impl \ : mpl::if_, name##_pod_accessor, \ name##_member_accessor> {}; \ \ template \ struct name##_wrapper : name##_wrapper_impl::type { \ typedef typename string::type string_type; \ Message const& message_; \ name##_wrapper(Message const& message) : message_(message) {} \ name##_wrapper(name##_wrapper const& other) : message_(other.message_) {} \ operator string_type() const { return this->get_value(message_); } \ }; \ \ template \ inline name##_wrapper > const name( \ basic_response const& message) { \ return name##_wrapper >(message); \ } \ \ template \ inline name##_wrapper > const name( \ basic_request const& message) { \ return name##_wrapper >(message); \ } #endif /* BOOST_NETWORK_DEFINE_HTTP_WRAPPER */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_HELPER_20101013 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/host.hpp000066400000000000000000000020131240331347200305770ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HOST_HPP_20100618 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HOST_HPP_20100618 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_request; namespace impl { template struct host_wrapper { basic_request const& message_; host_wrapper(basic_request const& message) : message_(message) {} typedef typename basic_request::string_type string_type; operator string_type() { return message_.host(); } }; } template inline impl::host_wrapper host(basic_request const& request) { return impl::host_wrapper(request); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_HOST_HPP_20100618 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/major_version.hpp000066400000000000000000000022401240331347200325010ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_MAJOR_VERSION_HPP_20101120 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_MAJOR_VERSION_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; template struct major_version_wrapper { basic_request const& request; explicit major_version_wrapper(basic_request const& request) : request(request) {} operator boost::uint8_t() { return request.http_version_major; } }; template inline typename enable_if, major_version_wrapper >::type major_version(basic_request const& request) { return major_version_wrapper(request); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_MAJOR_VERSION_HPP_20101120 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/method.hpp000066400000000000000000000021741240331347200311120ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_METHOD_HPP_20101118 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_METHOD_HPP_20101118 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct basic_request; template struct method_wrapper { explicit method_wrapper(basic_request const& message) : message_(message) {} basic_request const& message_; typedef typename basic_request::string_type string_type; operator string_type() { return message_.method; } }; template inline typename enable_if, typename string::type>::type method(basic_request const& message) { return method_wrapper(message); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_METHOD_HPP_20101118 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/minor_version.hpp000066400000000000000000000022401240331347200325150ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_MINOR_VERSION_HPP_20101120 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_MINOR_VERSION_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; template struct minor_version_wrapper { basic_request const& request; explicit minor_version_wrapper(basic_request const& request) : request(request) {} operator boost::uint8_t() { return request.http_version_minor; } }; template inline typename enable_if, minor_version_wrapper >::type minor_version(basic_request const& request) { return minor_version_wrapper(request); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_MINOR_VERSION_HPP_20101120 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/path.hpp000066400000000000000000000020131240331347200305560ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PATH_HPP_20100618 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PATH_HPP_20100618 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_request; namespace impl { template struct path_wrapper { basic_request const& message_; path_wrapper(basic_request const& message) : message_(message) {} typedef typename basic_request::string_type string_type; operator string_type() { return message_.path(); } }; } template inline impl::path_wrapper path(basic_request const& request) { return impl::path_wrapper(request); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PATH_HPP_20100618 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/port.hpp000066400000000000000000000034261240331347200306170ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PORT_HPP_20100618 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PORT_HPP_20100618 // Copyright 2010, 2014 Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Copyright 2014 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct basic_request; namespace impl { template struct port_wrapper { basic_request const& message_; port_wrapper(basic_request const& message) : message_(message) {} typedef typename basic_request::port_type port_type; operator port_type() const { return message_.port(); } #if (_MSC_VER >= 1600) // We hack this so that we don't run into the issue of MSVC 2010 not doing the // right thing when converting/copying Boost.Optional objects. struct optional_wrapper { boost::optional o_; explicit optional_wrapper(boost::optional o) : o_(o) {} operator boost::optional() const { return o_; } }; operator optional_wrapper() const { return optional_wrapper(uri::port_us(message_.uri())); } #else operator boost::optional() const { return uri::port_us(message_.uri()); } #endif }; } // namespace impl template inline impl::port_wrapper port(basic_request const& request) { return impl::port_wrapper(request); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PORT_HPP_20100618 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/protocol.hpp000066400000000000000000000021061240331347200314660ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_PROTOCOL_HPP_20100619 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_PROTOCOL_HPP_20100619 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_request; namespace impl { template struct protocol_wrapper { basic_request const& message_; protocol_wrapper(basic_request const& message) : message_(message) {} typedef typename basic_request::string_type string_type; operator string_type() { return message_.protocol(); } }; } template inline impl::protocol_wrapper protocol(basic_request const& request) { return impl::protocol_wrapper(request); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_PROTOCOL_HPP_20100619 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/query.hpp000066400000000000000000000021031240331347200307670ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_QUERY_HPP_20100618 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_QUERY_HPP_20100618 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_request; namespace impl { template struct query_wrapper { basic_request const& message_; query_wrapper(basic_request const& message) : message_(message) {} typedef typename basic_request::string_type string_type; operator string_type() { return message_.query(); } }; } // namespace impl template inline impl::query_wrapper query(basic_request const& request) { return impl::query_wrapper(request); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_QUERY_HPP_20100618 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/ready.hpp000066400000000000000000000025701240331347200307360ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_READY_HPP_20100618 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_READY_HPP_20100618 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { template struct async_message; namespace impl { template struct ready_wrapper : boost::network::detail::wrapper_base_const > { typedef boost::network::detail::wrapper_base_const > wrapper_base; explicit ready_wrapper(async_message const& message) : wrapper_base(message) {} operator bool() { return wrapper_base::_message.version_.is_ready() && wrapper_base::_message.status_.is_ready() && wrapper_base::_message.status_message_.is_ready() && wrapper_base::_message.headers_.is_ready() && wrapper_base::_message.body_.is_ready(); } }; } // namespace impl template inline bool ready(async_message const& message) { return impl::ready_wrapper(message); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_READY_HPP_20100618 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/source.hpp000066400000000000000000000013751240331347200311340ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_SOURCE_HPP_20100622 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_SOURCE_HPP_20100622 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { template struct basic_response; template struct basic_request; BOOST_NETWORK_DEFINE_HTTP_WRAPPER(source, source, source); } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_SOURCE_HPP_20100622 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/status.hpp000066400000000000000000000022731240331347200311550ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_STATUS_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_STATUS_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { template struct basic_response; namespace impl { template struct status_wrapper { basic_response const& response_; explicit status_wrapper(basic_response const& response) : response_(response) {} status_wrapper(status_wrapper const& other) : response_(other.response_) {} operator boost::uint16_t() { return response_.status(); } }; } // namespace impl template struct Response; template inline impl::status_wrapper status(basic_response const& response) { return impl::status_wrapper(response); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_STATUS_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/status_message.hpp000066400000000000000000000031141240331347200326540ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_STATUS_MESSAGE_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_STATUS_MESSAGE_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Copyright 2014 (c) Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { template struct basic_response; namespace impl { template struct status_message_wrapper { typedef typename string::type string_type; basic_response const& response_; explicit status_message_wrapper(basic_response const& response) : response_(response) {} status_message_wrapper(status_message_wrapper const& other) : response_(other.response_) {} operator string_type() const { return response_.status_message(); } }; template inline std::ostream& operator<<(std::ostream& os, const status_message_wrapper& wrapper) { return os << static_cast::type>(wrapper); } } // namespace impl template inline impl::status_message_wrapper status_message( basic_response const& response) { return impl::status_message_wrapper(response); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPER_STATUS_MESSAGE_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/uri.hpp000066400000000000000000000022061240331347200304250ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_URI_HPP_20100620 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_URI_HPP_20100620 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { template struct basic_request; namespace impl { template struct uri_wrapper { basic_request const& message_; uri_wrapper(basic_request const& message) : message_(message) {} typedef typename basic_request::string_type string_type; operator string_type() { return message_.uri().raw(); } operator boost::network::uri::uri() { return message_.uri(); } }; } template inline impl::uri_wrapper uri(basic_request const& request) { return impl::uri_wrapper(request); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_URI_HPP_20100620 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/message/wrappers/version.hpp000066400000000000000000000022621240331347200313150ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_VERSION_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_VERSION_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace boost { namespace network { namespace http { template struct basic_response; namespace impl { template struct version_wrapper { typedef typename string::type string_type; basic_response const& response_; explicit version_wrapper(basic_response const& response) : response_(response) {} version_wrapper(version_wrapper const& other) : response_(other.response_) {} operator string_type() { return response_.version(); } }; } // namespace impl template inline impl::version_wrapper version(basic_response const& response) { return impl::version_wrapper(response); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_WRAPPERS_VERSION_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/parser.hpp000066400000000000000000000246441240331347200256450ustar00rootroot00000000000000// This file is part of the Boost Network library // Based on the Pion Network Library (r421) // Copyright Atomic Labs, Inc. 2007-2008 // See http://cpp-netlib.sourceforge.net for library home page. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_HPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_HPP #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { // forward declarations used to finish HTTP requests template class basic_request; // forward declarations used to finish HTTP requests template class basic_response; /// an incremental HTTP 1.0/1.1 protocol parser template > class basic_parser : private boost::noncopyable { public: // import types from ParserTraits template typedef ParserTraits traits_type; typedef typename string::type string_type; // default destructor virtual ~basic_parser() {} /** * creates a new HTTP protocol parser * * @param is_request if true, the message is parsed as an HTTP request; * if false, the message is parsed as an HTTP response */ basic_parser(const bool is_request) : m_is_request(is_request), m_read_ptr(NULL), m_read_end_ptr(NULL), m_headers_parse_state(is_request ? PARSE_METHOD_START : PARSE_HTTP_VERSION_H), m_chunked_content_parse_state(PARSE_CHUNK_SIZE_START), m_status_code(0), m_bytes_last_read(0), m_bytes_total_read(0) {} /** * parses an HTTP message up to the end of the headers using bytes * available in the read buffer * * @param http_msg the HTTP message object to populate from parsing * * @return boost::tribool result of parsing: * false = message has an error, * true = finished parsing HTTP headers, * indeterminate = not yet finished parsing HTTP *headers */ boost::tribool parse_http_headers(basic_message& http_msg); /** * parses a chunked HTTP message-body using bytes available in the read *buffer * * @param chunk_buffers buffers to be populated from parsing chunked *content * * @return boost::tribool result of parsing: * false = message has an error, * true = finished parsing message, * indeterminate = message is not yet finished */ boost::tribool parse_chunks(types::chunk_cache_t& chunk_buffers); /** * prepares the payload content buffer and consumes any content *remaining * in the parser's read buffer * * @param http_msg the HTTP message object to consume content for * @return unsigned long number of content bytes consumed, if any */ std::size_t consume_content(basic_message& http_msg); /** * consume the bytes available in the read buffer, converting them into * the next chunk for the HTTP message * * @param chunk_buffers buffers to be populated from parsing chunked *content * @return unsigned long number of content bytes consumed, if any */ std::size_t consume_content_as_next_chunk( types::chunk_cache_t& chunk_buffers); /** * finishes parsing an HTTP request message (copies over request-only *data) * * @param http_request the HTTP request object to finish */ void finish(basic_request& http_request); /** * finishes an HTTP response message (copies over response-only data) * * @param http_request the HTTP response object to finish */ void finish(basic_response& http_response); /** * resets the location and size of the read buffer * * @param ptr pointer to the first bytes available to be read * @param len number of bytes available to be read */ inline void set_read_buffer(const char* ptr, std::size_t len) { m_read_ptr = ptr; m_read_end_ptr = ptr + len; } /** * saves the current read position bookmark * * @param read_ptr points to the next character to be consumed in the *read_buffer * @param read_end_ptr points to the end of the read_buffer (last byte + *1) */ inline void save_read_position(const char*& read_ptr, const char*& read_end_ptr) const { read_ptr = m_read_ptr; read_end_ptr = m_read_end_ptr; } /// resets the parser to its initial state inline void reset(void); /// returns true if there are no more bytes available in the read buffer inline bool eof(void) const { return m_read_ptr == NULL || m_read_ptr >= m_read_end_ptr; } /// returns the number of bytes read during the last parse operation inline std::size_t gcount(void) const { return m_bytes_last_read; } /// returns the total number of bytes read while parsing the HTTP /// message inline std::size_t bytes_read(void) const { return m_bytes_total_read; } /// returns the number of bytes available in the read buffer inline std::size_t bytes_available(void) const { return (eof() ? 0 : (m_read_end_ptr - m_read_ptr)); } protected: /** * parse key-value pairs out of a url-encoded string * (i.e. this=that&a=value) * * @param params container for key-values string pairs * @param ptr points to the start of the encoded string * @param len length of the encoded string, in bytes * * @return bool true if successful */ static bool parse_url_encoded(types::query_params& params, const char* ptr, const std::size_t len); /** * parse key-value pairs out of a "Cookie" request header * (i.e. this=that; a=value) * * @param params container for key-values string pairs * @param cookie_header header string to be parsed * * @return bool true if successful */ static bool parse_cookie_header(types::cookie_params& params, const string_type& cookie_header); /// true if the message is an HTTP request; false if it is an HTTP /// response const bool m_is_request; /// points to the next character to be consumed in the read_buffer const char* m_read_ptr; /// points to the end of the read_buffer (last byte + 1) const char* m_read_end_ptr; private: // returns true if the argument is a special character inline static bool is_special(int c) { switch (c) { case '(': case ')': case '<': case '>': case '@': case ',': case ';': case ':': case '\\': case '"': case '/': case '[': case ']': case '?': case '=': case '{': case '}': case ' ': case '\t': return true; default: return false; } } // returns true if the argument is a character inline static bool is_char(int c) { return (c >= 0 && c <= 127); } // returns true if the argument is a control character inline static bool is_control(int c) { return ((c >= 0 && c <= 31) || c == 127); } // returns true if the argument is a digit inline static bool is_digit(int c) { return (c >= '0' && c <= '9'); } // returns true if the argument is a hexadecimal digit inline static bool is_hex_digit(int c) { return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); } /// state used to keep track of where we are in parsing the HTTP headers enum headers_parse_state_t { PARSE_METHOD_START, PARSE_METHOD, PARSE_URI_STEM, PARSE_URI_QUERY, PARSE_HTTP_VERSION_H, PARSE_HTTP_VERSION_T_1, PARSE_HTTP_VERSION_T_2, PARSE_HTTP_VERSION_P, PARSE_HTTP_VERSION_SLASH, PARSE_HTTP_VERSION_MAJOR_START, PARSE_HTTP_VERSION_MAJOR, PARSE_HTTP_VERSION_MINOR_START, PARSE_HTTP_VERSION_MINOR, PARSE_STATUS_CODE_START, PARSE_STATUS_CODE, PARSE_STATUS_MESSAGE, PARSE_EXPECTING_NEWLINE, PARSE_EXPECTING_CR, PARSE_HEADER_WHITESPACE, PARSE_HEADER_START, PARSE_HEADER_NAME, PARSE_SPACE_BEFORE_HEADER_VALUE, PARSE_HEADER_VALUE, PARSE_EXPECTING_FINAL_NEWLINE, PARSE_EXPECTING_FINAL_CR }; /// state used to keep track of where we are in parsing chunked content enum chunked_content_parse_state_t { PARSE_CHUNK_SIZE_START, PARSE_CHUNK_SIZE, PARSE_EXPECTING_CR_AFTER_CHUNK_SIZE, PARSE_EXPECTING_LF_AFTER_CHUNK_SIZE, PARSE_CHUNK, PARSE_EXPECTING_CR_AFTER_CHUNK, PARSE_EXPECTING_LF_AFTER_CHUNK, PARSE_EXPECTING_FINAL_CR_AFTER_LAST_CHUNK, PARSE_EXPECTING_FINAL_LF_AFTER_LAST_CHUNK }; /// the current state of parsing HTTP headers headers_parse_state_t m_headers_parse_state; /// the current state of parsing chunked content chunked_content_parse_state_t m_chunked_content_parse_state; /// Used for parsing the HTTP response status code boost::uint16_t m_status_code; /// Used for parsing the HTTP response status message string_type m_status_message; /// Used for parsing the request method string_type m_method; /// Used for parsing the name of resource requested string_type m_resource; /// Used for parsing the query string portion of a URI string_type m_query_string; /// Used for parsing the name of HTTP headers string_type m_header_name; /// Used for parsing the value of HTTP headers string_type m_header_value; /// Used for parsing the chunk size string_type m_chunk_size_str; /// Used for parsing the current chunk std::vector m_current_chunk; /// number of bytes in the chunk currently being parsed std::size_t m_size_of_current_chunk; /// number of bytes read so far in the chunk currently being parsed std::size_t m_bytes_read_in_current_chunk; /// number of bytes read during last parse operation std::size_t m_bytes_last_read; /// total number of bytes read while parsing the HTTP message std::size_t m_bytes_total_read; }; /// typedef for the default HTTP protocol parser implementation typedef basic_parser parser; }; // namespace http }; // namespace network }; // namespace boost // import implementation file #include #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/parser/000077500000000000000000000000001240331347200251225ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/parser/incremental.hpp000066400000000000000000000222021240331347200301320ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_INCREMENTAL_HPP_20100909 #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_INCREMENTAL_HPP_20100909 // Copyright Dean Michael Berris 2010. // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct response_parser { enum state_t { http_response_begin, http_version_h, http_version_t1, http_version_t2, http_version_p, http_version_slash, http_version_major, http_version_dot, http_version_minor, http_version_done, http_status_digit, http_status_done, http_status_message_char, http_status_message_cr, http_status_message_done, http_header_name_char, http_header_colon, http_header_value_char, http_header_line_cr, http_header_line_done, http_headers_end_cr, http_headers_done }; explicit response_parser(state_t state = http_response_begin) : state_(state) {} response_parser(response_parser const& other) : state_(other.state_) {} ~response_parser() {} void swap(response_parser& other) { std::swap(other.state_, this->state_); } response_parser& operator=(response_parser rhs) { rhs.swap(*this); return *this; } template fusion::tuple > parse_until(state_t stop_state, Range& range_) { logic::tribool parsed_ok(logic::indeterminate); typename Range::const_iterator start = boost::begin(range_), current = start, end = boost::end(range_); boost::iterator_range local_range = boost::make_iterator_range(start, end); while (!boost::empty(local_range) && indeterminate(parsed_ok)) { current = boost::begin(local_range); if (state_ == stop_state) { parsed_ok = true; } else { switch (state_) { case http_response_begin: if (*current == ' ' || *current == '\r' || *current == '\n') { // skip valid leading whitespace ++start; ++current; } else if (*current == 'H') { state_ = http_version_h; start = current; ++current; } else { parsed_ok = false; } break; case http_version_h: if (*current == 'T') { state_ = http_version_t1; ++current; } else { parsed_ok = false; } break; case http_version_t1: if (*current == 'T') { state_ = http_version_t2; ++current; } else { parsed_ok = false; } break; case http_version_t2: if (*current == 'P') { state_ = http_version_p; ++current; } else { parsed_ok = false; } break; case http_version_p: if (*current == '/') { state_ = http_version_slash; ++current; } else { parsed_ok = false; } break; case http_version_slash: if (algorithm::is_digit()(*current)) { state_ = http_version_major; ++current; } else { parsed_ok = false; } break; case http_version_major: if (*current == '.') { state_ = http_version_dot; ++current; } else { parsed_ok = false; } break; case http_version_dot: if (algorithm::is_digit()(*current)) { state_ = http_version_minor; ++current; } else { parsed_ok = false; } break; case http_version_minor: if (*current == ' ') { state_ = http_version_done; ++current; } else { parsed_ok = false; } break; case http_version_done: if (algorithm::is_digit()(*current)) { state_ = http_status_digit; ++current; } else { parsed_ok = false; } break; case http_status_digit: if (algorithm::is_digit()(*current)) { ++current; } else if (*current == ' ') { state_ = http_status_done; ++current; } else if (*current == '\r' || *current == '\n') { state_ = http_status_done; } else { parsed_ok = false; } break; case http_status_done: if (*current == ' ') { ++current; } else if (*current == '\r') { state_ = http_status_message_cr; ++current; } else if (*current == '\n') { state_ = http_status_message_done; ++current; } else { state_ = http_status_message_char; ++current; } break; case http_status_message_char: if (*current == '\r') { state_ = http_status_message_cr; ++current; } else if (*current == '\n') { state_ = http_status_message_done; ++current; } else { ++current; } break; case http_status_message_cr: if (*current == '\n') { state_ = http_status_message_done; ++current; } else { parsed_ok = false; } break; case http_status_message_done: case http_header_line_done: if (*current == ' ') { ++current; } else if (algorithm::is_alnum()(*current) || algorithm::is_punct()(*current)) { state_ = http_header_name_char; ++current; } else if (*current == '\r') { state_ = http_headers_end_cr; ++current; } else if (*current == '\n') { state_ = http_headers_done; ++current; } else { parsed_ok = false; } break; case http_header_name_char: if (*current == ':') { state_ = http_header_colon; ++current; } else if (*current == '\r') { state_ = http_header_line_cr; ++current; } else if (*current == '\n') { state_ = http_header_line_done; ++current; } else if (algorithm::is_alnum()(*current) || algorithm::is_space()(*current) || algorithm::is_punct()(*current)) { ++current; } else { parsed_ok = false; } break; case http_header_colon: if (*current == '\r') { state_ = http_header_line_cr; ++current; } else if (*current == '\n') { state_ = http_header_line_done; ++current; } else if (algorithm::is_space()(*current)) { ++current; } else { state_ = http_header_value_char; ++current; } break; case http_header_value_char: if (*current == '\r') { state_ = http_header_line_cr; ++current; } else if (*current == '\n') { state_ = http_header_line_done; ++current; } else { ++current; } break; case http_header_line_cr: if (*current == '\n') { state_ = http_header_line_done; ++current; } else { parsed_ok = false; } break; case http_headers_end_cr: if (*current == '\n') { state_ = http_headers_done; ++current; } else { parsed_ok = false; } break; default: parsed_ok = false; } } local_range = boost::make_iterator_range(current, end); } if (state_ == stop_state) parsed_ok = true; return fusion::make_tuple(parsed_ok, boost::make_iterator_range(start, current)); } state_t state() { return state_; } void reset(state_t new_state = http_response_begin) { state_ = new_state; } private: state_t state_; }; } /* http */ } /* network */ } /* boost */ #endif cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/policies/000077500000000000000000000000001240331347200254355ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/policies/async_connection.hpp000066400000000000000000000105701240331347200315050ustar00rootroot00000000000000#ifndef BOOST_NETWORK_POLICY_ASYNC_CONNECTION_HPP_20100529 #define BOOST_NETWORK_POLICY_ASYNC_CONNECTION_HPP_20100529 // Copyright 2010 (C) Dean Michael Berris // Copyright 2010 (C) Sinefunc, Inc. // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct async_connection_policy : resolver_policy::type { protected: typedef typename string::type string_type; typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef typename resolver_base::resolve_function resolve_function; typedef function const&, system::error_code const&)> body_callback_function_type; typedef function body_generator_function_type; struct connection_impl { connection_impl(bool follow_redirect, bool always_verify_peer, resolve_function resolve, resolver_type& resolver, bool https, int timeout, optional const& certificate_filename, optional const& verify_path, optional const& certificate_file, optional const& private_key_file) { pimpl = impl::async_connection_base< Tag, version_major, version_minor>::new_connection(resolve, resolver, follow_redirect, always_verify_peer, https, timeout, certificate_filename, verify_path, certificate_file, private_key_file); } basic_response send_request(string_type const& method, basic_request const& request_, bool get_body, body_callback_function_type callback, body_generator_function_type generator) { return pimpl->start(request_, method, get_body, callback, generator); } private: shared_ptr > pimpl; }; typedef boost::shared_ptr connection_ptr; connection_ptr get_connection( resolver_type& resolver, basic_request const& request_, bool always_verify_peer, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) { string_type protocol_ = protocol(request_); connection_ptr connection_(new connection_impl( follow_redirect_, always_verify_peer, boost::bind(&async_connection_policy::resolve, this, boost::arg<1>(), boost::arg<2>(), boost::arg<3>(), boost::arg<4>()), resolver, boost::iequals(protocol_, string_type("https")), timeout_, certificate_filename, verify_path, certificate_file, private_key_file)); return connection_; } void cleanup() {} async_connection_policy(bool cache_resolved, bool follow_redirect, int timeout) : resolver_base(cache_resolved), follow_redirect_(follow_redirect), timeout_(timeout) {} bool follow_redirect_; int timeout_; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_POLICY_ASYNC_CONNECTION_HPP_ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/policies/async_resolver.hpp000066400000000000000000000066551240331347200312200ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_ASYNC_RESOLVER_20100622 #define BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_ASYNC_RESOLVER_20100622 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { namespace policies { template struct async_resolver : boost::enable_shared_from_this > { typedef typename resolver::type resolver_type; typedef typename resolver_type::iterator resolver_iterator; typedef typename resolver_type::query resolver_query; typedef std::pair resolver_iterator_pair; typedef typename string::type string_type; typedef boost::unordered_map endpoint_cache; typedef boost::function< void(boost::system::error_code const &, resolver_iterator_pair)> resolve_completion_function; typedef boost::function resolve_function; protected: bool cache_resolved_; endpoint_cache endpoint_cache_; boost::shared_ptr service_; boost::shared_ptr resolver_strand_; explicit async_resolver(bool cache_resolved) : cache_resolved_(cache_resolved), endpoint_cache_() {} void resolve(resolver_type &resolver_, string_type const &host, boost::uint16_t port, resolve_completion_function once_resolved) { if (cache_resolved_) { typename endpoint_cache::iterator iter = endpoint_cache_.find(boost::to_lower_copy(host)); if (iter != endpoint_cache_.end()) { boost::system::error_code ignored; once_resolved(ignored, iter->second); return; } } typename resolver_type::query q(resolver_type::protocol_type::v4(), host, lexical_cast(port)); resolver_.async_resolve(q, resolver_strand_->wrap(boost::bind( &async_resolver::handle_resolve, async_resolver::shared_from_this(), boost::to_lower_copy(host), once_resolved, boost::asio::placeholders::error, boost::asio::placeholders::iterator))); } void handle_resolve(string_type const &host, resolve_completion_function once_resolved, boost::system::error_code const &ec, resolver_iterator endpoint_iterator) { typename endpoint_cache::iterator iter; bool inserted = false; if (!ec && cache_resolved_) { boost::fusion::tie(iter, inserted) = endpoint_cache_.insert(std::make_pair( host, std::make_pair(endpoint_iterator, resolver_iterator()))); once_resolved(ec, iter->second); } else { once_resolved(ec, std::make_pair(endpoint_iterator, resolver_iterator())); } } }; } // namespace policies } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_ASYNC_RESOLVER_20100622 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/policies/pooled_connection.hpp000066400000000000000000000225541240331347200316570ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_POOLED_CONNECTION_POLICY_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_POOLED_CONNECTION_POLICY_20091214 // Copyright 2013 Google, Inc. // Copyright 2009 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #ifndef BOOST_NETWORK_HTTP_MAXIMUM_REDIRECT_COUNT #define BOOST_NETWORK_HTTP_MAXIMUM_REDIRECT_COUNT 5 #endif // BOOST_NETWORK_HTTP_MAXIMUM_REDIRECT_COUNT namespace boost { namespace network { namespace http { template struct pooled_connection_policy : resolver_policy::type { protected: typedef typename string::type string_type; typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef function resolver_function_type; typedef function const&, system::error_code const&)> body_callback_function_type; typedef function body_generator_function_type; void cleanup() { host_connection_map().swap(host_connections); } struct connection_impl { typedef function( resolver_type&, basic_request const&, optional const&, optional const&, optional const&, optional const&)> get_connection_function; connection_impl( resolver_type& resolver, bool follow_redirect, string_type const& host, string_type const& port, resolver_function_type resolve, get_connection_function get_connection, bool https, bool always_verify_peer, int timeout, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) : pimpl(impl::sync_connection_base:: new_connection(resolver, resolve, https, always_verify_peer, timeout, certificate_filename, verify_path, certificate_file, private_key_file)), resolver_(resolver), connection_follow_redirect_(follow_redirect), get_connection_(get_connection), certificate_filename_(certificate_filename), verify_path_(verify_path), certificate_file_(certificate_file), private_key_file_(private_key_file) {} basic_response send_request(string_type const& method, basic_request request_, bool get_body, body_callback_function_type callback, body_generator_function_type generator) { return send_request_impl(method, request_, get_body, callback, generator); } private: basic_response send_request_impl( string_type const& method, basic_request request_, bool get_body, body_callback_function_type callback, body_generator_function_type generator) { boost::uint8_t count = 0; bool retry = false; do { if (count >= BOOST_NETWORK_HTTP_MAXIMUM_REDIRECT_COUNT) boost::throw_exception(std::runtime_error( "Redirection exceeds maximum redirect count.")); basic_response response_; // check if the socket is open first if (!pimpl->is_open()) { pimpl->init_socket(request_.host(), lexical_cast(request_.port())); } response_ = basic_response(); response_ << ::boost::network::source(request_.host()); pimpl->send_request_impl(method, request_, generator); boost::asio::streambuf response_buffer; try { pimpl->read_status(response_, response_buffer); } catch (boost::system::system_error& e) { if (!retry && e.code() == boost::asio::error::eof) { retry = true; pimpl->init_socket(request_.host(), lexical_cast(request_.port())); continue; } throw; // it's a retry, and there's something wrong. } pimpl->read_headers(response_, response_buffer); if (get_body && response_.status() != 304 && (response_.status() != 204) && !(response_.status() >= 100 && response_.status() <= 199)) { pimpl->read_body(response_, response_buffer); } typename headers_range >::type connection_range = headers(response_)["Connection"]; if (version_major == 1 && version_minor == 1 && !empty(connection_range) && boost::begin(connection_range)->second == string_type("close")) { pimpl->close_socket(); } else if (version_major == 1 && version_minor == 0) { pimpl->close_socket(); } if (connection_follow_redirect_) { boost::uint16_t status = response_.status(); if (status >= 300 && status <= 307) { typename headers_range >::type location_range = headers(response_)["Location"]; typename range_iterator< typename headers_range >::type>::type location_header = boost::begin(location_range); if (location_header != boost::end(location_range)) { request_.uri(location_header->second); connection_ptr connection_; connection_ = get_connection_( resolver_, request_, certificate_filename_, verify_path_, certificate_file_, private_key_file_); ++count; continue; } else boost::throw_exception(std::runtime_error( "Location header not defined in redirect response.")); } } return response_; } while (true); } shared_ptr > pimpl; resolver_type& resolver_; bool connection_follow_redirect_; get_connection_function get_connection_; optional certificate_filename_; optional verify_path_; optional certificate_file_; optional private_key_file_; }; typedef shared_ptr connection_ptr; typedef unordered_map host_connection_map; host_connection_map host_connections; bool follow_redirect_; int timeout_; connection_ptr get_connection( resolver_type& resolver, basic_request const& request_, bool always_verify_peer, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) { string_type index = (request_.host() + ':') + lexical_cast(request_.port()); connection_ptr connection_; typename host_connection_map::iterator it = host_connections.find(index); if (it == host_connections.end()) { connection_.reset(new connection_impl( resolver, follow_redirect_, request_.host(), lexical_cast(request_.port()), boost::bind(&pooled_connection_policy::resolve, this, boost::arg<1>(), boost::arg<2>(), boost::arg<3>()), boost::bind(&pooled_connection_policy::get_connection, this, boost::arg<1>(), boost::arg<2>(), always_verify_peer, boost::arg<3>(), boost::arg<4>(), boost::arg<5>(), boost::arg<6>()), boost::iequals(request_.protocol(), string_type("https")), always_verify_peer, timeout_, certificate_filename, verify_path, certificate_file, private_key_file)); host_connections.insert(std::make_pair(index, connection_)); return connection_; } return it->second; } pooled_connection_policy(bool cache_resolved, bool follow_redirect, int timeout) : resolver_base(cache_resolved), host_connections(), follow_redirect_(follow_redirect), timeout_(timeout) {} }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_POOLED_CONNECTION_POLICY_20091214 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/policies/simple_connection.hpp000066400000000000000000000140371240331347200316630ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SIMPLE_CONNECTION_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SIMPLE_CONNECTION_20091214 // Copyright 2013 Google, Inc. // Copyright 2009 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct simple_connection_policy : resolver_policy::type { protected: typedef typename string::type string_type; typedef typename resolver_policy::type resolver_base; typedef typename resolver_base::resolver_type resolver_type; typedef function resolver_function_type; typedef function const&, system::error_code const&)> body_callback_function_type; typedef function body_generator_function_type; struct connection_impl { connection_impl( resolver_type& resolver, bool follow_redirect, bool always_verify_peer, string_type const& hostname, string_type const& port, resolver_function_type resolve, bool https, int timeout, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) : pimpl(), follow_redirect_(follow_redirect) { pimpl.reset(impl::sync_connection_base< Tag, version_major, version_minor>::new_connection(resolver, resolve, https, always_verify_peer, timeout, certificate_filename, verify_path, certificate_file, private_key_file)); } basic_response send_request(string_type const& method, basic_request request_, bool get_body, body_callback_function_type callback, body_generator_function_type generator) { basic_response response_; do { pimpl->init_socket(request_.host(), lexical_cast(request_.port())); pimpl->send_request_impl(method, request_, generator); response_ = basic_response(); response_ << network::source(request_.host()); boost::asio::streambuf response_buffer; pimpl->read_status(response_, response_buffer); pimpl->read_headers(response_, response_buffer); if (get_body) pimpl->read_body(response_, response_buffer); if (follow_redirect_) { boost::uint16_t status = response_.status(); if (status >= 300 && status <= 307) { typename headers_range >::type location_range = headers(response_)["Location"]; typename range_iterator< typename headers_range >::type>::type location_header = boost::begin(location_range); if (location_header != boost::end(location_range)) { request_.uri(location_header->second); } else throw std::runtime_error( "Location header not defined in redirect response."); } else break; } else break; } while (true); return response_; } private: shared_ptr > pimpl; bool follow_redirect_; }; typedef boost::shared_ptr connection_ptr; connection_ptr get_connection( resolver_type& resolver, basic_request const& request_, bool always_verify_peer, optional const& certificate_filename = optional(), optional const& verify_path = optional(), optional const& certificate_file = optional(), optional const& private_key_file = optional()) { connection_ptr connection_(new connection_impl( resolver, follow_redirect_, always_verify_peer, request_.host(), lexical_cast(request_.port()), boost::bind(&simple_connection_policy::resolve, this, boost::arg<1>(), boost::arg<2>(), boost::arg<3>()), boost::iequals(request_.protocol(), string_type("https")), timeout_, certificate_filename, verify_path, certificate_file, private_key_file)); return connection_; } void cleanup() {} simple_connection_policy(bool cache_resolved, bool follow_redirect, int timeout) : resolver_base(cache_resolved), follow_redirect_(follow_redirect), timeout_(timeout) {} // member variables bool follow_redirect_; int timeout_; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SIMPLE_CONNECTION_20091214 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/policies/sync_resolver.hpp000066400000000000000000000046701240331347200310520ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SYNC_RESOLVER_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SYNC_RESOLVER_20091214 // Copyright Dean Michael Berris 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { namespace policies { template struct sync_resolver { typedef typename resolver::type resolver_type; typedef typename resolver_type::iterator resolver_iterator; typedef typename resolver_type::query resolver_query; typedef std::pair resolver_iterator_pair; protected: typedef typename string::type string_type; typedef boost::unordered_map resolved_cache; resolved_cache endpoint_cache_; bool cache_resolved_; sync_resolver(bool cache_resolved) : cache_resolved_(cache_resolved) {} resolver_iterator_pair resolve(resolver_type& resolver_, string_type const& hostname, string_type const& port) { if (cache_resolved_) { typename resolved_cache::iterator cached_iterator = endpoint_cache_.find(hostname); if (cached_iterator == endpoint_cache_.end()) { bool inserted = false; boost::fusion::tie(cached_iterator, inserted) = endpoint_cache_.insert(std::make_pair( boost::to_lower_copy(hostname), std::make_pair( resolver_.resolve(resolver_query( hostname, port, resolver_query::numeric_service)), resolver_iterator()))); }; return cached_iterator->second; }; return std::make_pair(resolver_.resolve(resolver_query( hostname, port, resolver_query::numeric_service)), resolver_iterator()); }; }; } // namespace policies } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SYNC_RESOLVER_20091214 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/request.hpp000066400000000000000000000062361240331347200260360ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __NETWORK_PROTOCOL_HTTP_REQUEST_20070908_1_HPP__ #define __NETWORK_PROTOCOL_HTTP_REQUEST_20070908_1_HPP__ // Implement the HTTP Request Object #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // forward declarations namespace boost { namespace network { namespace http { template struct basic_request; } // namespace http } // namespace network } // namespace boost #include namespace boost { namespace network { namespace http { template basic_request& operator<<(basic_request& message, Directive const& directive) { directive(message); return message; } } // namespace http } // namespace network } // namespace boost #include #endif // __NETWORK_PROTOCOL_HTTP_REQUEST_20070908-1_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/request_concept.hpp000066400000000000000000000061661240331347200275530ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_REQUEST_CONCEPT_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_REQUEST_CONCEPT_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { namespace http { template struct ServerRequest { typedef typename R::string_type string_type; typedef typename R::tag tag; typedef typename R::headers_container_type headers_container_type; BOOST_CONCEPT_USAGE(ServerRequest) { string_type source_, method_, destination_; boost::uint8_t major_version_, minor_version_; headers_container_type headers_; string_type body_; source_ = source(request); method_ = method(request); destination_ = destination(request); major_version_ = major_version(request); minor_version_ = minor_version(request); headers_ = headers(request); body_ = body(request); source(request, source_); method(request, method_); destination(request, destination_); major_version(request, major_version_); minor_version(request, minor_version_); headers(request, headers_); add_header(request, string_type(), string_type()); remove_header(request, string_type()); clear_headers(request); body(request, body_); string_type name, value; request << ::boost::network::source(source_) << ::boost::network::destination(destination_) << ::boost::network::http::method(method_) << ::boost::network::http::major_version(major_version_) << ::boost::network::http::minor_version(minor_version_) << ::boost::network::header(name, value) << ::boost::network::body(body_); (void)source_; (void)method_; (void)destination_; (void)major_version_; (void)minor_version_; (void)headers_; (void)body_; (void)name; (void)value; } private: R request; }; template struct ClientRequest : boost::network::Message { typedef typename R::string_type string_type; typedef typename R::port_type port_type; BOOST_CONCEPT_USAGE(ClientRequest) { string_type tmp; R request_(tmp); swap(request, request_); // swappable via ADL string_type host_ = host(request); port_type port_ = port(request); string_type path_ = path(request); string_type query_ = query(request); string_type anchor_ = anchor(request); string_type protocol_ = protocol(request); request << uri(string_type()); boost::network::http::uri(request, string_type()); (void)host_; (void)port_; (void)path_; (void)query_; (void)anchor_; (void)protocol_; } private: R request; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_REQUEST_CONCEPT_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/request_parser.hpp000066400000000000000000000055021240331347200274050ustar00rootroot00000000000000// // request_parser.hpp // ~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2009 Dean Michael Berris (mikhailberis at gmail dot com) // Copyright (c) 2009 Tarro, Inc. // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Modifications by Dean Michael Berris // #ifndef HTTP_SERVER3_REQUEST_PARSER_HPP #define HTTP_SERVER3_REQUEST_PARSER_HPP #include #include #include namespace boost { namespace network { namespace http { namespace tag { struct default_; } /// Parser for incoming requests. template class basic_request_parser { public: /// Construct ready to parse the request method. basic_request_parser() : state_(method_start) {} /// Reset to initial parser state. void reset() { state_ = method_start; } /// Parse some data. The tribool return value is true when a complete /// request /// has been parsed, false if the data is invalid, indeterminate when /// more /// data is required. The InputIterator return value indicates how much /// of the /// input has been consumed. template boost::tuple parse_headers( basic_request& req, InputIterator begin, InputIterator end) { while (begin != end) { boost::tribool result = consume(req, *begin++); if (result || !result) return boost::make_tuple(result, begin); } boost::tribool result = boost::indeterminate; return boost::make_tuple(result, begin); } private: /// Handle the next character of input. boost::tribool consume(basic_request& req, char input); /// Check if a byte is an HTTP character. static bool is_char(int c); /// Check if a byte is an HTTP control character. static bool is_ctl(int c); /// Check if a byte is defined as an HTTP tspecial character. static bool is_tspecial(int c); /// Check if a byte is a digit. static bool is_digit(int c); /// The current state of the parser. enum state { method_start, method, uri_start, uri, http_version_h, http_version_t_1, http_version_t_2, http_version_p, http_version_slash, http_version_major_start, http_version_major, http_version_minor_start, http_version_minor, expecting_newline_1, header_line_start, header_lws, header_name, space_before_header_value, header_value, expecting_newline_2, expecting_newline_3 } state_; }; } // namespace http } // namespace network } // namespace boost #include #endif // HTTP_SERVER3_REQUEST_PARSER_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/response.hpp000066400000000000000000000061621240331347200262020ustar00rootroot00000000000000// Copyright Dean Michael Berris 2007. // Copyright Michael Dickey 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_RESPONSE_HPP #define BOOST_NETWORK_PROTOCOL_HTTP_RESPONSE_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct basic_response : public message_base::type { typedef typename string::type string_type; private: typedef typename message_base::type base_type; public: typedef Tag tag; basic_response() : base_type() {} basic_response(basic_response const& other) : base_type(other) {} basic_response& operator=(basic_response rhs) { rhs.swap(*this); return *this; }; void swap(basic_response& other) { base_type& base_ref(other), &this_ref(*this); std::swap(this_ref, base_ref); }; }; template inline void swap(basic_response& lhs, basic_response& rhs) { lhs.swap(rhs); } } // namespace http } // namespace network } // namespace boost #include namespace boost { namespace network { namespace http { template basic_response& operator<<(basic_response& message, Directive const& directive) { directive(message); return message; } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_RESPONSE_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/response_concept.hpp000066400000000000000000000036011240331347200277100ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_RESPONSE_CONCEPT_HPP_20100603 #define BOOST_NETWORK_PROTOCOL_HTTP_RESPONSE_CONCEPT_HPP_20100603 // Copyright 2010 (c) Dean Michael Berris. // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct Response : boost::network::Message { typedef typename R::string_type string_type; BOOST_CONCEPT_USAGE(Response) { R response_; swap(response, response_); // swappable via ADL typedef typename traits::version::type version_type; typedef typename traits::status::type status_type; typedef typename traits::status_message::type status_message_type; response << version(version_type()) // version directive << status(status_type()) // status directive << status_message( status_message_type()) // status_message directive ; version(response, version_type()); status(response, status_type()); status_message(response, status_message_type()); string_type version_ = version(response); boost::uint16_t status_ = status(response); string_type status_message_ = status_message(response); (void)version_; (void)status_; (void)status_message_; } private: R response; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_RESPONSE_CONCEPT_HPP_20100603 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server.hpp000066400000000000000000000037121240331347200256500ustar00rootroot00000000000000// Copyright 2009 (c) Tarro, Inc. // Copyright 2009 (c) Dean Michael Berris // Copyright 2010 (c) Glyn Matthews // Copyright 2003-2008 (c) Chris Kholhoff // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_HTTP_SERVER_HPP_ #define BOOST_NETWORK_HTTP_SERVER_HPP_ #include #include #include #include namespace boost { namespace network { namespace http { template struct server_base { typedef unsupported_tag type; }; template struct server_base >::type> { typedef async_server_base type; }; template struct server_base >::type> { typedef sync_server_base type; }; template struct basic_server : server_base::type {}; template struct server : server_base::type { typedef typename server_base::type server_base; typedef server_options options; explicit server(options const &options) : server_base(options) {} }; template struct async_server : server_base::type { typedef typename server_base::type server_base; typedef server_options options; explicit async_server(options const &options) : server_base(options) {} }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_HTTP_SERVER_HPP_ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/000077500000000000000000000000001240331347200251345ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/async_connection.hpp000066400000000000000000000615361240331347200312140ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_CONNECTION_HPP_20101027 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_CONNECTION_HPP_20101027 // Copyright 2010 Dean Michael Berris. // Copyright 2014 Jelle Van den Driessche. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BOOST_NETWORK_NO_LIB #include #endif #ifndef BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE /** Here we define a page's worth of header connection buffer data. * This can be tuned to reduce the memory cost of connections, but this * default size is set to be friendly to typical service applications. * This is the maximum size though and Boost.Asio's internal representation * of a streambuf would make appropriate decisions on how big a buffer * is to begin with. * * This kinda assumes that a page is by default 4096. Since we're using * the default allocator with the static buffers, it's not guaranteed that * the static buffers will be page-aligned when they are allocated. */ #define BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE 4096 #endif /* BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE */ namespace boost { namespace network { namespace http { #ifndef BOOST_NETWORK_NO_LIB extern void parse_version(std::string const& partial_parsed, fusion::tuple& version_pair); extern void parse_headers(std::string const& input, std::vector& container); #endif template struct async_connection : boost::enable_shared_from_this > { enum status_t { ok = 200, created = 201, accepted = 202, no_content = 204, partial_content = 206, multiple_choices = 300, moved_permanently = 301, moved_temporarily = 302, not_modified = 304, bad_request = 400, unauthorized = 401, forbidden = 403, not_found = 404, not_supported = 405, not_acceptable = 406, request_timeout = 408, precondition_failed = 412, unsatisfiable_range = 416, internal_server_error = 500, not_implemented = 501, bad_gateway = 502, service_unavailable = 503, space_unavailable = 507 }; typedef typename string::type string_type; typedef basic_request request; typedef shared_ptr connection_ptr; private: static char const* status_message(status_t status) { static char const ok_[] = "OK", created_[] = "Created", accepted_[] = "Accepted", no_content_[] = "No Content", multiple_choices_[] = "Multiple Choices", moved_permanently_[] = "Moved Permanently", moved_temporarily_[] = "Moved Temporarily", not_modified_[] = "Not Modified", bad_request_[] = "Bad Request", unauthorized_[] = "Unauthorized", forbidden_[] = "Fobidden", not_found_[] = "Not Found", not_supported_[] = "Not Supported", not_acceptable_[] = "Not Acceptable", internal_server_error_[] = "Internal Server Error", not_implemented_[] = "Not Implemented", bad_gateway_[] = "Bad Gateway", service_unavailable_[] = "Service Unavailable", unknown_[] = "Unknown", partial_content_[] = "Partial Content", request_timeout_[] = "Request Timeout", precondition_failed_[] = "Precondition Failed", unsatisfiable_range_[] = "Requested Range Not Satisfiable", space_unavailable_[] = "Insufficient Space to Store Resource"; switch (status) { case ok: return ok_; case created: return created_; case accepted: return accepted_; case no_content: return no_content_; case multiple_choices: return multiple_choices_; case moved_permanently: return moved_permanently_; case moved_temporarily: return moved_temporarily_; case not_modified: return not_modified_; case bad_request: return bad_request_; case unauthorized: return unauthorized_; case forbidden: return forbidden_; case not_found: return not_found_; case not_supported: return not_supported_; case not_acceptable: return not_acceptable_; case internal_server_error: return internal_server_error_; case not_implemented: return not_implemented_; case bad_gateway: return bad_gateway_; case service_unavailable: return service_unavailable_; case partial_content: return partial_content_; case request_timeout: return request_timeout_; case precondition_failed: return precondition_failed_; case unsatisfiable_range: return unsatisfiable_range_; case space_unavailable: return space_unavailable_; default: return unknown_; } } public: async_connection(asio::io_service& io_service, Handler& handler, utils::thread_pool& thread_pool, boost::shared_ptr ctx = boost::shared_ptr()) : strand(io_service), handler(handler), thread_pool_(thread_pool), headers_buffer( BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE), socket_(io_service, ctx), handshake_done(false), headers_already_sent(false), headers_in_progress(false) { new_start = read_buffer_.begin(); } ~async_connection() throw() { boost::system::error_code ignored; socket_.shutdown(asio::ip::tcp::socket::shutdown_receive, ignored); } /** Function: template set_headers(Range headers) * Precondition: headers have not been sent yet * Postcondition: headers have been linearized to a buffer, * and assumed to have been sent already when the *function exits * Throws: std::logic_error in case the headers have already been sent. * * A call to set_headers takes a Range where each element models the * Header concept. This Range will be linearized onto a buffer, which *is * then sent as soon as the first call to `write` or `flush` commences. */ template void set_headers(Range headers) { lock_guard lock(headers_mutex); if (headers_in_progress || headers_already_sent) boost::throw_exception( std::logic_error("Headers have already been sent.")); if (error_encountered) boost::throw_exception(boost::system::system_error(*error_encountered)); typedef constants consts; { std::ostream stream(&headers_buffer); stream << consts::http_slash() << 1 << consts::dot() << 1 << consts::space() << status << consts::space() << status_message(status) << consts::crlf(); if (!boost::empty(headers)) { typedef typename Range::const_iterator iterator; typedef typename string::type string_type; boost::transform(headers, std::ostream_iterator(stream), linearize_header()); } else { stream << consts::crlf(); } stream << consts::crlf(); } write_headers_only( boost::bind(&async_connection::do_nothing, async_connection::shared_from_this())); } void set_status(status_t new_status) { lock_guard lock(headers_mutex); if (headers_already_sent) boost::throw_exception(std::logic_error( "Headers have already been sent, cannot reset status.")); if (error_encountered) boost::throw_exception(boost::system::system_error(*error_encountered)); status = new_status; } template void write(Range const& range) { lock_guard lock(headers_mutex); if (error_encountered) boost::throw_exception(boost::system::system_error(*error_encountered)); boost::function f = boost::bind( &async_connection::default_error, async_connection::shared_from_this(), boost::arg<1>()); write_impl(boost::make_iterator_range(range), f); } template typename disable_if< is_base_of, void>::type write(Range const& range, Callback const& callback) { lock_guard lock(headers_mutex); if (error_encountered) boost::throw_exception(boost::system::system_error(*error_encountered)); write_impl(boost::make_iterator_range(range), callback); } template typename enable_if< is_base_of, void>::type write(ConstBufferSeq const& seq, Callback const& callback) { write_vec_impl(seq, callback, shared_array_list(), shared_buffers()); } private: typedef boost::array buffer_type; public: typedef iterator_range input_range; typedef boost::function< void(input_range, boost::system::error_code, std::size_t, connection_ptr)> read_callback_function; void read(read_callback_function callback) { if (error_encountered) boost::throw_exception(boost::system::system_error(*error_encountered)); if (new_start != read_buffer_.begin()) { input_range input = boost::make_iterator_range(new_start, read_buffer_.end()); thread_pool().post( boost::bind(callback, input, boost::system::error_code(), std::distance(new_start, data_end), async_connection::shared_from_this())); new_start = read_buffer_.begin(); return; } socket().async_read_some( asio::buffer(read_buffer_), strand.wrap(boost::bind( &async_connection::wrap_read_handler, async_connection::shared_from_this(), callback, asio::placeholders::error, asio::placeholders::bytes_transferred))); } boost::network::stream_handler& socket() { return socket_; } utils::thread_pool& thread_pool() { return thread_pool_; } bool has_error() { return (!!error_encountered); } optional error() { return error_encountered; } private: void wrap_read_handler(read_callback_function callback, boost::system::error_code const& ec, std::size_t bytes_transferred) { if (ec) error_encountered = in_place(ec); buffer_type::const_iterator data_start = read_buffer_.begin(), data_end = read_buffer_.begin(); std::advance(data_end, bytes_transferred); thread_pool().post(boost::bind( callback, boost::make_iterator_range(data_start, data_end), ec, bytes_transferred, async_connection::shared_from_this())); } void default_error(boost::system::error_code const& ec) { error_encountered = in_place(ec); } typedef boost::array array; typedef std::list > array_list; typedef boost::shared_ptr shared_array_list; typedef boost::shared_ptr > shared_buffers; typedef request_parser request_parser_type; typedef boost::lock_guard lock_guard; typedef std::list > pending_actions_list; asio::io_service::strand strand; Handler& handler; utils::thread_pool& thread_pool_; asio::streambuf headers_buffer; boost::network::stream_handler socket_; bool handshake_done; volatile bool headers_already_sent, headers_in_progress; boost::recursive_mutex headers_mutex; buffer_type read_buffer_; status_t status; request_parser_type parser; request request_; buffer_type::iterator new_start, data_end; string_type partial_parsed; optional error_encountered; pending_actions_list pending_actions; template friend struct async_server_base; enum state_t { method, uri, version, headers }; void start() { typename ostringstream::type ip_stream; ip_stream << socket_.remote_endpoint().address().to_v4().to_string() << ':' << socket_.remote_endpoint().port(); request_.source = ip_stream.str(); read_more(method); } void read_more(state_t state) { if (socket_.is_ssl_enabled() && !handshake_done) { socket_.async_handshake( boost::asio::ssl::stream_base::server, boost::bind(&async_connection::handle_handshake, async_connection::shared_from_this(), boost::asio::placeholders::error, state)); } else { socket_.async_read_some( asio::buffer(read_buffer_), strand.wrap( boost::bind(&async_connection::handle_read_data, async_connection::shared_from_this(), state, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred))); } } void handle_read_data(state_t state, boost::system::error_code const& ec, std::size_t bytes_transferred) { if (!ec) { logic::tribool parsed_ok; iterator_range result_range, input_range; data_end = read_buffer_.begin(); std::advance(data_end, bytes_transferred); switch (state) { case method: input_range = boost::make_iterator_range(new_start, data_end); fusion::tie(parsed_ok, result_range) = parser.parse_until(request_parser_type::method_done, input_range); if (!parsed_ok) { client_error(); break; } else if (parsed_ok == true) { swap(partial_parsed, request_.method); request_.method.append(boost::begin(result_range), boost::end(result_range)); trim(request_.method); new_start = boost::end(result_range); } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); new_start = read_buffer_.begin(); read_more(method); break; } case uri: input_range = boost::make_iterator_range(new_start, data_end); fusion::tie(parsed_ok, result_range) = parser.parse_until(request_parser_type::uri_done, input_range); if (!parsed_ok) { client_error(); break; } else if (parsed_ok == true) { swap(partial_parsed, request_.destination); request_.destination.append(boost::begin(result_range), boost::end(result_range)); trim(request_.destination); new_start = boost::end(result_range); } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); new_start = read_buffer_.begin(); read_more(uri); break; } case version: input_range = boost::make_iterator_range(new_start, data_end); fusion::tie(parsed_ok, result_range) = parser.parse_until( request_parser_type::version_done, input_range); if (!parsed_ok) { client_error(); break; } else if (parsed_ok == true) { fusion::tuple version_pair; partial_parsed.append(boost::begin(result_range), boost::end(result_range)); parse_version(partial_parsed, version_pair); request_.http_version_major = fusion::get<0>(version_pair); request_.http_version_minor = fusion::get<1>(version_pair); new_start = boost::end(result_range); partial_parsed.clear(); } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); new_start = read_buffer_.begin(); read_more(version); break; } case headers: input_range = boost::make_iterator_range(new_start, data_end); fusion::tie(parsed_ok, result_range) = parser.parse_until( request_parser_type::headers_done, input_range); if (!parsed_ok) { client_error(); break; } else if (parsed_ok == true) { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); parse_headers(partial_parsed, request_.headers); new_start = boost::end(result_range); thread_pool().post(boost::bind( &Handler::operator(), &handler, cref(request_), async_connection::shared_from_this())); return; } else { partial_parsed.append(boost::begin(result_range), boost::end(result_range)); new_start = read_buffer_.begin(); read_more(headers); break; } default: BOOST_ASSERT(false && "This is a bug, report to the cpp-netlib devel " "mailing list!"); std::abort(); } } else { error_encountered = in_place(ec); } } void client_error() { static char const* bad_request = "HTTP/1.0 400 Bad Request\r\nConnection: close\r\nContent-Type: " "text/plain\r\nContent-Length: 12\r\n\r\nBad Request."; asio::async_write( socket(), asio::buffer(bad_request, strlen(bad_request)), strand.wrap(boost::bind( &async_connection::client_error_sent, async_connection::shared_from_this(), asio::placeholders::error, asio::placeholders::bytes_transferred))); } void client_error_sent(boost::system::error_code const& ec, std::size_t bytes_transferred) { if (!ec) { boost::system::error_code ignored; socket().shutdown(asio::ip::tcp::socket::shutdown_both, ignored); socket().close(ignored); } else { error_encountered = in_place(ec); } } void do_nothing() {} void write_headers_only(boost::function callback) { if (headers_in_progress) return; headers_in_progress = true; asio::async_write( socket(), headers_buffer, strand.wrap(boost::bind( &async_connection::handle_write_headers, async_connection::shared_from_this(), callback, asio::placeholders::error, asio::placeholders::bytes_transferred))); } void handle_write_headers(boost::function callback, boost::system::error_code const& ec, std::size_t bytes_transferred) { lock_guard lock(headers_mutex); if (!ec) { headers_buffer.consume(headers_buffer.size()); headers_already_sent = true; thread_pool().post(callback); pending_actions_list::iterator start = pending_actions.begin(), end = pending_actions.end(); while (start != end) { thread_pool().post(*start++); } pending_actions_list().swap(pending_actions); } else { error_encountered = in_place(ec); } } void handle_write( boost::function callback, shared_array_list temporaries, shared_buffers buffers, boost::system::error_code const& ec, std::size_t bytes_transferred) { // we want to forget the temporaries and buffers thread_pool().post(boost::bind(callback, ec)); } template void write_impl(Range range, boost::function callback) { // linearize the whole range into a vector // of fixed-sized buffers, then schedule an asynchronous // write of these buffers -- make sure they are live // by making these linearized buffers shared and made // part of the completion handler. // // once the range has been linearized and sent, schedule // a wrapper to be called in the io_service's thread, that // will re-schedule the given callback into the thread pool // referred to here so that the io_service's thread can concentrate // on doing I/O. // static std::size_t const connection_buffer_size = BOOST_NETWORK_HTTP_SERVER_CONNECTION_BUFFER_SIZE; shared_array_list temporaries = boost::make_shared(); shared_buffers buffers = boost::make_shared >(0); std::size_t range_size = boost::distance(range); buffers->reserve((range_size / connection_buffer_size) + ((range_size % connection_buffer_size) ? 1 : 0)); std::size_t slice_size = std::min(range_size, connection_buffer_size); typename boost::range_iterator::type start = boost::begin(range), end = boost::end(range); while (slice_size != 0) { using boost::adaptors::sliced; shared_ptr new_array = make_shared(); boost::copy(range | sliced(0, slice_size), new_array->begin()); temporaries->push_back(new_array); buffers->push_back(asio::buffer(new_array->data(), slice_size)); std::advance(start, slice_size); range = boost::make_iterator_range(start, end); range_size = boost::distance(range); slice_size = std::min(range_size, connection_buffer_size); } if (!buffers->empty()) { write_vec_impl(*buffers, callback, temporaries, buffers); } } template void write_vec_impl(ConstBufferSeq const& seq, Callback const& callback, shared_array_list temporaries, shared_buffers buffers) { lock_guard lock(headers_mutex); if (error_encountered) boost::throw_exception(boost::system::system_error(*error_encountered)); boost::function callback_function = callback; boost::function continuation = boost::bind( &async_connection::template write_vec_impl< ConstBufferSeq, boost::function >, async_connection::shared_from_this(), seq, callback_function, temporaries, buffers); if (!headers_already_sent && !headers_in_progress) { write_headers_only(continuation); return; } else if (headers_in_progress && !headers_already_sent) { pending_actions.push_back(continuation); return; } asio::async_write( socket_, seq, boost::bind(&async_connection::handle_write, async_connection::shared_from_this(), callback_function, temporaries, buffers, asio::placeholders::error, asio::placeholders::bytes_transferred)); } void handle_handshake(const boost::system::error_code& ec, state_t state) { if (!ec) { handshake_done = true; read_more(state); } else { error_encountered = in_place(ec); } } }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_CONNECTION_HPP_20101027 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/async_server.hpp000066400000000000000000000143271240331347200303570ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_ASYNC_SERVER_HPP_20101025 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_ASYNC_SERVER_HPP_20101025 // Copyright 2010 Dean Michael Berris. // Copyright 2014 Jelle Van den Driessche. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct async_server_base : server_storage_base, socket_options_base { typedef basic_request request; typedef basic_response response; typedef typename string::type string_type; typedef typename boost::network::http::response_header::type response_header; typedef async_connection connection; typedef shared_ptr connection_ptr; typedef boost::unique_lock scoped_mutex_lock; explicit async_server_base(server_options const &options) : server_storage_base(options), socket_options_base(options), handler(options.handler()), address_(options.address()), port_(options.port()), thread_pool(options.thread_pool() ? options.thread_pool() : boost::make_shared()), acceptor(server_storage_base::service_), stopping(false), new_connection(), listening_mutex_(), stopping_mutex_(), listening(false), ctx_(options.context()) {} void run() { listen(); service_.run(); }; void stop() { // stop accepting new requests and let all the existing // handlers finish. scoped_mutex_lock listening_lock(listening_mutex_); if (listening) { // we dont bother stopping if we arent currently // listening scoped_mutex_lock stopping_lock(stopping_mutex_); stopping = true; system::error_code ignored; acceptor.close(ignored); listening = false; service_.post(boost::bind(&async_server_base::handle_stop, this)); } } void listen() { scoped_mutex_lock listening_lock(listening_mutex_); BOOST_NETWORK_MESSAGE("Listening on " << address_ << ':' << port_); if (!listening) start_listening(); // we only initialize our acceptor/sockets if we // arent already listening if (!listening) { BOOST_NETWORK_MESSAGE("Error listening on " << address_ << ':' << port_); boost::throw_exception( std::runtime_error("Error listening on provided port.")); } } private: Handler &handler; string_type address_, port_; boost::shared_ptr thread_pool; asio::ip::tcp::acceptor acceptor; bool stopping; connection_ptr new_connection; boost::mutex listening_mutex_; boost::mutex stopping_mutex_; bool listening; boost::shared_ptr ctx_; void handle_stop() { scoped_mutex_lock stopping_lock(stopping_mutex_); if (stopping) service_.stop(); // a user may have started listening again before // the stop command is reached } void handle_accept(boost::system::error_code const &ec) { { scoped_mutex_lock stopping_lock(stopping_mutex_); if (stopping) return; // we dont want to add another handler instance, and we // dont want to know about errors for a socket we dont // need anymore } if (ec) { BOOST_NETWORK_MESSAGE("Error accepting connection, reason: " << ec); } socket_options_base::socket_options(new_connection->socket().next_layer()); new_connection->start(); new_connection.reset(new connection(service_, handler, *thread_pool, ctx_)); acceptor.async_accept( new_connection->socket().next_layer(), boost::bind(&async_server_base::handle_accept, this, boost::asio::placeholders::error)); } void start_listening() { using boost::asio::ip::tcp; system::error_code error; service_.reset(); // this allows repeated cycles of run -> stop -> // run tcp::resolver resolver(service_); tcp::resolver::query query(address_, port_); tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error); if (error) { BOOST_NETWORK_MESSAGE("Error resolving '" << address_ << ':' << port_); return; } tcp::endpoint endpoint = *endpoint_iterator; acceptor.open(endpoint.protocol(), error); if (error) { BOOST_NETWORK_MESSAGE("Error opening socket: " << address_ << ":" << port_); return; } socket_options_base::acceptor_options(acceptor); acceptor.bind(endpoint, error); if (error) { BOOST_NETWORK_MESSAGE("Error binding socket: " << address_ << ":" << port_); return; } acceptor.listen(asio::socket_base::max_connections, error); if (error) { BOOST_NETWORK_MESSAGE("Error listening on socket: '" << error << "' on " << address_ << ":" << port_); return; } new_connection.reset(new connection(service_, handler, *thread_pool, ctx_)); acceptor.async_accept( new_connection->socket().next_layer(), boost::bind(&async_server_base::handle_accept, this, boost::asio::placeholders::error)); listening = true; scoped_mutex_lock stopping_lock(stopping_mutex_); stopping = false; // if we were in the process of stopping, we revoke // that command and continue listening BOOST_NETWORK_MESSAGE("Now listening on socket: '" << address_ << ":" << port_ << "'"); } }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_ASYNC_SERVER_HPP_20101025 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/impl/000077500000000000000000000000001240331347200260755ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/impl/parsers.ipp000066400000000000000000000043331240331347200302710ustar00rootroot00000000000000#ifndef SERVER_REQUEST_PARSERS_IMPL_UW3PM6V6 #define SERVER_REQUEST_PARSERS_IMPL_UW3PM6V6 #define BOOST_SPIRIT_UNICODE #include // Copyright 2013 Google, Inc. // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #ifdef BOOST_NETWORK_NO_LIB #ifndef BOOST_NETWORK_INLINE #define BOOST_NETWORK_INLINE inline #endif #else #define BOOST_NETWORK_INLINE #endif #include namespace boost { namespace spirit { namespace traits { typedef std::basic_string u32_string; template <> // struct assign_to_container_from_value { static void call(u32_string const& val, std::string& attr) { u32_to_u8_iterator begin = val.begin(), end = val.end(); for (; begin != end; ++begin) attr += *begin; } }; } // namespace traits } // namespace spirit } // namespace boost namespace boost { namespace network { namespace http { BOOST_NETWORK_INLINE void parse_version( std::string const& partial_parsed, fusion::tuple& version_pair) { using namespace boost::spirit::qi; parse(partial_parsed.begin(), partial_parsed.end(), (lit("HTTP/") >> ushort_ >> '.' >> ushort_), version_pair); } BOOST_NETWORK_INLINE void parse_headers( std::string const& input, std::vector& container) { using namespace boost::spirit::qi; u8_to_u32_iterator begin = input.begin(), end = input.end(); typedef as as_u32_string; parse(begin, end, *(+((alnum | punct) - ':') >> lit(": ") >> as_u32_string()[+((unicode::alnum | space | punct) - '\r' - '\n')] >> lit("\r\n")) >> lit("\r\n"), container); } } // namespace http } // namespace network } // namespace boost #endif /* SERVER_REQUEST_PARSERS_IMPL_UW3PM6V6 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/options.hpp000066400000000000000000000146651240331347200273540ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_OPTIONS_20130128 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_OPTIONS_20130128 // Copyright 2013 Google, Inc. // Copyright 2013 Dean Michael Berris // Copyright 2014 Jelle Van den Driessche // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct server_options { typedef typename string::type string_type; explicit server_options(Handler &handler) : io_service_(), handler_(handler), address_("localhost"), port_("80"), reuse_address_(false), report_aborted_(false), non_blocking_io_(true), linger_(true), linger_timeout_(0), receive_buffer_size_(), send_buffer_size_(), receive_low_watermark_(), send_low_watermark_(), thread_pool_(), context_() {} server_options(const server_options &other) : io_service_(other.io_service()), handler_(other.handler_), address_(other.address_), port_(other.port_), reuse_address_(other.reuse_address_), report_aborted_(other.report_aborted_), non_blocking_io_(other.non_blocking_io_), linger_(other.linger_), linger_timeout_(0), receive_buffer_size_(other.receive_buffer_size_), send_buffer_size_(other.send_buffer_size_), receive_low_watermark_(other.receive_low_watermark_), send_low_watermark_(other.send_low_watermark_), thread_pool_(other.thread_pool_), context_(other.context_) {} server_options &operator=(server_options other) { other.swap(*this); return *this; } void swap(server_options &other) { using std::swap; swap(io_service_, other.io_service_); swap(address_, other.address_); swap(port_, other.port_); swap(reuse_address_, other.reuse_address_); swap(report_aborted_, other.report_aborted_); swap(non_blocking_io_, other.non_blocking_io_); swap(linger_, other.linger_); swap(linger_timeout_, other.linger_timeout_); swap(receive_buffer_size_, other.receive_buffer_size_); swap(send_buffer_size_, other.send_buffer_size_); swap(receive_low_watermark_, other.receive_low_watermark_); swap(send_low_watermark_, other.send_low_watermark_); swap(thread_pool_, other.thread_pool_); swap(context_, other.context_); } server_options &context(boost::shared_ptr v) { context_ = v; return *this; } server_options &io_service(boost::shared_ptr v) { io_service_ = v; return *this; } server_options &address(string_type const &v) { address_ = v; return *this; } server_options &port(string_type const &v) { port_ = v; return *this; } server_options &reuse_address(bool v) { reuse_address_ = v; return *this; } server_options &report_aborted(bool v) { report_aborted_ = v; return *this; } server_options &non_blocking_io(bool v) { non_blocking_io_ = v; return *this; } server_options &linger(bool v) { linger_ = v; return *this; } server_options &linger_timeout(size_t v) { linger_timeout_ = v; return *this; } server_options &receive_buffer_size( boost::asio::socket_base::receive_buffer_size v) { receive_buffer_size_ = v; return *this; } server_options &send_buffer_size( boost::asio::socket_base::send_buffer_size v) { send_buffer_size_ = v; return *this; } server_options &receive_low_watermark( boost::asio::socket_base::receive_low_watermark v) { receive_low_watermark_ = v; return *this; } server_options &send_low_watermark( boost::asio::socket_base::send_low_watermark v) { send_low_watermark_ = v; return *this; } server_options &thread_pool(boost::shared_ptr v) { thread_pool_ = v; return *this; } boost::shared_ptr io_service() const { return io_service_; } string_type address() const { return address_; } string_type port() const { return port_; } Handler &handler() const { return handler_; } bool reuse_address() const { return reuse_address_; } bool report_aborted() const { return report_aborted_; } bool non_blocking_io() const { return non_blocking_io_; } bool linger() const { return linger_; } size_t linger_timeout() const { return linger_timeout_; } boost::optional receive_buffer_size() const { return receive_buffer_size_; } boost::optional send_buffer_size() const { return send_buffer_size_; } boost::optional receive_low_watermark() const { return receive_low_watermark_; } boost::optional send_low_watermark() const { return send_low_watermark_; } boost::shared_ptr thread_pool() const { return thread_pool_; } boost::shared_ptr context() const { return context_; } private: boost::shared_ptr io_service_; Handler &handler_; string_type address_; string_type port_; bool reuse_address_; bool report_aborted_; bool non_blocking_io_; bool linger_; size_t linger_timeout_; boost::optional receive_buffer_size_; boost::optional send_buffer_size_; boost::optional receive_low_watermark_; boost::optional send_low_watermark_; boost::shared_ptr thread_pool_; boost::shared_ptr context_; }; template inline void swap(server_options &a, server_options &b) { a.swap(b); } } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_OPTIONS_20130128 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/request.hpp000066400000000000000000000022331240331347200273350ustar00rootroot00000000000000// // request.hpp // ~~~~~~~~~~~ // // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2009 Dean Michael Berris (mikhailberis@gmail.com) // Copyright (c) 2009 Tarro, Inc. // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NETWORK_HTTP_REQUEST_HPP #define BOOST_NETWORK_HTTP_REQUEST_HPP #include #include #include #include "header.hpp" namespace boost { namespace network { namespace http { /// A request received from a client. struct request { std::string method; std::string uri; int http_version_major; int http_version_minor; std::vector
headers; std::string body; }; inline void swap(request& l, request& r) { using std::swap; swap(l.method, r.method); swap(l.uri, r.uri); swap(l.http_version_major, r.http_version_major); swap(l.http_version_minor, r.http_version_minor); swap(l.headers, r.headers); swap(l.body, r.body); } } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_HTTP_REQUEST_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/request_parser.hpp000066400000000000000000000152021240331347200307110ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_REQUEST_PARSER_HPP_20101005 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_REQUEST_PARSER_HPP_20101005 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { namespace http { template struct request_parser { enum state_t { method_start, method_char, method_done, uri_char, uri_done, version_h, version_t1, version_t2, version_p, version_slash, version_d1, version_dot, version_d2, version_cr, version_done, header_name, header_colon, header_value, header_cr, header_line_done, headers_cr, headers_done }; explicit request_parser(state_t start_state = method_start) : internal_state(start_state) {} void reset(state_t start_state = method_start) { internal_state = method_start; } state_t state() const { return internal_state; } template fusion::tuple > parse_until(state_t stop_state, Range& range) { logic::tribool parsed_ok = logic::indeterminate; typedef typename range_iterator::type iterator; iterator start = boost::begin(range), end = boost::end(range), current_iterator = start; iterator_range local_range = boost::make_iterator_range(start, end); while (!boost::empty(local_range) && stop_state != internal_state && indeterminate(parsed_ok)) { current_iterator = boost::begin(local_range); switch (internal_state) { case method_start: if (algorithm::is_upper()(*current_iterator)) internal_state = method_char; else parsed_ok = false; break; case method_char: if (algorithm::is_upper()(*current_iterator)) break; else if (algorithm::is_space()(*current_iterator)) internal_state = method_done; else parsed_ok = false; break; case method_done: if (algorithm::is_cntrl()(*current_iterator)) parsed_ok = false; else if (algorithm::is_space()(*current_iterator)) parsed_ok = false; else internal_state = uri_char; break; case uri_char: if (algorithm::is_cntrl()(*current_iterator)) parsed_ok = false; else if (algorithm::is_space()(*current_iterator)) internal_state = uri_done; break; case uri_done: if (*current_iterator == 'H') internal_state = version_h; else parsed_ok = false; break; case version_h: if (*current_iterator == 'T') internal_state = version_t1; else parsed_ok = false; break; case version_t1: if (*current_iterator == 'T') internal_state = version_t2; else parsed_ok = false; break; case version_t2: if (*current_iterator == 'P') internal_state = version_p; else parsed_ok = false; break; case version_p: if (*current_iterator == '/') internal_state = version_slash; else parsed_ok = false; break; case version_slash: if (algorithm::is_digit()(*current_iterator)) internal_state = version_d1; else parsed_ok = false; break; case version_d1: if (*current_iterator == '.') internal_state = version_dot; else parsed_ok = false; break; case version_dot: if (algorithm::is_digit()(*current_iterator)) internal_state = version_d2; else parsed_ok = false; break; case version_d2: if (*current_iterator == '\r') internal_state = version_cr; else parsed_ok = false; break; case version_cr: if (*current_iterator == '\n') internal_state = version_done; else parsed_ok = false; break; case version_done: if (algorithm::is_alnum()(*current_iterator)) internal_state = header_name; else if (*current_iterator == '\r') internal_state = headers_cr; else parsed_ok = false; break; case header_name: if (*current_iterator == ':') internal_state = header_colon; else if (algorithm::is_alnum()(*current_iterator) || algorithm::is_punct()(*current_iterator)) break; else parsed_ok = false; break; case header_colon: if (*current_iterator == ' ') internal_state = header_value; else parsed_ok = false; break; case header_value: if (*current_iterator == '\r') internal_state = header_cr; else if (algorithm::is_cntrl()(*current_iterator)) parsed_ok = false; break; case header_cr: if (*current_iterator == '\n') internal_state = header_line_done; else parsed_ok = false; break; case header_line_done: if (*current_iterator == '\r') internal_state = headers_cr; else if (algorithm::is_alnum()(*current_iterator)) internal_state = header_name; else parsed_ok = false; break; case headers_cr: if (*current_iterator == '\n') internal_state = headers_done; else parsed_ok = false; break; case headers_done: // anything that follows after headers_done is allowed. break; default: parsed_ok = false; }; if (internal_state == stop_state) parsed_ok = true; local_range = boost::make_iterator_range(++current_iterator, end); } return fusion::make_tuple( parsed_ok, boost::make_iterator_range(start, current_iterator)); } private: state_t internal_state; }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_REQUEST_PARSER_HPP_20101005 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/socket_options_base.hpp000066400000000000000000000046111240331347200317040ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SOCKET_OPTIONS_BASE_HPP_20101210 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SOCKET_OPTIONS_BASE_HPP_20101210 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { struct socket_options_base { protected: asio::socket_base::reuse_address acceptor_reuse_address; asio::socket_base::enable_connection_aborted acceptor_report_aborted; boost::optional receive_buffer_size; boost::optional send_buffer_size; boost::optional receive_low_watermark; boost::optional send_low_watermark; asio::socket_base::non_blocking_io non_blocking_io; asio::socket_base::linger linger; template explicit socket_options_base(server_options const &options) : acceptor_reuse_address(options.reuse_address()), acceptor_report_aborted(options.report_aborted()), receive_buffer_size(options.receive_buffer_size()), send_buffer_size(options.send_buffer_size()), receive_low_watermark(options.receive_low_watermark()), send_low_watermark(options.send_low_watermark()), non_blocking_io(options.non_blocking_io()), linger(options.linger(), options.linger_timeout()) {} void acceptor_options(boost::asio::ip::tcp::acceptor &acceptor) { acceptor.set_option(acceptor_reuse_address); acceptor.set_option(acceptor_report_aborted); } void socket_options(boost::asio::ip::tcp::socket &socket) { boost::system::error_code ignored; socket.io_control(non_blocking_io, ignored); socket.set_option(linger, ignored); if (receive_buffer_size) socket.set_option(*receive_buffer_size, ignored); if (receive_low_watermark) socket.set_option(*receive_low_watermark, ignored); if (send_buffer_size) socket.set_option(*send_buffer_size, ignored); if (send_low_watermark) socket.set_option(*send_low_watermark, ignored); } }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SOCKET_OPTIONS_BASE_HPP_20101210 \ */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/storage_base.hpp000066400000000000000000000021621240331347200303040ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_STORAGE_BASE_HPP_20101210 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_STORAGE_BASE_HPP_20101210 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { struct server_storage_base { struct no_io_service {}; struct has_io_service {}; protected: template explicit server_storage_base(server_options const& options) : self_service_(options.io_service() ? options.io_service() : boost::make_shared()), service_(*self_service_) {} boost::shared_ptr self_service_; asio::io_service& service_; }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_STORAGE_BASE_HPP_20101210 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/sync_connection.hpp000066400000000000000000000215551240331347200310500ustar00rootroot00000000000000// Copyright 2009 (c) Dean Michael Berris // Copyright 2009 (c) Tarroo, Inc. // Adapted from Christopher Kholhoff's Boost.Asio Example, released under // the Boost Software License, Version 1.0. (See acccompanying file // LICENSE_1_0.txt // or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_NETWORK_HTTP_SERVER_SYNC_CONNECTION_HPP_ #define BOOST_NETWORK_HTTP_SERVER_SYNC_CONNECTION_HPP_ #ifndef BOOST_NETWORK_HTTP_SERVER_CONNECTION_BUFFER_SIZE #define BOOST_NETWORK_HTTP_SERVER_CONNECTION_BUFFER_SIZE 1024uL #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct sync_connection : boost::enable_shared_from_this > { sync_connection(boost::asio::io_service &service, Handler &handler) : service_(service), handler_(handler), socket_(service_), wrapper_(service_) {} boost::asio::ip::tcp::socket &socket() { return socket_; } void start() { // This is HTTP so we really want to just // read and parse a request that's incoming // and then pass that request object to the // handler_ instance. // using boost::asio::ip::tcp; boost::system::error_code option_error; socket_.set_option(tcp::no_delay(true), option_error); if (option_error) handler_.log(boost::system::system_error(option_error).what()); socket_.async_read_some( boost::asio::buffer(buffer_), wrapper_.wrap( boost::bind(&sync_connection::handle_read_headers, sync_connection::shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred))); } private: struct is_content_length { template bool operator()(Header const &header) { return boost::to_lower_copy(header.name) == "content-length"; } }; void handle_read_headers(boost::system::error_code const &ec, size_t bytes_transferred) { if (!ec) { request_.source = socket_.remote_endpoint().address().to_string(); request_.source_port = socket_.remote_endpoint().port(); boost::tribool done; buffer_type::iterator new_start; tie(done, new_start) = parser_.parse_headers( request_, buffer_.data(), buffer_.data() + bytes_transferred); if (done) { if (request_.method[0] == 'P') { // look for the content-length header typename std::vector::type>::iterator it = std::find_if(request_.headers.begin(), request_.headers.end(), is_content_length()); if (it == request_.headers.end()) { response_ = basic_response::stock_reply( basic_response::bad_request); boost::asio::async_write( socket_, response_.to_buffers(), wrapper_.wrap(boost::bind( &sync_connection::handle_write, sync_connection::shared_from_this(), boost::asio::placeholders::error))); return; } size_t content_length = 0; try { content_length = boost::lexical_cast(it->value); } catch (...) { response_ = basic_response::stock_reply( basic_response::bad_request); boost::asio::async_write( socket_, response_.to_buffers(), wrapper_.wrap(boost::bind( &sync_connection::handle_write, sync_connection::shared_from_this(), boost::asio::placeholders::error))); return; } if (content_length != 0) { if (new_start != (buffer_.begin() + bytes_transferred)) { request_.body.append(new_start, buffer_.begin() + bytes_transferred); content_length -= std::distance(new_start, buffer_.begin() + bytes_transferred); } if (content_length > 0) { socket_.async_read_some( boost::asio::buffer(buffer_), wrapper_.wrap(boost::bind( &sync_connection::handle_read_body_contents, sync_connection::shared_from_this(), boost::asio::placeholders::error, content_length, boost::asio::placeholders::bytes_transferred))); return; } } handler_(request_, response_); boost::asio::async_write( socket_, response_.to_buffers(), wrapper_.wrap( boost::bind(&sync_connection::handle_write, sync_connection::shared_from_this(), boost::asio::placeholders::error))); } else { handler_(request_, response_); boost::asio::async_write( socket_, response_.to_buffers(), wrapper_.wrap( boost::bind(&sync_connection::handle_write, sync_connection::shared_from_this(), boost::asio::placeholders::error))); } } else if (!done) { response_ = basic_response::stock_reply(basic_response::bad_request); boost::asio::async_write( socket_, response_.to_buffers(), wrapper_.wrap( boost::bind(&sync_connection::handle_write, sync_connection::shared_from_this(), boost::asio::placeholders::error))); } else { socket_.async_read_some( boost::asio::buffer(buffer_), wrapper_.wrap( boost::bind(&sync_connection::handle_read_headers, sync_connection::shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred))); } } // TODO Log the error? } void handle_read_body_contents(boost::system::error_code const &ec, size_t bytes_to_read, size_t bytes_transferred) { if (!ec) { size_t difference = bytes_to_read - bytes_transferred; buffer_type::iterator start = buffer_.begin(), past_end = start; std::advance(past_end, (std::min)(bytes_to_read, bytes_transferred)); request_.body.append(buffer_.begin(), past_end); if (difference == 0) { handler_(request_, response_); boost::asio::async_write( socket_, response_.to_buffers(), wrapper_.wrap( boost::bind(&sync_connection::handle_write, sync_connection::shared_from_this(), boost::asio::placeholders::error))); } else { socket_.async_read_some( boost::asio::buffer(buffer_), wrapper_.wrap(boost::bind( &sync_connection::handle_read_body_contents, sync_connection::shared_from_this(), boost::asio::placeholders::error, difference, boost::asio::placeholders::bytes_transferred))); } } // TODO Log the error? } void handle_write(boost::system::error_code const &ec) { if (!ec) { using boost::asio::ip::tcp; boost::system::error_code ignored_ec; socket_.shutdown(tcp::socket::shutdown_receive, ignored_ec); } } boost::asio::io_service &service_; Handler &handler_; boost::asio::ip::tcp::socket socket_; boost::asio::io_service::strand wrapper_; typedef boost::array buffer_type; buffer_type buffer_; typedef basic_request_parser request_parser; request_parser parser_; basic_request request_; basic_response response_; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_HTTP_SERVER_SYNC_CONNECTION_HPP_ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/server/sync_server.hpp000066400000000000000000000113141240331347200302070ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Copyright 2010 Glyn Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025 #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct sync_server_base : server_storage_base, socket_options_base { typedef typename string::type string_type; typedef basic_request request; typedef basic_response response; typedef typename boost::network::http::response_header::type response_header; sync_server_base(server_options const& options) : server_storage_base(options), socket_options_base(options), handler_(options.handler()), address_(options.address()), port_(options.port()), acceptor_(server_storage_base::service_), new_connection(), listening_mutex_(), listening_(false) {} void run() { listen(); service_.run(); } void stop() { // stop accepting new connections and let all the existing handlers // finish. system::error_code ignored; acceptor_.close(ignored); service_.stop(); } void listen() { boost::unique_lock listening_lock(listening_mutex_); if (!listening_) start_listening(); } private: Handler& handler_; string_type address_, port_; boost::asio::ip::tcp::acceptor acceptor_; boost::shared_ptr > new_connection; boost::mutex listening_mutex_; bool listening_; void handle_accept(boost::system::error_code const& ec) { if (ec) { } socket_options_base::socket_options(new_connection->socket()); new_connection->start(); new_connection.reset(new sync_connection(service_, handler_)); acceptor_.async_accept( new_connection->socket(), boost::bind(&sync_server_base::handle_accept, this, boost::asio::placeholders::error)); } void start_listening() { using boost::asio::ip::tcp; system::error_code error; tcp::resolver resolver(service_); tcp::resolver::query query(address_, port_); tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error); if (error) { BOOST_NETWORK_MESSAGE("Error resolving address: " << address_ << ':' << port_); boost::throw_exception(std::runtime_error("Error resolving address.")); } tcp::endpoint endpoint = *endpoint_iterator; acceptor_.open(endpoint.protocol(), error); if (error) { BOOST_NETWORK_MESSAGE("Error opening socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\''); boost::throw_exception(std::runtime_error("Error opening socket.")); } socket_options_base::acceptor_options(acceptor_); acceptor_.bind(endpoint, error); if (error) { BOOST_NETWORK_MESSAGE("Error binding to socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\''); boost::throw_exception(std::runtime_error("Error binding to socket.")); } acceptor_.listen(tcp::socket::max_connections, error); if (error) { BOOST_NETWORK_MESSAGE("Error listening on socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\''); boost::throw_exception(std::runtime_error("Error listening on socket.")); } new_connection.reset(new sync_connection(service_, handler_)); acceptor_.async_accept( new_connection->socket(), boost::bind(&sync_server_base::handle_accept, this, boost::asio::placeholders::error)); listening_ = true; } }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/000077500000000000000000000000001240331347200253425ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/client_or_server.hpp000066400000000000000000000021001240331347200314100ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_CLIENT_OR_SERVER_HPP_20101127 #define BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_CLIENT_OR_SERVER_HPP_20101127 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { namespace http { template struct unsupported_tag; template struct client_or_server { typedef unsupported_tag type; }; template struct client_or_server >::type> { typedef tags::server type; }; template struct client_or_server >::type> { typedef tags::client type; }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_CLIENT_OR_SERVER_HPP_20101127 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/is_client.hpp000066400000000000000000000014051240331347200300240ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_SUPPORT_IS_CLIENT_HPP_20101118 #define BOOST_NETWORK_PROTOCOL_SUPPORT_IS_CLIENT_HPP_20101118 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct is_client : mpl::false_ {}; template struct is_client< Tag, typename enable_if::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_SUPPORT_IS_CLIENT_HPP_20101118 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/is_http.hpp000066400000000000000000000014011240331347200275210ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_HTTP_HPP_20100622 #define BOOST_NETWORK_SUPPORT_IS_HTTP_HPP_20100622 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct is_http : mpl::false_ {}; template struct is_http::type> : mpl::true_ {}; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_IS_HTTP_HPP_20100622 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/is_keepalive.hpp000066400000000000000000000014551240331347200305200ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 #define BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct unsupported_tag; template struct is_keepalive : mpl::false_ {}; template struct is_keepalive< Tag, typename enable_if::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/is_server.hpp000066400000000000000000000014051240331347200300540ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_SUPPORT_IS_SERVER_HPP_20101118 #define BOOST_NETWORK_PROTOCOL_SUPPORT_IS_SERVER_HPP_20101118 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct is_server : mpl::false_ {}; template struct is_server< Tag, typename enable_if::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_SUPPORT_IS_SERVER_HPP_20101118 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/is_simple.hpp000066400000000000000000000013551240331347200300430ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 #define BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct is_simple : mpl::false_ {}; template struct is_simple< Tag, typename enable_if::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/support/sync_only.hpp000066400000000000000000000017131240331347200300720ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_SYNC_ONLY_HPP_20100927 #define BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_SYNC_ONLY_HPP_20100927 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace http { template struct sync_only : mpl::inherit_linearly< typename mpl::replace_if::type, is_same, tags::sync>::type, mpl::inherit > {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_SYNC_ONLY_HPP_20100927 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/tags.hpp000066400000000000000000000042031240331347200252740ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_TAGS_HPP_20101019 #define BOOST_NETWORK_PROTOCOL_HTTP_TAGS_HPP_20101019 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { namespace tags { struct http { typedef mpl::true_::type is_http; }; struct keepalive { typedef mpl::true_::type is_keepalive; }; struct simple { typedef mpl::true_::type is_simple; }; struct server { typedef mpl::true_::type is_server; }; struct client { typedef mpl::true_::type is_client; }; using namespace boost::network::tags; template struct components; typedef mpl::vector http_default_8bit_tcp_resolve_tags; typedef mpl::vector http_default_8bit_udp_resolve_tags; typedef mpl::vector http_keepalive_8bit_tcp_resolve_tags; typedef mpl::vector http_keepalive_8bit_udp_resolve_tags; typedef mpl::vector http_async_8bit_udp_resolve_tags; typedef mpl::vector http_async_8bit_tcp_resolve_tags; typedef mpl::vector http_server_tags; typedef mpl::vector http_async_server_tags; BOOST_NETWORK_DEFINE_TAG(http_default_8bit_tcp_resolve); BOOST_NETWORK_DEFINE_TAG(http_default_8bit_udp_resolve); BOOST_NETWORK_DEFINE_TAG(http_keepalive_8bit_tcp_resolve); BOOST_NETWORK_DEFINE_TAG(http_keepalive_8bit_udp_resolve); BOOST_NETWORK_DEFINE_TAG(http_async_8bit_udp_resolve); BOOST_NETWORK_DEFINE_TAG(http_async_8bit_tcp_resolve); BOOST_NETWORK_DEFINE_TAG(http_server); BOOST_NETWORK_DEFINE_TAG(http_async_server); } /* tags */ } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_TAGS_HPP_20101019 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits.hpp000066400000000000000000000014251240331347200256470ustar00rootroot00000000000000// This file is part of the Boost Network library // Based on the Pion Network Library (r421) // Copyright Atomic Labs, Inc. 2007-2008 // See http://cpp-netlib.sourceforge.net for library home page. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_HPP #define BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_HPP // Convenience header for including different traits implementations. #include //#include #include #endif // BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/000077500000000000000000000000001240331347200251345ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/connection_keepalive.hpp000066400000000000000000000013341240331347200320320ustar00rootroot00000000000000// Copyright (c) Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_CONECTION_KEEPALIVE_20091218 #define BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_CONECTION_KEEPALIVE_20091218 #include #include namespace boost { namespace network { namespace http { template struct connection_keepalive : is_keepalive {}; } /* http */ } /* network */ } /* boost */ #endif // BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_CONECTION_KEEPALIVE_20091218 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/connection_policy.hpp000066400000000000000000000041451240331347200313670ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CONNECTION_POLICY_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_CONNECTION_POLICY_20091214 // Copyright 2013 Google, Inc. // Copyright Dean Michael Berris 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct unsupported_tag; template struct connection_policy { typedef unsupported_tag type; }; template struct connection_policy >::type> { typedef async_connection_policy type; }; template struct connection_policy< Tag, version_major, version_minor, typename enable_if< mpl::and_, mpl::not_ > > >::type> { typedef simple_connection_policy type; }; template struct connection_policy< Tag, version_major, version_minor, typename enable_if< mpl::and_, mpl::not_ > > >::type> { typedef pooled_connection_policy type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CONNECTION_POLICY_20091214 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/delegate_factory.hpp000066400000000000000000000017721240331347200311550ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_DELEGATE_FACTORY_HPP_20110819 #define BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_DELEGATE_FACTORY_HPP_20110819 // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include namespace boost { namespace network { namespace http { namespace impl { template struct connection_delegate_factory; } /* impl */ template struct unsupported_tag; template struct delegate_factory { typedef unsupported_tag type; }; template struct delegate_factory >::type> { typedef impl::connection_delegate_factory type; }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_DELEGATE_FACTORY_HPP_20110819 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/000077500000000000000000000000001240331347200260755ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/chunk_cache.ipp000066400000000000000000000015531240331347200310460ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_CHUNK_CACHE_CONTAINER_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_CHUNK_CACHE_CONTAINER_IPP #include #include #include #include namespace boost { namespace network { namespace http { template struct chunk_cache { // TODO define the allocator using an allocator_traits? typedef std::list::type> > type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_CHUNK_CACHE_CONTAINER_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/content.ipp000066400000000000000000000022221240331347200302570ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_CONTENT_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_CONTENT_IPP #include namespace boost { namespace network { namespace http { template <> struct content { static char const* type_html() { static char const* const TYPE_HTML = "text/html"; return TYPE_HTML; }; static char const* type_text() { static char const* const TYPE_TEXT = "text/plain"; return TYPE_TEXT; }; static char const* type_xml() { static char const* const TYPE_XML = "text/xml"; return TYPE_XML; }; static char const* type_urlencoded() { static char const* const TYPE_URLENCODED = "application/x-www-form-urlencoded"; return TYPE_URLENCODED; }; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_CONTENT_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/cookie_name.ipp000066400000000000000000000012731240331347200310630ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_COOKIE_NAME_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_COOKIE_NAME_IPP #include namespace boost { namespace network { namespace http { template <> struct cookie_name { static boost::uint32_t const MAX = 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_COOKIE_NAME_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/cookie_value.ipp000066400000000000000000000013071240331347200312550ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_COOKIE_VALUE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_COOKIE_VALUE_IPP #include namespace boost { namespace network { namespace http { template <> struct cookie_value { static boost::uint32_t const MAX = 1024u * 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_COOKIE_VALUE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/cookies_container.ipp000066400000000000000000000013721240331347200323100ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_COOKIES_CONTAINER_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_COOKIES_CONTAINER_IPP #include #include namespace boost { namespace network { namespace http { template struct cookies_container { typedef std::multimap::type, typename string::type> type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_COOKIES_CONTAINER_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/delimiters.ipp000066400000000000000000000021551240331347200307530ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_DELIMITERS_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_DELIMITERS_IPP #include namespace boost { namespace network { namespace http { // specialize on the tags::http_default_8bit_tcp_resolve type template <> struct delimiters { static char const* string_crlf() { static char const* const CRLF = "\x0D\x0A"; return CRLF; }; static char const* string_http_version() { static char const* const HTTP_VERSION = "HTTP/1.1"; return HTTP_VERSION; }; static char const* header_name_value_delimiter() { static char const* const HEADER_NAME_VALUE_DELIMITER = ": "; return HEADER_NAME_VALUE_DELIMITER; }; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_DELIMITERS_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/header_name.ipp000066400000000000000000000012731240331347200310420ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HEADER_NAME_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HEADER_NAME_IPP #include namespace boost { namespace network { namespace http { template <> struct header_name { static boost::uint32_t const MAX = 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HEADER_NAME_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/header_value.ipp000066400000000000000000000013071240331347200312340ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HEADER_VALUE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HEADER_VALUE_IPP #include namespace boost { namespace network { namespace http { template <> struct header_value { static boost::uint32_t const MAX = 1024u * 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HEADER_VALUE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/headers.ipp000066400000000000000000000041761240331347200302320ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_HPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_HPP #include namespace boost { namespace network { namespace http { template <> struct headers_ { static char const* host() { static char const* const HOST = "Host"; return HOST; }; static char const* cookie() { static char const* const COOKIE = "Cookie"; return COOKIE; }; static char const* set_cookie() { static char const* const SET_COOKIE = "Set-Cookie"; return SET_COOKIE; }; static char const* connection() { static char const* const CONNECTION = "Connection"; return CONNECTION; }; static char const* content_type() { static char const* const CONTENT_TYPE = "Content-Type"; return CONTENT_TYPE; }; static char const* content_length() { static char const* const CONTENT_LENGTH = "Content-Length"; return CONTENT_LENGTH; }; static char const* content_location() { static char const* const CONTENT_LOCATION = "Content-Location"; return CONTENT_LOCATION; }; static char const* last_modified() { static char const* const LAST_MODIFIED = "Last-Modified"; return LAST_MODIFIED; }; static char const* if_modified_since() { static char const* const IF_MODIFIED_SINCE = "If-Modified-Since"; return IF_MODIFIED_SINCE; }; static char const* transfer_encoding() { static char const* const TRANSFER_ENCODING = "Transfer-Encoding"; return TRANSFER_ENCODING; }; static char const* location() { static char const* const LOCATION = "Location"; return LOCATION; }; static char const* authorization() { static char const* const AUTHORIZATION = "Authorization"; return AUTHORIZATION; }; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/headers_container.ipp000066400000000000000000000031531240331347200322660ustar00rootroot00000000000000 // Copyright 2013 Google, Inc. // Copyright 2008 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_CONTAINER_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_CONTAINER_IPP #include #include #include #include #include #include namespace boost { namespace network { namespace impl { // Moving implementation from original // message_traits implementation by // Atomic Labs, Inc. // -- // returns true if str1 < str2 (ignoring case) struct is_less_ignore_case_impl { inline bool operator()( string::type const& str1, string::type const& str2) const { return to_lower_copy(str1) < to_lower_copy(str2); }; }; template struct headers_container_impl< Tag, typename enable_if::type> { typedef is_less_ignore_case_impl is_less_ignore_case; typedef std::multimap::type, string::type, is_less_ignore_case> type; }; } // namespace impl } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_CONTAINER_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/method.ipp000066400000000000000000000012471240331347200300730ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_METHOD_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_METHOD_IPP #include namespace boost { namespace network { namespace http { template <> struct method { static boost::uint32_t const MAX = 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_METHOD_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/post_content.ipp000066400000000000000000000013071240331347200313270ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_POST_CONTENT_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_POST_CONTENT_IPP #include namespace boost { namespace network { namespace http { template <> struct post_content { static boost::uint32_t const MAX = 1024u * 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_POST_CONTENT_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/query_container.ipp000066400000000000000000000013621240331347200320200ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_QUERY_CONTAINER_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_QUERY_CONTAINER_IPP #include #include namespace boost { namespace network { namespace http { template struct query_container { typedef std::multimap::type, typename string::type> type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_QUERY_CONTAINER_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/query_name.ipp000066400000000000000000000012671240331347200307620ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_NAME_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_NAME_IPP #include namespace boost { namespace network { namespace http { template <> struct query_name { static boost::uint32_t const MAX = 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_NAME_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/query_string.ipp000066400000000000000000000013071240331347200313430ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_STRING_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_STRING_IPP #include namespace boost { namespace network { namespace http { template <> struct query_string { static boost::uint32_t const MAX = 1024u * 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_STRING_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/query_value.ipp000066400000000000000000000013031240331347200311450ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_VALUE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_VALUE_IPP #include namespace boost { namespace network { namespace http { template <> struct query_value { static boost::uint32_t const MAX = 1024u * 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_QUERY_VALUE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/request_methods.ipp000066400000000000000000000021611240331347200320220ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_REQUEST_METHODS_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_REQUEST_METHODS_IPP #include namespace boost { namespace network { namespace http { template <> struct request_methods { static char const* head() { static char const* const HEAD = "HEAD"; return HEAD; }; static char const* get() { static char const* const GET = "GET"; return GET; }; static char const* put() { static char const* const PUT = "PUT"; return PUT; }; static char const* post() { static char const* const POST = "POST"; return POST; }; static char const* delete_() { static char const* const DELETE_ = "DELETE"; return DELETE_; }; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_REQUEST_METHODS_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/resource.ipp000066400000000000000000000012661240331347200304430ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_RESOURCE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_RESOURCE_IPP #include namespace boost { namespace network { namespace http { template <> struct resource { static boost::uint32_t const MAX = 1024u * 256u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_RESOURCE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/response_code.ipp000066400000000000000000000030131240331347200314340ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_RESPONSE_CODE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_RESPONSE_CODE_IPP #include #include namespace boost { namespace network { namespace http { /* This glob doesn't have a specialization on the * tags::http_default_8bit_tcp_resolve * yet because it doesn't need to define different behaviour/types * on different message tags -- for example, it doesn't need to * determine the type or change the values of the data no matter * what the tag type is provided. */ template struct response_code { static boost::uint16_t const OK = 200u; static boost::uint16_t const CREATED = 201u; static boost::uint16_t const NO_CONTENT = 204u; static boost::uint16_t const UNAUTHORIZED = 401u; static boost::uint16_t const FORBIDDEN = 403u; static boost::uint16_t const NOT_FOUND = 404u; static boost::uint16_t const METHOD_NOT_ALLOWED = 405u; static boost::uint16_t const NOT_MODIFIED = 304u; static boost::uint16_t const BAD_REQUEST = 400u; static boost::uint16_t const SERVER_ERROR = 500u; static boost::uint16_t const NOT_IMPLEMENTED = 501u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_RESPONSE_CODE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/response_message.ipp000066400000000000000000000037631240331347200321620ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_RESPONSE_MESSAGE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_RESPONSE_MESSAGE_IPP #include namespace boost { namespace network { namespace http { template <> struct response_message { static char const* ok() { static char const* const OK = "OK"; return OK; }; static char const* created() { static char const* const CREATED = "Created"; return CREATED; }; static char const* no_content() { static char const* const NO_CONTENT = "NO Content"; return NO_CONTENT; }; static char const* unauthorized() { static char const* const UNAUTHORIZED = "Unauthorized"; return UNAUTHORIZED; }; static char const* forbidden() { static char const* const FORBIDDEN = "Fobidden"; return FORBIDDEN; }; static char const* not_found() { static char const* const NOT_FOUND = "Not Found"; return NOT_FOUND; }; static char const* method_not_allowed() { static char const* const METHOD_NOT_ALLOWED = "Method Not Allowed"; return METHOD_NOT_ALLOWED; }; static char const* not_modified() { static char const* const NOT_MODIFIED = "Not Modified"; return NOT_MODIFIED; }; static char const* bad_request() { static char const* const BAD_REQUEST = "Bad Request"; return BAD_REQUEST; }; static char const* server_error() { static char const* const SERVER_ERROR = "Server Error"; return SERVER_ERROR; }; static char const* not_implemented() { static char const* const NOT_IMPLEMENTED = "Not Implemented"; return NOT_IMPLEMENTED; }; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_RESPONSE_MESSAGE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/impl/status_message.ipp000066400000000000000000000013141240331347200316350ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_STATUS_MESSAGE_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_STATUS_MESSAGE_IPP #include namespace boost { namespace network { namespace http { template <> struct status_message_text { static boost::uint32_t const MAX = 1024u; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_STATUS_MESSAGE_IPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/message_traits.hpp000066400000000000000000000034611240331347200306630ustar00rootroot00000000000000 // This file is part of the Boost Network library // Based on the Pion Network Library (r421) // Copyright Atomic Labs, Inc. 2007-2008 // See http://cpp-netlib.sourceforge.net for library home page. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Some changes Copyright (c) Dean Michael Berris 2008 #ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HPP namespace boost { namespace network { namespace http { template struct delimiters; template struct headers_; template struct content; template struct request_methods; template struct response_message; template struct response_code; template struct query_container; template struct cookies_container; template struct chunk_cache; } // namespace http } // namespace network } // namespace boost // Defer definition in implementation files #include #include #include #include #include #include #include #include #include #include #endif // BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/parser_traits.hpp000066400000000000000000000036421240331347200305340ustar00rootroot00000000000000// This file is part of the Boost Network library // Based on the Pion Network Library (r421) // Copyright Atomic Labs, Inc. 2007-2008 // See http://cpp-netlib.sourceforge.net for library home page. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Some changes Copyright 2008 (c) Dean Michael Berris #ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HPP #define BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HPP namespace boost { namespace network { namespace http { template struct status_message_text; template struct method; template struct resource; template struct query_string; template struct header_name; template struct header_value; template struct query_name; template struct query_value; template struct cookie_name; template struct cookie_value; template struct post_content; } // namespace http } // namespace network } // namespace boost // Include implementation files #include #include #include #include #include #include #include #include #include #include #include #endif // BOOST_NETWORK_PROTOCOL_HTTP_PARSER_TRAITS_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/resolver.hpp000066400000000000000000000025601240331347200275110ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_RESOLVER_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_RESOLVER_20091214 // Copyright Dean Michael Berris 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct unsupported_tag; template struct resolver : mpl::if_, is_http >, boost::asio::ip::tcp::resolver, typename mpl::if_, is_http >, boost::asio::ip::udp::resolver, unsupported_tag >::type> { BOOST_STATIC_ASSERT( (mpl::not_, is_tcp > >::value)); }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_RESOLVER_20091214 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/resolver_policy.hpp000066400000000000000000000022731240331347200310710ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_RESOLVER_POLICY_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_RESOLVER_POLICY_20091214 // Copyright Dean Michael Berris 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace http { template struct unsupported_tag; template struct resolver_policy : mpl::if_, is_http >, policies::async_resolver, typename mpl::if_, policies::sync_resolver, unsupported_tag >::type> {}; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_RESOLVER_POLICY_20091214 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/http/traits/vector.hpp000066400000000000000000000014561240331347200271550ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_VECTOR_HPP_20101019 #define BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_VECTOR_HPP_20101019 // Copyright (c) Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template <> struct vector { template struct apply { typedef std::vector type; }; }; template <> struct vector { template struct apply { typedef std::vector type; }; }; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_VECTOR_HPP_20101019 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/protocol/stream_handler.hpp000066400000000000000000000124171240331347200263550ustar00rootroot00000000000000#ifndef NETLIB_IO_STREAM_HANDLER_HPP #define NETLIB_IO_STREAM_HANDLER_HPP // Copyright 2014 Jelle Van den Driessche. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #if defined(_MSC_VER) && (_MSC_VER >= 1200) #pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { typedef boost::asio::ssl::stream ssl_socket; typedef boost::asio::ip::tcp::socket tcp_socket; struct stream_handler { public: stream_handler(boost::shared_ptr socket) : tcp_sock_(socket), ssl_enabled(false) {} ~stream_handler() {} stream_handler(boost::shared_ptr socket) : ssl_sock_(socket), ssl_enabled(true) {} stream_handler(boost::asio::io_service& io, boost::shared_ptr ctx = boost::shared_ptr()) { tcp_sock_ = boost::make_shared(boost::ref(io)); ssl_enabled = false; if (ctx) { /// SSL is enabled ssl_sock_ = boost::make_shared(boost::ref(io), boost::ref(*ctx)); ssl_enabled = true; } } template BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, void(boost::system::error_code, std::size_t)) async_write_some(const ConstBufferSequence& buffers, BOOST_ASIO_MOVE_ARG(WriteHandler) handler) { try { if (ssl_enabled) { ssl_sock_->async_write_some(buffers, handler); } else { tcp_sock_->async_write_some(buffers, handler); } } catch (const boost::system::error_code& e) { std::cerr << e.message() << std::endl; } catch (const boost::system::system_error& e) { std::cerr << e.code() << ": " << e.what() << std::endl; } } template BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, void(boost::system::error_code, std::size_t)) async_read_some(const MutableBufferSequence& buffers, BOOST_ASIO_MOVE_ARG(ReadHandler) handler) { try { if (ssl_enabled) { ssl_sock_->async_read_some(buffers, handler); } else { tcp_sock_->async_read_some(buffers, handler); } } catch (const boost::system::error_code& e) { std::cerr << e.message() << std::endl; } catch (const boost::system::system_error& e) { std::cerr << e.code() << ": " << e.what() << std::endl; } } void close(boost::system::error_code& e) { if (ssl_enabled) { ssl_sock_->next_layer().close(); } else { tcp_sock_->close(); } } tcp_socket::endpoint_type remote_endpoint() const { if (ssl_enabled) { return ssl_sock_->next_layer().remote_endpoint(); } else { return tcp_sock_->remote_endpoint(); } } void shutdown(boost::asio::socket_base::shutdown_type st, boost::system::error_code& e) { try { if (ssl_enabled) { ssl_sock_->shutdown(e); } else { tcp_sock_->shutdown(boost::asio::ip::tcp::socket::shutdown_send, e); } } catch (const boost::system::error_code& e) { std::cerr << e.message() << std::endl; } catch (const boost::system::system_error& e) { std::cerr << e.code() << ": " << e.what() << std::endl; } } ssl_socket::next_layer_type& next_layer() const { if (ssl_enabled) { return ssl_sock_->next_layer(); } else { return *tcp_sock_; } } ssl_socket::lowest_layer_type& lowest_layer() const { if (ssl_enabled) { return ssl_sock_->lowest_layer(); } else { return tcp_sock_->lowest_layer(); } } template BOOST_ASIO_INITFN_RESULT_TYPE(HandshakeHandler, void(boost::system::error_code)) async_handshake(ssl_socket::handshake_type type, BOOST_ASIO_MOVE_ARG(HandshakeHandler) handler) { try { if (ssl_enabled) { return ssl_sock_->async_handshake(type, handler); } else { // NOOP } } catch (const boost::system::error_code& e) { std::cerr << e.message() << std::endl; } catch (const boost::system::system_error& e) { std::cerr << e.code() << ": " << e.what() << std::endl; } } boost::shared_ptr get_tcp_socket() { return tcp_sock_; } boost::shared_ptr get_ssl_socket() { return ssl_sock_; } bool is_ssl_enabled() { return ssl_enabled; } private: boost::shared_ptr tcp_sock_; boost::shared_ptr ssl_sock_; bool ssl_enabled; }; } } #endif cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/000077500000000000000000000000001240331347200225225ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_async.hpp000066400000000000000000000013541240331347200250460ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_ASYNC_HPP_20100608 #define BOOST_NETWORK_SUPPORT_IS_ASYNC_HPP_20100608 // Copyright 2010 (c) Dean Michael Berris // Copyright 2010 (c) Sinefunc, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template struct is_async : mpl::false_ {}; template struct is_async< Tag, typename enable_if::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_IS_ASYNC_HPP_2010608 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_default_string.hpp000066400000000000000000000013431240331347200267410ustar00rootroot00000000000000// Copyright Dean Michael Berris 2010 // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_SUPPORT_STRING_CHECK_20100808 #define BOOST_NETWORK_SUPPORT_STRING_CHECK_20100808 #include #include namespace boost { namespace network { template struct is_default_string : mpl::false_ {}; template struct is_default_string< Tag, typename enable_if::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_STRING_CHECK_20100808 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_default_wstring.hpp000066400000000000000000000013501240331347200271260ustar00rootroot00000000000000// Copyright Dean Michael Berris 2010 // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_SUPPORT_WSTRING_CHECK_20100808 #define BOOST_NETWORK_SUPPORT_WSTRING_CHECK_20100808 #include #include namespace boost { namespace network { template struct is_default_wstring : mpl::false_ {}; template struct is_default_wstring< Tag, typename enable_if::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_STRING_CHECK_20100808 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_http.hpp000066400000000000000000000013141240331347200247040ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_HTTP_HPP_20100622 #define BOOST_NETWORK_SUPPORT_IS_HTTP_HPP_20100622 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template struct is_http : mpl::false_ {}; template struct is_http::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_IS_HTTP_HPP_20100622 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_keepalive.hpp000066400000000000000000000013221240331347200256710ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 #define BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template struct is_keepalive : mpl::false_ {}; template struct is_keepalive< Tag, typename enable_if::type> : mpl::true_ {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_pod.hpp000066400000000000000000000012641240331347200245130ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_POD_HPP_20101120 #define BOOST_NETWORK_SUPPORT_IS_POD_HPP_20101120 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template struct is_pod : mpl::false_ {}; template struct is_pod::type> : mpl::true_ {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_POD_HPP_20101120 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_simple.hpp000066400000000000000000000013001240331347200252110ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 #define BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template struct is_simple : mpl::false_ {}; template struct is_simple< Tag, typename enable_if::type> : mpl::true_ {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_sync.hpp000066400000000000000000000013141240331347200247010ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_SYNC_HPP_20100623 #define BOOST_NETWORK_SUPPORT_IS_SYNC_HPP_20100623 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { template struct is_sync : mpl::false_ {}; template struct is_sync::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_IS_SYNC_HPP_20100623 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_tcp.hpp000066400000000000000000000014041240331347200245130ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_TCP_HPP_20100622 #define BOOST_NETWORK_SUPPORT_IS_TCP_HPP_20100622 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include namespace boost { namespace network { template struct is_tcp : mpl::false_ {}; template struct is_tcp::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_IS_TCP_HPP_20100622cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/is_udp.hpp000066400000000000000000000014611240331347200245200ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_IS_UDP_HPP_20100622 #define BOOST_NETWORK_SUPPORT_IS_UDP_HPP_20100622 // Copyright 2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { template struct is_udp : mpl::false_ {}; template struct is_udp::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_IS_UDP_HPP_20100622 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/pod_or_normal.hpp000066400000000000000000000014661240331347200260740ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_POD_OR_NORMAL_HPP_20101128 #define BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_POD_OR_NORMAL_HPP_20101128 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include namespace boost { namespace network { template struct pod_or_normal { typedef tags::normal type; }; template struct pod_or_normal< Tag, typename enable_if::type> : tags::pod {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_POD_OR_NORMAL_HPP_20101128 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/support/sync_only.hpp000066400000000000000000000017371240331347200252600ustar00rootroot00000000000000#ifndef BOOST_NETWORK_SUPPORT_SYNC_ONLY_HPP_20100927 #define BOOST_NETWORK_SUPPORT_SYNC_ONLY_HPP_20100927 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include namespace boost { namespace network { template struct sync_only : mpl::inherit_linearly< typename mpl::replace_if::type, is_same, tags::sync>::type, mpl::inherit > {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_SYNC_ONLY_HPP_20100927 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/tags.hpp000066400000000000000000000036371240331347200224660ustar00rootroot00000000000000// Copyright Dean Michael Berris 2008, 2009. // Glyn Matthews 2009 // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_TAG_INCLUDED_20100808 #define BOOST_NETWORK_TAG_INCLUDED_20100808 #include #include #include #include namespace boost { namespace network { namespace tags { struct pod { typedef mpl::true_::type is_pod; }; struct normal { typedef mpl::true_::type is_normal; }; struct async { typedef mpl::true_::type is_async; }; struct tcp { typedef mpl::true_::type is_tcp; }; struct udp { typedef mpl::true_::type is_udp; }; struct sync { typedef mpl::true_::type is_sync; }; struct default_string { typedef mpl::true_::type is_default_string; }; struct default_wstring { typedef mpl::true_::type is_default_wstring; }; template struct components; // Tag Definition Macro Helper #ifndef BOOST_NETWORK_DEFINE_TAG #define BOOST_NETWORK_DEFINE_TAG(name) \ struct name \ : mpl::inherit_linearly >::type {}; \ template <> \ struct components { \ typedef name##_tags type; \ }; #endif // BOOST_NETWORK_DEFINE_TAG typedef default_string default_; } // namespace tags } // namespace network } // namespace boost #endif // __BOOST_NETWORK_TAGS_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/000077500000000000000000000000001240331347200223145ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/char.hpp000066400000000000000000000016401240331347200237430ustar00rootroot00000000000000// Copyright (c) Dean Michael Berris 2008, 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_TRAITS_CHAR_HPP #define BOOST_NETWORK_TRAITS_CHAR_HPP #include #include namespace boost { namespace network { template struct unsupported_tag; template struct char_ { typedef unsupported_tag type; }; template struct char_ >::type> { typedef char type; }; template struct char_ >::type> { typedef wchar_t type; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_CHAR_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/headers_container.hpp000066400000000000000000000016301240331347200265020ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2009. // Copyright 2013 Google, Inc. // Copyright 2013 Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_TRAITS_HEADERS_CONTAINER_INC #define BOOST_NETWORK_TRAITS_HEADERS_CONTAINER_INC #include #include #include namespace boost { namespace network { namespace impl { template struct headers_container_impl { typedef std::multimap::type, typename string::type> type; }; } // namespace impl template struct headers_container : impl::headers_container_impl {}; } // namespace network } // namespace boost #endif // __BOOST_NETWORK_TRAITS_HEADERS_CONTAINER_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/istream.hpp000066400000000000000000000017511240331347200244750ustar00rootroot00000000000000 #ifndef BOOST_NETWORK_TRAITS_ISTREAM_HPP_20100924 #define BOOST_NETWORK_TRAITS_ISTREAM_HPP_20100924 // Copyright 2010 (C) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include namespace boost { namespace network { template struct unsupported_tag; template struct istream { typedef unsupported_tag type; }; template struct istream >::type> { typedef std::istream type; }; template struct istream >::type> { typedef std::wistream type; }; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_TRAITS_ISTREAM_HPP_20100924 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/istringstream.hpp000066400000000000000000000021271240331347200257220ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2009. // Copyright (c) Dean Michael Berris 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_TRAITS_ISTRINGSTREAM_INC #define BOOST_NETWORK_TRAITS_ISTRINGSTREAM_INC #include #include #include #include namespace boost { namespace network { template struct unsupported_tag; template struct istringstream { typedef unsupported_tag type; }; template struct istringstream >::type> { typedef std::istringstream type; }; template struct istringstream >::type> { typedef std::basic_istringstream type; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_ISTRINGSTREAM_INC cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/ostream_iterator.hpp000066400000000000000000000020501240331347200264050ustar00rootroot00000000000000#ifndef BOOST_NETWORK_TRAITS_OSTREAM_ITERATOR_HPP_20100815 #define BOOST_NETWORK_TRAITS_OSTREAM_ITERATOR_HPP_20100815 // Copyright 2010 (C) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include namespace boost { namespace network { template struct unsupported_tag; template struct ostream_iterator; template struct ostream_iterator : mpl::if_, std::ostream_iterator, typename mpl::if_, std::ostream_iterator, unsupported_tag >::type> {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_OSTREAM_ITERATOR_HPP_20100815 cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/ostringstream.hpp000066400000000000000000000021531240331347200257270ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2009. // Copyright (c) Dean Michael Berris 2009, 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_TRAITS_OSTRINGSTREAM_INC #define BOOST_NETWORK_TRAITS_OSTRINGSTREAM_INC #include #include #include #include #include namespace boost { namespace network { template struct unsupported_tag; template struct ostringstream { typedef unsupported_tag type; }; template struct ostringstream >::type> { typedef std::ostringstream type; }; template struct ostringstream >::type> { typedef std::wostringstream type; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_OSTRINGSTREAM_INC cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/string.hpp000066400000000000000000000023721240331347200243370ustar00rootroot00000000000000// Copyright (c) Dean Michael Berris 2008, 2009. // Glyn Matthews 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_TRAITS_STRING_INC #define BOOST_NETWORK_TRAITS_STRING_INC #include #include #include #include #ifndef BOOST_NETWORK_DEFAULT_STRING #define BOOST_NETWORK_DEFAULT_STRING std::string #endif #ifndef BOOST_NETWORK_DEFAULT_WSTRING #define BOOST_NETWORK_DEFAULT_WSTRING std::wstring #endif namespace boost { namespace network { template struct unsupported_tag; template struct string { typedef unsupported_tag type; }; template struct string >::type> { typedef BOOST_NETWORK_DEFAULT_STRING type; }; template struct string >::type> { typedef BOOST_NETWORK_DEFAULT_WSTRING type; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_STRING_INC cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/traits/vector.hpp000066400000000000000000000013541240331347200243320ustar00rootroot00000000000000// Copyright (c) Dean Michael Berris 2008, 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_TRAITS_VECTOR_HPP #define BOOST_NETWORK_TRAITS_VECTOR_HPP #include #include namespace boost { namespace network { template struct unsupported_tag; template struct vector { template struct apply : mpl::if_, std::vector, unsupported_tag > {}; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_VECTOR_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri.hpp000066400000000000000000000004601240331347200223160ustar00rootroot00000000000000#ifndef BOOST_NETWORK_URL_HPP_ #define BOOST_NETWORK_URL_HPP_ // Copyright 2009 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #endif cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/000077500000000000000000000000001240331347200216055ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/accessors.hpp000066400000000000000000000060171240331347200243070ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_URI_ACCESSORS_INC__ #define __BOOST_NETWORK_URI_URI_ACCESSORS_INC__ #include #include #include #include #include namespace boost { namespace network { namespace uri { namespace details { template struct key_value_sequence : spirit::qi::grammar { typedef typename Map::key_type key_type; typedef typename Map::mapped_type mapped_type; typedef std::pair pair_type; key_value_sequence() : key_value_sequence::base_type(query) { query = pair >> *((spirit::qi::lit(';') | '&') >> pair); pair = key >> -('=' >> value); key = spirit::qi::char_("a-zA-Z_") >> *spirit::qi::char_("-+.~a-zA-Z_0-9/%"); value = +spirit::qi::char_("-+.~a-zA-Z_0-9/%"); } spirit::qi::rule query; spirit::qi::rule pair; spirit::qi::rule key; spirit::qi::rule value; }; } // namespace details template inline Map &query_map(const uri &uri_, Map &map) { const uri::string_type range = uri_.query(); details::key_value_sequence parser; spirit::qi::parse(boost::begin(range), boost::end(range), parser, map); return map; } inline uri::string_type username(const uri &uri_) { const uri::string_type user_info = uri_.user_info(); uri::const_iterator it(boost::begin(user_info)), end(boost::end(user_info)); for (; it != end; ++it) { if (*it == ':') { break; } } return uri::string_type(boost::begin(user_info), it); } inline uri::string_type password(const uri &uri_) { const uri::string_type user_info = uri_.user_info(); uri::const_iterator it(boost::begin(user_info)), end(boost::end(user_info)); for (; it != end; ++it) { if (*it == ':') { ++it; break; } } return uri::string_type(it, boost::end(user_info)); } inline uri::string_type decoded_path(const uri &uri_) { const uri::string_type path = uri_.path(); uri::string_type decoded_path; decode(path, std::back_inserter(decoded_path)); return decoded_path; } inline uri::string_type decoded_query(const uri &uri_) { const uri::string_type query = uri_.query(); uri::string_type decoded_query; decode(query, std::back_inserter(decoded_query)); return decoded_query; } inline uri::string_type decoded_fragment(const uri &uri_) { const uri::string_type fragment = uri_.fragment(); uri::string_type decoded_fragment; decode(fragment, std::back_inserter(decoded_fragment)); return decoded_fragment; } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_URI_ACCESSORS_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/builder.hpp000066400000000000000000000071521240331347200237510ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_BUILDER_INC__ #define __BOOST_NETWORK_URI_BUILDER_INC__ #include #include namespace boost { namespace network { namespace uri { class builder { typedef uri::string_type string_type; public: builder(uri &uri_) : uri_(uri_) {} builder &set_scheme(const string_type &scheme) { uri_.uri_.append(scheme); if (opaque_schemes::exists(scheme)) { uri_.uri_.append(":"); } else { uri_.uri_.append("://"); } uri_.parse(); return *this; } builder &scheme(const string_type &scheme) { return set_scheme(scheme); } builder &set_user_info(const string_type &user_info) { uri_.uri_.append(user_info); uri_.uri_.append("@"); uri_.parse(); return *this; } builder &user_info(const string_type &user_info) { return set_user_info(user_info); } builder &set_host(const string_type &host) { uri_.uri_.append(host); uri_.parse(); return *this; } builder &host(const string_type &host) { return set_host(host); } builder &set_host(const asio::ip::address &address) { uri_.uri_.append(address.to_string()); uri_.parse(); return *this; } builder &host(const asio::ip::address &host) { return set_host(host); } builder &set_host(const asio::ip::address_v4 &address) { uri_.uri_.append(address.to_string()); uri_.parse(); return *this; } builder &host(const asio::ip::address_v4 &host) { return set_host(host); } builder &set_host(const asio::ip::address_v6 &address) { uri_.uri_.append("["); uri_.uri_.append(address.to_string()); uri_.uri_.append("]"); uri_.parse(); return *this; } builder &host(const asio::ip::address_v6 &host) { return set_host(host); } builder &set_port(const string_type &port) { uri_.uri_.append(":"); uri_.uri_.append(port); uri_.parse(); return *this; } builder &port(const string_type &port) { return set_port(port); } builder &port(uint16_t port) { return set_port(boost::lexical_cast(port)); } builder &set_path(const string_type &path) { uri_.uri_.append(path); uri_.parse(); return *this; } builder &path(const string_type &path) { return set_path(path); } builder &encoded_path(const string_type &path) { string_type encoded_path; encode(path, std::back_inserter(encoded_path)); return set_path(encoded_path); } builder &set_query(const string_type &query) { uri_.uri_.append("?"); uri_.uri_.append(query); uri_.parse(); return *this; } builder &set_query(const string_type &key, const string_type &value) { if (!uri_.query_range()) { uri_.uri_.append("?"); } else { uri_.uri_.append("&"); } uri_.uri_.append(key); uri_.uri_.append("="); uri_.uri_.append(value); uri_.parse(); return *this; } builder &query(const string_type &query) { return set_query(query); } builder &query(const string_type &key, const string_type &value) { return set_query(key, value); } builder &set_fragment(const string_type &fragment) { uri_.uri_.append("#"); uri_.uri_.append(fragment); uri_.parse(); return *this; } builder &fragment(const string_type &fragment) { return set_fragment(fragment); } private: uri &uri_; }; } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_BUILDER_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/config.hpp000066400000000000000000000011261240331347200235630ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_CONFIG_INC__ #define __BOOST_NETWORK_URI_CONFIG_INC__ #include #include #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_URI_DYN_LINK) #define BOOST_URI_DECL #else #define BOOST_URI_DECL #endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_URI_DYN_LINK) #endif // __BOOST_NETWORK_URI_CONFIG_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/decode.hpp000066400000000000000000000042231240331347200235420ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DECODE_INC__ #define __BOOST_NETWORK_URI_DECODE_INC__ #include #include #include #include namespace boost { namespace network { namespace uri { namespace detail { template CharT letter_to_hex(CharT in) { switch (in) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': return in - '0'; case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': return in + 10 - 'a'; case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': return in + 10 - 'A'; } return CharT(); } } // namespace detail template OutputIterator decode(const InputIterator &in_begin, const InputIterator &in_end, const OutputIterator &out_begin) { typedef typename boost::iterator_value::type value_type; InputIterator it = in_begin; OutputIterator out = out_begin; while (it != in_end) { if (*it == '%') { ++it; value_type v0 = detail::letter_to_hex(*it); ++it; value_type v1 = detail::letter_to_hex(*it); ++it; *out++ = 0x10 * v0 + v1; } else if (*it == '+') { *out++ = ' '; ++it; } else { *out++ = *it++; } } return out; } template inline OutputIterator decode(const SinglePassRange &range, const OutputIterator &out) { return decode(boost::begin(range), boost::end(range), out); } inline std::string decoded(const std::string &input) { std::string decoded; decode(input, std::back_inserter(decoded)); return decoded; } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DECODE_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/detail/000077500000000000000000000000001240331347200230475ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/detail/uri_parts.hpp000066400000000000000000000047351240331347200256010ustar00rootroot00000000000000// Copyright 2009, 2010, 2011, 2012 Dean Michael Berris, Jeroen Habraken, Glyn // Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NETWORK_URL_DETAIL_URL_PARTS_HPP_ #define BOOST_NETWORK_URL_DETAIL_URL_PARTS_HPP_ #include #include namespace boost { namespace network { namespace uri { namespace detail { template struct hierarchical_part { optional > user_info; optional > host; optional > port; optional > path; FwdIter begin() const { return boost::begin(user_info); } FwdIter end() const { return boost::end(path); } void update() { if (!user_info) { if (host) { user_info = iterator_range(boost::begin(host.get()), boost::begin(host.get())); } else if (path) { user_info = iterator_range(boost::begin(path.get()), boost::begin(path.get())); } } if (!host) { host = iterator_range(boost::begin(path.get()), boost::begin(path.get())); } if (!port) { port = iterator_range(boost::end(host.get()), boost::end(host.get())); } if (!path) { path = iterator_range(boost::end(port.get()), boost::end(port.get())); } } }; template struct uri_parts { iterator_range scheme; hierarchical_part hier_part; optional > query; optional > fragment; FwdIter begin() const { return boost::begin(scheme); } FwdIter end() const { return boost::end(fragment); } void update() { hier_part.update(); if (!query) { query = iterator_range(boost::end(hier_part.path.get()), boost::end(hier_part.path.get())); } if (!fragment) { fragment = iterator_range(boost::end(query.get()), boost::end(query.get())); } } }; } // namespace detail } // namespace uri } // namespace network } // namespace boost #endif // BOOST_NETWORK_URL_DETAIL_URL_PARTS_HPP_ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives.hpp000066400000000000000000000023301240331347200244550ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_INC__ #include namespace boost { namespace network { namespace uri { inline uri &operator<<(uri &uri_, const uri &root_uri) { if (empty(uri_) && valid(root_uri)) { uri_.append(boost::begin(root_uri), boost::end(root_uri)); } return uri_; } template inline uri &operator<<(uri &uri_, const Directive &directive) { directive(uri_); return uri_; } } // namespace uri } // namespace network } // namespace boost #include #include #include #include #include #include #include #include #endif // __BOOST_NETWORK_URI_DIRECTIVES_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/000077500000000000000000000000001240331347200237465ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/authority.hpp000066400000000000000000000015451240331347200265140ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_AUTHORITY_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_AUTHORITY_INC__ namespace boost { namespace network { namespace uri { struct authority_directive { explicit authority_directive(const std::string &authority) : authority(authority) {} template void operator()(Uri &uri) const { uri.append(authority); } std::string authority; }; inline authority_directive authority(const std::string &authority) { return authority_directive(authority); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_AUTHORITY_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/fragment.hpp000066400000000000000000000017241240331347200262660ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_FRAGMENT_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_FRAGMENT_INC__ #include #include #include namespace boost { namespace network { namespace uri { struct fragment_directive { explicit fragment_directive(const std::string &fragment) : fragment(fragment) {} template void operator()(Uri &uri) const { uri.append("#"); uri.append(fragment); } std::string fragment; }; inline fragment_directive fragment(const std::string &fragment) { return fragment_directive(fragment); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_FRAGMENT_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/host.hpp000066400000000000000000000015251240331347200254370ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_HOST_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_HOST_INC__ #include #include namespace boost { namespace network { namespace uri { struct host_directive { explicit host_directive(const std::string &host) : host(host) {} template void operator()(Uri &uri) const { uri.append(host); } std::string host; }; inline host_directive host(const std::string &host) { return host_directive(host); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_HOST_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/path.hpp000066400000000000000000000023631240331347200254170ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_PATH_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_PATH_INC__ #include #include namespace boost { namespace network { namespace uri { struct path_directive { explicit path_directive(const std::string &path) : path(path) {} template void operator()(Uri &uri) const { uri.append(path); } std::string path; }; struct encoded_path_directive { explicit encoded_path_directive(const std::string &path) : path(path) {} void operator()(uri &uri_) const { std::string encoded_path; encode(path, std::back_inserter(encoded_path)); uri_.append(encoded_path); } std::string path; }; inline path_directive path(const std::string &path) { return path_directive(path); } inline encoded_path_directive encoded_path(const std::string &path) { return encoded_path_directive(path); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_PATH_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/port.hpp000066400000000000000000000021471240331347200254470ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_PORT_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_PORT_INC__ #include #include #include #include namespace boost { namespace network { namespace uri { struct port_directive { explicit port_directive(const std::string &port) : port(port) {} explicit port_directive(boost::uint16_t port) : port(boost::lexical_cast(port)) {} template void operator()(Uri &uri) const { uri.append(":"); uri.append(port); } std::string port; }; inline port_directive port(const std::string &port) { return port_directive(port); } inline port_directive port(boost::uint16_t port) { return port_directive(port); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_PORT_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/query.hpp000066400000000000000000000030521240331347200256240ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_QUERY_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_QUERY_INC__ #include #include #include namespace boost { namespace network { namespace uri { struct query_directive { explicit query_directive(const std::string &query) : query(query) {} template void operator()(Uri &uri) const { uri.append("?"); uri.append(query); } std::string query; }; inline query_directive query(const std::string &query) { return query_directive(query); } struct query_key_query_directive { query_key_query_directive(const std::string &key, const std::string &query) : key(key), query(query) {} template void operator()(Uri &uri) const { std::string encoded_key, encoded_query; if (boost::empty(uri.query())) { uri.append("?"); } else { uri.append("&"); } uri.append(key); uri.append("="); uri.append(query); } std::string key; std::string query; }; inline query_key_query_directive query(const std::string &key, const std::string &query) { return query_key_query_directive(key, query); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_QUERY_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/scheme.hpp000066400000000000000000000023671240331347200257330ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_SCHEME_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_SCHEME_INC__ #include #include #include namespace boost { namespace network { namespace uri { struct scheme_directive { explicit scheme_directive(const std::string &scheme) : scheme(scheme) {} template void operator()(Uri &uri) const { uri.append(scheme); if (opaque_schemes::exists(scheme)) { uri.append(":"); } else { uri.append("://"); } } std::string scheme; }; inline scheme_directive scheme(const std::string &scheme) { return scheme_directive(scheme); } namespace schemes { inline uri &http(uri &uri_) { return uri_ << scheme("http"); } inline uri &https(uri &uri_) { return uri_ << scheme("https"); } inline uri &file(uri &uri_) { return uri_ << scheme("file"); } } // namespace schemes } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_SCHEME_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/directives/user_info.hpp000066400000000000000000000016731240331347200264570ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_DIRECTIVES_USER_INFO_INC__ #define __BOOST_NETWORK_URI_DIRECTIVES_USER_INFO_INC__ #include #include namespace boost { namespace network { namespace uri { struct user_info_directive { explicit user_info_directive(const std::string &user_info) : user_info(user_info) {} template void operator()(Uri &uri) const { uri.append(user_info); uri.append("@"); } std::string user_info; }; inline user_info_directive user_info(const std::string &user_info) { return user_info_directive(user_info); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_DIRECTIVES_USER_INFO_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/encode.hpp000066400000000000000000000060031240331347200235520ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_ENCODE_INC__ #define __BOOST_NETWORK_URI_ENCODE_INC__ #include #include #include #include #include namespace boost { namespace network { namespace uri { namespace detail { template inline CharT hex_to_letter(CharT in) { switch (in) { case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: return in + '0'; case 10: case 11: case 12: case 13: case 14: default: return in - 10 + 'A'; } return CharT(); } template void encode_char(CharT in, OutputIterator &out) { switch (in) { case 'a': case 'A': case 'b': case 'B': case 'c': case 'C': case 'd': case 'D': case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': case 'h': case 'H': case 'i': case 'I': case 'j': case 'J': case 'k': case 'K': case 'l': case 'L': case 'm': case 'M': case 'n': case 'N': case 'o': case 'O': case 'p': case 'P': case 'q': case 'Q': case 'r': case 'R': case 's': case 'S': case 't': case 'T': case 'u': case 'U': case 'v': case 'V': case 'w': case 'W': case 'x': case 'X': case 'y': case 'Y': case 'z': case 'Z': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '-': case '.': case '_': case '~': case '/': out++ = in; break; default: out++ = '%'; out++ = hex_to_letter(in >> 4); out++ = hex_to_letter(in & 0x0f); ; } } } // namespace detail template OutputIterator encode(const InputIterator &in_begin, const InputIterator &in_end, const OutputIterator &out_begin) { typedef typename boost::iterator_value::type value_type; InputIterator it = in_begin; OutputIterator out = out_begin; while (it != in_end) { detail::encode_char(*it, out); ++it; } return out; } template inline OutputIterator encode(const SinglePassRange &range, const OutputIterator &out) { return encode(boost::begin(range), boost::end(range), out); } inline std::string encoded(const std::string &input) { std::string encoded; encode(input, std::back_inserter(encoded)); return encoded; } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_ENCODE_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/schemes.hpp000066400000000000000000000012261240331347200237460ustar00rootroot00000000000000// Copyright 2012 Glyn Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_SCHEMES_INC__ #define __BOOST_NETWORK_URI_SCHEMES_INC__ #include namespace boost { namespace network { namespace uri { class hierarchical_schemes { public: static bool exists(const std::string &scheme); }; class opaque_schemes { public: static bool exists(const std::string &scheme); }; } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_SCHEMES_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/uri.hpp000066400000000000000000000246341240331347200231260ustar00rootroot00000000000000// Copyright 2009, 2010, 2011, 2012 Dean Michael Berris, Jeroen Habraken, Glyn // Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_INC__ #define __BOOST_NETWORK_URI_INC__ #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace uri { namespace detail { bool parse(std::string::const_iterator first, std::string::const_iterator last, uri_parts &parts); } // namespace detail class BOOST_URI_DECL uri { friend class builder; public: typedef std::string string_type; typedef string_type::value_type value_type; typedef string_type::const_iterator const_iterator; typedef boost::iterator_range const_range_type; uri() : is_valid_(false) {} // uri(const value_type *uri) // : uri_(uri), is_valid_(false) { // parse(); //} uri(const string_type &uri) : uri_(uri), is_valid_(false) { parse(); } template uri(const FwdIter &first, const FwdIter &last) : uri_(first, last), is_valid_(false) { parse(); } uri(const uri &other) : uri_(other.uri_) { parse(); } uri &operator=(const uri &other) { uri(other).swap(*this); return *this; } uri &operator=(const string_type &uri_string) { uri(uri_string).swap(*this); return *this; } ~uri() {} void swap(uri &other) { boost::swap(uri_, other.uri_); other.parse(); boost::swap(is_valid_, other.is_valid_); } const_iterator begin() const { return uri_.begin(); } const_iterator end() const { return uri_.end(); } const_range_type scheme_range() const { return uri_parts_.scheme; } const_range_type user_info_range() const { return uri_parts_.hier_part.user_info ? uri_parts_.hier_part.user_info.get() : const_range_type(); } const_range_type host_range() const { return uri_parts_.hier_part.host ? uri_parts_.hier_part.host.get() : const_range_type(); } const_range_type port_range() const { return uri_parts_.hier_part.port ? uri_parts_.hier_part.port.get() : const_range_type(); } const_range_type path_range() const { return uri_parts_.hier_part.path ? uri_parts_.hier_part.path.get() : const_range_type(); } const_range_type query_range() const { return uri_parts_.query ? uri_parts_.query.get() : const_range_type(); } const_range_type fragment_range() const { return uri_parts_.fragment ? uri_parts_.fragment.get() : const_range_type(); } string_type scheme() const { const_range_type range = scheme_range(); return range ? string_type(boost::begin(range), boost::end(range)) : string_type(); } string_type user_info() const { const_range_type range = user_info_range(); return range ? string_type(boost::begin(range), boost::end(range)) : string_type(); } string_type host() const { const_range_type range = host_range(); return range ? string_type(boost::begin(range), boost::end(range)) : string_type(); } string_type port() const { const_range_type range = port_range(); return range ? string_type(boost::begin(range), boost::end(range)) : string_type(); } string_type path() const { const_range_type range = path_range(); return range ? string_type(boost::begin(range), boost::end(range)) : string_type(); } string_type query() const { const_range_type range = query_range(); return range ? string_type(boost::begin(range), boost::end(range)) : string_type(); } string_type fragment() const { const_range_type range = fragment_range(); return range ? string_type(boost::begin(range), boost::end(range)) : string_type(); } string_type string() const { return uri_; } bool is_valid() const { return is_valid_; } void append(const string_type &data) { uri_.append(data); parse(); } template void append(const FwdIter &first, const FwdIter &last) { uri_.append(first, last); parse(); } private: void parse(); string_type uri_; detail::uri_parts uri_parts_; bool is_valid_; }; inline void uri::parse() { const_iterator first(boost::begin(uri_)), last(boost::end(uri_)); is_valid_ = detail::parse(first, last, uri_parts_); if (is_valid_) { if (!uri_parts_.scheme) { uri_parts_.scheme = const_range_type(boost::begin(uri_), boost::begin(uri_)); } uri_parts_.update(); } } inline uri::string_type scheme(const uri &uri_) { return uri_.scheme(); } inline uri::string_type user_info(const uri &uri_) { return uri_.user_info(); } inline uri::string_type host(const uri &uri_) { return uri_.host(); } inline uri::string_type port(const uri &uri_) { return uri_.port(); } inline boost::optional port_us(const uri &uri_) { uri::string_type port = uri_.port(); return (port.empty()) ? boost::optional() : boost::optional( boost::lexical_cast(port)); } inline uri::string_type path(const uri &uri_) { return uri_.path(); } inline uri::string_type query(const uri &uri_) { return uri_.query(); } inline uri::string_type fragment(const uri &uri_) { return uri_.fragment(); } inline uri::string_type hierarchical_part(const uri &uri_) { uri::string_type::const_iterator first, last; uri::const_range_type user_info = uri_.user_info_range(); uri::const_range_type host = uri_.host_range(); uri::const_range_type port = uri_.port_range(); uri::const_range_type path = uri_.path_range(); if (user_info) { first = boost::begin(user_info); } else { first = boost::begin(host); } if (path) { last = boost::end(path); } else if (port) { last = boost::end(port); } else { last = boost::end(host); } return uri::string_type(first, last); } inline uri::string_type authority(const uri &uri_) { uri::string_type::const_iterator first, last; uri::const_range_type user_info = uri_.user_info_range(); uri::const_range_type host = uri_.host_range(); uri::const_range_type port = uri_.port_range(); if (user_info) { first = boost::begin(user_info); } else { first = boost::begin(host); } if (port) { last = boost::end(port); } else { last = boost::end(host); } return uri::string_type(first, last); } inline bool valid(const uri &uri_) { return uri_.is_valid(); } inline bool is_absolute(const uri &uri_) { return uri_.is_valid() && !boost::empty(uri_.scheme_range()); } inline bool is_relative(const uri &uri_) { return uri_.is_valid() && boost::empty(uri_.scheme_range()); } inline bool is_hierarchical(const uri &uri_) { return is_absolute(uri_) && hierarchical_schemes::exists(scheme(uri_)); } inline bool is_opaque(const uri &uri_) { return is_absolute(uri_) && opaque_schemes::exists(scheme(uri_)); } inline bool is_valid(const uri &uri_) { return valid(uri_); } inline void swap(uri &lhs, uri &rhs) { lhs.swap(rhs); } inline std::size_t hash_value(const uri &uri_) { std::size_t seed = 0; for (uri::const_iterator it = begin(uri_); it != end(uri_); ++it) { hash_combine(seed, *it); } return seed; } inline bool operator==(const uri &lhs, const uri &rhs) { return boost::equal(lhs, rhs); } inline bool operator==(const uri &lhs, const uri::string_type &rhs) { return boost::equal(lhs, rhs); } inline bool operator==(const uri::string_type &lhs, const uri &rhs) { return boost::equal(lhs, rhs); } inline bool operator==(const uri &lhs, const uri::value_type *rhs) { return boost::equal(lhs, boost::as_literal(rhs)); } inline bool operator==(const uri::value_type *lhs, const uri &rhs) { return boost::equal(boost::as_literal(lhs), rhs); } inline bool operator!=(const uri &lhs, const uri &rhs) { return !(lhs == rhs); } inline bool operator<(const uri &lhs, const uri &rhs) { return lhs.string() < rhs.string(); } } // namespace uri } // namespace network } // namespace boost #include #include #include namespace boost { namespace network { namespace uri { inline uri from_parts(const uri &base_uri, const uri::string_type &path_, const uri::string_type &query_, const uri::string_type &fragment_) { uri uri_(base_uri); builder(uri_).path(path_).query(query_).fragment(fragment_); return uri_; } inline uri from_parts(const uri &base_uri, const uri::string_type &path_, const uri::string_type &query_) { uri uri_(base_uri); builder(uri_).path(path_).query(query_); return uri_; } inline uri from_parts(const uri &base_uri, const uri::string_type &path_) { uri uri_(base_uri); builder(uri_).path(path_); return uri_; } inline uri from_parts(const uri::string_type &base_uri, const uri::string_type &path, const uri::string_type &query, const uri::string_type &fragment) { return from_parts(uri(base_uri), path, query, fragment); } inline uri from_parts(const uri::string_type &base_uri, const uri::string_type &path, const uri::string_type &query) { return from_parts(uri(base_uri), path, query); } inline uri from_parts(const uri::string_type &base_uri, const uri::string_type &path) { return from_parts(uri(base_uri), path); } } // namespace uri } // namespace network } // namespace boost #include namespace boost { namespace network { namespace uri { inline uri from_file(const filesystem::path &path_) { uri uri_; builder(uri_).scheme("file").path(path_.string()); return uri_; } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/uri.ipp000066400000000000000000000162651240331347200231300ustar00rootroot00000000000000// Copyright 2009, 2010, 2011, 2012 Dean Michael Berris, Jeroen Habraken, Glyn // Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include BOOST_FUSION_ADAPT_TPL_STRUCT( (FwdIter), (boost::network::uri::detail::hierarchical_part)(FwdIter), (boost::optional >, user_info)(boost::optional >, host)(boost::optional >, port)(boost::optional >, path)); BOOST_FUSION_ADAPT_TPL_STRUCT( (FwdIter), (boost::network::uri::detail::uri_parts)(FwdIter), (boost::iterator_range, scheme)(boost::network::uri::detail::hierarchical_part, hier_part)(boost::optional >, query)(boost::optional >, fragment)); namespace boost { namespace network { namespace uri { namespace detail { namespace qi = boost::spirit::qi; template struct uri_grammar : qi::grammar()> { typedef String string_type; typedef typename String::const_iterator const_iterator; uri_grammar() : uri_grammar::base_type(start, "uri") { // gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@" gen_delims %= qi::char_(":/?#[]@"); // sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," // / ";" / "=" sub_delims %= qi::char_("!$&'()*+,;="); // reserved = gen-delims / sub-delims reserved %= gen_delims | sub_delims; // unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" unreserved %= qi::alnum | qi::char_("-._~"); // pct-encoded = "%" HEXDIG HEXDIG pct_encoded %= qi::char_("%") >> qi::repeat(2)[qi::xdigit]; // pchar = unreserved / pct-encoded / sub-delims / ":" / "@" pchar %= qi::raw[unreserved | pct_encoded | sub_delims | qi::char_(":@")]; // segment = *pchar segment %= qi::raw[*pchar]; // segment-nz = 1*pchar segment_nz %= qi::raw[+pchar]; // segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" ) segment_nz_nc %= qi::raw[+(unreserved | pct_encoded | sub_delims | qi::char_("@"))]; // path-abempty = *( "/" segment ) path_abempty %= qi::raw[*(qi::char_("/") >> segment)]; // path-absolute = "/" [ segment-nz *( "/" segment ) ] path_absolute %= qi::raw [qi::char_("/") >> -(segment_nz >> *(qi::char_("/") >> segment))]; // path-rootless = segment-nz *( "/" segment ) path_rootless %= qi::raw[segment_nz >> *(qi::char_("/") >> segment)]; // path-empty = 0 path_empty %= qi::raw[qi::eps]; // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) scheme %= qi::raw[qi::alpha >> *(qi::alnum | qi::char_("+.-"))]; // user_info = *( unreserved / pct-encoded / sub-delims / ":" ) user_info %= qi::raw[*(unreserved | pct_encoded | sub_delims | qi::char_(":"))]; ip_literal %= qi::lit('[') >> (ipv6address | ipvfuture) >> ']'; ipvfuture %= qi::lit('v') >> +qi::xdigit >> '.' >> +(unreserved | sub_delims | ':'); ipv6address %= qi::raw[qi::repeat(6)[h16 >> ':'] >> ls32 | "::" >> qi::repeat(5)[h16 >> ':'] >> ls32 | qi::raw[h16] >> "::" >> qi::repeat(4)[h16 >> ':'] >> ls32 | qi::raw[+(*(h16 >> ':')) >> h16] >> "::" >> qi::repeat(3)[h16 >> ':'] >> ls32 | qi::raw[qi::repeat(2)[*(h16 >> ':')] >> h16] >> "::" >> qi::repeat(2)[h16 >> ':'] >> ls32 | qi::raw[qi::repeat(3)[*(h16 >> ':')] >> h16] >> "::" >> h16 >> ':' >> ls32 | qi::raw[qi::repeat(4)[*(h16 >> ':')] >> h16] >> "::" >> ls32 | qi::raw[qi::repeat(5)[*(h16 >> ':')] >> h16] >> "::" >> h16 | qi::raw[qi::repeat(6)[*(h16 >> ':')] >> h16] >> "::"]; // ls32 = ( h16 ":" h16 ) / IPv4address ls32 %= (h16 >> ':' >> h16) | ipv4address; // h16 = 1*4HEXDIG h16 %= qi::repeat(1, 4)[qi::xdigit]; // dec-octet = DIGIT / %x31-39 DIGIT / "1" 2DIGIT / "2" %x30-34 // DIGIT / "25" %x30-35 dec_octet %= !(qi::lit('0') >> qi::digit) >> qi::raw[qi::uint_parser()]; // IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet ipv4address %= qi::raw[dec_octet >> qi::repeat(3)[qi::lit('.') >> dec_octet]]; // reg-name = *( unreserved / pct-encoded / sub-delims ) reg_name %= qi::raw[*(unreserved | pct_encoded | sub_delims)]; // TODO, host = IP-literal / IPv4address / reg-name host %= qi::raw[ip_literal | ipv4address | reg_name]; // port %= qi::ushort_; port %= qi::raw[*qi::digit]; // query = *( pchar / "/" / "?" ) query %= qi::raw[*(pchar | qi::char_("/?"))]; // fragment = *( pchar / "/" / "?" ) fragment %= qi::raw[*(pchar | qi::char_("/?"))]; // hier-part = "//" authority path-abempty / path-absolute / // path-rootless / path-empty // authority = [ userinfo "@" ] host [ ":" port ] hier_part %= ((("//" >> user_info >> '@') | "//") >> host >> -(':' >> port) >> path_abempty) | (qi::attr(iterator_range()) >> qi::attr(iterator_range()) >> qi::attr(iterator_range()) >> (path_absolute | path_rootless | path_empty)); start %= (scheme >> ':') >> hier_part >> -('?' >> query) >> -('#' >> fragment); } qi::rule::value_type()> gen_delims, sub_delims, reserved, unreserved; qi::rule pct_encoded, pchar; qi::rule segment, segment_nz, segment_nz_nc; qi::rule()> path_abempty, path_absolute, path_rootless, path_empty; qi::rule dec_octet, ipv4address, reg_name, ipv6address, ipvfuture, ip_literal; qi::rule h16, ls32; qi::rule()> host, port; qi::rule()> scheme, user_info, query, fragment; qi::rule()> hier_part; // actual uri parser qi::rule()> start; }; bool parse(std::string::const_iterator first, std::string::const_iterator last, uri_parts &parts) { namespace qi = boost::spirit::qi; static detail::uri_grammar grammar; bool is_valid = qi::parse(first, last, grammar, parts); return is_valid && (first == last); } } // namespace detail } // namespace uri } // namespace network } // namespace boost cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/uri/uri_io.hpp000066400000000000000000000011431240331347200236030ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef __BOOST_NETWORK_URI_URI_IO_INC__ #define __BOOST_NETWORK_URI_URI_IO_INC__ #include namespace boost { namespace network { namespace uri { inline std::ostream &operator<<(std::ostream &os, const uri &uri_) { return os << uri_.string(); } } // namespace uri } // namespace network } // namespace boost #endif // __BOOST_NETWORK_URI_URI_IO_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/utils/000077500000000000000000000000001240331347200221465ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/utils/base64/000077500000000000000000000000001240331347200232325ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/utils/base64/encode-io.hpp000066400000000000000000000222631240331347200256120ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_BASE64_ENCODE_IO_HPP #define BOOST_NETWORK_UTILS_BASE64_ENCODE_IO_HPP #include #include #include #include #include namespace boost { namespace network { namespace utils { // Offers an interface to the BASE64 converter from encode.hpp, which is // based on stream manipulators to be friendly to the usage with output // streams combining heterogenous output by using the output operators. // The encoding state is serialized to long and maintained in te // extensible // internal array of the output stream. // // Summarized interface - ostream manipulators and one function: // // encode(InputIterator begin, InputIterator end) // encode(InputRange const & value) // encode(char const * value) // encode_rest // clear_state // bool empty_state(std::basic_ostream & output) namespace base64 { namespace io { // force using the ostream_iterator from boost::archive to write wide // characters reliably, althoth wchar_t may not be a native character // type using namespace boost::archive::iterators; namespace detail { // Enables transferring of the input sequence for the BASE64 // encoding into // the ostream operator defined for it, which performs the // operation. It // is to be used from ostream manipulators. // // std::basic_ostream & output = ...; // output << input_wrapper(value.begin(), // value.end()); template struct input_wrapper { input_wrapper(InputIterator begin, InputIterator end) : begin(begin), end(end) {} private: InputIterator begin, end; // only encoding of an input sequence needs access to it template friend std::basic_ostream &operator<<( std::basic_ostream &output, input_wrapper input_wrapper); }; // The output stream state should be used only in a single scope // around // encoding operations. Constructor performs initialization from // the // output stream internal extensible array and destructor updates it // according to the encoding result. It inherits from the // base64::state // to gain access to its protected members and allow easy value // passing // to base64::encode. // // // std::basic_ostream & output = ...; // { // state rest(output); // base64::encode(..., ostream_iterator(output), rest); // } template struct state : public boost::network::utils::base64::state { typedef boost::network::utils::base64::state super_t; // initialize the (inherited) contents of the base64::state<> from // the // output stream internal extensible array state(std::basic_ostream &output) : super_t(), output(output) { const unsigned triplet_index_size = sizeof(super_t::triplet_index) * 8; unsigned long data = static_cast(storage()); // mask the long value with the bit-size of the triplet_index // member super_t::triplet_index = data & ((1 << triplet_index_size) - 1); // shift the long value right to remove the the triplet_index // value; // masking is not necessary because the last_encoded_value it is // the // last record stored in the data value super_t::last_encoded_value = data >> triplet_index_size; } // update the value in the output stream internal extensible array // by // the last (inherited) contents of the base64::state<> ~state() { const unsigned triplet_index_size = sizeof(super_t::triplet_index) * 8; // store the last_encoded_value in the data value first unsigned long data = static_cast(super_t::last_encoded_value); // shift the long data value left to make place for storing the // full triplet_index value there data <<= triplet_index_size; data |= static_cast(super_t::triplet_index); storage() = static_cast(data); } private: // all data of the base64::state<> must be serializable into a // long // value allocated in the output stream internal extensible array BOOST_STATIC_ASSERT(sizeof(super_t) <= sizeof(long)); // allow only the construction with an output stream (strict RAII) state(); state(state const &); std::basic_ostream &output; long &storage() { static int index = std::ios_base::xalloc(); return output.iword(index); } }; // Output operator implementing the BASE64 encoding for an input // sequence // which was wrapped by the ostream manipulator; the state must be // preserved // because multiple sequences can be sent in the ouptut by this // operator. template std::basic_ostream &operator<<(std::basic_ostream &output, input_wrapper input) { typedef typename iterator_value::type value_type; state rest(output); base64::encode(input.begin, input.end, ostream_iterator(output), rest); return output; } } // namespace detail // Encoding ostream manipulator for sequences specified by the pair of // begin // and end iterators. // // std::vector buffer = ...; // std::basic_ostream & output = ...; // output << base64::io::encode(buffer.begin(), buffer.end()) << ... // << // base64::io::encode_rest; template detail::input_wrapper encode(InputIterator begin, InputIterator end) { return detail::input_wrapper(begin, end); } // Encoding ostream manipulator processing whole sequences which // either // support begin() and end() methods returning boundaries of the // sequence // or the boundaries can be computed by the Boost::Range. // // Warning: Buffers identified by C-pointers are processed including // their // termination character, if they have any. This is unexpected at // least // for the storing literals, which have a specialization here to avoid // it. // // std::vector buffer = ...; // std::basic_ostream & output = ...; // output << base64::io::encode(buffer) << ... << // base64::io::encode_rest; template detail::input_wrapper::type> encode(InputRange const &value) { typedef typename boost::range_const_iterator::type InputIterator; return detail::input_wrapper(boost::begin(value), boost::end(value)); } // Encoding ostream manipulator processing string literals; the usual // expectation from their encoding is processing only the string // content // without the terminating zero character. // // std::basic_ostream & output = ...; // output << base64::io::encode("ab") << ... << // base64::io::encode_rest; inline detail::input_wrapper encode(char const *value) { return detail::input_wrapper(value, value + strlen(value)); } // Encoding ostream manipulator which finishes encoding of the // previously // processed chunks. If their total byte-length was divisible by // three, // nothing is needed, if not, the last quantum will be encoded as if // padded // with zeroes, which will be indicated by appending '=' characters to // the // output. This manipulator must be always used at the end of // encoding, // after previous usages of the encode manipulator. // // std::basic_ostream & output = ...; // output << base64::io::encode("ab") << ... << // base64::io::encode_rest; template std::basic_ostream &encode_rest(std::basic_ostream &output) { detail::state rest(output); base64::encode_rest(ostream_iterator(output), rest); return output; } // Clears the encoding state in the internal array of the output // stream. // Use it to re-use a state object in an unknown state only; Encoding // of // the last chunk must be followed by encode_rest otherwise the end of // the // input sequence may be missing in the encoded output. The // encode_rest // ensures that the rest of the input sequence will be encoded // corectly and // the '=' padding applied as necessary. The encode rest clears the // state // when finished. // // std::basic_ostream & output = ...; // output << base64::io::encode("ab") << ...; // output << clear_state; template std::basic_ostream &clear_state(std::basic_ostream &output) { detail::state rest(output); rest.clear(); return output; } // Checks if the encoding state in the internal array of the output // stream // is empty. // // std::basic_ostream & output = ...; // output << base64::io::encode("ab") << ...; // bool is_complete = base64::io::empty_state(output); template bool empty_state(std::basic_ostream &output) { detail::state rest(output); return rest.empty(); } } // namespace io } // namespace base64 } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_BASE64_ENCODE_IO_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/utils/base64/encode.hpp000066400000000000000000000420351240331347200252040ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_BASE64_ENCODE_HPP #define BOOST_NETWORK_UTILS_BASE64_ENCODE_HPP #include #include #include #include #include namespace boost { namespace network { namespace utils { // Implements a BASE64 converter working on an iterator range. // If the input sequence does not end at the three-byte boundary, the last // encoded value part is remembered in an encoding state to be able to // continue with the next chunk; the BASE64 encoding processes the input // by byte-triplets. // // Summarized interface: // // struct state { // bool empty () const; // void clear(); // } // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output, State & rest) // OutputIterator encode_rest(OutputIterator output, State & rest) // OutputIterator encode(InputRange const & input, OutputIterator output, // State & rest) // OutputIterator encode(char const * value, OutputIterator output, // state & rest) // std::basic_string encode(InputRange const & value, State & rest) // std::basic_string encode(char const * value, state & rest) // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output) // OutputIterator encode(InputRange const & input, OutputIterator output) // OutputIterator encode(char const * value, OutputIterator output) // std::basic_string encode(InputRange const & value) // std::basic_string encode(char const * value) { // // See also http://libb64.sourceforge.net, which served as inspiration. // See also http://tools.ietf.org/html/rfc4648 for the specification. namespace base64 { namespace detail { // Picks a character from the output alphabet for another 6-bit value // from the input sequence to encode. template char encode_value(Value value) { static char const encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" "+/"; return encoding[static_cast(value)]; } } // namespace detail // Stores the state after processing the last chunk by the encoder. If // the // chunk byte-length is not divisible by three, the last (incomplete) // value // quantum canot be encoded right away; it has to wait for the next // chunk // of octets which will be processed joined (as if the trailing rest // from // the previous one was at its beinning). template struct state { state() : triplet_index(0), last_encoded_value(0) {} state(state const& source) : triplet_index(source.triplet_index), last_encoded_value(source.last_encoded_value) {} bool empty() const { return triplet_index == 0; } void clear() { // indicate that no rest has been left in the last encoded value // and no padding is needed for the encoded output triplet_index = 0; // the last encoded value, which may have been left from the last // encoding step, must be zeroed too; it is important before the // next encoding begins, because it works as a cyclic buffer and // must start empty - with zero last_encoded_value = 0; } protected: // number of the octet in the incomplete quantum, which has been // processed the last time; 0 means that the previous quantum was // complete 3 octets, 1 that just one octet was avalable and 2 that // two octets were available unsigned char triplet_index; // the value made of the previously shifted and or-ed octets which // was not completely split to 6-bit codes, because the last quantum // did not stop on the boundary of three octets Value last_encoded_value; // encoding of an input chunk needs to read and update the state template friend OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest); // finishing the encoding needs to read and clear the state template friend OutputIterator encode_rest(OutputIterator output, State& rest); }; // Encodes an input sequence to BASE64 writing it to the output iterator // and stopping if the last input tree-octet quantum was not complete, // in // which case it stores the state for the later continuation, when // another // input chunk is ready for the encoding. The encoding must be finished // by calling the encode_rest after processing the last chunk. // // std::vector buffer = ...; // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode(buffer.begin(), buffer.end(), appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest) { typedef typename iterator_value::type value_type; // continue with the rest of the last chunk - 2 or 4 bits which // are already shifted to the left and need to be or-ed with the // continuing data up to the target 6 bits value_type encoded_value = rest.last_encoded_value; // if the previous chunk stopped at encoding the first (1) or the // second // (2) octet of the three-byte quantum, jump to the right place, // otherwise start the loop with an empty encoded value buffer switch (rest.triplet_index) { // this loop processes the input sequence of bit-octets by bits, // shifting the current_value (used as a cyclic buffer) left and // or-ing next bits there, while pulling the bit-sextets from the // high word of the current_value for (value_type current_value;;) { case 0: // if the input sequence is empty or reached its end at the // 3-byte boundary, finish with an empty encoding state if (begin == end) { rest.triplet_index = 0; // the last encoded value is not interesting - it would not // be used, because processing of the next chunk will start // at the 3-byte boundary rest.last_encoded_value = 0; return output; } // read the first octet from the current triplet current_value = *begin++; // use just the upper 6 bits to encode it to the target alphabet encoded_value = (current_value & 0xfc) >> 2; *output++ = detail::encode_value(encoded_value); // shift the remaining two bits up to make place for the upoming // part of the next octet encoded_value = (current_value & 0x03) << 4; case 1: // if the input sequence reached its end after the first octet // from the quantum triplet, store the encoding state and finish if (begin == end) { rest.triplet_index = 1; rest.last_encoded_value = encoded_value; return output; } // read the second first octet from the current triplet current_value = *begin++; // combine the upper four bits (as the lower part) with the // previous two bits to encode it to the target alphabet encoded_value |= (current_value & 0xf0) >> 4; *output++ = detail::encode_value(encoded_value); // shift the remaining four bits up to make place for the // upoming // part of the next octet encoded_value = (current_value & 0x0f) << 2; case 2: // if the input sequence reached its end after the second octet // from the quantum triplet, store the encoding state and finish if (begin == end) { rest.triplet_index = 2; rest.last_encoded_value = encoded_value; return output; } // read the third octet from the current triplet current_value = *begin++; // combine the upper two bits (as the lower part) with the // previous four bits to encode it to the target alphabet encoded_value |= (current_value & 0xc0) >> 6; *output++ = detail::encode_value(encoded_value); // encode the remaining 6 bits to the target alphabet encoded_value = current_value & 0x3f; *output++ = detail::encode_value(encoded_value); } } return output; } // Finishes encoding of the previously processed chunks. If their total // byte-length was divisible by three, nothing is needed, if not, the // last // quantum will be encoded as if padded with zeroes, which will be // indicated // by appending '=' characters to the output. This method must be // always // used at the end of encoding, if the previous chunks were encoded by // the // method overload accepting the encoding state. // // std::vector buffer = ...; // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode(buffer.begin(), buffer.end(), appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode_rest(OutputIterator output, State& rest) { if (!rest.empty()) { // process the last part of the trailing octet (either 4 or 2 bits) // as if the input was padded with zeros - without or-ing the next // input value to it; it has been already shifted to the left *output++ = detail::encode_value(rest.last_encoded_value); // at least one padding '=' will be always needed - at least two // bits are missing in the finally encoded 6-bit value *output++ = '='; // if the last octet was the first in the triplet (the index was // 1), four bits are missing in the finally encoded 6-bit value; // another '=' character is needed for the another two bits if (rest.triplet_index < 2) *output++ = '='; // clear the state all the time to make sure that another call to // the encode_rest would not cause damage; the last encoded value, // which may have been left there, must be zeroed too; it is // important before the next encoding begins, because it works as // a cyclic buffer and must start empty - with zero rest.clear(); } return output; } // Encodes a part of an input sequence specified by the pair of begin // and // end iterators.to BASE64 writing it to the output iterator. If its // total // byte-length was not divisible by three, the output will be padded by // the // '=' characters. If you encode an input consisting of mutiple chunks, // use the method overload maintaining the encoding state. // // std::vector buffer = ...; // std::basic_string result; // base64::encode(buffer.begin(), buffer.end(), // std::back_inserter(result)); template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output) { state::type> rest; output = encode(begin, end, output, rest); return encode_rest(output, rest); } // Encodes an entire input sequence to BASE64, which either supports // begin() // and end() methods returning boundaries of the sequence or the // boundaries // can be computed by the Boost::Range, writing it to the output // iterator // and stopping if the last input tree-octet quantum was not complete, // in // which case it stores the state for the later continuation, when // another // input chunk is ready for the encoding. The encoding must be finished // by calling the encode_rest after processing the last chunk. // // Warning: Buffers identified by C-pointers are processed including // their // termination character, if they have any. This is unexpected at least // for the storing literals, which have a specialization here to avoid // it. // // std::vector buffer = ...; // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode(buffer, appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode(InputRange const& input, OutputIterator output, State& rest) { return encode(boost::begin(input), boost::end(input), output, rest); } // Encodes an entire string literal to BASE64, writing it to the output // iterator and stopping if the last input tree-octet quantum was not // complete, in which case it stores the state for the later // continuation, // when another input chunk is ready for the encoding. The encoding // must // be finished by calling the encode_rest after processing the last // chunk. // // The string literal is encoded without processing its terminating zero // character, which is the usual expectation. // // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode("ab", appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode(char const* value, OutputIterator output, state& rest) { return encode(value, value + strlen(value), output, rest); } // Encodes an entire input sequence to BASE64 writing it to the output // iterator, which either supports begin() and end() methods returning // boundaries of the sequence or the boundaries can be computed by the // Boost::Range. If its total byte-length was not divisible by three, // the output will be padded by the '=' characters. If you encode an // input consisting of mutiple chunks, use the method overload // maintaining // the encoding state. // // Warning: Buffers identified by C-pointers are processed including // their // termination character, if they have any. This is unexpected at least // for the storing literals, which have a specialization here to avoid // it. // // std::vector buffer = ...; // std::basic_string result; // base64::encode(buffer, std::back_inserter(result)); template OutputIterator encode(InputRange const& value, OutputIterator output) { return encode(boost::begin(value), boost::end(value), output); } // Encodes an entire string literal to BASE64 writing it to the output // iterator. If its total length (without the trailing zero) was not // divisible by three, the output will be padded by the '=' characters. // If you encode an input consisting of mutiple chunks, use the method // overload maintaining the encoding state. // // The string literal is encoded without processing its terminating zero // character, which is the usual expectation. // // std::basic_string result; // base64::encode("ab", std::back_inserter(result)); template OutputIterator encode(char const* value, OutputIterator output) { return encode(value, value + strlen(value), output); } // Encodes an entire input sequence to BASE64 returning the result as // string, which either supports begin() and end() methods returning // boundaries of the sequence or the boundaries can be computed by the // Boost::Range. If its total byte-length was not divisible by three, // the output will be padded by the '=' characters. If you encode an // input consisting of mutiple chunks, use other method maintaining // the encoding state writing to an output iterator. // // Warning: Buffers identified by C-pointers are processed including // their // termination character, if they have any. This is unexpected at least // for the storing literals, which have a specialization here to avoid // it. // // std::vector buffer = ...; // std::basic_string result = base64::encode(buffer); template std::basic_string encode(InputRange const& value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } // Encodes an entire string literal to BASE64 returning the result as // string. If its total byte-length was not divisible by three, the // output will be padded by the '=' characters. If you encode an // input consisting of mutiple chunks, use other method maintaining // the encoding state writing to an output iterator. // // The string literal is encoded without processing its terminating zero // character, which is the usual expectation. // // std::basic_string result = base64::encode("ab"); template std::basic_string encode(char const* value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } // The function overloads for string literals encode the input without // the terminating zero, which is usually expected, because the trailing // zero byte is not considered a part of the string value; the overloads // for an input range would wrap the string literal by Boost.Range and // encode the full memory occupated by the string literal - including // the // unwanted last zero byte. } // namespace base64 } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_BASE64_ENCODE_HPP cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/utils/thread_pool.hpp000066400000000000000000000060731240331347200251650ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_THREAD_POOL_HPP_20101020 #define BOOST_NETWORK_UTILS_THREAD_POOL_HPP_20101020 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include namespace boost { namespace network { namespace utils { typedef boost::shared_ptr io_service_ptr; typedef boost::shared_ptr worker_threads_ptr; typedef boost::shared_ptr sentinel_ptr; template struct basic_thread_pool { basic_thread_pool(std::size_t threads = 1, io_service_ptr io_service = io_service_ptr(), worker_threads_ptr worker_threads = worker_threads_ptr()) : threads_(threads), io_service_(io_service), worker_threads_(worker_threads), sentinel_() { bool commit = false; BOOST_SCOPE_EXIT_TPL( (&commit)(&io_service_)(&worker_threads_)(&sentinel_)) { if (!commit) { sentinel_.reset(); io_service_.reset(); if (worker_threads_.get()) { worker_threads_->interrupt_all(); worker_threads_->join_all(); } worker_threads_.reset(); } } BOOST_SCOPE_EXIT_END if (!io_service_.get()) { io_service_.reset(new boost::asio::io_service); } if (!worker_threads_.get()) { worker_threads_.reset(new boost::thread_group); } if (!sentinel_.get()) { sentinel_.reset(new boost::asio::io_service::work(*io_service_)); } for (std::size_t counter = 0; counter < threads_; ++counter) worker_threads_->create_thread( boost::bind(&boost::asio::io_service::run, io_service_)); commit = true; } std::size_t thread_count() const { return threads_; } void post(boost::function f) { io_service_->post(f); } ~basic_thread_pool() throw() { sentinel_.reset(); try { worker_threads_->join_all(); } catch (...) { BOOST_ASSERT(false && "A handler was not supposed to throw, but one did."); } } void swap(basic_thread_pool &other) { std::swap(other.threads_, threads_); std::swap(other.io_service_, io_service_); std::swap(other.worker_threads_, worker_threads_); std::swap(other.sentinel_, sentinel_); } protected: std::size_t threads_; io_service_ptr io_service_; worker_threads_ptr worker_threads_; sentinel_ptr sentinel_; private: basic_thread_pool(basic_thread_pool const &); // no copies please basic_thread_pool &operator=(basic_thread_pool); // no assignment // please }; typedef basic_thread_pool thread_pool; } /* utils */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_UTILS_THREAD_POOL_HPP_20101020 */ cpp-netlib-cpp-netlib-0.11.1RC1/boost/network/version.hpp000066400000000000000000000014641240331347200232110ustar00rootroot00000000000000#ifndef BOOST_NETWORK_VERSION_HPP_20091214 #define BOOST_NETWORK_VERSION_HPP_20091214 // Copyright 2009, 2013 Dean Michael Berris // Copyright Glyn Matthews 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #define BOOST_NETLIB_VERSION_MAJOR 0 #define BOOST_NETLIB_VERSION_MINOR 11 #define BOOST_NETLIB_VERSION_INCREMENT 1 #ifndef BOOST_NETLIB_VERSION #define BOOST_NETLIB_VERSION \ BOOST_STRINGIZE(BOOST_NETLIB_VERSION_MAJOR) "." BOOST_STRINGIZE( \ BOOST_NETLIB_VERSION_MINOR) "." BOOST_STRINGIZE(BOOST_NETLIB_VERSION_INCREMENT) #endif // BOOST_NETLIB_VERSION #endif // BOOST_NETWORK_VERSION_HPP_20091214 cpp-netlib-cpp-netlib-0.11.1RC1/cppnetlibConfig.cmake.in000066400000000000000000000016131240331347200227050ustar00rootroot00000000000000# - Config file for the cppnetlib package # It defines the following variables # CPPNETLIB_INCLUDE_DIRS - include directories for cppnetlib # CPPNETLIB_LIBRARIES - libraries to link against # CPPNETLIB_EXECUTABLE - the bar executable # Compute paths get_filename_component(CPPNETLIB_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) set(CPPNETLIB_INCLUDE_DIRS "@CONF_INCLUDE_DIRS@") # Our library dependencies (contains definitions for IMPORTED targets) if( NOT TARGET cppnetlib-client-connections AND NOT TARGET cppnetlib-server-parsers AND NOT TARGET cppnetlib-uri AND NOT CPPNETLIB_BINARY_DIR) include("${CPPNETLIB_CMAKE_DIR}/cppnetlibTargets.cmake") endif() # These are IMPORTED targets created by cppnetlibTargets.cmake set(CPPNETLIB_LIBRARIES cppnetlib-client-connections cppnetlib-server-parsers cppnetlib-uri) #set(CPPNETLIB_EXECUTABLE ...) # maybe the examples? cpp-netlib-cpp-netlib-0.11.1RC1/cppnetlibConfigVersion.cmake.in000066400000000000000000000006041240331347200242520ustar00rootroot00000000000000set(PACKAGE_VERSION "@CPPNETLIB_VERSION_STRING@") # Check whether the requested PACKAGE_FIND_VERSION is compatible if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}") set(PACKAGE_VERSION_COMPATIBLE FALSE) else() set(PACKAGE_VERSION_COMPATIBLE TRUE) if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}") set(PACKAGE_VERSION_EXACT TRUE) endif() endif()cpp-netlib-cpp-netlib-0.11.1RC1/index.html000066400000000000000000000014701240331347200201660ustar00rootroot00000000000000 Automatic redirection failed, please go to index.html.

Copyright 2010 Glyn Matthews

Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

cpp-netlib-cpp-netlib-0.11.1RC1/libs/000077500000000000000000000000001240331347200171205ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/000077500000000000000000000000001240331347200200475ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/To-Do.txt000066400000000000000000000007301240331347200215320ustar00rootroot00000000000000To Do list for Boost.Mime: General: * Finish the test suites ** Compare results to python parser ** Try to parse some bad mime inputs --> Added 0019-NoBoundary test * Integrate into cpp-netlib * Write some docs Specific: * Rename make_mime into something better. Parse, Encode? --> Changed the name to 'parse_mime', and made the stream and iterator versions use the same name * Start using boost::exception * Look into making the parsing restartable * Figure out how to cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/doc/000077500000000000000000000000001240331347200206145ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/doc/mime.qbk000066400000000000000000000043441240331347200222470ustar00rootroot00000000000000[/ (C) Copyright 2010 Marshall Clow Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt). ] [article C++ Mime Library [quickbook 1.4] [version 0.5] [authors [Clow, Marshall]] [copyright 2010 Marshall Clow] [purpose C++ library for MIME parsing, manipulation and printing] [category text] [license Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at [@http://www.boost.org/LICENSE_1_0.txt]) ] ] [def __boost__ [@http://www.boost.org/ the Boost C++ Libraries]] [def __boost_org__ [@http://www.boost.org/]] [def __boost_asio__ [@http://www.boost.org/libs/asio/index.html Boost.Asio]] [def __boost_system__ [@http://www.boost.org/libs/system/index.html Boost.System]] [def __boost_type_traits__ [@http://www.boost.org/libs/type_traits/index.html Boost.TypeTraits]] [def __boost_doc__ [@http://www.boost.org/doc/libs/]] [def __pion__ [@http://www.pion.org/projects/pion-network-library the Pion Network Library]] [def __cnl__ C++ Network Library] [def __message__ `basic_message`] [def __uri__ `basic_uri`] [def __python__ [@http://www.python.org Python]] [def __libcurl__ [@http://curl.haxx.se/ libcurl]] [def __mozilla_netlib__ [@http://www.mozilla.org/projects/netlib/ mozilla-netlib]] [def __sf_cpp_netlib__ [@http://sourceforge.net/projects/cpp-netlib/ sourceforge]] [def __github__ [@http://github.com/mikhailberis/cpp-netlib github]] [def __default_constructible__ [@http://www.boost.org/doc/html/DefaultConstructible.html DefaultConstructible]] [def __copy_constructible__ [@http://www.boost.org/doc/html/CopyConstructible.html CopyConstructible]] [def __assignable__ [@http://www.boost.org/doc/html/Assignable.html Assignable]] [def __equality_comparable__ [@http://www.boost.org/doc/html/Assignable.html Assignable]] [def __quick_start__ quick start] [include quick_start.qbk] #[include intro.qbk] #[include using.qbk] #[/include architecture.qbk] #[include message.qbk] #[include uri.qbk] #[include protocol.qbk] #[include examples.qbk] #[include reference.qbk] #[include acknowledgements.qbk] #[include appendices.qbk] #[include contributors.qbk] cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/doc/quick_start.qbk000066400000000000000000000004011240331347200236370ustar00rootroot00000000000000[/ (C) Copyright 2010 Marshall Clow Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt). ] [section:quick_start Quick Start] [endsect] [/ quick_start] cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/example/000077500000000000000000000000001240331347200215025ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/example/basic_parsing.cpp000066400000000000000000000100601240331347200250070ustar00rootroot00000000000000// // Copyright Marshall Clow 2009-2010 // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // #include #include #include #include #include struct my_traits { typedef std::string string_type; // typedef std::pair < std::string, string_type > header_type; typedef std::string body_type; }; // typedef boost::mime::mime_part<> mime_part; typedef boost::mime::basic_mime mime_part; template void DumpContainer(std::ostream &out, const std::string &prefix, const Container &c) { out << prefix << ' '; if (c.size() < 10) { for (typename Container::const_iterator iter = c.begin(); iter != c.end(); ++iter) out << (int)*iter << ' '; } else { for (int i = 0; i < 5; i++) out << int(c.begin()[i]) << ' '; out << "... "; for (int i = 0; i < 5; i++) out << int(c.rbegin()[i]) << ' '; } out << std::endl; } void DumpStructure(std::ostream &out, const char *title, const mime_part &mp, std::string prefix) { std::string content_type = mp.get_content_type(); if (NULL != title) out << prefix << "Data from: " << title << std::endl; out << prefix << "Content-Type: " << content_type << std::endl; out << prefix << "There are " << std::distance(mp.header_begin(), mp.header_end()) << " headers" << std::endl; size_t subpart_count = std::distance(mp.subpart_begin(), mp.subpart_end()); switch (mp.get_part_kind()) { case mime_part::simple_part: if (subpart_count != 0) out << str(boost::format("%s ### %d subparts on a simple (%s) type!") % prefix % subpart_count % content_type) << std::endl; out << prefix << "The body is " << mp.body_size() << " bytes long" << std::endl; DumpContainer(out, prefix, *mp.body()); break; case mime_part::multi_part: break; case mime_part::message_part: if (boost::iequals(content_type, "message/delivery-status")) out << prefix << "The body is " << mp.body_size() << " bytes long" << std::endl; else if (1 != subpart_count) out << str(boost::format("%s ### %d subparts on a message (%s) type!") % subpart_count % prefix % content_type) << std::endl; break; } if (subpart_count != 0) { out << prefix << "There are " << std::distance(mp.subpart_begin(), mp.subpart_end()) << " sub parts" << std::endl; for (mime_part::constPartIter iter = mp.subpart_begin(); iter != mp.subpart_end(); ++iter) DumpStructure(out, NULL, **iter, prefix + " "); } } int main(int argc, char *argv[]) { if (argc == 1) std::cerr << "Usage: basic_parsing " << std::endl; for (int i = 1; i < argc; ++i) { boost::shared_ptr rmp; try { std::ifstream in(argv[i]); if (!in) { std::cerr << "Can't open file " << argv[i] << std::endl; continue; } in >> std::noskipws; std::cout << "**********************************" << std::endl; rmp = mime_part::parse_mime(in); } catch (const boost::mime::mime_parsing_error &err) { std::cout << "Caught an error parsing '" << argv[i] << "'" << std::endl; std::cout << " " << err.what() << std::endl; continue; } catch (const boost::exception &berr) { std::cout << "Caught an boost error parsing '" << argv[i] << "'" << std::endl; // std::cout << " " << berr.what () << std::endl; continue; } try { DumpStructure(std::cout, argv[i], *rmp, std::string()); // std::ofstream out ( (std::string ( argv[i] ) + "-Results").c_str (), // std::ios::binary ); // out << rmp; } catch (const std::runtime_error &err) { std::cout << "Caught an error writing '" << argv[i] << "'" << std::endl; std::cout << " " << err.what() << std::endl; continue; } } return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/example/basic_usage.cpp000066400000000000000000000041101240331347200244470ustar00rootroot00000000000000// // Copyright Marshall Clow 2009-2010 // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // #include #include #include #include #include struct my_traits { typedef std::string string_type; // typedef std::pair < std::string, string_type > header_type; typedef std::string body_type; }; typedef boost::mime::basic_mime mime_part; int main(int argc, char* argv[]) { // (1) a really simple part mime_part mp("text", "plain"); mp.set_body("Hello World\n", 12); std::cout << mp; // Three trips around the house before we go through the door. // Make a part, copy it onto the heap, and wrap it into a shared pointer. std::cout << "*******" << std::endl; std::string str("Hi Mom!\n"); boost::shared_ptr mp0(new mime_part( mime_part::make_simple_part("text", "html", str.begin(), str.end()))); std::cout << mp0; std::cout << "*******" << std::endl; boost::shared_ptr mp1(new mime_part("text", "plain")); mp1->set_body("This is a test.....\n", 20); mp1->append_phrase_to_content_type("charset", "usascii"); std::cout << mp1; // Build a multipart mime_part mp2("multipart", "multiple"); mp2.set_body("This is the body of a multipart\n", 32); mp2.append_part(mp0); mp2.append_part(mp1); // stream it out to a string, then make a new part from the string std::ostringstream os1, os2; os1 << mp2; std::istringstream is(os1.str()); is >> std::noskipws; boost::shared_ptr strmp = mime_part::parse_mime(is); os2 << strmp; if (os1.str() == os2.str()) std::cout << "Strings match!!" << std::endl; else { // Write the differences out to files for examination std::cout << "##Strings differ!!" << std::endl; std::ofstream t1("test1.out", std::ios::binary); t1 << os1.str(); std::ofstream t2("test2.out", std::ios::binary); t2 << os2.str(); } return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/000077500000000000000000000000001240331347200210265ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/CMakeLists.txt000066400000000000000000000012661240331347200235730ustar00rootroot00000000000000include_directories(${CPP-NETLIB_SOURCE_DIR}) file ( COPY TestMessages DESTINATION ${CMAKE_CURRENT_BINARY_DIR} ) #This test causes a "too many sections" error on Windows MinGW64 #(MSVC has /bigobj, MinGW does not) if (NOT(${CMAKE_CXX_COMPILER_ID} MATCHES GNU AND ${CMAKE_SYSTEM_NAME} MATCHES "Windows")) if ( Boost_FOUND ) add_executable ( mime-roundtrip mime-roundtrip.cpp ) target_link_libraries ( mime-roundtrip ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) set_target_properties( mime-roundtrip PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/tests) add_test ( mime-roundtrip ${CPP-NETLIB_BINARY_DIR}/tests/mime-roundtrip ) endif () endif() cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/TestMessages/000077500000000000000000000000001240331347200234355ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/TestMessages/.gitattributes000066400000000000000000000000111240331347200263200ustar00rootroot00000000000000* -crlf cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/TestMessages/00000001000066400000000000000000000046431240331347200242470ustar00rootroot00000000000000Resent-To: mail.app@flagg2.qualcomm.com Resent-From: win-eudora-bugs@flagg2.qualcomm.com Resent-Message-Id: Resent-Date: Mon, 1 Nov 2004 15:38:13 -0800 Received: from flagg2.qualcomm.com [129.46.154.229] by localhost with IMAP (fetchmail-6.2.5) for marshall@localhost (single-drop); Tue, 02 Nov 2004 11:38:25 -0800 (PST) Received: from snape.qualcomm.com (unverified [129.46.132.184]) (using TLSv1 with Cipher RC4(128), Exch RSA_SIGN(1024), Hash MD5(128)) by flagg2.qualcomm.com (Rockliffe SMTPRA 6.1.16) with ESMTP id for ; Mon, 1 Nov 2004 15:38:13 -0800 Received: from sabrina.qualcomm.com (sabrina.qualcomm.com [129.46.61.150]) by snape.qualcomm.com (8.12.10/8.12.3/1.0) with ESMTP id iA1NcAcH015308 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=FAIL); Mon, 1 Nov 2004 15:38:11 -0800 (PST) Received: from moria.qualcomm.com (qualcomm.com [199.106.114.68]) by sabrina.qualcomm.com (8.12.10/8.12.5/1.0) with ESMTP id iA1Nc8HJ019370 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NOT) for ; Mon, 1 Nov 2004 15:38:09 -0800 (PST) Received: from isengard.qualcomm.com (isengard.qualcomm.com [199.106.114.75]) by moria.qualcomm.com (qualnet-external) with ESMTP id iA1Nc7Rg028808 for ; Mon, 1 Nov 2004 15:38:07 -0800 (PST) Received: from coyote.rain.org (coyote.rain.org [198.68.144.2]) by isengard.qualcomm.com with ESMTP id iA1Nc7uA020987 for ; Mon, 1 Nov 2004 15:38:07 -0800 (PST) Received: from sanders.rain.org (maxmp-189.rain.org [198.68.144.189]) by coyote.rain.org (Postfix) with ESMTP id 648227775 for ; Mon, 1 Nov 2004 15:38:06 -0800 (PST) Message-Id: <5.0.2.1.2.20041101153017.00a26ec0@rain.org> X-Sender: maia3@rain.org X-Mailer: QUALCOMM Windows Eudora Version 5.0.2 Date: Mon, 01 Nov 2004 15:31:46 -0800 To: win-eudora6-bugs@qualcomm.com From: Maia Subject: New Bugs Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii"; format=flowed X-PMX-Version: 4.6.0.97784, Antispam-Core: 4.6.0.97340, Antispam-Data: 2004.11.1.3 Just now, without any reason, an email of mine was turned into a mixture of text and directions and numbers and letters and is now unusable. Do you know why this is happening? Thanks, Maia cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/TestMessages/00000019000066400000000000000000000073531240331347200242610ustar00rootroot00000000000000Resent-To: mail.app@flagg2.qualcomm.com Resent-From: win-eudora-bugs@flagg2.qualcomm.com Resent-Message-Id: Resent-Date: Mon, 1 Nov 2004 16:01:16 -0800 Received: from flagg2.qualcomm.com [129.46.154.229] by localhost with IMAP (fetchmail-6.2.5) for marshall@localhost (single-drop); Tue, 02 Nov 2004 11:38:27 -0800 (PST) Received: from snape.qualcomm.com (unverified [129.46.132.184]) (using TLSv1 with Cipher RC4(128), Exch RSA_SIGN(1024), Hash MD5(128)) by flagg2.qualcomm.com (Rockliffe SMTPRA 6.1.16) with ESMTP id for ; Mon, 1 Nov 2004 16:01:16 -0800 Received: from neophyte.qualcomm.com (neophyte.qualcomm.com [129.46.61.149]) by snape.qualcomm.com (8.12.10/8.12.3/1.0) with ESMTP id iA201FcH022189 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=FAIL); Mon, 1 Nov 2004 16:01:15 -0800 (PST) Received: from hobbiton.qualcomm.com (hobbiton.qualcomm.com [199.106.114.69]) by neophyte.qualcomm.com (8.12.10/8.12.5/1.0) with ESMTP id iA201D9A029029 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NOT) for ; Mon, 1 Nov 2004 16:01:13 -0800 (PST) Received: from isengard.qualcomm.com (isengard.qualcomm.com [199.106.114.75]) by hobbiton.qualcomm.com (qualnet-external) with ESMTP id iA201BhJ016885 for ; Mon, 1 Nov 2004 16:01:12 -0800 (PST) Received: from localhost (localhost) by isengard.qualcomm.com id iA201CuA023535; Mon, 1 Nov 2004 16:01:12 -0800 (PST) Date: Mon, 1 Nov 2004 16:01:12 -0800 (PST) From: Mail Delivery Subsystem Message-Id: <200411020001.iA201CuA023535@isengard.qualcomm.com> To: MIME-Version: 1.0 Content-Type: multipart/report; report-type=delivery-status; boundary="iA201CuA023535.1099353672/isengard.qualcomm.com" Subject: Returned mail: see transcript for details Auto-Submitted: auto-generated (failure) X-PMX-Version: 4.6.0.99824, Antispam-Core: 4.6.0.97340, Antispam-Data: 2004.11.1.3 This is a MIME-encapsulated message --iA201CuA023535.1099353672/isengard.qualcomm.com The original message was received at Mon, 1 Nov 2004 16:01:09 -0800 (PST) from [210.193.18.250] ----- The following addresses had permanent fatal errors ----- (reason: 550 5.6.1 Prohibited attachment type) ----- Transcript of session follows ----- ... while talking to hobbiton.qualcomm.com.: >>> DATA <<< 550 5.6.1 Prohibited attachment type 554 5.0.0 Service unavailable --iA201CuA023535.1099353672/isengard.qualcomm.com Content-Type: message/delivery-status Reporting-MTA: dns; isengard.qualcomm.com Received-From-MTA: DNS; [210.193.18.250] Arrival-Date: Mon, 1 Nov 2004 16:01:09 -0800 (PST) Final-Recipient: RFC822; win-eudora6-bugs@eudora.com Action: failed Status: 5.6.1 Remote-MTA: DNS; hobbiton.qualcomm.com Diagnostic-Code: SMTP; 550 5.6.1 Prohibited attachment type Last-Attempt-Date: Mon, 1 Nov 2004 16:01:12 -0800 (PST) --iA201CuA023535.1099353672/isengard.qualcomm.com Content-Type: text/rfc822-headers Return-Path: Received: from eudora.com ([210.193.18.250]) by isengard.qualcomm.com with ESMTP id iA2018uA023523 for ; Mon, 1 Nov 2004 16:01:09 -0800 (PST) Message-Id: <200411020001.iA2018uA023523@isengard.qualcomm.com> From: win-eudora6-bugs@eudora.com To: win-eudora6-bugs@eudora.com Subject: Re: Excel file Date: Tue, 2 Nov 2004 08:00:34 +0800 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_NextPart_000_0001_00000AE6.000070CC" X-Priority: 3 X-MSMail-Priority: Normal --iA201CuA023535.1099353672/isengard.qualcomm.com-- cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/TestMessages/00000431000066400000000000000000000177411240331347200242610ustar00rootroot00000000000000Marshall-Sez: This message has nested multiparts; with the last part of a multipart being another multipart Resent-To: mail.app@flagg2.qualcomm.com Resent-From: eudora-suggest@flagg2.qualcomm.com Resent-Message-Id: Resent-Date: Mon, 1 Nov 2004 22:33:29 -0800 Received: from flagg2.qualcomm.com [129.46.154.229] by localhost with IMAP (fetchmail-6.2.5) for marshall@localhost (single-drop); Tue, 02 Nov 2004 11:39:31 -0800 (PST) Received: from snape.qualcomm.com (unverified [129.46.132.184]) (using TLSv1 with Cipher RC4(128), Exch RSA_SIGN(1024), Hash MD5(128)) by flagg2.qualcomm.com (Rockliffe SMTPRA 6.1.16) with ESMTP id for ; Mon, 1 Nov 2004 22:33:29 -0800 Received: from sabrina.qualcomm.com (sabrina.qualcomm.com [129.46.61.150]) by snape.qualcomm.com (8.12.10/8.12.3/1.0) with ESMTP id iA26XQcH013328 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=FAIL) for ; Mon, 1 Nov 2004 22:33:26 -0800 (PST) Received: from moria.qualcomm.com (qualcomm.com [199.106.114.68]) by sabrina.qualcomm.com (8.12.10/8.12.5/1.0) with ESMTP id iA26XNHJ013973 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NOT) for ; Mon, 1 Nov 2004 22:33:24 -0800 (PST) Received: from isengard.qualcomm.com (isengard.qualcomm.com [199.106.114.75]) by moria.qualcomm.com (qualnet-external) with ESMTP id iA26XMha015651 for ; Mon, 1 Nov 2004 22:33:22 -0800 (PST) Received: from d60-65-159-220.col.wideopenwest.com (d60-65-159-220.col.wideopenwest.com [65.60.220.159]) by isengard.qualcomm.com with ESMTP id iA26XFuA029259 for ; Mon, 1 Nov 2004 22:33:16 -0800 (PST) Received: from lopezclub.com (lopezclub-com.mr.outblaze.com [205.158.62.177]) by d60-65-159-220.col.wideopenwest.com with esmtp id 1F1D2A4AC2 for ; Tue, 02 Nov 2004 00:35:33 -0600 Message-ID: <010001c4c0a6$2e00ef5b$f3fa62fd@lopezclub.com> From: "Coarsest A. Spading" To: Eudora Subject: =?windows-1251?B?zeUg5OD+8iDv8O717uTgIOru4uDr5fD7Pw==?= Date: Tue, 02 Nov 2004 00:35:33 -0600 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_NextPart_000_0036_D092C96B.3CE29AF1" X-Priority: 3 X-MSMail-Priority: Normal X-Mailer: Microsoft Outlook Express 6.00.2800.1106 X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2600.0000 X-RAV-Antivirus: This e-mail has been scanned for viruses on host: d60-65-159-220.col.wideopenwest.com X-PMX-Version: 4.6.0.97784, Antispam-Core: 4.6.0.97340, Antispam-Data: 2004.11.1.6 X-PerlMx-Spam: Gauge=XXXXXXXXXIIIIII, Probability=96%, Report='MR_OUTBLAZE 5, IMGSPAM_BODY 3.2, RCVD_IN_CBL 3, __SANE_MSGID 0, __TO_MALFORMED_2 0, __MIME_VERSION 0, __NEXTPART_NORMAL 0, __NEXTPART_ALL 0, __CT 0, __CTYPE_HAS_BOUNDARY 0, __CTYPE_MULTIPART 0, __HAS_X_PRIORITY 0, __HAS_MSMAIL_PRI 0, __OUTLOOK_MUA_1 0, __HAS_X_MAILER 0, SUBJ_FULL_OF_8BITS 0, __HIGHBITS 0, __IMGSPAM_BODY 0, __TAG_EXISTS_BODY 0, __TAG_EXISTS_META 0, __TAG_EXISTS_HTML 0, HTML_FONT_COLOR_BLUE 0, __TAG_EXISTS_HEAD 0, __IMGSPAM_BODY_1 0, HTML_90_100 0, __HAS_MSGID 0, __OUTLOOK_MUA 0, IMGSPAM_BODY_1 0, __OUTLOOK_MSGID_1 0' X-Maybe-Spam: X-Maybe-Spam This is a multi-part message in MIME format. ------=_NextPart_000_0036_D092C96B.3CE29AF1 Content-Type: multipart/related; type="multipart/alternative"; boundary="----=_NextPart_001_0037_D092C96B.3CE29AF1" ------=_NextPart_001_0037_D092C96B.3CE29AF1 Content-Type: image/gif; name="ani.gif" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="ani.gif" Content-ID: R0lGODlh/ABLAMQAAP///wAAgAAA/wAAADMzmRERiEREoVVVqoiIw+7u9szM5SIikLu73d3d 7qqq1GZmsnd3u5mZzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ACH5BAAAAAAALAAAAAD8AEsAAAX/ICCOZGmeaKqubOu+cCzPdG2LCUQEQXEwt6BwyIoYCrzk gsgcGpHJwJLIIzmg0cCjye3GGossjwD0mltgcYDMrOKQi3IigkSc73jAooBQ5P8re313bgAP UiYKiICMQg4Bfo2SI4+RhAEjYQ4nhSJGSQeWIp0ApJ2kB1VqSSOopIkHcHYlCQ9IPg0kBwQA DDtrsyQKqWIsDbY9D7mjq5gqw7Imx7fKury+Y8EknzyhJYVXzswjCgYnirwjv1ll4ySm4qXx iqrNrfOsKY9Z6SINWEk2iSDw4FCWAst62VOxL0oBgc3imWiYpB8AijweqisoBiGJdVHaycOR zx2KBAiQ/7RDsGZZgx0W4X2L12ndTE7xbJ7kASEBAAU7gtXxeayHz1Jh2ABoYGARgB0Pjpo8 kQDJAZ8JUhWQOjVFAp4+gQaYVTXAVQBZjY5KWoapU5YEXMJ85yxCgAg3cWYUGSYh2lMSZd6j FKBpYIkmHxlOAcGssEUstQFoDIHZlI93u45kXLhE08p0WzQ+8HhKY3MkPls2sQOvngB+v9J0 RuDyYL1j/OIMzfu2yTD08goH/kodpBRNTXxNx0MgCQZrRCAxUdy4SIUWN6/YIarEjuvQmQdw PiK8CsB/JWtHwUCr7gQMEBxB33uqG5akBefFv144bjWaudMYAaJUF6B+5yFW3/9t1ZECn3xQ hBbLbizwJwIDYRTjW1foleUTgoN52N+CMy3UoDiGaYhCcSCuqOCGDL5YCIYA3tMchT8ZwBVv 0EkBQQQKyLYgglUcMkuLIxkZ4JJMipAcjksBZOCI/U0Jo3+3PUmdMz0u8GOQ6B1C3m9auCiC Jv6BCJgiBcDIIiQ9XGlcd5hdV8IhdiqWWplNfleCeSSewF0Kfj4XnSEB5NnZa2PSV6hv+4yJ KGn9sTQbloA15RySPGgqpwiNbTHCV6YtWt6ij2T3mmsA2BXTi6Ca6mQAoH1aQqgkkBoraiOo dtGhJIThGimW8sbmdjwgcNQwPCwThqi1JCGVmrM5VaX/gkoEStJYIohFFhIG5MKAQQk1pRQ2 FiHh15RlnZXWVljuxO1PQb1hFlZaSWVuGehmwme0PEwrziG1ogBSEhp5IgYEYbQTUY3yHOcm tjwUCOuv/FihxpgH95AQwfGWgNGNIZ8wskUjj+ddRwnZlQXDiW6IhMATpUiAetgUBgR0vD6s YqeYUsxrkz8Rs4B6tUDxwwkI/LKAqN3GWTIJ0ySzI9HCGK1e1QVExbTTUJf3iwE7m9oJSz1f nIeVk7Tt9ttwu8B23HTXbTcjc9+t995835B334AHLviWgxdu+OGIJ6744ow37vjjkEcu+eSU Bz7A5Zg3PgAAm+stwOefnyBA/wmggw5A6aafjvoIpUfe+QivJ5655ySMXvvpKNhuuwm7izB6 770zHjvnlccdPPC488567qQr//jwnb8u/ewiUM/55SdIDzv22XNfvffaY8499cMnb37ovrO+ +/rN37588OnH7/zy7d/+O/18iw/+97BX37//xAMgCbQXwAL+L4AEjB4BC1g+/K2Pfb6DoPnk Jz8JUhB16Dve/NRXQcBBD4D7Y+D/FnjA8plQBdHjnwBJqLz76Q5394OhDOvXQQpOEH4RbB0N HYi/vX2QeJtL4PZmx8Lrkc96AhwgEYFYQvGpwIXJg+ILobhD3WGwhxN0Xxa3WEMu1u2H4xvh AUtoAv8hJvGMIrzeCsf4RBlOcYZS3GAU66dB0WnRi+fD4t3AmMI0prGIZvQeGRGowDUaMgUW TKQeb2jD9MEPh4xspBYtqDf9LTCIlhyiEht4ySB2L3bY66MfjchGHpqyiw9MHRcxGDpW2vB3 q8uj+tDnuB8W75a4LGMJGvg4Vvryl8AMpjCHSUxh5vKYyEymMpfJzGY685nQjKY0p0nNalrz mtjMpja3yc1uevOb4AynOMdJznKa85zoTKc618nOdrrznfCMpzznSc96WlMR5mgAMQ6QELHw iRlRmBWdijYGh2WBEr8ggKT8sc+E6LMbukHoGJzjAKepx54naAoQANKmn2T/zKMHVcjQopaF TdAjoACwVBRYRQKOjsClJlBpEvDisigUDKPKQYSFUmGHVIAmFXh5BKVKEIYdpUJULFmCUE1Q BxGwpKMk2Cm3pKqepqY0Tk1xTXDeuYoU2KUyTYkEPtfTmcicoDEsBYCWRmLWNCEmrFEzB1w9 OlKyIsYutmFnV1GQCiCgBz2pyJABLAGdoZ4jOoHtVCSaMgu0EW4w9NlTY2VlGI/Ik21Ftata +WSQp4ghEroilMo65oeXREFVmo3sCExbkRJAoQAD1avaNoOekwb0CK45RD+qkwZR4VYEuo2S QyL610uV4B/DNUFwLztbN9CnHGu4AlR7Uxzkhu0my4x16qFUNBL6RCG7V0Xt38jJNjfMday0 6ExTaKYZ5BZsvZA17nclNtbzLoq7VTgCe+PJth3kgqqbBUICPJUKSh2CUsthamZ04ZhJAcCq SY1pg3l6VUpR2LXzinCBgdtg/hqXwWWAaWNO6w+OHqWwdwIQchHmk5EtFKYPdojJxLCJFWdk GeP9pmoVBpq0mCUhEIjGag3DzxGgFcMacsuPxVbQkzR0VE8+Qc6UspQoU8meoSVCZnG6zLkK QRGG5TIy0SsEL4v5zGiOWwgAADs= ------=_NextPart_001_0037_D092C96B.3CE29AF1 Content-Type: multipart/alternative; boundary="----=_NextPart_002_0038_D092C96B.3CE29AF1" ------=_NextPart_002_0038_D092C96B.3CE29AF1 Content-Type: text/plain; charset=windows-1251 Content-Transfer-Encoding: quoted-printable =c2=e4=ee=e1=e0=e2=ee=ea =ea =f0=e0=f1=f1=ea=e0=e7=e0=ec =ee =f1=f2=f0= =e0=ed=ed=fb=f5 =ef=f0=ee=e8=f1=f8=e5=f1=f2=e2=e8=ff=f5 ------=_NextPart_002_0038_D092C96B.3CE29AF1 Content-Type: text/html; charset=windows-1251 Content-Transfer-Encoding: quoted-printable
 
 
=f1=ee=e2=f0=e5=ec=e5=ed=ed=e0=ff =ed=e0=f3=ea=e0=2e = =c8=ed=ee=e3=e4=e0 =f2=e0=ea=ee=e9 =ea=eb=fe=f7 =e1=fc=e5=f2 =e8=e7
------=_NextPart_002_0038_D092C96B.3CE29AF1-- ------=_NextPart_001_0037_D092C96B.3CE29AF1-- ------=_NextPart_000_0036_D092C96B.3CE29AF1-- cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/TestMessages/00000975000066400000000000000000000112651240331347200242710ustar00rootroot00000000000000Resent-To: mail.app@flagg2.qualcomm.com Resent-From: eudora-suggest@flagg2.qualcomm.com Resent-Message-Id: Resent-Date: Tue, 2 Nov 2004 08:05:31 -0800 Received: from flagg2.qualcomm.com [129.46.154.229] by localhost with IMAP (fetchmail-6.2.5) for marshall@localhost (single-drop); Tue, 02 Nov 2004 11:40:47 -0800 (PST) Received: from snape.qualcomm.com (unverified [129.46.132.184]) (using TLSv1 with Cipher RC4(128), Exch RSA_SIGN(1024), Hash MD5(128)) by flagg2.qualcomm.com (Rockliffe SMTPRA 6.1.16) with ESMTP id for ; Tue, 2 Nov 2004 08:05:31 -0800 Received: from neophyte.qualcomm.com (neophyte.qualcomm.com [129.46.61.149]) by snape.qualcomm.com (8.12.10/8.12.3/1.0) with ESMTP id iA2G5TcH006140 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=FAIL) for ; Tue, 2 Nov 2004 08:05:30 -0800 (PST) Received: from hobbiton.qualcomm.com (hobbiton.qualcomm.com [199.106.114.69]) by neophyte.qualcomm.com (8.12.10/8.12.5/1.0) with ESMTP id iA2G5R9A004119 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NOT) for ; Tue, 2 Nov 2004 08:05:28 -0800 (PST) Received: from mailserver.internal.evanstech.com ([216.235.152.49]) by hobbiton.qualcomm.com (qualnet-external) with ESMTP id iA2G5QBU029487 for ; Tue, 2 Nov 2004 08:05:26 -0800 (PST) From: postmaster@evanstech.com To: eudora-suggest@qualcomm.com Date: Tue, 2 Nov 2004 11:04:00 -0500 MIME-Version: 1.0 Content-Type: multipart/report; report-type=delivery-status; boundary="9B095B5ADSN=_01C4A240558054EB0030F626mailserver.inter" X-DSNContext: 335a7efd - 4457 - 00000001 - 80040546 Message-ID: Subject: Delivery Status Notification (Failure) X-PMX-Version: 4.6.0.99824, Antispam-Core: 4.6.0.97340, Antispam-Data: 2004.11.1.8 X-PerlMx-Spam: Gauge=XXXXX, Probability=50%, Report='VBOUNCE 5, __TO_MALFORMED_2 0, __MIME_VERSION 0, __CT 0, __CTYPE_HAS_BOUNDARY 0, __CTYPE_MULTIPART 0, __HAS_MSGID 0, __SANE_MSGID 0, __UNUSABLE_MSGID 0, __VIRUS_MYDOOM_1 0, NO_REAL_NAME 0' This is a MIME-formatted message. Portions of this message may be unreadable without a MIME-capable mail program. --9B095B5ADSN=_01C4A240558054EB0030F626mailserver.inter Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit ------------------ Virus Warning Message (on echelon) Found virus WORM_SWASH.A in file message.pif (in message.zip) The uncleanable file is deleted. Visit http://qualnet.qualcomm.com/it/virus for more information --------------------------------------------------------- --9B095B5ADSN=_01C4A240558054EB0030F626mailserver.inter Content-Type: text/plain; charset=unicode-1-1-utf-7 This is an automatically generated Delivery Status Notification. Delivery to the following recipients failed. john@evanstech.com --9B095B5ADSN=_01C4A240558054EB0030F626mailserver.inter Content-Type: message/delivery-status Reporting-MTA: dns;mailserver.internal.evanstech.com Received-From-MTA: dns;qualcomm.com Arrival-Date: Tue, 2 Nov 2004 11:03:49 -0500 Final-Recipient: rfc822;john@evanstech.com Action: failed Status: 5.1.1 --9B095B5ADSN=_01C4A240558054EB0030F626mailserver.inter Content-Type: message/rfc822 Received: from qualcomm.com ([80.231.132.37] RDNS failed) by mailserver.internal.evanstech.com with Microsoft SMTPSVC(5.0.2195.6713); Tue, 2 Nov 2004 11:03:49 -0500 From: eudora-suggest@qualcomm.com To: john@evanstech.com Subject: Status Date: Tue, 2 Nov 2004 17:03:42 +0100 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_NextPart_000_0007_BF11B844.031F7FC2" X-Priority: 3 X-MSMail-Priority: Normal Return-Path: eudora-suggest@qualcomm.com Message-ID: X-OriginalArrivalTime: 02 Nov 2004 16:03:50.0928 (UTC) FILETIME=[8B44D100:01C4C0F5] This is a multi-part message in MIME format. ------=_NextPart_000_0007_BF11B844.031F7FC2 Content-Type: text/html; charset="Windows-1252" Content-Transfer-Encoding: 7bit The message cannot be represented in 7-bit ASCII encoding and has been sent as a binary attachment. ------=_NextPart_000_0007_BF11B844.031F7FC2 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit ------------------ Virus Warning Message (on echelon) message.zip is removed from here because it contains a virus. --------------------------------------------------------- ------=_NextPart_000_0007_BF11B844.031F7FC2-- --9B095B5ADSN=_01C4A240558054EB0030F626mailserver.inter-- cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/TestMessages/0019-NoBoundary000066400000000000000000000072551240331347200260400ustar00rootroot00000000000000Resent-To: mail.app@flagg2.qualcomm.com Resent-From: win-eudora-bugs@flagg2.qualcomm.com Resent-Message-Id: Resent-Date: Mon, 1 Nov 2004 16:01:16 -0800 Received: from flagg2.qualcomm.com [129.46.154.229] by localhost with IMAP (fetchmail-6.2.5) for marshall@localhost (single-drop); Tue, 02 Nov 2004 11:38:27 -0800 (PST) Received: from snape.qualcomm.com (unverified [129.46.132.184]) (using TLSv1 with Cipher RC4(128), Exch RSA_SIGN(1024), Hash MD5(128)) by flagg2.qualcomm.com (Rockliffe SMTPRA 6.1.16) with ESMTP id for ; Mon, 1 Nov 2004 16:01:16 -0800 Received: from neophyte.qualcomm.com (neophyte.qualcomm.com [129.46.61.149]) by snape.qualcomm.com (8.12.10/8.12.3/1.0) with ESMTP id iA201FcH022189 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=FAIL); Mon, 1 Nov 2004 16:01:15 -0800 (PST) Received: from hobbiton.qualcomm.com (hobbiton.qualcomm.com [199.106.114.69]) by neophyte.qualcomm.com (8.12.10/8.12.5/1.0) with ESMTP id iA201D9A029029 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NOT) for ; Mon, 1 Nov 2004 16:01:13 -0800 (PST) Received: from isengard.qualcomm.com (isengard.qualcomm.com [199.106.114.75]) by hobbiton.qualcomm.com (qualnet-external) with ESMTP id iA201BhJ016885 for ; Mon, 1 Nov 2004 16:01:12 -0800 (PST) Received: from localhost (localhost) by isengard.qualcomm.com id iA201CuA023535; Mon, 1 Nov 2004 16:01:12 -0800 (PST) Date: Mon, 1 Nov 2004 16:01:12 -0800 (PST) From: Mail Delivery Subsystem Message-Id: <200411020001.iA201CuA023535@isengard.qualcomm.com> To: MIME-Version: 1.0 Content-Type: multipart/report; report-type=delivery-status Subject: Returned mail: see transcript for details Auto-Submitted: auto-generated (failure) X-PMX-Version: 4.6.0.99824, Antispam-Core: 4.6.0.97340, Antispam-Data: 2004.11.1.3 This is a MIME-encapsulated message --iA201CuA023535.1099353672/isengard.qualcomm.com The original message was received at Mon, 1 Nov 2004 16:01:09 -0800 (PST) from [210.193.18.250] ----- The following addresses had permanent fatal errors ----- (reason: 550 5.6.1 Prohibited attachment type) ----- Transcript of session follows ----- ... while talking to hobbiton.qualcomm.com.: >>> DATA <<< 550 5.6.1 Prohibited attachment type 554 5.0.0 Service unavailable --iA201CuA023535.1099353672/isengard.qualcomm.com Content-Type: message/delivery-status Reporting-MTA: dns; isengard.qualcomm.com Received-From-MTA: DNS; [210.193.18.250] Arrival-Date: Mon, 1 Nov 2004 16:01:09 -0800 (PST) Final-Recipient: RFC822; win-eudora6-bugs@eudora.com Action: failed Status: 5.6.1 Remote-MTA: DNS; hobbiton.qualcomm.com Diagnostic-Code: SMTP; 550 5.6.1 Prohibited attachment type Last-Attempt-Date: Mon, 1 Nov 2004 16:01:12 -0800 (PST) --iA201CuA023535.1099353672/isengard.qualcomm.com Content-Type: text/rfc822-headers Return-Path: Received: from eudora.com ([210.193.18.250]) by isengard.qualcomm.com with ESMTP id iA2018uA023523 for ; Mon, 1 Nov 2004 16:01:09 -0800 (PST) Message-Id: <200411020001.iA2018uA023523@isengard.qualcomm.com> From: win-eudora6-bugs@eudora.com To: win-eudora6-bugs@eudora.com Subject: Re: Excel file Date: Tue, 2 Nov 2004 08:00:34 +0800 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_NextPart_000_0001_00000AE6.000070CC" X-Priority: 3 X-MSMail-Priority: Normal --iA201CuA023535.1099353672/isengard.qualcomm.com-- cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/mime-roundtrip.cpp000066400000000000000000000062161240331347200245120ustar00rootroot00000000000000/* Read in a mime structure, parse it, and write it back to a file with the same name as the input file, but with "-Results" appended to the name We don't just write to stdout, because we want to read/write binary data, and stdout on some systems eats CRLF, and turns them into newlines. Returns 0 for success, non-zero for failure */ #include #include #ifdef BOOST_TEST_DYN_LINK #define BOOST_TEST_ALTERNATIVE_INIT_API #endif #include #include #include #include #include #include #include namespace { std::string readfile(const char *fileName) { std::ifstream in(fileName); if (!in) { std::cerr << std::string("Can't open file: ") + fileName << std::endl; throw std::runtime_error(std::string("Can't open file: ") + fileName); } std::istreambuf_iterator src(in); std::istreambuf_iterator eof; std::string retVal; in >> std::noskipws; std::copy(src, eof, std::back_inserter(retVal)); return retVal; } struct my_traits { typedef std::string string_type; // typedef std::pair < std::string, string_type > header_type; typedef std::string body_type; }; // using namespace boost::mime; typedef boost::mime::basic_mime mime_part; typedef boost::shared_ptr smp; smp to_mime(const char *fileName) { std::ifstream in(fileName); if (!in) { std::cerr << std::string("Can't open file: ") + fileName << std::endl; throw std::runtime_error(std::string("Can't open file: ") + fileName); } in >> std::noskipws; return mime_part::parse_mime(in); } std::string from_mime(smp mp) { std::ostringstream oss; oss << *mp; return oss.str(); } void test_roundtrip(const char *fileName) { smp mp; BOOST_REQUIRE_NO_THROW(mp = to_mime(fileName)); BOOST_CHECK_EQUAL(readfile(fileName), from_mime(mp)); } void test_expected_parse_fail(const char *) {} } using namespace boost::unit_test; #ifdef BOOST_TEST_DYN_LINK bool init_unit_test() #else test_suite *init_unit_test_suite(int, char **) #endif { framework::master_test_suite().add( BOOST_TEST_CASE(boost::bind(test_roundtrip, "TestMessages/00000001"))); framework::master_test_suite().add( BOOST_TEST_CASE(boost::bind(test_roundtrip, "TestMessages/00000019"))); framework::master_test_suite().add( BOOST_TEST_CASE(boost::bind(test_roundtrip, "TestMessages/00000431"))); framework::master_test_suite().add( BOOST_TEST_CASE(boost::bind(test_roundtrip, "TestMessages/00000975"))); // Following test is removed because the file it used often tripped // false-positives when scanned by virus checkers. // framework::master_test_suite().add ( BOOST_TEST_CASE( boost::bind ( // test_roundtrip, "TestMessages/00001136" ))); // test cases that fail // framework::master_test_suite().add ( BOOST_TEST_CASE( boost::bind ( // test_roundtrip, "TestMessages/0019-NoBoundary" ))); return #ifdef BOOST_TEST_DYN_LINK true; #else 0; #endif } #ifdef BOOST_TEST_DYN_LINK int main(int argc, char *argv[]) { return unit_test_main(&init_unit_test, argc, argv); } #endif cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/mime-structure.cpp000066400000000000000000000075241240331347200245270ustar00rootroot00000000000000/* Read in a mime structure, parse it, dump the structure to stdout Returns 0 for success, non-zero for failure */ #include #include #include #include #include struct my_traits { typedef std::string string_type; // typedef std::pair < std::string, string_type > header_type; typedef std::string body_type; }; typedef boost::mime::basic_mime mime_part; template void DumpContainer(std::ostream &out, const std::string &prefix, const Container &c) { out << prefix << ' '; if (c.size() < 10) { for (typename Container::const_iterator iter = c.begin(); iter != c.end(); ++iter) out << (int)*iter << ' '; } else { for (int i = 0; i < 5; i++) out << int(c.begin()[i]) << ' '; out << "... "; for (int i = 0; i < 5; i++) out << int(c.rbegin()[i]) << ' '; } out << std::endl; } void DumpStructure(std::ostream &out, const char *title, const mime_part &mp, std::string prefix) { std::string content_type = mp.get_content_type(); if (NULL != title) out << prefix << "Data from: " << title << std::endl; out << prefix << "Content-Type: " << content_type << std::endl; out << prefix << "There are " << std::distance(mp.header_begin(), mp.header_end()) << " headers" << std::endl << std::flush; size_t subpart_count = std::distance(mp.subpart_begin(), mp.subpart_end()); switch (mp.get_part_kind()) { case mime_part::simple_part: if (subpart_count != 0) out << str(boost::format("%s ### %d subparts on a simple (%s) type!") % prefix % subpart_count % content_type) << std::endl; out << prefix << "The body is " << mp.body_size() << " bytes long" << std::endl; DumpContainer(out, prefix, *mp.body()); break; case mime_part::multi_part: break; case mime_part::message_part: if (boost::iequals(content_type, "message/delivery-status")) out << prefix << "The body is " << mp.body_size() << " bytes long" << std::endl; else if (1 != subpart_count) out << str(boost::format("%s ### %d subparts on a message (%s) type!") % subpart_count % prefix % content_type) << std::endl; break; } if (subpart_count != 0) { out << prefix << "There are " << std::distance(mp.subpart_begin(), mp.subpart_end()) << " sub parts" << std::endl << std::flush; for (mime_part::constPartIter iter = mp.subpart_begin(); iter != mp.subpart_end(); ++iter) DumpStructure(out, NULL, **iter, prefix + " "); } } int main(int argc, char *argv[]) { int retVal = 0; for (int i = 1; i < argc; ++i) { boost::shared_ptr rmp; try { std::ifstream in(argv[i]); if (!in) { std::cerr << "Can't open file " << argv[i] << std::endl; retVal += 100; continue; } in >> std::noskipws; std::cout << "**********************************" << std::endl; rmp = mime_part::parse_mime(in); } catch (const boost::mime::mime_parsing_error &err) { std::cout << "Caught an error parsing '" << argv[i] << "'" << std::endl; std::cout << " " << err.what() << std::endl; retVal += 10; continue; } catch (const boost::exception &berr) { std::cout << "Caught an boost error parsing '" << argv[i] << "'" << std::endl; // std::cout << " " << berr.what () << std::endl; retVal += 10; continue; } catch (const std::runtime_error &rerr) { std::cout << "Caught an runtime error parsing '" << argv[i] << "'" << std::endl; std::cout << " " << rerr.what() << std::endl; retVal += 10; continue; } DumpStructure(std::cout, argv[i], *rmp, std::string()); } return retVal; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/mime/test/mimeParse.py000077500000000000000000000022051240331347200233240ustar00rootroot00000000000000#!/usr/bin/python # # A python program to compare against the output from "mime-structure" tool. # # Usage: python mimeParse.py # import sys import email def parseOne ( msg, title, prefix ): # if prefix != "": # print msg if title != None: print "%sData from: %s" % ( prefix, title ) print "%sContent-Type: %s" % ( prefix, msg.get_content_type ()) print "%sThere are %d headers" % ( prefix, msg.__len__ ()) payload = msg.get_payload (); if msg.is_multipart (): print "%sThere are %s sub parts" % ( prefix, len ( payload )) for p in payload: parseOne ( p, None, prefix + " " ) else: bodyLen = 0 aBody = "" for p in payload: bodyLen += len (p) aBody += p print "%sThe body is %d bytes long" % ( prefix, bodyLen ) print prefix, if bodyLen < 10: for c in aBody: print ord(c), else: for i in range(0,5): print ord (aBody[i]), print "... ", for i in range(1,6): print ord (aBody[-i]), print '' # _structure ( msg ) def main(): for a in sys.argv[1:]: print "**********************************" parseOne ( email.message_from_file ( open ( a )), a, "" ) main ()cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/000077500000000000000000000000001240331347200206115ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/benchmarks/000077500000000000000000000000001240331347200227265ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/benchmarks/README.rst000066400000000000000000000002101240331347200244060ustar00rootroot00000000000000Here we can collect some statistics about different areas of performance in the :mod:`cpp-netlib`, including run-time and compile-time. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/build/000077500000000000000000000000001240331347200217105ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/build/CMakeLists.txt000066400000000000000000000005411240331347200244500ustar00rootroot00000000000000include_directories(${CPP-NETLIB_SOURCE_DIR}) find_package( Boost 1.45.0 COMPONENTS unit_test_framework system regex thread filesystem ) add_library(cppnetlib-uri STATIC ${CPP-NETLIB_SOURCE_DIR}/libs/network/src/parse_uri_impl.cpp) add_library(cppnetlib-server-parsers STATIC ${CPP-NETLIB_SOURCE_DIR}/libs/network/src/server_request_parsers_impl.cpp) cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/000077500000000000000000000000001240331347200213565ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/.gitignore000066400000000000000000000000061240331347200233420ustar00rootroot00000000000000_buildcpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/Makefile000066400000000000000000000060761240331347200230270ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml pickle json htmlhelp qthelp latex changes linkcheck doctest help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/cpp-netlib.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/cpp-netlib.qhc" latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \ "run these through (pdf)latex." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_ext/000077500000000000000000000000001240331347200223155ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_ext/adjusts.py000066400000000000000000000006701240331347200243470ustar00rootroot00000000000000from sphinx.writers import html as sphinx_htmlwriter class CppNetlibHTMLTranslator(sphinx_htmlwriter.SmartyPantsHTMLTranslator): """ cpp-netlib-customized HTML transformations of documentation. Based on djangodocs.DjangoHTMLTranslator """ def visit_section(self, node): node['ids'] = map(lambda x: "cpp-netlib-%s" % x, node['ids']) sphinx_htmlwriter.SmartyPantsHTMLTranslator.visit_section(self, node) cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/000077500000000000000000000000001240331347200230045ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/Button-Info-icon.png000066400000000000000000000066531240331347200266160ustar00rootroot00000000000000‰PNG  IHDR00Wù‡ rIDATxÚÕZ tUÅþþ·å%/ yYH€@•¥).E‹ZZµÅc¡uG=¥ñ¸´µ.ôTE-9UZí±(+Z·** E(Å‚ d_Èò²¼eúϹïÞûÞKjíéœóŸ;™wïÜùþÿû—™‘k™,ãXƲŒd)`ñéßúXYö±ìbù¥óH¼”¾âóCY.fùËd– Û¼b€~ˆe+ËßXžf9øM8‘eËù,iÆHZ6¡p´@p=„pyÔ;bîV ½–к_ þc ·ÝÓËò<ËR–÷¾n£Xîc™ÅââE%S™0ßa”ñlj:â«×Cpé¿cB Ì„І×Æ=L¨·½oÂÇ·±<Ër ËgG€‹åZ–»!¹ž9ÏÌ)Æ+M> ã†fQyq¶(+ `hŽŸ²üáuÓS8*DGOÛzhO}—¨¬iLJ‡:¨/cd½„ª×v2“:ä,KXÒ ¾2€,–5,2%æ ?ðúQœ›NçŒ-'—‘åwÿ'Þ;ú=Qzwo«xiW#Õ´t3àýu„kSNÞ²žežô¥H'•üœ€œbà,¶nA ò3}˜}B&È1Y“0k?ÓšJÚº¿ ëþU‡¦NV{ט¥m5òçP~Ö¯“@.þ–Ñ6‘0ýR”"Íë⇉$³å‚y"î+í~á>7sŽÞp ÏUÖÓ;lô°Ò_¹P½]ÞËéý耤 {Æ£”ôìEäIK–Ò„aÙB½Þ¶ xŸ„6€c¡ }bocì4¦(S¤û\D|ãnA;ªÛÅúÊzDzÙ7^]*Põ¶üa'ËÔTtJ@:ì3,aøD6àì§~Ì_ˆ‘yê ó);URª‚ðys7NžéÇå!ÔÅ“ÛëÐÒA~ÀgÝNJö5‡ðÌÎzöoö‹çïl—¿þ•e;Õk¯gYŽà0Â÷— ÊÈÂÌ1TR¡ÌMÚ!¥šÉn²´®Çû"1Ì>6Î, êq2h³|S öwôZú"n9 [Œ^ü¨Qˆ+ý/7rþ¨–s,dY9€Q†¹\žL\º’S©˜PœIòÕúHG"óI½nÕƒ=Ú0ÐA>7î?{d|ÜP×ч;6PãÒ l2z†%mc:íà‹ú*Ÿ¯—Ñ©Ó µ-O$xÚ0ÓI?N‡Ü€3ŽÍ¹ô‚­…[ô‰SŠ’f, úq×iÓL G±à…½Š:&dÔ¸à4ñòîf´Èè´‰#ùæ?AÓûâTdy°ƒŠWVpiA§ Š<a¤V‚²€²„ @kõÆ- ­ás»ð茑”ís;,ð^]îÝ\cjÛ´„"£"> §ðæ®0Þú¬•ÐøÃ|àpüu tÙa°Ö@vÎMÎG~–&qfÕZ× A|ܤ”Œ1 TzBa€O>JdØåöy{¯¸mS5šBÒµ…b0û"ÞßVÓNMÉ°ƒSÒKfÊ\;ó«ÈõãÚ'¹öã[C² kI¤P"•RE%[Ëb_——Žvê9Âpia£‹îب¿Æ ha+|PÇÎ,£ÒC—]-=’¡,Í7ÞÈò;L™K8ûáæÚ†µ/«1¤é¹oD—8…´¬DFfì—ãBh©d'L7û:‘ ÛïBý˜ˆ÷±D4Êô•U„-kåèÍ,ËL¯³œùÅ£1(Ë‘¹*# d¸öi@gŽk6mîñDí;- #ÿ¾–w‡jNÌWɧß`™&_#wRuÈÈÉÀÏ×Ün18ˇ¼€O[@ÐÊs™> yoúIœãJ³¯;‚¾î0¹#B ñ»‘›æ¡Ú€Wô™•†-Ç5yÓ>ÓþÀhîê 2E¢„û/µÉMQi~Ç \~±èÂì4d¦ylôBû ZtGD!—ÍeƒÒ¨,7]ŒÀ˜¢ úE;qg$F'o¨âÛböˆc û1íÐr#¡töFD}{¯ÑÇ‹>Ù$•p²\ÆY*pÆ\2-0èRÀÕ¦ŸÏ ŽA²è”Ø7©ÃýE,*Œ2¶ ¥pè×j;qå;5ýÐGQ%©SÒù£±ƒ)“~°š ô¸œe¾|˯YnÅÜÛ€IçZ²ø¼.e—iÙS)¥ÌzuYnWàˆý²ÿ‹÷h¬6ÔÚ5, éÓÖàq¹ùi …Õ=Û^X+—ßÈ—>ʲó—qá<ÅXt¶ß¯€\¨ËôòƒåÜ=/?ƒ;¥8 ÀÄW÷Ñ®°E ´bÌN!;0€¨±«3îÿx‹@… œX-<Ær®Y”Mxc•Îôa XJE¥rÃm#ágÇ:èóIG/¦¼q 9ÖÛ¯±dê˜Â@7W³9dW§«®–Ó>n˜‡ëŽ™dhÚËOK¤iÓ±íÑÉN'žÿí‡Ðø¢€Ã+>kÃ’›“6)òX´±÷yÃ#"Òù£<¾{›Àƒ€5…®á*uìIj\Ãø%w ³QHpAE¸>¿Ô¨%ìfn­ÅÆænMà Ì0iˆû@^t<‰LŽïÚ,°êú8…¤7,ÁîN:Ï \.¸ee êïTTJŒHê:/' «§ uЧ•#ÈÈ7«ŠÆRÐÆF™Ô‘”‰ñsшPHRhóàwÈ©ï6ÃèjÌäzÁÕ¬u—Ћ&.), ¸m²@˜ù!N¡µ%9˜5*w\iõ ]bNe£=yé¤eXÃ>—ª5@Ö?,ðâj9ß+‘:ïÅ–Y´qËź±%x? j!·ºš–P5’®…¸¥s¤80u8rÓ½?ù´YTêŒ×?ªîjGfÖ<¼P£S 5û"¢µè„•7 ¼¿1žÈT)‘ `9—DwœFÆÕN!·™ ~—O[þ€i\¾vJ±#‰qÒmµø¼'ÚoµiÐÈAMM!­yuð< §­]f)as§ãö' eåŠBn…Ü–5ÔÕæÄμ@¿ÍO7óæÝû+¹î_Ù ·XHUë$Gžh ­Gcj¼ª’p×erîf1g•ÓßG¸|‘À­¸\–¸h@Ä/ù`tžÃu¿À½u]t+—ÂŽìëÌ´)yo,:¦Õã2<±”ð÷5Iå´ÚÐ Ê÷cÅË@zº¢‹›¬«‹œÔrÙÆG GšÝLWB 4uO Þ’Udgî†.Dä¤P49êÄébHÌqºpÐÖ”´¡‘Mm)Ü)0ãöŠçƒ:†5l´Š;º²Àµ>7­L¨ÚøÅ5Q”µwis7¦Ž+ ŸÖv$[À¡uM!3òÄb–^~ øý)·”²©Mýà¡„ågM€ö·€•­7dÐÌ£2žcÍ_TÝNÇîmÿ8ãhœYÛIŸöD¬ºÇN¡¨m¡v0Ç»ºnà<Õx°ßM½lòÈb.¹¸l!±¶'5#ŒÂÌ nG~À¡Ò\*Hsž>T|Ô„¥;hÃô‘bkø‘ÖîTeƒÓTÉË à‰åO=(§_‡~ŽUdS[oàûÊÆòâç½™Sø…–CÇä"(Çš «Ù77… RjHâ|”kžp$fùÀî]ÀM³9„†åÙè€[²©£Åa%„eÏä 0ÁUª=Ñ9(ô0ï¼~ésX@®mEGýêp¯ˆšÇ&ÉÅš"µ5º9 „Ãl™D·²ãÎ!TïýBG‹²Y‡»“Nãj£‚£’ß°D.ïk=n{‚³,àßçøqVºÇ˜`''œŠ®0¶öj·%. u"¬ñ™ô¤z8Ø,™ÏlK®ë îÊf¯Ÿ~.pûrB†_x<.â÷Ç.Ž(¤2tò!€õŽä ‹©ù„š§–÷ÕFÙê!ür¡ÀÆ€ÿòxÝlÖŽoO%ÜÍT0H>¦ÒpÖrºÇ…„Ä–¼M`+—­i\åFÿ@OD}7keÚ,áÂòŸo~évêÓÎ÷ð¦gl¹Qfe:§yŒ$TrÛËl ¡îI(•ùZÓÁA¦,›±«XÌ›•ýUòɯô‰ÉN'õ‘Ïë#Ì¿A`>ûyV¦ŒL4ÌçżÍbG'Y/…Y‰BGìÌùŽˆ ®^«{£ÄG £¨XI¨X!6NŽŽÈG>³9?³\u0ûBfÀHl™^70½‚L­,öt¹5Õ‡¾LD·\#Ó¥•ÛÈté G÷;»ëžâ$ñ빚ð5|fµ7™'PToÜ/âŒ~Á,`â$ÀëÖyÖ'[YSÑ…Ã$¶ož{–c W0õÀ×ü¡;±%ÿ«A^>aòòr.³J CŠ„~åæ Ô-P[Çåb¡²R`ë ¹Éüžðþ«Abû¿ýgTíòï6ÿèoË¡Ú…IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/Button-Warning-icon.png000066400000000000000000000055371240331347200273300ustar00rootroot00000000000000‰PNG  IHDR00Wù‡ &IDATxÚíZ tå¾÷ŸÉî†%Ï%!QP‡DEä!ˆ§>ŽhE©¯ƒ´‚B± E¥9R()bÑ*G«Å7ÖÇ©ÊCŠˆÈÃPÌXB6 ÙMfæöþóØÙ,µ¼zN7çcþùgöŸûý÷ûï½ÿ,ÿã<Ùœª|ŒK%öùVÆGŒÆS€ï׌ÇÅ)×*ÿ`ЩH@Ž5‹1^€Wt Ð/:Ìþ¿ŽÑå1Ð ó¾9Œ NJı$0žñ§PPÀ¢!¼¸£ß4ùCüYµ#ÃF0RoÈþßÙDN݃>ô-[çµó5™Íþü»F\Võ$×B/Fù©@@Žñ㊙Csè¾Ë²¸2[‘hÛ×¼nì]CÔ°ßì/[¥I‹kdÿÆ•ð_JéX¸–±¸k±*ÖL."Ÿ  œùKTûL"ôµ4ŸAu¤­ ÆÎa\#ê;# Û*5yí:Æ['“€\¥›g¿u_+|N&ˆ6:à19Ûž‰ÿ´U¿£òSXòe\û—²û+FOFìdaqæ•=°øÞÄŒLRÍÌ,@HJ#Ñf¡¶b4QÓa:ï¾·9&û+zpEŒ ¿ Ùk§A—â n qÖurP$ÛèÔ¶þÍ›¤ïx ¶ÿ aŸ©aŠkåK]áMàYƈqC²`æM¹À‹ÔÞS…ïÈ£J&F#hë§4€I/‚¹ï×Ê+ wžH½«[爌/+¦Ü–”η¡uçhS úWÿN+!¥óÄ@‘Í`l«9'œ;©÷ÕM|¹?cý‰ +Ï‘#. fµµóí¦TЗ ¢¨4-#¼Œ#Ò!³­o©v-ü°G/<(ûV1ÉÛŽ7›‹ÎmŸ«)EQ@tÎ ·ÐyF(îHûE}Çs@5†*>_º®Cÿ‡ÂðÅ.éÎxéxhÁØ&Ú½ÿp! ì@ÌëJX<ÐZ¬È@”s&$fÝ)%L_Îâ¶&#ªy¿^IT½ W–ÇhÈô*à"ã;¾­+ãðñ"0•ñ‡ëû¶€Ç…?ˆÓ¯T3=£)%“¹/èù"iõ oaŸØ½Œ=ïðµ8Ü27o¬9ì<ãǃ@{Æ– ƒæÃ…,üˆÙÉœNW¸T»²2Ûx=ÐðèÒ®ðÊmŠî@ªÞL»öépþøJ¬S_îÎØu¬ HmÞ4ùWÙ4eXk=غ?'\aš$ œ}/+ñ èV0¾ž×ŒÇU¤ªÕœÜêaÚË58㵨¼þ Xkí˜Èø°mHQ¶Ì+†`&ü¹Ýý!kôŽ&:Ü ¢`g£j»žµNœøäH):Tõ1º©„½^Ù—2V 2lÊøÜëùñ!6°…*!«£5ë¼pÍét<Àm¥í(ÚóxÀØû {_mæþ’Á}µ;xÃYƒ/¯¬§ÛçDä-ÁÊ7G «?†€ÌÏôëê§e3 Q(‚ãþ™l¥?IÀ‘MFA¥Ã}ú·e@UزI! {ô8@ÝNÔ5ƒJ'WÁ'ÛâÒ¶‘`eüŸM€§Êy‹Xüñã­¡wg?o׳½ÒI#!Ì犴ËLÏ@ZÅ$ êO-Ù¸%äjK)AcÖmÃ%÷É-¨ÜGËÍÒ¡ŸK@V‰÷ß^ħÆåO?B @HD·„oÏBµÇ h›o¨ÿÆ’™!ËÊÜŽä݆«b½épWÙA|~i½ì Öú'èÌؘ•‰-O·Á¢|–NFA kæåŸ}ŽVò’d|¹¨ž¿ÌŠEÀ mC)@Ó¡¤±DÖýdŽ`÷q[‹™)1°û¨¨¶ä^An?·ÿTr§tÍ#wäÀ„sÀœõŒLsªDrtˉׇzÞGœÌ²-uhQÐ>¿„g8ž”œ~WÛòXZHýÌzµzÎÜ~¾ ÖÎïG¸‚ñ~Ç6*}ödd’¢²„„%ጠ¤F$µçRÿé–b»©iÓå Ù˜2Ü‹˜0#’Áu b]pOvðÞ¯a|ðcÈ·j%¯>ÜŠ®éŸÉ¹Š,!i®±€p-¼IéòG« MFt-i7»’—½ŒÔ5@VÛ9ÁDo¯n€§vÊ·{çCÊÛ½tîe”]Ö+€ï>ZrÝšRIÙ0!¯Œx#‘ÌÊ@„,¯‘·@ÿvlóè“MòH%φNpÕäý°|£¹ýäA`ÞÑpM åªùëæa·>K."1óöÑ!³'ÒD!¹vCCId›Ù˜=°‚71‹›{ÀÈŒ¤WdY ¶ÄdùÎF¼pt˜4‚V«ŽD`>ã7w_ÝÊÆä³q<¤@›š"%…À$ädå„Ñé ¸ 5Û6k=ðö²´Æ>q¼#ë<ø+ct:òMòÆP¶P7ý­ ò.+}¶DLI¹¸ää9Ú#R´Ñ’€{ti}ŽÏ+Ÿ4r¤º”“•aµ=GVB$jÈJ½ì5áQîRÆesïÉ£»¯mÉaĤú™VÀò€8²9¡a ÿLÙRÖñ®m¾+¤ñ€[N²_·½¡7"ïhÁ?ë`Ü“Õr¼åŒËå(ù†ì’öøɼ"òxöý¹–Þm IÚ·gÜ!€Öy‚€zæ%äÝèÐwöËð#pä¤óSx/éÐoL·îj’#\ÏxÓL;ŒÏ=ß}¤K{ýy\ï·°(¶q–áÎÑ‘Ž\ÖÎy‚€rÆ»L ?…ÀAÐ÷\•ÌºF"' 5¤¬¶«ŸšÅ«aÙú^õà~9‚|#x4£cuŸ.>X9·ˆŸÎÖÏà@ŽV¸LÕ|³ Þ*¿rÚëüý|Ot &`|C3ý“[÷î¶ ò’?.Ôí63ôÀqaX[a¦ƒþò±SSfß•c®ËBðµ hÙ!yÜZ÷„M‹ˆ5ëÂF¹­¿ÀßÍózÀ¨£òÖô‰Œt$ ÙÞ2#RÝ·œÆãoÖÒý ªåðÓ$ù“Ïðå³ a@kŸËåìÎà2²¹RgßsdÛ Ÿfä¥x€ T²§3]Kã×¹¼NÑ &P «6Å t‚™ ÉÇʽî°³[C¿?W›\ó„.bÔÄìºfÚ›ÈÐã;"qgÆi|ŸðF!iAÓ÷¶(Y ¥Ì´g ¸ÚdhDÞOh~²%Fƒî7 ¼"ŸÎxðñQ¹0ö†l6ˆHÈ5SbIS$„Í£P32f‘Gv"K¾’Ø”B ¹ ¼„„ø¶èV2êws?bÙëQšø”¹ÇyT8±¾]"Ö-(‚ü\ÅšÝÌ"À¬.,©Vl¨HŸ¸< Ø[%Êk€æ峓  8jB#®J!~¨®¨!l&·ƒ5:\xW¾ÛoþdØÛyÄß·ô<+Ÿy D=:ùd2½ª0“Z"Œ*vÜfN†U®Xå5O$\åƒ;4êÖ¬ÚaÁNXäjó‘Yœ@3ÌY'hó×0rf7}cæ·9²‹¥\ÈQß?ôïáÇâ•·®<€Þ5ˆýÖâ5¯!ºÖŒ³ks[ï”Èn ؉N硲JÃÕ›ã´fk¸ “£.c eÔº«• °Š¤ß2N‡Só³‡ñg°ŠÎ&'B¤~dß¹`ývUÉãÉúHì+ó~)¿jþÿ?{œìÏ+~Å:d`G«IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/cpp-netlib.css000066400000000000000000000221101240331347200255470ustar00rootroot00000000000000@import url('reset-fonts-grids.css'); html,body { background-repeat: no-repeat; background-position: left top; background-attachment: fixed; background-color: #fa2; } body { font: 12pt sans-serif; color: black; } #custom-doc { width: 80%; *width: 960px; min-width: 960px; max-width: 1240px; margin: auto; text-align: left; padding-top: 16px; margin-top: 0; } #hd { padding: 4px 0 12px 0; } #bd { /*background: #C5D88A;*/ } #ft { color: #C5D88A; font-size: 90%; padding-bottom: 2em; } pre { font-family: Monaco,monospace; font-size: 14px; background: #333; background: -moz-linear-gradient(-90deg,#333,#222 60%); background: -webkit-gradient(linear,0 top,0 bottom,from(#333),to(#222),color-stop(60%,#222)); border-width: 1px 0; margin: 1em 0; padding: .3em .4em; overflow: auto; line-height: 1.3em; color: #CCC; border-radius: 3px; -moz-border-radius: 3px; -webkit-border-radius: 3px; padding: 1em; } /*** links ***/ a { text-decoration: none; font-weight: bold } a img { border: none } a: link,a: visited { color: #800000 } #bd a: link,#bd a: visited { color: #800000; text-decoration: underline } #bd #sidebar a: link,#bd #sidebar a: visited { color: #8B4513; text-decoration: none } a: hover { color: #000 } #bd a: hover { background-color: #FF9955; color: black; text-decoration: none } #bd #sidebar a: hover { color: #FF9955; background: none } h2 a,h3 a,h4 a { text-decoration: none !important } a.reference em { /*color: #FF9955;*/ font-style: normal; font-weight: bold; } /*** sidebar ***/ #sidebar div.sphinxsidebarwrapper { font-size: 92%; margin-right: 14px } #sidebar h3,#sidebar h4 { color: #487858; font-size: 125% } #sidebar a { color: #8B4513 } #sidebar ul ul { margin-top: 0; margin-bottom: 0 } #sidebar li { margin-top: 0.2em; margin-bottom: 0.2em; list-style-position: inside; list-style-type: square; } /*** nav ***/ div.nav { margin: 0; font-size: 14px; text-align: right; color: #fff } div.nav a: link,div.nav a: visited { color: white } #hd div.nav { margin-top: -27px } #ft div.nav { margin-bottom: -18px } #hd h1 a { color: #EFFFEF } #global-nav { position: absolute; top: 5px; margin-left: -5px; padding: 7px 0; color: #263E2B } #global-nav a { padding: 0 4px } #global-nav a.about { padding-left: 0 } #global-nav a { color: #fff } /*** content ***/ #yui-main { -moz-border-radius: 3px; -moz-box-shadow: 0 0 9px rgba(0,0,0,0.5); -webkit-border-radius: 3px; -webkit-box-shadow: 0 0 9px rgba(0,0,0,0.5); border-radius: 3px; box-shadow: 0 0 9px rgba(0,0,0,0.5); background: none repeat scroll 0 0 #6ABDFB; } #yui-main div.yui-b { position: relative } #yui-main div.yui-b { background: #FFF; min-height: 330px; color: #164B2B; padding: 0.3em 2em 1em 2em } /*** basic styles ***/ dd { margin-left: 15px } h1,h2,h3,h4 { margin-top: 1em; font-weight: normal } h1 { font-size: 218%; font-weight: bold; margin-top: 0.6em; margin-bottom: .4em; line-height: 1.1em } h2 { font-size: 175%; font-weight: bold; margin-bottom: .6em; line-height: 1.2em; color: #092e20 } h3 { font-size: 150%; font-weight: bold; margin-bottom: .2em; color: #487858 } h4 { font-size: 125%; font-weight: bold; margin-top: 1.5em; margin-bottom: 3px } div.figure { text-align: center } div.figure p.caption { font-size: 1em; margin-top: 0; margin-bottom: 1.5em; color: black } hr { color: #ccc; background-color: #ccc; height: 1px; border: 0 } p,ul,dl { margin-top: .6em; color: #333 } #yui-main div.yui-b img { max-width: 50em; margin-left: auto; margin-right: auto; display: block; margin-top: 10px; margin-bottom: 10px } caption { font-size: 1em; font-weight: bold; margin-top: 0.5em; margin-bottom: 0.5em; margin-left: 2px; text-align: center } blockquote { padding: 0 1em; margin: 1em 0; font: "Times New Roman",serif; color: #234f32 } strong { font-weight: bold } em { font-style: italic } ins { font-weight: bold; text-decoration: none } /*** lists ***/ ol.arabic li { list-style-type: decimal } ul li { font-size: 1em } ol li { margin-bottom: .4em } ul ul { padding-left: 1.2em } ul ul ul { padding-left: 1em } ul.linklist,ul.toc { padding-left: 0 } ul.toc ul { margin-left: .6em } ul.toc ul li { list-style-type: square } ul.toc ul ul li { list-style-type: disc } ul.linklist li,ul.toc li { list-style-type: none } dt { font-weight: bold; margin-top: .5em; font-size: 1em } dd { margin-bottom: .8em } ol.toc { margin-bottom: 2em } ol.toc li { font-size: 125%; padding: .5em; line-height: 1.2em; clear: right } ol.toc li.b { background-color: #E0FFB8 } ol.toc li a: hover { background-color: transparent !important; text-decoration: underline !important } ol.toc span.release-date { color: #487858; float: right; font-size: 85%; padding-right: .5em } ol.toc span.comment-count { font-size: 75%; color: #999 } ul.simple li { list-style-type: disc; margin-left: 2em } /*** tables ***/ table { color: #000; margin-bottom: 1em; width: 100% } table.docutils td p { margin-top: 0; margin-bottom: .5em } table.docutils td,table.docutils th { border-bottom: 1px solid #dfdfdf; padding: 4px 2px } table.docutils thead th { border-bottom: 2px solid #dfdfdf; text-align: left; font-weight: bold; #487858-space: nowrap } table.docutils thead th p { margin: 0; padding: 0 } table.docutils { border-collapse: collapse } /*** code blocks ***/ .literal { #487858-space: nowrap } .literal { color: #234f32 } #sidebar .literal { color: #487858; background: transparent; font-size: 11px } h4 .literal { color: #234f32; font-size: 13px } dt .literal,table .literal { background: none } #bd a.reference { text-decoration: none } #bd a.reference tt.literal { border-bottom: 1px #234f32 dotted } /*** notes & admonitions ***/ .note,.admonition { padding: .8em 1em .8em; margin: 1em 0; background-color: #6ABDFB; -moz-border-radius: 3px; -moz-box-shadow: 0 1px 2px rgba(0,0,0,0.3); -webkit-border-radius: 3px; -webkit-box-shadow: 0 1px 2px rgba(0,0,0,0.3); border-radius: 3px; box-shadow: 0 1px 2px rgba(0,0,0,0.3); } .admonition-title { font-weight: bold; margin-top: 0 !important; margin-bottom: 0 !important } .admonition .last { margin-bottom: 0 !important } .note { padding-left: 85px; background: #6ABDFB url(Button-Info-icon.png) .8em .8em no-repeat } .warning { padding-left: 85px; background: #6ABDFB url(Button-Warning-icon.png) .8em .8em no-repeat } /*** versoinadded/changes ***/ div.versionadded,div.versionchanged { } div.versionadded span.title,div.versionchanged span.title { font-weight: bold } /*** p-links ***/ a.headerlink { color: #c60f0f; font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; visibility: hidden } h1: hover > a.headerlink,h2: hover > a.headerlink,h3: hover > a.headerlink,h4: hover > a.headerlink,h5: hover > a.headerlink,h6: hover > a.headerlink,dt: hover > a.headerlink { visibility: visible } /*** index ***/ table.indextable td { text-align: left; vertical-align: top } table.indextable dl,table.indextable dd { margin-top: 0; margin-bottom: 0 } table.indextable tr.pcap { height: 10px } table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2 } /*** page-specific overrides ***/ div#contents ul { margin-bottom: 0 } div#contents ul li { margin-bottom: 0 } div#contents ul ul li { margin-top: 0.3em } /*** IE hacks ***/ * pre { } .footer { color: white; } .footer a { color: #333; } img { margin: 10px 0 10px 0; } #index p.rubric { font-size: 150%; font-weight: normal; margin-bottom: .2em; color: #252; } #index div.section dt { font-weight: normal; } #index #cpp-netlib-getting-cpp-netlib, #index #cpp-netlib-boost { background:none repeat scroll 0 0 #6ABDFB; margin: 2em 0 2em 2em; border-radius:6px 6px; -webkit-border-radius:6px; -moz-border-radius:6px 6px; box-shadow:0 1px 2px rgba(0, 0, 0, 0.6); -webkit-box-shadow:0 1px 2px rgba(0, 0, 0, 0.6); -moz-box-shadow:0 1px 2px rgba(0, 0, 0, 0.6); overflow:visible; float:right; clear:both; padding:1em; width: 380px; } #index #cpp-netlib-getting-cpp-netlib a { font-weight: bold; font-size: 14px; } #index #cpp-netlib-getting-cpp-netlib h1 { color: #333; } #index #cpp-netlib-getting-cpp-netlib h2 { margin: 0; } #index #cpp-netlib-getting-cpp-netlib strong { font-size: 20px; } tt.py-exc.literal { color: red; } tt.xref span.pre { color: green; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/ftp_uri.png000066400000000000000000000617421240331347200251740ustar00rootroot00000000000000‰PNG  IHDR}©^C‹ÝsRGB®ÎébKGDÿÿÿ ½§“ pHYs × ×B(›xtIMEÚ 58qk IDATxÚì]gXUÇÖ~i‚ŠAA»`‰5ÖØ»±ÆhŒÆ£‰&1±DcL471ÆvÕ5vM¬` * ˆŠ€b¥wXßõmöÙœ(Øî¼Ï3Ï>göì6eÍ;kf­Ñ#"‚`Ĉ;v,:tèPªëüýý±aÃlݺUd¢€€€€€€Àk =m¤/11gϞţG`cc[[[Ô­[VVVoeF„‡‡£]»vˆŠŠB¥J•Jumûöí1nÜ8Œ1¢Ø´›6mÂgŸ}†ˆˆ˜šš–é7œ>}ÁÁÁ€áÇÃÚÚú-»wïâСC "´iÓMš4­U ÜQPP€ 6 -- –––5j”Ö´ûöíÃÆ///|üñÇh×®ÈDbûš£GBêzMLL0qâD‘1¯D„­[·âèÑ£HHH@£F0eÊØÛÛ{mtt4Ö¬Yƒàà`899aØ°ahÛ¶m‰ú¹ýû÷ãÌ™3066†¯¯/>úè#•èCBBpúôiL:µÄß©¯)òÏ?ÿ„³³3¾úê+ã?þÀìٳѱcGää䨥ÅÕ«Wßè_¾|9>þøãR¾ . ** C† )QúŒŒ ÄÅÅ¡<¬>Dtt4/^Œ¼ÑåñôéSDGGcëÖ­8yò¤H/ùùùˆŒŒDHH/^¬5Ý¢E‹ðå—_bØ°a8xð ¼¼¼0fÌ8p@d¢€NÄÇÇ#::ÑÑѸuëæÎ+2å#'';wÆ–-[ЫW/̘1ÆÆÆhÚ´)üýý‹å¾¾¾ÐÓÓÃÔ©SQ§NŒ5 «W¯ÖyÝñãÇñÎ;ïàÊ•+>|8úõë‡Ó§O£Y³fˆ‹‹Ózݹsç0mÚ4899¡OŸ>X¶lY©Ù­‘‘‘T©R% ¦’bãÆ4nÜ8zSñàÁªZµ*%&&–úÚ¾}ûÒêÕ«KœÞÏÏFE™™™åö=ÞÞÞtåÊz0kÖ,Z¾|9 ¼Lܺu‹êÖ­«ñÜõë×ÉÁÁ’““ñáááäéé)2O ÄxöìYXXˆŒxÅøüóÏéý÷ßW‹?sæ ÙÛÛÓÓ§O5^WPP@ 6¤Í›7«q KKKŠˆˆÐ*C*W®¬±Ÿ^´huêÔIãuYYYÔ¡CúꫯèÚµk”˜˜H5jÔ(Õ·ªiúÐ¥K4jÔ¨TS"oòÒÀ•+WbÔ¨Q¨Zµj©ÕôgÏžÅرcK|M‡°iÓ&˜˜˜ˆá•€Àˆ9sæ`Á‚033SÄ»¹¹¡B… ¸{÷®È$7þù'¾ùæµxii‘¶Ù¦;w¢R¥Jxÿý÷ñööö:t(~þùg×mܸóæ̓···Ú¹¹sçâÎ;ˆŠŠR;gll ???|ùå—ðôô|®oU#}ééé°µµ}陞——‡ððpdgg¿Ôç>{ö 7nÄŒ3J}íòåË1yòäRO ?bbbp÷îÝç"×QQQˆ-õu©©©¸yó&òóó_JY$''ãÞ½{Ï?‘‘‘¥ÎŸ'Ož ,,Lã²…òáÎ;HMM-uy\»v Ož<)Õuééé¸yó&îܹSªïÌÏÏÇýû÷qõêU<{öì¥åOBBnÞ¼‰¼¼¼–)%‘'¸uërssKTv'OžÄСC5ž·¶¶Æ;wD/ú ÛWLL ™™YªöX´ü£¢¢J,O¤þëe}gVVBCCñôéÓ—–¯ˆˆˆ@dd$ ÊU>çææâöíÛŠôùùùˆŽŽ.—oKKKÓÊ{ìíí‘œœ¬ñÜñãÇ1räHçFŽ‰={öh<7}út|úé§Ïééé¡~ýúˆŒŒ,·ˆbcc©nݺäèèHU«V¥*Uª£££"Œ=ZMM8räHrtt¤jÕª‘©©©Ú5µkצU«V)®Y±bÕ®]›éŸþ¡ððpêСÙØØP“&M¨fÍšôÎ;ïЦM›ŠUSдiÓÈÝݾùæ›çRë~ûí·¿­¤SÂÚÔ¾ÒT®“““Z¾H¡¸é䬬,úì³ÏÈÚÚš\]]ÉÍÍÌÌÌhâĉ”ššªsz7((ˆV­ZEVVVäââBæææäèèH~~~¯7n9::ÒäÉ“)22’|||ÈÜÜœêÕ«G¦¦¦4fÌÊÉÉ)Õú/¿üB¾¾¾äèèHäèèHS§N¥œœÓ»YYY4gÎù“––¦õyyyy´|ùrª^½:ÕªU‹7nLæææÔ¶m[ -Ñ;ÿý÷ßÔ´iSêÝ»7Ý»wOcšÃ‡–ÿ²eË(11‘ D¶¶¶äååENNNÔ´iSZ´håææj¼ÇùóçiÈ!T«V-277'///244¤FÑùóçu¾ã½{÷¨ÿþdaaA^^^äååEæææ4bÄ5j]¿~]k»Zºt)Õ¨QƒêÔ©C-Z´ 5j§§'-\¸,X 65"Õigggºqã†Ú=¿ûî;EMï¾fͪY³&ÙÛÛ“——™ššRÏž=)&&Fë7¶jÕªð¾k×®%Iž :”ªU«FŽŽŽ4iÒ$ùLC† ¡š5kRãÆÉÎÎŽÚ·oO¡¡¡Z§wcbbÈÁÁAO³gϦvíÚQ¥J•èðáÊóóæÍ+6–.]ª–?!!!äìì\_4߉ˆîÞ½K...…i¦OŸNDD½zõ*ŒkРegg«];|øðÂ4îîîôìÙ³2iÏyyy´lÙ²ÂöåííMfffÔ¶m[ Ó*‡U¿_uÚ«hÞ)®ÍÏϧü‘|}}ÉÌÌŒêÔ©CŽŽŽd``@&LP“W®\)Ì×]»vQÍš5ÉÕÕ•ÌÍÍÉÏÏBCC©nݺäììL...tìرÂk—-[VØ=z”¨}ûö…ý—ƒƒ½óÎ;´eË–r™Þ½pá5oÞœ,--©I“&dggGöööôÛo¿•ÛÔg\\ <˜,,,¨aÆäááA–––4nÜ8:sæ Í™3Gãu™™™4{öl²²²¢ºuëRݺuÉÌÌŒ&Mš¤V&[·n¥Úµk“——ýùçŸdnnN...T«V-ºwï:tˆ¬­­ÉÙÙ™š5kFwîÜÑùΤ&MšPŸ>}tÊ £F¢íÛ·«Å§§§“‹‹ =yòDãuíÛ·§sçÎi<—’’B”——WªüNNN&;;;zôèQ±iŸgz·pM_ll,EEEÑ·ß~Kǧ¨¨(EÐD2RSS)**Š–-[FT»&::Z(äääPtt4uëÖ&MšDÎÎδeË*(((LsêÔ)rqq¡¹sçê|ù3g΀ mþ\222¨zõêZ‘.Ìœ9“f̘Q,)½ÿ¾Z¾DEE‘ÖŠ$ 3f ÅÇÇ+â?úè#rqq¡ØØX­¤¯M›6Ô±cÇÂ<ÉÊÊ¢ýû÷SÕªUéâÅ‹jפ¥¥ÑêÕ«ÉÝÝlllè¿ÿýoae ¥îݻӄ Ê\ Œ=šš4iB×®]S4–É“'S×®]é£>ÒHú¤ü;v,%$$(â'NœH...§v]NNµk׎úöíKwïÞUtTëׯ':pà@±ïíææVXï´ ½‚‚ºwïÍž=›H´páBENmÚ´¡nݺQ~~¾Ú=öìÙC6l ÐÐÐÂóÉÉÉ´~ýz²´´¤h|vnn.Õ¬Y“æÍ›GŠ:¿`Á@ÿý·Æk¿üòKjÔ¨ݾ}[€ZYYQïÞ½Õ„û´iÓhÚ´iZß';;›¢¢¢ÈÉɉ.\¸ –O½{÷¦:(ž™MË–-#[[[µk$<}ú”¢¢¢hüøñôý÷ßS@@ÕªU‹-ZDñññ”••E&LPûÖ'N••ýöÛo…„°  €öîÝKîîî´qãF¤/ €Ú·o_øÿöíÛdggGŸ~ú)R»víÔH_ff&M:õ¹ò'((ˆªW¯NQQQ”••¥ñÚGѼyóhòäÉ…e””D:t õë×+äGÑNéúõëdee¥±­<rrr¨M›6Ô¯_?ŠŒŒT´¯uëÖ‘ƒƒ:tH£,^²d 988¨‘ºììlZ¿~=U¯^Îœ9£è+¤g.Z´ˆ:¤©áááôÞ{ïш#4Ú]]]ÉØظð}Ž9BÖÖÖdccC{÷î-,ïæÍ›+Þ%::šºtéBü19;;Óü¡x'ªS§}ñÅeJúÖ®]KNNN´{÷nE|HHuèÐ TæòùæÍ›äàà@?ÿü³¢/OMM¥ uéÒEc»¬_¿>7N!ŸŸ>}J~ø!¹ºº*Ê*//ÂÃÃIOOlllèæÍ›…ƒggg²µµ-¤þøã4iÒ$ïíââR(ŸçÍ›Wìw‘««+mß¾½PÎFEEQçÎiæÌ™Z¯srrÒÚ¦‰ˆìííéáÇ%Îï‚‚>|8M:µDé_ˆôIøõ×_iâĉ¥ºÉúõëiìر¥ºfÀ€d`` U[ñøñc²¶¶Öi˜˜Hfff€œœœ´jK´á?ÿùõéÓ§Ô áéÓ§TµjÕ ´¡fÍš:IßðáÃu’Þ¯¿þšzöì©•ôuëÖM£±È”)S´’ÕíÛ·“±±1íß¿_í\xx8™››kÔdhh¨u0òðáCªV­]½zµLH_XXÕ¬YS«b#''‡Ú·oOüñG™•e~~>µlÙ’þúë/­iúöí«‘ô <˜æÏŸ¯õºùóç« 322ÈÈȈ.]º¤èkõõõ¡3gÎеk×hóæÍäáá¡Q R¤oæÌ™äãã£sp[¤ÏðU.òmÙ²¥Îó­ZµÂ§Ÿ~Š/¾øBk333¼û~öÎ;Q«V­bß¡(233±zõjœ:uªÜò%((­ZµÒé ÑÀÀíڵÕ+WЬY3‹Aµ]G:Ój» ËÌJ›ˆpêÔ)¬_¿^kš * E‹óÇÇÇGgþ¢]»v BÓ¦Maaa066ÆÒ¥K‹5|)‰€¯¯o‰¿·U«V:Ï7kÖ gÎœAAAôõõÆ?ÿü3vïÞ˜˜¤¤¤ÀÔÔµk×FRR&L˜ ÙBK_˜ÿüs@`` >þøã2iÓ¡¡¡011Á’%Kt¦»wïžNã°Q£F¡R¥Jhݺ5ÌÍÍáïï÷¼zõ*–.]Šàà`<|øP­Z5¸¸¸ ++«\ätqmºeË–X°`A™øá»|ù2ž={†éӧ딩ÑÑÑÈË˃¡á‹wí!!!:å8::büøñå³®wP•Ïš,X_zzzž»*†Žâƒ>(ŒóôôD=àíí '''Ö²¦¦¦HHH€¥¥¥VãÄ*Uªk óÑGáöíÛ8rä*W®\®¼ë•’¾ôôôb-jÊ¢òjÂwß}Wlç¯ 7nD«V­àîî^nù’˜˜X"÷1VVVHHHx#­ú²²²••…Š+êL§)Jš?ÕªUCbb¢‚ÃÍÍMçunnn¨Y³f™[‡7˜(JøвeK4jÔ+V¬@ƒ `ee…¬¬,DDDvÜÚP»vm:t¨Ðz.00'NœÀo¿ý†¶mÛbõêÕw…100À‚ °`Á¤¥¥!$$þþþøí·ß°xñblØ°A#÷ññÁùóçáêêŠ;v`âĉ¨R¥ öîÝ‹Ñ£GãÂ… jVò %®ëªeù"xôè<<úè#Ìš5 S¦LÑH¦¥©fÍš¸yó&ÜÝݱ{÷n\¼x]»vÅ7àááK—.¡yóæe’¯¥i_Å‘ó‡¢bÅŠÈÈÈ@RR’NÒ·mÛ6L:Ó¦M×_~‰ÚµkÃØØÏž=CHHÊÍ⳸þÍÀÀ ÌòÖÑÑŽŽŽ:Ó-[¶ ÙÙÙeÒoÆÆÆ>×\¥é¿ÊªM¿RSS¡ |ªr`êÔ©Ø¿¿FÒW«V-„‡‡ÃÕÕUí\NNÒÓÓuæa^^FŽ‰´´4>|ø¥¸r{¥¤ïøñã˜9s¦ÎyãÆËü¹GŽtíÚµT×åççãûï¿ÇŸþY®ùÒ¨Q#üõ×_Ŧ»rå &OžüF’¾Š+¢AƒˆŽŽÖ©%¹~ý:êÖ­«–?%ÑÂ\¹rŸ|òIáwww¤¤¤`РA¥öÉø¢@VV–ÖFíçç§6â7o4h ö­&&&ðððPËUäææ*4¡5kÖDÍš51pàÀ­íÖ¬Y£‘d¨j LMMѺuk´nÝ ,À¦M›0räHܺuK+©éÑ£.]º„}ûö¡B… X¹r%FË—/«i¥6lˆ°°°Bm”6•Êw¨.´oß7nÜЙFÛy;;;…[¡N:ÁÏÏ7nÄÞ½{Q§N­»áH¤¸{÷î¸|ù2Þ}÷]⧟~*ÌI+­ oooܼy¹¹¹Ø±c† ‚V­ZáÑ£GˆŽŽÖª!T-“ØØX¸¸¸ÀÁÁC† ÁŸþ‰?ü077/“|­_¿>’““1xð`­š’`éҥؾ};Î;‡«W¯¢{÷îØ·oŸÆ¾ ==ãÆÃÞ½{ÕäyÕªUÑ¡C‡oiõ<ý×´iÓtö_eµ}d“&M`mmýR·k«W¯üüüž«ÿ*ÉÎ4AAAåÏËFxx¸N7uŽŽŽØ±c‡ÖÌÕ«WÑ«W/µs.\ÐIÒ³²²0pà@XXX`Ïž=å¦àR@” s44|.úñãÇñûï¿k"""´>¯ÿþZŠêééá“O>Á‰'ÔÎ:tHÍѨ*FŒÄÄDÜ¿_£Fêüùóسgzöì‰ * S§N¸zõ*acc£¦Y455EË–-±jÕ*‡M›6á½÷Þ+“:Ú©S'lÚ´ IIIZë°¶÷±··ÇãÇ‘’’Rçéé‰~ø;vìÀ¾}û0{öll÷îÝèÕ«Waþ„„„àüùó°µµÕ¨y522Bƒ pöìYœ8q½{÷†žžˆ;vhÕô©–ÉŽ;0xð`ÀàÁƒ±}ûvש"99«V­Â?ü Ó_£ „åË—?wÙ|ùå—ؽ{7üýýammN:aëÖ­èÝ»7Ο?¯–>88uêÔÑ:€ŠŠ*7ßyGŽÁÆ5ž ÄÖ­[Kµ'ª.Œ1¿ýö›Vq¥‘Ï[·nÅ×_]¬Ï»6mÚàÈ‘#ˆ‰‰Ñ™.44T¡õlÖ¬¢¢¢tjXŸr)›û÷ïã›o¾ÁÿûßbË¿^½z¸qã†VÍí¹sç´8 €µk×jôñ¹iÓ& 4H«–¸{÷îpttÄæÍ›_á€21ä¸t陚šjô;—œœLüñ‡šá€hÅŠäååE'N¤àà`JKK£ððpZ²d ÙÚÚÒ?ÿü£ó¹ááá…fÙ&&&Z]¨"00êÔ©Sjß9DD^^^%¶zQëÝ3gÎP­Zµ4šSíÚµµZêÚ†íôéÓÔ¶m[­†º¸7jÔHãâ~UüñÇ…eR¯^½b­ 5Z Þ¸qƒ6lH-[¶Ôh¬púôirttÔ˜?W®\Ñš?)))…þ#5¹HIII¡eË–iuÃ"¡mÛ¶…ß¹råÊb 9>ùäêÕ«½ûî»töìYJNN¦{÷îѦM›ÈÞÞ^ã=ú÷ï¯Ñ]@tt4ùúú’‘‘‘VCŽ:PçÎ5ú^ËÉÉ!OOOúúë¯5Ö*Uªhµì]±b988h´Î,(( jÑ¢…˜áÃ?$___úðÃ5ÞóÁƒT£F ~²>|H¾¾¾ÅtÍœ9“¾ÿþû·¿iÓ¦Q÷îÝÕagffÒøñã©C‡Z·a:t(­X±¢Ôm^5TåÈøñãÉ××W§K¤9s毯/õë×O!w===ÉÚÚZ«µßÝ»wÉÍÍlll†ÞÞÞäë뫶_[^Iu]ÓVUEå}íÚµiõêÕZÛ×wß}GŸ}ö™Ú¹Ù³g“ÚövDì.ÈÞÞžüýýñ?&###ºuë–Ú5Û¶m£ªU«’žž^¹r¬\¹’<==iÒ¤IBiiitóæMZ´hÙÚÚ–¨¯(Ë–O?ý”:wî¬ÕíèÑ£Ô£Gþ7oÞ\X– 4(ö™‹/&nI’““iòäÉT¿~}…[ÉÄÑÑ‘Õ® "GGGµü)KC__ßÂï,ê+X›ü6l˜Z;òóóÓÙWhì£|»wïÆ®]»°nÝ:øûûãóÏ?/ÔܵmÛkÖ¬)Uþ@•*Uðï¿ÿbÒ¤Iظq# Ã! IDATºuëggg<~üaaa8zô(zôèo¿ýVç»—æ;%Ö¾}û°jÕ*|ûí·¸xñ"ªT©ooo8p@ãÔÕ²eËЦM\¾|½zõBff&.^¼ˆÌ™3Í›7/Ì›¹sç*ŒŒŒŒŸŸoootîܨX±"¢¢¢ð矢E‹˜7ožÚ3+T¨€ZµjaÔ¨QhÔ¨5jGGGÄÅÅáôéÓ ÃÁƒ5¶5===4kÖ èÔ©SaüàÁƒÑ±cGŒ7N«öìèÑ£9r$Ö®]‹öíÛÃÚÚ7nÜÀž={0cÆ Ø÷ïßM›6ˆ ?~\žÆÐ×ǬY³Ð¡Cy;}útxzzbÈ!pwwGTTöìÙƒÞ½{cæÌ™hܸ1ºvíŠæÍ›+´°sçÎE·nÝУGµõk=B5´jX›5k† . cÇŽŠüéÔ©“Æ5EªZÂï¾ûN1ÍÔ´iSdddÀÅÅ*TÐx]:u””OOO…¡Ç!C0gÎüúë¯ÅÖ]Õº^œŒ533Ù3g0iÒ$lØ°AcûêÙ³§bË«øøxôë×ðõõÅ°aÃðã?ÂÅÅ°eËlÛ¶ +VD÷îÝññÇãûï¿ØÚÚbÑ¢Ehݺ5ºw-[",, 044„ŸŸÚ´iƒ¾}ûÂÊÊ Û¶mCxx8fÏž{÷îa̘1øàƒÚí &`ôèÑŠúª)®víÚÀÒ¥K1eÊ„„„ fÍšhÙ²%._¾ {{{³E7n,4ˆËËËCZZš¢¿Õ××Çœ9sЮ];ŵ‹/ÆO?ýoooôéÓõêՃ€ÜÜ\|÷Ýw°°°(“²€O?ýhܸ1úõëOOOddd $$'OžD›6mpìØ1T«VMqÝ;＃_~ù €Z¶l \¹r~~~øùçŸ}é¡C‡°jÕ*¤¦¦¢{÷î˜?~¡¡Lvv6ºwï®ÈMq/"Ÿ—,Y‚ &ÀÛÛ @ÕªUqéÒ%bçබÖÚ¦7oÞŒ>}úàäÉ“hß¾=®]»???lÙ²E£æþîÝ» …¥¥¥V õÕ«Waccƒ† *â³³³1tèPddd~gbb¢â>®®®X½zµÖoÕ#"JKKÕ+W´n­¢§§µ‚Õ´.éäÉ“xöìœáîîŽV­Zi\ß1pà@ < x!rtðàAøûû£_¿~ÅZä…‡‡£}ûöˆŠŠ*õ‚ÉwÞy'NÄ!CÊ„ÔÕªU AAAZ+“„¤¤$üóÏ?¸~ý:òòòаaCtíÚUãuOŸ>Åõë× Š•••bÁºêvZzzzðòò*/^,¬HúúúhÚ´i¡•fNN.^¼XH²ÝÝݵ®ÈÍÍÅæÍ›qûömŒ;¶ØEÝÿ¯mFHHNœ8§OŸÂ××­[·†……"##qÿþ}èëë£qãÆjèÙ³g8|ø0®_¿Žüü|xzz¢[·n%Z€|îÜ9\¹r·nÝ‚­­-<<<àíí]" Ш¨(¬_¿5jÔÀرcu֧ŋ#==‹-*u=IMMÅ–-[KKKxyy¡mÛ¶°²²Rä···ÂJ,&&5jÔÀ½{÷päÈDFF"++ èر£F‹oiIRR,--±oß>„‡‡ãñãÇ°¶¶†»»;¨•`l›‘‘¡V8sæ ¼½½u®ËÍÍÅßÿk×®!11 4@ÇŽáìì¬1}BBBCCµZ”ëëë£Q£Fj{äZ÷óóÃ¥K—РA´nÝîîîÈÌÌÄ… …DÂÊ•+±|ùrL™2M›6EJJ Ž9‚ÀÀ@iÍ#Mù“ŸŸÿýWgþdddàâÅ‹hÕªŒ ãoÞ¼ ===†eÁÁÁ°°°€“““bÊ688mÛ¶UiÂÓ§O±nÝ:äææâÃ?,Vf•¶}àÂ… …󆆆hÞ¼yaÆÅÅ!<<¼°œkÔ¨¡¶ž588‡Bll,ÜÜÜàííÖ­[COOÈË˃¹¹9¼½½‘K—.!//¯0ï$B„ÔÔT¸¹¹Z”kŠëÛ·/F¥U¢ ñññ…kXµ®¹ÒОUñðáCœ:u 7nÜ@nn.<<<РA4nܸXeFNN6oÞŒˆˆŒ;Vçº`UDFFâäÉ“¸qãŒáì쌎;¢N::¯+*Ÿ¥þ«¨|~öì®]»"R“õ§NRËMqEßwýúõpppÀ˜1cJÜߟ;wHLL,ôVPkÚŒŒ ìÛ·W¯^EíڵѣG­ýHZZZ‰–£5hÐ@c[Sí«5ÁÆÆõë××Mú^ÅÚ¯²"}¥Á´iÓ`oo¯uÍ6„……¡_¿~…Ú„Ńàåå…øøøb®À›!}¯/Ο?íÛ·ãƨV­|}}1zôè23Œx}ñ¼¤O@àUÃðécçÏŸ_¬¶RÜÜÜXfæ÷›6mBË–-áxƒÑªU«b}µ üO“¾ÄÄDDDD 11wîÜ)$S 6TL[”ž‡ðl•¦k„6¤§§#44´pÚ<-- þþþصköîÝ+jß[ŽŒŒ ܸq111ÈÌÌD`` ôôôàææö\õI@@àÕ"!!wïÞųgÏpëÖ­—Ú ”^úôî† °eËÅš,_¾¼\|ò½Jœúè#­‹½Þœ9s_}õ•b­¬žž&Mš„Š xÃðûï¿cÛ¶mjý׊+Ê̤€À[Eú^>Ä¢2Aúé¤O@@@@@@@àµÃ°aÀ† oßw-YhØÁH&}={±±oÎ-[ìÜ)*¬€€€€€€Àó¡}{`Þ< 5õíù¦G€E‹•m0ÕI_ÇŽÀÏ?¿”•üú+ e¿º×÷€“pò¤hdoRSÞ½[[@eßUز…Ó·ióf ¤€k×€úõ;;àܹ²¹ç“'@çÎ\'lmWW`Ó&@8L(®_ç~_jKNNÀ¡C/vÏÑ£jÕ€””7??úöš6zôКLbc nnÀßÿ¿™ýk "àƒ€ÌL`Û¶7§ –/>ý¨PUÉÇ‹üºãÁn4×®À… ÀÿïC¬@ÇŽÀ©S@íÚÀ?ÿõê‰ü|Ýqô( þÔTà“O€Ÿ~*»{§¥“'[·ùù×°!0~<0t(w:êÈÍ6oöí“Û—°~=ФIÙɶm{{`éR [7@×Î[DÀÓ§<¨üHH¬¬˜„Öª=ß{de±’(:xö ¨^ ¶¶@qŽü³³Ý»9s}}àßù]´’>"ÂòåÀ7ß°mÈížÄÄ÷ïÉÉ€³3àæ”`CbµNõÖ- 1¨Y“_ÐÎŽ_X[úÙ³3gøƒŠÙäùµÃúõÀ¤I\‰»u>úèÞ]û÷ ¼DD¿ýÆäüéS&~Û¶ff%¿Gv6ðá‡,¨LM‘#‰OO‘¿¯üý5k€={X˜/Z|öYù<+&øÏ€ßçºð@ÐÇèЧš7.ÙàB@àmD~>pó&pú4ÏŒ<)· O`Ê ]»²}îåË<è‹Žfò×¼9sccÖÖÇÅñQú“£ù>ÆÆ@¯^À¨Q¬•44,žÔ8ÀýÍÑ£2©- &66ªW¬­yp>5jìÚżLdçÌóæñ@'' U+&cOŸ2ézð@.Uýú3f-[êî 7ofÍ×;êç 9Ãíí>pÚ'¸ã=sæÍ՜ܼ |ù% WªáÃfÍXØ;:¾ø323¤$9¤§s¾çäÈÇ ¸U¬ÈGªL†¯hæ§O¹!ÅÅq%ÎÊâwÕÓãF$ÀÜœG=\ôô^ìÙ©©@HÌS'NpÙ¸ºrY úüÄüÀ`ÁàêUþïãÃíÄÛ›ƒ¥å‹½;k‘TË;3“óN œoÆÆL@mmY`T­úây÷¼B]UˆffÊåmd¤,ïJ•ä²¶°(2ôð!—uP“ùÛ·9¾kWô6mZþy•ÅrìØ1ׯËçôõÖÖ¯Ï2¡V-5jp¾JðûgeÉe§zÌÍòò¸œóò4ÿ60à²64”C… üm¦¦@•*LM¹¼íÈËc9”–&ÓÒ8O¥|S zzr¾hþ]±¢,ã‹ËhÿøçFv6kÉîß—Ã;,'ÃÂø»%Ô¨ÁkÓºtáe66å÷^))À_k×ò;¾(êÔaÓ¢…æó&°¶ðEafÆükî\nKÅ@¹#Ç’%žwaã¸qÿ;W¨ “~)¿¤P©’²¼‰”e”ÄÊ“'ÊöÖ¿?Ë,]ƒÕòÆãǼ $„ÃÕ«J¹ ŠŠ呾…×óÊ•ùhb¢$œ×ÚB^žL¸%"§+dfj×p”LLxúÛÊJìíY)áà _7‚˜˜¨$6ññêáe¨’BmAdKÁÈH®Sš‘’àKr+=]–»’¦,9Yó{™šrÿîåÅ+__ Aƒ—_npÿüÇ<óS\dc£TVåæò`2(ˆÛÍÂ…LÆ$¤§Ó¦ñ3,-¹¯uuå¼{øP ůýõòâþjìXæ %„ú6l ÀâÅ<Í¥­C64ätrbFk`ÀÂêâEàÝwY›%Mù9¨‘k;êÔaA DEiÖJ¨_Ÿ3­ÿ·S•íïÏkNâüSÙ£õµ€¥%—gÏž<]íTApþ<¯k;|øõü>[[ž*èØ‘ÀZY•ïHrÿ~Ö&ž:ÅÁëggžÒîÙ“§K£ýMKŽçò>z”§^'èé±<ž?ŸÉš¶ŒÜ\å”ò“',cÍÌXÚ¨Q©ˆžnÒ§ÚiGEq¥~ð€§¥iW[[Íš‹y½š°z5W~àãÏ?×¼6*=ï/1ܼ<¹ñ>çG½‘HJb«Ák×8\¿Îjï²P5ëës…µ´”ƒ4e¦:šKNfž˜ÈáÎY;ebÂë='OÖ½€öÁ^ø~½²ã¯Y“ëNµj\®Õªñ{©jRRXªUíØ‹t 5jp]lØ××5oÎõìU!:šIñõërˆ‰)b\¡‚²¬--Y#&•uÅŠœN*kiŠ]UóY£¯Mœ0A·ð îØ!wtOá¬] ¼ÿ¾È—·Çó´~^OŸž9˯ÞdìØÁkW‹®ž8‘g2^µ‹AúJ ±%„€€€€€€€€ }‚ô ü“¾x· W‰‚ö³Ö»7ðË/"?ÞFñN7°‹!—DúŽåmFj×¾ÿ^䮀€À«C\»8‹kÛ÷SàÍųgì+´`÷nÙ ³€€ÀK }•+óVmÏ»©º€€€@Y¡zuÞ!fÔ(‘o+,-ÿü‡·ÿ|]pþ¼(׶N•-ékÝšwdx]P­šÈQÆ/iiÀÌ™¢<ÊDì7òµ$}Àóï¹)P¾xøwP¶ŠŠÒž628wŽ7nׄ‚>/!<\¹Á{Ard’—Ç›•gdhff&pý:_—ž®=]J o&!.Ž7µ.ºñ8ï$ñèQñ êî]þ15ôv¢R%‘o;^—3æÍrD lñóÏ@hèkLú*T…T^øá E Þ#ÒÓSŽ¿t 4ˆŸ‰ ¨$`&£G³qMÿþ<í5v¬úý÷íãíµ¾úŠ§KªUã†DÖ?¾ýpr:väïß}¨W¯‹Š-âó;ó5«Wóóš5ãöíSî?îîÀ¯¿+Wòs[·’’ä4AA¼¿oÀÂ…L ?ø€÷„mÚ¨Y“I-À[+ÙØñ&èãÇkÎÏ={xW‰¯¿æï­Z•×€©ØWdâ[PÀß^y½w÷¼¾_wº¸8Χ´“ÿŒ ®S7n0a×MÄ˱±ü99ºÓ]¼(o“©}^t4·ƒÔT@_8)xë¡içŒû÷[·Š¿6/ë{l¬ît¹¹< ²²¸ÄÅ)åóêÕ¢,Þ6·oËÿ“’X•¤Ÿˆ‰BB¸ŽiCApö¬üÿÖ-YÞîÙ̘QÖßCDÇŽ BÔ³'ÑŒDkÖ­[GjHN&Z±‚hð`¢®]‰>ûŒèñcešs爢nÝøÿDŸ|BôÞ{šï)! €hút¢Î‰FŒ úóOõ4DcÆíÝËÿ%:”hØ0¢ät11D ð;Ì›Gôä‰æg>zDôõ×D½{óû}ó QZ½Ö¸vó×ÕUý\ݺ|îìY9î—_ˆ¼¼”é>ý”¨ukeÜÚµDÍš=}Êÿ ˆú÷çû/ç÷Â…gbB4>ÑÊ•|¢ýû9¢Ê•9ígŸ:E4s&‘ž‘••2wìàô?ü ÇI÷3†ÿççmÛFÔ·/ÇwéB4|8Ñ]ºD4`Ç7jDôßÿM˜@tæ ×c;;>·¿ò{׬!jÑ‚èÙ3ù{¥ûOœøòË57—hÏnWúúD/:DdkËïðû¥¤¨×‡f͈:t š5‹ÈÞžÈÚšïU3gµmËåÒ®§óöV¦ùç¢Æ‰æÌ!zÿ}.¯ªU‰BC‰òòˆúõã²76&òð ú÷_ŽŸ9“ÈÔ”ã«V%š4‰(+‹ïyö,‘¯/_7r¤òy?ÿLÔ«ÑÔ©ü‘“˹¢¸r…ÛÙäÉ\¯ììXæIí쫯ˆ\\øyÆÆ,½¼4ßKàÍÀÇDß~KT»6QÓ¦ÜMddÄå\©Ñ–-ê×åç-YÂœbÆ –gUª}ðQf¦œ.6–e’“ß/7—åÀr÷—_XæééqœT§Ö®}¡ÏmÙÂå;D©©ü•+}ñ…2åÅ‹,ä7näŽÒÏ?ÞƆ()I3éóóã{÷êEdfÆñšÈÜüùÜÙùû…„uï®ìô£¢˜”êësüš5œ™>>ÜqKûÄ &™ñ=*WæøwßåN]Ç5oÎ% WW¢øø×·"ÆÅi'}ݺ©“¾¸R©~ÿ“'Lœ$<}Êõ(ïwáßOOèÞ=ŽKK“ó{Ã9­$T““ùœ—§*œù\Hˆ7}:Ç9"Ç>- kUHÑÃ(!AŽÏÎfA ­^­¼fÉŽŸ=[ŽKH ²´$Ú¾]™öüyù{cb^n¹ñ Hª³ëÖ1Yùúk&aRž®ün;;"77¹|ããùýMLdBKÄíÎɉ šjÞ4h $Wææ<¸’pû6—eh¨' fÍR~Ãҥ߫—ú÷­\ÉuQÓ§U«&×-"¢“'ùyîî\׉˜Xþç?r|ñÑ÷ßóÀ¥J–]D\MLXI¸|™…³ }ÿ¤oÄî+öíãöìãÃñ߯Ló&×õ¯¾’ã22˜,ýö›2½«+(%¤¤°ÌT\=~ÌÏrwåñ6`Ç¢±c¹L›6eeɨQ|¬RE–Gªý-×Áš5•}ÔîÝò}RS9îÄ Yf<_¹’å}µj215å:YFÕ«ÇKQM*éKNæÑóÂ…ÊtòË~ú©:é³³ãûJÑÉ“¯ÚÉH#óªU¹ÁIHKc2 ÈZ="Ö2LôüüäøE‹8ÞÅ…è£äL‹#ªS‡Ï]¾¬$9Õª)‰w¨ìëŠ'O´“>‰,«VÂÏ>ã¸Î‰îß—ã¯_—ÿþ»L²'LÃÈ‘r…üûoY#¦§Ç$K›ÆJÒôEŸ>|îàA9îî]&jÙÙêdÓÙYyý¡Cß¿¿ú½›5S/g"þ€’p¬YÃqcÇ*¿÷ý÷åï=|øÕ”oË–üüÁƒåQaA\Çõôˆ‚ƒeB°¦ZõësüÕ«rÜøñIÛÜ°¡2]j* (ss¢ôtå¹N”ïÀßRTö±æ 7N_µª,‹6ââXO˜ ~?‰¤ Ò÷ö“¾öí•3 þþߣ‡2½+"òó•ñÁÁ²GøÝ¿Ïq«V)Ó~ó }o;®\á253#Ú¹SŽgùð,†„½{9î—_ÔïÕ¹3Ÿûì39./Oîs~ýU]®• é«^5ª£í¸8¢Ÿ~’ÿÏžÍ/«Þ@úõSV|‰ôuî¬L›—Çš: e¼›«=?ViJfìX9íG©gQXÇW­ªþ…ƒó¹;”DÈÁ§wUŸ)i…,-ßÒwý:OãD+ò4š¤AQ%ùçdzgšƒ*)«P5*Ú`` ™ô}ð?篿4«Ä÷íãúÃ9““ºvVéëÔ‰Ï]º¤Œ?qB]èϚń#6Vû÷jšzÃÅ‹Êøœy`Å 9þ×_Y»­:`’ÚŽ*yûî;Y@Iš±¢ä?2’ÓX[íÚ%ÇÇÄ(µùª$ûÊ9® @ÖænÚ$ÇGGó@MÓKS]¸|™Ïéë+µî5kÊÓ»E1cŸÛ½[ýœ4š¤ïí'}sç*ãÃÃeE„«W9®ysÍ÷’¦†¥{egsÇ[±"?I‘‘œ¬ì7é{ûp玬¡+Šä¸4ÈíÒ…ãNROø°¼4Jµ‘f©ŠÎF–éÓG—.¼pÐÓøé'^œhc|ò‰¼ðïäIÀܜ䫢Q#vˆÙ·¯úbACCõ…¶––¼RZÔ˜œÌÏŽŒ–.Uoo`êT Iu+¼¢ ³ÝÜä—EQ«–¼€]B` ¿Ïwß)ŸËÏ9ÈÎ~;¡zx°åOß¾\¶?ýxy§N) ¶:³°ÐT tôôt?_OÃî IDAT³¸óEá縺²UîÿËeQ÷Õµ¸–ˆë¢¶ï52z½ÊÑÈH6ŽQ]œ>q"РÁ ~Gf gi°„Ù¨åìYN?q"[t{xÈiœœxçŠøxÞÝ m[®'ÜþU1n7m’ãdCX»VŽß´IÝpHªNNêßÚ —uA&Çk¯ÒBè:uʯÞ¼y\¹$&*û3muä®_—?þ˜åç'Ÿðù;33¹øßC×®ÌEˆ€;wøxú´v9$ÉÚ¬,–×LL^ªœÒÇ?°€OI¦Mã—Ý¿_™êæMÙbîE ¹s‘¬A¥oÓ†-85…I“t[h—YÒ9UBÁ˜¶gþø£ÜÁ¼©ÖFª°¶f+ ]»¸:ub‹O€-`ÞÊH²²dW/e]»Ø·ã—_óç¿—?Å}offñ–|¯5kª×÷”¶È=š­”ÿúK©Âɉ­qߟ-dû hØøûoeº}ûØŠºre¶îÐøôSu볡Cy¶m›,~øز…ï{î6"î ‡ Q^/ ÂT-´U… 4À,éàK"ÂÂ1¼€&«^Õz!Õ=m®UÕëÞÒ¥¼«Kõê<ˆ<˜ëtjªÈãÿUÉrJOe™Tg4Õ­5deBq^ Ê•ôYYqG±mkøbcy+µ¯¾Rjí22dPYAjˆ%1«/K°vQ—õë ss®`‰‰ê¾éTI‹„E‹äßýû3oßžó~çNŽwu•Ójr1>kʳgó÷ ª~®¼Ê§n]>~ó¬SÅçŸ+5¯ $mk½z|ŒÚµØ¯ ÀæÍÀ?ÿðàîéS W/¥ßC€µ€¡¡À{ï1i[¾œÝä¨ÂÌŒëSBÇsçX“èè(»ÈùýwÖâ6oÎé5u¬Ú\̘˜°ÜiÕªdy#ÍH™’ †þ7Q»6cb´×=€5ݪèÕ‹2~È2kÇv%ð¿‹ XÛW·.ÏdJ3"šê–¾>§·°Pº\{é¤OøC‡²“]Éóó’%2[•:É-[4ßå›ožïéÎÎ|Ü»W³°ÎÏçéȲ†³3{NÿýwÍçW­z} a… ¬¹{ú¸rEŽ÷ócÈ›„À@9LMYs£J"† aÂÿä w²!!²iÃVY7l¨,—Ü\Í£•ìlù¼&²­:‚ÎÏç:–­ü–ÿU’Wi°!]§é¹Ò¢¨¦Gz¦êû ÊyÇß+µ”`ýz&0 ¼ÚrÖäÈZ$ÍšñqãF.«aÃ4ûÇT­Ã‹ˤ§[7%©Û¾ãce)Û¿_n#þ©~Õ)ÞåËåz5bûŒÜ¼øåÍ£DæÔüý±±¼´ÃÔ´dù%i7÷î՞掮^#´hÁÇ›7•ÓlªuàÀ ©þW­ÊZòS§˜ø8 îÃR .Þ>h’Çì?ÕÃC(HuëÀõô©©\WZ·.½ïÐ2¬SúX°@þgiÉS;;³€ æøNø¸r¥ÒI!ÀMZ ]/)«V ¨_Ÿ;ó±cÕµLË–•cÕ6møøå—ìhS×®±&¤èšÄ× ]»òqôh^—8v,p挼þqñbYÃGĤ@Õaó¥K€­-¯óxtòÓOüÍ7oòzÊjÕ˜M™¢$Ç÷î1™ÈÏg•Eqã?3'GÝ¡pt´,lžz‘Þaà@vü^Öœgfò”CZç¹êt¶‰ ï Jþ³³•kñ$bç訙T¶mËέÿþ›ËÛËKÎßx`ró&àë«~í¼yœÿÿ­>à;wŽ—L˜ ™Ø«j$|ø!·mS::UMÿªn ”¤aÑÁfÑ&Àõ´woþýË/ê÷ò÷gMŒ40ÉËã=œUeNÛ¶r¿(µ iæþ}¹®JëÞlÄƪ+Žãú¦:›&ñ©;eù¬Z¯írM›| ®Ç’œ,:3SZP•*êî)>ûŒ-L$?3))²“X[[v±};[QÚÚ*-˜$‹–V­ÔÍF$G¹·oËqGŽÈ&ËÎÎì³ï§ŸØ眻»ÒõøqœnÑ"å}ÓÓ9ÞÈHý™’8U7ÉÉDÕ«Ë­“&±ä˜1l¹¨êçëuDb";~41a75kÖÈֻ͛³/EÉÎøñìÒ£~}öÿÓº5§»ySý¾çαugåÊ:t`Ëh {ö°µv»vzõRZR;ÆÎ%¥óï¿Ï×ܽËå ÅwéÂî$ËЩSÙ©p»vìʃˆãÜÝe_€?ÿ̸Ò=fÌ`+¼À@þFÕwZ¶LvåÓµ«|nÊöɨê6ÄLJÝ3T®LÔ±£æ|yÖ»nn²ë!"¶,·²bkD AAœÖЭÜ?ûŒË¶W/ŽoÓ†‰ff²ï({{¥UÙêÕlM¡l»+WÊíîþ}¶Ö.j1_Ô]RQŸŒgÎhöVÔâÒÀ€Ý8I–ØmÍ AJk¶äd¶bÔýIJèÑCnÓ ²l™3‡óàïÿâ u/o>&LÐlÙ/µ==¥zL ×;==ö‰)Õµßg/AArÚ[·øÓ§Ë}bF»1›6Mù<ÉÂ~Än“‘‘¢lÞëÝ¢¼#1‘%¤~äó·U+¹¾,¼¼XñѶ-ËmnVþü“뢅×VƨâàAö+ÕÏ=Ô}AJïж-»*º¡Às@þù‡`iÉSB<ÅÕ·¯fSôädžj»qƒ‚÷éêGÕõcYYÊk\]YmYtª¯zuåÂóÈH6¥Žæø^½€*UäùtMS‰-Zð{µ´¶æEåÒÚ4U´k'[?¦¦ò÷\¿ÎÓ;ót•€À«B—.Àñã\ß›5ã郲vSPÀÃmÖðªkàJ²—¶¶tÙÙ%·‚'âiŽ²ZV‘—'ß+;›óPìÁ+ PDD0‡iÚT^ï\™\RYû¡G$V ¼¶¤O@@@@àõ!}o8ÄÐW@àu‚´ýMt'$ ä± }%„仨õ®€€€€ÀË…´,íñcí~qß0ˆé]×ÇŽ[·²ë€ý&véÂN‘ÅZ4—"ö?|ô¨<oÑ‚·híÑC>×B… HŸ€€€€€€€€€ }‚ô Ò' HŸ€€€€€€€€€ }‚ô Ò' HŸ€€€€€€€€ÀÛC‘匧O'Oäÿzz€««ØOU@àuÂãÇ@r²ü¿B N‘/oó(oT¨,ZÔ«ÇÁÝðòöíãM^îÞåMÔä6úÞ{@b¢È·zD‚y¼ìÜ ¬\ ÊqµjƒqhÒDhÿ^îÝöïç6yîœ<øªQ;˜305ù$ HŸÀ âÆ `Ý:îp?–ãÍÌ€V­__ÀÛ›5NN‚ ¼â‰0àúuàüyàìY &F>_¹2Ð¥ 0nе+`` òL@@@>rÀíÛÀ©SÀéÓ||ôHy¾bEÀÍ5‚öör¨^°²â`m]þZ‰¼< ;ÈÊ⣲²ä8M¿Uÿçæùùòò4ÿÎÏ ¹ã54”ƒç…©)wÒ•+Ë¿ÍÌ€ªU9XZrú·ÉÉ<õ˜˜È¿ÓÒ€ôtÒïŒ 9¿óòä<ÎËã5¥rkûmbó±èoMç¤ ý¯P¡|ó!;HHàÏáÑ#àáC11À­[¼¦V¦¦@ëÖ@»vš6ŒŒ„,¤Oà%#&†5aa@h(‡°0îÌuÁÀ€ P¥JòÑÈHÙ‘J‚Uô¿D‚‚7'%X­O× öö€³óë5}WP¢„6O@@@>×DL##û÷åpïžü;#CäSiak ¸¸01pqa›&MGÇò{f\ÂÞˆ6"ˆˆ¢¢Š'1ê{{.¯Zµ”GGG.S¡Á¤ï­CRkƒâã•GéwR’<ý§ÒÓËO‹gh¨Ôò *(§ MLx ·hœ*TPNùþxJ3'G>¦§©©ü­©©²ûœ¸8ññ¬IREµj@ãÆZ´Ú·,,JÿýññRA"ª¤¡(¡ÈÏWN¿©†¢SÈ©{ Pòòx 5:š5§ÀµkLÐîÝ“5JMš:ñ‚ÿ6m4[f&àçÇÁߟ ¤¦en4lÈ¡^=ÖDÕ®ÍÇ*UÞŒz"@]ë1UãôõÕ‰¹ê##&wÂPI@@@@>WŠ¤$¶ôôóŽãõ•O)¼ÿíÝ{pTåùðoHÈf“@ B¸ 0Jå‡ )­­\z¬â… Fh‹ Šƒ-Ž-"‡Ki-:V«Ñ6 ¹  r r!÷ÝMÞßÏœyÏîžÝ$$$›ðý̼óžóžwwÏžœì>û¾ïyÏd àÒÒ€­[eÞÅ¢"©Ó®0r$0|80t¨\…MDDÄ ¨ Ø·OæY|ÿ}]%]Ȇ€ÔT`Ü8Ž'#""}DMÚ¶mÀúõ¾wSII,hþSƃ>"""" ^EMDDDÄ ˆˆˆˆôƒ>""""bÐGDDDD úˆš¹3€ÿ¸~osvâ°t©Ü>î™gäVpDDDà”-DÃéÚ´JK%PëÕ«îϹg0w®Ü!$'xôQ¹×ð¦MÀ¤I<æDD·9Î$KÔÂÃþÈÍ­Ÿ€ïÒ%i5\ºèÔIÒgŸÉmಳy¼‰ˆˆAQ£<¸þž+=¸~]Z ýûKo GDDà˜>¢æáÐ!Écc=Ëðƒ>jöœNàÈ ˆ**€âbéNµRRdd™™€Ûm]ÇáÐ]¥eeR·®22¬/ä8|XöÉpô¨´Úù“•%yttà×ËÏ—×,-åùADÄ (ˆ|û-0s&DD7êm‹½{KùÈ‘ž;p4Ø°X»èÚèÖ Ø¿ß³ÞÀ¯~ üñÀHÝ´4Ù®”,tî lÙ|ú)”$'˺ÚÊÏV®”±|R^\ ¼óЯŸtÍ^¼|þ¹ìÏ=÷íÚ¯¼âù\¿ø…<Ï¿ÿí¹î=Npûv¹°ãÅuë€.]€#d, 1è#jtwß ¬ZŒ+­u••zÛK/K–H¹¹µ¬ª ˜0xþy äþô'¹BÖ»EÍé” kØ0 ÿòWP ¯—™ \»äågÎH àùóÀG“'K«ZyyíßÓñã€Í¦[ç 'OJû¿ÿÉú¶m’Ö¬–/—×{åàØ1ý˜­[e?zÈsÝÜ ùöÛrõî‹/Êòš5Àþ<  ûCDD úˆ‚Bb¢uy¾egÎgÏ……º¬uki14[¹Rºi§NÕeýú<"áâÅ@Û¶ÀÏ~üð‡²==X±øÃ$\´¨öïeÐ à¹ç|»bû÷\ZöÙ¾v­ìÏœ9ÀèÑô~ýuÍ_ëìY 5˜8HIÑåÉÉr<._¦OçùEDtàÕ»ÔütèØíÒÒWU%“‡„HàT\¬ë½û.)˜ÙéÓ’›[Ô¢¢$Ÿ4I/×õ"‰ÈHÏý1—À˜1žå}úï¿/ݾ5õÞ{ÒÙ»·ï¶Y³¤¥4=]IsPHDD úˆ‚žÝ.ÞÊ•Э^ ,X<ö˜´ø€Ë%­`O> ¼þºõó´05„Ûl¾eue<§·ˆëò„ÉËÊjþéé’wëæ»-.Nä‹¥K™AQ³Æî]jžV¬>üPºg• 1&OÖWÄ^¾,]¥‡‚V)&æÖîcHHíÊoÆåË’çç[oïÒEòŠ ž3DD úˆ‚@uPU•oÙO*p<ñ„<~ófiäJØ-€½{=§F1ûÜŒñ.Xo·Û%¯Ï‰¢‰ˆˆAÑM3ºe¯^µÞnîòÌÌ>ø@–ããeŠ’/¾õ¿ÿ]ƸÙl2Kn.°l™ïó]¹,\ØôÛÀ’ü±õv‡CZC­Æüƒ>¢×±£ä_~©ËÊËe:Àó‚·[Æñ™!sñrß[@.dä*Ý—^ÒÏqì˜\Eû£éÇSÅX]xq³Œ.U—˳ܘ8Ù»ÜhÍ´êŠ-*’<'dz|Ö,¹KDZcÀîÝžÛrrdš˜§žªß.e""bÐGtÓ† ‘®Èôt™beéR§7b„lÏÊfÏvîÔÁá¼yz,[I‰tõNŸ®/Ƙ>]Z”’«Xccöí¾}eº” ôëWôîÛ'õëêÆ ÝjyæŒg hÌßg.7¯Ÿ8áY^\¬ï’‘á¹­MéÖŽŒÆ×sò•—Ë”-))25{!JÕÇ7QزEZåΟ— píZ¹5Ù ArWgŸ•;WdfÊØ=¥€sçdNº €)SdÎ:ó¸N'ðòË2 ò™3Òå;uªB¡¡Ò‚¶p¡ÜÎÍhíKNf̸ù.ѽ{õëS§d=!AæìÝxõU}—Œ¸8™8úñÇ7ßöì‘Ö¿¹sÈ /ÈsmÛ&ïm?øŸQ£ôk8 s îß/ãÃÃåóæù¿Š˜ˆˆô5ªÊJ Èéòt»u—­§3ðvƒËU÷¹÷š‚Ûå}ƒ>"""¢Û ÇôÝxG¢º(+«ÝÄÆ¡¡@«V""""ª1NÎ|+8¬_\¸¸^d$pÿýÀƒßÿ>Ђ±8ùQU?ìÝ ìß®ÇÀ”)œœù–«¬ví¾ú ø׿€§Óý˜à€ûîîº èÙSR|<%ÑíæêUàÔ)I'OJ‘‘ܸáÿ16’<ü00lðÿ„…1èkpN'ðí·À¡CÀáÃÒ˜•ää~\\œÝ»;JÔÞ¡ƒNwÜØí<¾DDDMEQàp—.I2–sr€ìl ô ý?¾E  sg‰z÷î½è×HNZ¶ô©Î /X””Hêpîœo ÑZ·¤U0.N'ïõèhÏ%9»•›¥¤y?Pª¬”\)ßd<‡÷ºñ!Ò¢â™û[6ò°0IDM…Ë¥ÿOŒÿs^] çHˆç²ÕºñS] åߥ)q»âbI%%zùÆ /Ï:]¿.yn®Ô­N|<Ð¥‹¤Î%ïÚ¸óN G "¢Æ»Ë ¯)…pù²$cùêU9q®]“”› äçë/ðÚ°Ûu%ëv»œPƲw™Í&¿&ÂÂ$7/{çV‚97/[*þ«rï²ÊÊê“Û]÷zn·N.—çºU2¾tŒ/ž@¹y9˜çAuÉ8/ÂÃå|²Ù$÷NVåF™q®šÏÛèh'Ë/ÏàUZêùi,—•I*/ש&ëò¿(ÿoæõ`e|††J2–åÆ.ã+P2ꄆ꼺T—zVŸñÞqMÊŒróß@¹ñÙoþÛ›?›½Ï ó9eNÞeÆùZR"ç^m……ILÛ¶ÒP“ ËíÚI¯]b¢$cÙf«¿S‹A_3TY©MäçKÊËÓËF*(_#F*,”¼¼œÇš¾ˆß`ÐXŽ•ÔºµNþÖëñ·I«¨Ïˆ‚ÉÍËæ²ÂBÌy·~””H2ZɈšªÈHùŒˆ‰‘d,·n ´i#).N/ëññRÇh nèß úȇ˥Aó‡·¿TR¢¹{§ÒRÏ_æÁÞJEÕ·@¿æ­Z üuפ›Ø¼î¯«Ú{½²RÆɺ\žy}ò/¿Ä«K±±Áÿw,)‘^£—ÀXöNÆÃÂÂúý1Ø¢…´ð-½FîÝzåoÙ8G¼‡9XuÁVW¯ªJ·Þ{çüzlÚBCuï€Ý®ôy§ÈHýÃ0PjÕJyM´'A5,·Û³kÆHòe]]²êõ.«IwimƺÁNMÆíÔfìNMºl¬rï`«6y]kìCSPUå:òÄœÊÊ|ËJJôž¢"Ï–póz +ðm6 þ’’€Nd Ž9ïÔI¶ßª÷íp/ÊTQÞÉá`®¬,ðó´l©¿ÜÌ_tÞëFWºÝ.¹U2†˜ƒ»¦tYƒ·"·*«Í?¥šŽõµú,¬î30Poî Ô-m  ÷LÆùd^· Â1Æ úˆˆê¬¨Èw,­y9'8^’Õ@íˆ «î’“^½$OJ ÜõSZ*|eeétö¬u—.ù««ƒÎŽõX"«ÔZ+‰ˆAQP)(Ð`v6ðÍ7À‘#2±ªÕ ðèh™£Ó[µò ò.\ðßí ôéôí+©[7èÅÄðoAÄ AQƒs»ÌL - ؾ]fÖ¯íÇqx80|80~<ðÐC2g# '"}DDDD8/ƒ>""""bÐGDDDD úˆˆˆˆˆA1è#""""}DDDDÄ ˆˆˆˆô1è#""""}DDDDÄ ˆˆˆˆôQ`»v³f5ÞëçäóçÇóoAÄ ˆˆêÝßþôï<ôðÎ;·«W¯½,^Ì¿ Q3ÆC@DÔHÊËŠ 6VÖ{ ¸ç 9¹q÷ë—¿¾ûxöYëíW®íÛóïGÔÄ„(¥Q#xë- gO`Ô(]æt6›¤òòàÛg‡xùeàÝwù÷#jbؽKDÔòó7Þð-‚¸fÑ"i$"}DDÍR}vŠ8ÀĉÀ… ÖÛ"ès»k_gÍšÆkHD úˆˆnY ÷ç?ýúÆIIÀ˜1ÀÇë:iiÀ¯ Œ-éìY)/)¦O—ú£GëîÐìlà¾û€/¿”õùóeûìÙÖûpèððÃ@t40r$•e]ï¿ÿfÌ&L1£F[·úÖÛ³˜2hÓFÖßxèÐ;¨ªŠ‹%°ë×xþyý¸iÓ€§Ÿ–対Òï÷ÿÇë'ê÷Èø¿éÓeÛÏœ>ÍóŠ¨ñ>ÓˆˆÈÒﯠÔÞ½²ž›«TÇŽJ…‡+uø°®WV¦Tb¢Ô=zÔó9ž~ZÊçÌÑu¥}TÊ·n•õë×õc""”²Ù”úüs©·|¹®?dˆï~®Z¥Tt´Þ§ª*¥~ó©?s¦¬+¥Ô¦MJ+å¡¡JmÞ,Ïk³)¢Ô‰J¥¦*Õ©“~¬áòe¥6n”òñãeŸ¥Ün9>áá²mÓ&ßý;xP©–-•ÊÊâ9EÔˆØÒGDäÏ{ïÉÊzB0t¨tÏîÛ§ëEDÝ»[?Ç€žë@b¢ä€´¸%&qqžõ\.àèQ`Ç`Îàƒ€ï}ع8sƳ%pÎà·¿î½WÊBB€åËå"‘U«€¥|Ò$௕åª*™‡oÇéf>pèÕKZþžzÊ÷}´o´n-Ëv»ìsb"*ÇÇh©""¦M“`Ê*ˆ»tÉëÓÔÏÇihèͽvË–@jªçóôè!˹¹º|ùr{—’â»?óæÉòüùº<*J¶…„èò¶me~@C«VµßßÔT 2Rå7<·­Y<÷Ï'"}DDAjÁ`áBY>pxòI`ÃYw¹~Ú¶•üÚ5]öÉ'’ßu—oýAƒ$ÏÉ‘d°Û%è‹Œ´~»½öû– ǧ xûm•4/¸>IDAT]¾k—\˜òàƒ<Ÿˆô±´4`ð``ûv™®¤1[¬ÂÃ%w:%ÏËÓ­jF™Y—.zÙáÐË!!_§ºíþ¤¦J åÊ•@i©”­^ <ó Ï#"}DDAlÝ:à'?‘¿×_:v ®ý‹‰‘ ðíndÜ`T”ä}úÜúýéÔ ˜-ݕÆ#Føn¯¬ô\7ºJ.o·âîaa@ïÞ²œžî»½´T¦Ž8P.HióæɘÁ7ß”Àoüø›#HD úˆˆÄ7ßH~õªgy^žggŒí3Zwîô wï¶qsW®H^\,WÔ’ËV̧qÕì¦M¾1ÞøqžåJI]ïÀÕ`Þ@û¬PTäY§gOy=‡CºÃýÝ¿—ˆô…áÃ¥ulÿ~ ^öî•ñ|Ÿ~*Û¿þX¶ ÈÈucº” ä⊴4éê4ZØvï>û ¸xQÖ)^6o–.ÐåË¥…ìúuŸçrù^k¬›ïä1y2ðÈ#2éóÌ™ºÜí^}UZùÌWy¹ J§NY¿wcüŸù‚ó>gdÈÕ‹……¾ÿÝï$¿ÿ~ o_žKDÁ‚Sù±l™Rññ2ép×®JíÜ©Tv¶Lfܪ•R[¶èº.—Lœ,á”RÝ»+uò¤RëÖÉúàÁR¿¢Bê_¼¨T·nzÛ•+J}ò‰RC‡êç=Z©?Têôi¥fÏV*,LÊ»tQjÅ ýÚN§RÓ¦ÉÉýûˤÊ))JMªTq±®÷ÑGžÏߧRo½¥·WV*µd‰žh:"B©¹s•ºzU×yâ Ù–”¤ÔŽþ]JŠLæLDA#D©ú¼¡$Q3SQ!­sݺé«Zsså¶hVS›dfJkZß¾Òrwþ¼tÝcï̪ª¤û81±þöõÈi)¼ûnß ŸëË•+2}Œ¿¹ óòäýgg7ÜXB"ªƒ>""ª_¯½äçËÝ=ˆˆA5.—ÜîÎ;sçäî ‡II<6DA„rQÝŒ#wiß^º•_xƒ>""jvRRd|_B‚\…å[£”X¾|9455K|ÞåË—ñäÉ^™å!999xúô)‚‚‚„àà`¾Q¾2’““±lÙ2èêêòñcÇŽHMM-Ók&&& ûrVVßÈeˆ¼¼< ^T!žÛÑÑï޽̟?/^ä?f!„……«/ªN›6 ÑÑÑxñâ²³³Ku³ÜÜ\äää Zµj%>7!!µk׮Рíç燓'O–øÜ 6`áÂ…<µò‹Û·ocÉ’%(((Ò[nn.ß0_;wîÄ/¿üÂ+´?0²³³±uëVܺu«HõæÍ›ˆŠŠ‚ššÌÌÌеkW(++ˬ¿yóf\ºt /_¾„,,,øÆ.#Ü¿óæÍòÊgÏž!;;»Ü[;ãââP¥JÀ§OŸPµjÕþ[À××çÎùsçÐÐP´hÑBáyJŒ1–““ƒêÕ«—Z¡Ý¿?ÂÃñiÓ¦'P¯^=$$$T؆5jš7oŽE‹•è<Œ=ÏŸ?—Ëüxð( R÷SÅSd qçÎ4oÞœo»wïÆÕ«WqîÜ9™Çããã1sæLܸqÝ»w‡±±1ÒÓÓqýúuT©R§OŸV8 ²´´Äþýûy…ö+BKK ‰‰‰åZ¡ÐÐÐ@nn.”””о}{¡»ÓŒ>}ú 66}ûöEŸ>}0zôh=z´H…Vµ,nž““Sªé“‚‚‚2ŸÒù–ˆÅ¥K—JåcµaÃÌŸ?ŸWfyð(GðôôDÇŽyeö†@ ÀÆqäȹubbbàïïÈÈH‰™ÉuëÖaÎœ9=z4nܸÁ7&…HNNFõêÕ¡¤¤HJJB­Zµ~øv9{ö¬„nĵOQPåIªôøóÏ?1vìXT¯^½Dç…††ÂßߧOŸæ‘r¦È;vŒoŒgÎœ®®.¬¬¬äÖ©S§Ú·o/åf§¢¢‚M›6¡qãÆxõêš6mÊ7(¹øüù3´µµ%þWd̲Bi }R íÉ“'qðàA¡aÆpppÀü!3piýúõxþü9^¼x¤¤$Œ5J⸒’Œ=zH”?xð{÷î…@ €@ :4h€µk× ÿ¿}û+W®D^^Ú´iƒéÓ§ãÌ™3ðööÆÇ¡©©‰Î;£Gøå—_Š¥TîÛ·ÆÆÆ3f *UªTbBF…Ê•+£[·nrÏÿþ=V®\‰'Ož ::Íš5ƒ –-[&5ŒŒÄš5kŸŸ+++Lœ8Qx,66«V­B^^`õêÕhØ°¡Äùضm›ÐqÏž=¨T©¢££±}ûvܽ{VVV˜5k ¥ž•1†]»váܹs ªª*Œ1jÔ(tîÜÿþû/† "u^~~>6oÞŒëׯ#$$ZZZ033Ãäɓѵk×Ñï† ðÇ(¬Ó¨Q#¹\555˜››#22²Ø ­8€îÝ»cèСRõ"""°víZ!66Íš5C‡°lÙ2™–½û÷ïãÀ`ŒAII cÇŽE§N„Çýüü°sçN@II ÎÎΰ··/ußß»w/|||„ÿ Ë“ÂÇÕÔÔ°jÕ* Ú}üø1¼½½ñìÙ3„††";;ÆÆƘ7oz÷î]¦ÊäâÅ‹‘““#”…RSS±`Á¡{ל9sЪU+™×¹qã†o¥§§ÃÔÔÝ»wÇìÙ³¡ª*Ûf˜’’‚>àÙ³gÐÐÐÀóçÏxûö- aÆBZNæ1Æ0jÔ(ØØØ`óæ͸wïдiSØÚÚ*”%?~ĉ'àçç‡ÐÐPÄÆÆ¢aÆèׯæÏŸ/ôã•…/^`ùòå Dnn.lllðÛo¿¡gÏžX±b¢££¡¡¡M›6Iù_¾|{÷îEHH233ajjŠ^½zaúô鲶LaqF2oÞDŸ>}зo_899!-- ÷îÝC×®]1uêTá¹FFF°³³CTTùóç# OŸ>ÅÊ•+qñâE´iÓ{öì‘©ÄL:3fÌÀ°aÄLzÚ´iغu+zõê…ÌÌL)þÁ¹899áÉ“'PUUÅ AƒÐ©S'ØÚÚâÁƒÈÌÌÄ–-[Š­È¤©££#äQgÎœANNþþûo¡5oÇŽhݺ5zöì)Tü8xyyÁÚÚFFF8~ü8bccqèÐ!Ô¯_íÛ·ÇåË—åÞ·wïÞ¸ví¶lÙ‚W¯^ c.^¼ˆQ£F!44Tæy—/_FÛ¶mÑ°aC}„ƒôÂ8{ö,:uê+++\»v >|8-Z777\¸p7†ƒƒƒD¶'@ggg,Y²ãÆÿÿþ‹ððp¬X±·nÝ‚ >}úT¶Bˆ1Ʋ³³æààÀÒÓÓ™8òòò˜žž»wíÛ·³)S¦°’"77—©©©•èooo¦¢¢ÂYnn®ÔñôôtfnnÎ<<<^§mÛ¶ ÀŽ?^¢gÈÈÈ`õêÕc/_¾,ñ;Ïœ9“-Z´Hadz:HÝ3++K¢¬qãÆìÝ»weæææìéÓ§Âÿùùù,99Y¢ÎºuëØÊ•+%ʶmÛƦOŸ.Q–šš*ÑÆñññLOO•nݺÅôõõÙû÷ïe¿zõ*322bRÇ ØÌ™3™KKK–úô‰YXX°Í›7—øy"""˜†††T`Œ1{{{6`À&„eMš4aýúõ“(kÕª “8w„ LEE…­]»Væ}Ÿ>}ÊjÔ¨!už,¨««Y'==Ë¥ëÏŸ?3vóæMV–˜9s&›6m+((:–ŸŸÏ:vì(E׌1æîîκtéÂ233¥Žåå屡C‡²©S§JSVVfîîîÂÿ111 €Ä·g:::E>ûõë×™¹¹y‰Þ·V­Zlîܹ¬Q£FìÑ£GRß@Ïž=c:::r¿ñ“'O˜žž‹‹‹“I—µjÕb)))2y‘¡¡!»}û¶Ô±ÈÈH¦££#ÁÄqöìY¦¯¯/óºgÎœaÆ “ûî-[¶”{]šššlÞ¼yÌÐÐ(lÆ1b[¶l™Ìkeee±-Z0''')º²±±a›6m’{ž óôô,Ö7upp`G-uxöì³°°`‹/VXÏÂÂBØ&¬yóæÌÅÅEfßaŒ±°† ²¨¨(™ÇïܹÃ7n,ó[¦¤¤°zõêÉ=÷Ó§O¬^½z,11QXÆìúõëçùûû³víÚI0Auuu¶dÉ †Rš÷–‡Ö­[³«W¯*¬3}útæêê*÷ø’%K˜••KNNfoß¾e¦¦¦lß¾}¥~¦f͚ɨØÛÛ³H•V$œœœ¤Ê&L˜ÀÚ¶m+¡øÊb~«V­*…vÓ¦MløðáE2ñV­Z•Ù·|óæ kРÄàB³5j”DYRR«[·®Âþœ’’Â6lÈBBBŠl eee©vÖÔÔTØöÜ·Þ¿MMM$''#&&ÕªUCrr2ÔÔÔäú´%KºwïŽiÓ¦ÉÔo®^½Šëׯ#66ééé¨Y³¦0€Q¤ÜðÄajj*3ˆíÉ“'022’r[* ###øùù¡C‡eò]*d–ƒâ0ÈÊ•+#!!¡ÄŠ‚——š4i‚¶mÛ–XÛ±c‡„C¼"XYYÁ××ÖÖÖ8yò$Œ´´4œ>}Ó¦MS¨ÐrÁtï޽ëW¯péÒ%Œ=‹-Btt4ªW¯.l¥ªª øûûÃÆÆ'OžÄÂ… ±fÍ<~üíÛ·‡¯¯o™ ¿¤¤$‚b š4i¢ðxïÞ½áææ†5jH1ŽÂˆŠŠB×®]Q§N :½zõBÕªU‘””„ððð¯¶hAQ‹ŽT­Z>|(“{%$$àóçψŠŠ*RÉNLL,“"""J%p^½zU¬óš5k†×¯_•oÃ)2¥ P(N4n~~>RRRpéÒ¥"ÓÏ´lÙRf¹““bccŽ§OŸÂ××®®®ˆ‹‹Ã–-[0zôh)~“ššŠºuë~·v-nû¨Éùo–”Ö_¿~´´4…õÚ¶m‹ŒŒ …÷ÿ÷ßKOšššptt,ѪwïÞŪU«àââ+++¹ñiiiÈÉÉÁ™3gŠ¼¦±±±\þ3}út¬[·NbóçŸbĈRJÉæÍ›áááQ¬÷PQQÁ‘#G¤|†çÌ™ƒ¥K—J(´÷ï߇²²2~úé'™×ºÿ>ú÷ï+++ôêÕ „ªª*ËÕ*‰ HNN.Ö‚J…RÃÂÂн{wäåå!55jjj8rä²³³‘››‹æÍ›C]]>>>2chŠÒªU«†?J”edd gÏžøðáÆŽ ;;;ÔªU ©©©xõêÒÓÓe^+##Ca°7—Õ>‰‰‰E¶²²²Ì˜J¡ Bnn®ÜÑ|BBâããŽÆK WWW gíâbß¾}°³³+vÔ«µµµ¹zyyáĉHKKÃÂ… 1mÚ4øúúbÕªU2•¿ääd$%%áÔ©Sèß¿?,--‘››‹°°0„„„ȵ²Z[[ãáÇ011Fš¾zõ ^^^h×®‚‚‚Ê,á³®®.ªU«†Í›7i±.Šz÷îC‡áýû÷°··ÇÍ›7å*i @¿~ý°aéc}úôÁ¾ ;‘e¡jݺu™ÜË 6Äœ9s¾YŸ400PÔ$Í›7‡——W‘õÂÃÃ¥EË/^¼€Ž=úÕÚFUU-Z´À‚ ¤2n”•*U‚¹¹9ÌÍÍ1bÄÀ›7oйsg¨©©aøðá –¶¶6Þ¿/30R¼]å)AßxñâE©h½N:øóÏ?¿èþ7nÄÔ©SQ¹råR¿{÷îÏt8pmÚ´A5àèèˆ;wîÈ€Ô¬Yõë×Ǻuë¾ÈJ9}útÃÅÅ 6DRRöïß/SQœ7oæÍ›÷EmÚµkWÌ™3>>>B˺»»»TöqŽ_¿~B%[–ábãÆåB±°°€ŠŠ Nœ8Qâs[´hØØXÀèѣѽ{w 2»víÂóçÏ‹ b}üøq‘²¦°,™1cªT©"w!§ÿýWæµÌÍÍ 7À111ÑÑÑ2ÛGCC£TíóE貺PQYÊiii)6 cÖ¬Y7nœBkHAAîÝ»'L‘Q\¾|jjj%N“ŸŸ77·-skmm ___<{ö Œ1˜››ÃÆƱ±±ˆŒŒDpp°\áرcG0Ç×Z!Q­i½Ô×ׇ¦¦&®_¿þE÷þüù³Ð‚›˜˜X¬ô‚/^”{_y²äüùópuu•;c"¯?9®®®r]N,X ³ÜÈÈyyyEº”9Šãl½~ýz¶páÂ"£åW) øÐÑÑ‘ì’’ÂRSS¥‚Â:uêÄ:vìȦL™"-›˜˜Èœ™¥¥¥D@•,ôíÛ—`*** 38ˆã§Ÿ~b'Ož,±3ûáÇY×®]K äìì,áè?gÎæììÌÚ·o/÷ÓÕÕ•ùíN:Å7nÌ"""$Ê“““™ªª*{ýúµLµ··g¾JPØÈ‘#™¡¡¡TÀZpp0³´´dsçÎ-M7(bĈlüøñrûdJJ Û¼y³Â€¦¢¢ÂH$ÊÔ)SØСCåb\¾|™™šš²ððp©þÑ®];– 3Š¿G2ƒ]¾4(ìÝ»w¬V­ZìóçÏ¥ |©U«–Ìg–IlllÌ:$·Ndd¤ÌÈpGGG™Y8ôë×M˜0AªüãÇLWWWnPÊž={˜©©©Ì`àÀÀ@¦­­-u,..Ž9880Å “¬&C† a“'O–ðrêÔ)fbbÂbcc¥Wz÷î-—çgee±;w²W¯^É<>þ|6{öìR@°éÓ§³U«VIÉ«âd9 ´°°IIII¬Q£Fìüùór¯ùâÅ ¶mÛ6…÷MOOg 6d¡¡¡¬~ýúRYrÊÙÙÙ¬AƒìÍ›7lÁ‚ì?þ[×ÇLJխ[Wf¶“   fbbòU‚Ââã㙚ššT€Wjj*8p  32˜j IDAT˯¯/ÓÑÑ‘)O8ܺu‹={V¡NñøñcÆc³gÏf[·n-2(ÌÙÙ™²½{÷J:³6mÚ°9sæHghh(“vÒÓÓÙèÑ£™AaŒ1¶téRfaa!‘¡%33“M:•õîÝ›5oÞ\f–ƒ{÷ ²èèh¹ïsýúuvñâŲ »zõ*ŸŸõë×£mÛ¶ptt@É÷ïß»wï"++ nnn=z´TR{{{hjjÂÙÙƒ ‚™™bbbŠ£G‚1™Îö3gÎÄÔ©S1mÚ4888ƒ…._¾ŒÛ·oãàÁƒÂçáP§N;v 3fÌ@³fÍ ­­ @€÷ïßcÒ¤Iؽ{w‘¾L\ð…@ À“'Oйsg…õ`À€%¶\oØ°¡TËãZ[[ãðáÃÖ™Áƒ£cÇŽ˜>}ºÂó.\ˆÙ³g ­Ô&&&ÐÔÔDHHÌÌÌdž§­­jÕª!88X¢Í‡ ‚3fkZV<¨¥(+míÚµáííQ£F¡cÇŽ4hš5k†ÄÄD„……áÂ… ðó󃫫«„uhãÆX½z5ºuë___èëëC__‚7oÞ Q£Fèܹ3V®\)­V¯^“'OÆ Aƒ0nÜ8ØÙÙáÕ«Wxôè<==1iÒ$¼yó{öìžž¦NŠŒŒ ìÛ·ÑÑÑ8rä233Ñ¥Káóœ8qyyyèÖ­›Â2kkkáÈÙÅÅzzzB?§7ÊL¢ŠK—.IÌ~¡… …%zöì)å{éááI“&¡M›6˜?>ÌÌÌP©R%„‡‡Ã××ÄÀúGs>yò@¡Ÿ©««+† †víÚaÁ‚hÕªòòòˆK—.ááÇ8pà€Ô²²#FŒ@TTÌÍͱ`ÁX[[CCCAAAX½z5ììì°téRaýçÏŸãüùópuuEß¾}%ò]»ºº¢OŸ>011QX¶yófŒ9²XV'Ožú:geeÁÝÝ]"÷b•*U0eÊ©vª\¹2Î;‡#FàìÙ³3f Œ‘––†ððpܸqׯ_—xOño|òäIDFFâ·ß~ƒ™™*W®Œ¨¨(:txðàÔyõêÕÃÉ“'1|øpôìÙ}úôAãÆ#GŽ ,, ÞÞÞ2­‹æææhÙ²%FŒ9sæ ==ÿüóŽ=Š#Fàýû÷Ø¿?(¨uìØ1a0Q^^ÜÜÜ ¦¦&<®¥¥…É“'Ëœ=Û¾}; Ìž=fffÈÌÌD`` ¼½½†£GJùþþûï˜3gÌÌÌ°hÑ"´nÝÕªUË/àïï={öÀÞÞ”ºgJJ 8€   R…Æ¡l’—c  œàà`ÄÅÅÉœŠNOOG×®]1`ÀXYY ÝljÔ¨³gÏbäÈ‘8uê† ###|þüááá¸|ù2þý÷_¬Y³Fá³V©RÓ§OG—.]п…î(euuuLš4 S§NEpp°B?ØŽ;¢eË–èׯFŒKKK<}ú>>>ðööÆÒ¥K1uêT¬_¿^Ê’ûòåKœ={V‚WæææbãÆB«¤’’ºuë&DY»vm 0LJ‹‹ TTT„´îèèˆÎ;ãÔ©SPRR’X$ªC‡pssƒ­­-FŽ GGG4jÔH¨ûp~±;wîTh¡åô©„„„b¹ôY[[cÅŠ7nœ0È“%.Œ%K–`æÌ™xþü9œœœÇÃÓÓvvvpttĹsç‘#GJøTÿñÇœꚚš¨^½:âãã1pà@œ={Vn}*VY‡„;vàСC CíÚµ…«‰;vL‚h•”” ªª*ôï*L“ÙÙÙ°µµ…­­­½nÙ²žžžðòò¶mÛиqc´nÝ÷ï߇´´´˜˜(œÞ*((@vv¶Ð§K¼Œ9‘‘‘Sû¿ýö"""dN÷7iÒ·oßF^^BCCQ¯^=… spï"Τ—,Y"1õ¦¤¤$sºLKK ÇÇõë×qöìYìرYYY055…©©)|||d.z"ŽÁƒãÁƒ Á¬Y³Š šªR¥ Ο?oooœ?nnnPQQA“&MУG…àË–-ƒ““öíÛ‡“'O W Ûºu«­síµ…xBð+V ''G¢M–,Y"U–œœŒƒ–8Ð$%%E˜ cþüùRS¡ŠÚ¨yóæðõõÅ„+©U­Z¦¦¦èСÜÝÝe*×sçÎE›6mpíÚ5œ;wnnnÈÍÍ…®®.ºté‚Ý»wËå“666†››ÜÝÝ…+…uêÔ žžžrã”””pæÌ,^¼'NDíÚµaaasçÎÁÜÜ:::øôé“” €xû¸¸¸Wƒä (‹¶¶¶p¥¿ .`ݺuPWWGÓ¦M1tèP :T‚/‰_ÓÃÃ>ÄñãÇqäÈ$%%ÁÄÄfff¸|ù²ÜL;vì@ïÞ½eß“'OÆ–-[P§NtïÞ½H—‰ììlŒ?^ªïçææ •‘² E üýý±{÷n=z¡¡¡¨Y³&LMMÑ¥K8p XÓ£FÂòåËKä÷%˜…––>|ø€ììl)×0Y¼rÑ¢E|X¯hÑŠåË—cÎœ9¨R¥ ,--±oß>têÔ ÇŽ“ËÓ‡Š.]ºÀÃÛ7oÆëׯ¡¯¯SSSÌŸ?¿þú«By[—ÎÕ¨$²dìرÐÕÕÅŽ;pøðaèèèÀÜÜGŽA»vípúôiáªl²ÜGGŒ!40cP¿>m sçÿ_y‡%@TðÛo¢þ¤£lÞ,¿þÒ¥À!€‹Ëƒÿñ(=Nœ Z>øÿR¾e__ÆGŽb«¨ñø"/ðô¤ïýÿå‘‹…ªU)S€o´š[…BA0l°f ðÿeƒ…`²`hÈؾ}¬ÂcÕ*ÆZµªxϽacÕ«3Ц­ÍØìÙŒ={ÆxðࡌݺÅØðጩ«‹úP£FŒy{+>7 €1 ªß­c±±|{þhÈÊbÌÅ…1%%¢ƒÍ›Ëþ±±ÄÓƺta,!o÷ÿ"Þ¾eÌÊŠ¾³ž^É¿óܹtî¡C|[rÈÏ']`ìäI©Ã²ÚC‡¨ÃùøTÜ?ž±Ê•»x±b>ZcÛ·3Ö¼¹H(Œ™š26}: çyçÁ+°ŒíßOJlƒ’ýÅÞž±3gˆOŸ2fnNçV­ÊØÒ¥¼bû# -±]»kÒDdD8uêëÝÏ×—1}}º—c—.ŸFy”odg3vâcuëŠdvXXɯ“—ǘ“]ã×_{÷îÇnW??Æ,,¨=~ÿ]fÙyh.^֮ƌªW—oÎÉ!Ÿ†ÈÌnh4n Ô¬Y:³r|<ðæ  hjŠ¦ ëÕþ¿¨‚Üó<<È=iý®È`  nÜnÞ||¨½9Ô«´j´l ÑÖ°!P« üݤ ;›ž7;[´qÿsrhjW  ½¬ßŒªª¢MMö@µj´U­*Ú+ÿná¹¹äN“–&¹ÏÍ¥¾Çµ׆ÊÊ€ŠŠ¨ ÿVSÔÕ©M54dÿVRú¾Óvqq@l,CÛ«WÀÓ§ä"•ž.ª[³&Ð¥ е+Эõ‰Ò´¯‡°u+ñ S' W/য়€--­oç†Ä}×Ü\Ú €J•èÛTªDü±"€ë÷¹¹ô›1z~ñMo/ë>ôò%ðø1pù2ñ×ôtâ!cÆ‹‘‹Ê×Dr20{6pô(}çúõÉEÆÙ™x:Š%§>N’’ˆoNšD:TåÊ¥—¡‹nnć~ú øùgÀÊ ¨[—6 êW™™¤ÿ|ø¼OúX\ù™ÆÅ©©T'3¨QC䆥«K×ýé'ꃥEj*ð÷ßÀ£G"]ðãG + ¨R…¶5Hgá6Ѧ­Mí¤®N2-.ŽÞãömàÒ% (ˆúç®]ÔOd@þ ÙÙÀÈ‘ôqªTlmI8T«&j0nŸ”$ÿ%-,€qãè)Åðù3ÄîÝä-ó‰•HQkÐ@ÔõëÓ3DEwﳜ6 pwÿï)8™™ÀýûäL[D ¹ÂPQj×&¢¯]›ˆ¡jUq‰+Š**Ô)ù'²²h“õ›ÛsÊê·FDµk‹¶:uHÁ×Ó£­aCêLå‰6£ÎÏ)m±±À»wÄŒâã%·¬¬oÿ|•*‰”ÜÊ•¥÷…«©MÉÛ8ZãïÜ\ #ƒ6NIÿô‰6yüEC03ÌÍiëÐh۶쾫@x{‡Sow]]Rl[´ þÃõ-n`U©)¡â[v61}Y7( ¤§¯©©‰h½^=@_ŸxµÅ˜™Q[}múŒž=#CDd$í?|hûÿ*C ¡¬L¼I¼-Å÷ZZÒ[•*ÔܦªJÏS¸-?&¹¼~-ò_UV¦¸‘Áƒ‹6Þ| ÄÄÂrè’BeÚÚd¤03£Íؘx7ˆ¯VúYaË̤kÞÒÒDt&þ;+K4ÀàL)êêtN†Ô­KÆ’Æi30 ¾ü- #QQôÍ^½¢öâøbb¢HÞää~À ô¸AŸ¦¦ˆvÄÛOK‹¾uáã_ܦ¢Bíʵ]Zñ¤°0Ps[Z=o:À„ S·nÙ´ÁÓ§¤Ø^¹òõÚ¹JÀÎøõWÒýTU‹7(Û·…>>Dƒ_jjÀرÀï¿“ƒ¢W ;p€F¯_ÙU«FQ{C†È>¾u+Š¿TX·l ¬ZôíûãŒ33I<{F>2R´%$ð£gyÄо±1í9áÿ5­oïß/^Hn/_’ËG´ÊVp4ÍøFF¤ÀÊõ±[·ÈRðà 3YƒÈòj3KK2LØÙÍš}Ù5?þù‡¶'Oh`šZqèJ_èØèÑèÙ³ì/µß¾ œ= \¸@ÜòŒÊ•É’la´oO3#}ùu##É0åçmeg—zêÓè×fs¾_zù’t2//š=úZhÖŒô¾äóCwwÀÕõë­››S`¦³s±úhñ–¾-( NææFšŠNÑÒ"ë·U¯N#õ€æS¦[¶ˆ¦–’’€Ñ£óç‰(,,hŸ˜Hõß½£=7ú‘'ôìì€ùó‰Añ!=Dt41Hnã\D>~¤‘nZÚ÷ÐÊÊ"KŸ¼;^©’´÷[YYdýhÔ˜šJ/9™hîãGÙQI 01!aÇmff¥›rOH é—'Oˆ9ûùI¥Þ“³‚Ô¬I–˜5È*%nEçÞKÜ­@üwa×q«yáí{¯x­ªJ¼¡n]Iw"ñŒÄ ÔÕËg¿  )ë4/^¢÷-­æœ¥Ž³¨©«“0MKÑ»¸‹‡† Aƒ(Z¸M›âÝïùsàôià̲¦!íV¯NtÍYÎ8Úä¬‚ß šš$œŒ¨_·kGÊWyP`‹Âë×4ýàÑÙóç4ƒQžadDgg’åÅAApçÍß¼Iòª0(Žsagq_gñíkO/$&wIH þÅMër{IßQέC|z”›VŸ&å~—çegÓ3„„·q®J¦¦À‚¤ÜžfÌÏ'áææF¾ü\°° znÝš¬(ººDãÅ@ ›Ïˆ»_p¿¹)qq?â¼<Oᦗ¹©ñ:uDç^ô=ý¿ËŒÑLNx8)0>ˆÜr>}јx|ç/î§,>Ý^x_Ø­ƒë«œ?½º:)"II´%'?}J÷€‘¡ eK`æLùÓן>‘qëÐ!âÁémÚÐÖ²%}Çš5Eç/Ê ’²²$é¥ð–’"¹çä™ø–—'j'nÓÒ¹YÔ­K|ÚؘE üúÀ¿ÿ’»¨ª* 8êÔ!¬!Ch¦gçN iÓrõÈ%Wh¿ÑÑ€ƒ¹<~LÌò￉ñàQ^—GJ­¯/)§·nó¬T‰|Œ&Nìí©î³gÀþýÀ±c"Úµi¶ [7² ýk<*ââÈúâéItn`@Óˆ¿üBǽ¼È ,:šñcþýIÑàÁC‘eù¯¿(x'*Šîk×ŠÜ SSÉr×.â©FFÄOý•êò(?ÈÌÆ'7iùÿññ…r8Püö -@Ìó—_hÔôò%™™yð(ÏÈΦWWšZˆki‘e‚ƒƒ%ÃvtäXwï’Âúæ Í %%Q俦&YgÇŽýö³<*6 (XhÙ2òƒ4ˆ¶Ù³ÉÒüÓOÀŠÄ3ÿ+Vôÿ"ÒÓÉG–Ù»wËí£~…ù1]ºÄ Š€òž=’åêêÀöíäÀ΃GEDJ ùŒsf*W¦iGKK¾mx”II¤´Iü/_þïºý×pç¹ÓõíKÁÓ¼B˃<Ê5>~¤ib€‚E¾4¹bíß/ò¹Ÿ ?NÊÆŽÀÍ›€‰ 0z4ТÕýçàäIš2ûùg`üxÙÏvÿ>]34”,`½zƒóSÞÁÑhYàý{¢uqwa/Qý6Ï™Ÿ¯ø^ܳ)+‹þ„…ñ´ð£"/8hÞ03bbèÕª@ä“WiiÀÅ‹$êÖÚ¶%«¢"¢Wwwò€à`àógr'kÚTš–óòȯ6$„dAëÖüwù/C ÑÊ·àãt¼¬x}y³g´¯VíËÞ½$²°¬äÑ÷üÖiiä¦Q8xŽq0€±I“KJb,:š±ùóóõeز…1ssÆ<`ìógÆV¬ zC‡JÖ[´ˆÊwì`léRÆ:vdÌÞž1eeÆ´´ûðA²~BcNNtß—/»z•1Æ*UbìÔ)ªsñ"cíÛÓuƳµe¬woÆêק2ÆÒÒÛ»—1SSº'Wï^&Æ~ù…±{÷ b¬Gª;v,ãQ‘šJ´Õº5cÖÖŒ2Ö¿?cÏž‰êìÝËØàÁŒuïÎد¿ŠÊÃÃ>œÊ»wgìß©üúuÆêÔщ£#çèÅÏOTÎcGÒý«WglØ0Æ23¥Ÿ³ €1OOÆFŒ š21¡çô󓬗›ËØéÓtmGGÆ22ˆö´µûýwªËØòåŒ5hÀØÙ³Tǘè™ÍÌè™Û¿ŸîɽçĉŒ½z%ºç£Gô\ܱ¼<ž®*>~$ÞU¯}ÿãÇ;rDDcµj_Ç;ŒÕ®ÍØÌ™Œ]»ÆظqTwð`¢YÆ»{—è‚ëC†Ðÿýûéøû÷TnbBòÂÎŽx:w_ooþûüpú4Éd++¢™¾}[¿ž±&Mèøë׌͙#â5§O‹Îusc¬gO*Ÿ0AúÚ™™ŒÍKò[[›±Æ[²„±œQW¯[°€èÐLJ俙Éõ£GëÕKÄã†'„Û7ŒMž,:öþ}ùjÛ èÙêÖ¥>Ó®è]rs©m.¤ã÷ï3vù2c-[2Ö¢c‘‘t·o3†±¶mI™˜ÿ—}Ï“'é[ŽIíݵ+c^^¤k]»ÆXT”ˆG B:'/ìì«\™ô©Û·©<;›±330 çœ;Wö}ÓÓ›5‹¾uD?+VHÊ/ˆ–´µ !™7r$ýoÙ’±sçDuýýIîsüÆƆÚmõj!aTQ\ ›šJ*´7o2¦¤ÄX@€¨,;›; RÄZ33j,sçR¹‹‹äKC„'Ž›7©®¶6c‰‰¢ûU®Lå#GŠ㌠Æ:w½à΢ëܸAåúú’×?{–:‹x'JK£Î 0váÏÔÊìí‰RSEÄ 0Ö°!};¡¡T^­š´¢ibBÇÎœ)É>ˆE¯_Óîâ íš5DwnnŒYZRùÒ¥Ò÷8î“œLe))Ô¡54Hñàðûï4@ëÒ…±yóˆQŒ5mJŠúÔ©4°D mn.=ã„ T¾y3ýÿô‰Žÿù§¨ÃËbæ®®Äe)ã<Ê?RRÈð`aAßxêTB·o3¶nõŽçee‰è²~}R‚9å•1Æ5’æߌ‰Œ/^H–s ­ŽÝóéS*?žäƒÿ}*2T·kGJ§€þú«h $ŽÁƒ©ÜÕU²üÔ)*oÑBÚxefÆØ$MŒrÐWIDAT{³³‰§dœbŒØ ˆž8cTß¾’¸ë×EÇoÜ~«Wi õî]ùFF2Ö­=ÿ‰ô?2’sñwß³‡Þ“OG’\iܘ±6mD}ÙÓ“Žÿô“ôýV®¤cœá'-äÇ#:vdìàAÆöí£A §wýõü¶l!À˜®.ñ€þýI ?Ÿ±ªUéØöíÒïijJ2/7—¾õСT·ªsÿ>Ñ›ø€¸[7Æ/f¬O*«^]D‹$ë8þt÷.ýOJú¿BË ìáÃé†þú‹±À@ÑccºHa>LÄÎiøâ í¶m’uÏ)£âʇ²2¸)RJ +—܇‹“¼öš5²­«)**Œåç‹Ê›5# …ø=##EnÜ8ž¹•'DEÑw±·—,çFkAA’J¥’’´B˘ˆyr -]]*OO—,çú‡¶6”9ÄĈ:¸8¶m£réçWS#åTÜbzé’HùæF¢aa¤°pppTh9ÌžMåH+Õ\‡—50ëÝ[ú£GÓ75Šø‡—/‰ß‰óàÜ\ƪTa¬S'Ék .ª%Qhuu¥ûŠŽãJÛ¶1¦®NV2q<.[¡]µJ¶BËñÇ í”)d½GNÝ ~È38:’ìÎÊ"ˆ£uŽþ׬‘~âå}ûÒóß¹#}¬m[:æà@ÖLîÝóóÉZ …T|«¢Bº”¸õóõk*72’m0=Z²üÃ*WW'WÜ÷°³“”OœÑ°sgÉúcÇÒ;Š##ƒ1UUª󦨼qc/ã጑B 0vèäu¸Êa9HXZ’ÔÑ£@` °q#EU÷ï/òMøðVý>\ÚŸaÄÚd¡°F:´•ùù‘ïÄ­[ÀÇ’õgΔvšÖÔ¤}a? ##‘Ÿ†8”•† W¯(1}íÚäA9F·l‘¬ß®mÆƼ¿TyBÆ”ö×_%ËÛ´!ÀssmÈóÃ)­ÿ—¥%г§è¿žÈ$$HúmÜH4gi)y¾¾>=ÿáÃyð •kiÑÞÌ èÓ‡~›˜Hž[ÒÈr%%J9Ö»7-tÒ»·èØ»wÔÏNžäiª¢ƒ ÐêÖMä[ ÍšýúQÜ“'T¦¦F>{âÁ&OŸÑÑô»¤‹vhiILÖ©Cý0>žx+Š…ÏŸ)Eà/¿¿‡¡aÉø©¬òøxZ˜côhé´T5kRúÁ‡)ŽEÜ·táBºžŠ Щ“èœ%KˆŸîÞ ÌŸ/ŠãÉϧëWä…8¹°p!éQªª¢woÓ†äàС’õ›6%=-.N”9áñcò{.,Z¶¤ý¥K¤qüƒ“5UªPl”8¬¬(­W/ÉþÍÉݘɸ”ƒ)¯náo]£É͇Éï^ü[Ï›'xÚªpá‚äµå@U¨ð]¹Bé"BCIh[YGŽMšPÍðpQÀ—€c€¢²ˆÚO™R¼€yHYY±€Wv_½¢½­- ~å**È9_¹BA„QYnî·¦:u(€1-:dp0u<}}ÙÑà:~üXTV¹²ä@M¸:%A¯^Ä´nÞ¤6êÐÊ÷í£ii®É£â CRh9^Ç)%ùù”êíøqR| )0¶,À)Ë))|ûWD©©²S–E Ø‹¤\éèHGöïÜ)ø—76i œ8A²`Ü8*?žŒœ‘«"BÑ»ëèP ;@‹YyygÎ"[XOÓÓ£}á\åœ.”Ÿ/©;)’ HžË¡vmÚ§¦ŠÊÂÃIN7h ý­÷î•$ÉûÆœâ\ ž"z‹víÈ:;o>$þömÑèž#Ȳ½ý5®-Á·¿'²ÁÎ$¬££ihoÿýž¥R%IešË‰—“#»>Ǭ?|l)Bi"|•”€Å‹é÷êÕ"ºß·˜4‰§£ÿ:8¥D[[Töö-`aAÂïÈ`Ãɘ_ŠÂ† œ<”uÿ¥xóF¤dõí+{³°ÓPŠ‘Ytñb¢»õëEr}÷nZ¤"£(žŸ—GÆ8;;2žœ9#{ Ò¡e3ñõ•Tj9ÝnÀ€/—5Š¾µ¾¾üoÍYv}ë<]áý{2ÿjhÐti@YhSSE‚°Y3ÚQz–ÂHO'æXpV`y‰„ÃÂÈä\–àîù×_²MÙyy€›ÏàÊ ˆImØ@#Ò©SË_’wÎ¥æÓ'sG­Z´oÓæÛ<Ï ADë—.Qß½t‰¬¼;ÍÜ!œûJ\`mMS»'Nð‹ßð7súîÝ×¹>§(ûû˯SÒ™¶–-i6êõk¢ëׯIgàÜ·þ‹HO§w¾}›f*–Ÿ6UU•\/êÔ¡6¹}›fí\]é…].Ëó·.–Bûò%ùÏŠÈ¥K¤àrÓ¹õë“ÌžMK¶‰céRÉ‘UIFèÖÖ4ñè‘HWbÆŽ•tE(‹Ñݺ$Ôsrèúâ¦rX·ŽŸ’-o8v ص‹rsq¦ MMê0ùù²¯W˜†Ë¦¦Ä@ dOãr¾ãâ~`_**À‚ô{Íj?Þ:ûßCaþ`€®]iá¹ÇXYɾ†¬ ¿ÿðøï¡qcÚß»';'·,prR|…EqˆÏVq|ÛÓSä»-ŽçÏIÑ*)\\h¿v-ÍàSö9TËV­"¥tñb Ê2þˆÃÀ€rÿOšܽK¾ó[·’ž§ÈÕíKд)í÷î%£ia<{Væ«¡‰l¼›6Ijik“ïçwˆ4ù¿ÿh•nú7,LäÜ ˆe’“%ïÈùv$&ŠÊLLD‹,[F›7Ó²‹ä!î€Ì+Œˆ–hLO—~SY÷åóï¿Éb¶|9}d''²ÜŽÃ3¸ò„  Úú$Yþù³¤àåöººÄL¹AGOŸJÒ Îç•»>ç³Ã zY žS¢¹:5k#GŠ˜¶¬wPV¦é–Â×PäŸÎÝ»°ÒQø™³²¤¯3r$ù19Cï.~oÿ p ÚÅ•Ó£G)‚ãËœÛÙ³¢Á\p0ùrý!2Rä6Ã-ÊÀÍÈqõ¸dæ…û8}ÊâÁ<Ê?:v$žòü9àá!y,0Pö9\ðؽ{’åwïÒ^<^¦E ÚrrÈZ%)¿ÇŽ„‰ó½¢bw¬¬(&<œž{„ŠÑÞ\?,¬'%dÉÂÜ\Q¿ËÏÉAƨMíì(oÕ*`î\ sç’Éñg’7Ø?ÇÜœfö³²(È06Vt,#ƒüþYZG+|my÷äRœßpJÊÿV¸sG”†eùrÊ=»`å'{ýZ2U¾}¢ôÜÖ©“(™oV¥âR µmK¹ss{òD”ƒL]±cÇ(17—í·ß$¯Ëå*ãRÀ|üÈØ®]¢c3fPÄü|ÆnÝ¢ük\~Ä (WÛÛ·Œ¹»‹rºM™BéG8xxH¿‘¥MâQ¾pë}Ÿ5(åÔÍ›Œõë'Êã:q"¥iár¿rù{ô t''O26h(ÏkïÞD'\âîÝ©|Ö,Ê…Ç¥,ñö¦òV­¤Scq‰±ƒƒEåoßR.N%%JEÇáÓ'Æôô¤P_¿Nר__2?¨88ÚÞµK²|ÿ~Q?»~RÕˆ§¦ã°i“윹<*6&OñS//â¿ÙÙ´pBóæ”`žCV–(g¸Ž¥¿1‚±EiéÆŒ¥üٰʵ´(!»Ñ–»;•Wª$™Ò+6–R:” W-ó(ßpqÉÂß~#^»d åÈ–•¶+<œÒBUªÄØîÝ”ˆÎâ5€(%'·¨ —Ï 4rŽŽ”ÆKCƒ±iÓd§ŽÛ½»èçæøhŸ>§­[¶¤g^¹Rú˜•Ï©Ïaóf:Ö¤ É°¿þ¢ü±úúT¾v-É1Æ(­'7ûö¥>>s&}Ÿ ¤ÏâÒ­”bKÜ:‹K–''‹ÎOÙwù²è[W«Fùeœˆ_–ƒ5kR=ná†Â²kØ0Éò‰E ¿\¹ÂØÆÿÏCûî ü›7IÁsq¡$½òr ¾zE‚uŠʇ&θÒÓIA.¼eeQâîÂå…sÉÞ¿O/°zµt²äèhéó?&,랟>1!]Î%Ÿ½{é?.™ ŸGù@@9d54D ¤ß¼!E eQ<íÛ·¢@)5•:´š-~pë–¨þ;Ä`+Uåõtw§w h`ö÷ßt¾ø N·ýþ;õ›Gè·ø1ñDxTäç‹€xÏ¢ET.K¡eŒ¾7Ç£*W¦ßïÞÑÿƉïq‹¾pyK¹|ò)=³g“á‹12Œ!:^»6é%…¬Â00\È©¼âÊ2®pïW£/_¦Åœÿ×Þù³4 EQü&Š¤JKÝ\]DTtr,8¸¸ N®âR:‰ø%ÄOàà(*.‚³þ ÖA(µ‚­¥…Vu8\_’F±ú¢6½?(…¶–˜¤y/ïž{Ž;ñoeÅý{¾¿ÇM€ibßÍÏc,X[Ãߌc âãé·Xè|ÌΪíJ$ÔëssL¹»Ãöq€B?nrŠE$ÄqH—ÓWwßÄiHAãçtIµüþØÆÝjç/Y¶Ï£tï™&©jµºQ¯K;ªÐb”J(Y9sês9”Õ½’¯¯ðáŒF•EÈÙ4áñ¸ èñÑÝþ*”êz{¡A÷³òÒA>¯,UüØÝ…–‰ËÆB8XZ‚ìkkËíI)?¥P€”ptvl¶ ]êÀ@£Ü?uùžeáZz|L4=íß©nÛÊ3udD5Ì~—›È3}úÿÛ[h`:ÚlÖ-Ñ|~†%ëê*dx¥7³YÈ/ ³ Û†Œ¥PÀ±Ö5¾¾¼à‰Åˆˆ}h¡•ðû1xMÀÓ$šœt¿ö™×qw·ÞIg_´KAóÙd–ú÷TJÎA¾F4 ]j3Ÿg—¾–~¤Ó$BÃ*kju°¾Ž^œv™Ìù[îyM’ILø¸©?ilªÎç›Vi†Ž4L릳ó}2Käl !<”ËJ„¿½»ñ™Ù/aƒ³‚pì'\Ìý/Eݧ'rqË®Viû-./‰66ÜÍw^®¯áQû—~îºæ·rÄ!dÔj0.¯Vñ\,Ââ¥V.ÚÛV Žçç²?„`a7™reì|O‹©)LdãqlÛæfc"U»34ßñ¸E-,@z‰ üz 7ŠøRË ­ „ ËByÉ0p1ÛÛ N%ü ''(%Ö­RFŽ'‚ “£#¤ˆ¡/ayY_\òw™˜Àóà #å8yéé-i*…Š]2 ÛÆD©]]D‡‡ÈoT[f´$½LIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/mailto_uri.png000066400000000000000000000237541240331347200256710ustar00rootroot00000000000000‰PNG  IHDR„@³ÅsRGB®ÎébKGDÿÿÿ ½§“ pHYs × ×B(›xtIMEÚ {  IDATxÚíw\TÇúÿ?tC‘"@¬À‚ *bC-AQQc¬bŒŠh4¹5±ÆÄ£WÅ5±%ñ›ëU”h®ÆXÀNAT@ªH])Ëîóûc~g—u EˆçýzÍëì™™SvÚ3ó<3gtˆˆðpá¼÷Þ{8vì:uêTküóçÏ#++K~Þ±cGxyyáŸLdd$þýïãæÍ›~ï‹/"==##£W6âãã4h¬­­_šw»qã¶lÙ‚[·n¡cÇŽ˜ùä“&é0½6ÐKÂõë×iäÈ‘”––Vïk·lÙBáááuŽ¿`ÁúþûïéUãèÑ£4nܸ&}† åååÑ?úóÏ?_Šw)(( [[[JJJRòÏÈÈ víÚ‘T*%ÎóD'Nœà Ñ@^š‚——Ž;''§&–T*…T*}å„÷˜1cpèÐ!Þ‹yùâ‹/ðî»ïª¨Cáéé‰+W®ðDâ¼|*£ÂÂB”––*ù¡¼¼¼N7,**BZZÚ+ÙàÖ‡‡¢¸¸ø•x׬¬,<~ü¸A×fffª”‡ºðôéSdffþ­ê´†ªº>|Ø ksrr››[§¸QQQ˜2eŠÚ0$&&Öe4û÷ï7(?ŠD"AJJ Äbq¯)--Å“'O”üÊÊÊê•Æ?FQQÑßö?³³³ëœ—EII ÒÒÒ “Éê­&»ÿ>êcþ}ôè‘J›œ­z#FH$¢7ÒĉÉ‚ÌÍÍiùòåTQQA“&M" ²··§µkתf:tˆ‚‚‚¨M›6dnnNvvvdddDsæÌ¡’’Ó„„òññ!‘H$w·oßn2•Ñ AƒH$‘µµ5988(=W$Q·nÝ´ª hÊ”)Ô¢E j×®YZZ’³³3EFFÖé=óóóiúôé4`ÀŠŠŠÒ÷ĉäåå¥òŽ‚«ªªÒz½X,¦yóæ‘­­-9::’ 9::Òš5k¨ººZ«Ê(77—Ö¯_OdooO†††äå奢î $‘HD‘‘‘”˜˜H½zõ¢æÍ›“­­-µiÓ†Ö¯_ß$ÃÛªª*ZµjuïÞìííÉÞÞž|||hçεªŒ?~L“&M"KKKy^º¸¸ÐŽ;´>³´´”æÍ›GvvväèèHÔ²eK #±X¬ö™LF¦¦¦ôôéS¹_yy9­_¿ž‚‚‚¨eË–ZŸ›––Fòw´²²"Ú²e‹ÆrÖ£Gòôô$OOO “‡åä䯯¯¼-X°@åú¸¸8š={6‰D"211!'''ÒÕÕ%º~ýºJü©S§’H$¢U«VÑìÙ³ÉÌÌŒ,--éƒ> ©TJaaadnnN­ZµRz^zz:uïÞD"Íš5‹d2­\¹’:wîLöööÔªU+òöö¦¥K—jLÛçQ•””PXX˜R^ÚÙÙѼyóêü¼ú"“ÉhóæÍò|lß¾=YXXаaÃ(11‘ƯñÚC‡Q§NÈÜÜœœÉÜÜœFM™™™JñîÞ½+oWûí7òôô$[[[²²²¢èèhJKK#///²±±¡:ÐéÓ§å×"++‹Þÿ}ÒÓÓ£wÞy‡ÊËË)''‡Z·nMîîîBOŸ>¥œœrrr¢ŒŒ •]±b8p€’““I&“Éûwß}—F­ñJ¥RJMM¥¤¤$JJJ"‘HD—.]j2™™IIII4eÊZ¼x±ü¹‚»{÷.I$µ×&&&’££#-]ºTIÈÅÅÅQŸ>}hôèÑòÿ®‰/¿ü’rvv®µ±KNNVyǤ¤$200 ÊÊJ×æää««+½ÿþûôøñc¹ÿýû÷iÔ¨QäççGåååÂàÁƒiäÈ‘t÷î]y³mÛ6²µµ¥œœ•k²³³)<<œüýýÉÆƆ:D•••$•JéÌ™3raјH$  áÇӃäþ)))@Ë–-Ó(âããÉÁÁ–/_N¥¥¥rÿÛ·o“¿¿?;Vm^>zôˆœœœ(<<œòóó•àððpêСƒÚôê“À“'O¨C‡4eÊ:yò$?^£@8uê988ЦM›”ò<>>ž†J#GŽTû®W¯^%'''Z¶l(…%%%‘——͘1CéüòË/´qãFºté’\ˆåççÓÎ;ÉÚÚZ¥ÊËË£O?ý”ôôôhðàÁTZZJ………äááAîîîHÅÅÅTXXHžžžJBåÞ½{´cÇêÝ»7Qpp0¥§§+ ÷ß~›<<<”òêy‚`»Y°`RÉËË£°°0êرc£ÛÒ¤R)½ùæ›4bÄ%[©D"¡={öÐo¼AšÌº3gÎ$‘HD±±±òü.++£õëד½½=]¼xQI褦¦R§NÈÀÀ€"##I&“Qtt4YYY‘££#íÝ»—d29s†¼¼¼ˆhñâÅ4hÐ ¥^gxx8õïß_©üè£èË/¿¬—!ÍÜÜœŠŠŠê¿gÏžM*æÍ›Gß~ûm½z¢^^^´oß>RèС¡õ>QQQ¤££C(88¸ÁËÐÐP«@1b­^½Zcxhh¨R¯ñY0vìXµ‚qØ°aö5kÖ™™;wN%ì×_%OOÏF­\«V­¢ÀÀ@ù1`ÀÒÓÓS•••$‰èÇÔXi¬R>d2™Zÿš|ýõפ¶ñiß¾½ü|öìÙ4jÔ(¥su!//œ5Ö ©TJ´qãF .]ºÈGLÂÈqРA4oÞ¼Z;0ꦭ[·ªøoܸ‘¼¼¼¨¬¬L©äîî®ä÷õ×_«ÔÕS§Nš6mšÆçŽ;–-ZÔ(A&“Q@@€Ö‰%_~ù%;¶QËlDD„Ö{~ûí·jÂþýû©[·nTQQ¡öº3g΋‹‹Š6F$Ѻuë”ü:vìHkÖ¬Qòëܹ3ÅÅÅ)•``` W%YZZ¢oß¾Ð××—û™™™ÕK—Ø¢E ´jÕ ………¯´½à矆ƒƒ&Mš¤6\GG»víªU«´ê‡ ‚»wï"::l’w½té233±xñbq6lØ€C‡!//OmøæÍ›•ò]`Ô¨Qˆ‰‰Ñxßùóç£oß¾*þˆGuuu£ýÏ£GbË–-ócÛ¶mjíXGŽA»víðÎ;ï¨7ªéêb÷îÝX±b…R^^»v ÙÙÙ˜7ožÆwú補œŒ¸¸¸ZóhÁ‚µþÇ={ö`øðáèÙ³§Æwݺu+V¯^­Ñ6ñÇàûï¿ÇæÍ›QRR‚!C†À××ß~û-tttêîîîî(((PæïïSSS¥6¤gÏžJ~šÚ|÷ÝwŸ»yóf?~¼QÊNLL 0gÎq>þøcÄÅÅÕɶSŸ‰ß|óÆð°°0µåbéҥػw¯ÆµAèß¿?víÚ¥6tèP¥s 8Pɯfžè7ÆMOOÇ_|+W® ##ÕÕÕ°¶¶†‹‹‹Òâ±W•k×®aÀ€Zã´jÕ ŽŽŽ¸sçºté¢1^ûöíѾ}û&}×~ýúAWWó2SSSøøøàúõë*FhPÕ¡¯¯¯Uàéééil¸tttêe«Í˜[UU{{{q\]]Õ.NªK^:88ÀÎÎ)))èر# 66FFFø׿þ¥õÚfÍš!11îîîãØÛÛãܹsèÓ§Ö{ÅÆÆB*•ÖúL"B^^lmmUÂlmmqöìY :ëׯÇÌ™3µv ²²‘‘‘8tè222PXX333´mÛ%%%…éóеkW˜™™i ·µµ…D"AFFZ·ný\ÏŠ…¡¡a­éjjjŠÄÄD­õ¹®K~~>¼½½ëœ—‚@Éd011Öë&MšWWW•Þ¯D"‘Ÿ¯X±C† AJJ FŒ””µÓ­e2,,,j}æ’%K´†WUU¡¼¼µÎŒ+..Fß¾}Ѻuk|þùçèÒ¥ lll ‹‘žžŽµk×6IžÖecEEEƒF5êÒµ.y9yòd¸¸¸4ÊÿËÊʪS½TW^ë²Ò¾±êós "„ ðÕW_!$$DE¢ÛÚÚj•ú¯ žžžòO!h#>>/ü]ë²V!..óçÏ%óÃËË ZãH$$''«ø‹D¢:åeBB‚R^zzzbûöí¯÷ûÚØØ ??2™ ºººèÖ­bbb°mÛ69r†††òφ<›— z¦@ff&Œ `âĉ DXX¾ûî;µë²eË`cc£¢ž±°°€……ºvíÚ$yz÷î]¤§§£M›6Ã+++áèèØ(udï޽ϕ®õ¥sçÎ R?¹ººâÑ£G¨¬¬Ôú9™¸¸8xzz>÷{>×´‡BWWÓ¦MÓØ[}ízzzJß>©aÆáÀÈÎÎÖgÇŽpssƒ¥¥¥Æ8ÕÕÕ8pàV¯^G5ÉëÛ·/.\¸ µÑ;uêÄbq“Uî†òôéSlݺ*óØŸU]yzzªÕ™ lÚ´ UUU*þÇǾ}û““£ñÚmÛ¶ÁËËK©3ããã‰D‚ÿþ÷¿õ¯dºº°³³CZZšÜÏÉÉ ë֭Ñ#GðŸÿüG­þ<88G­Uøi"--  À’%K SSSü÷¿ÿEZZBCCÕªÿ®^½ªQ•"“É’’Ò$y¯££ƒ3f¨µ3UUU!$$Ÿþy£<Ë××OŸ>m˵k×°dÉœ?^kL:Umù:»sæÌÁÏ?ÿ¬ñ>EEEèÛ·/¾øâ 0@c ìܹ ,À… Ô†ïÛ·"‘He´¸iÓ&lß¾{öìQ+@&NœˆQ£FÁÏÏïùUFÓ¦Mßþ ===<|øP©Ð8pYYYؾ}»Z?lݺ#GŽÄÀáïïÔÔT\¾|ÅÅÅ8|ø0fÎœ‰©S§ÂÊÊ @³fÍ0#Ëܹs•t«III˜?>ÌÍÍå~o¾ù¦Šå}öìÙJR4##b±X©lÞ¼9~úé'¥™Sï¾û."##áãメC‡¢mÛ¶xðà®]»†„„,\¸Påš… BOO¾¾¾=z4ÜÝÝQXXˆ .àþýûøí·ßjýìFÍ«ºÞkc1nÜ8TUUaàÀ1b<==QYY‰˜˜\¾|;w¯¯Ò5Û·oÇÏ?ÿŒââbŒ?þþþX¹r¥¼çþî»ï"55………1bV¯^-WÝÌž=wîÜ!&&›6mBÛ¶m°¯Ò®[·ÕÕÕxûí·±hÑ"•Y I‘H„}ûö!88ƒ BÏž=!“Éð×_!%%ÑÑÑ?~<>úè#ØÙÙaË–-r#ô¢E‹ §§‡îÝ»c̘1pssCaa!þüóO<|øÇ—¿Mºuë†ß~û ¡¡¡hÓ¦ üüüЪU+¤¦¦"..—.]ÂüùóñÖ[o©\;wî\øøø`ôèÑ*777666j'Ì;fffèÓ§† www˜˜˜ )) 111ÈÍÍÅš5k”ÊÞ† °víZèëëc×®]HMM•ÛŠŠŠ0mÚ4ˆÅbœ={IIIØ¿¿ÜpºzõjôéÓ·oßÆ°aÃP]]+W®àêÕ«GïÞ½±gÏ\¸p‹-€ðÑGáäÉ“‹ÅÈÍÍÅÁƒåꨓ'Obܸq8xð üÿ©óÓÕÕźuëàííÈÈH„„„ ººX¹r%‚‚‚Ôj BCC•Fû7nÜ@zzºÒˆ«W¯^øì³Ï”®õññÁ±cÇŠvíÚÁÏÏvvvJy¹`Á >\ëˆ_˜ÉFDJm™&UÕîÝ»1yòdtëÖ =zô€¹¹9péÒ%À?ü 2éÁÚÚÑÑј2e 8€þýûÃÖÖ 8zô(f̘eË–Éãß¿aaaHKKÇ~ˆ̘1CŽiÓ¦aæÌ™*~:·nÝ"axnmm-·f?|ø÷ï߇•••Ü ªÎRRRpôèQdffÂÙÙ"‘ýû÷‡¾¾>bcc!‹abb¢ÔI$ÄÄÄÔšˆÎÎÎ*zÅÄÄÄZ (Í›7‡Æp©TŠ£GâÚµk¨¬¬DÇŽѹsgøùùiÕÕ¥¥¥áìÙ³ˆ‡……ÜÝÝñÖ[oÕésÑ•••Ø»w/ºwï®ôŸŸ>}Šýû÷#11Í›7‡H$Bß¾}ѲeKy «« OOO˜™™áÎ;rœ™™ºuë&/ÉÉÉxã7ä†|u~§OŸFDDN:U¯z “ÉpåÊ•ZÕ¿­[·Öh®ªª’çeff&\]]áææå´&Bþ 4H«ð¨IYYNœ8øøxÁÅÅ>>>èÝ»·Öë¤R)Nœ8[·n!//]ºtA¿~ýйsg•ò)´­:::puu•w†®_¿Ž’’tèÐA­ŸÎ˲§nܸq£FÂÇyb¼‚ÄÇÇcÿþýˆ‹‹CóæÍáéé‰3f¨2úºÐPÀi|ôy¼Zlß¾ýû÷ç ñŠâææ†uëÖñ„àpÀ©;ÅÅŸyó¦|1WYY¢££qþüùÍtáp^6•ÏíÛ·ñäɹ·}ûö2½”S¸Êè%åøñ㈈ˆ  ôèÑ|ðÖ©­ΫBVV¦OŸ®b>|8>þøcž@\ p8çE¡Ë“€Ãáp8\ p8‡ ‡Ãá(£~–Qy9PUÔaaG UUÀÓ§€™ [O™[QÁœ’ØÖe÷âp8œÆ ²’µó5ÑÑÑ0BˆŠ,,€Í›yÂÕ—òr wo@$ÔlÐR+b1ðÉ'€•`iÉœ¹9àï:Ô²²›Ãáp4rý:ðÞ{@‹ŠöÅÒè߈×0ËH&zônÞdÂA÷g8jÒmüxàèQ`Ï`êÔ†ß+&ˆˆNœÊÊþ––ÀàÁÀСìÈçks8M”–çϳvüÔ) æ×juuž=Y;5c §§eÚin.ë•>x|ø!ðùç¬1â¨çÜ9`þ|àÆ ÖÃo¬Õ¨••@t4ðË/L8äæ*‡ÛÙ^^@·nlTÒ¾=àâÂULÎëDEpÿ>pïÏÚ¡›7™¨ÙÄ›˜}ûAA@` k?j }Ba!“¿þʆï¼Ãz¥Ô­Á).òò˜ËÍeÇ’¦_úÐÓlmÎÁèÜh„]‘ä”” Š÷ÈËcÿËȈ%Ž‰ SÏØÚ-[²£ Pˇãwî°Æúøqàôi ysàûï ûC4 éé@l,põ*;^»©Æ³¶œ6mX¦×tVVL%hnÎœ‰É‹/ÐUUÌI$ìXY©|¬‹ŸDÂÔt‚“É´Ÿëê²2¨ÎéëÆÆ,mš5S=šš*Ò¯yóÆ-³ÿ¤Fª¨ˆ¹²2VçËË™«ù»¼\5ï¤R ºZ‘oêòêY?áÜÀ€Õ_##v¬ù»6¿šîEçiUkC‹‹Y99 — X²„5À'D¬g’¤¦²Bj*s÷﫨Õa`¼ñ†â6k¦øm` ¾âÉd 'TZuçÕÕŠÆ[“{Õí"‚Ñ_BÙ::66Ê¿ííY9•¨ªRtêž= Nhü‹ŠX#VM¨^JôõÂA2ϺšõCWWájž ¿‰T…žTÊêhy¹âX^Îh]ê®®.ksÍ@ûö סCÝ:¶õ¿ÿüø#1¨ë•6žžÀœ9LÏ¥mC—{÷˜ü‡€¿kS`Â`òä—S—Odf2Á­ÙiÙŒÓD˜š²Š,¸¶m»K—¿†ŸX $'³²’ždd0'üÎÉQíršÖñœ½½òyÛ¶@»võnôO Ôì-ÄÄ./wï2[Cm=ccEO©¦ Cè…7kÆ$fn.+€‰‰À°d—.À¿ÿ ô맪Z¾œ…I$,¡c«ë‰UU)F/½ss® €õfµaeÅT0̶ҧ“Èÿ*+#MîÉÖ ‹C~Á çj¶?ü[{rÚÔ5‚ÓvnhÈî«©·WÓOJª¢‚¥‰X¬8––²t,(P¸’õ ­½=+ó‚óòb£ç­ü%%l¦IBSy&'³cf¦ú÷06fe¿¦³°`•©©âجK¯gG’€òˆ±f:Õ<>«þÓöûYÕ¡:¢à^„ÓÑQ¨WóÜÜ\y†:gmýB¦ý7Þ·Œd2Ö¨”•±Â_U¥¨`ÆƬanˆ¡³¸˜éè¿ù†IV®>ý”…]½Êfõ<|„†²žz¯^õ×ýI¥L TZª(pR©¢À7ôÝ_7$ÖøUT(ô¿êtÂ5ŽŽòP»6g` ªóÕ}…×WVUYYLœ™É\z:S¦¤°Ž– hŒØä^½ØìÖÒV®¯_g·ØXvLNVîüØÚ®®ldâäÄ:R5Ý«¾I"QϪ8ksBàY÷¬ì’ÆƯlr½:·“J¥KY³˜•|Èf„ŽŒd=(çŸ(dÓÒXc~ù2pépëk¨ttX¹ë-`Äf4|ò„M1ûLý§ÝyÝã¼tÁÀ€ç‡ÓT¬_üô¯{œ&W¯²ON¿ù&àíÍöXîÓG5^UðùçÀðáìóÔ"+œÚ¶JÌÍeû´nÍ®‹UïÚ5`ìX¶GhëÖÀ¨Ql³šüñ3œ ÂÎÿ÷?¶%§½=ÂöOØ^ ³g³ïÁ{{{÷ª(óª`IDATf~>ðÁ춶l‹ÏcÇxéánû²é³ÄÆ£G³½Í;t`õåûïá••l_ï?fçÿù«&¨ßĪ¤„•ïvíسÿçËë Õ•Œ "KK¢7ØyI ч™š*ÇËÎ&òô$Z±‚H&#’J‰BC‰¢•+•ãzx0ÿS§ˆ†'Z¼˜hôhæסQE…rü]»ˆz÷&ºx‘Ÿ=KdbBdhHÃüÖ¬QÜ×ߟhÓ&¢à`¢µk‰œœ˜ÿ°aDééDC†Í›G4f ‘Ž‘¾>Ñ¥KÊϼqƒÈÍèða"‰„èáC¢.]Ø}¾ù†8œóÕWD;²²äçGtèQË–D®®Ì`çùùŠk.^dåý“OØyi)ÑÛo³¸[·2?‰„()‰Õ7€($„'%±:ID4t( ;r„häH¢… ‰¦Ne~¶¶DOžðüy ©»@ˆˆ 23#ª¬Tø=yBÔª•r¼à`"__e¿›7YAkÖŒ¨¬LU „„•—+üûöU ¬,¢æÍ™¨ÉgŸ)Ó§•éØ1…e% ÑäÉÊ…~õjæ?ožÂO&cÿeÉågž?Ïâ6oNTPÀK§áœ;ÇÊ’+{ÕÕ¬uð «oÑìÙŠøÓ¦1¿ßWøíÜÉüÆS¾wd$ó_´Hõ¹‚@9’¨°Pá?aóß½›çÍkˆn=†lh9gÛ&`{~ñ…²JéȦҩ‰H>Ìv<35Uoøª¹íœ››BU#°aÓ{3uà„5 —.±­ņ9®®ÀÈ‘Š{²}i¶§‚¥¥"LØq--Máwú4Û©ÊÎNù™÷î±ð²2ͪ-§.´hÁŽ­Zß~«Ø‹xüx`þ|¶g"~` 0t(àë«ðóöfdž¬)ø׿ØÉîîªuÃm*±uûvÖ`ïÙÃ6è˜:UY @›6ª×ï½W·gÙØ°ããÇ ¿[·Øþ®ÊÎ×—ÎöïWì=«m…°í³3/„)°……ÊÏîWó™ÆÆì™?ýÄö¢åp\ÿlÖL5,4”Åb ;[QOždSGóóÙ8aa ÛÝóbm­Z÷8¯ úuŽéìÌzÓ&±ÕŽÓ§³ïb†c¸{—Ÿ÷S‚µš°»wYŘ0¡öëut'u„ÿãë«è9q8ööLP”—³ŽŠÐ™ÉÌd{‹‹±ÎVÇŽóLuuÃGjñð`£€åËYÁ‰‹c³}„ž´°úñÙY?5ièg*„‘¦a±0:hL„ ÈoÞÔ§)žËá++v’%&½z±žü/¿~~<8/@ üßÿ15‹¡!°bÏ æÓ§ÀîÝ,N‡ì¸oÓ¯?Ë áQ_„{¯X¡>|öl ´´qSGèu­YH¥ªáû÷3;‡ó¼¨ëXTW99@Û¶ •Ò˜1À“'ÀÊ•ª#au Ð8œ&W¯gÎ(ÎÛ·gFbÈÈ`Ç7ßdúÿ¢"`Æ åBž|õл·ÂOhdŸÝÖY8¯YÀƒƒÙqçNf|«É/¿°¯7 =zá:uDݽ5UªáÃYELNfk$ÊËa«VòRÄy~ÔœcbXZ¸‹Å¬,J$Êe±¸˜?¡Þ B$7Wá/ÄÑTG„ú¡®ÄáA‰°0  @q.¬v bGss`íZöûða6»hölÀߟ©›¾úJaD†²gmÂ3rr~ãdz…8R)›}Ñ¥ 3hwí L™ÂìÏÞWaL0?&Œhjþ¿6m€O?e¿ú‰ÙQ„÷pqa£þ>NcœÌTÖì˜|þ9›AôÁÌÏÔè× „÷ß._f£•+Yxz:µnßÎÎ]\ØñìYàÄ V^a!¨^a¢­îq^ê`‹ynÜ š9“-@ˆÚ·gÿA&#Ú°->®yï=¶ˆGàûïÙÿÂMMÙÜoçyIH`eª];¢^½Ø:ƒ ˆˆ•×9£XÙ¬Ñwß±2ìæF¤§G4k–bñ™DÂ°5 ¬| eÙÍhýz¶ÀmÕ*"{{æolÌ¿ñj¯:DÏêk4ðä ›3]RÂz3b1ëõ 󨟥ªŠcuuÙ ÆìI?yܾÍÔS:±¹ÛMME{¦LÆþ7ÿ8§1HLd£\??6BHLd½t77 eKÍ×¥¤0Û‚¡!;¯¬d#mu×dg³µ45ûŽó¥îÃá4­@øë/žœ ßS™Ãy‘h›ÁápÀá¼FFÜ'OxZp¸@àp^K¤R`Û6Å,¶”¶êøÒ%ž6œÆÿ¢ÔC—;Ú IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/orange-background.jpg000066400000000000000000010521121240331347200271000ustar00rootroot00000000000000ÿØÿàJFIFHHÿþCreated with The GIMPÿÛC   ÿÛCÿÀ«ÿÄ ÿÄH !1AQ"aq2#B‘ R¡±Á3Ñ$bráð%4CS‚ñ&cs“¢ÂÿÄ ÿÄF !1A"Qaq2‘¡#B±RÁÑáð$3 brñ%C‚’4&5SƒÿÚ ?åN®umûã†Ûosd4ðqÎó_,#´“;/²–{;)™•Ïâ[ä¨ï?Û½\möRá¹8 O¥çzS[*ÂQ¸nÎ;T]Î °¦•°à.žu¦Ûã¼ÃHŒœwâµDs&p^[jÞÓ¤¬ÿ‡%m„#=©Tàà«+j†7[`7ô¬p>Ýë$Ï ÓTÌ8ÉZ“ô’säd a<¸ <ò¥íYq9JT<ŽÕ-nܬ‰ÙXÒ§ÇTVm†CM¥Bnäû“PsË$¯ÛvM©iZ ºk!2œ9Qàb°š"Ð¥˜Ý!_½0éN¤ê=M?OµmD D_›šì™ e)FpsÝ_j¶ôÏ…—K嶺ëHæ¨ÚýN Îx ÷*¹êjz'Å ™/à3ú©=½Í'iÓ×Øw‹@|VÔCy*ÇË‘ÜýÅk»m扶ù©çƒ\ÏƇçÕe-=Dµ s¥£‘î«”´Vµ8„ƒÏµAöV63'ˆÍ¥*RJÀ¨é”8û%»| Ÿµ&„àI†­‹ À¬K²°s²°Œ„­d0š&v˪ChemJ £ í˜Ì„•gþÃïR–Ó—‘PpMkž{JŽ\È}m°Jš ÂsäS'iÔKxYÆI<­ñÙKiBÔ0OŠe8)])ÂK© l H8ö¦‘³Õ’³‡•ÏÖŒc“žÕ)Ù8.Ý:ÉŒÉKJRS3ȤY7`¼kÏtÝ„©A?§ŸjP7Y>\Œ)4XÏÆ !ä%Г€x÷¤¦ì-yØœôQ®ÃiR)Ú€„­ÀUÇ8ñ]-Ñýpè"`xä-Iw´ÈCVïâq¥E …6£H­õCÔ4óR5¹ÙRf |nÝW×Ë Z–¦Ò¶ÕÈãµW¯6q3r7=§íHV–Y?ö[ø)¨ºKÏ sVáº×}Å–™Càðp1ûÕ7®§kX7%LZªÉ“.á6i†â¿)Ã!¤²÷l›EU:~Ø×»/Ù\Ä®x e×f:¯n:Û[O~*¿q:¡á»½:`ˆé°Nå2%ëmÓÊ/$`}<¤Ô3£šWe5IXöÉ—pœU¦§ZJ$4äGH “·p=aQWý/>ÅOR\"—ÕÊÛn Aa‚òÐ]'‡<ÍV*`26IUCæ;#…80t檂ôÒRŠrÚÆ2•x Óel”3·*s¡•¿øÆBMÓ0‹]Õëk¡$¶éJ~ãÁþÕõ«ìËÖ,©¡|‡vîÏeÎ&Ò¹®#áwÖÒ‘-)<`öÅ}/éZ¦i råK«0¦wëc6„+Œ ¶]¨Y(ÛuåŽÈPÚq1å—½0O€*‹GbÑ1r—5î# F¤ÒH™­,ƒ¸sÇj£x£áûk!%­Î ­Ý+Ô&Êãî è—X.¸ÜcŸëäŽ}$8ÂÞ7]KÒ]EæW5]m›âví#¸ÅrÄ2–;[ŽßZ1‚¢"Z|nÛ#*gËvS=º2®Ô`e~)ž£• 短o¢:‚R äñJÓÕyOÉL%Œ•"½Dº—;‡jUÕ²JL7 ªD¥ eÄŸµ3•îìSªv’@Q‰JyGo#ÍzÒ@S-_âKYŒµìJRqâ’$”œ“·)õè.7 Ø 1ÉÛÆiÙÔØðZ~½“v¸FSŠ–VÁÏzgÆéó¥¹_X>-:¦º^Ô‹œHÓ¯2KòÖ J”3´~¾ªý•î˜¶µõÍš@âq¶wÆù\•â[îwJ‡[8êWÕíCd“c‘u´¡˜Àa)ñ»ÿ±L~Ö>(ÑOiu]OæS/m51Ôˆj{þ‹çõåÿQo¼~¥dœ‘_**dšgI!É%tÅ+x‚§¯kB–¢­¤UŽ§ ÙFÒBi·! Œ¤ø§ò;¥ä8«N¦¢F(Kmm)ò*ÏIPÖGN¢"ç’¢ÓJD”°–Þìp;Õz¦©²à0{©z¥ºTU%#nUø¤NT«[Ý$’Æü¨ %^)h¥ÂY®ÂÂ4%:Hqë7Ôi^™Úl JâRûäŽÔÕõý“QXuak+~ ½2r3šK xÊ[:“ôkÈÂÂ<Ò'0å¥4¨¦ržy©î$É)'=ëÌçg¨Ùµ_ú\ß%o‚Ê• ‘É$ù­ëЈXc¦ˆnOêJ¡^av#Êë[ˆ‹R‰Ch('šúl†í†C€ϺÒÒ=æ£ß*#QÅ´ÄvdE%·{Fì}kš¾½Ž†-(Ã}³ùbŽÐéž&ãÙ6Úz¥6Nèn«|uñõ’?zó¤¼h®‘îcŽZ}÷JVôl-:ÆÄ.1ëˆnji²Ó,-iiHóï\kã=wÞoM!m~–c„§²£äÈ*Ù‚<`V«…Šá €[î2¡:‡PƒÇ=©ë]§eìÌAôï©n[%3½ß# âÚºŽk|º›»J§ßúh=«éL:¡TxÈuô(x'WQt']8ÂÓ) ™:ˢ΢öÕ°äÄ»Cõ™-©Gõy­Ãp¶ÅqƒïcRÐõIš]ÙFï6d´ Hã¶85¦z—§ Ñ:7Œ¦­·bÇg+™uæh¶ó­²žs‘\£Ö=å#Ånþ“êÇâ¾büBt"Ù«mÓ˜zÜÛËR(ïÞ«Öuª5`º*×peL;î¿?âGðStéö ›¯ôµáJ&[HAäêzûuö[ñÞ+¥+mÕõÂW ý§<{Çñ‹lypü@wêÆ•%H%*"»xóåÍ à¬h^"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„/׶ÒWMwªív.4܉.m:p†’Tµ`5ò §í_}©e#^#;¹ß…£¹8ìÙË­ÐRSºbÜã°îU‰¯:T‚¥]­÷vVpÚÚ_*ú¶÷óUë„̆¬Á‘£8-àßq·÷Míw *§0´…[YmÓ¦Ü"Ûíñ—5×m6Ú –ê‰à;šU”²Ô½°ÀÒç»`É'à Êu[PÈØd”ᣒWGÛáß,[¬÷ëlëMÅ¥aÆ$6R´~A­gÔ6Ù)ê_ ­-{N;}ˆ;‚£hê㙢HZ{…2J\-$¤)~SœFwVj\–I|D%cc¥´Ô„§„¿–FÅ=²ó1RØNïz{'+ ÂR–®n-ÀÒUÉö¤ŸHÊv"Ü'W´¶•nQÏzfÇ áS{-ÐáÀ”÷#öŒå¤d¬ÈÇ*ìÑ÷Ù–¸¯Á)Ô0îÒêAáDv'ñ“U+”ó1Ä4ïŒì~¡F¾çjÆémÍâ㿬Ƣ)£ÀÝ;§a Â{´":™p< ‚A Ó ¢í[' ¡²IZ»ƽpÂð· [eEIÆ;ÒNÆ)\¶–ØNîI¬c+(È;,­á´<•;ÿoÈ÷¬f;g &°¥V…8[H h«#ì)(óÊ|Æm€ê°ƒÛÅ`ÎS¨Ú0…¼µäǵzÖÂS ÊÓ"4Wü¶ÃmR=·Þ¼qìSšòì5"”ëL/ÿL¼…xö¯!apõ/)ÞçøHÛ‹%jVyì|Rù`)€vJ#¹µÒúGŠÄNü%lšÑ.ν©¿C~ /IJØ-ª$‚Ÿ­£“õ{+Í]‹;F{qUÙ¬2S÷ €¬4Wø{¨N ˆ»›“–0§’ N;¨{Ö£ªŽAPâïuµí½@æ1­VšQ¦"Ýý¸u¦Tèܤ÷@Ïzsp9ƒnøç+a ˆ–…Ð:ŸY]qS·'‘.XJPÚT”¤$3€*«w¬¬­«}}SËÞìdœd€[œm°/z~ÚÚ(±Ã}¾»•êô„ˆ¦ ®Ð$Çi{Wõ ¥H<ägíQìª0ÎPm¾?%/I}dÚ¼—ýÓÄ­,Ôäγ.l«'ËecµJ^mo!Õ­.§ìãÝcGxtŒTàKíþ‹jŒT=ç-›Ç¨3ÿq5°|ñaý;sa“?wÈÎûÿôµÿYô›ªØçê]QÓýB‰±Úþ`àŸ ×ÜŸ ºæ–ëFʘ_œüñžu]ðJZ[×DÛß#¥Y=»×CÛåg¡k©ãÁÝeü¤8RJO<)Ãd‰ŽÃÏ+Ãœái.2I#Þ¦*áóaý–PËåB¥µÎšKѤlg’>õÂ>=xlÙ)ß.$þëutoPð \®¬NÚ녿I*à½|iñÆú Ò×3H]UÓ—/2ƒº¦$%V¥8ÒTAò*µ‹†¾F] ÀZ‹­È;‘°}±DŒ-+×S‘ÊrŒÊ¶ k!QÏxN¨l©9Ü@¬¢„ÁMÁM³šò=©\àá:‰Û¤ðZm{’¬r{æ‰Âz\O*ÖÐÖ“&É’ÿ¦ã `rx«ŸFÚb–g>c–û¨;´îhÀî®9Úr ëzšu !€0 G?±­¯_j¦’˜³`Ü(8j^Çe§uÏ´ã Ü\TœwbÉ ã¶}ëAWÓ¼¶Ñ—å‚ðºoJêYŠ§ÖàÚ€““ÛÿJÜÝ5ÖOd`È} wáPnT Ôt„ûª5'ÌÁnÜœ¥9Ê•ŸÔkXx£×²×G÷&-?6³ÙÄRʤ/RÚôÔ  Íijf=ÎË•ÞŠXÙSWG=I$æ®T †î­1·HÙ/·Äj€úé)æ÷Mj%<)"›x }*á•rlJƒ’FêÙ0ÊmjÊUœvÕ®ÁR”àòR[Ú6ðyö§%ÙOµµ ñŠÇ^&LwN0¢¶Ù sÜS9æ%7’rFÊG±iFÈ#Å4MþTjêÂây_â¤)$÷OiäÏ%6BŒ²Vßœš^Wö 9¤Â^•)µå$ŒSr˜déMN,ëKê^^èW‘Vn™½š9DƒvPWKošÜe½Õyn±è"Jöã¹Ån¯ÿ-T¾#Ì:OeZÿ¦bÕ§uÔ]IyN¢ÞË…l’ €'Š¨õO[Ï$‚wz6Ïú)j kKÊuµ_d†Cñcº^)È'€*ÛaêY¨uʨ£a8ª«W¦TÉeéYT•dœŸ«z¾¢GÔ‰&>£þªzÙ屸o -® ÉûUTO”ÿÏIÝiLœ€F)טR4®ÉÊH¼›|”¼Ò¶àãõ%'˜0Tät"aºè®˜uIè°y@dý«;uÎZF½ØµÇRô¸ ¸õ+£ÝIj{›\„©*Æ9íö®²ðÓ¬â,$¿Óì¹C¯ºGI/h]tÜv.›y…Œó[ÚãÓÐ×B*"Û+@>wBâ×(¤Ói}.%M…¤ ç~²èæ5ÎËUºËz-# ’ú¡c¨HsÑsã½r?Wô¬P¼ÉŒ5oî’꧀•òGâËá¶Ï¯´ýÖ3öÖ_JФS߃Oü/ñ¢Í\ÐF è gÃ]Nc”ìy ðýñÁð›xè6µ¸]-ð]÷ÔNpÂÉíø¯¼ÞxÇQÐ6)<æÕ|ÄûIø&û%[®tMþCÎÿßóî¸ º%rb(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(Bý‰i«¼­?=3íû[‘°·œx#‘_ªKÜÒˆúl¾ÒýÝ’ I¸J.W77–ô‚¥wÍ1§§l@¥É#a•tÊ|­9¬ìZ¢ qÈ2€F2ŒPÏ·Ú§ìÝW[gªŽã@í3DrÓìTúÜʺgRÈ2®eÕiCÔÎ˸.2–“„6Hûžäþj™Õ7Ë¥SîuÇ2ÉÉù>çåcj³ÇEN!ŒaZÖ+m¥í6믗—r?öÂH JqÜÖ²®žŽúóùa>·:q1iü*ì‹Žú '8©hæÝ]ãhÂ@Û»TAPÈ¥äfBËB‘ZV”N2æ|ø¨Ê¶¸mÙc#6R¹*J[œ ‡ŒRÆËØÒ=¸¸Ñ,Z¶Y~%`Ø¥ý;È$‘Þ«w;,r8Nʖᕼ¢SœíL›Ó€³ce'„þöT¤(þž*"v`î°É K+)JN{Ò2 Ñ­:°yl‘äSg ÖIo·œ‹8ŒË’6…%8*ÉÏ'ɧ•—N×07@ÆÃù>å'K‹$å2!-¡ÅGÕö¨×’]ŽÊB5êÕô…ŽUXï„í®Y2âó’hNv[0sŒÖ+Ôùj§VEÔ>b€AKdN8Æ~ø¥h f ÍóŽxÛŸ•VN˜ùLnŨR ½<㟀™=d|%il$ÒZ½“ý›(.vÉ÷¥ v^à¶nR–’¬à À—­J¶¸/yíMÈ9Ùd•ÁK¯¨G%HlžN+p7M¤9Hr˜È-7´'Ú˜=¹Ý1îš}EÀ”Ÿ=éV0²pÇ Õœp 3—dl½qiHääy¬XÒRÑÆ9Hp^s ÉçðÒêWl´¶¯Élr>õQW¾šLã“Ü·ñŒË!;Ïo ü×DK³žSatG`Æ•±×}B>“žkç»ÊhÉÎ=Ñ c8]Ó®‡µ¯bêØÒæ9hÔÐ!|ôxrùÔ`•%%Cõc{æºßÁO³<CÆŽë3©.T­ÖÈž|Ö€I89ã<±ºÖ]âGð‡S½¬ó!‘Ú\æú´žÙÇnËœ)%äÇ.¤œ%\>õÉÐÔ=’ê„–‘ǺÛcd×¾R˜(ÒAmáüÿzéo|Qˆ*ÉÕØû­kÔ½(/ˆl›uuÙN²´6òJB»cŠè9._y¥t¬8p ]CLY.ƒÂ©¡_•=&+øSË8V* É>÷’㻈ʑ–?%ùì“ÈŠúä¬}L–øÔŸcTK¿GËç¸ç£Ÿ…?Cr …½ZXŽ¤¿é#ÔV@#½Q.Ôœ •z²]\_ƒÂ‡´™1î‰JÖG#÷¨§ét[-Ão¬a‹•t?­?ˆEn—1ÅHi-’¯ÓöüU4ÛdÕæÇÊÊŽˆFòø›±ådÅÛQZ£<Òß}ù?¨géV)ã+œbu²”rN=ëã_Ú[ÃPÉ̯Û#EÔ}ÔÁ­q¨·.$ŸÁ®Š'G)aìº>Ï8pPX¯ýjoîqR3l©Ú†€Õ=üÆ3ÍG†5Ç ¯0ÁR†‹1Û-¡ÅmÏ#5!ZÆéئ¥Ý”~è¦ÞAp7³ñL&Á9Nà;&&–@Æ#Ú“-Ï b8Á*ÓÒk¹ˆäÙ*RÏr;ŠµØYTXDr¡î‘ŨðöV¨vÛ ÈµéÈÚA9à“R7Ψ¨£î¤ Du¼=ÁÃð­š>Åo¹¬NºJS,«?Jq¹YüÒýh¦«h–±úG°ÆtÖë<Ñÿ.œ+¥V¾]´¯ wÖÆê{=¶’ 4DçåTᬨ|šeTî¡ž¶\u%@ +‘î“:yÎ{+Å6F¤ï7•)JJT¬*JŠ‡%\é¨Î„Ï “!̨’{þ)ìÏÒsz[•yèÍnŠmé{Úú•Éeé”þ%/ó‰ î©w«È„zyVœÆ¬6xâµÆR1€HÊ¿rklWV[mÑ}×Èiº«ÓùÒz•ªaÃfb—¡C8Z:õm—1ì »Ú¦puô¥«èÅF)6ÌIåf#­* æ°s—¯dÿm€_SL¥’pi0¼€ÐrSIfk'²ëí1Ò«U¾Ú÷KS3ä-°¥ªBTvqØ'€+³úÁZjZ6ÔUÓ‰ð /ã#€6óÝië¿XK,Å‘?{*kªÚBÕ+‘jˆˆ$ÈOéZ}ÀñZwÅ^š£¤”KJ͸‡ò ëÒ÷do­ÙT“(RFܯ5¤Ýœ«t¯ÊvlmA%ήqŽÂœA®Jc5Yo »w¦…¸É$§Å*èH9 Hª ¶!GÞ”úJ3êóûRÍÈ9*RáºA.‡Ì…ýkÏ9皉ä¸ø áÓrÜJ=¤9ŽR<~lËÏÖ—ŒªÊ y8[u$hr_oæv3ØÀ#Þ¡ú±Ô®}ä»Øþé qxfrCå0µ6”…'¸­eM Ô{©eGoñZÙê¶M\ w©'‘éÂ}@óœ*NüÚÊœÚ;x«5¹þêõo™hÓWI1f4 PF|x¥îTÍs2ž\íí|dŽWѾ†ë-¥–{cŸ5qðâçdÄÿ…Îob88 ëMu &Ĩ);rÞ¾‰ô-Î !ÜŒl¸­lÆ9 •§qµüË ZFâF ×=ùZâÑú*=qc°UªôÏÌ!Ô©°sÜb¸×«úE¯k˜à¶m‚öXAq÷Rz}óM>ÊT‚“‘ŠåÞ¬éÉYPé°n뢺?« 8¯…_ÖN¦éKäi6Æž6¾J3Œö5¼<ñžªË_#-«ÔVzkåé¥hppÆ ü?uÿ¢z‡¡ºþñ¤¯QŸCuF+ÊN­çÜv¯½žõÝ/P[Y]Nw#qìWÇ|3©é«“©¤Œ’Z~=¾¡Qµ{Z­!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!~Âb3„¥KÆE|J•ûà/´í²rùpêr¡ø¦¢M<§ÑŒ€¶Çœ"%ÆÿN|šÆX5œ¯H9ÊÂË'mÙ·9$«Þ½¸Eü’Z‘¨åuŽZÍ¿9àŒw­;_ágIÔ[MÈa²S¿‚Aî(À$8öVöFÒ<¨L¶ÔÄ¥'q>ýêrÄ茩-d¾ŒçóQ•íÃJ—º—:ûku šƒdD7RjZ9KYØVÉ$ø‘~ÁáXÚ~$››ÌÄÂËË8JR9¨iß#ô°d¤;cÏ8 Òãov þ›¤“Û5 ¡ÙÇd»2üT¥¨À'#)¨éÎ_ºMÇt¹%E(RÆ 6-–lŒéÙ•–Ô 4pÁÈ+ÇG“œÉÎKn;þ­±Í{5CäƳœp° öZ–è™ ãšh §á« ØJJyû×…ÙÝ=nÁd0Œ€}ëÃ’½k²‚þÂH ¨Šõ¬Y/y´!´ }DeG422Nèc=K6+N ²Õ3D \ÎBPÒ¶F`©ÚfÛï–òû'ƒ‘Ïï[Ϥ:ÝåÞDç8ZÞýÓÖÍŠ¬nºa»]æ;ìHam: ¢”Œ²{üÖÓs Š¡k²¾=•2¥p!Ý“Ë–™/ïa¼‚ =ª^­óJâÈ]é*2’V±ÚŠŠÍ³ítªaIXN?H­=ÔcÚ¦;œãá[¨.ÃðÆÆJ'¸óa·ln!CϵR9v¦·u}¢¸<4oʃ‘5ÛÒøÁ+Ê@íjpï,B·5ž½ŽˆøWƒOH—jŠÔ­ÊCc üµ¯œÆ²bæwC£c_˜ù*}uÐ7}!Ás’›Ó÷É—Cc ¤“Á>à‚«÷Vô m®jºª*†±Ã‚Ø? µõ\Κ‡Ät¸sÿ8Vn›ÖVùš~ã¦rœ’ÓŒ:¤À‚¼íLÿêhÍ¢kPŒk{Ú滂6;öÙT/=5,Ul®ÔK@ Žß¢‚\n7}©\þ¥ç1”+)Bü§þkzø✶ÉŲipA#³ÿ;ª7QtÜuP™˜9Vý£U|ãL—\.ƒ’ké7Mõ?Þ!fOu ¯–(å£ ã³ÞÚZR½ë©ìWXÛ rå¬k)_¨ì¬›ué¹,an¬{ÖÇ·]$GK²£¼‚Uq­‹5'!\€;àO­0Ìd2o…¸ú>g04…ÂÝE°ìuÕ£nߊù;׶_ºTëo®¥éK ¹ø®E˜ wöªûebÚ8ó#ÙN­Å[=ÇûÔ#¤Òì¨Ù9­N6ŽqíJ5¸:óÊg§²ÒˆÎÜm¤d%GhûŸÅ- ¯ ”ê)DcuoYºZÃ,¥éSÙuåûi¤û[Z×Ð!¬š@IìOPÃG ¤¬= ¸¦2€¤ÄôÁ!þõÕV³t´Œ¨1zH9Zâ«ÄfÈY¯Ô¹—¬—ôåɨëJ ;NìÆk¼PégÚpÇçŸÝmN”®mDZù 7¥ï.¹*:JËmä3À­uM9ŠA“²–º@þ‹Ø䶂V¾Øî*ÑÔ]QQ-(Õ.:^U5ªå«.Fy­SA‹Î¾UÚÛ š–â–ñI=Í[á` ÈVVœ5LtÓ-¥öÖöÕ¤`ãÞ£+'ÒTelÃWB[u*£4Ú[ZUÊÕÕsEœ*E]µ’\šuý—–8Þ¢9ÇsM®ÝEæXÉYRQ+¢_ú»®:˜ña|¥²*kÇkm#Ø*=°+{}>Î7¾½»´2"Ê&o$®ü {îqàõ$Cñ+Äúœ£2JìÊvkFäŸòUô¶íð¡Ó})£]ˆå¶ û8IÉûœg?½}™wÙ/¡m?%/ݵhnîÀ>ügŸ•È6ß®µ÷æ’2xÝ|Òº|;êC¯_ÓšÁ:ìB‘éŒ6È'ú–xH¯ŽWï³öëÕ2Úz^”ÈÎsÃøœpê» (hí­¹ÌŽAäý%}"èÀ~šÐÉ…¨º“)­G©“‡†×ÿ£EWÜ÷qCöšúEö}ûØútÅtêC÷ºÆáÁ¹>Kö‘îp>+‘¨éÅ1…Û`0ÙlÉl$¤þEvç\Ûìí³Ln°0ƒ¾;{áj¾†½\¥«k„Ž'>å|EêëðÕw“e¶8e+9Vìùí_›Ïï4ÒÜ䣷Ä×î¾”tts:™³J0HL?é,ÝstfÍif\˃˜á°ù&¼ð£Â Þ©¸¶×oÒLïl>¤¥ú“«àµÓšš‚Ñî»n7À·ÉÙ‹·K¤§'lÜT…$%vóýëé=«ÿLÈc·]VMF3é î1þ¹\ç?ÚN9j1 ŸÍp‡Uô+8»9n.*leä4µpA‡½|Þñ³Ã3ÒwgÛZâöv'ŸWGôP6ç” CºR¬¬ð¢kL±Ù;«ã’³€ØvBP 䊦‘ãQÙ°’º—JjÖ4¼V"ÛYfDá@ÿæWs]1Ò>(›L †€hiüXÕùã?ªÖ—{3j^]&çç²[¯/ÖmGg\É 2‰ð1“í“M¼Rë +ÍRßæ7aŒe!c¶MM.†ŠçV§!n% $¨p+•ÃŸ¨± öøN=IÒ說’­ß:›Lå5ßz[$V™luïŒUy.-=ðSZ;Œ ”<ÍPw{[®=è­’•gجèª4…z¥Ÿˆ3ÒzSI¡ßFð¹I ¶@JOïÞ®;=½òׇ;ÛIÆϺgx¸Öÿ#+º5¶”1.vIÞ´=Ã'8)>ƬIÓ´t‘Šûtš›¶}ÇÁT)*$©&9ÆÿÝ}èV¹\äD@wwœù­ñà÷WÉ4qŽW6ø›Óa­.} ´¸d@C •‚‘Åv;éß%1‘»ä.I¯f‰HQ‹Í¸¼ÚŒõÉÝkc”JIM[kp©=U¦Ù…•£œsî+›:ÞÊÆîy[6ÃysÁ\=Õ®ŸÇk ŽÚ’Aú{×9]³O?˜ÎG²éž‰ê<áŽ+ò£þ*?Žk]?pÔ cÇc%oGZSÉPçn}} û øÿ÷ –RT»ùnÀ*3Ç âêK3¼¶9ƒ-+òKuµÎ³ÜfZî1‰9‡Û­­8(P8 ×Ùjj˜æŒKË\2_®Vù©'u<í-{N)º—LQBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBìqÀe·Øì+áûFGr¾ÌÓŒ”éÐêž8íMjšC“øÉLW0ò‚wÜsOéäËr”é©‚ó7)'8ö§²aÑœ¤ËuÓÚF­¥JçwíZžõ™­ ÉÈV ,¥l$í$ÕfGáÊV¬e@u"iä†[.8}…Xínin\vR­ }·Ôa /`f›Uã²e3ê[’\JÔI_ßÀ¨j‰6Âj®þ–éý+xÕ˜ÚÒá*Ù¦½MòÞŽw`Â3ÀQì*W¢™g’æÁ‘Ì¥.ÑøŽáo±c áD/¾E)£Rn<$NÉ{«?Yþôå‘çdâ8Èä-vÛ“¬¼/- ÈÇŠÎxvô§º0¦ñ&¥ÍËZÈQÉ'ÜÔ+àÞ´“Þ8MÓ}îúÈ_9>õ Úm î±2¡"‡‚Æà¡R4ò–§˲S§'7lD¸²T´¶T•ØÔ ¬s}Lå!U›ø”öbßKí²Û’Zqã5½z*âë«þc|{åj¾¦·˜žpp S23Í¥ÚÚG8î+xÚ¨%ÑHºÖÓ7žU-¬¤- )¶Ê”âÏßmk/b= °TÕ…Ø“'…\”ÈiÏ›HQ î î+VSQTE‡‘±[*¬·JÍû¥¦ Ñ*CCÖôÓK{‹cØ÷ é`ª©“ÐÇlŸbjÁyv+YI$„„$d¨“€*µü ì8äžÈ¥ŒEew×jXõüM£Nuå‘v#«Ô‚µ()P÷ò´gØûx5½l~.Ic¶KÒwÚfUÆê3ãvîh>ÇÛ³–¢¹t„—ˆ¼Ú¥Ð]³†à;¯÷\Û.,6®¦[ÞuqŠÊšý)ð+œªªZéÖNN>‹uRÈóY7âÆêw§4Eó^Ú¯i…Û„xQŒ©_XË-¤¨gÈÈ©Þ”èËÅÁµ5ö˜õ Vy’€ZÑßs“ùn©½O}¡ ’8ªNŸ0énÜŸe_‹ÏF]cÚf¾§#:74³Üc÷® ðgÆÚ™"Êìžßý­sÔ}1Ù‘¼+ŠÙ©n(m.4¿P‘ƒœWmô÷‹Mg•>ùüÂÒw^—f¬ ƒÔ‹›/&( Q$dão¢ñ²X”ÃÊ‚wH1Û«b<÷.0CŽ¤…‘Îyª§Uu«àt“÷üÔ…®ŒBCB º‰mYJ–ÚP¤ã$ÿÚ¸ Å[s‹õ³€·wLÔ×)^न„‘¸÷­ ´%n* µ0n¤VÇq»¼˜ñ#©ìàT•¦Ï5tþT ÔJau¬dSÏÑv†œø~ÐI´çYê9ÝÖÞCQÓ€ÙöÉîk¹:KìïÑñ[õuk›;›-cõãe§î}yst¿öP‚Ïr¹ßWéxÚR¡˜RÅÆÜøî(`‘ÿ¸{Šå>ºéš[Ø2…æH?¤žOÕl[-ÂJÊ|Ê4»ºwӚɦ®hz{­úä$ûø©Nœê’ÉõTg–U– æÞJ¹'uªL¦m‡$!¤ '!|~ks]|y­t-‚<ŒÝT(º&ââ$û.WêN±sRÜi*%­à§œý³\¹ÔýG%εõNü=‚Ú¶KSi£K´œ—s¸ÃˆÒ78ë‰H8ì}êµl¢um[)Ùˈ …îäØ£s+éޚ鞀µX= ³áªà‚¥3¸)XòªúSÒÞt}5£ËžfùÀrXNý÷\¯wë;¬µ:¢aÑõÿ%Â]k°E´_f"XÈ<žâ¾~x¡d§¶Þ_Ç;{v+¦z äééås¢¡9¸¡Y³æ©mŸ_ÄÍÎêai„¥ím´ØñQ; "º ÕƒÁ|Úòò6/„ý«ÄÆþP¤wçqö­ÁÕŸlJ&ÚÞ+^ÐÂ1¶ä“ÆÃ|ª·ÂÇ2p)›êú+;£}I°[¢3,0ËoI–¡ŽàVÉû?ø­ižÐÃ+tÉ.äŒqÛ>ÿÝR HM7'TèOý·@Âÿâ»Ë~¦¤¥oðê‚^ÁÛûáiªúId‰Y·¸\±Öí=ivï÷jŠÜGä$‰-60€ð A@ð+ºÎÎøƒ€fëyt×iÊùÉ×N”ÅÔ6«ŒIQ‚ÂЮéÍQújùSn©lŽ'•Ô/{l¬ <…øŠÿo„Gúoª'õÇm[1Téù°„pA?«ö¯º¿dÛu¤m²¡þ =9?²âŸµƒíÿ¥n«b?Ù|^ ŽõÜ«çªò„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„/ÙgðÑŽe)( žE|:’±…ÇJû#I;^rÔàÔ6#¼¤¶¥+ÜöÒI‹†Jœƒ+á6ê÷î=³ö¯#¨#däe©ë3 Aq?IÒ‘×»8+/¸û)VŸš¨Á) þ_Ûɨk”·!>¦H¼ì’Ûv*pvò{Uº×ìíÈvBŽ]_B¥†™Iqd÷5%IÑ©ÊuÏ g«•&ÓzZãzœÄK|93$¬ð–ÐT°§”ºÊù>ïC¤~3†´¸àrHà粂¬¹Ã “84|œ+Jÿ oZAˆ^`?æTÆñé?z‡ê>¯¶JØ«ã1— C=Áî¢-÷˜*õyÔÊÊÀ\¨K‘òñ”âµc%)'“°ªÔ>I™¢Á‘œ{gÙ;©ÖLc.ÆÊé×tíÖ÷tÿ RòtÌ‘±nœ-Ä€\P=ŠŽN)N­6ù.Éga­ 7<‘Æ¢rwÇehlS·ï‡28öãè«À[ÉíŸ5Sv8V”¾9 g£ƒPrlåˆhJ}jR£ôc’ ×F½y;SÇã@%xŽR˜n­¶ H=é)Y’‡ìí“©·¡•#hHàýþ›0ì• ßRl”ã'ñKwJÙb’F{׎9(N!^œuŸ¨Ò$eÉÜ-r›žá}éÛFéàY§b»c5ƒ‰' µ°ÞÝŒ¤šõ䆥‹°®‹WYµÅƒM½¢´ýòU«Mº~+XxÎñýUt¢ñO©©í±Á[#(ÝœÆÓ†;<êoùªÍgHÛ&ªóB+xqÜ¢®Zt.XuÔ’‚Fxþõ¯ÚÑ›”’½`¼è[Cwö.Ö³{ßB Š8ôÞ=”~ÀǸu°uª‚¸f¤Fâ7;ú]ïØã~ù²ªÖÛkfs OÐõc¸öUT™å«yúGj 2, •ž6 ÙPH÷ïNwY–„¬$î »=ù¦åÝÖ@öZÝaÜÚƒ¹]Íf×— Ñ“ÙIáN(a)!I¨šˆ2í“y#ÉK¢=ç°úÊþ¢HüQ@8ìi" e©ªd¤‡v6AFÒ–d)Ä2R 2‹¤(š^8°€“¶òŠÆÓȬÜÁ„eKc:¢Þ{ sQf錭¥ |à´w4¼MùI@Lsб¸¶?4¬Nßtêu`¨(÷ûÔ‹Z9 Ñ9VÿMî‘=W¹>ÃC B” ¨ß5µ|+êškuyûÇõ€8öTž«·™cË•]¦F£ «zwœ÷ºªÇ~†gâš}ùZ:¦‘Àj•¾[PüÕ•,¡=ªùaŠz’÷“•äF>MqÌwߊ2°ƒ€EiÛÕ7“PapÞÛ1sCÕw¬£º¦›VÜae5ÌùçXÜ­¡Ò`I¥iÐWâ’ÒÜÂUô«Èö¨Î¤ˆÖÈ©y>•Óv¹R/R„In®BÈúäšÕ5Pˆ[­e§Ê a[:JÃg„‡nÒÜäÆZ£‡ÙWƒî“ïV†º º771»‡0òG|´ã?US¾Ü§$SÆKuƒ‡ÎêôOcNÉ»=¦ß•Ë) Ý€¶Ïô+ÜR7kŸÝe™öÉrdiå§Ü$þèúÆ1• 9ÍüûªŸ® ÃDÄÔ ¡Lˇ% Ϻôž8¦Ý6™Ë#Ûþi{e<†c ·mé~¡néke+t@ä÷í]­ÒX~ïüÇqú­wÕvƒòºai´>údúÍ7“‘ø«”—‡jÁ+^TØ+=¥7k±n'óš´Muòi´¹ãåEÓS—ÉéUv¡SËâ‰í\÷Ô슠½­vwÿ5±­‘– ÕI¨ô²6—=.Ädâ´§Ptéˆêh?U}´\Ïá%k±ÝÑ¥¤!QÛ «óE’þëT¢XSšú3R0â­ž¹b궧©å²²9@ìN²ôÔ×yZù†}³ÇÂv. ¤a ªÕ—mL;!·1ä`ÖƸø*øàóCwøXQuTr?IUŸ^ËD§"*CŒíÁ®zê;¡.hÎFÊóM3%nF‰o·ÿ}—ÛhǶ;jÖ,†Bÿ!£)ä·ÀA]U mH³óžoj“‚ŸûÕ¢ÑD(3Tñ‡7…@¼TÁ½Õ—rÖñÛlâFÀ$n§÷/r4±Ê¿EÓ'ð®yÖšˆj ê–èÝ„„7ŸaZ®÷–åTjeç [&Ïlû¬^[U|êpr„¡_jcˆSÑ7#tÿ¦^f3þ¢Æõ@ñNhÜÑ(s»(úÆ;N;+×Oj9 [ %NlgÅon–ê™õ7?TK•µ…¤§É×ÇÄ•6•- ǵYë/õB#ã„ÆšßfO*)y½ÜœÇË­ÅŒ;Õ¨/5²à‚vã•+KGx :UíöÂç9%Me!DàU&¢9ÞÒgƒ¾OoŸ…/…»4U•¥:±rÓ±ÙˆáS­€O8­Ñ¾3Ü,Lò¢:€guV½te=kµŠß­úíª5µvv§È…oWýÄ¡Xõ?<ö¨þзޡ¦û”²Äyåž h(¥:ŸÛ#…ÍSd.J–qKÏ&´dyÂÚ0’26XGœbö©:j‚Ñ…”±o²Xut¸ .4‚Øð3OáºT3ÿ ˆ !mlƒv¦{§R¯r£¹É[l+…màš{=m]C<©ß–û% éøƒƒÃwU´™¯Èp©°·VÖ¼Šœ…bŠµ¸)¸NŠ¼:ÒÛŠ\Ñ4Œ, -*Wç$7õàäg¿5 ;Wx‡Ò‡ðV×°Ý6rP´›n!õ²œŽÕÌ×Û d‡ÙoÞ¿–ãuñGã—á’ÕÔ­~2ØÄ”:ÊÐANqÁ­¹àW‰³Ù.Q¹®ÁoªÚ(/÷ÒL2בù/ÂÄWCuCz‡xÓH7<³ÕŒð?"¿Ažõõ?PÛY ²ì Cå|uñ“Âúžšº¾7ùN'ITlE§ÑBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBínëqŠíª ‡]Jæ8äx@ð+á$Tîó G}µÄrN0À{×uGjˆÎsö§•éVc Íù ©)ΦŒŒç'÷¬l¼Qq db€4©Z9ƒ¸+Èl¹húˆœVSȺ’ÆU©d}ÏE`¨§Ž>õP®`ÔL~¥O4EžÕr¸7wœB=D¶1ŒäÖtî§2G C´µÎh'ØgrV7j‰[ò¹+ïæ‡OßÂJíº“CƉª:ƒy¶¶%Í‘µß—*PdÓßõõŸ©|Rèß úy´½Æ>Z€ ž séåîúþÆïœ.7e†ùÔ×#%ÝÅÄ}-wïþ½×ËŸˆn­Ïꦲ*p­Ùa2œme¡ÎÜœ’|æ¾Kø›âEǪ®®¹W¼Ö†0ô°pç“•ÔÝ)ÓÐÛiŒQ4z·'Ü®Lœ:ž<×l« ÎÓS£3e¿üÊÞù§’ÚÚx$ßéL¦’!¢ ë$`öÛœ¦3D\ö‘Û+'”¥ÃikH*þ“ŽqP-ÿÈ@á; OvPTˉR‰üÔuqõefS!% Ȧñœ„¼g-ÊS-h(Gõ¬#né yÊ™hx×Z‚ɤ¬U6ï:B#0Þx*QÀÉð*ûᧆ×.­½Cb´g”ãs†´’ç`3žþÙP׫Õ=¾’JÚ³†0d§n§ôöïÓ-c{Зw£9p·>X|²­È+giò9¨¾¿èúŽ¾UتÞ×ÉLòÂ[øIÇ×qÂyÒ÷ènWÁÉFFv8PF’¤¸;p*šâ¬ 9)Éä¶\ÊRšlÇn•#<¤Ï,'h=©V´C);»0>üR¬;§Œå&pl)9R­9K¯[sÒ*wÈ¡ÌÊÅÍÊr†Úæ\%9¦³¼²ÅÀc RÊ[QlÞÄRMÜe!¤$ëuHÀ݊ͬb°^zŠV2r+×7x\–¥¢†½E!¯'ÎëHqi'a95žÍ‹6TT²]WÞ±pÛdJX%(sHùI“ºØ™)ʲ6æ“| Ç•¯ÂV8æ³È%°µ,ñŠQ£uãŽèI x$ö¬*vnË GLÚc„ UïQ/? št}”DŒ}~â9Ðy^d(ã΄…c’x4î2²Eå7õ Ø<ç'²ŸFá„ínkÓmE­’¤àœýÅ7’¡Ív¦öHT·[KqʲVÂb<†\… “Ý^2~þõÔ{†Hã”».­#ÔÖÇÆâ@تêÿ(|ÐŽÚøçš´uQ* Áî«1ÛÜ\BÊ·¦Bþeµ-ÇIúøóQ5ö£+}Nî¥hçÐ4»dÓ:ÝêÇ1¤2Nàq‘âª}/n¬všÒ×ëiá#´ØmvY¾àØ•¶j¿r ÒÜNîUeyð¦*õí9‡½4A¸­uWMŒÄà¶eâ ˆZ×r¬M«=YŽÇx­hwéÉ>þ*½SD`{d~‰ µ¸¾=@p®-yÐî1ô×R£K:eÉiurã$ÚOb3äcǽn_ :§øíÝY }~¢èömŒg»{ãœî©}ImºÉ «lŽxn4»ðŸ÷UYõž÷¦¡n—kZ–#¸NQŸ¤‘ïÀ­mUp¤¥®•ôÐ$:IçNvÏåʱZ…C4Í>Ï#qÛ=×;i›=ïE¼ÇW+ý>ճ䭞66ª˜e§tÎï$uD±ûÓ[Y15s¡“ô¨óWkZ>oüÛl­gp³5œ ¬5–½i¦‹-¾0?÷V]AÖmp1µ-iéÃìr¡Ú/P=y¸–Ôæü«„Õo¥ëäš«Üû}UŠéB!‹$at¬Ý&ågRÙNì‘] yðÞ®®ßÆ02¨twöG7+›õ©»{ŧ}GV á]«•¯v¡Nÿ-Ç+hPÖyÍË6J­‹Œï¢Ú‚V”øÇj²tø‰ïcd1«k²Jš±hÞ¬6Œvù®ÎðòÙHZ×iÀT;ÍC°pª=vÔi-8ØFøç”ó[²õ˜7eH¢«•²åÊ”cHú’ôxÁ**çÇþ%Û#ˆ‘É+nôíÙÁ›•Öý)Ð-4ËoÍd„?zÖÝÑMóLÒŸÉ8½ÞÜF–«šúÌhT„¤!>=ê¿âu5<1;QDzgi{ä.t¿Ü”¥8”deUË”ð Y jÛâÃyP¥¸µðJˆ.Æ©7j%&qÂ@m ÒÁ€¯@“é+%Òùtl¶´ã²8z˜éë UÒµ”TM.‘ç ÔmÞá,YŽziŽ˜+HÙ#Ê–Ô†f­ —]g>Ã=«éHø$þ´Šš¦8J@%ŸßØ{.h»õ°¯¨1DA`ì ™Ùô ]UDë¼h{šVÖZ‚w23äUÿ¤¼.ŠÿLúºæ7-8i$xÏÕW®=Vú Tî;ò9R6zQ£í^¾^mñÞØ”Òô9ÿÍö«å?9o…÷[œAÞVíhw¥Þáß ^¼¸TH)©Œòq¸ú//(én¢²¿g:^Óm¦”ôq·iÏ<ŠwÔ7¾€½Ún}p¹Ì 9›`ão®è·‹å-@ŸÏsÛž¾kßÛn ÂTT/ÔCn) Pòâ¾-Þ)Û ò@ÝÃIû€v]woñ5Ä`¢R^u{’”¨â«ŒŒ7¦b:6M©Iä‚Ž?½9kpŸ´ƒÂi}ÂŽw(û Z6ä¥̤ð­w+ô¦âBarQÂRz›¶Û¥¨•°S´¹îàR³LÈdyÀ Ö? ÝEþ‹«¶¦Ò†r\gÞ·ë~ͽX(>þø4³ê3ÿÉ–ƒ/$õ…ÖÿŽk–Ó3SËrÞ„ò°Q”þ#?šê_³ŸØ‘ýA ¸_\bcvÆ3Ÿ§¾ÝÖ‹ñWí¤ùtmÖO ­u¯øwôµý<ò-¯ÜaÝRßÐøs)R±ÆRk³/ßú~ô}Ýè›$5`?VwÿÜÜcöZÁö¯¼}ìyíiaFóq‘‘“>ëé¯M!ô«M[£Çƒ¦-¤*KŸ[«8÷<¥}yðFn†µQ¶8hckð³»óÿÈóúȽbûå\Åï™Ä„lc¬cMN¶Êne†&´ G¸ö®þÓµV*úÖÀe‹¸ÀÏä÷‡f¶)Ds´ö=— ^õ @J– Øãȯ˜µÝD$>•ÑTÔ=Š‰9}V Ïâ¢ÅÑîìŠ É‚T”>•¨ä¬Žõ“¥ÔÑd[›ÐVCJP?cD2¹§-Jšf¸n®} ÔÙ–ù,¡Ù FäžõéÞ°¨¦‘¡ÎÀ ¥xéÆHÂHå}égTóñÒ_úTÆ{jêÏxuúÏ&–åàdù_‘¹q^…%ø²SO6²…$÷þ•ö^)CÚÞ øéWJøetR 9§òI©DÙ!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!~Ì 2‡ÚuRr²ž|5©´€ÕöM“û)]±ÈVû4–Dtªc®d¸Odø£ªœdpøN¡gó5¸ì¢¯U±@Où„a!3òVVçÖ—ŠWÊ|QUÓŸÛêCÊsS¼“ãÚ«ÒIÙ[á:†¥#€•E–O!C5Pu7>ÉLo•4¶>ä%ý)ÈQíPUMÔ–kù*ËZ^·Ç.èúÙo„2TpšŽ¨–yZ!{‰kxß`› c^Áºb›&K®6óÅEJɦÐFÐK0mºÔÛĺ“žù¡ì$ÜxS²ÝJZŽ’B{“ïPÓBÓ—wMôŒ©;R]SJŽ}¾Õ øÀrõMtÔwfH‡´©Ç\Z[y$ŠB|•u,¦„eï îJFy„m.wu3ך^ë¤/KµÝ¡¿ð”¬RT’2œSΩé*Û%|–ÛŒNŠVc-sKNÈ8=ŠFÕtŠ¦$.iî7Q²Ëªô–¾W"«.vOÞ[Çunô£¨×^—j»~¯°?ŒÆÝè-iϦT’Ãï‚jó᧊w~¸›µ•Á³i-Œã#à÷­õ'MS]i¾éV3ä{©-»LëκjëÄûL)»»ª\‡–Tõw#'Éö§ áSõµtò[£3NuH÷N>£¹Ø¸óŒå/q¼Û¬Ô¬d„26€=‡oÉU2mÏ[ݔܦœaæÜ-©$v àŠÕ“±ñÈaxÚH?lui¥˜HÝM)q) ãŒóXi)Êlyò_^Ò)ÜlÃwNá- p«¾¬ƒ}“¶±a¿w æ½ÆdaoCjQJ#5‹œL½9nÚ8Å6<¤õŠQæ²-Û <å#S ¼¢¢@ñJ†ì–k{'(1Ü’TR’R;ý©­CÃvH¼µ¿‰+}Õ)Ig£”¦ØÙj#`ÜiUƒëQ ý_ÒyüQ”ªÉ¼îýhX¹(šMåbÐ WÀõ‘½7dl–`ÝOôå·HIÒúâv¡UÙ«Ãl²,ªŽ¤zFA_Ö—Ò~¢‚Œà§²‡šØ]4û lõÿÅ#‘ÕE¬9®hk_«.ów · œZ¼ÿ¾@ÚR<¬Ÿ39Î1¶“ÆAç<• ŽÛˆØ>¬÷­u.ãn…Ñ’6S$(„­[T°?µDÈâJh#%y!Õ¸ pMx1ÏuŽðš¤¶œnO&œDOuî0p™Ž¥¬­`„æ¤ ;Ø Ö²àmGJqÇÚ½ÒY´áL´íÆ\–[`)KJ À>Õ°<>3ýôE$ßUSêºf‹Ï)ËSi8sbnK2ñÉ®¿ÿ¡)§Nñ¡ëF>ã+ `á@ÕgT2e ïNvF)zžšÇçFr3„ÌÕ¹ÇK”GP´öó1 PNBJAí÷Åk.¥²y’™Ã½¶SöŠÌzBh“9HKåA{r<Š¨Ü,q9¡®'Y+eº¬µÞ”¹•*INå lÀ­Ku¯²ÙVŠ€Â [mæEºS`¥M«vqî*"¨µmŠIÛ4jëÓVøšÔ»sÓ jú=QÂÕàgÆjŽ“Lâ787W'°øÉïÙV/5²[@7SI߇}“µ®Ç"È[îŠ6Õ%E½êì•œ4©4õ'Ë Iàî™×][,>u8Ôÿªp^žŽò_fSAÆTæ±É@ǵ\ºªM,⊬fœ¹Ç¶× ±t@$‹gã>ÙP-_ ¯V$ ØÎ-’Ámù­ÛÕÞÖS¹³R³, e]³Þa‘æ9 ç»ÉÔ÷%ºÚ-×6Ö´¶¥þø­zÛTqpa8çcþ‹bPIM¸Ítöšvuá’ìwVîà2âOÅooºeµ7f?V{…LñðÖÇ–²ûgé›2tûAqÀW§Ïjûhð}µVÍOh.5®êçGP@=×õÇ¥þjLF¼gºqþµóKíàóh §hÏÓ…¾ú« ºZ⸲Û*Då…ý+n>õÅ*§ÁP#%néãF\ÕnÆ&ã!¥DqÁ滣î®òÛ‡ŸªÖ7V€wQ±Ó;äË‚¤-Èäñßý«n2º}!œåU檋; Õµ`éu¹²ÓN´ ™pæ .6(jÜá¾VpÜdÔÓ²èË.ŠnÕ Ú€3z”ªéRÓꉻáGÉ{/v ÝRýE}´2£nGõóûÆË´rÊaØ8-¯ÑÌqõÍW\[§pþkCSÈ[Z/HÊLÝ»rT£ûSØžIÙ­¼e!•ou¥€ïNäN Ûrº·£R­š>2§&+.]-Ò2¤§ü©öþõÕ~õU'Ojª{•ýñ’`=¿%§úþ†Zãåj:nßšì½Σê:j3N %õ¸pÛ~ØÏu}…}ðàÞ:Ú75}×Qq!£Ûò}€\ïÔRPÙœóüÓÀŸöO£GF±Y÷"{»ÚO óŠ¶õ‡†Ôö›_›ÇS;qùã…bê'ÕT`³•ÊZ“ªÏÚ L²¼áÔXã9)óï­>ÐUt”ﶷד¾ý–ú´tsJÚ¡¶Q;¨›a:ˆIp<¤à“ý5Ï—O¥’G-qý¾ŠñOÓ-ó¤à*QÔ=q”ãŠIܬ©J­0#šW—’Uæ'± Päã´¥6à^?z‘4ÚG9K—åE'¯’•cŽi†£•1x l‹¤¶#0’JŽÞÇŠ}O{ÛFIK¾VÄÃ!_C:%a醇µ©é‘~Q(‚ä§éñÙ =«éwÙª†°Qº¦½¦Z×c.#ð|4î7\±â=uîã0dNÓ`3õ*eêšíÚ‚%µ*D›2ÎIPà¤ý¼Uó®>Ñ’[î±P1úèÜrrr1ôøöPVžƒR:s´ƒû«w¤]cnÒa )K Yô¹á#Ån¾Ó´ðI-C…Î:~7ý–»ñÇHÆ˧p7]%¨ú½n…a2%\˜hm9QX®»êÿznÑm7 gkr3Ï’Óo&’¯Dl'eðÿ¯zÊ&µ×s/qv-zAcº°O5ùÛûAø®zË©¦»ŽÀûÝ}ðêÆëmµ”îåRž®Fy&´l+£›“žêUb¿ˆ IJÔ•{ÑÒDíLÙ4žƒXW…Ÿª0âÇJeKR‘Ž o›ñV*(ZÙA.ãeN¯é#+²Ð¢:׬åp zÁ áj9Ö¾#T]ša„ic¹Ï'áIÙº5°n ƒ¸ÞÖóŸR•šÖ°Pá\a·€6M­ÎqÕmâœ:¡8–FÉh}IAœR:áÛ¤æH ’¯µ(#Ç ¡PpI™7R‚g(ã.¥h!C븩G´ƒ²&§aiJvÉÜ3Y“–á?‹•hY™jK [ŠÁH{ÕR¹å®Â·Ð¿PJ‚”‰I<¨'‘ ©Sä+.Ð4µ©_`HíUÉ€aøL$•ÍÎʼzåné¦õ§mÝ/“uŸnfÝåÊsq—3h.­ ãb7}…\¼G¨éçÝK:M¯û£XÁ©äåòcÖáÃIà~Ê;¤™r4®’èF²ã€;7°>åSW gÖi)å8âµý4“žU„D4ä-pœõ$¤`¤ì+*†a‰»Yʘ2úU¹C‰ÅB>>ɹ*K äª + Vj&¢/æy-öW_C©}SéÜ6ÃJ.Þa¡)YúI.§ƒö­µöz¢óºîÑÇÿÔGψmùª\È!´ÔËìÇ/£âu`bßÔí+wm-¥R­(Bö§RSÏúVüÿÔ‚ÕäõìƒÿÛS´ÿü/pþØZsìÉ^élrFïé‘߸p ´­6ߦÃn8’Pµ”äŽsǵp5SÚchhÜr²è <̦›ÀZÁÁó¸ äle}šøA°Û4WÂ^´ê<¤6‹Óæs‘œZ@(R±°’{’ªû[à$Ìé?ê/pa•2yˆÜ¸—GçŒs•Æ^*\'¸õ¥=¦?ü`°{rìüa|©Ö­SŸJå*CÊYqàS‚‡*ßÍ|I™¸“.qsŽîÏ:9÷ߺìÛn4·ŽßE iÉoƒJ°gp¤N L:⢆ԼŽx©E‘¹SÂÝ)9ê‡ØRžSBpÖŽËtUp¤çŒÒSäî+I¦š»  ¥å*Í7Ô›¹‰;ŽúJÚœ“Jµ«&G¶À„äÉ‚”ç$ûW“HÔ”òyc%X,¢ÔÄFBLÅKX#8ö÷Í4žx§^yÎØöˆÑ#Üî<‘ë9€1žõàáKÒûTî·Xvç$µ § —\á(Ï“ö§öêa4͉ΠÔq“Àú¤ªfò˜^?•‰†Sí’FÂF;Ôt²œá.¶Rt )Cék d¬ËKÉãŠÁÏfÑ…¾+ÇR• äâ“‘ØYe+êJ²ofÑþç÷­ÃÕ= KGÑ–ëÔ#2Ï,ìy#ѧHýÉTûeÞInõnü,cüóŸôU ßJSú†ÚÓ,[¼¢wM2&¶”+$m÷§QÀâRÌ)ˆ8üçÒÃR>sRB6°eÉrZê϶C“g„…¥¢T´äœv¬-W- ®u>u[¯¦mIÒv R®ÈNÚ[JÅãUÁ²1µ.ËB¬WôLni1Ó[¯7‡[FB½üè~žêØjã!ŽÈvü­it°KÁ(mîB¥APÂ¥ÚŒ¬÷Q´ÇË:BŠÜË6ÔÄa¢<j­ÝÚ袿ù+¦P€Rrš+B‚ÁqÄŸÅh[Ûšù ÂÚ42;NBl*CŒ+p GüU6©¢2@à­‘Ów ³ËySí.àDÔ6CK'*Æ*½[vS§1Ñç•~3ÔZvEù :Û >•' ôñô»Ÿ F}ÿ5´)ºér²>ì×jx8{H9ÓL™à‚}?PµCo””u¢ìÛëÝ¿æ´é ¶„¥ÈÚ™,‘½µò­sjc©‹ÞgƒÂ^òC°øOu×.Ð𺃦eÈ1Ú[q±ÆøÈIägíßûWÙ²?MGÕ&ú‡`ˆÛ;î3ñƒÈás_ˆ—‡[kšÜîñ±Ku/Ãå±qŠ­0Shýf¶Wø Lø3DÍ{(w^¼8 Ÿª‹hN’Í°ßš¨HmϨæµ_Exit¶ÜD¥ 4e9yê¦ÍËè>ŸŽ¶4ÐJÇšúWÓzŸFÐãÙs]Ú]S*cª7˜’ÃlnVqœæ¹ëÆo Êæ1êÝl~Šê!í+æÕÛ¢£vT†V†·žãŒ×ÊÛǃ-¥¸9Ò´ŒÔT=o®ŸKJ¹tþ€òŒ!I ìwÅo˜³Ó}ݱ´ŒûªEÒò÷<“—IÑq Æ*ÞWŒws­´ÅMîÔO±PWºG,4¦‹~EÉ·KJ,g"œôoIÍQVÖ’Ò~©k•Þ8¢;î®mOmbÕhVP€B98Åm­,·Ð°`c|þê™c¬|õ|ó×óýÎHA#Þ¾ø›TÙ®Ï-9Á÷]ƒÒ”¥7<ª•æÓ¸žüùªdG òéIØ©^•³F»KKrÜK12²;â¶7‡ö˜«ªüª‡i`ï­_ªŸ50d•|!Ò¹Ô²ÄIŒ]ú.î_tŸÚ?ôW‡Ó[Tñ½•_ãÖHÏÐí¢Õæ÷{dúœAÛýýÖ¾™iK¿ß”¦-1ÜÉH;Küðð>õNðk á«»·ø©ÅÐ>2ã3ò÷Â7'òì·Bt«ræ᣺ã;®‘Ô2œ~àøik?QItoþÕóö³ÃûŒ}\ŽÇ|3úºè*KÍ;H‰¼…µéÛÕÞZ Bƒ*D…lB üæªvž’¸WÔ jHœù` ú”¥eÆžù’¸5¿U5¸è+­’r[0q“ôä ØýCáUÊÙIæJÒÓßoïì¢èz––¢M1…Y½ ÷¤­ÆÙg$d÷Q­=’BCÈ[â–1ÎéŽFŸu•úËq·[ñHUS˜†rÑHÇX×z@R;,†­2PJ=°)keàÒÈ$p£î1š[ÙOWª‹ißë§ w «§ÿfpÔÓ‚cøà”/RkYW%4–––¡^MWº‹ªên%¾k¶j•·ÙN‘ÊkµëÛ͘¥MH)ò2i…ªõYHñ%4„8q¹JÕØâ¨ÌnRmEÔÍO¨é̼È[=¶oãòç¸ÜketŸœ~Acnéš:m⌫w$)ÒJÕ“ß½FñÂŽ0’Ô•mNÚ—òÆ2³Àœ¥œ#N9ä FEë ìœ–~“žØ¤Z匸)²[_§ïN`v Ê20£…zŠÎjQN›ÂS åTŒ…5™å¼%Ž…lä jLÌœœ÷MDº{‚y✖±¥¹Y°Ë߯nkÉÞ <) šêü))Úâš þ3^DýRmQI­«³:SÔ÷c*?«$!IÀª¶ïAõÑŠlÊ~¥êî‘lÑFëé'Muów†[¨;°0k°:c«Ùúño¤Š– cýINpXà9½\‘Æ|ÕBwh“!=kòwPW☒Š@;sŠŸŠ_1‹Ðí.ÊqLT)IQý)±”…;n¥hiévèV©M= /ÌZ“±Â³ü¤Žø¹5_¯:²Üo¶ÿì¦)ðæ»;{{¢sˆT„lm(É™ÀÓÊ´BAnÊk‰Pã¥KINîØö¨—µÎQÎÆ¡…ªl…;!Äà¨ÊãX^ÁJ;ç…V8‡’3ßê©œ«;œV)Ü•dsšÁàac©=¯)Ž¥¬’â‡sL[ø°²ÎVˆ’RvàVR¹Ø-¯zm‹2WŒDGØiÍî ‘Ú‰c$`% [Ów¸·7qÎ=«&ÃÙz ÆS8|¸â–T§f<™‹ g£6L¿Ú£-a´­ä¤¨¤‘žø=êJÁ]_\p ßöL.º£Î«O[ÜåÛzsÓ½<«•ºáá*äÛLã|U­å ¥Ãîvgë)gŽÁj¶²¥²ÄD’†4ožòÒ×|ÐqØ}UK§)ã’ãSR#s\4°“À‚ßð¨×ãÎD“Ô)§sŒ+Åjé`18±ã…ucÆZv[­šrEÎW£õ9“õlÀ÷>ÔÞjÍ Ô2M e]úIY­JFZKÏðw+µUåº>Y}Ge S;ÈÎSåñ¨ˆk!*ÛØWµÔŽ.·pRTR;’ª©Ì4–ÝyD%ñÍ)‡8 Z95aGá¸Ò¤§´žA­—ѽ@ꦗœ4¨ûõ«ÌŒÊEªR¿OÔŒP[V;ø®ˆ½ß%‘­–ùk°´·ðàÇñ…R\Òu>˜BŠH>jN™ÒUS4K¶6Y1¬ùj XTââ¡A ‘ÀýU¯«:(Èàæ¿>ÊÝKx n”“UOE…ÄÈ°¹µé'ÅT/¶(`Ÿîí:°7?>Ëdt¨3·ÌpÙjÑ×s¾ÀˆýÁ¸AçÐ…<é;I<©Xç 'µÅ#›ÜÒwqà|œn¶c4î’&j g“ô]‚ž¨ÝlÏÚ-Ö÷™¹AŠŸD…¶BHÁB½ÓííJÒx¥t¥Có ·‡´òîßaÛ•­ÿè8*Y$ÓÇ?}DZ÷IY¹<õÕ¹(òí8IZ2p|f©tÒŠ›‡š[¥¯'#¶7þÝ“‰hšÚ/VHà«·£}H¹hmT‰°ä*Fž”¯F\b£•#<(qœ×Hý—¼{¯è{ó¦…åô3zdŒžFv?QÊÖ#ôd7J.Fâfn×|û~kéu²}¶õ‰–÷›~+© J‡kï]£«m7JhêhäÔÇ€GЮ*­¥ššCÃ-ïÙc€]ob]Œw§54òå¸e%Áÿ„ð–ÚdI.¨àg5 l»WtB0Ѳk_u)»ö„MŠ¤¯’GŸ» é÷K^íD¢¬Ã^c“!sþ±ÐqÜ}ĸÀJT?Pó\Óâg…ì’rL\ùÙmžœê—† _@é£8}7Qœâ´E»ÀºˆåÔÌή~®i }B0ûe/¶Jƒ[†Ãá2´Š‘ƒúª½OU9§-;+Ï¡Ø€ÐZc¡!##ŽÕ½:_Êj¿–ÜaTnNé]Œª+¬…Q!:”‚ãö®"ûZWINÒ}>ß’Ú~ù+æf¥w|ég*Î}«á'Po\ùr»rÇ"iPÇP>®I¨ðì)ò@Ý,¶ÝnxíÎÂ0¯ÅNY®Î¥”H8QõÑ6PTÖë iN-ÁÙ"¶%/UHà D‚¡'  ðTÆÙ¨nP‰yÕ8¼ ¿Øz‚éNL³’÷UêÛ<2ú[ÙJ^×÷†aEaå:¥¥íâ¯*]ãƒË‚'Áø8ßÙ@ÅÒ4Ï“nêu“-ÉSœ&QëWrkXTõIugÞ¦üxÆ~}Õ°Yƒ#Ä=#²vÒ¯EºÝ#µtyjˆH8­¾\á¸\™ÅÙŒ=Ó ìRAu8õ/¤;½ôÇMÛÍ‹N[!J[xqàœ¸ò±Îåžqöö߯èk%ež™±¼Q.qÆùqßòà.0ëUò¶}US9ÍaØ}ç¼Üm+xLŽÛL²â2R8øó\[öÅêûk¿îbhhxàl7Ïê·O„ôu¾[ÎH\ rz;γ„„|ˆ«¹1ïËË©é¢!¸qL²î‰m…¥Å$ä`}«Édt‘Š™ùQ§®`„$œãȦì¥<©Øà0´‰N8s½XzX· VÅî±=²s^$‹0S\íÛSÉìN)Õ8K¶=”t!Å9Îj@¸%Âsb×6QÙ‰]ï†ÐTqø•¥†I_¢—;Ø ŸÙ0šº6~#€›¥E“Õ‡R¦œO(`È4«˜Zt<`ûSŠiÚñè(ˆêøÜNãHMY?OŒç W5öãtΩà5oz7«‚žàzUŽÏ œsïºaz6R¤ýY§M—lðNS”+zTFåÿšñ§QMªêÀÂp™j(g-+ÙhÇÒxý«È%wVJyhMmÒܸG(Z·8‘Çâ *â ~¡ÂEðáÙ&¥#2¶+½éÛT¼Mà¥)Oùp~Õ‰+'Æìî¥V‹MÆ\i ‹ L”²UâÛeA¤ÿ™Dv2i£©å—Sãi-o$€=Éì>ª*²®&à Øed¯åÀ';ñQÚ™„åR¡Ÿ’rv¨|3 8jÒ½µ¿ÿ¨i* ÑVÏNVOhV,©LGB•œvæ«QG‡WÇ¥¹*ǶÅÿò† ¬ëOÒHïPUí-“>éƒð÷œ+Ó¤º\¿âZ¡Øù'ÓI-Õ'ÿ¿µo/ z¢jI¯a- o¶·q“ÙU/÷vÆæR·—þ‰Ó\Ûì–fŸÒZZ#3u‚ÝP“-OòŽNø€1ƒÉ¨¾¦£·Ý+i¬ÖHÁª•ÎÒ㾜†ŸñÊZÚéiØúÚ·á g;{ªÛV_/šª<8—Ùm>í¢*-ñÒ’0GÏæµÕÿ©.9£u|šÝ ~Ì€ÀÉSÔ4pQµßwGê{ªNá/{ä~0ø¦DKTõAÄ<¦§d©y@'§Lˆ Ê™Øp¶¸’[¤Úì9fóéÊÍ…úH#&¼då4yÉÊrmJáX¦¯x {nROóVR»N)»˜¼v›MÚž–òRÂ7¼±µ?zΖ•ÕyMÿéDÜ+ZÖý‚û² j7÷¸‡JO_ø¬./käGÃy>å%Lò[—(ŠþŒïQÜEF³”ê*ƒž6Ojµ1*ßE±sgJK vkaƒˆØV3¸g(Áœ`œU†[H’ úù Z]' á›ó‘ŸOÉÆ ÀÖ–?LØkIÃwçýÒá¶ÃáÔ,åPsØÕrS±O#V3Þ?C)<M%NÎ\V`á`ËÅJì‘‚•X¼ê\>F;Ñ0„Üì„Œ¥*§‡+0Âœž¶Hgw}%,>¥¡¢Oë)ýXû ÓÊ‹l±FÉœ=/ÎÓ”œµÒ˜Ç-åF[sRsíX9›à©$©MžS¶ÕGº…zN²àq¬öR¦žk£:>G쪀H<·pVØ “pº¶û‰Ë~¦ì+%#'=©¦´žÿæ‘ž-é É“gnõ12fº·HÂwg`5Y™Ï/êqîyLaf†i SÄ´±éÄi¶ä?“P†y%q$¤<¦—/…/çrŠ{piå=+)==‚mŸxvL”¶¯niì±cŽ­‡e¿ÜQ³„¤}CÜÓê õwQksøx«jŽ JNÝ“—[#]·øƒËA9Ú2‘œ’Š»tl•N=ØÒ2?ÑPú’Ûå·Í`ÎyQ[¸¡çðVÒÁçŽ1[N’µõ'ʇ¯¼°Ñ¨ðS´YÑâEiåÄOš·: RÓæC’6TÜ÷`*cU¶ëò—'%G9<Ö“¨qûÃõ÷+~t]tmGu§M¸÷¨[þ`YyyJˆWäU®ŸË”HF[‘Ÿ¦Tes,$³ át°LÜ&‹;‘æÀó) €xÿj´õÝ Ī ½Áñœ·Œ1ýðV¸éÇLaoÞAký)ÛNX–Ū=ô6ú˜.a.¥'bé'ñãïKQtuLv–Ýt¸ÄN‡áÒO¿Â½]šùÝKñÇr=×rtP>êeØå „“ëÇ'°ºcþõõì+Ö5Uï³U ³ª2}»€O·²åÏììimT|ðÈ®ÅDFý$•¶…e<àv¯¬´V¸„-ÔÑœn¹ÕÕ'V2šS¶e‡ß¨ÖPE¡Á¸ û¦sãÇ%M"Èmm‚¨V敲4*ܱ8ÔX% J\Û·U#­ÚÒÐOeféÒrB¯ ËJ^HcwšÕôÍk•¾¦•6‰%¦Ü¸ûUþ–ªááVê`s†—Å”ËìíIâ®THficNê»5;šíÕÕ-)üJ „„nRÁÈ?hÏ_Fþ䂶Bß„ ×ËŽ¥èÙÖiR\ ¨³¸äâ¾ ø¹á¥M¦­Ò5¹fJêHªch'uC®W¦âÐ¥ïšÓ,Œã+jy:Ú·0Rû¨Çbx¯töQ5tägØtû´•!§2HäÕ¹:?¦¤|Zƒ9áUn6ÆpJ鮘t÷F^® 5«.2Ó ´îZ@Ü}«»üð“¥/3z‚WhnøÎ7ýV•ëž°¹ÓB]o`ÔU¯¯­º&ÉjrÛaVÜ# AIð¡ç5Ò¾5XºFÙmu²Ì4–·ÒIôžûŽ· Òu·:©ÄõŸû/›:²J×|˜Õ¸6£úGôŸ8¯Š}]PÙ.RýßažcÙ˜E;|úzÒ¶éÌ<Ûò^u¦†yç5%Ò–z¸ê3Žv)Þ®?,±£%_?üGE‚ L@§º«¢j|rª³Ó˜¨'Üã#èµièÓU&©v ŸõŸPnÚ’VéòI`¥±ØW2uw^Ý/²×Ê\=»…´z{¦ièÛˆ›¿º©nBÉh?z¬ÓÓe\©iA'!F$N.üÅ}ªM€¥ƒ@Ø- ;»«?šPÇì”Ó¤m— C1YußþQXGN饃'á1’hØpò³˜Ä¨¡m¼Û­:;… núwFý2±IG+}')©HRðVIÍd WÈt´Û“*lfT6…,$œx&3$7<¨Êê¢Öjjú¢¥ô”(ÖøvˆA œuH×UîUßö¯£>õ›§èY0´‹¤¸üžqð ›zŽžººGJù{ ìÓº©¾$ciÛ½®%ö$Hðç’”ËA>j‹ö¥ºZ.1As¢`cßì0OmÿNêÓᪧ{ ‘ĵqœ;t©!¨Œ­çIÂRÊÚ¸Ö&:GhhÉ+vKXÖ´¹Êa#Gê‹TdʸXîQ#÷-¢K\z"íOÞg§{#÷-8P"óI+´1à”Ïê8•©A>õTÆîxÎËRÙBÜÈ)>ÿzÎ2âƒ/º”[¡6êP®0*b–ÜçáBÔ×€ê-)y$òxh¤³Èb9äð£…È‚™¥é™-åÔ¶T<櫵öYâváICyiÊ>Ñd–Ü@JªûlFÜ¡TZã 6p¤œcŠsM*fžTb4Õ1$<°Bàâ§n™,ÔÜ.³éP×Øí8â‹^Ê­—ÐýK÷°gÓß+VuN6v¸ŽWÔŽ–ëÍj>ÇSrìk¬l=MçcAÿeÅÝuÓžSŽBéW£üÃ(pr’?j´õ/LØÚ†Ö•dú§ÙV÷ûZšÜH8÷¹'ÄK$°Ë­í8ú+¥¦´…Ek8“@-¥dƒâ¹Ï¨4–’Ñ’¶§NÜ ojùñÒx§O]`ÊŒ BÊsž*½Ñ]E%¾µ³FO+©:bèÚ˜L.ß+ð#þ#¿ .tK«×KͲ!`¹>¥„a-;žc_¡³Š¢ÿdd3˘_8~Õ MÈÝ)›ˆä;ü÷_7«§—"¢„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„/Ú{N²ëmÉ#À¯„¯k%}‡q›9¨î¢@%õ¹„loêì*.¥ŽyÔãœl3Ø{,é lmÃ2ãÅfK?ÌÎqŒT3ä-vÉäm8L²¢1 B¼Ï§Ìé’¥ai ÝIm.%©%[NxÍFV7²”Ž]C•»Ó^õdgœ“I‚0¥ã ãMýR\i%\ڙܚtåg7àÈW}¿IXlÖö¦¸Kt 3y·—äê)>ÜӦţtÚÚçz@nH9<œwÒ?%uLó6Ü7¹úª]ðÁcÓ:«¯8´êÛWñ.»£j™8ù¤gékÿÞQB~ù­Ïör²PWõÒ4q‡‚t9÷°Oo}“O«f‚Ë;éäÐð6w·¹ü‚ëÏúûBôOY|Hè«÷OåYbÝe8Ì{JˆJ¢„úl¨÷ I^N=‡µIÁâ…/M¢éº»vÕR=¢<åé.ÒÜÀnwÁßlp©ôì÷8h+ ›V†‚]ÙÙ'óÂà)›e-Å°Œ4\ÜžÜ×,Åéw+qÆ1Ê·`é—ßÐÒõö÷Í¿ql:…~…Û‡RrtÔðÐ £˜LeÚuǶ~ª ×Fº´Sƒ¿÷UœmžÚ@8ûT Nñ•97 n[²#³œj´’³xð®AuôcD@%A¤”û ©Ôj•þ½ñ°ú(öÃè#¹VT¸j:1í ¨`¸ÿ®ã¨F×]P«ØVϬñfù'OŽšl”úµ q— Î,=+«Ek÷ps¶ÿ ¤vñ)r—)N8§”IÜO9­b)Á*êèšÞÉ ³å¥¸¥ç¿=éFBÜì˜L\0D¼°µ¨òIó⦼°Z0¥caÆË$áúFïzÄíÊs•gèÝ;§o¦áû¨šÓe¸«v;Ž0§óójÇ)ßÁ©Ž›¢µT:âu& ,%„0¼9㆜€}ÔMÞº¦67îÑy›àïŒqï… ÊyHÜݪ²Ù22ž€qºÞ ÷¤ w^„²2w«ŸÒiFWäl¬Û4Ój†µ2¡ón ©#ºÿšF:·DÓåS¶ü¿ÝEOqõp7NÄw¸£Ï¾j8‡‚•ós†åFßt­ß©@šqvN¡‰­]ÆÝ£¢ økcTé äËWßaû„!!K2B?ý#rs„´´”«ž HÍwGVMáÃ<1ŽåÓR:šõ lRÆ$y/âmM. 1ãìCyZ:ß7Q¿ªM%tAôMËšü¤ŸÃƒÜÜco|•Å¾¦Å, c5ÁÎnVû„™N¸T® íJiÀJ,TàO¶( ß¹§ÅÜ¥ܦµº‚ç*Ç4ñ­8N™þ –Ë»H~;òÜŽÒHm$ðŒžqX±‡¹J5%£r›ã¸•$£p<}éIÝ,¤Ð‘5)iJ%´ä€{ Œ¨”3tÎyNHS"<$%¤à«É¨)Þ÷î˜H÷<ç²}MÕ- %.qÞ£M)'p²Ü¥Ü|”ç=éAhMÜÝ–&2ÂKÀçóJÆìœÔ7t…ÒR²¼å^ô«\sºqÆê6üVV¢ëª*Q>jM’‘°N²’á†l£n=©l¹Ã*á¶Ü©»Vù0Q r\el>é(P;O”¨x?ju e¦’)˜á“¸ÁÏäGù(j·¶HßÂo¿D)yO„d©œsšék!.mA•§.CÌmØ*žt’ÛªiYQÝž 8êy!d`r’£RFàD–‚ÊP3ŽãÞµÕ]—ù»iÙ])+Ì@ò‘e†cNn"R‡BržõX‘Øv“ºØ6 ™*&cdvÞÉïH>ê_*+tûÕzôÌå½–Ûšù8jìKçL»c°‹yÄ Îh'Åç!Ϲ!X?ü¢‹ÕÞ‚JaDß.hÙ¦NÁä‡ü’¡¶W6®_¼îÂì°çÇëÂ_¤uMÖßi¹ÛÿÍi÷–ŸYŒÿÚWùÀðin™ë ú{|–縺•ÄÜìø€÷íŸdÛ¨l0MPÉÈÄÍÜ{.—èþ¿r6¤°Ú¤OŽ¨isùyÀÂUÜg÷Ïæ»ìÓâôÔ}EEA4Íòšì7€îFæëJx‹ÒM}µ a#É}MÑ $¶Sí_xOR¶<†;cÂã‡P—n´­Ç;‰!Þô´2É0Ëû¥C6N±VR´ãÁÅYmÌ!¥§dÂfR+£NLAd€¤½2ºÒËUüŽÉÍ „gPP5ØÓªV´š¡ÉÒ/‰Çl«S.ÁÍÂR"­< œVrй Fpq·<¸îa@¦«45ÒN]ÁÝ1­‰®O2™nàÁC˜VOÚ¬72âÍîJŽ‚WDíArÿU´3cHÿÓ6¢AÇÓšá¿<lñ¿Sù[Ç z±ÑÈÜ9|ÛÖ½7T+ƒ…¦mð8¯=qáýM¾±ÌŽ2ôþ˲ús«4CS“%ƒELT¶Ô–žZpAMWl}%UU0Y-ÈÎÊF鉬åu}‡MºÄFLt–‘’’Œ×tt—L:ž˜6•¤c¶3ýÖŠºÞZùvàü¦Y±onkq,Èi$g Iÿj«ËGsŠêé4¸6À sú)JZŠi ÒH)¦úõÞTu¾°¢£på"˜õÍ]ΦçÈFØßl'ö˜©£~ÁT®ØãÂQqÍ‹s¹W¹®r›§ã¥ËœàãÎUú+‰“f¦iÆã'ÓJ‘Ïâ«ïêÙ XìþŠF+n³—(EßQ•¶áC›WªnST8«-¨ d*Údõ8­ÛŽ3^AO°¬Q@Ð0guä©GyIz~ÈÈá;l`$»ÚRˆO?|v¥tœn³s@ òÍh‘w "KŠ B@äšòešFà Kœã€=ÉQ· ¶C‘ç +ë7A¾´ü;M¶ó«ï0_¹:±¡¸4=”®ÙüWØŸ²ÇØŽÕ,W®¤©kæpFÒÄO \5â—ŽUoôÖØÈ`ÛQÛ?@ ŸÝ&ÑöM>oºx4$ÆqJOU‚ŸõÍP~Þ>ôå¦ÝüZÅŽIüGÿ?…að3Ä •MGÝêÿ —Î!Õ=¸¯”%Ã8 «sqºw·[ç4êJ UœšÏîò†ÔÃB@Ãm¤ä'ÿ­Bß®7+Œ­ó oáh઒¶¾ Âw<”§EA™mKLW#²Ž@ûTÿEôÍœj†;ã÷Iß.±» ÎÊ×–âa9o”ÊÖË€¥[üÿzèkk+™¥~KÎrº¥K$Þgråæ³p“è$¡çñjÑU¾Ìꃡ¸nNý•¾.¢‰± ò‘&ÖZ’ø©j/ ¦Ò^wQ/êF¸à'»mà´ ‡rž2;T¸±y  (Éê‹÷aVÞžv,­ŠsQÈÁïOéh '.ºc,òc9V°"¦8[A.äš‘¬¢ˆGª<Ú*—êßeQê‹\Y«bRÛ‰9yûÒ]Ou dz×=­›íš:Ñ%-¹?*'œ }Ò6*iÁuARrÞeÒ–Ïém²C]An§õ²á?ª¶L¬ó)H;ƒØ{ýuDÌv™8Oºg§€ÉeºÀTÀí%'iÿ÷ªÍIá´®k3u{ ¿uuê 4¸°ãßý—VtÆåtÓw”Úîaiu$`ø#Å9·[ªì×á÷u Ƕ;}V–ëHkiÌѯ¥Ú:âÍÒÛ¬qŽÕÙý'PjéD}»./ê:GÁ1ÂËPÛRâ a5¦‡CÒW¨nͬ.0–Í‚{®3 Ũeõ#Èð2j¿{éŠÊZ(n·Ì] äo§c·8ùNrŽYä¥w³øÊ»'Ï+¢Ð?‚ωKSÌè…Â}$å* ìR8«î²úz´Òi,q3;»ü.ÇÇû¨:(ÍæVœiØöTìÛ"¬·&ƒŽ¡ä)´ºžÇ#<z×wzS ÌäàýFU¢)<ædìžlLÊŸsm °ã«$„¤’O° ºZ—ŠZv—Èý€$Ÿ`;”æ ¶KÜpžLfm®R£O‹"#Èám¼…!IüƒƒP UE,®§©aŽFœ¸GÔÂaKRÙÚÈ÷[mVǯsš‹l²V \XBFHÏ·5í¶ˆÏ3iÚÒ㌸à©ìœIRØX\àOÓr­3ÓG"ǹºnv™ŽÄx0¯IÜ¥ÅsÊýCƒÍ)z°fJöÌÇùoÐt»9Øœ´÷*5—ÀâÐ摨gŽ>ª«Ô¶ËmF ýi'qj…Û•- CÎ¥p´Œf¥Xtì§e­ t4%8VîOqHNü¤äN¨RÐI€Ç8¦g}–¤­¯0Òƒj‹Ç•{b°ŽCÁ^jË°†ÛRðœù¡Ïy+p2žl¬£ñLdz`Ou#K/¦3SGÔÙ%<ØûRo„†kì™Í('Bv·½§±ê'/g1zm-khFPúŠ¨>0œ÷«%ª+S­õµÏ#G•¤Ó¿¯Yí¸Ç)™eKj#€Y¾¢ym|¨+8+%YP'^y³9¹ST-˜6ÆTÔµ.S…AÖ¶‘ŒÞsÏ1^TÅ”ÇÆò^s©¸Ø{{çöLÚæ‘°Æ Ž:ð’94ÜFž‚’©Â{‚+…êÒ·2'ÅfÖî³kV›Äö¯”TÖÐÂ$´Iým«²‡ö©ª›d´å­™ºK€pùƒù¥)¤dŽ!‡ƒƒõQ°âÝx0<ך@ \ð¼;Þ|2ÄvÀ ` •ãœ2TªÛl áO‚sƒQ5UyÙ©¤“ï²zrxd˜R{‘ßÅ”ÅÛ¹cMH\2奻‘ ÚŒ“Ú³u6Ù)GÓSõ±HXR»}ê6¥Á¡6¨n…5Za„,'jñ‚}ê%óœaDºB‘K»4Ìe$ë>=©Í-6]ºôCÔBUÉçÛ„ Ô´tí,ñ¥3;!ÂFõ(ä✵ƒ²ÍzéFXl'*Ï÷¬ÙzÇåMí2Þµ¼!Ö‰J”•ŒƒþüTh¨,;o¿öMê!,¼5%M¥$zjÀP#ÊOoÚº£o¥ò\1ÁãÙj®££f¶ª¶ëk%Ũ ‡I85t’µN1¼p2«­~•L¤$­µŒ«¤xª¤¦6J`ÆÞÊf€µÃy†–´e**·}¡k€åZ-u²5Í-;„ÿoˆÅ¹Jy‡±”…¥'ïã5@¸±çÒõ·­½LgÃ4«Ï¦H»ß-pµ»s—%b:X@Ê*8|Ò]'nš[Ä”ÐùÏ‘ÚC.'€>Sn´Ñ ç{ô5£VOlr®MZÕ½·™6Xh¶åËÉIák¹þ*GÄy©¤«c­ñˆ°Ý.÷ï¿Ýk®œ–g4ýåÚ÷È?ÉóAªÀ¼Ã¨1nñÙ i@à©i9ÈûÔŸ@ÉK1 ·MD`œÿSNsõ*3ª›,8sNcqÁø}+éV´‰¯t›¶ÅÚ KBOõú¿~õ÷Cìëâ?Ztìu‡ÞaôJbÝ÷ÝqO]ôÔ–«Œå¿vý?ÙMÑ:GªYJ|WBÐÞdtÿv#Žê²êVéÔ¤1ß'iDñšØLp¢&‰,õ·œpjJ ‘«W²DG€·ÒêA8ÇŸ½:š¨H”‘yi^³´«!°RMGÅon­¸X¾­ÇºpM¡µÉoÇ곧é¤!Änš}ýÃbVÛœh(Àð)£¬LkO–Ñ•“kåCïÖg%GPRñì*—ÔÝ%l%²€¬V«c²wéͲs‹ù¸©*öÛØû×"ß¼ ¦«Î¨‹?’Ú¶Þ±ž&ÿ-É«¥¶¸²³ò¨P'9°¦Ö?(è¥?È)Õîç’=Ü®kgLíªŽ mùÛ]3`ð6Ø`aÓŸ€µµw[LÊjín‰Ç-…¥<(ŒÕ;Ä_ -Ô°#níÔçNõ\ò< ìWë‰öëkŽ4Zh¬Í|Ÿñ§¬(édtZsý—Iô½$³@•Ë:§P4ò•èa°<× uOS¹ÿ’0ø±ZœÀ5n©û”×]Ï=×0ßz$:Rí9*£êïPŽ´gø%— •…:¼çy€ûy­3㯋óõPú=àÈ.9ÎHáZz+§#·ÿ=ÿ‹²¦áéVSéߨ¼ç&µ=“Âæ’×–ä«=gQ8“ƒ€ŸŽ›uIKG`ö«`Ÿ5@¿¨8ÊLä©N\J@ñÍHÑôÅ0:\Ù5Yá1ÌþÉËACǽ?NÐ7ùŽÂpÊÙ\8ºÊ×l*ÃÍ{N©.´”»FPúI¥)˨qBÛiL¤Õ´r:—«b—,ixÛD‡b j{2½L)+V{Ÿø¦×ÊPìlS‡Z&Æ2¡×c8ôÙ!@qÍ5ºõdQå¬ å‚g9DF§ùÇR[9ñZÊ÷ÕÑÊͲ­ÖЮÍ)÷RÀl©Ng€OjªÇÕMahfä$*-å¹ÈÙ^ Ü¥ÆR#¾^ÓÂM=kê*cp¥~]ÜeYw«`Út%Òÿ!Ä-+e°v•+Þ£:¡«®óˆ›ÇrT„÷È)ÎUš÷F.0-"v,§„“Åt¤ÖPÚÍQiÒÉý•b>¼¦–(r°´t¿QË1ûS0’d`«ði÷HøIy©MAêqÁ)ÅYÑÂðÉŽ>TþÕšRêÚ.Ö{”TÂ’Ñ þþõUÑ}Aiªh­§‘™;´5=抶ä<ü«®¢²Í¹ÛYSêDÄ óõ'óV¦ê{}¦(â&h²> ¢UZ*#‰ä ´®á鞢e µ8 œý«rôMé´¤Ó‡jÇú.^ë{3É×…zÊlHŒÎRFjO­mª‡\g9Zº?Õk{¶¥Äî ç±®@ë®’lÍÕÎʺÚëHØ®t×zl¼Ü•÷ü×)uE€ÓÌö;ó[‹¥oE¤ ¯‘_=Ô¨,“ ¦Cn°â vç Œ_ÂÞ¶–ÃuŽhŒ캖ÓU}§˜j`¯çÓñ‹ðÝxøtêÞÂäWQ§Ÿ}k„áNFGí_¢ÿüQƒ©ìñÔµÃÍjæ¾PøóáT½5uv†ÿ!ç-=†{.E­È´J(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(Bý«0qÖŒçɯ„š\ã¿uõý ±¹r¶/º6M†××Þ.#ë^Ó°+ü¡]Ž)íºJ:À9Æß;÷JZ«ùpà~¿š†Cuq¤ ïÛÚ¢æ`sTã¥Ê·Ïj$k£ñ]jÄún(`9Žø÷¦SÓ¹€jÕÇÊ}ñJHiÎõÒˆmCÒ¨µ›"2îP¾I/-!jŒHÏí$}³WþˆñR÷Ó”u”v·ýéš ˆÉh<éÏr23Û*¿{éZꈦ˜lÃœ{ªu¦×~¹ 2ôýW>µ“ØÉ­_lXÜ+ѨŒ3 Nzª¦ öTm8f;lB¿”_P+Pʈã$äñNî3S>gš@DYôê »8Û?DêݯÉc—8Òo|͹n’êy=ªŸt€µÄŽ æ‘ *äézôžÔW^ë ª–ˆ×¶ä; —ÓX^âܬø5°ü8½Zí7:+Ås‹ü©54dỂs¹À …öž®² ))›ø›Œ†çÙPºÿP'QêëÝé%E¥¸ð¸ Q?óU1#¤s¦w/%ÇêI?æ¶3b‚8¿ÂN¬Þ¦Lo¶9-ç¡Çl¥–Ô¬¥¬òp)³†RëÕÉúIêó“^¶4£BD¬K˜JõÍ'…‚g6¯P­GhIíïYcÙeäÈôâ¥nB†)û ”í°¹Z&\¥Ë- t!!ÉÎÔûaNCs¹)ÄQµ›5nˆÛŽ'jFO½6™Á»¥$ ÔŽ+,BKn¹µNµFK#žtŽ'½ïÈo Ùw€îRŸ|~kÈh´òžRÛñêrmõ—œçŠu¤'€'H€—ÓYŽ :u3„ám;³žj veFT¿²p™pQm„ œç·µ'9å7ÐR‰ZÎã‘ßäxMS^ Âv‚›oŒãŒ‘[æ›Âúí¸‚Ò=DœrvTê/皥²JÀw#+Æ ´éI ²üI’ƒé9”ŸØñZB‡­­Ö¨§gžßC‰ßŽøãÕmãhž½…ÍyÒw ³ëƯ±Ü´<éqvE–Æ6€Œþ?5®>Ó%[n1,ðoOéöW? ì5T×&¶MÚW͇5ˆDÈw$=é;»kŠÎJ¾ä×ÆûÏQ™¦e\gÆç¹]jËV b-ÙvHº•óO2¦¦ ð0Mm®„ë—Í#°þËIõ÷G5±ŸJúM¤5w;c R‚ÉšìN¾¶z?!Û¸®3êC ˜€–\ã— œæµXÙ¤¹î&´3àaV’ØÜ”-%Œ`ñ\¿â ŸXa^lõ¥‡9\{Õ-™å¨6×4],¾SœñÛuÑ=Ô¥¯h%~KÿÆSáM­Q ozŽÙnÿóX`ÊaIG$§$Üf¾…}‡ü_uÍ”S?ÐïIS~>tWÞ›Æ3#FGÔ/ÇC­©§ÚÁJ’pAñ_m쌅ñâXËZîB×^¬BBBBBBBBBBBBBBBBBBBBBBBBBBBBBíJ7çvJT¤$ƒŒã8¯„U“–z›Êû $eÃOºíˆ“m½LéÕÉë›ênñmSpmÒàJh ­n+ÜyϹ5z¼ÜYy°Šš§k«…Á‘´4Ä’HÛ#=Îùî«ttòQWypå8džäû.FºDr3Ë(ý!]Á­YM #Ô¯QÕü^ã{Ñ°!²ÙtB;BrRŸÅa\%‘í|§-`Àø·F÷7»Žß* KP!ÜîûÒ”»yR83 ``T]D9NZ7S[]•éò`\}ON̵CªÆJ”ãø?µJô¥® ºø)kåÀùÇ;ü!Îý†é*ë—“ËF\Ö’¾ú³ñ þw>ŽtÞÝÕ~œj•jí?òŒ¿uaÔ†×Ô !mcõ£êz믵wÙ"‘¦7»Ž–†2 ‚öäéihÍqärÜÈãCøgãŸñªÃn¸G¢S8Îøä¸Liè“õþ²Ýöl«ƒ ¼•«jJT 'À9Åq8+º†–Ý8’ÈÆóΣ€3óœ-óWwtT’Ë-i?¢õ㦗ž˜õ&ÿ¥.v·ín6ù[hZq–•ÊHûF)÷Xt¥m‚íSg¹Fc–Aöå§èF=´t¥æ¶:¨œ‘Û߸P{Z='Z°}ýÍQ*–”îgö*ÂU½ÔAã§ù!`àý¿zm?;n7L ¿…¢\ÒüvBŽT„jlKžòç)jhƒF½¹É* €Û…³Øã½GÔÓÄSyC{ò¦šgX^tÞ©²j[4Ÿ–»Ûeµ.3ö8Ú‚“Ç‘ÇïÍ?鎢®²\!»[^c¨…ÁípìGQØŽÈ)½ÎÏm#é*–<GÕtZ¾!õwÄ©ƒ¨µi„ĆØf:6¶Ê3œ'÷$óïR>/x«|ë;¯ñ‹ëä hhÒÖ´dà©$“¹Ê¬ô@Pôõ¡ I:‰'$ŸŸìªçå:†\y+ʤ‚?jÕT±¹åY*Ãzµ)ç–²9©°ÐÑ€¥¨Y‘²RÚRT°wx“ì—“ áX]<ÖW~Ÿêë³Óï˜×‹|„Èe^ Ÿ±ƒö&­]×ט½SßmnÄð;#<ŧÜ8ÁUÃr£’‚ e?ëõ—Põ»âOYìjÈÕ®E®ÑmyùˆCÒTúëØ޳Ϧ ~y­‘ö„ûFÕuÄt´Ÿwòa§/xn·HuICS·Òôƒ’Ѷp¨]á´69¦¨×ªIZHhhÃsƒÜçsÝrEÁõKÔ qÆsí\í@[$“%­Ï œk'8± àÜs }^iEÜ#á} éoý¶ÃÐË×Uz¦›u¶Ù~r=šÜ¹±Ö¥ZZuÔÿùŠvòpÀN9šú]dû:Pto‡¿ÅzÁÌŽ[«¡/Œ»îŒ’ÙsœëÑê-ÀÓéÁç ÷Š3Wu-€ç:œ9î #ü÷Êä'¯öm0Ö»ÒVøVmKj–ú[ru¢gÒZ¶ºÊ¿¤,x jàóÔ‘Ûèî:h㨂g·L®oóå8é{#àM9‘ýWÔº ¹ÜèÞÐrÀvõ³¾‡ƒïðªÇd¨•ìN3äUB­Ó¸Hžt%kPÜ8¥ØÌì•k ŽS3²^yI Èš~ÈÚSË#pµ,­ ¶xq@Ç)Ë¢,R‚GŠ÷9+ÁÝ* Ç”dÍ',ᣠ$ÁÙ=‡„©ÂUß'œS×HrQO ¥9MNÎ/(ý_ëOôTaƒ+•©Á5éh÷JHîÉÖ*'.söÅ4‘òe)l¤Q™#ê>ب¹I˜‚­¨½3ÕÉÐ-õ [•ÿK.áü5.Ô]Ù»;ÉÁNîÛ±*ü ½³¥YÖNŒ}Éò˜Ï«PΟð C¸ÔT‡õu¿ø¡³—?N¼|gûŽHì7P¶°w/%9ò{V­vVƒÂDóÄ«pPÅ*Æl€R%¿ÔïN°^gt‚YH)h$ù"œÂ6Ü¥X‘ƒû°Ïâ‰pè{vÊ~n&SÅkW°¨÷Iì’ºvv)j&öíõïJZn&*óÙEÜ"20ŽUt¹ó Î2R½ šé~“»ÌæcµUêØÈÎ@[žuk‚ËŠIJ’0F|f¯RÎãq纪4BƒMmԽƀsë±ØsZ·ªâqü…w°¼R—¸ò£°ûä °{z×÷¸CݘÿVÉè؃ê©,Ó3LYIÚÖì”ÿ˜{URçsK{­ÕWB_nwÂê½AfŒ3b¼ÚSß eÏ!£÷)Zj6»§Ü-°\˜ÒXâö8ãmLÁçå® JÙî²éijÜô;p¬’ëÍ5Èîž½é(—×™}Õd¨¥o0âFS÷Ú¤îÏ|è |S ¢±Mm¶:q;ç1àdm‚t«œŒ‘¨uÿH×KW÷Újƒpà9¤ïùƒ„¹B:Öˆ‰¨CC'9àVˆŽàæJ[JÇO¶3°Ï;v)Ë ÖÐe;ã¯r»»Kj™×í'fqå­©id0è8Rxïý«ìÿ‡Þ!VßzzÌtÈÖ5®çhÁßÜò¹V÷aŠ’á ´œÍLl6››òAZœSy9Ím>èºêšìœJ®Ýn2< Š¶“k’†’BJ’zêÊkT°Âwº¡ön½ } NR®p~Õ|·¶xù)0ýòŸm‘TÚÛR 3Ú²²tC¡p|g .¶pF °â8¤´Û‚¼šÜttå‘žU>xòršAN‚¯zT‚˜V·=,a<šõ¤…ëI #­¶Pwö¥Øó“¨ävv ‘ô5£Šz2á‚¥#q¨^¡A ‚Êð{Õ}sosÛªþ¡±VK<¹w¨.\ê…’lØ„‡ ±Æ;ùÝö‚éºÊ7úHƒîVôèk”qJÜð¾qëK%Ù%°¨ï¨nÂx'5ñs«,— jçÃRÇlp2;.Ëé«­?“¬¡ÎiÙ±Ûõd°óCî8=–®&k’2ÈVXï1<éaÊhR=ßXñÍEd)¸;…¡r‚ÒQŽ;S¶ÊàY¶ò¢óv¥ÒFÚ„’Ï0ðSay àã¸iIº­Ñ® eaYÂAâ³lC;¨éérp¸tŽ¬ùS€¥x·¼>¼AM |Ã;ã *¥æÒâ4·bœµÎ¬´]e6ò¶§ nVB¾Ø÷æ¶\_hkØ +4½¾Äïú’¢¬ö‰˜ã¬ì Ñíï­µ8»´d½Œúdœß°5 oé×$tÃ>ÉÍSµ;N½ÕkyÕ ‡%èn:èp§š¯V]ߌMÈ!LSYØöêD%ê©Nÿ/ÖQã•v¨i.S;ú“–Yš8 p¸¾è'ÕQçß½/÷Ç“’Sö[‡ey×Q$«>y¯Kó¹O©­ŠáÓ7•G·G >Z{ø«-—ª¦¤f€îê2¾ÉëÜ)†²ÕÇ44ûÇ>a”îþ•Ü}êË{ñ:Z»ÜÞíY þ‰• ˆÇRÙ˜? ç;^‡jk¨i×ÃJQöÎkY/8 ñ=y $oÚ:e¥ö6Û\7ûT© gÿ”ù§QTÄᙉǸÆ?B^[µNs²“Û,JÓWV#…%ô!AhZF7§ÇA½øÎ;¤P%a.®æÐWøNFŒä·Ú3ùÅt—†=gLèGßxnß_ÑiÞ¨´É¨ˆ»«ÙShSM¼ÜŠm8ôwd‘äæº0õ¾f6h$Æéø÷ú-Y%Š ÒÞ{«WBõ•LffíŠ;k¡ü*ûJÃÂÊ<¿ùﲡõ_†Æf¹»¥=Zø‰ˆÃ™Hm, ¸æóÇz{ãÛÝI4PѼ̗aÙßð›tƒïs^÷ÄqÂùûªºéürñ*{ª[m)yBHñ_4:¿íC]w¯uT€é' lº¶ÃáäT”͈r/¯ú©/Q@–}d0¥nuYý`vG뫯4¿u9k Éß9öWKK2šO0r©ã’J=2[€­j×—aª÷éhʸz}{rÃuŠÞçAÿµLYëþåVÓÀU.¢¢eC _Xz-¬X˜Ìt:è?¤šîo¯pV?/vÛ ˆ¼Jé×Fç…ÕÒC­…ÒFF+sõÕ_Z…‰Å®ÂÞ£Ê±æ¹ ­-nò7jµ[eõ*^FÂy[A m5Ê=g&>Ëkô¬úe¯‰º9‹ÏOõ+R"¡Æý‚ûà…ÊZ;Äg§+¯¬NóíÎãûð¿_Yì i¾§ëk; 2Ì÷Bì ³õ¯Ò×D\MUª œw-Ù|fñbÎÚ ©§g³úîªÚ´­tŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠ¿i^q•§oÒÚ¾TF_e›<)ݲ÷2Û/­-:‚ÚÀ$nÇúT<‘œzvJº±#p²iH”émåíIçß4‰nÄåXÚRDí5j¿°ÚPëZJUÆv$ò~ôâ{œ±Ó>6“þI`5,øSLlLLÇþ¡±9Ú”ç'>}…A¸Õg/õ€¼n×0'æSâÉ'ê $Rn–c›«à©m¢æôK|ûRœPŽð q$pqÚ™ÉQ+ZcÒâ2=ñÂñ‘5Ò‘ºï½7ñé¬ä|4/áöú‰SßõQ7÷8)hgÈ žÀ é.®ûM]®Ϋ×JN\biË[¿$` ó¤~k[Cá/Pì[mÞÚ%r·Î*fë„Eº‰-;ê6£úAÈ$û×'²¦Jg²h‰aln×+cã$µÃb­Ž¹ubÙÕý%£/7Ä­}I†Ñƒ:Iþ çÝ@dgÛÕ¹¼VñMX(ëê™ÿ~Æ–JþÏhÇ–Oþá¸ú,:§d·I$QmuìO+šmF.×KåÒ°œ£ùóö­?8å\ë'e?[ì–Ë{Î ?IÏõb˜C§S³íû¨Ñ €Œ¾ß`‹{ŽÉ‹$!a?Q#€¿lÖPRkw¤þªI•Æ!‰—Û4õÖD8°- ªásVô†“Âö1ƒÞ³é¾‡ºÞ® ´Ú©Ý-CòC»°3œŽØç8YÕõ%<¨™á±·’xájjÆÓr›n¸Æz5ɇTËŒ¬aM­'îÅR.tŠCƒKšH#¸ àƒô*Z™+$g-pÈ)æóqSDp3ƒ±j9I#üÃßޚdzQðÄ–“Ýu¥ƒábá?HtÚêóÏ»ÔÝc%NÙìí”%¨SʤÉà‚7ÀO9®Ìì™4–ûE $&ïsÕ#cØG ;@>d§ÛƒØàd ÎV¬ŸÅ–6¢¯HÓIHsÎrçžÞÙü•Õí9§´¦®§tÄïã6øJùg§ƒ”K}?­höFröË}{mµÐÞg ´KçA Ð$ÿnÎpšNtl²zjº¦¢‘“Õ3Cž5i<€xçªþ6ßPíTIO²š‘Øì¥AåD·-¤©ßÔ>Þ)ž£ºfù2ì•JVTF{ûÒĬ\ÐNé͸Î!å '=é 8^ZŸ´”ËL=U`›¨#»2ÂÔÆ\šËg u€°V}ÊA|ðº÷Akê*…É¥ðE+ð9Ò×p;ñÇu|¢¨¨¡š:WbW4†ŸbF˱~,þ)%õQäh)qcÿ…ñmqÌoCÕ)N¼wúAÚn+¢~×iº®¹»¾ßC6«TOŒiÒ\ì­Ùõj gnøÊÖ~ xC†/¾Õ3þñà‡uc<õäž{.~NÂIY šäH¢$-þÍÊF¹jH$d°„wN£h'tˆ»ê¹— ÚiVŒ ð p”ÅŠã«Ëm8 2sX½Ø+Ü´~$•à¢³ôãµfмJãÅq×0†é9$Ǧ’]€œÊý&¿—…p99üSmܯKŸÄšCËt¥Ì‡{`Ó¶BšŒÆ^76°‡ ’¬óÅzú‚á•óŽ£1Áú‘—1þ”Ñï÷Må¨ÁRˆ @HÔlÏÁQÓJHNH>™ãÕÛî˜ü5EÕ¸BÞÕÂ`‚“¸5ê«`9ÎBsŽô¸¬¨òÄ>c´‡QÇéœ&FšýzF¯| þ¼¦977çSÉ÷üÒB÷Y7na|äî¥Cõ$2HJ@PüS–Ä1’•fÆ{8˪)}ë{5-0¤¶¨‹y@¥8@ûwU0o))r¦q¬Ï>@J1÷ÅAÉ\™ŽSš­„ˆö¶T¹Ï8BÊŠ y$â—µSTVT6v—=Ä$žç²汎•ç hÉ?E»éùé²âÌ&æÖZu§Û([JöRN?c[§¤nu–‹ ¯Œ±àé-p-sOÈ;ƒõU[Å,5TßxÁÍ;‚7óQØñ_1V‡“……‚úè[\’IOªA¾JÔW(„nÀQI±šdº„»ŽR=óÜUfñCÌ.Àî¦íÓ‚d²P˜n8Û¥¤àî8È­w}¶3ÿGv çþl¶O] Vëw|ÅKkwlqZêàÒu-ÙOÕ0ÈÌ.¼éíÅ[nÚfë‹­…ô–æÂ…íôÔR~à§ý¢§º/© vù¨j"Ó°ù¥¤ã„¨#aì°ë›[ñ×Ó¸²Wú2r3‘ŸßõVZR¬/_4ÔE"âÃá_Ë9VÒ8üŒæ®ÑøtêÛ#îVˆñ,nÎÜàí•TS諵Îô8w÷QÏ4—”ÓÁGzOƒZ bÐ0CÚwø#ýÕŠVeÚNã²ìï‡=KlÔnÌ°¾¦Û–ÚC¨lYþ¢Ð×Ö?°·\[/†[-@ €= W³Ÿ§eÍ~2Yg¢ ªhËIÆ}½—uXâÅkjÒG8¯¬6XéhÞŒerÕÖw¸eNeAB£ÐûÕê¦/:2Æí•V†¬ëܨˆ©`’2 ®ê-oŠ 5ÅZ¢ªIa¶@III­ƒo€ã”-CÁåI’@Jyô‚¢rVädžü ð¤$$³.)€Ò#"’yc§œµ-˜ì^ÆC…·[V=ª«/]ÐFý%["éI4å¥xu\¡$•cÞœ?®)K}'tŸ˜;”>á|nKÉF@Íj»ïWBÉ´<îíÕŠ’Öæ7)svhWhå·R #ö¯E’’á Šqœ¦Ï¹KO&[ÙRzףОSÏ"2ðJTÈ®Iñ_ìáI4…ímðG+ftψ²7 .\;Ô}s²|Ði¥ºÈÜ9ò÷ÅÏ ëlÚÄy{~}¿%Ô]ÔTéÔpW&\¤KaKCîË ¤Ã°Bßt‘1ÍËJa]Ó !DƒNÅéë"Âf‘=*9>}Í=Ž”Ž†ŸÙ499¥¨{y§­§ ezêr•Ilœ£$Ö^Q”‘‰*bââ[Ê‚3‘K·PÁ ø[Ýd.e‡P°UŒóRt—Æì¤_F׌±ûÁ)’0{äöduöB0Û;aV7éˆprB£ÀOöóMe˜ÈíD)ÊJFÆÌ™ ÁÈVi<{¥ü–{$j+)Á<÷¥Ã‚]´í’`)E=ÿóXšÂì¡7*9þQÂ}©´“7ßtœkŽ\—¸©€•©e öñMÚp†Æà'«iC¶°9ÇziRâ7 ¥C Ç€ò–ÐŒî5U\âÐìÉLì”ôë¦[é{Œ„§ß¢k«L®É ››€§V;»ð†Ã¥)#Þ¥,×7Â4ç¦SSµÃÔ×þ°ù®¨<^”RR”ç¶}êáXº‘¯{N\Aú÷QÙ„Žl ÃW^£úå žG5®_wª'iÁšþ¿ü”fá{Ÿ9Ç%ù/©]Ê”Ni«Ëžu9Ä“îr²ž67 hF/IVÆÛR–3€)ÌLÁÂzú&)±¦0s!‡YÏ )$T³#-„ú)[ý')eªNHJœp¡¬ŒàrjNÐé€w Ùd:rºïAéÝtb4iðΤ!å8x>ÄWaxyÓ½1p†:zØ¿š8q'œ­GÔ× •92@ïO¶Ni«4k"Ù~Ðú‚­«ov@>ù­‘?BÓ[¿îè\@iÁnÄ~«M^î/©•#s¸+µ´Ô‰ó-ŒúéR†ÐGšÚŽ ¯ž”jas=꣜éX^Ûii)Á¹ÇÄ_ ×rVâ Tž©a2"ÈJ‡Ü×õ](Òìw[:Å>™ùñ/£M÷NÞ¢)*P[KÍk¾–®’Žº9ÜvÊëï+„Œò½×ó£ÿ>•Ýz_ñ­™mÛç>eEYç?Þ¿Ig.°‚ïÒð9‡ÔÁ‚¾g}ªúF{wS:¡ãÑ0~[.­î¹•!!!!!!!!!!!!!!!!!!!!!!!!!!!!!~Ôä°€ãjÇ×Âä'b¾Ê±¤­±¤‚¤g&±’-”›èÂrõÊmEXÁày¦ÞQ#e† ›7x•& ˆÚÔ–»ãߊˆ|e¾’vI¶ƒ«º´º*Àž @³jì›ïä=‚=ÓÏç³<.þ5Ñ”w M4 µØç?Óûá@u[çm/™Oø›Âû¹Ò…}?tÒW¨šF6šº QnoVågsxìÛõk ü ¶3§%£·6a™¥®l ;çX-ƒíŸÍseß®&Š±“U—Ýò÷\ ñ¿ð/ ÷Í<í‡JɃ§Þ¶²d>Ú½FÝ“æ(NÑŸµ|ÖûVøEMÒ]E5ª'6Ñ0‡nA“pýòq¿áo :ñ—zG:YuHvàÙq‡ðÖ­¶[UᨪôÉR^pçyá>ÃŠæ ¸õ1Žh?'¶}¿E·éä/˜°œü$¶;ºKò[K§Ó^rœñLg‰Ínt­l8)Æ+6©:’Íò¹MY\”Úe)Œo ¢œùÁ5#ұњ؅ÇW‘©ºôãVœú±³ŽþtÌîƒðqž?55Ö1´nê=Á­Ü›Ž™edEL”¥¸Êç¿<Óþ£šÝÎá`¾˜8†jä·Ÿ”“¾‰†¨!üXãòPk´‡j›'°ª}<~­%LÓÈåbt&z’ãr¶zÏ&ZA|$rØR±ö«å‡¥r{ãÉkK¶ö¦·Úà ZáÁÙHuîh½Qkk‹q—CçaÿÝžã÷ª…¶¬P\Y<~¯-ÀýpR̈ÍNæ`n]ˆŽ¤tëI@kâJê96Þ©®-–ÌÓyn: EÊyJî¢T ”<œ×MWõÿOX¡wYtµS™|¨qh‰ BÂÝ/{µ ˆíßñã XÅÓu÷ Ž¾ ê&Ny>§ä4c·ºãÔ]§j;ÊîÓefD‰;ß}\œ©YR¿rkŽ€óªA©yËÝ—8îrNäþ¹[n³E8Éãúÿ÷{ñʯØL’EæJ0\xö]íR/áá×M\n]iÖö²órsrôý•|6Û?åS‰‰ö x®ÈëûéðË£)úvÒÿÿXºÄ$¨˜8—GÿÇl‡ÔGôãJÛm竺†Y§Ú†‰ØkFÂIG.pï§û®r湑‚yk*p¸¤Ÿsçó_>¼·4àpº05ÁÄ“•µ•£)ÉÏæîxªqvvj“cµ™Ùkp©°pŸ£"ÆêN–O)2q§’´Aö4²u¯u㮩jRÔ¬¬œ“^‘•Àðœ­Ñ‘!ZHQšBgà`ÎRµ¬ú&TøÚ‡2áB™?Í©——µO (%AêÇrö§–Ëꢩ9¬u;u–¸à¸d.Î=²{*ÕUÝ‘¾6àóŒÀÛ;û®”$œŽ>Õ\>¡º•)cxZV·T ©»Æø 8åiÚ úÏÓJ€°ÊÖ6…/a Ë(H^â¡Ø÷¥˜miÎVÈéÂ’’Užþ(yÝ,„ûØ\X[‡ œÔ|õx$^ü©Ì3  ;æ«õ¼î‘rsvü†Ò[NqŽ)»-Î;•à„¸ãÝE^º¸^KèSI9Ʀi ,ü'>C{,ç\äÝVôÉÒ¤M–²·YR–}É<“ŒSá[1¨ó¥qsù$œ“õ'tÚJãÉh¾À`~7­s>ˆ<þõØ/N$ÀZ¨)LrŸª®o±Ù2Ñ‚Ç#ÿ…èÆÙFR4$•Wê)®±=´ ÿ(~£5@½Ì%yh-“ccK*ÑÑ×øL¡¤Œ)â<æµ5öšGlxWšV—úJèœ9r¹j¨ñ­Ì"L‰(Te2OëJÆ<ùíM:Vž¡õ̤¥n§É–cßPÆ?ç|)N²l[Ì“œáÙö!tF“—s±N›:¤H·Ò\@à¤gŸõâ·ç…³O•ǨÂÖŒm÷ýu¨:‚*âkÞo•²ë¥`Ì’ú­²›GªC¨'ô¤+Áûæ«][áÝ(šIi¤YÕð3Û>ùXÐ_¥‰€L3§oÓÙ*éåz?SÛ®hJR’[ÿ!8?èMGx×ǦºššãÁ’¿Ä€ºC®-ÂãBøq‘ŸuõšÈûKK¡aM©!i>àö¯ÒeŽfJèêc>ƒ¸ú\£ ¹¤n6V#sY[[J’1[KÏŒ€ýXT×Ó;VSL¦yD´AWÛšc]&:ÚA*F ‹ ÐÐS) ‚šJŽGÂxÁJ¼‡,Zœ þÕ«œRTuÿÎ"E씣NZ¤Qä¡@Ébj}úODK LÈ‚B~¢6‘ŒWŽ¯\³†m·•[ß4›9.4žk__:’Q¨q¶u±¥Êœ¿Úî¶÷ 㸭€ñ\Í×Ý9]E }7á-‘h¯§™¸pL6ùwRéõ”¬ƒçÍQm— “žuž=Ô­]<}*iY¹j)BÊϽXañVK{ôIÊ­ÍÓB j -ë©l>Âqä ãœUŽ°ûC5±½Û~Ik_E=ŽÈ ™5ÅÕ¹Î8rÛ€ƒƒšâÏ:ÐVJé‚ Ýý/Ba±\Ǩìð_qkv3xÁ=…r¿QQÁ?,Á xYîµ 5Ê¥ºèØRw°Éî+XÔÙtc*ñG{sF ¯î)öò–¿˜?aŠk$ØÈSð^Á­” 姮”¡°4«*CvvÊF*Ö¿ºgLi­«JºV—{†2¤VöÒßÿ¤ ¬k­¹Ê©õ ’«Ä(ÎGÃ;T?RM=þQšwM"~‚«9ªp$(ûT„+tÔ´¤´ÿ½:k°”H_¦°‘Î;Ó–FQ…µµgjƒ‡de:2ãd'qçÅ2–28I9©Í…¤¤`yÅ5pÂi#7N1XCË)'hÔÚI°2°ãr¤ ØýUåÊÇ?šdú²B‹ž¬AáJmÖ'j½Bs܃Šbð÷ àã蘾²6ŽT­›CêÓÁXñM+œ0Õj9Y4ÚÛQ mAcÞ°‚iî‡4SÅ¡¨óg³FBT  ö©K}+$©dpOoªm+‹Hì»ë£V>ïð}O¡ìwfp¤H¸px¯ª_fŽšðòWÿ ½Ú¢˜ÿhðK³ý±û®dñáÔ oÞ(j\Ãì1Ý2üCôק:ø3t´_Àe‚m€©£ß…wÇûb ¾Ø~ t‡I:ëMÓä:03‡í'p?<…%àÿW]®l|Uäù¬ïïù.)·Û 1}}¦TÀ!HÝÜÎ+æ¥ §ŽâZÜ–glòº&Ybßžë¹úy :q«¬ÿÂ5ÌTI…!BQ€¶Ž?RWý*ö5õ£À/ zB÷lû§S7S%±oήZGl} 殶êk½ækaÚ{ð~î¸Ç¯½c¢Ú‰”Yï‡QiiYTWÖ‡Y#ÿÕºó°®BûS}œâðþëmµ?x£œe„ìö‘Ë_‰œ1ŸaÂݾõÔ—êRê¨ôL݈ƒò?ÑB4溴µLm€‘•sÎkJX:°Ó¨‘…z»Y ¶ Êé]ÕDÏ~¼ û½AÒ¬ A×g-ãpýë_ø·ÑñË|#Ô2ªvš¢Çn¨;Ü%(¾Ú‚“ÜWÍ>­´É罎ÂÛº°+’ú§¤•Gò‹€Žp>Õ§n”‚@X ? ô'P5Žnø_ŽñÁø^´Û½D´[”nV÷L…7ϧý@þÜ×Õ°7‹:¯áuô¿oϲŒûTôs/=?÷¸Fd‹.ü½—åŒq_`É¢”/BBBBBBBBBBBBBBBBBBBBBBBBBBBBíš$<ÃÉÜ•„ð=ϵ|žbéá}—*<ï©b™ 8Ïj~Ü:=IÜn윒¢¼ßµ6Æ[öR[K®¥–ÐV¢p¹¨º¨³ºÉ€R•ü¼»|´<â‹!³‘ž MF¶l4î¿-²Œ\t7â¨Z SYî j™ñ¾UäH;ŽðùF0•ÜÁüÖØè/¶ ŒUñT» är8Òáþ~j™Õ]IWLè\ÀC¶ú|¯½÷ωNˆõ÷¦Ö4kÒÍ›ø“NÇ™ æ „n®Ù8ýëêEËÆNƒê^Ž+󴶡¯a¦¸78Üþ¶üð¹žÇÐWk=d†€ê #ý{ûì¾ü@i‹^˜Ñq°­(²*âû‘Û'sŠIì¢{`+äw[tüVújxéöÏyn‰?M—^ô}c¦©{¤ü@Oüù\‰§ŽÌº·6ØÉ­opÙ]kVT¦Mµp§Çy+y;\B“Ý #÷¨8å1˘ݸÁÈìS*J€ü´¿º`Eöd»ð¸Éqr%••©J9*VrI÷©?XP}\’}ÕôÌ1i+c_鋲lï­åÚS’úѹIÏ$p9ãj³ßºf¶&²àèÏ’C}cv’Fq‘¶{|wU»Æ'Mäêõ{wT^’Õw#|[D· ËHRpv‘‚?Ê ¹éÿ™LòÇ`ŒcÈüû«mUs 2 …Ð]9ê )ÔvÛõ†×»\šj49×µ@'*ÏÈþÕíŽX!¥š…Ñ1ΛKD8NHú÷Øì£/V‡Écy g-Ôœõ7MuM´I‘"Åq¶ú~ªj^l7ž€|gšŒê>…ª´äÊæHÜgTov;o¿ÈN-7êiF×4û‚´éY¨3L™°Äû{-+s+QHZñÆHÁïÍV,•tðLg«„JФç¶ÆþZ[F6§p|Rýum®·Õ:ÙwŒŠ¸É{Ÿ¬éo¤0nFŽÇɽ‚¢*–ª#ü§ ŒnwÉØnUw&Ôä7Ý,.+{A}°J2F@'ÁïýP¦…À=M‘œ~ªn:ŒŒ;bžôՒᨮ1mVخ˞òÂm$’qÿŠ{Ó]+[y¯ŽÛof¹d òS+•lTñ:yNFW`õ/áoXt‡@iýcv9}ô%SK ÖO 8ç“Æ|×Lý >È×^‚²Ó]+©ÏÀ~“×é÷Û߃îµ'Hx£Gz¸II-'#ÝP¶×&¹é^f¡É+Zýƒ¹.˜ßn½rõ²9Áec†·8–´nNqÎþœä|­‘;Û“8•¾‡›!÷¥¹1â³—åŸr Ôln8kÕ¹Üç?žwRæ±²‰HuKc=ûøŒq©JPÜn›žnFÆÔê ?¤ø?½<Ó¥LÃ(;wM¬![N{^8ó¹K¼€ ýCÐ_…ˆ$ì–´Ú—´p|Ò.xå'5[ O)È­‹sd\tøš€éÛѺ¥!Ç`™—!×Ü+YãÀð)ï–0ÆŒ–Ä…0+íyálCN­A)’q&³Ž7=ÁŒ'€Oqh˸Wþ‹ørê6»²N»iË3WI 8休! ÈÅ$‘µ´’2¥` Ý]öyên£·Ë]gc$tNÃãÖÑ+Gw–8‚;“€¸êí6ÙS´‡pì$û9'° ¼¹Y$ékÌ»TÅGâ<¦\S.¥ÔnIÆR´ä(qÜpkG\é䤫}3œ×:7–æ’g ˆùf¥¯mL-™ †¼gqƒƒîà§kö«•¨.’®n3,­MFl6Ò9@àµ'Ô9.5’×ÎÖµòÖ†·?  Ù!o ŽšÂÒN‘Œ“’qîTt©Å¨¸º‰ €œHàxYÍb’^z›ŽÕ+ÍdW¡¤¬{œ!\g½dÖû¬Úßt­IÔ’~ô›å,Á'8±šNÜ„äö¦“HJñäáIc2U…ƒQ3I’l²–ÿ§ü´ãîkÈbÕ¹I–¦9.6Få,î*F6)XéÂo•í RŠ{‘N4a(r{Ž}HþŠH ý[½©‹ö~Jg+‰Ý6ÈšÛ(A[…;3ž1]áÝ÷E7óŸ³BÓSA™2uY]¹~d<âÉ9<Sw#çÊ&*ú§ -1–Ÿtúé$`çÞ¡'h''`­¶™NANִň¦ÎÒ‚•g)5G½G—9l‹ 2Hðcåu?F.qZ×z&ø éí ù[T¤´IVïÛµ%á…ÂTÛêkA1G4nvvÛè¤|C§’[=E6ÚßÃ{z´œnºÁµÜµ>¢~#®[­îÜ\ÇiJ'í[‚Šš‚{ýt´ò: wÎýÜh9Çì{-]Q,kx`Õp:~$$ÿµ]\[HNô´èþœEaÓˆÓT[ qú’¿+Û´ò“D$ã!A4˜”.W+|dªc«BÔR‘¹XO$þÀûW2ôÅTµ“SQ4¸áîA8 Ü»ò«eõñù,šOHøì»Aõ’R-–›dÙ ù–I'•8¯®}¨+ª¬4´5&H†œí“Žë›ú«Ã¨ü÷Íô»uÔ6­MóðÚx;¹J8®òµusªéZý[œ´…ÂÉåJZB—[î¥jN…­Zl÷wù­ÒîáW«(03…&RÛu¢Rã{ñäÖôqlÑmÊ…kKHPÉn—½¹ ©`ò«VW¼Ç!s2>UŽ7l·5tZ‹;V®Î FÕuÞc N;œ,BrÚÅ<“•ŒUöÝ}qü@œªÅM6’pœäEiÔ(©>9ûU°;#2Šw©õ-z‹ojTø­kÕÌ„¸Âì²Èâ5p @ajÃd%íZ"ùn€ÿý9õ|+cjÜê ª­Oª3ÞŽíüàŠæ¿l“2=€äðU®Å\Àð×.DÖW©Ö…HjK$ÆM|åëΡ¨¦$V~« ºnÛ@`Tþ ÍT’ׯ„ö­&zÞWpïJÙ°ô»2ÝÿP.tæÈI÷÷íN$ê7IïJÇj vÁE¦ÝVÛ¤zH=U'»<Å•9&Ü&—î{òw}>Ô˜¼ËŒ5Ç ÇÝþ$—PðRIÜ~ãµ2š¹î9qÊQŒsxÙJ¬WNÊl=xJÝÞ8Bûæ®ýIo“×q'€ ¹\*›é‡÷Mš«LX-Ž6嬨Ä^@KŸ©³ùò>ô‡WÑÑA;M‰Œöw ý{…ª¾ª@[/#Û… \6”6€dþ’¥<ç£stÔg”@zpn„l¥"»;‚ \!^šÀ>}©V]RÿÆ䦋†Š “œ+ÛéäW' Xîí)•Ý*úüµGö§m»4ò²¹£w$Š²IŽœ©‡¸iA^׊U•mqØ/[‰$`R3â±30¯Gu'´[ä<êR¢¢xÅEÕNÐ6M*¦cY•Ø=3éjVÓW Á?€¤µžß‘[Ó Å{>ùPAÎá¿óºÓYÕB2cfß*ν[àÚØ1¦ÅBZ9BTS‚Ú±Æ+`uU¢–ÞÓ̧lãƒð«éä¨v¨Žãª£rˆËï”lý\`W%6égyv[#È%£W)Þ4ˆ2S’[C›Ïa²ÕÓçÎ3“¶R2Ç ü+T›Ò¢»q´ÛrcÕ’rT~â¬ðô»«àuM %Ò0°öøIýú8ž#Àî•Xz§Òâšôèr‘Â’rª›é_E¹í’¥¯7;Ï8Mî ê–é`ÁÔ.¹ _)†‚]Ø6…žT}Í3ñcÆ[§ULÁ(Ó„Éù?)÷Jx~ËtdÿS¹U4RãW4MRC¹P*H=ǵi‡Bðñ'qºµKm:4“€W^éýYs—mf}•.­AÁú‘öÅvBx‡tuni/hàrŸ»X dÆ:ƒÏ~Ås‡Z5ì½JÓÉ.:¥°éR‚‡ecµjÿüN¸_ÚZÂHŒb¶'Fôì4€ÉüJ•Óš2ñ©f¥¸O5ŽêqÅmJGÞ¨öK[ë¥E€{’pÕ]kŒ=Ã+±ºiÑ+”eÇz=àH{…/êB¾Ùñ[÷¤>Í••ò¶hfÛƒùò™ê®¿ˆ׳ç•ô‹¡óåElÛ¥%MHAؤšê M]!ûŒí-x8#è¹ÄúHä>t{‚º‰â¢Œ¬sŠÙ]gŽ FGŒìª­CµºWŽÚ¸/ÅNš‰Ó:FzO¾Yê ªÕÆWe,¡ÅàóŒñZjxâpvœ¯¶:Çy€g âçøˆtNÑÔŽ—êx®ÛÚõÕÆÜ8 ÛÞ¦|7ëj¾ÃWѸã¾?UÔ0]A%þ¦Gêóuêþ…™Ó~£êÝ5µ6¸SiŒe¼ý'ûW軣º—Kd5Ñœëh?Ÿuò'Ä®•}–÷QopÙ®8úkVeEEEEEEEEEEEEEEEEEEEEEEEEEEEEE_¸·íà;곂Ÿµ|Ž§m._h[« ¸ºeÐÎŒj^jýo©¸LÔ,EôíÌ4éþd¹R׎ÈÀñß5ÔÝ?Óýþƒ«»Ukþ Ѧ&‡äeΰvZ®åvº¼tÌ8‹>¯¢àY,ÇjLˆÉ HBˆzæ†ÈâÐãÝmébØ yÒÉÖ›&¹Ó÷ìîV–ß q…öWýÁýªÓÒ7š„uW„±79iãqŒþ\¨Ký,³R¹»WWStLt^¢]-ó[6ûŠ½vÒõ6Ù9ʱۿoj­u=š;uf 󞦞H}Ò¶‹‘}9ôæíùª¶ýe6©‹rØã²"4¿¥Ü`+j·K<äägb¬-Ó4 ?“Ù_:*÷'¨ûë³u­÷xŒµòñùÿÕÛG¶9óV¸©Ÿs†¢ª¦£°7K{ÉÈÀìú¨J† Y#…‘æ3Éö^õ©.šË¡ç0ÛnÂyEnûŽ¨ ý‡ûæ¼êŽ±’ºŠ–ÖcÓ÷|äŸÄO?IØl ‡Õ4ç_ì¹úÚÿ¤ámCèî>ÕIž-C!Z¤9+°µ‡ÃSô?L¬=JÔqm Ó“’‚×£5:ØRrè²Þ¶‡‰ÿg.¥é+]5îìØÄ:t芮ÔÜä–à¢äñ$1seä€R•óšÔÍTe¥n¦àð¾¨Ã»i][ð5vÑÖK´ ÂÙ!3n‰àõn“÷òÐÒ{„!$óþµÞ=SÔ–ÛÇ‚´ôú†À(^ âv5M#Ÿœ³|én¢I#°Îöº š.±530¼ÈÜ4ŽÀ7ÏÉ_*¯ö—­7'c¾[.%D…e?Þ¸qÑ:7ŸÈ]âFä+g 3Ô½b×Ñôž•Š‰.1 û„å-ÐÚYˆÊw:¢£ì?r{VÆðÇÂzþ©«’ PÐÈXe¸à7ßÜçoÍBu—USY¨DÕGÄ5½òçp£_>ZûªØ±ÀÍ•#Ñp7¹Ä4‚¼'rÏl‘Ü÷­7U†f¦n#w°$ž7;ŒöÊ™’ èãóN]ϱÊu¹·ÝmQCÁâþôŒ`QuT"8Ù‡g8*«=I–m²oÑš–~—ÔÖmIiXjéôÈŽµ „,v8ûfžYïµ–ª¨îÑ4g-päu3= UΧ”e®Ø«–ß©ãk_v¼UÊ]‘¤l“è/ùˆN$û(ƒ<Ôuº¶žjá=ñÏ|g }Cœsž ÉLji_MöÏó !2cŒ½&Ý ÷†µãœ,v’?ý³UŒ81§ÓŸ×Ø©8`ô‚þWÓÏŽ“[¸¢ê™p ¶Òw[Ñ%Ä¥-'œ“È ãûý«ê‡Ø3ÂZÿ»nïkd ù!ÎhùßpZW1xçÕR¾áÔms³³°7 Å·[µ«–½ 5´[6ÉrKèK¡ICdý ‚œå8ýë›>×¾?ß:‚àWˆÄr9Äœo†· àŒ ãßuaðƒ ih!ûôGVZHÆýÎý×é­WrÒúŽÇ€¶U*Û!2b‡„8“JOœjänŒëJëÒ µ½ÀOµ4úŠÛ÷KDUÐ:–|èpÁÁÇî¨ÔõÙR L÷]qçV8 RŽOɨÊêùj§}]FòHâç2IÉÛêTå ½±‘·`òR.˜Þ¡u ƒ¨˜«Í¶Ô<-ÓK­N ~… ÿO=üp|VÄð¯­[ÓÊkù…³y$ÇC²Ò7Œg ò&}Uhþ%G%²7˜ÌƒšpGÈ?ó*9ÔýgÿÄ_©õ]ºÁN[%K\„A†Þ# û}¹Ou­—L³·Cü¶¶æû9±‡}YÉåUlCALÚ8Y–0äj%äp]’?æ0óŽÊp­JÀ?j¤µƒejs–ä%)OèÏÞ›¹ä¤õŒaz²äí^5¹Xµ¾ëJsúMg¤ezº÷Ð[ ÷½zde˜sFÉ\H…÷’Æä!d€2p3â±ÝÄ÷^™ÞR‡2+¯E} eÔ(¥IPå$x"“šÇñ‚~dnjS 8âÒRáMf:BIü#Ì€0œƒQ>žé˜v8Mrq´’à!DàS虓²qNÝGG$¿¸«nUàš”Š, ©6C+lu:”%II)òM`ö„«Ûº}jCho¤Ÿ÷¨çÄIQ¥Ã|¬_i™-(”çé9ûÖáðÕ°Ô6Ji9ÂÖ]ašðöð«‹›G.6 FÞGþ+aÕSù@4vTÈ_ب•:µ!.‚‘öª}dÎÓ•jµà8}5e®F=ýê©Q9s‹ˆ[ï¢ØÑpº ¥wµé Cd¾ 7!1ÝCŵŒ¥Dò<Õ~ß~}¾ã Â6‡:' î69KõÕ™· )8Ô1»U\ìÙyöW‰…!ïghÚ[ H$`vú³Å]ü@êËeEUD”gÐ÷ùƒl¨áÿñgè¹êÁCYJÈ⪦'¾pvý°´i[̧`¹pKLI”Ò‹kK£;“Žÿš_¢º¹î¥}^†¾FäáF?s„âùm²ù$Ó¾ÊíøOµÃ{ëåÛ»ÝÒ-‰äÅorYõIJqÉšé?°‚ÔWVSyÓÇLö³¸o™«-ÆA%àmŽOºÕŸh ùb§·S Dq¾Q«|gN1ÛóÂç[ýÚFœ›Ý®°”¿é¹ž0|µqÏEu4ÖªÓ²0ì;¶7ÛŸÝm6Ñ2ªŸßl…ÛÝ!ÖÆmì²¥…¹·ö#Áq¦lg| šæî¹±yNóB¼$^‘nB^CNÙ=« îwöе¯.“ß²×ÛLçÈUî°×íCˆ¹15Gå °•`«ì½kÞ¿ñUÔÔþ} {_ ÿö`OÀ<uk°t©{ôI =Õ_«Š’…+·¼8¾C[¨ÎvÊÑ÷úBHpS© Ã.ãž l™ %Uaüc+–u¾¯E®KèyÏM '?Šáª>N—©„ê ÙsÿS­n!Õ yíÚ¹+Æ =[ÿ–rüì¶çCÜ Û.A½éø ¼Z’2RHã5É•ÖªJf–îÙ]o¹Hü l«¥\@ô•ý?ëP‡Âµ:–¤\”é%U›`îWŽ§ÒºÓb‹5 f\addŒãóš¶Y:rž¤fy OÀPµ•rGø•º[Ý9q[y/Œý ”=êénm4î„@w÷O)ßæFF •[ÏI´•a}‡æ—¡¦˜åóÙGT¸o”ÿ3M››¹°Ãéä$òäø«ý!UR}oh#·oî£[s1ŸK ¤œ¥[¤»@ÚêRG¶*£=‘Hè¤sN ²DÃ3CÂKó¨VȤ Efh°2S”i¨J¿V)»ÚîAI:”c+cëC©çÒL{³”ͬ-á3=!e?QóOÛ)N¢y%7)”r Av¥„„p¦ ÎWCaJÓHëêî½›$î¬Í)d¶ªteJK‰Éÿ5í–He«k*‰ÑñʬÝ*dld5u’ÛpµÆb]¯×¾vä¤þÕÚ}ižÝjmåÏaã#ý0´­ÎºÞY> '¬®’.oÈ€ iÊpà_8ûöªïˆ÷Éëe}1ÀÈ܉?Ÿ÷Sý7BÈX%ý/ÉS$¸É$áDk ù pR5² E=[n[–ËN”x4«nÄG …U(•Õ=2ºG´ì’¶PêGƒí]Áö|êÖÛHÍ+JõÅ ªrÀp­n°ØzqÔm1ïà–ëF­K*q™‘PS‹#Ô…¿zìoáèN°ééj #!¸’ÙI-õ³³ÜòµÇBV^-WÏ4¾pZíð·²ùôAõ‡ wkäœÀ0»v*–0§:b]‘&:Êõ•v§vÓ5’Œ´û&7¸´q…uÛïs4ãˆb9ÛŒ).$m*öäVÛ ½Ëe¢›b7Ϻ¢VPGT g=”ª®±¨^UÍ-4Ôð]ZGýÓŽw{šñ ©bºTýñÍþiQîçê¦zf›î±yyôŽÞ™Àed7!ç #!ŠoáË"’¬ùÄñþéN¢©pSWÑž”Ú¡GŒÒš’â#dú…çAçQm—'uíl¯yo«ã+¢t;—{zs ./œÿz‹¤û´·—ÕCIü°´ïSÊÿ»œx £Ÿm&:VÝŠºu•#_M¯Ø-;Ž¬*·Q(!KsŠàïÜçey³·8!VÓ^iæC£iÍÖ@Æ“2¹ÒÆZàZ¸WâÓçeºCCeI[j Ï<`Ö²©ºBfká'gÓ~LíX;oñnéŒ} ñõÖ$pË3ÛXYºx?Øÿ¥}ñûukî=0"䳡\öÐévÓ]¡¸4cÍË…òŠºùqJ(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(Býǵ ²Q»%$jüÿ>-Y_l<–ÊIJë+Õ¾Ït´Û&¼Ìy-”8”à÷þõŒõítq¼µ®ä{¦¡ƒÎswU Þ,”<R T·&¤hæiÊ“ zRè²JŠÜu%Ä£w'Þ’’-ñ’ ¥Ï+»:CÕ.ÀèýÿKë+*\ÕF(‹!î ©A>ÃlÖð´øƒÓÑô„öJÊ`ê£ø_ŒŸÅž}ñ¶¼¸týqº¶¥Ìc²£îš¢Úå¶u€×Ë©D¥c&¹ÁÒ;@ÃGê¶M5 lÞv7*¥>u–bf[ä:é9 IÁ©ÆÅNMNÈ-3ÞºNKÒÝ[®-[–¥òi´­ 8÷)V³G læÛA’21Î{Ó*wœeÉ`òéxúÛXõÇL½r™sDVÜvœp¶”§öì*fçr»ßZتæ2˜¶h'†o¢¤ýÞ–‚_5­ Ôwǹ\çymØóžC©)ZUÈ5I»@[2ÞC™•ai”Ͻù[Ù»D·7òk’²ó›RæÁœó{S«m¯Ï2´ÈÒüXì>Oe[0…í~‚âN6UÆ«»‹œöLvÃiôÐ…r €Æ|SÓ •ÆR1ÇìSôQylÒJ³zCÕÍsÑfõUÏA\DYw‹Cö‰ød,¦+ŠNð i;@È÷«?Nx…x³ÁWGl—ËŽ©†96,<€HôžÙàáFõK[î’@êöjòœÁŸêöMz sç]™!¨s ’„+iœ‘Û#'òjŒbkžÚRHfÙÁì?m“»õÀ5™k@ l§ÍäE– F/z €¼f î {£i:[°Ï²§X!/þaî£é:\¦£jbÀ¿º˜5˜«7OÜ™‡ Rä8´!Ìî ૆5RÒ_ qÝDÔÀ\ñð”Äp2¸3²—wØÎ|ù¤ tŸ¢NOPÒ»¯ÿ¶6ºMbÒh°„^š*Zä![R‘Α÷''ï]=Ö_hjj @ÙâåãÛ`Nç’µ5?DÊ.rÕºL°ÿOù•Ë®ón2]—*K²pýeG$Šä9]—HrãÝlØ" hcv ¹Ç³”¥*#⛲,nŸCܦö>Z#n=-j.œ€óNÝ—à5IG&uÌ~RÐשUµ;ŽçϵJQÒ0¼5Çí”ýž†’Ljk7Î5¦º/Ó#ê6ØlM¹ÜQ:aH.º§fÎÔ¨ñ€Uæ·×RZà»ÔÁÒ]$DÐS4½òãH’BÐe“¸Š=ÚÌö÷ZÂßs4ÞeÞè4=ç o%­Ï¤cüNäýp¹ºlfíÒdÆ’ã/:ÛŠBƒj I àíPàŽ8>kAÔ@æ¼ÆÒ2ADZîÉ•o›£cºmzrŠvGIB{s^GNîOéàn­ÒfØqÅeD¥F”2Â’c1°NÍ°ßÓê/œø¦Žy,ËÃvNHa.gc{RŸ4ÐÈG%xé‡bœZaM£„ jnçä¤ÌÄ„hmÎ=¨À)ïuëMúŠ t}?sÞ½'²NB1•bÝô)³X­—ç5FšÜ¶ò#D™êÈk?Ðëx<õ5uê.Œ§¡¡†±µÐÌéZ¢2KÛžÏ $wý²«7§O3á0½šN2æá§äînßé$¨’{U +gd¾3öö”D˜K}Cÿêmæ½o>­Çè±”¿¡÷íïµµ¦ Ž{Ómöá'©ÝÒdºÚZ-wó^9¤œ¯R¸3Du(´ È#k̸nŽŒ;b¶H“&å)OÈqo<¬nRŽIñÉóDÓ=ĽîÉ>é0ÀÍš6Oöô!¤ €MBT¼¹`ó”àâÓƒƒÅ6kr™¹¥1ÏqR1äT• ‘¤a•ž§¿OÕ³!Í›ÞĆb1ÑPÊV†‚¤ W´ ¨ò®ç5rê>­«ºÌÊŠÝ:šÆ3ÒÖ³ÒƆ·! p7<“¹Ýae¶ÅBÇG 8s‹Ž§““¹$ã<džÆëÖ§]RÚjLe£Óu§Râ}¿ àƒàŠ‚ús£¿¿üüÓêÖ²fÝ`Óf\¢Âe€½ÛT±„çïíMã 'Õ²læ8[b%Imm•ŽÃÿ5±¼:©,¨xg$ *WEü°O )¨"­hK‰>G±­ùt£šhš÷ðµDnÃÉU„ÏQnìS-6¬ûfµlNn\îº[40wA¹4ÚCNÀ=ê³4ï/jÜ]'Q#6ÆÊòéÕµÛš À£fÐS¹\ŸÚ©—Zrçèf2ŠñrÐ̸/ îè)iøzÑšx—oÖªù½žž1)2@KƒìœãíŠëþ¶è^›¥ð’Ñt®„²à[>ÜzÿœpÎÇnà.Y©ëçë ª(pêa£9þ“£–þ|ªjÞ‡'¹Ïeˆù¹)Å‚œg·Û¸ÚËM=Ê8ívèÜfËr qž9Ûe²êÜ!¢©ÃFÃu(ÐZªó¡/WñoxT©ÐWÄÆuIV@'*Hî'íÍ^ü+ëk§NOWKolŽ–XÜÒÖ=ÍÆÉs[øƒFNü ¨­°RÝi¢óœÝ1¸8jþ@ž UßVeK¥¤]Ë…kBÛyÃäŽÙÿZ£ºº¢®vË;µg¿ù©Þ›¥Ž)LÀì­o†½n=‹®’”§Ÿ5ô[ì½Ô¿vŒ:C?úZ»Ä‹¢Z¸ú¯¯d¶ß© ò’’‘R?hÏ¥ó§ÈÕW¤:dúÂâ-M¯®ÏIYmo6ê”r­Ç¿½pµçÄjêÉ}$ƒõÊÝ”8šÀ ªÖ— j ¾´Ä÷*âžGÔµ´nr¦[gŽNT¿Gušd9 ¥ùkB²H榬~#UA8{ÉÀP÷>d­>XÝ}.è¯^-RQ8¢¾‚”zú‘önûFÒ0—c€sÁ\Åâ†Òœ¸5w3zªß*ÏóñŸmÁ³$3_J£êzI¨Mt.ÔÜqŸÙs+ì3GSåHÏ©^¯ú×X '§šÈy{0‘îqÿÖ¾2xéÔ^¦êaÓvfj’SŒ{oßûåvBÛi-–Óp¬8 PŽ¢ü7õ§:ez²eÒÝyˆê>Ó.âÛ<Àªg‹?bN«é+ú†zˆçd{½­.høÈñð§:GÆ+=â·î11Ìqà‘±ÿ5è]êÇ{¹*F¥\‡­‰VÐ^ÝÇîGŠÖfºË=ÊåÿëÁοӜgu?â]TTÿö@žøÊêî¤i}õ‰»Ö‘ØÆõµ¼«Åw—Œ^tðqévùnvçWúþkEômöäÊ“K_¿±á|ñ×ö­Îºätmwû×ÈOmmn¶·]ƒÒUøhuÎ3˜r2•êçq>Õ®axw mA;^6M^®ÕÏâž³xÊwfôP½Å Í<‚G5¸iX}Üð³nðfO©$¥=4Ýì9”ÍÔlÚ¨SE´¾R¦ÇtžÂ¬ôE;0É GeQfΞSDÍJ\ëÈÃYÈ÷¦µ7g9ä´ì±eµÍJ¬/ÓäNšì•$îQî>ÃñM‹üÇ¿’¬¶øÖ`&Ñr!8RN`irvN~èÐrœØžJR¡¸m%05–›.øO°ä.BÒ„ò¢q€*:hp™ÔSé Ö²ô»[ênK²é«µÑ”ËS •uÀUó¤ü#ê‹ìfkE “°rZÒ@úû*%êmÔoÕNÖ8ûTi[ÞžÒ»[å[ž=ƒˆÆïÁóP—¾—¹Zeò.P:'{8aY¬—Šz–æÁÀwD¦VÒ¥cÍD> á²°­zóHqô yíJØLtµ‚yxÝVú‚î‹ îºî×Ôøè¶&δ´YXÆxŸǵw¿JøÿNê&ZžÖ–Œã`reÏõý ã?Þ;Ýs~¹ÖæzÁ ½‚•,pTã5˾(x%ÝúIÔᶡþN2·'Lôàƒll{*Nu×æÞÞxsZy°ww*ð)tp‰œ2Œ+v4‘€/|¢y ÆÓ]C‘hl°æŽ<Š³tÏTÕZÉl[´öU{·LÇ?«8)æóÕWäÂ~; sz“·“úGÚ¬?n5P˜ÁÛsÙEQôœQ¸8öTã~ŠÞÞ´…$Ÿ<âµã‰[7)õŽ‹aX@ûU›§* q ›#~Tm[ÞFåO&µo\#± BêÏ8­­ZúwE–qߺƒ‹Ì2eÝ×<êyÊCëi*%¬òy?šÕ5.ËËG çEpXéëãѤ6ãN„8ö¤éå’ëaÝ)YG©˜ì»K§Ú‚lÈ(më’PTGÓß5Ô½ÕTQ g¿?ªÒ=Sk®Ö»‡¦·˜r!|ïdà çýë§:N²H&cå9iÌkF×òºÊ;ÁèÉÀ+ï[Öøÿ:Œü­,z]ôU梊µz…±œx®ñ:Ý#\Lc*áhœ j*¯—„¨(rO9®S¼[ÉŒe^ ˜er_XmûãÍ9?¶ ik»<© qÜÐV#Wáüv4ÇÈk=/uC[Pe8ÑV=ÆE}ªÿÓÚíæPK=‚ÕmZ0ëm4ã³°¿ôÄ.J0wX'{i k•>õž yKÆàéÒʶåLm‰OúCœ•gÓj¨½9jòwäzB¿úe6E¶kãøoÍ€îÒvŸô¥:~âèfë?²«uQ¼Vì«}qñu–ó–Ô¥¨‘ìsÚ¢iëp#'û«­–@èÆêÄ·ÚRâGc÷îH*QÑoœ-ÍCDÙ–ô)Ï”eÇB ¤Î ÀäâŸ[¢”G+´‚@'à{ànRsNæÆ÷’²u„«ž¸¿¤ºy¸Üm’›i_u°]I9ÛŽá;¹Çڤ廬yá¶JçÓl2à~;ã°ÏïîšYÛ,”íª¯h1¾?Ý^½Ò²³ê_ž·‘æP¦ÞPJR’‚O*Wôž{MOô}ÒÛj䕘µÇŒðNÿ§*‰Ö×6y±5õgqþʈÔ3÷ܥ壼ό֟‚w õb¦ô ¹HàL 6•ÉWlÒU0…f˜Œ)TyáÝ­nà‘Q2Óc%3—ð’¥e”6•DK7*ãu0nx-¥¢áPHÍDO‰ÊlÐÝ80쇖†#¡Ç$8v¡d“HÅFéÑ’RíÒ=Ná\VޛϵèËŽ¶ÕKnÊÊBàÇ}$.â…íû€Gœp+j×xY-ºÆoWy/xi†7™ZâAsq4ã'V6Ý@ÿÔl’¹´t£Wøœ8iŠ &JT§—±yãñZÒC‚¶RµÊõ˜Î¨å´ÔH¯ÿdƦäÜìžÿêÙ¶x/Ûí’ÝaN Žº…§Ó‘ý?j‘¤«œFba-iÎpHÈö8ä|qî¢E·ïó3Ž>놉½C™c·ëqŸ©m¢ÂFÔ¸2”¨£;V2“ÊOzŸºô­M5LtlÄ{ðàýž2ÓÀü@î)Jk¬/cæ °4–åÇbF{|÷LríS È‘\g"ÌiE mc IÁX«‰ðJèf®iÁb²’ec^2Þ=ÐÄIÊãž1’fá“‘º’EˆÒ…!KW“ŠŒšg$Åß áµÃ±Ÿ>ô×)0qÂÖôÆÒàÇèúk1#ÖZÎ0™ÞwÕY#;|S†³HÝ&âW‰qIÐFR|ò”¦Z’ ¥~kÎÉR CÓœ’öòµ)Xš_Aþ¢‘'ÙoŽ°¢£Îi¼öY¼•ïÜ?ÙÀŽRIC-•HÅ`J‚€ƒÆ+1 tL¸ÓyÎxX¼6Om« ¼¨x¨÷7tŠÌ—H*ÏÞ¼¬]Žèv>ôä÷óYG& Q®#…¨´€”% ‚}éBüî”l™;¤O|ÉB›B0Ÿõ¥c-î—Ôiù/2â’  |T¬qµÁ-¬ã öÌê‚¢´‚®ù«_GÊèë0Ó€ª=S¨²xI.ïõW;æºf†A->s˜aä*Æý!*Œ´!ú¥;þõ®¯ùnkǨ«EŽœºLçWóËí4•K£Š£ÀÐ\A[çäkVÏL¯r›ŽTSŸz§uU Vúȃۺú@z—RtÏAhç#9üvÜì†ßqCé}¥¶sïãö­±Õ>.3¨úFÓÓ,OF^×;‰®Üçœì~‹™‡D>ŠùWqþT¡¤àŽ%Ñ·‹ŽÕÖkÈ€¸!n2ã(Vá‚ ?ƒšÕÞÞªºzýE#uHÝM#ê OìU¨­°Ö[¤§.ôœ~˜?ÝIu5Êåa»·©ló$Þ晴¦Î”­%*ö ¨Í!Õ7[®ëü^×3¢™áÀ¹§Ö \3ìæ’¸%BY(`«€ÑT´9ÇÙª…²ÕYOOT µÜg¸Î2>†+”1Õµ­Ü·•èŒ;ŸÔŠêV‰ Yh£w ëÏ+'dz¢'ÕcÖú쎿®Z¸Cgæ'­‡Ð 2–×»oäR~(ôõk$3V¼îÁÙÇäjÇ,o`Çå…AIf#¯Èr\uú`g`Ñ0Ù[¦YA-ùÙ\)Ù¡Vš“Çmðý4'9Ê»Á§³Cç³Î…¾€¦heÓéî¡VK4ùk+eÖ#¯;IpàSj;t•Ld#%^¢“Ù5½çG]}H-©$n ^R~àÓÛEÚ²Ó>¨Nö?諳ÅU_Ý}é/]Þ¹ÙÙaÙg*IIʳ]ÿáÚ.¡ôvžBÓÂ箯ðî1/˜ëÏúá½­ÔT[C€„(+”çÎkNÕx­ÿIõ‰½H™‡ û©#Óámmä$ÝYø–þ#£eØ¡]×=ÙÓJ7ǽZ¼lûjÏ{é÷Z(%/óv'q§ç$nVàói® «•štïõ\a¥5¼í;0­µM_©±®±ßj­²ùÔ®úû¾n–†T3K•ôŽ¿OˆÚÖËp¤ƒúæº Ÿí+uí§hÀÆøT/ÿS™|Â2T寣]å•8âRJ@V<šÖA×n¯¨2L0HÁVÊžû»4´(ÝÆÝêÓ„%}ÁÍk÷ЇeÑŒ)ÚZÙ"!¹ÙV· ˆjRŠT¤g‚عÌ:^0U¢æ¿„6Å­;– k!'²r&=¸HÂã“…ŸÈ¥|ÀR® ­ˆ}K7äŸõ¯ H‚cwnÁ¬5„yŠÒ¦RA'$ÖAç;,ua2½°RE=Žs„¡ØÙlf:ø Ø+É$o% žTçG4о[Ñ($2§I=†M{@ÖISøK†~™ÝG^\E;‹9ÂûKÑͧôµ†-¢,v‚‘µA—;Ÿzý}š¼L±Ù¬lµBÀØÛ¾[±'¾}×ΟúF²¾©Õ$»û}=—ü\Ý-2®²áÛÒBœCñÚHÑ9 {ü×ÏO··SÛê¯&žŒd87oN[“°÷;þk£¼¡¨Š”I/`A>ø\0ÄE:áK€§ò+猯Һ?ï î¤m«‚ˆï+ùHïM'“Spà›ÉW‘‚œŽ¢¹¡•2Ñ-dc#¸¢–y">‡”×î18ê#!Deµ*J÷¯rÉ=óÞœÇ+B’Š¢1°M®[ÞN1¸œøñN@<§ŒœŸÄ„ÅxêÏÞ±tà #6NÔ0PVw{Ò^fx^r*eDäŸï@~w¸{%1ÙQHäÒ2=!#›•‰§­ŽÊHA|1Æ2¡S=3o55&-ZAîTlþW«Nš†Ór±Û’$·2)ÐOä¼VôÕM¶Iæy?·ê›Ûn ¨”4ŒÎ7yNKé@çµTáʾEÙh´¶ÿ©ÊH÷⽪Æ6I×8²ë™Ã“%Qœ\æà0œ (Êý…lŽ€¶ÏS s'î 'ôZ«©ê4±À7Q_DôÉ> Ù:Ϊ±÷w’Úv4¶6»Kž\HÉäén7Æ7#p´çŒ]s]h¦Œ[›—Hq¨Œ€>žêñ‹£:qпˆs¡:S2KÚ2ß(5= ¼¤‘½%ÃúÀVášçO¬ÝK_Ai:©áµ§9à ŒäçÈÏu±:åS=’ž¢»ÿ3Û“ùñ·ÑTA QË}éòÚÊJ²1’¬p+UÖQIˉVgA° M÷9»iS¾ßjJš¤T•;ÚÓ§ÙCߎ¦ ROÅME(#!MFàpWou%Å ‚SÚ“ª‹Œ%ä„÷³Ó9# <Šü_TŸÂLâÒ F³É¥šÓÖX=—BtóªFZ…¦b3 ¸ëm+èœÏÓÊžsSV‹µdrGCàÃ|œr«w‹zPýο_ôîù{Õr­:bÒäõ¥„¼¢1œ}GqÀ<æ¦ú“ÃÚ³vžtz˜Áœä~{œÇdç:†(éXê‡`“íú.]¸%ØO*À%M¬¥cØùªLÕºÚ ~ZyR;æéXÖ^£¡˜—XÑî¿–Í)I§<ƒûU®Ù$”/†¹Œkˆ9Ã#-ìFFGû$çÖ(NÇH'[W Öž]ãø­²ãr}˜ï©pQˆí©M…-°p2¤d'=‰óMoÔZçÀÉ›3ÜZâæ 3.sx´œm¶r Mh‚±––žNNÜ.–ê )öŸYlöX×5µò¾«Ì¤nKHHÉYÇ!#9Éãš¾ø±m– z@ÿ-¬Ôæ‘ÜcqìrsÜ­_Ós¶ª½óM‚s±\ x¸(H_¨{+{Ö‘¢¦v[þßk2¡3ù@•ŽÕé‡}“˜ÛžT’Õ1!½ë'vp3Q•°I´íÜ€§VyJ}ä6Ú›G$P54¹LgŒiÉåJ#Ëð@QOŸÔCàÓ7+¬-³úIj~Ó¨tåÚÿ,x1ÄïœKbD‰JNm”§€Ðä$žpyæ·SnÝ!AqŽ²Êfdq±º„šLí nŸHØììU)”·ibt¥ÎqÆœé þ’sý^ý²£=Vë¥ãªbÚ»| }¥…â4v„²€JSì@ª—‰¾)Ýzª¥³\4¶6¡ Àà?º™é®—§´´–d¼òIÜüª~<&ã´©RœÁàw­j¶ç²—©®.:ÊEz½@uõ7niÖ#í){‰8çîriËéX^]!¾Äå+CBîdÜ®Äø(ø^—ñ«n:Žó ÔЖ$zÒš* 7)E*,ÅI>¤åGÂF<×tý“~ËÏêx$ê{“5ÑÀ\pg•­Õ§W cNâtŽäj<^§)›C ÅD¸ß1¹Ãœ~qÇʳ4 tV„½k=GÔwæZrBÙ•iLEF’Ë£vÔÇX#j²•  Ax?Ô]3ÓÕ\ú´¼Jçø<£“'Ó pàìdiÁÀKßc¸\b† Anl„‚Òä¸rI|ä(ÅN´ègP&é½IÓóm÷ÔGî(S}HôÜ'¹sºIóǵR¾Öþ&tWVÝ)îÝ'â—N‰C˜×iƇ ÷v2×o±<) ú~ýlŽh.ïa9nHÏ#éí칧Ԕ oY8rMrS"sÈhnI[ˆNØ+ŽM53õ®î_Âlv˜¯!„"l Ô©Že,3Ê•€B‰8y'ŠÙõ~ Ü©úzN£¯|pF׆67¿ÈHÉòØ'O'V‘òªßõ}3® ¶Â×=î’ÑéhÿÜî{c*›z@RÖ¦ò¯zÕM‹+cp9[™m¢…:û»N0æ¼y#`›“êI ¨Ï ¬Ä~ë-G):å ¤‚iFÀRÂ&â§K…a[ÁûÓ°Á…ãšHÀJ™Ó AWçµ#,Y^reÂBWŸjföãdHÀ™^AÜœ e+pSrô«°÷¤—‰Kd¨„y¬¬­Þ™L‰ÈÔ¶ë…Êâ¸Û4€Ê™@Øá%')rŸ9î*w¦.VˆeÝéß3KðÂ×ÿK‰-v@îÜoÆB‰½2©Ìh£xag-.ÈîÜû¦Ä6ŸYHlIÆïz¤JwÊtÌãt±óbDu•:žüqI€=Iç—»o*?ØSˆ£Û)f·+{iB¡)aÀ$ ŽãóïYÛÎw^pV’IåIÚkÅî )½vÔHQ[ƒ·°¥ÛRZ0­x["Âe -…ŸW²G‚*×Òµ-5 ;“²€¿±æ,²Oq†±IB¯|šéËq,¤ÐÌn´ånòªÖ|t:€ µQz”+Pä?l.ÖTmû{(Qú7(óßZÜÕ¹ËzôÕ¥ò·[öJ´ÄUG”Ëí nï¡.Óji_¤·±¬ÒJëÄ8Ú—#1&úL8œd”ƒßíšæ „@éw§>ÿè´ék°ùu7.¡V| [n^œÙ&âISÍT¬wøÍZ š‚ßr0Ô¼ÈÝòàw' ~|ªUTÓMbnŸƒì´ê"ä›Z*J”Ù=È>j ¨)Œ”~n¢KOðVVŒG6‘ߺ›êkUé”Ú`Y"Û.vËZ ÈuÿÒÈ^Uîx'ÿÞ5²ükñaOgéÛdÍŠjHLns¯ÒÐGÀn£Îî'ºªôÿLIo¸×ÔK){%~¦ƒý;oíù(m’Òë7)RãÏêqJŒ=êëá åò$k^ØÜÞîíŽÜçÙMÝ*CšÓŒçeƒð¤C”¯ÿ0…}KÛ‚ÏÕïŒÕbŠÃQI>¶LÚâvÿ-ð‘5íÁif_]؇ Ë·|‹ûAG`¸î*µâUíì¦IÇqÇù{)K5&¦…[é×!Î.)ðÚÙ=÷ Š©ô4Ì•…²ñò¥n {­uZ¢Ún¯7 Ie’I=†{µB^_äU‘NpÑì¬6×™"ü¨$‘o¶óèõN;Ô)”ê$pTÔL8ÀV_N5ˆµÜQ ¥)1Ôr=ªÃÓ7‡ÒMƒÁ*&÷hó#/<®£¿H—Oe*8”îO½\—  â¼H™\–Håð»|%CòÜ”¾Ì°â\J@P9jNGéÁLd~v*ò°uóeŽÐiո粎Bkbô¯‰—;dzay?S¤\ºb–¨åíý?UÏz÷!ËÔ™/¿-Å0©DóãoµW:¦æúéÿˆLòé_ø²sôÆxÛ²šµÓ6‚À ƒ{/´PàÕmòyŸ‹¥s…¾0x§ÑKk_ f’ò‹½<¤f{qÊA64ÆóXq¿þd‘CèeaÄ-ú‚?ºZ †–éÊoCã;\Â=©'ÄFáf!,m)tÿjnãŽVn¨w²ð´’Á)â½"©É+Å´ €Þ–fJY•$¦Õ»’1ý©ÐDý–æâTIÆy¬ÚÐv)·*α\Øl¨¡y«§J\¥„zT]ÂFRÛüÐüÛ©Jt¨æ­·bfˆˆÝ·É 4HQnÒ\§†›h’£Â‡j¡ÒZª'—É•e¨º5ŒÉ8ÂèÍ+ÐI7(J\) .~Ì¡µ'…>3]Ó_g Û¥!šžaçãfc“ØgåjË÷ˆÑ@ý2§Ý&g}¤8ÂÓòÒ㬡i#*~üV¤|ÓÐÊúi=ÄpGÊ~ÂÙÚ%iË\SôËV<ìqÞÔsp)äŠéž‰ñy)ŽÉíÝi.·°4Jç´l»O\Víµ¯«í]+o¼JêBÞÁsÞˆ Šv€ +ÚUø­qWxx‘Äð˜yl|©ZTTF1ØU.ñuk£>nãá=† 害9oR U\yâ\ñ–—GóÝo_ òÙ€+ñ þ?e+LÛ§„}-NA8û×uÿéÉZ[£÷jµ}­iuô™ìBü WØuòu!!!!!!!!!!!!!!!!!!!!!!!!!!!!AO‡kÞ‡ÐÚ’~ ÖõÏ— ¹úB·‚²|´ÿ6|WÅo üA¶týs®•ù²´/Øú¶÷Æ@íºúÕÕÖJªøÛÃ;ü®£ê/VúE©,—þ£èµÜ:Ôhí«åÑnW¦d)jÆÅã‚Œ š»u׈]-u¥’õhl”"HÓÒ¨î ôéÎq¿FÙº^á í¥ªHù;ãè¾KjÉ÷[ÝÒ\뤷æËZŠ”âÔIQüÖšµGL fÁlùãð`‡r™Äí*O=ǵ?š‘’‹\GusèÝ]KÌÆš ³œžÿ¿µRnög3.`J8œd)5îÚqo¶“žâ¢i&,Ã\¥(+pîTN-²K*~@ASi;ïRÏ©k€ xÏ©Ã ò¼k­1}é•’ÄíŠ Co)Ž‡Øi(õ›ä©n¨r¥’G`êN e–š%‘ÉÓ–47S}Þ©ä÷Pö«$´õ’Êç—5ûîxú{*5n%.`y5^k”€7NZ^anü„©Â”yPî“î+¸†€ìá6¯¡$/¯ÊÐ7™ßí ]ùä2ôe›!¬~¾øÇ?½wÿ[xQW'†õ1.©Ú\ÑS™ƒ«×Øpqò¹bÑÔ1CÔOl›³qœì ù}uÓ®&Sþ /H )() …v¯œ1Îæ;ËÆÙu-5Ð8Þë(z_Qß-¨Óeùè²"J¤ˆû¦P +ÇlàŸµY)«ëek`fK$Àœ@÷8¯îf3 j#÷Âï.ŒômÍ2m蹧Р¡.rØXQ=†}±]“à·Òùÿx¸àjdgý‡+Aøâœ's²cøŸ]êÄô),Ìô¡ÌeÖ6²áhÈ#ü¹Åj´ÿOÕP\â{åôJ;1‘ŽÃ }TׄSG;HÝ‹ç%ÉÕ»-)ÉR÷gçÚ´%#fWJÒIˆ‹°¬ÛæµG—6¾ÉÖ‹K7 ›ˆŒ¦„'\l¤ó†Ô ‚¯$gµOu²“8Zdtðµ­qqaf PÁÎÍqÓžç•vÝzžHuU3ËÔâ3ž8ßç’½&ÐbÁnÞÄ´KôÀ‘긕/ÉFÀûþj“PÖ’4‚=÷ïñ°ÀøÝIGÁ:ÎRûlÔ´€RwŒWNIØ%<—;p¦ûƒgp'ñPuÄn±ònxS[B'Þ¥Fƒ…º¼`§'îOØy>%Ej–¦a -Ëö÷>ÀrO`£+k£…î89Üc ?:\ OFrc+(W¦°â7e'‚>â›\m²C;éß‚ZqAèFA)”u>{ƒ‚¢“.’åÀuE9΢:f³|'´ð€s…œhKØTxïXIP3€¤w]›ðËñA«~nȱí¿Ø&çø¢JŠYu@} ŽPàíŸ ‘[ëÀÏ´õÿ ¦s(‡Jü—BòtêÿHÝ®ã'pG#ŒjÏ<)·uˆèK¿QW¶Ûe¦|ó;³FqòãÃ[îã²–¸Ýiha55’68Ç%Çtö£è3} ÒˆÔºã_Ùí=^ÞÛ–í/ ¤Lv:w}K˜è;P!#qÈçíÑ~ x=iðúÖ$¸Ýƒ¯ÙË €5íÌŽ>‡;7PÝkNžñn¢¬0ÐR“@3ªg’ÐãØ1¼»äñ…Ë÷{ÍÊç!éÌ}Å­KQQ$÷'ó\=T“ÊéæqsÜrIÜ“ò¶Ù‰‘€ÈÀÊ8§¶nPá$ÖB<¯ZIZ—õUœ¨„a.×àa' ZÜò3æ²Ò^n… 'Œ÷â²N%‘…µ¢­‡ŠÅĤãØ¥Qö­A9J3ÜŸÞBq”«Ù”âÛe!Dä§<i«œ‘yN̽¡'ÎAÊnYÝ, Ü )±8I—G@ J•ÀÏ4”‡Ù'Á) 4¶˜W*W$wÅ6ÓÜ ³­*De":¤(€¬‚`ú}É)&µŽÝIm9J9Q¤›VB1ì´%EEG½,Geèh-:RæqÚ’{6A²ËÖ/¼²Fœñâ¼-ÒÔ¼c”¼a-‘ŠkË·^w ¸¨´ûkH V{Tý–]±þÅ6­ðŸ¢[= (ãpÛœýë«-´2–²FŒŒÀ´=d­UE-å‰Dl3œU3ªŽo¤d+-„0¸j^=Ç2i%²œ‘íZÀÅ&A £,w(™nS¥¹ôÆuŒ«ŽBUF^ ´úea ®¸¶Ù¦zCRò%²ógsc¾‘‘öàÿj{cµ>)«¤iÎÀŒà29ãý–‡­¹Ç®¢ˆÒÓÏÕMîñÐÛÖÙVÉmML¦w­´®:Áå'ïS]{l¦C=¶A!™¹ rÂàüªÅº –½“·NƒŒö#Ü,ó"éhvAd¡ JLUóe$÷÷àÔ}†¦ªË÷æ %’ˆ‰÷i#ôÆ7A,‚¤F庿DÈ„ËaÖeÏL´²âN{àÖ£hž9ŒáÌ9 RCšK†r½Æðã-ÝœZÛyÍ¡JRxÅlޚꚶKRǸ9ÎÁ${¨¨hZÀ6—4\5܈· ¸×€B»÷Í?µu K\ç—nA·ÇgHʇÜõD»Ó~„‰J ­À’x¦uµÕç©8¨ÚÀKV0§È€Òñ¹)''ïKZ.F á6|M“oe ¾Ìv\Ââ‰É&–tÞċl©JhZÁ°LSÔ°‡à`ƒæ•„nŸÀ}I²Ërv5ȨñÎiÕ\Ç”ú¦¹…¥vvÔ‰— 8¡‚œ{ñOì×<Âè^V²¹[DRlSn®¶¥©J} Ò¿N¥=é3åGg%ÑÕ„óÎM"ôÚcŒa>Ç| É.±§4óùg<¦Ù=’‡Ì6”¤zhîA=èþaÈX¹øåbˆØPQþ⼎œžRN—l+LÇŠª_§‘ÏnsWŽ”¥ƒÎ˜à ÔMÆGiÙYs߶Ül¯@šÃR· ÈA÷Á­Ùxê :«k©%öÀøú*…=,±Ô p¹¶çdqÌ ØȹvzGÄHì¶dÆ£émØä…nûS789>Wá+sKRøäÒ/,^p0¼“Å'v?”2€p²‰íÂc-ìQø»e™)Æ#¨!Eg‘Xd€ܥÒ"͎׬¶ŸiæÚ@þôó2j- {àãõ^¶v;`R8³Ü[»_*pé'¸ö¥éê4œ¸ey%>® ¿ôm<¦\TVGa’®€èY$% ÑQz•Å­ tÚuÄ'uS2¦ÚO WÑvŸªz~燜 ¶ã ]\:]—2ÎW4uUF¹uQË€þؼ•½‚ÊS»ýs\_ã}â§SUÜ©6l®üð3ûåm‘³IOlŽ)G©»¢½:2¸æT?U×QP*â­>RÆjã•Dñ;É:FØ_O´ÔD¦ÜÐB÷!Äd}«èõªÏ¦‹@vÏ¢âÌçÍ$ŽË“›'jþÕ£:ÚÖèæç¿)µ$šœ¢n>¦Ò¼}\Vš»ÜLqÇœát…7J$ŽGékH;qÛçè¾Kk}7©tÖ§“§®V¹6ûòd #r\'dw#ÍqŒYã©434é-ï«Œ}w]kAy‚ZqP<²3ù%êƒ;G>õžúnÖÝ]•µsŠê dƒÂ ÏÕ¸a^Ý«Þ§´KG!¦x-‘¹i çƒï«mP0ôŸóøMÿ9…峟"ªæñ)'©5ŽÓ{¼IŒÄR¦¼âˆBIQ8=¾Â›º0ã¢1“ì’®8·‘ÚB³ì6BêËEƘp­ÇÍWéi]W(`pk}ÏEÜnb6—Ÿug^¥ÆÐù‹§¯LÌšiÉðž%¹)R~ ÙÀ!<àäsÍIÞi"·NúzƒÈÈ24.³sƒŒlrj™òÖúåf‘ì{}~Ud›ƒ®—=Ee[‰=ê¦è@J²²—a•¶;‡²{“ÜR35;ÊQ *)YÏnj&g,2J—¶¬§zJ8$š‡ž§Ùxã¾»(a£µýé˜q'Ô”k\Ûþ"¤´¯FôSFBéµÅØ©j÷|mÂõÆèïõbAM´yÂÛµuoPý©§§±CÓ½JÛL:@ñœË3°2ã.Àäã$ï€@-C†1ÕÜ]Ô:¯Ìl>˜Ø;zA ‘îUt¶Ý_ˆýök7 ¡å©_8èQC‹ÏÔÏug5ÍÓ_$}{cy>¼ÿÈò}÷;óºÛl­ˆ8BËG>•`ëÁ¡úÇzfØöK8‚“zÊÞ ”„÷â”ìœ =’r„$+)ñÅ)¬ž –¸¤7·Ï|ÖgÊ<£Œ ‚Jweàqö¬÷ç²Î3ºuM–î»ñT[. ¶zž‘W¤Œíß¹ÁÎ3š~ë5_Ý~ü#w“:ô±:±§V7Æs…á«€Mä|ã#8úr‘Ôƒõe'Ú¢‹aÈ[RâÓÙj ò3X–…饀—±õ—i«áqá6u#³•7pµ@•ïÏ’u1Išr·¢ZÆß«ŒRN§Óo'¥íJÁ Ü5t=‚CA' i S3ó¯±*ãé—@'!±ÇÇ·Ú°‚çåÃPŸ§Õ7ž2ѤÂd¹\áHœë¶øæ4R¢PÙ9Ø?5œ­qs[¤{,¡ŽF·9+J_Qù¦¥z—¥wpÜGÞ°krp—dYHØ|”…‚R¯?zÊFo„«›§”èܤ,cq¦Î‹ ³+_ª èÊxã©‹1}K=Ók‡¦}•ÚkmCqC€ì+´mÕñÇ@ v#ÙsýÂ,Îr©i·$oqÅ)cœZºëT\ nåY¬ñ8a0M»¬„ã©OêÆ{}ªTç=ån^–¡3'²–iY&|¦ ÚǺª¥w‹Ëa!lY ò[†•ÜúC×`X#JuØÐÃk/ôÇ <ñïNºÄWA,Ï-€jÔyÀß;wÛÙh^¡Òÿ9Ì»;ÍL4d(OO—=ßR\8î,mGÒ^OlcÈ5°<(éúZʺŠçæFD]€Ý‹È{{«IS+bl#ÒçÏoªz¦Î±^-­[›j,wÛs,·´ŽÈîGlš{s¾Ü®]?Ynm>ˆâ{]èn“°8ÔF525r£…,qUÇ3Ÿ—8¹Ïéì>[ò‰¸_ì±$OE¾Ú¹(jC‹sÓA (•à„€2sƒø5ν'GEUw†šàí=íkÉvŸQÔA Û¾=Š¼ÉRèhä’6kxi c98ÛlŒþª?|‘Z¨JuP‹«C%k ;BŽß¨pN1ÈïYÕº+ªc¢?ÊÖàÃã¤8ãÔlnÈ#’Hbt¿;c|o¶ø߶W0^Èû¥$rN*zÞK@%XáiØ„VÄ­®´š–œêju#i²cOŒë:™lå8ÉÒ:€PFƒ¨(Õâ͹*S}ˆÈ"•dš0s•#OT[é)²Û¡o·¶Ô¸q\}¤ùíýªÓm³UÕ³];25î(Žp™Õ¦]ƒ1MËG òIJ’Gc÷¨Ú¹_ÌRŒ¤ÅͯfZ­Dy(e·ÈûS " ø'bª×y —lÆ逾é¿]%;öïO¨œfºv‹ÀAq³º¦<ÛVÇýV°›¬…=PÜ|.a¸ÁD’£8צâP ObjãúºVAPø³˜H?Q²Ùô³yŒSsŒ¡iÆïÚšÈÆó”ñ™Ê¸ÊBÔ°)Èœ6\lV‡C ƒâ•Ž\ Ò¥úe~:˜QS†?R‘ŽGI°+Ö&mnç·zòHwJšByNmNVA*#ñMŸa÷0àÿªIñIc$Ú4ì,»Z_ܦÒ¡Ïö ¢Ýœ¥(êˆ>¥q‡ã’Bø=êQ²5Ü)£+°JâÉƞƚ$Özpy ao–Óà!Ð=»T[âÁÝAVS¹¼'7£5Y8ý)3¿ $¸œ¤wNÿ䟖h~µ“û ˜°Ú›[8ÎÒÞçþr™WÔ˜™2U‰|é³–»@¼ÚnmÝá¤eä);h{ã$øæ¶×Tx@Ú:âVº—îN~q¿ÂªÛºœK?Ýçak»AÿE¥ ©PïšÕÉ ÒXVäÉv8J™Ü…§È¤ëu†ƒeˆh;½:ŠâI•y¨ÿã3çÖRth9d—Ú‘Êñ¹]óJÇZ$n ^ùDpšåDe{ÂN=ª>£K8)Ç™¤á3E§2œ€yÁÝÇ<%Ì™ cMýrvƒÇæ¼…ÍÎÊK)®\…nJxïO$~}Nüœ%vG™¤0x¤™&—‡T4†œ®µÐsl±ÔÜk¤X’Øpâl8•ƒà¤ðGÚ»—Án ¶SË+X×°‘æ‡4Žà‚ ÷Zc«(ê^ àq{ù…Í}cÓÖM3¬œzÂÚ#ÙäåÖÙFv°sÊF{ x­9ã§OÛèïo’Ô`—ÔÞîì=‡e±zåQQDÑS»Û¶}þST»nŲ¿ÏaZú‹ª$§Ç”7V-†S‡ð‘kŽ L–Ý»+&b µg¤ð NõVTÝ"„O³ÙœžävèœYzr8^üpU8ÕíÇ¥z‹Z²NMTä£ôì¬Æ‹Ñ¥‹®:-¨OÍGIw)$sÞ¯~׶ ƵÞëQuÝ´º'mÙ}téÕííQšÉ$'5ôâïñÍcö\Ö6Ãä©Üõ´C‰VÒöªOˆ1°¼‚^•§burW¦ ÓÆkz¾´2LUˆʤz…¹q¥{Mhž ŠÝéØ­Ñóº9í•øîÿ=:êzC>PIÚÌ–Ö¬ Œoñ]·ÿ§Üâ¢òwÁþËb}£Ùçô<®à¿‡¹¯¶Kä9^P¼EEEEEEEEEEEEEEEEEEEEEEEEd„"¼B+Ä"„/ܨ–ûŠn*O€+óù÷vçRû,ǵ›-’-ÒXYÛ-«Ú8HR0? ‘»€¡Ï>iVË”ýƒmÕ± µ¥šÅeÔjób¶Ê‡sSAÙJe%ö“’”,ò|ã½Y¨z±ð[¦µ˜˜èæ-%ÚG˜4œá¯äyÔUmóÕ²­ °` í¿¸î¡âhÆz—§¤¼ËŽèÖï\’Û˜R•<‚à>ù@UJø{}¡¡½ÒÕÜX_LÉZç4òX ϹÇnü%ïöú™m²ÅNq1iÿî±¾"uî–ÖÝpÖZÃBéøÚgIL¸8¸0™BR–Î08Ψ±L0 šÝš>@­su¿²‚ŠGjËŽy=×Ò=-c6øŸÃa¼Ã8(AÈíŸjûmÓ=&i©~çJ} ÷ÛŽë“«nÞl†Cøœ¯ ?¥*ßè—RëÎ)iu´€J;+÷çµlûGF ¨Îu¸Ç°Çú*ä×CæŠD-1…Á(Ž§Ó¹Ä°ÈúŠGŠ! …²èˆ‚[“§;’ Ûjž«±U­æ<ÅJ”ãÞœ˜Ç§´Œ(ØûV¢êHK‹¶×Æ1¿ü¯nß }æU‚åØOZ²ó:‚Bwl8ÊR¢>“ÇêÒ]Y Ö‰ô²S‡—Œ`miÄ%͹%±§‘\_t¨1ˤn×nÓîÜìq’FFø;Žó¡¿6vúÆØcÜeu'M®ƒ¦ºñk‹§XsP]Y[+˜úp¸l)8!³þew'ÇÞ¶%ŽûUm´Ô[IJԂ Ž¦´Œa¿^r>žë^ÞeŽ®¬J÷å±î;ŸŸ…Yê‰zVÇãkL¹/ÌôÛq¢È²T•çŸ§=ÇUéGC f’ EãPü'#pAØ÷©ÛoÞj$=¸ £fâ§0·xì*±%8rŽÑ€Ìy>¦29¨ù£ÂY­î¥–ÿH‘ß5 SžËOu4†ìdak*¡¯;›Ý€¤LÌ2BUµ¼÷&¢ß”ܼåK´ýº=Òëo¶¦\&’òK’ 2ÙQÆ\pð”$ö½¢Ñ%}\tl{c287SÜÁ“Œ¹Çf´w'„ui‚'LAv‘œ’~îUÙ¦ú_ª®Ú3_k›}•W d,û„y,â+êPÆU¹hÁÎR;`ûÖá韮ÕV ®¤kZú8]¡ÏkÚ\Ó¨4‘r挃‘¹níʧ\úêÝMq§¶Îò'˜àð;žÇ¶ýù[¯ú[]truöÕÔq¡\hó­iiàë3¾e)uµ¶ÚÆv©'*È‚*­:BñÑ «-ep¤Òc :›'šƒš×ÂỶ،u…¨è/Ô쪤Œ‘!s^HÁ >FÛªLôÚí®´ïRõÄ9¶ä5§b3rœÒÎÒão>°8ݹYÇU¾ð²®õÓ·N¢ŽF†P9Àòï1ØÛmÏ짮}KOEYInp:ª šÒ8[¨çòUc2–Ú—µIH©$€•ocBÐô¦”TB†|Öl„ºxÆŒ--«×RP…û“K5ºyK5„ðºRK:pßMß×Sú•¥¿ŒIu"X[/|ä' †÷_;HôÒ3‚3¼0F+|ÕôIÁÓ¢ë-Þ7ÕϤ26MQúŒ‡éhïŒ?>“‘…­"êK³îÿp‚‰þ[.‘Út»Ø7~OdÇbêŒÍòúe÷ØÖú‰ŽH‘hu×Z‡r%;I^Í®m8IÆGj§t§Š7;™m{þõmŽG?îï.Èâ u9£K³Œœ·!X.½{Q&¡í[@/o}‰ÈÏeQÞîí]®“g·4$ºâ––YÈm I!)É'8çµÕlþ|Ϙ408“¥»5¹9Àì8ð®6Ê3-‰Ä¸ŒžOÉù)ŒÈ'·Óãµ%å)'©Y'ê<׎$ÜÔ¥ ú‘À4á7‘˜!>úE ïL\üì£ÞÒxXúä+hÇ÷¬„]קß%XTÜ-1u¸D”‹c-’[KàŒ…ûùø©h­•­mTñ8Fð@'-úvç¾TUYd®ò¡pÖýñù()’ÙqJmC»Ô1‹)»RÆ%„+¸Ïæ›ÉOž?vÊŸét·w‰|´7§îNÅS¬•+êþ^B?÷¥\y3d¡tÂZv4–’ çӇߜõà(Úédq oÆ~3ú(ÔØ“m¢7ÍD“8ߪÞô½'²†{½DÔ['‡vêÜd‘î27E/ DrçIÎ4HX9VM6|c _-©á•ú«BT IíïR}4ÏûÆ¡¯€6~‹²œŠÆÅ'rOö®ŒTAN±øZ"¤‡Èr©wT¶e-)ÊÚÝÀ'‘š©:7µÏÛŽÍŽÄ$7hn•4°ñTÑ?­Úù] Ðog’sÎTÇGF™L­´0x[½HÝ*÷Tæ†Kè#n×½£õÊ MCå@2[Ú Ü B‚Vo¤ñÇ<Õ²ªŠgôÝ%ÎV)ÒK FrH¸Û}ð¹–Jzz[M$.Ë´±úO±ÈÛóùOÚQÛÁ>Õi…õ=»ù€òϨ{U‡Á¸ï.§¨£´1¯/ÉÎ@,ùiQwöSjlõ#½þí-.à÷ýPd­Ô4mï%å$å+x(`äq““Yô— ¦]EIp`…ù ’ ¡Í6ÉÙ5¾Ã |, ‡·ø9Ê…Ï…ÙIHO§õ}I*àšÐÊHRXÜ7‚U¢–¦F³9Ê­5ù6ëKû”–ýG@HÁ¨›]6^áò¬V©<Óô ›}KpîúªèÆ`)ýÊE*Öç©£>jAÔ>÷'–ÊÛ²‘ãÂ`8ÂEîÎØSX6W»v;“SVÛke‹YPÓ¼5Û©4X,ÑUÚÂR9­cëFQBiÏÙGMi3;R©5=ÅÛœ¹Ûl§*É#A¸ÖÊ—NÿêV»u—k—Hü;Yt-ÅÐæ±rKa@­ Ú¦þã9Šè¿³çGtÅ}^z…å=ñóý–¿ñZøãÍûºËY^­šf;Pì÷ÄÞ­»CadºœvÜÁüŠÝþ6ß(¬€SZª¼øÆp†8Î69÷Z³§(&«w™W–ÿØ® ÖSví:wÿµp¯=³šù©xÓÖI4œ¼“ú®€´ÄÆDÖQ6®Šç'ì|Ó3 üï”äôˆå79¯WÄ€v+,•¢\FŸNS¸«2m%:¥˜µø*22Øs¶ñSÊŠ5ë{ø9äW‹Ù9,öOQžNA{Ó #Lg„Hå/C‰YVxãŠ@´Óp L†´)*H9í^Æâ ö9\r£Sí«N\g8öíR´õC‡)ªz½mÒyIbLy¥}[“€)i¡i g°¸p§‰3®O",8îË|þ”¡9&šEG$ÆÒçÕ_Q4É!À Ðem2QPZ.Vu8Èõ™R7}Á=ÿj–ºôõÒÍ(eÊèdjan~F@Èú* žž·/¦;àƒú§i©BÞäfß.4±ƒž8ö¯dê©b§t1¼î~‰˜µ4K­Ãp«2œ RBSíU&NO*]­"=Í`áXÆiÔuj@)®L'Ö†]JJUÈ«º¦ˆŠP1Ý5œ9 Ÿ¦éxRZ[öé¨j@çb¸ðjvãÑÒÓùôRáØ÷Qm¸Ê×i{vPHv*ÖÛé5«¤‰ÙÓ'e1IXSrP wøóŠZG€ÏO+%†Õ¤íXÎ÷[¬â ̶‡VôãŽ1YßÝc¬ç*1!—a¯Õkõg¾iänÔ0T½+õìå*®¥Åe°´ ¸ž2x&­¶þª¬¦hdd`q²aSdŽGب¦ª¼È¿aÇ×ê­<§>);…ö¦²MuÊ}o£m8ÒР.½-€P…}?íMãhåXÙ¤…š_wrÜ^åT¤$e>„i)¾5¼úR¬“íNæ—dâi@nrº·¤¶'Û}™ ýn'š±ôm©òOç3sžËTõ…[CHqÙ}Jétõ3:V~ k¼º.£ËŒiçºâžº¦Õ)*é~Z\ ʆâ8ç½7ë‰{ÑkXéËTNkEâ‘“\ÕtžlÊÁLý*©ê ±MÚž}v¤kSuK–Å懌sŒî¯}#[™ÃH_’ÏñÆ~¾†êÆ_RT°Â”»ç9Òÿ`àñÔѽ½Êß1Ò0ô]W™þø‚5÷‘|a^P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P…ûÒðn7‹ƒFßÙ’ÁÜ–ÛIR¸ó_ÍÒæ8\@ÎÛì¾Ì×I#2hYtäíS{DAÿ§•ÈJ?P@åJQìÇ&ští’¢¶}°¼ ÝŽÀrO°ù) ÚáMÉá0j‹Mª Áö  ;S½\Ÿ½GÉ.%s[»AÙO[ä{Ú<ÞTYv÷NÔ,c›gu!ÌnùSvº=¯£éfuÒô÷þ‘ye-ÜK ôAÇÒ¯<‚?j¶Ýz>õKiŠùSJöQÊpÉKHcøßšŽƒª¨RêA óÈî¢Í[à8î¿z¤¾yZ6Vrõµ×aJ_ðåýXúvçpü}é³Ë‚yQSÀ4k¾ú9Ô ¤nÑw«z v¼§S”…ßúÞ»?Àž¸¶^e‹§n±µ±ã#m@{ûžV‹ë; ´š«i·+²íßZNßßwù+r˜IúyV¸ñÞ»ºo²NÛD>&bmò=¹ZHx_.¶k>•Ò:?¥zGNZpŠÄT¡Ô) ië âºßÃÏ ìjfý €oíôÿíkë§QVÔ¼¶gì ’0­?oþ)¶nR$´ãKiHæ7±z¶×ÑICŒ¦g˜]±ßÛò•5ëÇʘo%ÖI!%.’|~+]xÇd´Õ‘S%Naà‡{µÜ§ ÙÓ7ˆY 79çÛEAÞ´¡½.ñq9–Ť"\„0+ Äóûçšäî«ðRš²9¦3÷Œkv€Ü–‚È;òsîUþ‹®&C\ÝÙÀÎU@÷C4”8¿4ăpi·r¹$gÉI>õªê>Ͷ JsS ¼ÀßêÇ·°Ïº´®É¡Þ{óTÏTo2l–Va.SŽµ½E¡‘”g¹®]ñF®xtÒ9ú†ú}À[ ¢iMD®®1¾ß%\$)Å9¹IàŸ8ûýëUSS÷w%oŠ8XÖpšcÜÖVêäv¥¤¤OrÁJ`Ü×”£'ª¢r“# ÔÓ\¾Ê™™3µ»™¥¤”•`)\n8ÀNFSÚPòƹ­ 8åÎ ‘œd÷8Øw;YZ"n§~ƒ*jÂm,´ûæÜ•±AÐ…gœŒrûñ÷ªÄ’Ç å§VØ9ãßlw;$˜ù ý_…oŽ¦Ð~¢HñÎqQ2‚w rÀNB‘Fu²TûŠ‹•„l,•)·k õ¾ëM¦és‡a Èa§T”Jö @á_lÔÍ–¢è¡¡’@% 0»Ö{z[øˆí±>Éè)^á<Ìis?¨‘ô'…#~‹ª5ªäu·PêÆ™jÙ[ζ§$ïm­¬²BðRœ„§ìõï’x)ìQpÕ²,¥œ-ø¬&ˆ…#ZF¸’ò•µ×1àœø¦¾XÆÈ Ü'ç-ÍE\c2Lwz(Ò™u.äá*ý È ƒÈãŽiíuµôíiySC†’Ïg`úNÛƒ¸ÛmÓVVëÐ ãpGæ=DZà«#AtòÁ®¤\a³©­–Z„ì–•qVÏ]ä`ˆíàà­`ý$à1ßrè^‰¤½I4sWÇJæ0¹¢LúÞ8¤m—I<±•Yê>§žÞ#pÒ‡8§} ÿQøÕa©cÿœõ¹v÷í²v­·A úíTyh§‚GEPÒÇŽAØ‚­Öù|èÄ­ ƒì˜¬’N+6OÊZÛ©Þ1’sMß)¢«:Éj³Ü4Ýùs¥_ÔÿÈrÕ˜ÁlÈkrýuº®à%!%%9ÝžÕ9j·[_ARgÁ ÂÖ´åÞiyäin HïœìªÕu51ÕÄ؃|õ’pàp4†ŽwÎ~0‘3£î²¢E¸ÂŒû͸µ¶ßòö‡T„…-(Qà¨%I8š‚ÍXèYSå-䆞Ĵ@ùƒc‘”ê[äL˜ÀHÈó¾Ù m¬ú¯«gé˜Ý/Ÿ©dê oq*¶&S ÅÂpV77³%õgé+«i«Û98ÂŒê(›Q…Ôš—©oÝ<¸i›üvä6¾2Ö[.ŽÅ'¸®Éë/©n½7OÞZÁÄzÚñÆ÷Æ3ÝiK_DÉMvmm)ǸìGÊåv @ãŽÕóé®Áõ-½;¢µÉe§é"“ÖÈIa2”`«Óà•8Cœ¸ËÜqŸqKG!iÈ^9¹OíjF0¢¢~ýª^š÷$m-Ç)»©«Âôë@)Dçi8ÅcKc«®$À2‘’¢8ŽR/—vÛ%LHBÙu'…ª§’šcÃr–kØæêiO­nà-DÉÔÌ•Á䤎Å7LIŒë‰JÁG·šm[ÊËM.(,ò8> 7adÁŽ7­í:’°1ö«*6K2¡àã²g‘Hä%X)ãfìS±R B!.JÔIJVær:CˆÊè}ñ[Ô=9¢­ý>vk7r[†òBÐ|x>½mvøÍÔñÚc± t‘ì#{CÛl;#ÛmÛ n ’¡Õmn™¾G*9uÖ½8Ô6kã¨Ñʃ«]RLwX¤´ØÏÔ}>ßëTzêës© HY99 wý7ÙMÒÛêã§ÎÌc¶7ýUEó6Ãq‡uˆ ‡˜u. ýÁâ anwiÁ²Ÿ¨¦óšXFÅY:C¨¢5å‡Ü~BÒë8%~çûšN„MIPڀ㆜ì{û¨ ͈IcG îÇNõ%ËStëLÈ}µ)˼ç?zûÝáýþ²óÓùç -ÝpUöŽ:ZÉXÎsºê];oD(>´¦Ý‘ü´¼¤„ð€qÚºâÛlŽŽ‘¥ÛŸôZβ­Ò?Ó°OT8ñ®rVÂÒ¤©®q’{ÖUžŸÎçóác Èx´6\3C‡I *åHçÀªÞickg“v»<î~TœÄ᪼½JE¶á-qn[öÈä}Ík+…ÇȨ‘ÔíkýùSP5¥€?•Ô­I¸Kµ©¹Ëm—”œ6ßçïÍVú¦Ù-ƶ–ŸÏ:O¥à >½óì¥h+[nÀÜp›ú»Ô FÒÊ´FŠóO3>–Áú•î~ÕRñÿÅjk-½Ôt#Ëh Çsî¤zFÂúÊoîw_:í:‡Zu§ZZ"Árc–V¤“1{°‚Îó\ ÑW+÷\ß!sÉ´áÛìGÿj†¼x} -¹ÆLi –Œmñ¿cð¤)îî’Pú¯˜]}™"ßv¸[¦XPȉ$(;ý>1_|e‚Ho†h´‘Œøøì»ÃÇÓ 5þK‹%7%.8ë „žõE…ìÀ [±“Žkm÷ ßËf{štè†7NÚ[Œ„ùá -´ŽEGËJÞW¤ŽêÏ°Ê9R†yª|{&¬Ë{¡Ì%jÿZ©Õ0ÂH…+Kì4Ђ•Œj'Ëq;¯@[[–\à(¥ Æ}«Ã•ãœ+¨,^к@hUtÛCˆ½j9WKŽ¥¸(>¶–ÚϦÜVÉÙ蔹*I$ç¸æº*‡Æ*%®ÜÞ¢×8 |Õ/ïs†@ É- -> XÀ îã««:.ª¾¶¥×ŠtoY =#’ãøµ{WPô7®½uºé{œëV„ÑÝV•r»Ì¼\¦ <»ÒÌÿæT„”‚8ÊI#qÀ®ŽðŸÆë­öØ¡¸ù$•ßw|³Ó¸¸nk]^]œÄ¨€4ìjÕýqÐ5c]U,”ÌcXÆ4HÇfçÿÞ'ç×Ï;¾ ¸i®«+XEtܦû‹‚KÑ‹BÒæò•´HQÈ)ö$WtïS›?QÇuvf0Ìu7A~—‡7úunù åtd”QVZ~çÑ©…¹8Û~øÛÍuWÇv“ÐRµVƒêïMSfcLk#…€ÜiˆHK© yNqýAUÐ_lΙ´Ó_©¯ö Žã‘¢=8o¥Û7a‘¤œêÕ¶rµWÙæíq»¨wM!n]Éiݼï¶ÿ‘ ƒÄZr?½qÓ§] æ?VG {Qc²ÈZ Q<¤ I9åÄa.ezØ•DmIuMzå';Np¯ÍyŸ•—óNÜ)FŸÕšRÚ÷¡­—àRêK†Cí8È!$,   H9ÆE\¬wújhÌU4QÎvî25Ã#‚×–ÆZsò}ÂÁW8‡0줎ûÜlwQŸR1RVǨÑïÞ©¥ò4©ã·K®— —ÙÒ.7IÒgÏu[yÕ•-Õc$òO¥]Æyä3T8½îÜ—I?$îRtTͧŒE CZ;€&:¢7,b׶SÂO+3 H ¶¥jÀOžË0ŽUÏÒM_¦tíÚL}{g¸Ü,’Ó&T§æà%+Ü¢ÒWô­*JHÈã&Øzª›ø?O(¨©´áò·D’2òKyÁÜg#ÂÔ½1Ò·{Y×F¾iäÎ[ÖÖ‘îIgßuÂÚÆ¥yšÔy±®Ñ›p¶‰l…ä$Æà3ÈÍq½U; ñG ‘­8ÃÜp~FWAÙçsâkÞÝŒ–œdcŒŒý?ÐY$dŠóÌ”©vSƒç€J¶’IãïMe¨I>@ÞW©mÅÈLt —B@÷>Ô5 Œ¬µ`|-ëeö‰ IÅ#©¹ÂÇ!:Zæ7ó¬M£'hÎ Àî3â‘|`nwLk´’žێÃmªZˆÆ¼VÄé» d­çZwªëËœc8QIwq(”`ú]«cÃsˆÜ-n)œIQ)m!—ý`Bwò?Qªüá‘ãÉVJ¹Øjp§VÂV–Ê@'ÞµíÉÙÙ[£¡©IV>ƒrC²¢GlíBÖÇÛš¤^`k¶î¯÷f5°9Îì_jÛ­¹Ûœ–eÅFŽËQÊO¤}XûsPA_­`kNˆÚÖ~øúŸu£zvß3`v³êq'õ?ÝDí—4½>`B–ˆ[‰S[¸Pð½G}ûDÎ|ÇŽØö?E?]C¦çñ{©ñ‹l}ÄHóHl6!@p}³íV‹–ß4‚zræ·H' sí•Slõ icðNp™YÔ-¸%Ùí1fc¿S¯º¡ÎÜŸ§¤v÷ɦ1Üa’›î4Ѷ7È}r<󌑃@ýI=Ô”¶—75Ë[Àûﺉêø&V–»<â–6´¥cînÕUéÜêøSÊŒT¶1Á\€‰?1 …pÀ+iº-#esš7•ºT}¼œRq¿)(˜\6N‘Ò”¶Ÿþ_4Ñç%3,!ÄÕß ºÅ¹é€|9¹<à8’yÔÿfog¹µŒØêV¸ñÈ*)‹ˆ_BõÃÛÖÑÿYéî¤Zô•ÕØÛÝ‚ûm>°8Vô¨“Øð}ëé—ˆ?e9ºŒ²ÿÓ÷&RË,zžÇ³Tnwcö–û8évyÂ廊Ó[j¾¦‘ÓF€àwÛ9ýBøsÔw(º²ùo¹³˜’¶œÂ² ÆAò |V¹PÌÊ©[RuH×8ò ˾:q‘ÉJÉceA_ ZT¤•y¤#VVŒ $Pçª,ŒŽ|Ò³RënRO¦Ô@hËâ%²–”¬ƒ÷ªEƇËvUFãBc$„¾üÚYwrK‚vYÛ]¨&h?7*S,Dm×ÞQÚ’Oâ¤YJédc.<ÊyRàÑê8 Ê:z÷ki+»@’ÃJ|T½Ë¥.¬×WkOº¬ èev"p)Õ$-Xíž*–ügdì –‡ q<Ò¬ŒöY´î›3ôù¥šÜ'zÂO"ŠO<x¥c› üs4í”ß±Öˆ^JSNæ»dè`·:³/$'#Ÿ4Íð÷IJŠ†29¤Si"î¼ OœÈ5&!qKbº¦œ J”“ö¤$ÏeîƒÂzT©2ÊSÊ)3IIüE6qk{-M¥qœRI8ÏzBMøX8‡¹¤©ßëOSg; »¡ö[• e9JxóŠÁ²å j‘Äd”ãî9»%ÁHPï¤òwS ÝCd«c$d+2Ñum™mÍ €;ò \ìW†ÂyÂŽ«£v=KÍW%‰¥…!ARœy¨Þ®¸ÇU;^ÎFÇå#oƒ@ ¨2g-ƒ‡7&ªÍaÎB’òC’‡ni|$•œþ)é—<…[ÊÉ.´¡’r=©¡‹'+%)m!$+5ƒâÇu‹†®·¸Í‚<ÒgSMŽXDd8ðCaI'¾;š^ùpºqæ n¥slq'ڒ̆6>“ô,œ+ûÿÅl“lîc[páß¹ÿTÕ•e²‚Ó²c²ØPÄÃÌ-I^=²+YUO‰t§•uÑåu΀´Æ,´R„ú‰Æ]1áC"’¹íhÞ®¸?Qì»gDÛþjŒò2¢8ã±®õéEQ@iß’qíÝs/RÕ˜æÖÒæY–Œ¥…ZÓªínÔXÞTu5È;r£ó›z; ¯”¦¹c®(¦hÜ~åKÓ=¯~Ý×1unäÙ!A[r“œšæšÙÞ÷?u»ü?£!í_…ÏñòÕi“}ÒVÜJ³-NçéOÿZúëÿ§]E<Õ'ü#÷U?¶ÅkYe§ƒ;—ù¬¯© æ"(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(BýÓèýΫ¾é­3ø¥ÂL·Ë¿,ÉuçWô4Шøõñ¥:vKÅÖ: F=åûa.wäëì]Îø))]SRCqï°R½ÖšvùÒÍArÒ׋l»T˜-·c>¡ê4¯)^8Ü8ȪÅêÍQ\´5,š"ZæœdØã#>êbÛx§í°ÈF§Œ(×¹ƒu¶°q…e ’ò»SYì@W &Ôd¥Ž^nS‰õ‘µ?åOaH6‚8ÿ } NxW/E´v ÕºëIÛl–×.×Is[f,pœúŽÀ"¥º[¦«ïwXm†ÔJpÐx>ùÏaÝTz¾ù -,’Ô0 ÊûéÑ»F¨Ów ¾ž×’íî;ftErMwœ×âhÙ&6Û; û·u§Ml‡ÕÌ=OÔv—ùçà+-4:°2¢:]é%ÊÒ솔¶d6–—+ê+©`ø¨¢ñ¢Ãj¹Ã¬ÖÉ@A9Æîú-o麙 sõ7|ü{&[–º·ïÄx±Xˆ”îÂÈÉüý©Ã|Q„Iˆk[êÉÇï•ã,Ä÷\A×Ín»þ¸³ék-Ëæ.sFç2†PÁÈû Ὼõ÷®¦†Ín:G\á»@#qõø[—£,¢ ÖJ0Öð%_=1ÑöݧXbJHR’”à¯ß'Ü×SøQÒXC%v’ÑÈŸª×It}SœÜœ«œê+SÐg»2Þ¢ ¬©µí Wþïq[èue ´Žqƒà¶>¾ê Ö=¯ô»ªâ÷ª_µZL€€c)¥H Fqìxª]먧¥¡;p8ØsðvS6؃äv6\õñ7Ó¹—þi­GnDéo=•áÂ…!8Î䶤çÜpqÞ¸»í‰àåGܨïÏÖ2ìà´g'H#a¶ø[窎9d¦Ÿ=×ËåŽ\E*$†]mDáAI ¤ûWÎÇQONý30µÃÜ.™¥®ŽA˜ÎR:VCÁ ¨#¹$c"°ž©úƒprî>T¤w±¤“›ß:G¨ô|KÇQ[]µ&â×ÌÄiÕ€ò™ÏÒâ›ýIJ¿¤«Ž*c©ìWQŠ;„~[åh{ZHÕ¤ðKs–ç¶q•»ª)*õˆ¨0àžÙïƒß Ï{¤·=9kéÕÊUÂÇ;þ¥‹óX…,>ó)õKa¶9mÂRpƒÎ1î).©ðúº‰Ô-ó#”Ö0=‚7k-ÉÆ—€6þÑŸnT YETg,hÚIpÀ'ÈÏ#ç…¿RXÑWÙ6{‹Å2YÇêNÅ(ÆRyIûEkþ£°TPVKE0õ0àÿõÛèw RÝwûÄBVn o‘¨-M¥?%j;@Qq{²qÏúÔ¶òçdlÌ1Ls©m‹y•¸”,>?í£h)?œÒF‰£•“¨‰åtc÷m?¥ô܉Ý9Öo^­‘á^mwKX¢ºB\sÒYI@JNÔº…%dØ&¶ÏP]­vj)!éŠß6ÈØÉ£–ù jv—–†‡~±ÁþüeR¨­••-7Ht\]Úó‚31’Fä[ò¬-ÖM9¦:cqÒÍtÈ5®^t”j(·7Ù}ÜT¨ä!i%?R1¸ žk;_ŽÛwJ=¹¢´œýèJö¼z‹kGápÈ ÂÊåáýMMÐV>¯0ÿˆ±¥¹ï¿p}ˆØðUxu»J‘r¹¹2lç\.8óŠ*[Š<’¢y&¹õ÷GI!’G9Ä’I$’w$“¹'¹[6šEb` †8ü–û>Ö:¾TM/ax¾Êk”©Åp2¢Ûc·lœw«LtõÒýPÛuªÔJœÆ——ÑØ ÊJ²¶Ž…Ž©ªx»eÇ|dÿª¹ è?KOG”ÚŠ…¤¥HP8 ƒØƒ‘Š­TFøžcaÀàƒ±r÷Ô½/—+DŒ9|¤Šlœ“X‡{)ŽËZã«nòÎô«eÂu€­«í«¢ü)ÒSôäÞ¡¹Öp^cÉ ‹c( ;K$'z²0{ñÎEmž¨Ÿ£‡OQ @ŸøžOž^[åq öÆû êß j“¨ê UùB€åã>a=õvOý5øq×ýMé‡R:©¥“l“gÒêAŸÕ-¼…#qSNÅ”ŽJJÇlð*ÑÒ¿g‹½ï£*ºÎ‰íò©žæ¹‡!Î k\âÓŒ¶<÷À1}Yâå¶Íz¤±ÕƒæTþ iãÕ¾@'¾UMÓN_,79¶kŪ}®íÒËñŸh¡ÆÒ´žA­x´Õ[ªŸCpÑLÇ1àµÍ>ÄVá¼SÕDÙéÞÇ ‚Aºœôû§êÕڢϦî:Lè–foÅÆòú˜ŠÖÐIÜ°“‚qÇ'§|?éJ{ÝÚ+}]dtq¿9’bCœ'œ òB€êΣ6úGÕCçs¢1—ûŽOº:Ÿ :i¥ä‹‘xÕ÷+cMÊáBUã”çÖe%M€HïRN9 ]|a±tÕ _ðÞœgSÙ&kÉŽlÆÆâ܉-?ÒÖª7EuÚ©†ªåˆÛ/àÍÃÙ¿#ç¶@#Üò¹™Aä©ymIHŒùõ£Ÿw[U…®ã”'ù‡[Ti=D,]å:”ãø[¯"\4ƒé¡`K$“´÷œã¶iWÕHöµŽ'§ÂŒ}3Y)” é©p¥³Ë¦•°8Rv•{gÞ—û¼šŽiÒvsƒÁK²äÌNá:Ùµ*`:~r+w& *h!Ãÿo#‚“àƒIˆ›«/nF1ÿ>VÍ•¾—`ò™¤¾Ø˜mjŒä’6îý¼W` ÒŸÆ};­ŽOqeX Kgßÿ4ˆ§î˜ÍRp–e-)Nàœæ—Ž”½Áª"åsÄNÇ)öeÅ"ë-¨äŒgÚ¶…a1SyCŒl´%dåò†ËÁXyI$v53ggòÆ¢6LdöH.IO¨œáDEEu 7P;« “.)ÚÚóJlúé OšÖ—7—»Wuµl’=ŽZ¾4\„V$ÂŽ Ê°€rª×7Ye2†“ôV‹…i,Ó1Û ÕÖ·;«k¹Hmfßrh!¶9 q)KÇŒã8íRÝTg¨º¾*ÈÄrŒþ Ïç·Æê¡Ó4túX"“Tg$Œç—ê¬[ßZ2_Ÿ¢æEx2§ý‚ó!¿SÕi_¥ÄãÂTOÚºno°¿_µŽ{èÆX ´—Ú«,pô¼ö-k‹å n©—OºeúYH# gØ“.îÓõ|§×lÑ‘`ˆÜwZԑ궓œ+8­mÕ}! vˆc¦xó ™’H9Æ=ñýû(øîo5ns‡¤pVzfó ô·OúŸ¦n–Û„ÝsÛQ^ Ib;-”­·HÊTª’;±íVþ˜ñ£úëßNVS:K½cÚÀòßCcak›«Ô¬ìr7ÀM¯¶›½}憺µ´´— õ;!À±iǶ>UA­ç&ÝÓËÛŽ z®£ÓoÜ•q\½ÓŒìGâw+`Z!2\[¤þÊáF¤ºÜàé'µmGBÍ–Õ’0[êS7›õC›‚ýÀ¨@Ý'e¨·`¶à†pžøâ‘oºW`½K´ËL˜Ïª4„¨)*IÁI'IW, iݥ±«¤l±àî ½n:é»3vÅ" §’פ‰;’?tûLul”"‚Iš@ní#V>ª‹M᥻Ï3´s…È—i3.“äÜ&}Õ—£ÝDœæ´³e.ÉqÜÿu·(éÙ°—¬©µ!C“M¤È)Ç|¨åÆ”²¦ÈjNš§/Ê–èË“‘%6ÙYNqÍEÝhÄ£uuˆ¹›Ð3ÐÄÛriaÅã8ª]L …Í *ŸJ]ô¬´=Õ‹ÐÍu(à€Hì>Õaé›ë¨+TÎÙKÜèDZ;+³UuSh…%§¤£’R;lÖêëŸ[ÔVØi\Áæ4ï¶6öT«GKš9œöðU$ú}æÕ„«À®hª‹D„|«kî1µJRúéh@;ž‘Ê÷åv82 ¬gkÙø††Oee阚p¡)½DÛW‚²œ~1W.‰E÷HõmE§öQGNý¹ÁýTXÚ­öÛ¬˜öÕ)PT”­ £’ŒÒOœTwSRSS×9”g1ìFùÀ;ã? fÍW+¢oÄ  6¢’Oڢ˲“ Œ„îË€Œg˜ÈÔÒfÕ$ŸnÕã]Ù"ÇCR_˜u¥Œ’1Jù@… ÑîÆ.j Îq÷¤H¢otöÍÉ¥ %Dxæ™>”‚˜ËH@ËBXÛú€´ )Xšé=—Û%$4°’“ïQO©“Ú0œnV„;<Èãȧ!ñ¶0[ù¦qÎué* >ÖîÒ¤£Å;‚p¤"˜Žê9ëJˆv’¤ “f±KY¸8¥ Î}é !XHÁ§aºT^Cá]•šKË ä&Â3œá5¼Ë•-²všp×û§8ÏâIÑ1cé%@øûÒ†!ÊÉ°ƒÀN¬ÜRœœqM Îé´Ð í²tsi̤¨{íHO¤ÝÐ'¸®†Ì4G¨;SÊXðí@pš¸™š£dU3%JVØÕ‚n šHü§œÿ’Z–Þ ²Ð·i[ˆ¸Î+QªÖ˜¸à¤nñ˜Û€»K@ÁYTL+oí]CáÜRB#ãsçVÕŒWji¬²ÙÊFxö®áèkƒk^@Ï乧¨=n*ró –¥cyݪO©©Y‚ñÉUhåpp…WêqèÆxŒp?µq‰õ20;óʼXŽ§…󃯚•vˆ.mµœç¶rUtõm½Êì_ íÌ8'á??ñ~ê£:û®P-ÑdS ·°p¥Á¯¿ÿbΑ}»§3Æ ñû.=ûmõ#&¸ÁCôdãû/uÙ«„ÑBBBBBBBBBBBBBBBBBBBBBBBBBBBBï{áoâÕ߆ٺ®ÿl°[®Z²\O–¶Ïy°µÛ -M粈 f¾RxaãeÛ£h+iì°Æg© \2èÀÿïŸc¶Ã9_Z:Ó£c»ÍÞ|¶–ŽÕsæ¶êmÓ_êk®£¼¾ä™²Ÿ\‡â²¥-G$Ÿ¾Mháoys¦™Åò<—8žI'$Ÿ©Wèdk#Œ` ‚ŽÙD{Åͦå+åÛÏ*ïï^UæòÔ¬•3…(Uíí76çÛ!ÔÂÚ£¹ãÕlžÇŠoG,Æ3¡Åº¶8î=ŠrÚvÊçr7ú(ÃZðÏVœmlÜTÑZÎxœ{x«máÆ#ƒa¿ä’¬¬tNÌœ'=¡o†àã,%æ›ÆÉÏ摺F’3†žêá|hoòöWÓ:‡ÔÛ-Fe _bxÅkŠöH&ѳû&tW¹AÔã°]ŸÑ.Ÿ!9:b-š§.›JÇ#P¡ŽyŽÜÖÒè»K˜t:S`:¢À:‘Œ¶3ñÙVú’î*]¬ Ävw·Õ}2èîÔH†o·F}C-òâŽR]ð—ë+̦6?K}—] Û"6`¤/**Ïö®õ¡«¤xò¹#•¦*ÚýZŠb¿+äfF·ª\YŸa.¨S´žãó÷«-âé*[K¡ísrvÆ?Ý%53^7 qžØ‚å¶âËŠKi>“I#%9ìsÎ~õRê Ä&ºUè4r~wç j‚™Ãùà¦ûeÒë¥ì‘õs°f5§uèN6¤¦Èá'ÎÁ#¿j„­êJË7–ÆE!Õk‘ì~¼áLÓÒ2ªSL¯cì¹éQ©-ñ®°³é¶Ÿ_¯(´•8ÚH'€QÈ{WRMK]sŒ]YäÒ´»/À$dm€yÏ­Í SSA˜_©çe6ÿéœX3ïZ¢ín‡j€ù;L4™º¸~‰X-$•-^8H5@Š>>ãu™¹>U;ðé Øzñ¥¿ˆ¸“œa å\­Öûœ²¶Vœ;žx—eȺ—©Rµ •ÈºÏ™:vý¨uÇ”¢†@Â[çÛëFÖùµGͨËå<¹Î$à ¿·o–ᢳˆŸ¡Ã@ãûŸÍ4ÃÕ—*#Üy©M©%¥¶¢•RG!@ãSZ 4òT1”À™ItçV¢vÆ7ÎqŒo•/ü2´™p'm°9ÊúëÒïƒ]#¢:w'®ßú‚ó¦ãNŠêìÚM¹%›´÷T2‡ßX%HîÆOuØö¥G€}#Ñ=<ëψӗ×ÎÒYNÇðãÀ$N“üþÎ>åÎÈ\×]â¥ÎõuŽŠŒyQ‘®b=w{v÷<—Ïk£64ܦ*ÁóÂCªù_ÏO?Nâ8Î+çDÒ¸¸à`oÉÇl·Ç;.©¥…þX×ÏüÝ(Šã~¢w¤Žõ3J°ír£µ´–ÆÚ¬VBóÝ&xSëmÊ}PK ¬ gnyÇŒâ¡ÛLß1¾vtdgã¾3¶qÆvX¿V“§•ÙZRíðŸtÔzÑxfñfÒq=y7ÉòÂÕ"äæܶÎ$%€“·pyÍv§FÝ|–åA}4‘RÀ׺W¿[3öÒÒ#Îî7î+LÞèúÞJ‰èÜÙ&Œ0wvãsíŸÍtWÃVžÓ–¿ˆUÔ~ŽLé Òn±"%žÙ2ôäI‘ŠŠ J[SkRô‘•¨áD×Lý—:zŽªnEÑrÑÉM;^Ø!|ÏdÌnAÁŒ±Ïh8ÉÎÇbFBÔž3\«féª{Uí• ™¥¦WµÌ<÷¡Ãàc~BàN¯é-Ccên·ŸÕ <ôÜä]%¶û1ç1ó"c™ZUµ;Š›ÊÁÈ( p[ôÍƆýYÿTDMC¤xs[,nx•þ°p5jnà€p ˤzFñGSg§Y@¬n’Xí:Æ7ÆÛîpwÁ\ýª­pà_npmh¼· —TÚSqŽ’œw¶ P9f¨—úxi«e§„<1® ñŽÏh$ÈÊØöšÙ&¦d’é.#úNZ~‡‘ù&Ç‘ÙKXÕej’žéz †ÚôǪSä{Ów]•‹¤%^Ý)ë„î—[.–ì ÞírKÒ`Ê%0¦- ™´¥Ü`c8ö9VèðÛƪ®š‚H)álÍyΉ/’N̵íd˜ÆÚ¿<–¾êÞ€†ï+'|†9kYæ4ð¼‚[ù~XS›¯U¾5$Õë]AÑÍY'YHuÇæÛa_þŖJÉËiSá#èÞì1WûÏ‹=QRÛ»ì%õË¥a¨si¼Âs©¬ tšOv€¤mºªÛ:;©éàþMq`§nÁæ-Scä’Ÿ'ܨQzÙ[Ø£iëWHºOÓè ¼—Z~ÍmSs6€@Bä-jZÓõsžIÁ'ZóÄ%ê6Ð>ÝILÆZ`ƒËp§Ys‰nûç’*ÙÒ^GlªuT•³Î÷ $™f}ô>ØáV êËЂmè|ÊgÐ^–ÞrUŒlö­>ùÞY¨€@ø8ùÝ^M ;eê*IÖ2uœÒö£ÇKVÄ-¶l!*9RB‡ô©YYIþµ(ÔjjõÖ5µÔtöú‚<ªpC@vägœ¾8É$rT]ºÁ -Tµ1™1Ÿœq·¸gØÙCƒ * j©—…=¨{Gmß©Jþ`Ôi %Âk#ðU×¢ú©'IhE¢oºNjÝvÖßpaEpd„—c­$}C ’œã)Olœï®ñš¦ÍÓµ9[GEKµ1§Toèœ þFq3ŒœêŽ©è˜kkã¸SNø§ˆCHÇ`àsó¿;ªd`ÍÿÔE—·šÆöŠ=V‰úT±ÜV¢«¦|GÔq‘ŒƒÁVºz£§ ‚FØ C7LÄj%®âÆ£´-©/)¿—Ü£"2Gõ¼€HÎxž;r3-5š°E?Þüǧ$¹€SÀwÆ vÙÆ1–‚ù+œöÈÒ3žÇà|þXZM–K†|ôF>âd5•¡Ï #88 –UÃøšAP¥:¦Î*iË=Æ?Uy\'›ëÒ®/•¼$©GùŠÉÉîMTê.3ÍRú™É{ÞNI;ä÷ú…G££¬l ÛN8]©>%gj.žhÝ!jgSÚõœâmÇø’Ê$á°ÑØÞx J[Èãi¨×оە·Î¶Ø­Ì’Œ$ el„aš=8ßÖ7#m' d-dðF*+ÅEÆ Æúi?4 ·}[Ÿý¤œ{ƒ¿ +b±Ë—É‹–¦Ã-•)%Y'œŸ÷®né¿n5´ÜÝQ§Êbwç?ßõVK­Ò8ä5¹ÉUÕÍ̔Πìqâ•ß=ÿâ´5ò'I™ÜrIß<«• ™g•ÜÇÔä1'C¯ÓPÛ¹²‘žO5%fccÏ¥úd¹•§?+‰¤[d;5(ŒÓ‹YVR Qý«gSM–à­“5K[\TÚ-µÆc”¼­®'…¶ AO÷¨Ú¸Ë}Gcì¡].­ÛÂؤ¤#Á⣉+˜ÉJd«8§û–§l„g+lÆ’´ ”`v¬!q È\Â{bÊ©Q’”2•+9l¯8Ò9HK^Zìµ®uV››¬#i‰®X£ ºû©–›ÿ9GêÛ÷Ƕèüê©í2ß!¢{©bœð3†ÿ‹àw=”üB¶EVÚ7Ì5»€{ŸolªjçmôQ€Oœy­]OQ•±)juò›-°$.SeNÞžO(-Âs1J¿4²”b@J¶'Ïbjqhl£PTj眎骆֗m +‘ôŒdW´N8퀞Û\ßQZ´ôõ('r°¯µyX]µ1HO!Hå:î𢣌Sϯñ( † hˆÁT°’œóÏšsK»€ pÓ”û: ØPWÓŽjjóGé¦Ð;²aMÊD|¡)ÏñUÂ1°R¢6û!dÏ*u÷§ë÷ºAîà&Éò‘¿¸¥ãœpC9Æ@ZI9žÔ¡x<)íÊTàƒ)"Ä‘f¥á u#Þ½ÔZœÇ8M/$µÁÈö'e=a[¢•»zÆné99Ê”Gi„8¥9ß G”]_*ËÓZVåsJ VÓ=ŠÕSVŽ„ª¸; !ƒÝÛÙTî·(©ùÝN°Ü,û5)y…q½' þ)§Pô=]¡ÀO‡0÷ÉCÃuŠ£xÏ©4Ü­i %Ô[?nEVŸE¤yá?¦«ÔtžUsrµ4ê•·žÕ‹kvš§´aE·-X v©&T¶ÊIÁK­–+µÁ[!ÆuÕØqŠ—¶Z¥¬“Ë„d¢j˜£‘ØJî‹•©öÙ¹Ez:•ÈÜ;ŠÊïc¨¢xeKt’š¶¶9†b9S+&œµ:†]”Ó.• ª˜éÛtx5->é…Md­4¨WPtó:rdWíÊ" „ʳé¨p@>ÞGö©ž²éêzIšêc–•~®b龘Ž¹â7I¤ªÅ}A…¥ÀeEu}‚}½çâ¾JH<)=”=Å1»XŸo¨1I¾;©;-{‡Ê]Ó´<«”fW ö¨ˆé<ꆴw+¡k|’쯨]1ÓÎ|„gœiÅv—‡ý$tÍ‘ãeÇqwqhåtTxê„ÒJSŒŠÜµÁô‘ÎJÓ²J$q[ºÒš[„9œdžõNêªs!Ð÷¤ã õjÆɪ[qæ0¶ß$… x­9Y%=a"£`å!Ÿµ1|Àødz %‚÷±1ØÎ- Æ1ÁÈ­xé&Zo‘EõÆü8;ñù.ÄðjäjavØp ù‘ü`\§\~#:¨©®­ÏJèëMdþ–Áà­~Œü¦Ž.™£Œe€þkægÚ2¶izº­³é8EÌÕ´VEEEEEEEEEEEEEEEEEEEEEEEEEEEE_®°—’£œWŲA_gDd¥Ì! ”’M6‘à FÆBÃnTw3±@{ŠŽÑ¸a*ÁîœC—*¡`ŽØ¦Ò8DÏJ|Ç‚vV—LÝáD&£Èf*Á s àãßš­W×µÄ4÷ýÒÌšç$rµÁ¨âi¡x–̆c8ÿ¢Ø)Æòœæ“¯mT4Ì.Èc°ù*¢’iÈdÞß êךgQu+PIŒ—-«R Û_YB¤,#>©Ï $}>Mvw€¿f_âý77TÕÈ<Ö—ØãŽî<ç†;r›ëNµŽ–¹¶ÈÆF\á¿ä»†ÉÑ;¶Ñ¦5 Âí.ë¬Ô%…òÔTƒ„%ÇÓÏï]SÒßg+U–*+…CÌõäeï' m°hǧ~ëTÞ:Ò¦¢I"h ˆ~;ü•Ôš*ìͪµ¢ØÜÄ(l!c;}û×ntíiu8·1™ùÏ¿äµlAÒ\wSý>Äûz®ÆoÚXô?RHûøÍXmÖ§DÏT¥Í>ãa¿ë•Uêxc cÏFvÙ)Ð¥­¸ „¬ÿ1>ù§Wé_&5gOêJQ‘“ jä>­^œ1¥AB]mâ@ö¯—_i.ª|àÛ[sƒô=‚ܽ!n þi\}pˆåžì‡š†_¹¨)¼/ÿÚ+±Ç°ï\}Mmm|mŠ<ÈïIÏè9ÊÙPq¸€‡®Â® qƤ·2ôÄv’úÐ>qÎÏÁ⶗‰¾z‰äaš0ÝDqÇnøýTE©ÚZá€îC¦¬ËÐÑÛ»¸üiÒ¤¡¦Üm Û°¸sÇ¿€O欞Xeéæ¶|‰LÅ­pÕ¾þç±L.Ó¶¯ÑŒc…8Òª²^µ é:›ËoG`®2 Èl aX!Õà„‚{`×Cô]Š¢ª¤ÍO/›ËrÐG:Ηcáۃ쪗lŒc\4“¾ÛþJ‘ê~¡¹ÞµAµÛStzRÚây[IÆ•$œÛíZ‡«úÎïpº:ØâèÏ©®põ4c`ZüþØV{e¢š(5oÁö?DÈÏ]zs§®Òµ,O1vCze©O!´íÚ’¬ç¾ryȧÖïz~†¢[$%“<»1?. ÈÆ]Ÿ®yú)z2²f2·l·|ä¨vžëv êkW-`Ó^ª$aÄ8ÓEo¶²„${“çŠcfëûÇVÐKj¢§ Z›’ü7.!­ãp9ç²–©éŠkdâ¦wïÆ;n¸¬}W›r¹È·ÛTõ¾ÜÚ¶/úJˆï‘\OÔ½LëµC-ˆðÓÏ溥:F8c“w×7+V"cŽ°ä÷  –^¢²>“íƵGÅkôê“'oôø[ '0Ù%~äÄùïÌj*-ÑÔ¼¡„-J `TI?¹¢©ƒúü÷Oáf†€NêWn¸6ߧ³qçÞ È’7‰pá¸#l„ëÒæ–¸dˆ]]+ª=høŠÔúNÅ¿jN¢êu%‹Mµ—•ê:´Œ%ïÝGÆI5/SGÔ]o|Š'ÖWHmà»Kr@ÎÀ4d¹Î8w8òUf’ßgéº'Ë ËÝìsÿ?%õÿÃA~:Fö«ø¦‘+SuFëI³éˆrTË‘ÜÁÅìP;3ÎåG`+¥üEðÃÿ:wî½J Âù;rÖG!kb8ÿÚá–4ó#³¨,iÜ®}µx™Ô}_vôÈÐÆ}r–çVûžøà9+€ôäm<ýÊÛqÔ6Ëê4”™>rÞ]NÜ–÷‚°àû×ôí/Þ¢þ1®çÊÀyÆ2¨—n0¿+¥«êgò\Êg7Íhþ®?<²»JóðM{c¥±:¿¤µµºífš‡ž·ÙfÃv5ÙöÛ^ÕÖ T {ãÓ}}ö;¨¢±Å´V ›3u²°Ç9ov†åÚžÌ`3¸Ø…§m^9E%Ùö‰às\ÌH1‚FÛì@=²©@ºÙ¨-·Kµ“@ßäB…$Ä”¥  °è)PQ#Íi;WÙ«­®4\©mÏt1’×KH-üYkœÜãlz¯,´Ò¶ *­Ã sT6ŽÕ× „»KA˜È%ôú‰–9ã?ŠÔ0ôíD“>G—3ñ ¿<ãû«Cï²1!>“ÂXtMCnÌ]µyÀx•!)ûîµ7–Õ<,ng±!À}AÇ FÞb{HwÆÇöSÓù— Ñß…®,W[š’l¦^ÜI'q)ÛžùýóÊEÔT-ÐÍ°;~C„ÇyÒk ‘âËi^À´–Ü J’~ã±ã±ÁªÅîÛ- ÞLøÎ3±ÈÿŸ© Ä5–gotð¡A%$â¢ÃRM¥·¿ºO²iöYå o($7šôg’²c€å`!8¦wçê=‡½d'°Yjõ )‘±Ä€°kÉ’°~†×§ˆK>ù5U)o ¦¡Í9)3Öè¨BÒÓˆX#¶x¨±Rüî›Gpy)†-Å‹ Ú$ÕCbä†\ ,9úǃöÿÅYmU’6G°?Žp~¸þÉÝLOc]¤³Ý7Üu ›“.ê^ùTPŒà œdÛ'>ø™µ…Ù Îažp;ge“-Z7o'“î¤vFgj(ò~‹Ä{|$ïR Ý2T\Ú?¤n¨ð23S0QWײGDà …™v7Ñ8Îô‚FO;áBWÃ1hsà ΨžÙ÷Û`´³`¹KnæìX®H…°ì‡IÒl«œžI'°æ¢­özŠ˜¥ž’Ȇ§q°Î;Ÿ~Ã%3š®(´¶C‚í‡ÏüùR­.â­%sÌp²GÖJ’A*ïÜÜ^ C%5_Þƒž3ÁÁnë[õ”¡ñá¥Bg´™R–R¨ „¶+tKnŠi‹]†íòÙk©ªÞØ÷HdÛ£7)JB·…`ž* »¦ lÅÌ)„5ï#li‚T¢ËE@}@Ÿ5)cÀÆÊV•ø:‰L3š[Ò’R”‚x?šÓ½`™æð Ù=6öVµFVÚ''¹÷ªš9] ÓÖö1€•4ÒÖæ¤Hn;½Š‚ñ‘šˆ­›Ô3ÆTÕÆO*"ö®¨µ[m ±*;•](J³Â“àþj®’…’<Zìg±¿5¥«kjæ½£ñÝ#UœÂ}©vucÒÛß¿síù¦ì¶Í m@àñŽÙ8+KnUœÅºìÌs=Ò"1{ð®FO·î+mÓtÅâJÝX5C«}ÆxÈî©VS—ùNÙÎ;(Ó‘žša!å%+%Ì>ÇÞ´•cðƼíÔìs¶ âÞ{&.¡[#»¦ä";ˆRÐøÀ¥¨b†7Œ8oòtÝSüÿPå!èž—Òv¿˜ÔÚ‡UȱÊôÄx¨yc ‘’®Ý¿×Û_g*+ ›Þâêg7ðè¯ ò¬ãöLzþã]'ý­$ã¾\Z?eMu6sµ}áøÒS1•,¼ —†?R’8 ç8ÍhÏnqÕß*'‚_5ŽvCô†—|–‚@>øÙZz~ÇHÆÈ0qÆsÍ@€Êâ¨YÝN1™LG |îìNjH~”£…!L}Í$ñŠl÷>TD¯!Û+CAê(Zvb$IôœÆ6…'±«ïDõ4ÉÅD£Q³º¯Þmî¨f†®ô…ñWc·ih¬c*?¦ðØ sÈüvñ_Im_oš:k3(Ý.,-vÆpGqÙsÕ_‚²ÍZdsŽ3¾Vê'àϼ\ß·4– ­å©¦ÀÀB ‰}€¯–³µõ‘ƒ s‰ØH ­í°:(Çl¶­\RˆP>ô›§pݪJa‘²›Ûgú!§°Í@Ürò\å]y¾[Œ¸…ÔÎ$gµ1¡™¬~=Òê.Ò v·ÖÓÉmGœâ¦j㤅aœeŠËa_ÊJ”95ZpÉÙV&xÎܧ;jwÈÝ·<ÔÅ´zÀ“)? ß‚Qœ¤$ã#½Mõ)óÐ6ÂiUu)8ŽÆªM8È*e¯ t>çœsX=©¼œ§tl(Z 'µ`…š[Œ&91×d)$¨vSÖK” «$*”Jµø)æÏc»^ù{l'æ/9;ŸïRªšÇùt¬/w°HÖ\!…ºäphùNWt·¶~z‘—ßêN)k…Ž¾‡z¸‹÷^P^£›xÜúªùm­—xÅ6ieX†áY½/Ðú¨:’žÓ‘•&k§Û!#ÜÕ£¡úãÔ×hl¶¦Ï)Àø÷'à*·Xu %ª‰ÕµŽÃ¾Š§àǪšN€Ÿn»[”SóMÇ$?>NÀû×{Té÷ÖÖ6ÇQ ñÕFq­ŒÈ{Aä€FŽø9\žß´ŠºGBXXñøIÆ’~½¿5ÖÖ…M|ÒmƺIž¹ÊhmÒ°¦Žø<Ÿ»’/°÷HVÙM_­Ò9 ‡µØÒqØ`ƒƒØ­qñæïM\_NÐpGüî¾vkÞœÝt6 ¿éënP†ò›.#ú‘á{|d`×Æ/<¯é[Õmž¥ÂFÀâ¸ËHË]Uؽ%Ö”÷JH«"ôë|÷’ î¤—–XQ)<×0Îàöámyý®T³Eôðßä6%„ú%a8kiømÑ/¼JNÄÏü*¨º¨QÆtîWÒNž|;èË=Š,Òˆ³–àÊÛW°>ÿc_w|ûtÅ’‚;„¥²¾A¸'#ÃçþeqŸWxÁr¨ªtC-ºã¯‹9§´ÜË<;äGÔ_`žTØ…£>FJqŸø®û}tíšÍ5=¤‡E!/gÍÛnyÆqÌv[óÀ«ÝUl/}^Οc…Éûêa6”8ð8æ¾vÓ]à[éôÅçeÖa}ô°v–Á )ô÷iª2‘¶Rˆ¶!Wl©L9•p{ÖR48l§Ü«+MÞÚaæ”VQŽãÞ ©}4þa' ¾ƒ^ã…kXÔøäœ`Í]&ªŠàßVu*£¤û®íVƒé‰u%¡ê6HǹíV®èš¦Èw §Ô}^>îæWÓ½`D ,l$/ w¯¤Ý ÓmÂP2>WumØËRT¶{H„ç)ÏJësnòÏ-UúGäªæ䕇TR£»ï\‰Õnq•ÚyW:7e»¨Ó·°Ú8¤© ç5¦ªºÔ¥8!M2רŒw_8¾/ïÎ\4•é;¿”Û.cŸµUè:‰× ŒðÀº—Â{c`Î<¿™GŃÉâ#«.'»¼<×éCÂËzjŒðòßí(WV‘þ/ò\ï[%i”P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P…û,kL¼Ê”ÉWµ|6}Õ¤Ú¢òyRëv‹SªmIo'-z+£tõ¯LÄÑ*é&Ö˜Òî2•¹1ÞZª´#²NÝ©Ið2|×zt¿ÛW¤hà†ÏOFèâòØ!ÇâÁÛ}±€O<-3sðŠç#ÝU<¹Ã‰ Çl«¢É×ݬõv;ÍA´8êR•¾pHòO÷­¹Óiþž¿]›ABñ >vÖq;“ù*]×£+)#ó%qöWÖÔ–›ö«*Ê-Ész¶¯›G}ª?lòk¢¼3ñ.’çw™°a±€t’vÃ{ÿš ßlEN3ø÷*èÔR´ôËä᥮ .Ò‚ØÀsvåŒàþs[›¦®ÖBòÉá«|äì«“ÓIlóG« ¢ˆl»#¥YR½Ïÿ¦/’9”îþ$“#v âW u®ÎBÚ“ )NÅ‚­¾~æ¾N}¨¬7#Z*áa »oÊÝÝU”Z㺬XI_ô»Ðn‚DmZ©Z$¤çcirpy$œøªE,=u²¶’`æVëÖÝý-å»ûÆe<W åíÁÇϺßomL+ŒèñŸu é¥-G?Qý?½=û¼Ž{•3NÀüûö;ý;$fÖÙ×»q¸P´Ê7ˆ?‡¢_õv!'¾Úgáýò;„ µ‡`gŸ‚‹9‰Æ£¶Š4f“"Zz,•¤6°…‘ê¤x>ãó]Gàý;XfaÒçs‡Ÿ®øU7õ<ŽôÚ8Cú …ˆ2î1¤7 õíSÈä‘œ{þ*ÏCá”"X¦¹5ÞD®Ás@ÝG‹ì ´çàª×YtƒA°ô棼ӊ’áÉ l;±ÿl¤}øÜ8æ¡:ÇÁÞž‰òGXÈ.nÂ@ß?*Ómêºç†’NÞË–º‹©Üé^œ3I¸æ™¿´ñ »E·’ T•AÇ®Dñ^ý=Šží.0?:\Xt»÷ýxåmžˆ¶ST5ŽwÝ|äë-ÎÒö¥ ²ê¨üV$Jy1Ë!2ØS€I'j‰NïêÁ*»â‡OÚmµ†Ë\*ãsZ솑§#v¸ñ¨Cr1Ó¾”½Ük]WOå`ãsÏÈøQÍ©ïzPZu~Œ»Ý,š ¾´I±]-½Ì¹ ƒ‚GïZêϸ[*E]¾gC+s‡1Å®##l}ÆÅYnVºjØ]KXÀøÝËHÈ?’šjN¥jÍqxrÿ®õ ëRÞ]ÀrTçË®/¾£U»´õµ«©‘ÒJó—9ĹÄü¸’Oêœ[mÐÑÆ!¥`dc€ÐRè]Y–Ì U®ß›c1ù†ÖÁÚ¯[ægÁàSgÏTÖFÆ¿3¨cbs‘¾vü¹HÿÒ>G’umºú ÓŸˆŒê˜VK—UJcÆpÃ~ûÝÖlÅÆK{ JI;B³œd`fº»¤ú÷£+L¯‰¯cƒšºI€ÆL:ÃqØ€rO •§/}y§tZÉõ`‡5±5¿üN ç=ÎË¢\êGÁö©¶]m1sµ0†S"S×e*ÙowÀŽã‹[ǧo¸üÕߨz—ÂË¥<Ô}5G¢<¼ÖÍOv6>Y’GJF0pùT«Mõ•$íšç ~NŽÈì󡫦õ®ÔÝÖíl·i}a±”6¨p!â¤öÄ‚­ÊüÙìkŒ®~'% ŽŽž s°ÄÂF8Ä™9ÿ¢p·Œ="ðØæ|¯{ù:ŽÓN1û.’ƒñhÔÝ!¶Zz‡ÕØ+rÔÒÞŸ=²‹ç%ï“Ñù4zÜöç•[¥µÿEô7›å–Í;Wê·„V£ÇŸ°Ätd8IØA „’BŽ{s¨úWÄÞ…éziª­tÏ«ª“@ ™ŒkXÞdÐð\Xv„0œ¨+•×¦ï×Y DŠê$µÎÔO c|Îã–z÷âNj9v/à ÿ`´Gu×&Àrûê7)*¥¥!”-žy8$aÞ¡:ïí m¼TÓIOn0ÓÆçÃç—2@{66>=ùÒì`V};áÕ}#$5m{Ük¼¬ãÜí½ÆÊ¢êQ4öªr´ÏNíš ¦ZôœD{„™2sµ—Ô¢ß%8ڴLj½On¼Ô²{}tMh ¶7Êðíù&W¼íÀÆ>UÛ¥úr¢ßÙSRê‚ã\Ö·@}U]üAТHöíT?»Œ+9vÕ¯ÑÇ4Ý×[ØmúŠÁg¿7ë©H…6q†ÅÃè^XSÔ-GhmGø àÖàðNßG=ö(«`Š¡»‘Òcé>ƒ ݯqÇ–O§VÎتO^ÔÕ2Üù)etnÛÔÖ‡¹»V“ÈñqÆë¶ôvŒøbêïN:ƒr±èôEïMZç\ï)DÉ­ ¥¥ú mÅ}EÍ€§`ÆÕq‚ vÿHôw…aѵ÷Š{a¢©¡ŽWLÑ$¯pÃ_弟,ä·.n‘ÆÁZ&÷Ô]d»SÒÏR'Ž©ìdgK@É#V[ȹÁ.=°WÌ ¥­ÏM„¸êÉ $ý«æ3a$à ×]2NÉ;ï:‡”Ó­­.Ž’>Ç>iGÒ¹¤‡lGeã$k¿à­ŒM-”©E@}7’ …„´ú¶ s—Wö`e?ø¤FÜ„êMÿ0¥«qäÓŸ(„ù°û,Ò½Ç8†e››„¾4©1Ô§#¼¶¤”(¡D$ðRqàûVLñçËq8ö<¡î¼–=¸pÏêö.BÖæ2{0?°¦29Äò¢j-­v@'áu‘齄  §qHœ ´tïSÕAQœä{`ìµÿPôÔoa*¶fô벜J’s’½n ZÌò|Á’µeÎÆÖ ŠœÅŽ§›KûÁ*OŸjÚ“ Ú$'r©sÀtºE16òÉ`sÇj‡½±Ñœ³u#BAv£,¿ë>…'{¹¡:¢±’E¤Á[O¦ àáI`Ü¡5m¹A”Âå:•´áp kéc$ <.Š¤¥qs$iØ ÓÆ*-É*ÜáR¶¤{}êòu44m„êøÀè´þk¦,‰†ÊT'%Odn çmd.~gýœ¹™•·e¢åsvê *3ÍÆp>¨ûO J@ãöïVê×—ÐÅÖÆyÝ[­P:¥Îqì“Éh;§gJ.%L/ñØÓ T-.qÁJ1ÚjšÁî8ÜeÌa„¢ ×ØÜ> 8¯4S“¹ßŸ÷W–1…ÇXÊeô ›ÂÔT¿*=ë#/«+9œÞLR”¨÷â¼2䤛(à(“à™ÛqÆqS1 ±H´*͆Ì5ÁRP;³É¥jch`تíKäÖqÂa¸´¤¨ß#i ‹¤å>¡sx*52ç!)[Ô?Óã5œQr§#…™Ô›£!Õ¡JP9Íg)à%ám¤\Jt¶Êô\ڮƛTŨ$eŒ¸V, _6צUž1ßÅWjXr«ó-ÙÂh{åg©óËdäÚž›–¨ô©] ¢ÓÝHZPÙ¸¨îTnŒœ–[,¯r°3S÷†»%7©hà%wYÀ†Ò½É#aRI˜p›@Óº¾Þô Õ_ÈΖ7' Ö)NJqïI=Ä/^ Gm•¡+'ý)Õ²Xĸ‘º‚k>{"è†Ýh%h9¬jÈ:v (e ì¢Å¢Ê¾±”g½#œ”“]®-¨™²ÈiL¸Úà•`÷­‹á·WºÏ^ÙÚ7÷<X¿ÛMLeV†¿Õ¯¶t)ÖãNÚ¤•û£îHñ[¿Å¯c¼[€–6É‚§·lìª]1cu,äZ>x\¯©aÁiÅ¿ ” ŸÒNqÅrÑ–7H|‘†ûr¶ýÒ€NWrü_´Ö—Õ·µè1ó 0Ò×Ù¼÷?Ÿ½wïþ×›]¿«æ¨¹`9ÌÒÇé$îGöÏ`¹¿íCj­®¶G 6p ${¯¯º÷ªZSFh{®°—s†ìšÊ\uG€‘÷¯´>"xŸk雽E\ñäF20G¬ök}É_>ú[¢+îW8íÑ°‡“¾Ü•À¿Žm?h‹=ÆÛuN­J-¶Súkæí¿ÿSk|t’ƒHã&I`#añ²ëÿ²í\ïfHÀÆJâ]cÖ»–®Ô—ýIppo˜ê–¤ŽÀclWÌÿÌoö_üY¹ ¾£«¼•TÕ¹k´P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P…ýzGÐ}sÖV/· ¤Þº[íÍH{!-µôä$¹Xð+â?Hø)Õ½AC=ÊÏHéiàηì g$dã| ×Ø»ßRQ[ªMU VW k°N~Û!”5%…–Ö?Ê pG¨âïõpU®:¹¡þé|N J‹øMaIuaJ>p;Ç5(Éꛯô¸çô Xá/cu*™Ö ÓÚM,âÔa¶Im$dî$Iý€§U7Ë…E-rɘ’;žwçt•?MÁCª@õV»{¹JaQR§”ÅDÃÞ¢™@Öœ©—B¨ ÔºÖ«ÂíÎA wåC¥3ŒdŠmVÇéÀO? õ° 5wá3ÜŸ ¡×V®ÿŠFŒ!OÃåH2TãIÏב4õǨVxó…ž×-¨²ævm·œ¥=Ô@'ÅY¨únã9¼Ó1ÍŽ óî†ýH ¾|Ó}ÉäÎ;ãÝ_Z+âSQφÌ-Ø©°¤¨§!GœãÞ¥æñ_¨(ál0Î[ŒŒ´ãcÈ*‹]Ð1Åúu•õOáXZžÓo·ªd½*y!Èû~°¤Ï9¯¯ÿbïé_Ó¿s®~jAï¸=¿%Ì^%Ydû×›Ã{®¬†±=×C©Z·}C|W|ÛÙ÷ØK¤Ùj*™ n Q]IË\ßR3€q£’{ŸÍi¿,Ô•Vé ‘e߃a’sþ~ÊrÑVèæn+µGO/-êa*Ó1ä ¥,€B‘Äöí_'ú·Á» äÏA)ÝÇ à·ý–ô¶õOƒj”;-«u¡p­1–µJF8[¸ÁP©JË´ßs4Vø†£øšs»»’‘­.”ïÛèµiHW(3œä™2B°¦Á$øÏì+aøEt ªsÌ`;žÇæ :–©¯H;+ªDqf;÷& e<•)a¿Ò•yÀñø®ó¤·S™ºL€“Ž3ÆòÖáä ɲÛhvÐ*YŠÑ.BùÇ’´9Ðäj 8·¾’A㌂=ÑUI€šwzñ¶xÏÏ°&\ôhÕ3ŸÓ0n3´Še©PÚ¸=‰ »)KÊo~ÜSœ‘Šˆ¹Xù)Ú|Dµ®>­9Ø8·ãbF7Ü/`¥Ð5“»ù˜Ü¶~SËl úóS3hÐz^A¸N‘éÁµ@Jß_=›lT¢1ß½7³tµÆÿrû•¦™ÒJü–ÆÀIÀÜã;àä¬*nÛ©ŒÕÒ€ÆÜìÕ/ÔšsUhkõÃJêË=ÃNê(Že”‚ÛÑÜÒ´ÿJ‡±æª—‹<ÔuRU°²XÉkšv ŽAùRÊèjámU3ƒ£pÈ#‚=Ç“h½ ¬ú‹y‰¦t>ž½êíHú¶ Ûã)çœJS•„ó€$ø뤺&ë}«ûžÓK‚ì4d€9'°'¹”^:’‚×Nj®R¢jqÀR]+êeŠùÓ—] ¬bß-JôîqE½Õ¹oV3‡‚ÙÇ“ÅcYЦK<¤“U9ĘcŽ‚F@q‘¸Ï!dÞ¦¶>(ª#¨f‰Ô¯þ9ÆS|E8ÒJwsíZâp2¬/‰ d)…Šdv¥CTÔ¾ü@âTóm¹±KF~ •`à‘‘œ{iM䶡Ž©it@@ÜîÁÁ#ƒƒdÚ® Ý „`àžÇ¶xW¶¸‡Ó¯^§Kõ£ºiw™mæ‘wa Í‚áS}žÎ#@ƒ„œŠWÄšk$W"zmò>‘Àæ´´žZìz]ñ °UÞ˜}ÙÔؼ1˜=–¸vpÎã=Úx÷+F™²G½Ü£[v\WÝVÖÏ ·U‚pB2¯À5X°Y¤R’Zçq†¹ûý ¿@~vR—‡ÓÂgÆ@ùûà)3–ûU¦Tt³|u#×mèÎÇ,¹ýMœçôž2;Ó{í¦Š*,Þ`ÀÎXæ`‘êþ¶{¦´µuFKãÓùƒ·b¤7}#{€Í¶{²!Ìcæ^Qïõ‘÷ÚùÑuvæC$íôÌÝm8#-Ï;ŸË!ao½E6¶ŽXp~©‚m¶ÕÎ3rL¹›ÃiJAHJ±É ŽSìsù$TÌŒ¹®Ôï¦6ïÏ?#èASR÷nÜ”̶””8ÚÛQÁǽ )ó£º@`(”ŸqN#iä'‚„­ÅÝÍ›H›Î™êØ»]ä;Õ•–Žâïõ8?”ó*ÀàA8)óW÷ͺÖÙ-w7*Adð5²G†û¼r0ýAÏ-Uhé$ª¸«)0Ȉtr×~âk‡Ó±ìªÆe>¥ ”ÑÔúV¾—j…t’‚Ñ»4—ÿŸ´&gQn]•©”â”êm$˜êçê;¹dž2¢8çƒ[g§ªºî-uå•«9.òÌ!‡}°^ ¸ä‘ÏeE»EÔžie·Èl]µ‰5ÿ‡ U•õvC>i±³1«iu.$()ÏO?NòXÆHfµ=ÁЗº qÒApnv N9 ž½[ãœ@ÑRAx‘°'¾3“„È’IÈüÓl'EnA+ÛîM&æÄÆ ôº Õãƒ:GôÉOiœ¹á&^R•\HG5‡mÐZÉNì¤%/ÁqM›&—(:ú`XqÝ5H³ÃD†–ÀÚ•rIÿjß]3ENø[$gsÊÐW¯1²¹“Û[PŠÞÜg¿‘[jÍÆÊ…pÚL¨ýÚJ”…Çšuv wJPE©à•mnÖ·RŸå“Z÷@c‘ÚFA[VÉ;InêK<›‚ýBʾžøª \‚2rVø²\öàvW·Lôšu ÉVöÝ[1^–”¸½¾®Á’Oõp)çJô‹¯“M ek q¾A¨ãQnúGÉ(þ³¿([!µÎ 8ßÛ'áX¶hó}Z@Pu`ŽGâ¨6jIåœRDÜ—Ì*•ÆhÚß0ž¶vŠµIf×uŠâá&;‹DùÜë‡Êà[ÒíÐô³Y`ª‡ùb7?WâsŽ£±<ò«ôKPÇÉNñ«Pc€º‹k‘T *Ù.д)D#ý*ƒEÓòÐÖEW(Sdd¹øÛû¨šŠæKãIÛØ(¾£ŠÈ»üè‹c Çt$‚8ò3| Uï7H©n–ÚàC†— € ~mÎGÈÊ›´Lÿ»ùZ‹NAÈÛ8çò=DzÛv–Âô ˆ BK–…)*9yY?Q¦©ŠZHCc -ØwqÏ?ä’¢§pº=Úµ~Ÿ –p¸² µ8`ÂÙ,·+SjÞ¡ý«"Ü&ß)s(¶¡´Š@;t†¬ªúk L½Ü‚MY©œ p¦"“,ÊšÚã>ëMèR@ä╪¥sã4ç ª@¿tNúJÒF 0§˜7-p^B7ÈQÉ0 ĹŽ;æžS?V¢8 fÈÀX4Ϧ•H=Ù)Ëä ¹j¬mÏzQ.´-e´• U-ÝHôõËcͤŸõ¨Ë•/§)µÆ¹ªßp7& X\qU8*yqc´…t¯ÔPV©Ìx“iÙ=Úc?1Im¶”áûT­¾=ØhÊgVàßQZîñ‹ 3!§ã±沯…Ñ¿K† ‡7-Ý+·ÂCî2?A )¼tàîįòܑʾci}3;O\"ÈRc\ZeKaÍ€}`d ûc÷®‚·t¥–ª×¤ÀÝ>é«ÝëK¾Ü¸.¸Îp;ž³_êíÓ}â‰å®÷M.ôpU3Ë™¹ ÁÔZÿYëXíÀºÞŸv ymÄ ~ݳSÝ]âû¨Ø®u.{ÃxoéÆU^×Óû{Œ”ñãÉïúª¦S.¡JmeiRxïTí²·ÁQœ&Åú¹Ç¨²)A„äï¹ O¦$¼.q[sþÑPMg§iÆGtÚäÌÄp»C½d›l—ã´¦Ô¿©~ÕÕþ[¬ï¡–’®àæÏ#nÄ.tꘪ£²ÂìªYz§ä^u-µ¤”‚û×-ÓuLôs?Êà¶+mBV‚ý•yvP”êß#êQÉ>æ«F¥Ò<½üžTüY†öP ”r½êJI=ªV–NÊz' ° R ¸§‰mµ+튲Å8Æ2¬q¿-ÝnKÔÓŒ;4ð-=Á§-v22²1BlŠôú ¼gh$w¬f„i^KFátÿJ`N}æ]i+ZAûT‡GRJú­qŒ…­úÂx£ŒêÙ}!Ñ6yIÕ… ŽÞÕÜ7g”5¤ð¹©î,2FYù&êíMo+ î:hˆe¦®q ^t­³.H^ãœ&¨=CÕ4òêsŽ0°¦¡#…œò_YQÙï\ÍÕU=ÍŒúUž’-#u[k¨R!XåÜ7¥)ä{V–ê^–©¦¦uKqþjéÒõ,’©°žå~nÅw­qôGõlçd%§ä!$ã$¤[ìµÑÒ]ú–,ï‚ßØîºÂïpeŸ¦æ¨í¥ß®óø¹JrtùsQS®¸§O’I?ó_¢:xDqˆÇeðöåXꊇÎî\IýJEJ¦(¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡ ÷µÒŸˆ^¤ôŠ×qµèûãöë|¢TóaD’œÇÛñ7§üMê;=,”ªÇà „—5§c‘ƒ·Ñ}§»t•¾¶vÔÔ7/oS·+싼÷¥¹½÷ÜQZÕœ’£Þ¨QQènåXÄñ´aJ´LÛTEh›¨mŠ¹Yu&S?[yçÞ¬=%]o¥¹ÁQu‡Î¦k†¶q–÷ÝFÞ<Ùi^Ê7i±VÏÄV é•ë_›‡J,-éÝÐa„ää„Œ©Yç$äÓß®vjþ¡¬ªéÚ"…Îþ[vhà’A'r2TICWµ‘׿T»äþj(ÁFžÓµ#ϲ¦Ýoêe<«Xûf«tVÀàá‡mŽü÷MëªÜù| 8RNêz·1Ù#vÅ%G¶+Z:Yµ²@Üoð3ûöZ¶þO.¢~S¾§Ó²#)àˆ»” Ê”+Hu—LŠjƒ¡¥OXz†Bê–Ÿ¨uDKTí-\–¬NIŸŽBèNн½³Ž3Q‘]&4‚…ò;ÉÕ£>XƬqœ-•mI'Þ´0Œg¾=”£B†ÑzIHÀÀ籪UôZX\~Í_g¾ mê½Û^Ô*S·„FÛC €€y+OÛŠúµÿ§í¥òÃ-Ò d¨` #HnùÈ;ý0¹Æwhx€NÿUÞ^œæ]B”•9‚xÏàWÕJH&§`„ŸS±¿eÎÕzIÈLx*Þäi€»rÊ|œø§Ú!÷?*~çÿÝ7£“ù™ouÏúɬÞŠÚ}W\ÃiîG5ž(Y½M4­õJìßþ{­gªn2ïé | ݽ ”øyÔ«rxý©•—˜­Î5 ÚG ½ùYTß] ÒxJmöhÅí²ÜRm P rí[G¤ºN™ƒÌ©8nì «®q‰ÿþŸ·ÈK+EËçãí¡ Â{÷IþÝëqÛºb¤K¡ì# ì¢TþáFozJx"E¾6ØÂr¢}ÇÚ£oÝXÆ!o§Øn/”â –÷)’ó6;„qCnÇl;#Õ@V v縀ó¸üÕ'wÖîjÍMsÔZÇS&ë©'¾©$H{s’^QÉR‰îI5Î7UÎçÎàç¹Ä¹Î9$“¹$É'’VÖ†Ž8cl0°5Ø0;Ù ¬÷=_iê7J­º¿OñIÉÕL4¦bZp“»|’6S[ŠÆÓšØþtX}áAgÕM Z‰¨>˜À;wz_ìX³Æ2µ×_^ìM€Úîºet¼EøžïÿtnÉǺ’tÓâWèž¡u—« Ü5f°w*æTkûÖÕ.D‚¯FIôÊTæÅ…‚’« ŠË¡|P¼Úq¸IªqS–½Ây!v·’[&#sKœ78-:AÆZ êڋ.¤ä¤çhíŽsž*ÝOITÉ¥òŸÛP%§à‘’a±ïÂNç_;0èbÖ;î2»›Mô‡[+§·=OÓ.’ÓÖ¸ÿúk† —r3¦î%ÏEMá 7wmFà’2¢OOUøeÔ2ôÛî}7im5+p8”ÔT8Œ‡–º<ãê ` ~'´­WXÛ…Í´wJÝs;vÆÁÜd]í“û¨wQ>º‹¤,‰Öñ¾_QXœp·8_×´+ù€€@;¸8Ç~u‰ßfn¥é«{/>ŠªGc2BKÃIúög8}ÁÎ;ÙúkÅ[mmK­Î9qð23±²¨µN¯×ºª-¢Ý«/“î0­è-CmÀ6ÆO Æ=‡ö­Ô]qrº²(î3ºQÒÀãøì`¯Ë+Ý-,a®~äŽçåBÒ§[ʃ›³þnõYÈ'$++˜0¤w[Âõ+Q#ü–Ò¤(%R• ÇhZÉ8NBG“Ž;XêkþúöFØÚÍñ°;’Ü’vÛaÀÉì£`¥etŽsŸß}Ççî¢:žÑzÒ©ú{PÚÞ¶Ýâ«cì¸0¤’î ƒäNo½3Yk­’ßpaŽhÎÓÈ<ÿc•'g¸ÓWÓ6®‘ú£w|mýÓžâþ§j#ÈåHù!kCË ç9ÏjõÌY†öN(ZÎÝÄ$wâš¹¡dN京}K¦úMËý’Èþ›™ XÍ#(#€“.+iB7„…e?jÅ®<”>¯å«œæ‡IžVMp 8ãJ(Îå~kÂÀFR¡À§X®(r}ý©Œ%$îRäÉ ¨eT‰„&•Mô§b§ wVåèÁ.“¾NËDu‹•LD/%8=…møÜcìµm[|¡7‡ÚÞJ’¥F=ª­w¨hÝKÚéÎpT6]Áid)jÉΊ¦Þ§×“Ýlë$e]úEºágRTë-Èïæ´WPÆöIÂÚ”-0ŸGu)²ÛäʽÇÅ%@à¬m©ÎnÜ•5r«dtÅò…wÁ„óAm‰ö‘¿oê<óŠ˜é›kßS§>¬rwà-aWTׇw ÞbT‰2-0Z}æ›QÃÅ$`·µ\o~\rOn¢µ„€âoùŒ¨êwžR=”æ(¿Ý-Éj4cpLž£ªJxCAXÉü÷ûÔ¼3ßïtF:X¼ÑG§6 k°Oä]Ê«Ô:y²÷ió]òHÿd×Ô—b¾òÊ×=Ô¨©8à{šÔÍ´E-+¤a&gg9ããTúzÒ?P^Âái) ¡Í¡ÅmRsÏ& íí’8C]þ-Çä­YDµºˆás Èt¤(ÕšÆVÁrö±…¬çœÖN;¨ùY¾ÉßæIB›Jr¯4“ÊI§DçÅ[²Ää¨Ô Ë°ÑÉRqJÝ;§¸hz"!YÆ “><ǨsIÊØð.¤î95×`åa°r›l„«ëåJÓÁ€½ŠÒ\)F Q«¸²Yò±SM9£¯—‰IÈ$àŒ¨ïSý;ÒW+üº‹ÏÓo׌¨›¥ò’š<Îü.šÓÏ9¥6›å¹ÈÁIØw­Dñœ×Iô™`&Ûy¦s¶Ü œí϶}–ž¼0W·ï¯Î?Eηš‹¨®°b9ê°Ü…¡ Ù®Qê‹\tõóCËZçú­—A}3%~Ä€­½ N¬ôã…myÌq l? |(QÔ6ž7aÎؾ;*Rõ#míÖá®>u®ŸUÀ!ÂÊ}E5¸z›1´ú’G9«÷Z}•úªÄéDÐãÜŒ‚Kyn9n;û¦==⥶©­òßø¶øÏp~T/CèÛSéK×8Ê”T¼?¤UOÂîž ¬¨×pisaÛòÛº¸_¯Óµ¿É8+OW:LÅ–ãa»ZÊ•l–9 H܌Ď=Çö­¥ãW„±YYM_BìÃ?cÈ?–Øöî±è^¶}`’)¶{6úþªÊéeM^TîœÔ6˜¯Ây>˜$ ÈW…$ûƒWo"²Ö—Ynð2_N{‚xp>ãŸÕVºöáYN]$„9»®‚éwLáÛ'9¶Ò⢔œxÍ]úÊj‰)Ãõè$y –£ën·’xDŽ8%v•¶Í 6Û Nàzè%,4€~¹¶²ã$²JRµaµ!D;+YÜïgË0IÇ)Ôï5H*@8NpsZõ šâà­êlà¨ÛsÁx¡G+TTßK¥Ãý”ÓéNœ¨^¿ÕÙìÓã:ê A Ïž)Å7W6† "yÈ#ä{+/IØ MKѾWá_ü{úÒÃðmÚ Û0zÒgoZB¹NIí]Ýÿ§·CÿÜÍs{} ~eO}®ú˜Ðtävø݇HZ?Õ~XÉÉɯ¬ËåŠò„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„/Ú#Ju²ÒZN9&¾664ê+íoÞIÛ tk‚ „„¨)iÞ±’üç‚cêÿè;uS:Se¼ª};qÔÙš¹ôýè߸éÛŸlÖÕðÉnªë;u%ÛI¦|Ö×4öv{²§uµd¬´ÔÉMŸ1­8ø=—eÿˆž­é4½M`Ð}³éÛmŠÒÉ[îÀiRd8w)n­?©xÀöÀíWµŸZY®=[÷Ÿ†(éii15­kä'.9pÝ€ç 7ÁûUT6ÇTV¹Î’CýGØÈ2Óö]U¦:’5-Ñ1[ƒjõb0µ©/©[P”'<þ+NôÝ®Þê ÚêÉà Acs»Ü\ÜŒç¶ÊÕs©š:¨#¹ÖïQö Äø·è¦ºgßp³7f× ¾Î3n YR¤³„0<$ Ãù®’o\tÕgM[¨©£ò«é ²d’â,?‘…CêËMGñ9Ý«TX£ÛÝ\W•Ë»Y]y6·¤[˜%?4Óg >JÛŠÖ7‰¤®¢ûÔ°Ÿ$m¯ªƒ Š8eò˜rãÛ*ˆ×šJ c㕼ãÉ.³~+Eõ•¦* ¢1ž2¶/HÝ^÷˜Ý¶ ¤í4‰ ŒÚ•…(cÍWêZÇ7Q["¥Å­È_x> cÛ£é2›\ysnn”…¸Ù)CDɯ®ÿaËM'ð—MAs.n@÷ü×xÇTáS‰N=¾~Wxܾe1mø†+‰Q#$’{f¾“Ë>¦°¼`ì´’ÁÊ‹KuN¶´§ÓÇ¥o2V;I¤/)ÚCî¢.AŠë‘Üu)+i{’¬vûÖ²u’‘ÒG9\g û)¦ÌàÔÁôNK®¡+Bš~ߊ‘­¤{ +w!0dƒ Ê\[ñå¶XB—¸qƒŠŠ§u9ah9Oɲ™Xµ¾ËñÓ$¥ˆ„ìÎHûšöÕ`"V¶c¢>²N@ô©À‰pÓ©rJCOËu¥6ÖIVGmõ±›A%Ly¯h$ïÿç ƒCe9wá «u]ÆÁ•\RÓ-%±è‰òHÉÞ*§Ô}PújUD9§ 1ƒÎFrìññ‚žÑR±Ñá¿\¨¾·Ûµ×Vë+Õ‘™­EŽˆ‘ã-J-ǽ\T@=ÍU,öºz—Õ_êÀs¶cAÜ4¹ÿë<u-4Îg—K ¾OÏÂæº\úWx¾ÛtÖ³ê6¢ÿ§cgÒ}Ú{ÓZ€<”íQBrF9#Ã~>õ?FVÜã·ßn³ºš?Àñ‚wähv–ñ¸'¶Våè¨.AçPÀÝg‘’¹ÎÿÒ߆ 7îÚ ¯Ö©ÚÑ.¥ØëvñÒ„àî)ÛŸ±Îszç^¥°t?ÞzZþ×ÕµÛy‘9‡ìà4þ¼ñÝm«=Û¨çxeu&"Çbÿ®Wj~˜B¹™7‹KɘÒ×ûBÜóî{þõÌRÐùŒûÅ+‰i$z†2~?çä¶ÅTñ£S}ÑRâJ›jRe£(;Fìé÷¨3Pøe,en¶]£“'•N\z~·e6\õ)VrGj³Qõ»—ÆèöåtËëÄhöíW w..99‹2ç:Ú²”ÿ8E?HõÜ+V>ÔÞïUXÚ8駔˜ò\؈“¾±ôYÙÀd¨:WÒ6£Í‚fÆ ôŒý5s·²­Á÷}a´‘‚q‘÷ªÇ݀ƾU¥úµ8nºûá?¥ö­er™¯u/[ôŸE¬Ö)ðÚC¯E3®s$:TP!÷—BH·W…+k%׫ÐQ¶±­ n¹œ÷n43°ÛäÞã VxÕµT [­ô.ª|$’tFÐ9Ôÿ`7!}`øžÑÿHøYè½]Õ7þ¬iô1f]à.;÷‚§~¶VÒ‘„ «;v+§È&º7íIKÑ•='3jä´€hl¡Î–B–4œîAK .pðz»ª‡TyÓS0Qͳà Y³›¾s‘¾Ûå|XfæëJ܇ _5óÔ€®äû¨w*×Ò}낈ì Ô=[¥­Î6¦ÜrÙiÄœçr»žO5j³u½öÙ §¶ÖÍd[`9ç!¤ ó¹ÆUbëáÝ–á(ž¶š9^8.h${r§Q~(:Ë"ЫÚÒè¸ J›u €©)8áÒ?^1Æ{VU¾%õ¨þà+d‚°6ÙßâÆ6ÎqÛ”Îo­ ˜Tù-Ö8Û§·ÎZÊèúSŒú©w…)M~•g<þ j¶ÚZܸ÷VXhXÑ·d]½bV­àŽãk_Üd‘ÝZ-Äê †; ºJ ¿ê6R^ïj¦]je$—í…³-µÔ×+£Liöí‘VóozàöÅjÛÝw™&€¶M’S#2ý•åÒùL¹ÿ‰mCò%¾Ø/ÿ1´Œð€sÏâ¤:r’Zéi‚0çÌöáÃñ g 0{åDuÄ Ž½>L5€íØÿ©]7wЗÍ;*×6m±vxN´>]ÇD•gJ¼œ÷®Œ¼x%téúºië!4ñ½€´»:^}øϸU¤mÝYK[â‰úÞàrߨQ×ßj Ô@e×e:ëŵ­ÄçÛ*ü“ýª‰z}=ËîÔÎs‹ÜZâáIä´w~öåLCå‹ÍpÀ„ÌUvÑ—eÿ1m.#Í VÚ íTj²¸ô½tí§ÙÏc¢{O®äÆû)C`§¹ÂÜŽp?!<¯RLÔ¤\ßù8̶ÊKl'`GsîMTïe[y“ïSi±´45€4a£œ|ýTtV8èÜ’I9'<ªÃR!Ù6+„·QOª0<{V¼¢¨Ìç=ÕÒÒ没±·ÙsÔ° 3šºBN6WFäÒ¨ŒnÂ9ÿs^¶B\ÝGÎç4î³BTÓ«ÈJUœVS HƒÉVŸNìneËæu Yy¤¥DdûÖÕðzš×-y7\hÀ$óù*çPÕÔ64¿‰1køv¸7é‘í Ù #hÎvñÛñU¢¦eÞVÑãÎÉÕ—Í}8t߉AIe$ ¤°©få4¼ — vîÍ>ˆìŸ@ #J Y@ãšYÃ)ûX[f@Ê ‘„«íÞ’†§t´r´žS ›R7$ŒRAýÓøߨ¦ Am¹”ðEHÂA©ÃHV^†»&4”…/qÀÂj哯*å朹»+røÖé–ûšXO§¹*V;<ÓJ¤iô•S§Æ—0•u¹Õͺ.çbŒnºñú ÆHý«¥*~ѯwJÏ`‚=ØÇ×<þAPAÿúƒ*Ür©­úkT^¢?s…e¹Í„…ãÈl©)÷9­`èËå}3êè)¤’&ä¹Íi {“þjÛWv£‚A ’5®=‰ÝZPº[c•§%Èz÷"õ-ú¨ H-¨ã;T;È®èÿ¨.Ye¨ª1TãSN2=ðG#Û#ôTÚŽ­¬Ž0èÉÁ÷ú…ÍR¤)‰Î4â³µXPÏšåÛ!ŠW3œ´£cK6 Ååú¬+ Ž)“æqØž/OdÄ–dîJIûÒD‚ž5ÍvË7”¨r{V a*XÅc­!Dú~k2Õ‰NRc‰(õÁQÖ%!÷Ý7EeÖ$­Ãšòwå«9ÒÒÅ«añQ S&í²_o³>šÞCyí{ÓÛ|"i| pOº8‹ÔFS|í'ppT%!+Wp x#Þ§j-SÃ7ñêý“¸.Ì-ÔÕ …¥eÛûƒ EZ€õÊOÚž»§§„¶Z–â2qœä&RÝÙ!"3¸_A:5xÑk‚ÍŠçÚb¡@IB±Â÷wÏß5õ—ì¿Õ/÷ac­‚1iõl0q³³Î~Uʾ%[®BcWݨŸþ3õשQ%ÞZ·ØeEš¨aL™(ú³Ù'Î=ýëŒþÓ¾*EYveºÛ ‘´Ùhïð|{­Éá‡II1–¤ëßéßê¡ý èåãªÚ‰Ò÷Ê[Rà/¼£õ+'²•~Õ­< ðéâ ä[¨\ÐA{œ{wÓîì~^êgÄ¿iì4fBÜ¿°íõ? ìÆ’èLtžœi´ÙþR|tnSκK« w'·öâ¾øøuöJ莚·Ã y‘ƒÕ+œuçÜœãöÂùÝÔ,ß+ëI2jcl>õs¬ö¸:•Q£\#¾ˆ>£²·„?Þ¾n}¢¾ÒPÃÐK¬Rëfs’Z8a÷ÉÏÇ+¨¼?ðòWÑy²·ø8ö>ëŒíÏä§JuiËNº§6¤à'$œ­|é±õŒÔÕÒTc ‘ÅÄ79ÂßóÚuÄ#'€¬wµT}Qe©¿K)ôÓŸÒAϸ¥ñDÝi¾çWÿŒcK}±ì á²š7™¢çÝ[=>Ò2~a3#€[ÿ69«¿BÚjDßyÛ Â¢uwP³O–þWci  ¶™_ÌÆr|×BZ[¦kòõÎ=Cu2”êTÌ7€rGz†ê¾´|ãœ*¼4ù)±wP°¥üÖ®¬ê¯62%Ù?e&êsVò³œãý+@u2Êç ñ±Q aD]W¦•­+ òMQªË†ïåXbôáqħRYÓ:Zý.L”妖 Iǃڢ픾¤S8êqpÁø]ᵈ&;¿œ—ø”uµÞ±|Ej–d[mÊ1Èõ3õø¯Ð¯Ùƒ ›cé¨ÚF&ÿ’à/µ]¿ýÖ3è„có_=+£×+"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„/èËjÿ]zÇÃí×â7ªzª€Ói‚%ÛíA½óf•+khQQ AWêÚŽ;â¾iõ/Ùz£§z>N§ê ÆA(`s!ÒKË,qÈ q8ˆïŒ}G¡ñr ûãlÖØŒ›œ¿†Œr~Ÿ%|æÿ§L—ý&ßÂUûxïïÛ5ÊŽ¯ôŒì¶ó€'Rx1gGLpҖ›VäØ)ç9Å0’b÷€ÞvÂôé.êÒßúÞf è˜ê-Á&Ù¬=)+ŸrFÔÛ¢¯rýG¢ •é ¬'ŒîO½oê³…}êÝiê9EUŒsüÇc Ò Ðr@ÖqÁ#sõZê£Ä¸å£©š¦WBpþ£þƒºåýgj·ée³éùïN´µ!Ƙy`:ØQ Q€HÁÇÞ¹ª¥Ñ9ò6ª6¹Á§Ü@?˜Ýlú9\øXùÔ@'ôRí5+UËRA´I™cŠ=2=<¶ÂÖß«¶ó‚@ïæœÑ¶ºY•ø ˆ:Awlñ«Ør£+â†iÛNçaç|w8N6ŽºêKLiöVÊl€Û­ã…r?ÔTÌcuŠ…ô —ù2cS{Vtm+Þ$põËw×·=TݲÒR“ÿèíœà“„Œvg½Uê垧AÅÚ{að¤è-R‡Èܧ­¢›yۤɎ%ÅF>›A¸î{|Mü³$nwl>OÂNçX[§G}ŸøU“i馊rív”P u¸ä­Üãr¿ó_e>ɽICÒ(ãW&ü;n}ÿ%Çž%Å-ÎàYãl§Sñ@—î‹Q˨+?QPÇíRWo¶u;fw—îHÂŒ§ðÚ] ’š­Vý@[Žê[Œò¸<ù«gH}¨©.Ãîî®<̨»§EÍOê…t[Êe¡…#;UÉû×MYª‰²{ª\Áìq즤6äB’³ô£j}‰«­m¾9Ø^âro…ˆvT^›?œ¥¡*àïZö69³€¥Ç Ê¢[N4 …'üÕgû§˜Ò 3rœì×T[ÅNi+Ž–”„¼A'~>3ÿþšú)©ÞêÂÞƒœû~‰*Šg< «lÃWÞbüŒWî/'HZ'h“F꺮U­u(Ô‚óùq²–¥q…˜yÆxT[õL®šh'ïk’ È}Õ°ÔoQ@€úñùÎØ×'}¥Av)·PøsGpŒ–9§-sN O¸ùú­w=CfÔònwÖtÜ;¾Lâól²‡8Î~]D«` N<Õõ!}T•PÂØš÷ÝZZô·$œÙ$ü©e,ÔѶ3YhÆN2~Oʲt—KtS-Q‘/«ö½­RëÍú¦LÅJe,È@QJ²‚…€‘”`ã8Ø}3`³]iæÜ›MX5jlÁÂ2Ð?—¢F‡O?dq˜ÖõUÂÛ)ÿ´2C¶íÆ {’ }7åU·.œ\,W –Çþ^S¬8[qq]Kí’<¥h$ýÇ©î5Ž‚wS¼M8Ø‚?"2ù]é¯þkZð0Îü­-ZØÚÈ ø¨Ç×T„Wªßº†ÐÛò¥¸Ãc J–T”°'ŠEï{)HŒ-_ou gÓØ·_R»û~)ŒÍ:³Ù,ñ†êìÑ>§|4ô®ÇÒ·ÝíšÓOhî¢Þ쪛p‰"æìæå½°)?J~Q' •‘¸ã Õ×^1xYÒ6ëU¤ÑÕÅ\ð %o™$ ¼´Àw–Ó¿¨í¨éÆp箎ñõ-ʺ9atÔÑ<5‡KcÒ8$0aÛ¾vTíÏá›^Ùtx×öKž×Ú}‹{7+ˆ°Ü„·­ 8@4Ö› ¨g“œ7Õ~ÝhíÆèeŠ¶‘­‘ð?_•«lÙÀïØŒœŒ|·ø­mž·ø}K$‚G8±žc4‡‘þ’1·üÈTýÇPN™ ¿Ñn48àá¶÷)g‚៬àdŒgŠÒU3ùcv£ýw'sßú+­5cs¤;—w>ÞßDÞÙ.+õ`w¨÷´üdë–žW¦µm_jePâ7 <`'÷-+i Z’T’3x¨áVÒp’2¬ChÜ3äVc.8^{-R£L†ðndyŸØ—BmHQB†R¬¤rb;T•]ºh0Ùš[È#c¸;ûö÷ìŠZ¨æÄàà7Á¨KbËÁH$¤õ4E)#2r¤,"t¨Ò'7K™)õKjR'8 PNpqœg²†ÑS,Oš69Ìf5 š½ñºIv$c³}ˆ÷ì3yCS/—VÜyé$©a„ŽNy'ÿ¥r7U½²]ªµ8¼—;Õ¶ûü’ٖǘéc ÆFëÝ2ܸÖèm9µ/­À½¸«ÁϪ¯Žˆ†ÇÜð{ÿ²Æòøß3œ8 ·ª·fáé˜ø±ØŠT÷ó6ç.ƒÉþý»TÓ«!š1qè;‘Éù9ÿ-’FçU>yvÛã?óê¹×˘QY¬ [0Žéê ¯OkˆÁ>Ô‹rLJŽÊ:¦ °uדêô“KÊòð\REƒRæ^1ÛŒócÒq>EDŠ×6PölBŽ{HMsd ³ÚSî)H8ÜOžiO9îËÜrJY™ ãSBáC6æTËÃ…ýY ûÕŠãUC,Lû« \9ùM)b—YÖvUÓí¥kN8>M0À3-¥q,’$¼ØŠ…ºá!! rjI”RHÌ°dåc%Á•,½éIÖx‘Ý–…#xìx þ) –ªŒ5Õ Ó«tڊ焈÷¯‰’æR¡H²ní<ç*#rAÜ2œx53Jí•‚q”Zd|¼¦ÖG4VÅ­„CaÊé.H™§ ¢\ªô“é¦ò9Zöz`Ú¸Pí;)nÑcJqH`¼µc°Ï'ûVTÔ1É+!Ã\@?NêZ¥¥°8°eÀõRÓÕþœè¾–LL¢±%˜á¦Û ¼®ÀryÍ}µèï´gEt§‡REDÖŠ–3HQ;¶3žëŠî^^.Æ™I-qÉ>ˇ©çÉ5Å«ÓõŠÔþ¬ð?¾+æwKutÑËQ)À~£m[à}K ‰­q€¨ëº›2œ^yÝž&´uà4Êí÷WzFzCRØ2™S+=‡|ÕfAƒºÊ¶˜Œ©¥èï)-ˆí½¸à‚3O­“å|âzl™o¼âÖ²rT£’M|¶pÉß•ÖpSµ§$*}÷V–˜JÖ¬àÞ–d’œ¾g*ÙÑú;[:ŸâQ­2%FloXl…)´$²øg~«ƒïôΑÜéÁ {‘ʧÞï1ÿ.YI÷ôF*Ÿ·òp2=«°ü¡s©4È7Ýr§‰ó†Í–•Ñìá…¡ â­³%{Ge¦¥õúŠOqI ­ÀOÞµÏUÀE;œ;¥©« õÅÖ×éŸ~æ¹Òñ^ø¤Ñ©[#£k†R'å­Àç¨qžø¨i*K†¢S˜éƒq…Zê‹Òm±Þ i?Š¦\µK8>œoî®Ö;iãeùßÿïˆÔôߤZÊz%„ÉDW |ãrÈÂ@ýÍtoÙ{ M÷¨âihwìôê»Ä];ÓrÖ?m##ëÙ~¯9—›¥Âë=å¿2CËyÕ¨ä©J9'ýkô KJÈbl1Œ€?EñBíq’®¦J™Ž\òIüÊl§ =!!!!!!!!!!!!!!!!!!!!!!!!!!!!!A«|Lu©aÛ^£Ô×™Lkrž!–‘ÿËï_:ïÄKÿTÈɯµo¨ >†¸úZ>¿lã8î¾ÂXº^ŠÜ?í£ ÷=Õ[e¸j~¡M±ôûIXݸ\^sÓb4Fr¥’rT¬òO òÑ`¹ß&ŠßE³ý-kRHýÉJVÔÑP1Õ??äšÜ‘/Aê§âMD9Ób-H?Ö„:8È÷Á¨»ET¶ÚÁ<2Äã¤òççÓŠ¸ÛSH2HkÆ%ѽJê[ú¾öœ‰¬¯r.2šŽ‡Øm.ÿú#E /Â~œqà½Z€µ½¸pý×8|jh& fM·Þd_/pžJNR´†¸Àû’â¹SíÕÑpIkme$†GÂràpvøÿ5²ü¬"·DÍÒ×¾«æŽ›¨oÖO§tóhrUÆ?¡.+lú«y”Wk|)IÆÌñàsÅ|éé[âáEQn·z„ã0 ’Ö@7bF·o…¿îÔTÔµ žc³wñ“²å-a]±èSÛ\gaËÜ[Ð¥4¤œ8;¥CýAW’FÖÊ×׌Œx->Äw[¦jZíM#»}~B†¥1/?!*T ¦ÊU„  äŽ|sŸÝ» ÜêÍ'ì“9 ¹>–JZ.+é ƒK˜%ˆj{H j{;¦§\º[38òbî+ ;Ií»üRâFÊÜge9XïVÅ·\ÝŽ›cŽ!Ø;·))î{óŒÓZ›c\ßNÉä–ÈœuãOìúM²™‘‘6*7ˉ'f}³ïöªõU¢VC¢k-°N a æì†L¯ý,´A9ú‡Þ«µ4@lr })'èÑ[¸Ê‹n‡¶lçÔ”4†NÿQj8 O¹$zJ)ä•°D59Ärx 6Êè^ãé \›$È_aæ܉-µ–ÜmCjÛP8)P=ˆ ŠJ¡Ï‰æ)šCšH òØ‚¥hî‘ãpu0Ñúžé¤µ-Žþìgî­Ä‡aO©±%¬áMõ )%IÊyñRý!}‚×r†àøüƱÀ–j,Ö;´¹¸plHÝ5¼REWJúf†Çàö ¶åuÞ´øʹÝúa'¤7éf–èÞ¥ ,ÚfHur›#”º· RÔ{n$ñÀÀ­ßâÚr²íÓÃ¥­T‘ÐQg%±eÃ9ÒâyçažëPtǃ4Ô·Av¹U>®p0 nßL ¾ŠèßLõYz“¥:sciÕκLK%Hl¯ÑoºÜ)”‚x­s৅ucÔ0Y)‰k\r÷·žxã© euÇXÓX­3\ç>˜ÆÀœ{ û”£­šgGh~§ë ) ïÒu>•4Æ‹9ÔíT©g°ã~ð E@x¡g³Ðõ e‚GIIËXçãQcœ« @Ïtó ouÕ¶ˆ*îQˆæ{C‹GlñùãùUº$¶Ø*ܤ¬cÕ¯LDŒ+QvNB’ÚQ¨/lÜ“h·Ü.i‰rä†Vc°’œP„ Ã*ì3Í8·ô½EX’JhËü¦—»:Z9qÇgsÀî™ÖÜiéÃMKÃu#;džÔöO:U^ô6ª³jûl{k·H ¦ldHgpÿ;K*ö5%Ò]]U`¸Åu·çDrÝMÁ´ìyü¹ •òÓ ÊŽZŒèpâÓ¿ÈÝ]ڬǩ6'™ê¥¾ã«ud¾›-Á™ÇjÚ‡¼µè%œ©¤«%( NH ¯]cã\½GBYÔq>¦±¥þ\¾`cc é¶<´KuÜà *]›Ãˆ­5:ì®l1;Û¥ÎsÈî\_ŒžçI'’¨û‚"Ht;meÈ­¦¬(€ÜÉ'>iY$a; Ÿøͧ{Ã4ÊrUÑѳ^º:îªU ¼?‰ÂùGP[+‚€y…‚ÛÍ‘¹% ÔH ÖÓð»Æ‹ŸI‡[y¡¤–lw×Ë%¤·KÆÁÄ‚  xƒÐWï$T£v¡þ.1épØx9¶P[.ß©õ]Úùg³·e-ã Ãa´¥¨…G%( )oq;FZó¨î̯­š²„M{‹´´Öç° ÙXltòPÐÇO4šÜÁŒœ’ìqœ’IÇ$Ó~¨Ò‡GÜ~€ý¶C±š˜ÈQ<É܇A ¤ùkÞ éšûLͧ¸Äc{˜×€pr×M ‚F?äw [5ö–àÃ%+À%§àˆß¸I-pÓ?æ}Ga¶ÊÉ$ÅV'qn09R½Íµ{*ãÇ’èuj;R¤JGŸÅ-$2G!ŽV–‘î1ýÖ1Ô2BZqó•ÐÚ9¾‡Ýú1«àßXlëRÖ‰Ÿ0¤Çy€ËmÄŸ£'êÎ+xX$èiz*ªšº72ö×jŠ@çé{— è–Œ“ƒ•¬ïÎêz‚ )\×[Ëpö5v ó·~Ëš˜†÷-$) ökHRÓ;J°Þkˆ‹r²‰5].ä…ÆGjÝVz¦¼ëáh[³Ü]¾ëMÎS퇎¤;'Ÿý¢¦®5O–G¹Q03/l˜¡FS.¸úšú'ïUjfšfz´Àß0†„ú͹»ü6[ôÔèQ*þMP/á’:P0¶ÏHUýÙûï•>ÒV‡-2šÚ²Ñ xî>õCºV6£gVÖ¸Ô !9Èáv.‡‘8vàÜ÷WwŒ Ò¥w^Oq÷«?‡Ut”u|,ž<ã8Ü{…¡:¦¼ˆ‹=çá=®M™Ù,Nh×7•º['!¹9W;±Øžõd¬¾Zî1ÔèÄÏ?ÌðÈ øà÷Ê‹ò*Z÷£Ò{·¶yÂ5Mž¥؈ÙCï•#~å2ØíœpwÇÞ”ñ/¦mÖ˜Êqë—%­Õ—1£‚ì`C#ŽÙÛ+ËÆj‚]!Èo|`ßô^i-+*ø¹ÖÔ]aZÝ\W…¸¬)ÅÒ0 Þ²GÜÔ„~Ôß*¥¡ŠvD÷ÆòÝ@’òàhëvÍnܼêKüt¡“˜ËÀp ÿQÿÚ9)Cú&ÿ¦nȶêKdÛÿû¨)²ÒöžÇñþ•¯ú«ÃK݆æÚKí,”²ãPl-${Œó•Œ]OG]E ‘¼e§#?’ª:­ É a )¦›*ü’y5à‚-¼ŸlŸÕ]:6`#v®I\Ö·pñm[’Æ)èg¥l6Æpž­«ª!9R€äð?4ÚF@Êm3´ï…×3úG¦Zé§ýKP3s½¥!Km( Ïôýë¯+|³ÇІÿx–¨c-€Üç#ç J·®«_w4rC¦>Äà®u–ém ÎA#9®'l~²¶t $ä¨Ô‡6¾ØQïRQ3e)0Ÿç.?È0[ î}Ï€çu >c”Yg{  rpᓬò­-25ºýhvbRXÝÎFvûÛ=sŠ’²8Ûþnª÷šgIÃ9]'×Û¶™Ô6 8ô6"3zŒ='VÞyò=ëx}®:–Éu£¡’’&¶ª!¥Îoõ7gûüpµ†–ÚÊJ™„ĘÜrìWIhr1žÕÄñ¹oÁ&„_`XpƒÛóSöúŽÊz‚§SpTV:râRÞ¦&;eIJ6WöŒas *>ð‚0xÏ*¡UBe˜•J¼¨DRÛqy *K‰YÇÚ³v‚ŸÂu°ÝH™¼N›éµ"BÖ€s·ïø¬ë+å{CìÙ64…3zâë0P¦¸!8?j±ÓõœŒ‰¬Œî?eëf_—p««Œ•>êÖrT{š«¾S+‹ÝÉVx€^^0…ö¤œÁÊRHËŽÊæ鎞—|½Û˜CEÆˉ݃Vž‚éZ‹¥ÖxÙ–—U©ëÛIäqÆïþ¥t<þŠßï1-J|³ÆT乕¡±¹Ä8Û¸þÕõSÅ?²}G†U°CåÕQ4È×`nÖúžÝ·9ÁãeË]-â«âê8©å“1LCqìNÀþ»/–“d¨¢_cfh¶È^ÛnêµH¡;³ÁûŠqAÈKÍen’§ÈÖS®Ñ¢Ûˆ©^ìg%G°Í=¾uTô£'ÐÞÞþߧe[šÍRG%/ºÛ&ÌÈ}‡B‡Ó¹$U7ÐTDåaðqÊF–v4´ç ¡ÔÇ•á´a@MHÚö¨cÇb•©f¦ºËLur-£JÝ­w†Ù~Û!’*Jÿ§hðk¿<:û@ÓÛìVû”M’77ÓÅžØÎÀç¾Û-)}ðýõñÏLpàwöÇÊåΣké:¦áoõRøb#%†Êø$þæ¹Gľ½¨ê `óhnyÆIþånN–é6PÆò9yÉUbJ–~£Z×NŸîÅ%t¯‚Œ“šÎ0;§-`Ó…)¶ÜžŒÁZ’Hì<Ó'zJ†¨¤õç9Q).ïã®îݜԋA#e/LÌ5jvJ6œg5“"ßt¾Œ«£¶o¸¯H@Smº•+œq[ï¼DøA?ª¤õµ{©©§’6_Zm?Ózß`×mÆ‹ü!ÜĹýYÞ>“ûòí_xì¾ôïHÐQõ;X˜Y7|‡ð~½õ „.=][už[Qqó©Ÿ‘Ý3t¸Dˆ™lGGò‹«Ø¡ÆSž?Ò¸C¤g¥£–VB2Âçi?ûKŽŸÛ S®<ÇésÎøúãurÉi8JóƒÞœue+\Àü­s÷ŒϹlmMe y®têΰƒîÁØú©ªJ,»R€N˪[‰mF¹ß¨%2Ëç´g*ÝJC=$¨ä©¿/éWþ*®ëž—ˆôœ©˜iuð¹¬úÖ< |é.>„Z<ç‘Og¶f#.Æ>VêðþÂu8l¿?ãOñ*Æ«º[úem¸œuã&J¬ím'éÏäÿµ}|û xXhéÝu•¸ÆÀüžV’ûgõìPÑ2É òçà;î¿=G’M}_4Jò„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„/èþ‰é«Aé k¨õs·ÍUx–^•o‡„¦ÙnBVq•:¯>käµÛÃî–±[­sWWŠ™ÝªxãÆ" Î2绂FÃ÷_W`ê[]]DpÅ¢6 4ž\}ÕùâÇOh==pÒý<´éhï4vsl…L#iRÝ ¨“Ÿ½mKÿÚƦ |?áݱ´¯ô—ë™àŒd‘““ï¾;*Ì]+k.ó—¼o¹Ø};.}é_F¦õc©Ò4ýóPBÒwN\XœÚ ¬d$ ƒù­-àçïêK›ìÒÕ²‘Ñ\dž>ùV¾©ë?¹R¶x£2ƒÆŸÕ.˜ÙtÄÛfžé5ßQëçcÁõ5=Ï!,¸è^THý ¡8H'$OÚ£¼Lé ]5OÜúMòÕS@ÌÔKÿìÝ&N¢Ì £jÜŸÉ{Ó×I¤ˆÔ\tÇ#òÛßù÷ÆËšu,XKÑE¦C3 RÓ ¨d¤8Î3ö­+ZÈ„¯l/ob?ßÛÝ^¡{ŒÌ0âŸu«—ªaYÛœR”ĆÔ6’8JØÂp<ç4îíQY;%œîÆ5ƒÿ‹FIÚ)O–³ú‰'óU­þõ(FD%Êyô¥ R‰ ±¢¤w˜B±Ã+cÉ÷R^žiy—Y±Ùm T…¨sŽŸzpúY+&@%ÆèØZeqÈì»a‹„ enÑI Üê‡õª®W{¼vºFÐSž78÷îµ”Œ’²o:A¿öU¡ÖÒ¤8禽¾5ª«®ÒÎó§l«}¨5 ¹S×ÍLùJòé{Ò”´ú¿ÉVè‹w µÞ¿E²<ÇýG]ôVPÙÊ”@ì?5±ú~Äg‘£ŒþÊJ8×ÔŸð—êö¦ê7Lf»ªmɴˇv—–BŠ¶²’‚O¹ ¯¤¿g*X-U­¦†RæOÀ#Ír'ŠL’JÉInœcá}Ÿ·\SNÜé8I¯ ö®¢ÔáÞ¬Žš˜–g²Ky–—=W0”Ü}ëÕîã€}–tð`(#ÒâB³gv;÷¬z†êØœâ|¡Ï¶~Š~Žˆ¸iÎë—z­Õö¹Ç·Ë’í¶Ñ©E1ÕµÅdA ùWãçÚ:Û‰ Ôèâ‹;Ft»?_eÑÝÐím0“N\}÷\¼®¡ë»|ëv¡‡;PÛm3á·­ÕÜ•mPIì¬ re7ˆ]Wh©Žå³29rèõ8áÃ8烃±ýÖÚ=m¨c¢sZâ9ÀÜ.‰³u%½mngO_Ùôw(7'‡Gõ'>¿ÒºË¦¼pwRR¶×pÉ·>ã=ƒ»­esè³C)žœçÛ¶:j{tž“õ!ýMÓˇð¦S!R£ˆaËxVAl/¹áDíœÖº^êzW¨¦©°Ë¥¡Ä€ÓÿŒ;9f®ÆÜ•âŠ8ît ‚½¹vsÜÁÇeÌ]FÒpu oß-‘œjBV\rÛÞµíE|S2™šy$~êÕk¸Ï ÈWÍ~»kÙšbè,6§ÖÊ’2êÒ®sþZÛ>täu ûÄ»ç…z¤§27\‰Ë¦­Ì»éë«ÿ¨í)_6àrÞ•= # u'¨ä€ àgí[zn‡Š3ð½’ë'S;°Ž5ŽOÈÛ*.ªâÁ#¢sK@ïž~‹¬aégzyVÝO"Ê™I„fÇVä}lúaÀ‚¦ÁÌ(}*9Ž+\õ·…Uô’yžÆèn¼g9ÎúAh#Vÿ„G|)+/UÑ–†D ÉÇçùªjêȉ8¶”àä Õ4’kfVÔ®-ÝYÚO_É´h}] Õ¦ôÝÚÝøÒÑ6LrfZßk *3 ‚¤©IRNR¡ƒŒ€jm½La¶Mlt1¸Hæ¸=Íõ°·ü`8làAcº„N‡Üc¹^×0¤Kìá߸#Ýcg¶Ý]•=½/¿-âÛM‚T²|`V¿~%v†·'áOVÕ04¹ç`¦”18[t™¡A* á «ÎOÚ Ý ˆÖÑ·î£ÚÍlÕØ«JÜuËE¯YÆÓ¢^—²Íb×2gÊ«Ð}ç7¸„¸êFÕ,„APQNßÍYÒ•Ó[Œ˜‡‘›v“‚çeÀ8‰ o’1…\}Euq|¿Í‘¥íá£l„é øµçN]µ4{ FŸ·–‘%ð ”6·TBŽTN=RGHVÉM%|c1F@qÛ»:G¾ø8Æv yS²‘Ò1ùÀß|sÿ òÍtÓ \e]ÍÁ¸û¿˜c„•¤{¥*À'òj" FùÁµÑßN3ùgd⢎¤!Æ{eJí3³_­í;¨ošb¥%1¯#{+ˆ S¹Yd•nFàHIÎ1ïSvCSI]ô“¾¥Ø@·Üæ<‡!»•[Jj u=DBSÙ±øõmƒó²Eª­Öoãó‘lÖqµ“K­³CN2©$ŸÖ¤¸$çœ÷ïQ×èuÒEM/Þ¨âL8kßœ;Ô ç}Ô¥¶¦ S4Ë–@ãc€;m¶>‰þëо¦Û´¼]f¹¥]CΉì´^emßIjqHÈBBÆÌ«5p¹xMÔôVÆÞjh¤®ù€jhé%ŹÒ5m—c%CPø‰j’­ÔB¡¾kN4“ƒ’3€äã}»(M½«ÞŸ’^ŒìË|¥6¦É¡Eµ )'ÎãEk©jd„–ä´‘ƒÈØÿ‘VyjàŸÛ¿ÆW†l¢µzˆ «ï’MGù # ©>6°–Ç|¤V|Ów³á8µH¤^Øy› BcÒe--wãú•î£äù¤ë5Læ `°ÆqÜûŸ”Ê8 Iõ““ÏíôøI¸0¥ ûŠnúgpœ—p•¹}n2\n©%. !ÁúB‡¤Œò2?ÐVQÓÈ2Øþé&öd“tˬÅz!鹄á)R‰(ÜöjY°ä ö^µ±Úûª¹Ø.öëå®OË\!¾™ ¬¡+ÚâT;T<ŽÄb¥ìw*›elW 3¦hœÓ€p會‚;û¦— hªa}4ã,x ýÏ!\]GëUÿ­z¡:×]¢;÷_Eˆ²œˆÂ#´@Ú66>qŸÞ¬ž%ø‰vêëɽ_ž#ƒèho¥½€÷ÜŸ©öÙT:O¢é:v„Û­@èÉpÔI9>äïþʬ¹\ ¦ë:5ŠLåØTú‹0¨Qý%aÓse„5¸ðœžê?è9­¡öð»­îñÑ°Ò‡,ƒ€{ òãØ©UoªÑ»‚k!elXý!F¦•z­”qÞ¤á#§ìå(qÕ) NïÚ’u¤“Fi+ž©¼G‡d(ÊôÆHOš¸ôoIÕ^ëÙo¢asÝííܨëµÊ*HLÓ8ºK­ê¸©¦$K‡!¦ð¼£pB¾õÐøGHê—@ÉÇÆ=[g_ô ^ÔuCÄZÈ7åSz’å5Wc¾òÕè’‚œðqÅsSO,•ol§:N?OõW‹kåêQ·òâ ¶}B«íØáK0l’ÑaižDtAI0éÜ(f{M³*>*ÍC\ÎTã%fA]S¥´åž™bíñó3Bƒo0¤m)Ïb‘ö«,5@Û;oÔæmZ]8œÛ÷ZÆërÕ¦žFzqÉTÚÝ–£]q Á_'óTÈ/po Ñgq-ÁM—S•´šJqƒº•«Àet$ý_h^”›i‘ ܲ[:ö í«Ár>þõµ£ñöimµ1ÎÓ† ´ö Ž>}Ö¸ŽÁ9­lì÷ßcî¹Þkà¾pB5ª¢fË`ÂÌ3 å>¢vŸ5ãšHÂðœ+ç¦ú™ZrKrRHZ\IN<ÖÆðÿ«ße¨eS»8aQº¢Ð+"1ž_k´…¢ë¯4òÕx†•n)‘¥AMR£÷½~ŠºJûßI‰j&ÍÀ¦‘‡WÍ~£¯‚Ùtyg ~Çèy óóqˆ!Ö8B”œ~?â¿1u,Êæ{?B¾¥Û¥× ]ð?²oTr f’Ö¹@ÙX*Ä"-õ%-ïÈÍHØãcëæNFTáïr¾¼t†ÃÒ{¶ŠvÓ¯l{ìOêqôÔt¨RH=ÁÍ}°ð¢º ïÒòQ_飙¥Ã‘°Û±s\sËH+‚üDº_éîb¢Õ+£s}?Q¸#ê¾mõçLi-Õ+õDO~á¥Ò´;KV岜–Ê¿«iÈÏr1_)~Òcé¾°ªµôÔ¦JFé-$ä·PÉnNçIÈïŽsÉëß ïu÷+,U7VÎrÛwÇÏÙ'Ò’íR’a\bEz†T¥;wϸ¬|-®¶—}Ú¾–Iü÷ú©Kí<­õÂâg¨ä!™/°ã(1v¨ ‘““‚¿j«uTL©t`e›ãÛ8V{Qsš7ÝWLûÕU?#ÀN,Æqå ©^ÌàœSw8ÅÒìTÂßiŠë2](iÁ#ŒøⓉí{±Âg%Aa•_ÎgbÖwî9§ñ;²¤>•.Ñ:EG,¦T¯–Š’”NO°«OZ]RØý 'òEz»:™ššÜ•Òò:vÿHáYµL;ƒW;ÅE€°0[psµIðqÈ5ÒgàÝài¨úšž¥³QTÒx!Ã|ý RSu|wÙ$ ‘¥’Ǿ=ÇÁ]c§µÛTè$é6}GãÈuµ¨‘žr1]emñ~ºùÒÀÐ\ÙKwä€vöÊÑwžš§¡»}ýÛ‚?Utè½,›J—’s·?½^Žû¬³·l~ëZu%óïҬɌ²"+“»jŽëVB)\ÌïƒþÊ•O+ŒŸ œ¼¶ÿ­„•gÈóû¬íÒIS˜ÆVƶ¹ºwXÇ–ÜUaôîy½°Ü¡‚o.vçn Êjböú9UP®Ð¢‡äÇYB“Çl*«wë}õƪŸ`FãØü-ƒÒé_†I¾Àÿñø Ò= ©&ÌœˆÅ-,çv ¸ñ[ŸÁ? &½^£§Óí¿äºZ¶ãOc´:²LN{/À÷Xú™xêßPu¸½Huù2ßRsé·Ÿ¥#Ø_yº3¥á³Û¢ €`0׺ø¿â_ZI~»Ë^ó±8UÕhTP„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„W ¡âBBBí!å½Ü}kJxHÜp?¾Æá'¬W؃€õÓ¦ÿ𿨺_Vi›B.-ÅØÄ–Ã¥×J1¿ià¨(’â¶ç… UôçS¶áÓЉ$ü,kÆ£’1‘ÿ¸ªÝIfeuµÐÕ;OrG°ì¯[ÍúfŒë?TïU‡*&¾v¤±¸ ¢\$mþc¥<6‡vŽÊÀñX×_$³ÝolêxœnrµíçD²à—ÓŒµ¤ñß7e1­¤¤û—þ‚~@Ûû•‡Oþ$í*éÿY´…¶Ð›¥çS†àB–Ä$‚Kh Öwì¨Îžñ~kWFWt…ºšÇz¥'ˆñ»CvÜœœ’qž3º”­éVÝéî“;ÓÙµ{®EUÉrŸqó¨æ´×݃F•x˜™]²²zc£õUµµ‹@é ÒîSV •: –ÛBRT¥©G²RIüVÂð§ÂzÅd·%“'$à5£w8ü¹ïì úŠý®ÕsníÜ•süO|?i^Šõ66‹±j³«L[tWæI) ”âÔ”$vHÈïϽHxóÑ4=%ÔÕ;mœÎØC58ã:ËráéÛlŒÙÁQýÔ3ÜmŒ­¨f‡?;{vNÖáhí8…%¦ÿ‰È@V| ¢Õ]¡·PyQçÞÕªÜé$qÔr¬tVÀ0  “‹ßÉÉäT=(ʵÓÐà ªWVߦ…½;S€¿sö«õ’ØÂŽ)ôÏcv\—« ë•IRâBul-D)gÇßšÝ6I(4úݸPRUÈ_é íø;Z¯ÖΚê·/ëG¨æ£“±^B67€Oç5Õþ×Äë”B†`äü’?È.bñ>ža]/˜{ /·OÜc[‹—%©`6ƒŒø®½­êúJêÙ3èiø-î—·’¹ú_[á/Pn¡Ã~ÒGc\¥Mö· žîi'nÙÆÁlvø{#)õ7•b]¯±Ü°N¸0´–CE`g9â·O_õkNÍ]NAº‡ÕAZ(qVØ\7ÎÉÎ¥_¦^ïS¦©iKY;>”Œöðk¨îϸ]%­”çp8EÛý+ndP2.À&›¥çT=dÓv{ýÉV˜!k…:VÜ-çz¶ÉÉ9 y¯.×ÚÉ⊎¦gI †4¸–°’8;œr¤hè)¢|’FÌ9çsŽqÆ}Ó½—X7k€¿RR°pçr¼”ö¦VËU¢Zaúî?¸HÜ­…ìõÑ[)+¼iéb>ÑZÝK¯£bAR€)ÀQû(ÖÛŠæêË{¨˜ðv¢.Æ1Î0©"œÓT¼r©ßቷ¦íg‘½Â´((ÛŽ*&Ó <>m4ùÔ26*j²Bâ×ƾ7u»¦÷–úǨ­Ú•"µ¸è¸!aÄò·´ÎyÎ9OœW^xckkmÙ”nÆ䌎àiïß9=Çuq–ðDÇÆÝÝ·Ó®ÉøsÓZQ,"5¢JïÂcÏ©N°€Â!I(ôrw<â–VÁÀÀíšéª.Ÿ¶¸æ§€‰É.%Á¸Ñé òû¼“[;èJÑGr›ïnkßé c¾ùÏÆSI²Îµô©ÝU¾ßn6wÔo¢Çij6bHõR”¢SÃD¤% qÿgñMYœ\^âç|¸÷ÀÛ): iãlp´Ñßê´±.àÃ+‡óo¦îØYÚ¬r2;‹t„´´??T±§Œ;^‘«ß­áDòR¯¦NÙ)ævO,)í‰k?O|gŠi+‡)@ߥì!µ»µGi÷÷¦Ò“–‘Ã…>´uVé‹L»ƒT_íÖwÏóáµ1i'¶}FAخøç¦m]]x¤È¦©‘‘Xíÿ“3¥Ãà‚ gJÐÕÍçÔÀ×;Ü´jGrЫå×SÔ9k{©–¨OÊbÚäH/Ù-°àöSµÉ(Ka.Œœ«xÁ½uˆ-ê*‡UõSL’6=1˜[X9ÛXáãœ6 í…U¦ðÐZâ ²?H/Ë„Ž|›wÒK²ÓúƒÜw[ãj=?b¼êkU§MÚ§i;›qÒ†5CÒcí!hZd´”zJ%D˜iÎ*¾î¨££šªŽÙFÓM>Al’3!ÂVˆô’y-ìAÆW“ØjfŽ9j%q–<ï!§±¤œã¶s¾áUצ ºç2#æ2”ÛªBŒg’ëGBÒJTŸeA­{UDø¦|/Ʀ’=$9»{H#Ø‚A÷VŠ¾H„ Îãóp~|å˜/áÍ‹8IÂT#=Çi1ü9JEæ?„•{* JAà ñѧñS<÷JÜ…ŽÁ8Õè9å`úg„!.¨áK)A#Í€¡«™#7R–›a¨m<¢ƒ…mÜ1‘V+•³·ïð ×û¤€`lJL¹ º ’æôäÆ*ìúXˆFZ¦W¹þ¤ýRVµ¡±„wqVJ[¤yÙD}ܨ­%(ÈmiVá•sÚª÷ê–°<Æá•7kÙã* 2¿2¥ƒžx'È­TÚŒÔV"×Ó· ÉÒ!¶b±+q+plïU;É$±LÊÜ …ÕZGVj­#k™Åv›jˆë»œm· B•Œgø§1â-îÓI$Vê‡G³ ž3Ê×ýAÓ¶û„í–¦ ÷±!ZZNòÚÊdÞ\Ò²RCÊ$)Xà“ß9©ë8£wŸt&BvòGÁ?*‹¶‘üºa§É©Ô2ÄFdG&,6ˆmE³ÊÆiçRu´Õ±IN4F—iäŽS‹ ž?0±û¸î2š•©6ð¸‹äíKç%ñíûU*ñÖÔO¶Ój10¹vvöÏ|)Ù Syò`<{wY\ê$B’Û Ç‘éÎäw`œ±ïUyî5PJ%Œyo-ÒvÁÁ;p°¢-sÇ;-Îyöú)~žb{ %£ê¥¤Œ$cÏŠRË%cƒ«Hdlû¨´¹äŽJŒu£æQiÒLKµ®"RÛÊiòÙO̬÷# Ç«ox„ÙÛdµ¶ZsÒòZá¯'<Çl—‡mÓÔ=Õ¸ÈÈÛoŽ3ò¹^l|8$sZº6ÂÛ­p‘†”G*çE/¨eˆqÉ £zGÒKŸSY•Õw°ØÃ{–üçËM©XÈ@ “Ånüºõå\Ô¶Éá„Ä2LÏÐÓð 'òú•«:û¯ ³itѺBãÃO×è)¨c.Úáox£æ#º¶VPr2“ƒƒäqÞµ-}¹ô•R¼‚èÜZpr2ÒA ÷l{…°­r6X+xp~”Y d!<“ž+ÂïJ•Ý8M†¸Ši*RW»#µbÆ|¨Æ3S—Rôt=.ÔûÓÀ=5Ôá´õ`vîI®ºû2u%?OK5Õí·wü¾V¦ñ*ß%^š`pÐ%0ºë™ÚSø¬»ÎžT97QmÿP>Ƥ/¾0Ý:yõS\mú_YöìNþÊ—§ ­òÙÙã+”b¥W»²Ò¤­×]Y!)ò}«Ž©£uUHkùyíò¶ÔÚ!Qà'=Ie—¦ÝiZJXq9IÜû~i÷Rô´öéCeáã#pvùö+ËM{*§ ÒÚ÷:ÎáPŒÈô•dí„Å!¥I$8œ8;5!ôqÂ^20¬] õÃÕDY/)Øüàzm4¬Ö6²‚¾>7ºM¯£ðRqïIÒ8 \N,j¼„ùeÌv>õ!4AÁYg`sTœÊ2™ à*=°ú°£ Me“’éN{p)ó6 @Ü%öæ*OsÍ# )07*Ðbß)ÃÐÚvD€ BwÞ¥*-Ï}6Y’}€ÉP•þ²>êĶ|ZkÝf¸iË[¯Bšë ˆ§K‡ù`§i!'Î t7Eý¨úÂÃj’×o›K^Íœ’1;8v=•éà…¢áPÚ¹€piÎ1ÉÎy\ÿ è‰ …“¿Ü×+US¸­¥÷ÐO-³·‚j9䀙O“¢4ýÆù5ˆÐ”ÃPN÷„‚jÅÑÖ»­{(é Zç2í†UO¨.M¦Œ¾QùsêXºã¦r—)–õºÚ\ iÌ¡Äô­$pGÆ+qø™aê¾…©4uu‰ÏÀ1Þ—4œØŽ~B¢Ú*íW¦yÑ°<4‘¸ÜÈ+5‰Sd¹%÷ûëVå)\’~æ¹ÈUI4†Iœ\ãÉ'$­›CNØØÑ€d2[BÛR”Ú~Ôã89iÂ~ödnÝÔ©‹ŠÚ0 §1ÎxÎRÔ±´(ñqL’Sæ—Ñ©:1‡nTÛOÝãFy*q-©¡É÷í#ƒ%ËÆGuYN\ÒÖ­WK» œ†BA$§ì*9”ú¤8 Ô>˹Mf1B”Ê–ˆ¹©¶Qð¬3FcŒ‘Ùv¯L´îrßt¶Ü"·nwÐZÙ”…éq)$o'‚+·üèn©¢žšäÍ–¹ÌÚÒ@'ŒoÑh¶»\Y3&€ê´ã'|¤Ö©÷M}o§#¥çí¬IùŒ(õcðkX7©®}WBΞŒ—Cš·ßq¶AJWRSÚäusðáeô/¤=?nÝlŽóì§xO‘Ú¾ø!ák-ô,tÍê¹Ä>®tó9­;+fîÚ-î¥HA#ËÄËÔVú’#ß ƒoÊÜ£2.‹QPãÓîGšåþ¡ê‡M—¿ð÷ n >ª.ó±Þx©$nòq\÷q¨‚YÜcä)Øcs[º‰ëV’-è‘ Kõ€Þ¤ûþ*âE¶ž{{g¡$LOë…;Ó/>qlœÅ=UÕKƒK¯¿„¡äñP/j•´áï9õü×Kô5‘¯`/ïøÛüC»«õ§AÚ®9‰½NIJú’žÀþÿí_[>Å}[—j†î@h/¶—Y:š’+E;±¬î>üø×ÐB¾j"¼B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(Bý¤·K ºzaXJ‘¸•ÃI>+á t¯ÀܹÇIöÝ}}:†_!Àë¥.:-=³iÛö¢šøšd71å$bДáH.ƒÝÂppx~ê[D½-5;¢˜‹˜:Ü?’;{¼ì}‚†µLn¥ãÈÆÿ¹ú*ÏXj[MÔš÷¤Þ'™y×[¥\î?ŸzÖwzšºªÉ*kÜçÍ!ÔâîI;äýU¶†8ã…±D= Ø*ºtÒë­¡M/>žT›I+¼~>®ýj¸ÛµF«½Û4_JcGzãt¸É^å¦+GaR[§–Ç#'w¶k©|û7:ëê.¢™´ö¨Á{‰psG°ßKs±qö qO×>!7*]°Û`~¿EÓ¿=aèON®ý=Ó? 6†#?beä]/-ÅCr.¾¢R•î p€@ûEøÏãŽKÜþ8´Ôð1ì|±³A“QhÀ$8a¿ˆòIÆÇ¡z2»î2Éq{¤ÁkIÙ¸ÿ?ÙsH¨×duT¼ë³$I/É+<6’2–Àó€?Ú¹öª…³5×jÓ¨¹åÏ=ò{|ü«WßÞÆ 8[° %¨îÂL§•å„Œþ‘ZªãZj&/)**#0â Î’ ¥…Á¦Íj±PÀ]ù'm£&ë[Òa3¹1‘…<æ8BjõÒ/5Ò*-€ÜŸ`—¾Þ⡧Öóêìî­Ú´M ˆ¨q)%¦ÏþcR•™)k]G²tÚÅæW#¸_6úÔ›´Ç GmYm[?§ºr,êvålX-ÐÂÂçŒà/ÑÀWL¥tÿ£ZRÔùqW©Mÿ˜Hìë¸Yû ©ý«§<(ÖúŸ&•Ø Þû®'ñâ*jßSØœÉv¾¿¹·Îb¾…­Í‡pIÁíÅ>ñ¯Ä± ;©H.v7ßû*÷LYõIæðÎ-Y¨…sؤ=ê}V?5òò£¨§uF¶¬ÕtM¶ØÇ0çÙ\z#¨’.Yv[‘e ðxÿzì¯üX7 <–š£¥în7àª×wÞžû½S*bìU &%®.°´¯PÇuÛ#sš3RÚFãx߀|íÍqü4tt×èÙxiû¶±¯éÎøü–í¢ª‘ôNu9õãlû­Séóz.ýBóºVà¥=K?¥-~“ãxN2Ÿ[ôcì·Ž¨$õFáÝ„íÿ٠FÍ|ûÕ>’1#pÿ?¢¥mÎÙá_äüôwäE XŽ´œ/ºG‘ÆûÔ|“ÚðNAÇÁìÔ)ÉŸ!h«{O^!ÅuÇ$ÃD˜Ï6P´•é(öZqä}ø¦1{Ž†WG4aíiß ·ÿpÇqó¡n–÷JiÆ?æþ¤iK¦‘z©-»òóc¦dG p\iC‚5³ú磪úz¥¬˜œLÑ#y-<Û'þd®Ž 9iÁ+æ·ÄïL.º‚:âÀ¥¢áµ&CiýN³ýX÷üU»ÂŽµm<údÿ>U±é"Âbr™ô'Y¾Æ€éÝžÕG•iº99Zx5&ã:Ûªei•¥]ŽIÚR00ké§Lu#¤ŠÐèØCidsõµÁ®’<‡ÜüMvq¿á#m—8õ…±ÑÕTºN\1Œd¾ú®¦ø–Ôý8Ò3`½ÒdÈ…u—"à—uR[ßûŒ•»•ÿBGÑÀ<š÷ÅÛŲ±±XZ]Üé—7V¢K™“ϧ½¶Îå0ðþ†¦¡‚[Û€q¶@÷\ñrÑú‚ËÓ­*Ýæ,gß’³<Å%è켤¡Ç‡Òÿö}ÐUÎ3ó›Ä$UOGÕ°ß»ƒŽÌå¹9]uÑ5pH\bqÇwýû¬ìVöc4ŸRrSÂw”í>çÿ¥ë*òã’®u/.8Êrù6NéÏ'Í0óÊMµ#€•Á*8¤¼ÒFéA7ºÍhZ¶‚¯Ú’bùOe‚ãäpMf&^¶by[Ú HÅbíפäå9°ÛË( äý»ÓW9YšÞVÇ£Joê-<”´¨¤ã>Ù÷¬ZvÊ]³4œµ!%KC#Ú‚ì%Ę Ê3Ôxæ›K)Âð̺V¦óÉ)¦'Àå Y‚JÚ²në'H²v±ik–¤¸µo¶†Öò’¥,ˆ$åGÇl~H©;] µryPŒÏ~Ã;áGÜ+M’S°L«møËÂ’RRp F0i„î 25çb vž 1– x–¸­¨sMÛÊ4šR·š %xµ-¤žÔ¤rv)³â”ó«5m×RƵ"x‡¾,fá¡mGC%h@Âwìr€ãqäùÍ]¿êZêù¢.@ kZtŽ3¤ ãÜäžä­)~´RQ=Æ&þ"]É;žqŸþ–›e½O0”HÎø«ø¥2Cå8d•©*_‰ ‚“zMEG¦Ø!Cš™©·COO˜†øQÐÈ÷»ÔS ¥:@IÀ' ñZý9=ÕâÔͱŒ©mªrv™Kì cžõI«®-È-‹f}Ap qOm–èN=˜Áµ?9ªµEcÚ lJQ3Xu;9WfD×Ð ôÖ¬“ØŸÅ@² ¸î6PS¼ÄÏG![‹ž’rÏ.É!•Å›ó)SR ÎÆñ‚1ïžkkX¯í¯·Õ³LšÁký›Ö½¸PÜKj˜rÜ•]k[|´˜‡!OÛ·}.ŽË?ÿ ¢^¨E+Ë"v¸ÃOcþøW.™¬Œ‚é[‡û{'ˆPn·75æBÞÚ’œvÉj9”Î…ž~7ÎGÂŽª«ó¦10ì¬ûÓªÕ{¹ê+­Â6¯a-1ý-ÍÌÀÚB”8FÐpsŠÛæX/VÚÊûÝ[ÛucYä³N[1.GŽs6ÝQ.¿·ÔE`Ó8g8-ï°ï“ú+VÐå²ç¤å^nÓ`³"̨ñ˜€Ÿ¥ÉÉQQR¿lOÞ¶5¶¦ŽãÓN¼]%cd tQ²³¥DŸaŠ¡\Y<ÓS°‘>§ÃHÀóä&¾[õ¶¬èV×wøìE´Çž¦ã4’?–…åÀ;{Vþû@Qõ_QøQhê»Ã[?KÒ6cý-8äNéï…µ–»STÚé 29¹q=Èßó\ ˆaÕ„/##5ó…Óé ©Ÿ&ò奆S¸qÅ•¢RqTje#´j ®›€¦-óäÄõžš±¸}êRÛ~®¤{¥š¹ÁÆTEU²ž©àÌÀHáF¤'æ‹Ž”ýDåGßïLß.ù''÷S·K@öFŸû“b@õØy©{X¨c\6%%[+„d„稭®èCm†Xé'¶)ýÆ—MI`nvöQ´µá¬ßrž´þ¡¤§°¹NüÀo©­ƒ¦£¡ary>ë›kxš R;{r"dHJee~Š²àãûÁïÒ÷fÝŒ"W´zr vFø<í·æ½ê®žuΗ?#Ù&ëT]êf¤UéØ‘¡+ÒKd4Øl:Gõ”=¿°©¯¼]©ë‹Ù½TÁ.- ÄmÒ;‘î{¬ú£Ùg¥û´n.Îç8øϲ¨“/Ó;s¸VŸ0e]d;§V’Ãé $ç>)¬ŽpÙGÎçceÑÝ,é.¦ÕÑ›fŒÛ˜HI<¸|{VÌð÷ÀëïVÇ#­,Ôæ‚@=ñγêÞ·¡¶ÈRìû*é¹öÉk‡qŠô)‰%*mĤÿ÷ŠÖO³ÕÛªßG[ŽFœá‚?_þ•ó¥kâ¨`’4ï©ïAG cíRfEu‘éÂ:½6Š çÞ›¼o”ÆFdêO:JÞ5uæšÉæg< „$¨$~I<÷©î™éÚ˵lvë{5Í!£ n}É òJŠºÞ!¢‰Õ nùçö ¼ôÃÃÝ,»—TíЕk¡-ºÓèu²œsÈãïŠúáÏÙf§¤*`«ñ™­§™À×µíñ°úw÷\ÝÔ~-2÷æAbyÖÁ’ ª÷TÝôŽ‘×z½½-!¶¬ÍIIŒT¯¤ ¤œý‰"´_Þl==Öw&tÖ #<¼þ2>€å]zz‚ápµ@nù„ûç?è¸Çªzš§Öw+Ŷ;l0´¶ƒ´`-IH V>æ´¿[õw{”—ã‡ãa°Èùã+utµ¥ôt-‚C’ ý3²ŽÚßXZI'ÿ¯k#l¥gnÛ)ݲA+Ç$øªýTC .¢0U¦õr´ûÇÕiJNAÈ8 Ò–;“¨æó£àûprª×k8ªo*Ô»õb^²XEä¶ü±òì6£¸¶ÇÏ_E-Îj8ˆ"'9¹ÒFG× dÚ«%š²»ú€8<Œî rÒü´àÿÍBD{©šb´Å¶E’ëmJ†”pJH©{qÒ†ÊpÓ¶Éü³»I,ä)lþ™ŽznåלgÕ`”mJÆ3±CúUÆ=«hÝ|:û¼­†9ƒõ·SN1Ÿƒìrî /T°¹ÑãIÁÿUIÊyÕ8–äÞµüqœ«Ýc×Môi«;3£"|f—ænäšÞÜm‚é.@Oâÿu¬üD5`8e7¹Ó¯ u•X°ºáHØŽè'¶{Ô—Pu ó\§¡±»Oq{gŒû*äLŠ:fKT?šî»'¡]6…mB\ôx>H®Çû6øUIGœ7•Î>)uœ“9]Áj‚Ô8ÉCa(q5Ý  Ž–› .`¯«t$îS%ý¦_PX9VqŠäOi –q#]“ž¥ªG4aWWÊ—Žšäþ­{i¥vFÇÙ\id. ÔzV뺃a‚kúã«d§®-¦vÝþ«fÙmt £z‹X¡6•¸âŠsÁ$ö«GM×ÉQHÒF2p~ŠnÏÓ„Ô…ñ¯ãÿâ/Nô»§Wûƒ÷Fâ”G[Š%@m<~kzô7E‹tvªIÛŒ•Ò6¹›e·>áTCZ9ú/ç»ñÕ«‡Yz›¨5”Ç,¼ò“*?¥½Çù¯¸~t„vKTT1Àßê¾@xÑâ$I{’°þHoÓ*’«ºÔ¨¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¯pPŠ÷IBýÐus§½CøgêƒZoS9.¸¶:Ô…†¹1ÞáCi=ðqÎ;×ÆÛ¢»¤ú‚JaµTŽ¦œ€ì Ny¯­”µ‘^-íž6â9ÛåK:K¢õ§Å‡[ôoOQ<½«5%ÃÑ\§ÉXFRT·Wç)Râ§<.ðÂå×]G%0—xt’ÈAvKˆääàî@M:£ª)úvÕ÷™èhlŸ`«Î³i©ú¨‹FÌœ»‹–ù ˆÿö¤ý°‘ZžxÈ©š»Yïf}ô8·?·ä®”G4‘¿u4}wL=?Ðþ£j›ŽÒЈꔖâDd¨$)Å ¨ö÷«7Eô}Ǩ®°Ùm,×<¤†‚CFÀ“’vNéµâu몶ƒ'Ýt6¶s©¿º‡Zô…z¨:ˆÅv[‚!¸W@iÜ”§<”x÷¨~£©º[ªkzvZ—5Æ)×;Cƒ0¤8dl7O,”TW xnb,8C<î;þKv˜Òzm:{O\.óåܵméÇ_1ZWÑ(ÊBü©×…, òM>m’Š*zZxž]U.§9£ðˆÀ:Z}ÜâÓ‘ÀQ·k”Òºb˜£Ø{äòGÀR­Qwù(-Ú¡°`¡?©¤ŸÒ|çïT^±½¾R)£;gû¤¬ôÿ!ßêªWqÍÊQÍRƒ}Õ›î›ì´8þÔ/jO#u¼]K©§Ïiõ8ÀRÎ{UvÓª¢¡õåÇ¿+{t¸SQ±×7mkÔ-'¦,͸¹ÓnQ£42A.'ŸÀ?µo›£ oÊWªkYOE$®8Øÿeûèt8ö‹leÊå¶Y 'üØVèð²ªM-Et§’íûó²á;Í1œ²ñ”ç«/úmw—S)ø*aÒ¶©+Øvg¿±‘íšÐ½GÔ”UW)t‰ÏŒµØÒììzI÷ny ãCl‘µ´äds¾ßê¾ü@õÅz£©÷¥ðվܢ$<ƒÊÜöÏڹΦÿ–ë…@À' à|ü®‘²Ù[KJ$—ñ9X]êŠ i›åÅ,Ý T ³õ>Ê’=ÈïV{]ˆ<ñ±fÿ$}9*™Ôð»Í#Òº…í7'U:ÃQ›}÷Xe¤ä©Å~”œûšêŽŒuáãîY{ŽÀîì}Ôe¶î)¡Ç î«ùú†ç -ÏHêÈòîqÙJÚŠ‡]!V÷Æô}°œäcÚµ,ýCSå¾ßwiÆ Z Žcphüçµù!®‘Äÿ/8:^ù9É[#¢¦s;]¤ˆ ó°þ¬wNÁcù[¥ŸP7k4°%FòV¥¨ŸE%9¨äŽ1Z¦ÍMKT$§«pÛ8«$Z1°ÕØ‘·){õ]@ÅE>HàŽß\$}OÒoMêÙð4•æ-â —¢¸Ü„¾¦›XÈm× ©mà<O­íô”)iè%C±iÔpF@sšK‡Ó°;sŽ—ºTTÒµõL,“|ìGæ3¾=•l"¼µl)8ª¬$ ÚÉ1Ýfý¢\`Ú¥Æ}„¬nARH O¸Ïqø¥ecØÖ¹À€íÆG#Ü{¤b«c‰‚G+Bc‘¿R&\rœ‰ÚÆJ1ô%Ãç4›¥Ï ?8ê}#S¹>Íi³µe°Ú¢ÅI¤H»’£Ýn¯$©_Ø}©Õâîj£†/-Œò›Œ´`»ÿsÎN§|íð4t.ŽGH^ç{œðe­û¬‹ê~Nå!jBRKå%#1œö$äÔS§'Õ!àcþcªZ( ÔÁõL7[H„!8ܘÒKÍï)lÌœ‘µy ã%EnCKBÆ•!`ƒö=Ål |P»ôy¹Ùž)k˜u48»AýÛ!UºÓ£(/´f†â £$œZr89ÙdÞ“¹j»¬é7Y¶Ûl¹e2}u­!„-Õ=BŒúaG8ãŽ3Š¨SSMWQ—5KŽÍÇl‘ÆOÆÜ%ÍÍ”Ñ1±1Ä4iÇr1ßœ~ê{Ó—=7s—i»Fz öW±hWûƒäàŽæ›VA$º†ÞAÿŸ§º±ÐÕÅO¿e@ëž¾–Í°ÍnÈg“þÓÅß@ŵȹ–î°ÖÔ%ìCIp8sØÍGõ_…´¶Ù*CjZï%Ø9'nê>ÝÕ²NÆË÷'ƒLôß[ëÙR^Òz~Tè¨Q-*HJ07’}9¦ýàOSõI3Xé<ÈÁ M`dç'Û÷Nï½ok´Æp˜5ÇŽs¹Æßš»4×íûPéqªn·(º{LÂnKν1a ©Ä¤aç%J$~#tv¬‚ÇLúPÃðºp€Û‹iÀ Ÿ]++ËiW)NOcÛÅwGÚƒí%l½[™ÑýÃ’,85Í-:ÃÜïH$ÁšqŽÀ •gÁß+¨euÛ¨ª´çqÃŒnFÄü®[DOR2$¤øïšùó$¸~’·ì²`‘•¤4ûƒrþ¡ã5‘xdÙ“ãdÍ!È’Øp8â¤#-kr¤c•¡/’ÚcÆJ^9›Fò÷ebù vGÓK½ÂKÓ!´I¯©JR°ÕlµÚç©.u?1G|mþgã”Þé[M yå"Ô÷ùrIÚÚN8¥&¯täjà/()£`ÉåE˜‰*àà9RÉ㽊'Èì3”îIC7ì¥r,-[b²Fá)\ž{SËݼSFÑ!õŸù§­2¸žÁ#ºÚÄXÌCÛ8#qPM ÒÓ”òš¥®$aWRŸ t”žG) 07S´ç +Ž«nãÆzU¬Ý*w[`\ö$¤n?šÂ¢“<¬f¦•Ñ*ëmóG©pc¸RÊÓ³…R ñWn†ñ>ñÒÅî¶ÈC]ÈÉù+\u@ÒÜ@|ƒÒž©êyšÎboÀÈm-NIH¹òy5NëN¿«ê+©¸Vþ=!»îp8ÉüÓžŠ±Çn‡È‹ŒçõTY *(ìGzˆÉå_]“ÂÅä†Ñ¸É™' Ö³²žèO#J]#Þ"6ÛŽ£‚•y`én®©²\#¯¤½‡#<*×QYã­ˆÓÉ°*Ü×tÕýC·Û¬.Ê]²Ù—ØuK+^1’O°¹¼QûOõ7WQCm¸J[[†‚NOw¾;m²¤ô·†¹ßTÁªGmœ²ç‹”¹n"Ko-JpòN{šÐRO©lè¢kÓ²¬¤E|Õ_êo„¹…ß’‚ŽÜÝ&>¥Iö®kë;•\¹~0ùS4íÈR:“T«¡…(íîHÁ® ñ7¯dy|p·~ëgYl8Áz¢îÓÐù}çÉI ×?Øé…}CŒÙÊÚVúBÐÕÈpêý»HY&¾üÂÛA$wÅo~¡Òøàƒ$·Fô¶Oœð¿Ÿâ»ñŸtêž·¸tîÅuqëck&Z›_Ò9á¾?Ö¾Äý”¼m¾˜ÝêÛëwáÈý×}®­Ê>¾ç¬´7ñùmüð³PÔvŽŸð­'Õ–JŽ¨½ºŽ'bš—I#±{¿Ì ƒû¯˜Ú’|žªõ&û¨œYe¹²ÖöNU€TNîTsÛÉ5óîÑ@^öÀ?ÜI䜹߹ßó]=@d[š?·ù.öê6€Ó Zc¦ºŽÂ%iέ˜¬^t¾ûeD”î›P%> ®‚ñ§âðþåoe•Ï‚æÖ²RâíD‘‚1†íË~U/£ŒA¯×NIhì6ÿœ®u§][ê^‡Õw›KÑôs‘ëÌÅmþ!1ÒIn8?SªR” 6¤w9â´õÓ¾¡ŠÈþ°¸FáO#Ç­çW=Ç.h>§ òà1Π½Sõ5º;ƒl´ÏÌ d´ šÑîxø­:©féë¢.­ú’²Û+sŸAXÁ۞Ĥã>* ×}–ÜÇMF\0 ·ßO±ß”þÞÇ¿OnT²ïpv{Ž>¢­ËÉÇ|Vª;¼»Ý;£`ÀiQeº;’•~þ)Û#Õʱ¶…¾_6Ô ¡¿¶sSVë~§aX £Ã5{+㦆gRz)¨´ì"â ÝŽÙ¨‚2Ÿ÷®‹¨ ›¥„n|NÀôìxýV€¼³î·á;¡Ø_95m’÷f”õ¶úèjAq@ïXÉÁÅUm•QH5Ä8åt=¶¨>-Qðº¿à3¡Mê¦Èê%Ù†äEµ$5ú¿õ+«ÿÝNq÷U_ìõ¢HË[Gaõ<þËQø±uv–Ò µn~~ˆ­„Ù=$© nI$žø­Ã¥Ì¡4òìç²ÐF$›WuÄ}VsHi»Ó–© 7§šSÂO!GÙöë:Æÿ<ÞT_‰û~]Ö×èûŸ+LƒÒ7_%úw¡\Še^î \‹„—Të«XÊœQç&µýÞìéƒcƒðŽËnU×eå½—6üKõÂ/Dç#¨2.!‹½iU¹¬‘úÿ)çwڶDŽ}?[v•°ÆÝÝøŽ8 “ÖUÔô.š¨é`ïò»Óà“üBºCñki—GÊ—fÖ6Øí.ïi”BA/€³ÜÕzéZ|·§ŽÁ„ŽËµåuhnŸ²Ær, «üšVÙþbRF¡ù­Ç`ñÖ~Ÿ"ÒZʉ=%ðG¨ûŒ²µüNì]X £VE¶oL¯:[BéÍk:je¦äY.nYÈÉÜ;Ô'ˆ>ÖÙ,tE$¡íª€iÉùÈúò“¥ëŠjë¬ÖØ›§Ê8;mù$+V]ô¤{­êÙzTW 6.:UúñÎ<Š®tOˆk Snª1ê,û„ó©z~žàø駋#±Iøÿ«z‚î™Ñzšêóš"ÚóÒ¼#æ]ZŠŠ– >¢  þ‘[­þз^¡ ¡³ÞžM 9$±¸Îq'.#8h;óºÍž[ìížéBÀ*¥ ŽúCF6³É÷+c±®zŽ|K]¢4É/¸¥zL¡²µ%<œœñšç¡iª»ÖŠ[lN‘Þ¢Ö5¥Ä7rvh'nOÆW±Í Nž¥À7$à~ÿ*ÅkLOD kO@”ÌÇR\iE²€ó`c(F|Š¶UôlPEð=²¿%¹in Fã<‘ŸeN}öJ÷1à´lFAÁùü»(¶µº^t†“¾Zä¤ÅyÝ©#'<üŽ VCn¶æIk® ˆ%®n·ŒóS½7EKp¯Š¡‡Pä¿Ñqjˈ”]É÷Í9-ÂÞ ŒaYzbæ™iùGPíøªµÎKµq£Ò55YÙòÿKDädš®9ï՞ʧ÷ö禷í¬ÛÛ+ )òµH2`áÏtúž¬ÈqÙ]]øWÕ½\W¨^é³_[³ŸN˜q'¸÷YàxÉ®âû5ýŽïiñK‹¾åknî™ã‡,;w’>NËTx›ã¾Â>ãH<úÃÃG ÿäGØsôQ>°ÎÓv £úWDˆËµÂR£™L¤'gï÷5«Ñ"«¨Yd–ŸKd8k³’>£åp楓 M²N×@!`Šùè#‹ÑŒÒ”q=¹r€3pôäÀ'î .ú]MÊŸŽ"[•yh¸L]ÒÒ_t'Æ°MDÐÚ[QSå¹Ø§÷TËü¦­¡kÕ¶í’^ŠÊÃÈÆàOqö4Ú¶SÔƒµÝcdª2€â0ªå´ûÒ’ËKt¨% sÍI@2 Ü0Öêw Öw§T¶iñ¨âl) )æ¤nK$ÿ˜ôÖάð«©)lÿÇNñH9p9 ÿäôþj–ί²ÍW÷Böù½Ÿ¦yJ­6MGpBb>_ÚpÏqZÐÇ^ðZÍZ~§ Úû…37.‚Ð,k)[Ì…¹÷Mmϼ8ó›æN2V¦ên·Ð0òêÍ-£¡YCKôWßþk§úfÉOj{^ëE_ºŽZ’[•uZæz% ¥(ô¼+yRu»€Ò8ZÒ¶ŸW«º•8êÆA9#ÞõQ±Ô™ê*‘áÛ¦¦Ý-(©DkNÓÕ¿Y{ÎS÷3PÙEu6¯jK)[EÓ”ã=«]õï‰1À CsŒ)ËN™N²6Tĵ¦YS©Ú„¹ú³â¹"¢Ó%Âs36÷ý̧X öTTn±¬6§ö8”¬¢sV¦ø~ʵNù[;¡h_UP26_–ÏñHøÅcAè­C ô›¢’¦# /•-YŠëO²ÿƒÒÝ¡¤°Ÿ€¯Þ4øMÓÈÇz±Û$¯ÇúõpÔ{…âç%ÉS¤:§]qg%J'&¾ÐPѲš&ÃÃZ0ÄÛÝÞjú§ÕT¹Ç%3Ó•ŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠÍ­ÊX€„RèExNŠÁ㺠ã5“ •aBýàü)ôfýñOñÓŽZ£:lòf¶õÙ䤔ö¶Bä:¬vu( ù£öSðþ¢êQ5[C©).x Ï“#ÈhÙ<¾¢ø±ÕÂÉe’PïçKén9Ô{ý7+¢~;ØÓú·âã\iˆ—ú_BZœ[iYbvRm¦‘À¥#“Zû¯z½MÖ÷:ªÚØįŽ;€ØðƵ£`A8 ð¦úJß-»§©Z©îh'Ü— ’}Îê‰êNƒwáÿPiÙqu-¢öúXbå Q”Ü‚¡ïæ¨ÝMÓ•ý1}m3ecÞÐ×µì9ví?¾;+u–¦+ËKA$~_Õ[·SoÖ =Ô}i:Tˆ”¼íµo9•>Ò(RÇþÝéPü§«Û×NÜ¢–û¶§>©¥í{É%í-'}ñ¨>ŠbÍr¤,’–‹±p8R)ßIÕ½$Ñ•5,èÛ#^œXí¤žOÖp9W=êsįWÛ}¢ã6i(šÀq¹ÀdxÎÊ/¦ºFŽ’ºk„cùÒ“’Oì/JB¸½!O:!%[Ô ã>õ§.Õ1ˆôžU’¹º¥ «4ÌŽÚ1».vüU8@òsÙ/KoòT:íqP l`sß=êrŠ”r­4tÀnªÛÌ•¯Í}*ðǯà½Ò}âzÆ5àÿ§Ê¿e°…¾V‘±*Éx®R©ô¼ãÝoê hÊl•!%Iïþõäo…$ÇT!ÇþJBÊOÓ»‘V˜ÝÓøÎ૾7VáÀÑvK5ŸLEÓÚÎ#î»ÿSÁŸ!©ÒZ^AiÀ•m)„Œ@¾Mlúþ8-tô–ÚQMW 9¨ïl’5ÙË^ÒF0¶>J€‹¥ «d¨–Rø]ŒDæ´µ¤wÊç½@×̼ãèºIÊ”NI9ïTº Î7[– ±º{(2Ù;—œñšž8STÎÉij+…cióŒw¬ŒÍN'*o7¦ÄfyõqPov·’œ)=ïD߬¶¨7ið—ÊÔ+±€Jx?PãïR× ]-K CÆ[‘Œ}û|ð«ô×x&‘ÑÆì–ò£™K!KÚT¯'ÅAÏ&­“âõ±é{R[ÎEy]Ò¸ &åÄ”L†sk[R±^ †>¡ßŽߊv׃¬gm»oún°ÒAËJÖ[þ”¨ãÆ|Sm^éɪøN6hÖ‡nÖØú–eÖ-O#瀄*BÏÕé…ý;±œnã5`éY-‚¾#vû¶}~^5éï§VÙú¦•ÒÕy>â%ÁÓ«]³ð¯¡@øm·Ým+é=Ç«78¸î qïHŠÄ¨ïmÃe6‡»•ÚNç"ùâúµ“¦¾òø¦Ëå±Ív=%¯n½C?ˆ†·È¦ôäQä=—”‡G¨‚;å§>ÇQú*9 <¢ÊT7äç€Nqûw­8ÖàØM›¹M(ÎÕ"#èØëk(V2… ƒù"Ö.ä'ô:Û¬pSpZœ+ÍdàêI®ÂqŽàÂBŠŽ)¤­'u†­òSÓr–֠ƒâ™¹»î”‡nV³·œäsÞ½ì‡7°K¢N•Ä­™6“ÂÊNÓÞ°1‡m…éc¼–ë¬ p]J&E—å¡/ <Ò›RС”¨à‚=ˆíKÍG42vœ‚1±~AƒÜnŠZ¨åoòÜ26 ñÏÉ:—@I·sM4î•…´1‚V€ íÏšÊ/Q«õѱ0ŽéS*SnÆh2­äç5f¡œ´6äð;«¯Sßé(ŸR¼¸á£¹#ŸþÔ§¤]2ƒ'U‰ú†Õi&é}m¥e)$ +°ÉÛŸµ_<éZ+…Ê:¾¡æÛ¯0·l–´Ý\ œg¾3Õ{ÄN¸•–ÿ&‰ÃïöÉãéœ|«o@jh}?ê%¯PÛÂdºÃkXJ‡Ò‚¤©#>øÕ‡Áߨú¬ã¿QlÀ5Ü @€¾Çãr¨]c–ñf}ûj#qßß ±t7P­ÝIÔ×Tj;¦‡°?n·E¶ZbLÇ¥²¢T¶ÒZ†3ŒwPö¯¥x»G×wK§S_奧|6.4F×8¹ÏŽ\và“²æΪèÙ¬´´´L–FÊ÷¾G7—l8¾‹ƒ¾"&[U©YgX_¦_~~c²–Án´’R•ãh<öóKÄúM}_5mê«ï-–G+q©Ì†»œl=—TøHÉYCš„~[CCNHŒ‘óóMšŸá$LÐpõ÷Kµõ·ZÀSAR ¼€Ì–ÕŽ}2 Kƒíô«ó]Öc zj>ªèÛ“. Ù³$iÆá¸sƒÈ<ƒ¤ûÀVÉã»Ùvu¦÷J`v}/´ýv¿¸\Õ¥,óà_Ll¿RU±hRJJN{{Wu4\Ò0F>Ø+u]k¢tkA¸ýWRG…!ˆ…$§j|ÕQÙçŠÊÜ ej jZçå¾é&‰Ð×ýo¬ ķņ¤%е™KØÈH9;‘öó[Àß nÝ[{Š‚ÖÆIéf‘Œê>ß”¯Sõ=%²Úé%qÉwvO·ú«û«Ÿ·›}Ò/O¯Òm¢Á%·‚p‡€ $N£ïù¨gV>!uþ¾´Í°½z¸GÓ#8-“úN;µR”ü&¾žô'‰3;¤*:^š<²¤âáÀÏaî}×"uD€]^ã¼|cºXßGâBa°Þ6Œ3ZÆéá 0Sb&ïñIZòž-ví®¥®¯Å@PѶ”ùZôŸe_utÌÕʱaÛ ÛúÎãž½Y¬ðÍ(>aÎB¢³k1å6éKYöüÕ^¦çS O’ ÜŸö^ùÑ–åÉí‡^imÄ’TÓœc#½NºZ½M§©%§c¿Ê™Œ-/p¥S`ÇnÚ·VàmxïïVêûd ¡s¥v €¦ªq›s]þØ«Œ÷§v¬+é#ÍqÚÌûµÅôí8,;wÊÝ6šá ã•Ô=§ã­o,ž*âzIöðÙ&ßòVÛ,Mª~ί‰>°Â±hýOs—- SqÖRpò}…Y¬ÔŸÄê™NÜŸ€3ÿÒèK¹–Ø>ðý€_Ï/ã?¯×^·usRËLלÓñe¸ÌTnÊW‚A_ïŠûà·‡ØmÆó%|²ûGø¥=úõ$ qòb$bGuÇU¸×8"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"³ÆÈE{J!z~Ã㜼¬Yœà¡¡Ex^8á úø9£>ÿ‡áßRÜô Û=×®Ó`°Ì›„õ¥éwIR”gùQ·( {$œœV‹ñO«ì¾ô«íý:Ú©<¶<ê’G¼Ù@ á­€0ƀܓØ%eºu½â:«À>SAãf´{7ß=Ï%~^úÔ+ŸPõm÷]ßA½]e-ç9ÚT¯ô5òŽÑi–Y„$ê|Ž$¸í—=Ù$ûdŸÉw6Ɔ7ðFÜÈmý—B|Eô.KìÝ Ó7ÝFÔGp¶±6ó%.)IˆÃê h “–ÕãÚ·çŠþQt—TÒôõDÁÒãtî-Î?„÷Ã6Ûc…Génª’¶Ý=s[±$1¼q·÷ý• ×î­@×i ¥˜14fœ·5eµ5žDt)JÜ}Ôµ¸µ“ñ#¬EòæÙâg—KNÁ ÎH¤à“îâKŠ•èë?ÜéK\rù^ãÆ\~>8Pí ¥.Ším²Z#©éò\KIàd÷'ÀÉ­YäIU0‚=Üãÿ=•²z¶SGæ¼àÝu&±éÄîš5g…%öãzéR¨Å;°;Rqžj—Ôözš*–ÇUSC†FGù’¶KƒjØéš>>Š¾¹0ÌT%Aô;ô‚Hì AÓHçœc ÓHœ•\^¥— t­ÅÎ*ÍC­<ûÓZ6PEçVPá(ÏÚ¬†Â…©¯9Ývïþ¨‡kÓÍiø¨\›³»ðÐ+þ¥À?µxÙ&™ÞE3 Ý‚qÏÔákë½(|Þ|‡ ]cfŽÔÆ£Èd¡Ä’7ý5KL×D4Œg²ˆØs›ìº›§qº¿nÓVFýêZö¡‚r¯žÂºËd· #µ[Ûª¢C€3ûnxZæõ8„:¦c†7•W|TØõž€r^•º°ÔKÈi%Äú¡IkpÈ@ã8 ÕÆÛ%ÖÏZëMkq#Cu`‚=C#nU¯ +)jØ*£>“ÆË㞯¾ÇÓ ÌýÊ<&TJúÂw+98ÏŽ+TYhŸP|¨™¨°Vå‘ÂËç©%G'“]¸´œîW”/Ûð7ëNŸé÷Ä–¨éÞ§¹Hb>°³ˆæ ˜iÙí¯z8ÿö›7î7jç/µ'FÃwé)ËãÔø°æñ‘‰žn߯bŽþÀçé¿SÙ~°æ 6GÕž2+àýғʘ°ðUõ.Öu°a4Ëu‡îÃ4ÎAX"gº«ç(=ë8IàÕ²›lïFË\)‰RBUõ$qïJÏÊ3¾ël‡°•% RQF¥#`*'-´!K(X'È©¨\J{ne„2´8¬„æ½™¤‚¬Ge"›ã+!IHð|Ôsbpa÷Mj i u©:‹~ÕP B½Ü¹7„D‰½Y 2žÈHð9©‹÷QÜn‰× LžSCžG*õ¾Å &£@Ôr~IP7e! ”äƒPÍ‹%?1w! º¬÷=…8;æ¬ìœ™BX8VÜn÷e G¨„¯A?šOA!fÀ}–.åIWÓþõàÙ)· *XH^~Õ‘i¯{aoRÀ_ÓÁÆ+å:kÀ§{]¥o˜moÆaHin‚á , ûŸâ¼ó0?ç Š­#¢DΞ¸ÜmùSÃC.¥†ÊÔîR9Çßµ>¤‚iÎ#iqøY¶¹‘ÌìîTyæe$Ÿ¥YÇ41Àœ5ƒŽÛ…² ju/-n†Æ|ò}³^ËÇt£äkvWN£×=3ŸÓ=!¦ì}8-u å®ã}ùÕ8»šT?Ak% ò;‘Ï<Õ㩺’ÓWj¤ ¡·ˆg‡&Iµ—sØ·;nHã8T»5žçÎj©ª‹àáH>ug'?¢ª™šÒ×€¢•bµÌ8 «Ó©¶õ)Œ Õš‰©µäºÔdƈûáO„pÛGœ„cÓǧÕIRðú© ! rã€0Öó° g`0¡%ci2iXNOnw'ê{û¨ÕÅ-óž„ w¶²…’’÷‘Qâ,XÁR-®cØ zµµ(/“ŽÔæŒß•§:ÊåæI†“²ÙJÝm_öÔŸÒjyÏlmÕÁ [êÉÂLûËYú•qš¦ÕU‰ž^픵 » MlSq6<ãx sù¨'ËÈ én¥2Ðœ¤ÜZšóiCe°*9”å¹%m[5¼ÄÝù] Ò ®µ„MJþ’³¿p‰i„fÜAÑh¨$`“õOéð}ªÕÒ~õRCWWcˆ½´¬Öüzs‡õý£u[ëNªµÛ_w†:gi`=Ï?–ÝÎÊ[§,šåۭΙ¹6y¨eä¼¥¼;‚V‚¢FIÓç4Ç¢:'©l°PC0kòï/`2æä‘’GôïžczºZ›Oµ8‘¤· [“é8³ÝK:w cu.{z~ãyµX£[aɸ:ô—‚ £;RTpOŽüÖÏðwÃzN±y¶ÕÕGHÚXß#œ÷é>'mØnwUþ±êçØâ5Fé]+šÀ Óžä ÇÕJ4Æš¹ÇÓú•v¹k‹¦Ò¹[]ØNî·ú¹æª]Ó•æÑsu úakF¯^`†ŸêÏnÝÔ%ö÷ªà ËÉ:vÎsŸ„»Ikçô® i_Áí×›l¤ª$†f%J@Ü1¸GÖ3œÖ~ x¯/O]Au4uL ndÍs™êÎ@Ô3wM:¤›_HG˜èÞÏP-ÆvßB²™h´A›0$;.[ÍŸ™*å ¯?¥㊩uçM[(+"†ÚÞðKýšìðÌî@ùßå—™b>p­ü>ä|ü¦˜·#¸Ë¯´2°‘جŒdÖ½¤¨yû´ÖÝÈîF2¥ªý°{N Û¨úyÕóSw3–‚´$6…ŽŸVê¶xK]XÖÉÆ\ÿT…§ÄÊZþîYÁÜ­ºw£}HÓó6û¬˜ á PJ¿ w«/OøOÕÖê—}Æ_+ß8?P6+Ë·ˆÖJ¸õMqùÆU6_N#úȸÞ“#På×õoþ´½ï¡â{Su‘ϬÕê=Ž;cþYoX?M8.ÃÙeªìîEi‡YJ½=¸?zÖ^!YŸé’éù^Øn"G»•^j.¨j -dŽÌxˆe¦Á[cj÷ÈóR–¯/Vø-ÑÆؼ¬é{}.9îH8ùV»gEQÕÔsœdÂ¥º=Ók—^ú‚õžn­ƒ¦}D®K²¥îsÏ`FâsïïW?|Ÿ¯ú€Ù£«d9®¾MóŽ@Î9÷ ó×ýaKZ…\p±€Ý¿úHz‘Ò»®‘¼j=0¹öûۖ׋fT5ïiäêIüÞ*•âO‡•=-{©³Ï#%4îÒ_%®ÎàŒþ‡Øä%úW¬!¹RE^c€t»b>ú÷UîžqQe+QQ óÚµ}É¡À­5 <pºO¦Ö1¬õU¾>³ºÉ‹fHúÚ‚JþÙ=…múvÇzê¨ú¢w2” ôÏÆO Uõµuu¤¶0:O³ê4®’ÛïóíöXR\µ6Ú ”BÆ2ž}êÓâaèH/ÒÅa†GR³-’G~wß¿u‡IA|–‰’Õ¸  ÿ—'\fJ”ëYP³ZVå»-ÁNÇ5¸!{K_5¥D³[ݸH«ÓOr>ßµXí6zªù…= ä œvH\n0Ò³ÌÁ£åiT%ER˜[e.dŽ{¤ýªRðâ0Gd£&hsNÅ5ÍŠÑVÕ œRÐJ{'ð<»Óà¶ÇÓË}ÑÛæ¦ÜšÈ/6•õq€9óæ»ãì1KÄ—+û‡›ìk†AüŽÄ®mûA×]¤¥ô<8à®oŠCl곶3¤Æ ÃKAPHQP*V>ü$U‡ÿP)àêÞ¢§ŠÂæ¼A4rN¸Ø*Íj·=÷‚÷g?N?%óæëd”™Ž6†U¼(ƒÈÅ|¿ŠBÒXýˆØýBë ¦j'dˆ²†QµIú±Š5©&nT.ö•2 RAÁÎ*rÞA ãFÍúlب·?!I‡»%#Š”ši<²â[ìJDÑ1®×Ý\2²?sT‹{S6ÅP!@ž53Ó4†²§îáúAýòª}Qql ó\2Gù&£tõz&JÓóI HãÈ# ƒJuGIOi¨4Ó¸8Œn;‚žô·R2áv0¡¶û”–Û mGIªdŒÁV9à‹’¥ oñIm 2RÊIÆTœ€~ÿj†&K;`s´ê8ÏoÍEÖÖ˜£/`Êšß4ȇ>8ì¡›yl¶æpR¯Î XzšÔU"Ê͉iËN@ ƒùï쫶˸•Ž‘ß„ñžBv·h]E}Bá½ nÆ'##<ø4þÏcºV´³A-HVu=1ó5 ®˜éÇD”„Eb}IP^â;W@t·ƒn–66Fdƒž–ëA.1»eÕÑúsoŒÃ!Lœ8"¶ýWAQRÆãú- 7XÌ÷õFYw¤.3i?p*^ÝÓ¶ç7ª¨ê:œd+ÛbCkm´;*bS[  %©š¨R±{j[E”$?z¬^¼E&?é;ûºoü1ÑEF¦2—$—Ò@>kX×Ôyõc²œäFXSÄœVƒm­ð“÷«wFG†‡ãóQ•TOvøRû]ÊÒ%¤:ë>®x'ž*^Ûx· ‹ Äg?U_¸QTyyh8Zz£s´9n·»jZÁ¿©e>äU·íÕÖš‹L?Ã*#ÝÄßP³èZ*‘3„ÿ€ûª¿þ«“q‚˜NºB±ß5Íöþ°šåNÚwHW‘`d2ù *ª÷{‘d–®Už9ñQtT/¶TùÒ ¹Êýk¶2ª=—-õϪ1­6‰wòCQÐÚ–¼«·eê‹ûjbkI'¹ü=éV5Úœ6 ñÑþ(ÿââíÚ‡¦º>â£t›–WµyôìMv/Ù“ÀçOR˵KKcãÜ­sö—ñž-¾J 7ƒ3ý#àw+ó,ë«ykqÅ­G$žä×ÒvÆÜ/“³Jé^ó’wZëÄš(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B+'"±B(B+ ì!‰B+={!“Ý Ð íCXâ…åd[¾èEdŠÊIžN(+ÞËÔ¤Gq@^8à/Ú~¯êP5Ó±/ºâñ}¹ÀwrZ‘-J)t§¸Jã¶kâ=ÈÏSRêú׺Yäåî%Î?™ööì¾ÓPRSÓÄ`£h{7~Š„¿ÞS›çòûTŶ‘¼¤ÀƔת½rÕÝKoM®ý9Ù3 ZáÚ’²{µ Ò?}©hê ¥eêänwGë—KŸý¬hhý†ÿ*n³ÅAN"ˆa “©ÊfÑйlZ²çbT{ÕùPزý ÎË·þõ¥ƒ¦×ûåÂílLÃ"Ðü®”äÅyjA |%IÏþêiÓ]cµµN’-o–'1§ü$Cò~kΠéÙª[ìiv£ò=“Ž®¹_5r£O1ßLn»„ã'±>3šÔÎ/óçò@ÆsÇçÛ*ÑHè c£f>pª}E\iFÜ™|¤ìR›?I#¾µKRè’²}NX6J¡Â‚˜ØÒÜÓ)æ“W¤¦-ª=ʉÜ,¬; 8ÒÛÏlv©šj÷àÒ3I•5°[ÓȲ!Jz¦ÁØ´‘ƒÏà‘Qï¼Ï üȉÜtŒ°1ÍÃÆBƺi½ ËÃÎÈvBÌ–P®èAn8ÏïJTß䣂Q“Èò§U†MPçGÇù®ªøsÒ·¥ê{ðrÿMÆ…o~{’\PIB[O NHÁRÔ„ñÛ$×DýšúN~¦–®®Z»6ŸQÀí’1¿$n;-×HèYB=~c€Ç×¹ú/—¿â1ñaè³rî7íHíÖDB´¡.=¹Ù¯vÎrþõR°ôÅê®ÿr£y{ZãªC¹qÎ2çäŽÊ÷omªÜkªÈd`gØ~Kñ»ñ ñ•Ôîµ_®N9{—o°-Ò¦¢´¼%#ö¯¥Þø%j±S´äîO9\AâŸÚ¾ç; ¶¸ÇØåq̉ÊuoHuo:£’¥’ku±hÃF檚©&y’W8÷+EdE]oðuzËñ“ðÕqŽ­#XÛ‚N3úœÛÿýTSÆ_m¨hô;¶¤öS½1ÿù*þmþá~ì¥ÉuÆ#’ ®Å~onñ‘9ÔA=ð¾Ëô ƒ'tÉ5ˆ²3ÁÞ™@À^½ŒÉÁUÖí îäy«0å:›î™•9¨úDá ÷§Í¦sÛ² -vÉs󖳂¼ò>ôÞ8 8VZ r£î<·TT£ÉûT«ÂpèêAobÕœR3œ„ê#éÙ8»°Ò]eÑŒã$÷¤#³¸X0’pð´%N…´•Á`f®.ƒ¹ÒQSÜ&h0ÎpÂ×±Ù>Ä5Ä´ü8 éº–‚Yä¦!ñàZFÇ‚2#é•»iûÕ‚S°/–Ù–«ƒd…´ú T9ÿ_È⪗ ©fu=CK^݈#)j¢˜k…Àµ!eב¸'v<Ó´S¦µ8[î·K4Ä\m— Ö¹Éý0ê›Xe$ƒN¨êåâHZáÜäFëÊXäf‡´8{Ÿî›¤¶ÌÆR”ú§)[½ÒG$’{æ±cðrSÚIKvà) ñpÒzP黦%Üjä™òómì!(88ä«gýª~©îŽ!K$máú¹v p|c9ï„Æ™ÑÔÕýà<á£ìO¿×óU¡qcÕcÛ4ÄF;kŒg|/PáJòƒõ Ý°—-$'HÏ-Kõ3…¨ïM$á"øA„ûó.²™9å»!G*R»©^äÓysœÊ£ß+ÙLänSäœa+R¸>xæž~gºÓW*Ÿ5û§´¼…³ú’IñŠiU\âÒÜì¢D{­­!¾ ö¤{ÕbC‘€¬Vêbã–§í»£¥³”Ï棟³²¶-¤'›<ÏŒV\ô1•ƒß?j«¨‘¬>ê÷žØŽžWÕ„üQh—é-7§ný?ùÛlGO«:0Hqy$áI8 Á9Áâ¾”ýœþÛö’°ÒÙ®6÷ho¥Ò° äœî6ÕÎq•É)xv¾WÍYMW¥ï5ÙÇä§òV7PõŽ—ë4)úËA[[±é»h1ØeqRÛ²Üq[RÒžyÉ÷«o‹½Ynëêõ'Nb*ZoCZæ¾G<æGƒœþªÑ½7]ÓR¶Ûv™<»’HhnÍ”?‡N¬úòˬ…‰É1ÄÉŒ]p–›lŒá¥xÿÝÜcµCVÿéëhªéº~ ¡¯4åìH&ÀcZFt´ìA³œü%þcë"¼Éjª¦óN–˜÷$ñ·è£^ãeé¿Oõ#—‹p¼Ý®ÿúK8pqµâ;?Ö¨m½Ñ5Ó\`M\âÊ|ŽÌØ¿r3¿ê§/´•7«´"™þ\pz¤Ç¹á¿ê¨ÚfE¹? ÌÉhuN¼¶Žâ¼`áC°s\mq4ôÓAäÂ&š79Ìß;dç7ÛU¶á•Îþ²Ö‘¿O’¯;ÔÛ¨nÆÔX–Í4óVôÉ#%Nœq‘û`ï[‹®ïvŽ«Á(ÝEòËÉvÛ`†ûßu«m”•T.•Ò9Ò‡8·°ÿžåFãG‡oƒ}¨9*ã!—#Õ8Û÷Æ ijÚ*z X'´æIåc„š€Àö üŽ›šy&•ñTzXÒ4ã÷Êè[;ìÿ ¶—B´°’1ƒŽk§úF²¹Ã­Øpc~=Xßÿ®ËPÜ"wžðÞ2T¶ÛpŠãžÚIÁ$c?zݽ3w„¾a¸=ý”mÚÿO $Ú4ýén6€ÏÌg9÷¨ú‹%žè÷SÇ€ñ¾I^]0<(õó§‘eÆ8u+ ðŸj¡u'…Ò3Öàãì½³¬øTQú8õúȆ†Óéä#h Ö]má{ªí€³ì;qÂÙâ)§:+•®}Ôð@vÆ™d#ºÚQB‡î1Z;ÿÇ—ˆšœœ~ëzQø“A/¦£|Œ¥:J6»ÐQoÐçØSwn{*ik};ÎÇóSý!Õ·n™Š²P¶vÕFc:›¨Œ÷|a7½¾Ùt|OdÚLg#~Ê›sGÝ™’§D)-£9ýŠÑ’¾F·°È«×ñxˆÀpýSä]/ªâÅrï#¢2Ô¬Éﶤ °ÕKLjØá½ÿæê2[Å!x…ÎõʹÔ.å÷d:áW*8¬iåf=\«MD8 Í‹\Kü7µ,e¿iB²ãj öÎ9Å[zr®‚:ø¤¸³\ ú‡¸ü·ÇºòøÉ_JáLì<ðWS订è{gQ¸éÝ Í—M 2â ŠPâ1¼‚y W<龃ñs¥­=j.ÖÚ*ˆh!¹.Òæþ7eÙ!®†Œ-3é;M§Èªœ¾_Pß ñDz¢º”ý¦ûÔ]_+L5¶É&â쨡#„Å#í¸ª´O·ûMǪîtRK+žÁìr,ç óÑPÔRÚ ‚±ßÌkp/öP©º?P•2D'T20œçûV·¥“-ÈôVx/”û´ÇJ[ïv§Ó&BQ¥ƒšV‚ãQ S_NKNq±Âƒ¸ÕE1:ñ…ÜLtbáJ1¬¢\×*âd¡·¥ee*Nw}Àí]áÔÞ>ÝÓ1uDu>lîxi²ì8g8Ïn>IâTRWºÚöa˜$ÛaT—%6$פ&2÷U¸9®¹ôÕM-Sßç9ålJ;üoˆ3;(EÏ@Lp?$ÇR”²UŒsÍCÖô¥Ê6š‚ÞwýUš‹ª¢Ù„ìª+î…º}aPÿä9OTøŽ$iè­ô—ØHÙÃõPæ´UÑ·ÒŒòËRoº4Œ(û¤XÎB¸tu®õfIv÷ì'4ɵ5ŒJÓõ*Ÿ{©‚oD„~ªu¨4¶©ÖÖ÷"¿×–·R¤¨·ÿoÇý+aÇ%úëN,EåÇbGó…[¡»ÐÐ?-pí•_1Ñ-]ÿEËsÀúŠM0«èKË$¬ÇÄs˜?UkØz!~Iq¥#êiOz±Ûü¼ÉªxÐ8ÁªeËĺ2ÿ-¥]ú3¤/ W)×B•¹5µº/—2}5‡.<­iÔž!0·ìV龜Ûc6ÞÈ­îÇ$ŠëN™ðîž&†½u”ÏqË•»oÓ¢6­6’;;VݵôyŠ'8à6ÀZî®ù$‡r™õ謕8<‘â´_ˆÕÎ¥i{‡©;;ƒÝº®•|HsîñÍh‡uÔeû®-¶el\ÖŸP>‘ž;æžTÜ£©!¢A“ò°m1`È ®Døð[EÔ¡ÑÛžõE»VGG+›#ƒ\žÁJù[¨ “L@¶‚Îñ·=ê—rë‡Ó¼¶2Ç*F@vÄ(…ÛQÌZÛnâÎpSÎêÖ]Wâ=atl¦isí¾xÿ›)ê 4`IÂSlþ7rÂÖ‰it ð¯m4w›£ƒ‹^ô!%\iaôŒaN¬r}Y_%5EÇq‹ÿÅtO…ý>ùêÌw— °~;aU®‘³Ì‹u§YOµÚ£e„4Ä?H­™ÕÔöê'ÀÀÙ`0•éÊYꇅÈÝG×CŽëÒd!*HÉV@ ­zŠê Z%>£ìº ¤:`¹ØeùäÿÛGOtù,]¹ BšŽÚWõ<éà VÐð/ªûÕÕ­{O”wɳÏú+?‰=kEÓwÔ9À8qÆûp¿ßX^5Ö¦»jkä·%Ü%º§¥ã'€>¾ÈÙ,ðÛéYIN0ÖŒ/Œ]ÕŠù+êN\óúÊ%RŠ²ŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠŠ÷(Ex„P„P„P„P„VE¥¬PŠQ¿(E`ŠÏ$ð„Wå ¼å¥ô"².÷BØ”ýë…æVÀ S´J7=’o_¼ÿŽ~°èþ©u5ØšÏmÓÚ"ØÊ ÚmðÚ ± :GéJ@ÆIʉ÷5ñëįÛÕ]C5â–/&“Ç€ÐÖ4s¥ \rH}•è}ªÚÈe%Ï;¸É>ù_;n‘Š¤²ÆÒsQT’zK•¢µù ±Ê¸I ÆIpUÚœŠæÆÍoUÚ×çÒ9]£âµ`µíy KªHóZÞ÷)¨›nÕ¦˜Œ8®’:§¦ºE§í¶k_«ÔNzUÖkç*Rpl¶žÁ ’{’jW©¤³>ÕIGC…`s4Ž;@ cGnç<’wXÒ²±õóMRáäà´~ä¦g:}ԘɋdÜ6R©öà}ªŸyžJf9 ò^AOOs£î›YBßqO8®ýÉóUùd BZYÎËd¨4„¾¢VÑãÅaàíÝ7nîÊBˆå'Ô ;{Ó—<‚œ5½Ô¿GAMïQÚ-%A×FìsôŽOúIùûùÝcY6ˆåÙ3õ)VËtrûC-'€àb™RÝCž\2ç`ÙT⢠ ðÓÝPéM>:«sÕÖ€î·m&L{ˆx¥Qm$©gWý¿Ô3_Ó#Ãé펦?Å%ðwÁpÓƒØc Áäª=Ež¾{üR5ßöÀn1Ü÷Êþ|?¿ºŸâ/«:Šé*{ÿÀ¶¢0JR€¯÷=ë¿|𪗦¬ñFÆÿ5Ã.=ò¹7í â´×:çZ©]ˆ"8Û¹ïú.!­æ¹‘!!!v÷øpiUêÿ¿‡k`iÇgP7qt§úŽÚÞ*?ÿŒz©õíÕ´6JºÉ6k#y?¦?ÍZú‰Õ7ŠhYÉ{¾Wî qKe–RFA|×çw¸¿Ý}šéÚ?.…½J([¬+$ã¿zZ†€à­08e@^–Îòœàg¬‰ØN°£7–”·š-ç¶A÷©K{ÀiÊ dî”ï?.Êß #’Ò5úTµ!Û Q)J@dÒƒ$ü'kSÓÏj 2Sð”¥ÀâõcØx¤œÜëI<']9©'é˲.PQׂÒûaÆÜB)'¿ÛƒRú×Ó?Ì`b0@ ‚0v?ðÂe_@ÉâòäÎ9Ûc²|&S«’¤†V²TBGÒ2|T/™ƒÂÁ²if“ºDì7@ (·É…¥h'ê äïYµ§!àîæ øô=-¸Ïvù=ÙÓ\GÌ>é[« N哵#sœ^™ Þ\ó¹9?Ÿ<^RF!Ë`Øp¤6«[MÍyq¥D–˜û”—0v8‘ þi„Ó–?O;þGõIÏ+‹páÏì¡WçeÜ%ÈšRëË$­e ‘ÿ¥iÜ^u9IÛô4pzÏN£Iª%žãåQ!ÙAä”'jЕ % HRH‚NAî8«}+éäû¼¬-‘¿‹;rÀ;óžÛ'¶k™ªa™„gäç —P9óMˆSÛc)æýB”¥Ddù¦5%6©œFÒâ¬+u½Ç '»iäœw¬íô…äz(<_Œ}$팑‚~ŠÅ›¨Ò˜ie‡RiÎR;U¹µ3²g:7TæZ°âù)ŠÛÔÈÓO¯Ó`œžÿŠµX|DtÎm<›7þKÚ›8SFêbδf[Ö÷“ Æ;ÿjy]Õ_Ãd2R»Qw .K(”bM”îӭ̘í»(ŽøÆ1Vˈ5UQƒZï¦ØUªî›k^DjdÌÖå7»’¯°©§’¡»7e_}+˜ì{&yVØŠQÜÚB|w¨*Ξ!ÎÒ}””5òé¦vœ¶Êa1ÔËKI♟Œ°ÆÿVSêkÄì~ S(éÝm)Ä@犪Ü|;‚H‹4ŒçÙIž±©®Y7Ó‹za>ÒYG¢GèÛÁ¬ì>ˆéäiàÃ…äi7šNþêp襚Ái ÉÁ Uz ikۧ˫U/‰uç%ÅV¯†èÀ¤°BsÀ½U.¾ÃJul®vï ›‚WŒt;p‹ It`Á¥(¼-¦t&ž#»þR’ø¤LDzöÛÐHV‡R´Â+Xç*çšV? ˆ‚öj#ÝaU⋦n5+~Û¢X,ÇaË[giÆvòjíCÓ2Y¥wT*Þ§~²ðóº˜Bé…å|È‚°sŒ UîÇá= Ù©|{´ð«u>!Õ°hÕ²µâY˜oD?H-´ñ³ÇjßRQ yF¦ʉ=ÅÏ—ÌÎçºD­e¸²¯^ (W`qÍUŸÐ–úÖzâ Àêj˜]èqH™é½¥JS †ÙG8&¢©¼3ò_,íŸÙ9YÔ¨;uƒÓïK ~+-Œ€?5•v¹«33CqŒ€ )|D¬lxkŠIyè&–”¿V·¯þ˜²>é¤TOý9K+òæÑ(/•,n’ßúrÔÚSH ü sQf¤˜ &ŸÅç'9XȳÅBòÍ#¸Š®^m´Q€è@/+8®?Œ¡¹R!ÑÊTqUé¯81‡JöHY(Ô˜¯ÎUJ\•ílœ Š¿øQfa–¡þ“ÆU)méÆUá¬å4ÛõôMDŸIÔ¯Ž?5¬bñšþÐûœŸUt¤”gPìšo'›w×l†y5Iê/ ç2‡Åè JÝti«[ÌÙv×*ß´çƒÜÖŒêijí³µ®íû«¥º–9›ìªÛäëüûŠ%FõŸdòBsôÑý[s¹V×yÐeàö²¼[))"€ÆüŸ¡\%:„F”—7Ÿ/DÚÉcòäf ÙEÕQ±§[8]Ó-=h’´¢Ú‚ Ò¥ŽÆ»·ìÇà}sÚû†’5sŸ…§:âïRÆÿ''~É×Yj{F›¹År܈èi´ŸS…þÕ¹¼K}®Ëp†KlMÒÁê=‰ï·ù¦9d¨­…Í›9<*EpÔïLm‘R±ŽØ«œ›ÖpÖ_PѧYlgeµ]ѯ†„Fãœ*÷­šòÝjh"#¡r 7,•gŸŠ2ÑÀö2Œzñê9Ï<+†}+4î̃ àŸÇÆÝ¥:^òìÛ²R¢~¾UÇ`)_<<¯ê:–Æ©¹ÆOüì·/Yu5LÛÌò8Wâ«â?â3UõûXͼÝå>›J]Q‹¨á Ïõö+ÃÞ€¥±R¶(€×€ _!|_ñŠ³©êˆq"‡¿É\Û[ iTP„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„P„W !énŠð|¡ë±Ù¬PŠÍœ¡n„WŽÇd"²-Ù¬B+8Њð±¬ÃP²H$ñÅf3Ù­‰h¨æ“qÏ Á¾éSM í'Å(!Ã5$ÊR¦Žß$½gËy^¿[ú’Þ²Vé“Ü×Ä¢CF îlcˆ©ŽŽéõÏZ^[µÀùdHôÖé[ËÚ–‘’¢iÅ rÎó$Om€ÉPךÈàf·ŒŽ?5f\ì6 ¢Ýh³G¹ fIÆTûêä•~”aUk•ìU½†ic@.=ÉþÀ{i¥v·K1îà{e‹ Ý},ºÚÃJ²¥c îy N_‚@í•0êŸ(e ŒûkCKm`‘žxâ{Çè‡O‘©NíìÆ,¡÷`(‘É5^­'VJ`$<&ŽÉdc%U ,š–/Ê|}HL}Ο£¾>ôÒ<êÀJÒ‚\¢2¥å¶J?1 ÝÊPS’9SŽ•Ü Xõ—IèRÝC*K$xQÀ'ûdRòVˆX]Œ’EÒŠG45§ºšÜ5"š»‡¬¤aÏQööÅS©ZýZÛ±§‘AèÑ…Áâuñ0ßO¾.V8sÝûPèZá^˜åÅwíÙ?½uOÙ£§½õ rL3¹ßSÇú­qâ5é¶+-E{Ž‚Ô—ãêCÊ}÷^Y%jQQÏÞ¾ÁFÀÖ€ɺš‡K#¤$“ú­šA!!!}šÿ®?¨>'¯ÝEz*×jÓVÿ›Ž*I ~v%ã\»ö¾ëfÚ:6hšG™9 Üg'ôÂßßg—uǨÙ&=1ãõà/Õ™åé wwÒ_¼½¾JúáMJØØ7¦[d7u£Évj’•Eu.„¥¢Õ¹8;²8#Þ¥©!-x%Ç ì=ò1¾GŒ|¤ÞÙZæà=Ç¿ÐåTsäáJsŸ<ÕŠ(ð†à§&\Kѵ1Äÿzk "M“–o°I®¥`%dqÀö§£²{Dá‚|¼²s¸Š '©bÎŽê@ÇÜ,ÙÊqeÔ” jèÊ“‰Äl’¡Óê¸x84³˜0I)ɉËNyþÔÕôà€;u'´N}#¢,ƒEÔ(9€KG=ÿojʉ¸• »@Èõcù÷ÙD\)ðÂ^Ý[½×Rõ£]Òv[[ºS¬R5®!µÏ·É·z9BÒ u‡RJœž­‹¸Ï'~x½á×JYØÉ,cS&[®73Ö× ˆÎrÓ‡ªº7«ou2ÈÊê/.&çKšíYÁÆ8 þ ö*¦úSa´jUXµó÷©1îP–­;p±)‰QfIêÏÔŽé!rTFF*«lèJ6ÔKAusÌ’FM; Ñ# àgvö:NZíˆS·¨ª’&ËB]üÁ&ZæcõÛ ”“¸ÎHVÌ-I¨|§ž^=8ÁùÿžêþÙ5àº7Bôv²Óñ%5qMªöóÊKh‘EH)7+ú 9É>â¶MøkSv‰ŸwplŽ$훌mêí“N°ŽšgknXnU)¬4ž Ñ—Ù¶-Go~Ùrae i\ƒ)PáCî8ª=ÊÓQEPúJ¶HÂüÜ{±ìU²‚¾¨DÔç-?óoÍG$cÒaM´¯<óQñŒ’ÖŒ,#ºV@+Ø3Øײ°v Ç•£ucÚRí®Ò}Õ´¯t2Üd©Dê `yqÁ÷¦±É©…¹v6çcžE_—¹­ˆðwS/‡˜õ¸»é©)´;f“l“&rgNLFýê8AË„€9'÷­¹áOJ›½ké]§Ë½ï×'– X3³°râp1¹=†ê®+5+& v¢ö´in£—m¸ìÑÜöGUtWQ?WÉê7®¡”,Úç‡S-”céh)@…”§ç¶*÷J Dõ—Ә߫Ìá»ìp1¸<)Ž”¿1”ßwÃ3C'ßásˬ’6æ«fL-„_¿Â–XàïyµíÈãŒTdú¤:Ê©õ%Ý‘DwVŒdµž@I'5f¶ÇäÂÎëž®Õ>l„¤³Ceä•88ãµGßÒÎs•n'`°†—PÐK©öïT*­†å\mô œ¹i¿;9 ¶ãhR[‘XÛÚÂpy[“¦„`žT¥zV÷®uM¦ÅfŠ¹S$º8ü“öênŠÁQs¬ŽÛFÝRÈ@hú÷úJžê Å=#êjÁ•ö‡£Ý3Ó})ÕšRÇW'!·»ÉJˆl+oèçœWÓ|*´ô¥ö–†üK‡:gƒ†ç úû.ëÞ®«½[§ôùf@Œwú¦Ï‰Û£Ö»…°[gܯџ{Örl„« p„Ÿ Õÿn:Éhª 4rÉPÇ;S¤pÀ8á­#u)à… g†C3š0ûòH\‹ujç­ç92TY~²ô);¿˜{×ÎÛÅUîõS÷³ƒÕ’>=þ£eдSÛ#ÆáƒÏ.ÎéèΚÙîÚŠÅÝ5‡c[-IŒ­Av{)a§äí-—0xHG*õÀž¥¿Z:*ž¶ëJߺG١Ϋ©‘؉ŽkŽå„ñ†¨o…Ì=ib¦¹^䧣”ùï!Ï“V0³w‘Ž3>äøTÝÓMÊÓ·[$›ü›©êaõe^)½Åw?CM’IYn*íȵr?\t›¬—z›´Ïuè9ïŸXÒÖ8ŸLl9Ëð7.ã€6 g[o-¬§–:F·î;62Ó’áýN#¶ý¹<žSŒêwR,ó®Ví-|ŸkBä.EÁèìUíßNtþ”œàÊäð*¤>Ñ=]o¶Éiéê—Äß1ÒHö4’ü7Ô÷gKAFI''ŒIu'BYjõñàÀã°Æû4rO|ñ€žuU²|Wâ‹”¤-ÉHK»½Mü©X@dòsÇsZ‡­ü>®†àÃq—[çõIq:ŒÐ\rs€\xLìUð½Žò³6ã í¶îx ®ú‰uÒº®Ý¥åÅ”ô‹}¹1›õ¤I#(W)ÎìãàŠ±õÿQ\íÕ°ÒUÿkŠ=AÍpiÜ.ÙœçI 8#!Lt÷NSUQ>®"?šíG9é Ca'¹§–Û̳ɤ5¡§ŸöQ•q–7e&Z£G Ø{gm7JZ7†8ã*»å+¶? ×h8’òFy'c¾RTU¾(Ýê)µlokC±²És˜Yq´ªG~4åÝK Cn >‹Ó?žê-+SºÊ”–8>øªwˆ3BâÝ‚Ÿ§±‡7/K!_eÉP*?ly¥é:º¶ ‡³;cºmUk›'§¦N>›¥I=þê—¯¨¸2FTS–þ…FGMírh“%ÅaCVy"¦$¨žHÄß„÷ú©)Àë$:¥aAà¥Í?¤cžAó~«À;&ù·Çaoùxî<¤‚TÍQº“Ä6ÐÈcˆ8{ö cdüg¨Åª–+Ä· É“èHnÓÁ©ô¶{ÜŽ§­qcøÁߎÍÓ¡*`ÍŒd{©œ‹ËŠŸC©Sa¬@¶ºâ ‰Sûö®PñOÇh©c.ø['¦ü?ša¨ ”õ±òj$¼;ïZö‹ÅÈ/tu›:‡VÁÑÒÛ_æ²}Òцø/(²A9±«'@Z飩i™Îo¿·ÆMòs#pÝÒmw­n”Zí+§v|ûT‹ž-\\‡Ð;¥úW¦¡fg¨Xh]%zÔ->Ýè¼ÒŠIC§ô…â¡|3ðÆëÔaðWFppò6ÏÔ¯z§¨ihÜ .ÿ åн7y®jz8ZÛl•3]yö~û2Ô::–Ô3Q`ÉÛŸ‘²×=OÖm/`iØ•Ê7D¸Zþl©Lvt$ p¡žõÊWúÁMÖ’RT°5‘1ŽÁo»mœKil±î\êëÔ·5µÛ—˜áá*Æ o“ÖPGRBpÆ…W éQ;œ­HÕL^T¹l£Þ­Vþ£¦®›U[Ag±YºÂêaˆU1­æÛí÷EJ¶9è ¹À=sÚ&Ý[Slô€ÞïØ­‘Òô²Í—8ÊùáñE×›oO´Åêåv¸¤>–ÕÊ籨ޔ²Õ\ê[Jæ—FëqRþ”ÎpÜ/ÃÇÄÕç®=GºGbâóšv3ÊJô-@÷ûâ¾ÊøáŒ6 cNœHýÊùEö—ñzKÍÉÔ4îþK;•Â’ry5¾—)¯(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B+-;e¬PŠŠŠŠÈcº^µØ(ExìvB+À2„R¡˜B+=½8ñœW‡½Úp=Íe¨…š[9æ’Ó“…à9J[eKW< Í”î+; r#¤lYÂA4DÝ.ˆËïe½Q’Vy=éIO;/Yƒ±Jh-òl È´†¯á~ÙUÓ½7Ó;mݽGp·ê PZBôNæb¨§*Çù”ÓŸ×Än¦1ÒK-¼ùhËNZ2íûžËì媶Z÷2hÁl~Ç•齬_5dw%j¥,+2¥§•í«jåGnx%Ò–ê9*ßçòa.pÝ؆Žäñì–êj§6=13[ÏÀü«ÓS[‡Qî Ò½ÒwYö˜á/N’¯« Á%É.Ÿ¥p ì8ê~šuæ­ã§)_÷X†I<÷%ïw „£¬em}ÂAç±ñìå‹„ v‹ËÑ~m§ö¨ ­¬íW¿|U2)˜ø²ÕcÂVFì­%Ï3ÖíÂ`OÏ:_l(ãÇŽÕ t«tÒ™;žOÊkG†`pý2—š>‚Z'=±Š‚¯ 7å+#÷ÀSWšŒÄ‚ÛN&Ci?¬ n¨)[¹å8ØÜn‘ΔÃÌà)#œbŠx\º‘¢¦ ä…tÅ]‘ØT»B– À[­sXfxõÞSM”+<ý^3YÏNMçØd')³’¨sÕQ<}©”Ío!'#š?ñ¯Ì¯øœuÕ=Lë+š:Ó8JÓºyE Êè9qCò¬ÿjúËöXðìYìŸ{2WåÛö\ö¯ëŸ:¦;,Gfnì{ö’ù]J¸Í!!!\Ýè/R¾!u›:¦v?â×oOÖyÇ鱬ã{®Ò2p;’{ ©u·][zv×+¬š"nß$ûÜ«‡Cô5è+Ûo·7/<“°ÜŸeúÑøøV³ü&ôÒfšõ‘?Z\Ü›äô¨”È€†Áý- ç’y5ñËíãd½epcØÝ4ñçC{à÷?%}MðCÁH:^”µç\ïüNíô ·DR®B¾k›L#+ <­;a3=00­Ø9Áú8u$K5n¢W$šsjv¥_W55LNÖmnû­Mº¦•á'½fæä%ØÜ’¹¯‰-¤ñÛR0E¡=€n£®:P¬dŠ”c2¨ˆr·§;¸Å$ZFÅd;'JŠ· nö' 9:ŠÖ┟¨ÍdÑ• pBØÚÖS»)#ý«°ebcNl<´”)+ je+A :Foº“ÛJîúKj2v¨•8¼œgÜöÞŽŸ'm¿ç÷=”uc|¶jþIÝ›íßEj[uÓJ߯V‹Õ¾@‘ c–ˆðì¶Ô…ªÏ½MXºÖWPHc’#–¸lAã=þ}ÔMU®ž¾™ÔõQ‡2A‡2ö>éÃTkõk½g7Xë8 9:Sé©·6˜¢S˜úœì¤¥j?Rˆ$«šw}¿­ÊKk©N§†z2â7pÙÀQÀÆs€2’¶Ø>ãDÚ*W°.ß°í°à|+Ou«NéýÛP-ººÝÔÖfofæÅÍ&Þôoò9 HáÁŒrr*Ïnêz T&ÚÉb¹Fü™<Àèœß˜‹0àoŽIQ2ôdÕ¤K#JGáÒuƒï¬ñŒü«×Xkµu§Ñdß­õ3±h*ák|F+RTÂÓ¹+8=¸úOŽjÉ×ýYY}¶²j¸¼ß(ŒÉÀipÉ„p~6*·nµ‹mal³Pü.Î=p¸jô>Râúa:úb¥J ïV߸÷­XFßóÙmªf倻Jt±´È¾ÀgPÊ•Ð¥á×™l-iàã Q¶çžÙ©kL4Ž¨h­s›rÐ ÛßøýgN)Üêp ÇÙ[ýx¼Z§k›º]3Ó¥RRÔE<­þ¦Ô€¥%xý@ÀR=pël·©ä´‡}Û8f£’@žÄî6Îk£¢ž:F¶©ÀÊ6çãuÎQ®Ò¢Ü¶[|íQ ÆAî3íQm€hÙl¿%+µ¾®êk¶‡¹ôæZ-òìOÜ?ˆ‡¤GC²ý@„ ™#yHJ8ïŽõ?rë«Œ–†Ù¦ptAþfKZdÕ€?òc^p%ý)Isn18ùºy8Ç?‡ÏUëVô¸°”§œÕ!{Ý¥£%HW^ü¦ã…`Ù 7 ¿UXK¿íV: Cê+Hõ'RyÎÒ7 )îú®é[7wþâxãóT~¥¤”ÔÇImƒ\a¹qöÀw*×Öš¢Õ¬"ØìÚ¢öíÝ1ÙÄUDŽ•%ÆÉà¨ÖôñK«éz‚žžÝv©t®c}64µ¼`qÜìIü•¦¬sÛ¤–¦†-ÇÕ¨œŸÐvPýsÔyöC³`‡d]®Ym ±³-ã•`ûç½h_ü`¯¶_©ÛUHÚwQÆФé?’}ûû«KôdUto>qLòNNwí¿ù(¦ˆ×G­WÐGQ¹3Oh«Wß(€…% ŸuWAôƒ[MÕ]E‡F˜‹lvSFC¾€ yPWBùÆìŒwŸ³7‹6‘ë —u(5ÌH‰ïx‘¿‡» =šà06Æʋ랈º_­B–Òò%/´‚Ó±ÎÛŽå¹Æùá|lÕh×}IÕšÚ÷&ck¹ÎzH xºZB”v ¨òBS´dûV–ñÃWz¸Ô]&%ÒL÷<—çnvœ“¤a£à.ÔéÏ #µYà·D"hnÃ7 vÉÉQ=gÕæµdؽu‹1¦K d€PØä?z·ôíK" ”ô :.’òsåŒjÜ®é»Òîµß|¹Ì±ØÊT™2!¥+p“Ù'ÜÓ[PS].2¾(u:6‡?€ÛãèµÿYôÕPÕ-0p²¢£ˆíꛊá]¶á!~ƒŠúV´<1HÝCe±G¹»}èè\úv‡³©¾¯¿j& Å¸ÛþfbHdå_¸ïUËE,R<²cƒò¡i¬Q \1ŸuÑ¿ Ý~Ô«£öÝPô”YFà·øô”=‰­ÃÐ}RûMgeþKÁÎùÁË_ø‘Ðq>0ø.øW/[:±P|¼»=Ö3ÑYåJ ûÖ½ñ^¼\ª›$.Ô?|ªïIô›àܬދuNêÍ6Í«øÛ1'%[TT@ÝûÖÇ躶TÚE$Þ[Ç9úíÊ€êËE$æcpS-e1z-ÕKŸpŒ ”îijpexñŠO¨#’Ó/›3ÁŒ¿ä£m ÃCƒßeZ_z’/vV¤Ûäg¹B³ZË«ºÐÔQ—Ät’¬ÖÞžò&ÄVrº…p´ÜIΗHÉQ=«VSõ saî¬ÿÁc“m+¢z?Õ•_">ÍêCxi?©jÿšéŸ I35G¾“§õ>›»9ôLel»Žw ­›nê+udí|ËôU;µš²‘§p•êAL\!‰ ¹D} æ¼ê¨gOV ¶È ¶=’{TµÑhpÝWÚ·âFÉ¥ŠX[Aíã)Ç;x¨^¡ûXSPŸ$GæíÙYì¾OWë.ª%üBIÕQôûE¹*„¨ðz×7/´åEÃþÞÛlŽíî¯t^GJ5Tœ€œtWu {©©­rã4µ„…/·÷§Ý ãEÒ ‡—yÍã þ7êéd§×FàH]9§ºÁ¡ìÁé”’áAµ¬ïšè’ñ¿¦¬U¦¾â)vHiÇù­)wðòéS†Cp¾|_.ª™ÔûÝÞÁ3§¦)ÖÆìmI9ÇíÍ|×ê+¤7.ª¨¸Y³å:Ræö:IÎ1ì8]Wh³>LqUPhê¯K§W ÂÐùBÞq(+ôž+¦î^-ÑÓÓ‹uCrçë^Ñx,®tíà…Ck–앸¥¸ë ÛìkzöÉ$5Ffq»p}¾ Û=9k1ŒŸºcbŸ._«<Ú†0|ø©Ï úv²²¯4ìÔ8Ûëʈ뛬QÅ¥ç^Ú¹sl6Àó̼ÙOÒ¡ŽIÅuXôÍ]'šX[±Ö«éöÅU>–œ®vk\Êfä\’•ˆë#“ÛŸÞ¹FZé ª2Î6=ÊÜ2ô»È]µ¢5*ïšv mî¤8œx+¯¦¾×TÝ,±2Œ MÆs¶W2u=”RÖ<Ê9W §ªºIG¹G¿)†%”ýgpÎqØŠí¾ñvÙÓ±LËÑ ˜þ,c·e®.=Wp{$¤·+ŠîV=?«î×ÍJùVÜuE¢UÛž+ç݆>§»Õõ œ#s´äþco•Ó4WJ»u2Z3ùö_QuÆ“é_IZøzèNµÃ´"á\/#t›”•€”µw+^ý) ÕÒþ"ý§áŽÁ/Etm+`·–ùnîù;=ãÿžûœœl¥ús j&­þ3tºWXì=†>‹!°ÕÂc³'9»)+#·?jáÉXÍ [™ÒB\ØT‡ ù=©œ‡HÂu¤‚…9øaL ‘ƒ"£æ„?ržGBàu÷õ,(¨óÞ£¦ŒvO`Œ;9M“Ü QÇ'Å:§iÂhÀÂc‘!À†ÁqgÅHE䤥”·…'³Z­‚ Éû³’>ÓGÊ¥éݸgwíœ}é*c ò8Ç9ü¸ùMæ—ŒOtݨY~ÃjmN¥L‰ ’ÑWi<?½+oÏ‘¯pÛ”‰¨cGb?ºüpüAXnºs¬úÙxmæe¢â÷ È%%G÷ûwáÕÆ«-<ЋGö_*|{¡ž©«3ÿS²>•/WU§B¡$öî’…×?  º¿â¨v{\›5êÛ ÛW¯r¹úE´‡ô6µ )j< g&µ7ŠÞ,ÐtͽÕ8:oéfw'ç–éðŸÁ›ŸQÜ¢siùsÈ cà‘¿ä¿Q ßý&øl°=aéÖžj™Ô—9ÃêI–¯£§’x{WÈßWÕʲ|}éÜl™èNͪÛ>ß5ùsbÁ’Óhô›ùu“$ç%C„>¬«ƒÏšw3{œüŒ ýþ>V/kÃ@È=ý”r–ÂÐAìp : Œ'lá/.¨·¸)$‘â›î@wLów©yØGúœ aK·€µ2Tv¨¯ŽßŠÍí %#a JBÕÀ?ëQo=–lo«u‹®'j‚ŽNpq^±§;'fû)6•bÁ*PföåɘêJ‚W°á߃´Tœ$œdŽ@çµ+„8š‡0xß°ÜsœŽÀ¦WCǺ]´¶›v¹úWTªê¦#å¤B\wKXÿ¹¸’¶Ìî¥ê£§‰š£“W«ÒAÆ9<Œg)5ÆpðÉâÓžáÀõQ+uÊÿ¦æC»Û_ŸmœÚƒŒHh”)$v)5Œº),n-pܱ ©™[ í1HM÷½E>ó5r䩯™XÊÔ„„ï>ä'Ía;FI§´‘FÝ &Få­jBúÐÜœg|Rþ@öOLM•§ç¬5m•­­[í?ljEÊ,y³ÓMa#¤W‚V¬ œp*q“Ö×S6Ò*ç5®phÆ­9ÆIÛÒ7>Ê·SEEK/Þ› ó$!¤´~3Žß%CtÖ•¼ë+Ü-=§ JºÞä†akt¥%Gh'éJíL­–ªÊÙ…5N’C’ÐKŽ'o°©k¥Î õ. Œw; ö âÞ&ZœùT3éHmÂ¥§ IìAµUêÚ ÔïÑB×Ô´Gº™Ú‚]J–”8ɧV2Æ»SÂÔ=Or~töRbûy »Žjzª¹“KxZæmYÔše>Ëoc!$ðyÎj£Y\[! )û]1“ip‡P¤a*OŠ•ä¿RÚ68„x&‘èZÒAÏzXÔ; ðÚw?€º¤½¿õAùp­R#G‰¡!ïQ{K‰Ýú÷V3ö«O‡ÝSÔ5‚—`ÔrpHÏ Øäÿnê.÷Ô´¶Hijƒ©çHÀÈ•ôÂâæ«ÔVhqºw¥›é_It¼BÒ•>RQë;·êÚTw8µÿzíþ°§¾ÞmÞOS ešÞÍ?Íx~=Xþ§—{Éås -ô5$Ýçûå}[³èi8³š\­­¬+ÕºVx²<»†©mö”ÄͩżžK‹Èý >äšåjþ‡ŠçguM$†Já¦64»P9/v¤4cä’·çMÞº½Ÿyn˜9{ˆ{ wÿ%tü>Ü:ÍlÐk¹«JEzÈóÍ4ÅÆjSݬ2ÄrxçŠÝ^_:ÞÑÓƺ’Š7ÓLð$˜ÎcÜ0 êÓιákOizf{·*• ’ÆçúöÕž>êñºt¿]õÆÁ3\ËL‹®º¸É1ã¤mi…ÇiVÆGúñÜÕ›®<êŸl¿õD­&ãPðÖg a‰'8íƒ=øåj꺴ôµ[mLÃ)b<—8ퟪ£,–S§4êç§Ä{mšMÁ›;£VT’3é$rHÿL‘湧¡z'©©ì3V[tÇK4í¥vþ§ÍÞL2y ´ì3ÙBÓtm=(&é%^3ÖÉV$IãhOqŸQ¿ÒC‹¼ñìªW{ Ž›P“^e1´ ¤,)c{KX)Ê}Æ{Õ2 t±ìZA>ûl£á¤sˆÜÑ33©˜ù-ö»‰¿õ(«Šzi‹wp8R†Æì둹–tßTë-?uiÄ]]µJÂÕêš°týk ¬oÝXãÎø "õb£ª‹»ýOiË–ŸŸ|qwIM=|’œøæ·§CÛ-μ빼$ývÊÕw+uTP$z».{êUñÍÕ™ßô Æbìn-·˜AYQh([$ûþÄU#Äz[]·¨ªÓO-ƒ9fù# zI|a]úbÑ%u¤ÍoÐþŠ÷™Ö±oú2Ó%øép8Ÿé?qR7k#¥m5Ê´G?¢¬Sø{æH_Nv$g^»{³?q¶\õãýEµ+Óž@ý©­Ž¶YmÓWÃ3DàéqÁpî‡ý.Ø'ls3g÷ŠdÔêµê­0e2H˜‘¹D ì9ñQ½]-ÆÔÊÊaüöþ!ØÍÓÛm,´µ~LŸ‡²Dº^bi†Ø´K‘ê6­Å@à§ßR¶OXû_ý›ˆp=»}ÖÊsWüá±MªêÄ”!¶®Óœô¨©G°¨ÚÞ¡¸TF!©%øïÔýK©ÚSEÖùeÔO ¥.:Ùý9<Š£Í±Èç·8ùOi¬µÍõò£§-VM/jÿ©”Ñ} Þ>~ßšÚý)`û­7ñÇÌš2{ü}OeE»TÔVT}̳í•'=Q¶Þí‹qï–ˆ´$­8÷·èü_7Z#H t{î~ª#þ…ššp’ʈ“«Zšäɲd:"§w!\À­;[+ê'àem8l‰­£}” Ý©^~j^fRÂw~ø¨º *PFß*ÙWfkaÁoe&ºÍq7ÈÉ3\Ö¢sÛ>)ýæ‚1[z³ƒŸ¯e AJÓJã§ul^µ™«; ¡ÿ^VÔ’Gôýª÷ÕÂÞÛx….~ßý*¶ÓRê‚ò0ÕhtG_Ãva ÂT ’Tp÷´¾Íc®êßCZpIì3žê‰âwHÉ-9pÎBî.¢AÓ²t½Búã¿aÚé exí_\üJ±Xgé//!Ñ‘³öÉv3…ËýUYÕ´l;<|/wûöžN“viË¢ÝÞ•c¯‘½Wy³?§KaÕvxÆÿEØ–›Mc®RHŒëÒÍk¨¦"ÛÃŽ8ŽÁÀûÔ¯€}WyŽfÓÒ –ð˜uïMQ¾m‚™jM%ªîï\.óä>êÉ.+¾ßÅož©ð®ý^f¸U8’w>ßE]³u¾™­§„G2F¢·!ØíÉ}¶R2+Ÿ+£¼R1жRÖŽÃ…°©b£™Áå •%ôÉ*|“É$žõ¢Xf–°´ûïð­s@ÂÌ5Bú…Ô¦l¶9j~R#ÅBNr¬f®ÖçÔ´ ÆxR»ï9ëòsþ&JjUã§úíêÝŸËKu¥gÐO•~}«éWÙ£Àó3›v¸Ç†Ž\…ö›ñÓølF‚‚Oæ°;|¯ÎÌÙ²'ÈvT§\~BÔTµ­D•äšú!McC0ù[[-D†iœ\ãÉ=ÒJQ4EEEEEEEEEEEEz ^!!!!"½'(Ez[¶PŠÅ¡¯r„WˆE(²I¡èøB)V‚„W’!ƒ[”/S€yíY …áJI8£N®#nW› @ÉÍe’Ô`”¥àE9ÖÕ‡na;UHINyN`ò—0•ý*VqÍdȇd9›-­°¥¨ð *Ö,@N)’0‘Ÿø§Qǧuá+õÅ®ŸŒíÚâ¨Hm¶ Š)J€OaþÕð¦Ñ©Ì%}¹ó˜# ÏV!ùIL`´àýJ«,ºZ̹Vªžçä¥nmÔ¥*VVéU=¤á) iS(°–Jœ*mgǵBK0ÎÉôQa:Fiè¡J8R}霯köNá…Ää´-NŸTpïíHãe7Ù9´éÞFàF;ŠhèÓÈb;á6IYS„Iÿju }+?»SŒVÚ Rrºm3Ýœ/ 9§û2aª{.ÜŠÕ hÖœöýé(iÝ3¬ÎakåVý}êŪû]ÊM¼éÝ9m‰´p„!•ÖÛ´Ñ2º_2ž0ü44{ð·©‚zl±ÛŽI_“ÏŠÞ¡Ž¯u£[ëËu¾D{+¯†˜Qh¤zh $ûkêï…]žtq»&¯ê*®ú€¨ÈqLIBÜéW¢Žw‘œoV{qŠù­ãÚ‚¾èù-ÖgyTÀãP>§¯`~Ó¿¾Ì–ÛS#¸Üó-N8?…§¾¿Êú9$k|vbÄŠÄ8íŒ%¶Ò”° äʪÉfq|®.'Üåv-#cÙImÞ ±Ê’MCÕ`ì—k´…/Žêƒ<jFnœ ðVÄIy(på'¶`bi9 XIÈM²¥8T£ôøûS¨ÀÆÉ«›”®*÷!i'‚;RŒ¤H÷[îo"\v€ õƒ{U÷"½§k¾ÔÆr˜Xx€Ûd„ïO^Ì”»$„ýrŒÄvaºÔèÓƒ¬…¬4=œåµn*r29ïXºÂ\FvÎß n>2>Sš µg û÷QtªÚF2iÁ j7 a=ÄqJoÒ*¼S Ú3”5š]•½Ä%m“õù¤šâJ}I9ZRÙ·©³ž9Å*ìÉWDŸé{;Ú‘ÉCuižÔeÉ@I ¯n2ß›ÇNó«O þžÊ¿vªm i<8á27r›n[éFÐ V B‚‡ïM$ܧ’R±ËÞy?éX:"0$Y«›§Ú#HÈD­G¬U©/v+si“r‰iŽâƒH*Ø€ô”‚–w(ŒÁ휜U˦-q¿UeT2IOï,i dà?†dãíó•F¿]æk›KNZÉpÝD~€ó·²¯µ+¶¶î3ÿé…Ê‹fqÅzm)Å(„äàpOüÕAÒ÷`a¹8íÛ}¿²³[Y!c]7âÂŒªT ß¦][€ aíYº”Šƒ¨&gPÛVóÞFâÆe RA%IRFx4à8¼rjIÖI9ÝÈ¥›²ÁI´f·Ôý?Ôv­W£ïW =¨á8\‹22ö¸ÊŠJNÝ* ƒÁŠš°uuª±— l¦)™.iÁ¡!G]ìt·gRWF$Ü‚27 Á³ÊºkY×+ÍÚy‘9ç ¯ºàúžqG“ÇžsUêi*fsÜì½Ç$žI<þj‡Ö [# +)«CP£†[ožäù©Amlqh#uÏÕ÷O5ùÊeœË­:®v¶{U6ó™&{1nbu).Ÿ¬î<½F±û+}¢—ÝH¢Á%”‚¢*&iýJùA§m,Êv3{Ã*Ý‚zÆ*—7;e^(Üà3Ùw4;ä~9aT{/Ï]Ld)æÐø!cDqùÇÞ¶·‡ÝYSÐwaQS¹\ܶ?ßN Ö’YORÇ#Èfp=¹åJ4ŽêÇXÔÝZÕP/w]”m¡¢ñ%ÂGsÞ¶=-ÕiIYÖ·Xeš‘™ü;îÁ­µ»dá2¾õ‡§L ±•$îì|žÙì šrêþž»Ë¹¢õv±úo¤.# RL„gÊ…j.€êƒe©}Sªä„5Ã1´‘©¹ÜöÃ*Ûy me;`16Lƒê8ØýèkÐézVEyåiµLaÛœ§ö×¥Ï úlÇg  ÛGë$çÍ}+ðׯü6»ô½Âš) 2H<ÇeÀ<ͤ´6 wô‚2^IÕ¶¥ÈÝYÓQÞžF7A kcÕ—=Ù'¶Ù?‡²¶­×gþº/Ó½GªnÕˆ× ðwÿ:t™8Po=,§±â¶ÅgTø· í— äÃ̉‹ú¤’_Poÿóåû| -yQ@Þ°êZÊ:txv6kcÛ?þþ=?ªâm-¦õKÖˆ½N´Ü\¸[í3¸ü» ­ͪI,c* ''<bkçFô‡UCd‡­ìóù°RÎ鼶ä¶EÄ9 8œànîü •Ó—ëͽ•±T3K¦hf£±~F4ûpçO45Êd¯ÿýG7=_¡cÞ̸M!O¼ê¹Q[ƒ8CyRp <NÆð×Ørßzíï«¥lÎ&6±Ò¸“©ã8l`‘†‰Ø†ŒÖ]Ymÿ£l¡°Õ:0ZòC@à%Ûž@ßu"—Ä—Ä:‘a·KÒújqCδúB~Z+-Q×á' ì8¨7{M7Œ>-ë ‰ÐÐK¡ÏÖ4â8˜Üàv08ÜyQpO/EtvjÞ&ž<€Fù{ÝéhÏ8Ï<ò¿7âsñ¦úçñIª`ôí,µÓ2‘§,^š‰L†Ø;øçúÔ’sìoNªŠÝ=Öz»da”þ˜ãÿõÄÝ ?þöîü×UxÒ•¶ŽœŠ;“³S/ó$Û‡?|~YpÜe8ר$Ÿz¤ÔÈÀq…·\ã”éë=.’âÖ®Ù©œ´q‘¨£Ì R­Iq·°é;÷óù¨jŠGc;$µäázÎ¥¿]T•JRÂŒIj§„a‰2Ðݺ´“²_µM¸¡(ŽË$Õ"ëIüÐÁÝFÔ\Zõ¾u"rJBR… ž1Rvþ–”öwjÕoêÂZ›aKIð)Jžš‰ƒ)rÆ7žU›’`Gfl•©MÅU~ëæ8ÆÎP4¸ã)l^¯¼ÈæZAhð ïHKÑ-q28î°u¾9]…sôã¨ó˜»Ûœ™(5m¥N'·Óžj¡{é˜1ørT=æÊN ç.¨ø§øŽ²u9Íméý¼Û£[`†t VHíïŒVÞñoª,@úo¥òM–÷»9ÔµO†]=·Ï’¹åÆGd|ÎV­ctˆÃm¼¿UjûÖ‡­±BòKv mIE† °¢j›ª¡®% V¥´Â$ÆA´Ã« ÷NêËÛrÐâå¼ÒIÁ%~)ÆÙa ¬+-´ä§û†§}ëŠd"H)IÎEESÚÀn’†×§ R½L›ó T‡ÉZ´,žx¦òÒ=®·MéèÛÌD=N«,'ZaðŸT’£Á¢(dÖKx#(ûkfpÔ3…yèÞ«Cµè[¥¦=¥«Åá€ò€ÃCÉûÖÊé.¯¦¶Øªíf”I,§!džÉkÛçFIUrŽ¡Òic{{¯¸Ê“Ó˼¨¾´y¤ŽÏ9öŸNôГ§æšà#ïù%ªi™ÍŒvãþaqíæù*D’Ñ¿Ow|ÿ½V)hÖêÆësPS€Üá]ùhjÖ¶æ:¢øÆ ñÿšE–ŠIZöÔlã§_©åt™fÁJî½C´9ûjêØÚNxI©j¨­æ»´ýÔOËæy¸ÝG´ì˜7;e×ÔŸµíŠô’*WŠme²R¹’ùŽÃ±éçè¥ëD±½˜ou ¾\î–8+eÔ©ªNÓâ£â¶9‡L€·*ÁA s?På ÓH¸J }ÅÏji]É Rµ±0zŠê Ó‹Þ°¶¸¸-¥Ë†Â¦ÂŽ7[ ïëúš7›ss+wퟧÊÓ½MÖt¶éÀ”á™ÝW¯C¾@¼=h¸2äy(QB®é5F©±WSVÆHÓ‚*ÛM,´Â¢–Õ‹"Ç7N@{Œùõwg^jßsèÉm̸ÀïPܪ„WHëeu+ÆÊåҷΦu2ØÆœm™†Ì•ƒ„ƒ…~kqtGUuŸUÓÇbŽ4€ç?‹ç;ak[õ®ÉdœÖ<¤› wûSÄnK,%;³ž?´úì±v£ƒïu 1 g|ÿ¢‰±ø³I;ü˜NIIô%âÁ¥_}m§Ç5 áòÙÓÒùãb9Î7KuU¶®à4·8*evëw—LÃ,äåD~¯Å^º¯í%ÆO»Ò· ¿ä«–ÿ]Lß6c’¢w9¶¥Äzdµ¶—œàÏÚµýmÞŽ¢'É!Àʟ¢§ŸÍÇÝqwTz£cÓ,Ζü†ÀQPW;Íoš®´if3Áÿéo;5³Ëˆ:cÂüáÿˆ?øŒ3c¶Üô¾•º%Û³©ShBÏ·?a]¿özû6I[8®¸ `ïÇÐ-ãß}?Fa…ÃÍÁÀëòÿ¨uÓSÞ'ÞïÝ™páqÇrI&¾¨[íñRÂØ kv ãµúùQqª}eIËÞrS%=Pè¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¯q¶PŠñ¡¯@Bô ž{Va¾èYlçƒÅ /@X‘ƒŒæ² ¯”8¡dBr0x¯IAY(€1š4o¼+chæ@êV¤NŒR홡`æåkÈÊGzf]“’—cpœFí»GúÒìÜü,¶[JXÉHA4¨Õœ/S’J0žIÇŠrÆ‚v+ÖÁJ)ØË[î²4ŽY¨(¡cpÛíM¤«ÆÎøGÝOºýU»xvó#!¢ÃHNÒ|¬ç9?~kâ1¥l.'’¾ÁŠ‡œ0‚ÑgNŹ°¥¤àŸ½D×Vú±îœC§8 imJcº—NR“šƒ©~v ûZ —6ãRÛÞ…%NgÁïP®k˜wá9‹Ý"~JÛÜÚ‰¶ŠZ8ÁÜ)¸[†ì±jR”ÚTG’døG)v4ðžÜ–ùZ THÀ<ÓÕ§ Ý>¬ü$%·W!%q9¥Ãšº”Ò­–=44•§sÇÿõ÷ä’8Lf« ám•! ¶êY.ã„L.p.á"`'s²€Ü,ñ.‘f»[™¸Åy+má¸/íÍY¨îí|.ÒAä&òZÚñ‡œ‚¾dõ?áC­}oŸwÑwÓ®˜ô­/¡Ö‡DH–RNÓØc=È®Áé_,vvÕDe¨ª#pã†õÿE úÏÂJû©’€9‘Ò¿’Ö~8áFtïøEtí«Œ_ãÝ@ÕW eÄ´†ÙÝÿï`)kŸÛRâc"š™wÎJ¢Rýìq–%‘ç¸Èû.ÑègÁÏC:¨×©t6ŸyÛéh°'Îx¾ëh?«aWÝä¥:÷íÔWúCIW lgrÖŒgëÝnÞŒð2ÁdTQA‰=ÉÉý×WËW¬â–œmñŠÑì0Vù¤`t…´<¼œµ.òxÉ0váK,Á§ZË… V2 ϵDVBFwú†ž²Ñé·œ”Ú™ê8O£9 Í%å†Á sKy%£%%$¸8^ÈRWÃg8ï^ÆÜ,$`­±J÷¤n {RS„`)\¦TS½'‘ŠMÖMá28‚H?U>c²‚[PòÊ=2³€{V.`Î{§Ñ¼Œ/ •'v+Öç rÒÝ–ä:”-$v›£$%4e$Ó°y¼Á¶®S0y䶧8K@žT„Táï .'<’’©¬0Æd$v[õMÍ?xŸkrB$¶ÒÈmÔ %ÔøPÏ‚9¤šà o²wEV&ŒH3Ù8Øf"×o—!›‘D§Òcª:V´’ÙÁÜHàŒ€6ŸíM§’@KHŸŸ‚›ÖÀdxi óò£ò¤n.,,ç÷¬à([Ü¢3˜@PV û×’·|$ÞÌìž¡^np˜› ÆlH²P’ÓO)(r´ƒ…@89Á敆²h¢|Q¼†?€$ÆGî‘’†¹¯sswxØöÙ$qÅcêäýé‹FVXß+@KÎî q’R;½.6^µàѱa[Âœx¥XDr6K®w%[`ÆLvÛy­ÁNîg¶ŒQáÙYANXâ{܇vqù©£û.eëÞ¦uL¦6pŒ»¢Ûõ°R¯S›ÀspµÌTàœ…9kO×Ç'·š¨×Ty¯À9Z픀rn]ɈˆJ•ÿs¸¬ ¤sö[Ým©Ö¿Aº©ºC'¸_¹[¤„;«T6Ù!u¯ÃŸKm:“T7Ôm}ÆzEh”Δá)i×ÈÊÏœ@ð1æºì÷á¥5e\w¾¥am¢'bGw ÷ HöUOº¶zJCjµkåµ¼œN?`Wjjƒi¾§uT>”ë+¦ÒsÒ’Ô·> ÞÔåÀ€p8ãšè»ÇÙN‹«z¢J~”¯l´S€u¸ƒ£Oã Ò2@Øggmð´Õ—ÅŠ»-™³_©D{Žù>’{dòWR\îZ› Z_MtÎLÝ8­9p ‰ó€lv3dã°<šë«ÝÂåáÝ®¤êßÝ*3š2×1¤zݧƒßÝhú:¬®žôÆ¿Ï‹Õ§OôŒ¨]£áë£=U¿Ì~Û©/³m-Ê Ç>Ã4§õ®êáÕwËÓº3ï½ÓTÊÑ»¹øí„ÉssNõCPõ&ë|¸ëav~é2.‰´EJÜeeÇ÷ŠÔ6!°NNHÉ¥®[GY\®µwyj+ªLÒÇCLÀç0^cvÒ«rç80Nà'´m­°ÒQAHÈ ¬cª¤v½-ÆœQv6{.±ë.”»t¿á[Mhh’Ò䲨p. %8\´ån- Àþ“ŒçÂO<óÐßj{EwOxE †Øì–˜apw³rö´ îHÉÆ= î´'†·Úkç]Ít‘¾“­ì=špIÏ¿o’¸cMݵµ‹AÝäZÆ™4D–î HÜ”ç°^xàœñ_/ºkªúÎÏÑU[ÃÙmž_.Gœá„`ã=‰Î09ƒ¶1Ô×»}¦®ñj0ê˜Û©£¾'é·?¢æ‰®¿/á÷ákªúšÉ¨!Zõî Gý3dK )œ´<•—»ÿØ¡$ ¢ŽqÅ_¾ÎGÃd¬4ÓÆÉgpÓŸ<Âsæâœ@Ãõ‘êÆÊÏmé/âÝCIÑ—CóN aÍü;‹<¯YVÉ«ÝZ÷ MÞe–>Èî$c·ÚªõG1s+ i_€R;~ˆy¸è˜øKkùíJÔÞ³<'Žªlgb­K›™1”"ß¹ÕesU¹$|²ikrSZËœmnd)ÂmÀؘ\GR•Nθ¨ÑBe“'`4­l¾®Éšæä_h<OíŠsQA¹"+­t΂¾j؆—søœŸL­ÖP¡–øóP6^‘«¹ÏäP·Ì“sÈ —tê¨Ýüý‡¹T~¥ÔóìÒæ[–])§Ëž•‚¬ éÒ[+pFÄÄ+m¶™•HZSÆ’ÔrŽñs{ÇÕQ‹kñ€œ×ÛÆt…cYÞ‘pm~£â3);»ãuW* ky*ªE§•¢ù¨ãLÂmß¡ïJQQj!IÐÛ@õêÀÐzä[v! Jœ)JçûR°LúW¹Í9A_,úÜ;.·é]Ê×­4µûN;ub¨ÚÑênOµt·ƒÃu¶ÔYæ—ÊÔ·Ô-3ÕðËEUHav_?µ“,º–u7#Ót ¬vUh›QÔ>îÎ’FBèæjvÎጅØ]-èEßTè™Ú™¹¬2ÓLz¸?Ò1Þ¶O@ýž.½Gm¨ºÒ–èˆdäö÷Z‹«¼F§¢¯eÁ%Ç ¼Ó½%Õ±7t[‡”ÎóxXOsZë§ü6º\Ì¿sW•’~ç Õ[Ö´”A†oHv?uƒå§î L‡V‡}Åkéj7£\åŠ*†Íò—j½O"öÜvÇÒØ#Þ¤j®2Ô–ºcÀÀXڬ퀒)ËJj@NÅ $ㆹíß# ;µ¬I¿eÒ: ªšO•;li.!)5wè¯=1žÜ=C·oÍj>­èJ:±¦sŒ¨-ëXO¸ß¦Þgçç]YZŽ8=€ªUû«+®Ü«qæ<äã·Âµ[zv(iMàZ:GS1} E¹©³”«µlšêHkH‚¸‚ÁÙQ:ŠÆê\Éâ+µ´/ZôLl.¸ãq¦KÛü¤67+5ôÂO´Jt¡Ò–6IHØ“•ÌÝSáÞùVrß*¼Ö>§²lqcªwŒöÀ­WâgÛ¿®[ü-Œ1Æ{íþ™W.šðz ¾õ!ÔàZ'LTûE÷$)åãvà~*ƒAਨÒI!s¹ÿ%;QÖÁ®Ð€¢Wæbé’ùãmÇzÕÝCmŠÔ]ǽÿ纰Z¤’·7Êâ.¹üEBÑöyïIž–R„’>¬v¨[ º{ÌÞ@~1Ýlá´öؼÙëó ñ©þ$2%H¸éÝ/tr}ÉAHPmK~9?ñ_F<û6Èê뇤c•È~7}¥i­eÔtCT˜à/‚Ú«Sß5}âeöù1鳞QR”£œsØ}«¿-–È)!S· æ_TumÚ­ÕµŽ.s¿o¢ŒT‚¬¢„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"„"²iÂ^¹ÙB+"„"³`î…è'<Ò„e AÆÀ1^º'a Ķ’‚?¯Þ½ 8Ý _§÷  ¯ÊÌ'jîIÆxvåe…ãIúþ¡Íx2Œ%ž— ¥@W²4Vmh!*ô” p|æ¼dCºÈ°VæØÊ𔀡J‡)ÌŒhfp–!*B°¤…3K å2hÉÙzwnÀ Í*#Ê Π•! îÁ¦ÔâF»ù‡7=§!{µKp„d`óRQÌà©8éÝ+Ø6…cÁ¬¤{$ÝܬG+õ<…­ ÇIÛÅ|?xÛS—Ö—Uç`­iT[XmðJÏ&ª~¹¶R´Ä‡eºãJh¤êíÅ·*E­ì±·OôÖ >ùU6FS¡iJîÓ¼¢µzBžÔÜcÒq\WÐ¥w5„ÍÀKÆpUºý‚ÚƲ]ôæ/O­úeÇÚŸK<,/<ƒø¨š­1¸aÙÎr1ŒÇ=óû&ÔUÒ>Wú} ïî¶Ùm‰iM*C`¨ûøªýu^A )åUÄ¥©éÔBú™PÜx=©Í LË:F}J.܇rU¼­_z•0· ܇l%Iun!I!b‘-&Ç“éYGeמ!îëßJ]Í`¥Ú6 í{f°‰™Ü¯a‰¡ÉðÀcß—#*LB¢êùÀÀ¬ÛÂqÀÂÙnïQNjòP1‚Œ'³¡%(’íï÷¨zײČ'ƒÁ g ;{ÓjVeÊF¶9¹êKÎ8‘Ø㩧Ó0SYJ•Á[2™ÜK£¸Ïz‰©iaKGºÚBîPrŠÃV[„››ƒ„¼È;v”óMD]×›…¤‰ © ¯¬„…¥-|¦u0¤¨’ÑäSÖ¼¦’ÅyÊ28¯B–¤~•© QJ”ì»)ê?ÒÊ]Ýß4ÆOÅ‚’ îœ^}é ¡Ù.ú‹î$äSpv§Œ–¤Ì8 ¬ÞÞÉg7+Cçj3Œ“YÇÊnþ-%)OŸ½xîW­á*BŠNF3X•ŒƒešÞQäe"± 0s!ÀNלûRfR‚1Ü,F]Ú”ä«<ÖdéKG쳸>m”6–öû ò‡“ºq÷HŽPÏsK¾L% çéö™J$7p’Úˆ( (æÊ à-K×ÝT#ˆÓÄw<«–LÖØuÇP•ŽMYîÇ µguΓHér¢—9r{çÚµ­õÍv\êNÝw*:ûhSNÔqôÕj7î¯VºrH=•{6F\q§ZYÀ$v«<ÝM+sÚ(™ .ªøvèkýTÔÛc÷àÖrÂçM•·qÉǹ$ù«'†Ý/T_ µ®Ñm/•øΆ7“õ$†’ zë¬Ùf£2è×!!­oq]ñÕ¨×ðà ÇnµZìÝ2fæꙑ¼©éï„)ÔŽÙÆË]IâÅšóCá= dVÏ5ÅŽ—Ès³ž2qœmÆÁj.‚u½dùÞòúÂÁ–ÿKGpÒ}»ýT£ü:¤.ßcêV²½‰6¹)‡éÛ.ˆ±ZRÔœþ¥’özÙ¿úÒSPÑÝo1=Œ9= fåØÎÄêÆ@öÇu ö´€Í5¶Ÿn¯[øœ§>ÍåZ´†š×š[k˦¶zéÔwd¼¿JSàµg·¶´•Êu9ÊA#>IjvÅá•¿¨lu]I[[ç\¤%Ç\ƒL1NÐ}Minä÷8 ª}WRÖÚ.ÔÖ¨iC(ÃFíÉ! iþ¢í’JëÔ[õ‡G:+WXoñ.׶¡4ûnˈ=‘·(“‚‘ÏÛ5Õ7ùîÐ3UÛedõµ¤9ì!¤5¾–â@ nW?ÉWnê.©qD\A vù}ø÷ÉýÏxÚF¹ê Ñ:Æì¶:¨ãBû˜ä5vqmúÊ.9¸ƒÈqŠù»Ó¾Ôßúž²ÙÔrè½³þá‘9¯ œ¹ºÎ§µÃH'Ó¤oôuµGW2Õg†åm4ùNs]¼`HÁÉà“û«wªÚ_YkN—XõÛ iý b³2˜ìÄ·ÇÎó´ÚØ£’¢FõŒžæ¶w}'ÔýKÒT½KFö[á¡lL¨¸ ,sIþo¾$­uáýòÛl¾Ëky}L“œ—<—m¹Ë²09;d¾ýÕ]SoégH— =«á"m©™3ЧVا ÁRP°¨Î|Rýyãe΃£¬U®ø“|ÈçßÌsÇHFwsAÆ\6q$çp™Ùú‚kõÀF1LòÉaÀÓ’@Ø‘«cƒÆ_[êFíÚwEtƒCÜí²˜Ž‘"âñG šêqÅ…vRG¶1ZGÇ´ž†’×áçLO‚0 îÓ³¦p:œüãñ…aé[š²§¨îŒps½,á>1Øþëómþ"A±j~ª»£­WArÓºe¥AiÄRä’rê†;òœýQ<5é“k‰ð@ým.8>ãßèNH]¥áä2Go³L’nG°ìÌG®?:U"A þkuGK£Ôõz•ÃNJ[ ‡@.HIÚ8¤*do H F0rwQ>ã ¶¡ÈgÚŽÞó*>j3J¸™H•µ+qô“žjÍ NY“² !ºŠ¶ô®›L¦÷¬É©—{¦—iÂJjì8Vý†¸N´³'pFqÂS«e©c550–yšÝ}”ç©[¶€—¥@e†Ýh8Û™Ïí-¢XöªåÃ#èšZ.PÔµä»$m…WŸp¹ÍlÄ‘üò{g½/SOLõ”Ð hÇô®ÍО˧tÃñ5z[“%iþY%&ªtòC湲Ǫ26Ç ªUÊ9 û–sÕgrná:[ª´³ Âp’Ÿý£ïLZêv¸µ¼v•=G#Àþodߧ'^¬÷‘3Ô“»”î¥ëÈ1eƒ~JRHb™º°ŸµUÙ*º2¢ÑrR°TOš‡·Âé\âœÛG§Odüì K¶77)hx¨†NÁ)8aËôå\ý#êíÏ¥îrà”ȘûE *9Ú|Ú¬=1Õ56Š×ÔÑ´jstïÛä*çTô´w'55Q÷÷åê[Ë÷7^/ÍêtùR‰É5Ú· RK¹$’~O*åk”ð¶ÆBèNŸYíКˆ›Ê†ÜPž3Tjûš ×5A]«äü­Êêþ¢tëGÚt|+¦›Ôã[ÖxÎ+rõ…–ªj(ꩤ.{†H>øíðµu“©ë%ªt#Ò àˆÌ¹_×Ã… ~õªª´E¡ÊÞ­”6MWäÝz¶[a>ÌG.é÷ªÝe4°†É0Àw ¥ ò%#<% @¼h؉’·%@ZÆxܜѮ®‰–õ„£êéêÞcpUÔ–]Ÿ5R–ëŽ:µnRšôÔ»—nUŠ9e|Zº«ìÚez>Ûv~%¾BNm8*GùsàTÕ»ÄkÍ ¶ÚY‹"aÀlH=²¨u'CQW÷¹™—4ä|.¶ø\»ÚìÞ¬KÌÖZeЭêZ€%'¿zÞeËå5¯¦¸Ì"ù“½¿5§¼b·O;êfä·Ù]º«á÷¥Úªø”iûœw%²òþ¼z_Šèžªû0t}ÖìÚKS\eiyßðž~9ZúÅâÝö†”ýò2NÜ®ê—O?øay0ÞA~3¥^’Ï‘šàï|.«é{‡ÜêNAΓîéΈë?ã·ñUqj´¦ã!*FæÚ'µj·“O*ãQ^ZÒ\¾ ü3è®&Üä}Mò9Sy[Ž1ǹ¯¥?c‹é ˆ¤mü·.—coÌ®)ñ«¨ï>puv< ª—©½6ÑסÜ"ii‰rÒpAA >+CøÃáWMÍÖRØ'ÕN{‚6>Ál‡ëK”VvI^ÜIò£š9§!©ØÊw8ÉÍP¯^>Ñ œsÿ=”õZŠÉ4½E~MçÛi2°”žõ©/ïsXŸ i%œ©½–#v ÔÖð”g¿Þ¬–Z1FÑ3N«Üç3æ3Ê›NꙶEq¨î¡$£DóûVÔoŠ•a¦Wq¹ÿEW§è14Ï ç÷_º÷NÛp¹]JNTr¿ÓTšk}Þp3¯Yï¹ÊÜ–Øíö¨s.Ø_•Ÿñøí¸ê7çè­rQ}̡ע}$yÇÜ×Ó³ßÙý´@V×ÇÀØ.ûIý Ùn·[ëvÙö_¤I“5×$Êu×ßY*RÖI$ýë·ÚƵ¡Œ|ᚢIžd”’ãܬÁÝÂM*2vX5®î’H@I SWdª-'!&¡4EEEEEEEEEEEEEEEEEEEE(á²^iÛ(E`„RŒiEfJÛ‘^7=з§zXÉŸªIRU»ƒŸ”Ž$!xœ“µ\ÊgbŒ%^†Ò P>k)˜6ÂÍYS‰!€sM‡)TäÛ(Ê”F ä}©ÓXÇdì”2Ž@ýHÍdÐsŒ%ê¸JB‚HÎïµ9 Ö,&C¤­›àà½(èÏ+3NÖî;-ˆBÊ’~Ô¬-ß)H¥.JVÖÜc¿sHÕ´±ŽW8Wˆohã½yyn WÎoáî–'hH)O׌fœ¶œ…êýhÙ-S+ËOJ‡ùµ|%»UéiÝ}d·ÀíYOêJZ Zð”ãéj„ì­Œì£÷[²6ú-qÿ5%GGýE=`Ò0›íÁÄŸYy;Ž;Òõ[ì¸; Úâ]WÕö¨üút©€55.Šë*——J[iN )J<%%@~ÔCN^àÒàîx )Z[#°?Ùu&¢‰3Wë‡íVév †2íøm‰l¥MƒŒäry¨«ÕóWË z^ì 6kƒv¹ÆÄ ŒîT5-TTvæ—5nus“Yˆ´ºa•'æ% ò8ïT¸)]!$„î’"ü;²¯'¸dIq喝{f¬tÌÐТ–%Vùʲʃuµ¸ƒ1WóJÒ…`Ò AýéÕ=Kã“Päq°?ÝFÖÄÙ[ ä$1žvL¥,‚¥©D’zo6Õƒe ±¦š-»ØTd9$å<§hÎJ@øõJ”O4¼GOØAvÁ6+Â04õ¤žTŠB·ƒy$ä{S†3<,™Îët9aÌ€ϵ%QÎpÎÊ]k{ Q8Çâ¡j›²AãO+eñ{€Èå¼rSÖ娎6ú‹PÍMµÀìq ;„óc—µàNß"˜WÅ–ì²IR âÜ 8µE;`½`_!IGéñY e.‘€Ÿ­ì=!‰>‹ J}E,Ðœã'íȦ¯kŽã²IÃI¦éXBT‘Žø¬¡)μ„ÔNT‘íOú7IdòifÝIýø²JÒrâ›ÍÎRNiN¤ Ç$n ÿzgýIÅ/ÊÓ)Dò@짩0µ¼B–|Ölá6J}FNÀÛdsÏšL0÷+À00LzedœÖß 7òO#¶€”ÂÒú¼šËa*Ö÷N,©, º¾ }©»ÆNQ7 Èx žT{Ó¿ÀÜ Ê2UŸ¦ôš¤­ s i 4Ò–žJ§Þ+]õWV²›-g%[j–‰JRž*f½Œƒùqì0´ uÅÕÉÉQgq·ÂÝ$à皨Í!iXˆuì5Ýã«Øà žÕ ],NJéð0?ñ]½àÿÙîëSh¬m–q÷÷H!˜;é>=±õ\õâˆ4qVÅ=|öãÔ3¹ú†üªJí º£{ÕºQÔ}Fû=.ƒzJ®«ŽâOó8Ø;«Çª­–~£ª¬gHõDîúYñ!inÄädgw°6ÀÝm¥³ÓÒ:÷hˆÙ#ôdéùöÝw^ Õ>Óý¥ý2³Ý"6'²ÂdpËl¤e@¬÷qD+³¼@êû =î“é84ÈÖd´†€N\KÎÅÄ Ç>ëšlÖ+½_R‹ÝêF»ÐNœú‰<`{&é·Ã´M"K©5°gQØßµµxº[¡H"Ë©u†e¸3ê!XY-Œ9Ïkð§ìÚþ–†º{­ŸM#¯ŒlÐ舑s½EÀàú@¸ ¨.¶ñ‰÷AEGOåJטØ÷^Ò׺6œi#`º¨º¥ñQÖEÅ—l¶iý<©Aöaû›–PZYPÊ›I)ìqÏWx¿öâëI]rQÇOx!Žip”5ÙhsŽ o8Æ£·-ÐþtÕ!ÖÉ,Úp]œê$ùö\ý«5L†zÕhë7Wç3x‘t‚™©·ÙßYÔ–‚Xeå(À* *ç5Lën¿hëˆ:Ó¬œÙŸÕº<8ñ—¦[ÓǨz¶èe¯¦kÍ5,…ŬqcÃ1‡8“éqü-ßmŠÒÝkÐWÆÜ™k³SbšR<ù›€KAÝ¥Üî<*Z<ëïR½N…a„ÒÐÓï'ô©\œwQ'$Ÿjä ®±¼õ­DBùTèé ¢GîÜŽ\s’Ià-¥-%Ž}Ê é^r@øØ~Xà._øÂëV“øbé.«Ô:JâõÇUMÛfÓËy±™’_•ƒÈCiý9îH«Fxia9ž¥ÓD`s›€þ ’fÂÜîI'€§úR–¾ïQ kXÑ—<øGô·ä“¹_•Ëæ­Ôº‚ç.lמ”·–¥¸¥žV¢rIû×QPY©i¢lqŒ`atÕ< îË8œÛÉ[aAdóXVÈÁKI-ÁWv—‚ä¼±p -yöªÚ 3Õ*&­¡›öQG:~{ácùYÊqäTÕ¶cQÇ+&2‘ZÜ‹=ô/ÓÏ‘KU1Ñ·§†9]9¢4›sÚ%>£AÞG¸ïZÖáZ÷I¥»¨K¥p‰¡ zíi³ÜäºÜT²ëgèQò¡N ¤|̲ÍÁÒDr ݵ>³ê ÀýÒC²"6 hÜxJ}ªvªhãÈâçtÞ†ÅMÔ YÙ­2c¾Ds±àqÇz‡­¬a®’04ú—Fé+$v¡½pÔä­„Œ¥*<“TJɼÇ(à]Qå?ùC%K¯š¾ÇJ<‹TÄÃô¤2?Þ‚‹\žJŠŠ–I&N2Úfjâ©•!—vç&®uÐÓ˜tƒº¼3Ih<.©Ò63|1dÞÞ)—Ù)É­kS!ˆ9ºˆBWUTBÌC¸VV²°EnȨñaH)Ê\—·4/-(®C­#?Où­ãöƒñ?¦¯t4PZ` š<—¸ sÙR<+ékT³V<˜Ï+ŒãZÝa -ä- Ïjä©jÚI [éîàdÿŠÜî.+.‘À*6I=ÊŒmKµè<-—®Cn¡×›mäñLëçqÓ×SÅÆW@i¡\4òŒ†¥:ãÁ?Ôy?½\¼?ñ²Í9š7­}Ô=# ct9»(GQuuë¨÷˜r.Ee¡±´§²Gþi爞'×u @žµÙÒ0Ð8 {¤:fšÓNæÇÉIš´K·¡§aHO“ZÒkuHÃÜÓƒÝHè¤ôŸZ¼Ýa‚ˆó䳸`„+½&úêšWÇO±Qò[)ä9{“é]K.%ŧäÉu|òTsS%Õ5tõ‚g<¨+ý–9 -`]u­¶tBÔÇ{r1ßí];_â}%U8eSò´×ý3ÐSÔLh­¯Øg.Ø/’·Î}éR]uù QRÖ³’£ù®©Œ1 `À Š«žùže•Ù'¹M©Nx?šÏÙ1dIRYp';{{Ðу€–sKFpš$¨GšR5 [ ;$t¢EEEEEEEEEEEEEEEEEEEEd2vB+ÝEf„, É Å$¤{Òm;¡dŸLŸ« b–q±ÚNqȬq”/R•dÕŽ…·a •{Ö7dÖ¥iejVR=4‘ýëÍ%.Ög„²Ýévð¤XíC*3&Zƒ„a#¸©XaYŠM`J†Õ3ÜR²ÀVz‡u=°Ê8ÞV3Ú«—tŽíÊy¹­+qÔ÷#€)+0V&Óÿ/`£ë<í9'ϽH„ÓÛ (ŸÉêãí^O»vM<²ª9YìµDH@I¾27+ÒAÎO?zÊ0 J[9 Qñ^: xNÜö[ÞqÅ´'p>ÝëÆ°Ž„ا°¬Štœ@í%ks”÷¯AR±<ÂËnc9óšÊVä,åáHØx,Ù8ìj*XÎVtÀí•ë+ Y$œÁí$)ïòðW-!bfI>ÄxÅ dv¬vQï‘Úñ“dÖ @ ÇšZNØKè>ë2áJTÑã5à`;¯Ç)ùÜN[Œî±ûÀ;/#Ú¼)ÛxC΀¤¤nPíC#Y;©Ÿ´="Ck-¸¤ç&šÕOý#•Nê;üp4°×@Âi!¡´¨69ç“WJ*W²NÍ;®o¾\ÝQ!ÉÉM.mï)úˆÎ5MºÜæmºŽ¦¢q¨.¥»¥ÑBÀ?êj&ù§Q óÓöÍGS¸Mð’§ 35²æìáG=Í#RtÊc+c[é€8ÂV•6ûŒ…¹„• Ÿni%¼+åÒßJú™ð×oé‡Lí½:Ôj6­}u˜Äñº=¹¦ÉPÉ'n1ä+­|ŠÁfšßr–®?¿Nü‘ >\MaÈÕòìpß Ÿœâv${atuÏUëM>R4œGž²J’§ÖÔ|¦;‹*Á#ØyûÖÜ»uÏRô¥lOhŒ¾Žw9Þ£ÕÈööÉÕ:ß`¶] mš½Ø•ƒ?ˆJuôJ±è+/VuÎ {Þ¡šƒeiJ.0ØÉ.¸|$ãÞµ]2ú+DQsxmUÄëd᜗8üÿŸÕlo ªbšé%†‘„ÅLÜ:CŒþò?EÔ· öŠÒ½4¹Yìš"Ùl̽ñXW«=ð0Ü{r{ù¨>®ûOÖ_ºz—§þîÚX©}^€˜öŒ4cœ’Iï¾UšÍöy§£¹O{ŠGÏ$Þœ8ìÁÉÂí¯„¹=S뀾FÕW1£zZŒùm²”J½­8R™.damܯÀñÕŸej¾¤êŽ™{o~\H˵1$Ľ¯v­˜8s°ïÂ6Î9«Çøì==wöøß=ÙÍA$² vÆ7'úGæSŸÄdVõ6¹ë +ÜÇLíÚûƒÓ\•¬4“õ”Ÿ·š×_k» —û ïÔ dvŠ7†ÄHÒ^N–“FKsÇîGt×ÁªƒCpŽÝ^÷Ùš\ð7 pFÀþë›lÝêoÄ ·UÜl¿Á Ù¡CÎé'Ò HJ}ù’œ(ç ŒœœVèúŸÄ eMê‹DpFжà8±¸ÐÂ2rÖG†ä‚NNå¹ø±cé à‚}N’GpÝñ¨“©ßì9?Ý@¢Yº/m·iÙPï7i³[µ¶åÀJ^s5\z-Œ ¨O¹­AÔvßþëM%Cä“Ș;?ù‰Ç–`ß<¾KŸSO,¬–&µŽy Ò?ýŸøîO°á_×û¿O˜´ôý½)¬?Šé8Çn:‰ô!m·BÕÿmE|oÚ‚öçÍm>±ƒ§b§³QXëQAO’¥íÔe“­õmæ8eg:A8ÁÊÔVŠ+±¨¬uÆŸËï ˆ s@üCéÏ'ò_˜ïŒž¼Úþ"zÏ=vWV‚´ïiA<:¯­ì>¢ìY,6ï¹DêˆÙ£^᧖´~Ÿœn~Jën±Im¢l2œ¼îì{®A¸Ù-¶µ%°ÞòyΡ€»Ë`üÔv£i­Ám”©ôŸÕžÆ« ’7™]³›ÙKMHgŒ’vVEÆås¿GmÙò}4%?BqÀ¦× ý\ÄŸHà ‚‰£¶E °Á’’éÛ Ð·¥¡AJƒÞ «*õŒ)Ú­´++Mh‹Ö­¸8àa=ªRÅÓu—<ŠVçªý}Þž…™'”‹\ؤéçÔÓì ÉȪ:åcžŠsã=±W2¤jbi°Ý˜žÉŒé*ûÛñQs³Ëô»…+WBXíAXv LynPv´{Qi¢eTÞY*áZè[©ar·ˆ‹~ÕÆ×äHb§45¦fjZ 6Ø–‚PƒPš4¼5ÉZ§;Ë8WôI×ì‹ŒáC’JpŸ·ï]3j¼ÑKl0—f\mÿ0µ-D36«XÙª§™jy‡ÜõPSÏó\÷y·ËŽtüü­KZ×´ah·GyR0”½³UšRòàVUR´3%LRÛ‘J‘ƒ“RU诹ÂM‚ˆê¾©[ô¬U)éÜïÞ­vª‡½­ŒŽÊ>™ó‘ûñ‹ã'ãÊÍ¢áÜÊ®ÉSëÜi ʉ®ÄðÀÊ›½PšP}òV¼ñĪ.ž¤v¢5v_šž±üJkn¯\æ.ás‘ÖêÉ žGßø¯§=á¾Ñ C5ŽJù›âŒ—KÌ®k]¦,ñî8ÌmhBNJ·óß½má–<¤¤nûòS#ÌœýH b›¼`îšIhu Bþš\÷¢mXV摱GIç š’·×‘M-0cN¼zˆËÛƒŸAÎÙàìr6M&¤/š9‹Ü4vcŸqÿUOÝÛ-,:ò—õi탿% %ßtÒÛ¨@ù§nRÁí짺iÔ—S…j®Ý@ÂpÁ•/”Þ×sß$T$.ÈVJJ‚æah}±Ç…}©VŸd›šÌœ¤n„ä+o#Í*ÒxXIdón-´ìì2‘ ÒQ¶Ù´âöR æ°krÁ‘”ÖûÊ^sûS¨Ù²pÜöKÚ˜¯—ô‚SŒwÇ4ƒ Ô“$î­D«8ç½.Æì” Û+4í«ÎkÂOi]²Õ…´RvŽõ–AN&“Ó²DHZO|TtîÁYQÊ]ÊQé,¸~Ôˆp•÷*ËéÞ‡Ô}B¿1¤tÌ4Ü/o¶êÙc8S›V Ÿ¾N>ÔöËÓµ—JŸºÛØ_)†ŽN‘“ÜáUï×êzyõ.ÒÁßê¢ð­ïÀ½¹l ë:Pã.dpRq‚;cŠ‰|à48…3,Ú£ŒìFÅ5ÞÐÛZd%)ÝÂA$'íϵ)JílÔVP¸ÈÆ—œ”Ôµ`}ɧ Ote–P†Õ’¥:OŒ~Aà”ý`±I¸ÈBÔ£>{ kSSCyU+ÿP6 ¸X±Ë·Km´ž;Ó (å óp´ï©ÏÜ䕳dƒ¹·¬mïY ‰±‚å_lá0IRTR¶óšä« #œvUÅø;%å8”îHïV[{šÆám k!It.ž¿jIŒYl0¦\î«kL4’¢³Üàµ-÷ k*[OLÂùÀhÉ*Ñ9†š34ä5¡tÏU>®²è‹žª¹ÇEÂì×®"m™Oz²x‘á¥Ó¦b¥uÇõ ÖܔϠºæžó4ñÒ7ÓÆ~WTô‹¥Ú;NhKP5öšþ+gôwBš];¢»Œ¤ç&¶_‡h¡°M~êJbøˆô<;®í·ôT®°ê:Ú››-–ÉtËŸSqÈﺼtïÄúÍ¡¬:*ÆΟ»I•üˤÅ4P )J8'qàcϹ-¾;?®ºv‹Ã[4bži+΀K›§!çŽ?Ú‡tðµ½=u—«®2#cvcyùÏm”ý+¬4•ùÍ+Ôm*u4&f¤<·ÚC²’…leD(#=øšÓvÊ{íšõ'Oõuª!dƒs¥Ò€Ðk 8`#~ûl­Œ¼[n4­¸Z'òœZp!¹;á¶3ôLÝIé·Mú…¡õ4Ý;j½/^Å Îx R!Äi_ö㺄€++úOÔžÅ^¼A鎛»týMÂÊÉ d:d–C‘Xý›†žXâÃNHØ‚0·Iu…æ×t…•R7îÏËYF·8ràsVxõpw[}´é…Ý1dÕÝiºjmKk¼ÄrF›Óm’õ%'æŸ`«kiYàdçVahðÇøW†VÈï}s4’ÇTÒêZM$í€L’F]¡š²Ï‘…3ÄZû]VÉoé¦2) plÓž6þ†< ’ÞN>›*Öݨ5—]µxƒ&mÞâé–…Z¬--^ƒjQ8$~”„ßÍs-/PuOŠ×WÛÄÏ:MPÓdˆÛœïÙ­kÜÿUx®³ÛzNÝçµ¾“æJq¨ã·¹ÉýmõZÙ3¤&Ò½·Í‡k»^žÔ|-夬´6þ„àòR9îk¸¼už^‡èkw‡¶éÃ%ª?Ï{IÕÈ2iÆ6~à“ËÉ\¿Ð±uPÔu,Í/d84H؆»~H÷ìx\}®º ¥mÚ_BÜäkØvÛ­öj¾^ Q×)æa%E+t¶ØÉRxQ$§Â@'qOõ—Ù~Éc°Ð\ëî‚*Šçå‘è|…n ‹ckœç\N?Ù# ºkÆùn54̤/d ÝĆò2sŽ0w žäãùIñÿÖY&Ó7‡m­Ñ¨`Ü\®Sa²ät¸ÁN¹}iZ†F!?šcá×N¾)¦¡‚°TÛ |zZæ¶YÀ”µãP-x[«£ámȲ÷[MåO‚ÐC‹}À-Ø¢øÁgq¸r›œV´¬®óItªº(ÆwGPïÖoà)ƒ”¢âŒn)©k C@ÁÔO*†9_Q«úU¦'NGͳ5cº;ËÑÊ´½¡£eÕÚu:[KZܺ¸Êž“³) kˆ*|ê‚Ú\; ÀÔH|¨N1©uÍòý=Ô4§XŒI m<`}êßMÊuOmc<Á’“Yl²æIgÕmDýé}s¦` +ÞF—f¥pñ`Ö½eؾo„š|J}’ýeà—šY@ÝïⲺT €£%-r¨ì!Ê{ªdKjAkÕZ²95<’ו C ÎBÙnrâ\q»'+4UÕùƒKŠsšð×MôëRŵ8܉QZXHb¡í·ÓΛòBÿj|­Ó”£ª=@ª=1n^Œ‚ÛjØ}EÕpÏÌê¢oÒý7->ò.t³Z®7K²žSJJ7ñýê›q¸ÄØóÜ­šØ"Ž=Õá|„–- 4—Wë€ ÛïT˜*5<Ê¿A¥Ò’8Mú~ã%¦ËIQ'°¤kan¬§uÐ3c…oè­yxÓSr”¡L«¹"§ºc­*m/¥*©yéx«™êÛ GPµ ½X·dzhFPôŽM4êž³–ëYçM…ïMÙ™DÝuZÚa>²T…Ÿ¶*µ[8úUÁÅÒÕ‘§ç\^#þâ›[ª$†pè¬\éc ù‰mÁsœ^œ•㌠òçUQçM³Š(›Y¢4…¥©JÜ2;b¡îå:{p0¦öƒqV—scžÕ?Ó÷¹Iæ¸ä*ÅÚŒÈ0Ф+œ[‰;>ÇÞŸßú¦*çà7 †ŠHFé;smÖÈÊyå¡w'=©½®ÊVJyf~ œú×ñ¥t5©å¿qŒÛá$à,µ­='Wps#‰™qö'”´ñQƒ4Çuùöø¯ÿ؈MÆѧgªtò Z_c÷>v·„?f [=[pß´Šÿhš k])Õ'ëáfºê¥ê5òMóQMzkë'j ‰KcØ ú`éê;d"š€¾qõgSV^ê M[ÉÏÙ@ÛkAM«&¬mksº¥ý×=ˆ[Ýl6ÚIRŽqŠwçध¢ÀÕ”‘èîzy(ÝŒÖzInS)#Û„ÚäR”R=`æ;”È7á5)…-D% ~)HÎv ´”úŽÁhz*ÂIÇ4¡i M! Êj('‚ d̨)•¬ƒÏµ(›4wXqÚ…‹±—”,QBBBBBBBBBBBYvB+Ì!â^´dá ÒïJùXå Êݯ ðP½Á¯@¡z’ÁŠP¶’„« ú¾ô1ÈY`ŽHâ”3c²Ô¸ 6„ŠÀT;JhJZl€I'ý+ÒS¸ %X8HÿzvÆãbžFÜ7e½ÌÁ$¤zTò±%(.-e 8ÅdùyKµ.i.­$`„µrnÐ2.jî1J[ˆHemI µv<Ô›¶Yez½„á ŒÔ}T-q$ò±ÊÉE b°¥ƒPÉì¼Èå-Bò6¨œñŠI®ÉÁI²BNX¥ì))JNÐ{╆BÓ–’zNµã¨%Hãï^ËT\ïR¨n¿YQÙ ¡#by¯…òI…ö]§ ±û›Ê €óƒâ2”5š»¬µ¥ ¸aÆÙìM&Ú}‹“–ÈR¦á³/¯”’¡ÜÕ é$šSªc¨j=’{J-Ó%Ìz9$ù4­k‹ rT”=¸hÝ;\.¡J6„àÓ*j3ß”¼–70&ät”ŽßŠ“4¸nRä©*qa°”n@î1QR`×’M–áYP‰ ¨)E‰1‰úÚI   8ãßÕ +}ÿ5ù<Ö– ’ýY|ÿ¨¦¢Y!GjQÆ8ûRºW8¾]ÉYA†=!Aä%)Ym ÎÞüÓèÉ#%9kr¼ kw+,äáIAÎ¥£Ö+${{Rº0œ¸åytmja%¤•cœW”djÝ:x™=’yö¨Ë³1!ÂÞZJ½"ƒ–•þR{sÞ¤c~‰i|((*‹ÜYÜ*­×žŽêryíV&F2”˜=¿„«G,ºáQ㊭ÞÛ…#l•Î*ÉPÞãi<~õW‹nUÂ…ÚY•ÞKè‡Ãœßƒ¹]J‰Ô;Ó?ŸK’­/òÒS›BHÂT¼¨ò’03]ԽѰô 7PZëüËs,DŒ‡8æ`¤aÁàps‚p4ÕXõêãm¨§pp8xä6$ç|ñŒ.ùu; ×J‘µ*ÛÉÇúW:ix[¦Å…ä7TÒw#iÇzòf±^:VÅîyXJ7â°g¥&Æ”‰Ågr9ÁÍ8hÊu^!Äßoâ²s0™Îpr–§÷$ûSc±Ý{ û¬P‡‹¶ÐT¿õ›ˆÆJ{—^q9BþkÖ0EÙN–ù<¡+9ädûSiãî’ivWxhþ–hþ³Ù´ŸIz5Óé÷~ª¥Fé¨õ\ëºZo„0 B Km´Éܵ’µ+„¼ú? (:ª:{GNRƵoZ¶ŽÛÔumééOÝ™#›òK@Çâïþ0U«¥j%¸Zâ7–5Í´}øTr.ó¥3-Øňό¸ã§õ¸OÜþj€êv5­ þ]”/nqõ>²\Ï‘Sa§…%D쌯K}Ôl$¼. n s-K2J˜ÙtÛ’~X)oßê:ZGCýÕlˆ´î­( ÆŠÐKHPN<“k7;•¤î÷¹§yÔvNÞ†Ze~‘ã½aQp:tï…[m§ŠcvZ ¯++J{€£œÔîÔTµ%>2´.4— .Hma'‘šg­¢@ÓÊ»Y)C¤PÇZL¤=´¡!=óæ¦Øòúܖë{X+±>tÖ¢»KºÝ4^£´é[Ô$as¥-#ÑJ¸ú$Œæ¶Ÿ…9~©¹:¾ÇPÚwÂ?ŽØàwÛ•¯¼N­¥‰­Šª3#]ý g*ÚêoBõ½ÃK£¨úרc]Þ‘$³Ü…©å!€_²RÊNø•áÍò++zŽó^*'{‹C2\àÐ@ÕžO`ó¢úꉕf×CMä°Œ—ãHÏ·¹)áþ«^îñôŃPèE3*Xn× )BÔ”à8ïïɬo-É~}5%mý´ 0 ñ?û”½7EÅLùjigþkÜN·sÿÄqù'^“YtÖ¸ë®Ó ¿KÓ!С*Þà‡Fµ'íÛ4ßÁ>Š£¾uõ5±ÕN¦$>3‚ßKOo¯e‡_]ªíÝ7-g”%8ü/ß=·W§Sïq_›{:Ní!vÛ;®®<Ù3õwÒJ~•gr”pO‡&¶ˆUVWUÔX%&*'9Í•òÿ6G´éØçS9$ ÊÖÝn{"‹ïñs–úÞwÀ žÐqº×ª:e«åé{…Ú.€¸În,§¤ÊG¤·Ï!²xRÕÀç5¯zb?kzb¦[CœË]C÷·Kžp I8q9ãa€J¾õ%OLQ^©Ù\ƺ®&—45§!½Ï°žþÊy®:a¨Qz²ÛïB‡Ö®¤IµÇmÖâÈ3lH[`»»JIíØ sR~*x_ušõIn¸ÜEÖé4`9Œ ² Ã5 Ãu8œ78à““Y鎻£²ÍIFh(˜÷\4—ž\àÜgrF9WWÃqÒÐ5û†rÉÃh„¾ë)jú\wjŠÚ·4¼-=Àõñ“´`aYWT}›©:vÕ]+ìOÝéÿuZó±#w2™‡K›Žòœ€Òs“ª|b’åQHÈ®aÆI˜©Ûí¶3†Aø;d“¸ÀÓ¬®×^¸k˜º{M›t[#açm¬¼ø/<½¸Éxþ·„§°zÑž/^o,uvk&†BÀçA—1ä42YrçéÄlìÑù©˜·Óôµ¬ÖWNò¤íc{5¹Ü÷;¨æ²›£þ>oý{Õð ß_¾Ã±a©K¶6âVŸL%y [ƒ?Pí¸c¾jC¢<4 ÐŒê:،׺ýPÆK‰û«%k†áä‡ÝD–ŒCÎN ¸ÕuWR¶ÅLÿ.†,9Øù H9ÈÆ;`ó‚¿Tê]祥–û©¯Ê.]&>·NOèð‘öö¨˜é¸mô즃ð´ÝTôŒ‚6ðYmq¯P£)ÅZje‰»'zqÂè=%¾ÁŠµñŸ5­¯®c]¬$*ê+ÍW¡îÑÝ$2´ÆY+¢ùG!'Bø]‘ÖM3 ‡qÇ[VObx¯.Y4€¥åª¸`Vlûlh‘šù ãÅVcÅÇYP±Õ9ÎõM¹õµ!êIþô½L`·u+£PÝ^vÝy:¤ÚZe ©ÔmÝ·‘Ÿ½@RK->¯,ìT=u‚9žìíú*æá¢fMyÙÅÔ¾Vs‚y§õ =”´cC}“u¶Æ»t—[ €x§W+2 yMÕ•pi˜ »¸!º¼75P«%®ôòS Ù|¦ëLwm7ÍÄ%¦”ñäÓÈn9˜ÊOPd`q[¢\¢Zä£xHüÔ„Ô¯•¤„¸…Ï8}ë…þ7þ˜9´r½@±±S¿Ô‘†”Dì»tãbµêH…NºÛͧßíIU×ÃÿìÊʹH0S¬Ðú‚̇w+Ï<šdÉKŽSH)ÆÀñ¦ÜeIôÞI(ãÅF]àrÔú¶“ÓÊw¼¾ˆÌ”ÂZ‚1Í4·‡9Þ´ >]™eŽbT¯MÁÎ{Ÿzqp„ã!KÖÓa¹j½t£v[rU"JFRïPöú˜¼ðjFZ>¾)Ü0+S]>vôòbý€ö_,—:=›”åªÞæF Æë;{_(êOÔMBÔ;^ÉìkR§ne´%â¡Å6I)·Ü7ç)öÓpK»RúlçÅ2¨ƒIÈQ³Ñ9£`ž'3a±ÇnÔÜÌAÙ4€¹ƒS=',ëHHWŽjfÅW Sy³pvÿ,’úX¥÷&á^v–’Í[:Šá×…¸ÀUê'IMø”eÍ:cè8½Q+,ï•2ËÆ­ŠG>"!²—Z[÷ɦ“ZæÛ-ÂsKPdv–…Xê>£Zôó ur›l'Ý\æ¥-=34îÒÑÊ°¶Ö3*ùïןŒû>“py–Rÿõœ WMxqà}]\­a9U.¨ë:+]9‘Î+ó¯ñ'ñ­:§t›Ís“׸‚àQË£íì+éŸ…Þ ÐÙàkæn_ý—Ï/¼t®¸Ji­ï-`Û!pLåÈ”ã<ãŽ8NI'$Ÿzè:a嚶Í#õHuÝjczQÏ~(™à¤ã€òS‘9B~Œbú%<’‘´Wë“’Š’ecZ8L_NsºW´+èY%9ÏjU·&’3Áè!i’Óa¯Ñ‘š›|à4 (&³ qÐ÷)G±4ÂGmèØ ÆO ;Öüò‘ö¡I€ð‘’œï•›´2@˜”“º‡¬¤ÀÎ’劷+wIÏÛµfšP„P„P„P„P„P„P„W§á¯ŠŠÉ¸î„W˜öB+Ä"„"„"½á¥Â¸íŒ“^OáB;wn?•ÀEx¶6pI)ȬÀBØ¥œ§ìk0סÄ%MúŠÂT6šH'°3QÊpJ¸Väàšu¢7R|,ÆðŽÁ§ iÎëÐVÂÒB®A¬ÞâyÞ…¶20²T7ÒRC¬%XíÊseä´Gôÿµ{&‘ÊÅÀ²ÇÔÞ¢GbiÅ4%™ÆùM*r^-d)!C¿šYÓ‘Œ…ìÿƒ( $÷µ7ûð× „Î&•±µªPVÓþô¬õa›,å‡IܬÂÁ$ãhÅ0–>¼òC3]é!dÙÀÚ7n?þ™¹‡Hî—۲ؔžTSŸ>i£© OºFXu/Õê¥ìaM q_„yvJû LX[akm;Ü=ê@z¶<,þ©L/UÙ-0ò0²{cšJ}!™jöCéÀåMï+XiˆMgq+>@д ’¥ Ò’.j"Æn;;RÚxïú¾ô°€½åÅNQÀ#ܦYS €_ÔE?† ^ªPBEiqoÜÂPKdñKVG¦"B‰l™à«e©†Þôu!{[YÚ´¨qŠ¨ù"@}ÂöirÌVNÍuÅ­”-AŒçnxÿøÒm Ý'°BZ&)¨x%ÍÝϵ7ò~Sé? òL‡SÎ)$£#Í-ô¤éõäg…¸(` ¨ãÏÚ°SÍœ…(HÏ¥$,ÂVf*+±_lƒ±a|öàƒJÛÜ({†pxüÓçÁæÄXÓŒ…ÔZ¬¿ ouÿzë·Hõõ÷A¢.lškOÝÚj:f…;5õ„:èò6÷ç [ó¤¯= $¨ª¼ÑÌò]˜¢lƒCZG«SòÇ—n`à-?Ô½;ÔqÅ 6šˆÚàI{ÜÓ¨ŒìÜp¸‡Y=j¹ê­ÊÉnþjvBÜ(¬Fl¨”£qäà2}«TSËŽ?Ëã~qÆ{­ŠZìã“„ç¤Ö–Ï¥’’¯aP×–¸î¥¨ã 8 ÇZ].! îqgŽz¬3Œ«]ÌÔR³w¾3mz؇åÿ Z·8Öóé•Ç£XÞ2Ÿ x5ê8Ô·‘°Ež.ð¥ÌyÇPä4…#„ãj–HÚB²q‚{╪¦ xp9ÎÛäcßloÛGÍ)3¹¤Ü÷ÿ5aäòpI5ä¬î¤}9NQ%ª4†¤%(p¡@”«ô«ìiÀ‘„ð¥kaÔwi®"‘ 0ì§ %?ÈJG©C 2O泆•Ïcü#'éùÿö£n3šv7}ÉÂyÑw @Çê‘´-Z÷ÔÃ3’´©*ZTR R ) ŽsŽãÞ¦ë:~áOCÊx)å$5ü´‘±ìpUQÑÉTê ÿæ·‘‚«HneöP¥„ ¨g½BNÀœn§KH X§eiÛ„{½æÖ¶–eÂÚV’Gl¥@ƒø Ó::¼¼8‘Ø€GæÅ"׶oåÈ¢’ùµ¸úÊ”ò–T|ôðe¥L„¦;‰mÄ $jJF’ ìšUéV?O,:Ÿ[ê›^‰Ò2üfé!›oæ(uG°R‰õ1Ó9r»V2×la|³ƒG÷ß•w»ÒÐÒ:¶«¬Ü’3…mõ3áǬ=¶Ä›Ô­}Òñ䬡—d%%c¶’G8'çíKõφ=EÓÅŽ½Ñ¾¿!¥ÃbG ¶~9Æø®ÙüAµ^‰þ;dÓÈqùIGSÈõ”K„“š¡HÐBŸ•Î$¥pY’´„#Õs<8ÍfڂѹCîn„zŽîÁ¦£ ú²§8µ05fCÂ×ýCÖ2;-ˆò§ï2‚ ¡#¾1ýéGŽ°–á#žL‡*)6xgkaa {T{Þç'T‘»a²fjv×9qÇ~­À«Å1Ä)È­¹à$Ú‚àâXJÚ J±¬­ÔúŸêRöû).õ ’h:þT+ráÌÆ6€{ŠV§§›$¡ì[ ÇÓ¥ÓÀ¢°ç¿*bßRVˆÅY8ìj˜š™¬`håm‡ÒFåu¾—“Ò›?J§NDÛë½Aþiµ6ÓcʱÜýª]Ì´Gc{Ü÷ýü»`óîJ IÖ[«cÐ<€9îWK|/uçIØ—u±jËUÊó6DU3nm ©å)ò0”Ø{ŸjÛÞxh¡ó©ïq:g:760w¯c| ÷*©âLJµµ dÔ2†5®ûéÎ맬·¥ºCGuÙ­³'VÉcù ¸²‡šYI?­?¤ ‚µmk:NÑÓWJ Ããþ#(ËC‰ƒÃ›œòG~µ¼Ù¯U×*9­Ú„ ;‘»Hϱç=—+h‡mf›™ê¨ÖÚW¦::ôܹVËŒ¹Ù‘rB eYRÎR’p;šçŽ•û?ÝßOKz¸ÖEo§ªkŒO‘à=øìÆ«.Ï|lsÜ·¯¾0[ß<Öª gÕÏkdk[éf{¹Ç ÃFä •Õ2øn—r¿ë›.£ÓQ.š¢ßfS–æÜ’f\a[–ú…¸•‚r­À 5¼¼û6ÕÃ%Ö’ëLÃ_ X‡/c<Öº@ÜáÀ8Fn5´gÒOäʺtÅ ]kkmÈ’ãéËHôµßá>øÆq¸X?ÖÞú|4¦œÒÑtíº"F牳Œƒ•(Vr®T£íQý_âœ7l6º&S2!©ÎksAÏ©À÷dä¹Äç° õ7‡?tºÿ«œÈçöþO°$†Œ ´»s[‹¶£2³DY.°™ B_ v+AsžøÅQzåOh¸Á[3 ŒiÉk\ZNÛ ´ƒùgÜw[#¬, «¶˜iÈkÜ0 h8÷8!røüs]þ œ·hˆ_Ò¶×Ôû¦:v"CÛBô‚S„¥)Oq]]×·î«••÷À¤’Ƥ €2FHHnË_øsámO‡:˜näûçžy$þkä$å7:A#)Vr@«8,jÜ-øV&‘eœßd@㱪Õåîå¥føÜ[°ÂŸÇC¶©I}CGžüUnG Y¥Ü¬—°´ò¥š£¨3.ö¨ö“¤€+O?Ú½¢¤Ã@=“:;3'˜ ®`À¸Ét) !çñO§©­Á }1¡_z"ÂôÔ©©Ž}$`Zòù\Ö¸yaFVÐ…ßL3c˜·ÂFw{×´÷'ÊÝåVkjGPBK©Cͯ±¬¤¶H[±Ns!à§ö¦JrSnÆY\5øÖáü¬E1<§Û³H¸CHoé{ã¾i­;ÄnøYÁk·á8i\¦Sêz®%xÀ¦WjÖçdâ°±À5HžÒ7i³ ëJœ@óL£º07ÓÊÄV2&„ËpÒ»_B‹*Qž9½=ãÓÊ™£¨io*ÀÓNÿ m²—1ΪíÌy®È)Â6¼àhLÔÌȵ銆^Çp?æ™6¥Þ_“¤}Uv+v$É9TÑ\‰%%ߥ¢x©‚ز9W*zaVõ¢×ä~Œ„óTºÊ©5î¢n5 ì£Ò ¼ã¡ìÏ>Ôþ*{©H=ԲϤc))p®Øxýê*®îâtöM'¸»8)SÚ~\v7¶¢¬xö¨ß½w!5ek\ìšàÚ |—GÔ½gQ[éÙLK8Ñé*bÆž.ðGâ¡MòŠ–êÊwO78Rr\ö¬]PüîéŒW‚çá!fØñ^’“ãŠMÕ ÔµíÆ\Ÿo’ÈÊ‚€¦R¿º‹u[°O :ée-ä¤ fãÛ²Ž’6‡e,fî›yþcÁ xÍ<¦|Œ8n@Må 3p_QõZ×iaÅ?% ÷UYm–ºª‡»¾©Õ7Kàj …ºÉñ£¦´Ãr[]Ö3{AãÔæ·¿Hx?]pǤŸÉ4­¿ÐÛX\ò2Äïˆoñ½^äL·iœt§ÔÞvƒï÷®äð×ìÙOD•»|w\½âOÚÍÌ4#'Œçaþ«åþ±ê>ªÖï¿&ÿw•(¨çfò?jëNRP4GNÀÐ õ/V×ÜžMSɲ® *ZwçrªÇ¨¨ŽˆŽBLì`6¨Oãµ*ÇžY)A% €² œñý©Rí°£e„µx¢@ ã4”–”±¦R2Bp}ë' 79X9‡Ù¢U“¿ïXÇ(kIùY+md$£)Ï¿j°6êÇŸXÂm;}–æÚŒÏ;¸sO ª„»H9+ÃnøZåz œn9ïOËšÒp™Ô°¡“ƒNoIäø¦”%S57uv1ÜJH¬šîê«SC“²DPOù©`õø4•¥xÏVI«ù^ý8ã;¨^í……f¶V¬ŠŠŠŠŽÜŠŠô"².Ûd"±¡£š„Re¥22„V-'²œv¬Äš 0Šó:·(YçèÆ d…ˆäFÀ6«ãØà¡mPÊwmW·½'/+ Ü¥T³¼‘X°Ê[Q'$ýj$`y4ñ§e ÙpÜ”£Æ;+íJµÝ’””­ %9#8ì)­c±ƒ•à¹ZJ¶xÍ.K¢2Y†¬’æåa}üRÀì’Ž7hÁåfW³)A›‚ˆ"'ñ…“j+$,n沈ú·NžÀF0·$î?@ÚÁûÖ~[5g¤‹Ñ’²pôƒ½{3ZãƒÊGÎŒò¼õQ¼$%E$pi2°#dãËËR¦F⟨ƒ“Å3y!Äù&SÆö’à¶ÈÂPjQW‘šNG»&Þk½×ë6ï§.6XÖÙ3d3-¯Y‚‡P²QÛ )?cƒ_æ‰ì-×÷؃ý‰ÇÐ௲4•±Î €qÆ?D÷oÖNé |‰e¼é·ä_V!Ü!¹ Ô™–ÈRT‡Œ!*'ºž9«u5dÐÛ_MØ[1†ŒÈ4ñê-Øý®Éî¢Íf®óeƒÓþž{öù §Û6{o¸ë¨@Ê”£Ï"©—'¹‘–€¬A…8Ý® iÉzËVÔävÞŽ›8ià+@û({÷†ß¯51+TÀÝhnK¯8’NUÚ³t@„€9ªIil|âWå#8¨ê×b2£âÁvê]%Ç$úHmJÂyçÅBÂÖ³9VÊåzÛRxf°žŒ´$Û wå’îìóúi‘ÒŸˆò0•Úä)ÇÕ’¤ðH•T`5dÁ‚w¯9ãž)ˆS iX©°J”8Á¬ËŠZæ˜ÿO$W°R¥yÒ™-<2¢8§ì¼%Ÿ‡rš\c$‚ Sø§m™$ø3‘iÖYmÆþ•)Ur{ˆY20õÓˆCѳo\\³"j~i0â¢Cêl‚¦ÚÔ”©\ù þ(é¨Yp×79°ê,h{±ƒÃ\Z ú¹ßMïq·Ê)ñ¯¶I9‘œ)oQ#Z-VkÕ§Gê+ÅÖÊ.NHr#ñÒL—T„䣾Þx¨É&Œ"™î|-q ‘§ lFN a:°É,•õ ~œdþ[®s°Ñm)ÉÏ4«àß9VÙyX²FFNÞ‡ð²í²vHPI8ã¿4Èœ¤Ç)Dw܈¶ŸO*B·ƒŽÆ±sC†2µ¯*ß‘×Y'§.™7ÖÕ‚T”ÊuhBƒ¹„$nØ”çê8H$òM[§ë é,Œ°¼%¯×ß9ÆÃœ9ØO$ª\#MÃøˆ'^1ð¨æRP°1õv5[yÈÝX Üv Ë¿Ègø#²MC·ÇÞèOÖ¥q’BG'8AASMmGª–GÛïIU %XÙFZ°›.8‡~¢Ÿµ-I#e°­öæc)ŸJúV®¡Þ¤¿xrT fÔ·ŸKd„œp Y­Ð 2Òí,%ØÎ=¿U#u»ŠÛå7SÏe×ý3é÷O¯6õÄù‹ð{Ö§Œ”„ªrÔ~”㺿úU‡§ºzŠáLjf• A’âvמØT{ýî¶uj“p_¬´€Ó— q• <›4½Ï¿™Â|'ŽÞôÞéÒ¶ªŠJŠ·*Q—œþ_ BÃz¸T²fÆì9¸­í ÒË>Ž¾é~ºtÒ1¸hvŠ£<™oák”RBÒÒpTR’}¼}ëjØ:Q– Ú^´±·ïÖß[ƒ\d êk[‚âÛl•V¼õSîKÓ·7i¨;##ObãÀ%\Óþ!>nš#ªrùÓ'!êÉ6—\†ã%¹redí>±Ê¶ƒ‚®ÙÅnK׎^×ôÅ}­† ÉAsX~võîá¾5€FÚq²¡Aá_ZAt£¬¦­Õ $I9hgq§aœqϾUÓ-5§ºã¡´JºYiÕº›­ùO“:iL+Lv •Û-ó“Áäù'ÏöÞŽƒ®,þŸéÿ6¢õqÊ÷¡ˆl :ZÜ–ì\OºÙÝ_}¨é{UòøöEl:CÆoó«§e.é^œÖqõ]˧W¾»[z3 _L˜W‹ƒ»?jr¶ÈÊJÐv„…îœsŠyà­ªêÚšÞž¹ß™k¦õ²WkÌæìFK›œ ƒ‹›†å­ÎJŠëûÕ”L»ÒZÍuHÒøØF2v<Ó¾HÇ×ÝJ55¿¢©Œë]’Mù‹‚‘2òŒÆe¶£Ñq_ZJðTr~‘ù¨CÓÌ×øxéŸV&ÃäÉŽ6ÆÖáÞTŸˆküeÄ’ÑžØÌm†¯©uu6†Âæe±œ9ډϨNÀ÷*ÉÑ¿:k­sìz­5éØu¨×KÓ×ã6˃hôØŽ¬ú‰HHrŠÜ*R¾Õ¾ºWÀ»7]:žíAHöѹÍdµ•‘´éG¬È9{ƒ¥ÉyÁ*…Ôž0WtÄS[Ý>ep&8ƒ ‰;¹ã'9¬ÀhΆ„éå’WX•|ŒÖœÓ:>Õ¨ ÓÎM9•«úBB}‰ k¯ü=¦>"Kw§l4”4uE®kæ0Ç$dðF=ÆHn4¯:««êÛÓt¾j‰áäÒàˆ'?–û¯?ãñ3ÐF%XúOðç.S5ùw=as‡QÃ*qõ)“œwIÂBG“['­lt¹²ëÒñ‡ÇªW½å…¥Ò>BvÔ¡£ð€01ßìûfêŠzwIÔd†45±4¸8é 'ÜŸsÊøMižô†ujÛŽÕ[¬¦kNÁtqx.È æ<6”â^ÿáLdÀi)XæÒ­[ËtD3ê¤o÷ÅT.JòqÂ_ÏÔ6Jo·Æ€ˆ¹È=©+u½Àåë(¨ñÉL M™%æ÷6Jr3RO‚6ŸÇN@ÈW—‚Ü¥2…`,žrj‘vœ°UÖ!\5>ÚÒ…xÇj£ ¼ç`¨ãQ©Úq²Š¦_Ï­i”ò]9ÀñRŽ‹@ËrØɾ]†+¤¸Ê6/¾û¥!¢!9X­­ÎyŸ¿Šgpª15:­ŸËfWAéÝØ¡ÂçÒ¡Ô1š¯ÅŸÔN¢ÖÝ=YQ‹í0ç8ËJ HÁ“2ùd·9S4uš£ #2åÄÛ¥jløØå!#;©­ºî¹M†”’Aê6­¥­Ò¢ê!kdÈY½ÆÔ_Hã9¦L“#IN#¨i vƒqS@;qMŸBª£á?·)RˆIÆ)ÈçzTSàŒ©V¢0ÐRý4žäšs–Ô-CäyÙ0]®ðR×½8~ %$o™øj• ·ÊþU;ªú±e±0âݘÊ6‚{ö«=Ÿ£§¨vÍÎU’;KÝrž ukãcKiv%â‘ÛPã9ö®„èßêê܃ú*Õã®mô ËÞè¾WõŸãêé~*œvKÎœ€½Ä%?zëî…û:CLæÉWŒ{.}ëO³Ž$ûö_25†ºÕšºkó/W™ÓáÉIQÛû ê«-†Š‰F ”:’ûp®v¹¤'ã·è«L¸¥¨`ñÅ[Y3p¨rR‘éÊ@c7¥T°˜vMŸG“ºXÓ(O€i7;<¬DÞË7¢%cH?é@”„Ýð4úJB›jV¥¤%C4«j-íìµjÒVíƒÈ¥¼å53›È^öc#é¬|ÝÓ#ÈÝfRÚ“· Ågæìššp“©†øÆ@þô宄ÒX“|€¡¹'âœA1cƒ“Y"`¦IN¨ý<Œõ`|€¸`û(çÆGdÒ°É5w« v঵¡'$wÍ(Ç ¨éaiÝ#u í´Ûµ,lñ´í„Øóx8µ+P50`ìµ¥$šU6kpµ÷4$ÐR@Å-@ ‘“B^P¼E^àŒP½Á œœ×­8('+ÊrWˆ¯Š÷ Ñ4¤`wBò“(EfÒݯI!d’qšLò‚¼=Í!yJ4ì…˜_'µ{¨!H ž9¥t2P¶¬' r;Òrá ÖTÞ0° ûšA(Ì-È#~ÞAÎk1³ÊÞ™@c Áíù¯CýÖzÎ1ÙnDŒ àgÏzÌM…œr–ì¯]k<àöý«'€ð2Ÿ0ç‚””¬ÈïŒóJµ£` Pœ/KE8RGs÷§l’<åbN6¡XÎ+Ðìì³/[•¹ ¥)$ù¯ %Û&¨$섨£G>õ›sÒÌv¦aÈPQV|û{PX2“m3 rRT£¼qÀ¥täîQ3ð=*m$$¤ƒH¾„’yX¹ùf\³)ÀÚ¥ñYy0ã•ãºýnØåÅÕú¦ÜGxMŠ—R‡¥"1q,'ý4‘ŸÚ¾)Ú­ô•b:Ù|˜Ü}OÓ«OÎF%öI%Ššvê#¶qû©'R­ZlÞÄ <ʼn葖˜ë™ ‡šnIí¹^¢•‚{ÿza%PtÎl`€F¬8øq$gŸ…¹ò6O$œg“ÏÒÑàj'ìzyÆ®é@ÚÏY+;rJTÈïãÅDÖ¹Í{šHvăô8Ü~J~Û[æBÙ%Û>û$š;¦:߬:úÑÓ­a¸jI-ÐÄx‘T¥à¨ûžOŠ¸ô?HܯSŠ;T.šR3†Žä“À¹;) ÏPÒZi¾óZðÖ{Ÿ~ÁV½FÓ>žjûþŒ¾¥,Ýí’œ‡)þ‡P¢•î)½,Nv¦¸`‚A àþá?eK˜pàúÔN¿Qyi@šÊ¢#t£gHV=ž9J½U»oŸX®“>•„1jvT¡ ©–‹Ü(‘À¨’íGJp&Ôt(ó)qSTÉÍI»‰(a:Ô °@ð¤Âßl}hš•çϚƪ0cÂóU±h—iLLÈP\Q|Œ¯vô¤ŽàƒŽ=±Þ«Ó¥£'óÿ\~ÉgÅ)¸€¢×7â!ïý+ B0yQïJRÆüzÊ}sÊfT”:Ûˆ”¬{Sá iHÁ‘„Ì„áJ 8ÇŠ|ž1£ºX•‡Ñé¨~ô‰nRŃ²]ml²ð)pý©½Y¸M\Ü.èö¥ÑÚ'Z[/ýE³êI€Â”öå'׊µÈijB]òT´ŽsÎ1S= Qf‚¥æô¤´ét‰®ììÐ{Œï•^ê*zúŠc¸·^wÈà \›uÇVß•§¥è=(´hS5ÉjIa ̼8TJ^žêI.,  MôŒ’N5ÝQ<”L³Óa´¬qpÃ@sÎvt¤d¹Àp3¥¿Ò;™;OME⺣¨-9%­÷ |ã'ºç‡\*p”å?Š…hÆÊÝ$¹ c*IX( Eà¥#”š¤VǪϯ½län¾<ãïQÎ 'çÝY:Ž×¦%[ÝMMòX ·YÚáB¼«oƒÇ~i›òÉ΂\ÃÁ#ôɺ„ žV86qŒüªâß{ŸcrKQÃjiÔ¡¡`”8  <ŒÁ©Èå%¸ÎÇv89S5”,™ƒãº˜è]l³kã×+=¶d7ó.0c!M2AAZP#(ÜJGÈïOlõ1ÇR<à4; ägHpÁ KAÈíÈåW/V©OåÄòFüã€~ úsaÑ?öM'PÅø§ŒêfÃŽ°½¤v[nýgÔÞ@XÊ°(ÎH®œªðkÃz#4ýDÙ xo¥‘j“#ƒ‹Ú~1€}Âç£Õ]_QX)Å¥ÍsIC Ò}Ž02=ûü..êQéµÓWÜíý²ß­z ”·ø„’ô©êHǬæ R²NÄŒ'8Ê}e-¶¢ðøº~9>ïØÚó©îÆÚŽÝÜénÖ³Í_OH$¼½¾pv–¹ãÝ1ÍÑÒ,7•[gY/V ˜OB–Ú‚ã‚NwI ç;Ôe]†²*ÿ¸ÕBèäikP@<&UÝI é¼ýañ•pϼ[\‰ajצàÙÌ(Ÿ,ó›‹Š”ê y[»(ƒÂG 㸯µTŽŽ'ÁJؼ¶Ë‹Ž0眉öËKAw©käÄ„êv@ãÙBn²Ç‹é¡*RC¥{@¨ù*ÆOnÕ¨kþál,Ûüm¶9Æ%:o•²z‹ñ²Ö—˜ˆñPBB3Á󚓇îÔä`à{*ÕML“;AMSæ91`o)i>3úª¯vê6L4d折Æ܆,ŸA.¬ðxVy=”äl$à*ïTÌ—)Õ!§ Råq­•Õ¯˜Ó43Ë':ÞòÒÒ\ >ã`ÊlëŸR‹‹h( ´¡„¾g8éikrºïΙôòMº®5~»Cɾ°†­6·\̈ÐÊÒT¤çŸ]Á´gN2qšîo <- ékîýCÿdk›†BçfFFHÙ¼Ÿ6F÷Ò pÒq…ÊoÕ³_:ž–ßiq¨m9%ïÒçã`}ØÓùɺßÕ.–i®…õr&™¼Ûô:§LC¶ý8¹ª“!ÐR(Ü„’¥ðj§lñO¥mž^YÓ²²‹Ìq1S ’`µ­ eÁãÌÁqwôŠ]ÐwÚΪ·É_¨ÐÜ>`Ý-$ñÆÙó/âïã;¦ÿÿ s`[-vú×6hMžIwdv’QÙ*Ê‚s¹DŒkž|0–Å|éxìpJÚöÊÙ$—8c"úC˶È-Æüì·Õ« î’_ˆTHÓDFœz‹³ÉÈý7_“리¹ê;½Æýz¸»rºÊ}OÈyÅ)Õ¨ä’MtÌ6˜éãl-hÀ |GTÆŒ4lŸmš…¶mDcìj*ªÚ\r‚¡¤ìTÂß©YÞœ/-ýªªÔq¿)Ãp§0.ÑŸÚ7í> WªhÞÔíŽÀÂ_!À—´}dÓxÙ²Z9ÝÔ¢Õra+J_JPOŸj‰­¤v jpÚ‡ Õ‘j¹GKÈ-¸ìj­[Jò7 LHÝY/]ž‘!§Ô´ã±ª¼t¡Á «]¤åDbHÛ![ÖPsû ™š<³e/—nTÞãbJÖ}ê¿<[ì†V8Rk|H¯¬¦Úà~¥}ª2¾žW<†3[†ò¯þ—ê½3PZœ¸ÝcC·K}ž$+ÒiJJ ð0?Úœt•#qdU„6'×2<ý•~ýkŸîïòY—´dc¹ éƒømÒ][Õú¶7Lú‰Ù aC+~H?ˆà¦Á(Î{þkµ¼-û5Ðu }{:zãŠ@ãy'¿¤{žËCõ7‰Õš:ynt¥óHp9ÓóþËä‡Ä—IíZ'¬úƒFéÛ—Ï[c„,:·R²œ§'rÇk›ºÊÙ šçQoÚÙ°AÈü¶]sáÏT>ªÊʺ†é'¶?É"éÍŠÇs»Ù­·«»– '¬”ɘØܤ·Ÿ©A>xÏB§Žë\š#qõ;Ò;œw8íÝJÞnrùš•šÜÃŒ•ÐºÏ z“UµyÒ]ÓRé cÈzT†ý5[HQqgôƒ‚ž3ÝIjs§¼;¸×Šºû42OEq2é kFI~øð ;ʦÛüE¥¤|PÞ$lSJ@ÓœúaÜýqò¹7OÙŸCÍ¿"D€úJ½f–ŒŽxÁÏ<}†;sUûÅ\S|£’Vå|Žs4œc²îþ—u~ÍÓ+…†ÿ§´U£S_Úˆ¤¢]Ø¥ñã\C\¥%<îüŠ}ÐÝwJV6éKIÓè8ópð×AƒÒ §P'¿i~®èy¯ÉEUPèâ.Ü3-Ôø'“žøÙ#Ñ?Néc/R#NÙoWOYRô´lw’‘œAÁàEô'YK`ºÿ}4sϨ½¾f¯KŽH gœØ €žõ?…âáok£‹!§=÷=ÕÝÔ¯‹N¡õÖ᣽·Ç‘m¶!Ä´Ä$–5kVå-ÃÛ<$ `ñÏí vëÙhÝ|cicÔÐââ qÉ;ìÀ;­}Ñ^ZzV:ƒiqÕ.2]êÒÀûï¹+‡zßñ ¤ú2ÅËVëy­û}É^õ¾àìÓIÎT¡ÀãsZÇ£<7­¿ÔýÚ‚>NûlÑò}¾¼­”1+AvÊø ñGñw¬þ(ºŒ­g¨ÒźÙ‘×oe)KpØdà«QÍ}.èÏ¢´Rù[]n ³@~|ÕN€ÁNÏ&"tç;œþås“:‹oê'5j’Ù”ûï,JÆ¥P%į "m@òMyå?[5‚wµ„þUQµ–CØ)«NÊž[õà l‘ž{÷ªýGO¹Ü„ò:Ü Õnê GXmkyøª½OM¼;'¬ç/F¹an%Äsi³º}Àd§ÑKœeJájä…!mÊñÆpjk/b#sʳlÚù*h6¹)?“UJޜò]³FTŠ>¦ŒûáAÄp®{Ô\¶—´p”ŽVçb§±µ d4œ:ƒïUémÔvYºmÓ•¯Xµë²ƒÏpi­eŒéÔžD×8eOÚ»² /'‘œg$UjJ' °yít±zÅ0Ù)mÀ¢|I !{· &÷¦ÖuksdÈÚ8§RYLmô©8˜Æp¤öû伌ÉO¿'µDÔÛä-;'{±ØÔÖåGN% œc÷ª³í2‡p™y;¦Á}ˆ§ÁÞƒÎy§†ÜðÕ'V5£P@KI*ØíÆj³Un“8‰¯¥yá)y‚÷è’| ÒPÐÈ)ͤ‰]SNIL¢„ã}NJÑ€•m†î°SeJÚ™êWŠÂN–‘Þ¢ÕŸðOoÙ§€ËéÁóMO–öK›CÂh¹jWV…ªRÔGâŸÒÚ€>½‘å4m…Q_àßo!H[®%²|UÒÛ=<€˜ÕB]³B¤¯½&TÒµ¼Éwò*ÿnë•[dnTÅû¢m-.â"jñnë× õ*eoI°äªSt%*”Ä ç³["Õâ<¹Pî}ÇåʆÔr(t¦2·ØN1[Ù×ØÉZæëáèénꌾtúd2¬ÇPW°óWú¥cû­Yvé9¡ÎZ«9Ú}ÆœX[$(x«m=ÌxíRPÍžé„ôžŸPM2¡aíÁðE=Ž£'áCKHZ1„%MpQãÅ8˜ÈÒÓ‚ŸXãg½( m&Í)¶BY#n{ÓˆÜ,­pIL~2”î?ŠWÌQ“ÀÐrÀ²Häif8wL'!$u®6‘ÇŠT9EËF[Ìd@ǽ:†U,8ÈL2")Dá)ãϽIÅ8îS3Kže~ %IÀþÕ"^ÞÅAÕPîBguª)ÜqKµÊjC”…h#±¥Úr¢¥‡|- iG°p)¤±ËB’Rpk0ì&}סý…ÅdÈeá8¯X±sw^W£9X¸l±ÆŽæ”Mñ²Çp9È¡c¨Vºh¡ ’y,ƒr±¡bŠÌ ŠÁ¡¬‹Š@yEc”"½Á寲 #=©g;@QíIÊô°d¤sƒYkÆÁy•šy ,• ÅÏ'”«Ü°”öûSƒ#tcºÇ+Ý©l'*I=è‰ì‚‚SŒG±JÁˆœÁ®<%Jq+XR?PûÒÇÈ "çVæÖ ’¢A9æ“ócÖ¥šöü¥%yÆ?¤¼Àg<•âÂ?Pâ‘q¯KŠ6䔤1^Ê0>+bZ);TSŒ×Œp;„-•‘€Gß5Ž³–Eäò·!?IQW?zÊLè%b”%¶‹g'rñIÒ4êåbü•ú«³j µ•Å»h™.ÞúÒ¥²²•c9î9¯‹pUÍL/,ÎÇŒcŽBû/WAK4ÈÐà7ÝZ*“÷u›yy;æ¼øASyÙ·’œc¿5U»=¾o˜ÂNFù÷øÿu®Ñ4‡à7;cÙ7_&¦ß 1Ö†Âqø¦ús+õi¥§Ã²ŸzÔÎ’tTÞµ§R:w~êÃü«ö›d{¯ÉÂqä=½ÄNHN²¤€6cAã§üë –WÖÝèÝS;1å7Plyßw‚ 9‡v­wâ7M\î‘ {lÂ6œ‡dïþÙWß=YWÅ_^µ7X™éÞšé| Êke¦ÔÊ[ŽÈBBxJ@ p95Ö=Y ]}Mt,‰ÑŒ4c'l““¾—Itä”6øhj^bˆÏë¹ývPˆV÷· Ël§Ç«§¨n2{­šÖáY–”¶8Žj©Xã•‘Éåas!(Xl¬zÎŒdŒ¯&±’¬—4zu6ØòæÄCò­­\=U(ìHZwm“Î?5Ì=•.‰ÄýÀ8úî¢mÕfVù­ñþI7PuM‚üÆfÉ£­ºMqa7YŒê֙Χ‚ù ÉJ•Á#8ÎqR×jÊjª‘=,èkKAsp.ˉ>®HÎÉݲ†jv¹“Jd$“¸Æí²DZ¤ä{TDí8Vl7r¬Í'vvÅz¶\R\aä80}ˆ9¦“ù3²qý$Öµ4î‹×Úc>õÕÞ‘êî“ôÞëPXæZQyi†û;$LKeeá¸ï8åäøâ»G­Mç©zfkE…ßx¡¦k%-?䇫 ’ÂyÆÛ.n¶Š;mÖ•xÑ;œXAÎ’p¶O¿²ø‰rˆ«d×":•¢RP°¤ûWÓKæ°4.ˆoá³ÿˆšÖɧu%…ÉS#H…*ä¨o-ær¤))$„—½ ýXÇ5Ó6^Œ³QôsoתfKÚôÿ5ÑÈ\Â@Æ‘—c9Óþ‹žï÷:ùon£¡Æöã}!ÃIäñž2¸© DIáh ³Õ«kAyÛííŠåklÏΗñôì·Ý®à^ÐÙS¥a§RWŒSúu#1)ÄU·3åvÒ…a=ø2OŠgkµºª¶:MA¦GåÇKF£Œ¸€É=‚KPŽ7K‚p Àäàp>Jú?ñþמ“ô+Bu÷BëëV´„Èhzñ"ÚRZ·­\îiYþc)$ ¨áAc ŠéO~ËwŽˆ§Š³_Þ` Ö‘¡Ç%§:¢pÆ™3¹äBÒ>øûCÔ)­išN€ïêxûã¸àö_:¯zrõ§ ›ýžågvLvæ0‰,©¥:ÂÆä8¬… {‚85ÍÕvêšgùU ,qØp áÃ-8=ˆ9¸Ü-Ñ\SøÆAÎã·Õ#•f¸ZÖßñ —K­¥æTÙR2€È#{LçcÌOpíû§LÙ¨È#àå+† 6ï#Þ£¦i<'kcëC®€ƒÛñXÆÒѺô9Z§°†#¡ô­µ…q²Aö#Å+NIv ÇF ÷=þóR¡»,r®ÇorlÈÈJHÀíÛö¨šéÃXSJê¦ÅžWUÚ´å¡«"Ù‘re¬¥IwÔ) #n9ϹíŠRžÅ  ËÚu»¬ì¶1¿×+¯½Q,•->ÿ9R5“ÑëÿµØ`ÇÞ¯¶:7SãK‡ìµµÆ¼Hì¼)‹§Ë²ˆn©NÛ¢Cx÷ñš²V_\æçìovÏ*°‡¸¹»(}ÉmKu´´Z{”‘ÂEP®däã|p¥àn“Êc–ÚÙkÕu¶ÛÿåüUJX0ÍR b¡×!ÃyU¤Ö-ÚÔãMî^3ã½DÁjûò8[ZÍÒO‘¡îP» ý@ô˜î³)Ù„#iãÜTm°Ó´8c ØÛƒ²–èýLt}õS‘ß1KeØ«nRwŒoNÂÓÜÔ½=QdnòÒ7Æ{b;1?OýåÄAÙZºW =Që‡ñ›ŽÓ3ï؈Sòd¤ma€9ÁYã?aS ÐË´rIl¥|¬ˆeî`¹ã?ü)K—VZ,á‘VH÷`y$ü._Ö‹þ“ÔçLÞc?àʶºÚ“‡ØƒXÁòÜ^Ý.‚ÄØ­“c|rÁ÷–n nÃ6X& ÏLrBX@ý'Û5U‘ó? 'Ít¯µ¸]yðÛ­º¢u5ÑŽœèùš¶PßR›XW£ %8T…Œí%)íšÙ¾]¯ÖÉe}’PZÇ—7-h#îÓ°à»òZçÄ+-©ðFnS‰pßl“Ù£¾ÿ ƒ¿O/\Þ^Ôˆ“r¹Ãá_®ô…Ά_tmç«zeçíòYfk°Üt£twFP¤vÜ­¹Pî’{äUºn–šÃ¦¢êÚw6†½íÜ;ËwqÆãôȨÑuTwÚ9£±Ì5´¹¡Àd7±øÎÅw-ëâï º~V±Ñ'jõléåöu¢Ü²üpÒâÚZlœŸ©KyÌÿ¥ 8€®¼ÿóçGZ¢©éû \-ÕS@×ú"¬kf9>³æn1ø°\vÈ\éKàoUÕ{¥ðµÕ4ì•ÀR¸Ÿ/ØŒ}1üL¿¦:ËÕ]U«º¡âÙ:tØj»å`üª$4Ëa²ÐúÕ‚I<ž æ¹Çþ«²Üº®¢§§âlt- laŒÐc@.ÓÉÉÉãÝoo¨n;$4=IRd«9sµ;YÄ û ãÊ·[°³-ëó«5;D8í¥+KªÜ2]Éá°œð*8 šÔ”uvùùrKÚ‘Œ‚r?OÏc“¶ÁmJú¿6FEL2ÌúŽp@ø÷9úcå[·K¯Iî’t¼ØZ½(ãVÈÐç†&)ææÊBp¹ŠÏè+À>’~5%â7RÛnsBl´_sk#k^<Âýrž2w:G×*‡a£¾ÑE45UxËÉi- -iá›sñÖBêŸ@:WÓ½kÕ¾©j9V-c`9ÞÁÙ&êî0†RqÆãÇ?ŒNü"ðº–ý[,”—‚Ý îüŸQ'H|þŠ³Õë•$@0Ï Nå~8þ$þ+µWÄ_RnzÖôE¢Ð¦­V¦–K6ÈÙ%-§üÊò¥žTsö¯«¾xKCÓ–ÖÑR·~\{“õçn{- vñDÔ˳°Á¤¢jÅýÍÜZç³e%mëö‘¹ÊwN±ÕƒL•N·¯"ÆéJu~r7?4™²)(ºîÊñZ¨œîâg÷^¿­cä-ŒjçQçûÖ/³4ö^ÃÖÌ#ržâëwÚ OÌ/ïL'°4ï…-X·9ÔŸãuhX Jxîj:^šp¥áë8ÉÉr”Çê£èBvº{÷¨‰:A¤ä… Ϊiß*Slë€Z¶ãÈUDUtH#dö¥c…?·õ‰²A26ýÏŠ­ÔôAöSqÞá*c¬ÑËa*”•xwzƒ›¡ŸÂž2ìÓÁÙ:Àëœæ÷yú‡z?üi3¹j%ê&÷^‰ˆHq(T¶€üßóY;§‘+ÆõyÝÉö'Å-³nÓ-!\ÿVj>¥ÿ }þ<`t⟉è ¿Äç)©ðžAý)Óolï²ßÿâ’ $\y ¤ÿüE#¹b_øükAø±JŠCs”OaõVþ<–¥™uaÁÈýVáñPJ~¹AGìªÇÿijSøîMÆÅiSn ÚÙsÈ=éCálqRp+‹”¾ÝÔëÍÍIÏ9ÍAÖt”Ôœ#Pʵ´Ýâá0¶¥¼°¡ã5N¹ÑGØ'ñlAiÝòkÕ%Y÷­ksÃ\p–VÕª{rSž<Õ6²s’D)3Pc©9-§>ب³P즒Ö·l =“éŸíJ “ÛÝ7sǺb›¡ã=¼†QƒÈújRšüðp hè˜*¿¼ôɇ·ŸA ϲjËIÔîiܦRÛšîU3¨zHÂ’î#¹Ûšº[zÉÀƒ©AÖØnc\Í­:.ÉCËB”3‚[ZÅ׎ب^”#uÈÚän°·ÈŽHç’œb·M›¬ƒ€ZŠùѺç=E ßŒ¥ìFñ³mF×€ Óמ–|g`ª+…Ö—´µŽOzºÑÜšáU²‡IÁ 4ý°„ìì}»T«*òUz¥›î6M-å?¨nö§‘Ô&SƒÙ2É·©)NIÇj‘Ž£*&JWg…¯äŒ„ŸsN5Œ(ù!À# ¬úd'h?µ9Š|ì¢&‹tØê\΃Æ)Áx&2Æâ°r+…Ê~Ÿ½vQòÒ d¤nGNÔà}F–ÛåBÔR÷ ‘æR¡´ù§±Ì{¨÷4µ0ËŒJ–@À©hjulS:ŠmC!G$°¤œíÍ=kÕv®™Í9MKHIíŠrÓ²¯Í ФŽ1K5Þé›ã _¢ $ã5–½Ò¦a°}ëÒõ‹bhu vÇzM&`-ç4 wdËËÁÈ^Ðõ“8Z×·÷¥Æ鼘ì±JwW«·+Ð1¸dv¡z ‘Øб$žô •å ÄP„P„P„W¹!¯AÆèEdâPŠÅ¨EvP²$8À¬š(+ ½»€ƒ^<…àùY… Œw¬)^Bû´J±Yó°¬ËÂÐ’¤æ± ŽV%ã²qݱ¤ã`VZÈXk+:Q‚”’O‘â²Kgl¥Ma#ê;Iæ± n JEÇt­‘ÂŽiøyଠ[ЭÄxàÖM>Ë$±%q?ŠÆiÜì…“Ž rŒŠR˜’ ÁÄöX’Öî)=†;Rž@í%f²J7ý)›êˇ—„axAQPŠJ ÒP¿Y4{KGÕ¶‰šÖ û–šJ‰ÄuíSŸIÚ3àg>Õñ² ©˜ýUM.`ÎÀàŸÏ²û q–§ÊÅ.ò9ý×PôYÂéÅ«_êHºjÃ6zÒ`?9 ñùôÒ® !CŸ°¦6Þ¥t2*v>yÐÙ2X7Ζ²FÙ<$+-ï­­q 8duÁúû«®,Hµ¸ûJ€%8óa-¥$)]ù$}»UŽÉa>[þ•q­š(\çÇÉäáW‹ÙyÿLÉ(sãûT½m¿ Õ…Gp˱•iF}¨qb ån¨nVj§$Zä>ÊÍ’»–Il6«9z†‘Í2›ŠMÉ%¶æ9‚’¢”}\dz~uqXu5ÓSÈ3'”Ç4‡‚Îfœíý<÷.ìªvËìÕLGs!iÛúGçûþËœ)2e—74FïqU¤8ò¶"ê-wðëmÓ½8ëݧª?W»w–ô+•†V%ØI;RþãõnHÎ@g=ëjõÏ…¯±[-÷h꣨†µ¹Ìgð8K“œƒ–»Ò0摸 š§Nõ§ßîUV©éß¡Æ ±‰©¸ÿ˜>û$×Π郥:©m6›%×RÛ`* Ö4ö‹ñŸ[NØu¼ÉÙ´ã<ÿz…½_hb¹S\©!lò›æ1ãSö‚Ü–íÛžFê2ÏE1Ž®–wÒü°ŽÊ ulÙ—›œûÕÀCnD—Tê„vRÓ`“œ! )O°¨Œ«óž^y$“€Éö}ÀWÊ(Û冎Þû•ˆï¨ðà„ƒŠVa€¤ZH8SHW ^mæµÁÆqšƒš¯ô•!÷pá¹]' :évé}žó7§ò®Zc]]T)—8RR’˜JNʳsjYåJ í€1Í[ºg¯.6+|ôv‰]ê=/vÇ1ÿ…»dyp9öU FGp©a®h|qœ´ýYØüáSk#šÆñtù›õ’ÀYŠôå=q}M‰ O>“x +yd€”ùä’5_´ZÛ,R1Œ´»Ôq«ô·c—Ãõ n¬÷ÿ»ihav¢¤gî~=Ê–ž _…‰ÓeºÚ4û¸% î§V”¤“û$RíeM6÷¿0Â\æ·ÙÎäçé²J+$1Ö¾·—¸.o6B¹Fâ¯Þ£agºŒeDå¸}CŽy©˜²ÊY0t®Ôørøx•×.•õoSiïÎëí*Ó3ÿéÄD+zão9ÈiyÿõjÚœ lÚ«®1SÕ6香úd… —é {1¨ã4àöZÚýâ46ÛÅ=²µºbœ$' 4íÉíº‘Þæè­sÒ™`Zï6¤Û_iˆ¶›cn®ÑÂp㯩D;‘œ¤ïU íò†åjdí–AP×5­…º b Ýù{œCÉÛ Çe9AEYIt,xkáp$Èí!ùì1·ÁÊø|øcw[ÿëĤk¥Ÿñ_=t»;‰Z ˜–¸Ê>¤‚q°º¤žIkrø/ÐôÓÃÕýa †Û©¾færÞÆnç·8ÎÈö£x…׎̰ôû<ÚçŒz Z¿ªG~@àrRŒ³FøžëíÚÿ¢,ï1gp1i°ÂCxqQÛHCIÛž qø¨žé}½˜·BØÆOáÎNOêw?+D¢¾Â.!%ð×9ª4Ï‘®òÇ>êÖØÞ’w]ÿg붪ê5‹¥úAÍ5§:¡l±e]É1 ’¢¥ÈXÆTér22N ­ÍÔÞ%Ô̵ÙælTtô‘y%Ø.nN5<œ ±³7É9Üã›ßá5–zêöJꊊ‡ùšK¸Û£áCú‡ðÏ®™zçzÓzŠÇ¯´äu•º»{ÊqÆrr¿¥)Q-•¥$šªõ—„µX¤¨£–:¸Xw|.פo‚í€;~"Âö´œ¤º[źtÁUàñ¬ øÜ‘“Æ  áq?Z:ÃÓŽè‡uºÔŒÚ}2¤¶Öܹ!CúGu¬Ÿ·sUN‚è QÖŠ{|eÄò¤wÊÑrêX)úº—iŒ;WæoâÃã;¨wSl’ûÖŽD}KiBή@yãýNcdŽ’~«ø?à­³¥©õF5T¸ Oÿ!ì?ºã?üRª»Êø ôÁØ{®"qÅœ³ŠÞ-ÁZ>yŠN&Hdðâ‡â”µÜ„Ïø”ñ~-nÜåã!Åù¬›JÄEþ§­ý19Ë‹ý)ü9‡²d:Æ¥¼¸­ƒRÈN÷‰µ°¥›×Õl•±¡ÑÜ«?šMÖ–öNcñAÉJF¬tñ¹CóXj|¶¹•gÕ{?šk-†/e7EâiîSì}Wt^yãíö¨ù­ÊåAâkù%=żÜÞP%÷{óQóQD ßlêJÙ=J] T·6•8°5 QlÛMlòcYV•§ßXܵš®W¹­ lYay¿ô•¨­hW’8­qz¬Ø«Íé]M¥íKKl‚2qýëP]ëqSð ôû.ŒÒ–Ò‚ßÖ°½U‚“—Hi‹y_¢”¥a^kY\§nI+ÒpÉ B$Õ&ª@O¥#,Ø å˜êßµ1<à¦Ì8RÍaaÔ•K88åDJô½l#hÜØ?jÄ´°j ¸“Ù vÞ‡3†ù5Œ%î é•DrTfvŸŽêTTÆ|g**}ÓøêšUS¨tK2RèLqýªÉl¿¹¸ÉMë)Xá’5ë•¢Bœ.çÅm{WéÆê_fc ™5WEPê]YŠG‘ÇjÚ¶Ž» •¯¯"É7r®°é bzê,,÷#ŠÛö^µó1‚´í÷¢ÒH œoú3åC… (ß#½mKuëÌä­=xéí8ÙVs­)Éoƒö«\5Œ‚©2Û‰)…Ë^2•sÅ?mQ zRÍ‚F»rÁ KjüÓˆ+@9)‹é»”Ìõ·’>ø©FV6 jVçtßü,%@ŽiÓ+[Âa=!Ç¥%v8ÓŒ{gÅ8/ö )Ôù;”É*2N8=éÍ<„„ÒZ<¸Q÷báJÈþâ6E5Î$¶J¼ûÓØdÙDIbÌkb°MMÁ8#BU3$¦'š’9Íš°Ùâ“4Þ` •™ ‚Hóæ‘. =kõãÑ.”޵㫾Ébt l-.ítKAi‰»!´„’7)J Þ¾CÙ:EõäÏ#üº`ðÇI€í.p:Fœ‚IÇåÉ_[ï7¦Ä<–RHor*Åø£Ðìô¢åxÒ©ÖÍK=QÙvC°Õ–Ël(§#ÉÝ´ãÈ5I¸ôä–ëüÖéelÆ`½‡-' Ž6ʶô…S*)Z[°y|ÆMª]ûQÚtÜ9rŸ-¸‘Ò£€§\XBA>T9­ëÓJ›Dt”Õ$„4rv ª.ñÓ±óÈpÆŒ•/Ö=*×]*ê%ë§:ÖÔõ£T[$ü´¶T?í¨~qÆ"˜ßé䣖ZZ¦–I‹\ÓÈ#cù{ãp±±=µ1ÇW ÕÆAóöV;6[™— *ŒòQ¼¤€SïŸjÖn¬cA9Wö¸i?¢ëî uùZÏEhŽØ-ÓÖ U½˜r{jŸœêGÔ¥,’pš{âPCužAˆ¢hh‰îçûÁAôŸK:ƒ[äv§8“ð2Uky´H)Ü8üþ*ƒW-Ý^Dzú1 ú¤õgÀ]:ã/S]ZÕwUA…Þ… 1è¸ÐÊœê$•c¶ÞÜœoÞ ðfo èzÌNù%–g7@ƈ۬ÆsßS½.È=ÀÓÉZ’›®&g\t`Da.Õß#|Ø<./ÿ¥ŸµèM©$¹ÿ¦»9%æ¹þ–Ü-çû¤ÖŽêTÔ¦'{1õê>Õè÷O‰8J"IVÒ ñƒýé)˜SI¨a˺¾ ú‰ðݤ¯K²|Gh³©-ë­¶»’#—ݲÉÝŸU¤ç…áÈÆ<šè¿.,wwUDæUJ?•0g™ i#aœ±ÁÚ\«Ijm=Fg¥¬±K†Dâ^Î5‚{ücl~kšn´£Z²ém—wÊ…º#If(qKïéîAP 2FHö5̶øšXu»;9#Žãþd{¶Ló6f´îFqôZt§Oõ¾Õ¶-£­so×û¬Æà[£´)åœ% «÷ 51ÓV û½c-öÈŒ³¿8hÆNO$ $åguê:*WVÕ¼26Œ¸û(.²Ò·M/}»iëäe»B¸²ZÜ鸃… Œƒ‚c^·Ì†GC+pæ’<‚üˆN™UDMžeŽJºA®u—MuU»Uh[åÒÁ†¿U·âº¤œá@p¤Å' Žâ­ýâ]Ϧ.,¹Û_‚1©§:?ÂðÈúñÊ€ê^›¡ºÓ}Ö¶0àx=Á÷Ä|.ÐêÆF Õ7Dßú]¦m ºÜ-ˆ‡©Q§ÔÍíÐr· r„¬ò[ƒÈ9T×YxÆ×Üç¬é ¶ †$lsHs²I# n{´sß9U~›ðÅ‘S6ž÷)¬òÉòËö-‡=½ù\¹Ô.©ë®¦]ŽkÝUyÕPÚYmÙon ´žÛhKhð+Zõ7V]/•_}ºÎédÆqà͆€>Á³tõ ¶»ÐD#g8Ϲ=ÏÉLzI«œËí˜Ú¢H¹Ý>eµGŽÚ Öó@„„ŽU’;õkmGÞã±ë“P!¡¥Ù#|içé‚—»y"•æ©Á±àä“Œ¯exüIéN¡Yuàw©fÜÆ¿¹0ÜÉvÖKo[ʆRÓí! KníÆPyÈ©¿-;¼¢ó¥µ/Äk@n‚ñÒÐÖ†1–¶}ò« q¢’Þ߸gÈnC\wå§' ûª< ênA\wM8ý$öóÍRäÆ5k’v`©åžÃ>ë/8LFSô¬îq?oµF˹Ëw*¡w¾ÅLpNJµ,–$X¢úß"óª$e{?æ¥(ˆk•„Ÿp6šÔ}GÔÖmœª“—=gZ+eÆÖéÎjÅNÉÛáP^Ì÷Ní% éJý%/np8þÔå²B×hx ³‹Ù¸QÛÅé‹C+}õzINMGT]Û¦>SÊZ *Ÿå€¨‰šÝëì§PÕňd§xålýê¬Ìÿ\¹+hÚ:J8Ú5áa½ÈZ܈ü‡*ã¿ÒjàÒ–ðŸËÓmdí¥‰™kaš”¼FÕK ‰ÈnÊïg¢:ƪ†ù‹ËL6êQ¹_RÉá?sW»Lˆ[:p5Œ,5$˜q¦¹ µ¢KHîàÜ5í²'¹žaÙ>†>>™DuÝväЬ¨§¾Ù])zÑý3U‚5ÛLë«…ÎèŸ^ˆ¾–Žv`œ¤vÉÅD\›11ÐI¨œ H ürÿ²¬[î7U« ÒÎĦΞ[õ&§’ö†³Þøƒ‰*mn„2µ ê(ÕÏn|ÖTÕUR6†—‰È.ÒÓ§'.'l ÎüvR}I-5#~ý35hö=†Ãœ¸L¶M;nbT÷®S²ûjØÊKdúÜUœñïûÕ~áqq`lJÃ[ËZè†Ý[šAè°ÞÒm±ße@'æk\òS÷ñÏU¬©,n§ç·ÏÿyP׆Ê惬ƒð»s¥ÚïFËÓ÷] ­n×C*•e‰m€—Ñóer÷ ©JNÔ$gjr¥jؽ w³UتlÝC<‘é&Hȃ—õîK†Ñ-Éqö:¬ì·(«ã¸ÛbkŽd.v“§Ù½€sÜଽsþ'0øTÐ:ƒTõ¢,)fÊí®ÏnmJÒæÀ0€®_yjH*W=°HŽµð#í!q»¨jhŒÒº/&&ÆÖµ”ãN—I#œ˜éy9;6Ùhþ°ðN9Ú¨j<– q9.ç h ~|¯ÀwÅgľ¶ø£êΤê6©äxO¾çðëj¶Ç'ém nìT®äçí]5á†ô=1je#F¬eîÆîwsúðªiÕS\¦Ò 4a£üþ¥rú¬` ÖÈk½Ö¿’7 ’U4TSÅ,×û(çÓêå$\nê ‘K6]”lÔå$v9Ç‘J¶ESFp‘®2sÊp?å²áEÍ@ÞRGcAÁì)fÉžTUEç²H¶çÞ•k½”|”€-%…yÍg¬vHW-E¥{ŠËXM]ÊÇëdš÷b5½K•(-iáeÒwBu@äP=—’O#½9ÂL´º£úÊóïJ‚a,RÎW¨eÁß"±{ÂÊw…¹1Îs‚>õã¤Ù9Ž‹|„­¸®¨Œr)ÊÑÊ’†ß!;'&!¹ÎMŸ+Tí%±øμhg cšc,êÏAk;aJaAŸ´âþHÎ< ´Òuõ€RR6A°\»­úhË©t"8W'#mm{UiÆNê“w²µà‚k®‘¼=e&*IíÚ·ŸOõ£NrÔ}AÒ¡ÙÙrv¥éãð˹m! ÷·5£©AÁZBõÒ¦<–œ*šãbu‚—Àö|§¸6]ÉZÒªÞG!E¤C);T6óN™0ì j)ˆÊdr0+Â}ðjRžc ÙWdfå5\XH ”• äÔóšÂ}%6~{¨Ä–2Np|ãµJ™,ð—&—!?¨ç}éHÞÈLݱMÎA){IüŽõã$$é 6¦-Óèˆoqƒäb¤!˜IPRúŒÌŒ«ÀIãÏŠ“§“¢k¡*#!½¤ϵNFý[…^¬‰£”Ë (ÿNiËeZªnùì“ûqKçdÅÛŒ¬½§¶k&$ý)Ý*QÁûR˜Ôd³l“©G‘œŠbâ± í$ ÒŒÒd–‚ïÁ¥R0Ê÷4#QYr…qXžOlP±+ʈ¡¯F;¡âJk٤Њ÷d"ÊD¤„€œ5ë¼ÉÆ®én¹-yNîNq“•qÞ©ÝE\^É's·ÜïÉ?Üû“¸Ù÷H›mô°8 ¾¬áÕ›Pvù«m+§Vt7f‹}¼Î Ýò ÒÓêåçG 6â²FqœÓÞè{·RÄkêædQ0Ù,®dq‚=Z2pâtäú÷gÀÝFTÞàµú!‰ÒÈ㨱™.?#;Ì€¹#ª–k‡Õ×?¦ú‰¥ú™j`§eâ·ÑI#$6m·8¢Øœ.§ë÷Ã¥ï¤Rø˜èÜK„«˜´4«¼VÞ±2"W–V„ä}+OÖ{kPÖô…â•Õöº©Ö[ÞIŒ—`‚ì1á¹ÁËH:ˆà¤è:š’µ–ûÄmï ϱÔ í‚É ÖVŽ°ü$t*Á¦zazÓtÚ×6ÿR¾ÛmźÊ~Jœm¦H.¨%{”T3Økdý +©o6»]ÒÏLøééal29à5ºÉcN¼;SöÜ€*+ (êmwjÊZ©DŽ¨“[@9-hsíì¹wFhǵ«—Wš“mB!ET’•¯ù@ôÚF Rñ“ì$šç#j”PMXÇرœœ¨à` ÏÏJÙ·fÁ;##%çO’£ü‹Î>ˆ-Id#…%Ò3»íPäHÐ „û+U. K]Ù38²‚¼qŠrÖç,ò³€âðêËîN0?µMÒ—£~éÑù›aIñɦlnN”Ò7ZQtJÔ•:¥}ûR¿tßd“k;/¯Rþ ~f|ü2iKÌw_ê溩7ˆv¯V<Á ©Eo*@m(R”T’T1ßší/¯-žÁ-ȨŒùDŒ2%pΰ:Ž}²¹›¥lOòè^5SÈ?–_‡1ÎÎÀÀÆÇeó'ªHÓÌjÛØÒW7¯:mO©Pä-$)mFà|ŒàýÁ®$†˜DçBHwú®“·H÷RÆen—ãqØ(ž›mo<ê·¬ñé¤n’´Œõ§$©Ö ¥íRÖ˜Cw F*—9¹ ®t÷@ú{¦:C«ýt×r¬³ï÷fi]#gŽ^¹ÝHD¹n(zp╧ «rÜHú@ÞuÞÛìÖf\z†¨ÇQ;5CNÀ ÜÒ=/{Ž[s¾$´oƼg^WÜnßÃl´úãØ–g,rÖ\ïØ*«§ýjÔ=;°Î²ôúËj³kiS’ì}S º›ÔFÊ6|´gR B·JRIÆìqUNžëš«e§´Æ!«.ÏÞ]çi#s†´ç} 9Ü…jꆲ§Ï¯¾œ7S€ÑžKŽÙ?žÁ8ܬ:ÚÃt´uYÝ ßu“²TòàÝ' òÇËÅ)•d%d+)ÉÔ¯£ªemÑÍšYI$=âGð7 çmD”a¹ÐINú*F–DÜ`´ioÑ»`¢—_#ÿ®Õ)g–˜à:µ=ê|ÒÉÉq\œ’p=»“ÞµÿS:7LÖRÂèÆ7˵j?âàc㟒yTãïŽ74¿PÎØìž­Ð[ØÓ y¥¸ó€šFcå€Ó—*EÀ¾G'Wæ¡Je©¸ÜfóÀì*b+œ€69œC¯½ŽÕéIKÌÉ`¸Ûém![B«Æí[O$%ÍxÏotê gÿSVµ%¸ ­m+êóÎIªÌw YøJzÚ&“¸U¿R¡ËŸ¥þn ‹VÕ}iŸÞ¬QÕ@^Çg9ý•»¥ØÑVý—·>s$)Àá _Ô’O?š»ºš7E€·e=&²¸ ]Š—$Êx1ô}#<þÕH¨¤s°ÖŒ¬¡·:W‚Ö¦9w7g:V7ú 䨟ÕO᥷Öà¶ÇÊ“Ø®iˆÓCÒ¶a”¡\o÷Qö¦54ó;,ªiæ‘ícvo|ªöèòVµ/é$žÜÔõ$dà¬ÆÜåGcjVÞP‡pO½IÉi-õÈ—0»9 ñвe¯t;UÎ4 ƒ¨;ŸuàÚ[H?_ŽØ÷ªð|ñÔÂítŸÕDWÒÄ7™¹oÓ)=×R]XºC¸¢h‹.3^ƒ.Fm(V9ÉÈ$äýGšö ¹$>gõ{ñÿ ’‚ÉF='~JŽ´ãN¼ëò甆U“Üýé Zì´ì§ §ÆRˆ‘îs÷˜ˆyúˆ4œÒÅÎåH’Ü\…>ÓQ/蓶Ã|Û†Ò0ÃjZŽxàÍEçrî¶5®Ý¤et~“Ó )l©¾}ëW^nüà«\mÀ]-¥ôðoÑ lgߪ®×<ä’¦˜Æ®‚ÓöU,`gÍk[*F#¸W-–ß³Ó2š£WTž+~Ë%-¨ŒU.á>ršM¶êĈ‚„€“ùªä²út¨*‡eÙN)mJV{Ó [a3t±•S)ìT[à ŸÑ–eªÓäжÛ§'µC¼y'tý²e»¥ 3”’ROéÆ r“{ñÝzëIJ27vÍ)'§Ô‘¸²)‚¡ŒqãŠOΕޜíù'M—!4J´%ô©%!tµ4<»Véã+€Øªêû¢X‘¸¥W ÷ª^žó#]¤pkkù\ï®:n‡t½l;'R9¤^¹Ûó²âwÒÅ%oúQŽ 9⺦zà –¡½tÞ¢C†W!êΛOmÇT˜Å¬qÛ½n{7U´Œ•¥ï&uDÞt\ÖœWòÈó[ ‚ûÆ+TݬaÇ*ý‰Æ;¡cžx«%%iwm•¢€‡z”zU°e[ôz•†w3wn ƒ¨(ä¸ÁAÛϽNÒU¾Fés¸Q•ãdÎä"“¸*béÀ*&FoÂe”Úš;ðOŠÍŽ{N餴åܨÀ„î+Ÿ»IÝEÉVC ‚HàÓØŸº©¥.ÝE®qvà“ïSTÓ*Ím9ߺˆ¸ÚNwTÄoUJˆ°÷ȧ좜Ü$ª>i@p˜<­%Ù>)@vÊhú|ðµ†<‘ï^‡$ +I$W©;/1Y‡“, #<ç H>>ëVkÔŽQBBYå ´¡ŠY½ Œf”+ÀP3ÅbÀ½^V/å¬PŠ²J¶æ½Ïd,Ò¬ç9¯”$$‘“O‰Õ€°`+~”œã'·Ú– 4ebçv^4\ ;NI¦U.Y0ìgÕBJÀ#Å{yÝbò”ïlmm! Ó‰$hÃBÄ/JGÒ 4e–’³CŠ»ô¯c„j!,mCy'Î1N¢ŒòWºÏd¡)Ë€ g9h½Öd’7[T„úF3‘M ‰‡:– ÎwIÃ'y<y¬j `ü+'dp²Û´p¢ :§hòÂÃQÊõJJAíÀ¬æ1m¯•_½Ži=fþ—¹ZײôÜ»› Z“`ŠËÉUÝ‚ RË«H „`íQï_"º~Õw¸Û_m†¿D•gÝÀ~©q»CÈ£äç<¯¦—¥$M“ÊÔÖo¬ð?uUÝ$ëΚXº³¡ÑfÕV§ý'¡Ü%FA[HA )µ 8ävªM'QÜ­¶ª›/¯‘¢VÿO ãIÀîwçØ·PCYY Xs\@Ë}ÿ%Dü/ti]aŸÔ};hÓ½8¿j±hQ·'PÜ—Å^ì©èÀ¡Ç€g=nn…è[æÕ[5²ž9%òˆÜÁ‘êcKšq‘ê8ÙHõ—PÓÛ«©ÍCÜÆ—o†ä;àñù*‡FôëQ±¬µ5­¨*“t·‡“ ¡Á²0o;ÔTxÀÁæ´Ýsf«¥&…Á£S°8¹öVJ¹#lÖ ¨n.‡ÚñZA8Úx¯m‘ *æ1ž¢ªY×7JÖVTqîjß Â`úá¾ sÒÚ…è“Ù~‡[’Ó‰q O*#¥í7j»=|7Jhš´ûsÿÚi,­ª‰ôÒnׂЯºòz;üLצXÔ‹.—êÐÃ%Ó?õº²BÖž@PlÞ‚sÉ p6ÿˆ”u^)ÜkúªÓJØ_K£ ]©ïv¢I˜Û³ê'¶¦éÛ{z:í’Ë® %.kˆÙ€ò߯ùî¹:Ç¡åèþ=Uj)ä»z”Ü[ å>µ:ê–ÔC O¦Ñ?Rˆ*ñÚ¹Ÿ«Åcì4žeN\ç6"\}:1¥˜÷$¸lZ†Ix‘ôñìõíß~{®€øsHi‰Í%gÕ–ÛL=vfE®Bn’ÄXÑTóe×]ç oqQíÛ¸­ÉöE¶Û®—Jû-Þ6¹³SÈ2÷¤j<î]Ž1¸ç•[ñ”TEiÔÎ!ñ9®ÃFIß…KüKtîÍÑŽ¶uEÙ¯zkXÚ!_+>×$=¥gpôÖ8VÚ~õÌ=AÓ.¶WKj32S ´êÚšáÛß±ŽBÜ3w7;tÇ0¼n× 8}B«gô¦r:|ßQ¿ëNœÈˆä¤ÆE©‹º\ºä­qw!±ÛrˆÉí‘ÍX«zhÒ[a¸ºhœ%8 l2r]õ40sŽÄd[ú†*š÷ÛÄokš2Ii ?Ü«6R¤)YàƒµU‚®Á ä)t}­ïº~ñ©ìZbÿtÓV🟞ÌeÐÉìwô¤Ÿlæ¥íÝ?]53«bî…‡á®-ð €ÆOaœ•p»ÓG3`’@î;Ÿ V®øKø•Ð?ÕeÑÝu¦:zêqY°TÓ. ¡[…gƒæ¬½EÐËD~uÒŽX™°Ôæ8OœzOÁÁ쫶^¹²Ü'u%TrJÜå¡ÃVÜíÎÝÕü]Ùn5ê&3JH m)Àû?5Jž,î­ð ÒEôRF¦LŸ~ëv£»#M[v:Æž´°³;S;ÉÄŸÑŽ¨ñÊðp„äîM³¤-¶(›%Êõ)"ÃaîVÙÐí—KÌíEd°Å°[%<·™·ÅJƒ1[*8mG$ÆO%¦Á6 ·ý‡Œ¨äÔMm›ÈÍaÿè¨Q-MFôü(̓Q¢Ltº–÷/¢T<Ž*«UPö8=ÃgTtìpÈIa8õ@%ÃÙCÅ{E‰23ù¨Ú‰Èji¸Éu—‡ R¢ŸÔV3þ•u—Ê>ÓÛs5Œ¹n¶úÊ {oòIÉÈíU=EÅNyy!¹Ü¨Åã^Ú¢Ï,$8ë™Ç“V:;qwóô]-;™æ³× j,DBmÔ‚wVvûw1ß`­}3ÒΖ@÷ìB«tí¥z­n.,6\’„-Å’8HÔU‚²GSìNËgÇnû¶5pª Aw”ÅÕèRŸJ°sØ~*ßm¢c¡öVºX4´8 µÏ%…™T@ÆÑQµTØw¥X#ŒóGØnºé‘íPÖâh¿!Ò>˜íê'þ<Ó ˆHä¹Âeu¨e;Cœw;î:®®•Ë§--·ë8·vㆮ²®/¶¤IwRÛJ@Ø’sôó€;šºÝêláñÉjlŒ4 KI/îæéàðÓœm¹L:vK®.ZϧH ãØåQ4ê­÷R›ša=ÌI åM Þ28WMššËÉ’ãî V‘Ý#þjW<ÒÖì•š t–µ+ên³Ò— ÓÈÐÖg춠”¡¦ä=꼬 Z€Æârp8ÅJSÚ™æ9ìÈ;r@ÇrÎù<&všZ¸  ­ptžãaù& >‡Ümr®mº¡ôñÛÿ¥3¹9­:"SfêÏ(²}5¸ÜXe_Rñõö¨*¸Áß’”¨¦È×Ý[–ËÛP˜,S&DmHô’%µÈI á@ÙàûUb_¼Fòâ¶88ÛÙBÕÓ5¦vƒŽÄg  âô"Xø|‘שš’$&¥\ª%¼¸„ºê¿˜éî(íÉϵm Ïêàèöu•LÉ/•ãyÔáÿ´c¶O¾3«+üSþ ÿ§a„—FÍn#8ð8ÆÉ|‡ø›øØÐÿ·iZKF6u×P[FT¤/dXK#‚껨ùØ}È«Ç…>Wõb²¼ù4Ùú¹Ãàvú•‡Xuä0D#/=¿Õ|ê_Q5gV5ó\ëk«÷}C=âëî¬à}’‘Ù)ØWÐÞœ°QÚ¨ÙCDÀÈØ0ÿœ®l½WËY1’Sº€ú`jwPPßw>ËYc'8¯D‰Rdç Ye> ¦²’4ì°SqÉû×¢D‹è—†0(9ïY NV·‚ß”‘LŒmÏæ•‚£¤£ c ›ý$S€ÿu%?°I\krTM.רù郆Á \cžÜÒÍ•CÉAì´­Œ‘J‡¦²Q‘ÊÖ#¤‘EB@•àa<Œk/3ås ß•'º1ûWžjÇø~{/D0¤çïGœ”þVÄÂ8ì1XÂ]–“…½¨=‰¬MG²u œå.E¼gôóþÔÝÕ?*b+(ÎÁ83Œ'4ƒªBš¦´8OQaöúqQ“N­–û_'èÐsŒŒÔ|Õ ån³“”š +ôð*&z–ÀµYÈ<)ý¢Î§È%¾8ªåmhou³í–¼p­Û•*Ú¥6J¸ñTËÜ+ÅÓ¾ÊóÓ:Tå¥mÁì8íZöëx!MDÝ £´Îœ îl…qÜV¯º]9ÝOÃʾ¬60”·µ²Mk»Ã<•!jé±ÚhJˆ5C¸Väá.ßNêÁ… 9@ÛUª‰“–¿ebÚ[#ÁÍUëÈMê¥N£$ƒÀïPÕrw'fÒ€IÏ÷¦Ïqá1q){ʆ "×c”ÎVçt¹–”à Ƥ#º9£4u8;¯[C¨/iû“MCÌ’‡!Ä4c)Á–BR{æ­QìC“I$ÊÑ0,9ÍyX=)Å8ÁM›‰Â jïÎÎŒ'XÆéÆ+AIå9©»| ‚0™Í! Éàà$pœj’Ž#œá{ ^{¨4ägÒ­è*^<ö4§Þ r¦é¦dÎú«B2ùqM°•µk³_¦•öØËr¹K\tËÔCÅJ¶;ÖÚ°uXÖ0Vµ¼tùÁ:W!jþž–=}±Ö1œ95½,½PɃÊÓ·îœÉÕ…Í‹L8îîd§ÛýkkØoŒÇ¨­%|°½¤ì©ë…µÄ-HRTœ“ãŠØu´5ÇbµÍU±à’T:dœýE’F*Q²44î´®%G䡲P”ä{ûT-[€ Ç'•%(纋\"¡KV2⦠s†AL]Nìd¨döP•”g'ß Óºˆžœ¿…‘ô­^=ƒe # ¨ôôïÉεIBÿe^«`PéL¥…MÃ.Ub² Òâ8VF ¾Ã÷]¯Op¨1ù3<8wÁÁT6¹ÞÞÞª6=\«5ŽêBçTâc'¿ÑÂw}È8­7Ö³]›CWL*TSœ½‘´dûa» ƒÿ2¶oKÜ©„ñ½ìÌŒü$žÈÔh=kkêg©Ò‹µÖÓxŽë¯B˜œ²ë[A$ðñZ£:Ê®ŒºJ¸= ä·?ýr·ÝâJJ¸ß™³ˆù<.|ÔrµWEÝ$I™:CåÉ.©D©åIQWœœÓŠETàZvS†Æƒ}#e>é¾–ÑJºÚ´äÍMJK’CAéI>Yí¸ŽÂ­½'Ñu7Zÿ¹C3÷gN¬€q¾3ÙT¯Wéé`5RF^ÁÎ;u[õŸ¤w^™k λ¹Lˆ®–Ãñ\2ú|- E& EL”UmÓ,dµÃœò6!IÓ>ÚVUSœµã#ÝRQa.„­² sýªBYÃÛ‚›6›IuÿÃ÷Q¬:ÕcSê ¨þ",X²n2¡¢$—µwFZ¥7É*ÚIäS{/QÓZÌÎs˜Zß[Ù¤“ø½m‘Œ¬/¶:Šè£K冸éÔãqßÝXvËD©ë”ן.-Òâ–UœœääçÍhû˜ÔOr¬ÑHß0À`'ïž{KÜ»I>»éAKI#ƒÜƒÁŒUƒ¢úöÚè«¢`–àt»‡àü%ëhÅlFÁØ•ÕýgÔúÓâïOAëL¨½.·^-v¶­òlÚr*£ºÄv>"JÆõðr’F1À­ã5Ú¯¨+Õ±Á"x세˜ƒIÊœàO¤¶cÃë|(Í„Èóê$:LnOfœ¾.h]^õŠ×«ôŠ—`‡o¼°–dH™mnKÌ”+rC(0Tx*F +_EÔEnž‰±Fá&=N®iÜ<‚ægƒŒgº¾UÚ3WQ.Õv oî8?š¨§¸†q?« #rON2ÐT铸]wðï'MõM»‡Nú Îº¿Z­–9rmOÀuÕµfm´)a.6„”µ¸½Ëu]¸­»ÓÑR]íµ0Ý$˜KK ™—5šrC\ÜÖ¹ÜíÈÊÕ½R_EPÉé•í€OÈ$îqØ-7;ü=ið×"Ò×T5bæ鹊iý8ôÉNÆ}µº}9B•è¤vI?«8ÀÁÍ9ë^¢»]ì4•õ·7Oåéc v¼³s¡ùüvÉ%À>Ad´RÑ_%Rµžo¨H2}ÆyÏ츢WÞp¥ Q%\qÞµDò´ ’¶D®ÀÉát†é¤©i‰6òÛ‰†UËh8YñPú ƒ œdsûªûªÙ rïÙu­¶ [­¯Z µn~8šÂŠÕ‘ØÙ·j»ÂøíóÇ5;8?ˆýN¬òZnå{š¥ŽóŸœ©r¡?{œej ÜdÈ €ëƒ Q=ÎxOzØRÚt”T]d/{øûðpöUÊ{³©Æ˜†ÉÛ Cꃇ RæÜG·½0žÃCK‰}ñœÙ,ou ’ÿ›‹½çÀ;ŠÙŸ¶G#ö¤ê®TôÌ2>=cÛí¸L^é°*.þ^QœøC”HBwöÆxšÔõù‘Æs³Np3•)O!v9Uvxöw&–d­À§”æÝ òr@­i];\ávH=¸V§4¼¼wZÆiÆí0ÃkuC;þiüÕniŒ~Éj{ ¤õ˜dß ÆfD‰ò]NNOµBÇKçlàr¤ ³Êekr»‘% e„¸Ìsô‚O|ÖSY<¾J¿Qt¦— 7P}Aä®L©Å€Wõç=©›l¾dD7²Ù´TBH}!2^¯N\c°¥¨ »ÏoíR4-ŒëyV+5›ÉÜ”·Mê´ÄÁCÏ'i_ù'q mTö V¦ƒÍsI<.uÖÉ‹»âyyKÜVFs[.É@Ï'ù‡`¬ÔÐeLìvÛ¤ˆh“!• ŒœT}\-µ¥.ÚfóÔ¾6¡Ÿ`mØmÌ—#É }¶Ü)Œñ¸ÕûÔsb2´†èqî’–ßÞ$-Ä+7‡R˜Ä#?¤vÅ&2íÔ…4` 9I­Ö¸PÛZ®¤º¾ DÕVH÷b1±NüÒ–¨–¥½Ì}ñÒ [# )53k c[®nSê_úrÓºU¶[¦º·åŸ«o|kt¼1Œ59{Gu?‹àâ$´ò!Áýžb‚Uuó7ld’Ög¹ç¸\ýÕ=i®B(ð÷_)&É—p”üÙ²^—-Õ¸ë«*[Š=Ê”y$ûšëÈÚÀÀZªV9î.qÉHÔÉ<ñûRþhî›ÉJJÔZRrp+Ñ M)•ç¦¬vâ½Ö¼u>ËJÚíÀ¬ƒÓYirV‚k#*OîAeò㸯D‹×PŒ$ÅŒ`ñŸ5Ÿ˜Rl@H\eg˜å²… =+¸ÂD¶»dFIHáÂÄ3ÇÔž{RþÉSê ˜IàñûR‚_u%rÀÇk!"nh‡K)J¾ qø¯L¤l½e#AÝm sƒþÔ™“'L£JùVTé” zbšHΞ²Û춡¨ä(cÚ‘}@줩­ŽáÁ87g±¦¯œ©¸-9³má?éM$Ÿu`¦´ lÄKy*IÅ2š£eh¶Ù áI!Ú–²’O55` íCfhÁ!Nm:yn­;ЬµW«.@p®TVï`®};¦0ôíT{¥Ù^( ÒÌzX4ÐP@K| xïZöåtß9RÑ‚ ·¬V4°PŠJ¸WêR”üŒ«óKÚÓ±§ƒÛíZâïVr¦vWmšÔ[ öýª…[ZpIO!Ù»«B ¶È;@Ç|yª¬õ$œ,ŒÙÙ;²6ìÆ{Ó éë8S{RT€’9ªõaÝ!RrÕ>€Ú•ŽÜÔܪÍKÀNËŒR Ý´ãÏš@´åG¶pR`²Ns“I¹½Šq„çåcý)"ÂN —iSˆp–•‚c¡¶Œg*¯UTr½šÃM´O íŠ8l %cM)s°¢ÏòÎÜíb«¦·$«ÞÜtm ƒíRLcÏ3„‹æ9Âpa´¤ &žÐÖFÁøNS)%No%°J5j§p”Æ"r£QWÐÅDVM©Ã`§håpPK•®;›·#Þ¶vYõ7áæùðûn¼ê6µvªÑö‹£DÙ-’­Í¦U ‹ï4!å&0Ù…zJyÀÀÆi—Uôߥ)&¤¹Lè9ÒÈË7–0q®@|®ÇIÉ9áYl=eE{s]!ÎñâpáØd ÷ß…Z_~u}³IZµŒAyì"K&áh¸Àeh_é(û mcÀãäÔmß›­ çéÒí?ˆKßT±1œwÕÆêÉnñŠ ½Œ–ä _ÆÜ5ÄþÊŒÖß½WÓºmZº-™­W¤’âš~ícpσa[B]’Ð-!DöNìý‡ré*Û|"¦¢<Ãþ6úã8ǘÍLÎ÷'”=]AS# ŠQæé>—ü'ÙXŸ:’gL k¦oš_Wê¨W¸¬ÄzÕSȳÛ嶕bz#ì¤dŒ5ê!#’rq‹GHø¯k¶ÐTÛ*à–¡³˜Û/•€3KLŽþæ·Üº¦u­¸ÖÔÃVCA Pц·%¼`¼¹ÁÇúG¹L ¹ÁM¡ï¨’W°“—¾}À; `vI´·H¬VR’ÚeIã YÈŠ¯QQ¶Qš—~\{ë‰gik2½íVVä© 0ì6R€Tµ,€a÷«Ä4Âw5‘i!§Õ±ÛÜü-eYW(ßÔ½èiq–“×é »)ÝËuXä€0’{ qÀÉïWK¥5¾¥Œt 04n^rIü†ÃõǹQK)>ê6䆢´nGÔFÐ s»ÿF©êh¢1Éã…(Êgc$&Ñ-ä©Ç_JKC²•Ù?z\Þ[O#=—‘Å“é ç!÷U 4¦Þu_Õãÿݪ¥wPù¯u4.ûöü”—ð絺ÊÍÔF¶!2^’Ô©89i)+O#±ûÿÍGVÖSÒG®rìqÈüþR”ð=Ç *GXÏJX–¨¾³äàžMj*l>¤¹¼¶²”—7!r웣ɸd©IÀ>H­—#|µzu.–ä'ÛüÖ‹-ÊÖ1’1šŽ¡¦:Ê—µR“Ûu®Åp·1aº‘䛩y&2’±°7ƒGƒœÓêèâÆ·žç¶?Õ]èhet  hï.ç{$HTP¡ÀRb( n–ŽUâ‚ÖÈ=ÖmM1R¶C-)}ŠŠO¯|©/»œíÂfTÈÍ7!Ë£ÍÈ$ÿ-¼Ôƒaq D1ò•m)ÈÁQÆY*A}1Zyyúxíø©½ìn’p¥aiáO"^.-¯6ÔF[INÝÊNUûUzj(d”W¿wËÆJŒÍ7 šYù†ÔÊsúÊ0HüÔ¬"(‰ÑºŽãe/²3 I!öÔ~ÃœÔ%{ß)ádNÛ¦MOgÔ†agÓr3jÁFUÉIìOµIZê©šÌòSêO-Ã<¥ö+s–­ªÚe8xܾÙûSk…P—fìÍlÕcÀzT6Öìxh+PÀ*ê*­PÆÈt¹É ðün·1é-ß^s¯m';Iãö„•4iŒn‘–V1¤´nWÖ‰ôR+qo.?qÔjFæàFžWÝ^Ÿ¹?Þ®}áMêþýpá±wqãýÏÑSoP)Góç°_úýñ7¯zá<Ç— Øtƒk&=ª2°ÙÿÜéþµþxwG‡~[º~ cæ<¼óôÁi. ê:ŠÂZ ö\À¶œäœàÖÓNu1î–G”û׺׬¥ãu‚š#ú½{¨$ >6!c±^Õ˜+ÇE‘Œ-jlî²u9Æ0µqý5èzAô£¸Z‹|œVzÂ@À;/ ö5)7B{-+lŽx›]îšI :’žäf–2’1Ý%u G £ºŽ©¦p‘©“ý<Òáþê)ôÞËèÿZÏÍ)¸e¥L ƒY6_tŒ”{l!œƒY™d‹)ppR¶ãyÆ=黦÷RpP½¸ÉàH:e/á+D`4ƒ¥RpÛ€%­ÄPþži̥ඟdçPÆÞi¤•S´vÍCu"h+Û‘Q•5»«5-¥­<©Œ=>¥mPFážä¦’5¼)Õ›MvŸOqϵWën˜åYèhöÉVÕ‹K„¨·œvªmÂïò¬””øÆêâ±éÀ GÓÇQîCºœŠê°iܤ£o¿D¸ÜñÝ8`9V K¤¤¹MV¦¯ÔØáZúj"±<ãÚ©·Y‰åJ´l®kšœ!éÍVð@ÉV/PnéÂô– ÎÜç4ž½ò™Ô AMâMl!(V5b£¯ÀÀUŠšS•¦|´¸ÚHÚsI×W·)IOƒ”ÔÒ’I¦T±Îõ)’œØdåDµ\ÛC†aã1–C–Å- 8Š†¬cZpÕ†‚w[–¢¶°TIV;uDn‡ÔïWù$0vM2#¥c;ñQ· v¹§%¸)±øP$Š‹òõYO£ª ì¢×K;$¤¶¬)Yf,pkN@R´õÆ©íK¦›sÔ c#‘ù«=¶é¤€8IONBæ=k¢ÒëN…0SŽßjÚ¡,x%R®¶œŒ¸o¨½>!Ç]KKNsû~+¡:ªŒ •§ú¦3—¸ëUi ̼â›aa ã;{Öê³u4aËEuOÈÓéUDëA`-·R=±ØÕÚßPuge¯nVí‰W3ãGBžVã5cÅÃeUª`e ¸6TP´…vÅOÒ¿$î j©ÁÜr£/Ût(ç"Ÿ²© áGÉ@=J-6§ÊQÜãñR±K¶Ub¶ŸG 51’•xÚ¤©Ÿº­Õ°’¢W ’ÚIÏ~<Ôõ<¸Û²«×4–„Ĥ(ƒ•ø§ÃÊŒsr’€AQ=ÅdÓºŽ”vIF}€4»v)ŒÑç`’Ð '‘J‡d¦&ŽV ØR¿jSÝ6ã•ŠòF5àq^=¤ð²m’¥x5èÝ ‡}תG¦áH¬É"øÞËBÒR““ûW­`‘– 7)089¬“`p¼<óYì¼[(ï¯c Ð…$)G`;~õãÎû,ƒI@mÂAÚyäV(ÒV|„œä«ñY5Äp±ZIÉÉï^“’…åx…°(cBP;±[Ù)†3žÕè+ F”°R£Áï^€1’a8¡·RÂJ{ñOXácŸd©¦‰ZÎ8¬Ûù^†BSèîHW8ó^º®Ü¤‹½Ö@²ÉœvÍ%3°0ÞV럂„ÿsJË(,Öi:žw¡jløFVµ%yF#Œâ‡4íºÅÅ+N¶öõ€G {šV:cƒ¨ábVÖá-'p$ßíJöØî•hKÄL„)*à4› yüE.ù$¡'z†qÛ=éô§iNËÖ°»…èúPy=é'5 úxYyN^”‡qÛßÇzR9‹x)xâñ¯é/a¸ÚmÓwºáqÛFô¹J•à)9íø¯”=/ÔÐPÔºÍÚØÜg=Æß²îªú3C#K.ÚÞ¥yOÈ–ù|/ F úsžsö¥º‹Äšk‹Ã̧SŽÍǤïù,á´> ~ê'>-½¥­í·ñœ#$ÌàUB¦zxÞfsˆÆãóÿE)£èQ/áQ.ÁÄÉR”0AJG üŠòÍSKXÃæI«Ü"]$@*ÒóЋ¡žã²âÛãÛ‘õ:Ÿ©ßý‰ ò}ê0xoæÎê­^TLÜû‘žßÕŠ—¬å€ú»*ŠWÂ.Š½Ýî·(-½§4ë^ÅÈÂ3úQ7«íRT=,ê™T$1Ñ1¨‚ò=‡?@¬ñHÃXæêyý°ü3tÚ ´DÓ6;” ê̸Ê+—7ÀBPÒ>Àî£RUÒt³Çok¾§œ½ÿoÀÿîQpõõSÞ]!@6æTßAô^Óo¸±)ÈëˆÓ ÈyÅlŽQÏ?aÍ'Ð"ÖVš¹—¤ä8ŸKO¾O~ã*ùÕ³9¥­9ÕÈ÷]Pö¢Ör_jŽêR£Ýlµsu°ò’2¥%· gÉNrO~x­õÔ½qÔ—>’Óq©{´àÈdÒHhÎÙ!¬hW|ìµÝ5º˜wãßÜ®c•kzÐãËrL£-aAÙ±S¨÷%c¹>þk–íºÚÇ´ÈC‰$»VK¹#¿Ê¾Ô\]>=‚A¤×Ý|ÝÆñh²É¹GŒ¦Ì‰ yJqgBÕ½×  @R¸'¦ƒ¢î÷¢ûÍ3${XZ ¡ßÕŸHnyìÖä÷Æú~¬Š•ÂÏ $l>?¶>«TÙ:°À‘§%jÍYü/–Õ é®© GÔ¢?lRWÿo— so¹×K$mÛCÉ#m½@óô)å† ¼è"k{´“ù…žÝ.5‰:mÛî zɸ©PÌÇ>W“ž Ø9ç·~jQ·úê›K-3ÔI-(øÜã wZ0>ÙÝ!U] ª5"6‰?ÄÕÿñr•ÈÓ6ÅGÄX­£`ÜH*ÇÞ¢ª¨¢#SX6”k¯“9Øä‰ëUÚç6"•!˼ù HÚ ÖáQà$äd«·lÔ ]ºç[TÒ˜ùãQvxÁÏ'è±utLo° ñѺ¥—S7«úÞíkô$„ȱÚ`¦ºÜ–¤´Ù'éä’9>º'¤¼6é"ûÇT]Doaà¤Ë‘È.>–þ„uN¸Þn.Š s°?NJêEtŒj ôÍhÖVkÛÌòd¢C‰W‚µp0|vç½j««¦©®urZ](ˆþ’~¤í±÷Üî¬ ¨«’& ƒr9ÆB§eÉ’ûÅù2á<(öª]]ÒgÇüÇgld©5™ÃRHsT—”dº—[XàU7¥X$ª2T8;öRwtÄBÝ/SZÔÚà3-§‰<¤Ø•5T¥¾S• ¶`<Ì¢³f[ìñdÜýd•¥%Hý&¨uñA!•§$ð¬ðÍ( !Gô_S˜—óÿ6°2TsɨkÊ¢&†ã:½Õž¦Üç8U¥óWEnú¦dµó17ßüTm¥Ï‹ÌiÊØ0Z¥UÚÚó£­Ï®}´îxÛÙþj×b ®•¾\œ+%-¢MxTÍn«”µ2—œR ÆUâ¶$)™!\m6³„äÕÞqØÃJ%‚|Si(âä«­¾ÚÖúÊšZuͬ%Åzª>8Í@V0~,l¨ÆSíÎ36ûl¯U."YI#*ãö¦4²™$naä¿ €]šëx¸ýAæZ àœãûÖÆmt0ŶåIýÜc9V]¾Ö¶~e.mÆI>j«S8”’‘‚xSHR>mµ|ÁPHúŠ÷v¨ £ÐrÔ¨Œªbºj´*@ˆÊ}Tc`8ÍHÑÙŽnRTÍ~•/Ò7eÙnÛ£° Ì,¸—’‰Mz(ŽÛÐxPíÁàÓYdÑ&¶€qØî?0«·6X¢3Ür¬k´æïLÉ»ÍuiQË‹Q)Õ“ÎÔŽ?oQiMŽ\Oä?Ñ4¤‹Ê"ø kï:M·œo_'ÿ¥JTÀÐ5<î¥Ì ¸¥Ú·[X:sf]óX^íöø`eÕãwÿ(îjNËÓµ79„q—8ûš¯ÔVÓDÒç;_;:»ñÛy”ãÖÞ—Ç0Ù¥W -äŸÿ´Ùì>êþÕÓ}ö{§Œ nÇQÿ?ÜÿT;§Wg,§šùϨ/W}Qt™x¾N—uºHYq×ÞYZ–¯rMtÕºŠ X› ;CXÞákúÇN^S†s•qíÇz‘3å6Š™½×‹‹É8ÅzÙ‚ñÔƒ“˜êN?ª”óºHA¿ ZØó°æ²l‰¼Ð€w O¢9¬¼Âò¶ÂÐã*@9”kòš˜·qÂFàQ#¹4³mFsÂÔ¶þœàf³Me‹m‚Ô|ñ^å #=Ö o÷¬šït”°g”™hÀâ—*>HGiR<`‘J„ÝÑvÂÖ¦Î{b²Êk%7²ÒY>)Mi³éZ½"xæ½Öo»r¶¡Äd׆Od¼teÇtµ çœsM"—†“m‚VÔR¬)'H¤à¡$§V¡,”íIñMRì6Ò–™K ”çÍDÏ^ ~’…J¢éò6H¨÷¨‰®;r¦é(qÀS›V¤NãÛŠ¯Ö\öØ«,6óÎ9V}³I©MäöñŠ©Õ^0ySPR aÊqjÓ‹AHôvÕ~²èu/M+ÓfØ@(ʾªõµùáK±€¹[v+BJ‘–¹#Ú©— Ó¾êFé«¿OÚ7$*ƒr®+ÒòTÁV†NÔ¥88¨1Zy)Ü …!±ÁROŽÕp¨)Ø[¨+jim´!@ùªuA$å8.JðÿN=©¹vÛ§»mÔ’ÞÑ K›yÍET?|,$~NÊJÄ•¶x;UœÔT‚¼,`©­–ö†Šw« Ó&Æcv¥q¶nªEݙԀ’21Þ—©®ÔÝ#… µÌx)–3EG¹ÔŠNw€ÛiHúH¦OÏeòRŸš[XH¬š÷cIù-;•¥n©~HÙ¯Vb&„º*·}$`Šlndú&ó· @•ÎG|VÅm[žÏª‡#Hø>sô¨émÌ‘Ù$¥ó„¥²¥‚q´ÒtôÚ7"æà¤ï)JÆàE)S6[¤¥¢n|dj‹K‘ºÀ![€P4¼O$à—l¸áFçÀmDL«lÓwT1’ <…+ ù%SÚ«J hXC¨äöàU–Ží‰6JÉ¡€-ëž›Ku—UòàŒœdv­§aêæ·8UKŸX# µ—NAw|aÎxƒ[šÇÕaØ–ª»ôØÈ\‘¬´PQ}…4¡“Û·Ú·MŽÿ¸ÁÙi«÷Ly„úp¹²ý¤”ÒVPä‘[JÝwiƺXÝ-Ulý=*6åHÞjãOXñ*™WA#;&'˜[I%@¤ã%û…^’G ´¨…Å@„£ <“÷©È$Û ½09P©l¨¨ ãµKÒÉì«•£P8 %.>ð´“Ú§á–=‰UªrBŽIam‚2¯ý’4ð¢'ŒÆ2™^J¥¥@… \l¡ÝÂÖ´ ŽTiPxÎÉ K™#÷¥™…Zïeµ gy ¬ …Ÿ”HÝnD@q»é€NRN` ;­úNåGñJ5É;¤Ž)HW#½*Yì›>S•©AKç½{Œn’x. Ä´“žM*Çì’û¶é-LÖÀÒ° H=«Å˜bP…¥¨qBS , ü§…‰²ÄœrsJ{$–µçŒŒV: áBôwí^/BRÚ’€¡Œƒ^å*ÂP—Ôpœ^ƒÙ&böNé+8RHé™e‰8[.²²Gµy$œ¤É)Ix¨ÐŸ>ÂœvÀ^µ™X›õ»’FMxæ4“•˜‹' B½8ÇßÅ)3cspR²G¤à,R´©E)ÈÈÀ4“4°)=9+Á*;‰ç°ûSFJIá;5›'프•qÜæžî@7s%HJ’öÐÕvÍ{¦œ¬ÎÉ_ B>‘È8¥Üà—Ž N¶üªžÎå@ïÚû»)Ìq5¼/P˜èJJÖ4â'BwJåx³a[ ”|W’9¹ôòšT“•ûü^¬Ja¦œpÆln@ÇÔïþã_ŸªÞ°™ E(ô·¹Êúa ¡¯;0ÓZ–+wWq·´ÒËxoi $*>õ5eêJ30óâ-~6;õ8HVZ^é<)kÏDœT:dXä’ÚwjÊÚ8j?ysž3ŸËåF LÛFJß!÷å°Ô8 Æ´ØÙÞyx yCÁ=óörŽ”Ke# “ýNúÿ²hèÀ¤q/=½’7fÆkk&4tžþ–å}Ö|Ÿ5+šˆ7Ykìn2töË»ü¦ÒB÷HɺÝt—`T¸íA¼I½Gm ƒFNÔ«œgÉïSõõöïâ**ƒ;0Z3ŽÁÛã=ùXC¢?æ7I=¹þËd—NÕ)ä¿êaX+Üqù§I>s3³ùÊo‘ÙHÛÓ÷«­©w¶¢FlAôД:”îP*ÜOßr›¦îSP}ÿÊ „` 8Oÿrsï….0ù¾Q>¥ º½. ‰vë«Æu á 8œí'pHÇ|Ö”½ßfdòÒN4–·`í÷úge9MpnãáUº†!B‡pwWÚåÍtãø{m:\d{­E!;{Ö¿êúš(cšjÆ9ïùm%¿üŽsô%O[ÞÉG–@öÝBÆ »6¤©—ó Àn@qam'ÂpxÿéTºæâDr¹®ãP${sÁSQPÀNJÚßž©€s<ýG¾~ÔROP\æŸ}þW²¹v–ð¥1eªX2ˆÚGÒ6l On=ÿjÙ6kÜ•` 1ñ€×òÊ„©ˆHR[5Øenº”ö£ºÖߨ}€#ýªéa¬2Ô·LcÜg?ä~Š¢7£9rsÔ]F"¡iK Kjp¯ø’œ+¸:œ`£q;[Oý)Ï=ñYõW‹´QØZiü¹ÌÎÄç üF~VVË Î&Y_«ãúGÓÝSR/Ñe§j›I%EkVåŸÉ­5uêåpØ÷''ó*É#ÀÇ*qÖP­O‹{/ ¾éÛ½kÂöÍDÅ[#[MÉäöStÖ Õ)ÃBxeùÑ݇"îÔyŒ %hgÔúNs‚Rsƒö9ªü½HD˜¨n½=»v8ß÷ÏÊ–68ôfù÷TÇSºéI6‹W¥jJ²\)ý?߬¶ÝU-/kt°ŸÂ–ÍÓmpÍêUÏñ»"Y¶®É6ã&á°|ÚÜRä'žE?¨£1»Ò}$Ì|+ ·9Ñ–LÌ{}åÒâ¥Á©2CjFÝ ä¨Ô+ 2ig1Úeüe:~;’ĦÞíï•ûU„[I Çæ­6¾~­$a@®úÂé¨WÊ¡PÛÆÒSÝCïV+$4ÀjÜ«ÍO2>Fê2Ùr¡¸úÁxʉñSpUDѶÊÇMF×l–9¥b0ÜgBBî 1ɤw{‰””4ÚÁK!DŽ†™lw¨j‰œ]œ©XãÏ)Çæ·:Ü–ôÜIÈûo¡Ò‚× ŠÉñ¶A &)×)W«‚ž•5Ù*Ïžõ#3! n†@Ö3ÝLà!A¶½hÍÂ3íP's¤î–lG¨“×(ë’RÄU©;ê‰Õ!–<ÎS½°ëí;,”íå)=€ûÔUÁØn–,ª†ªÎªüFt¿¥³Í²}Õw›Î7Ð@t³öQàïVþðºíwÎc4Gîí³þªŸ[Ô0SŒ<î¸û[|wjM= Béhd+´™_[¿ƒû“[ºÅöy¤Á÷ ‹þÃõåRjúâWg˪â]]¯5†»¸9tÕ—ë…òiì^^B>ÉOdÀ­ñf°Q[âQÆßó÷TÊ›„Ó?T®ÊŠ6Ú”wœ‘íRÎvÍãe°3žø¬Ký–‡Wu´4€<šÄ¸¥[N [чlõ“%ÁCÙ²Kòà#äý©_;uãHÆ&FH*¯L©¬+5A OòЯÅx*pw^5Žç Öü c îsNcªýfNMÆÚG4ñ’¦3ÑÞ¶ sŽôèJ¢ŸFFáj ˆViM{&â=Ö+k#ŒÐî’š—<$«g>ö¥D‰Œ”‹Ig“Æ+0ôÍôëW¦Ÿ5˜zCîãº={ô¯<Ô}Ôšc“ØWž`J6‰nDnyÎk(N"¡÷N €T’Byÿjnéš9RÐjØ'¨•8¡ŽïL*+V kh)l+:r”lú¿½BTWmœ©¸hÆ•<µX–BIA?µW«.KÃHÒA!O-úx‘‚3ÉÍWjnXStöìJ°mVnOòÇ“Š­Ö\ºˆVÅ¢ÊÂZH å]óTúÊ÷'b"äò›iBÆZRGaÅ0uVB^8È;…8±Ùwìã½WîØSÇŒ¬¸´³é’ƒ‘íUZŠ²îƒ\O dz#ÒJOÕUZçj;%£n½”ú !%Ĭ$žEWª'ÒŒlM`ZÒÀÊ‘¸ƒÞ j+ ŽæÉ„ùØS²+l2VâIÀ÷üRsŒ5*HÆÝ’6 *½(Ý3 !d²G>M{w…8Û\HXùæšÕ5{#r§ñZÜ”¶j»#°wP3¿tæÈ#<ŒV~I;ç ¤¼-û³‘¿'½6 °Ý#§¥,²§ÉÁí^ˆ!'ºl÷†§ØÖŨ’‘Ϫ³}º@BŽž½£bµT°¼f²¢ˆÆÿRQ²j,Ì”í)A!U?-ÏD$7•‡“¾JÅ·IWz¦»½ÛɺõÑû'Hü!94úŠ 4’£¥;¥KŒÇêÍa§'e¡ÉN,ã%)¥Yî˜>S•¬=ÎîäsJŒà/»$º¥¸TM,Æ좤~]·ïVÐIõ‰iîŸ6BZµ-Nàœy¯@Âm,Žã²ÒHÍdS\¬‹Š!#'Šô· -ey¹jrH¯C¶ÂÄ•šPF ö¬„k̯Q*ñXõxJ– Åzd9BÚ¶x9Íxã”,S°÷ŠÅ(wál[ Q(#?ëB4畱´/ J[ÂÁï^€³ á)[cÔqGïN#r°;­É{s{H ‘D¸¹bJ‡ÝÁCdgÇš$.zp–Æ[ªQ(¤ûŸ‡”ù1“„ö™åÍÁJ•,¤o Ç&±—¸CšXu”­¶Y;ðã$w¬Æ·ršË&NBñ¶Öw”a)³æ²a“³e‹@<”¨!Ä”¼Rþôæ( œ Àçt©*ÞBÜ!RÿzÉH7©*ÆV§ÍIM(w ö›¦õ5ÕlF2y €N{{~+ó×v¡iyÂû -ºí«Sj?HýëQÕÅC_;åœéÎA°F$cCÊE=BcEB^lå/)ýÅÁã=€ñÚ¢dþèÌMÉ#‚\O_òK楘Ռ&’­?Öe0Tdc%ÒRƒïœr~Õ 9²Fä‚dù9ß| ¥ Ž¡çÔF+÷8-0âÎü\äýóPµ×ˆ[L"§8=ð¾Éüt®õ,m ™4'þãéG %ÅŸý©>=©¿MÜjíÕŽ'ôËÊÚf8lp=ÖëÖ¼y,ƶ –ÙÈL4:µ¶Ò¼¯~Õ°¯}yZö69]–·†j%£ç øMèº{Ôd`ç“ܨEÂä§ÜL©O6“Œã< Öu5x¨óÈÜû+tNËhQ[®²ƒé-ˆRc¾ö9Ú{T¤Ñ½û9»);šu8`.}Ô‘nMd)Å)h^àŸš³ÛmÚXHVȨŽ0ÞÍhÕòµ1óJZßqc+Q'Š¥WÚC§$,ŸC¢2ªî³Yq24ø.úÁi[qÇcíVΊ¬®ý•Ç¦ @H©ë%ÑV Q6G¤ÀVð•wÍ]nÞwà*É5¿S²Á•.Ÿ­Ú¹°‡Õ§!ÅqŸÚ¡`°˜­çu;kµ=£.P×í»–‡}5¸UÉÿš›e^œ«|4€²~~ ª¹µ”˜W€j::‰¤ŽÊDD;ªúáy‡Ô6‹Äã5d¦¡ind8K2ŒòŨ̒ð\öÔÛ~~ÔÆ·ËhÄiË¢À+#L]4Ììu¾}ÏO%Ä™,Eq(yäéBÔI>äSZx#MVtg}8‚3õ ­ÇÏ1‘J@l——ØšzÿqrM²*íQIKks;F{f£)ª&§n—IÍ•­r øLP´ÔxÒõ”¨æOusš¦Ý sròxvòÇ­êMNAXPÀ)ò¨¦t„ö &A#Útœ$ÔiéµÍÝÒÖI¶W€?2•:Nïtœg·|ùûRõRêOåÆv÷\O"Sòž[Ï:㮨’T¢IQ÷$÷5¾#Œ5º@ÙQ_9qÉZ‚V¥nÎk"@J5ŽrÞJˆÊvæ“/)Ãh²R´µ‘„§·µ"dOâ¤Ç+42½Ç‰a9”¤Þ“ó–ˆö^®)GŒŠ.xX¶ÒÉI$fœ„Ëå8â½ç„Ô°­Þ¢J{i2² +BÎÿ£Foºh~)+$'viüS $\ÏdÞë HVQÍ8&ïŒa!17r@ÜyïK‰¶L$¦ÁØýñ^”Éñiåx¨(ÁÈ}¨É¿”Ênv.ܤS¦Ìy+ )’O–VNî)C0LÅ!' s0£ÏžÔ‹êp”4Øá,M»Á4ª§PÒ—‹V„qÆr|SgW'¢p8R(`°BSÈïQ•øÜ©háû-µéÐ¥`¤ž½BÕ\Î2¥c¤Ï*uN6Ò’·QõxMWê.npÀRPS qm´6Þ'¾*½WZJŸ†‹V27S[}œ+iÛ“÷¨*ªÍ”³iÉÙNíö¶Ò]©«*BK@ʱ-vàƒžØ5Y«©9ÂzÖ{'SmÊÓµÓAU¶êB6`Ø`zh@SyWŽ*µq©ÉÙzþTḪ ˆÏ¿Ú«ï—%+»)=©’T”œæ¢k$ÙLÆÖ…oéèm©hRÓÅSk¤qÙ©½DÀÝL奆™Â=Ȩ“³ºF‰ïqõ& JÆF{RŤ)–ájIÅ7‘Ä„¡ãe,Ž¢P‘ã Ý7'¨cƒÍbÁ„¤n DíuþÕäÃ!g#Ž6VÍ©Øü„…}êÑ´»pªÕSaØ)D–FР• Nª1¶TíÔ‘4ø$`åTÌÒž>"•ZҽŃ´àæŸS±ÎyÙ@×9¸Â›²ñÝ„öÅYY´‡ªÒG—(tDzò¶í'½Uç HHV:xðÝÖÚ[§)IV| Åñ—0¯e7”ìÄ “½ ö¦ÐÓà¦RUŽÉúÙ){Ôµ;<£¥îÂVIÁ9jæqbõb¾ÐŽ­ªa)ç|éû‡–üžM΄H̯Ÿ]J鬇]’¯ME³“…x®é^«5¤­Ôý9¨»=×ëž9 ×à 8V2ç±®…°u0{\2¹ó¨ºTÆIjçí‘æ¬îCèÎNkdÐW‚i;½¹àʨº<êAFà>æ¯4òj`hT©Üs²‚L—°8¤¥väv©Hš3…U(ìTâÒd!K[ƒwça¤›FÀ*¥_©D^ˆB¾Œæ§".-ÉUy6q7½hRœäÓ¦°÷QóFɱå%$ì5“Y”ÇQÎRt¶§8 „ÒÌnoÿÜ°[ús•W‚\”Ýñ´©¢œOL~œ¤¤„”‘Øy¬F³' 1´óäÒçÒ¼m#G+`(o!C8©õn³µ­ÂJ¥©eE8 #&³QÁŽ>¤—*yâ€äƒ‚ĤŽH¥C}׋o¨€•R ‘„%Kçžßjó9Ýx„:÷ ~ô“ˆì½Y­$~ªÁ*)Áˆ%æ÷sãšV8‹¸X»+ùfc¤  Ÿ~Õ„Ñ–¤šâ·‡B#=éÍ#CšZóÏ MùZ~y°½Û9ûÖ!úë8ùÉJ(+ Ï*ñJÉ>w%`qÙ`´)hJ„ù¬œ6G˜1…µ¨IÞ½fÊbO¨¬ƒ J”¤Ö0H§ŽBÄ<ŽÖÞú~ªÀþôØFÜÆ7N yyÁánNÂ’’¼ö¤…3Ú xNLMöY‡V[ØÛ`÷¬é&n’˜Ôiþ•´.Ae[’3Œc“H‰äÉ-á(×FFY!·ÏÔ° ¡ÀŠô—¹ÚÏ)´¡º¶KšJPêJ ZˆÁæ(›¯'tòà+ZÔVÚ¿”1ã½xö’}‚öXr=)½¸î¯~Ä•sù¦‘ÆG2, á(Z>©(Ýíù©X$Œ7•‰_®«OPž]º;®¥¦V‘ô cŠø+_ÓŸÍ nÛ lÁ‡Ðž[ê›Ò–ååL ‚T•wü wI5¾¦ò°þùZC;+Š½Ó—ˆ¥K('j†2j"ái”Èn1¶Ê°ÛeD%ÌÉLWK«6©Ÿ4”´ñ•ãw4ö 2àaˆû)žÜºžik†—oy¸…ÇÖóoHöö¨/’Ç1 ê'sŸÛè£jl[k'ŽÊCR[a\]ç9 ¼ŽÃNzR‰¯Ôeqh°ü²@PµÖ÷éôŒŸeÕýU[q–ݦ[Èdðâ€Qµ? šY aÎ,ùå{o±´gPO#R\äƒ*]±¸‘Ü· º@Î 9<Ô=àKM#<£¤þ{¬ßo;' vV†¤½Ùl–£r—qb ÎeCê>ÀÙ¬µBö5ú°ÒGr~ŠÊWË)Ž1—*¢ÕÖ}+ªî¬[ãK—ÒpÉ_ÐN;cïYÞ,PÔ±²d‚Þ;~˜ íeš¶’=r ¿U4~Õ¤=q’]\eEEY'îkRWX*›™eÁ¤òçtꎪúX}J–¸õ&Óàãð¤¡[HO þôî••Í…am²W3V6KõPe ;ë4â#E$íñϹ>Õí5 ºq‡ ;}µºðåZhþª¦âû¶ç[ˆÜf×¼¬#.8O¨øûU¦ýÓÅ”Á­hÏ9ïúû+µ¾7êÑ-ꆲDHm¨0±œÞ¢:NÆ^ó¬n¢Ñk/q%U:SSÿ–ÐZÑ€°•`w­÷‹G”ÂB‘­¶Äí­ÙµÛåªRfÆeÔ •É>ØÚÅçHÝI+ÊJ.[•w©²bÆ @Hÿ`UúGàTózQ¯v©v ÉL¸ò0íWª®ìô•´Ï²>‘R4öz8Z2Už†Ã1¤d¨ñfäëÃê+lžqR>dA¿*~+P8S˜Çm È Ô @$©6AŽSãw‘§×-ü棽ڞÆ̤OÉDÇ>i÷ôsô§Vá‘øÍmÛj“Šßå7¾w? ZúïÖ4ûŠwWÍ.¤õ{[õ6æõÃS]Ÿ’Âœ.5 )a€Od§íÛ=ë¨úg£(-1©î{Ÿ©TŠš÷Nòù ­öþN{Uœ±7,KÚo~1Á¦îqJÄÌ”­¦NI#&‘s½ÓØÙ„± wÏjEï*F‘Êqi€6å4ÕÒ' ra•%a?µ&fìP–7c jûÒ“ÙzR…DB‘ÛÇjÁ³Ve›$/Ä á $»'#”™Šl‘D¥ Á?oò)û¦ÒF âìo²‹™¥Ä¹)­1ÏõöûÖ^bð…çʨœ©'Ú¼ó½’20e$v: å?ëšV9 nè€ ½q…ý ɧMá v+Rš#'¿#Ú³Öybk¹^–«ûW­— &Ò1&\|’‘•R͘òšÊ€6IL'JòSÆÒ•ûÃV™<'v#Œ@Ïâ˜I)åH2•­O ÁI Âw«ïLŸ9N› yOÐàŒúi'=ª6j“îœ6 Sì8JiJR”¨÷¦N%?†™¹É oh€ê6¬“Ψ Ê€TÍ4@§Q­Êsò9ªü•zvSq@ÐÜ€¤­Ž)Ä£aç¹5QTRíÈÔ¬›e á çŸzªÕV„ù¼©<{c¬¸Ô( ‹–­®Nã um`,%+NÞqUÚ™0vR `e)bYOÓÍDKPîP3ÝLí”(¨*©Ç &„øÛ';N@¨ó"yO\¦6ˆIÞ‚ÇYQ²“$jCn3-¥d€1âªïÉ*2_ÄR)÷¤© äûæ•Šw+(¥-ájµÈRÔ©#ïE\X•$éÃyR¦[Jö‘¿j†‘²]³‚¦gžNJ©ƒc.vk=CAß•¦K cyQÎ9¯_iÁKBþáh¶ÉÜñIí»XÔņä'Oá[v¹á¨Ä'°|TS#k²NʵS2-&úê%JIügmµŒ@©wÌò™ŠR N¯¤œf“£ˆHÒã²[r·8Ð)#°#Í%,dÒL“tÚ¶ÉNÐÀT\Íî8 û_¾JÖ"n(汎'“½5Ýzc”䩲G⥟ .$챎ɢjB÷ÂqÎN)*™ß(Ðí¾Ÿ B™ø<ªÊÿk¶Imä¼ÃmðHãµ?£¬Òÿ(;o•4 Æ ã£éH¶ðS$/“·½lž˜¼=„vP—ÊFg æOTôÕ鉯²Äu’¢ ŸÓí]cÑ×8ŒaÙÝsUÙåsˆouĺ§LÝ=wÙyä•}'|Öø´Ý" ¹Öùe™Žs\ù|Ó°ë­¼VG‘[‚âÝ–²¸Ù‹IPK‚^Ò¦=ü/vg“Ú½Ör±0Œe*a, (žÔ ”cIJÇNZVÒв“íX`…Œ‘–%8 ü’ ióIÊHá6p üKRšŽ8NVæaY³ÒŒÆ2·v²‘è¼="N9È¥Þ4I^á7¯p?Z‰ïMÒnnô£~€ šZ'¸^‚ÂÖÒŽTCH'°¯ýòBð†„âÜgú‰ñå‘“ºÉ£;¯ÒÚ@R€Hï÷¬„dÒe»­k)ÏУ»Æ+Âöû£u‘õ\$ãö¤ªdv6+Ö·)lhlGPSÎ)K#„ç½ Ò[³“ˆšO¤l”ä¬p@>)Ãd,:{'E¤7l` ½’æÑž=!5ò™GJ\·ƒ °{SÙd D‘iá`âä: ¥°yüÒ^xqÐA:‚ ³$,ÃR™JÖ€¡Ž ¥d4m²Í¬f¡¦ÜBÒJ±šÊ&¿‚²pKCrR…w$ãö¬Üìz“9)ËŽRYL†}C¹ã9¤] êý’2³®¸éÇμ³ªÓ§ú•%Ûí…¤†ÖÆ$4uÂÿ=ÿ5Ì=söz·U몶 ôÿIú{.Æð¯íc]@æQß%‡‚üz‡×Ý}YÒ=JkQÙáݬ×8×kSÍ¥Æ\m`îq“ÿÆ·¾’u$Ɔ<Á_CºZéAv¦ׇ5ÊÏ´uÔ[C$%…6²RÞ 9Îï5U¯é¦º@挧SZäõ&—­›Ôb3Qt²œxÅCEcu3ÉxåC¶€²Bì`et÷YÆŠ!G~W¤²¥»¸‚¯`Zê;1~\)•Â&‚]•&ºj—&LiµºËÊu{²µ€”&˜[ìÚ[ÇF2œ88 ­u,|Gm¹l©cŒ!\Rö+[ò\æ¥Y@ܤv>¦\­vf¤?-éŠJBJ•À°À¦w>Œí…ü%º‹ÝkÔÖn¶³Dß% ¥Åz‰ ó÷§T–ŸºI¾á7£·ˆ&# ¤…zKßá\S‡—Ôø&­‘DdŒèØÔíuµµ1»…З°]$Ùî6v%:ܧQ…ñûUAÔ58˜å™É méhbœIŽ0·p¼3zy–áróž?5wu,& MÂØÕ‘iô÷V?ýo¹Ø°ÉKÈœ­Î­Á°"«òtñŽVTF>¿ä¢¨ìå’ù‡‚U{¦/1-ò¤É~ã”…cÁ¹_„÷5=v·I,`5¤©©é‘Ê´/zëLßílBp=¹±á<«÷ªOTÒÊ^ÞêRÕn«kŽÛ(Kv@L}:Ûvõw+YÞµµO>Œþ*ŸWì€[›'þsŸ„Í2;ó\S·+‘}ÂpVWžiìˆÆ"n´R6†0¸±í±——] à(Q,’¿`öÈÙ:?>ìÿéò”ßÞš²–F»Ô¤©©©+µÍi9S­•ö¤*éÉà© m²×zº»pilÛô‘õ/<ŸÅ)AF#v©NS¨ÚÔB5ºyZ’ã‹WŽx©©*cÁk6NãhƦñ™vkm¶”†Šxâ«ò¼FIç( häeHm–6ýd‰~šÀ9Á5W^qèJg„úûl¶µ!¨­8{%[F0cÜF\ì%ZI'»Lt#Õ}1ýò¯4­äìÑ•“[…(G¡>2Ú¡Æå`çñPçToºV9JH©vËHŸ.,8¨­ç””|špÊyê\I'°XW^ZÏSˆq/W¾5í)/Øzc=êKyC“ÞÉ`+ÿbG+üö­ýÑ>K3MÜ–ý#ŸÌöZ£¨|Ecs1Ë—ÎýyÔímÔ{‡ñ [¨.wImµ+ 3Ÿ@á?µt·Oô½²/.Ž ÁßÜýJÖwYê©îP6Ôµ¹ÁQâ¬á5Ï)I Á*4Šy 9w©zÈsvBOïX» MÃ)ò"ÎF=©Œå/NË }IIYíL¤~ÊNõ §Æ RBæš™ü'F#'nwdÿµ4’^É@Ÿ²0;ÖÊÈ4,Щ)ïX“•ë[…f¼A8ZVØ$ï84£_…‡)ÙI=°}éfÈ“Z\k'“þ•˜‘3–<I2Ò3J°ÊD•©æò‚0qÞ²c÷Ý6x%4„U¼àýééy^hZ‹imÆãÞ³k÷I–î“-Ê8Î|ÒÂOt›âkL#‘“Ç~e÷„yk# ãêûâ±2/4–¡ïñ÷4“¥ÂÈF;§(Л!HQQ?ÚšËPRÑÂ=“ë1€„÷ÅGÉ7ržCIÁR8r”€OœTtõî¤Ð6 Q Ñ¥IÏÚ¡ê+“Ø©²p¦ÖëiJÓ¸+ûTUNB•§…¬r° [ѱ RqUºŠ“œ ÝÊÅŒØRRS“â¢æ˜ãtú&l¬Û¸úIIǹª­Â¤jÁJ1˜9N¯Ãq½ªR óšeà§ñ4„ºÞ§ œcšoSŒe:c4« IVÓŒŸoz­Ï&Ë<«2Ý–r”ã½Ujª=\¬›ÎëL”íy)ÆÐ8¥!9nTµ;ÚÊÀ `g5\óÂÂ¥¸ òlƒ°³za Z È $‡&¶¤Tã™ÎM:tX)&Ó´ò¥Ö¸ÈqÓŒb¢*&ÁÁQÕŽì¥q㥵¤¥G÷¦M‹Ív•*R¸sZe)h'îiȧ»IùII!qÊÂø¶.:’IóœÒuñ±Äi)Õ.ÔVÞáCÅjç'µGT³# ÆòSÈ®º[* cš†’e3·;¥l’ƒ…‚R®i´±Œl½l­nÁJíhBžB‡o÷¢ s¤pÝB×T‚ܬXÒËj;‡nÇÅZa¤00œð«ÒÄ^S:åz¯”¤ŒŸôª¼òù¯ÙH2-NL¤¶Ì~}éå% ¸Êi+å9"j›I*Çæ¤t¾&’Nɦ…ºƒÂSI6ê\tŽWŸq+S/­å)edÔ\O/v§”‘Œæ€ ¬ßXÖ8LËrr–G#9ZHö©Z*}¶MæÇ,YéüÓš–¢lÆ÷ZÛlîÚ0j DC°n~ÙJÊnGûS–´ð’t¡z¸ÊHïÏÞ²’±là¦I1îNyíƒYEJ_º”‚ 5E®6¦Þh¨¡;ð@$Rm¡{©ŠZ¼œ*kVi–hÇvRÔíSôSJ% #R'KÆ áN®hÕ(•¢"\?¡%IúNûÖäéØÓ¥ï¤õ¥¿Òu*Ë-„¿óv–š J‘’RàOz莜¬?+GuEXY£ouĺšÆÚS^™qµ–²?«î}«}Ùë5¾ë¯v˜ÚâH\ÿ¨]0ž~étFkgYŸˆË†ã…¦oT­ŠM*­¸Äù· mg'¹ûTü誅e#Nê"ÌÚT窡œã¿z°Ã>ZU:˜vÊ?!LEQKm!n'ÉíRt$kPÕgHÒ™d?%ð7RxãÞŸà“¨¨‚vÒ…ELVÒ© …)i$ Ò¥…¤BÄ·NÉ›Ò+R”2æ¼ÖSYrѳR† –‰ì3ȯ‡)„¯$g *] –ö#¥ËAÝ ÂãÛ *’R’iFË'Æ@ÊL•«•síF““I;¥zGùo+)ñJnÊô5§bVoEDqê#{ˆ=ŠÅŽqÝËÇÆ2REçBˆýëÒìÎMXÝb˜î0°qÏëNPØÎ5'‡Àú‡¨úRÙq'&'¿ÔJÔãn­ #~ô›N7QÒGŠN•-µ¤eG¾k"íö^ƒ¶¥>v“€;â¼Ü¥Í–æ™l-)uJWÛÞ²ÓŽW§=’ç´£õ†’;jÈÆyIR-Éo8QV~Ô™%(X)Bd?” % äsÞ”l®eîHáx‰kYR”Uÿ5žãÊU°¹Û¥±ƒ®«)ì) 59Ø^ýÔçr—¡µáIlý~I~Õ›é g YÖpÖ#>¢UêçƒíNÛ‡·Ë<û§ Œ­ßZÖ2‚à‰ïHÈLJáÃ?+,ëÅÇQ!d§/3þ¾8.ªÏç¬Ne‰:zè-–ÒÙ.Ê'µ9yß ¯A<-ìªÀîyÍ8c †^p°Ò”I–‡”²ÞÓŒÅ{S’=# 6ãºo\ŒíAúø÷íM¼Â0 ÉX9ƒ9H^*X)JBž'Û)^ú}ú­³–·ü<´þKµôÇ“Ì2Ì=s§–ã›°dÃW÷(5¡ºìîÇ“%º\|;ýWct?ÛT`E}ƒ?û›ÇéÏ÷]•¦~$:e¨ÛŠ¸:®ÒËÎVàmy> N0kF]¼,»Ò’$…ÄŒ…Ö½7ã/L\â†]‰Á‘Ý\mëG›åîoÄg(táCöñTWX‡õ3¶LvjiÙ® }ÿÝxuô‡œùoâ/£¾¼ïYÓÍhפ/Ó𱻄Îe4§–ã3 ¥’sODNÆ6QòÙÚ8 C]®jƒ5Ó!8 Ø#ðj6^Ÿ;[6PSZÞÇêhI¡õf>™D†2PtåDà%ýsN&è÷Tã$ ,&µNv ¾õ­‹â`4¤Àd4¨K)Ø£Îw-]Ô¯½=¦è·EÙ`,åŒ-k¹÷R{_W~Z!ô`ZÜ–F}gáR |Ó*Ž–‡IaiϾË…ë,c ¸¤súË6R[ï2‡ 9)k“ûœÒ0ôSØ)Ù˜8UÌþ©[$<”Ü&¡Ž8Hþ¬pôœÁ¿ËnÊLAumO´ë3˜’ rœ+‘DÖyÃHsHO£,qÉS†µ²Ò”zn$ ÷ɪûì;©7 s}@0”°ÑkrÆ ‡$·µ`î›ó1žÉAvéžáÔ¤Å|•½Ö£³»qq)ú•O©újÇ™(ÉöKKNO¨œ®Ùª¥Æx¥Ù*tä¢kÚ»;ßHÂQ´§H «Yj¹m  döÿJ¬ÉgsÊÅJâÖ`©¥ªûn Q0©ìp0äÔ eºLê-Ù+çHÈÙD.N]%Ê[Q縒Ž*n”DÆeÍýSÐàw)â×"E½°Û²Ëî$ó•dS*¸Û)Èn˜dÀáX0.ò¤€i”§°Ç½Vê(ØßÄSÿ!§‚¦VØŠ}^«î¸]<àp*¦pц–:ÚÓ‚T¥0BFÕ„$wÏŠˆ5žæ¡­fs€™5Rú]ÓÈê{Vêë ¾GI×Ò§øle_éR¾’¼]Š(\áîÇë¯\z¢ŠeÒ×uÇÝSøï³2ӶޔؾbIÊMÂZ6¶Ÿºî|Vïé³ÄÙóo`…¼þek׊Ífb¦¾WkN¬kþ ¾^Õzšãpl¨ÈQCIü q]céuµšhâ >üŸÕk*«Þi QÛ‚£Sn>é”'!- HúršEÇ*U¸)K[0>¡I<”ú %(Ø¡œ§ŠGRˆl–1yÊŽ #$˜O£òŸcG ÓeN¢Àá;4Ð • v¦Oz”€zR¤ § ÉÇcH“ì³`=Òö89#)4Õéa‘¹Y)Åá?M ;% Œ½zPW‹Ü&€v^•§J%Y¯Sw¸ãdŧ°í÷¥ZÜ$#—;™ÂݸóØRÃ}—“¼c /e%\[)Ž¥ŠÂ¿QÜA¬šRn ¹ÖJÊ•œsNC ¤¶Ú~¬W ’~geÇe¥Hú~”çšÌ,ÄedZt€6ãÚ±Ö€”1ŘÏsšJI+ àvOŒ[ÁZ@»T|µ8á<†=“Ô{Ry8ÀÅ1–±H1§º|bÞÚ‚•$9˜IRNÉäTù#*Ko·# ’6çÀïQ55IçÝpváO ÛQŒ$dÿµWj*÷ÝIÀÀÕ<pG“QrÕìGß Yo€}<+ƒŸ5 USºÌÂv>§Ð霒)Zp¬ÛP`e ÕT¸©; ÔÈû›PVH¨ÆIƒ•‹ƒ²ÂfÛP*@ÏŠöyI)&œ…>´¶œ¶ByÏ5\¬yá&àr­ÛzPÌbJ0íîj­'%z㺉\ ¢£<}ªB›ðìŸÁ&’=”šÊú’Ç•cš†¯ˆ²R¦`FÉâbÃÍä§qùíM NšiÚpЙA-¸Fiæ”ÿPSý8úRRævûÔ%lC*6³ðeOG¤R”FFÚRXZÆ<•Zd„»7"SÍ«ëJÈÏ"²§—Oâ ÂÊLàO'ö¨ªÆ±ÒG”¡ l&”æ@É®·Év|$ FÐr ¿jn Ý=cÓl¨Þ»%( l{â¤åg™1’Ñÿ2žA6‡eʵ¿@¹5@Ds)XʽBB'd¤•b‚v;Ij =’ùPî sÛÊ‚qô©_ù5t¶VF=\8r;'Ä=[®A×½6Ó×XòmÖÑ („É+AÇ<ù²ºs«ê vX©·Žž†V¼`/˜][è…úÛóÆÓ>MÂíX-«ŽÞEuwEx‰Œ˜`®që?¡Ï§'ouÅ:³¦WdÍ~]ËÔ<•’r¢£ìI­ïjêXÌXg š:—¤j[!2îUM¨¬ÄXj4uFRÒÀû§Î*ùh­kÚ[Œ“ïþK_Ýmx:tઆå¼æãœá]ñš³ÓJ±Ùkº¨¼·n¡’ÒÒw:T9ÿ-NÑ9Wjrp˜å8“´ ãÈŸ ¨:—F6g+C«KÌ¡HiyODÒ®hÆÉ®¢y^)ÐÚÛ-Ž9>h.o,<ÌòZO sJ´ŽB©À7dÎ\QÜ­¨ÏjT4c* Îî …)^š”kÖ4ž/9:R2’Ú𡶲Á5spí%kXVá±Gû׺½ÒaϤ§XO¸ÀÚù d÷Íx^@!©Ý6¡»¸J%4‘µæÎ#¨dø¬Ù?(¨ŒòxM‹—é©a¡´cž¿dÅÒö<÷R¤íOÕÛ5àvùÊòR×XyÕ’…úxÈûVÚ¶éÛ <•©°ÂK…Ò²³ØR­ Ç©6Àlqò[i¿Mg5ë¶0°¬Ž§NT;œ×Ž~á.Ƹn³Põ¥(’qïJ 57 ÂÇÊð4¦’r¤çŽHíûVqºH‘œ’.+ÎóÅa§Ó˜éNsÈN ˆ¦¥)¤©dàÜRí1’ž†R¤%ÝÉ RRôûÖU\Ö.pì·*bVy"°‘ÒœüKÕÈ\…UÂ{cÞ³’`F{¬ödä„·°`d` p q’RN9[þVFíŠIŒóÛ›é^óŒ,ãvÔÇÁ’GsšpØF2‚í\¥ÍBHZŠ—†Èæ—m óô¬Åxò¡ÇRqõ/õ€ dƒ'+=Ó+¯(Œ¶ Á<ÓwÆÖúšâ~nã[ã>‚~¦Nóþ”Bð]«Jð•½Çš‹½ÖB·€HÈíO´iõ°z¿²ñVÌØ®“²“ÆAªŒ—[Ë‚uKÒµÒœ2'~…LlÝ+Õ÷ÆVô+SÅ#üÀŒÔ-WQSœHð¶ƒÀÛýÆ3$0œ|ìÑ-zŒo´­9ûö¦mëÛqáêsÿ審ÿÿPýT’ÙðñÔ ìüÊXb:{§r°I¨Ê¯m±9Ê°ZþÊýG3|ÂZÏÏuiÛt×Än˜·Í[=¨‰NÔµêîÚ=’NqU «¿LUËæMϾ0¶õ—í0èký#«?¦Te»ÏÄ¥’p’›Åå÷Aÿõ‹K‰?±©wQt´ñé,h õ/ÑÊ_æ½ãä´…Ò}8ëOVß—Û«´3&ÔBL–é¨}ÈÕZ}¹RúFÆ»å+ØYJ€æ¡'ŽR±¹®nIV²Ý)Ô |”áQÝÚ«U• iãdùÈì´jMÒîœ@To¬,VåHiO…8£ö@É?ڜں^ñt áïŒ×…Iê?¬ö˜%tíf=ÈÏè¹SVˆWN¬H“Bé릣–2y`2Ö|~¢?jÜ6_³EÊr$¸Ê#ÀÜÿ¢æ~©ûiZb&;k+‡l?UE½ñÿ׫ÓǵÊÓšm¢H )Ô²–HÏß°YöréÈ|­t‡åÛ~ƒ XÅö™ê;‘Ìe±¡.ýöPY½yë6§JÍë¨ú®bUÉJe)´ÿd`Tü]c¥ÿÁJÆþYþùSôýsy­©©s³ùefT™Nz²ÝzKë9+qeJ'îO4ýík– ì¤Ù+©Ä’žš R‘œmÿšŽ{‚š¦§fö¤ ØW4ÑÄöRðÒÍÀ¤$f ÷R³Ü¢xIóX–Œ'­qÊ\Ê2 ®ôÙîì¤àˆìSªRöÜöÔи)hFÙO1bî%;qÜÓ)æ 'c#„öÄ@•dT|“eHÒ0शPÛd+Í6ƒº’kp„2;¨ýÅå*Öû­¿QϧØVs‡ JIÀJ¹Ç9°pÝdÞIs•gàŸ5‹ÂM­ÊÖþq¸ŒµzÅáH7qK†žV.áhshBOÞ”)‹Žé#¨s¶ÓŒRÑ’~ÅbÛ‚V¯jÌ¿°Iàv[H+X¾BT€J€O¨)c¶é …­q”è!#ŽsY²AÉYµ½ÖÖ!¥) S›–zÅõ²Q8¥‚RRÙäšk¯|¤-ñâ$8“•g4”“,ã§:²¤ÌÇl%'WŸ½EI3²¥bŒ¤lGkjB2~Õ$‡)舊wLd€[Oö¦fRwÊ’Ž8Â}·2Ò0… {ûTmKÉß)Ó㺞A a;½GØUz£Wtñ­Â“2‡88HOµE½Á8cÌf=DáÎP3œ&·’ë®úiÌd„ê$óiuÔ+j†x¦­pÔ@vShÌ!ÆÉV Ç9ìjY;&LئÉQP•€Qjw ¤„³j\Ý”‚Ó-=MÁâ˜ÎÒNW²JçµLˆ#`Úîðq·íL\ç£Ä]ÒA#-KQ ×”…‘h¥­µë„mäw¦óɲs šNAO–ô–^GÓÏ`*&a©g<åͶ­©oäœRÚCkÚ6dyüÔíF"Hß²«ÖJZñ‚™gIÇò€ ^rHñQÕQ4=ÂI¹õ-1$-.´R¢ÿzg; éÉÙXút·$-‚–‘ÏRöÚhäÂL•p‘ÍáZÖØУ¶Û©`åG9XÎ*ïf·ÁNÀí$ê÷Uj™dqÆE¢ðüT0âöùÊ›Šá»®vÕú*ð[} Ýõ»piÇùNyÎj~×vn­ jºw5>¶úŠá~¢ÚŽäæ¤Ýî-(-JB\gO¬Þ+}tå× 1­Ûò [_©Ë2\åóש–Rú¦IbÌìøIÞŸ^.å¥Å'—8ÀRAHÁ溦n°:0'qkŽ6;g žzÆŽ§wE¯¸;\ÿ“q@“luaD©)ÆÜwǾ>ý«tã[åêÎ@î%õY«–_û†–…JÞ­RcFõÔP¶]Fð­àå9#ûä¹Ó<·†ÇpµÊœ€ßóU›±Ò  TÛ8òªµÛÚ ;áV&…ÌÝ¥3ÈHe8F\Où¶T«´éÀP3Â[žéŒ•ŸU$y>Ôƒ[ƒºlÃþ%°H iÆQ>ª»+=…dÐ0C’3J{l™ÞYÜBUíJ7LÜu7¤è$”¤qæ”)6áhSë+ÝõYDz`çz³ÝjsÕ* _?ð)\¤Þ×gS—‰K…@햞뜅¸!jPàæ¼ÆvKãºÞ´­µ„º£éÿ”šòM@ð“~–îJÔã)Q%¼l'µ)3¯PáxÈDe©K( ñÆiÌmw&òz²qncϲ¨é R³}©8¶¡>tä„Ú§]XKJJI²{I(Ö¼‡elZßØ”©j Æ°íÊÖߪSƒÂ{ö¥#v•ã¤$n—"#Ë PVÄ‘ÉÍ(Ȝ㖀[ƒÂ÷Ñ[\|¸{`ôÁ¿¨¤Ëb z[ VöÖÇo5ëÜ/g“/sú6Ÿ*Ç4›µºóï'Nhš©J4¡Ž;â½{ÃÜ ¯ÎÊ]BKiÙŒãïOC€8#dðIžµ¥n´}4 óÇsL&Ü!{¥z†^l#yJ1äמKÆä$žÑÈK[qùYwèd¨ø¥bó&9íõY7)BÒÁS¾ªvv?ý)Û會²õÀVKÊŽæÔµý‰¬ŸXàpÒqì²-Îé;¸ÝÂs“Í%;n±pÂRÖ=@ÚB1Þ‚çÀIàž( CyR½+NÒ\1žëÞ9ZŠŸ— |s^É9o¥‡bŒËè­£Déæ6©P#¬à”ù® ­ê §ÿQ_\¨ú^™¸ÒÀ¬«}ž#,%¶c²ÓYþ”Uzšéì¸ä«Õ¢ÖÖl6Kÿ‡ÅHá¤`ûM¾òÿu?÷F‚Š‚éÊFÔöÅbùŽ≥jº1 ¨ jV–Gguè§ì¡KŠ— ¶’3šlÄRÍ~Ä'Ø1™l7ô¥ ¢GŒvàÓœ%«uM84Ù­ËT«iÛ’¨F9YyÕåY¤g׌SHZyN¯Ü¾]­¨psØ i)qÉ Í;0앺%èú{Î$ã?ª“–‡|á9õ{¬_¾ÉKjJ”—ϤVQÐ39§°W¾1€äÞÍçr]–žÎR2)Ô”XÆøK‘&fæ•RÜÊ#‚qÚ”}Ø—‘¯“ãôXµWfm§þIõg @Oã5‘¨ò¢2-Æz©2Èú%6M¨ìï¦sÑËŠŠ²bˈÚÐ~Ù"±¯ê IÛåº ?!ÅU(mW8gó…SÜ=ˆ'«üýRÐH²Û4³²+CèZyûÚ£í´ôn?÷x+Ì×Kˆ§0¼‹8ý•ªúƒñliáeÐúMIþã[?°&¶£¦úfR<ùßùì´×Võ¯ˆÑü2š'ü‚Oìp¸w©z÷­7¹ ë ·«vÓ¹,4’ÂÏp]Òý?c‚y¨‰ì•r¤Vö(äñâ£*dK0gu0cúU´Œ>j\' I(ãpãÕ1ÂWNvS+fRœT%Våa ÀÂq”—Îý¤çý)¼$ec“3 ¥Î9ÆËÂ~Ó….ŠþÔý|',y;#VùJèA(’Þ{EÑçd»¤–ç’âÓµ8ÁñQU 'y™E$ „cÅBOÊl×j)BÛic)GñÚ’kˆY7”™â”¤q€)Vd£ÍÏ dI+RÂÚG5äѺͯÎÊRiMý!XþõüçdŒØÊ~´£z¦³V *N¶–·+ÔÈÁã¡¿)6Ô7^éÚ%Åm¥• ©¼c$ϵ-‹[[$g…Ž:°¼yæœqxXÉç·šA˜{ŠQƒ 3.”¼œ,(S[«l¥@ÉV¶ßóHpmÎFjÅÓñ–K²„ºÊÁéʵ¦Mr4pBËŽcúj¿ÍZøÙÎJ«ÂòC{(-Ö÷ê²VJÉ9'ÍV®µnò÷*fŠé¾Óo\‰(Š~®þõW‚•ÏŸu)=n–á\¶kjl•0ç’Em+ `ÉÝR.n'dñ-A¤(giñR—xÛåg8Âc.rayIP RÉ?œZæ¦d©Höì·¥ (NÂ¥/ñÚ½f’6H—`î±QV ’{x5“ZNáf=’Öæ‚ŠŠ Ó‰w‹}’eû¡qÛP'·Ÿ]ž‰¯v¬öX¶RBÁ°¥açÅGFÐ{¬ÎéCm « WÕOÁÁ)q”­ÈM­ ¤þ£Ü“âÿ |ÄÝ•D•j³ó @Š‡¸ÁÕ[…- ùØ…º²êšRš–¨ÊïÏõ}©˾ ì~ªnã8ÆU«e8ÛÒcÝm.Q”0T‡ w'ÁÁ§¶º’\2HÛßåO±¹.TÖ¶=xzCM[/ üÁ<¬î)PúOúÖ̳\ê""AŒùÊa]ndƒIÊùµÕ ¬¬7Y— 8¹ÂÅ+, „8¼râ|{dy®©è®£§© 2n}û®{êÞŸ©c‰„àùÂùÕ…ê'oÉTY ,%I}-¤©+QÈRÈ9åY溿¥ª ÀÿÎù\…âª5:df~‹œ5xÍ#ko¶ÐZ”}4«%#°Žõ~¤kNãþr´ÍÞž6‚Fß ± PÎP2­ÞÞõd¥µÄaSg¦.i,<(ÃÊ} Ÿæ“‘“Ïj’ÁU¹ìáÉ•oä7Ÿ4ð;CÊü–¥¨¤ð8ïX’›“žBN Ñp… qNZÖ‘Ê@†ekRHÚ•d+ÛšÃ黜AÀ+J›Z2œ€k6¿&ïi<,‚Ê›;ÂwjQ¤Žü„ÈOÔ=1»Ú°s (tÚFÑóIPÆ6«Þ³hÂn*IüE&q缫*V1œÖy)«ŽøJ˜X?BÇÐx<ö¬ÃKŽRñ¼ã@Zži-’T±àû×­v9IÍenÇVó¸ À7 (Ü[¹JÚÞRe ì+Þûr¼sI-‰!k;ÖGþ”«Zs‡/O”µ–½ùÝãŠJF; ,ØÐ[‚pR2Ô—r²‘÷5˜cšwA‰ÚwX¥¤î8x—·šËÌÆÁ #ß ÎwoY_çµ'…š\ÊPáaÜ‘É¥bn䶂ßP)q}¨à)´!#É'?éDŒ²ÕÞv%ing¨á!>²ÿ±{ËÝ„ê€IO¬=%à€Ú”÷Ç^Ç#‰Ãy“§c‚¶¸Ô‡Î2ÚyÎ{Ó§Ë#› ’% í•Š›l´œ[Wœ בHÖ´äáfÖiØ$›R–”V§9ã'ŠðÕµ­ß$ýPsß„¢*æã+í,mße.j7¦ÖNáûT,’ä«5ÚÝÜ“/•c Ú)Fð¤žàNBØ–°IÜŸqX— Hîé²âÈ^VR;æÒ¿ ÔEDÚÊÉJÏíSL9¥v䧋~Çœh“ôö4Ò§`W”Jsº|¸Ê[VÓŽ>ôÊ»’²·ºeo(-Ђ;bŸ»è‘–P)šDÅ!ì ±âŸG-YG;‡8Np$!å){Ž¦µ1éK‰AN® †veXì~ÔÚ S«!&éšCøƒ=5’{š›á߈!ÒAI¢ß‹%iääwûÒ’ÛÁI}ç²XL¨Ø( Îr #ü$;•¨=”âϪÝ|¥jPK€y5_­³†Œ²l¾élB¥IS‹s*>Ô„vÜ7>〱nâÜ’¥z PúbÔæ=8Ùf»u‚ú…üÀ‰=²0’âˆýÍÖTÓø[ôM«-tµQ§`s~B†Iøué|·›xÚŽ€¬‚>¬ûäTô^(]ØÝ!ùZÊ:rw—º™£|짇ž–3´ÆÓÐ^%8>ª7Ïæ jüP»ŸÅ!ü”Œ> tôÇLßТhêßÃ, kh·* Yœ‚Ñm-!€àÏ’9÷©.ñvZ9ßrðîùáTºïÁ:;­+`€ˆÜÞ0uÄ7î…ê(±9”¼Þ@ Bwø­ínñ’¹š£;®z¬ð*¶Õ&—áôH#éÙˆ8À89â[£åNRṯ ýT¢-­ô„Œ‚°ïPÓÕµ^mô.`§´Bu%)Ș¾qŒ«41û'fX-‚Ti“ß”í‘àåÁ.C') HÇæ/öO㋾ÐÒ›QqHj)(aÆá(i )Î9'“œOãfZIIcLåçe&È!?FB×Èà~;Ô|®”ðpŸ£²€•óäcÍF½ù*B ÆR–wqµ<ŒšMØNã8)[MíV¢¿µ&â‰Y©Ä”6ÚsïIµ§;•î£Ý6— ʈÅ9Ò>`X«+o)s =ëÐpxI¼8îÒµPT³÷ûVA ér¶ Qöml¨¬3Xù.ä¤udúŽÉ,…¸J?FixZÝý×®-ì’‚ ÀY9ïK”†qÊÚ$§%9X=ÈïIº>éHÆËKªuÕ¤‚PœçŽÕ“pñ‡e¹¦ÐÚ·)>·ŸÅbòHÙ`ç{%.œµ±4˜aîS¦»! ¨‘š+6¼œâ¬äSI“¶ÆNéÉ*Išjç{§ nÜVŸ-€üS ž5',ßdù2À9óQóJ¸£>ÊJÃJi() ÇœÔSݨ”ù­„û—T O·½1›a²zÀR&`¥òÆp*.IË{¥Z=”âÑnm¶ÿJÜ#û ¯ÖÔpÜržh¡¾”}ý郿)VSŸÄmé$+rT)¥QöNÚ6Si.$œãý*£e•*ŠÚˆOÓôcÅDÊñÝ,ÄG}" ‰ãÍ0™š¶ ‚wK—ëŒ%ÌóŽ)éôž‘7 tx¦IïÅ'5N6KI8N%µ'éÉ æšjÎéHßµ7 #)RÊÀädÖf2w Ëš×3+ÂJ³ÀWÉÀüJÍ·¥O²Ò>’pþV€95|¡¤”á ˆÊ!?‘IÅ%x*Zòšp?‘´ñÅ,ÖéY°¥Ð¢”œã¿½7šT°sFéáxBZGcæšiÎëHÔ§y´ ¡*%y°ˆe1«œ†Êg1Ôú+!) ¤yóN$8 (˜ó¯erî㶙ܓÜxæ‡g²±21Œ¦5Ãz”²…í=³Æ 5`Òv^=…K-ÞuM;é‚“ïäÒ°PHâBŽ©­ô«¿K 2†ÖZ VÒ¥þ;VɱÓ~&ýUNäð〜o2[u܇²8Hjyu|eÙÇì“¡ˆ… :³†•xÏŠ©WMØ)–Œp¦Ö¦‚Ò‰RRr9ɧTqé<¨ú©sÁV½¼4Jõ¶(yãþjùm‘¥¾¬àþ[ÿš©T¹ÅÛvXÎ „!<§î;Òµí xKRä”Éò!Æk_ÖS=Ïp)/9 •6‡ ’RÛÍyR;m‚Aî­°RÓžùÇ$V@æ<aa„î†TÑ!xòx¬2Ð2’”áÛ•„Él•ÏnõU°³ˆ‚pãiÊŽEEËXA ÄŽìœYi©^áÏaïX² IÙ3•çK» ø'ŸF¦îd‚X*RrÓg"£+¤9 Ý9é–SiZˆq-”ÀRG4ʶ¯S4` q·ù©(FíUÖ ¶5qYi9b@AÛ¡öûÔ$nwòøwo•h¡—KrNBæ=kÓ)’–ü E2Ø…§–ÒµíÈîHî3Ú®ž§k1Ù«󺔑‚Fã8ú.ëMu,h“e*ýj˜ÖÍá׳”§ ÛçÿwûW@t7UйÀyd|9Z空vFúÚàsï•ó«6æš’ô—l–k¯ e^ŠI).I'vxWl¤Wbt5ö KLnÇÁ'üŽår¿_PVR¿Ì aÛaÂùáªm³¤È¸K[!Mnoj”Où±çï]ATeh{ùÇ·üßår'PQ=Ò9á§*œ¹»2(S i]²Ÿ5d‚6d®ê]+[é !-©! ¹*${SmvvUiƒ¹ziK-ÿ+rOs“KŽkšÑø_ÐPá@ ä`rM8‰™ÙÜ,à9IpÐåiç½a m#€•š–„'!M¶ÝC’kÖÓ &Û„ç™ Yl3ÙF–Œ¤ä“Ó©©¬¸U€ ¬ÃJbeåmKk$nÊk =Öxs· ÏGjŽÍ§Œó^$]µ $ŠLä™Æ7Yµé…%K$aJ1Èhhß)R‚^>“@©\”š÷+¼“¸ZƒkqÌt&²8;¬@wt¹‡ÖÒWÚOœgš#;‘”¸hÒ’"Kì­`;µ^øäÖm´ìSg–·â¹õ”Ty5‹Úää 1ÄçºÍ-:´•-ï§óC¥qnŽØÔViC-$zNùàöæ°iÛ~Rm%iRÝJ][‰W8'óK‡gr²ÊÚTãÁd„Æ<Ö@êjQŽÁÝ)–÷¥)òiCN)F½…û¥è@oëŽÒÛŽGúÖ$gx˜GÀåd™Ëm^›˜Áî1J½Øn1êøYÇ y[ŠÊÒݱÜóH¾în£° ÈhX6·ò©.sõnñJ[òìùc)³Þòbz‹ %µ•¬ó´r)h#Ó’íÉì³ß¥Â•íôN'Ô£ip•¿Õc¤g%xKq”·¿Ø{Ò’8´åû…‘6ɘã¡Gr‘‘ÀES—JX&„©ÍÎåJÈc^`àezçí’µÈ[€+fÔ'ÏŠòG¸HÀ :YZã²û-ŒmR€ôñí_7f“·uö’'µÇ*qÂãêOÞ“kTÌxêaú€­Iã½zgÆÁ?mf‘…ƒŒý>ž{q^6E=Qzi=†í§š{O*~ʇ ¥Â6‘SÔòd,UØ”•…¸Á%[ÓíJÈÐäƒpx+D©crÁÁÍ) à/š*>ýÁÔ­AµüóRqÓ4ÖfqŒ›^žâNüsŒS˜éÁÙ#ÞéæÓ{m…)+@pcýimr>ô ÀXÜî q ZH5•(ÁYº ceD—Ü #q*èZQÈãÊH‰ž“¥+#ß4¿“‘²o÷§èrâ’âRH)͔ҟ~Û”éoº6‡_ÓÛΦŒá+NG©(“t_¨ K;sïIGF1º“eB^ÅÅßOZ½þôÚJ1œ•›%:”†Ó>Qy+ Z†j6²™¸R½ØÙZ‘nò-¶³¹yRtÌin TÌbWÂw*‘’PzÖ€0ÔvÈR“ì)=C8^Èâä‡fR¼©4àëÀµ®JR£±8ŒSFy^6 "ÜQVå9¸Ô³X1²Dœ¬w#À¯t•âÈ­n§i ÷Í hjµ'ôí<ƒ^‡û¤¤²ËjÖ WžÜs^g/Í–ä4¢àúæ“s¶ÝzÖœa,)JRÚ€ ð~ÔÛ'º<¼ØT­ÿzÈå-{% D$‚¢;zMóã`–ksÂra”$íJ@Þ›:SÊw8O¬GIXá#Æ GK)ÆÉp2¤”©[Gìj˜’7N# Þ3J^T20x¦RI””<'pÚöîÚ>ôËPK5¤ð¡—P7dÿjeQÂwƒ¥X™ JT• cUÙäÁN#•1µ¤¥ ܲ£ãñPUnìô¥÷JT€p9æ’…9d¸ Ú›m$ x¦“;rS˜Ý¨)]½Ô—¶ýE'ǽBÔ°éÊÎ6Žê{z‡ öªì畃œÆfæ†Ô¤pO½{gÃl$±r‚¬¨“ÇÚ–—tà»*ö­+i·ŽAYª8LšÜ» =ÅJ9@­0ÂU’áÁª9…’H8© SíA?Úû’œúj½GU…榫ŽÇ9æÁ_ äxñš­O .¨ùàÔIÊÝryRHZ”®x#…6kq¸KÓFÖŒ­ØQÆ2yäœR3pœëêk >ÖZ–ÊUÝ9ö¦.‹!4|' –cå8Jp¬+Ûµ{cº‘hÈR[EÅmö(“þ\vÍbâ 쟤^f©…5¬‚ã¥È#ÊbÊGdõÝZÊHÍ10€¥À#dùiJÜZ>„¨’¦Þ^^Ægí’®+{%)@Bx`$qù«Í6–Œ…PšrNJ˜Ç”˜`Èqi.ÈÝÈÿéSQ†0ùŽþê6@ç–…¾n/‡'ŸÅ2ÂGúR±8Æ7N¢ŽBÓê+<µë(ñ‡Œ…Œ“cº°l_JBDv›ŽGz“¢¥Á- ÙEMu4mø¯1é¸ÑK›²“Vü—Ç¥íÁQåËxY¾¤m 9§µ-cš ŠÎ sÂÁˆ¨ZòØYOrj£5»ùî1ƒƒð‰¦#”¨-²TÖÑú{VQ°ñ§’@´ò C1‘”nˆàb£+©2AxÝ;§—eµ ØNÒ£ïIhÚ29?ó…„„ç=–‰ 7½JÇj«¦<d¤2èm[|T5l”Ï kAš} ã)ɧ¤Srvá4d`¥ˆZ•õ u9)³†É3Äò…3ØÓiÆv)xÆÙ ©ÆÖAPRAòj*XöØpŸµà(Ýâ å$-½Ì¨ñ”¯[Ò×çB¥íõA„ƒº¡u„[ãÍ€akçóžyâÙ,%Ùyß¿uk„µÍËW ë«´Ön‘b‘d’¥¥ÀóIKá>€xR{å$v­ßÓT¦œÍ~GÓü·ýTEèÈ×hدŸ|±ê;s’ûh€ÕÞÞÙKR`ºJRÃJÀõÉ ãê{Šé¿ î4¯ÑMRHÛ9ÿu¡|@·N#|ÔÛž Jù Ô‹T¼Ïþ!n™ ª@ÿ¶£Øç<‚<Ž vNNÀÐ#vGÊá~·µI—Ù€}—9\m±à¸´ ïd•Üû¶3—Vœ©¤l9äåCd4¯UaI B{pX²©ÔDçá° °ún¡RíI88ìhÂ]ë)ÍÛ”¶“Ž1Í4ŒŽ×48|¥±"ýx}Ñ… äw¢'Jp½dm=Ò´G.•:”xú{Òù•ã¾‹Ç8ã ÁˆÛANvßÒôÁÑŒÊI²¼ œã­¦RTžÜò)ÄMcAÛ9N5enmá•®C‰ ã;AþÔaÙ“„²brpÞKh!9çwŠBƒó·ëÖ¹¿Ô‘|Â);·aïM†—¸kØ/ 촸꒕ä`tÙZÆhiMæ{É# 3èS)XÿÛÁ¤¦;d¬YOâ_béDr¶7üÀr2;×Ë ®ÿÍçeõÖšå¥Üò¢/ié;ÞÃgv|ŽÕ7͸«0Б’™%‚•’>ÜRþs]êR_}iåx”¯æ  ¼vK¶¨4a©¢b7:¼6£ÇŸ@ý¹KGXì¦)’¢7·…w!øà¥]!vå3?n.(’€Ÿ¶sOYUºò)ËTzå @„£‘RTµ+/0•~е,ƒ59@!zé6)šc ã¾iô2Ù³¼ð›h¡\óšw€îWŽ¨)<™ï”¬ã¶)X©Ú8H:­À¤ìÍZ†7c+7ÂjÉY<Èu![<Ÿµyñ²RÒ0¹„( M9iÊÁ¯—¸´A Ð@)À¨pá85!j 9)³Ø Fž­ÅI-áKy´¨¨äñQ•GbSø*òýžDéÁÜO5\šMYʆ †ì¦QRà@X*ÅAÌ{)¥O Ì CiÜT|Õ~¦ Ê‘¥;áXYíåjñÅV®îÎÉþ“§ÖçÒµƒ’~â«•Qö» À¶)j-ž‡aUª°7H²ÖQ—B‘´dð=Çniñ›ü'(§cµn„FPHZQé㛤ìJ‘î”%U¹Qñö¤ËÏd£#Ô”ìPHÚ8ÀÍ$\3º}ÀÂD¦ÜRÈQã½/¬a,·le-¯qI‚ã¸BÛõ”©)VÑXä±kòš–R…nÚì½' 2¶í$n*¹ö¥€9IëX”BMd\{$ÈZö”î ½zxÝy‚¤¯nãÚ½k‡ Qé( ¯ö5ég E’àRTË'ŽGèN㺄…wQãµ4–Q†˜|+iŽô™x„GË ?Ú“söJD;ó†· ­d÷ÏaL%•Ãrœ0`—ªCd…AãŠCïœ%âvBp‹¤%JÁÏûSYd`—Œ§èÍÜHP"£¥vFÖ7VÊE+©ã¿5) A£ Å1Ÿ[D©#$÷Å6tÀ,™0j[‚’žùÁ>ÔÞyñÔ‚pBœ[’Péä·½WªŽNéØ“<)åµ¢è! nÇj¯Ô¿y+°“¾Ê‹»W‘Y1ûe —mÓ´ ¦’ QâšÍ‚VM”ƒvOqæzk ôÂq÷¦Až2¥®áX–™è,¥k*ÀàUn¶Ÿ}!{+v[å:ÛéíÛ;i¼L-YGŒ¡€§ ØIûR’¯žÖ)ä˜ÿRŠqÀªôì%É›¥$äl´ÍqNü©Dqö¬¡a F8òSS‰)kèTñŽÝ8lÞéM¾pKÈ+$ÆI¤ê`Ûe“ÜÐ2­ L¶Ä`=MÇ<{Š¬Ô5ÙÁ ±žÉ\¹Š ádÚŽëFFB‘Øßqgi ðÜù¤¥¤s¶jJBÉRZKiJU´ŽpM1,x:HÂL`¨t‰9uE\sþ•›c$)h^ÝN1å86§y ö¦ï‹ ÐRï™–S’²Gæ’,×¹ºÎ<ï¢T¼öÍ'$;/]&J[òØ…”d€îM{'|¨i¦/cÙ§¸ÛA* ¤``çk Út“°P•-'„ªtÕ+r[HPQãŽM+]˜Î“•í8Ûtãb”­ÈõrnGjoj’2°­nF²-ÊRö£Ÿ8«t†‘Àl¤¦@a¿WvÕöòiûâ³VwMZA8[`Ýýgƒ-‚§ rp;ŠhÙõ¼içèœ:=-ÉSÛ+TE>’œ½˜Mdq!,IJ07íÇly¬LlÆxH9¤î“(JÂ~¢¯ Ö,« Kˆ )Å»qàžÕW¯®t»4%šÀèh<¥•ƒŽj'ܬÉiÙc%Õ,R@#¾{Ôe]^—i#•ìL3…%•¼«ÆMT*¦Éþ ·KÙp ðB“ížõ•4®nälšȨ̀$+sAg)Q=©ñq8<&e¸8Ißpolv¯*$9ÆаÊO…–Ô¤ cÏŠfòàÓ„¶ÙÁMî¨þ”e@ŽÁ£¸Bl÷¬œ6Î_vw}–Õ>–*a-¥>ç¹5˜— MÌzvÊo/¸î{÷ûÖmã …‰S § P#Ú°Õ«”ŒÓ¶V•¥e[Žy¬±ºÀ%!+)[N;{ÖbìŒéFÄÛFsç"¼i.aùY´¶ J‡ôçýk#¤þ%„Otã¢2¥{g½xK1°J:px BqÅ’Ÿ£ÎkÆ·<&ào„÷3Êi* R­/RÂYÂ^Ðj)+RŠÔ·?Š|iƒF¢AÏÎéV»•ê%<·B6¤{׬•Íi C·;§6e+„9Ÿýö¢‘åä‡l±{@A‘µKQ öȬc9~““,ÈZ÷!%JZ±íYÔ3¬’½kN”’áSjFãIиœƒºÂjpíò³n2IÜÛ`ð“íXHr4`„4ä•›î 7é¨ú„v¥›,œ•t£š$¼ðg…„'Ó^K'§ÔI××é¾%-¶ôÖ0s_*kwÊú˜ku|-rôÛN-–Ñ“öÇúÖ0ÜÈاÔ× ÔÁ7G%iõV×Õäb¤éï.ΗeÄçPYúAaÏQ Ï Tý=ècKÇuc¸MŽée<’Zkcù§M»iüEHS܇QI¶ãgÖdà LAq৑LÁQ—­ËR•Á¥£ªJ¾pnm¹O¯fÂ@5)NÖMªÈå0L´c9Nï‘R4õ»¯L™‚ ·V½<¶†Ç½X©O¨”ÊZ‚bíåÖò1œS¦Ôàå8Žw;”Ç2Ðá;±žp;T„5ÄŒ±„ظ¿.ž3NÛ6¢“|Z7+ •,p0 b1”›dÊÐa,sÛ4¨œñ e*jÝÚ€Øϸ¤Qò—Œe87ex}{wö¦æ¸aJi*Eiˆ€ï#°¨Úٲݔ´,ƒÝY,0’GlUZYS7!IaCõÔœn#‹ h(ÈúñQ“Néì,ÉÙ?GgiÝÞ£d“*R3§b§vy%+88ùªýt@©22±fš’ã)8äŽ}ª[NpVMiu5nnCiu·'â iê\Ó‚œC¾ËÛ>æ$% 89ƒ^Vz™’–{r§Sæ¡HB{š¯ÓÓrS/$çtÂä4¾¶ŽÀy©M¡bø‹ÇLZ¼Øœ†ØmÏÒNÐ ?jöƒ«O8Œ•rXØ]ºä=QÒœbû±búÀãÈù­ÏgëX_†½ØP“PüK]4üÈD‡Y‚j÷KsŽNsÛ‹Êal)’@!÷†²›DÜ­l©)äm¡¯§ L¶{c<Ò¬‘dÖœ¤ëd¢~—köJ’ƒŒa-œÒC~RAá"q”’AIÉ<œv¥Úò8^“ºÒb‘¹íŠÌK• Å0Ε ŸnÔy‹; #%JFÑŒÖL¬‚ñ,)I '+¡ÏÂËIÆVåDÉHRFx ÇÎöX¥ŒÛö«8þ)»ª» °3ÀHB‚‡“Å%«l¥á߈ð·¶ÛŠÚ’” Ò/p¥Ã@[›·ïsipgíX:§e—ŸbCcè“ÿ<îÊWA# åš ôÔ¾|ö¦n¨<,£„€”5-eJHBý8¤_18ˆ`ä§fR–ÎJGÛ"™Èrç'dóHRBJr²xÇša09Y:2Ÿ  ääö¨üäç)D™ÈpŒ“ßíJ¿q•# °ÐT¾×””c=ȨJÒ qB´íêm e#Ó{²Ž*¯;=[¦rJÊA)­’7•Ž)f¸c:¸ "~¨Þ’uìoâ[y~¨ZˆYÆ+0œ2F©õ±âYA8oªí[¯t§šÉÇ~õ Š+š–àn–TŠØÂÜPZ”ŽqQ•ÀÂgPF2ž— ±„ƒÏ~ôűêIDC¾‰²=e6V¤îìiVÅŒ©æã( FO(Å%«$ça"WòÝÎÀ»µ8ÎBU£;9³¬©³Æ’sQ37Õ’›¼o„½÷vì'< ÓràNË8ŽÊOl™‚´ïP`Šlçc(ŸŸY[YW=Ç5 {s‰É´îi) ©í¨$7»$í$ŒjVjˆÆÌá4Ù)u²CåöÐIpN{Šj$"PÁ)+n¥pÛm¤!<ì gw¢ÒùªÄÓì%ò…,œœ`sâ—“ËQ+6ðµÚ¤-3ZSAdŒùÅBS=Ân?úNei,!Zaýì…¥<”Š²M¨Dïr£Cp›^”ê‚úî*)žìlœÄ9(ŽâÔæâ …$»d¼ cdè†ÀÚ¬{gŠ}Ø)™y[Ò€‚¥8Aì)Î\‘.ÎÁ!‘’8#ÅCVÓ”ê¾É¡)*^VSÆj8ZçeÀl¤p6JV®;db¢+iòã±á É·ÎqHƒÂÄ´´ ºA8ûSŒ‡n¼“_Ô•¶“t™nÅç¸X:†T””å+ɦÂ×{¬˜çƒÂ\³„a-©*áHQªÝ{³š@ÅKQ•Xj«iÁrš`3!¼()+ÿ51mÛJÓœ…c¤˜‘¤œå|øë>êîk*aÇÞd©ãÕÆAúÓÊ‚Fzß½Ôú4ää*ïPÙÛ+IÆÊ­}£®Î1x´¾û~“ W¨•IFô¤¥Ä«¾{vò+±újê'ÓQNÜãŸ|.zê 3‹ Ž1ò¾më« Ë<™¢æ‹‹8¢´HÜ%_r9þõÓv œsD@rã~¢°I ƒ¤÷ ”ï°UIP.Ná¸ò5²(êu²ç˽¼Å&û(Ô™D¸µ†ÒVG8©P율’sè ¡~ å`ŒÒ¬vê:V¸nà“—v}%­Ø÷§£Ld¨ `5kSÎ/›Ûµb[Ù%ç¸öZv§#zIûVlÏd“ÚÒrä·å‘è­aä4FIî¯Å,ؽ$’?>ÿEì±4Jm‘´‡ÂÕ5†Ÿ•——›’wZ !{•ŸãOºÆ0;¹O´´ìK(h=ëؘO €qÏ&KͲ•„ ¹î|R€›çGà);’XúŠ‰÷¥Ž0RJIÝkqýX¤Û±Cˆp^ ÁxOjT;…ƒsœ½*X9ÈçÁ£ÍYùnî·…¥#y@>ÙÍxÈÿÄ•t­;’n;÷ „œä ôœ$2K¶J›qÓ’¥^½¢OW ×-ˆl© ;As>k7Œ,ã‰Ç…œxã*Þ”…Øç„q‚íÓ¨ Çâ CLFh©ÖÐá Ž|R­„µÙìil·ÿhmC»PŸéÛæ¤>÷pH:§¬1‡çêN8ûTVŒ¼¸,¼í²xJL†wlJ9÷©jw5£IܬCõn”¼ÒòT‘ŽÀ╘Oe›šV¥'æRNÔŽNj9Ñ:W`r°Á^‚Ó[Fâéó^Œ´è/'ãæ•#ºÔVâØ”„Žÿýšs\§ “ãq;&ù2Ê› mÏ~õ„Ò0•tY (É Ö8ìrh‚<ò¼Ž-9Ô´Ïr2pnRŽ1ôø¯*šÓ³JBIc#Wë:=¢:ÛI$ v¾: s†ë蘯Ïu˜¶`(¡)8ÿÛÍEÔR9€ü'ôõgc•›¶…­¼¥¤”ùàQ¹‡J’Šáƒœ¨MëN©CþÚ¬sÞ½d¯„áÊj–°Ä£‘´ëÿRv©ûw¥å¯Îê\VF8MWý(¥´A^ÕwÎÞqN¨.º]ÂyO^áT#%·°KÉ÷*çKyaO㸃ÊaV—u_¤V£ßµH‹¸;e.+ZïJŠj C¬%h[D¦mµqÎS¨ýÕk'J»!^ª@Çš³Ãx  a#Ouâl-´«îzë‘'d¼DvLSmˆÊ’G8© jÃÊX¨dË:NR®2jzݶH¿.+S6d ïY¾¸ã”›#àµûBÔ¡± £Æ)ë@RÞQì”B¶¸ÁÂP1ïíITU‡r–†-÷ èE„Ÿ½12û•$Æ´ò–µomI*}Q;)`Œ$·E «·j‰ª—Ù?çV šÞµ«)A#ì;Õjº º”¤÷Æ„"¥) ^Ü«#C'™’œA9#HáÈ­)HéiâÒ2¤i\K°T¦ÜÛ©X e'ÛÅDT¸cu0%c*oo}Qä7¸ž=ê¡Í)v»!Yn‹}™Z°öªµE néhμ—e„¤•¹öði­@Ã7YÎüpTÞMšäË[¬º†Æ2HíPl¬ˆ ;¦Lª8 ½»‹i}<`òigR9Nô’£û¾2- „Ns&ªó[ο0¨Imä;ÌqÙ)Ÿ¤Ÿ‘o–•EAYFHÿšN –‰€'QÎdeà žïý?µ¼êFgÔ'')Ú¶%·©fiØì—ªˆceÔ½ù‹\K”hN¶Òj€þÕf¶õ¡Ú^s•_Ès°W8êMq´¾¦Ü†û­ƒÂ‚8ýëdZú‚)Û@+Ù`xü%A%ZžhãiÇlU†*¦žC áé£ä_*ݱ[èNÕëœßt Bt„¤6¡H™‚Mã-/ÁXág‘JÇP;,IؤâPdûÒ†£ ß/±pFÜ+ÆÔïºô;Ùaò¬¥#p*wóÅzf+Çr¶´›RAóŠÀ9ǺY£l$ªÜ];rïíK·Ý`c!*kÔåDšB@9K°á/ùW0Á¦þhá)æv K1’ð.¸ ÙqI>Ll€•2ÃiÉIVsÅ$ùtè'ˆ‘ʈÂTi„ò¬›Ê’!mµE¹Ûä%ÀKÐËA V|ù¤ ¹+0ìò‘<…)[@QOßÅ,Â0–Œ€RËzÀOŸ•IS§ihN²U“ž“ZC¸>™$vüS Nv+Âîå9ÌR“´'xïHùMì³aÛ”™™{V–÷¨,kÖGÖNw²¸ôËS%%jd” ŸÒŒÖT”ΕÎöÏ …@o%%Ôhص!i<‚r<ªÚ=%éƒHÉ)¢Þꇧ´œç ⣠!À>©ë\¦l•,'Œöê&¢,“ wH Èä¥ð˜f3«RQµràVT°0dl“t¡Ç+7d2£µ-ŽO4¥sÃ7ÊNöÔ0§VVq¤yýé¬ï©Ý’ScNÊ`b¥h[…©ýA9©¡ #V6Q±¹À`§ai¥Ç$ì$þœŠRž&ÒîW“¹Îf©ä†Â\HHÛßÅZieÀÀ ºØ‰w©6KšŒ©%_Aíƒ^Ô¹†¿•+MÂ~Ó+C6NGÿy¦”Qjû%ªönJ·[JÎS»ž*lj-õ( ¤!¾ŽS ”Ÿ˜$ä÷Á¨ú˜«ºHìà¹,‡¹e8Ïsïö¦1FI'3‘ÈRv™ výN6²×D’ámy•¡ -ú›ƒPÕ4¯–ƒ¤,"˜yL²‰àŒŒñUzã.®„!4$/Ô'i·5]!ÀîŽFC ýY#µGWÄÿü¯9ì>‹¸Ù8%hÁÊqù¦¬~xM‹ ÕœcœV1·'ušPË…@¯±¡#`³%%uj++FЯbi¤¯ÜŒ¥ØÌ ‰m6öVó Ü3ƒM’æä§-yoávÊ#y‚• 8ÊÐÚS”ŒvWØÓhšÆFÜsÛ¿ÕO[ê7Áß+‘:»¤ïèÝ2ÜãbX_¤\É ò1÷í[¥î°´ù.Øç„­v©§²ù]Õ˜)›»(Và$¼}¤”­§8šê¾«Î<’vZƒ¨)F r Êùó×—Âr×h»Ú$<Óo<¦+KJç ¶{{äq])нNCü™†qñÿ3ô\ëâGÇ$bHœGÐå|æÖzeV™ï¥÷þa! í|x®—²Ü8œ.3êË‘.\rhävP…-+K‡ü£ÅZíô•¯fn–;”Ìãé'%9ǨAI6yHâs»f@¥Ú7 ”“79ÂÈ?‘”´ 9.jn*NÃe£y $bÆxX¹ÇºÅÇ–¼äcŽ)@O!$Ç$¾š×“ÛÞ²L‹wY¶¿H,pI …“[ÂÖ§¬óí^ƒ…ƒŽ­ÊóiãÆkÖ…Ž•‰È +5–¾Ë "=—­€ã4ž‚í‚"po)BFôäm§2; ~ë ü»eépò9üSfœ¼® ì±l{çíNÜ윂™³$¥-­*FÅ1ç™yîSï3Ñ€7[’â>†sã5ãj´ìÎ Æá)J‹›TR½c,„HK6&´å(Ü’µ©;aN¡À#•™9D„oØ[PÜ®ã”ÍÁÀ*>f»+­í)Nìi Gâ8N …¥¹)Í‹R;8ó÷¤»ˆnégB t𜠰‘°Îsæ¤Ä­h&Øñ²NQn1 ƒOu’CˆÙ,Ñ„¬„„¨«qQí÷¦-pk‰nånV agjÑ´$ûVJç¿…Ž‘…±ÔÅ@x ç)ÆN^ç¿öIkºo{bÿì¤ ù#4âF‡cH^ š;¦Õ$¶’s‘M%Ãr½–véئÕÈ@J¸ÞqŒSVJtúFTcš¿^ÞaÂØm@ûŒö¯•Bœ€3Ýwë#8O퀅«„‘ß>ôØP8Ëê”úœ<,Ÿy¤µÂ†s“ϱ«§,?ÉnÊN6“Êjpµ!¿Óœœr*X Ì äowe‹p#€IñšfúhØî•lÏÊG>ÌÃçÓZAÈã£E1ÈRPU871ÊÒT…¤¶”þÔÊ¢¢hHÉRÖ¿±QÔh ãÇbT¤¬¿Ž; ý=ikw ¨ºZü„Ix² iÉÎ9b³õ!)F]ÆF ¤/z=ÈlG<ãjéAy;©&Ö0î¡Né—R¢Œ'EN²êÒT”-!DfÙ”VIlä㱩¸+¶Ø©äl¢²¬ªõÒçÅKCpÀK·•¬Y€çg8ñJà{¥Ž=–J„0@ όמt´rš„ÛÉJóXýì'`ÉR­nGCN†þ“Þ’ÄŒ¯ ŠÞˆÞº“ôþqIº]!8‚W€¥–ë^íŸAÇsŠˆª¬º°B0½£š‰ JéKˆö=³TË̯{r²\xÙlÖ6ÔM|ÈdþIÙj‹¥ÊN‘¸nê¤á*ã*nzŒ„þ-ŽU™ji”±• ªÇT¬{‹¶O"hq$§ZßµHi³ŽSöœ`…&´Æ!ŽïÅEUÌ3…™•Oô¹nÛ{¶Jå’²“Ø€|ÔL³ŽNà&u’k…ÚJímO©ôç7HŒÁ„ÅÕn…´ZHÉäqâ k £u8’&i—_íÝS-_xŠ°j:›Žë…Vó‚jÂ~‘¸Ôãc2¶³FFTöÉ,¶ûN«qÁÉöªõl[&óÒ‡rWBÇž™¶µHBÊ?•´Õ²Ù²ª3EåÈTV¬%§Öîóù«¥¹*GËËr¬[ÑsOŶ¨¢ª0dvH2Ú2^í”rñ¥ãÞa8‡=?«œN¨nï§a4¦§$GÞ:1å©võ”¹ß.+öÅl.·xÙé¥mZ¶;ªrñ .ö×m¥·!#¦®t]I  ²@ÛvÔ¢.é‹ë”XV<š›ŽëNîë (Î6L²ío¶• PW~iôU?312R4ÅAã' RÆrJhé7ÙyéúèØÒrRº·Mª·¬¹ÉÇüS‘8ÂpÉGáAa  B½ëÝ{¯@ß9X±nqn Ã鬤©,*rfÜá$'¶4Õõ 6 ['$EJŽߌSC)'œ­‚0A!I ?èkJ}Ò«{L2…ƒŠEÒ;ºü6wläð)„î÷K4'¶ )DR|SÔ³VaÉé¨@ ÎϽ1}Fû¤KÒ°ÙJZˆÆ3ŠqO;‰ÀJDI ª#Ì£ ´•säù¬¦Çr—tgº|a_IO<Ô{ÛÝe NVÀ„nÈHJ¬2S„¡•aX=é7·)å1™Ú^“õ~õ Vܧ.*^â²ÎñýCãÕ…ÃÉLr2‘•ƒíOcÉürdegü€H>1IOrŸRã›GÕÇ~;T{‚ÁÎ#„õn‘³¬çÛ4Îx³Ùxó¾T¥ðêYAïœÓÑ픳]î‘9?r‚wŸõ¬E>¬sÊ{³òÎó·ÿڣ«hÙg,çr¬HikåÊWÄ ˆhÎr™¾AÝE'VNà0{SÈZzе®b’[Kk##µ4©Œn²w \ò ŒÓ™ÌcñLˆÚ Æ¢ lC¯ X=ë×;Ù*dÇ*ÖÓ3ÜK(JI8Ærqöⱦl€—ãÓ•W)á>ß@qµ’Êãn;Š}U\0B…îÕžÊ Hiå “¼+œù¨¹†ˆˆu5C*} Å—<Šƒ‰û’‘Ø õiHaJZl©>H«T-t:Üp›±Ä¸&Tº…¸>€Ø°ªí}C†’¤ÔÞĦÒúФnàaYóYBCA(ªŒãeAU/1Ú°$ÙeA%%ÃãÕ3F<¥`¥‹-)\'Ô¯Os{ä}©˜hcÃh)l©9NAâ¬ßô‡(ùX R·ž¦J|óÞ£já'1çdƒc욤$: R0š¨×Ñ–¿H)ôgtœÇ ÛÉQóš…¬¥-Áå.%%2Ö–2{ã“U›³òÂÜQ¾¬$! é$Š®FÎÍCºÅ9*¤`åbìv[ À$`ÒòOˆX” «î9¦¤‡}PA 9`¢ NO|Ó?»ã%,Ù±Îê9qŠûO¡m¸ÖFSŽi:6´²?5-I;\Â7T–»·HlJZC‘ÖIq¥cŒTíãΦlIVJ @_3úí¢md»uŒÚ ˆøRã­@£ä郼ÌÆùl;-}Õ–9Úñœ/™Ýa¶YÊ’äfn–åzJõ܉+ryÛ”ž1ÿšë€¯™„‰N@=‡ó\Ù×´ñÈÝNËvìHÇÕ|ÞꔄÔwd·pRä#$¤ò>ßzé~—º½Çoú.BêË4——góÊæùQÇ'¿8â¶$2—œ´u3u&C@œRñï’«N°HržÃýëÌî˜ÈÁÂÅ a,«vJÁ¬“&ȲÐ\ $%$Vg~›QáQkvHóYŒ¬Y†g+RžÉ dæ½Âo$ùØ$äf„ÝÑŽåý«ÒRa¸Y}dIHûQ’³kO+Üà~‘@)mò·lÀÎ>Õƒs²Qд ” WjSP# !ÎA[ÐŽ2Sþµçdø4…áFÕ‚”©YîiHŸƒ˜ãÂX¶˜Ÿ©8ö¯{—vR n„ËJ¨ùŒ€œ/ü$aô­Í*Hïù¥¼Ðâ1q¥ÉmÜd$§'Í9g²zdaÊÚèRrŸ¼v@Ün½ä%ПZð…!Ž3HO) ±„8lSƒO¯~äd¬w#Š_H `õ L ÂTÐQ%JQOqX´‘é+s²Ø¤8‘ê%Ô`qûSª³#ƒH8Âô? Ým)R–ϪO¹¦îÛ8Üû¯5™oz‹VB}‡þiÅ<9ÉH™¬&—É.”€Uã¿zâ]²ÂXƒœв~ ­èò1æ¨a=ðRSSð“­%H[Ž< DÇéõ¬„FS{¨!ÃéŒþõœ’jþWê'N꣼â–÷< â¾aÆÖcIÝ} žQr¹"]÷°—…c8*íJTA;?ˆð‘lg9Q{î¥ù|}hI>Æ©õÄÏ&G*nŽ‡#u¦%å×á¥m­jO$(+µ”Þ[aÉRQR1%~u i}aÌàf£ ‰ÃÔ9^ºˆPSØ3Ò[qŇR Å%Gã$¹"è6ÙJÐ|£+Våx·æ”¹RÅ!kÏÂfÙÜÌ£L¶Õl㚇e•¥øw Á\匫zeÔ «‘ÇÞ•4ì„£åzÚÇ’¨MG¤§\!;’OµUº?Ħá¯p*,î‡Z¢”ÈQÆiÛ/9R´Õúy*§»è¹1e) hg¶*ÓG|k›±VX.Mp¨%ãO)§JÁ'àU‚Šå‘T¬3ŒlTIëzÐHÛŠšeP)û%Êõ»IS`ìQQûPêÌSÊwŒ—ǵá¼-ý»ÓgÖo²tœžµ1! „ €Ñ•®iÉJÆÍI¡e²î§øïO]^ß•"Æà¥!ãžp QQ—e:¦üIÊSO…v¤Ój‡Ü=æù-Õ8Ø885 pp–kÀMe …$ýYäSÍN৸a>By;qžڣ猥£~”ûÖÖâFx5+H ë\qœ©„e%µ7¸mG~ BÊ3•‰ç úDÆÜ\t£ Zp4Á°Sªa•ƒlž¿”(yÒÛØžÕ^©¬‹an­”ÖK²Þq!!;ïSlx M5øåKmL9émÎ=ª®A©f'^Ö}ˆÓkpƒ’pàsÅUjbõgܪÜÒÍ…TÜ".÷&NÍÁ(<ýên™ÞKB˜. ®× JW¤Jþ“Æ+Ê©ÀÝ.áÔìÇ`AB¶ ùäTKŸ“±MC@áJô×OXÔÖË”’Îâ–û籧´ÓÌé?¤*ŧDá¥s¥óK.ÆKA´6ŠrjÃEv`*e¬s†Z¢©Ñ†t‚’”«ñS ¾hjB£-ôª£VôýæäHC1%? «…§©$(ÉbÛIi9zŽ””¤g¸«{/ 8QÒÓ°Þ«C¬¤)MòOµ9ûèw&aÏ%6È„ê²R’6¢‘€zpX5ØK’pŒÿïIwÂv$X!߯¶ãCš8p¤ö‰HJ¾°qÅDUÄJÌ¿ Le!GhÜ=ê/É)HÞÊL€ã™Š’|R¤ºr*„¥¶’œ}|~)»(‚·¥òÉJ° ¬KSp Ž”e){ry½3™¸N¥»§ïP';ŠE2p#„˜©i8X‡BÔ;Õëšp4áJ-«^´aÁ÷¨é È'²TÌwRön«Úá?O÷¨ŠˆÆ•$€œ„Úü¦Ô¤ÖQ4Š‘‚PvK­K)q°09¦õ9ÎË9¦ÀV4V]’ž;cÞš=…ÎÀQÏ£p”˜)Ž ¨##•n=©Ó–Œ”ERçÓ…šàã R•lÀÎG­-Ic°8KJÌò§È+)W©¹³Æ}9­œù¡Ý’,f8QFÛäA+jI’%ÚIVŒ ž˜!8Çb*f–&WäÊQuu)eo¥8`Nkåk‘Ý)ÎTF÷¼·2¡Àɪ5L¹vT±n@V5ŸÕËnzCh8<÷¤#Îœ‘ÝFNð•>ö¡Dð?µNܦ%íΙÍEtz„»½Gy˜9=“¸Á)Þ%Á—’ÒÒ|sR±ÈÀ2 õì”ð‹ÊH#ƒßñNI.aX@ÃTîÈòP°Séäd4âä< “ʶáÈÚÐB¸F0xvóq ­Q»µ–J¥­¤ECTR–¤q :B ì'v¯À\‚ì”øÙOɦK MºØîÜ’ƒþÔÂh\Hî†dr›Š¨¬ÖS¿^À2•–Ñ€¢OŠŒš m ¹ç :FýÍñƒâ«w:bæ7”£†rNôgXl¨c¾œ+5<p¸Ç¬:2mI«Í¸óE§wŒþ+ktPÉ Áª:÷sÆAä¯]t麭ò%„:Ô´¡i ÏÒŸ)ÀïÚ»3î¬F01…ÍýoÓÀèÁú¯™WÓfZíì©·AZRöäûïö®·é{Ã&Ý£JãÈèÛË®LÉiÅî É$VÕ¢•¸\çt¥{N Ž­•sÉ©HÞbvã ¢Á§#tÁì< 0„„x&³ ÷M´F6w)+® `#ŒVmh&“JÍIÜI-¡yäÖI¤‘ús•¤$ŽEH6?•‘Ú;dšnnW»@ñ^•æ…°Ià ô¸’Í98 RœR¤V) %#e½·01ƒ»¿5àYÆÔ¥ºW‚x¯R' ­­©`”òF{ט=’¬—§„mOÔ .׿¯9ÂNiϧ‰.mNÞyþÔÌ7|¦ñ»|¤í:È (ŸÔ¤™ÆêY³4÷S(‰ÊŽìf£%pÁ É%n qeÄ­;TIæ˜çdÈÈøKH䥎ù4›£öN)žRèo4˨úŽ3À¤$§Ër–ä+JÄòž[ o Jˆ^Æ£ä> ²‹«ÒÒ¥×[[ˆ¸¶ËXã·§tŽÁ.Û …=Vøʇ1p¤mÊT’yã½4Š3Ãœ©w?-SA9+ŠÐHJR?ÖÈñ¶É(åÛÔRKz÷”’89ªó`Ó(ÁÊZ9s²šÚN1š˜ûÀ”“žIÁH.¯­ÖJ‹iíLk ÞÜö^± ÕnKÄ€à昚x\í†SãT@±ìÒRJII¥“pzŽ81Àñö¥ØSI£qvÁ/n…Åc¾?5èÇtîm-ÉZÃ{”J¶¤RL9Ù`Øòü¬ÒÊÕÂ?H=éP ÂhÎSãf;h(Û¹Xî)Ë™†á§:7ú{¥kQ)Iàc¹¦Òy€n‡4»bËoúd+ >æˆ*ð4ç& i8){vð•Vâ8¯g8ÒS†ÂÑÀOÑ£ „ãžÝéí8õœ!îì–ïChÀ"—š¿×«p“"RýC¼«*>)æNèÆxN -´ÉÂhc4œºÏV; Ëi\”§pðiaT†é]-)3²æM]I¹ITÊÂÎîÕŒšžC—‰Ö¶7lVR¿jrÙŒMÐÓ²jæy$C®(…%ÂT{Ó2Âã—r9Ÿ8Ze!@­JPS‡Çµ³ŽR3þÚŸM$Œ+œÒpìàç‰ktgºñç’ ¢ÑNªÂ5@WÜH·¤'«óbZ`WÓܤ°ç-<­Gpðj‹¨§“¨G+Ÿ$¾œçǽ#X*l»H D‹ñ²–—Þ╖w+0”Å”¥I%g'?Ú›ÉÓ²_^¬ØÚˆ³ Ð(ýW€2Õ“-n¯CÌ,ŽB†99¦òÈÝ.Yº“@ÝnKIYúP ÅCÔÓùd¬ì¨ì»¨ðW¢7çµ>‰ÒJw÷Â9)¶é§PÞXFìwÅekšý$©Ë}ׂªÉ%ªB”–”>gŠâw*ÑMZÉQ™°\mÅ¡m‘Ž3RÔõf¡ª`j:œ8RI²œ‰Ûd%ì¦íI=Ç;' —)>ݲ$ãÅgý)ç˜N ˜FœÛqÈW8T4Ôä¹IÅ' ¡q›\VÞHòiódÓ”à8•ìHm·µ5Œó8¬ÁʹúSpfË©!ÍRZBy+íM©ëLRê ª…½Âé",o)¯¬“Û½j{œæÒÙõ‘€i£îÓ°ÉRÖÖ9´;œ*n eòT Fx;Pðæ§âCÙYpÜp4„‚v`UVvY)HäÏ*ZÜ€Ìt ý8þõø²õžwV·O} r¾Yôåµ6sMFÙ šãÙ7¸Ô9­«Þý=&BÒHÅFѵîRÑÍ«Pë5ÝR¦–R¥•-^)åeœ%fy¹]-:»M¥å:Ð+-“õ †`ú p£„®‘àe@£Þr?¢“üмŠs-ÙRìvžº´tå>Â#Ooz¯IsÃqºŠ¹ŒJ+¬m¥2ˆu(žøæœÆçFòÕ7C'òÁ ”³n¬²€æT@ÀëÙ¤2úFåcpòòUΫ[V)kf@Þ•§û~j"9Œoto »!20öSšÚ!Þ/*†âP–”®pœçBŽÌ•U¢’ÖøõµÄa½û¨Oâ®Û ‹z‹Ñë<Iq1Д‚@!#?šbÛ¥M;´ÈvV Z÷8 —(ê-*Ölm튶P^‹ÆêZ)IªžájC-;OŒv«E5a n–**ì_¬ç$f¥Y.BP½jC+Û´“ÜÖN~WÉÍ”¤€R¼ÓIžxC”©YoŒ÷¤š3ÊÏ„®2 ǹ¤&Øáb\‚ûÓ=E`³óXŒ¬ÙŽëSã-+4¤dçuá;ì¢ËBÓ#)IÏcS,9nJt΂2NrJª.Wd$ZAüISŠ@I|b‘h=’nö Giú©rÜ…ëZ1’t§n?I¦’³mѬ§fT‰*9qL]ÂV7s….·íq( FR95>BÉï'tªZS…(å)ŒyXÅ)G•%ÉמÝêDDì'L”“…'·-Å¡ @HÏz‰©`ÊF}Ê[!Ç)’9Í"ÈY@Gkˆþ÷RN;b²–<”‡J™5 †’®*"H›”›&9Jã:¥>€•p}©œ­Ù<ì¤ PR ÇŠdÓ„˜ ’x«(u;È>ßzÍÜ'br±¤Ô¥¼Ö#Õ PÂ$JŒ­vNê̾ËqQP‡\ R‡qR5µtxyÎÊ"™¾¬…RÉÂæ%)_Ò Æ)„3¸·~ÊÁ¬¤Ì…¥–ÀQPÀíXŸG #¾é|é½¼’*=”ú¾Ë&É¥N™{ ¥G·ÏšP@7Y¾CKÉ’Ðâ}2¬¬˜Ó£)6Îr¶[[NÕ…wf±£¢i$e;/R¨.z; F@P>õ_L#f¶g9;+B$ÆC{–‚¥)8üS¸©ÝÔ-Nê#|x$¬€yǵ{HÒæv%?¥ÄaE-÷çml%I$œûÔ5U`dš6Ê›kN7V½…ý‘Êp¤îð|Sê }DžéŒ±ïº–ÅZFÂ¥gšsRZ2›H1²œ[€Ø!G9ïRV÷‡7… Q8*_Õ¸¦ðŸ¶)Z‚ç&lvœ-Š…ziÚ‚œî…¸'4Çt©­Á]Žß4µXÈÝ&êC;FÎŽ+iÂõ+f6âÙ¼xóQsÙvã )&Û rÓúvþ‘QõÃŒ$ØòºØH*ï¨æç9NCò9xÝÇ·÷¨›§¢sN£Òc-e%![sZâª71¸å&1¶¤¥G£F’–l¹;$ëk‡úŠIôLÒR¢B´©% ¨ÒrY„©ÆʱŒvÉ+)†‘ÊõÂDôUŸÒ  {ñMžçŒv äuVz²À¤´ñAQ! €SÁ©ŠY˜Çc;©Hëuî¾nuÛI‘&\ŲÒ[RS´ç“É®Žðúë£@ʤuX.eñìšmèÉ•9lî á$ùÅwA]£8®Wëë`½|ÍÕ6—¢=*B³#*QV{ƒšê;mHsZ3Ùqúá”¹Jqn-%>š3ØUÞŸð€«¯å2nÚµ?kˆ ÏÙ"Z\*;8IóAùQRFìúP¦\OÞ³bÆJWãe©(PQ÷¯ »$Ä. r³ŽÃ‰øJ]Ö$ cš^6äc çX´œ¨áB±uŒmÏ+zJ”’ö¬šíÒ­`áoRÌÒ€e™ÒxK|zC`Ø€?½:/»p½$wH’ÈpoÜA>ÔÕ±¸XétãF²@þô?->¥˜JS^§¨€Cuˆ‘߈ ‚F(;§$Ch ¸°OúSÂCÙºT†™B¢„—äÔÃÌs41ê½QBY»BW%¸Î0´•ç°[B&¦œ€š0¸}T1ËXR–m'½#/d)ºk‰iÝB.ömèy^ŠS÷§´•e§S4×#¯•Y¹dPqÅ%´žµZ#¯ÁWz:òìn‘?m ǵ:Š¥®SÐÕ·%0I%+#ñOânBd©Ñ…¥hlöÍ4‘¤„ú’ ƒƒÂ\œ+ôð{~i®=Ô¨”ý[¥ßø¨ù'ÃùyX35ÈnlÊЬã5›¡Ö2³#)%Úbe<’â·¨÷¥© -%ÙÂÐÄp²œ$â³’RU®Â³mPå»*FHÅU«'"]’>aÏ¥1N¸†‚Z8$ T…=)qÊq‡‡+?¥·†Eѵl w'ŒÓ:ºSœgMî !Šo¯]’òŠwàðEV¨Þ|ÂÓÈKÛÙéUΉ‹ê_bÃÕÉÚ¬289ÍiøO*ÎJ½z”mí˜à46ö5_E^[ÂŒµgV럭.¹ë+vH&”­hÓ²µcl®˜éÌU)öŸt,´‘íUvÄ$œ«·yA,õ¤Ø²uBV aXã·íX†k¨vÉ[p-ˆ%ZeôľDq¼¤c¶qQq8ë^UœÆAV†¸ˆ¦œb@’´å'ö¬®ñ˜¥kÏ&V×奩?Jn’mÚª1Ip6§>¡Žõ-Òu†±² gÔ´í}9Êî+•½+ese²V—Q¹ œc>ki])´eÓV¼¥a½•Ô= V§f¶V¡»žk[_­ «±Ä•ÂÚËCÆRÞ-Govr@ÿÆÕÔ$=•¡¼* û¢ÝK+Z"å#ØUîÝxÙÊU öTÂĨî:Tßøìjï {])Vœ(Ê¡mQP$dÔ¨Ùzçe*f;m@æ°tÄ Ýaµ;”HŽ²”4v‘´qíX?}Ê𜥄 ¤2¼(IñŒbŒ¯^;Ãj8â½o+ ˜ÏÔ¼ç½? %‚phö¦®ùMœ¯(%99ÇÚ†n¼`ÂHÉAQV .ðViÑ·›-”ã ði£˜s”% HJUŒŒö¤_!e—€§v™* ØH#Å@Õ1c'§”²xSwßÛ4” À쨦ЗÛR™Ût°vTÒÓƒŒ•d ‚*"u㟲YqP ÊÝŽi(óÒ‘‚ɲ"ˆ óÿŠRPžy£º™Ç}%”•c&¡æŒ—e3sÀrv€ê©N'šŽ©Œ”§˜ ™ÊR2R­„{v¨YM̃²aY-É-‚R¬j@FKuòF0U£¤%2ÛÍ€¼{Ó)cÀÉ):ì¬{ŒæÜ`´ P¸¦5µ ³HQ13ʯŽß]KÇ9¤D­ÑŽêa§ Ê–EWò±¸ûVnnGä’:R¶’J))MG¶M'$,ÞSâe8Ûi*ž+Q§„šC*ä‡Vr01ö¯'Øç)f n¤–u¥Mþ¡»÷ïIÛ s¤/iÆRï©Êalq ¸ûæ½­p,#pRNœaM#Jl±½N±Æ=ë#P3ŒîšÔC ’^õPwù§3Õ·Byof£6Åà «uUjêš[¤ ÁSŽ8Ý\Veúm dãÍ:¦qÊŒ’@çd)\U¸¬”âY vRNò¬!R€{ç5-ARå@̬!<(pEKÄƈÔ\²žÛÖÚ›JR2œy©'4L’W¯) +¦µu )ãŽVQä ¨4SÆ0 FÁri“Ë!fŸ#— OƘBÓ•ˆ8Pµ,—R ³ÍLúRà©•¥ð”§‘Û¨j¶î‚ïtí%M¸„‚ž|ÓF•˜yL­8_#)Í:srZÚ{§ø‹%GqL¥ÀÂÀœ•$µàHBœ$àÔe_áY±øì­`¤¢"TßÕ„çžÕ ØÉ ’ƒN^÷‰=k‡'°;Ê—ØV)(VG>ƙԹº0R’É’¬N4ªÆ3PÍíÆ7QØ=“c ú/ôé®0滄ý²ŽWõŽˆí8•#rT6•5lé‰[ænr¬™¥‹å/^ìí<ÌÂ. §‚8ÿï5×þW†î´÷UÆÙtŒ¯ýO€ÔI-²R‰$( ¦»[¥.N‘ ²ãŽ³§kíC 5ÒëŽ ‚9à s[–Ö@ås­èB€HäUV¨Ã´äp©“œjíɯHLß&;-~ª×€‘°ÖbBFg8`l’9ꨓšàBŽ8»u‡óÎ2+¿/4;•½”£iÜyî>ô®vÊR 9)SQøQ8MdØÉK¶0NÉ{QÙoëçì3Þ”xhØÒƒm–Ål’‘Ÿ”Ò1!Ýåcé§ òE,×1ç¯\ÂVÆÛlà1ØRÂ&5»•‚]é4‚\>1Ú½DÞû¡lm§·îÀ ì)_¼7l÷^e*JÒõå*Í5‘Î9^iÛ /P«$K ]ùXùexçžßjpÝÜì²×”©1¢œöȤ›Õ¥¼/t“¸KŒNå…ŽÔî:`Ñ—$œwKe)õNŽ)HšÇò—‰„rµËq–Â}3¼‘ÏÚ¼”´Ö ¬ä ­Éè(NóŠÊ2ãtÔŒ•ÇÒÊYåT¤ Ü÷Y‚JDäxØûÒl©iÙÃdx'”n6„à`)äŒð².#”Òûû²@9ïMšì‚™UîBF‡@YàÚšE§RH;¬Tà À?Q§cH “œÒÜçt‰Jò®)Ãô´e3Êû[Å©³¹Y¯U,…ôÖ#ºXV ‚G4Ý S†Ó³+PJ9¦¯hÊtÎÄu¨(£ŒŠk#AOã>¥½kQß“œ@4(·FZ‚VA9¤åhI»•/³8µ)`œ€Ÿj†®Œc)ü|§”8¼»Š`æ )Fð¶ïW½% ,²SݽÅú!Yæ™OÔ”o*CŨ¨‹€$Êu¶ºçª“»¹ÿŠeRÁ…) õõ­dn$㊎ Äa7‡XãH!fBP™RuCšðÄÞpšÍpNÓÈ>¡ÏÔF~vJ[CÊm RÉÍ#;Î…YCA***qàçíH’2™F™G,’pNìWšAN©\D˜ °¾¡åa PñST8Wh^t¨„€¢dÔÜJÉey'u©¥¯¶x¥ ²Àã¬'Ë3‹à(àƒQõì‘YÝÝqk•»jN€p†p [Õê+Ÿ¬­hÒœ@âpJz„ëŸËŽ?úTtñ…"§0^uIJT²FÊž&ó„' #êÓa²õ¼¥–e©Pv28ûÖ3ã%e"v»I|ïÅc€º†Ë ­°Ö­¬«<æ˜;ñ' Ün®¨N¯þ™@ÝÁ&¡î¿ÐdùåDm/8%6±õ{V@zJ™á+¢}ÔZZÚ² @Ïí|…°ì«Qÿå\Ï©\_ñ7Îy ãíEì çô­Nž¾ïÏÅÎ8©Kl-óÎÊçøJë‹ü©5¥%ÕœdTÕýç,oeN·0kyNj<[\Üž|ö¦WÚß,ŽvþêG±*Q\—îQyå¸Øw‘Ƶ£;(êN j"S À;+ËîÐà%iÇ­Q³›A)% Î}«SUDÕugá[Ý$[œÆ8Æ8íLå™þQLâU§mµ6¢¤ œâÙ#¶Ý;!r®©i¿]Áé§ø­­h{°7AT­ñ¶Âð@aWš"V*¾xœU…œ!&S®¤¥.µú‹Èúz÷@BÍJ%I -n­[>Õ›Z2„•*WÕÏšõá ZNˆ¤Ï(LS¢pNy©80½ÊÕj qš'!+’âÉý^i(ã (Ö¸®¸$¡!\sÅ-’ÏškFR­á1(2=éÓFéí×€¢7•€Œ” >•)´8²êQ?P¨ªÖ )hxVñQùCÏôÔ%+Ž¬&ª¹˜âýPwy©WŽ˜û'Ë+·6…3MDm/Á Žêp\_¤“»œÔ}|mlm-IDòNéÂ+‹õ3¸æ«³ ò——…+aÅyÅaŽé¸å92¥ÁÇj}MÂõܯd¸æÅ}gŠŒâ)Ôu+Q¬œò|PÁ²x¥6Ç•`àx¤jñ# Æ‚µA'ž) ‰mð‘)Ì:¼«ý)½$‡[~©ìmZc¸¸°¥€xo½IÖ¸‚HNbJ-®/ÕûT}Ãðªq•lÚ\X@àjbN2˜T¾Þ¥a\ÓãÿôÎú¦\…:²8¿§ê5í N‰Õä ÜcþjÅD⌛º‘‡RQ"¬eä “8Zqh) V?j§_œZÖãÝ>`Ï)KO8J2¯ÕÉ2‘{@OQ^p8œ+¶(’Gjå$JvyÅåQìkÊç ¬"9åj:•p¬sŽÕæ»mÖkÖ¢y>3Q•ä—n½ÎË&Ö ¦p{‘ši ÎÙèWaõ╨h;”â4Á-jíž6Õ2èãæaJR¦T¸° â“¢qÁRÒ4a+ܤ¬àã5ìR7’$dn²Z‰q9ö§¯9p+öC®Ž¹é§êÿõ†˜—–ÆH÷XT¼‚0¹_«Î-È)gqÚ³Ú­Ý7ÿ•¥{UÿŒ¯•}[Q\V[_Ô‚ò²œ+­ú!ä7e«¯œ/Ž?.(\îxÂpxÀë·|=`,nW ø…øäú® »º½ê½üVý¡`À\Ó^pÒ r\^IÏš³C´xTÇKHåCóY$r·¯ Ý´@=“‡m¸Ië³ÁFLpr²BWA ÀâY”œŒñY${%­©Cf GøSÆ“’Ô œçÅLÊÑåjî½ZÛ%IqG“‘UÙ ;•“9KÒ£„vííR?/7á^—TOp)jŸÂSd©’C€ùâ™3ñ,[ÂpJŽäŒñšzÇöçÝ&Õä¥ç·juTïçþiQÂÖÉúnõŒŸ‰`óºÍ*PQçÍeÑ’Âáñ’žjf€½“®Ë[î¸@ àý«7“ñ$jųÒu, Æt¸µ€I#›SÿäX¿„•KW¤®OêÅ?wá)£¹HR²±ž)„ü%V•°IïïHH=+ÀÑœ¤R”¢Q“íL$yÕ„„Ý“s„€5”|&õ¤ ýj¤¡>¢™È…’¨yÈI¤k$““šÆGwBÿÙcpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/pygments.css000066400000000000000000000067061240331347200253750ustar00rootroot00000000000000.hll { background-color: #404040 } .c { color: #999999; font-style: italic } /* Comment */ .err { color: #a61717; background-color: #e3d2d2 } /* Error */ .g { color: #d0d0d0 } /* Generic */ .k { color: #6ab825; font-weight: bold } /* Keyword */ .l { color: #d0d0d0 } /* Literal */ .n { color: #d0d0d0 } /* Name */ .o { color: #d0d0d0 } /* Operator */ .x { color: #d0d0d0 } /* Other */ .p { color: #d0d0d0 } /* Punctuation */ .cm { color: #999999; font-style: italic } /* Comment.Multiline */ .cp { color: #cd2828; font-weight: bold } /* Comment.Preproc */ .c1 { color: #999999; font-style: italic } /* Comment.Single */ .cs { color: #e50808; font-weight: bold; background-color: #520000 } /* Comment.Special */ .gd { color: #d22323 } /* Generic.Deleted */ .ge { color: #d0d0d0; font-style: italic } /* Generic.Emph */ .gr { color: #d22323 } /* Generic.Error */ .gh { color: #ffffff; font-weight: bold } /* Generic.Heading */ .gi { color: #589819 } /* Generic.Inserted */ .go { color: #cccccc } /* Generic.Output */ .gp { color: #aaaaaa } /* Generic.Prompt */ .gs { color: #d0d0d0; font-weight: bold } /* Generic.Strong */ .gu { color: #ffffff; text-decoration: underline } /* Generic.Subheading */ .gt { color: #d22323 } /* Generic.Traceback */ .kc { color: #6ab825; font-weight: bold } /* Keyword.Constant */ .kd { color: #6ab825; font-weight: bold } /* Keyword.Declaration */ .kn { color: #6ab825; font-weight: bold } /* Keyword.Namespace */ .kp { color: #6ab825 } /* Keyword.Pseudo */ .kr { color: #6ab825; font-weight: bold } /* Keyword.Reserved */ .kt { color: #6ab825; font-weight: bold } /* Keyword.Type */ .ld { color: #d0d0d0 } /* Literal.Date */ .m { color: #3677a9 } /* Literal.Number */ .s { color: #ed9d13 } /* Literal.String */ .na { color: #bbbbbb } /* Name.Attribute */ .nb { color: #24909d } /* Name.Builtin */ .nc { color: #447fcf; text-decoration: underline } /* Name.Class */ .no { color: #6AB825 } /* Name.Constant */ .nd { color: #ffa500 } /* Name.Decorator */ .ni { color: #d0d0d0 } /* Name.Entity */ .ne { color: #bbbbbb } /* Name.Exception */ .nf { color: #447fcf } /* Name.Function */ .nl { color: #d0d0d0 } /* Name.Label */ .nn { color: #447fcf; text-decoration: underline } /* Name.Namespace */ .nx { color: #d0d0d0 } /* Name.Other */ .py { color: #d0d0d0 } /* Name.Property */ .nt { color: #6ab825; font-weight: bold } /* Name.Tag */ .nv { color: #40ffff } /* Name.Variable */ .ow { color: #6ab825; font-weight: bold } /* Operator.Word */ .w { color: #666666 } /* Text.Whitespace */ .mf { color: #3677a9 } /* Literal.Number.Float */ .mh { color: #3677a9 } /* Literal.Number.Hex */ .mi { color: #3677a9 } /* Literal.Number.Integer */ .mo { color: #3677a9 } /* Literal.Number.Oct */ .sb { color: #ed9d13 } /* Literal.String.Backtick */ .sc { color: #ed9d13 } /* Literal.String.Char */ .sd { color: #ed9d13 } /* Literal.String.Doc */ .s2 { color: #ed9d13 } /* Literal.String.Double */ .se { color: #ed9d13 } /* Literal.String.Escape */ .sh { color: #ed9d13 } /* Literal.String.Heredoc */ .si { color: #ed9d13 } /* Literal.String.Interpol */ .sx { color: #ffa500 } /* Literal.String.Other */ .sr { color: #ed9d13 } /* Literal.String.Regex */ .s1 { color: #ed9d13 } /* Literal.String.Single */ .ss { color: #ed9d13 } /* Literal.String.Symbol */ .bp { color: #24909d } /* Name.Builtin.Pseudo */ .vc { color: #40ffff } /* Name.Variable.Class */ .vg { color: #40ffff } /* Name.Variable.Global */ .vi { color: #40ffff } /* Name.Variable.Instance */ .il { color: #3677a9 } /* Literal.Number.Integer.Long */ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/reset-fonts-grids.css000066400000000000000000000126221240331347200271000ustar00rootroot00000000000000/* Copyright (c) 2008, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.net/yui/license.txt version: 2.5.1 */ html{color:#000;background:#FFF;}body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,textarea,p,blockquote,th,td{margin:0;padding:0;}table{border-collapse:collapse;border-spacing:0;}fieldset,img{border:0;}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}li{list-style:none;}caption,th{text-align:left;}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal;}q:before,q:after{content:'';}abbr,acronym {border:0;font-variant:normal;}sup {vertical-align:text-top;}sub {vertical-align:text-bottom;}input,textarea,select{font-family:inherit;font-size:inherit;font-weight:inherit;}input,textarea,select{*font-size:100%;}legend{color:#000;}body {font:13px/1.231 arial,helvetica,clean,sans-serif;*font-size:small;*font:x-small;}table {font-size:inherit;font:100%;}pre,code,kbd,samp,tt{font-family:monospace;*font-size:108%;line-height:100%;} body{text-align:center;}#ft{clear:both;}#doc,#doc2,#doc3,#doc4,.yui-t1,.yui-t2,.yui-t3,.yui-t4,.yui-t5,.yui-t6,.yui-t7{margin:auto;text-align:left;width:57.69em;*width:56.25em;min-width:750px;}#doc2{width:73.076em;*width:71.25em;}#doc3{margin:auto 10px;width:auto;}#doc4{width:74.923em;*width:73.05em;}.yui-b{position:relative;}.yui-b{_position:static;}#yui-main .yui-b{position:static;}#yui-main{width:100%;}.yui-t1 #yui-main,.yui-t2 #yui-main,.yui-t3 #yui-main{float:right;margin-left:-25em;}.yui-t4 #yui-main,.yui-t5 #yui-main,.yui-t6 #yui-main{float:left;margin-right:-25em;}.yui-t1 .yui-b{float:left;width:12.30769em;*width:12.00em;}.yui-t1 #yui-main .yui-b{margin-left:13.30769em;*margin-left:13.05em;}.yui-t2 .yui-b{float:left;width:13.8461em;*width:13.50em;}.yui-t2 #yui-main .yui-b{margin-left:14.8461em;*margin-left:14.55em;}.yui-t3 .yui-b{float:left;width:23.0769em;*width:22.50em;}.yui-t3 #yui-main .yui-b{margin-left:24.0769em;*margin-left:23.62em;}.yui-t4 .yui-b{float:right;width:13.8456em;*width:13.50em;}.yui-t4 #yui-main .yui-b{margin-right:14.8456em;*margin-right:14.55em;}.yui-t5 .yui-b{float:right;width:18.4615em;*width:18.00em;}.yui-t5 #yui-main .yui-b{margin-right:19.4615em;*margin-right:19.125em;}.yui-t6 .yui-b{float:right;width:23.0769em;*width:22.50em;}.yui-t6 #yui-main .yui-b{margin-right:24.0769em;*margin-right:23.62em;}.yui-t7 #yui-main .yui-b{display:block;margin:0 0 1em 0;}#yui-main .yui-b{float:none;width:auto;}.yui-gb .yui-u,.yui-g .yui-gb .yui-u,.yui-gb .yui-g,.yui-gb .yui-gb,.yui-gb .yui-gc,.yui-gb .yui-gd,.yui-gb .yui-ge,.yui-gb .yui-gf,.yui-gc .yui-u,.yui-gc .yui-g,.yui-gd .yui-u{float:left;}.yui-g .yui-u,.yui-g .yui-g,.yui-g .yui-gb,.yui-g .yui-gc,.yui-g .yui-gd,.yui-g .yui-ge,.yui-g .yui-gf,.yui-gc .yui-u,.yui-gd .yui-g,.yui-g .yui-gc .yui-u,.yui-ge .yui-u,.yui-ge .yui-g,.yui-gf .yui-g,.yui-gf .yui-u{float:right;}.yui-g div.first,.yui-gb div.first,.yui-gc div.first,.yui-gd div.first,.yui-ge div.first,.yui-gf div.first,.yui-g .yui-gc div.first,.yui-g .yui-ge div.first,.yui-gc div.first div.first{float:left;}.yui-g .yui-u,.yui-g .yui-g,.yui-g .yui-gb,.yui-g .yui-gc,.yui-g .yui-gd,.yui-g .yui-ge,.yui-g .yui-gf{width:49.1%;}.yui-gb .yui-u,.yui-g .yui-gb .yui-u,.yui-gb .yui-g,.yui-gb .yui-gb,.yui-gb .yui-gc,.yui-gb .yui-gd,.yui-gb .yui-ge,.yui-gb .yui-gf,.yui-gc .yui-u,.yui-gc .yui-g,.yui-gd .yui-u{width:32%;margin-left:1.99%;}.yui-gb .yui-u{*margin-left:1.9%;*width:31.9%;}.yui-gc div.first,.yui-gd .yui-u{width:66%;}.yui-gd div.first{width:32%;}.yui-ge div.first,.yui-gf .yui-u{width:74.2%;}.yui-ge .yui-u,.yui-gf div.first{width:24%;}.yui-g .yui-gb div.first,.yui-gb div.first,.yui-gc div.first,.yui-gd div.first{margin-left:0;}.yui-g .yui-g .yui-u,.yui-gb .yui-g .yui-u,.yui-gc .yui-g .yui-u,.yui-gd .yui-g .yui-u,.yui-ge .yui-g .yui-u,.yui-gf .yui-g .yui-u{width:49%;*width:48.1%;*margin-left:0;}.yui-g .yui-gb div.first,.yui-gb .yui-gb div.first{*margin-right:0;*width:32%;_width:31.7%;}.yui-g .yui-gc div.first,.yui-gd .yui-g{width:66%;}.yui-gb .yui-g div.first{*margin-right:4%;_margin-right:1.3%;}.yui-gb .yui-gc div.first,.yui-gb .yui-gd div.first{*margin-right:0;}.yui-gb .yui-gb .yui-u,.yui-gb .yui-gc .yui-u{*margin-left:1.8%;_margin-left:4%;}.yui-g .yui-gb .yui-u{_margin-left:1.0%;}.yui-gb .yui-gd .yui-u{*width:66%;_width:61.2%;}.yui-gb .yui-gd div.first{*width:31%;_width:29.5%;}.yui-g .yui-gc .yui-u,.yui-gb .yui-gc .yui-u{width:32%;_float:right;margin-right:0;_margin-left:0;}.yui-gb .yui-gc div.first{width:66%;*float:left;*margin-left:0;}.yui-gb .yui-ge .yui-u,.yui-gb .yui-gf .yui-u{margin:0;}.yui-gb .yui-gb .yui-u{_margin-left:.7%;}.yui-gb .yui-g div.first,.yui-gb .yui-gb div.first{*margin-left:0;}.yui-gc .yui-g .yui-u,.yui-gd .yui-g .yui-u{*width:48.1%;*margin-left:0;}s .yui-gb .yui-gd div.first{width:32%;}.yui-g .yui-gd div.first{_width:29.9%;}.yui-ge .yui-g{width:24%;}.yui-gf .yui-g{width:74.2%;}.yui-gb .yui-ge div.yui-u,.yui-gb .yui-gf div.yui-u{float:right;}.yui-gb .yui-ge div.first,.yui-gb .yui-gf div.first{float:left;}.yui-gb .yui-ge .yui-u,.yui-gb .yui-gf div.first{*width:24%;_width:20%;}.yui-gb .yui-ge div.first,.yui-gb .yui-gf .yui-u{*width:73.5%;_width:65.5%;}.yui-ge div.first .yui-gd .yui-u{width:65%;}.yui-ge div.first .yui-gd div.first{width:32%;}#bd:after,.yui-g:after,.yui-gb:after,.yui-gc:after,.yui-gd:after,.yui-ge:after,.yui-gf:after{content:".";display:block;height:0;clear:both;visibility:hidden;}#bd,.yui-g,.yui-gb,.yui-gc,.yui-gd,.yui-ge,.yui-gf{zoom:1;}cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/_static/uri.svg000066400000000000000000000721231240331347200243310ustar00rootroot00000000000000 image/svg+xml mailto:john.doe@example.com { scheme { path ftp://john.doe:password@www.example.com:8021 { scheme { host { port password { { username { user_info { authority http://www.example.com/resource/?key=value#page1 { scheme path { { authority { query { fragment cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/conf.py000066400000000000000000000102431240331347200226550ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # cpp-netlib documentation build configuration file, created by # sphinx-quickstart on Wed Jun 23 20:50:04 2010. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys, os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.append(os.path.abspath('_ext')) # -- General configuration ----------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.todo', 'sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.coverage', ] todo_include_todos = True # Add any paths that contain templates here, relative to this directory. # templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. source_encoding = 'utf-8' # The master toctree document. master_doc = 'contents' # General information about the project. project = u'cpp-netlib' copyright = u'2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '0.11' # The full version, including alpha/beta/rc tags. release = '0.11.1' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. unused_docs = [ '' ] # List of directories, relative to source directory, that shouldn't be searched # for source files. exclude_trees = ['build', 'doxyxml', 'ext'] # If true, '()' will be appended to :func: etc. cross-reference text. # add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. # show_authors = False # The name of the Pygments (syntax highlighting) style to use. # pygments_style = 'sphinx' pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. # modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. html_theme = 'pyramid' # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". html_title = 'cpp-netlib v0.11.1' # A shorter title for the navigation bar. Default is the same as html_title. # html_short_title = 'cpp-netlib' # Use an HTML index. html_use_index = False # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". # html_style = 'cpp-netlib.css' # html_static_path = ['_static'] # html_translator_class = "adjusts.CppNetlibHTMLTranslator" # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. html_use_smartypants = True # Output file base name for HTML help builder. # htmlhelp_basename = 'cpp-netlibdoc' cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/contents.rst000066400000000000000000000003311240331347200237420ustar00rootroot00000000000000.. _contents: Contents -------- .. toctree:: :maxdepth: 4 index.rst whats_new.rst getting_started.rst examples.rst in_depth.rst techniques.rst history.rst reference.rst references.rst cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples.rst000066400000000000000000000014421240331347200237270ustar00rootroot00000000000000.. _examples: 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. All examples are built using CMake. 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: 1 examples/http/http_client examples/http/simple_wget examples/http/hello_world_server examples/http/hello_world_client examples/http/atom_reader examples/http/twitter_search cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/000077500000000000000000000000001240331347200231745ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/http/000077500000000000000000000000001240331347200241535ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/http/atom_reader.rst000066400000000000000000000041671240331347200271770ustar00rootroot00000000000000.. _atom_reader: ****************** Atom feed reader ****************** The next examples show some simple, more practical applications using the HTTP client. The first one reads a simple Atom_ feed and prints the titles of each entry to the console. .. _Atom: http://en.wikipedia.org/wiki/Atom_(standard) The code ======== .. code-block:: c++ #include "atom.hpp" #include #include #include int main(int argc, char * argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); atom::feed feed(response); std::cout << "Feed: " << feed.title() << " (" << feed.subtitle() << ")" << std::endl; BOOST_FOREACH(const atom::entry &entry, feed) { std::cout << entry.title() << " (" << entry.published() << ")" << std::endl; } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; } Building and running ``atom_reader`` ==================================== .. code-block:: bash $ cd ~/cpp-netlib-build $ make atom_reader And to run the example from the command line to access the feed that lists of all the commits on cpp-netlib's master branch: .. code-block:: bash $ ./example/atom_reader https://github.com/cpp-netlib/cpp-netlib/commits/master.atom Diving into the code ==================== Most of this will now be familiar. The response is passed to the constructor to the ``atom::feed`` class, which parses the resultant XML. To keep this example as simple as possible, `rapidxml`_, a header-only XML parser library, was used to parse the response. .. _`rapidxml`: http://rapidxml.sourceforge.net/ A similar example using RSS feeds exists in ``libs/network/example/rss``. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/http/hello_world_client.rst000066400000000000000000000053241240331347200305610ustar00rootroot00000000000000.. _hello_world_http_client: *************************** "Hello world" HTTP client *************************** Since we have a "Hello World" HTTP server, let's then create an HTTP client to access that server. This client will be similar to the HTTP client we made earlier in the documentation. The code ======== We want to create a simple HTTP client that just makes a request to the HTTP server that we created earlier. This really simple client will look like this: .. code-block:: c++ #include #include #include #include namespace http = boost::network::http; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { http::client client; std::ostringstream url; url << "http://" << argv[1] << ":" << argv[2] << "/"; http::client::request request(url.str()); http::client::response response = client.get(request); std::cout << body(response) << std::endl; } catch (std::exception & e) { std::cerr << e.what() << std::endl; return 1; } return 0; } Building and running the client =============================== Just like with the HTTP Server and HTTP client example before, we can build this example by doing the following on the shell: .. code-block:: bash $ cd ~/cpp-netlib-build $ make hello_world_client This example can be run from the command line as follows: .. code-block:: bash $ ./example/hello_world_client http://127.0.0.1:8000 .. note:: This assumes that you have the ``hello_world_server`` running on localhost port 8000. Diving into the code ==================== All this example shows is how easy it is to write an HTTP client that connects to an HTTP server, and gets the body of the response. The relevant lines are: .. code-block:: c++ http::client client; http::client::request request(url.str()); http::client::response response = client.get(request); std::cout << body(response) << std::endl; You can then imagine using this in an XML-RPC client, where you can craft the XML-RPC request as payload which you can pass as the body to a request, then perform the request via HTTP: .. code-block:: c++ http::client client; http::client::request request("http://my.webservice.com/"); http::client::response = client.post(request, some_xml_string, "application/xml"); std::data = body(response); The next set of examples show some more practical applications using the :mod:`cpp-netlib` HTTP client. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/http/hello_world_server.rst000066400000000000000000000103251240331347200306060ustar00rootroot00000000000000.. _hello_world_http_server: *************************** "Hello world" HTTP server *************************** Now that we've seen how we can deal with request and response objects from the client side, we'll see how we can then use the same abstractions on the server side. In this example we're going to create a simple HTTP Server in C++ using :mod:`cpp-netlib`. The code ======== The :mod:`cpp-netlib` provides the framework to develop embedded HTTP servers. For this example, the server is configured to return a simple response to any HTTP request. .. code-block:: c++ #include #include #include namespace http = boost::network::http; struct hello_world; typedef http::server server; struct hello_world { void operator() (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } }; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { hello_world handler; server server_(argv[1], argv[2], handler); server_.run(); } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } This is about a straightforward as server programming will get in C++. Building and running the server =============================== Just like with the HTTP client, we can build this example by doing the following on the shell: .. code-block:: bash $ cd ~/cpp-netlib-build $ make hello_world_server The first two arguments to the ``server`` constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously. This example can be run from a command line as follows: .. code-block:: bash $ ./example/hello_world_server 0.0.0.0 8000 .. note:: If you're going to run the server on port 80, you may have to run it as an administrator. Diving into the code ==================== Let's take a look at the code listing above in greater detail. .. code-block:: c++ #include This header contains all the code needed to develop an HTTP server with :mod:`cpp-netlib`. .. code-block:: c++ struct hello_world; typedef http::server server; struct hello_world { void operator () (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } }; ``hello_world`` is a functor class which handles HTTP requests. All the operator does here is return an HTTP response with HTTP code 200 and the body ``"Hello, !"``. The ```` in this case would be the IP address of the client that made the request. There are a number of pre-defined stock replies differentiated by status code with configurable bodies. All the supported enumeration values for the response status codes can be found in ``boost/network/protocol/http/impl/response.ipp``. .. code-block:: c++ hello_world handler; server server_(argv[1], argv[2], handler); server_.run(); The first two arguments to the ``server`` constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously. .. note:: In this example, the server is specifically made to be single-threaded. In a multi-threaded server, you would invoke the ``hello_world::run`` member method in a set of threads. In a multi-threaded environment you would also make sure that the handler does all the necessary synchronization for shared resources across threads. The handler is passed by reference to the server constructor and you should ensure that any calls to the ``operator()`` overload are thread-safe. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/http/http_client.rst000066400000000000000000000066251240331347200272330ustar00rootroot00000000000000.. _http_client: ************* HTTP client ************* The first code example is the simplest thing you can do with the :mod:`cpp-netlib`. The application is a simple HTTP client, which can be found in the subdirectory ``libs/network/example/http_client.cpp``. All this example doing is creating and sending an HTTP request to a server and printing the response body. The code ======== Without further ado, the code to do this is as follows: .. code-block:: c++ #include #include int main(int argc, char *argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " [url]" << std::endl; return 1; } http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); std::cout << body(response) << std::endl; return 0; } Running the example =================== You can then run this to get the Boost_ website: .. code-block:: bash $ cd ~/cpp-netlib-build $ make http_client $ ./example/http_client http://www.boost.org/ .. _Boost: http://www.boost.org/ .. note:: The instructions for all these examples assume that :mod:`cpp-netlib` is build outside the source tree, according to `CMake conventions`_. For the sake of consistency we assume that this is in the ``~/cpp-netlib-build`` directory. .. _`CMake conventions`: http://www.cmake.org/Wiki/CMake_FAQ#What_is_an_.22out-of-source.22_build.3F Diving into the code ==================== Since this is the first example, each line will be presented and explained in detail. .. code-block:: c++ #include All the code needed for the HTTP client resides in this header. .. code-block:: c++ http::client client; First we create a ``client`` object. The ``client`` abstracts all the connection and protocol logic. The default HTTP client is version 1.1, as specified in `RFC 2616`_. .. code-block:: c++ http::client::request request(argv[1]); Next, we create a ``request`` object, with a URI string passed as a constructor argument. .. code-block:: c++ request << header("Connection", "close"); :mod:`cpp-netlib` makes use of stream syntax and *directives* to allow developers to build complex message structures with greater flexibility and clarity. Here, we add the HTTP header "Connection: close" to the request in order to signal that the connection will be closed after the request has completed. .. code-block:: c++ http::client::response response = client.get(request); Once we've built the request, we then make an HTTP GET request throught the ``http::client`` from which an ``http::response`` is returned. ``http::client`` supports all common HTTP methods: GET, POST, HEAD, DELETE. .. code-block:: c++ std::cout << body(response) << std::endl; Finally, though we don't do any error checking, the response body is printed to the console using the ``body`` directive. That's all there is to the HTTP client. In fact, it's possible to compress this to a single line: .. code-block:: c++ std::cout << body(http::client().get(http::request("http://www.boost.org/"))); The next example will introduce the ``uri`` class. .. _`RFC 2616`: http://www.w3.org/Protocols/rfc2616/rfc2616.html cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/http/simple_wget.rst000066400000000000000000000060541240331347200272310ustar00rootroot00000000000000.. _simple_wget: *************** Simple `wget` *************** This example is a very simple implementation of a ``wget`` style clone. It's very similar to the previous example, but introduces the ``uri`` class. The code ======== .. code-block:: c++ #include #include #include #include #include namespace http = boost::network::http; namespace uri = boost::network::uri; namespace { std::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; } } // namespace int main(int argc, char *argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " url" << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); http::client::response response = client.get(request); std::string filename = get_filename(request.uri()); std::cout << "Saving to: " << filename << std::endl; std::ofstream ofs(filename.c_str()); ofs << static_cast(body(response)) << std::endl; } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } Running the example =================== You can then run this to copy the Boost_ website: .. code-block:: bash $ cd ~/cpp-netlib-build $ make simple_wget $ ./example/simple_wget http://www.boost.org/ $ cat index.html .. _Boost: http://www.boost.org/ Diving into the code ==================== As with ``wget``, this example simply makes an HTTP request to the specified resource, and saves it on the filesystem. If the file name is not specified, it names the resultant file as ``index.html``. The new thing to note here is use of the ``uri`` class. The ``uri`` takes a string as a constructor argument and parses it. The ``uri`` parser is fully-compliant with `RFC 3986`_. The URI is provided in the following header: .. _`RFC 3986`: http://www.ietf.org/rfc/rfc3986.txt .. code-block:: c++ #include Most of the rest of the code is familiar from the previous example. To retrieve the URI resource's file name, the following function is provided: .. code-block:: c++ std::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; } The ``uri`` interface provides access to its different components: ``scheme``, ``user_info``, ``host``, ``port``, ``path``, ``query`` and ``fragment``. The code above takes the URI path to determine the resource name. Next we'll develop a simple client/server application using ``http::server`` and ``http::client``. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/examples/http/twitter_search.rst000066400000000000000000000066061240331347200277440ustar00rootroot00000000000000.. _twitter_search: **************** Twitter search **************** This example uses `Twitter's search API`_ to list recent tweets given a user query. New features introduced here include the URI builder and ``uri::encoded`` function. .. _`Twitter's search API`: https://dev.twitter.com/docs/using-search The code ======== .. code-block:: c++ #include #include "rapidjson/rapidjson.h" #include "rapidjson/document.h" #include int main(int argc, char *argv[]) { using namespace boost::network; using namespace rapidjson; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; uri::uri base_uri("http://search.twitter.com/search.json"); std::cout << "Searching Twitter for query: " << argv[1] << std::endl; uri::uri search; search << base_uri << uri::query("q", uri::encoded(argv[1])); http::client::request request(search); http::client::response response = client.get(request); Document d; if (!d.Parse<0>(response.body().c_str()).HasParseError()) { const Value &results = d["results"]; for (SizeType i = 0; i < results.Size(); ++i) { const Value &user = results[i]["from_user_name"]; const Value &text = results[i]["text"]; std::cout << "From: " << user.GetString() << std::endl << " " << text.GetString() << std::endl << std::endl; } } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; } .. note:: To parse the results of these queries, this example uses `rapidjson`_, a header-only library that is released under the `MIT License`_. .. _`rapidjson`: http://code.google.com/p/rapidjson/ .. _`MIT License`: http://www.opensource.org/licenses/mit-license.php Building and running ``twitter_search`` ======================================= .. code-block:: bash $ cd ~/cpp-netlib-build $ make twitter_search Twitter provides a powerful set of operators to modify the behaviour of search queries. Some examples are provided below: .. code-block:: bash $ ./example/twitter_search "Lady Gaga" Returns any results that contain the exact phrase "Lady Gaga". .. code-block:: bash $ ./example/twitter_search "#olympics" Returns any results with the #olympics hash tag. .. code-block:: bash $ ./example/twitter_search "flight :(" Returns any results that contain "flight" and have a negative attitude. More examples can be found on `Twitter's search API`_ page. Diving into the code ==================== .. code-block:: c++ uri::uri base_uri("http://search.twitter.com/search.json"); std::cout << "Searching Twitter for query: " << argv[1] << std::endl; uri::uri search; search << base_uri << uri::query("q", uri::encoded(argv[1])); The :mod:`cpp-netlib` URI builder uses a stream-like syntax to allow developers to construct more complex URIs. The example above re-uses the same base URI and allows the command line argument to be used as part of the URI query. The builder also supports percent encoding using the ``encoded`` directive. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/getting_started.rst000066400000000000000000000235521240331347200253060ustar00rootroot00000000000000.. _getting_started: ***************** Getting Started ***************** Downloading an official release =============================== You can find links to the latest official release from the project's official website: http://cpp-netlib.org/ All previous 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/cpp-netlib/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:: Previous versions of :mod:`cpp-netlib` referred to the *mikhailberis* repository as the main development repository. This account is still valid, but not always up-to-date. In the interest of consistency, the main repository has been changed to *cpp-netlib*. 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/cpp-netlib/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.50.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 .. warning:: There is a known incompatibility between :mod:`cpp-netlib` and Boost 1.46.1 on some compilers. It is not recommended to use :mod:`cpp-netlib` with Boost 1.46.1. Some have reported though that Boost 1.47.0 and :mod:`cpp-netlib` work together better. 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 :mod:`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:: $ mkdir ~/cpp-netlib-build $ cd ~/cpp-netlib-build $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=gcc \ > -DCMAKE_CXX_COMPILER=g++ \ > ../cpp-netlib .. note:: While it's not compulsory, it's recommended that :mod:`cpp-netlib` is built outside the source directory. For the purposes of documentation, we'll assume that all builds are done in ``~/cpp-netlib-build``. If you intend to use the SSL support when using the HTTP client libraries in :mod:`cpp-netlib`, you may need to build it with OpenSSL_ installed or at least available to CMake. If you have the development headers for OpenSSL_ installed on your system when you build :mod:`cpp-netlib`, CMake will be able to detect it and set the ``BOOST_NETWORK_ENABLE_HTTPS`` macro when building the library to support HTTPS URIs. One example for building the library with OpenSSL_ support with a custom (non-installed) version of OpenSSL_ is by doing the following:: $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=clang \ > -DCMAKE_CXX_COMPILER=clang++ \ > -DOPENSSL_ROOT_DIR=/Users/dberris/homebrew/Cellar/openssl/1.0.1f > ../cpp-netlib .. _OpenSSL: http://www.openssl.org/ You can also use a different root directory for the Boost_ project by using the ``-DBOOST_ROOT`` configuration option to CMake. This is useful if you intend to build the library with a specific version of Boost that you've built in a separate directory:: $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=clang \ > -DCMAKE_CXX_COMPILER=clang++ \ > -DOPENSSL_ROOT_DIR=/Users/dberris/homebrew/Cellar/openssl/1.0.1f \ > -DBOOST_ROOT=/Users/dberris/Source/boost_1_55_0 > ../cpp-netlib 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 ``~/cpp-netlib-build``:: $ 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. However, this compile-time burden is much reduced in recent versions. .. _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 You can install :mod:`cpp-netlib` by issuing:: $ sudo make install By default this installs :mod:`cpp-netlib` into ``/usr/local``. .. note:: As of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using GCC on Linux these are:: libcppnetlib-client-connections.a libcppnetlib-server-parsers.a libcppnetlib-uri.a Users can find them in ``~/cpp-netlib-build/libs/network/src``. Building On Windows ~~~~~~~~~~~~~~~~~~~ If you're using the Microsoft Visual C++ compiler or the Microsoft Visual Studio IDE and you would like to build :mod:`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. .. note:: As of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using Visual C++ on Windows they are:: cppnetlib-client-connections.lib cppnetlib-server-parsers.lib cppnetlib-uri.lib Users can find them in ``~/cpp-netlib-build/libs/network/src``. Using :mod:`cpp-netlib` ======================= CMake projects ~~~~~~~~~~~~~~ Projects using CMake can add the following lines in their ``CMakeLists.txt`` to be able to use :mod:`cpp-netlib`:: set ( CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ~/cpp-netlib-build ) find_package ( cppnetlib 0.11.0 REQUIRED ) include_directories ( ${CPPNETLIB_INCLUDE_DIRS} ) target_link_libraries ( MyApplication ${CPPNETLIB_LIBRARIES} ) .. note:: Setting ``CMAKE_PREFIX_PATH`` is only required when :mod:`cpp-netlib` is not installed to a location that CMake searches. When :mod:`cpp-netlib` is installed to the default location (``/usr/local``), ``CMake`` can find it. .. note:: We assume that ``MyApplication`` is the application that you are building and which depends on :mod:`cpp-netlib`. 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/cpp-netlib/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 http://groups.google.com/forum/#!forum/cpp-netlib. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/history.rst000066400000000000000000000041711240331347200236140ustar00rootroot00000000000000Project history =============== The :mod:`cpp-netlib` was founded by Dean Michael Berris in 2007. Initially it consisted of a message template and an HTTP client. It found a home on Sourceforge_ but was migrated at the end of 2009 to Github_ where development is actively continued by a committed community. Motivation ~~~~~~~~~~ We're a group of C++ developers and we kept becoming annoyed that we had to repeatedly write the same code when building applications that needed to be network-aware. We found that there was a lack of accessible networking libraries, either standard or open source, that fulfilled our needs. Such libraries exist for every other major language. So, building on top of `Boost.Asio`_, we decided to get together and build our own. Objectives ~~~~~~~~~~ The objectives of the :mod:`cpp-netlib` are to: * develop a high quality, portable, easy to use C++ networking library * enable developers to easily extend the library * lower the barrier to entry for cross-platform network-aware C++ applications The goal the of :mod:`cpp-netlib` has never been to build a fully-featured web server - there are plenty of excellent options already available. The niche that this library targets is for light-weight networking functionality for C++ applications that have demanding performance requirements or memory constraints, but that also need to be portable. This type of application is becoming increasingly common as software becomes more distributed, and applications need to communicate with services. While many languages provide direct library support for high level network programming, this feature is missing in C++. Therefore, this library has been developed with the intention of eventually being submitted to Boost_, a collection of general, high quality libraries for C++ developers. Eventually, the :mod:`cpp-netlib` will be extended to support many of the application layer protocols such as SMTP, FTP, SOAP, XMPP etc. .. _Sourceforge: http://sourceforge.net/projects/cpp-netlib/ .. _Github: http://github.com/cpp-netlib/cpp-netlib .. _Boost: http://www.boost.org/ .. _`Boost.Asio`: http://www.boost.org/libs/asio/ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/000077500000000000000000000000001240331347200223225ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.buildinfo000066400000000000000000000003461240331347200243010ustar00rootroot00000000000000# 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: ae0de19b7b7891744d7373f4a9b6c125 tags: fbb0d17656682115ca4d033fb2f83ba1 cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/000077500000000000000000000000001240331347200242105ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/contents.doctree000066400000000000000000000073171240331347200274240ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}qXcontentsqˆsUsubstitution_defsq}qUparse_messagesq ]q cdocutils.nodes system_message q )q }q (U rawsourceqUUparentqcdocutils.nodes section q)q}q(hUU referencedqKhhUsourceqcdocutils.nodes reprunicode qX>/Users/dean/Documents/cpp-netlib/libs/network/doc/contents.rstq…q}qbUexpect_referenced_by_nameq}qhcdocutils.nodes target q)q}q(hX .. _contents:hhhhUtagnameqUtargetqU attributesq }q!(Uidsq"]Ubackrefsq#]Udupnamesq$]Uclassesq%]Unamesq&]Urefidq'Ucontentsq(uUlineq)KUdocumentq*hUchildrenq+]ubshUsectionq,h }q-(h$]q.Xcontentsq/ah%]h#]h"]q0(h(Uid1q1eh&]q2hauh)Kh*hUexpect_referenced_by_idq3}q4h(hsh+]q5(cdocutils.nodes title q6)q7}q8(hXContentsq9hhhhhUtitleq:h }q;(h$]h%]h#]h"]h&]uh)Kh*hh+]q…q?}q@(hh9hh7ubaubcdocutils.nodes compound qA)qB}qC(hUhhhhhUcompoundqDh }qE(h$]h%]qFUtoctree-wrapperqGah#]h"]h&]uh)Nh*hh+]qHcsphinx.addnodes toctree qI)qJ}qK(hUhhBhhhUtoctreeqLh }qM(UnumberedqNKU includehiddenqO‰hXcontentsqPU titlesonlyqQ‰UglobqR‰h"]h#]h$]h%]h&]UentriesqS]qT(NXindexqU†qVNX whats_newqW†qXNXgetting_startedqY†qZNXexamplesq[†q\NXin_depthq]†q^NX techniquesq_†q`NXhistoryqa†qbNX referenceqc†qdNX referencesqe†qfeUhiddenqg‰U includefilesqh]qi(hUhWhYh[h]h_hahcheeUmaxdepthqjKuh)Kh+]ubaubeubhhhUsystem_messageqkh }ql(h$]UlevelKh"]h#]qmh1aUsourcehh%]h&]UlineKUtypeUINFOqnuh)Kh*hh+]qocdocutils.nodes paragraph qp)qq}qr(hUh }qs(h$]h%]h#]h"]h&]uhh h+]qth=X+Duplicate implicit target name: "contents".qu…qv}qw(hUhhqubahU paragraphqxubaubaUcurrent_sourceqyNU decorationqzNUautofootnote_startq{KUnameidsq|}q}hh(sh+]q~(hhehUU transformerqNU footnote_refsq€}qUrefnamesq‚}qƒUsymbol_footnotesq„]q…Uautofootnote_refsq†]q‡Usymbol_footnote_refsqˆ]q‰U citationsqŠ]q‹h*hU current_lineqŒNUtransform_messagesq]qŽh )q}q(hUh }q‘(h$]UlevelKh"]h#]Usourcehh%]h&]UlineKUtypehnuh+]q’hp)q“}q”(hUh }q•(h$]h%]h#]h"]h&]uhhh+]q–h=X.Hyperlink target "contents" is not referenced.q—…q˜}q™(hUhh“ubahhxubahhkubaUreporterqšNUid_startq›KU autofootnotesqœ]qU citation_refsqž}qŸUindirect_targetsq ]q¡Usettingsq¢(cdocutils.frontend Values q£oq¤}q¥(Ufootnote_backlinksq¦KUrecord_dependenciesq§NU rfc_base_urlq¨Uhttp://tools.ietf.org/html/q©U tracebackqªˆUpep_referencesq«NUstrip_commentsq¬NU toc_backlinksq­Uentryq®U language_codeq¯Uenq°U datestampq±NU report_levelq²KU _destinationq³NU halt_levelq´KU strip_classesqµNh:NUerror_encoding_error_handlerq¶Ubackslashreplaceq·Udebugq¸NUembed_stylesheetq¹‰Uoutput_encoding_error_handlerqºUstrictq»U sectnum_xformq¼KUdump_transformsq½NU docinfo_xformq¾KUwarning_streamq¿NUpep_file_url_templateqÀUpep-%04dqÁUexit_status_levelqÂKUconfigqÃNUstrict_visitorqÄNUcloak_email_addressesqňUtrim_footnote_reference_spaceqƉUenvqÇNUdump_pseudo_xmlqÈNUexpose_internalsqÉNUsectsubtitle_xformqʉU source_linkqËNUrfc_referencesqÌNUoutput_encodingqÍUutf-8qÎU source_urlqÏNUinput_encodingqÐUutf-8qÑU_disable_configqÒNU id_prefixqÓUU tab_widthqÔKUerror_encodingqÕUUS-ASCIIqÖU_sourceq×U>/Users/dean/Documents/cpp-netlib/libs/network/doc/contents.rstqØUgettext_compactqÙˆU generatorqÚNUdump_internalsqÛNU smart_quotesq܉U pep_base_urlqÝUhttp://www.python.org/dev/peps/qÞUsyntax_highlightqßUlongqàUinput_encoding_error_handlerqáh»Uauto_id_prefixqâUidqãUdoctitle_xformqä‰Ustrip_elements_with_classesqåNU _config_filesqæ]qçUfile_insertion_enabledqèˆU raw_enabledqéKU dump_settingsqêNubUsymbol_footnote_startqëKUidsqì}qí(h(hh1huUsubstitution_namesqî}qïhh*h }qð(h$]h"]h#]Usourcehh%]h&]uU footnotesqñ]qòUrefidsqó}qôh(]qõhasub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/environment.pickle000066400000000000000000002333741240331347200277610ustar00rootroot00000000000000€(csphinx.environment BuildEnvironment qoq}q(Udlfilesqcsphinx.util FilenameUniqDict q)qc__builtin__ set q]…RqbUappq NU reread_alwaysq h]…Rq Utitlesq }q (X examples/http/hello_world_serverqcdocutils.nodes title q)q}q(U rawsourceqUU attributesq}q(Udupnamesq]Uclassesq]Ubackrefsq]Unamesq]Uidsq]uUchildrenq]qcdocutils.nodes Text qX"Hello world" HTTP serverq…q}q(hX"Hello world" HTTP serverq Uparentq!hubaUtagnameq"Utitleq#ubX referencesq$h)q%}q&(hUh}q'(h]h]h]h]h]uh]q(hX Referencesq)…q*}q+(hX Referencesq,h!h%ubah"h#ubXexamplesq-h)q.}q/(hUh}q0(h]h]h]h]h]uh]q1hXExamplesq2…q3}q4(hXExamplesq5h!h.ubah"h#ubX in_depth/uriq6h)q7}q8(hUh}q9(h]h]h]h]h]uh]q:hX The URI classq;…q<}q=(hX The URI classq>h!h7ubah"h#ubXcontentsq?h)q@}qA(hUh}qB(h]h]h]h]h]uh]qChXContentsqD…qE}qF(hXContentsqGh!h@ubah"h#ubXin_depthqHh)qI}qJ(hUh}qK(h]h]h]h]h]uh]qL(hXAn in-depth look at the qM…qN}qO(hXAn in-depth look at the qPh!hIubcdocutils.nodes literal qQ)qR}qS(hX cpp-netlibh}qT(h]h]h]h]h]uh!hIh]qUhX cpp-netlibqV…qW}qX(hUh!hRubah"UliteralqYubeh"h#ubXindexqZh)q[}q\(hUh}q](Udupnamesq^]Uclassesq_]Ubackrefsq`]Uidsqa]Unamesqb]uh]qchXGetting cpp-netlibqd…qe}qf(hXGetting cpp-netlibqgh!h[ubah"UtitleqhubXtechniques/directivesqih)qj}qk(hUh}ql(h]h]h]h]h]uh]qmhX Directivesqn…qo}qp(hX Directivesqqh!hjubah"h#ubX referenceqrh)qs}qt(hUh}qu(h]h]h]h]h]uh]qvhXReference Manualqw…qx}qy(hXReference Manualqzh!hsubah"h#ubX examples/http/hello_world_clientq{h)q|}q}(hUh}q~(h]h]h]h]h]uh]qhX"Hello world" HTTP clientq€…q}q‚(hX"Hello world" HTTP clientqƒh!h|ubah"h#ubXreference/http_serverq„h)q…}q†(hUh}q‡(h]h]h]h]h]uh]qˆhXHTTP Server APIq‰…qŠ}q‹(hXHTTP Server APIqŒh!h…ubah"h#ubXreference/http_responseqh)qŽ}q(hUh}q(h]h]h]h]h]uh]q‘hX HTTP Responseq’…q“}q”(hX HTTP Responseq•h!hŽubah"h#ubX techniquesq–h)q—}q˜(hUh}q™(h]h]h]h]h]uh]qšhX Techniquesq›…qœ}q(hX Techniquesqžh!h—ubah"h#ubXexamples/http/twitter_searchqŸh)q }q¡(hUh}q¢(h]h]h]h]h]uh]q£hXTwitter searchq¤…q¥}q¦(hXTwitter searchq§h!h ubah"h#ubXexamples/http/simple_wgetq¨h)q©}qª(hUh}q«(h]h]h]h]h]uh]q¬(hXSimple q­…q®}q¯(hXSimple q°h!h©ubcdocutils.nodes title_reference q±)q²}q³(hX`wget`q´h}qµ(h]h]h]h]h]uh!h©h]q¶hXwgetq·…q¸}q¹(hUh!h²ubah"Utitle_referenceqºubeh"h#ubXexamples/http/http_clientq»h)q¼}q½(hUh}q¾(h]h]h]h]h]uh]q¿hX HTTP clientqÀ…qÁ}qÂ(hX HTTP clientqÃh!h¼ubah"h#ubXtechniques/polymorphismqÄh)qÅ}qÆ(hUh}qÇ(h]h]h]h]h]uh]qÈhXStatic and dynamic polymorphismqÉ…qÊ}qË(hXStatic and dynamic polymorphismqÌh!hÅubah"h#ubXtechniques/tag_metafunctionsqÍh)qÎ}qÏ(hUh}qÐ(h]h]h]h]h]uh]qÑhXTag metafunctionsqÒ…qÓ}qÔ(hXTag metafunctionsqÕh!hÎubah"h#ubXin_depth/messageqÖh)q×}qØ(hUh}qÙ(h]h]h]h]h]uh]qÚhXThe message templateqÛ…qÜ}qÝ(hXThe message templateqÞh!h×ubah"h#ubXin_depth/http_client_tagsqßh)qà}qá(hUh}qâ(h]h]h]h]h]uh]qãhX qä…qå}qæ(hUh!hàubah"h#ubXexamples/http/atom_readerqçh)qè}qé(hUh}qê(h]h]h]h]h]uh]qëhXAtom feed readerqì…qí}qî(hXAtom feed readerqïh!hèubah"h#ubXgetting_startedqðh)qñ}qò(hUh}qó(h]h]h]h]h]uh]qôhXGetting Startedqõ…qö}q÷(hXGetting Startedqøh!hñubah"h#ubX whats_newqùh)qú}qû(hUh}qü(h^]h_]h`]ha]hb]uh]qýhX What's Newqþ…qÿ}r(hX What's Newrh!húubah"hhubXreference/http_requestrh)r}r(hUh}r(h]h]h]h]h]uh]rhX HTTP Requestr…r}r (hX HTTP Requestr h!jubah"h#ubXreference/http_clientr h)r }r (hUh}r(h^]h_]h`]ha]hb]uh]rhXHTTP Client APIr…r}r(hXHTTP Client APIrh!j ubah"hhubXhistoryrh)r}r(hUh}r(h]h]h]h]h]uh]rhXProject historyr…r}r(hXProject historyrh!jubah"h#ubX in_depth/httprh)r}r(hUh}r (h]h]h]h]h]uh]r!hXHTTP implementationr"…r#}r$(hXHTTP implementationr%h!jubah"h#ubuU domaindatar&}r'(Ustd}r((U anonlabels}r)(XindexhZUindex†Ugenindexr*j*U†Xhello_world_http_serverr+hUhello-world-http-serverr,†X referencer-hrU referencer.†Umodindexr/U py-modindexU†Xhello_world_http_clientr0h{Uhello-world-http-clientr1†X whats_newr2hùU whats-newr3†Xtwitter_searchr4hŸUtwitter-searchr5†Usearchr6UsearchU†Xexamplesr7h-Uexamplesr8†X simple_wgetr9h¨U simple-wgetr:†X atom_readerr;hçU atom-readerr<†X http_clientr=h»U http-clientr>†Xgetting_startedr?hðUgetting-startedr@†XcontentsrAh?UcontentsrB†Xin_depthrChHUin-depthrD†uUlabels}rE(j*j*Ucsphinx.locale _TranslationProxy rFcsphinx.locale mygettext rGUIndexrH†rIjGjH…rJ†b‡j+hj,X"Hello world" HTTP server‡j-hrj.XReference Manual‡j/U py-modindexUjFjGU Module IndexrK†rLjGjK…rM†b‡j0h{j1X"Hello world" HTTP client‡j2hùj3X What's New‡j4hŸj5XTwitter search‡j6j6UjFjGU Search PagerN†rOjGjN…rP†b‡j7h-j8XExamples‡j9h¨j:X Simple wget‡j;hçj<XAtom feed reader‡j=h»j>X HTTP client‡j?hðj@XGetting Started‡jAh?jBXContents‡jChHjDX"An in-depth look at the cpp-netlib‡uUversionrQKUobjectsrR}U progoptions}uUc}rS(jR}jQKuUpy}rT(jR}Umodules}jQKuUjs}rU(jR}jQKuUrst}rV(jR}jQKuUcpp}rW(jR}jQKuuU glob_toctreesrXh]…RrYUimagesrZh)r[(Xin_depth/../_static/ftp_uri.pngr\h]r]h6a…Rr^X ftp_uri.pngr_†r`X"in_depth/../_static/mailto_uri.pngrah]rbh6a…RrcXmailto_uri.pngrd†reX in_depth/../_static/http_uri.pngrfh]rgh6a…RrhX http_uri.pngri†rjuh]rk(jijdj_e…RrlbU doctreedirrmX@/Users/dean/Documents/cpp-netlib/libs/network/doc/html/.doctreesrnUversioning_conditionro‰U citationsrp}UversionrqK*Utodo_all_todosrr]rs}rt(UdocnamehiUsourcecdocutils.nodes reprunicode ruXK/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/directives.rstrv…rw}rxbUtodocsphinx.ext.todo todo_node ry)rz}r{(hXAn example using a directive.r|h}r}(h]h]r~Uadmonition-todorah]h]uh]r€(h)r}r‚(hXTodorƒh}r„(h]h]h]h]h]uh!jzh]r…hXTodor†…r‡}rˆ(hjƒh!jubah"h#ubcdocutils.nodes paragraph r‰)rŠ}r‹(hj|h}rŒ(h]h]h]h]h]uh!jzh]rhXAn example using a directive.rŽ…r}r(hj|h!jŠubah"U paragraphr‘ubeh"U todo_noder’ubUlinenoK;Utargetr“cdocutils.nodes target r”)r•}r–(hUh!cdocutils.nodes section r—)r˜}r™(hUh!cdocutils.nodes document rš)r›}rœ(U nametypesr}ržX directivesrŸNsUsubstitution_defsr }r¡Uparse_messagesr¢]r£Ucurrent_sourcer¤NU decorationr¥NUautofootnote_startr¦KUnameidsr§}r¨jŸU directivesr©sh]rªj˜ahUU transformerr«NU footnote_refsr¬}r­Urefnamesr®}r¯Usymbol_footnotesr°]r±Uautofootnote_refsr²]r³Usymbol_footnote_refsr´]rµjp]r¶Udocumentr·j›U current_liner¸NUtransform_messagesr¹]rºcdocutils.nodes system_message r»)r¼}r½(hUh}r¾(h]UlevelKh]h]Usourcejwh]h]UtypeUINFOuh]r¿j‰)rÀ}rÁ(hUh}rÂ(h]h]h]h]h]uh!j¼h]rÃhX-Hyperlink target "index-0" is not referenced.rÄ…rÅ}rÆ(hUh!jÀubah"j‘ubah"Usystem_messageubaUreporterrÇNUid_startrÈKU autofootnotesrÉ]rÊU citation_refsrË}rÌUindirect_targetsrÍ]rÎUsettingsrÏ(cdocutils.frontend Values rÐorÑ}rÒ(Ufootnote_backlinksrÓKUrecord_dependenciesrÔNU rfc_base_urlrÕUhttp://tools.ietf.org/html/rÖU tracebackr׈Upep_referencesrØNUstrip_commentsrÙNU toc_backlinksrÚUentryU language_coderÛUenU datestamprÜNU report_levelrÝKU _destinationrÞNU halt_levelrßKU strip_classesràNhhNUerror_encoding_error_handlerráUbackslashreplaceUdebugrâNUembed_stylesheetrã‰Uoutput_encoding_error_handlerräUstrictråU sectnum_xformræKUdump_transformsrçNU docinfo_xformrèKUwarning_streamréNUpep_file_url_templaterêUpep-%04dUexit_status_levelrëKUconfigrìNUstrict_visitorríNUcloak_email_addressesrîˆUtrim_footnote_reference_spacerï‰UenvrðNUdump_pseudo_xmlrñNUexpose_internalsròNUsectsubtitle_xformró‰U source_linkrôNUrfc_referencesrõNUoutput_encodingröUutf-8U source_urlr÷NUinput_encodingrøUutf-8U_disable_configrùNU id_prefixrúUU tab_widthrûKUerror_encodingrüUUS-ASCIIU_sourcerýUK/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/directives.rstUgettext_compactrþˆU generatorrÿNUdump_internalsrNU smart_quotesr‰U pep_base_urlrUhttp://www.python.org/dev/peps/rUsyntax_highlightrUlongUinput_encoding_error_handlerrjåUauto_id_prefixrUidUdoctitle_xformr‰Ustrip_elements_with_classesrNU _config_filesr ]Ufile_insertion_enabledr ˆU raw_enabledr KU dump_settingsr NubUsymbol_footnote_startr KUidsr}r(Uindex-0rjy)r}r(hj|h!j˜UsourcerjwUexpect_referenced_by_namer}h"j’h}r(h]h]rjah]h]h]rjauUlinerK;j·j›Uexpect_referenced_by_idr}rjj•sh]r(h)r}r(hjƒh}r(h]h]h]h]h]uh!jh]rhXTodor …r!}r"(hjƒh!jubah"h#ubj‰)r#}r$(hj|h!jjjwh"j‘h}r%(h]h]h]h]h]ujK=h]r&hXAn example using a directive.r'…r(}r)(hj|h!j#ubaubeubj©j˜uUsubstitution_namesr*}r+h"Udocumentr,h}r-(h]h]h]Usourcejwh]h]uU footnotesr.]r/Urefidsr0}r1j]r2j•asubjjwh"Usectionh}r3(h]h]h]h]r4jŸah]r5j©aujKj·j›h]r6(h)r7}r8(hhqh!j˜jjwh"h#h}r9(h]h]h]h]h]ujKj·j›h]r:hX Directivesr;…r<}r=(hhqh!j7ubaubj‰)r>}r?(hXThe :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.h!j˜jjwh"j‘h}r@(h]h]h]h]h]ujKj·j›h]rA(hXThe rB…rC}rD(hXThe h!j>ubcsphinx.addnodes pending_xref rE)rF}rG(hX:mod:`cpp-netlib`rHh!j>jjwh"U pending_xrefrIh}rJ(UreftypeXmodUrefwarnrK‰U reftargetrLX cpp-netlibU refdomainXpyrMh]h]U refexplicit‰h]h]h]UrefdocrNhiUpy:classrONU py:modulerPNujKh]rQhQ)rR}rS(hjHh}rT(h]h]rU(UxrefrVjMXpy-modrWeh]h]h]uh!jFh]rXhX cpp-netlibrY…rZ}r[(hUh!jRubah"hYubaubhX 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.r\…r]}r^(hX 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.h!j>ubeubj‰)r_}r`(hX<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:h!j˜jjwh"j‘h}ra(h]h]h]h]h]ujK j·j›h]rb(hXÓ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 rc…rd}re(hXÓ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 h!j_ubjE)rf}rg(hX:mod:`cpp-netlib`rhh!j_jjwh"jIh}ri(UreftypeXmodjK‰jLX cpp-netlibU refdomainXpyrjh]h]U refexplicit‰h]h]h]jNhijONjPNujK h]rkhQ)rl}rm(hjhh}rn(h]h]ro(jVjjXpy-modrpeh]h]h]uh!jfh]rqhX cpp-netlibrr…rs}rt(hUh!jlubah"hYubaubhXX the protocol implemented is similar to that of the standard iostream formatting system:ru…rv}rw(hXX the protocol implemented is similar to that of the standard iostream formatting system:h!j_ubeubcdocutils.nodes literal_block rx)ry}rz(hXYobject << directive1(...) << directive2(...) ... << directiveN(...);h!j˜jjwh"U literal_blockr{h}r|(Ulinenosr}‰Ulanguager~Xc++U xml:spacerUpreserver€h]h]h]h]h]ujKj·j›h]rhXYobject << directive1(...) << directive2(...) ... << directiveN(...);r‚…rƒ}r„(hUh!jyubaubj‰)r…}r†(hXÖ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:h!j˜jjwh"j‘h}r‡(h]h]h]h]h]ujKj·j›h]rˆ(hXIn r‰…rŠ}r‹(hXIn h!j…ubjE)rŒ}r(hX:mod:`cpp-netlib`rŽh!j…jjwh"jIh}r(UreftypeXmodjK‰jLX cpp-netlibU refdomainXpyrh]h]U refexplicit‰h]h]h]jNhijONjPNujKh]r‘hQ)r’}r“(hjŽh}r”(h]h]r•(jVjXpy-modr–eh]h]h]uh!jŒh]r—hX cpp-netlibr˜…r™}rš(hUh!j’ubah"hYubaubhX 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:r›…rœ}r(hX 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:h!j…ubeubjx)rž}rŸ(hX struct directive_type { template Input & operator()(Input & input) const { // do something to input return input; } };h!j˜jjwh"j{h}r (j}‰j~Xc++jj€h]h]h]h]h]ujKj·j›h]r¡hX struct directive_type { template Input & operator()(Input & input) const { // do something to input return input; } };r¢…r£}r¤(hUh!jžubaubj‰)r¥}r¦(hX†To simplify directive creation, usually factory or generator functions are defined to return concrete objects of the directive's type.r§h!j˜jjwh"j‘h}r¨(h]h]h]h]h]ujK&j·j›h]r©hX†To simplify directive creation, usually factory or generator functions are defined to return concrete objects of the directive's type.rª…r«}r¬(hj§h!j¥ubaubjx)r­}r®(hXEinline directive_type directive(...) { return directive_type(); }h!j˜jjwh"j{h}r¯(j}‰j~Xc++jj€h]h]h]h]h]ujK)j·j›h]r°hXEinline directive_type directive(...) { return directive_type(); }r±…r²}r³(hUh!j­ubaubj‰)r´}rµ(hX‰The trivial implementation of the directive protocol then boils down to the specialization of the shift-left operator on the target type.r¶h!j˜jjwh"j‘h}r·(h]h]h]h]h]ujK0j·j›h]r¸hX‰The trivial implementation of the directive protocol then boils down to the specialization of the shift-left operator on the target type.r¹…rº}r»(hj¶h!j´ubaubjx)r¼}r½(hXvtemplate inline target_type & operator<< (target_type & x, Directive const & f) { return f(x); }h!j˜jjwh"j{h}r¾(j}‰j~Xc++jj€h]h]h]h]h]ujK3j·j›h]r¿hXvtemplate inline target_type & operator<< (target_type & x, Directive const & f) { return f(x); }rÀ…rÁ}rÂ(hUh!j¼ubaubj•jj‰)rÃ}rÄ(hX@The rationale for implementing directives include the following:rÅh!j˜jjwh"j‘h}rÆ(h]h]h]h]h]ujK?j·j›h]rÇhX@The rationale for implementing directives include the following:rÈ…rÉ}rÊ(hjÅh!jÃubaubcdocutils.nodes block_quote rË)rÌ}rÍ(hUh!j˜jNh"U block_quoteh}rÎ(h]h]h]h]h]ujNj·j›h]rÏcdocutils.nodes bullet_list rÐ)rÑ}rÒ(hUh}rÓ(UbulletX*h]h]h]h]h]uh!jÌh]rÔ(cdocutils.nodes list_item rÕ)rÖ}r×(hX;**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.h}rØ(h]h]h]h]h]uh!jÑh]rÙj‰)rÚ}rÛ(hX;**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.h!jÖjjwh"j‘h}rÜ(h]h]h]h]h]ujKAh]rÝ(cdocutils.nodes strong rÞ)rß}rà(hX**Encapsulation**h}rá(h]h]h]h]h]uh!jÚh]râhX Encapsulationrã…rä}rå(hUh!jßubah"UstrongræubhX* - 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.rç…rè}ré(hX* - 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.h!jÚubeubah"U list_itemrêubjÕ)rë}rì(hXz**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.h}rí(h]h]h]h]h]uh!jÑh]rîj‰)rï}rð(hXz**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.h!jëjjwh"j‘h}rñ(h]h]h]h]h]ujKGh]rò(jÞ)ró}rô(hX**Flexibility**h}rõ(h]h]h]h]h]uh!jïh]röhX Flexibilityr÷…rø}rù(hUh!jóubah"jæubhXk - 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.rú…rû}rü(hXk - 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.h!jïubeubah"jêubjÕ)rý}rþ(hX´**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.h}rÿ(h]h]h]h]h]uh!jÑh]rj‰)r}r(hX´**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.h!jýjjwh"j‘h}r(h]h]h]h]h]ujKMh]r(jÞ)r}r(hX**Extensibility**h}r(h]h]h]h]h]uh!jh]rhX Extensibilityr …r }r (hUh!jubah"jæubhX£ - 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.r …r }r(hX£ - 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.h!jubeubah"jêubjÕ)r}r(hXE**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. h}r(h]h]h]h]h]uh!jÑh]rj‰)r}r(hXD**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.h!jjjwh"j‘h}r(h]h]h]h]h]ujKPh]r(jÞ)r}r(hX **Reuse**h}r(h]h]h]h]h]uh!jh]rhXReuser…r}r(hUh!jubah"jæubhX; - 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.r…r}r (hX; - 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.h!jubeubah"jêubeh"U bullet_listr!ubaubj‰)r"}r#(hX¿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.r$h!j˜jjwh"j‘h}r%(h]h]h]h]h]ujKVj·j›h]r&hX¿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.r'…r(}r)(hj$h!j"ubaubj‰)r*}r+(hXÉ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.r,h!j˜jjwh"j‘h}r-(h]h]h]h]h]ujKZj·j›h]r.hXÉ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.r/…r0}r1(hj,h!j*ubaubeubjjwh"j“h}r2(h]h]h]h]h]UrefidjujNj·j›h]ubuaUsrcdirr3X1/Users/dean/Documents/cpp-netlib/libs/network/docr4jìcsphinx.config Config r5)r6}r7(Uadd_module_namesr8ˆUpygments_styler9Usphinxr:Uhtml_use_smartypantsr;ˆU html_themer<Upyramidr=U exclude_treesr>]r?(Ubuildr@UdoxyxmlrAUextrBeU master_docrCUcontentsrDU html_titlerEUcpp-netlib v0.11.0U source_suffixrFU.rstU copyrightrGX@2008-2013, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.Usource_encodingrHUutf-8rIjqU0.11U today_fmtrJU %B %d, %YUtodo_include_todosrKˆU overridesrL}Uhtml_use_indexrM‰Uhtml_last_updated_fmtrNU %b %d, %YUprojectrOX cpp-netlibU extensionsrP]rQ(Usphinx.ext.todorRUsphinx.ext.autodocrSUsphinx.ext.doctestrTUsphinx.ext.coveragerUeUreleaserVU0.11.0U unused_docsrW]rXUaUsetuprYNubUmetadatarZ}r[(h}h$}h-}h6}h?}hH}hZ}hi}hr}h{}h„}h}h–}hŸ}h¨}h»}hÄ}hÍ}hÖ}hß}hç}hð}hù}j}j }j}j}uUversionchangesr\}Utoc_num_entriesr]}r^(hKh$Kh-Kh6Kh?KhHKhZKhiKhrKh{Kh„K hKh–KhŸKh¨Kh»KhÄKhÍKhÖKhßKhçKhðK hùKjKj K jKjKuUnumbered_toctreesr_h]…Rr`U found_docsrah]rb(X examples/http/hello_world_serverrcX referencesrdXexamplesreX in_depth/urirfXcontentsrgX techniquesrhhZXtechniques/directivesriX referencerjX examples/http/hello_world_clientrkXreference/http_serverrlXreference/http_responsermXin_depthrnXexamples/http/twitter_searchroXexamples/http/simple_wgetrpXexamples/http/http_clientrqXtechniques/polymorphismrrXtechniques/tag_metafunctionsrsXin_depth/messagertXin_depth/http_client_tagsruXexamples/http/atom_readerrvXgetting_startedrwhùXreference/http_requestrxj XhistoryryX in_depth/httprze…Rr{U longtitlesr|}r}(hhh$h%h-h.h6h7h?h@hHhIhZh[hihjhrhsh{h|h„h…hhŽh–h—hŸh h¨h©h»h¼hÄhÅhÍhÎhÖh×hßhàhçhèhðhñhùhújjj j jjjjuU dependenciesr~}r(j h]r€Xin_depth/http_client_tags.rstra…Rr‚h6h]rƒ(j\jajfe…Rr„jh]r…Xin_depth/http_client_tags.rstr†a…Rr‡uUtoctree_includesrˆ}r‰(hr]rŠ(Xreference/http_clientr‹Xreference/http_requestrŒXreference/http_responserXreference/http_serverrŽeh–]r(Xtechniques/tag_metafunctionsrXtechniques/directivesr‘Xtechniques/polymorphismr’eh-]r“(Xexamples/http/http_clientr”Xexamples/http/simple_wgetr•X examples/http/hello_world_serverr–X examples/http/hello_world_clientr—Xexamples/http/atom_readerr˜Xexamples/http/twitter_searchr™eh?]rš(Xindexr›X whats_newrœXgetting_startedrXexamplesržXin_depthrŸX techniquesr Xhistoryr¡X referencer¢X referencesr£ehH]r¤(Xin_depth/messager¥X in_depth/urir¦X in_depth/httpr§euU temp_datar¨}Utocsr©}rª(hjÐ)r«}r¬(hUh}r­(h]h]h]h]h]uh]r®jÕ)r¯}r°(hUh}r±(h]h]h]h]h]uh!j«h]r²(csphinx.addnodes compact_paragraph r³)r´}rµ(hUh}r¶(h]h]h]h]h]uh!j¯h]r·cdocutils.nodes reference r¸)r¹}rº(hUh}r»(U anchornameUUrefurihh]h]h]h]h]Uinternalˆuh!j´h]r¼hX"Hello world" HTTP serverr½…r¾}r¿(hh h!j¹ubah"U referencerÀubah"Ucompact_paragraphrÁubjÐ)rÂ}rÃ(hUh}rÄ(h]h]h]h]h]uh!j¯h]rÅ(jÕ)rÆ}rÇ(hUh}rÈ(h]h]h]h]h]uh!jÂh]rÉj³)rÊ}rË(hUh}rÌ(h]h]h]h]h]uh!jÆh]rÍj¸)rÎ}rÏ(hUh}rÐ(U anchornameU #the-codeUrefurihh]h]h]h]h]Uinternalˆuh!jÊh]rÑhXThe coderÒ…rÓ}rÔ(hXThe codeh!jÎubah"jÀubah"jÁubah"jêubjÕ)rÕ}rÖ(hUh}r×(h]h]h]h]h]uh!jÂh]rØj³)rÙ}rÚ(hUh}rÛ(h]h]h]h]h]uh!jÕh]rÜj¸)rÝ}rÞ(hUh}rß(U anchornameU #building-and-running-the-serverUrefurihh]h]h]h]h]Uinternalˆuh!jÙh]ràhXBuilding and running the serverrá…râ}rã(hXBuilding and running the serverh!jÝubah"jÀubah"jÁubah"jêubjÕ)rä}rå(hUh}ræ(h]h]h]h]h]uh!jÂh]rçj³)rè}ré(hUh}rê(h]h]h]h]h]uh!jäh]rëj¸)rì}rí(hUh}rî(U anchornameU#diving-into-the-codeUrefurihh]h]h]h]h]Uinternalˆuh!jèh]rïhXDiving into the coderð…rñ}rò(hXDiving into the codeh!jìubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubh$jÐ)ró}rô(hUh}rõ(h]h]h]h]h]uh]röjÕ)r÷}rø(hUh}rù(h]h]h]h]h]uh!jóh]rú(j³)rû}rü(hUh}rý(h]h]h]h]h]uh!j÷h]rþj¸)rÿ}r(hUh}r(U anchornameUUrefurih$h]h]h]h]h]Uinternalˆuh!jûh]rhX Referencesr…r}r(hh,h!jÿubah"jÀubah"jÁubjÐ)r}r(hUh}r(h]h]h]h]h]uh!j÷h]r (jÕ)r }r (hUh}r (h]h]h]h]h]uh!jh]r j³)r}r(hUh}r(h]h]h]h]h]uh!j h]rj¸)r}r(hUh}r(U anchornameU#about-cpp-netlibUrefurih$h]h]h]h]h]Uinternalˆuh!jh]r(hXAbout r…r}r(hXAbout h!jubhQ)r}r(hX cpp-netlibh}r(h]h]h]h]h]uh!jh]rhX cpp-netlibr…r}r(hUh!jubah"hYubeh"jÀubah"jÁubah"jêubjÕ)r }r!(hUh}r"(h]h]h]h]h]uh!jh]r#j³)r$}r%(hUh}r&(h]h]h]h]h]uh!j h]r'j¸)r(}r)(hUh}r*(U anchornameU#other-sourcesUrefurih$h]h]h]h]h]Uinternalˆuh!j$h]r+hX Other sourcesr,…r-}r.(hX Other sourcesh!j(ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubh-jÐ)r/}r0(hUh}r1(h]h]h]h]h]uh]r2jÕ)r3}r4(hUh}r5(h]h]h]h]h]uh!j/h]r6(j³)r7}r8(hUh}r9(h]h]h]h]h]uh!j3h]r:j¸)r;}r<(hUh}r=(U anchornameUUrefurih-h]h]h]h]h]Uinternalˆuh!j7h]r>hXExamplesr?…r@}rA(hh5h!j;ubah"jÀubah"jÁubjÐ)rB}rC(hUh}rD(h]h]h]h]h]uh!j3h]rEjÕ)rF}rG(hUh}rH(h]h]h]h]h]uh!jBh]rI(j³)rJ}rK(hUh}rL(h]h]h]h]h]uh!jFh]rMj¸)rN}rO(hUh}rP(U anchornameU#http-examplesUrefurih-h]h]h]h]h]Uinternalˆuh!jJh]rQhX HTTP examplesrR…rS}rT(hX HTTP examplesh!jNubah"jÀubah"jÁubjÐ)rU}rV(hUh}rW(h]h]h]h]h]uh!jFh]rXcsphinx.addnodes toctree rY)rZ}r[(hUh}r\(UnumberedKUparenth-U titlesonly‰Uglob‰h]h]h]h]U includehidden‰Uentries]r](Nj”†r^Nj•†r_Nj–†r`Nj—†raNj˜†rbNj™†rceUhidden‰UmaxdepthKU includefiles]rd(j”j•j–j—j˜j™eh]uh!jUh]h"Utoctreereubah"j!ubeh"jêubah"j!ubeh"jêubah"j!ubh6jÐ)rf}rg(hUh}rh(h]h]h]h]h]uh]rijÕ)rj}rk(hUh}rl(h]h]h]h]h]uh!jfh]rm(j³)rn}ro(hUh}rp(h]h]h]h]h]uh!jjh]rqj¸)rr}rs(hUh}rt(U anchornameUUrefurih6h]h]h]h]h]Uinternalˆuh!jnh]ruhX The URI classrv…rw}rx(hh>h!jrubah"jÀubah"jÁubjÐ)ry}rz(hUh}r{(h]h]h]h]h]uh!jjh]r|(jÕ)r}}r~(hUh}r(h]h]h]h]h]uh!jyh]r€j³)r}r‚(hUh}rƒ(h]h]h]h]h]uh!j}h]r„j¸)r…}r†(hUh}r‡(U anchornameU#generic-uri-syntax-overviewUrefurih6h]h]h]h]h]Uinternalˆuh!jh]rˆhXGeneric URI syntax overviewr‰…rŠ}r‹(hXGeneric URI syntax overviewh!j…ubah"jÀubah"jÁubah"jêubjÕ)rŒ}r(hUh}rŽ(h]h]h]h]h]uh!jyh]rj³)r}r‘(hUh}r’(h]h]h]h]h]uh!jŒh]r“j¸)r”}r•(hUh}r–(U anchornameU#id1Urefurih6h]h]h]h]h]Uinternalˆuh!jh]r—(hXThe r˜…r™}rš(hXThe h!j”ubhQ)r›}rœ(hX``uri``h}r(h]h]h]h]h]uh!j”h]ržhXurirŸ…r }r¡(hUh!j›ubah"hYubhX classr¢…r£}r¤(hX classh!j”ubeh"jÀubah"jÁubah"jêubjÕ)r¥}r¦(hUh}r§(h]h]h]h]h]uh!jyh]r¨j³)r©}rª(hUh}r«(h]h]h]h]h]uh!j¥h]r¬j¸)r­}r®(hUh}r¯(U anchornameU#the-uri-builderUrefurih6h]h]h]h]h]Uinternalˆuh!j©h]r°(hXThe r±…r²}r³(hXThe h!j­ubhQ)r´}rµ(hX``uri``h}r¶(h]h]h]h]h]uh!j­h]r·hXurir¸…r¹}rº(hUh!j´ubah"hYubhX builderr»…r¼}r½(hX builderh!j­ubeh"jÀubah"jÁubah"jêubjÕ)r¾}r¿(hUh}rÀ(h]h]h]h]h]uh!jyh]rÁj³)rÂ}rÃ(hUh}rÄ(h]h]h]h]h]uh!j¾h]rÅj¸)rÆ}rÇ(hUh}rÈ(U anchornameU #uri-conceptUrefurih6h]h]h]h]h]Uinternalˆuh!jÂh]rÉhQ)rÊ}rË(hX``URI Concept``h}rÌ(h]h]h]h]h]uh!jÆh]rÍhX URI ConceptrÎ…rÏ}rÐ(hUh!jÊubah"hYubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubh?jÐ)rÑ}rÒ(hUh}rÓ(h]h]h]h]h]uh]rÔjÕ)rÕ}rÖ(hUh}r×(h]h]h]h]h]uh!jÑh]rØ(j³)rÙ}rÚ(hUh}rÛ(h]h]h]h]h]uh!jÕh]rÜj¸)rÝ}rÞ(hUh}rß(U anchornameUUrefurih?h]h]h]h]h]Uinternalˆuh!jÙh]ràhXContentsrá…râ}rã(hhGh!jÝubah"jÀubah"jÁubjÐ)rä}rå(hUh}ræ(h]h]h]h]h]uh!jÕh]rçjY)rè}ré(hUh}rê(UnumberedKUparenth?U titlesonly‰Uglob‰h]h]h]h]U includehidden‰Uentries]rë(Nj›†rìNjœ†ríNj†rîNjž†rïNjŸ†rðNj †rñNj¡†ròNj¢†róNj£†rôeUhidden‰UmaxdepthKU includefiles]rõ(j›jœjjžjŸj j¡j¢j£eh]uh!jäh]h"jeubah"j!ubeh"jêubah"j!ubhHjÐ)rö}r÷(hUh}rø(h]h]h]h]h]uh]rùjÕ)rú}rû(hUh}rü(h]h]h]h]h]uh!jöh]rý(j³)rþ}rÿ(hUh}r(h]h]h]h]h]uh!júh]rj¸)r}r(hUh}r(U anchornameUUrefurihHh]h]h]h]h]Uinternalˆuh!jþh]r(hXAn in-depth look at the r…r}r(hhPh!jubhQ)r }r (hX cpp-netlibh}r (h]h]h]h]h]uh!jh]r hX cpp-netlibr …r}r(hUh!j ubah"hYubeh"jÀubah"jÁubjÐ)r}r(hUh}r(h]h]h]h]h]uh!júh]rjY)r}r(hUh}r(UnumberedKUparenthHU titlesonly‰Uglob‰h]h]h]h]U includehidden‰Uentries]r(Nj¥†rNj¦†rNj§†reUhidden‰UmaxdepthKU includefiles]r(j¥j¦j§eh]uh!jh]h"jeubah"j!ubeh"jêubah"j!ubhZjÐ)r}r(hUh}r(h^]h_]h`]ha]hb]uh]r(jÕ)r }r!(hUh}r"(h^]h_]h`]ha]hb]uh!jh]r#j³)r$}r%(hUh}r&(h^]h_]h`]ha]hb]uh!j h]r'j¸)r(}r)(hUh}r*(U anchornameUUrefurihZha]h`]h^]h_]hb]Uinternalˆuh!j$h]r+hXGetting cpp-netlibr,…r-}r.(hhgh!j(ubah"U referencer/ubah"Ucompact_paragraphr0ubah"U list_itemr1ubjÕ)r2}r3(hUh}r4(h^]h_]h`]ha]hb]uh!jh]r5j³)r6}r7(hUh}r8(h^]h_]h`]ha]hb]uh!j2h]r9j¸)r:}r;(hUh}r<(U anchornameU#c-network-libraryUrefurihZha]h`]h^]h_]hb]Uinternalˆuh!j6h]r=hXC++ Network Libraryr>…r?}r@(hXC++ Network Libraryh!j:ubah"j/ubah"j0ubah"j1ubjÕ)rA}rB(hUh}rC(h^]h_]h`]ha]hb]uh!jh]rDj³)rE}rF(hUh}rG(h^]h_]h`]ha]hb]uh!jAh]rHj¸)rI}rJ(hUh}rK(U anchornameU #hello-worldUrefurihZha]h`]h^]h_]hb]Uinternalˆuh!jEh]rLhX Hello, world!rM…rN}rO(hX Hello, world!h!jIubah"j/ubah"j0ubah"j1ubjÕ)rP}rQ(hUh}rR(h^]h_]h`]ha]hb]uh!jh]rSj³)rT}rU(hUh}rV(h^]h_]h`]ha]hb]uh!jPh]rWj¸)rX}rY(hUh}rZ(U anchornameU#want-to-learn-moreUrefurihZha]h`]h^]h_]hb]Uinternalˆuh!jTh]r[hXWant to learn more?r\…r]}r^(hXWant to learn more?h!jXubah"j/ubah"j0ubah"j1ubeh"U bullet_listr_ubhijÐ)r`}ra(hUh}rb(h]h]h]h]h]uh]rcjÕ)rd}re(hUh}rf(h]h]h]h]h]uh!j`h]rgj³)rh}ri(hUh}rj(h]h]h]h]h]uh!jdh]rkj¸)rl}rm(hUh}rn(U anchornameUUrefurihih]h]h]h]h]Uinternalˆuh!jhh]rohX Directivesrp…rq}rr(hhqh!jlubah"jÀubah"jÁubah"jêubah"j!ubhrjÐ)rs}rt(hUh}ru(h]h]h]h]h]uh]rvjÕ)rw}rx(hUh}ry(h]h]h]h]h]uh!jsh]rz(j³)r{}r|(hUh}r}(h]h]h]h]h]uh!jwh]r~j¸)r}r€(hUh}r(U anchornameUUrefurihrh]h]h]h]h]Uinternalˆuh!j{h]r‚hXReference Manualrƒ…r„}r…(hhzh!jubah"jÀubah"jÁubjÐ)r†}r‡(hUh}rˆ(h]h]h]h]h]uh!jwh]r‰jY)rŠ}r‹(hUh}rŒ(UnumberedKUparenthrU titlesonly‰Uglob‰h]h]h]h]U includehidden‰Uentries]r(Nj‹†rŽNjŒ†rNj†rNjŽ†r‘eUhidden‰UmaxdepthKU includefiles]r’(j‹jŒjjŽeh]uh!j†h]h"jeubah"j!ubeh"jêubah"j!ubh{jÐ)r“}r”(hUh}r•(h]h]h]h]h]uh]r–jÕ)r—}r˜(hUh}r™(h]h]h]h]h]uh!j“h]rš(j³)r›}rœ(hUh}r(h]h]h]h]h]uh!j—h]ržj¸)rŸ}r (hUh}r¡(U anchornameUUrefurih{h]h]h]h]h]Uinternalˆuh!j›h]r¢hX"Hello world" HTTP clientr£…r¤}r¥(hhƒh!jŸubah"jÀubah"jÁubjÐ)r¦}r§(hUh}r¨(h]h]h]h]h]uh!j—h]r©(jÕ)rª}r«(hUh}r¬(h]h]h]h]h]uh!j¦h]r­j³)r®}r¯(hUh}r°(h]h]h]h]h]uh!jªh]r±j¸)r²}r³(hUh}r´(U anchornameU #the-codeUrefurih{h]h]h]h]h]Uinternalˆuh!j®h]rµhXThe coder¶…r·}r¸(hXThe codeh!j²ubah"jÀubah"jÁubah"jêubjÕ)r¹}rº(hUh}r»(h]h]h]h]h]uh!j¦h]r¼j³)r½}r¾(hUh}r¿(h]h]h]h]h]uh!j¹h]rÀj¸)rÁ}rÂ(hUh}rÃ(U anchornameU #building-and-running-the-clientUrefurih{h]h]h]h]h]Uinternalˆuh!j½h]rÄhXBuilding and running the clientrÅ…rÆ}rÇ(hXBuilding and running the clienth!jÁubah"jÀubah"jÁubah"jêubjÕ)rÈ}rÉ(hUh}rÊ(h]h]h]h]h]uh!j¦h]rËj³)rÌ}rÍ(hUh}rÎ(h]h]h]h]h]uh!jÈh]rÏj¸)rÐ}rÑ(hUh}rÒ(U anchornameU#diving-into-the-codeUrefurih{h]h]h]h]h]Uinternalˆuh!jÌh]rÓhXDiving into the coderÔ…rÕ}rÖ(hXDiving into the codeh!jÐubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubh„jÐ)r×}rØ(hUh}rÙ(h]h]h]h]h]uh]rÚjÕ)rÛ}rÜ(hUh}rÝ(h]h]h]h]h]uh!j×h]rÞ(j³)rß}rà(hUh}rá(h]h]h]h]h]uh!jÛh]râj¸)rã}rä(hUh}rå(U anchornameUUrefurih„h]h]h]h]h]Uinternalˆuh!jßh]ræhXHTTP Server APIrç…rè}ré(hhŒh!jãubah"jÀubah"jÁubjÐ)rê}rë(hUh}rì(h]h]h]h]h]uh!jÛh]rí(jÕ)rî}rï(hUh}rð(h]h]h]h]h]uh!jêh]rñj³)rò}ró(hUh}rô(h]h]h]h]h]uh!jîh]rõj¸)rö}r÷(hUh}rø(U anchornameU#generalUrefurih„h]h]h]h]h]Uinternalˆuh!jòh]rùhXGeneralrú…rû}rü(hXGeneralh!jöubah"jÀubah"jÁubah"jêubjÕ)rý}rþ(hUh}rÿ(h]h]h]h]h]uh!jêh]rj³)r}r(hUh}r(h]h]h]h]h]uh!jýh]rj¸)r}r(hUh}r(U anchornameU#implementationsUrefurih„h]h]h]h]h]Uinternalˆuh!jh]rhXImplementationsr …r }r (hXImplementationsh!jubah"jÀubah"jÁubah"jêubjÕ)r }r (hUh}r(h]h]h]h]h]uh!jêh]r(j³)r}r(hUh}r(h]h]h]h]h]uh!j h]rj¸)r}r(hUh}r(U anchornameU#synchronous-serversUrefurih„h]h]h]h]h]Uinternalˆuh!jh]rhXSynchronous Serversr…r}r(hXSynchronous Serversh!jubah"jÀubah"jÁubjÐ)r}r(hUh}r(h]h]h]h]h]uh!j h]rjÕ)r}r (hUh}r!(h]h]h]h]h]uh!jh]r"(j³)r#}r$(hUh}r%(h]h]h]h]h]uh!jh]r&j¸)r'}r((hUh}r)(U anchornameU#api-documentationUrefurih„h]h]h]h]h]Uinternalˆuh!j#h]r*hXAPI Documentationr+…r,}r-(hXAPI Documentationh!j'ubah"jÀubah"jÁubjÐ)r.}r/(hUh}r0(h]h]h]h]h]uh!jh]r1(jÕ)r2}r3(hUh}r4(h]h]h]h]h]uh!j.h]r5j³)r6}r7(hUh}r8(h]h]h]h]h]uh!j2h]r9j¸)r:}r;(hUh}r<(U anchornameU #constructorUrefurih„h]h]h]h]h]Uinternalˆuh!j6h]r=hX Constructorr>…r?}r@(hX Constructorh!j:ubah"jÀubah"jÁubah"jêubjÕ)rA}rB(hUh}rC(h]h]h]h]h]uh!j.h]rDj³)rE}rF(hUh}rG(h]h]h]h]h]uh!jAh]rHj¸)rI}rJ(hUh}rK(U anchornameU#public-membersUrefurih„h]h]h]h]h]Uinternalˆuh!jEh]rLhXPublic MembersrM…rN}rO(hXPublic Membersh!jIubah"jÀubah"jÁubah"jêubjÕ)rP}rQ(hUh}rR(h]h]h]h]h]uh!j.h]rSj³)rT}rU(hUh}rV(h]h]h]h]h]uh!jPh]rWj¸)rX}rY(hUh}rZ(U anchornameU#response-objectUrefurih„h]h]h]h]h]Uinternalˆuh!jTh]r[hXResponse Objectr\…r]}r^(hXResponse Objecth!jXubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubeh"jêubjÕ)r_}r`(hUh}ra(h]h]h]h]h]uh!jêh]rb(j³)rc}rd(hUh}re(h]h]h]h]h]uh!j_h]rfj¸)rg}rh(hUh}ri(U anchornameU#asynchronous-serversUrefurih„h]h]h]h]h]Uinternalˆuh!jch]rjhXAsynchronous Serversrk…rl}rm(hXAsynchronous Serversh!jgubah"jÀubah"jÁubjÐ)rn}ro(hUh}rp(h]h]h]h]h]uh!j_h]rqjÕ)rr}rs(hUh}rt(h]h]h]h]h]uh!jnh]ru(j³)rv}rw(hUh}rx(h]h]h]h]h]uh!jrh]ryj¸)rz}r{(hUh}r|(U anchornameU#id5Urefurih„h]h]h]h]h]Uinternalˆuh!jvh]r}hXAPI Documentationr~…r}r€(hXAPI Documentationh!jzubah"jÀubah"jÁubjÐ)r}r‚(hUh}rƒ(h]h]h]h]h]uh!jrh]r„(jÕ)r…}r†(hUh}r‡(h]h]h]h]h]uh!jh]rˆj³)r‰}rŠ(hUh}r‹(h]h]h]h]h]uh!j…h]rŒj¸)r}rŽ(hUh}r(U anchornameU#id6Urefurih„h]h]h]h]h]Uinternalˆuh!j‰h]rhX Constructorr‘…r’}r“(hX Constructorh!jubah"jÀubah"jÁubah"jêubjÕ)r”}r•(hUh}r–(h]h]h]h]h]uh!jh]r—j³)r˜}r™(hUh}rš(h]h]h]h]h]uh!j”h]r›j¸)rœ}r(hUh}rž(U anchornameU#id7Urefurih„h]h]h]h]h]Uinternalˆuh!j˜h]rŸhXPublic Membersr …r¡}r¢(hXPublic Membersh!jœubah"jÀubah"jÁubah"jêubjÕ)r£}r¤(hUh}r¥(h]h]h]h]h]uh!jh]r¦j³)r§}r¨(hUh}r©(h]h]h]h]h]uh!j£h]rªj¸)r«}r¬(hUh}r­(U anchornameU#connection-objectUrefurih„h]h]h]h]h]Uinternalˆuh!j§h]r®hXConnection Objectr¯…r°}r±(hXConnection Objecth!j«ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubeh"jêubeh"j!ubeh"jêubah"j!ubhjÐ)r²}r³(hUh}r´(h]h]h]h]h]uh]rµjÕ)r¶}r·(hUh}r¸(h]h]h]h]h]uh!j²h]r¹(j³)rº}r»(hUh}r¼(h]h]h]h]h]uh!j¶h]r½j¸)r¾}r¿(hUh}rÀ(U anchornameUUrefurihh]h]h]h]h]Uinternalˆuh!jºh]rÁhX HTTP ResponserÂ…rÃ}rÄ(hh•h!j¾ubah"jÀubah"jÁubjÐ)rÅ}rÆ(hUh}rÇ(h]h]h]h]h]uh!j¶h]rÈ(jÕ)rÉ}rÊ(hUh}rË(h]h]h]h]h]uh!jÅh]rÌj³)rÍ}rÎ(hUh}rÏ(h]h]h]h]h]uh!jÉh]rÐj¸)rÑ}rÒ(hUh}rÓ(U anchornameU#response-conceptUrefurihh]h]h]h]h]Uinternalˆuh!jÍh]rÔhXResponse ConceptrÕ…rÖ}r×(hXResponse Concepth!jÑubah"jÀubah"jÁubah"jêubjÕ)rØ}rÙ(hUh}rÚ(h]h]h]h]h]uh!jÅh]rÛj³)rÜ}rÝ(hUh}rÞ(h]h]h]h]h]uh!jØh]rßj¸)rà}rá(hUh}râ(U anchornameU #directivesUrefurihh]h]h]h]h]Uinternalˆuh!jÜh]rãhX Directivesrä…rå}ræ(hX Directivesh!jàubah"jÀubah"jÁubah"jêubjÕ)rç}rè(hUh}ré(h]h]h]h]h]uh!jÅh]rêj³)rë}rì(hUh}rí(h]h]h]h]h]uh!jçh]rîj¸)rï}rð(hUh}rñ(U anchornameU #modifiersUrefurihh]h]h]h]h]Uinternalˆuh!jëh]ròhX Modifiersró…rô}rõ(hX Modifiersh!jïubah"jÀubah"jÁubah"jêubjÕ)rö}r÷(hUh}rø(h]h]h]h]h]uh!jÅh]rùj³)rú}rû(hUh}rü(h]h]h]h]h]uh!jöh]rýj¸)rþ}rÿ(hUh}r(U anchornameU #wrappersUrefurihh]h]h]h]h]Uinternalˆuh!júh]rhXWrappersr…r}r(hXWrappersh!jþubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubh–jÐ)r}r(hUh}r(h]h]h]h]h]uh]rjÕ)r }r (hUh}r (h]h]h]h]h]uh!jh]r (j³)r }r(hUh}r(h]h]h]h]h]uh!j h]rj¸)r}r(hUh}r(U anchornameUUrefurih–h]h]h]h]h]Uinternalˆuh!j h]rhX Techniquesr…r}r(hhžh!jubah"jÀubah"jÁubjÐ)r}r(hUh}r(h]h]h]h]h]uh!j h]rjY)r}r(hUh}r(UnumberedKUparenth–U titlesonly‰Uglob‰h]h]h]h]U includehidden‰Uentries]r(Nj†r Nj‘†r!Nj’†r"eUhidden‰UmaxdepthKU includefiles]r#(jj‘j’eh]uh!jh]h"jeubah"j!ubeh"jêubah"j!ubhŸjÐ)r$}r%(hUh}r&(h]h]h]h]h]uh]r'jÕ)r(}r)(hUh}r*(h]h]h]h]h]uh!j$h]r+(j³)r,}r-(hUh}r.(h]h]h]h]h]uh!j(h]r/j¸)r0}r1(hUh}r2(U anchornameUUrefurihŸh]h]h]h]h]Uinternalˆuh!j,h]r3hXTwitter searchr4…r5}r6(hh§h!j0ubah"jÀubah"jÁubjÐ)r7}r8(hUh}r9(h]h]h]h]h]uh!j(h]r:(jÕ)r;}r<(hUh}r=(h]h]h]h]h]uh!j7h]r>j³)r?}r@(hUh}rA(h]h]h]h]h]uh!j;h]rBj¸)rC}rD(hUh}rE(U anchornameU #the-codeUrefurihŸh]h]h]h]h]Uinternalˆuh!j?h]rFhXThe coderG…rH}rI(hXThe codeh!jCubah"jÀubah"jÁubah"jêubjÕ)rJ}rK(hUh}rL(h]h]h]h]h]uh!j7h]rMj³)rN}rO(hUh}rP(h]h]h]h]h]uh!jJh]rQj¸)rR}rS(hUh}rT(U anchornameU$#building-and-running-twitter-searchUrefurihŸh]h]h]h]h]Uinternalˆuh!jNh]rU(hXBuilding and running rV…rW}rX(hXBuilding and running h!jRubhQ)rY}rZ(hX``twitter_search``h}r[(h]h]h]h]h]uh!jRh]r\hXtwitter_searchr]…r^}r_(hUh!jYubah"hYubeh"jÀubah"jÁubah"jêubjÕ)r`}ra(hUh}rb(h]h]h]h]h]uh!j7h]rcj³)rd}re(hUh}rf(h]h]h]h]h]uh!j`h]rgj¸)rh}ri(hUh}rj(U anchornameU#diving-into-the-codeUrefurihŸh]h]h]h]h]Uinternalˆuh!jdh]rkhXDiving into the coderl…rm}rn(hXDiving into the codeh!jhubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubh¨jÐ)ro}rp(hUh}rq(h]h]h]h]h]uh]rrjÕ)rs}rt(hUh}ru(h]h]h]h]h]uh!joh]rv(j³)rw}rx(hUh}ry(h]h]h]h]h]uh!jsh]rzj¸)r{}r|(hUh}r}(U anchornameUUrefurih¨h]h]h]h]h]Uinternalˆuh!jwh]r~(hXSimple r…r€}r(hh°h!j{ubh±)r‚}rƒ(hh´h}r„(h]h]h]h]h]uh!j{h]r…hXwgetr†…r‡}rˆ(hUh!j‚ubah"hºubeh"jÀubah"jÁubjÐ)r‰}rŠ(hUh}r‹(h]h]h]h]h]uh!jsh]rŒ(jÕ)r}rŽ(hUh}r(h]h]h]h]h]uh!j‰h]rj³)r‘}r’(hUh}r“(h]h]h]h]h]uh!jh]r”j¸)r•}r–(hUh}r—(U anchornameU #the-codeUrefurih¨h]h]h]h]h]Uinternalˆuh!j‘h]r˜hXThe coder™…rš}r›(hXThe codeh!j•ubah"jÀubah"jÁubah"jêubjÕ)rœ}r(hUh}rž(h]h]h]h]h]uh!j‰h]rŸj³)r }r¡(hUh}r¢(h]h]h]h]h]uh!jœh]r£j¸)r¤}r¥(hUh}r¦(U anchornameU#running-the-exampleUrefurih¨h]h]h]h]h]Uinternalˆuh!j h]r§hXRunning the exampler¨…r©}rª(hXRunning the exampleh!j¤ubah"jÀubah"jÁubah"jêubjÕ)r«}r¬(hUh}r­(h]h]h]h]h]uh!j‰h]r®j³)r¯}r°(hUh}r±(h]h]h]h]h]uh!j«h]r²j¸)r³}r´(hUh}rµ(U anchornameU#diving-into-the-codeUrefurih¨h]h]h]h]h]Uinternalˆuh!j¯h]r¶hXDiving into the coder·…r¸}r¹(hXDiving into the codeh!j³ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubh»jÐ)rº}r»(hUh}r¼(h]h]h]h]h]uh]r½jÕ)r¾}r¿(hUh}rÀ(h]h]h]h]h]uh!jºh]rÁ(j³)rÂ}rÃ(hUh}rÄ(h]h]h]h]h]uh!j¾h]rÅj¸)rÆ}rÇ(hUh}rÈ(U anchornameUUrefurih»h]h]h]h]h]Uinternalˆuh!jÂh]rÉhX HTTP clientrÊ…rË}rÌ(hhÃh!jÆubah"jÀubah"jÁubjÐ)rÍ}rÎ(hUh}rÏ(h]h]h]h]h]uh!j¾h]rÐ(jÕ)rÑ}rÒ(hUh}rÓ(h]h]h]h]h]uh!jÍh]rÔj³)rÕ}rÖ(hUh}r×(h]h]h]h]h]uh!jÑh]rØj¸)rÙ}rÚ(hUh}rÛ(U anchornameU #the-codeUrefurih»h]h]h]h]h]Uinternalˆuh!jÕh]rÜhXThe coderÝ…rÞ}rß(hXThe codeh!jÙubah"jÀubah"jÁubah"jêubjÕ)rà}rá(hUh}râ(h]h]h]h]h]uh!jÍh]rãj³)rä}rå(hUh}ræ(h]h]h]h]h]uh!jàh]rçj¸)rè}ré(hUh}rê(U anchornameU#running-the-exampleUrefurih»h]h]h]h]h]Uinternalˆuh!jäh]rëhXRunning the examplerì…rí}rî(hXRunning the exampleh!jèubah"jÀubah"jÁubah"jêubjÕ)rï}rð(hUh}rñ(h]h]h]h]h]uh!jÍh]ròj³)ró}rô(hUh}rõ(h]h]h]h]h]uh!jïh]röj¸)r÷}rø(hUh}rù(U anchornameU#diving-into-the-codeUrefurih»h]h]h]h]h]Uinternalˆuh!jóh]rúhXDiving into the coderû…rü}rý(hXDiving into the codeh!j÷ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubhÄjÐ)rþ}rÿ(hUh}r(h]h]h]h]h]uh]rjÕ)r}r(hUh}r(h]h]h]h]h]uh!jþh]rj³)r}r(hUh}r(h]h]h]h]h]uh!jh]r j¸)r }r (hUh}r (U anchornameUUrefurihÄh]h]h]h]h]Uinternalˆuh!jh]r hXStatic and dynamic polymorphismr…r}r(hhÌh!j ubah"jÀubah"jÁubah"jêubah"j!ubhÍjÐ)r}r(hUh}r(h]h]h]h]h]uh]rjÕ)r}r(hUh}r(h]h]h]h]h]uh!jh]r(j³)r}r(hUh}r(h]h]h]h]h]uh!jh]rj¸)r}r(hUh}r(U anchornameUUrefurihÍh]h]h]h]h]Uinternalˆuh!jh]r hXTag metafunctionsr!…r"}r#(hhÕh!jubah"jÀubah"jÁubjÐ)r$}r%(hUh}r&(h]h]h]h]h]uh!jh]r'(jÕ)r(}r)(hUh}r*(h]h]h]h]h]uh!j$h]r+j³)r,}r-(hUh}r.(h]h]h]h]h]uh!j(h]r/j¸)r0}r1(hUh}r2(U anchornameU#template-specializationUrefurihÍh]h]h]h]h]Uinternalˆuh!j,h]r3hXTemplate Specializationr4…r5}r6(hXTemplate Specializationh!j0ubah"jÀubah"jÁubah"jêubjÕ)r7}r8(hUh}r9(h]h]h]h]h]uh!j$h]r:j³)r;}r<(hUh}r=(h]h]h]h]h]uh!j7h]r>j¸)r?}r@(hUh}rA(U anchornameU#template-metaprogrammingUrefurihÍh]h]h]h]h]Uinternalˆuh!j;h]rBhXTemplate MetaprogrammingrC…rD}rE(hXTemplate Metaprogrammingh!j?ubah"jÀubah"jÁubah"jêubjÕ)rF}rG(hUh}rH(h]h]h]h]h]uh!j$h]rIj³)rJ}rK(hUh}rL(h]h]h]h]h]uh!jFh]rMj¸)rN}rO(hUh}rP(U anchornameU #using-tagsUrefurihÍh]h]h]h]h]Uinternalˆuh!jJh]rQhX Using TagsrR…rS}rT(hX Using Tagsh!jNubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubhÖjÐ)rU}rV(hUh}rW(h]h]h]h]h]uh]rXjÕ)rY}rZ(hUh}r[(h]h]h]h]h]uh!jUh]r\(j³)r]}r^(hUh}r_(h]h]h]h]h]uh!jYh]r`j¸)ra}rb(hUh}rc(U anchornameUUrefurihÖh]h]h]h]h]Uinternalˆuh!j]h]rdhXThe message templatere…rf}rg(hhÞh!jaubah"jÀubah"jÁubjÐ)rh}ri(hUh}rj(h]h]h]h]h]uh!jYh]rk(jÕ)rl}rm(hUh}rn(h]h]h]h]h]uh!jhh]roj³)rp}rq(hUh}rr(h]h]h]h]h]uh!jlh]rsj¸)rt}ru(hUh}rv(U anchornameU#message-conceptUrefurihÖh]h]h]h]h]Uinternalˆuh!jph]rwhXMessage Conceptrx…ry}rz(hXMessage Concepth!jtubah"jÀubah"jÁubah"jêubjÕ)r{}r|(hUh}r}(h]h]h]h]h]uh!jhh]r~(j³)r}r€(hUh}r(h]h]h]h]h]uh!j{h]r‚j¸)rƒ}r„(hUh}r…(U anchornameU"#directives-modifiers-and-wrappersUrefurihÖh]h]h]h]h]Uinternalˆuh!jh]r†hX#Directives, Modifiers, and Wrappersr‡…rˆ}r‰(hX#Directives, Modifiers, and Wrappersh!jƒubah"jÀubah"jÁubjÐ)rŠ}r‹(hUh}rŒ(h]h]h]h]h]uh!j{h]r(jÕ)rŽ}r(hUh}r(h]h]h]h]h]uh!jŠh]r‘j³)r’}r“(hUh}r”(h]h]h]h]h]uh!jŽh]r•j¸)r–}r—(hUh}r˜(U anchornameU #directivesUrefurihÖh]h]h]h]h]Uinternalˆuh!j’h]r™hX Directivesrš…r›}rœ(hX Directivesh!j–ubah"jÀubah"jÁubah"jêubjÕ)r}rž(hUh}rŸ(h]h]h]h]h]uh!jŠh]r j³)r¡}r¢(hUh}r£(h]h]h]h]h]uh!jh]r¤j¸)r¥}r¦(hUh}r§(U anchornameU #modifiersUrefurihÖh]h]h]h]h]Uinternalˆuh!j¡h]r¨hX Modifiersr©…rª}r«(hX Modifiersh!j¥ubah"jÀubah"jÁubah"jêubjÕ)r¬}r­(hUh}r®(h]h]h]h]h]uh!jŠh]r¯j³)r°}r±(hUh}r²(h]h]h]h]h]uh!j¬h]r³j¸)r´}rµ(hUh}r¶(U anchornameU #wrappersUrefurihÖh]h]h]h]h]Uinternalˆuh!j°h]r·hXWrappersr¸…r¹}rº(hXWrappersh!j´ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubjÕ)r»}r¼(hUh}r½(h]h]h]h]h]uh!jhh]r¾j³)r¿}rÀ(hUh}rÁ(h]h]h]h]h]uh!j»h]rÂj¸)rÃ}rÄ(hUh}rÅ(U anchornameU#basic-messageUrefurihÖh]h]h]h]h]Uinternalˆuh!j¿h]rÆhQ)rÇ}rÈ(hX``basic_message``h}rÉ(h]h]h]h]h]uh!jÃh]rÊhX basic_messagerË…rÌ}rÍ(hUh!jÇubah"hYubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubhßjÐ)rÎ}rÏ(hUh}rÐ(h]h]h]h]h]uh]h"j!ubhçjÐ)rÑ}rÒ(hUh}rÓ(h]h]h]h]h]uh]rÔjÕ)rÕ}rÖ(hUh}r×(h]h]h]h]h]uh!jÑh]rØ(j³)rÙ}rÚ(hUh}rÛ(h]h]h]h]h]uh!jÕh]rÜj¸)rÝ}rÞ(hUh}rß(U anchornameUUrefurihçh]h]h]h]h]Uinternalˆuh!jÙh]ràhXAtom feed readerrá…râ}rã(hhïh!jÝubah"jÀubah"jÁubjÐ)rä}rå(hUh}ræ(h]h]h]h]h]uh!jÕh]rç(jÕ)rè}ré(hUh}rê(h]h]h]h]h]uh!jäh]rëj³)rì}rí(hUh}rî(h]h]h]h]h]uh!jèh]rïj¸)rð}rñ(hUh}rò(U anchornameU #the-codeUrefurihçh]h]h]h]h]Uinternalˆuh!jìh]róhXThe coderô…rõ}rö(hXThe codeh!jðubah"jÀubah"jÁubah"jêubjÕ)r÷}rø(hUh}rù(h]h]h]h]h]uh!jäh]rúj³)rû}rü(hUh}rý(h]h]h]h]h]uh!j÷h]rþj¸)rÿ}r (hUh}r (U anchornameU!#building-and-running-atom-readerUrefurihçh]h]h]h]h]Uinternalˆuh!jûh]r (hXBuilding and running r …r }r (hXBuilding and running h!jÿubhQ)r }r (hX``atom_reader``h}r (h]h]h]h]h]uh!jÿh]r hX atom_readerr …r }r (hUh!j ubah"hYubeh"jÀubah"jÁubah"jêubjÕ)r }r (hUh}r (h]h]h]h]h]uh!jäh]r j³)r }r (hUh}r (h]h]h]h]h]uh!j h]r j¸)r }r (hUh}r (U anchornameU#diving-into-the-codeUrefurihçh]h]h]h]h]Uinternalˆuh!j h]r hXDiving into the coder …r }r (hXDiving into the codeh!j ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubhðjÐ)r }r (hUh}r (h]h]h]h]h]uh]r jÕ)r }r! (hUh}r" (h]h]h]h]h]uh!j h]r# (j³)r$ }r% (hUh}r& (h]h]h]h]h]uh!j h]r' j¸)r( }r) (hUh}r* (U anchornameUUrefurihðh]h]h]h]h]Uinternalˆuh!j$ h]r+ hXGetting Startedr, …r- }r. (hhøh!j( ubah"jÀubah"jÁubjÐ)r/ }r0 (hUh}r1 (h]h]h]h]h]uh!j h]r2 (jÕ)r3 }r4 (hUh}r5 (h]h]h]h]h]uh!j/ h]r6 j³)r7 }r8 (hUh}r9 (h]h]h]h]h]uh!j3 h]r: j¸)r; }r< (hUh}r= (U anchornameU #downloading-an-official-releaseUrefurihðh]h]h]h]h]Uinternalˆuh!j7 h]r> hXDownloading an official releaser? …r@ }rA (hXDownloading an official releaseh!j; ubah"jÀubah"jÁubah"jêubjÕ)rB }rC (hUh}rD (h]h]h]h]h]uh!j/ h]rE j³)rF }rG (hUh}rH (h]h]h]h]h]uh!jB h]rI j¸)rJ }rK (hUh}rL (U anchornameU"#downloading-a-development-versionUrefurihðh]h]h]h]h]Uinternalˆuh!jF h]rM hX!Downloading a development versionrN …rO }rP (hX!Downloading a development versionh!jJ ubah"jÀubah"jÁubah"jêubjÕ)rQ }rR (hUh}rS (h]h]h]h]h]uh!j/ h]rT j³)rU }rV (hUh}rW (h]h]h]h]h]uh!jQ h]rX j¸)rY }rZ (hUh}r[ (U anchornameU#getting-boostUrefurihðh]h]h]h]h]Uinternalˆuh!jU h]r\ hX Getting Boostr] …r^ }r_ (hX Getting Boosth!jY ubah"jÀubah"jÁubah"jêubjÕ)r` }ra (hUh}rb (h]h]h]h]h]uh!j/ h]rc j³)rd }re (hUh}rf (h]h]h]h]h]uh!j` h]rg j¸)rh }ri (hUh}rj (U anchornameU#getting-cmakeUrefurihðh]h]h]h]h]Uinternalˆuh!jd h]rk hX Getting CMakerl …rm }rn (hX Getting CMakeh!jh ubah"jÀubah"jÁubah"jêubjÕ)ro }rp (hUh}rq (h]h]h]h]h]uh!j/ h]rr (j³)rs }rt (hUh}ru (h]h]h]h]h]uh!jo h]rv j¸)rw }rx (hUh}ry (U anchornameU#building-with-cmakeUrefurihðh]h]h]h]h]Uinternalˆuh!js h]rz hXBuilding with CMaker{ …r| }r} (hXBuilding with CMakeh!jw ubah"jÀubah"jÁubjÐ)r~ }r (hUh}r€ (h]h]h]h]h]uh!jo h]r (jÕ)r‚ }rƒ (hUh}r„ (h]h]h]h]h]uh!j~ h]r… j³)r† }r‡ (hUh}rˆ (h]h]h]h]h]uh!j‚ h]r‰ j¸)rŠ }r‹ (hUh}rŒ (U anchornameU#building-on-linuxUrefurihðh]h]h]h]h]Uinternalˆuh!j† h]r hXBuilding on LinuxrŽ …r }r (hXBuilding on Linuxh!jŠ ubah"jÀubah"jÁubah"jêubjÕ)r‘ }r’ (hUh}r“ (h]h]h]h]h]uh!j~ h]r” j³)r• }r– (hUh}r— (h]h]h]h]h]uh!j‘ h]r˜ j¸)r™ }rš (hUh}r› (U anchornameU#building-on-windowsUrefurihðh]h]h]h]h]Uinternalˆuh!j• h]rœ hXBuilding On Windowsr …rž }rŸ (hXBuilding On Windowsh!j™ ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubjÕ)r  }r¡ (hUh}r¢ (h]h]h]h]h]uh!j/ h]r£ (j³)r¤ }r¥ (hUh}r¦ (h]h]h]h]h]uh!j  h]r§ j¸)r¨ }r© (hUh}rª (U anchornameU#using-cpp-netlibUrefurihðh]h]h]h]h]Uinternalˆuh!j¤ h]r« (hXUsing r¬ …r­ }r® (hXUsing h!j¨ ubhQ)r¯ }r° (hX cpp-netlibh}r± (h]h]h]h]h]uh!j¨ h]r² hX cpp-netlibr³ …r´ }rµ (hUh!j¯ ubah"hYubeh"jÀubah"jÁubjÐ)r¶ }r· (hUh}r¸ (h]h]h]h]h]uh!j  h]r¹ jÕ)rº }r» (hUh}r¼ (h]h]h]h]h]uh!j¶ h]r½ j³)r¾ }r¿ (hUh}rÀ (h]h]h]h]h]uh!jº h]rÁ j¸)r }rà (hUh}rÄ (U anchornameU#cmake-projectsUrefurihðh]h]h]h]h]Uinternalˆuh!j¾ h]rÅ hXCMake projectsrÆ …rÇ }rÈ (hXCMake projectsh!j ubah"jÀubah"jÁubah"jêubah"j!ubeh"jêubjÕ)rÉ }rÊ (hUh}rË (h]h]h]h]h]uh!j/ h]rÌ j³)rÍ }rÎ (hUh}rÏ (h]h]h]h]h]uh!jÉ h]rÐ j¸)rÑ }rÒ (hUh}rÓ (U anchornameU!#reporting-issues-getting-supportUrefurihðh]h]h]h]h]Uinternalˆuh!jÍ h]rÔ hX!Reporting Issues, Getting SupportrÕ …rÖ }r× (hX!Reporting Issues, Getting Supporth!jÑ ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubhùjÐ)rØ }rÙ (hUh}rÚ (h^]h_]h`]ha]hb]uh]rÛ jÕ)rÜ }rÝ (hUh}rÞ (h^]h_]h`]ha]hb]uh!jØ h]rß (j³)rà }rá (hUh}râ (h^]h_]h`]ha]hb]uh!jÜ h]rã j¸)rä }rå (hUh}ræ (U anchornameUUrefurihùha]h`]h^]h_]hb]Uinternalˆuh!jà h]rç hX What's Newrè …ré }rê (hjh!jä ubah"j/ubah"j0ubjÐ)rë }rì (hUh}rí (h^]h_]h`]ha]hb]uh!jÜ h]rî (jÕ)rï }rð (hUh}rñ (h^]h_]h`]ha]hb]uh!jë h]rò (j³)ró }rô (hUh}rõ (h^]h_]h`]ha]hb]uh!jï h]rö j¸)r÷ }rø (hUh}rù (U anchornameU#cpp-netlib-0-11Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!jó h]rú (hQ)rû }rü (hX cpp-netlibh}rý (h^]h_]h`]ha]hb]uh!j÷ h]rþ hX cpp-netlibrÿ …r }r (hUh!jû ubah"Uliteralr ubhX 0.11r …r }r (hX 0.11r h!j÷ ubeh"j/ubah"j0ubjÐ)r }r (hUh}r (h^]h_]h`]ha]hb]uh!jï h]r jÕ)r }r (hUh}r (h^]h_]h`]ha]hb]uh!j h]r j³)r }r (hUh}r (h^]h_]h`]ha]hb]uh!j h]r j¸)r }r (hUh}r (U anchornameU#v0-11-0Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j h]r hXv0.11.0r …r }r (hXv0.11.0r h!j ubah"j/ubah"j0ubah"j1ubah"j_ubeh"j1ubjÕ)r }r (hUh}r (h^]h_]h`]ha]hb]uh!jë h]r (j³)r }r (hUh}r! (h^]h_]h`]ha]hb]uh!j h]r" j¸)r# }r$ (hUh}r% (U anchornameU#cpp-netlib-0-10Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j h]r& (hQ)r' }r( (hX cpp-netlibh}r) (h^]h_]h`]ha]hb]uh!j# h]r* hX cpp-netlibr+ …r, }r- (hUh!j' ubah"j ubhX 0.10r. …r/ }r0 (hX 0.10r1 h!j# ubeh"j/ubah"j0ubjÐ)r2 }r3 (hUh}r4 (h^]h_]h`]ha]hb]uh!j h]r5 (jÕ)r6 }r7 (hUh}r8 (h^]h_]h`]ha]hb]uh!j2 h]r9 j³)r: }r; (hUh}r< (h^]h_]h`]ha]hb]uh!j6 h]r= j¸)r> }r? (hUh}r@ (U anchornameU#v0-10-1Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j: h]rA hXv0.10.1rB …rC }rD (hXv0.10.1rE h!j> ubah"j/ubah"j0ubah"j1ubjÕ)rF }rG (hUh}rH (h^]h_]h`]ha]hb]uh!j2 h]rI j³)rJ }rK (hUh}rL (h^]h_]h`]ha]hb]uh!jF h]rM j¸)rN }rO (hUh}rP (U anchornameU#v0-10-0Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!jJ h]rQ hXv0.10.0rR …rS }rT (hXv0.10.0rU h!jN ubah"j/ubah"j0ubah"j1ubeh"j_ubeh"j1ubjÕ)rV }rW (hUh}rX (h^]h_]h`]ha]hb]uh!jë h]rY (j³)rZ }r[ (hUh}r\ (h^]h_]h`]ha]hb]uh!jV h]r] j¸)r^ }r_ (hUh}r` (U anchornameU#cpp-netlib-0-9Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!jZ h]ra (hQ)rb }rc (hX cpp-netlibh}rd (h^]h_]h`]ha]hb]uh!j^ h]re hX cpp-netlibrf …rg }rh (hUh!jb ubah"j ubhX 0.9ri …rj }rk (hX 0.9rl h!j^ ubeh"j/ubah"j0ubjÐ)rm }rn (hUh}ro (h^]h_]h`]ha]hb]uh!jV h]rp (jÕ)rq }rr (hUh}rs (h^]h_]h`]ha]hb]uh!jm h]rt j³)ru }rv (hUh}rw (h^]h_]h`]ha]hb]uh!jq h]rx j¸)ry }rz (hUh}r{ (U anchornameU#v0-9-5Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!ju h]r| hXv0.9.5r} …r~ }r (hXv0.9.5r€ h!jy ubah"j/ubah"j0ubah"j1ubjÕ)r }r‚ (hUh}rƒ (h^]h_]h`]ha]hb]uh!jm h]r„ j³)r… }r† (hUh}r‡ (h^]h_]h`]ha]hb]uh!j h]rˆ j¸)r‰ }rŠ (hUh}r‹ (U anchornameU#v0-9-4Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j… h]rŒ hXv0.9.4r …rŽ }r (hXv0.9.4r h!j‰ ubah"j/ubah"j0ubah"j1ubjÕ)r‘ }r’ (hUh}r“ (h^]h_]h`]ha]hb]uh!jm h]r” j³)r• }r– (hUh}r— (h^]h_]h`]ha]hb]uh!j‘ h]r˜ j¸)r™ }rš (hUh}r› (U anchornameU#v0-9-3Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j• h]rœ hXv0.9.3r …rž }rŸ (hXv0.9.3r  h!j™ ubah"j/ubah"j0ubah"j1ubjÕ)r¡ }r¢ (hUh}r£ (h^]h_]h`]ha]hb]uh!jm h]r¤ j³)r¥ }r¦ (hUh}r§ (h^]h_]h`]ha]hb]uh!j¡ h]r¨ j¸)r© }rª (hUh}r« (U anchornameU#v0-9-2Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j¥ h]r¬ hXv0.9.2r­ …r® }r¯ (hXv0.9.2r° h!j© ubah"j/ubah"j0ubah"j1ubjÕ)r± }r² (hUh}r³ (h^]h_]h`]ha]hb]uh!jm h]r´ j³)rµ }r¶ (hUh}r· (h^]h_]h`]ha]hb]uh!j± h]r¸ j¸)r¹ }rº (hUh}r» (U anchornameU#v0-9-1Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!jµ h]r¼ hXv0.9.1r½ …r¾ }r¿ (hXv0.9.1rÀ h!j¹ ubah"j/ubah"j0ubah"j1ubjÕ)rÁ }r (hUh}rà (h^]h_]h`]ha]hb]uh!jm h]rÄ j³)rÅ }rÆ (hUh}rÇ (h^]h_]h`]ha]hb]uh!jÁ h]rÈ j¸)rÉ }rÊ (hUh}rË (U anchornameU#v0-9-0Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!jÅ h]rÌ hXv0.9.0rÍ …rÎ }rÏ (hXv0.9.0rÐ h!jÉ ubah"j/ubah"j0ubah"j1ubeh"j_ubeh"j1ubjÕ)rÑ }rÒ (hUh}rÓ (h^]h_]h`]ha]hb]uh!jë h]rÔ j³)rÕ }rÖ (hUh}r× (h^]h_]h`]ha]hb]uh!jÑ h]rØ j¸)rÙ }rÚ (hUh}rÛ (U anchornameU#cpp-netlib-0-8Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!jÕ h]rÜ (hQ)rÝ }rÞ (hX cpp-netlibh}rß (h^]h_]h`]ha]hb]uh!jÙ h]rà hX cpp-netlibrá …râ }rã (hUh!jÝ ubah"j ubhX 0.8rä …rå }ræ (hX 0.8rç h!jÙ ubeh"j/ubah"j0ubah"j1ubjÕ)rè }ré (hUh}rê (h^]h_]h`]ha]hb]uh!jë h]rë j³)rì }rí (hUh}rî (h^]h_]h`]ha]hb]uh!jè h]rï j¸)rð }rñ (hUh}rò (U anchornameU#cpp-netlib-0-7Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!jì h]ró (hQ)rô }rõ (hX cpp-netlibh}rö (h^]h_]h`]ha]hb]uh!jð h]r÷ hX cpp-netlibrø …rù }rú (hUh!jô ubah"j ubhX 0.7rû …rü }rý (hX 0.7rþ h!jð ubeh"j/ubah"j0ubah"j1ubjÕ)rÿ }r (hUh}r (h^]h_]h`]ha]hb]uh!jë h]r j³)r }r (hUh}r (h^]h_]h`]ha]hb]uh!jÿ h]r j¸)r }r (hUh}r (U anchornameU#cpp-netlib-0-6Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j h]r (hQ)r }r (hX cpp-netlibh}r (h^]h_]h`]ha]hb]uh!j h]r hX cpp-netlibr …r }r (hUh!j ubah"j ubhX 0.6r …r }r (hX 0.6r h!j ubeh"j/ubah"j0ubah"j1ubjÕ)r }r (hUh}r (h^]h_]h`]ha]hb]uh!jë h]r j³)r }r (hUh}r (h^]h_]h`]ha]hb]uh!j h]r j¸)r }r (hUh}r (U anchornameU#cpp-netlib-0-5Urefurihùha]h`]h^]h_]hb]Uinternalˆuh!j h]r! (hQ)r" }r# (hX cpp-netlibh}r$ (h^]h_]h`]ha]hb]uh!j h]r% hX cpp-netlibr& …r' }r( (hUh!j" ubah"j ubhX 0.5r) …r* }r+ (hX 0.5r, h!j ubeh"j/ubah"j0ubah"j1ubeh"j_ubeh"j1ubah"j_ubjjÐ)r- }r. (hUh}r/ (h]h]h]h]h]uh]r0 jÕ)r1 }r2 (hUh}r3 (h]h]h]h]h]uh!j- h]r4 (j³)r5 }r6 (hUh}r7 (h]h]h]h]h]uh!j1 h]r8 j¸)r9 }r: (hUh}r; (U anchornameUUrefurijh]h]h]h]h]Uinternalˆuh!j5 h]r< hX HTTP Requestr= …r> }r? (hj h!j9 ubah"jÀubah"jÁubjÐ)r@ }rA (hUh}rB (h]h]h]h]h]uh!j1 h]rC (jÕ)rD }rE (hUh}rF (h]h]h]h]h]uh!j@ h]rG (j³)rH }rI (hUh}rJ (h]h]h]h]h]uh!jD h]rK j¸)rL }rM (hUh}rN (U anchornameU#request-conceptsUrefurijh]h]h]h]h]Uinternalˆuh!jH h]rO hXRequest ConceptsrP …rQ }rR (hXRequest Conceptsh!jL ubah"jÀubah"jÁubjÐ)rS }rT (hUh}rU (h]h]h]h]h]uh!jD h]rV (jÕ)rW }rX (hUh}rY (h]h]h]h]h]uh!jS h]rZ j³)r[ }r\ (hUh}r] (h]h]h]h]h]uh!jW h]r^ j¸)r_ }r` (hUh}ra (U anchornameU#normal-client-request-conceptUrefurijh]h]h]h]h]Uinternalˆuh!j[ h]rb hXNormal Client Request Conceptrc …rd }re (hXNormal Client Request Concepth!j_ ubah"jÀubah"jÁubah"jêubjÕ)rf }rg (hUh}rh (h]h]h]h]h]uh!jS h]ri j³)rj }rk (hUh}rl (h]h]h]h]h]uh!jf h]rm j¸)rn }ro (hUh}rp (U anchornameU#pod-server-request-conceptUrefurijh]h]h]h]h]Uinternalˆuh!jj h]rq hXPod Server Request Conceptrr …rs }rt (hXPod Server Request Concepth!jn ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubjÕ)ru }rv (hUh}rw (h]h]h]h]h]uh!j@ h]rx j³)ry }rz (hUh}r{ (h]h]h]h]h]uh!ju h]r| j¸)r} }r~ (hUh}r (U anchornameU #directivesUrefurijh]h]h]h]h]Uinternalˆuh!jy h]r€ hX Directivesr …r‚ }rƒ (hX Directivesh!j} ubah"jÀubah"jÁubah"jêubjÕ)r„ }r… (hUh}r† (h]h]h]h]h]uh!j@ h]r‡ j³)rˆ }r‰ (hUh}rŠ (h]h]h]h]h]uh!j„ h]r‹ j¸)rŒ }r (hUh}rŽ (U anchornameU #modifiersUrefurijh]h]h]h]h]Uinternalˆuh!jˆ h]r hX Modifiersr …r‘ }r’ (hX Modifiersh!jŒ ubah"jÀubah"jÁubah"jêubjÕ)r“ }r” (hUh}r• (h]h]h]h]h]uh!j@ h]r– j³)r— }r˜ (hUh}r™ (h]h]h]h]h]uh!j“ h]rš j¸)r› }rœ (hUh}r (U anchornameU #wrappersUrefurijh]h]h]h]h]Uinternalˆuh!j— h]rž hXWrappersrŸ …r  }r¡ (hXWrappersh!j› ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubj jÐ)r¢ }r£ (hUh}r¤ (h^]h_]h`]ha]hb]uh]r¥ jÕ)r¦ }r§ (hUh}r¨ (h^]h_]h`]ha]hb]uh!j¢ h]r© (j³)rª }r« (hUh}r¬ (h^]h_]h`]ha]hb]uh!j¦ h]r­ j¸)r® }r¯ (hUh}r° (U anchornameUUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!jª h]r± hXHTTP Client APIr² …r³ }r´ (hjh!j® ubah"j/ubah"j0ubjÐ)rµ }r¶ (hUh}r· (h^]h_]h`]ha]hb]uh!j¦ h]r¸ (jÕ)r¹ }rº (hUh}r» (h^]h_]h`]ha]hb]uh!jµ h]r¼ j³)r½ }r¾ (hUh}r¿ (h^]h_]h`]ha]hb]uh!j¹ h]rÀ j¸)rÁ }r (hUh}rà (U anchornameU#generalUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!j½ h]rÄ hXGeneralrÅ …rÆ }rÇ (hXGeneralrÈ h!jÁ ubah"j/ubah"j0ubah"j1ubjÕ)rÉ }rÊ (hUh}rË (h^]h_]h`]ha]hb]uh!jµ h]rÌ (j³)rÍ }rÎ (hUh}rÏ (h^]h_]h`]ha]hb]uh!jÉ h]rÐ j¸)rÑ }rÒ (hUh}rÓ (U anchornameU#implementationsUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!jÍ h]rÔ hXImplementationsrÕ …rÖ }r× (hXImplementationsrØ h!jÑ ubah"j/ubah"j0ubjÐ)rÙ }rÚ (hUh}rÛ (h^]h_]h`]ha]hb]uh!jÉ h]rÜ (jÕ)rÝ }rÞ (hUh}rß (h^]h_]h`]ha]hb]uh!jÙ h]rà j³)rá }râ (hUh}rã (h^]h_]h`]ha]hb]uh!jÝ h]rä j¸)rå }ræ (hUh}rç (U anchornameU#synchronous-clientsUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!já h]rè hXSynchronous Clientsré …rê }rë (hXSynchronous Clientsrì h!jå ubah"j/ubah"j0ubah"j1ubjÕ)rí }rî (hUh}rï (h^]h_]h`]ha]hb]uh!jÙ h]rð j³)rñ }rò (hUh}ró (h^]h_]h`]ha]hb]uh!jí h]rô j¸)rõ }rö (hUh}r÷ (U anchornameU#asynchronous-clientsUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!jñ h]rø hXAsynchronous Clientsrù …rú }rû (hXAsynchronous Clientsrü h!jõ ubah"j/ubah"j0ubah"j1ubeh"j_ubeh"j1ubjÕ)rý }rþ (hUh}rÿ (h^]h_]h`]ha]hb]uh!jµ h]r (j³)r }r (hUh}r (h^]h_]h`]ha]hb]uh!jý h]r j¸)r }r (hUh}r (U anchornameU#member-functionsUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!j h]r hXMember Functionsr …r }r (hXMember Functionsr h!j ubah"j/ubah"j0ubjÐ)r }r (hUh}r (h^]h_]h`]ha]hb]uh!jý h]r (jÕ)r }r (hUh}r (h^]h_]h`]ha]hb]uh!j h]r j³)r }r (hUh}r (h^]h_]h`]ha]hb]uh!j h]r j¸)r }r (hUh}r (U anchornameU #constructorsUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!j h]r hX Constructorsr …r }r (hX Constructorsr h!j ubah"j/ubah"j0ubah"j1ubjÕ)r! }r" (hUh}r# (h^]h_]h`]ha]hb]uh!j h]r$ j³)r% }r& (hUh}r' (h^]h_]h`]ha]hb]uh!j! h]r( j¸)r) }r* (hUh}r+ (U anchornameU #http-methodsUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!j% h]r, hX HTTP Methodsr- …r. }r/ (hX HTTP Methodsr0 h!j) ubah"j/ubah"j0ubah"j1ubjÕ)r1 }r2 (hUh}r3 (h^]h_]h`]ha]hb]uh!j h]r4 j³)r5 }r6 (hUh}r7 (h^]h_]h`]ha]hb]uh!j1 h]r8 j¸)r9 }r: (hUh}r; (U anchornameU#client-specificUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!j5 h]r< hXClient-Specificr= …r> }r? (hXClient-Specificr@ h!j9 ubah"j/ubah"j0ubah"j1ubjÕ)rA }rB (hUh}rC (h^]h_]h`]ha]hb]uh!j h]rD j³)rE }rF (hUh}rG (h^]h_]h`]ha]hb]uh!jA h]rH j¸)rI }rJ (hUh}rK (U anchornameU#streaming-body-handlerUrefurij ha]h`]h^]h_]hb]Uinternalˆuh!jE h]rL hXStreaming Body HandlerrM …rN }rO (hXStreaming Body HandlerrP h!jI ubah"j/ubah"j0ubah"j1ubeh"j_ubeh"j1ubeh"j_ubeh"j1ubah"j_ubjjÐ)rQ }rR (hUh}rS (h]h]h]h]h]uh]rT jÕ)rU }rV (hUh}rW (h]h]h]h]h]uh!jQ h]rX (j³)rY }rZ (hUh}r[ (h]h]h]h]h]uh!jU h]r\ j¸)r] }r^ (hUh}r_ (U anchornameUUrefurijh]h]h]h]h]Uinternalˆuh!jY h]r` hXProject historyra …rb }rc (hjh!j] ubah"jÀubah"jÁubjÐ)rd }re (hUh}rf (h]h]h]h]h]uh!jU h]rg (jÕ)rh }ri (hUh}rj (h]h]h]h]h]uh!jd h]rk j³)rl }rm (hUh}rn (h]h]h]h]h]uh!jh h]ro j¸)rp }rq (hUh}rr (U anchornameU #motivationUrefurijh]h]h]h]h]Uinternalˆuh!jl h]rs hX Motivationrt …ru }rv (hX Motivationh!jp ubah"jÀubah"jÁubah"jêubjÕ)rw }rx (hUh}ry (h]h]h]h]h]uh!jd h]rz j³)r{ }r| (hUh}r} (h]h]h]h]h]uh!jw h]r~ j¸)r }r€ (hUh}r (U anchornameU #objectivesUrefurijh]h]h]h]h]Uinternalˆuh!j{ h]r‚ hX Objectivesrƒ …r„ }r… (hX Objectivesh!j ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubjjÐ)r† }r‡ (hUh}rˆ (h]h]h]h]h]uh]r‰ jÕ)rŠ }r‹ (hUh}rŒ (h]h]h]h]h]uh!j† h]r (j³)rŽ }r (hUh}r (h]h]h]h]h]uh!jŠ h]r‘ j¸)r’ }r“ (hUh}r” (U anchornameUUrefurijh]h]h]h]h]Uinternalˆuh!jŽ h]r• hXHTTP implementationr– …r— }r˜ (hj%h!j’ ubah"jÀubah"jÁubjÐ)r™ }rš (hUh}r› (h]h]h]h]h]uh!jŠ h]rœ (jÕ)r }rž (hUh}rŸ (h]h]h]h]h]uh!j™ h]r  j³)r¡ }r¢ (hUh}r£ (h]h]h]h]h]uh!j h]r¤ j¸)r¥ }r¦ (hUh}r§ (U anchornameU #http-clientUrefurijh]h]h]h]h]Uinternalˆuh!j¡ h]r¨ hX HTTP clientr© …rª }r« (hX HTTP clienth!j¥ ubah"jÀubah"jÁubah"jêubjÕ)r¬ }r­ (hUh}r® (h]h]h]h]h]uh!j™ h]r¯ j³)r° }r± (hUh}r² (h]h]h]h]h]uh!j¬ h]r³ j¸)r´ }rµ (hUh}r¶ (U anchornameU #http-serverUrefurijh]h]h]h]h]Uinternalˆuh!j° h]r· hX HTTP serverr¸ …r¹ }rº (hX HTTP serverh!j´ ubah"jÀubah"jÁubah"jêubeh"j!ubeh"jêubah"j!ubuU indexentriesr» }r¼ (h]h$]h-]h6]h?]hH]hZ]hi]hr]h{]h„]h]h–]hŸ]h¨]h»]hÄ]hÍ]hÖ]hß]hç]hð]hù]j]j ]j]j]uUall_docsr½ }r¾ (hGAÔ­Ôz‚h$GAÔ­Ô±xîh-GAÔ­Ôv'éh6GAÔ­Ôl±h?GAÔ­Ôu¾hHGAÔ­Ô…|¦hZGAÔ¸æ'$[hiGAÔ­Ô³;ihrGAÔ­Ô“ãh{GAÔ­Ôx„Qh„GAÔ­Ô¯ªçhGAÔ­Ô¦nüh–GAÔ­Ô² úhŸGAÔ­ÔÉh¨GAÔ­Ô~)Çh»GAÔ­Ô|Ø„hÄGAÔ­Ô´øhÍGAÔ­ÔµåhÖGAÔ­Ô5ÎhßGAÔ­Ô‰eIhçGAÔ­Ôw?KhðGAÔ­ÔƒÒhùGAÔ¸æ4<´jGAÔ­ÔŸj GAÔ¸æ.Ô‘jGAÔ­Ô„­GjGAÔ­Ôˆ)NujÏ}r¿ (Ucloak_email_addressesˆUtrim_footnote_reference_space‰U halt_levelKUsectsubtitle_xform‰Uembed_stylesheet‰U pep_base_urljUdoctitle_xform‰Uwarning_streamcsphinx.util.nodes WarningStream rÀ )rÁ }r (U_rerà cre _compile rÄ U+\((DEBUG|INFO|WARNING|ERROR|SEVERE)/[0-4]\)rÅ K†RrÆ UwarnfuncrÇ NubUenvhU rfc_base_urljÖUfile_insertion_enabledˆUgettext_compactˆUinput_encodingjIuUfiles_to_rebuildrÈ }rÉ (j¢h]rÊ h?a…RrË j£h]rÌ h?a…RrÍ jžh]rÎ h?a…RrÏ j¦h]rÐ hHa…RrÑ j h]rÒ h?a…RrÓ j›h]rÔ h?a…RrÕ j‘h]rÖ h–a…Rr× j–h]rØ h-a…RrÙ j—h]rÚ h-a…RrÛ jŽh]rÜ hra…RrÝ jh]rÞ hra…Rrß jŸh]rà h?a…Rrá j™h]râ h-a…Rrã j•h]rä h-a…Rrå j”h]ræ h-a…Rrç j’h]rè h–a…Rré jh]rê h–a…Rrë j¥h]rì hHa…Rrí j˜h]rî h-a…Rrï jh]rð h?a…Rrñ jœh]rò h?a…Rró jŒh]rô hra…Rrõ j‹h]rö hra…Rr÷ j¡h]rø h?a…Rrù j§h]rú hHa…Rrû uUtoc_secnumbersrü }U_nitpick_ignorerý h]…Rrþ U _warnfuncrÿ Nub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples.doctree000066400000000000000000000155161240331347200274050ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(X http examplesqNXexamplesqˆuUsubstitution_defsq}q Uparse_messagesq ]q cdocutils.nodes system_message q )q }q(U rawsourceqUUparentqcdocutils.nodes section q)q}q(hUU referencedqKhhUsourceqcdocutils.nodes reprunicode qX>/Users/dean/Documents/cpp-netlib/libs/network/doc/examples.rstq…q}qbUexpect_referenced_by_nameq}qhcdocutils.nodes target q)q}q(hX .. _examples:hhhhUtagnameqUtargetq U attributesq!}q"(Uidsq#]Ubackrefsq$]Udupnamesq%]Uclassesq&]Unamesq']Urefidq(Uexamplesq)uUlineq*KUdocumentq+hUchildrenq,]ubshUsectionq-h!}q.(h%]q/Xexamplesq0ah&]h$]h#]q1(h)Uid1q2eh']q3hauh*Kh+hUexpect_referenced_by_idq4}q5h)hsh,]q6(cdocutils.nodes title q7)q8}q9(hXExamplesq:hhhhhUtitleq;h!}q<(h%]h&]h$]h#]h']uh*Kh+hh,]q=cdocutils.nodes Text q>XExamplesq?…q@}qA(hh:hh8ubaubcdocutils.nodes paragraph qB)qC}qD(hXOThe :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. All examples are built using CMake.hhhhhU paragraphqEh!}qF(h%]h&]h$]h#]h']uh*Kh+hh,]qG(h>XThe qH…qI}qJ(hXThe hhCubcsphinx.addnodes pending_xref qK)qL}qM(hX:mod:`cpp-netlib`qNhhChhhU pending_xrefqOh!}qP(UreftypeXmodUrefwarnqQ‰U reftargetqRX cpp-netlibU refdomainXpyqSh#]h$]U refexplicit‰h%]h&]h']UrefdocqTXexamplesqUUpy:classqVNU py:moduleqWNuh*Kh,]qXcdocutils.nodes literal qY)qZ}q[(hhNh!}q\(h%]h&]q](Uxrefq^hSXpy-modq_eh$]h#]h']uhhLh,]q`h>X cpp-netlibqa…qb}qc(hUhhZubahUliteralqdubaubh>Xä 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 qe…qf}qg(hXä 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 hhCubhK)qh}qi(hX:mod:`cpp-netlib`qjhhChhhhOh!}qk(UreftypeXmodhQ‰hRX cpp-netlibU refdomainXpyqlh#]h$]U refexplicit‰h%]h&]h']hThUhVNhWNuh*Kh,]qmhY)qn}qo(hhjh!}qp(h%]h&]qq(h^hlXpy-modqreh$]h#]h']uhhhh,]qsh>X cpp-netlibqt…qu}qv(hUhhnubahhdubaubh>XE for these kinds of application. All examples are built using CMake.qw…qx}qy(hXE for these kinds of application. All examples are built using CMake.hhCubeubh)qz}q{(hUhhhhhh-h!}q|(h%]h&]h$]h#]q}U http-examplesq~ah']qhauh*K h+hh,]q€(h7)q}q‚(hX HTTP examplesqƒhhzhhhh;h!}q„(h%]h&]h$]h#]h']uh*K h+hh,]q…h>X HTTP examplesq†…q‡}qˆ(hhƒhhubaubhB)q‰}qŠ(hX³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.hhzhhhhEh!}q‹(h%]h&]h$]h#]h']uh*Kh+hh,]qŒ(h>XThe HTTP component of the q…qŽ}q(hXThe HTTP component of the hh‰ubhK)q}q‘(hX:mod:`cpp-netlib`q’hh‰hhhhOh!}q“(UreftypeXmodhQ‰hRX cpp-netlibU refdomainXpyq”h#]h$]U refexplicit‰h%]h&]h']hThUhVNhWNuh*Kh,]q•hY)q–}q—(hh’h!}q˜(h%]h&]q™(h^h”Xpy-modqšeh$]h#]h']uhhh,]q›h>X cpp-netlibqœ…q}qž(hUhh–ubahhdubaubh>Xˆ contains a client and server. The examples that follow show how to use both for programs that can be embedded into larger applications.qŸ…q }q¡(hXˆ contains a client and server. The examples that follow show how to use both for programs that can be embedded into larger applications.hh‰ubeubcdocutils.nodes compound q¢)q£}q¤(hUhhzhhhUcompoundq¥h!}q¦(h%]h&]q§Utoctree-wrapperq¨ah$]h#]h']uh*Nh+hh,]q©csphinx.addnodes toctree qª)q«}q¬(hUhh£hhhUtoctreeq­h!}q®(Unumberedq¯KU includehiddenq°‰hhUU titlesonlyq±‰Uglobq²‰h#]h$]h%]h&]h']Uentriesq³]q´(NXexamples/http/http_clientqµ†q¶NXexamples/http/simple_wgetq·†q¸NX examples/http/hello_world_serverq¹†qºNX examples/http/hello_world_clientq»†q¼NXexamples/http/atom_readerq½†q¾NXexamples/http/twitter_searchq¿†qÀeUhiddenqÁ‰U includefilesqÂ]qÃ(hµh·h¹h»h½h¿eUmaxdepthqÄKuh*Kh,]ubaubeubeubhhhUsystem_messageqÅh!}qÆ(h%]UlevelKh#]h$]qÇh2aUsourcehh&]h']UlineKUtypeUINFOqÈuh*Kh+hh,]qÉhB)qÊ}qË(hUh!}qÌ(h%]h&]h$]h#]h']uhh h,]qÍh>X+Duplicate implicit target name: "examples".qÎ…qÏ}qÐ(hUhhÊubahhEubaubaUcurrent_sourceqÑNU decorationqÒNUautofootnote_startqÓKUnameidsqÔ}qÕ(hh~hh)uh,]qÖ(hhehUU transformerq×NU footnote_refsqØ}qÙUrefnamesqÚ}qÛUsymbol_footnotesqÜ]qÝUautofootnote_refsqÞ]qßUsymbol_footnote_refsqà]qáU citationsqâ]qãh+hU current_lineqäNUtransform_messagesqå]qæh )qç}qè(hUh!}qé(h%]UlevelKh#]h$]Usourcehh&]h']UlineKUtypehÈuh,]qêhB)që}qì(hUh!}qí(h%]h&]h$]h#]h']uhhçh,]qîh>X.Hyperlink target "examples" is not referenced.qï…qð}qñ(hUhhëubahhEubahhÅubaUreporterqòNUid_startqóKU autofootnotesqô]qõU citation_refsqö}q÷Uindirect_targetsqø]qùUsettingsqú(cdocutils.frontend Values qûoqü}qý(Ufootnote_backlinksqþKUrecord_dependenciesqÿNU rfc_base_urlrUhttp://tools.ietf.org/html/rU tracebackrˆUpep_referencesrNUstrip_commentsrNU toc_backlinksrUentryrU language_coderUenrU datestampr NU report_levelr KU _destinationr NU halt_levelr KU strip_classesr Nh;NUerror_encoding_error_handlerrUbackslashreplacerUdebugrNUembed_stylesheetr‰Uoutput_encoding_error_handlerrUstrictrU sectnum_xformrKUdump_transformsrNU docinfo_xformrKUwarning_streamrNUpep_file_url_templaterUpep-%04drUexit_status_levelrKUconfigrNUstrict_visitorrNUcloak_email_addressesrˆUtrim_footnote_reference_spacer‰UenvrNUdump_pseudo_xmlr NUexpose_internalsr!NUsectsubtitle_xformr"‰U source_linkr#NUrfc_referencesr$NUoutput_encodingr%Uutf-8r&U source_urlr'NUinput_encodingr(Uutf-8r)U_disable_configr*NU id_prefixr+UU tab_widthr,KUerror_encodingr-UUS-ASCIIr.U_sourcer/U>/Users/dean/Documents/cpp-netlib/libs/network/doc/examples.rstr0Ugettext_compactr1ˆU generatorr2NUdump_internalsr3NU smart_quotesr4‰U pep_base_urlr5Uhttp://www.python.org/dev/peps/r6Usyntax_highlightr7Ulongr8Uinput_encoding_error_handlerr9jUauto_id_prefixr:Uidr;Udoctitle_xformr<‰Ustrip_elements_with_classesr=NU _config_filesr>]Ufile_insertion_enabledr?ˆU raw_enabledr@KU dump_settingsrANubUsymbol_footnote_startrBKUidsrC}rD(h~hzh)hh2huUsubstitution_namesrE}rFhh+h!}rG(h%]h#]h$]Usourcehh&]h']uU footnotesrH]rIUrefidsrJ}rKh)]rLhasub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/000077500000000000000000000000001240331347200260265ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/http/000077500000000000000000000000001240331347200270055ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/http/atom_reader.doctree000066400000000000000000000236061240331347200326450ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xatom feed readerqNXrapidxmlqˆXthe codeqNX atom_readerq ˆXdiving into the codeq NXatomq ˆX building and running atom_readerq NuUsubstitution_defsq }qUparse_messagesq]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUatom-feed-readerqhUrapidxmlqhUthe-codeqh U atom-readerqh Udiving-into-the-codeqh Uatomqh U building-and-running-atom-readerquUchildrenq]q(cdocutils.nodes target q)q }q!(U rawsourceq"X.. _atom_reader:Uparentq#hUsourceq$cdocutils.nodes reprunicode q%XO/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/atom_reader.rstq&…q'}q(bUtagnameq)Utargetq*U attributesq+}q,(Uidsq-]Ubackrefsq.]Udupnamesq/]Uclassesq0]Unamesq1]Urefidq2huUlineq3KUdocumentq4hh]ubcdocutils.nodes section q5)q6}q7(h"Uh#hh$h'Uexpect_referenced_by_nameq8}q9h h sh)Usectionq:h+}q;(h/]h0]h.]h-]q<(hheh1]q=(hh euh3Kh4hUexpect_referenced_by_idq>}q?hh sh]q@(cdocutils.nodes title qA)qB}qC(h"XAtom feed readerqDh#h6h$h'h)UtitleqEh+}qF(h/]h0]h.]h-]h1]uh3Kh4hh]qGcdocutils.nodes Text qHXAtom feed readerqI…qJ}qK(h"hDh#hBubaubcdocutils.nodes paragraph qL)qM}qN(h"X³The next examples show some simple, more practical applications using the HTTP client. The first one reads a simple Atom_ feed and prints the titles of each entry to the console.h#h6h$h'h)U paragraphqOh+}qP(h/]h0]h.]h-]h1]uh3Kh4hh]qQ(hHXuThe next examples show some simple, more practical applications using the HTTP client. The first one reads a simple qR…qS}qT(h"XuThe next examples show some simple, more practical applications using the HTTP client. The first one reads a simple h#hMubcdocutils.nodes reference qU)qV}qW(h"XAtom_UresolvedqXKh#hMh)U referenceqYh+}qZ(UnameXAtomUrefuriq[X,http://en.wikipedia.org/wiki/Atom_(standard)q\h-]h.]h/]h0]h1]uh]q]hHXAtomq^…q_}q`(h"Uh#hVubaubhHX9 feed and prints the titles of each entry to the console.qa…qb}qc(h"X9 feed and prints the titles of each entry to the console.h#hMubeubh)qd}qe(h"X6.. _Atom: http://en.wikipedia.org/wiki/Atom_(standard)U referencedqfKh#h6h$h'h)h*h+}qg(h[h\h-]qhhah.]h/]h0]h1]qih auh3K h4hh]ubh5)qj}qk(h"Uh#h6h$h'h)h:h+}ql(h/]h0]h.]h-]qmhah1]qnhauh3Kh4hh]qo(hA)qp}qq(h"XThe codeqrh#hjh$h'h)hEh+}qs(h/]h0]h.]h-]h1]uh3Kh4hh]qthHXThe codequ…qv}qw(h"hrh#hpubaubcdocutils.nodes literal_block qx)qy}qz(h"X¨#include "atom.hpp" #include #include #include int main(int argc, char * argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); atom::feed feed(response); std::cout << "Feed: " << feed.title() << " (" << feed.subtitle() << ")" << std::endl; BOOST_FOREACH(const atom::entry &entry, feed) { std::cout << entry.title() << " (" << entry.published() << ")" << std::endl; } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; }h#hjh$h'h)U literal_blockq{h+}q|(Ulinenosq}‰Ulanguageq~Xc++U xml:spaceqUpreserveq€h-]h.]h/]h0]h1]uh3Kh4hh]qhHX¨#include "atom.hpp" #include #include #include int main(int argc, char * argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); atom::feed feed(response); std::cout << "Feed: " << feed.title() << " (" << feed.subtitle() << ")" << std::endl; BOOST_FOREACH(const atom::entry &entry, feed) { std::cout << entry.title() << " (" << entry.published() << ")" << std::endl; } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; }q‚…qƒ}q„(h"Uh#hyubaubeubh5)q…}q†(h"Uh#h6h$h'h)h:h+}q‡(h/]h0]h.]h-]qˆhah1]q‰h auh3K5h4hh]qŠ(hA)q‹}qŒ(h"X$Building and running ``atom_reader``qh#h…h$h'h)hEh+}qŽ(h/]h0]h.]h-]h1]uh3K5h4hh]q(hHXBuilding and running q…q‘}q’(h"XBuilding and running q“h#h‹ubcdocutils.nodes literal q”)q•}q–(h"X``atom_reader``q—h+}q˜(h/]h0]h.]h-]h1]uh#h‹h]q™hHX atom_readerqš…q›}qœ(h"Uh#h•ubah)Uliteralqubeubhx)qž}qŸ(h"X*$ cd ~/cpp-netlib-build $ make atom_readerh#h…h$h'h)h{h+}q (h}‰h~Xbashhh€h-]h.]h/]h0]h1]uh3K7h4hh]q¡hHX*$ cd ~/cpp-netlib-build $ make atom_readerq¢…q£}q¤(h"Uh#hžubaubhL)q¥}q¦(h"X|And to run the example from the command line to access the feed that lists of all the commits on cpp-netlib's master branch:q§h#h…h$h'h)hOh+}q¨(h/]h0]h.]h-]h1]uh3KNUcloak_email_addressesr?ˆUtrim_footnote_reference_spacer@‰UenvrANUdump_pseudo_xmlrBNUexpose_internalsrCNUsectsubtitle_xformrD‰U source_linkrENUrfc_referencesrFNUoutput_encodingrGUutf-8rHU source_urlrINUinput_encodingrJUutf-8rKU_disable_configrLNU id_prefixrMUU tab_widthrNKUerror_encodingrOUUS-ASCIIrPU_sourcerQUO/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/atom_reader.rstrRUgettext_compactrSˆU generatorrTNUdump_internalsrUNU smart_quotesrV‰U pep_base_urlrWUhttp://www.python.org/dev/peps/rXUsyntax_highlightrYUlongrZUinput_encoding_error_handlerr[j5Uauto_id_prefixr\Uidr]Udoctitle_xformr^‰Ustrip_elements_with_classesr_NU _config_filesr`]Ufile_insertion_enabledraˆU raw_enabledrbKU dump_settingsrcNubUsymbol_footnote_startrdKUidsre}rf(hh6hh…hhßhh6hhdhh´hhjuUsubstitution_namesrg}rhh)h4h+}ri(h/]h-]h.]Usourceh'h0]h1]uU footnotesrj]rkUrefidsrl}rmh]rnh asub.hello_world_client.doctree000066400000000000000000000256421240331347200341560ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/http€cdocutils.nodes document q)q}q(U nametypesq}q(X"hello world" http clientqNXhello_world_http_clientqˆXdiving into the codeqNXthe codeq NXbuilding and running the clientq NuUsubstitution_defsq }q Uparse_messagesq ]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUid1qhUhello-world-http-clientqhUdiving-into-the-codeqh Uthe-codeqh Ubuilding-and-running-the-clientquUchildrenq]q(cdocutils.nodes target q)q}q(U rawsourceqX.. _hello_world_http_client:UparentqhUsourceq cdocutils.nodes reprunicode q!XV/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/hello_world_client.rstq"…q#}q$bUtagnameq%Utargetq&U attributesq'}q((Uidsq)]Ubackrefsq*]Udupnamesq+]Uclassesq,]Unamesq-]Urefidq.huUlineq/KUdocumentq0hh]ubcdocutils.nodes section q1)q2}q3(hUhhh h#Uexpect_referenced_by_nameq4}q5hhsh%Usectionq6h'}q7(h+]h,]h*]h)]q8(hheh-]q9(hheuh/Kh0hUexpect_referenced_by_idq:}q;hhsh]q<(cdocutils.nodes title q=)q>}q?(hX"Hello world" HTTP clientq@hh2h h#h%UtitleqAh'}qB(h+]h,]h*]h)]h-]uh/Kh0hh]qCcdocutils.nodes Text qDX"Hello world" HTTP clientqE…qF}qG(hh@hh>ubaubcdocutils.nodes paragraph qH)qI}qJ(hX·Since we have a "Hello World" HTTP server, let's then create an HTTP client to access that server. This client will be similar to the HTTP client we made earlier in the documentation.qKhh2h h#h%U paragraphqLh'}qM(h+]h,]h*]h)]h-]uh/Kh0hh]qNhDX·Since we have a "Hello World" HTTP server, let's then create an HTTP client to access that server. This client will be similar to the HTTP client we made earlier in the documentation.qO…qP}qQ(hhKhhIubaubh1)qR}qS(hUhh2h h#h%h6h'}qT(h+]h,]h*]h)]qUhah-]qVh auh/K h0hh]qW(h=)qX}qY(hXThe codeqZhhRh h#h%hAh'}q[(h+]h,]h*]h)]h-]uh/K h0hh]q\hDXThe codeq]…q^}q_(hhZhhXubaubhH)q`}qa(hX›We want to create a simple HTTP client that just makes a request to the HTTP server that we created earlier. This really simple client will look like this:qbhhRh h#h%hLh'}qc(h+]h,]h*]h)]h-]uh/Kh0hh]qdhDX›We want to create a simple HTTP client that just makes a request to the HTTP server that we created earlier. This really simple client will look like this:qe…qf}qg(hhbhh`ubaubcdocutils.nodes literal_block qh)qi}qj(hXÛ#include #include #include #include namespace http = boost::network::http; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { http::client client; std::ostringstream url; url << "http://" << argv[1] << ":" << argv[2] << "/"; http::client::request request(url.str()); http::client::response response = client.get(request); std::cout << body(response) << std::endl; } catch (std::exception & e) { std::cerr << e.what() << std::endl; return 1; } return 0; }hhRh h#h%U literal_blockqkh'}ql(Ulinenosqm‰UlanguageqnXc++U xml:spaceqoUpreserveqph)]h*]h+]h,]h-]uh/Kh0hh]qqhDXÛ#include #include #include #include namespace http = boost::network::http; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { http::client client; std::ostringstream url; url << "http://" << argv[1] << ":" << argv[2] << "/"; http::client::request request(url.str()); http::client::response response = client.get(request); std::cout << body(response) << std::endl; } catch (std::exception & e) { std::cerr << e.what() << std::endl; return 1; } return 0; }qr…qs}qt(hUhhiubaubeubh1)qu}qv(hUhh2h h#h%h6h'}qw(h+]h,]h*]h)]qxhah-]qyh auh/K0h0hh]qz(h=)q{}q|(hXBuilding and running the clientq}hhuh h#h%hAh'}q~(h+]h,]h*]h)]h-]uh/K0h0hh]qhDXBuilding and running the clientq€…q}q‚(hh}hh{ubaubhH)qƒ}q„(hX}Just like with the HTTP Server and HTTP client example before, we can build this example by doing the following on the shell:q…hhuh h#h%hLh'}q†(h+]h,]h*]h)]h-]uh/K2h0hh]q‡hDX}Just like with the HTTP Server and HTTP client example before, we can build this example by doing the following on the shell:qˆ…q‰}qŠ(hh…hhƒubaubhh)q‹}qŒ(hX1$ cd ~/cpp-netlib-build $ make hello_world_clienthhuh h#h%hkh'}q(hm‰hnXbashhohph)]h*]h+]h,]h-]uh/K5h0hh]qŽhDX1$ cd ~/cpp-netlib-build $ make hello_world_clientq…q}q‘(hUhh‹ubaubhH)q’}q“(hX9This example can be run from the command line as follows:q”hhuh h#h%hLh'}q•(h+]h,]h*]h)]h-]uh/K:h0hh]q–hDX9This example can be run from the command line as follows:q—…q˜}q™(hh”hh’ubaubhh)qš}q›(hX4$ ./example/hello_world_client http://127.0.0.1:8000hhuh h#h%hkh'}qœ(hm‰hnXbashhohph)]h*]h+]h,]h-]uh/KKU _destinationr?NU halt_levelr@KU strip_classesrANhANUerror_encoding_error_handlerrBUbackslashreplacerCUdebugrDNUembed_stylesheetrE‰Uoutput_encoding_error_handlerrFUstrictrGU sectnum_xformrHKUdump_transformsrINU docinfo_xformrJKUwarning_streamrKNUpep_file_url_templaterLUpep-%04drMUexit_status_levelrNKUconfigrONUstrict_visitorrPNUcloak_email_addressesrQˆUtrim_footnote_reference_spacerR‰UenvrSNUdump_pseudo_xmlrTNUexpose_internalsrUNUsectsubtitle_xformrV‰U source_linkrWNUrfc_referencesrXNUoutput_encodingrYUutf-8rZU source_urlr[NUinput_encodingr\Uutf-8r]U_disable_configr^NU id_prefixr_UU tab_widthr`KUerror_encodingraUUS-ASCIIrbU_sourcercUV/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/hello_world_client.rstrdUgettext_compactreˆU generatorrfNUdump_internalsrgNU smart_quotesrh‰U pep_base_urlriUhttp://www.python.org/dev/peps/rjUsyntax_highlightrkUlongrlUinput_encoding_error_handlerrmjGUauto_id_prefixrnUidroUdoctitle_xformrp‰Ustrip_elements_with_classesrqNU _config_filesrr]rsUfile_insertion_enabledrtˆU raw_enabledruKU dump_settingsrvNubUsymbol_footnote_startrwKUidsrx}ry(hhºhhuhh2hhRhh2uUsubstitution_namesrz}r{h%h0h'}r|(h+]h)]h*]Usourceh#h,]h-]uU footnotesr}]r~Urefidsr}r€h]rhasub.hello_world_server.doctree000066400000000000000000000442161240331347200342040ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/http€cdocutils.nodes document q)q}q(U nametypesq}q(Xthe codeqNXbuilding and running the serverqNX"hello world" http serverqNXhello_world_http_serverq ˆXdiving into the codeq NuUsubstitution_defsq }q Uparse_messagesq ]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUthe-codeqhUbuilding-and-running-the-serverqhUid1qh Uhello-world-http-serverqh Udiving-into-the-codequUchildrenq]q(cdocutils.nodes target q)q}q(U rawsourceqX.. _hello_world_http_server:UparentqhUsourceq cdocutils.nodes reprunicode q!XV/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/hello_world_server.rstq"…q#}q$bUtagnameq%Utargetq&U attributesq'}q((Uidsq)]Ubackrefsq*]Udupnamesq+]Uclassesq,]Unamesq-]Urefidq.huUlineq/KUdocumentq0hh]ubcdocutils.nodes section q1)q2}q3(hUhhh h#Uexpect_referenced_by_nameq4}q5h hsh%Usectionq6h'}q7(h+]h,]h*]h)]q8(hheh-]q9(hh euh/Kh0hUexpect_referenced_by_idq:}q;hhsh]q<(cdocutils.nodes title q=)q>}q?(hX"Hello world" HTTP serverq@hh2h h#h%UtitleqAh'}qB(h+]h,]h*]h)]h-]uh/Kh0hh]qCcdocutils.nodes Text qDX"Hello world" HTTP serverqE…qF}qG(hh@hh>ubaubcdocutils.nodes paragraph qH)qI}qJ(hXþNow that we've seen how we can deal with request and response objects from the client side, we'll see how we can then use the same abstractions on the server side. In this example we're going to create a simple HTTP Server in C++ using :mod:`cpp-netlib`.hh2h h#h%U paragraphqKh'}qL(h+]h,]h*]h)]h-]uh/Kh0hh]qM(hDXìNow that we've seen how we can deal with request and response objects from the client side, we'll see how we can then use the same abstractions on the server side. In this example we're going to create a simple HTTP Server in C++ using qN…qO}qP(hXìNow that we've seen how we can deal with request and response objects from the client side, we'll see how we can then use the same abstractions on the server side. In this example we're going to create a simple HTTP Server in C++ using hhIubcsphinx.addnodes pending_xref qQ)qR}qS(hX:mod:`cpp-netlib`qThhIh h#h%U pending_xrefqUh'}qV(UreftypeXmodUrefwarnqW‰U reftargetqXX cpp-netlibU refdomainXpyqYh)]h*]U refexplicit‰h+]h,]h-]UrefdocqZX examples/http/hello_world_serverq[Upy:classq\NU py:moduleq]Nuh/Kh]q^cdocutils.nodes literal q_)q`}qa(hhTh'}qb(h+]h,]qc(UxrefqdhYXpy-modqeeh*]h)]h-]uhhRh]qfhDX cpp-netlibqg…qh}qi(hUhh`ubah%UliteralqjubaubhDX.…qk}ql(hX.hhIubeubh1)qm}qn(hUhh2h h#h%h6h'}qo(h+]h,]h*]h)]qphah-]qqhauh/K h0hh]qr(h=)qs}qt(hXThe codequhhmh h#h%hAh'}qv(h+]h,]h*]h)]h-]uh/K h0hh]qwhDXThe codeqx…qy}qz(hhuhhsubaubhH)q{}q|(hX«The :mod:`cpp-netlib` provides the framework to develop embedded HTTP servers. For this example, the server is configured to return a simple response to any HTTP request.hhmh h#h%hKh'}q}(h+]h,]h*]h)]h-]uh/Kh0hh]q~(hDXThe q…q€}q(hXThe hh{ubhQ)q‚}qƒ(hX:mod:`cpp-netlib`q„hh{h h#h%hUh'}q…(UreftypeXmodhW‰hXX cpp-netlibU refdomainXpyq†h)]h*]U refexplicit‰h+]h,]h-]hZh[h\Nh]Nuh/Kh]q‡h_)qˆ}q‰(hh„h'}qŠ(h+]h,]q‹(hdh†Xpy-modqŒeh*]h)]h-]uhh‚h]qhDX cpp-netlibqŽ…q}q(hUhhˆubah%hjubaubhDX– provides the framework to develop embedded HTTP servers. For this example, the server is configured to return a simple response to any HTTP request.q‘…q’}q“(hX– provides the framework to develop embedded HTTP servers. For this example, the server is configured to return a simple response to any HTTP request.hh{ubeubcdocutils.nodes literal_block q”)q•}q–(hXr#include #include #include namespace http = boost::network::http; struct hello_world; typedef http::server server; struct hello_world { void operator() (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } }; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { hello_world handler; server server_(argv[1], argv[2], handler); server_.run(); } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; }hhmh h#h%U literal_blockq—h'}q˜(Ulinenosq™‰UlanguageqšXc++U xml:spaceq›Upreserveqœh)]h*]h+]h,]h-]uh/Kh0hh]qhDXr#include #include #include namespace http = boost::network::http; struct hello_world; typedef http::server server; struct hello_world { void operator() (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } }; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { hello_world handler; server server_(argv[1], argv[2], handler); server_.run(); } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; }qž…qŸ}q (hUhh•ubaubhH)q¡}q¢(hXFThis is about a straightforward as server programming will get in C++.q£hhmh h#h%hKh'}q¤(h+]h,]h*]h)]h-]uh/KLet's take a look at the code listing above in greater detail.qühhìh h#h%hKh'}qý(h+]h,]h*]h)]h-]uh/KXh0hh]qþhDX>Let's take a look at the code listing above in greater detail.qÿ…r}r(hhühhúubaubh”)r}r(hX1#include hhìh h#h%h—h'}r(h™‰hšXc++h›hœh)]h*]h+]h,]h-]uh/KZh0hh]rhDX1#include r…r}r(hUhjubaubhH)r }r (hXZThis header contains all the code needed to develop an HTTP server with :mod:`cpp-netlib`.hhìh h#h%hKh'}r (h+]h,]h*]h)]h-]uh/K^h0hh]r (hDXHThis header contains all the code needed to develop an HTTP server with r …r}r(hXHThis header contains all the code needed to develop an HTTP server with hj ubhQ)r}r(hX:mod:`cpp-netlib`rhj h h#h%hUh'}r(UreftypeXmodhW‰hXX cpp-netlibU refdomainXpyrh)]h*]U refexplicit‰h+]h,]h-]hZh[h\Nh]Nuh/K^h]rh_)r}r(hjh'}r(h+]h,]r(hdjXpy-modreh*]h)]h-]uhjh]rhDX cpp-netlibr…r}r(hUhjubah%hjubaubhDX.…r}r (hX.hj ubeubh”)r!}r"(hXhstruct hello_world; typedef http::server server; struct hello_world { void operator () (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } };hhìh h#h%h—h'}r#(h™‰hšXc++h›hœh)]h*]h+]h,]h-]uh/Kah0hh]r$hDXhstruct hello_world; typedef http::server server; struct hello_world { void operator () (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } };r%…r&}r'(hUhj!ubaubhH)r(}r)(hX``hello_world`` is a functor class which handles HTTP requests. All the operator does here is return an HTTP response with HTTP code 200 and the body ``"Hello, !"``. The ```` in this case would be the IP address of the client that made the request.hhìh h#h%hKh'}r*(h+]h,]h*]h)]h-]uh/Koh0hh]r+(h_)r,}r-(hX``hello_world``h'}r.(h+]h,]h*]h)]h-]uhj(h]r/hDX hello_worldr0…r1}r2(hUhj,ubah%hjubhDXˆ is a functor class which handles HTTP requests. All the operator does here is return an HTTP response with HTTP code 200 and the body r3…r4}r5(hXˆ is a functor class which handles HTTP requests. All the operator does here is return an HTTP response with HTTP code 200 and the body hj(ubh_)r6}r7(hX``"Hello, !"``h'}r8(h+]h,]h*]h)]h-]uhj(h]r9hDX"Hello, !"r:…r;}r<(hUhj6ubah%hjubhDX. The r=…r>}r?(hX. The hj(ubh_)r@}rA(hX````h'}rB(h+]h,]h*]h)]h-]uhj(h]rChDXrD…rE}rF(hUhj@ubah%hjubhDXJ in this case would be the IP address of the client that made the request.rG…rH}rI(hXJ in this case would be the IP address of the client that made the request.hj(ubeubhH)rJ}rK(hXgThere are a number of pre-defined stock replies differentiated by status code with configurable bodies.rLhhìh h#h%hKh'}rM(h+]h,]h*]h)]h-]uh/Kth0hh]rNhDXgThere are a number of pre-defined stock replies differentiated by status code with configurable bodies.rO…rP}rQ(hjLhjJubaubhH)rR}rS(hX…All the supported enumeration values for the response status codes can be found in ``boost/network/protocol/http/impl/response.ipp``.hhìh h#h%hKh'}rT(h+]h,]h*]h)]h-]uh/Kwh0hh]rU(hDXSAll the supported enumeration values for the response status codes can be found in rV…rW}rX(hXSAll the supported enumeration values for the response status codes can be found in hjRubh_)rY}rZ(hX1``boost/network/protocol/http/impl/response.ipp``h'}r[(h+]h,]h*]h)]h-]uhjRh]r\hDX-boost/network/protocol/http/impl/response.ippr]…r^}r_(hUhjYubah%hjubhDX.…r`}ra(hX.hjRubeubh”)rb}rc(hXNhello_world handler; server server_(argv[1], argv[2], handler); server_.run();hhìh h#h%h—h'}rd(h™‰hšXc++h›hœh)]h*]h+]h,]h-]uh/Kzh0hh]rehDXNhello_world handler; server server_(argv[1], argv[2], handler); server_.run();rf…rg}rh(hUhjbubaubhH)ri}rj(hX²The first two arguments to the ``server`` constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously.hhìh h#h%hKh'}rk(h+]h,]h*]h)]h-]uh/K€h0hh]rl(hDXThe first two arguments to the rm…rn}ro(hXThe first two arguments to the hjiubh_)rp}rq(hX ``server``h'}rr(h+]h,]h*]h)]h-]uhjih]rshDXserverrt…ru}rv(hUhjpubah%hjubhDX‰ constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously.rw…rx}ry(hX‰ constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously.hjiubeubhÞ)rz}r{(hXØIn this example, the server is specifically made to be single-threaded. In a multi-threaded server, you would invoke the ``hello_world::run`` member method in a set of threads. In a multi-threaded environment you would also make sure that the handler does all the necessary synchronization for shared resources across threads. The handler is passed by reference to the server constructor and you should ensure that any calls to the ``operator()`` overload are thread-safe.hhìh h#h%háh'}r|(h+]h,]h*]h)]h-]uh/Nh0hh]r}hH)r~}r(hXØIn this example, the server is specifically made to be single-threaded. In a multi-threaded server, you would invoke the ``hello_world::run`` member method in a set of threads. In a multi-threaded environment you would also make sure that the handler does all the necessary synchronization for shared resources across threads. The handler is passed by reference to the server constructor and you should ensure that any calls to the ``operator()`` overload are thread-safe.hjzh h#h%hKh'}r€(h+]h,]h*]h)]h-]uh/K„h]r(hDXyIn this example, the server is specifically made to be single-threaded. In a multi-threaded server, you would invoke the r‚…rƒ}r„(hXyIn this example, the server is specifically made to be single-threaded. In a multi-threaded server, you would invoke the hj~ubh_)r…}r†(hX``hello_world::run``h'}r‡(h+]h,]h*]h)]h-]uhj~h]rˆhDXhello_world::runr‰…rŠ}r‹(hUhj…ubah%hjubhDX# member method in a set of threads. In a multi-threaded environment you would also make sure that the handler does all the necessary synchronization for shared resources across threads. The handler is passed by reference to the server constructor and you should ensure that any calls to the rŒ…r}rŽ(hX# member method in a set of threads. In a multi-threaded environment you would also make sure that the handler does all the necessary synchronization for shared resources across threads. The handler is passed by reference to the server constructor and you should ensure that any calls to the hj~ubh_)r}r(hX``operator()``h'}r‘(h+]h,]h*]h)]h-]uhj~h]r’hDX operator()r“…r”}r•(hUhjubah%hjubhDX overload are thread-safe.r–…r—}r˜(hX overload are thread-safe.hj~ubeubaubeubeubehUU transformerr™NU footnote_refsrš}r›Urefnamesrœ}rUsymbol_footnotesrž]rŸUautofootnote_refsr ]r¡Usymbol_footnote_refsr¢]r£U citationsr¤]r¥h0hU current_liner¦NUtransform_messagesr§]r¨cdocutils.nodes system_message r©)rª}r«(hUh'}r¬(h+]UlevelKh)]h*]Usourceh#h,]h-]UlineKUtypeUINFOr­uh]r®hH)r¯}r°(hUh'}r±(h+]h,]h*]h)]h-]uhjªh]r²hDX=Hyperlink target "hello-world-http-server" is not referenced.r³…r´}rµ(hUhj¯ubah%hKubah%Usystem_messager¶ubaUreporterr·NUid_startr¸KU autofootnotesr¹]rºU citation_refsr»}r¼Uindirect_targetsr½]r¾Usettingsr¿(cdocutils.frontend Values rÀorÁ}rÂ(Ufootnote_backlinksrÃKUrecord_dependenciesrÄNU rfc_base_urlrÅUhttp://tools.ietf.org/html/rÆU tracebackrLjUpep_referencesrÈNUstrip_commentsrÉNU toc_backlinksrÊUentryrËU language_coderÌUenrÍU datestamprÎNU report_levelrÏKU _destinationrÐNU halt_levelrÑKU strip_classesrÒNhANUerror_encoding_error_handlerrÓUbackslashreplacerÔUdebugrÕNUembed_stylesheetrÖ‰Uoutput_encoding_error_handlerr×UstrictrØU sectnum_xformrÙKUdump_transformsrÚNU docinfo_xformrÛKUwarning_streamrÜNUpep_file_url_templaterÝUpep-%04drÞUexit_status_levelrßKUconfigràNUstrict_visitorráNUcloak_email_addressesrâˆUtrim_footnote_reference_spacerã‰UenvräNUdump_pseudo_xmlråNUexpose_internalsræNUsectsubtitle_xformrç‰U source_linkrèNUrfc_referencesréNUoutput_encodingrêUutf-8rëU source_urlrìNUinput_encodingríUutf-8rîU_disable_configrïNU id_prefixrðUU tab_widthrñKUerror_encodingròUUS-ASCIIróU_sourcerôUV/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/hello_world_server.rstrõUgettext_compactröˆU generatorr÷NUdump_internalsrøNU smart_quotesrù‰U pep_base_urlrúUhttp://www.python.org/dev/peps/rûUsyntax_highlightrüUlongrýUinput_encoding_error_handlerrþjØUauto_id_prefixrÿUidrUdoctitle_xformr‰Ustrip_elements_with_classesrNU _config_filesr]Ufile_insertion_enabledrˆU raw_enabledrKU dump_settingsrNubUsymbol_footnote_startrKUidsr}r (hhìhh©hh2hhmhh2uUsubstitution_namesr }r h%h0h'}r (h+]h)]h*]Usourceh#h,]h-]uU footnotesr ]rUrefidsr}rh]rhasub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/http/http_client.doctree000066400000000000000000000437041240331347200327010ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xrunning the exampleqNXrfc 2616qˆXthe codeqNXcmake conventionsq ˆXdiving into the codeq NX http_clientq ˆXboostq ˆX http clientq NuUsubstitution_defsq}qUparse_messagesq]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUrunning-the-exampleqhUrfc-2616qhUthe-codeqh Ucmake-conventionsqh Udiving-into-the-codeqh U http-clientqh Uboostqh Uid1quUchildrenq]q (cdocutils.nodes target q!)q"}q#(U rawsourceq$X.. _http_client:Uparentq%hUsourceq&cdocutils.nodes reprunicode q'XO/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/http_client.rstq(…q)}q*bUtagnameq+Utargetq,U attributesq-}q.(Uidsq/]Ubackrefsq0]Udupnamesq1]Uclassesq2]Unamesq3]Urefidq4huUlineq5KUdocumentq6hh]ubcdocutils.nodes section q7)q8}q9(h$Uh%hh&h)Uexpect_referenced_by_nameq:}q;h h"sh+Usectionq(hheh3]q?(h h euh5Kh6hUexpect_referenced_by_idq@}qAhh"sh]qB(cdocutils.nodes title qC)qD}qE(h$X HTTP clientqFh%h8h&h)h+UtitleqGh-}qH(h1]h2]h0]h/]h3]uh5Kh6hh]qIcdocutils.nodes Text qJX HTTP clientqK…qL}qM(h$hFh%hDubaubcdocutils.nodes paragraph qN)qO}qP(h$X9The first code example is the simplest thing you can do with the :mod:`cpp-netlib`. The application is a simple HTTP client, which can be found in the subdirectory ``libs/network/example/http_client.cpp``. All this example doing is creating and sending an HTTP request to a server and printing the response body.h%h8h&h)h+U paragraphqQh-}qR(h1]h2]h0]h/]h3]uh5Kh6hh]qS(hJXAThe first code example is the simplest thing you can do with the qT…qU}qV(h$XAThe first code example is the simplest thing you can do with the h%hOubcsphinx.addnodes pending_xref qW)qX}qY(h$X:mod:`cpp-netlib`qZh%hOh&h)h+U pending_xrefq[h-}q\(UreftypeXmodUrefwarnq]‰U reftargetq^X cpp-netlibU refdomainXpyq_h/]h0]U refexplicit‰h1]h2]h3]Urefdocq`Xexamples/http/http_clientqaUpy:classqbNU py:moduleqcNuh5Kh]qdcdocutils.nodes literal qe)qf}qg(h$hZh-}qh(h1]h2]qi(Uxrefqjh_Xpy-modqkeh0]h/]h3]uh%hXh]qlhJX cpp-netlibqm…qn}qo(h$Uh%hfubah+UliteralqpubaubhJXS. The application is a simple HTTP client, which can be found in the subdirectory qq…qr}qs(h$XS. The application is a simple HTTP client, which can be found in the subdirectory h%hOubhe)qt}qu(h$X(``libs/network/example/http_client.cpp``h-}qv(h1]h2]h0]h/]h3]uh%hOh]qwhJX$libs/network/example/http_client.cppqx…qy}qz(h$Uh%htubah+hpubhJXl. All this example doing is creating and sending an HTTP request to a server and printing the response body.q{…q|}q}(h$Xl. All this example doing is creating and sending an HTTP request to a server and printing the response body.h%hOubeubh7)q~}q(h$Uh%h8h&h)h+h #include int main(int argc, char *argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " [url]" << std::endl; return 1; } http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); std::cout << body(response) << std::endl; return 0; }h%h~h&h)h+U literal_blockq—h-}q˜(Ulinenosq™‰UlanguageqšXc++U xml:spaceq›Upreserveqœh/]h0]h1]h2]h3]uh5Kh6hh]qhJXí#include #include int main(int argc, char *argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " [url]" << std::endl; return 1; } http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); std::cout << body(response) << std::endl; return 0; }qž…qŸ}q (h$Uh%h•ubaubeubh7)q¡}q¢(h$Uh%h8h&h)h+hh6hh]r(hC)r}r(h$XDiving into the coderh%j h&h)h+hGh-}r(h1]h2]h0]h/]h3]uh5K>h6hh]rhJXDiving into the coder…r}r(h$jh%jubaubhN)r}r(h$XUSince this is the first example, each line will be presented and explained in detail.rh%j h&h)h+hQh-}r(h1]h2]h0]h/]h3]uh5K@h6hh]rhJXUSince this is the first example, each line will be presented and explained in detail.r…r }r!(h$jh%jubaubh”)r"}r#(h$X1#include h%j h&h)h+h—h-}r$(h™‰hšXc++h›hœh/]h0]h1]h2]h3]uh5KCh6hh]r%hJX1#include r&…r'}r((h$Uh%j"ubaubhN)r)}r*(h$X?All the code needed for the HTTP client resides in this header.r+h%j h&h)h+hQh-}r,(h1]h2]h0]h/]h3]uh5KGh6hh]r-hJX?All the code needed for the HTTP client resides in this header.r.…r/}r0(h$j+h%j)ubaubh”)r1}r2(h$Xhttp::client client;h%j h&h)h+h—h-}r3(h™‰hšXc++h›hœh/]h0]h1]h2]h3]uh5KIh6hh]r4hJXhttp::client client;r5…r6}r7(h$Uh%j1ubaubhN)r8}r9(h$X«First we create a ``client`` object. The ``client`` abstracts all the connection and protocol logic. The default HTTP client is version 1.1, as specified in `RFC 2616`_.h%j h&h)h+hQh-}r:(h1]h2]h0]h/]h3]uh5KMh6hh]r;(hJXFirst we create a r<…r=}r>(h$XFirst we create a h%j8ubhe)r?}r@(h$X ``client``h-}rA(h1]h2]h0]h/]h3]uh%j8h]rBhJXclientrC…rD}rE(h$Uh%j?ubah+hpubhJX object. The rF…rG}rH(h$X object. The h%j8ubhe)rI}rJ(h$X ``client``h-}rK(h1]h2]h0]h/]h3]uh%j8h]rLhJXclientrM…rN}rO(h$Uh%jIubah+hpubhJXk abstracts all the connection and protocol logic. The default HTTP client is version 1.1, as specified in rP…rQ}rR(h$Xk abstracts all the connection and protocol logic. The default HTTP client is version 1.1, as specified in h%j8ubh·)rS}rT(h$X `RFC 2616`_hºKh%j8h+h»h-}rU(UnameXRFC 2616h½X0http://www.w3.org/Protocols/rfc2616/rfc2616.htmlrVh/]h0]h1]h2]h3]uh]rWhJXRFC 2616rX…rY}rZ(h$Uh%jSubaubhJX.…r[}r\(h$X.h%j8ubeubh”)r]}r^(h$X'http::client::request request(argv[1]);h%j h&h)h+h—h-}r_(h™‰hšXc++h›hœh/]h0]h1]h2]h3]uh5KQh6hh]r`hJX'http::client::request request(argv[1]);ra…rb}rc(h$Uh%j]ubaubhN)rd}re(h$XYNext, we create a ``request`` object, with a URI string passed as a constructor argument.h%j h&h)h+hQh-}rf(h1]h2]h0]h/]h3]uh5KUh6hh]rg(hJXNext, we create a rh…ri}rj(h$XNext, we create a h%jdubhe)rk}rl(h$X ``request``h-}rm(h1]h2]h0]h/]h3]uh%jdh]rnhJXrequestro…rp}rq(h$Uh%jkubah+hpubhJX< object, with a URI string passed as a constructor argument.rr…rs}rt(h$X< object, with a URI string passed as a constructor argument.h%jdubeubh”)ru}rv(h$X)request << header("Connection", "close");h%j h&h)h+h—h-}rw(h™‰hšXc++h›hœh/]h0]h1]h2]h3]uh5KXh6hh]rxhJX)request << header("Connection", "close");ry…rz}r{(h$Uh%juubaubhN)r|}r}(h$X3:mod:`cpp-netlib` makes use of stream syntax and *directives* to allow developers to build complex message structures with greater flexibility and clarity. Here, we add the HTTP header "Connection: close" to the request in order to signal that the connection will be closed after the request has completed.h%j h&h)h+hQh-}r~(h1]h2]h0]h/]h3]uh5K\h6hh]r(hW)r€}r(h$X:mod:`cpp-netlib`r‚h%j|h&h)h+h[h-}rƒ(UreftypeXmodh]‰h^X cpp-netlibU refdomainXpyr„h/]h0]U refexplicit‰h1]h2]h3]h`hahbNhcNuh5K\h]r…he)r†}r‡(h$j‚h-}rˆ(h1]h2]r‰(hjj„Xpy-modrŠeh0]h/]h3]uh%j€h]r‹hJX cpp-netlibrŒ…r}rŽ(h$Uh%j†ubah+hpubaubhJX makes use of stream syntax and r…r}r‘(h$X makes use of stream syntax and h%j|ubcdocutils.nodes emphasis r’)r“}r”(h$X *directives*h-}r•(h1]h2]h0]h/]h3]uh%j|h]r–hJX directivesr—…r˜}r™(h$Uh%j“ubah+UemphasisršubhJXö to allow developers to build complex message structures with greater flexibility and clarity. Here, we add the HTTP header "Connection: close" to the request in order to signal that the connection will be closed after the request has completed.r›…rœ}r(h$Xö to allow developers to build complex message structures with greater flexibility and clarity. Here, we add the HTTP header "Connection: close" to the request in order to signal that the connection will be closed after the request has completed.h%j|ubeubh”)rž}rŸ(h$X6http::client::response response = client.get(request);h%j h&h)h+h—h-}r (h™‰hšXc++h›hœh/]h0]h1]h2]h3]uh5Kbh6hh]r¡hJX6http::client::response response = client.get(request);r¢…r£}r¤(h$Uh%jžubaubhN)r¥}r¦(h$X×Once we've built the request, we then make an HTTP GET request throught the ``http::client`` from which an ``http::response`` is returned. ``http::client`` supports all common HTTP methods: GET, POST, HEAD, DELETE.h%j h&h)h+hQh-}r§(h1]h2]h0]h/]h3]uh5Kfh6hh]r¨(hJXLOnce we've built the request, we then make an HTTP GET request throught the r©…rª}r«(h$XLOnce we've built the request, we then make an HTTP GET request throught the h%j¥ubhe)r¬}r­(h$X``http::client``h-}r®(h1]h2]h0]h/]h3]uh%j¥h]r¯hJX http::clientr°…r±}r²(h$Uh%j¬ubah+hpubhJX from which an r³…r´}rµ(h$X from which an h%j¥ubhe)r¶}r·(h$X``http::response``h-}r¸(h1]h2]h0]h/]h3]uh%j¥h]r¹hJXhttp::responserº…r»}r¼(h$Uh%j¶ubah+hpubhJX is returned. r½…r¾}r¿(h$X is returned. h%j¥ubhe)rÀ}rÁ(h$X``http::client``h-}rÂ(h1]h2]h0]h/]h3]uh%j¥h]rÃhJX http::clientrÄ…rÅ}rÆ(h$Uh%jÀubah+hpubhJX; supports all common HTTP methods: GET, POST, HEAD, DELETE.rÇ…rÈ}rÉ(h$X; supports all common HTTP methods: GET, POST, HEAD, DELETE.h%j¥ubeubh”)rÊ}rË(h$X)std::cout << body(response) << std::endl;h%j h&h)h+h—h-}rÌ(h™‰hšXc++h›hœh/]h0]h1]h2]h3]uh5Kkh6hh]rÍhJX)std::cout << body(response) << std::endl;rÎ…rÏ}rÐ(h$Uh%jÊubaubhN)rÑ}rÒ(h$XyFinally, though we don't do any error checking, the response body is printed to the console using the ``body`` directive.h%j h&h)h+hQh-}rÓ(h1]h2]h0]h/]h3]uh5Koh6hh]rÔ(hJXfFinally, though we don't do any error checking, the response body is printed to the console using the rÕ…rÖ}r×(h$XfFinally, though we don't do any error checking, the response body is printed to the console using the h%jÑubhe)rØ}rÙ(h$X``body``h-}rÚ(h1]h2]h0]h/]h3]uh%jÑh]rÛhJXbodyrÜ…rÝ}rÞ(h$Uh%jØubah+hpubhJX directive.rß…rà}rá(h$X directive.h%jÑubeubhN)râ}rã(h$XbThat's all there is to the HTTP client. In fact, it's possible to compress this to a single line:räh%j h&h)h+hQh-}rå(h1]h2]h0]h/]h3]uh5Krh6hh]ræhJXbThat's all there is to the HTTP client. In fact, it's possible to compress this to a single line:rç…rè}ré(h$jäh%jâubaubh”)rê}rë(h$XNstd::cout << body(http::client().get(http::request("http://www.boost.org/")));h%j h&h)h+h—h-}rì(h™‰hšXc++h›hœh/]h0]h1]h2]h3]uh5Kuh6hh]ríhJXNstd::cout << body(http::client().get(http::request("http://www.boost.org/")));rî…rï}rð(h$Uh%jêubaubhN)rñ}rò(h$X2The next example will introduce the ``uri`` class.róh%j h&h)h+hQh-}rô(h1]h2]h0]h/]h3]uh5Kyh6hh]rõ(hJX$The next example will introduce the rö…r÷}rø(h$X$The next example will introduce the h%jñubhe)rù}rú(h$X``uri``h-}rû(h1]h2]h0]h/]h3]uh%jñh]rühJXurirý…rþ}rÿ(h$Uh%jùubah+hpubhJX class.r…r}r(h$X class.h%jñubeubh!)r}r(h$X@.. _`RFC 2616`: http://www.w3.org/Protocols/rfc2616/rfc2616.htmlhÏKh%j h&h)h+h,h-}r(h½jVh/]rhah0]h1]h2]h3]rhauh5K{h6hh]ubeubeubeh$UU transformerrNU footnote_refsr }r Urefnamesr }r (Xcmake conventions]r hòaXrfc 2616]rjSaXboost]rh¸auUsymbol_footnotesr]rUautofootnote_refsr]rUsymbol_footnote_refsr]rU citationsr]rh6hU current_linerNUtransform_messagesr]rcdocutils.nodes system_message r)r}r(h$Uh-}r(h1]UlevelKh/]h0]Usourceh)h2]h3]UlineKUtypeUINFOruh]r hN)r!}r"(h$Uh-}r#(h1]h2]h0]h/]h3]uh%jh]r$hJX1Hyperlink target "http-client" is not referenced.r%…r&}r'(h$Uh%j!ubah+hQubah+Usystem_messager(ubaUreporterr)NUid_startr*KU autofootnotesr+]r,U citation_refsr-}r.Uindirect_targetsr/]r0Usettingsr1(cdocutils.frontend Values r2or3}r4(Ufootnote_backlinksr5KUrecord_dependenciesr6NU rfc_base_urlr7Uhttp://tools.ietf.org/html/r8U tracebackr9ˆUpep_referencesr:NUstrip_commentsr;NU toc_backlinksr<Uentryr=U language_coder>Uenr?U datestampr@NU report_levelrAKU _destinationrBNU halt_levelrCKU strip_classesrDNhGNUerror_encoding_error_handlerrEUbackslashreplacerFUdebugrGNUembed_stylesheetrH‰Uoutput_encoding_error_handlerrIUstrictrJU sectnum_xformrKKUdump_transformsrLNU docinfo_xformrMKUwarning_streamrNNUpep_file_url_templaterOUpep-%04drPUexit_status_levelrQKUconfigrRNUstrict_visitorrSNUcloak_email_addressesrTˆUtrim_footnote_reference_spacerU‰UenvrVNUdump_pseudo_xmlrWNUexpose_internalsrXNUsectsubtitle_xformrY‰U source_linkrZNUrfc_referencesr[NUoutput_encodingr\Uutf-8r]U source_urlr^NUinput_encodingr_Uutf-8r`U_disable_configraNU id_prefixrbUU tab_widthrcKUerror_encodingrdUUS-ASCIIreU_sourcerfUO/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/http_client.rstrgUgettext_compactrhˆU generatorriNUdump_internalsrjNU smart_quotesrk‰U pep_base_urlrlUhttp://www.python.org/dev/peps/rmUsyntax_highlightrnUlongroUinput_encoding_error_handlerrpjJUauto_id_prefixrqUidrrUdoctitle_xformrs‰Ustrip_elements_with_classesrtNU _config_filesru]Ufile_insertion_enabledrvˆU raw_enabledrwKU dump_settingsrxNubUsymbol_footnote_startryKUidsrz}r{(hh8hh¡hjhjhj hh8hhÍhh~uUsubstitution_namesr|}r}h+h6h-}r~(h1]h/]h0]Usourceh)h2]h3]uU footnotesr]r€Urefidsr}r‚h]rƒh"asub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/http/simple_wget.doctree000066400000000000000000000351661240331347200327060ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xrunning the exampleqNX simple wgetqNXthe codeqNXdiving into the codeq NX simple_wgetq ˆXboostq ˆXrfc 3986q ˆuUsubstitution_defsq }qUparse_messagesq]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUrunning-the-exampleqhUid1qhUthe-codeqh Udiving-into-the-codeqh U simple-wgetqh Uboostqh Urfc-3986quUchildrenq]q(cdocutils.nodes target q)q }q!(U rawsourceq"X.. _simple_wget:Uparentq#hUsourceq$cdocutils.nodes reprunicode q%XO/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/simple_wget.rstq&…q'}q(bUtagnameq)Utargetq*U attributesq+}q,(Uidsq-]Ubackrefsq.]Udupnamesq/]Uclassesq0]Unamesq1]Urefidq2huUlineq3KUdocumentq4hh]ubcdocutils.nodes section q5)q6}q7(h"Uh#hh$h'Uexpect_referenced_by_nameq8}q9h h sh)Usectionq:h+}q;(h/]h0]h.]h-]q<(hheh1]q=(hh euh3Kh4hUexpect_referenced_by_idq>}q?hh sh]q@(cdocutils.nodes title qA)qB}qC(h"X Simple `wget`qDh#h6h$h'h)UtitleqEh+}qF(h/]h0]h.]h-]h1]uh3Kh4hh]qG(cdocutils.nodes Text qHXSimple qI…qJ}qK(h"XSimple qLh#hBubcdocutils.nodes title_reference qM)qN}qO(h"X`wget`qPh+}qQ(h/]h0]h.]h-]h1]uh#hBh]qRhHXwgetqS…qT}qU(h"Uh#hNubah)Utitle_referenceqVubeubcdocutils.nodes paragraph qW)qX}qY(h"X•This example is a very simple implementation of a ``wget`` style clone. It's very similar to the previous example, but introduces the ``uri`` class.h#h6h$h'h)U paragraphqZh+}q[(h/]h0]h.]h-]h1]uh3Kh4hh]q\(hHX2This example is a very simple implementation of a q]…q^}q_(h"X2This example is a very simple implementation of a h#hXubcdocutils.nodes literal q`)qa}qb(h"X``wget``h+}qc(h/]h0]h.]h-]h1]uh#hXh]qdhHXwgetqe…qf}qg(h"Uh#haubah)UliteralqhubhHXM style clone. It's very similar to the previous example, but introduces the qi…qj}qk(h"XM style clone. It's very similar to the previous example, but introduces the h#hXubh`)ql}qm(h"X``uri``h+}qn(h/]h0]h.]h-]h1]uh#hXh]qohHXuriqp…qq}qr(h"Uh#hlubah)hhubhHX class.qs…qt}qu(h"X class.h#hXubeubh5)qv}qw(h"Uh#h6h$h'h)h:h+}qx(h/]h0]h.]h-]qyhah1]qzhauh3K h4hh]q{(hA)q|}q}(h"XThe codeq~h#hvh$h'h)hEh+}q(h/]h0]h.]h-]h1]uh3K h4hh]q€hHXThe codeq…q‚}qƒ(h"h~h#h|ubaubcdocutils.nodes literal_block q„)q…}q†(h"Xx#include #include #include #include #include namespace http = boost::network::http; namespace uri = boost::network::uri; namespace { std::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; } } // namespace int main(int argc, char *argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " url" << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); http::client::response response = client.get(request); std::string filename = get_filename(request.uri()); std::cout << "Saving to: " << filename << std::endl; std::ofstream ofs(filename.c_str()); ofs << static_cast(body(response)) << std::endl; } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; }h#hvh$h'h)U literal_blockq‡h+}qˆ(Ulinenosq‰‰UlanguageqŠXc++U xml:spaceq‹UpreserveqŒh-]h.]h/]h0]h1]uh3Kh4hh]qhHXx#include #include #include #include #include namespace http = boost::network::http; namespace uri = boost::network::uri; namespace { std::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; } } // namespace int main(int argc, char *argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " url" << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); http::client::response response = client.get(request); std::string filename = get_filename(request.uri()); std::cout << "Saving to: " << filename << std::endl; std::ofstream ofs(filename.c_str()); ofs << static_cast(body(response)) << std::endl; } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; }qŽ…q}q(h"Uh#h…ubaubeubh5)q‘}q’(h"Uh#h6h$h'h)h:h+}q“(h/]h0]h.]h-]q”hah1]q•hauh3Kh4hh]q£(hHX"You can then run this to copy the q¤…q¥}q¦(h"X"You can then run this to copy the h#hŸubcdocutils.nodes reference q§)q¨}q©(h"XBoost_UresolvedqªKh#hŸh)U referenceq«h+}q¬(UnameXBoostUrefuriq­Xhttp://www.boost.org/q®h-]h.]h/]h0]h1]uh]q¯hHXBoostq°…q±}q²(h"Uh#h¨ubaubhHX website:q³…q´}qµ(h"X website:h#hŸubeubh„)q¶}q·(h"Xi$ cd ~/cpp-netlib-build $ make simple_wget $ ./example/simple_wget http://www.boost.org/ $ cat index.htmlh#h‘h$h'h)h‡h+}q¸(h‰‰hŠXbashh‹hŒh-]h.]h/]h0]h1]uh3K@h4hh]q¹hHXi$ cd ~/cpp-netlib-build $ make simple_wget $ ./example/simple_wget http://www.boost.org/ $ cat index.htmlqº…q»}q¼(h"Uh#h¶ubaubh)q½}q¾(h"X .. _Boost: http://www.boost.org/U referencedq¿Kh#h‘h$h'h)h*h+}qÀ(h­h®h-]qÁhah.]h/]h0]h1]qÂh auh3KGh4hh]ubeubh5)qÃ}qÄ(h"Uh#h6h$h'h)h:h+}qÅ(h/]h0]h.]h-]qÆhah1]qÇh auh3KJh4hh]qÈ(hA)qÉ}qÊ(h"XDiving into the codeqËh#hÃh$h'h)hEh+}qÌ(h/]h0]h.]h-]h1]uh3KJh4hh]qÍhHXDiving into the codeqÎ…qÏ}qÐ(h"hËh#hÉubaubhW)qÑ}qÒ(h"XÉAs with ``wget``, this example simply makes an HTTP request to the specified resource, and saves it on the filesystem. If the file name is not specified, it names the resultant file as ``index.html``.h#hÃh$h'h)hZh+}qÓ(h/]h0]h.]h-]h1]uh3KLh4hh]qÔ(hHXAs with qÕ…qÖ}q×(h"XAs with h#hÑubh`)qØ}qÙ(h"X``wget``h+}qÚ(h/]h0]h.]h-]h1]uh#hÑh]qÛhHXwgetqÜ…qÝ}qÞ(h"Uh#hØubah)hhubhHXª, this example simply makes an HTTP request to the specified resource, and saves it on the filesystem. If the file name is not specified, it names the resultant file as qß…qà}qá(h"Xª, this example simply makes an HTTP request to the specified resource, and saves it on the filesystem. If the file name is not specified, it names the resultant file as h#hÑubh`)qâ}qã(h"X``index.html``h+}qä(h/]h0]h.]h-]h1]uh#hÑh]qåhHX index.htmlqæ…qç}qè(h"Uh#hâubah)hhubhHX.…qé}qê(h"X.h#hÑubeubhW)që}qì(h"XãThe new thing to note here is use of the ``uri`` class. The ``uri`` takes a string as a constructor argument and parses it. The ``uri`` parser is fully-compliant with `RFC 3986`_. The URI is provided in the following header:h#hÃh$h'h)hZh+}qí(h/]h0]h.]h-]h1]uh3KPh4hh]qî(hHX)The new thing to note here is use of the qï…qð}qñ(h"X)The new thing to note here is use of the h#hëubh`)qò}qó(h"X``uri``h+}qô(h/]h0]h.]h-]h1]uh#hëh]qõhHXuriqö…q÷}qø(h"Uh#hòubah)hhubhHX class. The qù…qú}qû(h"X class. The h#hëubh`)qü}qý(h"X``uri``h+}qþ(h/]h0]h.]h-]h1]uh#hëh]qÿhHXurir…r}r(h"Uh#hüubah)hhubhHX> takes a string as a constructor argument and parses it. The r…r}r(h"X> takes a string as a constructor argument and parses it. The h#hëubh`)r}r(h"X``uri``h+}r(h/]h0]h.]h-]h1]uh#hëh]r hHXurir …r }r (h"Uh#jubah)hhubhHX parser is fully-compliant with r …r}r(h"X parser is fully-compliant with h#hëubh§)r}r(h"X `RFC 3986`_hªKh#hëh)h«h+}r(UnameXRFC 3986h­X#http://www.ietf.org/rfc/rfc3986.txtrh-]h.]h/]h0]h1]uh]rhHXRFC 3986r…r}r(h"Uh#jubaubhHX/. The URI is provided in the following header:r…r}r(h"X/. The URI is provided in the following header:h#hëubeubh)r}r(h"X3.. _`RFC 3986`: http://www.ietf.org/rfc/rfc3986.txth¿Kh#hÃh$h'h)h*h+}r(h­jh-]rhah.]h/]h0]h1]rh auh3KUh4hh]ubh„)r }r!(h"X #include h#hÃh$h'h)h‡h+}r"(h‰‰hŠXc++h‹hŒh-]h.]h/]h0]h1]uh3KWh4hh]r#hHX #include r$…r%}r&(h"Uh#j ubaubhW)r'}r((h"X‘Most of the rest of the code is familiar from the previous example. To retrieve the URI resource's file name, the following function is provided:r)h#hÃh$h'h)hZh+}r*(h/]h0]h.]h-]h1]uh3K[h4hh]r+hHX‘Most of the rest of the code is familiar from the previous example. To retrieve the URI resource's file name, the following function is provided:r,…r-}r.(h"j)h#j'ubaubh„)r/}r0(h"Xñstd::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; }h#hÃh$h'h)h‡h+}r1(h‰‰hŠXc++h‹hŒh-]h.]h/]h0]h1]uh3K_h4hh]r2hHXñstd::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; }r3…r4}r5(h"Uh#j/ubaubhW)r6}r7(h"XÚThe ``uri`` interface provides access to its different components: ``scheme``, ``user_info``, ``host``, ``port``, ``path``, ``query`` and ``fragment``. The code above takes the URI path to determine the resource name.h#hÃh$h'h)hZh+}r8(h/]h0]h.]h-]h1]uh3Khh4hh]r9(hHXThe r:…r;}r<(h"XThe h#j6ubh`)r=}r>(h"X``uri``h+}r?(h/]h0]h.]h-]h1]uh#j6h]r@hHXurirA…rB}rC(h"Uh#j=ubah)hhubhHX8 interface provides access to its different components: rD…rE}rF(h"X8 interface provides access to its different components: h#j6ubh`)rG}rH(h"X ``scheme``h+}rI(h/]h0]h.]h-]h1]uh#j6h]rJhHXschemerK…rL}rM(h"Uh#jGubah)hhubhHX, rN…rO}rP(h"X, h#j6ubh`)rQ}rR(h"X ``user_info``h+}rS(h/]h0]h.]h-]h1]uh#j6h]rThHX user_inforU…rV}rW(h"Uh#jQubah)hhubhHX, rX…rY}rZ(h"X, h#j6ubh`)r[}r\(h"X``host``h+}r](h/]h0]h.]h-]h1]uh#j6h]r^hHXhostr_…r`}ra(h"Uh#j[ubah)hhubhHX, rb…rc}rd(h"X, h#j6ubh`)re}rf(h"X``port``h+}rg(h/]h0]h.]h-]h1]uh#j6h]rhhHXportri…rj}rk(h"Uh#jeubah)hhubhHX, rl…rm}rn(h"X, h#j6ubh`)ro}rp(h"X``path``h+}rq(h/]h0]h.]h-]h1]uh#j6h]rrhHXpathrs…rt}ru(h"Uh#joubah)hhubhHX, rv…rw}rx(h"X, h#j6ubh`)ry}rz(h"X ``query``h+}r{(h/]h0]h.]h-]h1]uh#j6h]r|hHXqueryr}…r~}r(h"Uh#jyubah)hhubhHX and r€…r}r‚(h"X and h#j6ubh`)rƒ}r„(h"X ``fragment``h+}r…(h/]h0]h.]h-]h1]uh#j6h]r†hHXfragmentr‡…rˆ}r‰(h"Uh#jƒubah)hhubhHXD. The code above takes the URI path to determine the resource name.rŠ…r‹}rŒ(h"XD. The code above takes the URI path to determine the resource name.h#j6ubeubhW)r}rŽ(h"XbNext we'll develop a simple client/server application using ``http::server`` and ``http::client``.h#hÃh$h'h)hZh+}r(h/]h0]h.]h-]h1]uh3Kmh4hh]r(hHX<Next we'll develop a simple client/server application using r‘…r’}r“(h"X<Next we'll develop a simple client/server application using h#jubh`)r”}r•(h"X``http::server``h+}r–(h/]h0]h.]h-]h1]uh#jh]r—hHX http::serverr˜…r™}rš(h"Uh#j”ubah)hhubhHX and r›…rœ}r(h"X and h#jubh`)rž}rŸ(h"X``http::client``h+}r (h/]h0]h.]h-]h1]uh#jh]r¡hHX http::clientr¢…r£}r¤(h"Uh#jžubah)hhubhHX.…r¥}r¦(h"X.h#jubeubeubeubeh"UU transformerr§NU footnote_refsr¨}r©Urefnamesrª}r«(Xboost]r¬h¨aXrfc 3986]r­jauUsymbol_footnotesr®]r¯Uautofootnote_refsr°]r±Usymbol_footnote_refsr²]r³U citationsr´]rµh4hU current_liner¶NUtransform_messagesr·]r¸cdocutils.nodes system_message r¹)rº}r»(h"Uh+}r¼(h/]UlevelKh-]h.]Usourceh'h0]h1]UlineKUtypeUINFOr½uh]r¾hW)r¿}rÀ(h"Uh+}rÁ(h/]h0]h.]h-]h1]uh#jºh]rÂhHX1Hyperlink target "simple-wget" is not referenced.rÃ…rÄ}rÅ(h"Uh#j¿ubah)hZubah)Usystem_messagerÆubaUreporterrÇNUid_startrÈKU autofootnotesrÉ]rÊU citation_refsrË}rÌUindirect_targetsrÍ]rÎUsettingsrÏ(cdocutils.frontend Values rÐorÑ}rÒ(Ufootnote_backlinksrÓKUrecord_dependenciesrÔNU rfc_base_urlrÕUhttp://tools.ietf.org/html/rÖU tracebackr׈Upep_referencesrØNUstrip_commentsrÙNU toc_backlinksrÚUentryrÛU language_coderÜUenrÝU datestamprÞNU report_levelrßKU _destinationràNU halt_levelráKU strip_classesrâNhENUerror_encoding_error_handlerrãUbackslashreplaceräUdebugråNUembed_stylesheetræ‰Uoutput_encoding_error_handlerrçUstrictrèU sectnum_xformréKUdump_transformsrêNU docinfo_xformrëKUwarning_streamrìNUpep_file_url_templateríUpep-%04drîUexit_status_levelrïKUconfigrðNUstrict_visitorrñNUcloak_email_addressesròˆUtrim_footnote_reference_spaceró‰UenvrôNUdump_pseudo_xmlrõNUexpose_internalsröNUsectsubtitle_xformr÷‰U source_linkrøNUrfc_referencesrùNUoutput_encodingrúUutf-8rûU source_urlrüNUinput_encodingrýUutf-8rþU_disable_configrÿNU id_prefixrUU tab_widthrKUerror_encodingrUUS-ASCIIrU_sourcerUO/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/simple_wget.rstrUgettext_compactrˆU generatorrNUdump_internalsrNU smart_quotesr ‰U pep_base_urlr Uhttp://www.python.org/dev/peps/r Usyntax_highlightr Ulongr Uinput_encoding_error_handlerrjèUauto_id_prefixrUidrUdoctitle_xformr‰Ustrip_elements_with_classesrNU _config_filesr]Ufile_insertion_enabledrˆU raw_enabledrKU dump_settingsrNubUsymbol_footnote_startrKUidsr}r(hh‘hh6hh6hjhhÃhh½hhvuUsubstitution_namesr}rh)h4h+}r(h/]h-]h.]Usourceh'h0]h1]uU footnotesr]rUrefidsr}r h]r!h asub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/examples/http/twitter_search.doctree000066400000000000000000000346331240331347200334140ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(X mit licenseqˆXtwitter_searchqˆXtwitter's search apiqˆXtwitter searchq NX#building and running twitter_searchq NXthe codeq NXdiving into the codeq NX rapidjsonq ˆuUsubstitution_defsq}qUparse_messagesq]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hU mit-licenseqhUtwitter-searchqhUtwitter-s-search-apiqh Uid1qh U#building-and-running-twitter-searchqh Uthe-codeqh Udiving-into-the-codeqh U rapidjsonquUchildrenq]q (cdocutils.nodes target q!)q"}q#(U rawsourceq$X.. _twitter_search:Uparentq%hUsourceq&cdocutils.nodes reprunicode q'XR/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/twitter_search.rstq(…q)}q*bUtagnameq+Utargetq,U attributesq-}q.(Uidsq/]Ubackrefsq0]Udupnamesq1]Uclassesq2]Unamesq3]Urefidq4huUlineq5KUdocumentq6hh]ubcdocutils.nodes section q7)q8}q9(h$Uh%hh&h)Uexpect_referenced_by_nameq:}q;hh"sh+Usectionq(hheh3]q?(h heuh5Kh6hUexpect_referenced_by_idq@}qAhh"sh]qB(cdocutils.nodes title qC)qD}qE(h$XTwitter searchqFh%h8h&h)h+UtitleqGh-}qH(h1]h2]h0]h/]h3]uh5Kh6hh]qIcdocutils.nodes Text qJXTwitter searchqK…qL}qM(h$hFh%hDubaubcdocutils.nodes paragraph qN)qO}qP(h$X¨This example uses `Twitter's search API`_ to list recent tweets given a user query. New features introduced here include the URI builder and ``uri::encoded`` function.h%h8h&h)h+U paragraphqQh-}qR(h1]h2]h0]h/]h3]uh5Kh6hh]qS(hJXThis example uses qT…qU}qV(h$XThis example uses h%hOubcdocutils.nodes reference qW)qX}qY(h$X`Twitter's search API`_UresolvedqZKh%hOh+U referenceq[h-}q\(UnameXTwitter's search APIUrefuriq]X)https://dev.twitter.com/docs/using-searchq^h/]h0]h1]h2]h3]uh]q_hJXTwitter's search APIq`…qa}qb(h$Uh%hXubaubhJXe to list recent tweets given a user query. New features introduced here include the URI builder and qc…qd}qe(h$Xe to list recent tweets given a user query. New features introduced here include the URI builder and h%hOubcdocutils.nodes literal qf)qg}qh(h$X``uri::encoded``h-}qi(h1]h2]h0]h/]h3]uh%hOh]qjhJX uri::encodedqk…ql}qm(h$Uh%hgubah+UliteralqnubhJX function.qo…qp}qq(h$X function.h%hOubeubh!)qr}qs(h$XE.. _`Twitter's search API`: https://dev.twitter.com/docs/using-searchU referencedqtKh%h8h&h)h+h,h-}qu(h]h^h/]qvhah0]h1]h2]h3]qwhauh5K h6hh]ubh7)qx}qy(h$Uh%h8h&h)h+h #include "rapidjson/rapidjson.h" #include "rapidjson/document.h" #include int main(int argc, char *argv[]) { using namespace boost::network; using namespace rapidjson; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; uri::uri base_uri("http://search.twitter.com/search.json"); std::cout << "Searching Twitter for query: " << argv[1] << std::endl; uri::uri search; search << base_uri << uri::query("q", uri::encoded(argv[1])); http::client::request request(search); http::client::response response = client.get(request); Document d; if (!d.Parse<0>(response.body().c_str()).HasParseError()) { const Value &results = d["results"]; for (SizeType i = 0; i < results.Size(); ++i) { const Value &user = results[i]["from_user_name"]; const Value &text = results[i]["text"]; std::cout << "From: " << user.GetString() << std::endl << " " << text.GetString() << std::endl << std::endl; } } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; }h%hxh&h)h+U literal_blockq‰h-}qŠ(Ulinenosq‹‰UlanguageqŒXc++U xml:spaceqUpreserveqŽh/]h0]h1]h2]h3]uh5Kh6hh]qhJXi#include #include "rapidjson/rapidjson.h" #include "rapidjson/document.h" #include int main(int argc, char *argv[]) { using namespace boost::network; using namespace rapidjson; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; uri::uri base_uri("http://search.twitter.com/search.json"); std::cout << "Searching Twitter for query: " << argv[1] << std::endl; uri::uri search; search << base_uri << uri::query("q", uri::encoded(argv[1])); http::client::request request(search); http::client::response response = client.get(request); Document d; if (!d.Parse<0>(response.body().c_str()).HasParseError()) { const Value &results = d["results"]; for (SizeType i = 0; i < results.Size(); ++i) { const Value &user = results[i]["from_user_name"]; const Value &text = results[i]["text"]; std::cout << "From: " << user.GetString() << std::endl << " " << text.GetString() << std::endl << std::endl; } } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; }q…q‘}q’(h$Uh%h‡ubaubcdocutils.nodes note q“)q”}q•(h$X‡To parse the results of these queries, this example uses `rapidjson`_, a header-only library that is released under the `MIT License`_.h%hxh&h)h+Unoteq–h-}q—(h1]h2]h0]h/]h3]uh5Nh6hh]q˜hN)q™}qš(h$X‡To parse the results of these queries, this example uses `rapidjson`_, a header-only library that is released under the `MIT License`_.h%h”h&h)h+hQh-}q›(h1]h2]h0]h/]h3]uh5K?h]qœ(hJX9To parse the results of these queries, this example uses q…qž}qŸ(h$X9To parse the results of these queries, this example uses h%h™ubhW)q }q¡(h$X `rapidjson`_hZKh%h™h+h[h-}q¢(UnameX rapidjsonq£h]X#http://code.google.com/p/rapidjson/q¤h/]h0]h1]h2]h3]uh]q¥hJX rapidjsonq¦…q§}q¨(h$Uh%h ubaubhJX3, a header-only library that is released under the q©…qª}q«(h$X3, a header-only library that is released under the h%h™ubhW)q¬}q­(h$X`MIT License`_hZKh%h™h+h[h-}q®(UnameX MIT Licenseh]X2http://www.opensource.org/licenses/mit-license.phpq¯h/]h0]h1]h2]h3]uh]q°hJX MIT Licenseq±…q²}q³(h$Uh%h¬ubaubhJX.…q´}qµ(h$X.h%h™ubeubaubh!)q¶}q·(h$X4.. _`rapidjson`: http://code.google.com/p/rapidjson/htKh%hxh&h)h+h,h-}q¸(h]h¤h/]q¹hah0]h1]h2]h3]qºh auh5KCh6hh]ubh!)q»}q¼(h$XE.. _`MIT License`: http://www.opensource.org/licenses/mit-license.phphtKh%hxh&h)h+h,h-}q½(h]h¯h/]q¾hah0]h1]h2]h3]q¿hauh5KDh6hh]ubeubh7)qÀ}qÁ(h$Uh%h8h&h)h+hReturns any results that contain the exact phrase "Lady Gaga".qïh%hÀh&h)h+hQh-}qð(h1]h2]h0]h/]h3]uh5KUh6hh]qñhJX>Returns any results that contain the exact phrase "Lady Gaga".qò…qó}qô(h$hïh%híubaubh†)qõ}qö(h$X&$ ./example/twitter_search "#olympics"h%hÀh&h)h+h‰h-}q÷(h‹‰hŒXbashhhŽh/]h0]h1]h2]h3]uh5KWh6hh]qøhJX&$ ./example/twitter_search "#olympics"qù…qú}qû(h$Uh%hõubaubhN)qü}qý(h$X0Returns any results with the #olympics hash tag.qþh%hÀh&h)h+hQh-}qÿ(h1]h2]h0]h/]h3]uh5K[h6hh]rhJX0Returns any results with the #olympics hash tag.r…r}r(h$hþh%hüubaubh†)r}r(h$X&$ ./example/twitter_search "flight :("h%hÀh&h)h+h‰h-}r(h‹‰hŒXbashhhŽh/]h0]h1]h2]h3]uh5K]h6hh]rhJX&$ ./example/twitter_search "flight :("r…r }r (h$Uh%jubaubhN)r }r (h$XGReturns any results that contain "flight" and have a negative attitude.r h%hÀh&h)h+hQh-}r(h1]h2]h0]h/]h3]uh5Kah6hh]rhJXGReturns any results that contain "flight" and have a negative attitude.r…r}r(h$j h%j ubaubhN)r}r(h$X;More examples can be found on `Twitter's search API`_ page.rh%hÀh&h)h+hQh-}r(h1]h2]h0]h/]h3]uh5Kdh6hh]r(hJXMore examples can be found on r…r}r(h$XMore examples can be found on h%jubhW)r}r(h$X`Twitter's search API`_hZKh%jh+h[h-}r(UnameXTwitter's search APIh]h^h/]h0]h1]h2]h3]uh]rhJXTwitter's search APIr…r }r!(h$Uh%jubaubhJX page.r"…r#}r$(h$X page.h%jubeubeubh7)r%}r&(h$Uh%h8h&h)h+h…r?}r@(h$XThe h%j:ubcsphinx.addnodes pending_xref rA)rB}rC(h$X:mod:`cpp-netlib`rDh%j:h&h)h+U pending_xrefrEh-}rF(UreftypeXmodUrefwarnrG‰U reftargetrHX cpp-netlibU refdomainXpyrIh/]h0]U refexplicit‰h1]h2]h3]UrefdocrJXexamples/http/twitter_searchrKUpy:classrLNU py:modulerMNuh5Kqh]rNhf)rO}rP(h$jDh-}rQ(h1]h2]rR(UxrefrSjIXpy-modrTeh0]h/]h3]uh%jBh]rUhJX cpp-netlibrV…rW}rX(h$Uh%jOubah+hnubaubhJX URI builder uses a stream-like syntax to allow developers to construct more complex URIs. The example above re-uses the same base URI and allows the command line argument to be used as part of the URI query. The builder also supports percent encoding using the rY…rZ}r[(h$X URI builder uses a stream-like syntax to allow developers to construct more complex URIs. The example above re-uses the same base URI and allows the command line argument to be used as part of the URI query. The builder also supports percent encoding using the h%j:ubhf)r\}r](h$X ``encoded``h-}r^(h1]h2]h0]h/]h3]uh%j:h]r_hJXencodedr`…ra}rb(h$Uh%j\ubah+hnubhJX directive.rc…rd}re(h$X directive.h%j:ubeubeubeubeh$UU transformerrfNU footnote_refsrg}rhUrefnamesri}rj(X mit license]rkh¬aXtwitter's search api]rl(hXjeh£]rmh auUsymbol_footnotesrn]roUautofootnote_refsrp]rqUsymbol_footnote_refsrr]rsU citationsrt]ruh6hU current_linervNUtransform_messagesrw]rxcdocutils.nodes system_message ry)rz}r{(h$Uh-}r|(h1]UlevelKh/]h0]Usourceh)h2]h3]UlineKUtypeUINFOr}uh]r~hN)r}r€(h$Uh-}r(h1]h2]h0]h/]h3]uh%jzh]r‚hJX4Hyperlink target "twitter-search" is not referenced.rƒ…r„}r…(h$Uh%jubah+hQubah+Usystem_messager†ubaUreporterr‡NUid_startrˆKU autofootnotesr‰]rŠU citation_refsr‹}rŒUindirect_targetsr]rŽUsettingsr(cdocutils.frontend Values ror‘}r’(Ufootnote_backlinksr“KUrecord_dependenciesr”NU rfc_base_urlr•Uhttp://tools.ietf.org/html/r–U tracebackr—ˆUpep_referencesr˜NUstrip_commentsr™NU toc_backlinksršUentryr›U language_coderœUenrU datestampržNU report_levelrŸKU _destinationr NU halt_levelr¡KU strip_classesr¢NhGNUerror_encoding_error_handlerr£Ubackslashreplacer¤Udebugr¥NUembed_stylesheetr¦‰Uoutput_encoding_error_handlerr§Ustrictr¨U sectnum_xformr©KUdump_transformsrªNU docinfo_xformr«KUwarning_streamr¬NUpep_file_url_templater­Upep-%04dr®Uexit_status_levelr¯KUconfigr°NUstrict_visitorr±NUcloak_email_addressesr²ˆUtrim_footnote_reference_spacer³‰Uenvr´NUdump_pseudo_xmlrµNUexpose_internalsr¶NUsectsubtitle_xformr·‰U source_linkr¸NUrfc_referencesr¹NUoutput_encodingrºUutf-8r»U source_urlr¼NUinput_encodingr½Uutf-8r¾U_disable_configr¿NU id_prefixrÀUU tab_widthrÁKUerror_encodingrÂUUS-ASCIIrÃU_sourcerÄUR/Users/dean/Documents/cpp-netlib/libs/network/doc/examples/http/twitter_search.rstrÅUgettext_compactrƈU generatorrÇNUdump_internalsrÈNU smart_quotesrɉU pep_base_urlrÊUhttp://www.python.org/dev/peps/rËUsyntax_highlightrÌUlongrÍUinput_encoding_error_handlerrÎj¨Uauto_id_prefixrÏUidrÐUdoctitle_xformrщUstrip_elements_with_classesrÒNU _config_filesrÓ]Ufile_insertion_enabledrÔˆU raw_enabledrÕKU dump_settingsrÖNubUsymbol_footnote_startr×KUidsrØ}rÙ(hh8hhxhhrhhÀhh»hj%hh8hh¶uUsubstitution_namesrÚ}rÛh+h6h-}rÜ(h1]h/]h0]Usourceh)h2]h3]uU footnotesrÝ]rÞUrefidsrß}ràh]ráh"asub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/getting_started.doctree000066400000000000000000001556301240331347200307600ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(X pull requestsqˆXboost.date_timeqˆX boost.systemqˆXusing cpp-netlibq NX!downloading a development versionq NXbuilding with cmakeq NXmsysgitq ˆXcmakeq ˆX7zipqˆXbuilding on windowsqNX getting cmakeqNXboost web-siteqˆX subversionqˆX boost.regexqˆXboost getting startedqˆX getting boostqNX!reporting issues, getting supportqNXgit documentationqˆXboostqˆXgetting startedqNXdownloading an official releaseqNXcmake projectsqNXforkingqˆXgitqˆXgetting_startedqˆXbuilding on linuxqNXgithubq ˆX thrashingq!ˆuUsubstitution_defsq"}q#Uparse_messagesq$]q%Ucurrent_sourceq&NU decorationq'NUautofootnote_startq(KUnameidsq)}q*(hU pull-requestsq+hUboost-date-timeq,hU boost-systemq-h Uusing-cpp-netlibq.h U!downloading-a-development-versionq/h Ubuilding-with-cmakeq0h Umsysgitq1h Ucmakeq2hUzipq3hUbuilding-on-windowsq4hU getting-cmakeq5hUboost-web-siteq6hU subversionq7hU boost-regexq8hUboost-getting-startedq9hU getting-boostq:hU reporting-issues-getting-supportq;hUgit-documentationqhUdownloading-an-official-releaseq?hUcmake-projectsq@hUforkingqAhUgitqBhUgetting-startedqChUbuilding-on-linuxqDh UgithubqEh!U thrashingqFuUchildrenqG]qH(cdocutils.nodes target qI)qJ}qK(U rawsourceqLX.. _getting_started:UparentqMhUsourceqNcdocutils.nodes reprunicode qOXE/Users/dean/Documents/cpp-netlib/libs/network/doc/getting_started.rstqP…qQ}qRbUtagnameqSUtargetqTU attributesqU}qV(UidsqW]UbackrefsqX]UdupnamesqY]UclassesqZ]Unamesq[]Urefidq\hCuUlineq]KUdocumentq^hhG]ubcdocutils.nodes section q_)q`}qa(hLUhMhhNhQUexpect_referenced_by_nameqb}qchhJshSUsectionqdhU}qe(hY]hZ]hX]hW]qf(hCh>eh[]qg(hheuh]Kh^hUexpect_referenced_by_idqh}qihChJshG]qj(cdocutils.nodes title qk)ql}qm(hLXGetting StartedqnhMh`hNhQhSUtitleqohU}qp(hY]hZ]hX]hW]h[]uh]Kh^hhG]qqcdocutils.nodes Text qrXGetting Startedqs…qt}qu(hLhnhMhlubaubh_)qv}qw(hLUhMh`hNhQhShdhU}qx(hY]hZ]hX]hW]qyh?ah[]qzhauh]Kh^hhG]q{(hk)q|}q}(hLXDownloading an official releaseq~hMhvhNhQhShohU}q(hY]hZ]hX]hW]h[]uh]Kh^hhG]q€hrXDownloading an official releaseq…q‚}qƒ(hLh~hMh|ubaubcdocutils.nodes paragraph q„)q…}q†(hLXVYou can find links to the latest official release from the project's official website:q‡hMhvhNhQhSU paragraphqˆhU}q‰(hY]hZ]hX]hW]h[]uh]K h^hhG]qŠhrXVYou can find links to the latest official release from the project's official website:q‹…qŒ}q(hLh‡hMh…ubaubcdocutils.nodes block_quote qŽ)q}q(hLUhMhvhNhQhSU block_quoteq‘hU}q’(hY]hZ]hX]hW]h[]uh]Nh^hhG]q“h„)q”}q•(hLXhttp://cpp-netlib.org/q–hMhhNhQhShˆhU}q—(hY]hZ]hX]hW]h[]uh]K hG]q˜cdocutils.nodes reference q™)qš}q›(hLh–hU}qœ(Urefurih–hW]hX]hY]hZ]h[]uhMh”hG]qhrXhttp://cpp-netlib.org/qž…qŸ}q (hLUhMhšubahSU referenceq¡ubaubaubh„)q¢}q£(hLX_All previous stable versions of :mod:`cpp-netlib` can be downloaded from Github_ from this url:hMhvhNhQhShˆhU}q¤(hY]hZ]hX]hW]h[]uh]Kh^hhG]q¥(hrX All previous stable versions of q¦…q§}q¨(hLX All previous stable versions of hMh¢ubcsphinx.addnodes pending_xref q©)qª}q«(hLX:mod:`cpp-netlib`q¬hMh¢hNhQhSU pending_xrefq­hU}q®(UreftypeXmodUrefwarnq¯‰U reftargetq°X cpp-netlibU refdomainXpyq±hW]hX]U refexplicit‰hY]hZ]h[]Urefdocq²Xgetting_startedq³Upy:classq´NU py:moduleqµNuh]KhG]q¶cdocutils.nodes literal q·)q¸}q¹(hLh¬hU}qº(hY]hZ]q»(Uxrefq¼h±Xpy-modq½ehX]hW]h[]uhMhªhG]q¾hrX cpp-netlibq¿…qÀ}qÁ(hLUhMh¸ubahSUliteralqÂubaubhrX can be downloaded from qÃ…qÄ}qÅ(hLX can be downloaded from hMh¢ubh™)qÆ}qÇ(hLXGithub_UresolvedqÈKhMh¢hSh¡hU}qÉ(UnameXGithubUrefuriqÊX1http://github.com/cpp-netlib/cpp-netlib/downloadsqËhW]hX]hY]hZ]h[]uhG]qÌhrXGithubqÍ…qÎ}qÏ(hLUhMhÆubaubhrX from this url:qÐ…qÑ}qÒ(hLX from this url:hMh¢ubeubhŽ)qÓ}qÔ(hLUhMhvhNhQhSh‘hU}qÕ(hY]hZ]hX]hW]h[]uh]Nh^hhG]qÖh„)q×}qØ(hLX1http://github.com/cpp-netlib/cpp-netlib/downloadsqÙhMhÓhNhQhShˆhU}qÚ(hY]hZ]hX]hW]h[]uh]KhG]qÛh™)qÜ}qÝ(hLhÙhU}qÞ(UrefurihÙhW]hX]hY]hZ]h[]uhMh×hG]qßhrX1http://github.com/cpp-netlib/cpp-netlib/downloadsqà…qá}qâ(hLUhMhÜubahSh¡ubaubaubh„)qã}qä(hLXç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_).hMhvhNhQhShˆhU}qå(hY]hZ]hX]hW]h[]uh]Kh^hhG]qæ(hrX8Each release is available as gzipped (Using the command qç…qè}qé(hLX8Each release is available as gzipped (Using the command hMhãubh·)qê}që(hLX``tar xzf cpp-netlib.tar.gz``hU}qì(hY]hZ]hX]hW]h[]uhMhãhG]qíhrXtar xzf cpp-netlib.tar.gzqî…qï}qð(hLUhMhêubahShÂubhrX) or bzipped (Using qñ…qò}qó(hLX) or bzipped (Using hMhãubh·)qô}qõ(hLX``tar xjf cpp-netlib.tar.bz2``hU}qö(hY]hZ]hX]hW]h[]uhMhãhG]q÷hrXtar xjf cpp-netlib.tar.bz2qø…qù}qú(hLUhMhôubahShÂubhrX) tarball, or as a zipfile (qû…qü}qý(hLX) tarball, or as a zipfile (hMhãubh·)qþ}qÿ(hLX``unzip cpp-netlib.zip``hU}r(hY]hZ]hX]hW]h[]uhMhãhG]rhrXunzip cpp-netlib.zipr…r}r(hLUhMhþubahShÂubhrX%, or on Windows using a tool such as r…r}r(hLX%, or on Windows using a tool such as hMhãubh™)r}r (hLX7zip_hÈKhMhãhSh¡hU}r (UnameX7zipr hÊXhttp://www.7-zip.org/r hW]hX]hY]hZ]h[]uhG]r hrX7zipr…r}r(hLUhMjubaubhrX).r…r}r(hLX).hMhãubeubhI)r}r(hLX=.. _Github: http://github.com/cpp-netlib/cpp-netlib/downloadsU referencedrKhMhvhNhQhShThU}r(hÊhËhW]rhEahX]hY]hZ]h[]rh auh]Kh^hhG]ubhI)r}r(hLX.. _7zip: http://www.7-zip.org/jKhMhvhNhQhShThU}r(hÊj hW]rh3ahX]hY]hZ]h[]rhauh]Kh^hhG]ubeubh_)r}r (hLUhMh`hNhQhShdhU}r!(hY]hZ]hX]hW]r"h/ah[]r#h auh]Kh^hhG]r$(hk)r%}r&(hLX!Downloading a development versionr'hMjhNhQhShohU}r((hY]hZ]hX]hW]h[]uh]Kh^hhG]r)hrX!Downloading a development versionr*…r+}r,(hLj'hMj%ubaubh„)r-}r.(hLX|The :mod:`cpp-netlib` uses Git_ for source control, so to use any development versions Git must be installed on your system.hMjhNhQhShˆhU}r/(hY]hZ]hX]hW]h[]uh]Kh^hhG]r0(hrXThe r1…r2}r3(hLXThe hMj-ubh©)r4}r5(hLX:mod:`cpp-netlib`r6hMj-hNhQhSh­hU}r7(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr8hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KhG]r9h·)r:}r;(hLj6hU}r<(hY]hZ]r=(h¼j8Xpy-modr>ehX]hW]h[]uhMj4hG]r?hrX cpp-netlibr@…rA}rB(hLUhMj:ubahShÂubaubhrX uses rC…rD}rE(hLX uses hMj-ubh™)rF}rG(hLXGit_hÈKhMj-hSh¡hU}rH(UnameXGithÊXhttp://git-scm.com/rIhW]hX]hY]hZ]h[]uhG]rJhrXGitrK…rL}rM(hLUhMjFubaubhrX] for source control, so to use any development versions Git must be installed on your system.rN…rO}rP(hLX] for source control, so to use any development versions Git must be installed on your system.hMj-ubeubh„)rQ}rR(hLX>Using the command line, the command to get the latest code is:rShMjhNhQhShˆhU}rT(hY]hZ]hX]hW]h[]uh]K"h^hhG]rUhrX>Using the command line, the command to get the latest code is:rV…rW}rX(hLjShMjQubaubcdocutils.nodes literal_block rY)rZ}r[(hLX;shell$ git clone git://github.com/cpp-netlib/cpp-netlib.githMjhNhQhSU literal_blockr\hU}r](U xml:spacer^Upreserver_hW]hX]hY]hZ]h[]uh]K&h^hhG]r`hrX;shell$ git clone git://github.com/cpp-netlib/cpp-netlib.gitra…rb}rc(hLUhMjZubaubh„)rd}re(hLX¯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`_.hMjhNhQhShˆhU}rf(hY]hZ]hX]hW]h[]uh]K(h^hhG]rg(hrXš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 rh…ri}rj(hLXš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 hMjdubh™)rk}rl(hLX`Git documentation`_hÈKhMjdhSh¡hU}rm(UnameXGit documentationhÊX http://git-scm.com/documentationrnhW]hX]hY]hZ]h[]uhG]rohrXGit documentationrp…rq}rr(hLUhMjkubaubhrX.…rs}rt(hLX.hMjdubeubcdocutils.nodes note ru)rv}rw(hLXPrevious versions of :mod:`cpp-netlib` referred to the *mikhailberis* repository as the main development repository. This account is still valid, but not always up-to-date. In the interest of consistency, the main repository has been changed to *cpp-netlib*.hMjhNhQhSUnoterxhU}ry(hY]hZ]hX]hW]h[]uh]Nh^hhG]rzh„)r{}r|(hLXPrevious versions of :mod:`cpp-netlib` referred to the *mikhailberis* repository as the main development repository. This account is still valid, but not always up-to-date. In the interest of consistency, the main repository has been changed to *cpp-netlib*.hMjvhNhQhShˆhU}r}(hY]hZ]hX]hW]h[]uh]K,hG]r~(hrXPrevious versions of r…r€}r(hLXPrevious versions of hMj{ubh©)r‚}rƒ(hLX:mod:`cpp-netlib`r„hMj{hNhQhSh­hU}r…(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr†hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K,hG]r‡h·)rˆ}r‰(hLj„hU}rŠ(hY]hZ]r‹(h¼j†Xpy-modrŒehX]hW]h[]uhMj‚hG]rhrX cpp-netlibrŽ…r}r(hLUhMjˆubahShÂubaubhrX referred to the r‘…r’}r“(hLX referred to the hMj{ubcdocutils.nodes emphasis r”)r•}r–(hLX*mikhailberis*hU}r—(hY]hZ]hX]hW]h[]uhMj{hG]r˜hrX mikhailberisr™…rš}r›(hLUhMj•ubahSUemphasisrœubhrX° repository as the main development repository. This account is still valid, but not always up-to-date. In the interest of consistency, the main repository has been changed to r…rž}rŸ(hLX° repository as the main development repository. This account is still valid, but not always up-to-date. In the interest of consistency, the main repository has been changed to hMj{ubj”)r }r¡(hLX *cpp-netlib*hU}r¢(hY]hZ]hX]hW]h[]uhMj{hG]r£hrX cpp-netlibr¤…r¥}r¦(hLUhMj ubahSjœubhrX.…r§}r¨(hLX.hMj{ubeubaubh„)r©}rª(hLXQWindows users need to use msysGit_, and to invoke the command above from a shell.hMjhNhQhShˆhU}r«(hY]hZ]hX]hW]h[]uh]K1h^hhG]r¬(hrXWindows users need to use r­…r®}r¯(hLXWindows users need to use hMj©ubh™)r°}r±(hLXmsysGit_hÈKhMj©hSh¡hU}r²(UnameXmsysGithÊX/http://code.google.com/p/msysgit/downloads/listr³hW]hX]hY]hZ]h[]uhG]r´hrXmsysGitrµ…r¶}r·(hLUhMj°ubaubhrX/, and to invoke the command above from a shell.r¸…r¹}rº(hLX/, and to invoke the command above from a shell.hMj©ubeubh„)r»}r¼(hLXoFor fans of Subversion_, the same code can be checked out from http://svn.github.com/cpp-netlib/cpp-netlib.git.hMjhNhQhShˆhU}r½(hY]hZ]hX]hW]h[]uh]K4h^hhG]r¾(hrX For fans of r¿…rÀ}rÁ(hLX For fans of hMj»ubh™)rÂ}rÃ(hLX Subversion_hÈKhMj»hSh¡hU}rÄ(UnameX SubversionhÊXhttp://subversion.tigris.org/rÅhW]hX]hY]hZ]h[]uhG]rÆhrX SubversionrÇ…rÈ}rÉ(hLUhMjÂubaubhrX(, the same code can be checked out from rÊ…rË}rÌ(hLX(, the same code can be checked out from hMj»ubh™)rÍ}rÎ(hLX/http://svn.github.com/cpp-netlib/cpp-netlib.gitrÏhU}rÐ(UrefurijÏhW]hX]hY]hZ]h[]uhMj»hG]rÑhrX/http://svn.github.com/cpp-netlib/cpp-netlib.gitrÒ…rÓ}rÔ(hLUhMjÍubahSh¡ubhrX.…rÕ}rÖ(hLX.hMj»ubeubhI)r×}rØ(hLX.. _Git: http://git-scm.com/jKhMjhNhQhShThU}rÙ(hÊjIhW]rÚhBahX]hY]hZ]h[]rÛhauh]K7h^hhG]ubhI)rÜ}rÝ(hLX9.. _`Git documentation`: http://git-scm.com/documentationjKhMjhNhQhShThU}rÞ(hÊjnhW]rßh(hLUhMh`hNhQhShdhU}r?(hY]hZ]hX]hW]r@h:ah[]rAhauh]KFh^hhG]rB(hk)rC}rD(hLX Getting BoostrEhMj=hNhQhShohU}rF(hY]hZ]hX]hW]h[]uh]KFh^hhG]rGhrX Getting BoostrH…rI}rJ(hLjEhMjCubaubh„)rK}rL(hLXò:mod:`cpp-netlib` depends on Boost_. It should work for any version of Boost above 1.50.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`_.hMj=hNhQhShˆhU}rM(hY]hZ]hX]hW]h[]uh]KHh^hhG]rN(h©)rO}rP(hLX:mod:`cpp-netlib`rQhMjKhNhQhSh­hU}rR(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrShW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KHhG]rTh·)rU}rV(hLjQhU}rW(hY]hZ]rX(h¼jSXpy-modrYehX]hW]h[]uhMjOhG]rZhrX cpp-netlibr[…r\}r](hLUhMjUubahShÂubaubhrX depends on r^…r_}r`(hLX depends on hMjKubh™)ra}rb(hLXBoost_hÈKhMjKhSh¡hU}rc(UnameXBoosthÊXEhttp://www.boost.org/doc/libs/release/more/getting_started/index.htmlrdhW]hX]hY]hZ]h[]uhG]rehrXBoostrf…rg}rh(hLUhMjaubaubhrX‹. It should work for any version of Boost above 1.50.0. If Boost is not installed on your system, the latest package can be found on the ri…rj}rk(hLX‹. It should work for any version of Boost above 1.50.0. If Boost is not installed on your system, the latest package can be found on the hMjKubh™)rl}rm(hLX`Boost web-site`_hÈKhMjKhSh¡hU}rn(UnameXBoost web-sitehÊX$http://www.boost.org/users/download/rohW]hX]hY]hZ]h[]uhG]rphrXBoost web-siterq…rr}rs(hLUhMjlubaubhrX. The environment variable rt…ru}rv(hLX. The environment variable hMjKubh·)rw}rx(hLX``BOOST_ROOT``hU}ry(hY]hZ]hX]hW]h[]uhMjKhG]rzhrX BOOST_ROOTr{…r|}r}(hLUhMjwubahShÂubhrX£ 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 r~…r}r€(hLX£ 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 hMjKubh©)r}r‚(hLX:mod:`cpp-netlib`rƒhMjKhNhQhSh­hU}r„(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr…hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KHhG]r†h·)r‡}rˆ(hLjƒhU}r‰(hY]hZ]rŠ(h¼j…Xpy-modr‹ehX]hW]h[]uhMjhG]rŒhrX cpp-netlibr…rŽ}r(hLUhMj‡ubahShÂubaubhrX still requires linking with r…r‘}r’(hLX still requires linking with hMjKubh™)r“}r”(hLX`Boost.System`_hÈKhMjKhSh¡hU}r•(UnameX Boost.SystemhÊX+http://www.boost.org/libs/system/index.htmlr–hW]hX]hY]hZ]h[]uhG]r—hrX Boost.Systemr˜…r™}rš(hLUhMj“ubaubhrX, r›…rœ}r(hLX, hMjKubh™)rž}rŸ(hLX`Boost.Date_time`_hÈKhMjKhSh¡hU}r (UnameXBoost.Date_timehÊX.http://www.boost.org/libs/date_time/index.htmlr¡hW]hX]hY]hZ]h[]uhG]r¢hrXBoost.Date_timer£…r¤}r¥(hLUhMjžubaubhrX, and r¦…r§}r¨(hLX, and hMjKubh™)r©}rª(hLX`Boost.Regex`_hÈKhMjKhSh¡hU}r«(UnameX Boost.RegexhÊX*http://www.boost.org/libs/regex/index.htmlr¬hW]hX]hY]hZ]h[]uhG]r­hrX Boost.Regexr®…r¯}r°(hLUhMj©ubaubhrX.…r±}r²(hLX.hMjKubeubhI)r³}r´(hLXP.. _Boost: http://www.boost.org/doc/libs/release/more/getting_started/index.htmljKhMj=hNhQhShThU}rµ(hÊjdhW]r¶h=ahX]hY]hZ]h[]r·hauh]KQh^hhG]ubhI)r¸}r¹(hLX:.. _`Boost web-site`: http://www.boost.org/users/download/jKhMj=hNhQhShThU}rº(hÊjohW]r»h6ahX]hY]hZ]h[]r¼hauh]KRh^hhG]ubhI)r½}r¾(hLX?.. _`Boost.System`: http://www.boost.org/libs/system/index.htmljKhMj=hNhQhShThU}r¿(hÊj–hW]rÀh-ahX]hY]hZ]h[]rÁhauh]KSh^hhG]ubhI)rÂ}rÃ(hLXE.. _`Boost.Date_time`: http://www.boost.org/libs/date_time/index.htmljKhMj=hNhQhShThU}rÄ(hÊj¡hW]rÅh,ahX]hY]hZ]h[]rÆhauh]KTh^hhG]ubhI)rÇ}rÈ(hLX=.. _`Boost.Regex`: http://www.boost.org/libs/regex/index.htmljKhMj=hNhQhShThU}rÉ(hÊj¬hW]rÊh8ahX]hY]hZ]h[]rËhauh]KUh^hhG]ubju)rÌ}rÍ(hLXmYou can follow the steps in the `Boost Getting Started`_ guide to install Boost into your development system.hMj=hNhQhSjxhU}rÎ(hY]hZ]hX]hW]h[]uh]Nh^hhG]rÏh„)rÐ}rÑ(hLXmYou can follow the steps in the `Boost Getting Started`_ guide to install Boost into your development system.hMjÌhNhQhShˆhU}rÒ(hY]hZ]hX]hW]h[]uh]KWhG]rÓ(hrX You can follow the steps in the rÔ…rÕ}rÖ(hLX You can follow the steps in the hMjÐubh™)r×}rØ(hLX`Boost Getting Started`_hÈKhMjÐhSh¡hU}rÙ(UnameXBoost Getting StartedhÊXEhttp://www.boost.org/doc/libs/release/more/getting_started/index.htmlrÚhW]hX]hY]hZ]h[]uhG]rÛhrXBoost Getting StartedrÜ…rÝ}rÞ(hLUhMj×ubaubhrX5 guide to install Boost into your development system.rß…rà}rá(hLX5 guide to install Boost into your development system.hMjÐubeubaubhI)râ}rã(hLXe.. _`Boost Getting Started`: http://www.boost.org/doc/libs/release/more/getting_started/index.htmljKhMj=hNhQhShThU}rä(hÊjÚhW]råh9ahX]hY]hZ]h[]ræhauh]KZh^hhG]ubcdocutils.nodes warning rç)rè}ré(hLXøThere is a known incompatibility between :mod:`cpp-netlib` and Boost 1.46.1 on some compilers. It is not recommended to use :mod:`cpp-netlib` with Boost 1.46.1. Some have reported though that Boost 1.47.0 and :mod:`cpp-netlib` work together better.hMj=hNhQhSUwarningrêhU}rë(hY]hZ]hX]hW]h[]uh]Nh^hhG]rìh„)rí}rî(hLXøThere is a known incompatibility between :mod:`cpp-netlib` and Boost 1.46.1 on some compilers. It is not recommended to use :mod:`cpp-netlib` with Boost 1.46.1. Some have reported though that Boost 1.47.0 and :mod:`cpp-netlib` work together better.hMjèhNhQhShˆhU}rï(hY]hZ]hX]hW]h[]uh]K]hG]rð(hrX)There is a known incompatibility between rñ…rò}ró(hLX)There is a known incompatibility between hMjíubh©)rô}rõ(hLX:mod:`cpp-netlib`röhMjíhNhQhSh­hU}r÷(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrøhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K]hG]rùh·)rú}rû(hLjöhU}rü(hY]hZ]rý(h¼jøXpy-modrþehX]hW]h[]uhMjôhG]rÿhrX cpp-netlibr…r}r(hLUhMjúubahShÂubaubhrXB and Boost 1.46.1 on some compilers. It is not recommended to use r…r}r(hLXB and Boost 1.46.1 on some compilers. It is not recommended to use hMjíubh©)r}r(hLX:mod:`cpp-netlib`rhMjíhNhQhSh­hU}r (UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K]hG]r h·)r }r (hLjhU}r(hY]hZ]r(h¼j Xpy-modrehX]hW]h[]uhMjhG]rhrX cpp-netlibr…r}r(hLUhMj ubahShÂubaubhrXD with Boost 1.46.1. Some have reported though that Boost 1.47.0 and r…r}r(hLXD with Boost 1.46.1. Some have reported though that Boost 1.47.0 and hMjíubh©)r}r(hLX:mod:`cpp-netlib`rhMjíhNhQhSh­hU}r(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K]hG]rh·)r}r(hLjhU}r (hY]hZ]r!(h¼jXpy-modr"ehX]hW]h[]uhMjhG]r#hrX cpp-netlibr$…r%}r&(hLUhMjubahShÂubaubhrX work together better.r'…r(}r)(hLX work together better.hMjíubeubaubeubh_)r*}r+(hLUhMh`hNhQhShdhU}r,(hY]hZ]hX]hW]r-h5ah[]r.hauh]Kch^hhG]r/(hk)r0}r1(hLX Getting CMaker2hMj*hNhQhShohU}r3(hY]hZ]hX]hW]h[]uh]Kch^hhG]r4hrX Getting CMaker5…r6}r7(hLj2hMj0ubaubh„)r8}r9(hLXThe :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.hMj*hNhQhShˆhU}r:(hY]hZ]hX]hW]h[]uh]Keh^hhG]r;(hrXThe r<…r=}r>(hLXThe hMj8ubh©)r?}r@(hLX:mod:`cpp-netlib`rAhMj8hNhQhSh­hU}rB(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrChW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KehG]rDh·)rE}rF(hLjAhU}rG(hY]hZ]rH(h¼jCXpy-modrIehX]hW]h[]uhMj?hG]rJhrX cpp-netlibrK…rL}rM(hLUhMjEubahShÂubaubhrX uses rN…rO}rP(hLX uses hMj8ubh™)rQ}rR(hLXCMake_hÈKhMj8hSh¡hU}rS(UnameXCMakehÊXhttp://www.cmake.org/rThW]hX]hY]hZ]h[]uhG]rUhrXCMakerV…rW}rX(hLUhMjQubaubhrXŸ 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 rY…rZ}r[(hLXŸ 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 hMj8ubh©)r\}r](hLX:mod:`cpp-netlib`r^hMj8hNhQhSh­hU}r_(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr`hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KehG]rah·)rb}rc(hLj^hU}rd(hY]hZ]re(h¼j`Xpy-modrfehX]hW]h[]uhMj\hG]rghrX cpp-netlibrh…ri}rj(hLUhMjbubahShÂubaubhrX in your project. The rk…rl}rm(hLX in your project. The hMj8ubh©)rn}ro(hLX:mod:`cpp-netlib`rphMj8hNhQhSh­hU}rq(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrrhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KehG]rsh·)rt}ru(hLjphU}rv(hY]hZ]rw(h¼jrXpy-modrxehX]hW]h[]uhMjnhG]ryhrX cpp-netlibrz…r{}r|(hLUhMjtubahShÂubaubhrX& requires CMake version 2.8 or higher.r}…r~}r(hLX& requires CMake version 2.8 or higher.hMj8ubeubhI)r€}r(hLX .. _CMake: http://www.cmake.org/jKhMj*hNhQhShThU}r‚(hÊjThW]rƒh2ahX]hY]hZ]h[]r„h auh]Kjh^hhG]ubh„)r…}r†(hLXRLet'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.hMj*hNhQhShˆhU}r‡(hY]hZ]hX]hW]h[]uh]Klh^hhG]rˆ(hrX(Let's assume that you have unpacked the r‰…rŠ}r‹(hLX(Let's assume that you have unpacked the hMj…ubh©)rŒ}r(hLX:mod:`cpp-netlib`rŽhMj…hNhQhSh­hU}r(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KlhG]r‘h·)r’}r“(hLjŽhU}r”(hY]hZ]r•(h¼jXpy-modr–ehX]hW]h[]uhMjŒhG]r—hrX cpp-netlibr˜…r™}rš(hLUhMj’ubahShÂubaubhrX‰ 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 r›…rœ}r(hLX‰ 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 hMj…ubh·)rž}rŸ(hLX``cd ~``hU}r (hY]hZ]hX]hW]h[]uhMj…hG]r¡hrXcd ~r¢…r£}r¤(hLUhMjžubahShÂubhrX%. This sample below assumes that the r¥…r¦}r§(hLX%. This sample below assumes that the hMj…ubh·)r¨}r©(hLX``~/cpp-netlib``hU}rª(hY]hZ]hX]hW]h[]uhMj…hG]r«hrX ~/cpp-netlibr¬…r­}r®(hLUhMj¨ubahShÂubhrX9 directory exists, and is the top-level directory of the r¯…r°}r±(hLX9 directory exists, and is the top-level directory of the hMj…ubh©)r²}r³(hLX:mod:`cpp-netlib`r´hMj…hNhQhSh­hU}rµ(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr¶hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KlhG]r·h·)r¸}r¹(hLj´hU}rº(hY]hZ]r»(h¼j¶Xpy-modr¼ehX]hW]h[]uhMj²hG]r½hrX cpp-netlibr¾…r¿}rÀ(hLUhMj¸ubahShÂubaubhrX release.rÁ…rÂ}rÃ(hLX release.hMj…ubeubeubh_)rÄ}rÅ(hLUhMh`hNhQhShdhU}rÆ(hY]hZ]hX]hW]rÇh0ah[]rÈh auh]Ksh^hhG]rÉ(hk)rÊ}rË(hLXBuilding with CMakerÌhMjÄhNhQhShohU}rÍ(hY]hZ]hX]hW]h[]uh]Ksh^hhG]rÎhrXBuilding with CMakerÏ…rÐ}rÑ(hLjÌhMjÊubaubh„)rÒ}rÓ(hLXó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::hMjÄhNhQhShˆhU}rÔ(hY]hZ]hX]hW]h[]uh]Kuh^hhG]rÕ(hrX•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 rÖ…r×}rØ(hLX•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 hMjÒubh·)rÙ}rÚ(hLX ``cmake``hU}rÛ(hY]hZ]hX]hW]h[]uhMjÒhG]rÜhrXcmakerÝ…rÞ}rß(hLUhMjÙubahShÂubhrX' command at the top-level directory of rà…rá}râ(hLX' command at the top-level directory of hMjÒubh©)rã}rä(hLX:mod:`cpp-netlib`råhMjÒhNhQhSh­hU}ræ(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrçhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KuhG]rèh·)ré}rê(hLjåhU}rë(hY]hZ]rì(h¼jçXpy-modríehX]hW]h[]uhMjãhG]rîhrX cpp-netlibrï…rð}rñ(hLUhMjéubahShÂubaubhrX with additional parameters:rò…ró}rô(hLX with additional parameters:hMjÒubeubjY)rõ}rö(hLX±$ mkdir ~/cpp-netlib-build $ cd ~/cpp-netlib-build $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=gcc \ > -DCMAKE_CXX_COMPILER=g++ \ > ../cpp-netlibhMjÄhNhQhSj\hU}r÷(j^j_hW]hX]hY]hZ]h[]uh]Kzh^hhG]røhrX±$ mkdir ~/cpp-netlib-build $ cd ~/cpp-netlib-build $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=gcc \ > -DCMAKE_CXX_COMPILER=g++ \ > ../cpp-netlibrù…rú}rû(hLUhMjõubaubju)rü}rý(hLXÍWhile it's not compulsory, it's recommended that :mod:`cpp-netlib` is built outside the source directory. For the purposes of documentation, we'll assume that all builds are done in ``~/cpp-netlib-build``.hMjÄhNhQhSjxhU}rþ(hY]hZ]hX]hW]h[]uh]Nh^hhG]rÿh„)r}r(hLXÍWhile it's not compulsory, it's recommended that :mod:`cpp-netlib` is built outside the source directory. For the purposes of documentation, we'll assume that all builds are done in ``~/cpp-netlib-build``.hMjühNhQhShˆhU}r(hY]hZ]hX]hW]h[]uh]KhG]r(hrX1While it's not compulsory, it's recommended that r…r}r(hLX1While it's not compulsory, it's recommended that hMjubh©)r}r(hLX:mod:`cpp-netlib`r hMjhNhQhSh­hU}r (UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KhG]r h·)r }r(hLj hU}r(hY]hZ]r(h¼j Xpy-modrehX]hW]h[]uhMjhG]rhrX cpp-netlibr…r}r(hLUhMj ubahShÂubaubhrXt is built outside the source directory. For the purposes of documentation, we'll assume that all builds are done in r…r}r(hLXt is built outside the source directory. For the purposes of documentation, we'll assume that all builds are done in hMjubh·)r}r(hLX``~/cpp-netlib-build``hU}r(hY]hZ]hX]hW]h[]uhMjhG]rhrX~/cpp-netlib-buildr…r}r(hLUhMjubahShÂubhrX.…r }r!(hLX.hMjubeubaubh_)r"}r#(hLUhMjÄhNhQhShdhU}r$(hY]hZ]hX]hW]r%hDah[]r&hauh]K‡h^hhG]r'(hk)r(}r)(hLXBuilding on Linuxr*hMj"hNhQhShohU}r+(hY]hZ]hX]hW]h[]uh]K‡h^hhG]r,hrXBuilding on Linuxr-…r.}r/(hLj*hMj(ubaubh„)r0}r1(hLXú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 ``~/cpp-netlib-build``::hMj"hNhQhShˆhU}r2(hY]hZ]hX]hW]h[]uh]K‰h^hhG]r3(hrXƒOn Linux, this will generate the appropriate Makefiles that will enable you to build and run the tests and examples that come with r4…r5}r6(hLXƒOn Linux, this will generate the appropriate Makefiles that will enable you to build and run the tests and examples that come with hMj0ubh©)r7}r8(hLX:mod:`cpp-netlib`r9hMj0hNhQhSh­hU}r:(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr;hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K‰hG]r<h·)r=}r>(hLj9hU}r?(hY]hZ]r@(h¼j;Xpy-modrAehX]hW]h[]uhMj7hG]rBhrX cpp-netlibrC…rD}rE(hLUhMj=ubahShÂubaubhrX". To build the tests, you can run rF…rG}rH(hLX". To build the tests, you can run hMj0ubh·)rI}rJ(hLX``make``hU}rK(hY]hZ]hX]hW]h[]uhMj0hG]rLhrXmakerM…rN}rO(hLUhMjIubahShÂubhrX$ in the same top-level directory of rP…rQ}rR(hLX$ in the same top-level directory of hMj0ubh·)rS}rT(hLX``~/cpp-netlib-build``hU}rU(hY]hZ]hX]hW]h[]uhMj0hG]rVhrX~/cpp-netlib-buildrW…rX}rY(hLUhMjSubahShÂubhrX:…rZ}r[(hLX:hMj0ubeubjY)r\}r](hLX$ makehMj"hNhQhSj\hU}r^(j^j_hW]hX]hY]hZ]h[]uh]KŽh^hhG]r_hrX$ maker`…ra}rb(hLUhMj\ubaubju)rc}rd(hLXJust 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. However, this compile-time burden is much reduced in recent versions.hMj"hNhQhSjxhU}re(hY]hZ]hX]hW]h[]uh]Nh^hhG]rf(h„)rg}rh(hLXî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::hMjchNhQhShˆhU}ri(hY]hZ]hX]hW]h[]uh]KhG]rj(hrX5Just like with traditional GNU Make, you can add the rk…rl}rm(hLX5Just like with traditional GNU Make, you can add the hMjgubh·)rn}ro(hLX``-j``hU}rp(hY]hZ]hX]hW]h[]uhMjghG]rqhrX-jrr…rs}rt(hLUhMjnubahShÂubhrX² 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:ru…rv}rw(hLX² 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:hMjgubeubjY)rx}ry(hLXmake -j4hMjchSj\hU}rz(j^j_hW]hX]hY]hZ]h[]uh]K•hG]r{hrXmake -j4r|…r}}r~(hLUhMjxubaubh„)r}r€(hLXAs 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. However, this compile-time burden is much reduced in recent versions.hMjchNhQhShˆhU}r(hY]hZ]hX]hW]h[]uh]K—hG]r‚(hrX As a caveat, rƒ…r„}r…(hLX As a caveat, hMjubh©)r†}r‡(hLX:mod:`cpp-netlib`rˆhMjhNhQhSh­hU}r‰(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrŠhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K—hG]r‹h·)rŒ}r(hLjˆhU}rŽ(hY]hZ]r(h¼jŠXpy-modrehX]hW]h[]uhMj†hG]r‘hrX cpp-netlibr’…r“}r”(hLUhMjŒubahShÂubaubhrX• 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 r•…r–}r—(hLX• 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 hMjubh™)r˜}r™(hLX thrashing_hÈKhMjhSh¡hU}rš(UnameX thrashingr›hÊX9http://en.wikipedia.org/wiki/Thrashing_(computer_science)rœhW]hX]hY]hZ]h[]uhG]rhrX thrashingrž…rŸ}r (hLUhMj˜ubaubhrXT your system. However, this compile-time burden is much reduced in recent versions.r¡…r¢}r£(hLXT your system. However, this compile-time burden is much reduced in recent versions.hMjubeubeubhI)r¤}r¥(hLXH.. _thrashing: http://en.wikipedia.org/wiki/Thrashing_(computer_science)jKhMj"hNhQhShThU}r¦(hÊjœhW]r§hFahX]hY]hZ]h[]r¨h!auh]Kœh^hhG]ubh„)r©}rª(hLXIOnce the build has completed, you can now run the test suite by issuing::r«hMj"hNhQhShˆhU}r¬(hY]hZ]hX]hW]h[]uh]Kžh^hhG]r­hrXHOnce the build has completed, you can now run the test suite by issuing:r®…r¯}r°(hLXHOnce the build has completed, you can now run the test suite by issuing:hMj©ubaubjY)r±}r²(hLX $ make testhMj"hNhQhSj\hU}r³(j^j_hW]hX]hY]hZ]h[]uh]K h^hhG]r´hrX $ make testrµ…r¶}r·(hLUhMj±ubaubh„)r¸}r¹(hLX.You can install :mod:`cpp-netlib` by issuing::rºhMj"hNhQhShˆhU}r»(hY]hZ]hX]hW]h[]uh]K¢h^hhG]r¼(hrXYou can install r½…r¾}r¿(hLXYou can install hMj¸ubh©)rÀ}rÁ(hLX:mod:`cpp-netlib`rÂhMj¸hNhQhSh­hU}rÃ(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrÄhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K¢hG]rÅh·)rÆ}rÇ(hLjÂhU}rÈ(hY]hZ]rÉ(h¼jÄXpy-modrÊehX]hW]h[]uhMjÀhG]rËhrX cpp-netlibrÌ…rÍ}rÎ(hLUhMjÆubahShÂubaubhrX by issuing:rÏ…rÐ}rÑ(hLX by issuing:hMj¸ubeubjY)rÒ}rÓ(hLX$ sudo make installhMj"hNhQhSj\hU}rÔ(j^j_hW]hX]hY]hZ]h[]uh]K¤h^hhG]rÕhrX$ sudo make installrÖ…r×}rØ(hLUhMjÒubaubh„)rÙ}rÚ(hLX?By default this installs :mod:`cpp-netlib` into ``/usr/local``.rÛhMj"hNhQhShˆhU}rÜ(hY]hZ]hX]hW]h[]uh]K¦h^hhG]rÝ(hrXBy default this installs rÞ…rß}rà(hLXBy default this installs hMjÙubh©)rá}râ(hLX:mod:`cpp-netlib`rãhMjÙhNhQhSh­hU}rä(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyråhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K¦hG]ræh·)rç}rè(hLjãhU}ré(hY]hZ]rê(h¼jåXpy-modrëehX]hW]h[]uhMjáhG]rìhrX cpp-netlibrí…rî}rï(hLUhMjçubahShÂubaubhrX into rð…rñ}rò(hLX into hMjÙubh·)ró}rô(hLX``/usr/local``hU}rõ(hY]hZ]hX]hW]h[]uhMjÙhG]röhrX /usr/localr÷…rø}rù(hLUhMjóubahShÂubhrX.…rú}rû(hLX.hMjÙubeubju)rü}rý(hLXAs of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using GCC on Linux these are:: libcppnetlib-client-connections.a libcppnetlib-server-parsers.a libcppnetlib-uri.a Users can find them in ``~/cpp-netlib-build/libs/network/src``.hMj"hNhQhSjxhU}rþ(hY]hZ]hX]hW]h[]uh]Nh^hhG]rÿ(h„)r}r(hLXgAs of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using GCC on Linux these are::hMjühNhQhShˆhU}r(hY]hZ]hX]hW]h[]uh]K¨hG]r(hrXAs of version 0.9.3, r…r}r(hLXAs of version 0.9.3, hMjubh©)r}r(hLX:mod:`cpp-netlib`r hMjhNhQhSh­hU}r (UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]K¨hG]r h·)r }r(hLj hU}r(hY]hZ]r(h¼j Xpy-modrehX]hW]h[]uhMjhG]rhrX cpp-netlibr…r}r(hLUhMj ubahShÂubaubhrX@ produces three static libraries. Using GCC on Linux these are:r…r}r(hLX@ produces three static libraries. Using GCC on Linux these are:hMjubeubjY)r}r(hLXRlibcppnetlib-client-connections.a libcppnetlib-server-parsers.a libcppnetlib-uri.ahMjühSj\hU}r(j^j_hW]hX]hY]hZ]h[]uh]K«hG]rhrXRlibcppnetlib-client-connections.a libcppnetlib-server-parsers.a libcppnetlib-uri.ar…r}r(hLUhMjubaubh„)r }r!(hLX?Users can find them in ``~/cpp-netlib-build/libs/network/src``.hMjühNhQhShˆhU}r"(hY]hZ]hX]hW]h[]uh]K¯hG]r#(hrXUsers can find them in r$…r%}r&(hLXUsers can find them in hMj ubh·)r'}r((hLX'``~/cpp-netlib-build/libs/network/src``hU}r)(hY]hZ]hX]hW]h[]uhMj hG]r*hrX#~/cpp-netlib-build/libs/network/srcr+…r,}r-(hLUhMj'ubahShÂubhrX.…r.}r/(hLX.hMj ubeubeubeubh_)r0}r1(hLUhMjÄhNhQhShdhU}r2(hY]hZ]hX]hW]r3h4ah[]r4hauh]K²h^hhG]r5(hk)r6}r7(hLXBuilding On Windowsr8hMj0hNhQhShohU}r9(hY]hZ]hX]hW]h[]uh]K²h^hhG]r:hrXBuilding On Windowsr;…r<}r=(hLj8hMj6ubaubh„)r>}r?(hLXfIf 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.hMj0hNhQhShˆhU}r@(hY]hZ]hX]hW]h[]uh]K´h^hhG]rA(hrXç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 rB…rC}rD(hLXç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 hMj>ubh·)rE}rF(hLX ``cmake``hU}rG(hY]hZ]hX]hW]h[]uhMj>hG]rHhrXcmakerI…rJ}rK(hLUhMjEubahShÂubhrX -- the file should be named rL…rM}rN(hLX -- the file should be named hMj>ubh·)rO}rP(hLX``CPP-NETLIB.sln``hU}rQ(hY]hZ]hX]hW]h[]uhMj>hG]rRhrXCPP-NETLIB.slnrS…rT}rU(hLUhMjOubahShÂubhrXG (the solution) along with a number of project files for Visual Studio.rV…rW}rX(hLXG (the solution) along with a number of project files for Visual Studio.hMj>ubeubju)rY}rZ(hLX As of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using Visual C++ on Windows they are:: cppnetlib-client-connections.lib cppnetlib-server-parsers.lib cppnetlib-uri.lib Users can find them in ``~/cpp-netlib-build/libs/network/src``.hMj0hNhQhSjxhU}r[(hY]hZ]hX]hW]h[]uh]Nh^hhG]r\(h„)r]}r^(hLXoAs of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using Visual C++ on Windows they are::hMjYhNhQhShˆhU}r_(hY]hZ]hX]hW]h[]uh]KºhG]r`(hrXAs of version 0.9.3, ra…rb}rc(hLXAs of version 0.9.3, hMj]ubh©)rd}re(hLX:mod:`cpp-netlib`rfhMj]hNhQhSh­hU}rg(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrhhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KºhG]rih·)rj}rk(hLjfhU}rl(hY]hZ]rm(h¼jhXpy-modrnehX]hW]h[]uhMjdhG]rohrX cpp-netlibrp…rq}rr(hLUhMjjubahShÂubaubhrXH produces three static libraries. Using Visual C++ on Windows they are:rs…rt}ru(hLXH produces three static libraries. Using Visual C++ on Windows they are:hMj]ubeubjY)rv}rw(hLXOcppnetlib-client-connections.lib cppnetlib-server-parsers.lib cppnetlib-uri.libhMjYhSj\hU}rx(j^j_hW]hX]hY]hZ]h[]uh]K½hG]ryhrXOcppnetlib-client-connections.lib cppnetlib-server-parsers.lib cppnetlib-uri.librz…r{}r|(hLUhMjvubaubh„)r}}r~(hLX?Users can find them in ``~/cpp-netlib-build/libs/network/src``.hMjYhNhQhShˆhU}r(hY]hZ]hX]hW]h[]uh]KÁhG]r€(hrXUsers can find them in r…r‚}rƒ(hLXUsers can find them in hMj}ubh·)r„}r…(hLX'``~/cpp-netlib-build/libs/network/src``hU}r†(hY]hZ]hX]hW]h[]uhMj}hG]r‡hrX#~/cpp-netlib-build/libs/network/srcrˆ…r‰}rŠ(hLUhMj„ubahShÂubhrX.…r‹}rŒ(hLX.hMj}ubeubeubeubeubh_)r}rŽ(hLUhMh`hNhQhShdhU}r(hY]hZ]hX]hW]rh.ah[]r‘h auh]KÄh^hhG]r’(hk)r“}r”(hLXUsing :mod:`cpp-netlib`r•hMjhNhQhShohU}r–(hY]hZ]hX]hW]h[]uh]KÄh^hhG]r—(hrXUsing r˜…r™}rš(hLXUsing r›hMj“ubh©)rœ}r(hLX:mod:`cpp-netlib`ržhMj“hNhQhSh­hU}rŸ(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KÃhG]r¡h·)r¢}r£(hLjžhU}r¤(hY]hZ]r¥(h¼j Xpy-modr¦ehX]hW]h[]uhMjœhG]r§hrX cpp-netlibr¨…r©}rª(hLUhMj¢ubahShÂubaubeubh_)r«}r¬(hLUhMjhNhQhShdhU}r­(hY]hZ]hX]hW]r®h@ah[]r¯hauh]KÇh^hhG]r°(hk)r±}r²(hLXCMake projectsr³hMj«hNhQhShohU}r´(hY]hZ]hX]hW]h[]uh]KÇh^hhG]rµhrXCMake projectsr¶…r·}r¸(hLj³hMj±ubaubh„)r¹}rº(hLXrProjects using CMake can add the following lines in their ``CMakeLists.txt`` to be able to use :mod:`cpp-netlib`::hMj«hNhQhShˆhU}r»(hY]hZ]hX]hW]h[]uh]KÉh^hhG]r¼(hrX:Projects using CMake can add the following lines in their r½…r¾}r¿(hLX:Projects using CMake can add the following lines in their hMj¹ubh·)rÀ}rÁ(hLX``CMakeLists.txt``hU}rÂ(hY]hZ]hX]hW]h[]uhMj¹hG]rÃhrXCMakeLists.txtrÄ…rÅ}rÆ(hLUhMjÀubahShÂubhrX to be able to use rÇ…rÈ}rÉ(hLX to be able to use hMj¹ubh©)rÊ}rË(hLX:mod:`cpp-netlib`rÌhMj¹hNhQhSh­hU}rÍ(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrÎhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KÉhG]rÏh·)rÐ}rÑ(hLjÌhU}rÒ(hY]hZ]rÓ(h¼jÎXpy-modrÔehX]hW]h[]uhMjÊhG]rÕhrX cpp-netlibrÖ…r×}rØ(hLUhMjÐubahShÂubaubhrX:…rÙ}rÚ(hLX:hMj¹ubeubjY)rÛ}rÜ(hLXÝset ( CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ~/cpp-netlib-build ) find_package ( cppnetlib 0.11.0 REQUIRED ) include_directories ( ${CPPNETLIB_INCLUDE_DIRS} ) target_link_libraries ( MyApplication ${CPPNETLIB_LIBRARIES} )hMj«hNhQhSj\hU}rÝ(j^j_hW]hX]hY]hZ]h[]uh]KÌh^hhG]rÞhrXÝset ( CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ~/cpp-netlib-build ) find_package ( cppnetlib 0.11.0 REQUIRED ) include_directories ( ${CPPNETLIB_INCLUDE_DIRS} ) target_link_libraries ( MyApplication ${CPPNETLIB_LIBRARIES} )rß…rà}rá(hLUhMjÛubaubju)râ}rã(hLXßSetting ``CMAKE_PREFIX_PATH`` is only required when :mod:`cpp-netlib` is not installed to a location that CMake searches. When :mod:`cpp-netlib` is installed to the default location (``/usr/local``), ``CMake`` can find it.hMj«hNhQhSjxhU}rä(hY]hZ]hX]hW]h[]uh]Nh^hhG]råh„)ræ}rç(hLXßSetting ``CMAKE_PREFIX_PATH`` is only required when :mod:`cpp-netlib` is not installed to a location that CMake searches. When :mod:`cpp-netlib` is installed to the default location (``/usr/local``), ``CMake`` can find it.hMjâhNhQhShˆhU}rè(hY]hZ]hX]hW]h[]uh]KÑhG]ré(hrXSetting rê…rë}rì(hLXSetting hMjæubh·)rí}rî(hLX``CMAKE_PREFIX_PATH``hU}rï(hY]hZ]hX]hW]h[]uhMjæhG]rðhrXCMAKE_PREFIX_PATHrñ…rò}ró(hLUhMjíubahShÂubhrX is only required when rô…rõ}rö(hLX is only required when hMjæubh©)r÷}rø(hLX:mod:`cpp-netlib`rùhMjæhNhQhSh­hU}rú(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrûhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KÑhG]rüh·)rý}rþ(hLjùhU}rÿ(hY]hZ]r(h¼jûXpy-modrehX]hW]h[]uhMj÷hG]rhrX cpp-netlibr…r}r(hLUhMjýubahShÂubaubhrX; is not installed to a location that CMake searches. When r…r}r(hLX; is not installed to a location that CMake searches. When hMjæubh©)r }r (hLX:mod:`cpp-netlib`r hMjæhNhQhSh­hU}r (UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyr hW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KÑhG]rh·)r}r(hLj hU}r(hY]hZ]r(h¼j Xpy-modrehX]hW]h[]uhMj hG]rhrX cpp-netlibr…r}r(hLUhMjubahShÂubaubhrX' is installed to the default location (r…r}r(hLX' is installed to the default location (hMjæubh·)r}r(hLX``/usr/local``hU}r(hY]hZ]hX]hW]h[]uhMjæhG]rhrX /usr/localr…r }r!(hLUhMjubahShÂubhrX), r"…r#}r$(hLX), hMjæubh·)r%}r&(hLX ``CMake``hU}r'(hY]hZ]hX]hW]h[]uhMjæhG]r(hrXCMaker)…r*}r+(hLUhMj%ubahShÂubhrX can find it.r,…r-}r.(hLX can find it.hMjæubeubaubju)r/}r0(hLXqWe assume that ``MyApplication`` is the application that you are building and which depends on :mod:`cpp-netlib`.hMj«hNhQhSjxhU}r1(hY]hZ]hX]hW]h[]uh]Nh^hhG]r2h„)r3}r4(hLXqWe assume that ``MyApplication`` is the application that you are building and which depends on :mod:`cpp-netlib`.hMj/hNhQhShˆhU}r5(hY]hZ]hX]hW]h[]uh]KÕhG]r6(hrXWe assume that r7…r8}r9(hLXWe assume that hMj3ubh·)r:}r;(hLX``MyApplication``hU}r<(hY]hZ]hX]hW]h[]uhMj3hG]r=hrX MyApplicationr>…r?}r@(hLUhMj:ubahShÂubhrX? is the application that you are building and which depends on rA…rB}rC(hLX? is the application that you are building and which depends on hMj3ubh©)rD}rE(hLX:mod:`cpp-netlib`rFhMj3hNhQhSh­hU}rG(UreftypeXmodh¯‰h°X cpp-netlibU refdomainXpyrHhW]hX]U refexplicit‰hY]hZ]h[]h²h³h´NhµNuh]KÕhG]rIh·)rJ}rK(hLjFhU}rL(hY]hZ]rM(h¼jHXpy-modrNehX]hW]h[]uhMjDhG]rOhrX cpp-netlibrP…rQ}rR(hLUhMjJubahShÂubaubhrX.…rS}rT(hLX.hMj3ubeubaubeubeubh_)rU}rV(hLUhMh`hNhQhShdhU}rW(hY]hZ]hX]hW]rXh;ah[]rYhauh]KÚh^hhG]rZ(hk)r[}r\(hLX!Reporting Issues, Getting Supportr]hMjUhNhQhShohU}r^(hY]hZ]hX]hW]h[]uh]KÚh^hhG]r_hrX!Reporting Issues, Getting Supportr`…ra}rb(hLj]hMj[ubaubh„)rc}rd(hLX‰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.rehMjUhNhQhShˆhU}rf(hY]hZ]hX]hW]h[]uh]KÜh^hhG]rghrX‰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.rh…ri}rj(hLjehMjcubaubh„)rk}rl(hLXÕ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/cpp-netlib/cpp-netlib/issues.hMjUhNhQhShˆhU}rm(hY]hZ]hX]hW]h[]uh]Kßh^hhG]rn(hrX¦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 ro…rp}rq(hLX¦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 hMjkubh™)rr}rs(hLX.http://github.com/cpp-netlib/cpp-netlib/issuesrthU}ru(UrefurijthW]hX]hY]hZ]h[]uhMjkhG]rvhrX.http://github.com/cpp-netlib/cpp-netlib/issuesrw…rx}ry(hLUhMjrubahSh¡ubhrX.…rz}r{(hLX.hMjkubeubh„)r|}r}(hLXÑ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 http://groups.google.com/forum/#!forum/cpp-netlib.hMjUhNhQhShˆhU}r~(hY]hZ]hX]hW]h[]uh]Kãh^hhG]r(hrXŸ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 r€…r}r‚(hLXŸ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 hMj|ubh™)rƒ}r„(hLX1http://groups.google.com/forum/#!forum/cpp-netlibr…hU}r†(Urefurij…hW]hX]hY]hZ]h[]uhMj|hG]r‡hrX1http://groups.google.com/forum/#!forum/cpp-netlibrˆ…r‰}rŠ(hLUhMjƒubahSh¡ubhrX.…r‹}rŒ(hLX.hMj|ubeubeubeubehLUU transformerrNU footnote_refsrŽ}rUrefnamesr}r‘(Xboost.date_time]r’jžaXgit]r“jFaj]r”jaXmsysgit]r•j°aj ]r–jaj›]r—j˜aXboost getting started]r˜j×aXboost web-site]r™jlaX subversion]ršjÂaX boost.regex]r›j©aXgithub]rœ(hÆjjeX boost.system]rj“aXgit documentation]ržjkaX pull requests]rŸj(aXcmake]r jQaXboost]r¡jaauUsymbol_footnotesr¢]r£Uautofootnote_refsr¤]r¥Usymbol_footnote_refsr¦]r§U citationsr¨]r©h^hU current_linerªNUtransform_messagesr«]r¬cdocutils.nodes system_message r­)r®}r¯(hLUhU}r°(hY]UlevelKhW]hX]UsourcehQhZ]h[]UlineKUtypeUINFOr±uhG]r²h„)r³}r´(hLUhU}rµ(hY]hZ]hX]hW]h[]uhMj®hG]r¶hrX5Hyperlink target "getting-started" is not referenced.r·…r¸}r¹(hLUhMj³ubahShˆubahSUsystem_messagerºubaUreporterr»NUid_startr¼KU autofootnotesr½]r¾U citation_refsr¿}rÀUindirect_targetsrÁ]rÂUsettingsrÃ(cdocutils.frontend Values rÄorÅ}rÆ(Ufootnote_backlinksrÇKUrecord_dependenciesrÈNU rfc_base_urlrÉUhttp://tools.ietf.org/html/rÊU tracebackrˈUpep_referencesrÌNUstrip_commentsrÍNU toc_backlinksrÎUentryrÏU language_coderÐUenrÑU datestamprÒNU report_levelrÓKU _destinationrÔNU halt_levelrÕKU strip_classesrÖNhoNUerror_encoding_error_handlerr×UbackslashreplacerØUdebugrÙNUembed_stylesheetrÚ‰Uoutput_encoding_error_handlerrÛUstrictrÜU sectnum_xformrÝKUdump_transformsrÞNU docinfo_xformrßKUwarning_streamràNUpep_file_url_templateráUpep-%04drâUexit_status_levelrãKUconfigräNUstrict_visitorråNUcloak_email_addressesræˆUtrim_footnote_reference_spacerç‰UenvrèNUdump_pseudo_xmlréNUexpose_internalsrêNUsectsubtitle_xformrë‰U source_linkrìNUrfc_referencesríNUoutput_encodingrîUutf-8rïU source_urlrðNUinput_encodingrñUutf-8ròU_disable_configróNU id_prefixrôUU tab_widthrõKUerror_encodingröUUS-ASCIIr÷U_sourcerøUE/Users/dean/Documents/cpp-netlib/libs/network/doc/getting_started.rstrùUgettext_compactrúˆU generatorrûNUdump_internalsrüNU smart_quotesrý‰U pep_base_urlrþUhttp://www.python.org/dev/peps/rÿUsyntax_highlightrUlongrUinput_encoding_error_handlerrjÜUauto_id_prefixrUidrUdoctitle_xformr‰Ustrip_elements_with_classesrNU _config_filesr]Ufile_insertion_enabledrˆU raw_enabledr KU dump_settingsr NubUsymbol_footnote_startr KUidsr }r (h@j«h6j¸h,jÂh.jh4j0h1jáh2j€h-j½h3jhCh`h/jh>h`h7jæh0jÄh9jâh=j³h?hvhXProject historyq?…q@}qA(h"h:h#h8ubaubcdocutils.nodes paragraph qB)qC}qD(h"XThe :mod:`cpp-netlib` was founded by Dean Michael Berris in 2007. Initially it consisted of a message template and an HTTP client. It found a home on Sourceforge_ but was migrated at the end of 2009 to Github_ where development is actively continued by a committed community.h#h h$h'h)U paragraphqEh+}qF(h-]h.]h/]h0]h2]uh4Kh5hh]qG(h>XThe qH…qI}qJ(h"XThe h#hCubcsphinx.addnodes pending_xref qK)qL}qM(h"X:mod:`cpp-netlib`qNh#hCh$h'h)U pending_xrefqOh+}qP(UreftypeXmodUrefwarnqQ‰U reftargetqRX cpp-netlibU refdomainXpyqSh0]h/]U refexplicit‰h-]h.]h2]UrefdocqTXhistoryqUUpy:classqVNU py:moduleqWNuh4Kh]qXcdocutils.nodes literal qY)qZ}q[(h"hNh+}q\(h-]h.]q](Uxrefq^hSXpy-modq_eh/]h0]h2]uh#hLh]q`h>X cpp-netlibqa…qb}qc(h"Uh#hZubah)Uliteralqdubaubh>X‚ was founded by Dean Michael Berris in 2007. Initially it consisted of a message template and an HTTP client. It found a home on qe…qf}qg(h"X‚ was founded by Dean Michael Berris in 2007. Initially it consisted of a message template and an HTTP client. It found a home on h#hCubcdocutils.nodes reference qh)qi}qj(h"X Sourceforge_UresolvedqkKh#hCh)U referenceqlh+}qm(UnameX SourceforgeUrefuriqnX+http://sourceforge.net/projects/cpp-netlib/qoh0]h/]h-]h.]h2]uh]qph>X Sourceforgeqq…qr}qs(h"Uh#hiubaubh>X( but was migrated at the end of 2009 to qt…qu}qv(h"X( but was migrated at the end of 2009 to h#hCubhh)qw}qx(h"XGithub_hkKh#hCh)hlh+}qy(UnameXGithubhnX'http://github.com/cpp-netlib/cpp-netlibqzh0]h/]h-]h.]h2]uh]q{h>XGithubq|…q}}q~(h"Uh#hwubaubh>XB where development is actively continued by a committed community.q…q€}q(h"XB where development is actively continued by a committed community.h#hCubeubh)q‚}qƒ(h"Uh#h h$h'h)h*h+}q„(h-]h.]h/]h0]q…hah2]q†hauh4K h5hh]q‡(h7)qˆ}q‰(h"X MotivationqŠh#h‚h$h'h)h;h+}q‹(h-]h.]h/]h0]h2]uh4K h5hh]qŒh>X Motivationq…qŽ}q(h"hŠh#hˆubaubhB)q}q‘(h"X¦We're a group of C++ developers and we kept becoming annoyed that we had to repeatedly write the same code when building applications that needed to be network-aware.q’h#h‚h$h'h)hEh+}q“(h-]h.]h/]h0]h2]uh4K h5hh]q”h>X¦We're a group of C++ developers and we kept becoming annoyed that we had to repeatedly write the same code when building applications that needed to be network-aware.q•…q–}q—(h"h’h#hubaubhB)q˜}q™(h"XWe found that there was a lack of accessible networking libraries, either standard or open source, that fulfilled our needs. Such libraries exist for every other major language. So, building on top of `Boost.Asio`_, we decided to get together and build our own.h#h‚h$h'h)hEh+}qš(h-]h.]h/]h0]h2]uh4Kh5hh]q›(h>XËWe found that there was a lack of accessible networking libraries, either standard or open source, that fulfilled our needs. Such libraries exist for every other major language. So, building on top of qœ…q}qž(h"XËWe found that there was a lack of accessible networking libraries, either standard or open source, that fulfilled our needs. Such libraries exist for every other major language. So, building on top of h#h˜ubhh)qŸ}q (h"X `Boost.Asio`_hkKh#h˜h)hlh+}q¡(UnameX Boost.AsiohnXhttp://www.boost.org/libs/asio/q¢h0]h/]h-]h.]h2]uh]q£h>X Boost.Asioq¤…q¥}q¦(h"Uh#hŸubaubh>X/, we decided to get together and build our own.q§…q¨}q©(h"X/, we decided to get together and build our own.h#h˜ubeubeubh)qª}q«(h"Uh#h h$h'h)h*h+}q¬(h-]h.]h/]h0]q­hah2]q®hauh4Kh5hh]q¯(h7)q°}q±(h"X Objectivesq²h#hªh$h'h)h;h+}q³(h-]h.]h/]h0]h2]uh4Kh5hh]q´h>X Objectivesqµ…q¶}q·(h"h²h#h°ubaubhB)q¸}q¹(h"X/The objectives of the :mod:`cpp-netlib` are to:qºh#hªh$h'h)hEh+}q»(h-]h.]h/]h0]h2]uh4Kh5hh]q¼(h>XThe objectives of the q½…q¾}q¿(h"XThe objectives of the h#h¸ubhK)qÀ}qÁ(h"X:mod:`cpp-netlib`qÂh#h¸h$h'h)hOh+}qÃ(UreftypeXmodhQ‰hRX cpp-netlibU refdomainXpyqÄh0]h/]U refexplicit‰h-]h.]h2]hThUhVNhWNuh4Kh]qÅhY)qÆ}qÇ(h"hÂh+}qÈ(h-]h.]qÉ(h^hÄXpy-modqÊeh/]h0]h2]uh#hÀh]qËh>X cpp-netlibqÌ…qÍ}qÎ(h"Uh#hÆubah)hdubaubh>X are to:qÏ…qÐ}qÑ(h"X are to:h#h¸ubeubcdocutils.nodes bullet_list qÒ)qÓ}qÔ(h"Uh#hªh$h'h)U bullet_listqÕh+}qÖ(Ubulletq×X*h0]h/]h-]h.]h2]uh4Kh5hh]qØ(cdocutils.nodes list_item qÙ)qÚ}qÛ(h"XDdevelop a high quality, portable, easy to use C++ networking libraryqÜh#hÓh$h'h)U list_itemqÝh+}qÞ(h-]h.]h/]h0]h2]uh4Nh5hh]qßhB)qà}qá(h"hÜh#hÚh$h'h)hEh+}qâ(h-]h.]h/]h0]h2]uh4Kh]qãh>XDdevelop a high quality, portable, easy to use C++ networking libraryqä…qå}qæ(h"hÜh#hàubaubaubhÙ)qç}qè(h"X.enable developers to easily extend the libraryqéh#hÓh$h'h)hÝh+}qê(h-]h.]h/]h0]h2]uh4Nh5hh]qëhB)qì}qí(h"héh#hçh$h'h)hEh+}qî(h-]h.]h/]h0]h2]uh4Kh]qïh>X.enable developers to easily extend the libraryqð…qñ}qò(h"héh#hìubaubaubhÙ)qó}qô(h"XMlower the barrier to entry for cross-platform network-aware C++ applications h#hÓh$h'h)hÝh+}qõ(h-]h.]h/]h0]h2]uh4Nh5hh]qöhB)q÷}qø(h"XLlower the barrier to entry for cross-platform network-aware C++ applicationsqùh#hóh$h'h)hEh+}qú(h-]h.]h/]h0]h2]uh4Kh]qûh>XLlower the barrier to entry for cross-platform network-aware C++ applicationsqü…qý}qþ(h"hùh#h÷ubaubaubeubhB)qÿ}r(h"XòThe goal the of :mod:`cpp-netlib` has never been to build a fully-featured web server - there are plenty of excellent options already available. The niche that this library targets is for light-weight networking functionality for C++ applications that have demanding performance requirements or memory constraints, but that also need to be portable. This type of application is becoming increasingly common as software becomes more distributed, and applications need to communicate with services.h#hªh$h'h)hEh+}r(h-]h.]h/]h0]h2]uh4K h5hh]r(h>XThe goal the of r…r}r(h"XThe goal the of h#hÿubhK)r}r(h"X:mod:`cpp-netlib`rh#hÿh$h'h)hOh+}r (UreftypeXmodhQ‰hRX cpp-netlibU refdomainXpyr h0]h/]U refexplicit‰h-]h.]h2]hThUhVNhWNuh4K h]r hY)r }r (h"jh+}r(h-]h.]r(h^j Xpy-modreh/]h0]h2]uh#jh]rh>X cpp-netlibr…r}r(h"Uh#j ubah)hdubaubh>XÑ has never been to build a fully-featured web server - there are plenty of excellent options already available. The niche that this library targets is for light-weight networking functionality for C++ applications that have demanding performance requirements or memory constraints, but that also need to be portable. This type of application is becoming increasingly common as software becomes more distributed, and applications need to communicate with services.r…r}r(h"XÑ has never been to build a fully-featured web server - there are plenty of excellent options already available. The niche that this library targets is for light-weight networking functionality for C++ applications that have demanding performance requirements or memory constraints, but that also need to be portable. This type of application is becoming increasingly common as software becomes more distributed, and applications need to communicate with services.h#hÿubeubhB)r}r(h"X#While many languages provide direct library support for high level network programming, this feature is missing in C++. Therefore, this library has been developed with the intention of eventually being submitted to Boost_, a collection of general, high quality libraries for C++ developers.h#hªh$h'h)hEh+}r(h-]h.]h/]h0]h2]uh4K)h5hh]r(h>XØWhile many languages provide direct library support for high level network programming, this feature is missing in C++. Therefore, this library has been developed with the intention of eventually being submitted to r…r}r(h"XØWhile many languages provide direct library support for high level network programming, this feature is missing in C++. Therefore, this library has been developed with the intention of eventually being submitted to h#jubhh)r}r (h"XBoost_hkKh#jh)hlh+}r!(UnameXBoosthnXhttp://www.boost.org/r"h0]h/]h-]h.]h2]uh]r#h>XBoostr$…r%}r&(h"Uh#jubaubh>XE, a collection of general, high quality libraries for C++ developers.r'…r(}r)(h"XE, a collection of general, high quality libraries for C++ developers.h#jubeubhB)r*}r+(h"XˆEventually, the :mod:`cpp-netlib` will be extended to support many of the application layer protocols such as SMTP, FTP, SOAP, XMPP etc.h#hªh$h'h)hEh+}r,(h-]h.]h/]h0]h2]uh4K/h5hh]r-(h>XEventually, the r.…r/}r0(h"XEventually, the h#j*ubhK)r1}r2(h"X:mod:`cpp-netlib`r3h#j*h$h'h)hOh+}r4(UreftypeXmodhQ‰hRX cpp-netlibU refdomainXpyr5h0]h/]U refexplicit‰h-]h.]h2]hThUhVNhWNuh4K/h]r6hY)r7}r8(h"j3h+}r9(h-]h.]r:(h^j5Xpy-modr;eh/]h0]h2]uh#j1h]r<h>X cpp-netlibr=…r>}r?(h"Uh#j7ubah)hdubaubh>Xg will be extended to support many of the application layer protocols such as SMTP, FTP, SOAP, XMPP etc.r@…rA}rB(h"Xg will be extended to support many of the application layer protocols such as SMTP, FTP, SOAP, XMPP etc.h#j*ubeubcdocutils.nodes target rC)rD}rE(h"X<.. _Sourceforge: http://sourceforge.net/projects/cpp-netlib/U referencedrFKh#hªh$h'h)UtargetrGh+}rH(hnhoh0]rIhah/]h-]h.]h2]rJh auh4K3h5hh]ubjC)rK}rL(h"X3.. _Github: http://github.com/cpp-netlib/cpp-netlibjFKh#hªh$h'h)jGh+}rM(hnhzh0]rNhah/]h-]h.]h2]rOhauh4K4h5hh]ubjC)rP}rQ(h"X .. _Boost: http://www.boost.org/jFKh#hªh$h'h)jGh+}rR(hnj"h0]rShah/]h-]h.]h2]rTh auh4K5h5hh]ubjC)rU}rV(h"X1.. _`Boost.Asio`: http://www.boost.org/libs/asio/jFKh#hªh$h'h)jGh+}rW(hnh¢h0]rXhah/]h-]h.]h2]rYh auh4K6h5hh]ubeubeubah"UU transformerrZNU footnote_refsr[}r\Urefnamesr]}r^(X boost.asio]r_hŸaX sourceforge]r`hiaXboost]rajaXgithub]rbhwauUsymbol_footnotesrc]rdUautofootnote_refsre]rfUsymbol_footnote_refsrg]rhU citationsri]rjh5hU current_linerkNUtransform_messagesrl]rmUreporterrnNUid_startroKU autofootnotesrp]rqU citation_refsrr}rsUindirect_targetsrt]ruUsettingsrv(cdocutils.frontend Values rworx}ry(Ufootnote_backlinksrzKUrecord_dependenciesr{NU rfc_base_urlr|Uhttp://tools.ietf.org/html/r}U tracebackr~ˆUpep_referencesrNUstrip_commentsr€NU toc_backlinksrUentryr‚U language_coderƒUenr„U datestampr…NU report_levelr†KU _destinationr‡NU halt_levelrˆKU strip_classesr‰Nh;NUerror_encoding_error_handlerrŠUbackslashreplacer‹UdebugrŒNUembed_stylesheetr‰Uoutput_encoding_error_handlerrŽUstrictrU sectnum_xformrKUdump_transformsr‘NU docinfo_xformr’KUwarning_streamr“NUpep_file_url_templater”Upep-%04dr•Uexit_status_levelr–KUconfigr—NUstrict_visitorr˜NUcloak_email_addressesr™ˆUtrim_footnote_reference_spacerš‰Uenvr›NUdump_pseudo_xmlrœNUexpose_internalsrNUsectsubtitle_xformrž‰U source_linkrŸNUrfc_referencesr NUoutput_encodingr¡Uutf-8r¢U source_urlr£NUinput_encodingr¤Uutf-8r¥U_disable_configr¦NU id_prefixr§UU tab_widthr¨KUerror_encodingr©UUS-ASCIIrªU_sourcer«U=/Users/dean/Documents/cpp-netlib/libs/network/doc/history.rstr¬Ugettext_compactr­ˆU generatorr®NUdump_internalsr¯NU smart_quotesr°‰U pep_base_urlr±Uhttp://www.python.org/dev/peps/r²Usyntax_highlightr³Ulongr´Uinput_encoding_error_handlerrµjUauto_id_prefixr¶Uidr·Udoctitle_xformr¸‰Ustrip_elements_with_classesr¹NU _config_filesrº]Ufile_insertion_enabledr»ˆU raw_enabledr¼KU dump_settingsr½NubUsymbol_footnote_startr¾KUidsr¿}rÀ(hjUhh‚hjKhhªhjDhjPhh uUsubstitution_namesrÁ}rÂh)h5h+}rÃ(h-]h0]h/]Usourceh'h.]h2]uU footnotesrÄ]rÅUrefidsrÆ}rÇub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/in_depth.doctree000066400000000000000000000123241240331347200273530ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(X"an in-depth look at the cpp-netlibqNXin_depthqˆuUsubstitution_defsq}q Uparse_messagesq ]q Ucurrent_sourceq NU decorationq NUautofootnote_startqKUnameidsq}q(hU"an-in-depth-look-at-the-cpp-netlibqhUin-depthquUchildrenq]q(cdocutils.nodes target q)q}q(U rawsourceqX .. _in_depth:UparentqhUsourceqcdocutils.nodes reprunicode qX>/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth.rstq…q}qbUtagnameqUtargetq U attributesq!}q"(Uidsq#]Ubackrefsq$]Udupnamesq%]Uclassesq&]Unamesq']Urefidq(huUlineq)KUdocumentq*hh]ubcdocutils.nodes section q+)q,}q-(hUhhhhUexpect_referenced_by_nameq.}q/hhshUsectionq0h!}q1(h%]h&]h$]h#]q2(hheh']q3(hheuh)Kh*hUexpect_referenced_by_idq4}q5hhsh]q6(cdocutils.nodes title q7)q8}q9(hX)An in-depth look at the :mod:`cpp-netlib`q:hh,hhhUtitleq;h!}q<(h%]h&]h$]h#]h']uh)Kh*hh]q=(cdocutils.nodes Text q>XAn in-depth look at the q?…q@}qA(hXAn in-depth look at the qBhh8ubcsphinx.addnodes pending_xref qC)qD}qE(hX:mod:`cpp-netlib`qFhh8hhhU pending_xrefqGh!}qH(UreftypeXmodqIUrefwarnqJ‰U reftargetqKX cpp-netlibqLU refdomainXpyqMh#]h$]U refexplicit‰h%]h&]h']UrefdocqNXin_depthqOUpy:classqPNU py:moduleqQNuh)Kh]qRcdocutils.nodes literal qS)qT}qU(hhFh!}qV(h%]h&]qW(UxrefqXhMXpy-modqYeh$]h#]h']uhhDh]qZh>X cpp-netlibq[…q\}q](hUhhTubahUliteralq^ubaubeubcdocutils.nodes paragraph q_)q`}qa(hX¢The :mod:`cpp-netlib` is composed of three different sets of functionality: a **message** template, a **URI** template and different **protocol** implementations.hh,hhhU paragraphqbh!}qc(h%]h&]h$]h#]h']uh)Kh*hh]qd(h>XThe qe…qf}qg(hXThe hh`ubhC)qh}qi(hX:mod:`cpp-netlib`qjhh`hhhhGh!}qk(UreftypeXmodhJ‰hKX cpp-netlibU refdomainXpyqlh#]h$]U refexplicit‰h%]h&]h']hNhOhPNhQNuh)Kh]qmhS)qn}qo(hhjh!}qp(h%]h&]qq(hXhlXpy-modqreh$]h#]h']uhhhh]qsh>X cpp-netlibqt…qu}qv(hUhhnubahh^ubaubh>X9 is composed of three different sets of functionality: a qw…qx}qy(hX9 is composed of three different sets of functionality: a hh`ubcdocutils.nodes strong qz)q{}q|(hX **message**h!}q}(h%]h&]h$]h#]h']uhh`h]q~h>Xmessageq…q€}q(hUhh{ubahUstrongq‚ubh>X template, a qƒ…q„}q…(hX template, a hh`ubhz)q†}q‡(hX**URI**h!}qˆ(h%]h&]h$]h#]h']uhh`h]q‰h>XURIqŠ…q‹}qŒ(hUhh†ubahh‚ubh>X template and different q…qŽ}q(hX template and different hh`ubhz)q}q‘(hX **protocol**h!}q’(h%]h&]h$]h#]h']uhh`h]q“h>Xprotocolq”…q•}q–(hUhhubahh‚ubh>X implementations.q—…q˜}q™(hX implementations.hh`ubeubcdocutils.nodes compound qš)q›}qœ(hUhh,hhhUcompoundqh!}qž(h%]h&]qŸUtoctree-wrapperq ah$]h#]h']uh)Nh*hh]q¡csphinx.addnodes toctree q¢)q£}q¤(hUhh›hhhUtoctreeq¥h!}q¦(Unumberedq§KU includehiddenq¨‰hhOU titlesonlyq©‰Uglobqª‰h#]h$]h%]h&]h']Uentriesq«]q¬(NXin_depth/messageq­†q®NX in_depth/uriq¯†q°NX in_depth/httpq±†q²eUhiddenq³‰U includefilesq´]qµ(h­h¯h±eUmaxdepthq¶Kuh)K h]ubaubeubehUU transformerq·NU footnote_refsq¸}q¹Urefnamesqº}q»Usymbol_footnotesq¼]q½Uautofootnote_refsq¾]q¿Usymbol_footnote_refsqÀ]qÁU citationsqÂ]qÃh*hU current_lineqÄNUtransform_messagesqÅ]qÆcdocutils.nodes system_message qÇ)qÈ}qÉ(hUh!}qÊ(h%]UlevelKh#]h$]Usourcehh&]h']UlineKUtypeUINFOqËuh]qÌh_)qÍ}qÎ(hUh!}qÏ(h%]h&]h$]h#]h']uhhÈh]qÐh>X.Hyperlink target "in-depth" is not referenced.qÑ…qÒ}qÓ(hUhhÍubahhbubahUsystem_messageqÔubaUreporterqÕNUid_startqÖKU autofootnotesq×]qØU citation_refsqÙ}qÚUindirect_targetsqÛ]qÜUsettingsqÝ(cdocutils.frontend Values qÞoqß}qà(Ufootnote_backlinksqáKUrecord_dependenciesqâNU rfc_base_urlqãUhttp://tools.ietf.org/html/qäU tracebackqåˆUpep_referencesqæNUstrip_commentsqçNU toc_backlinksqèUentryqéU language_codeqêUenqëU datestampqìNU report_levelqíKU _destinationqîNU halt_levelqïKU strip_classesqðNh;NUerror_encoding_error_handlerqñUbackslashreplaceqòUdebugqóNUembed_stylesheetqô‰Uoutput_encoding_error_handlerqõUstrictqöU sectnum_xformq÷KUdump_transformsqøNU docinfo_xformqùKUwarning_streamqúNUpep_file_url_templateqûUpep-%04dqüUexit_status_levelqýKUconfigqþNUstrict_visitorqÿNUcloak_email_addressesrˆUtrim_footnote_reference_spacer‰UenvrNUdump_pseudo_xmlrNUexpose_internalsrNUsectsubtitle_xformr‰U source_linkrNUrfc_referencesrNUoutput_encodingrUutf-8r U source_urlr NUinput_encodingr Uutf-8r U_disable_configr NU id_prefixrUU tab_widthrKUerror_encodingrUUS-ASCIIrU_sourcerU>/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth.rstrUgettext_compactrˆU generatorrNUdump_internalsrNU smart_quotesr‰U pep_base_urlrUhttp://www.python.org/dev/peps/rUsyntax_highlightrUlongrUinput_encoding_error_handlerrhöUauto_id_prefixrUidrUdoctitle_xformr‰Ustrip_elements_with_classesr NU _config_filesr!]Ufile_insertion_enabledr"ˆU raw_enabledr#KU dump_settingsr$NubUsymbol_footnote_startr%KUidsr&}r'(hh,hh,uUsubstitution_namesr(}r)hh*h!}r*(h%]h#]h$]Usourcehh&]h']uU footnotesr+]r,Urefidsr-}r.h]r/hasub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/in_depth/000077500000000000000000000000001240331347200260025ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/in_depth/http.doctree000066400000000000000000000747441240331347200303500ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(X boost.threadqˆX http serverqNXhttp implementationqNX http clientq NuUsubstitution_defsq }q Uparse_messagesq ]q cdocutils.nodes system_message q)q}q(U rawsourceqUUparentqcdocutils.nodes section q)q}q(hUhh)q}q(hUhhUsourceqcdocutils.nodes reprunicode qXC/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth/http.rstq…q}qbUtagnameqUsectionqU attributesq}q (Udupnamesq!]Uclassesq"]Ubackrefsq#]Uidsq$]q%Uhttp-implementationq&aUnamesq']q(hauUlineq)KUdocumentq*hUchildrenq+]q,(cdocutils.nodes title q-)q.}q/(hXHTTP implementationq0hhhhhUtitleq1h}q2(h!]h"]h#]h$]h']uh)Kh*hh+]q3cdocutils.nodes Text q4XHTTP implementationq5…q6}q7(hh0hh.ubaubhh)q8}q9(hUhhhhhhh}q:(h!]h"]h#]h$]q;U http-serverq(h-)q?}q@(hX HTTP serverqAhh8hhhh1h}qB(h!]h"]h#]h$]h']uh)Kkh*hh+]qCh4X HTTP serverqD…qE}qF(hhAhh?ubaubcdocutils.nodes paragraph qG)qH}qI(hXÇAs with the HTTP client, the HTTP server that is provided with cpp-netlib is extensible through the tag mechanism and is embeddable. The template class declaration of ``basic_server`` is given below:hh8hhhU paragraphqJh}qK(h!]h"]h#]h$]h']uh)Kmh*hh+]qL(h4X§As with the HTTP client, the HTTP server that is provided with cpp-netlib is extensible through the tag mechanism and is embeddable. The template class declaration of qM…qN}qO(hX§As with the HTTP client, the HTTP server that is provided with cpp-netlib is extensible through the tag mechanism and is embeddable. The template class declaration of hhHubcdocutils.nodes literal qP)qQ}qR(hX``basic_server``h}qS(h!]h"]h#]h$]h']uhhHh+]qTh4X basic_serverqU…qV}qW(hUhhQubahUliteralqXubh4X is given below:qY…qZ}q[(hX is given below:hhHubeubcdocutils.nodes literal_block q\)q]}q^(hXynamespace boost { namespace network { namespace http { template basic_server; }}}hh8hhhU literal_blockq_h}q`(Ulinenosqa‰UlanguageqbXc++U xml:spaceqcUpreserveqdh$]h#]h!]h"]h']uh)Krh*hh+]qeh4Xynamespace boost { namespace network { namespace http { template basic_server; }}}qf…qg}qh(hUhh]ubaubhG)qi}qj(hX€The second template argument is used to specify the request handler type. The request handler type is a functor type which should overload the function call operator (``RequestHandler::operator()`` should be overloaded) that takes two parameters: the first one being a reference to a ``const basic_request`` and the second being a reference to a ``basic_response`` instance.hh8hhhhJh}qk(h!]h"]h#]h$]h']uh)K{h*hh+]ql(h4X§The second template argument is used to specify the request handler type. The request handler type is a functor type which should overload the function call operator (qm…qn}qo(hX§The second template argument is used to specify the request handler type. The request handler type is a functor type which should overload the function call operator (hhiubhP)qp}qq(hX``RequestHandler::operator()``h}qr(h!]h"]h#]h$]h']uhhih+]qsh4XRequestHandler::operator()qt…qu}qv(hUhhpubahhXubh4XW should be overloaded) that takes two parameters: the first one being a reference to a qw…qx}qy(hXW should be overloaded) that takes two parameters: the first one being a reference to a hhiubhP)qz}q{(hX``const basic_request``h}q|(h!]h"]h#]h$]h']uhhih+]q}h4Xconst basic_requestq~…q}q€(hUhhzubahhXubh4X' and the second being a reference to a q…q‚}qƒ(hX' and the second being a reference to a hhiubhP)q„}q…(hX``basic_response``h}q†(h!]h"]h#]h$]h']uhhih+]q‡h4Xbasic_responseqˆ…q‰}qŠ(hUhh„ubahhXubh4X instance.q‹…qŒ}q(hX instance.hhiubeubhG)qŽ}q(hXYAll the logic for parsing the HTTP request and building the ``const basic_request`` object resides internally in the ``basic_server`` template. Processing the request is delegated to the ``RequestHandler`` type, and the assumption of which would be that the response is formed inside the ``RequestHandler`` function call operator overload.hh8hhhhJh}q(h!]h"]h#]h$]h']uh)K‚h*hh+]q‘(h4X<All the logic for parsing the HTTP request and building the q’…q“}q”(hX<All the logic for parsing the HTTP request and building the hhŽubhP)q•}q–(hX``const basic_request``h}q—(h!]h"]h#]h$]h']uhhŽh+]q˜h4Xconst basic_requestq™…qš}q›(hUhh•ubahhXubh4X" object resides internally in the qœ…q}qž(hX" object resides internally in the hhŽubhP)qŸ}q (hX``basic_server``h}q¡(h!]h"]h#]h$]h']uhhŽh+]q¢h4X basic_serverq£…q¤}q¥(hUhhŸubahhXubh4X7 template. Processing the request is delegated to the q¦…q§}q¨(hX7 template. Processing the request is delegated to the hhŽubhP)q©}qª(hX``RequestHandler``h}q«(h!]h"]h#]h$]h']uhhŽh+]q¬h4XRequestHandlerq­…q®}q¯(hUhh©ubahhXubh4XS type, and the assumption of which would be that the response is formed inside the q°…q±}q²(hXS type, and the assumption of which would be that the response is formed inside the hhŽubhP)q³}q´(hX``RequestHandler``h}qµ(h!]h"]h#]h$]h']uhhŽh+]q¶h4XRequestHandlerq·…q¸}q¹(hUhh³ubahhXubh4X! function call operator overload.qº…q»}q¼(hX! function call operator overload.hhŽubeubhG)q½}q¾(hXThe ``basic_server`` template however is only an underlying implementation while the user-visible implementation is the ``http::server`` template. This simply specializes the ``basic_server`` template to use the ``default_`` tag and forwards the ``RequestHandler`` parameter:hh8hhhhJh}q¿(h!]h"]h#]h$]h']uh)K‰h*hh+]qÀ(h4XThe qÁ…qÂ}qÃ(hXThe hh½ubhP)qÄ}qÅ(hX``basic_server``h}qÆ(h!]h"]h#]h$]h']uhh½h+]qÇh4X basic_serverqÈ…qÉ}qÊ(hUhhÄubahhXubh4Xd template however is only an underlying implementation while the user-visible implementation is the qË…qÌ}qÍ(hXd template however is only an underlying implementation while the user-visible implementation is the hh½ubhP)qÎ}qÏ(hX``http::server``h}qÐ(h!]h"]h#]h$]h']uhh½h+]qÑh4X http::serverqÒ…qÓ}qÔ(hUhhÎubahhXubh4X' template. This simply specializes the qÕ…qÖ}q×(hX' template. This simply specializes the hh½ubhP)qØ}qÙ(hX``basic_server``h}qÚ(h!]h"]h#]h$]h']uhh½h+]qÛh4X basic_serverqÜ…qÝ}qÞ(hUhhØubahhXubh4X template to use the qß…qà}qá(hX template to use the hh½ubhP)qâ}qã(hX ``default_``h}qä(h!]h"]h#]h$]h']uhh½h+]qåh4Xdefault_qæ…qç}qè(hUhhâubahhXubh4X tag and forwards the qé…qê}që(hX tag and forwards the hh½ubhP)qì}qí(hX``RequestHandler``h}qî(h!]h"]h#]h$]h']uhh½h+]qïh4XRequestHandlerqð…qñ}qò(hUhhìubahhXubh4X parameter:qó…qô}qõ(hX parameter:hh½ubeubh\)qö}q÷(hX­namespace boost { namespace network { namespace http { template class server : public basic_server {}; }}}hh8hhhh_h}qø(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)Kh*hh+]qùh4X­namespace boost { namespace network { namespace http { template class server : public basic_server {}; }}}qú…qû}qü(hUhhöubaubhG)qý}qþ(hX¬To use the forwarding server type you just supply the request handler implementation as the parameter. For example, an "echo" server example might look something like this:qÿhh8hhhhJh}r(h!]h"]h#]h$]h']uh)K™h*hh+]rh4X¬To use the forwarding server type you just supply the request handler implementation as the parameter. For example, an "echo" server example might look something like this:r…r}r(hhÿhhýubaubh\)r}r(hXusing namespace boost::network; struct echo; typedef http::server echo_server; struct echo { void operator () (const echo_server::request &request, echo_server::response &response) const { std::string ip = source(request); response = echo_server::response::stock_reply( echo_server::response::ok, body(request)); std::cerr << "[" << ip << "]: " << request.uri << " status = " << echo_server::response::ok << '\n'; } };hh8hhhh_h}r(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)Kžh*hh+]rh4Xusing namespace boost::network; struct echo; typedef http::server echo_server; struct echo { void operator () (const echo_server::request &request, echo_server::response &response) const { std::string ip = source(request); response = echo_server::response::stock_reply( echo_server::response::ok, body(request)); std::cerr << "[" << ip << "]: " << request.uri << " status = " << echo_server::response::ok << '\n'; } };r …r }r (hUhjubaubhG)r }r (hXêHere, all we're doing is returning the original request body with an HTTP OK response (200). We are also printing the IP address from where the request came from. Notice that we are using a wrapper to access the source of the request.rhh8hhhhJh}r(h!]h"]h#]h$]h']uh)K±h*hh+]rh4XêHere, all we're doing is returning the original request body with an HTTP OK response (200). We are also printing the IP address from where the request came from. Notice that we are using a wrapper to access the source of the request.r…r}r(hjhj ubaubeubeubhhhhh}r(h!]h"]h#]h$]rU http-clientrah']rh auh)Kh*hh+]r(h-)r}r(hX HTTP clientrhhhhhh1h}r(h!]h"]h#]h$]h']uh)Kh*hh+]rh4X HTTP clientr…r}r (hjhjubaubhG)r!}r"(hX·At the heart of the HTTP client implementation is a single class aptly named ``basic_client``, which is also a template. The template ``basic_client`` takes three template parameters:hhhhhhJh}r#(h!]h"]h#]h$]h']uh)Kh*hh+]r$(h4XMAt the heart of the HTTP client implementation is a single class aptly named r%…r&}r'(hXMAt the heart of the HTTP client implementation is a single class aptly named hj!ubhP)r(}r)(hX``basic_client``h}r*(h!]h"]h#]h$]h']uhj!h+]r+h4X basic_clientr,…r-}r.(hUhj(ubahhXubh4X), which is also a template. The template r/…r0}r1(hX), which is also a template. The template hj!ubhP)r2}r3(hX``basic_client``h}r4(h!]h"]h#]h$]h']uhj!h+]r5h4X basic_clientr6…r7}r8(hUhj2ubahhXubh4X! takes three template parameters:r9…r:}r;(hX! takes three template parameters:hj!ubeubh\)r<}r=(hX°namespace boost { namespace http { template struct basic_client; } // namespace http } // namespace boosthhhhhh_h}r>(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)K h*hh+]r?h4X°namespace boost { namespace http { template struct basic_client; } // namespace http } // namespace boostr@…rA}rB(hUhj<ubaubhG)rC}rD(hXKThe ``Tag`` template parameter follows the same tag-dispatch mechanism to determine the behavior of the ``basic_client``. The interface of ``basic_client`` may change depending on certain properties defined for the tag you provide. Below is a table of predefined supported tags you can use in your overload of the ``basic_client``:hhhhhhJh}rE(h!]h"]h#]h$]h']uh)Kh*hh+]rF(h4XThe rG…rH}rI(hXThe hjCubhP)rJ}rK(hX``Tag``h}rL(h!]h"]h#]h$]h']uhjCh+]rMh4XTagrN…rO}rP(hUhjJubahhXubh4X] template parameter follows the same tag-dispatch mechanism to determine the behavior of the rQ…rR}rS(hX] template parameter follows the same tag-dispatch mechanism to determine the behavior of the hjCubhP)rT}rU(hX``basic_client``h}rV(h!]h"]h#]h$]h']uhjCh+]rWh4X basic_clientrX…rY}rZ(hUhjTubahhXubh4X. The interface of r[…r\}r](hX. The interface of hjCubhP)r^}r_(hX``basic_client``h}r`(h!]h"]h#]h$]h']uhjCh+]rah4X basic_clientrb…rc}rd(hUhj^ubahhXubh4XŸ may change depending on certain properties defined for the tag you provide. Below is a table of predefined supported tags you can use in your overload of the re…rf}rg(hXŸ may change depending on certain properties defined for the tag you provide. Below is a table of predefined supported tags you can use in your overload of the hjCubhP)rh}ri(hX``basic_client``h}rj(h!]h"]h#]h$]h']uhjCh+]rkh4X basic_clientrl…rm}rn(hUhjhubahhXubh4X:…ro}rp(hX:hjCubeubcdocutils.nodes transition rq)rr}rs(hX ------------rthhhhhU transitionruh}rv(h!]h"]h#]h$]h']uh)Kh*hh+]ubcdocutils.nodes table rw)rx}ry(hUhhhhXin_depth/http_client_tags.rstrz…r{}r|bhUtabler}h}r~(h!]h"]h#]h$]h']uh)Nh*hh+]rcdocutils.nodes tgroup r€)r}r‚(hUh}rƒ(h$]h#]h!]h"]h']UcolsKuhjxh+]r„(cdocutils.nodes colspec r…)r†}r‡(hUh}rˆ(h$]h#]h!]h"]h']UcolwidthK!uhjh+]hUcolspecr‰ubj…)rŠ}r‹(hUh}rŒ(h$]h#]h!]h"]h']UcolwidthK-uhjh+]hj‰ubcdocutils.nodes thead r)rŽ}r(hUh}r(h!]h"]h#]h$]h']uhjh+]r‘cdocutils.nodes row r’)r“}r”(hUh}r•(h!]h"]h#]h$]h']uhjŽh+]r–(cdocutils.nodes entry r—)r˜}r™(hUh}rš(h!]h"]h#]h$]h']uhj“h+]r›hG)rœ}r(hXTagržhj˜hj{hhJh}rŸ(h!]h"]h#]h$]h']uh)Kh+]r h4XTagr¡…r¢}r£(hjžhjœubaubahUentryr¤ubj—)r¥}r¦(hUh}r§(h!]h"]h#]h$]h']uhj“h+]r¨hG)r©}rª(hX Descriptionr«hj¥hj{hhJh}r¬(h!]h"]h#]h$]h']uh)Kh+]r­h4X Descriptionr®…r¯}r°(hj«hj©ubaubahj¤ubehUrowr±ubahUtheadr²ubcdocutils.nodes tbody r³)r´}rµ(hUh}r¶(h!]h"]h#]h$]h']uhjh+]r·(j’)r¸}r¹(hUh}rº(h!]h"]h#]h$]h']uhj´h+]r»(j—)r¼}r½(hUh}r¾(h!]h"]h#]h$]h']uhj¸h+]r¿hG)rÀ}rÁ(hXhttp_default_8bit_tcp_resolverÂhj¼hj{hhJh}rÃ(h!]h"]h#]h$]h']uh)Kh+]rÄh4Xhttp_default_8bit_tcp_resolverÅ…rÆ}rÇ(hjÂhjÀubaubahj¤ubj—)rÈ}rÉ(hUh}rÊ(h!]h"]h#]h$]h']uhj¸h+]rËhG)rÌ}rÍ(hX’This is the default HTTP implementation tag that resolves addresses with a TCP resolver and provides a synchronous/blocking HTTP client interface.rÎhjÈhj{hhJh}rÏ(h!]h"]h#]h$]h']uh)Kh+]rÐh4X’This is the default HTTP implementation tag that resolves addresses with a TCP resolver and provides a synchronous/blocking HTTP client interface.rÑ…rÒ}rÓ(hjÎhjÌubaubahj¤ubehj±ubj’)rÔ}rÕ(hUh}rÖ(h!]h"]h#]h$]h']uhj´h+]r×(j—)rØ}rÙ(hUh}rÚ(h!]h"]h#]h$]h']uhjÔh+]rÛhG)rÜ}rÝ(hXhttp_default_8bit_udp_resolverÞhjØhj{hhJh}rß(h!]h"]h#]h$]h']uh)K h+]ràh4Xhttp_default_8bit_udp_resolverá…râ}rã(hjÞhjÜubaubahj¤ubj—)rä}rå(hUh}ræ(h!]h"]h#]h$]h']uhjÔh+]rçhG)rè}ré(hX This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.rêhjähj{hhJh}rë(h!]h"]h#]h$]h']uh)K h+]rìh4X This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.rí…rî}rï(hjêhjèubaubahj¤ubehj±ubj’)rð}rñ(hUh}rò(h!]h"]h#]h$]h']uhj´h+]ró(j—)rô}rõ(hUh}rö(h!]h"]h#]h$]h']uhjðh+]r÷hG)rø}rù(hXhttp_keepalive_8bit_tcp_resolverúhjôhj{hhJh}rû(h!]h"]h#]h$]h']uh)Kh+]rüh4Xhttp_keepalive_8bit_tcp_resolverý…rþ}rÿ(hjúhjøubaubahj¤ubj—)r}r(hUh}r(h!]h"]h#]h$]h']uhjðh+]rhG)r}r(hXBThis tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the ``version_major`` and ``version_minor`` are both ``1``, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.hjhj{hhJh}r(h!]h"]h#]h$]h']uh)Kh+]r(h4XyThis tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the r…r }r (hXyThis tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the hjubhP)r }r (hX``version_major``h}r (h!]h"]h#]h$]h']uhjh+]rh4X version_majorr…r}r(hUhj ubahhXubh4X and r…r}r(hX and hjubhP)r}r(hX``version_minor``h}r(h!]h"]h#]h$]h']uhjh+]rh4X version_minorr…r}r(hUhjubahhXubh4X are both r…r}r(hX are both hjubhP)r}r (hX``1``h}r!(h!]h"]h#]h$]h']uhjh+]r"h4X1…r#}r$(hUhjubahhXubh4X“, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.r%…r&}r'(hX“, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.hjubeubahj¤ubehj±ubj’)r(}r)(hUh}r*(h!]h"]h#]h$]h']uhj´h+]r+(j—)r,}r-(hUh}r.(h!]h"]h#]h$]h']uhj(h+]r/hG)r0}r1(hXhttp_keepalive_8bit_udp_resolver2hj,hj{hhJh}r3(h!]h"]h#]h$]h']uh)Kh+]r4h4Xhttp_keepalive_8bit_udp_resolver5…r6}r7(hj2hj0ubaubahj¤ubj—)r8}r9(hUh}r:(h!]h"]h#]h$]h']uhj(h+]r;hG)r<}r=(hX This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.r>hj8hj{hhJh}r?(h!]h"]h#]h$]h']uh)Kh+]r@h4X This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.rA…rB}rC(hj>hj<ubaubahj¤ubehj±ubj’)rD}rE(hUh}rF(h!]h"]h#]h$]h']uhj´h+]rG(j—)rH}rI(hUh}rJ(h!]h"]h#]h$]h']uhjDh+]rKhG)rL}rM(hXhttp_async_8bit_tcp_resolverNhjHhj{hhJh}rO(h!]h"]h#]h$]h']uh)Kh+]rPh4Xhttp_async_8bit_tcp_resolverQ…rR}rS(hjNhjLubaubahj¤ubj—)rT}rU(hUh}rV(h!]h"]h#]h$]h']uhjDh+]rWhG)rX}rY(hXüThis tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of Boost.Thread_ shared futures to hold values. Users don't have to see this as they are implementation details.hjThj{hhJh}rZ(h!]h"]h#]h$]h']uh)Kh+]r[(h4XThis tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of r\…r]}r^(hXThis tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of hjXubcdocutils.nodes reference r_)r`}ra(hX Boost.Thread_UresolvedrbKhjXhU referencerch}rd(UnameX Boost.ThreadUrefurireX http://www.boost.org/libs/threadrfh$]h#]h!]h"]h']uh+]rgh4X Boost.Threadrh…ri}rj(hUhj`ubaubh4X` shared futures to hold values. Users don't have to see this as they are implementation details.rk…rl}rm(hX` shared futures to hold values. Users don't have to see this as they are implementation details.hjXubeubahj¤ubehj±ubj’)rn}ro(hUh}rp(h!]h"]h#]h$]h']uhj´h+]rq(j—)rr}rs(hUh}rt(h!]h"]h#]h$]h']uhjnh+]ruhG)rv}rw(hXhttp_async_8bit_udp_resolverxhjrhj{hhJh}ry(h!]h"]h#]h$]h']uh)K$h+]rzh4Xhttp_async_8bit_udp_resolver{…r|}r}(hjxhjvubaubahj¤ubj—)r~}r(hUh}r€(h!]h"]h#]h$]h']uhjnh+]rhG)r‚}rƒ(hX]This is similar to the above tag except that specifies the HTTP client to use a UDP resolver.r„hj~hj{hhJh}r…(h!]h"]h#]h$]h']uh)K$h+]r†h4X]This is similar to the above tag except that specifies the HTTP client to use a UDP resolver.r‡…rˆ}r‰(hj„hj‚ubaubahj¤ubehj±ubehUtbodyrŠubehUtgroupr‹ubaubcdocutils.nodes target rŒ)r}rŽ(hX2.. _Boost.Thread: http://www.boost.org/libs/threadU referencedrKhhhj{hUtargetrh}r‘(jejfh$]r’U boost-threadr“ah#]h!]h"]h']r”hauh)KIh*hh+]ubjŒ)r•}r–(hX2.. _Boost.Thread: http://www.boost.org/libs/threadjKhhhhhjh}r—(jeX http://www.boost.org/libs/threadh$]r˜Uid1r™ah#]h!]ršX boost.threadr›ah"]h']uh)KLh*hh+]ubhG)rœ}r(hXÐThe default typedef for the HTTP client that is provided uses the ``http_async_8bit_udp_resolve`` tag, and implements HTTP 1.1. The exact typedef is in the ``boost::network::http`` namespace as the following:hhhhhhJh}rž(h!]h"]h#]h$]h']uh)K#h*hh+]rŸ(h4XBThe default typedef for the HTTP client that is provided uses the r …r¡}r¢(hXBThe default typedef for the HTTP client that is provided uses the hjœubhP)r£}r¤(hX``http_async_8bit_udp_resolve``h}r¥(h!]h"]h#]h$]h']uhjœh+]r¦h4Xhttp_async_8bit_udp_resolver§…r¨}r©(hUhj£ubahhXubh4X; tag, and implements HTTP 1.1. The exact typedef is in the rª…r«}r¬(hX; tag, and implements HTTP 1.1. The exact typedef is in the hjœubhP)r­}r®(hX``boost::network::http``h}r¯(h!]h"]h#]h$]h']uhjœh+]r°h4Xboost::network::httpr±…r²}r³(hUhj­ubahhXubh4X namespace as the following:r´…rµ}r¶(hX namespace as the following:hjœubeubh\)r·}r¸(hXŽnamespace boost { namespace network { namespace http { typedef basic_client client; }}}hhhhhh_h}r¹(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)K'h*hh+]rºh4XŽnamespace boost { namespace network { namespace http { typedef basic_client client; }}}r»…r¼}r½(hUhj·ubaubhG)r¾}r¿(hXßThis type has nested typedefs for the correct types for the ``basic_request`` and ``basic_response`` templates. To use the correct types for ``basic_request`` or ``basic_response`` you can use these nested typedefs like so:hhhhhhJh}rÀ(h!]h"]h#]h$]h']uh)K1h*hh+]rÁ(h4X<This type has nested typedefs for the correct types for the rÂ…rÃ}rÄ(hX<This type has nested typedefs for the correct types for the hj¾ubhP)rÅ}rÆ(hX``basic_request``h}rÇ(h!]h"]h#]h$]h']uhj¾h+]rÈh4X basic_requestrÉ…rÊ}rË(hUhjÅubahhXubh4X and rÌ…rÍ}rÎ(hX and hj¾ubhP)rÏ}rÐ(hX``basic_response``h}rÑ(h!]h"]h#]h$]h']uhj¾h+]rÒh4Xbasic_responserÓ…rÔ}rÕ(hUhjÏubahhXubh4X) templates. To use the correct types for rÖ…r×}rØ(hX) templates. To use the correct types for hj¾ubhP)rÙ}rÚ(hX``basic_request``h}rÛ(h!]h"]h#]h$]h']uhj¾h+]rÜh4X basic_requestrÝ…rÞ}rß(hUhjÙubahhXubh4X or rà…rá}râ(hX or hj¾ubhP)rã}rä(hX``basic_response``h}rå(h!]h"]h#]h$]h']uhj¾h+]ræh4Xbasic_responserç…rè}ré(hUhjãubahhXubh4X+ you can use these nested typedefs like so:rê…rë}rì(hX+ you can use these nested typedefs like so:hj¾ubeubh\)rí}rî(hXÉboost::network::http::client::request request; boost::network::http::client::response response; // or... using namespace boost::network; http::client::request request; http::client::response response;hhhhhh_h}rï(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)K6h*hh+]rðh4XÉboost::network::http::client::request request; boost::network::http::client::response response; // or... using namespace boost::network; http::client::request request; http::client::response response;rñ…rò}ró(hUhjíubaubhG)rô}rõ(hXNTypical use cases for the HTTP client would look something like the following:röhhhhhhJh}r÷(h!]h"]h#]h$]h']uh)KAh*hh+]røh4XNTypical use cases for the HTTP client would look something like the following:rù…rú}rû(hjöhjôubaubh\)rü}rý(hXyusing namespace boost::network; http::request request("http://www.boost.org/"); request << header("Connection", "close");hhhhhh_h}rþ(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)KDh*hh+]rÿh4Xyusing namespace boost::network; http::request request("http://www.boost.org/"); request << header("Connection", "close");r…r}r(hUhjüubaubhG)r}r(hX©The ``basic_client`` implements all HTTP methods as member functions (HEAD, GET, POST, PUT, DELETE). Therefore, the code to make an HTTP request looks trivially simple:hhhhhhJh}r(h!]h"]h#]h$]h']uh)KKh*hh+]r(h4XThe r…r}r (hXThe hjubhP)r }r (hX``basic_client``h}r (h!]h"]h#]h$]h']uhjh+]r h4X basic_clientr…r}r(hUhj ubahhXubh4X• implements all HTTP methods as member functions (HEAD, GET, POST, PUT, DELETE). Therefore, the code to make an HTTP request looks trivially simple:r…r}r(hX• implements all HTTP methods as member functions (HEAD, GET, POST, PUT, DELETE). Therefore, the code to make an HTTP request looks trivially simple:hjubeubh\)r}r(hX£using namespace boost::network; http::client client; http::client::request request("http://www.boost.org/"); http::client::response response = client.get(request);hhhhhh_h}r(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)KPh*hh+]rh4X£using namespace boost::network; http::client client; http::client::request request("http://www.boost.org/"); http::client::response response = client.get(request);r…r}r(hUhjubaubhG)r}r(hXÀAccessing data from ``http::response`` is done using wrappers. To get the response headers, we use the ``headers`` wrapper which returns, in the default case, a multimap of strings to strings:hhhhhhJh}r(h!]h"]h#]h$]h']uh)KXh*hh+]r(h4XAccessing data from r…r }r!(hXAccessing data from hjubhP)r"}r#(hX``http::response``h}r$(h!]h"]h#]h$]h']uhjh+]r%h4Xhttp::responser&…r'}r((hUhj"ubahhXubh4XA is done using wrappers. To get the response headers, we use the r)…r*}r+(hXA is done using wrappers. To get the response headers, we use the hjubhP)r,}r-(hX ``headers``h}r.(h!]h"]h#]h$]h']uhjh+]r/h4Xheadersr0…r1}r2(hUhj,ubahhXubh4XN wrapper which returns, in the default case, a multimap of strings to strings:r3…r4}r5(hXN wrapper which returns, in the default case, a multimap of strings to strings:hjubeubh\)r6}r7(hXhusing namespace boost::network; typedef headers_range::type response_headers; boost::range_iterator::type iterator; response_headers headers_ = headers(response); for (iterator it = headers_.begin(); it != headers_.end(); ++it) { std::cout << it->first << ": " << it->second << std::endl; } std::cout << std::endl;hhhhhh_h}r8(ha‰hbXc++hchdh$]h#]h!]h"]h']uh)K]h*hh+]r9h4Xhusing namespace boost::network; typedef headers_range::type response_headers; boost::range_iterator::type iterator; response_headers headers_ = headers(response); for (iterator it = headers_.begin(); it != headers_.end(); ++it) { std::cout << it->first << ": " << it->second << std::endl; } std::cout << std::endl;r:…r;}r<(hUhj6ubaubeubhhhUsystem_messager=h}r>(h!]UlevelKh$]h#]r?j™aUsourcehh"]h']UlineK UtypeUINFOr@uh)K h*hh+]rAhG)rB}rC(hUh}rD(h!]h"]h#]h$]h']uhhh+]rEh4X/Duplicate explicit target name: "boost.thread".rF…rG}rH(hUhjBubahhJubaubaUcurrent_sourcerINU decorationrJNUautofootnote_startrKKUnameidsrL}rM(hj“hh(h!]h"]h#]h$]h%]uhh7h]q?(cdocutils.nodes entry q@)qA}qB(hUh}qC(h!]h"]h#]h$]h%]uhhh}r?(jjh$]r@hah#]h!]h"]h%]rAhauh&K)h'hh]ubehUU transformerrBNU footnote_refsrC}rDUrefnamesrE}rFX boost.thread]rGjasUsymbol_footnotesrH]rIUautofootnote_refsrJ]rKUsymbol_footnote_refsrL]rMU citationsrN]rOh'hU current_linerPNUtransform_messagesrQ]rRUreporterrSNUid_startrTKU autofootnotesrU]rVU citation_refsrW}rXUindirect_targetsrY]rZUsettingsr[(cdocutils.frontend Values r\or]}r^(Ufootnote_backlinksr_KUrecord_dependenciesr`NU rfc_base_urlraUhttp://tools.ietf.org/html/rbU tracebackrcˆUpep_referencesrdNUstrip_commentsreNU toc_backlinksrfhPU language_codergUenrhU datestampriNU report_levelrjKU _destinationrkNU halt_levelrlKU strip_classesrmNUtitlernNUerror_encoding_error_handlerroUbackslashreplacerpUdebugrqNUembed_stylesheetrr‰Uoutput_encoding_error_handlerrsUstrictrtU sectnum_xformruKUdump_transformsrvNU docinfo_xformrwKUwarning_streamrxNUpep_file_url_templateryUpep-%04drzUexit_status_levelr{KUconfigr|NUstrict_visitorr}NUcloak_email_addressesr~ˆUtrim_footnote_reference_spacer‰Uenvr€NUdump_pseudo_xmlrNUexpose_internalsr‚NUsectsubtitle_xformrƒ‰U source_linkr„NUrfc_referencesr…NUoutput_encodingr†Uutf-8r‡U source_urlrˆNUinput_encodingr‰Uutf-8rŠU_disable_configr‹NU id_prefixrŒUU tab_widthrKUerror_encodingrŽUUS-ASCIIrU_sourcerUO/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth/http_client_tags.rstr‘Ugettext_compactr’ˆU generatorr“NUdump_internalsr”NU smart_quotesr•‰U pep_base_urlr–Uhttp://www.python.org/dev/peps/r—Usyntax_highlightr˜Ulongr™Uinput_encoding_error_handlerršjtUauto_id_prefixr›UidrœUdoctitle_xformr‰Ustrip_elements_with_classesržNU _config_filesrŸ]Ufile_insertion_enabledr ˆU raw_enabledr¡KU dump_settingsr¢NubUsymbol_footnote_startr£KUidsr¤}r¥hj;sUsubstitution_namesr¦}r§hh'h}r¨(h!]h$]h#]Usourcehh"]h%]uU footnotesr©]rªUrefidsr«}r¬ub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/in_depth/message.doctree000066400000000000000000001471011240331347200310010ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(XwrappersqNX modifiersqNX basic_messageqNXmessage conceptq NXthe message templateq NX directivesq NX#directives, modifiers, and wrappersq NXadlq ˆuUsubstitution_defsq}qUparse_messagesq]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUwrappersqhU modifiersqhU basic-messageqh Umessage-conceptqh Uthe-message-templateqh U directivesqh U!directives-modifiers-and-wrappersqh UadlquUchildrenq]q cdocutils.nodes section q!)q"}q#(U rawsourceq$UUparentq%hUsourceq&cdocutils.nodes reprunicode q'XF/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth/message.rstq(…q)}q*bUtagnameq+Usectionq,U attributesq-}q.(Udupnamesq/]Uclassesq0]Ubackrefsq1]Uidsq2]q3haUnamesq4]q5h auUlineq6KUdocumentq7hh]q8(cdocutils.nodes title q9)q:}q;(h$XThe message templateq(h/]h0]h1]h2]h4]uh6Kh7hh]q?cdocutils.nodes Text q@XThe message templateqA…qB}qC(h$hh-}r?(h/]h0]h1]h2]h4]uh%j0h]r@hD)rA}rB(h$j>h%j<h&h)h+hHh-}rC(h/]h0]h1]h2]h4]uh6K.h]rD(h@XAn instance of rE…rF}rG(h$XAn instance of h%jAubhc)rH}rI(h$X**M**h-}rJ(h/]h0]h1]h2]h4]uh%jAh]rKh@XM…rL}rM(h$Uh%jHubah+hkubh@X.…rN}rO(h$X.h%jAubeubah+jubeubhþ)rP}rQ(h$Uh%hùh&h)h+jh-}rR(h/]h0]h1]h2]h4]uh6K/h7hh]rS(j)rT}rU(h$XSh-}rV(h/]h0]h1]h2]h4]uh%jPh]rWh@XS…rX}rY(h$XSh%jTubah+j ubj )rZ}r[(h$XA string type.r\h-}r](h/]h0]h1]h2]h4]uh%jPh]r^hD)r_}r`(h$j\h%jZh&h)h+hHh-}ra(h/]h0]h1]h2]h4]uh6K/h]rbh@XA string type.rc…rd}re(h$j\h%j_ubaubah+jubeubhþ)rf}rg(h$Uh%hùh&h)h+jh-}rh(h/]h0]h1]h2]h4]uh6K0h7hh]ri(j)rj}rk(h$Xs,k,vrlh-}rm(h/]h0]h1]h2]h4]uh%jfh]rnh@Xs,k,vro…rp}rq(h$jlh%jjubah+j ubj )rr}rs(h$XAn instance of **S**.rth-}ru(h/]h0]h1]h2]h4]uh%jfh]rvhD)rw}rx(h$jth%jrh&h)h+hHh-}ry(h/]h0]h1]h2]h4]uh6K0h]rz(h@XAn instance of r{…r|}r}(h$XAn instance of h%jwubhc)r~}r(h$X**S**h-}r€(h/]h0]h1]h2]h4]uh%jwh]rh@XS…r‚}rƒ(h$Uh%j~ubah+hkubh@X.…r„}r…(h$X.h%jwubeubah+jubeubhþ)r†}r‡(h$Uh%hùh&h)h+jh-}rˆ(h/]h0]h1]h2]h4]uh6K1h7hh]r‰(j)rŠ}r‹(h$XOh-}rŒ(h/]h0]h1]h2]h4]uh%j†h]rh@XO…rŽ}r(h$XOh%jŠubah+j ubj )r}r‘(h$XThe source type.r’h-}r“(h/]h0]h1]h2]h4]uh%j†h]r”hD)r•}r–(h$j’h%jh&h)h+hHh-}r—(h/]h0]h1]h2]h4]uh6K1h]r˜h@XThe source type.r™…rš}r›(h$j’h%j•ubaubah+jubeubhþ)rœ}r(h$Uh%hùh&h)h+jh-}rž(h/]h0]h1]h2]h4]uh6K2h7hh]rŸ(j)r }r¡(h$XDh-}r¢(h/]h0]h1]h2]h4]uh%jœh]r£h@XD…r¤}r¥(h$XDh%j ubah+j ubj )r¦}r§(h$XThe destination type.r¨h-}r©(h/]h0]h1]h2]h4]uh%jœh]rªhD)r«}r¬(h$j¨h%j¦h&h)h+hHh-}r­(h/]h0]h1]h2]h4]uh6K2h]r®h@XThe destination type.r¯…r°}r±(h$j¨h%j«ubaubah+jubeubhþ)r²}r³(h$Uh%hùh&h)h+jh-}r´(h/]h0]h1]h2]h4]uh6K3h7hh]rµ(j)r¶}r·(h$XBh-}r¸(h/]h0]h1]h2]h4]uh%j²h]r¹h@XB…rº}r»(h$XBh%j¶ubah+j ubj )r¼}r½(h$XThe body type.r¾h-}r¿(h/]h0]h1]h2]h4]uh%j²h]rÀhD)rÁ}rÂ(h$j¾h%j¼h&h)h+hHh-}rÃ(h/]h0]h1]h2]h4]uh6K3h]rÄh@XThe body type.rÅ…rÆ}rÇ(h$j¾h%jÁubaubah+jubeubhþ)rÈ}rÉ(h$Uh%hùh&h)h+jh-}rÊ(h/]h0]h1]h2]h4]uh6K4h7hh]rË(j)rÌ}rÍ(h$XTh-}rÎ(h/]h0]h1]h2]h4]uh%jÈh]rÏh@XT…rÐ}rÑ(h$XTh%jÌubah+j ubj )rÒ}rÓ(h$XThe Tag type. h-}rÔ(h/]h0]h1]h2]h4]uh%jÈh]rÕhD)rÖ}r×(h$X The Tag type.rØh%jÒh&h)h+hHh-}rÙ(h/]h0]h1]h2]h4]uh6K4h]rÚh@X The Tag type.rÛ…rÜ}rÝ(h$jØh%jÖubaubah+jubeubeubcdocutils.nodes table rÞ)rß}rà(h$Uh%hÇh&h)h+Utableráh-}râ(h/]h0]h1]h2]h4]uh6Nh7hh]rãcdocutils.nodes tgroup rä)rå}ræ(h$Uh-}rç(h2]h1]h/]h0]h4]UcolsKuh%jßh]rè(cdocutils.nodes colspec ré)rê}rë(h$Uh-}rì(h2]h1]h/]h0]h4]UcolwidthKuh%jåh]h+Ucolspecríubjé)rî}rï(h$Uh-}rð(h2]h1]h/]h0]h4]UcolwidthKuh%jåh]h+jíubjé)rñ}rò(h$Uh-}ró(h2]h1]h/]h0]h4]UcolwidthK)uh%jåh]h+jíubcdocutils.nodes thead rô)rõ}rö(h$Uh-}r÷(h/]h0]h1]h2]h4]uh%jåh]røcdocutils.nodes row rù)rú}rû(h$Uh-}rü(h/]h0]h1]h2]h4]uh%jõh]rý(cdocutils.nodes entry rþ)rÿ}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%júh]rhD)r}r(h$X Constructrh%jÿh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6K7h]rh@X Constructr…r }r (h$jh%jubaubah+Uentryr ubjþ)r }r (h$Uh-}r(h/]h0]h1]h2]h4]uh%júh]rhD)r}r(h$XResultrh%j h&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6K7h]rh@XResultr…r}r(h$jh%jubaubah+j ubjþ)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%júh]rhD)r}r(h$X Descriptionrh%jh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6K7h]r h@X Descriptionr!…r"}r#(h$jh%jubaubah+j ubeh+Urowr$ubah+Utheadr%ubcdocutils.nodes tbody r&)r'}r((h$Uh-}r)(h/]h0]h1]h2]h4]uh%jåh]r*(jù)r+}r,(h$Uh-}r-(h/]h0]h1]h2]h4]uh%j'h]r.(jþ)r/}r0(h$Uh-}r1(h/]h0]h1]h2]h4]uh%j+h]r2hD)r3}r4(h$X``typename M::tag``r5h%j/h&h)h+hHh-}r6(h/]h0]h1]h2]h4]uh6K9h]r7cdocutils.nodes literal r8)r9}r:(h$j5h-}r;(h/]h0]h1]h2]h4]uh%j3h]r<h@Xtypename M::tagr=…r>}r?(h$Uh%j9ubah+Uliteralr@ubaubah+j ubjþ)rA}rB(h$Uh-}rC(h/]h0]h1]h2]h4]uh%j+h]rDhD)rE}rF(h$XTh%jAh&h)h+hHh-}rG(h/]h0]h1]h2]h4]uh6K9h]rHh@XT…rI}rJ(h$XTh%jEubaubah+j ubjþ)rK}rL(h$Uh-}rM(h/]h0]h1]h2]h4]uh%j+h]rNhD)rO}rP(h$XThe nested tag type.rQh%jKh&h)h+hHh-}rR(h/]h0]h1]h2]h4]uh6K9h]rSh@XThe nested tag type.rT…rU}rV(h$jQh%jOubaubah+j ubeh+j$ubjù)rW}rX(h$Uh-}rY(h/]h0]h1]h2]h4]uh%j'h]rZ(jþ)r[}r\(h$Uh-}r](h/]h0]h1]h2]h4]uh%jWh]r^hD)r_}r`(h$X``M()``rah%j[h&h)h+hHh-}rb(h/]h0]h1]h2]h4]uh6K;h]rcj8)rd}re(h$jah-}rf(h/]h0]h1]h2]h4]uh%j_h]rgh@XM()rh…ri}rj(h$Uh%jdubah+j@ubaubah+j ubjþ)rk}rl(h$Uh-}rm(h/]h0]h1]h2]h4]uh%jWh]rnhD)ro}rp(h$X Instance of Mrqh%jkh&h)h+hHh-}rr(h/]h0]h1]h2]h4]uh6K;h]rsh@X Instance of Mrt…ru}rv(h$jqh%joubaubah+j ubjþ)rw}rx(h$Uh-}ry(h/]h0]h1]h2]h4]uh%jWh]rzhD)r{}r|(h$XDefault constructible.r}h%jwh&h)h+hHh-}r~(h/]h0]h1]h2]h4]uh6K;h]rh@XDefault constructible.r€…r}r‚(h$j}h%j{ubaubah+j ubeh+j$ubjù)rƒ}r„(h$Uh-}r…(h/]h0]h1]h2]h4]uh%j'h]r†(jþ)r‡}rˆ(h$Uh-}r‰(h/]h0]h1]h2]h4]uh%jƒh]rŠhD)r‹}rŒ(h$X``M(m)``rh%j‡h&h)h+hHh-}rŽ(h/]h0]h1]h2]h4]uh6K=h]rj8)r}r‘(h$jh-}r’(h/]h0]h1]h2]h4]uh%j‹h]r“h@XM(m)r”…r•}r–(h$Uh%jubah+j@ubaubah+j ubjþ)r—}r˜(h$Uh-}r™(h/]h0]h1]h2]h4]uh%jƒh]ršhD)r›}rœ(h$X Instance of Mrh%j—h&h)h+hHh-}rž(h/]h0]h1]h2]h4]uh6K=h]rŸh@X Instance of Mr …r¡}r¢(h$jh%j›ubaubah+j ubjþ)r£}r¤(h$Uh-}r¥(h/]h0]h1]h2]h4]uh%jƒh]r¦hD)r§}r¨(h$XCopy constructible.r©h%j£h&h)h+hHh-}rª(h/]h0]h1]h2]h4]uh6K=h]r«h@XCopy constructible.r¬…r­}r®(h$j©h%j§ubaubah+j ubeh+j$ubjù)r¯}r°(h$Uh-}r±(h/]h0]h1]h2]h4]uh%j'h]r²(jþ)r³}r´(h$Uh-}rµ(h/]h0]h1]h2]h4]uh%j¯h]r¶hD)r·}r¸(h$X ``m = n;``r¹h%j³h&h)h+hHh-}rº(h/]h0]h1]h2]h4]uh6K?h]r»j8)r¼}r½(h$j¹h-}r¾(h/]h0]h1]h2]h4]uh%j·h]r¿h@Xm = n;rÀ…rÁ}rÂ(h$Uh%j¼ubah+j@ubaubah+j ubjþ)rÃ}rÄ(h$Uh-}rÅ(h/]h0]h1]h2]h4]uh%j¯h]rÆhD)rÇ}rÈ(h$XReference to mrÉh%jÃh&h)h+hHh-}rÊ(h/]h0]h1]h2]h4]uh6K?h]rËh@XReference to mrÌ…rÍ}rÎ(h$jÉh%jÇubaubah+j ubjþ)rÏ}rÐ(h$Uh-}rÑ(h/]h0]h1]h2]h4]uh%j¯h]rÒhD)rÓ}rÔ(h$X Assignable.rÕh%jÏh&h)h+hHh-}rÖ(h/]h0]h1]h2]h4]uh6K?h]r×h@X Assignable.rØ…rÙ}rÚ(h$jÕh%jÓubaubah+j ubeh+j$ubjù)rÛ}rÜ(h$Uh-}rÝ(h/]h0]h1]h2]h4]uh%j'h]rÞ(jþ)rß}rà(h$Uh-}rá(h/]h0]h1]h2]h4]uh%jÛh]râhD)rã}rä(h$X``swap(m, n);``råh%jßh&h)h+hHh-}ræ(h/]h0]h1]h2]h4]uh6KAh]rçj8)rè}ré(h$jåh-}rê(h/]h0]h1]h2]h4]uh%jãh]rëh@X swap(m, n);rì…rí}rî(h$Uh%jèubah+j@ubaubah+j ubjþ)rï}rð(h$Uh-}rñ(h/]h0]h1]h2]h4]uh%jÛh]ròhD)ró}rô(h$X``void``rõh%jïh&h)h+hHh-}rö(h/]h0]h1]h2]h4]uh6KAh]r÷j8)rø}rù(h$jõh-}rú(h/]h0]h1]h2]h4]uh%jóh]rûh@Xvoidrü…rý}rþ(h$Uh%jøubah+j@ubaubah+j ubjþ)rÿ}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jÛh]rhD)r}r(h$X Swappable.rh%jÿh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6KAh]rh@X Swappable.r…r }r (h$jh%jubaubah+j ubeh+j$ubjù)r }r (h$Uh-}r (h/]h0]h1]h2]h4]uh%j'h]r(jþ)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%j h]rhD)r}r(h$X``source(m);``rh%jh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6KCh]rj8)r}r(h$jh-}r(h/]h0]h1]h2]h4]uh%jh]rh@X source(m);r…r}r(h$Uh%jubah+j@ubaubah+j ubjþ)r}r (h$Uh-}r!(h/]h0]h1]h2]h4]uh%j h]r"hD)r#}r$(h$XConvertible to Or%h%jh&h)h+hHh-}r&(h/]h0]h1]h2]h4]uh6KCh]r'h@XConvertible to Or(…r)}r*(h$j%h%j#ubaubah+j ubjþ)r+}r,(h$Uh-}r-(h/]h0]h1]h2]h4]uh%j h]r.hD)r/}r0(h$XRetrieve the source of ``m``.h%j+h&h)h+hHh-}r1(h/]h0]h1]h2]h4]uh6KCh]r2(h@XRetrieve the source of r3…r4}r5(h$XRetrieve the source of h%j/ubj8)r6}r7(h$X``m``h-}r8(h/]h0]h1]h2]h4]uh%j/h]r9h@Xm…r:}r;(h$Uh%j6ubah+j@ubh@X.…r<}r=(h$X.h%j/ubeubah+j ubeh+j$ubjù)r>}r?(h$Uh-}r@(h/]h0]h1]h2]h4]uh%j'h]rA(jþ)rB}rC(h$Uh-}rD(h/]h0]h1]h2]h4]uh%j>h]rEhD)rF}rG(h$X``destination(m);``rHh%jBh&h)h+hHh-}rI(h/]h0]h1]h2]h4]uh6KEh]rJj8)rK}rL(h$jHh-}rM(h/]h0]h1]h2]h4]uh%jFh]rNh@Xdestination(m);rO…rP}rQ(h$Uh%jKubah+j@ubaubah+j ubjþ)rR}rS(h$Uh-}rT(h/]h0]h1]h2]h4]uh%j>h]rUhD)rV}rW(h$XConvertible to DrXh%jRh&h)h+hHh-}rY(h/]h0]h1]h2]h4]uh6KEh]rZh@XConvertible to Dr[…r\}r](h$jXh%jVubaubah+j ubjþ)r^}r_(h$Uh-}r`(h/]h0]h1]h2]h4]uh%j>h]rahD)rb}rc(h$X"Retrieve the destination of ``m``.h%j^h&h)h+hHh-}rd(h/]h0]h1]h2]h4]uh6KEh]re(h@XRetrieve the destination of rf…rg}rh(h$XRetrieve the destination of h%jbubj8)ri}rj(h$X``m``h-}rk(h/]h0]h1]h2]h4]uh%jbh]rlh@Xm…rm}rn(h$Uh%jiubah+j@ubh@X.…ro}rp(h$X.h%jbubeubah+j ubeh+j$ubjù)rq}rr(h$Uh-}rs(h/]h0]h1]h2]h4]uh%j'h]rt(jþ)ru}rv(h$Uh-}rw(h/]h0]h1]h2]h4]uh%jqh]rxhD)ry}rz(h$X``headers(m);``r{h%juh&h)h+hHh-}r|(h/]h0]h1]h2]h4]uh6KGh]r}j8)r~}r(h$j{h-}r€(h/]h0]h1]h2]h4]uh%jyh]rh@X headers(m);r‚…rƒ}r„(h$Uh%j~ubah+j@ubaubah+j ubjþ)r…}r†(h$Uh-}r‡(h/]h0]h1]h2]h4]uh%jqh]rˆhD)r‰}rŠ(h$XConvertible to Hr‹h%j…h&h)h+hHh-}rŒ(h/]h0]h1]h2]h4]uh6KGh]rh@XConvertible to HrŽ…r}r(h$j‹h%j‰ubaubah+j ubjþ)r‘}r’(h$Uh-}r“(h/]h0]h1]h2]h4]uh%jqh]r”hD)r•}r–(h$XRetrieve the headers of ``m``.h%j‘h&h)h+hHh-}r—(h/]h0]h1]h2]h4]uh6KGh]r˜(h@XRetrieve the headers of r™…rš}r›(h$XRetrieve the headers of h%j•ubj8)rœ}r(h$X``m``h-}rž(h/]h0]h1]h2]h4]uh%j•h]rŸh@Xm…r }r¡(h$Uh%jœubah+j@ubh@X.…r¢}r£(h$X.h%j•ubeubah+j ubeh+j$ubjù)r¤}r¥(h$Uh-}r¦(h/]h0]h1]h2]h4]uh%j'h]r§(jþ)r¨}r©(h$Uh-}rª(h/]h0]h1]h2]h4]uh%j¤h]r«hD)r¬}r­(h$X ``body(m);``r®h%j¨h&h)h+hHh-}r¯(h/]h0]h1]h2]h4]uh6KIh]r°j8)r±}r²(h$j®h-}r³(h/]h0]h1]h2]h4]uh%j¬h]r´h@Xbody(m);rµ…r¶}r·(h$Uh%j±ubah+j@ubaubah+j ubjþ)r¸}r¹(h$Uh-}rº(h/]h0]h1]h2]h4]uh%j¤h]r»hD)r¼}r½(h$XConvertible to Br¾h%j¸h&h)h+hHh-}r¿(h/]h0]h1]h2]h4]uh6KIh]rÀh@XConvertible to BrÁ…rÂ}rÃ(h$j¾h%j¼ubaubah+j ubjþ)rÄ}rÅ(h$Uh-}rÆ(h/]h0]h1]h2]h4]uh%j¤h]rÇhD)rÈ}rÉ(h$XRetrieve the body of ``m``.h%jÄh&h)h+hHh-}rÊ(h/]h0]h1]h2]h4]uh6KIh]rË(h@XRetrieve the body of rÌ…rÍ}rÎ(h$XRetrieve the body of h%jÈubj8)rÏ}rÐ(h$X``m``h-}rÑ(h/]h0]h1]h2]h4]uh%jÈh]rÒh@Xm…rÓ}rÔ(h$Uh%jÏubah+j@ubh@X.…rÕ}rÖ(h$X.h%jÈubeubah+j ubeh+j$ubjù)r×}rØ(h$Uh-}rÙ(h/]h0]h1]h2]h4]uh%j'h]rÚ(jþ)rÛ}rÜ(h$Uh-}rÝ(h/]h0]h1]h2]h4]uh%j×h]rÞhD)rß}rà(h$X``m << source(s);``ráh%jÛh&h)h+hHh-}râ(h/]h0]h1]h2]h4]uh6KKh]rãj8)rä}rå(h$jáh-}ræ(h/]h0]h1]h2]h4]uh%jßh]rçh@Xm << source(s);rè…ré}rê(h$Uh%jäubah+j@ubaubah+j ubjþ)rë}rì(h$Uh-}rí(h/]h0]h1]h2]h4]uh%j×h]rîhD)rï}rð(h$X``M &``rñh%jëh&h)h+hHh-}rò(h/]h0]h1]h2]h4]uh6KKh]rój8)rô}rõ(h$jñh-}rö(h/]h0]h1]h2]h4]uh%jïh]r÷h@XM &rø…rù}rú(h$Uh%jôubah+j@ubaubah+j ubjþ)rû}rü(h$Uh-}rý(h/]h0]h1]h2]h4]uh%j×h]rþhD)rÿ}r(h$XSet the source of ``m``.h%jûh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6KKh]r(h@XSet the source of r…r}r(h$XSet the source of h%jÿubj8)r}r(h$X``m``h-}r(h/]h0]h1]h2]h4]uh%jÿh]r h@Xm…r }r (h$Uh%jubah+j@ubh@X.…r }r (h$X.h%jÿubeubah+j ubeh+j$ubjù)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%j'h]r(jþ)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jh]rhD)r}r(h$X``m << destination(s);``rh%jh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6KMh]rj8)r}r(h$jh-}r(h/]h0]h1]h2]h4]uh%jh]rh@Xm << destination(s);r…r }r!(h$Uh%jubah+j@ubaubah+j ubjþ)r"}r#(h$Uh-}r$(h/]h0]h1]h2]h4]uh%jh]r%hD)r&}r'(h$X``M &``r(h%j"h&h)h+hHh-}r)(h/]h0]h1]h2]h4]uh6KMh]r*j8)r+}r,(h$j(h-}r-(h/]h0]h1]h2]h4]uh%j&h]r.h@XM &r/…r0}r1(h$Uh%j+ubah+j@ubaubah+j ubjþ)r2}r3(h$Uh-}r4(h/]h0]h1]h2]h4]uh%jh]r5hD)r6}r7(h$XSet the destination of ``m``.h%j2h&h)h+hHh-}r8(h/]h0]h1]h2]h4]uh6KMh]r9(h@XSet the destination of r:…r;}r<(h$XSet the destination of h%j6ubj8)r=}r>(h$X``m``h-}r?(h/]h0]h1]h2]h4]uh%j6h]r@h@Xm…rA}rB(h$Uh%j=ubah+j@ubh@X.…rC}rD(h$X.h%j6ubeubah+j ubeh+j$ubjù)rE}rF(h$Uh-}rG(h/]h0]h1]h2]h4]uh%j'h]rH(jþ)rI}rJ(h$Uh-}rK(h/]h0]h1]h2]h4]uh%jEh]rLhD)rM}rN(h$X``m << header(k, v);``rOh%jIh&h)h+hHh-}rP(h/]h0]h1]h2]h4]uh6KOh]rQj8)rR}rS(h$jOh-}rT(h/]h0]h1]h2]h4]uh%jMh]rUh@Xm << header(k, v);rV…rW}rX(h$Uh%jRubah+j@ubaubah+j ubjþ)rY}rZ(h$Uh-}r[(h/]h0]h1]h2]h4]uh%jEh]r\hD)r]}r^(h$X``M &``r_h%jYh&h)h+hHh-}r`(h/]h0]h1]h2]h4]uh6KOh]raj8)rb}rc(h$j_h-}rd(h/]h0]h1]h2]h4]uh%j]h]reh@XM &rf…rg}rh(h$Uh%jbubah+j@ubaubah+j ubjþ)ri}rj(h$Uh-}rk(h/]h0]h1]h2]h4]uh%jEh]rlhD)rm}rn(h$XAdd a header to ``m``.h%jih&h)h+hHh-}ro(h/]h0]h1]h2]h4]uh6KOh]rp(h@XAdd a header to rq…rr}rs(h$XAdd a header to h%jmubj8)rt}ru(h$X``m``h-}rv(h/]h0]h1]h2]h4]uh%jmh]rwh@Xm…rx}ry(h$Uh%jtubah+j@ubh@X.…rz}r{(h$X.h%jmubeubah+j ubeh+j$ubjù)r|}r}(h$Uh-}r~(h/]h0]h1]h2]h4]uh%j'h]r(jþ)r€}r(h$Uh-}r‚(h/]h0]h1]h2]h4]uh%j|h]rƒhD)r„}r…(h$X``m << remove_header(k);``r†h%j€h&h)h+hHh-}r‡(h/]h0]h1]h2]h4]uh6KQh]rˆj8)r‰}rŠ(h$j†h-}r‹(h/]h0]h1]h2]h4]uh%j„h]rŒh@Xm << remove_header(k);r…rŽ}r(h$Uh%j‰ubah+j@ubaubah+j ubjþ)r}r‘(h$Uh-}r’(h/]h0]h1]h2]h4]uh%j|h]r“hD)r”}r•(h$X``M &``r–h%jh&h)h+hHh-}r—(h/]h0]h1]h2]h4]uh6KQh]r˜j8)r™}rš(h$j–h-}r›(h/]h0]h1]h2]h4]uh%j”h]rœh@XM &r…rž}rŸ(h$Uh%j™ubah+j@ubaubah+j ubjþ)r }r¡(h$Uh-}r¢(h/]h0]h1]h2]h4]uh%j|h]r£hD)r¤}r¥(h$XRemove a header from ``m``.h%j h&h)h+hHh-}r¦(h/]h0]h1]h2]h4]uh6KQh]r§(h@XRemove a header from r¨…r©}rª(h$XRemove a header from h%j¤ubj8)r«}r¬(h$X``m``h-}r­(h/]h0]h1]h2]h4]uh%j¤h]r®h@Xm…r¯}r°(h$Uh%j«ubah+j@ubh@X.…r±}r²(h$X.h%j¤ubeubah+j ubeh+j$ubjù)r³}r´(h$Uh-}rµ(h/]h0]h1]h2]h4]uh%j'h]r¶(jþ)r·}r¸(h$Uh-}r¹(h/]h0]h1]h2]h4]uh%j³h]rºhD)r»}r¼(h$X``m << body(s);``r½h%j·h&h)h+hHh-}r¾(h/]h0]h1]h2]h4]uh6KSh]r¿j8)rÀ}rÁ(h$j½h-}rÂ(h/]h0]h1]h2]h4]uh%j»h]rÃh@X m << body(s);rÄ…rÅ}rÆ(h$Uh%jÀubah+j@ubaubah+j ubjþ)rÇ}rÈ(h$Uh-}rÉ(h/]h0]h1]h2]h4]uh%j³h]rÊhD)rË}rÌ(h$X``M &``rÍh%jÇh&h)h+hHh-}rÎ(h/]h0]h1]h2]h4]uh6KSh]rÏj8)rÐ}rÑ(h$jÍh-}rÒ(h/]h0]h1]h2]h4]uh%jËh]rÓh@XM &rÔ…rÕ}rÖ(h$Uh%jÐubah+j@ubaubah+j ubjþ)r×}rØ(h$Uh-}rÙ(h/]h0]h1]h2]h4]uh%j³h]rÚhD)rÛ}rÜ(h$XSet the body of ``m``.h%j×h&h)h+hHh-}rÝ(h/]h0]h1]h2]h4]uh6KSh]rÞ(h@XSet the body of rß…rà}rá(h$XSet the body of h%jÛubj8)râ}rã(h$X``m``h-}rä(h/]h0]h1]h2]h4]uh%jÛh]råh@Xm…ræ}rç(h$Uh%jâubah+j@ubh@X.…rè}ré(h$X.h%jÛubeubah+j ubeh+j$ubjù)rê}rë(h$Uh-}rì(h/]h0]h1]h2]h4]uh%j'h]rí(jþ)rî}rï(h$Uh-}rð(h/]h0]h1]h2]h4]uh%jêh]rñhD)rò}ró(h$X``source(m,s);``rôh%jîh&h)h+hHh-}rõ(h/]h0]h1]h2]h4]uh6KUh]röj8)r÷}rø(h$jôh-}rù(h/]h0]h1]h2]h4]uh%jòh]rúh@X source(m,s);rû…rü}rý(h$Uh%j÷ubah+j@ubaubah+j ubjþ)rþ}rÿ(h$Uh-}r(h/]h0]h1]h2]h4]uh%jêh]rhD)r}r(h$X``void``rh%jþh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6KUh]rj8)r}r(h$jh-}r (h/]h0]h1]h2]h4]uh%jh]r h@Xvoidr …r }r (h$Uh%jubah+j@ubaubah+j ubjþ)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jêh]rhD)r}r(h$XSet the source of ``m``.h%jh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6KUh]r(h@XSet the source of r…r}r(h$XSet the source of h%jubj8)r}r(h$X``m``h-}r(h/]h0]h1]h2]h4]uh%jh]rh@Xm…r}r(h$Uh%jubah+j@ubh@X.…r}r (h$X.h%jubeubah+j ubeh+j$ubjù)r!}r"(h$Uh-}r#(h/]h0]h1]h2]h4]uh%j'h]r$(jþ)r%}r&(h$Uh-}r'(h/]h0]h1]h2]h4]uh%j!h]r(hD)r)}r*(h$X``destination(m,s);``r+h%j%h&h)h+hHh-}r,(h/]h0]h1]h2]h4]uh6KWh]r-j8)r.}r/(h$j+h-}r0(h/]h0]h1]h2]h4]uh%j)h]r1h@Xdestination(m,s);r2…r3}r4(h$Uh%j.ubah+j@ubaubah+j ubjþ)r5}r6(h$Uh-}r7(h/]h0]h1]h2]h4]uh%j!h]r8hD)r9}r:(h$X``void``r;h%j5h&h)h+hHh-}r<(h/]h0]h1]h2]h4]uh6KWh]r=j8)r>}r?(h$j;h-}r@(h/]h0]h1]h2]h4]uh%j9h]rAh@XvoidrB…rC}rD(h$Uh%j>ubah+j@ubaubah+j ubjþ)rE}rF(h$Uh-}rG(h/]h0]h1]h2]h4]uh%j!h]rHhD)rI}rJ(h$XSet the destination of ``m``.h%jEh&h)h+hHh-}rK(h/]h0]h1]h2]h4]uh6KWh]rL(h@XSet the destination of rM…rN}rO(h$XSet the destination of h%jIubj8)rP}rQ(h$X``m``h-}rR(h/]h0]h1]h2]h4]uh%jIh]rSh@Xm…rT}rU(h$Uh%jPubah+j@ubh@X.…rV}rW(h$X.h%jIubeubah+j ubeh+j$ubjù)rX}rY(h$Uh-}rZ(h/]h0]h1]h2]h4]uh%j'h]r[(jþ)r\}r](h$Uh-}r^(h/]h0]h1]h2]h4]uh%jXh]r_hD)r`}ra(h$X``add_header(m, k, v);``rbh%j\h&h)h+hHh-}rc(h/]h0]h1]h2]h4]uh6KYh]rdj8)re}rf(h$jbh-}rg(h/]h0]h1]h2]h4]uh%j`h]rhh@Xadd_header(m, k, v);ri…rj}rk(h$Uh%jeubah+j@ubaubah+j ubjþ)rl}rm(h$Uh-}rn(h/]h0]h1]h2]h4]uh%jXh]rohD)rp}rq(h$X``void``rrh%jlh&h)h+hHh-}rs(h/]h0]h1]h2]h4]uh6KYh]rtj8)ru}rv(h$jrh-}rw(h/]h0]h1]h2]h4]uh%jph]rxh@Xvoidry…rz}r{(h$Uh%juubah+j@ubaubah+j ubjþ)r|}r}(h$Uh-}r~(h/]h0]h1]h2]h4]uh%jXh]rhD)r€}r(h$XAdd a header to ``m``.h%j|h&h)h+hHh-}r‚(h/]h0]h1]h2]h4]uh6KYh]rƒ(h@XAdd a header to r„…r…}r†(h$XAdd a header to h%j€ubj8)r‡}rˆ(h$X``m``h-}r‰(h/]h0]h1]h2]h4]uh%j€h]rŠh@Xm…r‹}rŒ(h$Uh%j‡ubah+j@ubh@X.…r}rŽ(h$X.h%j€ubeubah+j ubeh+j$ubjù)r}r(h$Uh-}r‘(h/]h0]h1]h2]h4]uh%j'h]r’(jþ)r“}r”(h$Uh-}r•(h/]h0]h1]h2]h4]uh%jh]r–hD)r—}r˜(h$X``remove_header(m, k);``r™h%j“h&h)h+hHh-}rš(h/]h0]h1]h2]h4]uh6K[h]r›j8)rœ}r(h$j™h-}rž(h/]h0]h1]h2]h4]uh%j—h]rŸh@Xremove_header(m, k);r …r¡}r¢(h$Uh%jœubah+j@ubaubah+j ubjþ)r£}r¤(h$Uh-}r¥(h/]h0]h1]h2]h4]uh%jh]r¦hD)r§}r¨(h$X``void``r©h%j£h&h)h+hHh-}rª(h/]h0]h1]h2]h4]uh6K[h]r«j8)r¬}r­(h$j©h-}r®(h/]h0]h1]h2]h4]uh%j§h]r¯h@Xvoidr°…r±}r²(h$Uh%j¬ubah+j@ubaubah+j ubjþ)r³}r´(h$Uh-}rµ(h/]h0]h1]h2]h4]uh%jh]r¶hD)r·}r¸(h$XRemove a header from ``m``.h%j³h&h)h+hHh-}r¹(h/]h0]h1]h2]h4]uh6K[h]rº(h@XRemove a header from r»…r¼}r½(h$XRemove a header from h%j·ubj8)r¾}r¿(h$X``m``h-}rÀ(h/]h0]h1]h2]h4]uh%j·h]rÁh@Xm…rÂ}rÃ(h$Uh%j¾ubah+j@ubh@X.…rÄ}rÅ(h$X.h%j·ubeubah+j ubeh+j$ubjù)rÆ}rÇ(h$Uh-}rÈ(h/]h0]h1]h2]h4]uh%j'h]rÉ(jþ)rÊ}rË(h$Uh-}rÌ(h/]h0]h1]h2]h4]uh%jÆh]rÍhD)rÎ}rÏ(h$X``clear_headers(m);``rÐh%jÊh&h)h+hHh-}rÑ(h/]h0]h1]h2]h4]uh6K]h]rÒj8)rÓ}rÔ(h$jÐh-}rÕ(h/]h0]h1]h2]h4]uh%jÎh]rÖh@Xclear_headers(m);r×…rØ}rÙ(h$Uh%jÓubah+j@ubaubah+j ubjþ)rÚ}rÛ(h$Uh-}rÜ(h/]h0]h1]h2]h4]uh%jÆh]rÝhD)rÞ}rß(h$X``void``ràh%jÚh&h)h+hHh-}rá(h/]h0]h1]h2]h4]uh6K]h]râj8)rã}rä(h$jàh-}rå(h/]h0]h1]h2]h4]uh%jÞh]ræh@Xvoidrç…rè}ré(h$Uh%jãubah+j@ubaubah+j ubjþ)rê}rë(h$Uh-}rì(h/]h0]h1]h2]h4]uh%jÆh]ríhD)rî}rï(h$XClear the headers of ``m``.h%jêh&h)h+hHh-}rð(h/]h0]h1]h2]h4]uh6K]h]rñ(h@XClear the headers of rò…ró}rô(h$XClear the headers of h%jîubj8)rõ}rö(h$X``m``h-}r÷(h/]h0]h1]h2]h4]uh%jîh]røh@Xm…rù}rú(h$Uh%jõubah+j@ubh@X.…rû}rü(h$X.h%jîubeubah+j ubeh+j$ubjù)rý}rþ(h$Uh-}rÿ(h/]h0]h1]h2]h4]uh%j'h]r(jþ)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jýh]rhD)r}r(h$X``body(m,s);``rh%jh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6K_h]r j8)r }r (h$jh-}r (h/]h0]h1]h2]h4]uh%jh]r h@X body(m,s);r…r}r(h$Uh%j ubah+j@ubaubah+j ubjþ)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jýh]rhD)r}r(h$X``M &``rh%jh&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6K_h]rj8)r}r(h$jh-}r(h/]h0]h1]h2]h4]uh%jh]rh@XM &r…r}r (h$Uh%jubah+j@ubaubah+j ubjþ)r!}r"(h$Uh-}r#(h/]h0]h1]h2]h4]uh%jýh]r$hD)r%}r&(h$XSet the body of ``m``.h%j!h&h)h+hHh-}r'(h/]h0]h1]h2]h4]uh6K_h]r((h@XSet the body of r)…r*}r+(h$XSet the body of h%j%ubj8)r,}r-(h$X``m``h-}r.(h/]h0]h1]h2]h4]uh%j%h]r/h@Xm…r0}r1(h$Uh%j,ubah+j@ubh@X.…r2}r3(h$X.h%j%ubeubah+j ubeh+j$ubeh+Utbodyr4ubeh+Utgroupr5ubaubhD)r6}r7(h$X·Types that model the Message Concept are meant to encapsulate data that has a source, a destination, one or more named headers, and a body/payload. Because the accessors and the directives are not required to be part of the message type that models the Message Concept, a message can be implemented as a POD type and have all manipulations performed in the directive implementations, as well as value transformations done in the accessors.r8h%hÇh&h)h+hHh-}r9(h/]h0]h1]h2]h4]uh6Kbh7hh]r:h@X·Types that model the Message Concept are meant to encapsulate data that has a source, a destination, one or more named headers, and a body/payload. Because the accessors and the directives are not required to be part of the message type that models the Message Concept, a message can be implemented as a POD type and have all manipulations performed in the directive implementations, as well as value transformations done in the accessors.r;…r<}r=(h$j8h%j6ubaubeubh!)r>}r?(h$Uh%h"h&h)h+h,h-}r@(h/]h0]h1]h2]rAhah4]rBh auh6Kkh7hh]rC(h9)rD}rE(h$X#Directives, Modifiers, and WrappersrFh%j>h&h)h+h=h-}rG(h/]h0]h1]h2]h4]uh6Kkh7hh]rHh@X#Directives, Modifiers, and WrappersrI…rJ}rK(h$jFh%jDubaubhD)rL}rM(h$XœIn the Message Concept definition there are three basic constructs that follow a certain pattern. These patterns are Directives_, Modifiers_, and Wrappers_.h%j>h&h)h+hHh-}rN(h/]h0]h1]h2]h4]uh6Kmh7hh]rO(h@XuIn the Message Concept definition there are three basic constructs that follow a certain pattern. These patterns are rP…rQ}rR(h$XuIn the Message Concept definition there are three basic constructs that follow a certain pattern. These patterns are h%jLubh®)rS}rT(h$X Directives_h±Kh%jLh+h²h-}rU(UnameX Directivesh2]h1]h/]h0]h4]h´huh]rVh@X DirectivesrW…rX}rY(h$Uh%jSubaubh@X, rZ…r[}r\(h$X, h%jLubh®)r]}r^(h$X Modifiers_h±Kh%jLh+h²h-}r_(UnameX Modifiersh2]h1]h/]h0]h4]h´huh]r`h@X Modifiersra…rb}rc(h$Uh%j]ubaubh@X, and rd…re}rf(h$X, and h%jLubh®)rg}rh(h$X Wrappers_h±Kh%jLh+h²h-}ri(UnameXWrappersh2]h1]h/]h0]h4]h´huh]rjh@XWrappersrk…rl}rm(h$Uh%jgubaubh@X.…rn}ro(h$X.h%jLubeubh!)rp}rq(h$UhÉKh%j>h&h)h+h,h-}rr(h/]h0]h1]h2]rshah4]rth auh6Kqh7hh]ru(h9)rv}rw(h$X Directivesrxh%jph&h)h+h=h-}ry(h/]h0]h1]h2]h4]uh6Kqh7hh]rzh@X Directivesr{…r|}r}(h$jxh%jvubaubhD)r~}r(h$XàA directive is a function object that is applied to a Message. Directives encapsulate a set of operations that apply to messages. The general requirement for a Directive is that it should apply these operations on a message.r€h%jph&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6Ksh7hh]r‚h@XàA directive is a function object that is applied to a Message. Directives encapsulate a set of operations that apply to messages. The general requirement for a Directive is that it should apply these operations on a message.rƒ…r„}r…(h$j€h%j~ubaubhD)r†}r‡(h$XÉA directive may dispatch on the type of the message passed to it at the point of the function call. Typically, directives are generated using a factory function that returns the correct directive type.rˆh%jph&h)h+hHh-}r‰(h/]h0]h1]h2]h4]uh6Kwh7hh]rŠh@XÉA directive may dispatch on the type of the message passed to it at the point of the function call. Typically, directives are generated using a factory function that returns the correct directive type.r‹…rŒ}r(h$jˆh%j†ubaubhD)rŽ}r(h$XeFor a given directive ``foo_directive`` a generator function called ``foo`` is typically implemented:h%jph&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6K{h7hh]r‘(h@XFor a given directive r’…r“}r”(h$XFor a given directive h%jŽubj8)r•}r–(h$X``foo_directive``h-}r—(h/]h0]h1]h2]h4]uh%jŽh]r˜h@X foo_directiver™…rš}r›(h$Uh%j•ubah+j@ubh@X a generator function called rœ…r}rž(h$X a generator function called h%jŽubj8)rŸ}r (h$X``foo``h-}r¡(h/]h0]h1]h2]h4]uh%jŽh]r¢h@Xfoor£…r¤}r¥(h$Uh%jŸubah+j@ubh@X is typically implemented:r¦…r§}r¨(h$X is typically implemented:h%jŽubeubcdocutils.nodes literal_block r©)rª}r«(h$Xstruct foo_directive { template Message & operator()(Message & m) const { // do something to m return m; } }; foo_directive const foo() { return foo_directive(); } // to apply a directive, we use the << operator message m; m << foo();h%jph&h)h+U literal_blockr¬h-}r­(Ulinenosr®‰Ulanguager¯Xc++U xml:spacer°Upreserver±h2]h1]h/]h0]h4]uh6K~h7hh]r²h@Xstruct foo_directive { template Message & operator()(Message & m) const { // do something to m return m; } }; foo_directive const foo() { return foo_directive(); } // to apply a directive, we use the << operator message m; m << foo();r³…r´}rµ(h$Uh%jªubaubeubh!)r¶}r·(h$UhÉKh%j>h&h)h+h,h-}r¸(h/]h0]h1]h2]r¹hah4]rºhauh6K‘h7hh]r»(h9)r¼}r½(h$X Modifiersr¾h%j¶h&h)h+h=h-}r¿(h/]h0]h1]h2]h4]uh6K‘h7hh]rÀh@X ModifiersrÁ…rÂ}rÃ(h$j¾h%j¼ubaubhD)rÄ}rÅ(h$XìA modifier is generally defined as a free function that takes a reference to a non-const lvalue message as the first parameter, and any number of parameters. In the concept definition of the Message Concept, a modifier follows the form:rÆh%j¶h&h)h+hHh-}rÇ(h/]h0]h1]h2]h4]uh6K“h7hh]rÈh@XìA modifier is generally defined as a free function that takes a reference to a non-const lvalue message as the first parameter, and any number of parameters. In the concept definition of the Message Concept, a modifier follows the form:rÉ…rÊ}rË(h$jÆh%jÄubaubj©)rÌ}rÍ(h$Xmodifier(message, ...)h%j¶h&h)h+j¬h-}rÎ(j®‰j¯Xc++j°j±h2]h1]h/]h0]h4]uh6K—h7hh]rÏh@Xmodifier(message, ...)rÐ…rÑ}rÒ(h$Uh%jÌubaubhD)rÓ}rÔ(h$X Modifiers are meant to imply modifications on a message, which also allows for easier dispatch based on Argument Dependent Lookup (ADL_) on the type of the message. Note that Directives_ can be implemented in terms of Modifiers and vice versa, although that is not required nor specified.h%j¶h&h)h+hHh-}rÕ(h/]h0]h1]h2]h4]uh6K›h7hh]rÖ(h@XƒModifiers are meant to imply modifications on a message, which also allows for easier dispatch based on Argument Dependent Lookup (r×…rØ}rÙ(h$XƒModifiers are meant to imply modifications on a message, which also allows for easier dispatch based on Argument Dependent Lookup (h%jÓubh®)rÚ}rÛ(h$XADL_h±Kh%jÓh+h²h-}rÜ(UnameXADLUrefurirÝX;http://en.wikipedia.org/wiki/Argument-dependent_name_lookuprÞh2]h1]h/]h0]h4]uh]rßh@XADLrà…rá}râ(h$Uh%jÚubaubh@X() on the type of the message. Note that rã…rä}rå(h$X() on the type of the message. Note that h%jÓubh®)ræ}rç(h$X Directives_h±Kh%jÓh+h²h-}rè(UnameX Directivesh2]h1]h/]h0]h4]h´huh]réh@X Directivesrê…rë}rì(h$Uh%jæubaubh@Xf can be implemented in terms of Modifiers and vice versa, although that is not required nor specified.rí…rî}rï(h$Xf can be implemented in terms of Modifiers and vice versa, although that is not required nor specified.h%jÓubeubcdocutils.nodes target rð)rñ}rò(h$XD.. _ADL: http://en.wikipedia.org/wiki/Argument-dependent_name_lookuphÉKh%j¶h&h)h+Utargetróh-}rô(jÝjÞh2]rõhah1]h/]h0]h4]röh auh6K h7hh]ubeubh!)r÷}rø(h$UhÉKh%j>h&h)h+h,h-}rù(h/]h0]h1]h2]rúhah4]rûhauh6K£h7hh]rü(h9)rý}rþ(h$XWrappersrÿh%j÷h&h)h+h=h-}r(h/]h0]h1]h2]h4]uh6K£h7hh]rh@XWrappersr…r}r(h$jÿh%jýubaubhD)r}r(h$XôA Wrapper is basically an implementation detail that ensures that a given message, when wrapped, can be converted to the associated part of the message. A wrapper has a type that encapsulates the conversion logic from a message to a given type.rh%j÷h&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6K¥h7hh]r h@XôA Wrapper is basically an implementation detail that ensures that a given message, when wrapped, can be converted to the associated part of the message. A wrapper has a type that encapsulates the conversion logic from a message to a given type.r …r }r (h$jh%jubaubhD)r }r(h$XÈAn example of a Wrapper would be ``source_wrapper`` which would be returned by a call to the wrapper generator function ``source``. An example implementation of the ``source_wrapper`` would look like:h%j÷h&h)h+hHh-}r(h/]h0]h1]h2]h4]uh6Kªh7hh]r(h@X!An example of a Wrapper would be r…r}r(h$X!An example of a Wrapper would be h%j ubj8)r}r(h$X``source_wrapper``h-}r(h/]h0]h1]h2]h4]uh%j h]rh@Xsource_wrapperr…r}r(h$Uh%jubah+j@ubh@XE which would be returned by a call to the wrapper generator function r…r}r(h$XE which would be returned by a call to the wrapper generator function h%j ubj8)r}r(h$X ``source``h-}r (h/]h0]h1]h2]h4]uh%j h]r!h@Xsourcer"…r#}r$(h$Uh%jubah+j@ubh@X#. An example implementation of the r%…r&}r'(h$X#. An example implementation of the h%j ubj8)r(}r)(h$X``source_wrapper``h-}r*(h/]h0]h1]h2]h4]uh%j h]r+h@Xsource_wrapperr,…r-}r.(h$Uh%j(ubah+j@ubh@X would look like:r/…r0}r1(h$X would look like:h%j ubeubj©)r2}r3(h$XZtemplate class Message> struct source_wrapper { Message const & m; explicit source_wrapper(Message const & m) : m(m) {} typedef typename source::type source_type; operator source_type const & () { return m.source; } operator source_type const () { return m.source; } operator source_type () { return m.source; } }; template class Message> source_wrapper const source(Message const & message) { return source_wrapper(message); }h%j÷h&h)h+j¬h-}r4(j®‰j¯Xc++j°j±h2]h1]h/]h0]h4]uh6K®h7hh]r5h@XZtemplate class Message> struct source_wrapper { Message const & m; explicit source_wrapper(Message const & m) : m(m) {} typedef typename source::type source_type; operator source_type const & () { return m.source; } operator source_type const () { return m.source; } operator source_type () { return m.source; } }; template class Message> source_wrapper const source(Message const & message) { return source_wrapper(message); }r6…r7}r8(h$Uh%j2ubaubhD)r9}r:(h$XQThis pattern is similar to an adapter, but the specific notion of wrapping a data type (in this case, an object of a type that models the Message Concept) using an intermediary wrapper is what is pertained to by the Wrapper pattern. In this case, the Wrapper is ``source_wrapper`` while ``source`` is merely a wrapper generator function.h%j÷h&h)h+hHh-}r;(h/]h0]h1]h2]h4]uh6KÇh7hh]r<(h@XThis pattern is similar to an adapter, but the specific notion of wrapping a data type (in this case, an object of a type that models the Message Concept) using an intermediary wrapper is what is pertained to by the Wrapper pattern. In this case, the Wrapper is r=…r>}r?(h$XThis pattern is similar to an adapter, but the specific notion of wrapping a data type (in this case, an object of a type that models the Message Concept) using an intermediary wrapper is what is pertained to by the Wrapper pattern. In this case, the Wrapper is h%j9ubj8)r@}rA(h$X``source_wrapper``h-}rB(h/]h0]h1]h2]h4]uh%j9h]rCh@Xsource_wrapperrD…rE}rF(h$Uh%j@ubah+j@ubh@X while rG…rH}rI(h$X while h%j9ubj8)rJ}rK(h$X ``source``h-}rL(h/]h0]h1]h2]h4]uh%j9h]rMh@XsourcerN…rO}rP(h$Uh%jJubah+j@ubh@X( is merely a wrapper generator function.rQ…rR}rS(h$X( is merely a wrapper generator function.h%j9ubeubeubeubh!)rT}rU(h$UhÉKh%h"h&h)h+h,h-}rV(h/]h0]h1]h2]rWhah4]rXhauh6KÎh7hh]rY(h9)rZ}r[(h$X``basic_message``r\h%jTh&h)h+h=h-}r](h/]h0]h1]h2]h4]uh6KÎh7hh]r^j8)r_}r`(h$j\h-}ra(h/]h0]h1]h2]h4]uh%jZh]rbh@X basic_messagerc…rd}re(h$Uh%j_ubah+j@ubaubhD)rf}rg(h$XThe default implementation of a simple type that models the Message Concept is available in cpp-netlib. This default implementation is named ``basic_message`` which supports a ``Tag`` template parameter. The definition of ``basic_message`` looks like this:h%jTh&h)h+hHh-}rh(h/]h0]h1]h2]h4]uh6KÐh7hh]ri(h@XThe default implementation of a simple type that models the Message Concept is available in cpp-netlib. This default implementation is named rj…rk}rl(h$XThe default implementation of a simple type that models the Message Concept is available in cpp-netlib. This default implementation is named h%jfubj8)rm}rn(h$X``basic_message``h-}ro(h/]h0]h1]h2]h4]uh%jfh]rph@X basic_messagerq…rr}rs(h$Uh%jmubah+j@ubh@X which supports a rt…ru}rv(h$X which supports a h%jfubj8)rw}rx(h$X``Tag``h-}ry(h/]h0]h1]h2]h4]uh%jfh]rzh@XTagr{…r|}r}(h$Uh%jwubah+j@ubh@X' template parameter. The definition of r~…r}r€(h$X' template parameter. The definition of h%jfubj8)r}r‚(h$X``basic_message``h-}rƒ(h/]h0]h1]h2]h4]uh%jfh]r„h@X basic_messager……r†}r‡(h$Uh%jubah+j@ubh@X looks like this:rˆ…r‰}rŠ(h$X looks like this:h%jfubeubj©)r‹}rŒ(h$X)template class basic_message;h%jTh&h)h+j¬h-}r(j®‰j¯Xc++j°j±h2]h1]h/]h0]h4]uh6KÕh7hh]rŽh@X)template class basic_message;r…r}r‘(h$Uh%j‹ubaubhD)r’}r“(h$XyThe ``basic_message`` template requires that the following tag-dispatched metafunctions are defined for the type ``Tag``:h%jTh&h)h+hHh-}r”(h/]h0]h1]h2]h4]uh6KÚh7hh]r•(h@XThe r–…r—}r˜(h$XThe h%j’ubj8)r™}rš(h$X``basic_message``h-}r›(h/]h0]h1]h2]h4]uh%j’h]rœh@X basic_messager…rž}rŸ(h$Uh%j™ubah+j@ubh@X\ template requires that the following tag-dispatched metafunctions are defined for the type r …r¡}r¢(h$X\ template requires that the following tag-dispatched metafunctions are defined for the type h%j’ubj8)r£}r¤(h$X``Tag``h-}r¥(h/]h0]h1]h2]h4]uh%j’h]r¦h@XTagr§…r¨}r©(h$Uh%j£ubah+j@ubh@X:…rª}r«(h$X:h%j’ubeubj©)r¬}r­(h$XStemplate struct string; template struct headers_container;h%jTh&h)h+j¬h-}r®(j®‰j¯Xc++j°j±h2]h1]h/]h0]h4]uh6KÝh7hh]r¯h@XStemplate struct string; template struct headers_container;r°…r±}r²(h$Uh%j¬ubaubhD)r³}r´(h$XAll the operations defined by the message concept are implemented by this basic message type. Other message implementations can either use this common message type or specialize it according to whether they want to use different containers or whether it's going to be just a POD type.rµh%jTh&h)h+hHh-}r¶(h/]h0]h1]h2]h4]uh6Kåh7hh]r·h@XAll the operations defined by the message concept are implemented by this basic message type. Other message implementations can either use this common message type or specialize it according to whether they want to use different containers or whether it's going to be just a POD type.r¸…r¹}rº(h$jµh%j³ubaubeubeubah$UU transformerr»NU footnote_refsr¼}r½Urefnamesr¾}r¿(Xwrappers]rÀjgaX modifiers]rÁj]ah¿]rÂh¼aXmessage concept]rÃh¯aX directives]rÄ(jSjæeXadl]rÅjÚauUsymbol_footnotesrÆ]rÇUautofootnote_refsrÈ]rÉUsymbol_footnote_refsrÊ]rËU citationsrÌ]rÍh7hU current_linerÎNUtransform_messagesrÏ]rÐUreporterrÑNUid_startrÒKU autofootnotesrÓ]rÔU citation_refsrÕ}rÖUindirect_targetsr×]rØUsettingsrÙ(cdocutils.frontend Values rÚorÛ}rÜ(Ufootnote_backlinksrÝKUrecord_dependenciesrÞNU rfc_base_urlrßUhttp://tools.ietf.org/html/ràU tracebackráˆUpep_referencesrâNUstrip_commentsrãNU toc_backlinksräj U language_coderåUenræU datestamprçNU report_levelrèKU _destinationréNU halt_levelrêKU strip_classesrëNh=NUerror_encoding_error_handlerrìUbackslashreplaceríUdebugrîNUembed_stylesheetrï‰Uoutput_encoding_error_handlerrðUstrictrñU sectnum_xformròKUdump_transformsróNU docinfo_xformrôKUwarning_streamrõNUpep_file_url_templateröUpep-%04dr÷Uexit_status_levelrøKUconfigrùNUstrict_visitorrúNUcloak_email_addressesrûˆUtrim_footnote_reference_spacerü‰UenvrýNUdump_pseudo_xmlrþNUexpose_internalsrÿNUsectsubtitle_xformr‰U source_linkrNUrfc_referencesrNUoutput_encodingrUutf-8rU source_urlrNUinput_encodingrUutf-8rU_disable_configrNU id_prefixr UU tab_widthr KUerror_encodingr UUS-ASCIIr U_sourcer UF/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth/message.rstrUgettext_compactrˆU generatorrNUdump_internalsrNU smart_quotesr‰U pep_base_urlrUhttp://www.python.org/dev/peps/rUsyntax_highlightrUlongrUinput_encoding_error_handlerrjñUauto_id_prefixrUidrUdoctitle_xformr‰Ustrip_elements_with_classesrNU _config_filesr]Ufile_insertion_enabledrˆU raw_enabledrKU dump_settingsrNubUsymbol_footnote_startr KUidsr!}r"(hj÷hj¶hjThh"hj>hjphjñhhÇuUsubstitution_namesr#}r$h+h7h-}r%(h/]h2]h1]Usourceh)h0]h4]uU footnotesr&]r'Urefidsr(}r)ub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/in_depth/uri.doctree000066400000000000000000001021061240331347200301500ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xthe uri builderqNX the uri classqNX uri conceptqNXrfc 2368q ˆXrfc 2732q ˆXgeneric uri syntax overviewq NXrfc 3513q ˆXrfc 3986q ˆuUsubstitution_defsq}qUparse_messagesq]qcdocutils.nodes system_message q)q}q(U rawsourceqUUparentqcdocutils.nodes section q)q}q(hUU referencedqKhh)q}q(hUhKhhUsourceqcdocutils.nodes reprunicode qXB/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth/uri.rstq…q }q!bUtagnameq"Usectionq#U attributesq$}q%(Udupnamesq&]q'X the uri classq(aUclassesq)]Ubackrefsq*]Uidsq+]q,U the-uri-classq-aUnamesq.]uUlineq/KUdocumentq0hUchildrenq1]q2(cdocutils.nodes title q3)q4}q5(hX The URI classq6hhhh h"Utitleq7h$}q8(h&]h)]h*]h+]h.]uh/Kh0hh1]q9cdocutils.nodes Text q:X The URI classq;…q<}q=(hh6hh4ubaubcdocutils.nodes paragraph q>)q?}q@(hX¢In addition to protocol implementations, the :mod:`cpp-netlib` provides a powerful URI class. The class implements a parser based on `RFC 3986`_ and `RFC 2732`_.hhhh h"U paragraphqAh$}qB(h&]h)]h*]h+]h.]uh/Kh0hh1]qC(h:X-In addition to protocol implementations, the qD…qE}qF(hX-In addition to protocol implementations, the hh?ubcsphinx.addnodes pending_xref qG)qH}qI(hX:mod:`cpp-netlib`qJhh?hh h"U pending_xrefqKh$}qL(UreftypeXmodUrefwarnqM‰U reftargetqNX cpp-netlibU refdomainXpyqOh+]h*]U refexplicit‰h&]h)]h.]UrefdocqPX in_depth/uriqQUpy:classqRNU py:moduleqSNuh/Kh1]qTcdocutils.nodes literal qU)qV}qW(hhJh$}qX(h&]h)]qY(UxrefqZhOXpy-modq[eh*]h+]h.]uhhHh1]q\h:X cpp-netlibq]…q^}q_(hUhhVubah"Uliteralq`ubaubh:XH provides a powerful URI class. The class implements a parser based on qa…qb}qc(hXH provides a powerful URI class. The class implements a parser based on hh?ubcdocutils.nodes reference qd)qe}qf(hX `RFC 3986`_UresolvedqgKhh?h"U referenceqhh$}qi(UnameXRFC 3986UrefuriqjX"http://tools.ietf.org/html/rfc3986qkh+]h*]h&]h)]h.]uh1]qlh:XRFC 3986qm…qn}qo(hUhheubaubh:X and qp…qq}qr(hX and hh?ubhd)qs}qt(hX `RFC 2732`_hgKhh?h"hhh$}qu(UnameXRFC 2732hjX"http://tools.ietf.org/html/rfc2732qvh+]h*]h&]h)]h.]uh1]qwh:XRFC 2732qx…qy}qz(hUhhsubaubh:X.…q{}q|(hX.hh?ubeubh)q}}q~(hUhhhh h"h#h$}q(h&]h)]h*]h+]q€Ugeneric-uri-syntax-overviewqah.]q‚h auh/K h0hh1]qƒ(h3)q„}q…(hXGeneric URI syntax overviewq†hh}hh h"h7h$}q‡(h&]h)]h*]h+]h.]uh/K h0hh1]qˆh:XGeneric URI syntax overviewq‰…qŠ}q‹(hh†hh„ubaubh>)qŒ}q(hX"A generic URI will take the form::qŽhh}hh h"hAh$}q(h&]h)]h*]h+]h.]uh/K h0hh1]qh:X!A generic URI will take the form:q‘…q’}q“(hX!A generic URI will take the form:hhŒubaubcdocutils.nodes literal_block q”)q•}q–(hX([scheme:]scheme-specific-part[#fragment]hh}hh h"U literal_blockq—h$}q˜(U xml:spaceq™Upreserveqšh+]h*]h&]h)]h.]uh/K h0hh1]q›h:X([scheme:]scheme-specific-part[#fragment]qœ…q}qž(hUhh•ubaubh>)qŸ}q (hX”A URI is known as `absolute` if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, ``uri`` supports only absolute URIs.hh}hh h"hAh$}q¡(h&]h)]h*]h+]h.]uh/Kh0hh1]q¢(h:XA URI is known as q£…q¤}q¥(hXA URI is known as hhŸubcdocutils.nodes title_reference q¦)q§}q¨(hX `absolute`h$}q©(h&]h)]h*]h+]h.]uhhŸh1]qªh:Xabsoluteq«…q¬}q­(hUhh§ubah"Utitle_referenceq®ubh:XT if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, q¯…q°}q±(hXT if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, hhŸubhU)q²}q³(hX``uri``h$}q´(h&]h)]h*]h+]h.]uhhŸh1]qµh:Xuriq¶…q·}q¸(hUhh²ubah"h`ubh:X supports only absolute URIs.q¹…qº}q»(hX supports only absolute URIs.hhŸubeubh>)q¼}q½(hXfURIs can be further classified according to whether they're hierarchical or opaque (non-hierarchical).q¾hh}hh h"hAh$}q¿(h&]h)]h*]h+]h.]uh/Kh0hh1]qÀh:XfURIs can be further classified according to whether they're hierarchical or opaque (non-hierarchical).qÁ…qÂ}qÃ(hh¾hh¼ubaubh>)qÄ}qÅ(hX0Some examples of non-hierarchical URIs include::qÆhh}hh h"hAh$}qÇ(h&]h)]h*]h+]h.]uh/Kh0hh1]qÈh:X/Some examples of non-hierarchical URIs include:qÉ…qÊ}qË(hX/Some examples of non-hierarchical URIs include:hhÄubaubh”)qÌ}qÍ(hXVmailto:john.doe@example.com news:comp.infosystems.www.servers.unix tel:+1-816-555-1212hh}hh h"h—h$}qÎ(h™hšh+]h*]h&]h)]h.]uh/Kh0hh1]qÏh:XVmailto:john.doe@example.com news:comp.infosystems.www.servers.unix tel:+1-816-555-1212qÐ…qÑ}qÒ(hUhhÌubaubh>)qÓ}qÔ(hX The data following the first ``":"`` is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the ``":"`` to be a part of the path:hh}hh h"hAh$}qÕ(h&]h)]h*]h+]h.]uh/Kh0hh1]qÖ(h:XThe data following the first q×…qØ}qÙ(hXThe data following the first hhÓubhU)qÚ}qÛ(hX``":"``h$}qÜ(h&]h)]h*]h+]h.]uhhÓh1]qÝh:X":"qÞ…qß}qà(hUhhÚubah"h`ubh:XÈ is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the qá…qâ}qã(hXÈ is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the hhÓubhU)qä}qå(hX``":"``h$}qæ(h&]h)]h*]h+]h.]uhhÓh1]qçh:X":"qè…qé}qê(hUhhäubah"h`ubh:X to be a part of the path:që…qì}qí(hX to be a part of the path:hhÓubeubcdocutils.nodes image qî)qï}qð(hX%.. image:: ../_static/mailto_uri.png hh}hh h"Uimageqñh$}qò(UuriX"in_depth/../_static/mailto_uri.pngqóh+]h*]h&]h)]U candidatesqô}qõU*hósh.]uh/K"h0hh1]ubh>)qö}q÷(hX‘A hierarchical URI is identified by a double slash (``"//"``) after the scheme and a scheme-specific component, which `RFC 3986`_ defines to be::hh}hh h"hAh$}qø(h&]h)]h*]h+]h.]uh/K#h0hh1]qù(h:X4A hierarchical URI is identified by a double slash (qú…qû}qü(hX4A hierarchical URI is identified by a double slash (hhöubhU)qý}qþ(hX``"//"``h$}qÿ(h&]h)]h*]h+]h.]uhhöh1]rh:X"//"r…r}r(hUhhýubah"h`ubh:X:) after the scheme and a scheme-specific component, which r…r}r(hX:) after the scheme and a scheme-specific component, which hhöubhd)r}r(hX `RFC 3986`_hgKhhöh"hhh$}r (UnameXRFC 3986hjhkh+]h*]h&]h)]h.]uh1]r h:XRFC 3986r …r }r (hUhjubaubh:X defines to be:r…r}r(hX defines to be:hhöubeubh”)r}r(hX/[scheme:][//authority][path][?query][#fragment]hh}hh h"h—h$}r(h™hšh+]h*]h&]h)]h.]uh/K'h0hh1]rh:X/[scheme:][//authority][path][?query][#fragment]r…r}r(hUhjubaubh>)r}r(hX7The authority component can be further broken down to::rhh}hh h"hAh$}r(h&]h)]h*]h+]h.]uh/K)h0hh1]rh:X6The authority component can be further broken down to:r…r}r(hX6The authority component can be further broken down to:hjubaubh”)r }r!(hX[user_info@]host[:port]hh}hh h"h—h$}r"(h™hšh+]h*]h&]h)]h.]uh/K+h0hh1]r#h:X[user_info@]host[:port]r$…r%}r&(hUhj ubaubh>)r'}r((hX'Examples of hierarchical URIs include::r)hh}hh h"hAh$}r*(h&]h)]h*]h+]h.]uh/K-h0hh1]r+h:X&Examples of hierarchical URIs include:r,…r-}r.(hX&Examples of hierarchical URIs include:hj'ubaubh”)r/}r0(hX&http://www.boost.org/ file:///bin/bashhh}hh h"h—h$}r1(h™hšh+]h*]h&]h)]h.]uh/K/h0hh1]r2h:X&http://www.boost.org/ file:///bin/bashr3…r4}r5(hUhj/ubaubh>)r6}r7(hXhThe following example, describing a complex URI using FTP, shows how a URI is broken down by the parser:r8hh}hh h"hAh$}r9(h&]h)]h*]h+]h.]uh/K2h0hh1]r:h:XhThe following example, describing a complex URI using FTP, shows how a URI is broken down by the parser:r;…r<}r=(hj8hj6ubaubhî)r>}r?(hX".. image:: ../_static/ftp_uri.png hh}hh h"hñh$}r@(UuriXin_depth/../_static/ftp_uri.pngrAh+]h*]h&]h)]hô}rBU*jAsh.]uh/K6h0hh1]ubh>)rC}rD(hXwNote that the ``authority`` is further subdivided into different elements. Another example, using HTTP is given below:hh}hh h"hAh$}rE(h&]h)]h*]h+]h.]uh/K7h0hh1]rF(h:XNote that the rG…rH}rI(hXNote that the hjCubhU)rJ}rK(hX ``authority``h$}rL(h&]h)]h*]h+]h.]uhjCh1]rMh:X authorityrN…rO}rP(hUhjJubah"h`ubh:X\ is further subdivided into different elements. Another example, using HTTP is given below:rQ…rR}rS(hX\ is further subdivided into different elements. Another example, using HTTP is given below:hjCubeubhî)rT}rU(hX#.. image:: ../_static/http_uri.png hh}hh h"hñh$}rV(UuriX in_depth/../_static/http_uri.pngrWh+]h*]h&]h)]hô}rXU*jWsh.]uh/K;h0hh1]ubh>)rY}rZ(hXvThe difference here between the path in a hierarchical URI and that in the example above for the non-hierarchical URI.r[hh}hh h"hAh$}r\(h&]h)]h*]h+]h.]uh/K)r}}r~(hXc``uri`` support a stream style syntax to create a URI from it's elements. For example the program:hjahh h"hAh$}r(h&]h)]h*]h+]h.]uh/KVh0hh1]r€(hU)r}r‚(hX``uri``h$}rƒ(h&]h)]h*]h+]h.]uhj}h1]r„h:Xurir……r†}r‡(hUhjubah"h`ubh:X\ support a stream style syntax to create a URI from it's elements. For example the program:rˆ…r‰}rŠ(hX\ support a stream style syntax to create a URI from it's elements. For example the program:hj}ubeubh”)r‹}rŒ(hX:#include #include #include using namespace boost::network; int main() { uri::uri url; url << uri::scheme("http") << uri::host("www.github.com") << uri::path("/cpp-netlib"); std::cout << url << std::endl; return 0; }hjahh h"h—h$}r(UlinenosrŽ‰UlanguagerXc++h™hšh+]h*]h&]h)]h.]uh/KYh0hh1]rh:X:#include #include #include using namespace boost::network; int main() { uri::uri url; url << uri::scheme("http") << uri::host("www.github.com") << uri::path("/cpp-netlib"); std::cout << url << std::endl; return 0; }r‘…r’}r“(hUhj‹ubaubh>)r”}r•(hX will output::r–hjahh h"hAh$}r—(h&]h)]h*]h+]h.]uh/Kih0hh1]r˜h:X will output:r™…rš}r›(hX will output:hj”ubaubh”)rœ}r(hX http://www.github.com/cpp-netlibhjahh h"h—h$}rž(h™hšh+]h*]h&]h)]h.]uh/Kkh0hh1]rŸh:X http://www.github.com/cpp-netlibr …r¡}r¢(hUhjœubaubeubh)r£}r¤(hUhhhh h"h#h$}r¥(h&]h)]h*]h+]r¦U uri-conceptr§ah.]r¨hauh/Knh0hh1]r©(h3)rª}r«(hX``URI Concept``r¬hj£hh h"h7h$}r­(h&]h)]h*]h+]h.]uh/Knh0hh1]r®hU)r¯}r°(hj¬h$}r±(h&]h)]h*]h+]h.]uhjªh1]r²h:X URI Conceptr³…r´}rµ(hUhj¯ubah"h`ubaubh>)r¶}r·(hX **Legend**r¸hj£hh h"hAh$}r¹(h&]h)]h*]h+]h.]uh/Kph0hh1]rºcdocutils.nodes strong r»)r¼}r½(hj¸h$}r¾(h&]h)]h*]h+]h.]uhj¶h1]r¿h:XLegendrÀ…rÁ}rÂ(hUhj¼ubah"UstrongrÃubaubcdocutils.nodes field_list rÄ)rÅ}rÆ(hUhj£hh h"U field_listrÇh$}rÈ(h&]h)]h*]h+]h.]uh/Krh0hh1]rÉ(cdocutils.nodes field rÊ)rË}rÌ(hUhjÅhh h"UfieldrÍh$}rÎ(h&]h)]h*]h+]h.]uh/Krh0hh1]rÏ(cdocutils.nodes field_name rÐ)rÑ}rÒ(hXUh$}rÓ(h&]h)]h*]h+]h.]uhjËh1]rÔh:XU…rÕ}rÖ(hXUhjÑubah"U field_namer×ubcdocutils.nodes field_body rØ)rÙ}rÚ(hX The URI type.rÛh$}rÜ(h&]h)]h*]h+]h.]uhjËh1]rÝh>)rÞ}rß(hjÛhjÙhh h"hAh$}rà(h&]h)]h*]h+]h.]uh/Krh1]ráh:X The URI type.râ…rã}rä(hjÛhjÞubaubah"U field_bodyråubeubjÊ)ræ}rç(hUhjÅhh h"jÍh$}rè(h&]h)]h*]h+]h.]uh/Ksh0hh1]ré(jÐ)rê}rë(hXu,u_rìh$}rí(h&]h)]h*]h+]h.]uhjæh1]rîh:Xu,u_rï…rð}rñ(hjìhjêubah"j×ubjØ)rò}ró(hXAn instance of **M**.rôh$}rõ(h&]h)]h*]h+]h.]uhjæh1]röh>)r÷}rø(hjôhjòhh h"hAh$}rù(h&]h)]h*]h+]h.]uh/Ksh1]rú(h:XAn instance of rû…rü}rý(hXAn instance of hj÷ubj»)rþ}rÿ(hX**M**h$}r(h&]h)]h*]h+]h.]uhj÷h1]rh:XM…r}r(hUhjþubah"jÃubh:X.…r}r(hX.hj÷ubeubah"jåubeubjÊ)r}r(hUhjÅhh h"jÍh$}r(h&]h)]h*]h+]h.]uh/Kth0hh1]r (jÐ)r }r (hXSh$}r (h&]h)]h*]h+]h.]uhjh1]r h:XS…r}r(hXShj ubah"j×ubjØ)r}r(hXA string type.rh$}r(h&]h)]h*]h+]h.]uhjh1]rh>)r}r(hjhjhh h"hAh$}r(h&]h)]h*]h+]h.]uh/Kth1]rh:XA string type.r…r}r(hjhjubaubah"jåubeubjÊ)r}r(hUhjÅhh h"jÍh$}r(h&]h)]h*]h+]h.]uh/Kuh0hh1]r(jÐ)r }r!(hXs,vr"h$}r#(h&]h)]h*]h+]h.]uhjh1]r$h:Xs,vr%…r&}r'(hj"hj ubah"j×ubjØ)r(}r)(hXAn instance of **S**.r*h$}r+(h&]h)]h*]h+]h.]uhjh1]r,h>)r-}r.(hj*hj(hh h"hAh$}r/(h&]h)]h*]h+]h.]uh/Kuh1]r0(h:XAn instance of r1…r2}r3(hXAn instance of hj-ubj»)r4}r5(hX**S**h$}r6(h&]h)]h*]h+]h.]uhj-h1]r7h:XS…r8}r9(hUhj4ubah"jÃubh:X.…r:}r;(hX.hj-ubeubah"jåubeubjÊ)r<}r=(hUhjÅhh h"jÍh$}r>(h&]h)]h*]h+]h.]uh/Kvh0hh1]r?(jÐ)r@}rA(hXTh$}rB(h&]h)]h*]h+]h.]uhj<h1]rCh:XT…rD}rE(hXThj@ubah"j×ubjØ)rF}rG(hXThe Tag type. h$}rH(h&]h)]h*]h+]h.]uhj<h1]rIh>)rJ}rK(hX The Tag type.rLhjFhh h"hAh$}rM(h&]h)]h*]h+]h.]uh/Kvh1]rNh:X The Tag type.rO…rP}rQ(hjLhjJubaubah"jåubeubeubcdocutils.nodes table rR)rS}rT(hUhj£hh h"UtablerUh$}rV(h&]h)]h*]h+]h.]uh/Nh0hh1]rWcdocutils.nodes tgroup rX)rY}rZ(hUh$}r[(h+]h*]h&]h)]h.]UcolsKuhjSh1]r\(cdocutils.nodes colspec r])r^}r_(hUh$}r`(h+]h*]h&]h)]h.]UcolwidthKuhjYh1]h"Ucolspecraubj])rb}rc(hUh$}rd(h+]h*]h&]h)]h.]UcolwidthKuhjYh1]h"jaubj])re}rf(hUh$}rg(h+]h*]h&]h)]h.]UcolwidthK)uhjYh1]h"jaubcdocutils.nodes thead rh)ri}rj(hUh$}rk(h&]h)]h*]h+]h.]uhjYh1]rlcdocutils.nodes row rm)rn}ro(hUh$}rp(h&]h)]h*]h+]h.]uhjih1]rq(cdocutils.nodes entry rr)rs}rt(hUh$}ru(h&]h)]h*]h+]h.]uhjnh1]rvh>)rw}rx(hX Constructryhjshh h"hAh$}rz(h&]h)]h*]h+]h.]uh/Kyh1]r{h:X Constructr|…r}}r~(hjyhjwubaubah"Uentryrubjr)r€}r(hUh$}r‚(h&]h)]h*]h+]h.]uhjnh1]rƒh>)r„}r…(hXResultr†hj€hh h"hAh$}r‡(h&]h)]h*]h+]h.]uh/Kyh1]rˆh:XResultr‰…rŠ}r‹(hj†hj„ubaubah"jubjr)rŒ}r(hUh$}rŽ(h&]h)]h*]h+]h.]uhjnh1]rh>)r}r‘(hX Descriptionr’hjŒhh h"hAh$}r“(h&]h)]h*]h+]h.]uh/Kyh1]r”h:X Descriptionr•…r–}r—(hj’hjubaubah"jubeh"Urowr˜ubah"Utheadr™ubcdocutils.nodes tbody rš)r›}rœ(hUh$}r(h&]h)]h*]h+]h.]uhjYh1]rž(jm)rŸ}r (hUh$}r¡(h&]h)]h*]h+]h.]uhj›h1]r¢(jr)r£}r¤(hUh$}r¥(h&]h)]h*]h+]h.]uhjŸh1]r¦h>)r§}r¨(hX``U(u)``r©hj£hh h"hAh$}rª(h&]h)]h*]h+]h.]uh/K{h1]r«hU)r¬}r­(hj©h$}r®(h&]h)]h*]h+]h.]uhj§h1]r¯h:XU(u)r°…r±}r²(hUhj¬ubah"h`ubaubah"jubjr)r³}r´(hUh$}rµ(h&]h)]h*]h+]h.]uhjŸh1]r¶h>)r·}r¸(hX Instance of Ur¹hj³hh h"hAh$}rº(h&]h)]h*]h+]h.]uh/K{h1]r»h:X Instance of Ur¼…r½}r¾(hj¹hj·ubaubah"jubjr)r¿}rÀ(hUh$}rÁ(h&]h)]h*]h+]h.]uhjŸh1]rÂh>)rÃ}rÄ(hXCopy constructible.rÅhj¿hh h"hAh$}rÆ(h&]h)]h*]h+]h.]uh/K{h1]rÇh:XCopy constructible.rÈ…rÉ}rÊ(hjÅhjÃubaubah"jubeh"j˜ubjm)rË}rÌ(hUh$}rÍ(h&]h)]h*]h+]h.]uhj›h1]rÎ(jr)rÏ}rÐ(hUh$}rÑ(h&]h)]h*]h+]h.]uhjËh1]rÒh>)rÓ}rÔ(hX``U(s)``rÕhjÏhh h"hAh$}rÖ(h&]h)]h*]h+]h.]uh/K}h1]r×hU)rØ}rÙ(hjÕh$}rÚ(h&]h)]h*]h+]h.]uhjÓh1]rÛh:XU(s)rÜ…rÝ}rÞ(hUhjØubah"h`ubaubah"jubjr)rß}rà(hUh$}rá(h&]h)]h*]h+]h.]uhjËh1]râh>)rã}rä(hX Instance of Uråhjßhh h"hAh$}ræ(h&]h)]h*]h+]h.]uh/K}h1]rçh:X Instance of Urè…ré}rê(hjåhjãubaubah"jubjr)rë}rì(hUh$}rí(h&]h)]h*]h+]h.]uhjËh1]rîh>)rï}rð(hXConstructible from string.rñhjëhh h"hAh$}rò(h&]h)]h*]h+]h.]uh/K}h1]róh:XConstructible from string.rô…rõ}rö(hjñhjïubaubah"jubeh"j˜ubjm)r÷}rø(hUh$}rù(h&]h)]h*]h+]h.]uhj›h1]rú(jr)rû}rü(hUh$}rý(h&]h)]h*]h+]h.]uhj÷h1]rþh>)rÿ}r(hX ``u = u_;``rhjûhh h"hAh$}r(h&]h)]h*]h+]h.]uh/Kh1]rhU)r}r(hjh$}r(h&]h)]h*]h+]h.]uhjÿh1]rh:Xu = u_;r…r }r (hUhjubah"h`ubaubah"jubjr)r }r (hUh$}r (h&]h)]h*]h+]h.]uhj÷h1]rh>)r}r(hXReference to urhj hh h"hAh$}r(h&]h)]h*]h+]h.]uh/Kh1]rh:XReference to ur…r}r(hjhjubaubah"jubjr)r}r(hUh$}r(h&]h)]h*]h+]h.]uhj÷h1]rh>)r}r(hX Assignable.rhjhh h"hAh$}r(h&]h)]h*]h+]h.]uh/Kh1]rh:X Assignable.r …r!}r"(hjhjubaubah"jubeh"j˜ubjm)r#}r$(hUh$}r%(h&]h)]h*]h+]h.]uhj›h1]r&(jr)r'}r((hUh$}r)(h&]h)]h*]h+]h.]uhj#h1]r*h>)r+}r,(hX ``u = s;``r-hj'hh h"hAh$}r.(h&]h)]h*]h+]h.]uh/Kh1]r/hU)r0}r1(hj-h$}r2(h&]h)]h*]h+]h.]uhj+h1]r3h:Xu = s;r4…r5}r6(hUhj0ubah"h`ubaubah"jubjr)r7}r8(hUh$}r9(h&]h)]h*]h+]h.]uhj#h1]r:h>)r;}r<(hXReference to ur=hj7hh h"hAh$}r>(h&]h)]h*]h+]h.]uh/Kh1]r?h:XReference to ur@…rA}rB(hj=hj;ubaubah"jubjr)rC}rD(hUh$}rE(h&]h)]h*]h+]h.]uhj#h1]rFh>)rG}rH(hXAssignable from string.rIhjChh h"hAh$}rJ(h&]h)]h*]h+]h.]uh/Kh1]rKh:XAssignable from string.rL…rM}rN(hjIhjGubaubah"jubeh"j˜ubjm)rO}rP(hUh$}rQ(h&]h)]h*]h+]h.]uhj›h1]rR(jr)rS}rT(hUh$}rU(h&]h)]h*]h+]h.]uhjOh1]rVh>)rW}rX(hX``swap(u, u_);``rYhjShh h"hAh$}rZ(h&]h)]h*]h+]h.]uh/Kƒh1]r[hU)r\}r](hjYh$}r^(h&]h)]h*]h+]h.]uhjWh1]r_h:X swap(u, u_);r`…ra}rb(hUhj\ubah"h`ubaubah"jubjr)rc}rd(hUh$}re(h&]h)]h*]h+]h.]uhjOh1]rfh>)rg}rh(hX``void``rihjchh h"hAh$}rj(h&]h)]h*]h+]h.]uh/Kƒh1]rkhU)rl}rm(hjih$}rn(h&]h)]h*]h+]h.]uhjgh1]roh:Xvoidrp…rq}rr(hUhjlubah"h`ubaubah"jubjr)rs}rt(hUh$}ru(h&]h)]h*]h+]h.]uhjOh1]rvh>)rw}rx(hX Swappable.ryhjshh h"hAh$}rz(h&]h)]h*]h+]h.]uh/Kƒh1]r{h:X Swappable.r|…r}}r~(hjyhjwubaubah"jubeh"j˜ubjm)r}r€(hUh$}r(h&]h)]h*]h+]h.]uhj›h1]r‚(jr)rƒ}r„(hUh$}r…(h&]h)]h*]h+]h.]uhjh1]r†h>)r‡}rˆ(hX``scheme(u);``r‰hjƒhh h"hAh$}rŠ(h&]h)]h*]h+]h.]uh/K…h1]r‹hU)rŒ}r(hj‰h$}rŽ(h&]h)]h*]h+]h.]uhj‡h1]rh:X scheme(u);r…r‘}r’(hUhjŒubah"h`ubaubah"jubjr)r“}r”(hUh$}r•(h&]h)]h*]h+]h.]uhjh1]r–h>)r—}r˜(hXConvertible to Sr™hj“hh h"hAh$}rš(h&]h)]h*]h+]h.]uh/K…h1]r›h:XConvertible to Srœ…r}rž(hj™hj—ubaubah"jubjr)rŸ}r (hUh$}r¡(h&]h)]h*]h+]h.]uhjh1]r¢h>)r£}r¤(hX!Retrieve the URI scheme of ``u``.hjŸhh h"hAh$}r¥(h&]h)]h*]h+]h.]uh/K…h1]r¦(h:XRetrieve the URI scheme of r§…r¨}r©(hXRetrieve the URI scheme of hj£ubhU)rª}r«(hX``u``h$}r¬(h&]h)]h*]h+]h.]uhj£h1]r­h:Xu…r®}r¯(hUhjªubah"h`ubh:X.…r°}r±(hX.hj£ubeubah"jubeh"j˜ubjm)r²}r³(hUh$}r´(h&]h)]h*]h+]h.]uhj›h1]rµ(jr)r¶}r·(hUh$}r¸(h&]h)]h*]h+]h.]uhj²h1]r¹h>)rº}r»(hX``user_info(u);``r¼hj¶hh h"hAh$}r½(h&]h)]h*]h+]h.]uh/K‡h1]r¾hU)r¿}rÀ(hj¼h$}rÁ(h&]h)]h*]h+]h.]uhjºh1]rÂh:X user_info(u);rÃ…rÄ}rÅ(hUhj¿ubah"h`ubaubah"jubjr)rÆ}rÇ(hUh$}rÈ(h&]h)]h*]h+]h.]uhj²h1]rÉh>)rÊ}rË(hXConvertible to SrÌhjÆhh h"hAh$}rÍ(h&]h)]h*]h+]h.]uh/K‡h1]rÎh:XConvertible to SrÏ…rÐ}rÑ(hjÌhjÊubaubah"jubjr)rÒ}rÓ(hUh$}rÔ(h&]h)]h*]h+]h.]uhj²h1]rÕh>)rÖ}r×(hX Retrieve the user info of ``u``.hjÒhh h"hAh$}rØ(h&]h)]h*]h+]h.]uh/K‡h1]rÙ(h:XRetrieve the user info of rÚ…rÛ}rÜ(hXRetrieve the user info of hjÖubhU)rÝ}rÞ(hX``u``h$}rß(h&]h)]h*]h+]h.]uhjÖh1]ràh:Xu…rá}râ(hUhjÝubah"h`ubh:X.…rã}rä(hX.hjÖubeubah"jubeh"j˜ubjm)rå}ræ(hUh$}rç(h&]h)]h*]h+]h.]uhj›h1]rè(jr)ré}rê(hUh$}rë(h&]h)]h*]h+]h.]uhjåh1]rìh>)rí}rî(hX ``host(u);``rïhjéhh h"hAh$}rð(h&]h)]h*]h+]h.]uh/K‰h1]rñhU)rò}ró(hjïh$}rô(h&]h)]h*]h+]h.]uhjíh1]rõh:Xhost(u);rö…r÷}rø(hUhjòubah"h`ubaubah"jubjr)rù}rú(hUh$}rû(h&]h)]h*]h+]h.]uhjåh1]rüh>)rý}rþ(hXConvertible to Srÿhjùhh h"hAh$}r(h&]h)]h*]h+]h.]uh/K‰h1]rh:XConvertible to Sr…r}r(hjÿhjýubaubah"jubjr)r}r(hUh$}r(h&]h)]h*]h+]h.]uhjåh1]rh>)r }r (hXRetrieve the host of ``u``.hjhh h"hAh$}r (h&]h)]h*]h+]h.]uh/K‰h1]r (h:XRetrieve the host of r …r}r(hXRetrieve the host of hj ubhU)r}r(hX``u``h$}r(h&]h)]h*]h+]h.]uhj h1]rh:Xu…r}r(hUhjubah"h`ubh:X.…r}r(hX.hj ubeubah"jubeh"j˜ubjm)r}r(hUh$}r(h&]h)]h*]h+]h.]uhj›h1]r(jr)r}r(hUh$}r(h&]h)]h*]h+]h.]uhjh1]rh>)r }r!(hX ``port(u);``r"hjhh h"hAh$}r#(h&]h)]h*]h+]h.]uh/K‹h1]r$hU)r%}r&(hj"h$}r'(h&]h)]h*]h+]h.]uhj h1]r(h:Xport(u);r)…r*}r+(hUhj%ubah"h`ubaubah"jubjr)r,}r-(hUh$}r.(h&]h)]h*]h+]h.]uhjh1]r/h>)r0}r1(hXConvertible to Hr2hj,hh h"hAh$}r3(h&]h)]h*]h+]h.]uh/K‹h1]r4h:XConvertible to Hr5…r6}r7(hj2hj0ubaubah"jubjr)r8}r9(hUh$}r:(h&]h)]h*]h+]h.]uhjh1]r;h>)r<}r=(hXRetrieve the port of ``u``.hj8hh h"hAh$}r>(h&]h)]h*]h+]h.]uh/K‹h1]r?(h:XRetrieve the port of r@…rA}rB(hXRetrieve the port of hj<ubhU)rC}rD(hX``u``h$}rE(h&]h)]h*]h+]h.]uhj<h1]rFh:Xu…rG}rH(hUhjCubah"h`ubh:X.…rI}rJ(hX.hj<ubeubah"jubeh"j˜ubjm)rK}rL(hUh$}rM(h&]h)]h*]h+]h.]uhj›h1]rN(jr)rO}rP(hUh$}rQ(h&]h)]h*]h+]h.]uhjKh1]rRh>)rS}rT(hX ``path(u);``rUhjOhh h"hAh$}rV(h&]h)]h*]h+]h.]uh/Kh1]rWhU)rX}rY(hjUh$}rZ(h&]h)]h*]h+]h.]uhjSh1]r[h:Xpath(u);r\…r]}r^(hUhjXubah"h`ubaubah"jubjr)r_}r`(hUh$}ra(h&]h)]h*]h+]h.]uhjKh1]rbh>)rc}rd(hXConvertible to Srehj_hh h"hAh$}rf(h&]h)]h*]h+]h.]uh/Kh1]rgh:XConvertible to Srh…ri}rj(hjehjcubaubah"jubjr)rk}rl(hUh$}rm(h&]h)]h*]h+]h.]uhjKh1]rnh>)ro}rp(hXRetrieve the path of ``u``.hjkhh h"hAh$}rq(h&]h)]h*]h+]h.]uh/Kh1]rr(h:XRetrieve the path of rs…rt}ru(hXRetrieve the path of hjoubhU)rv}rw(hX``u``h$}rx(h&]h)]h*]h+]h.]uhjoh1]ryh:Xu…rz}r{(hUhjvubah"h`ubh:X.…r|}r}(hX.hjoubeubah"jubeh"j˜ubjm)r~}r(hUh$}r€(h&]h)]h*]h+]h.]uhj›h1]r(jr)r‚}rƒ(hUh$}r„(h&]h)]h*]h+]h.]uhj~h1]r…h>)r†}r‡(hX ``query(u);``rˆhj‚hh h"hAh$}r‰(h&]h)]h*]h+]h.]uh/Kh1]rŠhU)r‹}rŒ(hjˆh$}r(h&]h)]h*]h+]h.]uhj†h1]rŽh:X query(u);r…r}r‘(hUhj‹ubah"h`ubaubah"jubjr)r’}r“(hUh$}r”(h&]h)]h*]h+]h.]uhj~h1]r•h>)r–}r—(hXConvertible to Sr˜hj’hh h"hAh$}r™(h&]h)]h*]h+]h.]uh/Kh1]ršh:XConvertible to Sr›…rœ}r(hj˜hj–ubaubah"jubjr)rž}rŸ(hUh$}r (h&]h)]h*]h+]h.]uhj~h1]r¡h>)r¢}r£(hX#Retrieve the query string of ``u``.hjžhh h"hAh$}r¤(h&]h)]h*]h+]h.]uh/Kh1]r¥(h:XRetrieve the query string of r¦…r§}r¨(hXRetrieve the query string of hj¢ubhU)r©}rª(hX``u``h$}r«(h&]h)]h*]h+]h.]uhj¢h1]r¬h:Xu…r­}r®(hUhj©ubah"h`ubh:X.…r¯}r°(hX.hj¢ubeubah"jubeh"j˜ubjm)r±}r²(hUh$}r³(h&]h)]h*]h+]h.]uhj›h1]r´(jr)rµ}r¶(hUh$}r·(h&]h)]h*]h+]h.]uhj±h1]r¸h>)r¹}rº(hX``fragment(u);``r»hjµhh h"hAh$}r¼(h&]h)]h*]h+]h.]uh/K‘h1]r½hU)r¾}r¿(hj»h$}rÀ(h&]h)]h*]h+]h.]uhj¹h1]rÁh:X fragment(u);rÂ…rÃ}rÄ(hUhj¾ubah"h`ubaubah"jubjr)rÅ}rÆ(hUh$}rÇ(h&]h)]h*]h+]h.]uhj±h1]rÈh>)rÉ}rÊ(hXConvertible to SrËhjÅhh h"hAh$}rÌ(h&]h)]h*]h+]h.]uh/K‘h1]rÍh:XConvertible to SrÎ…rÏ}rÐ(hjËhjÉubaubah"jubjr)rÑ}rÒ(hUh$}rÓ(h&]h)]h*]h+]h.]uhj±h1]rÔh>)rÕ}rÖ(hXRetrieve the fragment of ``u``.r×hjÑhh h"hAh$}rØ(h&]h)]h*]h+]h.]uh/K‘h1]rÙ(h:XRetrieve the fragment of rÚ…rÛ}rÜ(hXRetrieve the fragment of hjÕubhU)rÝ}rÞ(hX``u``h$}rß(h&]h)]h*]h+]h.]uhjÕh1]ràh:Xu…rá}râ(hUhjÝubah"h`ubh:X.…rã}rä(hX.hjÕubeubah"jubeh"j˜ubeh"Utbodyråubeh"Utgroupræubaubcdocutils.nodes target rç)rè}ré(hX2.. _`RFC 3986`: http://tools.ietf.org/html/rfc3986hKhj£hh h"Utargetrêh$}rë(hjhkh+]rìUrfc-3986ríah*]h&]h)]h.]rîh auh/K”h0hh1]ubjç)rï}rð(hX2.. _`RFC 2368`: http://tools.ietf.org/html/rfc2368hj£hh h"jêh$}rñ(hjX"http://tools.ietf.org/html/rfc2368h+]ròUrfc-2368róah*]h&]h)]h.]rôh auh/K•h0hh1]ubjç)rõ}rö(hX2.. _`RFC 3513`: http://tools.ietf.org/html/rfc3513hj£hh h"jêh$}r÷(hjX"http://tools.ietf.org/html/rfc3513h+]røUrfc-3513rùah*]h&]h)]h.]rúh auh/K–h0hh1]ubjç)rû}rü(hX2.. _`RFC 2732`: http://tools.ietf.org/html/rfc2732hKhj£hh h"jêh$}rý(hjhvh+]rþUrfc-2732rÿah*]h&]h)]h.]rh auh/K—h0hh1]ubeubeubhh h"h#h$}r(h&]rh(ah)]h*]h+]rUid1rah.]uh/K@h0hh1]r(h3)r}r(hXThe ``uri`` classrhhhh h"h7h$}r (h&]h)]h*]h+]h.]uh/K@h0hh1]r (h:XThe r …r }r (hXThe rhjubhU)r}r(hX``uri``rh$}r(h&]h)]h*]h+]h.]uhjh1]rh:Xurir…r}r(hUhjubah"h`ubh:X classr…r}r(hX classrhjubeubh>)r}r(hX‹As of version 0.9.3, ``uri`` supplies a URI parser and builder. To use the parser, it's as simple as supplying a string to the constructor:hhhh h"hAh$}r(h&]h)]h*]h+]h.]uh/KBh0hh1]r(h:XAs of version 0.9.3, r…r }r!(hXAs of version 0.9.3, hjubhU)r"}r#(hX``uri``h$}r$(h&]h)]h*]h+]h.]uhjh1]r%h:Xurir&…r'}r((hUhj"ubah"h`ubh:Xo supplies a URI parser and builder. To use the parser, it's as simple as supplying a string to the constructor:r)…r*}r+(hXo supplies a URI parser and builder. To use the parser, it's as simple as supplying a string to the constructor:hjubeubh”)r,}r-(hXáusing namespace boost::network; uri::uri instance("http://cpp-netlib.github.com/"); assert(instance.is_valid()); std::cout << "scheme: " << instance.scheme() << std::endl << "host: " << instance.host() << std::endl;hhhh h"h—h$}r.(jŽ‰jXc++h™hšh+]h*]h&]h)]h.]uh/KFh0hh1]r/h:Xáusing namespace boost::network; uri::uri instance("http://cpp-netlib.github.com/"); assert(instance.is_valid()); std::cout << "scheme: " << instance.scheme() << std::endl << "host: " << instance.host() << std::endl;r0…r1}r2(hUhj,ubaubh>)r3}r4(hX1The command-line output of this program will be::r5hhhh h"hAh$}r6(h&]h)]h*]h+]h.]uh/KNh0hh1]r7h:X0The command-line output of this program will be:r8…r9}r:(hX0The command-line output of this program will be:hj3ubaubh”)r;}r<(hX(scheme: http host: cpp-netlib.github.comhhhh h"h—h$}r=(h™hšh+]h*]h&]h)]h.]uh/KPh0hh1]r>h:X(scheme: http host: cpp-netlib.github.comr?…r@}rA(hUhj;ubaubeubhh h"Usystem_messagerBh$}rC(h&]UlevelKh+]h*]rDjaUsourceh h)]h.]UlineK@UtypeUINFOrEuh/K@h0hh1]rFh>)rG}rH(hUh$}rI(h&]h)]h*]h+]h.]uhhh1]rJh:X0Duplicate implicit target name: "the uri class".rK…rL}rM(hUhjGubah"hAubaubaUcurrent_sourcerNNU decorationrONUautofootnote_startrPKUnameidsrQ}rR(hjehNhj§h jóh jÿh hh jùh jíuh1]rShahUU transformerrTNU footnote_refsrU}rVUrefnamesrW}rX(Xrfc 2732]rYhsaXrfc 3986]rZ(hejeuUsymbol_footnotesr[]r\Uautofootnote_refsr]]r^Usymbol_footnote_refsr_]r`U citationsra]rbh0hU current_linercNUtransform_messagesrd]re(h)rf}rg(hUh$}rh(h&]UlevelKh+]h*]Usourceh h)]h.]UlineK•UtypejEuh1]rih>)rj}rk(hUh$}rl(h&]h)]h*]h+]h.]uhjfh1]rmh:X.Hyperlink target "rfc 2368" is not referenced.rn…ro}rp(hUhjjubah"hAubah"jBubh)rq}rr(hUh$}rs(h&]UlevelKh+]h*]Usourceh h)]h.]UlineK–UtypejEuh1]rth>)ru}rv(hUh$}rw(h&]h)]h*]h+]h.]uhjqh1]rxh:X.Hyperlink target "rfc 3513" is not referenced.ry…rz}r{(hUhjuubah"hAubah"jBubeUreporterr|NUid_startr}KU autofootnotesr~]rU citation_refsr€}rUindirect_targetsr‚]rƒUsettingsr„(cdocutils.frontend Values r…or†}r‡(Ufootnote_backlinksrˆKUrecord_dependenciesr‰NU rfc_base_urlrŠUhttp://tools.ietf.org/html/r‹U tracebackrŒˆUpep_referencesrNUstrip_commentsrŽNU toc_backlinksrjU language_coderUenr‘U datestampr’NU report_levelr“KU _destinationr”NU halt_levelr•KU strip_classesr–Nh7NUerror_encoding_error_handlerr—Ubackslashreplacer˜Udebugr™NUembed_stylesheetrš‰Uoutput_encoding_error_handlerr›UstrictrœU sectnum_xformrKUdump_transformsržNU docinfo_xformrŸKUwarning_streamr NUpep_file_url_templater¡Upep-%04dr¢Uexit_status_levelr£KUconfigr¤NUstrict_visitorr¥NUcloak_email_addressesr¦ˆUtrim_footnote_reference_spacer§‰Uenvr¨NUdump_pseudo_xmlr©NUexpose_internalsrªNUsectsubtitle_xformr«‰U source_linkr¬NUrfc_referencesr­NUoutput_encodingr®Uutf-8r¯U source_urlr°NUinput_encodingr±Uutf-8r²U_disable_configr³NU id_prefixr´UU tab_widthrµKUerror_encodingr¶UUS-ASCIIr·U_sourcer¸UB/Users/dean/Documents/cpp-netlib/libs/network/doc/in_depth/uri.rstr¹Ugettext_compactrºˆU generatorr»NUdump_internalsr¼NU smart_quotesr½‰U pep_base_urlr¾Uhttp://www.python.org/dev/peps/r¿Usyntax_highlightrÀUlongrÁUinput_encoding_error_handlerrÂjœUauto_id_prefixrÃUidrÄUdoctitle_xformrʼnUstrip_elements_with_classesrÆNU _config_filesrÇ]Ufile_insertion_enabledrȈU raw_enabledrÉKU dump_settingsrÊNubUsymbol_footnote_startrËKUidsrÌ}rÍ(jójïjíjèjhjùjõjejah-hjÿjûj§j£hh}uUsubstitution_namesrÎ}rÏh"h0h$}rÐ(h&]h+]h*]Usourceh h)]h.]uU footnotesrÑ]rÒUrefidsrÓ}rÔub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/index.doctree000066400000000000000000000526051240331347200266760ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xgetting cpp-netlibqNXindexqˆXgithubqˆXc++ network libraryq NX hello, world!q NXwant to learn more?q NXboostq ˆuUsubstitution_defsq }qUparse_messagesq]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUgetting-cpp-netlibqhUindexqhUgithubqh Uc-network-libraryqh U hello-worldqh Uwant-to-learn-moreqh UboostquUchildrenq]q(cdocutils.nodes target q)q }q!(U rawsourceq"X .. _index:Uparentq#hUsourceq$cdocutils.nodes reprunicode q%X;/Users/dean/Documents/cpp-netlib/libs/network/doc/index.rstq&…q'}q(bUtagnameq)Utargetq*U attributesq+}q,(Uidsq-]Ubackrefsq.]Udupnamesq/]Uclassesq0]Unamesq1]Urefidq2huUlineq3KUdocumentq4hh]ubcdocutils.nodes rubric q5)q6}q7(h"X1Straightforward network programming in modern C++q8h#hh$h'Uexpect_referenced_by_nameq9}q:hh sh)Urubricq;h+}q<(h/]h0]h.]h-]q=hah1]q>hauh3Kh4hUexpect_referenced_by_idq?}q@hh sh]qAcdocutils.nodes Text qBX1Straightforward network programming in modern C++qC…qD}qE(h"h8h#h6ubaubcdocutils.nodes comment qF)qG}qH(h"X1:Authors: Glyn Matthews h#hh$h'h)UcommentqIh+}qJ(U xml:spaceqKUpreserveqLh-]h.]h/]h0]h1]uh3Kh4hh]qMhBX1:Authors: Glyn Matthews qN…qO}qP(h"Uh#hGubaubhF)qQ}qR(h"X(Dean Michael Berris h#hh$h'h)hIh+}qS(hKhLh-]h.]h/]h0]h1]uh3Kh4hh]qThBX(Dean Michael Berris qU…qV}qW(h"Uh#hQubaubhF)qX}qY(h"X:Date: 2013-12-21h#hh$h'h)hIh+}qZ(hKhLh-]h.]h/]h0]h1]uh3Kh4hh]q[hBX:Date: 2013-12-21q\…q]}q^(h"Uh#hXubaubhF)q_}q`(h"X:Version: 0.11.0h#hh$h'h)hIh+}qa(hKhLh-]h.]h/]h0]h1]uh3Kh4hh]qbhBX:Version: 0.11.0qc…qd}qe(h"Uh#h_ubaubhF)qf}qg(h"XT:Description: Complete user documentation, with examples, for the :mod:`cpp-netlib`.h#hh$h'h)hIh+}qh(hKhLh-]h.]h/]h0]h1]uh3Kh4hh]qihBXT:Description: Complete user documentation, with examples, for the :mod:`cpp-netlib`.qj…qk}ql(h"Uh#hfubaubhF)qm}qn(h"XC:Copyright: Copyright Glyn Matthews, Dean Michael Berris 2008-2013.h#hh$h'h)hIh+}qo(hKhLh-]h.]h/]h0]h1]uh3K h4hh]qphBXC:Copyright: Copyright Glyn Matthews, Dean Michael Berris 2008-2013.qq…qr}qs(h"Uh#hmubaubhF)qt}qu(h"XCopyrigh 2013 Google, Inc.h#hh$h'h)hIh+}qv(hKhLh-]h.]h/]h0]h1]uh3K h4hh]qwhBXCopyrigh 2013 Google, Inc.qx…qy}qz(h"Uh#htubaubhF)q{}q|(h"X5Distributed under the Boost Software License, Versionh#hh$h'h)hIh+}q}(hKhLh-]h.]h/]h0]h1]uh3K h4hh]q~hBX5Distributed under the Boost Software License, Versionq…q€}q(h"Uh#h{ubaubhF)q‚}qƒ(h"X61.0. (See accompanying file LICENSE_1_0.txt or copy ath#hh$h'h)hIh+}q„(hKhLh-]h.]h/]h0]h1]uh3K h4hh]q…hBX61.0. (See accompanying file LICENSE_1_0.txt or copy atq†…q‡}qˆ(h"Uh#h‚ubaubhF)q‰}qŠ(h"X%http://www.boost.org/LICENSE_1_0.txt)h#hh$h'h)hIh+}q‹(hKhLh-]h.]h/]h0]h1]uh3Kh4hh]qŒhBX%http://www.boost.org/LICENSE_1_0.txt)q…qŽ}q(h"Uh#h‰ubaubcdocutils.nodes section q)q‘}q’(h"Uh#hh$h'h)Usectionq“h+}q”(h/]h0]h.]h-]q•hah1]q–hauh3Kh4hh]q—(cdocutils.nodes title q˜)q™}qš(h"XGetting cpp-netlibq›h#h‘h$h'h)Utitleqœh+}q(h/]h0]h.]h-]h1]uh3Kh4hh]qžhBXGetting cpp-netlibqŸ…q }q¡(h"h›h#h™ubaubcdocutils.nodes paragraph q¢)q£}q¤(h"XTYou can find out more about the :mod:`cpp-netlib` project at http://cpp-netlib.org/.h#h‘h$h'h)U paragraphq¥h+}q¦(h/]h0]h.]h-]h1]uh3Kh4hh]q§(hBX You can find out more about the q¨…q©}qª(h"X You can find out more about the h#h£ubcsphinx.addnodes pending_xref q«)q¬}q­(h"X:mod:`cpp-netlib`q®h#h£h$h'h)U pending_xrefq¯h+}q°(UreftypeXmodUrefwarnq±‰U reftargetq²X cpp-netlibU refdomainXpyq³h-]h.]U refexplicit‰h/]h0]h1]Urefdocq´XindexqµUpy:classq¶NU py:moduleq·Nuh3Kh]q¸cdocutils.nodes literal q¹)qº}q»(h"h®h+}q¼(h/]h0]q½(Uxrefq¾h³Xpy-modq¿eh.]h-]h1]uh#h¬h]qÀhBX cpp-netlibqÁ…qÂ}qÃ(h"Uh#hºubah)UliteralqÄubaubhBX project at qÅ…qÆ}qÇ(h"X project at h#h£ubcdocutils.nodes reference qÈ)qÉ}qÊ(h"Xhttp://cpp-netlib.org/qËh+}qÌ(UrefurihËh-]h.]h/]h0]h1]uh#h£h]qÍhBXhttp://cpp-netlib.org/qÎ…qÏ}qÐ(h"Uh#hÉubah)U referenceqÑubhBX.…qÒ}qÓ(h"X.h#h£ubeubh¢)qÔ}qÕ(h"X **Download**qÖh#h‘h$h'h)h¥h+}q×(h/]h0]h.]h-]h1]uh3Kh4hh]qØcdocutils.nodes strong qÙ)qÚ}qÛ(h"hÖh+}qÜ(h/]h0]h.]h-]h1]uh#hÔh]qÝhBXDownloadqÞ…qß}qà(h"Uh#hÚubah)Ustrongqáubaubh¢)qâ}qã(h"X\You can get the latest official version of the library from the official project website at:qäh#h‘h$h'h)h¥h+}qå(h/]h0]h.]h-]h1]uh3Kh4hh]qæhBX\You can get the latest official version of the library from the official project website at:qç…qè}qé(h"häh#hâubaubcdocutils.nodes block_quote qê)që}qì(h"Uh#h‘h$h'h)U block_quoteqíh+}qî(h/]h0]h.]h-]h1]uh3Nh4hh]qïh¢)qð}qñ(h"Xhttp://cpp-netlib.org/qòh#hëh$h'h)h¥h+}qó(h/]h0]h.]h-]h1]uh3Kh]qôhÈ)qõ}qö(h"hòh+}q÷(Urefurihòh-]h.]h/]h0]h1]uh#hðh]qøhBXhttp://cpp-netlib.org/qù…qú}qû(h"Uh#hõubah)hÑubaubaubh¢)qü}qý(h"XÈThis version of :mod:`cpp-netlib` is tagged as cpp-netlib-0.11.0 in the GitHub_ repository. You can find more information about the progress of the development by checking our GitHub_ project page at:h#h‘h$h'h)h¥h+}qþ(h/]h0]h.]h-]h1]uh3Kh4hh]qÿ(hBXThis version of r…r}r(h"XThis version of h#hüubh«)r}r(h"X:mod:`cpp-netlib`rh#hüh$h'h)h¯h+}r(UreftypeXmodh±‰h²X cpp-netlibU refdomainXpyrh-]h.]U refexplicit‰h/]h0]h1]h´hµh¶Nh·Nuh3Kh]rh¹)r }r (h"jh+}r (h/]h0]r (h¾jXpy-modr eh.]h-]h1]uh#jh]rhBX cpp-netlibr…r}r(h"Uh#j ubah)hÄubaubhBX' is tagged as cpp-netlib-0.11.0 in the r…r}r(h"X' is tagged as cpp-netlib-0.11.0 in the h#hüubhÈ)r}r(h"XGitHub_UresolvedrKh#hüh)hÑh+}r(UnameXGitHubUrefurirXhttp://github.com/rh-]h.]h/]h0]h1]uh]rhBXGitHubr…r}r(h"Uh#jubaubhBXa repository. You can find more information about the progress of the development by checking our r…r }r!(h"Xa repository. You can find more information about the progress of the development by checking our h#hüubhÈ)r"}r#(h"XGitHub_jKh#hüh)hÑh+}r$(UnameXGitHubjjh-]h.]h/]h0]h1]uh]r%hBXGitHubr&…r'}r((h"Uh#j"ubaubhBX project page at:r)…r*}r+(h"X project page at:h#hüubeubhê)r,}r-(h"Uh#h‘h$h'h)híh+}r.(h/]h0]h.]h-]h1]uh3Nh4hh]r/h¢)r0}r1(h"X'http://github.com/cpp-netlib/cpp-netlibr2h#j,h$h'h)h¥h+}r3(h/]h0]h.]h-]h1]uh3K h]r4hÈ)r5}r6(h"j2h+}r7(Urefurij2h-]h.]h/]h0]h1]uh#j0h]r8hBX'http://github.com/cpp-netlib/cpp-netlibr9…r:}r;(h"Uh#j5ubah)hÑubaubaubh¢)r<}r=(h"X **Support**r>h#h‘h$h'h)h¥h+}r?(h/]h0]h.]h-]h1]uh3K"h4hh]r@hÙ)rA}rB(h"j>h+}rC(h/]h0]h.]h-]h1]uh#j<h]rDhBXSupportrE…rF}rG(h"Uh#jAubah)háubaubh¢)rH}rI(h"XlYou can ask questions, join the discussion, and report issues to the developers mailing list by joining via:rJh#h‘h$h'h)h¥h+}rK(h/]h0]h.]h-]h1]uh3K$h4hh]rLhBXlYou can ask questions, join the discussion, and report issues to the developers mailing list by joining via:rM…rN}rO(h"jJh#jHubaubhê)rP}rQ(h"Uh#h‘h$h'h)híh+}rR(h/]h0]h.]h-]h1]uh3Nh4hh]rSh¢)rT}rU(h"X*https://groups.google.com/group/cpp-netlibrVh#jPh$h'h)h¥h+}rW(h/]h0]h.]h-]h1]uh3K'h]rXhÈ)rY}rZ(h"jVh+}r[(UrefurijVh-]h.]h/]h0]h1]uh#jTh]r\hBX*https://groups.google.com/group/cpp-netlibr]…r^}r_(h"Uh#jYubah)hÑubaubaubh¢)r`}ra(h"X9You can also file issues on the Github_ issue tracker at:rbh#h‘h$h'h)h¥h+}rc(h/]h0]h.]h-]h1]uh3K)h4hh]rd(hBX You can also file issues on the re…rf}rg(h"X You can also file issues on the h#j`ubhÈ)rh}ri(h"XGithub_jKh#j`h)hÑh+}rj(UnameXGithubjjh-]h.]h/]h0]h1]uh]rkhBXGithubrl…rm}rn(h"Uh#jhubaubhBX issue tracker at:ro…rp}rq(h"X issue tracker at:h#j`ubeubhê)rr}rs(h"Uh#h‘h$h'h)híh+}rt(h/]h0]h.]h-]h1]uh3Nh4hh]ruh¢)rv}rw(h"X.http://github.com/cpp-netlib/cpp-netlib/issuesrxh#jrh$h'h)h¥h+}ry(h/]h0]h.]h-]h1]uh3K+h]rzhÈ)r{}r|(h"jxh+}r}(Urefurijxh-]h.]h/]h0]h1]uh#jvh]r~hBX.http://github.com/cpp-netlib/cpp-netlib/issuesr…r€}r(h"Uh#j{ubah)hÑubaubaubh¢)r‚}rƒ(h"XRWe are a growing community and we are happy to accept new contributions and ideas.r„h#h‘h$h'h)h¥h+}r…(h/]h0]h.]h-]h1]uh3K-h4hh]r†hBXRWe are a growing community and we are happy to accept new contributions and ideas.r‡…rˆ}r‰(h"j„h#j‚ubaubeubh)rŠ}r‹(h"Uh#hh$h'h)h“h+}rŒ(h/]h0]h.]h-]rhah1]rŽh auh3K1h4hh]r(h˜)r}r‘(h"XC++ Network Libraryr’h#jŠh$h'h)hœh+}r“(h/]h0]h.]h-]h1]uh3K1h4hh]r”hBXC++ Network Libraryr•…r–}r—(h"j’h#jubaubh¢)r˜}r™(h"XÓ:mod:`cpp-netlib` is a library collection that provides application layer protocol support using modern C++ techniques. It is light-weight, fast, portable and is intended to be as easy to configure as possible.h#jŠh$h'h)h¥h+}rš(h/]h0]h.]h-]h1]uh3K3h4hh]r›(h«)rœ}r(h"X:mod:`cpp-netlib`ržh#j˜h$h'h)h¯h+}rŸ(UreftypeXmodh±‰h²X cpp-netlibU refdomainXpyr h-]h.]U refexplicit‰h/]h0]h1]h´hµh¶Nh·Nuh3K3h]r¡h¹)r¢}r£(h"jžh+}r¤(h/]h0]r¥(h¾j Xpy-modr¦eh.]h-]h1]uh#jœh]r§hBX cpp-netlibr¨…r©}rª(h"Uh#j¢ubah)hÄubaubhBX is a library collection that provides application layer protocol support using modern C++ techniques. It is light-weight, fast, portable and is intended to be as easy to configure as possible.r«…r¬}r­(h"X is a library collection that provides application layer protocol support using modern C++ techniques. It is light-weight, fast, portable and is intended to be as easy to configure as possible.h#j˜ubeubeubh)r®}r¯(h"Uh#hh$h'h)h“h+}r°(h/]h0]h.]h-]r±hah1]r²h auh3K8h4hh]r³(h˜)r´}rµ(h"X Hello, world!r¶h#j®h$h'h)hœh+}r·(h/]h0]h.]h-]h1]uh3K8h4hh]r¸hBX Hello, world!r¹…rº}r»(h"j¶h#j´ubaubh¢)r¼}r½(h"XnThe :mod:`cpp-netlib` allows developers to write fast, portable network applications with the minimum of fuss.h#j®h$h'h)h¥h+}r¾(h/]h0]h.]h-]h1]uh3K:h4hh]r¿(hBXThe rÀ…rÁ}rÂ(h"XThe h#j¼ubh«)rÃ}rÄ(h"X:mod:`cpp-netlib`rÅh#j¼h$h'h)h¯h+}rÆ(UreftypeXmodh±‰h²X cpp-netlibU refdomainXpyrÇh-]h.]U refexplicit‰h/]h0]h1]h´hµh¶Nh·Nuh3K:h]rÈh¹)rÉ}rÊ(h"jÅh+}rË(h/]h0]rÌ(h¾jÇXpy-modrÍeh.]h-]h1]uh#jÃh]rÎhBX cpp-netlibrÏ…rÐ}rÑ(h"Uh#jÉubah)hÄubaubhBXY allows developers to write fast, portable network applications with the minimum of fuss.rÒ…rÓ}rÔ(h"XY allows developers to write fast, portable network applications with the minimum of fuss.h#j¼ubeubh¢)rÕ}rÖ(h"XgAn HTTP server-client example can be written in tens of lines of code. The client is as simple as this:r×h#j®h$h'h)h¥h+}rØ(h/]h0]h.]h-]h1]uh3K=h4hh]rÙhBXgAn HTTP server-client example can be written in tens of lines of code. The client is as simple as this:rÚ…rÛ}rÜ(h"j×h#jÕubaubcdocutils.nodes literal_block rÝ)rÞ}rß(h"Xusing namespace boost::network; using namespace boost::network::http; client::request request_("http://127.0.0.1:8000/"); request_ << header("Connection", "close"); client client_; client::response response_ = client_.get(request_); std::string body_ = body(response_);h#j®h$h'h)U literal_blockràh+}rá(Ulinenosrâ‰UlanguagerãXcpphKhLh-]h.]h/]h0]h1]uh3K@h4hh]rähBXusing namespace boost::network; using namespace boost::network::http; client::request request_("http://127.0.0.1:8000/"); request_ << header("Connection", "close"); client client_; client::response response_ = client_.get(request_); std::string body_ = body(response_);rå…ræ}rç(h"Uh#jÞubaubh¢)rè}ré(h"X2And the corresponding server code is listed below:rêh#j®h$h'h)h¥h+}rë(h/]h0]h.]h-]h1]uh3KKh4hh]rìhBX2And the corresponding server code is listed below:rí…rî}rï(h"jêh#jèubaubjÝ)rð}rñ(h"X¡namespace http = boost::network::http; struct handler; typedef http::server http_server; struct handler { void operator() (http_server::request const &request, http_server::response &response) { response = http_server::response::stock_reply( http_server::response::ok, "Hello, world!"); } void log(http_server::string_type const &info) { std::cerr << "ERROR: " << info << '\n'; } }; int main(int arg, char * argv[]) { handler handler_; http_server::options options(handler_); http_server server_( options.address("0.0.0.0") .port("8000")); server_.run(); }h#j®h$h'h)jàh+}rò(jâ‰jãXcpphKhLh-]h.]h/]h0]h1]uh3KMh4hh]róhBX¡namespace http = boost::network::http; struct handler; typedef http::server http_server; struct handler { void operator() (http_server::request const &request, http_server::response &response) { response = http_server::response::stock_reply( http_server::response::ok, "Hello, world!"); } void log(http_server::string_type const &info) { std::cerr << "ERROR: " << info << '\n'; } }; int main(int arg, char * argv[]) { handler handler_; http_server::options options(handler_); http_server server_( options.address("0.0.0.0") .port("8000")); server_.run(); }rô…rõ}rö(h"Uh#jðubaubeubh)r÷}rø(h"Uh#hh$h'h)h“h+}rù(h/]h0]h.]h-]rúhah1]rûh auh3Kjh4hh]rü(h˜)rý}rþ(h"XWant to learn more?rÿh#j÷h$h'h)hœh+}r(h/]h0]h.]h-]h1]uh3Kjh4hh]rhBXWant to learn more?r…r}r(h"jÿh#jýubaubhê)r}r(h"Uh#j÷h$Nh)híh+}r(h/]h0]h.]h-]h1]uh3Nh4hh]rcdocutils.nodes bullet_list r )r }r (h"Uh+}r (Ubulletr X*h-]h.]h/]h0]h1]uh#jh]r(cdocutils.nodes list_item r)r}r(h"XA:ref:`Take a look at the getting started guide `rh+}r(h/]h0]h.]h-]h1]uh#j h]rh¢)r}r(h"jh#jh$h'h)h¥h+}r(h/]h0]h.]h-]h1]uh3Klh]rh«)r}r(h"jh#jh$h'h)h¯h+}r(UreftypeXrefh±ˆh²Xgetting_startedU refdomainXstdrh-]h.]U refexplicitˆh/]h0]h1]h´hµuh3Klh]rcdocutils.nodes emphasis r)r}r (h"jh+}r!(h/]h0]r"(h¾jXstd-refr#eh.]h-]h1]uh#jh]r$hBX(Take a look at the getting started guider%…r&}r'(h"Uh#jubah)Uemphasisr(ubaubaubah)U list_itemr)ubj)r*}r+(h"X1:ref:`Learn from some simple examples `r,h+}r-(h/]h0]h.]h-]h1]uh#j h]r.h¢)r/}r0(h"j,h#j*h$h'h)h¥h+}r1(h/]h0]h.]h-]h1]uh3Kmh]r2h«)r3}r4(h"j,h#j/h$h'h)h¯h+}r5(UreftypeXrefh±ˆh²XexamplesU refdomainXstdr6h-]h.]U refexplicitˆh/]h0]h1]h´hµuh3Kmh]r7j)r8}r9(h"j,h+}r:(h/]h0]r;(h¾j6Xstd-refr<eh.]h-]h1]uh#j3h]r=hBXLearn from some simple examplesr>…r?}r@(h"Uh#j8ubah)j(ubaubaubah)j)ubj)rA}rB(h"X&:ref:`Find out what's new `rCh+}rD(h/]h0]h.]h-]h1]uh#j h]rEh¢)rF}rG(h"jCh#jAh$h'h)h¥h+}rH(h/]h0]h.]h-]h1]uh3Knh]rIh«)rJ}rK(h"jCh#jFh$h'h)h¯h+}rL(UreftypeXrefh±ˆh²X whats_newU refdomainXstdrMh-]h.]U refexplicitˆh/]h0]h1]h´hµuh3Knh]rNj)rO}rP(h"jCh+}rQ(h/]h0]rR(h¾jMXstd-refrSeh.]h-]h1]uh#jJh]rThBXFind out what's newrU…rV}rW(h"Uh#jOubah)j(ubaubaubah)j)ubj)rX}rY(h"X1:ref:`Study the library in more depth `rZh+}r[(h/]h0]h.]h-]h1]uh#j h]r\h¢)r]}r^(h"jZh#jXh$h'h)h¥h+}r_(h/]h0]h.]h-]h1]uh3Koh]r`h«)ra}rb(h"jZh#j]h$h'h)h¯h+}rc(UreftypeXrefh±ˆh²Xin_depthU refdomainXstdrdh-]h.]U refexplicitˆh/]h0]h1]h´hµuh3Koh]rej)rf}rg(h"jZh+}rh(h/]h0]ri(h¾jdXstd-refrjeh.]h-]h1]uh#jah]rkhBXStudy the library in more depthrl…rm}rn(h"Uh#jfubah)j(ubaubaubah)j)ubj)ro}rp(h"X;:ref:`Discover more through the full reference `rqh+}rr(h/]h0]h.]h-]h1]uh#j h]rsh¢)rt}ru(h"jqh#joh$h'h)h¥h+}rv(h/]h0]h.]h-]h1]uh3Kph]rwh«)rx}ry(h"jqh#jth$h'h)h¯h+}rz(UreftypeXrefh±ˆh²X referenceU refdomainXstdr{h-]h.]U refexplicitˆh/]h0]h1]h´hµuh3Kph]r|j)r}}r~(h"jqh+}r(h/]h0]r€(h¾j{Xstd-refreh.]h-]h1]uh#jxh]r‚hBX(Discover more through the full referencerƒ…r„}r…(h"Uh#j}ubah)j(ubaubaubah)j)ubj)r†}r‡(h"X):ref:`Full table of contents ` h+}rˆ(h/]h0]h.]h-]h1]uh#j h]r‰h¢)rŠ}r‹(h"X(:ref:`Full table of contents `rŒh#j†h$h'h)h¥h+}r(h/]h0]h.]h-]h1]uh3Kqh]rŽh«)r}r(h"jŒh#jŠh$h'h)h¯h+}r‘(UreftypeXrefh±ˆh²XcontentsU refdomainXstdr’h-]h.]U refexplicitˆh/]h0]h1]h´hµuh3Kqh]r“j)r”}r•(h"jŒh+}r–(h/]h0]r—(h¾j’Xstd-refr˜eh.]h-]h1]uh#jh]r™hBXFull table of contentsrš…r›}rœ(h"Uh#j”ubah)j(ubaubaubah)j)ubeh)U bullet_listrubaubcdocutils.nodes warning rž)rŸ}r (h"XêBe aware that not all features are stable. The generic message design is under review and the URI and HTTP client implementation will continue to undergo refactoring. Future versions will include support for other network protocols.h#j÷h$h'h)Uwarningr¡h+}r¢(h/]h0]h.]h-]h1]uh3Nh4hh]r£h¢)r¤}r¥(h"XêBe aware that not all features are stable. The generic message design is under review and the URI and HTTP client implementation will continue to undergo refactoring. Future versions will include support for other network protocols.r¦h#jŸh$h'h)h¥h+}r§(h/]h0]h.]h-]h1]uh3Ksh]r¨hBXêBe aware that not all features are stable. The generic message design is under review and the URI and HTTP client implementation will continue to undergo refactoring. Future versions will include support for other network protocols.r©…rª}r«(h"j¦h#j¤ubaubaubh)r¬}r­(h"X .. _Boost: http://www.boost.org/h#j÷h$h'h)h*h+}r®(jXhttp://www.boost.org/h-]r¯hah.]h/]h0]h1]r°h auh3Kzh4hh]ubh)r±}r²(h"X.. _GitHub: http://github.com/U referencedr³Kh#j÷h$h'h)h*h+}r´(jjh-]rµhah.]h/]h0]h1]r¶hauh3K{h4hh]ubeubeh"UU transformerr·NU footnote_refsr¸}r¹Urefnamesrº}r»Xgithub]r¼(jj"jhesUsymbol_footnotesr½]r¾Uautofootnote_refsr¿]rÀUsymbol_footnote_refsrÁ]rÂU citationsrÃ]rÄh4hU current_linerÅNUtransform_messagesrÆ]rÇ(cdocutils.nodes system_message rÈ)rÉ}rÊ(h"Uh+}rË(h/]UlevelKh-]h.]Usourceh'h0]h1]UlineKUtypeUINFOrÌuh]rÍh¢)rÎ}rÏ(h"Uh+}rÐ(h/]h0]h.]h-]h1]uh#jÉh]rÑhBX+Hyperlink target "index" is not referenced.rÒ…rÓ}rÔ(h"Uh#jÎubah)h¥ubah)Usystem_messagerÕubjÈ)rÖ}r×(h"Uh+}rØ(h/]UlevelKh-]h.]Usourceh'h0]h1]UlineKzUtypejÌuh]rÙh¢)rÚ}rÛ(h"Uh+}rÜ(h/]h0]h.]h-]h1]uh#jÖh]rÝhBX+Hyperlink target "boost" is not referenced.rÞ…rß}rà(h"Uh#jÚubah)h¥ubah)jÕubeUreporterráNUid_startrâKU autofootnotesrã]räU citation_refsrå}ræUindirect_targetsrç]rèUsettingsré(cdocutils.frontend Values rêorë}rì(Ufootnote_backlinksríKUrecord_dependenciesrîNU rfc_base_urlrïUhttp://tools.ietf.org/html/rðU tracebackrñˆUpep_referencesròNUstrip_commentsróNU toc_backlinksrôUentryrõU language_coderöUenr÷U datestamprøNU report_levelrùKU _destinationrúNU halt_levelrûKU strip_classesrüNhœNUerror_encoding_error_handlerrýUbackslashreplacerþUdebugrÿNUembed_stylesheetr‰Uoutput_encoding_error_handlerrUstrictrU sectnum_xformrKUdump_transformsrNU docinfo_xformrKUwarning_streamrNUpep_file_url_templaterUpep-%04drUexit_status_levelr KUconfigr NUstrict_visitorr NUcloak_email_addressesr ˆUtrim_footnote_reference_spacer ‰UenvrNUdump_pseudo_xmlrNUexpose_internalsrNUsectsubtitle_xformr‰U source_linkrNUrfc_referencesrNUoutput_encodingrUutf-8rU source_urlrNUinput_encodingrUutf-8rU_disable_configrNU id_prefixrUU tab_widthrKUerror_encodingrUUS-ASCIIrU_sourcerU;/Users/dean/Documents/cpp-netlib/libs/network/doc/index.rstrUgettext_compactr ˆU generatorr!NUdump_internalsr"NU smart_quotesr#‰U pep_base_urlr$Uhttp://www.python.org/dev/peps/r%Usyntax_highlightr&Ulongr'Uinput_encoding_error_handlerr(jUauto_id_prefixr)Uidr*Udoctitle_xformr+‰Ustrip_elements_with_classesr,NU _config_filesr-]Ufile_insertion_enabledr.ˆU raw_enabledr/KU dump_settingsr0NubUsymbol_footnote_startr1KUidsr2}r3(hh6hj±hj®hh‘hjŠhj÷hj¬uUsubstitution_namesr4}r5h)h4h+}r6(h/]h-]h.]Usourceh'h0]h1]uU footnotesr7]r8Urefidsr9}r:h]r;h asub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/reference.doctree000066400000000000000000000106351240331347200275220ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xreference manualqNX referenceqˆuUsubstitution_defsq}q Uparse_messagesq ]q Ucurrent_sourceq NU decorationq NUautofootnote_startqKUnameidsq}q(hUreference-manualqhU referencequUchildrenq]q(cdocutils.nodes target q)q}q(U rawsourceqX.. _reference:UparentqhUsourceqcdocutils.nodes reprunicode qX?/Users/dean/Documents/cpp-netlib/libs/network/doc/reference.rstq…q}qbUtagnameqUtargetq U attributesq!}q"(Uidsq#]Ubackrefsq$]Udupnamesq%]Uclassesq&]Unamesq']Urefidq(huUlineq)KUdocumentq*hh]ubcdocutils.nodes section q+)q,}q-(hUhhhhUexpect_referenced_by_nameq.}q/hhshUsectionq0h!}q1(h%]h&]h$]h#]q2(hheh']q3(hheuh)Kh*hUexpect_referenced_by_idq4}q5hhsh]q6(cdocutils.nodes title q7)q8}q9(hXReference Manualq:hh,hhhUtitleq;h!}q<(h%]h&]h$]h#]h']uh)Kh*hh]q=cdocutils.nodes Text q>XReference Manualq?…q@}qA(hh:hh8ubaubcdocutils.nodes paragraph qB)qC}qD(hXžThis reference manual refers to the API documentation of the public interfaces to the different client and/or server implementations within :mod:`cpp-netlib`.hh,hhhU paragraphqEh!}qF(h%]h&]h$]h#]h']uh)Kh*hh]qG(h>XŒThis reference manual refers to the API documentation of the public interfaces to the different client and/or server implementations within qH…qI}qJ(hXŒThis reference manual refers to the API documentation of the public interfaces to the different client and/or server implementations within hhCubcsphinx.addnodes pending_xref qK)qL}qM(hX:mod:`cpp-netlib`qNhhChhhU pending_xrefqOh!}qP(UreftypeXmodUrefwarnqQ‰U reftargetqRX cpp-netlibU refdomainXpyqSh#]h$]U refexplicit‰h%]h&]h']UrefdocqTX referenceqUUpy:classqVNU py:moduleqWNuh)Kh]qXcdocutils.nodes literal qY)qZ}q[(hhNh!}q\(h%]h&]q](Uxrefq^hSXpy-modq_eh$]h#]h']uhhLh]q`h>X cpp-netlibqa…qb}qc(hUhhZubahUliteralqdubaubh>X.…qe}qf(hX.hhCubeubcdocutils.nodes compound qg)qh}qi(hUhh,hhhUcompoundqjh!}qk(h%]h&]qlUtoctree-wrapperqmah$]h#]h']uh)Nh*hh]qncsphinx.addnodes toctree qo)qp}qq(hUhhhhhhUtoctreeqrh!}qs(UnumberedqtKU includehiddenqu‰hhUU titlesonlyqv‰Uglobqw‰h#]h$]h%]h&]h']Uentriesqx]qy(NXreference/http_clientqz†q{NXreference/http_requestq|†q}NXreference/http_responseq~†qNXreference/http_serverq€†qeUhiddenq‚‰U includefilesqƒ]q„(hzh|h~h€eUmaxdepthq…Kuh)K h]ubaubeubehUU transformerq†NU footnote_refsq‡}qˆUrefnamesq‰}qŠUsymbol_footnotesq‹]qŒUautofootnote_refsq]qŽUsymbol_footnote_refsq]qU citationsq‘]q’h*hU current_lineq“NUtransform_messagesq”]q•cdocutils.nodes system_message q–)q—}q˜(hUh!}q™(h%]UlevelKh#]h$]Usourcehh&]h']UlineKUtypeUINFOqšuh]q›hB)qœ}q(hUh!}qž(h%]h&]h$]h#]h']uhh—h]qŸh>X/Hyperlink target "reference" is not referenced.q …q¡}q¢(hUhhœubahhEubahUsystem_messageq£ubaUreporterq¤NUid_startq¥KU autofootnotesq¦]q§U citation_refsq¨}q©Uindirect_targetsqª]q«Usettingsq¬(cdocutils.frontend Values q­oq®}q¯(Ufootnote_backlinksq°KUrecord_dependenciesq±NU rfc_base_urlq²Uhttp://tools.ietf.org/html/q³U tracebackq´ˆUpep_referencesqµNUstrip_commentsq¶NU toc_backlinksq·Uentryq¸U language_codeq¹UenqºU datestampq»NU report_levelq¼KU _destinationq½NU halt_levelq¾KU strip_classesq¿Nh;NUerror_encoding_error_handlerqÀUbackslashreplaceqÁUdebugqÂNUembed_stylesheetqÉUoutput_encoding_error_handlerqÄUstrictqÅU sectnum_xformqÆKUdump_transformsqÇNU docinfo_xformqÈKUwarning_streamqÉNUpep_file_url_templateqÊUpep-%04dqËUexit_status_levelqÌKUconfigqÍNUstrict_visitorqÎNUcloak_email_addressesqψUtrim_footnote_reference_spaceqЉUenvqÑNUdump_pseudo_xmlqÒNUexpose_internalsqÓNUsectsubtitle_xformqÔ‰U source_linkqÕNUrfc_referencesqÖNUoutput_encodingq×Uutf-8qØU source_urlqÙNUinput_encodingqÚUutf-8qÛU_disable_configqÜNU id_prefixqÝUU tab_widthqÞKUerror_encodingqßUUS-ASCIIqàU_sourceqáU?/Users/dean/Documents/cpp-netlib/libs/network/doc/reference.rstqâUgettext_compactqãˆU generatorqäNUdump_internalsqåNU smart_quotesqæ‰U pep_base_urlqçUhttp://www.python.org/dev/peps/qèUsyntax_highlightqéUlongqêUinput_encoding_error_handlerqëhÅUauto_id_prefixqìUidqíUdoctitle_xformqî‰Ustrip_elements_with_classesqïNU _config_filesqð]Ufile_insertion_enabledqñˆU raw_enabledqòKU dump_settingsqóNubUsymbol_footnote_startqôKUidsqõ}qö(hh,hh,uUsubstitution_namesq÷}qøhh*h!}qù(h%]h#]h$]Usourcehh&]h']uU footnotesqú]qûUrefidsqü}qýh]qþhasub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/reference/000077500000000000000000000000001240331347200261465ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/reference/http_client.doctree000066400000000000000000003171321240331347200320410ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xsynchronous clientsqNXasynchronous clientsqNXstreaming body handlerqNX boost.threadq ˆXhttp client apiq NX constructorsq NXimplementationsq NXgeneralq NX active objectqˆX http methodsqNXmember functionsqNXclient-specificqNuUsubstitution_defsq}qUparse_messagesq]qcdocutils.nodes system_message q)q}q(U rawsourceqUUparentqcdocutils.nodes section q)q}q(hUU referencedqKhh)q}q (hUhh)q!}q"(hUhhUsourceq#cdocutils.nodes reprunicode q$XK/Users/dean/Documents/cpp-netlib/libs/network/doc/reference/http_client.rstq%…q&}q'bUtagnameq(Usectionq)U attributesq*}q+(Udupnamesq,]Uclassesq-]Ubackrefsq.]Uidsq/]q0Uhttp-client-apiq1aUnamesq2]q3h auUlineq4KUdocumentq5hUchildrenq6]q7(cdocutils.nodes title q8)q9}q:(hXHTTP Client APIq;hh!h#h&h(Utitleqcdocutils.nodes Text q?XHTTP Client APIq@…qA}qB(hh;hh9ubaubh)qC}qD(hUhh!h#h&h(h)h*}qE(h,]h-]h.]h/]qFUgeneralqGah2]qHh auh4Kh5hh6]qI(h8)qJ}qK(hXGeneralqLhhCh#h&h(h client;hhíh#h&h(U literal_blockrh*}r(Ulinenosr ‰Ulanguager Xc++U xml:spacer Upreserver h/]h.]h,]h-]h2]uh4K‡h5hh6]r h?XŠtypedef boost::network::http::basic_client< boost::network::http::tags::http_default_8bit_udp_resolve , 1 ,1 > client;r…r}r(hUhjubaubhR)r}r(hXIAlso, that code using the HTTP client will have use the following header:rhhíh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4Kh5hh6]rh?XIAlso, that code using the HTTP client will have use the following header:r…r}r(hjhjubaubj)r}r(hX0#include hhíh#h&h(jh*}r(j ‰j Xc++j j h/]h.]h,]h-]h2]uh4K’h5hh6]rh?X0#include r…r}r(hUhjubaubcdocutils.nodes note r )r!}r"(hXMStarting version 0.9, cpp-netlib clients and server implementations by default now have an externally-linked component. This is a breaking change for code that used to rely on cpp-netlib being a header-only library, but can inhibited by defining the ``BOOST_NETWORK_NO_LIB`` preprocessor macro before including any cpp-netlib header.hhíh#h&h(Unoter#h*}r$(h,]h-]h.]h/]h2]uh4Nh5hh6]r%hR)r&}r'(hXMStarting version 0.9, cpp-netlib clients and server implementations by default now have an externally-linked component. This is a breaking change for code that used to rely on cpp-netlib being a header-only library, but can inhibited by defining the ``BOOST_NETWORK_NO_LIB`` preprocessor macro before including any cpp-netlib header.hj!h#h&h(hUh*}r((h,]h-]h.]h/]h2]uh4K–h6]r)(h?XúStarting version 0.9, cpp-netlib clients and server implementations by default now have an externally-linked component. This is a breaking change for code that used to rely on cpp-netlib being a header-only library, but can inhibited by defining the r*…r+}r,(hXúStarting version 0.9, cpp-netlib clients and server implementations by default now have an externally-linked component. This is a breaking change for code that used to rely on cpp-netlib being a header-only library, but can inhibited by defining the hj&ubhf)r-}r.(hX``BOOST_NETWORK_NO_LIB``h*}r/(h,]h-]h.]h/]h2]uhj&h6]r0h?XBOOST_NETWORK_NO_LIBr1…r2}r3(hUhj-ubah(hqubh?X; preprocessor macro before including any cpp-netlib header.r4…r5}r6(hX; preprocessor macro before including any cpp-netlib header.hj&ubeubaubj )r7}r8(hX{Starting version 0.11, cpp-netlib clients and server implementations no longer support the ``BOOST_NETWORK_NO_LIB`` option.hhíh#h&h(j#h*}r9(h,]h-]h.]h/]h2]uh4Nh5hh6]r:hR)r;}r<(hX{Starting version 0.11, cpp-netlib clients and server implementations no longer support the ``BOOST_NETWORK_NO_LIB`` option.hj7h#h&h(hUh*}r=(h,]h-]h.]h/]h2]uh4Kœh6]r>(h?X[Starting version 0.11, cpp-netlib clients and server implementations no longer support the r?…r@}rA(hX[Starting version 0.11, cpp-netlib clients and server implementations no longer support the hj;ubhf)rB}rC(hX``BOOST_NETWORK_NO_LIB``h*}rD(h,]h-]h.]h/]h2]uhj;h6]rEh?XBOOST_NETWORK_NO_LIBrF…rG}rH(hUhjBubah(hqubh?X option.rI…rJ}rK(hX option.hj;ubeubaubh)rL}rM(hUhhíh#h&h(h)h*}rN(h,]h-]h.]h/]rOU constructorsrPah2]rQh auh4K h5hh6]rR(h8)rS}rT(hX ConstructorsrUhjLh#h&h(h`` object. The following table shows the options you can set on a ``client_options`` instance. hjdh#h&h(jlh*}r(h,]h-]h.]h/]h2]uh4K©h5hh6]rŽ(jo)r}r(hX,``explicit client(client::options const &)``r‘hj‹h#h&h(jsh*}r’(h,]h-]h.]h/]h2]uh4K©h6]r“hf)r”}r•(hj‘h*}r–(h,]h-]h.]h/]h2]uhjh6]r—h?X(explicit client(client::options const &)r˜…r™}rš(hUhj”ubah(hqubaubj})r›}rœ(hUh*}r(h,]h-]h.]h/]h2]uhj‹h6]ržhR)rŸ}r (hXConstructor taking a ``client_options`` object. The following table shows the options you can set on a ``client_options`` instance.hj›h#h&h(hUh*}r¡(h,]h-]h.]h/]h2]uh4K¨h6]r¢(h?XConstructor taking a r£…r¤}r¥(hXConstructor taking a hjŸubhf)r¦}r§(hX``client_options``h*}r¨(h,]h-]h.]h/]h2]uhjŸh6]r©h?Xclient_optionsrª…r«}r¬(hUhj¦ubah(hqubh?X@ object. The following table shows the options you can set on a r­…r®}r¯(hX@ object. The following table shows the options you can set on a hjŸubhf)r°}r±(hX``client_options``h*}r²(h,]h-]h.]h/]h2]uhjŸh6]r³h?Xclient_optionsr´…rµ}r¶(hUhj°ubah(hqubh?X instance.r·…r¸}r¹(hX instance.hjŸubeubah(jŠubeubeubcdocutils.nodes table rº)r»}r¼(hUhjLh#h&h(Utabler½h*}r¾(h,]h-]h.]h/]h2]uh4Nh5hh6]r¿cdocutils.nodes tgroup rÀ)rÁ}rÂ(hUh*}rÃ(h/]h.]h,]h-]h2]UcolsKuhj»h6]rÄ(cdocutils.nodes colspec rÅ)rÆ}rÇ(hUh*}rÈ(h/]h.]h,]h-]h2]UcolwidthKuhjÁh6]h(UcolspecrÉubjÅ)rÊ}rË(hUh*}rÌ(h/]h.]h,]h-]h2]UcolwidthKuhjÁh6]h(jÉubjÅ)rÍ}rÎ(hUh*}rÏ(h/]h.]h,]h-]h2]UcolwidthKuhjÁh6]h(jÉubcdocutils.nodes thead rÐ)rÑ}rÒ(hUh*}rÓ(h,]h-]h.]h/]h2]uhjÁh6]rÔcdocutils.nodes row rÕ)rÖ}r×(hUh*}rØ(h,]h-]h.]h/]h2]uhjÑh6]rÙ(cdocutils.nodes entry rÚ)rÛ}rÜ(hUh*}rÝ(h,]h-]h.]h/]h2]uhjÖh6]rÞhR)rß}rà(hXParameter NameráhjÛh#h&h(hUh*}râ(h,]h-]h.]h/]h2]uh4K¬h6]rãh?XParameter Namerä…rå}ræ(hjáhjßubaubah(UentryrçubjÚ)rè}ré(hUh*}rê(h,]h-]h.]h/]h2]uhjÖh6]rëhR)rì}rí(hXTyperîhjèh#h&h(hUh*}rï(h,]h-]h.]h/]h2]uh4K¬h6]rðh?XTyperñ…rò}ró(hjîhjìubaubah(jçubjÚ)rô}rõ(hUh*}rö(h,]h-]h.]h/]h2]uhjÖh6]r÷hR)rø}rù(hX Descriptionrúhjôh#h&h(hUh*}rû(h,]h-]h.]h/]h2]uh4K¬h6]rüh?X Descriptionrý…rþ}rÿ(hjúhjøubaubah(jçubeh(Urowrubah(Utheadrubcdocutils.nodes tbody r)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjÁh6]r(jÕ)r}r(hUh*}r (h,]h-]h.]h/]h2]uhjh6]r (jÚ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjh6]rhR)r}r(hXfollow_redirectsrhj h#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4K®h6]rh?Xfollow_redirectsr…r}r(hjhjubaubah(jçubjÚ)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjh6]rhR)r}r(hX``bool``rhjh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4K®h6]rhf)r }r!(hjh*}r"(h,]h-]h.]h/]h2]uhjh6]r#h?Xboolr$…r%}r&(hUhj ubah(hqubaubah(jçubjÚ)r'}r((hUh*}r)(h,]h-]h.]h/]h2]uhjh6]r*hR)r+}r,(hXYBoolean to specify whether the client should follow HTTP redirects. Default is ``false``.hj'h#h&h(hUh*}r-(h,]h-]h.]h/]h2]uh4K®h6]r.(h?XOBoolean to specify whether the client should follow HTTP redirects. Default is r/…r0}r1(hXOBoolean to specify whether the client should follow HTTP redirects. Default is hj+ubhf)r2}r3(hX ``false``h*}r4(h,]h-]h.]h/]h2]uhj+h6]r5h?Xfalser6…r7}r8(hUhj2ubah(hqubh?X.…r9}r:(hX.hj+ubeubah(jçubeh(jubjÕ)r;}r<(hUh*}r=(h,]h-]h.]h/]h2]uhjh6]r>(jÚ)r?}r@(hUh*}rA(h,]h-]h.]h/]h2]uhj;h6]rBhR)rC}rD(hXcache_resolvedrEhj?h#h&h(hUh*}rF(h,]h-]h.]h/]h2]uh4K´h6]rGh?Xcache_resolvedrH…rI}rJ(hjEhjCubaubah(jçubjÚ)rK}rL(hUh*}rM(h,]h-]h.]h/]h2]uhj;h6]rNhR)rO}rP(hX``bool``rQhjKh#h&h(hUh*}rR(h,]h-]h.]h/]h2]uh4K´h6]rShf)rT}rU(hjQh*}rV(h,]h-]h.]h/]h2]uhjOh6]rWh?XboolrX…rY}rZ(hUhjTubah(hqubaubah(jçubjÚ)r[}r\(hUh*}r](h,]h-]h.]h/]h2]uhj;h6]r^hR)r_}r`(hX`Boolean to specify whether the client should cache resolved endpoints. The default is ``false``.hj[h#h&h(hUh*}ra(h,]h-]h.]h/]h2]uh4K´h6]rb(h?XVBoolean to specify whether the client should cache resolved endpoints. The default is rc…rd}re(hXVBoolean to specify whether the client should cache resolved endpoints. The default is hj_ubhf)rf}rg(hX ``false``h*}rh(h,]h-]h.]h/]h2]uhj_h6]rih?Xfalserj…rk}rl(hUhjfubah(hqubh?X.…rm}rn(hX.hj_ubeubah(jçubeh(jubjÕ)ro}rp(hUh*}rq(h,]h-]h.]h/]h2]uhjh6]rr(jÚ)rs}rt(hUh*}ru(h,]h-]h.]h/]h2]uhjoh6]rvhR)rw}rx(hX io_serviceryhjsh#h&h(hUh*}rz(h,]h-]h.]h/]h2]uh4Kºh6]r{h?X io_servicer|…r}}r~(hjyhjwubaubah(jçubjÚ)r}r€(hUh*}r(h,]h-]h.]h/]h2]uhjoh6]r‚hR)rƒ}r„(hX``shared_ptr``r…hjh#h&h(hUh*}r†(h,]h-]h.]h/]h2]uh4Kºh6]r‡hf)rˆ}r‰(hj…h*}rŠ(h,]h-]h.]h/]h2]uhjƒh6]r‹h?Xshared_ptrrŒ…r}rŽ(hUhjˆubah(hqubaubah(jçubjÚ)r}r(hUh*}r‘(h,]h-]h.]h/]h2]uhjoh6]r’hR)r“}r”(hX.Shared pointer to a Boost.Asio ``io_service``.hjh#h&h(hUh*}r•(h,]h-]h.]h/]h2]uh4Kºh6]r–(h?XShared pointer to a Boost.Asio r—…r˜}r™(hXShared pointer to a Boost.Asio hj“ubhf)rš}r›(hX``io_service``h*}rœ(h,]h-]h.]h/]h2]uhj“h6]rh?X io_servicerž…rŸ}r (hUhjšubah(hqubh?X.…r¡}r¢(hX.hj“ubeubah(jçubeh(jubjÕ)r£}r¤(hUh*}r¥(h,]h-]h.]h/]h2]uhjh6]r¦(jÚ)r§}r¨(hUh*}r©(h,]h-]h.]h/]h2]uhj£h6]rªhR)r«}r¬(hXopenssl_certificater­hj§h#h&h(hUh*}r®(h,]h-]h.]h/]h2]uh4K¾h6]r¯h?Xopenssl_certificater°…r±}r²(hj­hj«ubaubah(jçubjÚ)r³}r´(hUh*}rµ(h,]h-]h.]h/]h2]uhj£h6]r¶hR)r·}r¸(hX ``string``r¹hj³h#h&h(hUh*}rº(h,]h-]h.]h/]h2]uh4K¾h6]r»hf)r¼}r½(hj¹h*}r¾(h,]h-]h.]h/]h2]uhj·h6]r¿h?XstringrÀ…rÁ}rÂ(hUhj¼ubah(hqubaubah(jçubjÚ)rÃ}rÄ(hUh*}rÅ(h,]h-]h.]h/]h2]uhj£h6]rÆhR)rÇ}rÈ(hXPThe filename of the certificate to load for the SSL connection for verification.rÉhjÃh#h&h(hUh*}rÊ(h,]h-]h.]h/]h2]uh4K¾h6]rËh?XPThe filename of the certificate to load for the SSL connection for verification.rÌ…rÍ}rÎ(hjÉhjÇubaubah(jçubeh(jubjÕ)rÏ}rÐ(hUh*}rÑ(h,]h-]h.]h/]h2]uhjh6]rÒ(jÚ)rÓ}rÔ(hUh*}rÕ(h,]h-]h.]h/]h2]uhjÏh6]rÖhR)r×}rØ(hXopenssl_verify_pathrÙhjÓh#h&h(hUh*}rÚ(h,]h-]h.]h/]h2]uh4KÃh6]rÛh?Xopenssl_verify_pathrÜ…rÝ}rÞ(hjÙhj×ubaubah(jçubjÚ)rß}rà(hUh*}rá(h,]h-]h.]h/]h2]uhjÏh6]râhR)rã}rä(hX ``string``råhjßh#h&h(hUh*}ræ(h,]h-]h.]h/]h2]uh4KÃh6]rçhf)rè}ré(hjåh*}rê(h,]h-]h.]h/]h2]uhjãh6]rëh?Xstringrì…rí}rî(hUhjèubah(hqubaubah(jçubjÚ)rï}rð(hUh*}rñ(h,]h-]h.]h/]h2]uhjÏh6]ròhR)ró}rô(hXEThe directory from which the certificate authority files are located.rõhjïh#h&h(hUh*}rö(h,]h-]h.]h/]h2]uh4KÃh6]r÷h?XEThe directory from which the certificate authority files are located.rø…rù}rú(hjõhjóubaubah(jçubeh(jubjÕ)rû}rü(hUh*}rý(h,]h-]h.]h/]h2]uhjh6]rþ(jÚ)rÿ}r(hUh*}r(h,]h-]h.]h/]h2]uhjûh6]rhR)r}r(hXalways_verify_peerrhjÿh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4KÈh6]rh?Xalways_verify_peerr…r }r (hjhjubaubah(jçubjÚ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjûh6]rhR)r}r(hX``bool``rhj h#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4KÈh6]rhf)r}r(hjh*}r(h,]h-]h.]h/]h2]uhjh6]rh?Xboolr…r}r(hUhjubah(hqubaubah(jçubjÚ)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjûh6]rhR)r}r (hXSBoolean to specify whether the client should always verify peers in SSL connectionsr!hjh#h&h(hUh*}r"(h,]h-]h.]h/]h2]uh4KÈh6]r#h?XSBoolean to specify whether the client should always verify peers in SSL connectionsr$…r%}r&(hj!hjubaubah(jçubeh(jubeh(Utbodyr'ubeh(Utgroupr(ubaubhR)r)}r*(hX\To use the above supported named parameters, you'll have code that looks like the following:r+hjLh#h&h(hUh*}r,(h,]h-]h.]h/]h2]uh4KÏh5hh6]r-h?X\To use the above supported named parameters, you'll have code that looks like the following:r.…r/}r0(hj+hj)ubaubj)r1}r2(hX~using namespace boost::network::http; // parameters are in this namespace client::options options; options.follow_redirects(true) .cache_resolved(true) .io_service(boost::make_shared()) .openssl_certificate("/tmp/my-cert") .openssl_verify_path("/tmp/ca-certs"); client client_(options); // use client_ as normal from here on out.hjLh#h&h(jh*}r3(j ‰j Xc++j j h/]h.]h,]h-]h2]uh4KÒh5hh6]r4h?X~using namespace boost::network::http; // parameters are in this namespace client::options options; options.follow_redirects(true) .cache_resolved(true) .io_service(boost::make_shared()) .openssl_certificate("/tmp/my-cert") .openssl_verify_path("/tmp/ca-certs"); client client_(options); // use client_ as normal from here on out.r5…r6}r7(hUhj1ubaubeubh)r8}r9(hUhhíh#h&h(h)h*}r:(h,]h-]h.]h/]r;U http-methodsr<ah2]r=hauh4Kßh5hh6]r>(h8)r?}r@(hX HTTP MethodsrAhj8h#h&h(h const &, boost::system::error_code const &)``.hjsh#h&h(jlh*}r•(h,]h-]h.]h/]h2]uh4Kóh5hh6]r–(jo)r—}r˜(hX/``response_ = client_.get(request_, callback)``r™hj“h#h&h(jsh*}rš(h,]h-]h.]h/]h2]uh4Kóh6]r›hf)rœ}r(hj™h*}rž(h,]h-]h.]h/]h2]uhj—h6]rŸh?X+response_ = client_.get(request_, callback)r …r¡}r¢(hUhjœubah(hqubaubj})r£}r¤(hUh*}r¥(h,]h-]h.]h/]h2]uhj“h6]r¦hR)r§}r¨(hXéPerform an HTTP GET request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hj£h#h&h(hUh*}r©(h,]h-]h.]h/]h2]uh4Kñh6]rª(h?XHPerform an HTTP GET request, and have the body chunks be handled by the r«…r¬}r­(hXHPerform an HTTP GET request, and have the body chunks be handled by the hj§ubhf)r®}r¯(hX ``callback``h*}r°(h,]h-]h.]h/]h2]uhj§h6]r±h?Xcallbackr²…r³}r´(hUhj®ubah(hqubh?X parameter. The signature of rµ…r¶}r·(hX parameter. The signature of hj§ubhf)r¸}r¹(hX ``callback``h*}rº(h,]h-]h.]h/]h2]uhj§h6]r»h?Xcallbackr¼…r½}r¾(hUhj¸ubah(hqubh?X should be the following: r¿…rÀ}rÁ(hX should be the following: hj§ubhf)rÂ}rÃ(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}rÄ(h,]h-]h.]h/]h2]uhj§h6]rÅh?XMvoid(iterator_range const &, boost::system::error_code const &)rÆ…rÇ}rÈ(hUhjÂubah(hqubh?X.…rÉ}rÊ(hX.hj§ubeubah(jŠubeubji)rË}rÌ(hXD``response_ = client_.head(request_)`` Perform an HTTP HEAD request.hjsh#h&h(jlh*}rÍ(h,]h-]h.]h/]h2]uh4Kõh5hh6]rÎ(jo)rÏ}rÐ(hX&``response_ = client_.head(request_)``rÑhjËh#h&h(jsh*}rÒ(h,]h-]h.]h/]h2]uh4Kõh6]rÓhf)rÔ}rÕ(hjÑh*}rÖ(h,]h-]h.]h/]h2]uhjÏh6]r×h?X"response_ = client_.head(request_)rØ…rÙ}rÚ(hUhjÔubah(hqubaubj})rÛ}rÜ(hUh*}rÝ(h,]h-]h.]h/]h2]uhjËh6]rÞhR)rß}rà(hXPerform an HTTP HEAD request.ráhjÛh#h&h(hUh*}râ(h,]h-]h.]h/]h2]uh4Köh6]rãh?XPerform an HTTP HEAD request.rä…rå}ræ(hjáhjßubaubah(jŠubeubji)rç}rè(hX•``response_ = client_.post(request_)`` Perform an HTTP POST, use the data already set in the request object which includes the headers, and the body.hjsh#h&h(jlh*}ré(h,]h-]h.]h/]h2]uh4Køh5hh6]rê(jo)rë}rì(hX&``response_ = client_.post(request_)``ríhjçh#h&h(jsh*}rî(h,]h-]h.]h/]h2]uh4Køh6]rïhf)rð}rñ(hjíh*}rò(h,]h-]h.]h/]h2]uhjëh6]róh?X"response_ = client_.post(request_)rô…rõ}rö(hUhjðubah(hqubaubj})r÷}rø(hUh*}rù(h,]h-]h.]h/]h2]uhjçh6]rúhR)rû}rü(hXnPerform an HTTP POST, use the data already set in the request object which includes the headers, and the body.rýhj÷h#h&h(hUh*}rþ(h,]h-]h.]h/]h2]uh4Køh6]rÿh?XnPerform an HTTP POST, use the data already set in the request object which includes the headers, and the body.r…r}r(hjýhjûubaubah(jŠubeubji)r}r(hX``response_ = client_.post(request_, callback)`` Perform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjsh#h&h(jlh*}r(h,]h-]h.]h/]h2]uh4Kýh5hh6]r(jo)r}r(hX0``response_ = client_.post(request_, callback)``r hjh#h&h(jsh*}r (h,]h-]h.]h/]h2]uh4Kýh6]r hf)r }r (hj h*}r(h,]h-]h.]h/]h2]uhjh6]rh?X,response_ = client_.post(request_, callback)r…r}r(hUhj ubah(hqubaubj})r}r(hUh*}r(h,]h-]h.]h/]h2]uhjh6]rhR)r}r(hXêPerform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4Kûh6]r(h?XIPerform an HTTP POST request, and have the body chunks be handled by the r…r}r(hXIPerform an HTTP POST request, and have the body chunks be handled by the hjubhf)r}r(hX ``callback``h*}r (h,]h-]h.]h/]h2]uhjh6]r!h?Xcallbackr"…r#}r$(hUhjubah(hqubh?X parameter. The signature of r%…r&}r'(hX parameter. The signature of hjubhf)r(}r)(hX ``callback``h*}r*(h,]h-]h.]h/]h2]uhjh6]r+h?Xcallbackr,…r-}r.(hUhj(ubah(hqubh?X should be the following: r/…r0}r1(hX should be the following: hjubhf)r2}r3(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}r4(h,]h-]h.]h/]h2]uhjh6]r5h?XMvoid(iterator_range const &, boost::system::error_code const &)r6…r7}r8(hUhj2ubah(hqubh?X.…r9}r:(hX.hjubeubah(jŠubeubji)r;}r<(hXØ``response_ = client_.post(request_, body)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``.hjsh#h&h(jlh*}r=(h,]h-]h.]h/]h2]uh4Mh5hh6]r>(jo)r?}r@(hX,``response_ = client_.post(request_, body)``rAhj;h#h&h(jsh*}rB(h,]h-]h.]h/]h2]uh4Mh6]rChf)rD}rE(hjAh*}rF(h,]h-]h.]h/]h2]uhj?h6]rGh?X(response_ = client_.post(request_, body)rH…rI}rJ(hUhjDubah(hqubaubj})rK}rL(hUh*}rM(h,]h-]h.]h/]h2]uhj;h6]rNhR)rO}rP(hX«Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``.hjKh#h&h(hUh*}rQ(h,]h-]h.]h/]h2]uh4Mh6]rR(h?XBody is a string of type rS…rT}rU(hXBody is a string of type hjOubhf)rV}rW(hX%``boost::network::string::type``h*}rX(h,]h-]h.]h/]h2]uhjOh6]rYh?X!boost::network::string::typerZ…r[}r\(hUhjVubah(hqubh?X where r]…r^}r_(hX where hjOubhf)r`}ra(hX``Tag``h*}rb(h,]h-]h.]h/]h2]uhjOh6]rch?XTagrd…re}rf(hUhj`ubah(hqubh?X is the HTTP Client's rg…rh}ri(hX is the HTTP Client's hjOubhf)rj}rk(hX``Tag``h*}rl(h,]h-]h.]h/]h2]uhjOh6]rmh?XTagrn…ro}rp(hUhjjubah(hqubh?X#. The default content-type used is rq…rr}rs(hX#. The default content-type used is hjOubhf)rt}ru(hX``x-application/octet-stream``h*}rv(h,]h-]h.]h/]h2]uhjOh6]rwh?Xx-application/octet-streamrx…ry}rz(hUhjtubah(hqubh?X.…r{}r|(hX.hjOubeubah(jŠubeubji)r}}r~(hX´``response_ = client_.post(request_, body, callback)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjsh#h&h(jlh*}r(h,]h-]h.]h/]h2]uh4Mh5hh6]r€(jo)r}r‚(hX6``response_ = client_.post(request_, body, callback)``rƒhj}h#h&h(jsh*}r„(h,]h-]h.]h/]h2]uh4Mh6]r…hf)r†}r‡(hjƒh*}rˆ(h,]h-]h.]h/]h2]uhjh6]r‰h?X2response_ = client_.post(request_, body, callback)rŠ…r‹}rŒ(hUhj†ubah(hqubaubj})r}rŽ(hUh*}r(h,]h-]h.]h/]h2]uhj}h6]rhR)r‘}r’(hX}Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjh#h&h(hUh*}r“(h,]h-]h.]h/]h2]uh4Mh6]r”(h?XBody is a string of type r•…r–}r—(hXBody is a string of type hj‘ubhf)r˜}r™(hX%``boost::network::string::type``h*}rš(h,]h-]h.]h/]h2]uhj‘h6]r›h?X!boost::network::string::typerœ…r}rž(hUhj˜ubah(hqubh?X where rŸ…r }r¡(hX where hj‘ubhf)r¢}r£(hX``Tag``h*}r¤(h,]h-]h.]h/]h2]uhj‘h6]r¥h?XTagr¦…r§}r¨(hUhj¢ubah(hqubh?X is the HTTP Client's r©…rª}r«(hX is the HTTP Client's hj‘ubhf)r¬}r­(hX``Tag``h*}r®(h,]h-]h.]h/]h2]uhj‘h6]r¯h?XTagr°…r±}r²(hUhj¬ubah(hqubh?X#. The default content-type used is r³…r´}rµ(hX#. The default content-type used is hj‘ubhf)r¶}r·(hX``x-application/octet-stream``h*}r¸(h,]h-]h.]h/]h2]uhj‘h6]r¹h?Xx-application/octet-streamrº…r»}r¼(hUhj¶ubah(hqubh?X2. Have the response body chunks be handled by the r½…r¾}r¿(hX2. Have the response body chunks be handled by the hj‘ubhf)rÀ}rÁ(hX ``callback``h*}rÂ(h,]h-]h.]h/]h2]uhj‘h6]rÃh?XcallbackrÄ…rÅ}rÆ(hUhjÀubah(hqubh?X parameter. The signature of rÇ…rÈ}rÉ(hX parameter. The signature of hj‘ubhf)rÊ}rË(hX ``callback``h*}rÌ(h,]h-]h.]h/]h2]uhj‘h6]rÍh?XcallbackrÎ…rÏ}rÐ(hUhjÊubah(hqubh?X should be the following: rÑ…rÒ}rÓ(hX should be the following: hj‘ubhf)rÔ}rÕ(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}rÖ(h,]h-]h.]h/]h2]uhj‘h6]r×h?XMvoid(iterator_range const &, boost::system::error_code const &)rØ…rÙ}rÚ(hUhjÔubah(hqubh?X.…rÛ}rÜ(hX.hj‘ubeubah(jŠubeubji)rÝ}rÞ(hXë``response_ = client_.post(request_, body, content_type)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers.hjsh#h&h(jlh*}rß(h,]h-]h.]h/]h2]uh4M h5hh6]rà(jo)rá}râ(hX:``response_ = client_.post(request_, body, content_type)``rãhjÝh#h&h(jsh*}rä(h,]h-]h.]h/]h2]uh4M h6]råhf)ræ}rç(hjãh*}rè(h,]h-]h.]h/]h2]uhjáh6]réh?X6response_ = client_.post(request_, body, content_type)rê…rë}rì(hUhjæubah(hqubaubj})rí}rî(hUh*}rï(h,]h-]h.]h/]h2]uhjÝh6]rðhR)rñ}rò(hX°The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers.hjíh#h&h(hUh*}ró(h,]h-]h.]h/]h2]uh4M h6]rô(h?X1The body and content_type parameters are of type rõ…rö}r÷(hX1The body and content_type parameters are of type hjñubhf)rø}rù(hX%``boost::network::string::type``h*}rú(h,]h-]h.]h/]h2]uhjñh6]rûh?X!boost::network::string::typerü…rý}rþ(hUhjøubah(hqubh?X where rÿ…r}r(hX where hjñubhf)r}r(hX``Tag``h*}r(h,]h-]h.]h/]h2]uhjñh6]rh?XTagr…r}r(hUhjubah(hqubh?X is the HTTP Client's r …r }r (hX is the HTTP Client's hjñubhf)r }r (hX``Tag``h*}r(h,]h-]h.]h/]h2]uhjñh6]rh?XTagr…r}r(hUhj ubah(hqubh?X/. This uses the request object's other headers.r…r}r(hX/. This uses the request object's other headers.hjñubeubah(jŠubeubji)r}r(hXÇ``response_ = client_.post(request_, body, content_type, callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjsh#h&h(jlh*}r(h,]h-]h.]h/]h2]uh4Mh5hh6]r(jo)r}r(hXD``response_ = client_.post(request_, body, content_type, callback)``rhjh#h&h(jsh*}r(h,]h-]h.]h/]h2]uh4Mh6]rhf)r}r (hjh*}r!(h,]h-]h.]h/]h2]uhjh6]r"h?X@response_ = client_.post(request_, body, content_type, callback)r#…r$}r%(hUhjubah(hqubaubj})r&}r'(hUh*}r((h,]h-]h.]h/]h2]uhjh6]r)hR)r*}r+(hX‚The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hj&h#h&h(hUh*}r,(h,]h-]h.]h/]h2]uh4Mh6]r-(h?X1The body and content_type parameters are of type r.…r/}r0(hX1The body and content_type parameters are of type hj*ubhf)r1}r2(hX%``boost::network::string::type``h*}r3(h,]h-]h.]h/]h2]uhj*h6]r4h?X!boost::network::string::typer5…r6}r7(hUhj1ubah(hqubh?X where r8…r9}r:(hX where hj*ubhf)r;}r<(hX``Tag``h*}r=(h,]h-]h.]h/]h2]uhj*h6]r>h?XTagr?…r@}rA(hUhj;ubah(hqubh?X is the HTTP Client's rB…rC}rD(hX is the HTTP Client's hj*ubhf)rE}rF(hX``Tag``h*}rG(h,]h-]h.]h/]h2]uhj*h6]rHh?XTagrI…rJ}rK(hUhjEubah(hqubh?X`. This uses the request object's other headers. Have the response body chunks be handled by the rL…rM}rN(hX`. This uses the request object's other headers. Have the response body chunks be handled by the hj*ubhf)rO}rP(hX ``callback``h*}rQ(h,]h-]h.]h/]h2]uhj*h6]rRh?XcallbackrS…rT}rU(hUhjOubah(hqubh?X parameter. The signature of rV…rW}rX(hX parameter. The signature of hj*ubhf)rY}rZ(hX ``callback``h*}r[(h,]h-]h.]h/]h2]uhj*h6]r\h?Xcallbackr]…r^}r_(hUhjYubah(hqubh?X should be the following: r`…ra}rb(hX should be the following: hj*ubhf)rc}rd(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}re(h,]h-]h.]h/]h2]uhj*h6]rfh?XMvoid(iterator_range const &, boost::system::error_code const &)rg…rh}ri(hUhjcubah(hqubh?X.…rj}rk(hX.hj*ubeubah(jŠubeubji)rl}rm(hXŸ``response_ = client_.post(request_, streaming_callback)`` Perform and HTTP POST request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hjsh#h&h(jlh*}rn(h,]h-]h.]h/]h2]uh4Mh5hh6]ro(jo)rp}rq(hX:``response_ = client_.post(request_, streaming_callback)``rrhjlh#h&h(jsh*}rs(h,]h-]h.]h/]h2]uh4Mh6]rthf)ru}rv(hjrh*}rw(h,]h-]h.]h/]h2]uhjph6]rxh?X6response_ = client_.post(request_, streaming_callback)ry…rz}r{(hUhjuubah(hqubaubj})r|}r}(hUh*}r~(h,]h-]h.]h/]h2]uhjlh6]rhR)r€}r(hXdPerform and HTTP POST request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hj|h#h&h(hUh*}r‚(h,]h-]h.]h/]h2]uh4Mh6]rƒ(h?XVPerform and HTTP POST request, and have the request's body chunks be generated by the r„…r…}r†(hXVPerform and HTTP POST request, and have the request's body chunks be generated by the hj€ubhf)r‡}rˆ(hX``streaming_callback``h*}r‰(h,]h-]h.]h/]h2]uhj€h6]rŠh?Xstreaming_callbackr‹…rŒ}r(hUhj‡ubah(hqubh?X$ which has a signature of the form: rŽ…r}r(hX$ which has a signature of the form: hj€ubhf)r‘}r’(hX``bool(string_type&)``h*}r“(h,]h-]h.]h/]h2]uhj€h6]r”h?Xbool(string_type&)r•…r–}r—(hUhj‘ubah(hqubh?X. The provided r˜…r™}rš(hX. The provided hj€ubhf)r›}rœ(hX``string_type&``h*}r(h,]h-]h.]h/]h2]uhj€h6]ržh?X string_type&rŸ…r }r¡(hUhj›ubah(hqubh?XE will be streamed as soon as the function returns. A return value of r¢…r£}r¤(hXE will be streamed as soon as the function returns. A return value of hj€ubhf)r¥}r¦(hX ``false``h*}r§(h,]h-]h.]h/]h2]uhj€h6]r¨h?Xfalser©…rª}r«(hUhj¥ubah(hqubh?XQ signals the client that the most recent invocation is the last chunk to be sent.r¬…r­}r®(hXQ signals the client that the most recent invocation is the last chunk to be sent.hj€ubeubah(jŠubeubji)r¯}r°(hX``response_ = client_.post(request_, callback, streaming_callback)`` Perform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hjsh#h&h(jlh*}r±(h,]h-]h.]h/]h2]uh4M#h5hh6]r²(jo)r³}r´(hXD``response_ = client_.post(request_, callback, streaming_callback)``rµhj¯h#h&h(jsh*}r¶(h,]h-]h.]h/]h2]uh4M#h6]r·hf)r¸}r¹(hjµh*}rº(h,]h-]h.]h/]h2]uhj³h6]r»h?X@response_ = client_.post(request_, callback, streaming_callback)r¼…r½}r¾(hUhj¸ubah(hqubaubj})r¿}rÀ(hUh*}rÁ(h,]h-]h.]h/]h2]uhj¯h6]rÂhR)rÃ}rÄ(hX:Perform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hj¿h#h&h(hUh*}rÅ(h,]h-]h.]h/]h2]uh4Mh6]rÆ(h?XIPerform an HTTP POST request, and have the body chunks be handled by the rÇ…rÈ}rÉ(hXIPerform an HTTP POST request, and have the body chunks be handled by the hjÃubhf)rÊ}rË(hX ``callback``h*}rÌ(h,]h-]h.]h/]h2]uhjÃh6]rÍh?XcallbackrÎ…rÏ}rÐ(hUhjÊubah(hqubh?X parameter. The signature of rÑ…rÒ}rÓ(hX parameter. The signature of hjÃubhf)rÔ}rÕ(hX ``callback``h*}rÖ(h,]h-]h.]h/]h2]uhjÃh6]r×h?XcallbackrØ…rÙ}rÚ(hUhjÔubah(hqubh?X should be the following: rÛ…rÜ}rÝ(hX should be the following: hjÃubhf)rÞ}rß(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}rà(h,]h-]h.]h/]h2]uhjÃh6]ráh?XMvoid(iterator_range const &, boost::system::error_code const &)râ…rã}rä(hUhjÞubah(hqubh?XC. This form also has the request's body chunks be generated by the rå…ræ}rç(hXC. This form also has the request's body chunks be generated by the hjÃubhf)rè}ré(hX``streaming_callback``h*}rê(h,]h-]h.]h/]h2]uhjÃh6]rëh?Xstreaming_callbackrì…rí}rî(hUhjèubah(hqubh?X$ which has a signature of the form: rï…rð}rñ(hX$ which has a signature of the form: hjÃubhf)rò}ró(hX``bool(string_type&)``h*}rô(h,]h-]h.]h/]h2]uhjÃh6]rõh?Xbool(string_type&)rö…r÷}rø(hUhjòubah(hqubh?X. The provided rù…rú}rû(hX. The provided hjÃubhf)rü}rý(hX``string_type&``h*}rþ(h,]h-]h.]h/]h2]uhjÃh6]rÿh?X string_type&r…r}r(hUhjüubah(hqubh?XE will be streamed as soon as the function returns. A return value of r…r}r(hXE will be streamed as soon as the function returns. A return value of hjÃubhf)r}r(hX ``false``h*}r(h,]h-]h.]h/]h2]uhjÃh6]r h?Xfalser …r }r (hUhjubah(hqubh?XQ signals the client that the most recent invocation is the last chunk to be sent.r …r}r(hXQ signals the client that the most recent invocation is the last chunk to be sent.hjÃubeubah(jŠubeubji)r}r(hX“``response_ = client_.put(request_)`` Perform an HTTP PUT, use the data already set in the request object which includes the headers, and the body.hjsh#h&h(jlh*}r(h,]h-]h.]h/]h2]uh4M&h5hh6]r(jo)r}r(hX%``response_ = client_.put(request_)``rhjh#h&h(jsh*}r(h,]h-]h.]h/]h2]uh4M&h6]rhf)r}r(hjh*}r(h,]h-]h.]h/]h2]uhjh6]rh?X!response_ = client_.put(request_)r…r}r(hUhjubah(hqubaubj})r }r!(hUh*}r"(h,]h-]h.]h/]h2]uhjh6]r#hR)r$}r%(hXmPerform an HTTP PUT, use the data already set in the request object which includes the headers, and the body.r&hj h#h&h(hUh*}r'(h,]h-]h.]h/]h2]uh4M&h6]r(h?XmPerform an HTTP PUT, use the data already set in the request object which includes the headers, and the body.r)…r*}r+(hj&hj$ubaubah(jŠubeubji)r,}r-(hX``response_ = client_.put(request_, callback)`` Perform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjsh#h&h(jlh*}r.(h,]h-]h.]h/]h2]uh4M+h5hh6]r/(jo)r0}r1(hX/``response_ = client_.put(request_, callback)``r2hj,h#h&h(jsh*}r3(h,]h-]h.]h/]h2]uh4M+h6]r4hf)r5}r6(hj2h*}r7(h,]h-]h.]h/]h2]uhj0h6]r8h?X+response_ = client_.put(request_, callback)r9…r:}r;(hUhj5ubah(hqubaubj})r<}r=(hUh*}r>(h,]h-]h.]h/]h2]uhj,h6]r?hR)r@}rA(hXéPerform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hj<h#h&h(hUh*}rB(h,]h-]h.]h/]h2]uh4M)h6]rC(h?XHPerform an HTTP PUT request, and have the body chunks be handled by the rD…rE}rF(hXHPerform an HTTP PUT request, and have the body chunks be handled by the hj@ubhf)rG}rH(hX ``callback``h*}rI(h,]h-]h.]h/]h2]uhj@h6]rJh?XcallbackrK…rL}rM(hUhjGubah(hqubh?X parameter. The signature of rN…rO}rP(hX parameter. The signature of hj@ubhf)rQ}rR(hX ``callback``h*}rS(h,]h-]h.]h/]h2]uhj@h6]rTh?XcallbackrU…rV}rW(hUhjQubah(hqubh?X should be the following: rX…rY}rZ(hX should be the following: hj@ubhf)r[}r\(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}r](h,]h-]h.]h/]h2]uhj@h6]r^h?XMvoid(iterator_range const &, boost::system::error_code const &)r_…r`}ra(hUhj[ubah(hqubh?X.…rb}rc(hX.hj@ubeubah(jŠubeubji)rd}re(hX×``response_ = client_.put(request_, body)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``.hjsh#h&h(jlh*}rf(h,]h-]h.]h/]h2]uh4M/h5hh6]rg(jo)rh}ri(hX+``response_ = client_.put(request_, body)``rjhjdh#h&h(jsh*}rk(h,]h-]h.]h/]h2]uh4M/h6]rlhf)rm}rn(hjjh*}ro(h,]h-]h.]h/]h2]uhjhh6]rph?X'response_ = client_.put(request_, body)rq…rr}rs(hUhjmubah(hqubaubj})rt}ru(hUh*}rv(h,]h-]h.]h/]h2]uhjdh6]rwhR)rx}ry(hX«Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``.hjth#h&h(hUh*}rz(h,]h-]h.]h/]h2]uh4M.h6]r{(h?XBody is a string of type r|…r}}r~(hXBody is a string of type hjxubhf)r}r€(hX%``boost::network::string::type``h*}r(h,]h-]h.]h/]h2]uhjxh6]r‚h?X!boost::network::string::typerƒ…r„}r…(hUhjubah(hqubh?X where r†…r‡}rˆ(hX where hjxubhf)r‰}rŠ(hX``Tag``h*}r‹(h,]h-]h.]h/]h2]uhjxh6]rŒh?XTagr…rŽ}r(hUhj‰ubah(hqubh?X is the HTTP Client's r…r‘}r’(hX is the HTTP Client's hjxubhf)r“}r”(hX``Tag``h*}r•(h,]h-]h.]h/]h2]uhjxh6]r–h?XTagr—…r˜}r™(hUhj“ubah(hqubh?X#. The default content-type used is rš…r›}rœ(hX#. The default content-type used is hjxubhf)r}rž(hX``x-application/octet-stream``h*}rŸ(h,]h-]h.]h/]h2]uhjxh6]r h?Xx-application/octet-streamr¡…r¢}r£(hUhjubah(hqubh?X.…r¤}r¥(hX.hjxubeubah(jŠubeubji)r¦}r§(hX³``response_ = client_.put(request_, body, callback)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjsh#h&h(jlh*}r¨(h,]h-]h.]h/]h2]uh4M6h5hh6]r©(jo)rª}r«(hX5``response_ = client_.put(request_, body, callback)``r¬hj¦h#h&h(jsh*}r­(h,]h-]h.]h/]h2]uh4M6h6]r®hf)r¯}r°(hj¬h*}r±(h,]h-]h.]h/]h2]uhjªh6]r²h?X1response_ = client_.put(request_, body, callback)r³…r´}rµ(hUhj¯ubah(hqubaubj})r¶}r·(hUh*}r¸(h,]h-]h.]h/]h2]uhj¦h6]r¹hR)rº}r»(hX}Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hj¶h#h&h(hUh*}r¼(h,]h-]h.]h/]h2]uh4M2h6]r½(h?XBody is a string of type r¾…r¿}rÀ(hXBody is a string of type hjºubhf)rÁ}rÂ(hX%``boost::network::string::type``h*}rÃ(h,]h-]h.]h/]h2]uhjºh6]rÄh?X!boost::network::string::typerÅ…rÆ}rÇ(hUhjÁubah(hqubh?X where rÈ…rÉ}rÊ(hX where hjºubhf)rË}rÌ(hX``Tag``h*}rÍ(h,]h-]h.]h/]h2]uhjºh6]rÎh?XTagrÏ…rÐ}rÑ(hUhjËubah(hqubh?X is the HTTP Client's rÒ…rÓ}rÔ(hX is the HTTP Client's hjºubhf)rÕ}rÖ(hX``Tag``h*}r×(h,]h-]h.]h/]h2]uhjºh6]rØh?XTagrÙ…rÚ}rÛ(hUhjÕubah(hqubh?X#. The default content-type used is rÜ…rÝ}rÞ(hX#. The default content-type used is hjºubhf)rß}rà(hX``x-application/octet-stream``h*}rá(h,]h-]h.]h/]h2]uhjºh6]râh?Xx-application/octet-streamrã…rä}rå(hUhjßubah(hqubh?X2. Have the response body chunks be handled by the ræ…rç}rè(hX2. Have the response body chunks be handled by the hjºubhf)ré}rê(hX ``callback``h*}rë(h,]h-]h.]h/]h2]uhjºh6]rìh?Xcallbackrí…rî}rï(hUhjéubah(hqubh?X parameter. The signature of rð…rñ}rò(hX parameter. The signature of hjºubhf)ró}rô(hX ``callback``h*}rõ(h,]h-]h.]h/]h2]uhjºh6]röh?Xcallbackr÷…rø}rù(hUhjóubah(hqubh?X should be the following: rú…rû}rü(hX should be the following: hjºubhf)rý}rþ(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}rÿ(h,]h-]h.]h/]h2]uhjºh6]rh?XMvoid(iterator_range const &, boost::system::error_code const &)r…r}r(hUhjýubah(hqubh?X.…r}r(hX.hjºubeubah(jŠubeubji)r}r(hXê``response_ = client_.put(request_, body, content_type)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers.hjsh#h&h(jlh*}r(h,]h-]h.]h/]h2]uh4M:h5hh6]r (jo)r }r (hX9``response_ = client_.put(request_, body, content_type)``r hjh#h&h(jsh*}r (h,]h-]h.]h/]h2]uh4M:h6]rhf)r}r(hj h*}r(h,]h-]h.]h/]h2]uhj h6]rh?X5response_ = client_.put(request_, body, content_type)r…r}r(hUhjubah(hqubaubj})r}r(hUh*}r(h,]h-]h.]h/]h2]uhjh6]rhR)r}r(hX°The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers.hjh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4M9h6]r(h?X1The body and content_type parameters are of type r…r}r (hX1The body and content_type parameters are of type hjubhf)r!}r"(hX%``boost::network::string::type``h*}r#(h,]h-]h.]h/]h2]uhjh6]r$h?X!boost::network::string::typer%…r&}r'(hUhj!ubah(hqubh?X where r(…r)}r*(hX where hjubhf)r+}r,(hX``Tag``h*}r-(h,]h-]h.]h/]h2]uhjh6]r.h?XTagr/…r0}r1(hUhj+ubah(hqubh?X is the HTTP Client's r2…r3}r4(hX is the HTTP Client's hjubhf)r5}r6(hX``Tag``h*}r7(h,]h-]h.]h/]h2]uhjh6]r8h?XTagr9…r:}r;(hUhj5ubah(hqubh?X/. This uses the request object's other headers.r<…r=}r>(hX/. This uses the request object's other headers.hjubeubah(jŠubeubji)r?}r@(hXÓ``response_ = client_.put(request_, body, content_type, body_handler=callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjsh#h&h(jlh*}rA(h,]h-]h.]h/]h2]uh4MAh5hh6]rB(jo)rC}rD(hXP``response_ = client_.put(request_, body, content_type, body_handler=callback)``rEhj?h#h&h(jsh*}rF(h,]h-]h.]h/]h2]uh4MAh6]rGhf)rH}rI(hjEh*}rJ(h,]h-]h.]h/]h2]uhjCh6]rKh?XLresponse_ = client_.put(request_, body, content_type, body_handler=callback)rL…rM}rN(hUhjHubah(hqubaubj})rO}rP(hUh*}rQ(h,]h-]h.]h/]h2]uhj?h6]rRhR)rS}rT(hX‚The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjOh#h&h(hUh*}rU(h,]h-]h.]h/]h2]uh4M=h6]rV(h?X1The body and content_type parameters are of type rW…rX}rY(hX1The body and content_type parameters are of type hjSubhf)rZ}r[(hX%``boost::network::string::type``h*}r\(h,]h-]h.]h/]h2]uhjSh6]r]h?X!boost::network::string::typer^…r_}r`(hUhjZubah(hqubh?X where ra…rb}rc(hX where hjSubhf)rd}re(hX``Tag``h*}rf(h,]h-]h.]h/]h2]uhjSh6]rgh?XTagrh…ri}rj(hUhjdubah(hqubh?X is the HTTP Client's rk…rl}rm(hX is the HTTP Client's hjSubhf)rn}ro(hX``Tag``h*}rp(h,]h-]h.]h/]h2]uhjSh6]rqh?XTagrr…rs}rt(hUhjnubah(hqubh?X`. This uses the request object's other headers. Have the response body chunks be handled by the ru…rv}rw(hX`. This uses the request object's other headers. Have the response body chunks be handled by the hjSubhf)rx}ry(hX ``callback``h*}rz(h,]h-]h.]h/]h2]uhjSh6]r{h?Xcallbackr|…r}}r~(hUhjxubah(hqubh?X parameter. The signature of r…r€}r(hX parameter. The signature of hjSubhf)r‚}rƒ(hX ``callback``h*}r„(h,]h-]h.]h/]h2]uhjSh6]r…h?Xcallbackr†…r‡}rˆ(hUhj‚ubah(hqubh?X should be the following: r‰…rŠ}r‹(hX should be the following: hjSubhf)rŒ}r(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}rŽ(h,]h-]h.]h/]h2]uhjSh6]rh?XMvoid(iterator_range const &, boost::system::error_code const &)r…r‘}r’(hUhjŒubah(hqubh?X.…r“}r”(hX.hjSubeubah(jŠubeubji)r•}r–(hX``response_ = client_.put(request_, streaming_callback)`` Perform and HTTP PUT request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hjsh#h&h(jlh*}r—(h,]h-]h.]h/]h2]uh4MGh5hh6]r˜(jo)r™}rš(hX9``response_ = client_.put(request_, streaming_callback)``r›hj•h#h&h(jsh*}rœ(h,]h-]h.]h/]h2]uh4MGh6]rhf)rž}rŸ(hj›h*}r (h,]h-]h.]h/]h2]uhj™h6]r¡h?X5response_ = client_.put(request_, streaming_callback)r¢…r£}r¤(hUhjžubah(hqubaubj})r¥}r¦(hUh*}r§(h,]h-]h.]h/]h2]uhj•h6]r¨hR)r©}rª(hXcPerform and HTTP PUT request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hj¥h#h&h(hUh*}r«(h,]h-]h.]h/]h2]uh4MDh6]r¬(h?XUPerform and HTTP PUT request, and have the request's body chunks be generated by the r­…r®}r¯(hXUPerform and HTTP PUT request, and have the request's body chunks be generated by the hj©ubhf)r°}r±(hX``streaming_callback``h*}r²(h,]h-]h.]h/]h2]uhj©h6]r³h?Xstreaming_callbackr´…rµ}r¶(hUhj°ubah(hqubh?X$ which has a signature of the form: r·…r¸}r¹(hX$ which has a signature of the form: hj©ubhf)rº}r»(hX``bool(string_type&)``h*}r¼(h,]h-]h.]h/]h2]uhj©h6]r½h?Xbool(string_type&)r¾…r¿}rÀ(hUhjºubah(hqubh?X. The provided rÁ…rÂ}rÃ(hX. The provided hj©ubhf)rÄ}rÅ(hX``string_type&``h*}rÆ(h,]h-]h.]h/]h2]uhj©h6]rÇh?X string_type&rÈ…rÉ}rÊ(hUhjÄubah(hqubh?XE will be streamed as soon as the function returns. A return value of rË…rÌ}rÍ(hXE will be streamed as soon as the function returns. A return value of hj©ubhf)rÎ}rÏ(hX ``false``h*}rÐ(h,]h-]h.]h/]h2]uhj©h6]rÑh?XfalserÒ…rÓ}rÔ(hUhjÎubah(hqubh?XQ signals the client that the most recent invocation is the last chunk to be sent.rÕ…rÖ}r×(hXQ signals the client that the most recent invocation is the last chunk to be sent.hj©ubeubah(jŠubeubji)rØ}rÙ(hX}``response_ = client_.put(request_, callback, streaming_callback)`` Perform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hjsh#h&h(jlh*}rÚ(h,]h-]h.]h/]h2]uh4MQh5hh6]rÛ(jo)rÜ}rÝ(hXC``response_ = client_.put(request_, callback, streaming_callback)``rÞhjØh#h&h(jsh*}rß(h,]h-]h.]h/]h2]uh4MQh6]ràhf)rá}râ(hjÞh*}rã(h,]h-]h.]h/]h2]uhjÜh6]räh?X?response_ = client_.put(request_, callback, streaming_callback)rå…ræ}rç(hUhjáubah(hqubaubj})rè}ré(hUh*}rê(h,]h-]h.]h/]h2]uhjØh6]rëhR)rì}rí(hX9Perform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent.hjèh#h&h(hUh*}rî(h,]h-]h.]h/]h2]uh4MJh6]rï(h?XHPerform an HTTP PUT request, and have the body chunks be handled by the rð…rñ}rò(hXHPerform an HTTP PUT request, and have the body chunks be handled by the hjìubhf)ró}rô(hX ``callback``h*}rõ(h,]h-]h.]h/]h2]uhjìh6]röh?Xcallbackr÷…rø}rù(hUhjóubah(hqubh?X parameter. The signature of rú…rû}rü(hX parameter. The signature of hjìubhf)rý}rþ(hX ``callback``h*}rÿ(h,]h-]h.]h/]h2]uhjìh6]rh?Xcallbackr…r}r(hUhjýubah(hqubh?X should be the following: r…r}r(hX should be the following: hjìubhf)r}r(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}r (h,]h-]h.]h/]h2]uhjìh6]r h?XMvoid(iterator_range const &, boost::system::error_code const &)r …r }r (hUhjubah(hqubh?XC. This form also has the request's body chunks be generated by the r…r}r(hXC. This form also has the request's body chunks be generated by the hjìubhf)r}r(hX``streaming_callback``h*}r(h,]h-]h.]h/]h2]uhjìh6]rh?Xstreaming_callbackr…r}r(hUhjubah(hqubh?X$ which has a signature of the form: r…r}r(hX$ which has a signature of the form: hjìubhf)r}r(hX``bool(string_type&)``h*}r(h,]h-]h.]h/]h2]uhjìh6]rh?Xbool(string_type&)r…r }r!(hUhjubah(hqubh?X. The provided r"…r#}r$(hX. The provided hjìubhf)r%}r&(hX``string_type&``h*}r'(h,]h-]h.]h/]h2]uhjìh6]r(h?X string_type&r)…r*}r+(hUhj%ubah(hqubh?XE will be streamed as soon as the function returns. A return value of r,…r-}r.(hXE will be streamed as soon as the function returns. A return value of hjìubhf)r/}r0(hX ``false``h*}r1(h,]h-]h.]h/]h2]uhjìh6]r2h?Xfalser3…r4}r5(hUhj/ubah(hqubh?XQ signals the client that the most recent invocation is the last chunk to be sent.r6…r7}r8(hXQ signals the client that the most recent invocation is the last chunk to be sent.hjìubeubah(jŠubeubji)r9}r:(hXI``response_ = client_.delete_(request_)`` Perform an HTTP DELETE request.hjsh#h&h(jlh*}r;(h,]h-]h.]h/]h2]uh4MSh5hh6]r<(jo)r=}r>(hX)``response_ = client_.delete_(request_)``r?hj9h#h&h(jsh*}r@(h,]h-]h.]h/]h2]uh4MSh6]rAhf)rB}rC(hj?h*}rD(h,]h-]h.]h/]h2]uhj=h6]rEh?X%response_ = client_.delete_(request_)rF…rG}rH(hUhjBubah(hqubaubj})rI}rJ(hUh*}rK(h,]h-]h.]h/]h2]uhj9h6]rLhR)rM}rN(hXPerform an HTTP DELETE request.rOhjIh#h&h(hUh*}rP(h,]h-]h.]h/]h2]uh4MTh6]rQh?XPerform an HTTP DELETE request.rR…rS}rT(hjOhjMubaubah(jŠubeubji)rU}rV(hX7``response_ = client_.delete_(request_, body_handler=callback)`` Perform an HTTP DELETE request, and have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. hjsh#h&h(jlh*}rW(h,]h-]h.]h/]h2]uh4MYh5hh6]rX(jo)rY}rZ(hX@``response_ = client_.delete_(request_, body_handler=callback)``r[hjUh#h&h(jsh*}r\(h,]h-]h.]h/]h2]uh4MYh6]r]hf)r^}r_(hj[h*}r`(h,]h-]h.]h/]h2]uhjYh6]rah?X<response_ = client_.delete_(request_, body_handler=callback)rb…rc}rd(hUhj^ubah(hqubaubj})re}rf(hUh*}rg(h,]h-]h.]h/]h2]uhjUh6]rhhR)ri}rj(hXõPerform an HTTP DELETE request, and have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``.hjeh#h&h(hUh*}rk(h,]h-]h.]h/]h2]uh4MVh6]rl(h?XTPerform an HTTP DELETE request, and have the response body chunks be handled by the rm…rn}ro(hXTPerform an HTTP DELETE request, and have the response body chunks be handled by the hjiubhf)rp}rq(hX ``callback``h*}rr(h,]h-]h.]h/]h2]uhjih6]rsh?Xcallbackrt…ru}rv(hUhjpubah(hqubh?X parameter. The signature of rw…rx}ry(hX parameter. The signature of hjiubhf)rz}r{(hX ``callback``h*}r|(h,]h-]h.]h/]h2]uhjih6]r}h?Xcallbackr~…r}r€(hUhjzubah(hqubh?X should be the following: r…r‚}rƒ(hX should be the following: hjiubhf)r„}r…(hXQ``void(iterator_range const &, boost::system::error_code const &)``h*}r†(h,]h-]h.]h/]h2]uhjih6]r‡h?XMvoid(iterator_range const &, boost::system::error_code const &)rˆ…r‰}rŠ(hUhj„ubah(hqubh?X.…r‹}rŒ(hX.hjiubeubah(jŠubeubeubeubh)r}rŽ(hUhhíh#h&h(h)h*}r(h,]h-]h.]h/]rUclient-specificr‘ah2]r’hauh4M\h5hh6]r“(h8)r”}r•(hXClient-Specificr–hjh#h&h(h }r? (hXN**Tag** - which static tag you choose that defines the behavior of the client.hj: h#h&h(hUh*}r@ (h,]h-]h.]h/]h2]uh4K"h6]rA (hŠ)rB }rC (hX**Tag**h*}rD (h,]h-]h.]h/]h2]uhj> h6]rE h?XTagrF …rG }rH (hUhjB ubah(h’ubh?XG - which static tag you choose that defines the behavior of the client.rI …rJ }rK (hXG - which static tag you choose that defines the behavior of the client.hj> ubeubah(h–ubh)rL }rM (hX‘**http_version_major** - an unsigned int that defines the HTTP major version number, this directly affects the HTTP messages sent by the client. h*}rN (h,]h-]h.]h/]h2]uhj6 h6]rO hR)rP }rQ (hX**http_version_major** - an unsigned int that defines the HTTP major version number, this directly affects the HTTP messages sent by the client.hjL h#h&h(hUh*}rR (h,]h-]h.]h/]h2]uh4K$h6]rS (hŠ)rT }rU (hX**http_version_major**h*}rV (h,]h-]h.]h/]h2]uhjP h6]rW h?Xhttp_version_majorrX …rY }rZ (hUhjT ubah(h’ubh?Xz - an unsigned int that defines the HTTP major version number, this directly affects the HTTP messages sent by the client.r[ …r\ }r] (hXz - an unsigned int that defines the HTTP major version number, this directly affects the HTTP messages sent by the client.hjP ubeubah(h–ubh)r^ }r_ (hXU**http_version_minor** - an unsigned int that defines the HTTP minor version number. h*}r` (h,]h-]h.]h/]h2]uhj6 h6]ra hR)rb }rc (hXT**http_version_minor** - an unsigned int that defines the HTTP minor version number.hj^ h#h&h(hUh*}rd (h,]h-]h.]h/]h2]uh4K'h6]re (hŠ)rf }rg (hX**http_version_minor**h*}rh (h,]h-]h.]h/]h2]uhjb h6]ri h?Xhttp_version_minorrj …rk }rl (hUhjf ubah(h’ubh?X> - an unsigned int that defines the HTTP minor version number.rm …rn }ro (hX> - an unsigned int that defines the HTTP minor version number.hjb ubeubah(h–ubeh(h©ubaubhR)rp }rq (hXsThere are two major different class of implementations of the ``basic_client`` template that depend on which tag you choose: `Synchronous Clients`_ and `Asynchronous Clients`_. These two different classes are described in their own sections following this one. What follows is a table of all tags supported by the HTTP client implementation provided by :mod:`cpp-netlib`.hhh#h&h(hUh*}rr (h,]h-]h.]h/]h2]uh4K*h5hh6]rs (h?X>There are two major different class of implementations of the rt …ru }rv (hX>There are two major different class of implementations of the hjp ubhf)rw }rx (hX``basic_client``h*}ry (h,]h-]h.]h/]h2]uhjp h6]rz h?X basic_clientr{ …r| }r} (hUhjw ubah(hqubh?X/ template that depend on which tag you choose: r~ …r }r€ (hX/ template that depend on which tag you choose: hjp ubhÒ)r }r‚ (hX`Synchronous Clients`_hÕKhjp h(hÖh*}rƒ (UnameXSynchronous Clientsh/]h.]h,]h-]h2]hØhÙuh6]r„ h?XSynchronous Clientsr… …r† }r‡ (hUhj ubaubh?X and rˆ …r‰ }rŠ (hX and hjp ubhÒ)r‹ }rŒ (hX`Asynchronous Clients`_hÕKhjp h(hÖh*}r (UnameXAsynchronous Clientsh/]h.]h,]h-]h2]hØUasynchronous-clientsrŽ uh6]r h?XAsynchronous Clientsr …r‘ }r’ (hUhj‹ ubaubh?X². These two different classes are described in their own sections following this one. What follows is a table of all tags supported by the HTTP client implementation provided by r“ …r” }r• (hX². These two different classes are described in their own sections following this one. What follows is a table of all tags supported by the HTTP client implementation provided by hjp ubhX)r– }r— (hX:mod:`cpp-netlib`r˜ hjp h#h&h(h\h*}r™ (UreftypeXmodh^‰h_X cpp-netlibU refdomainXpyrš h/]h.]U refexplicit‰h,]h-]h2]hahbhcNhdNuh4K*h6]r› hf)rœ }r (hj˜ h*}rž (h,]h-]rŸ (hkjš Xpy-modr  eh.]h/]h2]uhj– h6]r¡ h?X cpp-netlibr¢ …r£ }r¤ (hUhjœ ubah(hqubaubh?X.…r¥ }r¦ (hX.hjp ubeubcdocutils.nodes transition r§ )r¨ }r© (hX---------------rª hhh#h&h(U transitionr« h*}r¬ (h,]h-]h.]h/]h2]uh4K0h5hh6]ubjº)r­ }r® (hUhhh#h$Xin_depth/http_client_tags.rstr¯ …r° }r± bh(j½h*}r² (h,]h-]h.]h/]h2]uh4Nh5hh6]r³ jÀ)r´ }rµ (hUh*}r¶ (h/]h.]h,]h-]h2]UcolsKuhj­ h6]r· (jÅ)r¸ }r¹ (hUh*}rº (h/]h.]h,]h-]h2]UcolwidthK!uhj´ h6]h(jÉubjÅ)r» }r¼ (hUh*}r½ (h/]h.]h,]h-]h2]UcolwidthK-uhj´ h6]h(jÉubjÐ)r¾ }r¿ (hUh*}rÀ (h,]h-]h.]h/]h2]uhj´ h6]rÁ jÕ)r }rà (hUh*}rÄ (h,]h-]h.]h/]h2]uhj¾ h6]rÅ (jÚ)rÆ }rÇ (hUh*}rÈ (h,]h-]h.]h/]h2]uhj h6]rÉ hR)rÊ }rË (hXTagrÌ hjÆ h#j° h(hUh*}rÍ (h,]h-]h.]h/]h2]uh4Kh6]rÎ h?XTagrÏ …rÐ }rÑ (hjÌ hjÊ ubaubah(jçubjÚ)rÒ }rÓ (hUh*}rÔ (h,]h-]h.]h/]h2]uhj h6]rÕ hR)rÖ }r× (hX DescriptionrØ hjÒ h#j° h(hUh*}rÙ (h,]h-]h.]h/]h2]uh4Kh6]rÚ h?X DescriptionrÛ …rÜ }rÝ (hjØ hjÖ ubaubah(jçubeh(jubah(jubj)rÞ }rß (hUh*}rà (h,]h-]h.]h/]h2]uhj´ h6]rá (jÕ)râ }rã (hUh*}rä (h,]h-]h.]h/]h2]uhjÞ h6]rå (jÚ)ræ }rç (hUh*}rè (h,]h-]h.]h/]h2]uhjâ h6]ré hR)rê }rë (hXhttp_default_8bit_tcp_resolverì hjæ h#j° h(hUh*}rí (h,]h-]h.]h/]h2]uh4Kh6]rî h?Xhttp_default_8bit_tcp_resolverï …rð }rñ (hjì hjê ubaubah(jçubjÚ)rò }ró (hUh*}rô (h,]h-]h.]h/]h2]uhjâ h6]rõ hR)rö }r÷ (hX’This is the default HTTP implementation tag that resolves addresses with a TCP resolver and provides a synchronous/blocking HTTP client interface.rø hjò h#j° h(hUh*}rù (h,]h-]h.]h/]h2]uh4Kh6]rú h?X’This is the default HTTP implementation tag that resolves addresses with a TCP resolver and provides a synchronous/blocking HTTP client interface.rû …rü }rý (hjø hjö ubaubah(jçubeh(jubjÕ)rþ }rÿ (hUh*}r (h,]h-]h.]h/]h2]uhjÞ h6]r (jÚ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjþ h6]r hR)r }r (hXhttp_default_8bit_udp_resolver hj h#j° h(hUh*}r (h,]h-]h.]h/]h2]uh4K h6]r h?Xhttp_default_8bit_udp_resolver …r }r (hj hj ubaubah(jçubjÚ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjþ h6]r hR)r }r (hX This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.r hj h#j° h(hUh*}r (h,]h-]h.]h/]h2]uh4K h6]r h?X This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.r …r }r (hj hj ubaubah(jçubeh(jubjÕ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjÞ h6]r (jÚ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhj h6]r! hR)r" }r# (hXhttp_keepalive_8bit_tcp_resolver$ hj h#j° h(hUh*}r% (h,]h-]h.]h/]h2]uh4Kh6]r& h?Xhttp_keepalive_8bit_tcp_resolver' …r( }r) (hj$ hj" ubaubah(jçubjÚ)r* }r+ (hUh*}r, (h,]h-]h.]h/]h2]uhj h6]r- hR)r. }r/ (hXBThis tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the ``version_major`` and ``version_minor`` are both ``1``, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.hj* h#j° h(hUh*}r0 (h,]h-]h.]h/]h2]uh4Kh6]r1 (h?XyThis tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the r2 …r3 }r4 (hXyThis tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the hj. ubhf)r5 }r6 (hX``version_major``h*}r7 (h,]h-]h.]h/]h2]uhj. h6]r8 h?X version_majorr9 …r: }r; (hUhj5 ubah(hqubh?X and r< …r= }r> (hX and hj. ubhf)r? }r@ (hX``version_minor``h*}rA (h,]h-]h.]h/]h2]uhj. h6]rB h?X version_minorrC …rD }rE (hUhj? ubah(hqubh?X are both rF …rG }rH (hX are both hj. ubhf)rI }rJ (hX``1``h*}rK (h,]h-]h.]h/]h2]uhj. h6]rL h?X1…rM }rN (hUhjI ubah(hqubh?X“, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.rO …rP }rQ (hX“, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.hj. ubeubah(jçubeh(jubjÕ)rR }rS (hUh*}rT (h,]h-]h.]h/]h2]uhjÞ h6]rU (jÚ)rV }rW (hUh*}rX (h,]h-]h.]h/]h2]uhjR h6]rY hR)rZ }r[ (hXhttp_keepalive_8bit_udp_resolver\ hjV h#j° h(hUh*}r] (h,]h-]h.]h/]h2]uh4Kh6]r^ h?Xhttp_keepalive_8bit_udp_resolver_ …r` }ra (hj\ hjZ ubaubah(jçubjÚ)rb }rc (hUh*}rd (h,]h-]h.]h/]h2]uhjR h6]re hR)rf }rg (hX This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.rh hjb h#j° h(hUh*}ri (h,]h-]h.]h/]h2]uh4Kh6]rj h?X This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.rk …rl }rm (hjh hjf ubaubah(jçubeh(jubjÕ)rn }ro (hUh*}rp (h,]h-]h.]h/]h2]uhjÞ h6]rq (jÚ)rr }rs (hUh*}rt (h,]h-]h.]h/]h2]uhjn h6]ru hR)rv }rw (hXhttp_async_8bit_tcp_resolverx hjr h#j° h(hUh*}ry (h,]h-]h.]h/]h2]uh4Kh6]rz h?Xhttp_async_8bit_tcp_resolver{ …r| }r} (hjx hjv ubaubah(jçubjÚ)r~ }r (hUh*}r€ (h,]h-]h.]h/]h2]uhjn h6]r hR)r‚ }rƒ (hXüThis tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of Boost.Thread_ shared futures to hold values. Users don't have to see this as they are implementation details.hj~ h#j° h(hUh*}r„ (h,]h-]h.]h/]h2]uh4Kh6]r… (h?XThis tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of r† …r‡ }rˆ (hXThis tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of hj‚ ubhÒ)r‰ }rŠ (hX Boost.Thread_hÕKhj‚ h(hÖh*}r‹ (UnameX Boost.ThreadUrefurirŒ X http://www.boost.org/libs/threadr h/]h.]h,]h-]h2]uh6]rŽ h?X Boost.Threadr …r }r‘ (hUhj‰ ubaubh?X` shared futures to hold values. Users don't have to see this as they are implementation details.r’ …r“ }r” (hX` shared futures to hold values. Users don't have to see this as they are implementation details.hj‚ ubeubah(jçubeh(jubjÕ)r• }r– (hUh*}r— (h,]h-]h.]h/]h2]uhjÞ h6]r˜ (jÚ)r™ }rš (hUh*}r› (h,]h-]h.]h/]h2]uhj• h6]rœ hR)r }rž (hXhttp_async_8bit_udp_resolverŸ hj™ h#j° h(hUh*}r  (h,]h-]h.]h/]h2]uh4K$h6]r¡ h?Xhttp_async_8bit_udp_resolver¢ …r£ }r¤ (hjŸ hj ubaubah(jçubjÚ)r¥ }r¦ (hUh*}r§ (h,]h-]h.]h/]h2]uhj• h6]r¨ hR)r© }rª (hX]This is similar to the above tag except that specifies the HTTP client to use a UDP resolver.r« hj¥ h#j° h(hUh*}r¬ (h,]h-]h.]h/]h2]uh4K$h6]r­ h?X]This is similar to the above tag except that specifies the HTTP client to use a UDP resolver.r® …r¯ }r° (hj« hj© ubaubah(jçubeh(jubeh(j'ubeh(j(ubaubcdocutils.nodes target r± )r² }r³ (hX2.. _Boost.Thread: http://www.boost.org/libs/threadhKhhh#j° h(Utargetr´ h*}rµ (jŒ j h/]r¶ U boost-threadr· ah.]h,]h-]h2]r¸ h auh4K]h5hh6]ubhR)r¹ }rº (hX}In the above table the tags follow a pattern for describing the behavior introduced by the tags. This pattern is shown below:r» hhh#h&h(hUh*}r¼ (h,]h-]h.]h/]h2]uh4K4h5hh6]r½ h?X}In the above table the tags follow a pattern for describing the behavior introduced by the tags. This pattern is shown below:r¾ …r¿ }rÀ (hj» hj¹ ubaubhu)rÁ }r (hUhhh#h&h(hxh*}rà (h,]h-]h.]h/]h2]uh4Nh5hh6]rÄ hR)rÅ }rÆ (hX:___rÇ hjÁ h#h&h(hUh*}rÈ (h,]h-]h.]h/]h2]uh4K7h6]rÉ h?X:___rÊ …rË }rÌ (hjÇ hjÅ ubaubaubhR)rÍ }rÎ (hX¹For example, the tag ``http_default_8bit_tcp_resolve`` indicates the protocol ``http``, a modifier ``default``, a character width of ``8bit``, and a resolve strategy of ``tcp_resolve``.hhh#h&h(hUh*}rÏ (h,]h-]h.]h/]h2]uh4K9h5hh6]rÐ (h?XFor example, the tag rÑ …rÒ }rÓ (hXFor example, the tag hjÍ ubhf)rÔ }rÕ (hX!``http_default_8bit_tcp_resolve``h*}rÖ (h,]h-]h.]h/]h2]uhjÍ h6]r× h?Xhttp_default_8bit_tcp_resolverØ …rÙ }rÚ (hUhjÔ ubah(hqubh?X indicates the protocol rÛ …rÜ }rÝ (hX indicates the protocol hjÍ ubhf)rÞ }rß (hX``http``h*}rà (h,]h-]h.]h/]h2]uhjÍ h6]rá h?Xhttprâ …rã }rä (hUhjÞ ubah(hqubh?X , a modifier rå …ræ }rç (hX , a modifier hjÍ ubhf)rè }ré (hX ``default``h*}rê (h,]h-]h.]h/]h2]uhjÍ h6]rë h?Xdefaultrì …rí }rî (hUhjè ubah(hqubh?X, a character width of rï …rð }rñ (hX, a character width of hjÍ ubhf)rò }ró (hX``8bit``h*}rô (h,]h-]h.]h/]h2]uhjÍ h6]rõ h?X8bitrö …r÷ }rø (hUhjò ubah(hqubh?X, and a resolve strategy of rù …rú }rû (hX, and a resolve strategy of hjÍ ubhf)rü }rý (hX``tcp_resolve``h*}rþ (h,]h-]h.]h/]h2]uhjÍ h6]rÿ h?X tcp_resolver …r }r (hUhjü ubah(hqubh?X.…r }r (hX.hjÍ ubeubh)r }r (hUhKhhh#h&h(h)h*}r (h,]h-]h.]h/]r hÙah2]r hauh4K>h5hh6]r (h8)r }r (hXSynchronous Clientsr hj h#h&h(hh5hh6]r h?XSynchronous Clientsr …r }r (hj hj ubaubhR)r }r (hXuOf the client tags shown in the table, the following makes the ``basic_client`` behave as a fully synchronous client.hj h#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4K@h5hh6]r (h?X?Of the client tags shown in the table, the following makes the r …r }r (hX?Of the client tags shown in the table, the following makes the hj ubhf)r }r (hX``basic_client``h*}r (h,]h-]h.]h/]h2]uhj h6]r h?X basic_clientr …r }r (hUhj ubah(hqubh?X& behave as a fully synchronous client.r! …r" }r# (hX& behave as a fully synchronous client.hj ubeubhu)r$ }r% (hUhj h#Nh(hxh*}r& (h,]h-]h.]h/]h2]uh4Nh5hh6]r' h{)r( }r) (hUh*}r* (hX*h/]h.]h,]h-]h2]uhj$ h6]r+ (h)r, }r- (hX!**http_default_8bit_tcp_resolve**r. h*}r/ (h,]h-]h.]h/]h2]uhj( h6]r0 hR)r1 }r2 (hj. hj, h#h&h(hUh*}r3 (h,]h-]h.]h/]h2]uh4KCh6]r4 hŠ)r5 }r6 (hj. h*}r7 (h,]h-]h.]h/]h2]uhj1 h6]r8 h?Xhttp_default_8bit_tcp_resolver9 …r: }r; (hUhj5 ubah(h’ubaubah(h–ubh)r< }r= (hX!**http_default_8bit_udp_resolve**r> h*}r? (h,]h-]h.]h/]h2]uhj( h6]r@ hR)rA }rB (hj> hj< h#h&h(hUh*}rC (h,]h-]h.]h/]h2]uh4KDh6]rD hŠ)rE }rF (hj> h*}rG (h,]h-]h.]h/]h2]uhjA h6]rH h?Xhttp_default_8bit_udp_resolverI …rJ }rK (hUhjE ubah(h’ubaubah(h–ubh)rL }rM (hX#**http_keepalive_8bit_tcp_resolve**rN h*}rO (h,]h-]h.]h/]h2]uhj( h6]rP hR)rQ }rR (hjN hjL h#h&h(hUh*}rS (h,]h-]h.]h/]h2]uh4KEh6]rT hŠ)rU }rV (hjN h*}rW (h,]h-]h.]h/]h2]uhjQ h6]rX h?Xhttp_keepalive_8bit_tcp_resolverY …rZ }r[ (hUhjU ubah(h’ubaubah(h–ubh)r\ }r] (hX$**http_keepalive_8bit_udp_resolve** h*}r^ (h,]h-]h.]h/]h2]uhj( h6]r_ hR)r` }ra (hX#**http_keepalive_8bit_udp_resolve**rb hj\ h#h&h(hUh*}rc (h,]h-]h.]h/]h2]uh4KFh6]rd hŠ)re }rf (hjb h*}rg (h,]h-]h.]h/]h2]uhj` h6]rh h?Xhttp_keepalive_8bit_udp_resolveri …rj }rk (hUhje ubah(h’ubaubah(h–ubeh(h©ubaubhR)rl }rm (hX%The synchronous client implements all the operations of the client underneath the interface all block to wait for I/O to finish. All the member methods are synchronous and will block until the response object is ready or throws if erros are encountered in the performance of the HTTP requests.rn hj h#h&h(hUh*}ro (h,]h-]h.]h/]h2]uh4KHh5hh6]rp h?X%The synchronous client implements all the operations of the client underneath the interface all block to wait for I/O to finish. All the member methods are synchronous and will block until the response object is ready or throws if erros are encountered in the performance of the HTTP requests.rq …rr }rs (hjn hjl ubaubcdocutils.nodes warning rt )ru }rv (hXˆThe synchronous clients are **NOT** thread safe. You will need to do external synchronization to use synchronous client implementations.hj h#h&h(Uwarningrw h*}rx (h,]h-]h.]h/]h2]uh4Nh5hh6]ry hR)rz }r{ (hXˆThe synchronous clients are **NOT** thread safe. You will need to do external synchronization to use synchronous client implementations.hju h#h&h(hUh*}r| (h,]h-]h.]h/]h2]uh4KMh6]r} (h?XThe synchronous clients are r~ …r }r€ (hXThe synchronous clients are hjz ubhŠ)r }r‚ (hX**NOT**h*}rƒ (h,]h-]h.]h/]h2]uhjz h6]r„ h?XNOTr… …r† }r‡ (hUhj ubah(h’ubh?Xe thread safe. You will need to do external synchronization to use synchronous client implementations.rˆ …r‰ }rŠ (hXe thread safe. You will need to do external synchronization to use synchronous client implementations.hjz ubeubaubj )r‹ }rŒ (hX‡As of version 0.11, all the synchronous client implementations are deprecated. They will be removed in the next version of the library.hj h#h&h(j#h*}r (h,]h-]h.]h/]h2]uh4Nh5hh6]rŽ hR)r }r (hX‡As of version 0.11, all the synchronous client implementations are deprecated. They will be removed in the next version of the library.r‘ hj‹ h#h&h(hUh*}r’ (h,]h-]h.]h/]h2]uh4KPh6]r“ h?X‡As of version 0.11, all the synchronous client implementations are deprecated. They will be removed in the next version of the library.r” …r• }r– (hj‘ hj ubaubaubeubheubh#h&h(h)h*}r— (h,]h-]h.]h/]r˜ jŽ ah2]r™ hauh4KTh5hh6]rš (h8)r› }rœ (hXAsynchronous Clientsr hhh#h&h(h`` is an `Active Object`_. This means that the client has and manages its own lifetime thread, and returns values that are asynchronously filled in. The response object encapsulates Boost.Thread_ futures which get filled in once the values are available.hhh#h&h(hUh*}rÞ (h,]h-]h.]h/]h2]uh4K\h5hh6]rß (h?XLAn asynchronous client implementation means that``basic_client<...>`` is an rà …rá }râ (hXLAn asynchronous client implementation means that``basic_client<...>`` is an hjÜ ubhÒ)rã }rä (hX`Active Object`_hÕKhjÜ h(hÖh*}rå (UnameX Active ObjectjŒ X*http://en.wikipedia.org/wiki/Active_objectræ h/]h.]h,]h-]h2]uh6]rç h?X Active Objectrè …ré }rê (hUhjã ubaubh?X. This means that the client has and manages its own lifetime thread, and returns values that are asynchronously filled in. The response object encapsulates rë …rì }rí (hX. This means that the client has and manages its own lifetime thread, and returns values that are asynchronously filled in. The response object encapsulates hjÜ ubhÒ)rî }rï (hX Boost.Thread_hÕKhjÜ h(hÖh*}rð (UnameX Boost.ThreadjŒ j h/]h.]h,]h-]h2]uh6]rñ h?X Boost.Threadrò …ró }rô (hUhjî ubaubh?X; futures which get filled in once the values are available.rõ …rö }r÷ (hX; futures which get filled in once the values are available.hjÜ ubeubj± )rø }rù (hX2.. _Boost.Thread: http://www.boost.org/libs/threadhKhhh#h&h(j´ h*}rú (jŒ X http://www.boost.org/libs/threadh/]rû Uid1rü ah.]h,]rý X boost.threadrþ ah-]h2]uh4KŽh5hh6]ubj± )rÿ }r (hX?.. _`Active Object`: http://en.wikipedia.org/wiki/Active_objecthKhhh#h&h(j´ h*}r (jŒ jæ h/]r U active-objectr ah.]h,]h-]h2]r hauh4Kh5hh6]ubhR)r }r (hX»The asynchronous clients implement all operations asynchronously which are hidden from the user. The interface is still synchronous but the fetching of data happens on a different thread.r hhh#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4Keh5hh6]r h?X»The asynchronous clients implement all operations asynchronously which are hidden from the user. The interface is still synchronous but the fetching of data happens on a different thread.r …r }r (hj hj ubaubj )r }r (hXûThe asynchronous clients are thread safe, and can be shared across many threads. Each request starts a sequence of asynchronous operations dedicated to that request. The client does not re-cycle connections and uses a one-request-one-connection model.hhh#h&h(j#h*}r (h,]h-]h.]h/]h2]uh4Nh5hh6]r hR)r }r (hXûThe asynchronous clients are thread safe, and can be shared across many threads. Each request starts a sequence of asynchronous operations dedicated to that request. The client does not re-cycle connections and uses a one-request-one-connection model.r hj h#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4Kih6]r h?XûThe asynchronous clients are thread safe, and can be shared across many threads. Each request starts a sequence of asynchronous operations dedicated to that request. The client does not re-cycle connections and uses a one-request-one-connection model.r …r }r (hj hj ubaubaubhR)r }r (hXÅWhen an asynchronous client object is destroyed, it waits for all pending asynchronous operations to finish. Errors encountered during operations on retrieving data from the response objects cause exceptions to be thrown -- therefore it is best that if a client object is constructed, it should outlive the response object or be outside the try-catch block handling the errors from operations on responses. In code, usage should look like the following:r hhh#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4Knh5hh6]r h?XÅWhen an asynchronous client object is destroyed, it waits for all pending asynchronous operations to finish. Errors encountered during operations on retrieving data from the response objects cause exceptions to be thrown -- therefore it is best that if a client object is constructed, it should outlive the response object or be outside the try-catch block handling the errors from operations on responses. In code, usage should look like the following:r …r }r (hj hj ubaubj)r! }r" (hXÃhttp::client client; try { http::client::response response = client.get("http://www.example.com/"); std::cout << body(response); } catch (std::exception& e) { // deal with exceptions here }hhh#h&h(jh*}r# (j ‰j Xc++j j h/]h.]h,]h-]h2]uh4Kuh5hh6]r$ h?XÃhttp::client client; try { http::client::response response = client.get("http://www.example.com/"); std::cout << body(response); } catch (std::exception& e) { // deal with exceptions here }r% …r& }r' (hUhj! ubaubhR)r( }r) (hX˜A common mistake is to declare the client inside the try block which invokes undefined behavior when errors arise from the handling of response objects.r* hhh#h&h(hUh*}r+ (h,]h-]h.]h/]h2]uh4Kh5hh6]r, h?X˜A common mistake is to declare the client inside the try block which invokes undefined behavior when errors arise from the handling of response objects.r- …r. }r/ (hj* hj( ubaubeubh#h&h(Usystem_messager0 h*}r1 (h,]UlevelKh/]h.]r2 jü aUsourceh&h-]h2]UlineKbUtypeUINFOr3 uh4Kbh5hh6]r4 hR)r5 }r6 (hUh*}r7 (h,]h-]h.]h/]h2]uhhh6]r8 h?X/Duplicate explicit target name: "boost.thread".r9 …r: }r; (hUhj5 ubah(hUubaubaUcurrent_sourcer< NU decorationr= NUautofootnote_startr> KUnameidsr? }r@ (hhÙhjŽ hjÀh j· h h1h jPh j h hGhj hj<hhñhj‘uh6]rA h!ahUU transformerrB NU footnote_refsrC }rD UrefnamesrE }rF (Xsynchronous clients]rG (hÓj eXasynchronous clients]rH j‹ aX active object]rI jã aX boost.thread]rJ (j‰ jî euUsymbol_footnotesrK ]rL Uautofootnote_refsrM ]rN Usymbol_footnote_refsrO ]rP U citationsrQ ]rR h5hU current_linerS NUtransform_messagesrT ]rU UreporterrV NUid_startrW KU autofootnotesrX ]rY U citation_refsrZ }r[ Uindirect_targetsr\ ]r] Usettingsr^ (cdocutils.frontend Values r_ or` }ra (Ufootnote_backlinksrb KUrecord_dependenciesrc NU rfc_base_urlrd Uhttp://tools.ietf.org/html/re U tracebackrf ˆUpep_referencesrg NUstrip_commentsrh NU toc_backlinksri jçU language_coderj Uenrk U datestamprl NU report_levelrm KU _destinationrn NU halt_levelro KU strip_classesrp Nh(h/]h0]h1]h2]h4]uh6Kh7hh]q?cdocutils.nodes Text q@X HTTP RequestqA…qB}qC(h$h(h$X`Message Concept`_hPKh%j6h+hQh-}r?(UnameXMessage ConceptUrefurir@X(../in_depth/message.html#message-conceptrAh2]h1]h/]h0]h4]uh]rBh@XMessage ConceptrC…rD}rE(h$Uh%j=ubaubh@X, and also supports the following constructs.rF…rG}rH(h$X, and also supports the following constructs.h%j6ubeubhD)rI}rJ(h$X **Legend**rKh%j(h&h)h+hGh-}rL(h/]h0]h1]h2]h4]uh6K%h7hh]rMcdocutils.nodes strong rN)rO}rP(h$jKh-}rQ(h/]h0]h1]h2]h4]uh%jIh]rRh@XLegendrS…rT}rU(h$Uh%jOubah+UstrongrVubaubcdocutils.nodes field_list rW)rX}rY(h$Uh%j(h&h)h+U field_listrZh-}r[(h/]h0]h1]h2]h4]uh6K'h7hh]r\(cdocutils.nodes field r])r^}r_(h$Uh%jXh&h)h+Ufieldr`h-}ra(h/]h0]h1]h2]h4]uh6K'h7hh]rb(cdocutils.nodes field_name rc)rd}re(h$XRh-}rf(h/]h0]h1]h2]h4]uh%j^h]rgh@XR…rh}ri(h$XRh%jdubah+U field_namerjubcdocutils.nodes field_body rk)rl}rm(h$XThe request type.rnh-}ro(h/]h0]h1]h2]h4]uh%j^h]rphD)rq}rr(h$jnh%jlh&h)h+hGh-}rs(h/]h0]h1]h2]h4]uh6K'h]rth@XThe request type.ru…rv}rw(h$jnh%jqubaubah+U field_bodyrxubeubj])ry}rz(h$Uh%jXh&h)h+j`h-}r{(h/]h0]h1]h2]h4]uh6K(h7hh]r|(jc)r}}r~(h$Xrh-}r(h/]h0]h1]h2]h4]uh%jyh]r€h@Xr…r}r‚(h$Xrh%j}ubah+jjubjk)rƒ}r„(h$XAn instance of R.r…h-}r†(h/]h0]h1]h2]h4]uh%jyh]r‡hD)rˆ}r‰(h$j…h%jƒh&h)h+hGh-}rŠ(h/]h0]h1]h2]h4]uh6K(h]r‹h@XAn instance of R.rŒ…r}rŽ(h$j…h%jˆubaubah+jxubeubj])r}r(h$Uh%jXh&h)h+j`h-}r‘(h/]h0]h1]h2]h4]uh6K)h7hh]r’(jc)r“}r”(h$XSh-}r•(h/]h0]h1]h2]h4]uh%jh]r–h@XS…r—}r˜(h$XSh%j“ubah+jjubjk)r™}rš(h$XThe string type.r›h-}rœ(h/]h0]h1]h2]h4]uh%jh]rhD)rž}rŸ(h$j›h%j™h&h)h+hGh-}r (h/]h0]h1]h2]h4]uh6K)h]r¡h@XThe string type.r¢…r£}r¤(h$j›h%jžubaubah+jxubeubj])r¥}r¦(h$Uh%jXh&h)h+j`h-}r§(h/]h0]h1]h2]h4]uh6K*h7hh]r¨(jc)r©}rª(h$Xsh-}r«(h/]h0]h1]h2]h4]uh%j¥h]r¬h@Xs…r­}r®(h$Xsh%j©ubah+jjubjk)r¯}r°(h$XAn instance of S.r±h-}r²(h/]h0]h1]h2]h4]uh%j¥h]r³hD)r´}rµ(h$j±h%j¯h&h)h+hGh-}r¶(h/]h0]h1]h2]h4]uh6K*h]r·h@XAn instance of S.r¸…r¹}rº(h$j±h%j´ubaubah+jxubeubj])r»}r¼(h$Uh%jXh&h)h+j`h-}r½(h/]h0]h1]h2]h4]uh6K+h7hh]r¾(jc)r¿}rÀ(h$XPh-}rÁ(h/]h0]h1]h2]h4]uh%j»h]rÂh@XP…rÃ}rÄ(h$XPh%j¿ubah+jjubjk)rÅ}rÆ(h$XThe port type.rÇh-}rÈ(h/]h0]h1]h2]h4]uh%j»h]rÉhD)rÊ}rË(h$jÇh%jÅh&h)h+hGh-}rÌ(h/]h0]h1]h2]h4]uh6K+h]rÍh@XThe port type.rÎ…rÏ}rÐ(h$jÇh%jÊubaubah+jxubeubj])rÑ}rÒ(h$Uh%jXh&h)h+j`h-}rÓ(h/]h0]h1]h2]h4]uh6K,h7hh]rÔ(jc)rÕ}rÖ(h$Xph-}r×(h/]h0]h1]h2]h4]uh%jÑh]rØh@Xp…rÙ}rÚ(h$Xph%jÕubah+jjubjk)rÛ}rÜ(h$XAn instance of P. h-}rÝ(h/]h0]h1]h2]h4]uh%jÑh]rÞhD)rß}rà(h$XAn instance of P.ráh%jÛh&h)h+hGh-}râ(h/]h0]h1]h2]h4]uh6K,h]rãh@XAn instance of P.rä…rå}ræ(h$jáh%jßubaubah+jxubeubeubcdocutils.nodes table rç)rè}ré(h$Uh%j(h&h)h+Utablerêh-}rë(h/]h0]h1]h2]h4]uh6Nh7hh]rìcdocutils.nodes tgroup rí)rî}rï(h$Uh-}rð(h2]h1]h/]h0]h4]UcolsKuh%jèh]rñ(cdocutils.nodes colspec rò)ró}rô(h$Uh-}rõ(h2]h1]h/]h0]h4]UcolwidthKuh%jîh]h+Ucolspecröubjò)r÷}rø(h$Uh-}rù(h2]h1]h/]h0]h4]UcolwidthK uh%jîh]h+jöubjò)rú}rû(h$Uh-}rü(h2]h1]h/]h0]h4]UcolwidthK(uh%jîh]h+jöubcdocutils.nodes thead rý)rþ}rÿ(h$Uh-}r(h/]h0]h1]h2]h4]uh%jîh]rcdocutils.nodes row r)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jþh]r(cdocutils.nodes entry r)r}r (h$Uh-}r (h/]h0]h1]h2]h4]uh%jh]r hD)r }r (h$X Constructrh%jh&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6K/h]rh@X Constructr…r}r(h$jh%j ubaubah+Uentryrubj)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jh]rhD)r}r(h$XResultrh%jh&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6K/h]rh@XResultr…r}r (h$jh%jubaubah+jubj)r!}r"(h$Uh-}r#(h/]h0]h1]h2]h4]uh%jh]r$hD)r%}r&(h$X Descriptionr'h%j!h&h)h+hGh-}r((h/]h0]h1]h2]h4]uh6K/h]r)h@X Descriptionr*…r+}r,(h$j'h%j%ubaubah+jubeh+Urowr-ubah+Utheadr.ubcdocutils.nodes tbody r/)r0}r1(h$Uh-}r2(h/]h0]h1]h2]h4]uh%jîh]r3(j)r4}r5(h$Uh-}r6(h/]h0]h1]h2]h4]uh%j0h]r7(j)r8}r9(h$Uh-}r:(h/]h0]h1]h2]h4]uh%j4h]r;hD)r<}r=(h$X``R::string_type``r>h%j8h&h)h+hGh-}r?(h/]h0]h1]h2]h4]uh6K1h]r@hë)rA}rB(h$j>h-}rC(h/]h0]h1]h2]h4]uh%j<h]rDh@XR::string_typerE…rF}rG(h$Uh%jAubah+hóubaubah+jubj)rH}rI(h$Uh-}rJ(h/]h0]h1]h2]h4]uh%j4h]rKhD)rL}rM(h$X``S``rNh%jHh&h)h+hGh-}rO(h/]h0]h1]h2]h4]uh6K1h]rPhë)rQ}rR(h$jNh-}rS(h/]h0]h1]h2]h4]uh%jLh]rTh@XS…rU}rV(h$Uh%jQubah+hóubaubah+jubj)rW}rX(h$Uh-}rY(h/]h0]h1]h2]h4]uh%j4h]rZhD)r[}r\(h$X The nested ``string_type`` type.h%jWh&h)h+hGh-}r](h/]h0]h1]h2]h4]uh6K1h]r^(h@X The nested r_…r`}ra(h$X The nested h%j[ubhë)rb}rc(h$X``string_type``h-}rd(h/]h0]h1]h2]h4]uh%j[h]reh@X string_typerf…rg}rh(h$Uh%jbubah+hóubh@X type.ri…rj}rk(h$X type.h%j[ubeubah+jubeh+j-ubj)rl}rm(h$Uh-}rn(h/]h0]h1]h2]h4]uh%j0h]ro(j)rp}rq(h$Uh-}rr(h/]h0]h1]h2]h4]uh%jlh]rshD)rt}ru(h$X``R::port_type``rvh%jph&h)h+hGh-}rw(h/]h0]h1]h2]h4]uh6K3h]rxhë)ry}rz(h$jvh-}r{(h/]h0]h1]h2]h4]uh%jth]r|h@X R::port_typer}…r~}r(h$Uh%jyubah+hóubaubah+jubj)r€}r(h$Uh-}r‚(h/]h0]h1]h2]h4]uh%jlh]rƒhD)r„}r…(h$X``P``r†h%j€h&h)h+hGh-}r‡(h/]h0]h1]h2]h4]uh6K3h]rˆhë)r‰}rŠ(h$j†h-}r‹(h/]h0]h1]h2]h4]uh%j„h]rŒh@XP…r}rŽ(h$Uh%j‰ubah+hóubaubah+jubj)r}r(h$Uh-}r‘(h/]h0]h1]h2]h4]uh%jlh]r’hD)r“}r”(h$XThe nested ``port_type`` type.h%jh&h)h+hGh-}r•(h/]h0]h1]h2]h4]uh6K3h]r–(h@X The nested r—…r˜}r™(h$X The nested h%j“ubhë)rš}r›(h$X ``port_type``h-}rœ(h/]h0]h1]h2]h4]uh%j“h]rh@X port_typerž…rŸ}r (h$Uh%jšubah+hóubh@X type.r¡…r¢}r£(h$X type.h%j“ubeubah+jubeh+j-ubj)r¤}r¥(h$Uh-}r¦(h/]h0]h1]h2]h4]uh%j0h]r§(j)r¨}r©(h$Uh-}rª(h/]h0]h1]h2]h4]uh%j¤h]r«hD)r¬}r­(h$X ``R r(s)``r®h%j¨h&h)h+hGh-}r¯(h/]h0]h1]h2]h4]uh6K5h]r°hë)r±}r²(h$j®h-}r³(h/]h0]h1]h2]h4]uh%j¬h]r´h@XR r(s)rµ…r¶}r·(h$Uh%j±ubah+hóubaubah+jubj)r¸}r¹(h$Uh-}rº(h/]h0]h1]h2]h4]uh%j¤h]r»hD)r¼}r½(h$X**NA**r¾h%j¸h&h)h+hGh-}r¿(h/]h0]h1]h2]h4]uh6K5h]rÀjN)rÁ}rÂ(h$j¾h-}rÃ(h/]h0]h1]h2]h4]uh%j¼h]rÄh@XNArÅ…rÆ}rÇ(h$Uh%jÁubah+jVubaubah+jubj)rÈ}rÉ(h$Uh-}rÊ(h/]h0]h1]h2]h4]uh%j¤h]rËhD)rÌ}rÍ(h$XnConstruct a Request with an ``s`` provided. This treats ``s`` as the URI to where the request is destined for.h%jÈh&h)h+hGh-}rÎ(h/]h0]h1]h2]h4]uh6K5h]rÏ(h@XConstruct a Request with an rÐ…rÑ}rÒ(h$XConstruct a Request with an h%jÌubhë)rÓ}rÔ(h$X``s``h-}rÕ(h/]h0]h1]h2]h4]uh%jÌh]rÖh@Xs…r×}rØ(h$Uh%jÓubah+hóubh@X provided. This treats rÙ…rÚ}rÛ(h$X provided. This treats h%jÌubhë)rÜ}rÝ(h$X``s``h-}rÞ(h/]h0]h1]h2]h4]uh%jÌh]rßh@Xs…rà}rá(h$Uh%jÜubah+hóubh@X1 as the URI to where the request is destined for.râ…rã}rä(h$X1 as the URI to where the request is destined for.h%jÌubeubah+jubeh+j-ubj)rå}ræ(h$Uh-}rç(h/]h0]h1]h2]h4]uh%j0h]rè(j)ré}rê(h$Uh-}rë(h/]h0]h1]h2]h4]uh%jåh]rìhD)rí}rî(h$X``host(request)``rïh%jéh&h)h+hGh-}rð(h/]h0]h1]h2]h4]uh6K9h]rñhë)rò}ró(h$jïh-}rô(h/]h0]h1]h2]h4]uh%jíh]rõh@X host(request)rö…r÷}rø(h$Uh%jòubah+hóubaubah+jubj)rù}rú(h$Uh-}rû(h/]h0]h1]h2]h4]uh%jåh]rühD)rý}rþ(h$XConvertible to ``S``h%jùh&h)h+hGh-}rÿ(h/]h0]h1]h2]h4]uh6K9h]r(h@XConvertible to r…r}r(h$XConvertible to h%jýubhë)r}r(h$X``S``h-}r(h/]h0]h1]h2]h4]uh%jýh]rh@XS…r}r (h$Uh%jubah+hóubeubah+jubj)r }r (h$Uh-}r (h/]h0]h1]h2]h4]uh%jåh]r hD)r}r(h$X5Return the host to where the request is destined for.rh%j h&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6K9h]rh@X5Return the host to where the request is destined for.r…r}r(h$jh%jubaubah+jubeh+j-ubj)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%j0h]r(j)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jh]rhD)r}r(h$X``port(request)``r h%jh&h)h+hGh-}r!(h/]h0]h1]h2]h4]uh6KhD)r?}r@(h$X5Return the port to where the request is destined for.rAh%j;h&h)h+hGh-}rB(h/]h0]h1]h2]h4]uh6K(j)r?}r@(h$Uh-}rA(h/]h0]h1]h2]h4]uh%j;h]rBhD)rC}rD(h$X ``uri(r, s)``rEh%j?h&h)h+hGh-}rF(h/]h0]h1]h2]h4]uh6KMh]rGhë)rH}rI(h$jEh-}rJ(h/]h0]h1]h2]h4]uh%jCh]rKh@X uri(r, s)rL…rM}rN(h$Uh%jHubah+hóubaubah+jubj)rO}rP(h$Uh-}rQ(h/]h0]h1]h2]h4]uh%j;h]rRhD)rS}rT(h$X``void``rUh%jOh&h)h+hGh-}rV(h/]h0]h1]h2]h4]uh6KMh]rWhë)rX}rY(h$jUh-}rZ(h/]h0]h1]h2]h4]uh%jSh]r[h@Xvoidr\…r]}r^(h$Uh%jXubah+hóubaubah+jubj)r_}r`(h$Uh-}ra(h/]h0]h1]h2]h4]uh%j;h]rbhD)rc}rd(h$XSet the URI of the request.reh%j_h&h)h+hGh-}rf(h/]h0]h1]h2]h4]uh6KMh]rgh@XSet the URI of the request.rh…ri}rj(h$jeh%jcubaubah+jubeh+j-ubeh+Utbodyrkubeh+Utgrouprlubaubeubh!)rm}rn(h$Uh{Kh%hyh&h)h+h,h-}ro(h/]h0]h1]h2]rphah4]rqh auh6KQh7hh]rr(h9)rs}rt(h$XPod Server Request Conceptruh%jmh&h)h+h=h-}rv(h/]h0]h1]h2]h4]uh6KQh7hh]rwh@XPod Server Request Conceptrx…ry}rz(h$juh%jsubaubhD)r{}r|(h$X|A type models the Pod Server Request Concept if it models the `Message Concept`_ and also supports the following constructs.h%jmh&h)h+hGh-}r}(h/]h0]h1]h2]h4]uh6KSh7hh]r~(h@X>A type models the Pod Server Request Concept if it models the r…r€}r(h$X>A type models the Pod Server Request Concept if it models the h%j{ubhM)r‚}rƒ(h$X`Message Concept`_hPKh%j{h+hQh-}r„(UnameXMessage Conceptj@jAh2]h1]h/]h0]h4]uh]r…h@XMessage Conceptr†…r‡}rˆ(h$Uh%j‚ubaubh@X, and also supports the following constructs.r‰…rŠ}r‹(h$X, and also supports the following constructs.h%j{ubeubhD)rŒ}r(h$X **Legend**rŽh%jmh&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6KVh7hh]rjN)r‘}r’(h$jŽh-}r“(h/]h0]h1]h2]h4]uh%jŒh]r”h@XLegendr•…r–}r—(h$Uh%j‘ubah+jVubaubjW)r˜}r™(h$Uh%jmh&h)h+jZh-}rš(h/]h0]h1]h2]h4]uh6KXh7hh]r›(j])rœ}r(h$Uh%j˜h&h)h+j`h-}rž(h/]h0]h1]h2]h4]uh6KXh7hh]rŸ(jc)r }r¡(h$XRh-}r¢(h/]h0]h1]h2]h4]uh%jœh]r£h@XR…r¤}r¥(h$XRh%j ubah+jjubjk)r¦}r§(h$XThe request type.r¨h-}r©(h/]h0]h1]h2]h4]uh%jœh]rªhD)r«}r¬(h$j¨h%j¦h&h)h+hGh-}r­(h/]h0]h1]h2]h4]uh6KXh]r®h@XThe request type.r¯…r°}r±(h$j¨h%j«ubaubah+jxubeubj])r²}r³(h$Uh%j˜h&h)h+j`h-}r´(h/]h0]h1]h2]h4]uh6KYh7hh]rµ(jc)r¶}r·(h$Xrh-}r¸(h/]h0]h1]h2]h4]uh%j²h]r¹h@Xr…rº}r»(h$Xrh%j¶ubah+jjubjk)r¼}r½(h$XAn instance of R.r¾h-}r¿(h/]h0]h1]h2]h4]uh%j²h]rÀhD)rÁ}rÂ(h$j¾h%j¼h&h)h+hGh-}rÃ(h/]h0]h1]h2]h4]uh6KYh]rÄh@XAn instance of R.rÅ…rÆ}rÇ(h$j¾h%jÁubaubah+jxubeubj])rÈ}rÉ(h$Uh%j˜h&h)h+j`h-}rÊ(h/]h0]h1]h2]h4]uh6KZh7hh]rË(jc)rÌ}rÍ(h$XSh-}rÎ(h/]h0]h1]h2]h4]uh%jÈh]rÏh@XS…rÐ}rÑ(h$XSh%jÌubah+jjubjk)rÒ}rÓ(h$XThe string type.rÔh-}rÕ(h/]h0]h1]h2]h4]uh%jÈh]rÖhD)r×}rØ(h$jÔh%jÒh&h)h+hGh-}rÙ(h/]h0]h1]h2]h4]uh6KZh]rÚh@XThe string type.rÛ…rÜ}rÝ(h$jÔh%j×ubaubah+jxubeubj])rÞ}rß(h$Uh%j˜h&h)h+j`h-}rà(h/]h0]h1]h2]h4]uh6K[h7hh]rá(jc)râ}rã(h$XIh-}rä(h/]h0]h1]h2]h4]uh%jÞh]råh@XI…ræ}rç(h$XIh%jâubah+jjubjk)rè}ré(h$XAn unsigned 8 bit integer.rêh-}rë(h/]h0]h1]h2]h4]uh%jÞh]rìhD)rí}rî(h$jêh%jèh&h)h+hGh-}rï(h/]h0]h1]h2]h4]uh6K[h]rðh@XAn unsigned 8 bit integer.rñ…rò}ró(h$jêh%jíubaubah+jxubeubj])rô}rõ(h$Uh%j˜h&h)h+j`h-}rö(h/]h0]h1]h2]h4]uh6K\h7hh]r÷(jc)rø}rù(h$XVh-}rú(h/]h0]h1]h2]h4]uh%jôh]rûh@XV…rü}rý(h$XVh%jøubah+jjubjk)rþ}rÿ(h$XThe vector type for headers. h-}r(h/]h0]h1]h2]h4]uh%jôh]rhD)r}r(h$XThe vector type for headers.rh%jþh&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6K\h]rh@XThe vector type for headers.r…r}r (h$jh%jubaubah+jxubeubeubjç)r }r (h$Uh%jmh&h)h+jêh-}r (h/]h0]h1]h2]h4]uh6Nh7hh]r jí)r}r(h$Uh-}r(h2]h1]h/]h0]h4]UcolsKuh%j h]r(jò)r}r(h$Uh-}r(h2]h1]h/]h0]h4]UcolwidthKuh%jh]h+jöubjò)r}r(h$Uh-}r(h2]h1]h/]h0]h4]UcolwidthKuh%jh]h+jöubjò)r}r(h$Uh-}r(h2]h1]h/]h0]h4]UcolwidthK%uh%jh]h+jöubjý)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jh]rj)r}r (h$Uh-}r!(h/]h0]h1]h2]h4]uh%jh]r"(j)r#}r$(h$Uh-}r%(h/]h0]h1]h2]h4]uh%jh]r&hD)r'}r((h$X Constructr)h%j#h&h)h+hGh-}r*(h/]h0]h1]h2]h4]uh6K_h]r+h@X Constructr,…r-}r.(h$j)h%j'ubaubah+jubj)r/}r0(h$Uh-}r1(h/]h0]h1]h2]h4]uh%jh]r2hD)r3}r4(h$XResultr5h%j/h&h)h+hGh-}r6(h/]h0]h1]h2]h4]uh6K_h]r7h@XResultr8…r9}r:(h$j5h%j3ubaubah+jubj)r;}r<(h$Uh-}r=(h/]h0]h1]h2]h4]uh%jh]r>hD)r?}r@(h$X DescriptionrAh%j;h&h)h+hGh-}rB(h/]h0]h1]h2]h4]uh6K_h]rCh@X DescriptionrD…rE}rF(h$jAh%j?ubaubah+jubeh+j-ubah+j.ubj/)rG}rH(h$Uh-}rI(h/]h0]h1]h2]h4]uh%jh]rJ(j)rK}rL(h$Uh-}rM(h/]h0]h1]h2]h4]uh%jGh]rN(j)rO}rP(h$Uh-}rQ(h/]h0]h1]h2]h4]uh%jKh]rRhD)rS}rT(h$X``R::string_type``rUh%jOh&h)h+hGh-}rV(h/]h0]h1]h2]h4]uh6Kah]rWhë)rX}rY(h$jUh-}rZ(h/]h0]h1]h2]h4]uh%jSh]r[h@XR::string_typer\…r]}r^(h$Uh%jXubah+hóubaubah+jubj)r_}r`(h$Uh-}ra(h/]h0]h1]h2]h4]uh%jKh]rbhD)rc}rd(h$X``S``reh%j_h&h)h+hGh-}rf(h/]h0]h1]h2]h4]uh6Kah]rghë)rh}ri(h$jeh-}rj(h/]h0]h1]h2]h4]uh%jch]rkh@XS…rl}rm(h$Uh%jhubah+hóubaubah+jubj)rn}ro(h$Uh-}rp(h/]h0]h1]h2]h4]uh%jKh]rqhD)rr}rs(h$X The nested ``string_type`` type.h%jnh&h)h+hGh-}rt(h/]h0]h1]h2]h4]uh6Kah]ru(h@X The nested rv…rw}rx(h$X The nested h%jrubhë)ry}rz(h$X``string_type``h-}r{(h/]h0]h1]h2]h4]uh%jrh]r|h@X string_typer}…r~}r(h$Uh%jyubah+hóubh@X type.r€…r}r‚(h$X type.h%jrubeubah+jubeh+j-ubj)rƒ}r„(h$Uh-}r…(h/]h0]h1]h2]h4]uh%jGh]r†(j)r‡}rˆ(h$Uh-}r‰(h/]h0]h1]h2]h4]uh%jƒh]rŠhD)r‹}rŒ(h$X``R::headers_container_type``rh%j‡h&h)h+hGh-}rŽ(h/]h0]h1]h2]h4]uh6Kch]rhë)r}r‘(h$jh-}r’(h/]h0]h1]h2]h4]uh%j‹h]r“h@XR::headers_container_typer”…r•}r–(h$Uh%jubah+hóubaubah+jubj)r—}r˜(h$Uh-}r™(h/]h0]h1]h2]h4]uh%jƒh]ršhD)r›}rœ(h$X``V``rh%j—h&h)h+hGh-}rž(h/]h0]h1]h2]h4]uh6Kch]rŸhë)r }r¡(h$jh-}r¢(h/]h0]h1]h2]h4]uh%j›h]r£h@XV…r¤}r¥(h$Uh%j ubah+hóubaubah+jubj)r¦}r§(h$Uh-}r¨(h/]h0]h1]h2]h4]uh%jƒh]r©hD)rª}r«(h$X+The nested ``headers_container_type`` type.h%j¦h&h)h+hGh-}r¬(h/]h0]h1]h2]h4]uh6Kch]r­(h@X The nested r®…r¯}r°(h$X The nested h%jªubhë)r±}r²(h$X``headers_container_type``h-}r³(h/]h0]h1]h2]h4]uh%jªh]r´h@Xheaders_container_typerµ…r¶}r·(h$Uh%j±ubah+hóubh@X type.r¸…r¹}rº(h$X type.h%jªubeubah+jubeh+j-ubj)r»}r¼(h$Uh-}r½(h/]h0]h1]h2]h4]uh%jGh]r¾(j)r¿}rÀ(h$Uh-}rÁ(h/]h0]h1]h2]h4]uh%j»h]rÂhD)rÃ}rÄ(h$X ``r.source``rÅh%j¿h&h)h+hGh-}rÆ(h/]h0]h1]h2]h4]uh6Kfh]rÇhë)rÈ}rÉ(h$jÅh-}rÊ(h/]h0]h1]h2]h4]uh%jÃh]rËh@Xr.sourcerÌ…rÍ}rÎ(h$Uh%jÈubah+hóubaubah+jubj)rÏ}rÐ(h$Uh-}rÑ(h/]h0]h1]h2]h4]uh%j»h]rÒhD)rÓ}rÔ(h$X``S``rÕh%jÏh&h)h+hGh-}rÖ(h/]h0]h1]h2]h4]uh6Kfh]r×hë)rØ}rÙ(h$jÕh-}rÚ(h/]h0]h1]h2]h4]uh%jÓh]rÛh@XS…rÜ}rÝ(h$Uh%jØubah+hóubaubah+jubj)rÞ}rß(h$Uh-}rà(h/]h0]h1]h2]h4]uh%j»h]ráhD)râ}rã(h$X!The nested source of the request.räh%jÞh&h)h+hGh-}rå(h/]h0]h1]h2]h4]uh6Kfh]ræh@X!The nested source of the request.rç…rè}ré(h$jäh%jâubaubah+jubeh+j-ubj)rê}rë(h$Uh-}rì(h/]h0]h1]h2]h4]uh%jGh]rí(j)rî}rï(h$Uh-}rð(h/]h0]h1]h2]h4]uh%jêh]rñhD)rò}ró(h$X ``r.method``rôh%jîh&h)h+hGh-}rõ(h/]h0]h1]h2]h4]uh6Khh]röhë)r÷}rø(h$jôh-}rù(h/]h0]h1]h2]h4]uh%jòh]rúh@Xr.methodrû…rü}rý(h$Uh%j÷ubah+hóubaubah+jubj)rþ}rÿ(h$Uh-}r(h/]h0]h1]h2]h4]uh%jêh]rhD)r}r(h$X``S``rh%jþh&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6Khh]rhë)r}r(h$jh-}r (h/]h0]h1]h2]h4]uh%jh]r h@XS…r }r (h$Uh%jubah+hóubaubah+jubj)r }r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jêh]rhD)r}r(h$XThe method of the request.rh%j h&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6Khh]rh@XThe method of the request.r…r}r(h$jh%jubaubah+jubeh+j-ubj)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jGh]r(j)r}r(h$Uh-}r(h/]h0]h1]h2]h4]uh%jh]r hD)r!}r"(h$X``r.destination``r#h%jh&h)h+hGh-}r$(h/]h0]h1]h2]h4]uh6Kjh]r%hë)r&}r'(h$j#h-}r((h/]h0]h1]h2]h4]uh%j!h]r)h@X r.destinationr*…r+}r,(h$Uh%j&ubah+hóubaubah+jubj)r-}r.(h$Uh-}r/(h/]h0]h1]h2]h4]uh%jh]r0hD)r1}r2(h$X``S``r3h%j-h&h)h+hGh-}r4(h/]h0]h1]h2]h4]uh6Kjh]r5hë)r6}r7(h$j3h-}r8(h/]h0]h1]h2]h4]uh%j1h]r9h@XS…r:}r;(h$Uh%j6ubah+hóubaubah+jubj)r<}r=(h$Uh-}r>(h/]h0]h1]h2]h4]uh%jh]r?hD)r@}rA(h$XHThe destination of the request. This is normally the URI of the request.rBh%j<h&h)h+hGh-}rC(h/]h0]h1]h2]h4]uh6Kjh]rDh@XHThe destination of the request. This is normally the URI of the request.rE…rF}rG(h$jBh%j@ubaubah+jubeh+j-ubj)rH}rI(h$Uh-}rJ(h/]h0]h1]h2]h4]uh%jGh]rK(j)rL}rM(h$Uh-}rN(h/]h0]h1]h2]h4]uh%jHh]rOhD)rP}rQ(h$X``r.version_major``rRh%jLh&h)h+hGh-}rS(h/]h0]h1]h2]h4]uh6Knh]rThë)rU}rV(h$jRh-}rW(h/]h0]h1]h2]h4]uh%jPh]rXh@Xr.version_majorrY…rZ}r[(h$Uh%jUubah+hóubaubah+jubj)r\}r](h$Uh-}r^(h/]h0]h1]h2]h4]uh%jHh]r_hD)r`}ra(h$X``I``rbh%j\h&h)h+hGh-}rc(h/]h0]h1]h2]h4]uh6Knh]rdhë)re}rf(h$jbh-}rg(h/]h0]h1]h2]h4]uh%j`h]rhh@XI…ri}rj(h$Uh%jeubah+hóubaubah+jubj)rk}rl(h$Uh-}rm(h/]h0]h1]h2]h4]uh%jHh]rnhD)ro}rp(h$X-The major version number part of the request.rqh%jkh&h)h+hGh-}rr(h/]h0]h1]h2]h4]uh6Knh]rsh@X-The major version number part of the request.rt…ru}rv(h$jqh%joubaubah+jubeh+j-ubj)rw}rx(h$Uh-}ry(h/]h0]h1]h2]h4]uh%jGh]rz(j)r{}r|(h$Uh-}r}(h/]h0]h1]h2]h4]uh%jwh]r~hD)r}r€(h$X``r.version_minor``rh%j{h&h)h+hGh-}r‚(h/]h0]h1]h2]h4]uh6Kqh]rƒhë)r„}r…(h$jh-}r†(h/]h0]h1]h2]h4]uh%jh]r‡h@Xr.version_minorrˆ…r‰}rŠ(h$Uh%j„ubah+hóubaubah+jubj)r‹}rŒ(h$Uh-}r(h/]h0]h1]h2]h4]uh%jwh]rŽhD)r}r(h$X``I``r‘h%j‹h&h)h+hGh-}r’(h/]h0]h1]h2]h4]uh6Kqh]r“hë)r”}r•(h$j‘h-}r–(h/]h0]h1]h2]h4]uh%jh]r—h@XI…r˜}r™(h$Uh%j”ubah+hóubaubah+jubj)rš}r›(h$Uh-}rœ(h/]h0]h1]h2]h4]uh%jwh]rhD)rž}rŸ(h$X-The minor version number part of the request.r h%jšh&h)h+hGh-}r¡(h/]h0]h1]h2]h4]uh6Kqh]r¢h@X-The minor version number part of the request.r£…r¤}r¥(h$j h%jžubaubah+jubeh+j-ubj)r¦}r§(h$Uh-}r¨(h/]h0]h1]h2]h4]uh%jGh]r©(j)rª}r«(h$Uh-}r¬(h/]h0]h1]h2]h4]uh%j¦h]r­hD)r®}r¯(h$X ``r.headers``r°h%jªh&h)h+hGh-}r±(h/]h0]h1]h2]h4]uh6Kth]r²hë)r³}r´(h$j°h-}rµ(h/]h0]h1]h2]h4]uh%j®h]r¶h@X r.headersr·…r¸}r¹(h$Uh%j³ubah+hóubaubah+jubj)rº}r»(h$Uh-}r¼(h/]h0]h1]h2]h4]uh%j¦h]r½hD)r¾}r¿(h$X``V``rÀh%jºh&h)h+hGh-}rÁ(h/]h0]h1]h2]h4]uh6Kth]rÂhë)rÃ}rÄ(h$jÀh-}rÅ(h/]h0]h1]h2]h4]uh%j¾h]rÆh@XV…rÇ}rÈ(h$Uh%jÃubah+hóubaubah+jubj)rÉ}rÊ(h$Uh-}rË(h/]h0]h1]h2]h4]uh%j¦h]rÌhD)rÍ}rÎ(h$XThe vector of headers.rÏh%jÉh&h)h+hGh-}rÐ(h/]h0]h1]h2]h4]uh6Kth]rÑh@XThe vector of headers.rÒ…rÓ}rÔ(h$jÏh%jÍubaubah+jubeh+j-ubj)rÕ}rÖ(h$Uh-}r×(h/]h0]h1]h2]h4]uh%jGh]rØ(j)rÙ}rÚ(h$Uh-}rÛ(h/]h0]h1]h2]h4]uh%jÕh]rÜhD)rÝ}rÞ(h$X ``r.body``rßh%jÙh&h)h+hGh-}rà(h/]h0]h1]h2]h4]uh6Kvh]ráhë)râ}rã(h$jßh-}rä(h/]h0]h1]h2]h4]uh%jÝh]råh@Xr.bodyræ…rç}rè(h$Uh%jâubah+hóubaubah+jubj)ré}rê(h$Uh-}rë(h/]h0]h1]h2]h4]uh%jÕh]rìhD)rí}rî(h$X``S``rïh%jéh&h)h+hGh-}rð(h/]h0]h1]h2]h4]uh6Kvh]rñhë)rò}ró(h$jïh-}rô(h/]h0]h1]h2]h4]uh%jíh]rõh@XS…rö}r÷(h$Uh%jòubah+hóubaubah+jubj)rø}rù(h$Uh-}rú(h/]h0]h1]h2]h4]uh%jÕh]rûhD)rü}rý(h$XThe body of the request.rþh%jøh&h)h+hGh-}rÿ(h/]h0]h1]h2]h4]uh6Kvh]rh@XThe body of the request.r…r}r(h$jþh%jüubaubah+jubeh+j-ubeh+jkubeh+jlubaubcdocutils.nodes target r)r}r(h$X=.. _Message Concept: ../in_depth/message.html#message-concepth{Kh%jmh&h)h+Utargetrh-}r(j@jAh2]r hah1]h/]h0]h4]r h auh6Kyh7hh]ubeubeubh!)r }r (h$Uh{Kh%h"h&h)h+h,h-}r (h/]h0]h1]h2]rhah4]rh auh6K|h7hh]r(h9)r}r(h$X Directivesrh%j h&h)h+h=h-}r(h/]h0]h1]h2]h4]uh6K|h7hh]rh@X Directivesr…r}r(h$jh%jubaubhD)r}r(h$XÅThis section details the provided directives that are provided by :mod:`cpp-netlib`. The section was written to assume that an appropriately constructed request instance is either of the following:h%j h&h)h+hGh-}r(h/]h0]h1]h2]h4]uh6K~h7hh]r(h@XBThis section details the provided directives that are provided by r…r}r(h$XBThis section details the provided directives that are provided by h%jubcsphinx.addnodes pending_xref r )r!}r"(h$X:mod:`cpp-netlib`r#h%jh&h)h+U pending_xrefr$h-}r%(UreftypeXmodUrefwarnr&‰U reftargetr'X cpp-netlibU refdomainXpyr(h2]h1]U refexplicit‰h/]h0]h4]Urefdocr)Xreference/http_requestr*Upy:classr+NU py:moduler,Nuh6K~h]r-hë)r.}r/(h$j#h-}r0(h/]h0]r1(Uxrefr2j(Xpy-modr3eh1]h2]h4]uh%j!h]r4h@X cpp-netlibr5…r6}r7(h$Uh%j.ubah+hóubaubh@Xr. The section was written to assume that an appropriately constructed request instance is either of the following:r8…r9}r:(h$Xr. The section was written to assume that an appropriately constructed request instance is either of the following:h%jubeubcdocutils.nodes literal_block r;)r<}r=(h$XÍboost::network::http::basic_request< boost::network::http::tags::http_default_8bit_udp_resolve > request; // or boost::network::http::basic_request< boost::network::http::tags::http_server > request;h%j h&h)h+U literal_blockr>h-}r?(Ulinenosr@‰UlanguagerAXc++U xml:spacerBUpreserverCh2]h1]h/]h0]h4]uh6K‚h7hh]rDh@XÍboost::network::http::basic_request< boost::network::http::tags::http_default_8bit_udp_resolve > request; // or boost::network::http::basic_request< boost::network::http::tags::http_server > request;rE…rF}rG(h$Uh%j<ubaubhD)rH}rI(h$XWThe section also assumes that there following using namespace declaration is in effect:rJh%j h&h)h+hGh-}rK(h/]h0]h1]h2]h4]uh6KŽh7hh]rLh@XWThe section also assumes that there following using namespace declaration is in effect:rM…rN}rO(h$jJh%jHubaubj;)rP}rQ(h$Xusing namespace boost::network;h%j h&h)h+j>h-}rR(j@‰jAXc++jBjCh2]h1]h/]h0]h4]uh6K‘h7hh]rSh@Xusing namespace boost::network;rT…rU}rV(h$Uh%jPubaubhD)rW}rX(h$X8Directives are meant to be used in the following manner:rYh%j h&h)h+hGh-}rZ(h/]h0]h1]h2]h4]uh6K•h7hh]r[h@X8Directives are meant to be used in the following manner:r\…r]}r^(h$jYh%jWubaubj;)r_}r`(h$Xrequest << directive(...);h%j h&h)h+j>h-}ra(j@‰jAXc++jBjCh2]h1]h/]h0]h4]uh6K—h7hh]rbh@Xrequest << directive(...);rc…rd}re(h$Uh%j_ubaubcdocutils.nodes warning rf)rg}rh(h$XèThere are two versions of directives, those that are applicable to messages that support narrow strings (``std::string``) and those that are applicable to messages that support wide strings (``std::wstring``). The :mod:`cpp-netlib` implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases. For now all the implemented directives are listed, even if some of them still do not implement things correctly.h%j h&h)h+Uwarningrih-}rj(h/]h0]h1]h2]h4]uh6Nh7hh]rk(hD)rl}rm(h$XvThere are two versions of directives, those that are applicable to messages that support narrow strings (``std::string``) and those that are applicable to messages that support wide strings (``std::wstring``). The :mod:`cpp-netlib` implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases.h%jgh&h)h+hGh-}rn(h/]h0]h1]h2]h4]uh6K›h]ro(h@XiThere are two versions of directives, those that are applicable to messages that support narrow strings (rp…rq}rr(h$XiThere are two versions of directives, those that are applicable to messages that support narrow strings (h%jlubhë)rs}rt(h$X``std::string``h-}ru(h/]h0]h1]h2]h4]uh%jlh]rvh@X std::stringrw…rx}ry(h$Uh%jsubah+hóubh@XG) and those that are applicable to messages that support wide strings (rz…r{}r|(h$XG) and those that are applicable to messages that support wide strings (h%jlubhë)r}}r~(h$X``std::wstring``h-}r(h/]h0]h1]h2]h4]uh%jlh]r€h@X std::wstringr…r‚}rƒ(h$Uh%j}ubah+hóubh@X). The r„…r…}r†(h$X). The h%jlubj )r‡}rˆ(h$X:mod:`cpp-netlib`r‰h%jlh&h)h+j$h-}rŠ(UreftypeXmodj&‰j'X cpp-netlibU refdomainXpyr‹h2]h1]U refexplicit‰h/]h0]h4]j)j*j+Nj,Nuh6K›h]rŒhë)r}rŽ(h$j‰h-}r(h/]h0]r(j2j‹Xpy-modr‘eh1]h2]h4]uh%j‡h]r’h@X cpp-netlibr“…r”}r•(h$Uh%jubah+hóubaubh@X implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases.r–…r—}r˜(h$X implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases.h%jlubeubhD)r™}rš(h$XpFor now all the implemented directives are listed, even if some of them still do not implement things correctly.r›h%jgh&h)h+hGh-}rœ(h/]h0]h1]h2]h4]uh6K¢h]rh@XpFor now all the implemented directives are listed, even if some of them still do not implement things correctly.rž…rŸ}r (h$j›h%j™ubaubeubcdocutils.nodes definition_list r¡)r¢}r£(h$Uh%j h&h)h+Udefinition_listr¤h-}r¥(h/]h0]h1]h2]h4]uh6Nh7hh]r¦(cdocutils.nodes definition_list_item r§)r¨}r©(h$Xž*unspecified* ``source(std::string const & source_)`` Create a source directive with a ``std::string`` as a parameter, to be set as the source of the request.h%j¢h&h)h+Udefinition_list_itemrªh-}r«(h/]h0]h1]h2]h4]uh6K¦h]r¬(cdocutils.nodes term r­)r®}r¯(h$X5*unspecified* ``source(std::string const & source_)``r°h%j¨h&h)h+Utermr±h-}r²(h/]h0]h1]h2]h4]uh6K¦h]r³(cdocutils.nodes emphasis r´)rµ}r¶(h$X *unspecified*h-}r·(h/]h0]h1]h2]h4]uh%j®h]r¸h@X unspecifiedr¹…rº}r»(h$Uh%jµubah+Uemphasisr¼ubh@X …r½}r¾(h$X h%j®ubhë)r¿}rÀ(h$X'``source(std::string const & source_)``h-}rÁ(h/]h0]h1]h2]h4]uh%j®h]rÂh@X#source(std::string const & source_)rÃ…rÄ}rÅ(h$Uh%j¿ubah+hóubeubcdocutils.nodes definition rÆ)rÇ}rÈ(h$Uh-}rÉ(h/]h0]h1]h2]h4]uh%j¨h]rÊhD)rË}rÌ(h$XhCreate a source directive with a ``std::string`` as a parameter, to be set as the source of the request.h%jÇh&h)h+hGh-}rÍ(h/]h0]h1]h2]h4]uh6K¦h]rÎ(h@X!Create a source directive with a rÏ…rÐ}rÑ(h$X!Create a source directive with a h%jËubhë)rÒ}rÓ(h$X``std::string``h-}rÔ(h/]h0]h1]h2]h4]uh%jËh]rÕh@X std::stringrÖ…r×}rØ(h$Uh%jÒubah+hóubh@X8 as a parameter, to be set as the source of the request.rÙ…rÚ}rÛ(h$X8 as a parameter, to be set as the source of the request.h%jËubeubah+U definitionrÜubeubj§)rÝ}rÞ(h$X *unspecified* ``source(std::wstring const & source_)`` Create a source directive with a ``std::wstring`` as a parameter, to be set as the source of the request.h%j¢h&h)h+jªh-}rß(h/]h0]h1]h2]h4]uh6K©h7hh]rà(j­)rá}râ(h$X6*unspecified* ``source(std::wstring const & source_)``rãh%jÝh&h)h+j±h-}rä(h/]h0]h1]h2]h4]uh6K©h]rå(j´)ræ}rç(h$X *unspecified*h-}rè(h/]h0]h1]h2]h4]uh%jáh]réh@X unspecifiedrê…rë}rì(h$Uh%jæubah+j¼ubh@X …rí}rî(h$X h%jáubhë)rï}rð(h$X(``source(std::wstring const & source_)``h-}rñ(h/]h0]h1]h2]h4]uh%jáh]ròh@X$source(std::wstring const & source_)ró…rô}rõ(h$Uh%jïubah+hóubeubjÆ)rö}r÷(h$Uh-}rø(h/]h0]h1]h2]h4]uh%jÝh]rùhD)rú}rû(h$XiCreate a source directive with a ``std::wstring`` as a parameter, to be set as the source of the request.h%jöh&h)h+hGh-}rü(h/]h0]h1]h2]h4]uh6K©h]rý(h@X!Create a source directive with a rþ…rÿ}r(h$X!Create a source directive with a h%júubhë)r}r(h$X``std::wstring``h-}r(h/]h0]h1]h2]h4]uh%júh]rh@X std::wstringr…r}r(h$Uh%jubah+hóubh@X8 as a parameter, to be set as the source of the request.r…r }r (h$X8 as a parameter, to be set as the source of the request.h%júubeubah+jÜubeubj§)r }r (h$X­*unspecified* ``destination(std::string const & source_)`` Create a destination directive with a ``std::string`` as a parameter, to be set as the destination of the request.h%j¢h&h)h+jªh-}r (h/]h0]h1]h2]h4]uh6K¬h7hh]r(j­)r}r(h$X:*unspecified* ``destination(std::string const & source_)``rh%j h&h)h+j±h-}r(h/]h0]h1]h2]h4]uh6K¬h]r(j´)r}r(h$X *unspecified*h-}r(h/]h0]h1]h2]h4]uh%jh]rh@X unspecifiedr…r}r(h$Uh%jubah+j¼ubh@X …r}r(h$X h%jubhë)r}r(h$X,``destination(std::string const & source_)``h-}r(h/]h0]h1]h2]h4]uh%jh]r h@X(destination(std::string const & source_)r!…r"}r#(h$Uh%jubah+hóubeubjÆ)r$}r%(h$Uh-}r&(h/]h0]h1]h2]h4]uh%j h]r'hD)r(}r)(h$XrCreate a destination directive with a ``std::string`` as a parameter, to be set as the destination of the request.h%j$h&h)h+hGh-}r*(h/]h0]h1]h2]h4]uh6K¬h]r+(h@X&Create a destination directive with a r,…r-}r.(h$X&Create a destination directive with a h%j(ubhë)r/}r0(h$X``std::string``h-}r1(h/]h0]h1]h2]h4]uh%j(h]r2h@X std::stringr3…r4}r5(h$Uh%j/ubah+hóubh@X= as a parameter, to be set as the destination of the request.r6…r7}r8(h$X= as a parameter, to be set as the destination of the request.h%j(ubeubah+jÜubeubj§)r9}r:(h$X¯*unspecified* ``destination(std::wstring const & source_)`` Create a destination directive with a ``std::wstring`` as a parameter, to be set as the destination of the request.h%j¢h&h)h+jªh-}r;(h/]h0]h1]h2]h4]uh6K¯h7hh]r<(j­)r=}r>(h$X;*unspecified* ``destination(std::wstring const & source_)``r?h%j9h&h)h+j±h-}r@(h/]h0]h1]h2]h4]uh6K¯h]rA(j´)rB}rC(h$X *unspecified*h-}rD(h/]h0]h1]h2]h4]uh%j=h]rEh@X unspecifiedrF…rG}rH(h$Uh%jBubah+j¼ubh@X …rI}rJ(h$X h%j=ubhë)rK}rL(h$X-``destination(std::wstring const & source_)``h-}rM(h/]h0]h1]h2]h4]uh%j=h]rNh@X)destination(std::wstring const & source_)rO…rP}rQ(h$Uh%jKubah+hóubeubjÆ)rR}rS(h$Uh-}rT(h/]h0]h1]h2]h4]uh%j9h]rUhD)rV}rW(h$XsCreate a destination directive with a ``std::wstring`` as a parameter, to be set as the destination of the request.h%jRh&h)h+hGh-}rX(h/]h0]h1]h2]h4]uh6K¯h]rY(h@X&Create a destination directive with a rZ…r[}r\(h$X&Create a destination directive with a h%jVubhë)r]}r^(h$X``std::wstring``h-}r_(h/]h0]h1]h2]h4]uh%jVh]r`h@X std::wstringra…rb}rc(h$Uh%j]ubah+hóubh@X= as a parameter, to be set as the destination of the request.rd…re}rf(h$X= as a parameter, to be set as the destination of the request.h%jVubeubah+jÜubeubj§)rg}rh(h$X*unspecified* ``header(std::string const & name, std::string const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::string``.h%j¢h&h)h+jªh-}ri(h/]h0]h1]h2]h4]uh6K³h7hh]rj(j­)rk}rl(h$XM*unspecified* ``header(std::string const & name, std::string const & value)``rmh%jgh&h)h+j±h-}rn(h/]h0]h1]h2]h4]uh6K³h]ro(j´)rp}rq(h$X *unspecified*h-}rr(h/]h0]h1]h2]h4]uh%jkh]rsh@X unspecifiedrt…ru}rv(h$Uh%jpubah+j¼ubh@X …rw}rx(h$X h%jkubhë)ry}rz(h$X?``header(std::string const & name, std::string const & value)``h-}r{(h/]h0]h1]h2]h4]uh%jkh]r|h@X;header(std::string const & name, std::string const & value)r}…r~}r(h$Uh%jyubah+hóubeubjÆ)r€}r(h$Uh-}r‚(h/]h0]h1]h2]h4]uh%jgh]rƒhD)r„}r…(h$X´Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::string``.h%j€h&h)h+hGh-}r†(h/]h0]h1]h2]h4]uh6K²h]r‡(h@X¤Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both rˆ…r‰}rŠ(h$X¤Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both h%j„ubhë)r‹}rŒ(h$X``std::string``h-}r(h/]h0]h1]h2]h4]uh%j„h]rŽh@X std::stringr…r}r‘(h$Uh%j‹ubah+hóubh@X.…r’}r“(h$X.h%j„ubeubah+jÜubeubj§)r”}r•(h$X*unspecified* ``header(std::wstring const & name, std::wstring const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::wstring``.h%j¢h&h)h+jªh-}r–(h/]h0]h1]h2]h4]uh6K·h7hh]r—(j­)r˜}r™(h$XO*unspecified* ``header(std::wstring const & name, std::wstring const & value)``ršh%j”h&h)h+j±h-}r›(h/]h0]h1]h2]h4]uh6K·h]rœ(j´)r}rž(h$X *unspecified*h-}rŸ(h/]h0]h1]h2]h4]uh%j˜h]r h@X unspecifiedr¡…r¢}r£(h$Uh%jubah+j¼ubh@X …r¤}r¥(h$X h%j˜ubhë)r¦}r§(h$XA``header(std::wstring const & name, std::wstring const & value)``h-}r¨(h/]h0]h1]h2]h4]uh%j˜h]r©h@X=header(std::wstring const & name, std::wstring const & value)rª…r«}r¬(h$Uh%j¦ubah+hóubeubjÆ)r­}r®(h$Uh-}r¯(h/]h0]h1]h2]h4]uh%j”h]r°hD)r±}r²(h$XµCreate a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::wstring``.h%j­h&h)h+hGh-}r³(h/]h0]h1]h2]h4]uh6K¶h]r´(h@X¤Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both rµ…r¶}r·(h$X¤Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both h%j±ubhë)r¸}r¹(h$X``std::wstring``h-}rº(h/]h0]h1]h2]h4]uh%j±h]r»h@X std::wstringr¼…r½}r¾(h$Uh%j¸ubah+hóubh@X.…r¿}rÀ(h$X.h%j±ubeubah+jÜubeubj§)rÁ}rÂ(h$X*unspecified* ``remove_header(std::string const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::string``.h%j¢h&h)h+jªh-}rÃ(h/]h0]h1]h2]h4]uh6K»h7hh]rÄ(j­)rÅ}rÆ(h$X9*unspecified* ``remove_header(std::string const & name)``rÇh%jÁh&h)h+j±h-}rÈ(h/]h0]h1]h2]h4]uh6K»h]rÉ(j´)rÊ}rË(h$X *unspecified*h-}rÌ(h/]h0]h1]h2]h4]uh%jÅh]rÍh@X unspecifiedrÎ…rÏ}rÐ(h$Uh%jÊubah+j¼ubh@X …rÑ}rÒ(h$X h%jÅubhë)rÓ}rÔ(h$X+``remove_header(std::string const & name)``h-}rÕ(h/]h0]h1]h2]h4]uh%jÅh]rÖh@X'remove_header(std::string const & name)r×…rØ}rÙ(h$Uh%jÓubah+hóubeubjÆ)rÚ}rÛ(h$Uh-}rÜ(h/]h0]h1]h2]h4]uh%jÁh]rÝhD)rÞ}rß(h$XÌCreate a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::string``.h%jÚh&h)h+hGh-}rà(h/]h0]h1]h2]h4]uh6Kºh]rá(h@X¼Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type râ…rã}rä(h$X¼Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type h%jÞubhë)rå}ræ(h$X``std::string``h-}rç(h/]h0]h1]h2]h4]uh%jÞh]rèh@X std::stringré…rê}rë(h$Uh%jåubah+hóubh@X.…rì}rí(h$X.h%jÞubeubah+jÜubeubj§)rî}rï(h$X*unspecified* ``remove_header(std::wstring const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::wstring``.h%j¢h&h)h+jªh-}rð(h/]h0]h1]h2]h4]uh6K¿h7hh]rñ(j­)rò}ró(h$X:*unspecified* ``remove_header(std::wstring const & name)``rôh%jîh&h)h+j±h-}rõ(h/]h0]h1]h2]h4]uh6K¿h]rö(j´)r÷}rø(h$X *unspecified*h-}rù(h/]h0]h1]h2]h4]uh%jòh]rúh@X unspecifiedrû…rü}rý(h$Uh%j÷ubah+j¼ubh@X …rþ}rÿ(h$X h%jòubhë)r }r (h$X,``remove_header(std::wstring const & name)``h-}r (h/]h0]h1]h2]h4]uh%jòh]r h@X(remove_header(std::wstring const & name)r …r }r (h$Uh%j ubah+hóubeubjÆ)r }r (h$Uh-}r (h/]h0]h1]h2]h4]uh%jîh]r hD)r }r (h$XÍCreate a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::wstring``.h%j h&h)h+hGh-}r (h/]h0]h1]h2]h4]uh6K¾h]r (h@X¼Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type r …r }r (h$X¼Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type h%j ubhë)r }r (h$X``std::wstring``h-}r (h/]h0]h1]h2]h4]uh%j h]r h@X std::wstringr …r }r (h$Uh%j ubah+hóubh@X.…r }r (h$X.h%j ubeubah+jÜubeubj§)r }r (h$X»*unspecified* ``body(std::string const & body_)`` Create a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::string``.h%j¢h&h)h+jªh-}r (h/]h0]h1]h2]h4]uh6KÂh7hh]r (j­)r }r (h$X1*unspecified* ``body(std::string const & body_)``r! h%j h&h)h+j±h-}r" (h/]h0]h1]h2]h4]uh6KÂh]r# (j´)r$ }r% (h$X *unspecified*h-}r& (h/]h0]h1]h2]h4]uh%j h]r' h@X unspecifiedr( …r) }r* (h$Uh%j$ ubah+j¼ubh@X …r+ }r, (h$X h%j ubhë)r- }r. (h$X#``body(std::string const & body_)``h-}r/ (h/]h0]h1]h2]h4]uh%j h]r0 h@Xbody(std::string const & body_)r1 …r2 }r3 (h$Uh%j- ubah+hóubeubjÆ)r4 }r5 (h$Uh-}r6 (h/]h0]h1]h2]h4]uh%j h]r7 hD)r8 }r9 (h$X‰Create a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::string``.h%j4 h&h)h+hGh-}r: (h/]h0]h1]h2]h4]uh6KÂh]r; (h@XyCreate a body directive that will set the request's body to the given parameter. In this case the type of the body is an r< …r= }r> (h$XyCreate a body directive that will set the request's body to the given parameter. In this case the type of the body is an h%j8 ubhë)r? }r@ (h$X``std::string``h-}rA (h/]h0]h1]h2]h4]uh%j8 h]rB h@X std::stringrC …rD }rE (h$Uh%j? ubah+hóubh@X.…rF }rG (h$X.h%j8 ubeubah+jÜubeubj§)rH }rI (h$X¾*unspecified* ``body(std::wstring const & body_)`` Create a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::wstring``. h%j¢h&h)h+jªh-}rJ (h/]h0]h1]h2]h4]uh6KÆh7hh]rK (j­)rL }rM (h$X2*unspecified* ``body(std::wstring const & body_)``rN h%jH h&h)h+j±h-}rO (h/]h0]h1]h2]h4]uh6KÆh]rP (j´)rQ }rR (h$X *unspecified*h-}rS (h/]h0]h1]h2]h4]uh%jL h]rT h@X unspecifiedrU …rV }rW (h$Uh%jQ ubah+j¼ubh@X …rX }rY (h$X h%jL ubhë)rZ }r[ (h$X$``body(std::wstring const & body_)``h-}r\ (h/]h0]h1]h2]h4]uh%jL h]r] h@X body(std::wstring const & body_)r^ …r_ }r` (h$Uh%jZ ubah+hóubeubjÆ)ra }rb (h$Uh-}rc (h/]h0]h1]h2]h4]uh%jH h]rd hD)re }rf (h$XŠCreate a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::wstring``.h%ja h&h)h+hGh-}rg (h/]h0]h1]h2]h4]uh6KÅh]rh (h@XyCreate a body directive that will set the request's body to the given parameter. In this case the type of the body is an ri …rj }rk (h$XyCreate a body directive that will set the request's body to the given parameter. In this case the type of the body is an h%je ubhë)rl }rm (h$X``std::wstring``h-}rn (h/]h0]h1]h2]h4]uh%je h]ro h@X std::wstringrp …rq }rr (h$Uh%jl ubah+hóubh@X.…rs }rt (h$X.h%je ubeubah+jÜubeubeubeubh!)ru }rv (h$Uh{Kh%h"h&h)h+h,h-}rw (h/]h0]h1]h2]rx hah4]ry hauh6KÉh7hh]rz (h9)r{ }r| (h$X Modifiersr} h%ju h&h)h+h=h-}r~ (h/]h0]h1]h2]h4]uh6KÉh7hh]r h@X Modifiersr€ …r }r‚ (h$j} h%j{ ubaubhD)rƒ }r„ (h$XSThis section details the provided modifiers that are provided by :mod:`cpp-netlib`.h%ju h&h)h+hGh-}r… (h/]h0]h1]h2]h4]uh6KËh7hh]r† (h@XAThis section details the provided modifiers that are provided by r‡ …rˆ }r‰ (h$XAThis section details the provided modifiers that are provided by h%jƒ ubj )rŠ }r‹ (h$X:mod:`cpp-netlib`rŒ h%jƒ h&h)h+j$h-}r (UreftypeXmodj&‰j'X cpp-netlibU refdomainXpyrŽ h2]h1]U refexplicit‰h/]h0]h4]j)j*j+Nj,Nuh6KËh]r hë)r }r‘ (h$jŒ h-}r’ (h/]h0]r“ (j2jŽ Xpy-modr” eh1]h2]h4]uh%jŠ h]r• h@X cpp-netlibr– …r— }r˜ (h$Uh%j ubah+hóubaubh@X.…r™ }rš (h$X.h%jƒ ubeubj¡)r› }rœ (h$Uh%ju h&h)h+j¤h-}r (h/]h0]h1]h2]h4]uh6Nh7hh]rž (j§)rŸ }r  (h$Xü``template inline void source(basic_request & request, typename string::type const & source_)`` Modifies the source of the given ``request``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_request``.h%j› h&h)h+jªh-}r¡ (h/]h0]h1]h2]h4]uh6KÏh]r¢ (j­)r£ }r¤ (h$Xu``template inline void source(basic_request & request, typename string::type const & source_)``r¥ h%jŸ h&h)h+j±h-}r¦ (h/]h0]h1]h2]h4]uh6KÏh]r§ hë)r¨ }r© (h$j¥ h-}rª (h/]h0]h1]h2]h4]uh%j£ h]r« h@Xqtemplate inline void source(basic_request & request, typename string::type const & source_)r¬ …r­ }r® (h$Uh%j¨ ubah+hóubaubjÆ)r¯ }r° (h$Uh-}r± (h/]h0]h1]h2]h4]uh%jŸ h]r² hD)r³ }r´ (h$X†Modifies the source of the given ``request``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_request``.h%j¯ h&h)h+hGh-}rµ (h/]h0]h1]h2]h4]uh6KÏh]r¶ (h@X!Modifies the source of the given r· …r¸ }r¹ (h$X!Modifies the source of the given h%j³ ubhë)rº }r» (h$X ``request``h-}r¼ (h/]h0]h1]h2]h4]uh%j³ h]r½ h@Xrequestr¾ …r¿ }rÀ (h$Uh%jº ubah+hóubh@X. The type of rÁ …r }rà (h$X. The type of h%j³ ubhë)rÄ }rÅ (h$X ``source_``h-}rÆ (h/]h0]h1]h2]h4]uh%j³ h]rÇ h@Xsource_rÈ …rÉ }rÊ (h$Uh%jÄ ubah+hóubh@X is dependent on the rË …rÌ }rÍ (h$X is dependent on the h%j³ ubhë)rÎ }rÏ (h$X``Tag``h-}rÐ (h/]h0]h1]h2]h4]uh%j³ h]rÑ h@XTagrÒ …rÓ }rÔ (h$Uh%jÎ ubah+hóubh@X specialization of rÕ …rÖ }r× (h$X specialization of h%j³ ubhë)rØ }rÙ (h$X``basic_request``h-}rÚ (h/]h0]h1]h2]h4]uh%j³ h]rÛ h@X basic_requestrÜ …rÝ }rÞ (h$Uh%jØ ubah+hóubh@X.…rß }rà (h$X.h%j³ ubeubah+jÜubeubj§)rá }râ (h$X``template inline void destination(basic_request & request, typename string::type const & destination_)`` Modifies the destination of the given ``request``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_request``.h%j› h&h)h+jªh-}rã (h/]h0]h1]h2]h4]uh6KÒh7hh]rä (j­)rå }ræ (h$X``template inline void destination(basic_request & request, typename string::type const & destination_)``rç h%já h&h)h+j±h-}rè (h/]h0]h1]h2]h4]uh6KÒh]ré hë)rê }rë (h$jç h-}rì (h/]h0]h1]h2]h4]uh%jå h]rí h@X{template inline void destination(basic_request & request, typename string::type const & destination_)rî …rï }rð (h$Uh%jê ubah+hóubaubjÆ)rñ }rò (h$Uh-}ró (h/]h0]h1]h2]h4]uh%já h]rô hD)rõ }rö (h$XModifies the destination of the given ``request``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_request``.h%jñ h&h)h+hGh-}r÷ (h/]h0]h1]h2]h4]uh6KÒh]rø (h@X&Modifies the destination of the given rù …rú }rû (h$X&Modifies the destination of the given h%jõ ubhë)rü }rý (h$X ``request``h-}rþ (h/]h0]h1]h2]h4]uh%jõ h]rÿ h@Xrequestr …r }r (h$Uh%jü ubah+hóubh@X. The type of r …r }r (h$X. The type of h%jõ ubhë)r }r (h$X``destination_``h-}r (h/]h0]h1]h2]h4]uh%jõ h]r h@X destination_r …r }r (h$Uh%j ubah+hóubh@X is dependent on the r …r }r (h$X is dependent on the h%jõ ubhë)r }r (h$X``Tag``h-}r (h/]h0]h1]h2]h4]uh%jõ h]r h@XTagr …r }r (h$Uh%j ubah+hóubh@X specialization of r …r }r (h$X specialization of h%jõ ubhë)r }r (h$X``basic_request``h-}r (h/]h0]h1]h2]h4]uh%jõ h]r h@X basic_requestr …r }r (h$Uh%j ubah+hóubh@X.…r! }r" (h$X.h%jõ ubeubah+jÜubeubj§)r# }r$ (h$X<``template inline void add_header(basic_request & request, typename string::type const & name, typename string::type const & value)`` Adds a header to the given ``request``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_request``.h%j› h&h)h+jªh-}r% (h/]h0]h1]h2]h4]uh6KÖh7hh]r& (j­)r' }r( (h$X ``template inline void add_header(basic_request & request, typename string::type const & name, typename string::type const & value)``r) h%j# h&h)h+j±h-}r* (h/]h0]h1]h2]h4]uh6KÖh]r+ hë)r, }r- (h$j) h-}r. (h/]h0]h1]h2]h4]uh%j' h]r/ h@Xœtemplate inline void add_header(basic_request & request, typename string::type const & name, typename string::type const & value)r0 …r1 }r2 (h$Uh%j, ubah+hóubaubjÆ)r3 }r4 (h$Uh-}r5 (h/]h0]h1]h2]h4]uh%j# h]r6 hD)r7 }r8 (h$X›Adds a header to the given ``request``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_request``.h%j3 h&h)h+hGh-}r9 (h/]h0]h1]h2]h4]uh6KÕh]r: (h@XAdds a header to the given r; …r< }r= (h$XAdds a header to the given h%j7 ubhë)r> }r? (h$X ``request``h-}r@ (h/]h0]h1]h2]h4]uh%j7 h]rA h@XrequestrB …rC }rD (h$Uh%j> ubah+hóubh@X. The type of the rE …rF }rG (h$X. The type of the h%j7 ubhë)rH }rI (h$X``name``h-}rJ (h/]h0]h1]h2]h4]uh%j7 h]rK h@XnamerL …rM }rN (h$Uh%jH ubah+hóubh@X and rO …rP }rQ (h$X and h%j7 ubhë)rR }rS (h$X ``value``h-}rT (h/]h0]h1]h2]h4]uh%j7 h]rU h@XvaluerV …rW }rX (h$Uh%jR ubah+hóubh@X! parameters are dependent on the rY …rZ }r[ (h$X! parameters are dependent on the h%j7 ubhë)r\ }r] (h$X``Tag``h-}r^ (h/]h0]h1]h2]h4]uh%j7 h]r_ h@XTagr` …ra }rb (h$Uh%j\ ubah+hóubh@X specialization of rc …rd }re (h$X specialization of h%j7 ubhë)rf }rg (h$X``basic_request``h-}rh (h/]h0]h1]h2]h4]uh%j7 h]ri h@X basic_requestrj …rk }rl (h$Uh%jf ubah+hóubh@X.…rm }rn (h$X.h%j7 ubeubah+jÜubeubj§)ro }rp (h$X ``template inline void remove_header(basic_request & request, typename string::type const & name)`` Removes a header from the given ``request``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_request``.h%j› h&h)h+jªh-}rq (h/]h0]h1]h2]h4]uh6KÙh7hh]rr (j­)rs }rt (h$Xy``template inline void remove_header(basic_request & request, typename string::type const & name)``ru h%jo h&h)h+j±h-}rv (h/]h0]h1]h2]h4]uh6KÙh]rw hë)rx }ry (h$ju h-}rz (h/]h0]h1]h2]h4]uh%js h]r{ h@Xutemplate inline void remove_header(basic_request & request, typename string::type const & name)r| …r} }r~ (h$Uh%jx ubah+hóubaubjÆ)r }r€ (h$Uh-}r (h/]h0]h1]h2]h4]uh%jo h]r‚ hD)rƒ }r„ (h$XRemoves a header from the given ``request``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_request``.h%j h&h)h+hGh-}r… (h/]h0]h1]h2]h4]uh6KÙh]r† (h@X Removes a header from the given r‡ …rˆ }r‰ (h$X Removes a header from the given h%jƒ ubhë)rŠ }r‹ (h$X ``request``h-}rŒ (h/]h0]h1]h2]h4]uh%jƒ h]r h@XrequestrŽ …r }r (h$Uh%jŠ ubah+hóubh@X. The type of the r‘ …r’ }r“ (h$X. The type of the h%jƒ ubhë)r” }r• (h$X``name``h-}r– (h/]h0]h1]h2]h4]uh%jƒ h]r— h@Xnamer˜ …r™ }rš (h$Uh%j” ubah+hóubh@X parameter is dependent on the r› …rœ }r (h$X parameter is dependent on the h%jƒ ubhë)rž }rŸ (h$X``Tag``h-}r  (h/]h0]h1]h2]h4]uh%jƒ h]r¡ h@XTagr¢ …r£ }r¤ (h$Uh%jž ubah+hóubh@X specialization of r¥ …r¦ }r§ (h$X specialization of h%jƒ ubhë)r¨ }r© (h$X``basic_request``h-}rª (h/]h0]h1]h2]h4]uh%jƒ h]r« h@X basic_requestr¬ …r­ }r® (h$Uh%j¨ ubah+hóubh@X.…r¯ }r° (h$X.h%jƒ ubeubah+jÜubeubj§)r± }r² (h$X€``template inline void clear_headers(basic_request & request)`` Removes all headers from the given ``request``.h%j› h&h)h+jªh-}r³ (h/]h0]h1]h2]h4]uh6KÛh7hh]r´ (j­)rµ }r¶ (h$XP``template inline void clear_headers(basic_request & request)``r· h%j± h&h)h+j±h-}r¸ (h/]h0]h1]h2]h4]uh6KÛh]r¹ hë)rº }r» (h$j· h-}r¼ (h/]h0]h1]h2]h4]uh%jµ h]r½ h@XLtemplate inline void clear_headers(basic_request & request)r¾ …r¿ }rÀ (h$Uh%jº ubah+hóubaubjÆ)rÁ }r (h$Uh-}rà (h/]h0]h1]h2]h4]uh%j± h]rÄ hD)rÅ }rÆ (h$X/Removes all headers from the given ``request``.h%jÁ h&h)h+hGh-}rÇ (h/]h0]h1]h2]h4]uh6KÜh]rÈ (h@X#Removes all headers from the given rÉ …rÊ }rË (h$X#Removes all headers from the given h%jÅ ubhë)rÌ }rÍ (h$X ``request``h-}rÎ (h/]h0]h1]h2]h4]uh%jÅ h]rÏ h@XrequestrÐ …rÑ }rÒ (h$Uh%jÌ ubah+hóubh@X.…rÓ }rÔ (h$X.h%jÅ ubeubah+jÜubeubj§)rÕ }rÖ (h$Xõ``template inline void body(basic_request & request, typename string::type const & body_)`` Modifies the body of the given ``request``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_request``. h%j› h&h)h+jªh-}r× (h/]h0]h1]h2]h4]uh6Kßh7hh]rØ (j­)rÙ }rÚ (h$Xq``template inline void body(basic_request & request, typename string::type const & body_)``rÛ h%jÕ h&h)h+j±h-}rÜ (h/]h0]h1]h2]h4]uh6Kßh]rÝ hë)rÞ }rß (h$jÛ h-}rà (h/]h0]h1]h2]h4]uh%jÙ h]rá h@Xmtemplate inline void body(basic_request & request, typename string::type const & body_)râ …rã }rä (h$Uh%jÞ ubah+hóubaubjÆ)rå }ræ (h$Uh-}rç (h/]h0]h1]h2]h4]uh%jÕ h]rè hD)ré }rê (h$X‚Modifies the body of the given ``request``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_request``.h%jå h&h)h+hGh-}rë (h/]h0]h1]h2]h4]uh6KÞh]rì (h@XModifies the body of the given rí …rî }rï (h$XModifies the body of the given h%jé ubhë)rð }rñ (h$X ``request``h-}rò (h/]h0]h1]h2]h4]uh%jé h]ró h@Xrequestrô …rõ }rö (h$Uh%jð ubah+hóubh@X. The type of r÷ …rø }rù (h$X. The type of h%jé ubhë)rú }rû (h$X ``body_``h-}rü (h/]h0]h1]h2]h4]uh%jé h]rý h@Xbody_rþ …rÿ }r (h$Uh%jú ubah+hóubh@X is dependent on the r …r }r (h$X is dependent on the h%jé ubhë)r }r (h$X``Tag``h-}r (h/]h0]h1]h2]h4]uh%jé h]r h@XTagr …r }r (h$Uh%j ubah+hóubh@X specialization of r …r }r (h$X specialization of h%jé ubhë)r }r (h$X``basic_request``h-}r (h/]h0]h1]h2]h4]uh%jé h]r h@X basic_requestr …r }r (h$Uh%j ubah+hóubh@X.…r }r (h$X.h%jé ubeubah+jÜubeubeubeubh!)r }r (h$Uh{Kh%h"h&h)h+h,h-}r (h/]h0]h1]h2]r hah4]r hauh6Kâh7hh]r (h9)r }r (h$XWrappersr h%j h&h)h+h=h-}r (h/]h0]h1]h2]h4]uh6Kâh7hh]r! h@XWrappersr" …r# }r$ (h$j h%j ubaubhD)r% }r& (h$X0This section details the provided request wrappers that come with :mod:`cpp-netlib`. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect:h%j h&h)h+hGh-}r' (h/]h0]h1]h2]h4]uh6Käh7hh]r( (h@XBThis section details the provided request wrappers that come with r) …r* }r+ (h$XBThis section details the provided request wrappers that come with h%j% ubj )r, }r- (h$X:mod:`cpp-netlib`r. h%j% h&h)h+j$h-}r/ (UreftypeXmodj&‰j'X cpp-netlibU refdomainXpyr0 h2]h1]U refexplicit‰h/]h0]h4]j)j*j+Nj,Nuh6Käh]r1 hë)r2 }r3 (h$j. h-}r4 (h/]h0]r5 (j2j0 Xpy-modr6 eh1]h2]h4]uh%j, h]r7 h@X cpp-netlibr8 …r9 }r: (h$Uh%j2 ubah+hóubaubh@XÝ. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect:r; …r< }r= (h$XÝ. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect:h%j% ubeubj;)r> }r? (h$XEusing namespace boost::network; using namespace boost::network::http;h%j h&h)h+j>h-}r@ (j@‰jAXc++jBjCh2]h1]h/]h0]h4]uh6Kêh7hh]rA h@XEusing namespace boost::network; using namespace boost::network::http;rB …rC }rD (h$Uh%j> ubaubj¡)rE }rF (h$Uh%j h&h)h+j¤h-}rG (h/]h0]h1]h2]h4]uh6Nh7hh]rH (j§)rI }rJ (h$XÂ``template `` *unspecified* ``source(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the source of a given request.h%jE h&h)h+jªh-}rK (h/]h0]h1]h2]h4]uh6Kðh]rL (j­)rM }rN (h$XU``template `` *unspecified* ``source(basic_request const & request)``rO h%jI h&h)h+j±h-}rP (h/]h0]h1]h2]h4]uh6Kðh]rQ (hë)rR }rS (h$X``template ``h-}rT (h/]h0]h1]h2]h4]uh%jM h]rU h@Xtemplate rV …rW }rX (h$Uh%jR ubah+hóubh@X …rY }rZ (h$X h%jM ubj´)r[ }r\ (h$X *unspecified*h-}r] (h/]h0]h1]h2]h4]uh%jM h]r^ h@X unspecifiedr_ …r` }ra (h$Uh%j[ ubah+j¼ubh@X …rb }rc (h$X h%jM ubhë)rd }re (h$X.``source(basic_request const & request)``h-}rf (h/]h0]h1]h2]h4]uh%jM h]rg h@X*source(basic_request const & request)rh …ri }rj (h$Uh%jd ubah+hóubeubjÆ)rk }rl (h$Uh-}rm (h/]h0]h1]h2]h4]uh%jI h]rn hD)ro }rp (h$XlReturns a wrapper convertible to ``typename string::type`` that provides the source of a given request.h%jk h&h)h+hGh-}rq (h/]h0]h1]h2]h4]uh6Kðh]rr (h@X!Returns a wrapper convertible to rs …rt }ru (h$X!Returns a wrapper convertible to h%jo ubhë)rv }rw (h$X``typename string::type``h-}rx (h/]h0]h1]h2]h4]uh%jo h]ry h@Xtypename string::typerz …r{ }r| (h$Uh%jv ubah+hóubh@X- that provides the source of a given request.r} …r~ }r (h$X- that provides the source of a given request.h%jo ubeubah+jÜubeubj§)r€ }r (h$XÌ``template `` *unspecified* ``destination(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the destination of a given request.h%jE h&h)h+jªh-}r‚ (h/]h0]h1]h2]h4]uh6Kóh7hh]rƒ (j­)r„ }r… (h$XZ``template `` *unspecified* ``destination(basic_request const & request)``r† h%j€ h&h)h+j±h-}r‡ (h/]h0]h1]h2]h4]uh6Kóh]rˆ (hë)r‰ }rŠ (h$X``template ``h-}r‹ (h/]h0]h1]h2]h4]uh%j„ h]rŒ h@Xtemplate r …rŽ }r (h$Uh%j‰ ubah+hóubh@X …r }r‘ (h$X h%j„ ubj´)r’ }r“ (h$X *unspecified*h-}r” (h/]h0]h1]h2]h4]uh%j„ h]r• h@X unspecifiedr– …r— }r˜ (h$Uh%j’ ubah+j¼ubh@X …r™ }rš (h$X h%j„ ubhë)r› }rœ (h$X3``destination(basic_request const & request)``h-}r (h/]h0]h1]h2]h4]uh%j„ h]rž h@X/destination(basic_request const & request)rŸ …r  }r¡ (h$Uh%j› ubah+hóubeubjÆ)r¢ }r£ (h$Uh-}r¤ (h/]h0]h1]h2]h4]uh%j€ h]r¥ hD)r¦ }r§ (h$XqReturns a wrapper convertible to ``typename string::type`` that provides the destination of a given request.h%j¢ h&h)h+hGh-}r¨ (h/]h0]h1]h2]h4]uh6Kóh]r© (h@X!Returns a wrapper convertible to rª …r« }r¬ (h$X!Returns a wrapper convertible to h%j¦ ubhë)r­ }r® (h$X``typename string::type``h-}r¯ (h/]h0]h1]h2]h4]uh%j¦ h]r° h@Xtypename string::typer± …r² }r³ (h$Uh%j­ ubah+hóubh@X2 that provides the destination of a given request.r´ …rµ }r¶ (h$X2 that provides the destination of a given request.h%j¦ ubeubah+jÜubeubj§)r· }r¸ (h$X``template `` *unspecified* ``headers(basic_request const & request)`` Returns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_request::headers_container_type`` that provides the headers of a given request.h%jE h&h)h+jªh-}r¹ (h/]h0]h1]h2]h4]uh6K÷h7hh]rº (j­)r» }r¼ (h$XV``template `` *unspecified* ``headers(basic_request const & request)``r½ h%j· h&h)h+j±h-}r¾ (h/]h0]h1]h2]h4]uh6K÷h]r¿ (hë)rÀ }rÁ (h$X``template ``h-}r (h/]h0]h1]h2]h4]uh%j» h]rà h@Xtemplate rÄ …rÅ }rÆ (h$Uh%jÀ ubah+hóubh@X …rÇ }rÈ (h$X h%j» ubj´)rÉ }rÊ (h$X *unspecified*h-}rË (h/]h0]h1]h2]h4]uh%j» h]rÌ h@X unspecifiedrÍ …rÎ }rÏ (h$Uh%jÉ ubah+j¼ubh@X …rÐ }rÑ (h$X h%j» ubhë)rÒ }rÓ (h$X/``headers(basic_request const & request)``h-}rÔ (h/]h0]h1]h2]h4]uh%j» h]rÕ h@X+headers(basic_request const & request)rÖ …r× }rØ (h$Uh%jÒ ubah+hóubeubjÆ)rÙ }rÚ (h$Uh-}rÛ (h/]h0]h1]h2]h4]uh%j· h]rÜ hD)rÝ }rÞ (h$X¿Returns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_request::headers_container_type`` that provides the headers of a given request.h%jÙ h&h)h+hGh-}rß (h/]h0]h1]h2]h4]uh6Köh]rà (h@X!Returns a wrapper convertible to rá …râ }rã (h$X!Returns a wrapper convertible to h%jÝ ubhë)rä }rå (h$X5``typename headers_range >::type``h-}ræ (h/]h0]h1]h2]h4]uh%jÝ h]rç h@X1typename headers_range >::typerè …ré }rê (h$Uh%jä ubah+hóubh@X or rë …rì }rí (h$X or h%jÝ ubhë)rî }rï (h$X7``typename basic_request::headers_container_type``h-}rð (h/]h0]h1]h2]h4]uh%jÝ h]rñ h@X3typename basic_request::headers_container_typerò …ró }rô (h$Uh%jî ubah+hóubh@X. that provides the headers of a given request.rõ …rö }r÷ (h$X. that provides the headers of a given request.h%jÝ ubeubah+jÜubeubj§)rø }rù (h$X¿``template `` *unspecified* ``body(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the body of a given request. h%jE h&h)h+jªh-}rú (h/]h0]h1]h2]h4]uh6Kûh7hh]rû (j­)rü }rý (h$XS``template `` *unspecified* ``body(basic_request const & request)``rþ h%jø h&h)h+j±h-}rÿ (h/]h0]h1]h2]h4]uh6Kûh]r (hë)r }r (h$X``template ``h-}r (h/]h0]h1]h2]h4]uh%jü h]r h@Xtemplate r …r }r (h$Uh%j ubah+hóubh@X …r }r (h$X h%jü ubj´)r }r (h$X *unspecified*h-}r (h/]h0]h1]h2]h4]uh%jü h]r h@X unspecifiedr …r }r (h$Uh%j ubah+j¼ubh@X …r }r (h$X h%jü ubhë)r }r (h$X,``body(basic_request const & request)``h-}r (h/]h0]h1]h2]h4]uh%jü h]r h@X(body(basic_request const & request)r …r }r (h$Uh%j ubah+hóubeubjÆ)r }r (h$Uh-}r (h/]h0]h1]h2]h4]uh%jø h]r hD)r }r (h$XjReturns a wrapper convertible to ``typename string::type`` that provides the body of a given request.h%j h&h)h+hGh-}r (h/]h0]h1]h2]h4]uh6Kúh]r! (h@X!Returns a wrapper convertible to r" …r# }r$ (h$X!Returns a wrapper convertible to h%j ubhë)r% }r& (h$X``typename string::type``h-}r' (h/]h0]h1]h2]h4]uh%j h]r( h@Xtypename string::typer) …r* }r+ (h$Uh%j% ubah+hóubh@X+ that provides the body of a given request.r, …r- }r. (h$X+ that provides the body of a given request.h%j ubeubah+jÜubeubeubeubeubah$UU transformerr/ NU footnote_refsr0 }r1 Urefnamesr2 }r3 (Xwrappers]r4 hoaX modifiers]r5 heaXrequest concepts]r6 hNaXmessage concept]r7 (j=j‚eXnormal client request concept]r8 (hh©h×jeXpod server request concept]r9 (h™hºhájeX directives]r: h[auUsymbol_footnotesr; ]r< Uautofootnote_refsr= ]r> Usymbol_footnote_refsr? ]r@ U citationsrA ]rB h7hU current_linerC NUtransform_messagesrD ]rE UreporterrF NUid_startrG KU autofootnotesrH ]rI U citation_refsrJ }rK Uindirect_targetsrL ]rM UsettingsrN (cdocutils.frontend Values rO orP }rQ (Ufootnote_backlinksrR KUrecord_dependenciesrS NU rfc_base_urlrT Uhttp://tools.ietf.org/html/rU U tracebackrV ˆUpep_referencesrW NUstrip_commentsrX NU toc_backlinksrY jU language_coderZ Uenr[ U datestampr\ NU report_levelr] KU _destinationr^ NU halt_levelr_ KU strip_classesr` Nh=NUerror_encoding_error_handlerra Ubackslashreplacerb Udebugrc NUembed_stylesheetrd ‰Uoutput_encoding_error_handlerre Ustrictrf U sectnum_xformrg KUdump_transformsrh NU docinfo_xformri KUwarning_streamrj NUpep_file_url_templaterk Upep-%04drl Uexit_status_levelrm KUconfigrn NUstrict_visitorro NUcloak_email_addressesrp ˆUtrim_footnote_reference_spacerq ‰Uenvrr NUdump_pseudo_xmlrs NUexpose_internalsrt NUsectsubtitle_xformru ‰U source_linkrv NUrfc_referencesrw NUoutput_encodingrx Uutf-8ry U source_urlrz NUinput_encodingr{ Uutf-8r| U_disable_configr} NU id_prefixr~ UU tab_widthr KUerror_encodingr€ UUS-ASCIIr U_sourcer‚ UL/Users/dean/Documents/cpp-netlib/libs/network/doc/reference/http_request.rstrƒ Ugettext_compactr„ ˆU generatorr… NUdump_internalsr† NU smart_quotesr‡ ‰U pep_base_urlrˆ Uhttp://www.python.org/dev/peps/r‰ Usyntax_highlightrŠ Ulongr‹ Uinput_encoding_error_handlerrŒ jf Uauto_id_prefixr UidrŽ Udoctitle_xformr ‰Ustrip_elements_with_classesr NU _config_filesr‘ ]Ufile_insertion_enabledr’ ˆU raw_enabledr“ KU dump_settingsr” NubUsymbol_footnote_startr• KUidsr– }r— (hj hj(hju hj hh"hjmhhyhjuUsubstitution_namesr˜ }r™ h+h7h-}rš (h/]h2]h1]Usourceh)h0]h4]uU footnotesr› ]rœ Urefidsr }rž ub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/reference/http_response.doctree000066400000000000000000003671231240331347200324260ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(XwrappersqNX modifiersqNXresponse conceptqNXmessage conceptq ˆX directivesq NX http responseq NuUsubstitution_defsq }q Uparse_messagesq]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUwrappersqhU modifiersqhUresponse-conceptqh Umessage-conceptqh U directivesqh U http-responsequUchildrenq]qcdocutils.nodes section q)q}q(U rawsourceq UUparentq!hUsourceq"cdocutils.nodes reprunicode q#XM/Users/dean/Documents/cpp-netlib/libs/network/doc/reference/http_response.rstq$…q%}q&bUtagnameq'Usectionq(U attributesq)}q*(Udupnamesq+]Uclassesq,]Ubackrefsq-]Uidsq.]q/haUnamesq0]q1h auUlineq2KUdocumentq3hh]q4(cdocutils.nodes title q5)q6}q7(h X HTTP Responseq8h!hh"h%h'Utitleq9h)}q:(h+]h,]h-]h.]h0]uh2Kh3hh]q;cdocutils.nodes Text q}q?(h h8h!h6ubaubcdocutils.nodes paragraph q@)qA}qB(h X This part of the documentation talks about the publicly accessible API of the HTTP Response objects. This section details the `Response Concept`_ requirements, the implemented and required Directives_, Modifiers_, and Wrappers_ that work with the HTTP Response objects.h!hh"h%h'U paragraphqCh)}qD(h+]h,]h-]h.]h0]uh2Kh3hh]qE(h(h Xph)}r?(h+]h,]h-]h.]h0]uh!j9h]r@h}r?(h Uh)}r@(h+]h,]h-]h.]h0]uh!j9h]rAh@)rB}rC(h X ConstructrDh!j>h"h%h'hCh)}rE(h+]h,]h-]h.]h0]uh2K*h]rFh::type``r¬h!j¦h"h%h'hCh)}r­(h+]h,]h-]h.]h0]uh2K/h]r®h‚)r¯}r°(h j¬h)}r±(h+]h,]h-]h.]h0]uh!jªh]r²h::typer³…r´}rµ(h Uh!j¯ubah'hŠubaubah'jJubj=)r¶}r·(h Uh)}r¸(h+]h,]h-]h.]h0]uh!j¢h]r¹h@)rº}r»(h X``V``r¼h!j¶h"h%h'hCh)}r½(h+]h,]h-]h.]h0]uh2K/h]r¾h‚)r¿}rÀ(h j¼h)}rÁ(h+]h,]h-]h.]h0]uh!jºh]rÂh::type``rÛh!jÕh"h%h'hCh)}rÜ(h+]h,]h-]h.]h0]uh2K2h]rÝh‚)rÞ}rß(h jÛh)}rà(h+]h,]h-]h.]h0]uh!jÙh]ráh::typerâ…rã}rä(h Uh!jÞubah'hŠubaubah'jJubj=)rå}ræ(h Uh)}rç(h+]h,]h-]h.]h0]uh!jÑh]rèh@)ré}rê(h X``T``rëh!jåh"h%h'hCh)}rì(h+]h,]h-]h.]h0]uh2K2h]ríh‚)rî}rï(h jëh)}rð(h+]h,]h-]h.]h0]uh!jéh]rñh::type``r h!jh"h%h'hCh)}r (h+]h,]h-]h.]h0]uh2K5h]r h‚)r }r(h j h)}r(h+]h,]h-]h.]h0]uh!jh]rh::typer…r}r(h Uh!j ubah'hŠubaubah'jJubj=)r}r(h Uh)}r(h+]h,]h-]h.]h0]uh!jh]rh@)r}r(h X``M``rh!jh"h%h'hCh)}r(h+]h,]h-]h.]h0]uh2K5h]rh‚)r}r(h jh)}r(h+]h,]h-]h.]h0]uh!jh]r h(h+]h,]h-]h.]h0]uh!j7h]r?h}r?(h Uh!j:ubah'hŠubh(h X:mod:`cpp-netlib`r?h!j5h"h%h'U pending_xrefr@h)}rA(UreftypeXmodUrefwarnrB‰U reftargetrCX cpp-netlibU refdomainXpyrDh.]h-]U refexplicit‰h+]h,]h0]UrefdocrEXreference/http_responserFUpy:classrGNU py:modulerHNuh2KSh]rIh‚)rJ}rK(h j?h)}rL(h+]h,]rM(UxrefrNjDXpy-modrOeh-]h.]h0]uh!j=h]rPh response; // or boost::network::http::basic_response< boost::network::http::tags::http_server > response;h!j'h"h%h'U literal_blockrZh)}r[(Ulinenosr\‰Ulanguager]Xc++U xml:spacer^Upreserver_h.]h-]h+]h,]h0]uh2KWh3hh]r`h response; // or boost::network::http::basic_response< boost::network::http::tags::http_server > response;ra…rb}rc(h Uh!jXubaubh@)rd}re(h XWThe section also assumes that there following using namespace declaration is in effect:rfh!j'h"h%h'hCh)}rg(h+]h,]h-]h.]h0]uh2Kch3hh]rhh`` and ``boost::shared_future``). The :mod:`cpp-netlib` implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases. For now all the implemented directives are listed, even if some of them still do not implement things correctly.h!j'h"h%h'Uwarningr…h)}r†(h+]h,]h-]h.]h0]uh2Nh3hh]r‡(h@)rˆ}r‰(h X}There are four versions of directives, those that are applicable to messages that support narrow strings (``std::string``), those that are applicable to messages that support wide strings (``std::wstring``), those that are applicable to messages that support future-wrapped narrow and wide strings (``boost::shared_future`` and ``boost::shared_future``).h!jƒh"h%h'hCh)}rŠ(h+]h,]h-]h.]h0]uh2Kph]r‹(h``h)}r¥(h+]h,]h-]h.]h0]uh!jˆh]r¦hr§…r¨}r©(h Uh!j£ubah'hŠubh``h)}r¯(h+]h,]h-]h.]h0]uh!jˆh]r°hr±…r²}r³(h Uh!j­ubah'hŠubh(h Uh!j8ubah'hŠubh const & source_)`` Create a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response.h!jÙh"h%h'jáh)}rD(h+]h,]h-]h.]h0]uh2K…h3hh]rE(jä)rF}rG(h XK*unspecified* ``source(boost::shared_future const & source_)``rHh!jBh"h%h'jèh)}rI(h+]h,]h-]h.]h0]uh2K…h]rJ(jë)rK}rL(h X *unspecified*h)}rM(h+]h,]h-]h.]h0]uh!jFh]rNh const & source_)``h)}rV(h+]h,]h-]h.]h0]uh!jFh]rWh const & source_)rX…rY}rZ(h Uh!jTubah'hŠubeubjý)r[}r\(h Uh)}r](h+]h,]h-]h.]h0]uh!jBh]r^h@)r_}r`(h XCreate a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response.h!j[h"h%h'hCh)}ra(h+]h,]h-]h.]h0]uh2K…h]rb(h``h)}rh(h+]h,]h-]h.]h0]uh!j_h]rihrj…rk}rl(h Uh!jfubah'hŠubh const & source_)`` Create a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response.h!jÙh"h%h'jáh)}rr(h+]h,]h-]h.]h0]uh2Kˆh3hh]rs(jä)rt}ru(h XL*unspecified* ``source(boost::shared_future const & source_)``rvh!jph"h%h'jèh)}rw(h+]h,]h-]h.]h0]uh2Kˆh]rx(jë)ry}rz(h X *unspecified*h)}r{(h+]h,]h-]h.]h0]uh!jth]r|h``source(boost::shared_future const & source_)``h)}r„(h+]h,]h-]h.]h0]uh!jth]r…h const & source_)r†…r‡}rˆ(h Uh!j‚ubah'hŠubeubjý)r‰}rŠ(h Uh)}r‹(h+]h,]h-]h.]h0]uh!jph]rŒh@)r}rŽ(h X€Create a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response.h!j‰h"h%h'hCh)}r(h+]h,]h-]h.]h0]uh2Kˆh]r(h``h)}r–(h+]h,]h-]h.]h0]uh!jh]r—hr˜…r™}rš(h Uh!j”ubah'hŠubh as a parameter, to be set as the destination of the response.rÉ…rÊ}rË(h X> as a parameter, to be set as the destination of the response.h!j»ubeubah'jubeubjÞ)rÌ}rÍ(h X°*unspecified* ``destination(std::wstring const & source_)`` Create a destination directive with a ``std::wstring`` as a parameter, to be set as the destination of the response.h!jÙh"h%h'jáh)}rÎ(h+]h,]h-]h.]h0]uh2KŽh3hh]rÏ(jä)rÐ}rÑ(h X;*unspecified* ``destination(std::wstring const & source_)``rÒh!jÌh"h%h'jèh)}rÓ(h+]h,]h-]h.]h0]uh2KŽh]rÔ(jë)rÕ}rÖ(h X *unspecified*h)}r×(h+]h,]h-]h.]h0]uh!jÐh]rØh as a parameter, to be set as the destination of the response.r÷…rø}rù(h X> as a parameter, to be set as the destination of the response.h!jéubeubah'jubeubjÞ)rú}rû(h Xß*unspecified* ``destination(boost::shared_future const & destination_)`` Create a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response.h!jÙh"h%h'jáh)}rü(h+]h,]h-]h.]h0]uh2K‘h3hh]rý(jä)rþ}rÿ(h XU*unspecified* ``destination(boost::shared_future const & destination_)``rh!júh"h%h'jèh)}r(h+]h,]h-]h.]h0]uh2K‘h]r(jë)r}r(h X *unspecified*h)}r(h+]h,]h-]h.]h0]uh!jþh]rh const & destination_)``h)}r(h+]h,]h-]h.]h0]uh!jþh]rh const & destination_)r…r}r(h Uh!j ubah'hŠubeubjý)r}r(h Uh)}r(h+]h,]h-]h.]h0]uh!júh]rh@)r}r(h X‰Create a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response.h!jh"h%h'hCh)}r(h+]h,]h-]h.]h0]uh2K‘h]r(h``h)}r (h+]h,]h-]h.]h0]uh!jh]r!hr"…r#}r$(h Uh!jubah'hŠubh as a parameter, to be set as the destination of the response.r%…r&}r'(h X> as a parameter, to be set as the destination of the response.h!jubeubah'jubeubjÞ)r(}r)(h Xá*unspecified* ``destination(boost::shared_future const & destination_)`` Create a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response.h!jÙh"h%h'jáh)}r*(h+]h,]h-]h.]h0]uh2K”h3hh]r+(jä)r,}r-(h XV*unspecified* ``destination(boost::shared_future const & destination_)``r.h!j(h"h%h'jèh)}r/(h+]h,]h-]h.]h0]uh2K”h]r0(jë)r1}r2(h X *unspecified*h)}r3(h+]h,]h-]h.]h0]uh!j,h]r4h const & destination_)``h)}r<(h+]h,]h-]h.]h0]uh!j,h]r=h const & destination_)r>…r?}r@(h Uh!j:ubah'hŠubeubjý)rA}rB(h Uh)}rC(h+]h,]h-]h.]h0]uh!j(h]rDh@)rE}rF(h XŠCreate a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response.h!jAh"h%h'hCh)}rG(h+]h,]h-]h.]h0]uh2K”h]rH(h``h)}rN(h+]h,]h-]h.]h0]uh!jEh]rOhrP…rQ}rR(h Uh!jLubah'hŠubh as a parameter, to be set as the destination of the response.rS…rT}rU(h X> as a parameter, to be set as the destination of the response.h!jEubeubah'jubeubjÞ)rV}rW(h X*unspecified* ``header(std::string const & name, std::string const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the response. In this case the name and values are both ``std::string``.h!jÙh"h%h'jáh)}rX(h+]h,]h-]h.]h0]uh2K˜h3hh]rY(jä)rZ}r[(h XM*unspecified* ``header(std::string const & name, std::string const & value)``r\h!jVh"h%h'jèh)}r](h+]h,]h-]h.]h0]uh2K˜h]r^(jë)r_}r`(h X *unspecified*h)}ra(h+]h,]h-]h.]h0]uh!jZh]rbh(h+]h,]h-]h.]h0]uh2Kªh]r?(jë)r@}rA(h X *unspecified*h)}rB(h+]h,]h-]h.]h0]uh!j;h]rCh const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``.h!jÙh"h%h'jáh)}rf(h+]h,]h-]h.]h0]uh2K­h3hh]rg(jä)rh}ri(h XG*unspecified* ``body(boost::shared_future const & body_)``rjh!jdh"h%h'jèh)}rk(h+]h,]h-]h.]h0]uh2K­h]rl(jë)rm}rn(h X *unspecified*h)}ro(h+]h,]h-]h.]h0]uh!jhh]rph const & body_)``h)}rx(h+]h,]h-]h.]h0]uh!jhh]ryh const & body_)rz…r{}r|(h Uh!jvubah'hŠubeubjý)r}}r~(h Uh)}r(h+]h,]h-]h.]h0]uh!jdh]r€h@)r}r‚(h X Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``.h!j}h"h%h'hCh)}rƒ(h+]h,]h-]h.]h0]uh2K­h]r„(h``h)}rŠ(h+]h,]h-]h.]h0]uh!jh]r‹hrŒ…r}rŽ(h Uh!jˆubah'hŠubh const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``.h!jÙh"h%h'jáh)}r“(h+]h,]h-]h.]h0]uh2K°h3hh]r”(jä)r•}r–(h XH*unspecified* ``body(boost::shared_future const & body_)``r—h!j‘h"h%h'jèh)}r˜(h+]h,]h-]h.]h0]uh2K°h]r™(jë)rš}r›(h X *unspecified*h)}rœ(h+]h,]h-]h.]h0]uh!j•h]rh const & body_)``h)}r¥(h+]h,]h-]h.]h0]uh!j•h]r¦h const & body_)r§…r¨}r©(h Uh!j£ubah'hŠubeubjý)rª}r«(h Uh)}r¬(h+]h,]h-]h.]h0]uh!j‘h]r­h@)r®}r¯(h X¡Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``.h!jªh"h%h'hCh)}r°(h+]h,]h-]h.]h0]uh2K°h]r±(h``h)}r·(h+]h,]h-]h.]h0]uh!j®h]r¸hr¹…rº}r»(h Uh!jµubah'hŠubh const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``. Note that this version includes the full ``"HTTP/"`` string.h!jÙh"h%h'jáh)}r< (h+]h,]h-]h.]h0]uh2K¿h3hh]r= (jä)r> }r? (h XM*unspecified* ``version(boost::shared_future const & version_)``r@ h!j: h"h%h'jèh)}rA (h+]h,]h-]h.]h0]uh2K¿h]rB (jë)rC }rD (h X *unspecified*h)}rE (h+]h,]h-]h.]h0]uh!j> h]rF h ubh‚)rL }rM (h X?``version(boost::shared_future const & version_)``h)}rN (h+]h,]h-]h.]h0]uh!j> h]rO h const & version_)rP …rQ }rR (h Uh!jL ubah'hŠubeubjý)rS }rT (h Uh)}rU (h+]h,]h-]h.]h0]uh!j: h]rV (h@)rW }rX (h X©Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``.h!jS h"h%h'hCh)}rY (h+]h,]h-]h.]h0]uh2K½h]rZ (h``h)}r` (h+]h,]h-]h.]h0]uh!jW h]ra hrb …rc }rd (h Uh!j^ ubah'hŠubh const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``. Note that this version includes the full ``"HTTP/"`` string.h!jÙh"h%h'jáh)}rz (h+]h,]h-]h.]h0]uh2KÄh3hh]r{ (jä)r| }r} (h XN*unspecified* ``version(boost::shared_future const & version_)``r~ h!jx h"h%h'jèh)}r (h+]h,]h-]h.]h0]uh2KÄh]r€ (jë)r }r‚ (h X *unspecified*h)}rƒ (h+]h,]h-]h.]h0]uh!j| h]r„ h const & version_)``h)}rŒ (h+]h,]h-]h.]h0]uh!j| h]r h const & version_)rŽ …r }r (h Uh!jŠ ubah'hŠubeubjý)r‘ }r’ (h Uh)}r“ (h+]h,]h-]h.]h0]uh!jx h]r” (h@)r• }r– (h XªCreate a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``.h!j‘ h"h%h'hCh)}r— (h+]h,]h-]h.]h0]uh2KÂh]r˜ (h``h)}rž (h+]h,]h-]h.]h0]uh!j• h]rŸ hr  …r¡ }r¢ (h Uh!jœ ubah'hŠubh const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``. Note that this status_message includes the full ``"HTTP/"`` string.h!jÙh"h%h'jáh)}r4 (h+]h,]h-]h.]h0]uh2KÓh3hh]r5 (jä)r6 }r7 (h X[*unspecified* ``status_message(boost::shared_future const & status_message_)``r8 h!j2 h"h%h'jèh)}r9 (h+]h,]h-]h.]h0]uh2KÓh]r: (jë)r; }r< (h X *unspecified*h)}r= (h+]h,]h-]h.]h0]uh!j6 h]r> h const & status_message_)``h)}rF (h+]h,]h-]h.]h0]uh!j6 h]rG h const & status_message_)rH …rI }rJ (h Uh!jD ubah'hŠubeubjý)rK }rL (h Uh)}rM (h+]h,]h-]h.]h0]uh!j2 h]rN (h@)rO }rP (h X¾Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``.h!jK h"h%h'hCh)}rQ (h+]h,]h-]h.]h0]uh2KÑh]rR (h``h)}rX (h+]h,]h-]h.]h0]uh!jO h]rY hrZ …r[ }r\ (h Uh!jV ubah'hŠubh const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``. Note that this status_message includes the full ``"HTTP/"`` string.h!jÙh"h%h'jáh)}rr (h+]h,]h-]h.]h0]uh2KØh3hh]rs (jä)rt }ru (h X\*unspecified* ``status_message(boost::shared_future const & status_message_)``rv h!jp h"h%h'jèh)}rw (h+]h,]h-]h.]h0]uh2KØh]rx (jë)ry }rz (h X *unspecified*h)}r{ (h+]h,]h-]h.]h0]uh!jt h]r| h const & status_message_)``h)}r„ (h+]h,]h-]h.]h0]uh!jt h]r… h const & status_message_)r† …r‡ }rˆ (h Uh!j‚ ubah'hŠubeubjý)r‰ }rŠ (h Uh)}r‹ (h+]h,]h-]h.]h0]uh!jp h]rŒ (h@)r }rŽ (h X¿Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``.h!j‰ h"h%h'hCh)}r (h+]h,]h-]h.]h0]uh2KÖh]r (h``h)}r– (h+]h,]h-]h.]h0]uh!j h]r— hr˜ …r™ }rš (h Uh!j” ubah'hŠubh const & status_)`` Create a status directive that will set the response's status to the given parameter. In this case the type of ``status_`` is ``boost::shared_future``. h!jÙh"h%h'jáh)}rç (h+]h,]h-]h.]h0]uh2Kßh3hh]rè (jä)ré }rê (h XO*unspecified* ``status(boost::shared_future const & status_)``rë h!jå h"h%h'jèh)}rì (h+]h,]h-]h.]h0]uh2Kßh]rí (jë)rî }rï (h X *unspecified*h)}rð (h+]h,]h-]h.]h0]uh!jé h]rñ h const & status_)``h)}rù (h+]h,]h-]h.]h0]uh!jé h]rú h const & status_)rû …rü }rý (h Uh!j÷ ubah'hŠubeubjý)rþ }rÿ (h Uh)}r (h+]h,]h-]h.]h0]uh!jå h]r h@)r }r (h X¨Create a status directive that will set the response's status to the given parameter. In this case the type of ``status_`` is ``boost::shared_future``.h!jþ h"h%h'hCh)}r (h+]h,]h-]h.]h0]uh2KÞh]r (h``h)}r (h+]h,]h-]h.]h0]uh!j h]r hr …r }r (h Uh!j ubah'hŠubh }r? (h Uh!j7 ubah'hŠubaubh inline void source(basic_response & response, typename string::type const & source_)`` Modifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}rH (h+]h,]h-]h.]h0]uh2Kèh]rI (jä)rJ }rK (h Xw``template inline void source(basic_response & response, typename string::type const & source_)``rL h!jF h"h%h'jèh)}rM (h+]h,]h-]h.]h0]uh2Kèh]rN h‚)rO }rP (h jL h)}rQ (h+]h,]h-]h.]h0]uh!jJ h]rR h inline void source(basic_response & response, typename string::type const & source_)rS …rT }rU (h Uh!jO ubah'hŠubaubjý)rV }rW (h Uh)}rX (h+]h,]h-]h.]h0]uh!jF h]rY h@)rZ }r[ (h XˆModifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jV h"h%h'hCh)}r\ (h+]h,]h-]h.]h0]uh2Kèh]r] (h inline void source(basic_response & response, boost::shared_future::type> const & source_)`` Modifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}rŠ (h+]h,]h-]h.]h0]uh2Këh3hh]r‹ (jä)rŒ }r (h X``template inline void source(basic_response & response, boost::shared_future::type> const & source_)``rŽ h!jˆ h"h%h'jèh)}r (h+]h,]h-]h.]h0]uh2Këh]r h‚)r‘ }r’ (h jŽ h)}r“ (h+]h,]h-]h.]h0]uh!jŒ h]r” h inline void source(basic_response & response, boost::shared_future::type> const & source_)r• …r– }r— (h Uh!j‘ ubah'hŠubaubjý)r˜ }r™ (h Uh)}rš (h+]h,]h-]h.]h0]uh!jˆ h]r› h@)rœ }r (h XˆModifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!j˜ h"h%h'hCh)}rž (h+]h,]h-]h.]h0]uh2Këh]rŸ (h inline void destination(basic_response & response, typename string::type const & destination_)`` Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}rÌ (h+]h,]h-]h.]h0]uh2Kîh3hh]rÍ (jä)rÎ }rÏ (h X``template inline void destination(basic_response & response, typename string::type const & destination_)``rÐ h!jÊ h"h%h'jèh)}rÑ (h+]h,]h-]h.]h0]uh2Kîh]rÒ h‚)rÓ }rÔ (h jÐ h)}rÕ (h+]h,]h-]h.]h0]uh!jÎ h]rÖ h inline void destination(basic_response & response, typename string::type const & destination_)r× …rØ }rÙ (h Uh!jÓ ubah'hŠubaubjý)rÚ }rÛ (h Uh)}rÜ (h+]h,]h-]h.]h0]uh!jÊ h]rÝ h@)rÞ }rß (h X’Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jÚ h"h%h'hCh)}rà (h+]h,]h-]h.]h0]uh2Kîh]rá (h inline void destination(basic_response & response, boost::shared_future::type> const & destination_)`` Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}r (h+]h,]h-]h.]h0]uh2Kñh3hh]r (jä)r }r (h X—``template inline void destination(basic_response & response, boost::shared_future::type> const & destination_)``r h!j h"h%h'jèh)}r (h+]h,]h-]h.]h0]uh2Kñh]r h‚)r }r (h j h)}r (h+]h,]h-]h.]h0]uh!j h]r h inline void destination(basic_response & response, boost::shared_future::type> const & destination_)r …r }r (h Uh!j ubah'hŠubaubjý)r }r (h Uh)}r (h+]h,]h-]h.]h0]uh!j h]r h@)r }r! (h X’Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!j h"h%h'hCh)}r" (h+]h,]h-]h.]h0]uh2Kñh]r# (h h inline void add_header(basic_response & response, typename string::type const & name, typename string::type const & value)`` Adds a header to the given ``response``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}rP (h+]h,]h-]h.]h0]uh2Kõh3hh]rQ (jä)rR }rS (h X¢``template inline void add_header(basic_response & response, typename string::type const & name, typename string::type const & value)``rT h!jN h"h%h'jèh)}rU (h+]h,]h-]h.]h0]uh2Kõh]rV h‚)rW }rX (h jT h)}rY (h+]h,]h-]h.]h0]uh!jR h]rZ h inline void add_header(basic_response & response, typename string::type const & name, typename string::type const & value)r[ …r\ }r] (h Uh!jW ubah'hŠubaubjý)r^ }r_ (h Uh)}r` (h+]h,]h-]h.]h0]uh!jN h]ra h@)rb }rc (h XAdds a header to the given ``response``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_response``.h!j^ h"h%h'hCh)}rd (h+]h,]h-]h.]h0]uh2Kôh]re (h inline void remove_header(basic_response & response, typename string::type const & name)`` Removes a header from the given ``response``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}rœ (h+]h,]h-]h.]h0]uh2Køh3hh]r (jä)rž }rŸ (h X{``template inline void remove_header(basic_response & response, typename string::type const & name)``r  h!jš h"h%h'jèh)}r¡ (h+]h,]h-]h.]h0]uh2Køh]r¢ h‚)r£ }r¤ (h j  h)}r¥ (h+]h,]h-]h.]h0]uh!jž h]r¦ h inline void remove_header(basic_response & response, typename string::type const & name)r§ …r¨ }r© (h Uh!j£ ubah'hŠubaubjý)rª }r« (h Uh)}r¬ (h+]h,]h-]h.]h0]uh!jš h]r­ h@)r® }r¯ (h X’Removes a header from the given ``response``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_response``.h!jª h"h%h'hCh)}r° (h+]h,]h-]h.]h0]uh2Køh]r± (h inline void headers(basic_response & response, typename headers_container >::type const & headers_)`` Sets the whole headers contained in ``response`` as the given parameter ``headers_``.h!jB h"h%h'jáh)}rÞ (h+]h,]h-]h.]h0]uh2Kûh3hh]rß (jä)rà }rá (h X•``template inline void headers(basic_response & response, typename headers_container >::type const & headers_)``râ h!jÜ h"h%h'jèh)}rã (h+]h,]h-]h.]h0]uh2Kûh]rä h‚)rå }ræ (h jâ h)}rç (h+]h,]h-]h.]h0]uh!jà h]rè h inline void headers(basic_response & response, typename headers_container >::type const & headers_)ré …rê }rë (h Uh!jå ubah'hŠubaubjý)rì }rí (h Uh)}rî (h+]h,]h-]h.]h0]uh!jÜ h]rï h@)rð }rñ (h XUSets the whole headers contained in ``response`` as the given parameter ``headers_``.h!jì h"h%h'hCh)}rò (h+]h,]h-]h.]h0]uh2Kûh]ró (h inline void headers(basic_response & response, boost::shared_future >::type> const & headers_)`` Sets the whole headers contained in ``response`` as the given parameter ``headers_``.h!jB h"h%h'jáh)}r (h+]h,]h-]h.]h0]uh2Kþh3hh]r (jä)r }r (h X«``template inline void headers(basic_response & response, boost::shared_future >::type> const & headers_)``r h!j h"h%h'jèh)}r (h+]h,]h-]h.]h0]uh2Kþh]r h‚)r }r (h j h)}r (h+]h,]h-]h.]h0]uh!j h]r h inline void headers(basic_response & response, boost::shared_future >::type> const & headers_)r …r }r (h Uh!j ubah'hŠubaubjý)r }r (h Uh)}r (h+]h,]h-]h.]h0]uh!j h]r h@)r }r (h XUSets the whole headers contained in ``response`` as the given parameter ``headers_``.h!j h"h%h'hCh)}r (h+]h,]h-]h.]h0]uh2Kþh]r! (h inline void clear_headers(basic_response & response)`` Removes all headers from the given ``response``.h!jB h"h%h'jáh)}r: (h+]h,]h-]h.]h0]uh2Mh3hh]r; (jä)r< }r= (h XR``template inline void clear_headers(basic_response & response)``r> h!j8 h"h%h'jèh)}r? (h+]h,]h-]h.]h0]uh2Mh]r@ h‚)rA }rB (h j> h)}rC (h+]h,]h-]h.]h0]uh!j< h]rD h inline void clear_headers(basic_response & response)rE …rF }rG (h Uh!jA ubah'hŠubaubjý)rH }rI (h Uh)}rJ (h+]h,]h-]h.]h0]uh!j8 h]rK h@)rL }rM (h X0Removes all headers from the given ``response``.h!jH h"h%h'hCh)}rN (h+]h,]h-]h.]h0]uh2Mh]rO (h inline void body(basic_response & response, typename string::type const & body_)`` Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}r^ (h+]h,]h-]h.]h0]uh2Mh3hh]r_ (jä)r` }ra (h Xs``template inline void body(basic_response & response, typename string::type const & body_)``rb h!j\ h"h%h'jèh)}rc (h+]h,]h-]h.]h0]uh2Mh]rd h‚)re }rf (h jb h)}rg (h+]h,]h-]h.]h0]uh!j` h]rh h inline void body(basic_response & response, typename string::type const & body_)ri …rj }rk (h Uh!je ubah'hŠubaubjý)rl }rm (h Uh)}rn (h+]h,]h-]h.]h0]uh!j\ h]ro h@)rp }rq (h X„Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jl h"h%h'hCh)}rr (h+]h,]h-]h.]h0]uh2Mh]rs (h inline void body(basic_response & response, boost::shared_future::type> const & body_)`` Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}r  (h+]h,]h-]h.]h0]uh2Mh3hh]r¡ (jä)r¢ }r£ (h X‰``template inline void body(basic_response & response, boost::shared_future::type> const & body_)``r¤ h!jž h"h%h'jèh)}r¥ (h+]h,]h-]h.]h0]uh2Mh]r¦ h‚)r§ }r¨ (h j¤ h)}r© (h+]h,]h-]h.]h0]uh!j¢ h]rª h inline void body(basic_response & response, boost::shared_future::type> const & body_)r« …r¬ }r­ (h Uh!j§ ubah'hŠubaubjý)r® }r¯ (h Uh)}r° (h+]h,]h-]h.]h0]uh!jž h]r± h@)r² }r³ (h X„Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!j® h"h%h'hCh)}r´ (h+]h,]h-]h.]h0]uh2Mh]rµ (h inline void version(basic_response & response, typename traits::version >::type const & version_)`` Modifies the version of the given ``response``. The type of ``version_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}râ (h+]h,]h-]h.]h0]uh2M h3hh]rã (jä)rä }rå (h X“``template inline void version(basic_response & response, typename traits::version >::type const & version_)``ræ h!jà h"h%h'jèh)}rç (h+]h,]h-]h.]h0]uh2M h]rè h‚)ré }rê (h jæ h)}rë (h+]h,]h-]h.]h0]uh!jä h]rì h inline void version(basic_response & response, typename traits::version >::type const & version_)rí …rî }rï (h Uh!jé ubah'hŠubaubjý)rð }rñ (h Uh)}rò (h+]h,]h-]h.]h0]uh!jà h]ró h@)rô }rõ (h XŠModifies the version of the given ``response``. The type of ``version_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jð h"h%h'hCh)}rö (h+]h,]h-]h.]h0]uh2M h]r÷ (h inline void status(basic_response & response, typename traits::status >::type const & status_)`` Modifies the status of the given ``response``. The type of ``status_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jB h"h%h'jáh)}r$(h+]h,]h-]h.]h0]uh2M h3hh]r%(jä)r&}r'(h X``template inline void status(basic_response & response, typename traits::status >::type const & status_)``r(h!j"h"h%h'jèh)}r)(h+]h,]h-]h.]h0]uh2M h]r*h‚)r+}r,(h j(h)}r-(h+]h,]h-]h.]h0]uh!j&h]r.h inline void status(basic_response & response, typename traits::status >::type const & status_)r/…r0}r1(h Uh!j+ubah'hŠubaubjý)r2}r3(h Uh)}r4(h+]h,]h-]h.]h0]uh!j"h]r5h@)r6}r7(h XˆModifies the status of the given ``response``. The type of ``status_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!j2h"h%h'hCh)}r8(h+]h,]h-]h.]h0]uh2M h]r9(h(h X ``response``h)}r?(h+]h,]h-]h.]h0]uh!j6h]r@h inline void status_message(basic_response & response, typename traits::status_message >::type const & status_message_)`` Modifies the status message of the given ``response``. The type of ``status_message_`` is dependent on the ``Tag`` specialization of ``basic_response``. h!jB h"h%h'jáh)}rf(h+]h,]h-]h.]h0]uh2Mh3hh]rg(jä)rh}ri(h X¨``template inline void status_message(basic_response & response, typename traits::status_message >::type const & status_message_)``rjh!jdh"h%h'jèh)}rk(h+]h,]h-]h.]h0]uh2Mh]rlh‚)rm}rn(h jjh)}ro(h+]h,]h-]h.]h0]uh!jhh]rph inline void status_message(basic_response & response, typename traits::status_message >::type const & status_message_)rq…rr}rs(h Uh!jmubah'hŠubaubjý)rt}ru(h Uh)}rv(h+]h,]h-]h.]h0]uh!jdh]rwh@)rx}ry(h X˜Modifies the status message of the given ``response``. The type of ``status_message_`` is dependent on the ``Tag`` specialization of ``basic_response``.h!jth"h%h'hCh)}rz(h+]h,]h-]h.]h0]uh2Mh]r{(h`` *unspecified* ``source(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the source of a given response.h!jÔh"h%h'jáh)}rÚ(h+]h,]h-]h.]h0]uh2M!h]rÛ(jä)rÜ}rÝ(h XW``template `` *unspecified* ``source(basic_response const & response)``rÞh!jØh"h%h'jèh)}rß(h+]h,]h-]h.]h0]uh2M!h]rà(h‚)rá}râ(h X``template ``h)}rã(h+]h,]h-]h.]h0]uh!jÜh]rährå…ræ}rç(h Uh!jáubah'hŠubh const & response)``h)}rõ(h+]h,]h-]h.]h0]uh!jÜh]röh const & response)r÷…rø}rù(h Uh!jóubah'hŠubeubjý)rú}rû(h Uh)}rü(h+]h,]h-]h.]h0]uh!jØh]rýh@)rþ}rÿ(h XmReturns a wrapper convertible to ``typename string::type`` that provides the source of a given response.h!júh"h%h'hCh)}r(h+]h,]h-]h.]h0]uh2M!h]r(h::type``h)}r(h+]h,]h-]h.]h0]uh!jþh]rh::typer …r }r (h Uh!jubah'hŠubh`` *unspecified* ``destination(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the destination of a given response.h!jÔh"h%h'jáh)}r(h+]h,]h-]h.]h0]uh2M$h3hh]r(jä)r}r(h X\``template `` *unspecified* ``destination(basic_response const & response)``rh!jh"h%h'jèh)}r(h+]h,]h-]h.]h0]uh2M$h]r(h‚)r}r(h X``template ``h)}r(h+]h,]h-]h.]h0]uh!jh]rhr…r}r(h Uh!jubah'hŠubh const & response)``h)}r,(h+]h,]h-]h.]h0]uh!jh]r-h const & response)r.…r/}r0(h Uh!j*ubah'hŠubeubjý)r1}r2(h Uh)}r3(h+]h,]h-]h.]h0]uh!jh]r4h@)r5}r6(h XrReturns a wrapper convertible to ``typename string::type`` that provides the destination of a given response.h!j1h"h%h'hCh)}r7(h+]h,]h-]h.]h0]uh2M$h]r8(h::type``h)}r>(h+]h,]h-]h.]h0]uh!j5h]r?h::typer@…rA}rB(h Uh!j<ubah'hŠubh`` *unspecified* ``headers(basic_response const & response)`` Returns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_response::headers_container_type`` that provides the headers of a given response.h!jÔh"h%h'jáh)}rH(h+]h,]h-]h.]h0]uh2M(h3hh]rI(jä)rJ}rK(h XX``template `` *unspecified* ``headers(basic_response const & response)``rLh!jFh"h%h'jèh)}rM(h+]h,]h-]h.]h0]uh2M(h]rN(h‚)rO}rP(h X``template ``h)}rQ(h+]h,]h-]h.]h0]uh!jJh]rRhrS…rT}rU(h Uh!jOubah'hŠubh const & response)``h)}rc(h+]h,]h-]h.]h0]uh!jJh]rdh const & response)re…rf}rg(h Uh!jaubah'hŠubeubjý)rh}ri(h Uh)}rj(h+]h,]h-]h.]h0]uh!jFh]rkh@)rl}rm(h XÂReturns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_response::headers_container_type`` that provides the headers of a given response.h!jhh"h%h'hCh)}rn(h+]h,]h-]h.]h0]uh2M'h]ro(h >::type``h)}ru(h+]h,]h-]h.]h0]uh!jlh]rvh >::typerw…rx}ry(h Uh!jsubah'hŠubh::headers_container_type``h)}r(h+]h,]h-]h.]h0]uh!jlh]r€h::headers_container_typer…r‚}rƒ(h Uh!j}ubah'hŠubh`` *unspecified* ``body(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the body of a given response.h!jÔh"h%h'jáh)}r‰(h+]h,]h-]h.]h0]uh2M+h3hh]rŠ(jä)r‹}rŒ(h XU``template `` *unspecified* ``body(basic_response const & response)``rh!j‡h"h%h'jèh)}rŽ(h+]h,]h-]h.]h0]uh2M+h]r(h‚)r}r‘(h X``template ``h)}r’(h+]h,]h-]h.]h0]uh!j‹h]r“hr”…r•}r–(h Uh!jubah'hŠubh const & response)``h)}r¤(h+]h,]h-]h.]h0]uh!j‹h]r¥h const & response)r¦…r§}r¨(h Uh!j¢ubah'hŠubeubjý)r©}rª(h Uh)}r«(h+]h,]h-]h.]h0]uh!j‡h]r¬h@)r­}r®(h XkReturns a wrapper convertible to ``typename string::type`` that provides the body of a given response.h!j©h"h%h'hCh)}r¯(h+]h,]h-]h.]h0]uh2M+h]r°(h::type``h)}r¶(h+]h,]h-]h.]h0]uh!j­h]r·h::typer¸…r¹}rº(h Uh!j´ubah'hŠubh`` *unspecified* ``version(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the version of the given response.h!jÔh"h%h'jáh)}rÀ(h+]h,]h-]h.]h0]uh2M.h3hh]rÁ(jä)rÂ}rÃ(h XX``template `` *unspecified* ``version(basic_response const & response)``rÄh!j¾h"h%h'jèh)}rÅ(h+]h,]h-]h.]h0]uh2M.h]rÆ(h‚)rÇ}rÈ(h X``template ``h)}rÉ(h+]h,]h-]h.]h0]uh!jÂh]rÊhrË…rÌ}rÍ(h Uh!jÇubah'hŠubh const & response)``h)}rÛ(h+]h,]h-]h.]h0]uh!jÂh]rÜh const & response)rÝ…rÞ}rß(h Uh!jÙubah'hŠubeubjý)rà}rá(h Uh)}râ(h+]h,]h-]h.]h0]uh!j¾h]rãh@)rä}rå(h XpReturns a wrapper convertible to ``typename string::type`` that provides the version of the given response.h!jàh"h%h'hCh)}ræ(h+]h,]h-]h.]h0]uh2M.h]rç(h::type``h)}rí(h+]h,]h-]h.]h0]uh!jäh]rîh::typerï…rð}rñ(h Uh!jëubah'hŠubh`` *unspecified* ``status(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the status of the given response.h!jÔh"h%h'jáh)}r÷(h+]h,]h-]h.]h0]uh2M1h3hh]rø(jä)rù}rú(h XW``template `` *unspecified* ``status(basic_response const & response)``rûh!jõh"h%h'jèh)}rü(h+]h,]h-]h.]h0]uh2M1h]rý(h‚)rþ}rÿ(h X``template ``h)}r(h+]h,]h-]h.]h0]uh!jùh]rhr…r}r(h Uh!jþubah'hŠubh const & response)``h)}r(h+]h,]h-]h.]h0]uh!jùh]rh const & response)r…r}r(h Uh!jubah'hŠubeubjý)r}r(h Uh)}r(h+]h,]h-]h.]h0]uh!jõh]rh@)r}r(h XoReturns a wrapper convertible to ``typename string::type`` that provides the status of the given response.h!jh"h%h'hCh)}r(h+]h,]h-]h.]h0]uh2M1h]r(h::type``h)}r$(h+]h,]h-]h.]h0]uh!jh]r%h::typer&…r'}r((h Uh!j"ubah'hŠubh`` *unspecified* ``status_message(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the status message of the given response.h!jÔh"h%h'jáh)}r.(h+]h,]h-]h.]h0]uh2M4h3hh]r/(jä)r0}r1(h X_``template `` *unspecified* ``status_message(basic_response const & response)``r2h!j,h"h%h'jèh)}r3(h+]h,]h-]h.]h0]uh2M4h]r4(h‚)r5}r6(h X``template ``h)}r7(h+]h,]h-]h.]h0]uh!j0h]r8hr9…r:}r;(h Uh!j5ubah'hŠubh}r?(h X *unspecified*h)}r@(h+]h,]h-]h.]h0]uh!j0h]rAhubah'jóubh const & response)``h)}rI(h+]h,]h-]h.]h0]uh!j0h]rJh const & response)rK…rL}rM(h Uh!jGubah'hŠubeubjý)rN}rO(h Uh)}rP(h+]h,]h-]h.]h0]uh!j,h]rQh@)rR}rS(h XwReturns a wrapper convertible to ``typename string::type`` that provides the status message of the given response.h!jNh"h%h'hCh)}rT(h+]h,]h-]h.]h0]uh2M4h]rU(h::type``h)}r[(h+]h,]h-]h.]h0]uh!jRh]r\h::typer]…r^}r_(h Uh!jYubah'hŠubhcdocutils.nodes Text q?XHTTP Server APIq@…qA}qB(hh;hh9ubaubh)qC}qD(hUhh!h#h&h(h)h*}qE(h,]h-]h.]h/]qFUgeneralqGah2]qHh auh4Kh5hh6]qI(h8)qJ}qK(hXGeneralqLhhCh#h&h(h}r?(hUhhÄh#h&h(Udefinition_listr@h*}rA(h,]h-]h.]h/]h2]uh4Nh5hh6]rB(cdocutils.nodes definition_list_item rC)rD}rE(hXH The Handler type.hj>h#h&h(Udefinition_list_itemrFh*}rG(h,]h-]h.]h/]h2]uh4K-h6]rH(cdocutils.nodes term rI)rJ}rK(hXHhjDh#h&h(UtermrLh*}rM(h,]h-]h.]h/]h2]uh4K-h6]rNh?XH…rO}rP(hXHhjJubaubcdocutils.nodes definition rQ)rR}rS(hUh*}rT(h,]h-]h.]h/]h2]uhjDh6]rUhR)rV}rW(hXThe Handler type.rXhjRh#h&h(hUh*}rY(h,]h-]h.]h/]h2]uh4K.h6]rZh?XThe Handler type.r[…r\}r](hjXhjVubaubah(U definitionr^ubeubjC)r_}r`(hXh An instance of H.hj>h#h&h(jFh*}ra(h,]h-]h.]h/]h2]uh4K/h5hh6]rb(jI)rc}rd(hXhhj_h#h&h(jLh*}re(h,]h-]h.]h/]h2]uh4K/h6]rfh?Xh…rg}rh(hXhhjcubaubjQ)ri}rj(hUh*}rk(h,]h-]h.]h/]h2]uhj_h6]rlhR)rm}rn(hXAn instance of H.rohjih#h&h(hUh*}rp(h,]h-]h.]h/]h2]uh4K0h6]rqh?XAn instance of H.rr…rs}rt(hjohjmubaubah(j^ubeubjC)ru}rv(hX+Req A type that models the Request Concept.hj>h#h&h(jFh*}rw(h,]h-]h.]h/]h2]uh4K1h5hh6]rx(jI)ry}rz(hXReqr{hjuh#h&h(jLh*}r|(h,]h-]h.]h/]h2]uh4K1h6]r}h?XReqr~…r}r€(hj{hjyubaubjQ)r}r‚(hUh*}rƒ(h,]h-]h.]h/]h2]uhjuh6]r„hR)r…}r†(hX'A type that models the Request Concept.r‡hjh#h&h(hUh*}rˆ(h,]h-]h.]h/]h2]uh4K2h6]r‰h?X'A type that models the Request Concept.rŠ…r‹}rŒ(hj‡hj…ubaubah(j^ubeubjC)r}rŽ(hX,Res A type that models the Response Concept.hj>h#h&h(jFh*}r(h,]h-]h.]h/]h2]uh4K3h5hh6]r(jI)r‘}r’(hXResr“hjh#h&h(jLh*}r”(h,]h-]h.]h/]h2]uh4K3h6]r•h?XResr–…r—}r˜(hj“hj‘ubaubjQ)r™}rš(hUh*}r›(h,]h-]h.]h/]h2]uhjh6]rœhR)r}rž(hX(A type that models the Response Concept.rŸhj™h#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4K4h6]r¡h?X(A type that models the Response Concept.r¢…r£}r¤(hjŸhjubaubah(j^ubeubjC)r¥}r¦(hXreq An instance of Req.hj>h#h&h(jFh*}r§(h,]h-]h.]h/]h2]uh4K5h5hh6]r¨(jI)r©}rª(hXreqr«hj¥h#h&h(jLh*}r¬(h,]h-]h.]h/]h2]uh4K5h6]r­h?Xreqr®…r¯}r°(hj«hj©ubaubjQ)r±}r²(hUh*}r³(h,]h-]h.]h/]h2]uhj¥h6]r´hR)rµ}r¶(hXAn instance of Req.r·hj±h#h&h(hUh*}r¸(h,]h-]h.]h/]h2]uh4K6h6]r¹h?XAn instance of Req.rº…r»}r¼(hj·hjµubaubah(j^ubeubjC)r½}r¾(hXres An instance of Res. hj>h#h&h(jFh*}r¿(h,]h-]h.]h/]h2]uh4K8h5hh6]rÀ(jI)rÁ}rÂ(hXresrÃhj½h#h&h(jLh*}rÄ(h,]h-]h.]h/]h2]uh4K8h6]rÅh?XresrÆ…rÇ}rÈ(hjÃhjÁubaubjQ)rÉ}rÊ(hUh*}rË(h,]h-]h.]h/]h2]uhj½h6]rÌhR)rÍ}rÎ(hXAn instance of Res.rÏhjÉh#h&h(hUh*}rÐ(h,]h-]h.]h/]h2]uh4K8h6]rÑh?XAn instance of Res.rÒ…rÓ}rÔ(hjÏhjÍubaubah(j^ubeubeubcdocutils.nodes table rÕ)rÖ}r×(hUhhÄh#h&h(UtablerØh*}rÙ(h,]h-]h.]h/]h2]uh4Nh5hh6]rÚcdocutils.nodes tgroup rÛ)rÜ}rÝ(hUh*}rÞ(h/]h.]h,]h-]h2]UcolsKuhjÖh6]rß(cdocutils.nodes colspec rà)rá}râ(hUh*}rã(h/]h.]h,]h-]h2]UcolwidthKuhjÜh6]h(Ucolspecräubjà)rå}ræ(hUh*}rç(h/]h.]h,]h-]h2]UcolwidthK uhjÜh6]h(jäubjà)rè}ré(hUh*}rê(h/]h.]h,]h-]h2]UcolwidthK.uhjÜh6]h(jäubcdocutils.nodes thead rë)rì}rí(hUh*}rî(h,]h-]h.]h/]h2]uhjÜh6]rïcdocutils.nodes row rð)rñ}rò(hUh*}ró(h,]h-]h.]h/]h2]uhjìh6]rô(cdocutils.nodes entry rõ)rö}r÷(hUh*}rø(h,]h-]h.]h/]h2]uhjñh6]rùhR)rú}rû(hX Constructrühjöh#h&h(hUh*}rý(h,]h-]h.]h/]h2]uh4K;h6]rþh?X Constructrÿ…r}r(hjühjúubaubah(Uentryrubjõ)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjñh6]rhR)r}r(hX Return Typer hjh#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4K;h6]r h?X Return Typer …r }r(hj hjubaubah(jubjõ)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjñh6]rhR)r}r(hX Descriptionrhjh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4K;h6]rh?X Descriptionr…r}r(hjhjubaubah(jubeh(Urowrubah(Utheadrubcdocutils.nodes tbody r)r}r(hUh*}r (h,]h-]h.]h/]h2]uhjÜh6]r!jð)r"}r#(hUh*}r$(h,]h-]h.]h/]h2]uhjh6]r%(jõ)r&}r'(hUh*}r((h,]h-]h.]h/]h2]uhj"h6]r)hR)r*}r+(hX``h(req,res)``r,hj&h#h&h(hUh*}r-(h,]h-]h.]h/]h2]uh4K=h6]r.hf)r/}r0(hj,h*}r1(h,]h-]h.]h/]h2]uhj*h6]r2h?X h(req,res)r3…r4}r5(hUhj/ubah(hqubaubah(jubjõ)r6}r7(hUh*}r8(h,]h-]h.]h/]h2]uhj"h6]r9hR)r:}r;(hX``void``r<hj6h#h&h(hUh*}r=(h,]h-]h.]h/]h2]uh4K=h6]r>hf)r?}r@(hj<h*}rA(h,]h-]h.]h/]h2]uhj:h6]rBh?XvoidrC…rD}rE(hUhj?ubah(hqubaubah(jubjõ)rF}rG(hUh*}rH(h,]h-]h.]h/]h2]uhj"h6]rIhR)rJ}rK(hXŽHandle the request; res is passed in as a non-const lvalue, which represents the response to be returned to the client performing the request.rLhjFh#h&h(hUh*}rM(h,]h-]h.]h/]h2]uh4K=h6]rNh?XŽHandle the request; res is passed in as a non-const lvalue, which represents the response to be returned to the client performing the request.rO…rP}rQ(hjLhjJubaubah(jubeh(jubah(UtbodyrRubeh(UtgrouprSubaubhR)rT}rU(hXiMore information about the internals of the `Synchronous Servers`_ can be found in the following section.hhÄh#h&h(hUh*}rV(h,]h-]h.]h/]h2]uh4KCh5hh6]rW(h?X,More information about the internals of the rX…rY}rZ(hX,More information about the internals of the hjTubhÚ)r[}r\(hX`Synchronous Servers`_hÝKhjTh(hÞh*}r](UnameXSynchronous Serversh/]h.]h,]h-]h2]hàháuh6]r^h?XSynchronous Serversr_…r`}ra(hUhj[ubaubh?X' can be found in the following section.rb…rc}rd(hX' can be found in the following section.hjTubeubhR)re}rf(hX`The AsynchronousHandler concept for `Asynchronous Servers`_ is described by the following table:hhÄh#h&h(hUh*}rg(h,]h-]h.]h/]h2]uh4KFh5hh6]rh(h?X$The AsynchronousHandler concept for ri…rj}rk(hX$The AsynchronousHandler concept for hjeubhÚ)rl}rm(hX`Asynchronous Servers`_hÝKhjeh(hÞh*}rn(UnameXAsynchronous Serversh/]h.]h,]h-]h2]hàhìuh6]roh?XAsynchronous Serversrp…rq}rr(hUhjlubaubh?X% is described by the following table:rs…rt}ru(hX% is described by the following table:hjeubeubj+)rv}rw(hX---------------rxhhÄh#h&h(j/h*}ry(h,]h-]h.]h/]h2]uh4KIh5hh6]ubhR)rz}r{(hX **Legend:**r|hhÄh#h&h(hUh*}r}(h,]h-]h.]h/]h2]uh4KKh5hh6]r~hŠ)r}r€(hj|h*}r(h,]h-]h.]h/]h2]uhjzh6]r‚h?XLegend:rƒ…r„}r…(hUhjubah(h’ubaubj=)r†}r‡(hUhhÄh#h&h(j@h*}rˆ(h,]h-]h.]h/]h2]uh4Nh5hh6]r‰(jC)rŠ}r‹(hXH The Handler type.hj†h#h&h(jFh*}rŒ(h,]h-]h.]h/]h2]uh4KMh6]r(jI)rŽ}r(hXHhjŠh#h&h(jLh*}r(h,]h-]h.]h/]h2]uh4KMh6]r‘h?XH…r’}r“(hXHhjŽubaubjQ)r”}r•(hUh*}r–(h,]h-]h.]h/]h2]uhjŠh6]r—hR)r˜}r™(hXThe Handler type.ršhj”h#h&h(hUh*}r›(h,]h-]h.]h/]h2]uh4KNh6]rœh?XThe Handler type.r…rž}rŸ(hjšhj˜ubaubah(j^ubeubjC)r }r¡(hXh An instance of H.hj†h#h&h(jFh*}r¢(h,]h-]h.]h/]h2]uh4KOh5hh6]r£(jI)r¤}r¥(hXhhj h#h&h(jLh*}r¦(h,]h-]h.]h/]h2]uh4KOh6]r§h?Xh…r¨}r©(hXhhj¤ubaubjQ)rª}r«(hUh*}r¬(h,]h-]h.]h/]h2]uhj h6]r­hR)r®}r¯(hXAn instance of H.r°hjªh#h&h(hUh*}r±(h,]h-]h.]h/]h2]uh4KPh6]r²h?XAn instance of H.r³…r´}rµ(hj°hj®ubaubah(j^ubeubjC)r¶}r·(hX+Req A type that models the Request Concept.hj†h#h&h(jFh*}r¸(h,]h-]h.]h/]h2]uh4KQh5hh6]r¹(jI)rº}r»(hXReqr¼hj¶h#h&h(jLh*}r½(h,]h-]h.]h/]h2]uh4KQh6]r¾h?XReqr¿…rÀ}rÁ(hj¼hjºubaubjQ)rÂ}rÃ(hUh*}rÄ(h,]h-]h.]h/]h2]uhj¶h6]rÅhR)rÆ}rÇ(hX'A type that models the Request Concept.rÈhjÂh#h&h(hUh*}rÉ(h,]h-]h.]h/]h2]uh4KRh6]rÊh?X'A type that models the Request Concept.rË…rÌ}rÍ(hjÈhjÆubaubah(j^ubeubjC)rÎ}rÏ(hX@ConnectionPtr A type that models the Connection Pointer Concept.hj†h#h&h(jFh*}rÐ(h,]h-]h.]h/]h2]uh4KSh5hh6]rÑ(jI)rÒ}rÓ(hX ConnectionPtrrÔhjÎh#h&h(jLh*}rÕ(h,]h-]h.]h/]h2]uh4KSh6]rÖh?X ConnectionPtrr×…rØ}rÙ(hjÔhjÒubaubjQ)rÚ}rÛ(hUh*}rÜ(h,]h-]h.]h/]h2]uhjÎh6]rÝhR)rÞ}rß(hX2A type that models the Connection Pointer Concept.ràhjÚh#h&h(hUh*}rá(h,]h-]h.]h/]h2]uh4KTh6]râh?X2A type that models the Connection Pointer Concept.rã…rä}rå(hjàhjÞubaubah(j^ubeubjC)ræ}rç(hXreq An instance of Req.hj†h#h&h(jFh*}rè(h,]h-]h.]h/]h2]uh4KUh5hh6]ré(jI)rê}rë(hXreqrìhjæh#h&h(jLh*}rí(h,]h-]h.]h/]h2]uh4KUh6]rîh?Xreqrï…rð}rñ(hjìhjêubaubjQ)rò}ró(hUh*}rô(h,]h-]h.]h/]h2]uhjæh6]rõhR)rö}r÷(hXAn instance of Req.røhjòh#h&h(hUh*}rù(h,]h-]h.]h/]h2]uh4KVh6]rúh?XAn instance of Req.rû…rü}rý(hjøhjöubaubah(j^ubeubjC)rþ}rÿ(hX#conn An instance of ConncetionPtr. hj†h#h&h(jFh*}r(h,]h-]h.]h/]h2]uh4KXh5hh6]r(jI)r}r(hXconnrhjþh#h&h(jLh*}r(h,]h-]h.]h/]h2]uh4KXh6]rh?Xconnr…r}r (hjhjubaubjQ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjþh6]r hR)r}r(hXAn instance of ConncetionPtr.rhj h#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4KXh6]rh?XAn instance of ConncetionPtr.r…r}r(hjhjubaubah(j^ubeubeubjÕ)r}r(hUhhÄh#h&h(jØh*}r(h,]h-]h.]h/]h2]uh4Nh5hh6]rjÛ)r}r(hUh*}r(h/]h.]h,]h-]h2]UcolsKuhjh6]r(jà)r}r(hUh*}r (h/]h.]h,]h-]h2]UcolwidthKuhjh6]h(jäubjà)r!}r"(hUh*}r#(h/]h.]h,]h-]h2]UcolwidthK uhjh6]h(jäubjà)r$}r%(hUh*}r&(h/]h.]h,]h-]h2]UcolwidthK,uhjh6]h(jäubjë)r'}r((hUh*}r)(h,]h-]h.]h/]h2]uhjh6]r*jð)r+}r,(hUh*}r-(h,]h-]h.]h/]h2]uhj'h6]r.(jõ)r/}r0(hUh*}r1(h,]h-]h.]h/]h2]uhj+h6]r2hR)r3}r4(hX Constructr5hj/h#h&h(hUh*}r6(h,]h-]h.]h/]h2]uh4K[h6]r7h?X Constructr8…r9}r:(hj5hj3ubaubah(jubjõ)r;}r<(hUh*}r=(h,]h-]h.]h/]h2]uhj+h6]r>hR)r?}r@(hX Return TyperAhj;h#h&h(hUh*}rB(h,]h-]h.]h/]h2]uh4K[h6]rCh?X Return TyperD…rE}rF(hjAhj?ubaubah(jubjõ)rG}rH(hUh*}rI(h,]h-]h.]h/]h2]uhj+h6]rJhR)rK}rL(hX DescriptionrMhjGh#h&h(hUh*}rN(h,]h-]h.]h/]h2]uh4K[h6]rOh?X DescriptionrP…rQ}rR(hjMhjKubaubah(jubeh(jubah(jubj)rS}rT(hUh*}rU(h,]h-]h.]h/]h2]uhjh6]rVjð)rW}rX(hUh*}rY(h,]h-]h.]h/]h2]uhjSh6]rZ(jõ)r[}r\(hUh*}r](h,]h-]h.]h/]h2]uhjWh6]r^hR)r_}r`(hX``h(req, conn)``rahj[h#h&h(hUh*}rb(h,]h-]h.]h/]h2]uh4K]h6]rchf)rd}re(hjah*}rf(h,]h-]h.]h/]h2]uhj_h6]rgh?X h(req, conn)rh…ri}rj(hUhjdubah(hqubaubah(jubjõ)rk}rl(hUh*}rm(h,]h-]h.]h/]h2]uhjWh6]rnhR)ro}rp(hX``void``rqhjkh#h&h(hUh*}rr(h,]h-]h.]h/]h2]uh4K]h6]rshf)rt}ru(hjqh*}rv(h,]h-]h.]h/]h2]uhjoh6]rwh?Xvoidrx…ry}rz(hUhjtubah(hqubaubah(jubjõ)r{}r|(hUh*}r}(h,]h-]h.]h/]h2]uhjWh6]r~hR)r}r€(hXtHandle the request; conn is a shared pointer which exposes functions for writing to and reading from the connection.rhj{h#h&h(hUh*}r‚(h,]h-]h.]h/]h2]uh4K]h6]rƒh?XtHandle the request; conn is a shared pointer which exposes functions for writing to and reading from the connection.r„…r…}r†(hjhjubaubah(jubeh(jubah(jRubeh(jSubaubhR)r‡}rˆ(hXjMore information about the internals of the `Asynchronous Servers`_ can be found in the following section.hhÄh#h&h(hUh*}r‰(h,]h-]h.]h/]h2]uh4Kbh5hh6]rŠ(h?X,More information about the internals of the r‹…rŒ}r(hX,More information about the internals of the hj‡ubhÚ)rŽ}r(hX`Asynchronous Servers`_hÝKhj‡h(hÞh*}r(UnameXAsynchronous Serversh/]h.]h,]h-]h2]hàhìuh6]r‘h?XAsynchronous Serversr’…r“}r”(hUhjŽubaubh?X' can be found in the following section.r•…r–}r—(hX' can be found in the following section.hj‡ubeubeubh)r˜}r™(hUhKhh!h#h&h(h)h*}rš(h,]h-]h.]h/]r›háah2]rœhauh4Kfh5hh6]r(h8)rž}rŸ(hXSynchronous Serversr hj˜h#h&h(h http_server; struct handler { void operator()( http_server::request const & req, http_server::response & res ) { // do something, and then edit the res object here. } };hj˜h#h&h(U literal_blockröh*}r÷(Ulinenosrø‰UlanguagerùXc++U xml:spacerúUpreserverûh/]h.]h,]h-]h2]uh4K{h5hh6]rüh?X struct handler; typedef boost::network::http::server http_server; struct handler { void operator()( http_server::request const & req, http_server::response & res ) { // do something, and then edit the res object here. } };rý…rþ}rÿ(hUhjôubaubhR)r}r(hX/More information about the actual HTTP Server API follows in the next section. It is important to understand that the HTTP Server is actually embedded in your application, which means you can expose almost all your application logic through the Handler type, which you can also initialize appropriately.rhj˜h#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4K‰h5hh6]rh?X/More information about the actual HTTP Server API follows in the next section. It is important to understand that the HTTP Server is actually embedded in your application, which means you can expose almost all your application logic through the Handler type, which you can also initialize appropriately.r…r}r(hjhjubaubh)r}r (hUhKhj˜h#h&h(h)h*}r (h,]r Xapi documentationr ah-]h.]h/]r Uapi-documentationrah2]uh4Kh5hh6]r(h8)r}r(hXAPI Documentationrhjh#h&h(hhjh#h&h(jöh*}r"(jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4K“h5hh6]r#h?X0#include r$…r%}r&(hUhj ubaubhR)r'}r((hX8And that the following typedef's have been put in place:r)hjh#h&h(hUh*}r*(h,]h-]h.]h/]h2]uh4K—h5hh6]r+h?X8And that the following typedef's have been put in place:r,…r-}r.(hj)hj'ubaubjó)r/}r0(hXstruct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()( http_server::request const & request, http_server::response & response ) { // do something here } };hjh#h&h(jöh*}r1(jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4K™h5hh6]r2h?Xstruct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()( http_server::request const & request, http_server::response & response ) { // do something here } };r3…r4}r5(hUhj/ubaubh)r6}r7(hUhKhjh#h&h(h)h*}r8(h,]r9X constructorr:ah-]h.]h/]r;U constructorr<ah2]uh4K¨h5hh6]r=(h8)r>}r?(hX Constructorr@hj6h#h&h(hubaubj=)rF}rG(hUhj6h#h&h(j@h*}rH(h,]h-]h.]h/]h2]uh4Nh5hh6]rIjC)rJ}rK(hXÐ``explicit http_server(options)`` Construct an HTTP Server instance, passing in a ``server_options`` object. The following table shows the supported options in ``server_options``. hjFh#h&h(jFh*}rL(h,]h-]h.]h/]h2]uh4K­h6]rM(jI)rN}rO(hX!``explicit http_server(options)``rPhjJh#h&h(jLh*}rQ(h,]h-]h.]h/]h2]uh4K­h6]rRhf)rS}rT(hjPh*}rU(h,]h-]h.]h/]h2]uhjNh6]rVh?Xexplicit http_server(options)rW…rX}rY(hUhjSubah(hqubaubjQ)rZ}r[(hUh*}r\(h,]h-]h.]h/]h2]uhjJh6]r]hR)r^}r_(hX­Construct an HTTP Server instance, passing in a ``server_options`` object. The following table shows the supported options in ``server_options``.hjZh#h&h(hUh*}r`(h,]h-]h.]h/]h2]uh4K«h6]ra(h?X0Construct an HTTP Server instance, passing in a rb…rc}rd(hX0Construct an HTTP Server instance, passing in a hj^ubhf)re}rf(hX ``server_options``h*}rg(h,]h-]h.]h/]h2]uhj^h6]rhh?Xserver_optionsri…rj}rk(hUhjeubah(hqubh?X< object. The following table shows the supported options in rl…rm}rn(hX< object. The following table shows the supported options in hj^ubhf)ro}rp(hX ``server_options``h*}rq(h,]h-]h.]h/]h2]uhj^h6]rrh?Xserver_optionsrs…rt}ru(hUhjoubah(hqubh?X.…rv}rw(hX.hj^ubeubah(j^ubeubaubjÕ)rx}ry(hUhj6h#h&h(jØh*}rz(h,]h-]h.]h/]h2]uh4Nh5hh6]r{jÛ)r|}r}(hUh*}r~(h/]h.]h,]h-]h2]UcolsKuhjxh6]r(jà)r€}r(hUh*}r‚(h/]h.]h,]h-]h2]UcolwidthKuhj|h6]h(jäubjà)rƒ}r„(hUh*}r…(h/]h.]h,]h-]h2]UcolwidthK*uhj|h6]h(jäubjà)r†}r‡(hUh*}rˆ(h/]h.]h,]h-]h2]UcolwidthKbuhj|h6]h(jäubjë)r‰}rŠ(hUh*}r‹(h,]h-]h.]h/]h2]uhj|h6]rŒjð)r}rŽ(hUh*}r(h,]h-]h.]h/]h2]uhj‰h6]r(jõ)r‘}r’(hUh*}r“(h,]h-]h.]h/]h2]uhjh6]r”hR)r•}r–(hXParameter Namer—hj‘h#h&h(hUh*}r˜(h,]h-]h.]h/]h2]uh4K°h6]r™h?XParameter Namerš…r›}rœ(hj—hj•ubaubah(jubjõ)r}rž(hUh*}rŸ(h,]h-]h.]h/]h2]uhjh6]r hR)r¡}r¢(hXTyper£hjh#h&h(hUh*}r¤(h,]h-]h.]h/]h2]uh4K°h6]r¥h?XTyper¦…r§}r¨(hj£hj¡ubaubah(jubjõ)r©}rª(hUh*}r«(h,]h-]h.]h/]h2]uhjh6]r¬hR)r­}r®(hX Descriptionr¯hj©h#h&h(hUh*}r°(h,]h-]h.]h/]h2]uh4K°h6]r±h?X Descriptionr²…r³}r´(hj¯hj­ubaubah(jubeh(jubah(jubj)rµ}r¶(hUh*}r·(h,]h-]h.]h/]h2]uhj|h6]r¸(jð)r¹}rº(hUh*}r»(h,]h-]h.]h/]h2]uhjµh6]r¼(jõ)r½}r¾(hUh*}r¿(h,]h-]h.]h/]h2]uhj¹h6]rÀhR)rÁ}rÂ(hXaddressrÃhj½h#h&h(hUh*}rÄ(h,]h-]h.]h/]h2]uh4K²h6]rÅh?XaddressrÆ…rÇ}rÈ(hjÃhjÁubaubah(jubjõ)rÉ}rÊ(hUh*}rË(h,]h-]h.]h/]h2]uhj¹h6]rÌhR)rÍ}rÎ(hX string_typerÏhjÉh#h&h(hUh*}rÐ(h,]h-]h.]h/]h2]uh4K²h6]rÑh?X string_typerÒ…rÓ}rÔ(hjÏhjÍubaubah(jubjõ)rÕ}rÖ(hUh*}r×(h,]h-]h.]h/]h2]uhj¹h6]rØhR)rÙ}rÚ(hX`The hostname or IP address from which the server should be bound to. This parameter is required.rÛhjÕh#h&h(hUh*}rÜ(h,]h-]h.]h/]h2]uh4K²h6]rÝh?X`The hostname or IP address from which the server should be bound to. This parameter is required.rÞ…rß}rà(hjÛhjÙubaubah(jubeh(jubjð)rá}râ(hUh*}rã(h,]h-]h.]h/]h2]uhjµh6]rä(jõ)rå}ræ(hUh*}rç(h,]h-]h.]h/]h2]uhjáh6]rèhR)ré}rê(hXportrëhjåh#h&h(hUh*}rì(h,]h-]h.]h/]h2]uh4K´h6]ríh?Xportrî…rï}rð(hjëhjéubaubah(jubjõ)rñ}rò(hUh*}ró(h,]h-]h.]h/]h2]uhjáh6]rôhR)rõ}rö(hX string_typer÷hjñh#h&h(hUh*}rø(h,]h-]h.]h/]h2]uh4K´h6]rùh?X string_typerú…rû}rü(hj÷hjõubaubah(jubjõ)rý}rþ(hUh*}rÿ(h,]h-]h.]h/]h2]uhjáh6]rhR)r}r(hXSThe port to which the server should bind and listen to. This parameter is required.rhjýh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4K´h6]rh?XSThe port to which the server should bind and listen to. This parameter is required.r…r}r(hjhjubaubah(jubeh(jubjð)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjµh6]r (jõ)r }r(hUh*}r(h,]h-]h.]h/]h2]uhj h6]rhR)r}r(hX thread_poolrhj h#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4K¶h6]rh?X thread_poolr…r}r(hjhjubaubah(jubjõ)r}r(hUh*}r(h,]h-]h.]h/]h2]uhj h6]rhR)r}r(hX``shared_ptr``rhjh#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4K¶h6]r!hf)r"}r#(hjh*}r$(h,]h-]h.]h/]h2]uhjh6]r%h?Xshared_ptrr&…r'}r((hUhj"ubah(hqubaubah(jubjõ)r)}r*(hUh*}r+(h,]h-]h.]h/]h2]uhj h6]r,hR)r-}r.(hXÖA shared pointer to an instance of ``boost::network::utils::thread_pool`` -- this is the thread pool from where the handler is invoked. This parameter is only applicable and required for ``async_server`` instances.hj)h#h&h(hUh*}r/(h,]h-]h.]h/]h2]uh4K¶h6]r0(h?X#A shared pointer to an instance of r1…r2}r3(hX#A shared pointer to an instance of hj-ubhf)r4}r5(hX&``boost::network::utils::thread_pool``h*}r6(h,]h-]h.]h/]h2]uhj-h6]r7h?X"boost::network::utils::thread_poolr8…r9}r:(hUhj4ubah(hqubh?Xr -- this is the thread pool from where the handler is invoked. This parameter is only applicable and required for r;…r<}r=(hXr -- this is the thread pool from where the handler is invoked. This parameter is only applicable and required for hj-ubhf)r>}r?(hX``async_server``h*}r@(h,]h-]h.]h/]h2]uhj-h6]rAh?X async_serverrB…rC}rD(hUhj>ubah(hqubh?X instances.rE…rF}rG(hX instances.hj-ubeubah(jubeh(jubjð)rH}rI(hUh*}rJ(h,]h-]h.]h/]h2]uhjµh6]rK(jõ)rL}rM(hUh*}rN(h,]h-]h.]h/]h2]uhjHh6]rOhR)rP}rQ(hX io_servicerRhjLh#h&h(hUh*}rS(h,]h-]h.]h/]h2]uh4Kºh6]rTh?X io_servicerU…rV}rW(hjRhjPubaubah(jubjõ)rX}rY(hUh*}rZ(h,]h-]h.]h/]h2]uhjHh6]r[hR)r\}r](hX``shared_ptr``r^hjXh#h&h(hUh*}r_(h,]h-]h.]h/]h2]uh4Kºh6]r`hf)ra}rb(hj^h*}rc(h,]h-]h.]h/]h2]uhj\h6]rdh?Xshared_ptrre…rf}rg(hUhjaubah(hqubaubah(jubjõ)rh}ri(hUh*}rj(h,]h-]h.]h/]h2]uhjHh6]rkhR)rl}rm(hXÉAn optional lvalue to an instance of ``boost::asio::io_service`` which allows the server to use an already-constructed ``boost::asio::io_service`` instance instead of instantiating one that it manages.hjhh#h&h(hUh*}rn(h,]h-]h.]h/]h2]uh4Kºh6]ro(h?X%An optional lvalue to an instance of rp…rq}rr(hX%An optional lvalue to an instance of hjlubhf)rs}rt(hX``boost::asio::io_service``h*}ru(h,]h-]h.]h/]h2]uhjlh6]rvh?Xboost::asio::io_servicerw…rx}ry(hUhjsubah(hqubh?X7 which allows the server to use an already-constructed rz…r{}r|(hX7 which allows the server to use an already-constructed hjlubhf)r}}r~(hX``boost::asio::io_service``h*}r(h,]h-]h.]h/]h2]uhjlh6]r€h?Xboost::asio::io_servicer…r‚}rƒ(hUhj}ubah(hqubh?X7 instance instead of instantiating one that it manages.r„…r…}r†(hX7 instance instead of instantiating one that it manages.hjlubeubah(jubeh(jubjð)r‡}rˆ(hUh*}r‰(h,]h-]h.]h/]h2]uhjµh6]rŠ(jõ)r‹}rŒ(hUh*}r(h,]h-]h.]h/]h2]uhj‡h6]rŽhR)r}r(hX reuse_addressr‘hj‹h#h&h(hUh*}r’(h,]h-]h.]h/]h2]uh4K¾h6]r“h?X reuse_addressr”…r•}r–(hj‘hjubaubah(jubjõ)r—}r˜(hUh*}r™(h,]h-]h.]h/]h2]uhj‡h6]ršhR)r›}rœ(hX``bool``rhj—h#h&h(hUh*}rž(h,]h-]h.]h/]h2]uh4K¾h6]rŸhf)r }r¡(hjh*}r¢(h,]h-]h.]h/]h2]uhj›h6]r£h?Xboolr¤…r¥}r¦(hUhj ubah(hqubaubah(jubjõ)r§}r¨(hUh*}r©(h,]h-]h.]h/]h2]uhj‡h6]rªhR)r«}r¬(hXÀA boolean that specifies whether to re-use the address and port on which the server will be bound to. This enables or disables the socket option for listener sockets. The default is ``false``.hj§h#h&h(hUh*}r­(h,]h-]h.]h/]h2]uh4K¾h6]r®(h?X¶A boolean that specifies whether to re-use the address and port on which the server will be bound to. This enables or disables the socket option for listener sockets. The default is r¯…r°}r±(hX¶A boolean that specifies whether to re-use the address and port on which the server will be bound to. This enables or disables the socket option for listener sockets. The default is hj«ubhf)r²}r³(hX ``false``h*}r´(h,]h-]h.]h/]h2]uhj«h6]rµh?Xfalser¶…r·}r¸(hUhj²ubah(hqubh?X.…r¹}rº(hX.hj«ubeubah(jubeh(jubjð)r»}r¼(hUh*}r½(h,]h-]h.]h/]h2]uhjµh6]r¾(jõ)r¿}rÀ(hUh*}rÁ(h,]h-]h.]h/]h2]uhj»h6]rÂhR)rÃ}rÄ(hXreport_abortedrÅhj¿h#h&h(hUh*}rÆ(h,]h-]h.]h/]h2]uh4KÂh6]rÇh?Xreport_abortedrÈ…rÉ}rÊ(hjÅhjÃubaubah(jubjõ)rË}rÌ(hUh*}rÍ(h,]h-]h.]h/]h2]uhj»h6]rÎhR)rÏ}rÐ(hX``bool``rÑhjËh#h&h(hUh*}rÒ(h,]h-]h.]h/]h2]uh4KÂh6]rÓhf)rÔ}rÕ(hjÑh*}rÖ(h,]h-]h.]h/]h2]uhjÏh6]r×h?XboolrØ…rÙ}rÚ(hUhjÔubah(hqubaubah(jubjõ)rÛ}rÜ(hUh*}rÝ(h,]h-]h.]h/]h2]uhj»h6]rÞhR)rß}rà(hXGA boolean that specifies whether the listening socket should report aborted connection attempts to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for future-proofing the code in case an optional error handler function is supported in later releases of cpp-netlib. The default is ``false``.hjÛh#h&h(hUh*}rá(h,]h-]h.]h/]h2]uh4KÂh6]râ(h?X=A boolean that specifies whether the listening socket should report aborted connection attempts to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for future-proofing the code in case an optional error handler function is supported in later releases of cpp-netlib. The default is rã…rä}rå(hX=A boolean that specifies whether the listening socket should report aborted connection attempts to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for future-proofing the code in case an optional error handler function is supported in later releases of cpp-netlib. The default is hjßubhf)ræ}rç(hX ``false``h*}rè(h,]h-]h.]h/]h2]uhjßh6]réh?Xfalserê…rë}rì(hUhjæubah(hqubh?X.…rí}rî(hX.hjßubeubah(jubeh(jubjð)rï}rð(hUh*}rñ(h,]h-]h.]h/]h2]uhjµh6]rò(jõ)ró}rô(hUh*}rõ(h,]h-]h.]h/]h2]uhjïh6]röhR)r÷}rø(hXreceive_buffer_sizerùhjóh#h&h(hUh*}rú(h,]h-]h.]h/]h2]uh4KÇh6]rûh?Xreceive_buffer_sizerü…rý}rþ(hjùhj÷ubaubah(jubjõ)rÿ}r(hUh*}r(h,]h-]h.]h/]h2]uhjïh6]rhR)r}r(hX``int``rhjÿh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4KÇh6]rhf)r}r (hjh*}r (h,]h-]h.]h/]h2]uhjh6]r h?Xintr …r }r(hUhjubah(hqubaubah(jubjõ)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjïh6]rhR)r}r(hXhThe size of the socket's receive buffer. The default is defined by Boost.Asio and is platform-dependent.rhjh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4KÇh6]rh?XhThe size of the socket's receive buffer. The default is defined by Boost.Asio and is platform-dependent.r…r}r(hjhjubaubah(jubeh(jubjð)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjµh6]r(jõ)r}r (hUh*}r!(h,]h-]h.]h/]h2]uhjh6]r"hR)r#}r$(hXsend_buffer_sizer%hjh#h&h(hUh*}r&(h,]h-]h.]h/]h2]uh4KÊh6]r'h?Xsend_buffer_sizer(…r)}r*(hj%hj#ubaubah(jubjõ)r+}r,(hUh*}r-(h,]h-]h.]h/]h2]uhjh6]r.hR)r/}r0(hX``int``r1hj+h#h&h(hUh*}r2(h,]h-]h.]h/]h2]uh4KÊh6]r3hf)r4}r5(hj1h*}r6(h,]h-]h.]h/]h2]uhj/h6]r7h?Xintr8…r9}r:(hUhj4ubah(hqubaubah(jubjõ)r;}r<(hUh*}r=(h,]h-]h.]h/]h2]uhjh6]r>hR)r?}r@(hXeThe size of the socket's send buffer. The default is defined by Boost.Asio and is platform-dependent.rAhj;h#h&h(hUh*}rB(h,]h-]h.]h/]h2]uh4KÊh6]rCh?XeThe size of the socket's send buffer. The default is defined by Boost.Asio and is platform-dependent.rD…rE}rF(hjAhj?ubaubah(jubeh(jubjð)rG}rH(hUh*}rI(h,]h-]h.]h/]h2]uhjµh6]rJ(jõ)rK}rL(hUh*}rM(h,]h-]h.]h/]h2]uhjGh6]rNhR)rO}rP(hXreceive_low_watermarkrQhjKh#h&h(hUh*}rR(h,]h-]h.]h/]h2]uh4KÍh6]rSh?Xreceive_low_watermarkrT…rU}rV(hjQhjOubaubah(jubjõ)rW}rX(hUh*}rY(h,]h-]h.]h/]h2]uhjGh6]rZhR)r[}r\(hX``int``r]hjWh#h&h(hUh*}r^(h,]h-]h.]h/]h2]uh4KÍh6]r_hf)r`}ra(hj]h*}rb(h,]h-]h.]h/]h2]uhj[h6]rch?Xintrd…re}rf(hUhj`ubah(hqubaubah(jubjõ)rg}rh(hUh*}ri(h,]h-]h.]h/]h2]uhjGh6]rjhR)rk}rl(hX~The size of the socket's low watermark for its receive buffer. The default is defined by Boost.Asio and is platform-dependent.rmhjgh#h&h(hUh*}rn(h,]h-]h.]h/]h2]uh4KÍh6]roh?X~The size of the socket's low watermark for its receive buffer. The default is defined by Boost.Asio and is platform-dependent.rp…rq}rr(hjmhjkubaubah(jubeh(jubjð)rs}rt(hUh*}ru(h,]h-]h.]h/]h2]uhjµh6]rv(jõ)rw}rx(hUh*}ry(h,]h-]h.]h/]h2]uhjsh6]rzhR)r{}r|(hXsend_buffer_sizer}hjwh#h&h(hUh*}r~(h,]h-]h.]h/]h2]uh4KÐh6]rh?Xsend_buffer_sizer€…r}r‚(hj}hj{ubaubah(jubjõ)rƒ}r„(hUh*}r…(h,]h-]h.]h/]h2]uhjsh6]r†hR)r‡}rˆ(hX``int``r‰hjƒh#h&h(hUh*}rŠ(h,]h-]h.]h/]h2]uh4KÐh6]r‹hf)rŒ}r(hj‰h*}rŽ(h,]h-]h.]h/]h2]uhj‡h6]rh?Xintr…r‘}r’(hUhjŒubah(hqubaubah(jubjõ)r“}r”(hUh*}r•(h,]h-]h.]h/]h2]uhjsh6]r–hR)r—}r˜(hX€The size of the socket's send low watermark for its send buffer. The default is defined by Boost.Asio and is platform-dependent.r™hj“h#h&h(hUh*}rš(h,]h-]h.]h/]h2]uh4KÐh6]r›h?X€The size of the socket's send low watermark for its send buffer. The default is defined by Boost.Asio and is platform-dependent.rœ…r}rž(hj™hj—ubaubah(jubeh(jubjð)rŸ}r (hUh*}r¡(h,]h-]h.]h/]h2]uhjµh6]r¢(jõ)r£}r¤(hUh*}r¥(h,]h-]h.]h/]h2]uhjŸh6]r¦hR)r§}r¨(hXnon_blocking_ior©hj£h#h&h(hUh*}rª(h,]h-]h.]h/]h2]uh4KÓh6]r«h?Xnon_blocking_ior¬…r­}r®(hj©hj§ubaubah(jubjõ)r¯}r°(hUh*}r±(h,]h-]h.]h/]h2]uhjŸh6]r²hR)r³}r´(hX``bool``rµhj¯h#h&h(hUh*}r¶(h,]h-]h.]h/]h2]uh4KÓh6]r·hf)r¸}r¹(hjµh*}rº(h,]h-]h.]h/]h2]uhj³h6]r»h?Xboolr¼…r½}r¾(hUhj¸ubah(hqubaubah(jubjõ)r¿}rÀ(hUh*}rÁ(h,]h-]h.]h/]h2]uhjŸh6]rÂhR)rÃ}rÄ(hX„An optional bool to define whether the socket should use non-blocking I/O in case the platform supports it. The default is ``true``.hj¿h#h&h(hUh*}rÅ(h,]h-]h.]h/]h2]uh4KÓh6]rÆ(h?X{An optional bool to define whether the socket should use non-blocking I/O in case the platform supports it. The default is rÇ…rÈ}rÉ(hX{An optional bool to define whether the socket should use non-blocking I/O in case the platform supports it. The default is hjÃubhf)rÊ}rË(hX``true``h*}rÌ(h,]h-]h.]h/]h2]uhjÃh6]rÍh?XtruerÎ…rÏ}rÐ(hUhjÊubah(hqubh?X.…rÑ}rÒ(hX.hjÃubeubah(jubeh(jubjð)rÓ}rÔ(hUh*}rÕ(h,]h-]h.]h/]h2]uhjµh6]rÖ(jõ)r×}rØ(hUh*}rÙ(h,]h-]h.]h/]h2]uhjÓh6]rÚhR)rÛ}rÜ(hXlingerrÝhj×h#h&h(hUh*}rÞ(h,]h-]h.]h/]h2]uh4KÖh6]rßh?Xlingerrà…rá}râ(hjÝhjÛubaubah(jubjõ)rã}rä(hUh*}rå(h,]h-]h.]h/]h2]uhjÓh6]ræhR)rç}rè(hX``bool``réhjãh#h&h(hUh*}rê(h,]h-]h.]h/]h2]uh4KÖh6]rëhf)rì}rí(hjéh*}rî(h,]h-]h.]h/]h2]uhjçh6]rïh?Xboolrð…rñ}rò(hUhjìubah(hqubaubah(jubjõ)ró}rô(hUh*}rõ(h,]h-]h.]h/]h2]uhjÓh6]röhR)r÷}rø(hXAn optional bool to determine whether the socket should linger in case there's still data to be sent out at the time of its closing. The default is ``true``.hjóh#h&h(hUh*}rù(h,]h-]h.]h/]h2]uh4KÖh6]rú(h?X”An optional bool to determine whether the socket should linger in case there's still data to be sent out at the time of its closing. The default is rû…rü}rý(hX”An optional bool to determine whether the socket should linger in case there's still data to be sent out at the time of its closing. The default is hj÷ubhf)rþ}rÿ(hX``true``h*}r(h,]h-]h.]h/]h2]uhj÷h6]rh?Xtruer…r}r(hUhjþubah(hqubh?X.…r}r(hX.hj÷ubeubah(jubeh(jubjð)r}r(hUh*}r (h,]h-]h.]h/]h2]uhjµh6]r (jõ)r }r (hUh*}r (h,]h-]h.]h/]h2]uhjh6]rhR)r}r(hXlinger_timeoutrhj h#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4KÙh6]rh?Xlinger_timeoutr…r}r(hjhjubaubah(jubjõ)r}r(hUh*}r(h,]h-]h.]h/]h2]uhjh6]rhR)r}r(hX``int``rhjh#h&h(hUh*}r(h,]h-]h.]h/]h2]uh4KÙh6]rhf)r }r!(hjh*}r"(h,]h-]h.]h/]h2]uhjh6]r#h?Xintr$…r%}r&(hUhj ubah(hqubaubah(jubjõ)r'}r((hUh*}r)(h,]h-]h.]h/]h2]uhjh6]r*hR)r+}r,(hXqAn optional int to define the timeout to wait for socket closes before it is set to linger. The default is ``0``.hj'h#h&h(hUh*}r-(h,]h-]h.]h/]h2]uh4KÙh6]r.(h?XkAn optional int to define the timeout to wait for socket closes before it is set to linger. The default is r/…r0}r1(hXkAn optional int to define the timeout to wait for socket closes before it is set to linger. The default is hj+ubhf)r2}r3(hX``0``h*}r4(h,]h-]h.]h/]h2]uhj+h6]r5h?X0…r6}r7(hUhj2ubah(hqubh?X.…r8}r9(hX.hj+ubeubah(jubeh(jubeh(jRubeh(jSubaubhR)r:}r;(hX\To use the above supported named parameters, you'll have code that looks like the following:r<hj6h#h&h(hUh*}r=(h,]h-]h.]h/]h2]uh4KÝh5hh6]r>h?X\To use the above supported named parameters, you'll have code that looks like the following:r?…r@}rA(hj<hj:ubaubjó)rB}rC(hX²using namespace boost::network::http; // parameters are in this namespace handler handler_instance; async_server::options options(handler_instance); options.address("0.0.0.0") .port("80") .io_service(boost::make_shared()) .thread_pool(boost::make_shared(2)) .reuse_address(true); async_server instance(options); instance.run();hj6h#h&h(jöh*}rD(jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4Kßh5hh6]rEh?X²using namespace boost::network::http; // parameters are in this namespace handler handler_instance; async_server::options options(handler_instance); options.address("0.0.0.0") .port("80") .io_service(boost::make_shared()) .thread_pool(boost::make_shared(2)) .reuse_address(true); async_server instance(options); instance.run();rF…rG}rH(hUhjBubaubeubh)rI}rJ(hUhKhjh#h&h(h)h*}rK(h,]rLXpublic membersrMah-]h.]h/]rNUpublic-membersrOah2]uh4Kíh5hh6]rP(h8)rQ}rR(hXPublic MembersrShjIh#h&h(h(hUh*}r?(h,]h-]h.]h/]h2]uhj9h6]r@hR)rA}rB(hX Member NamerChj=h#h&h(hUh*}rD(h,]h-]h.]h/]h2]uh4M.h6]rEh?X Member NamerF…rG}rH(hjChjAubaubah(jubjõ)rI}rJ(hUh*}rK(h,]h-]h.]h/]h2]uhj9h6]rLhR)rM}rN(hXTyperOhjIh#h&h(hUh*}rP(h,]h-]h.]h/]h2]uh4M.h6]rQh?XTyperR…rS}rT(hjOhjMubaubah(jubjõ)rU}rV(hUh*}rW(h,]h-]h.]h/]h2]uhj9h6]rXhR)rY}rZ(hX Descriptionr[hjUh#h&h(hUh*}r\(h,]h-]h.]h/]h2]uh4M.h6]r]h?X Descriptionr^…r_}r`(hj[hjYubaubah(jubeh(jubah(jubj)ra}rb(hUh*}rc(h,]h-]h.]h/]h2]uhj(h6]rd(jð)re}rf(hUh*}rg(h,]h-]h.]h/]h2]uhjah6]rh(jõ)ri}rj(hUh*}rk(h,]h-]h.]h/]h2]uhjeh6]rlhR)rm}rn(hXstatusrohjih#h&h(hUh*}rp(h,]h-]h.]h/]h2]uh4M0h6]rqh?Xstatusrr…rs}rt(hjohjmubaubah(jubjõ)ru}rv(hUh*}rw(h,]h-]h.]h/]h2]uhjeh6]rxhR)ry}rz(hX``status_type``r{hjuh#h&h(hUh*}r|(h,]h-]h.]h/]h2]uh4M0h6]r}hf)r~}r(hj{h*}r€(h,]h-]h.]h/]h2]uhjyh6]rh?X status_typer‚…rƒ}r„(hUhj~ubah(hqubaubah(jubjõ)r…}r†(hUh*}r‡(h,]h-]h.]h/]h2]uhjeh6]rˆhR)r‰}rŠ(hX The HTTP status of the response.r‹hj…h#h&h(hUh*}rŒ(h,]h-]h.]h/]h2]uh4M0h6]rh?X The HTTP status of the response.rŽ…r}r(hj‹hj‰ubaubah(jubeh(jubjð)r‘}r’(hUh*}r“(h,]h-]h.]h/]h2]uhjah6]r”(jõ)r•}r–(hUh*}r—(h,]h-]h.]h/]h2]uhj‘h6]r˜hR)r™}rš(hXheadersr›hj•h#h&h(hUh*}rœ(h,]h-]h.]h/]h2]uh4M2h6]rh?Xheadersrž…rŸ}r (hj›hj™ubaubah(jubjõ)r¡}r¢(hUh*}r£(h,]h-]h.]h/]h2]uhj‘h6]r¤hR)r¥}r¦(hX``vector
``r§hj¡h#h&h(hUh*}r¨(h,]h-]h.]h/]h2]uh4M2h6]r©hf)rª}r«(hj§h*}r¬(h,]h-]h.]h/]h2]uhj¥h6]r­h?Xvector
r®…r¯}r°(hUhjªubah(hqubaubah(jubjõ)r±}r²(hUh*}r³(h,]h-]h.]h/]h2]uhj‘h6]r´hR)rµ}r¶(hXVector of headers. [#]_hj±h#h&h(hUh*}r·(h,]h-]h.]h/]h2]uh4M2h6]r¸(h?XVector of headers. r¹…rº}r»(hXVector of headers. hjµubcdocutils.nodes footnote_reference r¼)r½}r¾(hX[#]_hÝKhjµh(Ufootnote_referencer¿h*}rÀ(UautorÁKh/]rÂUid1rÃah.]h,]h-]h2]hàUid3rÄuh6]rÅh?X1…rÆ}rÇ(hUhj½ubaubeubah(jubeh(jubjð)rÈ}rÉ(hUh*}rÊ(h,]h-]h.]h/]h2]uhjah6]rË(jõ)rÌ}rÍ(hUh*}rÎ(h,]h-]h.]h/]h2]uhjÈh6]rÏhR)rÐ}rÑ(hXcontentrÒhjÌh#h&h(hUh*}rÓ(h,]h-]h.]h/]h2]uh4M4h6]rÔh?XcontentrÕ…rÖ}r×(hjÒhjÐubaubah(jubjõ)rØ}rÙ(hUh*}rÚ(h,]h-]h.]h/]h2]uhjÈh6]rÛhR)rÜ}rÝ(hX``string_type`` [#]_hjØh#h&h(hUh*}rÞ(h,]h-]h.]h/]h2]uh4M4h6]rß(hf)rà}rá(hX``string_type``h*}râ(h,]h-]h.]h/]h2]uhjÜh6]rãh?X string_typerä…rå}ræ(hUhjàubah(hqubh?X …rç}rè(hX hjÜubj¼)ré}rê(hX[#]_hÝKhjÜh(j¿h*}rë(jÁKh/]rìUid2ríah.]h,]h-]h2]hàUid4rîuh6]rïh?X2…rð}rñ(hUhjéubaubeubah(jubjõ)rò}ró(hUh*}rô(h,]h-]h.]h/]h2]uhjÈh6]rõhR)rö}r÷(hXThe contents of the response.røhjòh#h&h(hUh*}rù(h,]h-]h.]h/]h2]uh4M4h6]rúh?XThe contents of the response.rû…rü}rý(hjøhjöubaubah(jubeh(jubeh(jRubeh(jSubaubcdocutils.nodes footnote rþ)rÿ}r (hX¯A header is a struct of type ``response_header``. An instance always has the members ``name`` and ``value`` both of which are of type ``string_type``.hj¸h#h&h(Ufootnoter h*}r (jÁKh/]r jÄah.]r jÃah,]h-]h2]r U1auh4M7h5hh6]r (cdocutils.nodes label r )r }r (hUhjÿh#Nh(Ulabelr h*}r (h,]h-]h.]h/]h2]uh4Nh5hh6]r h?X1…r }r (hUhj ubaubhR)r }r (hX¯A header is a struct of type ``response_header``. An instance always has the members ``name`` and ``value`` both of which are of type ``string_type``.hjÿh#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4M7h6]r (h?XA header is a struct of type r …r }r (hXA header is a struct of type hj ubhf)r }r (hX,``response_header``h*}r (h,]h-]h.]h/]h2]uhj h6]r h?X(response_headerr …r }r (hUhj ubah(hqubh?X%. An instance always has the members r …r }r (hX%. An instance always has the members hj ubhf)r }r! (hX``name``h*}r" (h,]h-]h.]h/]h2]uhj h6]r# h?Xnamer$ …r% }r& (hUhj ubah(hqubh?X and r' …r( }r) (hX and hj ubhf)r* }r+ (hX ``value``h*}r, (h,]h-]h.]h/]h2]uhj h6]r- h?Xvaluer. …r/ }r0 (hUhj* ubah(hqubh?X both of which are of type r1 …r2 }r3 (hX both of which are of type hj ubhf)r4 }r5 (hX``string_type``h*}r6 (h,]h-]h.]h/]h2]uhj h6]r7 h?X string_typer8 …r9 }r: (hUhj4 ubah(hqubh?X.…r; }r< (hX.hj ubeubeubjþ)r= }r> (hXN``string_type`` is ``boost::network::string::type``. hj¸h#h&h(j h*}r? (jÁKh/]r@ jîah.]rA jíah,]h-]h2]rB U2auh4M:h5hh6]rC (j )rD }rE (hUhj= h#Nh(j h*}rF (h,]h-]h.]h/]h2]uh4Nh5hh6]rG h?X2…rH }rI (hUhjD ubaubhR)rJ }rK (hXM``string_type`` is ``boost::network::string::type``.hj= h#h&h(hUh*}rL (h,]h-]h.]h/]h2]uh4M:h6]rM (hf)rN }rO (hX``string_type``h*}rP (h,]h-]h.]h/]h2]uhjJ h6]rQ h?X string_typerR …rS }rT (hUhjN ubah(hqubh?X is rU …rV }rW (hX is hjJ ubhf)rX }rY (hX9``boost::network::string::type``h*}rZ (h,]h-]h.]h/]h2]uhjJ h6]r[ h?X5boost::network::string::typer\ …r] }r^ (hUhjX ubah(hqubh?X.…r_ }r` (hX.hjJ ubeubeubeubeubeubheubh#h&h(h)h*}ra (h,]h-]h.]h/]rb hìah2]rc h auh4M>h5hh6]rd (h8)re }rf (hXAsynchronous Serversrg hhh#h&h(hh5hh6]ri h?XAsynchronous Serversrj …rk }rl (hjg hje ubaubhR)rm }rn (hXyThe asynchronous server implementation is significantly different to the synchronous server implementation in three ways:ro hhh#h&h(hUh*}rp (h,]h-]h.]h/]h2]uh4M@h5hh6]rq h?XyThe asynchronous server implementation is significantly different to the synchronous server implementation in three ways:rr …rs }rt (hjo hjm ubaubhu)ru }rv (hUhhh#Nh(hxh*}rw (h,]h-]h.]h/]h2]uh4Nh5hh6]rx cdocutils.nodes enumerated_list ry )rz }r{ (hUh*}r| (Usuffixr} U.h/]h.]h,]Uprefixr~ Uh-]h2]Uenumtyper Uarabicr€ uhju h6]r (h)r‚ }rƒ (hX**The Handler instance is invoked asynchronously**. This means the I/O thread used to handle network-related events are free to handle only the I/O related events. This enables the server to scale better as to the number of concurrent connections it can handle.h*}r„ (h,]h-]h.]h/]h2]uhjz h6]r… hR)r† }r‡ (hX**The Handler instance is invoked asynchronously**. This means the I/O thread used to handle network-related events are free to handle only the I/O related events. This enables the server to scale better as to the number of concurrent connections it can handle.hj‚ h#h&h(hUh*}rˆ (h,]h-]h.]h/]h2]uh4MCh6]r‰ (hŠ)rŠ }r‹ (hX2**The Handler instance is invoked asynchronously**h*}rŒ (h,]h-]h.]h/]h2]uhj† h6]r h?X.The Handler instance is invoked asynchronouslyrŽ …r }r (hUhjŠ ubah(h’ubh?XÓ. This means the I/O thread used to handle network-related events are free to handle only the I/O related events. This enables the server to scale better as to the number of concurrent connections it can handle.r‘ …r’ }r“ (hXÓ. This means the I/O thread used to handle network-related events are free to handle only the I/O related events. This enables the server to scale better as to the number of concurrent connections it can handle.hj† ubeubah(h–ubh)r” }r• (hXÚ**The Handler is able to schedule asynchronous actions on the thread pool associated with the server.** This allows handlers to perform multiple asynchronous computations that later on perform writes to the connection.h*}r– (h,]h-]h.]h/]h2]uhjz h6]r— hR)r˜ }r™ (hXÚ**The Handler is able to schedule asynchronous actions on the thread pool associated with the server.** This allows handlers to perform multiple asynchronous computations that later on perform writes to the connection.hj” h#h&h(hUh*}rš (h,]h-]h.]h/]h2]uh4MGh6]r› (hŠ)rœ }r (hXg**The Handler is able to schedule asynchronous actions on the thread pool associated with the server.**h*}rž (h,]h-]h.]h/]h2]uhj˜ h6]rŸ h?XcThe Handler is able to schedule asynchronous actions on the thread pool associated with the server.r  …r¡ }r¢ (hUhjœ ubah(h’ubh?Xs This allows handlers to perform multiple asynchronous computations that later on perform writes to the connection.r£ …r¤ }r¥ (hXs This allows handlers to perform multiple asynchronous computations that later on perform writes to the connection.hj˜ ubeubah(h–ubh)r¦ }r§ (hX**The Handler is able to control the (asynchronous) writes to and reads from the HTTP connection.** Because the connection is available to the Handler, that means it can write out chunks of data at a time or stream data through the connection continuously. h*}r¨ (h,]h-]h.]h/]h2]uhjz h6]r© hR)rª }r« (hX**The Handler is able to control the (asynchronous) writes to and reads from the HTTP connection.** Because the connection is available to the Handler, that means it can write out chunks of data at a time or stream data through the connection continuously.hj¦ h#h&h(hUh*}r¬ (h,]h-]h.]h/]h2]uh4MJh6]r­ (hŠ)r® }r¯ (hXc**The Handler is able to control the (asynchronous) writes to and reads from the HTTP connection.**h*}r° (h,]h-]h.]h/]h2]uhjª h6]r± h?X_The Handler is able to control the (asynchronous) writes to and reads from the HTTP connection.r² …r³ }r´ (hUhj® ubah(h’ubh?X Because the connection is available to the Handler, that means it can write out chunks of data at a time or stream data through the connection continuously.rµ …r¶ }r· (hX Because the connection is available to the Handler, that means it can write out chunks of data at a time or stream data through the connection continuously.hjª ubeubah(h–ubeh(Uenumerated_listr¸ ubaubhR)r¹ }rº (hX‰The asynchronous server is meant to allow for better scalability in terms of the number of concurrent connections and for performing asynchronous actions within the handlers. If your application does not need to write out information asynchronously or perform potentially long computations, then the synchronous server gives a generally better performance profile than the asynchronous server.r» hhh#h&h(hUh*}r¼ (h,]h-]h.]h/]h2]uh4MOh5hh6]r½ h?X‰The asynchronous server is meant to allow for better scalability in terms of the number of concurrent connections and for performing asynchronous actions within the handlers. If your application does not need to write out information asynchronously or perform potentially long computations, then the synchronous server gives a generally better performance profile than the asynchronous server.r¾ …r¿ }rÀ (hj» hj¹ ubaubhR)rÁ }r (hXThe asynchronous server implementation is available from a single user-facing template named ``async_server``. This template takes in a single template parameter which is the type of the Handler to be called once a request has been parsed from a connection.hhh#h&h(hUh*}rà (h,]h-]h.]h/]h2]uh4MVh5hh6]rÄ (h?X]The asynchronous server implementation is available from a single user-facing template named rÅ …rÆ }rÇ (hX]The asynchronous server implementation is available from a single user-facing template named hjÁ ubhf)rÈ }rÉ (hX``async_server``h*}rÊ (h,]h-]h.]h/]h2]uhjÁ h6]rË h?X async_serverrÌ …rÍ }rÎ (hUhjÈ ubah(hqubh?X”. This template takes in a single template parameter which is the type of the Handler to be called once a request has been parsed from a connection.rÏ …rÐ }rÑ (hX”. This template takes in a single template parameter which is the type of the Handler to be called once a request has been parsed from a connection.hjÁ ubeubhR)rÒ }rÓ (hXsAn instance of Handler is taken as a reference to the constructor similar to the synchronous server implementation.rÔ hhh#h&h(hUh*}rÕ (h,]h-]h.]h/]h2]uh4M[h5hh6]rÖ h?XsAn instance of Handler is taken as a reference to the constructor similar to the synchronous server implementation.r× …rØ }rÙ (hjÔ hjÒ ubaubjÝ)rÚ }rÛ (hXQThe asynchronous server implementation, like the synchronous server implementation, does not perform any synchronization on the calls to the Handler invocation. This means if your handler contains or maintains internal state, you are responsible for implementing your own synchronization on accesses to the internal state of the Handler.hhh#h&h(jàh*}rÜ (h,]h-]h.]h/]h2]uh4Nh5hh6]rÝ hR)rÞ }rß (hXQThe asynchronous server implementation, like the synchronous server implementation, does not perform any synchronization on the calls to the Handler invocation. This means if your handler contains or maintains internal state, you are responsible for implementing your own synchronization on accesses to the internal state of the Handler.rà hjÚ h#h&h(hUh*}rá (h,]h-]h.]h/]h2]uh4M^h6]râ h?XQThe asynchronous server implementation, like the synchronous server implementation, does not perform any synchronization on the calls to the Handler invocation. This means if your handler contains or maintains internal state, you are responsible for implementing your own synchronization on accesses to the internal state of the Handler.rã …rä }rå (hjà hjÞ ubaubaubhR)ræ }rç (hXKThe general pattern for using the ``async_server`` template is shown below:rè hhh#h&h(hUh*}ré (h,]h-]h.]h/]h2]uh4Mdh5hh6]rê (h?X"The general pattern for using the rë …rì }rí (hX"The general pattern for using the hjæ ubhf)rî }rï (hX``async_server``h*}rð (h,]h-]h.]h/]h2]uhjæ h6]rñ h?X async_serverrò …ró }rô (hUhjî ubah(hqubh?X template is shown below:rõ …rö }r÷ (hX template is shown below:hjæ ubeubjó)rø }rù (hX`struct handler; typedef boost::network::http::async_server http_server; struct handler { void operator()( http_server::request const & req, http_server::connection_ptr connection ) { // handle the request here, and use the connection to // either read more data or write data out to the client } };hhh#h&h(jöh*}rú (jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4Mfh5hh6]rû h?X`struct handler; typedef boost::network::http::async_server http_server; struct handler { void operator()( http_server::request const & req, http_server::connection_ptr connection ) { // handle the request here, and use the connection to // either read more data or write data out to the client } };rü …rý }rþ (hUhjø ubaubheubh#h&h(h)h*}rÿ (h,]r j ah-]h.]h/]r Uid5r ah2]uh4Mvh5hh6]r (h8)r }r (hXAPI Documentationr hhh#h&h(h #include hhh#h&h(jöh*}r (jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4Mzh5hh6]r h?X_#include #include r …r }r (hUhj ubaubhR)r }r (hX8And that the following typedef's have been put in place:r hhh#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4Mh5hh6]r h?X8And that the following typedef's have been put in place:r …r! }r" (hj hj ubaubjó)r# }r$ (hX struct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()( http_server::request const & request, http_server::connection_ptr connection ) { // do something here } };hhh#h&h(jöh*}r% (jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4Mh5hh6]r& h?X struct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()( http_server::request const & request, http_server::connection_ptr connection ) { // do something here } };r' …r( }r) (hUhj# ubaubh)r* }r+ (hUhKhhh#h&h(h)h*}r, (h,]r- j:ah-]h.]h/]r. Uid6r/ ah2]uh4Mh5hh6]r0 (h8)r1 }r2 (hX Constructorr3 hj* h#h&h(h (hX|``explicit http_server(options)`` Construct an HTTP server instance passing in a ``server_options`` instance. hj9 h#h&h(jFh*}r? (h,]h-]h.]h/]h2]uh4M”h6]r@ (jI)rA }rB (hX!``explicit http_server(options)``rC hj= h#h&h(jLh*}rD (h,]h-]h.]h/]h2]uh4M”h6]rE hf)rF }rG (hjC h*}rH (h,]h-]h.]h/]h2]uhjA h6]rI h?Xexplicit http_server(options)rJ …rK }rL (hUhjF ubah(hqubaubjQ)rM }rN (hUh*}rO (h,]h-]h.]h/]h2]uhj= h6]rP hR)rQ }rR (hXYConstruct an HTTP server instance passing in a ``server_options`` instance.hjM h#h&h(hUh*}rS (h,]h-]h.]h/]h2]uh4M“h6]rT (h?X/Construct an HTTP server instance passing in a rU …rV }rW (hX/Construct an HTTP server instance passing in a hjQ ubhf)rX }rY (hX ``server_options``h*}rZ (h,]h-]h.]h/]h2]uhjQ h6]r[ h?Xserver_optionsr\ …r] }r^ (hUhjX ubah(hqubh?X instance.r_ …r` }ra (hX instance.hjQ ubeubah(j^ubeubaubeubh)rb }rc (hUhKhhh#h&h(h)h*}rd (h,]re jMah-]h.]h/]rf Uid7rg ah2]uh4M—h5hh6]rh (h8)ri }rj (hXPublic Membersrk hjb h#h&h(h(2)); http_server server(options.address("127.0.0.1").port("8000"));hjb h#h&h(jöh*}r„ (jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4Mœh5hh6]r… h?XËhandler_type handler; http_server::options options(handler); options.thread_pool(boost::make_shared(2)); http_server server(options.address("127.0.0.1").port("8000"));r† …r‡ }rˆ (hUhj‚ ubaubj=)r‰ }rŠ (hUhjb h#h&h(j@h*}r‹ (h,]h-]h.]h/]h2]uh4Nh5hh6]rŒ jC)r }rŽ (hXu``server.run()`` Run the HTTP Server event loop. This function can be run on multiple threads following the example: hj‰ h#h&h(jFh*}r (h,]h-]h.]h/]h2]uh4M¥h6]r (jI)r‘ }r’ (hX``server.run()``r“ hj h#h&h(jLh*}r” (h,]h-]h.]h/]h2]uh4M¥h6]r• hf)r– }r— (hj“ h*}r˜ (h,]h-]h.]h/]h2]uhj‘ h6]r™ h?X server.run()rš …r› }rœ (hUhj– ubah(hqubaubjQ)r }rž (hUh*}rŸ (h,]h-]h.]h/]h2]uhj h6]r  hR)r¡ }r¢ (hXcRun the HTTP Server event loop. This function can be run on multiple threads following the example:r£ hj h#h&h(hUh*}r¤ (h,]h-]h.]h/]h2]uh4M¤h6]r¥ h?XcRun the HTTP Server event loop. This function can be run on multiple threads following the example:r¦ …r§ }r¨ (hj£ hj¡ ubaubah(j^ubeubaubjó)r© }rª (hX™boost::thread t1(boost::bind(&http_server::run, &server)); boost::thread t2(boost::bind(&http_server::run, &server)); server.run(); t1.join(); t2.join();hjb h#h&h(jöh*}r« (jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4M§h5hh6]r¬ h?X™boost::thread t1(boost::bind(&http_server::run, &server)); boost::thread t2(boost::bind(&http_server::run, &server)); server.run(); t1.join(); t2.join();r­ …r® }r¯ (hUhj© ubaubj=)r° }r± (hUhjb h#h&h(j@h*}r² (h,]h-]h.]h/]h2]uh4Nh5hh6]r³ jC)r´ }rµ (hX]``server.stop()`` Stop the HTTP Server acceptor and wait for all pending requests to finish. hj° h#h&h(jFh*}r¶ (h,]h-]h.]h/]h2]uh4M°h6]r· (jI)r¸ }r¹ (hX``server.stop()``rº hj´ h#h&h(jLh*}r» (h,]h-]h.]h/]h2]uh4M°h6]r¼ hf)r½ }r¾ (hjº h*}r¿ (h,]h-]h.]h/]h2]uhj¸ h6]rÀ h?X server.stop()rÁ …r }rà (hUhj½ ubah(hqubaubjQ)rÄ }rÅ (hUh*}rÆ (h,]h-]h.]h/]h2]uhj´ h6]rÇ hR)rÈ }rÉ (hXJStop the HTTP Server acceptor and wait for all pending requests to finish.rÊ hjÄ h#h&h(hUh*}rË (h,]h-]h.]h/]h2]uh4M°h6]rÌ h?XJStop the HTTP Server acceptor and wait for all pending requests to finish.rÍ …rÎ }rÏ (hjÊ hjÈ ubaubah(j^ubeubaubeubh)rÐ }rÑ (hUhhh#h&h(h)h*}rÒ (h,]h-]h.]h/]rÓ Uconnection-objectrÔ ah2]rÕ hauh4M³h5hh6]rÖ (h8)r× }rØ (hXConnection ObjectrÙ hjÐ h#h&h(h write(Range range)`` The connection object exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept. The write function, although it looks synchronous, starts of a series of asynchronous writes to the connection as soon as the range is serialized to appropriately sized buffers. To use this in your handler, it would look something like this: hjç h#h&h(jFh*}rí (h,]h-]h.]h/]h2]uh4M¿h6]rî (jI)rï }rð (hX-``template write(Range range)``rñ hjë h#h&h(jLh*}rò (h,]h-]h.]h/]h2]uh4M¿h6]ró hf)rô }rõ (hjñ h*}rö (h,]h-]h.]h/]h2]uhjï h6]r÷ h?X)template write(Range range)rø …rù }rú (hUhjô ubah(hqubaubjQ)rû }rü (hUh*}rý (h,]h-]h.]h/]h2]uhjë h6]rþ (hR)rÿ }r (hXBThe connection object exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept. The write function, although it looks synchronous, starts of a series of asynchronous writes to the connection as soon as the range is serialized to appropriately sized buffers.hjû h#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4M¹h6]r (h?X)The connection object exposes a function r …r }r (hX)The connection object exposes a function hjÿ ubhf)r }r (hX ``write``h*}r (h,]h-]h.]h/]h2]uhjÿ h6]r h?Xwriter …r }r (hUhj ubah(hqubh?X3 that can be given a parameter that adheres to the r …r }r (hX3 that can be given a parameter that adheres to the hjÿ ubhÚ)r }r (hX Boost.Range_hÝKhjÿ h(hÞh*}r (UnameX Boost.RangeUrefurir Xhttp://www.boost.org/libs/ranger h/]h.]h,]h-]h2]uh6]r h?X Boost.Ranger …r }r (hUhj ubaubh?X …r }r (hX hjÿ ubhf)r }r (hX``Single Pass Range``h*}r (h,]h-]h.]h/]h2]uhjÿ h6]r h?XSingle Pass Ranger …r }r! (hUhj ubah(hqubh?X» Concept. The write function, although it looks synchronous, starts of a series of asynchronous writes to the connection as soon as the range is serialized to appropriately sized buffers.r" …r# }r$ (hX» Concept. The write function, although it looks synchronous, starts of a series of asynchronous writes to the connection as soon as the range is serialized to appropriately sized buffers.hjÿ ubeubhR)r% }r& (hX?To use this in your handler, it would look something like this:r' hjû h#h&h(hUh*}r( (h,]h-]h.]h/]h2]uh4M¿h6]r) h?X?To use this in your handler, it would look something like this:r* …r+ }r, (hj' hj% ubaubeh(j^ubeubaubjó)r- }r. (hXgconnection->write("Hello, world!"); std::string sample = "I have a string!"; connection->write(sample);hjÐ h#h&h(jöh*}r/ (jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4MÁh5hh6]r0 h?Xgconnection->write("Hello, world!"); std::string sample = "I have a string!"; connection->write(sample);r1 …r2 }r3 (hUhj- ubaubj=)r4 }r5 (hUhjÐ h#h&h(j@h*}r6 (h,]h-]h.]h/]h2]uh4Nh5hh6]r7 (jC)r8 }r9 (hX ``template void write(Range range, Callback callback)`` The connection object also exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept, as well as a Callback function that returns ``void`` and takes a ``boost::system::error_code`` as a parameter. This overload of ``write`` is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory right away. hj4 h#h&h(jFh*}r: (h,]h-]h.]h/]h2]uh4MÍh6]r; (jI)r< }r= (hXU``template void write(Range range, Callback callback)``r> hj8 h#h&h(jLh*}r? (h,]h-]h.]h/]h2]uh4MÍh6]r@ hf)rA }rB (hj> h*}rC (h,]h-]h.]h/]h2]uhj< h6]rD h?XQtemplate void write(Range range, Callback callback)rE …rF }rG (hUhjA ubah(hqubaubjQ)rH }rI (hUh*}rJ (h,]h-]h.]h/]h2]uhj8 h6]rK hR)rL }rM (hX³The connection object also exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept, as well as a Callback function that returns ``void`` and takes a ``boost::system::error_code`` as a parameter. This overload of ``write`` is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory right away.hjH h#h&h(hUh*}rN (h,]h-]h.]h/]h2]uh4MÈh6]rO (h?X.The connection object also exposes a function rP …rQ }rR (hX.The connection object also exposes a function hjL ubhf)rS }rT (hX ``write``h*}rU (h,]h-]h.]h/]h2]uhjL h6]rV h?XwriterW …rX }rY (hUhjS ubah(hqubh?X3 that can be given a parameter that adheres to the rZ …r[ }r\ (hX3 that can be given a parameter that adheres to the hjL ubhÚ)r] }r^ (hX Boost.Range_hÝKhjL h(hÞh*}r_ (UnameX Boost.Rangej j h/]h.]h,]h-]h2]uh6]r` h?X Boost.Rangera …rb }rc (hUhj] ubaubh?X …rd }re (hX hjL ubhf)rf }rg (hX``Single Pass Range``h*}rh (h,]h-]h.]h/]h2]uhjL h6]ri h?XSingle Pass Rangerj …rk }rl (hUhjf ubah(hqubh?X6 Concept, as well as a Callback function that returns rm …rn }ro (hX6 Concept, as well as a Callback function that returns hjL ubhf)rp }rq (hX``void``h*}rr (h,]h-]h.]h/]h2]uhjL h6]rs h?Xvoidrt …ru }rv (hUhjp ubah(hqubh?X and takes a rw …rx }ry (hX and takes a hjL ubhf)rz }r{ (hX``boost::system::error_code``h*}r| (h,]h-]h.]h/]h2]uhjL h6]r} h?Xboost::system::error_coder~ …r }r€ (hUhjz ubah(hqubh?X" as a parameter. This overload of r …r‚ }rƒ (hX" as a parameter. This overload of hjL ubhf)r„ }r… (hX ``write``h*}r† (h,]h-]h.]h/]h2]uhjL h6]r‡ h?Xwriterˆ …r‰ }rŠ (hUhj„ ubah(hqubh?X” is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory right away.r‹ …rŒ }r (hX” is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory right away.hjL ubeubah(j^ubeubjC)rŽ }r (hXU``template void read(ReadCallback callback)`` The connection object has a function ``read`` which can be used to read more information from the connection. This ``read`` function takes in a callback that can be assigned to a Boost.Function_ with the signature ``void(input_range,error_code,size_t,connection_ptr)``. The following list shows what the types actually mean: * **input_range** -- ``boost::iterator_range`` : The range that denotes the data read from the connection. * **error_code** -- ``boost::system::error_code`` : The error code if there were any errors encountered from the read. * **size_t** -- ``std::size_t`` : The number of bytes transferred. * **connection_ptr** -- ``http_server::connection_ptr`` : A handle to the current connection, so that it is kept alive at the time of the read callback invocation. This interface is useful when doing reads of uploaded data that can be potentially large and may not fit in memory. The read handler is then responsible for dealing with the chunks of data available from the connection. hj4 h#h&h(jFh*}r (h,]h-]h.]h/]h2]uh4Mâh5hh6]r‘ (jI)r’ }r“ (hXB``template void read(ReadCallback callback)``r” hjŽ h#h&h(jLh*}r• (h,]h-]h.]h/]h2]uh4Mâh6]r– hf)r— }r˜ (hj” h*}r™ (h,]h-]h.]h/]h2]uhj’ h6]rš h?X>template void read(ReadCallback callback)r› …rœ }r (hUhj— ubah(hqubaubjQ)rž }rŸ (hUh*}r  (h,]h-]h.]h/]h2]uhjŽ h6]r¡ (hR)r¢ }r£ (hXDThe connection object has a function ``read`` which can be used to read more information from the connection. This ``read`` function takes in a callback that can be assigned to a Boost.Function_ with the signature ``void(input_range,error_code,size_t,connection_ptr)``. The following list shows what the types actually mean:hjž h#h&h(hUh*}r¤ (h,]h-]h.]h/]h2]uh4MÐh6]r¥ (h?X%The connection object has a function r¦ …r§ }r¨ (hX%The connection object has a function hj¢ ubhf)r© }rª (hX``read``h*}r« (h,]h-]h.]h/]h2]uhj¢ h6]r¬ h?Xreadr­ …r® }r¯ (hUhj© ubah(hqubh?XF which can be used to read more information from the connection. This r° …r± }r² (hXF which can be used to read more information from the connection. This hj¢ ubhf)r³ }r´ (hX``read``h*}rµ (h,]h-]h.]h/]h2]uhj¢ h6]r¶ h?Xreadr· …r¸ }r¹ (hUhj³ ubah(hqubh?X8 function takes in a callback that can be assigned to a rº …r» }r¼ (hX8 function takes in a callback that can be assigned to a hj¢ ubhÚ)r½ }r¾ (hXBoost.Function_hÝKhj¢ h(hÞh*}r¿ (UnameXBoost.Functionj X"http://www.boost.org/libs/functionrÀ h/]h.]h,]h-]h2]uh6]rÁ h?XBoost.Functionr …rà }rÄ (hUhj½ ubaubh?X with the signature rÅ …rÆ }rÇ (hX with the signature hj¢ ubhf)rÈ }rÉ (hX6``void(input_range,error_code,size_t,connection_ptr)``h*}rÊ (h,]h-]h.]h/]h2]uhj¢ h6]rË h?X2void(input_range,error_code,size_t,connection_ptr)rÌ …rÍ }rÎ (hUhjÈ ubah(hqubh?X8. The following list shows what the types actually mean:rÏ …rÐ }rÑ (hX8. The following list shows what the types actually mean:hj¢ ubeubhu)rÒ }rÓ (hUh*}rÔ (h,]h-]h.]h/]h2]uhjž h6]rÕ h{)rÖ }r× (hUh*}rØ (hX*h/]h.]h,]h-]h2]uhjÒ h6]rÙ (h)rÚ }rÛ (hXv**input_range** -- ``boost::iterator_range`` : The range that denotes the data read from the connection.h*}rÜ (h,]h-]h.]h/]h2]uhjÖ h6]rÝ hR)rÞ }rß (hXv**input_range** -- ``boost::iterator_range`` : The range that denotes the data read from the connection.hjÚ h#h&h(hUh*}rà (h,]h-]h.]h/]h2]uh4MÖh6]rá (hŠ)râ }rã (hX**input_range**h*}rä (h,]h-]h.]h/]h2]uhjÞ h6]rå h?X input_rangeræ …rç }rè (hUhjâ ubah(h’ubh?X -- ré …rê }rë (hX -- hjÞ ubhf)rì }rí (hX'``boost::iterator_range``h*}rî (h,]h-]h.]h/]h2]uhjÞ h6]rï h?X#boost::iterator_rangerð …rñ }rò (hUhjì ubah(hqubh?X< : The range that denotes the data read from the connection.ró …rô }rõ (hX< : The range that denotes the data read from the connection.hjÞ ubeubah(h–ubh)rö }r÷ (hXt**error_code** -- ``boost::system::error_code`` : The error code if there were any errors encountered from the read.h*}rø (h,]h-]h.]h/]h2]uhjÖ h6]rù hR)rú }rû (hXt**error_code** -- ``boost::system::error_code`` : The error code if there were any errors encountered from the read.hjö h#h&h(hUh*}rü (h,]h-]h.]h/]h2]uh4MØh6]rý (hŠ)rþ }rÿ (hX**error_code**h*}r (h,]h-]h.]h/]h2]uhjú h6]r h?X error_coder …r }r (hUhjþ ubah(h’ubh?X -- r …r }r (hX -- hjú ubhf)r }r (hX``boost::system::error_code``h*}r (h,]h-]h.]h/]h2]uhjú h6]r h?Xboost::system::error_coder …r }r (hUhj ubah(hqubh?XE : The error code if there were any errors encountered from the read.r …r }r (hXE : The error code if there were any errors encountered from the read.hjú ubeubah(h–ubh)r }r (hX@**size_t** -- ``std::size_t`` : The number of bytes transferred.r h*}r (h,]h-]h.]h/]h2]uhjÖ h6]r hR)r }r (hj hj h#h&h(hUh*}r (h,]h-]h.]h/]h2]uh4MÚh6]r (hŠ)r }r (hX **size_t**h*}r (h,]h-]h.]h/]h2]uhj h6]r h?Xsize_tr …r }r! (hUhj ubah(h’ubh?X -- r" …r# }r$ (hX -- hj ubhf)r% }r& (hX``std::size_t``h*}r' (h,]h-]h.]h/]h2]uhj h6]r( h?X std::size_tr) …r* }r+ (hUhj% ubah(hqubh?X# : The number of bytes transferred.r, …r- }r. (hX# : The number of bytes transferred.hj ubeubah(h–ubh)r/ }r0 (hX¢**connection_ptr** -- ``http_server::connection_ptr`` : A handle to the current connection, so that it is kept alive at the time of the read callback invocation. h*}r1 (h,]h-]h.]h/]h2]uhjÖ h6]r2 hR)r3 }r4 (hX¡**connection_ptr** -- ``http_server::connection_ptr`` : A handle to the current connection, so that it is kept alive at the time of the read callback invocation.hj/ h#h&h(hUh*}r5 (h,]h-]h.]h/]h2]uh4MÛh6]r6 (hŠ)r7 }r8 (hX**connection_ptr**h*}r9 (h,]h-]h.]h/]h2]uhj3 h6]r: h?Xconnection_ptrr; …r< }r= (hUhj7 ubah(h’ubh?X -- r> …r? }r@ (hX -- hj3 ubhf)rA }rB (hX``http_server::connection_ptr``h*}rC (h,]h-]h.]h/]h2]uhj3 h6]rD h?Xhttp_server::connection_ptrrE …rF }rG (hUhjA ubah(hqubh?Xl : A handle to the current connection, so that it is kept alive at the time of the read callback invocation.rH …rI }rJ (hXl : A handle to the current connection, so that it is kept alive at the time of the read callback invocation.hj3 ubeubah(h–ubeh(h»ubah(hxubhR)rK }rL (hXÛThis interface is useful when doing reads of uploaded data that can be potentially large and may not fit in memory. The read handler is then responsible for dealing with the chunks of data available from the connection.rM hjž h#h&h(hUh*}rN (h,]h-]h.]h/]h2]uh4Mßh6]rO h?XÛThis interface is useful when doing reads of uploaded data that can be potentially large and may not fit in memory. The read handler is then responsible for dealing with the chunks of data available from the connection.rP …rQ }rR (hjM hjK ubaubeh(j^ubeubjC)rS }rT (hXÖ``void set_status(status_t new_status)`` The ``set_status`` function takes a parameter of type ``status_t`` which is an enum type nested in ``http_status::connection`` which is given in the following code listing. hj4 h#h&h(jFh*}rU (h,]h-]h.]h/]h2]uh4Mçh5hh6]rV (jI)rW }rX (hX(``void set_status(status_t new_status)``rY hjS h#h&h(jLh*}rZ (h,]h-]h.]h/]h2]uh4Mçh6]r[ hf)r\ }r] (hjY h*}r^ (h,]h-]h.]h/]h2]uhjW h6]r_ h?X$void set_status(status_t new_status)r` …ra }rb (hUhj\ ubah(hqubaubjQ)rc }rd (hUh*}re (h,]h-]h.]h/]h2]uhjS h6]rf hR)rg }rh (hX¬The ``set_status`` function takes a parameter of type ``status_t`` which is an enum type nested in ``http_status::connection`` which is given in the following code listing.hjc h#h&h(hUh*}ri (h,]h-]h.]h/]h2]uh4Måh6]rj (h?XThe rk …rl }rm (hXThe hjg ubhf)rn }ro (hX``set_status``h*}rp (h,]h-]h.]h/]h2]uhjg h6]rq h?X set_statusrr …rs }rt (hUhjn ubah(hqubh?X$ function takes a parameter of type ru …rv }rw (hX$ function takes a parameter of type hjg ubhf)rx }ry (hX ``status_t``h*}rz (h,]h-]h.]h/]h2]uhjg h6]r{ h?Xstatus_tr| …r} }r~ (hUhjx ubah(hqubh?X! which is an enum type nested in r …r€ }r (hX! which is an enum type nested in hjg ubhf)r‚ }rƒ (hX``http_status::connection``h*}r„ (h,]h-]h.]h/]h2]uhjg h6]r… h?Xhttp_status::connectionr† …r‡ }rˆ (hUhj‚ ubah(hqubh?X. which is given in the following code listing.r‰ …rŠ }r‹ (hX. which is given in the following code listing.hjg ubeubah(j^ubeubeubjó)rŒ }r (hXÙenum status_t { ok = 200 , created = 201 , accepted = 202 , no_content = 204 , multiple_choices = 300 , moved_permanently = 301 , moved_temporarily = 302 , not_modified = 304 , bad_request = 400 , unauthorized = 401 , forbidden = 403 , not_found = 404 , not_supported = 405 , not_acceptable = 406 , internal_server_error = 500 , not_implemented = 501 , bad_gateway = 502 , service_unavailable = 503 };hjÐ h#h&h(jöh*}rŽ (jø‰jùXc++jújûh/]h.]h,]h-]h2]uh4Méh5hh6]r h?XÙenum status_t { ok = 200 , created = 201 , accepted = 202 , no_content = 204 , multiple_choices = 300 , moved_permanently = 301 , moved_temporarily = 302 , not_modified = 304 , bad_request = 400 , unauthorized = 401 , forbidden = 403 , not_found = 404 , not_supported = 405 , not_acceptable = 406 , internal_server_error = 500 , not_implemented = 501 , bad_gateway = 502 , service_unavailable = 503 };r …r‘ }r’ (hUhjŒ ubaubcdocutils.nodes note r“ )r” }r• (hXéYou may set and re-set the status several times as long as you have not set the headers or sent data through the connection. If you do this after data has already been set, the function will throw an instance of ``std::logic_error``.hjÐ h#h&h(Unoter– h*}r— (h,]h-]h.]h/]h2]uh4Nh5hh6]r˜ hR)r™ }rš (hXéYou may set and re-set the status several times as long as you have not set the headers or sent data through the connection. If you do this after data has already been set, the function will throw an instance of ``std::logic_error``.hj” h#h&h(hUh*}r› (h,]h-]h.]h/]h2]uh4Mh6]rœ (h?XÔYou may set and re-set the status several times as long as you have not set the headers or sent data through the connection. If you do this after data has already been set, the function will throw an instance of r …rž }rŸ (hXÔYou may set and re-set the status several times as long as you have not set the headers or sent data through the connection. If you do this after data has already been set, the function will throw an instance of hj™ ubhf)r  }r¡ (hX``std::logic_error``h*}r¢ (h,]h-]h.]h/]h2]uhj™ h6]r£ h?Xstd::logic_errorr¤ …r¥ }r¦ (hUhj  ubah(hqubh?X.…r§ }r¨ (hX.hj™ ubeubaubj=)r© }rª (hUhjÐ h#h&h(j@h*}r« (h,]h-]h.]h/]h2]uh4Nh5hh6]r¬ jC)r­ }r® (hXï``template void set_headers(Range range)`` The ``set_headers`` function takes a Single Pass Range of ``boost::network::http::response_header`` instances and linearizes them to a buffer with at most ``BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE`` and immediately schedules an asynchronous write once that is done. The function throws an instance of ``std::logic_error`` if you try to set the headers for a connection more than once. hj© h#h&h(jFh*}r¯ (h,]h-]h.]h/]h2]uh4Mh6]r° (jI)r± }r² (hX8``template void set_headers(Range range)``r³ hj­ h#h&h(jLh*}r´ (h,]h-]h.]h/]h2]uh4Mh6]rµ hf)r¶ }r· (hj³ h*}r¸ (h,]h-]h.]h/]h2]uhj± h6]r¹ h?X4template void set_headers(Range range)rº …r» }r¼ (hUhj¶ ubah(hqubaubjQ)r½ }r¾ (hUh*}r¿ (h,]h-]h.]h/]h2]uhj­ h6]rÀ (hR)rÁ }r (hX<The ``set_headers`` function takes a Single Pass Range of ``boost::network::http::response_header`` instances and linearizes them to a buffer with at most ``BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE`` and immediately schedules an asynchronous write once that is done.hj½ h#h&h(hUh*}rà (h,]h-]h.]h/]h2]uh4Mh6]rÄ (h?XThe rÅ …rÆ }rÇ (hXThe hjÁ ubhf)rÈ }rÉ (hX``set_headers``h*}rÊ (h,]h-]h.]h/]h2]uhjÁ h6]rË h?X set_headersrÌ …rÍ }rÎ (hUhjÈ ubah(hqubh?X' function takes a Single Pass Range of rÏ …rÐ }rÑ (hX' function takes a Single Pass Range of hjÁ ubhf)rÒ }rÓ (hXH``boost::network::http::response_header``h*}rÔ (h,]h-]h.]h/]h2]uhjÁ h6]rÕ h?XDboost::network::http::response_headerrÖ …r× }rØ (hUhjÒ ubah(hqubh?X8 instances and linearizes them to a buffer with at most rÙ …rÚ }rÛ (hX8 instances and linearizes them to a buffer with at most hjÁ ubhf)rÜ }rÝ (hX?``BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE``h*}rÞ (h,]h-]h.]h/]h2]uhjÁ h6]rß h?X;BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZErà …rá }râ (hUhjÜ ubah(hqubh?XC and immediately schedules an asynchronous write once that is done.rã …rä }rå (hXC and immediately schedules an asynchronous write once that is done.hjÁ ubeubhR)ræ }rç (hXvThe function throws an instance of ``std::logic_error`` if you try to set the headers for a connection more than once.hj½ h#h&h(hUh*}rè (h,]h-]h.]h/]h2]uh4M h6]ré (h?X#The function throws an instance of rê …rë }rì (hX#The function throws an instance of hjæ ubhf)rí }rî (hX``std::logic_error``h*}rï (h,]h-]h.]h/]h2]uhjæ h6]rð h?Xstd::logic_errorrñ …rò }ró (hUhjí ubah(hqubh?X? if you try to set the headers for a connection more than once.rô …rõ }rö (hX? if you try to set the headers for a connection more than once.hjæ ubeubeh(j^ubeubaubcdocutils.nodes target r÷ )rø }rù (hX0.. _Boost.Range: http://www.boost.org/libs/rangehKhjÐ h#h&h(Utargetrú h*}rû (j j h/]rü U boost-rangerý ah.]h,]h-]h2]rþ h auh4Mh5hh6]ubj÷ )rÿ }r (hX6.. _Boost.Function: http://www.boost.org/libs/functionhKhjÐ h#h&h(jú h*}r (j jÀ h/]r Uboost-functionr ah.]h,]h-]h2]r hauh4Mh5hh6]ubeubeubh#h&h(Usystem_messager h*}r (h,]UlevelKh/]h.]r j aUsourceh&h-]h2]UlineMvUtypeUINFOr uh4Mvh5hh6]r hR)r }r (hUh*}r (h,]h-]h.]h/]h2]uhhh6]r h?X4Duplicate implicit target name: "api documentation".r …r }r (hUhj ubah(hUubaubh)r }r (hUhj* h#h&h(j h*}r (h,]UlevelKh/]h.]r j/ aUsourceh&h-]h2]UlineMUtypej uh4Mh5hh6]r hR)r }r (hUh*}r (h,]h-]h.]h/]h2]uhj h6]r h?X.Duplicate implicit target name: "constructor".r …r }r (hUhj ubah(hUubaubh)r }r (hUhjb h#h&h(j h*}r (h,]UlevelKh/]h.]r jg aUsourceh&h-]h2]UlineM—Utypej uh4M—h5hh6]r! hR)r" }r# (hUh*}r$ (h,]h-]h.]h/]h2]uhj h6]r% h?X1Duplicate implicit target name: "public members".r& …r' }r( (hUhj" ubah(hUubaubeUcurrent_sourcer) NU decorationr* NUautofootnote_startr+ KUnameidsr, }r- (hj hháhh1h Nh jý h hÈh hGU1jÄU2jîh hìhNhj¼hjÔ hNuh6]r. h!ahUU transformerr/ NU footnote_refsr0 }r1 Urefnamesr2 }r3 (Xasynchronous servers]r4 (héjljŽeXboost.function]r5 j½ aXsynchronous servers]r6 (hÛjj!j[eX boost.range]r7 (j j] euUsymbol_footnotesr8 ]r9 Uautofootnote_refsr: ]r; (j½jéeUsymbol_footnote_refsr< ]r= U citationsr> ]r? h5hU current_liner@ NUtransform_messagesrA ]rB UreporterrC NUid_startrD KU autofootnotesrE ]rF (jÿj= eU citation_refsrG }rH Uindirect_targetsrI ]rJ UsettingsrK (cdocutils.frontend Values rL orM }rN (Ufootnote_backlinksrO KUrecord_dependenciesrP NU rfc_base_urlrQ Uhttp://tools.ietf.org/html/rR U tracebackrS ˆUpep_referencesrT NUstrip_commentsrU NU toc_backlinksrV jU language_coderW UenrX U datestamprY NU report_levelrZ KU _destinationr[ NU halt_levelr\ KU strip_classesr] Nh}q?(h(X Referencesq@h)h&h*h-h/UtitleqAh1}qB(h3]h4]h5]h6]h8]uh:Kh;hh#]qCcdocutils.nodes Text qDX ReferencesqE…qF}qG(h(h@h)h>ubaubh%)qH}qI(h(Uh)h&h*h-h/h0h1}qJ(h3]h4]h5]h6]qKhah8]qLhauh:Kh;hh#]qM(h=)qN}qO(h(XAbout :mod:`cpp-netlib`qPh)hHh*h-h/hAh1}qQ(h3]h4]h5]h6]h8]uh:Kh;hh#]qR(hDXAbout qS…qT}qU(h(XAbout qVh)hNubcsphinx.addnodes pending_xref qW)qX}qY(h(X:mod:`cpp-netlib`qZh)hNh*h-h/U pending_xrefq[h1}q\(UreftypeXmodUrefwarnq]‰U reftargetq^X cpp-netlibU refdomainXpyq_h6]h5]U refexplicit‰h3]h4]h8]Urefdocq`X referencesqaUpy:classqbNU py:moduleqcNuh:Kh#]qdcdocutils.nodes literal qe)qf}qg(h(hZh1}qh(h3]h4]qi(Uxrefqjh_Xpy-modqkeh5]h6]h8]uh)hXh#]qlhDX cpp-netlibqm…qn}qo(h(Uh)hfubah/Uliteralqpubaubeubcdocutils.nodes bullet_list qq)qr}qs(h(Uh)hHh*h-h/U bullet_listqth1}qu(UbulletqvX*h6]h5]h3]h4]h8]uh:Kh;hh#]qw(cdocutils.nodes list_item qx)qy}qz(h(X`BoostCon 2010 Slides`_q{h)hrh*h-h/U list_itemq|h1}q}(h3]h4]h5]h6]h8]uh:Nh;hh#]q~cdocutils.nodes paragraph q)q€}q(h(h{h)hyh*h-h/U paragraphq‚h1}qƒ(h3]h4]h5]h6]h8]uh:Kh#]q„cdocutils.nodes reference q…)q†}q‡(h(h{UresolvedqˆKh)h€h/U referenceq‰h1}qŠ(UnameXBoostCon 2010 SlidesUrefuriq‹X"http://www.filetolink.com/b0e89d06qŒh6]h5]h3]h4]h8]uh#]qhDXBoostCon 2010 SlidesqŽ…q}q(h(Uh)h†ubaubaubaubhx)q‘}q’(h(X`BoostCon 2010 Paper`_ h)hrh*h-h/h|h1}q“(h3]h4]h5]h6]h8]uh:Nh;hh#]q”h)q•}q–(h(X`BoostCon 2010 Paper`_q—h)h‘h*h-h/h‚h1}q˜(h3]h4]h5]h6]h8]uh:Kh#]q™h…)qš}q›(h(h—hˆKh)h•h/h‰h1}qœ(UnameXBoostCon 2010 Paperh‹XQhttp://github.com/downloads/mikhailberis/cpp-netlib-boostcon-paper/cpp-netlib.pdfqh6]h5]h3]h4]h8]uh#]qžhDXBoostCon 2010 PaperqŸ…q }q¡(h(Uh)hšubaubaubaubeubeubh%)q¢}q£(h(Uh)h&h*h-h/h0h1}q¤(h3]h4]h5]h6]q¥hah8]q¦h auh:K h;hh#]q§(h=)q¨}q©(h(X Other sourcesqªh)h¢h*h-h/hAh1}q«(h3]h4]h5]h6]h8]uh:K h;hh#]q¬hDX Other sourcesq­…q®}q¯(h(hªh)h¨ubaubhq)q°}q±(h(Uh)h¢h*h-h/hth1}q²(hvX*h6]h5]h3]h4]h8]uh:K h;hh#]q³(hx)q´}qµ(h(XL`Template Metaprogramming`_: The best guide to C++ template metaprogramming.q¶h)h°h*h-h/h|h1}q·(h3]h4]h5]h6]h8]uh:Nh;hh#]q¸h)q¹}qº(h(h¶h)h´h*h-h/h‚h1}q»(h3]h4]h5]h6]h8]uh:K h#]q¼(h…)q½}q¾(h(X`Template Metaprogramming`_hˆKh)h¹h/h‰h1}q¿(UnameXTemplate Metaprogrammingh‹X http://www.boostpro.com/mplbook/qÀh6]h5]h3]h4]h8]uh#]qÁhDXTemplate MetaprogrammingqÂ…qÃ}qÄ(h(Uh)h½ubaubhDX1: The best guide to C++ template metaprogramming.qÅ…qÆ}qÇ(h(X1: The best guide to C++ template metaprogramming.h)h¹ubeubaubhx)qÈ}qÉ(h(X(`HTTP 1.0`_: The HTTP 1.0 specification.qÊh)h°h*h-h/h|h1}qË(h3]h4]h5]h6]h8]uh:Nh;hh#]qÌh)qÍ}qÎ(h(hÊh)hÈh*h-h/h‚h1}qÏ(h3]h4]h5]h6]h8]uh:Kh#]qÐ(h…)qÑ}qÒ(h(X `HTTP 1.0`_hˆKh)hÍh/h‰h1}qÓ(UnameXHTTP 1.0h‹X.http://www.w3.org/Protocols/HTTP/1.0/spec.htmlqÔh6]h5]h3]h4]h8]uh#]qÕhDXHTTP 1.0qÖ…q×}qØ(h(Uh)hÑubaubhDX: The HTTP 1.0 specification.qÙ…qÚ}qÛ(h(X: The HTTP 1.0 specification.h)hÍubeubaubhx)qÜ}qÝ(h(X3`HTTP 1.1 (RFC 2616)`_: The HTTP 1.1 specification.qÞh)h°h*h-h/h|h1}qß(h3]h4]h5]h6]h8]uh:Nh;hh#]qàh)qá}qâ(h(hÞh)hÜh*h-h/h‚h1}qã(h3]h4]h5]h6]h8]uh:Kh#]qä(h…)qå}qæ(h(X`HTTP 1.1 (RFC 2616)`_hˆKh)háh/h‰h1}qç(UnameXHTTP 1.1 (RFC 2616)h‹X0http://www.w3.org/Protocols/rfc2616/rfc2616.htmlqèh6]h5]h3]h4]h8]uh#]qéhDXHTTP 1.1 (RFC 2616)qê…që}qì(h(Uh)håubaubhDX: The HTTP 1.1 specification.qí…qî}qï(h(X: The HTTP 1.1 specification.h)háubeubaubhx)qð}qñ(h(XC`URI Generic Syntax (RFC 3986)`_: Generic URI syntax specification.qòh)h°h*h-h/h|h1}qó(h3]h4]h5]h6]h8]uh:Nh;hh#]qôh)qõ}qö(h(hòh)hðh*h-h/h‚h1}q÷(h3]h4]h5]h6]h8]uh:Kh#]qø(h…)qù}qú(h(X `URI Generic Syntax (RFC 3986)`_hˆKh)hõh/h‰h1}qû(UnameXURI Generic Syntax (RFC 3986)h‹X#http://www.ietf.org/rfc/rfc3986.txtqüh6]h5]h3]h4]h8]uh#]qýhDXURI Generic Syntax (RFC 3986)qþ…qÿ}r(h(Uh)hùubaubhDX#: Generic URI syntax specification.r…r}r(h(X#: Generic URI syntax specification.h)hõubeubaubhx)r}r(h(XY`Format for Literal IPv6 Addresses in URLs (RFC 2732)`_: Literal IPv6 Addresses in URLs. h)h°h*h-h/h|h1}r(h3]h4]h5]h6]h8]uh:Nh;hh#]rh)r}r (h(XX`Format for Literal IPv6 Addresses in URLs (RFC 2732)`_: Literal IPv6 Addresses in URLs.r h)jh*h-h/h‚h1}r (h3]h4]h5]h6]h8]uh:Kh#]r (h…)r }r(h(X7`Format for Literal IPv6 Addresses in URLs (RFC 2732)`_hˆKh)jh/h‰h1}r(UnameX4Format for Literal IPv6 Addresses in URLs (RFC 2732)h‹X#http://www.ietf.org/rfc/rfc2732.txtrh6]h5]h3]h4]h8]uh#]rhDX4Format for Literal IPv6 Addresses in URLs (RFC 2732)r…r}r(h(Uh)j ubaubhDX!: Literal IPv6 Addresses in URLs.r…r}r(h(X!: Literal IPv6 Addresses in URLs.h)jubeubaubeubcdocutils.nodes target r)r}r(h(X>.. _`BoostCon 2010 Slides`: http://www.filetolink.com/b0e89d06U referencedrKh)h¢h*h-h/Utargetrh1}r(h‹hŒh6]rhah5]h3]h4]h8]rhauh:Kh;hh#]ubj)r }r!(h(Xl.. _`BoostCon 2010 Paper`: http://github.com/downloads/mikhailberis/cpp-netlib-boostcon-paper/cpp-netlib.pdfjKh)h¢h*h-h/jh1}r"(h‹hh6]r#h"ah5]h3]h4]h8]r$hauh:Kh;hh#]ubj)r%}r&(h(X@.. _`Template Metaprogramming`: http://www.boostpro.com/mplbook/jKh)h¢h*h-h/jh1}r'(h‹hÀh6]r(hah5]h3]h4]h8]r)h auh:Kh;hh#]ubj)r*}r+(h(X>.. _`HTTP 1.0`: http://www.w3.org/Protocols/HTTP/1.0/spec.htmljKh)h¢h*h-h/jh1}r,(h‹hÔh6]r-h ah5]h3]h4]h8]r.h auh:Kh;hh#]ubj)r/}r0(h(XK.. _`HTTP 1.1 (RFC 2616)`: http://www.w3.org/Protocols/rfc2616/rfc2616.htmljKh)h¢h*h-h/jh1}r1(h‹hèh6]r2h!ah5]h3]h4]h8]r3hauh:Kh;hh#]ubj)r4}r5(h(XH.. _`URI Generic Syntax (RFC 3986)`: http://www.ietf.org/rfc/rfc3986.txtjKh)h¢h*h-h/jh1}r6(h‹hüh6]r7hah5]h3]h4]h8]r8h auh:Kh;hh#]ubj)r9}r:(h(X_.. _`Format for Literal IPv6 Addresses in URLs (RFC 2732)`: http://www.ietf.org/rfc/rfc2732.txtjKh)h¢h*h-h/jh1}r;(h‹jh6]r<hah5]h3]h4]h8]r=hauh:Kh;hh#]ubeubeubah(UU transformerr>NU footnote_refsr?}r@UrefnamesrA}rB(Xboostcon 2010 slides]rCh†aXhttp 1.0]rDhÑaX4format for literal ipv6 addresses in urls (rfc 2732)]rEj aXuri generic syntax (rfc 3986)]rFhùaXtemplate metaprogramming]rGh½aXhttp 1.1 (rfc 2616)]rHhåaXboostcon 2010 paper]rIhšauUsymbol_footnotesrJ]rKUautofootnote_refsrL]rMUsymbol_footnote_refsrN]rOU citationsrP]rQh;hU current_linerRNUtransform_messagesrS]rTUreporterrUNUid_startrVKU autofootnotesrW]rXU citation_refsrY}rZUindirect_targetsr[]r\Usettingsr](cdocutils.frontend Values r^or_}r`(Ufootnote_backlinksraKUrecord_dependenciesrbNU rfc_base_urlrcUhttp://tools.ietf.org/html/rdU tracebackreˆUpep_referencesrfNUstrip_commentsrgNU toc_backlinksrhUentryriU language_coderjUenrkU datestamprlNU report_levelrmKU _destinationrnNU halt_levelroKU strip_classesrpNhANUerror_encoding_error_handlerrqUbackslashreplacerrUdebugrsNUembed_stylesheetrt‰Uoutput_encoding_error_handlerruUstrictrvU sectnum_xformrwKUdump_transformsrxNU docinfo_xformryKUwarning_streamrzNUpep_file_url_templater{Upep-%04dr|Uexit_status_levelr}KUconfigr~NUstrict_visitorrNUcloak_email_addressesr€ˆUtrim_footnote_reference_spacer‰Uenvr‚NUdump_pseudo_xmlrƒNUexpose_internalsr„NUsectsubtitle_xformr…‰U source_linkr†NUrfc_referencesr‡NUoutput_encodingrˆUutf-8r‰U source_urlrŠNUinput_encodingr‹Uutf-8rŒU_disable_configrNU id_prefixrŽUU tab_widthrKUerror_encodingrUUS-ASCIIr‘U_sourcer’U@/Users/dean/Documents/cpp-netlib/libs/network/doc/references.rstr“Ugettext_compactr”ˆU generatorr•NUdump_internalsr–NU smart_quotesr—‰U pep_base_urlr˜Uhttp://www.python.org/dev/peps/r™Usyntax_highlightršUlongr›Uinput_encoding_error_handlerrœjvUauto_id_prefixrUidržUdoctitle_xformrŸ‰Ustrip_elements_with_classesr NU _config_filesr¡]Ufile_insertion_enabledr¢ˆU raw_enabledr£KU dump_settingsr¤NubUsymbol_footnote_startr¥KUidsr¦}r§(hj4h"j hjhh¢hj9hh&h j*hj%hhHh!j/uUsubstitution_namesr¨}r©h/h;h1}rª(h3]h6]h5]Usourceh-h4]h8]uU footnotesr«]r¬Urefidsr­}r®ub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/techniques.doctree000066400000000000000000000074201240331347200277320ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}qX techniquesqNsUsubstitution_defsq}qUparse_messagesq ]q Ucurrent_sourceq NU decorationq NUautofootnote_startq KUnameidsq}qhU techniquesqsUchildrenq]qcdocutils.nodes section q)q}q(U rawsourceqUUparentqhUsourceqcdocutils.nodes reprunicode qX@/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques.rstq…q}qbUtagnameqUsectionqU attributesq}q (Udupnamesq!]Uclassesq"]Ubackrefsq#]Uidsq$]q%haUnamesq&]q'hauUlineq(KUdocumentq)hh]q*(cdocutils.nodes title q+)q,}q-(hX Techniquesq.hhhhhUtitleq/h}q0(h!]h"]h#]h$]h&]uh(Kh)hh]q1cdocutils.nodes Text q2X Techniquesq3…q4}q5(hh.hh,ubaubcdocutils.nodes paragraph q6)q7}q8(hX~The :mod:`cpp-netlib` uses several advanced techniques to achieve it's aims. This chapter describes some of those techniques.hhhhhU paragraphq9h}q:(h!]h"]h#]h$]h&]uh(Kh)hh]q;(h2XThe q<…q=}q>(hXThe hh7ubcsphinx.addnodes pending_xref q?)q@}qA(hX:mod:`cpp-netlib`qBhh7hhhU pending_xrefqCh}qD(UreftypeXmodUrefwarnqE‰U reftargetqFX cpp-netlibU refdomainXpyqGh$]h#]U refexplicit‰h!]h"]h&]UrefdocqHX techniquesqIUpy:classqJNU py:moduleqKNuh(Kh]qLcdocutils.nodes literal qM)qN}qO(hhBh}qP(h!]h"]qQ(UxrefqRhGXpy-modqSeh#]h$]h&]uhh@h]qTh2X cpp-netlibqU…qV}qW(hUhhNubahUliteralqXubaubh2Xi uses several advanced techniques to achieve it's aims. This chapter describes some of those techniques.qY…qZ}q[(hXi uses several advanced techniques to achieve it's aims. This chapter describes some of those techniques.hh7ubeubcdocutils.nodes compound q\)q]}q^(hUhhhhhUcompoundq_h}q`(h!]h"]qaUtoctree-wrapperqbah#]h$]h&]uh(Nh)hh]qccsphinx.addnodes toctree qd)qe}qf(hUhh]hhhUtoctreeqgh}qh(UnumberedqiKU includehiddenqj‰hhIU titlesonlyqk‰Uglobql‰h$]h#]h!]h"]h&]Uentriesqm]qn(NXtechniques/tag_metafunctionsqo†qpNXtechniques/directivesqq†qrNXtechniques/polymorphismqs†qteUhiddenqu‰U includefilesqv]qw(hohqhseUmaxdepthqxKuh(Kh]ubaubeubahUU transformerqyNU footnote_refsqz}q{Urefnamesq|}q}Usymbol_footnotesq~]qUautofootnote_refsq€]qUsymbol_footnote_refsq‚]qƒU citationsq„]q…h)hU current_lineq†NUtransform_messagesq‡]qˆUreporterq‰NUid_startqŠKU autofootnotesq‹]qŒU citation_refsq}qŽUindirect_targetsq]qUsettingsq‘(cdocutils.frontend Values q’oq“}q”(Ufootnote_backlinksq•KUrecord_dependenciesq–NU rfc_base_urlq—Uhttp://tools.ietf.org/html/q˜U tracebackq™ˆUpep_referencesqšNUstrip_commentsq›NU toc_backlinksqœUentryqU language_codeqžUenqŸU datestampq NU report_levelq¡KU _destinationq¢NU halt_levelq£KU strip_classesq¤Nh/NUerror_encoding_error_handlerq¥Ubackslashreplaceq¦Udebugq§NUembed_stylesheetq¨‰Uoutput_encoding_error_handlerq©UstrictqªU sectnum_xformq«KUdump_transformsq¬NU docinfo_xformq­KUwarning_streamq®NUpep_file_url_templateq¯Upep-%04dq°Uexit_status_levelq±KUconfigq²NUstrict_visitorq³NUcloak_email_addressesq´ˆUtrim_footnote_reference_spaceqµ‰Uenvq¶NUdump_pseudo_xmlq·NUexpose_internalsq¸NUsectsubtitle_xformq¹‰U source_linkqºNUrfc_referencesq»NUoutput_encodingq¼Uutf-8q½U source_urlq¾NUinput_encodingq¿Uutf-8qÀU_disable_configqÁNU id_prefixqÂUU tab_widthqÃKUerror_encodingqÄUUS-ASCIIqÅU_sourceqÆU@/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques.rstqÇUgettext_compactqȈU generatorqÉNUdump_internalsqÊNU smart_quotesqˉU pep_base_urlqÌUhttp://www.python.org/dev/peps/qÍUsyntax_highlightqÎUlongqÏUinput_encoding_error_handlerqÐhªUauto_id_prefixqÑUidqÒUdoctitle_xformqÓ‰Ustrip_elements_with_classesqÔNU _config_filesqÕ]Ufile_insertion_enabledqÖˆU raw_enabledq×KU dump_settingsqØNubUsymbol_footnote_startqÙKUidsqÚ}qÛhhsUsubstitution_namesqÜ}qÝhh)h}qÞ(h!]h$]h#]Usourcehh"]h&]uU footnotesqß]qàUrefidsqá}qâub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/techniques/000077500000000000000000000000001240331347200263605ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/techniques/directives.doctree000066400000000000000000000412611240331347200320740ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}qX directivesqNsUsubstitution_defsq}qUparse_messagesq ]q Ucurrent_sourceq NU decorationq NUautofootnote_startq KUnameidsq}qhU directivesqsUchildrenq]qcdocutils.nodes section q)q}q(U rawsourceqUUparentqhUsourceqcdocutils.nodes reprunicode qXK/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/directives.rstq…q}qbUtagnameqUsectionqU attributesq}q (Udupnamesq!]Uclassesq"]Ubackrefsq#]Uidsq$]q%haUnamesq&]q'hauUlineq(KUdocumentq)hh]q*(cdocutils.nodes title q+)q,}q-(hX Directivesq.hhhhhUtitleq/h}q0(h!]h"]h#]h$]h&]uh(Kh)hh]q1cdocutils.nodes Text q2X Directivesq3…q4}q5(hh.hh,ubaubcdocutils.nodes paragraph q6)q7}q8(hXThe :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.hhhhhU paragraphq9h}q:(h!]h"]h#]h$]h&]uh(Kh)hh]q;(h2XThe q<…q=}q>(hXThe hh7ubcsphinx.addnodes pending_xref q?)q@}qA(hX:mod:`cpp-netlib`qBhh7hhhU pending_xrefqCh}qD(UreftypeXmodUrefwarnqE‰U reftargetqFX cpp-netlibU refdomainXpyqGh$]h#]U refexplicit‰h!]h"]h&]UrefdocqHXtechniques/directivesqIUpy:classqJNU py:moduleqKNuh(Kh]qLcdocutils.nodes literal qM)qN}qO(hhBh}qP(h!]h"]qQ(UxrefqRhGXpy-modqSeh#]h$]h&]uhh@h]qTh2X cpp-netlibqU…qV}qW(hUhhNubahUliteralqXubaubh2X 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.qY…qZ}q[(hX 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.hh7ubeubh6)q\}q](hX<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:hhhhhh9h}q^(h!]h"]h#]h$]h&]uh(K h)hh]q_(h2XÓ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 q`…qa}qb(hXÓ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 hh\ubh?)qc}qd(hX:mod:`cpp-netlib`qehh\hhhhCh}qf(UreftypeXmodhE‰hFX cpp-netlibU refdomainXpyqgh$]h#]U refexplicit‰h!]h"]h&]hHhIhJNhKNuh(K h]qhhM)qi}qj(hheh}qk(h!]h"]ql(hRhgXpy-modqmeh#]h$]h&]uhhch]qnh2X cpp-netlibqo…qp}qq(hUhhiubahhXubaubh2XX the protocol implemented is similar to that of the standard iostream formatting system:qr…qs}qt(hXX the protocol implemented is similar to that of the standard iostream formatting system:hh\ubeubcdocutils.nodes literal_block qu)qv}qw(hXYobject << directive1(...) << directive2(...) ... << directiveN(...);hhhhhU literal_blockqxh}qy(Ulinenosqz‰Ulanguageq{Xc++U xml:spaceq|Upreserveq}h$]h#]h!]h"]h&]uh(Kh)hh]q~h2XYobject << directive1(...) << directive2(...) ... << directiveN(...);q…q€}q(hUhhvubaubh6)q‚}qƒ(hXÖ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:hhhhhh9h}q„(h!]h"]h#]h$]h&]uh(Kh)hh]q…(h2XIn q†…q‡}qˆ(hXIn hh‚ubh?)q‰}qŠ(hX:mod:`cpp-netlib`q‹hh‚hhhhCh}qŒ(UreftypeXmodhE‰hFX cpp-netlibU refdomainXpyqh$]h#]U refexplicit‰h!]h"]h&]hHhIhJNhKNuh(Kh]qŽhM)q}q(hh‹h}q‘(h!]h"]q’(hRhXpy-modq“eh#]h$]h&]uhh‰h]q”h2X cpp-netlibq•…q–}q—(hUhhubahhXubaubh2X 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:q˜…q™}qš(hX 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:hh‚ubeubhu)q›}qœ(hX struct directive_type { template Input & operator()(Input & input) const { // do something to input return input; } };hhhhhhxh}q(hz‰h{Xc++h|h}h$]h#]h!]h"]h&]uh(Kh)hh]qžh2X struct directive_type { template Input & operator()(Input & input) const { // do something to input return input; } };qŸ…q }q¡(hUhh›ubaubh6)q¢}q£(hX†To simplify directive creation, usually factory or generator functions are defined to return concrete objects of the directive's type.q¤hhhhhh9h}q¥(h!]h"]h#]h$]h&]uh(K&h)hh]q¦h2X†To simplify directive creation, usually factory or generator functions are defined to return concrete objects of the directive's type.q§…q¨}q©(hh¤hh¢ubaubhu)qª}q«(hXEinline directive_type directive(...) { return directive_type(); }hhhhhhxh}q¬(hz‰h{Xc++h|h}h$]h#]h!]h"]h&]uh(K)h)hh]q­h2XEinline directive_type directive(...) { return directive_type(); }q®…q¯}q°(hUhhªubaubh6)q±}q²(hX‰The trivial implementation of the directive protocol then boils down to the specialization of the shift-left operator on the target type.q³hhhhhh9h}q´(h!]h"]h#]h$]h&]uh(K0h)hh]qµh2X‰The trivial implementation of the directive protocol then boils down to the specialization of the shift-left operator on the target type.q¶…q·}q¸(hh³hh±ubaubhu)q¹}qº(hXvtemplate inline target_type & operator<< (target_type & x, Directive const & f) { return f(x); }hhhhhhxh}q»(hz‰h{Xc++h|h}h$]h#]h!]h"]h&]uh(K3h)hh]q¼h2Xvtemplate inline target_type & operator<< (target_type & x, Directive const & f) { return f(x); }q½…q¾}q¿(hUhh¹ubaubcdocutils.nodes target qÀ)qÁ}qÂ(hUhhhhhUtargetqÃh}qÄ(h$]h#]h!]h"]h&]UrefidqÅUindex-0qÆuh(Nh)hh]ubcsphinx.ext.todo todo_node qÇ)qÈ}qÉ(hXAn example using a directive.qÊhhhhUexpect_referenced_by_nameqË}hU todo_nodeqÌh}qÍ(h!]h"]qÎUadmonition-todoqÏah#]h$]qÐhÆah&]uh(K;h)hUexpect_referenced_by_idqÑ}qÒhÆhÁsh]qÓ(h+)qÔ}qÕ(hXTodoqÖh}q×(h!]h"]h#]h$]h&]uhhÈh]qØh2XTodoqÙ…qÚ}qÛ(hhÖhhÔubahh/ubh6)qÜ}qÝ(hhÊhhÈhhhh9h}qÞ(h!]h"]h#]h$]h&]uh(K=h]qßh2XAn example using a directive.qà…qá}qâ(hhÊhhÜubaubeubh6)qã}qä(hX@The rationale for implementing directives include the following:qåhhhhhh9h}qæ(h!]h"]h#]h$]h&]uh(K?h)hh]qçh2X@The rationale for implementing directives include the following:qè…qé}qê(hhåhhãubaubcdocutils.nodes block_quote që)qì}qí(hUhhhNhU block_quoteqîh}qï(h!]h"]h#]h$]h&]uh(Nh)hh]qðcdocutils.nodes bullet_list qñ)qò}qó(hUh}qô(UbulletqõX*h$]h#]h!]h"]h&]uhhìh]qö(cdocutils.nodes list_item q÷)qø}qù(hX;**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.h}qú(h!]h"]h#]h$]h&]uhhòh]qûh6)qü}qý(hX;**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.hhøhhhh9h}qþ(h!]h"]h#]h$]h&]uh(KAh]qÿ(cdocutils.nodes strong r)r}r(hX**Encapsulation**h}r(h!]h"]h#]h$]h&]uhhüh]rh2X Encapsulationr…r}r(hUhjubahUstrongrubh2X* - 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.r …r }r (hX* - 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.hhüubeubahU list_itemr ubh÷)r }r(hXz**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.h}r(h!]h"]h#]h$]h&]uhhòh]rh6)r}r(hXz**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.hj hhhh9h}r(h!]h"]h#]h$]h&]uh(KGh]r(j)r}r(hX**Flexibility**h}r(h!]h"]h#]h$]h&]uhjh]rh2X Flexibilityr…r}r(hUhjubahjubh2Xk - 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.r…r}r(hXk - 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.hjubeubahj ubh÷)r}r (hX´**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.h}r!(h!]h"]h#]h$]h&]uhhòh]r"h6)r#}r$(hX´**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.hjhhhh9h}r%(h!]h"]h#]h$]h&]uh(KMh]r&(j)r'}r((hX**Extensibility**h}r)(h!]h"]h#]h$]h&]uhj#h]r*h2X Extensibilityr+…r,}r-(hUhj'ubahjubh2X£ - 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.r.…r/}r0(hX£ - 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.hj#ubeubahj ubh÷)r1}r2(hXE**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. h}r3(h!]h"]h#]h$]h&]uhhòh]r4h6)r5}r6(hXD**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.hj1hhhh9h}r7(h!]h"]h#]h$]h&]uh(KPh]r8(j)r9}r:(hX **Reuse**h}r;(h!]h"]h#]h$]h&]uhj5h]r<h2XReuser=…r>}r?(hUhj9ubahjubh2X; - 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.r@…rA}rB(hX; - 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.hj5ubeubahj ubehU bullet_listrCubaubh6)rD}rE(hX¿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.rFhhhhhh9h}rG(h!]h"]h#]h$]h&]uh(KVh)hh]rHh2X¿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.rI…rJ}rK(hjFhjDubaubh6)rL}rM(hXÉ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.rNhhhhhh9h}rO(h!]h"]h#]h$]h&]uh(KZh)hh]rPh2XÉ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.rQ…rR}rS(hjNhjLubaubeubahUU transformerrTNU footnote_refsrU}rVUrefnamesrW}rXUsymbol_footnotesrY]rZUautofootnote_refsr[]r\Usymbol_footnote_refsr]]r^U citationsr_]r`h)hU current_lineraNUtransform_messagesrb]rccdocutils.nodes system_message rd)re}rf(hUh}rg(h!]UlevelKh$]h#]Usourcehh"]h&]UtypeUINFOrhuh]rih6)rj}rk(hUh}rl(h!]h"]h#]h$]h&]uhjeh]rmh2X-Hyperlink target "index-0" is not referenced.rn…ro}rp(hUhjjubahh9ubahUsystem_messagerqubaUreporterrrNUid_startrsKU autofootnotesrt]ruU citation_refsrv}rwUindirect_targetsrx]ryUsettingsrz(cdocutils.frontend Values r{or|}r}(Ufootnote_backlinksr~KUrecord_dependenciesrNU rfc_base_urlr€Uhttp://tools.ietf.org/html/rU tracebackr‚ˆUpep_referencesrƒNUstrip_commentsr„NU toc_backlinksr…Uentryr†U language_coder‡UenrˆU datestampr‰NU report_levelrŠKU _destinationr‹NU halt_levelrŒKU strip_classesrNh/NUerror_encoding_error_handlerrŽUbackslashreplacerUdebugrNUembed_stylesheetr‘‰Uoutput_encoding_error_handlerr’Ustrictr“U sectnum_xformr”KUdump_transformsr•NU docinfo_xformr–KUwarning_streamr—NUpep_file_url_templater˜Upep-%04dr™Uexit_status_levelršKUconfigr›NUstrict_visitorrœNUcloak_email_addressesrˆUtrim_footnote_reference_spacerž‰UenvrŸNUdump_pseudo_xmlr NUexpose_internalsr¡NUsectsubtitle_xformr¢‰U source_linkr£NUrfc_referencesr¤NUoutput_encodingr¥Uutf-8r¦U source_urlr§NUinput_encodingr¨Uutf-8r©U_disable_configrªNU id_prefixr«UU tab_widthr¬KUerror_encodingr­UUS-ASCIIr®U_sourcer¯UK/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/directives.rstr°Ugettext_compactr±ˆU generatorr²NUdump_internalsr³NU smart_quotesr´‰U pep_base_urlrµUhttp://www.python.org/dev/peps/r¶Usyntax_highlightr·Ulongr¸Uinput_encoding_error_handlerr¹j“Uauto_id_prefixrºUidr»Udoctitle_xformr¼‰Ustrip_elements_with_classesr½NU _config_filesr¾]Ufile_insertion_enabledr¿ˆU raw_enabledrÀKU dump_settingsrÁNubUsymbol_footnote_startrÂKUidsrÃ}rÄ(hÆhÈhhuUsubstitution_namesrÅ}rÆhh)h}rÇ(h!]h$]h#]Usourcehh"]h&]uU footnotesrÈ]rÉUrefidsrÊ}rËhÆ]rÌhÁasub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/techniques/polymorphism.doctree000066400000000000000000000255501240331347200325000ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}qXstatic and dynamic polymorphismqNsUsubstitution_defsq}qUparse_messagesq ]q Ucurrent_sourceq NU decorationq NUautofootnote_startq KUnameidsq}qhUstatic-and-dynamic-polymorphismqsUchildrenq]qcdocutils.nodes section q)q}q(U rawsourceqUUparentqhUsourceqcdocutils.nodes reprunicode qXM/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/polymorphism.rstq…q}qbUtagnameqUsectionqU attributesq}q (Udupnamesq!]Uclassesq"]Ubackrefsq#]Uidsq$]q%haUnamesq&]q'hauUlineq(KUdocumentq)hh]q*(cdocutils.nodes title q+)q,}q-(hXStatic and dynamic polymorphismq.hhhhhUtitleq/h}q0(h!]h"]h#]h$]h&]uh(Kh)hh]q1cdocutils.nodes Text q2XStatic and dynamic polymorphismq3…q4}q5(hh.hh,ubaubcdocutils.nodes paragraph q6)q7}q8(hXvWith a header only library, you can only do so much with static polymorphism alone. There are some situations where you have to handle dynamic polymorphism because of unavoidable runtime-based decision making. Although you can deal with the base types that remain static, behavior can vary greatly which derived type should be handling the situation based on runtime values.q9hhhhhU paragraphq:h}q;(h!]h"]h#]h$]h&]uh(Kh)hh]q}q?(hh9hh7ubaubh6)q@}qA(hXdThis situation comes up in the :mod:`cpp-netlib` when we decide what kind of connection handler to use for a given HTTP URI -- whether it's plain HTTP or HTTPS. Although the HTTP semantics are the same for HTTP and HTTPS the implementation of the connection handler greatly varies on whether to use a plain TCP connection or an SSL-wrapped TCP connection.hhhhhh:h}qB(h!]h"]h#]h$]h&]uh(K h)hh]qC(h2XThis situation comes up in the qD…qE}qF(hXThis situation comes up in the hh@ubcsphinx.addnodes pending_xref qG)qH}qI(hX:mod:`cpp-netlib`qJhh@hhhU pending_xrefqKh}qL(UreftypeXmodUrefwarnqM‰U reftargetqNX cpp-netlibU refdomainXpyqOh$]h#]U refexplicit‰h!]h"]h&]UrefdocqPXtechniques/polymorphismqQUpy:classqRNU py:moduleqSNuh(K h]qTcdocutils.nodes literal qU)qV}qW(hhJh}qX(h!]h"]qY(UxrefqZhOXpy-modq[eh#]h$]h&]uhhHh]q\h2X cpp-netlibq]…q^}q_(hUhhVubahUliteralq`ubaubh2X4 when we decide what kind of connection handler to use for a given HTTP URI -- whether it's plain HTTP or HTTPS. Although the HTTP semantics are the same for HTTP and HTTPS the implementation of the connection handler greatly varies on whether to use a plain TCP connection or an SSL-wrapped TCP connection.qa…qb}qc(hX4 when we decide what kind of connection handler to use for a given HTTP URI -- whether it's plain HTTP or HTTPS. Although the HTTP semantics are the same for HTTP and HTTPS the implementation of the connection handler greatly varies on whether to use a plain TCP connection or an SSL-wrapped TCP connection.hh@ubeubh6)qd}qe(hXUThe general pattern or technique is to combine tag-based dispatch with a strategy factory, all while not requiring any externally built libraries. Doing it in a header-only library requires a little creativity and additional layers of indirection that you otherwise will not need for a library with externally built static/dynamic libraries.qfhhhhhh:h}qg(h!]h"]h#]h$]h&]uh(Kh)hh]qhh2XUThe general pattern or technique is to combine tag-based dispatch with a strategy factory, all while not requiring any externally built libraries. Doing it in a header-only library requires a little creativity and additional layers of indirection that you otherwise will not need for a library with externally built static/dynamic libraries.qi…qj}qk(hhfhhdubaubh6)ql}qm(hXíFirst we define the base type which we want to support dynamic behavior with. There's nothing special with the base type, except that it supports the tag dispatch earlier defined and has a virtual destructor. In code it looks like this:qnhhhhhh:h}qo(h!]h"]h#]h$]h&]uh(Kh)hh]qph2XíFirst we define the base type which we want to support dynamic behavior with. There's nothing special with the base type, except that it supports the tag dispatch earlier defined and has a virtual destructor. In code it looks like this:qq…qr}qs(hhnhhlubaubcdocutils.nodes literal_block qt)qu}qv(hX©template struct base { virtual void foo() = 0; // make this an abstract base virtual ~base() { // do the base destructor thing here. } };hhhhhU literal_blockqwh}qx(Ulinenosqy‰UlanguageqzXc++U xml:spaceq{Upreserveq|h$]h#]h!]h"]h&]uh(Kh)hh]q}h2X©template struct base { virtual void foo() = 0; // make this an abstract base virtual ~base() { // do the base destructor thing here. } };q~…q}q€(hUhhuubaubh6)q}q‚(hXÑWe then define a set of derived types that specialize the implementation of the ``foo`` member function. To facilitate the dispatch of the correct type based on an input, we create a strategy factory function:hhhhhh:h}qƒ(h!]h"]h#]h$]h&]uh(K)h)hh]q„(h2XPWe then define a set of derived types that specialize the implementation of the q……q†}q‡(hXPWe then define a set of derived types that specialize the implementation of the hhubhU)qˆ}q‰(hX``foo``h}qŠ(h!]h"]h#]h$]h&]uhhh]q‹h2XfooqŒ…q}qŽ(hUhhˆubahh`ubh2Xz member function. To facilitate the dispatch of the correct type based on an input, we create a strategy factory function:q…q}q‘(hXz member function. To facilitate the dispatch of the correct type based on an input, we create a strategy factory function:hhubeubht)q’}q“(hX‹template unique_ptr > strategy(int input, Tag) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; // ... default: ptr.reset(0); break; } return ptr; } unique_ptr > ptr = strategy(input, default_()); // input is a runtime valuehhhhhhwh}q”(hy‰hzXc++h{h|h$]h#]h!]h"]h&]uh(K.h)hh]q•h2X‹template unique_ptr > strategy(int input, Tag) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; // ... default: ptr.reset(0); break; } return ptr; } unique_ptr > ptr = strategy(input, default_()); // input is a runtime valueq–…q—}q˜(hUhh’ubaubh6)q™}qš(hX¢The strategy factory can be a standalone function, or a static member of a factory class that is specialized by tag dispatch. This can be done like the following:q›hhhhhh:h}qœ(h!]h"]h#]h$]h&]uh(K?h)hh]qh2X¢The strategy factory can be a standalone function, or a static member of a factory class that is specialized by tag dispatch. This can be done like the following:qž…qŸ}q (hh›hh™ubaubht)q¡}q¢(hX™template struct strategy; template <> struct strategy { static unique_ptr > create(int input) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; //... default: ptr.reset(0); break; } return ptr; } };hhhhhhwh}q£(hy‰hzXc++h{h|h$]h#]h!]h"]h&]uh(KCh)hh]q¤h2X™template struct strategy; template <> struct strategy { static unique_ptr > create(int input) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; //... default: ptr.reset(0); break; } return ptr; } };q¥…q¦}q§(hUhh¡ubaubh6)q¨}q©(hXÄThis approach allows the header-only libraries to define new dynamic types in subsequent versions of the library while keeping the static-dynamic bridge fluid. The only down-side to this is the possibility of derived type explosion in case there are a lot of different strategies or specializations available -- this though is not unique to static-dynamic bridging, but is also a problem with pure object oriented programming with dynamic polymorphism.qªhhhhhh:h}q«(h!]h"]h#]h$]h&]uh(KVh)hh]q¬h2XÄThis approach allows the header-only libraries to define new dynamic types in subsequent versions of the library while keeping the static-dynamic bridge fluid. The only down-side to this is the possibility of derived type explosion in case there are a lot of different strategies or specializations available -- this though is not unique to static-dynamic bridging, but is also a problem with pure object oriented programming with dynamic polymorphism.q­…q®}q¯(hhªhh¨ubaubeubahUU transformerq°NU footnote_refsq±}q²Urefnamesq³}q´Usymbol_footnotesqµ]q¶Uautofootnote_refsq·]q¸Usymbol_footnote_refsq¹]qºU citationsq»]q¼h)hU current_lineq½NUtransform_messagesq¾]q¿UreporterqÀNUid_startqÁKU autofootnotesqÂ]qÃU citation_refsqÄ}qÅUindirect_targetsqÆ]qÇUsettingsqÈ(cdocutils.frontend Values qÉoqÊ}qË(Ufootnote_backlinksqÌKUrecord_dependenciesqÍNU rfc_base_urlqÎUhttp://tools.ietf.org/html/qÏU tracebackqЈUpep_referencesqÑNUstrip_commentsqÒNU toc_backlinksqÓUentryqÔU language_codeqÕUenqÖU datestampq×NU report_levelqØKU _destinationqÙNU halt_levelqÚKU strip_classesqÛNh/NUerror_encoding_error_handlerqÜUbackslashreplaceqÝUdebugqÞNUembed_stylesheetq߉Uoutput_encoding_error_handlerqàUstrictqáU sectnum_xformqâKUdump_transformsqãNU docinfo_xformqäKUwarning_streamqåNUpep_file_url_templateqæUpep-%04dqçUexit_status_levelqèKUconfigqéNUstrict_visitorqêNUcloak_email_addressesqëˆUtrim_footnote_reference_spaceqì‰UenvqíNUdump_pseudo_xmlqîNUexpose_internalsqïNUsectsubtitle_xformqð‰U source_linkqñNUrfc_referencesqòNUoutput_encodingqóUutf-8qôU source_urlqõNUinput_encodingqöUutf-8q÷U_disable_configqøNU id_prefixqùUU tab_widthqúKUerror_encodingqûUUS-ASCIIqüU_sourceqýUM/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/polymorphism.rstqþUgettext_compactqÿˆU generatorrNUdump_internalsrNU smart_quotesr‰U pep_base_urlrUhttp://www.python.org/dev/peps/rUsyntax_highlightrUlongrUinput_encoding_error_handlerrháUauto_id_prefixrUidr Udoctitle_xformr ‰Ustrip_elements_with_classesr NU _config_filesr ]Ufile_insertion_enabledr ˆU raw_enabledrKU dump_settingsrNubUsymbol_footnote_startrKUidsr}rhhsUsubstitution_namesr}rhh)h}r(h!]h$]h#]Usourcehh"]h&]uU footnotesr]rUrefidsr}rub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/techniques/tag_metafunctions.doctree000066400000000000000000000706351240331347200334540ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xtemplate metaprogrammingqNXtag metafunctionsqNX using tagsqNXtemplate specializationq NX boost.mplq ˆuUsubstitution_defsq }q Uparse_messagesq ]qUcurrent_sourceqNU decorationqNUautofootnote_startqKUnameidsq}q(hUtemplate-metaprogrammingqhUtag-metafunctionsqhU using-tagsqh Utemplate-specializationqh U boost-mplquUchildrenq]qcdocutils.nodes section q)q}q(U rawsourceqUUparentqhUsourceq cdocutils.nodes reprunicode q!XR/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/tag_metafunctions.rstq"…q#}q$bUtagnameq%Usectionq&U attributesq'}q((Udupnamesq)]Uclassesq*]Ubackrefsq+]Uidsq,]q-haUnamesq.]q/hauUlineq0KUdocumentq1hh]q2(cdocutils.nodes title q3)q4}q5(hXTag metafunctionsq6hhh h#h%Utitleq7h'}q8(h)]h*]h+]h,]h.]uh0Kh1hh]q9cdocutils.nodes Text q:XTag metafunctionsq;…q<}q=(hh6hh4ubaubcdocutils.nodes paragraph q>)q?}q@(hX…Sometimes you want to vary a function or a type's behavior based on a static parameter. In the :mod:`cpp-netlib` there are a number of things you might want to change based on some such parameter -- like what the underlying string type should be and how large a buffer should be, among other things. The primary way to define this in a header-only manner is to use tag-based metafunctions.hhh h#h%U paragraphqAh'}qB(h)]h*]h+]h,]h.]uh0Kh1hh]qC(h:X_Sometimes you want to vary a function or a type's behavior based on a static parameter. In the qD…qE}qF(hX_Sometimes you want to vary a function or a type's behavior based on a static parameter. In the hh?ubcsphinx.addnodes pending_xref qG)qH}qI(hX:mod:`cpp-netlib`qJhh?h h#h%U pending_xrefqKh'}qL(UreftypeXmodUrefwarnqM‰U reftargetqNX cpp-netlibU refdomainXpyqOh,]h+]U refexplicit‰h)]h*]h.]UrefdocqPXtechniques/tag_metafunctionsqQUpy:classqRNU py:moduleqSNuh0Kh]qTcdocutils.nodes literal qU)qV}qW(hhJh'}qX(h)]h*]qY(UxrefqZhOXpy-modq[eh+]h,]h.]uhhHh]q\h:X cpp-netlibq]…q^}q_(hUhhVubah%Uliteralq`ubaubh:X there are a number of things you might want to change based on some such parameter -- like what the underlying string type should be and how large a buffer should be, among other things. The primary way to define this in a header-only manner is to use tag-based metafunctions.qa…qb}qc(hX there are a number of things you might want to change based on some such parameter -- like what the underlying string type should be and how large a buffer should be, among other things. The primary way to define this in a header-only manner is to use tag-based metafunctions.hh?ubeubh>)qd}qe(hXæThe skeleton of the approach is based on a similar technique for defining type traits. In the :mod:`cpp-netlib` however the type traits are defined on opaque tag types which serve to associate results to a family of metafunctions.hhh h#h%hAh'}qf(h)]h*]h+]h,]h.]uh0K h1hh]qg(h:X^The skeleton of the approach is based on a similar technique for defining type traits. In the qh…qi}qj(hX^The skeleton of the approach is based on a similar technique for defining type traits. In the hhdubhG)qk}ql(hX:mod:`cpp-netlib`qmhhdh h#h%hKh'}qn(UreftypeXmodhM‰hNX cpp-netlibU refdomainXpyqoh,]h+]U refexplicit‰h)]h*]h.]hPhQhRNhSNuh0K h]qphU)qq}qr(hhmh'}qs(h)]h*]qt(hZhoXpy-modqueh+]h,]h.]uhhkh]qvh:X cpp-netlibqw…qx}qy(hUhhqubah%h`ubaubh:Xw however the type traits are defined on opaque tag types which serve to associate results to a family of metafunctions.qz…q{}q|(hXw however the type traits are defined on opaque tag types which serve to associate results to a family of metafunctions.hhdubeubh)q}}q~(hUhhh h#h%h&h'}q(h)]h*]h+]h,]q€hah.]qh auh0Kh1hh]q‚(h3)qƒ}q„(hXTemplate Specializationq…hh}h h#h%h7h'}q†(h)]h*]h+]h,]h.]uh0Kh1hh]q‡h:XTemplate Specializationqˆ…q‰}qŠ(hh…hhƒubaubh>)q‹}qŒ(hXTo illustrate this point, let's define a tag ``default_`` which we use to denote the default implementation of a certain type ``foo``. For instance we decide that the default string type we will use for ``default_`` tagged ``foo`` specializations will be an ``std::string``.hh}h h#h%hAh'}q(h)]h*]h+]h,]h.]uh0Kh1hh]qŽ(h:X-To illustrate this point, let's define a tag q…q}q‘(hX-To illustrate this point, let's define a tag hh‹ubhU)q’}q“(hX ``default_``h'}q”(h)]h*]h+]h,]h.]uhh‹h]q•h:Xdefault_q–…q—}q˜(hUhh’ubah%h`ubh:XE which we use to denote the default implementation of a certain type q™…qš}q›(hXE which we use to denote the default implementation of a certain type hh‹ubhU)qœ}q(hX``foo``h'}qž(h)]h*]h+]h,]h.]uhh‹h]qŸh:Xfooq …q¡}q¢(hUhhœubah%h`ubh:XF. For instance we decide that the default string type we will use for q£…q¤}q¥(hXF. For instance we decide that the default string type we will use for hh‹ubhU)q¦}q§(hX ``default_``h'}q¨(h)]h*]h+]h,]h.]uhh‹h]q©h:Xdefault_qª…q«}q¬(hUhh¦ubah%h`ubh:X tagged q­…q®}q¯(hX tagged hh‹ubhU)q°}q±(hX``foo``h'}q²(h)]h*]h+]h,]h.]uhh‹h]q³h:Xfooq´…qµ}q¶(hUhh°ubah%h`ubh:X specializations will be an q·…q¸}q¹(hX specializations will be an hh‹ubhU)qº}q»(hX``std::string``h'}q¼(h)]h*]h+]h,]h.]uhh‹h]q½h:X std::stringq¾…q¿}qÀ(hUhhºubah%h`ubh:X.…qÁ}qÂ(hX.hh‹ubeubh>)qÃ}qÄ(hX×In the :mod:`cpp-netlib` this is done by defining a ``string`` metafunction type that is specialized on the tag ``default_`` whose nested ``type`` result is the type ``std::string``. In code this would translate to:hh}h h#h%hAh'}qÅ(h)]h*]h+]h,]h.]uh0Kh1hh]qÆ(h:XIn the qÇ…qÈ}qÉ(hXIn the hhÃubhG)qÊ}qË(hX:mod:`cpp-netlib`qÌhhÃh h#h%hKh'}qÍ(UreftypeXmodhM‰hNX cpp-netlibU refdomainXpyqÎh,]h+]U refexplicit‰h)]h*]h.]hPhQhRNhSNuh0Kh]qÏhU)qÐ}qÑ(hhÌh'}qÒ(h)]h*]qÓ(hZhÎXpy-modqÔeh+]h,]h.]uhhÊh]qÕh:X cpp-netlibqÖ…q×}qØ(hUhhÐubah%h`ubaubh:X this is done by defining a qÙ…qÚ}qÛ(hX this is done by defining a hhÃubhU)qÜ}qÝ(hX ``string``h'}qÞ(h)]h*]h+]h,]h.]uhhÃh]qßh:Xstringqà…qá}qâ(hUhhÜubah%h`ubh:X2 metafunction type that is specialized on the tag qã…qä}qå(hX2 metafunction type that is specialized on the tag hhÃubhU)qæ}qç(hX ``default_``h'}qè(h)]h*]h+]h,]h.]uhhÃh]qéh:Xdefault_qê…që}qì(hUhhæubah%h`ubh:X whose nested qí…qî}qï(hX whose nested hhÃubhU)qð}qñ(hX``type``h'}qò(h)]h*]h+]h,]h.]uhhÃh]qóh:Xtypeqô…qõ}qö(hUhhðubah%h`ubh:X result is the type q÷…qø}qù(hX result is the type hhÃubhU)qú}qû(hX``std::string``h'}qü(h)]h*]h+]h,]h.]uhhÃh]qýh:X std::stringqþ…qÿ}r(hUhhúubah%h`ubh:X". In code this would translate to:r…r}r(hX". In code this would translate to:hhÃubeubcdocutils.nodes literal_block r)r}r(hX˜template struct string { typedef void type; }; struct default_; template <> struct string { typedef std::string type; };hh}h h#h%U literal_blockrh'}r(Ulinenosr ‰Ulanguager Xc++U xml:spacer Upreserver h,]h+]h)]h*]h.]uh0Kh1hh]r h:X˜template struct string { typedef void type; }; struct default_; template <> struct string { typedef std::string type; };r…r}r(hUhjubaubeubh)r}r(hUhhh h#h%h&h'}r(h)]h*]h+]h,]rhah.]rhauh0K-h1hh]r(h3)r}r(hXTemplate Metaprogrammingrhjh h#h%h7h'}r(h)]h*]h+]h,]h.]uh0K-h1hh]rh:XTemplate Metaprogrammingr…r}r(hjhjubaubh>)r}r (hXúStarting with version 0.7, the tag dispatch mechanism changed slightly to use Boost.MPL_. The idea is still the same, although we can get a little smarter than just using template specializations. Instead of just defining an opaque type ``default_``, we use the Boost.MPL equivalent of a vector to define which root types of properties this ``default_`` tag supports. The idea is to make the opaque type ``default_`` inherit property tags which the library supports internally as definite extension points.hjh h#h%hAh'}r!(h)]h*]h+]h,]h.]uh0K/h1hh]r"(h:XNStarting with version 0.7, the tag dispatch mechanism changed slightly to use r#…r$}r%(hXNStarting with version 0.7, the tag dispatch mechanism changed slightly to use hjubcdocutils.nodes reference r&)r'}r((hX Boost.MPL_Uresolvedr)Khjh%U referencer*h'}r+(UnameX Boost.MPLUrefurir,X(http://www.boost.org/libs/mpl/index.htmlr-h,]h+]h)]h*]h.]uh]r.h:X Boost.MPLr/…r0}r1(hUhj'ubaubh:X•. The idea is still the same, although we can get a little smarter than just using template specializations. Instead of just defining an opaque type r2…r3}r4(hX•. The idea is still the same, although we can get a little smarter than just using template specializations. Instead of just defining an opaque type hjubhU)r5}r6(hX ``default_``h'}r7(h)]h*]h+]h,]h.]uhjh]r8h:Xdefault_r9…r:}r;(hUhj5ubah%h`ubh:X\, we use the Boost.MPL equivalent of a vector to define which root types of properties this r<…r=}r>(hX\, we use the Boost.MPL equivalent of a vector to define which root types of properties this hjubhU)r?}r@(hX ``default_``h'}rA(h)]h*]h+]h,]h.]uhjh]rBh:Xdefault_rC…rD}rE(hUhj?ubah%h`ubh:X3 tag supports. The idea is to make the opaque type rF…rG}rH(hX3 tag supports. The idea is to make the opaque type hjubhU)rI}rJ(hX ``default_``h'}rK(h)]h*]h+]h,]h.]uhjh]rLh:Xdefault_rM…rN}rO(hUhjIubah%h`ubh:XZ inherit property tags which the library supports internally as definite extension points.rP…rQ}rR(hXZ inherit property tags which the library supports internally as definite extension points.hjubeubcdocutils.nodes target rS)rT}rU(hX7.. _Boost.MPL: http://www.boost.org/libs/mpl/index.htmlU referencedrVKhjh h#h%UtargetrWh'}rX(j,j-h,]rYhah+]h)]h*]h.]rZh auh0K7h1hh]ubh>)r[}r\(hXSOur definition of the ``default_`` tag will then look something like the following:hjh h#h%hAh'}r](h)]h*]h+]h,]h.]uh0K9h1hh]r^(h:XOur definition of the r_…r`}ra(hXOur definition of the hj[ubhU)rb}rc(hX ``default_``h'}rd(h)]h*]h+]h,]h.]uhj[h]reh:Xdefault_rf…rg}rh(hUhjbubah%h`ubh:X1 tag will then look something like the following:ri…rj}rk(hX1 tag will then look something like the following:hj[ubeubj)rl}rm(hX7typedef mpl::vector default_tags; template struct components; typedef mpl::inherit_linearly< default_tags, mpl::inherit >::type default_; template struct components { typedef default_tags type; };hjh h#h%jh'}rn(j ‰j Xc++j j h,]h+]h)]h*]h.]uh0K default_tags; template struct components; typedef mpl::inherit_linearly< default_tags, mpl::inherit >::type default_; template struct components { typedef default_tags type; };rp…rq}rr(hUhjlubaubh>)rs}rt(hXvIn the above listing, ``default_string`` is what we call a "root" tag which is meant to be combined with other "root" tags to form composite tags. In this case our composite tag is the tag ``default_``. There are a number of these "root" tags that :mod:`cpp-netlib` provides. These are in the namespace ``boost::network::tags`` and are defined in ``boost/network/tags.hpp``.hjh h#h%hAh'}ru(h)]h*]h+]h,]h.]uh0KMh1hh]rv(h:XIn the above listing, rw…rx}ry(hXIn the above listing, hjsubhU)rz}r{(hX``default_string``h'}r|(h)]h*]h+]h,]h.]uhjsh]r}h:Xdefault_stringr~…r}r€(hUhjzubah%h`ubh:X• is what we call a "root" tag which is meant to be combined with other "root" tags to form composite tags. In this case our composite tag is the tag r…r‚}rƒ(hX• is what we call a "root" tag which is meant to be combined with other "root" tags to form composite tags. In this case our composite tag is the tag hjsubhU)r„}r…(hX ``default_``h'}r†(h)]h*]h+]h,]h.]uhjsh]r‡h:Xdefault_rˆ…r‰}rŠ(hUhj„ubah%h`ubh:X/. There are a number of these "root" tags that r‹…rŒ}r(hX/. There are a number of these "root" tags that hjsubhG)rŽ}r(hX:mod:`cpp-netlib`rhjsh h#h%hKh'}r‘(UreftypeXmodhM‰hNX cpp-netlibU refdomainXpyr’h,]h+]U refexplicit‰h)]h*]h.]hPhQhRNhSNuh0KMh]r“hU)r”}r•(hjh'}r–(h)]h*]r—(hZj’Xpy-modr˜eh+]h,]h.]uhjŽh]r™h:X cpp-netlibrš…r›}rœ(hUhj”ubah%h`ubaubh:X& provides. These are in the namespace r…rž}rŸ(hX& provides. These are in the namespace hjsubhU)r }r¡(hX``boost::network::tags``h'}r¢(h)]h*]h+]h,]h.]uhjsh]r£h:Xboost::network::tagsr¤…r¥}r¦(hUhj ubah%h`ubh:X and are defined in r§…r¨}r©(hX and are defined in hjsubhU)rª}r«(hX``boost/network/tags.hpp``h'}r¬(h)]h*]h+]h,]h.]uhjsh]r­h:Xboost/network/tags.hppr®…r¯}r°(hUhjªubah%h`ubh:X.…r±}r²(hX.hjsubeubh>)r³}r´(hXfUsing this technique we change slightly our definition of the ``string`` metafunction class into this:hjh h#h%hAh'}rµ(h)]h*]h+]h,]h.]uh0KSh1hh]r¶(h:X>Using this technique we change slightly our definition of the r·…r¸}r¹(hX>Using this technique we change slightly our definition of the hj³ubhU)rº}r»(hX ``string``h'}r¼(h)]h*]h+]h,]h.]uhj³h]r½h:Xstringr¾…r¿}rÀ(hUhjºubah%h`ubh:X metafunction class into this:rÁ…rÂ}rÃ(hX metafunction class into this:hj³ubeubj)rÄ}rÅ(hXítemplate struct unsupported_tag; template struct string : mpl::if_< is_base_of< tags::default_string, Tag >, std::string, unsupported_tag > {};hjh h#h%jh'}rÆ(j ‰j Xc++j j h,]h+]h)]h*]h.]uh0KVh1hh]rÇh:Xítemplate struct unsupported_tag; template struct string : mpl::if_< is_base_of< tags::default_string, Tag >, std::string, unsupported_tag > {};rÈ…rÉ}rÊ(hUhjÄubaubh>)rË}rÌ(hXþNotice that we don't have the typedef for ``type`` in the body of ``string`` anymore, but we do inherit from ``mpl::if_``. Since ``mpl::if_`` is a template metafunction itself, it contains a definition of the resulting ``type`` which ``string`` inherits.hjh h#h%hAh'}rÍ(h)]h*]h+]h,]h.]uh0Kgh1hh]rÎ(h:X*Notice that we don't have the typedef for rÏ…rÐ}rÑ(hX*Notice that we don't have the typedef for hjËubhU)rÒ}rÓ(hX``type``h'}rÔ(h)]h*]h+]h,]h.]uhjËh]rÕh:XtyperÖ…r×}rØ(hUhjÒubah%h`ubh:X in the body of rÙ…rÚ}rÛ(hX in the body of hjËubhU)rÜ}rÝ(hX ``string``h'}rÞ(h)]h*]h+]h,]h.]uhjËh]rßh:Xstringrà…rá}râ(hUhjÜubah%h`ubh:X! anymore, but we do inherit from rã…rä}rå(hX! anymore, but we do inherit from hjËubhU)ræ}rç(hX ``mpl::if_``h'}rè(h)]h*]h+]h,]h.]uhjËh]réh:Xmpl::if_rê…rë}rì(hUhjæubah%h`ubh:X. Since rí…rî}rï(hX. Since hjËubhU)rð}rñ(hX ``mpl::if_``h'}rò(h)]h*]h+]h,]h.]uhjËh]róh:Xmpl::if_rô…rõ}rö(hUhjðubah%h`ubh:XN is a template metafunction itself, it contains a definition of the resulting r÷…rø}rù(hXN is a template metafunction itself, it contains a definition of the resulting hjËubhU)rú}rû(hX``type``h'}rü(h)]h*]h+]h,]h.]uhjËh]rýh:Xtyperþ…rÿ}r(hUhjúubah%h`ubh:X which r…r}r(hX which hjËubhU)r}r(hX ``string``h'}r(h)]h*]h+]h,]h.]uhjËh]rh:Xstringr…r }r (hUhjubah%h`ubh:X inherits.r …r }r (hX inherits.hjËubeubh>)r}r(hXfYou can see the real definition of the ``string`` metafunction in ``boost/network/traits/string.hpp``.hjh h#h%hAh'}r(h)]h*]h+]h,]h.]uh0Klh1hh]r(h:X'You can see the real definition of the r…r}r(hX'You can see the real definition of the hjubhU)r}r(hX ``string``h'}r(h)]h*]h+]h,]h.]uhjh]rh:Xstringr…r}r(hUhjubah%h`ubh:X metafunction in r…r}r(hX metafunction in hjubhU)r}r (hX#``boost/network/traits/string.hpp``h'}r!(h)]h*]h+]h,]h.]uhjh]r"h:Xboost/network/traits/string.hppr#…r$}r%(hUhjubah%h`ubh:X.…r&}r'(hX.hjubeubeubh)r(}r)(hUhhh h#h%h&h'}r*(h)]h*]h+]h,]r+hah.]r,hauh0Kph1hh]r-(h3)r.}r/(hX Using Tagsr0hj(h h#h%h7h'}r1(h)]h*]h+]h,]h.]uh0Kph1hh]r2h:X Using Tagsr3…r4}r5(hj0hj.ubaubh>)r6}r7(hX0Once we have the defined tag, we can then use this in the definition of our types. In the definition of the type ``foo`` we use this type function ``string`` and pass the tag type parameter to determine what to use as the string type in the context of the type ``foo``. In code this would translate into:hj(h h#h%hAh'}r8(h)]h*]h+]h,]h.]uh0Krh1hh]r9(h:XqOnce we have the defined tag, we can then use this in the definition of our types. In the definition of the type r:…r;}r<(hXqOnce we have the defined tag, we can then use this in the definition of our types. In the definition of the type hj6ubhU)r=}r>(hX``foo``h'}r?(h)]h*]h+]h,]h.]uhj6h]r@h:XfoorA…rB}rC(hUhj=ubah%h`ubh:X we use this type function rD…rE}rF(hX we use this type function hj6ubhU)rG}rH(hX ``string``h'}rI(h)]h*]h+]h,]h.]uhj6h]rJh:XstringrK…rL}rM(hUhjGubah%h`ubh:Xh and pass the tag type parameter to determine what to use as the string type in the context of the type rN…rO}rP(hXh and pass the tag type parameter to determine what to use as the string type in the context of the type hj6ubhU)rQ}rR(hX``foo``h'}rS(h)]h*]h+]h,]h.]uhj6h]rTh:XfoorU…rV}rW(hUhjQubah%h`ubh:X$. In code this would translate into:rX…rY}rZ(hX$. In code this would translate into:hj6ubeubj)r[}r\(hXŒtemplate struct foo { typedef typename string::type string_type; // .. use string_type where you need a string. };hj(h h#h%jh'}r](j ‰j Xc++j j h,]h+]h)]h*]h.]uh0Kxh1hh]r^h:XŒtemplate struct foo { typedef typename string::type string_type; // .. use string_type where you need a string. };r_…r`}ra(hUhj[ubaubh>)rb}rc(hX—Using this approach we can support different types of strings for different tags on the type ``foo``. In case we want to use a different type of string for the tag ``default_`` we only change the composition of the ``string_tags`` MPL vector. For example, in :mod:`cpp-netlib` there is a root tag ``default_wstring`` which causes the ``string`` metafunction to define ``std::wstring`` as the resulting type.hj(h h#h%hAh'}rd(h)]h*]h+]h,]h.]uh0Kh1hh]re(h:X]Using this approach we can support different types of strings for different tags on the type rf…rg}rh(hX]Using this approach we can support different types of strings for different tags on the type hjbubhU)ri}rj(hX``foo``h'}rk(h)]h*]h+]h,]h.]uhjbh]rlh:Xfoorm…rn}ro(hUhjiubah%h`ubh:X@. In case we want to use a different type of string for the tag rp…rq}rr(hX@. In case we want to use a different type of string for the tag hjbubhU)rs}rt(hX ``default_``h'}ru(h)]h*]h+]h,]h.]uhjbh]rvh:Xdefault_rw…rx}ry(hUhjsubah%h`ubh:X' we only change the composition of the rz…r{}r|(hX' we only change the composition of the hjbubhU)r}}r~(hX``string_tags``h'}r(h)]h*]h+]h,]h.]uhjbh]r€h:X string_tagsr…r‚}rƒ(hUhj}ubah%h`ubh:X MPL vector. For example, in r„…r…}r†(hX MPL vector. For example, in hjbubhG)r‡}rˆ(hX:mod:`cpp-netlib`r‰hjbh h#h%hKh'}rŠ(UreftypeXmodhM‰hNX cpp-netlibU refdomainXpyr‹h,]h+]U refexplicit‰h)]h*]h.]hPhQhRNhSNuh0Kh]rŒhU)r}rŽ(hj‰h'}r(h)]h*]r(hZj‹Xpy-modr‘eh+]h,]h.]uhj‡h]r’h:X cpp-netlibr“…r”}r•(hUhjubah%h`ubaubh:X there is a root tag r–…r—}r˜(hX there is a root tag hjbubhU)r™}rš(hX``default_wstring``h'}r›(h)]h*]h+]h,]h.]uhjbh]rœh:Xdefault_wstringr…rž}rŸ(hUhj™ubah%h`ubh:X which causes the r …r¡}r¢(hX which causes the hjbubhU)r£}r¤(hX ``string``h'}r¥(h)]h*]h+]h,]h.]uhjbh]r¦h:Xstringr§…r¨}r©(hUhj£ubah%h`ubh:X metafunction to define rª…r«}r¬(hX metafunction to define hjbubhU)r­}r®(hX``std::wstring``h'}r¯(h)]h*]h+]h,]h.]uhjbh]r°h:X std::wstringr±…r²}r³(hUhj­ubah%h`ubh:X as the resulting type.r´…rµ}r¶(hX as the resulting type.hjbubeubh>)r·}r¸(hXúThe approach also allows for the control of the structure and features of types like ``foo`` based on the specialization of the tag. Whole type function families can be defined on tags where they are supported and ignored in cases where they are not.hj(h h#h%hAh'}r¹(h)]h*]h+]h,]h.]uh0Kˆh1hh]rº(h:XUThe approach also allows for the control of the structure and features of types like r»…r¼}r½(hXUThe approach also allows for the control of the structure and features of types like hj·ubhU)r¾}r¿(hX``foo``h'}rÀ(h)]h*]h+]h,]h.]uhj·h]rÁh:XfoorÂ…rÃ}rÄ(hUhj¾ubah%h`ubh:Xž based on the specialization of the tag. Whole type function families can be defined on tags where they are supported and ignored in cases where they are not.rÅ…rÆ}rÇ(hXž based on the specialization of the tag. Whole type function families can be defined on tags where they are supported and ignored in cases where they are not.hj·ubeubh>)rÈ}rÉ(hXûTo illustrate let's define a new tag ``swappable``. Given the above definition of ``foo``, we want to make the ``swappable``-tagged ``foo`` define a ``swap`` function that extends the original ``default_``-tagged ``foo``. In code this would look like:hj(h h#h%hAh'}rÊ(h)]h*]h+]h,]h.]uh0Kh1hh]rË(h:X%To illustrate let's define a new tag rÌ…rÍ}rÎ(hX%To illustrate let's define a new tag hjÈubhU)rÏ}rÐ(hX ``swappable``h'}rÑ(h)]h*]h+]h,]h.]uhjÈh]rÒh:X swappablerÓ…rÔ}rÕ(hUhjÏubah%h`ubh:X . Given the above definition of rÖ…r×}rØ(hX . Given the above definition of hjÈubhU)rÙ}rÚ(hX``foo``h'}rÛ(h)]h*]h+]h,]h.]uhjÈh]rÜh:XfoorÝ…rÞ}rß(hUhjÙubah%h`ubh:X, we want to make the rà…rá}râ(hX, we want to make the hjÈubhU)rã}rä(hX ``swappable``h'}rå(h)]h*]h+]h,]h.]uhjÈh]ræh:X swappablerç…rè}ré(hUhjãubah%h`ubh:X-tagged rê…rë}rì(hX-tagged hjÈubhU)rí}rî(hX``foo``h'}rï(h)]h*]h+]h,]h.]uhjÈh]rðh:Xfoorñ…rò}ró(hUhjíubah%h`ubh:X define a rô…rõ}rö(hX define a hjÈubhU)r÷}rø(hX``swap``h'}rù(h)]h*]h+]h,]h.]uhjÈh]rúh:Xswaprû…rü}rý(hUhj÷ubah%h`ubh:X$ function that extends the original rþ…rÿ}r(hX$ function that extends the original hjÈubhU)r}r(hX ``default_``h'}r(h)]h*]h+]h,]h.]uhjÈh]rh:Xdefault_r…r}r(hUhjubah%h`ubh:X-tagged r…r }r (hX-tagged hjÈubhU)r }r (hX``foo``h'}r (h)]h*]h+]h,]h.]uhjÈh]rh:Xfoor…r}r(hUhj ubah%h`ubh:X. In code this would look like:r…r}r(hX. In code this would look like:hjÈubeubj)r}r(hX†struct swappable; template <> struct foo : foo { void swap(foo & other) { // ... } };hj(h h#h%jh'}r(j ‰j Xc++j j h,]h+]h)]h*]h.]uh0K’h1hh]rh:X†struct swappable; template <> struct foo : foo { void swap(foo & other) { // ... } };r…r}r(hUhjubaubh>)r}r(hXFWe also for example want to enable an ADL-reachable ``swap`` function:rhj(h h#h%hAh'}r(h)]h*]h+]h,]h.]uh0Kh1hh]r (h:X4We also for example want to enable an ADL-reachable r!…r"}r#(hX4We also for example want to enable an ADL-reachable hjubhU)r$}r%(hX``swap``h'}r&(h)]h*]h+]h,]h.]uhjh]r'h:Xswapr(…r)}r*(hUhj$ubah%h`ubh:X function:r+…r,}r-(hX function:hjubeubj)r.}r/(hXlstruct swappable; inline void swap(foo & left, foo & right) { left.swap(right); }hj(h h#h%jh'}r0(j ‰j Xc++j j h,]h+]h)]h*]h.]uh0KŸh1hh]r1h:Xlstruct swappable; inline void swap(foo & left, foo & right) { left.swap(right); }r2…r3}r4(hUhj.ubaubh>)r5}r6(hXÍOverall what the tag-based definition approach allows is for static definition of extension points that ensures type-safety and invariants. This keeps the whole extension mechanism static and yet flexible.r7hj(h h#h%hAh'}r8(h)]h*]h+]h,]h.]uh0K¨h1hh]r9h:XÍOverall what the tag-based definition approach allows is for static definition of extension points that ensures type-safety and invariants. This keeps the whole extension mechanism static and yet flexible.r:…r;}r<(hj7hj5ubaubeubeubahUU transformerr=NU footnote_refsr>}r?Urefnamesr@}rAX boost.mpl]rBj'asUsymbol_footnotesrC]rDUautofootnote_refsrE]rFUsymbol_footnote_refsrG]rHU citationsrI]rJh1hU current_linerKNUtransform_messagesrL]rMUreporterrNNUid_startrOKU autofootnotesrP]rQU citation_refsrR}rSUindirect_targetsrT]rUUsettingsrV(cdocutils.frontend Values rWorX}rY(Ufootnote_backlinksrZKUrecord_dependenciesr[NU rfc_base_urlr\Uhttp://tools.ietf.org/html/r]U tracebackr^ˆUpep_referencesr_NUstrip_commentsr`NU toc_backlinksraUentryrbU language_codercUenrdU datestampreNU report_levelrfKU _destinationrgNU halt_levelrhKU strip_classesriNh7NUerror_encoding_error_handlerrjUbackslashreplacerkUdebugrlNUembed_stylesheetrm‰Uoutput_encoding_error_handlerrnUstrictroU sectnum_xformrpKUdump_transformsrqNU docinfo_xformrrKUwarning_streamrsNUpep_file_url_templatertUpep-%04druUexit_status_levelrvKUconfigrwNUstrict_visitorrxNUcloak_email_addressesryˆUtrim_footnote_reference_spacerz‰Uenvr{NUdump_pseudo_xmlr|NUexpose_internalsr}NUsectsubtitle_xformr~‰U source_linkrNUrfc_referencesr€NUoutput_encodingrUutf-8r‚U source_urlrƒNUinput_encodingr„Uutf-8r…U_disable_configr†NU id_prefixr‡UU tab_widthrˆKUerror_encodingr‰UUS-ASCIIrŠU_sourcer‹UR/Users/dean/Documents/cpp-netlib/libs/network/doc/techniques/tag_metafunctions.rstrŒUgettext_compactrˆU generatorrŽNUdump_internalsrNU smart_quotesr‰U pep_base_urlr‘Uhttp://www.python.org/dev/peps/r’Usyntax_highlightr“Ulongr”Uinput_encoding_error_handlerr•joUauto_id_prefixr–Uidr—Udoctitle_xformr˜‰Ustrip_elements_with_classesr™NU _config_filesrš]r›Ufile_insertion_enabledrœˆU raw_enabledrKU dump_settingsržNubUsymbol_footnote_startrŸKUidsr }r¡(hj(hjThjhhhh}uUsubstitution_namesr¢}r£h%h1h'}r¤(h)]h,]h+]Usourceh#h*]h.]uU footnotesr¥]r¦Urefidsr§}r¨ub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/.doctrees/whats_new.doctree000066400000000000000000001672261240331347200275740ustar00rootroot00000000000000€cdocutils.nodes document q)q}q(U nametypesq}q(Xv0.9.1qNXv0.9.0qNX#263qˆXv0.9.2q NX#265q ˆX#264q ˆX#81q ˆX#287q ˆX#285qˆXv0.10.1qNXv0.9.3qNX#316qˆX#83qˆXv0.9.5qNX#245qˆX#110qˆX#194qˆX#27qˆX#69qˆX#67qˆX what's newqNX#213qˆXcpp-netlib 0.9qNX#313qˆX#80qˆX#277qˆX#82q ˆX#172q!ˆXv0.10.0q"NX#86q#ˆX#166q$ˆX#279q%ˆXcpp-netlib 0.6q&NX#233q'ˆX#349q(ˆXv0.11.0q)NX#255q*ˆXcpp-netlib 0.8q+NX whats_newq,ˆX#79q-ˆX#78q.ˆXcpp-netlib 0.5q/NX#182q0ˆXcpp-netlib 0.7q1NX#73q2ˆX#72q3ˆXv0.9.4q4NX#129q5ˆXcpp-netlib 0.10q6NXcpp-netlib 0.11q7NX#168q8ˆuUsubstitution_defsq9}q:Uparse_messagesq;]qNUautofootnote_startq?KUnameidsq@}qA(hUv0-9-1qBhUv0-9-0qChUid17qDh Uv0-9-2qEh Uid14qFh Uid19qGh Uid31qHh Uid7qIhUid6qJhUv0-10-1qKhUv0-9-3qLhUid9qMhUid33qNhUv0-9-5qOhUid2qPhUid22qQhUid15qRhUid5qShUid11qThUid26qUhU what-s-newqVhUid24qWhUcpp-netlib-0-9qXhUid8qYhUid30qZhUid3q[h Uid32q\h!Uid16q]h"Uv0-10-0q^h#Uid12q_h$Uid21q`h%Uid4qah&Ucpp-netlib-0-6qbh'Uid18qch(Uid10qdh)Uv0-11-0qeh*Uid20qfh+Ucpp-netlib-0-8qgh,U whats-newqhh-Uid29qih.Uid28qjh/Ucpp-netlib-0-5qkh0Uid13qlh1Ucpp-netlib-0-7qmh2Uid25qnh3Uid27qoh4Uv0-9-4qph5Uid1qqh6Ucpp-netlib-0-10qrh7Ucpp-netlib-0-11qsh8Uid23qtuUchildrenqu]qv(cdocutils.nodes target qw)qx}qy(U rawsourceqzX.. _whats_new:Uparentq{hUsourceq|cdocutils.nodes reprunicode q}X?/Users/dean/Documents/cpp-netlib/libs/network/doc/whats_new.rstq~…q}q€bUtagnameqUtargetq‚U attributesqƒ}q„(Uidsq…]Ubackrefsq†]Udupnamesq‡]Uclassesqˆ]Unamesq‰]UrefidqŠhhuUlineq‹KUdocumentqŒhhu]ubcdocutils.nodes section q)qŽ}q(hzUh{hh|hUexpect_referenced_by_nameq}q‘h,hxshUsectionq’hƒ}q“(h‡]hˆ]h†]h…]q”(hVhheh‰]q•(hh,euh‹KhŒhUexpect_referenced_by_idq–}q—hhhxshu]q˜(cdocutils.nodes title q™)qš}q›(hzX What's Newqœh{hŽh|hhUtitleqhƒ}qž(h‡]hˆ]h†]h…]h‰]uh‹KhŒhhu]qŸcdocutils.nodes Text q X What's Newq¡…q¢}q£(hzhœh{hšubaubh)q¤}q¥(hzUh{hŽh|hhh’hƒ}q¦(h‡]hˆ]h†]h…]q§hsah‰]q¨h7auh‹KhŒhhu]q©(h™)qª}q«(hzX:mod:`cpp-netlib` 0.11q¬h{h¤h|hhhhƒ}q­(h‡]hˆ]h†]h…]h‰]uh‹KhŒhhu]q®(csphinx.addnodes pending_xref q¯)q°}q±(hzX:mod:`cpp-netlib`q²h{hªh|hhU pending_xrefq³hƒ}q´(UreftypeXmodUrefwarnqµ‰U reftargetq¶X cpp-netlibU refdomainXpyq·h…]h†]U refexplicit‰h‡]hˆ]h‰]Urefdocq¸X whats_newq¹Upy:classqºNU py:moduleq»Nuh‹Khu]q¼cdocutils.nodes literal q½)q¾}q¿(hzh²hƒ}qÀ(h‡]hˆ]qÁ(UxrefqÂh·Xpy-modqÃeh†]h…]h‰]uh{h°hu]qÄh X cpp-netlibqÅ…qÆ}qÇ(hzUh{h¾ubahUliteralqÈubaubh X 0.11qÉ…qÊ}qË(hzX 0.11qÌh{hªubeubh)qÍ}qÎ(hzUh{h¤h|hhh’hƒ}qÏ(h‡]hˆ]h†]h…]qÐheah‰]qÑh)auh‹K hŒhhu]qÒ(h™)qÓ}qÔ(hzXv0.11.0qÕh{hÍh|hhhhƒ}qÖ(h‡]hˆ]h†]h…]h‰]uh‹K hŒhhu]q×h Xv0.11.0qØ…qÙ}qÚ(hzhÕh{hÓubaubcdocutils.nodes bullet_list qÛ)qÜ}qÝ(hzUh{hÍh|hhU bullet_listqÞhƒ}qß(UbulletqàX*h…]h†]h‡]hˆ]h‰]uh‹K hŒhhu]qá(cdocutils.nodes list_item qâ)qã}qä(hzX3Fix thread leak in DNS resolution failure (`#245`_)qåh{hÜh|hhU list_itemqæhƒ}qç(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]qècdocutils.nodes paragraph qé)qê}që(hzhåh{hãh|hhU paragraphqìhƒ}qí(h‡]hˆ]h†]h…]h‰]uh‹K hu]qî(h X+Fix thread leak in DNS resolution failure (qï…qð}qñ(hzX+Fix thread leak in DNS resolution failure (h{hêubcdocutils.nodes reference qò)qó}qô(hzX`#245`_UresolvedqõKh{hêhU referenceqöhƒ}q÷(UnameX#245qøUrefuriqùX3https://github.com/cpp-netlib/cpp-netlib/issues/245qúh…]h†]h‡]hˆ]h‰]uhu]qûh X#245qü…qý}qþ(hzUh{hóubaubh X)…qÿ}r(hzX)h{hêubeubaubhâ)r}r(hzX4Remove unsupported `client_fwd.hpp` header (`#277`_)rh{hÜh|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhé)r}r(hzjh{jh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K hu]r (h XRemove unsupported r …r }r (hzXRemove unsupported h{jubcdocutils.nodes title_reference r )r}r(hzX`client_fwd.hpp`hƒ}r(h‡]hˆ]h†]h…]h‰]uh{jhu]rh Xclient_fwd.hppr…r}r(hzUh{jubahUtitle_referencerubh X header (r…r}r(hzX header (h{jubhò)r}r(hzX`#277`_hõKh{jhhöhƒ}r(UnameX#277rhùX3https://github.com/cpp-netlib/cpp-netlib/issues/277rh…]h†]h‡]hˆ]h‰]uhu]rh X#277r…r }r!(hzUh{jubaubh X)…r"}r#(hzX)h{jubeubaubhâ)r$}r%(hzX‚Remove support for header-only usage (`#129`_) -- this means that the BOOST_NETWORK_NO_LIB option is no longer actually supported.r&h{hÜh|hhhæhƒ}r'(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r(hé)r)}r*(hzj&h{j$h|hhhìhƒ}r+(h‡]hˆ]h†]h…]h‰]uh‹Khu]r,(h X&Remove support for header-only usage (r-…r.}r/(hzX&Remove support for header-only usage (h{j)ubhò)r0}r1(hzX`#129`_hõKh{j)hhöhƒ}r2(UnameX#129r3hùX3https://github.com/cpp-netlib/cpp-netlib/issues/129r4h…]h†]h‡]hˆ]h‰]uhu]r5h X#129r6…r7}r8(hzUh{j0ubaubh XU) -- this means that the BOOST_NETWORK_NO_LIB option is no longer actually supported.r9…r:}r;(hzXU) -- this means that the BOOST_NETWORK_NO_LIB option is no longer actually supported.h{j)ubeubaubhâ)r<}r=(hzX6Deprecate Synchronous Client implementations (`#279`_)r>h{hÜh|hhhæhƒ}r?(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r@hé)rA}rB(hzj>h{j<h|hhhìhƒ}rC(h‡]hˆ]h†]h…]h‰]uh‹Khu]rD(h X.Deprecate Synchronous Client implementations (rE…rF}rG(hzX.Deprecate Synchronous Client implementations (h{jAubhò)rH}rI(hzX`#279`_hõKh{jAhhöhƒ}rJ(UnameX#279rKhùX3https://github.com/cpp-netlib/cpp-netlib/issues/279rLh…]h†]h‡]hˆ]h‰]uhu]rMh X#279rN…rO}rP(hzUh{jHubaubh X)…rQ}rR(hzX)h{jAubeubaubhâ)rS}rT(hzXCSupport streaming body chunks for PUT/POST client requests (`#27`_)rUh{hÜh|hhhæhƒ}rV(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rWhé)rX}rY(hzjUh{jSh|hhhìhƒ}rZ(h‡]hˆ]h†]h…]h‰]uh‹Khu]r[(h X<Support streaming body chunks for PUT/POST client requests (r\…r]}r^(hzX<Support streaming body chunks for PUT/POST client requests (h{jXubhò)r_}r`(hzX`#27`_hõKh{jXhhöhƒ}ra(UnameX#27rbhùX2https://github.com/cpp-netlib/cpp-netlib/issues/27rch…]h†]h‡]hˆ]h‰]uhu]rdh X#27re…rf}rg(hzUh{j_ubaubh X)…rh}ri(hzX)h{jXubeubaubhâ)rj}rk(hzXDFix non-case-sensitive header parsing for some client tags (`#313`_)rlh{hÜh|hhhæhƒ}rm(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rnhé)ro}rp(hzjlh{jjh|hhhìhƒ}rq(h‡]hˆ]h†]h…]h‰]uh‹Khu]rr(h X<Fix non-case-sensitive header parsing for some client tags (rs…rt}ru(hzX<Fix non-case-sensitive header parsing for some client tags (h{joubhò)rv}rw(hzX`#313`_hõKh{johhöhƒ}rx(UnameX#313ryhùX3https://github.com/cpp-netlib/cpp-netlib/issues/313rzh…]h†]h‡]hˆ]h‰]uhu]r{h X#313r|…r}}r~(hzUh{jvubaubh X)…r}r€(hzX)h{joubeubaubhâ)r}r‚(hzX<Remove unsupported Jamfiles from the whole project (`#316`_)rƒh{hÜh|hhhæhƒ}r„(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r…hé)r†}r‡(hzjƒh{jh|hhhìhƒ}rˆ(h‡]hˆ]h†]h…]h‰]uh‹Khu]r‰(h X4Remove unsupported Jamfiles from the whole project (rŠ…r‹}rŒ(hzX4Remove unsupported Jamfiles from the whole project (h{j†ubhò)r}rŽ(hzX`#316`_hõKh{j†hhöhƒ}r(UnameX#316rhùX3https://github.com/cpp-netlib/cpp-netlib/issues/316r‘h…]h†]h‡]hˆ]h‰]uhu]r’h X#316r“…r”}r•(hzUh{jubaubh X)…r–}r—(hzX)h{j†ubeubaubhâ)r˜}r™(hzX1Add ``make install`` for Linux and OS X (`#285`_)ršh{hÜh|hhhæhƒ}r›(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rœhé)r}rž(hzjšh{j˜h|hhhìhƒ}rŸ(h‡]hˆ]h†]h…]h‰]uh‹Khu]r (h XAdd r¡…r¢}r£(hzXAdd h{jubh½)r¤}r¥(hzX``make install``hƒ}r¦(h‡]hˆ]h†]h…]h‰]uh{jhu]r§h X make installr¨…r©}rª(hzUh{j¤ubahhÈubh X for Linux and OS X (r«…r¬}r­(hzX for Linux and OS X (h{jubhò)r®}r¯(hzX`#285`_hõKh{jhhöhƒ}r°(UnameX#285r±hùX3https://github.com/cpp-netlib/cpp-netlib/issues/285r²h…]h†]h‡]hˆ]h‰]uhu]r³h X#285r´…rµ}r¶(hzUh{j®ubaubh X)…r·}r¸(hzX)h{jubeubaubhâ)r¹}rº(hzX&Fix incorrect Body processing (`#69`_)r»h{hÜh|hhhæhƒ}r¼(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r½hé)r¾}r¿(hzj»h{j¹h|hhhìhƒ}rÀ(h‡]hˆ]h†]h…]h‰]uh‹Khu]rÁ(h XFix incorrect Body processing (rÂ…rÃ}rÄ(hzXFix incorrect Body processing (h{j¾ubhò)rÅ}rÆ(hzX`#69`_hõKh{j¾hhöhƒ}rÇ(UnameX#69rÈhùX2https://github.com/cpp-netlib/cpp-netlib/issues/69rÉh…]h†]h‡]hˆ]h‰]uhu]rÊh X#69rË…rÌ}rÍ(hzUh{jÅubaubh X)…rÎ}rÏ(hzX)h{j¾ubeubaubhâ)rÐ}rÑ(hzX>Support chunked transfer encoding from HTTP responses (`#86`_)rÒh{hÜh|hhhæhƒ}rÓ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÔhé)rÕ}rÖ(hzjÒh{jÐh|hhhìhƒ}r×(h‡]hˆ]h†]h…]h‰]uh‹Khu]rØ(h X7Support chunked transfer encoding from HTTP responses (rÙ…rÚ}rÛ(hzX7Support chunked transfer encoding from HTTP responses (h{jÕubhò)rÜ}rÝ(hzX`#86`_hõKh{jÕhhöhƒ}rÞ(UnameX#86rßhùX2https://github.com/cpp-netlib/cpp-netlib/issues/86ràh…]h†]h‡]hˆ]h‰]uhu]ráh X#86râ…rã}rä(hzUh{jÜubaubh X)…rå}ræ(hzX)h{jÕubeubaubhâ)rç}rè(hzX,Make OS X Clang builds use C++11 and libc++.réh{hÜh|hhhæhƒ}rê(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rëhé)rì}rí(hzjéh{jçh|hhhìhƒ}rî(h‡]hˆ]h†]h…]h‰]uh‹Khu]rïh X,Make OS X Clang builds use C++11 and libc++.rð…rñ}rò(hzjéh{jìubaubaubhâ)ró}rô(hzX#Update Boost requirement to 1.54.0.rõh{hÜh|hhhæhƒ}rö(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r÷hé)rø}rù(hzjõh{jóh|hhhìhƒ}rú(h‡]hˆ]h†]h…]h‰]uh‹Khu]rûh X#Update Boost requirement to 1.54.0.rü…rý}rþ(hzjõh{jøubaubaubhâ)rÿ}r(hzX7Experimental Base64 encoding/decoding library (`#287`_)rh{hÜh|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhé)r}r(hzjh{jÿh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹Khu]r(h X/Experimental Base64 encoding/decoding library (r…r }r (hzX/Experimental Base64 encoding/decoding library (h{jubhò)r }r (hzX`#287`_hõKh{jhhöhƒ}r (UnameX#287rhùX3https://github.com/cpp-netlib/cpp-netlib/issues/287rh…]h†]h‡]hˆ]h‰]uhu]rh X#287r…r}r(hzUh{j ubaubh X)…r}r(hzX)h{jubeubaubhâ)r}r(hzX×*Known test failure:* OS X Xcode Clang 5.0 + Boost 1.54.0 + libc++ don't play well with Boost.Serialization issues, mitigate test breakage but ``cpp-netlib-utils_base64_test`` still fails in this platform. (`#287`_)h{hÜh|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhé)r}r(hzX×*Known test failure:* OS X Xcode Clang 5.0 + Boost 1.54.0 + libc++ don't play well with Boost.Serialization issues, mitigate test breakage but ``cpp-netlib-utils_base64_test`` still fails in this platform. (`#287`_)h{jh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹Khu]r(cdocutils.nodes emphasis r)r}r (hzX*Known test failure:*hƒ}r!(h‡]hˆ]h†]h…]h‰]uh{jhu]r"h XKnown test failure:r#…r$}r%(hzUh{jubahUemphasisr&ubh Xz OS X Xcode Clang 5.0 + Boost 1.54.0 + libc++ don't play well with Boost.Serialization issues, mitigate test breakage but r'…r(}r)(hzXz OS X Xcode Clang 5.0 + Boost 1.54.0 + libc++ don't play well with Boost.Serialization issues, mitigate test breakage but h{jubh½)r*}r+(hzX ``cpp-netlib-utils_base64_test``hƒ}r,(h‡]hˆ]h†]h…]h‰]uh{jhu]r-h Xcpp-netlib-utils_base64_testr.…r/}r0(hzUh{j*ubahhÈubh X still fails in this platform. (r1…r2}r3(hzX still fails in this platform. (h{jubhò)r4}r5(hzX`#287`_hõKh{jhhöhƒ}r6(UnameX#287hùjh…]h†]h‡]hˆ]h‰]uhu]r7h X#287r8…r9}r:(hzUh{j4ubaubh X)…r;}r<(hzX)h{jubeubaubhâ)r=}r>(hzXbProvide a client option to always validate peers for HTTPS requests made by the client. (`#349`_) h{hÜh|hhhæhƒ}r?(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r@hé)rA}rB(hzXaProvide a client option to always validate peers for HTTPS requests made by the client. (`#349`_)h{j=h|hhhìhƒ}rC(h‡]hˆ]h†]h…]h‰]uh‹Khu]rD(h XYProvide a client option to always validate peers for HTTPS requests made by the client. (rE…rF}rG(hzXYProvide a client option to always validate peers for HTTPS requests made by the client. (h{jAubhò)rH}rI(hzX`#349`_hõKh{jAhhöhƒ}rJ(UnameX#349rKhùX3https://github.com/cpp-netlib/cpp-netlib/issues/349rLh…]h†]h‡]hˆ]h‰]uhu]rMh X#349rN…rO}rP(hzUh{jHubaubh X)…rQ}rR(hzX)h{jAubeubaubeubhw)rS}rT(hzX?.. _`#129`: https://github.com/cpp-netlib/cpp-netlib/issues/129U referencedrUKh{hÍh|hhh‚hƒ}rV(hùj4h…]rWhqah†]h‡]hˆ]h‰]rXh5auh‹KhŒhhu]ubhw)rY}rZ(hzX?.. _`#245`: https://github.com/cpp-netlib/cpp-netlib/issues/245jUKh{hÍh|hhh‚hƒ}r[(hùhúh…]r\hPah†]h‡]hˆ]h‰]r]hauh‹K hŒhhu]ubhw)r^}r_(hzX?.. _`#277`: https://github.com/cpp-netlib/cpp-netlib/issues/277jUKh{hÍh|hhh‚hƒ}r`(hùjh…]rah[ah†]h‡]hˆ]h‰]rbhauh‹K!hŒhhu]ubhw)rc}rd(hzX?.. _`#279`: https://github.com/cpp-netlib/cpp-netlib/issues/279jUKh{hÍh|hhh‚hƒ}re(hùjLh…]rfhaah†]h‡]hˆ]h‰]rgh%auh‹K"hŒhhu]ubhw)rh}ri(hzX=.. _`#27`: https://github.com/cpp-netlib/cpp-netlib/issues/27jUKh{hÍh|hhh‚hƒ}rj(hùjch…]rkhSah†]h‡]hˆ]h‰]rlhauh‹K#hŒhhu]ubhw)rm}rn(hzX?.. _`#285`: https://github.com/cpp-netlib/cpp-netlib/issues/285jUKh{hÍh|hhh‚hƒ}ro(hùj²h…]rphJah†]h‡]hˆ]h‰]rqhauh‹K$hŒhhu]ubhw)rr}rs(hzX?.. _`#287`: https://github.com/cpp-netlib/cpp-netlib/issues/287jUKh{hÍh|hhh‚hƒ}rt(hùjh…]ruhIah†]h‡]hˆ]h‰]rvh auh‹K%hŒhhu]ubhw)rw}rx(hzX?.. _`#313`: https://github.com/cpp-netlib/cpp-netlib/issues/313jUKh{hÍh|hhh‚hƒ}ry(hùjzh…]rzhYah†]h‡]hˆ]h‰]r{hauh‹K&hŒhhu]ubhw)r|}r}(hzX?.. _`#316`: https://github.com/cpp-netlib/cpp-netlib/issues/316jUKh{hÍh|hhh‚hƒ}r~(hùj‘h…]rhMah†]h‡]hˆ]h‰]r€hauh‹K'hŒhhu]ubhw)r}r‚(hzX?.. _`#349`: https://github.com/cpp-netlib/cpp-netlib/issues/349jUKh{hÍh|hhh‚hƒ}rƒ(hùjLh…]r„hdah†]h‡]hˆ]h‰]r…h(auh‹K(hŒhhu]ubhw)r†}r‡(hzX=.. _`#69`: https://github.com/cpp-netlib/cpp-netlib/issues/69jUKh{hÍh|hhh‚hƒ}rˆ(hùjÉh…]r‰hTah†]h‡]hˆ]h‰]rŠhauh‹K)hŒhhu]ubhw)r‹}rŒ(hzX=.. _`#86`: https://github.com/cpp-netlib/cpp-netlib/issues/86jUKh{hÍh|hhh‚hƒ}r(hùjàh…]rŽh_ah†]h‡]hˆ]h‰]rh#auh‹K*hŒhhu]ubeubeubh)r}r‘(hzUh{hŽh|hhh’hƒ}r’(h‡]hˆ]h†]h…]r“hrah‰]r”h6auh‹K-hŒhhu]r•(h™)r–}r—(hzX:mod:`cpp-netlib` 0.10r˜h{jh|hhhhƒ}r™(h‡]hˆ]h†]h…]h‰]uh‹K-hŒhhu]rš(h¯)r›}rœ(hzX:mod:`cpp-netlib`rh{j–h|hhh³hƒ}rž(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyrŸh…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹K,hu]r h½)r¡}r¢(hzjhƒ}r£(h‡]hˆ]r¤(hÂjŸXpy-modr¥eh†]h…]h‰]uh{j›hu]r¦h X cpp-netlibr§…r¨}r©(hzUh{j¡ubahhÈubaubh X 0.10rª…r«}r¬(hzX 0.10r­h{j–ubeubh)r®}r¯(hzUh{jh|hhh’hƒ}r°(h‡]hˆ]h†]h…]r±hKah‰]r²hauh‹K0hŒhhu]r³(h™)r´}rµ(hzXv0.10.1r¶h{j®h|hhhhƒ}r·(h‡]hˆ]h†]h…]h‰]uh‹K0hŒhhu]r¸h Xv0.10.1r¹…rº}r»(hzj¶h{j´ubaubhÛ)r¼}r½(hzUh{j®h|hhhÞhƒ}r¾(hàX*h…]h†]h‡]hˆ]h‰]uh‹K1hŒhhu]r¿(hâ)rÀ}rÁ(hzXCDocumentation updates (`#182`_, `#265`_, `#194`_, `#233`_, `#255`_)rÂh{j¼h|hhhæhƒ}rÃ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÄhé)rÅ}rÆ(hzjÂh{jÀh|hhhìhƒ}rÇ(h‡]hˆ]h†]h…]h‰]uh‹K1hu]rÈ(h XDocumentation updates (rÉ…rÊ}rË(hzXDocumentation updates (h{jÅubhò)rÌ}rÍ(hzX`#182`_hõKh{jÅhhöhƒ}rÎ(UnameX#182rÏhùX3https://github.com/cpp-netlib/cpp-netlib/issues/182rÐh…]h†]h‡]hˆ]h‰]uhu]rÑh X#182rÒ…rÓ}rÔ(hzUh{jÌubaubh X, rÕ…rÖ}r×(hzX, h{jÅubhò)rØ}rÙ(hzX`#265`_hõKh{jÅhhöhƒ}rÚ(UnameX#265rÛhùX3https://github.com/cpp-netlib/cpp-netlib/issues/265rÜh…]h†]h‡]hˆ]h‰]uhu]rÝh X#265rÞ…rß}rà(hzUh{jØubaubh X, rá…râ}rã(hzX, h{jÅubhò)rä}rå(hzX`#194`_hõKh{jÅhhöhƒ}ræ(UnameX#194rçhùX3https://github.com/cpp-netlib/cpp-netlib/issues/194rèh…]h†]h‡]hˆ]h‰]uhu]réh X#194rê…rë}rì(hzUh{jäubaubh X, rí…rî}rï(hzX, h{jÅubhò)rð}rñ(hzX`#233`_hõKh{jÅhhöhƒ}rò(UnameX#233róhùX3https://github.com/cpp-netlib/cpp-netlib/issues/233rôh…]h†]h‡]hˆ]h‰]uhu]rõh X#233rö…r÷}rø(hzUh{jðubaubh X, rù…rú}rû(hzX, h{jÅubhò)rü}rý(hzX`#255`_hõKh{jÅhhöhƒ}rþ(UnameX#255rÿhùX3https://github.com/cpp-netlib/cpp-netlib/issues/255rh…]h†]h‡]hˆ]h‰]uhu]rh X#255r…r}r(hzUh{jüubaubh X)…r}r(hzX)h{jÅubeubaubhâ)r}r(hzXnFix issue with async server inadvertently stopping from listening when accepting a connection fails. (`#172`_)h{j¼h|hhhæhƒ}r (h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r hé)r }r (hzXnFix issue with async server inadvertently stopping from listening when accepting a connection fails. (`#172`_)h{jh|hhhìhƒ}r (h‡]hˆ]h†]h…]h‰]uh‹K2hu]r(h XfFix issue with async server inadvertently stopping from listening when accepting a connection fails. (r…r}r(hzXfFix issue with async server inadvertently stopping from listening when accepting a connection fails. (h{j ubhò)r}r(hzX`#172`_hõKh{j hhöhƒ}r(UnameX#172rhùX3https://github.com/cpp-netlib/cpp-netlib/issues/172rh…]h†]h‡]hˆ]h‰]uhu]rh X#172r…r}r(hzUh{jubaubh X)…r}r(hzX)h{j ubeubaubhâ)r}r(hzXXAllow overriding and ultimately removing defaulted headers from HTTP requests. (`#263`_)h{j¼h|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r hé)r!}r"(hzXXAllow overriding and ultimately removing defaulted headers from HTTP requests. (`#263`_)h{jh|hhhìhƒ}r#(h‡]hˆ]h†]h…]h‰]uh‹K4hu]r$(h XPAllow overriding and ultimately removing defaulted headers from HTTP requests. (r%…r&}r'(hzXPAllow overriding and ultimately removing defaulted headers from HTTP requests. (h{j!ubhò)r(}r)(hzX`#263`_hõKh{j!hhöhƒ}r*(UnameX#263r+hùX3https://github.com/cpp-netlib/cpp-netlib/issues/263r,h…]h†]h‡]hˆ]h‰]uhu]r-h X#263r.…r/}r0(hzUh{j(ubaubh X)…r1}r2(hzX)h{j!ubeubaubhâ)r3}r4(hzX6Add `-Wall` to the base rule for GCC builds. (`#264`_)r5h{j¼h|hhhæhƒ}r6(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r7hé)r8}r9(hzj5h{j3h|hhhìhƒ}r:(h‡]hˆ]h†]h…]h‰]uh‹K6hu]r;(h XAdd r<…r=}r>(hzXAdd h{j8ubj )r?}r@(hzX`-Wall`hƒ}rA(h‡]hˆ]h†]h…]h‰]uh{j8hu]rBh X-WallrC…rD}rE(hzUh{j?ubahjubh X# to the base rule for GCC builds. (rF…rG}rH(hzX# to the base rule for GCC builds. (h{j8ubhò)rI}rJ(hzX`#264`_hõKh{j8hhöhƒ}rK(UnameX#264rLhùX3https://github.com/cpp-netlib/cpp-netlib/issues/264rMh…]h†]h‡]hˆ]h‰]uhu]rNh X#264rO…rP}rQ(hzUh{jIubaubh X)…rR}rS(hzX)h{j8ubeubaubhâ)rT}rU(hzXBMake the server implementation throw on startup errors. (`#166`_) h{j¼h|hhhæhƒ}rV(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rWhé)rX}rY(hzXAMake the server implementation throw on startup errors. (`#166`_)h{jTh|hhhìhƒ}rZ(h‡]hˆ]h†]h…]h‰]uh‹K7hu]r[(h X9Make the server implementation throw on startup errors. (r\…r]}r^(hzX9Make the server implementation throw on startup errors. (h{jXubhò)r_}r`(hzX`#166`_hõKh{jXhhöhƒ}ra(UnameX#166rbhùX3https://github.com/cpp-netlib/cpp-netlib/issues/166rch…]h†]h‡]hˆ]h‰]uhu]rdh X#166re…rf}rg(hzUh{j_ubaubh X)…rh}ri(hzX)h{jXubeubaubeubhw)rj}rk(hzX?.. _`#182`: https://github.com/cpp-netlib/cpp-netlib/issues/182jUKh{j®h|hhh‚hƒ}rl(hùjÐh…]rmhlah†]h‡]hˆ]h‰]rnh0auh‹K9hŒhhu]ubhw)ro}rp(hzX?.. _`#265`: https://github.com/cpp-netlib/cpp-netlib/issues/265jUKh{j®h|hhh‚hƒ}rq(hùjÜh…]rrhFah†]h‡]hˆ]h‰]rsh auh‹K:hŒhhu]ubhw)rt}ru(hzX?.. _`#194`: https://github.com/cpp-netlib/cpp-netlib/issues/194jUKh{j®h|hhh‚hƒ}rv(hùjèh…]rwhRah†]h‡]hˆ]h‰]rxhauh‹K;hŒhhu]ubhw)ry}rz(hzX?.. _`#172`: https://github.com/cpp-netlib/cpp-netlib/issues/172jUKh{j®h|hhh‚hƒ}r{(hùjh…]r|h]ah†]h‡]hˆ]h‰]r}h!auh‹KhŒhhu]ubhw)rˆ}r‰(hzX?.. _`#264`: https://github.com/cpp-netlib/cpp-netlib/issues/264jUKh{j®h|hhh‚hƒ}rŠ(hùjMh…]r‹hGah†]h‡]hˆ]h‰]rŒh auh‹K?hŒhhu]ubhw)r}rŽ(hzX?.. _`#255`: https://github.com/cpp-netlib/cpp-netlib/issues/255jUKh{j®h|hhh‚hƒ}r(hùjh…]rhfah†]h‡]hˆ]h‰]r‘h*auh‹K@hŒhhu]ubhw)r’}r“(hzX?.. _`#166`: https://github.com/cpp-netlib/cpp-netlib/issues/166jUKh{j®h|hhh‚hƒ}r”(hùjch…]r•h`ah†]h‡]hˆ]h‰]r–h$auh‹KAhŒhhu]ubeubh)r—}r˜(hzUh{jh|hhh’hƒ}r™(h‡]hˆ]h†]h…]ršh^ah‰]r›h"auh‹KDhŒhhu]rœ(h™)r}rž(hzXv0.10.0rŸh{j—h|hhhhƒ}r (h‡]hˆ]h†]h…]h‰]uh‹KDhŒhhu]r¡h Xv0.10.0r¢…r£}r¤(hzjŸh{jubaubhÛ)r¥}r¦(hzUh{j—h|hhhÞhƒ}r§(hàX*h…]h†]h‡]hˆ]h‰]uh‹KEhŒhhu]r¨(hâ)r©}rª(hzXCAdded support for more HTTP status codes (206, 408, 412, 416, 507).r«h{j¥h|hhhæhƒ}r¬(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r­hé)r®}r¯(hzj«h{j©h|hhhìhƒ}r°(h‡]hˆ]h†]h…]h‰]uh‹KEhu]r±h XCAdded support for more HTTP status codes (206, 408, 412, 416, 507).r²…r³}r´(hzj«h{j®ubaubaubhâ)rµ}r¶(hzX+Refactored the parser for chunked encoding.r·h{j¥h|hhhæhƒ}r¸(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r¹hé)rº}r»(hzj·h{jµh|hhhìhƒ}r¼(h‡]hˆ]h†]h…]h‰]uh‹KFhu]r½h X+Refactored the parser for chunked encoding.r¾…r¿}rÀ(hzj·h{jºubaubaubhâ)rÁ}rÂ(hzXWFixed parsing chunked encoding if the response body has ``CLRFCLRF``.rÃh{j¥h|hhhæhƒ}rÄ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÅhé)rÆ}rÇ(hzjÃh{jÁh|hhhìhƒ}rÈ(h‡]hˆ]h†]h…]h‰]uh‹KGhu]rÉ(h X8Fixed parsing chunked encoding if the response body has rÊ…rË}rÌ(hzX8Fixed parsing chunked encoding if the response body has h{jÆubh½)rÍ}rÎ(hzX``CLRFCLRF``hƒ}rÏ(h‡]hˆ]h†]h…]h‰]uh{jÆhu]rÐh XCLRFCLRFrÑ…rÒ}rÓ(hzUh{jÍubahhÈubh X.…rÔ}rÕ(hzX.h{jÆubeubaubhâ)rÖ}r×(hzX Added librt dependency on Linux.rØh{j¥h|hhhæhƒ}rÙ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÚhé)rÛ}rÜ(hzjØh{jÖh|hhhìhƒ}rÝ(h‡]hˆ]h†]h…]h‰]uh‹KHhu]rÞh X Added librt dependency on Linux.rß…rà}rá(hzjØh{jÛubaubaubhâ)râ}rã(hzX@Check the callback in the asynchronous client before calling it.räh{j¥h|hhhæhƒ}rå(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]ræhé)rç}rè(hzjäh{jâh|hhhìhƒ}ré(h‡]hˆ]h†]h…]h‰]uh‹KIhu]rêh X@Check the callback in the asynchronous client before calling it.rë…rì}rí(hzjäh{jçubaubaubhâ)rî}rï(hzX(Fixed issues `#110`_, `#168`_, `#213`_. h{j¥h|hhhæhƒ}rð(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rñhé)rò}ró(hzX'Fixed issues `#110`_, `#168`_, `#213`_.h{jîh|hhhìhƒ}rô(h‡]hˆ]h†]h…]h‰]uh‹KJhu]rõ(h X Fixed issues rö…r÷}rø(hzX Fixed issues h{jòubhò)rù}rú(hzX`#110`_hõKh{jòhhöhƒ}rû(UnameX#110rühùX3https://github.com/cpp-netlib/cpp-netlib/issues/110rýh…]h†]h‡]hˆ]h‰]uhu]rþh X#110rÿ…r}r(hzUh{jùubaubh X, r…r}r(hzX, h{jòubhò)r}r(hzX`#168`_hõKh{jòhhöhƒ}r(UnameX#168rhùX3https://github.com/cpp-netlib/cpp-netlib/issues/168r h…]h†]h‡]hˆ]h‰]uhu]r h X#168r …r }r (hzUh{jubaubh X, r…r}r(hzX, h{jòubhò)r}r(hzX`#213`_hõKh{jòhhöhƒ}r(UnameX#213rhùX3https://github.com/cpp-netlib/cpp-netlib/issues/213rh…]h†]h‡]hˆ]h‰]uhu]rh X#213r…r}r(hzUh{jubaubh X.…r}r(hzX.h{jòubeubaubeubhw)r}r(hzX?.. _`#110`: https://github.com/cpp-netlib/cpp-netlib/issues/110jUKh{j—h|hhh‚hƒ}r(hùjýh…]rhQah†]h‡]hˆ]h‰]r hauh‹KLhŒhhu]ubhw)r!}r"(hzX?.. _`#168`: https://github.com/cpp-netlib/cpp-netlib/issues/168jUKh{j—h|hhh‚hƒ}r#(hùj h…]r$htah†]h‡]hˆ]h‰]r%h8auh‹KMhŒhhu]ubhw)r&}r'(hzX?.. _`#213`: https://github.com/cpp-netlib/cpp-netlib/issues/213jUKh{j—h|hhh‚hƒ}r((hùjh…]r)hWah†]h‡]hˆ]h‰]r*hauh‹KNhŒhhu]ubeubeubh)r+}r,(hzUh{hŽh|hhh’hƒ}r-(h‡]hˆ]h†]h…]r.hXah‰]r/hauh‹KQhŒhhu]r0(h™)r1}r2(hzX:mod:`cpp-netlib` 0.9r3h{j+h|hhhhƒ}r4(h‡]hˆ]h†]h…]h‰]uh‹KQhŒhhu]r5(h¯)r6}r7(hzX:mod:`cpp-netlib`r8h{j1h|hhh³hƒ}r9(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyr:h…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹KPhu]r;h½)r<}r=(hzj8hƒ}r>(h‡]hˆ]r?(hÂj:Xpy-modr@eh†]h…]h‰]uh{j6hu]rAh X cpp-netlibrB…rC}rD(hzUh{j<ubahhÈubaubh X 0.9rE…rF}rG(hzX 0.9rHh{j1ubeubh)rI}rJ(hzUh{j+h|hhh’hƒ}rK(h‡]hˆ]h†]h…]rLhOah‰]rMhauh‹KThŒhhu]rN(h™)rO}rP(hzXv0.9.5rQh{jIh|hhhhƒ}rR(h‡]hˆ]h†]h…]h‰]uh‹KThŒhhu]rSh Xv0.9.5rT…rU}rV(hzjQh{jOubaubhÛ)rW}rX(hzUh{jIh|hhhÞhƒ}rY(hàX*h…]h†]h‡]hˆ]h‰]uh‹KUhŒhhu]rZ(hâ)r[}r\(hzXBRemoved dependency on Boost.Parameter from HTTP client and server.r]h{jWh|hhhæhƒ}r^(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r_hé)r`}ra(hzj]h{j[h|hhhìhƒ}rb(h‡]hˆ]h†]h…]h‰]uh‹KUhu]rch XBRemoved dependency on Boost.Parameter from HTTP client and server.rd…re}rf(hzj]h{j`ubaubaubhâ)rg}rh(hzX)Fixed for Clang error on Twitter example.rih{jWh|hhhæhƒ}rj(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rkhé)rl}rm(hzjih{jgh|hhhìhƒ}rn(h‡]hˆ]h†]h…]h‰]uh‹KVhu]roh X)Fixed for Clang error on Twitter example.rp…rq}rr(hzjih{jlubaubaubhâ)rs}rt(hzX/Added source port to the request (HTTP server).ruh{jWh|hhhæhƒ}rv(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rwhé)rx}ry(hzjuh{jsh|hhhìhƒ}rz(h‡]hˆ]h†]h…]h‰]uh‹KWhu]r{h X/Added source port to the request (HTTP server).r|…r}}r~(hzjuh{jxubaubaubhâ)r}r€(hzX(Updated CMake config for MSVC 2010/2012.rh{jWh|hhhæhƒ}r‚(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rƒhé)r„}r…(hzjh{jh|hhhìhƒ}r†(h‡]hˆ]h†]h…]h‰]uh‹KXhu]r‡h X(Updated CMake config for MSVC 2010/2012.rˆ…r‰}rŠ(hzjh{j„ubaubaubhâ)r‹}rŒ(hzX@Now support chunked content encoding in client response parsing.rh{jWh|hhhæhƒ}rŽ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhé)r}r‘(hzjh{j‹h|hhhìhƒ}r’(h‡]hˆ]h†]h…]h‰]uh‹KYhu]r“h X@Now support chunked content encoding in client response parsing.r”…r•}r–(hzjh{jubaubaubhâ)r—}r˜(hzXBFixed bug with client not invoking callback when a request fails. h{jWh|hhhæhƒ}r™(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]ršhé)r›}rœ(hzXAFixed bug with client not invoking callback when a request fails.rh{j—h|hhhìhƒ}rž(h‡]hˆ]h†]h…]h‰]uh‹KZhu]rŸh XAFixed bug with client not invoking callback when a request fails.r …r¡}r¢(hzjh{j›ubaubaubeubeubh)r£}r¤(hzUh{j+h|hhh’hƒ}r¥(h‡]hˆ]h†]h…]r¦hpah‰]r§h4auh‹K]hŒhhu]r¨(h™)r©}rª(hzXv0.9.4r«h{j£h|hhhhƒ}r¬(h‡]hˆ]h†]h…]h‰]uh‹K]hŒhhu]r­h Xv0.9.4r®…r¯}r°(hzj«h{j©ubaubhÛ)r±}r²(hzUh{j£h|hhhÞhƒ}r³(hàX*h…]h†]h‡]hˆ]h‰]uh‹K^hŒhhu]r´(hâ)rµ}r¶(hzXLots of URI fixes.r·h{j±h|hhhæhƒ}r¸(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r¹hé)rº}r»(hzj·h{jµh|hhhìhƒ}r¼(h‡]hˆ]h†]h…]h‰]uh‹K^hu]r½h XLots of URI fixes.r¾…r¿}rÀ(hzj·h{jºubaubaubhâ)rÁ}rÂ(hzXWFixed async_server's request handler so it doesn't make copies of the supplied handler.rÃh{j±h|hhhæhƒ}rÄ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÅhé)rÆ}rÇ(hzjÃh{jÁh|hhhìhƒ}rÈ(h‡]hˆ]h†]h…]h‰]uh‹K_hu]rÉh XWFixed async_server's request handler so it doesn't make copies of the supplied handler.rÊ…rË}rÌ(hzjÃh{jÆubaubaubhâ)rÍ}rÎ(hzXKFix for issue `#73`_ regarding SSL connections ending in short read errors.rÏh{j±h|hhhæhƒ}rÐ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÑhé)rÒ}rÓ(hzjÏh{jÍh|hhhìhƒ}rÔ(h‡]hˆ]h†]h…]h‰]uh‹K`hu]rÕ(h XFix for issue rÖ…r×}rØ(hzXFix for issue h{jÒubhò)rÙ}rÚ(hzX`#73`_hõKh{jÒhhöhƒ}rÛ(UnameX#73rÜhùX2https://github.com/cpp-netlib/cpp-netlib/issues/73rÝh…]h†]h‡]hˆ]h‰]uhu]rÞh X#73rß…rà}rá(hzUh{jÙubaubh X7 regarding SSL connections ending in short read errors.râ…rã}rä(hzX7 regarding SSL connections ending in short read errors.h{jÒubeubaubhâ)rå}ræ(hzXFinal C++03-only release. h{j±h|hhhæhƒ}rç(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rèhé)ré}rê(hzXFinal C++03-only release.rëh{jåh|hhhìhƒ}rì(h‡]hˆ]h†]h…]h‰]uh‹Kahu]ríh XFinal C++03-only release.rî…rï}rð(hzjëh{jéubaubaubeubhw)rñ}rò(hzX=.. _`#73`: https://github.com/cpp-netlib/cpp-netlib/issues/73jUKh{j£h|hhh‚hƒ}ró(hùjÝh…]rôhnah†]h‡]hˆ]h‰]rõh2auh‹KchŒhhu]ubeubh)rö}r÷(hzUh{j+h|hhh’hƒ}rø(h‡]hˆ]h†]h…]rùhLah‰]rúhauh‹KfhŒhhu]rû(h™)rü}rý(hzXv0.9.3rþh{jöh|hhhhƒ}rÿ(h‡]hˆ]h†]h…]h‰]uh‹KfhŒhhu]rh Xv0.9.3r…r}r(hzjþh{jüubaubhÛ)r}r(hzUh{jöh|hhhÞhƒ}r(hàX*h…]h†]h‡]hˆ]h‰]uh‹KghŒhhu]r(hâ)r}r (hzX"URI, HTTP client and HTTP server are now built as static libraries (``libcppnetlib-uri.a``, ``libcppnetlib-client-connections.a`` and ``libcppnetlib-server-parsers.a`` on Linux and ``cppnetlib-uri.lib``, ``cppnetlib-client-connections.lib`` and ``cppnetlib-server-parsers.lib`` on Windows).r h{jh|hhhæhƒ}r (h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r hé)r }r(hzj h{jh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹Kghu]r(h XDURI, HTTP client and HTTP server are now built as static libraries (r…r}r(hzXDURI, HTTP client and HTTP server are now built as static libraries (h{j ubh½)r}r(hzX``libcppnetlib-uri.a``hƒ}r(h‡]hˆ]h†]h…]h‰]uh{j hu]rh Xlibcppnetlib-uri.ar…r}r(hzUh{jubahhÈubh X, r…r}r(hzX, h{j ubh½)r}r(hzX%``libcppnetlib-client-connections.a``hƒ}r (h‡]hˆ]h†]h…]h‰]uh{j hu]r!h X!libcppnetlib-client-connections.ar"…r#}r$(hzUh{jubahhÈubh X and r%…r&}r'(hzX and h{j ubh½)r(}r)(hzX!``libcppnetlib-server-parsers.a``hƒ}r*(h‡]hˆ]h†]h…]h‰]uh{j hu]r+h Xlibcppnetlib-server-parsers.ar,…r-}r.(hzUh{j(ubahhÈubh X on Linux and r/…r0}r1(hzX on Linux and h{j ubh½)r2}r3(hzX``cppnetlib-uri.lib``hƒ}r4(h‡]hˆ]h†]h…]h‰]uh{j hu]r5h Xcppnetlib-uri.libr6…r7}r8(hzUh{j2ubahhÈubh X, r9…r:}r;(hzX, h{j ubh½)r<}r=(hzX$``cppnetlib-client-connections.lib``hƒ}r>(h‡]hˆ]h†]h…]h‰]uh{j hu]r?h X cppnetlib-client-connections.libr@…rA}rB(hzUh{j<ubahhÈubh X and rC…rD}rE(hzX and h{j ubh½)rF}rG(hzX ``cppnetlib-server-parsers.lib``hƒ}rH(h‡]hˆ]h†]h…]h‰]uh{j hu]rIh Xcppnetlib-server-parsers.librJ…rK}rL(hzUh{jFubahhÈubh X on Windows).rM…rN}rO(hzX on Windows).h{j ubeubaubhâ)rP}rQ(hzXUpdated URI parser.rRh{jh|hhhæhƒ}rS(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rThé)rU}rV(hzjRh{jPh|hhhìhƒ}rW(h‡]hˆ]h†]h…]h‰]uh‹Khhu]rXh XUpdated URI parser.rY…rZ}r[(hzjRh{jUubaubaubhâ)r\}r](hzXA new URI builder.r^h{jh|hhhæhƒ}r_(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r`hé)ra}rb(hzj^h{j\h|hhhìhƒ}rc(h‡]hˆ]h†]h…]h‰]uh‹Kihu]rdh XA new URI builder.re…rf}rg(hzj^h{jaubaubaubhâ)rh}ri(hzXURI support for IPv6 RFC 2732.rjh{jh|hhhæhƒ}rk(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rlhé)rm}rn(hzjjh{jhh|hhhìhƒ}ro(h‡]hˆ]h†]h…]h‰]uh‹Kjhu]rph XURI support for IPv6 RFC 2732.rq…rr}rs(hzjjh{jmubaubaubhâ)rt}ru(hzXLFixed issues `#67`_, `#72`_, `#78`_, `#79`_, `#80`_, `#81`_, `#82`_, `#83`_.rvh{jh|hhhæhƒ}rw(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rxhé)ry}rz(hzjvh{jth|hhhìhƒ}r{(h‡]hˆ]h†]h…]h‰]uh‹Kkhu]r|(h X Fixed issues r}…r~}r(hzX Fixed issues h{jyubhò)r€}r(hzX`#67`_hõKh{jyhhöhƒ}r‚(UnameX#67rƒhùX2https://github.com/cpp-netlib/cpp-netlib/issues/67r„h…]h†]h‡]hˆ]h‰]uhu]r…h X#67r†…r‡}rˆ(hzUh{j€ubaubh X, r‰…rŠ}r‹(hzX, h{jyubhò)rŒ}r(hzX`#72`_hõKh{jyhhöhƒ}rŽ(UnameX#72rhùX2https://github.com/cpp-netlib/cpp-netlib/issues/72rh…]h†]h‡]hˆ]h‰]uhu]r‘h X#72r’…r“}r”(hzUh{jŒubaubh X, r•…r–}r—(hzX, h{jyubhò)r˜}r™(hzX`#78`_hõKh{jyhhöhƒ}rš(UnameX#78r›hùX2https://github.com/cpp-netlib/cpp-netlib/issues/78rœh…]h†]h‡]hˆ]h‰]uhu]rh X#78rž…rŸ}r (hzUh{j˜ubaubh X, r¡…r¢}r£(hzX, h{jyubhò)r¤}r¥(hzX`#79`_hõKh{jyhhöhƒ}r¦(UnameX#79r§hùX2https://github.com/cpp-netlib/cpp-netlib/issues/79r¨h…]h†]h‡]hˆ]h‰]uhu]r©h X#79rª…r«}r¬(hzUh{j¤ubaubh X, r­…r®}r¯(hzX, h{jyubhò)r°}r±(hzX`#80`_hõKh{jyhhöhƒ}r²(UnameX#80r³hùX2https://github.com/cpp-netlib/cpp-netlib/issues/80r´h…]h†]h‡]hˆ]h‰]uhu]rµh X#80r¶…r·}r¸(hzUh{j°ubaubh X, r¹…rº}r»(hzX, h{jyubhò)r¼}r½(hzX`#81`_hõKh{jyhhöhƒ}r¾(UnameX#81r¿hùX2https://github.com/cpp-netlib/cpp-netlib/issues/81rÀh…]h†]h‡]hˆ]h‰]uhu]rÁh X#81rÂ…rÃ}rÄ(hzUh{j¼ubaubh X, rÅ…rÆ}rÇ(hzX, h{jyubhò)rÈ}rÉ(hzX`#82`_hõKh{jyhhöhƒ}rÊ(UnameX#82rËhùX2https://github.com/cpp-netlib/cpp-netlib/issues/82rÌh…]h†]h‡]hˆ]h‰]uhu]rÍh X#82rÎ…rÏ}rÐ(hzUh{jÈubaubh X, rÑ…rÒ}rÓ(hzX, h{jyubhò)rÔ}rÕ(hzX`#83`_hõKh{jyhhöhƒ}rÖ(UnameX#83r×hùX2https://github.com/cpp-netlib/cpp-netlib/issues/83rØh…]h†]h‡]hˆ]h‰]uhu]rÙh X#83rÚ…rÛ}rÜ(hzUh{jÔubaubh X.…rÝ}rÞ(hzX.h{jyubeubaubhâ)rß}rà(hzXNew examples for the HTTP client, including an Atom feed, an RSS feed and a very simple client that uses the Twitter Search API. h{jh|hhhæhƒ}rá(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]râhé)rã}rä(hzX€New examples for the HTTP client, including an Atom feed, an RSS feed and a very simple client that uses the Twitter Search API.råh{jßh|hhhìhƒ}ræ(h‡]hˆ]h†]h…]h‰]uh‹Klhu]rçh X€New examples for the HTTP client, including an Atom feed, an RSS feed and a very simple client that uses the Twitter Search API.rè…ré}rê(hzjåh{jãubaubaubeubhw)rë}rì(hzX=.. _`#67`: https://github.com/cpp-netlib/cpp-netlib/issues/67jUKh{jöh|hhh‚hƒ}rí(hùj„h…]rîhUah†]h‡]hˆ]h‰]rïhauh‹KohŒhhu]ubhw)rð}rñ(hzX=.. _`#72`: https://github.com/cpp-netlib/cpp-netlib/issues/72jUKh{jöh|hhh‚hƒ}rò(hùjh…]róhoah†]h‡]hˆ]h‰]rôh3auh‹KphŒhhu]ubhw)rõ}rö(hzX=.. _`#78`: https://github.com/cpp-netlib/cpp-netlib/issues/78jUKh{jöh|hhh‚hƒ}r÷(hùjœh…]røhjah†]h‡]hˆ]h‰]rùh.auh‹KqhŒhhu]ubhw)rú}rû(hzX=.. _`#79`: https://github.com/cpp-netlib/cpp-netlib/issues/79jUKh{jöh|hhh‚hƒ}rü(hùj¨h…]rýhiah†]h‡]hˆ]h‰]rþh-auh‹KrhŒhhu]ubhw)rÿ}r(hzX=.. _`#80`: https://github.com/cpp-netlib/cpp-netlib/issues/80jUKh{jöh|hhh‚hƒ}r(hùj´h…]rhZah†]h‡]hˆ]h‰]rhauh‹KshŒhhu]ubhw)r}r(hzX=.. _`#81`: https://github.com/cpp-netlib/cpp-netlib/issues/81jUKh{jöh|hhh‚hƒ}r(hùjÀh…]rhHah†]h‡]hˆ]h‰]rh auh‹KthŒhhu]ubhw)r }r (hzX=.. _`#82`: https://github.com/cpp-netlib/cpp-netlib/issues/82jUKh{jöh|hhh‚hƒ}r (hùjÌh…]r h\ah†]h‡]hˆ]h‰]r h auh‹KuhŒhhu]ubhw)r}r(hzX=.. _`#83`: https://github.com/cpp-netlib/cpp-netlib/issues/83jUKh{jöh|hhh‚hƒ}r(hùjØh…]rhNah†]h‡]hˆ]h‰]rhauh‹KvhŒhhu]ubeubh)r}r(hzUh{j+h|hhh’hƒ}r(h‡]hˆ]h†]h…]rhEah‰]rh auh‹KyhŒhhu]r(h™)r}r(hzXv0.9.2rh{jh|hhhhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹KyhŒhhu]rh Xv0.9.2r…r}r (hzjh{jubaubhÛ)r!}r"(hzUh{jh|hhhÞhƒ}r#(hàX*h…]h†]h‡]hˆ]h‰]uh‹KzhŒhhu]r$hâ)r%}r&(hzXCritial bug fixes to v0.9.1. h{j!h|hhhæhƒ}r'(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r(hé)r)}r*(hzXCritial bug fixes to v0.9.1.r+h{j%h|hhhìhƒ}r,(h‡]hˆ]h†]h…]h‰]uh‹Kzhu]r-h XCritial bug fixes to v0.9.1.r.…r/}r0(hzj+h{j)ubaubaubaubeubh)r1}r2(hzUh{j+h|hhh’hƒ}r3(h‡]hˆ]h†]h…]r4hBah‰]r5hauh‹K}hŒhhu]r6(h™)r7}r8(hzXv0.9.1r9h{j1h|hhhhƒ}r:(h‡]hˆ]h†]h…]h‰]uh‹K}hŒhhu]r;h Xv0.9.1r<…r=}r>(hzj9h{j7ubaubhÛ)r?}r@(hzUh{j1h|hhhÞhƒ}rA(hàX*h…]h†]h‡]hˆ]h‰]uh‹K~hŒhhu]rB(hâ)rC}rD(hzXŽIntroduced macro ``BOOST_NETWORK_DEFAULT_TAG`` to allow for programmatically defining the default flag to use throughout the compilation unit.h{j?h|hhhæhƒ}rE(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rFhé)rG}rH(hzXŽIntroduced macro ``BOOST_NETWORK_DEFAULT_TAG`` to allow for programmatically defining the default flag to use throughout the compilation unit.h{jCh|hhhìhƒ}rI(h‡]hˆ]h†]h…]h‰]uh‹K~hu]rJ(h XIntroduced macro rK…rL}rM(hzXIntroduced macro h{jGubh½)rN}rO(hzX``BOOST_NETWORK_DEFAULT_TAG``hƒ}rP(h‡]hˆ]h†]h…]h‰]uh{jGhu]rQh XBOOST_NETWORK_DEFAULT_TAGrR…rS}rT(hzUh{jNubahhÈubh X` to allow for programmatically defining the default flag to use throughout the compilation unit.rU…rV}rW(hzX` to allow for programmatically defining the default flag to use throughout the compilation unit.h{jGubeubaubhâ)rX}rY(hzXSupport for streaming body handlers when performing HTTP client operations. See documentation for HTTP client interface for more information.h{j?h|hhhæhƒ}rZ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r[hé)r\}r](hzXSupport for streaming body handlers when performing HTTP client operations. See documentation for HTTP client interface for more information.r^h{jXh|hhhìhƒ}r_(h‡]hˆ]h†]h…]h‰]uh‹K€hu]r`h XSupport for streaming body handlers when performing HTTP client operations. See documentation for HTTP client interface for more information.ra…rb}rc(hzj^h{j\ubaubaubhâ)rd}re(hzXNumerous bug fixes from v0.9.0.rfh{j?h|hhhæhƒ}rg(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhhé)ri}rj(hzjfh{jdh|hhhìhƒ}rk(h‡]hˆ]h†]h…]h‰]uh‹K‚hu]rlh XNumerous bug fixes from v0.9.0.rm…rn}ro(hzjfh{jiubaubaubhâ)rp}rq(hzXGoogle, Inc. contributions. h{j?h|hhhæhƒ}rr(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rshé)rt}ru(hzXGoogle, Inc. contributions.rvh{jph|hhhìhƒ}rw(h‡]hˆ]h†]h…]h‰]uh‹Kƒhu]rxh XGoogle, Inc. contributions.ry…rz}r{(hzjvh{jtubaubaubeubeubh)r|}r}(hzUh{j+h|hhh’hƒ}r~(h‡]hˆ]h†]h…]rhCah‰]r€hauh‹K†hŒhhu]r(h™)r‚}rƒ(hzXv0.9.0r„h{j|h|hhhhƒ}r…(h‡]hˆ]h†]h…]h‰]uh‹K†hŒhhu]r†h Xv0.9.0r‡…rˆ}r‰(hzj„h{j‚ubaubhÛ)rŠ}r‹(hzUh{j|h|hhhÞhƒ}rŒ(hàX*h…]h†]h‡]hˆ]h‰]uh‹K‡hŒhhu]r(hâ)rŽ}r(hzX**IMPORTANT BREAKING CHANGE**: By default all compile-time heavy parser implementations are now compiled to external static libraries. In order to use :mod:`cpp-netlib` in header-only mode, users must define the preprocessor macro ``BOOST_NETWORK_NO_LIB`` before including any :mod:`cpp-netlib` header. This breaks code that relied on the version 0.8.x line where the library is strictly header-only.h{jŠh|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r‘hé)r’}r“(hzX**IMPORTANT BREAKING CHANGE**: By default all compile-time heavy parser implementations are now compiled to external static libraries. In order to use :mod:`cpp-netlib` in header-only mode, users must define the preprocessor macro ``BOOST_NETWORK_NO_LIB`` before including any :mod:`cpp-netlib` header. This breaks code that relied on the version 0.8.x line where the library is strictly header-only.h{jŽh|hhhìhƒ}r”(h‡]hˆ]h†]h…]h‰]uh‹K‡hu]r•(cdocutils.nodes strong r–)r—}r˜(hzX**IMPORTANT BREAKING CHANGE**hƒ}r™(h‡]hˆ]h†]h…]h‰]uh{j’hu]ršh XIMPORTANT BREAKING CHANGEr›…rœ}r(hzUh{j—ubahUstrongržubh Xz: By default all compile-time heavy parser implementations are now compiled to external static libraries. In order to use rŸ…r }r¡(hzXz: By default all compile-time heavy parser implementations are now compiled to external static libraries. In order to use h{j’ubh¯)r¢}r£(hzX:mod:`cpp-netlib`r¤h{j’h|hhh³hƒ}r¥(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyr¦h…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹K‡hu]r§h½)r¨}r©(hzj¤hƒ}rª(h‡]hˆ]r«(hÂj¦Xpy-modr¬eh†]h…]h‰]uh{j¢hu]r­h X cpp-netlibr®…r¯}r°(hzUh{j¨ubahhÈubaubh X? in header-only mode, users must define the preprocessor macro r±…r²}r³(hzX? in header-only mode, users must define the preprocessor macro h{j’ubh½)r´}rµ(hzX``BOOST_NETWORK_NO_LIB``hƒ}r¶(h‡]hˆ]h†]h…]h‰]uh{j’hu]r·h XBOOST_NETWORK_NO_LIBr¸…r¹}rº(hzUh{j´ubahhÈubh X before including any r»…r¼}r½(hzX before including any h{j’ubh¯)r¾}r¿(hzX:mod:`cpp-netlib`rÀh{j’h|hhh³hƒ}rÁ(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyrÂh…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹K‡hu]rÃh½)rÄ}rÅ(hzjÀhƒ}rÆ(h‡]hˆ]rÇ(hÂjÂXpy-modrÈeh†]h…]h‰]uh{j¾hu]rÉh X cpp-netlibrÊ…rË}rÌ(hzUh{jÄubahhÈubaubh Xj header. This breaks code that relied on the version 0.8.x line where the library is strictly header-only.rÍ…rÎ}rÏ(hzXj header. This breaks code that relied on the version 0.8.x line where the library is strictly header-only.h{j’ubeubaubhâ)rÐ}rÑ(hzX¤Fix issue #41: Introduce a macro ``BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG`` which makes the default HTTP client use ``tags::http_async_8bit_udp_resolve`` as the tag.h{jŠh|hhhæhƒ}rÒ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÓhé)rÔ}rÕ(hzX¤Fix issue #41: Introduce a macro ``BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG`` which makes the default HTTP client use ``tags::http_async_8bit_udp_resolve`` as the tag.h{jÐh|hhhìhƒ}rÖ(h‡]hˆ]h†]h…]h‰]uh‹Khu]r×(h X!Fix issue #41: Introduce a macro rØ…rÙ}rÚ(hzX!Fix issue #41: Introduce a macro h{jÔubh½)rÛ}rÜ(hzX)``BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG``hƒ}rÝ(h‡]hˆ]h†]h…]h‰]uh{jÔhu]rÞh X%BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAGrß…rà}rá(hzUh{jÛubahhÈubh X) which makes the default HTTP client use râ…rã}rä(hzX) which makes the default HTTP client use h{jÔubh½)rå}ræ(hzX%``tags::http_async_8bit_udp_resolve``hƒ}rç(h‡]hˆ]h†]h…]h‰]uh{jÔhu]rèh X!tags::http_async_8bit_udp_resolveré…rê}rë(hzUh{jåubahhÈubh X as the tag.rì…rí}rî(hzX as the tag.h{jÔubeubaubhâ)rï}rð(hzX`Fix issue #40: Write the status line and headers in a single buffer write instead of two writes.h{jŠh|hhhæhƒ}rñ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]ròhé)ró}rô(hzX`Fix issue #40: Write the status line and headers in a single buffer write instead of two writes.rõh{jïh|hhhìhƒ}rö(h‡]hˆ]h†]h…]h‰]uh‹Khu]r÷h X`Fix issue #40: Write the status line and headers in a single buffer write instead of two writes.rø…rù}rú(hzjõh{jóubaubaubhâ)rû}rü(hzXZMore consistent message API for client and server messages (request and response objects).h{jŠh|hhhæhƒ}rý(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rþhé)rÿ}r(hzXZMore consistent message API for client and server messages (request and response objects).rh{jûh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K’hu]rh XZMore consistent message API for client and server messages (request and response objects).r…r}r(hzjh{jÿubaubaubhâ)r}r(hzXxRefactoring of internal implementations to allow better separation of concerns and more manageable coding/documentation.h{jŠh|hhhæhƒ}r (h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r hé)r }r (hzXxRefactoring of internal implementations to allow better separation of concerns and more manageable coding/documentation.r h{jh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K”hu]rh XxRefactoring of internal implementations to allow better separation of concerns and more manageable coding/documentation.r…r}r(hzj h{j ubaubaubhâ)r}r(hzXMClient and server constructors that support Boost.Parameter named parameters.rh{jŠh|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhé)r}r(hzjh{jh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K–hu]rh XMClient and server constructors that support Boost.Parameter named parameters.r…r}r(hzjh{jubaubaubhâ)r}r (hzXrClient and server constructors now take in an optional reference to a Boost.Asio ``io_service`` to use internally.h{jŠh|hhhæhƒ}r!(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r"hé)r#}r$(hzXrClient and server constructors now take in an optional reference to a Boost.Asio ``io_service`` to use internally.h{jh|hhhìhƒ}r%(h‡]hˆ]h†]h…]h‰]uh‹K—hu]r&(h XQClient and server constructors now take in an optional reference to a Boost.Asio r'…r(}r)(hzXQClient and server constructors now take in an optional reference to a Boost.Asio h{j#ubh½)r*}r+(hzX``io_service``hƒ}r,(h‡]hˆ]h†]h…]h‰]uh{j#hu]r-h X io_servicer.…r/}r0(hzUh{j*ubahhÈubh X to use internally.r1…r2}r3(hzX to use internally.h{j#ubeubaubhâ)r4}r5(hzX+Documentation updates to reflect new APIs. h{jŠh|hhhæhƒ}r6(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r7hé)r8}r9(hzX*Documentation updates to reflect new APIs.r:h{j4h|hhhìhƒ}r;(h‡]hˆ]h†]h…]h‰]uh‹K™hu]r<h X*Documentation updates to reflect new APIs.r=…r>}r?(hzj:h{j8ubaubaubeubeubeubh)r@}rA(hzUh{hŽh|hhh’hƒ}rB(h‡]hˆ]h†]h…]rChgah‰]rDh+auh‹KœhŒhhu]rE(h™)rF}rG(hzX:mod:`cpp-netlib` 0.8rHh{j@h|hhhhƒ}rI(h‡]hˆ]h†]h…]h‰]uh‹KœhŒhhu]rJ(h¯)rK}rL(hzX:mod:`cpp-netlib`rMh{jFh|hhh³hƒ}rN(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyrOh…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹K›hu]rPh½)rQ}rR(hzjMhƒ}rS(h‡]hˆ]rT(hÂjOXpy-modrUeh†]h…]h‰]uh{jKhu]rVh X cpp-netlibrW…rX}rY(hzUh{jQubahhÈubaubh X 0.8rZ…r[}r\(hzX 0.8r]h{jFubeubhÛ)r^}r_(hzUh{j@h|hhhÞhƒ}r`(hàX*h…]h†]h‡]hˆ]h‰]uh‹KžhŒhhu]ra(hâ)rb}rc(hzX,Updates to URI unit tests and documentation.rdh{j^h|hhhæhƒ}re(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rfhé)rg}rh(hzjdh{jbh|hhhìhƒ}ri(h‡]hˆ]h†]h…]h‰]uh‹Kžhu]rjh X,Updates to URI unit tests and documentation.rk…rl}rm(hzjdh{jgubaubaubhâ)rn}ro(hzXAMore documentation, covering the HTTP Client and HTTP Server APIsrph{j^h|hhhæhƒ}rq(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rrhé)rs}rt(hzjph{jnh|hhhìhƒ}ru(h‡]hˆ]h†]h…]h‰]uh‹KŸhu]rvh XAMore documentation, covering the HTTP Client and HTTP Server APIsrw…rx}ry(hzjph{jsubaubaubhâ)rz}r{(hzX_Asynchronous HTTP Server that now supports running request handlers on a different thread pool.h{j^h|hhhæhƒ}r|(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r}hé)r~}r(hzX_Asynchronous HTTP Server that now supports running request handlers on a different thread pool.r€h{jzh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K hu]r‚h X_Asynchronous HTTP Server that now supports running request handlers on a different thread pool.rƒ…r„}r…(hzj€h{j~ubaubaubhâ)r†}r‡(hzXCAn initial thread pool implementation, using Boost.Asio underneath.rˆh{j^h|hhhæhƒ}r‰(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rŠhé)r‹}rŒ(hzjˆh{j†h|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K¢hu]rŽh XCAn initial thread pool implementation, using Boost.Asio underneath.r…r}r‘(hzjˆh{j‹ubaubaubhâ)r’}r“(hzXŽAdding a ready(...) wrapper to check whether a response object returned by the asynchronous client in 0.7 already has all the parts available.h{j^h|hhhæhƒ}r”(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r•hé)r–}r—(hzXŽAdding a ready(...) wrapper to check whether a response object returned by the asynchronous client in 0.7 already has all the parts available.r˜h{j’h|hhhìhƒ}r™(h‡]hˆ]h†]h…]h‰]uh‹K£hu]ršh XŽAdding a ready(...) wrapper to check whether a response object returned by the asynchronous client in 0.7 already has all the parts available.r›…rœ}r(hzj˜h{j–ubaubaubhâ)rž}rŸ(hzX.Some attempts at lowering compile time costs. h{j^h|hhhæhƒ}r (h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r¡hé)r¢}r£(hzX-Some attempts at lowering compile time costs.r¤h{jžh|hhhìhƒ}r¥(h‡]hˆ]h†]h…]h‰]uh‹K¥hu]r¦h X-Some attempts at lowering compile time costs.r§…r¨}r©(hzj¤h{j¢ubaubaubeubeubh)rª}r«(hzUh{hŽh|hhh’hƒ}r¬(h‡]hˆ]h†]h…]r­hmah‰]r®h1auh‹K¨hŒhhu]r¯(h™)r°}r±(hzX:mod:`cpp-netlib` 0.7r²h{jªh|hhhhƒ}r³(h‡]hˆ]h†]h…]h‰]uh‹K¨hŒhhu]r´(h¯)rµ}r¶(hzX:mod:`cpp-netlib`r·h{j°h|hhh³hƒ}r¸(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyr¹h…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹K§hu]rºh½)r»}r¼(hzj·hƒ}r½(h‡]hˆ]r¾(hÂj¹Xpy-modr¿eh†]h…]h‰]uh{jµhu]rÀh X cpp-netlibrÁ…rÂ}rÃ(hzUh{j»ubahhÈubaubh X 0.7rÄ…rÅ}rÆ(hzX 0.7rÇh{j°ubeubhÛ)rÈ}rÉ(hzUh{jªh|hhhÞhƒ}rÊ(hàX*h…]h†]h‡]hˆ]h‰]uh‹KªhŒhhu]rË(hâ)rÌ}rÍ(hzXRadical documentation overhaulrÎh{jÈh|hhhæhƒ}rÏ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÐhé)rÑ}rÒ(hzjÎh{jÌh|hhhìhƒ}rÓ(h‡]hˆ]h†]h…]h‰]uh‹Kªhu]rÔh XRadical documentation overhaulrÕ…rÖ}r×(hzjÎh{jÑubaubaubhâ)rØ}rÙ(hzXAsynchronous HTTP clientrÚh{jÈh|hhhæhƒ}rÛ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rÜhé)rÝ}rÞ(hzjÚh{jØh|hhhìhƒ}rß(h‡]hˆ]h†]h…]h‰]uh‹K«hu]ràh XAsynchronous HTTP clientrá…râ}rã(hzjÚh{jÝubaubaubhâ)rä}rå(hzX&Tag dispatch overhaul, using Boost.MPLræh{jÈh|hhhæhƒ}rç(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rèhé)ré}rê(hzjæh{jäh|hhhìhƒ}rë(h‡]hˆ]h†]h…]h‰]uh‹K¬hu]rìh X&Tag dispatch overhaul, using Boost.MPLrí…rî}rï(hzjæh{jéubaubaubhâ)rð}rñ(hzXHTTP Client Facade refactoringròh{jÈh|hhhæhƒ}ró(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rôhé)rõ}rö(hzjòh{jðh|hhhìhƒ}r÷(h‡]hˆ]h†]h…]h‰]uh‹K­hu]røh XHTTP Client Facade refactoringrù…rú}rû(hzjòh{jõubaubaubhâ)rü}rý(hzX'Bug fixes for HTTP 1.1 response parsingrþh{jÈh|hhhæhƒ}rÿ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhé)r}r(hzjþh{jüh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K®hu]rh X'Bug fixes for HTTP 1.1 response parsingr…r}r(hzjþh{jubaubaubhâ)r}r (hzX2Minimized code repetition with some header macro'sr h{jÈh|hhhæhƒ}r (h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r hé)r }r(hzj h{jh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K¯hu]rh X2Minimized code repetition with some header macro'sr…r}r(hzj h{j ubaubaubhâ)r}r(hzXOConfigurable HTTPS support in the library with ``BOOST_NETWORK_ENABLE_HTTPS`` h{jÈh|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rhé)r}r(hzXMConfigurable HTTPS support in the library with ``BOOST_NETWORK_ENABLE_HTTPS``h{jh|hhhìhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹K°hu]r(h X/Configurable HTTPS support in the library with r…r}r(hzX/Configurable HTTPS support in the library with h{jubh½)r}r (hzX``BOOST_NETWORK_ENABLE_HTTPS``hƒ}r!(h‡]hˆ]h†]h…]h‰]uh{jhu]r"h XBOOST_NETWORK_ENABLE_HTTPSr#…r$}r%(hzUh{jubahhÈubeubaubeubeubh)r&}r'(hzUh{hŽh|hhh’hƒ}r((h‡]hˆ]h†]h…]r)hbah‰]r*h&auh‹K´hŒhhu]r+(h™)r,}r-(hzX:mod:`cpp-netlib` 0.6r.h{j&h|hhhhƒ}r/(h‡]hˆ]h†]h…]h‰]uh‹K´hŒhhu]r0(h¯)r1}r2(hzX:mod:`cpp-netlib`r3h{j,h|hhh³hƒ}r4(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyr5h…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹K³hu]r6h½)r7}r8(hzj3hƒ}r9(h‡]hˆ]r:(hÂj5Xpy-modr;eh†]h…]h‰]uh{j1hu]r<h X cpp-netlibr=…r>}r?(hzUh{j7ubahhÈubaubh X 0.6r@…rA}rB(hzX 0.6rCh{j,ubeubhÛ)rD}rE(hzUh{j&h|hhhÞhƒ}rF(hàX*h…]h†]h‡]hˆ]h‰]uh‹K¶hŒhhu]rGhâ)rH}rI(hzXMany fixes for MSVC compiler h{jDh|hhhæhƒ}rJ(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rKhé)rL}rM(hzXMany fixes for MSVC compilerrNh{jHh|hhhìhƒ}rO(h‡]hˆ]h†]h…]h‰]uh‹K¶hu]rPh XMany fixes for MSVC compilerrQ…rR}rS(hzjNh{jLubaubaubaubeubh)rT}rU(hzUh{hŽh|hhh’hƒ}rV(h‡]hˆ]h†]h…]rWhkah‰]rXh/auh‹K¹hŒhhu]rY(h™)rZ}r[(hzX:mod:`cpp-netlib` 0.5r\h{jTh|hhhhƒ}r](h‡]hˆ]h†]h…]h‰]uh‹K¹hŒhhu]r^(h¯)r_}r`(hzX:mod:`cpp-netlib`rah{jZh|hhh³hƒ}rb(UreftypeXmodhµ‰h¶X cpp-netlibU refdomainXpyrch…]h†]U refexplicit‰h‡]hˆ]h‰]h¸h¹hºNh»Nuh‹K¸hu]rdh½)re}rf(hzjahƒ}rg(h‡]hˆ]rh(hÂjcXpy-modrieh†]h…]h‰]uh{j_hu]rjh X cpp-netlibrk…rl}rm(hzUh{jeubahhÈubaubh X 0.5rn…ro}rp(hzX 0.5rqh{jZubeubhÛ)rr}rs(hzUh{jTh|hhhÞhƒ}rt(hàX*h…]h†]h‡]hˆ]h‰]uh‹K»hŒhhu]ru(hâ)rv}rw(hzXAn embeddable HTTP 1.1 serverrxh{jrh|hhhæhƒ}ry(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rzhé)r{}r|(hzjxh{jvh|hhhìhƒ}r}(h‡]hˆ]h†]h…]h‰]uh‹K»hu]r~h XAn embeddable HTTP 1.1 serverr…r€}r(hzjxh{j{ubaubaubhâ)r‚}rƒ(hzX,An HTTP 1.1 client upgraded to support HTTPSr„h{jrh|hhhæhƒ}r…(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r†hé)r‡}rˆ(hzj„h{j‚h|hhhìhƒ}r‰(h‡]hˆ]h†]h…]h‰]uh‹K¼hu]rŠh X,An HTTP 1.1 client upgraded to support HTTPSr‹…rŒ}r(hzj„h{j‡ubaubaubhâ)rŽ}r(hzX$An updated URI parser implementationrh{jrh|hhhæhƒ}r‘(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]r’hé)r“}r”(hzjh{jŽh|hhhìhƒ}r•(h‡]hˆ]h†]h…]h‰]uh‹K½hu]r–h X$An updated URI parser implementationr—…r˜}r™(hzjh{j“ubaubaubhâ)rš}r›(hzXAn asynchronous HTTP 1.1 clientrœh{jrh|hhhæhƒ}r(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]ržhé)rŸ}r (hzjœh{jšh|hhhìhƒ}r¡(h‡]hˆ]h†]h…]h‰]uh‹K¾hu]r¢h XAn asynchronous HTTP 1.1 clientr£…r¤}r¥(hzjœh{jŸubaubaubhâ)r¦}r§(hzX<An HTTP 1.1 client that supports streaming function handlersr¨h{jrh|hhhæhƒ}r©(h‡]hˆ]h†]h…]h‰]uh‹NhŒhhu]rªhé)r«}r¬(hzj¨h{j¦h|hhhìhƒ}r­(h‡]hˆ]h†]h…]h‰]uh‹K¿hu]r®h X<An HTTP 1.1 client that supports streaming function handlersr¯…r°}r±(hzj¨h{j«ubaubaubeubeubeubehzUU transformerr²NU footnote_refsr³}r´Urefnamesrµ}r¶(j+]r·j(ajÛ]r¸jØajL]r¹jIaj¿]rºj¼aj]r»(j j4ejy]r¼jvaj]r½jaj]r¾jahø]r¿hóajü]rÀjùajç]rÁjäajb]rÂj_ajÈ]rÃjÅajƒ]rÄj€aj]rÅjaj±]rÆj®aj³]rÇj°aj]rÈjajË]rÉjÈaj×]rÊjÔajß]rËjÜajb]rÌj_ajK]rÍjHajó]rÎjðajK]rÏjHaj]rÐjajÿ]rÑjüaj§]rÒj¤aj›]rÓj˜ajÏ]rÔjÌajÜ]rÕjÙaj]rÖjŒaj3]r×j0auUsymbol_footnotesrØ]rÙUautofootnote_refsrÚ]rÛUsymbol_footnote_refsrÜ]rÝU citationsrÞ]rßhŒhU current_lineràNUtransform_messagesrá]râcdocutils.nodes system_message rã)rä}rå(hzUhƒ}ræ(h‡]UlevelKh…]h†]Usourcehhˆ]h‰]UlineKUtypeUINFOrçuhu]rèhé)ré}rê(hzUhƒ}rë(h‡]hˆ]h†]h…]h‰]uh{jähu]rìh X/Hyperlink target "whats-new" is not referenced.rí…rî}rï(hzUh{jéubahhìubahUsystem_messagerðubaUreporterrñNUid_startròK"U autofootnotesró]rôU citation_refsrõ}röUindirect_targetsr÷]røUsettingsrù(cdocutils.frontend Values rúorû}rü(Ufootnote_backlinksrýKUrecord_dependenciesrþNU rfc_base_urlrÿUhttp://tools.ietf.org/html/r U tracebackr ˆUpep_referencesr NUstrip_commentsr NU toc_backlinksr Uentryr U language_coder Uenr U datestampr NU report_levelr KU _destinationr NU halt_levelr KU strip_classesr NhNUerror_encoding_error_handlerr Ubackslashreplacer Udebugr NUembed_stylesheetr ‰Uoutput_encoding_error_handlerr Ustrictr U sectnum_xformr KUdump_transformsr NU docinfo_xformr KUwarning_streamr NUpep_file_url_templater Upep-%04dr Uexit_status_levelr KUconfigr NUstrict_visitorr NUcloak_email_addressesr ˆUtrim_footnote_reference_spacer ‰Uenvr NUdump_pseudo_xmlr NUexpose_internalsr NUsectsubtitle_xformr! ‰U source_linkr" NUrfc_referencesr# NUoutput_encodingr$ Uutf-8r% U source_urlr& NUinput_encodingr' Uutf-8r( U_disable_configr) NU id_prefixr* UU tab_widthr+ KUerror_encodingr, UUS-ASCIIr- U_sourcer. U?/Users/dean/Documents/cpp-netlib/libs/network/doc/whats_new.rstr/ Ugettext_compactr0 ˆU generatorr1 NUdump_internalsr2 NU smart_quotesr3 ‰U pep_base_urlr4 Uhttp://www.python.org/dev/peps/r5 Usyntax_highlightr6 Ulongr7 Uinput_encoding_error_handlerr8 j Uauto_id_prefixr9 Uidr: Udoctitle_xformr; ‰Ustrip_elements_with_classesr< NU _config_filesr= ]Ufile_insertion_enabledr> ˆU raw_enabledr? KU dump_settingsr@ NubUsymbol_footnote_startrA KUidsrB }rC (h[j^hkjThbj&hmjªhsh¤hgj@hXj+h^j—hKj®hhhŽhYjwhMj|hJjmhIjrhajchSjhhPjYhehÍhrjhqjShdjhTj†h_j‹hljjhFjohRjth]jyhDj~hcjƒhGjˆh\j hNjhZjÿhHjhBj1hCj|hLjöhEjhOjIhpj£hVhŽhijúhjjõh`j’hfjhtj!hQjhnjñhWj&hojðhUjëuUsubstitution_namesrD }rE hhŒhƒ}rF (h‡]h…]h†]Usourcehhˆ]h‰]uU footnotesrG ]rH UrefidsrI }rJ hh]rK hxasub.cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_images/000077500000000000000000000000001240331347200237265ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_images/boost.png000066400000000000000000000320641240331347200255670ustar00rootroot00000000000000‰PNG  IHDR0aQ^ýsBIT|dˆ pHYs ! !0C«ˆtEXtSoftwarewww.inkscape.org›î< IDATxœíw|ÕõöŸ™í«ÝU/–dUËMî½c¦S ±1 „PBË ˜Ä H?’@ ½%40S‚qÁã^å*É꽬´½ÏûÇõH[îìήÖEÖ|?Ïìvwµóì¹çž{.ÃqD’à±KHHHœn˜(¬@Õé«Š„„„Dt°g»±" ˜„„D¿E0 ‰~‹$`ýIÀ$$$ú-’€IHHô[$“è·ÈÏv$D²iðüóô}j5˜¤§W_ Lž|fë68~xôQ 3xõUñç­\ ¼÷°c T<üæ7§¯ž IÀú uuÀêÕ‘ûÓŸ€ñãï¾RSO½ äó/(ÎúõÀ7^/y­Rzýi©Þ@E°þFj*ðÆen7ÐÑA~åßyØ·¸þz"bréO|ÖøðC"^sçÿý/› ˆù"!éÛÝßÐh€k®¡ïûÕ¯€ùó›n¾ÿžÚÌ™g´z~ÔÕ‘õ¢ED¼€aÎ^}ÎC$'þùÆ 7ô6·oï-w¹‡ƒls°kÐÚJ¿†Õ ìÞ lÞ tw ßËã!×ôùÈk§ض§Ù¹®TUëÖ⬓ÚZ`ãFR›-òñiþ}ÿ=pøpos.pè°aCø÷î|‡°ÛÉëädòÚí=ÖåÊÊȽZZ„¯éõ’kðõ¯©!uèp'v)à$Îÿý/Ç—›ùØ™3ɱ¿ùMoÙøñ¤¬¼œãÆŽ%Û,Ëq·ÜÒ{L}=ÇÝtÇ1 ÙÏ/&pÜž=¡÷¹ýv²ÿË/9î‘G8N¥ê='!ã–-ã8'ô<ŸãÞz‹ã²²ï£×sÜÓOÓÏÙ±ƒã&O<ža8nútŽ;|˜þ9üø#Ç•–ž£ÑpÜÃsœÓI?ç£8.?¿÷x–師¯æ¸o¿%¯ D<wÞxO~¹ì²ÞcL&RÿÏŒ¿þš5¡×üË_Èþ^à¸Çë=¾¸˜ãš›#×é<åœiBrA¿¾Á¯i0Aæxðë‰ÍF~Ñ`äÈÐýwß 8¤¤F#P\LÊ››qã€övR¶`éÙÜ´‰XbS§ï¾KœÒÁ,[Fîyíµ¤ [S¼ü2ðÌ3@}=ñÿøóàƒÀ?þÈdÀâÅÀ¨Q@u5ðÉ'ÀòåÀÿþG¬,ÞWS\q±¤æÌ!Íb‡÷ãÀĉÄ2¤÷o¿ üâÄbY¸˜1ƒXœ«VÏ=G®ÿägçµ×€;ï$Û S¦ËpÅ r¬XæÌ!ë/¾šš€‹/&Ÿé¨Q¤ÜåfÏ&‡ôtò¹åä{÷’s.~ÿ{à ½ö—_’Ά4GÕjÒ3:Pá΢æóù8ŸÏÇy½^Îãñô,n·[ôâž×ëí¹¦Ïç‹wuÏ.b,°ŽŽ[²„§Õr\mmï>ÞcŽ[µŠXA äŽã¸+¯$û¯¸‚ã,–Àë>ÿ<Ù—’Âq­­½å¼cü9r„ãt:²ÏߢX¿žÔA£á¸Í›Ï©¬ä¸!CÈ9ÿ÷½åÏ=GÊn¾9ô=óÖæoÛ[ÖÖÆqII¤üÃïì丩SɾgŸ <Ç` å/½xζm¤¾b-0ž . ç|ôQ`9oAEþþ|ý5Ç)'“qÜîݽå¼pÜw¿‘ÍÆqâësrÆŒ,^´üÅÈårq.—‹s:‹ÃáèY‚÷ñç¸\®QãïqÞ/`Z-ÇÝzkà²d yyÁÈCï/`‹‡^{÷n²O­=ø‡ñÑG{Ëx5Šb0>Jö/Zþ:þ¬^ÝÛu¹HÙC‘²{î =þÈŽûøcŽ;z´·lÙ2rüu×ÑïñÉ'½MV·›”½ò )?ž~Î=÷ÄGÀl6"Nóp÷ºâŠÞ2^À8Îj_‡óœ3Ò„äN59?AôíLðvðëpÍF~›a˜mÿ×ç»UÀîp”Ée,fLz°ÍFšrB””ÿ;på•ôýãÆ…–9BÖ³fƒÓÏ»áÒœ

€“?Ö¡óøsÚÚˆßÇl&Ûþû„Î;r„ÜkÄ"VO> <þ8é±\·Ž7a )¹ùf °°÷ü'Èú¡‡ÈŽŠ ò™46’×ÙÙôãòòÂ_G,Ñ|Ö €Åèt½ûh¿ 8°XíÐë4±×³ŸpÚLH¸¢0šxñY^üšapG±sÉkn7†ˆäfÐOÐjÛn‹ý†þÕJÖjµðy2YÓBh×…”ãÃüçbîõ‡?Ëë³ÏȲwoïòÜs¤£àê«É±&YÏŸO? dí:e þ á¯#–h>k ôóú¬OqðX Þút=–^9SÇ–ÄXÉþCÜ,’pNã·…šá–³Eu==«0÷ ö, JÖ55ÂÇÔÖ’5­Ç‹·^„ÎIL$ÃhrsIï™ÝNöñ÷:/#HÄKKɲ|99fÕ*àõ׉µvç¤ùÉ0¤™µcpÇÀ’%ÂïÉþ}ñ÷†Jí+Ñ|ÖJ%‰!AuC+Þùt#vª@,ø@\YyAòù|§}ñz½!eþ÷¦í§-þ"z6°‚œô3W‰aÃÈzçÎ^ !ÿf[0þ³þð~%>¬€az`~_0»w“àQ¹3†”=û,ñÁ<Ø{\^ýùçÄbii!þ%~ªé½~=ýÀ­·=FÂGâÿHÀ+mÛèåÑÂÖuu@y9ýþ³?>âåÚ&<ÿöÜûä=â¥Õ¨‘šÚžóÄMÀüÅÃßÒ ~›eY¨ÕêžE£Ñ@£Ñl -jµZ”˜…/ÿ×gƒê†6jùý;—ˆEk+ðôÓ¡û·l!±P¦ÌŠ¡çææÞì·ÜÒ[~ß}dýÔS½þ0§³7SÃå—÷6ÿ¶n%÷xüñÐ{77§xb"PTDÊˆå[oK,˜{ïþó’%"-”-]Jšu›7kÖßÕEbÚâAFcŸxøáБ55¤I Ð?k?¼>~õûW±nÛÁ€áüì3øãw–‰‹€…`a Þ¯Öh௠¯ ÖS‹Í'‡“ô8 èY”*5T*•hò/£ .¿}&©nµÀô ¤$Á¬2ðâ‹Ë’õ†ˆŸiÃâ<Ÿ?Ÿø°î¸ƒˆ]0^/±²þþw"¯¿LšD˜_qXÎ󳟑цba¼ü2È÷Þ#VÐæÍ@RðÒK½çüæ7Ä"ûüsÒ»úòËd ú²eÄ‹Š÷«MžÜÄ:w.y6ÑZ´ˆ ²f"¼Ï+7·7pôúëÉ9ßOz|'O&A¿ñâ¹çˆ/kõj`ÞùÀ‚--Úv¸E­VCÆÊ°³ºN†9å³Â)ÿ/Ã2ð¾,¿5€¼D%rõZØíö JÈ¿ÅqX–…ÏçÃ0=kÿ2þ5ÓËíACKgHùYù^py`o»X;¼ÅËäñÇIt8_ÿšŒMôÏsŲÄò ÎÅ0¤‰ôÐC$«ÆÝwîŸ6/Ýܹ$²þÁ¯¾"‹ÿõþðà‰'¯óï“Þ¼'žÝ—žNDä†Ë~˜õãž“™I"à/¸€þþ£%7س‡ˆî–-a&2ù—^Š˜I„öãœa÷ÃY&f‹$^‘DŒa¨ÕTv8àpûbŒ³Y:´ 0›L{ý…*X¼xá⛵Àé±ÚÆ6ªÅWC°ùó‰ß(\ïU8^„1ð~%³g“!A»v‘ug' Â;“³²ˆå´mñ‡%%]$Üå¯×“ú<ü0°?ñ]%'“áJBÉo¾™ ¹Y»–4³ìvò^&L =^&#>®[o%=•GŽQ-..½T8–ê‘Gˆˆõéœ7ŽX† äó×Dšð Ě*- Ý7t(iïÙC>ëúz2œè’Kè±x7ÞHÄÝï½Ö¸¨ßŸó”> M°h~°`ÓétpsÀÉGÌ•÷q@U· ÃR4°Y­ðx<Äõ<‹Wð6˲§]À¢òefömÌÛĉâŽÓhHsw¼‹E¡ J4VÊСÂ=‘4ˆˆECv6Y„{idd+(Zó9´ ad2Òœž2%òµòòBbÑ-°Ô„ŒÉFó%…óu¿fYG›mðúúæsj·y`vù 7¢êy ·í/¼§“*¡ÈÜÓˆš€¥% ÓÆh¥÷C¢°`K*Óéõè²{Ðh u@ÆBU· J¥²§W2\¸„XÝ™± …P0 Ÿ=p~A%bÃát£¥=t˜Ô@òQ6!#ù¸ÄøÂT*” %v5˜âö&,.Úm$'&Áf³…øÁhŽzZ“1xÍ×ÿt5'i¿ YiÉP«‚çØ.tt™áöx‘š¤ƒAwöÆÅyJÈ tÚÝð´w!QŸ¶î§¯Ï³ÅŽn³ >ŽC’^ ƒ^ {fóvºÜ˜,6˜­Ä=bÐi`Ði¡Ë"œ)â? -HÍG s»ÝŒL& k}…³ÊxKF¯7 ÑäB·ÝQlP C#Ër9 ½^“ÉÔÓë *ñòà_oë6ÛÐe  þz<^ì9\‰-»Žbç¡ Xm>C…\†â¼,ÌZŠÙ“G"IŸ×zòppàX5«FYy-Ê«›àòæ‹šÉw$´æ8 Ðé ØXÞ §×2&qaZ¥ ã³40›Lp»Ý=½f³YÐq¼í¿ŽTÆÆñ—|ÿÑjüîï߸p6nºŠ8зî>Š·>Y–qie,‹ë.›†ΉÛCjw¸ðÝ°fÃn4¶††|„ƒe,˜;7_}A\ý2Uõ­øbý.|¿£ .·'ªsÓS øÅ’ù˜I(%õÍø`Íü°÷<©ªƒ˜6n(n¿þ"ädF¯ àÞ?¾ªº0)§Ã R*ðé?>'ÆþÆQÃ0LGG£R©ÂúŽÂ‰ËëèD›N(P)JRÀår¡¹¹Yt¯cp¸„ÅÅ—ñÖ—ÿv<¨ ÓƒÔe¶â™W?áãaÆËQðú|Xùõ6ü¸ï–ß}}T¿ð4¶î>ŠW>Z c·%¦ó}>k6ìƦGðÈ/®Áø‘…‘O ƒÕæÀ[ŸnÀ·[öQ-1´ušðç—?ÅÄQÅxìÎEШà *€ã8¼·z3V~ó|}è„Ú¾ÿv¬ÀK/Á‚¹Â½Ä^ŸõMí1ß'/;í¼/@|’q8Œ^¯pl‡s~¯õz'Ûc›ð'M+G’ZŽššø|>äååC«-}Çqèîîx¼®¦¤P¸\Æâ¡?¿CuЊ¥®©¿øžÿíÏbò‘™­vüý­5ØyP`¬^”˜,6üñŸ+±üîë1qTqL×Ø]V‰Þù2f1 fOY%–¿ðžº)´•èóìNžþ×ÇØ´:.õðú|xùƒo‘–lÌÑØÒ w ÏùQÀòÄ2.—‹Û“,^r¹:]v՚ዃ° P˜¤Dww7¬V+ ´Z Êšmp{}z›™|J—Þ×ä?ÿfjQ’­6«•*ÎÁ¯ã!bÕõô°¿¾ùlvgHyVzJò!%Q§Ë¦6#ÊNÔÂ+êÑÜÖ…?½ü)ž}ø§QÕ«³Û‚åÏ $ ¦jIÁ ¤§`Ðia³;Ñn4áhe=<^z}\nžú×Çxö‘ŸbXaNTuÚ¸½ Ï¿½Fð½@¢^‹!ùƒdH€J!‡ÑdEMC[Øfï±Ê<ñâ <ûÈOEýM}>ϼ²JP¼X–AAN’ H6$@¯Ó¢ÛlE[§ -‚âËq^|÷+üç¯÷Q;„âÅr>÷LŠ±ÀŒÛífh—˜pƒÁ‹Ãƒf“+-G 6(¡`“§Ò¸ddf¢¾Ë…º.g ¿ èõ£ûÖÐë{óù8ŒÎÔÀåtÂ{jpm°`ÅSÀ8ŽCM#ýK,^“GÁÒ…³¨}—ÉŠÖlÁWßï¡^«ìD-v—Ub’H«§¹­ ¿{þ}4·Ñ­¿ÌÔD,]8ÓÇ£ú´ÌV;¾Ûzï¯ÙLÍqæöxñÒ¿Á‹ËïËŠû ×lØW?úV°É8sÂp,ºd†eSÿ.•µÍøïêMØu°‚zþáŠ:|½ioØ&Ï>ÿ»Ë*CÊõZ\1w".›=iÉôN ¯Ï‡ÿmÞ‡÷¿ØŒnsètp]f+ö©¢Z¨3' Çgÿ~´çõž²J<ýïOBŽ»mÑ<\}qhPl¼;-Î%Âz¥yë \.— xEZ, Tr$júž~L-g1Ø @ss3\.RSSÁÊä8Ñfùš]/Úmh´Ú°Íã`«,VšÚŒpº(‰ýHШ°üîëñÄ}K-–$Cî¾é2<ô34È>ýöGQu²;\øíßÞ£ŠÃKÎÆ«Oß…ù3Ç :äõ ,ºtþùø/•žD=¦ª®k6ìU§Í»Žà•éâ•‘šˆç½¿½ë: /ÎüQ)ÎË¿^‚_-½Tð>ï~ö=ºÌi„NÑÐÒ‰ÏÖ†¦ ÊÍJÅ?–ß›¯š#(^±Z̈ç½Jý9Øq€ÞdgYJ…¼g©oî Wœ—p¿œ¯þ/@| kD ,\³Òb±Àáp 4³ï)n‹“pº\hii\.GzzÊùŽ>pÒè˲=Ù-„+&”Œ'3- {ì6L?LÔõ.š1K® ÏÀ}ðX Ú:#Çܽ¶b-µ·S£Râ÷.ÆÍW‰ïÙ”žŒ§¸QÐÿöåÆݯÑÙeÆ¿Þû†ºoôÐ<ücùí9$WT}`á…“p˵s©û¬66í8öü÷¿ØÒ­¼ÿ ”Õ5_1SÐ2*+È2zŠʱvkè2–ÅoïºSÆDŸš8;#YðAml5R³pøó»_Áb ý»– Â÷ÝSçÄâËg /›þ¹îhb¤ù·ûPèþyÓF!91|Šg“ÇйwG°yhþS½î §`:Gg1°ž±4#ív;º»M™¥E,-ËCR”0èêêBBBRR’q¸Ås—z0 f7Ü^jFTS2V„Æ@À²_^SøƒZ¥ÀÅ3ÇR÷•0·Ç‹þ÷kê¾»n¼J‹¢® ÏåsÆ >à»ÂôpnÚy{(¾¦”$=žøõ’˜£ý†Á fQ÷••×Rsk@EM¬”Ž•XGAdg¤€a¤$éQ:d0.š17_5×_6#⹯õÍ¡!çsOc8¢ŠÄô G±¶¶V!?YjctVSn¢*ƒ£UU=a­fÚ,î¸t $»Ee— #ÓÔp9=ûÁœ®&äœÉ#û$#Šrð9¥¼®Q8†hãö2jÓexQ.¿€’>: ärFÍÃæ]GBö…³À>ý–ž¢úöë.D’¡o# &Œ¤¾­ÝÔl¦´@dW€J…«þõˆ /, ÍÔžÞ*`¢-°pV‡¨—¹Ýntvvbh† ™xÙQÉYä'*P__»ÝŽôôth´nŽÝq/„Ñá…Ñá…F£ kyÅ*b|D0J…·_QŸê^”GO·c°,P‡À/o˜ß§ºðŒ(¦û©hÍC€X‹•”a2C ²1wê¨>×G¯ÓF¾ ÕÉæ ~»Ë*ðΪ1³Æ"^@¸:ÏÿÍêðz½ ¹I®éåóùÐÚÚ †ãPœ*~hÉÜn7êêêÀ²,òòòq²Ã«+öà¾pTu9!“É R©Þ“ÿv¬VÛØN=wæ„á}7(éx÷­¢>#‡äF«%DŠ@RH,>ûŽ’ÃÀ5ó§ÄäzˆªNVzÒz9øø›møíßÞÃÖ=GC&'>;ð¦&ô3À/bÒË„/¾Üçó¡¥¥EÙÙœtJ Àº Çÿ @­¡¬¬ ÅÅÅðAykü­/‡‡CƒÅlîSóòñïÃ?ë+¿Ž!ÿ×üYtÿU4ȺAí ž8â붤–ÏŸ!_ ¦Y-›ƒJ U‹î‘ƒR°NôžìáE9P)‚¡/‡NÔâЉZÈå2Œ–i㆞¶ì4>Ãù°ˆÂÆ[`€øIkýñ/ooo‡×ë¼àã=Z[[¡Õj‘““ƒý Vx|ñÏáOƒÙ ­jµNg¨7Vh¿ )‰:ŒVÐçk{9ú(ä7:t<Ô¹/—Ë0{òˆ>×¥?QjR¨t¸¼–ú9kâð˜›\4XïMª@/ž\.Ãe³Çcõzzs›Çãñbïá“Ø{ø$þýþÿPœ—…)cK0uL †äŠ‹Iûþd¤&A£Š½w¿?#ú[M“)RžÏçC{{{Øl©þkþzyyypz|¨7:ã2<½éªUðx<)úÒ IÄ=²dp\¾Üíñ^´³¹­ íÆÐã‡ägÅõaèè2Óë”Z'š ÀèaùÔòXi¢N<·]7»Ë*"†øSYÛŒÊÚf|¸f R’ô˜6¶ÍƒáE±5Ïmv'Z)±zµù„0F`›ê ‡V«Err i*r¤ÁH6¹SeÚçw 8œ¬¬„ÉdB]]²³³‘©W¢Årúý .J3'–f£?´&@éÊ$1 °J°ƒ™.âUžhDõlÖ‰e$„cº” 9žyø§øÛ›_`ÿѪ¨ïÙÙeÆ×›öâëM{‘›•ŠËæŒÇÂy“ b˜Ðð³2 7H‘ø=C‰„B&ømÿ²àò̬ApB‰FÐdfÑlfÑbeÑj“¡Í.G»C‡.Œ.Œn5º-–:UÖ‡”1 PR(ÚmÝÔïV¼ës¤"´>€ø†.=—·òê&¬ÝºÛ÷Ÿ= ÈŸšÆ6üîùðå·#;#òw@(îl !â9­ÉÂår9RSÓ°«¼f{t™3y:-.œh²bØðáÉdp:8yò$JÒÕPÉOOõe,ƒ¼DœG\g&¢}uZ5ô }# GÊC­*ƒN‹¼A¡_ðöNº(#%~ÖNKG7µY›“™Š„ v£@}âh}Âêb ))„{n¾ÿyî~¼ø{2 {havTþL›Ý‰?¿²JÔ±´@…\†ì8ýöGâ×µC!-- 6—»+¢KE̾ªn¦g¡¤¤'Nœ@mm-rscD¦Å‹†ÁzXp°Øíaý]ÑúÂhc Ãe0ˆ†ÚÆvjó´T ƒ€æ\ר•Q%÷‹Ä¼Yc(NyZ‡¿Ï‡'š:‰…aH&ˆâ¼,,]8]f+öªÄ®CØ{¤*dƒ`ªêZPUׂÂÁáçý¤åh<(íŒOZr.!$`m›oîù¿ÚÖh40 ørW#¼} ypz|ØWcÂäâ466Ân·ãĉã;v,jŒNtÇhÝÑÐÈY Ò)`±˜ûì°†æÈ%¥1ïw”QËiY>mv'5¦)Þa)Bu¢Åt»é?Dñ¬R]S;5Ê?;#9®qTIú\4c .š1^ŸûŽTá³µÛÃfqÝ{¤*¬€µMÔàßìÿÂ7!9ôŠ,Pük¡íÔÔ4ÔµÛPÑÒ‰& ºmn > ࣣF#FeŧéÚ^¥IDATùÅS”¤„Çãé‰ýŠ×CÍqj)½Hñ˜)†ã8¬ÿñPH¹V£ÂœÉ#CÊ1U±LL!D[§ W‡”'hÕ3¼€R'zo\<ë$¸Ï Ù`d,‹I£Šñ§‡nÂÏ_,x\$+Mp÷BDá‹æAÖëõP©”Øx0¶YThp°«²©©)ÈÈÈ˲¨¬¨€A-GnR|š=©’Ô2X,æˆ"­°5¶©3èÐzÄ¢eëžcÔ&ؼ©£¨©Ë¨Ý÷n‡šÎ:V¯Û ZÏ…ÓFA. ýÚiÕô¿a%{i,ØìN|÷ChÊ †.™%<òÀçãÐØjÄ®ƒXµvGŸrÓ_;ª ¯M!öNÐ?À-0Ñ>0–ecün™L†¤ädì;Ù…³+®Í’–n'jÚlRR‚îîn8455axFZÌnxú%‚eˆõe·Ûáñx¨S¨õ)þK RL²Áp¸=^¼ýéê¾ËçŒkÒŒ¥øã@Ÿ@¯K¸d”‘¨ªk¡®-ÌŽ8𻑤¬×iâÚÉÑ¡ Ø©€ÂcY–j…½"f0$¢­Û²š¾ýJEâH£v·…`Ymmm°Û™›C¿(™¡Íf-TÑ ˜ÐD¶ ZïX8v—Uâ¯o~Aõ3Ýzí\$éÃ'þ›(8Ñfwâõ•ßEU€|gþóù÷ø\ έ×Î ÓÅ0À„RzÓõ»­PÃÑÚÑß¿ð!Õ‚3è´øåáœgBÃsV~ýCÄ @h8]n¼òÑZê¾+"$Ž´Ù0YB›¿‰1f„=ŸˆäÄïiF[`Á¹F£Z­ÂºýÍÔ‡*žø|öV›––ŠÄÄD°,‹ººZ¤é¸pH"æ0¯Ø€¹ÅÌ+Òcn‘êqA¡s ô˜“¯Ãœfçë0+/i r˜M¦Az¯ÑŠ—ÃéF“ÀTeyøÿüʧ‚Í‹Àc‰ƒüÉ—VPC!.™5VÔaà sCÖÿxï¬Ú(úïØe²âÉ—VbÅW?P÷Ïž4×ÌŸñ:BÎt¯Ï‡?þs%ª(C„Øy°÷=ý&ÕbbYËî¼V0ûAËÌbs&²Àü—4N7q5µ÷ø‘…˜/ œ‡–“/š¡h É‰Ï '—Ë,0~؇¿€uš]hì ü/ê;°:<ÈÌÌ„ÍfƒÍfCuu5ŠÞ^7!k‘eÙ^E·ÛM-²6£yµmÇM6·uá‘ÿû~¹d>¦r}Ž¯ÁÛŸnÀ‰júø¹)cJðëŸ.U'–ep×ÒK±ì¯ïQ÷üÍ6¯jÀ/Ïô¥»-øfó>¬úv»`>ù±Ã ð`˜iß‚5q¶î9²ÏlµãÁ?¿¥ gãÊy“B"ùò­¬Ç‡_nÁÞÃ'©÷`Üz¥ @ñŒ,ŒŒÔDêÊ–ÝGQUߊŸÿäbÁ :âßüjã|¹qÕjÓjT¸ÿÖ+ÃÖÎçær{°ì¯ïaìð|äggÀît¢ËdÃ=7_Níé=aÂ=X ð V»wïÞÂáÇJ#“ÉœœŒÕÛëQÑd¡s}¼c¸±¡çíÁ©Ìž‚òòrX­Ö±áň¶ÞW®\,k·îÇ?Þý* L£VbPz2usfj"†åôÌ­Øa4ãÀ±Áhu€ü’ÿáÞÅQçÍú뛫±q;=à”'?'à sœ˜–azf½>v²!¬0O[‚ew.ŠªNm&ÜóÄkÔI4xrÆ,DVZ2uØœ.tv™qðx-:Råðç=tûUÔØ8ÿÛ¼/ Lx“™šˆAÉÈLKBj’f«mdU]S;Õ÷?å“÷-5x¾ª¾÷>ùº¨:Àê——E•å¢?#ÚS(j™ðÑêv»ŽÍDu«Þò„‹EÆ2˜Xh€ÑØ›ÍÖ#&¼ØD±àíHNú¾;ðC{ó³Óqß- pÿÓo†ÄµttSçhbÑ¥Óð³EŠžíÚŸn½›Cpæj€ôâEÓSʲ n¾ú,¾|fÔNæôž~ðF,þAs{¼aëK#;#Ëî\U‰KgÃö'ÂÞ+Ú¿@²Z<õàRÑy¼Ò’ôËe¢ƒzeÄúÄûÀ8™LÖ/ôÀ[­dîICNïàÒ‘9:¨,š››¨bl9 ‰­y(v‰†ª†P+« 7ù9é¸û¦Ëb€ Yyô—×âŽë/Šùr¹ Ëﺳ&Æ' ëˆâ\¼ð»Û±äŠèÅ‹gha6ž~ðƘæ\ F.—á'—ÏÀ‹øyÔ)p†Á£¿¸¥%ñÉGÆ0d.Éç÷³¨’êušˆ~²Àû œ®É°Ø)ëŠÀ)•JNèaç_û|>ØlVL–†#uÝ°8â?éF‚J†Ò\=ÚZ[àõzÃZR‘D,œEüc/€nñ_àKfCfZþòê*Ñá µ×]2 ×\25.ÙSårûÕ"ì:X×V|‡ÆÖèß–«/šŒiã†Å,\þ -ÌÆëOß…¿Ü‚ÕëwE=¤H£Vbþ̱¸æâ)ÈLKŠ¹µÏ>üS|úív¬üf[Ä!?4˜XZŒÛÍ‹8`[ˆ;o¸f‹êô'Ö²þJX0ä‰ejjjŠ²²²Êýý^Á~0>õLbR2N¶XñõnÞBŠŸlîÈTdèd¨¬¬àë׳#b‘üa‘üdÑø¾2–oÅס½só¦ Èeµ9°nÛA|½i/µgI£RbBi¦O†)cJ¨Nìxàñx±ïhv¬Àî²JÁÀÍ­E¹˜4z¦Ód¼bi7š°ã@9vªÀÁc5ÑÌ´$Œ(ÊÅÔqC1itqÜóÄ»ÜlÙuÛ”ãd]3ZÚ»¨=µ $ê0fX>&‚‰£Š"†µˆåxU6n/Cu}+Œ&+,VõZ¤¥žl@Fj"–,˜—{õ" @D¬¥¥¥(99¹"X°hÛ …‰‰‰X¹µŽ¸ Xv²NGmmmã/šuÉ©IÀ΄ynwºÐa4ÃØmN«Fj²>æY ûŠËíA—É £É§Ó]‚IzíYÆÞbsÀØmA—É ™L}‚é)‰1ÏØ+v‡ F“6»V»•ɉ:$'êL/àÙF¬€Áh4étºÊHâůõzÌNïoªé¹F_LÆ2¸jR&B"ÆgIÄhF{-!!qî ê‰ä8&ìxÈàÅf³"U¯Bi^|2jÏÑA§’£½½=@Pd2™`ØC¤¦a¤¦fp¹„„Ĺ…è§R¥RqBsšhø|>8vÌ™•¢o¿F)ø|ººŒðù|T¿”X‹ä¼. ‰—„Ä9JTOf$Ñ ^;(XS‡öÍÁ;©(>Ÿ&“IÐê ¥pÍÀp¾/¡÷'!!qîµi!¶¹Å[-‡ã “¬‹­G(#Q…¢Ìt;©â©9)$nbDLj:JHœÛˆr⟢@êìÙþ³hûos‡v‡néþf€€dçLÏ~¯O“œ çu¡£½½w?xC?œ)”B(lv'ŽVÖÃárcBiÑy1üáŠ:åfFÏçÁrLš£ŸÆ{ÁëõA.cQ88ƒÒÅM¯Öe¶âà±ÞŽ£ôd†åøÝ"ÒÒÞ…ö.sTêÖ7wô “ÉXäd¦ˆVµÙ8Y×Bþ.«Í=Aã<J=¹m}sŽVÖàÓ`biq¿r“y!&Á_$v;T22ô2¤ëX¤éX¤%0HÕ©Z YÃ!YÝ»$ª|dQzás;`>ÕtŒ×"dÅÛi_YÛŒ§ÿý Z:ÑÞiÂ}|Spl Ç‹.Sl©[ú’Ó+¯~¸6êfµÇãÅ+׉:ÖjsàíO6ÀØmA}s'žú×Ç¢Ó í9T‰öƒËíÕæÀ;«6DOì×ãâêÊóõ÷{Q^Ý—Ûƒ£ϼúv(uîÑÊzlÚyXÔ±eåµøßæ}0v[z±A¾·—áÝϾü¸ïDÄqžý˜§UówÖ³,ÛcyñezÊ9ŽƒÃá°Êh³xÏè현Š4+Œ¯G,á}Áãñâ…w¾ÄS.í bÔ¨•hë4‰NI\V^‡#u¸qáì¨î½u÷Qx}¾°¹ÞcÅëóÁãñFsU×Üܬ4QÇVÕ·¢´d0®¾x bU™D ruC+æN)홨#Q¯ÌLAãÇ}Ç‘Ÿ“Žv£ f«]ôœÕ ­¸ÿ¶+‘y*ç™Éb ;°<ðÜ6ѹí«ëÛpÁ”R\:;ú¿íçëvâÉû— IŸ€ ¦”bõºQ_ã\£OóBú‹€AóoR2 Ó³Ž$`ük1÷Þ¦‰Tp¹P2žNûmûŽcBi`¶XAéì2cï‘*ì?ZµJ‰õÛâÂéc"6ƒ[8RQ‡­{Ž¢ '›wyA,õÍ1M¤ZÝЊ‚\qùÛ«ê[QßÜ×>úF“ Z5Æ(yŸ6°,‹ÖŽn˜m”¨Å"RÖDœ?[»OÜ·]&+ŽU6„M—ãO]S;¶ï;€Œ¨nhÃïïù‰È:·â²ÙÂó‹ô ÷ÊLKŠ˜‘gÎä‘øõ“o`úøa˜9q¸`:íþDŸÛIBÍG1½|ÁÇ„sÂÇ⼶WR&“ŭDZ®©9™½¯bý|vŠ†–Nä J+cEùpÜÒO¬O¨º¾Ïƒ9SFâ‚)¥(;Q eøæ¶. /ÊLÆbË®#xüÞÅ=i‰"ñͦ½CR|wÍ8Z). l—Ù ƒN‹ŒÔDt›m8Y׊§X*:ùlĉ{Mc®œ7 ÓÇÃôñâš÷ºK§áßOþ#ŠsñæÇëE7[Ïeâ23·SÍßê .Ól ׌º/¿©9©ùO4jUÀì×Ç«ðáš­xâ¾%ÏÍLKBfZÖm;ˆ«.¢ÏâC#?;ùÙéX÷Ã\ùöGD̦Š$CäÁФ™Úkå-š?w?ñ:®¿tzDXùÍ6,¼hFŸ²h†çâ×ÃëóAáÇ­&è¾K®˜…×V¬%` -¢}¢uMíp»=Óèçe‰rŒšçß^ƒ §†ÛãAU}+ùù5¢î{.SE$ MÄhëàíŠÇAÀNwŒ—ÛãűÊz¨UJ ÉUWþ¹Jyu~é£ gB'Âz8^Õ 8©«?^ŸGÊë4?ƒÒ“E‰@ró»Üž€ÉC*k›‘‘’ØcÍ…«ßЂì€ïÕ±“ (ÎËŠØoj3B§U8ü—×ahavÄs-6ºÍ6Q"f¶ÚCf·JMÖd5 GG—åÕMH2$`hA6·Ô;§EÀxΔ&$\þÛBÎ} ‰þKÜš4ü›•gZÀüï/ —„ÄùÉi0!!ãË€èœ÷´ë ­%á’89#Æã/$B¾°àm1× Þ–DKBb`pFÌŸ`1£­Å^‡¶–8ÿ9kæO8ñ¡‰™$RÀ9"`áÄJBBB)Ù•„„D¿E0 ‰~‹$`ýIÀ$$$ú-’€IHHô[$“è·H&!!Ño‘LBB¢ß" ˜„„D¿E0 ‰~Ëÿv%Õ ñÚíIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_images/ftp_uri.png000066400000000000000000000617421240331347200261160ustar00rootroot00000000000000‰PNG  IHDR}©^C‹ÝsRGB®ÎébKGDÿÿÿ ½§“ pHYs × ×B(›xtIMEÚ 58qk IDATxÚì]gXUÇÖ~i‚ŠAA»`‰5ÖØ»±ÆhŒÆ£‰&1±DcL471ÆvÕ5vM¬` * ˆŠ€b¥wXßõmöÙœ(Øî¼Ï3Ï>göì6eÍ;kf­Ñ#"‚`Ĉ;v,:tèPªëüýý±aÃlݺUd¢€€€€€€Àk =m¤/11gϞţG`cc[[[Ô­[VVVoeF„‡‡£]»vˆŠŠB¥J•Jumûöí1nÜ8Œ1¢Ø´›6mÂgŸ}†ˆˆ˜šš–é7œ>}ÁÁÁ€áÇÃÚÚú-»wïâСC "´iÓMš4­U ÜQPP€ 6 -- –––5j”Ö´ûöíÃÆ///|üñÇh×®ÈDbûš£GBêzMLL0qâD‘1¯D„­[·âèÑ£HHH@£F0eÊØÛÛ{mtt4Ö¬Yƒàà`899aØ°ahÛ¶m‰ú¹ýû÷ãÌ™3066†¯¯/>úè#•èCBBpúôiL:µÄß©¯)òÏ?ÿ„³³3¾úê+ã?þÀìٳѱcGää䨥ÅÕ«Wßè_¾|9>þøãR¾ . ** C† )QúŒŒ ÄÅÅ¡<¬>Dtt4/^Œ¼ÑåñôéSDGGcëÖ­8yò¤H/ùùùˆŒŒDHH/^¬5Ý¢E‹ðå—_bØ°a8xð ¼¼¼0fÌ8p@d¢€NÄÇÇ#::ÑÑѸuëæÎ+2å#'';wÆ–-[ЫW/̘1ÆÆÆhÚ´)üýý‹å¾¾¾ÐÓÓÃÔ©SQ§NŒ5 «W¯ÖyÝñãÇñÎ;ïàÊ•+>|8úõë‡Ó§O£Y³fˆ‹‹Ózݹsç0mÚ4899¡OŸ>X¶lY©Ù­‘‘‘T©R% ¦’bãÆ4nÜ8zSñàÁªZµ*%&&–úÚ¾}ûÒêÕ«KœÞÏÏFE™™™åö=ÞÞÞtåÊz0kÖ,Z¾|9 ¼Lܺu‹êÖ­«ñÜõë×ÉÁÁ’““ñáááäéé)2O ÄxöìYXXˆŒxÅøüóÏéý÷ßW‹?sæ ÙÛÛÓÓ§O5^WPP@ 6¤Í›7«q KKKŠˆˆÐ*C*W®¬±Ÿ^´huêÔIãuYYYÔ¡CúꫯèÚµk”˜˜H5jÔ(Õ·ªiúÐ¥K4jÔ¨TS"oòÒÀ•+WbÔ¨Q¨Zµj©ÕôgÏžÅرcK|M‡°iÓ&˜˜˜ˆá•€Àˆ9sæ`Á‚033SÄ»¹¹¡B… ¸{÷®È$7þù'¾ùæµxii‘¶Ù¦;w¢R¥Jxÿý÷ñööö:t(~þùg×mܸóæ̓···Ú¹¹sçâÎ;ˆŠŠR;gll ???|ùå—ðôô|®oU#}ééé°µµ}陞——‡ððpdgg¿Ôç>{ö 7nÄŒ3J}íòåË1yòäRO ?bbbp÷îÝç"×QQQˆ-õu©©©¸yó&òóó_JY$''ãÞ½{Ï?‘‘‘¥ÎŸ'Ož ,,Lã²…òáÎ;HMM-uy\»v Ož<)Õuééé¸yó&îܹSªïÌÏÏÇýû÷qõêU<{öì¥åOBBnÞ¼‰¼¼¼–)%‘'¸uërssKTv'OžÄСC5ž·¶¶Æ;wD/ú ÛWLL ™™YªöX´ü£¢¢J,O¤þëe}gVVBCCñôéÓ—–¯ˆˆˆ@dd$ ÊU>çææâöíÛŠôùùùˆŽŽ.—oKKKÓÊ{ìíí‘œœ¬ñÜñãÇ1räHçFŽ‰={öh<7}út|úé§Ïééé¡~ýúˆŒŒ,·ˆbcc©nݺäèèHU«V¥*Uª£££"Œ=ZMM8räHrtt¤jÕª‘©©©Ú5µkצU«V)®Y±bÕ®]›éŸþ¡ððpêСÙØØP“&M¨fÍšôÎ;ïЦM›ŠUSдiÓÈÝݾùæ›çRë~ûí·¿­¤SÂÚÔ¾ÒT®“““Z¾H¡¸é䬬,úì³ÏÈÚÚš\]]ÉÍÍÌÌÌhâĉ”ššªsz7((ˆV­ZEVVVäââBæææäèèH~~~¯7n9::ÒäÉ“)22’|||ÈÜÜœêÕ«G¦¦¦4fÌÊÉÉ)Õú/¿üB¾¾¾äèèHäèèHS§N¥œœÓ»YYY4gÎù“––¦õyyyy´|ùrª^½:ÕªU‹7nLæææÔ¶m[ -Ñ;ÿý÷ßÔ´iSêÝ»7Ý»wOcšÃ‡–ÿ²eË(11‘ D¶¶¶äååENNNÔ´iSZ´håææj¼ÇùóçiÈ!T«V-277'///244¤FÑùóçu¾ã½{÷¨ÿþdaaA^^^äååEæææ4bÄ5j]¿~]k»Zºt)Õ¨QƒêÔ©C-Z´ 5j§§'-\¸,X 65"Õigggºqã†Ú=¿ûî;EMï¾fͪY³&ÙÛÛ“——™ššRÏž=)&&Fë7¶jÕªð¾k×®%Iž :”ªU«FŽŽŽ4iÒ$ùLC† ¡š5kRãÆÉÎÎŽÚ·oO¡¡¡Z§wcbbÈÁÁAO³gϦvíÚQ¥J•èðáÊóóæÍ+6–.]ª–?!!!äìì\_4߉ˆîÞ½K...…i¦OŸNDD½zõ*ŒkРegg«];|øðÂ4îîîôìÙ³2iÏyyy´lÙ²ÂöåííMfffÔ¶m[ Ó*‡U¿_uÚ«hÞ)®ÍÏϧü‘|}}ÉÌÌŒêÔ©CŽŽŽd``@&LP“W®\)Ì×]»vQÍš5ÉÕÕ•ÌÍÍÉÏÏBCC©nݺäììL...tìرÂk—-[VØ=z”¨}ûö…ý—ƒƒ½óÎ;´eË–r™Þ½pá5oÞœ,--©I“&dggGöööôÛo¿•ÛÔg\\ <˜,,,¨aÆäááA–––4nÜ8:sæ Í™3Gãu™™™4{öl²²²¢ºuëRݺuÉÌÌŒ&Mš¤V&[·n¥Úµk“——ýùçŸdnnN...T«V-ºwï:tˆ¬­­ÉÙÙ™š5kFwîÜÑùΤ&MšPŸ>}tÊ £F¢íÛ·«Å§§§“‹‹ =yòDãuíÛ·§sçÎi<—’’B”——WªüNNN&;;;zôèQ±iŸgz·pM_ll,EEEÑ·ß~Kǧ¨¨(EÐD2RSS)**Š–-[FT»&::Z(äääPtt4uëÖ&MšDÎÎδeË*(((LsêÔ)rqq¡¹sçê|ù3g΀ mþ\222¨zõêZ‘.Ìœ9“f̘Q,)½ÿ¾Z¾DEE‘ÖŠ$ 3f ÅÇÇ+â?úè#rqq¡ØØX­¤¯M›6Ô±cÇÂ<ÉÊÊ¢ýû÷SÕªUéâÅ‹jפ¥¥ÑêÕ«ÉÝÝlllè¿ÿýoae ¥îݻӄ Ê\ Œ=šš4iB×®]S4–É“'S×®]é£>ÒHú¤ü;v,%$$(â'NœH...§v]NNµk׎úöíKwïÞUtTëׯ':pà@±ïíææVXï´ ½‚‚ºwïÍž=›H´páBENmÚ´¡nݺQ~~¾Ú=öìÙC6l ÐÐÐÂóÉÉÉ´~ýz²´´¤h|vnn.Õ¬Y“æÍ›GŠ:¿`Á@ÿý·Æk¿üòKjÔ¨ݾ}[€ZYYQïÞ½Õ„û´iÓhÚ´iZß';;›¢¢¢ÈÉɉ.\¸ –O½{÷¦:(ž™MË–-#[[[µk$<}ú”¢¢¢hüøñôý÷ßS@@ÕªU‹-ZDñññ”••E&LPûÖ'N••ýöÛo…„°  €öîÝKîîî´qãF¤/ €Ú·o_øÿöíÛdggGŸ~ú)R»víÔH_ff&M:õ¹ò'((ˆªW¯NQQQ”••¥ñÚGѼyóhòäÉ…e””D:t õë×+äGÑNéúõëdee¥±­<rrr¨M›6Ô¯_?ŠŒŒT´¯uëÖ‘ƒƒ:tH£,^²d 988¨‘ºììlZ¿~=U¯^Îœ9£è+¤g.Z´ˆ:¤©áááôÞ{ïш#4Ú]]]ÉØظð}Ž9BÖÖÖdccC{÷î-,ïæÍ›+Þ%::šºtéBü19;;Óü¡x'ªS§}ñÅeJúÖ®]KNNN´{÷nE|HHuèÐ TæòùæÍ›äàà@?ÿü³¢/OMM¥ uéÒEc»¬_¿>7N!ŸŸ>}J~ø!¹ºº*Ê*//ÂÃÃIOOlllèæÍ›…ƒggg²µµ-¤þøã4iÒ$ïíââR(ŸçÍ›Wìw‘««+mß¾½PÎFEEQçÎiæÌ™Z¯srrÒÚ¦‰ˆìííéáÇ%Îï‚‚>|8M:µDé_ˆôIøõ×_iâĉ¥ºÉúõëiìر¥ºfÀ€d`` U[ñøñc²¶¶Öi˜˜Hfff€œœœ´jK´á?ÿùõéÓ§Ô áéÓ§TµjÕ ´¡fÍš:IßðáÃu’Þ¯¿þšzöì©•ôuëÖM£±È”)S´’ÕíÛ·“±±1íß¿_í\xx8™››kÔdhh¨u0òðáCªV­]½zµLH_XXÕ¬YS«b#''‡Ú·oOüñG™•e~~>µlÙ’þúë/­iúöí«‘ô <˜æÏŸ¯õºùóç« 322ÈÈȈ.]º¤èkõõõ¡3gÎеk×hóæÍäáá¡Q R¤oæÌ™äãã£sp[¤ÏðU.òmÙ²¥Îó­ZµÂ§Ÿ~Š/¾øBk333¼û~öÎ;Q«V­bß¡(233±zõjœ:uªÜò%((­ZµÒé ÑÀÀíڵÕ+WЬY3‹Aµ]G:Ój» ËÌJ›ˆpêÔ)¬_¿^kš * E‹óÇÇÇGgþ¢]»v BÓ¦Maaa066ÆÒ¥K‹5|)‰€¯¯o‰¿·U«V:Ï7kÖ gÎœAAAôõõÆ?ÿü3vïÞ˜˜¤¤¤ÀÔÔµk×FRR&L˜ ÙBK_˜ÿüs@`` >þøã2iÓ¡¡¡011Á’%Kt¦»wïžNã°Q£F¡R¥Jhݺ5ÌÍÍáïï÷¼zõ*–.]Šàà`<|øP­Z5¸¸¸ ++«\ätqmºeË–X°`A™øá»|ù2ž={†éӧ딩ÑÑÑÈË˃¡á‹wí!!!:å8::büøñå³®wP•Ïš,X_zzzž»*†Žâƒ>(ŒóôôD=àíí '''Ö²¦¦¦HHH€¥¥¥VãÄ*Uªk óÑGáöíÛ8rä*W®\®¼ë•’¾ôôôb-jÊ¢òjÂwß}Wlç¯ 7nD«V­àîî^nù’˜˜X"÷1VVVHHHx#­ú²²²••…Š+êL§)Jš?ÕªUCbb¢‚ÃÍÍMçunnn¨Y³f™[‡7˜(JøвeK4jÔ+V¬@ƒ `ee…¬¬,DDDvÜÚP»vm:t¨Ðz.00'NœÀo¿ý†¶mÛbõêÕw…100À‚ °`Á¤¥¥!$$þþþøí·ß°xñblØ°A#÷ññÁùóçáêêŠ;v`âĉ¨R¥ öîÝ‹Ñ£GãÂ… jVò %®ëªeù"xôè<<úè#Ìš5 S¦LÑH¦¥©fÍš¸yó&ÜÝݱ{÷n\¼x]»vÅ7àááK—.¡yóæe’¯¥i_Å‘ó‡¢bÅŠÈÈÈ@RR’NÒ·mÛ6L:Ó¦M×_~‰ÚµkÃØØÏž=CHHÊÍ⳸þÍÀÀ ÌòÖÑÑŽŽŽ:Ó-[¶ ÙÙÙeÒoÆÆÆ>×\¥é¿ÊªM¿RSS¡ |ªr`êÔ©Ø¿¿FÒW«V-„‡‡ÃÕÕUí\NNÒÓÓuæa^^FŽ‰´´4>|ø¥¸r{¥¤ïøñã˜9s¦ÎyãÆËü¹GŽtíÚµT×åççãûï¿ÇŸþY®ùÒ¨Q#üõ×_Ŧ»rå &OžüF’¾Š+¢AƒˆŽŽÖ©%¹~ý:êÖ­«–?%ÑÂ\¹rŸ|òIáwww¤¤¤`РA¥öÉø¢@VV–ÖFíçç§6â7o4h ö­&&&ðððPËUäææ*4¡5kÖDÍš51pàÀ­íÖ¬Y£‘d¨j LMMѺuk´nÝ ,À¦M›0räHܺuK+©éÑ£.]º„}ûö¡B… X¹r%FË—/«i¥6lˆ°°°Bm”6•Êw¨.´oß7nÜЙFÛy;;;…[¡N:ÁÏÏ7nÄÞ½{Q§N­»áH¤¸{÷î¸|ù2Þ}÷]⧟~*ÌI+­ oooܼy¹¹¹Ø±c† ‚V­ZáÑ£GˆŽŽÖª!T-“ØØX¸¸¸ÀÁÁC† ÁŸþ‰?ü077/“|­_¿>’““1xð`­š’`éҥؾ};Î;‡«W¯¢{÷îØ·oŸÆ¾ ==ãÆÃÞ½{ÕäyÕªUÑ¡C‡oiõ<ý×´iÓtö_eµ}d“&M`mmýR·k«W¯üüüž«ÿ*ÉÎ4AAAåÏËFxx¸N7uŽŽŽØ±c‡ÖÌÕ«WÑ«W/µs.\ÐIÒ³²²0pà@XXX`Ïž=å¦àR@” s44|.úñãÇñûï¿k"""´>¯ÿþZŠêééá“O>Á‰'ÔÎ:tHÍѨ*FŒÄÄDÜ¿_£Fêüùóسgzöì‰ * S§N¸zõ*acc£¦Y455EË–-±jÕ*‡M›6á½÷Þ+“:Ú©S'lÚ´ IIIZë°¶÷±··ÇãÇ‘’’Rçéé‰~ø;vìÀ¾}û0{öll÷îÝèÕ«Waþ„„„àüùó°µµÕ¨y522Bƒ pöìYœ8q½{÷†žžˆ;vhÕô©–ÉŽ;0xð`ÀàÁƒ±}ûvש"99«V­Â?ü Ó_£ „åË—?wÙ|ùå—ؽ{7üýýammN:aëÖ­èÝ»7Ο?¯–>88uêÔÑ:€ŠŠ*7ßyGŽÁÆ5ž ÄÖ­[Kµ'ª.Œ1¿ýö›Vq¥‘Ï[·nÅ×_]¬Ï»6mÚàÈ‘#ˆ‰‰Ñ™.44T¡õlÖ¬¢¢¢tjXŸr)›û÷ïã›o¾ÁÿûßbË¿^½z¸qã†VÍí¹sç´8 €µk×jôñ¹iÓ& 4H«–¸{÷îpttÄæÍ›_á€21ä¸t陚šjô;—œœLüñ‡šá€hÅŠäååE'N¤àà`JKK£ððpZ²d ÙÚÚÒ?ÿü£ó¹ááá…fÙ&&&Z]¨"00êÔ©Sjß9DD^^^%¶zQëÝ3gÎP­Zµ4šSíÚµµZêÚ†íôéÓÔ¶m[­†º¸7jÔHãâ~UüñÇ…eR¯^½b­ 5Z Þ¸qƒ6lH-[¶Ôh¬púôirttÔ˜?W®\Ñš?)))…þ#5¹HIII¡eË–iuÃ"¡mÛ¶…ß¹råÊb 9>ùäêÕ«½ûî»töìYJNN¦{÷îѦM›ÈÞÞ^ã=ú÷ï¯Ñ]@tt4ùúú’‘‘‘VCŽ:PçÎ5ú^ËÉÉ!OOOúúë¯5Ö*Uªhµì]±b988h´Î,(( jÑ¢…˜áÃ?$___úðÃ5ÞóÁƒT£F ~²>|H¾¾¾ÅtÍœ9“¾ÿþû·¿iÓ¦Q÷îÝÕagffÒøñã©C‡Z·a:t(­X±¢Ôm^5TåÈøñãÉ××W§K¤9s毯/õë×O!w===ÉÚÚZ«µßÝ»wÉÍÍlll†ÞÞÞäë뫶_[^Iu]ÓVUEå}íÚµiõêÕZÛ×wß}GŸ}ö™Ú¹Ù³g“ÚövDì.ÈÞÞžüýýñ?&###ºuë–Ú5Û¶m£ªU«’žž^¹r¬\¹’<==iÒ¤IBiiitóæMZ´hÙÚÚ–¨¯(Ë–O?ý”:wî¬ÕíèÑ£Ô£Gþ7oÞ\X– 4(ö™‹/&nI’““iòäÉT¿~}…[ÉÄÑÑ‘Õ® "GGGµü)KC__ßÂï,ê+X›ü6l˜Z;òóóÓÙWhì£|»wïÆ®]»°nÝ:øûûãóÏ?/ÔܵmÛkÖ¬)Uþ@•*Uðï¿ÿbÒ¤Iظq# Ã! IDATºuëggg<~üaaa8zô(zôèo¿ýVç»—æ;%Ö¾}û°jÕ*|ûí·¸xñ"ªT©ooo8p@ãÔÕ²eËЦM\¾|½zõBff&.^¼ˆÌ™3Í›7/Ì›¹sç*ŒŒŒŒŸŸoootîܨX±"¢¢¢ð矢E‹˜7ožÚ3+T¨€ZµjaÔ¨QhÔ¨5jGGGÄÅÅáôéÓ ÃÁƒ5¶5===4kÖ èÔ©SaüàÁƒÑ±cGŒ7N«öìèÑ£9r$Ö®]‹öíÛÃÚÚ7nÜÀž={0cÆ Ø÷ïßM›6ˆ ?~\žÆÐ×ǬY³Ð¡Cy;}útxzzbÈ!pwwGTTöìÙƒÞ½{cæÌ™hܸ1ºvíŠæÍ›+´°sçÎE·nÝУGµõk=B5´jX›5k† . cÇŽŠüéÔ©“Æ5EªZÂï¾ûN1ÍÔ´iSdddÀÅÅ*TÐx]:u””OOO…¡Ç!C0gÎüúë¯ÅÖ]Õº^œŒ533Ù3g0iÒ$lØ°AcûêÙ³§bË«øøxôë×ðõõÅ°aÃðã?ÂÅÅ°eËlÛ¶ +VD÷îÝññÇãûï¿ØÚÚbÑ¢Ehݺ5ºw-[",, 044„ŸŸÚ´iƒ¾}ûÂÊÊ Û¶mCxx8fÏž{÷îa̘1øàƒÚí &`ôèÑŠúª)®víÚÀÒ¥K1eÊ„„„ fÍšhÙ²%._¾ {{{³E7n,4ˆËËËCZZš¢¿Õ××Çœ9sЮ];ŵ‹/ÆO?ýoooôéÓõêՃ€ÜÜ\|÷Ýw°°°(“²€O?ýhܸ1úõëOOOddd $$'OžD›6mpìØ1T«VMqÝ;＃_~ù €Z¶l \¹r~~~øùçŸ}é¡C‡°jÕ*¤¦¦¢{÷î˜?~¡¡Lvv6ºwï®ÈMq/"Ÿ—,Y‚ &ÀÛÛ @ÕªUqéÒ%bçබÖÚ¦7oÞŒ>}úàäÉ“hß¾=®]»???lÙ²E£æþîÝ» …¥¥¥V õÕ«Waccƒ† *â³³³1tèPddd~gbb¢â>®®®X½zµÖoÕ#"JKKÕ+W´n­¢§§µ‚Õ´.éäÉ“xöìœáîîŽV­Zi\ß1pà@ < x!rtðàAøûû£_¿~ÅZä…‡‡£}ûöˆŠŠ*õ‚ÉwÞy'NÄ!CÊ„ÔÕªU AAAZ+“„¤¤$üóÏ?¸~ý:òòòаaCtíÚUãuOŸ>Åõë× Š•••bÁºêvZzzzðòò*/^,¬HúúúhÚ´i¡•fNN.^¼XH²ÝÝݵ®ÈÍÍÅæÍ›qûömŒ;¶ØEÝÿ¯mFHHNœ8§OŸÂ××­[·†……"##qÿþ}èëë£qãÆjèÙ³g8|ø0®_¿Žüü|xzz¢[·n%Z€|îÜ9\¹r·nÝ‚­­-<<<àíí]" Ш¨(¬_¿5jÔÀرcu֧ŋ#==‹-*u=IMMÅ–-[KKKxyy¡mÛ¶°²²Rä···ÂJ,&&5jÔÀ½{÷päÈDFF"++ èر£F‹oiIRR,--±oß>„‡‡ãñãÇ°¶¶†»»;¨•`l›‘‘¡V8sæ ¼½½u®ËÍÍÅßÿk×®!11 4@ÇŽáìì¬1}BBBCCµZ”ëëë£Q£Fj{äZ÷óóÃ¥K—РA´nÝîîîÈÌÌÄ… …DÂÊ•+±|ùrL™2M›6EJJ Ž9‚ÀÀ@iÍ#Mù“ŸŸÿýWgþdddàâÅ‹hÕªŒ ãoÞ¼ ===†eÁÁÁ°°°€“““bÊ688mÛ¶UiÂÓ§O±nÝ:äææâÃ?,Vf•¶}àÂ… …󆆆hÞ¼yaÆÅÅ!<<¼°œkÔ¨¡¶ž588‡Bll,ÜÜÜàííÖ­[COOÈË˃¹¹9¼½½‘K—.!//¯0ï$B„ÔÔT¸¹¹Z”kŠëÛ·/F¥U¢ ñññ…kXµ®¹ÒОUñðáCœ:u 7nÜ@nn.<<<РA4nܸXeFNN6oÞŒˆˆŒ;Vçº`UDFFâäÉ“¸qãŒáì쌎;¢N::¯+*Ÿ¥þ«¨|~öì®]»"R“õ§NRËMqEßwýúõpppÀ˜1cJÜߟ;wHLL,ôVPkÚŒŒ ìÛ·W¯^EíڵѣG­ýHZZZ‰–£5hÐ@c[Sí«5ÁÆÆõë××Mú^ÅÚ¯²"}¥Á´iÓ`oo¯uÍ6„……¡_¿~…Ú„Ńàåå…øøøb®À›!}¯/Ο?íÛ·ãƨV­|}}1zôè23Œx}ñ¼¤O@àUÃðécçÏŸ_¬¶RÜÜÜXfæ÷›6mBË–-áxƒÑªU«b}µ üO“¾ÄÄDDDD 11wîÜ)$S 6TL[”ž‡ðl•¦k„6¤§§#44´pÚ<-- þþþصköîÝ+jß[ŽŒŒ ܸq111ÈÌÌD`` ôôôàææö\õI@@àÕ"!!wïÞųgÏpëÖ­—Ú ”^úôî† °eËÅš,_¾¼\|ò½Jœúè#­‹½Þœ9s_}õ•b­¬žž&Mš„Š xÃðûï¿cÛ¶mjý׊+Ê̤€À[Eú^>Ä¢2Aúé¤O@@@@@@@àµÃ°aÀ† oßw-YhØÁH&}={±±oÎ-[ìÜ)*¬€€€€€€Àó¡}{`Þ< 5õíù¦G€E‹•m0ÕI_ÇŽÀÏ?¿”•üú+ e¿º×÷€“pò¤hdoRSÞ½[[@eßUز…Ó·ióf ¤€k×€úõ;;àܹ²¹ç“'@çÎ\'lmWW`Ó&@8L(®_ç~_jKNNÀ¡C/vÏÑ£jÕ€””7??úöš6zôКLbc nnÀßÿ¿™ýk "àƒ€ÌL`Û¶7§ –/>ý¨PUÉÇ‹üºãÁn4×®À… ÀÿïC¬@ÇŽÀ©S@íÚÀ?ÿõê‰ü|Ýqô( þÔTà“O€Ÿ~*»{§¥“'[·ùù×°!0~<0t(w:êÈÍ6oöí“Û—°~=ФIÙɶm{{`éR [7@×Î[DÀÓ§<¨üHH¬¬˜„Öª=ß{de±’(:xö ¨^ ¶¶@qŽü³³Ý»9s}}àßù]´’>"ÂòåÀ7ß°mÈížÄÄ÷ïÉÉ€³3àæ”`CbµNõÖ- 1¨Y“_ÐÎŽ_X[úÙ³3gøƒŠÙäùµÃúõÀ¤I\‰»u>úèÞ]û÷ ¼DD¿ýÆäüéS&~Û¶ff%¿Gv6ðá‡,¨LM‘#‰OO‘¿¯üý5k€={X˜/Z|öYù<+&øÏ€ßçºð@ÐÇèЧš7.ÙàB@àmD~>pó&pú4ÏŒ<)· O`Ê ]»²}îåË<è‹Žfò×¼9sccÖÖÇÅñQú“£ù>ÆÆ@¯^À¨Q¬•44,žÔ8ÀýÍÑ£2©- &66ªW¬­yp>5jìÚżLdçÌóæñ@'' U+&cOŸ2ézð@.Uýú3f-[êî 7ofÍ×;êç 9Ãíí>pÚ'¸ã=sæÍ՜ܼ |ù% WªáÃfÍXØ;:¾ø323¤$9¤§s¾çäÈÇ ¸U¬ÈGªL†¯hæ§O¹!ÅÅq%ÎÊâwÕÓãF$ÀÜœG=\ôô^ìÙ©©@HÌS'NpÙ¸ºrY úüÄüÀ`ÁàêUþïãÃíÄÛ›ƒ¥å‹½;k‘TË;3“óN œoÆÆL@mmY`T­úây÷¼B]UˆffÊåmd¤,ïJ•ä²¶°(2ôð!—uP“ùÛ·9¾kWô6mZþy•ÅrìØ1ׯËçôõÖÖ¯Ï2¡V-5jp¾JðûgeÉe§zÌÍòò¸œóò4ÿ60à²64”C… üm¦¦@•*LM¹¼íÈËc9”–&ÓÒ8O¥|S zzr¾hþ]±¢,ã‹ËhÿøçFv6kÉîß—Ã;,'ÃÂø»%Ô¨ÁkÓºtáe66å÷^))À_k×ò;¾(êÔaÓ¢…æó&°¶ðEafÆükî\nKÅ@¹#Ç’%žwaã¸qÿ;W¨ “~)¿¤P©’²¼‰”e”ÄÊ“'ÊöÖ¿?Ë,]ƒÕòÆãǼ $„ÃÕ«J¹ ŠŠ呾…×óÊ•ùhb¢$œ×ÚB^žL¸%"§+dfj×p”LLxúÛÊJìíY)áà _7‚˜˜¨$6ññêáe¨’BmAdKÁÈH®Sš‘’àKr+=]–»’¦,9Yó{™šrÿîåÅ+__ Aƒ—_npÿüÇ<óS\dc£TVåæò`2(ˆÛÍÂ…LÆ$¤§Ó¦ñ3,-¹¯uuå¼{øP ůýõòâþjìXæ %„ú6l ÀâÅ<Í¥­C64ätrbFk`ÀÂêâEàÝwY›%Mù9¨‘k;êÔaA DEiÖJ¨_Ÿ3­ÿ·S•íïÏkNâüSÙ£õµ€¥%—gÏž<]íTApþ<¯k;|øõü>[[ž*èØ‘ÀZY•ïHrÿ~Ö&ž:ÅÁëggžÒîÙ“§K£ýMKŽçò>z”§^'èé±<ž?ŸÉš¶ŒÜ\å”ò“',cÍÌXÚ¨Q©ˆžnÒ§ÚiGEq¥~ð€§¥iW[[Íš‹y½š°z5W~àãÏ?×¼6*=ï/1ܼ<¹ñ>çG½‘HJb«Ák×8\¿Îjï²P5ëës…µ´”ƒ4e¦:šKNfž˜ÈáÎY;ebÂë='OÖ½€öÁ^ø~½²ã¯Y“ëNµj\®Õªñ{©jRRXªUíØ‹t 5jp]lØ××5oÎõìU!:šIñõërˆ‰)b\¡‚²¬--Y#&•uÅŠœN*kiŠ]UóY£¯Mœ0A·ð îØ!wtOá¬] ¼ÿ¾È—·Çó´~^OŸž9˯ÞdìØÁkW‹®ž8‘g2^µ‹AúJ ±%„€€€€€€€€ }‚ô ü“¾x· W‰‚ö³Ö»7ðË/"?ÞFñN7°‹!—DúŽåmFj×¾ÿ^䮀€À«C\»8‹kÛ÷SàÍųgì+´`÷nÙ ³€€ÀK }•+óVmÏ»©º€€€@Y¡zuÞ!fÔ(‘o+,-ÿü‡·ÿ|]pþ¼(׶N•-ékÝšwdx]P­šÈQÆ/iiÀÌ™¢<ÊDì7òµ$}Àóï¹)P¾xøwP¶ŠŠÒž628wŽ7nׄ‚>/!<\¹Á{Ard’—Ç›•gdhff&pý:_—ž®=]J o&!.Ž7µ.ºñ8ï$ñèQñ êî]þ15ôv¢R%‘o;^—3æÍrD lñóÏ@hèkLú*T…T^øá E Þ#ÒÓSŽ¿t 4ˆŸ‰ ¨$`&£G³qMÿþ<í5v¬úý÷íãíµ¾úŠ§KªUã†DÖ?¾ýpr:väïß}¨W¯‹Š-âó;ó5«Wóóš5ãöíSî?îîÀ¯¿+Wòs[·’’ä4AA¼¿oÀÂ…L ?ø€÷„mÚ¨Y“I-À[+ÙØñ&èãÇkÎÏ={xW‰¯¿æï­Z•×€©ØWdâ[PÀß^y½w÷¼¾_wº¸8Χ´“ÿŒ ®S7n0a×MÄ˱±ü99ºÓ]¼(o“©}^t4·ƒÔT@_8)xë¡içŒû÷[·Š¿6/ë{l¬ît¹¹< ²²¸ÄÅ)åóêÕ¢,Þ6·oËÿ“’X•¤Ÿˆ‰BB¸ŽiCApö¬üÿÖ-YÞîÙ̘QÖßCDÇŽ BÔ³'ÑŒDkÖ­[GjHN&Z±‚hð`¢®]‰>ûŒèñcešs爢nÝøÿDŸ|BôÞ{šï)! €hút¢Î‰FŒ úóOõ4DcÆíÝËÿ%:”hØ0¢ät11D ð;Ì›Gôä‰æg>zDôõ×D½{óû}ó QZ½Ö¸vó×ÕUý\ݺ|îìY9î—_ˆ¼¼”é>ý”¨ukeÜÚµDÍš=}Êÿ ˆú÷çû/ç÷Â…gbB4>ÑÊ•|¢ýû9¢Ê•9ígŸ:E4s&‘ž‘••2wìàô?ü ÇI÷3†ÿççmÛFÔ·/ÇwéB4|8Ñ]ºD4`Ç7jDôßÿM˜@tæ ×c;;>·¿ò{׬!jÑ‚èÙ3ù{¥ûOœøòË57—hÏnWúúD/:DdkËïðû¥¤¨×‡f͈:t š5‹ÈÞžÈÚšïU3gµmËåÒ®§óöV¦ùç¢Æ‰æÌ!zÿ}.¯ªU‰BC‰òòˆúõã²76&òð ú÷_ŽŸ9“ÈÔ”ã«V%š4‰(+‹ïyö,‘¯/_7r¤òy?ÿLÔ«ÑÔ©ü‘“˹¢¸r…ÛÙäÉ\¯ììXæIí쫯ˆ\\øyÆÆ,½¼4ßKàÍÀÇDß~KT»6QÓ¦ÜMddÄå\©Ñ–-ê×åç-YÂœbÆ –gUª}ðQf¦œ.6–e’“ß/7—åÀr÷—_XæééqœT§Ö®}¡ÏmÙÂå;D©©ü•+}ñ…2åÅ‹,ä7näŽÒÏ?ÞƆ()I3éóóã{÷êEdfÆñšÈÜüùÜÙùû…„uï®ìô£¢˜”êësüš5œ™>>ÜqKûÄ &™ñ=*WæøwßåN]Ç5oÎ% WW¢øø×·"ÆÅi'}ݺ©“¾¸R©~ÿ“'Lœ$<}Êõ(ïwáßOOèÞ=ŽKK“ó{Ã9­$T““ùœ—§*œù\Hˆ7}:Ç9"Ç>- kUHÑÃ(!AŽÏÎfA ­^­¼fÉŽŸ=[ŽKH ²´$Ú¾]™öüyù{cb^n¹ñ Hª³ëÖ1Yùúk&aRž®ün;;"77¹|ããùýMLdBKÄíÎɉ šjÞ4h $Wææ<¸’pû6—eh¨' fÍR~Ãҥ߫—ú÷­\ÉuQÓ§U«&×-"¢“'ùyîî\׉˜Xþç?r|ñÑ÷ßóÀ¥J–]D\MLXI¸|™…³ }ÿ¤oÄî+öíãöìãÃñ߯Ló&×õ¯¾’ã22˜,ýö›2½«+(%¤¤°ÌT\=~ÌÏrwåñ6`Ç¢±c¹L›6eeɨQ|¬RE–Gªý-×Áš5•}ÔîÝò}RS9îÄ Yf<_¹’å}µj215å:YFÕ«ÇKQM*éKNæÑóÂ…ÊtòË~ú©:é³³ãûJÑÉ“¯ÚÉH#óªU¹ÁIHKc2 ÈZ="Ö2LôüüäøE‹8ÞÅ…è£äL‹#ªS‡Ï]¾¬$9Õª)‰w¨ìëŠ'O´“>‰,«VÂÏ>ã¸Î‰îß—ã¯_—ÿþ»L²'LÃÈ‘r…üûoY#¦§Ç$K›ÆJÒôEŸ>|îàA9îî]&jÙÙêdÓÙYyý¡Cß¿¿ú½›5S/g"þ€’p¬YÃqcÇ*¿÷ý÷åï=|øÕ”oË–üüÁƒåQaA\Çõôˆ‚ƒeB°¦ZõësüÕ«rÜøñIÛÜ°¡2]j* (ss¢ôtå¹N”ïÀßRTö±æ 7N_µª,‹6ââXO˜ ~?‰¤ Ò÷ö“¾öí•3 þþߣ‡2½+"òó•ñÁÁ²GøÝ¿Ïq«V)Ó~ó }o;®\á253#Ú¹SŽgùð,†„½{9î—_ÔïÕ¹3Ÿûì39./Oîs~ýU]®• é«^5ª£í¸8¢Ÿ~’ÿÏžÍ/«Þ@úõSV|‰ôuî¬L›—Çš: e¼›«=?ViJfìX9íG©gQXÇW­ªþ…ƒó¹;”DÈÁ§wUŸ)i…,-ßÒwý:OãD+ò4š¤AQ%ùçdzgšƒ*)«P5*Ú`` ™ô}ð?篿4«Ä÷íãúÃ9““ºvVéëÔ‰Ï]º¤Œ?qB]èϚń#6Vû÷jšzÃÅ‹Êøœy`Å 9þ×_Y»­:`’ÚŽ*yûî;Y@Iš±¢ä?2’ÓX[íÚ%ÇÇÄ(µùª$ûÊ9® @ÖænÚ$ÇGGó@MÓKS]¸|™Ïéë+µî5kÊÓ»E1cŸÛ½[ýœ4š¤ïí'}sç*ãÃÃeE„«W9®ysÍ÷’¦†¥{egsÇ[±"?I‘‘œ¬ì7é{ûp玬¡+Šä¸4ÈíÒ…ãNROø°¼4Jµ‘f©ŠÎF–éÓG—.¼pÐÓøé'^œhc|ò‰¼ðïäIÀܜ䫢Q#vˆÙ·¯úbACCõ…¶––¼RZÔ˜œÌÏŽŒ–.Uoo`êT Iu+¼¢ ³ÝÜä—EQ«–¼€]B` ¿Ïwß)ŸËÏ9ÈÎ~;¡zx°åOß¾\¶?ýxy§N) ¶:³°ÐT tôôt?_OÃî IDAT³¸óEá縺²UîÿËeQ÷Õµ¸–ˆë¢¶ï52z½ÊÑÈH6ŽQ]œ>q"РÁ ~Gf gi°„Ù¨åìYN?q"[t{xÈiœœxçŠøxÞÝ m[®'ÜþU1n7m’ãdCX»VŽß´IÝpHªNNêßÚ —uA&Çk¯ÒBè:uʯÞ¼y\¹$&*û3muä®_—?þ˜åç'Ÿðù;33¹øßC×®ÌEˆ€;wøxú´v9$ÉÚ¬,–×LL^ªœÒÇ?°€OI¦Mã—Ý¿_™êæMÙbîE ¹s‘¬A¥oÓ†-85…I“t[h—YÒ9UBÁ˜¶gþø£ÜÁ¼©ÖFª°¶f+ ]»¸:ub‹O€-`ÞÊH²²dW/e]»Ø·ã—_óç¿—?Å}offñ–|¯5kª×÷”¶È=š­”ÿúK©Âɉ­qߟ-dû hØøûoeº}ûØŠºre¶îÐøôSu볡Cy¶m›,~øز…ï{î6"î ‡ Q^/ ÂT-´U… 4À,éàK"ÂÂ1¼€&«^Õz!Õ=m®UÕëÞÒ¥¼«Kõê<ˆ<˜ëtjªÈãÿUÉrJOe™Tg4Õ­5deBq^ Ê•ôYYqG±mkøbcy+µ¯¾Rjí22dPYAjˆ%1«/K°vQ—õë ss®`‰‰ê¾éTI‹„E‹äßýû3oßžó~çNŽwu•Ójr1>kʳgó÷ ª~®¼Ê§n]>~ó¬SÅçŸ+5¯ $mk½z|ŒÚµØ¯ ÀæÍÀ?ÿðàîéS W/¥ßC€µ€¡¡À{ï1i[¾œÝä¨ÂÌŒëSBÇsçX“èè(»ÈùýwÖâ6oÎé5u¬Ú\̘˜°ÜiÕªdy#ÍH™’ †þ7Q»6cb´×=€5ݪèÕ‹2~È2kÇv%ð¿‹ XÛW·.ÏdJ3"šê–¾>§·°Pº\{é¤OøC‡²“]Éóó’%2[•:É-[4ßå›ožïéÎÎ|Ü»W³°ÎÏçéȲ†³3{NÿýwÍçW­z} a… ¬¹{ú¸rEŽ÷ócÈ›„À@9LMYs£J"† aÂÿä w²!!²iÃVY7l¨,—Ü\Í£•ìlù¼&²­:‚ÎÏç:–­ü–ÿU’Wi°!]§é¹Ò¢¨¦Gz¦êû ÊyÇß+µ”`ýz&0 ¼ÚrÖäÈZ$ÍšñqãF.«aÃ4ûÇT­Ã‹ˤ§[7%©Û¾ãce)Û¿_n#þ©~Õ)ÞåËåz5bûŒÜ¼øåÍ£DæÔüý±±¼´ÃÔ´dù%i7÷î՞掮^#´hÁÇ›7•ÓlªuàÀ ©þW­ÊZòS§˜ø8 îÃR .Þ>h’Çì?ÕÃC(HuëÀõô©©\WZ·.½ïÐ2¬SúX°@þgiÉS;;³€ æøNø¸r¥ÒI!ÀMZ ]/)«V ¨_Ÿ;ó±cÕµLË–•cÕ6møøå—ìhS×®±&¤èšÄ× ]»òqôh^—8v,p挼þqñbYÃGĤ@Õaó¥K€­-¯óxtòÓOüÍ7oòzÊjÕ˜M™¢$Ç÷î1™ÈÏg•Eqã?3'GÝ¡pt´,lžz‘Þaà@vü^Öœgfò”CZç¹êt¶‰ ï Jþ³³•kñ$bç訙T¶mËέÿþ›ËÛËKÎßx`ró&àë«~í¼yœÿÿ­>à;wŽ—L˜ ™Ø«j$|ø!·mS::UMÿªn ”¤aÑÁfÑ&Àõ´woþýË/ê÷ò÷gMŒ40ÉËã=œUeNÛ¶r¿(µ iæþ}¹®JëÞlÄƪ+Žãú¦:›&ñ©;eù¬Z¯írM›| ®Ç’œ,:3SZP•*êî)>ûŒ-L$?3))²“X[[v±};[QÚÚ*-˜$‹–V­ÔÍF$G¹·oËqGŽÈ&ËÎÎì³ï§ŸØ眻»ÒõøqœnÑ"å}ÓÓ9ÞÈHý™’8U7ÉÉDÕ«Ë­“&±ä˜1l¹¨êçëuDb";~41a75kÖÈֻ͛³/EÉÎøñìÒ£~}öÿÓº5§»ySý¾çαugåÊ:t`Ëh {ö°µv»vzõRZR;ÆÎ%¥óï¿Ï×ܽËå ÅwéÂî$ËЩSÙ©p»vìʃˆãÜÝe_€?ÿ̸Ò=fÌ`+¼À@þFÕwZ¶LvåÓµ«|nÊöɨê6ÄLJÝ3T®LÔ±£æ|yÖ»nn²ë!"¶,·²bkD AAœÖЭÜ?ûŒË¶W/ŽoÓ†‰ff²ï({{¥UÙêÕlM¡l»+WÊíîþ}¶Ö.j1_Ô]RQŸŒgÎhöVÔâÒÀ€Ý8I–ØmÍ AJk¶äd¶bÔýIJèÑCnÓ ²l™3‡óàïÿâ u/o>&LÐlÙ/µ==¥zL ×;==ö‰)Õµßg/AArÚ[·øÓ§Ë}bF»1›6Mù<ÉÂ~Än“‘‘¢lÞëÝ¢¼#1‘%¤~äó·U+¹¾,¼¼XñѶ-ËmnVþü“뢅×VƨâàAö+ÕÏ=Ô}AJïж-»*º¡Às@þù‡`iÉSB<ÅÕ·¯fSôädžj»qƒ‚÷éêGÕõcYYÊk\]YmYtª¯zuåÂóÈH6¥Žæø^½€*UäùtMS‰-Zð{µ´¶æEåÒÚ4U´k'[?¦¦ò÷\¿ÎÓ;ót•€À«B—.Àñã\ß›5ã郲vSPÀÃmÖðªkàJ²—¶¶tÙÙ%·‚'âiŽ²ZV‘—'ß+;›óPìÁ+ PDD0‡iÚT^ï\™\RYû¡G$V ¼¶¤O@@@@àõ!}o8ÄÐW@àu‚´ýMt'$ ä± }%„仨õ®€€€€ÀË…´,íñcí~qß0ˆé]×ÇŽ[·²ë€ý&véÂN‘ÅZ4—"ö?|ô¨<oÑ‚·híÑC>×B… HŸ€€€€€€€€€ }‚ô Ò' HŸ€€€€€€€€€ }‚ô Ò' HŸ€€€€€€€€ÀÛC‘匧O'Oäÿzz€««ØOU@àuÂãÇ@r²ü¿B N‘/oó(oT¨,ZÔ«ÇÁÝðòöíãM^îÞåMÔä6úÞ{@b¢È·zD‚y¼ìÜ ¬\ ÊqµjƒqhÒDhÿ^îÝöïç6yîœ<øªQ;˜305ù$ HŸÀ âÆ `Ý:îp?–ãÍÌ€V­__ÀÛ›5NN‚ ¼â‰0àúuàüyàìY &F>_¹2Ð¥ 0nе+`` òL@@@>rÀíÛÀ©SÀéÓ||ôHy¾bEÀÍ5‚öör¨^°²â`m]þZ‰¼< ;ÈÊ⣲²ä8M¿Uÿçæùùòò4ÿÎÏ ¹ã54”ƒç…©)wÒ•+Ë¿ÍÌ€ªU9XZrú·ÉÉ<õ˜˜È¿ÓÒ€ôtÒïŒ 9¿óòä<ÎËã5¥rkûmbó±èoMç¤ ý¯P¡|ó!;HHàÏáÑ#àáC11À­[¼¦V¦¦@ëÖ@»vš6ŒŒ„,¤Oà%#&†5aa@h(‡°0îÌuÁÀ€ P¥JòÑÈHÙ‘J‚Uô¿D‚‚7'%X­O× öö€³óë5}WP¢„6O@@@>×DL##û÷åpïžü;#CäSiak ¸¸01pqa›&MGÇò{f\ÂÞˆ6"ˆˆ¢¢Š'1ê{{.¯Zµ”GGG.S¡Á¤ï­CRkƒâã•GéwR’<ý§ÒÓËO‹gh¨Ôò *(§ MLx ·hœ*TPNùþxJ3'G>¦§©©ü­©©²ûœ¸8ññ¬IREµj@ãÆZ´Ú·,,JÿýññRA"ª¤¡(¡ÈÏWN¿©†¢SÈ©{ Pòòx 5:š5§ÀµkLÐîÝ“5JMš:ñ‚ÿ6m4[f&àçÇÁߟ ¤¦en4lÈ¡^=ÖDÕ®ÍÇ*UÞŒz"@]ë1UãôõÕ‰¹ê##&wÂPI@@@@>WŠ¤$¶ôôóŽãõ•O)¼ÿíÝ{pTåùðoHÈf“@ B¸ 0Jå‡ )­­\z¬â… Fh‹ Šƒ-Ž-"‡Ki-:V«Ñ6 ¹  r r!÷ÝMÞßÏœyÏîžÝ$$$›ðý̼óžóžwwÏžœì>û¾ïyÏd àÒÒ€­[eÞÅ¢"©Ó®0r$0|80t¨\…MDDÄ ¨ Ø·OæY|ÿ}]%]Ȇ€ÔT`Ü8Ž'#""}DMÚ¶mÀúõ¾wSII,hþSƃ>"""" ^EMDDDÄ ˆˆˆˆôƒ>""""bÐGDDDD úˆš¹3€ÿ¸~osvâ°t©Ü>î™gäVpDDDà”-DÃéÚ´JK%PëÕ«îϹg0w®Ü!$'xôQ¹×ð¦MÀ¤I<æDD·9Î$KÔÂÃþÈÍ­Ÿ€ïÒ%i5\ºèÔIÒgŸÉmಳy¼‰ˆˆAQ£<¸þž+=¸~]Z ýûKo GDDà˜>¢æáÐ!Écc=Ëðƒ>jöœNàÈ ˆ**€âbéNµRRdd™™€Ûm]ÇáÐ]¥eeR·®22¬/ä8|XöÉpô¨´Úù“•%yttà×ËÏ—×,-åùADÄ (ˆ|û-0s&DD7êm‹½{KùÈ‘ž;p4Ø°X»èÚèÖ Ø¿ß³ÞÀ¯~ üñÀHÝ´4Ù®”,tî lÙ|ú)”$'˺ÚÊÏV®”±|R^\ ¼óЯŸtÍ^¼|þ¹ìÏ=÷íÚ¯¼âù\¿ø…<Ï¿ÿí¹î=Npûv¹°ãÅuë€.]€#d, 1è#jtwß ¬ZŒ+­u••zÛK/K–H¹¹µ¬ª ˜0xþy äþô'¹BÖ»EÍé” kØ0 ÿòWP ¯—™ \»äågÎH àùóÀG“'K«ZyyíßÓñã€Í¦[ç 'OJû¿ÿÉú¶m’Ö¬–/—×{åàØ1ý˜­[e?zÈsÝÜ ùöÛrõî‹/Êòš5Àþ<  ûCDD úˆ‚Bb¢uy¾egÎgÏ……º¬uki14[¹Rºi§NÕeýú<"áâÅ@Û¶ÀÏ~üð‡²==X±øÃ$\´¨öïeÐ à¹ç|»bû÷\ZöÙ¾v­ìÏœ9ÀèÑô~ýuÍ_ëìY 5˜8HIÑåÉÉr<._¦OçùEDtàÕ»ÔütèØíÒÒWU%“‡„HàT\¬ë½û.)˜ÙéÓ’›[Ô¢¢$Ÿ4I/×õ"‰ÈHÏý1—À˜1žå}úï¿/ݾ5õÞ{ÒÙ»·ï¶Y³¤¥4=]IsPHDD úˆ‚žÝ.ÞÊ•Э^ ,X<ö˜´ø€Ë%­`O> ¼þºõó´05„Ûl¾eue<§·ˆëò„ÉËÊjþéé’wëæ»-.Nä‹¥K™AQ³Æî]jžV¬>üPºg• 1&OÖWÄ^¾,]¥‡‚V)&æÖîcHHíÊoÆåË’çç[oïÒEòŠ ž3DD úˆ‚@uPU•oÙO*p<ñ„<~ófiäJØ-€½{=§F1ûÜŒñ.Xo·Û%¯Ï‰¢‰ˆˆAÑM3ºe¯^µÞnîòÌÌ>ø@–ããeŠ’/¾õ¿ÿ]ƸÙl2Kn.°l™ïó]¹,\ØôÛÀ’ü±õv‡CZC­Æüƒ>¢×±£ä_~©ËÊËe:Àó‚·[Æñ™!sñrß[@.dä*Ý—^ÒÏqì˜\Eû£éÇSÅX]xq³Œ.U—˳ܘ8Ù»ÜhÍ´êŠ-*’<'dz|Ö,¹KDZcÀîÝžÛrrdš˜§žªß.e""bÐGtÓ† ‘®Èôt™beéR§7b„lÏÊfÏvîÔÁá¼yz,[I‰tõNŸ®/Ƙ>]Z”’«Xccöí¾}eº” ôëWôîÛ'õëêÆ ÝjyæŒg hÌßg.7¯Ÿ8áY^\¬ï’‘á¹­MéÖŽŒÆ×sò•—Ë”-))25{!JÕÇ7QزEZåΟ— píZ¹5Ù ArWgŸ•;WdfÊØ=¥€sçdNº €)SdÎ:ó¸N'ðòË2 ò™3Òå;uªB¡¡Ò‚¶p¡ÜÎÍhíKNf̸ù.ѽ{õëS§d=!AæìÝxõU}—Œ¸8™8úñÇ7ßöì‘Ö¿¹sÈ /ÈsmÛ&ïm?øŸQ£ôk8 s îß/ãÃÃåóæù¿Š˜ˆˆô5ªÊJ Èéòt»u—­§3ðvƒËU÷¹÷š‚Ûå}ƒ>"""¢Û ÇôÝxG¢º(+«ÝÄÆ¡¡@«V""""ª1NÎ|+8¬_\¸¸^d$pÿýÀƒßÿ>Ђ±8ùQU?ìÝ ìß®ÇÀ”)œœù–«¬ví¾ú ø׿€§Óý˜à€ûîîº èÙSR|<%ÑíæêUàÔ)I'OJ‘‘ܸáÿ16’<ü00lðÿ„…1èkpN'ðí·À¡CÀáÃÒ˜•ää~\\œÝ»;JÔÞ¡ƒNwÜØí<¾DDDMEQàp—.I2–sr€ìl ô ý?¾E  sg‰z÷î½è×HNZ¶ô©Î /X””Hêpîœo ÑZ·¤U0.N'ïõèhÏ%9»•›¥¤y?Pª¬”\)ßd<‡÷ºñ!Ò¢â™û[6ò°0IDM…Ë¥ÿOŒÿs^] çHˆç²ÕºñS] åߥ)q»âbI%%zùÆ /Ï:]¿.yn®Ô­N|<Ð¥‹¤Î%ïÚ¸óN G "¢Æ»Ë ¯)…pù²$cùêU9q®]“”› äçë/ðÚ°Ûu%ëv»œPƲw™Í&¿&ÂÂ$7/{çV‚97/[*þ«rï²ÊÊê“Û]÷zn·N.—çºU2¾tŒ/ž@¹y9˜çAuÉ8/ÂÃå|²Ù$÷NVåF™q®šÏÛèh'Ë/ÏàUZêùi,—•I*/ש&ëò¿(ÿoæõ`e|††J2–åÆ.ã+P2ꄆ꼺T—zVŸñÞqMÊŒróß@¹ñÙoþÛ›?›½Ï ó9eNÞeÆùZR"ç^m……ILÛ¶ÒP“ ËíÚI¯]b¢$cÙf«¿S‹A_3TY©MäçKÊËÓËF*(_#F*,”¼¼œÇš¾ˆß`ÐXŽ•ÔºµNþÖëñ·I«¨Ïˆ‚ÉÍËæ²ÂBÌy·~””H2ZɈšªÈHùŒˆ‰‘d,·n ´i#).N/ëññRÇh nèß úȇ˥Aó‡·¿TR¢¹{§ÒRÏ_æÁÞJEÕ·@¿æ­Z üuפ›Ø¼î¯«Ú{½²RÆɺ\žy}ò/¿Ä«K±±Áÿw,)‘^£—ÀXöNÆÃÂÂúý1Ø¢…´ð-½FîÝzåoÙ8G¼‡9XuÁVW¯ªJ·Þ{çüzlÚBCuï€Ý®ôy§ÈHýÃ0PjÕJyM´'A5,·Û³kÆHòe]]²êõ.«IwimƺÁNMÆíÔfìNMºl¬rï`«6y]kìCSPUå:òÄœÊÊ|ËJJôž¢"Ï–póz +ðm6 þ’’€Nd Ž9ïÔI¶ßª÷íp/ÊTQÞÉá`®¬,ðó´l©¿ÜÌ_tÞëFWºÝ.¹U2†˜ƒ»¦tYƒ·"·*«Í?¥šŽõµú,¬î30Poî Ô-m  ÷LÆùd^· Â1Æ úˆˆê¬¨Èw,­y9'8^’Õ@íˆ «î’“^½$OJ ÜõSZ*|eeétö¬u—.ù««ƒÎŽõX"«ÔZ+‰ˆAQP)(Ð`v6ðÍ7À‘#2±ªÕ ðèh™£Ó[µò ò.\ðßí ôéôí+©[7èÅÄðoAÄ AQƒs»ÌL - ؾ]fÖ¯íÇqx80|80~<ðÐC2g# '"}DDDD8/ƒ>""""bÐGDDDD úˆˆˆˆˆA1è#""""}DDDDÄ ˆˆˆˆô1è#""""}DDDDÄ ˆˆˆˆôQ`»v³f5ÞëçäóçÇóoAÄ ˆˆêÝßþôï<ôðÎ;·«W¯½,^Ì¿ Q3ÆC@DÔHÊËŠ 6VÖ{ ¸ç 9¹q÷ë—¿¾ûxöYëíW®íÛóïGÔÄ„(¥Q#xë- gO`Ô(]æt6›¤òòàÛg‡xùeàÝwù÷#jbؽKDÔòó7Þð-‚¸fÑ"i$"}DDÍR}vŠ8ÀĉÀ… ÖÛ"ès»k_gÍšÆkHD úˆˆnY ÷ç?ýúÆIIÀ˜1ÀÇë:iiÀ¯ Œ-éìY)/)¦O—ú£GëîÐìlà¾û€/¿”õùóeûìÙÖûpèððÃ@t40r$•e]ï¿ÿfÌ&L1£F[·úÖÛ³˜2hÓFÖßxèÐ;¨ªŠ‹%°ë×xþyý¸iÓ€§Ÿ–対Òï÷ÿÇë'ê÷Èø¿éÓeÛÏœ>ÍóŠ¨ñ>ÓˆˆÈÒﯠÔÞ½²ž›«TÇŽJ…‡+uø°®WV¦Tb¢Ô=zÔó9ž~ZÊçÌÑu¥}TÊ·n•õë×õc""”²Ù”úüs©·|¹®?dˆï~®Z¥Tt´Þ§ª*¥~ó©?s¦¬+¥Ô¦MJ+å¡¡JmÞ,Ïk³)¢Ô‰J¥¦*Õ©“~¬áòe¥6n”òñãeŸ¥Ün9>áá²mÓ&ßý;xP©–-•ÊÊâ9EÔˆØÒGDäÏ{ïÉÊzB0t¨tÏîÛ§ëEDÝ»[?Ç€žë@b¢ä€´¸%&qqžõ\.àèQ`Ç`Îàƒ€ï}ع8sƳ%pÎà·¿î½WÊBB€åËå"‘U«€¥|Ò$௕åª*™‡oÇéf>pèÕKZþžzÊ÷}´o´n-Ëv»ìsb"*ÇÇh©""¦M“`Ê*ˆ»tÉëÓÔÏÇihèͽvË–@jªçóôè!˹¹º|ùr{—’â»?óæÉòüùº<*J¶…„èò¶me~@C«VµßßÔT 2Rå7<·­Y<÷Ï'"}DDAjÁ`áBY>pxòI`ÃYw¹~Ú¶•üÚ5]öÉ'’ßu—oýAƒ$ÏÉ‘d°Û%è‹Œ´~»½öû– ǧ xûm•4/¸>IDAT]¾k—\˜òàƒ<Ÿˆô±´4`ð``ûv™®¤1[¬ÂÃ%w:%ÏËÓ­jF™Y—.zÙáÐË!!_§ºíþ¤¦J åÊ•@i©”­^ <ó Ï#"}DDAlÝ:à'?‘¿×_:v ®ý‹‰‘ ðíndÜ`T”ä}úÜúýéÔ ˜-ݕÆ#Føn¯¬ô\7ºJ.o·âîaa@ïÞ²œžî»½´T¦Ž8P.HióæɘÁ7ß”Àoüø›#HD úˆˆÄ7ßH~õªgy^žggŒí3Zwîô wï¶qsW®H^\,WÔ’ËV̧qÕì¦M¾1ÞøqžåJI]ïÀÕ`Þ@û¬PTäY§gOy=‡CºÃýÝ¿—ˆô…áÃ¥ulÿ~ ^öî•ñ|Ÿ~*Û¿þX¶ ÈÈucº” ä⊴4éê4ZØvï>û ¸xQÖ)^6o–.ÐåË¥…ìúuŸçrù^k¬›ïä1y2ðÈ#2éóÌ™ºÜí^}UZùÌWy¹ J§NY¿wcüŸù‚ó>gdÈÕ‹……¾ÿÝï$¿ÿ~ o_žKDÁ‚Sù±l™Rññ2ép×®JíÜ©Tv¶Lfܪ•R[¶èº.—Lœ,á”RÝ»+uò¤RëÖÉúàÁR¿¢Bê_¼¨T·nzÛ•+J}ò‰RC‡êç=Z©?Têôi¥fÏV*,LÊ»tQjÅ ýÚN§RÓ¦ÉÉýûˤÊ))JMªTq±®÷ÑGžÏߧRo½¥·WV*µd‰žh:"B©¹s•ºzU×yâ Ù–”¤ÔŽþ]JŠLæLDA#D©ú¼¡$Q3SQ!­sݺé«Zsså¶hVS›dfJkZß¾Òrwþ¼tÝcï̪ª¤û81±þöõÈi)¼ûnß ŸëË•+2}Œ¿¹ óòäýgg7ÜXB"ªƒ>""ª_¯½äçËÝ=ˆˆA5.—ÜîÎ;sçäî ‡II<6DA„rQÝŒ#wiß^º•_xƒ>""jvRRd|_B‚\…å[£”X¾|9455K|ÞåË—ñäÉ^™å!999xúô)‚‚‚„àà`¾Q¾2’““±lÙ2èêêòñcÇŽHMM-Ók&&& ûrVVßÈeˆ¼¼< ^T!žÛÑÑï޽̟?/^ä?f!„……«/ªN›6 ÑÑÑxñâ²³³Ku³ÜÜ\äää Zµj%>7!!µk׮Рíç燓'O–øÜ 6`áÂ…<µò‹Û·ocÉ’%(((Ò[nn.ß0_;wîÄ/¿üÂ+´?0²³³±uëVܺu«HõæÍ›ˆŠŠ‚ššÌÌÌеkW(++ˬ¿yóf\ºt /_¾„,,,øÆ.#Ü¿óæÍòÊgÏž!;;»Ü[;ãââP¥JÀ§OŸPµjÕþ[À××çÎùsçÐÐP´hÑBáyJŒ1–““ƒêÕ«—Z¡Ý¿?ÂÃñiÓ¦'P¯^=$$$T؆5jš7oŽE‹•è<Œ=ÏŸ?—Ëüxð( R÷SÅSd qçÎ4oÞœo»wïÆÕ«WqîÜ9™Çããã1sæLܸqÝ»w‡±±1ÒÓÓqýúuT©R§OŸV8 ²´´Äþýûy…ö+BKK ‰‰‰åZ¡ÐÐÐ@nn.”””о}{¡»ÓŒ>}ú 66}ûöEŸ>}0zôh=z´H…Vµ,nž““Sªé“‚‚‚2ŸÒù–ˆÅ¥K—JåcµaÃÌŸ?ŸWfyð(GðôôDÇŽyeö†@ ÀÆqäȹubbbàïïÈÈH‰™ÉuëÖaÎœ9=z4nܸÁ7&…HNNFõêÕ¡¤¤HJJB­Zµ~øv9{ö¬„nĵOQPåIªôøóÏ?1vìXT¯^½Dç…††ÂßߧOŸæ‘r¦È;vŒoŒgÎœ®®.¬¬¬äÖ©S§Ú·o/åf§¢¢‚M›6¡qãÆxõêš6mÊ7(¹øüù3´µµ%þWd̲Bi }R íÉ“'qðàA¡aÆpppÀü!3piýúõxþü9^¼x¤¤$Œ5J⸒’Œ=zH”?xð{÷î…@ €@ :4h€µk× ÿ¿}û+W®D^^Ú´iƒéÓ§ãÌ™3ðööÆÇ¡©©‰Î;£Gøå—_Š¥TîÛ·ÆÆÆ3f *UªTbBF…Ê•+£[·nrÏÿþ=V®\‰'Ož ::Íš5ƒ –-[&5ŒŒÄš5kŸŸ+++Lœ8Qx,66«V­B^^`õêÕhØ°¡Äùضm›ÐqÏž=¨T©¢££±}ûvܽ{VVV˜5k ¥ž•1†]»váܹs ªª*Œ1jÔ(tîÜÿþû/† "u^~~>6oÞŒëׯ#$$ZZZ033Ãäɓѵk×Ñï† ðÇ(¬Ó¨Q#¹\555˜››#22²Ø ­8€îÝ»cèСRõ"""°víZ!66Íš5C‡°lÙ2™–½û÷ïãÀ`ŒAII cÇŽE§N„Çýüü°sçN@II ÎÎΰ··/ußß»w/|||„ÿ Ë“ÂÇÕÔÔ°jÕ* Ú}üø1¼½½ñìÙ3„††";;ÆÆƘ7oz÷î]¦ÊäâÅ‹‘““#”…RSS±`Á¡{ל9sЪU+™×¹qã†o¥§§ÃÔÔÝ»wÇìÙ³¡ª*Ûf˜’’‚>àÙ³gÐÐÐÀóçÏxûö- aÆBZNæ1Æ0jÔ(ØØØ`óæ͸wïдiSØÚÚ*”%?~ĉ'àçç‡ÐÐPÄÆÆ¢aÆèׯæÏŸ/ôã•…/^`ùòå Dnn.lllðÛo¿¡gÏžX±b¢££¡¡¡M›6Iù_¾|{÷îEHH233ajjŠ^½zaúô鲶LaqF2oÞDŸ>}зo_899!-- ÷îÝC×®]1uêTá¹FFF°³³CTTùóç# OŸ>ÅÊ•+qñâE´iÓ{öì‘©ÄL:3fÌÀ°aÄLzÚ´iغu+zõê…ÌÌL)þÁ¹899áÉ“'PUUÅ AƒÐ©S'ØÚÚâÁƒÈÌÌÄ–-[Š­È¤©££#äQgÎœANNþþûo¡5oÇŽhݺ5zöì)Tü8xyyÁÚÚFFF8~ü8bccqèÐ!Ô¯_íÛ·ÇåË—åÞ·wïÞ¸ví¶lÙ‚W¯^ c.^¼ˆQ£F!44Tæy—/_FÛ¶mÑ°aC}„ƒôÂ8{ö,:uê+++\»v >|8-Z777\¸p7†ƒƒƒD¶'@ggg,Y²ãÆÿÿþ‹ððp¬X±·nÝ‚ >}úT¶Bˆ1Ʋ³³æààÀÒÓÓ™8òòò˜žž»wíÛ·³)S¦°’"77—©©©•èooo¦¢¢ÂYnn®ÔñôôtfnnÎ<<<^§mÛ¶ ÀŽ?^¢gÈÈÈ`õêÕc/_¾,ñ;Ïœ9“-Z´Hadz:HÝ3++K¢¬qãÆìÝ»weæææìéÓ§Âÿùùù,99Y¢ÎºuëØÊ•+%ʶmÛƦOŸ.Q–šš*ÑÆñññLOO•nݺÅôõõÙû÷ïe¿zõ*322bRÇ ØÌ™3™KKK–úô‰YXX°Í›7—øy"""˜†††T`Œ1{{{6`À&„eMš4aýúõ“(kÕª “8w„ LEE…­]»Væ}Ÿ>}ÊjÔ¨!už,¨««Y'==Ë¥ëÏŸ?3vóæMV–˜9s&›6m+((:–ŸŸÏ:vì(E׌1æîîκtéÂ233¥Žåå屡C‡²©S§JSVVfîîîÂÿ111 €Ä·g:::E>ûõë×™¹¹y‰Þ·V­Zlîܹ¬Q£FìÑ£GRß@Ïž=c:::r¿ñ“'O˜žž‹‹‹“I—µjÕb)))2y‘¡¡!»}û¶Ô±ÈÈH¦££#ÁÄqöìY¦¯¯/óºgÎœaÆ “ûî-[¶”{]šššlÞ¼yÌÐÐ(lÆ1b[¶l™Ìkeee±-Z0''')º²±±a›6m’{ž óôô,Ö7upp`G-uxöì³°°`‹/VXÏÂÂBØ&¬yóæÌÅÅEfßaŒ±°† ²¨¨(™ÇïܹÃ7n,ó[¦¤¤°zõêÉ=÷Ó§O¬^½z,11QXÆìúõëçùûû³víÚI0Auuu¶dÉ †Rš÷–‡Ö­[³«W¯*¬3}útæêê*÷ø’%K˜••KNNfoß¾e¦¦¦lß¾}¥~¦f͚ɨØÛÛ³H•V$œœœ¤Ê&L˜ÀÚ¶m+¡øÊb~«V­*…vÓ¦MløðáE2ñV­Z•Ù·|óæ kРÄàB³5j”DYRR«[·®Âþœ’’Â6lÈBBBŠl eee©vÖÔÔTØöÜ·Þ¿MMM$''#&&ÕªUCrr2ÔÔÔäú´%KºwïŽiÓ¦ÉÔo®^½Šëׯ#66ééé¨Y³¦0€Q¤ÜðÄajj*3ˆíÉ“'022’r[* ###øùù¡C‡eò]*d–ƒâ0ÈÊ•+#!!¡ÄŠ‚——š4i‚¶mÛ–XÛ±c‡„C¼"XYYÁ××ÖÖÖ8yò$Œ´´4œ>}Ó¦MS¨ÐrÁtï޽ëW¯péÒ%Œ=‹-Btt4ªW¯.l¥ªª øûûÃÆÆ'OžÄÂ… ±fÍ<~üíÛ·‡¯¯o™ ¿¤¤$‚b š4i¢ðxïÞ½áææ†5jH1ŽÂˆŠŠB×®]Q§N :½zõBÕªU‘””„ððð¯¶hAQ‹ŽT­Z>|(“{%$$àóçψŠŠ*RÉNLL,“"""J%p^½zU¬óš5k†×¯_•oÃ)2¥ P(N4n~~>RRRpéÒ¥"ÓÏ´lÙRf¹““bccŽ§OŸÂ××®®®ˆ‹‹Ã–-[0zôh)~“ššŠºuë~·v-nû¨Éùo–”Ö_¿~´´4…õÚ¶m‹ŒŒ …÷ÿ÷ßKOšššptt,ѪwïÞŪU«àââ+++¹ñiiiÈÉÉÁ™3gŠ¼¦±±±\þ3}út¬[·NbóçŸbĈRJÉæÍ›áááQ¬÷PQQÁ‘#G¤|†çÌ™ƒ¥K—J(´÷ï߇²²2~úé'™×ºÿ>ú÷ï+++ôêÕ „ªª*ËÕ*‰ HNN.Ö‚J…RÃÂÂн{wäåå!55jjj8rä²³³‘››‹æÍ›C]]>>>2chŠÒªU«†?J”edd gÏžøðáÆŽ ;;;ÔªU ©©©xõêÒÓÓe^+##Ca°7—Õ>‰‰‰E¶²²²Ì˜J¡ Bnn®ÜÑ|BBâããŽÆK WWW gíâbß¾}°³³+vÔ«µµµ¹zyyáĉHKKÃÂ… 1mÚ4øúúbÕªU2•¿ääd$%%áÔ©Sèß¿?,--‘››‹°°0„„„ȵ²Z[[ãáÇ011Fš¾zõ ^^^h×®‚‚‚Ê,á³®®.ªU«†Í›7i±.Šz÷îC‡áýû÷°··ÇÍ›7å*i @¿~ý°aéc}úôÁ¾ ;‘e¡jݺu™ÜË 6Äœ9s¾YŸ400PÔ$Í›7‡——W‘õÂÃÃ¥EË/^¼€Ž=úÕÚFUU-Z´À‚ ¤2n”•*U‚¹¹9ÌÍÍ1bÄÀ›7oйsg¨©©aøðá –¶¶6Þ¿/30R¼]å)AßxñâE©h½N:øóÏ?¿èþ7nÄÔ©SQ¹råR¿{÷îÏt8pmÚ´A5àèèˆ;wîÈ€Ô¬Yõë×Ǻuë¾ÈJ9}útÃÅÅ 6DRRöïß/SQœ7oæÍ›÷EmÚµkWÌ™3>>>B˺»»»TöqŽ_¿~B%[–ábãÆåB±°°€ŠŠ Nœ8Qâs[´hØØXÀèѣѽ{w 2»víÂóçÏ‹ b}üøq‘²¦°,™1cªT©"w!§ÿýWæµÌÍÍ 7À111ÑÑÑ2ÛGCC£TíóE貺PQYÊiii)6 cÖ¬Y7nœBkHAAîÝ»'L‘Q\¾|jjj%N“ŸŸ77·-skmm ___<{ö Œ1˜››ÃÆƱ±±ˆŒŒDpp°\áرcG0Ç×Z!Q­i½Ô×ׇ¦¦&®_¿þE÷þüù³Ð‚›˜˜X¬ô‚/^”{_y²äüùópuu•;c"¯?9®®®r]N,X ³ÜÈÈyyyEº”9Šãl½~ýz¶páÂ"£åW) øÐÑÑ‘ì’’ÂRSS¥‚Â:uêÄ:vìȦL™"-›˜˜Èœ™¥¥¥D@•,ôíÛ—`*** 38ˆã§Ÿ~b'Ož,±3ûáÇY×®]K äìì,áè?gÎæììÌÚ·o/÷ÓÕÕ•ùíN:Å7nÌ"""$Ê“““™ªª*{ýúµLµ··g¾JPØÈ‘#™¡¡¡TÀZpp0³´´dsçÎ-M7(bĈlüøñrûdJJ Û¼y³Â€¦¢¢ÂH$ÊÔ)SØСCåb\¾|™™šš²ððp©þÑ®];– 3Š¿G2ƒ]¾4(ìÝ»w¬V­ZìóçÏ¥ |©U«–Ìg–IlllÌ:$·Ndd¤ÌÈpGGG™Y8ôë×M˜0AªüãÇLWWWnPÊž={˜©©©Ì`àÀÀ@¦­­-u,..Ž9880Å “¬&C† a“'O–ðrêÔ)fbbÂbcc¥Wz÷î-—çgee±;w²W¯^É<>þ|6{öìR@°éÓ§³U«VIÉ«âd9 ´°°IIII¬Q£Fìüùór¯ùâÅ ¶mÛ6…÷MOOg 6d¡¡¡¬~ýúRYrÊÙÙÙ¬AƒìÍ›7lÁ‚ì?þ[×ÇLJխ[Wf¶“   fbbòU‚Ââã㙚ššT€Wjj*8p  32˜j IDAT˯¯/ÓÑÑ‘)O8ܺu‹={V¡NñøñcÆc³gÏf[·n-2(ÌÙÙ™²½{÷J:³6mÚ°9sæHghh(“vÒÓÓÙèÑ£™AaŒ1¶téRfaa!‘¡%33“M:•õîÝ›5oÞ\f–ƒ{÷ ²èèh¹ïsýúuvñâŲ »zõ*ŸŸõë×£mÛ¶ptt@É÷ïß»wï"++ nnn=z´TR{{{hjjÂÙÙƒ ‚™™bbbŠ£G‚1™Îö3gÎÄÔ©S1mÚ4888ƒ…._¾ŒÛ·oãàÁƒÂçáP§N;v 3fÌ@³fÍ ­­ @€÷ïßcÒ¤Iؽ{w‘¾L\ð…@ À“'Oйsg…õ`À€%¶\oØ°¡TËãZ[[ãðáÃÖ™Áƒ£cÇŽ˜>}ºÂó.\ˆÙ³g ­Ô&&&ÐÔÔDHHÌÌÌdž§­­jÕª!88X¢Í‡ ‚3fkZV<¨¥(+míÚµáííQ£F¡cÇŽ4hš5k†ÄÄD„……áÂ… ðó󃫫«„uhãÆX½z5ºuë___èëëC__‚7oÞ Q£Fèܹ3V®\)­V¯^“'OÆ Aƒ0nÜ8ØÙÙáÕ«Wxôè<==1iÒ$¼yó{öìžž¦NŠŒŒ ìÛ·ÑÑÑ8rä233Ñ¥Káóœ8qyyyèÖ­›Â2kkkáÈÙÅÅzzzB?§7ÊL¢ŠK—.IÌ~¡… …%zöì)å{éááI“&¡M›6˜?>ÌÌÌP©R%„‡‡Ã××ÄÀúGs>yò@¡Ÿ©««+† †víÚaÁ‚hÕªòòòˆK—.ááÇ8pà€Ô²²#FŒ@TTÌÍͱ`ÁX[[CCCAAAX½z5ììì°téRaýçÏŸãüùópuuEß¾}%ò]»ºº¢OŸ>011QX¶yófŒ9²XV'Ožú:geeÁÝÝ]"÷b•*U0eÊ©vª\¹2Î;‡#FàìÙ³3f Œ‘––†ððpܸqׯ_—xOño|òäIDFFâ·ß~ƒ™™*W®Œ¨¨(:txðàÔyõêÕÃÉ“'1|øpôìÙ}úôAãÆ#GŽ ,, ÞÞÞ2­‹æææhÙ²%FŒ9sæ ==ÿüóŽ=Š#Fàýû÷Ø¿?(¨uìØ1a0Q^^ÜÜÜ ¦¦&<®¥¥…É“'Ëœ=Û¾}; Ìž=fffÈÌÌD`` ¼½½†£GJùþþûï˜3gÌÌÌ°hÑ"´nÝÕªUË/àïï={öÀÞÞ”ºgJJ 8€   R…Æ¡l’—c  œàà`ÄÅÅÉœŠNOOG×®]1`ÀXYY ÝljÔ¨³gÏbäÈ‘8uê† ###|þüááá¸|ù2þý÷_¬Y³Fá³V©RÓ§OG—.]п…î(euuuLš4 S§NEpp°B?ØŽ;¢eË–èׯFŒKKK<}ú>>>ðööÆÒ¥K1uêT¬_¿^Ê’ûòåKœ={V‚WæææbãÆB«¤’’ºuë&DY»vm 0LJ‹‹ TTT„´îèèˆÎ;ãÔ©SPRR’X$ªC‡pssƒ­­-FŽ GGG4jÔH¨ûp~±;wîTh¡åô©„„„b¹ôY[[cÅŠ7nœ0È“%.Œ%K–`æÌ™xþü9œœœÇÃÓÓvvvpttĹsç‘#GJøTÿñÇœꚚš¨^½:âãã1pà@œ={Vn}*VY‡„;vàСC CíÚµ…«‰;vL‚h•”” ªª*ôï*L“ÙÙÙ°µµ…­­­½nÙ²žžžðòò¶mÛиqc´nÝ÷ï߇´´´˜˜(œÞ*((@vv¶Ð§K¼Œ9‘‘‘Sû¿ýö"""dN÷7iÒ·oßF^^BCCQ¯^=… spï"Τ—,Y"1õ¦¤¤$sºLKK ÇÇõë×qöìYìرYYY055…©©)|||d.z"ŽÁƒãÁƒ Á¬Y³Š šªR¥ Ο?oooœ?nnnPQQA“&MУG…àË–-ƒ““öíÛ‡“'O W Ûºu«­síµ…xBð+V ''G¢M–,Y"U–œœŒƒ–8Ð$%%E˜ cþüùRS¡ŠÚ¨yóæðõõÅ„+©U­Z¦¦¦èСÜÝÝe*×sçÎE›6mpíÚ5œ;wnnnÈÍÍ…®®.ºté‚Ý»wËå“666†››ÜÝÝ…+…uêÔ žžžrã”””pæÌ,^¼'NDíÚµaaasçÎÁÜÜ:::øôé“” €xû¸¸¸Wƒä (‹¶¶¶p¥¿ .`ݺuPWWGÓ¦M1tèP :T‚/‰_ÓÃÃ>ÄñãÇqäÈ$%%ÁÄÄfff¸|ù²ÜL;vì@ïÞ½eß“'OÆ–-[P§NtïÞ½H—‰ììlŒ?^ªïçææ •‘² E üýý±{÷n=z¡¡¡¨Y³&LMMÑ¥K8p XÓ£FÂòåËKä÷%˜…––>|ø€ììl)×0Y¼rÑ¢E|X¯hÑŠåË—cÎœ9¨R¥ ,--±oß>têÔ ÇŽ“ËÓ‡Š.]ºÀÃÛ7oÆëׯ¡¯¯SSSÌŸ?¿þú«By[—ÎÕ¨$²dìرÐÕÕÅŽ;pøðaèèèÀÜÜGŽA»vípúôiáªl²ÜGGŒ!40cP¿>m sçÿ_y‡%@TðÛo¢þ¤£lÞ,¿þÒ¥À!€‹Ëƒÿñ(=Nœ Z>øÿR¾e__ÆGŽb«¨ñø"/ðô¤ïýÿå‘‹…ªU)S€o´š[…BA0l°f ðÿeƒ…`²`hÈؾ}¬ÂcÕ*ÆZµªxϽacÕ«3Ц­ÍØìÙŒ={ÆxðࡌݺÅØðጩ«‹úP£FŒy{+>7 €1 ªß­c±±|{þhÈÊbÌÅ…1%%¢ƒÍ›Ëþ±±ÄÓƺta,!o÷ÿ"Þ¾eÌÊŠ¾³ž^É¿óܹtî¡C|[rÈÏ']`ìäI©Ã²ÚC‡¨ÃùøTÜ?ž±Ê•»x±b>ZcÛ·3Ö¼¹H(Œ™š26}: çyçÁ+°ŒíßOJlƒ’ýÅÞž±3gˆOŸ2fnNçV­ÊØÒ¥¼bû# -±]»kÒDdD8uêëÝÏ×—1}}º—c—.ŸFy”odg3vâcuëŠdvXXɯ“—ǘ“]ã×_{÷îÇnW??Æ,,¨=~ÿ]fÙyh.^֮ƌªW—oÎÉ!Ÿ†ÈÌnh4n Ô¬Y:³r|<ðæ  hjŠ¦ ëÕþ¿¨‚Üó<<È=iý®È`  nÜnÞ||¨½9Ô«´j´l ÑÖ°!P« üݤ ;›ž7;[´qÿsrhjW  ½¬ßŒªª¢MMö@µj´U­*Ú+ÿná¹¹äN“–&¹ÏÍ¥¾Çµ׆ÊÊ€ŠŠ¨ ÿVSÔÕ©M54dÿVRú¾Óvqq@l,CÛ«WÀÓ§ä"•ž.ª[³&Ð¥ е+Эõ‰Ò´¯‡°u+ñ S' W/য়€--­oç†Ä}×Ü\Ú €J•èÛTªDü±"€ë÷¹¹ô›1z~ñMo/ë>ôò%ðø1pù2ñ×ôtâ!cÆ‹‘‹Ê×Dr20{6pô(}çúõÉEÆÙ™x:Š%§>N’’ˆoNšD:TåÊ¥—¡‹nnć~ú øùgÀÊ ¨[—6 êW™™¤ÿ|ø¼OúX\ù™ÆÅ©©T'3¨QC䆥«K×ýé'ꃥEj*ð÷ßÀ£G"]ðãG + ¨R…¶5Hgá6Ѧ­Mí¤®N2-.ŽÞãömàÒ% (ˆúç®]ÔOd@þ ÙÙÀÈ‘ôqªTlmI8T«&j0nŸ”$ÿ%-,€qãè)Åðù3ÄîÝä-ó‰•HQkÐ@ÔõëÓ3DEwﳜ6 pwÿï)8™™ÀýûäL[D ¹ÂPQj×&¢¯]›ˆ¡jUq‰+Š**Ô)ù'²²h“õ›ÛsÊê·FDµk‹¶:uHÁ×Ó£­aCêLå‰6£ÎÏ)m±±À»wÄŒâã%·¬¬oÿ|•*‰”ÜÊ•¥÷…«©MÉÛ8ZãïÜ\ #ƒ6NIÿô‰6yüEC03ÌÍiëÐh۶쾫@x{‡Sow]]Rl[´ þÃõ-n`U©)¡â[v61}Y7( ¤§¯©©‰h½^=@_ŸxµÅ˜™Q[}múŒž=#CDd$í?|hûÿ*C ¡¬L¼I¼-Å÷ZZÒ[•*ÔܦªJÏS¸-?&¹¼~-ò_UV¦¸‘Áƒ‹6Þ| ÄÄÂrè’BeÚÚd¤03£Íؘx7ˆ¯VúYaË̤kÞÒÒDt&þ;+K4ÀàL)êêtN†Ô­KÆ’Æi30 ¾ü- #QQôÍ^½¢öâøbb¢HÞää~À ô¸AŸ¦¦ˆvÄÛOK‹¾uáã_ܦ¢Bíʵ]Zñ¤°0Ps[Z=o:À„ S·nÙ´ÁÓ§¤Ø^¹òõÚ¹JÀÎøõWÒýTU‹7(Û·…>>Dƒ_jjÀرÀï¿“ƒ¢W ;p€F¯_ÙU«FQ{C†È>¾u+Š¿TX·l ¬ZôíûãŒ33I<{F>2R´%$ð£gyÄо±1í9áÿ5­oïß/^Hn/_’ËG´ÊVp4ÍøFF¤ÀÊõ±[·ÈRðà 3YƒÈòj3KK2LØÙÍš}Ù5?þù‡¶'Oh`šZqèJ_èØèÑèÙ³ì/µß¾ œ= \¸@ÜòŒÊ•É’la´oO3#}ùu##É0åçmeg—zêÓè×fs¾_zù’t2//š=úZhÖŒô¾äóCwwÀÕõë­››S`¦³s±úhñ–¾-( NææFšŠNÑÒ"ë·U¯N#õ€æS¦[¶ˆ¦–’’€Ñ£óç‰(,,hŸ˜Hõß½£=7ú‘'ôìì€ùó‰Añ!=Dt41Hnã\D>~¤‘nZÚ÷ÐÊÊ"KŸ¼;^©’´÷[YYdýhÔ˜šJ/9™hîãGÙQI 01!aÇmff¥›rOH é—'Oˆ9ûùI¥Þ“³‚Ô¬I–˜5È*%nEçÞKÜ­@üwa×q«yáí{¯x­ªJ¼¡n]Iw"ñŒÄ ÔÕËg¿  )ë4/^¢÷-­æœ¥Ž³¨©«“0MKÑ»¸‹‡† Aƒ(Z¸M›âÝïùsàôià̲¦!íV¯NtÍYÎ8Úä¬‚ß šš$œŒ¨_·kGÊWyP`‹Âë×4ýàÑÙóç4ƒQžadDgg’åÅAApçÍß¼Iòª0(Žsagq_gñíkO/$&wIH þÅMër{IßQέC|z”›VŸ&å~—çegÓ3„„·q®J¦¦À‚¤ÜžfÌÏ'áææF¾ü\°° znÝš¬(ººDãÅ@ ›Ïˆ»_p¿¹)qq?â¼<Oᦗ¹©ñ:uDç^ô=ý¿ËŒÑLNx8)0>ˆÜr>}јx|ç/î§,>Ý^x_Ø­ƒë«œ?½º:)"II´%'?}J÷€‘¡ eK`æLùÓן>‘qëÐ!âÁémÚÐÖ²%}Çš5Eç/Ê ’²²$é¥ð–’"¹çä™ø–—'j'nÓÒ¹YÔ­K|ÚؘE üúÀ¿ÿ’»¨ª* 8êÔ!¬!Ch¦gçN iÓrõÈ%Wh¿ÑÑ€ƒ¹<~LÌò￉ñàQ^—GJ­¯/)§·nó¬T‰|Œ&Nìí©î³gÀþýÀ±c"Úµi¶ [7² ýk<*ââÈúâéItn`@Óˆ¿üBǽ¼È ,:šñcþýIÑàÁC‘eù¯¿(x'*Šîk×ŠÜ SSÉr×.â©FFÄOý•êò(?ÈÌÆ'7iùÿññ…r8Püö -@Ìó—_hÔôò%™™yð(ÏÈΦWWšZˆki‘e‚ƒƒ%ÃvtäXwï’Âúæ Í %%Q俦&YgÇŽýö³<*6 (XhÙ2òƒ4ˆ¶Ù³ÉÒüÓOÀŠÄ3ÿ+Vôÿ"ÒÓÉG–Ù»wËí£~…ù1]ºÄ Š€òž=’åêêÀöíäÀ΃GEDJ ùŒsf*W¦iGKK¾mx”II¤´Iü/_þïºý×pç¹ÓõíKÁÓ¼B˃<Ê5>~¤ib€‚E¾4¹bíß/ò¹Ÿ ?NÊÆŽÀÍ›€‰ 0z4ТÕýçàäIš2ûùg`üxÙÏvÿ>]34”,`½zƒóSÞÁÑhYàý{¢uqwa/Qý6Ï™Ÿ¯ø^ܳ)+‹þ„…ñ´ð£"/8hÞ03bbèÕª@ä“WiiÀÅ‹$êÖÚ¶%«¢"¢Wwwò€à`àógr'kÚTš–óòȯ6$„dAëÖüwù/C ÑÊ·àãt¼¬x}y³g´¯VíËÞ½$²°¬äÑ÷üÖiiä¦Q8xŽq0€±I“KJb,:š±ùóóõeز…1ssÆ<`ìógÆV¬ zC‡JÖ[´ˆÊwì`léRÆ:vdÌÞž1eeÆ´´ûðA²~BcNNtß—/»z•1Æ*UbìÔ)ªsñ"cíÛÓuƳµe¬woÆêק2ÆÒÒÛ»—1SSº'Wï^&Æ~ù…±{÷ b¬Gª;v,ãQ‘šJ´Õº5cÖÖŒ2Ö¿?cÏž‰êìÝËØàÁŒuïÎد¿ŠÊÃÃ>œÊ»wgìß©üúuÆêÔщ£#çèÅÏOTÎcGÒý«WglØ0Æ23¥Ÿ³ €1OOÆFŒ š21¡çô󓬗›ËØéÓtmGGÆ22ˆö´µûýwªËØòåŒ5hÀØÙ³Tǘè™ÍÌè™Û¿ŸîɽçĉŒ½z%ºç£Gô\ܱ¼<ž®*>~$ÞU¯}ÿãÇ;rDDcµj_Ç;ŒÕ®ÍØÌ™Œ]»ÆظqTwð`¢YÆ»{—è‚ëC†Ðÿýûéøû÷TnbBòÂÎŽx:w_ooþûüpú4Éd++¢™¾}[¿ž±&Mèøë׌͙#â5§O‹Îusc¬gO*Ÿ0AúÚ™™ŒÍKò[[›±Æ[²„±œQW¯[°€èÐLJ俙Éõ£GëÕKÄã†'„Û7ŒMž,:öþ}ùjÛ èÙêÖ¥>Ó®è]rs©m.¤ã÷ï3vù2c-[2Ö¢c‘‘t·o3†±¶mI™˜ÿ—}Ï“'é[ŽIíݵ+c^^¤k]»ÆXT”ˆG B:'/ìì«\™ô©Û·©<;›±330 çœ;Wö}ÓÓ›5‹¾uD?+VHÊ/ˆ–´µ !™7r$ýoÙ’±sçDuýýIîsüÆƆÚmõj!aTQ\ ›šJ*´7o2¦¤ÄX@€¨,;›; RÄZ33j,sçR¹‹‹äKC„'Ž›7©®¶6c‰‰¢ûU®Lå#GŠ㌠Æ:w½à΢ëܸAåúú’×?{–:‹x'JK£Î 0váÏÔÊìí‰RSEÄ 0Ö°!};¡¡T^­š´¢ibBÇÎœ)É>ˆE¯_Óîâ íš5DwnnŒYZRùÒ¥Ò÷8î“œLe))Ô¡54Hñàðûï4@ëÒ…±yóˆQŒ5mJŠúÔ©4°D mn.=ã„ T¾y3ýÿô‰Žÿù§¨ÃËbæ®®Äe)ã<Ê?RRÈð`aAßxêTB·o3¶nõŽçee‰è²~}R‚9å•1Æ5’æߌ‰Œ/^H–s ­ŽÝóéS*?žäƒÿ}*2T·kGJ§€þú«h $ŽÁƒ©ÜÕU²üÔ)*oÑBÚxefÆØ$MŒrÐWIDAT{³³‰§dœbŒØ ˆž8cTß¾’¸ë×EÇoÜ~«Wi õî]ùFF2Ö­=ÿ‰ô?2’sñwß³‡Þ“OG’\iܘ±6mD}ÙÓ“Žÿô“ôýV®¤cœá'-äÇ#:vdìàAÆöí£A §wýõü¶l!À˜®.ñ€þýI ?Ÿ±ªUéØöíÒïijJ2/7—¾õСT·ªsÿ>Ñ›ø€¸[7Æ/f¬O*«^]D‹$ë8þt÷.ýOJú¿BË ìáÃé†þú‹±À@ÑccºHa>LÄÎiøâ í¶m’uÏ)£âʇ²2¸)RJ +—܇‹“¼öš5²­«)**Œåç‹Ê›5# …ø=##EnÜ8ž¹•'DEÑw±·—,çFkAA’J¥’’´B˘ˆyr -]]*OO—,çú‡¶6”9ÄĈ:¸8¶m£réçWS#åTÜbzé’HùæF¢aa¤°pppTh9ÌžMåH+Õ\‡—50ëÝ[ú£GÓ75Šø‡—/‰ß‰óàÜ\ƪTa¬S'Ék .ª%Qhuu¥ûŠŽãJÛ¶1¦®NV2q<.[¡]µJ¶BËñÇ í”)d½GNÝ ~È38:’ìÎÊ"ˆ£uŽþ׬‘~âå}ûÒóß¹#}¬m[:æà@ÖLîÝóóÉZ …T|«¢Bº”¸õóõk*72’m0=Z²üÃ*WW'WÜ÷°³“”OœÑ°sgÉúcÇÒ;Š##ƒ1UUª󦨼qc/ã጑B 0vèäu¸Êa9HXZ’ÔÑ£@` °q#EU÷ï/òMøðVý>\ÚŸaÄÚd¡°F:´•ùù‘ïÄ­[ÀÇ’õgΔvšÖÔ¤}a? ##‘Ÿ†8”•† W¯(1}íÚäA9F·l‘¬ß®mÆƼ¿TyBÆ”ö×_%ËÛ´!ÀssmÈóÃ)­ÿ—¥%г§è¿žÈ$$HúmÜH4gi)y¾¾>=ÿáÃyð •kiÑÞÌ èÓ‡~›˜Hž[ÒÈr%%J9Ö»7-tÒ»·èØ»wÔÏNžäiª¢ƒ ÐêÖMä[ ÍšýúQÜ“'T¦¦F>{âÁ&OŸÑÑô»¤‹vhiILÖ©Cý0>žx+Š…ÏŸ)Eà/¿¿‡¡aÉø©¬òøxZ˜côhé´T5kRúÁ‡)ŽEÜ·táBºžŠ Щ“èœ%KˆŸîÞ ÌŸ/ŠãÉϧëWä…8¹°p!éQªª¢woÓ†äàС’õ›6%=-.N”9áñcò{.,Z¶¤ý¥K¤qüƒ“5UªPl”8¬¬(­W/ÉþÍÉݘɸ”ƒ)¯náo]£É͇Éï^ü[Ï›'xÚªpá‚äµå@U¨ð]¹Bé"BCIh[YGŽMšPÍðpQÀ—€c€¢²ˆÚO™R¼€yHYY±€Wv_½¢½­- ~å**È9_¹BA„QYnî·¦:u(€1-:dp0u<}}ÙÑà:~üXTV¹²ä@M¸:%A¯^Ä´nÞ¤6êÐÊ÷í£ii®É£â CRh9^Ç)%ùù”êíøqR| )0¶,À)Ë))|ûWD©©²S–E Ø‹¤\éèHGöïÜ)ø—76i œ8A²`Ü8*?žŒœ‘«"BÑ»ëèP ;@‹YyygÎ"[XOÓÓ£}á\åœ.”Ÿ/©;)’ HžË¡vmÚ§¦ŠÊÂÃIN7h ý­÷î•$ÉûÆœâ\ ž"z‹víÈ:;o>$þömÑèž#Ȳ½ý5®-Á·¿'²ÁÎ$¬££ihoÿýž¥R%IešË‰—“#»>Ǭ?|l)Bi"|•”€Å‹é÷êÕ"ºß·˜4‰§£ÿ:8¥D[[Töö-`aAÂïÈ`Ãɘ_ŠÂ† œ<”uÿ¥xóF¤dõí+{³°ÓPŠ‘Ytñb¢»õëEr}÷nZ¤"£(žŸ—GÆ8;;2žœ9#{ Ò¡e3ñõ•Tj9ÝnÀ€/—5Š¾µ¾¾üoÍYv}ë<]áý{2ÿjhÐti@YhSSE‚°Y3ÚQz–ÂHO'æXpV`y‰„ÃÂÈä\–àîù×_²MÙyy€›ÏàÊ ˆImØ@#Ò©SË_’wÎ¥æÓ'sG­Z´oÓæÛ<Ï ADë—.Qß½t‰¬¼;ÍÜ!œûJ\`mMS»'Nð‹ßð7súîÝ×¹>§(ûû˯SÒ™¶–-i6êõk¢ëׯIgàÜ·þ‹HO§w¾}›f*–Ÿ6UU•\/êÔ¡6¹}›fí\]é…].Ëó·.–Bûò%ùÏŠÈ¥K¤àrÓ¹õë“ÌžMK¶‰céRÉ‘UIFèÖÖ4ñè‘HWbÆŽ•tE(‹Ñݺ$Ôsrèúâ¦rX·ŽŸ’-o8v ص‹rsq¦ MMê0ùù²¯W˜†Ë¦¦Ä@ dOãr¾ãâ~`_**À‚ô{Íj?Þ:ûßCaþ`€®]iá¹ÇXYɾ†¬ ¿ÿðøï¡qcÚß»';'·,prR|…EqˆÏVq|ÛÓSä»-ŽçÏIÑ*)\\h¿v-ÍàSö9TËV­"¥tñb Ê2þˆÃÀ€rÿOšܽK¾ó[·’ž§ÈÕíKд)í÷î%£ia<{Væ«¡‰l¼›6Ijik“ïçwˆ4ù¿ÿh•nú7,LäÜ ˆe’“%ïÈùv$&ŠÊLLD‹,[F›7Ó²‹ä!î€Ì+Œˆ–hLO—~SY÷åóï¿Éb¶|9}d''²ÜŽÃ3¸ò„  Úú$Yþù³¤àåöººÄL¹AGOŸJÒ Îç•»>ç³Ã zY žS¢¹:5k#GŠ˜¶¬wPV¦é–Â×PäŸÎÝ»°ÒQø™³²¤¯3r$ù19Cï.~oÿ p ÚÅ•Ó£G)‚ãËœÛÙ³¢Á\p0ùrý!2Rä6Ã-ÊÀÍÈqõ¸dæ…û8}ÊâÁ<Ê?:v$žòü9àá!y,0Pö9\ðؽ{’åwïÒ^<^¦E ÚrrÈZ%)¿ÇŽ„‰ó½¢bw¬¬(&<œž{„ŠÑÞ\?,¬'%dÉÂÜ\Q¿ËÏÉAƨMíì(oÕ*`î\ sç’Éñg’7Ø?ÇÜœfö³²(È06Vt,#ƒüþYZG+|my÷äRœßpJÊÿV¸sG”†eùrÊ=»`å'{ýZ2U¾}¢ôÜÖ©“(™oV¥âR µmK¹ss{òD”ƒL]±cÇ(17—í·ß$¯Ëå*ãRÀ|üÈØ®]¢c3fPÄü|ÆnÝ¢ük\~Ä (WÛÛ·Œ¹»‹rºM™BéG8xxH¿‘¥MâQ¾pë}Ÿ5(åÔÍ›Œõë'Êã:q"¥iár¿rù{ô t''O26h(ÏkïÞD'\âîÝ©|Ö,Ê…Ç¥,ñö¦òV­¤Scq‰±ƒƒEåoßR.N%%JEÇáÓ'Æôô¤P_¿Nר__2?¨88ÚÞµK²|ÿ~Q?»~RÕˆ§¦ã°i“윹<*6&OñS//â¿ÙÙ´pBóæ”`žCV–(g¸Ž¥¿1‚±EiéÆŒ¥üٰʵ´(!»Ñ–»;•Wª$™Ò+6–R:” W-ó(ßpqÉÂß~#^»d åÈ–•¶+<œÒBUªÄØîÝ”ˆÎâ5€(%'·¨ —Ï 4rŽŽ”ÆKCƒ±iÓd§ŽÛ½»èçæøhŸ>§­[¶¤g^¹Rú˜•Ï©Ïaóf:Ö¤ É°¿þ¢ü±úúT¾v-É1Æ(­'7ûö¥>>s&}Ÿ ¤ÏâÒ­”bKÜ:‹K–''‹ÎOÙwù²è[W«Fùeœˆ_–ƒ5kR=ná†Â²kØ0Éò‰E ¿\¹ÂØÆÿÏCûî ü›7IÁsq¡$½òr ¾zE‚uŠʇ&θÒÓIA.¼eeQâîÂå…sÉÞ¿O/°zµt²äèhéó?&,랟>1!]Î%Ÿ½{é?.™ ŸGù@@9d54D ¤ß¼!E eQ<íÛ·¢@)5•:´š-~pë–¨þ;Ä`+Uåõtw§w h`ö÷ßt¾ø N·ýþ;õ›Gè·ø1ñDxTäç‹€xÏ¢ET.K¡eŒ¾7Ç£*W¦ßïÞÑÿƉïq‹¾pyK¹|ò)=³g“á‹12Œ!:^»6é%…¬Â00\È©¼âÊ2®pïW£/_¦Åœÿ×Þù³4 EQü&Š¤JKÝ\]DTtr,8¸¸ N®âR:‰ø%ÄOàà(*.‚³þ ÖA(µ‚­¥…Vu8\_’F±ú¢6½?(…¶–˜¤y/ïž{Ž;ñoeÅý{¾¿ÇM€ibßÍÏc,X[Ãߌc âãé·Xè|ÌΪíJ$ÔëssL¹»Ãöq€B?nrŠE$ÄqH—ÓWwßÄiHAãçtIµüþØÆÝjç/Y¶Ï£tï™&©jµºQ¯K;ªÐb”J(Y9sês9”Õ½’¯¯ðáŒF•EÈÙ4áñ¸ èñÑÝþ*”êz{¡A÷³òÒA>¯,UüØÝ…–‰ËÆB8XZ‚ìkkËíI)?¥P€”ptvl¶ ]êÀ@£Ü?uùžeáZz|L4=íß©nÛÊ3udD5Ì~—›È3}úÿÛ[h`:ÚlÖ-Ñ|~†%ëê*dx¥7³YÈ/ ³ Û†Œ¥PÀ±Ö5¾¾¼à‰Åˆˆ}h¡•ðû1xMÀÓ$šœt¿ö™×qw·ÞIg_´KAóÙd–ú÷TJÎA¾F4 ]j3Ÿg—¾–~¤Ó$BÃ*kju°¾Ž^œv™Ìù[îyM’ILø¸©?ilªÎç›Vi†Ž4L릳ó}2Käl !<”ËJ„¿½»ñ™Ù/aƒ³‚pì'\Ìý/Eݧ'rqË®Viû-./‰66ÜÍw^®¯áQû—~îºæ·rÄ!dÔj0.¯Vñ\,Ââ¥V.ÚÛV Žçç²?„`a7™reì|O‹©)LdãqlÛæfc"U»34ßñ¸E-,@z‰ üz 7ŠøRË ­ „ ËByÉ0p1ÛÛ N%ü ''(%Ö­RFŽ'‚ “£#¤ˆ¡/ayY_\òw™˜Àóà #å8yéé-i*…Š]2 ÛÆD©]]D‡‡ÈoT[f´$½LIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_images/mailto_uri.png000066400000000000000000000237541240331347200266130ustar00rootroot00000000000000‰PNG  IHDR„@³ÅsRGB®ÎébKGDÿÿÿ ½§“ pHYs × ×B(›xtIMEÚ {  IDATxÚíw\TÇúÿ?tC‘"@¬À‚ *bC-AQQc¬bŒŠh4¹5±ÆÄ£WÅ5±%ñ›ëU”h®ÆXÀNAT@ªH])Ëîóûc~g—u EˆçýzÍëì™™SvÚ3ó<3gtˆˆðpá¼÷Þ{8vì:uêTküóçÏ#++K~Þ±cGxyyáŸLdd$þýïãæÍ›~ï‹/"==##£W6âãã4h¬­­_šw»qã¶lÙ‚[·n¡cÇŽ˜ùä“&é0½6ÐKÂõë×iäÈ‘”––Vïk·lÙBáááuŽ¿`ÁúþûïéUãèÑ£4nܸ&}† åååÑ?úóÏ?_Šw)(( [[[JJJRòÏÈÈ víÚ‘T*%ÎóD'Nœà Ñ@^š‚——Ž;''§&–T*…T*}å„÷˜1cpèÐ!Þ‹yùâ‹/ðî»ïª¨Cáéé‰+W®ðDâ¼|*£ÂÂB”––*ù¡¼¼¼N7,**BZZÚ+ÙàÖ‡‡¢¸¸ø•x׬¬,<~ü¸A×fffª”‡ºðôéSdffþ­ê´†ªº>|Ø ksrr››[§¸QQQ˜2eŠÚ0$&&Öe4û÷ï7(?ŠD"AJJ Äbq¯)--Å“'O”üÊÊÊê•Æ?FQQÑßö?³³³ëœ—EII ÒÒÒ “Éê­&»ÿ>êcþ}ôè‘J›œ­z#FH$¢7ÒĉÉ‚ÌÍÍiùòåTQQA“&M" ²··§µkתf:tˆ‚‚‚¨M›6dnnNvvvdddDsæÌ¡’’Ó„„òññ!‘H$w·oßn2•Ñ AƒH$‘µµ5988(=W$Q·nÝ´ª hÊ”)Ô¢E j×®YZZ’³³3EFFÖé=óóóiúôé4`ÀŠŠŠÒ÷ĉäåå¥òŽ‚«ªªÒz½X,¦yóæ‘­­-9::’ 9::Òš5k¨ººZ«Ê(77—Ö¯_OdooO†††äå奢î $‘HD‘‘‘”˜˜H½zõ¢æÍ›“­­-µiÓ†Ö¯_ß$ÃÛªª*ZµjuïÞìííÉÞÞž|||hçεªŒ?~L“&M"KKKy^º¸¸ÐŽ;´>³´´”æÍ›GvvväèèHÔ²eK #±X¬ö™LF¦¦¦ôôéS¹_yy9­_¿ž‚‚‚¨eË–ZŸ›––Fòw´²²"Ú²e‹ÆrÖ£Gòôô$OOO “‡åä䯯¯¼-X°@åú¸¸8š={6‰D"211!'''ÒÕÕ%º~ýºJü©S§’H$¢U«VÑìÙ³ÉÌÌŒ,--éƒ> ©TJaaadnnN­ZµRz^zz:uïÞD"Íš5‹d2­\¹’:wîLöööÔªU+òöö¦¥K—jLÛçQ•””PXX˜R^ÚÙÙѼyóêü¼ú"“ÉhóæÍò|lß¾=YXXаaÃ(11‘ƯñÚC‡Q§NÈÜÜœœÉÜÜœFM™™™JñîÞ½+oWûí7òôô$[[[²²²¢èèhJKK#///²±±¡:ÐéÓ§å×"++‹Þÿ}ÒÓÓ£wÞy‡ÊËË)''‡Z·nMîîîBOŸ>¥œœrrr¢ŒŒ •]±b8p€’““I&“Éûwß}—F­ñJ¥RJMM¥¤¤$JJJ"‘HD—.]j2™™IIII4eÊZ¼x±ü¹‚»{÷.I$µ×&&&’££#-]ºTIÈÅÅÅQŸ>}hôèÑòÿ®‰/¿ü’rvv®µ±KNNVyǤ¤$200 ÊÊJ×æää««+½ÿþûôøñc¹ÿýû÷iÔ¨QäççGåååÂàÁƒiäÈ‘t÷î]y³mÛ6²µµ¥œœ•k²³³)<<œüýýÉÆƆ:D•••$•JéÌ™3raјH$  áÇӃäþ)))@Ë–-Ó(âããÉÁÁ–/_N¥¥¥rÿÛ·o“¿¿?;Vm^>zôˆœœœ(<<œòóó•àððpêСƒÚôê“À“'O¨C‡4eÊ:yò$?^£@8uê988ЦM›”ò<>>ž†J#GŽTû®W¯^%'''Z¶l(…%%%‘——͘1CéüòË/´qãFºté’\ˆåççÓÎ;ÉÚÚZ¥ÊËË£O?ý”ôôôhðàÁTZZJ………äááAîîîHÅÅÅTXXHžžžJBåÞ½{´cÇêÝ»7Qpp0¥§§+ ÷ß~›<<<”òêy‚`»Y°`RÉËË£°°0êرc£ÛÒ¤R)½ùæ›4bÄ%[©D"¡={öÐo¼AšÌº3gÎ$‘HD±±±òü.++£õëד½½=]¼xQI褦¦R§NÈÀÀ€"##I&“Qtt4YYY‘££#íÝ»—d29s†¼¼¼ˆhñâÅ4hÐ ¥^gxx8õïß_©üè£èË/¿¬—!ÍÜÜœŠŠŠê¿gÏžM*æÍ›Gß~ûm½z¢^^^´oß>RèС¡õ>QQQ¤££C(88¸ÁËÐÐP«@1b­^½Zcxhh¨R¯ñY0vìXµ‚qØ°aö5kÖ™™;wN%ì×_%OOÏF­\«V­¢ÀÀ@ù1`ÀÒÓÓS•••$‰èÇÔXi¬R>d2™Zÿš|ýõפ¶ñiß¾½ü|öìÙ4jÔ(¥su!//œ5Ö ©TJ´qãF .]ºÈGLÂÈqРA4oÞ¼Z;0ꦭ[·ªøoܸ‘¼¼¼¨¬¬L©äîî®ä÷õ×_«ÔÕS§Nš6mšÆçŽ;–-ZÔ(A&“Q@@€Ö‰%_~ù%;¶QËlDD„Ö{~ûí·jÂþýû©[·nTQQ¡öº3g΋‹‹Š6F$Ѻuë”ü:vìHkÖ¬Qòëܹ3ÅÅÅ)•``` W%YZZ¢oß¾Ð××—û™™™ÕK—Ø¢E ´jÕ ………¯´½à矆ƒƒ&Mš¤6\GG»víªU«´ê‡ ‚»wï"::l’w½té233±xñbq6lØ€C‡!//OmøæÍ›•ò]`Ô¨Qˆ‰‰Ñxßùóç£oß¾*þˆGuuu£ýÏ£GbË–-ócÛ¶mjíXGŽA»víðÎ;ï¨7ªéêb÷îÝX±b…R^^»v ÙÙÙ˜7ožÆwú補œŒ¸¸¸ZóhÁ‚µþÇ={ö`øðáèÙ³§Æwݺu+V¯^­Ñ6ñÇàûï¿ÇæÍ›QRR‚!C†À××ß~û-tttêîîîî(((PæïïSSS¥6¤gÏžJ~šÚ|÷ÝwŸ»yóf?~¼QÊNLL 0gÎq>þøcÄÅÅÕɶSŸ‰ß|óÆð°°0µåbéҥػw¯ÆµAèß¿?víÚ¥6tèP¥s 8Pɯfžè7ÆMOOÇ_|+W® ##ÕÕÕ°¶¶†‹‹‹Òâ±W•k×®aÀ€Zã´jÕ ŽŽŽ¸sçºté¢1^ûöíѾ}û&}×~ýúAWWó2SSSøøøàúõë*FhPÕ¡¯¯¯Uàéééil¸tttêe«Í˜[UU{{{q\]]Õ.NªK^:88ÀÎÎ)))èر# 66FFFø׿þ¥õÚfÍš!11îîîãØÛÛãܹsèÓ§Ö{ÅÆÆB*•ÖúL"B^^lmmUÂlmmqöìY :ëׯÇÌ™3µv ²²‘‘‘8tè222PXX333´mÛ%%%…éóеkW˜™™i ·µµ…D"AFFZ·ný\ÏŠ…¡¡a­éjjjŠÄÄD­õ¹®K~~>¼½½ëœ—‚@Éd011Öë&MšWWW•Þ¯D"‘Ÿ¯X±C† AJJ FŒ””µÓ­e2,,,j}æ’%K´†WUU¡¼¼µÎŒ+..Fß¾}Ѻuk|þùçèÒ¥ lll ‹‘žžŽµk×6IžÖecEEEƒF5êÒµ.y9yòd¸¸¸4ÊÿËÊʪS½TW^ë²Ò¾±êós "„ ðÕW_!$$DE¢ÛÚÚj•ú¯ žžžòO!h#>>/ü]ë²V!..óçÏ%óÃËË ZãH$$''«ø‹D¢:åeBB‚R^zzzbûöí¯÷ûÚØØ ??2™ ºººèÖ­bbb°mÛ69r†††òφ<›— z¦@ff&Œ `âĉ DXX¾ûî;µë²eË`cc£¢ž±°°€……ºvíÚ$yz÷î]¤§§£M›6Ã+++áèèØ(udï޽ϕ®õ¥sçÎ R?¹ººâÑ£G¨¬¬Ôú9™¸¸8xzz>÷{>×´‡BWWÓ¦MÓØ[}ízzzJß>©aÆáÀÈÎÎÖgÇŽpssƒ¥¥¥Æ8ÕÕÕ8pàV¯^G5ÉëÛ·/.\¸ µÑ;uêÄbq“Uî†òôéSlݺ*óØŸU]yzzªÕ™ lÚ´ UUU*þÇǾ}û““£ñÚmÛ¶ÁËËK©3ããã‰D‚ÿþ÷¿õ¯dºº°³³CZZšÜÏÉÉ ë֭Ñ#GðŸÿüG­þ<88G­Uøi"--  À’%K SSSü÷¿ÿEZZBCCÕªÿ®^½ªQ•"“É’’Ò$y¯££ƒ3f¨µ3UUU!$$Ÿþy£<Ë××OŸ>m˵k×°dÉœ?^kL:Umù:»sæÌÁÏ?ÿ¬ñ>EEEèÛ·/¾øâ 0@c ìܹ ,À… Ô†ïÛ·"‘He´¸iÓ&lß¾{öìQ+@&NœˆQ£FÁÏÏïùUFÓ¦Mßþ ===<|øP©Ð8pYYYؾ}»Z?lݺ#GŽÄÀáïïÔÔT\¾|ÅÅÅ8|ø0fÎœ‰©S§ÂÊÊ @³fÍ0#Ëܹs•t«III˜?>ÌÍÍå~o¾ù¦Šå}öìÙJR4##b±X©lÞ¼9~úé'¥™Sï¾û."##áãメC‡¢mÛ¶xðà®]»†„„,\¸Påš… BOO¾¾¾=z4ÜÝÝQXXˆ .àþýûøí·ßjýìFÍ«ºÞkc1nÜ8TUUaàÀ1b<==QYY‰˜˜\¾|;w¯¯Ò5Û·oÇÏ?ÿŒââbŒ?þþþX¹r¥¼çþî»ï"55………1bV¯^-WÝÌž=wîÜ!&&›6mBÛ¶m°¯Ò®[·ÕÕÕxûí·±hÑ"•Y I‘H„}ûö!88ƒ BÏž=!“Éð×_!%%ÑÑÑ?~<>úè#ØÙÙaË–-r#ô¢E‹ §§‡îÝ»c̘1pssCaa!þüóO<|øÇ—¿Mºuë†ß~û ¡¡¡hÓ¦ üüüЪU+¤¦¦"..—.]ÂüùóñÖ[o©\;wî\øøø`ôèÑ*777666j'Ì;fffèÓ§† www˜˜˜ )) 111ÈÍÍÅš5k”ÊÞ† °víZèëëc×®]HMM•ÛŠŠŠ0mÚ4ˆÅbœ={IIIØ¿¿ÜpºzõjôéÓ·oßÆ°aÃP]]+W®àêÕ«GïÞ½±gÏ\¸p‹-€ðÑGáäÉ“‹ÅÈÍÍÅÁƒåꨓ'Obܸq8xð üÿ©óÓÕÕźuëàííÈÈH„„„ ººX¹r%‚‚‚Ôj BCC•Fû7nÜ@zzºÒˆ«W¯^øì³Ï”®õññÁ±cÇŠvíÚÁÏÏvvvJy¹`Á >\ëˆ_˜ÉFDJm™&UÕîÝ»1yòdtëÖ =zô€¹¹9péÒ%À?ü 2éÁÚÚÑÑј2e 8€þýûÃÖÖ 8zô(f̘eË–Éãß¿aaaHKKÇ~ˆ̘1CŽiÓ¦aæÌ™*~:·nÝ"axnmm-·f?|ø÷ï߇•••Ü ªÎRRRpôèQdffÂÙÙ"‘ýû÷‡¾¾>bcc!‹abb¢ÔI$ÄÄÄÔšˆÎÎÎ*zÅÄÄÄZ (Í›7‡Æp©TŠ£GâÚµk¨¬¬DÇŽѹsgøùùiÕÕ¥¥¥áìÙ³ˆ‡……ÜÝÝñÖ[oÕésÑ•••Ø»w/ºwï®ôŸŸ>}Šýû÷#11Í›7‡H$Bß¾}ѲeKy «« OOO˜™™áÎ;rœ™™ºuë&/ÉÉÉxã7ä†|u~§OŸFDDN:U¯z “ÉpåÊ•ZÕ¿­[·Öh®ªª’çeff&\]]áææå´&Bþ 4H«ð¨IYYNœ8øøxÁÅÅ>>>èÝ»·Öë¤R)Nœ8[·n!//]ºtA¿~ýйsg•ò)´­:::puu•w†®_¿Ž’’tèÐA­ŸÎ˲§nܸq£FÂÇyb¼‚ÄÇÇcÿþýˆ‹‹CóæÍáéé‰3f¨2úºÐPÀi|ôy¼Zlß¾ýû÷ç ñŠâææ†uëÖñ„àpÀ©;ÅÅŸyó¦|1WYY¢££qþüùÍtáp^6•ÏíÛ·ñäɹ·}ûö2½”S¸Êè%åøñ㈈ˆ  ôèÑ|ðÖ©­ΫBVV¦OŸ®b>|8>þøcž@\ p8çE¡Ë“€Ãáp8\ p8‡ ‡Ãá(£~–Qy9PUÔaaG UUÀÓ§€™ [O™[QÁœ’ØÖe÷âp8œÆ ²’µó5ÑÑÑ0BˆŠ,,€Í›yÂÕ—òr wo@$ÔlÐR+b1ðÉ'€•`iÉœ¹9àï:Ô²²›Ãáp4rý:ðÞ{@‹ŠöÅÒè߈×0ËH&zônÞdÂA÷g8jÒmüxàèQ`Ï`êÔ†ß+&ˆˆNœÊÊþ––ÀàÁÀСìÈçks8M”–çϳvüÔ) æ×juuž=Y;5c §§eÚin.ë•>x|ø!ðùç¬1â¨çÜ9`þ|àÆ ÖÃo¬Õ¨••@t4ðË/L8äæ*‡ÛÙ^^@·nlTÒ¾=àâÂULÎëDEpÿ>pïÏÚ¡›7™¨ÙÄ›˜}ûAA@` k?j }Ba!“¿þʆï¼Ãz¥Ô­Á).òò˜ËÍeÇ’¦_úÐÓlmÎÁèÜh„]‘ä”” Š÷ÈËcÿËȈ%Ž‰ SÏØÚ-[²£ Pˇãwî°Æúøqàôi ysàûï ûC4 éé@l,põ*;^»©Æ³¶œ6mX¦×tVVL%hnÎœ‰É‹/ÐUUÌI$ìXY©|¬‹ŸDÂÔt‚“É´Ÿëê²2¨ÎéëÆÆ,mš5S=šš*Ò¯yóÆ-³ÿ¤Fª¨ˆ¹²2VçËË™«ù»¼\5ï¤R ºZ‘oêòêY?áÜÀ€Õ_##v¬ù»6¿šîEçiUkC‹‹Y99 — X²„5À'D¬g’¤¦²Bj*s÷﫨Õa`¼ñ†â6k¦øm` ¾âÉd 'TZuçÕÕŠÆ[“{Õí"‚Ñ_BÙ::66Ê¿ííY9•¨ªRtêž= Nhü‹ŠX#VM¨^JôõÂA2ϺšõCWWájž ¿‰T…žTÊêhy¹âX^Îh]ê®®.ksÍ@ûö סCÝ:¶õ¿ÿüø#1¨ë•6žžÀœ9LÏ¥mC—{÷˜ü‡€¿kS`Â`òä—S—Odf2Á­ÙiÙŒÓD˜š²Š,¸¶m»K—¿†ŸX $'³²’ždd0'üÎÉQíršÖñœ½½òyÛ¶@»võnôO Ôì-ÄÄ./wï2[Cm=ccEO©¦ Cè…7kÆ$fn.+€‰‰À°d—.À¿ÿ ô맪Z¾œ…I$,¡c«ë‰UU)F/½ss® €õfµaeÅT0̶ҧ“Èÿ*+#MîÉÖ ‹C~Á çj¶?ü[{rÚÔ5‚ÓvnhÈî«©·WÓOJª¢‚¥‰X¬8––²t,(P¸’õ ­½=+ó‚óòb£ç­ü%%l¦IBSy&'³cf¦ú÷06fe¿¦³°`•©©âجK¯gG’€òˆ±f:Õ<>«þÓöûYÕ¡:¢à^„ÓÑQ¨WóÜÜ\y†:gmýB¦ý7Þ·Œd2Ö¨”•±Â_U¥¨`ÆƬanˆ¡³¸˜éè¿ù†IV®>ý”…]½Êfõ<|„†²žz¯^õ×ýI¥L TZª(pR©¢À7ôÝ_7$ÖøUT(ô¿êtÂ5ŽŽòP»6g` ªóÕ}…×WVUYYLœ™É\z:S¦¤°Ž– hŒØä^½ØìÖÒV®¯_g·ØXvLNVîüØÚ®®ldâäÄ:R5Ý«¾I"QϪ8ksBàY÷¬ì’ÆƯlr½:·“J¥KY³˜•|Èf„ŽŒd=(çŸ(dÓÒXc~ù2pépëk¨ttX¹ë-`Äf4|ò„M1ûLý§ÝyÝã¼tÁÀ€ç‡ÓT¬_üô¯{œ&W¯²ON¿ù&àíÍöXîÓG5^UðùçÀðáìóÔ"+œÚ¶JÌÍeû´nÍ®‹UïÚ5`ìX¶GhëÖÀ¨Ql³šüñ3œ ÂÎÿ÷?¶%§½=ÂöOØ^ ³g³ïÁ{{{÷ª(óª`IDATf~>ðÁ춶l‹ÏcÇxéánû²é³ÄÆ£G³½Í;t`õåûïá••l_ï?fçÿù«&¨ßĪ¤„•ïvíسÿçËë Õ•Œ "KK¢7ØyI ч™š*ÇËÎ&òô$Z±‚H&#’J‰BC‰¢•+•ãzx0ÿS§ˆ†'Z¼˜hôhæסQE…rü]»ˆz÷&ºx‘Ÿ=KdbBdhHÃüÖ¬QÜ×ߟhÓ&¢à`¢µk‰œœ˜ÿ°aDééDC†Í›G4f ‘Ž‘¾>Ñ¥KÊϼqƒÈÍèða"‰„èáC¢.]Ø}¾ù†8œóÕWD;²²äçGtèQË–D®®Ì`çùùŠk.^dåý“OØyi)ÑÛo³¸[·2?‰„()‰Õ7€($„'%±:ID4t( ;r„häH¢… ‰¦Ne~¶¶DOžðüy ©»@ˆˆ 23#ª¬Tø=yBÔª•r¼à`"__e¿›7YAkÖŒ¨¬LU „„•—+üûöU ¬,¢æÍ™¨ÉgŸ)Ó§•éØ1…e% ÑäÉÊ…~õjæ?ožÂO&cÿeÉågž?Ïâ6oNTPÀK§áœ;ÇÊ’+{ÕÕ¬uð «oÑìÙŠøÓ¦1¿ßWøíÜÉüÆS¾wd$ó_´Hõ¹‚@9’¨°Pá?aóß½›çÍkˆn=†lh9gÛ&`{~ñ…²JéȦҩ‰H>Ìv<35Uoøª¹íœ››BU#°aÓ{3uà„5 —.±­ņ9®®ÀÈ‘Š{²}i¶§‚¥¥"LØq--Máwú4Û©ÊÎNù™÷î±ð²2ͪ-§.´hÁŽ­Zß~«Ø‹xüx`þ|¶g"~` 0t(àë«ðóöfdž¬)ø׿ØÉîîªuÃm*±uûvÖ`ïÙÃ6è˜:UY @›6ª×ï½W·gÙØ°ããÇ ¿[·Øþ®ÊÎ×—ÎöïWì=«m…°í³3/„)°……ÊÏîWó™ÆÆì™?ýÄö¢åp\ÿlÖL5,4”Åb ;[QOždSGóóÙ8aa ÛÝóbm­Z÷8¯ úuŽéìÌzÓ&±ÕŽÓ§³ïb†c¸{—Ÿ÷S‚µš°»wYŘ0¡öëut'u„ÿãë«è9q8ööLP”—³ŽŠÐ™ÉÌd{‹‹±ÎVÇŽóLuuÃGjñð`£€åËYÁ‰‹c³}„ž´°úñÙY?5ièg*„‘¦a±0:hL„ ÈoÞÔ§)žËá++v’%&½z±žü/¿~~<8/@ üßÿ15‹¡!°bÏ æÓ§ÀîÝ,N‡ì¸oÓ¯?Ë áQ_„{¯X¡>|öl ´´qSGèu­YH¥ªáû÷3;‡ó¼¨ëXTW99@Û¶ •Ò˜1À“'ÀÊ•ª#au Ð8œ&W¯gÎ(ÎÛ·gFbÈÈ`Ç7ßdúÿ¢"`Æ åBž|õл·ÂOhdŸÝÖY8¯YÀƒƒÙqçNf|«É/¿°¯7 =zá:uDݽ5UªáÃYELNfk$ÊËa«VòRÄy~ÔœcbXZ¸‹Å¬,J$Êe±¸˜?¡Þ B$7Wá/ÄÑTG„ú¡®ÄáA‰°0  @q.¬v bGss`íZöûða6»hölÀߟ©›¾úJaD†²gmÂ3rr~ãdz…8R)›}Ñ¥ 3hwí L™ÂìÏÞWaL0?&Œhjþ¿6m€O?e¿ú‰ÙQ„÷pqa£þ>NcœÌTÖì˜|þ9›AôÁÌÏÔè× „÷ß._f£•+Yxz:µnßÎÎ]\ØñìYàÄ V^a!¨^a¢­îq^ê`‹ynÜ š9“-@ˆÚ·gÿA&#Ú°->®yï=¶ˆGàûïÙÿÂMMÙÜoçyIH`eª];¢^½Ø:ƒ ˆˆ•×9£XÙ¬Ñwß±2ìæF¤§G4k–bñ™DÂ°5 ¬| eÙÍhýz¶ÀmÕ*"{{æolÌ¿ñj¯:DÏêk4ðä ›3]RÂz3b1ëõ 󨟥ªŠcuuÙ ÆìI?yܾÍÔS:±¹ÛMME{¦LÆþ7ÿ8§1HLd£\??6BHLd½t77 eKÍ×¥¤0Û‚¡!;¯¬d#mu×dg³µ45ûŽó¥îÃá4­@øë/žœ ßS™Ãy‘h›ÁápÀá¼FFÜ'OxZp¸@àp^K¤R`Û6Å,¶”¶êøÒ%ž6œÆÿ¢ÔC—;Ú IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/000077500000000000000000000000001240331347200241445ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/contents.txt000066400000000000000000000003311240331347200265370ustar00rootroot00000000000000.. _contents: Contents -------- .. toctree:: :maxdepth: 4 index.rst whats_new.rst getting_started.rst examples.rst in_depth.rst techniques.rst history.rst reference.rst references.rst cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples.txt000066400000000000000000000014421240331347200265240ustar00rootroot00000000000000.. _examples: 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. All examples are built using CMake. 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: 1 examples/http/http_client examples/http/simple_wget examples/http/hello_world_server examples/http/hello_world_client examples/http/atom_reader examples/http/twitter_search cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/000077500000000000000000000000001240331347200257625ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/http/000077500000000000000000000000001240331347200267415ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/http/atom_reader.txt000066400000000000000000000041671240331347200317740ustar00rootroot00000000000000.. _atom_reader: ****************** Atom feed reader ****************** The next examples show some simple, more practical applications using the HTTP client. The first one reads a simple Atom_ feed and prints the titles of each entry to the console. .. _Atom: http://en.wikipedia.org/wiki/Atom_(standard) The code ======== .. code-block:: c++ #include "atom.hpp" #include #include #include int main(int argc, char * argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); atom::feed feed(response); std::cout << "Feed: " << feed.title() << " (" << feed.subtitle() << ")" << std::endl; BOOST_FOREACH(const atom::entry &entry, feed) { std::cout << entry.title() << " (" << entry.published() << ")" << std::endl; } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; } Building and running ``atom_reader`` ==================================== .. code-block:: bash $ cd ~/cpp-netlib-build $ make atom_reader And to run the example from the command line to access the feed that lists of all the commits on cpp-netlib's master branch: .. code-block:: bash $ ./example/atom_reader https://github.com/cpp-netlib/cpp-netlib/commits/master.atom Diving into the code ==================== Most of this will now be familiar. The response is passed to the constructor to the ``atom::feed`` class, which parses the resultant XML. To keep this example as simple as possible, `rapidxml`_, a header-only XML parser library, was used to parse the response. .. _`rapidxml`: http://rapidxml.sourceforge.net/ A similar example using RSS feeds exists in ``libs/network/example/rss``. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/http/hello_world_client.txt000066400000000000000000000053241240331347200333560ustar00rootroot00000000000000.. _hello_world_http_client: *************************** "Hello world" HTTP client *************************** Since we have a "Hello World" HTTP server, let's then create an HTTP client to access that server. This client will be similar to the HTTP client we made earlier in the documentation. The code ======== We want to create a simple HTTP client that just makes a request to the HTTP server that we created earlier. This really simple client will look like this: .. code-block:: c++ #include #include #include #include namespace http = boost::network::http; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { http::client client; std::ostringstream url; url << "http://" << argv[1] << ":" << argv[2] << "/"; http::client::request request(url.str()); http::client::response response = client.get(request); std::cout << body(response) << std::endl; } catch (std::exception & e) { std::cerr << e.what() << std::endl; return 1; } return 0; } Building and running the client =============================== Just like with the HTTP Server and HTTP client example before, we can build this example by doing the following on the shell: .. code-block:: bash $ cd ~/cpp-netlib-build $ make hello_world_client This example can be run from the command line as follows: .. code-block:: bash $ ./example/hello_world_client http://127.0.0.1:8000 .. note:: This assumes that you have the ``hello_world_server`` running on localhost port 8000. Diving into the code ==================== All this example shows is how easy it is to write an HTTP client that connects to an HTTP server, and gets the body of the response. The relevant lines are: .. code-block:: c++ http::client client; http::client::request request(url.str()); http::client::response response = client.get(request); std::cout << body(response) << std::endl; You can then imagine using this in an XML-RPC client, where you can craft the XML-RPC request as payload which you can pass as the body to a request, then perform the request via HTTP: .. code-block:: c++ http::client client; http::client::request request("http://my.webservice.com/"); http::client::response = client.post(request, some_xml_string, "application/xml"); std::data = body(response); The next set of examples show some more practical applications using the :mod:`cpp-netlib` HTTP client. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/http/hello_world_server.txt000066400000000000000000000103251240331347200334030ustar00rootroot00000000000000.. _hello_world_http_server: *************************** "Hello world" HTTP server *************************** Now that we've seen how we can deal with request and response objects from the client side, we'll see how we can then use the same abstractions on the server side. In this example we're going to create a simple HTTP Server in C++ using :mod:`cpp-netlib`. The code ======== The :mod:`cpp-netlib` provides the framework to develop embedded HTTP servers. For this example, the server is configured to return a simple response to any HTTP request. .. code-block:: c++ #include #include #include namespace http = boost::network::http; struct hello_world; typedef http::server server; struct hello_world { void operator() (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } }; int main(int argc, char * argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { hello_world handler; server server_(argv[1], argv[2], handler); server_.run(); } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } This is about a straightforward as server programming will get in C++. Building and running the server =============================== Just like with the HTTP client, we can build this example by doing the following on the shell: .. code-block:: bash $ cd ~/cpp-netlib-build $ make hello_world_server The first two arguments to the ``server`` constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously. This example can be run from a command line as follows: .. code-block:: bash $ ./example/hello_world_server 0.0.0.0 8000 .. note:: If you're going to run the server on port 80, you may have to run it as an administrator. Diving into the code ==================== Let's take a look at the code listing above in greater detail. .. code-block:: c++ #include This header contains all the code needed to develop an HTTP server with :mod:`cpp-netlib`. .. code-block:: c++ struct hello_world; typedef http::server server; struct hello_world { void operator () (server::request const &request, server::response &response) { std::string ip = source(request); response = server::response::stock_reply( server::response::ok, std::string("Hello, ") + ip + "!"); } }; ``hello_world`` is a functor class which handles HTTP requests. All the operator does here is return an HTTP response with HTTP code 200 and the body ``"Hello, !"``. The ```` in this case would be the IP address of the client that made the request. There are a number of pre-defined stock replies differentiated by status code with configurable bodies. All the supported enumeration values for the response status codes can be found in ``boost/network/protocol/http/impl/response.ipp``. .. code-block:: c++ hello_world handler; server server_(argv[1], argv[2], handler); server_.run(); The first two arguments to the ``server`` constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously. .. note:: In this example, the server is specifically made to be single-threaded. In a multi-threaded server, you would invoke the ``hello_world::run`` member method in a set of threads. In a multi-threaded environment you would also make sure that the handler does all the necessary synchronization for shared resources across threads. The handler is passed by reference to the server constructor and you should ensure that any calls to the ``operator()`` overload are thread-safe. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/http/http_client.txt000066400000000000000000000066251240331347200320300ustar00rootroot00000000000000.. _http_client: ************* HTTP client ************* The first code example is the simplest thing you can do with the :mod:`cpp-netlib`. The application is a simple HTTP client, which can be found in the subdirectory ``libs/network/example/http_client.cpp``. All this example doing is creating and sending an HTTP request to a server and printing the response body. The code ======== Without further ado, the code to do this is as follows: .. code-block:: c++ #include #include int main(int argc, char *argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " [url]" << std::endl; return 1; } http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); std::cout << body(response) << std::endl; return 0; } Running the example =================== You can then run this to get the Boost_ website: .. code-block:: bash $ cd ~/cpp-netlib-build $ make http_client $ ./example/http_client http://www.boost.org/ .. _Boost: http://www.boost.org/ .. note:: The instructions for all these examples assume that :mod:`cpp-netlib` is build outside the source tree, according to `CMake conventions`_. For the sake of consistency we assume that this is in the ``~/cpp-netlib-build`` directory. .. _`CMake conventions`: http://www.cmake.org/Wiki/CMake_FAQ#What_is_an_.22out-of-source.22_build.3F Diving into the code ==================== Since this is the first example, each line will be presented and explained in detail. .. code-block:: c++ #include All the code needed for the HTTP client resides in this header. .. code-block:: c++ http::client client; First we create a ``client`` object. The ``client`` abstracts all the connection and protocol logic. The default HTTP client is version 1.1, as specified in `RFC 2616`_. .. code-block:: c++ http::client::request request(argv[1]); Next, we create a ``request`` object, with a URI string passed as a constructor argument. .. code-block:: c++ request << header("Connection", "close"); :mod:`cpp-netlib` makes use of stream syntax and *directives* to allow developers to build complex message structures with greater flexibility and clarity. Here, we add the HTTP header "Connection: close" to the request in order to signal that the connection will be closed after the request has completed. .. code-block:: c++ http::client::response response = client.get(request); Once we've built the request, we then make an HTTP GET request throught the ``http::client`` from which an ``http::response`` is returned. ``http::client`` supports all common HTTP methods: GET, POST, HEAD, DELETE. .. code-block:: c++ std::cout << body(response) << std::endl; Finally, though we don't do any error checking, the response body is printed to the console using the ``body`` directive. That's all there is to the HTTP client. In fact, it's possible to compress this to a single line: .. code-block:: c++ std::cout << body(http::client().get(http::request("http://www.boost.org/"))); The next example will introduce the ``uri`` class. .. _`RFC 2616`: http://www.w3.org/Protocols/rfc2616/rfc2616.html cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/http/simple_wget.txt000066400000000000000000000060541240331347200320260ustar00rootroot00000000000000.. _simple_wget: *************** Simple `wget` *************** This example is a very simple implementation of a ``wget`` style clone. It's very similar to the previous example, but introduces the ``uri`` class. The code ======== .. code-block:: c++ #include #include #include #include #include namespace http = boost::network::http; namespace uri = boost::network::uri; namespace { std::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; } } // namespace int main(int argc, char *argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " url" << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); http::client::response response = client.get(request); std::string filename = get_filename(request.uri()); std::cout << "Saving to: " << filename << std::endl; std::ofstream ofs(filename.c_str()); ofs << static_cast(body(response)) << std::endl; } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } Running the example =================== You can then run this to copy the Boost_ website: .. code-block:: bash $ cd ~/cpp-netlib-build $ make simple_wget $ ./example/simple_wget http://www.boost.org/ $ cat index.html .. _Boost: http://www.boost.org/ Diving into the code ==================== As with ``wget``, this example simply makes an HTTP request to the specified resource, and saves it on the filesystem. If the file name is not specified, it names the resultant file as ``index.html``. The new thing to note here is use of the ``uri`` class. The ``uri`` takes a string as a constructor argument and parses it. The ``uri`` parser is fully-compliant with `RFC 3986`_. The URI is provided in the following header: .. _`RFC 3986`: http://www.ietf.org/rfc/rfc3986.txt .. code-block:: c++ #include Most of the rest of the code is familiar from the previous example. To retrieve the URI resource's file name, the following function is provided: .. code-block:: c++ std::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty()? "index.html" : filename; } The ``uri`` interface provides access to its different components: ``scheme``, ``user_info``, ``host``, ``port``, ``path``, ``query`` and ``fragment``. The code above takes the URI path to determine the resource name. Next we'll develop a simple client/server application using ``http::server`` and ``http::client``. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/examples/http/twitter_search.txt000066400000000000000000000066061240331347200325410ustar00rootroot00000000000000.. _twitter_search: **************** Twitter search **************** This example uses `Twitter's search API`_ to list recent tweets given a user query. New features introduced here include the URI builder and ``uri::encoded`` function. .. _`Twitter's search API`: https://dev.twitter.com/docs/using-search The code ======== .. code-block:: c++ #include #include "rapidjson/rapidjson.h" #include "rapidjson/document.h" #include int main(int argc, char *argv[]) { using namespace boost::network; using namespace rapidjson; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; uri::uri base_uri("http://search.twitter.com/search.json"); std::cout << "Searching Twitter for query: " << argv[1] << std::endl; uri::uri search; search << base_uri << uri::query("q", uri::encoded(argv[1])); http::client::request request(search); http::client::response response = client.get(request); Document d; if (!d.Parse<0>(response.body().c_str()).HasParseError()) { const Value &results = d["results"]; for (SizeType i = 0; i < results.Size(); ++i) { const Value &user = results[i]["from_user_name"]; const Value &text = results[i]["text"]; std::cout << "From: " << user.GetString() << std::endl << " " << text.GetString() << std::endl << std::endl; } } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; } .. note:: To parse the results of these queries, this example uses `rapidjson`_, a header-only library that is released under the `MIT License`_. .. _`rapidjson`: http://code.google.com/p/rapidjson/ .. _`MIT License`: http://www.opensource.org/licenses/mit-license.php Building and running ``twitter_search`` ======================================= .. code-block:: bash $ cd ~/cpp-netlib-build $ make twitter_search Twitter provides a powerful set of operators to modify the behaviour of search queries. Some examples are provided below: .. code-block:: bash $ ./example/twitter_search "Lady Gaga" Returns any results that contain the exact phrase "Lady Gaga". .. code-block:: bash $ ./example/twitter_search "#olympics" Returns any results with the #olympics hash tag. .. code-block:: bash $ ./example/twitter_search "flight :(" Returns any results that contain "flight" and have a negative attitude. More examples can be found on `Twitter's search API`_ page. Diving into the code ==================== .. code-block:: c++ uri::uri base_uri("http://search.twitter.com/search.json"); std::cout << "Searching Twitter for query: " << argv[1] << std::endl; uri::uri search; search << base_uri << uri::query("q", uri::encoded(argv[1])); The :mod:`cpp-netlib` URI builder uses a stream-like syntax to allow developers to construct more complex URIs. The example above re-uses the same base URI and allows the command line argument to be used as part of the URI query. The builder also supports percent encoding using the ``encoded`` directive. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/getting_started.txt000066400000000000000000000235521240331347200301030ustar00rootroot00000000000000.. _getting_started: ***************** Getting Started ***************** Downloading an official release =============================== You can find links to the latest official release from the project's official website: http://cpp-netlib.org/ All previous 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/cpp-netlib/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:: Previous versions of :mod:`cpp-netlib` referred to the *mikhailberis* repository as the main development repository. This account is still valid, but not always up-to-date. In the interest of consistency, the main repository has been changed to *cpp-netlib*. 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/cpp-netlib/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.50.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 .. warning:: There is a known incompatibility between :mod:`cpp-netlib` and Boost 1.46.1 on some compilers. It is not recommended to use :mod:`cpp-netlib` with Boost 1.46.1. Some have reported though that Boost 1.47.0 and :mod:`cpp-netlib` work together better. 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 :mod:`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:: $ mkdir ~/cpp-netlib-build $ cd ~/cpp-netlib-build $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=gcc \ > -DCMAKE_CXX_COMPILER=g++ \ > ../cpp-netlib .. note:: While it's not compulsory, it's recommended that :mod:`cpp-netlib` is built outside the source directory. For the purposes of documentation, we'll assume that all builds are done in ``~/cpp-netlib-build``. If you intend to use the SSL support when using the HTTP client libraries in :mod:`cpp-netlib`, you may need to build it with OpenSSL_ installed or at least available to CMake. If you have the development headers for OpenSSL_ installed on your system when you build :mod:`cpp-netlib`, CMake will be able to detect it and set the ``BOOST_NETWORK_ENABLE_HTTPS`` macro when building the library to support HTTPS URIs. One example for building the library with OpenSSL_ support with a custom (non-installed) version of OpenSSL_ is by doing the following:: $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=clang \ > -DCMAKE_CXX_COMPILER=clang++ \ > -DOPENSSL_ROOT_DIR=/Users/dberris/homebrew/Cellar/openssl/1.0.1f > ../cpp-netlib .. _OpenSSL: http://www.openssl.org/ You can also use a different root directory for the Boost_ project by using the ``-DBOOST_ROOT`` configuration option to CMake. This is useful if you intend to build the library with a specific version of Boost that you've built in a separate directory:: $ cmake -DCMAKE_BUILD_TYPE=Debug \ > -DCMAKE_C_COMPILER=clang \ > -DCMAKE_CXX_COMPILER=clang++ \ > -DOPENSSL_ROOT_DIR=/Users/dberris/homebrew/Cellar/openssl/1.0.1f \ > -DBOOST_ROOT=/Users/dberris/Source/boost_1_55_0 > ../cpp-netlib 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 ``~/cpp-netlib-build``:: $ 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. However, this compile-time burden is much reduced in recent versions. .. _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 You can install :mod:`cpp-netlib` by issuing:: $ sudo make install By default this installs :mod:`cpp-netlib` into ``/usr/local``. .. note:: As of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using GCC on Linux these are:: libcppnetlib-client-connections.a libcppnetlib-server-parsers.a libcppnetlib-uri.a Users can find them in ``~/cpp-netlib-build/libs/network/src``. Building On Windows ~~~~~~~~~~~~~~~~~~~ If you're using the Microsoft Visual C++ compiler or the Microsoft Visual Studio IDE and you would like to build :mod:`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. .. note:: As of version 0.9.3, :mod:`cpp-netlib` produces three static libraries. Using Visual C++ on Windows they are:: cppnetlib-client-connections.lib cppnetlib-server-parsers.lib cppnetlib-uri.lib Users can find them in ``~/cpp-netlib-build/libs/network/src``. Using :mod:`cpp-netlib` ======================= CMake projects ~~~~~~~~~~~~~~ Projects using CMake can add the following lines in their ``CMakeLists.txt`` to be able to use :mod:`cpp-netlib`:: set ( CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ~/cpp-netlib-build ) find_package ( cppnetlib 0.11.0 REQUIRED ) include_directories ( ${CPPNETLIB_INCLUDE_DIRS} ) target_link_libraries ( MyApplication ${CPPNETLIB_LIBRARIES} ) .. note:: Setting ``CMAKE_PREFIX_PATH`` is only required when :mod:`cpp-netlib` is not installed to a location that CMake searches. When :mod:`cpp-netlib` is installed to the default location (``/usr/local``), ``CMake`` can find it. .. note:: We assume that ``MyApplication`` is the application that you are building and which depends on :mod:`cpp-netlib`. 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/cpp-netlib/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 http://groups.google.com/forum/#!forum/cpp-netlib. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/history.txt000066400000000000000000000041711240331347200264110ustar00rootroot00000000000000Project history =============== The :mod:`cpp-netlib` was founded by Dean Michael Berris in 2007. Initially it consisted of a message template and an HTTP client. It found a home on Sourceforge_ but was migrated at the end of 2009 to Github_ where development is actively continued by a committed community. Motivation ~~~~~~~~~~ We're a group of C++ developers and we kept becoming annoyed that we had to repeatedly write the same code when building applications that needed to be network-aware. We found that there was a lack of accessible networking libraries, either standard or open source, that fulfilled our needs. Such libraries exist for every other major language. So, building on top of `Boost.Asio`_, we decided to get together and build our own. Objectives ~~~~~~~~~~ The objectives of the :mod:`cpp-netlib` are to: * develop a high quality, portable, easy to use C++ networking library * enable developers to easily extend the library * lower the barrier to entry for cross-platform network-aware C++ applications The goal the of :mod:`cpp-netlib` has never been to build a fully-featured web server - there are plenty of excellent options already available. The niche that this library targets is for light-weight networking functionality for C++ applications that have demanding performance requirements or memory constraints, but that also need to be portable. This type of application is becoming increasingly common as software becomes more distributed, and applications need to communicate with services. While many languages provide direct library support for high level network programming, this feature is missing in C++. Therefore, this library has been developed with the intention of eventually being submitted to Boost_, a collection of general, high quality libraries for C++ developers. Eventually, the :mod:`cpp-netlib` will be extended to support many of the application layer protocols such as SMTP, FTP, SOAP, XMPP etc. .. _Sourceforge: http://sourceforge.net/projects/cpp-netlib/ .. _Github: http://github.com/cpp-netlib/cpp-netlib .. _Boost: http://www.boost.org/ .. _`Boost.Asio`: http://www.boost.org/libs/asio/ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/in_depth.txt000066400000000000000000000005331240331347200265000ustar00rootroot00000000000000.. _in_depth: An in-depth look at the :mod:`cpp-netlib` ========================================= The :mod:`cpp-netlib` is composed of three different sets of functionality: a **message** template, a **URI** template and different **protocol** implementations. .. toctree:: :maxdepth: 2 in_depth/message in_depth/uri in_depth/http cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/in_depth/000077500000000000000000000000001240331347200257365ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/in_depth/http.txt000066400000000000000000000127351240331347200274660ustar00rootroot00000000000000HTTP implementation =================== HTTP client ``````````` At the heart of the HTTP client implementation is a single class aptly named ``basic_client``, which is also a template. The template ``basic_client`` takes three template parameters: .. code-block:: c++ namespace boost { namespace http { template struct basic_client; } // namespace http } // namespace boost The ``Tag`` template parameter follows the same tag-dispatch mechanism to determine the behavior of the ``basic_client``. The interface of ``basic_client`` may change depending on certain properties defined for the tag you provide. Below is a table of predefined supported tags you can use in your overload of the ``basic_client``: ------------ .. include:: http_client_tags.rst .. _Boost.Thread: http://www.boost.org/libs/thread The default typedef for the HTTP client that is provided uses the ``http_async_8bit_udp_resolve`` tag, and implements HTTP 1.1. The exact typedef is in the ``boost::network::http`` namespace as the following: .. code-block:: c++ namespace boost { namespace network { namespace http { typedef basic_client client; }}} This type has nested typedefs for the correct types for the ``basic_request`` and ``basic_response`` templates. To use the correct types for ``basic_request`` or ``basic_response`` you can use these nested typedefs like so: .. code-block:: c++ boost::network::http::client::request request; boost::network::http::client::response response; // or... using namespace boost::network; http::client::request request; http::client::response response; Typical use cases for the HTTP client would look something like the following: .. code-block:: c++ using namespace boost::network; http::request request("http://www.boost.org/"); request << header("Connection", "close"); The ``basic_client`` implements all HTTP methods as member functions (HEAD, GET, POST, PUT, DELETE). Therefore, the code to make an HTTP request looks trivially simple: .. code-block:: c++ using namespace boost::network; http::client client; http::client::request request("http://www.boost.org/"); http::client::response response = client.get(request); Accessing data from ``http::response`` is done using wrappers. To get the response headers, we use the ``headers`` wrapper which returns, in the default case, a multimap of strings to strings: .. code-block:: c++ using namespace boost::network; typedef headers_range::type response_headers; boost::range_iterator::type iterator; response_headers headers_ = headers(response); for (iterator it = headers_.begin(); it != headers_.end(); ++it) { std::cout << it->first << ": " << it->second << std::endl; } std::cout << std::endl; HTTP server ``````````` As with the HTTP client, the HTTP server that is provided with cpp-netlib is extensible through the tag mechanism and is embeddable. The template class declaration of ``basic_server`` is given below: .. code-block:: c++ namespace boost { namespace network { namespace http { template basic_server; }}} The second template argument is used to specify the request handler type. The request handler type is a functor type which should overload the function call operator (``RequestHandler::operator()`` should be overloaded) that takes two parameters: the first one being a reference to a ``const basic_request`` and the second being a reference to a ``basic_response`` instance. All the logic for parsing the HTTP request and building the ``const basic_request`` object resides internally in the ``basic_server`` template. Processing the request is delegated to the ``RequestHandler`` type, and the assumption of which would be that the response is formed inside the ``RequestHandler`` function call operator overload. The ``basic_server`` template however is only an underlying implementation while the user-visible implementation is the ``http::server`` template. This simply specializes the ``basic_server`` template to use the ``default_`` tag and forwards the ``RequestHandler`` parameter: .. code-block:: c++ namespace boost { namespace network { namespace http { template class server : public basic_server {}; }}} To use the forwarding server type you just supply the request handler implementation as the parameter. For example, an "echo" server example might look something like this: .. code-block:: c++ using namespace boost::network; struct echo; typedef http::server echo_server; struct echo { void operator () (const echo_server::request &request, echo_server::response &response) const { std::string ip = source(request); response = echo_server::response::stock_reply( echo_server::response::ok, body(request)); std::cerr << "[" << ip << "]: " << request.uri << " status = " << echo_server::response::ok << '\n'; } }; Here, all we're doing is returning the original request body with an HTTP OK response (200). We are also printing the IP address from where the request came from. Notice that we are using a wrapper to access the source of the request. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/in_depth/http_client_tags.txt000066400000000000000000000062631240331347200320410ustar00rootroot00000000000000+---------------------------------+---------------------------------------------+ | Tag | Description | +=================================+=============================================+ | http_default_8bit_tcp_resolve | This is the default HTTP implementation tag | | | that resolves addresses with a TCP resolver | | | and provides a synchronous/blocking HTTP | | | client interface. | +---------------------------------+---------------------------------------------+ | http_default_8bit_udp_resolve | This is similar to the above tag except that| | | it specifies the HTTP client to use a UDP | | | resolver. It also provides a synchronous/ | | | blocking HTTP client interface. | +---------------------------------+---------------------------------------------+ | http_keepalive_8bit_tcp_resolve | This tag specifies that the HTTP client by | | | default will keep connections to the server | | | alive. It only makes sense if the | | | ``version_major`` and ``version_minor`` are | | | both ``1``, to indicate HTTP 1.1. This tag | | | causes the HTTP client to resolve using a | | | TCP resolver and provides a synchronous/ | | | blocking HTTP client interface. | +---------------------------------+---------------------------------------------+ | http_keepalive_8bit_udp_resolve | This is similar to the above tag except that| | | it specifies the HTTP client to use a UDP | | | resolver. It also provides a synchronous/ | | | blocking HTTP client interface. | +---------------------------------+---------------------------------------------+ | http_async_8bit_tcp_resolve | This tag provides an active HTTP client | | | object implementation that uses a TCP | | | resolver. Response objects returned will | | | encapsulate a number of Boost.Thread_ | | | shared futures to hold values. Users don't | | | have to see this as they are implementation | | | details. | +---------------------------------+---------------------------------------------+ | http_async_8bit_udp_resolve | This is similar to the above tag except that| | | specifies the HTTP client to use a UDP | | | resolver. | +---------------------------------+---------------------------------------------+ .. _Boost.Thread: http://www.boost.org/libs/thread cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/in_depth/message.txt000066400000000000000000000247231240331347200301330ustar00rootroot00000000000000The message template ==================== One of the core components in the library is the concept and the implementation of a common message type. In most (not all) network protocols, the concept of a message is central to the definition of the protocol. In HTTP, SMTP, XMPP, and even other protocols like SNMP and ICMP, there is a common notion of a "packet" or a message. In cpp-netlib we chose to implement the concept of a message that has the following common parts: * **Source** - every message has a source identifier which varies from protocol to protocol. * **Destination** - every message has a destination identifier which varies from protocol to protocol. * **Headers** - each message is assumed to contain headers, which may be empty in cases where the protocol does not support it, but is nonetheless supported by cpp-netlib messages. * **Body** - the content area of a message which varies from protocol to protocol (also sometimes referred to as payload). This division is purely logical -- in the underlying implementation, the message type can choose to have different means of storing the data, depending on the type used to tag the message. This section covers the `Message Concept`_ as well as the `basic_message`_ implementation. Message Concept ``````````````` .. warning:: The Message framework is deprecated in the 0.11 release, and will be removed in future versions of the library. The Message Concept specifies what the valid operations on a message are as well as what messages look like semantically. The following table summarize the operations and syntactic as well as semantic properties of messages. **Legend** :M: The message type. :H: A headers container type. :m,n: An instance of **M**. :S: A string type. :s,k,v: An instance of **S**. :O: The source type. :D: The destination type. :B: The body type. :T: The Tag type. +----------------------------+----------------------+-----------------------------------------+ | Construct | Result | Description | +============================+======================+=========================================+ | ``typename M::tag`` | T | The nested tag type. | +----------------------------+----------------------+-----------------------------------------+ | ``M()`` | Instance of M | Default constructible. | +----------------------------+----------------------+-----------------------------------------+ | ``M(m)`` | Instance of M | Copy constructible. | +----------------------------+----------------------+-----------------------------------------+ | ``m = n;`` | Reference to m | Assignable. | +----------------------------+----------------------+-----------------------------------------+ | ``swap(m, n);`` | ``void`` | Swappable. | +----------------------------+----------------------+-----------------------------------------+ | ``source(m);`` | Convertible to O | Retrieve the source of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``destination(m);`` | Convertible to D | Retrieve the destination of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``headers(m);`` | Convertible to H | Retrieve the headers of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``body(m);`` | Convertible to B | Retrieve the body of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << source(s);`` | ``M &`` | Set the source of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << destination(s);`` | ``M &`` | Set the destination of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << header(k, v);`` | ``M &`` | Add a header to ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << remove_header(k);`` | ``M &`` | Remove a header from ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << body(s);`` | ``M &`` | Set the body of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``source(m,s);`` | ``void`` | Set the source of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``destination(m,s);`` | ``void`` | Set the destination of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``add_header(m, k, v);`` | ``void`` | Add a header to ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``remove_header(m, k);`` | ``void`` | Remove a header from ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``clear_headers(m);`` | ``void`` | Clear the headers of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``body(m,s);`` | ``M &`` | Set the body of ``m``. | +----------------------------+----------------------+-----------------------------------------+ Types that model the Message Concept are meant to encapsulate data that has a source, a destination, one or more named headers, and a body/payload. Because the accessors and the directives are not required to be part of the message type that models the Message Concept, a message can be implemented as a POD type and have all manipulations performed in the directive implementations, as well as value transformations done in the accessors. Directives, Modifiers, and Wrappers ``````````````````````````````````` In the Message Concept definition there are three basic constructs that follow a certain pattern. These patterns are Directives_, Modifiers_, and Wrappers_. Directives ~~~~~~~~~~ A directive is a function object that is applied to a Message. Directives encapsulate a set of operations that apply to messages. The general requirement for a Directive is that it should apply these operations on a message. A directive may dispatch on the type of the message passed to it at the point of the function call. Typically, directives are generated using a factory function that returns the correct directive type. For a given directive ``foo_directive`` a generator function called ``foo`` is typically implemented: .. code-block:: c++ struct foo_directive { template Message & operator()(Message & m) const { // do something to m return m; } }; foo_directive const foo() { return foo_directive(); } // to apply a directive, we use the << operator message m; m << foo(); Modifiers ~~~~~~~~~ A modifier is generally defined as a free function that takes a reference to a non-const lvalue message as the first parameter, and any number of parameters. In the concept definition of the Message Concept, a modifier follows the form: .. code-block:: c++ modifier(message, ...) Modifiers are meant to imply modifications on a message, which also allows for easier dispatch based on Argument Dependent Lookup (ADL_) on the type of the message. Note that Directives_ can be implemented in terms of Modifiers and vice versa, although that is not required nor specified. .. _ADL: http://en.wikipedia.org/wiki/Argument-dependent_name_lookup Wrappers ~~~~~~~~ A Wrapper is basically an implementation detail that ensures that a given message, when wrapped, can be converted to the associated part of the message. A wrapper has a type that encapsulates the conversion logic from a message to a given type. An example of a Wrapper would be ``source_wrapper`` which would be returned by a call to the wrapper generator function ``source``. An example implementation of the ``source_wrapper`` would look like: .. code-block:: c++ template class Message> struct source_wrapper { Message const & m; explicit source_wrapper(Message const & m) : m(m) {} typedef typename source::type source_type; operator source_type const & () { return m.source; } operator source_type const () { return m.source; } operator source_type () { return m.source; } }; template class Message> source_wrapper const source(Message const & message) { return source_wrapper(message); } This pattern is similar to an adapter, but the specific notion of wrapping a data type (in this case, an object of a type that models the Message Concept) using an intermediary wrapper is what is pertained to by the Wrapper pattern. In this case, the Wrapper is ``source_wrapper`` while ``source`` is merely a wrapper generator function. ``basic_message`` ````````````````` The default implementation of a simple type that models the Message Concept is available in cpp-netlib. This default implementation is named ``basic_message`` which supports a ``Tag`` template parameter. The definition of ``basic_message`` looks like this: .. code-block:: c++ template class basic_message; The ``basic_message`` template requires that the following tag-dispatched metafunctions are defined for the type ``Tag``: .. code-block:: c++ template struct string; template struct headers_container; All the operations defined by the message concept are implemented by this basic message type. Other message implementations can either use this common message type or specialize it according to whether they want to use different containers or whether it's going to be just a POD type. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/in_depth/uri.txt000066400000000000000000000134011240331347200272750ustar00rootroot00000000000000The URI class ============= In addition to protocol implementations, the :mod:`cpp-netlib` provides a powerful URI class. The class implements a parser based on `RFC 3986`_ and `RFC 2732`_. Generic URI syntax overview ``````````````````````````` A generic URI will take the form:: [scheme:]scheme-specific-part[#fragment] A URI is known as `absolute` if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, ``uri`` supports only absolute URIs. URIs can be further classified according to whether they're hierarchical or opaque (non-hierarchical). Some examples of non-hierarchical URIs include:: mailto:john.doe@example.com news:comp.infosystems.www.servers.unix tel:+1-816-555-1212 The data following the first ``":"`` is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the ``":"`` to be a part of the path: .. image:: ../_static/mailto_uri.png A hierarchical URI is identified by a double slash (``"//"``) after the scheme and a scheme-specific component, which `RFC 3986`_ defines to be:: [scheme:][//authority][path][?query][#fragment] The authority component can be further broken down to:: [user_info@]host[:port] Examples of hierarchical URIs include:: http://www.boost.org/ file:///bin/bash The following example, describing a complex URI using FTP, shows how a URI is broken down by the parser: .. image:: ../_static/ftp_uri.png Note that the ``authority`` is further subdivided into different elements. Another example, using HTTP is given below: .. image:: ../_static/http_uri.png The difference here between the path in a hierarchical URI and that in the example above for the non-hierarchical URI. The ``uri`` class ````````````````` As of version 0.9.3, ``uri`` supplies a URI parser and builder. To use the parser, it's as simple as supplying a string to the constructor: .. code-block:: c++ using namespace boost::network; uri::uri instance("http://cpp-netlib.github.com/"); assert(instance.is_valid()); std::cout << "scheme: " << instance.scheme() << std::endl << "host: " << instance.host() << std::endl; The command-line output of this program will be:: scheme: http host: cpp-netlib.github.com The ``uri`` builder ``````````````````` ``uri`` support a stream style syntax to create a URI from it's elements. For example the program: .. code-block:: c++ #include #include #include using namespace boost::network; int main() { uri::uri url; url << uri::scheme("http") << uri::host("www.github.com") << uri::path("/cpp-netlib"); std::cout << url << std::endl; return 0; } will output:: http://www.github.com/cpp-netlib ``URI Concept`` ``````````````` **Legend** :U: The URI type. :u,u_: An instance of **M**. :S: A string type. :s,v: An instance of **S**. :T: The Tag type. +----------------------------+----------------------+-----------------------------------------+ | Construct | Result | Description | +============================+======================+=========================================+ | ``U(u)`` | Instance of U | Copy constructible. | +----------------------------+----------------------+-----------------------------------------+ | ``U(s)`` | Instance of U | Constructible from string. | +----------------------------+----------------------+-----------------------------------------+ | ``u = u_;`` | Reference to u | Assignable. | +----------------------------+----------------------+-----------------------------------------+ | ``u = s;`` | Reference to u | Assignable from string. | +----------------------------+----------------------+-----------------------------------------+ | ``swap(u, u_);`` | ``void`` | Swappable. | +----------------------------+----------------------+-----------------------------------------+ | ``scheme(u);`` | Convertible to S | Retrieve the URI scheme of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``user_info(u);`` | Convertible to S | Retrieve the user info of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``host(u);`` | Convertible to S | Retrieve the host of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``port(u);`` | Convertible to H | Retrieve the port of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``path(u);`` | Convertible to S | Retrieve the path of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``query(u);`` | Convertible to S | Retrieve the query string of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``fragment(u);`` | Convertible to S | Retrieve the fragment of ``u``. | +----------------------------+----------------------+-----------------------------------------+ .. _`RFC 3986`: http://tools.ietf.org/html/rfc3986 .. _`RFC 2368`: http://tools.ietf.org/html/rfc2368 .. _`RFC 3513`: http://tools.ietf.org/html/rfc3513 .. _`RFC 2732`: http://tools.ietf.org/html/rfc2732 cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/index.txt000066400000000000000000000074371240331347200260270ustar00rootroot00000000000000.. _index: .. rubric:: Straightforward network programming in modern C++ .. :Authors: Glyn Matthews .. Dean Michael Berris .. :Date: 2014-10-01 .. :Version: 0.11.0 .. :Description: Complete user documentation, with examples, for the :mod:`cpp-netlib`. .. :Copyright: Copyright Glyn Matthews, Dean Michael Berris 2008-2013. .. Copyrigh 2013 Google, Inc. .. Distributed under the Boost Software License, Version .. 1.0. (See accompanying file LICENSE_1_0.txt or copy at .. http://www.boost.org/LICENSE_1_0.txt) Getting cpp-netlib ================== You can find out more about the :mod:`cpp-netlib` project at http://cpp-netlib.org/. **Download** You can get the latest official version of the library from the official project website at: http://cpp-netlib.org/ This version of :mod:`cpp-netlib` is tagged as cpp-netlib-0.11.0 in the GitHub_ repository. You can find more information about the progress of the development by checking our GitHub_ project page at: http://github.com/cpp-netlib/cpp-netlib **Support** You can ask questions, join the discussion, and report issues to the developers mailing list by joining via: https://groups.google.com/group/cpp-netlib You can also file issues on the Github_ issue tracker at: http://github.com/cpp-netlib/cpp-netlib/issues We are a growing community and we are happy to accept new contributions and ideas. C++ Network Library =================== :mod:`cpp-netlib` is a library collection that provides application layer protocol support using modern C++ techniques. It is light-weight, fast, portable and is intended to be as easy to configure as possible. Hello, world! ============= The :mod:`cpp-netlib` allows developers to write fast, portable network applications with the minimum of fuss. An HTTP server-client example can be written in tens of lines of code. The client is as simple as this: .. code-block:: cpp using namespace boost::network; using namespace boost::network::http; client::request request_("http://127.0.0.1:8000/"); request_ << header("Connection", "close"); client client_; client::response response_ = client_.get(request_); std::string body_ = body(response_); And the corresponding server code is listed below: .. code-block:: cpp namespace http = boost::network::http; struct handler; typedef http::server http_server; struct handler { void operator() (http_server::request const &request, http_server::response &response) { response = http_server::response::stock_reply( http_server::response::ok, "Hello, world!"); } void log(http_server::string_type const &info) { std::cerr << "ERROR: " << info << '\n'; } }; int main(int arg, char * argv[]) { handler handler_; http_server::options options(handler_); http_server server_( options.address("0.0.0.0") .port("8000")); server_.run(); } Want to learn more? =================== * :ref:`Take a look at the getting started guide ` * :ref:`Learn from some simple examples ` * :ref:`Find out what's new ` * :ref:`Study the library in more depth ` * :ref:`Discover more through the full reference ` * :ref:`Full table of contents ` .. warning:: Be aware that not all features are stable. The generic message design is under review and the URI and HTTP client implementation will continue to undergo refactoring. Future versions will include support for other network protocols. .. _Boost: http://www.boost.org/ .. _GitHub: http://github.com/ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/reference.txt000066400000000000000000000005311240331347200266420ustar00rootroot00000000000000.. _reference: Reference Manual ================ This reference manual refers to the API documentation of the public interfaces to the different client and/or server implementations within :mod:`cpp-netlib`. .. toctree:: :maxdepth: 2 reference/http_client reference/http_request reference/http_response reference/http_server cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/reference/000077500000000000000000000000001240331347200261025ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/reference/http_client.txt000066400000000000000000000555361240331347200311760ustar00rootroot00000000000000 HTTP Client API =============== General ------- :mod:`cpp-netlib` includes and implements a number of HTTP clients that you can use and embed in your own applications. All of the HTTP client implementations: * **Cannot be copied.** This means you may have to store instances of the clients in dynamic memory if you intend to use them as function parameters or pass them around in smart pointers or by reference. * **Assume that requests made are independent of each other.** There currently is no cookie or session management system built-in to cpp-netlib's HTTP client implementations. The HTTP clients all share the same API, but the internals are documented in terms of what is different and what to expect with the different implementations. As of 0.9.1 the default implementation for the :mod:`cpp-netlib` HTTP client is asynchronous. As of 0.11 the `Synchronous Clients`_ are now *DEPRECATED* and will be removed in subsequent releases. Features -------- The HTTP client implementation supports requesting secure HTTP (HTTPS) content only in the following situations: * **Client libraries are built with ``BOOST_NETWORK_ENABLE_HTTPS``.** This tells the implementation to use HTTPS-specific code to handle HTTPS-based content when making connections associated with HTTPS URI's. This requires a dependency on OpenSSL_. * **The ``BOOST_NETWORK_ENABLE_HTTPS`` macro is set when compiling user code.** It is best to define this either at compile-time of all code using the library, or before including any of the client headers. To use the client implementations that support HTTPS URIs, you may explicitly do the following: .. code-block:: c++ #define BOOST_NETWORK_ENABLE_HTTPS #include This forces HTTPS support to be enabled and forces a dependency on OpenSSL_. This dependency is imposed by `Boost.Asio`_ .. _OpenSSL: http://www.openssl.org/ .. _`Boost.Asio`: http://www.boost.org/libs/asio Implementations --------------- There is a single user-facing template class named ``basic_client`` which takes three template parameters: * **Tag** - which static tag you choose that defines the behavior of the client. * **http_version_major** - an unsigned int that defines the HTTP major version number, this directly affects the HTTP messages sent by the client. * **http_version_minor** - an unsigned int that defines the HTTP minor version number. There are two major different class of implementations of the ``basic_client`` template that depend on which tag you choose: `Synchronous Clients`_ and `Asynchronous Clients`_. These two different classes are described in their own sections following this one. What follows is a table of all tags supported by the HTTP client implementation provided by :mod:`cpp-netlib`. --------------- .. include:: ../in_depth/http_client_tags.rst In the above table the tags follow a pattern for describing the behavior introduced by the tags. This pattern is shown below: ___ For example, the tag ``http_default_8bit_tcp_resolve`` indicates the protocol ``http``, a modifier ``default``, a character width of ``8bit``, and a resolve strategy of ``tcp_resolve``. Synchronous Clients ~~~~~~~~~~~~~~~~~~~ Of the client tags shown in the table, the following makes the ``basic_client`` behave as a fully synchronous client. * **http_default_8bit_tcp_resolve** * **http_default_8bit_udp_resolve** * **http_keepalive_8bit_tcp_resolve** * **http_keepalive_8bit_udp_resolve** The synchronous client implements all the operations of the client underneath the interface all block to wait for I/O to finish. All the member methods are synchronous and will block until the response object is ready or throws if errors are encountered in the performance of the HTTP requests. .. warning:: The synchronous clients are **NOT** thread safe. You will need to do external synchronization to use synchronous client implementations. .. note:: As of version 0.11, all the synchronous client implementations are deprecated. They will be removed in the next version of the library. Asynchronous Clients ~~~~~~~~~~~~~~~~~~~~ The following tags specify the ``basic_client`` to behave in an asynchronous manner: * **http_async_8bit_tcp_resolve** * **http_async_8bit_udp_resolve** An asynchronous client implementation means that``basic_client<...>`` is an `Active Object`_. This means that the client has and manages its own lifetime thread, and returns values that are asynchronously filled in. The response object encapsulates Boost.Thread_ futures which get filled in once the values are available. .. _Boost.Thread: http://www.boost.org/libs/thread .. _`Active Object`: http://en.wikipedia.org/wiki/Active_object The asynchronous clients implement all operations asynchronously which are hidden from the user. The interface is still synchronous but the fetching of data happens on a different thread. .. note:: The asynchronous clients are thread safe, and can be shared across many threads. Each request starts a sequence of asynchronous operations dedicated to that request. The client does not re-cycle connections and uses a one-request-one-connection model. When an asynchronous client object is destroyed, it waits for all pending asynchronous operations to finish. Errors encountered during operations on retrieving data from the response objects cause exceptions to be thrown -- therefore it is best that if a client object is constructed, it should outlive the response object or be outside the try-catch block handling the errors from operations on responses. In code, usage should look like the following: .. code-block:: c++ http::client client; try { http::client::response response = client.get("http://www.example.com/"); std::cout << body(response); } catch (std::exception& e) { // deal with exceptions here } A common mistake is to declare the client inside the try block which invokes undefined behavior when errors arise from the handling of response objects. Previous examples cited by the documentation showed the short version of the code which didn't bother moving the ``http::client`` object outside of the same ``try`` block where the request/response objects are being used. Member Functions ---------------- In this section we assume that the following typedef is in effect: .. code-block:: c++ typedef boost::network::http::basic_client< boost::network::http::tags::http_default_8bit_udp_resolve , 1 , 1 > client; Also, that code using the HTTP client will have use the following header: .. code-block:: c++ #include .. note:: Starting version 0.9, cpp-netlib clients and server implementations by default now have an externally-linked component. This is a breaking change for code that used to rely on cpp-netlib being a header-only library, but can inhibited by defining the ``BOOST_NETWORK_NO_LIB`` preprocessor macro before including any cpp-netlib header. .. note:: Starting version 0.11, cpp-netlib clients and server implementations no longer support the ``BOOST_NETWORK_NO_LIB`` option. Constructors ~~~~~~~~~~~~ The client implementation can be default constructed, or customized at initialization. ``client()`` Default constructor. ``explicit client(client::options const &)`` Constructor taking a ``client_options`` object. The following table shows the options you can set on a ``client_options`` instance. +--------------------------+----------------------------+--------------------------+ | Parameter Name | Type | Description | +==========================+============================+==========================+ | follow_redirects | ``bool`` | Boolean to specify | | | | whether the client | | | | should follow HTTP | | | | redirects. Default is | | | | ``false``. | +--------------------------+----------------------------+--------------------------+ | cache_resolved | ``bool`` | Boolean to specify | | | | whether the client | | | | should cache resolved | | | | endpoints. The default | | | | is ``false``. | +--------------------------+----------------------------+--------------------------+ | io_service | ``shared_ptr`` | Shared pointer to a | | | | Boost.Asio | | | | ``io_service``. | +--------------------------+----------------------------+--------------------------+ | openssl_certificate | ``string`` | The filename of the | | | | certificate to load for | | | | the SSL connection for | | | | verification. | +--------------------------+----------------------------+--------------------------+ | openssl_verify_path | ``string`` | The directory from | | | | which the certificate | | | | authority files are | | | | located. | +--------------------------+----------------------------+--------------------------+ | always_verify_peer | ``bool`` | Boolean to specify | | | | whether the client | | | | should always verify | | | | peers in SSL connections | +--------------------------+----------------------------+--------------------------+ | openssl_certificate_file | ``string`` | Filename of the | | | | certificate to use for | | | | client-side SSL session | | | | establishment. | +--------------------------+----------------------------+--------------------------+ | openssl_private_key_file | ``string`` | Filename of the | | | | private key to use for | | | | client-side SSL session | | | | establishment. | +--------------------------+----------------------------+--------------------------+ | timeout | ``int`` | Number of seconds to | | | | wait for client requests | | | | before considering a | | | | timeout has occurred. | +--------------------------+----------------------------+--------------------------+ To use the above supported named parameters, you'll have code that looks like the following: .. code-block:: c++ using namespace boost::network::http; // parameters are in this namespace client::options options; options.follow_redirects(true) .cache_resolved(true) .io_service(boost::make_shared()) .openssl_certificate("/tmp/my-cert") .openssl_verify_path("/tmp/ca-certs") .timeout(10); client client_(options); // use client_ as normal from here on out. HTTP Methods ~~~~~~~~~~~~ The client implementation supports various HTTP methods. The following constructs assume that a client has been properly constructed named ``client_`` and that there is an appropriately constructed request object named ``request_`` and that there is an appropriately constructed response object named ``response_`` like the following: .. code-block:: c++ using namespace boost::network::http; // parameters are here client client_(); client::request request_("http://cpp-netib.github.com/"); client::response response_; ``response_ = client_.get(request_)`` Perform an HTTP GET request. ``response_ = client_.get(request_, callback)`` Perform an HTTP GET request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.head(request_)`` Perform an HTTP HEAD request. ``response_ = client_.post(request_)`` Perform an HTTP POST, use the data already set in the request object which includes the headers, and the body. ``response_ = client_.post(request_, callback)`` Perform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.post(request_, body)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. ``response_ = client_.post(request_, body, callback)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.post(request_, body, content_type)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. ``response_ = client_.post(request_, body, content_type, callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.post(request_, body, content_type, callback, streaming_callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. The ``streaming_callback`` argument should have a which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.post(request_, streaming_callback)`` Perform and HTTP POST request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.post(request_, callback, streaming_callback)`` Perform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.put(request_)`` Perform an HTTP PUT, use the data already set in the request object which includes the headers, and the body. ``response_ = client_.put(request_, callback)`` Perform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.put(request_, body)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. ``response_ = client_.put(request_, body, callback)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.put(request_, body, content_type)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. ``response_ = client_.put(request_, body, content_type, callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.put(request_, body, content_type, callback, streaming_callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent ``response_ = client_.put(request_, streaming_callback)`` Perform and HTTP PUT request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.put(request_, callback, streaming_callback)`` Perform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.delete_(request_)`` Perform an HTTP DELETE request. ``response_ = client_.delete_(request_, body_handler=callback)`` Perform an HTTP DELETE request, and have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. Client-Specific ~~~~~~~~~~~~~~~ ``client_.clear_resolved_cache()`` Clear the cache of resolved endpoints. Streaming Body Handler ~~~~~~~~~~~~~~~~~~~~~~ As of v0.9.1 the library now offers a way to support a streaming body callback function in all HTTP requests that expect a body part (GET, PUT, POST, DELETE). A convenience macro is also provided to make callback handlers easier to write. This macro is called ``BOOST_NETWORK_HTTP_BODY_CALLBACK`` which allows users to write the following code to easily create functions or function objects that are compatible with the callback function requirements. An example of how to use the macro is shown below: .. code-block:: c++ struct body_handler { explicit body_handler(std::string & body) : body(body) {} BOOST_NETWORK_HTTP_BODY_CALLBACK(operator(), range, error) { // in here, range is the Boost.Range iterator_range, and error is // the Boost.System error code. if (!error) body.append(boost::begin(range), boost::end(range)); } std::string & body; }; // somewhere else std::string some_string; response_ = client_.get(request("http://cpp-netlib.github.com/"), body_handler(some_string)); You can also use if for standalone functions instead if you don't want or need to create a function object. .. code-block:: c++ BOOST_NETWORK_HTTP_BODY_CALLBACK(print_body, range, error) { if (!error) std::cout << "Received " << boost::distance(range) << "bytes." << std::endl; else std::cout << "Error: " << error << std::endl; } // somewhere else response_ = client_.get(request("http://cpp-netlib.github.com/"), print_body); The ``BOOST_NETWORK_HTTP_BODY_CALLBACK`` macro is defined in ``boost/network/protocol/http/client/macros.hpp``. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/reference/http_request.txt000066400000000000000000000316521240331347200314010ustar00rootroot00000000000000 HTTP Request ============ This part of the documentation talks about the publicly accessible API of the HTTP Request objects. This section details the `Request Concepts`_ requirements, the implemented and required Directives_, Modifiers_, and Wrappers_ that work with the HTTP Request objects. Request Concepts ---------------- There are two generally supported Request Concepts implemented in the library. The first of two is the `Normal Client Request Concept`_ and the second is the `Pod Server Request Concept`_. The `Normal Client Request Concept`_ is what the HTTP Client interface requires. All operations performed internally by the HTTP Client abide by the interface required by this concept definition. The `Pod Server Request Concept`_ is as the name suggests what the HTTP Server implementation requires from Request Objects. Switching on whether the `Request` concept chooses either of the `Normal Client Request Concept`_ or the `Pod Server Request Concept`_ is done through the nested ``tag`` type and whether that tag derives from the root tag ``pod``. Simply, if the Request type's nested ``tag`` type derives from ``boost::network::tags::pod`` then it chooses to enforce the `Pod Server Request Concept`_, otherwise it chooses the `Normal Client Request Concept`_. Normal Client Request Concept ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A type models the Normal Client Request Concept if it models the `Message Concept`_ and also supports the following constructs. **Legend** :R: The request type. :r: An instance of R. :S: The string type. :s: An instance of S. :P: The port type. :p: An instance of P. +-----------------------+-------------+----------------------------------------+ | Construct | Result | Description | +=======================+=============+========================================+ | ``R::string_type`` | ``S`` | The nested ``string_type`` type. | +-----------------------+-------------+----------------------------------------+ | ``R::port_type`` | ``P`` | The nested ``port_type`` type. | +-----------------------+-------------+----------------------------------------+ | ``R r(s)`` | **NA** | Construct a Request with an ``s`` | | | | provided. This treats ``s`` as the URI | | | | to where the request is destined for. | +-----------------------+-------------+----------------------------------------+ | ``host(request)`` | Convertible | Return the host to where the request | | | to ``S`` | is destined for. | +-----------------------+-------------+----------------------------------------+ | ``port(request)`` | Convertible | Return the port to where the request | | | to ``P`` | is destined for. | +-----------------------+-------------+----------------------------------------+ | ``path(request)`` | Convertible | Return the path included in the URI. | | | to ``S`` | | +-----------------------+-------------+----------------------------------------+ | ``query(request)`` | Convertible | Return the query part of the URI. | | | to ``S`` | | +-----------------------+-------------+----------------------------------------+ | ``anchor(request)`` | Convertible | Return the anchor part of the URI. | | | to ``S`` | | +-----------------------+-------------+----------------------------------------+ | ``protocol(request)`` | Convertible | Return the protocol/scheme part of the | | | to ``S`` | URI. | +-----------------------+-------------+----------------------------------------+ | ``r << uri(s)`` | ``R&`` | Set the URI of the request. | +-----------------------+-------------+----------------------------------------+ | ``uri(r, s)`` | ``void`` | Set the URI of the request. | +-----------------------+-------------+----------------------------------------+ Pod Server Request Concept ~~~~~~~~~~~~~~~~~~~~~~~~~~ A type models the Pod Server Request Concept if it models the `Message Concept`_ and also supports the following constructs. **Legend** :R: The request type. :r: An instance of R. :S: The string type. :I: An unsigned 8 bit integer. :V: The vector type for headers. +-------------------------------+--------+-------------------------------------+ | Construct | Result | Description | +===============================+========+=====================================+ | ``R::string_type`` | ``S`` | The nested ``string_type`` type. | +-------------------------------+--------+-------------------------------------+ | ``R::headers_container_type`` | ``V`` | The nested | | | | ``headers_container_type`` type. | +-------------------------------+--------+-------------------------------------+ | ``r.source`` | ``S`` | The nested source of the request. | +-------------------------------+--------+-------------------------------------+ | ``r.method`` | ``S`` | The method of the request. | +-------------------------------+--------+-------------------------------------+ | ``r.destination`` | ``S`` | The destination of the request. | | | | This is normally the URI of the | | | | request. | +-------------------------------+--------+-------------------------------------+ | ``r.version_major`` | ``I`` | The major version number part of | | | | the request. | +-------------------------------+--------+-------------------------------------+ | ``r.version_minor`` | ``I`` | The minor version number part of | | | | the request. | +-------------------------------+--------+-------------------------------------+ | ``r.headers`` | ``V`` | The vector of headers. | +-------------------------------+--------+-------------------------------------+ | ``r.body`` | ``S`` | The body of the request. | +-------------------------------+--------+-------------------------------------+ .. _Message Concept: ../in_depth/message.html#message-concept Directives ---------- This section details the provided directives that are provided by :mod:`cpp-netlib`. The section was written to assume that an appropriately constructed request instance is either of the following: .. code-block:: c++ boost::network::http::basic_request< boost::network::http::tags::http_default_8bit_udp_resolve > request; // or boost::network::http::basic_request< boost::network::http::tags::http_server > request; The section also assumes that there following using namespace declaration is in effect: .. code-block:: c++ using namespace boost::network; Directives are meant to be used in the following manner: .. code-block:: c++ request << directive(...); .. warning:: There are two versions of directives, those that are applicable to messages that support narrow strings (``std::string``) and those that are applicable to messages that support wide strings (``std::wstring``). The :mod:`cpp-netlib` implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases. For now all the implemented directives are listed, even if some of them still do not implement things correctly. *unspecified* ``source(std::string const & source_)`` Create a source directive with a ``std::string`` as a parameter, to be set as the source of the request. *unspecified* ``source(std::wstring const & source_)`` Create a source directive with a ``std::wstring`` as a parameter, to be set as the source of the request. *unspecified* ``destination(std::string const & source_)`` Create a destination directive with a ``std::string`` as a parameter, to be set as the destination of the request. *unspecified* ``destination(std::wstring const & source_)`` Create a destination directive with a ``std::wstring`` as a parameter, to be set as the destination of the request. *unspecified* ``header(std::string const & name, std::string const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::string``. *unspecified* ``header(std::wstring const & name, std::wstring const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::wstring``. *unspecified* ``remove_header(std::string const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::string``. *unspecified* ``remove_header(std::wstring const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::wstring``. *unspecified* ``body(std::string const & body_)`` Create a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::string``. *unspecified* ``body(std::wstring const & body_)`` Create a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::wstring``. Modifiers --------- This section details the provided modifiers that are provided by :mod:`cpp-netlib`. ``template inline void source(basic_request & request, typename string::type const & source_)`` Modifies the source of the given ``request``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void destination(basic_request & request, typename string::type const & destination_)`` Modifies the destination of the given ``request``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void add_header(basic_request & request, typename string::type const & name, typename string::type const & value)`` Adds a header to the given ``request``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void remove_header(basic_request & request, typename string::type const & name)`` Removes a header from the given ``request``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void clear_headers(basic_request & request)`` Removes all headers from the given ``request``. ``template inline void body(basic_request & request, typename string::type const & body_)`` Modifies the body of the given ``request``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_request``. Wrappers -------- This section details the provided request wrappers that come with :mod:`cpp-netlib`. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect: .. code-block:: c++ using namespace boost::network; using namespace boost::network::http; ``template `` *unspecified* ``source(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the source of a given request. ``template `` *unspecified* ``destination(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the destination of a given request. ``template `` *unspecified* ``headers(basic_request const & request)`` Returns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_request::headers_container_type`` that provides the headers of a given request. ``template `` *unspecified* ``body(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the body of a given request. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/reference/http_response.txt000066400000000000000000000433441240331347200315500ustar00rootroot00000000000000 HTTP Response ============= This part of the documentation talks about the publicly accessible API of the HTTP Response objects. This section details the `Response Concept`_ requirements, the implemented and required Directives_, Modifiers_, and Wrappers_ that work with the HTTP Response objects. .. note:: The HTTP server response object is a POD type, which doesn't support any of the following details. There are only a few fields available in the HTTP server response type, which can be seen in ``boost/network/protocol/http/impl/response.ipp``. Response Concept ---------------- A type models the Response Concept if it models the `Message Concept`_ and also supports the following constructs. **Legend** :R: The response type. :r: An instance of R. :S: The string type. :s,e,g: Instances of S. :P: The port type. :p: An instance of P. :V: The version type. :v: An instance of v. :T: The status type. :t: An instance of T. :M: The status message type. :m: An instance of M. :U: An unsigned 16-bit int. :u: An instance of U. .. note:: In the table below, the namespace ``traits`` is an alias for ``boost::network::http::traits``. +-------------------------------------+----------+-----------------------------+ | Construct | Result | Description | +=====================================+==========+=============================+ | ``R::string_type`` | ``S`` | The nested ``string_type`` | | | | type. | +-------------------------------------+----------+-----------------------------+ | ``traits::version::type`` | ``V`` | The version type associated | | | | with R. | +-------------------------------------+----------+-----------------------------+ | ``traits::status::type`` | ``T`` | The status type associated | | | | with R. | +-------------------------------------+----------+-----------------------------+ | ``traits::status_message::type`` | ``M`` | The status message type | | | | associated with R. | +-------------------------------------+----------+-----------------------------+ | ``r << version(v)`` | ``R&`` | Sets the version of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``r << status(t)`` | ``R&`` | Sets the status of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``r << status_message(m)`` | ``R&`` | Sets the status message of | | | | ``r``. | +-------------------------------------+----------+-----------------------------+ | ``version(r, v)`` | ``void`` | Sets the version of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``status(r, t)`` | ``void`` | Sets the status of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``status_message(r, m)`` | ``void`` | Sets the status message of | | | | ``r``. | +-------------------------------------+----------+-----------------------------+ | ``S e = version(r)`` | **NA** | Get the version of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``U u = status(r)`` | **NA** | Get the status of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``S g = status_message(r)`` | **NA** | Get the status message of | | | | ``r``. | +-------------------------------------+----------+-----------------------------+ .. _Message Concept: ../in_depth/message.html#message-concept Directives ---------- This section details the provided directives that are provided by :mod:`cpp-netlib`. The section was written to assume that an appropriately constructed response instance is either of the following: .. code-block:: c++ boost::network::http::basic_response< boost::network::http::tags::http_default_8bit_udp_resolve > response; // or boost::network::http::basic_response< boost::network::http::tags::http_server > response; The section also assumes that there following using namespace declaration is in effect: .. code-block:: c++ using namespace boost::network; Directives are meant to be used in the following manner: .. code-block:: c++ response << directive(...); .. warning:: There are four versions of directives, those that are applicable to messages that support narrow strings (``std::string``), those that are applicable to messages that support wide strings (``std::wstring``), those that are applicable to messages that support future-wrapped narrow and wide strings (``boost::shared_future`` and ``boost::shared_future``). The :mod:`cpp-netlib` implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases. For now all the implemented directives are listed, even if some of them still do not implement things correctly. *unspecified* ``source(std::string const & source_)`` Create a source directive with a ``std::string`` as a parameter, to be set as the source of the response. *unspecified* ``source(std::wstring const & source_)`` Create a source directive with a ``std::wstring`` as a parameter, to be set as the source of the response. *unspecified* ``source(boost::shared_future const & source_)`` Create a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response. *unspecified* ``source(boost::shared_future const & source_)`` Create a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response. *unspecified* ``destination(std::string const & source_)`` Create a destination directive with a ``std::string`` as a parameter, to be set as the destination of the response. *unspecified* ``destination(std::wstring const & source_)`` Create a destination directive with a ``std::wstring`` as a parameter, to be set as the destination of the response. *unspecified* ``destination(boost::shared_future const & destination_)`` Create a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response. *unspecified* ``destination(boost::shared_future const & destination_)`` Create a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response. *unspecified* ``header(std::string const & name, std::string const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the response. In this case the name and values are both ``std::string``. *unspecified* ``header(std::wstring const & name, std::wstring const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the response. In this case the name and values are both ``std::wstring``. *unspecified* ``remove_header(std::string const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the response. In this case the name of the header is of type ``std::string``. *unspecified* ``remove_header(std::wstring const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the response. In this case the name of the header is of type ``std::wstring``. *unspecified* ``body(std::string const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``std::string``. *unspecified* ``body(std::wstring const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``std::wstring``. *unspecified* ``body(boost::shared_future const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``. *unspecified* ``body(boost::shared_future const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``. *unspecified* ``version(std::string const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``std::string``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``version(std::wstring const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``std::wstring``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``version(boost::shared_future const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``version(boost::shared_future const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``status_message(std::string const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``std::string``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status_message(std::wstring const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``std::wstring``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status_message(boost::shared_future const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status_message(boost::shared_future const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status(boost::uint16_t status_)`` Create a status directive that will set the response's status to the given parameter. In this case the type of ``status_`` is ``boost::uint16_t``. *unspecified* ``status(boost::shared_future const & status_)`` Create a status directive that will set the response's status to the given parameter. In this case the type of ``status_`` is ``boost::shared_future``. Modifiers --------- This section details the provided modifiers that are provided by :mod:`cpp-netlib`. ``template inline void source(basic_response & response, typename string::type const & source_)`` Modifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void source(basic_response & response, boost::shared_future::type> const & source_)`` Modifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void destination(basic_response & response, typename string::type const & destination_)`` Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void destination(basic_response & response, boost::shared_future::type> const & destination_)`` Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void add_header(basic_response & response, typename string::type const & name, typename string::type const & value)`` Adds a header to the given ``response``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void remove_header(basic_response & response, typename string::type const & name)`` Removes a header from the given ``response``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void headers(basic_response & response, typename headers_container >::type const & headers_)`` Sets the whole headers contained in ``response`` as the given parameter ``headers_``. ``template inline void headers(basic_response & response, boost::shared_future >::type> const & headers_)`` Sets the whole headers contained in ``response`` as the given parameter ``headers_``. ``template inline void clear_headers(basic_response & response)`` Removes all headers from the given ``response``. ``template inline void body(basic_response & response, typename string::type const & body_)`` Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void body(basic_response & response, boost::shared_future::type> const & body_)`` Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void version(basic_response & response, typename traits::version >::type const & version_)`` Modifies the version of the given ``response``. The type of ``version_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void status(basic_response & response, typename traits::status >::type const & status_)`` Modifies the status of the given ``response``. The type of ``status_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void status_message(basic_response & response, typename traits::status_message >::type const & status_message_)`` Modifies the status message of the given ``response``. The type of ``status_message_`` is dependent on the ``Tag`` specialization of ``basic_response``. Wrappers -------- This section details the provided response wrappers that come with :mod:`cpp-netlib`. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect: .. code-block:: c++ using namespace boost::network; using namespace boost::network::http; ``template `` *unspecified* ``source(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the source of a given response. ``template `` *unspecified* ``destination(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the destination of a given response. ``template `` *unspecified* ``headers(basic_response const & response)`` Returns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_response::headers_container_type`` that provides the headers of a given response. ``template `` *unspecified* ``body(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the body of a given response. ``template `` *unspecified* ``version(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the version of the given response. ``template `` *unspecified* ``status(basic_response const & response)`` Returns a wrapper convertible to ``typename boost::uint16_t`` that provides the status of the given response. ``template `` *unspecified* ``status_message(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the status message of the given response. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/reference/http_server.txt000066400000000000000000000654431240331347200312240ustar00rootroot00000000000000 HTTP Server API =============== General ------- :mod:`cpp-netlib` includes and implements two distinct HTTP server implementations that you can use and embed in your own applications. Both HTTP Server implementations: * **Cannot be copied.** This means you may have to store instances of the HTTP Server in dynamic memory if you intend to use them as function parameters or pass them around in smart pointers of by reference. * **Assume that requests made are independent of each other.** None of the HTTP Server implementations support request pipelining (yet) so a single connection only deals with a single request. * **Are header-only and are compiled-into your application.** Future releases in case you want to upgrade the implementation you are using in your application will be distributed as header-only implementations, which means you have to re-compile your application to use a newer version of the implementations. The HTTP Servers have different semantics, and in some cases require different APIs from the supplied template parameters. Implementations --------------- There are two different user-facing template classes that differentiate the `Synchronous Servers`_ from the `Asynchronous Servers`_. Both templates take a single template parameter named ``Handler`` which describes the type of the Handler function object. There are two different Handler concepts, one concept for `Synchronous Servers`_ and another for `Asynchronous Servers`. The SynchronousHandler concept for `Synchronous Servers`_ is described by the following table: --------------- **Legend:** H The Handler type. h An instance of H. Req A type that models the Request Concept. Res A type that models the Response Concept. req An instance of Req. res An instance of Res. +----------------+-------------+----------------------------------------------+ | Construct | Return Type | Description | +================+=============+==============================================+ | ``h(req,res)`` | ``void`` | Handle the request; res is passed in as a | | | | non-const lvalue, which represents the | | | | response to be returned to the client | | | | performing the request. | +----------------+-------------+----------------------------------------------+ More information about the internals of the `Synchronous Servers`_ can be found in the following section. The AsynchronousHandler concept for `Asynchronous Servers`_ is described by the following table: --------------- **Legend:** H The Handler type. h An instance of H. Req A type that models the Request Concept. ConnectionPtr A type that models the Connection Pointer Concept. req An instance of Req. conn An instance of ConncetionPtr. +------------------+-------------+--------------------------------------------+ | Construct | Return Type | Description | +==================+=============+============================================+ | ``h(req, conn)`` | ``void`` | Handle the request; conn is a shared | | | | pointer which exposes functions for | | | | writing to and reading from the connection.| +------------------+-------------+--------------------------------------------+ More information about the internals of the `Asynchronous Servers`_ can be found in the following section. Synchronous Servers ------------------- The synchronous server implementation is represented by the template ``server`` in namespace ``boost::network::http``. The ``server`` template takes in a single template parameter named ``Handler`` which models the SynchronousHandler concept (described above). An instance of Handler is taken in by reference to the constructor of the HTTP server. This means the Handler is not copied around and only a single instance of the handler is used for all connections and requests performed against the HTTP server. .. warning:: It is important to note that the HTTP server does not implement any locking upon invoking the Handler. In case you have any state in the Handler that will be associated with the synchronous server, you would have to implement your own synchronization internal to the Handler implementation. This matters especially if you run the synchronous server in multiple threads. The general pattern of usage for the HTTP Server template is shown below: .. code-block:: c++ struct handler; typedef boost::network::http::server http_server; struct handler { void operator()( http_server::request const & req, http_server::response & res ) { // do something, and then edit the res object here. } }; More information about the actual HTTP Server API follows in the next section. It is important to understand that the HTTP Server is actually embedded in your application, which means you can expose almost all your application logic through the Handler type, which you can also initialize appropriately. API Documentation ~~~~~~~~~~~~~~~~~ The following sections assume that the following file has been included: .. code-block:: c++ #include And that the following typedef's have been put in place: .. code-block:: c++ struct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()(http_server::request const & request, http_server::response & response) { // do something here } }; Constructor ``````````` ``explicit http_server(options)`` Construct an HTTP Server instance, passing in a ``server_options`` object. The following table shows the supported options in ``server_options``. +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | Parameter Name | Type | Description | +=======================+==========================================+==================================================================================================+ | address | string_type | The hostname or IP address from which the server should be bound to. This parameter is required. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | port | string_type | The port to which the server should bind and listen to. This parameter is required. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | thread_pool | ``shared_ptr`` | A shared pointer to an instance of ``boost::network::utils::thread_pool`` -- this is the | | | | thread pool from where the handler is invoked. This parameter is only applicable and required | | | | for ``async_server`` instances. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | io_service | ``shared_ptr`` | An optional lvalue to an instance of ``boost::asio::io_service`` which allows the server to use | | | | an already-constructed ``boost::asio::io_service`` instance instead of instantiating one that it | | | | manages. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | reuse_address | ``bool`` | A boolean that specifies whether to re-use the address and port on which the server will be | | | | bound to. This enables or disables the socket option for listener sockets. The default is | | | | ``false``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | report_aborted | ``bool`` | A boolean that specifies whether the listening socket should report aborted connection attempts | | | | to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for | | | | future-proofing the code in case an optional error handler function is supported in later | | | | releases of cpp-netlib. The default is ``false``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | receive_buffer_size | ``int`` | The size of the socket's receive buffer. The default is defined by Boost.Asio and is | | | | platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | send_buffer_size | ``int`` | The size of the socket's send buffer. The default is defined by Boost.Asio and is | | | | platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | receive_low_watermark | ``int`` | The size of the socket's low watermark for its receive buffer. The default is defined by | | | | Boost.Asio and is platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | send_buffer_size | ``int`` | The size of the socket's send low watermark for its send buffer. The default is defined by | | | | Boost.Asio and is platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | non_blocking_io | ``bool`` | An optional bool to define whether the socket should use non-blocking I/O in case the platform | | | | supports it. The default is ``true``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | linger | ``bool`` | An optional bool to determine whether the socket should linger in case there's still data to be | | | | sent out at the time of its closing. The default is ``true``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | linger_timeout | ``int`` | An optional int to define the timeout to wait for socket closes before it is set to linger. | | | | The default is ``0``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | context | ``shared_ptr`` | An optional shared pointer to an instance of ``boost::asio::ssl::context`` -- this contains the | | | | settings needed to support SSL. This parameter is only applicable for ``async_server`` instances.| +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ To use the above supported named parameters, you'll have code that looks like the following: .. code-block:: c++ using namespace boost::network::http; // parameters are in this namespace handler handler_instance; sync_server::options options(handler_instance); options.address("0.0.0.0") .port("80") .io_service(boost::make_shared()) .reuse_address(true); sync_server instance(options); instance.run(); Public Members `````````````` The following definitions assume that a properly constructed ``http_server`` instance has been constructed in the following manner: .. code-block:: c++ handler_type handler; http_server::options options(handler); http_server server(options.address("127.0.0.1").port("8000")); ``server.run()`` Run the HTTP Server event loop. This function can be run on multiple threads following the example: .. code-block:: c++ boost::thread t1(boost::bind(&http_server::run, &server)); boost::thread t2(boost::bind(&http_server::run, &server)); server.run(); t1.join(); t2.join(); ``server.stop()`` Stop the HTTP Server acceptor and wait for all pending requests to finish. Response Object ``````````````` The response object has its own public member functions which can be very helpful in certain simple situations. ``response = http_server::response::stock_reply(status, body)`` Code like the above should go inside the handler's ``operator()`` overload. The body parameter is an ``std::string``. The status parameter is any of the following values from the ``http_server::response`` enum ``status_type``: .. code-block:: c++ enum status_type { ok = 200, created = 201, accepted = 202, no_content = 204, multiple_choices = 300, moved_permanently = 301, moved_temporarily = 302, not_modified = 304, bad_request = 400, unauthorized = 401, forbidden = 403, not_found = 404, not_supported = 405, not_acceptable = 406, internal_server_error = 500, not_implemented = 501, bad_gateway = 502, service_unavailable = 503 }; The response object also has the following publicly accessible member values which can be directly manipulated by the handler. +------------------+----------------------+------------------------------------+ | Member Name | Type | Description | +==================+======================+====================================+ | status | ``status_type`` | The HTTP status of the response. | +------------------+----------------------+------------------------------------+ | headers | ``vector

`` | Vector of headers. [#]_ | +------------------+----------------------+------------------------------------+ | content | ``string_type`` [#]_ | The contents of the response. | +------------------+----------------------+------------------------------------+ .. [#] A header is a struct of type ``response_header``. An instance always has the members ``name`` and ``value`` both of which are of type ``string_type``. .. [#] ``string_type`` is ``boost::network::string::type``. Asynchronous Servers -------------------- The asynchronous server implementation is significantly different to the synchronous server implementation in three ways: #. **The Handler instance is invoked asynchronously**. This means the I/O thread used to handle network-related events are free to handle only the I/O related events. This enables the server to scale better as to the number of concurrent connections it can handle. #. **The Handler is able to schedule asynchronous actions on the thread pool associated with the server.** This allows handlers to perform multiple asynchronous computations that later on perform writes to the connection. #. **The Handler is able to control the (asynchronous) writes to and reads from the HTTP connection.** Because the connection is available to the Handler, that means it can write out chunks of data at a time or stream data through the connection continuously. The asynchronous server is meant to allow for better scalability in terms of the number of concurrent connections and for performing asynchronous actions within the handlers. If your application does not need to write out information asynchronously or perform potentially long computations, then the synchronous server gives a generally better performance profile than the asynchronous server. The asynchronous server implementation is available from a single user-facing template named ``async_server``. This template takes in a single template parameter which is the type of the Handler to be called once a request has been parsed from a connection. An instance of Handler is taken as a reference to the constructor similar to the synchronous server implementation. .. warning:: The asynchronous server implementation, like the synchronous server implementation, does not perform any synchronization on the calls to the Handler invocation. This means if your handler contains or maintains internal state, you are responsible for implementing your own synchronization on accesses to the internal state of the Handler. The general pattern for using the ``async_server`` template is shown below: .. code-block:: c++ struct handler; typedef boost::network::http::async_server http_server; struct handler { void operator()( http_server::request const & req, http_server::connection_ptr connection ) { // handle the request here, and use the connection to // either read more data or write data out to the client } }; API Documentation ~~~~~~~~~~~~~~~~~ The following sections assume that the following file has been included: .. code-block:: c++ #include #include And that the following typedef's have been put in place: .. code-block:: c++ struct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()(http_server::request const & request, http_server::connection_ptr connection) { // do something here } }; Constructor ``````````` ``explicit http_server(options)`` Construct an HTTP server instance passing in a ``server_options`` instance. Public Members `````````````` The following definitions assume that a properly constructed ``http_server`` instance has been constructed in the following manner: .. code-block:: c++ handler_type handler; http_server::options options(handler); options.thread_pool(boost::make_shared(2)); http_server server(options.address("127.0.0.1").port("8000")); ``server.run()`` Run the HTTP Server event loop. This function can be run on multiple threads following the example: .. code-block:: c++ boost::thread t1(boost::bind(&http_server::run, &server)); boost::thread t2(boost::bind(&http_server::run, &server)); server.run(); t1.join(); t2.join(); ``server.stop()`` Stop the HTTP Server acceptor and wait for all pending requests to finish. Connection Object ````````````````` The connection object has its own public member functions which will be the primary means for reading from and writing to the connection. ``template write(Range range)`` The connection object exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept. The write function, although it looks synchronous, starts of a series of asynchronous writes to the connection as soon as the range is serialized to appropriately sized buffers. To use this in your handler, it would look something like this: .. code-block:: c++ connection->write("Hello, world!"); std::string sample = "I have a string!"; connection->write(sample); ``template void write(Range range, Callback callback)`` The connection object also exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept, as well as a Callback function that returns ``void`` and takes a ``boost::system::error_code`` as a parameter. This overload of ``write`` is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory right away. ``template void read(ReadCallback callback)`` The connection object has a function ``read`` which can be used to read more information from the connection. This ``read`` function takes in a callback that can be assigned to a Boost.Function_ with the signature ``void(input_range,error_code,size_t,connection_ptr)``. The following list shows what the types actually mean: * **input_range** -- ``boost::iterator_range`` : The range that denotes the data read from the connection. * **error_code** -- ``boost::system::error_code`` : The error code if there were any errors encountered from the read. * **size_t** -- ``std::size_t`` : The number of bytes transferred. * **connection_ptr** -- ``http_server::connection_ptr`` : A handle to the current connection, so that it is kept alive at the time of the read callback invocation. This interface is useful when doing reads of uploaded data that can be potentially large and may not fit in memory. The read handler is then responsible for dealing with the chunks of data available from the connection. ``void set_status(status_t new_status)`` The ``set_status`` function takes a parameter of type ``status_t`` which is an enum type nested in ``http_status::connection`` which is given in the following code listing. .. code-block:: c++ enum status_t { ok = 200 , created = 201 , accepted = 202 , no_content = 204 , multiple_choices = 300 , moved_permanently = 301 , moved_temporarily = 302 , not_modified = 304 , bad_request = 400 , unauthorized = 401 , forbidden = 403 , not_found = 404 , not_supported = 405 , not_acceptable = 406 , internal_server_error = 500 , not_implemented = 501 , bad_gateway = 502 , service_unavailable = 503 }; .. note:: You may set and re-set the status several times as long as you have not set the headers or sent data through the connection. If you do this after data has already been set, the function will throw an instance of ``std::logic_error``. ``template void set_headers(Range range)`` The ``set_headers`` function takes a Single Pass Range of ``boost::network::http::response_header`` instances and linearizes them to a buffer with at most ``BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE`` and immediately schedules an asynchronous write once that is done. The function throws an instance of ``std::logic_error`` if you try to set the headers for a connection more than once. Adding SSL support to Asynchronous Server ----------------------------------------- In order to setup SSL support for an Asynchronous Server, it is best to start from a regular Asynchronous Server (see above). Once this server is setup, SSL can be enabled by adding a Boost.Asio.Ssl.Context_ to the options. The settings that can be used are defined in the link. .. code-block:: c++ // Initialize SSL context boost::shared_ptr ctx = boost::make_shared(boost::asio::ssl::context::sslv23); ctx->set_options( boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use); // Set keys ctx->set_password_callback(password_callback); ctx->use_certificate_chain_file("server.pem"); ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem); ctx->use_tmp_dh_file("dh512.pem"); handler_type handler; http_server::options options(handler); options.thread_pool(boost::make_shared(2)); http_server server(options.address("127.0.0.1").port("8442").context(ctx)); std::string password_callback(std::size_t max_length, boost::asio::ssl::context_base::password_purpose purpose) { return std::string("test"); } .. _Boost.Range: http://www.boost.org/libs/range .. _Boost.Function: http://www.boost.org/libs/function .. _Boost.Asio.SSL.Context: http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/ssl__context.html cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/references.txt000066400000000000000000000020141240331347200270230ustar00rootroot00000000000000References ========== About :mod:`cpp-netlib` ~~~~~~~~~~~~~~~~~~~~~~~ * `BoostCon 2010 Slides`_ * `BoostCon 2010 Paper`_ Other sources ~~~~~~~~~~~~~ * `Template Metaprogramming`_: The best guide to C++ template metaprogramming. * `HTTP 1.0`_: The HTTP 1.0 specification. * `HTTP 1.1 (RFC 2616)`_: The HTTP 1.1 specification. * `URI Generic Syntax (RFC 3986)`_: Generic URI syntax specification. * `Format for Literal IPv6 Addresses in URLs (RFC 2732)`_: Literal IPv6 Addresses in URLs. .. _`BoostCon 2010 Slides`: http://www.filetolink.com/b0e89d06 .. _`BoostCon 2010 Paper`: http://github.com/downloads/mikhailberis/cpp-netlib-boostcon-paper/cpp-netlib.pdf .. _`Template Metaprogramming`: http://www.boostpro.com/mplbook/ .. _`HTTP 1.0`: http://www.w3.org/Protocols/HTTP/1.0/spec.html .. _`HTTP 1.1 (RFC 2616)`: http://www.w3.org/Protocols/rfc2616/rfc2616.html .. _`URI Generic Syntax (RFC 3986)`: http://www.ietf.org/rfc/rfc3986.txt .. _`Format for Literal IPv6 Addresses in URLs (RFC 2732)`: http://www.ietf.org/rfc/rfc2732.txt cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/techniques.txt000066400000000000000000000004111240331347200270510ustar00rootroot00000000000000Techniques ========== The :mod:`cpp-netlib` uses several advanced techniques to achieve it's aims. This chapter describes some of those techniques. .. toctree:: :maxdepth: 1 techniques/tag_metafunctions techniques/directives techniques/polymorphism cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/techniques/000077500000000000000000000000001240331347200263145ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/techniques/directives.txt000066400000000000000000000066741240331347200312330ustar00rootroot00000000000000Directives ========== 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 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 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. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/techniques/polymorphism.txt000066400000000000000000000065001240331347200316200ustar00rootroot00000000000000Static and dynamic polymorphism =============================== With a header only library, you can only do so much with static polymorphism alone. There are some situations where you have to handle dynamic polymorphism because of unavoidable runtime-based decision making. Although you can deal with the base types that remain static, behavior can vary greatly which derived type should be handling the situation based on runtime values. This situation comes up in the :mod:`cpp-netlib` when we decide what kind of connection handler to use for a given HTTP URI -- whether it's plain HTTP or HTTPS. Although the HTTP semantics are the same for HTTP and HTTPS the implementation of the connection handler greatly varies on whether to use a plain TCP connection or an SSL-wrapped TCP connection. The general pattern or technique is to combine tag-based dispatch with a strategy factory, all while not requiring any externally built libraries. Doing it in a header-only library requires a little creativity and additional layers of indirection that you otherwise will not need for a library with externally built static/dynamic libraries. First we define the base type which we want to support dynamic behavior with. There's nothing special with the base type, except that it supports the tag dispatch earlier defined and has a virtual destructor. In code it looks like this: .. code-block:: c++ template struct base { virtual void foo() = 0; // make this an abstract base virtual ~base() { // do the base destructor thing here. } }; We then define a set of derived types that specialize the implementation of the ``foo`` member function. To facilitate the dispatch of the correct type based on an input, we create a strategy factory function: .. code-block:: c++ template unique_ptr > strategy(int input, Tag) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; // ... default: ptr.reset(0); break; } return ptr; } unique_ptr > ptr = strategy(input, default_()); // input is a runtime value The strategy factory can be a standalone function, or a static member of a factory class that is specialized by tag dispatch. This can be done like the following: .. code-block:: c++ template struct strategy; template <> struct strategy { static unique_ptr > create(int input) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; //... default: ptr.reset(0); break; } return ptr; } }; This approach allows the header-only libraries to define new dynamic types in subsequent versions of the library while keeping the static-dynamic bridge fluid. The only down-side to this is the possibility of derived type explosion in case there are a lot of different strategies or specializations available -- this though is not unique to static-dynamic bridging, but is also a problem with pure object oriented programming with dynamic polymorphism. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/techniques/tag_metafunctions.txt000066400000000000000000000130661240331347200325750ustar00rootroot00000000000000Tag metafunctions ================= Sometimes you want to vary a function or a type's behavior based on a static parameter. In the :mod:`cpp-netlib` there are a number of things you might want to change based on some such parameter -- like what the underlying string type should be and how large a buffer should be, among other things. The primary way to define this in a header-only manner is to use tag-based metafunctions. The skeleton of the approach is based on a similar technique for defining type traits. In the :mod:`cpp-netlib` however the type traits are defined on opaque tag types which serve to associate results to a family of metafunctions. Template Specialization ----------------------- To illustrate this point, let's define a tag ``default_`` which we use to denote the default implementation of a certain type ``foo``. For instance we decide that the default string type we will use for ``default_`` tagged ``foo`` specializations will be an ``std::string``. In the :mod:`cpp-netlib` this is done by defining a ``string`` metafunction type that is specialized on the tag ``default_`` whose nested ``type`` result is the type ``std::string``. In code this would translate to: .. code-block:: c++ template struct string { typedef void type; }; struct default_; template <> struct string { typedef std::string type; }; Template Metaprogramming ------------------------ Starting with version 0.7, the tag dispatch mechanism changed slightly to use Boost.MPL_. The idea is still the same, although we can get a little smarter than just using template specializations. Instead of just defining an opaque type ``default_``, we use the Boost.MPL equivalent of a vector to define which root types of properties this ``default_`` tag supports. The idea is to make the opaque type ``default_`` inherit property tags which the library supports internally as definite extension points. .. _Boost.MPL: http://www.boost.org/libs/mpl/index.html Our definition of the ``default_`` tag will then look something like the following: .. code-block:: c++ typedef mpl::vector default_tags; template struct components; typedef mpl::inherit_linearly< default_tags, mpl::inherit >::type default_; template struct components { typedef default_tags type; }; In the above listing, ``default_string`` is what we call a "root" tag which is meant to be combined with other "root" tags to form composite tags. In this case our composite tag is the tag ``default_``. There are a number of these "root" tags that :mod:`cpp-netlib` provides. These are in the namespace ``boost::network::tags`` and are defined in ``boost/network/tags.hpp``. Using this technique we change slightly our definition of the ``string`` metafunction class into this: .. code-block:: c++ template struct unsupported_tag; template struct string : mpl::if_< is_base_of< tags::default_string, Tag >, std::string, unsupported_tag > {}; Notice that we don't have the typedef for ``type`` in the body of ``string`` anymore, but we do inherit from ``mpl::if_``. Since ``mpl::if_`` is a template metafunction itself, it contains a definition of the resulting ``type`` which ``string`` inherits. You can see the real definition of the ``string`` metafunction in ``boost/network/traits/string.hpp``. Using Tags ---------- Once we have the defined tag, we can then use this in the definition of our types. In the definition of the type ``foo`` we use this type function ``string`` and pass the tag type parameter to determine what to use as the string type in the context of the type ``foo``. In code this would translate into: .. code-block:: c++ template struct foo { typedef typename string::type string_type; // .. use string_type where you need a string. }; Using this approach we can support different types of strings for different tags on the type ``foo``. In case we want to use a different type of string for the tag ``default_`` we only change the composition of the ``string_tags`` MPL vector. For example, in :mod:`cpp-netlib` there is a root tag ``default_wstring`` which causes the ``string`` metafunction to define ``std::wstring`` as the resulting type. The approach also allows for the control of the structure and features of types like ``foo`` based on the specialization of the tag. Whole type function families can be defined on tags where they are supported and ignored in cases where they are not. To illustrate let's define a new tag ``swappable``. Given the above definition of ``foo``, we want to make the ``swappable``-tagged ``foo`` define a ``swap`` function that extends the original ``default_``-tagged ``foo``. In code this would look like: .. code-block:: c++ struct swappable; template <> struct foo : foo { void swap(foo & other) { // ... } }; We also for example want to enable an ADL-reachable ``swap`` function: .. code-block:: c++ struct swappable; inline void swap(foo & left, foo & right) { left.swap(right); } Overall what the tag-based definition approach allows is for static definition of extension points that ensures type-safety and invariants. This keeps the whole extension mechanism static and yet flexible. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_sources/whats_new.txt000066400000000000000000000211121240331347200267010ustar00rootroot00000000000000.. _whats_new: ************ What's New ************ :mod:`cpp-netlib` 0.11 ---------------------- v0.11.1 ~~~~~~~ * Add support for request timeouts. * Build configuration fixes. * Support for Travis CI in-project config. * Make the response parser more flexible to support older/ad-hoc servers that don't have standard format responses. * Fix some instability in the client destructor. * MSVC 2010 specific fixes. v0.11.0 ~~~~~~~ * Fix thread leak in DNS resolution failure (`#245`_) * Remove unsupported `client_fwd.hpp` header (`#277`_) * Remove support for header-only usage (`#129`_) -- this means that the BOOST_NETWORK_NO_LIB option is no longer actually supported. * Deprecate Synchronous Client implementations (`#279`_) * Support streaming body chunks for PUT/POST client requests (`#27`_) * Fix non-case-sensitive header parsing for some client tags (`#313`_) * Remove unsupported Jamfiles from the whole project (`#316`_) * Add ``make install`` for Linux and OS X (`#285`_) * Fix incorrect Body processing (`#69`_) * Support chunked transfer encoding from HTTP responses (`#86`_) * Make OS X Clang builds use C++11 and libc++. * Update Boost requirement to 1.54.0. * Experimental Base64 encoding/decoding library (`#287`_) * *Known test failure:* OS X Xcode Clang 5.0 + Boost 1.54.0 + libc++ don't play well with Boost.Serialization issues, mitigate test breakage but ``cpp-netlib-utils_base64_test`` still fails in this platform. (`#287`_) * Provide a client option to always validate peers for HTTPS requests made by the client. (`#349`_) * Back-port fix for `#163`_ for improved URI parsing. * Added support for client-side certificates and private keys (`#361`_). .. _`#129`: https://github.com/cpp-netlib/cpp-netlib/issues/129 .. _`#163`: https://github.com/cpp-netlib/cpp-netlib/issues/163 .. _`#245`: https://github.com/cpp-netlib/cpp-netlib/issues/245 .. _`#277`: https://github.com/cpp-netlib/cpp-netlib/issues/277 .. _`#279`: https://github.com/cpp-netlib/cpp-netlib/issues/279 .. _`#27`: https://github.com/cpp-netlib/cpp-netlib/issues/27 .. _`#285`: https://github.com/cpp-netlib/cpp-netlib/issues/285 .. _`#287`: https://github.com/cpp-netlib/cpp-netlib/issues/287 .. _`#313`: https://github.com/cpp-netlib/cpp-netlib/issues/313 .. _`#316`: https://github.com/cpp-netlib/cpp-netlib/issues/316 .. _`#349`: https://github.com/cpp-netlib/cpp-netlib/issues/349 .. _`#69`: https://github.com/cpp-netlib/cpp-netlib/issues/69 .. _`#86`: https://github.com/cpp-netlib/cpp-netlib/issues/86 .. _`#361`: https://github.com/cpp-netlib/cpp-netlib/pull/361 :mod:`cpp-netlib` 0.10 ---------------------- v0.10.1 ~~~~~~~ * Documentation updates (`#182`_, `#265`_, `#194`_, `#233`_, `#255`_) * Fix issue with async server inadvertently stopping from listening when accepting a connection fails. (`#172`_) * Allow overriding and ultimately removing defaulted headers from HTTP requests. (`#263`_) * Add `-Wall` to the base rule for GCC builds. (`#264`_) * Make the server implementation throw on startup errors. (`#166`_) .. _`#182`: https://github.com/cpp-netlib/cpp-netlib/issues/182 .. _`#265`: https://github.com/cpp-netlib/cpp-netlib/issues/265 .. _`#194`: https://github.com/cpp-netlib/cpp-netlib/issues/194 .. _`#172`: https://github.com/cpp-netlib/cpp-netlib/issues/172 .. _`#263`: https://github.com/cpp-netlib/cpp-netlib/issues/263 .. _`#233`: https://github.com/cpp-netlib/cpp-netlib/issues/233 .. _`#264`: https://github.com/cpp-netlib/cpp-netlib/issues/264 .. _`#255`: https://github.com/cpp-netlib/cpp-netlib/issues/255 .. _`#166`: https://github.com/cpp-netlib/cpp-netlib/issues/166 v0.10.0 ~~~~~~~ * Added support for more HTTP status codes (206, 408, 412, 416, 507). * Refactored the parser for chunked encoding. * Fixed parsing chunked encoding if the response body has ``CLRFCLRF``. * Added librt dependency on Linux. * Check the callback in the asynchronous client before calling it. * Fixed issues `#110`_, `#168`_, `#213`_. .. _`#110`: https://github.com/cpp-netlib/cpp-netlib/issues/110 .. _`#168`: https://github.com/cpp-netlib/cpp-netlib/issues/168 .. _`#213`: https://github.com/cpp-netlib/cpp-netlib/issues/213 :mod:`cpp-netlib` 0.9 --------------------- v0.9.5 ~~~~~~ * Removed dependency on Boost.Parameter from HTTP client and server. * Fixed for Clang error on Twitter example. * Added source port to the request (HTTP server). * Updated CMake config for MSVC 2010/2012. * Now support chunked content encoding in client response parsing. * Fixed bug with client not invoking callback when a request fails. v0.9.4 ~~~~~~ * Lots of URI fixes. * Fixed async_server's request handler so it doesn't make copies of the supplied handler. * Fix for issue `#73`_ regarding SSL connections ending in short read errors. * Final C++03-only release. .. _`#73`: https://github.com/cpp-netlib/cpp-netlib/issues/73 v0.9.3 ~~~~~~ * URI, HTTP client and HTTP server are now built as static libraries (``libcppnetlib-uri.a``, ``libcppnetlib-client-connections.a`` and ``libcppnetlib-server-parsers.a`` on Linux and ``cppnetlib-uri.lib``, ``cppnetlib-client-connections.lib`` and ``cppnetlib-server-parsers.lib`` on Windows). * Updated URI parser. * A new URI builder. * URI support for IPv6 RFC 2732. * Fixed issues `#67`_, `#72`_, `#78`_, `#79`_, `#80`_, `#81`_, `#82`_, `#83`_. * New examples for the HTTP client, including an Atom feed, an RSS feed and a very simple client that uses the Twitter Search API. .. _`#67`: https://github.com/cpp-netlib/cpp-netlib/issues/67 .. _`#72`: https://github.com/cpp-netlib/cpp-netlib/issues/72 .. _`#78`: https://github.com/cpp-netlib/cpp-netlib/issues/78 .. _`#79`: https://github.com/cpp-netlib/cpp-netlib/issues/79 .. _`#80`: https://github.com/cpp-netlib/cpp-netlib/issues/80 .. _`#81`: https://github.com/cpp-netlib/cpp-netlib/issues/81 .. _`#82`: https://github.com/cpp-netlib/cpp-netlib/issues/82 .. _`#83`: https://github.com/cpp-netlib/cpp-netlib/issues/83 v0.9.2 ~~~~~~ * Critial bug fixes to v0.9.1. v0.9.1 ~~~~~~ * Introduced macro ``BOOST_NETWORK_DEFAULT_TAG`` to allow for programmatically defining the default flag to use throughout the compilation unit. * Support for streaming body handlers when performing HTTP client operations. See documentation for HTTP client interface for more information. * Numerous bug fixes from v0.9.0. * Google, Inc. contributions. v0.9.0 ~~~~~~ * **IMPORTANT BREAKING CHANGE**: By default all compile-time heavy parser implementations are now compiled to external static libraries. In order to use :mod:`cpp-netlib` in header-only mode, users must define the preprocessor macro ``BOOST_NETWORK_NO_LIB`` before including any :mod:`cpp-netlib` header. This breaks code that relied on the version 0.8.x line where the library is strictly header-only. * Fix issue #41: Introduce a macro ``BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG`` which makes the default HTTP client use ``tags::http_async_8bit_udp_resolve`` as the tag. * Fix issue #40: Write the status line and headers in a single buffer write instead of two writes. * More consistent message API for client and server messages (request and response objects). * Refactoring of internal implementations to allow better separation of concerns and more manageable coding/documentation. * Client and server constructors that support Boost.Parameter named parameters. * Client and server constructors now take in an optional reference to a Boost.Asio ``io_service`` to use internally. * Documentation updates to reflect new APIs. :mod:`cpp-netlib` 0.8 --------------------- * Updates to URI unit tests and documentation. * More documentation, covering the HTTP Client and HTTP Server APIs * Asynchronous HTTP Server that now supports running request handlers on a different thread pool. * An initial thread pool implementation, using Boost.Asio underneath. * Adding a ready(...) wrapper to check whether a response object returned by the asynchronous client in 0.7 already has all the parts available. * Some attempts at lowering compile time costs. :mod:`cpp-netlib` 0.7 --------------------- * Radical documentation overhaul * Asynchronous HTTP client * Tag dispatch overhaul, using Boost.MPL * HTTP Client Facade refactoring * Bug fixes for HTTP 1.1 response parsing * Minimized code repetition with some header macro's * Configurable HTTPS support in the library with ``BOOST_NETWORK_ENABLE_HTTPS`` :mod:`cpp-netlib` 0.6 --------------------- * Many fixes for MSVC compiler :mod:`cpp-netlib` 0.5 --------------------- * An embeddable HTTP 1.1 server * An HTTP 1.1 client upgraded to support HTTPS * An updated URI parser implementation * An asynchronous HTTP 1.1 client * An HTTP 1.1 client that supports streaming function handlers cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/000077500000000000000000000000001240331347200237505ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/Button-Info-icon.png000066400000000000000000000066531240331347200275620ustar00rootroot00000000000000‰PNG  IHDR00Wù‡ rIDATxÚÕZ tUÅþþ·å%/ yYH€@•¥).E‹ZZµÅc¡uG=¥ñ¸´µ.ôTE-9UZí±(+Z·** E(Å‚ d_Èò²¼eúϹïÞûÞKjíéœóŸ;™wïÜùþÿû—™‘k™,ãXƲŒd)`ñéßúXYö±ìbù¥óH¼”¾âóCY.fùËd– Û¼b€~ˆe+ËßXžf9øM8‘eËù,iÆHZ6¡p´@p=„pyÔ;bîV ½–к_ þc ·ÝÓËò<ËR–÷¾n£Xîc™ÅââE%S™0ßa”ñlj:â«×Cpé¿cB Ì„І×Æ=L¨·½oÂÇ·±<Ër ËgG€‹åZ–»!¹ž9ÏÌ)Æ+M> ã†fQyq¶(+ `hŽŸ²üáuÓS8*DGOÛzhO}—¨¬iLJ‡:¨/cd½„ª×v2“:ä,KXÒ ¾2€,–5,2%æ ?ðúQœ›NçŒ-'—‘åwÿ'Þ;ú=Qzwo«xiW#Õ´t3àýu„kSNÞ²žežô¥H'•üœ€œbà,¶nA ò3}˜}B&È1Y“0k?ÓšJÚº¿ ëþU‡¦NV{ט¥m5òçP~Ö¯“@.þ–Ñ6‘0ýR”"Íë⇉$³å‚y"î+í~á>7sŽÞp ÏUÖÓ;lô°Ò_¹P½]ÞËéý耤 {Æ£”ôìEäIK–Ò„aÙB½Þ¶ xŸ„6€c¡ }bocì4¦(S¤û\D|ãnA;ªÛÅúÊzDzÙ7^]*Põ¶üa'ËÔTtJ@:ì3,aøD6àì§~Ì_ˆ‘yê ó);URª‚ðys7NžéÇå!ÔÅ“ÛëÐÒA~ÀgÝNJö5‡ðÌÎzöoö‹çïl—¿þ•e;Õk¯gYŽà0Â÷— ÊÈÂÌ1TR¡ÌMÚ!¥šÉn²´®Çû"1Ì>6Î, êq2h³|S öwôZú"n9 [Œ^ü¨Qˆ+ý/7rþ¨–s,dY9€Q†¹\žL\º’S©˜PœIòÕúHG"óI½nÕƒ=Ú0ÐA>7î?{d|ÜP×ч;6PãÒ l2z†%mc:íà‹ú*Ÿ¯—Ñ©Ó µ-O$xÚ0ÓI?N‡Ü€3ŽÍ¹ô‚­…[ô‰SŠ’f, úq×iÓL G±à…½Š:&dÔ¸à4ñòîf´Èè´‰#ùæ?AÓûâTdy°ƒŠWVpiA§ Š<a¤V‚²€²„ @kõÆ- ­ás»ð茑”ís;,ð^]îÝ\cjÛ´„"£"> §ðæ®0Þú¬•ÐøÃ|àpüu tÙa°Ö@vÎMÎG~–&qfÕZ× A|ܤ”Œ1 TzBa€O>JdØåöy{¯¸mS5šBÒµ…b0û"ÞßVÓNMÉ°ƒSÒKfÊ\;ó«ÈõãÚ'¹öã[C² kI¤P"•RE%[Ëb_——Žvê9Âpia£‹îب¿Æ ha+|PÇÎ,£ÒC—]-=’¡,Í7ÞÈò;L™K8ûáæÚ†µ/«1¤é¹oD—8…´¬DFfì—ãBh©d'L7û:‘ ÛïBý˜ˆ÷±D4Êô•U„-kåèÍ,ËL¯³œùÅ£1(Ë‘¹*# d¸öi@gŽk6mîñDí;- #ÿ¾–w‡jNÌWɧß`™&_#wRuÈÈÉÀÏ×Ün18ˇ¼€O[@ÐÊs™> yoúIœãJ³¯;‚¾î0¹#B ñ»‘›æ¡Ú€Wô™•†-Ç5yÓ>ÓþÀhîê 2E¢„û/µÉMQi~Ç \~±èÂì4d¦ylôBû ZtGD!—ÍeƒÒ¨,7]ŒÀ˜¢ úE;qg$F'o¨âÛböˆc û1íÐr#¡töFD}{¯ÑÇ‹>Ù$•p²\ÆY*pÆ\2-0èRÀÕ¦ŸÏ ŽA²è”Ø7©ÃýE,*Œ2¶ ¥pè×j;qå;5ýÐGQ%©SÒù£±ƒ)“~°š ô¸œe¾|˯YnÅÜÛ€IçZ²ø¼.e—iÙS)¥ÌzuYnWàˆý²ÿ‹÷h¬6ÔÚ5, éÓÖàq¹ùi …Õ=Û^X+—ßÈ—>ʲó—qá<ÅXt¶ß¯€\¨ËôòƒåÜ=/?ƒ;¥8 ÀÄW÷Ñ®°E ´bÌN!;0€¨±«3îÿx‹@… œX-<Ær®Y”Mxc•Îôa XJE¥rÃm#ágÇ:èóIG/¦¼q 9ÖÛ¯±dê˜Â@7W³9dW§«®–Ó>n˜‡ëŽ™dhÚËOK¤iÓ±íÑÉN'žÿí‡Ðø¢€Ã+>kÃ’›“6)òX´±÷yÃ#"Òù£<¾{›Àƒ€5…®á*uìIj\Ãø%w ³QHpAE¸>¿Ô¨%ìfn­ÅÆænMà Ì0iˆû@^t<‰LŽïÚ,°êú8…¤7,ÁîN:Ï \.¸ee êïTTJŒHê:/' «§ uЧ•#ÈÈ7«ŠÆRÐÆF™Ô‘”‰ñsшPHRhóàwÈ©ï6ÃèjÌäzÁÕ¬u—Ћ&.), ¸m²@˜ù!N¡µ%9˜5*w\iõ ]bNe£=yé¤eXÃ>—ª5@Ö?,ðâj9ß+‘:ïÅ–Y´qËź±%x? j!·ºš–P5’®…¸¥s¤80u8rÓ½?ù´YTêŒ×?ªîjGfÖ<¼P£S 5û"¢µè„•7 ¼¿1žÈT)‘ `9—DwœFÆÕN!·™ ~—O[þ€i\¾vJ±#‰qÒmµø¼'ÚoµiÐÈAMM!­yuð< §­]f)as§ãö' eåŠBn…Ü–5ÔÕæÄμ@¿ÍO7óæÝû+¹î_Ù ·XHUë$Gžh ­Gcj¼ª’p×erîf1g•ÓßG¸|‘À­¸\–¸h@Ä/ù`tžÃu¿À½u]t+—ÂŽìëÌ´)yo,:¦Õã2<±”ð÷5Iå´ÚÐ Ê÷cÅË@zº¢‹›¬«‹œÔrÙÆG GšÝLWB 4uO Þ’Udgî†.Dä¤P49êÄébHÌqºpÐÖ”´¡‘Mm)Ü)0ãöŠçƒ:†5l´Š;º²Àµ>7­L¨ÚøÅ5Q”µwis7¦Ž+ ŸÖv$[À¡uM!3òÄb–^~ øý)·”²©Mýà¡„ågM€ö·€•­7dÐÌ£2žcÍ_TÝNÇîmÿ8ãhœYÛIŸöD¬ºÇN¡¨m¡v0Ç»ºnà<Õx°ßM½lòÈb.¹¸l!±¶'5#ŒÂÌ nG~À¡Ò\*Hsž>T|Ô„¥;hÃô‘bkø‘ÖîTeƒÓTÉË à‰åO=(§_‡~ŽUdS[oàûÊÆòâç½™Sø…–CÇä"(Çš «Ù77… RjHâ|”kžp$fùÀî]ÀM³9„†åÙè€[²©£Åa%„eÏä 0ÁUª=Ñ9(ô0ï¼~ésX@®mEGýêp¯ˆšÇ&ÉÅš"µ5º9 „Ãl™D·²ãÎ!TïýBG‹²Y‡»“Nãj£‚£’ß°D.ïk=n{‚³,àßçøqVºÇ˜`''œŠ®0¶öj·%. u"¬ñ™ô¤z8Ø,™ÏlK®ë îÊf¯Ÿ~.pûrB†_x<.â÷Ç.Ž(¤2tò!€õŽä ‹©ù„š§–÷ÕFÙê!ür¡ÀÆ€ÿòxÝlÖŽoO%ÜÍT0H>¦ÒpÖrºÇ…„Ä–¼M`+—­i\åFÿ@OD}7keÚ,áÂòŸo~évêÓÎ÷ð¦gl¹Qfe:§yŒ$TrÛËl ¡îI(•ùZÓÁA¦,›±«XÌ›•ýUòɯô‰ÉN'õ‘Ïë#Ì¿A`>ûyV¦ŒL4ÌçżÍbG'Y/…Y‰BGìÌùŽˆ ®^«{£ÄG £¨XI¨X!6NŽŽÈG>³9?³\u0ûBfÀHl™^70½‚L­,öt¹5Õ‡¾LD·\#Ó¥•ÛÈté G÷;»ëžâ$ñ빚ð5|fµ7™'PToÜ/âŒ~Á,`â$ÀëÖyÖ'[YSÑ…Ã$¶ož{–c W0õÀ×ü¡;±%ÿ«A^>aòòr.³J CŠ„~åæ Ô-P[Çåb¡²R`ë ¹Éüžðþ«Abû¿ýgTíòï6ÿèoË¡Ú…IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/Button-Warning-icon.png000066400000000000000000000055371240331347200302740ustar00rootroot00000000000000‰PNG  IHDR00Wù‡ &IDATxÚíZ tå¾÷ŸÉî†%Ï%!QP‡DEä!ˆ§>ŽhE©¯ƒ´‚B± E¥9R()bÑ*G«Å7ÖÇ©ÊCŠˆÈÃPÌXB6 ÙMfæöþóØÙ,µ¼zN7çcþùgöŸûý÷ûï½ÿ,ÿã<Ùœª|ŒK%öùVÆGŒÆS€ï׌ÇÅ)×*ÿ`ЩH@Ž5‹1^€Wt Ð/:Ìþ¿ŽÑå1Ð ó¾9Œ NJı$0žñ§PPÀ¢!¼¸£ß4ùCüYµ#ÃF0RoÈþßÙDN݃>ô-[çµó5™Íþü»F\Võ$×B/Fù©@@Žñ㊙Csè¾Ë²¸2[‘hÛ×¼nì]CÔ°ßì/[¥I‹kdÿÆ•ð_JéX¸–±¸k±*ÖL."Ÿ  œùKTûL"ôµ4ŸAu¤­ ÆÎa\#ê;# Û*5yí:Æ['“€\¥›g¿u_+|N&ˆ6:à19Ûž‰ÿ´U¿£òSXòe\û—²û+FOFìdaqæ•=°øÞÄŒLRÍÌ,@HJ#Ñf¡¶b4QÓa:ï¾·9&û+zpEŒ ¿ Ùk§A—â n qÖurP$ÛèÔ¶þÍ›¤ïx ¶ÿ aŸ©aŠkåK]áMàYƈqC²`æM¹À‹ÔÞS…ïÈ£J&F#hë§4€I/‚¹ï×Ê+ wžH½«[爌/+¦Ü–”η¡uçhS úWÿN+!¥óÄ@‘Í`l«9'œ;©÷ÕM|¹?cý‰ +Ï‘#. fµµóí¦TЗ ¢¨4-#¼Œ#Ò!³­o©v-ü°G/<(ûV1ÉÛŽ7›‹ÎmŸ«)EQ@tÎ ·ÐyF(îHûE}Çs@5†*>_º®Cÿ‡ÂðÅ.éÎxéxhÁØ&Ú½ÿp! ì@ÌëJX<ÐZ¬È@”s&$fÝ)%L_Îâ¶&#ªy¿^IT½ W–ÇhÈô*à"ã;¾­+ãðñ"0•ñ‡ëû¶€Ç…?ˆÓ¯T3=£)%“¹/èù"iõ oaŸØ½Œ=ïðµ8Ü27o¬9ì<ãǃ@{Æ– ƒæÃ…,üˆÙÉœNW¸T»²2Ûx=ÐðèÒ®ðÊmŠî@ªÞL»öépþøJ¬S_îÎØu¬ HmÞ4ùWÙ4eXk=غ?'\aš$ œ}/+ñ èV0¾ž×ŒÇU¤ªÕœÜêaÚË58㵨¼þ Xkí˜Èø°mHQ¶Ì+†`&ü¹Ýý!kôŽ&:Ü ¢`g£j»žµNœøäH):Tõ1º©„½^Ù—2V 2lÊøÜëùñ!6°…*!«£5ë¼pÍét<Àm¥í(ÚóxÀØû {_mæþ’Á}µ;xÃYƒ/¯¬§ÛçDä-ÁÊ7G «?†€ÌÏôëê§e3 Q(‚ãþ™l¥?IÀ‘MFA¥Ã}ú·e@UزI! {ô8@ÝNÔ5ƒJ'WÁ'ÛâÒ¶‘`eüŸM€§Êy‹Xüñã­¡wg?o׳½ÒI#!Ì犴ËLÏ@ZÅ$ êO-Ù¸%äjK)AcÖmÃ%÷É-¨ÜGËÍÒ¡ŸK@V‰÷ß^ħÆåO?B @HD·„oÏBµÇ h›o¨ÿÆ’™!ËÊÜŽä݆«b½épWÙA|~i½ì Öú'èÌؘ•‰-O·Á¢|–NFA kæåŸ}ŽVò’d|¹¨ž¿ÌŠEÀ mC)@Ó¡¤±DÖýdŽ`÷q[‹™)1°û¨¨¶ä^An?·ÿTr§tÍ#wäÀ„sÀœõŒLsªDrtˉׇzÞGœÌ²-uhQÐ>¿„g8ž”œ~WÛòXZHýÌzµzÎÜ~¾ ÖÎïG¸‚ñ~Ç6*}ödd’¢²„„%ጠ¤F$µçRÿé–b»©iÓå Ù˜2Ü‹˜0#’Áu b]pOvðÞ¯a|ðcÈ·j%¯>ÜŠ®éŸÉ¹Š,!i®±€p-¼IéòG« MFt-i7»’—½ŒÔ5@VÛ9ÁDo¯n€§vÊ·{çCÊÛ½tîe”]Ö+€ï>ZrÝšRIÙ0!¯Œx#‘ÌÊ@„,¯‘·@ÿvlóè“MòH%φNpÕäý°|£¹ýäA`ÞÑpM åªùëæa·>K."1óöÑ!³'ÒD!¹vCCId›Ù˜=°‚71‹›{ÀÈŒ¤WdY ¶ÄdùÎF¼pt˜4‚V«ŽD`>ã7w_ÝÊÆä³q<¤@›š"%…À$ädå„Ñé ¸ 5Û6k=ðö²´Æ>q¼#ë<ø+ct:òMòÆP¶P7ý­ ò.+}¶DLI¹¸ää9Ú#R´Ñ’€{ti}ŽÏ+Ÿ4r¤º”“•aµ=GVB$jÈJ½ì5áQîRÆesïÉ£»¯mÉaĤú™VÀò€8²9¡a ÿLÙRÖñ®m¾+¤ñ€[N²_·½¡7"ïhÁ?ë`Ü“Õr¼åŒËå(ù†ì’öøɼ"òxöý¹–Þm IÚ·gÜ!€Öy‚€zæ%äÝèÐwöËð#pä¤óSx/éÐoL·îj’#\ÏxÓL;ŒÏ=ß}¤K{ýy\ï·°(¶q–áÎÑ‘Ž\ÖÎy‚€rÆ»L ?…ÀAÐ÷\•ÌºF"' 5¤¬¶«ŸšÅ«aÙú^õà~9‚|#x4£cuŸ.>X9·ˆŸÎÖÏà@ŽV¸LÕ|³ Þ*¿rÚëüý|Ot &`|C3ý“[÷î¶ ò’?.Ôí63ôÀqaX[a¦ƒþò±SSfß•c®ËBðµ hÙ!yÜZ÷„M‹ˆ5ëÂF¹­¿ÀßÍózÀ¨£òÖô‰Œt$ ÙÞ2#RÝ·œÆãoÖÒý ªåðÓ$ù“Ïðå³ a@kŸËåìÎà2²¹RgßsdÛ Ÿfä¥x€ T²§3]Kã×¹¼NÑ &P «6Å t‚™ ÉÇʽî°³[C¿?W›\ó„.bÔÄìºfÚ›ÈÐã;"qgÆi|ŸðF!iAÓ÷¶(Y ¥Ì´g ¸ÚdhDÞOh~²%Fƒî7 ¼"ŸÎxðñQ¹0ö†l6ˆHÈ5SbIS$„Í£P32f‘Gv"K¾’Ø”B ¹ ¼„„ø¶èV2êws?bÙëQšø”¹ÇyT8±¾]"Ö-(‚ü\ÅšÝÌ"À¬.,©Vl¨HŸ¸< Ø[%Êk€æ峓  8jB#®J!~¨®¨!l&·ƒ5:\xW¾ÛoþdØÛyÄß·ô<+Ÿy D=:ùd2½ª0“Z"Œ*vÜfN†U®Xå5O$\åƒ;4êÖ¬ÚaÁNXäjó‘Yœ@3ÌY'hó×0rf7}cæ·9²‹¥\ÈQß?ôïáÇâ•·®<€Þ5ˆýÖâ5¯!ºÖŒ³ks[ï”Èn ؉N硲JÃÕ›ã´fk¸ “£.c eÔº«• °Š¤ß2N‡Só³‡ñg°ŠÎ&'B¤~dß¹`ývUÉãÉúHì+ó~)¿jþÿ?{œìÏ+~Å:d`G«IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/ajax-loader.gif000066400000000000000000000012411240331347200266240ustar00rootroot00000000000000GIF89aòÿÿÿU|ÆÖßN€U|l–®Š«¾™¶Æ!þCreated with ajaxload.info!ù !ÿ NETSCAPE2.0,3ºÜþ0ÊIkc:œN˜f E±1º™Á¶.`ÄÂqÐ-[9ݦ9 JkçH!ù ,4ºÜþNŒ! „ »°æŠDqBQT`1 `LE[¨|µußía€ ×â†C²%$*!ù ,6º2#+ÊAÈÌ”V/…côNñIBa˜«pð ̳½ƨ+YíüƒÃ2©dŸ¿!ù ,3ºb%+Ê2†‘ìœV_…‹¦ …! 1D‡aªF‚°ÑbR]ó=08,Ȥr9L!ù ,2ºr'+JçdðóL &vÃ`\bT”…„¹hYB)ÏÊ@é<Ã&,ȤR’!ù ,3º Â9ãtç¼Úž0Çà!.B¶ÊW¬¢1  sa»°5÷•0° ‰»Ÿm)J!ù ,2ºÜþð ÙœU]šîÚqp•`ˆÝaœÝ4–…AFÅ0`›¶ Â@›1€ÂÖΑ!ù ,2ºÜþ0ÊI«eBÔœ)×à ŽÇq10©Ê°®PÂaVÚ¥ ub‚ž[;cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/basic.css000066400000000000000000000204171240331347200255470ustar00rootroot00000000000000/* * basic.css * ~~~~~~~~~ * * Sphinx stylesheet -- basic theme. * * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ /* -- main layout ----------------------------------------------------------- */ div.clearer { clear: both; } /* -- relbar ---------------------------------------------------------------- */ div.related { width: 100%; font-size: 90%; } div.related h3 { display: none; } div.related ul { margin: 0; padding: 0 0 0 10px; list-style: none; } div.related li { display: inline; } div.related li.right { float: right; margin-right: 5px; } /* -- sidebar --------------------------------------------------------------- */ div.sphinxsidebarwrapper { padding: 10px 5px 0 10px; } div.sphinxsidebar { float: left; width: 230px; margin-left: -100%; font-size: 90%; } div.sphinxsidebar ul { list-style: none; } div.sphinxsidebar ul ul, div.sphinxsidebar ul.want-points { margin-left: 20px; list-style: square; } div.sphinxsidebar ul ul { margin-top: 0; margin-bottom: 0; } div.sphinxsidebar form { margin-top: 10px; } div.sphinxsidebar input { border: 1px solid #98dbcc; font-family: sans-serif; font-size: 1em; } div.sphinxsidebar #searchbox input[type="text"] { width: 170px; } div.sphinxsidebar #searchbox input[type="submit"] { width: 30px; } img { border: 0; } /* -- search page ----------------------------------------------------------- */ ul.search { margin: 10px 0 0 20px; padding: 0; } ul.search li { padding: 5px 0 5px 20px; background-image: url(file.png); background-repeat: no-repeat; background-position: 0 7px; } ul.search li a { font-weight: bold; } ul.search li div.context { color: #888; margin: 2px 0 0 30px; text-align: left; } ul.keywordmatches li.goodmatch a { font-weight: bold; } /* -- index page ------------------------------------------------------------ */ table.contentstable { width: 90%; } table.contentstable p.biglink { line-height: 150%; } a.biglink { font-size: 1.3em; } span.linkdescr { font-style: italic; padding-top: 5px; font-size: 90%; } /* -- general index --------------------------------------------------------- */ table.indextable { width: 100%; } table.indextable td { text-align: left; vertical-align: top; } table.indextable dl, table.indextable dd { margin-top: 0; margin-bottom: 0; } table.indextable tr.pcap { height: 10px; } table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2; } img.toggler { margin-right: 3px; margin-top: 3px; cursor: pointer; } div.modindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } div.genindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } /* -- general body styles --------------------------------------------------- */ a.headerlink { visibility: hidden; } h1:hover > a.headerlink, h2:hover > a.headerlink, h3:hover > a.headerlink, h4:hover > a.headerlink, h5:hover > a.headerlink, h6:hover > a.headerlink, dt:hover > a.headerlink { visibility: visible; } div.body p.caption { text-align: inherit; } div.body td { text-align: left; } .field-list ul { padding-left: 1em; } .first { margin-top: 0 !important; } p.rubric { margin-top: 30px; font-weight: bold; } img.align-left, .figure.align-left, object.align-left { clear: left; float: left; margin-right: 1em; } img.align-right, .figure.align-right, object.align-right { clear: right; float: right; margin-left: 1em; } img.align-center, .figure.align-center, object.align-center { display: block; margin-left: auto; margin-right: auto; } .align-left { text-align: left; } .align-center { text-align: center; } .align-right { text-align: right; } /* -- sidebars -------------------------------------------------------------- */ div.sidebar { margin: 0 0 0.5em 1em; border: 1px solid #ddb; padding: 7px 7px 0 7px; background-color: #ffe; width: 40%; float: right; } p.sidebar-title { font-weight: bold; } /* -- topics ---------------------------------------------------------------- */ div.topic { border: 1px solid #ccc; padding: 7px 7px 0 7px; margin: 10px 0 10px 0; } p.topic-title { font-size: 1.1em; font-weight: bold; margin-top: 10px; } /* -- admonitions ----------------------------------------------------------- */ div.admonition { margin-top: 10px; margin-bottom: 10px; padding: 7px; } div.admonition dt { font-weight: bold; } div.admonition dl { margin-bottom: 0; } p.admonition-title { margin: 0px 10px 5px 0px; font-weight: bold; } div.body p.centered { text-align: center; margin-top: 25px; } /* -- tables ---------------------------------------------------------------- */ table.docutils { border: 0; border-collapse: collapse; } table.docutils td, table.docutils th { padding: 1px 8px 1px 5px; border-top: 0; border-left: 0; border-right: 0; border-bottom: 1px solid #aaa; } table.field-list td, table.field-list th { border: 0 !important; } table.footnote td, table.footnote th { border: 0 !important; } th { text-align: left; padding-right: 5px; } table.citation { border-left: solid 1px gray; margin-left: 1px; } table.citation td { border-bottom: none; } /* -- other body styles ----------------------------------------------------- */ ol.arabic { list-style: decimal; } ol.loweralpha { list-style: lower-alpha; } ol.upperalpha { list-style: upper-alpha; } ol.lowerroman { list-style: lower-roman; } ol.upperroman { list-style: upper-roman; } dl { margin-bottom: 15px; } dd p { margin-top: 0px; } dd ul, dd table { margin-bottom: 10px; } dd { margin-top: 3px; margin-bottom: 10px; margin-left: 30px; } dt:target, .highlighted { background-color: #fbe54e; } dl.glossary dt { font-weight: bold; font-size: 1.1em; } .field-list ul { margin: 0; padding-left: 1em; } .field-list p { margin: 0; } .refcount { color: #060; } .optional { font-size: 1.3em; } .versionmodified { font-style: italic; } .system-message { background-color: #fda; padding: 5px; border: 3px solid red; } .footnote:target { background-color: #ffa; } .line-block { display: block; margin-top: 1em; margin-bottom: 1em; } .line-block .line-block { margin-top: 0; margin-bottom: 0; margin-left: 1.5em; } .guilabel, .menuselection { font-family: sans-serif; } .accelerator { text-decoration: underline; } .classifier { font-style: oblique; } abbr, acronym { border-bottom: dotted 1px; cursor: help; } /* -- code displays --------------------------------------------------------- */ pre { overflow: auto; overflow-y: hidden; /* fixes display issues on Chrome browsers */ } td.linenos pre { padding: 5px 0px; border: 0; background-color: transparent; color: #aaa; } table.highlighttable { margin-left: 0.5em; } table.highlighttable td { padding: 0 0.5em 0 0.5em; } tt.descname { background-color: transparent; font-weight: bold; font-size: 1.2em; } tt.descclassname { background-color: transparent; } tt.xref, a tt { background-color: transparent; font-weight: bold; } h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt { background-color: transparent; } .viewcode-link { float: right; } .viewcode-back { float: right; font-family: sans-serif; } div.viewcode-block:target { margin: -1px -10px; padding: 0 10px; } /* -- math display ---------------------------------------------------------- */ img.math { vertical-align: middle; } div.body div.math p { text-align: center; } span.eqno { float: right; } /* -- printout stylesheet --------------------------------------------------- */ @media print { div.document, div.documentwrapper, div.bodywrapper { margin: 0 !important; width: 100%; } div.sphinxsidebar, div.related, div.footer, #top-link { display: none; } }cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/boost.png000066400000000000000000000320641240331347200256110ustar00rootroot00000000000000‰PNG  IHDR0aQ^ýsBIT|dˆ pHYs ! !0C«ˆtEXtSoftwarewww.inkscape.org›î< IDATxœíw|ÕõöŸ™í«ÝU/–dUËMî½c¦S ±1 „PBË ˜Ä H?’@ ½%40S‚qÁã^å*É꽬´½ÏûÇõH[îìήÖEÖ|?Ïìvwµóì¹çž{.ÃqD’à±KHHHœn˜(¬@Õé«Š„„„Dt°g»±" ˜„„D¿E0 ‰~‹$`ýIÀ$$$ú-’€IHHô[$“è·ÈÏv$D²iðüóô}j5˜¤§W_ Lž|fë68~xôQ 3xõUñç­\ ¼÷°c T<üæ7§¯ž IÀú uuÀêÕ‘ûÓŸ€ñãï¾RSO½ äó/(ÎúõÀ7^/y­Rzýi©Þ@E°þFj*ðÆen7ÐÑA~åßyØ·¸þz"bréO|ÖøðC"^sçÿý/› ˆù"!éÛÝßÐh€k®¡ïûÕ¯€ùó›n¾ÿžÚÌ™g´z~ÔÕ‘õ¢ED¼€aÎ^}ÎC$'þùÆ 7ô6·oï-w¹‡ƒls°kÐÚJ¿†Õ ìÞ lÞ tw ßËã!×ôùÈk§ض§Ù¹®TUëÖ⬓ÚZ`ãFR›-òñiþ}ÿ=pøpos.pè°aCø÷î|‡°ÛÉëädòÚí=ÖåÊÊȽZZ„¯éõ’kðõ¯©!uèp'v)à$Îÿý/Ç—›ùØ™3ɱ¿ùMoÙøñ¤¬¼œãÆŽ%Û,Ëq·ÜÒ{L}=ÇÝtÇ1 ÙÏ/&pÜž=¡÷¹ýv²ÿË/9î‘G8N¥ê='!ã–-ã8'ô<ŸãÞz‹ã²²ï£×sÜÓOÓÏÙ±ƒã&O<ža8nútŽ;|˜þ9üø#Ç•–ž£ÑpÜÃsœÓI?ç£8.?¿÷x–師¯æ¸o¿%¯ D<wÞxO~¹ì²ÞcL&RÿÏŒ¿þš5¡×üË_Èþ^à¸Çë=¾¸˜ãš›#×é<åœiBrA¿¾Á¯i0Aæxðë‰ÍF~Ñ`äÈÐýwß 8¤¤F#P\LÊ››qã€övR¶`éÙÜ´‰XbS§ï¾KœÒÁ,[Fîyíµ¤ [S¼ü2ðÌ3@}=ñÿøóàƒÀ?þÈdÀâÅÀ¨Q@u5ðÉ'ÀòåÀÿþG¬,ÞWS\q±¤æÌ!Íb‡÷ãÀĉÄ2¤÷o¿ üâÄbY¸˜1ƒXœ«VÏ=G®ÿägçµ×€;ï$Û S¦ËpÅ r¬XæÌ!ë/¾šš€‹/&Ÿé¨Q¤ÜåfÏ&‡ôtò¹åä{÷’s.~ÿ{à ½ö—_’Ά4GÕjÒ3:Pá΢æóù8ŸÏÇy½^Îãñô,n·[ôâž×ëí¹¦Ïç‹wuÏ.b,°ŽŽ[²„§Õr\mmï>ÞcŽ[µŠXA äŽã¸+¯$û¯¸‚ã,–Àë>ÿ<Ù—’Âq­­½å¼cü9r„ãt:²ÏߢX¿žÔA£á¸Í›Ï©¬ä¸!CÈ9ÿ÷½åÏ=GÊn¾9ô=óÖæoÛ[ÖÖÆqII¤üÃïì丩SɾgŸ <Ç` å/½xζm¤¾b-0ž . ç|ôQ`9oAEþþ|ý5Ç)'“qÜîݽå¼pÜw¿‘ÍÆqâësrÆŒ,^´üÅÈårq.—‹s:‹ÃáèY‚÷ñç¸\®QãïqÞ/`Z-ÇÝzkà²d yyÁÈCï/`‹‡^{÷n²O­=ø‡ñÑG{Ëx5Šb0>Jö/Zþ:þ¬^ÝÛu¹HÙC‘²{î =þÈŽûøcŽ;z´·lÙ2rüu×ÑïñÉ'½MV·›”½ò )?ž~Î=÷ÄGÀl6"Nóp÷ºâŠÞ2^À8Îj_‡óœ3Ò„äN59?AôíLðvðëpÍF~›a˜mÿ×ç»UÀîp”Ée,fLz°ÍFšrB””ÿ;på•ôýãÆ…–9BÖ³fƒÓÏ»áÒœ

€“?Ö¡óøsÚÚˆßÇl&Ûþû„Î;r„ÜkÄ"VO> <þ8é±\·Ž7a )¹ùf °°÷ü'Èú¡‡ÈŽŠ ò™46’×ÙÙôãòòÂ_G,Ñ|Ö €Åèt½ûh¿ 8°XíÐë4±×³ŸpÚLH¸¢0šxñY^üšapG±sÉkn7†ˆäfÐOÐjÛn‹ý†þÕJÖjµðy2YÓBh×…”ãÃüçbîõ‡?Ëë³ÏȲwoïòÜs¤£àê«É±&YÏŸO? dí:e þ á¯#–h>k ôóú¬OqðX Þút=–^9SÇ–ÄXÉþCÜ,’pNã·…šá–³Eu==«0÷ ö, JÖ55ÂÇÔÖ’5­Ç‹·^„ÎIL$ÃhrsIï™ÝNöñ÷:/#HÄKKɲ|99fÕ*àõ׉µvç¤ùÉ0¤™µcpÇÀ’%ÂïÉþ}ñ÷†Jí+Ñ|ÖJ%‰!AuC+Þùt#vª@,ø@\YyAòù|§}ñz½!eþ÷¦í§-þ"z6°‚œô3W‰aÃÈzçÎ^ !ÿf[0þ³þð~%>¬€az`~_0»w“àQ¹3†”=û,ñÁ<Ø{\^ýùçÄbii!þ%~ªé½~=ýÀ­·=FÂGâÿHÀ+mÛèåÑÂÖuu@y9ýþ³?>âåÚ&<ÿöÜûä=â¥Õ¨‘šÚžóÄMÀüÅÃßÒ ~›eY¨ÕêžE£Ñ@£Ñl -jµZ”˜…/ÿ×gƒê†6jùý;—ˆEk+ðôÓ¡û·l!±P¦ÌŠ¡çææÞì·ÜÒ[~ß}dýÔS½þ0§³7SÃå—÷6ÿ¶n%÷xüñÐ{77§xb"PTDÊˆå[oK,˜{ïþó’%"-”-]Jšu›7kÖßÕEbÚâAFcŸxøáБ55¤I Ð?k?¼>~õûW±nÛÁ€áüì3øãw–‰‹€…`a Þ¯Öh௠¯ ÖS‹Í'‡“ô8 èY”*5T*•hò/£ .¿}&©nµÀô ¤$Á¬2ðâ‹Ë’õ†ˆŸiÃâ<Ÿ?Ÿø°î¸ƒˆ]0^/±²þþw"¯¿LšD˜_qXÎ󳟑цba¼ü2È÷Þ#VÐæÍ@RðÒK½çüæ7Ä"ûüsÒ»úòËd ú²eÄ‹Š÷«MžÜÄ:w.y6ÑZ´ˆ ²f"¼Ï+7·7pôúëÉ9ßOz|'O&A¿ñâ¹çˆ/kõj`ÞùÀ‚--Úv¸E­VCÆÊ°³ºN†9å³Â)ÿ/Ã2ð¾,¿5€¼D%rõZØíö JÈ¿ÅqX–…ÏçÃ0=kÿ2þ5ÓËíACKgHùYù^py`o»X;¼ÅËäñÇIt8_ÿšŒMôÏsŲÄò ÎÅ0¤‰ôÐC$«ÆÝwîŸ6/Ýܹ$²þÁ¯¾"‹ÿõþðà‰'¯óï“Þ¼'žÝ—žNDä†Ë~˜õãž“™I"à/¸€þþ£%7س‡ˆî–-a&2ù—^Š˜I„öãœa÷ÃY&f‹$^‘DŒa¨ÕTv8àpûbŒ³Y:´ 0›L{ý…*X¼xá⛵Àé±ÚÆ6ªÅWC°ùó‰ß(\ïU8^„1ð~%³g“!A»v‘ug' Â;“³²ˆå´mñ‡%%]$Üå¯×“ú<ü0°?ñ]%'“áJBÉo¾™ ¹Y»–4³ìvò^&L =^&#>®[o%=•GŽQ-..½T8–ê‘Gˆˆõéœ7ŽX† äó×Dšð Ě*- Ý7t(iïÙC>ëúz2œè’Kè±x7ÞHÄÝï½Ö¸¨ßŸó”> M°h~°`ÓétpsÀÉGÌ•÷q@U· ÃR4°Y­ðx<Äõ<‹Wð6˲§]À¢òefömÌÛĉâŽÓhHsw¼‹E¡ J4VÊСÂ=‘4ˆˆECv6Y„{idd+(Zó9´ ad2Òœž2%òµòòBbÑ-°Ô„ŒÉFó%…óu¿fYG›mðúúæsj·y`vù 7¢êy ·í/¼§“*¡ÈÜÓˆš€¥% ÓÆh¥÷C¢°`K*Óéõè²{Ðh u@ÆBU· J¥²§W2\¸„XÝ™± …P0 Ÿ=p~A%bÃát£¥=t˜Ô@òQ6!#ù¸ÄøÂT*” %v5˜âö&,.Úm$'&Áf³…øÁhŽzZ“1xÍ×ÿt5'i¿ YiÉP«‚çØ.tt™áöx‘š¤ƒAwöÆÅyJÈ tÚÝð´w!QŸ¶î§¯Ï³ÅŽn³ >ŽC’^ ƒ^ {fóvºÜ˜,6˜­Ä=bÐi`Ði¡Ë"œ)â? -HÍG s»ÝŒL& k}…³ÊxKF¯7 ÑäB·ÝQlP C#Ër9 ½^“ÉÔÓë *ñòà_oë6ÛÐe  þz<^ì9\‰-»Žbç¡ Xm>C…\†â¼,ÌZŠÙ“G"IŸ×zòppàX5«FYy-Ê«›àòæ‹šÉw$´æ8 Ðé ØXÞ §×2&qaZ¥ ã³40›Lp»Ý=½f³YÐq¼í¿ŽTÆÆñ—|ÿÑjüîï߸p6nºŠ8зî>Š·>Y–qie,‹ë.›†ΉÛCjw¸ðÝ°fÃn4¶††|„ƒe,˜;7_}A\ý2Uõ­øbý.|¿£ .·'ªsÓS øÅ’ù˜I(%õÍø`Íü°÷<©ªƒ˜6n(n¿þ"ädF¯ àÞ?¾ªº0)§Ã R*ðé?>'ÆþÆQÃ0LGG£R©ÂúŽÂ‰ËëèD›N(P)JRÀår¡¹¹Yt¯cp¸„ÅÅ—ñÖ—ÿv<¨ ÓƒÔe¶â™W?áãaÆËQðú|Xùõ6ü¸ï–ß}}T¿ð4¶î>ŠW>Z c·%¦ó}>k6ìƦGðÈ/®Áø‘…‘O ƒÕæÀ[ŸnÀ·[öQ-1´ušðç—?ÅÄQÅxìÎEШà *€ã8¼·z3V~ó|}è„Ú¾ÿv¬ÀK/Á‚¹Â½Ä^ŸõMí1ß'/;í¼/@|’q8Œ^¯pl‡s~¯õz'Ûc›ð'M+G’ZŽššø|>äååC«-}Çqèîîx¼®¦¤P¸\Æâ¡?¿CuЊ¥®©¿øžÿíÏbò‘™­vüý­5ØyP`¬^”˜,6üñŸ+±üîë1qTqL×Ø]V‰Þù2f1 fOY%–¿ðžº)´•èóìNžþ×ÇØ´:.õðú|xùƒo‘–lÌÑØÒ w ÏùQÀòÄ2.—‹Û“,^r¹:]v՚ዃ° P˜¤Dww7¬V+ ´Z Êšmp{}z›™|J—Þ×ä?ÿfjQ’­6«•*ÎÁ¯ã!bÕõô°¿¾ùlvgHyVzJò!%Q§Ë¦6#ÊNÔÂ+êÑÜÖ…?½ü)ž}ø§QÕ«³Û‚åÏ $ ¦jIÁ ¤§`Ðia³;Ñn4áhe=<^z}\nžú×Çxö‘ŸbXaNTuÚ¸½ Ï¿½Fð½@¢^‹!ùƒdH€J!‡ÑdEMC[Øfï±Ê<ñâ <ûÈOEýM}>ϼ²JP¼X–AAN’ H6$@¯Ó¢ÛlE[§ -‚âËq^|÷+üç¯÷Q;„âÅr>÷LŠ±ÀŒÛífh—˜pƒÁ‹Ãƒf“+-G 6(¡`“§Ò¸ddf¢¾Ë…º.g ¿ èõ£ûÖÐë{óù8ŒÎÔÀåtÂ{jpm°`ÅSÀ8ŽCM#ýK,^“GÁÒ…³¨}—ÉŠÖlÁWßï¡^«ìD-v—Ub’H«§¹­ ¿{þ}4·Ñ­¿ÌÔD,]8ÓÇ£ú´ÌV;¾Ûzï¯ÙLÍqæöxñÒ¿Á‹ËïËŠû ×lØW?úV°É8sÂp,ºd†eSÿ.•µÍøïêMØu°‚zþáŠ:|½ioØ&Ï>ÿ»Ë*CÊõZ\1w".›=iÉôN ¯Ï‡ÿmÞ‡÷¿ØŒnsètp]f+ö©¢Z¨3' Çgÿ~´çõž²J<ýïOBŽ»mÑ<\}qhPl¼;-Î%Âz¥yë \.— xEZ, Tr$júž~L-g1Ø @ss3\.RSSÁÊä8Ñfùš]/Úmh´Ú°Íã`«,VšÚŒpº(‰ýHШ°üîëñÄ}K-–$Cî¾é2<ô34È>ýöGQu²;\øíßÞ£ŠÃKÎÆ«Oß…ù3Ç :äõ ,ºtþùø/•žD=¦ª®k6ìU§Í»Žà•éâ•‘šˆç½¿½ë: /ÎüQ)ÎË¿^‚_-½Tð>ï~ö=ºÌi„NÑÐÒ‰ÏÖ†¦ ÊÍJÅ?–ß›¯š#(^±Z̈ç½Jý9Øq€ÞdgYJ…¼g©oî Wœ—p¿œ¯þ/@| kD ,\³Òb±Àáp 4³ï)n‹“pº\hii\.GzzÊùŽ>pÒè˲=Ù-„+&”Œ'3- {ì6L?LÔõ.š1K® ÏÀ}ðX Ú:#Çܽ¶b-µ·S£Râ÷.ÆÍW‰ïÙ”žŒ§¸QÐÿöåÆݯÑÙeÆ¿Þû†ºoôÐ<ücùí9$WT}`á…“p˵s©û¬66í8öü÷¿ØÒ­¼ÿ ”Õ5_1SÐ2*+È2zŠʱvkè2–ÅoïºSÆDŸš8;#YðAml5R³pøó»_Áb ý»– Â÷ÝSçÄâËg /›þ¹îhb¤ù·ûPèþyÓF!91|Šg“ÇйwG°yhþS½î §`:Gg1°ž±4#ív;º»M™¥E,-ËCR”0èêêBBBRR’q¸Ås—z0 f7Ü^jFTS2V„Æ@À²_^SøƒZ¥ÀÅ3ÇR÷•0·Ç‹þ÷kê¾»n¼J‹¢® ÏåsÆ >à»ÂôpnÚy{(¾¦”$=žøõ’˜£ý†Á fQ÷••×Rsk@EM¬”Ž•XGAdg¤€a¤$éQ:d0.š17_5×_6#⹯õÍ¡!çsOc8¢ŠÄô G±¶¶V!?YjctVSn¢*ƒ£UU=a­fÚ,î¸t $»Ee— #ÓÔp9=ûÁœ®&äœÉ#û$#Šrð9¥¼®Q8†hãö2jÓexQ.¿€’>: ärFÍÃæ]GBö…³À>ý–ž¢úöë.D’¡o# &Œ¤¾­ÝÔl¦´@dW€J…«þõˆ /, ÍÔžÞ*`¢-°pV‡¨—¹Ýntvvbh† ™xÙQÉYä'*P__»ÝŽôôth´nŽÝq/„Ñá…Ñá…F£ kyÅ*b|D0J…·_QŸê^”GO·c°,P‡À/o˜ß§ºðŒ(¦û©hÍC€X‹•”a2C ²1wê¨>×G¯ÓF¾ ÕÉæ ~»Ë*ðΪ1³Æ"^@¸:ÏÿÍêðz½ ¹I®éåóùÐÚÚ †ãPœ*~hÉÜn7êêêÀ²,òòòq²Ã«+öà¾pTu9!“É R©Þ“ÿv¬VÛØN=wæ„á}7(éx÷­¢>#‡äF«%DŠ@RH,>ûŽ’ÃÀ5ó§ÄäzˆªNVzÒz9øø›møíßÞÃÖ=GC&'>;ð¦&ô3À/bÒË„/¾Üçó¡¥¥EÙÙœtJ Àº Çÿ @­¡¬¬ ÅÅÅðAykü­/‡‡CƒÅlîSóòñïÃ?ë+¿Ž!ÿ×üYtÿU4ȺAí ž8â붤–ÏŸ!_ ¦Y-›ƒJ U‹î‘ƒR°NôžìáE9P)‚¡/‡NÔâЉZÈå2Œ–i㆞¶ì4>Ãù°ˆÂÆ[`€øIkýñ/ooo‡×ë¼àã=Z[[¡Õj‘““ƒý Vx|ñÏáOƒÙ ­jµNg¨7Vh¿ )‰:ŒVÐçk{9ú(ä7:t<Ô¹/—Ë0{òˆ>×¥?QjR¨t¸¼–ú9kâð˜›\4XïMª@/ž\.Ãe³Çcõzzs›Çãñbïá“Ø{ø$þýþÿPœ—…)cK0uL †äŠ‹Iûþd¤&A£Š½w¿?#ú[M“)RžÏçC{{{Øl©þkþzyyypz|¨7:ã2<½éªUðx<)úÒ IÄ=²dp\¾Üíñ^´³¹­ íÆÐã‡ägÅõaèè2Óë”Z'š ÀèaùÔòXi¢N<·]7»Ë*"†øSYÛŒÊÚf|¸f R’ô˜6¶ÍƒáE±5Ïmv'Z)±zµù„0F`›ê ‡V«Err i*r¤ÁH6¹SeÚçw 8œ¬¬„ÉdB]]²³³‘©W¢Årúý .J3'–f£?´&@éÊ$1 °J°ƒ™.âUžhDõlÖ‰e$„cº” 9žyø§øÛ›_`ÿѪ¨ïÙÙeÆ×›öâëM{‘›•ŠËæŒÇÂy“ b˜Ðð³2 7H‘ø=C‰„B&ømÿ²àò̬ApB‰FÐdfÑlfÑbeÑj“¡Í.G»C‡.Œ.Œn5º-–:UÖ‡”1 PR(ÚmÝÔïV¼ës¤"´>€ø†.=—·òê&¬ÝºÛ÷Ÿ= ÈŸšÆ6üîùðå·#;#òw@(îl !â9­ÉÂår9RSÓ°«¼f{t™3y:-.œh²bØðáÉdp:8yò$JÒÕPÉOOõe,ƒ¼DœG\g&¢}uZ5ô }# GÊC­*ƒN‹¼A¡_ðöNº(#%~ÖNKG7µY›“™Š„ v£@}âh}Âêb ))„{n¾ÿyî~¼ø{2 {havTþL›Ý‰?¿²JÔ±´@…\†ì8ýöGâ×µC!-- 6—»+¢KE̾ªn¦g¡¤¤'Nœ@mm-rscD¦Å‹†ÁzXp°Øíaý]ÑúÂhc Ãe0ˆ†ÚÆvjó´T ƒ€æ\ר•Q%÷‹Ä¼Yc(NyZ‡¿Ï‡'š:‰…aH&ˆâ¼,,]8]f+öªÄ®CØ{¤*dƒ`ªêZPUׂÂÁáçý¤åh<(íŒOZr.!$`m›oîù¿ÚÖh40 ørW#¼} ypz|ØWcÂäâ466Ân·ãĉã;v,jŒNtÇhÝÑÐÈY Ò)`±˜ûì°†æÈ%¥1ïw”QËiY>mv'5¦)Þa)Bu¢Åt»é?Dñ¬R]S;5Ê?;#9®qTIú\4c .š1^ŸûŽTá³µÛÃfqÝ{¤*¬€µMÔàßìÿÂ7!9ôŠ,Pük¡íÔÔ4ÔµÛPÑÒ‰& ºmn > ࣣF#FeŧéÚ^¥IDATùÅS”¤„Çãé‰ýŠ×CÍqj)½Hñ˜)†ã8¬ÿñPH¹V£ÂœÉ#CÊ1U±LL!D[§ W‡”'hÕ3¼€R'zo\<ë$¸Ï Ù`d,‹I£Šñ§‡nÂÏ_,x\$+Mp÷BDá‹æAÖëõP©”Øx0¶YThp°«²©©)ÈÈÈ˲¨¬¨€A-GnR|š=©’Ô2X,æˆ"­°5¶©3èÐzÄ¢eëžcÔ&ؼ©£¨©Ë¨Ý÷n‡šÎ:V¯Û ZÏ…ÓFA. ýÚiÕô¿a%{i,ØìN|÷ChÊ †.™%<òÀçãÐØjÄ®ƒXµvGŸrÓ_;ª ¯M!öNÐ?À-0Ñ>0–ecün™L†¤ädì;Ù…³+®Í’–n'jÚlRR‚îîn8455axFZÌnxú%‚eˆõe·Ûáñx¨S¨õ)þK RL²Áp¸=^¼ýéê¾ËçŒkÒŒ¥øã@Ÿ@¯K¸d”‘¨ªk¡®-ÌŽ8𻑤¬×iâÚÉÑ¡ Ø©€ÂcY–j…½"f0$¢­Û²š¾ýJEâH£v·…`Ymmm°Û™›C¿(™¡Íf-TÑ ˜ÐD¶ ZïX8v—Uâ¯o~Aõ3Ýzí\$éÃ'þ›(8Ñfwâõ•ßEU€|gþóù÷ø\ έ×Î ÓÅ0À„RzÓõ»­PÃÑÚÑß¿ð!Õ‚3è´øåáœgBÃsV~ýCÄ @h8]n¼òÑZê¾+"$Ž´Ù0YB›¿‰1f„=ŸˆäÄïiF[`Á¹F£Z­ÂºýÍÔ‡*žø|öV›––ŠÄÄD°,‹ººZ¤é¸pH"æ0¯Ø€¹ÅÌ+Òcn‘êqA¡s ô˜“¯Ãœfçë0+/i r˜M¦Az¯ÑŠ—ÃéF“ÀTeyøÿüʧ‚Í‹Àc‰ƒüÉ—VPC!.™5VÔaà sCÖÿxï¬Ú(úïØe²âÉ—VbÅW?P÷Ïž4×ÌŸñ:BÎt¯Ï‡?þs%ª(C„Øy°÷=ý&ÕbbYËî¼V0ûAËÌbs&²Àü—4N7q5µ÷ø‘…˜/ œ‡–“/š¡h É‰Ï '—Ë,0~؇¿€uš]hì ü/ê;°:<ÈÌÌ„ÍfƒÍfCuu5ŠÞ^7!k‘eÙ^E·ÛM-²6£yµmÇM6·uá‘ÿû~¹d>¦r}Ž¯ÁÛŸnÀ‰júø¹)cJðëŸ.U'–ep×ÒK±ì¯ïQ÷üÍ6¯jÀ/Ïô¥»-øfó>¬úv»`>ù±Ã ð`˜iß‚5q¶î9²ÏlµãÁ?¿¥ gãÊy“B"ùò­¬Ç‡_nÁÞÃ'©÷`Üz¥ @ñŒ,ŒŒÔDêÊ–ÝGQUߊŸÿäbÁ :âßüjã|¹qÕjÓjT¸ÿÖ+ÃÖÎçær{°ì¯ïaìð|äggÀît¢ËdÃ=7_Níé=aÂ=X ð V»wïÞÂáÇJ#“ÉœœŒÕÛëQÑd¡s}¼c¸±¡çíÁ©Ìž‚òòrX­Ö±áň¶ÞW®\,k·îÇ?Þý* L£VbPz2usfj"†åôÌ­Øa4ãÀ±Áhu€ü’ÿáÞÅQçÍú뛫±q;=à”'?'à sœ˜–azf½>v²!¬0O[‚ew.ŠªNm&ÜóÄkÔI4xrÆ,DVZ2uØœ.tv™qðx-:Råðç=tûUÔØ8ÿÛ¼/ Lx“™šˆAÉÈLKBj’f«mdU]S;Õ÷?å“÷-5x¾ª¾÷>ùº¨:Àê——E•å¢?#ÚS(j™ðÑêv»ŽÍDu«Þò„‹EÆ2˜Xh€ÑØ›ÍÖ#&¼ØD±àíHNú¾;ðC{ó³Óqß- pÿÓo†ÄµttSçhbÑ¥Óð³EŠžíÚŸn½›Cpæj€ôâEÓSʲ n¾ú,¾|fÔNæôž~ðF,þAs{¼aëK#;#Ëî\U‰KgÃö'ÂÞ+Ú¿@²Z<õàRÑy¼Ò’ôËe¢ƒzeÄúÄûÀ8™LÖ/ôÀ[­dîICNïàÒ‘9:¨,š››¨bl9 ‰­y(v‰†ª†P+« 7ù9é¸û¦Ëb€ Yyô—×âŽë/Šùr¹ Ëﺳ&Æ' ëˆâ\¼ð»Û±äŠèÅ‹gha6ž~ðƘæ\ F.—á'—ÏÀ‹øyÔ)p†Á£¿¸¥%ñÉGÆ0d.Éç÷³¨’êušˆ~²Àû œ®É°Ø)ëŠÀ)•JNèaç_û|>ØlVL–†#uÝ°8â?éF‚J†Ò\=ÚZ[àõzÃZR‘D,œEüc/€nñ_àKfCfZþòê*Ñá µ×]2 ×\25.ÙSårûÕ"ì:X×V|‡ÆÖèß–«/šŒiã†Å,\þ -ÌÆëOß…¿Ü‚ÕëwE=¤H£Vbþ̱¸æâ)ÈLKŠ¹µÏ>üS|úív¬üf[Ä!?4˜XZŒÛÍ‹8`[ˆ;o¸f‹êô'Ö²þJX0ä‰ejjjŠ²²²Êýý^Á~0>õLbR2N¶XñõnÞBŠŸlîÈTdèd¨¬¬àë׳#b‘üa‘üdÑø¾2–oÅס½só¦ Èeµ9°nÛA|½i/µgI£RbBi¦O†)cJ¨Nìxàñx±ïhv¬Àî²JÁÀÍ­E¹˜4z¦Ód¼bi7š°ã@9vªÀÁc5ÑÌ´$Œ(ÊÅÔqC1itqÜóÄ»ÜlÙuÛ”ãd]3ZÚ»¨=µ $ê0fX>&‚‰£Š"†µˆåxU6n/Cu}+Œ&+,VõZ¤¥žl@Fj"–,˜—{õ" @D¬¥¥¥(99¹"X°hÛ …‰‰‰X¹µŽ¸ Xv²NGmmmã/šuÉ©IÀ΄ynwºÐa4ÃØmN«Fj²>æY ûŠËíA—É £É§Ó]‚IzíYÆÞbsÀØmA—É ™L}‚é)‰1ÏØ+v‡ F“6»V»•ɉ:$'êL/àÙF¬€Áh4étºÊHâůõzÌNïoªé¹F_LÆ2¸jR&B"ÆgIÄhF{-!!qî ê‰ä8&ìxÈàÅf³"U¯Bi^|2jÏÑA§’£½½=@Pd2™`ØC¤¦a¤¦fp¹„„Ĺ…è§R¥RqBsšhø|>8vÌ™•¢o¿F)ø|ººŒðù|T¿”X‹ä¼. ‰—„Ä9JTOf$Ñ ^;(XS‡öÍÁ;©(>Ÿ&“IÐê ¥pÍÀp¾/¡÷'!!qîµi!¶¹Å[-‡ã “¬‹­G(#Q…¢Ìt;©â©9)$nbDLj:JHœÛˆr⟢@êìÙþ³hûos‡v‡néþf€€dçLÏ~¯O“œ çu¡£½½w?xC?œ)”B(lv'ŽVÖÃárcBiÑy1üáŠ:åfFÏçÁrLš£ŸÆ{ÁëõA.cQ88ƒÒÅM¯Öe¶âà±ÞŽ£ôd†åøÝ"ÒÒÞ…ö.sTêÖ7wô “ÉXäd¦ˆVµÙ8Y×Bþ.«Í=Aã<J=¹m}sŽVÖàÓ`biq¿r“y!&Á_$v;T22ô2¤ëX¤éX¤%0HÕ©Z YÃ!YÝ»$ª|dQzás;`>ÕtŒ×"dÅÛi_YÛŒ§ÿý Z:ÑÞiÂ}|Spl Ç‹.Sl©[ú’Ó+¯~¸6êfµÇãÅ+׉:ÖjsàíO6ÀØmA}s'žú×Ç¢Ó í9T‰öƒËíÕæÀ;«6DOì×ãâêÊóõ÷{Q^Ý—Ûƒ£ϼúv(uîÑÊzlÚyXÔ±eåµøßæ}0v[z±A¾·—áÝϾü¸ïDÄqžý˜§UówÖ³,ÛcyñezÊ9ŽƒÃá°Êh³xÏè현Š4+Œ¯G,á}Áãñâ…w¾ÄS.í bÔ¨•hë4‰NI\V^‡#u¸qáì¨î½u÷Qx}¾°¹ÞcÅëóÁãñFsU×Üܬ4QÇVÕ·¢´d0®¾x bU™D ruC+æN)홨#Q¯ÌLAãÇ}Ç‘Ÿ“Žv£ f«]ôœÕ ­¸ÿ¶+‘y*ç™Éb ;°<ðÜ6ѹí«ëÛpÁ”R\:;ú¿íçëvâÉû— IŸ€ ¦”bõºQ_ã\£OóBú‹€AóoR2 Ó³Ž$`ük1÷Þ¦‰Tp¹P2žNûmûŽcBi`¶XAéì2cï‘*ì?ZµJ‰õÛâÂéc"6ƒ[8RQ‡­{Ž¢ '›wyA,õÍ1M¤ZÝЊ‚\qùÛ«ê[QßÜ×>úF“ Z5Æ(yŸ6°,‹ÖŽn˜m”¨Å"RÖDœ?[»OÜ·]&+ŽU6„M—ãO]S;¶ï;€Œ¨nhÃïïù‰È:·â²ÙÂó‹ô ÷ÊLKŠ˜‘gÎä‘øõ“o`úøa˜9q¸`:íþDŸÛIBÍG1½|ÁÇ„sÂÇ⼶WR&“ŭDZ®©9™½¯bý|vŠ†–Nä J+cEùpÜÒO¬O¨º¾Ïƒ9SFâ‚)¥(;Q eøæ¶. /ÊLÆbË®#xüÞÅ=i‰"ñͦ½CR|wÍ8Z). l—Ù ƒN‹ŒÔDt›m8Y׊§X*:ùlĉ{Mc®œ7 ÓÇÃôñâš÷ºK§áßOþ#ŠsñæÇëE7[Ïeâ23·SÍßê .Ól ׌º/¿©9©ùO4jUÀì×Ç«ðáš­xâ¾%ÏÍLKBfZÖm;ˆ«.¢ÏâC#?;ùÙéX÷Ã\ùöGD̦Š$CäÁФ™Úkå-š?w?ñ:®¿tzDXùÍ6,¼hFŸ²h†çâ×ÃëóAáÇ­&è¾K®˜…×V¬%` -¢}¢uMíp»=Óèçe‰rŒšçß^ƒ §†ÛãAU}+ùù5¢î{.SE$ MÄhëàíŠÇAÀNwŒ—ÛãűÊz¨UJ ÉUWþ¹Jyu~é£ gB'Âz8^Õ 8©«?^ŸGÊë4?ƒÒ“E‰@ró»Üž€ÉC*k›‘‘’ØcÍ…«ßЂì€ïÕ±“ (ÎËŠØoj3B§U8ü—×ahavÄs-6ºÍ6Q"f¶ÚCf·JMÖd5 GG—åÕMH2$`hA6·Ô;§EÀxΔ&$\þÛBÎ} ‰þKÜš4ü›•gZÀüï/ —„ÄùÉi0!!ãË€èœ÷´ë ­%á’89#Æã/$B¾°àm1× Þ–DKBb`pFÌŸ`1£­Å^‡¶–8ÿ9kæO8ñ¡‰™$RÀ9"`áÄJBBB)Ù•„„D¿E0 ‰~‹$`ýIÀ$$$ú-’€IHHô[$“è·H&!!Ño‘LBB¢ß" ˜„„D¿E0 ‰~Ëÿv%Õ ñÚíIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/comment-bright.png000066400000000000000000000066541240331347200274100ustar00rootroot00000000000000‰PNG  IHDRóÿa OiCCPPhotoshop ICC profilexÚSgTSé=÷ÞôBKˆ€”KoR RB‹€‘&*! Jˆ!¡ÙQÁEEÈ ˆŽŽ€ŒQ, Š Øä!¢Žƒ£ˆŠÊûá{£kÖ¼÷æÍþµ×>ç¬ó³ÏÀ –H3Q5€ ©BàƒÇÄÆáä.@ $p³d!sý#ø~<<+"À¾xÓ ÀM›À0‡ÿêB™\€„Àt‘8K€@zŽB¦@F€˜&S `ËcbãP-`'æÓ€ø™{[”! ‘ eˆDh;¬ÏVŠEX0fKÄ9Ø-0IWfH°·ÀÎ ² 0Qˆ…){`È##x„™FòW<ñ+®ç*x™²<¹$9E[-qWW.(ÎI+6aaš@.Ây™24àóÌ ‘àƒóýxήÎÎ6Ž¶_-ê¿ÿ"bbãþåÏ«p@át~Ñþ,/³€;€mþ¢%îh^  u÷‹f²@µ éÚWópø~<ß5°j>{‘-¨]cöK'XtÀâ÷ò»oÁÔ(€hƒáÏwÿï?ýG %€fI’q^D$.Tʳ?ÇD *°AôÁ,ÀÁÜÁ ü`6„B$ÄÂBB d€r`)¬‚B(†Í°*`/Ô@4ÀQh†“p.ÂU¸=púažÁ(¼ AÈa!ÚˆbŠX#Ž™…ø!ÁH‹$ ɈQ"K‘5H1RŠT UHò=r9‡\Fº‘;È2‚ü†¼G1”²Q=Ô µC¹¨7„F¢ Ðdt1š ›Ðr´=Œ6¡çЫhÚ>CÇ0Àè3Äl0.ÆÃB±8, “c˱"¬ «Æ°V¬»‰õcϱwEÀ 6wB aAHXLXNØH¨ $4Ú 7 „QÂ'"“¨K´&ºùÄb21‡XH,#Ö/{ˆCÄ7$‰C2'¹I±¤TÒÒFÒnR#é,©›4H#“ÉÚdk²9”, +È…ääÃä3ää!ò[ b@q¤øSâ(RÊjJåå4åe˜2AU£šRݨ¡T5ZB­¡¶R¯Q‡¨4uš9̓IK¥­¢•Óhh÷i¯ètºÝ•N—ÐWÒËéGè—èôw †ƒÇˆg(›gw¯˜L¦Ó‹ÇT071ë˜ç™™oUX*¶*|‘Ê •J•&•*/T©ª¦ªÞª UóUËT©^S}®FU3Sã© Ô–«UªPëSSg©;¨‡ªg¨oT?¤~Yý‰YÃLÃOC¤Q ±_ã¼Æ c³x,!k «†u5Ä&±ÍÙ|v*»˜ý»‹=ª©¡9C3J3W³Ró”f?ã˜qøœtN ç(§—ó~ŠÞï)â)¦4L¹1e\kª–—–X«H«Q«Gë½6®í§¦½E»YûAÇJ'\'GgÎçSÙSݧ §M=:õ®.ªk¥¡»Dw¿n§î˜ž¾^€žLo§Þy½çú}/ýTýmú§õG X³ $Û Î<Å5qo</ÇÛñQC]Ã@C¥a•a—á„‘¹Ñ<£ÕFFŒiÆ\ã$ãmÆmÆ£&&!&KMêMîšRM¹¦)¦;L;LÇÍÌÍ¢ÍÖ™5›=1×2ç›ç›×›ß·`ZxZ,¶¨¶¸eI²äZ¦Yn…Z9Y¥XUZ]³F­­%Ö»­»§§¹N“N«žÖgðñ¶É¶©·°åØÛ®¶m¶}agbg·Å®Ã“}º}ý= ‡Ù«Z~s´r:V:ޚΜî?}Åô–é/gXÏÏØ3ã¶Ë)ÄiS›ÓGgg¹sƒóˆ‹‰K‚Ë.—>.›ÆÝȽäJtõq]ázÒõ›³›Âí¨Û¯î6îiî‡ÜŸÌ4Ÿ)žY3sÐÃÈCàQåÑ? Ÿ•0k߬~OCOgµç#/c/‘W­×°·¥wª÷aï>ö>rŸã>ã<7Þ2ÞY_Ì7À·È·ËOÃož_…ßC#ÿdÿzÿѧ€%g‰A[ûøz|!¿Ž?:Ûeö²ÙíAŒ ¹AA‚­‚åÁ­!hÈì­!÷ç˜Î‘Îi…P~èÖÐaæa‹Ã~ '…‡…W†?ŽpˆXÑ1—5wÑÜCsßDúD–DÞ›g1O9¯-J5*>ª.j<Ú7º4º?Æ.fYÌÕXXIlK9.*®6nl¾ßüíó‡ââ ã{˜/È]py¡ÎÂô…§©.,:–@LˆN8”ðA*¨Œ%òw%Ž yÂÂg"/Ñ6шØC\*NòH*Mz’쑼5y$Å3¥,幄'©¼L LÝ›:žšv m2=:½1ƒ’‘qBª!M“¶gêgæfvˬe…²þÅn‹·/•Ék³¬Y- ¶B¦èTZ(×*²geWf¿Í‰Ê9–«ž+Íí̳ÊÛ7œïŸÿíÂá’¶¥†KW-X潬j9²‰Š®Û—Ø(Üxå‡oÊ¿™Ü”´©«Ä¹dÏfÒféæÞ-ž[–ª—æ—n ÙÚ´ ßV´íõöEÛ/—Í(Û»ƒ¶C¹£¿<¸¼e§ÉÎÍ;?T¤TôTúT6îÒݵa×ønÑî{¼ö4ìÕÛ[¼÷ý>ɾÛUUMÕfÕeûIû³÷?®‰ªéø–ûm]­NmqíÇÒý#¶×¹ÔÕÒ=TRÖ+ëGǾþïw- 6 UœÆâ#pDyäé÷ ß÷ :ÚvŒ{¬áÓvg/jBšòšF›Sšû[b[ºOÌ>ÑÖêÞzüGÛœ499â?rýéü§CÏdÏ&žþ¢þË®/~øÕë×Îјѡ—ò—“¿m|¥ýêÀë¯ÛÆÂƾÉx31^ôVûíÁwÜwï£ßOä| (ÿhù±õSЧû“““ÿ˜óüc3-ÛbKGDÿÿÿ ½§“ pHYs  šœtIMEÚ 6 B©\<ÞIDAT8Ë…’Kh]e…¿½ÿs1mAÛÄÚ`j‚Ïh[-ˆE(FEŠÁaAœ! bI« àÈ*–BX‘"Ø4)NŠõUR‚Zˆ¹­!’×Mhj“›ssÎùÿíà–¨àãmØ‹Å^‹-\ggßÏ ÷ßì]o|ÑÑÒ¬[3±¶4§Á§6»”û©òèø¯×>zd‘¿ ]½#Œ»î8ÙþüáÇOݺ±t{5·uIÍXN!I=@Vf¾®Ÿ=v×ÀÞþ1ûº}e>;ØÉö×fvìénøvËÍÅxaÉHrÏʪJ’¦Fȹ`œÈðDò¹WZ®]ÀžSíýŸø%S)ÌWAÌœb¹ |0K=âSo7D†~\~qâÍ-ïÀËŸ\ùaóMÅ“Z,S'*æô™‘È} óF`—†ÎNnzæ674¸öËUÈç¬ó³ÏÀ –H3Q5€ ©BàƒÇÄÆáä.@ $p³d!sý#ø~<<+"À¾xÓ ÀM›À0‡ÿêB™\€„Àt‘8K€@zŽB¦@F€˜&S `ËcbãP-`'æÓ€ø™{[”! ‘ eˆDh;¬ÏVŠEX0fKÄ9Ø-0IWfH°·ÀÎ ² 0Qˆ…){`È##x„™FòW<ñ+®ç*x™²<¹$9E[-qWW.(ÎI+6aaš@.Ây™24àóÌ ‘àƒóýxήÎÎ6Ž¶_-ê¿ÿ"bbãþåÏ«p@át~Ñþ,/³€;€mþ¢%îh^  u÷‹f²@µ éÚWópø~<ß5°j>{‘-¨]cöK'XtÀâ÷ò»oÁÔ(€hƒáÏwÿï?ýG %€fI’q^D$.Tʳ?ÇD *°AôÁ,ÀÁÜÁ ü`6„B$ÄÂBB d€r`)¬‚B(†Í°*`/Ô@4ÀQh†“p.ÂU¸=púažÁ(¼ AÈa!ÚˆbŠX#Ž™…ø!ÁH‹$ ɈQ"K‘5H1RŠT UHò=r9‡\Fº‘;È2‚ü†¼G1”²Q=Ô µC¹¨7„F¢ Ðdt1š ›Ðr´=Œ6¡çЫhÚ>CÇ0Àè3Äl0.ÆÃB±8, “c˱"¬ «Æ°V¬»‰õcϱwEÀ 6wB aAHXLXNØH¨ $4Ú 7 „QÂ'"“¨K´&ºùÄb21‡XH,#Ö/{ˆCÄ7$‰C2'¹I±¤TÒÒFÒnR#é,©›4H#“ÉÚdk²9”, +È…ääÃä3ää!ò[ b@q¤øSâ(RÊjJåå4åe˜2AU£šRݨ¡T5ZB­¡¶R¯Q‡¨4uš9̓IK¥­¢•Óhh÷i¯ètºÝ•N—ÐWÒËéGè—èôw †ƒÇˆg(›gw¯˜L¦Ó‹ÇT071ë˜ç™™oUX*¶*|‘Ê •J•&•*/T©ª¦ªÞª UóUËT©^S}®FU3Sã© Ô–«UªPëSSg©;¨‡ªg¨oT?¤~Yý‰YÃLÃOC¤Q ±_ã¼Æ c³x,!k «†u5Ä&±ÍÙ|v*»˜ý»‹=ª©¡9C3J3W³Ró”f?ã˜qøœtN ç(§—ó~ŠÞï)â)¦4L¹1e\kª–—–X«H«Q«Gë½6®í§¦½E»YûAÇJ'\'GgÎçSÙSݧ §M=:õ®.ªk¥¡»Dw¿n§î˜ž¾^€žLo§Þy½çú}/ýTýmú§õG X³ $Û Î<Å5qo</ÇÛñQC]Ã@C¥a•a—á„‘¹Ñ<£ÕFFŒiÆ\ã$ãmÆmÆ£&&!&KMêMîšRM¹¦)¦;L;LÇÍÌÍ¢ÍÖ™5›=1×2ç›ç›×›ß·`ZxZ,¶¨¶¸eI²äZ¦Yn…Z9Y¥XUZ]³F­­%Ö»­»§§¹N“N«žÖgðñ¶É¶©·°åØÛ®¶m¶}agbg·Å®Ã“}º}ý= ‡Ù«Z~s´r:V:ޚΜî?}Åô–é/gXÏÏØ3ã¶Ë)ÄiS›ÓGgg¹sƒóˆ‹‰K‚Ë.—>.›ÆÝȽäJtõq]ázÒõ›³›Âí¨Û¯î6îiî‡ÜŸÌ4Ÿ)žY3sÐÃÈCàQåÑ? Ÿ•0k߬~OCOgµç#/c/‘W­×°·¥wª÷aï>ö>rŸã>ã<7Þ2ÞY_Ì7À·È·ËOÃož_…ßC#ÿdÿzÿѧ€%g‰A[ûøz|!¿Ž?:Ûeö²ÙíAŒ ¹AA‚­‚åÁ­!hÈì­!÷ç˜Î‘Îi…P~èÖÐaæa‹Ã~ '…‡…W†?ŽpˆXÑ1—5wÑÜCsßDúD–DÞ›g1O9¯-J5*>ª.j<Ú7º4º?Æ.fYÌÕXXIlK9.*®6nl¾ßüíó‡ââ ã{˜/È]py¡ÎÂô…§©.,:–@LˆN8”ðA*¨Œ%òw%Ž yÂÂg"/Ñ6шØC\*NòH*Mz’쑼5y$Å3¥,幄'©¼L LÝ›:žšv m2=:½1ƒ’‘qBª!M“¶gêgæfvˬe…²þÅn‹·/•Ék³¬Y- ¶B¦èTZ(×*²geWf¿Í‰Ê9–«ž+Íí̳ÊÛ7œïŸÿíÂá’¶¥†KW-X潬j9²‰Š®Û—Ø(Üxå‡oÊ¿™Ü”´©«Ä¹dÏfÒféæÞ-ž[–ª—æ—n ÙÚ´ ßV´íõöEÛ/—Í(Û»ƒ¶C¹£¿<¸¼e§ÉÎÍ;?T¤TôTúT6îÒݵa×ønÑî{¼ö4ìÕÛ[¼÷ý>ɾÛUUMÕfÕeûIû³÷?®‰ªéø–ûm]­NmqíÇÒý#¶×¹ÔÕÒ=TRÖ+ëGǾþïw- 6 UœÆâ#pDyäé÷ ß÷ :ÚvŒ{¬áÓvg/jBšòšF›Sšû[b[ºOÌ>ÑÖêÞzüGÛœ499â?rýéü§CÏdÏ&žþ¢þË®/~øÕë×Îјѡ—ò—“¿m|¥ýêÀë¯ÛÆÂƾÉx31^ôVûíÁwÜwï£ßOä| (ÿhù±õSЧû“““ÿ˜óüc3-ÛbKGDÿÿÿ ½§“ pHYs  šœtIMEÚ!â›ÈÝ,IDAT8Ëe’_HuÇ?Ïï}ßsŽž3ÍyòË•¶¦‹U2MvQÉÖŠFÔE¬.ŠÑÍÃÅ‚­ÄŠbÑE$DD­‹ËZF5b@QÌ"š:2§›š¦¾ïû{Ÿn.êsõåçû<_ø yî?ô½m÷²ýè·wV™ê@t£R`}Z íÄÐ_£# _=œá_@ÝËý ßw^óRë®·•%6gC-έ(K>ä| $„Éï{¯}ç¬ó³ÏÀ –H3Q5€ ©BàƒÇÄÆáä.@ $p³d!sý#ø~<<+"À¾xÓ ÀM›À0‡ÿêB™\€„Àt‘8K€@zŽB¦@F€˜&S `ËcbãP-`'æÓ€ø™{[”! ‘ eˆDh;¬ÏVŠEX0fKÄ9Ø-0IWfH°·ÀÎ ² 0Qˆ…){`È##x„™FòW<ñ+®ç*x™²<¹$9E[-qWW.(ÎI+6aaš@.Ây™24àóÌ ‘àƒóýxήÎÎ6Ž¶_-ê¿ÿ"bbãþåÏ«p@át~Ñþ,/³€;€mþ¢%îh^  u÷‹f²@µ éÚWópø~<ß5°j>{‘-¨]cöK'XtÀâ÷ò»oÁÔ(€hƒáÏwÿï?ýG %€fI’q^D$.Tʳ?ÇD *°AôÁ,ÀÁÜÁ ü`6„B$ÄÂBB d€r`)¬‚B(†Í°*`/Ô@4ÀQh†“p.ÂU¸=púažÁ(¼ AÈa!ÚˆbŠX#Ž™…ø!ÁH‹$ ɈQ"K‘5H1RŠT UHò=r9‡\Fº‘;È2‚ü†¼G1”²Q=Ô µC¹¨7„F¢ Ðdt1š ›Ðr´=Œ6¡çЫhÚ>CÇ0Àè3Äl0.ÆÃB±8, “c˱"¬ «Æ°V¬»‰õcϱwEÀ 6wB aAHXLXNØH¨ $4Ú 7 „QÂ'"“¨K´&ºùÄb21‡XH,#Ö/{ˆCÄ7$‰C2'¹I±¤TÒÒFÒnR#é,©›4H#“ÉÚdk²9”, +È…ääÃä3ää!ò[ b@q¤øSâ(RÊjJåå4åe˜2AU£šRݨ¡T5ZB­¡¶R¯Q‡¨4uš9̓IK¥­¢•Óhh÷i¯ètºÝ•N—ÐWÒËéGè—èôw †ƒÇˆg(›gw¯˜L¦Ó‹ÇT071ë˜ç™™oUX*¶*|‘Ê •J•&•*/T©ª¦ªÞª UóUËT©^S}®FU3Sã© Ô–«UªPëSSg©;¨‡ªg¨oT?¤~Yý‰YÃLÃOC¤Q ±_ã¼Æ c³x,!k «†u5Ä&±ÍÙ|v*»˜ý»‹=ª©¡9C3J3W³Ró”f?ã˜qøœtN ç(§—ó~ŠÞï)â)¦4L¹1e\kª–—–X«H«Q«Gë½6®í§¦½E»YûAÇJ'\'GgÎçSÙSݧ §M=:õ®.ªk¥¡»Dw¿n§î˜ž¾^€žLo§Þy½çú}/ýTýmú§õG X³ $Û Î<Å5qo</ÇÛñQC]Ã@C¥a•a—á„‘¹Ñ<£ÕFFŒiÆ\ã$ãmÆmÆ£&&!&KMêMîšRM¹¦)¦;L;LÇÍÌÍ¢ÍÖ™5›=1×2ç›ç›×›ß·`ZxZ,¶¨¶¸eI²äZ¦Yn…Z9Y¥XUZ]³F­­%Ö»­»§§¹N“N«žÖgðñ¶É¶©·°åØÛ®¶m¶}agbg·Å®Ã“}º}ý= ‡Ù«Z~s´r:V:ޚΜî?}Åô–é/gXÏÏØ3ã¶Ë)ÄiS›ÓGgg¹sƒóˆ‹‰K‚Ë.—>.›ÆÝȽäJtõq]ázÒõ›³›Âí¨Û¯î6îiî‡ÜŸÌ4Ÿ)žY3sÐÃÈCàQåÑ? Ÿ•0k߬~OCOgµç#/c/‘W­×°·¥wª÷aï>ö>rŸã>ã<7Þ2ÞY_Ì7À·È·ËOÃož_…ßC#ÿdÿzÿѧ€%g‰A[ûøz|!¿Ž?:Ûeö²ÙíAŒ ¹AA‚­‚åÁ­!hÈì­!÷ç˜Î‘Îi…P~èÖÐaæa‹Ã~ '…‡…W†?ŽpˆXÑ1—5wÑÜCsßDúD–DÞ›g1O9¯-J5*>ª.j<Ú7º4º?Æ.fYÌÕXXIlK9.*®6nl¾ßüíó‡ââ ã{˜/È]py¡ÎÂô…§©.,:–@LˆN8”ðA*¨Œ%òw%Ž yÂÂg"/Ñ6шØC\*NòH*Mz’쑼5y$Å3¥,幄'©¼L LÝ›:žšv m2=:½1ƒ’‘qBª!M“¶gêgæfvˬe…²þÅn‹·/•Ék³¬Y- ¶B¦èTZ(×*²geWf¿Í‰Ê9–«ž+Íí̳ÊÛ7œïŸÿíÂá’¶¥†KW-X潬j9²‰Š®Û—Ø(Üxå‡oÊ¿™Ü”´©«Ä¹dÏfÒféæÞ-ž[–ª—æ—n ÙÚ´ ßV´íõöEÛ/—Í(Û»ƒ¶C¹£¿<¸¼e§ÉÎÍ;?T¤TôTúT6îÒݵa×ønÑî{¼ö4ìÕÛ[¼÷ý>ɾÛUUMÕfÕeûIû³÷?®‰ªéø–ûm]­NmqíÇÒý#¶×¹ÔÕÒ=TRÖ+ëGǾþïw- 6 UœÆâ#pDyäé÷ ß÷ :ÚvŒ{¬áÓvg/jBšòšF›Sšû[b[ºOÌ>ÑÖêÞzüGÛœ499â?rýéü§CÏdÏ&žþ¢þË®/~øÕë×Îјѡ—ò—“¿m|¥ýêÀë¯ÛÆÂƾÉx31^ôVûíÁwÜwï£ßOä| (ÿhù±õSЧû“““ÿ˜óüc3-ÛbKGDÿÿÿ ½§“ pHYs  šœtIMEÚ 1;ïV·¿§IDAT8Ëu‘ËkÜUÇ?ßsgœ4ÔØøhª‚`µ©ÖG1 RQ‚”îܸp%èBªø”n"‚bРXJ ‹.4V iZð##T;m£µ!4™üæžãbâP­~7÷rîù>ιbwïý†cû†; m;‡oª”ÓAÜàΆ ζZ^«/®þôä£Ãç¸|îs¯ÝÉø{Óý;†¯y¿»Rº¥ð¸Â=È9(rÉt¦Vo¼¾û¡­ûG÷Í1±wíÞÿ#_àÓ©¹›{»¿ìî*•›E&ç å!€€ˆÀƒ(—Lç–VŸßuïÀ«oœéêûÁᲵ‘DŽÀ€ P„‡²G”“4ÿçÊ Ü:&€¯ç~™êî*ݳÖreˆuá: ‚ááS­-,ßUšœ©^Ÿ’ú›E&·™JY[ÃPà!RˆìB ŖޞʖR@_ÎôÈ€dBfó”€NvHfÂ"è2ØTÊî]­ˆR‘’ ³ö j§'BàÖ1‰ddAak…/DIJD… ’D2‘ÌH&L`&L† $Ex,6‹|Ö~_\©¿Pœ‘ $™ýMH`I˜©=Ÿ @¨±Z|õÈÎÁ|ttv´gcåЕ—WTZ'¤õ3rŽÈîje"ܵx¾9ÿö›¯°W> ¹mb©Ñ|by¥ˆ•fFRx{wí%Dúõå¹Z½±€áCíÿÞüô$õwdüÀôðÖ«ÞH¦mW÷nètaµ(ŠM<~;9¿ôáž]C/ñ_¸ãåŸ;÷ÉãÕ«§æã‹Õ#Ÿ}ûÀáÉïoÿ`zS§áÚ·ù_>:;x컓§?Ÿ©yóÝ©ÿ|}æ’~ûwam-/ž®7ž=¾0úìS÷5è»ØíRç¿š¾P"*Ö¯ IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/cpp-netlib.css000066400000000000000000000221101240331347200265130ustar00rootroot00000000000000@import url('reset-fonts-grids.css'); html,body { background-repeat: no-repeat; background-position: left top; background-attachment: fixed; background-color: #fa2; } body { font: 12pt sans-serif; color: black; } #custom-doc { width: 80%; *width: 960px; min-width: 960px; max-width: 1240px; margin: auto; text-align: left; padding-top: 16px; margin-top: 0; } #hd { padding: 4px 0 12px 0; } #bd { /*background: #C5D88A;*/ } #ft { color: #C5D88A; font-size: 90%; padding-bottom: 2em; } pre { font-family: Monaco,monospace; font-size: 14px; background: #333; background: -moz-linear-gradient(-90deg,#333,#222 60%); background: -webkit-gradient(linear,0 top,0 bottom,from(#333),to(#222),color-stop(60%,#222)); border-width: 1px 0; margin: 1em 0; padding: .3em .4em; overflow: auto; line-height: 1.3em; color: #CCC; border-radius: 3px; -moz-border-radius: 3px; -webkit-border-radius: 3px; padding: 1em; } /*** links ***/ a { text-decoration: none; font-weight: bold } a img { border: none } a: link,a: visited { color: #800000 } #bd a: link,#bd a: visited { color: #800000; text-decoration: underline } #bd #sidebar a: link,#bd #sidebar a: visited { color: #8B4513; text-decoration: none } a: hover { color: #000 } #bd a: hover { background-color: #FF9955; color: black; text-decoration: none } #bd #sidebar a: hover { color: #FF9955; background: none } h2 a,h3 a,h4 a { text-decoration: none !important } a.reference em { /*color: #FF9955;*/ font-style: normal; font-weight: bold; } /*** sidebar ***/ #sidebar div.sphinxsidebarwrapper { font-size: 92%; margin-right: 14px } #sidebar h3,#sidebar h4 { color: #487858; font-size: 125% } #sidebar a { color: #8B4513 } #sidebar ul ul { margin-top: 0; margin-bottom: 0 } #sidebar li { margin-top: 0.2em; margin-bottom: 0.2em; list-style-position: inside; list-style-type: square; } /*** nav ***/ div.nav { margin: 0; font-size: 14px; text-align: right; color: #fff } div.nav a: link,div.nav a: visited { color: white } #hd div.nav { margin-top: -27px } #ft div.nav { margin-bottom: -18px } #hd h1 a { color: #EFFFEF } #global-nav { position: absolute; top: 5px; margin-left: -5px; padding: 7px 0; color: #263E2B } #global-nav a { padding: 0 4px } #global-nav a.about { padding-left: 0 } #global-nav a { color: #fff } /*** content ***/ #yui-main { -moz-border-radius: 3px; -moz-box-shadow: 0 0 9px rgba(0,0,0,0.5); -webkit-border-radius: 3px; -webkit-box-shadow: 0 0 9px rgba(0,0,0,0.5); border-radius: 3px; box-shadow: 0 0 9px rgba(0,0,0,0.5); background: none repeat scroll 0 0 #6ABDFB; } #yui-main div.yui-b { position: relative } #yui-main div.yui-b { background: #FFF; min-height: 330px; color: #164B2B; padding: 0.3em 2em 1em 2em } /*** basic styles ***/ dd { margin-left: 15px } h1,h2,h3,h4 { margin-top: 1em; font-weight: normal } h1 { font-size: 218%; font-weight: bold; margin-top: 0.6em; margin-bottom: .4em; line-height: 1.1em } h2 { font-size: 175%; font-weight: bold; margin-bottom: .6em; line-height: 1.2em; color: #092e20 } h3 { font-size: 150%; font-weight: bold; margin-bottom: .2em; color: #487858 } h4 { font-size: 125%; font-weight: bold; margin-top: 1.5em; margin-bottom: 3px } div.figure { text-align: center } div.figure p.caption { font-size: 1em; margin-top: 0; margin-bottom: 1.5em; color: black } hr { color: #ccc; background-color: #ccc; height: 1px; border: 0 } p,ul,dl { margin-top: .6em; color: #333 } #yui-main div.yui-b img { max-width: 50em; margin-left: auto; margin-right: auto; display: block; margin-top: 10px; margin-bottom: 10px } caption { font-size: 1em; font-weight: bold; margin-top: 0.5em; margin-bottom: 0.5em; margin-left: 2px; text-align: center } blockquote { padding: 0 1em; margin: 1em 0; font: "Times New Roman",serif; color: #234f32 } strong { font-weight: bold } em { font-style: italic } ins { font-weight: bold; text-decoration: none } /*** lists ***/ ol.arabic li { list-style-type: decimal } ul li { font-size: 1em } ol li { margin-bottom: .4em } ul ul { padding-left: 1.2em } ul ul ul { padding-left: 1em } ul.linklist,ul.toc { padding-left: 0 } ul.toc ul { margin-left: .6em } ul.toc ul li { list-style-type: square } ul.toc ul ul li { list-style-type: disc } ul.linklist li,ul.toc li { list-style-type: none } dt { font-weight: bold; margin-top: .5em; font-size: 1em } dd { margin-bottom: .8em } ol.toc { margin-bottom: 2em } ol.toc li { font-size: 125%; padding: .5em; line-height: 1.2em; clear: right } ol.toc li.b { background-color: #E0FFB8 } ol.toc li a: hover { background-color: transparent !important; text-decoration: underline !important } ol.toc span.release-date { color: #487858; float: right; font-size: 85%; padding-right: .5em } ol.toc span.comment-count { font-size: 75%; color: #999 } ul.simple li { list-style-type: disc; margin-left: 2em } /*** tables ***/ table { color: #000; margin-bottom: 1em; width: 100% } table.docutils td p { margin-top: 0; margin-bottom: .5em } table.docutils td,table.docutils th { border-bottom: 1px solid #dfdfdf; padding: 4px 2px } table.docutils thead th { border-bottom: 2px solid #dfdfdf; text-align: left; font-weight: bold; #487858-space: nowrap } table.docutils thead th p { margin: 0; padding: 0 } table.docutils { border-collapse: collapse } /*** code blocks ***/ .literal { #487858-space: nowrap } .literal { color: #234f32 } #sidebar .literal { color: #487858; background: transparent; font-size: 11px } h4 .literal { color: #234f32; font-size: 13px } dt .literal,table .literal { background: none } #bd a.reference { text-decoration: none } #bd a.reference tt.literal { border-bottom: 1px #234f32 dotted } /*** notes & admonitions ***/ .note,.admonition { padding: .8em 1em .8em; margin: 1em 0; background-color: #6ABDFB; -moz-border-radius: 3px; -moz-box-shadow: 0 1px 2px rgba(0,0,0,0.3); -webkit-border-radius: 3px; -webkit-box-shadow: 0 1px 2px rgba(0,0,0,0.3); border-radius: 3px; box-shadow: 0 1px 2px rgba(0,0,0,0.3); } .admonition-title { font-weight: bold; margin-top: 0 !important; margin-bottom: 0 !important } .admonition .last { margin-bottom: 0 !important } .note { padding-left: 85px; background: #6ABDFB url(Button-Info-icon.png) .8em .8em no-repeat } .warning { padding-left: 85px; background: #6ABDFB url(Button-Warning-icon.png) .8em .8em no-repeat } /*** versoinadded/changes ***/ div.versionadded,div.versionchanged { } div.versionadded span.title,div.versionchanged span.title { font-weight: bold } /*** p-links ***/ a.headerlink { color: #c60f0f; font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; visibility: hidden } h1: hover > a.headerlink,h2: hover > a.headerlink,h3: hover > a.headerlink,h4: hover > a.headerlink,h5: hover > a.headerlink,h6: hover > a.headerlink,dt: hover > a.headerlink { visibility: visible } /*** index ***/ table.indextable td { text-align: left; vertical-align: top } table.indextable dl,table.indextable dd { margin-top: 0; margin-bottom: 0 } table.indextable tr.pcap { height: 10px } table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2 } /*** page-specific overrides ***/ div#contents ul { margin-bottom: 0 } div#contents ul li { margin-bottom: 0 } div#contents ul ul li { margin-top: 0.3em } /*** IE hacks ***/ * pre { } .footer { color: white; } .footer a { color: #333; } img { margin: 10px 0 10px 0; } #index p.rubric { font-size: 150%; font-weight: normal; margin-bottom: .2em; color: #252; } #index div.section dt { font-weight: normal; } #index #cpp-netlib-getting-cpp-netlib, #index #cpp-netlib-boost { background:none repeat scroll 0 0 #6ABDFB; margin: 2em 0 2em 2em; border-radius:6px 6px; -webkit-border-radius:6px; -moz-border-radius:6px 6px; box-shadow:0 1px 2px rgba(0, 0, 0, 0.6); -webkit-box-shadow:0 1px 2px rgba(0, 0, 0, 0.6); -moz-box-shadow:0 1px 2px rgba(0, 0, 0, 0.6); overflow:visible; float:right; clear:both; padding:1em; width: 380px; } #index #cpp-netlib-getting-cpp-netlib a { font-weight: bold; font-size: 14px; } #index #cpp-netlib-getting-cpp-netlib h1 { color: #333; } #index #cpp-netlib-getting-cpp-netlib h2 { margin: 0; } #index #cpp-netlib-getting-cpp-netlib strong { font-size: 20px; } tt.py-exc.literal { color: red; } tt.xref span.pre { color: green; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/default.css000066400000000000000000000077101240331347200261130ustar00rootroot00000000000000/* * default.css_t * ~~~~~~~~~~~~~ * * Sphinx stylesheet -- default theme. * * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ @import url("basic.css"); /* -- page layout ----------------------------------------------------------- */ body { font-family: sans-serif; font-size: 100%; background-color: #11303d; color: #000; margin: 0; padding: 0; } div.document { background-color: #1c4e63; } div.documentwrapper { float: left; width: 100%; } div.bodywrapper { margin: 0 0 0 230px; } div.body { background-color: #ffffff; color: #000000; padding: 0 20px 30px 20px; } div.footer { color: #ffffff; width: 100%; padding: 9px 0 9px 0; text-align: center; font-size: 75%; } div.footer a { color: #ffffff; text-decoration: underline; } div.related { background-color: #133f52; line-height: 30px; color: #ffffff; } div.related a { color: #ffffff; } div.sphinxsidebar { } div.sphinxsidebar h3 { font-family: 'Trebuchet MS', sans-serif; color: #ffffff; font-size: 1.4em; font-weight: normal; margin: 0; padding: 0; } div.sphinxsidebar h3 a { color: #ffffff; } div.sphinxsidebar h4 { font-family: 'Trebuchet MS', sans-serif; color: #ffffff; font-size: 1.3em; font-weight: normal; margin: 5px 0 0 0; padding: 0; } div.sphinxsidebar p { color: #ffffff; } div.sphinxsidebar p.topless { margin: 5px 10px 10px 10px; } div.sphinxsidebar ul { margin: 10px; padding: 0; color: #ffffff; } div.sphinxsidebar a { color: #98dbcc; } div.sphinxsidebar input { border: 1px solid #98dbcc; font-family: sans-serif; font-size: 1em; } /* -- hyperlink styles ------------------------------------------------------ */ a { color: #355f7c; text-decoration: none; } a:visited { color: #355f7c; text-decoration: none; } a:hover { text-decoration: underline; } /* -- body styles ----------------------------------------------------------- */ div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { font-family: 'Trebuchet MS', sans-serif; background-color: #f2f2f2; font-weight: normal; color: #20435c; border-bottom: 1px solid #ccc; margin: 20px -20px 10px -20px; padding: 3px 0 3px 10px; } div.body h1 { margin-top: 0; font-size: 200%; } div.body h2 { font-size: 160%; } div.body h3 { font-size: 140%; } div.body h4 { font-size: 120%; } div.body h5 { font-size: 110%; } div.body h6 { font-size: 100%; } a.headerlink { color: #c60f0f; font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; } a.headerlink:hover { background-color: #c60f0f; color: white; } div.body p, div.body dd, div.body li { text-align: justify; line-height: 130%; } div.admonition p.admonition-title + p { display: inline; } div.admonition p { margin-bottom: 5px; } div.admonition pre { margin-bottom: 5px; } div.admonition ul, div.admonition ol { margin-bottom: 5px; } div.note { background-color: #eee; border: 1px solid #ccc; } div.seealso { background-color: #ffc; border: 1px solid #ff6; } div.topic { background-color: #eee; } div.warning { background-color: #ffe4e4; border: 1px solid #f66; } p.admonition-title { display: inline; } p.admonition-title:after { content: ":"; } pre { padding: 5px; background-color: #eeffcc; color: #333333; line-height: 120%; border: 1px solid #ac9; border-left: none; border-right: none; } tt { background-color: #ecf0f3; padding: 0 1px 0 1px; font-size: 0.95em; } th { background-color: #ede; } .warning tt { background: #efc2c2; } .note tt { background: #d6d6d6; } .viewcode-back { font-family: sans-serif; } div.viewcode-block:target { background-color: #f4debf; border-top: 1px solid #ac9; border-bottom: 1px solid #ac9; }cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/dialog-note.png000066400000000000000000000030561240331347200266640ustar00rootroot00000000000000‰PNG  IHDR szzôsBIT|dˆåIDATX…–[l×Çgn{ñ.kì5Æ€ñcS›–ª´J„(ižªH©RòEIUT‰J}@}á©´ªT¤´U“—<4m_’¨ª¢¤¡@M”ÐV$¸vHØÅÁàÛÚk÷¾³3§Þ]ïŒok>éÓÜÎùþ¿ó}ç2‚MØïckÉà‰ &ž‘ˆ>[²Õvd@UEN…9pnåJüE+òö©ËÌÕSÔ%|‚½º*~'…òÈžQµ»¯iÝFCCCm‡L6™˜%6ú…uçî´c_-9üôÔ;|ñÀgŸÂˆæøƒ¢jÏ><è88(DÊÄI™È|ne0Ý@ G ÜÈèÍayíÚͼ´í?O8uöuŠ›øã÷hÅ'.víŠö?r⨮.$±Í$H¹sՔМÆVþuñR)þÕôŽýøŸÌÔðÛã4uñÙ¡CûÛ‡ ûÞÒ±ëvG¨m ʯLæŠrðgHÖ6Q½}ÎAk ˆ«èýÚžÿHgóâe“éEÚvvˆ@ƒh˜š˜=v¨W¯ŒQ ¨x;´…9×ÓÜðëŠ=1^wÊ×3{n†þ¾¥wOËP[˜sµß\%8œí‘ :ü£ç~ØìŒÇ×M»ö­çP‡ž^~“Ò'/¯M!ÊöüõO[XÈ:§/0 ž ýœèð@frãšKá W¹Q{‰œOòo÷E‚~ÎW^W^9J)Nô|ã›Â6“«©—7=Ï‹÷ÉeéÚÛ'„Pžxå(@Nçñ®íMºÌ,ÖWw…– Št¶…œÎã.€ ÎÉ=}~™ª/Þççëêæ¤Mº÷uA“.$}--ÈB¾®@²°ùÈR‰HsHú´Ê‡’CK¸©'e®ÝÛ%ènç¤î!ÓSK{†ÐF «ö üØR´‚\p†ª©8u®û*@y!Ë{ÿAæ–'¯Ðüˆ` "eyÏS±‘`@MIÑ.ä±þ$´-dv™ž;šÛ%^µR¹8ŽLO""ˆ`+-K‡S@SH¤’‰HHÓ–µ2XÁD¦Èüò$³IÄ–öÕÅkÍ)!çÇéiD ™Œo;š"g\n-Ü¿ÓŠ¶—;ÙPÊ s&2; öÊÓ´øú³l†\}++Ê,fÒ‚[.€¬ÅkñøÌ£;[ûÞºÿU³c— Û™Ùú¥qñϧ Y‹× f,Þ½“(X"´ÄŠ3jU3~ð*_$ð=ûÖ&¶ŸÌX‹w]/\ÂDá·oÆ¥V)æ•#uß÷×\r.ñH±±Y òí.aº²yN_I&inA¾ ZWÏ!só”>| Š™ Ô”öÝ\»1µÍsºòzÅÑËOò›î¨ï'GŽìGo€óà?#U wõsõúx16‘~éÅ·øy•ËÛv*Å™ØtáßÆKzï€ky0q¶«›‘ø¼›H6•âLíçѯŒá<º‡7gæò'UÛ í8Ð/sìÒæµU ½g€áÛóÎ'ÃÓ“Y‹ïž¹Œ«V«ïB kwˆ7ŠÅü±ù™d¤óà ¦ú Ȥê;ª…@¶#wõpåƒÛÖÍØÂçÿ¾Ëñ_}Èàªéj> p} ùßoô†íŽ‘[Ý>]Õ¢Cû…,ÏvÇvÍ¡ˆ†Z[Ê®nFã¦|çÊíüølñï¿üˆç?¸K†¥’ À¦|\x'¡øËU?ÞÃÞc]œ êØÝêWz»¶M[ 61t•¢åYÌ`Î-òe,aÍäœl‘büúbŒ/Bçk®+Œa/ˆ¿§‘–‡»xx_34v –àPé|‰û£s¼÷þÞ-XC¸r¿*€ðž{£œ%¥m\-§U²TÛ`•½Xãg×*7^ÑŠ°VVjb8e·= ˜+?»F¼ž)ˆÚQW¼b•,ÔBÊâžÙ_±ÿíO‰xÇ£ÐIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/dialog-seealso.png000066400000000000000000000027361240331347200273560ustar00rootroot00000000000000‰PNG  IHDR szzôsBIT|dˆtEXtSoftwarewww.inkscape.org›î<pIDATX…Å–[lUÇÿß™ÙݶÔÞì…R‹)¡Þ¸GB¸T MVcˆFÑYDž|‘G£QLLÔø¤‰KbÀ„¨$„5ATB@*Ò…‚”ZJé…Þwév/s;Ÿìn¶ën¡ÀÙ|9çÌœ9¿ßùæÌÎ3ãAq¯x|Ú—Ÿv×óܳ€íBÁ¯Ÿæ~P´pöŠUBÁ)O+yX<sYÝú:hõø´9÷]@‚ÚªzeíÓ/–“ÍŸ¶ø¾ *FÍnÌ,­—¿R õ¨Ç§5Þ" Œ<”_Ϫ7r5§ëÏ.mÛm¯ŸÎÿ€Ç§åh W‰èYf.¬ÎØÖøúõ °Ù„Ír•b¥âç¦ïññ¯¼¥ï¸gO[MûfWkµÕOæÏ(£<­9Î|Rѽ‹MH6a± —ȃŠþ{øf(p%6û½º9mOs’Àgîò- ‹_vW-DÔ Bç0Lƒ)£08 › ØlÁf1;„þXTr¡ÌY‹ó—ÎE‡oœe‰ü^=tÇŸVN,{lCÕòù5:¢ò&$[°ØHÖ‰Ô'®EšµƒMä¡Òµÿt\Ô{úº¯±Ä¿WO0Ô©V/|³tþúGWÎkTBÖ0nm6àÖîOÔ”r$d 'á«Ã4-ŒŽŒXö§Â§ðø´µUŵë—ÌÝ Í>“ €“?${‰0¤w$ç(qÖ@³ qâôñˆnÆÞ÷oÑ¿Hçdˆß÷ÝëžÚä Û£°X‡€ ƒ˜àRf@!GÊ„¾ØyŒ›ƒ0dP¦Íé98Ñr–îJÀmòþþž‹gliÁjî@è²tHMZ|°íGëùã;­XÚ99â²…þ'@DâÛwí s4òÉ‘KSFPúHiQål±:ÀyìsKçoÒÎOm«‰:ž¤ˆH)ÊÆ‘þÎŽãáÁ`aq…(|DÛðprÒ&wN AMȤ¯>N„’D$€”·aü€—J¶·(iœ[³èíXtÜlÿ½íëCŸÇN Â@idò6a§÷‰™OÉ$pj{ãÇEUËê_›c΋MWù0Ô%3(Òàö4ÚvzÒ’ýâ9ŠsÍ;•Õ³•š¡«7Ní t´Yf<©È”‰ô•K63Û“>H2܆D$3äÈ!Q±PuÏQÝŠJ°WêÝ'õ˜Çá™DÒ¥,f–“ö@Še§Ö‰U§?Vœ!R%lf¶'ñ¦ú$‹Ë¤ e‚S|òLI8gMë³s®ûœÝ‡ <U´´¥£}Öÿ­_ÎþÏÕ3y੧B‘ ¶2ܦ úàÉ&×rö=ëµjþ6´¿yǾ¿çg{Áø¯ZW­×S]½‘¶ÖV„Ã:4Fð=‹‹‹¸tñ¼qibÔVžüÅ+/ýzðŽ <£GÖPc²åK½ý[# Èä«ÈU ¸ÒȇЀå‰0zR Dð÷ƒo™é+GËùàÀÐÐ3έòk·Œ&ì¡e«Ö?²áþ/þ5gÂSy¬j¸gu#bá Î}Ë‘ªPuüÉLNIWñoo =öîW'Ξðuêfü–¶ÿàéF[W>¹þÇBŸÎ˜èNiØ´6Š¶DÀ†„“œ“Ô9÷"!á·7…ÕBÙ²Î_ɹ?|p:3¿²kÕšì¹³ï× °k×O㤋7{Ú»º(±iM­:41rAA2"D€(/ÞPWæÊÕÙœ¡ÝÜ9súdÿÆ }ƒ££§¬ÿ¦ÃnÀt¶½¹scØöÚ“„–„$H¹Dä0N6'²ÁæKãdrFVX×ìxCÀ(›N¡lK»¯s˜élûMunê? ìlí\ÊU,¬lÓáÃ÷ˆ)—@A9D°9#‹1f2N,3ƒs2‚U‚:«^ΔŠ}÷ݧé;ëß„¾×ÕãZ¦Š€ E.ã°‘É9Ä”d €ï3RÊW°]ÏcDÅ ®… U›V4§š¡¼Õu(åE5¡ÁS6LÇs‚Bs‰àÈaŒlÆ`A O|WùT¨¸ ÁWŒÈ7]ºà¤|?Z71­e'“˜^¨ZñˆîÌ!‚͈,²8#›sA*_ùYÓw¤´ƒ ‘""®Ÿ1ªÖ½ˆøX¹”ESTw –‘-Ze6lÎÈd&çdh Gz³ó%ó¼%åÌš‰¦ ®U‚Œ™Ë›ÂZ®X¶Ó&ëð<ó·×.Ž–W67z\#çòb5¿ñ®D*¤Ï•­t±ìN-V쉹¼9\1ÜqÁY6bÏ¥27ùh@h†®3ã m‰åŽŒT¥r_«û={jlÝÚ ßi]ÑkoY昮,´'BH%#-íMÁn®\<›ûv9ªÁ^"{K2í)”«Sl<ŸŠ7Þ­sÕyà¿—Ü/îqë;†€"×Þ:|ô¯¶å`WK<2<™7/;~µð˜*-‹…»:Û’&ãÑʃkç"Íw ¦šbk›¢úÆžŽÛÒÛ988h|îŸÑŽ=?é é¡|sÇnC‰È䊦€"Î3†éŒEBZ>à% C»xÐ/YÑ€þ£}ûž¥bñÉW^üÍŸo•ŸÝàÕ—žÿØu­ïž|÷ˆH6†™œuÕ6 FJ Î ƒ˜k_¼8‘t=çÓ†€èž7‹…òàíÄ—äÓé¹ôµXXðTž•ž™-gçÒIbL2]¹ï;ÚžžÔ5QáÄÚ®\™&yv)¹—ðòËûsRúÏ\›¡e ÁÕ†S‰}ôᱯ]úç{Û.~rtçØøÉ'V¯ŒêJpb=§N}Ó>XJnm©‘íš{ÿòúßÛ³cUª%©/L 8vñn¦€5Ý+E¿è:UuðíÃ××zqð¹Ù;ÞnßñøÁX¢ç±‡·lAOÏZ4F#à\# ›[À;oÆøøÄåùŒ¾îСì;ê´6çÚ²Ù†¯ÞxãOÈ.”àJ ÍA>7åä/x‡MØKÍY@z¦Â?»€]»¾û€+=ä ˜Ëd ”… ãY½vÕ““Õ3Ùóä³ óŽz@G"Cª£]Ý)œ8qcSp]÷õÿç´ïÞ{;00ðch\GâÂ…«èííÅúž.„Bâ[uå¬grwwóÓš¦„aL¡\6ALC¡X‚Àè¹05yÙ\ñR<îÿnfÆ”·ê†ë9Z-DǺÆÆÐ^!O*Ì9ƒR>”bPŠg•2Ÿ9“ùåü|±üY“ €¬îçq@¨EpzºdNNf‡;;{esswßîÝ?×6mzÓÓe;®8rdäÕjյ喝Ä׃jPK ªÿ Bétzº££ãž±±±ÖÑÑQ?ŸÏ?~üžçyüšÐuTí_s£®% š¨^E Dhoooö}Ÿg2™bMÀ`×BÖÂ`Ýl ê¹ ¯[ªÕœ»Ñ^ÜPåõJ¯»qËøoMJ<ålㆈIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/dialog-warning.png000066400000000000000000000025571240331347200273710ustar00rootroot00000000000000‰PNG  IHDR szzôsBIT|dˆ&IDATX…å—[hTG€¿™sÎîÙ‹»1‰«Y“&ë݈˪ˆ—xÉ‚—€Ä VD£4R%õ‚Z[郈}òÅÆXjò" &£¢` D%¼"f„ÚÍÆf“xÎéC’%&F›‹Oýa˜afþÿÿþ3ÿÌÏÿ»(#Q.e&(×Á® 9\Å_ao;ü ±28>\;b8JeoOIù3´i“‚aPwáBW<Ýö üñÙÊAi¢qnqq¶úàªJ<-ͺwþ|s¾ü:†boÈGÐ…)Á`¦[QD¬¦†Xu5Þädá RÜP4T{C(‡¢(?OYµJm½t ™š ©©Ä*+™Û¤ÇÎAÒgøŠÓ/«µ´Ðñø1ú8Ž#ÞЀÞÑ/'Ç.àûÏpÆ*º~8°|¹Özù2ʬYhùùØÂaÔ¹s‰]½JöâÅ6©ªß•Bú¨t¡ô¼<»ùð!]‘úþýÙ­î()¡óÕ+”¦&ü¡pbTJ!ÝîõgΛ§ÅªªÐ–.E[¸!B´`ÛêÕÄnÜ #Ԥñé䌀„™+WŠÎ;w0b1ô}û¢û÷öÎýû1b1ÌÆF2æÍ3%œ€³0Ë1~ü&ÿ”)jÛõëØ P§OÇ0 Z[[‰F£˜¦‰’‘cËÞÖÖâTÕë]Q +F  Â©ìü|+^SƒeY8vï ‰  ƒD"„8‹‹±…®{÷Èš?N[Ÿxì> P¹î¬¬¼Ô”åmm-ö­[‘~?B\.WbŸËåBLIÁUTDûýû¤&'K›Ï7­ ¾€BñËÔ5kx[U…p»ÑwîLœyèÎçŽÈqãˆ×Õ‘ ©N–ƒmÈç᫤ٳsܦ)Ûëë±ïÚ…LJJ8r8(Š‚¢(躞¸Òéĵw/Ožà•R¸&Mò½…]C8 ªT”“SÂaÙvå ÒïG/,L8Id¾Ó‰Óé|o^sô©Si¯«#+'GS¤üáwðüg€ Øá[°`¢ýõkÑñô)Ž={ºžˆ¾·÷xbÂëû°ó4\ºú–Ê$`ì4˜ €nöÉ‘Š„w€0 ÞM@ Ðkµè€ü¶}@L  èìiÖ(Ú™ü p ¢žáM/´IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/doctools.js000066400000000000000000000152701240331347200261410ustar00rootroot00000000000000/* * doctools.js * ~~~~~~~~~~~ * * Sphinx JavaScript utilities for all documentation. * * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ /** * select a different prefix for underscore */ $u = _.noConflict(); /** * make the code below compatible with browsers without * an installed firebug like debugger if (!window.console || !console.firebug) { var names = ["log", "debug", "info", "warn", "error", "assert", "dir", "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace", "profile", "profileEnd"]; window.console = {}; for (var i = 0; i < names.length; ++i) window.console[names[i]] = function() {}; } */ /** * small helper function to urldecode strings */ jQuery.urldecode = function(x) { return decodeURIComponent(x).replace(/\+/g, ' '); } /** * small helper function to urlencode strings */ jQuery.urlencode = encodeURIComponent; /** * This function returns the parsed url parameters of the * current request. Multiple values per key are supported, * it will always return arrays of strings for the value parts. */ jQuery.getQueryParameters = function(s) { if (typeof s == 'undefined') s = document.location.search; var parts = s.substr(s.indexOf('?') + 1).split('&'); var result = {}; for (var i = 0; i < parts.length; i++) { var tmp = parts[i].split('=', 2); var key = jQuery.urldecode(tmp[0]); var value = jQuery.urldecode(tmp[1]); if (key in result) result[key].push(value); else result[key] = [value]; } return result; }; /** * small function to check if an array contains * a given item. */ jQuery.contains = function(arr, item) { for (var i = 0; i < arr.length; i++) { if (arr[i] == item) return true; } return false; }; /** * highlight a given string on a jquery object by wrapping it in * span elements with the given class name. */ jQuery.fn.highlightText = function(text, className) { function highlight(node) { if (node.nodeType == 3) { var val = node.nodeValue; var pos = val.toLowerCase().indexOf(text); if (pos >= 0 && !jQuery(node.parentNode).hasClass(className)) { var span = document.createElement("span"); span.className = className; span.appendChild(document.createTextNode(val.substr(pos, text.length))); node.parentNode.insertBefore(span, node.parentNode.insertBefore( document.createTextNode(val.substr(pos + text.length)), node.nextSibling)); node.nodeValue = val.substr(0, pos); } } else if (!jQuery(node).is("button, select, textarea")) { jQuery.each(node.childNodes, function() { highlight(this); }); } } return this.each(function() { highlight(this); }); }; /** * Small JavaScript module for the documentation. */ var Documentation = { init : function() { this.fixFirefoxAnchorBug(); this.highlightSearchWords(); this.initIndexTable(); }, /** * i18n support */ TRANSLATIONS : {}, PLURAL_EXPR : function(n) { return n == 1 ? 0 : 1; }, LOCALE : 'unknown', // gettext and ngettext don't access this so that the functions // can safely bound to a different name (_ = Documentation.gettext) gettext : function(string) { var translated = Documentation.TRANSLATIONS[string]; if (typeof translated == 'undefined') return string; return (typeof translated == 'string') ? translated : translated[0]; }, ngettext : function(singular, plural, n) { var translated = Documentation.TRANSLATIONS[singular]; if (typeof translated == 'undefined') return (n == 1) ? singular : plural; return translated[Documentation.PLURALEXPR(n)]; }, addTranslations : function(catalog) { for (var key in catalog.messages) this.TRANSLATIONS[key] = catalog.messages[key]; this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); this.LOCALE = catalog.locale; }, /** * add context elements like header anchor links */ addContextElements : function() { $('div[id] > :header:first').each(function() { $('\u00B6'). attr('href', '#' + this.id). attr('title', _('Permalink to this headline')). appendTo(this); }); $('dt[id]').each(function() { $('\u00B6'). attr('href', '#' + this.id). attr('title', _('Permalink to this definition')). appendTo(this); }); }, /** * workaround a firefox stupidity */ fixFirefoxAnchorBug : function() { if (document.location.hash && $.browser.mozilla) window.setTimeout(function() { document.location.href += ''; }, 10); }, /** * highlight the search words provided in the url in the text */ highlightSearchWords : function() { var params = $.getQueryParameters(); var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; if (terms.length) { var body = $('div.body'); window.setTimeout(function() { $.each(terms, function() { body.highlightText(this.toLowerCase(), 'highlighted'); }); }, 10); $('

' + _('Hide Search Matches') + '

') .appendTo($('#searchbox')); } }, /** * init the domain index toggle buttons */ initIndexTable : function() { var togglers = $('img.toggler').click(function() { var src = $(this).attr('src'); var idnum = $(this).attr('id').substr(7); $('tr.cg-' + idnum).toggle(); if (src.substr(-9) == 'minus.png') $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); else $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); }).css('display', ''); if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { togglers.click(); } }, /** * helper function to hide the search marks again */ hideSearchWords : function() { $('#searchbox .highlight-link').fadeOut(300); $('span.highlighted').removeClass('highlighted'); }, /** * make the url absolute */ makeURL : function(relativeURL) { return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; }, /** * get the current relative url */ getCurrentURL : function() { var path = document.location.pathname; var parts = path.split(/\//); $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { if (this == '..') parts.pop(); }); var url = parts.join('/'); return path.substring(url.lastIndexOf('/') + 1, path.length - 1); } }; // quick alias for translations _ = Documentation.gettext; $(document).ready(function() { Documentation.init(); }); cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/down-pressed.png000066400000000000000000000005601240331347200270710ustar00rootroot00000000000000‰PNG  IHDRóÿasRGB®ÎébKGDùC» pHYs × ×B(›xtIMEÚ -vF#ðIDAT8ËÍÒ!OAàïÚJ, ++@ I v¢bÿ@Wñ7F’ HNâ±ú# ‚4¡8Ì6¹4×6Tñ’MvvÞ¼7³»êœûöDs¿‡aóxâ1†U îq‚;<¦ˆÏ E¸Â-f)âºj%ßpˆo4xFà78G…>æ)â-ƒ ž ¡ÂEYm4%7YTk-¾–Q¶a–"NWAo-y†eqÒá¾,)â ÓÒYÓÑú´ptŽÐå½\hóq´Îím˜sÔz¦ìG]ÄNñ‡Òa…‡röç߶¨s^lã vh\î2Ù%ðâßãŽ0EeRvØIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/down.png000066400000000000000000000005531240331347200254300ustar00rootroot00000000000000‰PNG  IHDRóÿasRGB®ÎébKGDùC» pHYs × ×B(›xtIMEÚ"ÅíU{ëIDAT8ËÍÒ¡NCAÐóÚJ, ++@ ™4>‡¨â/ÐUü’¤^,†~T&Ô3M^^^ÛPÅM6ÙÙ¹sïÌî*¥ôí‰RJ¿‡a)e¼GñÃ*ƒœàñ¹¡èW¸Å<"®«Fò ‡øFgÜã78G…>q ƒ†ÁOI¨p‘«‰:s“õAÕjñ5GÙ†yDœ®ƒ^+y†U:ép_%G§@D|ašÕ­O“£s„Æ(ïy¡M,"â¨Íím˜sÔx:÷£.b§@D|`–V˜åÙŸÛ²”²ÜÆìиÜe²KàÅ¿Ç/êG!‚ ™IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/epub.css000066400000000000000000000127341240331347200254240ustar00rootroot00000000000000/* * default.css_t * ~~~~~~~~~~~~~ * * Sphinx stylesheet -- default theme. * * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ @import url("basic.css"); /* -- page layout ----------------------------------------------------------- */ body { font-family: {{ theme_bodyfont }}; font-size: 100%; background-color: {{ theme_footerbgcolor }}; color: #000; margin: 0; padding: 0; } div.document { background-color: {{ theme_sidebarbgcolor }}; } div.documentwrapper { float: left; width: 100%; } div.bodywrapper { margin: 0 0 0 230px; } div.body { background-color: {{ theme_bgcolor }}; color: {{ theme_textcolor }}; padding: 0 20px 30px 20px; } {%- if theme_rightsidebar|tobool %} div.bodywrapper { margin: 0 230px 0 0; } {%- endif %} div.footer { color: {{ theme_footertextcolor }}; width: 100%; padding: 9px 0 9px 0; text-align: center; font-size: 75%; } div.footer a { color: {{ theme_footertextcolor }}; text-decoration: underline; } div.related { background-color: {{ theme_relbarbgcolor }}; line-height: 30px; color: {{ theme_relbartextcolor }}; } div.related a { color: {{ theme_relbarlinkcolor }}; } div.sphinxsidebar { {%- if theme_stickysidebar|tobool %} top: 30px; bottom: 0; margin: 0; position: fixed; overflow: auto; height: auto; {%- endif %} {%- if theme_rightsidebar|tobool %} float: right; {%- if theme_stickysidebar|tobool %} right: 0; {%- endif %} {%- endif %} } {%- if theme_stickysidebar|tobool %} /* this is nice, but it it leads to hidden headings when jumping to an anchor */ /* div.related { position: fixed; } div.documentwrapper { margin-top: 30px; } */ {%- endif %} div.sphinxsidebar h3 { font-family: {{ theme_headfont }}; color: {{ theme_sidebartextcolor }}; font-size: 1.4em; font-weight: normal; margin: 0; padding: 0; } div.sphinxsidebar h3 a { color: {{ theme_sidebartextcolor }}; } div.sphinxsidebar h4 { font-family: {{ theme_headfont }}; color: {{ theme_sidebartextcolor }}; font-size: 1.3em; font-weight: normal; margin: 5px 0 0 0; padding: 0; } div.sphinxsidebar p { color: {{ theme_sidebartextcolor }}; } div.sphinxsidebar p.topless { margin: 5px 10px 10px 10px; } div.sphinxsidebar ul { margin: 10px; padding: 0; color: {{ theme_sidebartextcolor }}; } div.sphinxsidebar a { color: {{ theme_sidebarlinkcolor }}; } div.sphinxsidebar input { border: 1px solid {{ theme_sidebarlinkcolor }}; font-family: sans-serif; font-size: 1em; } {% if theme_collapsiblesidebar|tobool %} /* for collapsible sidebar */ div#sidebarbutton { background-color: {{ theme_sidebarbtncolor }}; } {% endif %} /* -- hyperlink styles ------------------------------------------------------ */ a { color: {{ theme_linkcolor }}; text-decoration: none; } a:visited { color: {{ theme_visitedlinkcolor }}; text-decoration: none; } a:hover { text-decoration: underline; } {% if theme_externalrefs|tobool %} a.external { text-decoration: none; border-bottom: 1px dashed {{ theme_linkcolor }}; } a.external:hover { text-decoration: none; border-bottom: none; } a.external:visited { text-decoration: none; border-bottom: 1px dashed {{ theme_visitedlinkcolor }}; } {% endif %} /* -- body styles ----------------------------------------------------------- */ div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { font-family: {{ theme_headfont }}; background-color: {{ theme_headbgcolor }}; font-weight: normal; color: {{ theme_headtextcolor }}; border-bottom: 1px solid #ccc; margin: 20px -20px 10px -20px; padding: 3px 0 3px 10px; } div.body h1 { margin-top: 0; font-size: 200%; } div.body h2 { font-size: 160%; } div.body h3 { font-size: 140%; } div.body h4 { font-size: 120%; } div.body h5 { font-size: 110%; } div.body h6 { font-size: 100%; } a.headerlink { color: {{ theme_headlinkcolor }}; font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; } a.headerlink:hover { background-color: {{ theme_headlinkcolor }}; color: white; } div.body p, div.body dd, div.body li { text-align: justify; line-height: 130%; } div.admonition p.admonition-title + p { display: inline; } div.admonition p { margin-bottom: 5px; } div.admonition pre { margin-bottom: 5px; } div.admonition ul, div.admonition ol { margin-bottom: 5px; } div.note { background-color: #eee; border: 1px solid #ccc; } div.seealso { background-color: #ffc; border: 1px solid #ff6; } div.topic { background-color: #eee; } div.warning { background-color: #ffe4e4; border: 1px solid #f66; } p.admonition-title { display: inline; } p.admonition-title:after { content: ":"; } pre { padding: 5px; background-color: {{ theme_codebgcolor }}; color: {{ theme_codetextcolor }}; line-height: 120%; border: 1px solid #ac9; border-left: none; border-right: none; } tt { background-color: #ecf0f3; padding: 0 1px 0 1px; font-size: 0.95em; } th { background-color: #ede; } .warning tt { background: #efc2c2; } .note tt { background: #d6d6d6; } .viewcode-back { font-family: {{ theme_bodyfont }}; } div.viewcode-block:target { background-color: #f4debf; border-top: 1px solid #ac9; border-bottom: 1px solid #ac9; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/file.png000066400000000000000000000006101240331347200253720ustar00rootroot00000000000000‰PNG  IHDRóÿabKGDÿÿÿ ½§“ pHYs  šœtIMEÕ  )¶TIDAT8Ë­‘±JÄ@†¿Ir('[ "&xØÙYZ ‚Xø0‚!i|†_@±Ô÷•t§ÓDÄæÏ] ¹#¹Äxÿjv˜ùç› Y–ÐN‡ažE‘i«(ŠÌÄÉ™yž£µ@D¦£&±ˆ`Û6®ë–P¦Zk’$)5%"ôz½Ê.NñA#Aœba‘`Vsø¾_3ñc°,«™àä2m¼Ýñþjó [kŸìlv¹y|!IÕ´ðþyô;ÀðvÈé "Œß®°—a©?ŸAúðÄ7Œ`ô˜ñÇc^énôk?¸²Bg}»TЙ¹D#ÁÑÞ "R¹D1÷£çyüEŽRê*ŽãÝ6MJ©3þK_U«t8F~ÇIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/footerbg.png000066400000000000000000000005151240331347200262660ustar00rootroot00000000000000‰PNG  IHDRfÍÉÙIDAT8…“É‘Ã0í¬œZ샔%[®Ú‡Šâ58äù| X0`©‡˜Ôáÿo©„qNG@Å™Ï;mH#©¡¦8‰áÎáàKkƒÜ8FèOž-«&19çÀZ#¸ÆA¢dF\gƒ/8ñŠML—¦Gpº8ûdk躓à€éâ}œ}ºôts¾ìóœùe.¾uõ9dë=|úî÷¢­üð9àëðèè­óÉM÷êíÂþÖÓ±}ÈæÕ»æ™ëÁk>öÿ½´þÎÆÕ;«t.k~äí!;?ÀÛŸîZ¢Ôq‚–ÜYÁ:ßîw·óuËmMŽ|¬<äÈì¡ñ+3ëÝ9ðípâ-nù³V=F|˜IEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/ftp_uri.png000066400000000000000000000617421240331347200261400ustar00rootroot00000000000000‰PNG  IHDR}©^C‹ÝsRGB®ÎébKGDÿÿÿ ½§“ pHYs × ×B(›xtIMEÚ 58qk IDATxÚì]gXUÇÖ~i‚ŠAA»`‰5ÖØ»±ÆhŒÆ£‰&1±DcL471ÆvÕ5vM¬` * ˆŠ€b¥wXßõmöÙœ(Øî¼Ï3Ï>göì6eÍ;kf­Ñ#"‚`Ĉ;v,:tèPªëüýý±aÃlݺUd¢€€€€€€Àk =m¤/11gϞţG`cc[[[Ô­[VVVoeF„‡‡£]»vˆŠŠB¥J•Jumûöí1nÜ8Œ1¢Ø´›6mÂgŸ}†ˆˆ˜šš–é7œ>}ÁÁÁ€áÇÃÚÚú-»wïâСC "´iÓMš4­U ÜQPP€ 6 -- –––5j”Ö´ûöíÃÆ///|üñÇh×®ÈDbûš£GBêzMLL0qâD‘1¯D„­[·âèÑ£HHH@£F0eÊØÛÛ{mtt4Ö¬Yƒàà`899aØ°ahÛ¶m‰ú¹ýû÷ãÌ™3066†¯¯/>úè#•èCBBpúôiL:µÄß©¯)òÏ?ÿ„³³3¾úê+ã?þÀìٳѱcGää䨥ÅÕ«Wßè_¾|9>þøãR¾ . ** C† )QúŒŒ ÄÅÅ¡<¬>Dtt4/^Œ¼ÑåñôéSDGGcëÖ­8yò¤H/ùùùˆŒŒDHH/^¬5Ý¢E‹ðå—_bØ°a8xð ¼¼¼0fÌ8p@d¢€NÄÇÇ#::ÑÑѸuëæÎ+2å#'';wÆ–-[ЫW/̘1ÆÆÆhÚ´)üýý‹å¾¾¾ÐÓÓÃÔ©SQ§NŒ5 «W¯ÖyÝñãÇñÎ;ïàÊ•+>|8úõë‡Ó§O£Y³fˆ‹‹Ózݹsç0mÚ4899¡OŸ>X¶lY©Ù­‘‘‘T©R% ¦’bãÆ4nÜ8zSñàÁªZµ*%&&–úÚ¾}ûÒêÕ«KœÞÏÏFE™™™åö=ÞÞÞtåÊz0kÖ,Z¾|9 ¼Lܺu‹êÖ­«ñÜõë×ÉÁÁ’““ñáááäéé)2O ÄxöìYXXˆŒxÅøüóÏéý÷ßW‹?sæ ÙÛÛÓÓ§O5^WPP@ 6¤Í›7«q KKKŠˆˆÐ*C*W®¬±Ÿ^´huêÔIãuYYYÔ¡CúꫯèÚµk”˜˜H5jÔ(Õ·ªiúÐ¥K4jÔ¨TS"oòÒÀ•+WbÔ¨Q¨Zµj©ÕôgÏžÅرcK|M‡°iÓ&˜˜˜ˆá•€Àˆ9sæ`Á‚033SÄ»¹¹¡B… ¸{÷®È$7þù'¾ùæµxii‘¶Ù¦;w¢R¥Jxÿý÷ñööö:t(~þùg×mܸóæ̓···Ú¹¹sçâÎ;ˆŠŠR;gll ???|ùå—ðôô|®oU#}ééé°µµ}陞——‡ððpdgg¿Ôç>{ö 7nÄŒ3J}íòåË1yòäRO ?bbbp÷îÝç"×QQQˆ-õu©©©¸yó&òóó_JY$''ãÞ½{Ï?‘‘‘¥ÎŸ'Ož ,,Lã²…òáÎ;HMM-uy\»v Ož<)Õuééé¸yó&îܹSªïÌÏÏÇýû÷qõêU<{öì¥åOBBnÞ¼‰¼¼¼–)%‘'¸uërssKTv'OžÄСC5ž·¶¶Æ;wD/ú ÛWLL ™™YªöX´ü£¢¢J,O¤þëe}gVVBCCñôéÓ—–¯ˆˆˆ@dd$ ÊU>çææâöíÛŠôùùùˆŽŽ.—oKKKÓÊ{ìíí‘œœ¬ñÜñãÇ1räHçFŽ‰={öh<7}út|úé§Ïééé¡~ýúˆŒŒ,·ˆbcc©nݺäèèHU«V¥*Uª£££"Œ=ZMM8räHrtt¤jÕª‘©©©Ú5µkצU«V)®Y±bÕ®]›éŸþ¡ððpêСÙØØP“&M¨fÍšôÎ;ïЦM›ŠUSдiÓÈÝݾùæ›çRë~ûí·¿­¤SÂÚÔ¾ÒT®“““Z¾H¡¸é䬬,úì³ÏÈÚÚš\]]ÉÍÍÌÌÌhâĉ”ššªsz7((ˆV­ZEVVVäââBæææäèèH~~~¯7n9::ÒäÉ“)22’|||ÈÜÜœêÕ«G¦¦¦4fÌÊÉÉ)Õú/¿üB¾¾¾äèèHäèèHS§N¥œœÓ»YYY4gÎù“––¦õyyyy´|ùrª^½:ÕªU‹7nLæææÔ¶m[ -Ñ;ÿý÷ßÔ´iSêÝ»7Ý»wOcšÃ‡–ÿ²eË(11‘ D¶¶¶äååENNNÔ´iSZ´håææj¼ÇùóçiÈ!T«V-277'///244¤FÑùóçu¾ã½{÷¨ÿþdaaA^^^äååEæææ4bÄ5j]¿~]k»Zºt)Õ¨QƒêÔ©C-Z´ 5j§§'-\¸,X 65"Õigggºqã†Ú=¿ûî;EMï¾fͪY³&ÙÛÛ“——™ššRÏž=)&&Fë7¶jÕªð¾k×®%Iž :”ªU«FŽŽŽ4iÒ$ùLC† ¡š5kRãÆÉÎÎŽÚ·oO¡¡¡Z§wcbbÈÁÁAO³gϦvíÚQ¥J•èðáÊóóæÍ+6–.]ª–?!!!äìì\_4߉ˆîÞ½K...…i¦OŸNDD½zõ*ŒkРegg«];|øðÂ4îîîôìÙ³2iÏyyy´lÙ²ÂöåííMfffÔ¶m[ Ó*‡U¿_uÚ«hÞ)®ÍÏϧü‘|}}ÉÌÌŒêÔ©CŽŽŽd``@&LP“W®\)Ì×]»vQÍš5ÉÕÕ•ÌÍÍÉÏÏBCC©nݺäììL...tìرÂk—-[VØ=z”¨}ûö…ý—ƒƒ½óÎ;´eË–r™Þ½pá5oÞœ,--©I“&dggGöööôÛo¿•ÛÔg\\ <˜,,,¨aÆäááA–––4nÜ8:sæ Í™3Gãu™™™4{öl²²²¢ºuëRݺuÉÌÌŒ&Mš¤V&[·n¥Úµk“——ýùçŸdnnN...T«V-ºwï:tˆ¬­­ÉÙÙ™š5kFwîÜÑùΤ&MšPŸ>}tÊ £F¢íÛ·«Å§§§“‹‹ =yòDãuíÛ·§sçÎi<—’’B”——WªüNNN&;;;zôèQ±iŸgz·pM_ll,EEEÑ·ß~Kǧ¨¨(EÐD2RSS)**Š–-[FT»&::Z(äääPtt4uëÖ&MšDÎÎδeË*(((LsêÔ)rqq¡¹sçê|ù3g΀ mþ\222¨zõêZ‘.Ìœ9“f̘Q,)½ÿ¾Z¾DEE‘ÖŠ$ 3f ÅÇÇ+â?úè#rqq¡ØØX­¤¯M›6Ô±cÇÂ<ÉÊÊ¢ýû÷SÕªUéâÅ‹jפ¥¥ÑêÕ«ÉÝÝlllè¿ÿýoae ¥îݻӄ Ê\ Œ=šš4iB×®]S4–É“'S×®]é£>ÒHú¤ü;v,%$$(â'NœH...§v]NNµk׎úöíKwïÞUtTëׯ':pà@±ïíææVXï´ ½‚‚ºwïÍž=›H´páBENmÚ´¡nݺQ~~¾Ú=öìÙC6l ÐÐÐÂóÉÉÉ´~ýz²´´¤h|vnn.Õ¬Y“æÍ›GŠ:¿`Á@ÿý·Æk¿üòKjÔ¨ݾ}[€ZYYQïÞ½Õ„û´iÓhÚ´iZß';;›¢¢¢ÈÉɉ.\¸ –O½{÷¦:(ž™MË–-#[[[µk$<}ú”¢¢¢hüøñôý÷ßS@@ÕªU‹-ZDñññ”••E&LPûÖ'N••ýöÛo…„°  €öîÝKîîî´qãF¤/ €Ú·o_øÿöíÛdggGŸ~ú)R»víÔH_ff&M:õ¹ò'((ˆªW¯NQQQ”••¥ñÚGѼyóhòäÉ…e””D:t õë×+äGÑNéúõëdee¥±­<rrr¨M›6Ô¯_?ŠŒŒT´¯uëÖ‘ƒƒ:tH£,^²d 988¨‘ºììlZ¿~=U¯^Îœ9£è+¤g.Z´ˆ:¤©áááôÞ{ïш#4Ú]]]ÉØظð}Ž9BÖÖÖdccC{÷î-,ïæÍ›+Þ%::šºtéBü19;;Óü¡x'ªS§}ñÅeJúÖ®]KNNN´{÷nE|HHuèÐ TæòùæÍ›äàà@?ÿü³¢/OMM¥ uéÒEc»¬_¿>7N!ŸŸ>}J~ø!¹ºº*Ê*//ÂÃÃIOOlllèæÍ›…ƒggg²µµ-¤þøã4iÒ$ïíââR(ŸçÍ›Wìw‘««+mß¾½PÎFEEQçÎiæÌ™Z¯srrÒÚ¦‰ˆìííéáÇ%Îï‚‚>|8M:µDé_ˆôIøõ×_iâĉ¥ºÉúõëiìر¥ºfÀ€d`` U[ñøñc²¶¶Öi˜˜Hfff€œœœ´jK´á?ÿùõéÓ§Ô áéÓ§TµjÕ ´¡fÍš:IßðáÃu’Þ¯¿þšzöì©•ôuëÖM£±È”)S´’ÕíÛ·“±±1íß¿_í\xx8™››kÔdhh¨u0òðáCªV­]½zµLH_XXÕ¬YS«b#''‡Ú·oOüñG™•e~~>µlÙ’þúë/­iúöí«‘ô <˜æÏŸ¯õºùóç« 322ÈÈȈ.]º¤èkõõõ¡3gÎеk×hóæÍäáá¡Q R¤oæÌ™äãã£sp[¤ÏðU.òmÙ²¥Îó­ZµÂ§Ÿ~Š/¾øBk333¼û~öÎ;Q«V­bß¡(233±zõjœ:uªÜò%((­ZµÒé ÑÀÀíڵÕ+WЬY3‹Aµ]G:Ój» ËÌJ›ˆpêÔ)¬_¿^kš * E‹óÇÇÇGgþ¢]»v BÓ¦Maaa066ÆÒ¥K‹5|)‰€¯¯o‰¿·U«V:Ï7kÖ gÎœAAAôõõÆ?ÿü3vïÞ˜˜¤¤¤ÀÔÔµk×FRR&L˜ ÙBK_˜ÿüs@`` >þøã2iÓ¡¡¡011Á’%Kt¦»wïžNã°Q£F¡R¥Jhݺ5ÌÍÍáïï÷¼zõ*–.]Šàà`<|øP­Z5¸¸¸ ++«\ätqmºeË–X°`A™øá»|ù2ž={†éӧ딩ÑÑÑÈË˃¡á‹wí!!!:å8::büøñå³®wP•Ïš,X_zzzž»*†Žâƒ>(ŒóôôD=àíí '''Ö²¦¦¦HHH€¥¥¥VãÄ*Uªk óÑGáöíÛ8rä*W®\®¼ë•’¾ôôôb-jÊ¢òjÂwß}Wlç¯ 7nD«V­àîî^nù’˜˜X"÷1VVVHHHx#­ú²²²••…Š+êL§)Jš?ÕªUCbb¢‚ÃÍÍMçunnn¨Y³f™[‡7˜(JøвeK4jÔ+V¬@ƒ `ee…¬¬,DDDvÜÚP»vm:t¨Ðz.00'NœÀo¿ý†¶mÛbõêÕw…100À‚ °`Á¤¥¥!$$þþþøí·ß°xñblØ°A#÷ññÁùóçáêêŠ;v`âĉ¨R¥ öîÝ‹Ñ£GãÂ… jVò %®ëªeù"xôè<<úè#Ìš5 S¦LÑH¦¥©fÍš¸yó&ÜÝݱ{÷n\¼x]»vÅ7àááK—.¡yóæe’¯¥i_Å‘ó‡¢bÅŠÈÈÈ@RR’NÒ·mÛ6L:Ó¦M×_~‰ÚµkÃØØÏž=CHHÊÍ⳸þÍÀÀ ÌòÖÑÑŽŽŽ:Ó-[¶ ÙÙÙeÒoÆÆÆ>×\¥é¿ÊªM¿RSS¡ |ªr`êÔ©Ø¿¿FÒW«V-„‡‡ÃÕÕUí\NNÒÓÓuæa^^FŽ‰´´4>|ø¥¸r{¥¤ïøñã˜9s¦ÎyãÆËü¹GŽtíÚµT×åççãûï¿ÇŸþY®ùÒ¨Q#üõ×_Ŧ»rå &OžüF’¾Š+¢AƒˆŽŽÖ©%¹~ý:êÖ­«–?%ÑÂ\¹rŸ|òIáwww¤¤¤`РA¥öÉø¢@VV–ÖFíçç§6â7o4h ö­&&&ðððPËUäææ*4¡5kÖDÍš51pàÀ­íÖ¬Y£‘d¨j LMMѺuk´nÝ ,À¦M›0räHܺuK+©éÑ£.]º„}ûö¡B… X¹r%FË—/«i¥6lˆ°°°Bm”6•Êw¨.´oß7nÜЙFÛy;;;…[¡N:ÁÏÏ7nÄÞ½{Q§N­»áH¤¸{÷î¸|ù2Þ}÷]⧟~*ÌI+­ oooܼy¹¹¹Ø±c† ‚V­ZáÑ£GˆŽŽÖª!T-“ØØX¸¸¸ÀÁÁC† ÁŸþ‰?ü077/“|­_¿>’““1xð`­š’`éҥؾ};Î;‡«W¯¢{÷îØ·oŸÆ¾ ==ãÆÃÞ½{ÕäyÕªUÑ¡C‡oiõ<ý×´iÓtö_eµ}d“&M`mmýR·k«W¯üüüž«ÿ*ÉÎ4AAAåÏËFxx¸N7uŽŽŽØ±c‡ÖÌÕ«WÑ«W/µs.\ÐIÒ³²²0pà@XXX`Ïž=å¦àR@” s44|.úñãÇñûï¿k"""´>¯ÿþZŠêééá“O>Á‰'ÔÎ:tHÍѨ*FŒÄÄDÜ¿_£Fêüùóسgzöì‰ * S§N¸zõ*acc£¦Y455EË–-±jÕ*‡M›6á½÷Þ+“:Ú©S'lÚ´ IIIZë°¶÷±··ÇãÇ‘’’Rçéé‰~ø;vìÀ¾}û0{öll÷îÝèÕ«Waþ„„„àüùó°µµÕ¨y522Bƒ pöìYœ8q½{÷†žžˆ;vhÕô©–ÉŽ;0xð`ÀàÁƒ±}ûvש"99«V­Â?ü Ó_£ „åË—?wÙ|ùå—ؽ{7üýýammN:aëÖ­èÝ»7Ο?¯–>88uêÔÑ:€ŠŠ*7ßyGŽÁÆ5ž ÄÖ­[Kµ'ª.Œ1¿ýö›Vq¥‘Ï[·nÅ×_]¬Ï»6mÚàÈ‘#ˆ‰‰Ñ™.44T¡õlÖ¬¢¢¢tjXŸr)›û÷ïã›o¾ÁÿûßbË¿^½z¸qã†VÍí¹sç´8 €µk×jôñ¹iÓ& 4H«–¸{÷îpttÄæÍ›_á€21ä¸t陚šjô;—œœLüñ‡šá€hÅŠäååE'N¤àà`JKK£ððpZ²d ÙÚÚÒ?ÿü£ó¹ááá…fÙ&&&Z]¨"00êÔ©Sjß9DD^^^%¶zQëÝ3gÎP­Zµ4šSíÚµµZêÚ†íôéÓÔ¶m[­†º¸7jÔHãâ~UüñÇ…eR¯^½b­ 5Z Þ¸qƒ6lH-[¶Ôh¬púôirttÔ˜?W®\Ñš?)))…þ#5¹HIII¡eË–iuÃ"¡mÛ¶…ß¹råÊb 9>ùäêÕ«½ûî»töìYJNN¦{÷îѦM›ÈÞÞ^ã=ú÷ï¯Ñ]@tt4ùúú’‘‘‘VCŽ:PçÎ5ú^ËÉÉ!OOOúúë¯5Ö*Uªhµì]±b988h´Î,(( jÑ¢…˜áÃ?$___úðÃ5ÞóÁƒT£F ~²>|H¾¾¾ÅtÍœ9“¾ÿþû·¿iÓ¦Q÷îÝÕagffÒøñã©C‡Z·a:t(­X±¢Ôm^5TåÈøñãÉ××W§K¤9s毯/õë×O!w===ÉÚÚZ«µßÝ»wÉÍÍlll†ÞÞÞäë뫶_[^Iu]ÓVUEå}íÚµiõêÕZÛ×wß}GŸ}ö™Ú¹Ù³g“ÚövDì.ÈÞÞžüýýñ?&###ºuë–Ú5Û¶m£ªU«’žž^¹r¬\¹’<==iÒ¤IBiiitóæMZ´hÙÚÚ–¨¯(Ë–O?ý”:wî¬ÕíèÑ£Ô£Gþ7oÞ\X– 4(ö™‹/&nI’““iòäÉT¿~}…[ÉÄÑÑ‘Õ® "GGGµü)KC__ßÂï,ê+X›ü6l˜Z;òóóÓÙWhì£|»wïÆ®]»°nÝ:øûûãóÏ?/ÔܵmÛkÖ¬)Uþ@•*Uðï¿ÿbÒ¤Iظq# Ã! IDATºuëggg<~üaaa8zô(zôèo¿ýVç»—æ;%Ö¾}û°jÕ*|ûí·¸xñ"ªT©ooo8p@ãÔÕ²eËЦM\¾|½zõBff&.^¼ˆÌ™3Í›7/Ì›¹sç*ŒŒŒŒŸŸoootîܨX±"¢¢¢ð矢E‹˜7ožÚ3+T¨€ZµjaÔ¨QhÔ¨5jGGGÄÅÅáôéÓ ÃÁƒ5¶5===4kÖ èÔ©SaüàÁƒÑ±cGŒ7N«öìèÑ£9r$Ö®]‹öíÛÃÚÚ7nÜÀž={0cÆ Ø÷ïßM›6ˆ ?~\žÆÐ×ǬY³Ð¡Cy;}útxzzbÈ!pwwGTTöìÙƒÞ½{cæÌ™hܸ1ºvíŠæÍ›+´°sçÎE·nÝУGµõk=B5´jX›5k† . cÇŽŠüéÔ©“Æ5EªZÂï¾ûN1ÍÔ´iSdddÀÅÅ*TÐx]:u””OOO…¡Ç!C0gÎüúë¯ÅÖ]Õº^œŒ533Ù3g0iÒ$lØ°AcûêÙ³§bË«øøxôë×ðõõÅ°aÃðã?ÂÅÅ°eËlÛ¶ +VD÷îÝññÇãûï¿ØÚÚbÑ¢Ehݺ5ºw-[",, 044„ŸŸÚ´iƒ¾}ûÂÊÊ Û¶mCxx8fÏž{÷îa̘1øàƒÚí &`ôèÑŠúª)®víÚÀÒ¥K1eÊ„„„ fÍšhÙ²%._¾ {{{³E7n,4ˆËËËCZZš¢¿Õ××Çœ9sЮ];ŵ‹/ÆO?ýoooôéÓõêՃ€ÜÜ\|÷Ýw°°°(“²€O?ýhܸ1úõëOOOddd $$'OžD›6mpìØ1T«VMqÝ;＃_~ù €Z¶l \¹r~~~øùçŸ}é¡C‡°jÕ*¤¦¦¢{÷î˜?~¡¡Lvv6ºwï®ÈMq/"Ÿ—,Y‚ &ÀÛÛ @ÕªUqéÒ%bçබÖÚ¦7oÞŒ>}úàäÉ“hß¾=®]»???lÙ²E£æþîÝ» …¥¥¥V õÕ«Waccƒ† *â³³³1tèPddd~gbb¢â>®®®X½zµÖoÕ#"JKKÕ+W´n­¢§§µ‚Õ´.éäÉ“xöìœáîîŽV­Zi\ß1pà@ < x!rtðàAøûû£_¿~ÅZä…‡‡£}ûöˆŠŠ*õ‚ÉwÞy'NÄ!CÊ„ÔÕªU AAAZ+“„¤¤$üóÏ?¸~ý:òòòаaCtíÚUãuOŸ>Åõë× Š•••bÁºêvZzzzðòò*/^,¬HúúúhÚ´i¡•fNN.^¼XH²ÝÝݵ®ÈÍÍÅæÍ›qûömŒ;¶ØEÝÿ¯mFHHNœ8§OŸÂ××­[·†……"##qÿþ}èëë£qãÆjèÙ³g8|ø0®_¿Žüü|xzz¢[·n%Z€|îÜ9\¹r·nÝ‚­­-<<<àíí]" Ш¨(¬_¿5jÔÀرcu֧ŋ#==‹-*u=IMMÅ–-[KKKxyy¡mÛ¶°²²Rä···ÂJ,&&5jÔÀ½{÷päÈDFF"++ èر£F‹oiIRR,--±oß>„‡‡ãñãÇ°¶¶†»»;¨•`l›‘‘¡V8sæ ¼½½u®ËÍÍÅßÿk×®!11 4@ÇŽáìì¬1}BBBCCµZ”ëëë£Q£Fj{äZ÷óóÃ¥K—РA´nÝîîîÈÌÌÄ… …DÂÊ•+±|ùrL™2M›6EJJ Ž9‚ÀÀ@iÍ#Mù“ŸŸÿýWgþdddàâÅ‹hÕªŒ ãoÞ¼ ===†eÁÁÁ°°°€“““bÊ688mÛ¶UiÂÓ§O±nÝ:äææâÃ?,Vf•¶}àÂ… …󆆆hÞ¼yaÆÅÅ!<<¼°œkÔ¨¡¶ž588‡Bll,ÜÜÜàííÖ­[COOÈË˃¹¹9¼½½‘K—.!//¯0ï$B„ÔÔT¸¹¹Z”kŠëÛ·/F¥U¢ ñññ…kXµ®¹ÒОUñðáCœ:u 7nÜ@nn.<<<РA4nܸXeFNN6oÞŒˆˆŒ;Vçº`UDFFâäÉ“¸qãŒáì쌎;¢N::¯+*Ÿ¥þ«¨|~öì®]»"R“õ§NRËMqEßwýúõpppÀ˜1cJÜߟ;wHLL,ôVPkÚŒŒ ìÛ·W¯^EíڵѣG­ýHZZZ‰–£5hÐ@c[Sí«5ÁÆÆõë××Mú^ÅÚ¯²"}¥Á´iÓ`oo¯uÍ6„……¡_¿~…Ú„Ńàåå…øøøb®À›!}¯/Ο?íÛ·ãƨV­|}}1zôè23Œx}ñ¼¤O@àUÃðécçÏŸ_¬¶RÜÜÜXfæ÷›6mBË–-áxƒÑªU«b}µ üO“¾ÄÄDDDD 11wîÜ)$S 6TL[”ž‡ðl•¦k„6¤§§#44´pÚ<-- þþþصköîÝ+jß[ŽŒŒ ܸq111ÈÌÌD`` ôôôàææö\õI@@àÕ"!!wïÞųgÏpëÖ­—Ú ”^úôî† °eËÅš,_¾¼\|ò½Jœúè#­‹½Þœ9s_}õ•b­¬žž&Mš„Š xÃðûï¿cÛ¶mjý׊+Ê̤€À[Eú^>Ä¢2Aúé¤O@@@@@@@àµÃ°aÀ† oßw-YhØÁH&}={±±oÎ-[ìÜ)*¬€€€€€€Àó¡}{`Þ< 5õíù¦G€E‹•m0ÕI_ÇŽÀÏ?¿”•üú+ e¿º×÷€“pò¤hdoRSÞ½[[@eßUز…Ó·ióf ¤€k×€úõ;;àܹ²¹ç“'@çÎ\'lmWW`Ó&@8L(®_ç~_jKNNÀ¡C/vÏÑ£jÕ€””7??úöš6zôКLbc nnÀßÿ¿™ýk "àƒ€ÌL`Û¶7§ –/>ý¨PUÉÇ‹üºãÁn4×®À… ÀÿïC¬@ÇŽÀ©S@íÚÀ?ÿõê‰ü|Ýqô( þÔTà“O€Ÿ~*»{§¥“'[·ùù×°!0~<0t(w:êÈÍ6oöí“Û—°~=ФIÙɶm{{`éR [7@×Î[DÀÓ§<¨üHH¬¬˜„Öª=ß{de±’(:xö ¨^ ¶¶@qŽü³³Ý»9s}}àßù]´’>"ÂòåÀ7ß°mÈížÄÄ÷ïÉÉ€³3àæ”`CbµNõÖ- 1¨Y“_ÐÎŽ_X[úÙ³3gøƒŠÙäùµÃúõÀ¤I\‰»u>úèÞ]û÷ ¼DD¿ýÆäüéS&~Û¶ff%¿Gv6ðá‡,¨LM‘#‰OO‘¿¯üý5k€={X˜/Z|öYù<+&øÏ€ßçºð@ÐÇèЧš7.ÙàB@àmD~>pó&pú4ÏŒ<)· O`Ê ]»²}îåË<è‹Žfò×¼9sccÖÖÇÅñQú“£ù>ÆÆ@¯^À¨Q¬•44,žÔ8ÀýÍÑ£2©- &66ªW¬­yp>5jìÚżLdçÌóæñ@'' U+&cOŸ2ézð@.Uýú3f-[êî 7ofÍ×;êç 9Ãíí>pÚ'¸ã=sæÍ՜ܼ |ù% WªáÃfÍXØ;:¾ø323¤$9¤§s¾çäÈÇ ¸U¬ÈGªL†¯hæ§O¹!ÅÅq%ÎÊâwÕÓãF$ÀÜœG=\ôô^ìÙ©©@HÌS'NpÙ¸ºrY úüÄüÀ`ÁàêUþïãÃíÄÛ›ƒ¥å‹½;k‘TË;3“óN œoÆÆL@mmY`T­úây÷¼B]UˆffÊåmd¤,ïJ•ä²¶°(2ôð!—uP“ùÛ·9¾kWô6mZþy•ÅrìØ1ׯËçôõÖÖ¯Ï2¡V-5jp¾JðûgeÉe§zÌÍòò¸œóò4ÿ60à²64”C… üm¦¦@•*LM¹¼íÈËc9”–&ÓÒ8O¥|S zzr¾hþ]±¢,ã‹ËhÿøçFv6kÉîß—Ã;,'ÃÂø»%Ô¨ÁkÓºtáe66å÷^))À_k×ò;¾(êÔaÓ¢…æó&°¶ðEafÆükî\nKÅ@¹#Ç’%žwaã¸qÿ;W¨ “~)¿¤P©’²¼‰”e”ÄÊ“'ÊöÖ¿?Ë,]ƒÕòÆãǼ $„ÃÕ«J¹ ŠŠ呾…×óÊ•ùhb¢$œ×ÚB^žL¸%"§+dfj×p”LLxúÛÊJìíY)áà _7‚˜˜¨$6ññêáe¨’BmAdKÁÈH®Sš‘’àKr+=]–»’¦,9Yó{™šrÿîåÅ+__ Aƒ—_npÿüÇ<óS\dc£TVåæò`2(ˆÛÍÂ…LÆ$¤§Ó¦ñ3,-¹¯uuå¼{øP ůýõòâþjìXæ %„ú6l ÀâÅ<Í¥­C64ätrbFk`ÀÂêâEàÝwY›%Mù9¨‘k;êÔaA DEiÖJ¨_Ÿ3­ÿ·S•íïÏkNâüSÙ£õµ€¥%—gÏž<]íTApþ<¯k;|øõü>[[ž*èØ‘ÀZY•ïHrÿ~Ö&ž:ÅÁëggžÒîÙ“§K£ýMKŽçò>z”§^'èé±<ž?ŸÉš¶ŒÜ\å”ò“',cÍÌXÚ¨Q©ˆžnÒ§ÚiGEq¥~ð€§¥iW[[Íš‹y½š°z5W~àãÏ?×¼6*=ï/1ܼ<¹ñ>çG½‘HJb«Ák×8\¿Îjï²P5ëës…µ´”ƒ4e¦:šKNfž˜ÈáÎY;ebÂë='OÖ½€öÁ^ø~½²ã¯Y“ëNµj\®Õªñ{©jRRXªUíØ‹t 5jp]lØ××5oÎõìU!:šIñõërˆ‰)b\¡‚²¬--Y#&•uÅŠœN*kiŠ]UóY£¯Mœ0A·ð îØ!wtOá¬] ¼ÿ¾È—·Çó´~^OŸž9˯ÞdìØÁkW‹®ž8‘g2^µ‹AúJ ±%„€€€€€€€€ }‚ô ü“¾x· W‰‚ö³Ö»7ðË/"?ÞFñN7°‹!—DúŽåmFj×¾ÿ^䮀€À«C\»8‹kÛ÷SàÍųgì+´`÷nÙ ³€€ÀK }•+óVmÏ»©º€€€@Y¡zuÞ!fÔ(‘o+,-ÿü‡·ÿ|]pþ¼(׶N•-ékÝšwdx]P­šÈQÆ/iiÀÌ™¢<ÊDì7òµ$}Àóï¹)P¾xøwP¶ŠŠÒž628wŽ7nׄ‚>/!<\¹Á{Ard’—Ç›•gdhff&pý:_—ž®=]J o&!.Ž7µ.ºñ8ï$ñèQñ êî]þ15ôv¢R%‘o;^—3æÍrD lñóÏ@hèkLú*T…T^øá E Þ#ÒÓSŽ¿t 4ˆŸ‰ ¨$`&£G³qMÿþ<í5v¬úý÷íãíµ¾úŠ§KªUã†DÖ?¾ýpr:väïß}¨W¯‹Š-âó;ó5«Wóóš5ãöíSî?îîÀ¯¿+Wòs[·’’ä4AA¼¿oÀÂ…L ?ø€÷„mÚ¨Y“I-À[+ÙØñ&èãÇkÎÏ={xW‰¯¿æï­Z•×€©ØWdâ[PÀß^y½w÷¼¾_wº¸8Χ´“ÿŒ ®S7n0a×MÄ˱±ü99ºÓ]¼(o“©}^t4·ƒÔT@_8)xë¡içŒû÷[·Š¿6/ë{l¬ît¹¹< ²²¸ÄÅ)åóêÕ¢,Þ6·oËÿ“’X•¤Ÿˆ‰BB¸ŽiCApö¬üÿÖ-YÞîÙ̘QÖßCDÇŽ BÔ³'ÑŒDkÖ­[GjHN&Z±‚hð`¢®]‰>ûŒèñcešs爢nÝøÿDŸ|BôÞ{šï)! €hút¢Î‰FŒ úóOõ4DcÆíÝËÿ%:”hØ0¢ät11D ð;Ì›Gôä‰æg>zDôõ×D½{óû}ó QZ½Ö¸vó×ÕUý\ݺ|îìY9î—_ˆ¼¼”é>ý”¨ukeÜÚµDÍš=}Êÿ ˆú÷çû/ç÷Â…gbB4>ÑÊ•|¢ýû9¢Ê•9ígŸ:E4s&‘ž‘••2wìàô?ü ÇI÷3†ÿççmÛFÔ·/ÇwéB4|8Ñ]ºD4`Ç7jDôßÿM˜@tæ ×c;;>·¿ò{׬!jÑ‚èÙ3ù{¥ûOœøòË57—hÏnWúúD/:DdkËïðû¥¤¨×‡f͈:t š5‹ÈÞžÈÚšïU3gµmËåÒ®§óöV¦ùç¢Æ‰æÌ!zÿ}.¯ªU‰BC‰òòˆúõã²76&òð ú÷_ŽŸ9“ÈÔ”ã«V%š4‰(+‹ïyö,‘¯/_7r¤òy?ÿLÔ«ÑÔ©ü‘“˹¢¸r…ÛÙäÉ\¯ììXæIí쫯ˆ\\øyÆÆ,½¼4ßKàÍÀÇDß~KT»6QÓ¦ÜMddÄå\©Ñ–-ê×åç-YÂœbÆ –gUª}ðQf¦œ.6–e’“ß/7—åÀr÷—_XæééqœT§Ö®}¡ÏmÙÂå;D©©ü•+}ñ…2åÅ‹,ä7näŽÒÏ?ÞƆ()I3éóóã{÷êEdfÆñšÈÜüùÜÙùû…„uï®ìô£¢˜”êësüš5œ™>>ÜqKûÄ &™ñ=*WæøwßåN]Ç5oÎ% WW¢øø×·"ÆÅi'}ݺ©“¾¸R©~ÿ“'Lœ$<}Êõ(ïwáßOOèÞ=ŽKK“ó{Ã9­$T““ùœ—§*œù\Hˆ7}:Ç9"Ç>- kUHÑÃ(!AŽÏÎfA ­^­¼fÉŽŸ=[ŽKH ²´$Ú¾]™öüyù{cb^n¹ñ Hª³ëÖ1Yùúk&aRž®ün;;"77¹|ããùýMLdBKÄíÎɉ šjÞ4h $Wææ<¸’pû6—eh¨' fÍR~Ãҥ߫—ú÷­\ÉuQÓ§U«&×-"¢“'ùyîî\׉˜Xþç?r|ñÑ÷ßóÀ¥J–]D\MLXI¸|™…³ }ÿ¤oÄî+öíãöìãÃñ߯Ló&×õ¯¾’ã22˜,ýö›2½«+(%¤¤°ÌT\=~ÌÏrwåñ6`Ç¢±c¹L›6eeɨQ|¬RE–Gªý-×Áš5•}ÔîÝò}RS9îÄ Yf<_¹’å}µj215å:YFÕ«ÇKQM*éKNæÑóÂ…ÊtòË~ú©:é³³ãûJÑÉ“¯ÚÉH#óªU¹ÁIHKc2 ÈZ="Ö2LôüüäøE‹8ÞÅ…è£äL‹#ªS‡Ï]¾¬$9Õª)‰w¨ìëŠ'O´“>‰,«VÂÏ>ã¸Î‰îß—ã¯_—ÿþ»L²'LÃÈ‘r…üûoY#¦§Ç$K›ÆJÒôEŸ>|îàA9îî]&jÙÙêdÓÙYyý¡Cß¿¿ú½›5S/g"þ€’p¬YÃqcÇ*¿÷ý÷åï=|øÕ”oË–üüÁƒåQaA\Çõôˆ‚ƒeB°¦ZõësüÕ«rÜøñIÛÜ°¡2]j* (ss¢ôtå¹N”ïÀßRTö±æ 7N_µª,‹6ââXO˜ ~?‰¤ Ò÷ö“¾öí•3 þþߣ‡2½+"òó•ñÁÁ²GøÝ¿Ïq«V)Ó~ó }o;®\á253#Ú¹SŽgùð,†„½{9î—_ÔïÕ¹3Ÿûì39./Oîs~ýU]®• é«^5ª£í¸8¢Ÿ~’ÿÏžÍ/«Þ@úõSV|‰ôuî¬L›—Çš: e¼›«=?ViJfìX9íG©gQXÇW­ªþ…ƒó¹;”DÈÁ§wUŸ)i…,-ßÒwý:OãD+ò4š¤AQ%ùçdzgšƒ*)«P5*Ú`` ™ô}ð?篿4«Ä÷íãúÃ9““ºvVéëÔ‰Ï]º¤Œ?qB]èϚń#6Vû÷jšzÃÅ‹Êøœy`Å 9þ×_Y»­:`’ÚŽ*yûî;Y@Iš±¢ä?2’ÓX[íÚ%ÇÇÄ(µùª$ûÊ9® @ÖænÚ$ÇGGó@MÓKS]¸|™Ïéë+µî5kÊÓ»E1cŸÛ½[ýœ4š¤ïí'}sç*ãÃÃeE„«W9®ysÍ÷’¦†¥{egsÇ[±"?I‘‘œ¬ì7é{ûp玬¡+Šä¸4ÈíÒ…ãNROø°¼4Jµ‘f©ŠÎF–éÓG—.¼pÐÓøé'^œhc|ò‰¼ðïäIÀܜ䫢Q#vˆÙ·¯úbACCõ…¶––¼RZÔ˜œÌÏŽŒ–.Uoo`êT Iu+¼¢ ³ÝÜä—EQ«–¼€]B` ¿Ïwß)ŸËÏ9ÈÎ~;¡zx°åOß¾\¶?ýxy§N) ¶:³°ÐT tôôt?_OÃî IDAT³¸óEá縺²UîÿËeQ÷Õµ¸–ˆë¢¶ï52z½ÊÑÈH6ŽQ]œ>q"РÁ ~Gf gi°„Ù¨åìYN?q"[t{xÈiœœxçŠøxÞÝ m[®'ÜþU1n7m’ãdCX»VŽß´IÝpHªNNêßÚ —uA&Çk¯ÒBè:uʯÞ¼y\¹$&*û3muä®_—?þ˜åç'Ÿðù;33¹øßC×®ÌEˆ€;wøxú´v9$ÉÚ¬,–×LL^ªœÒÇ?°€OI¦Mã—Ý¿_™êæMÙbîE ¹s‘¬A¥oÓ†-85…I“t[h—YÒ9UBÁ˜¶gþø£ÜÁ¼©ÖFª°¶f+ ]»¸:ub‹O€-`ÞÊH²²dW/e]»Ø·ã—_óç¿—?Å}offñ–|¯5kª×÷”¶È=š­”ÿúK©Âɉ­qߟ-dû hØøûoeº}ûØŠºre¶îÐøôSu볡Cy¶m›,~øز…ï{î6"î ‡ Q^/ ÂT-´U… 4À,éàK"ÂÂ1¼€&«^Õz!Õ=m®UÕëÞÒ¥¼«Kõê<ˆ<˜ëtjªÈãÿUÉrJOe™Tg4Õ­5deBq^ Ê•ôYYqG±mkøbcy+µ¯¾Rjí22dPYAjˆ%1«/K°vQ—õë ss®`‰‰ê¾éTI‹„E‹äßýû3oßžó~çNŽwu•Ójr1>kʳgó÷ ª~®¼Ê§n]>~ó¬SÅçŸ+5¯ $mk½z|ŒÚµØ¯ ÀæÍÀ?ÿðàîéS W/¥ßC€µ€¡¡À{ï1i[¾œÝä¨ÂÌŒëSBÇsçX“èè(»ÈùýwÖâ6oÎé5u¬Ú\̘˜°ÜiÕªdy#ÍH™’ †þ7Q»6cb´×=€5ݪèÕ‹2~È2kÇv%ð¿‹ XÛW·.ÏdJ3"šê–¾>§·°Pº\{é¤OøC‡²“]Éóó’%2[•:É-[4ßå›ožïéÎÎ|Ü»W³°ÎÏçéȲ†³3{NÿýwÍçW­z} a… ¬¹{ú¸rEŽ÷ócÈ›„À@9LMYs£J"† aÂÿä w²!!²iÃVY7l¨,—Ü\Í£•ìlù¼&²­:‚ÎÏç:–­ü–ÿU’Wi°!]§é¹Ò¢¨¦Gz¦êû ÊyÇß+µ”`ýz&0 ¼ÚrÖäÈZ$ÍšñqãF.«aÃ4ûÇT­Ã‹ˤ§[7%©Û¾ãce)Û¿_n#þ©~Õ)ÞåËåz5bûŒÜ¼øåÍ£DæÔüý±±¼´ÃÔ´dù%i7÷î՞掮^#´hÁÇ›7•ÓlªuàÀ ©þW­ÊZòS§˜ø8 îÃR .Þ>h’Çì?ÕÃC(HuëÀõô©©\WZ·.½ïÐ2¬SúX°@þgiÉS;;³€ æøNø¸r¥ÒI!ÀMZ ]/)«V ¨_Ÿ;ó±cÕµLË–•cÕ6møøå—ìhS×®±&¤èšÄ× ]»òqôh^—8v,p挼þqñbYÃGĤ@Õaó¥K€­-¯óxtòÓOüÍ7oòzÊjÕ˜M™¢$Ç÷î1™ÈÏg•Eqã?3'GÝ¡pt´,lžz‘Þaà@vü^Öœgfò”CZç¹êt¶‰ ï Jþ³³•kñ$bç訙T¶mËέÿþ›ËÛËKÎßx`ró&àë«~í¼yœÿÿ­>à;wŽ—L˜ ™Ø«j$|ø!·mS::UMÿªn ”¤aÑÁfÑ&Àõ´woþýË/ê÷ò÷gMŒ40ÉËã=œUeNÛ¶r¿(µ iæþ}¹®JëÞlÄƪ+Žãú¦:›&ñ©;eù¬Z¯írM›| ®Ç’œ,:3SZP•*êî)>ûŒ-L$?3))²“X[[v±};[QÚÚ*-˜$‹–V­ÔÍF$G¹·oËqGŽÈ&ËÎÎì³ï§ŸØ眻»ÒõøqœnÑ"å}ÓÓ9ÞÈHý™’8U7ÉÉDÕ«Ë­“&±ä˜1l¹¨êçëuDb";~41a75kÖÈֻ͛³/EÉÎøñìÒ£~}öÿÓº5§»ySý¾çαugåÊ:t`Ëh {ö°µv»vzõRZR;ÆÎ%¥óï¿Ï×ܽËå ÅwéÂî$ËЩSÙ©p»vìʃˆãÜÝe_€?ÿ̸Ò=fÌ`+¼À@þFÕwZ¶LvåÓµ«|nÊöɨê6ÄLJÝ3T®LÔ±£æ|yÖ»nn²ë!"¶,·²bkD AAœÖЭÜ?ûŒË¶W/ŽoÓ†‰ff²ï({{¥UÙêÕlM¡l»+WÊíîþ}¶Ö.j1_Ô]RQŸŒgÎhöVÔâÒÀ€Ý8I–ØmÍ AJk¶äd¶bÔýIJèÑCnÓ ²l™3‡óàïÿâ u/o>&LÐlÙ/µ==¥zL ×;==ö‰)Õµßg/AArÚ[·øÓ§Ë}bF»1›6Mù<ÉÂ~Än“‘‘¢lÞëÝ¢¼#1‘%¤~äó·U+¹¾,¼¼XñѶ-ËmnVþü“뢅×VƨâàAö+ÕÏ=Ô}AJïж-»*º¡Às@þù‡`iÉSB<ÅÕ·¯fSôädžj»qƒ‚÷éêGÕõcYYÊk\]YmYtª¯zuåÂóÈH6¥Žæø^½€*UäùtMS‰-Zð{µ´¶æEåÒÚ4U´k'[?¦¦ò÷\¿ÎÓ;ót•€À«B—.Àñã\ß›5ã郲vSPÀÃmÖðªkàJ²—¶¶tÙÙ%·‚'âiŽ²ZV‘—'ß+;›óPìÁ+ PDD0‡iÚT^ï\™\RYû¡G$V ¼¶¤O@@@@àõ!}o8ÄÐW@àu‚´ýMt'$ ä± }%„仨õ®€€€€ÀË…´,íñcí~qß0ˆé]×ÇŽ[·²ë€ý&véÂN‘ÅZ4—"ö?|ô¨<oÑ‚·híÑC>×B… HŸ€€€€€€€€€ }‚ô Ò' HŸ€€€€€€€€€ }‚ô Ò' HŸ€€€€€€€€ÀÛC‘匧O'Oäÿzz€««ØOU@àuÂãÇ@r²ü¿B N‘/oó(oT¨,ZÔ«ÇÁÝðòöíãM^îÞåMÔä6úÞ{@b¢È·zD‚y¼ìÜ ¬\ ÊqµjƒqhÒDhÿ^îÝöïç6yîœ<øªQ;˜305ù$ HŸÀ âÆ `Ý:îp?–ãÍÌ€V­__ÀÛ›5NN‚ ¼â‰0àúuàüyàìY &F>_¹2Ð¥ 0nе+`` òL@@@>rÀíÛÀ©SÀéÓ||ôHy¾bEÀÍ5‚öör¨^°²â`m]þZ‰¼< ;ÈÊ⣲²ä8M¿Uÿçæùùòò4ÿÎÏ ¹ã54”ƒç…©)wÒ•+Ë¿ÍÌ€ªU9XZrú·ÉÉ<õ˜˜È¿ÓÒ€ôtÒïŒ 9¿óòä<ÎËã5¥rkûmbó±èoMç¤ ý¯P¡|ó!;HHàÏáÑ#àáC11À­[¼¦V¦¦@ëÖ@»vš6ŒŒ„,¤Oà%#&†5aa@h(‡°0îÌuÁÀ€ P¥JòÑÈHÙ‘J‚Uô¿D‚‚7'%X­O× öö€³óë5}WP¢„6O@@@>×DL##û÷åpïžü;#CäSiak ¸¸01pqa›&MGÇò{f\ÂÞˆ6"ˆˆ¢¢Š'1ê{{.¯Zµ”GGG.S¡Á¤ï­CRkƒâã•GéwR’<ý§ÒÓËO‹gh¨Ôò *(§ MLx ·hœ*TPNùþxJ3'G>¦§©©ü­©©²ûœ¸8ññ¬IREµj@ãÆZ´Ú·,,JÿýññRA"ª¤¡(¡ÈÏWN¿©†¢SÈ©{ Pòòx 5:š5§ÀµkLÐîÝ“5JMš:ñ‚ÿ6m4[f&àçÇÁߟ ¤¦en4lÈ¡^=ÖDÕ®ÍÇ*UÞŒz"@]ë1UãôõÕ‰¹ê##&wÂPI@@@@>WŠ¤$¶ôôóŽãõ•O)¼ÿíÝ{pTåùðoHÈf“@ B¸ 0Jå‡ )­­\z¬â… Fh‹ Šƒ-Ž-"‡Ki-:V«Ñ6 ¹  r r!÷ÝMÞßÏœyÏîžÝ$$$›ðý̼óžóžwwÏžœì>û¾ïyÏd àÒÒ€­[eÞÅ¢"©Ó®0r$0|80t¨\…MDDÄ ¨ Ø·OæY|ÿ}]%]Ȇ€ÔT`Ü8Ž'#""}DMÚ¶mÀúõ¾wSII,hþSƃ>"""" ^EMDDDÄ ˆˆˆˆôƒ>""""bÐGDDDD úˆš¹3€ÿ¸~osvâ°t©Ü>î™gäVpDDDà”-DÃéÚ´JK%PëÕ«îϹg0w®Ü!$'xôQ¹×ð¦MÀ¤I<æDD·9Î$KÔÂÃþÈÍ­Ÿ€ïÒ%i5\ºèÔIÒgŸÉmಳy¼‰ˆˆAQ£<¸þž+=¸~]Z ýûKo GDDà˜>¢æáÐ!Écc=Ëðƒ>jöœNàÈ ˆ**€âbéNµRRdd™™€Ûm]ÇáÐ]¥eeR·®22¬/ä8|XöÉpô¨´Úù“•%yttà×ËÏ—×,-åùADÄ (ˆ|û-0s&DD7êm‹½{KùÈ‘ž;p4Ø°X»èÚèÖ Ø¿ß³ÞÀ¯~ üñÀHÝ´4Ù®”,tî lÙ|ú)”$'˺ÚÊÏV®”±|R^\ ¼óЯŸtÍ^¼|þ¹ìÏ=÷íÚ¯¼âù\¿ø…<Ï¿ÿí¹î=Npûv¹°ãÅuë€.]€#d, 1è#jtwß ¬ZŒ+­u••zÛK/K–H¹¹µ¬ª ˜0xþy äþô'¹BÖ»EÍé” kØ0 ÿòWP ¯—™ \»äågÎH àùóÀG“'K«ZyyíßÓñã€Í¦[ç 'OJû¿ÿÉú¶m’Ö¬–/—×{åàØ1ý˜­[e?zÈsÝÜ ùöÛrõî‹/Êòš5Àþ<  ûCDD úˆ‚Bb¢uy¾egÎgÏ……º¬uki14[¹Rºi§NÕeýú<"áâÅ@Û¶ÀÏ~üð‡²==X±øÃ$\´¨öïeÐ à¹ç|»bû÷\ZöÙ¾v­ìÏœ9ÀèÑô~ýuÍ_ëìY 5˜8HIÑåÉÉr<._¦OçùEDtàÕ»ÔütèØíÒÒWU%“‡„HàT\¬ë½û.)˜ÙéÓ’›[Ô¢¢$Ÿ4I/×õ"‰ÈHÏý1—À˜1žå}úï¿/ݾ5õÞ{ÒÙ»·ï¶Y³¤¥4=]IsPHDD úˆ‚žÝ.ÞÊ•Э^ ,X<ö˜´ø€Ë%­`O> ¼þºõó´05„Ûl¾eue<§·ˆëò„ÉËÊjþéé’wëæ»-.Nä‹¥K™AQ³Æî]jžV¬>üPºg• 1&OÖWÄ^¾,]¥‡‚V)&æÖîcHHíÊoÆåË’çç[oïÒEòŠ ž3DD úˆ‚@uPU•oÙO*p<ñ„<~ófiäJØ-€½{=§F1ûÜŒñ.Xo·Û%¯Ï‰¢‰ˆˆAÑM3ºe¯^µÞnîòÌÌ>ø@–ããeŠ’/¾õ¿ÿ]ƸÙl2Kn.°l™ïó]¹,\ØôÛÀ’ü±õv‡CZC­Æüƒ>¢×±£ä_~©ËÊËe:Àó‚·[Æñ™!sñrß[@.dä*Ý—^ÒÏqì˜\Eû£éÇSÅX]xq³Œ.U—˳ܘ8Ù»ÜhÍ´êŠ-*’<'dz|Ö,¹KDZcÀîÝžÛrrdš˜§žªß.e""bÐGtÓ† ‘®Èôt™beéR§7b„lÏÊfÏvîÔÁá¼yz,[I‰tõNŸ®/Ƙ>]Z”’«Xccöí¾}eº” ôëWôîÛ'õëêÆ ÝjyæŒg hÌßg.7¯Ÿ8áY^\¬ï’‘á¹­MéÖŽŒÆ×sò•—Ë”-))25{!JÕÇ7QزEZåΟ— píZ¹5Ù ArWgŸ•;WdfÊØ=¥€sçdNº €)SdÎ:ó¸N'ðòË2 ò™3Òå;uªB¡¡Ò‚¶p¡ÜÎÍhíKNf̸ù.ѽ{õëS§d=!AæìÝxõU}—Œ¸8™8úñÇ7ßöì‘Ö¿¹sÈ /ÈsmÛ&ïm?øŸQ£ôk8 s îß/ãÃÃåóæù¿Š˜ˆˆô5ªÊJ Èéòt»u—­§3ðvƒËU÷¹÷š‚Ûå}ƒ>"""¢Û ÇôÝxG¢º(+«ÝÄÆ¡¡@«V""""ª1NÎ|+8¬_\¸¸^d$pÿýÀƒßÿ>Ђ±8ùQU?ìÝ ìß®ÇÀ”)œœù–«¬ví¾ú ø׿€§Óý˜à€ûîîº èÙSR|<%ÑíæêUàÔ)I'OJ‘‘ܸáÿ16’<ü00lðÿ„…1èkpN'ðí·À¡CÀáÃÒ˜•ää~\\œÝ»;JÔÞ¡ƒNwÜØí<¾DDDMEQàp—.I2–sr€ìl ô ý?¾E  sg‰z÷î½è×HNZ¶ô©Î /X””Hêpîœo ÑZ·¤U0.N'ïõèhÏ%9»•›¥¤y?Pª¬”\)ßd<‡÷ºñ!Ò¢â™û[6ò°0IDM…Ë¥ÿOŒÿs^] çHˆç²ÕºñS] åߥ)q»âbI%%zùÆ /Ï:]¿.yn®Ô­N|<Ð¥‹¤Î%ïÚ¸óN G "¢Æ»Ë ¯)…pù²$cùêU9q®]“”› äçë/ðÚ°Ûu%ëv»œPƲw™Í&¿&ÂÂ$7/{çV‚97/[*þ«rï²ÊÊê“Û]÷zn·N.—çºU2¾tŒ/ž@¹y9˜çAuÉ8/ÂÃå|²Ù$÷NVåF™q®šÏÛèh'Ë/ÏàUZêùi,—•I*/ש&ëò¿(ÿoæõ`e|††J2–åÆ.ã+P2ꄆ꼺T—zVŸñÞqMÊŒróß@¹ñÙoþÛ›?›½Ï ó9eNÞeÆùZR"ç^m……ILÛ¶ÒP“ ËíÚI¯]b¢$cÙf«¿S‹A_3TY©MäçKÊËÓËF*(_#F*,”¼¼œÇš¾ˆß`ÐXŽ•ÔºµNþÖëñ·I«¨Ïˆ‚ÉÍËæ²ÂBÌy·~””H2ZɈšªÈHùŒˆ‰‘d,·n ´i#).N/ëññRÇh nèß úȇ˥Aó‡·¿TR¢¹{§ÒRÏ_æÁÞJEÕ·@¿æ­Z üuפ›Ø¼î¯«Ú{½²RÆɺ\žy}ò/¿Ä«K±±Áÿw,)‘^£—ÀXöNÆÃÂÂúý1Ø¢…´ð-½FîÝzåoÙ8G¼‡9XuÁVW¯ªJ·Þ{çüzlÚBCuï€Ý®ôy§ÈHýÃ0PjÕJyM´'A5,·Û³kÆHòe]]²êõ.«IwimƺÁNMÆíÔfìNMºl¬rï`«6y]kìCSPUå:òÄœÊÊ|ËJJôž¢"Ï–póz +ðm6 þ’’€Nd Ž9ïÔI¶ßª÷íp/ÊTQÞÉá`®¬,ðó´l©¿ÜÌ_tÞëFWºÝ.¹U2†˜ƒ»¦tYƒ·"·*«Í?¥šŽõµú,¬î30Poî Ô-m  ÷LÆùd^· Â1Æ úˆˆê¬¨Èw,­y9'8^’Õ@íˆ «î’“^½$OJ ÜõSZ*|eeétö¬u—.ù««ƒÎŽõX"«ÔZ+‰ˆAQP)(Ð`v6ðÍ7À‘#2±ªÕ ðèh™£Ó[µò ò.\ðßí ôéôí+©[7èÅÄðoAÄ AQƒs»ÌL - ؾ]fÖ¯íÇqx80|80~<ðÐC2g# '"}DDDD8/ƒ>""""bÐGDDDD úˆˆˆˆˆA1è#""""}DDDDÄ ˆˆˆˆô1è#""""}DDDDÄ ˆˆˆˆôQ`»v³f5ÞëçäóçÇóoAÄ ˆˆêÝßþôï<ôðÎ;·«W¯½,^Ì¿ Q3ÆC@DÔHÊËŠ 6VÖ{ ¸ç 9¹q÷ë—¿¾ûxöYëíW®íÛóïGÔÄ„(¥Q#xë- gO`Ô(]æt6›¤òòàÛg‡xùeàÝwù÷#jbؽKDÔòó7Þð-‚¸fÑ"i$"}DDÍR}vŠ8ÀĉÀ… ÖÛ"ès»k_gÍšÆkHD úˆˆnY ÷ç?ýúÆIIÀ˜1ÀÇë:iiÀ¯ Œ-éìY)/)¦O—ú£GëîÐìlà¾û€/¿”õùóeûìÙÖûpèððÃ@t40r$•e]ï¿ÿfÌ&L1£F[·úÖÛ³˜2hÓFÖßxèÐ;¨ªŠ‹%°ë×xþyý¸iÓ€§Ÿ–対Òï÷ÿÇë'ê÷Èø¿éÓeÛÏœ>ÍóŠ¨ñ>ÓˆˆÈÒﯠÔÞ½²ž›«TÇŽJ…‡+uø°®WV¦Tb¢Ô=zÔó9ž~ZÊçÌÑu¥}TÊ·n•õë×õc""”²Ù”úüs©·|¹®?dˆï~®Z¥Tt´Þ§ª*¥~ó©?s¦¬+¥Ô¦MJ+å¡¡JmÞ,Ïk³)¢Ô‰J¥¦*Õ©“~¬áòe¥6n”òñãeŸ¥Ün9>áá²mÓ&ßý;xP©–-•ÊÊâ9EÔˆØÒGDäÏ{ïÉÊzB0t¨tÏîÛ§ëEDÝ»[?Ç€žë@b¢ä€´¸%&qqžõ\.àèQ`Ç`Îàƒ€ï}ع8sƳ%pÎà·¿î½WÊBB€åËå"‘U«€¥|Ò$௕åª*™‡oÇéf>pèÕKZþžzÊ÷}´o´n-Ëv»ìsb"*ÇÇh©""¦M“`Ê*ˆ»tÉëÓÔÏÇihèͽvË–@jªçóôè!˹¹º|ùr{—’â»?óæÉòüùº<*J¶…„èò¶me~@C«VµßßÔT 2Rå7<·­Y<÷Ï'"}DDAjÁ`áBY>pxòI`ÃYw¹~Ú¶•üÚ5]öÉ'’ßu—oýAƒ$ÏÉ‘d°Û%è‹Œ´~»½öû– ǧ xûm•4/¸>IDAT]¾k—\˜òàƒ<Ÿˆô±´4`ð``ûv™®¤1[¬ÂÃ%w:%ÏËÓ­jF™Y—.zÙáÐË!!_§ºíþ¤¦J åÊ•@i©”­^ <ó Ï#"}DDAlÝ:à'?‘¿×_:v ®ý‹‰‘ ðíndÜ`T”ä}úÜúýéÔ ˜-ݕÆ#Føn¯¬ô\7ºJ.o·âîaa@ïÞ²œžî»½´T¦Ž8P.HióæɘÁ7ß”Àoüø›#HD úˆˆÄ7ßH~õªgy^žggŒí3Zwîô wï¶qsW®H^\,WÔ’ËV̧qÕì¦M¾1ÞøqžåJI]ïÀÕ`Þ@û¬PTäY§gOy=‡CºÃýÝ¿—ˆô…áÃ¥ulÿ~ ^öî•ñ|Ÿ~*Û¿þX¶ ÈÈucº” ä⊴4éê4ZØvï>û ¸xQÖ)^6o–.ÐåË¥…ìúuŸçrù^k¬›ïä1y2ðÈ#2éóÌ™ºÜí^}UZùÌWy¹ J§NY¿wcüŸù‚ó>gdÈÕ‹……¾ÿÝï$¿ÿ~ o_žKDÁ‚Sù±l™Rññ2ép×®JíÜ©Tv¶Lfܪ•R[¶èº.—Lœ,á”RÝ»+uò¤RëÖÉúàÁR¿¢Bê_¼¨T·nzÛ•+J}ò‰RC‡êç=Z©?Têôi¥fÏV*,LÊ»tQjÅ ýÚN§RÓ¦ÉÉýûˤÊ))JMªTq±®÷ÑGžÏߧRo½¥·WV*µd‰žh:"B©¹s•ºzU×yâ Ù–”¤ÔŽþ]JŠLæLDA#D©ú¼¡$Q3SQ!­sݺé«Zsså¶hVS›dfJkZß¾Òrwþ¼tÝcï̪ª¤û81±þöõÈi)¼ûnß ŸëË•+2}Œ¿¹ óòäýgg7ÜXB"ªƒ>""ª_¯½äçËÝ=ˆˆA5.—ÜîÎ;sçäî ‡II<6DA„rQÝŒ#wiß^º•_xƒ>""jvRRd|_B‚\…å[£”X¾|9455K|ÞåË—ñäÉ^™å!999xúô)‚‚‚„àà`¾Q¾2’““±lÙ2èêêòñcÇŽHMM-Ók&&& ûrVVßÈeˆ¼¼< ^T!žÛÑÑï޽̟?/^ä?f!„……«/ªN›6 ÑÑÑxñâ²³³Ku³ÜÜ\äää Zµj%>7!!µk׮Рíç燓'O–øÜ 6`áÂ…<µò‹Û·ocÉ’%(((Ò[nn.ß0_;wîÄ/¿üÂ+´?0²³³±uëVܺu«HõæÍ›ˆŠŠ‚ššÌÌÌеkW(++ˬ¿yóf\ºt /_¾„,,,øÆ.#Ü¿óæÍòÊgÏž!;;»Ü[;ãââP¥JÀ§OŸPµjÕþ[À××çÎùsçÐÐP´hÑBáyJŒ1–““ƒêÕ«—Z¡Ý¿?ÂÃñiÓ¦'P¯^=$$$T؆5jš7oŽE‹•è<Œ=ÏŸ?—Ëüxð( R÷SÅSd qçÎ4oÞœo»wïÆÕ«WqîÜ9™Çããã1sæLܸqÝ»w‡±±1ÒÓÓqýúuT©R§OŸV8 ²´´Äþýûy…ö+BKK ‰‰‰åZ¡ÐÐÐ@nn.”””о}{¡»ÓŒ>}ú 66}ûöEŸ>}0zôh=z´H…Vµ,nž““Sªé“‚‚‚2ŸÒù–ˆÅ¥K—JåcµaÃÌŸ?ŸWfyð(GðôôDÇŽyeö†@ ÀÆqäȹubbbàïïÈÈH‰™ÉuëÖaÎœ9=z4nܸÁ7&…HNNFõêÕ¡¤¤HJJB­Zµ~øv9{ö¬„nĵOQPåIªôøóÏ?1vìXT¯^½Dç…††ÂßߧOŸæ‘r¦È;vŒoŒgÎœ®®.¬¬¬äÖ©S§Ú·o/åf§¢¢‚M›6¡qãÆxõêš6mÊ7(¹øüù3´µµ%þWd̲Bi }R íÉ“'qðàA¡aÆpppÀü!3piýúõxþü9^¼x¤¤$Œ5J⸒’Œ=zH”?xð{÷î…@ €@ :4h€µk× ÿ¿}û+W®D^^Ú´iƒéÓ§ãÌ™3ðööÆÇ¡©©‰Î;£Gøå—_Š¥TîÛ·ÆÆÆ3f *UªTbBF…Ê•+£[·nrÏÿþ=V®\‰'Ož ::Íš5ƒ –-[&5ŒŒÄš5kŸŸ+++Lœ8Qx,66«V­B^^`õêÕhØ°¡Äùضm›ÐqÏž=¨T©¢££±}ûvܽ{VVV˜5k ¥ž•1†]»váܹs ªª*Œ1jÔ(tîÜÿþû/† "u^~~>6oÞŒëׯ#$$ZZZ033Ãäɓѵk×Ñï† ðÇ(¬Ó¨Q#¹\555˜››#22²Ø ­8€îÝ»cèСRõ"""°víZ!66Íš5C‡°lÙ2™–½û÷ïãÀ`ŒAII cÇŽE§N„Çýüü°sçN@II ÎÎΰ··/ußß»w/|||„ÿ Ë“ÂÇÕÔÔ°jÕ* Ú}üø1¼½½ñìÙ3„††";;ÆÆƘ7oz÷î]¦ÊäâÅ‹‘““#”…RSS±`Á¡{ל9sЪU+™×¹qã†o¥§§ÃÔÔÝ»wÇìÙ³¡ª*Ûf˜’’‚>àÙ³gÐÐÐÀóçÏxûö- aÆBZNæ1Æ0jÔ(ØØØ`óæ͸wïдiSØÚÚ*”%?~ĉ'àçç‡ÐÐPÄÆÆ¢aÆèׯæÏŸ/ôã•…/^`ùòå Dnn.lllðÛo¿¡gÏžX±b¢££¡¡¡M›6Iù_¾|{÷îEHH233ajjŠ^½zaúô鲶LaqF2oÞDŸ>}зo_899!-- ÷îÝC×®]1uêTá¹FFF°³³CTTùóç# OŸ>ÅÊ•+qñâE´iÓ{öì‘©ÄL:3fÌÀ°aÄLzÚ´iغu+zõê…ÌÌL)þÁ¹899áÉ“'PUUÅ AƒÐ©S'ØÚÚâÁƒÈÌÌÄ–-[Š­È¤©££#äQgÎœANNþþûo¡5oÇŽhݺ5zöì)Tü8xyyÁÚÚFFF8~ü8bccqèÐ!Ô¯_íÛ·ÇåË—åÞ·wïÞ¸ví¶lÙ‚W¯^ c.^¼ˆQ£F!44Tæy—/_FÛ¶mÑ°aC}„ƒôÂ8{ö,:uê+++\»v >|8-Z777\¸p7†ƒƒƒD¶'@ggg,Y²ãÆÿÿþ‹ððp¬X±·nÝ‚ >}úT¶Bˆ1Ʋ³³æààÀÒÓÓ™8òòò˜žž»wíÛ·³)S¦°’"77—©©©•èooo¦¢¢ÂYnn®ÔñôôtfnnÎ<<<^§mÛ¶ ÀŽ?^¢gÈÈÈ`õêÕc/_¾,ñ;Ïœ9“-Z´Hadz:HÝ3++K¢¬qãÆìÝ»weæææìéÓ§Âÿùùù,99Y¢ÎºuëØÊ•+%ʶmÛƦOŸ.Q–šš*ÑÆñññLOO•nݺÅôõõÙû÷ïe¿zõ*322bRÇ ØÌ™3™KKK–úô‰YXX°Í›7—øy"""˜†††T`Œ1{{{6`À&„eMš4aýúõ“(kÕª “8w„ LEE…­]»Væ}Ÿ>}ÊjÔ¨!už,¨««Y'==Ë¥ëÏŸ?3vóæMV–˜9s&›6m+((:–ŸŸÏ:vì(E׌1æîîκtéÂ233¥Žåå屡C‡²©S§JSVVfîîîÂÿ111 €Ä·g:::E>ûõë×™¹¹y‰Þ·V­Zlîܹ¬Q£FìÑ£GRß@Ïž=c:::r¿ñ“'O˜žž‹‹‹“I—µjÕb)))2y‘¡¡!»}û¶Ô±ÈÈH¦££#ÁÄqöìY¦¯¯/óºgÎœaÆ “ûî-[¶”{]šššlÞ¼yÌÐÐ(lÆ1b[¶l™Ìkeee±-Z0''')º²±±a›6m’{ž óôô,Ö7upp`G-uxöì³°°`‹/VXÏÂÂBØ&¬yóæÌÅÅEfßaŒ±°† ²¨¨(™ÇïܹÃ7n,ó[¦¤¤°zõêÉ=÷Ó§O¬^½z,11QXÆìúõëçùûû³víÚI0Auuu¶dÉ †Rš÷–‡Ö­[³«W¯*¬3}útæêê*÷ø’%K˜••KNNfoß¾e¦¦¦lß¾}¥~¦f͚ɨØÛÛ³H•V$œœœ¤Ê&L˜ÀÚ¶m+¡øÊb~«V­*…vÓ¦MløðáE2ñV­Z•Ù·|óæ kРÄàB³5j”DYRR«[·®Âþœ’’Â6lÈBBBŠl eee©vÖÔÔTØöÜ·Þ¿MMM$''#&&ÕªUCrr2ÔÔÔäú´%KºwïŽiÓ¦ÉÔo®^½Šëׯ#66ééé¨Y³¦0€Q¤ÜðÄajj*3ˆíÉ“'022’r[* ###øùù¡C‡eò]*d–ƒâ0ÈÊ•+#!!¡ÄŠ‚——š4i‚¶mÛ–XÛ±c‡„C¼"XYYÁ××ÖÖÖ8yò$Œ´´4œ>}Ó¦MS¨ÐrÁtï޽ëW¯péÒ%Œ=‹-Btt4ªW¯.l¥ªª øûûÃÆÆ'OžÄÂ… ±fÍ<~üíÛ·‡¯¯o™ ¿¤¤$‚b š4i¢ðxïÞ½áææ†5jH1ŽÂˆŠŠB×®]Q§N :½zõBÕªU‘””„ððð¯¶hAQ‹ŽT­Z>|(“{%$$àóçψŠŠ*RÉNLL,“"""J%p^½zU¬óš5k†×¯_•oÃ)2¥ P(N4n~~>RRRpéÒ¥"ÓÏ´lÙRf¹““bccŽ§OŸÂ××®®®ˆ‹‹Ã–-[0zôh)~“ššŠºuë~·v-nû¨Éùo–”Ö_¿~´´4…õÚ¶m‹ŒŒ …÷ÿ÷ßKOšššptt,ѪwïÞŪU«àââ+++¹ñiiiÈÉÉÁ™3gŠ¼¦±±±\þ3}út¬[·NbóçŸbĈRJÉæÍ›áááQ¬÷PQQÁ‘#G¤|†çÌ™ƒ¥K—J(´÷ï߇²²2~úé'™×ºÿ>ú÷ï+++ôêÕ „ªª*ËÕ*‰ HNN.Ö‚J…RÃÂÂн{wäåå!55jjj8rä²³³‘››‹æÍ›C]]>>>2chŠÒªU«†?J”edd gÏžøðáÆŽ ;;;ÔªU ©©©xõêÒÓÓe^+##Ca°7—Õ>‰‰‰E¶²²²Ì˜J¡ Bnn®ÜÑ|BBâããŽÆK WWW gíâbß¾}°³³+vÔ«µµµ¹zyyáĉHKKÃÂ… 1mÚ4øúúbÕªU2•¿ääd$%%áÔ©Sèß¿?,--‘››‹°°0„„„ȵ²Z[[ãáÇ011Fš¾zõ ^^^h×®‚‚‚Ê,á³®®.ªU«†Í›7i±.Šz÷îC‡áýû÷°··ÇÍ›7å*i @¿~ý°aéc}úôÁ¾ ;‘e¡jݺu™ÜË 6Äœ9s¾YŸ400PÔ$Í›7‡——W‘õÂÃÃ¥EË/^¼€Ž=úÕÚFUU-Z´À‚ ¤2n”•*U‚¹¹9ÌÍÍ1bÄÀ›7oйsg¨©©aøðá –¶¶6Þ¿/30R¼]å)AßxñâE©h½N:øóÏ?¿èþ7nÄÔ©SQ¹råR¿{÷îÏt8pmÚ´A5àèèˆ;wîÈ€Ô¬Yõë×Ǻuë¾ÈJ9}útÃÅÅ 6DRRöïß/SQœ7oæÍ›÷EmÚµkWÌ™3>>>B˺»»»TöqŽ_¿~B%[–ábãÆåB±°°€ŠŠ Nœ8Qâs[´hØØXÀèѣѽ{w 2»víÂóçÏ‹ b}üøq‘²¦°,™1cªT©"w!§ÿýWæµÌÍÍ 7À111ÑÑÑ2ÛGCC£TíóE貺PQYÊiii)6 cÖ¬Y7nœBkHAAîÝ»'L‘Q\¾|jjj%N“ŸŸ77·-skmm ___<{ö Œ1˜››ÃÆƱ±±ˆŒŒDpp°\áرcG0Ç×Z!Q­i½Ô×ׇ¦¦&®_¿þE÷þüù³Ð‚›˜˜X¬ô‚/^”{_y²äüùópuu•;c"¯?9®®®r]N,X ³ÜÈÈyyyEº”9Šãl½~ýz¶páÂ"£åW) øÐÑÑ‘ì’’ÂRSS¥‚Â:uêÄ:vìȦL™"-›˜˜Èœ™¥¥¥D@•,ôíÛ—`*** 38ˆã§Ÿ~b'Ož,±3ûáÇY×®]K äìì,áè?gÎæììÌÚ·o/÷ÓÕÕ•ùíN:Å7nÌ"""$Ê“““™ªª*{ýúµLµ··g¾JPØÈ‘#™¡¡¡TÀZpp0³´´dsçÎ-M7(bĈlüøñrûdJJ Û¼y³Â€¦¢¢ÂH$ÊÔ)SØСCåb\¾|™™šš²ððp©þÑ®];– 3Š¿G2ƒ]¾4(ìÝ»w¬V­ZìóçÏ¥ |©U«–Ìg–IlllÌ:$·Ndd¤ÌÈpGGG™Y8ôë×M˜0AªüãÇLWWWnPÊž={˜©©©Ì`àÀÀ@¦­­-u,..Ž9880Å “¬&C† a“'O–ðrêÔ)fbbÂbcc¥Wz÷î-—çgee±;w²W¯^É<>þ|6{öìR@°éÓ§³U«VIÉ«âd9 ´°°IIII¬Q£Fìüùór¯ùâÅ ¶mÛ6…÷MOOg 6d¡¡¡¬~ýúRYrÊÙÙÙ¬AƒìÍ›7lÁ‚ì?þ[×ÇLJխ[Wf¶“   fbbòU‚Ââã㙚ššT€Wjj*8p  32˜j IDAT˯¯/ÓÑÑ‘)O8ܺu‹={V¡NñøñcÆc³gÏf[·n-2(ÌÙÙ™²½{÷J:³6mÚ°9sæHghh(“vÒÓÓÙèÑ£™AaŒ1¶téRfaa!‘¡%33“M:•õîÝ›5oÞ\f–ƒ{÷ ²èèh¹ïsýúuvñâŲ »zõ*ŸŸõë×£mÛ¶ptt@É÷ïß»wï"++ nnn=z´TR{{{hjjÂÙÙƒ ‚™™bbbŠ£G‚1™Îö3gÎÄÔ©S1mÚ4888ƒ…._¾ŒÛ·oãàÁƒÂçáP§N;v 3fÌ@³fÍ ­­ @€÷ïßcÒ¤Iؽ{w‘¾L\ð…@ À“'Oйsg…õ`À€%¶\oØ°¡TËãZ[[ãðáÃÖ™Áƒ£cÇŽ˜>}ºÂó.\ˆÙ³g ­Ô&&&ÐÔÔDHHÌÌÌdž§­­jÕª!88X¢Í‡ ‚3fkZV<¨¥(+míÚµáííQ£F¡cÇŽ4hš5k†ÄÄD„……áÂ… ðó󃫫«„uhãÆX½z5ºuë___èëëC__‚7oÞ Q£Fèܹ3V®\)­V¯^“'OÆ Aƒ0nÜ8ØÙÙáÕ«Wxôè<==1iÒ$¼yó{öìžž¦NŠŒŒ ìÛ·ÑÑÑ8rä233Ñ¥Káóœ8qyyyèÖ­›Â2kkkáÈÙÅÅzzzB?§7ÊL¢ŠK—.IÌ~¡… …%zöì)å{éááI“&¡M›6˜?>ÌÌÌP©R%„‡‡Ã××ÄÀúGs>yò@¡Ÿ©««+† †víÚaÁ‚hÕªòòòˆK—.ááÇ8pà€Ô²²#FŒ@TTÌÍͱ`ÁX[[CCCAAAX½z5ììì°téRaýçÏŸãüùópuuEß¾}%ò]»ºº¢OŸ>011QX¶yófŒ9²XV'Ožú:geeÁÝÝ]"÷b•*U0eÊ©vª\¹2Î;‡#FàìÙ³3f Œ‘––†ððpܸqׯ_—xOño|òäIDFFâ·ß~ƒ™™*W®Œ¨¨(:txðàÔyõêÕÃÉ“'1|øpôìÙ}úôAãÆ#GŽ ,, ÞÞÞ2­‹æææhÙ²%FŒ9sæ ==ÿüóŽ=Š#Fàýû÷Ø¿?(¨uìØ1a0Q^^ÜÜÜ ¦¦&<®¥¥…É“'Ëœ=Û¾}; Ìž=fffÈÌÌD`` ¼½½†£GJùþþûï˜3gÌÌÌ°hÑ"´nÝÕªUË/àïï={öÀÞÞ”ºgJJ 8€   R…Æ¡l’—c  œàà`ÄÅÅÉœŠNOOG×®]1`ÀXYY ÝljÔ¨³gÏbäÈ‘8uê† ###|þüááá¸|ù2þý÷_¬Y³Fá³V©RÓ§OG—.]п…î(euuuLš4 S§NEpp°B?ØŽ;¢eË–èׯFŒKKK<}ú>>>ðööÆÒ¥K1uêT¬_¿^Ê’ûòåKœ={V‚WæææbãÆB«¤’’ºuë&DY»vm 0LJ‹‹ TTT„´îèèˆÎ;ãÔ©SPRR’X$ªC‡pssƒ­­-FŽ GGG4jÔH¨ûp~±;wîTh¡åô©„„„b¹ôY[[cÅŠ7nœ0È“%.Œ%K–`æÌ™xþü9œœœÇÃÓÓvvvpttĹsç‘#GJøTÿñÇœꚚš¨^½:âãã1pà@œ={Vn}*VY‡„;vàСC CíÚµ…«‰;vL‚h•”” ªª*ôï*L“ÙÙÙ°µµ…­­­½nÙ²žžžðòò¶mÛиqc´nÝ÷ï߇´´´˜˜(œÞ*((@vv¶Ð§K¼Œ9‘‘‘Sû¿ýö"""dN÷7iÒ·oßF^^BCCQ¯^=… spï"Τ—,Y"1õ¦¤¤$sºLKK ÇÇõë×qöìYìرYYY055…©©)|||d.z"ŽÁƒãÁƒ Á¬Y³Š šªR¥ Ο?oooœ?nnnPQQA“&MУG…àË–-ƒ““öíÛ‡“'O W Ûºu«­síµ…xBð+V ''G¢M–,Y"U–œœŒƒ–8Ð$%%E˜ cþüùRS¡ŠÚ¨yóæðõõÅ„+©U­Z¦¦¦èСÜÝÝe*×sçÎE›6mpíÚ5œ;wnnnÈÍÍ…®®.ºté‚Ý»wËå“666†››ÜÝÝ…+…uêÔ žžžrã”””pæÌ,^¼'NDíÚµaaasçÎÁÜÜ:::øôé“” €xû¸¸¸Wƒä (‹¶¶¶p¥¿ .`ݺuPWWGÓ¦M1tèP :T‚/‰_ÓÃÃ>ÄñãÇqäÈ$%%ÁÄÄfff¸|ù²ÜL;vì@ïÞ½eß“'OÆ–-[P§NtïÞ½H—‰ììlŒ?^ªïçææ •‘² E üýý±{÷n=z¡¡¡¨Y³&LMMÑ¥K8p XÓ£FÂòåËKä÷%˜…––>|ø€ììl)×0Y¼rÑ¢E|X¯hÑŠåË—cÎœ9¨R¥ ,--±oß>têÔ ÇŽ“ËÓ‡Š.]ºÀÃÛ7oÆëׯ¡¯¯SSSÌŸ?¿þú«By[—ÎÕ¨$²dìرÐÕÕÅŽ;pøðaèèèÀÜÜGŽA»vípúôiáªl²ÜGGŒ!40cP¿>m sçÿ_y‡%@TðÛo¢þ¤£lÞ,¿þÒ¥À!€‹Ëƒÿñ(=Nœ Z>øÿR¾e__ÆGŽb«¨ñø"/ðô¤ïýÿå‘‹…ªU)S€o´š[…BA0l°f ðÿeƒ…`²`hÈؾ}¬ÂcÕ*ÆZµªxϽacÕ«3Ц­ÍØìÙŒ={ÆxðࡌݺÅØðጩ«‹úP£FŒy{+>7 €1 ªß­c±±|{þhÈÊbÌÅ…1%%¢ƒÍ›Ëþ±±ÄÓƺta,!o÷ÿ"Þ¾eÌÊŠ¾³ž^É¿óܹtî¡C|[rÈÏ']`ìäI©Ã²ÚC‡¨ÃùøTÜ?ž±Ê•»x±b>ZcÛ·3Ö¼¹H(Œ™š26}: çyçÁ+°ŒíßOJlƒ’ýÅÞž±3gˆOŸ2fnNçV­ÊØÒ¥¼bû# -±]»kÒDdD8uêëÝÏ×—1}}º—c—.ŸFy”odg3vâcuëŠdvXXɯ“—ǘ“]ã×_{÷îÇnW??Æ,,¨=~ÿ]fÙyh.^֮ƌªW—oÎÉ!Ÿ†ÈÌnh4n Ô¬Y:³r|<ðæ  hjŠ¦ ëÕþ¿¨‚Üó<<È=iý®È`  nÜnÞ||¨½9Ô«´j´l ÑÖ°!P« üݤ ;›ž7;[´qÿsrhjW  ½¬ßŒªª¢MMö@µj´U­*Ú+ÿná¹¹äN“–&¹ÏÍ¥¾Çµ׆ÊÊ€ŠŠ¨ ÿVSÔÕ©M54dÿVRú¾Óvqq@l,CÛ«WÀÓ§ä"•ž.ª[³&Ð¥ е+Эõ‰Ò´¯‡°u+ñ S' W/য়€--­oç†Ä}×Ü\Ú €J•èÛTªDü±"€ë÷¹¹ô›1z~ñMo/ë>ôò%ðø1pù2ñ×ôtâ!cÆ‹‘‹Ê×Dr20{6pô(}çúõÉEÆÙ™x:Š%§>N’’ˆoNšD:TåÊ¥—¡‹nnć~ú øùgÀÊ ¨[—6 êW™™¤ÿ|ø¼OúX\ù™ÆÅ©©T'3¨QC䆥«K×ýé'ꃥEj*ð÷ßÀ£G"]ðãG + ¨R…¶5Hgá6Ѧ­Mí¤®N2-.ŽÞãömàÒ% (ˆúç®]ÔOd@þ ÙÙÀÈ‘ôqªTlmI8T«&j0nŸ”$ÿ%-,€qãè)Åðù3ÄîÝä-ó‰•HQkÐ@ÔõëÓ3DEwﳜ6 pwÿï)8™™ÀýûäL[D ¹ÂPQj×&¢¯]›ˆ¡jUq‰+Š**Ô)ù'²²h“õ›ÛsÊê·FDµk‹¶:uHÁ×Ó£­aCêLå‰6£ÎÏ)m±±À»wÄŒâã%·¬¬oÿ|•*‰”ÜÊ•¥÷…«©MÉÛ8ZãïÜ\ #ƒ6NIÿô‰6yüEC03ÌÍiëÐh۶쾫@x{‡Sow]]Rl[´ þÃõ-n`U©)¡â[v61}Y7( ¤§¯©©‰h½^=@_ŸxµÅ˜™Q[}múŒž=#CDd$í?|hûÿ*C ¡¬L¼I¼-Å÷ZZÒ[•*ÔܦªJÏS¸-?&¹¼~-ò_UV¦¸‘Áƒ‹6Þ| ÄÄÂrè’BeÚÚd¤03£Íؘx7ˆ¯VúYaË̤kÞÒÒDt&þ;+K4ÀàL)êêtN†Ô­KÆ’Æi30 ¾ü- #QQôÍ^½¢öâøbb¢HÞää~À ô¸AŸ¦¦ˆvÄÛOK‹¾uáã_ܦ¢Bíʵ]Zñ¤°0Ps[Z=o:À„ S·nÙ´ÁÓ§¤Ø^¹òõÚ¹JÀÎøõWÒýTU‹7(Û·…>>Dƒ_jjÀرÀï¿“ƒ¢W ;p€F¯_ÙU«FQ{C†È>¾u+Š¿TX·l ¬ZôíûãŒ33I<{F>2R´%$ð£gyÄо±1í9áÿ5­oïß/^Hn/_’ËG´ÊVp4ÍøFF¤ÀÊõ±[·ÈRðà 3YƒÈòj3KK2LØÙÍš}Ù5?þù‡¶'Oh`šZqèJ_èØèÑèÙ³ì/µß¾ œ= \¸@ÜòŒÊ•É’la´oO3#}ùu##É0åçmeg—zêÓè×fs¾_zù’t2//š=úZhÖŒô¾äóCwwÀÕõë­››S`¦³s±úhñ–¾-( NææFšŠNÑÒ"ë·U¯N#õ€æS¦[¶ˆ¦–’’€Ñ£óç‰(,,hŸ˜Hõß½£=7ú‘'ôìì€ùó‰Añ!=Dt41Hnã\D>~¤‘nZÚ÷ÐÊÊ"KŸ¼;^©’´÷[YYdýhÔ˜šJ/9™hîãGÙQI 01!aÇmff¥›rOH é—'Oˆ9ûùI¥Þ“³‚Ô¬I–˜5È*%nEçÞKÜ­@üwa×q«yáí{¯x­ªJ¼¡n]Iw"ñŒÄ ÔÕËg¿  )ë4/^¢÷-­æœ¥Ž³¨©«“0MKÑ»¸‹‡† Aƒ(Z¸M›âÝïùsàôià̲¦!íV¯NtÍYÎ8Úä¬‚ß šš$œŒ¨_·kGÊWyP`‹Âë×4ýàÑÙóç4ƒQžadDgg’åÅAApçÍß¼Iòª0(Žsagq_gñíkO/$&wIH þÅMër{IßQέC|z”›VŸ&å~—çegÓ3„„·q®J¦¦À‚¤ÜžfÌÏ'áææF¾ü\°° znÝš¬(ººDãÅ@ ›Ïˆ»_p¿¹)qq?â¼<Oᦗ¹©ñ:uDç^ô=ý¿ËŒÑLNx8)0>ˆÜr>}јx|ç/î§,>Ý^x_Ø­ƒë«œ?½º:)"II´%'?}J÷€‘¡ eK`æLùÓן>‘qëÐ!âÁémÚÐÖ²%}Çš5Eç/Ê ’²²$é¥ð–’"¹çä™ø–—'j'nÓÒ¹YÔ­K|ÚؘE üúÀ¿ÿ’»¨ª* 8êÔ!¬!Ch¦gçN iÓrõÈ%Wh¿ÑÑ€ƒ¹<~LÌò￉ñàQ^—GJ­¯/)§·nó¬T‰|Œ&Nìí©î³gÀþýÀ±c"Úµi¶ [7² ýk<*ââÈúâéItn`@Óˆ¿üBǽ¼È ,:šñcþýIÑàÁC‘eù¯¿(x'*Šîk×ŠÜ SSÉr×.â©FFÄOý•êò(?ÈÌÆ'7iùÿññ…r8Püö -@Ìó—_hÔôò%™™yð(ÏÈΦWWšZˆki‘e‚ƒƒ%ÃvtäXwï’Âúæ Í %%Q俦&YgÇŽýö³<*6 (XhÙ2òƒ4ˆ¶Ù³ÉÒüÓOÀŠÄ3ÿ+Vôÿ"ÒÓÉG–Ù»wËí£~…ù1]ºÄ Š€òž=’åêêÀöíäÀ΃GEDJ ùŒsf*W¦iGKK¾mx”II¤´Iü/_þïºý×pç¹ÓõíKÁÓ¼B˃<Ê5>~¤ib€‚E¾4¹bíß/ò¹Ÿ ?NÊÆŽÀÍ›€‰ 0z4ТÕýçàäIš2ûùg`üxÙÏvÿ>]34”,`½zƒóSÞÁÑhYàý{¢uqwa/Qý6Ï™Ÿ¯ø^ܳ)+‹þ„…ñ´ð£"/8hÞ03bbèÕª@ä“WiiÀÅ‹$êÖÚ¶%«¢"¢Wwwò€à`àógr'kÚTš–óòȯ6$„dAëÖüwù/C ÑÊ·àãt¼¬x}y³g´¯VíËÞ½$²°¬äÑ÷üÖiiä¦Q8xŽq0€±I“KJb,:š±ùóóõeز…1ssÆ<`ìógÆV¬ zC‡JÖ[´ˆÊwì`léRÆ:vdÌÞž1eeÆ´´ûðA²~BcNNtß—/»z•1Æ*UbìÔ)ªsñ"cíÛÓuƳµe¬woÆêק2ÆÒÒÛ»—1SSº'Wï^&Æ~ù…±{÷ b¬Gª;v,ãQ‘šJ´Õº5cÖÖŒ2Ö¿?cÏž‰êìÝËØàÁŒuïÎد¿ŠÊÃÃ>œÊ»wgìß©üúuÆêÔщ£#çèÅÏOTÎcGÒý«WglØ0Æ23¥Ÿ³ €1OOÆFŒ š21¡çô󓬗›ËØéÓtmGGÆ22ˆö´µûýwªËØòåŒ5hÀØÙ³Tǘè™ÍÌè™Û¿ŸîɽçĉŒ½z%ºç£Gô\ܱ¼<ž®*>~$ÞU¯}ÿãÇ;rDDcµj_Ç;ŒÕ®ÍØÌ™Œ]»ÆظqTwð`¢YÆ»{—è‚ëC†Ðÿýûéøû÷TnbBòÂÎŽx:w_ooþûüpú4Éd++¢™¾}[¿ž±&Mèøë׌͙#â5§O‹Îusc¬gO*Ÿ0AúÚ™™ŒÍKò[[›±Æ[²„±œQW¯[°€èÐLJ俙Éõ£GëÕKÄã†'„Û7ŒMž,:öþ}ùjÛ èÙêÖ¥>Ó®è]rs©m.¤ã÷ï3vù2c-[2Ö¢c‘‘t·o3†±¶mI™˜ÿ—}Ï“'é[ŽIíݵ+c^^¤k]»ÆXT”ˆG B:'/ìì«\™ô©Û·©<;›±330 çœ;Wö}ÓÓ›5‹¾uD?+VHÊ/ˆ–´µ !™7r$ýoÙ’±sçDuýýIîsüÆƆÚmõj!aTQ\ ›šJ*´7o2¦¤ÄX@€¨,;›; RÄZ33j,sçR¹‹‹äKC„'Ž›7©®¶6c‰‰¢ûU®Lå#GŠ㌠Æ:w½à΢ëܸAåúú’×?{–:‹x'JK£Î 0váÏÔÊìí‰RSEÄ 0Ö°!};¡¡T^­š´¢ibBÇÎœ)É>ˆE¯_Óîâ íš5DwnnŒYZRùÒ¥Ò÷8î“œLe))Ô¡54Hñàðûï4@ëÒ…±yóˆQŒ5mJŠúÔ©4°D mn.=ã„ T¾y3ýÿô‰Žÿù§¨ÃËbæ®®Äe)ã<Ê?RRÈð`aAßxêTB·o3¶nõŽçee‰è²~}R‚9å•1Æ5’æߌ‰Œ/^H–s ­ŽÝóéS*?žäƒÿ}*2T·kGJ§€þú«h $ŽÁƒ©ÜÕU²üÔ)*oÑBÚxefÆØ$MŒrÐWIDAT{³³‰§dœbŒØ ˆž8cTß¾’¸ë×EÇoÜ~«Wi õî]ùFF2Ö­=ÿ‰ô?2’sñwß³‡Þ“OG’\iܘ±6mD}ÙÓ“Žÿô“ôýV®¤cœá'-äÇ#:vdìàAÆöí£A §wýõü¶l!À˜®.ñ€þýI ?Ÿ±ªUéØöíÒïijJ2/7—¾õСT·ªsÿ>Ñ›ø€¸[7Æ/f¬O*«^]D‹$ë8þt÷.ýOJú¿BË ìáÃé†þú‹±À@ÑccºHa>LÄÎiøâ í¶m’uÏ)£âʇ²2¸)RJ +—܇‹“¼öš5²­«)**Œåç‹Ê›5# …ø=##EnÜ8ž¹•'DEÑw±·—,çFkAA’J¥’’´B˘ˆyr -]]*OO—,çú‡¶6”9ÄĈ:¸8¶m£réçWS#åTÜbzé’HùæF¢aa¤°pppTh9ÌžMåH+Õ\‡—50ëÝ[ú£GÓ75Šø‡—/‰ß‰óàÜ\ƪTa¬S'Ék .ª%Qhuu¥ûŠŽãJÛ¶1¦®NV2q<.[¡]µJ¶BËñÇ í”)d½GNÝ ~È38:’ìÎÊ"ˆ£uŽþ׬‘~âå}ûÒóß¹#}¬m[:æà@ÖLîÝóóÉZ …T|«¢Bº”¸õóõk*72’m0=Z²üÃ*WW'WÜ÷°³“”OœÑ°sgÉúcÇÒ;Š##ƒ1UUª󦨼qc/ã጑B 0vèäu¸Êa9HXZ’ÔÑ£@` °q#EU÷ï/òMøðVý>\ÚŸaÄÚd¡°F:´•ùù‘ïÄ­[ÀÇ’õgΔvšÖÔ¤}a? ##‘Ÿ†8”•† W¯(1}íÚäA9F·l‘¬ß®mÆƼ¿TyBÆ”ö×_%ËÛ´!ÀssmÈóÃ)­ÿ—¥%г§è¿žÈ$$HúmÜH4gi)y¾¾>=ÿáÃyð •kiÑÞÌ èÓ‡~›˜Hž[ÒÈr%%J9Ö»7-tÒ»·èØ»wÔÏNžäiª¢ƒ ÐêÖMä[ ÍšýúQÜ“'T¦¦F>{âÁ&OŸÑÑô»¤‹vhiILÖ©Cý0>žx+Š…ÏŸ)Eà/¿¿‡¡aÉø©¬òøxZ˜côhé´T5kRúÁ‡)ŽEÜ·táBºžŠ Щ“èœ%KˆŸîÞ ÌŸ/ŠãÉϧëWä…8¹°p!éQªª¢woÓ†äàС’õ›6%=-.N”9áñcò{.,Z¶¤ý¥K¤qüƒ“5UªPl”8¬¬(­W/ÉþÍÉݘɸ”ƒ)¯náo]£É͇Éï^ü[Ï›'xÚªpá‚äµå@U¨ð]¹Bé"BCIh[YGŽMšPÍðpQÀ—€c€¢²ˆÚO™R¼€yHYY±€Wv_½¢½­- ~å**È9_¹BA„QYnî·¦:u(€1-:dp0u<}}ÙÑà:~üXTV¹²ä@M¸:%A¯^Ä´nÞ¤6êÐÊ÷í£ii®É£â CRh9^Ç)%ùù”êíøqR| )0¶,À)Ë))|ûWD©©²S–E Ø‹¤\éèHGöïÜ)ø—76i œ8A²`Ü8*?žŒœ‘«"BÑ»ëèP ;@‹YyygÎ"[XOÓÓ£}á\åœ.”Ÿ/©;)’ HžË¡vmÚ§¦ŠÊÂÃIN7h ý­÷î•$ÉûÆœâ\ ž"z‹víÈ:;o>$þömÑèž#Ȳ½ý5®-Á·¿'²ÁÎ$¬££ihoÿýž¥R%IešË‰—“#»>Ǭ?|l)Bi"|•”€Å‹é÷êÕ"ºß·˜4‰§£ÿ:8¥D[[Töö-`aAÂïÈ`Ãɘ_ŠÂ† œ<”uÿ¥xóF¤dõí+{³°ÓPŠ‘Ytñb¢»õëEr}÷nZ¤"£(žŸ—GÆ8;;2žœ9#{ Ò¡e3ñõ•Tj9ÝnÀ€/—5Š¾µ¾¾üoÍYv}ë<]áý{2ÿjhÐti@YhSSE‚°Y3ÚQz–ÂHO'æXpV`y‰„ÃÂÈä\–àîù×_²MÙyy€›ÏàÊ ˆImØ@#Ò©SË_’wÎ¥æÓ'sG­Z´oÓæÛ<Ï ADë—.Qß½t‰¬¼;ÍÜ!œûJ\`mMS»'Nð‹ßð7súîÝ×¹>§(ûû˯SÒ™¶–-i6êõk¢ëׯIgàÜ·þ‹HO§w¾}›f*–Ÿ6UU•\/êÔ¡6¹}›fí\]é…].Ëó·.–Bûò%ùÏŠÈ¥K¤àrÓ¹õë“ÌžMK¶‰céRÉ‘UIFèÖÖ4ñè‘HWbÆŽ•tE(‹Ñݺ$Ôsrèúâ¦rX·ŽŸ’-o8v ص‹rsq¦ MMê0ùù²¯W˜†Ë¦¦Ä@ dOãr¾ãâ~`_**À‚ô{Íj?Þ:ûßCaþ`€®]iá¹ÇXYɾ†¬ ¿ÿðøï¡qcÚß»';'·,prR|…EqˆÏVq|ÛÓSä»-ŽçÏIÑ*)\\h¿v-ÍàSö9TËV­"¥tñb Ê2þˆÃÀ€rÿOšܽK¾ó[·’ž§ÈÕíKд)í÷î%£ia<{Væ«¡‰l¼›6Ijik“ïçwˆ4ù¿ÿh•nú7,LäÜ ˆe’“%ïÈùv$&ŠÊLLD‹,[F›7Ó²‹ä!î€Ì+Œˆ–hLO—~SY÷åóï¿Éb¶|9}d''²ÜŽÃ3¸ò„  Úú$Yþù³¤àåöººÄL¹AGOŸJÒ Îç•»>ç³Ã zY žS¢¹:5k#GŠ˜¶¬wPV¦é–Â×PäŸÎÝ»°ÒQø™³²¤¯3r$ù19Cï.~oÿ p ÚÅ•Ó£G)‚ãËœÛÙ³¢Á\p0ùrý!2Rä6Ã-ÊÀÍÈqõ¸dæ…û8}ÊâÁ<Ê?:v$žòü9àá!y,0Pö9\ðؽ{’åwïÒ^<^¦E ÚrrÈZ%)¿ÇŽ„‰ó½¢bw¬¬(&<œž{„ŠÑÞ\?,¬'%dÉÂÜ\Q¿ËÏÉAƨMíì(oÕ*`î\ sç’Éñg’7Ø?ÇÜœfö³²(È06Vt,#ƒüþYZG+|my÷äRœßpJÊÿV¸sG”†eùrÊ=»`å'{ýZ2U¾}¢ôÜÖ©“(™oV¥âR µmK¹ss{òD”ƒL]±cÇ(17—í·ß$¯Ëå*ãRÀ|üÈØ®]¢c3fPÄü|ÆnÝ¢ük\~Ä (WÛÛ·Œ¹»‹rºM™BéG8xxH¿‘¥MâQ¾pë}Ÿ5(åÔÍ›Œõë'Êã:q"¥iár¿rù{ô t''O26h(ÏkïÞD'\âîÝ©|Ö,Ê…Ç¥,ñö¦òV­¤Scq‰±ƒƒEåoßR.N%%JEÇáÓ'Æôô¤P_¿Nר__2?¨88ÚÞµK²|ÿ~Q?»~RÕˆ§¦ã°i“윹<*6&OñS//â¿ÙÙ´pBóæ”`žCV–(g¸Ž¥¿1‚±EiéÆŒ¥üٰʵ´(!»Ñ–»;•Wª$™Ò+6–R:” W-ó(ßpqÉÂß~#^»d åÈ–•¶+<œÒBUªÄØîÝ”ˆÎâ5€(%'·¨ —Ï 4rŽŽ”ÆKCƒ±iÓd§ŽÛ½»èçæøhŸ>§­[¶¤g^¹Rú˜•Ï©Ïaóf:Ö¤ É°¿þ¢ü±úúT¾v-É1Æ(­'7ûö¥>>s&}Ÿ ¤ÏâÒ­”bKÜ:‹K–''‹ÎOÙwù²è[W«Fùeœˆ_–ƒ5kR=ná†Â²kØ0Éò‰E ¿\¹ÂØÆÿÏCûî ü›7IÁsq¡$½òr ¾zE‚uŠʇ&θÒÓIA.¼eeQâîÂå…sÉÞ¿O/°zµt²äèhéó?&,랟>1!]Î%Ÿ½{é?.™ ŸGù@@9d54D ¤ß¼!E eQ<íÛ·¢@)5•:´š-~pë–¨þ;Ä`+Uåõtw§w h`ö÷ßt¾ø N·ýþ;õ›Gè·ø1ñDxTäç‹€xÏ¢ET.K¡eŒ¾7Ç£*W¦ßïÞÑÿƉïq‹¾pyK¹|ò)=³g“á‹12Œ!:^»6é%…¬Â00\È©¼âÊ2®pïW£/_¦Åœÿ×Þù³4 EQü&Š¤JKÝ\]DTtr,8¸¸ N®âR:‰ø%ÄOàà(*.‚³þ ÖA(µ‚­¥…Vu8\_’F±ú¢6½?(…¶–˜¤y/ïž{Ž;ñoeÅý{¾¿ÇM€ibßÍÏc,X[Ãߌc âãé·Xè|ÌΪíJ$ÔëssL¹»Ãöq€B?nrŠE$ÄqH—ÓWwßÄiHAãçtIµüþØÆÝjç/Y¶Ï£tï™&©jµºQ¯K;ªÐb”J(Y9sês9”Õ½’¯¯ðáŒF•EÈÙ4áñ¸ èñÑÝþ*”êz{¡A÷³òÒA>¯,UüØÝ…–‰ËÆB8XZ‚ìkkËíI)?¥P€”ptvl¶ ]êÀ@£Ü?uùžeáZz|L4=íß©nÛÊ3udD5Ì~—›È3}úÿÛ[h`:ÚlÖ-Ñ|~†%ëê*dx¥7³YÈ/ ³ Û†Œ¥PÀ±Ö5¾¾¼à‰Åˆˆ}h¡•ðû1xMÀÓ$šœt¿ö™×qw·ÞIg_´KAóÙd–ú÷TJÎA¾F4 ]j3Ÿg—¾–~¤Ó$BÃ*kju°¾Ž^œv™Ìù[îyM’ILø¸©?ilªÎç›Vi†Ž4L릳ó}2Käl !<”ËJ„¿½»ñ™Ù/aƒ³‚pì'\Ìý/Eݧ'rqË®Viû-./‰66ÜÍw^®¯áQû—~îºæ·rÄ!dÔj0.¯Vñ\,Ââ¥V.ÚÛV Žçç²?„`a7™reì|O‹©)LdãqlÛæfc"U»34ßñ¸E-,@z‰ üz 7ŠøRË ­ „ ËByÉ0p1ÛÛ N%ü ''(%Ö­RFŽ'‚ “£#¤ˆ¡/ayY_\òw™˜Àóà #å8yéé-i*…Š]2 ÛÆD©]]D‡‡ÈoT[f´$½LIEND®B`‚cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/ie6.css000066400000000000000000000013261240331347200251470ustar00rootroot00000000000000* html img, * html .png{position:relative;behavior:expression((this.runtimeStyle.behavior="none")&&(this.pngSet?this.pngSet=true:(this.nodeName == "IMG" && this.src.toLowerCase().indexOf('.png')>-1?(this.runtimeStyle.backgroundImage = "none", this.runtimeStyle.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + this.src + "',sizingMethod='image')", this.src = "_static/transparent.gif"):(this.origBg = this.origBg? this.origBg :this.currentStyle.backgroundImage.toString().replace('url("','').replace('")',''), this.runtimeStyle.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + this.origBg + "',sizingMethod='crop')", this.runtimeStyle.backgroundImage = "none")),this.pngSet=true) );} cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/_static/jquery.js000066400000000000000000007557201240331347200256450ustar00rootroot00000000000000/*! * jQuery JavaScript Library v1.7.2 * http://jquery.com/ * * Copyright 2011, John Resig * Dual licensed under the MIT or GPL Version 2 licenses. * http://jquery.org/license * * Includes Sizzle.js * http://sizzlejs.com/ * Copyright 2011, The Dojo Foundation * Released under the MIT, BSD, and GPL Licenses. * * Date: Thu Nov 15 18:28:24 BRST 2012 */ (function( window, undefined ) { // Use the correct document accordingly with window argument (sandbox) var document = window.document, navigator = window.navigator, location = window.location; var jQuery = (function() { // Define a local copy of jQuery var jQuery = function( selector, context ) { // The jQuery object is actually just the init constructor 'enhanced' return new jQuery.fn.init( selector, context, rootjQuery ); }, // Map over jQuery in case of overwrite _jQuery = window.jQuery, // Map over the $ in case of overwrite _$ = window.$, // A central reference to the root jQuery(document) rootjQuery, // A simple way to check for HTML strings or ID strings // Prioritize #id over to avoid XSS via location.hash (#9521) quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, // Check if a string has a non-whitespace character in it rnotwhite = /\S/, // Used for trimming whitespace trimLeft = /^\s+/, trimRight = /\s+$/, // Match a standalone tag rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/, // JSON RegExp rvalidchars = /^[\],:{}\s]*$/, rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, // Useragent RegExp rwebkit = /(webkit)[ \/]([\w.]+)/, ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/, rmsie = /(msie) ([\w.]+)/, rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/, // Matches dashed string for camelizing rdashAlpha = /-([a-z]|[0-9])/ig, rmsPrefix = /^-ms-/, // Used by jQuery.camelCase as callback to replace() fcamelCase = function( all, letter ) { return ( letter + "" ).toUpperCase(); }, // Keep a UserAgent string for use with jQuery.browser userAgent = navigator.userAgent, // For matching the engine and version of the browser browserMatch, // The deferred used on DOM ready readyList, // The ready event handler DOMContentLoaded, // Save a reference to some core methods toString = Object.prototype.toString, hasOwn = Object.prototype.hasOwnProperty, push = Array.prototype.push, slice = Array.prototype.slice, trim = String.prototype.trim, indexOf = Array.prototype.indexOf, // [[Class]] -> type pairs class2type = {}; jQuery.fn = jQuery.prototype = { constructor: jQuery, init: function( selector, context, rootjQuery ) { var match, elem, ret, doc; // Handle $(""), $(null), or $(undefined) if ( !selector ) { return this; } // Handle $(DOMElement) if ( selector.nodeType ) { this.context = this[0] = selector; this.length = 1; return this; } // The body element only exists once, optimize finding it if ( selector === "body" && !context && document.body ) { this.context = document; this[0] = document.body; this.selector = selector; this.length = 1; return this; } // Handle HTML strings if ( typeof selector === "string" ) { // Are we dealing with HTML string or an ID? if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { // Assume that strings that start and end with <> are HTML and skip the regex check match = [ null, selector, null ]; } else { match = quickExpr.exec( selector ); } // Verify a match, and that no context was specified for #id if ( match && (match[1] || !context) ) { // HANDLE: $(html) -> $(array) if ( match[1] ) { context = context instanceof jQuery ? context[0] : context; doc = ( context ? context.ownerDocument || context : document ); // If a single string is passed in and it's a single tag // just do a createElement and skip the rest ret = rsingleTag.exec( selector ); if ( ret ) { if ( jQuery.isPlainObject( context ) ) { selector = [ document.createElement( ret[1] ) ]; jQuery.fn.attr.call( selector, context, true ); } else { selector = [ doc.createElement( ret[1] ) ]; } } else { ret = jQuery.buildFragment( [ match[1] ], [ doc ] ); selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes; } return jQuery.merge( this, selector ); // HANDLE: $("#id") } else { elem = document.getElementById( match[2] ); // Check parentNode to catch when Blackberry 4.6 returns // nodes that are no longer in the document #6963 if ( elem && elem.parentNode ) { // Handle the case where IE and Opera return items // by name instead of ID if ( elem.id !== match[2] ) { return rootjQuery.find( selector ); } // Otherwise, we inject the element directly into the jQuery object this.length = 1; this[0] = elem; } this.context = document; this.selector = selector; return this; } // HANDLE: $(expr, $(...)) } else if ( !context || context.jquery ) { return ( context || rootjQuery ).find( selector ); // HANDLE: $(expr, context) // (which is just equivalent to: $(context).find(expr) } else { return this.constructor( context ).find( selector ); } // HANDLE: $(function) // Shortcut for document ready } else if ( jQuery.isFunction( selector ) ) { return rootjQuery.ready( selector ); } if ( selector.selector !== undefined ) { this.selector = selector.selector; this.context = selector.context; } return jQuery.makeArray( selector, this ); }, // Start with an empty selector selector: "", // The current version of jQuery being used jquery: "1.7.2", // The default length of a jQuery object is 0 length: 0, // The number of elements contained in the matched element set size: function() { return this.length; }, toArray: function() { return slice.call( this, 0 ); }, // Get the Nth element in the matched element set OR // Get the whole matched element set as a clean array get: function( num ) { return num == null ? // Return a 'clean' array this.toArray() : // Return just the object ( num < 0 ? this[ this.length + num ] : this[ num ] ); }, // Take an array of elements and push it onto the stack // (returning the new matched element set) pushStack: function( elems, name, selector ) { // Build a new jQuery matched element set var ret = this.constructor(); if ( jQuery.isArray( elems ) ) { push.apply( ret, elems ); } else { jQuery.merge( ret, elems ); } // Add the old object onto the stack (as a reference) ret.prevObject = this; ret.context = this.context; if ( name === "find" ) { ret.selector = this.selector + ( this.selector ? " " : "" ) + selector; } else if ( name ) { ret.selector = this.selector + "." + name + "(" + selector + ")"; } // Return the newly-formed element set return ret; }, // Execute a callback for every element in the matched set. // (You can seed the arguments with an array of args, but this is // only used internally.) each: function( callback, args ) { return jQuery.each( this, callback, args ); }, ready: function( fn ) { // Attach the listeners jQuery.bindReady(); // Add the callback readyList.add( fn ); return this; }, eq: function( i ) { i = +i; return i === -1 ? this.slice( i ) : this.slice( i, i + 1 ); }, first: function() { return this.eq( 0 ); }, last: function() { return this.eq( -1 ); }, slice: function() { return this.pushStack( slice.apply( this, arguments ), "slice", slice.call(arguments).join(",") ); }, map: function( callback ) { return this.pushStack( jQuery.map(this, function( elem, i ) { return callback.call( elem, i, elem ); })); }, end: function() { return this.prevObject || this.constructor(null); }, // For internal use only. // Behaves like an Array's method, not like a jQuery method. push: push, sort: [].sort, splice: [].splice }; // Give the init function the jQuery prototype for later instantiation jQuery.fn.init.prototype = jQuery.fn; jQuery.extend = jQuery.fn.extend = function() { var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false; // Handle a deep copy situation if ( typeof target === "boolean" ) { deep = target; target = arguments[1] || {}; // skip the boolean and the target i = 2; } // Handle case when target is a string or something (possible in deep copy) if ( typeof target !== "object" && !jQuery.isFunction(target) ) { target = {}; } // extend jQuery itself if only one argument is passed if ( length === i ) { target = this; --i; } for ( ; i < length; i++ ) { // Only deal with non-null/undefined values if ( (options = arguments[ i ]) != null ) { // Extend the base object for ( name in options ) { src = target[ name ]; copy = options[ name ]; // Prevent never-ending loop if ( target === copy ) { continue; } // Recurse if we're merging plain objects or arrays if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { if ( copyIsArray ) { copyIsArray = false; clone = src && jQuery.isArray(src) ? src : []; } else { clone = src && jQuery.isPlainObject(src) ? src : {}; } // Never move original objects, clone them target[ name ] = jQuery.extend( deep, clone, copy ); // Don't bring in undefined values } else if ( copy !== undefined ) { target[ name ] = copy; } } } } // Return the modified object return target; }; jQuery.extend({ noConflict: function( deep ) { if ( window.$ === jQuery ) { window.$ = _$; } if ( deep && window.jQuery === jQuery ) { window.jQuery = _jQuery; } return jQuery; }, // Is the DOM ready to be used? Set to true once it occurs. isReady: false, // A counter to track how many items to wait for before // the ready event fires. See #6781 readyWait: 1, // Hold (or release) the ready event holdReady: function( hold ) { if ( hold ) { jQuery.readyWait++; } else { jQuery.ready( true ); } }, // Handle when the DOM is ready ready: function( wait ) { // Either a released hold or an DOMready/load event and not yet ready if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) { // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). if ( !document.body ) { return setTimeout( jQuery.ready, 1 ); } // Remember that the DOM is ready jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be if ( wait !== true && --jQuery.readyWait > 0 ) { return; } // If there are functions bound, to execute readyList.fireWith( document, [ jQuery ] ); // Trigger any bound ready events if ( jQuery.fn.trigger ) { jQuery( document ).trigger( "ready" ).off( "ready" ); } } }, bindReady: function() { if ( readyList ) { return; } readyList = jQuery.Callbacks( "once memory" ); // Catch cases where $(document).ready() is called after the // browser event has already occurred. if ( document.readyState === "complete" ) { // Handle it asynchronously to allow scripts the opportunity to delay ready return setTimeout( jQuery.ready, 1 ); } // Mozilla, Opera and webkit nightlies currently support this event if ( document.addEventListener ) { // Use the handy event callback document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); // A fallback to window.onload, that will always work window.addEventListener( "load", jQuery.ready, false ); // If IE event model is used } else if ( document.attachEvent ) { // ensure firing before onload, // maybe late but safe also for iframes document.attachEvent( "onreadystatechange", DOMContentLoaded ); // A fallback to window.onload, that will always work window.attachEvent( "onload", jQuery.ready ); // If IE and not a frame // continually check to see if the document is ready var toplevel = false; try { toplevel = window.frameElement == null; } catch(e) {} if ( document.documentElement.doScroll && toplevel ) { doScrollCheck(); } } }, // See test/unit/core.js for details concerning isFunction. // Since version 1.3, DOM methods and functions like alert // aren't supported. They return false on IE (#2968). isFunction: function( obj ) { return jQuery.type(obj) === "function"; }, isArray: Array.isArray || function( obj ) { return jQuery.type(obj) === "array"; }, isWindow: function( obj ) { return obj != null && obj == obj.window; }, isNumeric: function( obj ) { return !isNaN( parseFloat(obj) ) && isFinite( obj ); }, type: function( obj ) { return obj == null ? String( obj ) : class2type[ toString.call(obj) ] || "object"; }, isPlainObject: function( obj ) { // Must be an Object. // Because of IE, we also have to check the presence of the constructor property. // Make sure that DOM nodes and window objects don't pass through, as well if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { return false; } try { // Not own constructor property must be Object if ( obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { return false; } } catch ( e ) { // IE8,9 Will throw exceptions on certain host objects #9897 return false; } // Own properties are enumerated firstly, so to speed up, // if last one is own, then all properties are own. var key; for ( key in obj ) {} return key === undefined || hasOwn.call( obj, key ); }, isEmptyObject: function( obj ) { for ( var name in obj ) { return false; } return true; }, error: function( msg ) { throw new Error( msg ); }, parseJSON: function( data ) { if ( typeof data !== "string" || !data ) { return null; } // Make sure leading/trailing whitespace is removed (IE can't handle it) data = jQuery.trim( data ); // Attempt to parse using the native JSON parser first if ( window.JSON && window.JSON.parse ) { return window.JSON.parse( data ); } // Make sure the incoming data is actual JSON // Logic borrowed from http://json.org/json2.js if ( rvalidchars.test( data.replace( rvalidescape, "@" ) .replace( rvalidtokens, "]" ) .replace( rvalidbraces, "")) ) { return ( new Function( "return " + data ) )(); } jQuery.error( "Invalid JSON: " + data ); }, // Cross-browser xml parsing parseXML: function( data ) { if ( typeof data !== "string" || !data ) { return null; } var xml, tmp; try { if ( window.DOMParser ) { // Standard tmp = new DOMParser(); xml = tmp.parseFromString( data , "text/xml" ); } else { // IE xml = new ActiveXObject( "Microsoft.XMLDOM" ); xml.async = "false"; xml.loadXML( data ); } } catch( e ) { xml = undefined; } if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { jQuery.error( "Invalid XML: " + data ); } return xml; }, noop: function() {}, // Evaluates a script in a global context // Workarounds based on findings by Jim Driscoll // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context globalEval: function( data ) { if ( data && rnotwhite.test( data ) ) { // We use execScript on Internet Explorer // We use an anonymous function so that context is window // rather than jQuery in Firefox ( window.execScript || function( data ) { window[ "eval" ].call( window, data ); } )( data ); } }, // Convert dashed to camelCase; used by the css and data modules // Microsoft forgot to hump their vendor prefix (#9572) camelCase: function( string ) { return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); }, nodeName: function( elem, name ) { return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase(); }, // args is for internal usage only each: function( object, callback, args ) { var name, i = 0, length = object.length, isObj = length === undefined || jQuery.isFunction( object ); if ( args ) { if ( isObj ) { for ( name in object ) { if ( callback.apply( object[ name ], args ) === false ) { break; } } } else { for ( ; i < length; ) { if ( callback.apply( object[ i++ ], args ) === false ) { break; } } } // A special, fast, case for the most common use of each } else { if ( isObj ) { for ( name in object ) { if ( callback.call( object[ name ], name, object[ name ] ) === false ) { break; } } } else { for ( ; i < length; ) { if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) { break; } } } } return object; }, // Use native String.trim function wherever possible trim: trim ? function( text ) { return text == null ? "" : trim.call( text ); } : // Otherwise use our own trimming functionality function( text ) { return text == null ? "" : text.toString().replace( trimLeft, "" ).replace( trimRight, "" ); }, // results is for internal usage only makeArray: function( array, results ) { var ret = results || []; if ( array != null ) { // The window, strings (and functions) also have 'length' // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 var type = jQuery.type( array ); if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) { push.call( ret, array ); } else { jQuery.merge( ret, array ); } } return ret; }, inArray: function( elem, array, i ) { var len; if ( array ) { if ( indexOf ) { return indexOf.call( array, elem, i ); } len = array.length; i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; for ( ; i < len; i++ ) { // Skip accessing in sparse arrays if ( i in array && array[ i ] === elem ) { return i; } } } return -1; }, merge: function( first, second ) { var i = first.length, j = 0; if ( typeof second.length === "number" ) { for ( var l = second.length; j < l; j++ ) { first[ i++ ] = second[ j ]; } } else { while ( second[j] !== undefined ) { first[ i++ ] = second[ j++ ]; } } first.length = i; return first; }, grep: function( elems, callback, inv ) { var ret = [], retVal; inv = !!inv; // Go through the array, only saving the items // that pass the validator function for ( var i = 0, length = elems.length; i < length; i++ ) { retVal = !!callback( elems[ i ], i ); if ( inv !== retVal ) { ret.push( elems[ i ] ); } } return ret; }, // arg is for internal usage only map: function( elems, callback, arg ) { var value, key, ret = [], i = 0, length = elems.length, // jquery objects are treated as arrays isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ; // Go through the array, translating each of the items to their if ( isArray ) { for ( ; i < length; i++ ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret[ ret.length ] = value; } } // Go through every key on the object, } else { for ( key in elems ) { value = callback( elems[ key ], key, arg ); if ( value != null ) { ret[ ret.length ] = value; } } } // Flatten any nested arrays return ret.concat.apply( [], ret ); }, // A global GUID counter for objects guid: 1, // Bind a function to a context, optionally partially applying any // arguments. proxy: function( fn, context ) { if ( typeof context === "string" ) { var tmp = fn[ context ]; context = fn; fn = tmp; } // Quick check to determine if target is callable, in the spec // this throws a TypeError, but we will just return undefined. if ( !jQuery.isFunction( fn ) ) { return undefined; } // Simulated bind var args = slice.call( arguments, 2 ), proxy = function() { return fn.apply( context, args.concat( slice.call( arguments ) ) ); }; // Set the guid of unique handler to the same of original handler, so it can be removed proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++; return proxy; }, // Mutifunctional method to get and set values to a collection // The value/s can optionally be executed if it's a function access: function( elems, fn, key, value, chainable, emptyGet, pass ) { var exec, bulk = key == null, i = 0, length = elems.length; // Sets many values if ( key && typeof key === "object" ) { for ( i in key ) { jQuery.access( elems, fn, i, key[i], 1, emptyGet, value ); } chainable = 1; // Sets one value } else if ( value !== undefined ) { // Optionally, function values get executed if exec is true exec = pass === undefined && jQuery.isFunction( value ); if ( bulk ) { // Bulk operations only iterate when executing function values if ( exec ) { exec = fn; fn = function( elem, key, value ) { return exec.call( jQuery( elem ), value ); }; // Otherwise they run against the entire set } else { fn.call( elems, value ); fn = null; } } if ( fn ) { for (; i < length; i++ ) { fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); } } chainable = 1; } return chainable ? elems : // Gets bulk ? fn.call( elems ) : length ? fn( elems[0], key ) : emptyGet; }, now: function() { return ( new Date() ).getTime(); }, // Use of jQuery.browser is frowned upon. // More details: http://docs.jquery.com/Utilities/jQuery.browser uaMatch: function( ua ) { ua = ua.toLowerCase(); var match = rwebkit.exec( ua ) || ropera.exec( ua ) || rmsie.exec( ua ) || ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) || []; return { browser: match[1] || "", version: match[2] || "0" }; }, sub: function() { function jQuerySub( selector, context ) { return new jQuerySub.fn.init( selector, context ); } jQuery.extend( true, jQuerySub, this ); jQuerySub.superclass = this; jQuerySub.fn = jQuerySub.prototype = this(); jQuerySub.fn.constructor = jQuerySub; jQuerySub.sub = this.sub; jQuerySub.fn.init = function init( selector, context ) { if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) { context = jQuerySub( context ); } return jQuery.fn.init.call( this, selector, context, rootjQuerySub ); }; jQuerySub.fn.init.prototype = jQuerySub.fn; var rootjQuerySub = jQuerySub(document); return jQuerySub; }, browser: {} }); // Populate the class2type map jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { class2type[ "[object " + name + "]" ] = name.toLowerCase(); }); browserMatch = jQuery.uaMatch( userAgent ); if ( browserMatch.browser ) { jQuery.browser[ browserMatch.browser ] = true; jQuery.browser.version = browserMatch.version; } // Deprecated, use jQuery.browser.webkit instead if ( jQuery.browser.webkit ) { jQuery.browser.safari = true; } // IE doesn't match non-breaking spaces with \s if ( rnotwhite.test( "\xA0" ) ) { trimLeft = /^[\s\xA0]+/; trimRight = /[\s\xA0]+$/; } // All jQuery objects should point back to these rootjQuery = jQuery(document); // Cleanup functions for the document ready method if ( document.addEventListener ) { DOMContentLoaded = function() { document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); jQuery.ready(); }; } else if ( document.attachEvent ) { DOMContentLoaded = function() { // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). if ( document.readyState === "complete" ) { document.detachEvent( "onreadystatechange", DOMContentLoaded ); jQuery.ready(); } }; } // The DOM ready check for Internet Explorer function doScrollCheck() { if ( jQuery.isReady ) { return; } try { // If IE is used, use the trick by Diego Perini // http://javascript.nwbox.com/IEContentLoaded/ document.documentElement.doScroll("left"); } catch(e) { setTimeout( doScrollCheck, 1 ); return; } // and execute any waiting functions jQuery.ready(); } return jQuery; })(); // String to Object flags format cache var flagsCache = {}; // Convert String-formatted flags into Object-formatted ones and store in cache function createFlags( flags ) { var object = flagsCache[ flags ] = {}, i, length; flags = flags.split( /\s+/ ); for ( i = 0, length = flags.length; i < length; i++ ) { object[ flags[i] ] = true; } return object; } /* * Create a callback list using the following parameters: * * flags: an optional list of space-separated flags that will change how * the callback list behaves * * By default a callback list will act like an event callback list and can be * "fired" multiple times. * * Possible flags: * * once: will ensure the callback list can only be fired once (like a Deferred) * * memory: will keep track of previous values and will call any callback added * after the list has been fired right away with the latest "memorized" * values (like a Deferred) * * unique: will ensure a callback can only be added once (no duplicate in the list) * * stopOnFalse: interrupt callings when a callback returns false * */ jQuery.Callbacks = function( flags ) { // Convert flags from String-formatted to Object-formatted // (we check in cache first) flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {}; var // Actual callback list list = [], // Stack of fire calls for repeatable lists stack = [], // Last fire value (for non-forgettable lists) memory, // Flag to know if list was already fired fired, // Flag to know if list is currently firing firing, // First callback to fire (used internally by add and fireWith) firingStart, // End of the loop when firing firingLength, // Index of currently firing callback (modified by remove if needed) firingIndex, // Add one or several callbacks to the list add = function( args ) { var i, length, elem, type, actual; for ( i = 0, length = args.length; i < length; i++ ) { elem = args[ i ]; type = jQuery.type( elem ); if ( type === "array" ) { // Inspect recursively add( elem ); } else if ( type === "function" ) { // Add if not in unique mode and callback is not in if ( !flags.unique || !self.has( elem ) ) { list.push( elem ); } } } }, // Fire callbacks fire = function( context, args ) { args = args || []; memory = !flags.memory || [ context, args ]; fired = true; firing = true; firingIndex = firingStart || 0; firingStart = 0; firingLength = list.length; for ( ; list && firingIndex < firingLength; firingIndex++ ) { if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) { memory = true; // Mark as halted break; } } firing = false; if ( list ) { if ( !flags.once ) { if ( stack && stack.length ) { memory = stack.shift(); self.fireWith( memory[ 0 ], memory[ 1 ] ); } } else if ( memory === true ) { self.disable(); } else { list = []; } } }, // Actual Callbacks object self = { // Add a callback or a collection of callbacks to the list add: function() { if ( list ) { var length = list.length; add( arguments ); // Do we need to add the callbacks to the // current firing batch? if ( firing ) { firingLength = list.length; // With memory, if we're not firing then // we should call right away, unless previous // firing was halted (stopOnFalse) } else if ( memory && memory !== true ) { firingStart = length; fire( memory[ 0 ], memory[ 1 ] ); } } return this; }, // Remove a callback from the list remove: function() { if ( list ) { var args = arguments, argIndex = 0, argLength = args.length; for ( ; argIndex < argLength ; argIndex++ ) { for ( var i = 0; i < list.length; i++ ) { if ( args[ argIndex ] === list[ i ] ) { // Handle firingIndex and firingLength if ( firing ) { if ( i <= firingLength ) { firingLength--; if ( i <= firingIndex ) { firingIndex--; } } } // Remove the element list.splice( i--, 1 ); // If we have some unicity property then // we only need to do this once if ( flags.unique ) { break; } } } } } return this; }, // Control if a given callback is in the list has: function( fn ) { if ( list ) { var i = 0, length = list.length; for ( ; i < length; i++ ) { if ( fn === list[ i ] ) { return true; } } } return false; }, // Remove all callbacks from the list empty: function() { list = []; return this; }, // Have the list do nothing anymore disable: function() { list = stack = memory = undefined; return this; }, // Is it disabled? disabled: function() { return !list; }, // Lock the list in its current state lock: function() { stack = undefined; if ( !memory || memory === true ) { self.disable(); } return this; }, // Is it locked? locked: function() { return !stack; }, // Call all callbacks with the given context and arguments fireWith: function( context, args ) { if ( stack ) { if ( firing ) { if ( !flags.once ) { stack.push( [ context, args ] ); } } else if ( !( flags.once && memory ) ) { fire( context, args ); } } return this; }, // Call all the callbacks with the given arguments fire: function() { self.fireWith( this, arguments ); return this; }, // To know if the callbacks have already been called at least once fired: function() { return !!fired; } }; return self; }; var // Static reference to slice sliceDeferred = [].slice; jQuery.extend({ Deferred: function( func ) { var doneList = jQuery.Callbacks( "once memory" ), failList = jQuery.Callbacks( "once memory" ), progressList = jQuery.Callbacks( "memory" ), state = "pending", lists = { resolve: doneList, reject: failList, notify: progressList }, promise = { done: doneList.add, fail: failList.add, progress: progressList.add, state: function() { return state; }, // Deprecated isResolved: doneList.fired, isRejected: failList.fired, then: function( doneCallbacks, failCallbacks, progressCallbacks ) { deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks ); return this; }, always: function() { deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments ); return this; }, pipe: function( fnDone, fnFail, fnProgress ) { return jQuery.Deferred(function( newDefer ) { jQuery.each( { done: [ fnDone, "resolve" ], fail: [ fnFail, "reject" ], progress: [ fnProgress, "notify" ] }, function( handler, data ) { var fn = data[ 0 ], action = data[ 1 ], returned; if ( jQuery.isFunction( fn ) ) { deferred[ handler ](function() { returned = fn.apply( this, arguments ); if ( returned && jQuery.isFunction( returned.promise ) ) { returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify ); } else { newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); } }); } else { deferred[ handler ]( newDefer[ action ] ); } }); }).promise(); }, // Get a promise for this deferred // If obj is provided, the promise aspect is added to the object promise: function( obj ) { if ( obj == null ) { obj = promise; } else { for ( var key in promise ) { obj[ key ] = promise[ key ]; } } return obj; } }, deferred = promise.promise({}), key; for ( key in lists ) { deferred[ key ] = lists[ key ].fire; deferred[ key + "With" ] = lists[ key ].fireWith; } // Handle state deferred.done( function() { state = "resolved"; }, failList.disable, progressList.lock ).fail( function() { state = "rejected"; }, doneList.disable, progressList.lock ); // Call given func if any if ( func ) { func.call( deferred, deferred ); } // All done! return deferred; }, // Deferred helper when: function( firstParam ) { var args = sliceDeferred.call( arguments, 0 ), i = 0, length = args.length, pValues = new Array( length ), count = length, pCount = length, deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ? firstParam : jQuery.Deferred(), promise = deferred.promise(); function resolveFunc( i ) { return function( value ) { args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; if ( !( --count ) ) { deferred.resolveWith( deferred, args ); } }; } function progressFunc( i ) { return function( value ) { pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; deferred.notifyWith( promise, pValues ); }; } if ( length > 1 ) { for ( ; i < length; i++ ) { if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) { args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) ); } else { --count; } } if ( !count ) { deferred.resolveWith( deferred, args ); } } else if ( deferred !== firstParam ) { deferred.resolveWith( deferred, length ? [ firstParam ] : [] ); } return promise; } }); jQuery.support = (function() { var support, all, a, select, opt, input, fragment, tds, events, eventName, i, isSupported, div = document.createElement( "div" ), documentElement = document.documentElement; // Preliminary tests div.setAttribute("className", "t"); div.innerHTML = "
a"; all = div.getElementsByTagName( "*" ); a = div.getElementsByTagName( "a" )[ 0 ]; // Can't get basic test support if ( !all || !all.length || !a ) { return {}; } // First batch of supports tests select = document.createElement( "select" ); opt = select.appendChild( document.createElement("option") ); input = div.getElementsByTagName( "input" )[ 0 ]; support = { // IE strips leading whitespace when .innerHTML is used leadingWhitespace: ( div.firstChild.nodeType === 3 ), // Make sure that tbody elements aren't automatically inserted // IE will insert them into empty tables tbody: !div.getElementsByTagName("tbody").length, // Make sure that link elements get serialized correctly by innerHTML // This requires a wrapper element in IE htmlSerialize: !!div.getElementsByTagName("link").length, // Get the style information from getAttribute // (IE uses .cssText instead) style: /top/.test( a.getAttribute("style") ), // Make sure that URLs aren't manipulated // (IE normalizes it by default) hrefNormalized: ( a.getAttribute("href") === "/a" ), // Make sure that element opacity exists // (IE uses filter instead) // Use a regex to work around a WebKit issue. See #5145 opacity: /^0.55/.test( a.style.opacity ), // Verify style float existence // (IE uses styleFloat instead of cssFloat) cssFloat: !!a.style.cssFloat, // Make sure that if no value is specified for a checkbox // that it defaults to "on". // (WebKit defaults to "" instead) checkOn: ( input.value === "on" ), // Make sure that a selected-by-default option has a working selected property. // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) optSelected: opt.selected, // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) getSetAttribute: div.className !== "t", // Tests for enctype support on a form(#6743) enctype: !!document.createElement("form").enctype, // Makes sure cloning an html5 element does not cause problems // Where outerHTML is undefined, this still works html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav>", // Will be defined later submitBubbles: true, changeBubbles: true, focusinBubbles: false, deleteExpando: true, noCloneEvent: true, inlineBlockNeedsLayout: false, shrinkWrapBlocks: false, reliableMarginRight: true, pixelMargin: true }; // jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat"); // Make sure checked status is properly cloned input.checked = true; support.noCloneChecked = input.cloneNode( true ).checked; // Make sure that the options inside disabled selects aren't marked as disabled // (WebKit marks them as disabled) select.disabled = true; support.optDisabled = !opt.disabled; // Test to see if it's possible to delete an expando from an element // Fails in Internet Explorer try { delete div.test; } catch( e ) { support.deleteExpando = false; } if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { div.attachEvent( "onclick", function() { // Cloning a node shouldn't copy over any // bound event handlers (IE does this) support.noCloneEvent = false; }); div.cloneNode( true ).fireEvent( "onclick" ); } // Check if a radio maintains its value // after being appended to the DOM input = document.createElement("input"); input.value = "t"; input.setAttribute("type", "radio"); support.radioValue = input.value === "t"; input.setAttribute("checked", "checked"); // #11217 - WebKit loses check when the name is after the checked attribute input.setAttribute( "name", "t" ); div.appendChild( input ); fragment = document.createDocumentFragment(); fragment.appendChild( div.lastChild ); // WebKit doesn't clone checked state correctly in fragments support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; // Check if a disconnected checkbox will retain its checked // value of true after appended to the DOM (IE6/7) support.appendChecked = input.checked; fragment.removeChild( input ); fragment.appendChild( div ); // Technique from Juriy Zaytsev // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/ // We only care about the case where non-standard event systems // are used, namely in IE. Short-circuiting here helps us to // avoid an eval call (in setAttribute) which can cause CSP // to go haywire. See: https://developer.mozilla.org/en/Security/CSP if ( div.attachEvent ) { for ( i in { submit: 1, change: 1, focusin: 1 }) { eventName = "on" + i; isSupported = ( eventName in div ); if ( !isSupported ) { div.setAttribute( eventName, "return;" ); isSupported = ( typeof div[ eventName ] === "function" ); } support[ i + "Bubbles" ] = isSupported; } } fragment.removeChild( div ); // Null elements to avoid leaks in IE fragment = select = opt = div = input = null; // Run tests that need a body at doc ready jQuery(function() { var container, outer, inner, table, td, offsetSupport, marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight, paddingMarginBorderVisibility, paddingMarginBorder, body = document.getElementsByTagName("body")[0]; if ( !body ) { // Return for frameset docs that don't have a body return; } conMarginTop = 1; paddingMarginBorder = "padding:0;margin:0;border:"; positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;"; paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;"; style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;"; html = "
" + "" + "
"; container = document.createElement("div"); container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px"; body.insertBefore( container, body.firstChild ); // Construct the test element div = document.createElement("div"); container.appendChild( div ); // Check if table cells still have offsetWidth/Height when they are set // to display:none and there are still other visible table cells in a // table row; if so, offsetWidth/Height are not reliable for use when // determining if an element has been hidden directly using // display:none (it is still safe to use offsets if a parent element is // hidden; don safety goggles and see bug #4512 for more information). // (only IE 8 fails this test) div.innerHTML = "
t
"; tds = div.getElementsByTagName( "td" ); isSupported = ( tds[ 0 ].offsetHeight === 0 ); tds[ 0 ].style.display = ""; tds[ 1 ].style.display = "none"; // Check if empty table cells still have offsetWidth/Height // (IE <= 8 fail this test) support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); // Check if div with explicit width and no margin-right incorrectly // gets computed margin-right based on width of container. For more // info see bug #3333 // Fails in WebKit before Feb 2011 nightlies // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right if ( window.getComputedStyle ) { div.innerHTML = ""; marginDiv = document.createElement( "div" ); marginDiv.style.width = "0"; marginDiv.style.marginRight = "0"; div.style.width = "2px"; div.appendChild( marginDiv ); support.reliableMarginRight = ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; } if ( typeof div.style.zoom !== "undefined" ) { // Check if natively block-level elements act like inline-block // elements when setting their display to 'inline' and giving // them layout // (IE < 8 does this) div.innerHTML = ""; div.style.width = div.style.padding = "1px"; div.style.border = 0; div.style.overflow = "hidden"; div.style.display = "inline"; div.style.zoom = 1; support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 ); // Check if elements with layout shrink-wrap their children // (IE 6 does this) div.style.display = "block"; div.style.overflow = "visible"; div.innerHTML = "
"; support.shrinkWrapBlocks = ( div.offsetWidth !== 3 ); } div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility; div.innerHTML = html; outer = div.firstChild; inner = outer.firstChild; td = outer.nextSibling.firstChild.firstChild; offsetSupport = { doesNotAddBorder: ( inner.offsetTop !== 5 ), doesAddBorderForTableAndCells: ( td.offsetTop === 5 ) }; inner.style.position = "fixed"; inner.style.top = "20px"; // safari subtracts parent border width here which is 5px offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 ); inner.style.position = inner.style.top = ""; outer.style.overflow = "hidden"; outer.style.position = "relative"; offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 ); offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop ); if ( window.getComputedStyle ) { div.style.marginTop = "1%"; support.pixelMargin = ( window.getComputedStyle( div, null ) || { marginTop: 0 } ).marginTop !== "1%"; } if ( typeof container.style.zoom !== "undefined" ) { container.style.zoom = 1; } body.removeChild( container ); marginDiv = div = container = null; jQuery.extend( support, offsetSupport ); }); return support; })(); var rbrace = /^(?:\{.*\}|\[.*\])$/, rmultiDash = /([A-Z])/g; jQuery.extend({ cache: {}, // Please use with caution uuid: 0, // Unique for each copy of jQuery on the page // Non-digits removed to match rinlinejQuery expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ), // The following elements throw uncatchable exceptions if you // attempt to add expando properties to them. noData: { "embed": true, // Ban all objects except for Flash (which handle expandos) "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", "applet": true }, hasData: function( elem ) { elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; return !!elem && !isEmptyDataObject( elem ); }, data: function( elem, name, data, pvt /* Internal Use Only */ ) { if ( !jQuery.acceptData( elem ) ) { return; } var privateCache, thisCache, ret, internalKey = jQuery.expando, getByName = typeof name === "string", // We have to handle DOM nodes and JS objects differently because IE6-7 // can't GC object references properly across the DOM-JS boundary isNode = elem.nodeType, // Only DOM nodes need the global jQuery cache; JS object data is // attached directly to the object so GC can occur automatically cache = isNode ? jQuery.cache : elem, // Only defining an ID for JS objects if its cache already exists allows // the code to shortcut on the same path as a DOM node with no cache id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey, isEvents = name === "events"; // Avoid doing any more work than we need to when trying to get data on an // object that has no data at all if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) { return; } if ( !id ) { // Only DOM nodes need a new unique ID for each element since their data // ends up in the global cache if ( isNode ) { elem[ internalKey ] = id = ++jQuery.uuid; } else { id = internalKey; } } if ( !cache[ id ] ) { cache[ id ] = {}; // Avoids exposing jQuery metadata on plain JS objects when the object // is serialized using JSON.stringify if ( !isNode ) { cache[ id ].toJSON = jQuery.noop; } } // An object can be passed to jQuery.data instead of a key/value pair; this gets // shallow copied over onto the existing cache if ( typeof name === "object" || typeof name === "function" ) { if ( pvt ) { cache[ id ] = jQuery.extend( cache[ id ], name ); } else { cache[ id ].data = jQuery.extend( cache[ id ].data, name ); } } privateCache = thisCache = cache[ id ]; // jQuery data() is stored in a separate object inside the object's internal data // cache in order to avoid key collisions between internal data and user-defined // data. if ( !pvt ) { if ( !thisCache.data ) { thisCache.data = {}; } thisCache = thisCache.data; } if ( data !== undefined ) { thisCache[ jQuery.camelCase( name ) ] = data; } // Users should not attempt to inspect the internal events object using jQuery.data, // it is undocumented and subject to change. But does anyone listen? No. if ( isEvents && !thisCache[ name ] ) { return privateCache.events; } // Check for both converted-to-camel and non-converted data property names // If a data property was specified if ( getByName ) { // First Try to find as-is property data ret = thisCache[ name ]; // Test for null|undefined property data if ( ret == null ) { // Try to find the camelCased property ret = thisCache[ jQuery.camelCase( name ) ]; } } else { ret = thisCache; } return ret; }, removeData: function( elem, name, pvt /* Internal Use Only */ ) { if ( !jQuery.acceptData( elem ) ) { return; } var thisCache, i, l, // Reference to internal data cache key internalKey = jQuery.expando, isNode = elem.nodeType, // See jQuery.data for more information cache = isNode ? jQuery.cache : elem, // See jQuery.data for more information id = isNode ? elem[ internalKey ] : internalKey; // If there is already no cache entry for this object, there is no // purpose in continuing if ( !cache[ id ] ) { return; } if ( name ) { thisCache = pvt ? cache[ id ] : cache[ id ].data; if ( thisCache ) { // Support array or space separated string names for data keys if ( !jQuery.isArray( name ) ) { // try the string as a key before any manipulation if ( name in thisCache ) { name = [ name ]; } else { // split the camel cased version by spaces unless a key with the spaces exists name = jQuery.camelCase( name ); if ( name in thisCache ) { name = [ name ]; } else { name = name.split( " " ); } } } for ( i = 0, l = name.length; i < l; i++ ) { delete thisCache[ name[i] ]; } // If there is no data left in the cache, we want to continue // and let the cache object itself get destroyed if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { return; } } } // See jQuery.data for more information if ( !pvt ) { delete cache[ id ].data; // Don't destroy the parent cache unless the internal data object // had been the only thing left in it if ( !isEmptyDataObject(cache[ id ]) ) { return; } } // Browsers that fail expando deletion also refuse to delete expandos on // the window, but it will allow it on all other JS objects; other browsers // don't care // Ensure that `cache` is not a window object #10080 if ( jQuery.support.deleteExpando || !cache.setInterval ) { delete cache[ id ]; } else { cache[ id ] = null; } // We destroyed the cache and need to eliminate the expando on the node to avoid // false lookups in the cache for entries that no longer exist if ( isNode ) { // IE does not allow us to delete expando properties from nodes, // nor does it have a removeAttribute function on Document nodes; // we must handle all of these cases if ( jQuery.support.deleteExpando ) { delete elem[ internalKey ]; } else if ( elem.removeAttribute ) { elem.removeAttribute( internalKey ); } else { elem[ internalKey ] = null; } } }, // For internal use only. _data: function( elem, name, data ) { return jQuery.data( elem, name, data, true ); }, // A method for determining if a DOM node can handle the data expando acceptData: function( elem ) { if ( elem.nodeName ) { var match = jQuery.noData[ elem.nodeName.toLowerCase() ]; if ( match ) { return !(match === true || elem.getAttribute("classid") !== match); } } return true; } }); jQuery.fn.extend({ data: function( key, value ) { var parts, part, attr, name, l, elem = this[0], i = 0, data = null; // Gets all values if ( key === undefined ) { if ( this.length ) { data = jQuery.data( elem ); if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { attr = elem.attributes; for ( l = attr.length; i < l; i++ ) { name = attr[i].name; if ( name.indexOf( "data-" ) === 0 ) { name = jQuery.camelCase( name.substring(5) ); dataAttr( elem, name, data[ name ] ); } } jQuery._data( elem, "parsedAttrs", true ); } } return data; } // Sets multiple values if ( typeof key === "object" ) { return this.each(function() { jQuery.data( this, key ); }); } parts = key.split( ".", 2 ); parts[1] = parts[1] ? "." + parts[1] : ""; part = parts[1] + "!"; return jQuery.access( this, function( value ) { if ( value === undefined ) { data = this.triggerHandler( "getData" + part, [ parts[0] ] ); // Try to fetch any internally stored data first if ( data === undefined && elem ) { data = jQuery.data( elem, key ); data = dataAttr( elem, key, data ); } return data === undefined && parts[1] ? this.data( parts[0] ) : data; } parts[1] = value; this.each(function() { var self = jQuery( this ); self.triggerHandler( "setData" + part, parts ); jQuery.data( this, key, value ); self.triggerHandler( "changeData" + part, parts ); }); }, null, value, arguments.length > 1, null, false ); }, removeData: function( key ) { return this.each(function() { jQuery.removeData( this, key ); }); } }); function dataAttr( elem, key, data ) { // If nothing was found internally, try to fetch any // data from the HTML5 data-* attribute if ( data === undefined && elem.nodeType === 1 ) { var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { try { data = data === "true" ? true : data === "false" ? false : data === "null" ? null : jQuery.isNumeric( data ) ? +data : rbrace.test( data ) ? jQuery.parseJSON( data ) : data; } catch( e ) {} // Make sure we set the data so it isn't changed later jQuery.data( elem, key, data ); } else { data = undefined; } } return data; } // checks a cache object for emptiness function isEmptyDataObject( obj ) { for ( var name in obj ) { // if the public data object is empty, the private is still empty if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { continue; } if ( name !== "toJSON" ) { return false; } } return true; } function handleQueueMarkDefer( elem, type, src ) { var deferDataKey = type + "defer", queueDataKey = type + "queue", markDataKey = type + "mark", defer = jQuery._data( elem, deferDataKey ); if ( defer && ( src === "queue" || !jQuery._data(elem, queueDataKey) ) && ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) { // Give room for hard-coded callbacks to fire first // and eventually mark/queue something else on the element setTimeout( function() { if ( !jQuery._data( elem, queueDataKey ) && !jQuery._data( elem, markDataKey ) ) { jQuery.removeData( elem, deferDataKey, true ); defer.fire(); } }, 0 ); } } jQuery.extend({ _mark: function( elem, type ) { if ( elem ) { type = ( type || "fx" ) + "mark"; jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 ); } }, _unmark: function( force, elem, type ) { if ( force !== true ) { type = elem; elem = force; force = false; } if ( elem ) { type = type || "fx"; var key = type + "mark", count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 ); if ( count ) { jQuery._data( elem, key, count ); } else { jQuery.removeData( elem, key, true ); handleQueueMarkDefer( elem, type, "mark" ); } } }, queue: function( elem, type, data ) { var q; if ( elem ) { type = ( type || "fx" ) + "queue"; q = jQuery._data( elem, type ); // Speed up dequeue by getting out quickly if this is just a lookup if ( data ) { if ( !q || jQuery.isArray(data) ) { q = jQuery._data( elem, type, jQuery.makeArray(data) ); } else { q.push( data ); } } return q || []; } }, dequeue: function( elem, type ) { type = type || "fx"; var queue = jQuery.queue( elem, type ), fn = queue.shift(), hooks = {}; // If the fx queue is dequeued, always remove the progress sentinel if ( fn === "inprogress" ) { fn = queue.shift(); } if ( fn ) { // Add a progress sentinel to prevent the fx queue from being // automatically dequeued if ( type === "fx" ) { queue.unshift( "inprogress" ); } jQuery._data( elem, type + ".run", hooks ); fn.call( elem, function() { jQuery.dequeue( elem, type ); }, hooks ); } if ( !queue.length ) { jQuery.removeData( elem, type + "queue " + type + ".run", true ); handleQueueMarkDefer( elem, type, "queue" ); } } }); jQuery.fn.extend({ queue: function( type, data ) { var setter = 2; if ( typeof type !== "string" ) { data = type; type = "fx"; setter--; } if ( arguments.length < setter ) { return jQuery.queue( this[0], type ); } return data === undefined ? this : this.each(function() { var queue = jQuery.queue( this, type, data ); if ( type === "fx" && queue[0] !== "inprogress" ) { jQuery.dequeue( this, type ); } }); }, dequeue: function( type ) { return this.each(function() { jQuery.dequeue( this, type ); }); }, // Based off of the plugin by Clint Helfers, with permission. // http://blindsignals.com/index.php/2009/07/jquery-delay/ delay: function( time, type ) { time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; type = type || "fx"; return this.queue( type, function( next, hooks ) { var timeout = setTimeout( next, time ); hooks.stop = function() { clearTimeout( timeout ); }; }); }, clearQueue: function( type ) { return this.queue( type || "fx", [] ); }, // Get a promise resolved when queues of a certain type // are emptied (fx is the type by default) promise: function( type, object ) { if ( typeof type !== "string" ) { object = type; type = undefined; } type = type || "fx"; var defer = jQuery.Deferred(), elements = this, i = elements.length, count = 1, deferDataKey = type + "defer", queueDataKey = type + "queue", markDataKey = type + "mark", tmp; function resolve() { if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); } } while( i-- ) { if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) || ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) || jQuery.data( elements[ i ], markDataKey, undefined, true ) ) && jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) { count++; tmp.add( resolve ); } } resolve(); return defer.promise( object ); } }); var rclass = /[\n\t\r]/g, rspace = /\s+/, rreturn = /\r/g, rtype = /^(?:button|input)$/i, rfocusable = /^(?:button|input|object|select|textarea)$/i, rclickable = /^a(?:rea)?$/i, rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, getSetAttribute = jQuery.support.getSetAttribute, nodeHook, boolHook, fixSpecified; jQuery.fn.extend({ attr: function( name, value ) { return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 ); }, removeAttr: function( name ) { return this.each(function() { jQuery.removeAttr( this, name ); }); }, prop: function( name, value ) { return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 ); }, removeProp: function( name ) { name = jQuery.propFix[ name ] || name; return this.each(function() { // try/catch handles cases where IE balks (such as removing a property on window) try { this[ name ] = undefined; delete this[ name ]; } catch( e ) {} }); }, addClass: function( value ) { var classNames, i, l, elem, setClass, c, cl; if ( jQuery.isFunction( value ) ) { return this.each(function( j ) { jQuery( this ).addClass( value.call(this, j, this.className) ); }); } if ( value && typeof value === "string" ) { classNames = value.split( rspace ); for ( i = 0, l = this.length; i < l; i++ ) { elem = this[ i ]; if ( elem.nodeType === 1 ) { if ( !elem.className && classNames.length === 1 ) { elem.className = value; } else { setClass = " " + elem.className + " "; for ( c = 0, cl = classNames.length; c < cl; c++ ) { if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) { setClass += classNames[ c ] + " "; } } elem.className = jQuery.trim( setClass ); } } } } return this; }, removeClass: function( value ) { var classNames, i, l, elem, className, c, cl; if ( jQuery.isFunction( value ) ) { return this.each(function( j ) { jQuery( this ).removeClass( value.call(this, j, this.className) ); }); } if ( (value && typeof value === "string") || value === undefined ) { classNames = ( value || "" ).split( rspace ); for ( i = 0, l = this.length; i < l; i++ ) { elem = this[ i ]; if ( elem.nodeType === 1 && elem.className ) { if ( value ) { className = (" " + elem.className + " ").replace( rclass, " " ); for ( c = 0, cl = classNames.length; c < cl; c++ ) { className = className.replace(" " + classNames[ c ] + " ", " "); } elem.className = jQuery.trim( className ); } else { elem.className = ""; } } } } return this; }, toggleClass: function( value, stateVal ) { var type = typeof value, isBool = typeof stateVal === "boolean"; if ( jQuery.isFunction( value ) ) { return this.each(function( i ) { jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); }); } return this.each(function() { if ( type === "string" ) { // toggle individual class names var className, i = 0, self = jQuery( this ), state = stateVal, classNames = value.split( rspace ); while ( (className = classNames[ i++ ]) ) { // check each className given, space seperated list state = isBool ? state : !self.hasClass( className ); self[ state ? "addClass" : "removeClass" ]( className ); } } else if ( type === "undefined" || type === "boolean" ) { if ( this.className ) { // store className if set jQuery._data( this, "__className__", this.className ); } // toggle whole className this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || ""; } }); }, hasClass: function( selector ) { var className = " " + selector + " ", i = 0, l = this.length; for ( ; i < l; i++ ) { if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) { return true; } } return false; }, val: function( value ) { var hooks, ret, isFunction, elem = this[0]; if ( !arguments.length ) { if ( elem ) { hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { return ret; } ret = elem.value; return typeof ret === "string" ? // handle most common string cases ret.replace(rreturn, "") : // handle cases where value is null/undef or number ret == null ? "" : ret; } return; } isFunction = jQuery.isFunction( value ); return this.each(function( i ) { var self = jQuery(this), val; if ( this.nodeType !== 1 ) { return; } if ( isFunction ) { val = value.call( this, i, self.val() ); } else { val = value; } // Treat null/undefined as ""; convert numbers to string if ( val == null ) { val = ""; } else if ( typeof val === "number" ) { val += ""; } else if ( jQuery.isArray( val ) ) { val = jQuery.map(val, function ( value ) { return value == null ? "" : value + ""; }); } hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; // If set returns undefined, fall back to normal setting if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { this.value = val; } }); } }); jQuery.extend({ valHooks: { option: { get: function( elem ) { // attributes.value is undefined in Blackberry 4.7 but // uses .value. See #6932 var val = elem.attributes.value; return !val || val.specified ? elem.value : elem.text; } }, select: { get: function( elem ) { var value, i, max, option, index = elem.selectedIndex, values = [], options = elem.options, one = elem.type === "select-one"; // Nothing was selected if ( index < 0 ) { return null; } // Loop through all the selected options i = one ? index : 0; max = one ? index + 1 : options.length; for ( ; i < max; i++ ) { option = options[ i ]; // Don't return options that are disabled or in a disabled optgroup if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) { // Get the specific value for the option value = jQuery( option ).val(); // We don't need an array for one selects if ( one ) { return value; } // Multi-Selects return an array values.push( value ); } } // Fixes Bug #2551 -- select.val() broken in IE after form.reset() if ( one && !values.length && options.length ) { return jQuery( options[ index ] ).val(); } return values; }, set: function( elem, value ) { var values = jQuery.makeArray( value ); jQuery(elem).find("option").each(function() { this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0; }); if ( !values.length ) { elem.selectedIndex = -1; } return values; } } }, attrFn: { val: true, css: true, html: true, text: true, data: true, width: true, height: true, offset: true }, attr: function( elem, name, value, pass ) { var ret, hooks, notxml, nType = elem.nodeType; // don't get/set attributes on text, comment and attribute nodes if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { return; } if ( pass && name in jQuery.attrFn ) { return jQuery( elem )[ name ]( value ); } // Fallback to prop when attributes are not supported if ( typeof elem.getAttribute === "undefined" ) { return jQuery.prop( elem, name, value ); } notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); // All attributes are lowercase // Grab necessary hook if one is defined if ( notxml ) { name = name.toLowerCase(); hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); } if ( value !== undefined ) { if ( value === null ) { jQuery.removeAttr( elem, name ); return; } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { return ret; } else { elem.setAttribute( name, "" + value ); return value; } } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) { return ret; } else { ret = elem.getAttribute( name ); // Non-existent attributes return null, we normalize to undefined return ret === null ? undefined : ret; } }, removeAttr: function( elem, value ) { var propName, attrNames, name, l, isBool, i = 0; if ( value && elem.nodeType === 1 ) { attrNames = value.toLowerCase().split( rspace ); l = attrNames.length; for ( ; i < l; i++ ) { name = attrNames[ i ]; if ( name ) { propName = jQuery.propFix[ name ] || name; isBool = rboolean.test( name ); // See #9699 for explanation of this approach (setting first, then removal) // Do not do this for boolean attributes (see #10870) if ( !isBool ) { jQuery.attr( elem, name, "" ); } elem.removeAttribute( getSetAttribute ? name : propName ); // Set corresponding property to false for boolean attributes if ( isBool && propName in elem ) { elem[ propName ] = false; } } } } }, attrHooks: { type: { set: function( elem, value ) { // We can't allow the type property to be changed (since it causes problems in IE) if ( rtype.test( elem.nodeName ) && elem.parentNode ) { jQuery.error( "type property can't be changed" ); } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { // Setting the type on a radio button after the value resets the value in IE6-9 // Reset value to it's default in case type is set after value // This is for element creation var val = elem.value; elem.setAttribute( "type", value ); if ( val ) { elem.value = val; } return value; } } }, // Use the value property for back compat // Use the nodeHook for button elements in IE6/7 (#1954) value: { get: function( elem, name ) { if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { return nodeHook.get( elem, name ); } return name in elem ? elem.value : null; }, set: function( elem, value, name ) { if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { return nodeHook.set( elem, value, name ); } // Does not return so that setAttribute is also used elem.value = value; } } }, propFix: { tabindex: "tabIndex", readonly: "readOnly", "for": "htmlFor", "class": "className", maxlength: "maxLength", cellspacing: "cellSpacing", cellpadding: "cellPadding", rowspan: "rowSpan", colspan: "colSpan", usemap: "useMap", frameborder: "frameBorder", contenteditable: "contentEditable" }, prop: function( elem, name, value ) { var ret, hooks, notxml, nType = elem.nodeType; // don't get/set properties on text, comment and attribute nodes if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { return; } notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); if ( notxml ) { // Fix name and attach hooks name = jQuery.propFix[ name ] || name; hooks = jQuery.propHooks[ name ]; } if ( value !== undefined ) { if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { return ret; } else { return ( elem[ name ] = value ); } } else { if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { return ret; } else { return elem[ name ]; } } }, propHooks: { tabIndex: { get: function( elem ) { // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ var attributeNode = elem.getAttributeNode("tabindex"); return attributeNode && attributeNode.specified ? parseInt( attributeNode.value, 10 ) : rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 0 : undefined; } } } }); // Add the tabIndex propHook to attrHooks for back-compat (different case is intentional) jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex; // Hook for boolean attributes boolHook = { get: function( elem, name ) { // Align boolean attributes with corresponding properties // Fall back to attribute presence where some booleans are not supported var attrNode, property = jQuery.prop( elem, name ); return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? name.toLowerCase() : undefined; }, set: function( elem, value, name ) { var propName; if ( value === false ) { // Remove boolean attributes when set to false jQuery.removeAttr( elem, name ); } else { // value is true since we know at this point it's type boolean and not false // Set boolean attributes to the same name and set the DOM property propName = jQuery.propFix[ name ] || name; if ( propName in elem ) { // Only set the IDL specifically if it already exists on the element elem[ propName ] = true; } elem.setAttribute( name, name.toLowerCase() ); } return name; } }; // IE6/7 do not support getting/setting some attributes with get/setAttribute if ( !getSetAttribute ) { fixSpecified = { name: true, id: true, coords: true }; // Use this for any attribute in IE6/7 // This fixes almost every IE6/7 issue nodeHook = jQuery.valHooks.button = { get: function( elem, name ) { var ret; ret = elem.getAttributeNode( name ); return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ? ret.nodeValue : undefined; }, set: function( elem, value, name ) { // Set the existing or create a new attribute node var ret = elem.getAttributeNode( name ); if ( !ret ) { ret = document.createAttribute( name ); elem.setAttributeNode( ret ); } return ( ret.nodeValue = value + "" ); } }; // Apply the nodeHook to tabindex jQuery.attrHooks.tabindex.set = nodeHook.set; // Set width and height to auto instead of 0 on empty string( Bug #8150 ) // This is for removals jQuery.each([ "width", "height" ], function( i, name ) { jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { set: function( elem, value ) { if ( value === "" ) { elem.setAttribute( name, "auto" ); return value; } } }); }); // Set contenteditable to false on removals(#10429) // Setting to empty string throws an error as an invalid value jQuery.attrHooks.contenteditable = { get: nodeHook.get, set: function( elem, value, name ) { if ( value === "" ) { value = "false"; } nodeHook.set( elem, value, name ); } }; } // Some attributes require a special call on IE if ( !jQuery.support.hrefNormalized ) { jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { get: function( elem ) { var ret = elem.getAttribute( name, 2 ); return ret === null ? undefined : ret; } }); }); } if ( !jQuery.support.style ) { jQuery.attrHooks.style = { get: function( elem ) { // Return undefined in the case of empty string // Normalize to lowercase since IE uppercases css property names return elem.style.cssText.toLowerCase() || undefined; }, set: function( elem, value ) { return ( elem.style.cssText = "" + value ); } }; } // Safari mis-reports the default selected property of an option // Accessing the parent's selectedIndex property fixes it if ( !jQuery.support.optSelected ) { jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, { get: function( elem ) { var parent = elem.parentNode; if ( parent ) { parent.selectedIndex; // Make sure that it also works with optgroups, see #5701 if ( parent.parentNode ) { parent.parentNode.selectedIndex; } } return null; } }); } // IE6/7 call enctype encoding if ( !jQuery.support.enctype ) { jQuery.propFix.enctype = "encoding"; } // Radios and checkboxes getter/setter if ( !jQuery.support.checkOn ) { jQuery.each([ "radio", "checkbox" ], function() { jQuery.valHooks[ this ] = { get: function( elem ) { // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified return elem.getAttribute("value") === null ? "on" : elem.value; } }; }); } jQuery.each([ "radio", "checkbox" ], function() { jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], { set: function( elem, value ) { if ( jQuery.isArray( value ) ) { return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 ); } } }); }); var rformElems = /^(?:textarea|input|select)$/i, rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/, rhoverHack = /(?:^|\s)hover(\.\S+)?\b/, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|contextmenu)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/, quickParse = function( selector ) { var quick = rquickIs.exec( selector ); if ( quick ) { // 0 1 2 3 // [ _, tag, id, class ] quick[1] = ( quick[1] || "" ).toLowerCase(); quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" ); } return quick; }, quickIs = function( elem, m ) { var attrs = elem.attributes || {}; return ( (!m[1] || elem.nodeName.toLowerCase() === m[1]) && (!m[2] || (attrs.id || {}).value === m[2]) && (!m[3] || m[3].test( (attrs[ "class" ] || {}).value )) ); }, hoverHack = function( events ) { return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); }; /* * Helper functions for managing events -- not part of the public interface. * Props to Dean Edwards' addEvent library for many of the ideas. */ jQuery.event = { add: function( elem, types, handler, data, selector ) { var elemData, eventHandle, events, t, tns, type, namespaces, handleObj, handleObjIn, quick, handlers, special; // Don't attach events to noData or text/comment nodes (allow plain objects tho) if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) { return; } // Caller can pass in an object of custom data in lieu of the handler if ( handler.handler ) { handleObjIn = handler; handler = handleObjIn.handler; selector = handleObjIn.selector; } // Make sure that the handler has a unique ID, used to find/remove it later if ( !handler.guid ) { handler.guid = jQuery.guid++; } // Init the element's event structure and main handler, if this is the first events = elemData.events; if ( !events ) { elemData.events = events = {}; } eventHandle = elemData.handle; if ( !eventHandle ) { elemData.handle = eventHandle = function( e ) { // Discard the second event of a jQuery.event.trigger() and // when an event is called after a page has unloaded return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : undefined; }; // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events eventHandle.elem = elem; } // Handle multiple events separated by a space // jQuery(...).bind("mouseover mouseout", fn); types = jQuery.trim( hoverHack(types) ).split( " " ); for ( t = 0; t < types.length; t++ ) { tns = rtypenamespace.exec( types[t] ) || []; type = tns[1]; namespaces = ( tns[2] || "" ).split( "." ).sort(); // If event changes its type, use the special event handlers for the changed type special = jQuery.event.special[ type ] || {}; // If selector defined, determine special event api type, otherwise given type type = ( selector ? special.delegateType : special.bindType ) || type; // Update special based on newly reset type special = jQuery.event.special[ type ] || {}; // handleObj is passed to all event handlers handleObj = jQuery.extend({ type: type, origType: tns[1], data: data, handler: handler, guid: handler.guid, selector: selector, quick: selector && quickParse( selector ), namespace: namespaces.join(".") }, handleObjIn ); // Init the event handler queue if we're the first handlers = events[ type ]; if ( !handlers ) { handlers = events[ type ] = []; handlers.delegateCount = 0; // Only use addEventListener/attachEvent if the special events handler returns false if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { // Bind the global event handler to the element if ( elem.addEventListener ) { elem.addEventListener( type, eventHandle, false ); } else if ( elem.attachEvent ) { elem.attachEvent( "on" + type, eventHandle ); } } } if ( special.add ) { special.add.call( elem, handleObj ); if ( !handleObj.handler.guid ) { handleObj.handler.guid = handler.guid; } } // Add to the element's handler list, delegates in front if ( selector ) { handlers.splice( handlers.delegateCount++, 0, handleObj ); } else { handlers.push( handleObj ); } // Keep track of which events have ever been used, for event optimization jQuery.event.global[ type ] = true; } // Nullify elem to prevent memory leaks in IE elem = null; }, global: {}, // Detach an event or set of events from an element remove: function( elem, types, handler, selector, mappedTypes ) { var elemData = jQuery.hasData( elem ) && jQuery._data( elem ), t, tns, type, origType, namespaces, origCount, j, events, special, handle, eventType, handleObj; if ( !elemData || !(events = elemData.events) ) { return; } // Once for each type.namespace in types; type may be omitted types = jQuery.trim( hoverHack( types || "" ) ).split(" "); for ( t = 0; t < types.length; t++ ) { tns = rtypenamespace.exec( types[t] ) || []; type = origType = tns[1]; namespaces = tns[2]; // Unbind all events (on this namespace, if provided) for the element if ( !type ) { for ( type in events ) { jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); } continue; } special = jQuery.event.special[ type ] || {}; type = ( selector? special.delegateType : special.bindType ) || type; eventType = events[ type ] || []; origCount = eventType.length; namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null; // Remove matching events for ( j = 0; j < eventType.length; j++ ) { handleObj = eventType[ j ]; if ( ( mappedTypes || origType === handleObj.origType ) && ( !handler || handler.guid === handleObj.guid ) && ( !namespaces || namespaces.test( handleObj.namespace ) ) && ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { eventType.splice( j--, 1 ); if ( handleObj.selector ) { eventType.delegateCount--; } if ( special.remove ) { special.remove.call( elem, handleObj ); } } } // Remove generic event handler if we removed something and no more handlers exist // (avoids potential for endless recursion during removal of special event handlers) if ( eventType.length === 0 && origCount !== eventType.length ) { if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { jQuery.removeEvent( elem, type, elemData.handle ); } delete events[ type ]; } } // Remove the expando if it's no longer used if ( jQuery.isEmptyObject( events ) ) { handle = elemData.handle; if ( handle ) { handle.elem = null; } // removeData also checks for emptiness and clears the expando if empty // so use it instead of delete jQuery.removeData( elem, [ "events", "handle" ], true ); } }, // Events that are safe to short-circuit if no handlers are attached. // Native DOM events should not be added, they may have inline handlers. customEvent: { "getData": true, "setData": true, "changeData": true }, trigger: function( event, data, elem, onlyHandlers ) { // Don't do events on text and comment nodes if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) { return; } // Event object or event type var type = event.type || event, namespaces = [], cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType; // focus/blur morphs to focusin/out; ensure we're not firing them right now if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { return; } if ( type.indexOf( "!" ) >= 0 ) { // Exclusive events trigger only for the exact event (no namespaces) type = type.slice(0, -1); exclusive = true; } if ( type.indexOf( "." ) >= 0 ) { // Namespaced trigger; create a regexp to match event type in handle() namespaces = type.split("."); type = namespaces.shift(); namespaces.sort(); } if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) { // No jQuery handlers for this event type, and it can't have inline handlers return; } // Caller can pass in an Event, Object, or just an event type string event = typeof event === "object" ? // jQuery.Event object event[ jQuery.expando ] ? event : // Object literal new jQuery.Event( type, event ) : // Just the event type (string) new jQuery.Event( type ); event.type = type; event.isTrigger = true; event.exclusive = exclusive; event.namespace = namespaces.join( "." ); event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null; ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; // Handle a global trigger if ( !elem ) { // TODO: Stop taunting the data cache; remove global events and always attach to document cache = jQuery.cache; for ( i in cache ) { if ( cache[ i ].events && cache[ i ].events[ type ] ) { jQuery.event.trigger( event, data, cache[ i ].handle.elem, true ); } } return; } // Clean up the event in case it is being reused event.result = undefined; if ( !event.target ) { event.target = elem; } // Clone any incoming data and prepend the event, creating the handler arg list data = data != null ? jQuery.makeArray( data ) : []; data.unshift( event ); // Allow special events to draw outside the lines special = jQuery.event.special[ type ] || {}; if ( special.trigger && special.trigger.apply( elem, data ) === false ) { return; } // Determine event propagation path in advance, per W3C events spec (#9951) // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) eventPath = [[ elem, special.bindType || type ]]; if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { bubbleType = special.delegateType || type; cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; old = null; for ( ; cur; cur = cur.parentNode ) { eventPath.push([ cur, bubbleType ]); old = cur; } // Only add window if we got to document (e.g., not plain obj or detached DOM) if ( old && old === elem.ownerDocument ) { eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); } } // Fire handlers on the event path for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) { cur = eventPath[i][0]; event.type = eventPath[i][1]; handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); if ( handle ) { handle.apply( cur, data ); } // Note that this is a bare JS function and not a jQuery handler handle = ontype && cur[ ontype ]; if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) { event.preventDefault(); } } event.type = type; // If nobody prevented the default action, do it now if ( !onlyHandlers && !event.isDefaultPrevented() ) { if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { // Call a native DOM method on the target with the same name name as the event. // Can't use an .isFunction() check here because IE6/7 fails that test. // Don't do default actions on window, that's where global variables be (#6170) // IE<9 dies on focus/blur to hidden element (#1486) if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) { // Don't re-trigger an onFOO event when we call its FOO() method old = elem[ ontype ]; if ( old ) { elem[ ontype ] = null; } // Prevent re-triggering of the same event, since we already bubbled it above jQuery.event.triggered = type; elem[ type ](); jQuery.event.triggered = undefined; if ( old ) { elem[ ontype ] = old; } } } } return event.result; }, dispatch: function( event ) { // Make a writable jQuery.Event from the native event object event = jQuery.event.fix( event || window.event ); var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), delegateCount = handlers.delegateCount, args = [].slice.call( arguments, 0 ), run_all = !event.exclusive && !event.namespace, special = jQuery.event.special[ event.type ] || {}, handlerQueue = [], i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related; // Use the fix-ed jQuery.Event rather than the (read-only) native event args[0] = event; event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { return; } // Determine handlers that should run if there are delegated events // Avoid non-left-click bubbling in Firefox (#3861) if ( delegateCount && !(event.button && event.type === "click") ) { // Pregenerate a single jQuery object for reuse with .is() jqcur = jQuery(this); jqcur.context = this.ownerDocument || this; for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { // Don't process events on disabled elements (#6911, #8165) if ( cur.disabled !== true ) { selMatch = {}; matches = []; jqcur[0] = cur; for ( i = 0; i < delegateCount; i++ ) { handleObj = handlers[ i ]; sel = handleObj.selector; if ( selMatch[ sel ] === undefined ) { selMatch[ sel ] = ( handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel ) ); } if ( selMatch[ sel ] ) { matches.push( handleObj ); } } if ( matches.length ) { handlerQueue.push({ elem: cur, matches: matches }); } } } } // Add the remaining (directly-bound) handlers if ( handlers.length > delegateCount ) { handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) }); } // Run delegates first; they may want to stop propagation beneath us for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) { matched = handlerQueue[ i ]; event.currentTarget = matched.elem; for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) { handleObj = matched.matches[ j ]; // Triggered event must either 1) be non-exclusive and have no namespace, or // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) { event.data = handleObj.data; event.handleObj = handleObj; ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) .apply( matched.elem, args ); if ( ret !== undefined ) { event.result = ret; if ( ret === false ) { event.preventDefault(); event.stopPropagation(); } } } } } // Call the postDispatch hook for the mapped type if ( special.postDispatch ) { special.postDispatch.call( this, event ); } return event.result; }, // Includes some event props shared by KeyEvent and MouseEvent // *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 *** props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), fixHooks: {}, keyHooks: { props: "char charCode key keyCode".split(" "), filter: function( event, original ) { // Add which for key events if ( event.which == null ) { event.which = original.charCode != null ? original.charCode : original.keyCode; } return event; } }, mouseHooks: { props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), filter: function( event, original ) { var eventDoc, doc, body, button = original.button, fromElement = original.fromElement; // Calculate pageX/Y if missing and clientX/Y available if ( event.pageX == null && original.clientX != null ) { eventDoc = event.target.ownerDocument || document; doc = eventDoc.documentElement; body = eventDoc.body; event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); } // Add relatedTarget, if necessary if ( !event.relatedTarget && fromElement ) { event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; } // Add which for click: 1 === left; 2 === middle; 3 === right // Note: button is not normalized, so don't use it if ( !event.which && button !== undefined ) { event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) ); } return event; } }, fix: function( event ) { if ( event[ jQuery.expando ] ) { return event; } // Create a writable copy of the event object and normalize some properties var i, prop, originalEvent = event, fixHook = jQuery.event.fixHooks[ event.type ] || {}, copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; event = jQuery.Event( originalEvent ); for ( i = copy.length; i; ) { prop = copy[ --i ]; event[ prop ] = originalEvent[ prop ]; } // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2) if ( !event.target ) { event.target = originalEvent.srcElement || document; } // Target should not be a text node (#504, Safari) if ( event.target.nodeType === 3 ) { event.target = event.target.parentNode; } // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8) if ( event.metaKey === undefined ) { event.metaKey = event.ctrlKey; } return fixHook.filter? fixHook.filter( event, originalEvent ) : event; }, special: { ready: { // Make sure the ready event is setup setup: jQuery.bindReady }, load: { // Prevent triggered image.load events from bubbling to window.load noBubble: true }, focus: { delegateType: "focusin" }, blur: { delegateType: "focusout" }, beforeunload: { setup: function( data, namespaces, eventHandle ) { // We only want to do this special case on windows if ( jQuery.isWindow( this ) ) { this.onbeforeunload = eventHandle; } }, teardown: function( namespaces, eventHandle ) { if ( this.onbeforeunload === eventHandle ) { this.onbeforeunload = null; } } } }, simulate: function( type, elem, event, bubble ) { // Piggyback on a donor event to simulate a different one. // Fake originalEvent to avoid donor's stopPropagation, but if the // simulated event prevents default then we do the same on the donor. var e = jQuery.extend( new jQuery.Event(), event, { type: type, isSimulated: true, originalEvent: {} } ); if ( bubble ) { jQuery.event.trigger( e, null, elem ); } else { jQuery.event.dispatch.call( elem, e ); } if ( e.isDefaultPrevented() ) { event.preventDefault(); } } }; // Some plugins are using, but it's undocumented/deprecated and will be removed. // The 1.7 special event interface should provide all the hooks needed now. jQuery.event.handle = jQuery.event.dispatch; jQuery.removeEvent = document.removeEventListener ? function( elem, type, handle ) { if ( elem.removeEventListener ) { elem.removeEventListener( type, handle, false ); } } : function( elem, type, handle ) { if ( elem.detachEvent ) { elem.detachEvent( "on" + type, handle ); } }; jQuery.Event = function( src, props ) { // Allow instantiation without the 'new' keyword if ( !(this instanceof jQuery.Event) ) { return new jQuery.Event( src, props ); } // Event object if ( src && src.type ) { this.originalEvent = src; this.type = src.type; // Events bubbling up the document may have been marked as prevented // by a handler lower down the tree; reflect the correct value. this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false || src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse; // Event type } else { this.type = src; } // Put explicitly provided properties onto the event object if ( props ) { jQuery.extend( this, props ); } // Create a timestamp if incoming event doesn't have one this.timeStamp = src && src.timeStamp || jQuery.now(); // Mark it as fixed this[ jQuery.expando ] = true; }; function returnFalse() { return false; } function returnTrue() { return true; } // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html jQuery.Event.prototype = { preventDefault: function() { this.isDefaultPrevented = returnTrue; var e = this.originalEvent; if ( !e ) { return; } // if preventDefault exists run it on the original event if ( e.preventDefault ) { e.preventDefault(); // otherwise set the returnValue property of the original event to false (IE) } else { e.returnValue = false; } }, stopPropagation: function() { this.isPropagationStopped = returnTrue; var e = this.originalEvent; if ( !e ) { return; } // if stopPropagation exists run it on the original event if ( e.stopPropagation ) { e.stopPropagation(); } // otherwise set the cancelBubble property of the original event to true (IE) e.cancelBubble = true; }, stopImmediatePropagation: function() { this.isImmediatePropagationStopped = returnTrue; this.stopPropagation(); }, isDefaultPrevented: returnFalse, isPropagationStopped: returnFalse, isImmediatePropagationStopped: returnFalse }; // Create mouseenter/leave events using mouseover/out and event-time checks jQuery.each({ mouseenter: "mouseover", mouseleave: "mouseout" }, function( orig, fix ) { jQuery.event.special[ orig ] = { delegateType: fix, bindType: fix, handle: function( event ) { var target = this, related = event.relatedTarget, handleObj = event.handleObj, selector = handleObj.selector, ret; // For mousenter/leave call the handler if related is outside the target. // NB: No relatedTarget if the mouse left/entered the browser window if ( !related || (related !== target && !jQuery.contains( target, related )) ) { event.type = handleObj.origType; ret = handleObj.handler.apply( this, arguments ); event.type = fix; } return ret; } }; }); // IE submit delegation if ( !jQuery.support.submitBubbles ) { jQuery.event.special.submit = { setup: function() { // Only need this for delegated form submit events if ( jQuery.nodeName( this, "form" ) ) { return false; } // Lazy-add a submit handler when a descendant form may potentially be submitted jQuery.event.add( this, "click._submit keypress._submit", function( e ) { // Node name check avoids a VML-related crash in IE (#9807) var elem = e.target, form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; if ( form && !form._submit_attached ) { jQuery.event.add( form, "submit._submit", function( event ) { event._submit_bubble = true; }); form._submit_attached = true; } }); // return undefined since we don't need an event listener }, postDispatch: function( event ) { // If form was submitted by the user, bubble the event up the tree if ( event._submit_bubble ) { delete event._submit_bubble; if ( this.parentNode && !event.isTrigger ) { jQuery.event.simulate( "submit", this.parentNode, event, true ); } } }, teardown: function() { // Only need this for delegated form submit events if ( jQuery.nodeName( this, "form" ) ) { return false; } // Remove delegated handlers; cleanData eventually reaps submit handlers attached above jQuery.event.remove( this, "._submit" ); } }; } // IE change delegation and checkbox/radio fix if ( !jQuery.support.changeBubbles ) { jQuery.event.special.change = { setup: function() { if ( rformElems.test( this.nodeName ) ) { // IE doesn't fire change on a check/radio until blur; trigger it on click // after a propertychange. Eat the blur-change in special.change.handle. // This still fires onchange a second time for check/radio after blur. if ( this.type === "checkbox" || this.type === "radio" ) { jQuery.event.add( this, "propertychange._change", function( event ) { if ( event.originalEvent.propertyName === "checked" ) { this._just_changed = true; } }); jQuery.event.add( this, "click._change", function( event ) { if ( this._just_changed && !event.isTrigger ) { this._just_changed = false; jQuery.event.simulate( "change", this, event, true ); } }); } return false; } // Delegated event; lazy-add a change handler on descendant inputs jQuery.event.add( this, "beforeactivate._change", function( e ) { var elem = e.target; if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) { jQuery.event.add( elem, "change._change", function( event ) { if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { jQuery.event.simulate( "change", this.parentNode, event, true ); } }); elem._change_attached = true; } }); }, handle: function( event ) { var elem = event.target; // Swallow native change events from checkbox/radio, we already triggered them above if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) { return event.handleObj.handler.apply( this, arguments ); } }, teardown: function() { jQuery.event.remove( this, "._change" ); return rformElems.test( this.nodeName ); } }; } // Create "bubbling" focus and blur events if ( !jQuery.support.focusinBubbles ) { jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { // Attach a single capturing handler while someone wants focusin/focusout var attaches = 0, handler = function( event ) { jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true ); }; jQuery.event.special[ fix ] = { setup: function() { if ( attaches++ === 0 ) { document.addEventListener( orig, handler, true ); } }, teardown: function() { if ( --attaches === 0 ) { document.removeEventListener( orig, handler, true ); } } }; }); } jQuery.fn.extend({ on: function( types, selector, data, fn, /*INTERNAL*/ one ) { var origFn, type; // Types can be a map of types/handlers if ( typeof types === "object" ) { // ( types-Object, selector, data ) if ( typeof selector !== "string" ) { // && selector != null // ( types-Object, data ) data = data || selector; selector = undefined; } for ( type in types ) { this.on( type, selector, data, types[ type ], one ); } return this; } if ( data == null && fn == null ) { // ( types, fn ) fn = selector; data = selector = undefined; } else if ( fn == null ) { if ( typeof selector === "string" ) { // ( types, selector, fn ) fn = data; data = undefined; } else { // ( types, data, fn ) fn = data; data = selector; selector = undefined; } } if ( fn === false ) { fn = returnFalse; } else if ( !fn ) { return this; } if ( one === 1 ) { origFn = fn; fn = function( event ) { // Can use an empty set, since event contains the info jQuery().off( event ); return origFn.apply( this, arguments ); }; // Use same guid so caller can remove using origFn fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); } return this.each( function() { jQuery.event.add( this, types, fn, data, selector ); }); }, one: function( types, selector, data, fn ) { return this.on( types, selector, data, fn, 1 ); }, off: function( types, selector, fn ) { if ( types && types.preventDefault && types.handleObj ) { // ( event ) dispatched jQuery.Event var handleObj = types.handleObj; jQuery( types.delegateTarget ).off( handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler ); return this; } if ( typeof types === "object" ) { // ( types-object [, selector] ) for ( var type in types ) { this.off( type, selector, types[ type ] ); } return this; } if ( selector === false || typeof selector === "function" ) { // ( types [, fn] ) fn = selector; selector = undefined; } if ( fn === false ) { fn = returnFalse; } return this.each(function() { jQuery.event.remove( this, types, fn, selector ); }); }, bind: function( types, data, fn ) { return this.on( types, null, data, fn ); }, unbind: function( types, fn ) { return this.off( types, null, fn ); }, live: function( types, data, fn ) { jQuery( this.context ).on( types, this.selector, data, fn ); return this; }, die: function( types, fn ) { jQuery( this.context ).off( types, this.selector || "**", fn ); return this; }, delegate: function( selector, types, data, fn ) { return this.on( types, selector, data, fn ); }, undelegate: function( selector, types, fn ) { // ( namespace ) or ( selector, types [, fn] ) return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn ); }, trigger: function( type, data ) { return this.each(function() { jQuery.event.trigger( type, data, this ); }); }, triggerHandler: function( type, data ) { if ( this[0] ) { return jQuery.event.trigger( type, data, this[0], true ); } }, toggle: function( fn ) { // Save reference to arguments for access in closure var args = arguments, guid = fn.guid || jQuery.guid++, i = 0, toggler = function( event ) { // Figure out which function to execute var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); // Make sure that clicks stop event.preventDefault(); // and execute the function return args[ lastToggle ].apply( this, arguments ) || false; }; // link all the functions, so any of them can unbind this click handler toggler.guid = guid; while ( i < args.length ) { args[ i++ ].guid = guid; } return this.click( toggler ); }, hover: function( fnOver, fnOut ) { return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); } }); jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) { // Handle event binding jQuery.fn[ name ] = function( data, fn ) { if ( fn == null ) { fn = data; data = null; } return arguments.length > 0 ? this.on( name, null, data, fn ) : this.trigger( name ); }; if ( jQuery.attrFn ) { jQuery.attrFn[ name ] = true; } if ( rkeyEvent.test( name ) ) { jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks; } if ( rmouseEvent.test( name ) ) { jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks; } }); /*! * Sizzle CSS Selector Engine * Copyright 2011, The Dojo Foundation * Released under the MIT, BSD, and GPL Licenses. * More information: http://sizzlejs.com/ */ (function(){ var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, expando = "sizcache" + (Math.random() + '').replace('.', ''), done = 0, toString = Object.prototype.toString, hasDuplicate = false, baseHasDuplicate = true, rBackslash = /\\/g, rReturn = /\r\n/g, rNonWord = /\W/; // Here we check if the JavaScript engine is using some sort of // optimization where it does not always call our comparision // function. If that is the case, discard the hasDuplicate value. // Thus far that includes Google Chrome. [0, 0].sort(function() { baseHasDuplicate = false; return 0; }); var Sizzle = function( selector, context, results, seed ) { results = results || []; context = context || document; var origContext = context; if ( context.nodeType !== 1 && context.nodeType !== 9 ) { return []; } if ( !selector || typeof selector !== "string" ) { return results; } var m, set, checkSet, extra, ret, cur, pop, i, prune = true, contextXML = Sizzle.isXML( context ), parts = [], soFar = selector; // Reset the position of the chunker regexp (start from head) do { chunker.exec( "" ); m = chunker.exec( soFar ); if ( m ) { soFar = m[3]; parts.push( m[1] ); if ( m[2] ) { extra = m[3]; break; } } } while ( m ); if ( parts.length > 1 && origPOS.exec( selector ) ) { if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { set = posProcess( parts[0] + parts[1], context, seed ); } else { set = Expr.relative[ parts[0] ] ? [ context ] : Sizzle( parts.shift(), context ); while ( parts.length ) { selector = parts.shift(); if ( Expr.relative[ selector ] ) { selector += parts.shift(); } set = posProcess( selector, set, seed ); } } } else { // Take a shortcut and set the context if the root selector is an ID // (but not if it'll be faster if the inner selector is an ID) if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML && Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) { ret = Sizzle.find( parts.shift(), context, contextXML ); context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0]; } if ( context ) { ret = seed ? { expr: parts.pop(), set: makeArray(seed) } : Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML ); set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set; if ( parts.length > 0 ) { checkSet = makeArray( set ); } else { prune = false; } while ( parts.length ) { cur = parts.pop(); pop = cur; if ( !Expr.relative[ cur ] ) { cur = ""; } else { pop = parts.pop(); } if ( pop == null ) { pop = context; } Expr.relative[ cur ]( checkSet, pop, contextXML ); } } else { checkSet = parts = []; } } if ( !checkSet ) { checkSet = set; } if ( !checkSet ) { Sizzle.error( cur || selector ); } if ( toString.call(checkSet) === "[object Array]" ) { if ( !prune ) { results.push.apply( results, checkSet ); } else if ( context && context.nodeType === 1 ) { for ( i = 0; checkSet[i] != null; i++ ) { if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) { results.push( set[i] ); } } } else { for ( i = 0; checkSet[i] != null; i++ ) { if ( checkSet[i] && checkSet[i].nodeType === 1 ) { results.push( set[i] ); } } } } else { makeArray( checkSet, results ); } if ( extra ) { Sizzle( extra, origContext, results, seed ); Sizzle.uniqueSort( results ); } return results; }; Sizzle.uniqueSort = function( results ) { if ( sortOrder ) { hasDuplicate = baseHasDuplicate; results.sort( sortOrder ); if ( hasDuplicate ) { for ( var i = 1; i < results.length; i++ ) { if ( results[i] === results[ i - 1 ] ) { results.splice( i--, 1 ); } } } } return results; }; Sizzle.matches = function( expr, set ) { return Sizzle( expr, null, null, set ); }; Sizzle.matchesSelector = function( node, expr ) { return Sizzle( expr, null, null, [node] ).length > 0; }; Sizzle.find = function( expr, context, isXML ) { var set, i, len, match, type, left; if ( !expr ) { return []; } for ( i = 0, len = Expr.order.length; i < len; i++ ) { type = Expr.order[i]; if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { left = match[1]; match.splice( 1, 1 ); if ( left.substr( left.length - 1 ) !== "\\" ) { match[1] = (match[1] || "").replace( rBackslash, "" ); set = Expr.find[ type ]( match, context, isXML ); if ( set != null ) { expr = expr.replace( Expr.match[ type ], "" ); break; } } } } if ( !set ) { set = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName( "*" ) : []; } return { set: set, expr: expr }; }; Sizzle.filter = function( expr, set, inplace, not ) { var match, anyFound, type, found, item, filter, left, i, pass, old = expr, result = [], curLoop = set, isXMLFilter = set && set[0] && Sizzle.isXML( set[0] ); while ( expr && set.length ) { for ( type in Expr.filter ) { if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) { filter = Expr.filter[ type ]; left = match[1]; anyFound = false; match.splice(1,1); if ( left.substr( left.length - 1 ) === "\\" ) { continue; } if ( curLoop === result ) { result = []; } if ( Expr.preFilter[ type ] ) { match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter ); if ( !match ) { anyFound = found = true; } else if ( match === true ) { continue; } } if ( match ) { for ( i = 0; (item = curLoop[i]) != null; i++ ) { if ( item ) { found = filter( item, match, i, curLoop ); pass = not ^ found; if ( inplace && found != null ) { if ( pass ) { anyFound = true; } else { curLoop[i] = false; } } else if ( pass ) { result.push( item ); anyFound = true; } } } } if ( found !== undefined ) { if ( !inplace ) { curLoop = result; } expr = expr.replace( Expr.match[ type ], "" ); if ( !anyFound ) { return []; } break; } } } // Improper expression if ( expr === old ) { if ( anyFound == null ) { Sizzle.error( expr ); } else { break; } } old = expr; } return curLoop; }; Sizzle.error = function( msg ) { throw new Error( "Syntax error, unrecognized expression: " + msg ); }; /** * Utility function for retreiving the text value of an array of DOM nodes * @param {Array|Element} elem */ var getText = Sizzle.getText = function( elem ) { var i, node, nodeType = elem.nodeType, ret = ""; if ( nodeType ) { if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { // Use textContent || innerText for elements if ( typeof elem.textContent === 'string' ) { return elem.textContent; } else if ( typeof elem.innerText === 'string' ) { // Replace IE's carriage returns return elem.innerText.replace( rReturn, '' ); } else { // Traverse it's children for ( elem = elem.firstChild; elem; elem = elem.nextSibling) { ret += getText( elem ); } } } else if ( nodeType === 3 || nodeType === 4 ) { return elem.nodeValue; } } else { // If no nodeType, this is expected to be an array for ( i = 0; (node = elem[i]); i++ ) { // Do not traverse comment nodes if ( node.nodeType !== 8 ) { ret += getText( node ); } } } return ret; }; var Expr = Sizzle.selectors = { order: [ "ID", "NAME", "TAG" ], match: { ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/, ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/, TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/, CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/, POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/, PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/ }, leftMatch: {}, attrMap: { "class": "className", "for": "htmlFor" }, attrHandle: { href: function( elem ) { return elem.getAttribute( "href" ); }, type: function( elem ) { return elem.getAttribute( "type" ); } }, relative: { "+": function(checkSet, part){ var isPartStr = typeof part === "string", isTag = isPartStr && !rNonWord.test( part ), isPartStrNotTag = isPartStr && !isTag; if ( isTag ) { part = part.toLowerCase(); } for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { if ( (elem = checkSet[i]) ) { while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ? elem || false : elem === part; } } if ( isPartStrNotTag ) { Sizzle.filter( part, checkSet, true ); } }, ">": function( checkSet, part ) { var elem, isPartStr = typeof part === "string", i = 0, l = checkSet.length; if ( isPartStr && !rNonWord.test( part ) ) { part = part.toLowerCase(); for ( ; i < l; i++ ) { elem = checkSet[i]; if ( elem ) { var parent = elem.parentNode; checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false; } } } else { for ( ; i < l; i++ ) { elem = checkSet[i]; if ( elem ) { checkSet[i] = isPartStr ? elem.parentNode : elem.parentNode === part; } } if ( isPartStr ) { Sizzle.filter( part, checkSet, true ); } } }, "": function(checkSet, part, isXML){ var nodeCheck, doneName = done++, checkFn = dirCheck; if ( typeof part === "string" && !rNonWord.test( part ) ) { part = part.toLowerCase(); nodeCheck = part; checkFn = dirNodeCheck; } checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML ); }, "~": function( checkSet, part, isXML ) { var nodeCheck, doneName = done++, checkFn = dirCheck; if ( typeof part === "string" && !rNonWord.test( part ) ) { part = part.toLowerCase(); nodeCheck = part; checkFn = dirNodeCheck; } checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML ); } }, find: { ID: function( match, context, isXML ) { if ( typeof context.getElementById !== "undefined" && !isXML ) { var m = context.getElementById(match[1]); // Check parentNode to catch when Blackberry 4.6 returns // nodes that are no longer in the document #6963 return m && m.parentNode ? [m] : []; } }, NAME: function( match, context ) { if ( typeof context.getElementsByName !== "undefined" ) { var ret = [], results = context.getElementsByName( match[1] ); for ( var i = 0, l = results.length; i < l; i++ ) { if ( results[i].getAttribute("name") === match[1] ) { ret.push( results[i] ); } } return ret.length === 0 ? null : ret; } }, TAG: function( match, context ) { if ( typeof context.getElementsByTagName !== "undefined" ) { return context.getElementsByTagName( match[1] ); } } }, preFilter: { CLASS: function( match, curLoop, inplace, result, not, isXML ) { match = " " + match[1].replace( rBackslash, "" ) + " "; if ( isXML ) { return match; } for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { if ( elem ) { if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) { if ( !inplace ) { result.push( elem ); } } else if ( inplace ) { curLoop[i] = false; } } } return false; }, ID: function( match ) { return match[1].replace( rBackslash, "" ); }, TAG: function( match, curLoop ) { return match[1].replace( rBackslash, "" ).toLowerCase(); }, CHILD: function( match ) { if ( match[1] === "nth" ) { if ( !match[2] ) { Sizzle.error( match[0] ); } match[2] = match[2].replace(/^\+|\s*/g, ''); // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6' var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec( match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" || !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]); // calculate the numbers (first)n+(last) including if they are negative match[2] = (test[1] + (test[2] || 1)) - 0; match[3] = test[3] - 0; } else if ( match[2] ) { Sizzle.error( match[0] ); } // TODO: Move to normal caching system match[0] = done++; return match; }, ATTR: function( match, curLoop, inplace, result, not, isXML ) { var name = match[1] = match[1].replace( rBackslash, "" ); if ( !isXML && Expr.attrMap[name] ) { match[1] = Expr.attrMap[name]; } // Handle if an un-quoted value was used match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" ); if ( match[2] === "~=" ) { match[4] = " " + match[4] + " "; } return match; }, PSEUDO: function( match, curLoop, inplace, result, not ) { if ( match[1] === "not" ) { // If we're dealing with a complex expression, or a simple one if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) { match[3] = Sizzle(match[3], null, null, curLoop); } else { var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); if ( !inplace ) { result.push.apply( result, ret ); } return false; } } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { return true; } return match; }, POS: function( match ) { match.unshift( true ); return match; } }, filters: { enabled: function( elem ) { return elem.disabled === false && elem.type !== "hidden"; }, disabled: function( elem ) { return elem.disabled === true; }, checked: function( elem ) { return elem.checked === true; }, selected: function( elem ) { // Accessing this property makes selected-by-default // options in Safari work properly if ( elem.parentNode ) { elem.parentNode.selectedIndex; } return elem.selected === true; }, parent: function( elem ) { return !!elem.firstChild; }, empty: function( elem ) { return !elem.firstChild; }, has: function( elem, i, match ) { return !!Sizzle( match[3], elem ).length; }, header: function( elem ) { return (/h\d/i).test( elem.nodeName ); }, text: function( elem ) { var attr = elem.getAttribute( "type" ), type = elem.type; // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) // use getAttribute instead to test this case return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null ); }, radio: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type; }, checkbox: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type; }, file: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "file" === elem.type; }, password: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "password" === elem.type; }, submit: function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && "submit" === elem.type; }, image: function( elem ) { return elem.nodeName.toLowerCase() === "input" && "image" === elem.type; }, reset: function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && "reset" === elem.type; }, button: function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && "button" === elem.type || name === "button"; }, input: function( elem ) { return (/input|select|textarea|button/i).test( elem.nodeName ); }, focus: function( elem ) { return elem === elem.ownerDocument.activeElement; } }, setFilters: { first: function( elem, i ) { return i === 0; }, last: function( elem, i, match, array ) { return i === array.length - 1; }, even: function( elem, i ) { return i % 2 === 0; }, odd: function( elem, i ) { return i % 2 === 1; }, lt: function( elem, i, match ) { return i < match[3] - 0; }, gt: function( elem, i, match ) { return i > match[3] - 0; }, nth: function( elem, i, match ) { return match[3] - 0 === i; }, eq: function( elem, i, match ) { return match[3] - 0 === i; } }, filter: { PSEUDO: function( elem, match, i, array ) { var name = match[1], filter = Expr.filters[ name ]; if ( filter ) { return filter( elem, i, match, array ); } else if ( name === "contains" ) { return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0; } else if ( name === "not" ) { var not = match[3]; for ( var j = 0, l = not.length; j < l; j++ ) { if ( not[j] === elem ) { return false; } } return true; } else { Sizzle.error( name ); } }, CHILD: function( elem, match ) { var first, last, doneName, parent, cache, count, diff, type = match[1], node = elem; switch ( type ) { case "only": case "first": while ( (node = node.previousSibling) ) { if ( node.nodeType === 1 ) { return false; } } if ( type === "first" ) { return true; } node = elem; /* falls through */ case "last": while ( (node = node.nextSibling) ) { if ( node.nodeType === 1 ) { return false; } } return true; case "nth": first = match[2]; last = match[3]; if ( first === 1 && last === 0 ) { return true; } doneName = match[0]; parent = elem.parentNode; if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) { count = 0; for ( node = parent.firstChild; node; node = node.nextSibling ) { if ( node.nodeType === 1 ) { node.nodeIndex = ++count; } } parent[ expando ] = doneName; } diff = elem.nodeIndex - last; if ( first === 0 ) { return diff === 0; } else { return ( diff % first === 0 && diff / first >= 0 ); } } }, ID: function( elem, match ) { return elem.nodeType === 1 && elem.getAttribute("id") === match; }, TAG: function( elem, match ) { return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match; }, CLASS: function( elem, match ) { return (" " + (elem.className || elem.getAttribute("class")) + " ") .indexOf( match ) > -1; }, ATTR: function( elem, match ) { var name = match[1], result = Sizzle.attr ? Sizzle.attr( elem, name ) : Expr.attrHandle[ name ] ? Expr.attrHandle[ name ]( elem ) : elem[ name ] != null ? elem[ name ] : elem.getAttribute( name ), value = result + "", type = match[2], check = match[4]; return result == null ? type === "!=" : !type && Sizzle.attr ? result != null : type === "=" ? value === check : type === "*=" ? value.indexOf(check) >= 0 : type === "~=" ? (" " + value + " ").indexOf(check) >= 0 : !check ? value && result !== false : type === "!=" ? value !== check : type === "^=" ? value.indexOf(check) === 0 : type === "$=" ? value.substr(value.length - check.length) === check : type === "|=" ? value === check || value.substr(0, check.length + 1) === check + "-" : false; }, POS: function( elem, match, i, array ) { var name = match[2], filter = Expr.setFilters[ name ]; if ( filter ) { return filter( elem, i, match, array ); } } } }; var origPOS = Expr.match.POS, fescape = function(all, num){ return "\\" + (num - 0 + 1); }; for ( var type in Expr.match ) { Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) ); Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) ); } // Expose origPOS // "global" as in regardless of relation to brackets/parens Expr.match.globalPOS = origPOS; var makeArray = function( array, results ) { array = Array.prototype.slice.call( array, 0 ); if ( results ) { results.push.apply( results, array ); return results; } return array; }; // Perform a simple check to determine if the browser is capable of // converting a NodeList to an array using builtin methods. // Also verifies that the returned array holds DOM nodes // (which is not the case in the Blackberry browser) try { Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType; // Provide a fallback method if it does not work } catch( e ) { makeArray = function( array, results ) { var i = 0, ret = results || []; if ( toString.call(array) === "[object Array]" ) { Array.prototype.push.apply( ret, array ); } else { if ( typeof array.length === "number" ) { for ( var l = array.length; i < l; i++ ) { ret.push( array[i] ); } } else { for ( ; array[i]; i++ ) { ret.push( array[i] ); } } } return ret; }; } var sortOrder, siblingCheck; if ( document.documentElement.compareDocumentPosition ) { sortOrder = function( a, b ) { if ( a === b ) { hasDuplicate = true; return 0; } if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) { return a.compareDocumentPosition ? -1 : 1; } return a.compareDocumentPosition(b) & 4 ? -1 : 1; }; } else { sortOrder = function( a, b ) { // The nodes are identical, we can exit early if ( a === b ) { hasDuplicate = true; return 0; // Fallback to using sourceIndex (in IE) if it's available on both nodes } else if ( a.sourceIndex && b.sourceIndex ) { return a.sourceIndex - b.sourceIndex; } var al, bl, ap = [], bp = [], aup = a.parentNode, bup = b.parentNode, cur = aup; // If the nodes are siblings (or identical) we can do a quick check if ( aup === bup ) { return siblingCheck( a, b ); // If no parents were found then the nodes are disconnected } else if ( !aup ) { return -1; } else if ( !bup ) { return 1; } // Otherwise they're somewhere else in the tree so we need // to build up a full list of the parentNodes for comparison while ( cur ) { ap.unshift( cur ); cur = cur.parentNode; } cur = bup; while ( cur ) { bp.unshift( cur ); cur = cur.parentNode; } al = ap.length; bl = bp.length; // Start walking down the tree looking for a discrepancy for ( var i = 0; i < al && i < bl; i++ ) { if ( ap[i] !== bp[i] ) { return siblingCheck( ap[i], bp[i] ); } } // We ended someplace up the tree so do a sibling check return i === al ? siblingCheck( a, bp[i], -1 ) : siblingCheck( ap[i], b, 1 ); }; siblingCheck = function( a, b, ret ) { if ( a === b ) { return ret; } var cur = a.nextSibling; while ( cur ) { if ( cur === b ) { return -1; } cur = cur.nextSibling; } return 1; }; } // Check to see if the browser returns elements by name when // querying by getElementById (and provide a workaround) (function(){ // We're going to inject a fake input element with a specified name var form = document.createElement("div"), id = "script" + (new Date()).getTime(), root = document.documentElement; form.innerHTML = ""; // Inject it into the root element, check its status, and remove it quickly root.insertBefore( form, root.firstChild ); // The workaround has to do additional checks after a getElementById // Which slows things down for other browsers (hence the branching) if ( document.getElementById( id ) ) { Expr.find.ID = function( match, context, isXML ) { if ( typeof context.getElementById !== "undefined" && !isXML ) { var m = context.getElementById(match[1]); return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : []; } }; Expr.filter.ID = function( elem, match ) { var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); return elem.nodeType === 1 && node && node.nodeValue === match; }; } root.removeChild( form ); // release memory in IE root = form = null; })(); (function(){ // Check to see if the browser returns only elements // when doing getElementsByTagName("*") // Create a fake element var div = document.createElement("div"); div.appendChild( document.createComment("") ); // Make sure no comments are found if ( div.getElementsByTagName("*").length > 0 ) { Expr.find.TAG = function( match, context ) { var results = context.getElementsByTagName( match[1] ); // Filter out possible comments if ( match[1] === "*" ) { var tmp = []; for ( var i = 0; results[i]; i++ ) { if ( results[i].nodeType === 1 ) { tmp.push( results[i] ); } } results = tmp; } return results; }; } // Check to see if an attribute returns normalized href attributes div.innerHTML = ""; if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && div.firstChild.getAttribute("href") !== "#" ) { Expr.attrHandle.href = function( elem ) { return elem.getAttribute( "href", 2 ); }; } // release memory in IE div = null; })(); if ( document.querySelectorAll ) { (function(){ var oldSizzle = Sizzle, div = document.createElement("div"), id = "__sizzle__"; div.innerHTML = "

"; // Safari can't handle uppercase or unicode characters when // in quirks mode. if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) { return; } Sizzle = function( query, context, extra, seed ) { context = context || document; // Only use querySelectorAll on non-XML documents // (ID selectors don't work in non-HTML documents) if ( !seed && !Sizzle.isXML(context) ) { // See if we find a selector to speed up var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query ); if ( match && (context.nodeType === 1 || context.nodeType === 9) ) { // Speed-up: Sizzle("TAG") if ( match[1] ) { return makeArray( context.getElementsByTagName( query ), extra ); // Speed-up: Sizzle(".CLASS") } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) { return makeArray( context.getElementsByClassName( match[2] ), extra ); } } if ( context.nodeType === 9 ) { // Speed-up: Sizzle("body") // The body element only exists once, optimize finding it if ( query === "body" && context.body ) { return makeArray( [ context.body ], extra ); // Speed-up: Sizzle("#ID") } else if ( match && match[3] ) { var elem = context.getElementById( match[3] ); // Check parentNode to catch when Blackberry 4.6 returns // nodes that are no longer in the document #6963 if ( elem && elem.parentNode ) { // Handle the case where IE and Opera return items // by name instead of ID if ( elem.id === match[3] ) { return makeArray( [ elem ], extra ); } } else { return makeArray( [], extra ); } } try { return makeArray( context.querySelectorAll(query), extra ); } catch(qsaError) {} // qSA works strangely on Element-rooted queries // We can work around this by specifying an extra ID on the root // and working up from there (Thanks to Andrew Dupont for the technique) // IE 8 doesn't work on object elements } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { var oldContext = context, old = context.getAttribute( "id" ), nid = old || id, hasParent = context.parentNode, relativeHierarchySelector = /^\s*[+~]/.test( query ); if ( !old ) { context.setAttribute( "id", nid ); } else { nid = nid.replace( /'/g, "\\$&" ); } if ( relativeHierarchySelector && hasParent ) { context = context.parentNode; } try { if ( !relativeHierarchySelector || hasParent ) { return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra ); } } catch(pseudoError) { } finally { if ( !old ) { oldContext.removeAttribute( "id" ); } } } } return oldSizzle(query, context, extra, seed); }; for ( var prop in oldSizzle ) { Sizzle[ prop ] = oldSizzle[ prop ]; } // release memory in IE div = null; })(); } (function(){ var html = document.documentElement, matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector; if ( matches ) { // Check to see if it's possible to do matchesSelector // on a disconnected node (IE 9 fails this) var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ), pseudoWorks = false; try { // This should fail with an exception // Gecko does not error, returns false instead matches.call( document.documentElement, "[test!='']:sizzle" ); } catch( pseudoError ) { pseudoWorks = true; } Sizzle.matchesSelector = function( node, expr ) { // Make sure that attribute selectors are quoted expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']"); if ( !Sizzle.isXML( node ) ) { try { if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) { var ret = matches.call( node, expr ); // IE 9's matchesSelector returns false on disconnected nodes if ( ret || !disconnectedMatch || // As well, disconnected nodes are said to be in a document // fragment in IE 9, so check for that node.document && node.document.nodeType !== 11 ) { return ret; } } } catch(e) {} } return Sizzle(expr, null, null, [node]).length > 0; }; } })(); (function(){ var div = document.createElement("div"); div.innerHTML = "
"; // Opera can't find a second classname (in 9.6) // Also, make sure that getElementsByClassName actually exists if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) { return; } // Safari caches class attributes, doesn't catch changes (in 3.2) div.lastChild.className = "e"; if ( div.getElementsByClassName("e").length === 1 ) { return; } Expr.order.splice(1, 0, "CLASS"); Expr.find.CLASS = function( match, context, isXML ) { if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { return context.getElementsByClassName(match[1]); } }; // release memory in IE div = null; })(); function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { for ( var i = 0, l = checkSet.length; i < l; i++ ) { var elem = checkSet[i]; if ( elem ) { var match = false; elem = elem[dir]; while ( elem ) { if ( elem[ expando ] === doneName ) { match = checkSet[elem.sizset]; break; } if ( elem.nodeType === 1 && !isXML ){ elem[ expando ] = doneName; elem.sizset = i; } if ( elem.nodeName.toLowerCase() === cur ) { match = elem; break; } elem = elem[dir]; } checkSet[i] = match; } } } function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { for ( var i = 0, l = checkSet.length; i < l; i++ ) { var elem = checkSet[i]; if ( elem ) { var match = false; elem = elem[dir]; while ( elem ) { if ( elem[ expando ] === doneName ) { match = checkSet[elem.sizset]; break; } if ( elem.nodeType === 1 ) { if ( !isXML ) { elem[ expando ] = doneName; elem.sizset = i; } if ( typeof cur !== "string" ) { if ( elem === cur ) { match = true; break; } } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { match = elem; break; } } elem = elem[dir]; } checkSet[i] = match; } } } if ( document.documentElement.contains ) { Sizzle.contains = function( a, b ) { return a !== b && (a.contains ? a.contains(b) : true); }; } else if ( document.documentElement.compareDocumentPosition ) { Sizzle.contains = function( a, b ) { return !!(a.compareDocumentPosition(b) & 16); }; } else { Sizzle.contains = function() { return false; }; } Sizzle.isXML = function( elem ) { // documentElement is verified for cases where it doesn't yet exist // (such as loading iframes in IE - #4833) var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement; return documentElement ? documentElement.nodeName !== "HTML" : false; }; var posProcess = function( selector, context, seed ) { var match, tmpSet = [], later = "", root = context.nodeType ? [context] : context; // Position selectors must be done after the filter // And so must :not(positional) so we move all PSEUDOs to the end while ( (match = Expr.match.PSEUDO.exec( selector )) ) { later += match[0]; selector = selector.replace( Expr.match.PSEUDO, "" ); } selector = Expr.relative[selector] ? selector + "*" : selector; for ( var i = 0, l = root.length; i < l; i++ ) { Sizzle( selector, root[i], tmpSet, seed ); } return Sizzle.filter( later, tmpSet ); }; // EXPOSE // Override sizzle attribute retrieval Sizzle.attr = jQuery.attr; Sizzle.selectors.attrMap = {}; jQuery.find = Sizzle; jQuery.expr = Sizzle.selectors; jQuery.expr[":"] = jQuery.expr.filters; jQuery.unique = Sizzle.uniqueSort; jQuery.text = Sizzle.getText; jQuery.isXMLDoc = Sizzle.isXML; jQuery.contains = Sizzle.contains; })(); var runtil = /Until$/, rparentsprev = /^(?:parents|prevUntil|prevAll)/, // Note: This RegExp should be improved, or likely pulled from Sizzle rmultiselector = /,/, isSimple = /^.[^:#\[\.,]*$/, slice = Array.prototype.slice, POS = jQuery.expr.match.globalPOS, // methods guaranteed to produce a unique set when starting from a unique set guaranteedUnique = { children: true, contents: true, next: true, prev: true }; jQuery.fn.extend({ find: function( selector ) { var self = this, i, l; if ( typeof selector !== "string" ) { return jQuery( selector ).filter(function() { for ( i = 0, l = self.length; i < l; i++ ) { if ( jQuery.contains( self[ i ], this ) ) { return true; } } }); } var ret = this.pushStack( "", "find", selector ), length, n, r; for ( i = 0, l = this.length; i < l; i++ ) { length = ret.length; jQuery.find( selector, this[i], ret ); if ( i > 0 ) { // Make sure that the results are unique for ( n = length; n < ret.length; n++ ) { for ( r = 0; r < length; r++ ) { if ( ret[r] === ret[n] ) { ret.splice(n--, 1); break; } } } } } return ret; }, has: function( target ) { var targets = jQuery( target ); return this.filter(function() { for ( var i = 0, l = targets.length; i < l; i++ ) { if ( jQuery.contains( this, targets[i] ) ) { return true; } } }); }, not: function( selector ) { return this.pushStack( winnow(this, selector, false), "not", selector); }, filter: function( selector ) { return this.pushStack( winnow(this, selector, true), "filter", selector ); }, is: function( selector ) { return !!selector && ( typeof selector === "string" ? // If this is a positional selector, check membership in the returned set // so $("p:first").is("p:last") won't return true for a doc with two "p". POS.test( selector ) ? jQuery( selector, this.context ).index( this[0] ) >= 0 : jQuery.filter( selector, this ).length > 0 : this.filter( selector ).length > 0 ); }, closest: function( selectors, context ) { var ret = [], i, l, cur = this[0]; // Array (deprecated as of jQuery 1.7) if ( jQuery.isArray( selectors ) ) { var level = 1; while ( cur && cur.ownerDocument && cur !== context ) { for ( i = 0; i < selectors.length; i++ ) { if ( jQuery( cur ).is( selectors[ i ] ) ) { ret.push({ selector: selectors[ i ], elem: cur, level: level }); } } cur = cur.parentNode; level++; } return ret; } // String var pos = POS.test( selectors ) || typeof selectors !== "string" ? jQuery( selectors, context || this.context ) : 0; for ( i = 0, l = this.length; i < l; i++ ) { cur = this[i]; while ( cur ) { if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) { ret.push( cur ); break; } else { cur = cur.parentNode; if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) { break; } } } } ret = ret.length > 1 ? jQuery.unique( ret ) : ret; return this.pushStack( ret, "closest", selectors ); }, // Determine the position of an element within // the matched set of elements index: function( elem ) { // No argument, return index in parent if ( !elem ) { return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1; } // index in selector if ( typeof elem === "string" ) { return jQuery.inArray( this[0], jQuery( elem ) ); } // Locate the position of the desired element return jQuery.inArray( // If it receives a jQuery object, the first element is used elem.jquery ? elem[0] : elem, this ); }, add: function( selector, context ) { var set = typeof selector === "string" ? jQuery( selector, context ) : jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ), all = jQuery.merge( this.get(), set ); return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ? all : jQuery.unique( all ) ); }, andSelf: function() { return this.add( this.prevObject ); } }); // A painfully simple check to see if an element is disconnected // from a document (should be improved, where feasible). function isDisconnected( node ) { return !node || !node.parentNode || node.parentNode.nodeType === 11; } jQuery.each({ parent: function( elem ) { var parent = elem.parentNode; return parent && parent.nodeType !== 11 ? parent : null; }, parents: function( elem ) { return jQuery.dir( elem, "parentNode" ); }, parentsUntil: function( elem, i, until ) { return jQuery.dir( elem, "parentNode", until ); }, next: function( elem ) { return jQuery.nth( elem, 2, "nextSibling" ); }, prev: function( elem ) { return jQuery.nth( elem, 2, "previousSibling" ); }, nextAll: function( elem ) { return jQuery.dir( elem, "nextSibling" ); }, prevAll: function( elem ) { return jQuery.dir( elem, "previousSibling" ); }, nextUntil: function( elem, i, until ) { return jQuery.dir( elem, "nextSibling", until ); }, prevUntil: function( elem, i, until ) { return jQuery.dir( elem, "previousSibling", until ); }, siblings: function( elem ) { return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem ); }, children: function( elem ) { return jQuery.sibling( elem.firstChild ); }, contents: function( elem ) { return jQuery.nodeName( elem, "iframe" ) ? elem.contentDocument || elem.contentWindow.document : jQuery.makeArray( elem.childNodes ); } }, function( name, fn ) { jQuery.fn[ name ] = function( until, selector ) { var ret = jQuery.map( this, fn, until ); if ( !runtil.test( name ) ) { selector = until; } if ( selector && typeof selector === "string" ) { ret = jQuery.filter( selector, ret ); } ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret; if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) { ret = ret.reverse(); } return this.pushStack( ret, name, slice.call( arguments ).join(",") ); }; }); jQuery.extend({ filter: function( expr, elems, not ) { if ( not ) { expr = ":not(" + expr + ")"; } return elems.length === 1 ? jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] : jQuery.find.matches(expr, elems); }, dir: function( elem, dir, until ) { var matched = [], cur = elem[ dir ]; while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) { if ( cur.nodeType === 1 ) { matched.push( cur ); } cur = cur[dir]; } return matched; }, nth: function( cur, result, dir, elem ) { result = result || 1; var num = 0; for ( ; cur; cur = cur[dir] ) { if ( cur.nodeType === 1 && ++num === result ) { break; } } return cur; }, sibling: function( n, elem ) { var r = []; for ( ; n; n = n.nextSibling ) { if ( n.nodeType === 1 && n !== elem ) { r.push( n ); } } return r; } }); // Implement the identical functionality for filter and not function winnow( elements, qualifier, keep ) { // Can't pass null or undefined to indexOf in Firefox 4 // Set to 0 to skip string check qualifier = qualifier || 0; if ( jQuery.isFunction( qualifier ) ) { return jQuery.grep(elements, function( elem, i ) { var retVal = !!qualifier.call( elem, i, elem ); return retVal === keep; }); } else if ( qualifier.nodeType ) { return jQuery.grep(elements, function( elem, i ) { return ( elem === qualifier ) === keep; }); } else if ( typeof qualifier === "string" ) { var filtered = jQuery.grep(elements, function( elem ) { return elem.nodeType === 1; }); if ( isSimple.test( qualifier ) ) { return jQuery.filter(qualifier, filtered, !keep); } else { qualifier = jQuery.filter( qualifier, filtered ); } } return jQuery.grep(elements, function( elem, i ) { return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep; }); } function createSafeFragment( document ) { var list = nodeNames.split( "|" ), safeFrag = document.createDocumentFragment(); if ( safeFrag.createElement ) { while ( list.length ) { safeFrag.createElement( list.pop() ); } } return safeFrag; } var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" + "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g, rleadingWhitespace = /^\s+/, rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, rtagName = /<([\w:]+)/, rtbody = /]", "i"), // checked="checked" or checked rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptType = /\/(java|ecma)script/i, rcleanScript = /^\s*", "" ], legend: [ 1, "
", "
" ], thead: [ 1, "", "
" ], tr: [ 2, "", "
" ], td: [ 3, "", "
" ], col: [ 2, "", "
" ], area: [ 1, "", "" ], _default: [ 0, "", "" ] }, safeFragment = createSafeFragment( document ); wrapMap.optgroup = wrapMap.option; wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td; // IE can't serialize and

Navigation

Contents¶

Next topic

Getting cpp-netlib

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples.html000066400000000000000000000136331240331347200250340ustar00rootroot00000000000000 Examples — cpp-netlib v0.11.1

Navigation

Examples¶

The 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 cpp-netlib for these kinds of application. All examples are built using CMake.

HTTP examples¶

The HTTP component of the 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.

Table Of Contents

Previous topic

Getting Started

Next topic

HTTP client

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/000077500000000000000000000000001240331347200241405ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/http/000077500000000000000000000000001240331347200251175ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/http/atom_reader.html000066400000000000000000000300501240331347200302650ustar00rootroot00000000000000 Atom feed reader — cpp-netlib v0.11.1

Navigation

Atom feed reader¶

The next examples show some simple, more practical applications using the HTTP client. The first one reads a simple Atom feed and prints the titles of each entry to the console.

The code¶

#include "atom.hpp"
#include <boost/network/protocol/http/client.hpp>
#include <boost/foreach.hpp>
#include <iostream>

int main(int argc, char * argv[]) {
    using namespace boost::network;

    if (argc != 2) {
        std::cout << "Usage: " << argv[0] << " <url>" << std::endl;
        return 1;
    }

    try {
        http::client client;
        http::client::request request(argv[1]);
        request << header("Connection", "close");
        http::client::response response = client.get(request);
        atom::feed feed(response);

        std::cout << "Feed: " << feed.title()
                  << " (" << feed.subtitle() << ")" << std::endl;
        BOOST_FOREACH(const atom::entry &entry, feed) {
            std::cout << entry.title()
                      << " (" << entry.published() << ")" << std::endl;
        }
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

Building and running atom_reader¶

$ cd ~/cpp-netlib-build
$ make atom_reader

And to run the example from the command line to access the feed that lists of all the commits on cpp-netlib’s master branch:

$ ./example/atom_reader https://github.com/cpp-netlib/cpp-netlib/commits/master.atom

Diving into the code¶

Most of this will now be familiar. The response is passed to the constructor to the atom::feed class, which parses the resultant XML. To keep this example as simple as possible, rapidxml, a header-only XML parser library, was used to parse the response.

A similar example using RSS feeds exists in libs/network/example/rss.

Table Of Contents

Previous topic

“Hello world” HTTP client

Next topic

Twitter search

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/http/hello_world_client.html000066400000000000000000000332571240331347200316670ustar00rootroot00000000000000 “Hello world†HTTP client — cpp-netlib v0.11.1

Navigation

“Hello world” HTTP client¶

Since we have a “Hello World” HTTP server, let’s then create an HTTP client to access that server. This client will be similar to the HTTP client we made earlier in the documentation.

The code¶

We want to create a simple HTTP client that just makes a request to the HTTP server that we created earlier. This really simple client will look like this:

#include <boost/network/protocol/http/client.hpp>
#include <string>
#include <sstream>
#include <iostream>

namespace http = boost::network::http;

int main(int argc, char * argv[]) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " address port" << std::endl;
        return 1;
    }

    try {
        http::client client;
        std::ostringstream url;
        url << "http://" << argv[1] << ":" << argv[2] << "/";
        http::client::request request(url.str());
        http::client::response response =
            client.get(request);
        std::cout << body(response) << std::endl;
    } catch (std::exception & e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }
    return 0;
}

Building and running the client¶

Just like with the HTTP Server and HTTP client example before, we can build this example by doing the following on the shell:

$ cd ~/cpp-netlib-build
$ make hello_world_client

This example can be run from the command line as follows:

$ ./example/hello_world_client http://127.0.0.1:8000

Note

This assumes that you have the hello_world_server running on localhost port 8000.

Diving into the code¶

All this example shows is how easy it is to write an HTTP client that connects to an HTTP server, and gets the body of the response. The relevant lines are:

http::client client;
http::client::request request(url.str());
http::client::response response =
    client.get(request);
std::cout << body(response) << std::endl;

You can then imagine using this in an XML-RPC client, where you can craft the XML-RPC request as payload which you can pass as the body to a request, then perform the request via HTTP:

http::client client;
http::client::request request("http://my.webservice.com/");
http::client::response =
    client.post(request, some_xml_string, "application/xml");
std::data = body(response);

The next set of examples show some more practical applications using the cpp-netlib HTTP client.

Table Of Contents

Previous topic

“Hello world” HTTP server

Next topic

Atom feed reader

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/http/hello_world_server.html000066400000000000000000000410511240331347200317060ustar00rootroot00000000000000 “Hello world†HTTP server — cpp-netlib v0.11.1

Navigation

“Hello world” HTTP server¶

Now that we’ve seen how we can deal with request and response objects from the client side, we’ll see how we can then use the same abstractions on the server side. In this example we’re going to create a simple HTTP Server in C++ using cpp-netlib.

The code¶

The cpp-netlib provides the framework to develop embedded HTTP servers. For this example, the server is configured to return a simple response to any HTTP request.

#include <boost/network/protocol/http/server.hpp>
#include <string>
#include <iostream>

namespace http = boost::network::http;

struct hello_world;
typedef http::server<hello_world> server;

struct hello_world {
    void operator() (server::request const &request,
                     server::response &response) {
        std::string ip = source(request);
        response = server::response::stock_reply(
            server::response::ok, std::string("Hello, ") + ip + "!");
    }
};

int
main(int argc, char * argv[]) {

    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " address port" << std::endl;
        return 1;
    }

    try {
        hello_world handler;
        server server_(argv[1], argv[2], handler);
        server_.run();
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }

    return 0;
}

This is about a straightforward as server programming will get in C++.

Building and running the server¶

Just like with the HTTP client, we can build this example by doing the following on the shell:

$ cd ~/cpp-netlib-build
$ make hello_world_server

The first two arguments to the server constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously. This example can be run from a command line as follows:

$ ./example/hello_world_server 0.0.0.0 8000

Note

If you’re going to run the server on port 80, you may have to run it as an administrator.

Diving into the code¶

Let’s take a look at the code listing above in greater detail.

#include <boost/network/protocol/http/server.hpp>

This header contains all the code needed to develop an HTTP server with cpp-netlib.

struct hello_world;
typedef http::server<hello_world> server;

struct hello_world {
    void operator () (server::request const &request,
                      server::response &response) {
        std::string ip = source(request);
        response = server::response::stock_reply(
            server::response::ok, std::string("Hello, ") + ip + "!");
    }
};

hello_world is a functor class which handles HTTP requests. All the operator does here is return an HTTP response with HTTP code 200 and the body "Hello, <ip>!". The <ip> in this case would be the IP address of the client that made the request.

There are a number of pre-defined stock replies differentiated by status code with configurable bodies.

All the supported enumeration values for the response status codes can be found in boost/network/protocol/http/impl/response.ipp.

hello_world handler;
server server_(argv[1], argv[2], handler);
server_.run();

The first two arguments to the server constructor are the host and the port on which the server will listen. The third argument is the the handler object defined previously.

Note

In this example, the server is specifically made to be single-threaded. In a multi-threaded server, you would invoke the hello_world::run member method in a set of threads. In a multi-threaded environment you would also make sure that the handler does all the necessary synchronization for shared resources across threads. The handler is passed by reference to the server constructor and you should ensure that any calls to the operator() overload are thread-safe.

Table Of Contents

Previous topic

Simple wget

Next topic

“Hello world” HTTP client

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/http/http_client.html000066400000000000000000000334051240331347200303270ustar00rootroot00000000000000 HTTP client — cpp-netlib v0.11.1

Navigation

HTTP client¶

The first code example is the simplest thing you can do with the cpp-netlib. The application is a simple HTTP client, which can be found in the subdirectory libs/network/example/http_client.cpp. All this example doing is creating and sending an HTTP request to a server and printing the response body.

The code¶

Without further ado, the code to do this is as follows:

#include <boost/network/protocol/http/client.hpp>
#include <iostream>

int main(int argc, char *argv[]) {
    using namespace boost::network;

    if (argc != 2) {
        std::cout << "Usage: " << argv[0] << " [url]" << std::endl;
        return 1;
    }

    http::client client;
    http::client::request request(argv[1]);
    request << header("Connection", "close");
    http::client::response response = client.get(request);
    std::cout << body(response) << std::endl;

    return 0;
}

Running the example¶

You can then run this to get the Boost website:

$ cd ~/cpp-netlib-build
$ make http_client
$ ./example/http_client http://www.boost.org/

Note

The instructions for all these examples assume that cpp-netlib is build outside the source tree, according to CMake conventions. For the sake of consistency we assume that this is in the ~/cpp-netlib-build directory.

Diving into the code¶

Since this is the first example, each line will be presented and explained in detail.

#include <boost/network/protocol/http/client.hpp>

All the code needed for the HTTP client resides in this header.

http::client client;

First we create a client object. The client abstracts all the connection and protocol logic. The default HTTP client is version 1.1, as specified in RFC 2616.

http::client::request request(argv[1]);

Next, we create a request object, with a URI string passed as a constructor argument.

request << header("Connection", "close");

cpp-netlib makes use of stream syntax and directives to allow developers to build complex message structures with greater flexibility and clarity. Here, we add the HTTP header “Connection: close” to the request in order to signal that the connection will be closed after the request has completed.

http::client::response response = client.get(request);

Once we’ve built the request, we then make an HTTP GET request throught the http::client from which an http::response is returned. http::client supports all common HTTP methods: GET, POST, HEAD, DELETE.

std::cout << body(response) << std::endl;

Finally, though we don’t do any error checking, the response body is printed to the console using the body directive.

That’s all there is to the HTTP client. In fact, it’s possible to compress this to a single line:

std::cout << body(http::client().get(http::request("http://www.boost.org/")));

The next example will introduce the uri class.

Table Of Contents

Previous topic

Examples

Next topic

Simple wget

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/http/simple_wget.html000066400000000000000000000402621240331347200303300ustar00rootroot00000000000000 Simple wget — cpp-netlib v0.11.1

Navigation

Simple wget¶

This example is a very simple implementation of a wget style clone. It’s very similar to the previous example, but introduces the uri class.

The code¶

#include <boost/network/protocol/http/client.hpp>
#include <boost/network/uri.hpp>
#include <string>
#include <fstream>
#include <iostream>

namespace http = boost::network::http;
namespace uri = boost::network::uri;

namespace {
std::string get_filename(const uri::uri &url) {
    std::string path = uri::path(url);
    std::size_t index = path.find_last_of('/');
    std::string filename = path.substr(index + 1);
    return filename.empty()? "index.html" : filename;
}
} // namespace

int
main(int argc, char *argv[]) {
    if (argc != 2) {
        std::cerr << "Usage: " << argv[0] << " url" << std::endl;
        return 1;
    }

    try {
        http::client client;
        http::client::request request(argv[1]);
        http::client::response response = client.get(request);

        std::string filename = get_filename(request.uri());
        std::cout << "Saving to: " << filename << std::endl;
        std::ofstream ofs(filename.c_str());
        ofs << static_cast<std::string>(body(response)) << std::endl;
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }

    return 0;
}

Running the example¶

You can then run this to copy the Boost website:

$ cd ~/cpp-netlib-build
$ make simple_wget
$ ./example/simple_wget http://www.boost.org/
$ cat index.html

Diving into the code¶

As with wget, this example simply makes an HTTP request to the specified resource, and saves it on the filesystem. If the file name is not specified, it names the resultant file as index.html.

The new thing to note here is use of the uri class. The uri takes a string as a constructor argument and parses it. The uri parser is fully-compliant with RFC 3986. The URI is provided in the following header:

#include <boost/network/uri.hpp>

Most of the rest of the code is familiar from the previous example. To retrieve the URI resource’s file name, the following function is provided:

std::string get_filename(const uri::uri &url) {
    std::string path = uri::path(url);
    std::size_t index = path.find_last_of('/');
    std::string filename = path.substr(index + 1);
    return filename.empty()? "index.html" : filename;
}

The uri interface provides access to its different components: scheme, user_info, host, port, path, query and fragment. The code above takes the URI path to determine the resource name.

Next we’ll develop a simple client/server application using http::server and http::client.

Table Of Contents

Previous topic

HTTP client

Next topic

“Hello world” HTTP server

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/examples/http/twitter_search.html000066400000000000000000000412021240331347200310330ustar00rootroot00000000000000 Twitter search — cpp-netlib v0.11.1

Navigation

Table Of Contents

Previous topic

Atom feed reader

Next topic

An in-depth look at the cpp-netlib

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/genindex.html000066400000000000000000000055111240331347200250130ustar00rootroot00000000000000 Index — cpp-netlib v0.9.4
documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/getting_started.html000066400000000000000000000564611240331347200264130ustar00rootroot00000000000000 Getting Started — cpp-netlib v0.11.1

Navigation

Getting Started¶

Downloading an official release¶

You can find links to the latest official release from the project’s official website:

All previous stable versions of cpp-netlib can be downloaded from Github from this url:

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).

Downloading a development version¶

The 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/cpp-netlib/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

Previous versions of cpp-netlib referred to the mikhailberis repository as the main development repository. This account is still valid, but not always up-to-date. In the interest of consistency, the main repository has been changed to cpp-netlib.

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/cpp-netlib/cpp-netlib.git.

Note

The 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).

Getting Boost¶

cpp-netlib depends on Boost. It should work for any version of Boost above 1.50.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 cpp-netlib still requires linking with Boost.System, Boost.Date_time, and Boost.Regex.

Note

You can follow the steps in the Boost Getting Started guide to install Boost into your development system.

Warning

There is a known incompatibility between cpp-netlib and Boost 1.46.1 on some compilers. It is not recommended to use cpp-netlib with Boost 1.46.1. Some have reported though that Boost 1.47.0 and cpp-netlib work together better.

Getting CMake¶

The 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 cpp-netlib in your project. The cpp-netlib requires CMake version 2.8 or higher.

Let’s assume that you have unpacked the 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 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 cpp-netlib with additional parameters:

$ mkdir ~/cpp-netlib-build
$ cd ~/cpp-netlib-build
$ cmake -DCMAKE_BUILD_TYPE=Debug \
>       -DCMAKE_C_COMPILER=gcc   \
>       -DCMAKE_CXX_COMPILER=g++ \
>       ../cpp-netlib

Note

While it’s not compulsory, it’s recommended that cpp-netlib is built outside the source directory. For the purposes of documentation, we’ll assume that all builds are done in ~/cpp-netlib-build.

If you intend to use the SSL support when using the HTTP client libraries in cpp-netlib, you may need to build it with OpenSSL installed or at least available to CMake. If you have the development headers for OpenSSL installed on your system when you build cpp-netlib, CMake will be able to detect it and set the BOOST_NETWORK_ENABLE_HTTPS macro when building the library to support HTTPS URIs.

One example for building the library with OpenSSL support with a custom (non-installed) version of OpenSSL is by doing the following:

$ cmake -DCMAKE_BUILD_TYPE=Debug \
>       -DCMAKE_C_COMPILER=clang \
>       -DCMAKE_CXX_COMPILER=clang++ \
>       -DOPENSSL_ROOT_DIR=/Users/dberris/homebrew/Cellar/openssl/1.0.1f
>       ../cpp-netlib

You can also use a different root directory for the Boost project by using the -DBOOST_ROOT configuration option to CMake. This is useful if you intend to build the library with a specific version of Boost that you’ve built in a separate directory:

$ cmake -DCMAKE_BUILD_TYPE=Debug \
>       -DCMAKE_C_COMPILER=clang \
>       -DCMAKE_CXX_COMPILER=clang++ \
>       -DOPENSSL_ROOT_DIR=/Users/dberris/homebrew/Cellar/openssl/1.0.1f \
>       -DBOOST_ROOT=/Users/dberris/Source/boost_1_55_0
>       ../cpp-netlib

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 cpp-netlib. To build the tests, you can run make in the same top-level directory of ~/cpp-netlib-build:

$ 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, 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. However, this compile-time burden is much reduced in recent versions.

Once the build has completed, you can now run the test suite by issuing:

$ make test

You can install cpp-netlib by issuing:

$ sudo make install

By default this installs cpp-netlib into /usr/local.

Note

As of version 0.9.3, cpp-netlib produces three static libraries. Using GCC on Linux these are:

libcppnetlib-client-connections.a
libcppnetlib-server-parsers.a
libcppnetlib-uri.a

Users can find them in ~/cpp-netlib-build/libs/network/src.

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.

Note

As of version 0.9.3, cpp-netlib produces three static libraries. Using Visual C++ on Windows they are:

cppnetlib-client-connections.lib
cppnetlib-server-parsers.lib
cppnetlib-uri.lib

Users can find them in ~/cpp-netlib-build/libs/network/src.

Using cpp-netlib¶

CMake projects¶

Projects using CMake can add the following lines in their CMakeLists.txt to be able to use cpp-netlib:

set ( CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ~/cpp-netlib-build )
find_package ( cppnetlib 0.11.0 REQUIRED )
include_directories ( ${CPPNETLIB_INCLUDE_DIRS} )
target_link_libraries ( MyApplication ${CPPNETLIB_LIBRARIES} )

Note

Setting CMAKE_PREFIX_PATH is only required when cpp-netlib is not installed to a location that CMake searches. When cpp-netlib is installed to the default location (/usr/local), CMake can find it.

Note

We assume that MyApplication is the application that you are building and which depends on cpp-netlib.

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/cpp-netlib/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 http://groups.google.com/forum/#!forum/cpp-netlib.

Table Of Contents

Previous topic

What’s New

Next topic

Examples

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/history.html000066400000000000000000000162051240331347200247150ustar00rootroot00000000000000 Project history — cpp-netlib v0.11.1

Navigation

Project history¶

The cpp-netlib was founded by Dean Michael Berris in 2007. Initially it consisted of a message template and an HTTP client. It found a home on Sourceforge but was migrated at the end of 2009 to Github where development is actively continued by a committed community.

Motivation¶

We’re a group of C++ developers and we kept becoming annoyed that we had to repeatedly write the same code when building applications that needed to be network-aware.

We found that there was a lack of accessible networking libraries, either standard or open source, that fulfilled our needs. Such libraries exist for every other major language. So, building on top of Boost.Asio, we decided to get together and build our own.

Objectives¶

The objectives of the cpp-netlib are to:

  • develop a high quality, portable, easy to use C++ networking library
  • enable developers to easily extend the library
  • lower the barrier to entry for cross-platform network-aware C++ applications

The goal the of cpp-netlib has never been to build a fully-featured web server - there are plenty of excellent options already available. The niche that this library targets is for light-weight networking functionality for C++ applications that have demanding performance requirements or memory constraints, but that also need to be portable. This type of application is becoming increasingly common as software becomes more distributed, and applications need to communicate with services.

While many languages provide direct library support for high level network programming, this feature is missing in C++. Therefore, this library has been developed with the intention of eventually being submitted to Boost, a collection of general, high quality libraries for C++ developers.

Eventually, the cpp-netlib will be extended to support many of the application layer protocols such as SMTP, FTP, SOAP, XMPP etc.

Table Of Contents

Previous topic

Static and dynamic polymorphism

Next topic

Reference Manual

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/in_depth.html000066400000000000000000000143641240331347200250120ustar00rootroot00000000000000 An in-depth look at the cpp-netlib — cpp-netlib v0.11.1

Navigation

An in-depth look at the cpp-netlib¶

The cpp-netlib is composed of three different sets of functionality: a message template, a URI template and different protocol implementations.

Previous topic

Twitter search

Next topic

The message template

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/in_depth/000077500000000000000000000000001240331347200241145ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/in_depth/http.html000066400000000000000000000552011240331347200257640ustar00rootroot00000000000000 HTTP implementation — cpp-netlib v0.11.1

Navigation

HTTP implementation¶

HTTP client¶

At the heart of the HTTP client implementation is a single class aptly named basic_client, which is also a template. The template basic_client takes three template parameters:

namespace boost { namespace http {

    template <class Tag, unsigned version_major, unsigned version_minor>
    struct basic_client;

} // namespace http

} // namespace boost

The Tag template parameter follows the same tag-dispatch mechanism to determine the behavior of the basic_client. The interface of basic_client may change depending on certain properties defined for the tag you provide. Below is a table of predefined supported tags you can use in your overload of the basic_client:

Tag Description
http_default_8bit_tcp_resolve This is the default HTTP implementation tag that resolves addresses with a TCP resolver and provides a synchronous/blocking HTTP client interface.
http_default_8bit_udp_resolve This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.
http_keepalive_8bit_tcp_resolve This tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the version_major and version_minor are both 1, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.
http_keepalive_8bit_udp_resolve This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.
http_async_8bit_tcp_resolve This tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of Boost.Thread shared futures to hold values. Users don’t have to see this as they are implementation details.
http_async_8bit_udp_resolve This is similar to the above tag except that specifies the HTTP client to use a UDP resolver.

The default typedef for the HTTP client that is provided uses the http_async_8bit_udp_resolve tag, and implements HTTP 1.1. The exact typedef is in the boost::network::http namespace as the following:

namespace boost { namespace network { namespace http {

    typedef basic_client<tags::http_async_8bit_udp_resolve, 1, 1>
        client;

}}}

This type has nested typedefs for the correct types for the basic_request and basic_response templates. To use the correct types for basic_request or basic_response you can use these nested typedefs like so:

boost::network::http::client::request request;
boost::network::http::client::response response;

// or...
using namespace boost::network;
http::client::request request;
http::client::response response;

Typical use cases for the HTTP client would look something like the following:

using namespace boost::network;
http::request request("http://www.boost.org/");
request << header("Connection", "close");

The basic_client implements all HTTP methods as member functions (HEAD, GET, POST, PUT, DELETE). Therefore, the code to make an HTTP request looks trivially simple:

using namespace boost::network;
http::client client;
http::client::request request("http://www.boost.org/");
http::client::response response = client.get(request);

Accessing data from http::response is done using wrappers. To get the response headers, we use the headers wrapper which returns, in the default case, a multimap of strings to strings:

using namespace boost::network;
typedef headers_range<http_client::response>::type response_headers;
boost::range_iterator<response_headers>::type iterator;

response_headers headers_ = headers(response);
for (iterator it = headers_.begin(); it != headers_.end(); ++it) {
    std::cout << it->first << ": " << it->second << std::endl;
}
std::cout << std::endl;

HTTP server¶

As with the HTTP client, the HTTP server that is provided with cpp-netlib is extensible through the tag mechanism and is embeddable. The template class declaration of basic_server is given below:

namespace boost { namespace network { namespace http {

    template <class Tag, class RequestHandler> basic_server;

}}}

The second template argument is used to specify the request handler type. The request handler type is a functor type which should overload the function call operator (RequestHandler::operator() should be overloaded) that takes two parameters: the first one being a reference to a const basic_request<Tag> and the second being a reference to a basic_response<Tag> instance.

All the logic for parsing the HTTP request and building the const basic_request<Tag> object resides internally in the basic_server template. Processing the request is delegated to the RequestHandler type, and the assumption of which would be that the response is formed inside the RequestHandler function call operator overload.

The basic_server template however is only an underlying implementation while the user-visible implementation is the http::server template. This simply specializes the basic_server template to use the default_ tag and forwards the RequestHandler parameter:

namespace boost { namespace network { namespace http {

    template <class RequestHandler>
    class server :
        public basic_server<default_, RequestHandler> {};

}}}

To use the forwarding server type you just supply the request handler implementation as the parameter. For example, an “echo” server example might look something like this:

using namespace boost::network;
struct echo;
typedef http::server<echo> echo_server;

struct echo {
    void operator () (const echo_server::request &request,
                      echo_server::response &response) const {
        std::string ip = source(request);
        response = echo_server::response::stock_reply(
            echo_server::response::ok,
            body(request));
        std::cerr << "[" << ip << "]: " << request.uri <<
            " status = " << echo_server::response::ok << '\n';
    }
};

Here, all we’re doing is returning the original request body with an HTTP OK response (200). We are also printing the IP address from where the request came from. Notice that we are using a wrapper to access the source of the request.

Table Of Contents

Previous topic

The URI class

Next topic

Techniques

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/in_depth/http_client_tags.html000066400000000000000000000116411240331347200303400ustar00rootroot00000000000000 <no title> — cpp-netlib v0.11.1

Navigation

Tag Description
http_default_8bit_tcp_resolve This is the default HTTP implementation tag that resolves addresses with a TCP resolver and provides a synchronous/blocking HTTP client interface.
http_default_8bit_udp_resolve This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.
http_keepalive_8bit_tcp_resolve This tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the version_major and version_minor are both 1, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.
http_keepalive_8bit_udp_resolve This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.
http_async_8bit_tcp_resolve This tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of Boost.Thread shared futures to hold values. Users don’t have to see this as they are implementation details.
http_async_8bit_udp_resolve This is similar to the above tag except that specifies the HTTP client to use a UDP resolver.

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/in_depth/message.html000066400000000000000000000617541240331347200264430ustar00rootroot00000000000000 The message template — cpp-netlib v0.11.1

Navigation

The message template¶

One of the core components in the library is the concept and the implementation of a common message type. In most (not all) network protocols, the concept of a message is central to the definition of the protocol. In HTTP, SMTP, XMPP, and even other protocols like SNMP and ICMP, there is a common notion of a “packet” or a message. In cpp-netlib we chose to implement the concept of a message that has the following common parts:

  • Source - every message has a source identifier which varies from protocol to protocol.
  • Destination - every message has a destination identifier which varies from protocol to protocol.
  • Headers - each message is assumed to contain headers, which may be empty in cases where the protocol does not support it, but is nonetheless supported by cpp-netlib messages.
  • Body - the content area of a message which varies from protocol to protocol (also sometimes referred to as payload).

This division is purely logical – in the underlying implementation, the message type can choose to have different means of storing the data, depending on the type used to tag the message. This section covers the Message Concept as well as the basic_message implementation.

Message Concept¶

Warning

The Message framework is deprecated in the 0.11 release, and will be removed in future versions of the library.

The Message Concept specifies what the valid operations on a message are as well as what messages look like semantically. The following table summarize the operations and syntactic as well as semantic properties of messages.

Legend

M:The message type.
H:A headers container type.
m,n:An instance of M.
S:A string type.
s,k,v:An instance of S.
O:The source type.
D:The destination type.
B:The body type.
T:The Tag type.
Construct Result Description
typename M::tag T The nested tag type.
M() Instance of M Default constructible.
M(m) Instance of M Copy constructible.
m = n; Reference to m Assignable.
swap(m, n); void Swappable.
source(m); Convertible to O Retrieve the source of m.
destination(m); Convertible to D Retrieve the destination of m.
headers(m); Convertible to H Retrieve the headers of m.
body(m); Convertible to B Retrieve the body of m.
m << source(s); M & Set the source of m.
m << destination(s); M & Set the destination of m.
m << header(k, v); M & Add a header to m.
m << remove_header(k); M & Remove a header from m.
m << body(s); M & Set the body of m.
source(m,s); void Set the source of m.
destination(m,s); void Set the destination of m.
add_header(m, k, v); void Add a header to m.
remove_header(m, k); void Remove a header from m.
clear_headers(m); void Clear the headers of m.
body(m,s); M & Set the body of m.

Types that model the Message Concept are meant to encapsulate data that has a source, a destination, one or more named headers, and a body/payload. Because the accessors and the directives are not required to be part of the message type that models the Message Concept, a message can be implemented as a POD type and have all manipulations performed in the directive implementations, as well as value transformations done in the accessors.

Directives, Modifiers, and Wrappers¶

In the Message Concept definition there are three basic constructs that follow a certain pattern. These patterns are Directives, Modifiers, and Wrappers.

Directives¶

A directive is a function object that is applied to a Message. Directives encapsulate a set of operations that apply to messages. The general requirement for a Directive is that it should apply these operations on a message.

A directive may dispatch on the type of the message passed to it at the point of the function call. Typically, directives are generated using a factory function that returns the correct directive type.

For a given directive foo_directive a generator function called foo is typically implemented:

struct foo_directive {
    template <class Message>
    Message & operator()(Message & m) const {
        // do something to m
        return m;
    }
};

foo_directive const foo() {
    return foo_directive();
}

// to apply a directive, we use the << operator
message m;
m << foo();

Modifiers¶

A modifier is generally defined as a free function that takes a reference to a non-const lvalue message as the first parameter, and any number of parameters. In the concept definition of the Message Concept, a modifier follows the form:

modifier(message, ...)

Modifiers are meant to imply modifications on a message, which also allows for easier dispatch based on Argument Dependent Lookup (ADL) on the type of the message. Note that Directives can be implemented in terms of Modifiers and vice versa, although that is not required nor specified.

Wrappers¶

A Wrapper is basically an implementation detail that ensures that a given message, when wrapped, can be converted to the associated part of the message. A wrapper has a type that encapsulates the conversion logic from a message to a given type.

An example of a Wrapper would be source_wrapper which would be returned by a call to the wrapper generator function source. An example implementation of the source_wrapper would look like:

template <class Tag, template <class> class Message>
struct source_wrapper {
    Message<Tag> const & m;
    explicit source_wrapper(Message<Tag> const & m)
    : m(m) {}
    typedef typename source<Tag>::type source_type;
    operator source_type const & () {
        return m.source;
    }
    operator source_type const () {
        return m.source;
    }
    operator source_type () {
        return m.source;
    }
};

template <class Tag, template <class> class Message>
source_wrapper<Tag, Message> const
source(Message<Tag> const & message) {
    return source_wrapper<Tag, Message>(message);
}

This pattern is similar to an adapter, but the specific notion of wrapping a data type (in this case, an object of a type that models the Message Concept) using an intermediary wrapper is what is pertained to by the Wrapper pattern. In this case, the Wrapper is source_wrapper while source is merely a wrapper generator function.

basic_message¶

The default implementation of a simple type that models the Message Concept is available in cpp-netlib. This default implementation is named basic_message which supports a Tag template parameter. The definition of basic_message looks like this:

template <class Tag>
class basic_message;

The basic_message template requires that the following tag-dispatched metafunctions are defined for the type Tag:

template <class Tag>
struct string;

template <class Tag>
struct headers_container;

All the operations defined by the message concept are implemented by this basic message type. Other message implementations can either use this common message type or specialize it according to whether they want to use different containers or whether it’s going to be just a POD type.

Table Of Contents

Previous topic

An in-depth look at the cpp-netlib

Next topic

The URI class

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/in_depth/uri.html000066400000000000000000000375771240331347200256240ustar00rootroot00000000000000 The URI class — cpp-netlib v0.11.1

Navigation

The URI class¶

In addition to protocol implementations, the cpp-netlib provides a powerful URI class. The class implements a parser based on RFC 3986 and RFC 2732.

Generic URI syntax overview¶

A generic URI will take the form:

[scheme:]scheme-specific-part[#fragment]

A URI is known as absolute if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, uri supports only absolute URIs.

URIs can be further classified according to whether they’re hierarchical or opaque (non-hierarchical).

Some examples of non-hierarchical URIs include:

mailto:john.doe@example.com
news:comp.infosystems.www.servers.unix
tel:+1-816-555-1212

The data following the first ":" is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the ":" to be a part of the path:

../_images/mailto_uri.png

A hierarchical URI is identified by a double slash ("//") after the scheme and a scheme-specific component, which RFC 3986 defines to be:

[scheme:][//authority][path][?query][#fragment]

The authority component can be further broken down to:

[user_info@]host[:port]

Examples of hierarchical URIs include:

http://www.boost.org/
file:///bin/bash

The following example, describing a complex URI using FTP, shows how a URI is broken down by the parser:

../_images/ftp_uri.png

Note that the authority is further subdivided into different elements. Another example, using HTTP is given below:

../_images/http_uri.png

The difference here between the path in a hierarchical URI and that in the example above for the non-hierarchical URI.

The uri class¶

As of version 0.9.3, uri supplies a URI parser and builder. To use the parser, it’s as simple as supplying a string to the constructor:

using namespace boost::network;
uri::uri instance("http://cpp-netlib.github.com/");
assert(instance.is_valid());
std::cout << "scheme: " << instance.scheme() << std::endl
          << "host: " << instance.host() << std::endl;

The command-line output of this program will be:

scheme: http
host: cpp-netlib.github.com

The uri builder¶

uri support a stream style syntax to create a URI from it’s elements. For example the program:

#include <iostream>
#include <boost/network/uri.hpp>
#include <boost/network/uri/uri_io.hpp>
using namespace boost::network;

int main() {
    uri::uri url;
    url << uri::scheme("http")
        << uri::host("www.github.com")
        << uri::path("/cpp-netlib");
    std::cout << url << std::endl;
    return 0;
}

will output:

http://www.github.com/cpp-netlib

URI Concept¶

Legend

U:The URI type.
u,u_:An instance of M.
S:A string type.
s,v:An instance of S.
T:The Tag type.
Construct Result Description
U(u) Instance of U Copy constructible.
U(s) Instance of U Constructible from string.
u = u_; Reference to u Assignable.
u = s; Reference to u Assignable from string.
swap(u, u_); void Swappable.
scheme(u); Convertible to S Retrieve the URI scheme of u.
user_info(u); Convertible to S Retrieve the user info of u.
host(u); Convertible to S Retrieve the host of u.
port(u); Convertible to H Retrieve the port of u.
path(u); Convertible to S Retrieve the path of u.
query(u); Convertible to S Retrieve the query string of u.
fragment(u); Convertible to S Retrieve the fragment of u.

Table Of Contents

Previous topic

The message template

Next topic

HTTP implementation

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/index.html000066400000000000000000000325561240331347200243320ustar00rootroot00000000000000 Getting cpp-netlib — cpp-netlib v0.11.1

Navigation

Straightforward network programming in modern C++

Getting cpp-netlib¶

You can find out more about the cpp-netlib project at http://cpp-netlib.org/.

Download

You can get the latest official version of the library from the official project website at:

This version of cpp-netlib is tagged as cpp-netlib-0.11.0 in the GitHub repository. You can find more information about the progress of the development by checking our GitHub project page at:

Support

You can ask questions, join the discussion, and report issues to the developers mailing list by joining via:

You can also file issues on the Github issue tracker at:

We are a growing community and we are happy to accept new contributions and ideas.

C++ Network Library¶

cpp-netlib is a library collection that provides application layer protocol support using modern C++ techniques. It is light-weight, fast, portable and is intended to be as easy to configure as possible.

Hello, world!¶

The cpp-netlib allows developers to write fast, portable network applications with the minimum of fuss.

An HTTP server-client example can be written in tens of lines of code. The client is as simple as this:

using namespace boost::network;
using namespace boost::network::http;

client::request request_("http://127.0.0.1:8000/");
request_ << header("Connection", "close");
client client_;
client::response response_ = client_.get(request_);
std::string body_ = body(response_);

And the corresponding server code is listed below:

namespace http = boost::network::http;

struct handler;
typedef http::server<handler> http_server;

struct handler {
    void operator() (http_server::request const &request,
                     http_server::response &response) {
        response = http_server::response::stock_reply(
            http_server::response::ok, "Hello, world!");
    }

    void log(http_server::string_type const &info) {
        std::cerr << "ERROR: " << info << '\n';
    }
};

int main(int arg, char * argv[]) {
    handler handler_;
    http_server::options options(handler_);
    http_server server_(
        options.address("0.0.0.0")
               .port("8000"));
    server_.run();
}

Want to learn more?¶

Warning

Be aware that not all features are stable. The generic message design is under review and the URI and HTTP client implementation will continue to undergo refactoring. Future versions will include support for other network protocols.

Table Of Contents

Previous topic

Contents

Next topic

What’s New

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/objects.inv000066400000000000000000000007611240331347200244750ustar00rootroot00000000000000# Sphinx inventory version 2 # Project: cpp-netlib # Version: 0.11 # The remainder of this file is compressed using zlib. xÚSANÃ0¼û«‚ÄÉT\¹UQE­ÄÑrãmbá8‘³%å÷$Y'$U[õ”ÝÙ™±=vRôÖÞJûƒv‚jK„¡Y^‡$»¶Ù)“ #&£zË-p+òÂœ ¯ü•ý æ·*ÌÁá¥gÑÓ­12ûBŒÑêLŒ<çRŸ6LXë…¦"Wµ¹~É#›´€ŒºESÃѢמwì¯ñ5ö¢²íWÕ)^MhDc d§Ût5´µ¸5ñZŒzï8Ð:ÓT)õÔm€Yݵ²e}5ÕCX‹f;d}ª*Òš€NþÀÉm"({Å÷°á^$…§fS'ÙöhŸíKì…õÊ`I'Ï¡G™n½dÎÂÃP»¢øM@BR–ÍÁÈÙøo‘¥cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/reference.html000066400000000000000000000155741240331347200251620ustar00rootroot00000000000000 Reference Manual — cpp-netlib v0.11.1

Navigation

Previous topic

Project history

Next topic

HTTP Client API

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/reference/000077500000000000000000000000001240331347200242605ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/reference/http_client.html000066400000000000000000001445121240331347200274720ustar00rootroot00000000000000 HTTP Client API — cpp-netlib v0.11.1

Navigation

HTTP Client API¶

General¶

cpp-netlib includes and implements a number of HTTP clients that you can use and embed in your own applications. All of the HTTP client implementations:

  • Cannot be copied. This means you may have to store instances of the clients in dynamic memory if you intend to use them as function parameters or pass them around in smart pointers or by reference.
  • Assume that requests made are independent of each other. There currently is no cookie or session management system built-in to cpp-netlib’s HTTP client implementations.

The HTTP clients all share the same API, but the internals are documented in terms of what is different and what to expect with the different implementations.

As of 0.9.1 the default implementation for the cpp-netlib HTTP client is asynchronous.

As of 0.11 the Synchronous Clients are now DEPRECATED and will be removed in subsequent releases.

Features¶

The HTTP client implementation supports requesting secure HTTP (HTTPS) content only in the following situations:

  • Client libraries are built with ``BOOST_NETWORK_ENABLE_HTTPS``. This tells the implementation to use HTTPS-specific code to handle HTTPS-based content when making connections associated with HTTPS URI’s. This requires a dependency on OpenSSL.
  • The ``BOOST_NETWORK_ENABLE_HTTPS`` macro is set when compiling user code. It is best to define this either at compile-time of all code using the library, or before including any of the client headers.

To use the client implementations that support HTTPS URIs, you may explicitly do the following:

#define BOOST_NETWORK_ENABLE_HTTPS
#include <boost/network/include/http/client.hpp>

This forces HTTPS support to be enabled and forces a dependency on OpenSSL. This dependency is imposed by Boost.Asio

Implementations¶

There is a single user-facing template class named basic_client which takes three template parameters:

  • Tag - which static tag you choose that defines the behavior of the client.
  • http_version_major - an unsigned int that defines the HTTP major version number, this directly affects the HTTP messages sent by the client.
  • http_version_minor - an unsigned int that defines the HTTP minor version number.

There are two major different class of implementations of the basic_client template that depend on which tag you choose: Synchronous Clients and Asynchronous Clients. These two different classes are described in their own sections following this one. What follows is a table of all tags supported by the HTTP client implementation provided by cpp-netlib.

Tag Description
http_default_8bit_tcp_resolve This is the default HTTP implementation tag that resolves addresses with a TCP resolver and provides a synchronous/blocking HTTP client interface.
http_default_8bit_udp_resolve This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.
http_keepalive_8bit_tcp_resolve This tag specifies that the HTTP client by default will keep connections to the server alive. It only makes sense if the version_major and version_minor are both 1, to indicate HTTP 1.1. This tag causes the HTTP client to resolve using a TCP resolver and provides a synchronous/ blocking HTTP client interface.
http_keepalive_8bit_udp_resolve This is similar to the above tag except that it specifies the HTTP client to use a UDP resolver. It also provides a synchronous/ blocking HTTP client interface.
http_async_8bit_tcp_resolve This tag provides an active HTTP client object implementation that uses a TCP resolver. Response objects returned will encapsulate a number of Boost.Thread shared futures to hold values. Users don’t have to see this as they are implementation details.
http_async_8bit_udp_resolve This is similar to the above tag except that specifies the HTTP client to use a UDP resolver.

In the above table the tags follow a pattern for describing the behavior introduced by the tags. This pattern is shown below:

<protocol>_<modifier>_<character-width>_<resolve-strategy>

For example, the tag http_default_8bit_tcp_resolve indicates the protocol http, a modifier default, a character width of 8bit, and a resolve strategy of tcp_resolve.

Synchronous Clients¶

Of the client tags shown in the table, the following makes the basic_client behave as a fully synchronous client.

  • http_default_8bit_tcp_resolve
  • http_default_8bit_udp_resolve
  • http_keepalive_8bit_tcp_resolve
  • http_keepalive_8bit_udp_resolve

The synchronous client implements all the operations of the client underneath the interface all block to wait for I/O to finish. All the member methods are synchronous and will block until the response object is ready or throws if errors are encountered in the performance of the HTTP requests.

Warning

The synchronous clients are NOT thread safe. You will need to do external synchronization to use synchronous client implementations.

Note

As of version 0.11, all the synchronous client implementations are deprecated. They will be removed in the next version of the library.

Asynchronous Clients¶

The following tags specify the basic_client to behave in an asynchronous manner:

  • http_async_8bit_tcp_resolve
  • http_async_8bit_udp_resolve

An asynchronous client implementation means that``basic_client<...>`` is an Active Object. This means that the client has and manages its own lifetime thread, and returns values that are asynchronously filled in. The response object encapsulates Boost.Thread futures which get filled in once the values are available.

The asynchronous clients implement all operations asynchronously which are hidden from the user. The interface is still synchronous but the fetching of data happens on a different thread.

Note

The asynchronous clients are thread safe, and can be shared across many threads. Each request starts a sequence of asynchronous operations dedicated to that request. The client does not re-cycle connections and uses a one-request-one-connection model.

When an asynchronous client object is destroyed, it waits for all pending asynchronous operations to finish. Errors encountered during operations on retrieving data from the response objects cause exceptions to be thrown – therefore it is best that if a client object is constructed, it should outlive the response object or be outside the try-catch block handling the errors from operations on responses. In code, usage should look like the following:

http::client client;
try {
  http::client::response response = client.get("http://www.example.com/");
  std::cout << body(response);
} catch (std::exception& e) {
  // deal with exceptions here
}

A common mistake is to declare the client inside the try block which invokes undefined behavior when errors arise from the handling of response objects. Previous examples cited by the documentation showed the short version of the code which didn’t bother moving the http::client object outside of the same try block where the request/response objects are being used.

Member Functions¶

In this section we assume that the following typedef is in effect:

typedef boost::network::http::basic_client<
    boost::network::http::tags::http_default_8bit_udp_resolve
    , 1
    , 1
    >
    client;

Also, that code using the HTTP client will have use the following header:

#include <boost/network/include/http/client.hpp>

Note

Starting version 0.9, cpp-netlib clients and server implementations by default now have an externally-linked component. This is a breaking change for code that used to rely on cpp-netlib being a header-only library, but can inhibited by defining the BOOST_NETWORK_NO_LIB preprocessor macro before including any cpp-netlib header.

Note

Starting version 0.11, cpp-netlib clients and server implementations no longer support the BOOST_NETWORK_NO_LIB option.

Constructors¶

The client implementation can be default constructed, or customized at initialization.

client()
Default constructor.
explicit client(client::options const &)
Constructor taking a client_options<Tag> object. The following table shows the options you can set on a client_options<Tag> instance.
Parameter Name Type Description
follow_redirects bool Boolean to specify whether the client should follow HTTP redirects. Default is false.
cache_resolved bool Boolean to specify whether the client should cache resolved endpoints. The default is false.
io_service shared_ptr<io_service> Shared pointer to a Boost.Asio io_service.
openssl_certificate string The filename of the certificate to load for the SSL connection for verification.
openssl_verify_path string The directory from which the certificate authority files are located.
always_verify_peer bool Boolean to specify whether the client should always verify peers in SSL connections
openssl_certificate_file string Filename of the certificate to use for client-side SSL session establishment.
openssl_private_key_file string Filename of the private key to use for client-side SSL session establishment.
timeout int Number of seconds to wait for client requests before considering a timeout has occurred.

To use the above supported named parameters, you’ll have code that looks like the following:

using namespace boost::network::http; // parameters are in this namespace
client::options options;
options.follow_redirects(true)
       .cache_resolved(true)
       .io_service(boost::make_shared<boost::asio::io_service>())
       .openssl_certificate("/tmp/my-cert")
       .openssl_verify_path("/tmp/ca-certs")
       .timeout(10);
client client_(options);
// use client_ as normal from here on out.

HTTP Methods¶

The client implementation supports various HTTP methods. The following constructs assume that a client has been properly constructed named client_ and that there is an appropriately constructed request object named request_ and that there is an appropriately constructed response object named response_ like the following:

using namespace boost::network::http;  // parameters are here
client client_();
client::request request_("http://cpp-netib.github.com/");
client::response response_;
response_ = client_.get(request_)
Perform an HTTP GET request.
response_ = client_.get(request_, callback)
Perform an HTTP GET request, and have the body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).
response_ = client_.head(request_)
Perform an HTTP HEAD request.
response_ = client_.post(request_)
Perform an HTTP POST, use the data already set in the request object which includes the headers, and the body.
response_ = client_.post(request_, callback)
Perform an HTTP POST request, and have the body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).
response_ = client_.post(request_, body)
Body is a string of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. The default content-type used is x-application/octet-stream.
response_ = client_.post(request_, body, callback)
Body is a string of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. The default content-type used is x-application/octet-stream. Have the response body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).
response_ = client_.post(request_, body, content_type)
The body and content_type parameters are of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. This uses the request object’s other headers.
response_ = client_.post(request_, body, content_type, callback)
The body and content_type parameters are of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. This uses the request object’s other headers. Have the response body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).
response_ = client_.post(request_, body, content_type, callback, streaming_callback)
The body and content_type parameters are of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. This uses the request object’s other headers. Have the response body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &). The streaming_callback argument should have a which has a signature of the form: bool(string_type&). The provided string_type& will be streamed as soon as the function returns. A return value of false signals the client that the most recent invocation is the last chunk to be sent.
response_ = client_.post(request_, streaming_callback)
Perform and HTTP POST request, and have the request’s body chunks be generated by the streaming_callback which has a signature of the form: bool(string_type&). The provided string_type& will be streamed as soon as the function returns. A return value of false signals the client that the most recent invocation is the last chunk to be sent.
response_ = client_.post(request_, callback, streaming_callback)
Perform an HTTP POST request, and have the body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &). This form also has the request’s body chunks be generated by the streaming_callback which has a signature of the form: bool(string_type&). The provided string_type& will be streamed as soon as the function returns. A return value of false signals the client that the most recent invocation is the last chunk to be sent.
response_ = client_.put(request_)
Perform an HTTP PUT, use the data already set in the request object which includes the headers, and the body.
response_ = client_.put(request_, callback)
Perform an HTTP PUT request, and have the body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).
response_ = client_.put(request_, body)
Body is a string of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. The default content-type used is x-application/octet-stream.
response_ = client_.put(request_, body, callback)
Body is a string of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. The default content-type used is x-application/octet-stream. Have the response body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).
response_ = client_.put(request_, body, content_type)
The body and content_type parameters are of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. This uses the request object’s other headers.
response_ = client_.put(request_, body, content_type, callback)
The body and content_type parameters are of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. This uses the request object’s other headers. Have the response body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).
response_ = client_.put(request_, body, content_type, callback, streaming_callback)
The body and content_type parameters are of type boost::network::string<Tag>::type where Tag is the HTTP Client’s Tag. This uses the request object’s other headers. Have the response body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &). This form also has the request’s body chunks be generated by the streaming_callback which has a signature of the form: bool(string_type&). The provided string_type& will be streamed as soon as the function returns. A return value of false signals the client that the most recent invocation is the last chunk to be sent
response_ = client_.put(request_, streaming_callback)
Perform and HTTP PUT request, and have the request’s body chunks be generated by the streaming_callback which has a signature of the form: bool(string_type&). The provided string_type& will be streamed as soon as the function returns. A return value of false signals the client that the most recent invocation is the last chunk to be sent.
response_ = client_.put(request_, callback, streaming_callback)
Perform an HTTP PUT request, and have the body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &). This form also has the request’s body chunks be generated by the streaming_callback which has a signature of the form: bool(string_type&). The provided string_type& will be streamed as soon as the function returns. A return value of false signals the client that the most recent invocation is the last chunk to be sent.
response_ = client_.delete_(request_)
Perform an HTTP DELETE request.
response_ = client_.delete_(request_, body_handler=callback)
Perform an HTTP DELETE request, and have the response body chunks be handled by the callback parameter. The signature of callback should be the following: void(iterator_range<char const *> const &, boost::system::error_code const &).

Client-Specific¶

client_.clear_resolved_cache()
Clear the cache of resolved endpoints.

Streaming Body Handler¶

As of v0.9.1 the library now offers a way to support a streaming body callback function in all HTTP requests that expect a body part (GET, PUT, POST, DELETE). A convenience macro is also provided to make callback handlers easier to write. This macro is called BOOST_NETWORK_HTTP_BODY_CALLBACK which allows users to write the following code to easily create functions or function objects that are compatible with the callback function requirements.

An example of how to use the macro is shown below:

struct body_handler {
    explicit body_handler(std::string & body)
    : body(body) {}

    BOOST_NETWORK_HTTP_BODY_CALLBACK(operator(), range, error) {
        // in here, range is the Boost.Range iterator_range, and error is
        // the Boost.System error code.
        if (!error)
            body.append(boost::begin(range), boost::end(range));
    }

    std::string & body;
};

// somewhere else
std::string some_string;
response_ = client_.get(request("http://cpp-netlib.github.com/"),
                        body_handler(some_string));

You can also use if for standalone functions instead if you don’t want or need to create a function object.

BOOST_NETWORK_HTTP_BODY_CALLBACK(print_body, range, error) {
    if (!error)
        std::cout << "Received " << boost::distance(range) << "bytes."
                  << std::endl;
    else
        std::cout << "Error: " << error << std::endl;
}

// somewhere else
response_ = client_.get(request("http://cpp-netlib.github.com/"),
                        print_body);

The BOOST_NETWORK_HTTP_BODY_CALLBACK macro is defined in boost/network/protocol/http/client/macros.hpp.

Table Of Contents

Previous topic

Reference Manual

Next topic

HTTP Request

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/reference/http_request.html000066400000000000000000000762511240331347200277100ustar00rootroot00000000000000 HTTP Request — cpp-netlib v0.11.1

Navigation

HTTP Request¶

This part of the documentation talks about the publicly accessible API of the HTTP Request objects. This section details the Request Concepts requirements, the implemented and required Directives, Modifiers, and Wrappers that work with the HTTP Request objects.

Request Concepts¶

There are two generally supported Request Concepts implemented in the library. The first of two is the Normal Client Request Concept and the second is the Pod Server Request Concept.

The Normal Client Request Concept is what the HTTP Client interface requires. All operations performed internally by the HTTP Client abide by the interface required by this concept definition.

The Pod Server Request Concept is as the name suggests what the HTTP Server implementation requires from Request Objects.

Switching on whether the Request concept chooses either of the Normal Client Request Concept or the Pod Server Request Concept is done through the nested tag type and whether that tag derives from the root tag pod. Simply, if the Request type’s nested tag type derives from boost::network::tags::pod then it chooses to enforce the Pod Server Request Concept, otherwise it chooses the Normal Client Request Concept.

Normal Client Request Concept¶

A type models the Normal Client Request Concept if it models the Message Concept and also supports the following constructs.

Legend

R:The request type.
r:An instance of R.
S:The string type.
s:An instance of S.
P:The port type.
p:An instance of P.
Construct Result Description
R::string_type S The nested string_type type.
R::port_type P The nested port_type type.
R r(s) NA Construct a Request with an s provided. This treats s as the URI to where the request is destined for.
host(request) Convertible to S Return the host to where the request is destined for.
port(request) Convertible to P Return the port to where the request is destined for.
path(request) Convertible to S Return the path included in the URI.
query(request) Convertible to S Return the query part of the URI.
anchor(request) Convertible to S Return the anchor part of the URI.
protocol(request) Convertible to S Return the protocol/scheme part of the URI.
r << uri(s) R& Set the URI of the request.
uri(r, s) void Set the URI of the request.

Pod Server Request Concept¶

A type models the Pod Server Request Concept if it models the Message Concept and also supports the following constructs.

Legend

R:The request type.
r:An instance of R.
S:The string type.
I:An unsigned 8 bit integer.
V:The vector type for headers.
Construct Result Description
R::string_type S The nested string_type type.
R::headers_container_type V The nested headers_container_type type.
r.source S The nested source of the request.
r.method S The method of the request.
r.destination S The destination of the request. This is normally the URI of the request.
r.version_major I The major version number part of the request.
r.version_minor I The minor version number part of the request.
r.headers V The vector of headers.
r.body S The body of the request.

Directives¶

This section details the provided directives that are provided by cpp-netlib. The section was written to assume that an appropriately constructed request instance is either of the following:

boost::network::http::basic_request<
  boost::network::http::tags::http_default_8bit_udp_resolve
> request;

// or

boost::network::http::basic_request<
  boost::network::http::tags::http_server
> request;

The section also assumes that there following using namespace declaration is in effect:

using namespace boost::network;

Directives are meant to be used in the following manner:

request << directive(...);

Warning

There are two versions of directives, those that are applicable to messages that support narrow strings (std::string) and those that are applicable to messages that support wide strings (std::wstring). The cpp-netlib implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases.

For now all the implemented directives are listed, even if some of them still do not implement things correctly.

unspecified source(std::string const & source_)
Create a source directive with a std::string as a parameter, to be set as the source of the request.
unspecified source(std::wstring const & source_)
Create a source directive with a std::wstring as a parameter, to be set as the source of the request.
unspecified destination(std::string const & source_)
Create a destination directive with a std::string as a parameter, to be set as the destination of the request.
unspecified destination(std::wstring const & source_)
Create a destination directive with a std::wstring as a parameter, to be set as the destination of the request.
unspecified header(std::string const & name, std::string const & value)
Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both std::string.
unspecified header(std::wstring const & name, std::wstring const & value)
Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both std::wstring.
unspecified remove_header(std::string const & name)
Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type std::string.
unspecified remove_header(std::wstring const & name)
Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type std::wstring.
unspecified body(std::string const & body_)
Create a body directive that will set the request’s body to the given parameter. In this case the type of the body is an std::string.
unspecified body(std::wstring const & body_)
Create a body directive that will set the request’s body to the given parameter. In this case the type of the body is an std::wstring.

Modifiers¶

This section details the provided modifiers that are provided by cpp-netlib.

template <class Tag> inline void source(basic_request<Tag> & request, typename string<Tag>::type const & source_)
Modifies the source of the given request. The type of source_ is dependent on the Tag specialization of basic_request.
template <class Tag> inline void destination(basic_request<Tag> & request, typename string<Tag>::type const & destination_)
Modifies the destination of the given request. The type of destination_ is dependent on the Tag specialization of basic_request.
template <class Tag> inline void add_header(basic_request<Tag> & request, typename string<Tag>::type const & name, typename string<Tag>::type const & value)
Adds a header to the given request. The type of the name and value parameters are dependent on the Tag specialization of basic_request.
template <class Tag> inline void remove_header(basic_request<Tag> & request, typename string<Tag>::type const & name)
Removes a header from the given request. The type of the name parameter is dependent on the Tag specialization of basic_request.
template <class Tag> inline void clear_headers(basic_request<Tag> & request)
Removes all headers from the given request.
template <class Tag> inline void body(basic_request<Tag> & request, typename string<Tag>::type const & body_)
Modifies the body of the given request. The type of body_ is dependent on the Tag specialization of basic_request.

Wrappers¶

This section details the provided request wrappers that come with cpp-netlib. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect:

using namespace boost::network;
using namespace boost::network::http;
template <class Tag> unspecified source(basic_request<Tag> const & request)
Returns a wrapper convertible to typename string<Tag>::type that provides the source of a given request.
template <class Tag> unspecified destination(basic_request<Tag> const & request)
Returns a wrapper convertible to typename string<Tag>::type that provides the destination of a given request.
template <class Tag> unspecified headers(basic_request<Tag> const & request)
Returns a wrapper convertible to typename headers_range<basic_request<Tag> >::type or typename basic_request<Tag>::headers_container_type that provides the headers of a given request.
template <class Tag> unspecified body(basic_request<Tag> const & request)
Returns a wrapper convertible to typename string<Tag>::type that provides the body of a given request.

Table Of Contents

Previous topic

HTTP Client API

Next topic

HTTP Response

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/reference/http_response.html000066400000000000000000001330121240331347200300430ustar00rootroot00000000000000 HTTP Response — cpp-netlib v0.11.1

Navigation

HTTP Response¶

This part of the documentation talks about the publicly accessible API of the HTTP Response objects. This section details the Response Concept requirements, the implemented and required Directives, Modifiers, and Wrappers that work with the HTTP Response objects.

Note

The HTTP server response object is a POD type, which doesn’t support any of the following details. There are only a few fields available in the HTTP server response type, which can be seen in boost/network/protocol/http/impl/response.ipp.

Response Concept¶

A type models the Response Concept if it models the Message Concept and also supports the following constructs.

Legend

R:The response type.
r:An instance of R.
S:The string type.
s,e,g:Instances of S.
P:The port type.
p:An instance of P.
V:The version type.
v:An instance of v.
T:The status type.
t:An instance of T.
M:The status message type.
m:An instance of M.
U:An unsigned 16-bit int.
u:An instance of U.

Note

In the table below, the namespace traits is an alias for boost::network::http::traits.

Construct Result Description
R::string_type S The nested string_type type.
traits::version<R>::type V The version type associated with R.
traits::status<R>::type T The status type associated with R.
traits::status_message<R>::type M The status message type associated with R.
r << version(v) R& Sets the version of r.
r << status(t) R& Sets the status of r.
r << status_message(m) R& Sets the status message of r.
version(r, v) void Sets the version of r.
status(r, t) void Sets the status of r.
status_message(r, m) void Sets the status message of r.
S e = version(r) NA Get the version of r.
U u = status(r) NA Get the status of r.
S g = status_message(r) NA Get the status message of r.

Directives¶

This section details the provided directives that are provided by cpp-netlib. The section was written to assume that an appropriately constructed response instance is either of the following:

boost::network::http::basic_response<
  boost::network::http::tags::http_default_8bit_udp_resolve
> response;

// or

boost::network::http::basic_response<
  boost::network::http::tags::http_server
> response;

The section also assumes that there following using namespace declaration is in effect:

using namespace boost::network;

Directives are meant to be used in the following manner:

response << directive(...);

Warning

There are four versions of directives, those that are applicable to messages that support narrow strings (std::string), those that are applicable to messages that support wide strings (std::wstring), those that are applicable to messages that support future-wrapped narrow and wide strings (boost::shared_future<std::string> and boost::shared_future<std::wstring>).

The cpp-netlib implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases.

For now all the implemented directives are listed, even if some of them still do not implement things correctly.

unspecified source(std::string const & source_)
Create a source directive with a std::string as a parameter, to be set as the source of the response.
unspecified source(std::wstring const & source_)
Create a source directive with a std::wstring as a parameter, to be set as the source of the response.
unspecified source(boost::shared_future<std::string> const & source_)
Create a source directive with a boost::shared_future<std::string> as a parameter, to be set as the source of the response.
unspecified source(boost::shared_future<std::wstring> const & source_)
Create a source directive with a boost::shared_future<std::wstring> as a parameter, to be set as the source of the response.
unspecified destination(std::string const & source_)
Create a destination directive with a std::string as a parameter, to be set as the destination of the response.
unspecified destination(std::wstring const & source_)
Create a destination directive with a std::wstring as a parameter, to be set as the destination of the response.
unspecified destination(boost::shared_future<std::string> const & destination_)
Create a destination directive with a boost::shared_future<std::string> as a parameter, to be set as the destination of the response.
unspecified destination(boost::shared_future<std::wstring> const & destination_)
Create a destination directive with a boost::shared_future<std::wstring> as a parameter, to be set as the destination of the response.
unspecified header(std::string const & name, std::string const & value)
Create a header directive that will add the given name and value pair to the headers already associated with the response. In this case the name and values are both std::string.
unspecified header(std::wstring const & name, std::wstring const & value)
Create a header directive that will add the given name and value pair to the headers already associated with the response. In this case the name and values are both std::wstring.
unspecified remove_header(std::string const & name)
Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the response. In this case the name of the header is of type std::string.
unspecified remove_header(std::wstring const & name)
Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the response. In this case the name of the header is of type std::wstring.
unspecified body(std::string const & body_)
Create a body directive that will set the response’s body to the given parameter. In this case the type of the body is an std::string.
unspecified body(std::wstring const & body_)
Create a body directive that will set the response’s body to the given parameter. In this case the type of the body is an std::wstring.
unspecified body(boost::shared_future<std::string> const & body_)
Create a body directive that will set the response’s body to the given parameter. In this case the type of the body is an boost::shared_future<std::string>.
unspecified body(boost::shared_future<std::wstring> const & body_)
Create a body directive that will set the response’s body to the given parameter. In this case the type of the body is an boost::shared_future<std::wstring>.
unspecified version(std::string const & version_)

Create a version directive that will set the response’s version to the given parameter. In this case the type of the version is an std::string.

Note that this version includes the full "HTTP/" string.

unspecified version(std::wstring const & version_)

Create a version directive that will set the response’s version to the given parameter. In this case the type of the version is an std::wstring.

Note that this version includes the full "HTTP/" string.

unspecified version(boost::shared_future<std::string> const & version_)

Create a version directive that will set the response’s version to the given parameter. In this case the type of the version is an boost::shared_future<std::string>.

Note that this version includes the full "HTTP/" string.

unspecified version(boost::shared_future<std::wstring> const & version_)

Create a version directive that will set the response’s version to the given parameter. In this case the type of the version is an boost::shared_future<std::wstring>.

Note that this version includes the full "HTTP/" string.

unspecified status_message(std::string const & status_message_)

Create a status_message directive that will set the response’s status_message to the given parameter. In this case the type of the status_message is an std::string.

Note that this status_message includes the full "HTTP/" string.

unspecified status_message(std::wstring const & status_message_)

Create a status_message directive that will set the response’s status_message to the given parameter. In this case the type of the status_message is an std::wstring.

Note that this status_message includes the full "HTTP/" string.

unspecified status_message(boost::shared_future<std::string> const & status_message_)

Create a status_message directive that will set the response’s status_message to the given parameter. In this case the type of the status_message is an boost::shared_future<std::string>.

Note that this status_message includes the full "HTTP/" string.

unspecified status_message(boost::shared_future<std::wstring> const & status_message_)

Create a status_message directive that will set the response’s status_message to the given parameter. In this case the type of the status_message is an boost::shared_future<std::wstring>.

Note that this status_message includes the full "HTTP/" string.

unspecified status(boost::uint16_t status_)
Create a status directive that will set the response’s status to the given parameter. In this case the type of status_ is boost::uint16_t.
unspecified status(boost::shared_future<boost::uint16_t> const & status_)
Create a status directive that will set the response’s status to the given parameter. In this case the type of status_ is boost::shared_future<boost::uint16_t>.

Modifiers¶

This section details the provided modifiers that are provided by cpp-netlib.

template <class Tag> inline void source(basic_response<Tag> & response, typename string<Tag>::type const & source_)
Modifies the source of the given response. The type of source_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void source(basic_response<Tag> & response, boost::shared_future<typename string<Tag>::type> const & source_)
Modifies the source of the given response. The type of source_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void destination(basic_response<Tag> & response, typename string<Tag>::type const & destination_)
Modifies the destination of the given response. The type of destination_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void destination(basic_response<Tag> & response, boost::shared_future<typename string<Tag>::type> const & destination_)
Modifies the destination of the given response. The type of destination_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void add_header(basic_response<Tag> & response, typename string<Tag>::type const & name, typename string<Tag>::type const & value)
Adds a header to the given response. The type of the name and value parameters are dependent on the Tag specialization of basic_response.
template <class Tag> inline void remove_header(basic_response<Tag> & response, typename string<Tag>::type const & name)
Removes a header from the given response. The type of the name parameter is dependent on the Tag specialization of basic_response.
template <class Tag> inline void headers(basic_response<Tag> & response, typename headers_container<basic_response<Tag> >::type const & headers_)
Sets the whole headers contained in response as the given parameter headers_.
template <class Tag> inline void headers(basic_response<Tag> & response, boost::shared_future<typename headers_container<basic_response<Tag> >::type> const & headers_)
Sets the whole headers contained in response as the given parameter headers_.
template <class Tag> inline void clear_headers(basic_response<Tag> & response)
Removes all headers from the given response.
template <class Tag> inline void body(basic_response<Tag> & response, typename string<Tag>::type const & body_)
Modifies the body of the given response. The type of body_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void body(basic_response<Tag> & response, boost::shared_future<typename string<Tag>::type> const & body_)
Modifies the body of the given response. The type of body_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void version(basic_response<Tag> & response, typename traits::version<basic_response<Tag> >::type const & version_)
Modifies the version of the given response. The type of version_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void status(basic_response<Tag> & response, typename traits::status<basic_response<Tag> >::type const & status_)
Modifies the status of the given response. The type of status_ is dependent on the Tag specialization of basic_response.
template <class Tag> inline void status_message(basic_response<Tag> & response, typename traits::status_message<basic_response<Tag> >::type const & status_message_)
Modifies the status message of the given response. The type of status_message_ is dependent on the Tag specialization of basic_response.

Wrappers¶

This section details the provided response wrappers that come with cpp-netlib. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect:

using namespace boost::network;
using namespace boost::network::http;
template <class Tag> unspecified source(basic_response<Tag> const & response)
Returns a wrapper convertible to typename string<Tag>::type that provides the source of a given response.
template <class Tag> unspecified destination(basic_response<Tag> const & response)
Returns a wrapper convertible to typename string<Tag>::type that provides the destination of a given response.
template <class Tag> unspecified headers(basic_response<Tag> const & response)
Returns a wrapper convertible to typename headers_range<basic_response<Tag> >::type or typename basic_response<Tag>::headers_container_type that provides the headers of a given response.
template <class Tag> unspecified body(basic_response<Tag> const & response)
Returns a wrapper convertible to typename string<Tag>::type that provides the body of a given response.
template <class Tag> unspecified version(basic_response<Tag> const & response)
Returns a wrapper convertible to typename string<Tag>::type that provides the version of the given response.
template <class Tag> unspecified status(basic_response<Tag> const & response)
Returns a wrapper convertible to typename boost::uint16_t that provides the status of the given response.
template <class Tag> unspecified status_message(basic_response<Tag> const & response)
Returns a wrapper convertible to typename string<Tag>::type that provides the status message of the given response.

Table Of Contents

Previous topic

HTTP Request

Next topic

HTTP Server API

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/reference/http_server.html000066400000000000000000001547731240331347200275340ustar00rootroot00000000000000 HTTP Server API — cpp-netlib v0.11.1

Navigation

HTTP Server API¶

General¶

cpp-netlib includes and implements two distinct HTTP server implementations that you can use and embed in your own applications. Both HTTP Server implementations:

  • Cannot be copied. This means you may have to store instances of the HTTP Server in dynamic memory if you intend to use them as function parameters or pass them around in smart pointers of by reference.
  • Assume that requests made are independent of each other. None of the HTTP Server implementations support request pipelining (yet) so a single connection only deals with a single request.
  • Are header-only and are compiled-into your application. Future releases in case you want to upgrade the implementation you are using in your application will be distributed as header-only implementations, which means you have to re-compile your application to use a newer version of the implementations.

The HTTP Servers have different semantics, and in some cases require different APIs from the supplied template parameters.

Implementations¶

There are two different user-facing template classes that differentiate the Synchronous Servers from the Asynchronous Servers. Both templates take a single template parameter named Handler which describes the type of the Handler function object.

There are two different Handler concepts, one concept for Synchronous Servers and another for Asynchronous Servers.

The SynchronousHandler concept for Synchronous Servers is described by the following table:

Legend:

H
The Handler type.
h
An instance of H.
Req
A type that models the Request Concept.
Res
A type that models the Response Concept.
req
An instance of Req.
res
An instance of Res.
Construct Return Type Description
h(req,res) void Handle the request; res is passed in as a non-const lvalue, which represents the response to be returned to the client performing the request.

More information about the internals of the Synchronous Servers can be found in the following section.

The AsynchronousHandler concept for Asynchronous Servers is described by the following table:

Legend:

H
The Handler type.
h
An instance of H.
Req
A type that models the Request Concept.
ConnectionPtr
A type that models the Connection Pointer Concept.
req
An instance of Req.
conn
An instance of ConncetionPtr.
Construct Return Type Description
h(req, conn) void Handle the request; conn is a shared pointer which exposes functions for writing to and reading from the connection.

More information about the internals of the Asynchronous Servers can be found in the following section.

Synchronous Servers¶

The synchronous server implementation is represented by the template server in namespace boost::network::http. The server template takes in a single template parameter named Handler which models the SynchronousHandler concept (described above).

An instance of Handler is taken in by reference to the constructor of the HTTP server. This means the Handler is not copied around and only a single instance of the handler is used for all connections and requests performed against the HTTP server.

Warning

It is important to note that the HTTP server does not implement any locking upon invoking the Handler. In case you have any state in the Handler that will be associated with the synchronous server, you would have to implement your own synchronization internal to the Handler implementation. This matters especially if you run the synchronous server in multiple threads.

The general pattern of usage for the HTTP Server template is shown below:

struct handler;
typedef boost::network::http::server<handler> http_server;

struct handler {
    void operator()(
        http_server::request const & req,
        http_server::response & res
    ) {
        // do something, and then edit the res object here.
    }
};

More information about the actual HTTP Server API follows in the next section. It is important to understand that the HTTP Server is actually embedded in your application, which means you can expose almost all your application logic through the Handler type, which you can also initialize appropriately.

API Documentation¶

The following sections assume that the following file has been included:

#include <boost/network/include/http/server.hpp>

And that the following typedef’s have been put in place:

struct handler_type;
typedef boost::network::http::server<handler_type> http_server;

struct handler_type {
    void operator()(http_server::request const & request,
                    http_server::response & response) {
        // do something here
    }
};

Constructor¶

explicit http_server(options)
Construct an HTTP Server instance, passing in a server_options<Tag, Handler> object. The following table shows the supported options in server_options<Tag, Handler>.
Parameter Name Type Description
address string_type The hostname or IP address from which the server should be bound to. This parameter is required.
port string_type The port to which the server should bind and listen to. This parameter is required.
thread_pool shared_ptr<thread_pool> A shared pointer to an instance of boost::network::utils::thread_pool – this is the thread pool from where the handler is invoked. This parameter is only applicable and required for async_server instances.
io_service shared_ptr<io_service> An optional lvalue to an instance of boost::asio::io_service which allows the server to use an already-constructed boost::asio::io_service instance instead of instantiating one that it manages.
reuse_address bool A boolean that specifies whether to re-use the address and port on which the server will be bound to. This enables or disables the socket option for listener sockets. The default is false.
report_aborted bool A boolean that specifies whether the listening socket should report aborted connection attempts to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for future-proofing the code in case an optional error handler function is supported in later releases of cpp-netlib. The default is false.
receive_buffer_size int The size of the socket’s receive buffer. The default is defined by Boost.Asio and is platform-dependent.
send_buffer_size int The size of the socket’s send buffer. The default is defined by Boost.Asio and is platform-dependent.
receive_low_watermark int The size of the socket’s low watermark for its receive buffer. The default is defined by Boost.Asio and is platform-dependent.
send_buffer_size int The size of the socket’s send low watermark for its send buffer. The default is defined by Boost.Asio and is platform-dependent.
non_blocking_io bool An optional bool to define whether the socket should use non-blocking I/O in case the platform supports it. The default is true.
linger bool An optional bool to determine whether the socket should linger in case there’s still data to be sent out at the time of its closing. The default is true.
linger_timeout int An optional int to define the timeout to wait for socket closes before it is set to linger. The default is 0.
context shared_ptr<context> An optional shared pointer to an instance of boost::asio::ssl::context – this contains the settings needed to support SSL. This parameter is only applicable for async_server instances.

To use the above supported named parameters, you’ll have code that looks like the following:

using namespace boost::network::http; // parameters are in this namespace
handler handler_instance;
sync_server<handler>::options options(handler_instance);
options.address("0.0.0.0")
       .port("80")
       .io_service(boost::make_shared<boost::asio::io_service>())
       .reuse_address(true);
sync_server<handler> instance(options);
instance.run();

Public Members¶

The following definitions assume that a properly constructed http_server instance has been constructed in the following manner:

handler_type handler;
http_server::options options(handler);
http_server server(options.address("127.0.0.1").port("8000"));
server.run()
Run the HTTP Server event loop. This function can be run on multiple threads following the example:
boost::thread t1(boost::bind(&http_server::run, &server));
boost::thread t2(boost::bind(&http_server::run, &server));
server.run();
t1.join();
t2.join();
server.stop()
Stop the HTTP Server acceptor and wait for all pending requests to finish.

Response Object¶

The response object has its own public member functions which can be very helpful in certain simple situations.

response = http_server::response::stock_reply(status, body)
Code like the above should go inside the handler’s operator() overload. The body parameter is an std::string. The status parameter is any of the following values from the http_server::response enum status_type:
enum status_type {
    ok = 200,
    created = 201,
    accepted = 202,
    no_content = 204,
    multiple_choices = 300,
    moved_permanently = 301,
    moved_temporarily = 302,
    not_modified = 304,
    bad_request = 400,
    unauthorized = 401,
    forbidden = 403,
    not_found = 404,
    not_supported = 405,
    not_acceptable = 406,
    internal_server_error = 500,
    not_implemented = 501,
    bad_gateway = 502,
    service_unavailable = 503
};

The response object also has the following publicly accessible member values which can be directly manipulated by the handler.

Member Name Type Description
status status_type The HTTP status of the response.
headers vector<header> Vector of headers. [1]
content string_type [2] The contents of the response.
[1]A header is a struct of type response_header<http::tags::http_server>. An instance always has the members name and value both of which are of type string_type.
[2]string_type is boost::network::string<http::tags::http_server>::type.

Asynchronous Servers¶

The asynchronous server implementation is significantly different to the synchronous server implementation in three ways:

  1. The Handler instance is invoked asynchronously. This means the I/O thread used to handle network-related events are free to handle only the I/O related events. This enables the server to scale better as to the number of concurrent connections it can handle.
  2. The Handler is able to schedule asynchronous actions on the thread pool associated with the server. This allows handlers to perform multiple asynchronous computations that later on perform writes to the connection.
  3. The Handler is able to control the (asynchronous) writes to and reads from the HTTP connection. Because the connection is available to the Handler, that means it can write out chunks of data at a time or stream data through the connection continuously.

The asynchronous server is meant to allow for better scalability in terms of the number of concurrent connections and for performing asynchronous actions within the handlers. If your application does not need to write out information asynchronously or perform potentially long computations, then the synchronous server gives a generally better performance profile than the asynchronous server.

The asynchronous server implementation is available from a single user-facing template named async_server. This template takes in a single template parameter which is the type of the Handler to be called once a request has been parsed from a connection.

An instance of Handler is taken as a reference to the constructor similar to the synchronous server implementation.

Warning

The asynchronous server implementation, like the synchronous server implementation, does not perform any synchronization on the calls to the Handler invocation. This means if your handler contains or maintains internal state, you are responsible for implementing your own synchronization on accesses to the internal state of the Handler.

The general pattern for using the async_server template is shown below:

struct handler;
typedef boost::network::http::async_server<handler> http_server;

struct handler {
    void operator()(
        http_server::request const & req,
        http_server::connection_ptr connection
    ) {
        // handle the request here, and use the connection to
        // either read more data or write data out to the client
    }
};

API Documentation¶

The following sections assume that the following file has been included:

#include <boost/network/include/http/server.hpp>
#include <boost/network/utils/thread_pool.hpp>

And that the following typedef’s have been put in place:

struct handler_type;
typedef boost::network::http::server<handler_type> http_server;

struct handler_type {
    void operator()(http_server::request const & request,
                    http_server::connection_ptr connection) {
        // do something here
    }
};

Constructor¶

explicit http_server(options)
Construct an HTTP server instance passing in a server_options<Tag, Handler> instance.

Public Members¶

The following definitions assume that a properly constructed http_server instance has been constructed in the following manner:

handler_type handler;
http_server::options options(handler);
options.thread_pool(boost::make_shared<boost::network::utils::thread_pool>(2));
http_server server(options.address("127.0.0.1").port("8000"));
server.run()
Run the HTTP Server event loop. This function can be run on multiple threads following the example:
boost::thread t1(boost::bind(&http_server::run, &server));
boost::thread t2(boost::bind(&http_server::run, &server));
server.run();
t1.join();
t2.join();
server.stop()
Stop the HTTP Server acceptor and wait for all pending requests to finish.

Connection Object¶

The connection object has its own public member functions which will be the primary means for reading from and writing to the connection.

template <class Range> write(Range range)

The connection object exposes a function write that can be given a parameter that adheres to the Boost.Range Single Pass Range Concept. The write function, although it looks synchronous, starts of a series of asynchronous writes to the connection as soon as the range is serialized to appropriately sized buffers.

To use this in your handler, it would look something like this:

connection->write("Hello, world!");
std::string sample = "I have a string!";
connection->write(sample);
template <class Range, class Callback> void write(Range range, Callback callback)
The connection object also exposes a function write that can be given a parameter that adheres to the Boost.Range Single Pass Range Concept, as well as a Callback function that returns void and takes a boost::system::error_code as a parameter. This overload of write is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory right away.
template <class ReadCallback> void read(ReadCallback callback)

The connection object has a function read which can be used to read more information from the connection. This read function takes in a callback that can be assigned to a Boost.Function with the signature void(input_range,error_code,size_t,connection_ptr). The following list shows what the types actually mean:

  • input_range – boost::iterator_range<char const *> : The range that denotes the data read from the connection.
  • error_code – boost::system::error_code : The error code if there were any errors encountered from the read.
  • size_t – std::size_t : The number of bytes transferred.
  • connection_ptr – http_server::connection_ptr : A handle to the current connection, so that it is kept alive at the time of the read callback invocation.

This interface is useful when doing reads of uploaded data that can be potentially large and may not fit in memory. The read handler is then responsible for dealing with the chunks of data available from the connection.

void set_status(status_t new_status)
The set_status function takes a parameter of type status_t which is an enum type nested in http_status::connection which is given in the following code listing.
enum status_t {
    ok = 200
    , created = 201
    , accepted = 202
    , no_content = 204
    , multiple_choices = 300
    , moved_permanently = 301
    , moved_temporarily = 302
    , not_modified = 304
    , bad_request = 400
    , unauthorized = 401
    , forbidden = 403
    , not_found = 404
    , not_supported = 405
    , not_acceptable = 406
    , internal_server_error = 500
    , not_implemented = 501
    , bad_gateway = 502
    , service_unavailable = 503
};

Note

You may set and re-set the status several times as long as you have not set the headers or sent data through the connection. If you do this after data has already been set, the function will throw an instance of std::logic_error.

template <class Range> void set_headers(Range range)

The set_headers function takes a Single Pass Range of boost::network::http::response_header<http::tags::http_async_server> instances and linearizes them to a buffer with at most BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE and immediately schedules an asynchronous write once that is done.

The function throws an instance of std::logic_error if you try to set the headers for a connection more than once.

Adding SSL support to Asynchronous Server¶

In order to setup SSL support for an Asynchronous Server, it is best to start from a regular Asynchronous Server (see above). Once this server is setup, SSL can be enabled by adding a Boost.Asio.Ssl.Context to the options. The settings that can be used are defined in the link.

// Initialize SSL context
boost::shared_ptr<boost::asio::ssl::context> ctx = boost::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);
ctx->set_options(
            boost::asio::ssl::context::default_workarounds
            | boost::asio::ssl::context::no_sslv2
            | boost::asio::ssl::context::single_dh_use);

// Set keys
ctx->set_password_callback(password_callback);
ctx->use_certificate_chain_file("server.pem");
ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem);
ctx->use_tmp_dh_file("dh512.pem");

handler_type handler;
http_server::options options(handler);
options.thread_pool(boost::make_shared<boost::network::utils::thread_pool>(2));
http_server server(options.address("127.0.0.1").port("8442").context(ctx));

std::string password_callback(std::size_t max_length, boost::asio::ssl::context_base::password_purpose purpose) {
    return std::string("test");
}

Table Of Contents

Previous topic

HTTP Response

Next topic

References

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/references.html000066400000000000000000000125101240331347200253300ustar00rootroot00000000000000 References — cpp-netlib v0.11.1

Navigation

References¶

Other sources¶

Table Of Contents

Previous topic

HTTP Server API

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/search.html000066400000000000000000000063621240331347200244640ustar00rootroot00000000000000 Search — cpp-netlib v0.11.1

Navigation

Search

Please activate JavaScript to enable the search functionality.

From here you can search these documents. Enter your search words into the box below and click "search". Note that the search function will automatically search for all of the words. Pages containing fewer words won't appear in the result list.

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/searchindex.js000066400000000000000000000565351240331347200251730ustar00rootroot00000000000000Search.setIndex({objects:{},terms:{directive_typ:7,all:[6,21,20,15,8,24,9,23,18,25,2,17,7,16,22,10],code:[6,13,14,15,8,24,9,21,25,20,26,10,11,7,16,4,22],skeleton:11,chain:7,illustr:11,queri:[14,23,13,3],forbidden:10,lack:26,icmp:18,basic_messag:[18,4,12],four:17,sync_serv:10,appropri:[23,21,24,10,17],concept:[23,0,18,10,17,7,3,4,12],follow:[21,14,15,8,24,9,11,23,18,25,2,17,7,3,16,10],lookup:18,ptr:16,abid:[23,7],"7zip":21,hierarch:3,whose:11,decid:[16,26,11],arg:6,"const":[6,23,13,14,8,24,18,20,10,17,7,25],system:[24,7,10,21],boost_network_http_body_callback:24,pem:10,base_uri:13,unpack:21,tweet:13,base64:22,interact:21,send:[10,15],program:[6,8,16,2,3,26],swap:[18,3,11],under:[6,13],sens:[24,7,19,25],set:[12,21,13,8,24,9,23,18,10,17,7,16,2],stock_repli:[6,10,8,25],xcode:22,introduc:[24,13,14,15,22],sourc:[23,8,15,18,25,1,17,26,21,4,22],everi:[26,18],string:[6,23,14,15,8,24,9,11,18,10,17,3,25],straightforward:[6,8],fals:[24,10],"void":[6,23,8,24,16,11,18,10,17,3,25],multi:8,nich:26,netlib:[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20,21,22,23,24,25,26],endpoint:24,fan:21,pipelin:10,failur:22,veri:[14,10,22],join:[6,10,21],default_:[16,25,11],exact:[13,25],relev:9,default_workaround:10,span:12,http_async_serv:10,administr:8,level:[21,26],openssl_certif:24,list:[6,23,13,8,17,10,11,20,21],upload:10,iter:25,factori:[16,7,18],"try":[13,14,8,24,9,10,20],vector:[23,10,11],verif:24,cooki:24,refer:[6,0,8,24,18,25,1,10,7,3,21,4,22],directiven:7,impli:18,work:[23,21,17],tel:3,throught:15,ten:6,core:18,natur:7,yourself:21,direct:[12,23,13,15,0,18,26,17,7,4,5],transform:[7,18],cppnetlib_include_dir:21,handler_typ:10,second:[24,23,25],cost:22,design:[6,2],pass:[20,8,15,24,9,18,10,11,7],download:[6,21,4],further:[3,15],cat:14,port:[6,23,14,8,9,10,17,3,22],append:24,compat:24,index:14,what:[6,23,13,14,8,24,9,18,10,11,20,16,4,22],msysgit:21,barrier:26,repli:8,section:[24,23,18,10,17],advanc:5,abl:[10,21],sln:21,overload:[10,8,25],access:[23,20,14,9,25,10,17,7,26],delet:[24,15,25],version:[6,23,15,24,16,11,18,10,17,3,21,4,22],source_wrapp:18,always_verify_p:24,underneath:[24,22],"new":[6,13,14,16,11,7,3,21,4,22],liter:[1,12],boost:[6,23,13,14,15,8,24,9,11,22,25,26,10,17,20,3,21,4,19],method:[23,8,15,24,4,25],xml:[9,20],full:[6,21,17],hash:13,deriv:[16,23],absolut:3,gener:[6,23,0,24,16,18,26,1,10,7,3,21,4,12],never:26,unauthor:10,privat:[24,22],here:[13,14,8,15,24,16,10,3,25],boost_network_http_client_default_tag:22,bodi:[6,23,13,14,15,8,24,9,11,18,10,17,25,4,22],subvers:21,explicitli:24,let:[9,21,8,11],argv:[6,13,14,8,15,9,20],address:[6,8,24,9,1,10,25,19],path:[14,23,3,21],along:21,becom:26,modifi:[23,13,0,24,18,17,4,12],sinc:[9,15,11],valu:[23,13,8,24,16,18,10,17,25,19],wait:[24,10],search:[13,22,2,4,21],produc:21,convers:18,forum:21,shift:7,anymor:11,larger:2,ctx:10,host:[14,23,3,21,8],breakag:22,branch:[20,21],sensit:22,cert:24,cerr:[6,13,14,8,9,20,25],behav:24,mitig:22,http_keepalive_8bit_tcp_resolv:[24,19,25],non_blocking_io:10,http_client:[15,25],implement:[6,23,14,0,24,16,11,22,18,25,10,19,17,7,3,21,4,12],narrow:[23,17],range_iter:25,portabl:[6,26],overrid:22,semant:[16,7,10,18],via:[6,9],repositori:[6,21],solut:21,multiple_choic:10,expect:24,filenam:[24,14],ipp:[8,17],api:[23,13,0,24,10,17,4,22],single_dh_us:10,visibl:25,instabl:22,instal:[21,22],txt:21,establish:24,unit:22,regex:21,argc:[13,14,8,15,9,20],from:[6,23,13,14,15,8,24,9,11,18,25,20,10,17,7,3,21,22],describ:[24,5,3,2,10],would:[8,18,10,11,21,25],commun:[6,2,26],sake:15,fstream:14,doubl:3,doesn:[22,17],upgrad:[10,22],next:[14,15,24,9,10,20],get_filenam:14,few:[21,17],handler:[6,8,24,16,10,25,4,22],call:[8,24,18,25,10,11,7,21,22],usr:21,recommend:21,taken:10,clear_head:[23,18,17],type:[23,24,16,17,18,25,10,11,7,3,26],until:24,minor:[24,23],more:[6,13,9,18,26,10,20,21,4,22],reachabl:11,chapter:5,headers_rang:[23,25,17],afford:7,share:[24,25,10,8,19],swappabl:[18,3,11],relat:10,c_str:[13,14],notic:[25,11],warn:[6,23,24,18,10,17,21],visual:21,depth:[6,4,12],include_directori:21,simple_wget:14,known:[3,21,22],central:18,hold:[24,19,25],olymp:13,cach:24,content_typ:24,must:[21,22],account:21,dcmake_c_compil:21,retriev:[23,14,24,18,17,3],internal_server_error:10,scalabl:10,alia:17,setup:10,linger:10,uniqu:16,histori:[4,26],annoi:26,remain:[16,7],minimum:6,can:[6,21,13,14,15,8,24,9,11,18,25,2,17,7,3,16,10],caveat:21,socket:10,about:[6,23,8,1,10,17,21,4],purpos:[10,21],root:[23,21,11],fetch:24,aliv:[24,25,10,19],proof:10,control:[21,10,11],heart:25,encapsul:[25,24,7,19,18],stream:[13,15,24,10,3,4,22],give:10,process:[25,3,22],lock:10,sudo:21,smtp:[26,18],indic:[24,19,25],high:26,tag:[6,23,13,24,16,11,18,25,10,19,17,22,3,4,5],want:[6,21,24,16,18,10,11,9,4],http_async_8bit_udp_resolv:[24,25,19,22],tarbal:21,phrase:13,serial:[10,22],keep:[20,24,16,19,11,7,25],unsign:[24,23,25,17],occur:[24,23,17],risk:21,low:10,alwai:[24,22,10,21],differenti:[10,8],put:[24,25,10,22],end:[25,24,26,22],goal:26,secur:24,programmat:22,myapplic:21,uri_io:3,classifi:3,write:[6,24,9,10,22,26],how:[8,24,9,2,11,3,21],foreach:20,pure:[16,18],subdirectori:15,opt:21,verifi:24,simpl:[6,20,14,15,8,9,22,18,25,2,7,3,4,10],mpl:[22,11],stock:8,follow_redirect:24,resourc:[14,21,8],getstr:13,remove_head:[23,18,17],clone:[14,21],after:[3,10,15],hello_world_cli:9,came:25,constraint:26,status_messag:17,befor:[24,9,10,22],xzf:21,password_callback:10,commit:[20,26],mai:[8,24,18,10,21,25],multipl:10,shared_ptr:[24,10],data:[24,9,18,10,25,3,22],parallel:21,hoc:22,util:10,forc:24,github:[6,24,20,3,21,26],reuse_address:10,practic:[9,20,2],third:8,date_tim:21,ani:[13,8,15,24,16,18,10,17,21,22],light:[6,26],valid:[22,21,18],author:[24,3],explicit:[24,10,18],correspond:6,use_private_key_fil:10,element:3,issu:[6,21,4,22],inform:[6,22,10,21],"switch":[16,23],maintain:[7,10],environ:[21,8],allow:[6,13,15,24,16,18,10,11,7,22],anoth:[3,10],mechan:[25,11],other:[6,24,18,1,10,11,7,4,26],order:[7,10,15,22],talk:[23,17],serv:11,feed:[20,2,4,22],composit:11,help:10,xmpp:[26,18],offici:[6,21,4],move:[24,7],becaus:[16,7,10,18],receive_buffer_s:10,cross:26,ofstream:14,paper:1,through:[6,23,25,10,21],server_opt:10,use_certificate_chain_fil:10,affect:24,size_t:[14,10],still:[23,24,17,10,11,21,22],vari:[16,18,11],dynam:[24,16,10,4,5],paramet:[23,24,17,18,25,10,11,7,21,22],divis:18,style:[14,3],group:[6,21,26],fit:10,fix:22,atom_read:[20,4],complex:[13,3,21,15],twitter:[13,2,4,22],unsupported_tag:11,better:[22,10,21],platform:[22,26,10,21],window:[21,4,22],pend:[24,10],mail:[6,21],hidden:[24,7],main:[6,13,14,15,8,9,20,3,21],might:[25,11],easier:[24,18],non:[21,22,3,10,18],multimap:25,"return":[23,13,14,15,8,24,9,18,25,20,10,17,7,3,16,22,19],greater:[15,8],thei:[24,18,19,11,3,21,25],output:3,handl:[24,16,10,8],smarter:11,safe:[24,8],initi:[24,26,10,22],"break":[24,16,22],framework:[8,18],facilit:16,instead:[24,22,10,11],find_last_of:14,now:[23,8,24,17,20,21,22],discuss:[6,21],nor:18,choic:21,term:[24,10,18],document:[23,13,0,24,9,10,17,21,4,22],somewher:24,name:[23,14,24,18,10,17,25,21,22],from_user_nam:13,realist:2,edit:10,config:22,didn:24,default_tag:11,separ:[21,22],easili:[24,26],slide:1,submit:[21,26],http_server:[6,23,10,17],timeout:[24,10,22],each:[15,24,18,10,20,21],debug:21,found:[13,8,15,10,21,26],complet:[21,15],side:[24,16,8,22],mean:[24,21,22,10,18],compil:[24,7,10,22,21],dcmake_cxx_compil:21,weight:[6,26],michael:26,chunk:[24,10,22],continu:[6,10,26],functor:[8,25],realli:9,heavi:[21,22],ensur:[18,8,11],set_statu:10,"static":[24,16,22,11,7,21,4,5],connect:[6,15,24,16,21,25,10,20,9,22,19],someth:[25,18,7,10,11],our:[6,26,21,11],happen:24,unique_ptr:16,orient:[16,7],special:[23,16,17,18,11,7,4,25],out:[6,24,10,21],variabl:21,ftp:[3,26],shown:[24,10],them:[23,21,24,10,17],safeti:11,network:[6,23,13,14,15,8,24,9,11,18,25,26,2,17,20,3,21,4,10],webservic:9,cppnetlib:[21,22],open:26,req:10,publish:20,rational:7,profil:10,unsupport:22,adapt:18,rel:3,reader:[20,2,4],print:[20,15,25],correct:[16,25,18],common:[24,26,2,15,18],model:[23,24,18,10,17,7,21],earlier:[9,16],iostream:[13,14,15,8,9,20,7,3],linear:10,insid:[24,10,25],watermark:10,migrat:26,basic_cli:[24,25],manipul:[10,18],situat:[24,16,7,10],differ:[23,14,0,24,16,11,18,10,17,7,3,21,22,12],free:[10,18],standard:[7,26,22],standalon:[24,16],base:[13,24,16,18,11,7,3,21,22],latest:[6,21],releas:[23,13,24,18,10,17,21,4,22],org:[6,14,15,3,21,25],"byte":[24,10],version_minor:[24,23,19,25],bash:3,thrown:24,netib:24,chose:18,your:[24,25,10,21],suffici:21,thread:[8,24,10,19,22,25],question:[6,21],prescrib:21,synchron:[8,0,24,19,25,10,4,22],openssl:[24,21],unavoid:16,thing:[23,14,15,16,17,11,21],enforc:23,place:10,outsid:[24,21,15],boost_network_http_server_connection_header_buffer_max_s:10,some_xml_str:9,undergo:6,assign:[3,10,18],first:[23,8,15,16,18,20,3,21,25],origin:[25,11],softwar:26,major:[24,23,26],attent:7,directli:[24,10],onc:[24,21,10,15,11],twitter_search:[13,4],independ:[24,7,10],qualiti:26,number:[23,8,24,18,19,11,25,21,10],placehold:11,date:21,instruct:[21,15],alreadi:[23,24,10,17,26,22],done:[23,16,18,10,11,21,25],wrapper:[23,0,18,25,17,12,4,22],body_:[6,23,17],stabl:[6,21],custom:[24,21],miss:26,predefin:25,size:[13,10],client_fwd:22,given:[23,13,16,17,18,10,11,3,25],"long":10,com:[6,13,24,9,20,3,21],convent:15,width:24,associ:[23,24,17,18,10,11],top:[21,26],mkdir:21,sometim:[18,11],least:21,grow:6,max_length:10,master:20,accept:[6,7,10,22],interfac:[23,14,0,24,25,10,19,7,22],choos:[24,23,21,18],scheme:[14,23,3],zipfil:21,cite:[24,14],store:[24,10,18],listen:[10,8,22],adher:10,udp:[24,19,25],shell:[9,21,8],consol:[20,15],option:[6,24,10,26,21,22],especi:10,namespac:[6,23,13,14,15,8,24,9,11,10,17,20,3,25],travi:22,tool:21,copi:[14,24,18,10,3,22],specifi:[14,15,24,18,19,25,3,21,10],aptli:25,"short":[24,22],pars:[13,14,25,10,20,3,22],mostli:21,attempt:[10,22],than:[10,11],rss:[20,22],std:[6,23,13,14,15,8,24,9,11,10,17,20,3,25],wide:[23,17],kind:[16,2],john:3,target:[7,26],instanc:[23,24,17,18,10,11,3,25],clariti:15,hpp:[13,14,15,8,24,9,10,11,20,3,22],remov:[24,23,18,22,17],dive:[13,14,8,15,9,20,4],requesthandl:25,structur:[15,11],"final":[15,22],project:[6,26,21,4,22],matter:10,reus:7,not_accept:10,boil:7,str:9,opaqu:[3,11],similar:[20,14,24,9,18,25,10,11,7,19],typic:[25,21,18],rapidxml:20,iterator_rang:[24,10],seri:[2,10],pre:[8,12],"function":[13,14,0,24,16,22,18,25,26,10,11,7,4,12],fashion:7,payload:[9,18],abov:[13,14,8,24,10,11,25,3,21,19],pertain:18,add_head:[23,18,17],modern:6,openssl_private_key_fil:24,packag:21,properli:[24,10],manner:[24,23,11,10,17],have:[21,13,8,24,16,18,25,26,10,11,7,9,22,19],tabl:[6,24,18,10,17,25],need:[8,15,24,16,2,11,26,21,10],seen:[8,17],dedic:24,incompat:21,well:[7,10,22,18],cellar:21,repeatedli:26,boost_network_default_tag:22,imagin:9,shared_futur:17,port_typ:23,techniqu:[6,16,11,7,4,5],lib:[20,21,15,22],callback:[24,10,22],service_unavail:10,self:7,offer:24,basic_request:[23,25],note:[13,14,15,8,24,9,18,10,17,3,21],also:[6,23,13,8,24,16,11,18,25,26,10,17,7,21,19],exampl:[6,13,14,15,8,24,9,22,18,25,20,2,11,7,3,21,4,10],read:[20,10,22,21],take:[6,14,8,24,18,25,10,7,3,22],which:[21,20,15,8,24,9,11,18,25,10,17,7,3,16,22],combin:[16,11],cmake_prefix_path:21,mit:13,singl:[8,15,24,10,22,25],asio:[24,26,10,22],begin:[24,25],sure:8,distribut:[26,10,21],plenti:26,though:[16,21,15],buffer:[22,10,11],conncetionptr:10,compress:15,deleg:25,discov:6,most:[24,20,14,10,18],plai:22,said:3,typenam:[18,11,23,17],pair:[23,17],boost_foreach:20,"class":[23,20,14,15,8,24,16,11,18,25,10,17,7,3,4,12],tradit:21,don:[15,24,19,11,25,21,22],filesystem:14,url:[14,15,9,1,20,3,21],clear:[24,18],later:10,cover:[22,18],uri:[6,23,13,14,15,24,16,25,1,22,3,21,4,12],doe:[23,8,24,18,10,17,3],part:[23,13,24,18,17,3,22],directive2:7,determin:[25,14,10,11],neg:13,readcallback:10,usual:[23,7,17],microsoft:21,fact:15,translat:11,cmakelist:21,connection_ptr:10,show:[24,9,2,20,3,10],text:13,inherit_linearli:11,sent:[24,10],substr:14,syntax:[13,15,1,3,4,12],concurr:10,radic:22,protocol:[6,23,13,14,15,8,24,9,18,20,26,2,17,7,3,12],trivial:[7,25],find:[6,21],foo_direct:18,cout:[13,14,15,24,9,20,3,25],redirect:24,current:[24,3,10],onli:[13,24,16,11,25,20,10,17,7,3,21,22,19],bind:10,locat:[24,21],librt:22,pointer:[24,10],explain:15,response_head:[10,25],activ:[24,25,19,26],written:[6,23,17],makefil:21,should:[8,24,16,18,10,11,21,25],prolong:7,configur:[6,21,8,22],experiment:22,templat:[23,24,16,11,18,25,26,1,10,17,7,21,4,12],hello_world:8,local:21,flexibl:[7,22,15,11],set_head:10,within:[10,0,21],contribut:[6,22],caus:[24,25,19,11],get:[6,13,14,15,8,24,9,11,25,17,20,21,4,26],familiar:[20,14],simplest:15,stop:[10,22],fluid:16,clang:[21,22],soon:[24,10],ssl:[0,24,16,10,21,4,22],is_base_of:11,cannot:[24,10],tcp_resolv:24,cache_resolv:24,progress:6,report:[6,10,4,21],metafunct:[18,11,4,5],requir:[23,24,16,18,10,17,26,3,21,22],embedd:[25,22],streaming_callback:24,receiv:[24,10],enabl:[24,21,26,10,11],emb:[24,10],command:[13,8,9,20,3,21],patch:21,rfc:[3,1,15,14,22],provid:[6,23,13,14,8,24,11,25,19,17,26,3,22],aris:24,contain:[13,8,11,18,2,17,7,10],status_typ:10,where:[23,24,16,18,25,26,10,11,7,9,22],async_serv:[10,22],certif:[24,22],learn:[6,4],set_opt:10,tree:15,truli:7,jamfil:22,startup:22,accord:[3,15,18],packet:18,compliant:14,increasingli:26,see:[8,24,19,11,25,10,22],cppnetlib_librari:21,result:[23,13,14,17,18,20,11,7,3],respons:[6,13,14,8,0,15,24,9,22,25,10,17,20,4,19],fail:22,close:[6,20,10,15,25],charact:24,best:[24,1,10],concern:22,awar:[6,26],statu:[25,22,10,8,17],wire:7,kei:[24,10,22],correctli:[23,17],pattern:[24,16,7,10,18],review:6,easi:[6,9,26],enumer:8,conveni:24,user_info:[14,3],state:[7,10],bridg:16,gaga:13,between:[3,21],"import":[10,22],awai:10,approach:[16,11],across:[24,8],signatur:[24,10],assumpt:25,handler_:6,syntact:[7,18],status_message_:17,numer:22,ask:[6,21],no_sslv2:10,were:10,typedef:[6,8,24,18,10,11,25],hello_world_serv:[9,8],extens:[25,7,11],job:21,print_bodi:24,preprocessor:[24,22],request_:[6,24],overhaul:22,dboost_root:21,come:[23,16,7,21,17],endl:[13,14,8,15,24,9,20,3,25],regular:10,addit:[16,7,3,21],both:[23,24,2,17,25,10,19],metaprogram:[1,21,4,11],exist:[20,21,26],subtitl:20,berri:26,cycl:24,response_:[6,24],howev:[25,21,11],context_bas:10,default_wstr:11,against:10,etc:26,handler_inst:10,context:[7,10,11],logic:[25,7,10,15,18],improv:22,whole:[11,22,17],load:24,among:11,simpli:[23,7,14,25],undefin:24,point:[18,11],instanti:10,schedul:10,logic_error:10,dispatch:[25,16,18,22,11],header:[6,23,13,14,15,8,24,16,11,18,25,20,10,17,7,21,22],rpc:9,dcmake_build_typ:21,suppli:[25,3,10,22],homebrew:21,comput:[10,21],pod:[23,18,4,17],throughout:22,assum:[23,15,24,9,18,10,17,21],summar:18,sever:[10,5],save:14,ultim:22,rudimentari:7,creat:[23,8,15,24,9,21,10,17,3,16],version_major:[24,23,19,25],headers_contain:[18,17],attitud:13,compos:12,empti:[14,18],accessor:[23,18,17],compon:[14,24,18,2,11,3],json:13,much:[16,21],treat:23,interest:21,modif:18,acceptor:10,"abstract":[16,15,8],strategi:[24,16],field:17,echo:25,boostcon:1,flight:13,resolut:22,convert:[23,18,3,17],depend:[23,24,18,10,17,25,21,22],argument:[13,14,8,15,24,18,25],assert:3,unzip:21,craft:9,understand:10,togeth:[21,26],demand:26,"catch":[13,14,8,24,9,20],last:24,rang:[24,10],synchronoushandl:10,resid:[15,25],present:15,"case":[23,8,16,17,18,10,11,25,21,22],inhibit:24,therefor:[24,25,26],look:[6,21,8,24,9,18,25,10,11,7,16,4,12],gnu:21,plain:16,servic:26,properti:[25,18,7,11],sourceforg:26,aim:5,defin:[8,24,16,18,25,10,11,7,3,21,22],"while":[16,18,26,7,21,25],make_shar:[24,10],boost_root:21,behavior:[24,16,25,11],error:[6,24,10,15,22],thrash:21,aid:2,invoc:[24,10],anchor:23,loop:10,"8bit":24,bin:3,layer:[6,16,7,26],tar:21,almost:10,alon:16,linger_timeout:10,site:21,destin:[23,18,17],itself:[7,11],motiv:[4,26],new_statu:10,boost_network_enable_http:[24,21,22],no_cont:10,sizetyp:13,mani:[24,26,21,22],conn:10,headers_container_typ:[23,17],oper:[6,23,13,8,24,18,25,10,17,7,22],develop:[6,13,14,15,8,2,21,4,26],ado:15,minim:22,perform:[23,24,9,18,10,26,22],suggest:23,make:[13,14,8,15,24,16,21,25,19,11,20,9,22],intermediari:18,same:[13,8,24,16,25,11,7,21,26],member:[8,0,24,16,10,4,25],fragment:[14,3],html:14,decod:22,http_keepalive_8bit_udp_resolv:[24,19,25],none:10,eventu:26,start:[6,24,10,11,21,4],higher:21,overal:11,http:[0,1,2,3,4,12,6,8,9,10,17,13,14,15,16,18,19,20,21,22,23,24,25,26],hostnam:10,ostringstream:9,nest:[23,17,18,10,11,7,25],chainabl:7,upon:10,effect:[24,23,17],action:10,user:[13,24,25,10,7,3,21,22,19],dh512:10,extern:[24,16,22],build:[13,14,8,15,9,25,26,20,21,4,22],studi:6,soap:26,recent:[24,13,21],memori:[24,26,10,21],http_default_8bit_udp_resolv:[24,23,25,19,17],lower:[26,22],xjf:21,kept:[10,26],equival:11,older:22,find_packag:21,macro:[24,21,22],builder:[22,13,3,4,12],string_typ:[6,23,24,17,10,11],facad:22,inherit:11,without:[7,15],person:21,client:[6,23,13,14,8,0,15,24,9,22,21,25,26,2,19,20,10,4,12],reflect:22,thi:[8,3,5,6,7,0,9,10,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26],destroi:24,error_cod:[24,10],everyth:3,left:[7,11],construct:[23,13,24,18,10,17,3],identifi:[3,18],entri:[20,26],just:[23,8,9,17,18,11,21,25],object:[23,8,15,24,16,22,18,25,26,10,17,7,4,19],boost_network_no_lib:[24,22],tcp:[24,16,19,25],openssl_verify_path:24,clear_resolved_cach:24,refactor:[6,22],meant:[23,18,11,10,17],derived1:16,derived0:16,rest:14,body_handl:24,yet:[10,11],languag:26,previous:8,web:[21,26],sslv23:10,struct:[6,8,24,16,18,10,11,7,25],expos:10,snmp:18,critial:22,percent:13,had:26,except:[13,14,8,24,9,19,20,16,25],littl:[16,11],target_link_librari:21,wall:22,add:[23,15,18,17,21,22],is_valid:3,http_default_8bit_tcp_resolv:[24,19,25],versa:18,overview:[3,4,12],extend:[7,26,11],adl:[18,11],subsequ:[24,16,23,17],source_:[23,17],smart:[24,10],headers_:[25,17],dsel:7,applic:[6,23,14,15,24,9,26,2,17,20,21,10],around:[24,10],format:[7,1,22],libc:22,fuss:6,ladi:13,regard:22,wstring:[23,11,17],distanc:24,test:[22,10,21],built:[15,24,16,2,21,22],asynchronoushandl:10,openssl_certificate_fil:24,burden:21,guid:[6,1,21],world:[6,8,9,10,4,2],bit:[23,17],foo:[16,18,11],report_abort:10,licens:13,linux:[21,4,22],if_:11,mikhailberi:21,like:[21,13,8,24,16,18,10,11,7,9,25],specif:[8,24,18,1,3,21,4,22],deprec:[24,22,18],docutil:12,signal:[24,15],echo_serv:25,manual:[0,4],unix:[3,21],integ:23,noth:16,collect:[6,26],"boolean":[24,10],necessari:8,either:[23,24,18,10,17,26],http_async_8bit_tcp_resolv:[24,19,25],http_version_minor:24,not_modifi:10,decis:16,concret:7,input_rang:10,fulfil:26,encount:[24,10],www:[14,25,3,15,24],right:[10,11],dean:26,famili:11,deal:[24,16,10,8],simplifi:7,sstream:9,status_:17,creation:7,some:[6,23,13,9,11,21,10,17,20,3,16,22,5],back:22,resolv:[24,19,25],certain:[25,18,7,10,11],intern:[23,24,10,11,22,25],unspecifi:[23,17],sampl:[10,21],send_buffer_s:10,mistak:24,home:[21,26],indirect:[16,7],server:[6,23,14,0,8,15,24,9,21,25,26,2,19,17,22,3,10,4,12],variou:24,titl:[20,19],librari:[6,23,13,24,16,11,18,20,26,2,17,7,21,4,22],hasparseerror:13,basic:[7,18],connectionptr:10,scale:10,lead:7,abort:10,broad:7,lvalu:[10,18],octet:24,achiev:5,when:[24,16,18,10,26,21,22],tracker:6,larg:[10,11],slash:3,sequenc:24,content:[6,24,18,10,4,22],localhost:9,mode:22,msvc:22,mailto:3,previou:[24,14,21],run:[6,13,14,15,8,9,10,20,21,4,22],power:[13,3,21],"enum":10,usag:[13,14,8,15,24,9,10,20,22],els:24,set_password_callback:10,http_statu:10,broken:3,step:21,use_tmp_dh_fil:10,although:[21,16,18,10,11],async:22,peer:[24,22],wget:[14,2,4],post:[24,9,25,15,22],appli:[7,18],impos:24,fulli:[24,14,26],session:24,src:21,dberri:21,actual:[10,22],greatli:16,utils_base64_test:22,receive_low_watermark:10,static_cast:14,slightli:11,page:[6,13,21],dopenssl_root_dir:21,distinct:10,delete_:24,messag:[6,23,15,24,22,18,26,17,7,4,12],constructor:[14,8,15,24,10,20,3,4,22],bz2:21,comp:3,disabl:10,block:[24,25,10,19],abus:7,underli:[25,18,7,11],thread_pool:10,own:[24,10,26],real:11,rapidjson:13,lifetim:24,default_str:11,client_opt:24,outliv:24,encod:[23,13,22,17],bound:10,two:[23,8,24,10,22,25],down:[16,7,3],creativ:16,been:[24,26,10,21],inadvert:22,wrap:[16,18,17],chang:[24,11,7,21,22,25],updat:22,destructor:[16,22],mere:18,manag:[24,10,22],websit:[6,14,21,15],git:21,string_tag:11,log:6,wai:[24,3,10,11],area:18,behaviour:13,transfer:[10,22],support:[6,23,13,15,8,0,24,16,11,18,25,26,10,17,7,3,21,4,22],hex:22,primari:[10,11],fast:6,happi:6,avail:[24,16,18,10,17,26,21,22],stuck:21,reli:[24,22],bad_request:10,includ:[6,23,13,14,15,8,24,9,20,10,17,7,3,22],lot:[16,21,22],ipv6:[1,22],forward:25,server_:[6,8],strictli:22,repetit:22,individu:21,fork:21,svn:21,head:[24,15,25],zip:21,gzip:21,form:[24,18,11,7,3,25],enough:[7,21],password_purpos:10,three:[24,18,10,12,21,25],bother:24,idea:[6,11],link:[24,10,21],detect:21,newer:10,atom:[20,2,4,22],line:[6,13,8,15,9,20,3,21,22],inlin:[11,23,7,17],"true":[24,10],bug:[21,22],reset:16,pull:21,"throw":[24,10,22],immedi:[7,10],utf:[23,17],input:[16,7],consist:[26,21,15,22],possibl:[6,16,20,15],whether:[23,24,16,18,10,3,22],explos:16,libcppnetlib:[21,22],tell:24,asynchron:[24,22,0,4,10],not_support:10,below:[6,13,24,10,17,3,21,25],those:[23,5,17],publicli:[23,10,17],boost_1_55_0:21,otherwis:[23,16,3,21],problem:16,http_version_major:24,even:[18,7,23,17],impl:[8,17],significantli:10,version_:17,featur:[6,13,0,24,11,21,4,26],artifact:21,io_servic:[24,10,22],"int":[6,13,14,15,8,24,9,10,17,20,3,16],request:[6,23,13,14,8,0,15,24,9,25,10,20,21,4,22],dure:24,parser:[14,20,3,21,22],moved_temporarili:10,deep:7,repres:10,"char":[6,13,14,15,8,24,9,10,20],bzip:21,bad_gatewai:10,clrf:22,file:[6,14,24,10,3,21],compulsori:21,face:[24,10],check:[6,21,15,22],fill:24,incorrect:22,denot:[10,11],readi:[24,22],cmake:[22,15,2,4,21],infosystem:3,nonetheless:18,uint16_t:17,todo:7,client_:[6,24],excel:26,detail:[23,8,15,24,18,19,17,25,10],virtual:16,event:10,status_t:10,"default":[15,24,16,18,25,19,11,22,21,10],finish:[24,10],declar:[24,23,25,17],bool:[24,10],futur:[6,24,18,10,17,25,19],normal:[24,23,4],trait:[11,17],basic_serv:25,you:[6,14,8,15,24,9,21,10,11,16,25],made:[24,9,10,8,22],runtim:16,tmp:24,target_typ:7,intend:[6,24,10,21],directive1:7,lend:7,subdivid:3,polymorph:[16,4,5],time:[24,7,10,22,21],source_typ:18,gcc:[21,22],googl:[6,21,22],definit:[23,18,10,11],"public":[10,0,25],intent:26,embed:[2,8,10],consid:24,not_found:10,destination_:[23,17],pool:[10,22],reduc:21,moved_perman:10,studio:21,longer:[24,22],vice:18,directori:[24,21,15],info:[6,3],suit:21,descript:[23,24,18,10,17,25,3,19],flag:22,rule:22,notion:[7,18],not_impl:10,some_str:24,basic_respons:[25,17],ignor:11,invok:[24,22,10,8,21],potenti:10,leak:22,cpp:[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20,21,22,23,24,25,26],invari:11,inc:22,hello:[6,8,9,10,4,2],legend:[23,18,3,10,17]},objtypes:{},titles:["Reference Manual","References","Examples","The URI class","Contents","Techniques","Getting cpp-netlib","Directives","“Hello world” HTTP server","“Hello world” HTTP client","HTTP Server API","Tag metafunctions","An in-depth look at the cpp-netlib","Twitter search","Simple wget","HTTP client","Static and dynamic polymorphism","HTTP Response","The message template","<no title>","Atom feed reader","Getting Started","What’s New","HTTP Request","HTTP Client API","HTTP implementation","Project history"],objnames:{},filenames:["reference","references","examples","in_depth/uri","contents","techniques","index","techniques/directives","examples/http/hello_world_server","examples/http/hello_world_client","reference/http_server","techniques/tag_metafunctions","in_depth","examples/http/twitter_search","examples/http/simple_wget","examples/http/http_client","techniques/polymorphism","reference/http_response","in_depth/message","in_depth/http_client_tags","examples/http/atom_reader","getting_started","whats_new","reference/http_request","reference/http_client","in_depth/http","history"]})cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/techniques.html000066400000000000000000000112241240331347200253600ustar00rootroot00000000000000 Techniques — cpp-netlib v0.11.1

Navigation

Techniques¶

The cpp-netlib uses several advanced techniques to achieve it’s aims. This chapter describes some of those techniques.

Previous topic

HTTP implementation

Next topic

Tag metafunctions

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/techniques/000077500000000000000000000000001240331347200244725ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/techniques/directives.html000066400000000000000000000236761240331347200275370ustar00rootroot00000000000000 Directives — cpp-netlib v0.11.1

Navigation

Directives¶

The 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 cpp-netlib the protocol implemented is similar to that of the standard iostream formatting system:

object << directive1(...)
       << directive2(...)
       ...
       << directiveN(...);

In 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:

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.

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.

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.

Previous topic

Tag metafunctions

Next topic

Static and dynamic polymorphism

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/techniques/polymorphism.html000066400000000000000000000304241240331347200301250ustar00rootroot00000000000000 Static and dynamic polymorphism — cpp-netlib v0.11.1

Navigation

Static and dynamic polymorphism¶

With a header only library, you can only do so much with static polymorphism alone. There are some situations where you have to handle dynamic polymorphism because of unavoidable runtime-based decision making. Although you can deal with the base types that remain static, behavior can vary greatly which derived type should be handling the situation based on runtime values.

This situation comes up in the cpp-netlib when we decide what kind of connection handler to use for a given HTTP URI – whether it’s plain HTTP or HTTPS. Although the HTTP semantics are the same for HTTP and HTTPS the implementation of the connection handler greatly varies on whether to use a plain TCP connection or an SSL-wrapped TCP connection.

The general pattern or technique is to combine tag-based dispatch with a strategy factory, all while not requiring any externally built libraries. Doing it in a header-only library requires a little creativity and additional layers of indirection that you otherwise will not need for a library with externally built static/dynamic libraries.

First we define the base type which we want to support dynamic behavior with. There’s nothing special with the base type, except that it supports the tag dispatch earlier defined and has a virtual destructor. In code it looks like this:

template <class Tag>
struct base {
    virtual void foo() = 0; // make this an abstract base
    virtual ~base() {
        // do the base destructor thing here.
    }
};

We then define a set of derived types that specialize the implementation of the foo member function. To facilitate the dispatch of the correct type based on an input, we create a strategy factory function:

template <class Tag>
unique_ptr<base<Tag> > strategy(int input, Tag) {
    unique_ptr<base<Tag> > ptr;
    switch(input) {
        case 0: ptr.reset(new derived0()); break;
        case 1: ptr.reset(new derived1()); break;
        // ...
        default: ptr.reset(0); break;
    }
    return ptr;
}

unique_ptr<base<default_> > ptr =
    strategy(input, default_()); // input is a runtime value

The strategy factory can be a standalone function, or a static member of a factory class that is specialized by tag dispatch. This can be done like the following:

template <class Tag>
struct strategy;

template <>
struct strategy<default_> {
    static unique_ptr<base<default_> > create(int input) {
        unique_ptr<base<default_> > ptr;
        switch(input) {
            case 0: ptr.reset(new derived0()); break;
            case 1: ptr.reset(new derived1()); break;
            //...
            default: ptr.reset(0); break;
        }
        return ptr;
    }
};

This approach allows the header-only libraries to define new dynamic types in subsequent versions of the library while keeping the static-dynamic bridge fluid. The only down-side to this is the possibility of derived type explosion in case there are a lot of different strategies or specializations available – this though is not unique to static-dynamic bridging, but is also a problem with pure object oriented programming with dynamic polymorphism.

Previous topic

Directives

Next topic

Project history

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/techniques/tag_metafunctions.html000066400000000000000000000445041240331347200311010ustar00rootroot00000000000000 Tag metafunctions — cpp-netlib v0.11.1

Navigation

Tag metafunctions¶

Sometimes you want to vary a function or a type’s behavior based on a static parameter. In the cpp-netlib there are a number of things you might want to change based on some such parameter – like what the underlying string type should be and how large a buffer should be, among other things. The primary way to define this in a header-only manner is to use tag-based metafunctions.

The skeleton of the approach is based on a similar technique for defining type traits. In the cpp-netlib however the type traits are defined on opaque tag types which serve to associate results to a family of metafunctions.

Template Specialization¶

To illustrate this point, let’s define a tag default_ which we use to denote the default implementation of a certain type foo. For instance we decide that the default string type we will use for default_ tagged foo specializations will be an std::string.

In the cpp-netlib this is done by defining a string metafunction type that is specialized on the tag default_ whose nested type result is the type std::string. In code this would translate to:

template <class Tag>
struct string {
    typedef void type;
};

struct default_;

template <>
struct string<default_> {
    typedef std::string type;
};

Template Metaprogramming¶

Starting with version 0.7, the tag dispatch mechanism changed slightly to use Boost.MPL. The idea is still the same, although we can get a little smarter than just using template specializations. Instead of just defining an opaque type default_, we use the Boost.MPL equivalent of a vector to define which root types of properties this default_ tag supports. The idea is to make the opaque type default_ inherit property tags which the library supports internally as definite extension points.

Our definition of the default_ tag will then look something like the following:

typedef mpl::vector<default_string> default_tags;

template <class Tag>
struct components;

typedef mpl::inherit_linearly<
    default_tags,
    mpl::inherit<mpl::placeholders::_1, mpl::placeholders::_2>
    >::type default_;

template <class Tag>
struct components<default_> {
    typedef default_tags type;
};

In the above listing, default_string is what we call a “root” tag which is meant to be combined with other “root” tags to form composite tags. In this case our composite tag is the tag default_. There are a number of these “root” tags that cpp-netlib provides. These are in the namespace boost::network::tags and are defined in boost/network/tags.hpp.

Using this technique we change slightly our definition of the string metafunction class into this:

template <class Tag>
struct unsupported_tag;

template <class Tag>
struct string :
    mpl::if_<
        is_base_of<
            tags::default_string,
            Tag
        >,
        std::string,
        unsupported_tag<Tag>
    >
{};

Notice that we don’t have the typedef for type in the body of string anymore, but we do inherit from mpl::if_. Since mpl::if_ is a template metafunction itself, it contains a definition of the resulting type which string inherits.

You can see the real definition of the string metafunction in boost/network/traits/string.hpp.

Using Tags¶

Once we have the defined tag, we can then use this in the definition of our types. In the definition of the type foo we use this type function string and pass the tag type parameter to determine what to use as the string type in the context of the type foo. In code this would translate into:

template <class Tag>
struct foo {
    typedef typename string<Tag>::type string_type;

    // .. use string_type where you need a string.
};

Using this approach we can support different types of strings for different tags on the type foo. In case we want to use a different type of string for the tag default_ we only change the composition of the string_tags MPL vector. For example, in cpp-netlib there is a root tag default_wstring which causes the string metafunction to define std::wstring as the resulting type.

The approach also allows for the control of the structure and features of types like foo based on the specialization of the tag. Whole type function families can be defined on tags where they are supported and ignored in cases where they are not.

To illustrate let’s define a new tag swappable. Given the above definition of foo, we want to make the swappable-tagged foo define a swap function that extends the original default_-tagged foo. In code this would look like:

struct swappable;

template <>
struct foo<swappable> : foo<default_> {
    void swap(foo<swappable> & other) {
        // ...
    }
};

We also for example want to enable an ADL-reachable swap function:

struct swappable;

inline
void swap(foo<swappable> & left, foo<swappable> & right) {
    left.swap(right);
}

Overall what the tag-based definition approach allows is for static definition of extension points that ensures type-safety and invariants. This keeps the whole extension mechanism static and yet flexible.

Table Of Contents

Previous topic

Techniques

Next topic

Directives

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/html/whats_new.html000066400000000000000000000472301240331347200252150ustar00rootroot00000000000000 What’s New — cpp-netlib v0.11.1

Navigation

What’s New¶

cpp-netlib 0.11¶

v0.11.1¶

  • Add support for request timeouts.
  • Build configuration fixes.
  • Support for Travis CI in-project config.
  • Make the response parser more flexible to support older/ad-hoc servers that don’t have standard format responses.
  • Fix some instability in the client destructor.
  • MSVC 2010 specific fixes.

v0.11.0¶

  • Fix thread leak in DNS resolution failure (#245)
  • Remove unsupported client_fwd.hpp header (#277)
  • Remove support for header-only usage (#129) – this means that the BOOST_NETWORK_NO_LIB option is no longer actually supported.
  • Deprecate Synchronous Client implementations (#279)
  • Support streaming body chunks for PUT/POST client requests (#27)
  • Fix non-case-sensitive header parsing for some client tags (#313)
  • Remove unsupported Jamfiles from the whole project (#316)
  • Add make install for Linux and OS X (#285)
  • Fix incorrect Body processing (#69)
  • Support chunked transfer encoding from HTTP responses (#86)
  • Make OS X Clang builds use C++11 and libc++.
  • Update Boost requirement to 1.54.0.
  • Experimental Base64 encoding/decoding library (#287)
  • Known test failure: OS X Xcode Clang 5.0 + Boost 1.54.0 + libc++ don’t play well with Boost.Serialization issues, mitigate test breakage but cpp-netlib-utils_base64_test still fails in this platform. (#287)
  • Provide a client option to always validate peers for HTTPS requests made by the client. (#349)
  • Back-port fix for #163 for improved URI parsing.
  • Added support for client-side certificates and private keys (#361).

cpp-netlib 0.10¶

v0.10.1¶

  • Documentation updates (#182, #265, #194, #233, #255)
  • Fix issue with async server inadvertently stopping from listening when accepting a connection fails. (#172)
  • Allow overriding and ultimately removing defaulted headers from HTTP requests. (#263)
  • Add -Wall to the base rule for GCC builds. (#264)
  • Make the server implementation throw on startup errors. (#166)

v0.10.0¶

  • Added support for more HTTP status codes (206, 408, 412, 416, 507).
  • Refactored the parser for chunked encoding.
  • Fixed parsing chunked encoding if the response body has <chunk>CLRF<hex>CLRF<data>.
  • Added librt dependency on Linux.
  • Check the callback in the asynchronous client before calling it.
  • Fixed issues #110, #168, #213.

cpp-netlib 0.9¶

v0.9.5¶

  • Removed dependency on Boost.Parameter from HTTP client and server.
  • Fixed for Clang error on Twitter example.
  • Added source port to the request (HTTP server).
  • Updated CMake config for MSVC 2010/2012.
  • Now support chunked content encoding in client response parsing.
  • Fixed bug with client not invoking callback when a request fails.

v0.9.4¶

  • Lots of URI fixes.
  • Fixed async_server’s request handler so it doesn’t make copies of the supplied handler.
  • Fix for issue #73 regarding SSL connections ending in short read errors.
  • Final C++03-only release.

v0.9.3¶

  • URI, HTTP client and HTTP server are now built as static libraries (libcppnetlib-uri.a, libcppnetlib-client-connections.a and libcppnetlib-server-parsers.a on Linux and cppnetlib-uri.lib, cppnetlib-client-connections.lib and cppnetlib-server-parsers.lib on Windows).
  • Updated URI parser.
  • A new URI builder.
  • URI support for IPv6 RFC 2732.
  • Fixed issues #67, #72, #78, #79, #80, #81, #82, #83.
  • New examples for the HTTP client, including an Atom feed, an RSS feed and a very simple client that uses the Twitter Search API.

v0.9.2¶

  • Critial bug fixes to v0.9.1.

v0.9.1¶

  • Introduced macro BOOST_NETWORK_DEFAULT_TAG to allow for programmatically defining the default flag to use throughout the compilation unit.
  • Support for streaming body handlers when performing HTTP client operations. See documentation for HTTP client interface for more information.
  • Numerous bug fixes from v0.9.0.
  • Google, Inc. contributions.

v0.9.0¶

  • IMPORTANT BREAKING CHANGE: By default all compile-time heavy parser implementations are now compiled to external static libraries. In order to use cpp-netlib in header-only mode, users must define the preprocessor macro BOOST_NETWORK_NO_LIB before including any cpp-netlib header. This breaks code that relied on the version 0.8.x line where the library is strictly header-only.
  • Fix issue #41: Introduce a macro BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG which makes the default HTTP client use tags::http_async_8bit_udp_resolve as the tag.
  • Fix issue #40: Write the status line and headers in a single buffer write instead of two writes.
  • More consistent message API for client and server messages (request and response objects).
  • Refactoring of internal implementations to allow better separation of concerns and more manageable coding/documentation.
  • Client and server constructors that support Boost.Parameter named parameters.
  • Client and server constructors now take in an optional reference to a Boost.Asio io_service to use internally.
  • Documentation updates to reflect new APIs.

cpp-netlib 0.8¶

  • Updates to URI unit tests and documentation.
  • More documentation, covering the HTTP Client and HTTP Server APIs
  • Asynchronous HTTP Server that now supports running request handlers on a different thread pool.
  • An initial thread pool implementation, using Boost.Asio underneath.
  • Adding a ready(...) wrapper to check whether a response object returned by the asynchronous client in 0.7 already has all the parts available.
  • Some attempts at lowering compile time costs.

cpp-netlib 0.7¶

  • Radical documentation overhaul
  • Asynchronous HTTP client
  • Tag dispatch overhaul, using Boost.MPL
  • HTTP Client Facade refactoring
  • Bug fixes for HTTP 1.1 response parsing
  • Minimized code repetition with some header macro’s
  • Configurable HTTPS support in the library with BOOST_NETWORK_ENABLE_HTTPS

cpp-netlib 0.6¶

  • Many fixes for MSVC compiler

cpp-netlib 0.5¶

  • An embeddable HTTP 1.1 server
  • An HTTP 1.1 client upgraded to support HTTPS
  • An updated URI parser implementation
  • An asynchronous HTTP 1.1 client
  • An HTTP 1.1 client that supports streaming function handlers

Table Of Contents

Previous topic

Getting cpp-netlib

Next topic

Getting Started

Navigation

© Copyright 2008-2014, Glyn Matthews, Dean Michael Berris; 2013 Google, Inc.. Last updated on Sep 08, 2014. Created using Sphinx 1.1.3.
cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/in_depth.rst000066400000000000000000000005331240331347200237030ustar00rootroot00000000000000.. _in_depth: An in-depth look at the :mod:`cpp-netlib` ========================================= The :mod:`cpp-netlib` is composed of three different sets of functionality: a **message** template, a **URI** template and different **protocol** implementations. .. toctree:: :maxdepth: 2 in_depth/message in_depth/uri in_depth/http cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/in_depth/000077500000000000000000000000001240331347200231505ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/in_depth/http.rst000066400000000000000000000127351240331347200246710ustar00rootroot00000000000000HTTP implementation =================== HTTP client ``````````` At the heart of the HTTP client implementation is a single class aptly named ``basic_client``, which is also a template. The template ``basic_client`` takes three template parameters: .. code-block:: c++ namespace boost { namespace http { template struct basic_client; } // namespace http } // namespace boost The ``Tag`` template parameter follows the same tag-dispatch mechanism to determine the behavior of the ``basic_client``. The interface of ``basic_client`` may change depending on certain properties defined for the tag you provide. Below is a table of predefined supported tags you can use in your overload of the ``basic_client``: ------------ .. include:: http_client_tags.rst .. _Boost.Thread: http://www.boost.org/libs/thread The default typedef for the HTTP client that is provided uses the ``http_async_8bit_udp_resolve`` tag, and implements HTTP 1.1. The exact typedef is in the ``boost::network::http`` namespace as the following: .. code-block:: c++ namespace boost { namespace network { namespace http { typedef basic_client client; }}} This type has nested typedefs for the correct types for the ``basic_request`` and ``basic_response`` templates. To use the correct types for ``basic_request`` or ``basic_response`` you can use these nested typedefs like so: .. code-block:: c++ boost::network::http::client::request request; boost::network::http::client::response response; // or... using namespace boost::network; http::client::request request; http::client::response response; Typical use cases for the HTTP client would look something like the following: .. code-block:: c++ using namespace boost::network; http::request request("http://www.boost.org/"); request << header("Connection", "close"); The ``basic_client`` implements all HTTP methods as member functions (HEAD, GET, POST, PUT, DELETE). Therefore, the code to make an HTTP request looks trivially simple: .. code-block:: c++ using namespace boost::network; http::client client; http::client::request request("http://www.boost.org/"); http::client::response response = client.get(request); Accessing data from ``http::response`` is done using wrappers. To get the response headers, we use the ``headers`` wrapper which returns, in the default case, a multimap of strings to strings: .. code-block:: c++ using namespace boost::network; typedef headers_range::type response_headers; boost::range_iterator::type iterator; response_headers headers_ = headers(response); for (iterator it = headers_.begin(); it != headers_.end(); ++it) { std::cout << it->first << ": " << it->second << std::endl; } std::cout << std::endl; HTTP server ``````````` As with the HTTP client, the HTTP server that is provided with cpp-netlib is extensible through the tag mechanism and is embeddable. The template class declaration of ``basic_server`` is given below: .. code-block:: c++ namespace boost { namespace network { namespace http { template basic_server; }}} The second template argument is used to specify the request handler type. The request handler type is a functor type which should overload the function call operator (``RequestHandler::operator()`` should be overloaded) that takes two parameters: the first one being a reference to a ``const basic_request`` and the second being a reference to a ``basic_response`` instance. All the logic for parsing the HTTP request and building the ``const basic_request`` object resides internally in the ``basic_server`` template. Processing the request is delegated to the ``RequestHandler`` type, and the assumption of which would be that the response is formed inside the ``RequestHandler`` function call operator overload. The ``basic_server`` template however is only an underlying implementation while the user-visible implementation is the ``http::server`` template. This simply specializes the ``basic_server`` template to use the ``default_`` tag and forwards the ``RequestHandler`` parameter: .. code-block:: c++ namespace boost { namespace network { namespace http { template class server : public basic_server {}; }}} To use the forwarding server type you just supply the request handler implementation as the parameter. For example, an "echo" server example might look something like this: .. code-block:: c++ using namespace boost::network; struct echo; typedef http::server echo_server; struct echo { void operator () (const echo_server::request &request, echo_server::response &response) const { std::string ip = source(request); response = echo_server::response::stock_reply( echo_server::response::ok, body(request)); std::cerr << "[" << ip << "]: " << request.uri << " status = " << echo_server::response::ok << '\n'; } }; Here, all we're doing is returning the original request body with an HTTP OK response (200). We are also printing the IP address from where the request came from. Notice that we are using a wrapper to access the source of the request. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/in_depth/http_client_tags.rst000066400000000000000000000062631240331347200272440ustar00rootroot00000000000000+---------------------------------+---------------------------------------------+ | Tag | Description | +=================================+=============================================+ | http_default_8bit_tcp_resolve | This is the default HTTP implementation tag | | | that resolves addresses with a TCP resolver | | | and provides a synchronous/blocking HTTP | | | client interface. | +---------------------------------+---------------------------------------------+ | http_default_8bit_udp_resolve | This is similar to the above tag except that| | | it specifies the HTTP client to use a UDP | | | resolver. It also provides a synchronous/ | | | blocking HTTP client interface. | +---------------------------------+---------------------------------------------+ | http_keepalive_8bit_tcp_resolve | This tag specifies that the HTTP client by | | | default will keep connections to the server | | | alive. It only makes sense if the | | | ``version_major`` and ``version_minor`` are | | | both ``1``, to indicate HTTP 1.1. This tag | | | causes the HTTP client to resolve using a | | | TCP resolver and provides a synchronous/ | | | blocking HTTP client interface. | +---------------------------------+---------------------------------------------+ | http_keepalive_8bit_udp_resolve | This is similar to the above tag except that| | | it specifies the HTTP client to use a UDP | | | resolver. It also provides a synchronous/ | | | blocking HTTP client interface. | +---------------------------------+---------------------------------------------+ | http_async_8bit_tcp_resolve | This tag provides an active HTTP client | | | object implementation that uses a TCP | | | resolver. Response objects returned will | | | encapsulate a number of Boost.Thread_ | | | shared futures to hold values. Users don't | | | have to see this as they are implementation | | | details. | +---------------------------------+---------------------------------------------+ | http_async_8bit_udp_resolve | This is similar to the above tag except that| | | specifies the HTTP client to use a UDP | | | resolver. | +---------------------------------+---------------------------------------------+ .. _Boost.Thread: http://www.boost.org/libs/thread cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/in_depth/message.rst000066400000000000000000000247231240331347200253360ustar00rootroot00000000000000The message template ==================== One of the core components in the library is the concept and the implementation of a common message type. In most (not all) network protocols, the concept of a message is central to the definition of the protocol. In HTTP, SMTP, XMPP, and even other protocols like SNMP and ICMP, there is a common notion of a "packet" or a message. In cpp-netlib we chose to implement the concept of a message that has the following common parts: * **Source** - every message has a source identifier which varies from protocol to protocol. * **Destination** - every message has a destination identifier which varies from protocol to protocol. * **Headers** - each message is assumed to contain headers, which may be empty in cases where the protocol does not support it, but is nonetheless supported by cpp-netlib messages. * **Body** - the content area of a message which varies from protocol to protocol (also sometimes referred to as payload). This division is purely logical -- in the underlying implementation, the message type can choose to have different means of storing the data, depending on the type used to tag the message. This section covers the `Message Concept`_ as well as the `basic_message`_ implementation. Message Concept ``````````````` .. warning:: The Message framework is deprecated in the 0.11 release, and will be removed in future versions of the library. The Message Concept specifies what the valid operations on a message are as well as what messages look like semantically. The following table summarize the operations and syntactic as well as semantic properties of messages. **Legend** :M: The message type. :H: A headers container type. :m,n: An instance of **M**. :S: A string type. :s,k,v: An instance of **S**. :O: The source type. :D: The destination type. :B: The body type. :T: The Tag type. +----------------------------+----------------------+-----------------------------------------+ | Construct | Result | Description | +============================+======================+=========================================+ | ``typename M::tag`` | T | The nested tag type. | +----------------------------+----------------------+-----------------------------------------+ | ``M()`` | Instance of M | Default constructible. | +----------------------------+----------------------+-----------------------------------------+ | ``M(m)`` | Instance of M | Copy constructible. | +----------------------------+----------------------+-----------------------------------------+ | ``m = n;`` | Reference to m | Assignable. | +----------------------------+----------------------+-----------------------------------------+ | ``swap(m, n);`` | ``void`` | Swappable. | +----------------------------+----------------------+-----------------------------------------+ | ``source(m);`` | Convertible to O | Retrieve the source of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``destination(m);`` | Convertible to D | Retrieve the destination of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``headers(m);`` | Convertible to H | Retrieve the headers of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``body(m);`` | Convertible to B | Retrieve the body of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << source(s);`` | ``M &`` | Set the source of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << destination(s);`` | ``M &`` | Set the destination of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << header(k, v);`` | ``M &`` | Add a header to ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << remove_header(k);`` | ``M &`` | Remove a header from ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``m << body(s);`` | ``M &`` | Set the body of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``source(m,s);`` | ``void`` | Set the source of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``destination(m,s);`` | ``void`` | Set the destination of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``add_header(m, k, v);`` | ``void`` | Add a header to ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``remove_header(m, k);`` | ``void`` | Remove a header from ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``clear_headers(m);`` | ``void`` | Clear the headers of ``m``. | +----------------------------+----------------------+-----------------------------------------+ | ``body(m,s);`` | ``M &`` | Set the body of ``m``. | +----------------------------+----------------------+-----------------------------------------+ Types that model the Message Concept are meant to encapsulate data that has a source, a destination, one or more named headers, and a body/payload. Because the accessors and the directives are not required to be part of the message type that models the Message Concept, a message can be implemented as a POD type and have all manipulations performed in the directive implementations, as well as value transformations done in the accessors. Directives, Modifiers, and Wrappers ``````````````````````````````````` In the Message Concept definition there are three basic constructs that follow a certain pattern. These patterns are Directives_, Modifiers_, and Wrappers_. Directives ~~~~~~~~~~ A directive is a function object that is applied to a Message. Directives encapsulate a set of operations that apply to messages. The general requirement for a Directive is that it should apply these operations on a message. A directive may dispatch on the type of the message passed to it at the point of the function call. Typically, directives are generated using a factory function that returns the correct directive type. For a given directive ``foo_directive`` a generator function called ``foo`` is typically implemented: .. code-block:: c++ struct foo_directive { template Message & operator()(Message & m) const { // do something to m return m; } }; foo_directive const foo() { return foo_directive(); } // to apply a directive, we use the << operator message m; m << foo(); Modifiers ~~~~~~~~~ A modifier is generally defined as a free function that takes a reference to a non-const lvalue message as the first parameter, and any number of parameters. In the concept definition of the Message Concept, a modifier follows the form: .. code-block:: c++ modifier(message, ...) Modifiers are meant to imply modifications on a message, which also allows for easier dispatch based on Argument Dependent Lookup (ADL_) on the type of the message. Note that Directives_ can be implemented in terms of Modifiers and vice versa, although that is not required nor specified. .. _ADL: http://en.wikipedia.org/wiki/Argument-dependent_name_lookup Wrappers ~~~~~~~~ A Wrapper is basically an implementation detail that ensures that a given message, when wrapped, can be converted to the associated part of the message. A wrapper has a type that encapsulates the conversion logic from a message to a given type. An example of a Wrapper would be ``source_wrapper`` which would be returned by a call to the wrapper generator function ``source``. An example implementation of the ``source_wrapper`` would look like: .. code-block:: c++ template class Message> struct source_wrapper { Message const & m; explicit source_wrapper(Message const & m) : m(m) {} typedef typename source::type source_type; operator source_type const & () { return m.source; } operator source_type const () { return m.source; } operator source_type () { return m.source; } }; template class Message> source_wrapper const source(Message const & message) { return source_wrapper(message); } This pattern is similar to an adapter, but the specific notion of wrapping a data type (in this case, an object of a type that models the Message Concept) using an intermediary wrapper is what is pertained to by the Wrapper pattern. In this case, the Wrapper is ``source_wrapper`` while ``source`` is merely a wrapper generator function. ``basic_message`` ````````````````` The default implementation of a simple type that models the Message Concept is available in cpp-netlib. This default implementation is named ``basic_message`` which supports a ``Tag`` template parameter. The definition of ``basic_message`` looks like this: .. code-block:: c++ template class basic_message; The ``basic_message`` template requires that the following tag-dispatched metafunctions are defined for the type ``Tag``: .. code-block:: c++ template struct string; template struct headers_container; All the operations defined by the message concept are implemented by this basic message type. Other message implementations can either use this common message type or specialize it according to whether they want to use different containers or whether it's going to be just a POD type. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/in_depth/uri.rst000066400000000000000000000134011240331347200245000ustar00rootroot00000000000000The URI class ============= In addition to protocol implementations, the :mod:`cpp-netlib` provides a powerful URI class. The class implements a parser based on `RFC 3986`_ and `RFC 2732`_. Generic URI syntax overview ``````````````````````````` A generic URI will take the form:: [scheme:]scheme-specific-part[#fragment] A URI is known as `absolute` if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, ``uri`` supports only absolute URIs. URIs can be further classified according to whether they're hierarchical or opaque (non-hierarchical). Some examples of non-hierarchical URIs include:: mailto:john.doe@example.com news:comp.infosystems.www.servers.unix tel:+1-816-555-1212 The data following the first ``":"`` is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the ``":"`` to be a part of the path: .. image:: ../_static/mailto_uri.png A hierarchical URI is identified by a double slash (``"//"``) after the scheme and a scheme-specific component, which `RFC 3986`_ defines to be:: [scheme:][//authority][path][?query][#fragment] The authority component can be further broken down to:: [user_info@]host[:port] Examples of hierarchical URIs include:: http://www.boost.org/ file:///bin/bash The following example, describing a complex URI using FTP, shows how a URI is broken down by the parser: .. image:: ../_static/ftp_uri.png Note that the ``authority`` is further subdivided into different elements. Another example, using HTTP is given below: .. image:: ../_static/http_uri.png The difference here between the path in a hierarchical URI and that in the example above for the non-hierarchical URI. The ``uri`` class ````````````````` As of version 0.9.3, ``uri`` supplies a URI parser and builder. To use the parser, it's as simple as supplying a string to the constructor: .. code-block:: c++ using namespace boost::network; uri::uri instance("http://cpp-netlib.github.com/"); assert(instance.is_valid()); std::cout << "scheme: " << instance.scheme() << std::endl << "host: " << instance.host() << std::endl; The command-line output of this program will be:: scheme: http host: cpp-netlib.github.com The ``uri`` builder ``````````````````` ``uri`` support a stream style syntax to create a URI from it's elements. For example the program: .. code-block:: c++ #include #include #include using namespace boost::network; int main() { uri::uri url; url << uri::scheme("http") << uri::host("www.github.com") << uri::path("/cpp-netlib"); std::cout << url << std::endl; return 0; } will output:: http://www.github.com/cpp-netlib ``URI Concept`` ``````````````` **Legend** :U: The URI type. :u,u_: An instance of **M**. :S: A string type. :s,v: An instance of **S**. :T: The Tag type. +----------------------------+----------------------+-----------------------------------------+ | Construct | Result | Description | +============================+======================+=========================================+ | ``U(u)`` | Instance of U | Copy constructible. | +----------------------------+----------------------+-----------------------------------------+ | ``U(s)`` | Instance of U | Constructible from string. | +----------------------------+----------------------+-----------------------------------------+ | ``u = u_;`` | Reference to u | Assignable. | +----------------------------+----------------------+-----------------------------------------+ | ``u = s;`` | Reference to u | Assignable from string. | +----------------------------+----------------------+-----------------------------------------+ | ``swap(u, u_);`` | ``void`` | Swappable. | +----------------------------+----------------------+-----------------------------------------+ | ``scheme(u);`` | Convertible to S | Retrieve the URI scheme of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``user_info(u);`` | Convertible to S | Retrieve the user info of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``host(u);`` | Convertible to S | Retrieve the host of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``port(u);`` | Convertible to H | Retrieve the port of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``path(u);`` | Convertible to S | Retrieve the path of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``query(u);`` | Convertible to S | Retrieve the query string of ``u``. | +----------------------------+----------------------+-----------------------------------------+ | ``fragment(u);`` | Convertible to S | Retrieve the fragment of ``u``. | +----------------------------+----------------------+-----------------------------------------+ .. _`RFC 3986`: http://tools.ietf.org/html/rfc3986 .. _`RFC 2368`: http://tools.ietf.org/html/rfc2368 .. _`RFC 3513`: http://tools.ietf.org/html/rfc3513 .. _`RFC 2732`: http://tools.ietf.org/html/rfc2732 cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/index.rst000066400000000000000000000074371240331347200232320ustar00rootroot00000000000000.. _index: .. rubric:: Straightforward network programming in modern C++ .. :Authors: Glyn Matthews .. Dean Michael Berris .. :Date: 2014-10-01 .. :Version: 0.11.0 .. :Description: Complete user documentation, with examples, for the :mod:`cpp-netlib`. .. :Copyright: Copyright Glyn Matthews, Dean Michael Berris 2008-2013. .. Copyrigh 2013 Google, Inc. .. Distributed under the Boost Software License, Version .. 1.0. (See accompanying file LICENSE_1_0.txt or copy at .. http://www.boost.org/LICENSE_1_0.txt) Getting cpp-netlib ================== You can find out more about the :mod:`cpp-netlib` project at http://cpp-netlib.org/. **Download** You can get the latest official version of the library from the official project website at: http://cpp-netlib.org/ This version of :mod:`cpp-netlib` is tagged as cpp-netlib-0.11.0 in the GitHub_ repository. You can find more information about the progress of the development by checking our GitHub_ project page at: http://github.com/cpp-netlib/cpp-netlib **Support** You can ask questions, join the discussion, and report issues to the developers mailing list by joining via: https://groups.google.com/group/cpp-netlib You can also file issues on the Github_ issue tracker at: http://github.com/cpp-netlib/cpp-netlib/issues We are a growing community and we are happy to accept new contributions and ideas. C++ Network Library =================== :mod:`cpp-netlib` is a library collection that provides application layer protocol support using modern C++ techniques. It is light-weight, fast, portable and is intended to be as easy to configure as possible. Hello, world! ============= The :mod:`cpp-netlib` allows developers to write fast, portable network applications with the minimum of fuss. An HTTP server-client example can be written in tens of lines of code. The client is as simple as this: .. code-block:: cpp using namespace boost::network; using namespace boost::network::http; client::request request_("http://127.0.0.1:8000/"); request_ << header("Connection", "close"); client client_; client::response response_ = client_.get(request_); std::string body_ = body(response_); And the corresponding server code is listed below: .. code-block:: cpp namespace http = boost::network::http; struct handler; typedef http::server http_server; struct handler { void operator() (http_server::request const &request, http_server::response &response) { response = http_server::response::stock_reply( http_server::response::ok, "Hello, world!"); } void log(http_server::string_type const &info) { std::cerr << "ERROR: " << info << '\n'; } }; int main(int arg, char * argv[]) { handler handler_; http_server::options options(handler_); http_server server_( options.address("0.0.0.0") .port("8000")); server_.run(); } Want to learn more? =================== * :ref:`Take a look at the getting started guide ` * :ref:`Learn from some simple examples ` * :ref:`Find out what's new ` * :ref:`Study the library in more depth ` * :ref:`Discover more through the full reference ` * :ref:`Full table of contents ` .. warning:: Be aware that not all features are stable. The generic message design is under review and the URI and HTTP client implementation will continue to undergo refactoring. Future versions will include support for other network protocols. .. _Boost: http://www.boost.org/ .. _GitHub: http://github.com/ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/make.bat000066400000000000000000000060071240331347200227660ustar00rootroot00000000000000@ECHO OFF REM Command file for Sphinx documentation set SPHINXBUILD=sphinx-build set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. changes to make an overview over all changed/added/deprecated items echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\cpp-netlib.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\cpp-netlib.ghc goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) :end cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/reference.rst000066400000000000000000000005311240331347200240450ustar00rootroot00000000000000.. _reference: Reference Manual ================ This reference manual refers to the API documentation of the public interfaces to the different client and/or server implementations within :mod:`cpp-netlib`. .. toctree:: :maxdepth: 2 reference/http_client reference/http_request reference/http_response reference/http_server cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/reference/000077500000000000000000000000001240331347200233145ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/reference/http_client.rst000066400000000000000000000555361240331347200264010ustar00rootroot00000000000000 HTTP Client API =============== General ------- :mod:`cpp-netlib` includes and implements a number of HTTP clients that you can use and embed in your own applications. All of the HTTP client implementations: * **Cannot be copied.** This means you may have to store instances of the clients in dynamic memory if you intend to use them as function parameters or pass them around in smart pointers or by reference. * **Assume that requests made are independent of each other.** There currently is no cookie or session management system built-in to cpp-netlib's HTTP client implementations. The HTTP clients all share the same API, but the internals are documented in terms of what is different and what to expect with the different implementations. As of 0.9.1 the default implementation for the :mod:`cpp-netlib` HTTP client is asynchronous. As of 0.11 the `Synchronous Clients`_ are now *DEPRECATED* and will be removed in subsequent releases. Features -------- The HTTP client implementation supports requesting secure HTTP (HTTPS) content only in the following situations: * **Client libraries are built with ``BOOST_NETWORK_ENABLE_HTTPS``.** This tells the implementation to use HTTPS-specific code to handle HTTPS-based content when making connections associated with HTTPS URI's. This requires a dependency on OpenSSL_. * **The ``BOOST_NETWORK_ENABLE_HTTPS`` macro is set when compiling user code.** It is best to define this either at compile-time of all code using the library, or before including any of the client headers. To use the client implementations that support HTTPS URIs, you may explicitly do the following: .. code-block:: c++ #define BOOST_NETWORK_ENABLE_HTTPS #include This forces HTTPS support to be enabled and forces a dependency on OpenSSL_. This dependency is imposed by `Boost.Asio`_ .. _OpenSSL: http://www.openssl.org/ .. _`Boost.Asio`: http://www.boost.org/libs/asio Implementations --------------- There is a single user-facing template class named ``basic_client`` which takes three template parameters: * **Tag** - which static tag you choose that defines the behavior of the client. * **http_version_major** - an unsigned int that defines the HTTP major version number, this directly affects the HTTP messages sent by the client. * **http_version_minor** - an unsigned int that defines the HTTP minor version number. There are two major different class of implementations of the ``basic_client`` template that depend on which tag you choose: `Synchronous Clients`_ and `Asynchronous Clients`_. These two different classes are described in their own sections following this one. What follows is a table of all tags supported by the HTTP client implementation provided by :mod:`cpp-netlib`. --------------- .. include:: ../in_depth/http_client_tags.rst In the above table the tags follow a pattern for describing the behavior introduced by the tags. This pattern is shown below: ___ For example, the tag ``http_default_8bit_tcp_resolve`` indicates the protocol ``http``, a modifier ``default``, a character width of ``8bit``, and a resolve strategy of ``tcp_resolve``. Synchronous Clients ~~~~~~~~~~~~~~~~~~~ Of the client tags shown in the table, the following makes the ``basic_client`` behave as a fully synchronous client. * **http_default_8bit_tcp_resolve** * **http_default_8bit_udp_resolve** * **http_keepalive_8bit_tcp_resolve** * **http_keepalive_8bit_udp_resolve** The synchronous client implements all the operations of the client underneath the interface all block to wait for I/O to finish. All the member methods are synchronous and will block until the response object is ready or throws if errors are encountered in the performance of the HTTP requests. .. warning:: The synchronous clients are **NOT** thread safe. You will need to do external synchronization to use synchronous client implementations. .. note:: As of version 0.11, all the synchronous client implementations are deprecated. They will be removed in the next version of the library. Asynchronous Clients ~~~~~~~~~~~~~~~~~~~~ The following tags specify the ``basic_client`` to behave in an asynchronous manner: * **http_async_8bit_tcp_resolve** * **http_async_8bit_udp_resolve** An asynchronous client implementation means that``basic_client<...>`` is an `Active Object`_. This means that the client has and manages its own lifetime thread, and returns values that are asynchronously filled in. The response object encapsulates Boost.Thread_ futures which get filled in once the values are available. .. _Boost.Thread: http://www.boost.org/libs/thread .. _`Active Object`: http://en.wikipedia.org/wiki/Active_object The asynchronous clients implement all operations asynchronously which are hidden from the user. The interface is still synchronous but the fetching of data happens on a different thread. .. note:: The asynchronous clients are thread safe, and can be shared across many threads. Each request starts a sequence of asynchronous operations dedicated to that request. The client does not re-cycle connections and uses a one-request-one-connection model. When an asynchronous client object is destroyed, it waits for all pending asynchronous operations to finish. Errors encountered during operations on retrieving data from the response objects cause exceptions to be thrown -- therefore it is best that if a client object is constructed, it should outlive the response object or be outside the try-catch block handling the errors from operations on responses. In code, usage should look like the following: .. code-block:: c++ http::client client; try { http::client::response response = client.get("http://www.example.com/"); std::cout << body(response); } catch (std::exception& e) { // deal with exceptions here } A common mistake is to declare the client inside the try block which invokes undefined behavior when errors arise from the handling of response objects. Previous examples cited by the documentation showed the short version of the code which didn't bother moving the ``http::client`` object outside of the same ``try`` block where the request/response objects are being used. Member Functions ---------------- In this section we assume that the following typedef is in effect: .. code-block:: c++ typedef boost::network::http::basic_client< boost::network::http::tags::http_default_8bit_udp_resolve , 1 , 1 > client; Also, that code using the HTTP client will have use the following header: .. code-block:: c++ #include .. note:: Starting version 0.9, cpp-netlib clients and server implementations by default now have an externally-linked component. This is a breaking change for code that used to rely on cpp-netlib being a header-only library, but can inhibited by defining the ``BOOST_NETWORK_NO_LIB`` preprocessor macro before including any cpp-netlib header. .. note:: Starting version 0.11, cpp-netlib clients and server implementations no longer support the ``BOOST_NETWORK_NO_LIB`` option. Constructors ~~~~~~~~~~~~ The client implementation can be default constructed, or customized at initialization. ``client()`` Default constructor. ``explicit client(client::options const &)`` Constructor taking a ``client_options`` object. The following table shows the options you can set on a ``client_options`` instance. +--------------------------+----------------------------+--------------------------+ | Parameter Name | Type | Description | +==========================+============================+==========================+ | follow_redirects | ``bool`` | Boolean to specify | | | | whether the client | | | | should follow HTTP | | | | redirects. Default is | | | | ``false``. | +--------------------------+----------------------------+--------------------------+ | cache_resolved | ``bool`` | Boolean to specify | | | | whether the client | | | | should cache resolved | | | | endpoints. The default | | | | is ``false``. | +--------------------------+----------------------------+--------------------------+ | io_service | ``shared_ptr`` | Shared pointer to a | | | | Boost.Asio | | | | ``io_service``. | +--------------------------+----------------------------+--------------------------+ | openssl_certificate | ``string`` | The filename of the | | | | certificate to load for | | | | the SSL connection for | | | | verification. | +--------------------------+----------------------------+--------------------------+ | openssl_verify_path | ``string`` | The directory from | | | | which the certificate | | | | authority files are | | | | located. | +--------------------------+----------------------------+--------------------------+ | always_verify_peer | ``bool`` | Boolean to specify | | | | whether the client | | | | should always verify | | | | peers in SSL connections | +--------------------------+----------------------------+--------------------------+ | openssl_certificate_file | ``string`` | Filename of the | | | | certificate to use for | | | | client-side SSL session | | | | establishment. | +--------------------------+----------------------------+--------------------------+ | openssl_private_key_file | ``string`` | Filename of the | | | | private key to use for | | | | client-side SSL session | | | | establishment. | +--------------------------+----------------------------+--------------------------+ | timeout | ``int`` | Number of seconds to | | | | wait for client requests | | | | before considering a | | | | timeout has occurred. | +--------------------------+----------------------------+--------------------------+ To use the above supported named parameters, you'll have code that looks like the following: .. code-block:: c++ using namespace boost::network::http; // parameters are in this namespace client::options options; options.follow_redirects(true) .cache_resolved(true) .io_service(boost::make_shared()) .openssl_certificate("/tmp/my-cert") .openssl_verify_path("/tmp/ca-certs") .timeout(10); client client_(options); // use client_ as normal from here on out. HTTP Methods ~~~~~~~~~~~~ The client implementation supports various HTTP methods. The following constructs assume that a client has been properly constructed named ``client_`` and that there is an appropriately constructed request object named ``request_`` and that there is an appropriately constructed response object named ``response_`` like the following: .. code-block:: c++ using namespace boost::network::http; // parameters are here client client_(); client::request request_("http://cpp-netib.github.com/"); client::response response_; ``response_ = client_.get(request_)`` Perform an HTTP GET request. ``response_ = client_.get(request_, callback)`` Perform an HTTP GET request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.head(request_)`` Perform an HTTP HEAD request. ``response_ = client_.post(request_)`` Perform an HTTP POST, use the data already set in the request object which includes the headers, and the body. ``response_ = client_.post(request_, callback)`` Perform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.post(request_, body)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. ``response_ = client_.post(request_, body, callback)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.post(request_, body, content_type)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. ``response_ = client_.post(request_, body, content_type, callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.post(request_, body, content_type, callback, streaming_callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. The ``streaming_callback`` argument should have a which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.post(request_, streaming_callback)`` Perform and HTTP POST request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.post(request_, callback, streaming_callback)`` Perform an HTTP POST request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.put(request_)`` Perform an HTTP PUT, use the data already set in the request object which includes the headers, and the body. ``response_ = client_.put(request_, callback)`` Perform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.put(request_, body)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. ``response_ = client_.put(request_, body, callback)`` Body is a string of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. The default content-type used is ``x-application/octet-stream``. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.put(request_, body, content_type)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. ``response_ = client_.put(request_, body, content_type, callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. ``response_ = client_.put(request_, body, content_type, callback, streaming_callback)`` The body and content_type parameters are of type ``boost::network::string::type`` where ``Tag`` is the HTTP Client's ``Tag``. This uses the request object's other headers. Have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent ``response_ = client_.put(request_, streaming_callback)`` Perform and HTTP PUT request, and have the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.put(request_, callback, streaming_callback)`` Perform an HTTP PUT request, and have the body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. This form also has the request's body chunks be generated by the ``streaming_callback`` which has a signature of the form: ``bool(string_type&)``. The provided ``string_type&`` will be streamed as soon as the function returns. A return value of ``false`` signals the client that the most recent invocation is the last chunk to be sent. ``response_ = client_.delete_(request_)`` Perform an HTTP DELETE request. ``response_ = client_.delete_(request_, body_handler=callback)`` Perform an HTTP DELETE request, and have the response body chunks be handled by the ``callback`` parameter. The signature of ``callback`` should be the following: ``void(iterator_range const &, boost::system::error_code const &)``. Client-Specific ~~~~~~~~~~~~~~~ ``client_.clear_resolved_cache()`` Clear the cache of resolved endpoints. Streaming Body Handler ~~~~~~~~~~~~~~~~~~~~~~ As of v0.9.1 the library now offers a way to support a streaming body callback function in all HTTP requests that expect a body part (GET, PUT, POST, DELETE). A convenience macro is also provided to make callback handlers easier to write. This macro is called ``BOOST_NETWORK_HTTP_BODY_CALLBACK`` which allows users to write the following code to easily create functions or function objects that are compatible with the callback function requirements. An example of how to use the macro is shown below: .. code-block:: c++ struct body_handler { explicit body_handler(std::string & body) : body(body) {} BOOST_NETWORK_HTTP_BODY_CALLBACK(operator(), range, error) { // in here, range is the Boost.Range iterator_range, and error is // the Boost.System error code. if (!error) body.append(boost::begin(range), boost::end(range)); } std::string & body; }; // somewhere else std::string some_string; response_ = client_.get(request("http://cpp-netlib.github.com/"), body_handler(some_string)); You can also use if for standalone functions instead if you don't want or need to create a function object. .. code-block:: c++ BOOST_NETWORK_HTTP_BODY_CALLBACK(print_body, range, error) { if (!error) std::cout << "Received " << boost::distance(range) << "bytes." << std::endl; else std::cout << "Error: " << error << std::endl; } // somewhere else response_ = client_.get(request("http://cpp-netlib.github.com/"), print_body); The ``BOOST_NETWORK_HTTP_BODY_CALLBACK`` macro is defined in ``boost/network/protocol/http/client/macros.hpp``. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/reference/http_request.rst000066400000000000000000000316521240331347200266040ustar00rootroot00000000000000 HTTP Request ============ This part of the documentation talks about the publicly accessible API of the HTTP Request objects. This section details the `Request Concepts`_ requirements, the implemented and required Directives_, Modifiers_, and Wrappers_ that work with the HTTP Request objects. Request Concepts ---------------- There are two generally supported Request Concepts implemented in the library. The first of two is the `Normal Client Request Concept`_ and the second is the `Pod Server Request Concept`_. The `Normal Client Request Concept`_ is what the HTTP Client interface requires. All operations performed internally by the HTTP Client abide by the interface required by this concept definition. The `Pod Server Request Concept`_ is as the name suggests what the HTTP Server implementation requires from Request Objects. Switching on whether the `Request` concept chooses either of the `Normal Client Request Concept`_ or the `Pod Server Request Concept`_ is done through the nested ``tag`` type and whether that tag derives from the root tag ``pod``. Simply, if the Request type's nested ``tag`` type derives from ``boost::network::tags::pod`` then it chooses to enforce the `Pod Server Request Concept`_, otherwise it chooses the `Normal Client Request Concept`_. Normal Client Request Concept ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A type models the Normal Client Request Concept if it models the `Message Concept`_ and also supports the following constructs. **Legend** :R: The request type. :r: An instance of R. :S: The string type. :s: An instance of S. :P: The port type. :p: An instance of P. +-----------------------+-------------+----------------------------------------+ | Construct | Result | Description | +=======================+=============+========================================+ | ``R::string_type`` | ``S`` | The nested ``string_type`` type. | +-----------------------+-------------+----------------------------------------+ | ``R::port_type`` | ``P`` | The nested ``port_type`` type. | +-----------------------+-------------+----------------------------------------+ | ``R r(s)`` | **NA** | Construct a Request with an ``s`` | | | | provided. This treats ``s`` as the URI | | | | to where the request is destined for. | +-----------------------+-------------+----------------------------------------+ | ``host(request)`` | Convertible | Return the host to where the request | | | to ``S`` | is destined for. | +-----------------------+-------------+----------------------------------------+ | ``port(request)`` | Convertible | Return the port to where the request | | | to ``P`` | is destined for. | +-----------------------+-------------+----------------------------------------+ | ``path(request)`` | Convertible | Return the path included in the URI. | | | to ``S`` | | +-----------------------+-------------+----------------------------------------+ | ``query(request)`` | Convertible | Return the query part of the URI. | | | to ``S`` | | +-----------------------+-------------+----------------------------------------+ | ``anchor(request)`` | Convertible | Return the anchor part of the URI. | | | to ``S`` | | +-----------------------+-------------+----------------------------------------+ | ``protocol(request)`` | Convertible | Return the protocol/scheme part of the | | | to ``S`` | URI. | +-----------------------+-------------+----------------------------------------+ | ``r << uri(s)`` | ``R&`` | Set the URI of the request. | +-----------------------+-------------+----------------------------------------+ | ``uri(r, s)`` | ``void`` | Set the URI of the request. | +-----------------------+-------------+----------------------------------------+ Pod Server Request Concept ~~~~~~~~~~~~~~~~~~~~~~~~~~ A type models the Pod Server Request Concept if it models the `Message Concept`_ and also supports the following constructs. **Legend** :R: The request type. :r: An instance of R. :S: The string type. :I: An unsigned 8 bit integer. :V: The vector type for headers. +-------------------------------+--------+-------------------------------------+ | Construct | Result | Description | +===============================+========+=====================================+ | ``R::string_type`` | ``S`` | The nested ``string_type`` type. | +-------------------------------+--------+-------------------------------------+ | ``R::headers_container_type`` | ``V`` | The nested | | | | ``headers_container_type`` type. | +-------------------------------+--------+-------------------------------------+ | ``r.source`` | ``S`` | The nested source of the request. | +-------------------------------+--------+-------------------------------------+ | ``r.method`` | ``S`` | The method of the request. | +-------------------------------+--------+-------------------------------------+ | ``r.destination`` | ``S`` | The destination of the request. | | | | This is normally the URI of the | | | | request. | +-------------------------------+--------+-------------------------------------+ | ``r.version_major`` | ``I`` | The major version number part of | | | | the request. | +-------------------------------+--------+-------------------------------------+ | ``r.version_minor`` | ``I`` | The minor version number part of | | | | the request. | +-------------------------------+--------+-------------------------------------+ | ``r.headers`` | ``V`` | The vector of headers. | +-------------------------------+--------+-------------------------------------+ | ``r.body`` | ``S`` | The body of the request. | +-------------------------------+--------+-------------------------------------+ .. _Message Concept: ../in_depth/message.html#message-concept Directives ---------- This section details the provided directives that are provided by :mod:`cpp-netlib`. The section was written to assume that an appropriately constructed request instance is either of the following: .. code-block:: c++ boost::network::http::basic_request< boost::network::http::tags::http_default_8bit_udp_resolve > request; // or boost::network::http::basic_request< boost::network::http::tags::http_server > request; The section also assumes that there following using namespace declaration is in effect: .. code-block:: c++ using namespace boost::network; Directives are meant to be used in the following manner: .. code-block:: c++ request << directive(...); .. warning:: There are two versions of directives, those that are applicable to messages that support narrow strings (``std::string``) and those that are applicable to messages that support wide strings (``std::wstring``). The :mod:`cpp-netlib` implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases. For now all the implemented directives are listed, even if some of them still do not implement things correctly. *unspecified* ``source(std::string const & source_)`` Create a source directive with a ``std::string`` as a parameter, to be set as the source of the request. *unspecified* ``source(std::wstring const & source_)`` Create a source directive with a ``std::wstring`` as a parameter, to be set as the source of the request. *unspecified* ``destination(std::string const & source_)`` Create a destination directive with a ``std::string`` as a parameter, to be set as the destination of the request. *unspecified* ``destination(std::wstring const & source_)`` Create a destination directive with a ``std::wstring`` as a parameter, to be set as the destination of the request. *unspecified* ``header(std::string const & name, std::string const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::string``. *unspecified* ``header(std::wstring const & name, std::wstring const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the request. In this case the name and values are both ``std::wstring``. *unspecified* ``remove_header(std::string const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::string``. *unspecified* ``remove_header(std::wstring const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the request. In this case the name of the header is of type ``std::wstring``. *unspecified* ``body(std::string const & body_)`` Create a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::string``. *unspecified* ``body(std::wstring const & body_)`` Create a body directive that will set the request's body to the given parameter. In this case the type of the body is an ``std::wstring``. Modifiers --------- This section details the provided modifiers that are provided by :mod:`cpp-netlib`. ``template inline void source(basic_request & request, typename string::type const & source_)`` Modifies the source of the given ``request``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void destination(basic_request & request, typename string::type const & destination_)`` Modifies the destination of the given ``request``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void add_header(basic_request & request, typename string::type const & name, typename string::type const & value)`` Adds a header to the given ``request``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void remove_header(basic_request & request, typename string::type const & name)`` Removes a header from the given ``request``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_request``. ``template inline void clear_headers(basic_request & request)`` Removes all headers from the given ``request``. ``template inline void body(basic_request & request, typename string::type const & body_)`` Modifies the body of the given ``request``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_request``. Wrappers -------- This section details the provided request wrappers that come with :mod:`cpp-netlib`. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect: .. code-block:: c++ using namespace boost::network; using namespace boost::network::http; ``template `` *unspecified* ``source(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the source of a given request. ``template `` *unspecified* ``destination(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the destination of a given request. ``template `` *unspecified* ``headers(basic_request const & request)`` Returns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_request::headers_container_type`` that provides the headers of a given request. ``template `` *unspecified* ``body(basic_request const & request)`` Returns a wrapper convertible to ``typename string::type`` that provides the body of a given request. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/reference/http_response.rst000066400000000000000000000433441240331347200267530ustar00rootroot00000000000000 HTTP Response ============= This part of the documentation talks about the publicly accessible API of the HTTP Response objects. This section details the `Response Concept`_ requirements, the implemented and required Directives_, Modifiers_, and Wrappers_ that work with the HTTP Response objects. .. note:: The HTTP server response object is a POD type, which doesn't support any of the following details. There are only a few fields available in the HTTP server response type, which can be seen in ``boost/network/protocol/http/impl/response.ipp``. Response Concept ---------------- A type models the Response Concept if it models the `Message Concept`_ and also supports the following constructs. **Legend** :R: The response type. :r: An instance of R. :S: The string type. :s,e,g: Instances of S. :P: The port type. :p: An instance of P. :V: The version type. :v: An instance of v. :T: The status type. :t: An instance of T. :M: The status message type. :m: An instance of M. :U: An unsigned 16-bit int. :u: An instance of U. .. note:: In the table below, the namespace ``traits`` is an alias for ``boost::network::http::traits``. +-------------------------------------+----------+-----------------------------+ | Construct | Result | Description | +=====================================+==========+=============================+ | ``R::string_type`` | ``S`` | The nested ``string_type`` | | | | type. | +-------------------------------------+----------+-----------------------------+ | ``traits::version::type`` | ``V`` | The version type associated | | | | with R. | +-------------------------------------+----------+-----------------------------+ | ``traits::status::type`` | ``T`` | The status type associated | | | | with R. | +-------------------------------------+----------+-----------------------------+ | ``traits::status_message::type`` | ``M`` | The status message type | | | | associated with R. | +-------------------------------------+----------+-----------------------------+ | ``r << version(v)`` | ``R&`` | Sets the version of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``r << status(t)`` | ``R&`` | Sets the status of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``r << status_message(m)`` | ``R&`` | Sets the status message of | | | | ``r``. | +-------------------------------------+----------+-----------------------------+ | ``version(r, v)`` | ``void`` | Sets the version of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``status(r, t)`` | ``void`` | Sets the status of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``status_message(r, m)`` | ``void`` | Sets the status message of | | | | ``r``. | +-------------------------------------+----------+-----------------------------+ | ``S e = version(r)`` | **NA** | Get the version of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``U u = status(r)`` | **NA** | Get the status of ``r``. | +-------------------------------------+----------+-----------------------------+ | ``S g = status_message(r)`` | **NA** | Get the status message of | | | | ``r``. | +-------------------------------------+----------+-----------------------------+ .. _Message Concept: ../in_depth/message.html#message-concept Directives ---------- This section details the provided directives that are provided by :mod:`cpp-netlib`. The section was written to assume that an appropriately constructed response instance is either of the following: .. code-block:: c++ boost::network::http::basic_response< boost::network::http::tags::http_default_8bit_udp_resolve > response; // or boost::network::http::basic_response< boost::network::http::tags::http_server > response; The section also assumes that there following using namespace declaration is in effect: .. code-block:: c++ using namespace boost::network; Directives are meant to be used in the following manner: .. code-block:: c++ response << directive(...); .. warning:: There are four versions of directives, those that are applicable to messages that support narrow strings (``std::string``), those that are applicable to messages that support wide strings (``std::wstring``), those that are applicable to messages that support future-wrapped narrow and wide strings (``boost::shared_future`` and ``boost::shared_future``). The :mod:`cpp-netlib` implementation still does not convert wide strings into UTF-8 encoded narrow strings. This will be implemented in subsequent library releases. For now all the implemented directives are listed, even if some of them still do not implement things correctly. *unspecified* ``source(std::string const & source_)`` Create a source directive with a ``std::string`` as a parameter, to be set as the source of the response. *unspecified* ``source(std::wstring const & source_)`` Create a source directive with a ``std::wstring`` as a parameter, to be set as the source of the response. *unspecified* ``source(boost::shared_future const & source_)`` Create a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response. *unspecified* ``source(boost::shared_future const & source_)`` Create a source directive with a ``boost::shared_future`` as a parameter, to be set as the source of the response. *unspecified* ``destination(std::string const & source_)`` Create a destination directive with a ``std::string`` as a parameter, to be set as the destination of the response. *unspecified* ``destination(std::wstring const & source_)`` Create a destination directive with a ``std::wstring`` as a parameter, to be set as the destination of the response. *unspecified* ``destination(boost::shared_future const & destination_)`` Create a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response. *unspecified* ``destination(boost::shared_future const & destination_)`` Create a destination directive with a ``boost::shared_future`` as a parameter, to be set as the destination of the response. *unspecified* ``header(std::string const & name, std::string const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the response. In this case the name and values are both ``std::string``. *unspecified* ``header(std::wstring const & name, std::wstring const & value)`` Create a header directive that will add the given name and value pair to the headers already associated with the response. In this case the name and values are both ``std::wstring``. *unspecified* ``remove_header(std::string const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the response. In this case the name of the header is of type ``std::string``. *unspecified* ``remove_header(std::wstring const & name)`` Create a remove_header directive that will remove all the occurences of the given name from the headers already associated with the response. In this case the name of the header is of type ``std::wstring``. *unspecified* ``body(std::string const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``std::string``. *unspecified* ``body(std::wstring const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``std::wstring``. *unspecified* ``body(boost::shared_future const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``. *unspecified* ``body(boost::shared_future const & body_)`` Create a body directive that will set the response's body to the given parameter. In this case the type of the body is an ``boost::shared_future``. *unspecified* ``version(std::string const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``std::string``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``version(std::wstring const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``std::wstring``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``version(boost::shared_future const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``version(boost::shared_future const & version_)`` Create a version directive that will set the response's version to the given parameter. In this case the type of the version is an ``boost::shared_future``. Note that this version includes the full ``"HTTP/"`` string. *unspecified* ``status_message(std::string const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``std::string``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status_message(std::wstring const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``std::wstring``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status_message(boost::shared_future const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status_message(boost::shared_future const & status_message_)`` Create a status_message directive that will set the response's status_message to the given parameter. In this case the type of the status_message is an ``boost::shared_future``. Note that this status_message includes the full ``"HTTP/"`` string. *unspecified* ``status(boost::uint16_t status_)`` Create a status directive that will set the response's status to the given parameter. In this case the type of ``status_`` is ``boost::uint16_t``. *unspecified* ``status(boost::shared_future const & status_)`` Create a status directive that will set the response's status to the given parameter. In this case the type of ``status_`` is ``boost::shared_future``. Modifiers --------- This section details the provided modifiers that are provided by :mod:`cpp-netlib`. ``template inline void source(basic_response & response, typename string::type const & source_)`` Modifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void source(basic_response & response, boost::shared_future::type> const & source_)`` Modifies the source of the given ``response``. The type of ``source_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void destination(basic_response & response, typename string::type const & destination_)`` Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void destination(basic_response & response, boost::shared_future::type> const & destination_)`` Modifies the destination of the given ``response``. The type of ``destination_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void add_header(basic_response & response, typename string::type const & name, typename string::type const & value)`` Adds a header to the given ``response``. The type of the ``name`` and ``value`` parameters are dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void remove_header(basic_response & response, typename string::type const & name)`` Removes a header from the given ``response``. The type of the ``name`` parameter is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void headers(basic_response & response, typename headers_container >::type const & headers_)`` Sets the whole headers contained in ``response`` as the given parameter ``headers_``. ``template inline void headers(basic_response & response, boost::shared_future >::type> const & headers_)`` Sets the whole headers contained in ``response`` as the given parameter ``headers_``. ``template inline void clear_headers(basic_response & response)`` Removes all headers from the given ``response``. ``template inline void body(basic_response & response, typename string::type const & body_)`` Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void body(basic_response & response, boost::shared_future::type> const & body_)`` Modifies the body of the given ``response``. The type of ``body_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void version(basic_response & response, typename traits::version >::type const & version_)`` Modifies the version of the given ``response``. The type of ``version_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void status(basic_response & response, typename traits::status >::type const & status_)`` Modifies the status of the given ``response``. The type of ``status_`` is dependent on the ``Tag`` specialization of ``basic_response``. ``template inline void status_message(basic_response & response, typename traits::status_message >::type const & status_message_)`` Modifies the status message of the given ``response``. The type of ``status_message_`` is dependent on the ``Tag`` specialization of ``basic_response``. Wrappers -------- This section details the provided response wrappers that come with :mod:`cpp-netlib`. Wrappers are used to convert a message into a different type, usually providing accessor operations to retrieve just part of the message. This section assumes that the following using namespace directives are in effect: .. code-block:: c++ using namespace boost::network; using namespace boost::network::http; ``template `` *unspecified* ``source(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the source of a given response. ``template `` *unspecified* ``destination(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the destination of a given response. ``template `` *unspecified* ``headers(basic_response const & response)`` Returns a wrapper convertible to ``typename headers_range >::type`` or ``typename basic_response::headers_container_type`` that provides the headers of a given response. ``template `` *unspecified* ``body(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the body of a given response. ``template `` *unspecified* ``version(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the version of the given response. ``template `` *unspecified* ``status(basic_response const & response)`` Returns a wrapper convertible to ``typename boost::uint16_t`` that provides the status of the given response. ``template `` *unspecified* ``status_message(basic_response const & response)`` Returns a wrapper convertible to ``typename string::type`` that provides the status message of the given response. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/reference/http_server.rst000066400000000000000000000654431240331347200264270ustar00rootroot00000000000000 HTTP Server API =============== General ------- :mod:`cpp-netlib` includes and implements two distinct HTTP server implementations that you can use and embed in your own applications. Both HTTP Server implementations: * **Cannot be copied.** This means you may have to store instances of the HTTP Server in dynamic memory if you intend to use them as function parameters or pass them around in smart pointers of by reference. * **Assume that requests made are independent of each other.** None of the HTTP Server implementations support request pipelining (yet) so a single connection only deals with a single request. * **Are header-only and are compiled-into your application.** Future releases in case you want to upgrade the implementation you are using in your application will be distributed as header-only implementations, which means you have to re-compile your application to use a newer version of the implementations. The HTTP Servers have different semantics, and in some cases require different APIs from the supplied template parameters. Implementations --------------- There are two different user-facing template classes that differentiate the `Synchronous Servers`_ from the `Asynchronous Servers`_. Both templates take a single template parameter named ``Handler`` which describes the type of the Handler function object. There are two different Handler concepts, one concept for `Synchronous Servers`_ and another for `Asynchronous Servers`. The SynchronousHandler concept for `Synchronous Servers`_ is described by the following table: --------------- **Legend:** H The Handler type. h An instance of H. Req A type that models the Request Concept. Res A type that models the Response Concept. req An instance of Req. res An instance of Res. +----------------+-------------+----------------------------------------------+ | Construct | Return Type | Description | +================+=============+==============================================+ | ``h(req,res)`` | ``void`` | Handle the request; res is passed in as a | | | | non-const lvalue, which represents the | | | | response to be returned to the client | | | | performing the request. | +----------------+-------------+----------------------------------------------+ More information about the internals of the `Synchronous Servers`_ can be found in the following section. The AsynchronousHandler concept for `Asynchronous Servers`_ is described by the following table: --------------- **Legend:** H The Handler type. h An instance of H. Req A type that models the Request Concept. ConnectionPtr A type that models the Connection Pointer Concept. req An instance of Req. conn An instance of ConncetionPtr. +------------------+-------------+--------------------------------------------+ | Construct | Return Type | Description | +==================+=============+============================================+ | ``h(req, conn)`` | ``void`` | Handle the request; conn is a shared | | | | pointer which exposes functions for | | | | writing to and reading from the connection.| +------------------+-------------+--------------------------------------------+ More information about the internals of the `Asynchronous Servers`_ can be found in the following section. Synchronous Servers ------------------- The synchronous server implementation is represented by the template ``server`` in namespace ``boost::network::http``. The ``server`` template takes in a single template parameter named ``Handler`` which models the SynchronousHandler concept (described above). An instance of Handler is taken in by reference to the constructor of the HTTP server. This means the Handler is not copied around and only a single instance of the handler is used for all connections and requests performed against the HTTP server. .. warning:: It is important to note that the HTTP server does not implement any locking upon invoking the Handler. In case you have any state in the Handler that will be associated with the synchronous server, you would have to implement your own synchronization internal to the Handler implementation. This matters especially if you run the synchronous server in multiple threads. The general pattern of usage for the HTTP Server template is shown below: .. code-block:: c++ struct handler; typedef boost::network::http::server http_server; struct handler { void operator()( http_server::request const & req, http_server::response & res ) { // do something, and then edit the res object here. } }; More information about the actual HTTP Server API follows in the next section. It is important to understand that the HTTP Server is actually embedded in your application, which means you can expose almost all your application logic through the Handler type, which you can also initialize appropriately. API Documentation ~~~~~~~~~~~~~~~~~ The following sections assume that the following file has been included: .. code-block:: c++ #include And that the following typedef's have been put in place: .. code-block:: c++ struct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()(http_server::request const & request, http_server::response & response) { // do something here } }; Constructor ``````````` ``explicit http_server(options)`` Construct an HTTP Server instance, passing in a ``server_options`` object. The following table shows the supported options in ``server_options``. +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | Parameter Name | Type | Description | +=======================+==========================================+==================================================================================================+ | address | string_type | The hostname or IP address from which the server should be bound to. This parameter is required. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | port | string_type | The port to which the server should bind and listen to. This parameter is required. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | thread_pool | ``shared_ptr`` | A shared pointer to an instance of ``boost::network::utils::thread_pool`` -- this is the | | | | thread pool from where the handler is invoked. This parameter is only applicable and required | | | | for ``async_server`` instances. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | io_service | ``shared_ptr`` | An optional lvalue to an instance of ``boost::asio::io_service`` which allows the server to use | | | | an already-constructed ``boost::asio::io_service`` instance instead of instantiating one that it | | | | manages. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | reuse_address | ``bool`` | A boolean that specifies whether to re-use the address and port on which the server will be | | | | bound to. This enables or disables the socket option for listener sockets. The default is | | | | ``false``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | report_aborted | ``bool`` | A boolean that specifies whether the listening socket should report aborted connection attempts | | | | to the accept handler (an internal detail of cpp-netlib). This is put in place to allow for | | | | future-proofing the code in case an optional error handler function is supported in later | | | | releases of cpp-netlib. The default is ``false``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | receive_buffer_size | ``int`` | The size of the socket's receive buffer. The default is defined by Boost.Asio and is | | | | platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | send_buffer_size | ``int`` | The size of the socket's send buffer. The default is defined by Boost.Asio and is | | | | platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | receive_low_watermark | ``int`` | The size of the socket's low watermark for its receive buffer. The default is defined by | | | | Boost.Asio and is platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | send_buffer_size | ``int`` | The size of the socket's send low watermark for its send buffer. The default is defined by | | | | Boost.Asio and is platform-dependent. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | non_blocking_io | ``bool`` | An optional bool to define whether the socket should use non-blocking I/O in case the platform | | | | supports it. The default is ``true``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | linger | ``bool`` | An optional bool to determine whether the socket should linger in case there's still data to be | | | | sent out at the time of its closing. The default is ``true``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | linger_timeout | ``int`` | An optional int to define the timeout to wait for socket closes before it is set to linger. | | | | The default is ``0``. | +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | context | ``shared_ptr`` | An optional shared pointer to an instance of ``boost::asio::ssl::context`` -- this contains the | | | | settings needed to support SSL. This parameter is only applicable for ``async_server`` instances.| +-----------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ To use the above supported named parameters, you'll have code that looks like the following: .. code-block:: c++ using namespace boost::network::http; // parameters are in this namespace handler handler_instance; sync_server::options options(handler_instance); options.address("0.0.0.0") .port("80") .io_service(boost::make_shared()) .reuse_address(true); sync_server instance(options); instance.run(); Public Members `````````````` The following definitions assume that a properly constructed ``http_server`` instance has been constructed in the following manner: .. code-block:: c++ handler_type handler; http_server::options options(handler); http_server server(options.address("127.0.0.1").port("8000")); ``server.run()`` Run the HTTP Server event loop. This function can be run on multiple threads following the example: .. code-block:: c++ boost::thread t1(boost::bind(&http_server::run, &server)); boost::thread t2(boost::bind(&http_server::run, &server)); server.run(); t1.join(); t2.join(); ``server.stop()`` Stop the HTTP Server acceptor and wait for all pending requests to finish. Response Object ``````````````` The response object has its own public member functions which can be very helpful in certain simple situations. ``response = http_server::response::stock_reply(status, body)`` Code like the above should go inside the handler's ``operator()`` overload. The body parameter is an ``std::string``. The status parameter is any of the following values from the ``http_server::response`` enum ``status_type``: .. code-block:: c++ enum status_type { ok = 200, created = 201, accepted = 202, no_content = 204, multiple_choices = 300, moved_permanently = 301, moved_temporarily = 302, not_modified = 304, bad_request = 400, unauthorized = 401, forbidden = 403, not_found = 404, not_supported = 405, not_acceptable = 406, internal_server_error = 500, not_implemented = 501, bad_gateway = 502, service_unavailable = 503 }; The response object also has the following publicly accessible member values which can be directly manipulated by the handler. +------------------+----------------------+------------------------------------+ | Member Name | Type | Description | +==================+======================+====================================+ | status | ``status_type`` | The HTTP status of the response. | +------------------+----------------------+------------------------------------+ | headers | ``vector
`` | Vector of headers. [#]_ | +------------------+----------------------+------------------------------------+ | content | ``string_type`` [#]_ | The contents of the response. | +------------------+----------------------+------------------------------------+ .. [#] A header is a struct of type ``response_header``. An instance always has the members ``name`` and ``value`` both of which are of type ``string_type``. .. [#] ``string_type`` is ``boost::network::string::type``. Asynchronous Servers -------------------- The asynchronous server implementation is significantly different to the synchronous server implementation in three ways: #. **The Handler instance is invoked asynchronously**. This means the I/O thread used to handle network-related events are free to handle only the I/O related events. This enables the server to scale better as to the number of concurrent connections it can handle. #. **The Handler is able to schedule asynchronous actions on the thread pool associated with the server.** This allows handlers to perform multiple asynchronous computations that later on perform writes to the connection. #. **The Handler is able to control the (asynchronous) writes to and reads from the HTTP connection.** Because the connection is available to the Handler, that means it can write out chunks of data at a time or stream data through the connection continuously. The asynchronous server is meant to allow for better scalability in terms of the number of concurrent connections and for performing asynchronous actions within the handlers. If your application does not need to write out information asynchronously or perform potentially long computations, then the synchronous server gives a generally better performance profile than the asynchronous server. The asynchronous server implementation is available from a single user-facing template named ``async_server``. This template takes in a single template parameter which is the type of the Handler to be called once a request has been parsed from a connection. An instance of Handler is taken as a reference to the constructor similar to the synchronous server implementation. .. warning:: The asynchronous server implementation, like the synchronous server implementation, does not perform any synchronization on the calls to the Handler invocation. This means if your handler contains or maintains internal state, you are responsible for implementing your own synchronization on accesses to the internal state of the Handler. The general pattern for using the ``async_server`` template is shown below: .. code-block:: c++ struct handler; typedef boost::network::http::async_server http_server; struct handler { void operator()( http_server::request const & req, http_server::connection_ptr connection ) { // handle the request here, and use the connection to // either read more data or write data out to the client } }; API Documentation ~~~~~~~~~~~~~~~~~ The following sections assume that the following file has been included: .. code-block:: c++ #include #include And that the following typedef's have been put in place: .. code-block:: c++ struct handler_type; typedef boost::network::http::server http_server; struct handler_type { void operator()(http_server::request const & request, http_server::connection_ptr connection) { // do something here } }; Constructor ``````````` ``explicit http_server(options)`` Construct an HTTP server instance passing in a ``server_options`` instance. Public Members `````````````` The following definitions assume that a properly constructed ``http_server`` instance has been constructed in the following manner: .. code-block:: c++ handler_type handler; http_server::options options(handler); options.thread_pool(boost::make_shared(2)); http_server server(options.address("127.0.0.1").port("8000")); ``server.run()`` Run the HTTP Server event loop. This function can be run on multiple threads following the example: .. code-block:: c++ boost::thread t1(boost::bind(&http_server::run, &server)); boost::thread t2(boost::bind(&http_server::run, &server)); server.run(); t1.join(); t2.join(); ``server.stop()`` Stop the HTTP Server acceptor and wait for all pending requests to finish. Connection Object ````````````````` The connection object has its own public member functions which will be the primary means for reading from and writing to the connection. ``template write(Range range)`` The connection object exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept. The write function, although it looks synchronous, starts of a series of asynchronous writes to the connection as soon as the range is serialized to appropriately sized buffers. To use this in your handler, it would look something like this: .. code-block:: c++ connection->write("Hello, world!"); std::string sample = "I have a string!"; connection->write(sample); ``template void write(Range range, Callback callback)`` The connection object also exposes a function ``write`` that can be given a parameter that adheres to the Boost.Range_ ``Single Pass Range`` Concept, as well as a Callback function that returns ``void`` and takes a ``boost::system::error_code`` as a parameter. This overload of ``write`` is useful for writing streaming applications that send out chunks of data at a time, or for writing data that may not all fit in memory right away. ``template void read(ReadCallback callback)`` The connection object has a function ``read`` which can be used to read more information from the connection. This ``read`` function takes in a callback that can be assigned to a Boost.Function_ with the signature ``void(input_range,error_code,size_t,connection_ptr)``. The following list shows what the types actually mean: * **input_range** -- ``boost::iterator_range`` : The range that denotes the data read from the connection. * **error_code** -- ``boost::system::error_code`` : The error code if there were any errors encountered from the read. * **size_t** -- ``std::size_t`` : The number of bytes transferred. * **connection_ptr** -- ``http_server::connection_ptr`` : A handle to the current connection, so that it is kept alive at the time of the read callback invocation. This interface is useful when doing reads of uploaded data that can be potentially large and may not fit in memory. The read handler is then responsible for dealing with the chunks of data available from the connection. ``void set_status(status_t new_status)`` The ``set_status`` function takes a parameter of type ``status_t`` which is an enum type nested in ``http_status::connection`` which is given in the following code listing. .. code-block:: c++ enum status_t { ok = 200 , created = 201 , accepted = 202 , no_content = 204 , multiple_choices = 300 , moved_permanently = 301 , moved_temporarily = 302 , not_modified = 304 , bad_request = 400 , unauthorized = 401 , forbidden = 403 , not_found = 404 , not_supported = 405 , not_acceptable = 406 , internal_server_error = 500 , not_implemented = 501 , bad_gateway = 502 , service_unavailable = 503 }; .. note:: You may set and re-set the status several times as long as you have not set the headers or sent data through the connection. If you do this after data has already been set, the function will throw an instance of ``std::logic_error``. ``template void set_headers(Range range)`` The ``set_headers`` function takes a Single Pass Range of ``boost::network::http::response_header`` instances and linearizes them to a buffer with at most ``BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE`` and immediately schedules an asynchronous write once that is done. The function throws an instance of ``std::logic_error`` if you try to set the headers for a connection more than once. Adding SSL support to Asynchronous Server ----------------------------------------- In order to setup SSL support for an Asynchronous Server, it is best to start from a regular Asynchronous Server (see above). Once this server is setup, SSL can be enabled by adding a Boost.Asio.Ssl.Context_ to the options. The settings that can be used are defined in the link. .. code-block:: c++ // Initialize SSL context boost::shared_ptr ctx = boost::make_shared(boost::asio::ssl::context::sslv23); ctx->set_options( boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use); // Set keys ctx->set_password_callback(password_callback); ctx->use_certificate_chain_file("server.pem"); ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem); ctx->use_tmp_dh_file("dh512.pem"); handler_type handler; http_server::options options(handler); options.thread_pool(boost::make_shared(2)); http_server server(options.address("127.0.0.1").port("8442").context(ctx)); std::string password_callback(std::size_t max_length, boost::asio::ssl::context_base::password_purpose purpose) { return std::string("test"); } .. _Boost.Range: http://www.boost.org/libs/range .. _Boost.Function: http://www.boost.org/libs/function .. _Boost.Asio.SSL.Context: http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/ssl__context.html cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/references.rst000066400000000000000000000020141240331347200242260ustar00rootroot00000000000000References ========== About :mod:`cpp-netlib` ~~~~~~~~~~~~~~~~~~~~~~~ * `BoostCon 2010 Slides`_ * `BoostCon 2010 Paper`_ Other sources ~~~~~~~~~~~~~ * `Template Metaprogramming`_: The best guide to C++ template metaprogramming. * `HTTP 1.0`_: The HTTP 1.0 specification. * `HTTP 1.1 (RFC 2616)`_: The HTTP 1.1 specification. * `URI Generic Syntax (RFC 3986)`_: Generic URI syntax specification. * `Format for Literal IPv6 Addresses in URLs (RFC 2732)`_: Literal IPv6 Addresses in URLs. .. _`BoostCon 2010 Slides`: http://www.filetolink.com/b0e89d06 .. _`BoostCon 2010 Paper`: http://github.com/downloads/mikhailberis/cpp-netlib-boostcon-paper/cpp-netlib.pdf .. _`Template Metaprogramming`: http://www.boostpro.com/mplbook/ .. _`HTTP 1.0`: http://www.w3.org/Protocols/HTTP/1.0/spec.html .. _`HTTP 1.1 (RFC 2616)`: http://www.w3.org/Protocols/rfc2616/rfc2616.html .. _`URI Generic Syntax (RFC 3986)`: http://www.ietf.org/rfc/rfc3986.txt .. _`Format for Literal IPv6 Addresses in URLs (RFC 2732)`: http://www.ietf.org/rfc/rfc2732.txt cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/techniques.rst000066400000000000000000000004111240331347200242540ustar00rootroot00000000000000Techniques ========== The :mod:`cpp-netlib` uses several advanced techniques to achieve it's aims. This chapter describes some of those techniques. .. toctree:: :maxdepth: 1 techniques/tag_metafunctions techniques/directives techniques/polymorphism cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/techniques/000077500000000000000000000000001240331347200235265ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/techniques/directives.rst000066400000000000000000000066741240331347200264360ustar00rootroot00000000000000Directives ========== 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 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 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. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/techniques/polymorphism.rst000066400000000000000000000065001240331347200270230ustar00rootroot00000000000000Static and dynamic polymorphism =============================== With a header only library, you can only do so much with static polymorphism alone. There are some situations where you have to handle dynamic polymorphism because of unavoidable runtime-based decision making. Although you can deal with the base types that remain static, behavior can vary greatly which derived type should be handling the situation based on runtime values. This situation comes up in the :mod:`cpp-netlib` when we decide what kind of connection handler to use for a given HTTP URI -- whether it's plain HTTP or HTTPS. Although the HTTP semantics are the same for HTTP and HTTPS the implementation of the connection handler greatly varies on whether to use a plain TCP connection or an SSL-wrapped TCP connection. The general pattern or technique is to combine tag-based dispatch with a strategy factory, all while not requiring any externally built libraries. Doing it in a header-only library requires a little creativity and additional layers of indirection that you otherwise will not need for a library with externally built static/dynamic libraries. First we define the base type which we want to support dynamic behavior with. There's nothing special with the base type, except that it supports the tag dispatch earlier defined and has a virtual destructor. In code it looks like this: .. code-block:: c++ template struct base { virtual void foo() = 0; // make this an abstract base virtual ~base() { // do the base destructor thing here. } }; We then define a set of derived types that specialize the implementation of the ``foo`` member function. To facilitate the dispatch of the correct type based on an input, we create a strategy factory function: .. code-block:: c++ template unique_ptr > strategy(int input, Tag) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; // ... default: ptr.reset(0); break; } return ptr; } unique_ptr > ptr = strategy(input, default_()); // input is a runtime value The strategy factory can be a standalone function, or a static member of a factory class that is specialized by tag dispatch. This can be done like the following: .. code-block:: c++ template struct strategy; template <> struct strategy { static unique_ptr > create(int input) { unique_ptr > ptr; switch(input) { case 0: ptr.reset(new derived0()); break; case 1: ptr.reset(new derived1()); break; //... default: ptr.reset(0); break; } return ptr; } }; This approach allows the header-only libraries to define new dynamic types in subsequent versions of the library while keeping the static-dynamic bridge fluid. The only down-side to this is the possibility of derived type explosion in case there are a lot of different strategies or specializations available -- this though is not unique to static-dynamic bridging, but is also a problem with pure object oriented programming with dynamic polymorphism. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/techniques/tag_metafunctions.rst000066400000000000000000000130661240331347200300000ustar00rootroot00000000000000Tag metafunctions ================= Sometimes you want to vary a function or a type's behavior based on a static parameter. In the :mod:`cpp-netlib` there are a number of things you might want to change based on some such parameter -- like what the underlying string type should be and how large a buffer should be, among other things. The primary way to define this in a header-only manner is to use tag-based metafunctions. The skeleton of the approach is based on a similar technique for defining type traits. In the :mod:`cpp-netlib` however the type traits are defined on opaque tag types which serve to associate results to a family of metafunctions. Template Specialization ----------------------- To illustrate this point, let's define a tag ``default_`` which we use to denote the default implementation of a certain type ``foo``. For instance we decide that the default string type we will use for ``default_`` tagged ``foo`` specializations will be an ``std::string``. In the :mod:`cpp-netlib` this is done by defining a ``string`` metafunction type that is specialized on the tag ``default_`` whose nested ``type`` result is the type ``std::string``. In code this would translate to: .. code-block:: c++ template struct string { typedef void type; }; struct default_; template <> struct string { typedef std::string type; }; Template Metaprogramming ------------------------ Starting with version 0.7, the tag dispatch mechanism changed slightly to use Boost.MPL_. The idea is still the same, although we can get a little smarter than just using template specializations. Instead of just defining an opaque type ``default_``, we use the Boost.MPL equivalent of a vector to define which root types of properties this ``default_`` tag supports. The idea is to make the opaque type ``default_`` inherit property tags which the library supports internally as definite extension points. .. _Boost.MPL: http://www.boost.org/libs/mpl/index.html Our definition of the ``default_`` tag will then look something like the following: .. code-block:: c++ typedef mpl::vector default_tags; template struct components; typedef mpl::inherit_linearly< default_tags, mpl::inherit >::type default_; template struct components { typedef default_tags type; }; In the above listing, ``default_string`` is what we call a "root" tag which is meant to be combined with other "root" tags to form composite tags. In this case our composite tag is the tag ``default_``. There are a number of these "root" tags that :mod:`cpp-netlib` provides. These are in the namespace ``boost::network::tags`` and are defined in ``boost/network/tags.hpp``. Using this technique we change slightly our definition of the ``string`` metafunction class into this: .. code-block:: c++ template struct unsupported_tag; template struct string : mpl::if_< is_base_of< tags::default_string, Tag >, std::string, unsupported_tag > {}; Notice that we don't have the typedef for ``type`` in the body of ``string`` anymore, but we do inherit from ``mpl::if_``. Since ``mpl::if_`` is a template metafunction itself, it contains a definition of the resulting ``type`` which ``string`` inherits. You can see the real definition of the ``string`` metafunction in ``boost/network/traits/string.hpp``. Using Tags ---------- Once we have the defined tag, we can then use this in the definition of our types. In the definition of the type ``foo`` we use this type function ``string`` and pass the tag type parameter to determine what to use as the string type in the context of the type ``foo``. In code this would translate into: .. code-block:: c++ template struct foo { typedef typename string::type string_type; // .. use string_type where you need a string. }; Using this approach we can support different types of strings for different tags on the type ``foo``. In case we want to use a different type of string for the tag ``default_`` we only change the composition of the ``string_tags`` MPL vector. For example, in :mod:`cpp-netlib` there is a root tag ``default_wstring`` which causes the ``string`` metafunction to define ``std::wstring`` as the resulting type. The approach also allows for the control of the structure and features of types like ``foo`` based on the specialization of the tag. Whole type function families can be defined on tags where they are supported and ignored in cases where they are not. To illustrate let's define a new tag ``swappable``. Given the above definition of ``foo``, we want to make the ``swappable``-tagged ``foo`` define a ``swap`` function that extends the original ``default_``-tagged ``foo``. In code this would look like: .. code-block:: c++ struct swappable; template <> struct foo : foo { void swap(foo & other) { // ... } }; We also for example want to enable an ADL-reachable ``swap`` function: .. code-block:: c++ struct swappable; inline void swap(foo & left, foo & right) { left.swap(right); } Overall what the tag-based definition approach allows is for static definition of extension points that ensures type-safety and invariants. This keeps the whole extension mechanism static and yet flexible. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/doc/whats_new.rst000066400000000000000000000211121240331347200241040ustar00rootroot00000000000000.. _whats_new: ************ What's New ************ :mod:`cpp-netlib` 0.11 ---------------------- v0.11.1 ~~~~~~~ * Add support for request timeouts. * Build configuration fixes. * Support for Travis CI in-project config. * Make the response parser more flexible to support older/ad-hoc servers that don't have standard format responses. * Fix some instability in the client destructor. * MSVC 2010 specific fixes. v0.11.0 ~~~~~~~ * Fix thread leak in DNS resolution failure (`#245`_) * Remove unsupported `client_fwd.hpp` header (`#277`_) * Remove support for header-only usage (`#129`_) -- this means that the BOOST_NETWORK_NO_LIB option is no longer actually supported. * Deprecate Synchronous Client implementations (`#279`_) * Support streaming body chunks for PUT/POST client requests (`#27`_) * Fix non-case-sensitive header parsing for some client tags (`#313`_) * Remove unsupported Jamfiles from the whole project (`#316`_) * Add ``make install`` for Linux and OS X (`#285`_) * Fix incorrect Body processing (`#69`_) * Support chunked transfer encoding from HTTP responses (`#86`_) * Make OS X Clang builds use C++11 and libc++. * Update Boost requirement to 1.54.0. * Experimental Base64 encoding/decoding library (`#287`_) * *Known test failure:* OS X Xcode Clang 5.0 + Boost 1.54.0 + libc++ don't play well with Boost.Serialization issues, mitigate test breakage but ``cpp-netlib-utils_base64_test`` still fails in this platform. (`#287`_) * Provide a client option to always validate peers for HTTPS requests made by the client. (`#349`_) * Back-port fix for `#163`_ for improved URI parsing. * Added support for client-side certificates and private keys (`#361`_). .. _`#129`: https://github.com/cpp-netlib/cpp-netlib/issues/129 .. _`#163`: https://github.com/cpp-netlib/cpp-netlib/issues/163 .. _`#245`: https://github.com/cpp-netlib/cpp-netlib/issues/245 .. _`#277`: https://github.com/cpp-netlib/cpp-netlib/issues/277 .. _`#279`: https://github.com/cpp-netlib/cpp-netlib/issues/279 .. _`#27`: https://github.com/cpp-netlib/cpp-netlib/issues/27 .. _`#285`: https://github.com/cpp-netlib/cpp-netlib/issues/285 .. _`#287`: https://github.com/cpp-netlib/cpp-netlib/issues/287 .. _`#313`: https://github.com/cpp-netlib/cpp-netlib/issues/313 .. _`#316`: https://github.com/cpp-netlib/cpp-netlib/issues/316 .. _`#349`: https://github.com/cpp-netlib/cpp-netlib/issues/349 .. _`#69`: https://github.com/cpp-netlib/cpp-netlib/issues/69 .. _`#86`: https://github.com/cpp-netlib/cpp-netlib/issues/86 .. _`#361`: https://github.com/cpp-netlib/cpp-netlib/pull/361 :mod:`cpp-netlib` 0.10 ---------------------- v0.10.1 ~~~~~~~ * Documentation updates (`#182`_, `#265`_, `#194`_, `#233`_, `#255`_) * Fix issue with async server inadvertently stopping from listening when accepting a connection fails. (`#172`_) * Allow overriding and ultimately removing defaulted headers from HTTP requests. (`#263`_) * Add `-Wall` to the base rule for GCC builds. (`#264`_) * Make the server implementation throw on startup errors. (`#166`_) .. _`#182`: https://github.com/cpp-netlib/cpp-netlib/issues/182 .. _`#265`: https://github.com/cpp-netlib/cpp-netlib/issues/265 .. _`#194`: https://github.com/cpp-netlib/cpp-netlib/issues/194 .. _`#172`: https://github.com/cpp-netlib/cpp-netlib/issues/172 .. _`#263`: https://github.com/cpp-netlib/cpp-netlib/issues/263 .. _`#233`: https://github.com/cpp-netlib/cpp-netlib/issues/233 .. _`#264`: https://github.com/cpp-netlib/cpp-netlib/issues/264 .. _`#255`: https://github.com/cpp-netlib/cpp-netlib/issues/255 .. _`#166`: https://github.com/cpp-netlib/cpp-netlib/issues/166 v0.10.0 ~~~~~~~ * Added support for more HTTP status codes (206, 408, 412, 416, 507). * Refactored the parser for chunked encoding. * Fixed parsing chunked encoding if the response body has ``CLRFCLRF``. * Added librt dependency on Linux. * Check the callback in the asynchronous client before calling it. * Fixed issues `#110`_, `#168`_, `#213`_. .. _`#110`: https://github.com/cpp-netlib/cpp-netlib/issues/110 .. _`#168`: https://github.com/cpp-netlib/cpp-netlib/issues/168 .. _`#213`: https://github.com/cpp-netlib/cpp-netlib/issues/213 :mod:`cpp-netlib` 0.9 --------------------- v0.9.5 ~~~~~~ * Removed dependency on Boost.Parameter from HTTP client and server. * Fixed for Clang error on Twitter example. * Added source port to the request (HTTP server). * Updated CMake config for MSVC 2010/2012. * Now support chunked content encoding in client response parsing. * Fixed bug with client not invoking callback when a request fails. v0.9.4 ~~~~~~ * Lots of URI fixes. * Fixed async_server's request handler so it doesn't make copies of the supplied handler. * Fix for issue `#73`_ regarding SSL connections ending in short read errors. * Final C++03-only release. .. _`#73`: https://github.com/cpp-netlib/cpp-netlib/issues/73 v0.9.3 ~~~~~~ * URI, HTTP client and HTTP server are now built as static libraries (``libcppnetlib-uri.a``, ``libcppnetlib-client-connections.a`` and ``libcppnetlib-server-parsers.a`` on Linux and ``cppnetlib-uri.lib``, ``cppnetlib-client-connections.lib`` and ``cppnetlib-server-parsers.lib`` on Windows). * Updated URI parser. * A new URI builder. * URI support for IPv6 RFC 2732. * Fixed issues `#67`_, `#72`_, `#78`_, `#79`_, `#80`_, `#81`_, `#82`_, `#83`_. * New examples for the HTTP client, including an Atom feed, an RSS feed and a very simple client that uses the Twitter Search API. .. _`#67`: https://github.com/cpp-netlib/cpp-netlib/issues/67 .. _`#72`: https://github.com/cpp-netlib/cpp-netlib/issues/72 .. _`#78`: https://github.com/cpp-netlib/cpp-netlib/issues/78 .. _`#79`: https://github.com/cpp-netlib/cpp-netlib/issues/79 .. _`#80`: https://github.com/cpp-netlib/cpp-netlib/issues/80 .. _`#81`: https://github.com/cpp-netlib/cpp-netlib/issues/81 .. _`#82`: https://github.com/cpp-netlib/cpp-netlib/issues/82 .. _`#83`: https://github.com/cpp-netlib/cpp-netlib/issues/83 v0.9.2 ~~~~~~ * Critial bug fixes to v0.9.1. v0.9.1 ~~~~~~ * Introduced macro ``BOOST_NETWORK_DEFAULT_TAG`` to allow for programmatically defining the default flag to use throughout the compilation unit. * Support for streaming body handlers when performing HTTP client operations. See documentation for HTTP client interface for more information. * Numerous bug fixes from v0.9.0. * Google, Inc. contributions. v0.9.0 ~~~~~~ * **IMPORTANT BREAKING CHANGE**: By default all compile-time heavy parser implementations are now compiled to external static libraries. In order to use :mod:`cpp-netlib` in header-only mode, users must define the preprocessor macro ``BOOST_NETWORK_NO_LIB`` before including any :mod:`cpp-netlib` header. This breaks code that relied on the version 0.8.x line where the library is strictly header-only. * Fix issue #41: Introduce a macro ``BOOST_NETWORK_HTTP_CLIENT_DEFAULT_TAG`` which makes the default HTTP client use ``tags::http_async_8bit_udp_resolve`` as the tag. * Fix issue #40: Write the status line and headers in a single buffer write instead of two writes. * More consistent message API for client and server messages (request and response objects). * Refactoring of internal implementations to allow better separation of concerns and more manageable coding/documentation. * Client and server constructors that support Boost.Parameter named parameters. * Client and server constructors now take in an optional reference to a Boost.Asio ``io_service`` to use internally. * Documentation updates to reflect new APIs. :mod:`cpp-netlib` 0.8 --------------------- * Updates to URI unit tests and documentation. * More documentation, covering the HTTP Client and HTTP Server APIs * Asynchronous HTTP Server that now supports running request handlers on a different thread pool. * An initial thread pool implementation, using Boost.Asio underneath. * Adding a ready(...) wrapper to check whether a response object returned by the asynchronous client in 0.7 already has all the parts available. * Some attempts at lowering compile time costs. :mod:`cpp-netlib` 0.7 --------------------- * Radical documentation overhaul * Asynchronous HTTP client * Tag dispatch overhaul, using Boost.MPL * HTTP Client Facade refactoring * Bug fixes for HTTP 1.1 response parsing * Minimized code repetition with some header macro's * Configurable HTTPS support in the library with ``BOOST_NETWORK_ENABLE_HTTPS`` :mod:`cpp-netlib` 0.6 --------------------- * Many fixes for MSVC compiler :mod:`cpp-netlib` 0.5 --------------------- * An embeddable HTTP 1.1 server * An HTTP 1.1 client upgraded to support HTTPS * An updated URI parser implementation * An asynchronous HTTP 1.1 client * An HTTP 1.1 client that supports streaming function handlers cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/000077500000000000000000000000001240331347200222445ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/CMakeLists.txt000066400000000000000000000142031240331347200250040ustar00rootroot00000000000000# Copyright (c) Dean Michael Berris 2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) include_directories(${CPP-NETLIB_SOURCE_DIR}) if (OPENSSL_FOUND) include_directories(${OPENSSL_INCLUDE_DIR}) endif (OPENSSL_FOUND) add_executable(http_client http_client.cpp) add_executable(simple_wget simple_wget.cpp) add_executable(atom_reader atom/atom.cpp atom/main.cpp) add_executable(rss_reader rss/rss.cpp rss/main.cpp) add_executable(twitter_search twitter/search.cpp) add_executable(hello_world_server http/hello_world_server.cpp) add_executable(hello_world_client http/hello_world_client.cpp) add_executable(hello_world_async_server_with_work_queue http/hello_world_async_server_with_work_queue.cpp) add_executable(trivial_google trivial_google.cpp) if (UNIX) add_executable(fileserver http/fileserver.cpp) endif (UNIX) add_dependencies(http_client cppnetlib-uri cppnetlib-client-connections) add_dependencies(simple_wget cppnetlib-uri cppnetlib-client-connections) add_dependencies(atom_reader cppnetlib-uri cppnetlib-client-connections) add_dependencies(rss_reader cppnetlib-uri cppnetlib-client-connections) add_dependencies(twitter_search cppnetlib-uri cppnetlib-client-connections) add_dependencies(trivial_google cppnetlib-uri cppnetlib-client-connections) set(BOOST_CLIENT_LIBS ${Boost_PROGRAM_OPTIONS_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_DATE_TIME_LIBRARY} ${Boost_REGEX_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${Boost_FILESYSTEM_LIBRARY} ${Boost_CHRONO_LIBRARY}) set(BOOST_SERVER_LIBS ${Boost_THREAD_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${Boost_DATE_TIME_LIBRARY} ${Boost_REGEX_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ${Boost_FILESYSTEM_LIBRARY} ${Boost_CHRONO_LIBRARY}) target_link_libraries(http_client ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(simple_wget ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(atom_reader ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(rss_reader ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(twitter_search ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(trivial_google ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(hello_world_server ${BOOST_SERVER_LIBS} ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries(hello_world_client ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(hello_world_async_server_with_work_queue ${BOOST_CLIENT_LIBS} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections cppnetlib-server-parsers) if (OPENSSL_FOUND) target_link_libraries(http_client ${OPENSSL_LIBRARIES}) target_link_libraries(simple_wget ${OPENSSL_LIBRARIES}) target_link_libraries(atom_reader ${OPENSSL_LIBRARIES}) target_link_libraries(rss_reader ${OPENSSL_LIBRARIES}) target_link_libraries(twitter_search ${OPENSSL_LIBRARIES}) target_link_libraries(hello_world_server ${OPENSSL_LIBRARIES}) target_link_libraries(hello_world_client ${OPENSSL_LIBRARIES}) target_link_libraries(hello_world_async_server_with_work_queue ${OPENSSL_LIBRARIES}) target_link_libraries(trivial_google ${OPENSSL_LIBRARIES}) endif (OPENSSL_FOUND) if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU AND ${CMAKE_SYSTEM_NAME} MATCHES "Windows") target_link_libraries(http_client ws2_32) target_link_libraries(simple_wget ws2_32) target_link_libraries(atom_reader ws2_32) target_link_libraries(rss_reader ws2_32) target_link_libraries(twitter_search ws2_32) target_link_libraries(hello_world_server ws2_32 wsock32) target_link_libraries(hello_world_client ws2_32) target_link_libraries(hello_world_async_server_with_work_queue ws2_32 wsock32) target_link_libraries(trivial_google ws2_32) endif() if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") target_link_libraries(http_client rt) target_link_libraries(simple_wget rt) target_link_libraries(atom_reader rt) target_link_libraries(rss_reader rt) target_link_libraries(twitter_search rt) target_link_libraries(hello_world_server rt) target_link_libraries(hello_world_client rt) target_link_libraries(hello_world_async_server_with_work_queue rt) target_link_libraries(trivial_google rt) endif() if (UNIX) target_link_libraries(fileserver ${BOOST_SERVER_LIBS} ${Boost_FILESYSTEM_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-server-parsers) if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") target_link_libraries(fileserver rt) endif() if (OPENSSL_FOUND) target_link_libraries(fileserver ${OPENSSL_LIBRARIES}) endif(OPENSSL_FOUND) endif (UNIX) set_target_properties(http_client PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(simple_wget PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(atom_reader PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(rss_reader PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(twitter_search PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(trivial_google PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(hello_world_server PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(hello_world_client PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) set_target_properties(hello_world_async_server_with_work_queue PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) if (UNIX) set_target_properties(fileserver PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) endif (UNIX) cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/atom/000077500000000000000000000000001240331347200232045ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/atom/atom.cpp000066400000000000000000000053301240331347200246510ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include "atom.hpp" #include "../rapidxml/rapidxml.hpp" #include #include namespace boost { namespace network { namespace atom { feed::feed(const http::client::response &response) { std::string response_body = body(response); rapidxml::xml_document<> doc; doc.parse<0>(const_cast(response_body.c_str())); rapidxml::xml_node<> *feed = doc.first_node("feed"); if (!feed) { throw std::runtime_error("Invalid atom feed."); } rapidxml::xml_node<> *title = feed->first_node("title"); if (title) { title_ = title->first_node()->value(); } rapidxml::xml_node<> *subtitle = feed->first_node("subtitle"); if (subtitle) { subtitle_ = subtitle->first_node()->value(); } rapidxml::xml_node<> *id = feed->first_node("id"); if (id) { id_ = id->first_node()->value(); } rapidxml::xml_node<> *updated = feed->first_node("updated"); if (updated) { updated_ = updated->first_node()->value(); } rapidxml::xml_node<> *author = feed->first_node("author"); if (author) { rapidxml::xml_node<> *name = author->first_node("name"); rapidxml::xml_node<> *email = author->first_node("email"); if (name && email) { author_ = atom::author(name->first_node()->value(), email->first_node()->value()); } else if (name) { author_ = atom::author(name->first_node()->value()); } } rapidxml::xml_node<> *entry = feed->first_node("entry"); while (entry) { entries_.push_back(atom::entry()); rapidxml::xml_node<> *title = entry->first_node("title"); if (title) { entries_.back().set_title(title->first_node()->value()); } rapidxml::xml_node<> *id = entry->first_node("id"); if (id) { entries_.back().set_id(id->first_node()->value()); } rapidxml::xml_node<> *published = entry->first_node("published"); if (published) { entries_.back().set_published(published->first_node()->value()); } rapidxml::xml_node<> *updated = entry->first_node("updated"); if (updated) { entries_.back().set_updated(updated->first_node()->value()); } rapidxml::xml_node<> *summary = entry->first_node("summary"); if (summary) { entries_.back().set_summary(summary->first_node()->value()); } rapidxml::xml_node<> *content = entry->first_node("content"); if (content) { entries_.back().set_content(content->first_node()->value()); } entry = entry->next_sibling(); } } } // namespace atom } // namespace network } // namespace boost cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/atom/atom.hpp000066400000000000000000000050671240331347200246650ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef ___ATOM_INC__ #define ___ATOM_INC__ #include #include #include namespace boost { namespace network { namespace atom { class entry { public: void set_title(const std::string &title) { title_ = title; } std::string title() const { return title_; } void set_id(const std::string &id) { id_ = id; } std::string id() const { return id_; } void set_published(const std::string &published) { published_ = published; } std::string published() const { return published_; } void set_updated(const std::string &updated) { updated_ = updated; } std::string updated() const { return updated_; } void set_summary(const std::string &summary) { summary_ = summary; } std::string summary() const { return summary_; } void set_content(const std::string &content) { content_ = content; } std::string content() const { return content_; } private: std::string title_; std::string id_; std::string published_; std::string updated_; std::string summary_; std::string content_; }; class author { public: author() {} author(const std::string &name) : name_(name) {} author(const std::string &name, const std::string &email) : name_(name), email_(email) {} std::string name() const { return name_; } std::string email() const { return email_; } private: std::string name_; std::string email_; }; class feed { public: typedef entry value_type; typedef std::vector::iterator iterator; typedef std::vector::const_iterator const_iterator; feed(const http::client::response &response); std::string title() const { return title_; } std::string subtitle() const { return subtitle_; } std::string id() const { return id_; } std::string updated() const { return updated_; } atom::author author() const { return author_; } unsigned int entry_count() const { return entries_.size(); } iterator begin() { return entries_.begin(); } iterator end() { return entries_.end(); } const_iterator begin() const { return entries_.begin(); } const_iterator end() const { return entries_.end(); } private: std::string title_; std::string subtitle_; std::string id_; std::string updated_; atom::author author_; std::vector entries_; }; } // namespace atom } // namespace network } // namespace boost #endif // ___ATOM_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/atom/main.cpp000066400000000000000000000020661240331347200246400ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include "atom.hpp" #include #include #include int main(int argc, char *argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); atom::feed feed(response); std::cout << "Feed: " << feed.title() << " (" << feed.subtitle() << ")" << std::endl; BOOST_FOREACH(const atom::entry & entry, feed) { std::cout << entry.title() << " (" << entry.published() << ")" << std::endl; } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/000077500000000000000000000000001240331347200232235ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/fileserver.cpp000066400000000000000000000154261240331347200261050ustar00rootroot00000000000000// Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include namespace http = boost::network::http; namespace utils = boost::network::utils; struct file_server; typedef http::async_server server; struct file_cache { typedef std::map > region_map; typedef std::map > meta_map; std::string doc_root_; region_map regions; meta_map file_headers; boost::shared_mutex cache_mutex; explicit file_cache(std::string const &doc_root) : doc_root_(doc_root) {} ~file_cache() throw() { BOOST_FOREACH(region_map::value_type const & region, regions) { munmap(region.second.first, region.second.second); } } bool has(std::string const &path) { boost::shared_lock lock(cache_mutex); return regions.find(doc_root_ + path) != regions.end(); } bool add(std::string const &path) { boost::upgrade_lock lock(cache_mutex); std::string real_filename = doc_root_ + path; if (regions.find(real_filename) != regions.end()) return true; #ifdef O_NOATIME int fd = open(real_filename.c_str(), O_RDONLY | O_NOATIME | O_NONBLOCK); #else int fd = open(real_filename.c_str(), O_RDONLY | O_NONBLOCK); #endif if (fd == -1) return false; std::size_t size = lseek(fd, 0, SEEK_END); void *region = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0); if (region == MAP_FAILED) { close(fd); return false; } boost::upgrade_to_unique_lock unique_lock(lock); regions.insert(std::make_pair(real_filename, std::make_pair(region, size))); static server::response_header common_headers[] = { {"Connection", "close"}, {"Content-Type", "x-application/octet-stream"}, {"Content-Length", "0"}}; std::vector headers(common_headers, common_headers + 3); headers[2].value = boost::lexical_cast(size); file_headers.insert(std::make_pair(real_filename, headers)); return true; } std::pair get(std::string const &path) { boost::shared_lock lock(cache_mutex); region_map::const_iterator region = regions.find(doc_root_ + path); if (region != regions.end()) return region->second; else return std::pair(0, 0); } boost::iterator_range::iterator> meta( std::string const &path) { boost::shared_lock lock(cache_mutex); static std::vector empty_vector; meta_map::iterator headers = file_headers.find(doc_root_ + path); if (headers != file_headers.end()) { std::vector::iterator begin = headers->second .begin(), end = headers->second.end(); return boost::make_iterator_range(begin, end); } else return boost::make_iterator_range(empty_vector); } }; struct connection_handler : boost::enable_shared_from_this { explicit connection_handler(file_cache &cache) : file_cache_(cache) {} void operator()(std::string const &path, server::connection_ptr connection, bool serve_body) { bool ok = file_cache_.has(path); if (!ok) ok = file_cache_.add(path); if (ok) { send_headers(file_cache_.meta(path), connection); if (serve_body) send_file(file_cache_.get(path), 0, connection); } else { not_found(path, connection); } } void not_found(std::string const &path, server::connection_ptr connection) { static server::response_header headers[] = {{"Connection", "close"}, {"Content-Type", "text/plain"}}; connection->set_status(server::connection::not_found); connection->set_headers(boost::make_iterator_range(headers, headers + 2)); connection->write("File Not Found!"); } template void send_headers(Range const &headers, server::connection_ptr connection) { connection->set_status(server::connection::ok); connection->set_headers(headers); } void send_file(std::pair mmaped_region, off_t offset, server::connection_ptr connection) { // chunk it up page by page std::size_t adjusted_offset = offset + 4096; off_t rightmost_bound = std::min(mmaped_region.second, adjusted_offset); connection->write( boost::asio::const_buffers_1( static_cast(mmaped_region.first) + offset, rightmost_bound), boost::bind(&connection_handler::handle_chunk, connection_handler::shared_from_this(), mmaped_region, rightmost_bound, connection, _1)); } void handle_chunk(std::pair mmaped_region, off_t offset, server::connection_ptr connection, boost::system::error_code const &ec) { if (!ec && offset < mmaped_region.second) send_file(mmaped_region, offset, connection); } file_cache &file_cache_; }; struct file_server { explicit file_server(file_cache &cache) : cache_(cache) {} void operator()(server::request const &request, server::connection_ptr connection) { if (request.method == "HEAD") { boost::shared_ptr h(new connection_handler(cache_)); (*h)(request.destination, connection, false); } else if (request.method == "GET") { boost::shared_ptr h(new connection_handler(cache_)); (*h)(request.destination, connection, true); } else { static server::response_header error_headers[] = { {"Connection", "close"}}; connection->set_status(server::connection::not_supported); connection->set_headers( boost::make_iterator_range(error_headers, error_headers + 1)); connection->write("Method not supported."); } } file_cache &cache_; }; int main(int argc, char *argv[]) { file_cache cache("."); file_server handler(cache); server::options options(handler); server instance(options.thread_pool(boost::make_shared(4)) .address("0.0.0.0") .port("8000")); instance.run(); return 0; } hello_world_async_server_with_work_queue.cpp000066400000000000000000000106771240331347200342610ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/* * sample application to show the usage of work queues along with async http *server * * (C) Copyright Dino Korah 2013. * Distributed under the Boost Software License, Version 1.0. (See copy at * http://www.boost.org/LICENSE_1_0.txt) */ #include #include #include #include #include #include #include #include #include #define Log(line) \ do { \ std::cout << line << std::endl; \ } while (false) struct handler; typedef boost::network::http::async_server server; /** * request + connection encapsulation (work item) */ struct request_data { const server::request req; server::connection_ptr conn; typedef boost::shared_ptr pointer; request_data(server::request const& req, const server::connection_ptr& conn) : req(req), conn(conn) {} }; /** * A basic work queue */ struct work_queue { typedef std::list list; list requests; boost::mutex mutex; inline void put(const request_data::pointer& p_rd) { boost::unique_lock lock(mutex); requests.push_back(p_rd); (void)lock; } inline request_data::pointer get() { boost::unique_lock lock(mutex); request_data::pointer p_ret; if (!requests.empty()) { p_ret = requests.front(); requests.pop_front(); } (void)lock; return p_ret; } }; struct handler { work_queue& queue; handler(work_queue& queue) : queue(queue) {} /** * Feed the work queue * * @param req * @param conn */ void operator()(server::request const& req, const server::connection_ptr& conn) { queue.put(boost::make_shared(req, conn)); } }; /** * Clean shutdown signal handler * * @param error * @param signal * @param p_server_instance */ void shut_me_down(const boost::system::error_code& error, int signal, boost::shared_ptr p_server_instance) { if (!error) p_server_instance->stop(); } /** * Process request; worker (thread) * * @param queue */ void process_request(work_queue& queue) { while (!boost::this_thread::interruption_requested()) { request_data::pointer p_req(queue.get()); if (p_req) { // some heavy work! boost::this_thread::sleep(boost::posix_time::seconds(10)); p_req->conn->set_status(server::connection::ok); p_req->conn->write("Hello, world!"); } boost::this_thread::sleep(boost::posix_time::microseconds(1000)); } } int main(void) try { // the thread group boost::shared_ptr p_threads( boost::make_shared()); // setup asio::io_service boost::shared_ptr p_io_service( boost::make_shared()); boost::shared_ptr p_work( boost::make_shared( boost::ref(*p_io_service))); // io_service threads { int n_threads = 5; while (0 < n_threads--) { p_threads->create_thread( boost::bind(&boost::asio::io_service::run, p_io_service)); } } // the shared work queue work_queue queue; // worker threads that will process the request; off the queue { int n_threads = 5; while (0 < n_threads--) { p_threads->create_thread(boost::bind(process_request, boost::ref(queue))); } } // setup the async server handler request_handler(queue); boost::shared_ptr p_server_instance(boost::make_shared( server::options(request_handler) .address("0.0.0.0") .port("8800") .io_service(p_io_service) .reuse_address(true) .thread_pool(boost::make_shared( 2, p_io_service, p_threads)))); // setup clean shutdown boost::asio::signal_set signals(*p_io_service, SIGINT, SIGTERM); signals.async_wait(boost::bind(shut_me_down, _1, _2, p_server_instance)); // run the async server p_server_instance->run(); // we are stopped - shutting down p_threads->interrupt_all(); p_work.reset(); p_io_service->stop(); p_threads->join_all(); Log("Terminated normally"); exit(EXIT_SUCCESS); } catch (const std::exception& e) { Log("Abnormal termination - exception:" << e.what()); exit(EXIT_FAILURE); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/hello_world_client.cpp000066400000000000000000000023161240331347200276010ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) //[ hello_world_client_main /*` This is a part of the 'Hello World' example. We create a client object and make a single HTTP request. If we use make this request to the `hello_world_server`, then the output is simply "Hello, World!". */ #include #include namespace http = boost::network::http; int main(int argc, char *argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " url" << std::endl; return 1; } try { /*<< Creates the client. >>*/ http::client client; /*<< Creates a request using a URI supplied on the command line. >>*/ http::client::request request(argv[1]); /*<< Gets a response from the HTTP server. >>*/ http::client::response response = client.get(request); /*<< Prints the response body to the console. >>*/ std::cout << body(response) << std::endl; } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } //] cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/hello_world_server.cpp000066400000000000000000000035301240331347200276300ustar00rootroot00000000000000// Copyright 2009 (c) Tarro, Inc. // Copyright 2009 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // //[ hello_world_server_main /*` This is a part of the 'Hello World' example. It's used to demonstrate how easy it is to set up an HTTP server. All we do in this example is create a request handler and run the server. */ #include #include namespace http = boost::network::http; /*<< Defines the server. >>*/ struct hello_world; typedef http::server server; /*<< Defines the request handler. It's a class that defines two functions, `operator()` and `log()` >>*/ struct hello_world { /*<< This is the function that handles the incoming request. >>*/ void operator()(server::request const &request, server::response &response) { server::string_type ip = source(request); unsigned int port = request.source_port; std::ostringstream data; data << "Hello, " << ip << ':' << port << '!'; response = server::response::stock_reply(server::response::ok, data.str()); } /*<< It's necessary to define a log function, but it's ignored in this example. >>*/ void log(...) { // do nothing } }; int main(int argc, char *argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " address port" << std::endl; return 1; } try { /*<< Creates the request handler. >>*/ hello_world handler; /*<< Creates the server. >>*/ server::options options(handler); server server_(options.address(argv[1]).port(argv[2])); /*<< Runs the server. >>*/ server_.run(); } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } //] cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/one_liner.cpp000066400000000000000000000011321240331347200256760ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) //[ http_one_liner_main /*` */ #include using namespace std; using namespace boost::network; using namespace boost::network::http; int main(int argc, const char *argv[]) { /*<< The client sends an HTTP request to the server, and the output is printed to the console. >>*/ cout << body(client().get(client::request("http://www.boost.org/"))); return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/ssl/000077500000000000000000000000001240331347200240245ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/ssl/dh512.pem000066400000000000000000000007221240331347200253530ustar00rootroot00000000000000Diffie-Hellman-Parameters: (512 bit) prime: 00:f8:57:8f:79:09:08:95:c9:0a:74:2c:85:b5:75: ff:07:67:c0:d2:94:4f:a2:45:77:7e:e1:f4:b6:86: 60:9a:33:80:7b:31:75:f3:fc:8e:c3:0b:d0:8d:77: a4:ed:3a:e8:e4:35:69:3e:ce:63:49:26:a4:64:38: 55:41:51:de:13 generator: 5 (0x5) -----BEGIN DH PARAMETERS----- MEYCQQD4V495CQiVyQp0LIW1df8HZ8DSlE+iRXd+4fS2hmCaM4B7MXXz/I7DC9CN d6TtOujkNWk+zmNJJqRkOFVBUd4TAgEF -----END DH PARAMETERS----- cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/ssl/server.pem000066400000000000000000000061321240331347200260370ustar00rootroot00000000000000-----BEGIN RSA PRIVATE KEY----- Proc-Type: 4,ENCRYPTED DEK-Info: DES-EDE3-CBC,0ED70FE151E3399B +0JpEbgYMyIdEE7yKdosnNzzwGffSe6UIOf/8RgWg5N1f6obqYVRPaO53R1Fdhx2 08q5acaNNCZcoCs1X0s0F/dr4L5XOorz2W5qUKnlDiZqBVBfpW8vIKMiZxOBePO7 /h4LGtuX843k5sCmXnONtDJrpklsds0/vvZbuln6VHNf3mCWdLc8d5yJq/nPUKSm hBd8uXPF0VUSSmTre2P0pTACz2WWI7N2uWKJqBJgGbqTfR5ciufXVR/n9leICjWM LiipPMdp4ZNGDQcP3eW7/pSgxGzGvxP9e1vTEkmv0/fRGgClOdQbs+uEyDemOA+V KHJYGhdhSCDM4VJQTO40dDhsn0glp9IjchYrxjI6jyziG1Jg7YMhoeQBMYm1zSsY vqB0i7gtjVBKzltWN9fNvZ1kOJWhOsHuPocP4L4sqaQEqWCMtcKnm8ECGYXtu8E2 QmDokiWqO1+MORf+naU0nOTtnXSpsysBn1ns+8TeUzaLAy8Dd/mhX2+SWnwGs0RI VEYP+mef96SnqOKy2mDl/uzwcKUdKw4wnXrb2s8039gXBDZL09YlJxu/b/h67Dzn LSRft4JjdojTmT0Ji4eJFiew9L3bbbUyIhA9M/cdoNEnXMmOcO+XDMxemaaX4rLf nmEUcz0xpe8CVqTgx/TuOv06PX/iLyCYPnz5nczeVIw0a1/9g4WRghtoO/ezGJia jpJRmXI7Mcw4z4GgW1AbVEeIPSXQD6sqnuNcY4h/62XkVI29FjsVgU1ZRx5fu68L EIPuEri087Eep1NdRHOWwN03ppRdNxQQqB4uMNL2ruX3LzRKa0p7OQ3iL7e2V6el 2srv/5AYtFCq/adukhNcpU/otSZ5Re5B6C1zLAEUSKcgYHjCOUluq8HnCijnVCMh pEQPaSM0P36DlNFjAWFlK8/N80LOfiYekLyZLbHjczSOS3EyVyvuF3pbtSHzpgtF W4EJD8siMTXcE5hL8Ws1FwWHfviAq/mI4NUcNNz6S/4IcHS6teQOE5/uFcicJxXl 2wgZgYzBUeQlSqyI6XKoyfdJXducbLQqSWLEHL++Ek0ZaUKOiF+iGKPE0azKwMCc QumPY+R2BhJbuiTQE36hBpte//XPQS5dWwXW5RTJm8ARNl1vNR/DESfhWX+wmKqx 2UBDRoEBa5HvrU82tWeGgm9CvTg6EOSNkap/BSdd3np631NnVm1tYz/flQvw4+5t AH0X9C1QsGFwP6y/pAZ+YB+U65iN1UE3D3U1pC5JL+56ETc3GsPKnsWhAftIMm4r l7zJ4BsrvfVnRaZFH4W+ITGy5q7iLD6Tuhpq574DxCINHtiENr00ZfPw08pMpvjG 5qhuE7Vgx5MGcVhUkz+Dtsm7bDRNsRxGAO5MSiIl70oahB5q247HF2ZElVT6+LbU rQlIL4OdTdSXplW84NcoLTRy1HmLPf8B0Dt5f9Es0fAeWMiOmrrzM+spOgGXQhwv VnqQrDeSDk6TOjN5z+BuwFfR7kImO+/As9NnG8D0l0PCRMW79mED2iOTnyHT8g8b JLOjK/u2RxXFtbRwhERl4pei3NHfX4yXz2mcFjFLEOKin909WqObwedMsOUYoiN9 -----END RSA PRIVATE KEY----- -----BEGIN CERTIFICATE----- MIID5jCCAs6gAwIBAgIJAI84QTgzQ+NXMA0GCSqGSIb3DQEBBQUAMFUxCzAJBgNV BAYTAkJFMRMwEQYDVQQIEwpTb21lLVN0YXRlMRIwEAYDVQQKEwljcHBuZXRsaWIx DDAKBgNVBAsTA3NzbDEPMA0GA1UEAxMGc2VydmVyMB4XDTE0MDUyMTA4MzI1OFoX DTI0MDUxODA4MzI1OFowVTELMAkGA1UEBhMCQkUxEzARBgNVBAgTClNvbWUtU3Rh dGUxEjAQBgNVBAoTCWNwcG5ldGxpYjEMMAoGA1UECxMDc3NsMQ8wDQYDVQQDEwZz ZXJ2ZXIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZdnFuC9w3Jmdh nQkeCD3rJ3LbmopRJkBFeAdHXvF2zPedsCjQ2J9XNcrGoejQuWNzEfmhs8pPSve3 +Hn5AmqByGzN6aylJnD4qZZqpV1JrWvhReswLJktUTKtu+gh2a3gZjvXAdkGi0QX LoXyAFuhILmivE9bQB6unUpMhGiAfX9AxDINgBt/+oi2V8bkXdJl45BNUY9IqgaJ 9WeDC37DmORb/IDHjmancIMyirDG2SBBGOVv/wuI0a/QUmjtBKUMEiX8PtyKSORA PnOd2Fe0LL70thBD1WtlMNoU3upIrlLUE0F4bb+Ibn+iuSyu6dWp7rr9kR3uigQ6 gspTVX4RAgMBAAGjgbgwgbUwHQYDVR0OBBYEFHZpVctJQmv6ixP7PmHcFUa+7+Dy MIGFBgNVHSMEfjB8gBR2aVXLSUJr+osT+z5h3BVGvu/g8qFZpFcwVTELMAkGA1UE BhMCQkUxEzARBgNVBAgTClNvbWUtU3RhdGUxEjAQBgNVBAoTCWNwcG5ldGxpYjEM MAoGA1UECxMDc3NsMQ8wDQYDVQQDEwZzZXJ2ZXKCCQCPOEE4M0PjVzAMBgNVHRME BTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQCd70N4MzxI7jKdyFXNQtHLh74hALd5 p2PconV+3dE3yge88Z9IkgIx8MtVl6jm7dlggwJLGTBUD5fI0iL+KWqLl7/QxbwS 82J28ScsXlEf7pygowEsUYPM8j6O42JhIGQqMWOnmqnBVDxszHvYkO12/JupbEeK p5RYS3GkyxQm5MmX0pX0H6wdfCkOdSZrHaXTx2wq2lKeQgN3mECUH51jXzB1G3nI y1dCMD+AF3eUqS2UxgPbF14U6V2vsk4DvbgyzjYFjF+ttFdnIgGwAJJWet+orhW/ k+h3ZaviXhOyqjpXHXGkVUj+/AvKWArjl7D6Xh03iUp0xt1Bn28CxQ90 -----END CERTIFICATE----- cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http/ssl/ssl_server.cpp000066400000000000000000000062241240331347200267230ustar00rootroot00000000000000/* * Sample application based loosely on existing async server sample to *demonstrate ssl * * Requires openssl lib to run (https://www.openssl.org/) * * (C) Copyright Jelle Van den Driessche 2014. * * Distributed under the Boost Software License, Version 1.0. (See copy at * http://www.boost.org/LICENSE_1_0.txt) */ #include #include #include #include #include #include struct handler; typedef boost::network::http::async_server server; std::string password_callback( std::size_t max_length, boost::asio::ssl::context_base::password_purpose purpose) { return std::string("test"); } /** * request + connection encapsulation (work item) */ struct request_data { const server::request req; server::connection_ptr conn; typedef boost::shared_ptr pointer; request_data(server::request const& req, const server::connection_ptr& conn) : req(req), conn(conn) {} }; struct handler { void operator()(server::request const& req, const server::connection_ptr& conn) { conn->set_status(server::connection::ok); conn->write(std::string("Hello World!!")); } }; /** * Clean shutdown signal handler * * @param error * @param signal * @param p_server_instance */ void shut_me_down(const boost::system::error_code& error, int signal, boost::shared_ptr p_server_instance) { if (!error) p_server_instance->stop(); } int main(void) try { // setup asio::io_service boost::shared_ptr p_io_service( boost::make_shared()); // Initialize SSL context boost::shared_ptr ctx = boost::make_shared( boost::asio::ssl::context::sslv23); ctx->set_options(boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use); // Set keys ctx->set_password_callback(password_callback); ctx->use_certificate_chain_file("server.pem"); ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem); ctx->use_tmp_dh_file("dh512.pem"); // setup the async server handler request_handler; boost::shared_ptr p_server_instance(boost::make_shared( server::options(request_handler) .address("0.0.0.0") .port("8442") .io_service(p_io_service) .reuse_address(true) .thread_pool( boost::make_shared(2)) .context(ctx))); // setup clean shutdown boost::asio::signal_set signals(*p_io_service, SIGINT, SIGTERM); signals.async_wait(boost::bind(shut_me_down, _1, _2, p_server_instance)); // run the async server p_server_instance->run(); // we are stopped - shutting down p_io_service->stop(); std::cout << "Terminated normally" << std::endl; exit(EXIT_SUCCESS); } catch (const std::exception& e) { std::cout << "Abnormal termination - exception:" << e.what() << std::endl; exit(EXIT_FAILURE); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http_client.cpp000066400000000000000000000051251240331347200252700ustar00rootroot00000000000000 // Copyright 2008, 2014 Dean Michael Berris // Copyright 2014 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) //[ http_client_main /*` This application takes a URL as a command line argument and prints the resource to the console. */ #include #include #include #include #include namespace po = boost::program_options; int main(int argc, char* argv[]) { using namespace boost::network; po::options_description options("Allowed options"); std::string output_filename, source; bool show_headers; options.add_options()("help,h", "produce help message")( "headers,H", "print headers")("status,S", "print status and message")( "source,s", po::value(&source), "source URL"); po::positional_options_description positional_options; positional_options.add("source", 1); po::variables_map vm; try { po::store(po::command_line_parser(argc, argv) .options(options) .positional(positional_options) .run(), vm); po::notify(vm); } catch (std::exception& e) { std::cout << "Error: " << e.what() << std::endl; std::cout << options << std::endl; return EXIT_FAILURE; } if (vm.count("help")) { std::cout << options << std::endl; return EXIT_SUCCESS; } if (vm.count("source") < 1) { std::cout << "Error: Source URL required." << std::endl; std::cout << options << std::endl; return EXIT_FAILURE; } show_headers = vm.count("headers") ? true : false; bool show_status = vm.count("status") ? true : false; http::client::request request(source); http::client::string_type destination_ = host(request); request << ::boost::network::header("Connection", "close"); http::client::options client_options; client_options.follow_redirects(true); http::client client(client_options); http::client::response response = client.get(request); if (show_status) std::cout << status(response) << " " << status_message(response) << std::endl; if (show_headers) { headers_range::type headers_ = response.headers(); typedef std::pair header_type; BOOST_FOREACH(header_type const & header, headers_) { std::cout << header.first << ": " << header.second << std::endl; } std::cout << std::endl; } std::cout << body(response); return EXIT_SUCCESS; } //] cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/http_client1.cpp000066400000000000000000000012551240331347200253510ustar00rootroot00000000000000// Copyright Dean Michael Berris 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include int main(int argc, char* argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); std::cout << body(response) << std::endl; return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rapidxml/000077500000000000000000000000001240331347200240645ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rapidxml/license.txt000066400000000000000000000053001240331347200262450ustar00rootroot00000000000000Use of this software is granted under one of the following two licenses, to be chosen freely by the user. 1. Boost Software License - Version 1.0 - August 17th, 2003 =============================================================================== Copyright (c) 2006, 2007 Marcin Kalicinski Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 2. The MIT License =============================================================================== Copyright (c) 2006, 2007 Marcin Kalicinski Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rapidxml/manual.html000066400000000000000000003347131240331347200262420ustar00rootroot00000000000000

RAPIDXML Manual

Version 1.13

Copyright (C) 2006, 2009 Marcin Kalicinski
See accompanying file license.txt for license information.

Table of Contents

1. What is RapidXml?
1.1 Dependencies And Compatibility
1.2 Character Types And Encodings
1.3 Error Handling
1.4 Memory Allocation
1.5 W3C Compliance
1.6 API Design
1.7 Reliability
1.8 Acknowledgements
2. Two Minute Tutorial
2.1 Parsing
2.2 Accessing The DOM Tree
2.3 Modifying The DOM Tree
2.4 Printing XML
3. Differences From Regular XML Parsers
3.1 Lifetime Of Source Text
3.2 Ownership Of Strings
3.3 Destructive Vs Non-Destructive Mode
4. Performance
4.1 Comparison With Other Parsers
5. Reference

1. What is RapidXml?

RapidXml is an attempt to create the fastest XML DOM parser possible, while retaining useability, portability and reasonable W3C compatibility. It is an in-situ parser written in C++, with parsing speed approaching that of strlen() function executed on the same data.

Entire parser is contained in a single header file, so no building or linking is neccesary. To use it you just need to copy rapidxml.hpp file to a convenient place (such as your project directory), and include it where needed. You may also want to use printing functions contained in header rapidxml_print.hpp.

1.1 Dependencies And Compatibility

RapidXml has no dependencies other than a very small subset of standard C++ library (<cassert>, <cstdlib>, <new> and <exception>, unless exceptions are disabled). It should compile on any reasonably conformant compiler, and was tested on Visual C++ 2003, Visual C++ 2005, Visual C++ 2008, gcc 3, gcc 4, and Comeau 4.3.3. Care was taken that no warnings are produced on these compilers, even with highest warning levels enabled.

1.2 Character Types And Encodings

RapidXml is character type agnostic, and can work both with narrow and wide characters. Current version does not fully support UTF-16 or UTF-32, so use of wide characters is somewhat incapacitated. However, it should succesfully parse wchar_t strings containing UTF-16 or UTF-32 if endianness of the data matches that of the machine. UTF-8 is fully supported, including all numeric character references, which are expanded into appropriate UTF-8 byte sequences (unless you enable parse_no_utf8 flag).

Note that RapidXml performs no decoding - strings returned by name() and value() functions will contain text encoded using the same encoding as source file. Rapidxml understands and expands the following character references: &apos; &amp; &quot; &lt; &gt; &#...; Other character references are not expanded.

1.3 Error Handling

By default, RapidXml uses C++ exceptions to report errors. If this behaviour is undesirable, RAPIDXML_NO_EXCEPTIONS can be defined to suppress exception code. See parse_error class and parse_error_handler() function for more information.

1.4 Memory Allocation

RapidXml uses a special memory pool object to allocate nodes and attributes, because direct allocation using new operator would be far too slow. Underlying memory allocations performed by the pool can be customized by use of memory_pool::set_allocator() function. See class memory_pool for more information.

1.5 W3C Compliance

RapidXml is not a W3C compliant parser, primarily because it ignores DOCTYPE declarations. There is a number of other, minor incompatibilities as well. Still, it can successfully parse and produce complete trees of all valid XML files in W3C conformance suite (over 1000 files specially designed to find flaws in XML processors). In destructive mode it performs whitespace normalization and character entity substitution for a small set of built-in entities.

1.6 API Design

RapidXml API is minimalistic, to reduce code size as much as possible, and facilitate use in embedded environments. Additional convenience functions are provided in separate headers: rapidxml_utils.hpp and rapidxml_print.hpp. Contents of these headers is not an essential part of the library, and is currently not documented (otherwise than with comments in code).

1.7 Reliability

RapidXml is very robust and comes with a large harness of unit tests. Special care has been taken to ensure stability of the parser no matter what source text is thrown at it. One of the unit tests produces 100,000 randomly corrupted variants of XML document, which (when uncorrupted) contains all constructs recognized by RapidXml. RapidXml passes this test when it correctly recognizes that errors have been introduced, and does not crash or loop indefinitely.

Another unit test puts RapidXml head-to-head with another, well estabilished XML parser, and verifies that their outputs match across a wide variety of small and large documents.

Yet another test feeds RapidXml with over 1000 test files from W3C compliance suite, and verifies that correct results are obtained. There are also additional tests that verify each API function separately, and test that various parsing modes work as expected.

1.8 Acknowledgements

I would like to thank Arseny Kapoulkine for his work on pugixml, which was an inspiration for this project. Additional thanks go to Kristen Wegner for creating pugxml, from which pugixml was derived. Janusz Wohlfeil kindly ran RapidXml speed tests on hardware that I did not have access to, allowing me to expand performance comparison table.

2. Two Minute Tutorial

2.1 Parsing

The following code causes RapidXml to parse a zero-terminated string named text: 
using namespace rapidxml;
xml_document<> doc;    // character type defaults to char
doc.parse<0>(text);    // 0 means default parse flags
doc object is now a root of DOM tree containing representation of the parsed XML. Because all RapidXml interface is contained inside namespace rapidxml, users must either bring contents of this namespace into scope, or fully qualify all the names. Class xml_document represents a root of the DOM hierarchy. By means of public inheritance, it is also an xml_node and a memory_pool. Template parameter of xml_document::parse() function is used to specify parsing flags, with which you can fine-tune behaviour of the parser. Note that flags must be a compile-time constant.

2.2 Accessing The DOM Tree

To access the DOM tree, use methods of xml_node and xml_attribute classes: 
cout << "Name of my first node is: " << doc.first_node()->name() << "\n";
xml_node<> *node = doc.first_node("foobar");
cout << "Node foobar has value " << node->value() << "\n";
for (xml_attribute<> *attr = node->first_attribute();
     attr; attr = attr->next_attribute())
{
    cout << "Node foobar has attribute " << attr->name() << " ";
    cout << "with value " << attr->value() << "\n";
}

2.3 Modifying The DOM Tree

DOM tree produced by the parser is fully modifiable. Nodes and attributes can be added/removed, and their contents changed. The below example creates a HTML document, whose sole contents is a link to google.com website: 
xml_document<> doc;
xml_node<> *node = doc.allocate_node(node_element, "a", "Google");
doc.append_node(node);
xml_attribute<> *attr = doc.allocate_attribute("href", "google.com");
node->append_attribute(attr);
One quirk is that nodes and attributes do not own the text of their names and values. This is because normally they only store pointers to the source text. So, when assigning a new name or value to the node, care must be taken to ensure proper lifetime of the string. The easiest way to achieve it is to allocate the string from the xml_document memory pool. In the above example this is not necessary, because we are only assigning character constants. But the code below uses memory_pool::allocate_string() function to allocate node name (which will have the same lifetime as the document), and assigns it to a new node: 
xml_document<> doc;
char *node_name = doc.allocate_string(name);        // Allocate string and copy name into it
xml_node<> *node = doc.allocate_node(node_element, node_name);  // Set node name to node_name
Check Reference section for description of the entire interface.

2.4 Printing XML

You can print xml_document and xml_node objects into an XML string. Use print() function or operator <<, which are defined in rapidxml_print.hpp header. 
using namespace rapidxml;
xml_document<> doc;    // character type defaults to char
// ... some code to fill the document

// Print to stream using operator <<
std::cout << doc;   

// Print to stream using print function, specifying printing flags
print(std::cout, doc, 0);   // 0 means default printing flags

// Print to string using output iterator
std::string s;
print(std::back_inserter(s), doc, 0);

// Print to memory buffer using output iterator
char buffer[4096];                      // You are responsible for making the buffer large enough!
char *end = print(buffer, doc, 0);      // end contains pointer to character after last printed character
*end = 0;                               // Add string terminator after XML

3. Differences From Regular XML Parsers

RapidXml is an in-situ parser, which allows it to achieve very high parsing speed. In-situ means that parser does not make copies of strings. Instead, it places pointers to the source text in the DOM hierarchy.

3.1 Lifetime Of Source Text

In-situ parsing requires that source text lives at least as long as the document object. If source text is destroyed, names and values of nodes in DOM tree will become destroyed as well. Additionally, whitespace processing, character entity translation, and zero-termination of strings require that source text be modified during parsing (but see non-destructive mode). This makes the text useless for further processing once it was parsed by RapidXml.

In many cases however, these are not serious issues.

3.2 Ownership Of Strings

Nodes and attributes produced by RapidXml do not own their name and value strings. They merely hold the pointers to them. This means you have to be careful when setting these values manually, by using xml_base::name(const Ch *) or xml_base::value(const Ch *) functions. Care must be taken to ensure that lifetime of the string passed is at least as long as lifetime of the node/attribute. The easiest way to achieve it is to allocate the string from memory_pool owned by the document. Use memory_pool::allocate_string() function for this purpose.

3.3 Destructive Vs Non-Destructive Mode

By default, the parser modifies source text during the parsing process. This is required to achieve character entity translation, whitespace normalization, and zero-termination of strings.

In some cases this behaviour may be undesirable, for example if source text resides in read only memory, or is mapped to memory directly from file. By using appropriate parser flags (parse_non_destructive), source text modifications can be disabled. However, because RapidXml does in-situ parsing, it obviously has the following side-effects:

4. Performance

RapidXml achieves its speed through use of several techniques:
  • In-situ parsing. When building DOM tree, RapidXml does not make copies of string data, such as node names and values. Instead, it stores pointers to interior of the source text.
  • Use of template metaprogramming techniques. This allows it to move much of the work to compile time. Through magic of the templates, C++ compiler generates a separate copy of parsing code for any combination of parser flags you use. In each copy, all possible decisions are made at compile time and all unused code is omitted.
  • Extensive use of lookup tables for parsing.
  • Hand-tuned C++ with profiling done on several most popular CPUs.
This results in a very small and fast code: a parser which is custom tailored to exact needs with each invocation.

4.1 Comparison With Other Parsers

The table below compares speed of RapidXml to some other parsers, and to strlen() function executed on the same data. On a modern CPU (as of 2007), you can expect parsing throughput to be close to 1 GB/s. As a rule of thumb, parsing speed is about 50-100x faster than Xerces DOM, 30-60x faster than TinyXml, 3-12x faster than pugxml, and about 5% - 30% faster than pugixml, the fastest XML parser I know of.
  • The test file is a real-world, 50kB large, moderately dense XML file.
  • All timing is done by using RDTSC instruction present in Pentium-compatible CPUs.
  • No profile-guided optimizations are used.
  • All parsers are running in their fastest modes.
  • The results are given in CPU cycles per character, so frequency of CPUs is irrelevant.
  • The results are minimum values from a large number of runs, to minimize effects of operating system activity, task switching, interrupt handling etc.
  • A single parse of the test file takes about 1/10th of a millisecond, so with large number of runs there is a good chance of hitting at least one no-interrupt streak, and obtaining undisturbed results.
Platform
Compiler
strlen() RapidXml pugixml 0.3 pugxml TinyXml
Pentium 4
MSVC 8.0
2.5
5.4
7.0
61.7
298.8
Pentium 4
gcc 4.1.1
0.8
6.1
9.5
67.0
413.2
Core 2
MSVC 8.0
1.0
4.5
5.0
24.6
154.8
Core 2
gcc 4.1.1
0.6
4.6
5.4
28.3
229.3
Athlon XP
MSVC 8.0
3.1
7.7
8.0
25.5
182.6
Athlon XP
gcc 4.1.1
0.9
8.2
9.2
33.7
265.2
Pentium 3
MSVC 8.0
2.0
6.3
7.0
30.9
211.9
Pentium 3
gcc 4.1.1
1.0
6.7
8.9
35.3
316.0
(*) All results are in CPU cycles per character of source text

5. Reference

This section lists all classes, functions, constants etc. and describes them in detail.
class template rapidxml::memory_pool
constructor memory_pool()
destructor ~memory_pool()
function allocate_node(node_type type, const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0)
function allocate_attribute(const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0)
function allocate_string(const Ch *source=0, std::size_t size=0)
function clone_node(const xml_node< Ch > *source, xml_node< Ch > *result=0)
function clear()
function set_allocator(alloc_func *af, free_func *ff)

class rapidxml::parse_error
constructor parse_error(const char *what, void *where)
function what() const
function where() const

class template rapidxml::xml_attribute
constructor xml_attribute()
function document() const
function previous_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
function next_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const

class template rapidxml::xml_base
constructor xml_base()
function name() const
function name_size() const
function value() const
function value_size() const
function name(const Ch *name, std::size_t size)
function name(const Ch *name)
function value(const Ch *value, std::size_t size)
function value(const Ch *value)
function parent() const

class template rapidxml::xml_document
constructor xml_document()
function parse(Ch *text)
function clear()

class template rapidxml::xml_node
constructor xml_node(node_type type)
function type() const
function document() const
function first_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
function last_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
function previous_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
function next_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
function first_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
function last_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
function type(node_type type)
function prepend_node(xml_node< Ch > *child)
function append_node(xml_node< Ch > *child)
function insert_node(xml_node< Ch > *where, xml_node< Ch > *child)
function remove_first_node()
function remove_last_node()
function remove_node(xml_node< Ch > *where)
function remove_all_nodes()
function prepend_attribute(xml_attribute< Ch > *attribute)
function append_attribute(xml_attribute< Ch > *attribute)
function insert_attribute(xml_attribute< Ch > *where, xml_attribute< Ch > *attribute)
function remove_first_attribute()
function remove_last_attribute()
function remove_attribute(xml_attribute< Ch > *where)
function remove_all_attributes()

namespace rapidxml
enum node_type
function parse_error_handler(const char *what, void *where)
function print(OutIt out, const xml_node< Ch > &node, int flags=0)
function print(std::basic_ostream< Ch > &out, const xml_node< Ch > &node, int flags=0)
function operator<<(std::basic_ostream< Ch > &out, const xml_node< Ch > &node)
constant parse_no_data_nodes
constant parse_no_element_values
constant parse_no_string_terminators
constant parse_no_entity_translation
constant parse_no_utf8
constant parse_declaration_node
constant parse_comment_nodes
constant parse_doctype_node
constant parse_pi_nodes
constant parse_validate_closing_tags
constant parse_trim_whitespace
constant parse_normalize_whitespace
constant parse_default
constant parse_non_destructive
constant parse_fastest
constant parse_full
constant print_no_indenting

class template rapidxml::memory_pool

Defined in rapidxml.hpp
Base class for xml_document

Description

This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation. In most cases, you will not need to use this class directly. However, if you need to create nodes manually or modify names/values of nodes, you are encouraged to use memory_pool of relevant xml_document to allocate the memory. Not only is this faster than allocating them by using new operator, but also their lifetime will be tied to the lifetime of document, possibly simplyfing memory management.

Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool. You can also call allocate_string() function to allocate strings. Such strings can then be used as names or values of nodes without worrying about their lifetime. Note that there is no free() function -- all allocations are freed at once when clear() function is called, or when the pool is destroyed.

It is also possible to create a standalone memory_pool, and use it to allocate nodes, whose lifetime will not be tied to any document.

Pool maintains RAPIDXML_STATIC_POOL_SIZE bytes of statically allocated memory. Until static memory is exhausted, no dynamic memory allocations are done. When static memory is exhausted, pool allocates additional blocks of memory of size RAPIDXML_DYNAMIC_POOL_SIZE each, by using global new[] and delete[] operators. This behaviour can be changed by setting custom allocation routines. Use set_allocator() function to set them.

Allocations for nodes, attributes and strings are aligned at RAPIDXML_ALIGNMENT bytes. This value defaults to the size of pointer on target architecture.

To obtain absolutely top performance from the parser, it is important that all nodes are allocated from a single, contiguous block of memory. Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably. If required, you can tweak RAPIDXML_STATIC_POOL_SIZE, RAPIDXML_DYNAMIC_POOL_SIZE and RAPIDXML_ALIGNMENT to obtain best wasted memory to performance compromise. To do it, define their values before rapidxml.hpp file is included.

Parameters

Ch
Character type of created nodes.

constructor memory_pool::memory_pool

Synopsis

memory_pool();

Description

Constructs empty pool with default allocator functions.

destructor memory_pool::~memory_pool

Synopsis

~memory_pool();

Description

Destroys pool and frees all the memory. This causes memory occupied by nodes allocated by the pool to be freed. Nodes allocated from the pool are no longer valid.

function memory_pool::allocate_node

Synopsis

xml_node<Ch>* allocate_node(node_type type, const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0);

Description

Allocates a new node from the pool, and optionally assigns name and value to it. If the allocation request cannot be accomodated, this function will throw std::bad_alloc. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call rapidxml::parse_error_handler() function.

Parameters

type
Type of node to create.
name
Name to assign to the node, or 0 to assign no name.
value
Value to assign to the node, or 0 to assign no value.
name_size
Size of name to assign, or 0 to automatically calculate size from name string.
value_size
Size of value to assign, or 0 to automatically calculate size from value string.

Returns

Pointer to allocated node. This pointer will never be NULL.

function memory_pool::allocate_attribute

Synopsis

xml_attribute<Ch>* allocate_attribute(const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0);

Description

Allocates a new attribute from the pool, and optionally assigns name and value to it. If the allocation request cannot be accomodated, this function will throw std::bad_alloc. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call rapidxml::parse_error_handler() function.

Parameters

name
Name to assign to the attribute, or 0 to assign no name.
value
Value to assign to the attribute, or 0 to assign no value.
name_size
Size of name to assign, or 0 to automatically calculate size from name string.
value_size
Size of value to assign, or 0 to automatically calculate size from value string.

Returns

Pointer to allocated attribute. This pointer will never be NULL.

function memory_pool::allocate_string

Synopsis

Ch* allocate_string(const Ch *source=0, std::size_t size=0);

Description

Allocates a char array of given size from the pool, and optionally copies a given string to it. If the allocation request cannot be accomodated, this function will throw std::bad_alloc. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call rapidxml::parse_error_handler() function.

Parameters

source
String to initialize the allocated memory with, or 0 to not initialize it.
size
Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.

Returns

Pointer to allocated char array. This pointer will never be NULL.

function memory_pool::clone_node

Synopsis

xml_node<Ch>* clone_node(const xml_node< Ch > *source, xml_node< Ch > *result=0);

Description

Clones an xml_node and its hierarchy of child nodes and attributes. Nodes and attributes are allocated from this memory pool. Names and values are not cloned, they are shared between the clone and the source. Result node can be optionally specified as a second parameter, in which case its contents will be replaced with cloned source node. This is useful when you want to clone entire document.

Parameters

source
Node to clone.
result
Node to put results in, or 0 to automatically allocate result node

Returns

Pointer to cloned node. This pointer will never be NULL.

function memory_pool::clear

Synopsis

void clear();

Description

Clears the pool. This causes memory occupied by nodes allocated by the pool to be freed. Any nodes or strings allocated from the pool will no longer be valid.

function memory_pool::set_allocator

Synopsis

void set_allocator(alloc_func *af, free_func *ff);

Description

Sets or resets the user-defined memory allocation functions for the pool. This can only be called when no memory is allocated from the pool yet, otherwise results are undefined. Allocation function must not return invalid pointer on failure. It should either throw, stop the program, or use longjmp() function to pass control to other place of program. If it returns invalid pointer, results are undefined.

User defined allocation functions must have the following forms:

void *allocate(std::size_t size);
void free(void *pointer);

Parameters

af
Allocation function, or 0 to restore default function
ff
Free function, or 0 to restore default function

class rapidxml::parse_error

Defined in rapidxml.hpp

Description

Parse error exception. This exception is thrown by the parser when an error occurs. Use what() function to get human-readable error message. Use where() function to get a pointer to position within source text where error was detected.

If throwing exceptions by the parser is undesirable, it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included. This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception. This function must be defined by the user.

This class derives from std::exception class.

constructor parse_error::parse_error

Synopsis

parse_error(const char *what, void *where);

Description

Constructs parse error.

function parse_error::what

Synopsis

virtual const char* what() const;

Description

Gets human readable description of error.

Returns

Pointer to null terminated description of the error.

function parse_error::where

Synopsis

Ch* where() const;

Description

Gets pointer to character data where error happened. Ch should be the same as char type of xml_document that produced the error.

Returns

Pointer to location within the parsed string where error occured.

class template rapidxml::xml_attribute

Defined in rapidxml.hpp
Inherits from xml_base

Description

Class representing attribute node of XML document. Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base). Note that after parse, both name and value of attribute will point to interior of source text used for parsing. Thus, this text must persist in memory for the lifetime of attribute.

Parameters

Ch
Character type to use.

constructor xml_attribute::xml_attribute

Synopsis

xml_attribute();

Description

Constructs an empty attribute with the specified type. Consider using memory_pool of appropriate xml_document if allocating attributes manually.

function xml_attribute::document

Synopsis

xml_document<Ch>* document() const;

Description

Gets document of which attribute is a child.

Returns

Pointer to document that contains this attribute, or 0 if there is no parent document.

function xml_attribute::previous_attribute

Synopsis

xml_attribute<Ch>* previous_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets previous attribute, optionally matching attribute name.

Parameters

name
Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found attribute, or 0 if not found.

function xml_attribute::next_attribute

Synopsis

xml_attribute<Ch>* next_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets next attribute, optionally matching attribute name.

Parameters

name
Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found attribute, or 0 if not found.

class template rapidxml::xml_base

Defined in rapidxml.hpp
Base class for xml_attribute xml_node

Description

Base class for xml_node and xml_attribute implementing common functions: name(), name_size(), value(), value_size() and parent().

Parameters

Ch
Character type to use

constructor xml_base::xml_base

Synopsis

xml_base();

function xml_base::name

Synopsis

Ch* name() const;

Description

Gets name of the node. Interpretation of name depends on type of node. Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.

Use name_size() function to determine length of the name.

Returns

Name of node, or empty string if node has no name.

function xml_base::name_size

Synopsis

std::size_t name_size() const;

Description

Gets size of node name, not including terminator character. This function works correctly irrespective of whether name is or is not zero terminated.

Returns

Size of node name, in characters.

function xml_base::value

Synopsis

Ch* value() const;

Description

Gets value of node. Interpretation of value depends on type of node. Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.

Use value_size() function to determine length of the value.

Returns

Value of node, or empty string if node has no value.

function xml_base::value_size

Synopsis

std::size_t value_size() const;

Description

Gets size of node value, not including terminator character. This function works correctly irrespective of whether value is or is not zero terminated.

Returns

Size of node value, in characters.

function xml_base::name

Synopsis

void name(const Ch *name, std::size_t size);

Description

Sets name of node to a non zero-terminated string. See Ownership Of Strings .

Note that node does not own its name or value, it only stores a pointer to it. It will not delete or otherwise free the pointer on destruction. It is reponsibility of the user to properly manage lifetime of the string. The easiest way to achieve it is to use memory_pool of the document to allocate the string - on destruction of the document the string will be automatically freed.

Size of name must be specified separately, because name does not have to be zero terminated. Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).

Parameters

name
Name of node to set. Does not have to be zero terminated.
size
Size of name, in characters. This does not include zero terminator, if one is present.

function xml_base::name

Synopsis

void name(const Ch *name);

Description

Sets name of node to a zero-terminated string. See also Ownership Of Strings and xml_node::name(const Ch *, std::size_t).

Parameters

name
Name of node to set. Must be zero terminated.

function xml_base::value

Synopsis

void value(const Ch *value, std::size_t size);

Description

Sets value of node to a non zero-terminated string. See Ownership Of Strings .

Note that node does not own its name or value, it only stores a pointer to it. It will not delete or otherwise free the pointer on destruction. It is reponsibility of the user to properly manage lifetime of the string. The easiest way to achieve it is to use memory_pool of the document to allocate the string - on destruction of the document the string will be automatically freed.

Size of value must be specified separately, because it does not have to be zero terminated. Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).

If an element has a child node of type node_data, it will take precedence over element value when printing. If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.

Parameters

value
value of node to set. Does not have to be zero terminated.
size
Size of value, in characters. This does not include zero terminator, if one is present.

function xml_base::value

Synopsis

void value(const Ch *value);

Description

Sets value of node to a zero-terminated string. See also Ownership Of Strings and xml_node::value(const Ch *, std::size_t).

Parameters

value
Vame of node to set. Must be zero terminated.

function xml_base::parent

Synopsis

xml_node<Ch>* parent() const;

Description

Gets node parent.

Returns

Pointer to parent node, or 0 if there is no parent.

class template rapidxml::xml_document

Defined in rapidxml.hpp
Inherits from xml_node memory_pool

Description

This class represents root of the DOM hierarchy. It is also an xml_node and a memory_pool through public inheritance. Use parse() function to build a DOM tree from a zero-terminated XML text string. parse() function allocates memory for nodes and attributes by using functions of xml_document, which are inherited from memory_pool. To access root node of the document, use the document itself, as if it was an xml_node.

Parameters

Ch
Character type to use.

constructor xml_document::xml_document

Synopsis

xml_document();

Description

Constructs empty XML document.

function xml_document::parse

Synopsis

void parse(Ch *text);

Description

Parses zero-terminated XML string according to given flags. Passed string will be modified by the parser, unless rapidxml::parse_non_destructive flag is used. The string must persist for the lifetime of the document. In case of error, rapidxml::parse_error exception will be thrown.

If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning. Make sure that data is zero-terminated.

Document can be parsed into multiple times. Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool.

Parameters

text
XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser.

function xml_document::clear

Synopsis

void clear();

Description

Clears the document by deleting all nodes and clearing the memory pool. All nodes owned by document pool are destroyed.

class template rapidxml::xml_node

Defined in rapidxml.hpp
Inherits from xml_base
Base class for xml_document

Description

Class representing a node of XML document. Each node may have associated name and value strings, which are available through name() and value() functions. Interpretation of name and value depends on type of the node. Type of node can be determined by using type() function.

Note that after parse, both name and value of node, if any, will point interior of source text used for parsing. Thus, this text must persist in the memory for the lifetime of node.

Parameters

Ch
Character type to use.

constructor xml_node::xml_node

Synopsis

xml_node(node_type type);

Description

Constructs an empty node with the specified type. Consider using memory_pool of appropriate document to allocate nodes manually.

Parameters

type
Type of node to construct.

function xml_node::type

Synopsis

node_type type() const;

Description

Gets type of node.

Returns

Type of node.

function xml_node::document

Synopsis

xml_document<Ch>* document() const;

Description

Gets document of which node is a child.

Returns

Pointer to document that contains this node, or 0 if there is no parent document.

function xml_node::first_node

Synopsis

xml_node<Ch>* first_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets first child node, optionally matching node name.

Parameters

name
Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found child, or 0 if not found.

function xml_node::last_node

Synopsis

xml_node<Ch>* last_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets last child node, optionally matching node name. Behaviour is undefined if node has no children. Use first_node() to test if node has children.

Parameters

name
Name of child to find, or 0 to return last child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found child, or 0 if not found.

function xml_node::previous_sibling

Synopsis

xml_node<Ch>* previous_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets previous sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use parent() to test if node has a parent.

Parameters

name
Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found sibling, or 0 if not found.

function xml_node::next_sibling

Synopsis

xml_node<Ch>* next_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets next sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use parent() to test if node has a parent.

Parameters

name
Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found sibling, or 0 if not found.

function xml_node::first_attribute

Synopsis

xml_attribute<Ch>* first_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets first attribute of node, optionally matching attribute name.

Parameters

name
Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found attribute, or 0 if not found.

function xml_node::last_attribute

Synopsis

xml_attribute<Ch>* last_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;

Description

Gets last attribute of node, optionally matching attribute name.

Parameters

name
Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size
Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive
Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found attribute, or 0 if not found.

function xml_node::type

Synopsis

void type(node_type type);

Description

Sets type of node.

Parameters

type
Type of node to set.

function xml_node::prepend_node

Synopsis

void prepend_node(xml_node< Ch > *child);

Description

Prepends a new child node. The prepended child becomes the first child, and all existing children are moved one position back.

Parameters

child
Node to prepend.

function xml_node::append_node

Synopsis

void append_node(xml_node< Ch > *child);

Description

Appends a new child node. The appended child becomes the last child.

Parameters

child
Node to append.

function xml_node::insert_node

Synopsis

void insert_node(xml_node< Ch > *where, xml_node< Ch > *child);

Description

Inserts a new child node at specified place inside the node. All children after and including the specified node are moved one position back.

Parameters

where
Place where to insert the child, or 0 to insert at the back.
child
Node to insert.

function xml_node::remove_first_node

Synopsis

void remove_first_node();

Description

Removes first child node. If node has no children, behaviour is undefined. Use first_node() to test if node has children.

function xml_node::remove_last_node

Synopsis

void remove_last_node();

Description

Removes last child of the node. If node has no children, behaviour is undefined. Use first_node() to test if node has children.

function xml_node::remove_node

Synopsis

void remove_node(xml_node< Ch > *where);

Description

Removes specified child from the node.

function xml_node::remove_all_nodes

Synopsis

void remove_all_nodes();

Description

Removes all child nodes (but not attributes).

function xml_node::prepend_attribute

Synopsis

void prepend_attribute(xml_attribute< Ch > *attribute);

Description

Prepends a new attribute to the node.

Parameters

attribute
Attribute to prepend.

function xml_node::append_attribute

Synopsis

void append_attribute(xml_attribute< Ch > *attribute);

Description

Appends a new attribute to the node.

Parameters

attribute
Attribute to append.

function xml_node::insert_attribute

Synopsis

void insert_attribute(xml_attribute< Ch > *where, xml_attribute< Ch > *attribute);

Description

Inserts a new attribute at specified place inside the node. All attributes after and including the specified attribute are moved one position back.

Parameters

where
Place where to insert the attribute, or 0 to insert at the back.
attribute
Attribute to insert.

function xml_node::remove_first_attribute

Synopsis

void remove_first_attribute();

Description

Removes first attribute of the node. If node has no attributes, behaviour is undefined. Use first_attribute() to test if node has attributes.

function xml_node::remove_last_attribute

Synopsis

void remove_last_attribute();

Description

Removes last attribute of the node. If node has no attributes, behaviour is undefined. Use first_attribute() to test if node has attributes.

function xml_node::remove_attribute

Synopsis

void remove_attribute(xml_attribute< Ch > *where);

Description

Removes specified attribute from node.

Parameters

where
Pointer to attribute to be removed.

function xml_node::remove_all_attributes

Synopsis

void remove_all_attributes();

Description

Removes all attributes of node.

enum node_type

Description

Enumeration listing all node types produced by the parser. Use xml_node::type() function to query node type.

Values

node_document
A document node. Name and value are empty.
node_element
An element node. Name contains element name. Value contains text of first data node.
node_data
A data node. Name is empty. Value contains data text.
node_cdata
A CDATA node. Name is empty. Value contains data text.
node_comment
A comment node. Name is empty. Value contains comment text.
node_declaration
A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
node_doctype
A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
node_pi
A PI node. Name contains target. Value contains instructions.

function parse_error_handler

Synopsis

void rapidxml::parse_error_handler(const char *what, void *where);

Description

When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function is called to notify user about the error. It must be defined by the user.

This function cannot return. If it does, the results are undefined.

A very simple definition might look like that: void rapidxml::parse_error_handler(const char *what, void *where) { std::cout << "Parse error: " << what << "\n"; std::abort(); }

Parameters

what
Human readable description of the error.
where
Pointer to character data where error was detected.

function print

Synopsis

OutIt rapidxml::print(OutIt out, const xml_node< Ch > &node, int flags=0);

Description

Prints XML to given output iterator.

Parameters

out
Output iterator to print to.
node
Node to be printed. Pass xml_document to print entire document.
flags
Flags controlling how XML is printed.

Returns

Output iterator pointing to position immediately after last character of printed text.

function print

Synopsis

std::basic_ostream<Ch>& rapidxml::print(std::basic_ostream< Ch > &out, const xml_node< Ch > &node, int flags=0);

Description

Prints XML to given output stream.

Parameters

out
Output stream to print to.
node
Node to be printed. Pass xml_document to print entire document.
flags
Flags controlling how XML is printed.

Returns

Output stream.

function operator<<

Synopsis

std::basic_ostream<Ch>& rapidxml::operator<<(std::basic_ostream< Ch > &out, const xml_node< Ch > &node);

Description

Prints formatted XML to given output stream. Uses default printing flags. Use print() function to customize printing process.

Parameters

out
Output stream to print to.
node
Node to be printed.

Returns

Output stream.

constant parse_no_data_nodes

Synopsis

const int parse_no_data_nodes = 0x1;

Description

Parse flag instructing the parser to not create data nodes. Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_no_element_values

Synopsis

const int parse_no_element_values = 0x2;

Description

Parse flag instructing the parser to not use text of first data node as a value of parent element. Can be combined with other flags by use of | operator. Note that child data nodes of element node take precendence over its value when printing. That is, if element has one or more child data nodes and a value, the value will be ignored. Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.

See xml_document::parse() function.

constant parse_no_string_terminators

Synopsis

const int parse_no_string_terminators = 0x4;

Description

Parse flag instructing the parser to not place zero terminators after strings in the source text. By default zero terminators are placed, modifying source text. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_no_entity_translation

Synopsis

const int parse_no_entity_translation = 0x8;

Description

Parse flag instructing the parser to not translate entities in the source text. By default entities are translated, modifying source text. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_no_utf8

Synopsis

const int parse_no_utf8 = 0x10;

Description

Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters. By default, UTF-8 handling is enabled. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_declaration_node

Synopsis

const int parse_declaration_node = 0x20;

Description

Parse flag instructing the parser to create XML declaration node. By default, declaration node is not created. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_comment_nodes

Synopsis

const int parse_comment_nodes = 0x40;

Description

Parse flag instructing the parser to create comments nodes. By default, comment nodes are not created. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_doctype_node

Synopsis

const int parse_doctype_node = 0x80;

Description

Parse flag instructing the parser to create DOCTYPE node. By default, doctype node is not created. Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_pi_nodes

Synopsis

const int parse_pi_nodes = 0x100;

Description

Parse flag instructing the parser to create PI nodes. By default, PI nodes are not created. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_validate_closing_tags

Synopsis

const int parse_validate_closing_tags = 0x200;

Description

Parse flag instructing the parser to validate closing tag names. If not set, name inside closing tag is irrelevant to the parser. By default, closing tags are not validated. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_trim_whitespace

Synopsis

const int parse_trim_whitespace = 0x400;

Description

Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes. By default, whitespace is not trimmed. This flag does not cause the parser to modify source text. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_normalize_whitespace

Synopsis

const int parse_normalize_whitespace = 0x800;

Description

Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character. Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag. By default, whitespace is not normalized. If this flag is specified, source text will be modified. Can be combined with other flags by use of | operator.

See xml_document::parse() function.

constant parse_default

Synopsis

const int parse_default = 0;

Description

Parse flags which represent default behaviour of the parser. This is always equal to 0, so that all other flags can be simply ored together. Normally there is no need to inconveniently disable flags by anding with their negated (~) values. This also means that meaning of each flag is a negation of the default setting. For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is enabled by default, and using the flag will disable it.

See xml_document::parse() function.

constant parse_non_destructive

Synopsis

const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;

Description

A combination of parse flags that forbids any modifications of the source text. This also results in faster parsing. However, note that the following will occur:
  • names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends
  • entities will not be translated
  • whitespace will not be normalized
See xml_document::parse() function.

constant parse_fastest

Synopsis

const int parse_fastest = parse_non_destructive | parse_no_data_nodes;

Description

A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.

See xml_document::parse() function.

constant parse_full

Synopsis

const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;

Description

A combination of parse flags resulting in largest amount of data being extracted. This usually results in slowest parsing.

See xml_document::parse() function.

constant print_no_indenting

Synopsis

const int print_no_indenting = 0x1;

Description

Printer flag instructing the printer to suppress indenting of XML. See print() function.

cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rapidxml/rapidxml.hpp000066400000000000000000003053361240331347200264270ustar00rootroot00000000000000#ifndef RAPIDXML_HPP_INCLUDED #define RAPIDXML_HPP_INCLUDED // Copyright (C) 2006, 2009 Marcin Kalicinski // Version 1.13 // Revision $DateTime: 2009/05/13 01:46:17 $ //! \file rapidxml.hpp This file contains rapidxml parser and DOM implementation // If standard library is disabled, user must provide implementations of // required functions and typedefs #if !defined(RAPIDXML_NO_STDLIB) #include // For std::size_t #include // For assert #include // For placement new #endif // On MSVC, disable "conditional expression is constant" warning (level 4). // This warning is almost impossible to avoid with certain types of templated // code #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4127) // Conditional expression is constant #endif /////////////////////////////////////////////////////////////////////////// // RAPIDXML_PARSE_ERROR #if defined(RAPIDXML_NO_EXCEPTIONS) #define RAPIDXML_PARSE_ERROR(what, where) \ { \ parse_error_handler(what, where); \ assert(0); \ } namespace rapidxml { //! When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, //! this function is called to notify user about the error. //! It must be defined by the user. //!

//! This function cannot return. If it does, the results are undefined. //!

//! A very simple definition might look like that: //! 

//! void %rapidxml::%parse_error_handler(const char *what, void *where)
//! {
//!     std::cout << "Parse error: " << what << "\n";
//!     std::abort();
//! }
//!
//! \param what Human readable description of the error. //! \param where Pointer to character data where error was detected. void parse_error_handler(const char *what, void *where); } #else #include // For std::exception #define RAPIDXML_PARSE_ERROR(what, where) throw parse_error(what, where) namespace rapidxml { //! Parse error exception. //! This exception is thrown by the parser when an error occurs. //! Use what() function to get human-readable error message. //! Use where() function to get a pointer to position within source text where // error was detected. //!

//! If throwing exceptions by the parser is undesirable, //! it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before // rapidxml.hpp is included. //! This will cause the parser to call rapidxml::parse_error_handler() // function instead of throwing an exception. //! This function must be defined by the user. //!

//! This class derives from std::exception class. class parse_error : public std::exception { public: //! Constructs parse error parse_error(const char *what, void *where) : m_what(what), m_where(where) {} //! Gets human readable description of error. //! \return Pointer to null terminated description of the error. virtual const char *what() const throw() { return m_what; } //! Gets pointer to character data where error happened. //! Ch should be the same as char type of xml_document that produced the // error. //! \return Pointer to location within the parsed string where error // occured. template Ch *where() const { return reinterpret_cast(m_where); } private: const char *m_what; void *m_where; }; } #endif /////////////////////////////////////////////////////////////////////////// // Pool sizes #ifndef RAPIDXML_STATIC_POOL_SIZE // Size of static memory block of memory_pool. // Define RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to // override the default value. // No dynamic memory allocations are performed by memory_pool until static // memory is exhausted. #define RAPIDXML_STATIC_POOL_SIZE (64 * 1024) #endif #ifndef RAPIDXML_DYNAMIC_POOL_SIZE // Size of dynamic memory block of memory_pool. // Define RAPIDXML_DYNAMIC_POOL_SIZE before including rapidxml.hpp if you want // to override the default value. // After the static block is exhausted, dynamic blocks with approximately this // size are allocated by memory_pool. #define RAPIDXML_DYNAMIC_POOL_SIZE (64 * 1024) #endif #ifndef RAPIDXML_ALIGNMENT // Memory allocation alignment. // Define RAPIDXML_ALIGNMENT before including rapidxml.hpp if you want to // override the default value, which is the size of pointer. // All memory allocations for nodes, attributes and strings will be aligned to // this value. // This must be a power of 2 and at least 1, otherwise memory_pool will not // work. #define RAPIDXML_ALIGNMENT sizeof(void *) #endif namespace rapidxml { // Forward declarations template class xml_node; template class xml_attribute; template class xml_document; //! Enumeration listing all node types produced by the parser. //! Use xml_node::type() function to query node type. enum node_type { node_document, //!< A document node. Name and value are empty. node_element, //!< An element node. Name contains element name. Value // contains text of first data node. node_data, //!< A data node. Name is empty. Value contains data text. node_cdata, //!< A CDATA node. Name is empty. Value contains data text. node_comment, //!< A comment node. Name is empty. Value contains comment // text. node_declaration, //!< A declaration node. Name and value are empty. // Declaration parameters (version, encoding and // standalone) are in node attributes. node_doctype, //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE // text. node_pi //!< A PI node. Name contains target. Value contains instructions. }; /////////////////////////////////////////////////////////////////////// // Parsing flags //! Parse flag instructing the parser to not create data nodes. //! Text of first data node will still be placed in value of parent element, // unless rapidxml::parse_no_element_values flag is also specified. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_no_data_nodes = 0x1; //! Parse flag instructing the parser to not use text of first data node as a // value of parent element. //! Can be combined with other flags by use of | operator. //! Note that child data nodes of element node take precendence over its value // when printing. //! That is, if element has one or more child data nodes and a value, // the value will be ignored. //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes // if you want to manipulate data using values of elements. //!

//! See xml_document::parse() function. const int parse_no_element_values = 0x2; //! Parse flag instructing the parser to not place zero terminators after // strings in the source text. //! By default zero terminators are placed, modifying source text. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_no_string_terminators = 0x4; //! Parse flag instructing the parser to not translate entities in the source // text. //! By default entities are translated, modifying source text. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_no_entity_translation = 0x8; //! Parse flag instructing the parser to disable UTF-8 handling and assume // plain 8 bit characters. //! By default, UTF-8 handling is enabled. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_no_utf8 = 0x10; //! Parse flag instructing the parser to create XML declaration node. //! By default, declaration node is not created. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_declaration_node = 0x20; //! Parse flag instructing the parser to create comments nodes. //! By default, comment nodes are not created. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_comment_nodes = 0x40; //! Parse flag instructing the parser to create DOCTYPE node. //! By default, doctype node is not created. //! Although W3C specification allows at most one DOCTYPE node, RapidXml will // silently accept documents with more than one. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_doctype_node = 0x80; //! Parse flag instructing the parser to create PI nodes. //! By default, PI nodes are not created. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_pi_nodes = 0x100; //! Parse flag instructing the parser to validate closing tag names. //! If not set, name inside closing tag is irrelevant to the parser. //! By default, closing tags are not validated. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_validate_closing_tags = 0x200; //! Parse flag instructing the parser to trim all leading and trailing // whitespace of data nodes. //! By default, whitespace is not trimmed. //! This flag does not cause the parser to modify source text. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_trim_whitespace = 0x400; //! Parse flag instructing the parser to condense all whitespace runs of data // nodes to a single space character. //! Trimming of leading and trailing whitespace of data is controlled by // rapidxml::parse_trim_whitespace flag. //! By default, whitespace is not normalized. //! If this flag is specified, source text will be modified. //! Can be combined with other flags by use of | operator. //!

//! See xml_document::parse() function. const int parse_normalize_whitespace = 0x800; // Compound flags //! Parse flags which represent default behaviour of the parser. //! This is always equal to 0, so that all other flags can be simply ored // together. //! Normally there is no need to inconveniently disable flags by anding with // their negated (~) values. //! This also means that meaning of each flag is a negation of the // default setting. //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 // is enabled by default, //! and using the flag will disable it. //!

//! See xml_document::parse() function. const int parse_default = 0; //! A combination of parse flags that forbids any modifications of the source // text. //! This also results in faster parsing. However, note that the following will // occur: //!
    //!
  • names and values of nodes will not be zero terminated, you have to use // xml_base::name_size() and xml_base::value_size() functions to determine // where name and value ends
    • //!
  • entities will not be translated
    • //!
  • whitespace will not be normalized
    • //!
//! See xml_document::parse() function. const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation; //! A combination of parse flags resulting in fastest possible parsing, // without sacrificing important data. //!

//! See xml_document::parse() function. const int parse_fastest = parse_non_destructive | parse_no_data_nodes; //! A combination of parse flags resulting in largest amount of data being // extracted. //! This usually results in slowest parsing. //!

//! See xml_document::parse() function. const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags; /////////////////////////////////////////////////////////////////////// // Internals //! \cond internal namespace internal { // Struct that contains lookup tables for the parser // It must be a template to allow correct linking (because it has static // data members, which are defined in a header file). template struct lookup_tables { static const unsigned char lookup_whitespace[256]; // Whitespace table static const unsigned char lookup_node_name[256]; // Node name table static const unsigned char lookup_text[256]; // Text table static const unsigned char lookup_text_pure_no_ws[256]; // Text table static const unsigned char lookup_text_pure_with_ws[256]; // Text table static const unsigned char lookup_attribute_name[256]; // Attribute name // table static const unsigned char lookup_attribute_data_1[256]; // Attribute // data table // with single // quote static const unsigned char lookup_attribute_data_1_pure[256]; // Attribute // data table // with single // quote static const unsigned char lookup_attribute_data_2[256]; // Attribute // data table // with double // quotes static const unsigned char lookup_attribute_data_2_pure[256]; // Attribute // data table // with double // quotes static const unsigned char lookup_digits[256]; // Digits static const unsigned char lookup_upcase[256]; // To uppercase conversion // table for ASCII // characters }; // Find length of the string template inline std::size_t measure(const Ch *p) { const Ch *tmp = p; while (*tmp) ++tmp; return tmp - p; } // Compare strings for equality template inline bool compare(const Ch *p1, std::size_t size1, const Ch *p2, std::size_t size2, bool case_sensitive) { if (size1 != size2) return false; if (case_sensitive) { for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2) if (*p1 != *p2) return false; } else { for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2) if (lookup_tables<0>::lookup_upcase[static_cast(*p1)] != lookup_tables<0>::lookup_upcase[static_cast(*p2)]) return false; } return true; } } //! \endcond /////////////////////////////////////////////////////////////////////// // Memory pool //! This class is used by the parser to create new nodes and attributes, // without overheads of dynamic memory allocation. //! In most cases, you will not need to use this class directly. //! However, if you need to create nodes manually or modify names/values of // nodes, //! you are encouraged to use memory_pool of relevant xml_document to allocate // the memory. //! Not only is this faster than allocating them by using new // operator, //! but also their lifetime will be tied to the lifetime of document, //! possibly simplyfing memory management. //!

//! Call allocate_node() or allocate_attribute() functions to obtain new nodes // or attributes from the pool. //! You can also call allocate_string() function to allocate strings. //! Such strings can then be used as names or values of nodes without worrying // about their lifetime. //! Note that there is no free() function -- all allocations are // freed at once when clear() function is called, //! or when the pool is destroyed. //!

//! It is also possible to create a standalone memory_pool, and use it //! to allocate nodes, whose lifetime will not be tied to any document. //!

//! Pool maintains RAPIDXML_STATIC_POOL_SIZE bytes of statically // allocated memory. //! Until static memory is exhausted, no dynamic memory allocations are done. //! When static memory is exhausted, pool allocates additional blocks of // memory of size RAPIDXML_DYNAMIC_POOL_SIZE each, //! by using global new[] and delete[] operators. //! This behaviour can be changed by setting custom allocation routines. //! Use set_allocator() function to set them. //!

//! Allocations for nodes, attributes and strings are aligned at //RAPIDXML_ALIGNMENT bytes. //! This value defaults to the size of pointer on target architecture. //!

//! To obtain absolutely top performance from the parser, //! it is important that all nodes are allocated from a single, contiguous // block of memory. //! Otherwise, cache misses when jumping between two (or more) disjoint blocks // of memory can slow down parsing quite considerably. //! If required, you can tweak RAPIDXML_STATIC_POOL_SIZE, //RAPIDXML_DYNAMIC_POOL_SIZE and RAPIDXML_ALIGNMENT //! to obtain best wasted memory to performance compromise. //! To do it, define their values before rapidxml.hpp file is included. //! \param Ch Character type of created nodes. template class memory_pool { public: //! \cond internal typedef void *(alloc_func)(std::size_t); // Type of user-defined function // used to allocate memory typedef void(free_func)(void *); // Type of user-defined function used to // free memory //! \endcond //! Constructs empty pool with default allocator functions. memory_pool() : m_alloc_func(0), m_free_func(0) { init(); } //! Destroys pool and frees all the memory. //! This causes memory occupied by nodes allocated by the pool to be freed. //! Nodes allocated from the pool are no longer valid. ~memory_pool() { clear(); } //! Allocates a new node from the pool, and optionally assigns name and // value to it. //! If the allocation request cannot be accomodated, this function will // throw std::bad_alloc. //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this // function //! will call rapidxml::parse_error_handler() function. //! \param type Type of node to create. //! \param name Name to assign to the node, or 0 to assign no name. //! \param value Value to assign to the node, or 0 to assign no value. //! \param name_size Size of name to assign, or 0 to automatically calculate // size from name string. //! \param value_size Size of value to assign, or 0 to automatically // calculate size from value string. //! \return Pointer to allocated node. This pointer will never be NULL. xml_node *allocate_node(node_type type, const Ch *name = 0, const Ch *value = 0, std::size_t name_size = 0, std::size_t value_size = 0) { void *memory = allocate_aligned(sizeof(xml_node)); xml_node *node = new (memory) xml_node(type); if (name) { if (name_size > 0) node->name(name, name_size); else node->name(name); } if (value) { if (value_size > 0) node->value(value, value_size); else node->value(value); } return node; } //! Allocates a new attribute from the pool, and optionally assigns name and // value to it. //! If the allocation request cannot be accomodated, this function will // throw std::bad_alloc. //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this // function //! will call rapidxml::parse_error_handler() function. //! \param name Name to assign to the attribute, or 0 to assign no name. //! \param value Value to assign to the attribute, or 0 to assign no value. //! \param name_size Size of name to assign, or 0 to automatically calculate // size from name string. //! \param value_size Size of value to assign, or 0 to automatically // calculate size from value string. //! \return Pointer to allocated attribute. This pointer will never be NULL. xml_attribute *allocate_attribute(const Ch *name = 0, const Ch *value = 0, std::size_t name_size = 0, std::size_t value_size = 0) { void *memory = allocate_aligned(sizeof(xml_attribute)); xml_attribute *attribute = new (memory) xml_attribute; if (name) { if (name_size > 0) attribute->name(name, name_size); else attribute->name(name); } if (value) { if (value_size > 0) attribute->value(value, value_size); else attribute->value(value); } return attribute; } //! Allocates a char array of given size from the pool, and optionally // copies a given string to it. //! If the allocation request cannot be accomodated, this function will // throw std::bad_alloc. //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this // function //! will call rapidxml::parse_error_handler() function. //! \param source String to initialize the allocated memory with, or 0 to // not initialize it. //! \param size Number of characters to allocate, or zero to calculate it // automatically from source string length; if size is 0, source string must // be specified and null terminated. //! \return Pointer to allocated char array. This pointer will never be // NULL. Ch *allocate_string(const Ch *source = 0, std::size_t size = 0) { assert(source || size); // Either source or size (or both) must be specified if (size == 0) size = internal::measure(source) + 1; Ch *result = static_cast(allocate_aligned(size * sizeof(Ch))); if (source) for (std::size_t i = 0; i < size; ++i) result[i] = source[i]; return result; } //! Clones an xml_node and its hierarchy of child nodes and attributes. //! Nodes and attributes are allocated from this memory pool. //! Names and values are not cloned, they are shared between the clone and // the source. //! Result node can be optionally specified as a second parameter, //! in which case its contents will be replaced with cloned source node. //! This is useful when you want to clone entire document. //! \param source Node to clone. //! \param result Node to put results in, or 0 to automatically allocate // result node //! \return Pointer to cloned node. This pointer will never be NULL. xml_node *clone_node(const xml_node *source, xml_node *result = 0) { // Prepare result node if (result) { result->remove_all_attributes(); result->remove_all_nodes(); result->type(source->type()); } else result = allocate_node(source->type()); // Clone name and value result->name(source->name(), source->name_size()); result->value(source->value(), source->value_size()); // Clone child nodes and attributes for (xml_node *child = source->first_node(); child; child = child->next_sibling()) result->append_node(clone_node(child)); for (xml_attribute *attr = source->first_attribute(); attr; attr = attr->next_attribute()) result->append_attribute(allocate_attribute( attr->name(), attr->value(), attr->name_size(), attr->value_size())); return result; } //! Clears the pool. //! This causes memory occupied by nodes allocated by the pool to be freed. //! Any nodes or strings allocated from the pool will no longer be valid. void clear() { while (m_begin != m_static_memory) { char *previous_begin = reinterpret_cast
(align(m_begin))->previous_begin; if (m_free_func) m_free_func(m_begin); else delete[] m_begin; m_begin = previous_begin; } init(); } //! Sets or resets the user-defined memory allocation functions for the // pool. //! This can only be called when no memory is allocated from the pool yet, // otherwise results are undefined. //! Allocation function must not return invalid pointer on failure. It // should either throw, //! stop the program, or use longjmp() function to pass control // to other place of program. //! If it returns invalid pointer, results are undefined. //!

//! User defined allocation functions must have the following forms: //!
//!
void *allocate(std::size_t size); //!
void free(void *pointer); //!
//! \param af Allocation function, or 0 to restore default function //! \param ff Free function, or 0 to restore default function void set_allocator(alloc_func *af, free_func *ff) { assert(m_begin == m_static_memory && m_ptr == align(m_begin)); // Verify that no memory is allocated yet m_alloc_func = af; m_free_func = ff; } private: struct header { char *previous_begin; }; void init() { m_begin = m_static_memory; m_ptr = align(m_begin); m_end = m_static_memory + sizeof(m_static_memory); } char *align(char *ptr) { std::size_t alignment = ((RAPIDXML_ALIGNMENT - (std::size_t(ptr) & (RAPIDXML_ALIGNMENT - 1))) & (RAPIDXML_ALIGNMENT - 1)); return ptr + alignment; } char *allocate_raw(std::size_t size) { // Allocate void *memory; if (m_alloc_func) // Allocate memory using either user-specified // allocation function or global operator new[] { memory = m_alloc_func(size); assert(memory); // Allocator is not allowed to return 0, on failure it // must either throw, stop the program or use longjmp } else { memory = new char[size]; #ifdef RAPIDXML_NO_EXCEPTIONS if (!memory) // If exceptions are disabled, verify memory allocation, // because new will not be able to throw bad_alloc RAPIDXML_PARSE_ERROR("out of memory", 0); #endif } return static_cast(memory); } void *allocate_aligned(std::size_t size) { // Calculate aligned pointer char *result = align(m_ptr); // If not enough memory left in current pool, allocate a new pool if (result + size > m_end) { // Calculate required pool size (may be bigger than // RAPIDXML_DYNAMIC_POOL_SIZE) std::size_t pool_size = RAPIDXML_DYNAMIC_POOL_SIZE; if (pool_size < size) pool_size = size; // Allocate std::size_t alloc_size = sizeof(header) + (2 * RAPIDXML_ALIGNMENT - 2) + pool_size; // 2 alignments required in worst // case: one for header, one for // actual allocation char *raw_memory = allocate_raw(alloc_size); // Setup new pool in allocated memory char *pool = align(raw_memory); header *new_header = reinterpret_cast
(pool); new_header->previous_begin = m_begin; m_begin = raw_memory; m_ptr = pool + sizeof(header); m_end = raw_memory + alloc_size; // Calculate aligned pointer again using new pool result = align(m_ptr); } // Update pool and return aligned pointer m_ptr = result + size; return result; } char *m_begin; // Start of raw memory making up current pool char *m_ptr; // First free byte in current pool char *m_end; // One past last available byte in current pool char m_static_memory[RAPIDXML_STATIC_POOL_SIZE]; // Static raw memory alloc_func *m_alloc_func; // Allocator function, or 0 if default is to be // used free_func *m_free_func; // Free function, or 0 if default is to be used }; /////////////////////////////////////////////////////////////////////////// // XML base //! Base class for xml_node and xml_attribute implementing common functions: //! name(), name_size(), value(), value_size() and parent(). //! \param Ch Character type to use template class xml_base { public: /////////////////////////////////////////////////////////////////////////// // Construction & destruction // Construct a base with empty name, value and parent xml_base() : m_name(0), m_value(0), m_parent(0) {} /////////////////////////////////////////////////////////////////////////// // Node data access //! Gets name of the node. //! Interpretation of name depends on type of node. //! Note that name will not be zero-terminated if // rapidxml::parse_no_string_terminators option was selected during parse. //!

//! Use name_size() function to determine length of the name. //! \return Name of node, or empty string if node has no name. Ch *name() const { return m_name ? m_name : nullstr(); } //! Gets size of node name, not including terminator character. //! This function works correctly irrespective of whether name is or is not // zero terminated. //! \return Size of node name, in characters. std::size_t name_size() const { return m_name ? m_name_size : 0; } //! Gets value of node. //! Interpretation of value depends on type of node. //! Note that value will not be zero-terminated if // rapidxml::parse_no_string_terminators option was selected during parse. //!

//! Use value_size() function to determine length of the value. //! \return Value of node, or empty string if node has no value. Ch *value() const { return m_value ? m_value : nullstr(); } //! Gets size of node value, not including terminator character. //! This function works correctly irrespective of whether value is or is not // zero terminated. //! \return Size of node value, in characters. std::size_t value_size() const { return m_value ? m_value_size : 0; } /////////////////////////////////////////////////////////////////////////// // Node modification //! Sets name of node to a non zero-terminated string. //! See \ref ownership_of_strings. //!

//! Note that node does not own its name or value, it only stores a pointer // to it. //! It will not delete or otherwise free the pointer on destruction. //! It is reponsibility of the user to properly manage lifetime of the // string. //! The easiest way to achieve it is to use memory_pool of the document to // allocate the string - //! on destruction of the document the string will be automatically freed. //!

//! Size of name must be specified separately, because name does not have to // be zero terminated. //! Use name(const Ch *) function to have the length automatically // calculated (string must be zero terminated). //! \param name Name of node to set. Does not have to be zero terminated. //! \param size Size of name, in characters. This does not include zero // terminator, if one is present. void name(const Ch *name, std::size_t size) { m_name = const_cast(name); m_name_size = size; } //! Sets name of node to a zero-terminated string. //! See also \ref ownership_of_strings and xml_node::name(const Ch *, // std::size_t). //! \param name Name of node to set. Must be zero terminated. void name(const Ch *name) { this->name(name, internal::measure(name)); } //! Sets value of node to a non zero-terminated string. //! See \ref ownership_of_strings. //!

//! Note that node does not own its name or value, it only stores a pointer // to it. //! It will not delete or otherwise free the pointer on destruction. //! It is reponsibility of the user to properly manage lifetime of the // string. //! The easiest way to achieve it is to use memory_pool of the document to // allocate the string - //! on destruction of the document the string will be automatically freed. //!

//! Size of value must be specified separately, because it does not have to // be zero terminated. //! Use value(const Ch *) function to have the length automatically // calculated (string must be zero terminated). //!

//! If an element has a child node of type node_data, it will take // precedence over element value when printing. //! If you want to manipulate data of elements using values, use parser flag // rapidxml::parse_no_data_nodes to prevent creation of data nodes by the // parser. //! \param value value of node to set. Does not have to be zero terminated. //! \param size Size of value, in characters. This does not include zero // terminator, if one is present. void value(const Ch *value, std::size_t size) { m_value = const_cast(value); m_value_size = size; } //! Sets value of node to a zero-terminated string. //! See also \ref ownership_of_strings and xml_node::value(const Ch *, // std::size_t). //! \param value Vame of node to set. Must be zero terminated. void value(const Ch *value) { this->value(value, internal::measure(value)); } /////////////////////////////////////////////////////////////////////////// // Related nodes access //! Gets node parent. //! \return Pointer to parent node, or 0 if there is no parent. xml_node *parent() const { return m_parent; } protected: // Return empty string static Ch *nullstr() { static Ch zero = Ch('\0'); return &zero; } Ch *m_name; // Name of node, or 0 if no name Ch *m_value; // Value of node, or 0 if no value std::size_t m_name_size; // Length of node name, or undefined of no name std::size_t m_value_size; // Length of node value, or undefined if no value xml_node *m_parent; // Pointer to parent node, or 0 if none }; //! Class representing attribute node of XML document. //! Each attribute has name and value strings, which are available through // name() and value() functions (inherited from xml_base). //! Note that after parse, both name and value of attribute will point to // interior of source text used for parsing. //! Thus, this text must persist in memory for the lifetime of attribute. //! \param Ch Character type to use. template class xml_attribute : public xml_base { friend class xml_node; public: /////////////////////////////////////////////////////////////////////////// // Construction & destruction //! Constructs an empty attribute with the specified type. //! Consider using memory_pool of appropriate xml_document if allocating // attributes manually. xml_attribute() {} /////////////////////////////////////////////////////////////////////////// // Related nodes access //! Gets document of which attribute is a child. //! \return Pointer to document that contains this attribute, or 0 if there // is no parent document. xml_document *document() const { if (xml_node *node = this->parent()) { while (node->parent()) node = node->parent(); return node->type() == node_document ? static_cast *>(node) : 0; } else return 0; } //! Gets previous attribute, optionally matching attribute name. //! \param name Name of attribute to find, or 0 to return previous attribute // regardless of its name; this string doesn't have to be zero-terminated if // name_size is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found attribute, or 0 if not found. xml_attribute *previous_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_attribute *attribute = m_prev_attribute; attribute; attribute = attribute->m_prev_attribute) if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive)) return attribute; return 0; } else return this->m_parent ? m_prev_attribute : 0; } //! Gets next attribute, optionally matching attribute name. //! \param name Name of attribute to find, or 0 to return next attribute // regardless of its name; this string doesn't have to be zero-terminated if // name_size is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found attribute, or 0 if not found. xml_attribute *next_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_attribute *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute) if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive)) return attribute; return 0; } else return this->m_parent ? m_next_attribute : 0; } private: xml_attribute *m_prev_attribute; // Pointer to previous sibling of // attribute, or 0 if none; only valid // if parent is non-zero xml_attribute *m_next_attribute; // Pointer to next sibling of // attribute, or 0 if none; only valid // if parent is non-zero }; /////////////////////////////////////////////////////////////////////////// // XML node //! Class representing a node of XML document. //! Each node may have associated name and value strings, which are available // through name() and value() functions. //! Interpretation of name and value depends on type of the node. //! Type of node can be determined by using type() function. //!

//! Note that after parse, both name and value of node, if any, will point // interior of source text used for parsing. //! Thus, this text must persist in the memory for the lifetime of node. //! \param Ch Character type to use. template class xml_node : public xml_base { public: /////////////////////////////////////////////////////////////////////////// // Construction & destruction //! Constructs an empty node with the specified type. //! Consider using memory_pool of appropriate document to allocate nodes // manually. //! \param type Type of node to construct. xml_node(node_type type) : m_type(type), m_first_node(0), m_first_attribute(0) {} /////////////////////////////////////////////////////////////////////////// // Node data access //! Gets type of node. //! \return Type of node. node_type type() const { return m_type; } /////////////////////////////////////////////////////////////////////////// // Related nodes access //! Gets document of which node is a child. //! \return Pointer to document that contains this node, or 0 if there is no // parent document. xml_document *document() const { xml_node *node = const_cast *>(this); while (node->parent()) node = node->parent(); return node->type() == node_document ? static_cast *>(node) : 0; } //! Gets first child node, optionally matching node name. //! \param name Name of child to find, or 0 to return first child regardless // of its name; this string doesn't have to be zero-terminated if name_size // is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found child, or 0 if not found. xml_node *first_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_node *child = m_first_node; child; child = child->next_sibling()) if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive)) return child; return 0; } else return m_first_node; } //! Gets last child node, optionally matching node name. //! Behaviour is undefined if node has no children. //! Use first_node() to test if node has children. //! \param name Name of child to find, or 0 to return last child regardless // of its name; this string doesn't have to be zero-terminated if name_size // is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found child, or 0 if not found. xml_node *last_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { assert( m_first_node); // Cannot query for last child if node has no children if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_node *child = m_last_node; child; child = child->previous_sibling()) if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive)) return child; return 0; } else return m_last_node; } //! Gets previous sibling node, optionally matching node name. //! Behaviour is undefined if node has no parent. //! Use parent() to test if node has a parent. //! \param name Name of sibling to find, or 0 to return previous sibling // regardless of its name; this string doesn't have to be zero-terminated if // name_size is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found sibling, or 0 if not found. xml_node *previous_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { assert(this->m_parent); // Cannot query for siblings if node has no parent if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_node *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling) if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive)) return sibling; return 0; } else return m_prev_sibling; } //! Gets next sibling node, optionally matching node name. //! Behaviour is undefined if node has no parent. //! Use parent() to test if node has a parent. //! \param name Name of sibling to find, or 0 to return next sibling // regardless of its name; this string doesn't have to be zero-terminated if // name_size is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found sibling, or 0 if not found. xml_node *next_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { assert(this->m_parent); // Cannot query for siblings if node has no parent if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_node *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling) if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive)) return sibling; return 0; } else return m_next_sibling; } //! Gets first attribute of node, optionally matching attribute name. //! \param name Name of attribute to find, or 0 to return first attribute // regardless of its name; this string doesn't have to be zero-terminated if // name_size is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found attribute, or 0 if not found. xml_attribute *first_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_attribute *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute) if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive)) return attribute; return 0; } else return m_first_attribute; } //! Gets last attribute of node, optionally matching attribute name. //! \param name Name of attribute to find, or 0 to return last attribute // regardless of its name; this string doesn't have to be zero-terminated if // name_size is non-zero //! \param name_size Size of name, in characters, or 0 to have size // calculated automatically from string //! \param case_sensitive Should name comparison be case-sensitive; non // case-sensitive comparison works properly only for ASCII characters //! \return Pointer to found attribute, or 0 if not found. xml_attribute *last_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const { if (name) { if (name_size == 0) name_size = internal::measure(name); for (xml_attribute *attribute = m_last_attribute; attribute; attribute = attribute->m_prev_attribute) if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive)) return attribute; return 0; } else return m_first_attribute ? m_last_attribute : 0; } /////////////////////////////////////////////////////////////////////////// // Node modification //! Sets type of node. //! \param type Type of node to set. void type(node_type type) { m_type = type; } /////////////////////////////////////////////////////////////////////////// // Node manipulation //! Prepends a new child node. //! The prepended child becomes the first child, and all existing children // are moved one position back. //! \param child Node to prepend. void prepend_node(xml_node *child) { assert(child && !child->parent() && child->type() != node_document); if (first_node()) { child->m_next_sibling = m_first_node; m_first_node->m_prev_sibling = child; } else { child->m_next_sibling = 0; m_last_node = child; } m_first_node = child; child->m_parent = this; child->m_prev_sibling = 0; } //! Appends a new child node. //! The appended child becomes the last child. //! \param child Node to append. void append_node(xml_node *child) { assert(child && !child->parent() && child->type() != node_document); if (first_node()) { child->m_prev_sibling = m_last_node; m_last_node->m_next_sibling = child; } else { child->m_prev_sibling = 0; m_first_node = child; } m_last_node = child; child->m_parent = this; child->m_next_sibling = 0; } //! Inserts a new child node at specified place inside the node. //! All children after and including the specified node are moved one // position back. //! \param where Place where to insert the child, or 0 to insert at the // back. //! \param child Node to insert. void insert_node(xml_node *where, xml_node *child) { assert(!where || where->parent() == this); assert(child && !child->parent() && child->type() != node_document); if (where == m_first_node) prepend_node(child); else if (where == 0) append_node(child); else { child->m_prev_sibling = where->m_prev_sibling; child->m_next_sibling = where; where->m_prev_sibling->m_next_sibling = child; where->m_prev_sibling = child; child->m_parent = this; } } //! Removes first child node. //! If node has no children, behaviour is undefined. //! Use first_node() to test if node has children. void remove_first_node() { assert(first_node()); xml_node *child = m_first_node; m_first_node = child->m_next_sibling; if (child->m_next_sibling) child->m_next_sibling->m_prev_sibling = 0; else m_last_node = 0; child->m_parent = 0; } //! Removes last child of the node. //! If node has no children, behaviour is undefined. //! Use first_node() to test if node has children. void remove_last_node() { assert(first_node()); xml_node *child = m_last_node; if (child->m_prev_sibling) { m_last_node = child->m_prev_sibling; child->m_prev_sibling->m_next_sibling = 0; } else m_first_node = 0; child->m_parent = 0; } //! Removes specified child from the node // \param where Pointer to child to be removed. void remove_node(xml_node *where) { assert(where && where->parent() == this); assert(first_node()); if (where == m_first_node) remove_first_node(); else if (where == m_last_node) remove_last_node(); else { where->m_prev_sibling->m_next_sibling = where->m_next_sibling; where->m_next_sibling->m_prev_sibling = where->m_prev_sibling; where->m_parent = 0; } } //! Removes all child nodes (but not attributes). void remove_all_nodes() { for (xml_node *node = first_node(); node; node = node->m_next_sibling) node->m_parent = 0; m_first_node = 0; } //! Prepends a new attribute to the node. //! \param attribute Attribute to prepend. void prepend_attribute(xml_attribute *attribute) { assert(attribute && !attribute->parent()); if (first_attribute()) { attribute->m_next_attribute = m_first_attribute; m_first_attribute->m_prev_attribute = attribute; } else { attribute->m_next_attribute = 0; m_last_attribute = attribute; } m_first_attribute = attribute; attribute->m_parent = this; attribute->m_prev_attribute = 0; } //! Appends a new attribute to the node. //! \param attribute Attribute to append. void append_attribute(xml_attribute *attribute) { assert(attribute && !attribute->parent()); if (first_attribute()) { attribute->m_prev_attribute = m_last_attribute; m_last_attribute->m_next_attribute = attribute; } else { attribute->m_prev_attribute = 0; m_first_attribute = attribute; } m_last_attribute = attribute; attribute->m_parent = this; attribute->m_next_attribute = 0; } //! Inserts a new attribute at specified place inside the node. //! All attributes after and including the specified attribute are moved one // position back. //! \param where Place where to insert the attribute, or 0 to insert at the // back. //! \param attribute Attribute to insert. void insert_attribute(xml_attribute *where, xml_attribute *attribute) { assert(!where || where->parent() == this); assert(attribute && !attribute->parent()); if (where == m_first_attribute) prepend_attribute(attribute); else if (where == 0) append_attribute(attribute); else { attribute->m_prev_attribute = where->m_prev_attribute; attribute->m_next_attribute = where; where->m_prev_attribute->m_next_attribute = attribute; where->m_prev_attribute = attribute; attribute->m_parent = this; } } //! Removes first attribute of the node. //! If node has no attributes, behaviour is undefined. //! Use first_attribute() to test if node has attributes. void remove_first_attribute() { assert(first_attribute()); xml_attribute *attribute = m_first_attribute; if (attribute->m_next_attribute) { attribute->m_next_attribute->m_prev_attribute = 0; } else m_last_attribute = 0; attribute->m_parent = 0; m_first_attribute = attribute->m_next_attribute; } //! Removes last attribute of the node. //! If node has no attributes, behaviour is undefined. //! Use first_attribute() to test if node has attributes. void remove_last_attribute() { assert(first_attribute()); xml_attribute *attribute = m_last_attribute; if (attribute->m_prev_attribute) { attribute->m_prev_attribute->m_next_attribute = 0; m_last_attribute = attribute->m_prev_attribute; } else m_first_attribute = 0; attribute->m_parent = 0; } //! Removes specified attribute from node. //! \param where Pointer to attribute to be removed. void remove_attribute(xml_attribute *where) { assert(first_attribute() && where->parent() == this); if (where == m_first_attribute) remove_first_attribute(); else if (where == m_last_attribute) remove_last_attribute(); else { where->m_prev_attribute->m_next_attribute = where->m_next_attribute; where->m_next_attribute->m_prev_attribute = where->m_prev_attribute; where->m_parent = 0; } } //! Removes all attributes of node. void remove_all_attributes() { for (xml_attribute *attribute = first_attribute(); attribute; attribute = attribute->m_next_attribute) attribute->m_parent = 0; m_first_attribute = 0; } private: /////////////////////////////////////////////////////////////////////////// // Restrictions // No copying xml_node(const xml_node &); void operator=(const xml_node &); /////////////////////////////////////////////////////////////////////////// // Data members // Note that some of the pointers below have UNDEFINED values if certain // other pointers are 0. // This is required for maximum performance, as it allows the parser to omit // initialization of // unneded/redundant values. // // The rules are as follows: // 1. first_node and first_attribute contain valid pointers, or 0 if node // has no children/attributes respectively // 2. last_node and last_attribute are valid only if node has at least one // child/attribute respectively, otherwise they contain garbage // 3. prev_sibling and next_sibling are valid only if node has a parent, // otherwise they contain garbage node_type m_type; // Type of node; always valid xml_node *m_first_node; // Pointer to first child node, or 0 if none; // always valid xml_node *m_last_node; // Pointer to last child node, or 0 if none; // this value is only valid if m_first_node is // non-zero xml_attribute *m_first_attribute; // Pointer to first attribute of // node, or 0 if none; always valid xml_attribute *m_last_attribute; // Pointer to last attribute of node, // or 0 if none; this value is only // valid if m_first_attribute is // non-zero xml_node *m_prev_sibling; // Pointer to previous sibling of node, or 0 // if none; this value is only valid if // m_parent is non-zero xml_node *m_next_sibling; // Pointer to next sibling of node, or 0 if // none; this value is only valid if m_parent // is non-zero }; /////////////////////////////////////////////////////////////////////////// // XML document //! This class represents root of the DOM hierarchy. //! It is also an xml_node and a memory_pool through public inheritance. //! Use parse() function to build a DOM tree from a zero-terminated XML text // string. //! parse() function allocates memory for nodes and attributes by using // functions of xml_document, //! which are inherited from memory_pool. //! To access root node of the document, use the document itself, as if it was // an xml_node. //! \param Ch Character type to use. template class xml_document : public xml_node, public memory_pool { public: //! Constructs empty XML document xml_document() : xml_node(node_document) {} //! Parses zero-terminated XML string according to given flags. //! Passed string will be modified by the parser, unless // rapidxml::parse_non_destructive flag is used. //! The string must persist for the lifetime of the document. //! In case of error, rapidxml::parse_error exception will be thrown. //!

//! If you want to parse contents of a file, you must first load the file // into the memory, and pass pointer to its beginning. //! Make sure that data is zero-terminated. //!

//! Document can be parsed into multiple times. //! Each new call to parse removes previous nodes and attributes (if any), // but does not clear memory pool. //! \param text XML data to parse; pointer is non-const to denote fact that // this data may be modified by the parser. template void parse(Ch *text) { assert(text); // Remove current contents this->remove_all_nodes(); this->remove_all_attributes(); // Parse BOM, if any parse_bom(text); // Parse children while (1) { // Skip whitespace before node skip(text); if (*text == 0) break; // Parse and append new child if (*text == Ch('<')) { ++text; // Skip '<' if (xml_node *node = parse_node(text)) this->append_node(node); } else RAPIDXML_PARSE_ERROR("expected <", text); } } //! Clears the document by deleting all nodes and clearing the memory pool. //! All nodes owned by document pool are destroyed. void clear() { this->remove_all_nodes(); this->remove_all_attributes(); memory_pool::clear(); } private: /////////////////////////////////////////////////////////////////////// // Internal character utility functions // Detect whitespace character struct whitespace_pred { static unsigned char test(Ch ch) { return internal::lookup_tables<0>::lookup_whitespace [static_cast(ch)]; } }; // Detect node name character struct node_name_pred { static unsigned char test(Ch ch) { return internal::lookup_tables<0>::lookup_node_name [static_cast(ch)]; } }; // Detect attribute name character struct attribute_name_pred { static unsigned char test(Ch ch) { return internal::lookup_tables<0>::lookup_attribute_name [static_cast(ch)]; } }; // Detect text character (PCDATA) struct text_pred { static unsigned char test(Ch ch) { return internal::lookup_tables<0>::lookup_text [static_cast(ch)]; } }; // Detect text character (PCDATA) that does not require processing struct text_pure_no_ws_pred { static unsigned char test(Ch ch) { return internal::lookup_tables<0>::lookup_text_pure_no_ws [static_cast(ch)]; } }; // Detect text character (PCDATA) that does not require processing struct text_pure_with_ws_pred { static unsigned char test(Ch ch) { return internal::lookup_tables<0>::lookup_text_pure_with_ws [static_cast(ch)]; } }; // Detect attribute value character template struct attribute_value_pred { static unsigned char test(Ch ch) { if (Quote == Ch('\'')) return internal::lookup_tables<0>::lookup_attribute_data_1 [static_cast(ch)]; if (Quote == Ch('\"')) return internal::lookup_tables<0>::lookup_attribute_data_2 [static_cast(ch)]; return 0; // Should never be executed, to avoid warnings on Comeau } }; // Detect attribute value character template struct attribute_value_pure_pred { static unsigned char test(Ch ch) { if (Quote == Ch('\'')) return internal::lookup_tables<0>::lookup_attribute_data_1_pure [static_cast(ch)]; if (Quote == Ch('\"')) return internal::lookup_tables<0>::lookup_attribute_data_2_pure [static_cast(ch)]; return 0; // Should never be executed, to avoid warnings on Comeau } }; // Insert coded character, using UTF8 or 8-bit ASCII template static void insert_coded_character(Ch *&text, unsigned long code) { if (Flags & parse_no_utf8) { // Insert 8-bit ASCII character // Todo: possibly verify that code is less than 256 and use replacement // char otherwise? text[0] = static_cast(code); text += 1; } else { // Insert UTF8 sequence if (code < 0x80) // 1 byte sequence { text[0] = static_cast(code); text += 1; } else if (code < 0x800) // 2 byte sequence { text[1] = static_cast((code | 0x80) & 0xBF); code >>= 6; text[0] = static_cast(code | 0xC0); text += 2; } else if (code < 0x10000) // 3 byte sequence { text[2] = static_cast((code | 0x80) & 0xBF); code >>= 6; text[1] = static_cast((code | 0x80) & 0xBF); code >>= 6; text[0] = static_cast(code | 0xE0); text += 3; } else if (code < 0x110000) // 4 byte sequence { text[3] = static_cast((code | 0x80) & 0xBF); code >>= 6; text[2] = static_cast((code | 0x80) & 0xBF); code >>= 6; text[1] = static_cast((code | 0x80) & 0xBF); code >>= 6; text[0] = static_cast(code | 0xF0); text += 4; } else // Invalid, only codes up to 0x10FFFF are allowed in Unicode { RAPIDXML_PARSE_ERROR("invalid numeric character entity", text); } } } // Skip characters until predicate evaluates to true template static void skip(Ch *&text) { Ch *tmp = text; while (StopPred::test(*tmp)) ++tmp; text = tmp; } // Skip characters until predicate evaluates to true while doing the // following: // - replacing XML character entity references with proper characters // (' & " < > &#...;) // - condensing whitespace sequences to single space character template static Ch *skip_and_expand_character_refs(Ch *&text) { // If entity translation, whitespace condense and whitespace trimming is // disabled, use plain skip if (Flags & parse_no_entity_translation && !(Flags & parse_normalize_whitespace) && !(Flags & parse_trim_whitespace)) { skip(text); return text; } // Use simple skip until first modification is detected skip(text); // Use translation skip Ch *src = text; Ch *dest = src; while (StopPred::test(*src)) { // If entity translation is enabled if (!(Flags & parse_no_entity_translation)) { // Test if replacement is needed if (src[0] == Ch('&')) { switch (src[1]) { // & ' case Ch('a') : if (src[2] == Ch('m') && src[3] == Ch('p') && src[4] == Ch(';')) { *dest = Ch('&'); ++dest; src += 5; continue; } if (src[2] == Ch('p') && src[3] == Ch('o') && src[4] == Ch('s') && src[5] == Ch(';')) { *dest = Ch('\''); ++dest; src += 6; continue; } break; // " case Ch('q') : if (src[2] == Ch('u') && src[3] == Ch('o') && src[4] == Ch('t') && src[5] == Ch(';')) { *dest = Ch('"'); ++dest; src += 6; continue; } break; // > case Ch('g') : if (src[2] == Ch('t') && src[3] == Ch(';')) { *dest = Ch('>'); ++dest; src += 4; continue; } break; // < case Ch('l') : if (src[2] == Ch('t') && src[3] == Ch(';')) { *dest = Ch('<'); ++dest; src += 4; continue; } break; // &#...; - assumes ASCII case Ch('#') : if (src[2] == Ch('x')) { unsigned long code = 0; src += 3; // Skip &#x while (1) { unsigned char digit = internal::lookup_tables<0>::lookup_digits [static_cast(*src)]; if (digit == 0xFF) break; code = code * 16 + digit; ++src; } insert_coded_character(dest, code); // Put character in output } else { unsigned long code = 0; src += 2; // Skip &# while (1) { unsigned char digit = internal::lookup_tables<0>::lookup_digits [static_cast(*src)]; if (digit == 0xFF) break; code = code * 10 + digit; ++src; } insert_coded_character(dest, code); // Put character in output } if (*src == Ch(';')) ++src; else RAPIDXML_PARSE_ERROR("expected ;", src); continue; // Something else default: // Ignore, just copy '&' verbatim break; } } } // If whitespace condensing is enabled if (Flags & parse_normalize_whitespace) { // Test if condensing is needed if (whitespace_pred::test(*src)) { *dest = Ch(' '); ++dest; // Put single space in dest ++src; // Skip first whitespace char // Skip remaining whitespace chars while (whitespace_pred::test(*src)) ++src; continue; } } // No replacement, only copy character *dest++ = *src++; } // Return new end text = src; return dest; } /////////////////////////////////////////////////////////////////////// // Internal parsing functions // Parse BOM, if any template void parse_bom(Ch *&text) { // UTF-8? if (static_cast(text[0]) == 0xEF && static_cast(text[1]) == 0xBB && static_cast(text[2]) == 0xBF) { text += 3; // Skup utf-8 bom } } // Parse XML declaration ( xml_node *parse_xml_declaration(Ch *&text) { // If parsing of declaration is disabled if (!(Flags & parse_declaration_node)) { // Skip until end of declaration while (text[0] != Ch('?') || text[1] != Ch('>')) { if (!text[0]) RAPIDXML_PARSE_ERROR("unexpected end of data", text); ++text; } text += 2; // Skip '?>' return 0; } // Create declaration xml_node *declaration = this->allocate_node(node_declaration); // Skip whitespace before attributes or ?> skip(text); // Parse declaration attributes parse_node_attributes(text, declaration); // Skip ?> if (text[0] != Ch('?') || text[1] != Ch('>')) RAPIDXML_PARSE_ERROR("expected ?>", text); text += 2; return declaration; } // Parse XML comment (' return 0; // Do not produce comment node } // Remember value start Ch *value = text; // Skip until end of comment while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>')) { if (!text[0]) RAPIDXML_PARSE_ERROR("unexpected end of data", text); ++text; } // Create comment node xml_node *comment = this->allocate_node(node_comment); comment->value(value, text - value); // Place zero terminator after comment value if (!(Flags & parse_no_string_terminators)) *text = Ch('\0'); text += 3; // Skip '-->' return comment; } // Parse DOCTYPE template xml_node *parse_doctype(Ch *&text) { // Remember value start Ch *value = text; // Skip to > while (*text != Ch('>')) { // Determine character type switch (*text) { // If '[' encountered, scan for matching ending ']' using naive // algorithm with depth // This works for all W3C test files except for 2 most wicked case Ch('[') : { ++text; // Skip '[' int depth = 1; while (depth > 0) { switch (*text) { case Ch('[') : ++depth; break; case Ch(']') : --depth; break; case 0: RAPIDXML_PARSE_ERROR("unexpected end of data", text); } ++text; } break; } // Error on end of text case Ch('\0') : RAPIDXML_PARSE_ERROR("unexpected end of data", text); // Other character, skip it default: ++text; } } // If DOCTYPE nodes enabled if (Flags & parse_doctype_node) { // Create a new doctype node xml_node *doctype = this->allocate_node(node_doctype); doctype->value(value, text - value); // Place zero terminator after value if (!(Flags & parse_no_string_terminators)) *text = Ch('\0'); text += 1; // skip '>' return doctype; } else { text += 1; // skip '>' return 0; } } // Parse PI template xml_node *parse_pi(Ch *&text) { // If creation of PI nodes is enabled if (Flags & parse_pi_nodes) { // Create pi node xml_node *pi = this->allocate_node(node_pi); // Extract PI target name Ch *name = text; skip(text); if (text == name) RAPIDXML_PARSE_ERROR("expected PI target", text); pi->name(name, text - name); // Skip whitespace between pi target and pi skip(text); // Remember start of pi Ch *value = text; // Skip to '?>' while (text[0] != Ch('?') || text[1] != Ch('>')) { if (*text == Ch('\0')) RAPIDXML_PARSE_ERROR("unexpected end of data", text); ++text; } // Set pi value (verbatim, no entity expansion or whitespace // normalization) pi->value(value, text - value); // Place zero terminator after name and value if (!(Flags & parse_no_string_terminators)) { pi->name()[pi->name_size()] = Ch('\0'); pi->value()[pi->value_size()] = Ch('\0'); } text += 2; // Skip '?>' return pi; } else { // Skip to '?>' while (text[0] != Ch('?') || text[1] != Ch('>')) { if (*text == Ch('\0')) RAPIDXML_PARSE_ERROR("unexpected end of data", text); ++text; } text += 2; // Skip '?>' return 0; } } // Parse and append data // Return character that ends data. // This is necessary because this character might have been overwritten by a // terminating 0 template Ch parse_and_append_data(xml_node *node, Ch *&text, Ch *contents_start) { // Backup to contents start if whitespace trimming is disabled if (!(Flags & parse_trim_whitespace)) text = contents_start; // Skip until end of data Ch *value = text, *end; if (Flags & parse_normalize_whitespace) end = skip_and_expand_character_refs(text); else end = skip_and_expand_character_refs(text); // Trim trailing whitespace if flag is set; leading was already trimmed by // whitespace skip after > if (Flags & parse_trim_whitespace) { if (Flags & parse_normalize_whitespace) { // Whitespace is already condensed to single space characters by // skipping function, so just trim 1 char off the end if (*(end - 1) == Ch(' ')) --end; } else { // Backup until non-whitespace character is found while (whitespace_pred::test(*(end - 1))) --end; } } // If characters are still left between end and value (this test is only // necessary if normalization is enabled) // Create new data node if (!(Flags & parse_no_data_nodes)) { xml_node *data = this->allocate_node(node_data); data->value(value, end - value); node->append_node(data); } // Add data to parent node if no data exists yet if (!(Flags & parse_no_element_values)) if (*node->value() == Ch('\0')) node->value(value, end - value); // Place zero terminator after value if (!(Flags & parse_no_string_terminators)) { Ch ch = *text; *end = Ch('\0'); return ch; // Return character that ends data; this is required because // zero terminator overwritten it } // Return character that ends data return *text; } // Parse CDATA template xml_node *parse_cdata(Ch *&text) { // If CDATA is disabled if (Flags & parse_no_data_nodes) { // Skip until end of cdata while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>')) { if (!text[0]) RAPIDXML_PARSE_ERROR("unexpected end of data", text); ++text; } text += 3; // Skip ]]> return 0; // Do not produce CDATA node } // Skip until end of cdata Ch *value = text; while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>')) { if (!text[0]) RAPIDXML_PARSE_ERROR("unexpected end of data", text); ++text; } // Create new cdata node xml_node *cdata = this->allocate_node(node_cdata); cdata->value(value, text - value); // Place zero terminator after value if (!(Flags & parse_no_string_terminators)) *text = Ch('\0'); text += 3; // Skip ]]> return cdata; } // Parse element node template xml_node *parse_element(Ch *&text) { // Create element node xml_node *element = this->allocate_node(node_element); // Extract element name Ch *name = text; skip(text); if (text == name) RAPIDXML_PARSE_ERROR("expected element name", text); element->name(name, text - name); // Skip whitespace between element name and attributes or > skip(text); // Parse attributes, if any parse_node_attributes(text, element); // Determine ending type if (*text == Ch('>')) { ++text; parse_node_contents(text, element); } else if (*text == Ch('/')) { ++text; if (*text != Ch('>')) RAPIDXML_PARSE_ERROR("expected >", text); ++text; } else RAPIDXML_PARSE_ERROR("expected >", text); // Place zero terminator after name if (!(Flags & parse_no_string_terminators)) element->name()[element->name_size()] = Ch('\0'); // Return parsed element return element; } // Determine node type, and parse it template xml_node *parse_node(Ch *&text) { // Parse proper node type switch (text[0]) { // <... default: // Parse and append element node return parse_element(text); // (text); } else { // Parse PI return parse_pi(text); } // (text); } break; // (text); } break; // (text); } } // switch // Attempt to skip other, unrecognized node types starting with ')) { if (*text == 0) RAPIDXML_PARSE_ERROR("unexpected end of data", text); ++text; } ++text; // Skip '>' return 0; // No node recognized } } // Parse contents of the node - children, data etc. template void parse_node_contents(Ch *&text, xml_node *node) { // For all children and text while (1) { // Skip whitespace between > and node contents Ch *contents_start = text; // Store start of node contents before whitespace is skipped skip(text); Ch next_char = *text; // After data nodes, instead of continuing the loop, control jumps here. // This is because zero termination inside parse_and_append_data() // function // would wreak havoc with the above code. // Also, skipping whitespace after data nodes is unnecessary. after_data_node: // Determine what comes next: node closing, child node, data node, or 0? switch (next_char) { // Node closing or child node case Ch('<') : if (text[1] == Ch('/')) { // Node closing text += 2; // Skip '(text); if (!internal::compare(node->name(), node->name_size(), closing_name, text - closing_name, true)) RAPIDXML_PARSE_ERROR("invalid closing tag name", text); } else { // No validation, just skip name skip(text); } // Skip remaining whitespace after node name skip(text); if (*text != Ch('>')) RAPIDXML_PARSE_ERROR("expected >", text); ++text; // Skip '>' return; // Node closed, finished parsing contents } else { // Child node ++text; // Skip '<' if (xml_node *child = parse_node(text)) node->append_node(child); } break; // End of data - error case Ch('\0') : RAPIDXML_PARSE_ERROR("unexpected end of data", text); // Data node default: next_char = parse_and_append_data(node, text, contents_start); goto after_data_node; // Bypass regular processing after data nodes } } } // Parse XML attributes of the node template void parse_node_attributes(Ch *&text, xml_node *node) { // For all attributes while (attribute_name_pred::test(*text)) { // Extract attribute name Ch *name = text; ++text; // Skip first character of attribute name skip(text); if (text == name) RAPIDXML_PARSE_ERROR("expected attribute name", name); // Create new attribute xml_attribute *attribute = this->allocate_attribute(); attribute->name(name, text - name); node->append_attribute(attribute); // Skip whitespace after attribute name skip(text); // Skip = if (*text != Ch('=')) RAPIDXML_PARSE_ERROR("expected =", text); ++text; // Add terminating zero after name if (!(Flags & parse_no_string_terminators)) attribute->name()[attribute->name_size()] = 0; // Skip whitespace after = skip(text); // Skip quote and remember if it was ' or " Ch quote = *text; if (quote != Ch('\'') && quote != Ch('"')) RAPIDXML_PARSE_ERROR("expected ' or \"", text); ++text; // Extract attribute value and expand char refs in it Ch *value = text, *end; const int AttFlags = Flags & ~parse_normalize_whitespace; // No whitespace normalization // in attributes if (quote == Ch('\'')) end = skip_and_expand_character_refs< attribute_value_pred, attribute_value_pure_pred, AttFlags>(text); else end = skip_and_expand_character_refs, attribute_value_pure_pred, AttFlags>(text); // Set attribute value attribute->value(value, end - value); // Make sure that end quote is present if (*text != quote) RAPIDXML_PARSE_ERROR("expected ' or \"", text); ++text; // Skip quote // Add terminating zero after value if (!(Flags & parse_no_string_terminators)) attribute->value()[attribute->value_size()] = 0; // Skip whitespace after attribute value skip(text); } } }; //! \cond internal namespace internal { // Whitespace (space \n \r \t) template const unsigned char lookup_tables::lookup_whitespace[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 3 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 4 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 5 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 6 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 7 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // A 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // B 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // C 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // D 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // E 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // F }; // Node name (anything but space \n \r \t / > ? \0) template const unsigned char lookup_tables::lookup_node_name[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Text (i.e. PCDATA) (anything but < \0) template const unsigned char lookup_tables::lookup_text[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Text (i.e. PCDATA) that does not require processing when ws normalization // is disabled // (anything but < \0 &) template const unsigned char lookup_tables::lookup_text_pure_no_ws[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Text (i.e. PCDATA) that does not require processing when ws // normalizationis is enabled // (anything but < \0 & space \n \r \t) template const unsigned char lookup_tables::lookup_text_pure_with_ws[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Attribute name (anything but space \n \r \t / < > = ? ! \0) template const unsigned char lookup_tables::lookup_attribute_name[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Attribute data with single quote (anything but ' \0) template const unsigned char lookup_tables::lookup_attribute_data_1[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Attribute data with single quote that does not require processing // (anything but ' \0 &) template const unsigned char lookup_tables::lookup_attribute_data_1_pure[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Attribute data with double quote (anything but " \0) template const unsigned char lookup_tables::lookup_attribute_data_2[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Attribute data with double quote that does not require processing // (anything but " \0 &) template const unsigned char lookup_tables::lookup_attribute_data_2_pure[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F }; // Digits (dec and hex, 255 denotes end of numeric character reference) template const unsigned char lookup_tables::lookup_digits[256] = { // 0 1 2 3 4 5 6 7 8 9 A B C D E F 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 0 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 1 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 2 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255, // 3 255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 4 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 5 255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 6 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 7 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 8 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 9 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // A 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // B 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // C 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // D 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // E 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 // F }; // Upper case conversion template const unsigned char lookup_tables::lookup_upcase[256] = { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A B C D E F 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, // 0 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, // 1 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, // 2 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, // 3 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, // 4 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, // 5 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, // 6 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127, // 7 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, // 8 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, // 9 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, // A 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, // B 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, // C 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, // D 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, // E 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 // F }; } //! \endcond } // Undefine internal macros #undef RAPIDXML_PARSE_ERROR // On MSVC, restore warnings state #ifdef _MSC_VER #pragma warning(pop) #endif #endif cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rapidxml/rapidxml_iterators.hpp000066400000000000000000000056551240331347200305240ustar00rootroot00000000000000#ifndef RAPIDXML_ITERATORS_HPP_INCLUDED #define RAPIDXML_ITERATORS_HPP_INCLUDED // Copyright (C) 2006, 2009 Marcin Kalicinski // Version 1.13 // Revision $DateTime: 2009/05/13 01:46:17 $ //! \file rapidxml_iterators.hpp This file contains rapidxml iterators #include "rapidxml.hpp" namespace rapidxml { //! Iterator of child nodes of xml_node template class node_iterator { public: typedef typename xml_node value_type; typedef typename xml_node &reference; typedef typename xml_node *pointer; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; node_iterator() : m_node(0) {} node_iterator(xml_node *node) : m_node(node->first_node()) {} reference operator*() const { assert(m_node); return *m_node; } pointer operator->() const { assert(m_node); return m_node; } node_iterator &operator++() { assert(m_node); m_node = m_node->next_sibling(); return *this; } node_iterator operator++(int) { node_iterator tmp = *this; ++this; return tmp; } node_iterator &operator--() { assert(m_node && m_node->previous_sibling()); m_node = m_node->previous_sibling(); return *this; } node_iterator operator--(int) { node_iterator tmp = *this; ++this; return tmp; } bool operator==(const node_iterator &rhs) { return m_node == rhs.m_node; } bool operator!=(const node_iterator &rhs) { return m_node != rhs.m_node; } private: xml_node *m_node; }; //! Iterator of child attributes of xml_node template class attribute_iterator { public: typedef typename xml_attribute value_type; typedef typename xml_attribute &reference; typedef typename xml_attribute *pointer; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; attribute_iterator() : m_attribute(0) {} attribute_iterator(xml_node *node) : m_attribute(node->first_attribute()) {} reference operator*() const { assert(m_attribute); return *m_attribute; } pointer operator->() const { assert(m_attribute); return m_attribute; } attribute_iterator &operator++() { assert(m_attribute); m_attribute = m_attribute->next_attribute(); return *this; } attribute_iterator operator++(int) { attribute_iterator tmp = *this; ++this; return tmp; } attribute_iterator &operator--() { assert(m_attribute && m_attribute->previous_attribute()); m_attribute = m_attribute->previous_attribute(); return *this; } attribute_iterator operator--(int) { attribute_iterator tmp = *this; ++this; return tmp; } bool operator==(const attribute_iterator &rhs) { return m_attribute == rhs.m_attribute; } bool operator!=(const attribute_iterator &rhs) { return m_attribute != rhs.m_attribute; } private: xml_attribute *m_attribute; }; } #endif cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rapidxml/rapidxml_print.hpp000066400000000000000000000310211240331347200276260ustar00rootroot00000000000000#ifndef RAPIDXML_PRINT_HPP_INCLUDED #define RAPIDXML_PRINT_HPP_INCLUDED // Copyright (C) 2006, 2009 Marcin Kalicinski // Version 1.13 // Revision $DateTime: 2009/05/13 01:46:17 $ //! \file rapidxml_print.hpp This file contains rapidxml printer implementation #include "rapidxml.hpp" // Only include streams if not disabled #ifndef RAPIDXML_NO_STREAMS #include #include #endif namespace rapidxml { /////////////////////////////////////////////////////////////////////// // Printing flags const int print_no_indenting = 0x1; //!< Printer flag instructing the printer // to suppress indenting of XML. See // print() function. /////////////////////////////////////////////////////////////////////// // Internal //! \cond internal namespace internal { /////////////////////////////////////////////////////////////////////////// // Internal character operations // Copy characters from given range to given output iterator template inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out) { while (begin != end) *out++ = *begin++; return out; } // Copy characters from given range to given output iterator and expand // characters into references (< > ' " &) template inline OutIt copy_and_expand_chars(const Ch *begin, const Ch *end, Ch noexpand, OutIt out) { while (begin != end) { if (*begin == noexpand) { *out++ = *begin; // No expansion, copy character } else { switch (*begin) { case Ch('<') : *out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';'); break; case Ch('>') : *out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';'); break; case Ch('\'') : *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';'); break; case Ch('"') : *out++ = Ch('&'); *out++ = Ch('q'); *out++ = Ch('u'); *out++ = Ch('o'); *out++ = Ch('t'); *out++ = Ch(';'); break; case Ch('&') : *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';'); break; default: *out++ = *begin; // No expansion, copy character } } ++begin; // Step to next character } return out; } // Fill given output iterator with repetitions of the same character template inline OutIt fill_chars(OutIt out, int n, Ch ch) { for (int i = 0; i < n; ++i) *out++ = ch; return out; } // Find character template inline bool find_char(const Ch *begin, const Ch *end) { while (begin != end) if (*begin++ == ch) return true; return false; } /////////////////////////////////////////////////////////////////////////// // Internal printing operations // Print node template inline OutIt print_node(OutIt out, const xml_node *node, int flags, int indent) { // Print proper node type switch (node->type()) { // Document case node_document: out = print_children(out, node, flags, indent); break; // Element case node_element: out = print_element_node(out, node, flags, indent); break; // Data case node_data: out = print_data_node(out, node, flags, indent); break; // CDATA case node_cdata: out = print_cdata_node(out, node, flags, indent); break; // Declaration case node_declaration: out = print_declaration_node(out, node, flags, indent); break; // Comment case node_comment: out = print_comment_node(out, node, flags, indent); break; // Doctype case node_doctype: out = print_doctype_node(out, node, flags, indent); break; // Pi case node_pi: out = print_pi_node(out, node, flags, indent); break; // Unknown default: assert(0); break; } // If indenting not disabled, add line break after node if (!(flags & print_no_indenting)) *out = Ch('\n'), ++out; // Return modified iterator return out; } // Print children of the node template inline OutIt print_children(OutIt out, const xml_node *node, int flags, int indent) { for (xml_node *child = node->first_node(); child; child = child->next_sibling()) out = print_node(out, child, flags, indent); return out; } // Print attributes of the node template inline OutIt print_attributes(OutIt out, const xml_node *node, int flags) { for (xml_attribute *attribute = node->first_attribute(); attribute; attribute = attribute->next_attribute()) { if (attribute->name() && attribute->value()) { // Print attribute name *out = Ch(' '), ++out; out = copy_chars(attribute->name(), attribute->name() + attribute->name_size(), out); *out = Ch('='), ++out; // Print attribute value using appropriate quote type if (find_char( attribute->value(), attribute->value() + attribute->value_size())) { *out = Ch('\''), ++out; out = copy_and_expand_chars( attribute->value(), attribute->value() + attribute->value_size(), Ch('"'), out); *out = Ch('\''), ++out; } else { *out = Ch('"'), ++out; out = copy_and_expand_chars( attribute->value(), attribute->value() + attribute->value_size(), Ch('\''), out); *out = Ch('"'), ++out; } } } return out; } // Print data node template inline OutIt print_data_node(OutIt out, const xml_node *node, int flags, int indent) { assert(node->type() == node_data); if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out); return out; } // Print data node template inline OutIt print_cdata_node(OutIt out, const xml_node *node, int flags, int indent) { assert(node->type() == node_cdata); if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); *out = Ch('<'); ++out; *out = Ch('!'); ++out; *out = Ch('['); ++out; *out = Ch('C'); ++out; *out = Ch('D'); ++out; *out = Ch('A'); ++out; *out = Ch('T'); ++out; *out = Ch('A'); ++out; *out = Ch('['); ++out; out = copy_chars(node->value(), node->value() + node->value_size(), out); *out = Ch(']'); ++out; *out = Ch(']'); ++out; *out = Ch('>'); ++out; return out; } // Print element node template inline OutIt print_element_node(OutIt out, const xml_node *node, int flags, int indent) { assert(node->type() == node_element); // Print element name and attributes, if any if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); *out = Ch('<'), ++out; out = copy_chars(node->name(), node->name() + node->name_size(), out); out = print_attributes(out, node, flags); // If node is childless if (node->value_size() == 0 && !node->first_node()) { // Print childless node tag ending *out = Ch('/'), ++out; *out = Ch('>'), ++out; } else { // Print normal node tag ending *out = Ch('>'), ++out; // Test if node contains a single data node only (and no other nodes) xml_node *child = node->first_node(); if (!child) { // If node has no children, only print its value without indenting out = copy_and_expand_chars( node->value(), node->value() + node->value_size(), Ch(0), out); } else if (child->next_sibling() == 0 && child->type() == node_data) { // If node has a sole data child, only print its value without // indenting out = copy_and_expand_chars( child->value(), child->value() + child->value_size(), Ch(0), out); } else { // Print all children with full indenting if (!(flags & print_no_indenting)) *out = Ch('\n'), ++out; out = print_children(out, node, flags, indent + 1); if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); } // Print node end *out = Ch('<'), ++out; *out = Ch('/'), ++out; out = copy_chars(node->name(), node->name() + node->name_size(), out); *out = Ch('>'), ++out; } return out; } // Print declaration node template inline OutIt print_declaration_node(OutIt out, const xml_node *node, int flags, int indent) { // Print declaration start if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); *out = Ch('<'), ++out; *out = Ch('?'), ++out; *out = Ch('x'), ++out; *out = Ch('m'), ++out; *out = Ch('l'), ++out; // Print attributes out = print_attributes(out, node, flags); // Print declaration end *out = Ch('?'), ++out; *out = Ch('>'), ++out; return out; } // Print comment node template inline OutIt print_comment_node(OutIt out, const xml_node *node, int flags, int indent) { assert(node->type() == node_comment); if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); *out = Ch('<'), ++out; *out = Ch('!'), ++out; *out = Ch('-'), ++out; *out = Ch('-'), ++out; out = copy_chars(node->value(), node->value() + node->value_size(), out); *out = Ch('-'), ++out; *out = Ch('-'), ++out; *out = Ch('>'), ++out; return out; } // Print doctype node template inline OutIt print_doctype_node(OutIt out, const xml_node *node, int flags, int indent) { assert(node->type() == node_doctype); if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); *out = Ch('<'), ++out; *out = Ch('!'), ++out; *out = Ch('D'), ++out; *out = Ch('O'), ++out; *out = Ch('C'), ++out; *out = Ch('T'), ++out; *out = Ch('Y'), ++out; *out = Ch('P'), ++out; *out = Ch('E'), ++out; *out = Ch(' '), ++out; out = copy_chars(node->value(), node->value() + node->value_size(), out); *out = Ch('>'), ++out; return out; } // Print pi node template inline OutIt print_pi_node(OutIt out, const xml_node *node, int flags, int indent) { assert(node->type() == node_pi); if (!(flags & print_no_indenting)) out = fill_chars(out, indent, Ch('\t')); *out = Ch('<'), ++out; *out = Ch('?'), ++out; out = copy_chars(node->name(), node->name() + node->name_size(), out); *out = Ch(' '), ++out; out = copy_chars(node->value(), node->value() + node->value_size(), out); *out = Ch('?'), ++out; *out = Ch('>'), ++out; return out; } } //! \endcond /////////////////////////////////////////////////////////////////////////// // Printing //! Prints XML to given output iterator. //! \param out Output iterator to print to. //! \param node Node to be printed. Pass xml_document to print entire // document. //! \param flags Flags controlling how XML is printed. //! \return Output iterator pointing to position immediately after last // character of printed text. template inline OutIt print(OutIt out, const xml_node &node, int flags = 0) { return internal::print_node(out, &node, flags, 0); } #ifndef RAPIDXML_NO_STREAMS //! Prints XML to given output stream. //! \param out Output stream to print to. //! \param node Node to be printed. Pass xml_document to print entire // document. //! \param flags Flags controlling how XML is printed. //! \return Output stream. template inline std::basic_ostream &print(std::basic_ostream &out, const xml_node &node, int flags = 0) { print(std::ostream_iterator(out), node, flags); return out; } //! Prints formatted XML to given output stream. Uses default printing flags. // Use print() function to customize printing process. //! \param out Output stream to print to. //! \param node Node to be printed. //! \return Output stream. template inline std::basic_ostream &operator<<(std::basic_ostream &out, const xml_node &node) { return print(out, node); } #endif } #endif cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rapidxml/rapidxml_utils.hpp000066400000000000000000000053741240331347200276460ustar00rootroot00000000000000#ifndef RAPIDXML_UTILS_HPP_INCLUDED #define RAPIDXML_UTILS_HPP_INCLUDED // Copyright (C) 2006, 2009 Marcin Kalicinski // Version 1.13 // Revision $DateTime: 2009/05/13 01:46:17 $ //! \file rapidxml_utils.hpp This file contains high-level rapidxml utilities // that can be useful //! in certain simple scenarios. They should probably not be used if maximizing // performance is the main objective. #include "rapidxml.hpp" #include #include #include #include namespace rapidxml { //! Represents data loaded from a file template class file { public: //! Loads file into the memory. Data will be automatically destroyed by the // destructor. //! \param filename Filename to load. file(const char *filename) { using namespace std; // Open stream basic_ifstream stream(filename, ios::binary); if (!stream) throw runtime_error(string("cannot open file ") + filename); stream.unsetf(ios::skipws); // Determine stream size stream.seekg(0, ios::end); size_t size = stream.tellg(); stream.seekg(0); // Load data and add terminating 0 m_data.resize(size + 1); stream.read(&m_data.front(), static_cast(size)); m_data[size] = 0; } //! Loads file into the memory. Data will be automatically destroyed by the // destructor //! \param stream Stream to load from file(std::basic_istream &stream) { using namespace std; // Load data and add terminating 0 stream.unsetf(ios::skipws); m_data.assign(istreambuf_iterator(stream), istreambuf_iterator()); if (stream.fail() || stream.bad()) throw runtime_error("error reading stream"); m_data.push_back(0); } //! Gets file data. //! \return Pointer to data of file. Ch *data() { return &m_data.front(); } //! Gets file data. //! \return Pointer to data of file. const Ch *data() const { return &m_data.front(); } //! Gets file data size. //! \return Size of file data, in characters. std::size_t size() const { return m_data.size(); } private: std::vector m_data; // File data }; //! Counts children of node. Time complexity is O(n). //! \return Number of children of node template inline std::size_t count_children(xml_node *node) { xml_node *child = node->first_node(); std::size_t count = 0; while (child) { ++count; child = child->next_sibling(); } return count; } //! Counts attributes of node. Time complexity is O(n). //! \return Number of attributes of node template inline std::size_t count_attributes(xml_node *node) { xml_attribute *attr = node->first_attribute(); std::size_t count = 0; while (attr) { ++count; attr = attr->next_attribute(); } return count; } } #endif cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rss/000077500000000000000000000000001240331347200230535ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rss/main.cpp000066400000000000000000000020611240331347200245020ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include "rss.hpp" #include #include #include int main(int argc, char *argv[]) { using namespace boost::network; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; http::client::request request(argv[1]); request << header("Connection", "close"); http::client::response response = client.get(request); rss::channel channel(response); std::cout << "Channel: " << channel.title() << " (" << channel.description() << ")" << std::endl; BOOST_FOREACH(const rss::item & item, channel) { std::cout << item.title() << " (" << item.author() << ")" << std::endl; } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rss/rss.cpp000066400000000000000000000037771240331347200244040ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include "rss.hpp" #include "../rapidxml/rapidxml.hpp" #include #include namespace boost { namespace network { namespace rss { channel::channel(const http::client::response &response) { std::string response_body = body(response); rapidxml::xml_document<> doc; doc.parse<0>(const_cast(response_body.c_str())); rapidxml::xml_node<> *rss = doc.first_node("rss"); if (!rss) { throw std::runtime_error("Invalid RSS feed."); } rapidxml::xml_node<> *channel = rss->first_node("channel"); if (!channel) { throw std::runtime_error("Invalid RSS channel."); } rapidxml::xml_node<> *title = channel->first_node("title"); if (title) { title_ = title->first_node()->value(); } rapidxml::xml_node<> *description = channel->first_node("description"); if (description) { description_ = description->first_node()->value(); } rapidxml::xml_node<> *link = channel->first_node("link"); if (link) { link_ = link->first_node()->value(); } rapidxml::xml_node<> *author = channel->first_node("author"); if (author) { author_ = author->first_node()->value(); } rapidxml::xml_node<> *item = channel->first_node("item"); while (item) { items_.push_back(rss::item()); rapidxml::xml_node<> *title = item->first_node("title"); if (title) { items_.back().set_title(title->first_node()->value()); } rapidxml::xml_node<> *author = item->first_node("author"); if (author) { items_.back().set_author(author->first_node()->value()); } rapidxml::xml_node<> *description = item->first_node("description"); if (description) { items_.back().set_description(description->first_node()->value()); } item = item->next_sibling(); } } } // namespace rss } // namespace network } // namespace boost cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/rss/rss.hpp000066400000000000000000000034051240331347200243750ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef ___RSS_INC__ #define ___RSS_INC__ #include #include #include namespace boost { namespace network { namespace rss { class item { public: void set_title(const std::string &title) { title_ = title; } std::string title() const { return title_; } void set_author(const std::string &author) { author_ = author; } std::string author() const { return author_; } void set_description(const std::string &description) { description_ = description; } std::string description() const { return description_; } private: std::string title_; std::string author_; std::string description_; }; class channel { public: typedef item value_type; typedef std::vector::iterator iterator; typedef std::vector::const_iterator const_iterator; channel(const http::client::response &response); std::string title() const { return title_; } std::string description() const { return description_; } std::string link() const { return link_; } std::string author() const { return author_; } unsigned int item_count() const { return items_.size(); } iterator begin() { return items_.begin(); } iterator end() { return items_.end(); } const_iterator begin() const { return items_.begin(); } const_iterator end() const { return items_.end(); } private: std::string title_; std::string description_; std::string link_; std::string author_; std::vector items_; }; } // namespace rss } // namespace network } // namespace boost #endif // ___RSS_INC__ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/simple_wget.cpp000066400000000000000000000030151240331347200252660ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2009, 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) //[ simple_wget_main /*` This is a very basic clone of wget. It's missing a lot of features, such as content-type detection, but it does the fundamental things the same. It demonstrates the use the `uri` and the `http::client`. */ #include #include #include #include #include namespace http = boost::network::http; namespace uri = boost::network::uri; namespace { std::string get_filename(const uri::uri &url) { std::string path = uri::path(url); std::size_t index = path.find_last_of('/'); std::string filename = path.substr(index + 1); return filename.empty() ? "index.html" : filename; } } // namespace int main(int argc, char *argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " url" << std::endl; return 1; } http::client client; try { http::client::request request(argv[1]); http::client::response response = client.get(request); std::string filename = get_filename(request.uri()); std::cout << "Saving to: " << filename << std::endl; std::ofstream ofs(filename.c_str()); ofs << static_cast(body(response)) << std::endl; } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } //] cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/trivial_google.cpp000066400000000000000000000010731240331347200257570ustar00rootroot00000000000000// Copyright 2014 Dean Michael Berris // Copyright 2014 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace http = boost::network::http; int main(int, char * []) { http::client client; http::client::request request("https://www.google.com/"); http::client::response response = client.get(request); std::cout << body(response) << std::endl; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/000077500000000000000000000000001240331347200237465ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/000077500000000000000000000000001240331347200257375ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/document.h000066400000000000000000000704631240331347200277400ustar00rootroot00000000000000#ifndef RAPIDJSON_DOCUMENT_H_ #define RAPIDJSON_DOCUMENT_H_ #include "reader.h" #include "internal/strfunc.h" namespace rapidjson { /////////////////////////////////////////////////////////////////////////////// // GenericValue //! Represents a JSON value. Use Value for UTF8 encoding and default allocator. /*! A JSON value can be one of 7 types. This class is a variant type supporting these types. Use the Value if UTF8 and default allocator \tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document) \tparam Allocator Allocator type for allocating memory of object, array and string. */ #pragma pack (push, 4) template > class GenericValue { public: //! Name-value pair in an object. struct Member { GenericValue name; //!< name of member (must be a string) GenericValue value; //!< value of member. }; typedef Encoding EncodingType; //!< Encoding type from template parameter. typedef Allocator AllocatorType; //!< Allocator type from template parameter. typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. typedef Member* MemberIterator; //!< Member iterator for iterating in object. typedef const Member* ConstMemberIterator; //!< Constant member iterator for iterating in object. typedef GenericValue* ValueIterator; //!< Value iterator for iterating in array. typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array. //!@name Constructors and destructor. //@{ //! Default constructor creates a null value. GenericValue() : flags_(kNullFlag) {} //! Copy constructor is not permitted. private: GenericValue(const GenericValue& rhs); public: //! Constructor with JSON value type. /*! This creates a Value of specified type with default content. \param type Type of the value. \note Default content for number is zero. */ GenericValue(Type type) { static const unsigned defaultFlags[7] = { kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kConstStringFlag, kNumberFlag | kIntFlag | kUintFlag | kInt64Flag | kUint64Flag | kDoubleFlag }; RAPIDJSON_ASSERT(type <= kNumberType); flags_ = defaultFlags[type]; memset(&data_, 0, sizeof(data_)); } //! Constructor for boolean value. GenericValue(bool b) : flags_(b ? kTrueFlag : kFalseFlag) {} //! Constructor for int value. GenericValue(int i) : flags_(kNumberIntFlag) { data_.n.i64 = i; if (i >= 0) flags_ |= kUintFlag | kUint64Flag; } //! Constructor for unsigned value. GenericValue(unsigned u) : flags_(kNumberUintFlag) { data_.n.u64 = u; if (!(u & 0x80000000)) flags_ |= kIntFlag | kInt64Flag; } //! Constructor for int64_t value. GenericValue(int64_t i64) : flags_(kNumberInt64Flag) { data_.n.i64 = i64; if (i64 >= 0) { flags_ |= kNumberUint64Flag; if (!(i64 & 0xFFFFFFFF00000000LL)) flags_ |= kUintFlag; if (!(i64 & 0xFFFFFFFF80000000LL)) flags_ |= kIntFlag; } else if (i64 >= -2147483648LL) flags_ |= kIntFlag; } //! Constructor for uint64_t value. GenericValue(uint64_t u64) : flags_(kNumberUint64Flag) { data_.n.u64 = u64; if (!(u64 & 0x8000000000000000L)) flags_ |= kInt64Flag; if (!(u64 & 0xFFFFFFFF00000000L)) flags_ |= kUintFlag; if (!(u64 & 0xFFFFFFFF80000000L)) flags_ |= kIntFlag; } //! Constructor for double value. GenericValue(double d) : flags_(kNumberDoubleFlag) { data_.n.d = d; } //! Constructor for constant string (i.e. do not make a copy of string) GenericValue(const Ch* s, SizeType length) { RAPIDJSON_ASSERT(s != NULL); flags_ = kConstStringFlag; data_.s.str = s; data_.s.length = length; } //! Constructor for constant string (i.e. do not make a copy of string) GenericValue(const Ch* s) { SetStringRaw(s, internal::StrLen(s)); } //! Constructor for copy-string (i.e. do make a copy of string) GenericValue(const Ch* s, SizeType length, Allocator& allocator) { SetStringRaw(s, length, allocator); } //! Constructor for copy-string (i.e. do make a copy of string) GenericValue(const Ch*s, Allocator& allocator) { SetStringRaw(s, internal::StrLen(s), allocator); } //! Destructor. /*! Need to destruct elements of array, members of object, or copy-string. */ ~GenericValue() { if (Allocator::kNeedFree) { // Shortcut by Allocator's trait switch(flags_) { case kArrayFlag: for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v) v->~GenericValue(); Allocator::Free(data_.a.elements); break; case kObjectFlag: for (Member* m = data_.o.members; m != data_.o.members + data_.o.size; ++m) { m->name.~GenericValue(); m->value.~GenericValue(); } Allocator::Free(data_.o.members); break; case kCopyStringFlag: Allocator::Free((void*)data_.s.str); break; } } } //@} //!@name Assignment operators //@{ //! Assignment with move semantics. /*! \param rhs Source of the assignment. It will become a null value after assignment. */ GenericValue& operator=(GenericValue& rhs) { RAPIDJSON_ASSERT(this != &rhs); this->~GenericValue(); memcpy(this, &rhs, sizeof(GenericValue)); rhs.flags_ = kNullFlag; return *this; } //! Assignment with primitive types. /*! \tparam T Either Type, int, unsigned, int64_t, uint64_t, const Ch* \param value The value to be assigned. */ template GenericValue& operator=(T value) { this->~GenericValue(); new (this) GenericValue(value); return *this; } //@} //!@name Type //@{ Type GetType() const { return static_cast(flags_ & kTypeMask); } bool IsNull() const { return flags_ == kNullFlag; } bool IsFalse() const { return flags_ == kFalseFlag; } bool IsTrue() const { return flags_ == kTrueFlag; } bool IsBool() const { return (flags_ & kBoolFlag) != 0; } bool IsObject() const { return flags_ == kObjectFlag; } bool IsArray() const { return flags_ == kArrayFlag; } bool IsNumber() const { return (flags_ & kNumberFlag) != 0; } bool IsInt() const { return (flags_ & kIntFlag) != 0; } bool IsUint() const { return (flags_ & kUintFlag) != 0; } bool IsInt64() const { return (flags_ & kInt64Flag) != 0; } bool IsUint64() const { return (flags_ & kUint64Flag) != 0; } bool IsDouble() const { return (flags_ & kDoubleFlag) != 0; } bool IsString() const { return (flags_ & kStringFlag) != 0; } //@} //!@name Null //@{ GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; } //@} //!@name Bool //@{ bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return flags_ == kTrueFlag; } GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; } //@} //!@name Object //@{ //! Set this value as an empty object. GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; } //! Get the value associated with the object's name. GenericValue& operator[](const Ch* name) { if (Member* member = FindMember(name)) return member->value; else { static GenericValue NullValue; return NullValue; } } const GenericValue& operator[](const Ch* name) const { return const_cast(*this)[name]; } //! Member iterators. ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.members; } ConstMemberIterator MemberEnd() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.members + data_.o.size; } MemberIterator MemberBegin() { RAPIDJSON_ASSERT(IsObject()); return data_.o.members; } MemberIterator MemberEnd() { RAPIDJSON_ASSERT(IsObject()); return data_.o.members + data_.o.size; } //! Check whether a member exists in the object. bool HasMember(const Ch* name) const { return FindMember(name) != 0; } //! Add a member (name-value pair) to the object. /*! \param name A string value as name of member. \param value Value of any type. \param allocator Allocator for reallocating memory. \return The value itself for fluent API. \note The ownership of name and value will be transfered to this object if success. */ GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) { RAPIDJSON_ASSERT(IsObject()); RAPIDJSON_ASSERT(name.IsString()); Object& o = data_.o; if (o.size >= o.capacity) { if (o.capacity == 0) { o.capacity = kDefaultObjectCapacity; o.members = (Member*)allocator.Malloc(o.capacity * sizeof(Member)); } else { SizeType oldCapacity = o.capacity; o.capacity *= 2; o.members = (Member*)allocator.Realloc(o.members, oldCapacity * sizeof(Member), o.capacity * sizeof(Member)); } } o.members[o.size].name = name; o.members[o.size].value = value; o.size++; return *this; } GenericValue& AddMember(const char* name, Allocator& nameAllocator, GenericValue& value, Allocator& allocator) { GenericValue n(name, internal::StrLen(name), nameAllocator); return AddMember(n, value, allocator); } GenericValue& AddMember(const char* name, GenericValue& value, Allocator& allocator) { GenericValue n(name, internal::StrLen(name)); return AddMember(n, value, allocator); } template GenericValue& AddMember(const char* name, T value, Allocator& allocator) { GenericValue n(name, internal::StrLen(name)); GenericValue v(value); return AddMember(n, v, allocator); } //! Remove a member in object by its name. /*! \param name Name of member to be removed. \return Whether the member existed. \note Removing member is implemented by moving the last member. So the ordering of members is changed. */ bool RemoveMember(const Ch* name) { RAPIDJSON_ASSERT(IsObject()); if (Member* m = FindMember(name)) { RAPIDJSON_ASSERT(data_.o.size > 0); RAPIDJSON_ASSERT(data_.o.members != 0); if (data_.o.size > 1) { // Move the last one to this place Member* last = data_.o.members + (data_.o.size - 1); m->name = last->name; m->value = last->value; } else { // Only one left, just destroy m->name.~GenericValue(); m->value.~GenericValue(); } --data_.o.size; return true; } return false; } //@} //!@name Array //@{ //! Set this value as an empty array. GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; } //! Get the number of elements in array. SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; } //! Get the capacity of array. SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; } //! Check whether the array is empty. bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; } //! Remove all elements in the array. /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged. */ void Clear() { RAPIDJSON_ASSERT(IsArray()); for (SizeType i = 0; i < data_.a.size; ++i) data_.a.elements[i].~GenericValue(); data_.a.size = 0; } //! Get an element from array by index. /*! \param index Zero-based index of element. \note \code Value a(kArrayType); a.PushBack(123); int x = a[0].GetInt(); // Error: operator[ is ambiguous, as 0 also mean a null pointer of const char* type. int y = a[SizeType(0)].GetInt(); // Cast to SizeType will work. int z = a[0u].GetInt(); // This works too. \endcode */ GenericValue& operator[](SizeType index) { RAPIDJSON_ASSERT(IsArray()); RAPIDJSON_ASSERT(index < data_.a.size); return data_.a.elements[index]; } const GenericValue& operator[](SizeType index) const { return const_cast(*this)[index]; } //! Element iterator ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements; } ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements + data_.a.size; } ConstValueIterator Begin() const { return const_cast(*this).Begin(); } ConstValueIterator End() const { return const_cast(*this).End(); } //! Request the array to have enough capacity to store elements. /*! \param newCapacity The capacity that the array at least need to have. \param allocator The allocator for allocating memory. It must be the same one use previously. \return The value itself for fluent API. */ GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) { RAPIDJSON_ASSERT(IsArray()); if (newCapacity > data_.a.capacity) { data_.a.elements = (GenericValue*)allocator.Realloc(data_.a.elements, data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue)); data_.a.capacity = newCapacity; } return *this; } //! Append a value at the end of the array. /*! \param value The value to be appended. \param allocator The allocator for allocating memory. It must be the same one use previously. \return The value itself for fluent API. \note The ownership of the value will be transfered to this object if success. \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient. */ GenericValue& PushBack(GenericValue& value, Allocator& allocator) { RAPIDJSON_ASSERT(IsArray()); if (data_.a.size >= data_.a.capacity) Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : data_.a.capacity * 2, allocator); data_.a.elements[data_.a.size++] = value; return *this; } template GenericValue& PushBack(T value, Allocator& allocator) { GenericValue v(value); return PushBack(v, allocator); } //! Remove the last element in the array. GenericValue& PopBack() { RAPIDJSON_ASSERT(IsArray()); RAPIDJSON_ASSERT(!Empty()); data_.a.elements[--data_.a.size].~GenericValue(); return *this; } //@} //!@name Number //@{ int GetInt() const { RAPIDJSON_ASSERT(flags_ & kIntFlag); return data_.n.i; } unsigned GetUint() const { RAPIDJSON_ASSERT(flags_ & kUintFlag); return data_.n.u; } int64_t GetInt64() const { RAPIDJSON_ASSERT(flags_ & kInt64Flag); return data_.n.i64; } int64_t GetUint64() const { RAPIDJSON_ASSERT(flags_ & kInt64Flag); return data_.n.u64; } double GetDouble() const { RAPIDJSON_ASSERT(IsNumber()); if ((flags_ & kDoubleFlag) != 0) return data_.n.d; // exact type, no conversion. if ((flags_ & kIntFlag) != 0) return data_.n.i; // int -> double if ((flags_ & kUintFlag) != 0) return data_.n.u; // unsigned -> double if ((flags_ & kInt64Flag) != 0) return (double)data_.n.i64; // int64_t -> double (may lose precision) RAPIDJSON_ASSERT((flags_ & kUint64Flag) != 0); return (double)data_.n.u64; // uint64_t -> double (may lose precision) } GenericValue& SetInt(int i) { this->~GenericValue(); new (this) GenericValue(i); return *this; } GenericValue& SetUint(unsigned u) { this->~GenericValue(); new (this) GenericValue(u); return *this; } GenericValue& SetInt64(int64_t i64) { this->~GenericValue(); new (this) GenericValue(i64); return *this; } GenericValue& SetUint64(uint64_t u64) { this->~GenericValue(); new (this) GenericValue(u64); return *this; } GenericValue& SetDouble(double d) { this->~GenericValue(); new (this) GenericValue(d); return *this; } //@} //!@name String //@{ const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return data_.s.str; } //! Get the length of string. /*! Since rapidjson permits "\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength(). */ SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return data_.s.length; } //! Set this value as a string without copying source string. /*! This version has better performance with supplied length, and also support string containing null character. \param s source string pointer. \param length The length of source string, excluding the trailing null terminator. \return The value itself for fluent API. */ GenericValue& SetString(const Ch* s, SizeType length) { this->~GenericValue(); SetStringRaw(s, length); return *this; } //! Set this value as a string without copying source string. /*! \param s source string pointer. \return The value itself for fluent API. */ GenericValue& SetString(const Ch* s) { return SetString(s, internal::StrLen(s)); } //! Set this value as a string by copying from source string. /*! This version has better performance with supplied length, and also support string containing null character. \param s source string. \param length The length of source string, excluding the trailing null terminator. \param allocator Allocator for allocating copied buffer. Commonly use document.GetAllocator(). \return The value itself for fluent API. */ GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(s, length, allocator); return *this; } //! Set this value as a string by copying from source string. /*! \param s source string. \param allocator Allocator for allocating copied buffer. Commonly use document.GetAllocator(). \return The value itself for fluent API. */ GenericValue& SetString(const Ch* s, Allocator& allocator) { SetString(s, internal::StrLen(s), allocator); return *this; } //@} //! Generate events of this value to a Handler. /*! This function adopts the GoF visitor pattern. Typical usage is to output this JSON value as JSON text via Writer, which is a Handler. It can also be used to deep clone this value via GenericDocument, which is also a Handler. \tparam Handler type of handler. \param handler An object implementing concept Handler. */ template GenericValue& Accept(Handler& handler) { switch(GetType()) { case kNullType: handler.Null(); break; case kFalseType: handler.Bool(false); break; case kTrueType: handler.Bool(true); break; case kObjectType: handler.StartObject(); for (Member* m = data_.o.members; m != data_.o.members + data_.o.size; ++m) { handler.String(m->name.data_.s.str, m->name.data_.s.length, false); m->value.Accept(handler); } handler.EndObject(data_.o.size); break; case kArrayType: handler.StartArray(); for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v) v->Accept(handler); handler.EndArray(data_.a.size); break; case kStringType: handler.String(data_.s.str, data_.s.length, false); break; case kNumberType: if (IsInt()) handler.Int(data_.n.i); else if (IsUint()) handler.Uint(data_.n.u); else if (IsInt64()) handler.Int64(data_.n.i64); else if (IsUint64()) handler.Uint64(data_.n.i64); else handler.Double(data_.n.d); break; } return *this; } private: template friend class GenericDocument; enum { kBoolFlag = 0x100, kNumberFlag = 0x200, kIntFlag = 0x400, kUintFlag = 0x800, kInt64Flag = 0x1000, kUint64Flag = 0x2000, kDoubleFlag = 0x4000, kStringFlag = 0x100000, kCopyFlag = 0x200000, // Initial flags of different types. kNullFlag = kNullType, kTrueFlag = kTrueType | kBoolFlag, kFalseFlag = kFalseType | kBoolFlag, kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag, kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag, kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag, kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag, kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag, kConstStringFlag = kStringType | kStringFlag, kCopyStringFlag = kStringType | kStringFlag | kCopyFlag, kObjectFlag = kObjectType, kArrayFlag = kArrayType, kTypeMask = 0xFF // bitwise-and with mask of 0xFF can be optimized by compiler }; static const SizeType kDefaultArrayCapacity = 16; static const SizeType kDefaultObjectCapacity = 16; struct String { const Ch* str; SizeType length; unsigned hashcode; //!< reserved }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode // By using proper binary layout, retrieval of different integer types do not need conversions. union Number { #if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN struct { int i; char padding[4]; }; struct { unsigned u; char padding2[4]; }; #else struct { char padding[4]; int i; }; struct { char padding2[4]; unsigned u; }; #endif int64_t i64; uint64_t u64; double d; }; // 8 bytes struct Object { Member* members; SizeType size; SizeType capacity; }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode struct Array { GenericValue* elements; SizeType size; SizeType capacity; }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode union Data { String s; Number n; Object o; Array a; }; // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode //! Find member by name. Member* FindMember(const Ch* name) { RAPIDJSON_ASSERT(name); RAPIDJSON_ASSERT(IsObject()); Object& o = data_.o; for (Member* member = o.members; member != data_.o.members + data_.o.size; ++member) if (name[member->name.data_.s.length] == '\0' && memcmp(member->name.data_.s.str, name, member->name.data_.s.length * sizeof(Ch)) == 0) return member; return 0; } const Member* FindMember(const Ch* name) const { return const_cast(*this).FindMember(name); } // Initialize this value as array with initial data, without calling destructor. void SetArrayRaw(GenericValue* values, SizeType count, Allocator& alloctaor) { flags_ = kArrayFlag; data_.a.elements = (GenericValue*)alloctaor.Malloc(count * sizeof(GenericValue)); memcpy(data_.a.elements, values, count * sizeof(GenericValue)); data_.a.size = data_.a.capacity = count; } //! Initialize this value as object with initial data, without calling destructor. void SetObjectRaw(Member* members, SizeType count, Allocator& alloctaor) { flags_ = kObjectFlag; data_.o.members = (Member*)alloctaor.Malloc(count * sizeof(Member)); memcpy(data_.o.members, members, count * sizeof(Member)); data_.o.size = data_.o.capacity = count; } //! Initialize this value as constant string, without calling destructor. void SetStringRaw(const Ch* s, SizeType length) { RAPIDJSON_ASSERT(s != NULL); flags_ = kConstStringFlag; data_.s.str = s; data_.s.length = length; } //! Initialize this value as copy string with initial data, without calling destructor. void SetStringRaw(const Ch* s, SizeType length, Allocator& allocator) { RAPIDJSON_ASSERT(s != NULL); flags_ = kCopyStringFlag; data_.s.str = (char *)allocator.Malloc(length + 1); data_.s.length = length; memcpy((void*)data_.s.str, s, length); ((char*)data_.s.str)[length] = '\0'; } //! Assignment without calling destructor void RawAssign(GenericValue& rhs) { memcpy(this, &rhs, sizeof(GenericValue)); rhs.flags_ = kNullFlag; } Data data_; unsigned flags_; }; #pragma pack (pop) //! Value with UTF8 encoding. typedef GenericValue > Value; /////////////////////////////////////////////////////////////////////////////// // GenericDocument //! A document for parsing JSON text as DOM. /*! \implements Handler \tparam Encoding encoding for both parsing and string storage. \tparam Alloactor allocator for allocating memory for the DOM, and the stack during parsing. */ template > class GenericDocument : public GenericValue { public: typedef typename Encoding::Ch Ch; //!< Character type derived from Encoding. typedef GenericValue ValueType; //!< Value type of the document. typedef Allocator AllocatorType; //!< Allocator type from template parameter. //! Constructor /*! \param allocator Optional allocator for allocating stack memory. \param stackCapacity Initial capacity of stack in bytes. */ GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(allocator, stackCapacity), parseError_(0), errorOffset_(0) {} //! Parse JSON text from an input stream. /*! \tparam parseFlags Combination of ParseFlag. \param stream Input stream to be parsed. \return The document itself for fluent API. */ template GenericDocument& ParseStream(Stream& stream) { ValueType::SetNull(); // Remove existing root if exist GenericReader reader; if (reader.template Parse(stream, *this)) { RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object this->RawAssign(*stack_.template Pop(1)); parseError_ = 0; errorOffset_ = 0; } else { parseError_ = reader.GetParseError(); errorOffset_ = reader.GetErrorOffset(); ClearStack(); } return *this; } //! Parse JSON text from a mutable string. /*! \tparam parseFlags Combination of ParseFlag. \param str Mutable zero-terminated string to be parsed. \return The document itself for fluent API. */ template GenericDocument& ParseInsitu(Ch* str) { GenericInsituStringStream s(str); return ParseStream(s); } //! Parse JSON text from a read-only string. /*! \tparam parseFlags Combination of ParseFlag (must not contain kParseInsituFlag). \param str Read-only zero-terminated string to be parsed. */ template GenericDocument& Parse(const Ch* str) { RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag)); GenericStringStream s(str); return ParseStream(s); } //! Whether a parse error was occured in the last parsing. bool HasParseError() const { return parseError_ != 0; } //! Get the message of parsing error. const char* GetParseError() const { return parseError_; } //! Get the offset in character of the parsing error. size_t GetErrorOffset() const { return errorOffset_; } //! Get the allocator of this document. Allocator& GetAllocator() { return stack_.GetAllocator(); } //! Get the capacity of stack in bytes. size_t GetStackCapacity() const { return stack_.GetCapacity(); } private: friend class GenericReader; // for Reader to call the following private handler functions // Implementation of Handler void Null() { new (stack_.template Push()) ValueType(); } void Bool(bool b) { new (stack_.template Push()) ValueType(b); } void Int(int i) { new (stack_.template Push()) ValueType(i); } void Uint(unsigned i) { new (stack_.template Push()) ValueType(i); } void Int64(int64_t i) { new (stack_.template Push()) ValueType(i); } void Uint64(uint64_t i) { new (stack_.template Push()) ValueType(i); } void Double(double d) { new (stack_.template Push()) ValueType(d); } void String(const Ch* str, SizeType length, bool copy) { if (copy) new (stack_.template Push()) ValueType(str, length, GetAllocator()); else new (stack_.template Push()) ValueType(str, length); } void StartObject() { new (stack_.template Push()) ValueType(kObjectType); } void EndObject(SizeType memberCount) { typename ValueType::Member* members = stack_.template Pop(memberCount); stack_.template Top()->SetObjectRaw(members, (SizeType)memberCount, GetAllocator()); } void StartArray() { new (stack_.template Push()) ValueType(kArrayType); } void EndArray(SizeType elementCount) { ValueType* elements = stack_.template Pop(elementCount); stack_.template Top()->SetArrayRaw(elements, elementCount, GetAllocator()); } void ClearStack() { if (Allocator::kNeedFree) while (stack_.GetSize() > 0) // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects) (stack_.template Pop(1))->~ValueType(); else stack_.Clear(); } static const size_t kDefaultStackCapacity = 1024; internal::Stack stack_; const char* parseError_; size_t errorOffset_; }; typedef GenericDocument > Document; } // namespace rapidjson #endif // RAPIDJSON_DOCUMENT_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/filestream.h000066400000000000000000000017111240331347200302430ustar00rootroot00000000000000#ifndef RAPIDJSON_FILESTREAM_H_ #define RAPIDJSON_FILESTREAM_H_ #include namespace rapidjson { //! Wrapper of C file stream for input or output. /*! This simple wrapper does not check the validity of the stream. \implements Stream */ class FileStream { public: typedef char Ch; //!< Character type. Only support char. FileStream(FILE* fp) : fp_(fp), count_(0) { Read(); } char Peek() const { return current_; } char Take() { char c = current_; Read(); return c; } size_t Tell() const { return count_; } void Put(char c) { fputc(c, fp_); } // Not implemented char* PutBegin() { return 0; } size_t PutEnd(char*) { return 0; } private: void Read() { RAPIDJSON_ASSERT(fp_ != 0); int c = fgetc(fp_); if (c != EOF) { current_ = (char)c; count_++; } else current_ = '\0'; } FILE* fp_; char current_; size_t count_; }; } // namespace rapidjson #endif // RAPIDJSON_FILESTREAM_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/internal/000077500000000000000000000000001240331347200275535ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/internal/pow10.h000066400000000000000000000116151240331347200306760ustar00rootroot00000000000000#ifndef RAPIDJSON_POW10_ #define RAPIDJSON_POW10_ namespace rapidjson { namespace internal { //! Computes integer powers of 10 in double (10.0^n). /*! This function uses lookup table for fast and accurate results. \param n positive/negative exponent. Must <= 308. \return 10.0^n */ inline double Pow10(int n) { static const double e[] = { // 1e-308...1e308: 617 * 8 bytes = 4936 bytes 1e-308,1e-307,1e-306,1e-305,1e-304,1e-303,1e-302,1e-301,1e-300, 1e-299,1e-298,1e-297,1e-296,1e-295,1e-294,1e-293,1e-292,1e-291,1e-290,1e-289,1e-288,1e-287,1e-286,1e-285,1e-284,1e-283,1e-282,1e-281,1e-280, 1e-279,1e-278,1e-277,1e-276,1e-275,1e-274,1e-273,1e-272,1e-271,1e-270,1e-269,1e-268,1e-267,1e-266,1e-265,1e-264,1e-263,1e-262,1e-261,1e-260, 1e-259,1e-258,1e-257,1e-256,1e-255,1e-254,1e-253,1e-252,1e-251,1e-250,1e-249,1e-248,1e-247,1e-246,1e-245,1e-244,1e-243,1e-242,1e-241,1e-240, 1e-239,1e-238,1e-237,1e-236,1e-235,1e-234,1e-233,1e-232,1e-231,1e-230,1e-229,1e-228,1e-227,1e-226,1e-225,1e-224,1e-223,1e-222,1e-221,1e-220, 1e-219,1e-218,1e-217,1e-216,1e-215,1e-214,1e-213,1e-212,1e-211,1e-210,1e-209,1e-208,1e-207,1e-206,1e-205,1e-204,1e-203,1e-202,1e-201,1e-200, 1e-199,1e-198,1e-197,1e-196,1e-195,1e-194,1e-193,1e-192,1e-191,1e-190,1e-189,1e-188,1e-187,1e-186,1e-185,1e-184,1e-183,1e-182,1e-181,1e-180, 1e-179,1e-178,1e-177,1e-176,1e-175,1e-174,1e-173,1e-172,1e-171,1e-170,1e-169,1e-168,1e-167,1e-166,1e-165,1e-164,1e-163,1e-162,1e-161,1e-160, 1e-159,1e-158,1e-157,1e-156,1e-155,1e-154,1e-153,1e-152,1e-151,1e-150,1e-149,1e-148,1e-147,1e-146,1e-145,1e-144,1e-143,1e-142,1e-141,1e-140, 1e-139,1e-138,1e-137,1e-136,1e-135,1e-134,1e-133,1e-132,1e-131,1e-130,1e-129,1e-128,1e-127,1e-126,1e-125,1e-124,1e-123,1e-122,1e-121,1e-120, 1e-119,1e-118,1e-117,1e-116,1e-115,1e-114,1e-113,1e-112,1e-111,1e-110,1e-109,1e-108,1e-107,1e-106,1e-105,1e-104,1e-103,1e-102,1e-101,1e-100, 1e-99, 1e-98, 1e-97, 1e-96, 1e-95, 1e-94, 1e-93, 1e-92, 1e-91, 1e-90, 1e-89, 1e-88, 1e-87, 1e-86, 1e-85, 1e-84, 1e-83, 1e-82, 1e-81, 1e-80, 1e-79, 1e-78, 1e-77, 1e-76, 1e-75, 1e-74, 1e-73, 1e-72, 1e-71, 1e-70, 1e-69, 1e-68, 1e-67, 1e-66, 1e-65, 1e-64, 1e-63, 1e-62, 1e-61, 1e-60, 1e-59, 1e-58, 1e-57, 1e-56, 1e-55, 1e-54, 1e-53, 1e-52, 1e-51, 1e-50, 1e-49, 1e-48, 1e-47, 1e-46, 1e-45, 1e-44, 1e-43, 1e-42, 1e-41, 1e-40, 1e-39, 1e-38, 1e-37, 1e-36, 1e-35, 1e-34, 1e-33, 1e-32, 1e-31, 1e-30, 1e-29, 1e-28, 1e-27, 1e-26, 1e-25, 1e-24, 1e-23, 1e-22, 1e-21, 1e-20, 1e-19, 1e-18, 1e-17, 1e-16, 1e-15, 1e-14, 1e-13, 1e-12, 1e-11, 1e-10, 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e+0, 1e+1, 1e+2, 1e+3, 1e+4, 1e+5, 1e+6, 1e+7, 1e+8, 1e+9, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40, 1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60, 1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80, 1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100, 1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120, 1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140, 1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160, 1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180, 1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200, 1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220, 1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240, 1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260, 1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280, 1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300, 1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308 }; RAPIDJSON_ASSERT(n <= 308); return n < -308 ? 0.0 : e[n + 308]; } } // namespace internal } // namespace rapidjson #endif // RAPIDJSON_POW10_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/internal/stack.h000066400000000000000000000045131240331347200310340ustar00rootroot00000000000000#ifndef RAPIDJSON_INTERNAL_STACK_H_ #define RAPIDJSON_INTERNAL_STACK_H_ namespace rapidjson { namespace internal { /////////////////////////////////////////////////////////////////////////////// // Stack //! A type-unsafe stack for storing different types of data. /*! \tparam Allocator Allocator for allocating stack memory. */ template class Stack { public: Stack(Allocator* allocator, size_t stack_capacity) : allocator_(allocator), own_allocator_(0), stack_(0), stack_top_(0), stack_end_(0), stack_capacity_(stack_capacity) { RAPIDJSON_ASSERT(stack_capacity_ > 0); if (!allocator_) own_allocator_ = allocator_ = new Allocator(); stack_top_ = stack_ = (char*)allocator_->Malloc(stack_capacity_); stack_end_ = stack_ + stack_capacity_; } ~Stack() { Allocator::Free(stack_); delete own_allocator_; // Only delete if it is owned by the stack } void Clear() { /*stack_top_ = 0;*/ stack_top_ = stack_; } template T* Push(size_t count = 1) { // Expand the stack if needed if (stack_top_ + sizeof(T) * count >= stack_end_) { size_t new_capacity = stack_capacity_ * 2; size_t size = GetSize(); size_t new_size = GetSize() + sizeof(T) * count; if (new_capacity < new_size) new_capacity = new_size; stack_ = (char*)allocator_->Realloc(stack_, stack_capacity_, new_capacity); stack_capacity_ = new_capacity; stack_top_ = stack_ + size; stack_end_ = stack_ + stack_capacity_; } T* ret = (T*)stack_top_; stack_top_ += sizeof(T) * count; return ret; } template T* Pop(size_t count) { RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T)); stack_top_ -= count * sizeof(T); return (T*)stack_top_; } template T* Top() { RAPIDJSON_ASSERT(GetSize() >= sizeof(T)); return (T*)(stack_top_ - sizeof(T)); } template T* Bottom() { return (T*)stack_; } Allocator& GetAllocator() { return *allocator_; } size_t GetSize() const { /*return stack_top_;*/ return stack_top_ - stack_; } size_t GetCapacity() const { return stack_capacity_; } private: Allocator* allocator_; Allocator* own_allocator_; char *stack_; char *stack_top_; char *stack_end_; size_t stack_capacity_; }; } // namespace internal } // namespace rapidjson #endif // RAPIDJSON_STACK_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/internal/strfunc.h000066400000000000000000000012501240331347200314060ustar00rootroot00000000000000#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_ #define RAPIDJSON_INTERNAL_STRFUNC_H_ namespace rapidjson { namespace internal { //! Custom strlen() which works on different character types. /*! \tparam Ch Character type (e.g. char, wchar_t, short) \param s Null-terminated input string. \return Number of characters in the string. \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints. */ template inline SizeType StrLen(const Ch* s) { const Ch* p = s; while (*p != '\0') ++p; return SizeType(p - s); } } // namespace internal } // namespace rapidjson #endif // RAPIDJSON_INTERNAL_STRFUNC_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/prettywriter.h000066400000000000000000000121671240331347200307030ustar00rootroot00000000000000#ifndef RAPIDJSON_PRETTYWRITER_H_ #define RAPIDJSON_PRETTYWRITER_H_ #include "writer.h" namespace rapidjson { //! Writer with indentation and spacing. /*! \tparam Stream Type of ouptut stream. \tparam Encoding Encoding of both source strings and output. \tparam Allocator Type of allocator for allocating memory of stack. */ template, typename Allocator = MemoryPoolAllocator<> > class PrettyWriter : public Writer { public: typedef Writer Base; typedef typename Base::Ch Ch; //! Constructor /*! \param stream Output stream. \param allocator User supplied allocator. If it is null, it will create a private one. \param levelDepth Initial capacity of */ PrettyWriter(Stream& stream, Allocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : Base(stream, allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {} //! Set custom indentation. /*! \param indentChar Character for indentation. Must be whitespace character (' ', '\t', '\n', '\r'). \param indentCharCount Number of indent characters for each indentation level. \note The default indentation is 4 spaces. */ PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) { RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r'); indentChar_ = indentChar; indentCharCount_ = indentCharCount; return *this; } //@name Implementation of Handler. //@{ PrettyWriter& Null() { PrettyPrefix(kNullType); Base::WriteNull(); return *this; } PrettyWriter& Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); Base::WriteBool(b); return *this; } PrettyWriter& Int(int i) { PrettyPrefix(kNumberType); Base::WriteInt(i); return *this; } PrettyWriter& Uint(unsigned u) { PrettyPrefix(kNumberType); Base::WriteUint(u); return *this; } PrettyWriter& Int64(int64_t i64) { PrettyPrefix(kNumberType); Base::WriteInt64(i64); return *this; } PrettyWriter& Uint64(uint64_t u64) { PrettyPrefix(kNumberType); Base::WriteUint64(u64); return *this; } PrettyWriter& Double(double d) { PrettyPrefix(kNumberType); Base::WriteDouble(d); return *this; } PrettyWriter& String(const Ch* str, SizeType length, bool copy = false) { PrettyPrefix(kStringType); Base::WriteString(str, length); return *this; } PrettyWriter& StartObject() { PrettyPrefix(kObjectType); new (Base::level_stack_.template Push()) typename Base::Level(false); Base::WriteStartObject(); return *this; } PrettyWriter& EndObject(SizeType memberCount = 0) { RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); RAPIDJSON_ASSERT(!Base::level_stack_.template Top()->inArray); bool empty = Base::level_stack_.template Pop(1)->valueCount == 0; if (!empty) { Base::stream_.Put('\n'); WriteIndent(); } Base::WriteEndObject(); return *this; } PrettyWriter& StartArray() { PrettyPrefix(kArrayType); new (Base::level_stack_.template Push()) typename Base::Level(true); Base::WriteStartArray(); return *this; } PrettyWriter& EndArray(SizeType memberCount = 0) { RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); RAPIDJSON_ASSERT(Base::level_stack_.template Top()->inArray); bool empty = Base::level_stack_.template Pop(1)->valueCount == 0; if (!empty) { Base::stream_.Put('\n'); WriteIndent(); } Base::WriteEndArray(); return *this; } //@} //! Simpler but slower overload. PrettyWriter& String(const Ch* str) { return String(str, internal::StrLen(str)); } protected: void PrettyPrefix(Type type) { if (Base::level_stack_.GetSize() != 0) { // this value is not at root typename Base::Level* level = Base::level_stack_.template Top(); if (level->inArray) { if (level->valueCount > 0) { Base::stream_.Put(','); // add comma if it is not the first element in array Base::stream_.Put('\n'); } else Base::stream_.Put('\n'); WriteIndent(); } else { // in object if (level->valueCount > 0) { if (level->valueCount % 2 == 0) { Base::stream_.Put(','); Base::stream_.Put('\n'); } else { Base::stream_.Put(':'); Base::stream_.Put(' '); } } else Base::stream_.Put('\n'); if (level->valueCount % 2 == 0) WriteIndent(); } if (!level->inArray && level->valueCount % 2 == 0) RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name level->valueCount++; } else RAPIDJSON_ASSERT(type == kObjectType || type == kArrayType); } void WriteIndent() { size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_; PutN(Base::stream_, indentChar_, count); } Ch indentChar_; unsigned indentCharCount_; }; } // namespace rapidjson #endif // RAPIDJSON_RAPIDJSON_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/rapidjson.h000066400000000000000000000402011240331347200300760ustar00rootroot00000000000000#ifndef RAPIDJSON_RAPIDJSON_H_ #define RAPIDJSON_RAPIDJSON_H_ // Copyright (c) 2011 Milo Yip (miloyip@gmail.com) // Version 0.1 #include // malloc(), realloc(), free() #include // memcpy() /////////////////////////////////////////////////////////////////////////////// // RAPIDJSON_NO_INT64DEFINE // Here defines int64_t and uint64_t types in global namespace. // If user have their own definition, can define RAPIDJSON_NO_INT64DEFINE to disable this. #ifndef RAPIDJSON_NO_INT64DEFINE #ifdef _MSC_VER typedef __int64 int64_t; typedef unsigned __int64 uint64_t; #else #include #endif #endif // RAPIDJSON_NO_INT64TYPEDEF /////////////////////////////////////////////////////////////////////////////// // RAPIDJSON_ENDIAN #define RAPIDJSON_LITTLEENDIAN 0 //!< Little endian machine #define RAPIDJSON_BIGENDIAN 1 //!< Big endian machine //! Endianness of the machine. /*! GCC provided macro for detecting endianness of the target machine. But other compilers may not have this. User can define RAPIDJSON_ENDIAN to either RAPIDJSON_LITTLEENDIAN or RAPIDJSON_BIGENDIAN. */ #ifndef RAPIDJSON_ENDIAN #ifdef __BYTE_ORDER__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN #else #define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN #endif // __BYTE_ORDER__ #else #define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN // Assumes little endian otherwise. #endif #endif // RAPIDJSON_ENDIAN /////////////////////////////////////////////////////////////////////////////// // RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_SIMD // Enable SSE2 optimization. //#define RAPIDJSON_SSE2 // Enable SSE4.2 optimization. //#define RAPIDJSON_SSE42 #if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) #define RAPIDJSON_SIMD #endif /////////////////////////////////////////////////////////////////////////////// // RAPIDJSON_NO_SIZETYPEDEFINE #ifndef RAPIDJSON_NO_SIZETYPEDEFINE namespace rapidjson { //! Use 32-bit array/string indices even for 64-bit platform, instead of using size_t. /*! User may override the SizeType by defining RAPIDJSON_NO_SIZETYPEDEFINE. */ typedef unsigned SizeType; } // namespace rapidjson #endif /////////////////////////////////////////////////////////////////////////////// // RAPIDJSON_ASSERT //! Assertion. /*! By default, rapidjson uses C assert() for assertion. User can override it by defining RAPIDJSON_ASSERT(x) macro. */ #ifndef RAPIDJSON_ASSERT #include #define RAPIDJSON_ASSERT(x) assert(x) #endif // RAPIDJSON_ASSERT namespace rapidjson { /////////////////////////////////////////////////////////////////////////////// // Allocator /*! \class rapidjson::Allocator \brief Concept for allocating, resizing and freeing memory block. Note that Malloc() and Realloc() are non-static but Free() is static. So if an allocator need to support Free(), it needs to put its pointer in the header of memory block. \code concept Allocator { static const bool kNeedFree; //!< Whether this allocator needs to call Free(). // Allocate a memory block. // \param size of the memory block in bytes. // \returns pointer to the memory block. void* Malloc(size_t size); // Resize a memory block. // \param originalPtr The pointer to current memory block. Null pointer is permitted. // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.) // \param newSize the new size in bytes. void* Realloc(void* originalPtr, size_t originalSize, size_t newSize); // Free a memory block. // \param pointer to the memory block. Null pointer is permitted. static void Free(void *ptr); }; \endcode */ /////////////////////////////////////////////////////////////////////////////// // CrtAllocator //! C-runtime library allocator. /*! This class is just wrapper for standard C library memory routines. \implements Allocator */ class CrtAllocator { public: static const bool kNeedFree = true; void* Malloc(size_t size) { return malloc(size); } void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { return realloc(originalPtr, newSize); } static void Free(void *ptr) { free(ptr); } }; /////////////////////////////////////////////////////////////////////////////// // MemoryPoolAllocator //! Default memory allocator used by the parser and DOM. /*! This allocator allocate memory blocks from pre-allocated memory chunks. It does not free memory blocks. And Realloc() only allocate new memory. The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default. User may also supply a buffer as the first chunk. If the user-buffer is full then additional chunks are allocated by BaseAllocator. The user-buffer is not deallocated by this allocator. \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator. \implements Allocator */ template class MemoryPoolAllocator { public: static const bool kNeedFree = false; //!< Tell users that no need to call Free() with this allocator. (concept Allocator) //! Constructor with chunkSize. /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize. \param baseAllocator The allocator for allocating memory chunks. */ MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0) { if (!baseAllocator_) ownBaseAllocator_ = baseAllocator_ = new BaseAllocator(); AddChunk(chunk_capacity_); } //! Constructor with user-supplied buffer. /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size. The user buffer will not be deallocated when this allocator is destructed. \param buffer User supplied buffer. \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader). \param chunkSize The size of memory chunk. The default is kDefaultChunkSize. \param baseAllocator The allocator for allocating memory chunks. */ MemoryPoolAllocator(char *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0) { RAPIDJSON_ASSERT(buffer != 0); RAPIDJSON_ASSERT(size > sizeof(ChunkHeader)); chunkHead_ = (ChunkHeader*)buffer; chunkHead_->capacity = size - sizeof(ChunkHeader); chunkHead_->size = 0; chunkHead_->next = 0; } //! Destructor. /*! This deallocates all memory chunks, excluding the user-supplied buffer. */ ~MemoryPoolAllocator() { Clear(); delete ownBaseAllocator_; } //! Deallocates all memory chunks, excluding the user-supplied buffer. void Clear() { while(chunkHead_ != 0 && chunkHead_ != (ChunkHeader *)userBuffer_) { ChunkHeader* next = chunkHead_->next; baseAllocator_->Free(chunkHead_); chunkHead_ = next; } } //! Computes the total capacity of allocated memory chunks. /*! \return total capacity in bytes. */ size_t Capacity() { size_t capacity = 0; for (ChunkHeader* c = chunkHead_; c != 0; c = c->next) capacity += c->capacity; return capacity; } //! Computes the memory blocks allocated. /*! \return total used bytes. */ size_t Size() { size_t size = 0; for (ChunkHeader* c = chunkHead_; c != 0; c = c->next) size += c->size; return size; } //! Allocates a memory block. (concept Allocator) void* Malloc(size_t size) { if (chunkHead_->size + size > chunkHead_->capacity) AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size); char *buffer = (char *)(chunkHead_ + 1) + chunkHead_->size; chunkHead_->size += size; return buffer; } //! Resizes a memory block (concept Allocator) void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { if (originalPtr == 0) return Malloc(newSize); // Do not shrink if new size is smaller than original if (originalSize >= newSize) return originalPtr; // Simply expand it if it is the last allocation and there is sufficient space if (originalPtr == (char *)(chunkHead_ + 1) + chunkHead_->size - originalSize) { size_t increment = newSize - originalSize; if (chunkHead_->size + increment <= chunkHead_->capacity) { chunkHead_->size += increment; return originalPtr; } } // Realloc process: allocate and copy memory, do not free original buffer. void* newBuffer = Malloc(newSize); RAPIDJSON_ASSERT(newBuffer != 0); // Do not handle out-of-memory explicitly. return memcpy(newBuffer, originalPtr, originalSize); } //! Frees a memory block (concept Allocator) static void Free(void *ptr) {} // Do nothing private: //! Creates a new chunk. /*! \param capacity Capacity of the chunk in bytes. */ void AddChunk(size_t capacity) { ChunkHeader* chunk = (ChunkHeader*)baseAllocator_->Malloc(sizeof(ChunkHeader) + capacity); chunk->capacity = capacity; chunk->size = 0; chunk->next = chunkHead_; chunkHead_ = chunk; } static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity. //! Chunk header for perpending to each chunk. /*! Chunks are stored as a singly linked list. */ struct ChunkHeader { size_t capacity; //!< Capacity of the chunk in bytes (excluding the header itself). size_t size; //!< Current size of allocated memory in bytes. ChunkHeader *next; //!< Next chunk in the linked list. }; ChunkHeader *chunkHead_; //!< Head of the chunk linked-list. Only the head chunk serves allocation. size_t chunk_capacity_; //!< The minimum capacity of chunk when they are allocated. char *userBuffer_; //!< User supplied buffer. BaseAllocator* baseAllocator_; //!< base allocator for allocating memory chunks. BaseAllocator* ownBaseAllocator_; //!< base allocator created by this object. }; /////////////////////////////////////////////////////////////////////////////// // Encoding /*! \class rapidjson::Encoding \brief Concept for encoding of Unicode characters. \code concept Encoding { typename Ch; //! Type of character. //! \brief Encode a Unicode codepoint to a buffer. //! \param buffer pointer to destination buffer to store the result. It should have sufficient size of encoding one character. //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively. //! \returns the pointer to the next character after the encoded data. static Ch* Encode(Ch *buffer, unsigned codepoint); }; \endcode */ /////////////////////////////////////////////////////////////////////////////// // UTF8 //! UTF-8 encoding. /*! http://en.wikipedia.org/wiki/UTF-8 \tparam CharType Type for storing 8-bit UTF-8 data. Default is char. \implements Encoding */ template struct UTF8 { typedef CharType Ch; static Ch* Encode(Ch *buffer, unsigned codepoint) { if (codepoint <= 0x7F) *buffer++ = codepoint & 0xFF; else if (codepoint <= 0x7FF) { *buffer++ = 0xC0 | ((codepoint >> 6) & 0xFF); *buffer++ = 0x80 | ((codepoint & 0x3F)); } else if (codepoint <= 0xFFFF) { *buffer++ = 0xE0 | ((codepoint >> 12) & 0xFF); *buffer++ = 0x80 | ((codepoint >> 6) & 0x3F); *buffer++ = 0x80 | (codepoint & 0x3F); } else { RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); *buffer++ = 0xF0 | ((codepoint >> 18) & 0xFF); *buffer++ = 0x80 | ((codepoint >> 12) & 0x3F); *buffer++ = 0x80 | ((codepoint >> 6) & 0x3F); *buffer++ = 0x80 | (codepoint & 0x3F); } return buffer; } }; /////////////////////////////////////////////////////////////////////////////// // UTF16 //! UTF-16 encoding. /*! http://en.wikipedia.org/wiki/UTF-16 \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead. \implements Encoding */ template struct UTF16 { typedef CharType Ch; static Ch* Encode(Ch* buffer, unsigned codepoint) { if (codepoint <= 0xFFFF) { RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair *buffer++ = codepoint; } else { RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); unsigned v = codepoint - 0x10000; *buffer++ = (v >> 10) + 0xD800; *buffer++ = (v & 0x3FF) + 0xDC00; } return buffer; } }; /////////////////////////////////////////////////////////////////////////////// // UTF32 //! UTF-32 encoding. /*! http://en.wikipedia.org/wiki/UTF-32 \tparam Ch Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead. \implements Encoding */ template struct UTF32 { typedef CharType Ch; static Ch *Encode(Ch* buffer, unsigned codepoint) { RAPIDJSON_ASSERT(codepoint <= 0x10FFFF); *buffer++ = codepoint; return buffer; } }; /////////////////////////////////////////////////////////////////////////////// // Stream /*! \class rapidjson::Stream \brief Concept for reading and writing characters. For read-only stream, no need to implement PutBegin(), Put() and PutEnd(). For write-only stream, only need to implement Put(). \code concept Stream { typename Ch; //!< Character type of the stream. //! Read the current character from stream without moving the read cursor. Ch Peek() const; //! Read the current character from stream and moving the read cursor to next character. Ch Take(); //! Get the current read cursor. //! \return Number of characters read from start. size_t Tell(); //! Begin writing operation at the current read pointer. //! \return The begin writer pointer. Ch* PutBegin(); //! Write a character. void Put(Ch c); //! End the writing operation. //! \param begin The begin write pointer returned by PutBegin(). //! \return Number of characters written. size_t PutEnd(Ch* begin); } \endcode */ //! Put N copies of a character to a stream. template inline void PutN(Stream& stream, Ch c, size_t n) { for (size_t i = 0; i < n; i++) stream.Put(c); } /////////////////////////////////////////////////////////////////////////////// // StringStream //! Read-only string stream. /*! \implements Stream */ template struct GenericStringStream { typedef typename Encoding::Ch Ch; GenericStringStream(const Ch *src) : src_(src), head_(src) {} Ch Peek() const { return *src_; } Ch Take() { return *src_++; } size_t Tell() const { return src_ - head_; } Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; } void Put(Ch c) { RAPIDJSON_ASSERT(false); } size_t PutEnd(Ch* begin) { RAPIDJSON_ASSERT(false); return 0; } const Ch* src_; //!< Current read position. const Ch* head_; //!< Original head of the string. }; typedef GenericStringStream > StringStream; /////////////////////////////////////////////////////////////////////////////// // InsituStringStream //! A read-write string stream. /*! This string stream is particularly designed for in-situ parsing. \implements Stream */ template struct GenericInsituStringStream { typedef typename Encoding::Ch Ch; GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {} // Read Ch Peek() { return *src_; } Ch Take() { return *src_++; } size_t Tell() { return src_ - head_; } // Write Ch* PutBegin() { return dst_ = src_; } void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; } size_t PutEnd(Ch* begin) { return dst_ - begin; } Ch* src_; Ch* dst_; Ch* head_; }; typedef GenericInsituStringStream > InsituStringStream; /////////////////////////////////////////////////////////////////////////////// // Type //! Type of JSON value enum Type { kNullType = 0, //!< null kFalseType = 1, //!< false kTrueType = 2, //!< true kObjectType = 3, //!< object kArrayType = 4, //!< array kStringType = 5, //!< string kNumberType = 6, //!< number }; } // namespace rapidjson #endif // RAPIDJSON_RAPIDJSON_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/reader.h000066400000000000000000000473741240331347200273710ustar00rootroot00000000000000#ifndef RAPIDJSON_READER_H_ #define RAPIDJSON_READER_H_ // Copyright (c) 2011 Milo Yip (miloyip@gmail.com) // Version 0.1 #include "rapidjson.h" #include "internal/pow10.h" #include "internal/stack.h" #include #ifdef RAPIDJSON_SSE42 #include #elif defined(RAPIDJSON_SSE2) #include #endif #ifndef RAPIDJSON_PARSE_ERROR #define RAPIDJSON_PARSE_ERROR(msg, offset) do { parseError_ = msg; errorOffset_ = offset; longjmp(jmpbuf_, 1); } while(false) #endif namespace rapidjson { /////////////////////////////////////////////////////////////////////////////// // ParseFlag //! Combination of parseFlags enum ParseFlag { kParseDefaultFlags = 0, //!< Default parse flags. Non-destructive parsing. Text strings are decoded into allocated buffer. kParseInsituFlag = 1 //!< In-situ(destructive) parsing. }; /////////////////////////////////////////////////////////////////////////////// // Handler /*! \class rapidjson::Handler \brief Concept for receiving events from GenericReader upon parsing. \code concept Handler { typename Ch; void Null(); void Bool(bool b); void Int(int i); void Uint(unsigned i); void Int64(int64_t i); void Uint64(uint64_t i); void Double(double d); void String(const Ch* str, SizeType length, bool copy); void StartObject(); void EndObject(SizeType memberCount); void StartArray(); void EndArray(SizeType elementCount); }; \endcode */ /////////////////////////////////////////////////////////////////////////////// // BaseReaderHandler //! Default implementation of Handler. /*! This can be used as base class of any reader handler. \implements Handler */ template > struct BaseReaderHandler { typedef typename Encoding::Ch Ch; void Default() {} void Null() { Default(); } void Bool(bool b) { Default(); } void Int(int i) { Default(); } void Uint(unsigned i) { Default(); } void Int64(int64_t i) { Default(); } void Uint64(uint64_t i) { Default(); } void Double(double d) { Default(); } void String(const Ch* str, SizeType length, bool copy) { Default(); } void StartObject() { Default(); } void EndObject(SizeType memberCount) { Default(); } void StartArray() { Default(); } void EndArray(SizeType elementCount) { Default(); } }; /////////////////////////////////////////////////////////////////////////////// // SkipWhitespace //! Skip the JSON white spaces in a stream. /*! \param stream A input stream for skipping white spaces. \note This function has SSE2/SSE4.2 specialization. */ template void SkipWhitespace(Stream& stream) { Stream s = stream; // Use a local copy for optimization while (s.Peek() == ' ' || s.Peek() == '\n' || s.Peek() == '\r' || s.Peek() == '\t') s.Take(); stream = s; } #ifdef RAPIDJSON_SSE42 //! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once. inline const char *SkipWhitespace_SIMD(const char* p) { static const char whitespace[16] = " \n\r\t"; __m128i w = _mm_loadu_si128((const __m128i *)&whitespace[0]); for (;;) { __m128i s = _mm_loadu_si128((const __m128i *)p); unsigned r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY)); if (r == 0) // all 16 characters are whitespace p += 16; else { // some of characters may be non-whitespace #ifdef _MSC_VER // Find the index of first non-whitespace unsigned long offset; if (_BitScanForward(&offset, r)) return p + offset; #else if (r != 0) return p + __builtin_ffs(r) - 1; #endif } } } #elif defined(RAPIDJSON_SSE2) //! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once. inline const char *SkipWhitespace_SIMD(const char* p) { static const char whitespaces[4][17] = { " ", "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r", "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"}; __m128i w0 = _mm_loadu_si128((const __m128i *)&whitespaces[0][0]); __m128i w1 = _mm_loadu_si128((const __m128i *)&whitespaces[1][0]); __m128i w2 = _mm_loadu_si128((const __m128i *)&whitespaces[2][0]); __m128i w3 = _mm_loadu_si128((const __m128i *)&whitespaces[3][0]); for (;;) { __m128i s = _mm_loadu_si128((const __m128i *)p); __m128i x = _mm_cmpeq_epi8(s, w0); x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1)); x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2)); x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3)); unsigned short r = ~_mm_movemask_epi8(x); if (r == 0) // all 16 characters are whitespace p += 16; else { // some of characters may be non-whitespace #ifdef _MSC_VER // Find the index of first non-whitespace unsigned long offset; if (_BitScanForward(&offset, r)) return p + offset; #else if (r != 0) return p + __builtin_ffs(r) - 1; #endif } } } #endif // RAPIDJSON_SSE2 #ifdef RAPIDJSON_SIMD //! Template function specialization for InsituStringStream template<> inline void SkipWhitespace(InsituStringStream& stream) { stream.src_ = const_cast(SkipWhitespace_SIMD(stream.src_)); } //! Template function specialization for StringStream template<> inline void SkipWhitespace(StringStream& stream) { stream.src_ = SkipWhitespace_SIMD(stream.src_); } #endif // RAPIDJSON_SIMD /////////////////////////////////////////////////////////////////////////////// // GenericReader //! SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator. /*! GenericReader parses JSON text from a stream, and send events synchronously to an object implementing Handler concept. It needs to allocate a stack for storing a single decoded string during non-destructive parsing. For in-situ parsing, the decoded string is directly written to the source text string, no temporary buffer is required. A GenericReader object can be reused for parsing multiple JSON text. \tparam Encoding Encoding of both the stream and the parse output. \tparam Allocator Allocator type for stack. */ template > class GenericReader { public: typedef typename Encoding::Ch Ch; //! Constructor. /*! \param allocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing) \param stackCapacity stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing) */ GenericReader(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(allocator, stackCapacity), parseError_(0), errorOffset_(0) {} //! Parse JSON text. /*! \tparam parseFlags Combination of ParseFlag. \tparam Stream Type of input stream. \tparam Handler Type of handler which must implement Handler concept. \param stream Input stream to be parsed. \param handler The handler to receive events. \return Whether the parsing is successful. */ template bool Parse(Stream& stream, Handler& handler) { parseError_ = 0; errorOffset_ = 0; if (setjmp(jmpbuf_)) { stack_.Clear(); return false; } SkipWhitespace(stream); if (stream.Peek() == '\0') RAPIDJSON_PARSE_ERROR("Text only contains white space(s)", stream.Tell()); else { switch (stream.Peek()) { case '{': ParseObject(stream, handler); break; case '[': ParseArray(stream, handler); break; default: RAPIDJSON_PARSE_ERROR("Expect either an object or array at root", stream.Tell()); return false; } SkipWhitespace(stream); if (stream.Peek() != '\0') RAPIDJSON_PARSE_ERROR("Nothing should follow the root object or array.", stream.Tell()); } return true; } bool HasParseError() const { return parseError_ != 0; } const char* GetParseError() const { return parseError_; } size_t GetErrorOffset() const { return errorOffset_; } private: // Parse object: { string : value, ... } template void ParseObject(Stream& stream, Handler& handler) { RAPIDJSON_ASSERT(stream.Peek() == '{'); stream.Take(); // Skip '{' handler.StartObject(); SkipWhitespace(stream); if (stream.Peek() == '}') { stream.Take(); handler.EndObject(0); // empty object return; } for (SizeType memberCount = 0;;) { if (stream.Peek() != '"') { RAPIDJSON_PARSE_ERROR("Name of an object member must be a string", stream.Tell()); break; } ParseString(stream, handler); SkipWhitespace(stream); if (stream.Take() != ':') { RAPIDJSON_PARSE_ERROR("There must be a colon after the name of object member", stream.Tell()); break; } SkipWhitespace(stream); ParseValue(stream, handler); SkipWhitespace(stream); ++memberCount; switch(stream.Take()) { case ',': SkipWhitespace(stream); break; case '}': handler.EndObject(memberCount); return; default: RAPIDJSON_PARSE_ERROR("Must be a comma or '}' after an object member", stream.Tell()); } } } // Parse array: [ value, ... ] template void ParseArray(Stream& stream, Handler& handler) { RAPIDJSON_ASSERT(stream.Peek() == '['); stream.Take(); // Skip '[' handler.StartArray(); SkipWhitespace(stream); if (stream.Peek() == ']') { stream.Take(); handler.EndArray(0); // empty array return; } for (SizeType elementCount = 0;;) { ParseValue(stream, handler); ++elementCount; SkipWhitespace(stream); switch (stream.Take()) { case ',': SkipWhitespace(stream); break; case ']': handler.EndArray(elementCount); return; default: RAPIDJSON_PARSE_ERROR("Must be a comma or ']' after an array element.", stream.Tell()); } } } template void ParseNull(Stream& stream, Handler& handler) { RAPIDJSON_ASSERT(stream.Peek() == 'n'); stream.Take(); if (stream.Take() == 'u' && stream.Take() == 'l' && stream.Take() == 'l') handler.Null(); else RAPIDJSON_PARSE_ERROR("Invalid value", stream.Tell() - 1); } template void ParseTrue(Stream& stream, Handler& handler) { RAPIDJSON_ASSERT(stream.Peek() == 't'); stream.Take(); if (stream.Take() == 'r' && stream.Take() == 'u' && stream.Take() == 'e') handler.Bool(true); else RAPIDJSON_PARSE_ERROR("Invalid value", stream.Tell()); } template void ParseFalse(Stream& stream, Handler& handler) { RAPIDJSON_ASSERT(stream.Peek() == 'f'); stream.Take(); if (stream.Take() == 'a' && stream.Take() == 'l' && stream.Take() == 's' && stream.Take() == 'e') handler.Bool(false); else RAPIDJSON_PARSE_ERROR("Invalid value", stream.Tell() - 1); } // Helper function to parse four hexidecimal digits in \uXXXX in ParseString(). template unsigned ParseHex4(Stream& stream) { Stream s = stream; // Use a local copy for optimization unsigned codepoint = 0; for (int i = 0; i < 4; i++) { Ch c = s.Take(); codepoint <<= 4; codepoint += c; if (c >= '0' && c <= '9') codepoint -= '0'; else if (c >= 'A' && c <= 'F') codepoint -= 'A' - 10; else if (c >= 'a' && c <= 'f') codepoint -= 'a' - 10; else { RAPIDJSON_PARSE_ERROR("Incorrect hex digit after \\u escape", s.Tell() - 1); return 0; } } stream = s; // Restore stream return codepoint; } // Parse string, handling the prefix and suffix double quotes and escaping. template void ParseString(Stream& stream, Handler& handler) { #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 static const Ch escape[256] = { Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/', Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, 0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0, 0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16 }; #undef Z16 Stream s = stream; // Use a local copy for optimization RAPIDJSON_ASSERT(s.Peek() == '\"'); s.Take(); // Skip '\"' Ch *head; SizeType len; if (parseFlags & kParseInsituFlag) head = s.PutBegin(); else len = 0; #define RAPIDJSON_PUT(x) \ do { \ if (parseFlags & kParseInsituFlag) \ s.Put(x); \ else { \ *stack_.template Push() = x; \ ++len; \ } \ } while(false) for (;;) { Ch c = s.Take(); if (c == '\\') { // Escape Ch e = s.Take(); if ((sizeof(Ch) == 1 || e < 256) && escape[(unsigned char)e]) RAPIDJSON_PUT(escape[(unsigned char)e]); else if (e == 'u') { // Unicode unsigned codepoint = ParseHex4(s); if (codepoint >= 0xD800 && codepoint <= 0xDBFF) { // Handle UTF-16 surrogate pair if (s.Take() != '\\' || s.Take() != 'u') { RAPIDJSON_PARSE_ERROR("Missing the second \\u in surrogate pair", s.Tell() - 2); return; } unsigned codepoint2 = ParseHex4(s); if (codepoint2 < 0xDC00 || codepoint2 > 0xDFFF) { RAPIDJSON_PARSE_ERROR("The second \\u in surrogate pair is invalid", s.Tell() - 2); return; } codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000; } Ch buffer[4]; SizeType count = SizeType(Encoding::Encode(buffer, codepoint) - &buffer[0]); if (parseFlags & kParseInsituFlag) for (SizeType i = 0; i < count; i++) s.Put(buffer[i]); else { memcpy(stack_.template Push(count), buffer, count * sizeof(Ch)); len += count; } } else { RAPIDJSON_PARSE_ERROR("Unknown escape character", stream.Tell() - 1); return; } } else if (c == '"') { // Closing double quote if (parseFlags & kParseInsituFlag) { size_t length = s.PutEnd(head); RAPIDJSON_ASSERT(length <= 0xFFFFFFFF); RAPIDJSON_PUT('\0'); // null-terminate the string handler.String(head, SizeType(length), false); } else { RAPIDJSON_PUT('\0'); handler.String(stack_.template Pop(len), len - 1, true); } stream = s; // restore stream return; } else if (c == '\0') { RAPIDJSON_PARSE_ERROR("lacks ending quotation before the end of string", stream.Tell() - 1); return; } else if ((unsigned)c < 0x20) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF RAPIDJSON_PARSE_ERROR("Incorrect unescaped character in string", stream.Tell() - 1); return; } else RAPIDJSON_PUT(c); // Normal character, just copy } #undef RAPIDJSON_PUT } template void ParseNumber(Stream& stream, Handler& handler) { Stream s = stream; // Local copy for optimization // Parse minus bool minus = false; if (s.Peek() == '-') { minus = true; s.Take(); } // Parse int: zero / ( digit1-9 *DIGIT ) unsigned i; bool try64bit = false; if (s.Peek() == '0') { i = 0; s.Take(); } else if (s.Peek() >= '1' && s.Peek() <= '9') { i = s.Take() - '0'; if (minus) while (s.Peek() >= '0' && s.Peek() <= '9') { if (i >= 214748364) { // 2^31 = 2147483648 if (i != 214748364 || s.Peek() > '8') { try64bit = true; break; } } i = i * 10 + (s.Take() - '0'); } else while (s.Peek() >= '0' && s.Peek() <= '9') { if (i >= 429496729) { // 2^32 - 1 = 4294967295 if (i != 429496729 || s.Peek() > '5') { try64bit = true; break; } } i = i * 10 + (s.Take() - '0'); } } else { RAPIDJSON_PARSE_ERROR("Expect a value here.", stream.Tell()); return; } // Parse 64bit int uint64_t i64; bool useDouble = false; if (try64bit) { i64 = i; if (minus) while (s.Peek() >= '0' && s.Peek() <= '9') { if (i64 >= 922337203685477580uLL) // 2^63 = 9223372036854775808 if (i64 != 922337203685477580uLL || s.Peek() > '8') { useDouble = true; break; } i64 = i64 * 10 + (s.Take() - '0'); } else while (s.Peek() >= '0' && s.Peek() <= '9') { if (i64 >= 1844674407370955161uLL) // 2^64 - 1 = 18446744073709551615 if (i64 != 1844674407370955161uLL || s.Peek() > '5') { useDouble = true; break; } i64 = i64 * 10 + (s.Take() - '0'); } } // Force double for big integer double d; if (useDouble) { d = (double)i64; while (s.Peek() >= '0' && s.Peek() <= '9') { if (d >= 1E307) { RAPIDJSON_PARSE_ERROR("Number too big to store in double", stream.Tell()); return; } d = d * 10 + (s.Take() - '0'); } } // Parse frac = decimal-point 1*DIGIT int expFrac = 0; if (s.Peek() == '.') { if (!useDouble) { d = try64bit ? (double)i64 : (double)i; useDouble = true; } s.Take(); if (s.Peek() >= '0' && s.Peek() <= '9') { d = d * 10 + (s.Take() - '0'); --expFrac; } else { RAPIDJSON_PARSE_ERROR("At least one digit in fraction part", stream.Tell()); return; } while (s.Peek() >= '0' && s.Peek() <= '9') { if (expFrac > -16) { d = d * 10 + (s.Peek() - '0'); --expFrac; } s.Take(); } } // Parse exp = e [ minus / plus ] 1*DIGIT int exp = 0; if (s.Peek() == 'e' || s.Peek() == 'E') { if (!useDouble) { d = try64bit ? (double)i64 : (double)i; useDouble = true; } s.Take(); bool expMinus = false; if (s.Peek() == '+') s.Take(); else if (s.Peek() == '-') { s.Take(); expMinus = true; } if (s.Peek() >= '0' && s.Peek() <= '9') { exp = s.Take() - '0'; while (s.Peek() >= '0' && s.Peek() <= '9') { exp = exp * 10 + (s.Take() - '0'); if (exp > 308) { RAPIDJSON_PARSE_ERROR("Number too big to store in double", stream.Tell()); return; } } } else { RAPIDJSON_PARSE_ERROR("At least one digit in exponent", s.Tell()); return; } if (expMinus) exp = -exp; } // Finish parsing, call event according to the type of number. if (useDouble) { d *= internal::Pow10(exp + expFrac); handler.Double(minus ? -d : d); } else { if (try64bit) { if (minus) handler.Int64(-(int64_t)i64); else handler.Uint64(i64); } else { if (minus) handler.Int(-(int)i); else handler.Uint(i); } } stream = s; // restore stream } // Parse any JSON value template void ParseValue(Stream& stream, Handler& handler) { switch (stream.Peek()) { case 'n': ParseNull (stream, handler); break; case 't': ParseTrue (stream, handler); break; case 'f': ParseFalse (stream, handler); break; case '"': ParseString(stream, handler); break; case '{': ParseObject(stream, handler); break; case '[': ParseArray (stream, handler); break; default : ParseNumber(stream, handler); } } static const size_t kDefaultStackCapacity = 256; //!< Default stack capacity in bytes for storing a single decoded string. internal::Stack stack_; //!< A stack for storing decoded string temporarily during non-destructive parsing. jmp_buf jmpbuf_; //!< setjmp buffer for fast exit from nested parsing function calls. const char* parseError_; size_t errorOffset_; }; // class GenericReader //! Reader with UTF8 encoding and default allocator. typedef GenericReader > Reader; } // namespace rapidjson #endif // RAPIDJSON_READER_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/stringbuffer.h000066400000000000000000000025341240331347200306140ustar00rootroot00000000000000#ifndef RAPIDJSON_STRINGBUFFER_H_ #define RAPIDJSON_STRINGBUFFER_H_ #include "rapidjson.h" #include "internal/stack.h" namespace rapidjson { //! Represents an in-memory output stream. /*! \tparam Encoding Encoding of the stream. \tparam Allocator type for allocating memory buffer. \implements Stream */ template struct GenericStringBuffer { typedef typename Encoding::Ch Ch; GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {} void Put(Ch c) { *stack_.template Push() = c; } void Clear() { stack_.Clear(); } const char* GetString() const { // Push and pop a null terminator. This is safe. *stack_.template Push() = '\0'; stack_.template Pop(1); return stack_.template Bottom(); } size_t Size() const { return stack_.Size(); } static const size_t kDefaultCapacity = 256; mutable internal::Stack stack_; }; typedef GenericStringBuffer > StringBuffer; //! Implement specialized version of PutN() with memset() for better performance. template<> inline void PutN(GenericStringBuffer >& stream, char c, size_t n) { memset(stream.stack_.Push(n), c, n * sizeof(c)); } } // namespace rapidjson #endif // RAPIDJSON_STRINGBUFFER_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/rapidjson/writer.h000066400000000000000000000150061240331347200274260ustar00rootroot00000000000000#ifndef RAPIDJSON_WRITER_H_ #define RAPIDJSON_WRITER_H_ #include "rapidjson.h" #include "internal/stack.h" #include "internal/strfunc.h" #include // snprintf() or _sprintf_s() #include // placement new namespace rapidjson { //! JSON writer /*! Writer implements the concept Handler. It generates JSON text by events to an output stream. User may programmatically calls the functions of a writer to generate JSON text. On the other side, a writer can also be passed to objects that generates events, for example Reader::Parse() and Document::Accept(). \tparam Stream Type of ouptut stream. \tparam Encoding Encoding of both source strings and output. \implements Handler */ template, typename Allocator = MemoryPoolAllocator<> > class Writer { public: typedef typename Encoding::Ch Ch; Writer(Stream& stream, Allocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) : stream_(stream), level_stack_(allocator, levelDepth * sizeof(Level)) {} //@name Implementation of Handler //@{ Writer& Null() { Prefix(kNullType); WriteNull(); return *this; } Writer& Bool(bool b) { Prefix(b ? kTrueType : kFalseType); WriteBool(b); return *this; } Writer& Int(int i) { Prefix(kNumberType); WriteInt(i); return *this; } Writer& Uint(unsigned u) { Prefix(kNumberType); WriteUint(u); return *this; } Writer& Int64(int64_t i64) { Prefix(kNumberType); WriteInt64(i64); return *this; } Writer& Uint64(uint64_t u64) { Prefix(kNumberType); WriteUint64(u64); return *this; } Writer& Double(double d) { Prefix(kNumberType); WriteDouble(d); return *this; } Writer& String(const Ch* str, SizeType length, bool copy = false) { Prefix(kStringType); WriteString(str, length); return *this; } Writer& StartObject() { Prefix(kObjectType); new (level_stack_.template Push()) Level(false); WriteStartObject(); return *this; } Writer& EndObject(SizeType memberCount = 0) { RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); RAPIDJSON_ASSERT(!level_stack_.template Top()->inArray); level_stack_.template Pop(1); WriteEndObject(); return *this; } Writer& StartArray() { Prefix(kArrayType); new (level_stack_.template Push()) Level(true); WriteStartArray(); return *this; } Writer& EndArray(SizeType elementCount = 0) { RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); RAPIDJSON_ASSERT(level_stack_.template Top()->inArray); level_stack_.template Pop(1); WriteEndArray(); return *this; } //@} //! Simpler but slower overload. Writer& String(const Ch* str) { return String(str, internal::StrLen(str)); } protected: //! Information for each nested level struct Level { Level(bool inArray) : inArray(inArray), valueCount(0) {} bool inArray; //!< true if in array, otherwise in object size_t valueCount; //!< number of values in this level }; static const size_t kDefaultLevelDepth = 32; void WriteNull() { stream_.Put('n'); stream_.Put('u'); stream_.Put('l'); stream_.Put('l'); } void WriteBool(bool b) { if (b) { stream_.Put('t'); stream_.Put('r'); stream_.Put('u'); stream_.Put('e'); } else { stream_.Put('f'); stream_.Put('a'); stream_.Put('l'); stream_.Put('s'); stream_.Put('e'); } } void WriteInt(int i) { if (i < 0) { stream_.Put('-'); i = -i; } WriteUint((unsigned)i); } void WriteUint(unsigned u) { char buffer[10]; char *p = buffer; do { *p++ = (u % 10) + '0'; u /= 10; } while (u > 0); do { --p; stream_.Put(*p); } while (p != buffer); } void WriteInt64(int64_t i64) { if (i64 < 0) { stream_.Put('-'); i64 = -i64; } WriteUint64((uint64_t)i64); } void WriteUint64(uint64_t u64) { char buffer[20]; char *p = buffer; do { *p++ = char(u64 % 10) + '0'; u64 /= 10; } while (u64 > 0); do { --p; stream_.Put(*p); } while (p != buffer); } //! \todo Optimization with custom double-to-string converter. void WriteDouble(double d) { char buffer[100]; #if _MSC_VER int ret = sprintf_s(buffer, sizeof(buffer), "%g", d); #else int ret = snprintf(buffer, sizeof(buffer), "%g", d); #endif RAPIDJSON_ASSERT(ret >= 1); for (int i = 0; i < ret; i++) stream_.Put(buffer[i]); } void WriteString(const Ch* str, SizeType length) { static const char hexDigits[] = "0123456789ABCDEF"; static const char escape[256] = { #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 //0 1 2 3 4 5 6 7 8 9 A B C D E F 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10 0, 0, '"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20 Z16, Z16, // 30~4F 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, // 50 Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16 // 60~FF #undef Z16 }; stream_.Put('\"'); for (const Ch* p = str; p != str + length; ++p) { if ((sizeof(Ch) == 1 || *p < 256) && escape[(unsigned char)*p]) { stream_.Put('\\'); stream_.Put(escape[(unsigned char)*p]); if (escape[(unsigned char)*p] == 'u') { stream_.Put('0'); stream_.Put('0'); stream_.Put(hexDigits[(*p) >> 4]); stream_.Put(hexDigits[(*p) & 0xF]); } } else stream_.Put(*p); } stream_.Put('\"'); } void WriteStartObject() { stream_.Put('{'); } void WriteEndObject() { stream_.Put('}'); } void WriteStartArray() { stream_.Put('['); } void WriteEndArray() { stream_.Put(']'); } void Prefix(Type type) { if (level_stack_.GetSize() != 0) { // this value is not at root Level* level = level_stack_.template Top(); if (level->valueCount > 0) { if (level->inArray) stream_.Put(','); // add comma if it is not the first element in array else // in object stream_.Put((level->valueCount % 2 == 0) ? ',' : ':'); } if (!level->inArray && level->valueCount % 2 == 0) RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name level->valueCount++; } else RAPIDJSON_ASSERT(type == kObjectType || type == kArrayType); } Stream& stream_; internal::Stack level_stack_; }; } // namespace rapidjson #endif // RAPIDJSON_RAPIDJSON_H_ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/twitter/search.cpp000066400000000000000000000030111240331347200257120ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011, 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include "rapidjson/rapidjson.h" #include "rapidjson/document.h" #include // This example uses the Twitter Search API. // // https://dev.twitter.com/docs/using-search int main(int argc, char *argv[]) { using namespace boost::network; using namespace rapidjson; if (argc != 2) { std::cout << "Usage: " << argv[0] << " " << std::endl; return 1; } try { http::client client; uri::uri base_uri("http://search.twitter.com/search.json"); std::cout << "Searching Twitter for query: " << argv[1] << std::endl; uri::uri search; search << base_uri << uri::query("q", uri::encoded(argv[1])); http::client::request request(search); http::client::response response = client.get(request); Document d; if (!d.Parse<0>(response.body().c_str()).HasParseError()) { const Value &results = d["results"]; for (SizeType i = 0; i < results.Size(); ++i) { const Value &user = results[i]["from_user_name"]; const Value &text = results[i]["text"]; std::cout << "From: " << user.GetString() << std::endl << " " << text.GetString() << std::endl << std::endl; } } } catch (std::exception &e) { std::cerr << e.what() << std::endl; } return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/example/uri_builder.cpp000066400000000000000000000010331240331347200252520ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include using namespace boost::network; int main(int argc, char *argv[]) { uri::uri url; url << uri::scheme("http") << uri::host("www.github.com") << uri::path("/cpp-netlib"); std::cout << url << std::endl; return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/000077500000000000000000000000001240331347200227715ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/CMakeLists.txt000066400000000000000000000015651240331347200255400ustar00rootroot00000000000000# Copyright 2013 Google, Inc. # Copyright 2010 Dean Michael Berris # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # Commenting this out until it's ready for prime-time later on. # include_directories(${CPP-NETLIB_SOURCE_DIR}) # set(CMAKE_BUILD_TYPE Release) # if (Boost_FOUND) # add_executable(cpp-netlib-utils_base64_experiment utils_base64_experiment.cpp) # target_link_libraries(cpp-netlib-utils_base64_experiment ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) # if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") # target_link_libraries(cpp-netlib-utils_base64_experiment rt) # endif() # set_target_properties(cpp-netlib-utils_base64_experiment # PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/tests) # endif() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/000077500000000000000000000000001240331347200241315ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/base64-standalone.hpp000066400000000000000000000422561240331347200300650ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_BASE64_STANDALONE_HPP #define BOOST_NETWORK_UTILS_BASE64_STANDALONE_HPP #include #include #include #include #include namespace boost { namespace network { namespace utils { // Implements a BASE64 converter working on an iterator range from the // scratch. If the input sequence does not end at the three-byte // boundary, // the last encoded value part is remembered in an encoding state to be // able // to continue with the next chunk; the BASE64 encoding processes the // input // by byte-triplets. // // Summarized interface: // // struct state { // bool empty () const; // void clear(); // } // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output, State & rest) // OutputIterator encode_rest(OutputIterator output, State & rest) // OutputIterator encode(InputRange const & input, OutputIterator output, // State & rest) // OutputIterator encode(char const * value, OutputIterator output, // state & rest) // std::basic_string encode(InputRange const & value, State & rest) // std::basic_string encode(char const * value, state & rest) // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output) // OutputIterator encode(InputRange const & input, OutputIterator output) // OutputIterator encode(char const * value, OutputIterator output) // std::basic_string encode(InputRange const & value) // std::basic_string encode(char const * value) { namespace base64_standalone { namespace detail { // Picks a character from the output alphabet for another 6-bit value // from the input sequence to encode. template char encode_value(Value value) { static char const* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" "+/"; return encoding[static_cast(value)]; } } // namespace detail // Stores the state after processing the last chunk by the encoder. If // the // chunk byte-length is not divisible by three, the last (incomplete) // value // quantum canot be encoded right away; it has to wait for the next // chunk // of octets which will be processed joined (as if the trailing rest // from // the previous one was at its beinning). template struct state { state() : triplet_index(0), last_encoded_value(0) {} state(state const& source) : triplet_index(source.triplet_index), last_encoded_value(source.last_encoded_value) {} bool empty() const { return triplet_index == 0; } void clear() { // indicate that no rest has been left in the last encoded value // and no padding is needed for the encoded output triplet_index = 0; // the last encoded value, which may have been left from the last // encoding step, must be zeroed too; it is important before the // next encoding begins, because it works as a cyclic buffer and // must start empty - with zero last_encoded_value = 0; } unsigned short padding_length() const { // the fewer octets from the triplet processed, the more characters // needed as padding padding - that is why the complement here return triplet_index ? 3 - triplet_index : 0; } protected: // number of the octet in the incomplete quantum, which has been // processed the last time; 0 means that the previous quantum was // complete 3 octets, 1 that just one octet was avalable and 2 that // two octets were available unsigned char triplet_index; // the value made of the previously shifted and or-ed octets which // was not completely split to 6-bit codes, because the last quantum // did not stop on the boundary of three octets Value last_encoded_value; // encoding of an input chunk needs to read and update the state template friend OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest); // finishing the encoding needs to read and clear the state template friend OutputIterator encode_rest(OutputIterator output, State& rest); }; // Encodes an input sequence to BASE64 writing it to the output iterator // and stopping if the last input tree-octet quantum was not complete, // in // which case it stores the state for the later continuation, when // another // input chunk is ready for the encoding. The encoding must be finished // by calling the encode_rest after processing the last chunk. // // std::vector buffer = ...; // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode(buffer.begin(), buffer.end(), appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest) { typedef typename iterator_value::type value_type; // continue with the rest of the last chunk - 2 or 4 bits which // are already shifted to the left and need to be or-ed with the // continuing data up to the target 6 bits value_type encoded_value = rest.last_encoded_value; // if the previous chunk stopped at encoding the first (1) or the // second // (2) octet of the three-byte quantum, jump to the right place, // otherwise start the loop with an empty encoded value buffer switch (rest.triplet_index) { // this loop processes the input sequence of bit-octets by bits, // shifting the current_value (used as a cyclic buffer) left and // or-ing next bits there, while pulling the bit-sextets from the // high word of the current_value for (value_type current_value;;) { case 0: // if the input sequence is empty or reached its end at the // 3-byte boundary, finish with an empty encoding state if (begin == end) { rest.triplet_index = 0; // the last encoded value is not interesting - it would not // be used, because processing of the next chunk will start // at the 3-byte boundary rest.last_encoded_value = 0; return output; } // read the first octet from the current triplet current_value = *begin++; // use just the upper 6 bits to encode it to the target alphabet encoded_value = (current_value & 0xfc) >> 2; *output++ = detail::encode_value(encoded_value); // shift the remaining two bits up to make place for the upoming // part of the next octet encoded_value = (current_value & 0x03) << 4; case 1: // if the input sequence reached its end after the first octet // from the quantum triplet, store the encoding state and finish if (begin == end) { rest.triplet_index = 1; rest.last_encoded_value = encoded_value; return output; } // read the second first octet from the current triplet current_value = *begin++; // combine the upper four bits (as the lower part) with the // previous two bits to encode it to the target alphabet encoded_value |= (current_value & 0xf0) >> 4; *output++ = detail::encode_value(encoded_value); // shift the remaining four bits up to make place for the // upoming // part of the next octet encoded_value = (current_value & 0x0f) << 2; case 2: // if the input sequence reached its end after the second octet // from the quantum triplet, store the encoding state and finish if (begin == end) { rest.triplet_index = 2; rest.last_encoded_value = encoded_value; return output; } // read the third octet from the current triplet current_value = *begin++; // combine the upper two bits (as the lower part) with the // previous four bits to encode it to the target alphabet encoded_value |= (current_value & 0xc0) >> 6; *output++ = detail::encode_value(encoded_value); // encode the remaining 6 bits to the target alphabet encoded_value = current_value & 0x3f; *output++ = detail::encode_value(encoded_value); } } return output; } // Finishes encoding of the previously processed chunks. If their total // byte-length was divisible by three, nothing is needed, if not, the // last // quantum will be encoded as if padded with zeroes, which will be // indicated // by appending '=' characters to the output. This method must be // always // used at the end of encoding, if the previous chunks were encoded by // the // method overload accepting the encoding state. // // std::vector buffer = ...; // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode(buffer.begin(), buffer.end(), appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode_rest(OutputIterator output, State& rest) { if (!rest.empty()) { // process the last part of the trailing octet (either 4 or 2 bits) // as if the input was padded with zeros - without or-ing the next // input value to it; it has been already shifted to the left *output++ = detail::encode_value(rest.last_encoded_value); // at least one padding '=' will be always needed - at least two // bits are missing in the finally encoded 6-bit value *output++ = '='; // if the last octet was the first in the triplet (the index was // 1), four bits are missing in the finally encoded 6-bit value; // another '=' character is needed for the another two bits if (rest.triplet_index < 2) *output++ = '='; // clear the state all the time to make sure that another call to // the encode_rest would not cause damage; the last encoded value, // which may have been left there, must be zeroed too; it is // important before the next encoding begins, because it works as // a cyclic buffer and must start empty - with zero rest.clear(); } return output; } // Encodes a part of an input sequence specified by the pair of begin // and // end iterators.to BASE64 writing it to the output iterator. If its // total // byte-length was not divisible by three, the output will be padded by // the // '=' characters. If you encode an input consisting of mutiple chunks, // use the method overload maintaining the encoding state. // // std::vector buffer = ...; // std::basic_string result; // base64::encode(buffer.begin(), buffer.end(), // std::back_inserter(result)); template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output) { state::type> rest; output = encode(begin, end, output, rest); return encode_rest(output, rest); } // Encodes an entire input sequence to BASE64, which either supports // begin() // and end() methods returning boundaries of the sequence or the // boundaries // can be computed by the Boost::Range, writing it to the output // iterator // and stopping if the last input tree-octet quantum was not complete, // in // which case it stores the state for the later continuation, when // another // input chunk is ready for the encoding. The encoding must be finished // by calling the encode_rest after processing the last chunk. // // Warning: Buffers identified by C-pointers are processed including // their // termination character, if they have any. This is unexpected at least // for the storing literals, which have a specialization here to avoid // it. // // std::vector buffer = ...; // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode(buffer, appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode(InputRange const& input, OutputIterator output, State& rest) { return encode(boost::begin(input), boost::end(input), output, rest); } // Encodes an entire string literal to BASE64, writing it to the output // iterator and stopping if the last input tree-octet quantum was not // complete, in which case it stores the state for the later // continuation, // when another input chunk is ready for the encoding. The encoding // must // be finished by calling the encode_rest after processing the last // chunk. // // The string literal is encoded without processing its terminating zero // character, which is the usual expectation. // // std::basic_string result; // std::back_insert_iterator > appender(result); // base64::state rest; // base64::encode("ab", appender, rest); // ... // base64::encode_rest(appender, rest); template OutputIterator encode(char const* value, OutputIterator output, state& rest) { return encode(value, value + strlen(value), output, rest); } // Encodes an entire input sequence to BASE64 writing it to the output // iterator, which either supports begin() and end() methods returning // boundaries of the sequence or the boundaries can be computed by the // Boost::Range. If its total byte-length was not divisible by three, // the output will be padded by the '=' characters. If you encode an // input consisting of mutiple chunks, use the method overload // maintaining // the encoding state. // // Warning: Buffers identified by C-pointers are processed including // their // termination character, if they have any. This is unexpected at least // for the storing literals, which have a specialization here to avoid // it. // // std::vector buffer = ...; // std::basic_string result; // base64::encode(buffer, std::back_inserter(result)); template OutputIterator encode(InputRange const& value, OutputIterator output) { return encode(boost::begin(value), boost::end(value), output); } // Encodes an entire string literal to BASE64 writing it to the output // iterator. If its total length (without the trailing zero) was not // divisible by three, the output will be padded by the '=' characters. // If you encode an input consisting of mutiple chunks, use the method // overload maintaining the encoding state. // // The string literal is encoded without processing its terminating zero // character, which is the usual expectation. // // std::basic_string result; // base64::encode("ab", std::back_inserter(result)); template OutputIterator encode(char const* value, OutputIterator output) { return encode(value, value + strlen(value), output); } // Encodes an entire input sequence to BASE64 returning the result as // string, which either supports begin() and end() methods returning // boundaries of the sequence or the boundaries can be computed by the // Boost::Range. If its total byte-length was not divisible by three, // the output will be padded by the '=' characters. If you encode an // input consisting of mutiple chunks, use other method maintaining // the encoding state writing to an output iterator. // // Warning: Buffers identified by C-pointers are processed including // their // termination character, if they have any. This is unexpected at least // for the storing literals, which have a specialization here to avoid // it. // // std::vector buffer = ...; // std::basic_string result = base64::encode(buffer); template std::basic_string encode(InputRange const& value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } // Encodes an entire string literal to BASE64 returning the result as // string. If its total byte-length was not divisible by three, the // output will be padded by the '=' characters. If you encode an // input consisting of mutiple chunks, use other method maintaining // the encoding state writing to an output iterator. // // The string literal is encoded without processing its terminating zero // character, which is the usual expectation. // // std::basic_string result = base64::encode("ab"); template std::basic_string encode(char const* value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } // the function overloads for string literals encode the input without // the terminating zero, which is usually expected, because the trailing // zero byte is not considered a part of the string value; the overloads // foran input range would wrap the string literal by Boost.Range and // encodethe full memory occupated by the string literal - including the // unwanted last zero byte } // namespace base64_standalone } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_BASE64_STANDALONE_HPP cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/base64-stateful_buffer.hpp000066400000000000000000000202301240331347200311010ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_BASE64_STATEFUL_BUFFER_HPP #define BOOST_NETWORK_UTILS_BASE64_STATEFUL_BUFFER_HPP #include #include #include #include #include #include #include #include namespace boost { namespace network { namespace utils { // Uses base64_from_binary and transform_width to implement a BASE64 // converter working on an iterator range. Because the transform_width // encodes immediately every input byte, while the BASE64 encoding // processes // the input by byte-triplets, if the input sequence does not end at the // three-byte boundary, the rest is remembered in an encoding state to // be able to continue with the next chunk. It uses an internal buffer // of 4095 input octets to be able to read the input by octet-triplets. // // Summarized interface: // // struct state { // bool empty () const; // void clear(); // } // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output, State & rest) // OutputIterator encode_rest(OutputIterator output, State & rest) // OutputIterator encode(InputRange const & input, OutputIterator output, // State & rest) // OutputIterator encode(char const * value, OutputIterator output, // state & rest) // std::basic_string encode(InputRange const & value, State & rest) // std::basic_string encode(char const * value, state & rest) // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output) // OutputIterator encode(InputRange const & input, OutputIterator output) // OutputIterator encode(char const * value, OutputIterator output) // std::basic_string encode(InputRange const & value) // std::basic_string encode(char const * value) { namespace base64_stateful_buffer { // force using the ostream_iterator from boost::archive to write wide // characters reliably, althoth wchar_t may not be a native character // type using namespace boost::archive::iterators; template struct state { state() : size(0) {} state(state const& source) : data(source.data), size(source.size) {} bool empty() const { return size == 0; } void clear() { size = 0; } private: typedef boost::array data_type; typedef typename data_type::const_iterator const_iterator_type; template void fill(InputIterator begin, InputIterator end) { // make sure that there is always zero padding for the incomplete // triplet; the encode will read three bytes from the vector data.fill(0); size = std::copy(begin, end, data.begin()) - data.begin(); } template OutputIterator write(OutputIterator output) { return std::copy(data.begin(), data.begin() + size, output); } const_iterator_type begin() const { return data.begin(); } const_iterator_type end() const { return data.begin() + size; } data_type data; std::size_t size; template friend OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest); template friend OutputIterator encode_rest(OutputIterator output, State& rest); }; template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest) { typedef typename iterator_value::type value_type; // declare the buffer type for 1365 octet triplets; make sure that the // number is divisible by three if you change it (!) const std::size_t BufferSize = 4095; BOOST_STATIC_ASSERT(BufferSize / 3 * 3 == BufferSize); typedef boost::array buffer_type; // declare the encoding iterator type typedef base64_from_binary > base64_text; if (begin != end) { // declare the buffer, a variable to remmeber its size and the size // which can be encoded (the nearest lower size divisible by three) buffer_type buffer; std::size_t buffer_size = 0, encode_size = 0; // if the previous state contained an incomplete octet triplet, put // it to the start of the buffer to get it prepended to the input if (!rest.empty()) { buffer_size = rest.size; rest.write(buffer.begin()); rest.clear(); } // iterate over the entire input while (begin != end) { // fill the buffer with the input as much as possible while (begin != end && buffer_size < buffer.size()) buffer[buffer_size++] = *begin++; // if the buffer could not be filled completely, compute // the size which can be encoded immediately. encode_size = buffer_size / 3 * 3; if (encode_size > 0) { // encode the buffer part of the size divisible by three base64_text base64_begin(buffer.begin()), base64_end(buffer.begin() + encode_size); output = std::copy(base64_begin, base64_end, output); // zero the buffer size to prepare for the next iteration buffer_size = 0; } } // if the complete buffer could not be encoded, store the last // incomplete octet triplet to the transiting state if (buffer_size > encode_size) rest.fill(buffer.begin() + encode_size, buffer.begin() + buffer_size); } return output; } template OutputIterator encode_rest(OutputIterator output, State& rest) { typedef typename State::const_iterator_type iterator_type; // declare the encoding iterator type typedef base64_from_binary > base64_text; if (!rest.empty()) { // encode the incomplete octet triplet using zeros as padding // (an artificial input continuation) base64_text base64_begin(rest.begin()), base64_end(rest.end()); output = std::copy(base64_begin, base64_end, output); // at least one padding '=' will be always needed - at least two // bits are missing in the finally encoded 6-bit value if (rest.size > 0) { *output++ = '='; // if the last octet was the first in the triplet (the index was, // four bits are missing in the finally encoded 6-bit value; // another '=' character is needed for the another two bits if (rest.size == 1) *output++ = '='; } rest.clear(); } return output; } template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output) { state::type> rest; output = encode(begin, end, output, rest); return encode_rest(output, rest); } template OutputIterator encode(InputRange const& value, OutputIterator output) { return encode(boost::begin(value), boost::end(value), output); } template OutputIterator encode(char const* value, OutputIterator output) { return encode(value, value + strlen(value), output); } template std::basic_string encode(InputRange const& value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } template std::basic_string encode(char const* value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } // the function overloads for string literals encode the input without // the terminating zero, which is usually expected, because the trailing // zero byte is not considered a part of the string value; the overloads // foran input range would wrap the string literal by Boost.Range and // encodethe full memory occupated by the string literal - including the // unwanted last zero byte } // namespace base64_stateful_buffer } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_BASE64_STATEFUL_BUFFER_HPP cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/base64-stateful_iterator.hpp000066400000000000000000000144741240331347200314760ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_BASE64_STATEFUL_ITERATOR_HPP #define BOOST_NETWORK_UTILS_BASE64_STATEFUL_ITERATOR_HPP #include #include "iterators/stateful_transform_width.hpp" #include "iterators/iterator_with_state.hpp" #include #include #include #include #include #include #include namespace boost { namespace network { namespace utils { // Uses base64_from_binary and stateful_transform_width to implement a // BASE64 // converter working on an iterator range. Based on transform_width, the // stateful_transform_width relies on the end iterator and the encoding // state // stored in the transformed iterator; usually by using the iterator // adaptor // - iterator_with_state. Storing the encoding state in the transformed // iterator practically means adapting every such iterator, but the // iterators // which wrap the stateful_transform_width, like the base64_from_binary, // do // not need to be re-declared with an extra constructor to pass the end // iterator and the encoding state to an extended transform_width. // // Summarized interface: // // struct state { // bool empty () const; // void clear(); // unsigned short padding_length() const; // } // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output, State & rest) // OutputIterator encode_rest(OutputIterator output, State & rest) // OutputIterator encode(InputRange const & input, OutputIterator output, // State & rest) // OutputIterator encode(char const * value, OutputIterator output, // state & rest) // std::basic_string encode(InputRange const & value, State & rest) // std::basic_string encode(char const * value, state & rest) // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output) // OutputIterator encode(InputRange const & input, OutputIterator output) // OutputIterator encode(char const * value, OutputIterator output) // std::basic_string encode(InputRange const & value) // std::basic_string encode(char const * value) { namespace base64_stateful_iterator { // force using the ostream_iterator from boost::archive to write wide // characters reliably, althoth wchar_t may not be a native character // type using namespace boost::archive::iterators; using namespace boost::network::utils::iterators; template struct state : public state_for_transform_width { typedef state this_t; typedef state_for_transform_width super_t; state() {} state(this_t const& source) : super_t(source) {} unsigned short padding_length() const { // the BASE64 encoding unit consists of 6 bits; if the 8-bit // input cannot be completely divided to 6-bit chunks, 2 or // 4 bits can remain, which the bit_count returns as displacement // of the 8-bit value (right shift length) - 6 or 4 unsigned short bits = super_t::bit_count(); return bits > 0 ? 6 / bits : 0; } }; template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest) { typedef boost::iterator_with_state stateful_input; // declare the encoding iterator type typedef base64_from_binary > base64_input; // declare the stateful transforming itarators stateful_input stateful_begin(begin, end, rest), stateful_end(end); // declare the iterator to transform the encoded 6-bit units to the // BASE64 alphabet base64_input base64_begin(stateful_begin), base64_end(stateful_end); return std::copy(base64_begin, base64_end, output); } template OutputIterator encode_rest(OutputIterator output, State& rest) { unsigned short padding_length = rest.padding_length(); if (padding_length > 0) { typedef typename State::value_type value_type; // declare the input padding type and the adapted iterator including // the encoding state for it - see below typedef boost::array pillow_input; typedef boost::iterator_with_state stateful_input; // declare the encoding iterator type typedef base64_from_binary > base64_input; // although containing encoding state to continue with the next // chunk, the stateful_transform_width still reads from the input // iterator and needs the complete quantum for the encoding; the // zero padding will make for an artifitial input ending here pillow_input pillow = {{0, 0}}; stateful_input stateful_begin(pillow.begin(), pillow.end(), rest); base64_input base64_begin(stateful_begin); *output++ = *base64_begin; if (padding_length > 0) { *output++ = '='; if (padding_length > 1) *output++ = '='; } } return output; } template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output) { state::type> rest; output = encode(begin, end, output, rest); return encode_rest(output, rest); } template OutputIterator encode(InputRange const& input, OutputIterator output) { return encode(boost::begin(input), boost::end(input), output); } template OutputIterator encode(char const* value, OutputIterator output) { return encode(value, value + strlen(value), output); } template std::basic_string encode(InputRange const& value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } template std::basic_string encode(char const* value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } } // namespace base64_stateful_iterator } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_BASE64_STATEFUL_ITERATOR_HPP cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/base64-stateful_transform.hpp000066400000000000000000000147241240331347200316560ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_BASE64_STATEFUL_TRANSFORM_HPP #define BOOST_NETWORK_UTILS_BASE64_STATEFUL_TRANSFORM_HPP #include "iterators/stateful_base64_from_binary.hpp" #include "iterators/transform_width_with_state.hpp" #include #include #include #include #include #include #include namespace boost { namespace network { namespace utils { // Uses stateful_base64_from_binary and transform_width_with_state to // implement a BASE64 converter working on an iterator range. Based on // transform_width, the transform_width_with_state stores the end iterator // and the encoding state to be able to process the encoding input by // chunks. The stateful_base64_from_binary just passes through the // constructor parameters, which the transform_width_with_state needs. // Storing the encoding state in the transforming iterator makes any // input iterator transformable without adapting, but the iterators which // wrap it, like the base64_from_binary, needs to be re-declared with // the extra constructor. // // Summarized interface: // // struct state { // bool empty () const; // void clear(); // unsigned short padding_length() const; // } // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output, State & rest) // OutputIterator encode_rest(OutputIterator output, State & rest) // OutputIterator encode(InputRange const & input, OutputIterator output, // State & rest) // OutputIterator encode(char const * value, OutputIterator output, // state & rest) // std::basic_string encode(InputRange const & value, State & rest) // std::basic_string encode(char const * value, state & rest) // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output) // OutputIterator encode(InputRange const & input, OutputIterator output) // OutputIterator encode(char const * value, OutputIterator output) // std::basic_string encode(InputRange const & value) // std::basic_string encode(char const * value) { namespace base64_stateful_transform { // force using the ostream_iterator from boost::archive to write wide // characters reliably, althoth wchar_t may not be a native character // type using namespace boost::archive::iterators; using namespace boost::network::utils::iterators; template struct state : public transform_width_state { typedef transform_width_state super_t; state() {} state(state const& source) : super_t(source) {} unsigned short padding_length() const { // the BASE64 encoding unit consists of 6 bits; if the 8-bit // input cannot be completely divided to 6-bit chunks, 2 or // 4 bits can remain, which the bit_count returns as displacement // of the 8-bit value (right shift length) - 6 or 4 unsigned short bits = super_t::bit_count(); return bits > 0 ? 6 / bits : 0; } }; template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output, State& rest) { // declare the transforming iterator type typedef transform_width_with_state stateful_input; // declare the encoding iterator type typedef stateful_base64_from_binary base64_input; base64_input base64_begin(begin, end, rest), base64_end(end); return std::copy(base64_begin, base64_end, output); } template OutputIterator encode_rest(OutputIterator output, State& rest) { unsigned short padding_length = rest.padding_length(); if (padding_length > 0) { typedef typename State::value_type value_type; // declare the input padding type and the adapted iterator including // the encoding state for it - see below typedef boost::array pillow_input; // declare the transforming iterator type typedef transform_width_with_state stateful_input; // declare the encoding iterator type typedef stateful_base64_from_binary base64_input; // although containing encoding state to continue with the next // chunk, the stateful_transform_width still reads from the input // iterator and needs the complete quantum for the encoding; the // zero padding will make for an artifitial input ending here pillow_input pillow = {{0, 0}}; base64_input base64_begin(pillow.begin(), pillow.end(), rest), base64_end(pillow.end()); *output++ = *base64_begin; if (padding_length > 0) { *output++ = '='; if (padding_length > 1) *output++ = '='; } } return output; } template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output) { state::type> rest; output = encode(begin, end, output, rest); return encode_rest(output, rest); } template OutputIterator encode(InputRange const& input, OutputIterator output, State& rest) { return encode(boost::begin(input), boost::end(input), output, rest); } template OutputIterator encode(char const* value, OutputIterator output, state& rest) { return encode(value, value + strlen(value), output, rest); } template OutputIterator encode(InputRange const& input, OutputIterator output) { return encode(boost::begin(input), boost::end(input), output); } template OutputIterator encode(char const* value, OutputIterator output) { return encode(value, value + strlen(value), output); } template std::basic_string encode(InputRange const& value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } template std::basic_string encode(char const* value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } } // namespace base64_stateful_transform } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_BASE64_STATEFUL_TRANSFORM_HPP cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/base64-stateless.hpp000066400000000000000000000066041240331347200277410ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_BASE64_STATELESS_HPP #define BOOST_NETWORK_UTILS_BASE64_STATELESS_HPP #include #include #include #include #include #include #include namespace boost { namespace network { namespace utils { // Uses base64_from_binary and transform_width to implement a BASE64 // converter working on an iterator range. While it is a nice example // of code reuse, the input sequence must either end at the three-byte // boundary or be padded with a zero, otherwise the transforming // iterator tries to read behind the end iterator. // // Summarized interface: // // OutputIterator encode(InputIterator begin, InputIterator end, // OutputIterator output) // OutputIterator encode(InputRange const & input, OutputIterator output) // OutputIterator encode(char const * value, OutputIterator output) // std::basic_string encode(InputRange const & value) // std::basic_string encode(char const * value) namespace base64_stateless { // force using the ostream_iterator from boost::archive to write wide // characters reliably, although wchar_t may not be a native character // type using namespace boost::archive::iterators; template OutputIterator encode(InputIterator begin, InputIterator end, OutputIterator output) { // declare the encoding iterator type typedef base64_from_binary > base64_text; base64_text base64_begin(begin), base64_end(end); // iterate through the input by the encoding iterator one encoded // unit at a time to learn how many units were encoded without // requiring neither the input iterators nor the output ones to be // random access iterators (supporting subtraction end - begin) std::size_t encoded_count = 0; while (base64_begin != base64_end) { *output++ = *base64_begin++; ++encoded_count; } // the encoding iterator advanced so many times as is the encoded // output // size, but the padding is determined by the number of bytes in the // last // (incomplete) input byte-triplet; first compute the input length and // then how many trailing bytes followed the last complete quantum std::size_t incomplete_length = encoded_count * 6 / 8 % 3; if (incomplete_length > 0) { *output++ = '='; if (incomplete_length < 2) *output++ = '='; } return output; } template OutputIterator encode(InputRange const& input, OutputIterator output) { return encode(boost::begin(input), boost::end(input), output); } template OutputIterator encode(char const* value, OutputIterator output) { return encode(value, value + strlen(value), output); } template std::basic_string encode(InputRange const& value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } template std::basic_string encode(char const* value) { std::basic_string result; encode(value, std::back_inserter(result)); return result; } } // namespace base64_stateless } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_BASE64_STATELESS_HPP cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/iterators/000077500000000000000000000000001240331347200261455ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/iterators/iterator_with_state.hpp000066400000000000000000000044061240331347200327460ustar00rootroot00000000000000#ifndef BOOST_ITERATOR_WITH_STATE_HPP #define BOOST_ITERATOR_WITH_STATE_HPP #include #include #include #include #include // The class iterator_with_state adds storing the end iterator and the // transforming state to an existing iterator, so that it can be used as // a base in the transform_width_with_state. namespace boost { template class iterator_with_state; namespace detail { template struct iterator_with_state_base { typedef iterator_adaptor< iterator_with_state, Iterator, use_default, typename mpl::if_< is_convertible::type, random_access_traversal_tag>, bidirectional_traversal_tag, use_default>::type> type; }; } template class iterator_with_state : public detail::iterator_with_state_base::type { typedef typename detail::iterator_with_state_base::type super_t; friend class iterator_core_access; public: iterator_with_state() {} typedef State state_type; iterator_with_state(Iterator x, Iterator end_, State& state_) : super_t(x), m_end(end_), m_state(&state_) {} iterator_with_state(Iterator x) : super_t(x) {} template iterator_with_state( iterator_with_state const& t, typename enable_if_convertible::type* = 0) : super_t(t.base()), m_end(t.end()), m_state(&t.state()) {} Iterator const& end() const { return m_end; } State const& state() const { return *m_state; } State& state() { return *m_state; } private: void increment() { ++this->base_reference(); } void decrement() { --(this->base_reference()); } Iterator m_end; State* m_state; }; template iterator_with_state make_iterator_with_state( Iterator x, Iterator end = Iterator(), State state = State()) { return iterator_with_state(x, end, state); } } // namespace boost #endif // BOOST_ITERATOR_WITH_STATE_HPP stateful_base64_from_binary.hpp000066400000000000000000000044161240331347200341660ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/iterators#ifndef BOOST_NETWORK_UTILS_ITERATORS_STATEFUL_BASE64_FROM_BINARY_HPP #define BOOST_NETWORK_UTILS_ITERATORS_STATEFUL_BASE64_FROM_BINARY_HPP #include #include #include #include #include // The class stateful_base64_from_binary works like base64_from_binary from // boost/archive/iterators, only expecting an iterator base which supports // transformng state and needs the end iterator and the state passed to the // constructor. The transform_width_with_state, for example. namespace boost { namespace network { namespace utils { namespace iterators { namespace detail { template struct from_6_bit { typedef CharType result_type; CharType operator()(CharType t) const { const char* lookup_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz" "0123456789" "+/"; BOOST_ASSERT(t < 64); return lookup_table[static_cast(t)]; } }; } // namespace detail template ::type> class stateful_base64_from_binary : public transform_iterator, Base> { friend class boost::iterator_core_access; typedef transform_iterator, Base> super_t; public: template stateful_base64_from_binary(BOOST_PFTO_WRAPPER(T) start, BOOST_PFTO_WRAPPER(T) end, State& state) : super_t( Base(BOOST_MAKE_PFTO_WRAPPER(static_cast(start)), end, state), detail::from_6_bit()) {} template stateful_base64_from_binary(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast(start))), detail::from_6_bit()) {} // intel 7.1 doesn't like default copy constructor stateful_base64_from_binary(const stateful_base64_from_binary& rhs) : super_t(Base(rhs.base_reference()), detail::from_6_bit()) {} }; } // namespace iterators } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_ITERATORS_STATEFUL_BASE64_FROM_BINARY_HPP cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/iterators/stateful_transform_width.hpp000066400000000000000000000156201240331347200340030ustar00rootroot00000000000000#ifndef BOOST_NETWORK_UTILS_ITERATORS_STATEFUL_TRANSFORM_WIDTH_HPP #define BOOST_NETWORK_UTILS_ITERATORS_STATEFUL_TRANSFORM_WIDTH_HPP #include #include #include #include // The class stateful_transform_width works like transform_width from // boost/archive/iterators if the collection of input values can be converted // to the output without padding the input with zeros. (The total input bit // count is divisible by the bit size of an output value.) It it cannot, the // partially encoded last value, which would have to be padded with zero, // is stored to the state_for_transform_width, which can be used later to // continue the encoding when another chunk of input values is available. // The end iterator is needed to detect the end transformation. // // The encoding state and the end iterator are owned by the input iterator // which has to provide access to them. The iterator adaptor // iterator_with_state is supposed to be used to add this functionality to // existing iterators. namespace boost { namespace network { namespace utils { namespace iterators { template class state_for_transform_width { public: typedef Value value_type; state_for_transform_width() : m_displacement(0) {} state_for_transform_width(state_for_transform_width const &source) : m_displacement(source.m_displacement), m_buffer(source.m_buffer) {} bool empty() const { return bit_count() == 0; } void clear() { m_displacement = 0; } protected: unsigned short bit_count() const { return m_displacement > 0 ? BitsIn - m_displacement : 0; } private: unsigned short m_displacement; value_type m_buffer; template friend class stateful_transform_width; }; template < class Base, int BitsOut, int BitsIn, class Char = typename boost::iterator_value::type // output character > class stateful_transform_width : public boost::iterator_adaptor< stateful_transform_width, Base, Char, single_pass_traversal_tag, Char> { friend class boost::iterator_core_access; typedef typename boost::iterator_adaptor< stateful_transform_width, Base, Char, single_pass_traversal_tag, Char> super_t; typedef stateful_transform_width this_t; typedef typename iterator_value::type base_value_type; Char fill(); Char dereference_impl() { if (!m_full) { m_current_value = fill(); m_full = true; } return m_current_value; } Char dereference() const { return const_cast(this)->dereference_impl(); } bool equal(const this_t &rhs) const { return this->base_reference() == rhs.base_reference(); } void increment() { m_displacement += BitsOut; while (m_displacement >= BitsIn) { m_displacement -= BitsIn; if (0 == m_displacement) m_bufferfull = false; if (!m_bufferfull) ++this->base_reference(); } // detect if the number of bits in the m_buffer is not enough // to encode a full 6-bit unit - read the next byte from the input if (m_displacement >= 0 && BitsIn - m_displacement < BitsOut) { // the following condition is compilable only with this variable typename this_t::base_type const &end_ = this->base_reference().end(); if (this->base_reference() != end_) { // read the next byte from the input or make it zero to // provide padding to encode th elast byte m_next_buffer = ++this->base_reference() != end_ ? *this->base_reference() : 0; m_nextfull = true; } // store the encoding state if we encountered the last byte if (this->base_reference() == end_) { typename Base::state_type &state = this->base_reference().state(); state.m_displacement = m_displacement; state.m_buffer = m_buffer; } } m_full = false; } // the most recent encoded character Char m_current_value; // number of bits left in current input character buffer unsigned int m_displacement; // value to be just encoded and a next value to be encoded base_value_type m_buffer, m_next_buffer; // flag to current output character is ready - just used to save time bool m_full; // flag to indicate that m_buffer and/or m_nextbuffer have data bool m_bufferfull, m_nextfull; public: template stateful_transform_width(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast(start)))), m_displacement(0), m_full(false), m_bufferfull(false), m_nextfull(false) {} stateful_transform_width(const stateful_transform_width &rhs) : super_t(rhs.base_reference()), m_current_value(rhs.m_current_value), m_displacement(rhs.m_displacement), m_buffer(rhs.m_buffer), m_next_buffer(rhs.m_next_buffer), m_full(rhs.m_full), m_bufferfull(rhs.m_bufferfull), m_nextfull(rhs.m_nextfull) {} }; template Char stateful_transform_width::fill() { typename Base::state_type &state = this->base_reference().state(); if (!state.empty()) { // initialize the m_buffer from the state and put the current input // byte to the m_next_buffer to make it follow right after m_displacement = state.m_displacement; m_buffer = state.m_buffer; m_bufferfull = true; m_next_buffer = *this->base_reference(); m_nextfull = true; state.clear(); } Char retval = 0; unsigned int missing_bits = BitsOut; for (;;) { unsigned int bcount; if (!m_bufferfull) { // fill the current m_buffer firstly from m_next_buffer if // available then read the input sequence if (m_nextfull) { m_buffer = m_next_buffer; m_nextfull = false; } else { m_buffer = *this->base_reference(); } m_bufferfull = true; bcount = BitsIn; } else bcount = BitsIn - m_displacement; unsigned int i = (std::min)(bcount, missing_bits); // shift interesting bits to least significant position unsigned int j = m_buffer >> (bcount - i); // strip off uninteresting bits // (note presumption of two's complement arithmetic) j &= ~(-(1 << i)); // append then interesting bits to the output value retval <<= i; retval |= j; missing_bits -= i; if (0 == missing_bits) break; // if we used a byte from the input sequence and not from the // prepared m_next_buffer, advance the input sequence iterator if (!m_nextfull) ++this->base_reference(); m_bufferfull = false; } return retval; } } // namespace iterators } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_ITERATORS_STATEFUL_TRANSFORM_WIDTH_HPP transform_width_with_state.hpp000066400000000000000000000172751240331347200342600ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils/iterators#ifndef BOOST_NETWORK_UTILS_ITERATORS_TRANSFORM_WIDTH_WITH_STATE_HPP #define BOOST_NETWORK_UTILS_ITERATORS_TRANSFORM_WIDTH_WITH_STATE_HPP #include #include #include #include // The class transform_width_with_state works like transform_width from // boost/archive/iterators if the collection of input values can be converted // to the output without padding the input with zeros. (The total input bit // count is divisible by the bit size of an output value.) It it cannot, the // partially encoded last value, which would have to be padded with zero, // is stored to the transform_width_state, which can be used later to // continue the encoding when another chunk of input values is available. // The end iterator is needed to detect the end transformation. // // The encoding state and the end iterator are owned by the transforming // iterator and they have to be passed to its constructor. Iterator adaptors // need to propagate the state and the end iterator to the transforming // iterator's constructor, which is inconvenient. namespace boost { namespace network { namespace utils { namespace iterators { template class transform_width_state { public: typedef Value value_type; transform_width_state() : m_displacement(0) {} transform_width_state(transform_width_state const &source) : m_displacement(source.m_displacement), m_buffer(source.m_buffer) {} bool empty() const { return bit_count() == 0; } void clear() { m_displacement = 0; } protected: unsigned short bit_count() const { return m_displacement > 0 ? BitsIn - m_displacement : 0; } private: unsigned short m_displacement; value_type m_buffer; template friend class transform_width_with_state; }; template ::type, // output character class State = transform_width_state< typename iterator_value::type, BitsOut, BitsIn> > class transform_width_with_state : public boost::iterator_adaptor< transform_width_with_state, Base, Char, single_pass_traversal_tag, Char> { friend class boost::iterator_core_access; typedef typename boost::iterator_adaptor< transform_width_with_state, Base, Char, single_pass_traversal_tag, Char> super_t; typedef transform_width_with_state this_t; typedef typename iterator_value::type base_value_type; Char fill(); Char dereference_impl() { if (!m_full) { m_current_value = fill(); m_full = true; } return m_current_value; } Char dereference() const { return const_cast(this)->dereference_impl(); } bool equal(const this_t &rhs) const { return this->base_reference() == rhs.base_reference(); } void increment() { m_displacement += BitsOut; while (m_displacement >= BitsIn) { m_displacement -= BitsIn; if (0 == m_displacement) m_bufferfull = false; if (!m_bufferfull) ++this->base_reference(); } // detect if the number of bits in the m_buffer is not enough // to encode a full 6-bit unit - read the next byte from the input if (m_displacement >= 0 && BitsIn - m_displacement < BitsOut) { // the following condition is compilable only with this variable typename this_t::base_type const &end_ = this->end(); if (this->base_reference() != end_) { // read the next byte from the input or make it zero to // provide padding to encode th elast byte m_next_buffer = ++this->base_reference() != end_ ? *this->base_reference() : 0; m_nextfull = true; } // store the encoding state if we encountered the last byte if (this->base_reference() == end_) { State &state = this->state(); state.m_displacement = m_displacement; state.m_buffer = m_buffer; } } m_full = false; } Base const &end() const { return m_end; } State const &state() const { return *m_state; } State &state() { return *m_state; } // iterator end for the iterator start sent to the constructor Base m_end; // encoding state to use and update State *m_state; // the most recent encoded character Char m_current_value; // number of bits left in current input character buffer unsigned int m_displacement; // value to be just encoded and a next value to be encoded base_value_type m_buffer, m_next_buffer; // flag to current output character is ready - just used to save time bool m_full; // flag to indicate that m_buffer and/or m_nextbuffer have data bool m_bufferfull, m_nextfull; public: template transform_width_with_state(BOOST_PFTO_WRAPPER(T) start, BOOST_PFTO_WRAPPER(T) end, State &state) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast(start)))), m_end(end), m_state(&state), m_displacement(0), m_full(false), m_bufferfull(false), m_nextfull(false) {} template transform_width_with_state(BOOST_PFTO_WRAPPER(T) start) : super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast(start)))), m_displacement(0), m_full(false), m_bufferfull(false), m_nextfull(false) {} transform_width_with_state(const transform_width_with_state &rhs) : super_t(rhs.base_reference()), m_end(rhs.m_end), m_state(rhs.m_state), m_current_value(rhs.m_current_value), m_displacement(rhs.m_displacement), m_buffer(rhs.m_buffer), m_next_buffer(rhs.m_next_buffer), m_full(rhs.m_full), m_bufferfull(rhs.m_bufferfull), m_nextfull(rhs.m_nextfull) {} }; template Char transform_width_with_state::fill() { State &state = this->state(); if (!state.empty()) { // initialize the m_buffer from the state and put the current input // byte to the m_next_buffer to make it follow right after m_displacement = state.m_displacement; m_buffer = state.m_buffer; m_bufferfull = true; m_next_buffer = *this->base_reference(); m_nextfull = true; state.clear(); } Char retval = 0; unsigned int missing_bits = BitsOut; for (;;) { unsigned int bcount; if (!m_bufferfull) { // fill the current m_buffer firstly from m_next_buffer if // available then read the input sequence if (m_nextfull) { m_buffer = m_next_buffer; m_nextfull = false; } else { m_buffer = *this->base_reference(); } m_bufferfull = true; bcount = BitsIn; } else bcount = BitsIn - m_displacement; unsigned int i = (std::min)(bcount, missing_bits); // shift interesting bits to least significant position unsigned int j = m_buffer >> (bcount - i); // strip off uninteresting bits // (note presumption of two's complement arithmetic) j &= ~(-(1 << i)); // append then interesting bits to the output value retval <<= i; retval |= j; missing_bits -= i; if (0 == missing_bits) break; // if we used a byte from the input sequence and not from the // prepared m_next_buffer, advance the input sequence iterator if (!m_nextfull) ++this->base_reference(); m_bufferfull = false; } return retval; } } // namespace iterators } // namespace utils } // namespace network } // namespace boost #endif // BOOST_NETWORK_UTILS_ITERATORS_TRANSFORM_WIDTH_WITH_STATE_HPP cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils_base64_experiment.cpp000066400000000000000000000114741240331347200302500ustar00rootroot00000000000000#include #include #include #include "utils/base64-standalone.hpp" // Since we're having issues with libc++ on OS X we're excluding this in the // meantime if we're using libc++ #ifndef _LIBCPP_VERSION #include "utils/base64-stateless.hpp" #include "utils/base64-stateful_buffer.hpp" #endif #include "utils/base64-stateful_iterator.hpp" #include "utils/base64-stateful_transform.hpp" #include #include #include #include #include #include // the main entry point does nothing; the tests are run by constructors // of testing classes, which are executed by global variables int main(int argc, char const* argv[]) { return 0; } using namespace boost::network::utils; // macros to build names of test classes ans gobal runner variables #define stringify_internal(x) #x #define stringify(x) stringify_internal(x) #define concatenate_internal(x, y) x##y #define concatenate(x, y) concatenate_internal(x, y) #ifdef NDEBUG // testing block sizes (im MB) which let the tests run approximately // 5s on my machine in the optimized mode #define single_block_size 160 #define multiple_block_size 320 #define multiple_block_count 1280 #else // testing block sizes (im MB) which let the tests run approximately // 5s on my machine in the not optimized mode #define single_block_size 16 #define multiple_block_size 64 #define multiple_block_count 256 #endif // the class name of a test suite; base64 has to be defined as a namespace // name with an alternative implementation of the base64 encoding interface #define test_name concatenate(base64, _test) // the code which actually performs the encoding; base64 has to be defined // as a namespace name - see above #define encode_single_block std::string result = base64::encode(buffer) #define encode_multiple_blocks \ std::string result; \ std::back_insert_iterator result_encoder(result); \ base64::state rest; \ for (unsigned block_index = 0; block_index < buffers.size(); \ ++block_index) { \ std::vector const& buffer = buffers[block_index]; \ base64::encode(buffer.begin(), buffer.end(), result_encoder, rest); \ } \ base64::encode_rest(result_encoder, rest) // testing the code from experimental/base64-stateless.hpp // NOTE(dberris): Only do this if we're NOT using libc++. #ifndef _LIBCPP_VERSION #define base64 base64_stateless #include "utils_base64_experiment.ipp" #undef base64 // enable the second test case, which encodes the input buffer chunk by chunk // and remembers the encoding state to be able to continue #define base64_with_state // testing the code from experimental/base64-stateful_buffer.hpp #define base64 base64_stateful_buffer #include "utils_base64_experiment.ipp" #undef base64 #endif // _LIBCPP_VERSION // testing the code from experimental/base64-stateful_transform.hpp #define base64 base64_stateful_transform #include "utils_base64_experiment.ipp" #undef base64 // testing the code from experimental/base64-stateful_iterator.hpp #define base64 base64_stateful_iterator #include "utils_base64_experiment.ipp" #undef base64 // testing the code from experimental/base64-standalone.hpp, // which has become the code in boost/network/utils/base64/encode.hpp #define base64 base64_standalone #include "utils_base64_experiment.ipp" #undef base64 // redefine the testing code to use the iostream implementation from // boost/network/utils/base64/encode-io.hpp which depends on the // interface from boost/network/utils/base64/encode.hpp #undef test_name #undef encode_single_block #undef encode_multiple_blocks #define test_name concatenate(concatenate(base64, _standalone_io), _test) #define encode_single_block \ std::stringstream result; \ result << base64::io::encode(buffer) << base64::io::encode_rest #define encode_multiple_blocks \ std::stringstream result; \ for (unsigned block_index = 0; block_index < buffers.size(); \ ++block_index) { \ std::vector const& buffer = buffers[block_index]; \ result << base64::io::encode(buffer.begin(), buffer.end()); \ } \ result << base64::io::encode_rest // testing the iostream implementation with the code from // boost/network/utils/base64/encode.hpp #define base64 base64 #include "utils_base64_experiment.ipp" #undef base64 cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils_base64_experiment.ipp000066400000000000000000000033651240331347200302560ustar00rootroot00000000000000class test_name { void test_single_block(); void test_multiple_blocks(); public: test_name() { std::cout << "Executing " stringify(test_name) ":" << std::endl; test_single_block(); test_multiple_blocks(); } }; test_name concatenate(run_, test_name); void test_name::test_single_block() { std::cout << " Encoding " << single_block_size << " MB buffer took "; // Fill a single vector with random bytes. std::vector buffer(single_block_size * 1024 * 1024); for (std::vector::iterator current = buffer.begin(); current != buffer.end(); ++current) *current = static_cast(rand() % 255); // Encode the single vector to a single BASE64 string. clock_t start = clock(); encode_single_block; clock_t end = clock(); std::cout << (double)(end - start) / CLOCKS_PER_SEC << "s." << std::endl; } void test_name::test_multiple_blocks() { #ifdef base64_with_state std::cout << " Encoding " << multiple_block_count << " x " << multiple_block_size << " KB buffers took "; // Fill multiple vectors with random bytes. std::vector > buffers(multiple_block_count); for (unsigned block_index = 0; block_index < buffers.size(); ++block_index) { std::vector& buffer = buffers[block_index]; buffer.resize(multiple_block_size * 1024); for (std::vector::iterator current = buffer.begin(); current != buffer.end(); ++current) *current = static_cast(rand() % 255); } // Encode the multiple vectors to a single BASE64 string. clock_t start = clock(); encode_multiple_blocks; clock_t end = clock(); std::cout << (double)(end - start) / CLOCKS_PER_SEC << "s." << std::endl; #endif } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/experiment/utils_base64_experiment.txt000066400000000000000000000046041240331347200303020ustar00rootroot00000000000000Benchmark results from GCC 4.6.4 without any optimization (no switches): Executing base64_stateless_test: Encoding 16 MB buffer took 4.81s. Executing base64_stateful_buffer_test: Encoding 16 MB buffer took 4.93s. Encoding 256 x 64 KB buffers took 4.92s. Executing base64_stateful_transform_test: Encoding 16 MB buffer took 5.32s. Encoding 256 x 64 KB buffers took 5.25s. Executing base64_stateful_iterator_test: Encoding 16 MB buffer took 7.03s. Encoding 256 x 64 KB buffers took 7.02s. Executing base64_standalone_test: Encoding 16 MB buffer took 0.93s. Encoding 256 x 64 KB buffers took 1.01s. Executing base64_standalone_io_test: Encoding 16 MB buffer took 2.31s. Encoding 256 x 64 KB buffers took 2.32s. Benchmark results from GCC 4.6.4 with the -O3 optimization; the processed data were 10 times bigger than for the test run without any optimization: Executing base64_stateless_test: Encoding 160 MB buffer took 3.42s. Executing base64_stateful_buffer_test: Encoding 160 MB buffer took 3.69s. Encoding 1280 x 320 KB buffers took 9.43s. Executing base64_stateful_transform_test: Encoding 160 MB buffer took 4.71s. Encoding 1280 x 320 KB buffers took 12.27s. Executing base64_stateful_iterator_test: Encoding 160 MB buffer took 4.65s. Encoding 1280 x 320 KB buffers took 11.92s. Executing base64_standalone_test: Encoding 160 MB buffer took 1.46s. Encoding 1280 x 320 KB buffers took 4.09s. Executing base64_standalone_io_test: Encoding 160 MB buffer took 3.93s. Encoding 1280 x 320 KB buffers took 10.18s. Testing the base64_stateless was done for the sake of completeness just to test the pure boost implementation only; state is needed for chunked encoding. The three different base64_stateful_xxx implementations are comparable; the base64_stateful_iterator may have spent more time in copy constructors, because the state is owned lower - by the transformed iterator adaptor. The iostream interface brings noticeable overhead, especially if the encoding state (stored in the internal extensible array of the output stream) is used extensively. The boost transforming iterators are not enough to implement BASE64 encoding of a chunked input. Taking the additional code into consideration, the amount of code for the non-boost base64_standalone implementation is not so different and offers better performance. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/src/000077500000000000000000000000001240331347200214005ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/src/CMakeLists.txt000066400000000000000000000043001240331347200241350ustar00rootroot00000000000000# Copyright (c) Glyn Matthews 2011. # Copyright 2011 Dean Michael Berris (dberris@google.com) # Copyright 2011 Google, Inc. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) include_directories(${CPP-NETLIB_SOURCE_DIR}) file(GLOB_RECURSE CPP-NETLIB_HEADERS "${CPP-NETLIB_SOURCE_DIR}/boost/" "*.hpp") set(CPP-NETLIB_URI_SRCS uri/uri.cpp uri/schemes.cpp) add_library(cppnetlib-uri ${CPP-NETLIB_URI_SRCS}) set_target_properties(cppnetlib-uri PROPERTIES VERSION ${CPPNETLIB_VERSION_STRING} SOVERSION ${CPPNETLIB_VERSION_MAJOR} PUBLIC_HEADER "${CPP-NETLIB_HEADERS}") install(TARGETS cppnetlib-uri EXPORT cppnetlibTargets PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}) set(CPP-NETLIB_HTTP_SERVER_SRCS server_request_parsers_impl.cpp) add_library(cppnetlib-server-parsers ${CPP-NETLIB_HTTP_SERVER_SRCS}) set_target_properties(cppnetlib-server-parsers PROPERTIES VERSION ${CPPNETLIB_VERSION_STRING} SOVERSION ${CPPNETLIB_VERSION_MAJOR} PUBLIC_HEADER "${CPP-NETLIB_HEADERS}") install(TARGETS cppnetlib-server-parsers EXPORT cppnetlibTargets PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}) set(CPP-NETLIB_HTTP_CLIENT_SRCS client.cpp) add_library(cppnetlib-client-connections ${CPP-NETLIB_HTTP_CLIENT_SRCS}) set_target_properties(cppnetlib-client-connections PROPERTIES VERSION ${CPPNETLIB_VERSION_STRING} SOVERSION ${CPPNETLIB_VERSION_MAJOR} PUBLIC_HEADER "${CPP-NETLIB_HEADERS}") if (OPENSSL_FOUND) target_link_libraries(cppnetlib-client-connections ${OPENSSL_LIBRARIES}) endif () if (Boost_FOUND) target_link_libraries(cppnetlib-client-connections ${Boost_System_LIBRARY}) endif () install(TARGETS cppnetlib-client-connections EXPORT cppnetlibTargets PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}) cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/src/client.cpp000066400000000000000000000010751240331347200233650ustar00rootroot00000000000000 // Copyright 2011 Dean Michael Berris (dberris@google.com). // Copyright 2011 Google, Inc. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifdef BOOST_NETWORK_NO_LIB #warn Building the library even with BOOST_NETWORK_NO_LIB defined. #undef BOOST_NETWORK_NO_LIB #endif #include #ifdef BOOST_NETWORK_ENABLE_HTTPS #include #endif cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/src/server_request_parsers_impl.cpp000066400000000000000000000005031240331347200277400ustar00rootroot00000000000000// Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifdef BOOST_NETWORK_NO_LIB #undef BOOST_NETWORK_NO_LIB #endif #include cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/src/uri/000077500000000000000000000000001240331347200221775ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/src/uri/schemes.cpp000066400000000000000000000036141240331347200243360ustar00rootroot00000000000000// Copyright 2012 Glyn Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace boost { namespace network { namespace uri { namespace { static boost::unordered_set hierarchical_schemes_; static boost::unordered_set opaque_schemes_; bool register_hierarchical_schemes() { hierarchical_schemes_.insert("http"); hierarchical_schemes_.insert("https"); hierarchical_schemes_.insert("shttp"); hierarchical_schemes_.insert("ftp"); hierarchical_schemes_.insert("file"); hierarchical_schemes_.insert("dns"); hierarchical_schemes_.insert("nfs"); hierarchical_schemes_.insert("imap"); hierarchical_schemes_.insert("nntp"); hierarchical_schemes_.insert("pop"); hierarchical_schemes_.insert("rsync"); hierarchical_schemes_.insert("snmp"); hierarchical_schemes_.insert("telnet"); hierarchical_schemes_.insert("svn"); hierarchical_schemes_.insert("svn+ssh"); hierarchical_schemes_.insert("git"); hierarchical_schemes_.insert("git+ssh"); return true; } bool register_opaque_schemes() { opaque_schemes_.insert("mailto"); opaque_schemes_.insert("news"); opaque_schemes_.insert("im"); opaque_schemes_.insert("sip"); opaque_schemes_.insert("sms"); opaque_schemes_.insert("xmpp"); return true; } static bool hierarchical = register_hierarchical_schemes(); static bool opaque = register_opaque_schemes(); } // namespace bool hierarchical_schemes::exists(const std::string &scheme) { return hierarchical_schemes_.end() != hierarchical_schemes_.find(scheme); } bool opaque_schemes::exists(const std::string &scheme) { return opaque_schemes_.end() != opaque_schemes_.find(scheme); } } // namespace uri } // namespace network } // namespace boost cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/src/uri/uri.cpp000066400000000000000000000003741240331347200235060ustar00rootroot00000000000000// Copyright 2012 Glyn Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/000077500000000000000000000000001240331347200215705ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/CMakeLists.txt000066400000000000000000000030121240331347200243240ustar00rootroot00000000000000# Copyright (c) Dean Michael Berris 2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) include_directories(${CPP-NETLIB_SOURCE_DIR}) add_subdirectory(uri) add_subdirectory(http) if (Boost_FOUND) set( TESTS message_test message_transform_test utils_thread_pool # utils_base64_test -- turn on when ready. ) foreach (test ${TESTS}) if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU) set_source_files_properties(${test}.cpp PROPERTIES COMPILE_FLAGS "-Wall") endif() add_executable(cpp-netlib-${test} ${test}.cpp) add_dependencies(cpp-netlib-${test} cppnetlib-uri) target_link_libraries(cpp-netlib-${test} ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri) if (OPENSSL_FOUND) target_link_libraries(cpp-netlib-${test} ${OPENSSL_LIBRARIES}) endif() if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU AND ${CMAKE_SYSTEM_NAME} MATCHES "Windows") target_link_libraries(cpp-netlib-${test} ws2_32 wsock32) endif() if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") target_link_libraries(cpp-netlib-${test} rt) endif() set_target_properties(cpp-netlib-${test} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/tests) add_test(cpp-netlib-${test} ${CPP-NETLIB_BINARY_DIR}/tests/cpp-netlib-${test}) endforeach (test) endif() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/client_server_include_failure.cpp000066400000000000000000000014361240331347200303560ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE Client and server includes #include // // The problem here is a bizarre compilation failure in including // these two files, and instantiating a client. It's described at // http://github.com/cpp-netlib/cpp-netlib/issues#issue/13 // #include #include BOOST_AUTO_TEST_CASE(test1) { typedef boost::network::http::basic_client< boost::network::http::tags::http_keepalive_8bit_udp_resolve, 1, 1> http_client; http_client client; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/000077500000000000000000000000001240331347200225475ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/CMakeLists.txt000066400000000000000000000073051240331347200253140ustar00rootroot00000000000000 # Copyright 2010 Dean Michael Berris. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) include_directories(${CPP-NETLIB_SOURCE_DIR}) if (OPENSSL_FOUND) include_directories( ${OPENSSL_INCLUDE_DIR} ) add_definitions(-DBOOST_NETWORK_ENABLE_HTTPS) endif() if (Boost_FOUND) set ( TESTS response_incremental_parser_test request_incremental_parser_test request_linearize_test ) foreach ( test ${TESTS} ) add_executable(cpp-netlib-http-${test} ${test}.cpp) add_dependencies(cpp-netlib-http-${test} cppnetlib-uri) target_link_libraries(cpp-netlib-http-${test} ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri) if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU AND ${CMAKE_SYSTEM_NAME} MATCHES "Windows") target_link_libraries(cpp-netlib-http-${test} ws2_32) endif() if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") target_link_libraries(cpp-netlib-http-${test} rt) endif() set_target_properties(cpp-netlib-http-${test} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/tests) add_test(cpp-netlib-http-${test} ${CPP-NETLIB_BINARY_DIR}/tests/cpp-netlib-http-${test}) endforeach (test) set ( TESTS client_constructor_test client_get_test client_get_different_port_test client_get_timeout_test client_get_streaming_test ) foreach ( test ${TESTS} ) add_executable(cpp-netlib-http-${test} ${test}.cpp) add_dependencies(cpp-netlib-http-${test} cppnetlib-uri cppnetlib-client-connections) target_link_libraries(cpp-netlib-http-${test} ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri cppnetlib-client-connections) if (OPENSSL_FOUND) target_link_libraries(cpp-netlib-http-${test} ${OPENSSL_LIBRARIES}) endif() if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU AND ${CMAKE_SYSTEM_NAME} MATCHES "Windows") target_link_libraries(cpp-netlib-http-${test} ws2_32) endif() if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") target_link_libraries(cpp-netlib-http-${test} rt) endif() set_target_properties(cpp-netlib-http-${test} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/tests) add_test(cpp-netlib-http-${test} ${CPP-NETLIB_BINARY_DIR}/tests/cpp-netlib-http-${test}) endforeach (test) set ( SERVER_API_TESTS server_constructor_test server_async_run_stop_concurrency server_header_parser_test ) foreach ( test ${SERVER_API_TESTS} ) add_executable(cpp-netlib-http-${test} ${test}.cpp) add_dependencies(cpp-netlib-http-${test} cppnetlib-server-parsers) target_link_libraries(cpp-netlib-http-${test} ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-server-parsers) if (OPENSSL_FOUND) target_link_libraries(cpp-netlib-http-${test} ${OPENSSL_LIBRARIES}) endif() if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU AND ${CMAKE_SYSTEM_NAME} MATCHES "Windows") target_link_libraries(cpp-netlib-http-${test} ws2_32 wsock32) endif() if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") target_link_libraries(cpp-netlib-http-${test} rt) endif() set_target_properties(cpp-netlib-http-${test} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/tests) add_test(cpp-netlib-http-${test} ${CPP-NETLIB_BINARY_DIR}/tests/cpp-netlib-http-${test}) endforeach (test) endif() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_constructor_test.cpp000066400000000000000000000023501240331347200302350ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP 1.0 Client Constructor Test #include #include #include "client_types.hpp" namespace http = boost::network::http; BOOST_AUTO_TEST_CASE_TEMPLATE(http_client_constructor_test, client, client_types) { typename client::options options; client instance; client instance2( options.io_service(boost::make_shared())); } BOOST_AUTO_TEST_CASE_TEMPLATE(http_cient_constructor_params_test, client, client_types) { typename client::options options; client instance(options.follow_redirects(true).cache_resolved(true)); client instance2( options.openssl_certificate("foo").openssl_verify_path("bar")); client instance3( options.openssl_certificate_file("foo").openssl_private_key_file("bar")); client instance4( options.follow_redirects(true) .io_service(boost::make_shared()) .cache_resolved(true)); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_get_different_port_test.cpp000066400000000000000000000016271240331347200315270ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Client Get Different Port Test #include #include #include "client_types.hpp" namespace net = boost::network; namespace http = boost::network::http; BOOST_AUTO_TEST_CASE_TEMPLATE(http_get_test_different_port, client, client_types) { typename client::request request("http://www.boost.org:80/"); client client_; typename client::response response_ = client_.get(request); typename net::headers_range::type range = headers(response_)["Content-Type"]; BOOST_CHECK(boost::begin(range) != boost::end(range)); BOOST_CHECK(body(response_).size() != 0); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_get_streaming_test.cpp000066400000000000000000000032211240331347200304760ustar00rootroot00000000000000// Copyright 2011 Dean Michael Berris <mikhailberis@gmail.com>. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP 1.1 Get Streaming Test #include #include #include #include "client_types.hpp" namespace net = boost::network; namespace http = boost::network::http; struct body_handler { explicit body_handler(std::string& body) : body(body) {} BOOST_NETWORK_HTTP_BODY_CALLBACK(operator(), range, error) { body.append(boost::begin(range), boost::end(range)); } std::string& body; }; BOOST_AUTO_TEST_CASE_TEMPLATE(http_client_get_streaming_test, client, async_only_client_types) { typename client::request request("http://www.boost.org"); typename client::response response; typename client::string_type body_string; typename client::string_type dummy_body; body_handler handler_instance(body_string); { client client_; BOOST_CHECK_NO_THROW(response = client_.get(request, handler_instance)); typename net::headers_range::type range = headers(response)["Content-Type"]; BOOST_CHECK(!boost::empty(range)); BOOST_CHECK_EQUAL(body(response).size(), 0u); BOOST_CHECK_EQUAL(response.version().substr(0, 7), std::string("HTTP/1.")); BOOST_CHECK_EQUAL(response.status(), 200u); BOOST_CHECK_EQUAL(response.status_message(), std::string("OK")); dummy_body = body(response); } BOOST_CHECK(dummy_body == typename client::string_type()); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_get_test.cpp000066400000000000000000000042521240331347200264320ustar00rootroot00000000000000// Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP 1.0 Get Test #include #include #include "client_types.hpp" namespace net = boost::network; namespace http = boost::network::http; BOOST_AUTO_TEST_CASE_TEMPLATE(http_client_get_test, client, client_types) { typename client::request request("http://www.boost.org"); client client_; typename client::response response; BOOST_REQUIRE_NO_THROW(response = client_.get(request)); typename net::headers_range::type range = headers(response)["Content-Type"]; BOOST_CHECK(!boost::empty(range)); BOOST_REQUIRE_NO_THROW(BOOST_CHECK(body(response).size() != 0)); BOOST_CHECK_EQUAL(response.version().substr(0, 7), std::string("HTTP/1.")); BOOST_CHECK_EQUAL(response.status(), 200u); BOOST_CHECK_EQUAL(response.status_message(), std::string("OK")); } #ifdef BOOST_NETWORK_ENABLE_HTTPS BOOST_AUTO_TEST_CASE_TEMPLATE(https_client_get_test, client, client_types) { typename client::request request("https://www.google.com/"); client client_; typename client::response response_ = client_.get(request); typename net::headers_range::type range = headers(response_)["Content-Type"]; BOOST_CHECK(boost::begin(range) != boost::end(range)); BOOST_CHECK(body(response_).size() != 0); } #endif BOOST_AUTO_TEST_CASE_TEMPLATE(http_temp_client_get_test, client, client_types) { typename client::request request("http://www.google.co.kr"); typename client::response response; BOOST_REQUIRE_NO_THROW(response = client().get(request)); typename net::headers_range::type range = headers(response)["Content-Type"]; BOOST_CHECK(!boost::empty(range)); BOOST_REQUIRE_NO_THROW(BOOST_CHECK(body(response).size() != 0)); BOOST_CHECK_EQUAL(response.version().substr(0, 7), std::string("HTTP/1.")); BOOST_CHECK_EQUAL(response.status(), 200u); BOOST_CHECK_EQUAL(response.status_message(), std::string("OK")); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_get_timeout_test.cpp000066400000000000000000000036151240331347200302020ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Client Get Timeout Test #include #include #include "client_types.hpp" namespace http = boost::network::http; BOOST_AUTO_TEST_CASE_TEMPLATE(http_get_test_timeout_1_0, client, client_types) { typename client::request request("http://localhost:12121/"); typename client::response response_; client client_; boost::uint16_t port_ = port(request); typename client::response::string_type temp; BOOST_CHECK_EQUAL(12121, port_); BOOST_CHECK_THROW(response_ = client_.get(request); temp = body(response_); , std::exception); } BOOST_AUTO_TEST_CASE_TEMPLATE(http_get_test_timeout_with_options, client, client_types) { typename client::request request( "http://cznic.dl.sourceforge.net/project/boost/boost/1.55.0/" "boost_1_55_0.tar.bz2"); typename client::response response; typename client::options options; client client_(options.timeout(1)); typename client::response::string_type temp; BOOST_CHECK_THROW(response = client_.get(request); temp = body(response); , std::exception); } #ifdef BOOST_NETWORK_ENABLE_HTTPS BOOST_AUTO_TEST_CASE_TEMPLATE(https_get_test_timeout_with_options, client, client_types) { typename client::request request( "https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.8.2.tar.bz2"); typename client::response response; typename client::options options; client client_(options.timeout(1)); typename client::response::string_type temp; BOOST_CHECK_THROW(response = client_.get(request); temp = body(response); , std::exception); } #endif cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_include_inlined.cpp000066400000000000000000000012121240331347200277320ustar00rootroot00000000000000// Copyright 2011 Dean Michael Berris <mikhailberis@gmail.com>. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_NETWORK_NO_LIB #include int main(int argc, char* argv[]) { using namespace boost; using namespace boost::network; http::client c; http::client::request req("http://www.boost.org/"); try { http::client::response res = c.get(req); } catch (...) { // ignore the error, we just want to make sure // the interface works inlined. } return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_localhost_normal_test.cpp000066400000000000000000000300721240331347200312120ustar00rootroot00000000000000// // Copyright Divye Kapoor 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Changes by Kim Grasman 2008 // Changes by Dean Michael Berris 2008, 2010 #define BOOST_TEST_MODULE http 1.0 localhost tests #include #include #include #include #include #include #include #include #include #include "http_test_server.hpp" using std::cout; using std::endl; namespace { const std::string base_url = "http://localhost:8000"; const std::string cgi_url = base_url + "/cgi-bin/requestinfo.py"; struct running_server_fixture { // NOTE: Can't use BOOST_REQUIRE_MESSAGE here, as Boost.Test data structures // are not fully set up when the global fixture runs. running_server_fixture() { if (!server.start()) cout << "Failed to start HTTP server for test!" << endl; } ~running_server_fixture() { if (!server.stop()) cout << "Failed to stop HTTP server for test!" << endl; } http_test_server server; }; std::size_t readfile(std::ifstream& file, std::vector& buffer) { using std::ios; std::istreambuf_iterator src(file); std::istreambuf_iterator eof; std::copy(src, eof, std::back_inserter(buffer)); return buffer.size(); } std::map parse_headers(std::string const& body) { std::map headers; std::istringstream stream(body); while (stream.good()) { std::string line; std::getline(stream, line); if (!stream.eof()) { std::size_t colon = line.find(':'); if (colon != std::string::npos) { std::string header = line.substr(0, colon); std::string value = line.substr(colon + 2); headers[header] = value; } } } return headers; } std::string get_content_length(std::string const& content) { return boost::lexical_cast(content.length()); } } #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) // Uncomment the below if you're running Python pre-2.6. There was a bug // in the Python HTTP server for earlier versions that causes this test // case to fail. // BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES(text_query_preserves_crlf, 2); #endif BOOST_GLOBAL_FIXTURE(running_server_fixture); BOOST_AUTO_TEST_CASE(body_test) { // Tests presence of body in http responses using namespace boost::network; http::client::request request_(base_url); http::client client_; http::client::response response_; BOOST_REQUIRE_NO_THROW(response_ = client_.get(request_)); BOOST_CHECK(body(response_).size() != 0); } BOOST_AUTO_TEST_CASE(text_content_type_test) { // Tests correct parsing of the content-type header sent by the server using namespace boost::network; http::client::request request_(base_url); http::client client_; http::client::response response_; BOOST_REQUIRE_NO_THROW(response_ = client_.get(request_)); BOOST_REQUIRE(headers(response_).count("Content-type") != 0); headers_range::type range = headers(response_)["Content-type"]; BOOST_CHECK(boost::begin(range)->first == "Content-type"); BOOST_CHECK(boost::begin(range)->second == "text/html"); } BOOST_AUTO_TEST_CASE(binary_content_type_test) { // Tests correct parsing of content-type for binary files such as .zip files using namespace boost::network; http::client::request request_(base_url + "/boost.jpg"); http::client client_; http::client::response response_; BOOST_REQUIRE_NO_THROW(response_ = client_.get(request_)); BOOST_REQUIRE(headers(response_).count("Content-type") != 0); headers_range::type range = headers(response_)["Content-type"]; BOOST_CHECK(boost::begin(range)->first == "Content-type"); BOOST_CHECK(boost::begin(range)->second == "image/jpeg"); } BOOST_AUTO_TEST_CASE(content_length_header_test) { // Uses the test.xml file to ensure that the file was received at the correct // length for a text encoding using namespace boost::network; http::client::request request_(base_url + "/test.xml"); http::client client_; http::client::response response_; BOOST_REQUIRE_NO_THROW(response_ = client_.get(request_)); BOOST_REQUIRE(headers(response_).count("Content-Length") != 0); headers_range::type range = headers(response_)["Content-Length"]; BOOST_CHECK_EQUAL(boost::begin(range)->first, "Content-Length"); BOOST_CHECK_EQUAL(boost::begin(range)->second, "113"); BOOST_CHECK(body(response_).size() != 0); } BOOST_AUTO_TEST_CASE(text_query_preserves_crlf) { // Tests proper transfer of a text file using namespace boost::network; http::client::request request_(base_url + "/test.xml"); http::client client_; http::client::response response_; BOOST_REQUIRE_NO_THROW(response_ = client_.get(request_)); http::client::response::string_type body_ = body(response_); BOOST_CHECK(body(response_).size() != 0); using std::ios; std::ifstream file("libs/network/test/server/test.xml", ios::in | ios::binary); if (!file) { file.clear(); file.open("server/test.xml", ios::in | ios::binary); } BOOST_REQUIRE_MESSAGE(file, "Could not open local test.xml"); std::vector memblock; std::size_t size = readfile(file, memblock); BOOST_CHECK(size != 0); BOOST_CHECK_EQUAL(body_.size(), size); if (body(response_).size() == size) { std::pair::iterator, std::string::const_iterator> diff_pos = std::mismatch(memblock.begin(), memblock.end(), body_.begin()); BOOST_CHECK_EQUAL( boost::numeric_cast(diff_pos.first - memblock.begin()), size); } } BOOST_AUTO_TEST_CASE(binary_file_query) { // Tests proper transfer of a binary image using namespace boost::network; http::client::request request_(base_url + "/boost.jpg"); http::client client_; http::client::response response_; BOOST_REQUIRE_NO_THROW(response_ = client_.get(request_)); http::client::response::string_type body_ = body(response_); BOOST_CHECK(body_.size() != 0); using std::ios; std::ifstream file("libs/network/test/server/boost.jpg", ios::in | ios::binary); if (!file) { file.clear(); file.open("server/boost.jpg", ios::in | ios::binary); } BOOST_REQUIRE_MESSAGE(file, "Could not open boost.jpg locally"); std::vector memblock; std::size_t size = readfile(file, memblock); BOOST_CHECK(size != 0); BOOST_CHECK_EQUAL(body_.size(), size); std::pair::iterator, std::string::const_iterator> diff_pos = std::mismatch(memblock.begin(), memblock.end(), body_.begin()); BOOST_CHECK_EQUAL( boost::numeric_cast(diff_pos.first - memblock.begin()), size); } BOOST_AUTO_TEST_CASE(cgi_query) { // Get a dynamic request with no Content-Length header // Ensure that we have a body using namespace boost::network; http::client::request req(cgi_url + "?query=1"); http::client c; http::client::response r; BOOST_REQUIRE_NO_THROW(r = c.get(req)); BOOST_CHECK(body(r).size() != 0); BOOST_CHECK(boost::empty(headers(r)["Content-Length"])); } BOOST_AUTO_TEST_CASE(cgi_multi_line_headers) { using namespace boost::network; http::client::request req(base_url + "/cgi-bin/multiline-header.py?query=1"); http::client c; http::client::response r; BOOST_REQUIRE_NO_THROW(r = c.get(req)); BOOST_CHECK(body(r).size() != 0); BOOST_CHECK(boost::empty(headers(r)["Content-Type"])); headers_range::type range = headers(r)["X-CppNetlib-Test"]; BOOST_REQUIRE(boost::begin(range) != boost::end(range)); BOOST_REQUIRE(distance(range) == 2); BOOST_CHECK_EQUAL(boost::begin(range)->second, std::string("multi-line-header")); BOOST_CHECK_EQUAL((++boost::begin(range))->second, std::string("that-should-concatenate")); } BOOST_AUTO_TEST_CASE(file_not_found) { // Request for a non existing file. // Ensure that we have a body even in the presence of an error response using namespace boost::network; http::client::request req(base_url + "/file_not_found"); http::client c; http::client::response r = c.get(req); BOOST_CHECK(body(r).size() != 0); } BOOST_AUTO_TEST_CASE(head_test) { using namespace boost::network; http::client::request request_(base_url + "/test.xml"); http::client client_; http::client::response response_; BOOST_REQUIRE_NO_THROW(response_ = client_.head(request_)); BOOST_REQUIRE(headers(response_).count("Content-Length") != 0); headers_range::type range = headers(response_)["Content-Length"]; BOOST_CHECK_EQUAL(boost::begin(range)->first, "Content-Length"); BOOST_CHECK_EQUAL(boost::begin(range)->second, "113"); BOOST_CHECK(body(response_).size() == 0); } BOOST_AUTO_TEST_CASE(post_with_explicit_headers) { // This test checks that the headers echoed through echo_headers.py // are in fact the same as what are sent through the POST request using namespace boost::network; const std::string postdata = "empty"; const std::string content_length = get_content_length(postdata); const std::string content_type = "application/x-www-form-urlencoded"; http::client::request req(base_url + "/cgi-bin/echo_headers.py"); req << header("Content-Length", content_length); req << header("Content-Type", content_type); req << body(postdata); http::client c; http::client::response r; BOOST_REQUIRE_NO_THROW(r = c.post(req)); std::map headers = parse_headers(body(r)); BOOST_CHECK_EQUAL(headers["content-length"], content_length); BOOST_CHECK_EQUAL(headers["content-type"], content_type); } BOOST_AUTO_TEST_CASE(post_with_implicit_headers) { // This test checks that post(request, body) derives Content-Length // and Content-Type using namespace boost::network; const std::string postdata = "empty"; http::client::request req(base_url + "/cgi-bin/echo_headers.py"); http::client c; http::client::response r; BOOST_REQUIRE_NO_THROW(r = c.post(req, postdata)); std::map headers = parse_headers(body(r)); BOOST_CHECK_EQUAL(headers["content-length"], get_content_length(postdata)); BOOST_CHECK_EQUAL(headers["content-type"], "x-application/octet-stream"); } BOOST_AUTO_TEST_CASE(post_with_explicit_content_type) { // This test checks that post(request, content_type, body) derives // Content-Length, // and keeps Content-Type using namespace boost::network; const std::string postdata = "empty"; const std::string content_type = "application/x-my-content-type"; http::client::request req(base_url + "/cgi-bin/echo_headers.py"); http::client c; http::client::response r; BOOST_REQUIRE_NO_THROW(r = c.post(req, content_type, postdata)); std::map headers = parse_headers(body(r)); BOOST_CHECK_EQUAL(headers["content-length"], get_content_length(postdata)); BOOST_CHECK_EQUAL(headers["content-type"], content_type); } BOOST_AUTO_TEST_CASE(post_body_default_content_type) { // This test checks that post(request, body) gets the post data // through to the server using namespace boost::network; const std::string postdata = "firstname=bill&lastname=badger"; http::client::request req(base_url + "/cgi-bin/echo_body.py"); http::client c; http::client::response r; BOOST_REQUIRE_NO_THROW(r = c.post(req, postdata)); http::client::response::string_type body_ = body(r); BOOST_CHECK_EQUAL(postdata, body_); } BOOST_AUTO_TEST_CASE(post_with_custom_headers) { // This test checks that custom headers pass through to the server // when posting using namespace boost::network; http::client::request req(base_url + "/cgi-bin/echo_headers.py"); req << header("X-Cpp-Netlib", "rocks!"); http::client c; http::client::response r; BOOST_REQUIRE_NO_THROW(r = c.post(req, std::string())); std::map headers = parse_headers(body(r)); BOOST_CHECK_EQUAL(headers["x-cpp-netlib"], "rocks!"); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_localhost_ssl_test.cpp000066400000000000000000000271371240331347200305330ustar00rootroot00000000000000// // Copyright Divye Kapoor 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // Changes by Kim Grasman 2008 // Changes by Dean Michael Berris 2008, 2009 #define BOOST_TEST_MODULE https 1.0 localhost tests #include #include #include #include #include #include #include #include #define HTTPS_SERVER_TEST #include "http_test_server.hpp" using std::cout; using std::endl; namespace { const std::string base_url = "https://localhost:8443"; const std::string cgi_url = base_url + "/cgi-bin/requestinfo.py"; struct running_server_fixture { // NOTE: Can't use BOOST_REQUIRE_MESSAGE here, as Boost.Test data structures // are not fully set up when the global fixture runs. running_server_fixture() { if (!server.start()) cout << "Failed to start HTTP server for test!" << endl; } ~running_server_fixture() { if (!server.stop()) cout << "Failed to stop HTTP server for test!" << endl; } http_test_server server; }; std::size_t readfile(std::ifstream& file, std::vector& buffer) { using std::ios; std::istreambuf_iterator src(file); std::istreambuf_iterator eof; std::copy(src, eof, std::back_inserter(buffer)); return buffer.size(); } } #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) // Uncomment the below if you're running Python pre-2.6. There was a bug // in the Python HTTP server for earlier versions that causes this test // case to fail. // BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES(text_query_preserves_crlf, 2); #endif BOOST_GLOBAL_FIXTURE(running_server_fixture); BOOST_AUTO_TEST_CASE(body_test) { // Tests presence of body in http responses using namespace boost::network; http::client::request request_(base_url); http::client client_; http::client::response response_ = client_.get(request_); BOOST_CHECK(body(response_).size() != 0); } BOOST_AUTO_TEST_CASE(text_content_type_test) { // Tests correct parsing of the content-type header sent by the server using namespace boost::network; http::client::request request_(base_url); http::client client_; http::client::response response_ = client_.get(request_); BOOST_REQUIRE(headers(response_).count("Content-type") != 0); headers_range::type range = headers(response_)["Content-type"]; BOOST_CHECK(boost::begin(range)->first == "Content-type"); BOOST_CHECK(boost::begin(range)->second == "text/html"); } BOOST_AUTO_TEST_CASE(binary_content_type_test) { // Tests correct parsing of content-type for binary files such as .zip files using namespace boost::network; http::client::request request_(base_url + "/boost.jpg"); http::client client_; http::client::response response_ = client_.get(request_); BOOST_REQUIRE(headers(response_).count("Content-type") != 0); headers_range::type range = headers(response_)["Content-type"]; BOOST_CHECK(boost::begin(range)->first == "Content-type"); BOOST_CHECK(boost::begin(range)->second == "image/jpeg"); } BOOST_AUTO_TEST_CASE(content_length_header_test) { // Uses the test.xml file to ensure that the file was received at the correct // length for a text encoding using namespace boost::network; http::client::request request_(base_url + "/test.xml"); http::client client_; http::client::response response_ = client_.get(request_); BOOST_REQUIRE(headers(response_).count("Content-Length") != 0); headers_range::type range = headers(response_)["Content-Length"]; BOOST_CHECK_EQUAL(boost::begin(range)->first, "Content-Length"); BOOST_CHECK_EQUAL(boost::begin(range)->second, "113"); BOOST_CHECK(body(response_).size() != 0); } BOOST_AUTO_TEST_CASE(text_query_preserves_crlf) { // Tests proper transfer of a text file using namespace boost::network; http::client::request request_(base_url + "/test.xml"); http::client client_; http::client::response response_ = client_.get(request_); http::client::response::string_type body_ = body(response_); BOOST_CHECK(body_.size() != 0); using std::ios; std::ifstream file("libs/network/test/server/test.xml", ios::in | ios::binary); if (!file) { file.clear(); file.open("server/test.xml", ios::in | ios::binary); } BOOST_REQUIRE_MESSAGE(file, "Could not open local test.xml"); std::vector memblock; std::size_t size = readfile(file, memblock); BOOST_CHECK(size != 0); BOOST_CHECK_EQUAL(body(response_).size(), size); if (body(response_).size() == size) { std::pair::iterator, std::string::const_iterator> diff_pos = std::mismatch(memblock.begin(), memblock.end(), body_.begin()); BOOST_CHECK_EQUAL( boost::numeric_cast(diff_pos.first - memblock.begin()), size); } } BOOST_AUTO_TEST_CASE(binary_file_query) { // Tests proper transfer of a binary image using namespace boost::network; http::client::request request_(base_url + "/boost.jpg"); http::client client_; http::client::response response_; BOOST_CHECK_NO_THROW(response_ = client_.get(request_)); http::client::response::string_type body_ = body(response_); BOOST_CHECK(body_.size() != 0); using std::ios; std::ifstream file("libs/network/test/server/boost.jpg", ios::in | ios::binary); if (!file) { file.clear(); file.open("server/boost.jpg", ios::in | ios::binary); } BOOST_REQUIRE_MESSAGE(file, "Could not open boost.jpg locally"); std::vector memblock; std::size_t size = readfile(file, memblock); BOOST_CHECK(size != 0); BOOST_CHECK_EQUAL(body(response_).size(), size); std::pair::iterator, std::string::const_iterator> diff_pos = std::mismatch(memblock.begin(), memblock.end(), body_.begin()); BOOST_CHECK_EQUAL( boost::numeric_cast(diff_pos.first - memblock.begin()), size); } // BOOST_AUTO_TEST_CASE(cgi_query) { // // Get a dynamic request with no Content-Length header // // Ensure that we have a body // using namespace boost::network; // // http::client::request req(cgi_url + "?query=1"); // http::client c; // http::client::response r; // BOOST_REQUIRE_NO_THROW(r = c.get(req)); // BOOST_CHECK(body(r).size() != 0); // BOOST_CHECK(headers(r)["Content-Type"].begin() != // headers(r)["Content-Type"].end()); //} // // BOOST_AUTO_TEST_CASE(cgi_multi_line_headers) { // using namespace boost::network; // // http::client::request req(base_url + // "/cgi-bin/multiline-header.py?query=1"); // http::client c; // http::client::response r; // BOOST_REQUIRE_NO_THROW(r = c.get(req)); // BOOST_CHECK(body(r).size() != 0); // BOOST_CHECK(headers(r)["Content-Type"].begin() != // headers(r)["Content-Type"].end()); // headers_range::type // range=headers(r)["X-CppNetlib-Test"]; // BOOST_REQUIRE(boost::begin(range) != boost::end(range)); // BOOST_REQUIRE(distance(range) == 2); // BOOST_CHECK_EQUAL(boost::begin(range)->second, // std::string("multi-line-header")); // BOOST_CHECK_EQUAL((++boost::begin(range))->second, // std::string("that-should-concatenate")); //} BOOST_AUTO_TEST_CASE(file_not_found) { // Request for a non existing file. // Ensure that we have a body even in the presence of an error response using namespace boost::network; http::client::request req(base_url + "/file_not_found"); http::client c; http::client::response r = c.get(req); BOOST_CHECK(body(r).size() != 0); } BOOST_AUTO_TEST_CASE(head_test) { using namespace boost::network; http::client::request request_(base_url + "/test.xml"); http::client client_; http::client::response response_ = client_.head(request_); BOOST_REQUIRE(headers(response_).count("Content-Length") != 0); headers_range::type range = headers(response_)["Content-Length"]; BOOST_CHECK_EQUAL(boost::begin(range)->first, "Content-Length"); BOOST_CHECK_EQUAL(boost::begin(range)->second, "113"); BOOST_CHECK(body(response_).size() == 0); } // BOOST_AUTO_TEST_CASE(post_with_explicit_headers) { // // This test checks that the headers echoed through echo_headers.py // // are in fact the same as what are sent through the POST request // using namespace boost::network; // // const std::string postdata = "empty"; // const std::string content_length = get_content_length(postdata); // const std::string content_type = "application/x-www-form-urlencoded"; // // http::client::request req(base_url + "/cgi-bin/echo_headers.py"); // req << header("Content-Length", content_length); // req << header("Content-Type", content_type); // req << body(postdata); // // http::client c; // http::client::response r; // BOOST_REQUIRE_NO_THROW(r = c.post(req)); // // std::map headers = parse_headers(body(r)); // BOOST_CHECK_EQUAL(headers["content-length"], content_length); // BOOST_CHECK_EQUAL(headers["content-type"], content_type); //} // // BOOST_AUTO_TEST_CASE(post_with_implicit_headers) { // // This test checks that post(request, body) derives Content-Length // // and Content-Type // using namespace boost::network; // // const std::string postdata = "empty"; // // http::client::request req(base_url + "/cgi-bin/echo_headers.py"); // // http::client c; // http::client::response r; // BOOST_REQUIRE_NO_THROW(r = c.post(req, postdata)); // // std::map headers = parse_headers(body(r)); // BOOST_CHECK_EQUAL(headers["content-length"], // get_content_length(postdata)); // BOOST_CHECK_EQUAL(headers["content-type"], "x-application/octet-stream"); //} // // BOOST_AUTO_TEST_CASE(post_with_explicit_content_type) { // // This test checks that post(request, content_type, body) derives // Content-Length, // // and keeps Content-Type // using namespace boost::network; // // const std::string postdata = "empty"; // const std::string content_type = "application/x-my-content-type"; // // http::client::request req(base_url + "/cgi-bin/echo_headers.py"); // // http::client c; // http::client::response r; // BOOST_REQUIRE_NO_THROW(r = c.post(req, content_type, postdata)); // // std::map headers = parse_headers(body(r)); // BOOST_CHECK_EQUAL(headers["content-length"], // get_content_length(postdata)); // BOOST_CHECK_EQUAL(headers["content-type"], content_type); //} // // BOOST_AUTO_TEST_CASE(post_body_default_content_type) { // // This test checks that post(request, body) gets the post data // // through to the server // using namespace boost::network; // // const std::string postdata = "firstname=bill&lastname=badger"; // // http::client::request req(base_url + "/cgi-bin/echo_body.py"); // // http::client c; // http::client::response r; // BOOST_REQUIRE_NO_THROW(r = c.post(req, postdata)); // // BOOST_CHECK_EQUAL(postdata, body(r)); //} // // BOOST_AUTO_TEST_CASE(post_with_custom_headers) { // // This test checks that custom headers pass through to the server // // when posting // using namespace boost::network; // // http::client::request req(base_url + "/cgi-bin/echo_headers.py"); // req << header("X-Cpp-Netlib", "rocks!"); // // http::client c; // http::client::response r; // BOOST_REQUIRE_NO_THROW(r = c.post(req, std::string())); // // std::map headers = parse_headers(body(r)); // BOOST_CHECK_EQUAL(headers["x-cpp-netlib"], "rocks!"); //} cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/client_types.hpp000066400000000000000000000025741240331347200257720ustar00rootroot00000000000000#ifndef CLIENT_TYPES_ROOWQCLE #define CLIENT_TYPES_ROOWQCLE // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include "tag_types.hpp" #include #include #include #include #include #include namespace mpl = boost::mpl; template struct client_adapter { template struct apply { typedef boost::network::http::basic_client type; }; }; typedef mpl::transform >::type client_1_0; typedef mpl::transform >::type client_1_1; typedef mpl::joint_view::type client_types; typedef mpl::joint_view< mpl::transform >::type, client_adapter<1, 0> >::type, mpl::transform >::type, client_adapter<1, 1> >::type>::type async_only_client_types; #endif /* CLIENT_TYPES_ROOWQCLE */ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/http_test_server.hpp000066400000000000000000000101441240331347200266640ustar00rootroot00000000000000// // Copyright Kim Grasman 2008. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Changes by Allister Levi Sanchez 2008 // Changes by Dean Michael Berris 2010 #ifndef __NETWORK_TEST_HTTP_TEST_SERVER_HPP__ #define __NETWORK_TEST_HTTP_TEST_SERVER_HPP__ #define BOOST_FILESYSTEM_VERSION 3 #include #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(MIN) #include // ShellExecuteEx #include #pragma comment(lib, "shell32") #else #include // fork, execlp etc. #include #include // for waitpid #include // for chmod #include // for kill #endif struct http_test_server { bool start() { using namespace boost::filesystem; path script_path = get_server_path(current_path()); if (script_path.empty()) return false; path cgibin_path = script_path.parent_path() / "cgi-bin"; if (!set_cgibin_permissions(cgibin_path)) return false; server_child = launch_python_script(script_path); if (server_child == 0) return false; return true; } bool stop() { kill_script(server_child); return true; } private: #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) typedef HANDLE script_handle_t; #else typedef pid_t script_handle_t; #endif boost::filesystem::path get_server_path( const boost::filesystem::path& base_path) { using namespace boost::filesystem; const path script_name = #if defined(HTTPS_SERVER_TEST) "https_test_server.py" #else "http_test_server.py" #endif ; // if executed from $CPP_NETLIB_HOME path server_path = base_path / "libs/network/test/server" / script_name; if (!exists(server_path)) { // if executed from $CPP_NETLIB_HOME/libs/network/test server_path = base_path / "server" / script_name; if (!exists(server_path)) return path(); } return server_path; } script_handle_t launch_python_script( const boost::filesystem::path& python_script_path) { using namespace boost::filesystem; path::string_type script_name = python_script_path.filename().native(); path::string_type script_dir = python_script_path.parent_path().native(); #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) SHELLEXECUTEINFOA sei = {0}; sei.cbSize = sizeof(sei); sei.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI; sei.lpVerb = "open"; sei.lpFile = "python.exe"; sei.lpParameters = reinterpret_cast(script_name.c_str()); sei.lpDirectory = reinterpret_cast(script_dir.c_str()); sei.nShow = SW_SHOWNOACTIVATE; if (!ShellExecuteExA(&sei)) return 0; return sei.hProcess; #else // Try general Unix code pid_t child_process = fork(); if (child_process < 0) return false; if (child_process == 0) { // child process // cd into script dir and launch python script current_path(script_dir); if (execlp("python", "python", script_name.c_str(), (char*)NULL) == -1) return 0; } else { // parent sleep(1); } return child_process; #endif } void kill_script(script_handle_t h) { #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) TerminateProcess(h, 0U); CloseHandle(h); #else kill(h, SIGTERM); #endif } bool set_cgibin_permissions(const boost::filesystem::path& cgibin_path) { using namespace boost::filesystem; #if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32) // set the CGI script execute permission for (directory_iterator i(cgibin_path); i != directory_iterator(); ++i) { if (is_regular_file(i->status())) { path::string_type file_path = i->path().string(); if (chmod(file_path.c_str(), S_IWUSR | S_IXUSR | S_IXGRP | S_IXOTH | S_IRUSR | S_IRGRP | S_IROTH) != 0) return false; } } #endif return true; } script_handle_t server_child; }; #endif // __NETWORK_TEST_HTTP_TEST_SERVER_HPP__ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/message_async_ready_test.cpp000066400000000000000000000010471240331347200303210ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Async Response Test #include #include namespace http = boost::network::http; BOOST_AUTO_TEST_CASE(unready_state_response) { typedef http::basic_response response; response r; BOOST_CHECK(!ready(r)); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/message_test.cpp000066400000000000000000000170141240331347200257410ustar00rootroot00000000000000 // Copyright 2010 (c) Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP message test #include #include #include #include #include #include using namespace boost::network; typedef boost::mpl::list tag_types; struct fixtures {}; BOOST_FIXTURE_TEST_SUITE(http_message_test_suite, fixtures) BOOST_AUTO_TEST_CASE_TEMPLATE(request_constructor_test, T, tag_types) { http::basic_request request("http://boost.org"); typedef typename http::basic_request::string_type string_type; string_type host = http::host(request); boost::uint16_t port = http::port(request); string_type path = http::path(request); string_type query = http::query(request); string_type anchor = http::anchor(request); string_type protocol = http::protocol(request); BOOST_CHECK_EQUAL(host, "boost.org"); BOOST_CHECK_EQUAL(port, 80u); BOOST_CHECK_EQUAL(path, "/"); BOOST_CHECK_EQUAL(query, ""); BOOST_CHECK_EQUAL(anchor, ""); BOOST_CHECK_EQUAL(protocol, "http"); } BOOST_AUTO_TEST_CASE_TEMPLATE(request_copy_constructor_test, T, tag_types) { http::basic_request request("http://boost.org/handler.php"); request << header("Content-Type", "text/plain") << body("Hello, World!"); http::basic_request copy(request); typedef typename http::basic_request::string_type string_type; string_type orig_host = http::host(request), copy_host = http::host(copy); boost::uint16_t orig_port = http::port(request), copy_port = http::port(copy); string_type orig_path = http::path(request), copy_path = http::path(copy); string_type orig_body = body(request), copy_body = body(copy); BOOST_CHECK_EQUAL(orig_host, copy_host); BOOST_CHECK_EQUAL(orig_port, copy_port); BOOST_CHECK_EQUAL(orig_path, copy_path); BOOST_CHECK_EQUAL(orig_body, copy_body); } BOOST_AUTO_TEST_CASE_TEMPLATE(request_assignment_test, T, tag_types) { http::basic_request request("http://boost.org/handler.php"); request << header("Content-Type", "text/plain") << body("Hello, World!"); http::basic_request copy; copy = request; typedef typename http::basic_request::string_type string_type; string_type orig_host = http::host(request), copy_host = http::host(copy); boost::uint16_t orig_port = http::port(request), copy_port = http::port(copy); string_type orig_path = http::path(request), copy_path = http::path(copy); string_type orig_body = body(request), copy_body = body(copy); BOOST_CHECK_EQUAL(orig_host, copy_host); BOOST_CHECK_EQUAL(orig_port, copy_port); BOOST_CHECK_EQUAL(orig_path, copy_path); BOOST_CHECK_EQUAL(orig_body, copy_body); } BOOST_AUTO_TEST_CASE_TEMPLATE(request_swap_test, T, tag_types) { boost::network::http::basic_request request("http://boost.org/"); boost::network::http::basic_request other; swap(other, request); // ADL typedef typename http::basic_request::string_type string_type; string_type orig_host = http::host(request), orig_path = http::path(request), copy_host = http::host(other), copy_path = http::path(other); boost::uint16_t orig_port = http::port(request), copy_port = http::port(request); BOOST_CHECK_EQUAL(orig_host, ""); BOOST_CHECK_EQUAL(orig_port, 80u); BOOST_CHECK_EQUAL(orig_path, "/"); BOOST_CHECK_EQUAL(copy_host, "boost.org"); BOOST_CHECK_EQUAL(copy_port, 80u); BOOST_CHECK_EQUAL(copy_path, "/"); } BOOST_AUTO_TEST_CASE_TEMPLATE(request_uri_directive_test, T, tag_types) { http::basic_request request; request << http::uri("http://boost.org/"); typename http::basic_request::string_type uri_ = http::uri(request); BOOST_CHECK_EQUAL(uri_, "http://boost.org/"); } BOOST_AUTO_TEST_CASE_TEMPLATE(response_constructor_test, T, tag_types) { http::basic_response response; typename http::basic_response::string_type body_ = body(response); BOOST_CHECK_EQUAL(body_, std::string()); } BOOST_AUTO_TEST_CASE_TEMPLATE(response_copy_construct_test, T, tag_types) { using namespace http; http::basic_response response; response << http::version("HTTP/1.1") << http::status(200u) << body("The quick brown fox jumps over the lazy dog") << http::status_message("OK"); http::basic_response copy(response); typename http::basic_response::string_type version_orig = version(response), version_copy = version(copy); BOOST_CHECK_EQUAL(version_orig, version_copy); boost::uint16_t status_orig = status(response), status_copy = status(copy); BOOST_CHECK_EQUAL(status_orig, status_copy); typename http::basic_response::string_type status_message_orig = status_message(response), status_message_copy = status_message(copy), body_orig = body(response), body_copy = body(copy); BOOST_CHECK_EQUAL(status_message_orig, status_message_copy); BOOST_CHECK_EQUAL(body_orig, body_copy); } BOOST_AUTO_TEST_CASE_TEMPLATE(response_assignment_construct_test, T, tag_types) { http::basic_response response; response << http::version("HTTP/1.1") << http::status(200) << http::status_message("OK") << body("The quick brown fox jumps over the lazy dog"); http::basic_response copy; copy = response; typedef typename http::basic_response::string_type string_type; string_type version_orig = version(response), version_copy = version(copy); BOOST_CHECK_EQUAL(version_orig, version_copy); boost::uint16_t status_orig = status(response), status_copy = status(copy); BOOST_CHECK_EQUAL(status_orig, status_copy); string_type status_message_orig = status_message(response), status_message_copy = status_message(copy); BOOST_CHECK_EQUAL(status_message_orig, status_message_copy); string_type body_orig = body(response), body_copy = body(copy); BOOST_CHECK_EQUAL(body_orig, body_copy); } BOOST_AUTO_TEST_CASE_TEMPLATE(response_swap_test, T, tag_types) { using namespace boost::network::http; http::basic_response response; response << version("HTTP/1.1") << status(200) << status_message("OK") << body("RESPONSE"); boost::network::http::basic_response swapped; BOOST_REQUIRE_NO_THROW(swap(response, swapped)); BOOST_CHECK_EQUAL(response.version(), std::string()); BOOST_CHECK_EQUAL(response.status(), 0u); BOOST_CHECK_EQUAL(response.status_message(), std::string()); typename http::basic_response::string_type orig_body = body(response), swapped_body = body(swapped); BOOST_CHECK_EQUAL(orig_body, std::string()); BOOST_CHECK_EQUAL(swapped.version(), std::string("HTTP/1.1")); BOOST_CHECK_EQUAL(swapped.status(), 200u); BOOST_CHECK_EQUAL(swapped.status_message(), std::string("OK")); BOOST_CHECK_EQUAL(swapped_body, std::string("RESPONSE")); } BOOST_AUTO_TEST_SUITE_END() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/request_incremental_parser_test.cpp000066400000000000000000000132151240331347200317410ustar00rootroot00000000000000// Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Incremental Request Parser Test #include #include #include #include #include #include #include #include /** Synopsis * * Test for the HTTP Request Incremental Parser * -------------------------------------------- * * In this test we fully intend to specify how an incremental HTTP request * parser should be used. This follows the HTTP Response Incremental Parser * example, and models the Incremental Parser Concept. * */ namespace tags = boost::network::tags; namespace logic = boost::logic; namespace fusion = boost::fusion; using namespace boost::network::http; BOOST_AUTO_TEST_CASE(incremental_parser_constructor) { request_parser p; // default constructible } BOOST_AUTO_TEST_CASE(incremental_parser_parse_http_method) { request_parser p; logic::tribool parsed_ok = false; typedef request_parser request_parser_type; typedef boost::iterator_range range_type; range_type result_range; std::string valid_http_method = "GET "; fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::method_done, valid_http_method); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(!boost::empty(result_range)); std::string parsed(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; std::string invalid_http_method = "get "; p.reset(); fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::method_done, invalid_http_method); BOOST_CHECK_EQUAL(parsed_ok, false); parsed.assign(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; } BOOST_AUTO_TEST_CASE(incremental_parser_parse_http_uri) { request_parser p; logic::tribool parsed_ok = false; typedef request_parser request_parser_type; typedef boost::iterator_range range_type; range_type result_range; std::string valid_http_request = "GET / HTTP/1.1\r\n"; fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::uri_done, valid_http_request); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(!boost::empty(result_range)); std::string parsed(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; std::string invalid_http_request = "GET /\t HTTP/1.1\r\n"; p.reset(); fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::uri_done, invalid_http_request); BOOST_CHECK_EQUAL(parsed_ok, false); parsed.assign(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; } BOOST_AUTO_TEST_CASE(incremental_parser_parse_http_version) { request_parser p; logic::tribool parsed_ok = false; typedef request_parser request_parser_type; typedef boost::iterator_range range_type; range_type result_range; std::string valid_http_request = "GET / HTTP/1.1\r\n"; fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::version_done, valid_http_request); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(!boost::empty(result_range)); std::string parsed(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; std::string invalid_http_request = "GET / HTTP 1.1\r\n"; p.reset(); fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::version_done, invalid_http_request); BOOST_CHECK_EQUAL(parsed_ok, false); parsed.assign(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; } BOOST_AUTO_TEST_CASE(incremental_parser_parse_http_headers) { request_parser p; logic::tribool parsed_ok = false; typedef request_parser request_parser_type; typedef boost::iterator_range range_type; range_type result_range; std::string valid_http_request = "GET / HTTP/1.1\r\nHost: cpp-netlib.org\r\n\r\n"; fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::headers_done, valid_http_request); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(!boost::empty(result_range)); std::string parsed(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; valid_http_request = "GET / HTTP/1.1\r\nHost: cpp-netlib.org\r\nConnection: close\r\n\r\n"; p.reset(); fusion::tie(parsed_ok, result_range) = p.parse_until(request_parser_type::headers_done, valid_http_request); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(!boost::empty(result_range)); parsed.assign(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " [state:" << p.state() << "] " << std::endl; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/request_linearize_test.cpp000066400000000000000000000052011240331347200300420ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Request Linearize Test #include #include #include #include #include #include namespace http = boost::network::http; namespace tags = boost::network::http::tags; namespace mpl = boost::mpl; namespace net = boost::network; typedef mpl::list tag_types; BOOST_AUTO_TEST_CASE_TEMPLATE(linearize_request, T, tag_types) { http::basic_request request("http://www.boost.org"); static char http_1_0_output[] = "GET / HTTP/1.0\r\n" "Host: www.boost.org\r\n" "Accept: */*\r\n" "Connection: Close\r\n" "\r\n"; static char http_1_1_output[] = "GET / HTTP/1.1\r\n" "Host: www.boost.org\r\n" "Accept: */*\r\n" "Accept-Encoding: identity;q=1.0, *;q=0\r\n" "Connection: Close\r\n" "\r\n"; typename http::basic_request::string_type output_1_0; linearize(request, "GET", 1, 0, std::back_inserter(output_1_0)); BOOST_CHECK_EQUAL(output_1_0, http_1_0_output); typename http::basic_request::string_type output_1_1; linearize(request, "GET", 1, 1, std::back_inserter(output_1_1)); BOOST_CHECK_EQUAL(output_1_1, http_1_1_output); } BOOST_AUTO_TEST_CASE_TEMPLATE(linearize_request_override_headers, T, tag_types) { http::basic_request request("http://www.boost.org"); // We can override the defaulted headers and test that here. request << net::header("Accept", ""); static char http_1_0_no_accept_output[] = "GET / HTTP/1.0\r\n" "Host: www.boost.org\r\n" "Connection: Close\r\n" "\r\n"; static char http_1_1_no_accept_output[] = "GET / HTTP/1.1\r\n" "Host: www.boost.org\r\n" "Accept-Encoding: identity;q=1.0, *;q=0\r\n" "Connection: Close\r\n" "\r\n"; typename http::basic_request::string_type output_1_0; linearize(request, "GET", 1, 0, std::back_inserter(output_1_0)); BOOST_CHECK_EQUAL(output_1_0, http_1_0_no_accept_output); typename http::basic_request::string_type output_1_1; linearize(request, "GET", 1, 1, std::back_inserter(output_1_1)); BOOST_CHECK_EQUAL(output_1_1, http_1_1_no_accept_output); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/response_incremental_parser_test.cpp000066400000000000000000000422161240331347200321120ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2010. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Incremental Parser Test #include #include #include #include #include #include #include /** Synopsis * * Test for HTTP Response Incremental Parser * ----------------------------------------- * * In this test we fully intend to specify how an incremental * HTTP Response parser should be used. This defines the bare * minimum implementation for an Incremental Parser concept, * and shall follow an interface that puts a premium on simplicity. * * The motivation for coming up with a re-startable stateful * incremental parser comes from the requirement in the asynchronous * HTTP client implementation that allows for parsing an HTTP * response as the data comes in. By being able to process some * parts of the message ahead of others, we are allowed to set * the promise values bound to futures that the users of the client * would be waiting on. * * The basic interface that we're looking for is a means of providing: * - a range of input * - a means of resetting the parser's state * - a means of initializing the parser to a given state * - a parse_until function that takes a state as parameter and * a range from which the parser will operate on, returns * a tuple of a boost::logic::tribool and a resulting range * * One of the possible implementations can use the Boost.MSM library * to create the state machine. The test however does not specify what * implementation should be used, but rather that the interface and the * semantics are according to expectations. * * Date: September 9, 2010 * Author: Dean Michael Berris */ namespace tags = boost::network::tags; namespace logic = boost::logic; namespace fusion = boost::fusion; using namespace boost::network::http; struct crlf { static const std::string literal; }; const std::string crlf::literal = "\r\n"; struct lf { static const std::string literal; }; const std::string lf::literal = "\n"; typedef boost::mpl::vector eol_types; BOOST_AUTO_TEST_CASE(incremental_parser_constructor) { response_parser p; // default constructible } /** In this test we want to be able to parse incrementally a * range passed in as input, and specify to the parser that * it should stop when we reach a certain state. In this case * we want it to parse until it either finds the HTTP version * or there is an error encountered. */ BOOST_AUTO_TEST_CASE(incremental_parser_parse_http_version) { response_parser p; // default constructible logic::tribool parsed_ok = false; typedef response_parser response_parser_type; typedef boost::iterator_range range_type; range_type result_range; std::string valid_http_version = "HTTP/1.0 "; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_version_done, valid_http_version); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(!boost::empty(result_range)); std::string parsed(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(); valid_http_version = "HTTP/1.1 "; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_version_done, valid_http_version); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(!boost::empty(result_range)); parsed.assign(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(); std::string invalid_http_version = "HTTP 1.0"; parsed_ok = logic::indeterminate; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_version_done, invalid_http_version); BOOST_CHECK_EQUAL(parsed_ok, false); parsed.assign(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(); valid_http_version = "HTTP/0.9 "; parsed_ok = logic::indeterminate; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_version_done, valid_http_version); BOOST_CHECK_EQUAL(parsed_ok, true); parsed.assign(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; } /** In this test we then want to check that we can parse a status * string right after the version string. We should expect that * the parser doesn't do any conversions from string to integer * and outsource that part to the user of the parser. */ BOOST_AUTO_TEST_CASE_TEMPLATE(incremental_parser_parse_status, eol, eol_types) { typedef response_parser response_parser_type; typedef boost::iterator_range range_type; // We want to create a parser that has been initialized to a specific // state. In this case we assume that the parser has already parsed // the version part of the HTTP Response. response_parser_type p(response_parser_type::http_version_done); std::string valid_status = "200 "; logic::tribool parsed_ok; range_type result_range; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_status_done, valid_status); BOOST_CHECK_EQUAL(parsed_ok, true); std::string parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_version_done); std::string invalid_status = "200x "; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_status_done, invalid_status); BOOST_CHECK_EQUAL(parsed_ok, false); parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; valid_status = "200" + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_status_done, valid_status); BOOST_CHECK_EQUAL(parsed_ok, true); parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; } /** In this test then we get the rest of the first line of the HTTP * Response, and treat it as the status message. */ BOOST_AUTO_TEST_CASE_TEMPLATE(incremental_parser_parse_status_message, eol, eol_types) { typedef response_parser response_parser_type; typedef boost::iterator_range range_type; response_parser_type p(response_parser_type::http_status_done); std::string valid_status_message = "OK" + eol::literal + "Server: Foo"; logic::tribool parsed_ok; range_type result_range; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_status_message_done, valid_status_message); BOOST_CHECK_EQUAL(parsed_ok, true); std::string parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_done); valid_status_message = "OK" + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_status_message_done, valid_status_message); BOOST_CHECK_EQUAL(parsed_ok, true); parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_done); valid_status_message = "Internal Server Error" + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_status_message_done, valid_status_message); BOOST_CHECK_EQUAL(parsed_ok, true); parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_done); valid_status_message = eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_status_message_done, valid_status_message); BOOST_CHECK_EQUAL(parsed_ok, true); parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_done); valid_status_message = "한글메시지" + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until( response_parser_type::http_status_message_done, valid_status_message); BOOST_CHECK_EQUAL(parsed_ok, true); parsed = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed << " state=" << p.state() << std::endl; } /** This test specifices how one-line-per-header parsing happens incrementally. */ BOOST_AUTO_TEST_CASE_TEMPLATE(incremental_parser_parse_header_lines, eol, eol_types) { typedef response_parser response_parser_type; typedef boost::iterator_range range_type; response_parser_type p(response_parser_type::http_status_message_done); std::string valid_headers = "Server: Foo" + eol::literal + "Content-Type: application/json" + eol::literal + eol::literal; logic::tribool parsed_ok; range_type result_range; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); std::string parsed1 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed1 << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_message_done); std::string::const_iterator end = valid_headers.end(); valid_headers.assign(boost::end(result_range), end); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); std::string parsed2 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed2 << " state=" << p.state() << std::endl; valid_headers.assign(boost::end(result_range), end); p.reset(response_parser_type::http_status_message_done); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_headers_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(parsed1 != parsed2); p.reset(response_parser_type::http_status_message_done); valid_headers = " Server: Foo" + eol::literal + " Content-Type: application/json" + eol::literal + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed1 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed1 << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_message_done); end = valid_headers.end(); valid_headers.assign(boost::end(result_range), end); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed2 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed2 << " state=" << p.state() << std::endl; valid_headers.assign(boost::end(result_range), end); p.reset(response_parser_type::http_status_message_done); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_headers_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(parsed1 != parsed2); p.reset(response_parser_type::http_status_message_done); valid_headers = "_Server: Foo" + eol::literal + "_Content-Type: application/json" + eol::literal + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed1 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed1 << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_message_done); end = valid_headers.end(); valid_headers.assign(boost::end(result_range), end); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed2 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed2 << " state=" << p.state() << std::endl; valid_headers.assign(boost::end(result_range), end); p.reset(response_parser_type::http_status_message_done); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_headers_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(parsed1 != parsed2); p.reset(response_parser_type::http_status_message_done); valid_headers = "Server: " + eol::literal + "Content-Type: application/json" + eol::literal + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed1 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed1 << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_message_done); end = valid_headers.end(); valid_headers.assign(boost::end(result_range), end); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed2 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed2 << " state=" << p.state() << std::endl; valid_headers.assign(boost::end(result_range), end); p.reset(response_parser_type::http_status_message_done); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_headers_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(parsed1 != parsed2); p.reset(response_parser_type::http_status_message_done); valid_headers = "Server: 서버" + eol::literal + "Content-Type: application/json" + eol::literal + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed1 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed1 << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_message_done); end = valid_headers.end(); valid_headers.assign(boost::end(result_range), end); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed2 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed2 << " state=" << p.state() << std::endl; valid_headers.assign(boost::end(result_range), end); p.reset(response_parser_type::http_status_message_done); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_headers_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(parsed1 != parsed2); p.reset(response_parser_type::http_status_message_done); valid_headers = "Content-Type: text/html;" + eol::literal + "charset=utf-8" + eol::literal + eol::literal; fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed1 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed1 << " state=" << p.state() << std::endl; p.reset(response_parser_type::http_status_message_done); end = valid_headers.end(); valid_headers.assign(boost::end(result_range), end); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_header_line_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); parsed2 = std::string(boost::begin(result_range), boost::end(result_range)); std::cout << "PARSED: " << parsed2 << " state=" << p.state() << std::endl; valid_headers.assign(boost::end(result_range), end); p.reset(response_parser_type::http_status_message_done); fusion::tie(parsed_ok, result_range) = p.parse_until(response_parser_type::http_headers_done, valid_headers); BOOST_CHECK_EQUAL(parsed_ok, true); BOOST_CHECK(parsed1 != parsed2); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/server_async.cpp000066400000000000000000000033611240331347200257610ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Asynchronous Server Tests #include #include #include #include namespace net = boost::network; namespace http = boost::network::http; namespace utils = boost::network::utils; struct async_hello_world; typedef http::async_server server; struct async_hello_world { struct is_content_length { template bool operator()(Header const& header) { return boost::iequals(name(header), "content-length"); } }; void operator()(server::request const& request, server::connection_ptr connection) { static server::response_header headers[] = {{"Connection", "close"}, {"Content-Type", "text/plain"}, {"Server", "cpp-netlib/0.9"}, {"Content-Length", "13"}}; static std::string hello_world("Hello, World!"); connection->set_status(server::connection::ok); connection->set_headers(boost::make_iterator_range(headers, headers + 4)); connection->write(hello_world); } }; int main(int argc, char* argv[]) { utils::thread_pool thread_pool(2); async_hello_world handler; std::string port = "8000"; if (argc > 1) port = argv[1]; server instance("localhost", port, handler, thread_pool, http::_reuse_address = true); instance.run(); return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/server_async_less_copy.cpp000066400000000000000000000040111240331347200300320ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Asynchronous Server Tests #include #include #include #include #include #include namespace net = boost::network; namespace http = boost::network::http; namespace utils = boost::network::utils; struct async_hello_world; typedef http::async_server server; struct async_hello_world { struct is_content_length { template bool operator()(Header const& header) { return boost::iequals(name(header), "content-length"); } }; void operator()(server::request const& request, server::connection_ptr connection) { static server::response_header headers[] = {{"Connection", "close"}, {"Content-Type", "text/plain"}, {"Server", "cpp-netlib/0.9"}, {"Content-Length", "13"}}; static char const* hello_world = "Hello, World!"; connection->set_status(server::connection::ok); connection->set_headers(boost::make_iterator_range(headers, headers + 4)); std::vector iovec; iovec.push_back(boost::asio::const_buffer(hello_world, 13)); connection->write(iovec, boost::bind(&async_hello_world::error, this, _1)); } void error(boost::system::error_code const& ec) { // do nothing here. } }; int main(int argc, char* argv[]) { utils::thread_pool thread_pool(2); async_hello_world handler; std::string port = "8000"; if (argc > 1) port = argv[1]; server instance("127.0.0.1", port, handler, thread_pool, http::_reuse_address = true); instance.run(); return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/server_async_run_stop_concurrency.cpp000066400000000000000000000114221240331347200323210ustar00rootroot00000000000000#define BOOST_TEST_MODULE HTTP Asynchronous Server Tests #ifdef BOOST_TEST_DYN_LINK #define BOOST_TEST_NO_MAIN #endif /* BOOST_TEST_DYN_LINK */ #include #include #include namespace http = boost::network::http; namespace util = boost::network::utils; struct dummy_async_handler; typedef http::async_server async_server; struct dummy_async_handler { void operator()(async_server::request const& req, async_server::connection_ptr conn) { // Really, this is just for testing purposes } }; // In this batch of tests we ensure that calling run and stop on an // async_server, in any sequence, is thread safe. int main(int argc, char* argv[]) { dummy_async_handler async_handler; #define ASYNC_SERVER_TEST_CONFIG \ options.address("127.0.0.1").port("8007").reuse_address(true) #define ASYNC_SERVER_SLEEP_TIME boost::posix_time::milliseconds(100) // stop from main thread { BOOST_NETWORK_MESSAGE("TEST: stop without running"); async_server::options options(async_handler); async_server server_instance(ASYNC_SERVER_TEST_CONFIG); server_instance.stop(); } // run-stop from main thread { BOOST_NETWORK_MESSAGE("TEST: stop from main thread"); async_server::options options(async_handler); async_server server_instance(ASYNC_SERVER_TEST_CONFIG); boost::thread running_thread( boost::bind(&async_server::run, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); server_instance.stop(); running_thread.join(); } // run-stop from another thread { BOOST_NETWORK_MESSAGE("TEST: stop from another thread"); async_server::options options(async_handler); async_server server_instance(ASYNC_SERVER_TEST_CONFIG); boost::thread running_thread( boost::bind(&async_server::run, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread stopping_thread( boost::bind(&async_server::stop, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); stopping_thread.join(); running_thread.join(); } // run-stop-run-stop from another thread { BOOST_NETWORK_MESSAGE("TEST: run-stop-run-stop from another thread"); async_server::options options(async_handler); async_server server_instance(ASYNC_SERVER_TEST_CONFIG); boost::thread running_thread( boost::bind(&async_server::run, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread stopping_thread( boost::bind(&async_server::stop, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread second_running_thread( boost::bind(&async_server::run, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread second_stopping_thread( boost::bind(&async_server::stop, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); stopping_thread.join(); running_thread.join(); second_stopping_thread.join(); second_running_thread.join(); } // run-run-stop from another thread { BOOST_NETWORK_MESSAGE("TEST: run-run-stop from another thread"); async_server::options options(async_handler); async_server server_instance(ASYNC_SERVER_TEST_CONFIG); boost::thread running_thread( boost::bind(&async_server::run, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread second_running_thread( boost::bind(&async_server::run, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread stopping_thread( boost::bind(&async_server::stop, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); stopping_thread.join(); running_thread.join(); second_running_thread.join(); } // run-stop-stop from another thread { BOOST_NETWORK_MESSAGE("TEST: run-stop-stop from another thread"); async_server::options options(async_handler); async_server server_instance(ASYNC_SERVER_TEST_CONFIG); boost::thread running_thread( boost::bind(&async_server::run, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread stopping_thread( boost::bind(&async_server::stop, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); boost::thread second_stopping_thread( boost::bind(&async_server::stop, &server_instance)); boost::this_thread::sleep(ASYNC_SERVER_SLEEP_TIME); stopping_thread.join(); second_stopping_thread.join(); running_thread.join(); } #undef ASYNC_SERVER_TEST_CONFIG return 0; } #ifdef BOOST_TEST_DYN_LINK #undef BOOST_TEST_NO_MAIN #endif /* BOOST_TEST_DYN_LINK */ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/server_constructor_test.cpp000066400000000000000000000061751240331347200302760ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Server Construtor Tests #include #include namespace http = boost::network::http; namespace util = boost::network::utils; struct dummy_sync_handler; struct dummy_async_handler; typedef http::server sync_server; typedef http::async_server async_server; struct dummy_sync_handler { void operator()(sync_server::request const &req, sync_server::response &res) { // Really, this is just for testing purposes } void log(char const *) {} }; struct dummy_async_handler { void operator()(async_server::request const &req, async_server::connection_ptr conn) { // Really, this is just for testing purposes } }; BOOST_AUTO_TEST_CASE(minimal_constructor) { dummy_sync_handler sync_handler; dummy_async_handler async_handler; sync_server::options sync_options(sync_handler); async_server::options async_options(async_handler); BOOST_CHECK_NO_THROW( sync_server sync_instance(sync_options.address("127.0.0.1").port("80"))); BOOST_CHECK_NO_THROW(async_server async_instance( async_options.address("127.0.0.1").port("80"))); } BOOST_AUTO_TEST_CASE(with_io_service_parameter) { dummy_sync_handler sync_handler; dummy_async_handler async_handler; boost::shared_ptr thread_pool; boost::shared_ptr io_service; sync_server::options sync_options(sync_handler); async_server::options async_options(async_handler); BOOST_CHECK_NO_THROW( sync_server sync_instance(sync_options.address("127.0.0.1") .port("80") .io_service(io_service) .thread_pool(thread_pool))); BOOST_CHECK_NO_THROW( async_server async_instance(async_options.address("127.0.0.1") .port("80") .io_service(io_service) .thread_pool(thread_pool))); } BOOST_AUTO_TEST_CASE(throws_on_failure) { dummy_sync_handler sync_handler; dummy_async_handler async_handler; boost::shared_ptr thread_pool; boost::shared_ptr io_service; sync_server::options sync_options(sync_handler); async_server::options async_options(async_handler); sync_server sync_instance(sync_options.address("127.0.0.1") .port("80") .io_service(io_service) .thread_pool(thread_pool)); async_server async_instance(async_options.address("127.0.0.1") .port("80") .io_service(io_service) .thread_pool(thread_pool)); BOOST_CHECK_THROW(sync_instance.run(), std::runtime_error); BOOST_CHECK_THROW(async_instance.run(), std::runtime_error); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/server_header_parser_test.cpp000066400000000000000000000036661240331347200305170ustar00rootroot00000000000000// Copyright 2013 Rudolfs Bundulis // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Server Header Parser Test #include #include #include #define BOOST_LOCALE_NO_LIB #include #include #include /** Synopsis * * Test for Utf8 support in the asynchronous connection header parser * -------------------------------------------- * * This test checks for Utf8 support in the header parser * for asynchronous connection * */ namespace tags = boost::network::tags; namespace logic = boost::logic; namespace fusion = boost::fusion; using namespace boost::network::http; BOOST_AUTO_TEST_CASE(async_connection_parse_headers) { std::wstring utf16_test_name = L"R\u016bdolfs"; request_header_narrow utf8_header = { "X-Utf8-Test-Header", boost::locale::conv::utf_to_utf(utf16_test_name)}; std::string valid_http_request; valid_http_request.append(utf8_header.name) .append(": ") .append(utf8_header.value) .append("\r\n\r\n"); std::vector headers; parse_headers(valid_http_request, headers); std::vector::iterator header_iterator = headers.begin(); for (; header_iterator != headers.end(); ++header_iterator) { if (header_iterator->name == utf8_header.name && header_iterator->value == utf8_header.value) break; } std::wstring utf16_test_name_from_header = boost::locale::conv::utf_to_utf(header_iterator->value); BOOST_CHECK(header_iterator != headers.end()); BOOST_CHECK(utf16_test_name_from_header == utf16_test_name); std::cout << "utf8 header parsed, name: " << header_iterator->name << ", value: " << header_iterator->value; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/server_hello_world.cpp000066400000000000000000000027041240331347200271560ustar00rootroot00000000000000// Copyright 2009 (c) Tarro, Inc. // Copyright 2009-2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include #include #include #include #include #include #include namespace http = boost::network::http; using boost::assign::list_of; using boost::lexical_cast; using std::string; using std::cerr; using std::endl; struct hello_world; typedef http::server server; struct hello_world { void operator()(server::request const& request, server::response& response) { static server::response::header_type header = {"Connection", "close"}; response = server::response::stock_reply(server::response::ok, "Hello, World!"); response.headers.push_back(header); assert(response.status == server::response::ok); assert(response.headers.size() == 3); assert(response.content == "Hello, World!"); } void log(string const& data) { cerr << data << endl; abort(); } }; int main(int argc, char* argv[]) { hello_world handler; std::string port = "8000"; if (argc > 1) port = argv[1]; server server_("127.0.0.1", port, handler, http::_reuse_address = true); server_.run(); return EXIT_SUCCESS; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/server_include_inlined.cpp000066400000000000000000000032231240331347200277660ustar00rootroot00000000000000// Copyright 2009 (c) Tarro, Inc. // Copyright 2009-2010 (c) Dean Michael Berris // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include #include #define BOOST_NETWORK_NO_LIB #include #include #include #include #include #include namespace http = boost::network::http; using boost::assign::list_of; using boost::lexical_cast; using std::string; using std::cerr; using std::endl; struct hello_world; typedef http::server server; struct hello_world { void operator()(server::request const& request, server::response& response) { static server::response::header_type header = {"Connection", "close"}; response = server::response::stock_reply(server::response::ok, "Hello, World!"); response.headers.push_back(header); assert(response.status == server::response::ok); assert(response.headers.size() == 3); assert(response.content == "Hello, World!"); } void log(string const& data) { cerr << data << endl; abort(); } }; int main(int argc, char* argv[]) { hello_world handler; std::string port = "8000"; if (argc > 1) port = argv[1]; server server_("127.0.0.1", port, handler, http::_reuse_address = true); boost::thread runner(boost::bind(&server::run, &server_)); try { server_.stop(); runner.join(); } catch (...) { /* ignore all errors */ } return EXIT_SUCCESS; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http/tag_types.hpp000066400000000000000000000015041240331347200252570ustar00rootroot00000000000000#ifndef TAG_TYPES_4NNM8B5T #define TAG_TYPES_4NNM8B5T // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include namespace http = boost::network::http; typedef boost::mpl::vector tag_types; #endif /* TAG_TYPES_4NNM8B5T */ cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/http_server_async_less_copy.cpp000066400000000000000000000047711240331347200301270ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE HTTP Asynchronous Server Tests #include #include #include #include #include namespace net = boost::network; namespace http = boost::network::http; namespace utils = boost::network::utils; struct async_hello_world; typedef http::async_server server; struct async_hello_world { struct is_content_length { template bool operator()(Header const& header) { return boost::iequals(header.name, "content-length"); } }; void operator()(server::request const& request, server::connection_ptr connection) { static server::response_header headers[] = { {"Connection", "close"}, {"Content-Type", "text/plain"}, {"Server", "cpp-netlib/0.9-devel"}}; if (request.method == "HEAD") { connection->set_status(server::connection::ok); connection->set_headers(boost::make_iterator_range(headers, headers + 3)); } else { if (request.method == "PUT" || request.method == "POST") { static std::string bad_request("Bad Request."); server::request::headers_container_type::iterator found = boost::find_if(request.headers, is_content_length()); if (found == request.headers.end()) { connection->set_status(server::connection::bad_request); connection->set_headers( boost::make_iterator_range(headers, headers + 3)); connection->write(bad_request); return; } } static char const* hello_world = "Hello, World!"; connection->set_status(server::connection::ok); connection->set_headers(boost::make_iterator_range(headers, headers + 3)); std::vector iovec; iovec.push_back(boost::asio::const_buffer(hello_world, 13)); connection->write(iovec, boost::bind(&async_hello_world::error, this, _1)); } } void error(boost::system::error_code const& ec) { // do nothing here. } }; int main(int argc, char* argv[]) { utils::thread_pool thread_pool(2); async_hello_world handler; server instance("127.0.0.1", "8000", handler, thread_pool); instance.run(); return 0; } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/httplib_acceptance.py000066400000000000000000000052661240331347200257670ustar00rootroot00000000000000# Copyright (c) 2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) #!/bin/env python from sys import argv from time import sleep import httplib2 as httplib from subprocess import Popen,PIPE if len(argv) < 4: print('I need the executable to run, the port to run it on, and the final touched file indicator.') exit(1) print('Running {0} on port {1}...'.format(argv[1], argv[2])) pipe = None try: pipe = Popen(args=[argv[1], argv[2]], executable=argv[1], stdin=PIPE, stdout=PIPE, close_fds=True) print('Done with spawning {0}.'.format(argv[1])) print('Sleeping to give the server a chance to run...') sleep(1) except: print('I cannot spawn \'{0}\' properly.'.format(argv[1])) exit(1) status = 0 client = httplib.Http(timeout=5) expected = b'Hello, World!' def test(url, method, expected, headers={}, body=''): global status try: print('Request: {method} {url} body=\'{body}\''.format(method=method, url=url, body=body)), resp, content = client.request(url, method, headers=headers, body=body) if content != expected: print('ERROR: \'{0}\' != \'{1}\'; sizes: {2} != {3}'.format(content, expected, len(content), len(expected))) status = 1 else: print('... passed.') except Exception as e: print('Caught Exception: {0}'.format(e)) status = 1 def test_status(url, method, expected, headers={}, body=''): global status try: print('Request: {method} {url} body=\'{body}\''.format(method=method, url=url, body=body)), resp, content = client.request('http://localhost:8000/', 'PUT', body='') if resp['status'] != expected: print('ERROR: response status (got {0}) != expecting {1}'.format(resp['status'], expected)) status = 1 else: print('... passed.') except Exception as e: print('Caught Exception: {0}'.format(e)) status = 1 url = 'http://127.0.0.1:{0}/'.format(argv[2]) test(url, 'GET', expected) test(url, 'DELETE', expected) # Good request case, there's a content-length header for POST test(url, 'POST', expected, {'Content-Length': '0'}) # Good request case, there's a content-length header for PUT test(url, 'PUT', expected, {'Content-Length': '0'}) # Bad request case, no content-length for POST test_status(url, 'POST', '400') # Bad request case, no content-length for PUT test_status(url, 'PUT', '400') if status != 0: print('Failures encountered.') pipe.terminate() exit(status) open(argv[len(argv) - 1], 'w').close() print('All tests pass.') pipe.terminate() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/message_test.cpp000066400000000000000000000125001240331347200247550ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE message test #include #include #include #include #include using namespace boost::network; typedef boost::mpl::list tag_types; struct string_header_name { static std::string string; }; std::string string_header_name::string = "Header"; struct wstring_header_name { static std::wstring string; }; std::wstring wstring_header_name::string = L"Header"; struct string_header_value { static std::string string; }; std::string string_header_value::string = "Value"; struct wstring_header_value { static std::wstring string; }; std::wstring wstring_header_value::string = L"Value"; template struct header_name : string_header_name {}; template <> struct header_name : wstring_header_name {}; template struct header_value : string_header_value {}; template <> struct header_value : wstring_header_value {}; struct string_body_data { static std::string string; }; std::string string_body_data::string = "The quick brown fox jumps over the lazy dog."; struct wstring_body_data { static std::wstring string; }; std::wstring wstring_body_data::string = L"The quick brown fox jumps over the lazy dog."; template struct body_data : string_body_data {}; template <> struct body_data : wstring_body_data {}; struct string_source_data { static std::string string; }; std::string string_source_data::string = "Source"; struct wstring_source_data { static std::wstring string; }; std::wstring wstring_source_data::string = L"Source"; template struct source_data : string_source_data {}; template <> struct source_data : wstring_body_data {}; struct string_destination_data { static std::string string; }; std::string string_destination_data::string = "Destination"; struct wstring_destination_data { static std::wstring string; }; std::wstring wstring_destination_data::string = L"Destination"; template struct destination_data : string_destination_data {}; template <> struct destination_data : wstring_destination_data {}; /** * Defines a set of template functions that can be used to test * generic code. */ BOOST_AUTO_TEST_CASE_TEMPLATE(copy_constructor_test, T, tag_types) { basic_message instance; instance << header(header_name::string, header_value::string); basic_message copy(instance); BOOST_CHECK_EQUAL(headers(copy).count(header_name::string), static_cast(1)); typename headers_range >::type range = headers(copy)[header_name::string]; BOOST_CHECK(boost::begin(range) != boost::end(range)); } BOOST_AUTO_TEST_CASE_TEMPLATE(swap_test, T, tag_types) { basic_message instance; instance << header(header_name::string, header_value::string); basic_message other; swap(instance, other); BOOST_CHECK_EQUAL(headers(instance).count(header_name::string), static_cast(0)); BOOST_CHECK_EQUAL(headers(other).count(header_name::string), static_cast(1)); } BOOST_AUTO_TEST_CASE_TEMPLATE(headers_directive_test, T, tag_types) { basic_message instance; instance << header(header_name::string, header_value::string); BOOST_CHECK_EQUAL(headers(instance).count(header_name::string), static_cast(1)); typename headers_range >::type range = headers(instance)[header_name::string]; BOOST_CHECK(boost::begin(range) != boost::end(range)); } BOOST_AUTO_TEST_CASE_TEMPLATE(body_directive_test, T, tag_types) { basic_message instance; instance << ::boost::network::body(body_data::string); typename string::type body_string = body(instance); BOOST_CHECK(body_string == body_data::string); } BOOST_AUTO_TEST_CASE_TEMPLATE(source_directive_test, T, tag_types) { basic_message instance; instance << ::boost::network::source(source_data::string); typename string::type source_string = source(instance); BOOST_CHECK(source_string == source_data::string); } BOOST_AUTO_TEST_CASE_TEMPLATE(destination_directive_test, T, tag_types) { basic_message instance; instance << destination(destination_data::string); BOOST_CHECK(destination(instance) == destination_data::string); } BOOST_AUTO_TEST_CASE_TEMPLATE(remove_header_directive_test, T, tag_types) { basic_message instance; instance << header(header_name::string, header_value::string) << remove_header(header_name::string); typename headers_range >::type range = headers(instance); BOOST_CHECK(boost::begin(range) == boost::end(range)); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/message_transform_test.cpp000066400000000000000000000023131240331347200270510ustar00rootroot00000000000000 // Copyright Dean Michael Berris 2007. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE message test #include #include #include #include BOOST_AUTO_TEST_CASE(message_transform_toupper) { using namespace boost::network; message msg; msg << source("me"); BOOST_CHECK_EQUAL(source(msg), "me"); msg << transform(to_upper_, source_); BOOST_CHECK_EQUAL(source(msg), "ME"); msg << destination("you"); BOOST_CHECK_EQUAL(destination(msg), "you"); msg << transform(to_upper_, destination_); BOOST_CHECK_EQUAL(destination(msg), "YOU"); } BOOST_AUTO_TEST_CASE(message_transform_tolower) { using namespace boost::network; message msg; msg << source("ME"); BOOST_CHECK_EQUAL(source(msg), "ME"); msg << transform(to_lower_, source_); BOOST_CHECK_EQUAL(source(msg), "me"); msg << destination("YOU"); BOOST_CHECK_EQUAL(destination(msg), "YOU"); msg << transform(to_lower_, destination_); BOOST_CHECK_EQUAL(destination(msg), "you"); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/000077500000000000000000000000001240331347200230765ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/boost.jpg000066400000000000000000000107061240331347200247320ustar00rootroot00000000000000ÿØÿàJFIF``ÿáHExifII*1&8Adobe ImageReady †ȯÿÛC    $.' ",#(7),01444'9=82<.342ÿÛC  2!!22222222222222222222222222222222222222222222222222ÿÀV"ÿÄ ÿĵ}!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúÿÄ ÿĵw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÚ ?÷ú(¢€ ) ¦– fŒÔ{¨Ý@ÑL N€Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š) 5BïŠ{šÊÕo…•«8?¼o•¿¯áU9ÉE)(«²GÕlÒF®e8 )<þTèµY¤Ç8.ÝÒ3\j¾NsZšU¿Ún7DqüÌGè+ÑžœcvÎ(âjJVHêUêPÕP·ÍÉU=Æêz¿8ìkÎågo2-ƒKš…_5(5%¯›µ›¿·k—÷yÈšáÜ} ~•ô³wö þï80Û»Œz…8ýkæêéíمg²>‡ð­§Ø¼+¥ÀF[£0ô,7ÔÖÅxÒ|V×#cK=4*€ÉÀð:š‹ZºÊ Å…Œ‘÷XáüËåPèÍ»”ªÅhzý— kÖ~"ÓVöÍŽ3¶HÛïFÞ†´¤‘"¤‘ÕFY˜àêMdÓNÌÕ;ê:Šàµ¯ŠZm“´:l |ãƒ!;#CŒŸËñ®nO‹ZÑ|Çe§ªú29?žáV©Mô3u"a¢¼ÇLø¶UMON„ó-»goüÿz5õ¶¥gÝœË4 «©ëS(J;•)lX¢›$‰m$Ž¨Š2ÌÇRk„Ö¾)i¶NÐé°5óŽ „ìŒ}2/ƈÅËa¹%¹ÞÑ^='Å­h¾c²ÓÕ}ŸÏp­=3âØiU5=8"̶í¿ðþ5nŒÈUbzu^ÆúÛR³ŽîÎeš UÔõ®cÅÞ;¶ðÜ‚Ò…ÍñŠÂÆMÇ×Ú¡E·d[’Jìëè¯?uÜœYéØí˜ßÿ‹£þνÿ>šoýûþ.´ö#ÚÄö:+Íü%ãígÄ"‚Â{{•šF0IË׊~"êzGˆnôë(,Úv¨y‹d¨'£Á>ª}”¯aûHÚçŸøŠïíÞ$Ô®s÷.WýÜ?LWºxVÓì^Òà# -јzêkç‚I$“’z“^añ;]šæÚÎ+=5CºÄ G' 㮊°m$ŒiÉ&Û=~Š(®3¤(¢Š)¤Ó©Œh) cêö_mµ!fæOQZ’¶sÚ†¿¥ã@° Š}æߌN•µÍÎðèeYÅFÒ3K¿md®†%M+Où°Jrßí9íYKâU=lÿò)ÿ Ѿ€_iàÀK`y±´;­vÔ”äãŠÈæ‚ŠMÃVcZYG9f9&¦†VŠEt8e9E§F®¹GKwÖç]o2ÏÊ·¡î*ÒšÌÒàhmbs!ÝAZi^-T”ÚG­I·ÙÌüD»û/‚¯8i™"‹@kÊ<§Eªø®ÂÒxij–‘OBª¤óùWwñnïf™§Yç™&iHÿtcÿg¬?…žw‰..Hù`¶8?í1~«h{´›3žµ=þÏÐÛþù¯3ø…á;oÜÛÝi॥ÆTÄXŒ= ç#^Ó^[ñkT‰ÞÇKƒI3Jû¹QüÏåëYÒ”œ‹©ÊPøOy$~!º´ùS[–#?Ĥ`þDþt¿¼Q-æ¤ú-´…m-Î&ÚÖIè}‡§®}ªo„º{Iª_j$‘D!Sس@¿­pz„­q©]Lç/$Îì}É&¶QN£}Œ›j G‚<|Hïwvï„M´ìûÒ7\Aê}ÿ/Lÿ„Ã?gò²¢ÛŒnÜÛ¿ï¬æE^ ÓDXÃFYˆîÅŽZè« •$äm$ñŸ‡ÃZßÙ¡v{iPK n d‚¸#ùWUð“P›Ï¿Ó™‰‡`AþœÏ#ò¬¯Š:Š^x¡m£`VÒï’Xþ„VÇÂ;Σ¨°ù0°!õ?y¿öZÚNô®Ì¢­SC?âWŠ%¼ÔŸE¶­¥¹ÄÛOúÉ=°ôõϵQðG‚‰îîÝâ°‰¶ŸzFëè=O¿åËêµÆ¥u3œ¼“;±÷$š÷OE^ ÓDXÃFYˆîÅŽZ&ýœ,‚>üîÃþO ýŸÉþÊ‹n1»snÿ¾³šòOøq|5­ýšg¶•°–êH û‚?•{íx¿ÅE/§ï7þËV—c/g§YÛÈF7áǦ@®OÇú>iáÍCRû?m‘” qónf?–k?áN±wsæ™<$0*¼%ŽJH+ôéV>-]ùz•  ® ‘êOõaP¢ÕK\¦Ó…Ï>ðv«â» IãBÎZE= ª“Ïå^Ó„´ kˆç‡J·Ic`èÁyV ךü(´ó¼IqrG˱Áÿiˆô ^ÇN´Ÿ5©ErÜ(¢ŠÀØ(¢Š Fõ!¨ØPN±xÖ6Ϋ–P6ýOšóí嘳Xœ’{צ]B³Dèë¹Xaê yÍý›é÷²[¿ «y{ôpRšêqbSº}«WKáË·u{S“°yˆ}=Erêk·Ñ4ÿ±ØÃK†oA[b¥NÌ΄[ž„W"ÍpòÅ0\çaRp{Ó ÐÂJ­$ÛЕy­•Ž¥T®­Ôµ®u}^½†ª÷©”Pžsž;ñ^ïÍñµ°?,àŸ÷˜“ü€¬O x¶ëÂßiû-´»Œ¹ãnqŒzöKÁº¯|÷·ÖuÀüé8 ªŸð®ü+ÿ@¿ü˜—ÿŠ®…V¼­:ræº8Iþ+ëRBÉ­œ.z8Vb>€œW+ie©ø›W)Ésw;nwnެǰ¯f<*?Ù]=n%ÿâ«sOÒìt¨<› H­ã<‘ã'Ü÷ühö°Š÷PýœŸÄʾÐàðö „'q_šI1îzŸóØ ñOh3è:ýÄn‡ìó9’ 1Ã)9ÇÔgÿ¯_@U{Û MJÙ­ïmãžÕ$\¯±¬áQÅÝ—8)+3á/\ønØÙMoö«=Å‘CmhÉëƒÜ{VÖ©ñjImš=3O0ÊÃiœ6ߢüÏá]ÿ ¼73–Hn!ÉéÇøöiö¿ |5lášÚYÈÿž²œ~C£&ïbj%kžK£èºŸŠ5FŽÝZGvß4ï÷W'’Çü“^ñ¢iú“Ÿm’‘Xõv=Iúšµigmcn¶öG+Ñ#P£ô©«:•ý „9OŸüa Ï ë÷º³ÌæH$Ç ¤çQœþ½ixKÇ×>¶6S[ýªÏqdPÛZ2zà÷Õì׶š•³[ÞÛÇ<'ªH¹_c\´ÿ ¼73–Hn!ÉéÇøökEV.6š!Ó’w‰ÎjŸ¤–Ù£Ó4ó ¬0&™Ãmú(ÌþÅèú.§âQ£·V‘Ý·Í;ýÕÉä±ÿ$×­Zü5ðÕ³†kig#þzÊqù WQigmcn¶öG+Ñ#P£ô£ÚÆ+ÜCör“÷™ƒ<–~ðx1ÄfŽßjíÎÖ•Ù†N W3ÿ zßþ€òÿßñÿÄ×{ªi6:ÕŸÙ5|è7Ù½—‘Ó• Ö'ü+¿ ÿÐ/ÿ&%ÿâª#(}­Ê’—Ù9ßø[Öÿô—þÿþ&¸¯øªãÅ7±K$+0©X¢ »êIîNå^¯ÿ ï¿ô ÿɉøª·aàßi“‰ít¸–U9Vvi>£q8«S§R%ÂoFÌ?†ž›IÒæ¾»ŒÇqy·j0åc3èNsùVOÅëyˆÒî“ùˆ[°c´ÌùW§Ô7vv÷öÏmwM Œ28È5š©ïó2Ü=ÞTx'…¼Sqáké'†ž)”,‘1ÆqЃØÿ{/…|BÞ&ÒZý¬þʦ5O3~àç8É…T?<*I'JúO(ÿÙ«oLÒìô{%³°‡É·RHMŹ''’Iª©8KTµ&”wz(¢ŠÄÔ(¢Š)¤S¨ Yj¬–‘HÙtV>ê ^"›¶šml&“(‹(ç”÷Àÿ ²‘â¥ÛJ†ÛÜKa¡iàRâ–ÄÅ-P=n¾~¹8Ô"Ô «qþŽẄÀr¿)Ï9ÏÒ·äßå?•·ÌÚvîéžÙö§QM»‰#3E—Ù¤}H¦÷‘™AFã€sÛÅ.·ý¢l é¥ÌÁI ä@Èúuü+JŠ/­ÂÚXd>o’žqC.>m€ŸlÓè¢Ì¿ý£û!ŲLÎdw’ p»ÁlÏLô«Ö·+w•#™8ı”oÈŒÔÔS¾–S&éneñ.žJ-¡ŠY$aŒÇ = êqRëÍ:èwŸfš=‹å)fã xÎx­(¾ÁcšðÌ7BòöYc¸Š¨‘¬†P¬y,@–ÏAéWõè®®m­í­Cn–uÀ°  9+‚ukZŠnZÜ-¥Œ ZÝÛ­ó]™•ŒÛ.Qñ”g$ÝsšˆMýÄiaa äÈ Ë,gfÕcÆIǾ­Ê(æÖám,RÒ%šm"Ñîcxç1(‘d0`0r½sÞ µÔîn¯î-ã•£†8ãU¥VîY+ÄnŠë¨¡JÎàÕÕˆ,¢h,`‰æy™#U28Ã1©÷ªBܵö«=À•UîvD²ÅP2 ö'<Žµ­E+…Ž{Åü›(íVclÎÆà®OågÍ‚sÒ´ôxŒZ\!••ŽX†ßžOûd°üjõ_Kµ¹Êx–;§Ô7À÷r*C…·X'1–Îsº6^{sÒº5dM2ÙeˆÅ'–»Ð¹m§Œ’IüMZ¢›•Õ-nQEHŠ( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( Š( ÿÙcpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/certificate.pem000066400000000000000000000013651240331347200260700ustar00rootroot00000000000000-----BEGIN CERTIFICATE----- MIICAzCCAWwCCQDVrANJOmGIcjANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJB VTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0 cyBQdHkgTHRkMCAXDTA5MTIxNzIzMTcwN1oYDzE5MTcwMzExMTAyMDM1WjBFMQsw CQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJu ZXQgV2lkZ2l0cyBQdHkgTHRkMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCw c3j9E+LMKqw2PBf/a5zLIAfNxDadFW2OB3S85kXgr72x/00oi5JiPOeA7LGrmhuJ +nDXiO+AWL1O6fOzOkyTd0Nh1hCHJzjrJEfIt3iqdQGHiocVupWN5iCQRzCrErbP vtvvs/r7mMheb9W3q9lntKPwiZ7mmr/daYdAbVuQpQIDAQABMA0GCSqGSIb3DQEB BQUAA4GBAHz1OhxKYSc5kYmgkMYYwtmHFWWTL2jy6xk4+yv5sGAmze4dvtQqCNiA TaljCHWdAkHaXXBzbZ7+e3qem2M1Y31HqO0ZiQezpJ1TFLPc5/0uNX8JIPovb+s7 c/wevNe16tw4dhM0DQ2V3FH8AwiQANUtZ8yFk91RH4rTaQBQDYOE -----END CERTIFICATE----- cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/cgi-bin/000077500000000000000000000000001240331347200244065ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/cgi-bin/cgisupport.py000077500000000000000000000022361240331347200271650ustar00rootroot00000000000000#!/usr/bin/python # # Copyright Kim Grasman 2008. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http:#www.boost.org/LICENSE_1_0.txt) # class http_headers: def __init__(self, header_str): self.parse(header_str) def raw_headers(self): return self.raw def iteritems(self): return self.headers.iteritems() def value(self, name): return self.headers[name] def parse(self, header_str): self.raw = header_str self.headers = self.__parse_headers(header_str) def __parse_headers(self, str): dict = {} # I'm sure there are better ways to do this in Python, # but I don't know my way around so well lines = str.split('\n') for line in lines: header = line.split(': ') if len(header) > 0: name = header[0] if len(header) > 1: value = ': '.join(header[1:]) # re-join the rest of the items as value if len(name) > 0: dict[name] = value return dict cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/cgi-bin/echo_body.py000077500000000000000000000013011240331347200267110ustar00rootroot00000000000000#!/usr/bin/python # # Copyright Divye Kapoor 2008. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http:#www.boost.org/LICENSE_1_0.txt) # # This program sets up a CGI application on localhost # It can be accessed by http://localhost:8000/cgi-bin/echo_form.py # It returns the query parameters passed to the CGI Script as plain text. # import cgitb; cgitb.enable() # for debugging only import cgi import os, sys sys.stdout.write( "Content-type: text/plain; charset=us-ascii\r\n\r\n" ) sys.stdout.write( "\r\n" ) # POST data/form data is available in the .value property sys.stdout.write( cgi.FieldStorage().value ) cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/cgi-bin/echo_headers.py000077500000000000000000000011521240331347200273730ustar00rootroot00000000000000#!/usr/bin/python # # Copyright Kim Grasman 2008. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http:#www.boost.org/LICENSE_1_0.txt) # # This program sets up a CGI application on localhost # It can be accessed by http://localhost:8000/cgi-bin/echo_headers.py # import cgi import os, sys import cgisupport sys.stdout.write( "Content-type: text/plain; charset=us-ascii\r\n\r\n" ) sys.stdout.write( "\r\n" ) hdrs = cgisupport.http_headers(os.environ.get('HTTP_ALL_HEADERS')) for h,v in hdrs.iteritems(): print h + ": " + v cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/cgi-bin/multiline-header.py000077500000000000000000000024161240331347200302160ustar00rootroot00000000000000#!/usr/bin/python # # Copyright Divye Kapoor 2008. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http:#www.boost.org/LICENSE_1_0.txt) # # This program sets up a CGI application on localhost # It can be accessed by http://localhost:8000/cgi-bin/requestinfo.py # It returns the query parameters passed to the CGI Script as plain text. # import cgitb; cgitb.enable() # for debugging only import cgi import os, sys print "X-CppNetlib-Test: multi-line-header\r\n" print " that-should-concatenate\r\n" print "Content-type: text/plain; charset=us-ascii\r\n\r\n" print "\r\n" form = cgi.FieldStorage() qstring = "" qstring_dict = {} if os.environ.has_key("QUERY_STRING"): qstring = os.environ["QUERY_STRING"] try: qstring_dict = cgi.parse_qs(qstring,1,1) # parse_qs(query_string,keep_blanks,strict_parsing) except ValueError: print "Error parsing query string." print "Query string:", qstring print "GET parameters:", for i in qstring_dict.keys(): print i,"-",qstring_dict[i],";", print # Remove GET params and print only the POST ones print "POST parameters:", for i in form.keys(): if i not in qstring_dict.keys(): print i,"-",form.getfirst(i, ""),";", print cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/cgi-bin/requestinfo.py000077500000000000000000000032221240331347200273260ustar00rootroot00000000000000#!/usr/bin/python # # Copyright Divye Kapoor 2008. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http:#www.boost.org/LICENSE_1_0.txt) # # This program sets up a CGI application on localhost # It can be accessed by http://localhost:8000/cgi-bin/requestinfo.py # It returns the query parameters passed to the CGI Script as plain text. # import cgitb; cgitb.enable() # for debugging only import cgi import os, sys sys.stdout.write( "HTTP/1.0 200 Requestinfo.py Output follows\r\n" ) sys.stdout.write( "Content-type: text/plain; charset=us-ascii\r\n\r\n" ) sys.stdout.write( "\r\n" ) form = cgi.FieldStorage() qstring = "" qstring_dict = {} print "Headers: ",form.headers if os.environ.has_key("QUERY_STRING"): qstring = os.environ["QUERY_STRING"] try: qstring_dict = cgi.parse_qs(qstring,1,1) # parse_qs(query_string,keep_blanks,strict_parsing) except ValueError: print "Error parsing query string." print "Query string:", qstring print "GET parameters:", for i in qstring_dict.keys(): print i,"-",qstring_dict[i],";", print # Remove GET params and print only the POST ones print "POST parameters:", try: for i in form.keys(): if i not in qstring_dict.keys(): print i,"-",form.getfirst(i, ""),";", print except TypeError: # In case of empty POST bodies. pass print 'HTTP HEADERS-------------------' print 'Content-Type:', os.environ.get('CONTENT_TYPE') print 'Content-Length:', os.environ.get('CONTENT_LENGTH') for k in os.environ.keys(): if k.startswith('HTTP_'): print k, ':', os.environ[k] cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/cgi_server.py000066400000000000000000000016641240331347200256070ustar00rootroot00000000000000#!/usr/bin/python # # Copyright Divye Kapoor 2008. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http:#www.boost.org/LICENSE_1_0.txt) # # This program sets up a CGI HTTP Server at port 8000 on localhost # It will be used to test the http::client interface of the library import CGIHTTPServer import BaseHTTPServer import threading from threading import Thread, Event stop_serving = Event() server_thread = None def run(server_class=BaseHTTPServer.HTTPServer, handler_class=CGIHTTPServer.CGIHTTPRequestHandler): server_address = ('',8000) httpd = server_class(server_address, handler_class) while not stop_serving.isSet(): httpd.handle_request() def start_server(): server_thread = Thread(None, run, "HTTP Server",(), None, None) server_thread.start() server_thread.join() if __name__ == '__main__': start_server() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/http_test_server.py000066400000000000000000000020671240331347200270610ustar00rootroot00000000000000#!/usr/bin/env python # # Copyright Allister Levi Sanchez 2008. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # # This program sets up a CGI HTTP Server at port 8000 on localhost # It will be used to test the http::client interface of the library import BaseHTTPServer import CGIHTTPServer import os class HttpTestHandler(CGIHTTPServer.CGIHTTPRequestHandler): def run_cgi(self): """Version of run_cgi that provides more HTTP headers.""" headers_str = '' for a in self.headers.items(): headers_str += "%s: %s\n" % a os.environ['HTTP_ALL_HEADERS'] = headers_str # run the rest of run_cgi CGIHTTPServer.CGIHTTPRequestHandler.run_cgi(self) def run_server(server_class=BaseHTTPServer.HTTPServer, handler_class=HttpTestHandler): server_address = ('',8000) httpd = server_class(server_address, handler_class) httpd.serve_forever() if __name__ == '__main__': run_server() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/https_test_server.py000066400000000000000000000031711240331347200272410ustar00rootroot00000000000000#!/usr/bin/env python # Copyright 2009 Jeroen Habraken # Copyright 2009 Dean Michael Berris # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) import socket from BaseHTTPServer import HTTPServer from SimpleHTTPServer import SimpleHTTPRequestHandler from CGIHTTPServer import CGIHTTPRequestHandler from OpenSSL import SSL import os class SecureHTTPServer(HTTPServer): def __init__(self, server_address, HandlerClass): HTTPServer.__init__(self, server_address, HandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file ("key.pem") ctx.use_certificate_file("certificate.pem") self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() class SecureHTTPRequestHandler(CGIHTTPRequestHandler): def setup(self): self.connection = self.request self.rfile = socket._fileobject(self.request, "rb", self.rbufsize) self.wfile = socket._fileobject(self.request, "wb", self.wbufsize) def run_cgi(self): """Version of run_cgi that provides more HTTP headers.""" headers_str = '' for a in self.headers.items(): headers_str += "%s: %s\n" % a os.environ['HTTP_ALL_HEADERS'] = headers_str # run the rest of run_cgi CGIHTTPRequestHandler.run_cgi(self) if __name__ == '__main__': SecureHTTPServer(('127.0.0.1', 8443), SecureHTTPRequestHandler).serve_forever() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/key.pem000066400000000000000000000015671240331347200244020ustar00rootroot00000000000000-----BEGIN RSA PRIVATE KEY----- MIICXAIBAAKBgQCwc3j9E+LMKqw2PBf/a5zLIAfNxDadFW2OB3S85kXgr72x/00o i5JiPOeA7LGrmhuJ+nDXiO+AWL1O6fOzOkyTd0Nh1hCHJzjrJEfIt3iqdQGHiocV upWN5iCQRzCrErbPvtvvs/r7mMheb9W3q9lntKPwiZ7mmr/daYdAbVuQpQIDAQAB AoGBAIJ7MXn8TZdq6uRENf7ERjMTIZIwya4JnXUM4G+b3QqVCrLottcHtxz8Krl0 zsG1+S1kTDOmaG1BseP8LyFXOC4Ni8H6vjnFG/vTzuArPhtoB9B5wXDnPfPQH22a 10XH3aGbOoyP9sg0HF0ZJsnou3QgQfg49whWa8gl8SUSckI1AkEA4NFwJ7GpVmIA ZuVzguKEKNNxC9PNUDeGUCyjH5fejolL2wIQQ4rKpml05TbUuugQByxBi+Gbd51j hGeFOncVywJBAMjsrWoOyGpDJIe2H0Aklecp9awn2H59GFNBmDvUO6LAAkr5Dkky 64QGLCZLAdswH9QaMuBvzKSZkzGcfDKwpU8CQBxTJt9Jaf1hMY3FQO1vnpkKMsb7 s3V02W5GgXLcjoTE1ZLNSsFHvkqDJOAwLVMzI7nToJqAHTdP1Bb9d/KqyEsCQA0x /fGJJwBTiIKhI0xDGtUjnE7CDyW/cWmGVUkYlxIJKh1iXd3QykbRYPTi2Cxc7Lox PkYfEYF91Hzdmgp6L2ECQFcCg0qKfvy1YeTChrDFMBrZx4yoqYGBnqEqxshksAJg o1r5HVSlO71aVgeAs/5DD4IIb2OyiJE/dv6t0L8TQeQ= -----END RSA PRIVATE KEY----- cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/server/test.xml000066400000000000000000000001611240331347200245750ustar00rootroot00000000000000 Hi! This is node 1 Node 2 here. cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/uri/000077500000000000000000000000001240331347200223675ustar00rootroot00000000000000cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/uri/CMakeLists.txt000066400000000000000000000025661240331347200251400ustar00rootroot00000000000000# Copyright (c) Dean Michael Berris 2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) include_directories(${CPP-NETLIB_SOURCE_DIR}) if (Boost_FOUND) set( TESTS uri_test uri_builder_test uri_builder_stream_test uri_encoding_test relative_uri_test ) foreach (test ${TESTS}) if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU) set_source_files_properties(${test}.cpp PROPERTIES COMPILE_FLAGS "-Wall") endif() add_executable(cpp-netlib-${test} ${test}.cpp) add_dependencies(cpp-netlib-${test} cppnetlib-uri) target_link_libraries(cpp-netlib-${test} ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-uri) if (OPENSSL_FOUND) target_link_libraries(cpp-netlib-${test} ${OPENSSL_LIBRARIES}) endif() if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU AND ${CMAKE_SYSTEM_NAME} MATCHES "Windows") target_link_libraries(cpp-netlib-${test} ws2_32) endif() set_target_properties(cpp-netlib-${test} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/tests) add_test(cpp-netlib-${test} ${CPP-NETLIB_BINARY_DIR}/tests/cpp-netlib-${test}) endforeach (test) endif() cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/uri/relative_uri_test.cpp000066400000000000000000000011411240331347200266210ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE Relative URL Test #include #include #include #include using namespace boost::network; BOOST_AUTO_TEST_CASE(relative_uri_test) { // don't yet support relative URIs uri::uri instance("example.com"); BOOST_REQUIRE(!uri::valid(instance)); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/uri/uri_builder_stream_test.cpp000066400000000000000000000104311240331347200300110ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE URI builder stream test #include #include #include #include #include using namespace boost::network; BOOST_AUTO_TEST_CASE(builder_test) { uri::uri instance; instance << uri::scheme("http") << uri::host("www.example.com") << uri::path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/", instance.string()); } BOOST_AUTO_TEST_CASE(full_uri_builder_test) { uri::uri instance; instance << uri::scheme("http") << uri::user_info("user:password") << uri::host("www.example.com") << uri::port("80") << uri::path("/path") << uri::query("query") << uri::fragment("fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL( "http://user:password@www.example.com:80/path?query#fragment", instance.string()); } BOOST_AUTO_TEST_CASE(port_test) { uri::uri instance; instance << uri::scheme("http") << uri::host("www.example.com") << uri::port(8000) << uri::path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com:8000/", instance.string()); } BOOST_AUTO_TEST_CASE(encoded_path_test) { uri::uri instance; instance << uri::scheme("http") << uri::host("www.example.com") << uri::port(8000) << uri::encoded_path("/Path With (Some) Encoded Characters!"); ; BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL( "http://www.example.com:8000/" "Path%20With%20%28Some%29%20Encoded%20Characters%21", instance.string()); } BOOST_AUTO_TEST_CASE(query_test) { uri::uri instance; instance << uri::scheme("http") << uri::host("www.example.com") << uri::path("/") << uri::query("key", "value"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/?key=value", instance.string()); } BOOST_AUTO_TEST_CASE(query_2_test) { uri::uri instance; instance << uri::scheme("http") << uri::host("www.example.com") << uri::path("/") << uri::query("key1", "value1") << uri::query("key2", "value2"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/?key1=value1&key2=value2", instance.string()); } BOOST_AUTO_TEST_CASE(fragment_test) { uri::uri instance; instance << uri::scheme("http") << uri::host("www.example.com") << uri::path("/") << uri::fragment("fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/#fragment", instance.string()); } BOOST_AUTO_TEST_CASE(from_base_test) { uri::uri base_uri("http://www.example.com"); uri::uri instance; instance << base_uri << uri::path("/") << uri::fragment("fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/#fragment", instance.string()); } BOOST_AUTO_TEST_CASE(scheme_http_test) { uri::uri instance; instance << uri::schemes::http << uri::host("www.example.com") << uri::path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/", instance.string()); } BOOST_AUTO_TEST_CASE(scheme_https_test) { uri::uri instance; instance << uri::schemes::https << uri::host("www.example.com") << uri::path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("https://www.example.com/", instance.string()); } BOOST_AUTO_TEST_CASE(encoded_null_char_test) { // there is a potential bug in the way we process ranges if the // strings are null terminated. uri::uri instance; instance << uri::scheme("http") << uri::host("www.example.com") << uri::encoded_path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/", instance.string()); } BOOST_AUTO_TEST_CASE(mailto_builder_test) { uri::uri instance; instance << uri::scheme("mailto") << uri::path("cpp-netlib@example.com"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("mailto:cpp-netlib@example.com", instance.string()); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/uri/uri_builder_test.cpp000066400000000000000000000105251240331347200264420ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE URI builder test #include #include #include #include using namespace boost::network; BOOST_AUTO_TEST_CASE(builder_test) { uri::uri instance; uri::builder builder(instance); builder.scheme("http").host("www.example.com").path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/", instance.string()); } BOOST_AUTO_TEST_CASE(full_uri_builder_test) { uri::uri instance; uri::builder builder(instance); builder.scheme("http") .user_info("user:password") .host("www.example.com") .port("80") .path("/path") .query("query") .fragment("fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL( "http://user:password@www.example.com:80/path?query#fragment", instance.string()); } BOOST_AUTO_TEST_CASE(port_test) { uri::uri instance; uri::builder(instance).scheme("http").host("www.example.com").port(8000).path( "/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com:8000/", instance.string()); } BOOST_AUTO_TEST_CASE(encoded_path_test) { uri::uri instance; uri::builder builder(instance); builder.scheme("http").host("www.example.com").port(8000).encoded_path( "/Path With (Some) Encoded Characters!"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL( "http://www.example.com:8000/" "Path%20With%20%28Some%29%20Encoded%20Characters%21", instance.string()); } BOOST_AUTO_TEST_CASE(query_test) { uri::uri instance; uri::builder builder(instance); builder.scheme("http").host("www.example.com").path("/").query("key", "value"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/?key=value", instance.string()); } BOOST_AUTO_TEST_CASE(query_2_test) { uri::uri instance; uri::builder builder(instance); builder.scheme("http") .host("www.example.com") .path("/") .query("key1", "value1") .query("key2", "value2"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/?key1=value1&key2=value2", instance.string()); } BOOST_AUTO_TEST_CASE(fragment_test) { uri::uri instance; uri::builder builder(instance); builder.scheme("http").host("www.example.com").path("/").fragment("fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/#fragment", instance.string()); } BOOST_AUTO_TEST_CASE(from_base_test) { uri::uri instance("http://www.example.com"); uri::builder builder(instance); builder.path("/").fragment("fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/#fragment", instance.string()); } BOOST_AUTO_TEST_CASE(encoded_null_char_test) { // there is a potential bug in the way we process ranges if the // strings are null terminated. uri::uri instance; uri::builder builder(instance); builder.scheme("http").host("www.example.com").encoded_path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://www.example.com/", instance.string()); } BOOST_AUTO_TEST_CASE(mailto_builder_test) { uri::uri instance; uri::builder builder(instance); builder.scheme("mailto").path("cpp-netlib@example.com"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("mailto:cpp-netlib@example.com", instance.string()); } BOOST_AUTO_TEST_CASE(ipv4_address) { using namespace boost::asio::ip; uri::uri instance; uri::builder builder(instance); builder.scheme("http").host(address_v4::loopback()).path("/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL("http://127.0.0.1/", instance.string()); } // BOOST_AUTO_TEST_CASE(ipv6_address) { // using namespace boost::asio::ip; // uri::uri instance; // uri::builder builder(instance); // builder // .scheme("http") // .host(address_v6::loopback()) // .path("/") // ; // BOOST_REQUIRE(uri::valid(instance)); // BOOST_CHECK_EQUAL("http://[::1]/", instance.string()); //} cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/uri/uri_encoding_test.cpp000066400000000000000000000020021240331347200265710ustar00rootroot00000000000000// Copyright (c) Glyn Matthews 2011. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE URL encoding test #include #include #include #include #include using namespace boost::network; BOOST_AUTO_TEST_CASE(encoding_test) { const std::string unencoded(" !\"#$%&\'()*"); const std::string encoded("%20%21%22%23%24%25%26%27%28%29%2A"); std::string instance; uri::encode(unencoded, std::back_inserter(instance)); BOOST_CHECK_EQUAL(instance, encoded); } BOOST_AUTO_TEST_CASE(decoding_test) { const std::string unencoded(" !\"#$%&\'()*"); const std::string encoded("%20%21%22%23%24%25%26%27%28%29%2A"); std::string instance; uri::decode(encoded, std::back_inserter(instance)); BOOST_CHECK_EQUAL(instance, unencoded); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/uri/uri_test.cpp000066400000000000000000000465331240331347200247440ustar00rootroot00000000000000// Copyright 2009, 2010, 2011 Dean Michael Berris, Jeroen Habraken, Glyn // Matthews. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt of copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE URL Test #include #include #include #include #include #include #include #include #include #include using namespace boost::network; BOOST_AUTO_TEST_CASE(basic_uri_scheme_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); } BOOST_AUTO_TEST_CASE(basic_uri_user_info_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::user_info(instance), ""); } BOOST_AUTO_TEST_CASE(basic_uri_host_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::host(instance), "www.example.com"); } BOOST_AUTO_TEST_CASE(basic_uri_port_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::port(instance), ""); } BOOST_AUTO_TEST_CASE(basic_uri_path_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::path(instance), "/"); } BOOST_AUTO_TEST_CASE(basic_uri_query_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::query(instance), ""); } BOOST_AUTO_TEST_CASE(basic_uri_fragment_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::fragment(instance), ""); } BOOST_AUTO_TEST_CASE(basic_uri_value_semantics_test) { uri::uri original; uri::uri assigned; assigned = original; BOOST_CHECK(original == assigned); assigned = "http://www.example.com/"; BOOST_CHECK(original != assigned); uri::uri copy(assigned); BOOST_CHECK(copy == assigned); } BOOST_AUTO_TEST_CASE(basic_uri_range_scheme_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.scheme_range()); BOOST_CHECK(instance.begin() == boost::begin(instance.scheme_range())); BOOST_CHECK(boost::equal(instance.scheme_range(), boost::as_literal("http"))); } BOOST_AUTO_TEST_CASE(basic_uri_range_user_info_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(!instance.user_info_range()); BOOST_CHECK(boost::begin(instance.host_range()) == boost::begin(instance.user_info_range())); BOOST_CHECK(boost::begin(instance.host_range()) == boost::end(instance.user_info_range())); } BOOST_AUTO_TEST_CASE(basic_uri_range_host_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.host_range()); BOOST_CHECK(boost::equal(instance.host_range(), boost::as_literal("www.example.com"))); } BOOST_AUTO_TEST_CASE(basic_uri_range_port_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(!instance.port_range()); BOOST_CHECK(boost::end(instance.host_range()) == boost::begin(instance.port_range())); BOOST_CHECK(boost::end(instance.host_range()) == boost::end(instance.port_range())); } BOOST_AUTO_TEST_CASE(basic_uri_range_path_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.path_range()); BOOST_CHECK(boost::equal(instance.path_range(), boost::as_literal("/"))); BOOST_CHECK(instance.end() == boost::end(instance.path_range())); } BOOST_AUTO_TEST_CASE(basic_uri_range_query_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(!instance.query_range()); BOOST_CHECK(instance.end() == boost::begin(instance.query_range())); BOOST_CHECK(instance.end() == boost::end(instance.query_range())); } BOOST_AUTO_TEST_CASE(basic_uri_range_fragment_test) { uri::uri instance("http://www.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(!instance.fragment_range()); BOOST_CHECK(instance.end() == boost::begin(instance.fragment_range())); BOOST_CHECK(instance.end() == boost::end(instance.fragment_range())); } BOOST_AUTO_TEST_CASE(full_uri_scheme_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); } BOOST_AUTO_TEST_CASE(full_uri_user_info_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::user_info(instance), "user:password"); } BOOST_AUTO_TEST_CASE(full_uri_host_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::host(instance), "www.example.com"); } BOOST_AUTO_TEST_CASE(full_uri_port_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::port(instance), "80"); BOOST_CHECK(uri::port_us(instance)); BOOST_CHECK_EQUAL(uri::port_us(instance).get(), 80); } BOOST_AUTO_TEST_CASE(full_uri_path_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::path(instance), "/path"); } BOOST_AUTO_TEST_CASE(full_uri_query_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::query(instance), "query"); } BOOST_AUTO_TEST_CASE(full_uri_fragment_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::fragment(instance), "fragment"); } BOOST_AUTO_TEST_CASE(full_uri_range_scheme_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.scheme_range()); BOOST_CHECK(instance.begin() == boost::begin(instance.scheme_range())); BOOST_CHECK(boost::equal(instance.scheme_range(), boost::as_literal("http"))); } BOOST_AUTO_TEST_CASE(full_uri_range_user_info_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.user_info_range()); BOOST_CHECK(boost::equal(instance.user_info_range(), boost::as_literal("user:password"))); } BOOST_AUTO_TEST_CASE(full_uri_range_host_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.host_range()); BOOST_CHECK(boost::equal(instance.host_range(), boost::as_literal("www.example.com"))); } BOOST_AUTO_TEST_CASE(full_uri_range_port_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.port_range()); BOOST_CHECK(boost::equal(instance.port_range(), boost::as_literal("80"))); } BOOST_AUTO_TEST_CASE(full_uri_range_path_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.path_range()); BOOST_CHECK(boost::equal(instance.path_range(), boost::as_literal("/path"))); } BOOST_AUTO_TEST_CASE(full_uri_range_query_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.query_range()); BOOST_CHECK(boost::equal(instance.query_range(), boost::as_literal("query"))); } BOOST_AUTO_TEST_CASE(full_uri_range_fragment_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(instance.fragment_range()); BOOST_CHECK( boost::equal(instance.fragment_range(), boost::as_literal("fragment"))); BOOST_CHECK(instance.end() == boost::end(instance.fragment_range())); } BOOST_AUTO_TEST_CASE(mailto_test) { uri::uri instance("mailto:john.doe@example.com"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "mailto"); BOOST_CHECK_EQUAL(uri::path(instance), "john.doe@example.com"); } BOOST_AUTO_TEST_CASE(file_test) { uri::uri instance("file:///bin/bash"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "file"); BOOST_CHECK_EQUAL(uri::path(instance), "/bin/bash"); } BOOST_AUTO_TEST_CASE(xmpp_test) { uri::uri instance( "xmpp:example-node@example.com?message;subject=Hello%20World"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "xmpp"); BOOST_CHECK_EQUAL(uri::path(instance), "example-node@example.com"); BOOST_CHECK_EQUAL(uri::query(instance), "message;subject=Hello%20World"); } BOOST_AUTO_TEST_CASE(ipv4_address_test) { uri::uri instance("http://129.79.245.252/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); BOOST_CHECK_EQUAL(uri::host(instance), "129.79.245.252"); BOOST_CHECK_EQUAL(uri::path(instance), "/"); } BOOST_AUTO_TEST_CASE(ipv4_loopback_test) { uri::uri instance("http://127.0.0.1/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); BOOST_CHECK_EQUAL(uri::host(instance), "127.0.0.1"); BOOST_CHECK_EQUAL(uri::path(instance), "/"); } BOOST_AUTO_TEST_CASE(ipv6_address_test_1) { uri::uri instance("http://[1080:0:0:0:8:800:200C:417A]/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); BOOST_CHECK_EQUAL(uri::host(instance), "[1080:0:0:0:8:800:200C:417A]"); BOOST_CHECK_EQUAL(uri::path(instance), "/"); } BOOST_AUTO_TEST_CASE(ipv6_address_test_2) { uri::uri instance("http://[2001:db8:85a3:8d3:1319:8a2e:370:7348]/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); BOOST_CHECK_EQUAL(uri::host(instance), "[2001:db8:85a3:8d3:1319:8a2e:370:7348]"); BOOST_CHECK_EQUAL(uri::path(instance), "/"); } // BOOST_AUTO_TEST_CASE(ipv6_loopback_test) { // uri::uri instance("http://[::1]/"); // BOOST_REQUIRE(uri::valid(instance)); // BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); // BOOST_CHECK_EQUAL(uri::host(instance), "[::1]"); // BOOST_CHECK_EQUAL(uri::path(instance), "/"); //} BOOST_AUTO_TEST_CASE(ftp_test) { uri::uri instance("ftp://john.doe@ftp.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "ftp"); BOOST_CHECK_EQUAL(uri::user_info(instance), "john.doe"); BOOST_CHECK_EQUAL(uri::host(instance), "ftp.example.com"); BOOST_CHECK_EQUAL(uri::path(instance), "/"); } BOOST_AUTO_TEST_CASE(news_test) { uri::uri instance("news:comp.infosystems.www.servers.unix"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "news"); BOOST_CHECK_EQUAL(uri::path(instance), "comp.infosystems.www.servers.unix"); } BOOST_AUTO_TEST_CASE(tel_test) { uri::uri instance("tel:+1-816-555-1212"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "tel"); BOOST_CHECK_EQUAL(uri::path(instance), "+1-816-555-1212"); } BOOST_AUTO_TEST_CASE(encoded_uri_test) { uri::uri instance( "http://www.example.com/" "Path%20With%20%28Some%29%20Encoded%20Characters%21"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::scheme(instance), "http"); BOOST_CHECK_EQUAL(uri::host(instance), "www.example.com"); BOOST_CHECK_EQUAL(uri::path(instance), "/Path%20With%20%28Some%29%20Encoded%20Characters%21"); BOOST_CHECK_EQUAL(uri::decoded_path(instance), "/Path With (Some) Encoded Characters!"); } BOOST_AUTO_TEST_CASE(copy_constructor_test) { uri::uri instance("http://www.example.com/"); uri::uri copy = instance; BOOST_CHECK_EQUAL(instance, copy); } BOOST_AUTO_TEST_CASE(assignment_test) { uri::uri instance("http://www.example.com/"); uri::uri copy; copy = instance; BOOST_CHECK_EQUAL(instance, copy); } BOOST_AUTO_TEST_CASE(swap_test) { uri::uri instance("http://www.example.com/"); uri::uri copy("http://www.example.org/"); uri::swap(instance, copy); BOOST_CHECK_EQUAL(instance.string(), "http://www.example.org/"); BOOST_CHECK_EQUAL(copy.string(), "http://www.example.com/"); } BOOST_AUTO_TEST_CASE(equality_test) { uri::uri uri_1("http://www.example.com/"); uri::uri uri_2("http://www.example.com/"); BOOST_CHECK(uri_1 == uri_2); } BOOST_AUTO_TEST_CASE(equality_test_1) { uri::uri uri_1("http://www.example.com/"); std::string uri_2("http://www.example.com/"); BOOST_CHECK(uri_1 == uri_2); } BOOST_AUTO_TEST_CASE(equality_test_2) { std::string uri_1("http://www.example.com/"); uri::uri uri_2("http://www.example.com/"); BOOST_CHECK(uri_1 == uri_2); } BOOST_AUTO_TEST_CASE(equality_test_3) { uri::uri uri_1("http://www.example.com/"); std::string uri_2("http://www.example.com/"); BOOST_CHECK(uri_1 == uri_2.c_str()); } BOOST_AUTO_TEST_CASE(equality_test_4) { std::string uri_1("http://www.example.com/"); uri::uri uri_2("http://www.example.com/"); BOOST_CHECK(uri_1.c_str() == uri_2); } BOOST_AUTO_TEST_CASE(inequality_test) { uri::uri uri_1("http://www.example.com/"); uri::uri uri_2("http://www.example.com/"); BOOST_CHECK(!(uri_1 != uri_2)); } BOOST_AUTO_TEST_CASE(less_than_test) { // uri_1 is lexicographically less than uri_2 uri::uri uri_1("http://www.example.com/"); uri::uri uri_2("http://www.example.org/"); BOOST_CHECK(uri_1 < uri_2); } BOOST_AUTO_TEST_CASE(username_test) { uri::uri instance("ftp://john.doe@ftp.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::username(instance), "john.doe"); } BOOST_AUTO_TEST_CASE(pasword_test) { uri::uri instance("ftp://john.doe:password@ftp.example.com/"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::password(instance), "password"); } BOOST_AUTO_TEST_CASE(hierarchical_part_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::hierarchical_part(instance), "user:password@www.example.com:80/path"); } BOOST_AUTO_TEST_CASE(partial_hierarchical_part_test) { uri::uri instance("http://www.example.com?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::hierarchical_part(instance), "www.example.com"); } BOOST_AUTO_TEST_CASE(authority_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::authority(instance), "user:password@www.example.com:80"); } BOOST_AUTO_TEST_CASE(partial_authority_test) { uri::uri instance("http://www.example.com/path?query#fragment"); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK_EQUAL(uri::authority(instance), "www.example.com"); } BOOST_AUTO_TEST_CASE(http_query_map_test) { uri::uri instance( "http://user:password@www.example.com:80/path?query=something#fragment"); BOOST_REQUIRE(uri::valid(instance)); std::map queries; uri::query_map(instance, queries); BOOST_REQUIRE_EQUAL(queries.size(), std::size_t(1)); BOOST_CHECK_EQUAL(queries.begin()->first, "query"); BOOST_CHECK_EQUAL(queries.begin()->second, "something"); } BOOST_AUTO_TEST_CASE(xmpp_query_map_test) { uri::uri instance( "xmpp:example-node@example.com?message;subject=Hello%20World"); BOOST_REQUIRE(uri::valid(instance)); std::map queries; uri::query_map(instance, queries); BOOST_REQUIRE_EQUAL(queries.size(), std::size_t(2)); BOOST_CHECK_EQUAL(queries.begin()->first, "message"); BOOST_CHECK_EQUAL(queries.begin()->second, ""); BOOST_CHECK_EQUAL((++queries.begin())->first, "subject"); BOOST_CHECK_EQUAL((++queries.begin())->second, "Hello%20World"); } BOOST_AUTO_TEST_CASE(range_test) { const std::string url("http://www.example.com/"); uri::uri instance(url); BOOST_REQUIRE(uri::valid(instance)); BOOST_CHECK(boost::equal(instance, url)); } BOOST_AUTO_TEST_CASE(issue_67_test) { // https://github.com/cpp-netlib/cpp-netlib/issues/67 const std::string site_name("http://www.google.com"); uri::uri bar0; uri::uri bar1 = site_name; bar0 = site_name; BOOST_CHECK(uri::is_valid(bar0)); BOOST_CHECK(uri::is_valid(bar1)); } BOOST_AUTO_TEST_CASE(from_parts_1) { BOOST_CHECK_EQUAL(uri::uri("http://www.example.com/path?query#fragment"), uri::from_parts(uri::uri("http://www.example.com"), "/path", "query", "fragment")); } BOOST_AUTO_TEST_CASE(from_parts_2) { BOOST_CHECK_EQUAL( uri::uri("http://www.example.com/path?query#fragment"), uri::from_parts("http://www.example.com", "/path", "query", "fragment")); } BOOST_AUTO_TEST_CASE(from_parts_3) { BOOST_CHECK_EQUAL( uri::uri("http://www.example.com/path?query"), uri::from_parts("http://www.example.com", "/path", "query")); } BOOST_AUTO_TEST_CASE(from_parts_4) { BOOST_CHECK_EQUAL(uri::uri("http://www.example.com/path"), uri::from_parts("http://www.example.com", "/path")); } BOOST_AUTO_TEST_CASE(from_file) { boost::filesystem::path path("/a/path/to/a/file.txt"); BOOST_CHECK_EQUAL(uri::uri("file:///a/path/to/a/file.txt"), uri::from_file(path)); } BOOST_AUTO_TEST_CASE(issue_104_test) { // https://github.com/cpp-netlib/cpp-netlib/issues/104 boost::scoped_ptr instance(new uri::uri("http://www.example.com/")); uri::uri copy = *instance; instance.reset(); BOOST_CHECK_EQUAL(uri::scheme(copy), "http"); } BOOST_AUTO_TEST_CASE(uri_set_test) { std::set uri_set; uri_set.insert(uri::uri("http://www.example.com/")); BOOST_REQUIRE(!uri_set.empty()); BOOST_CHECK_EQUAL((*uri_set.begin()), uri::uri("http://www.example.com/")); } BOOST_AUTO_TEST_CASE(uri_unordered_set_test) { boost::unordered_set uri_set; uri_set.insert(uri::uri("http://www.example.com/")); BOOST_REQUIRE(!uri_set.empty()); BOOST_CHECK_EQUAL((*uri_set.begin()), uri::uri("http://www.example.com/")); } BOOST_AUTO_TEST_CASE(issue_161_test) { uri::uri instance( "http://www.example.com/" "path?param1=-¶m2=some+plus+encoded+text¶m3=~"); BOOST_REQUIRE(uri::valid(instance)); std::map queries; uri::query_map(instance, queries); BOOST_REQUIRE_EQUAL(queries.size(), std::size_t(3)); BOOST_CHECK_EQUAL(queries["param1"], "-"); BOOST_CHECK_EQUAL(queries["param2"], "some+plus+encoded+text"); BOOST_CHECK_EQUAL(queries["param3"], "~"); BOOST_CHECK_EQUAL(uri::decoded(queries["param2"]), "some plus encoded text"); } BOOST_AUTO_TEST_CASE(issue_364_test) { uri::uri instance; uri::schemes::http(instance) << uri::host("my.awesome.server.com"); BOOST_CHECK_EQUAL("my.awesome.server.com", uri::authority(instance)); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/utils_base64_test.cpp000066400000000000000000000160401240331347200256400ustar00rootroot00000000000000#define BOOST_TEST_MODULE BASE64 Test #include #include #include #include #include #include #include #include #include #include using namespace boost::network::utils; // proves that all public functions are compilable; the result check // is very minimum here, so that the test doesn't look so stupid ;-) BOOST_AUTO_TEST_CASE(interface_test) { std::string result; base64::state state; // check string literal BOOST_CHECK_EQUAL(base64::encode("abc"), "YWJj"); base64::encode("abc", std::back_inserter(result)); BOOST_CHECK_EQUAL(result, "YWJj"); result.clear(); base64::encode("abc", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YWJj"); // check std::string std::string input("abc"); BOOST_CHECK_EQUAL(base64::encode(input), "YWJj"); result.clear(); base64::encode(input, std::back_inserter(result)); BOOST_CHECK_EQUAL(result, "YWJj"); result.clear(); base64::encode(input.begin(), input.end(), std::back_inserter(result)); BOOST_CHECK_EQUAL(result, "YWJj"); result.clear(); base64::encode(input, std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YWJj"); result.clear(); base64::encode(input.begin(), input.end(), std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YWJj"); // check array of chars char char_array[] = {'a', 'b', 'c', 0}; BOOST_CHECK_EQUAL(base64::encode(char_array), "YWJj"); // check boost::array of chars boost::array char_boost_array = {{'a', 'b', 'c'}}; BOOST_CHECK_EQUAL(base64::encode(char_boost_array), "YWJj"); // check std::vector of chars std::vector char_vector(char_array, char_array + 3); BOOST_CHECK_EQUAL(base64::encode(char_vector), "YWJj"); // check array of ints int int_array[] = {'a', 'b', 'c'}; BOOST_CHECK_EQUAL(base64::encode(int_array), "YWJj"); // check boost::array of ints boost::array int_boost_array = {{'a', 'b', 'c'}}; BOOST_CHECK_EQUAL(base64::encode(int_boost_array), "YWJj"); // check std::vector of ints std::vector int_vector(int_array, int_array + 3); BOOST_CHECK_EQUAL(base64::encode(int_vector), "YWJj"); // check that base64::encode_rest is compilable and callable result.clear(); base64::encode_rest(std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, ""); // check that the iostream interface is compilable and callable std::ostringstream output; output << base64::io::encode("abc") << base64::io::encode(input.begin(), input.end()) << base64::io::encode(int_array) << base64::io::encode(int_boost_array) << base64::io::encode(char_array) << base64::io::encode(char_boost_array) << base64::io::encode(char_vector) << base64::io::encode_rest; BOOST_CHECK_EQUAL(output.str(), "YWJjYWJjYWJjYWJjYWJjYWJjYWJj"); } // checks that functions encoding a single chunk append the correct padding // if the input byte count is not divisible by 3 BOOST_AUTO_TEST_CASE(padding_test) { BOOST_CHECK_EQUAL(base64::encode(""), ""); BOOST_CHECK_EQUAL(base64::encode("a"), "YQ=="); BOOST_CHECK_EQUAL(base64::encode("aa"), "YWE="); BOOST_CHECK_EQUAL(base64::encode("aaa"), "YWFh"); } // check that functions using encoding state interrupt and resume encoding // correcly if the byte count of the partial input is not divisible by 3 BOOST_AUTO_TEST_CASE(state_test) { base64::state state; std::string result; // check encoding empty input; including the state value base64::encode("", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, ""); BOOST_CHECK(state.empty()); result.clear(); state.clear(); // check one third of quantum which needs two character padding; // including how the state develops when encoded by single character base64::encode("a", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "Y"); BOOST_CHECK(!state.empty()); base64::encode_rest(std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YQ=="); BOOST_CHECK(state.empty()); result.clear(); state.clear(); // check two thirds of quantum which needs one character padding; // including how the state develops when encoded by single character base64::encode("a", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "Y"); BOOST_CHECK(!state.empty()); base64::encode("a", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YW"); BOOST_CHECK(!state.empty()); base64::encode_rest(std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YWE="); BOOST_CHECK(state.empty()); result.clear(); state.clear(); // check a complete quantum which needs no padding; including // how the state develops when encoded by single character base64::encode("a", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "Y"); BOOST_CHECK(!state.empty()); base64::encode("a", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YW"); BOOST_CHECK(!state.empty()); base64::encode("a", std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YWFh"); BOOST_CHECK(state.empty()); base64::encode_rest(std::back_inserter(result), state); BOOST_CHECK_EQUAL(result, "YWFh"); BOOST_CHECK(state.empty()); } // checks that the base64 output can be returned as wchar_t too BOOST_AUTO_TEST_CASE(wide_character_test) { BOOST_CHECK(base64::encode("abc") == L"YWJj"); BOOST_CHECK(base64::encode(std::string("abc")) == L"YWJj"); std::wostringstream output; output << base64::io::encode("abc") << base64::io::encode_rest; BOOST_CHECK(output.str() == L"YWJj"); } // checks that the base64-io manipulators are compilable and work BOOST_AUTO_TEST_CASE(io_test) { // check complete quantum where no state has to be remembered std::ostringstream output; output << base64::io::encode("abc") << base64::io::encode_rest; BOOST_CHECK_EQUAL(output.str(), "YWJj"); // check that encode_rest clears the state output.str(""); output << base64::io::encode("a"); BOOST_CHECK(!base64::io::empty_state(output)); output << base64::io::encode_rest; BOOST_CHECK(base64::io::empty_state(output)); // check that forced clearing the state works output.str(""); output << base64::io::encode("a"); BOOST_CHECK(!base64::io::empty_state(output)); output << base64::io::clear_state; BOOST_CHECK(base64::io::empty_state(output)); // check one third of quantum which has to be remembered in state output.str(""); output << base64::io::encode("a") << base64::io::encode("bc") << base64::io::encode_rest; BOOST_CHECK_EQUAL(output.str(), "YWJj"); // check two thirds of quantum which have to be remembered in state. output.str(""); output << base64::io::encode("ab") << base64::io::encode("c") << base64::io::encode_rest; BOOST_CHECK_EQUAL(output.str(), "YWJj"); } cpp-netlib-cpp-netlib-0.11.1RC1/libs/network/test/utils_thread_pool.cpp000066400000000000000000000026361240331347200260230ustar00rootroot00000000000000 // Copyright 2010 Dean Michael Berris. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #define BOOST_TEST_MODULE utils thread pool test #include #include #include #include using namespace boost::network; // This test specifies the requirements for a thread pool interface. At the // very least any thread pool implementation should be able to pass the simple // tests that this unit test requires of thread pools. Ultimately the // requirements will show up in the Concept documentation, but this test is the // canonical definition of what a thread pool should look like at least // syntactically. // BOOST_AUTO_TEST_CASE(default_constructor) { utils::thread_pool pool; BOOST_CHECK_EQUAL(pool.thread_count(), std::size_t(1)); } struct foo { foo() : val_(0) {} void bar(int val) { val_ += val; } int const val() const { return val_; } protected: int val_; }; BOOST_AUTO_TEST_CASE(post_work) { foo instance; { utils::thread_pool pool; BOOST_CHECK_NO_THROW(pool.post(boost::bind(&foo::bar, &instance, 1))); BOOST_CHECK_NO_THROW(pool.post(boost::bind(&foo::bar, &instance, 2))); // require that pool is destroyed here, RAII baby } BOOST_CHECK_EQUAL(instance.val(), 3); } cpp-netlib-cpp-netlib-0.11.1RC1/package.sh000077500000000000000000000013321240331347200201200ustar00rootroot00000000000000#!/bin/sh # # Copyright 2012 Dean Michael Berris # Copyright 2012 Google, Inc. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # VERSION="$1" if [ "$VERSION" == "" ]; then VERSION="`git log --format=oneline | awk '{print $1}' | head -1`" fi TAG="cpp-netlib-$VERSION" git tag $TAG echo "Tagged $TAG." git archive --prefix=cpp-netlib-$VERSION/ --format=zip $TAG >cpp-netlib-$VERSION.zip git archive --prefix=cpp-netlib-$VERSION/ --format=tar $TAG | gzip >cpp-netlib-$VERSION.tar.gz git archive --prefix=cpp-netlib-$VERSION/ --format=tar $TAG | bzip2 >cpp-netlib-$VERSION.tar.bz2 echo "Packaged $TAG."