pax_global_header00006660000000000000000000000064117446056060014523gustar00rootroot0000000000000052 comment=aca06670fb515fc8fdeb9f285707d9eb9e83cf9b cpp-netlib-0.9.4/000077500000000000000000000000001174460560600135725ustar00rootroot00000000000000cpp-netlib-0.9.4/.gitignore000066400000000000000000000001561174460560600155640ustar00rootroot00000000000000*.cmake *.swp *.pyc CMakeCache.txt CMakeFiles Makefile Testing *.gch libs/mime/test/mime-roundtrip *.a _build cpp-netlib-0.9.4/CMakeLists.txt000066400000000000000000000022321174460560600163310ustar00rootroot00000000000000# 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) set(Boost_USE_STATIC_LIBS ON) set(Boost_USE_MULTI_THREADED ON) find_package( Boost 1.45.0 REQUIRED unit_test_framework system regex date_time thread filesystem program_options ) find_package( OpenSSL ) find_package( Threads ) set(CMAKE_VERBOSE_MAKEFILE true) if (CMAKE_BUILD_TYPE MATCHES Debug) add_definitions(-DBOOST_NETWORK_DEBUG) endif() if (OPENSSL_FOUND) add_definitions(-DBOOST_NETWORK_ENABLE_HTTPS) 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) add_subdirectory(libs/network/test) if (NOT MSVC) add_subdirectory(libs/mime/test) endif(NOT MSVC) add_subdirectory(libs/network/example) endif(Boost_FOUND) enable_testing() cpp-netlib-0.9.4/Jamroot000066400000000000000000000007361174460560600151360ustar00rootroot00000000000000 # 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) import os ; local BOOST_ROOT = [ os.environ BOOST_ROOT ] ; use-project /boost : $(BOOST_ROOT) ; use-project /cpp-netlib : libs/network/build ; using testing ; build-project libs/network/build ; build-project libs/network/test ; build-project libs/mime/test ; cpp-netlib-0.9.4/LICENSE_1_0.txt000066400000000000000000000024721174460560600160610ustar00rootroot00000000000000Boost 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-0.9.4/RATIONALE.txt000066400000000000000000000035411174460560600156540ustar00rootroot00000000000000C++ 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-0.9.4/README.rst000066400000000000000000000134131174460560600152630ustar00rootroot00000000000000C++ 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-0.9.4/boost/000077500000000000000000000000001174460560600147205ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/mime.hpp000066400000000000000000000707741174460560600163770ustar00rootroot00000000000000// // 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_t > 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< basic_mime > 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< std::string, string_type> 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< basic_mime > parse_mime ( Iterator &begin, Iterator end ) { return detail::parse_mime ( begin, end ); } // Build a mime part from a stream static boost::shared_ptr < basic_mime > 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< basic_mime > parse_mime ( Iterator &begin, Iterator end, const char *default_content_type ) { tracer t ( __func__ ); typedef typename boost::mime::basic_mime mime_part; shared_ptr < mime_part > 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 ( 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-0.9.4/boost/network.hpp000066400000000000000000000010061174460560600171170ustar00rootroot00000000000000 // 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-0.9.4/boost/network/000077500000000000000000000000001174460560600164115ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/constants.hpp000066400000000000000000000107471174460560600211470ustar00rootroot00000000000000#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_< is_default_wstring, impl::constants_wide, unsupported_tag >::type >::type {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_CONSTANTS_HPP_20100808 cpp-netlib-0.9.4/boost/network/detail/000077500000000000000000000000001174460560600176535ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/detail/debug.hpp000066400000000000000000000016021174460560600214510ustar00rootroot00000000000000#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-0.9.4/boost/network/detail/directive_base.hpp000066400000000000000000000017301174460560600233350ustar00rootroot00000000000000 // 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-0.9.4/boost/network/detail/wrapper_base.hpp000066400000000000000000000022671174460560600230450ustar00rootroot00000000000000 // 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-0.9.4/boost/network/include/000077500000000000000000000000001174460560600200345ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/include/http/000077500000000000000000000000001174460560600210135ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/include/http/client.hpp000066400000000000000000000007101174460560600230000ustar00rootroot00000000000000#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-0.9.4/boost/network/include/http/server.hpp000066400000000000000000000006351174460560600230360ustar00rootroot00000000000000#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-0.9.4/boost/network/include/message.hpp000066400000000000000000000007301174460560600221710ustar00rootroot00000000000000#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-0.9.4/boost/network/message.hpp000066400000000000000000000112111174460560600205420ustar00rootroot00000000000000// 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-0.9.4/boost/network/message/000077500000000000000000000000001174460560600200355ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/message/directives.hpp000066400000000000000000000022401174460560600227050ustar00rootroot00000000000000 // 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-0.9.4/boost/network/message/directives/000077500000000000000000000000001174460560600221765ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/message/directives/detail/000077500000000000000000000000001174460560600234405ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/message/directives/detail/string_directive.hpp000066400000000000000000000062321174460560600275200ustar00rootroot00000000000000#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-0.9.4/boost/network/message/directives/detail/string_value.hpp000066400000000000000000000024501174460560600266540ustar00rootroot00000000000000#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_< is_async, boost::shared_future::type>, typename mpl::if_< mpl::or_< is_sync, 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-0.9.4/boost/network/message/directives/header.hpp000066400000000000000000000057511174460560600241470ustar00rootroot00000000000000 // 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_< is_base_of< tags::pod, typename Message::tag >, 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-0.9.4/boost/network/message/directives/remove_header.hpp000066400000000000000000000023731174460560600255210ustar00rootroot00000000000000 // 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 < class T > 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-0.9.4/boost/network/message/message_concept.hpp000066400000000000000000000047111174460560600237100ustar00rootroot00000000000000 #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-0.9.4/boost/network/message/modifiers/000077500000000000000000000000001174460560600220165ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/message/modifiers/add_header.hpp000066400000000000000000000043431174460560600245730ustar00rootroot00000000000000 #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_ > , 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< mpl::and_< mpl::not_ > , 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< is_pod , 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-0.9.4/boost/network/message/modifiers/body.hpp000066400000000000000000000021711174460560600234650ustar00rootroot00000000000000#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-0.9.4/boost/network/message/modifiers/clear_headers.hpp000066400000000000000000000042501174460560600253110ustar00rootroot00000000000000#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_ > , 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< mpl::and_< mpl::not_ > , 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-0.9.4/boost/network/message/modifiers/destination.hpp000066400000000000000000000024531174460560600250540ustar00rootroot00000000000000 #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-0.9.4/boost/network/message/modifiers/remove_header.hpp000066400000000000000000000050761174460560600253440ustar00rootroot00000000000000 #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_ > , mpl::not_ > > , void >::type remove_header(Message & message, KeyType const & key, Tag) { message.headers().erase(key); } template inline typename enable_if< mpl::and_< mpl::not_ > , 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< is_pod , 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-0.9.4/boost/network/message/modifiers/source.hpp000066400000000000000000000023211174460560600240250ustar00rootroot00000000000000 #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-0.9.4/boost/network/message/traits/000077500000000000000000000000001174460560600213435ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/message/traits/body.hpp000066400000000000000000000026741174460560600230220ustar00rootroot00000000000000 #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_sync, is_same, is_same >, typename string::type, unsupported_tag >::type > {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_BODY_HPP_20100903 cpp-netlib-0.9.4/boost/network/message/traits/destination.hpp000066400000000000000000000026741174460560600244060ustar00rootroot00000000000000 #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_sync, is_same, is_same >, typename string::type, unsupported_tag >::type > {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_DESTINATION_HPP_20100903 cpp-netlib-0.9.4/boost/network/message/traits/headers.hpp000066400000000000000000000042421174460560600234710ustar00rootroot00000000000000 #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_sync, 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_sync, is_same, is_same >, typename string::type, unsupported_tag >::type > {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_HEADERS_HPP_20100903 cpp-netlib-0.9.4/boost/network/message/traits/source.hpp000066400000000000000000000026501174460560600233570ustar00rootroot00000000000000#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_sync, is_same, is_same >, typename string::type, unsupported_tag >::type > {}; } // namespace traits } /* network */ } /* boost */ #endif // BOOST_NETWORK_MESSAGE_TRAITS_SOURCE_HPP_20100903 cpp-netlib-0.9.4/boost/network/message/transformers.hpp000066400000000000000000000037661174460560600233070ustar00rootroot00000000000000 // 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< Algorithm >::type > ::result_type:: template type< typename boost::function_traits< typename boost::remove_pointer< Selector >::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-0.9.4/boost/network/message/transformers/000077500000000000000000000000001174460560600225625ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/message/transformers/selectors.hpp000066400000000000000000000033501174460560600252770ustar00rootroot00000000000000 // 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-0.9.4/boost/network/message/transformers/to_lower.hpp000066400000000000000000000050001174460560600251200ustar00rootroot00000000000000 // 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-0.9.4/boost/network/message/transformers/to_upper.hpp000066400000000000000000000050011174460560600251240ustar00rootroot00000000000000 // 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-0.9.4/boost/network/message/wrappers.hpp000066400000000000000000000011631174460560600224120ustar00rootroot00000000000000 // 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-0.9.4/boost/network/message/wrappers/000077500000000000000000000000001174460560600217005ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/message/wrappers/body.hpp000066400000000000000000000075661174460560600233640ustar00rootroot00000000000000 // 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 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-0.9.4/boost/network/message/wrappers/destination.hpp000066400000000000000000000026051174460560600247350ustar00rootroot00000000000000 // 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-0.9.4/boost/network/message/wrappers/headers.hpp000066400000000000000000000074411174460560600240320ustar00rootroot00000000000000 // 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 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-0.9.4/boost/network/message/wrappers/source.hpp000066400000000000000000000025441174460560600237160ustar00rootroot00000000000000 // 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-0.9.4/boost/network/message_fwd.hpp000066400000000000000000000007071174460560600214120ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol.hpp000066400000000000000000000010531174460560600207620ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/000077500000000000000000000000001174460560600202525ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http.hpp000066400000000000000000000012501174460560600217400ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/000077500000000000000000000000001174460560600212315ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/algorithms/000077500000000000000000000000001174460560600234025ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/algorithms/linearize.hpp000066400000000000000000000130051174460560600260740ustar00rootroot00000000000000#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 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)), (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); 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); 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) { boost::copy(accept_encoding, oi); *oi = consts::colon_char(); *oi = consts::space_char(); boost::copy(default_accept_encoding, oi); boost::copy(crlf, oi); } 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); boost::copy(header_name, oi); *oi = consts::colon_char(); *oi = consts::space_char(); boost::copy(header_value, oi); boost::copy(crlf, oi); } if (!connection_keepalive::value) { 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-0.9.4/boost/network/protocol/http/client.hpp000066400000000000000000000067741174460560600232360ustar00rootroot00000000000000#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; // Constructor // ================================================================= // This is a Boost.Parameter-based constructor forwarder, whose // implementation is actually forwarded to the base type. // // The supported parameters are: // _follow_redirects : bool -- whether to follow HTTP redirect // responses (default: false) // _cache_resolved : bool -- whether to cache the resolved // endpoints (default: false) // _io_service : boost::asio::io_service & // -- supply an io_service to the // client // _openssl_certificate : string // -- the name of the certificate file // to use // _openssl_verify_path : string // -- the name of the directory from // which the certificate authority // files can be found BOOST_PARAMETER_CONSTRUCTOR( basic_client, (base_facade_type), tag, (optional (in_out(io_service), (boost::asio::io_service&)) (follow_redirects, (bool)) (cache_resolved, (bool)) (openssl_certificate, (string_type)) (openssl_verify_path, (string_type)) )) // // ================================================================= }; #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-0.9.4/boost/network/protocol/http/client/000077500000000000000000000000001174460560600225075ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/client/async_impl.hpp000066400000000000000000000072301174460560600253600ustar00rootroot00000000000000#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 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; async_client(bool cache_resolved, bool follow_redirect, optional const & certificate_filename, optional const & verify_path) : connection_base(cache_resolved, follow_redirect), service_ptr(new boost::asio::io_service), service_(*service_ptr), resolver_(service_), sentinel_(new boost::asio::io_service::work(service_)), certificate_filename_(certificate_filename), verify_path_(verify_path) { connection_base::resolver_strand_.reset(new boost::asio::io_service::strand(service_)); lifetime_thread_.reset(new boost::thread( boost::bind( &boost::asio::io_service::run, &service_ ))); } async_client(bool cache_resolved, bool follow_redirect, boost::asio::io_service & service, optional const & certificate_filename, optional const & verify_path) : connection_base(cache_resolved, follow_redirect), service_ptr(0), service_(service), resolver_(service_), sentinel_(new boost::asio::io_service::work(service_)), certificate_filename_(certificate_filename), verify_path_(verify_path) { } ~async_client() throw () { sentinel_.reset(); if (lifetime_thread_.get()) { lifetime_thread_->join(); lifetime_thread_.reset(); } delete service_ptr; } basic_response const request_skeleton( basic_request const & request_, string_type const & method, bool get_body, body_callback_function_type callback ) { typename connection_base::connection_ptr connection_; connection_ = connection_base::get_connection(resolver_, request_, certificate_filename_, verify_path_); return connection_->send_request(method, request_, get_body, callback); } boost::asio::io_service * service_ptr; boost::asio::io_service & service_; resolver_type resolver_; boost::shared_ptr sentinel_; boost::shared_ptr lifetime_thread_; optional certificate_filename_, verify_path_; }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_ASYNC_IMPL_HPP_20100623 cpp-netlib-0.9.4/boost/network/protocol/http/client/connection/000077500000000000000000000000001174460560600246465ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/client/connection/async_base.hpp000066400000000000000000000057051174460560600274750ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_ASYNC_CONNECTION_BASE_20100529 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_ASYNC_CONNECTION_BASE_20100529 // 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 { 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 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 https, optional certificate_filename=optional(), optional const & verify_path=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, delegate_factory_type::new_connection_delegate( resolver.get_io_service(), https, certificate_filename, verify_path))); 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) = 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-0.9.4/boost/network/protocol/http/client/connection/async_normal.hpp000066400000000000000000000475721174460560600300630ustar00rootroot00000000000000#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 > { 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 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, connection_delegate_ptr delegate) : 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) { 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, _1, _2))); 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)); } void handle_resolved(boost::uint16_t port, bool get_body, body_callback_function_type callback, 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, std::make_pair(++iter, resolver_iterator()), placeholders::error))); } else { set_errors(ec ? ec : boost::asio::error::host_not_found); } } void handle_connected(boost::uint16_t port, bool get_body, body_callback_function_type callback, resolver_iterator_pair endpoint_range, boost::system::error_code const & ec) { 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, 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, std::make_pair(++iter, resolver_iterator()), placeholders::error))); } else { set_errors(ec ? ec : boost::asio::error::host_not_found); } } } enum state_t { version, status, status_message, headers, body }; void handle_sent_request(bool get_body, body_callback_function_type callback, boost::system::error_code const & ec, std::size_t bytes_transferred) { if (!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(), version, get_body, callback, placeholders::error, placeholders::bytes_transferred))); } else { set_errors(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 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 #endif ; if (!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 ); 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(); } 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(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!"); } } } 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 cpp-netlib-0.9.4/boost/network/protocol/http/client/connection/async_protocol_handler.hpp000066400000000000000000000354301174460560600321170ustar00rootroot00000000000000#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); } 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; }; } /* impl */ } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_PROTOCOL_HANDLER_HPP_20101015 */ cpp-netlib-0.9.4/boost/network/protocol/http/client/connection/connection_delegate.hpp000066400000000000000000000021601174460560600313470ustar00rootroot00000000000000#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 ~connection_delegate() {} }; } /* impl */ } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_CONNECTION_DELEGATE_HPP_ */ cpp-netlib-0.9.4/boost/network/protocol/http/client/connection/connection_delegate_factory.hpp000066400000000000000000000037461174460560600331110ustar00rootroot00000000000000#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, optional certificate_filename, optional verify_path) { connection_delegate_ptr delegate; if (https) { #ifdef BOOST_NETWORK_ENABLE_HTTPS delegate.reset(new ssl_delegate(service, certificate_filename, verify_path)); #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-0.9.4/boost/network/protocol/http/client/connection/normal_delegate.hpp000066400000000000000000000032121174460560600304770ustar00rootroot00000000000000#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); ~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-0.9.4/boost/network/protocol/http/client/connection/normal_delegate.ipp000066400000000000000000000031521174460560600305030ustar00rootroot00000000000000#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); } boost::network::http::impl::normal_delegate::~normal_delegate() {} #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_IPP_20110819 */ cpp-netlib-0.9.4/boost/network/protocol/http/client/connection/ssl_delegate.hpp000066400000000000000000000043021174460560600300110ustar00rootroot00000000000000#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, optional certificate_filename, optional verify_path); 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); ~ssl_delegate(); private: asio::io_service & service_; optional certificate_filename_, verify_path_; scoped_ptr context_; scoped_ptr > socket_; 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-0.9.4/boost/network/protocol/http/client/connection/ssl_delegate.ipp000077500000000000000000000052301174460560600300160ustar00rootroot00000000000000#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 boost::network::http::impl::ssl_delegate::ssl_delegate(asio::io_service & service, optional certificate_filename, optional verify_path) : service_(service), certificate_filename_(certificate_filename), verify_path_(verify_path) {} 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 { context_->set_verify_mode(asio::ssl::context::verify_none); } 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); } boost::network::http::impl::ssl_delegate::~ssl_delegate() {} #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_IPP_20110819 */ cpp-netlib-0.9.4/boost/network/protocol/http/client/connection/sync_base.hpp000066400000000000000000000306161174460560600273330ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_SYNC_CONNECTION_BASE_20091217 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_SYNC_CONNECTION_BASE_20091217 // 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 #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 { std::size_t chunk_bytes_read = read(socket_, response_buffer, boost::asio::transfer_at_least(chunk_size), 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; // 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, optional const & cert_filename = optional(), optional const & verify_path = optional()) { if (https) { #ifdef BOOST_NETWORK_ENABLE_HTTPS return dynamic_cast*>(new https_sync_connection(resolver, resolve, cert_filename, verify_path)); #else throw std::runtime_error("HTTPS not supported."); #endif } return dynamic_cast*>(new http_sync_connection(resolver, resolve)); } 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_) = 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-0.9.4/boost/network/protocol/http/client/connection/sync_normal.hpp000066400000000000000000000074211174460560600277070ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_SYNC_CONNECTION_20100601 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_SYNC_CONNECTION_20100601 // 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 { 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 { 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 sync_connection_base_impl connection_base; http_sync_connection(resolver_type & resolver, resolver_function_type resolve) : connection_base(), 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_) { 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); } 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() { 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: 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-0.9.4/boost/network/protocol/http/client/connection/sync_ssl.hpp000066400000000000000000000115421174460560600272170ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTPS_SYNC_CONNECTION_HTTP_20100601 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTPS_SYNC_CONNECTION_HTTP_20100601 // 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 { 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 { 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 sync_connection_base_impl connection_base; // FIXME make the certificate filename and verify path parameters be optional ranges https_sync_connection(resolver_type & resolver, resolver_function_type resolve, optional const & certificate_filename = optional(), optional const & verify_path = optional()) : connection_base(), 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 { context_.set_verify_mode(boost::asio::ssl::context::verify_none); } } 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_) { 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); } 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() { 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: 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-0.9.4/boost/network/protocol/http/client/facade.hpp000066400000000000000000000156171174460560600244350ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_FACADE_HPP_20100623 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_FACADE_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 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; template basic_client_facade(ArgPack const & args) { init_pimpl(args, typename mpl::if_< is_same< typename parameter::value_type::type, void >, no_io_service, has_io_service >::type()); } BOOST_PARAMETER_MEMBER_FUNCTION((response const), head, tag, (required (request,(request const &)))) { return pimpl->request_skeleton(request, "HEAD", false, body_callback_function_type()); } BOOST_PARAMETER_MEMBER_FUNCTION((response const), get , tag, (required (request,(request const &)) ) (optional (body_handler,(body_callback_function_type),body_callback_function_type()) ) ) { return pimpl->request_skeleton(request, "GET", true, body_handler); } BOOST_PARAMETER_MEMBER_FUNCTION((response const), post, tag, (required (request,(request)) // yes sir, we make a copy of the original request. ) (optional (body,(string_type const &),string_type()) (content_type,(string_type const &),string_type()) (body_handler,(body_callback_function_type),body_callback_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); } BOOST_PARAMETER_MEMBER_FUNCTION((response const), put , tag, (required (request,(request)) // yes sir, we make a copy of the original request. ) (optional (body,(string_type const &),string_type()) (content_type,(string_type const &),string_type()) (body_handler,(body_callback_function_type),body_callback_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); } BOOST_PARAMETER_MEMBER_FUNCTION((response const), delete_, tag, (required (request,(request const &)) ) (optional (body_handler,(body_callback_function_type),body_callback_function_type()) ) ) { return pimpl->request_skeleton(request, "DELETE", true, body_handler); } void clear_resolved_cache() { pimpl->clear_resolved_cache(); } protected: struct no_io_service {}; struct has_io_service {}; boost::shared_ptr pimpl; template void init_pimpl(ArgPack const & args, no_io_service) { pimpl.reset( new pimpl_type( args[_cache_resolved|false] , args[_follow_redirects|false] , optional(args[_openssl_certificate|optional()]) , optional(args[_openssl_verify_path|optional()]) ) ); } template void init_pimpl(ArgPack const & args, has_io_service) { pimpl.reset( new pimpl_type( args[_cache_resolved|false] , args[_follow_redirects|false] , args[_io_service] , optional(args[_openssl_certificate|optional()]) , optional(args[_openssl_verify_path|optional()]) ) ); } }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_FACADE_HPP_20100623 cpp-netlib-0.9.4/boost/network/protocol/http/client/macros.hpp000066400000000000000000000013701174460560600245050ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/client/parameters.hpp000066400000000000000000000015771174460560600253750ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_PARAMETERS_HPP_2010127 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_PARAMETERS_HPP_2010127 // 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 { BOOST_PARAMETER_NAME(follow_redirects) BOOST_PARAMETER_NAME(cache_resolved) BOOST_PARAMETER_NAME(openssl_certificate) BOOST_PARAMETER_NAME(openssl_verify_path) BOOST_PARAMETER_NAME(request) BOOST_PARAMETER_NAME(body) BOOST_PARAMETER_NAME(content_type) BOOST_PARAMETER_NAME(body_handler) } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_PARAMETERS_HPP_2010127 */ cpp-netlib-0.9.4/boost/network/protocol/http/client/pimpl.hpp000066400000000000000000000063371174460560600243520ustar00rootroot00000000000000#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_< mpl::and_< is_async, 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, optional const & certificate_filename, optional const & verify_path) : base_type(cache_resolved, follow_redirect, certificate_filename, verify_path) {} basic_client_impl(bool cache_resolved, bool follow_redirect, boost::asio::io_service & service, optional const & certificate_filename, optional const & verify_path) : base_type(cache_resolved, follow_redirect, service, certificate_filename, verify_path) {} ~basic_client_impl() {} }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_PIMPL_HPP_20100623 cpp-netlib-0.9.4/boost/network/protocol/http/client/sync_impl.hpp000066400000000000000000000062511174460560600252210ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_SYNC_IMPL_HPP_20100623 #define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_SYNC_IMPL_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) 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; friend struct basic_client_impl; boost::asio::io_service * service_ptr; boost::asio::io_service & service_; resolver_type resolver_; optional certificate_file, verify_path; sync_client(bool cache_resolved, bool follow_redirect , optional const & certificate_file = optional() , optional const & verify_path = optional() ) : connection_base(cache_resolved, follow_redirect), service_ptr(new boost::asio::io_service), service_(*service_ptr), resolver_(service_) , certificate_file(certificate_file) , verify_path(verify_path) {} sync_client(bool cache_resolved, bool follow_redirect, boost::asio::io_service & service , optional const & certificate_file = optional() , optional const & verify_path = optional() ) : connection_base(cache_resolved, follow_redirect), service_ptr(0), service_(service), resolver_(service_) , certificate_file(certificate_file) , verify_path(verify_path) {} ~sync_client() { connection_base::cleanup(); delete service_ptr; } basic_response const request_skeleton(basic_request const & request_, string_type method, bool get_body, body_callback_function_type callback) { typename connection_base::connection_ptr connection_; connection_ = connection_base::get_connection(resolver_, request_, certificate_file, verify_path); return connection_->send_request(method, request_, get_body, callback); } }; } // namespace impl } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_SYNC_IMPL_HPP_20100623 cpp-netlib-0.9.4/boost/network/protocol/http/client_fwd.hpp000066400000000000000000000014671174460560600240700ustar00rootroot00000000000000 // 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_CLIENT_20080923_1_HPP__ #define __NETWORK_PROTOCOL_HTTP_CLIENT_20080923_1_HPP__ #include #include namespace boost { namespace network { namespace http { //! Forward declaration of basic_client template. template class basic_client; typedef basic_client client; } // namespace http } // namespace network } // namespace boost #endif // __NETWORK_PROTOCOL_HTTP_CLIENT_20080923_1_HPP__ cpp-netlib-0.9.4/boost/network/protocol/http/errors.hpp000066400000000000000000000015061174460560600232600ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/impl/000077500000000000000000000000001174460560600221725ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/impl/message.ipp000066400000000000000000000256571174460560600243470ustar00rootroot00000000000000// 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_ptr[i])]; if(base64code0==nop) // non base64 character return false; if(!(++i(input_ptr[i])]; if(base64code1==nop) // non base64 character return false; output += ((base64code0 << 2) | ((base64code1 >> 4) & 0x3)); if(++i(input_ptr[i])]; if(base64code2==nop) // non base64 character return false; output += ((base64code1 << 4) & 0xf0) | ((base64code2 >> 2) & 0x0f); } if(++i(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> 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-0.9.4/boost/network/protocol/http/impl/parser.ipp000066400000000000000000001044161174460560600242060ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol/http/impl/request.hpp000066400000000000000000000176571174460560600244130ustar00rootroot00000000000000 // 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 : vector::apply::type> {}; template <> struct headers_container : 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 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(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 {}; template <> struct basic_request : not_quite_pod_request_base {}; 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-0.9.4/boost/network/protocol/http/impl/request_parser.ipp000066400000000000000000000153271174460560600257600ustar00rootroot00000000000000// // 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-0.9.4/boost/network/protocol/http/impl/response.ipp000066400000000000000000000341651174460560600245530ustar00rootroot00000000000000// // 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. 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 } 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

" ""; 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; 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"; 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); default: return buffer(internal_server_error); } } }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_RESPONSE_RESPONSE_IPP cpp-netlib-0.9.4/boost/network/protocol/http/message.hpp000066400000000000000000000121221174460560600233640ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol/http/message/000077500000000000000000000000001174460560600226555ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/message/async_message.hpp000066400000000000000000000122071174460560600262110ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/directives/000077500000000000000000000000001174460560600250165ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/message/directives/major_version.hpp000066400000000000000000000023371174460560600304110ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/directives/method.hpp000066400000000000000000000012251174460560600270070ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/directives/minor_version.hpp000066400000000000000000000023401174460560600304170ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/directives/status.hpp000066400000000000000000000047151174460560600270610ustar00rootroot00000000000000#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< boost::uint16_t, boost::shared_future > 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_< is_async, 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-0.9.4/boost/network/protocol/http/message/directives/status_message.hpp000066400000000000000000000015671174460560600305670ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/directives/uri.hpp000066400000000000000000000014031174460560600263240ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/directives/version.hpp000066400000000000000000000014471174460560600272220ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/header.hpp000066400000000000000000000061561174460560600246260ustar00rootroot00000000000000// // 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_< is_default_string, request_header_narrow, typename mpl::if_< is_default_wstring, 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_< is_default_string, response_header_narrow, typename mpl::if_< is_default_wstring, 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-0.9.4/boost/network/protocol/http/message/header/000077500000000000000000000000001174460560600241055ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/message/header/name.hpp000066400000000000000000000021561174460560600255420ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/header/value.hpp000066400000000000000000000024411174460560600257330ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/header_concept.hpp000066400000000000000000000020471174460560600263340ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/message_base.hpp000066400000000000000000000016211174460560600260040ustar00rootroot00000000000000#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_< is_async, async_message, message_impl > {}; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_BASE_HPP_20100603 cpp-netlib-0.9.4/boost/network/protocol/http/message/modifiers/000077500000000000000000000000001174460560600246365ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/message/modifiers/body.hpp000066400000000000000000000043721174460560600263120ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/clear_headers.hpp000066400000000000000000000034201174460560600301270ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/destination.hpp000066400000000000000000000054661174460560600277030ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/headers.hpp000066400000000000000000000032221174460560600267610ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/major_version.hpp000066400000000000000000000017061174460560600302300ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/method.hpp000066400000000000000000000015651174460560600266360ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/minor_version.hpp000066400000000000000000000017071174460560600302450ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/source.hpp000066400000000000000000000052541174460560600266550ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/status.hpp000066400000000000000000000024361174460560600266770ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/status_message.hpp000066400000000000000000000025461174460560600304050ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/uri.hpp000066400000000000000000000015101174460560600261430ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/modifiers/version.hpp000066400000000000000000000025601174460560600270370ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/traits/000077500000000000000000000000001174460560600241635ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/message/traits/status.hpp000066400000000000000000000020301174460560600262120ustar00rootroot00000000000000#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_< is_sync, boost::uint16_t, unsupported_tag >::type > {}; } /* traits */ } /* http */ } /* network */ } /* boost */ #endif cpp-netlib-0.9.4/boost/network/protocol/http/message/traits/status_message.hpp000066400000000000000000000024751174460560600277330ustar00rootroot00000000000000#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_sync, is_same, is_same >, typename string::type, unsupported_tag >::type > {}; } /* traits */ } /* http */ } /* network */ } /* boost */ #endif cpp-netlib-0.9.4/boost/network/protocol/http/message/traits/version.hpp000066400000000000000000000032071174460560600263630ustar00rootroot00000000000000#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, is_default_string, is_default_wstring > >::type > { typedef typename string::type type; }; } /* traits */ } /* http */ } /* network */ } /* boost */ #endif cpp-netlib-0.9.4/boost/network/protocol/http/message/wrappers/000077500000000000000000000000001174460560600245205ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/message/wrappers/anchor.hpp000066400000000000000000000023051174460560600265030ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/body.hpp000066400000000000000000000041411174460560600261660ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/destination.hpp000066400000000000000000000015521174460560600275550ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/headers.hpp000066400000000000000000000103651174460560600266510ustar00rootroot00000000000000 #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 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-0.9.4/boost/network/protocol/http/message/wrappers/helper.hpp000066400000000000000000000110011174460560600265010ustar00rootroot00000000000000#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_< \ is_base_of, \ 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-0.9.4/boost/network/protocol/http/message/wrappers/host.hpp000066400000000000000000000022421174460560600262060ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/major_version.hpp000066400000000000000000000023671174460560600301160ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/method.hpp000066400000000000000000000023451174460560600265150ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/minor_version.hpp000066400000000000000000000023701174460560600301240ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/path.hpp000066400000000000000000000022411174460560600261640ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/port.hpp000066400000000000000000000025131174460560600262160ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PORT_HPP_20100618 #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_PORT_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) #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() { return message_.port(); } operator boost::optional () { return uri::port_us(message_.uri()); } }; } // 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-0.9.4/boost/network/protocol/http/message/wrappers/protocol.hpp000066400000000000000000000023271174460560600270760ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/query.hpp000066400000000000000000000023451174460560600264020ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/ready.hpp000066400000000000000000000030721174460560600263370ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/source.hpp000066400000000000000000000014151174460560600265320ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/status.hpp000066400000000000000000000025441174460560600265610ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/status_message.hpp000066400000000000000000000026521174460560600302650ustar00rootroot00000000000000#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. // Distributed under the 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 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 () { return response_.status_message(); } }; } // 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-0.9.4/boost/network/protocol/http/message/wrappers/uri.hpp000066400000000000000000000024761174460560600260410ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/message/wrappers/version.hpp000066400000000000000000000025361174460560600267240ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/parameters.hpp000066400000000000000000000012171174460560600241060ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_PARAMETERS_HPP_20101210 #define BOOST_NETWORK_PROTOCOL_HTTP_PARAMETERS_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) #if !defined(BOOST_PARAMETER_MAX_ARITY) #define BOOST_PARAMETER_MAX_ARITY 16 #endif #include namespace boost { namespace network { namespace http { BOOST_PARAMETER_NAME(io_service) } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_PARAMETERS_HPP_20101210 */ cpp-netlib-0.9.4/boost/network/protocol/http/parser.hpp000066400000000000000000000302031174460560600232340ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol/http/parser/000077500000000000000000000000001174460560600225255ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/parser/incremental.hpp000066400000000000000000000256701174460560600255510ustar00rootroot00000000000000#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 { parsed_ok = false; } break; case http_status_done: if (algorithm::is_alnum()(*current)) { state_ = http_status_message_char; ++current; } else { parsed_ok = false; } break; case http_status_message_char: if (algorithm::is_alnum()(*current) || algorithm::is_punct()(*current) || (*current == ' ')) { ++current; } else if (*current == '\r') { state_ = http_status_message_cr; ++current; } else { parsed_ok = false; } 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 (algorithm::is_alnum()(*current)) { state_ = http_header_name_char; ++current; } else if (*current == '\r') { state_ = http_headers_end_cr; ++current; } else { parsed_ok = false; } break; case http_header_name_char: if (*current == ':') { state_ = http_header_colon; ++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 (algorithm::is_space()(*current)) { ++current; } else if (algorithm::is_alnum()(*current) || algorithm::is_punct()(*current)) { state_ = http_header_value_char; ++current; } else { parsed_ok = false; } break; case http_header_value_char: if (*current == '\r') { state_ = http_header_line_cr; ++current; } else if (algorithm::is_cntrl()(*current)) { parsed_ok = false; } 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-0.9.4/boost/network/protocol/http/policies/000077500000000000000000000000001174460560600230405ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/policies/async_connection.hpp000066400000000000000000000071531174460560600271130ustar00rootroot00000000000000#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; struct connection_impl { connection_impl( bool follow_redirect, resolve_function resolve, resolver_type & resolver, bool https, optional const & certificate_filename, optional const & verify_path ) { pimpl = impl::async_connection_base::new_connection(resolve, resolver, follow_redirect, https, certificate_filename, verify_path); } basic_response send_request(string_type const & method, basic_request const & request_, bool get_body, body_callback_function_type callback) { return pimpl->start(request_, method, get_body, callback); } private: shared_ptr > pimpl; }; typedef boost::shared_ptr connection_ptr; connection_ptr get_connection(resolver_type & resolver, basic_request const & request_, optional const & certificate_filename = optional(), optional const & verify_path = optional()) { string_type protocol_ = protocol(request_); connection_ptr connection_( new connection_impl( follow_redirect_ , boost::bind( &async_connection_policy::resolve, this, _1, _2, _3, _4 ) , resolver , boost::iequals(protocol_, string_type("https")) , certificate_filename , verify_path)); return connection_; } void cleanup() { } async_connection_policy(bool cache_resolved, bool follow_redirect) : resolver_base(cache_resolved), follow_redirect_(follow_redirect) {} bool follow_redirect_; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_POLICY_ASYNC_CONNECTION_HPP_ cpp-netlib-0.9.4/boost/network/protocol/http/policies/async_resolver.hpp000066400000000000000000000101301174460560600266020ustar00rootroot00000000000000#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 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-0.9.4/boost/network/protocol/http/policies/pooled_connection.hpp000066400000000000000000000212241174460560600272530ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_POOLED_CONNECTION_POLICY_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_POOLED_CONNECTION_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 #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; void cleanup() { host_connection_map().swap(host_connections); } struct connection_impl { typedef function(resolver_type &,basic_request 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, optional const & certificate_file=optional(), optional const & verify_path=optional()) : pimpl(impl::sync_connection_base::new_connection(resolver, resolve, https, certificate_file, verify_path)) , resolver_(resolver) , connection_follow_redirect_(follow_redirect) , get_connection_(get_connection) , certificate_filename_(certificate_file) , verify_path_(verify_path) {} basic_response send_request(string_type const & method, basic_request request_, bool get_body, body_callback_function_type callback) { return send_request_impl(method, request_, get_body); } private: basic_response send_request_impl(string_type const & method, basic_request request_, bool get_body) { 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_); 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 >::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_); ++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_, verify_path_; }; typedef shared_ptr connection_ptr; typedef unordered_map host_connection_map; host_connection_map host_connections; bool follow_redirect_; connection_ptr get_connection(resolver_type & resolver, basic_request const & request_, optional const & certificate_filename = optional(), optional const & verify_path = 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, _1, _2, _3 ) , boost::bind( &pooled_connection_policy::get_connection, this, _1, _2, _3, _4 ) , boost::iequals(request_.protocol(), string_type("https")) , certificate_filename , verify_path ) ); host_connections.insert(std::make_pair(index, connection_)); return connection_; } return it->second; } pooled_connection_policy(bool cache_resolved, bool follow_redirect) : resolver_base(cache_resolved), host_connections(), follow_redirect_(follow_redirect) {} }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_POOLED_CONNECTION_POLICY_20091214 cpp-netlib-0.9.4/boost/network/protocol/http/policies/simple_connection.hpp000066400000000000000000000124031174460560600272610ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SIMPLE_CONNECTION_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SIMPLE_CONNECTION_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 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; struct connection_impl { connection_impl(resolver_type & resolver, bool follow_redirect, string_type const & hostname, string_type const & port, resolver_function_type resolve, bool https, optional const & certificate_filename = optional(), optional const & verify_path = optional()) : pimpl() , follow_redirect_(follow_redirect) { pimpl.reset(impl::sync_connection_base::new_connection(resolver, resolve, https, certificate_filename, verify_path)); } basic_response send_request(string_type const & method, basic_request request_, bool get_body, body_callback_function_type callback) { basic_response response_; do { pimpl->init_socket(request_.host(), lexical_cast(request_.port())); pimpl->send_request_impl(method, request_); 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 >::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_ , optional const & certificate_file = optional() , optional const & verify_file = optional() ) { connection_ptr connection_( new connection_impl( resolver , follow_redirect_ , request_.host() , lexical_cast(request_.port()) , boost::bind( &simple_connection_policy::resolve, this, _1, _2, _3 ) , boost::iequals(request_.protocol(), string_type("https")) , certificate_file , verify_file ) ); return connection_; } void cleanup() { } simple_connection_policy(bool cache_resolved, bool follow_redirect) : resolver_base(cache_resolved), follow_redirect_(follow_redirect) {} // member variables bool follow_redirect_; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_SIMPLE_CONNECTION_20091214 cpp-netlib-0.9.4/boost/network/protocol/http/policies/sync_resolver.hpp000066400000000000000000000066131174460560600264540ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/request.hpp000066400000000000000000000062721174460560600234410ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/request_concept.hpp000066400000000000000000000071041174460560600251470ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/request_parser.hpp000066400000000000000000000054771174460560600250230ustar00rootroot00000000000000// // 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-0.9.4/boost/network/protocol/http/response.hpp000066400000000000000000000064661174460560600236140ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol/http/response_concept.hpp000066400000000000000000000040431174460560600253140ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/server.hpp000066400000000000000000000066621174460560600232620ustar00rootroot00000000000000// 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 #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; BOOST_PARAMETER_CONSTRUCTOR( server, (server_base), tag, (required (address, (typename server_base::string_type const &)) (port, (typename server_base::string_type const &)) (in_out(handler), (Handler &))) (optional (in_out(io_service), (boost::asio::io_service &)) (reuse_address, (bool)) (report_aborted, (bool)) (receive_buffer_size, (int)) (send_buffer_size, (int)) (receive_low_watermark, (int)) (send_low_watermark, (int)) (non_blocking_io, (int)) (linger, (bool)) (linger_timeout, (int))) ) }; template struct async_server : server_base::type { typedef typename server_base::type server_base; BOOST_PARAMETER_CONSTRUCTOR( async_server, (server_base), tag, (required (address, (typename server_base::string_type const &)) (port, (typename server_base::string_type const &)) (in_out(handler), (Handler&)) (in_out(thread_pool), (utils::thread_pool&))) (optional (in_out(io_service), (boost::asio::io_service&)) (reuse_address, (bool)) (report_aborted, (bool)) (receive_buffer_size, (int)) (send_buffer_size, (int)) (receive_low_watermark, (int)) (send_low_watermark, (int)) (non_blocking_io, (bool)) (linger, (bool)) (linger_timeout, (int))) ) }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_HTTP_SERVER_HPP_ cpp-netlib-0.9.4/boost/network/protocol/http/server/000077500000000000000000000000001174460560600225375ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/server/async_connection.hpp000066400000000000000000000702361174460560600266140ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_CONNECTION_HPP_20101027 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_CONNECTION_HPP_20101027 // 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 #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 , 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 }; 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" ; 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_; default: return unknown_; } } public: async_connection( asio::io_service & io_service , Handler & handler , utils::thread_pool & thread_pool ) : socket_(io_service) , strand(io_service) , handler(handler) , thread_pool_(thread_pool) , headers_already_sent(false) , headers_in_progress(false) , headers_buffer(BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE) { 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() , _1); write_impl( boost::make_iterator_range(range) , f ); } template typename disable_if, 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, 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 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))); } asio::ip::tcp::socket & 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::ip::tcp::socket socket_; asio::io_service::strand strand; Handler & handler; utils::thread_pool & thread_pool_; volatile bool headers_already_sent, headers_in_progress; asio::streambuf headers_buffer; 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) { 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 > ,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) ); } }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_CONNECTION_HPP_20101027 */ cpp-netlib-0.9.4/boost/network/protocol/http/server/async_server.hpp000066400000000000000000000147751174460560600257710ustar00rootroot00000000000000#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. // Distributed under the 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; template async_server_base(ArgPack const & args) : server_storage_base(args, typename mpl::if_< is_same< typename parameter::value_type::type, void >, server_storage_base::no_io_service, server_storage_base::has_io_service >::type()) , socket_options_base(args) , handler(args[_handler]) , address_(args[_address]) , port_(args[_port]) , thread_pool(args[_thread_pool]) , acceptor(server_storage_base::service_) , stopping(false) , new_connection() , listening_mutex_() , stopping_mutex_() , listening(false) {} 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_; utils::thread_pool & thread_pool; asio::ip::tcp::acceptor acceptor; bool stopping; connection_ptr new_connection; boost::mutex listening_mutex_; boost::mutex stopping_mutex_; bool listening; 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) { socket_options_base::socket_options(new_connection->socket()); new_connection->start(); new_connection.reset( new connection( service_ , handler , thread_pool ) ); acceptor.async_accept(new_connection->socket(), boost::bind( &async_server_base::handle_accept , this , boost::asio::placeholders::error ) ); } else { BOOST_NETWORK_MESSAGE("Error accepting connection, reason: " << ec); } } 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)); acceptor.async_accept(new_connection->socket(), 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-0.9.4/boost/network/protocol/http/server/impl/000077500000000000000000000000001174460560600235005ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/server/impl/parsers.ipp000066400000000000000000000031511174460560600256710ustar00rootroot00000000000000#ifndef SERVER_REQUEST_PARSERS_IMPL_UW3PM6V6 #define SERVER_REQUEST_PARSERS_IMPL_UW3PM6V6 #include // 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 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; parse( input.begin(), input.end(), *( +(alnum|(punct-':')) >> lit(": ") >> +((alnum|space|punct) - '\r' - '\n') >> lit("\r\n") ) >> lit("\r\n") , container ); } } /* http */ } /* network */ } /* boost */ #endif /* SERVER_REQUEST_PARSERS_IMPL_UW3PM6V6 */ cpp-netlib-0.9.4/boost/network/protocol/http/server/parameters.hpp000066400000000000000000000021021174460560600254060ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_PARAMETERS_HPP_20101210 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_PARAMETERS_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 { BOOST_PARAMETER_NAME(address) BOOST_PARAMETER_NAME(port) BOOST_PARAMETER_NAME(handler) BOOST_PARAMETER_NAME(thread_pool) BOOST_PARAMETER_NAME(reuse_address) BOOST_PARAMETER_NAME(report_aborted) BOOST_PARAMETER_NAME(receive_buffer_size) BOOST_PARAMETER_NAME(send_buffer_size) BOOST_PARAMETER_NAME(receive_low_watermark) BOOST_PARAMETER_NAME(send_low_watermark) BOOST_PARAMETER_NAME(non_blocking_io) BOOST_PARAMETER_NAME(linger) BOOST_PARAMETER_NAME(linger_timeout) } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_PARAMETERS_HPP_20101210 */ cpp-netlib-0.9.4/boost/network/protocol/http/server/request.hpp000066400000000000000000000023641174460560600247450ustar00rootroot00000000000000// // 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-0.9.4/boost/network/protocol/http/server/request_parser.hpp000066400000000000000000000176201174460560600263220ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/server/socket_options_base.hpp000066400000000000000000000071011174460560600273040ustar00rootroot00000000000000#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 #include #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 socket_options_base(ArgPack const & args) : acceptor_reuse_address(args[_reuse_address|false]) , acceptor_report_aborted(args[_report_aborted|false]) , non_blocking_io(args[_non_blocking_io|true]) , linger(args[_linger|true], args[_linger_timeout|0]) { set_optional(receive_buffer_size, args, _receive_buffer_size); set_optional(send_buffer_size, args, _send_buffer_size); set_optional(receive_low_watermark, args, _receive_low_watermark); set_optional(send_low_watermark, args, _send_low_watermark); } 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); } private: template typename boost::enable_if< mpl::not_< boost::is_same< typename boost::parameter::value_type::type , void > > , void >::type set_optional(Optional & option, Args const & args, Keyword const & keyword) { option = in_place(args[keyword]); } template typename boost::enable_if< boost::is_same< typename boost::parameter::value_type::type , void > , void >::type set_optional(Optional &, Args const &, Keyword const &) { // do nothing } }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SOCKET_OPTIONS_BASE_HPP_20101210 */ cpp-netlib-0.9.4/boost/network/protocol/http/server/storage_base.hpp000066400000000000000000000024031174460560600257050ustar00rootroot00000000000000#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 namespace boost { namespace network { namespace http { struct server_storage_base { struct no_io_service {}; struct has_io_service {}; protected: template server_storage_base(ArgPack const & /* args */, no_io_service) : self_service_(new boost::asio::io_service()) , service_(*self_service_) {} template server_storage_base(ArgPack const & args, has_io_service) : self_service_(0) , service_(args[_io_service]) {} ~server_storage_base() { delete self_service_; self_service_ = 0; } asio::io_service * self_service_; asio::io_service & service_; }; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_STORAGE_BASE_HPP_20101210 */ cpp-netlib-0.9.4/boost/network/protocol/http/server/sync_connection.hpp000066400000000000000000000276441174460560600264600ustar00rootroot00000000000000// 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(); 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-0.9.4/boost/network/protocol/http/server/sync_server.hpp000066400000000000000000000120521174460560600256120ustar00rootroot00000000000000 // 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; template sync_server_base(ArgPack const & args) : server_storage_base(args, typename mpl::if_< is_same< typename parameter::value_type::type, void >, server_storage_base::no_io_service, server_storage_base::has_io_service >::type()) , socket_options_base(args) , handler_(args[_handler]) , address_(args[_address]) , port_(args[_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_); return; } tcp::endpoint endpoint = *endpoint_iterator; acceptor_.open(endpoint.protocol(), error); if (error) { BOOST_NETWORK_MESSAGE("Error opening socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\''); return; } socket_options_base::acceptor_options(acceptor_); acceptor_.bind(endpoint, error); if (error) { BOOST_NETWORK_MESSAGE("Error binding to socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\''); return; } acceptor_.listen(tcp::socket::max_connections, error); if (error) { BOOST_NETWORK_MESSAGE("Error listening on socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\''); return; } 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-0.9.4/boost/network/protocol/http/support/000077500000000000000000000000001174460560600227455ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/support/client_or_server.hpp000066400000000000000000000022471174460560600270270ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/support/is_client.hpp000066400000000000000000000014421174460560600254300ustar00rootroot00000000000000#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::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_SUPPORT_IS_CLIENT_HPP_20101118 */ cpp-netlib-0.9.4/boost/network/protocol/http/support/is_http.hpp000066400000000000000000000014061174460560600251310ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/support/is_keepalive.hpp000066400000000000000000000015201174460560600261140ustar00rootroot00000000000000#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::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 */ cpp-netlib-0.9.4/boost/network/protocol/http/support/is_server.hpp000066400000000000000000000014411174460560600254570ustar00rootroot00000000000000#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::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_SUPPORT_IS_SERVER_HPP_20101118 */ cpp-netlib-0.9.4/boost/network/protocol/http/support/is_simple.hpp000066400000000000000000000014101174460560600254360ustar00rootroot00000000000000#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::type> : mpl::true_ {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 */ cpp-netlib-0.9.4/boost/network/protocol/http/support/sync_only.hpp000066400000000000000000000017471174460560600255040ustar00rootroot00000000000000#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< typename tags::components::type, is_same, tags::sync >::type , mpl::inherit > {}; } /* http */ } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_SYNC_ONLY_HPP_20100927 */ cpp-netlib-0.9.4/boost/network/protocol/http/tags.hpp000066400000000000000000000043461174460560600227070ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/traits.hpp000066400000000000000000000014241174460560600232510ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol/http/traits/000077500000000000000000000000001174460560600225375ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/traits/connection_keepalive.hpp000066400000000000000000000013601174460560600274340ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol/http/traits/connection_policy.hpp000066400000000000000000000041751174460560600267750ustar00rootroot00000000000000#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CONNECTION_POLICY_20091214 #define BOOST_NETWORK_PROTOCOL_HTTP_CONNECTION_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 #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, mpl::not_ > > >::type> { typedef simple_connection_policy type; }; template struct connection_policy, mpl::not_ > > >::type> { typedef pooled_connection_policy type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_CONNECTION_POLICY_20091214 cpp-netlib-0.9.4/boost/network/protocol/http/traits/delegate_factory.hpp000066400000000000000000000017741174460560600265620ustar00rootroot00000000000000#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-0.9.4/boost/network/protocol/http/traits/impl/000077500000000000000000000000001174460560600235005ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/protocol/http/traits/impl/chunk_cache.ipp000066400000000000000000000017341174460560600264520ustar00rootroot00000000000000 // 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< std::vector< typename char_::type > > type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_CHUNK_CACHE_CONTAINER_IPP cpp-netlib-0.9.4/boost/network/protocol/http/traits/impl/content.ipp000066400000000000000000000025231174460560600256660ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/cookie_name.ipp000066400000000000000000000013261174460560600264650ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/cookie_value.ipp000066400000000000000000000013421174460560600266570ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/cookies_container.ipp000066400000000000000000000015061174460560600277120ustar00rootroot00000000000000 // 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< typename string::type, typename string::type > type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_COOKIES_CONTAINER_IPP cpp-netlib-0.9.4/boost/network/protocol/http/traits/impl/delimiters.ipp000066400000000000000000000024141174460560600263540ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/header_name.ipp000066400000000000000000000013261174460560600264440ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/header_value.ipp000066400000000000000000000013421174460560600266360ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/headers.ipp000066400000000000000000000052701174460560600256310ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/headers_container.ipp000066400000000000000000000031421174460560600276670ustar00rootroot00000000000000 // 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_CONTAINER_IPP #define BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_CONTAINER_IPP #include #include #include #include #include namespace boost { namespace network { template <> struct headers_container { // Moving implementation from original // message_traits implementation by // Atomic Labs, Inc. // -- // returns true if str1 < str2 (ignoring case) struct is_less_ignore_case { inline bool operator() ( string::type const & str1, string::type const & str2) const { return to_lower_copy(str1) < to_lower_copy(str2); }; }; typedef std::multimap< string::type, string::type, is_less_ignore_case> type; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_HEADERS_CONTAINER_IPP cpp-netlib-0.9.4/boost/network/protocol/http/traits/impl/method.ipp000066400000000000000000000013041174460560600254700ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/post_content.ipp000066400000000000000000000013421174460560600267310ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/query_container.ipp000066400000000000000000000014751174460560600274300ustar00rootroot00000000000000 // 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< typename string::type, typename string::type > type; }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_MESSAGE_TRAITS_QUERY_CONTAINER_IPP cpp-netlib-0.9.4/boost/network/protocol/http/traits/impl/query_name.ipp000066400000000000000000000013221174460560600263550ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/query_string.ipp000066400000000000000000000013421174460560600267450ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/query_value.ipp000066400000000000000000000013361174460560600265560ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/request_methods.ipp000066400000000000000000000025641174460560600274340ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/resource.ipp000066400000000000000000000013211174460560600260360ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/response_code.ipp000066400000000000000000000032371174460560600270470ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/response_message.ipp000066400000000000000000000047771174460560600275730ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/impl/status_message.ipp000066400000000000000000000013501174460560600272400ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/message_traits.hpp000066400000000000000000000036311174460560600262650ustar00rootroot00000000000000 // 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-0.9.4/boost/network/protocol/http/traits/parser_traits.hpp000066400000000000000000000040431174460560600261330ustar00rootroot00000000000000// 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-0.9.4/boost/network/protocol/http/traits/resolver.hpp000066400000000000000000000031511174460560600251110ustar00rootroot00000000000000#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_< mpl::and_< is_tcp, is_http >, boost::asio::ip::tcp::resolver, typename mpl::if_< mpl::and_< is_udp, is_http >, boost::asio::ip::udp::resolver, unsupported_tag >::type > { BOOST_STATIC_ASSERT(( mpl::not_< mpl::and_< is_udp, is_tcp > >::value )); }; } // namespace http } // namespace network } // namespace boost #endif // BOOST_NETWORK_PROTOCOL_HTTP_TRAITS_RESOLVER_20091214 cpp-netlib-0.9.4/boost/network/protocol/http/traits/resolver_policy.hpp000066400000000000000000000023571174460560600264770ustar00rootroot00000000000000#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_< mpl::and_< is_async,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-0.9.4/boost/network/protocol/http/traits/vector.hpp000066400000000000000000000016001174460560600245470ustar00rootroot00000000000000#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-0.9.4/boost/network/support/000077500000000000000000000000001174460560600201255ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/support/is_async.hpp000066400000000000000000000013671174460560600224550ustar00rootroot00000000000000#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::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif //BOOST_NETWORK_SUPPORT_IS_ASYNC_HPP_2010608 cpp-netlib-0.9.4/boost/network/support/is_default_string.hpp000066400000000000000000000013631174460560600243460ustar00rootroot00000000000000// 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::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_STRING_CHECK_20100808 cpp-netlib-0.9.4/boost/network/support/is_default_wstring.hpp000066400000000000000000000013641174460560600245360ustar00rootroot00000000000000// 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::type> : mpl::true_ {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_SUPPORT_STRING_CHECK_20100808 cpp-netlib-0.9.4/boost/network/support/is_http.hpp000066400000000000000000000013221174460560600223060ustar00rootroot00000000000000#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-0.9.4/boost/network/support/is_keepalive.hpp000066400000000000000000000013551174460560600233020ustar00rootroot00000000000000#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::type> : mpl::true_ {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_KEEPALIVE_HPP_20100927 */ cpp-netlib-0.9.4/boost/network/support/is_pod.hpp000066400000000000000000000013021174460560600221070ustar00rootroot00000000000000#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-0.9.4/boost/network/support/is_simple.hpp000066400000000000000000000013271174460560600226250ustar00rootroot00000000000000#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::type> : mpl::true_ {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_IS_SIMPLE_HPP_20100927 */ cpp-netlib-0.9.4/boost/network/support/is_sync.hpp000066400000000000000000000013231174460560600223040ustar00rootroot00000000000000#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-0.9.4/boost/network/support/is_tcp.hpp000066400000000000000000000014171174460560600221220ustar00rootroot00000000000000#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-0.9.4/boost/network/support/is_udp.hpp000066400000000000000000000014671174460560600221310ustar00rootroot00000000000000#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_20100622cpp-netlib-0.9.4/boost/network/support/pod_or_normal.hpp000066400000000000000000000015131174460560600234700ustar00rootroot00000000000000#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::type> : tags::pod {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_PROTOCOL_HTTP_SUPPORT_POD_OR_NORMAL_HPP_20101128 */ cpp-netlib-0.9.4/boost/network/support/sync_only.hpp000066400000000000000000000017731174460560600226630ustar00rootroot00000000000000#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< typename tags::components::type, is_same, tags::sync >::type , mpl::inherit > {}; } /* network */ } /* boost */ #endif /* BOOST_NETWORK_SUPPORT_SYNC_ONLY_HPP_20100927 */ cpp-netlib-0.9.4/boost/network/tags.hpp000066400000000000000000000036111174460560600200610ustar00rootroot00000000000000// 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< \ name##_tags, \ mpl::inherit \ >::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-0.9.4/boost/network/traits/000077500000000000000000000000001174460560600177175ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/traits/char.hpp000066400000000000000000000017471174460560600213560ustar00rootroot00000000000000// 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-0.9.4/boost/network/traits/headers_container.hpp000066400000000000000000000013721174460560600241100ustar00rootroot00000000000000// Copyright (c) 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_HEADERS_CONTAINER_INC__ # define __BOOST_NETWORK_TRAITS_HEADERS_CONTAINER_INC__ # include # include # include namespace boost { namespace network { template struct headers_container { typedef std::multimap< typename string::type, typename string::type > type; }; } // namespace network } // namespace boost #endif // __BOOST_NETWORK_TRAITS_HEADERS_CONTAINER_INC__ cpp-netlib-0.9.4/boost/network/traits/istream.hpp000066400000000000000000000021071174460560600220740ustar00rootroot00000000000000 #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-0.9.4/boost/network/traits/istringstream.hpp000066400000000000000000000022571174460560600233310ustar00rootroot00000000000000// 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-0.9.4/boost/network/traits/ostream_iterator.hpp000066400000000000000000000020631174460560600240140ustar00rootroot00000000000000#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_< is_default_string, std::ostream_iterator, typename mpl::if_< is_default_wstring, std::ostream_iterator, unsupported_tag >::type > {}; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_OSTREAM_ITERATOR_HPP_20100815 cpp-netlib-0.9.4/boost/network/traits/ostringstream.hpp000066400000000000000000000023051174460560600233310ustar00rootroot00000000000000// 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-0.9.4/boost/network/traits/string.hpp000066400000000000000000000025231174460560600217400ustar00rootroot00000000000000// 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-0.9.4/boost/network/traits/vector.hpp000066400000000000000000000015041174460560600217320ustar00rootroot00000000000000// 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_< is_default_string , std::vector , unsupported_tag > {}; }; } // namespace network } // namespace boost #endif // BOOST_NETWORK_TRAITS_VECTOR_HPP cpp-netlib-0.9.4/boost/network/uri.hpp000066400000000000000000000004611174460560600177220ustar00rootroot00000000000000#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-0.9.4/boost/network/uri/000077500000000000000000000000001174460560600172105ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/uri/accessors.hpp000066400000000000000000000062461174460560600217160ustar00rootroot00000000000000// 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 < typename Map > 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 < class Map > 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-0.9.4/boost/network/uri/builder.hpp000066400000000000000000000101021174460560600213410ustar00rootroot00000000000000// 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-0.9.4/boost/network/uri/config.hpp000066400000000000000000000011411174460560600211630ustar00rootroot00000000000000// 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-0.9.4/boost/network/uri/decode.hpp000066400000000000000000000043531174460560600211510ustar00rootroot00000000000000// 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 < typename CharT > 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 < class InputIterator, class OutputIterator > 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 { *out++ = *it++; } } return out; } template < class SinglePassRange, class OutputIterator > 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-0.9.4/boost/network/uri/detail/000077500000000000000000000000001174460560600204525ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/uri/detail/uri_parts.hpp000066400000000000000000000053561174460560600232040ustar00rootroot00000000000000// 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 < class FwdIter > 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 < class FwdIter > 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-0.9.4/boost/network/uri/directives.hpp000066400000000000000000000023771174460560600220730ustar00rootroot00000000000000// 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 < class Directive > 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-0.9.4/boost/network/uri/directives/000077500000000000000000000000001174460560600213515ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/uri/directives/authority.hpp000066400000000000000000000016201174460560600241110ustar00rootroot00000000000000// 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 < class Uri > 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-0.9.4/boost/network/uri/directives/fragment.hpp000066400000000000000000000020101174460560600236560ustar00rootroot00000000000000// 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 < class Uri > 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-0.9.4/boost/network/uri/directives/host.hpp000066400000000000000000000016121174460560600230370ustar00rootroot00000000000000// 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 < class Uri > 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-0.9.4/boost/network/uri/directives/path.hpp000066400000000000000000000025161174460560600230220ustar00rootroot00000000000000// 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 < class Uri > 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-0.9.4/boost/network/uri/directives/port.hpp000066400000000000000000000022541174460560600230510ustar00rootroot00000000000000// 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 < class Uri > 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-0.9.4/boost/network/uri/directives/query.hpp000066400000000000000000000032471174460560600232350ustar00rootroot00000000000000// 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 < class Uri > 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 < class Uri > 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-0.9.4/boost/network/uri/directives/scheme.hpp000066400000000000000000000025271174460560600233340ustar00rootroot00000000000000// 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 < class Uri > 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-0.9.4/boost/network/uri/directives/user_info.hpp000066400000000000000000000017561174460560600240640ustar00rootroot00000000000000// 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 < class Uri > 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-0.9.4/boost/network/uri/encode.hpp000066400000000000000000000061601174460560600211610ustar00rootroot00000000000000// 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 < typename CharT > 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 < typename CharT, class OutputIterator > 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 < class InputIterator, class OutputIterator > 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 < class SinglePassRange, class OutputIterator > 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-0.9.4/boost/network/uri/schemes.hpp000066400000000000000000000012351174460560600213510ustar00rootroot00000000000000// 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-0.9.4/boost/network/uri/uri.hpp000066400000000000000000000241771174460560600205330ustar00rootroot00000000000000// 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 < class FwdIter > 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_); boost::swap(uri_parts_, other.uri_parts_); 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 < class FwdIter > 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_) { return uri::string_type(boost::begin(uri_.user_info_range()), boost::end(uri_.path_range())); } inline uri::string_type authority(const uri &uri_) { return uri::string_type(boost::begin(uri_.user_info_range()), boost::end(uri_.port_range())); } 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-0.9.4/boost/network/uri/uri.ipp000066400000000000000000000203231174460560600205210ustar00rootroot00000000000000// 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 < class String > struct uri_grammar : qi::grammar< typename String::const_iterator , detail::uri_parts()> { 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-0.9.4/boost/network/uri/uri_io.hpp000066400000000000000000000011511174460560600212050ustar00rootroot00000000000000// 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-0.9.4/boost/network/utils/000077500000000000000000000000001174460560600175515ustar00rootroot00000000000000cpp-netlib-0.9.4/boost/network/utils/thread_pool.hpp000066400000000000000000000071071174460560600225670ustar00rootroot00000000000000#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-0.9.4/boost/network/version.hpp000066400000000000000000000014251174460560600206110ustar00rootroot00000000000000#ifndef BOOST_NETWORK_VERSION_HPP_20091214 #define BOOST_NETWORK_VERSION_HPP_20091214 // Copyright Dean Michael Berris 2009. // 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 9 #define BOOST_NETLIB_VERSION_INCREMENT 0 #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-0.9.4/index.html000066400000000000000000000014701174460560600155710ustar00rootroot00000000000000 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-0.9.4/libs/000077500000000000000000000000001174460560600145235ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/mime/000077500000000000000000000000001174460560600154525ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/mime/To-Do.txt000066400000000000000000000007301174460560600171350ustar00rootroot00000000000000To 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-0.9.4/libs/mime/doc/000077500000000000000000000000001174460560600162175ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/mime/doc/Jamfile.v2000066400000000000000000000040631174460560600200420ustar00rootroot00000000000000# (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) path-constant boost-images : doc/src/images ; xml mime : mime.qbk ; boostbook standalone : mime : # HTML options first: # Use graphics not text for navigation: navig.graphics=1 # How far down we chunk nested sections, basically all of them: chunk.section.depth=3 # Don't put the first section on the same page as the TOC: chunk.first.sections=1 # How far down sections get TOC's toc.section.depth=10 # Max depth in each TOC: toc.max.depth=3 # How far down we go with TOC's generate.section.toc.level=10 # Path for links to Boost: boost.root=http://cpp-netlib.github.com/ # Path for libraries index: boost.libraries=http://www.boost.org/libs/libraries.htm # Use the main Boost stylesheet: html.stylesheet=../boostbook.css # PDF Options: # TOC Generation: this is needed for FOP-0.9 and later: #fop1.extensions=1 # Or enable this if you're using XEP: xep.extensions=1 # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9! fop.extensions=0 # No indent on body text: body.start.indent=0pt # Margin size: page.margin.inner=0.5in # Margin size: page.margin.outer=0.5in # Yes, we want graphics for admonishments: admon.graphics=1 # Set this one for PDF generation *only*: # default pnd graphics are awful in PDF form, # better use SVG's instead: pdf:admon.graphics.extension=".svg" pdf:admon.graphics.path=$(boost-images)/ ; cpp-netlib-0.9.4/libs/mime/doc/mime.qbk000066400000000000000000000043441174460560600176520ustar00rootroot00000000000000[/ (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-0.9.4/libs/mime/doc/quick_start.qbk000066400000000000000000000004011174460560600212420ustar00rootroot00000000000000[/ (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-0.9.4/libs/mime/example/000077500000000000000000000000001174460560600171055ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/mime/example/Jamfile.v2000066400000000000000000000010601174460560600207220ustar00rootroot00000000000000# # Copyright Marshall Clow 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) import os ; project mime_examples : requirements ../../../ $BOOST_ROOT msvc:WIN32_LEAN_AND_MEAN msvc:_SCL_SECURE_NO_WARNINGS 256 static ; exe basic_usage : basic_usage.cpp ; exe basic_parsing : basic_parsing.cpp ; cpp-netlib-0.9.4/libs/mime/example/basic_parsing.cpp000066400000000000000000000075411174460560600224240ustar00rootroot00000000000000// // 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-0.9.4/libs/mime/example/basic_usage.cpp000066400000000000000000000041171174460560600220610ustar00rootroot00000000000000// // 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-0.9.4/libs/mime/test/000077500000000000000000000000001174460560600164315ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/mime/test/CMakeLists.txt000066400000000000000000000005651174460560600211770ustar00rootroot00000000000000include_directories(${CPP-NETLIB_SOURCE_DIR}) find_package ( Boost 1.41.0 COMPONENTS unit_test_framework ) set ( Boost_USE_STATIC_LIBS ON ) set ( Boost_USE_MULTITHREADED ON ) if ( Boost_FOUND ) add_executable ( mime-roundtrip mime-roundtrip.cpp ) target_link_libraries ( mime-roundtrip ${Boost_LIBRARIES} ) add_test ( mime-roundtrip mime-roundtrip ) endif () cpp-netlib-0.9.4/libs/mime/test/Jamfile.v2000066400000000000000000000011161174460560600202500ustar00rootroot00000000000000# # Copyright Marshall Clow 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) import os ; project mime_test : requirements ../../../ /boost//unit_test_framework msvc:WIN32_LEAN_AND_MEAN msvc:_SCL_SECURE_NO_WARNINGS 256 static ; unit-test mime_round_trip : mime-roundtrip.cpp ; exe mime-structure : mime-structure.cpp ; cpp-netlib-0.9.4/libs/mime/test/TestMessages/000077500000000000000000000000001174460560600210405ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/mime/test/TestMessages/.gitattributes000066400000000000000000000000111174460560600237230ustar00rootroot00000000000000* -crlf cpp-netlib-0.9.4/libs/mime/test/TestMessages/00000001000066400000000000000000000046431174460560600216520ustar00rootroot00000000000000Resent-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-0.9.4/libs/mime/test/TestMessages/00000019000066400000000000000000000073531174460560600216640ustar00rootroot00000000000000Resent-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-0.9.4/libs/mime/test/TestMessages/00000431000066400000000000000000000177411174460560600216640ustar00rootroot00000000000000Marshall-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-0.9.4/libs/mime/test/TestMessages/00000975000066400000000000000000000112651174460560600216740ustar00rootroot00000000000000Resent-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-0.9.4/libs/mime/test/TestMessages/0019-NoBoundary000066400000000000000000000072551174460560600234430ustar00rootroot00000000000000Resent-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-0.9.4/libs/mime/test/mime-roundtrip.cpp000066400000000000000000000057001174460560600221120ustar00rootroot00000000000000/* 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 #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 *fileName ) { } } using namespace boost::unit_test; test_suite* init_unit_test_suite( int argc, char* argv[] ) { 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 0; } cpp-netlib-0.9.4/libs/mime/test/mime-structure.cpp000066400000000000000000000071731174460560600221320ustar00rootroot00000000000000/* 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-0.9.4/libs/mime/test/mimeParse.py000077500000000000000000000022051174460560600207270ustar00rootroot00000000000000#!/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-0.9.4/libs/network/000077500000000000000000000000001174460560600162145ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/benchmarks/000077500000000000000000000000001174460560600203315ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/benchmarks/README.rst000066400000000000000000000002101174460560600220110ustar00rootroot00000000000000Here we can collect some statistics about different areas of performance in the :mod:`cpp-netlib`, including run-time and compile-time. cpp-netlib-0.9.4/libs/network/build/000077500000000000000000000000001174460560600173135ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/build/CMakeLists.txt000066400000000000000000000005411174460560600220530ustar00rootroot00000000000000include_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-0.9.4/libs/network/build/Jamfile.v2000066400000000000000000000016701174460560600211370ustar00rootroot00000000000000 # 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) import os ; local BOOST_ROOT = [ os.environ BOOST_ROOT ] ; project cpp-netlib : requirements ../../../ $(BOOST_ROOT) 256 : source-location ../../../ ; cpp-pch client : boost/network/include/http/client.hpp ; cpp-pch server : boost/network/include/http/server.hpp ; lib cppnetlib-uri : libs/network/src/uri/parse.cpp ; lib cppnetlib-server-parsers : libs/network/src/server_request_parsers_impl.cpp ; lib cppnetlib-client-connections : libs/network/src/client.cpp ; install headers : client server : ../../../boost/network/include/http ; install libraries : cppnetlib-uri cppnetlib-server-parsers cppnetlib-client-connections ; alias all : headers ; cpp-netlib-0.9.4/libs/network/doc/000077500000000000000000000000001174460560600167615ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/.gitignore000066400000000000000000000000061174460560600207450ustar00rootroot00000000000000_buildcpp-netlib-0.9.4/libs/network/doc/Makefile000066400000000000000000000060761174460560600204320ustar00rootroot00000000000000# 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-0.9.4/libs/network/doc/_ext/000077500000000000000000000000001174460560600177205ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/_ext/adjusts.py000066400000000000000000000006701174460560600217520ustar00rootroot00000000000000from 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-0.9.4/libs/network/doc/_static/000077500000000000000000000000001174460560600204075ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/_static/Button-Info-icon.png000066400000000000000000000066531174460560600242210ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/_static/Button-Warning-icon.png000066400000000000000000000055371174460560600247330ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/_static/boost.png000066400000000000000000000320641174460560600222500ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/_static/cpp-netlib.css000066400000000000000000000221101174460560600231520ustar00rootroot00000000000000@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-0.9.4/libs/network/doc/_static/ftp_uri.png000066400000000000000000000617421174460560600225770ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/_static/mailto_uri.png000066400000000000000000000237541174460560600232740ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/_static/orange-background.jpg000066400000000000000000010521121174460560600245030ustar00rootroot00000000000000ÿØÿà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-0.9.4/libs/network/doc/_static/pygments.css000066400000000000000000000067061174460560600230000ustar00rootroot00000000000000.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-0.9.4/libs/network/doc/_static/reset-fonts-grids.css000066400000000000000000000126221174460560600245030ustar00rootroot00000000000000/* 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-0.9.4/libs/network/doc/_static/uri.svg000066400000000000000000000721231174460560600217340ustar00rootroot00000000000000 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-0.9.4/libs/network/doc/_templates/000077500000000000000000000000001174460560600211165ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/_templates/genindex.html000066400000000000000000000001541174460560600236050ustar00rootroot00000000000000{% extends "!genindex.html" %} {% block bodyclass %}{% endblock %} {% block sidebarwrapper %}{% endblock %}cpp-netlib-0.9.4/libs/network/doc/_templates/layout.html000066400000000000000000000070301174460560600233210ustar00rootroot00000000000000{% extends "!layout.html" %} {%- macro secondnav() %} {%- if prev %} « previous {{ reldelim2 }} {%- endif %} {%- if parents %} up {%- else %} up {%- endif %} {%- if next %} {{ reldelim2 }} next » {%- endif %} {%- endmacro %} {% block extrahead %} {% endblock %} {% block document %}

{% block body %}{% endblock %}
{% block sidebarwrapper %} {% if pagename != 'index' %} {%- endif %} {% endblock %}
{{ secondnav() }}
{% endblock %} {% block sidebarrel %}

Browse

You are here:

{% endblock %} {# Empty some default blocks out #} {% block relbar1 %}{% endblock %} {% block relbar2 %}{% endblock %} {% block sidebar1 %}{% endblock %} {% block sidebar2 %}{% endblock %} {% block footer %}
documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
{% endblock %} cpp-netlib-0.9.4/libs/network/doc/_templates/modindex.html000066400000000000000000000001531174460560600236120ustar00rootroot00000000000000{% extends "!modindex.html" %} {% block bodyclass %}{% endblock %} {% block sidebarwrapper %}{% endblock %}cpp-netlib-0.9.4/libs/network/doc/_templates/search.html000066400000000000000000000001511174460560600232460ustar00rootroot00000000000000{% extends "!search.html" %} {% block bodyclass %}{% endblock %} {% block sidebarwrapper %}{% endblock %}cpp-netlib-0.9.4/libs/network/doc/conf.py000066400000000000000000000101211174460560600202530ustar00rootroot00000000000000# -*- 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-2012, Glyn Matthews, Dean Michael Berris' # 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.9' # The full version, including alpha/beta/rc tags. release = '0.9.4' # 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 = 'bw' # 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 = 'default' # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". html_title = 'cpp-netlib v0.9.4' # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = 'cpp-netlib' # 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-0.9.4/libs/network/doc/contents.rst000066400000000000000000000003141174460560600213460ustar00rootroot00000000000000.. _contents: Contents -------- .. toctree:: :maxdepth: 3 whats_new.rst getting_started.rst examples.rst in_depth.rst techniques.rst history.rst reference.rst references.rst cpp-netlib-0.9.4/libs/network/doc/examples.rst000066400000000000000000000014421174460560600213320ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/examples/000077500000000000000000000000001174460560600205775ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/examples/http/000077500000000000000000000000001174460560600215565ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/examples/http/atom_reader.rst000066400000000000000000000041671174460560600246020ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/examples/http/hello_world_client.rst000066400000000000000000000053241174460560600261640ustar00rootroot00000000000000.. _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, "application/xml", some_xml_string); std::data = body(response); The next set of examples show some more practical applications using the :mod:`cpp-netlib` HTTP client. cpp-netlib-0.9.4/libs/network/doc/examples/http/hello_world_server.rst000066400000000000000000000103251174460560600262110ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/examples/http/http_client.rst000066400000000000000000000065751174460560600246420ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/examples/http/simple_wget.rst000066400000000000000000000060541174460560600246340ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/examples/http/twitter_search.rst000066400000000000000000000066061174460560600253470ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/getting_started.rst000066400000000000000000000165531174460560600227140ustar00rootroot00000000000000.. _getting_started: ***************** Getting Started ***************** Downloading an official release =============================== All stable versions of :mod:`cpp-netlib` can be downloaded from Github_ from this url: http://github.com/cpp-netlib/cpp-netlib/downloads Each release is available as gzipped (Using the command ``tar xzf cpp-netlib.tar.gz``) or bzipped (Using ``tar xjf cpp-netlib.tar.bz2``) tarball, or as a zipfile (``unzip cpp-netlib.zip``, or on Windows using a tool such as 7zip_). .. _Github: http://github.com/cpp-netlib/cpp-netlib/downloads .. _7zip: http://www.7-zip.org/ Downloading a development version ================================= The :mod:`cpp-netlib` uses Git_ for source control, so to use any development versions Git must be installed on your system. Using the command line, the command to get the latest code is: :: shell$ git clone git://github.com/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.45.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 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``. 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 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, :mod:`cpp-netlib` produces three static libraries. Using GCC on Linux these are:: libcppnetlib-client-connections.a libcppnetlib-server-parsers.a libcppnetlib-uri.a And 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``. 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-0.9.4/libs/network/doc/history.rst000066400000000000000000000041711174460560600212170ustar00rootroot00000000000000Project 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-0.9.4/libs/network/doc/html/000077500000000000000000000000001174460560600177255ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/.buildinfo000066400000000000000000000003461174460560600217040ustar00rootroot00000000000000# 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: 2782e6e8740d26e9cc1f54812c829fe8 tags: fbb0d17656682115ca4d033fb2f83ba1 cpp-netlib-0.9.4/libs/network/doc/html/_images/000077500000000000000000000000001174460560600213315ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_images/boost.png000066400000000000000000000320641174460560600231720ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/html/_images/ftp_uri.png000066400000000000000000000617421174460560600235210ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/html/_images/mailto_uri.png000066400000000000000000000237541174460560600242160ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/html/_sources/000077500000000000000000000000001174460560600215475ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_sources/contents.txt000066400000000000000000000003141174460560600241430ustar00rootroot00000000000000.. _contents: Contents -------- .. toctree:: :maxdepth: 3 whats_new.rst getting_started.rst examples.rst in_depth.rst techniques.rst history.rst reference.rst references.rst cpp-netlib-0.9.4/libs/network/doc/html/_sources/examples.txt000066400000000000000000000014421174460560600241270ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/examples/000077500000000000000000000000001174460560600233655ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_sources/examples/http/000077500000000000000000000000001174460560600243445ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_sources/examples/http/atom_reader.txt000066400000000000000000000041671174460560600273770ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/examples/http/hello_world_client.txt000066400000000000000000000053241174460560600307610ustar00rootroot00000000000000.. _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, "application/xml", some_xml_string); std::data = body(response); The next set of examples show some more practical applications using the :mod:`cpp-netlib` HTTP client. cpp-netlib-0.9.4/libs/network/doc/html/_sources/examples/http/hello_world_server.txt000066400000000000000000000103251174460560600310060ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/examples/http/http_client.txt000066400000000000000000000065751174460560600274370ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/examples/http/simple_wget.txt000066400000000000000000000060541174460560600274310ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/examples/http/twitter_search.txt000066400000000000000000000066061174460560600301440ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/getting_started.txt000066400000000000000000000165531174460560600255110ustar00rootroot00000000000000.. _getting_started: ***************** Getting Started ***************** Downloading an official release =============================== All stable versions of :mod:`cpp-netlib` can be downloaded from Github_ from this url: http://github.com/cpp-netlib/cpp-netlib/downloads Each release is available as gzipped (Using the command ``tar xzf cpp-netlib.tar.gz``) or bzipped (Using ``tar xjf cpp-netlib.tar.bz2``) tarball, or as a zipfile (``unzip cpp-netlib.zip``, or on Windows using a tool such as 7zip_). .. _Github: http://github.com/cpp-netlib/cpp-netlib/downloads .. _7zip: http://www.7-zip.org/ Downloading a development version ================================= The :mod:`cpp-netlib` uses Git_ for source control, so to use any development versions Git must be installed on your system. Using the command line, the command to get the latest code is: :: shell$ git clone git://github.com/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.45.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 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``. 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 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, :mod:`cpp-netlib` produces three static libraries. Using GCC on Linux these are:: libcppnetlib-client-connections.a libcppnetlib-server-parsers.a libcppnetlib-uri.a And 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``. 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-0.9.4/libs/network/doc/html/_sources/history.txt000066400000000000000000000041711174460560600240140ustar00rootroot00000000000000Project 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-0.9.4/libs/network/doc/html/_sources/in_depth.txt000066400000000000000000000005331174460560600241030ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/in_depth/000077500000000000000000000000001174460560600233415ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_sources/in_depth/http.txt000066400000000000000000000127411174460560600250660ustar00rootroot00000000000000HTTP 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_default_8bit_udp_resolve`` tag, and implements HTTP 1.0. 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-0.9.4/libs/network/doc/html/_sources/in_depth/http_client_tags.txt000066400000000000000000000062631174460560600274440ustar00rootroot00000000000000+---------------------------------+---------------------------------------------+ | 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-0.9.4/libs/network/doc/html/_sources/in_depth/message.txt000066400000000000000000000246701174460560600255370ustar00rootroot00000000000000The 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 is under review at present and will be subject to change in newer versions. 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-0.9.4/libs/network/doc/html/_sources/in_depth/uri.txt000066400000000000000000000134011174460560600247000ustar00rootroot00000000000000The 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-0.9.4/libs/network/doc/html/_sources/index.txt000066400000000000000000000100041174460560600234120ustar00rootroot00000000000000.. _index: .. rubric:: Straightforward network programming in modern C++ .. :Authors: Glyn Matthews .. Dean Michael Berris .. :Date: Feb 22, 2012 .. :Version: 0.9.4 .. :Description: Complete user documentation, with examples, for the :mod:`cpp-netlib`. .. :Copyright: Copyright Glyn Matthews, Dean Michael Berris 2008-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) Getting cpp-netlib ================== **Download** You can download the latest releases of the library at: http://github.com/cpp-netlib/cpp-netlib/downloads 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. Boost ===== The :mod:`cpp-netlib` is being developed for eventual submission to Boost_. .. image:: _static/boost.png :align: left C++ Network Library =================== The :mod:`cpp-netlib` is a library 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. It is developed by people linked to the Boost_ community and will soon be submitted for review into Boost. A presentation about :mod:`cpp-netlib` was given at `BoostCon 2010`_, for which the `slides`_ and the `paper`_ can be found on-line. 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:: c++ 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:: c++ 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 server_("0.0.0.0", "8000", handler_); 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 ` .. 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/ .. _`BoostCon 2010`: http://www.boostcon.com/ .. _`slides`: http://www.filetolink.com/b0e89d06 .. _`paper`: http://github.com/downloads/mikhailberis/cpp-netlib-boostcon-paper/cpp-netlib.pdf .. _Git: http://git-scm.com/ .. _GitHub: http://github.com/ cpp-netlib-0.9.4/libs/network/doc/html/_sources/reference.txt000066400000000000000000000005311174460560600242450ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/html/_sources/reference/000077500000000000000000000000001174460560600235055ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_sources/reference/http_client.txt000066400000000000000000000366601174460560600265760ustar00rootroot00000000000000 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. * **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 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. 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 erros 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. 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. 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. Constructors ~~~~~~~~~~~~ The client implementation can be default constructed, or customized at initialization. ``client()`` Default constructor. ``client(boost::asio::io_service & io_service)`` Construct a client to use an existing Boost.Asio ``io_service`` instance. ``template client(ArgPack const & args)`` Pass in an argument pack. See supported parameters in the table below. +----------------------+-------------------------------+-------------------------+ | 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 | ``boost::asio::io_service &`` | Reference to an | | | | instance of 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. | +----------------------+-------------------------------+-------------------------+ 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 boost::asio::io_service my_io_service; client client_(_follow_redirects=true, _cache_resolved=true, _io_service=my_io_service , _openssl_certificate="/tmp/my-cert" , _openssl_verify_path="/tmp/ca-certs/"); // 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_, _body_handler=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_, _body_handler=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, _body_handler=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_, content_type, body)`` 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_, content_type, body, _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 &)``. ``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_, _body_handler=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, _body_handler=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_, content_type, body)`` 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_, content_type, body, _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 &)``. ``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=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/"), _body_handler=print_body); The ``BOOST_NETWORK_HTTP_BODY_CALLBACK`` macro is defined in ``boost/network/protocol/http/client/macros.hpp``. cpp-netlib-0.9.4/libs/network/doc/html/_sources/reference/http_request.txt000066400000000000000000000316341174460560600270040ustar00rootroot00000000000000 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: 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-0.9.4/libs/network/doc/html/_sources/reference/http_response.txt000066400000000000000000000427461174460560600271600ustar00rootroot00000000000000 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. 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: 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 string::type`` 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-0.9.4/libs/network/doc/html/_sources/reference/http_server.txt000066400000000000000000000632511174460560600266220ustar00rootroot00000000000000 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 ``````````` ``http_server(address, port, handler)`` Construct an HTTP Server instance, passing in the address and port as ``std::string const &`` and handler being of type ``handler_type`` but passed in as an lvalue reference. ``template client(ArgPack const & args)`` Pass in an argument pack. See supported parameters in the table below. +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | 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. | +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | _handler | ``Handler &`` | An lvalue reference to an instance of ``Handler``. This parameter is required. | +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | _thread_pool | ``boost::network::utils::thread_pool &`` | An lvalue reference 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 | ``boost::asio::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``. | +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ 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 boost::asio::io_service my_io_service; boost::network::utils::thread_pool pool(2); handler handler_instance; async_server instance(_address="0.0.0.0", _port="80", _handler=handler_instance, _io_service=my_io_service, _thread_pool=pool, _reuse_address=true); 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 server("127.0.0.1", "8000", handler); ``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 applacation 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 ``````````` ``http_server(address, port, handler, thread_pool)`` Construct an HTTP Server instance, passing in the address and port as ``std::string const &`` and handler being of type ``handler_type`` but passed in as an lvalue reference. The ``thread_pool`` parameter is an instance of ``boost::network::utils::thread_pool`` that has been previously instantiated. .. note:: The ``boost::network::utils::thread_pool`` has a single constructor parameter which is the number of threads to run the thread pool. 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; boost::network::utils::thread_pool thread_pool(2); http_server server("127.0.0.1", "8000", handler, thread_pool); ``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. .. _Boost.Range: http://www.boost.org/libs/range .. _Boost.Function: http://www.boost.org/libs/function cpp-netlib-0.9.4/libs/network/doc/html/_sources/references.txt000066400000000000000000000020141174460560600244260ustar00rootroot00000000000000References ========== 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-0.9.4/libs/network/doc/html/_sources/techniques.txt000066400000000000000000000004111174460560600244540ustar00rootroot00000000000000Techniques ========== 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-0.9.4/libs/network/doc/html/_sources/techniques/000077500000000000000000000000001174460560600237175ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_sources/techniques/directives.txt000066400000000000000000000066741174460560600266360ustar00rootroot00000000000000Directives ========== 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-0.9.4/libs/network/doc/html/_sources/techniques/polymorphism.txt000066400000000000000000000065001174460560600272230ustar00rootroot00000000000000Static 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-0.9.4/libs/network/doc/html/_sources/techniques/tag_metafunctions.txt000066400000000000000000000130661174460560600302000ustar00rootroot00000000000000Tag 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-0.9.4/libs/network/doc/html/_sources/whats_new.txt000066400000000000000000000103011174460560600243020ustar00rootroot00000000000000.. _whats_new: ************ What's New ************ :mod:`cpp-netlib` 0.9 --------------------- 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-0.9.4/libs/network/doc/html/_static/000077500000000000000000000000001174460560600213535ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/_static/Button-Info-icon.png000066400000000000000000000066531174460560600251650ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/html/_static/Button-Warning-icon.png000066400000000000000000000055371174460560600256770ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/html/_static/basic.css000066400000000000000000000201161174460560600231460ustar00rootroot00000000000000/* * 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; } 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 { clear: both; 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; } /* -- 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-0.9.4/libs/network/doc/html/_static/boost.png000066400000000000000000000320641174460560600232140ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/html/_static/cpp-netlib.css000066400000000000000000000221101174460560600241160ustar00rootroot00000000000000@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-0.9.4/libs/network/doc/html/_static/default.css000066400000000000000000000077101174460560600235160ustar00rootroot00000000000000/* * 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-0.9.4/libs/network/doc/html/_static/doctools.js000066400000000000000000000153271174460560600235470ustar00rootroot00000000000000/* * doctools.js * ~~~~~~~~~~~ * * Sphinx JavaScript utilties 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($('.sidebar .this-page-menu')); } }, /** * 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() { $('.sidebar .this-page-menu li.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-0.9.4/libs/network/doc/html/_static/file.png000066400000000000000000000004701174460560600230010ustar00rootroot00000000000000‰PNG  IHDR(-SoPLTE•••™™™•••hs„it†mymz’n{’n{“rŸÏ†Œ”‰”¢‰˜­‰™®Šš¯š¸Ø¨ÂÌÀÔÄÄÄÄÅÅÅÆÆÆÇÇÇêêêëëëìììííåííííñÖîîîïïïðððñññòòòÿÿÿ$­§tRNSV¨¬´5ØÞgsIDATxÚeÏÑ‚ …áÍÒ4Ö,2 ¶ ÐÞÿe°ñ¿üÎrQtü‰0c­%âÁ<§é{o縳+`Ó..Ò{þÐÿBå z|G­µ€ávïû«€¶»œ›ZÍXå–ì¼a^ìÿrBQûV¥~do|˜IEND®B`‚cpp-netlib-0.9.4/libs/network/doc/html/_static/ftp_uri.png000066400000000000000000000617421174460560600235430ustar00rootroot00000000000000‰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-0.9.4/libs/network/doc/html/_static/jquery.js000066400000000000000000007152521174460560600232440ustar00rootroot00000000000000/*! * jQuery JavaScript Library v1.6.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 Jun 30 14:16:56 2011 -0400 */ (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 // (both of which we optimize for) 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+$/, // Check for digits rdigit = /\d/, // 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])/ig, // 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.6.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.done( fn ); return this; }, eq: function( 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.resolveWith( document, [ jQuery ] ); // Trigger any bound ready events if ( jQuery.fn.trigger ) { jQuery( document ).trigger( "ready" ).unbind( "ready" ); } } }, bindReady: function() { if ( readyList ) { return; } readyList = jQuery._Deferred(); // 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"; }, // A crude way of determining if an object is a window isWindow: function( obj ) { return obj && typeof obj === "object" && "setInterval" in obj; }, isNaN: function( obj ) { return obj == null || !rdigit.test( obj ) || isNaN( 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; } // Not own constructor property must be Object if ( obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { 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 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 // (xml & tmp used internally) parseXML: function( data , xml , tmp ) { 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 ); } tmp = xml.documentElement; if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) { 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 ); } }, // Converts a dashed string to camelCased string; // Used by both the css and data modules camelCase: function( string ) { return string.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' // The extra typeof function check is to prevent crashes // in Safari 2 (See: #3039) // 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 ) { if ( indexOf ) { return indexOf.call( array, elem ); } for ( var i = 0, length = array.length; i < length; i++ ) { if ( 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, key, value, exec, fn, pass ) { var length = elems.length; // Setting many attributes if ( typeof key === "object" ) { for ( var k in key ) { jQuery.access( elems, k, key[k], exec, fn, value ); } return elems; } // Setting one attribute if ( value !== undefined ) { // Optionally, function values get executed if exec is true exec = !pass && exec && jQuery.isFunction(value); for ( var i = 0; i < length; i++ ) { fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); } return elems; } // Getting an attribute return length ? fn( elems[0], key ) : undefined; }, 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; })(); var // Promise methods promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ), // Static reference to slice sliceDeferred = [].slice; jQuery.extend({ // Create a simple deferred (one callbacks list) _Deferred: function() { var // callbacks list callbacks = [], // stored [ context , args ] fired, // to avoid firing when already doing so firing, // flag to know if the deferred has been cancelled cancelled, // the deferred itself deferred = { // done( f1, f2, ...) done: function() { if ( !cancelled ) { var args = arguments, i, length, elem, type, _fired; if ( fired ) { _fired = fired; fired = 0; } for ( i = 0, length = args.length; i < length; i++ ) { elem = args[ i ]; type = jQuery.type( elem ); if ( type === "array" ) { deferred.done.apply( deferred, elem ); } else if ( type === "function" ) { callbacks.push( elem ); } } if ( _fired ) { deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] ); } } return this; }, // resolve with given context and args resolveWith: function( context, args ) { if ( !cancelled && !fired && !firing ) { // make sure args are available (#8421) args = args || []; firing = 1; try { while( callbacks[ 0 ] ) { callbacks.shift().apply( context, args ); } } finally { fired = [ context, args ]; firing = 0; } } return this; }, // resolve with this as context and given arguments resolve: function() { deferred.resolveWith( this, arguments ); return this; }, // Has this deferred been resolved? isResolved: function() { return !!( firing || fired ); }, // Cancel cancel: function() { cancelled = 1; callbacks = []; return this; } }; return deferred; }, // Full fledged deferred (two callbacks list) Deferred: function( func ) { var deferred = jQuery._Deferred(), failDeferred = jQuery._Deferred(), promise; // Add errorDeferred methods, then and promise jQuery.extend( deferred, { then: function( doneCallbacks, failCallbacks ) { deferred.done( doneCallbacks ).fail( failCallbacks ); return this; }, always: function() { return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments ); }, fail: failDeferred.done, rejectWith: failDeferred.resolveWith, reject: failDeferred.resolve, isRejected: failDeferred.isResolved, pipe: function( fnDone, fnFail ) { return jQuery.Deferred(function( newDefer ) { jQuery.each( { done: [ fnDone, "resolve" ], fail: [ fnFail, "reject" ] }, 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 ); } else { newDefer[ action ]( 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 ) { if ( promise ) { return promise; } promise = obj = {}; } var i = promiseMethods.length; while( i-- ) { obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ]; } return obj; } }); // Make sure only one callback list will be used deferred.done( failDeferred.cancel ).fail( deferred.cancel ); // Unexpose cancel delete deferred.cancel; // Call given func if any if ( func ) { func.call( deferred, deferred ); } return deferred; }, // Deferred helper when: function( firstParam ) { var args = arguments, i = 0, length = args.length, count = length, deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ? firstParam : jQuery.Deferred(); function resolveFunc( i ) { return function( value ) { args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; if ( !( --count ) ) { // Strange bug in FF4: // Values changed onto the arguments object sometimes end up as undefined values // outside the $.when method. Cloning the object into a fresh array solves the issue deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) ); } }; } if ( length > 1 ) { for( ; i < length; i++ ) { if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) { args[ i ].promise().then( resolveFunc(i), deferred.reject ); } else { --count; } } if ( !count ) { deferred.resolveWith( deferred, args ); } } else if ( deferred !== firstParam ) { deferred.resolveWith( deferred, length ? [ firstParam ] : [] ); } return deferred.promise(); } }); jQuery.support = (function() { var div = document.createElement( "div" ), documentElement = document.documentElement, all, a, select, opt, input, marginDiv, support, fragment, body, testElementParent, testElement, testElementStyle, tds, events, eventName, i, isSupported; // 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", // Will be defined later submitBubbles: true, changeBubbles: true, focusinBubbles: false, deleteExpando: true, noCloneEvent: true, inlineBlockNeedsLayout: false, shrinkWrapBlocks: false, reliableMarginRight: true }; // 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 it's 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"); div.appendChild( input ); fragment = document.createDocumentFragment(); fragment.appendChild( div.firstChild ); // WebKit doesn't clone checked state correctly in fragments support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; div.innerHTML = ""; // Figure out if the W3C box model works as expected div.style.width = div.style.paddingLeft = "1px"; body = document.getElementsByTagName( "body" )[ 0 ]; // We use our own, invisible, body unless the body is already present // in which case we use a div (#9239) testElement = document.createElement( body ? "div" : "body" ); testElementStyle = { visibility: "hidden", width: 0, height: 0, border: 0, margin: 0 }; if ( body ) { jQuery.extend( testElementStyle, { position: "absolute", left: -1000, top: -1000 }); } for ( i in testElementStyle ) { testElement.style[ i ] = testElementStyle[ i ]; } testElement.appendChild( div ); testElementParent = body || documentElement; testElementParent.insertBefore( testElement, testElementParent.firstChild ); // Check if a disconnected checkbox will retain its checked // value of true after appended to the DOM (IE6/7) support.appendChecked = input.checked; support.boxModel = div.offsetWidth === 2; if ( "zoom" in div.style ) { // 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.style.display = "inline"; div.style.zoom = 1; support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 ); // Check if elements with layout shrink-wrap their children // (IE 6 does this) div.style.display = ""; div.innerHTML = "
    "; support.shrinkWrapBlocks = ( div.offsetWidth !== 2 ); } div.innerHTML = "
    t
    "; tds = div.getElementsByTagName( "td" ); // 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) 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 ); div.innerHTML = ""; // 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 ( document.defaultView && document.defaultView.getComputedStyle ) { marginDiv = document.createElement( "div" ); marginDiv.style.width = "0"; marginDiv.style.marginRight = "0"; div.appendChild( marginDiv ); support.reliableMarginRight = ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; } // Remove the body element we added testElement.innerHTML = ""; testElementParent.removeChild( testElement ); // Technique from Juriy Zaytsev // http://thinkweb2.com/projects/prototype/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; } } // Null connected elements to avoid leaks in IE testElement = fragment = select = opt = body = marginDiv = div = input = null; return support; })(); // Keep track of boxModel jQuery.boxModel = jQuery.support.boxModel; var rbrace = /^(?:\{.*\}|\[.*\])$/, rmultiDash = /([a-z])([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 internalKey = jQuery.expando, getByName = typeof name === "string", thisCache, // 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[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando; // 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 || (pvt && id && !cache[ id ][ internalKey ])) && 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[ jQuery.expando ] = id = ++jQuery.uuid; } else { id = jQuery.expando; } } if ( !cache[ id ] ) { cache[ id ] = {}; // TODO: This is a hack for 1.5 ONLY. 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 ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name); } else { cache[ id ] = jQuery.extend(cache[ id ], name); } } thisCache = cache[ id ]; // Internal jQuery data is stored in a separate object inside the object's data // cache in order to avoid key collisions between internal data and user-defined // data if ( pvt ) { if ( !thisCache[ internalKey ] ) { thisCache[ internalKey ] = {}; } thisCache = thisCache[ internalKey ]; } if ( data !== undefined ) { thisCache[ jQuery.camelCase( name ) ] = data; } // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should // not attempt to inspect the internal events object using jQuery.data, as this // internal data object is undocumented and subject to change. if ( name === "events" && !thisCache[name] ) { return thisCache[ internalKey ] && thisCache[ internalKey ].events; } return getByName ? // Check for both converted-to-camel and non-converted data property names thisCache[ jQuery.camelCase( name ) ] || thisCache[ name ] : thisCache; }, removeData: function( elem, name, pvt /* Internal Use Only */ ) { if ( !jQuery.acceptData( elem ) ) { return; } var 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[ jQuery.expando ] : jQuery.expando; // If there is already no cache entry for this object, there is no // purpose in continuing if ( !cache[ id ] ) { return; } if ( name ) { var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ]; if ( thisCache ) { delete thisCache[ name ]; // If there is no data left in the cache, we want to continue // and let the cache object itself get destroyed if ( !isEmptyDataObject(thisCache) ) { return; } } } // See jQuery.data for more information if ( pvt ) { delete cache[ id ][ internalKey ]; // Don't destroy the parent cache unless the internal data object // had been the only thing left in it if ( !isEmptyDataObject(cache[ id ]) ) { return; } } var internalCache = cache[ id ][ internalKey ]; // 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 if ( jQuery.support.deleteExpando || cache != window ) { delete cache[ id ]; } else { cache[ id ] = null; } // We destroyed the entire user cache at once because it's faster than // iterating through each key, but we need to continue to persist internal // data if it existed if ( internalCache ) { cache[ id ] = {}; // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery // metadata on plain JS objects when the object is serialized using // JSON.stringify if ( !isNode ) { cache[ id ].toJSON = jQuery.noop; } cache[ id ][ internalKey ] = internalCache; // Otherwise, we need to eliminate the expando on the node to avoid // false lookups in the cache for entries that no longer exist } else 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[ jQuery.expando ]; } else if ( elem.removeAttribute ) { elem.removeAttribute( jQuery.expando ); } else { elem[ jQuery.expando ] = 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 data = null; if ( typeof key === "undefined" ) { if ( this.length ) { data = jQuery.data( this[0] ); if ( this[0].nodeType === 1 ) { var attr = this[0].attributes, name; for ( var i = 0, l = attr.length; i < l; i++ ) { name = attr[i].name; if ( name.indexOf( "data-" ) === 0 ) { name = jQuery.camelCase( name.substring(5) ); dataAttr( this[0], name, data[ name ] ); } } } } return data; } else if ( typeof key === "object" ) { return this.each(function() { jQuery.data( this, key ); }); } var parts = key.split("."); parts[1] = parts[1] ? "." + parts[1] : ""; if ( value === undefined ) { data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); // Try to fetch any internally stored data first if ( data === undefined && this.length ) { data = jQuery.data( this[0], key ); data = dataAttr( this[0], key, data ); } return data === undefined && parts[1] ? this.data( parts[0] ) : data; } else { return this.each(function() { var $this = jQuery( this ), args = [ parts[0], value ]; $this.triggerHandler( "setData" + parts[1] + "!", args ); jQuery.data( this, key, value ); $this.triggerHandler( "changeData" + parts[1] + "!", args ); }); } }, 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-$2" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { try { data = data === "true" ? true : data === "false" ? false : data === "null" ? null : !jQuery.isNaN( data ) ? parseFloat( 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; } // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON // property to be considered empty objects; this property always exists in // order to make sure JSON.stringify does not expose internal metadata function isEmptyDataObject( obj ) { for ( var name in obj ) { 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, undefined, true ); if ( defer && ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) && ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) { // 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, undefined, true ) && !jQuery.data( elem, markDataKey, undefined, true ) ) { jQuery.removeData( elem, deferDataKey, true ); defer.resolve(); } }, 0 ); } } jQuery.extend({ _mark: function( elem, type ) { if ( elem ) { type = (type || "fx") + "mark"; jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true ); } }, _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, undefined, true) || 1 ) - 1 ); if ( count ) { jQuery.data( elem, key, count, true ); } else { jQuery.removeData( elem, key, true ); handleQueueMarkDefer( elem, type, "mark" ); } } }, queue: function( elem, type, data ) { if ( elem ) { type = (type || "fx") + "queue"; var q = jQuery.data( elem, type, undefined, true ); // 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), true ); } else { q.push( data ); } } return q || []; } }, dequeue: function( elem, type ) { type = type || "fx"; var queue = jQuery.queue( elem, type ), fn = queue.shift(), defer; // 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"); } fn.call(elem, function() { jQuery.dequeue(elem, type); }); } if ( !queue.length ) { jQuery.removeData( elem, type + "queue", true ); handleQueueMarkDefer( elem, type, "queue" ); } } }); jQuery.fn.extend({ queue: function( type, data ) { if ( typeof type !== "string" ) { data = type; type = "fx"; } if ( data === undefined ) { return jQuery.queue( this[0], type ); } return 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() { var elem = this; setTimeout(function() { jQuery.dequeue( elem, type ); }, time ); }); }, 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._Deferred(), true ) )) { count++; tmp.done( resolve ); } } resolve(); return defer.promise(); } }); 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, rinvalidChar = /\:|^on/, formHook, boolHook; jQuery.fn.extend({ attr: function( name, value ) { return jQuery.access( this, name, value, true, jQuery.attr ); }, removeAttr: function( name ) { return this.each(function() { jQuery.removeAttr( this, name ); }); }, prop: function( name, value ) { return jQuery.access( this, name, value, true, jQuery.prop ); }, 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 + " "; for ( var i = 0, l = this.length; i < l; i++ ) { if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) { return true; } } return false; }, val: function( value ) { var hooks, ret, elem = this[0]; if ( !arguments.length ) { if ( elem ) { hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ]; 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 undefined; } var 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.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ]; // 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, 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 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { var 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 }, attrFix: { // Always normalize to ensure hook usage tabindex: "tabIndex" }, attr: function( elem, name, value, pass ) { var nType = elem.nodeType; // don't get/set attributes on text, comment and attribute nodes if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { return undefined; } if ( pass && name in jQuery.attrFn ) { return jQuery( elem )[ name ]( value ); } // Fallback to prop when attributes are not supported if ( !("getAttribute" in elem) ) { return jQuery.prop( elem, name, value ); } var ret, hooks, notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); // Normalize the name if needed if ( notxml ) { name = jQuery.attrFix[ name ] || name; hooks = jQuery.attrHooks[ name ]; if ( !hooks ) { // Use boolHook for boolean attributes if ( rboolean.test( name ) ) { hooks = boolHook; // Use formHook for forms and if the name contains certain characters } else if ( formHook && name !== "className" && (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) { hooks = formHook; } } } if ( value !== undefined ) { if ( value === null ) { jQuery.removeAttr( elem, name ); return undefined; } 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, name ) { var propName; if ( elem.nodeType === 1 ) { name = jQuery.attrFix[ name ] || name; if ( jQuery.support.getSetAttribute ) { // Use removeAttribute in browsers that support it elem.removeAttribute( name ); } else { jQuery.attr( elem, name, "" ); elem.removeAttributeNode( elem.getAttributeNode( name ) ); } // Set corresponding property to false for boolean attributes if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) 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; } } }, 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; } }, // Use the value property for back compat // Use the formHook for button elements in IE6/7 (#1954) value: { get: function( elem, name ) { if ( formHook && jQuery.nodeName( elem, "button" ) ) { return formHook.get( elem, name ); } return name in elem ? elem.value : null; }, set: function( elem, value, name ) { if ( formHook && jQuery.nodeName( elem, "button" ) ) { return formHook.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 nType = elem.nodeType; // don't get/set properties on text, comment and attribute nodes if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { return undefined; } var ret, hooks, 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 )) !== undefined ) { return ret; } else { return elem[ name ]; } } }, propHooks: {} }); // Hook for boolean attributes boolHook = { get: function( elem, name ) { // Align boolean attributes with corresponding properties return jQuery.prop( elem, name ) ? 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 ( !jQuery.support.getSetAttribute ) { // propFix is more comprehensive and contains all fixes jQuery.attrFix = jQuery.propFix; // Use this for any attribute on a form in IE6/7 formHook = jQuery.attrHooks.name = jQuery.attrHooks.title = jQuery.valHooks.button = { get: function( elem, name ) { var ret; ret = elem.getAttributeNode( name ); // Return undefined if nodeValue is empty string return ret && ret.nodeValue !== "" ? ret.nodeValue : undefined; }, set: function( elem, value, name ) { // Check form objects in IE (multiple bugs related) // Only use nodeValue if the attribute node exists on the form var ret = elem.getAttributeNode( name ); if ( ret ) { ret.nodeValue = value; return value; } } }; // 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; } } }); }); } // 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; } } } }); } // 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 rnamespaces = /\.(.*)$/, rformElems = /^(?:textarea|input|select)$/i, rperiod = /\./g, rspaces = / /g, rescape = /[^\w\s.|`]/g, fcleanup = function( nm ) { return nm.replace(rescape, "\\$&"); }; /* * A number of helper functions used for managing events. * Many of the ideas behind this code originated from * Dean Edwards' addEvent library. */ jQuery.event = { // Bind an event to an element // Original by Dean Edwards add: function( elem, types, handler, data ) { if ( elem.nodeType === 3 || elem.nodeType === 8 ) { return; } if ( handler === false ) { handler = returnFalse; } else if ( !handler ) { // Fixes bug #7229. Fix recommended by jdalton return; } var handleObjIn, handleObj; if ( handler.handler ) { handleObjIn = handler; handler = handleObjIn.handler; } // Make sure that the function being executed has a unique ID if ( !handler.guid ) { handler.guid = jQuery.guid++; } // Init the element's event structure var elemData = jQuery._data( elem ); // If no elemData is found then we must be trying to bind to one of the // banned noData elements if ( !elemData ) { return; } var events = elemData.events, eventHandle = elemData.handle; if ( !events ) { elemData.events = events = {}; } 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.handle.apply( eventHandle.elem, arguments ) : undefined; }; } // Add elem as a property of the handle function // This is to prevent a memory leak with non-native events in IE. eventHandle.elem = elem; // Handle multiple events separated by a space // jQuery(...).bind("mouseover mouseout", fn); types = types.split(" "); var type, i = 0, namespaces; while ( (type = types[ i++ ]) ) { handleObj = handleObjIn ? jQuery.extend({}, handleObjIn) : { handler: handler, data: data }; // Namespaced event handlers if ( type.indexOf(".") > -1 ) { namespaces = type.split("."); type = namespaces.shift(); handleObj.namespace = namespaces.slice(0).sort().join("."); } else { namespaces = []; handleObj.namespace = ""; } handleObj.type = type; if ( !handleObj.guid ) { handleObj.guid = handler.guid; } // Get the current list of functions bound to this event var handlers = events[ type ], special = jQuery.event.special[ type ] || {}; // Init the event handler queue if ( !handlers ) { handlers = events[ type ] = []; // Check for a special event handler // 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 the function to the element's handler list handlers.push( handleObj ); // Keep track of which events have 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, pos ) { // don't do events on text and comment nodes if ( elem.nodeType === 3 || elem.nodeType === 8 ) { return; } if ( handler === false ) { handler = returnFalse; } var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType, elemData = jQuery.hasData( elem ) && jQuery._data( elem ), events = elemData && elemData.events; if ( !elemData || !events ) { return; } // types is actually an event object here if ( types && types.type ) { handler = types.handler; types = types.type; } // Unbind all events for the element if ( !types || typeof types === "string" && types.charAt(0) === "." ) { types = types || ""; for ( type in events ) { jQuery.event.remove( elem, type + types ); } return; } // Handle multiple events separated by a space // jQuery(...).unbind("mouseover mouseout", fn); types = types.split(" "); while ( (type = types[ i++ ]) ) { origType = type; handleObj = null; all = type.indexOf(".") < 0; namespaces = []; if ( !all ) { // Namespaced event handlers namespaces = type.split("."); type = namespaces.shift(); namespace = new RegExp("(^|\\.)" + jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)"); } eventType = events[ type ]; if ( !eventType ) { continue; } if ( !handler ) { for ( j = 0; j < eventType.length; j++ ) { handleObj = eventType[ j ]; if ( all || namespace.test( handleObj.namespace ) ) { jQuery.event.remove( elem, origType, handleObj.handler, j ); eventType.splice( j--, 1 ); } } continue; } special = jQuery.event.special[ type ] || {}; for ( j = pos || 0; j < eventType.length; j++ ) { handleObj = eventType[ j ]; if ( handler.guid === handleObj.guid ) { // remove the given handler for the given type if ( all || namespace.test( handleObj.namespace ) ) { if ( pos == null ) { eventType.splice( j--, 1 ); } if ( special.remove ) { special.remove.call( elem, handleObj ); } } if ( pos != null ) { break; } } } // remove generic event handler if no more handlers exist if ( eventType.length === 0 || pos != null && eventType.length === 1 ) { if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { jQuery.removeEvent( elem, type, elemData.handle ); } ret = null; delete events[ type ]; } } // Remove the expando if it's no longer used if ( jQuery.isEmptyObject( events ) ) { var handle = elemData.handle; if ( handle ) { handle.elem = null; } delete elemData.events; delete elemData.handle; if ( jQuery.isEmptyObject( elemData ) ) { jQuery.removeData( elem, undefined, 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 ) { // Event object or event type var type = event.type || event, namespaces = [], exclusive; 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.exclusive = exclusive; event.namespace = namespaces.join("."); event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)"); // triggerHandler() and global events don't bubble or run the default action if ( onlyHandlers || !elem ) { event.preventDefault(); event.stopPropagation(); } // Handle a global trigger if ( !elem ) { // TODO: Stop taunting the data cache; remove global events and always attach to document jQuery.each( jQuery.cache, function() { // internalKey variable is just used to make it easier to find // and potentially change this stuff later; currently it just // points to jQuery.expando var internalKey = jQuery.expando, internalCache = this[ internalKey ]; if ( internalCache && internalCache.events && internalCache.events[ type ] ) { jQuery.event.trigger( event, data, internalCache.handle.elem ); } }); return; } // Don't do events on text and comment nodes if ( elem.nodeType === 3 || elem.nodeType === 8 ) { return; } // Clean up the event in case it is being reused event.result = undefined; 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 ); var cur = elem, // IE doesn't like method names with a colon (#3533, #8272) ontype = type.indexOf(":") < 0 ? "on" + type : ""; // Fire event on the current element, then bubble up the DOM tree do { var handle = jQuery._data( cur, "handle" ); event.currentTarget = cur; if ( handle ) { handle.apply( cur, data ); } // Trigger an inline bound script if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) { event.result = false; event.preventDefault(); } // Bubble up to document, then to window cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window; } while ( cur && !event.isPropagationStopped() ); // If nobody prevented the default action, do it now if ( !event.isDefaultPrevented() ) { var old, special = jQuery.event.special[ type ] || {}; if ( (!special._default || special._default.call( elem.ownerDocument, event ) === 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. // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch. try { if ( ontype && elem[ type ] ) { // Don't re-trigger an onFOO event when we call its FOO() method old = elem[ ontype ]; if ( old ) { elem[ ontype ] = null; } jQuery.event.triggered = type; elem[ type ](); } } catch ( ieError ) {} if ( old ) { elem[ ontype ] = old; } jQuery.event.triggered = undefined; } } return event.result; }, handle: function( event ) { event = jQuery.event.fix( event || window.event ); // Snapshot the handlers list since a called handler may add/remove events. var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0), run_all = !event.exclusive && !event.namespace, args = Array.prototype.slice.call( arguments, 0 ); // Use the fix-ed Event rather than the (read-only) native event args[0] = event; event.currentTarget = this; for ( var j = 0, l = handlers.length; j < l; j++ ) { var handleObj = handlers[ j ]; // Triggered event must 1) be non-exclusive and have no namespace, or // 2) have namespace(s) a subset or equal to those in the bound event. if ( run_all || event.namespace_re.test( handleObj.namespace ) ) { // Pass in a reference to the handler function itself // So that we can later remove it event.handler = handleObj.handler; event.data = handleObj.data; event.handleObj = handleObj; var ret = handleObj.handler.apply( this, args ); if ( ret !== undefined ) { event.result = ret; if ( ret === false ) { event.preventDefault(); event.stopPropagation(); } } if ( event.isImmediatePropagationStopped() ) { break; } } } return event.result; }, props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "), fix: function( event ) { if ( event[ jQuery.expando ] ) { return event; } // store a copy of the original event object // and "clone" to set read-only properties var originalEvent = event; event = jQuery.Event( originalEvent ); for ( var i = this.props.length, prop; i; ) { prop = this.props[ --i ]; event[ prop ] = originalEvent[ prop ]; } // Fix target property, if necessary if ( !event.target ) { // Fixes #1925 where srcElement might not be defined either event.target = event.srcElement || document; } // check if target is a textnode (safari) if ( event.target.nodeType === 3 ) { event.target = event.target.parentNode; } // Add relatedTarget, if necessary if ( !event.relatedTarget && event.fromElement ) { event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement; } // Calculate pageX/Y if missing and clientX/Y available if ( event.pageX == null && event.clientX != null ) { var eventDocument = event.target.ownerDocument || document, doc = eventDocument.documentElement, body = eventDocument.body; event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0); event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0); } // Add which for key events if ( event.which == null && (event.charCode != null || event.keyCode != null) ) { event.which = event.charCode != null ? event.charCode : event.keyCode; } // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs) if ( !event.metaKey && event.ctrlKey ) { event.metaKey = event.ctrlKey; } // Add which for click: 1 === left; 2 === middle; 3 === right // Note: button is not normalized, so don't use it if ( !event.which && event.button !== undefined ) { event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) )); } return event; }, // Deprecated, use jQuery.guid instead guid: 1E8, // Deprecated, use jQuery.proxy instead proxy: jQuery.proxy, special: { ready: { // Make sure the ready event is setup setup: jQuery.bindReady, teardown: jQuery.noop }, live: { add: function( handleObj ) { jQuery.event.add( this, liveConvert( handleObj.origType, handleObj.selector ), jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) ); }, remove: function( handleObj ) { jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj ); } }, 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; } } } } }; 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.preventDefault ) { 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 ); } // timeStamp is buggy for some events on Firefox(#3843) // So we won't rely on the native value this.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 }; // Checks if an event happened on an element within another element // Used in jQuery.event.special.mouseenter and mouseleave handlers var withinElement = function( event ) { // Check if mouse(over|out) are still within the same parent element var related = event.relatedTarget, inside = false, eventType = event.type; event.type = event.data; if ( related !== this ) { if ( related ) { inside = jQuery.contains( this, related ); } if ( !inside ) { jQuery.event.handle.apply( this, arguments ); event.type = eventType; } } }, // In case of event delegation, we only need to rename the event.type, // liveHandler will take care of the rest. delegate = function( event ) { event.type = event.data; jQuery.event.handle.apply( this, arguments ); }; // Create mouseenter and mouseleave events jQuery.each({ mouseenter: "mouseover", mouseleave: "mouseout" }, function( orig, fix ) { jQuery.event.special[ orig ] = { setup: function( data ) { jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig ); }, teardown: function( data ) { jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement ); } }; }); // submit delegation if ( !jQuery.support.submitBubbles ) { jQuery.event.special.submit = { setup: function( data, namespaces ) { if ( !jQuery.nodeName( this, "form" ) ) { jQuery.event.add(this, "click.specialSubmit", function( e ) { var elem = e.target, type = elem.type; if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) { trigger( "submit", this, arguments ); } }); jQuery.event.add(this, "keypress.specialSubmit", function( e ) { var elem = e.target, type = elem.type; if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) { trigger( "submit", this, arguments ); } }); } else { return false; } }, teardown: function( namespaces ) { jQuery.event.remove( this, ".specialSubmit" ); } }; } // change delegation, happens here so we have bind. if ( !jQuery.support.changeBubbles ) { var changeFilters, getVal = function( elem ) { var type = elem.type, val = elem.value; if ( type === "radio" || type === "checkbox" ) { val = elem.checked; } else if ( type === "select-multiple" ) { val = elem.selectedIndex > -1 ? jQuery.map( elem.options, function( elem ) { return elem.selected; }).join("-") : ""; } else if ( jQuery.nodeName( elem, "select" ) ) { val = elem.selectedIndex; } return val; }, testChange = function testChange( e ) { var elem = e.target, data, val; if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) { return; } data = jQuery._data( elem, "_change_data" ); val = getVal(elem); // the current data will be also retrieved by beforeactivate if ( e.type !== "focusout" || elem.type !== "radio" ) { jQuery._data( elem, "_change_data", val ); } if ( data === undefined || val === data ) { return; } if ( data != null || val ) { e.type = "change"; e.liveFired = undefined; jQuery.event.trigger( e, arguments[1], elem ); } }; jQuery.event.special.change = { filters: { focusout: testChange, beforedeactivate: testChange, click: function( e ) { var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : ""; if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) { testChange.call( this, e ); } }, // Change has to be called before submit // Keydown will be called before keypress, which is used in submit-event delegation keydown: function( e ) { var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : ""; if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) || (e.keyCode === 32 && (type === "checkbox" || type === "radio")) || type === "select-multiple" ) { testChange.call( this, e ); } }, // Beforeactivate happens also before the previous element is blurred // with this event you can't trigger a change event, but you can store // information beforeactivate: function( e ) { var elem = e.target; jQuery._data( elem, "_change_data", getVal(elem) ); } }, setup: function( data, namespaces ) { if ( this.type === "file" ) { return false; } for ( var type in changeFilters ) { jQuery.event.add( this, type + ".specialChange", changeFilters[type] ); } return rformElems.test( this.nodeName ); }, teardown: function( namespaces ) { jQuery.event.remove( this, ".specialChange" ); return rformElems.test( this.nodeName ); } }; changeFilters = jQuery.event.special.change.filters; // Handle when the input is .focus()'d changeFilters.focus = changeFilters.beforeactivate; } function trigger( type, elem, args ) { // 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. // Don't pass args or remember liveFired; they apply to the donor event. var event = jQuery.extend( {}, args[ 0 ] ); event.type = type; event.originalEvent = {}; event.liveFired = undefined; jQuery.event.handle.call( elem, event ); if ( event.isDefaultPrevented() ) { args[ 0 ].preventDefault(); } } // 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; jQuery.event.special[ fix ] = { setup: function() { if ( attaches++ === 0 ) { document.addEventListener( orig, handler, true ); } }, teardown: function() { if ( --attaches === 0 ) { document.removeEventListener( orig, handler, true ); } } }; function handler( donor ) { // Donor event is always a native one; fix it and switch its type. // Let focusin/out handler cancel the donor focus/blur event. var e = jQuery.event.fix( donor ); e.type = fix; e.originalEvent = {}; jQuery.event.trigger( e, null, e.target ); if ( e.isDefaultPrevented() ) { donor.preventDefault(); } } }); } jQuery.each(["bind", "one"], function( i, name ) { jQuery.fn[ name ] = function( type, data, fn ) { var handler; // Handle object literals if ( typeof type === "object" ) { for ( var key in type ) { this[ name ](key, data, type[key], fn); } return this; } if ( arguments.length === 2 || data === false ) { fn = data; data = undefined; } if ( name === "one" ) { handler = function( event ) { jQuery( this ).unbind( event, handler ); return fn.apply( this, arguments ); }; handler.guid = fn.guid || jQuery.guid++; } else { handler = fn; } if ( type === "unload" && name !== "one" ) { this.one( type, data, fn ); } else { for ( var i = 0, l = this.length; i < l; i++ ) { jQuery.event.add( this[i], type, handler, data ); } } return this; }; }); jQuery.fn.extend({ unbind: function( type, fn ) { // Handle object literals if ( typeof type === "object" && !type.preventDefault ) { for ( var key in type ) { this.unbind(key, type[key]); } } else { for ( var i = 0, l = this.length; i < l; i++ ) { jQuery.event.remove( this[i], type, fn ); } } return this; }, delegate: function( selector, types, data, fn ) { return this.live( types, data, fn, selector ); }, undelegate: function( selector, types, fn ) { if ( arguments.length === 0 ) { return this.unbind( "live" ); } else { return this.die( types, null, fn, selector ); } }, 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 ); } }); var liveMap = { focus: "focusin", blur: "focusout", mouseenter: "mouseover", mouseleave: "mouseout" }; jQuery.each(["live", "die"], function( i, name ) { jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) { var type, i = 0, match, namespaces, preType, selector = origSelector || this.selector, context = origSelector ? this : jQuery( this.context ); if ( typeof types === "object" && !types.preventDefault ) { for ( var key in types ) { context[ name ]( key, data, types[key], selector ); } return this; } if ( name === "die" && !types && origSelector && origSelector.charAt(0) === "." ) { context.unbind( origSelector ); return this; } if ( data === false || jQuery.isFunction( data ) ) { fn = data || returnFalse; data = undefined; } types = (types || "").split(" "); while ( (type = types[ i++ ]) != null ) { match = rnamespaces.exec( type ); namespaces = ""; if ( match ) { namespaces = match[0]; type = type.replace( rnamespaces, "" ); } if ( type === "hover" ) { types.push( "mouseenter" + namespaces, "mouseleave" + namespaces ); continue; } preType = type; if ( liveMap[ type ] ) { types.push( liveMap[ type ] + namespaces ); type = type + namespaces; } else { type = (liveMap[ type ] || type) + namespaces; } if ( name === "live" ) { // bind live handler for ( var j = 0, l = context.length; j < l; j++ ) { jQuery.event.add( context[j], "live." + liveConvert( type, selector ), { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } ); } } else { // unbind live handler context.unbind( "live." + liveConvert( type, selector ), fn ); } } return this; }; }); function liveHandler( event ) { var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret, elems = [], selectors = [], events = jQuery._data( this, "events" ); // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911) if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) { return; } if ( event.namespace ) { namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)"); } event.liveFired = this; var live = events.live.slice(0); for ( j = 0; j < live.length; j++ ) { handleObj = live[j]; if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) { selectors.push( handleObj.selector ); } else { live.splice( j--, 1 ); } } match = jQuery( event.target ).closest( selectors, event.currentTarget ); for ( i = 0, l = match.length; i < l; i++ ) { close = match[i]; for ( j = 0; j < live.length; j++ ) { handleObj = live[j]; if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) { elem = close.elem; related = null; // Those two events require additional checking if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) { event.type = handleObj.preType; related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0]; // Make sure not to accidentally match a child element with the same selector if ( related && jQuery.contains( elem, related ) ) { related = elem; } } if ( !related || related !== elem ) { elems.push({ elem: elem, handleObj: handleObj, level: close.level }); } } } } for ( i = 0, l = elems.length; i < l; i++ ) { match = elems[i]; if ( maxLevel && match.level > maxLevel ) { break; } event.currentTarget = match.elem; event.data = match.handleObj.data; event.handleObj = match.handleObj; ret = match.handleObj.origHandler.apply( match.elem, arguments ); if ( ret === false || event.isPropagationStopped() ) { maxLevel = match.level; if ( ret === false ) { stop = false; } if ( event.isImmediatePropagationStopped() ) { break; } } } return stop; } function liveConvert( type, selector ) { return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&"); } 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").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.bind( name, data, fn ) : this.trigger( name ); }; if ( jQuery.attrFn ) { jQuery.attrFn[ name ] = true; } }); /*! * 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, done = 0, toString = Object.prototype.toString, hasDuplicate = false, baseHasDuplicate = true, rBackslash = /\\/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 ); } 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 ); } } } 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; if ( !expr ) { return []; } for ( var i = 0, l = Expr.order.length; i < l; i++ ) { var match, type = Expr.order[i]; if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { var 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, old = expr, result = [], curLoop = set, isXMLFilter = set && set[0] && Sizzle.isXML( set[0] ); while ( expr && set.length ) { for ( var type in Expr.filter ) { if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) { var found, item, 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 ( var i = 0; (item = curLoop[i]) != null; i++ ) { if ( item ) { found = filter( item, match, i, curLoop ); var 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 "Syntax error, unrecognized expression: " + msg; }; 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 || Sizzle.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 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; case "last": while ( (node = node.nextSibling) ) { if ( node.nodeType === 1 ) { return false; } } return true; case "nth": var first = match[2], last = match[3]; if ( first === 1 && last === 0 ) { return true; } var doneName = match[0], parent = elem.parentNode; if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { var count = 0; for ( node = parent.firstChild; node; node = node.nextSibling ) { if ( node.nodeType === 1 ) { node.nodeIndex = ++count; } } parent.sizcache = doneName; } var 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.toLowerCase() === match; }, CLASS: function( elem, match ) { return (" " + (elem.className || elem.getAttribute("class")) + " ") .indexOf( match ) > -1; }, ATTR: function( elem, match ) { var name = match[1], result = 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 === "=" ? 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) ); } 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; }; } // Utility function for retreiving the text value of an array of DOM nodes Sizzle.getText = function( elems ) { var ret = "", elem; for ( var i = 0; elems[i]; i++ ) { elem = elems[i]; // Get the text from text nodes and CDATA nodes if ( elem.nodeType === 3 || elem.nodeType === 4 ) { ret += elem.nodeValue; // Traverse everything else, except comment nodes } else if ( elem.nodeType !== 8 ) { ret += Sizzle.getText( elem.childNodes ); } } return ret; }; // 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.sizcache === doneName ) { match = checkSet[elem.sizset]; break; } if ( elem.nodeType === 1 && !isXML ){ elem.sizcache = 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.sizcache === doneName ) { match = checkSet[elem.sizset]; break; } if ( elem.nodeType === 1 ) { if ( !isXML ) { elem.sizcache = 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 ) { 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 ); } return Sizzle.filter( later, tmpSet ); }; // EXPOSE 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.POS, // 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" ? jQuery.filter( selector, this ).length > 0 : this.filter( selector ).length > 0 ); }, closest: function( selectors, context ) { var ret = [], i, l, cur = this[0]; // Array if ( jQuery.isArray( selectors ) ) { var match, selector, matches = {}, level = 1; if ( cur && selectors.length ) { for ( i = 0, l = selectors.length; i < l; i++ ) { selector = selectors[i]; if ( !matches[ selector ] ) { matches[ selector ] = POS.test( selector ) ? jQuery( selector, context || this.context ) : selector; } } while ( cur && cur.ownerDocument && cur !== context ) { for ( selector in matches ) { match = matches[ selector ]; if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) { ret.push({ selector: selector, 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 ) { if ( !elem || typeof elem === "string" ) { return jQuery.inArray( this[0], // If it receives a string, the selector is used // If it receives nothing, the siblings are used elem ? jQuery( elem ) : this.parent().children() ); } // 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 ), // The variable 'args' was introduced in // https://github.com/jquery/jquery/commit/52a0238 // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed. // http://code.google.com/p/v8/issues/detail?id=1050 args = slice.call(arguments); 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, args.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; }); } var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g, rleadingWhitespace = /^\s+/, rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, rtagName = /<([\w:]+)/, rtbody = /", "" ], legend: [ 1, "
    ", "
    " ], thead: [ 1, "", "
    " ], tr: [ 2, "", "
    " ], td: [ 3, "", "
    " ], col: [ 2, "", "
    " ], area: [ 1, "", "" ], _default: [ 0, "", "" ] }; wrapMap.optgroup = wrapMap.option; wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td; // IE can't serialize and
    up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/examples.html000066400000000000000000000150741174460560600224400ustar00rootroot00000000000000 Examples — cpp-netlib v0.9.4

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/examples/000077500000000000000000000000001174460560600215435ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/examples/http/000077500000000000000000000000001174460560600225225ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/examples/http/atom_reader.html000066400000000000000000000314521174460560600256770ustar00rootroot00000000000000 Atom feed reader — cpp-netlib v0.9.4

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/examples/http/hello_world_client.html000066400000000000000000000347241174460560600272720ustar00rootroot00000000000000 “Hello world†HTTP client — cpp-netlib v0.9.4

    “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, "application/xml", some_xml_string);
std::data = body(response);

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

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/examples/http/hello_world_server.html000066400000000000000000000426001174460560600273120ustar00rootroot00000000000000 “Hello world†HTTP server — cpp-netlib v0.9.4

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

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/examples/http/http_client.html000066400000000000000000000350241174460560600257310ustar00rootroot00000000000000 HTTP client — cpp-netlib v0.9.4

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/examples/http/simple_wget.html000066400000000000000000000416741174460560600257430ustar00rootroot00000000000000 Simple wget — cpp-netlib v0.9.4

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/examples/http/twitter_search.html000066400000000000000000000430561174460560600264470ustar00rootroot00000000000000 Twitter search — cpp-netlib v0.9.4
    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/genindex.html000066400000000000000000000055111174460560600224160ustar00rootroot00000000000000 Index — cpp-netlib v0.9.4
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/getting_started.html000066400000000000000000000460041174460560600240060ustar00rootroot00000000000000 Getting Started — cpp-netlib v0.9.4

    Getting Started¶

    Downloading an official release¶

    All 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.45.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.

    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

    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 GCC on Linux these are:

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

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

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/history.html000066400000000000000000000175021174460560600223210ustar00rootroot00000000000000 Project history — cpp-netlib v0.9.4

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/in_depth.html000066400000000000000000000157451174460560600224210ustar00rootroot00000000000000 An in-depth look at the cpp-netlib — cpp-netlib v0.9.4

    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 | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/in_depth/000077500000000000000000000000001174460560600215175ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/in_depth/http.html000066400000000000000000000565551174460560600234040ustar00rootroot00000000000000 HTTP implementation — cpp-netlib v0.9.4

    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_default_8bit_udp_resolve tag, and implements HTTP 1.0. The exact typedef is in the boost::network::http namespace as the following:

    namespace boost { namespace network { namespace http {

    typedef basic_client<tags::http_default_8bit_udp_resolve, 1, 0>
        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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/in_depth/http_client_tags.html000066400000000000000000000135431174460560600257460ustar00rootroot00000000000000 <no title> — cpp-netlib v0.9.4
    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.
    up
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/in_depth/message.html000066400000000000000000000634441174460560600240440ustar00rootroot00000000000000 The message template — cpp-netlib v0.9.4

    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 is under review at present and will be subject to change in newer versions.

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/in_depth/uri.html000066400000000000000000000410471174460560600232120ustar00rootroot00000000000000 The URI class — cpp-netlib v0.9.4

    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.
    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/index.html000066400000000000000000000303401174460560600217220ustar00rootroot00000000000000 Getting cpp-netlib — cpp-netlib v0.9.4

    Straightforward network programming in modern C++

    Getting cpp-netlib¶

    Download

    You can download the latest releases of the library at:

    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.

    Boost¶

    The cpp-netlib is being developed for eventual submission to Boost.

    _images/boost.png

    C++ Network Library¶

    The cpp-netlib is a library 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.

    It is developed by people linked to the Boost community and will soon be submitted for review into Boost. A presentation about cpp-netlib was given at BoostCon 2010, for which the slides and the paper can be found on-line.

    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 server_("0.0.0.0", "8000", handler_);
    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.

    up
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/objects.inv000066400000000000000000000007601174460560600220770ustar00rootroot00000000000000# Sphinx inventory version 2 # Project: cpp-netlib # Version: 0.9 # 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-0.9.4/libs/network/doc/html/reference.html000066400000000000000000000163521174460560600225600ustar00rootroot00000000000000 Reference Manual — cpp-netlib v0.9.4

    Reference Manual¶

    This reference manual refers to the API documentation of the public interfaces to the different client and/or server implementations within cpp-netlib.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/reference/000077500000000000000000000000001174460560600216635ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/reference/http_client.html000066400000000000000000001142511174460560600250720ustar00rootroot00000000000000 HTTP Client API — cpp-netlib v0.9.4

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

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

    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.

    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.

    Constructors¶

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

    client()
    Default constructor.
    client(boost::asio::io_service & io_service)
    Construct a client to use an existing Boost.Asio io_service instance.
    template <class ArgPack> client(ArgPack const & args)
    Pass in an argument pack. See supported parameters in the table below.
    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 boost::asio::io_service & Reference to an instance of 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.

    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
boost::asio::io_service my_io_service;
client client_(_follow_redirects=true, _cache_resolved=true,
               _io_service=my_io_service
               , _openssl_certificate="/tmp/my-cert"
               , _openssl_verify_path="/tmp/ca-certs/");
// 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_, _body_handler=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_, _body_handler=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, _body_handler=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_, content_type, body)
    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_, content_type, body, _body_handler=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_)
    Perform an HTTP PUT, use the data already set in the request object which includes the headers, and the body.
    response_ = client_.put(request_, _body_handler=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, _body_handler=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_, content_type, body)
    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_, content_type, body, _body_handler=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_.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=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/"),
                        _body_handler=print_body);

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

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/reference/http_request.html000066400000000000000000000766631174460560600253220ustar00rootroot00000000000000 HTTP Request — cpp-netlib v0.9.4

    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.
    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/reference/http_response.html000066400000000000000000001327171174460560600254610ustar00rootroot00000000000000 HTTP Response — cpp-netlib v0.9.4

    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.

    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 string<Tag>::type 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.
    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/reference/http_server.html000066400000000000000000001426541174460560600251320ustar00rootroot00000000000000 HTTP Server API — cpp-netlib v0.9.4

    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¶

    http_server(address, port, handler)
    Construct an HTTP Server instance, passing in the address and port as std::string const & and handler being of type handler_type but passed in as an lvalue reference.
    template <class ArgPack> client(ArgPack const & args)
    Pass in an argument pack. See supported parameters in the table below.
    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.
    _handler Handler & An lvalue reference to an instance of Handler. This parameter is required.
    _thread_pool boost::network::utils::thread_pool & An lvalue reference 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 boost::asio::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.

    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
boost::asio::io_service my_io_service;
boost::network::utils::thread_pool pool(2);
handler handler_instance;
async_server<handler> instance(_address="0.0.0.0", _port="80", _handler=handler_instance,
                               _io_service=my_io_service, _thread_pool=pool,
                               _reuse_address=true);
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 server("127.0.0.1", "8000", handler);
    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 applacation 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¶

    http_server(address, port, handler, thread_pool)
    Construct an HTTP Server instance, passing in the address and port as std::string const & and handler being of type handler_type but passed in as an lvalue reference. The thread_pool parameter is an instance of boost::network::utils::thread_pool that has been previously instantiated.

    Note

    The boost::network::utils::thread_pool has a single constructor parameter which is the number of threads to run the thread pool.

    Public Members¶

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

    handler_type handler;
boost::network::utils::thread_pool thread_pool(2);
http_server server("127.0.0.1", "8000", handler, thread_pool);
    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/references.html000066400000000000000000000142511174460560600227370ustar00rootroot00000000000000 References — cpp-netlib v0.9.4

    References¶

    Other sources¶

    « previous | up
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/search.html000066400000000000000000000072571174460560600220730ustar00rootroot00000000000000 Search — cpp-netlib v0.9.4
    up
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/searchindex.js000066400000000000000000000534261174460560600225720ustar00rootroot00000000000000Search.setIndex({objects:{},terms:{directive_typ:7,all:[6,21,20,15,8,24,9,23,18,25,2,17,7,16,22,10],concept:[23,0,18,10,17,7,3,4,12],skeleton:11,chain:7,illustr:11,queri:[14,23,13,3],forbidden:10,lack:26,icmp:18,basic_messag:[18,4,12],four:17,appropri:[23,21,24,10,17],code:[6,13,14,15,8,24,9,21,25,20,26,10,11,7,16,22],follow:[21,14,15,8,24,9,11,23,18,25,2,17,7,3,16,10],lookup:18,ptr:16,abid:[23,7],hierarch:3,content:[24,10,4,18],decid:[16,26,11],arg:[6,10,24],"const":[6,23,13,14,8,24,18,20,10,17,7,25],system:[24,7,10,21],boost_network_http_body_callback:24,base_uri:13,unpack:21,tweet:13,send:[10,15],program:[6,8,16,2,3,26],swap:[18,3,11],under:[6,13,18],sens:[24,7,19,25],set:[12,23,13,8,24,9,18,10,17,7,16,2],"_follow_redirect":24,stock_repli:[6,10,8,25],messag:[6,23,15,24,22,18,26,17,7,4,12],introduc:[24,13,14,15,22],http_async_8bit_udp_resolv:[24,25,19,22],sourc:[23,8,15,18,1,17,25,21,4,26],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,veri:[14,10,22],affect:24,default_:[16,25,11],syntax:[13,15,1,3,4,12],exact:[13,25],relev:9,span:12,http_async_serv:10,administr:8,level:[21,26],list:[6,23,13,8,17,10,11,20,21],upload:10,iter:25,correct:[16,25,18],"try":[13,14,8,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,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],fulli:[24,14,26],handler_typ:10,second:[23,25],cost:22,design:[6,2],chang:[24,18,25,11,7,21,22],pass:[20,8,15,24,9,18,10,11,7],download:[6,21,4],further:[3,15],cat:14,port:[23,14,8,9,10,17,3],append:24,asio:[24,26,10,22],index:14,what:[6,23,13,14,8,24,9,18,10,11,20,16,4,22],msysgit:21,barrier:26,svn:21,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],directori:[24,21,15],source_wrapp:18,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:[24,23,15,8,25],xml:[9,20],full:[6,21,17],hash:13,deriv:[16,23],absolut:3,join:[6,10,21],gener:[6,23,0,24,16,18,26,1,10,7,3,21,4,12],never:26,unauthor:10,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,22],subvers:21,let:[9,21,8,11],argv:[6,13,14,8,15,9,20],address:[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,2,4,22],produc:21,convers:18,forum:21,shift:7,anymor:11,larger:2,host:[14,23,3,21,8],cert:24,cerr:[6,13,14,8,9,20,25],behav:24,http_keepalive_8bit_tcp_resolv:[24,19,25],action: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],semant:[16,7,10,18],via:[6,9],repositori:21,solut:21,multiple_choic:10,expect:24,substr:14,ipp:8,api:[23,13,0,24,10,17,4,22],famili:11,visibl:25,instal:21,should:[8,24,16,18,10,11,21,25],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,upgrad:[24,10,22],next:[9,20,14,10,15],get_filenam:14,few:21,handler:[6,8,24,16,10,25,22],call:[8,24,18,10,11,7,21,25],recommend:21,taken:10,clear_head:[23,18,17],type:[23,24,16,17,18,25,10,11,7,3,26],start:[6,24,10,11,21,4],minor:[24,23],more:[6,13,9,18,26,10,20,21,22],reachabl:11,chapter:5,said:3,headers_rang:[23,25,17],afford:7,share:[24,25,10,8,19],swappabl:[18,3,11],relat:10,about:[6,23,8,1,10,17,21,4],notic:[25,11],site:21,warn:[6,23,24,18,10,17,21],visual:21,depth:[6,4,12],indic:[24,19,25],simple_wget:14,known:[3,21],central:18,hold:[24,19,25],olymp:13,cach:24,content_typ:24,must:[21,22],account:21,dcmake_c_compil:21,retriev:[14,23,18,3,17],internal_server_error:10,scalabl:10,alia:17,work:[23,21,17],uniqu:16,histori:[4,26],annoi:26,remain:[16,7],minimum:6,can:[6,21,13,14,15,8,24,9,18,25,2,11,7,3,16,10],caveat:21,learn:6,purpos:21,root:[23,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,22],give:10,process:[3,25],lock:10,smtp:[26,18],templat:[23,24,16,11,18,25,26,1,10,17,7,21,4,12],high:26,tag:[23,13,24,16,11,18,25,10,19,17,22,3,4,5],want:[6,21,24,16,18,10,11,9],explos:16,tarbal:21,phrase:13,serial:10,keep:[20,24,16,19,11,7,25],unsign:[24,23,25,17],occur:[23,17],risk:21,low:10,alwai:[10,21],differenti:[10,8],put:[24,10,25],end:[25,24,26,22],goal:26,"_send_buffer_s":10,programmat:22,anoth:[3,10],uri_io:3,classifi:3,divis:18,how:[8,24,9,2,11,3,21],delete_:24,foreach:20,pure:[16,18],subdirectori:15,opt:21,instead:[24,22,10,11],simpl:[6,20,14,15,8,9,22,18,25,2,7,3,4,10],mpl:[22,11],stock:8,resourc:[14,21,8],getstr:13,remove_head:[23,18,17],clone:[14,21],after:[3,10,15],hello_world_cli:9,came:25,status_messag:17,befor:[24,9,10,22],xzf:21,"_openssl_certif":24,commit:[20,26],mai:[24,25,10,8,18],multipl:10,data:[24,9,18,10,3,25],parallel:21,util:10,github:[6,24,20,3,21,26],attempt:[10,22],practic:[9,20,2],third:8,date_tim:21,light:[6,26],author:[24,3],explicit:[24,18],correspond:6,made:[24,9,10,8],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],mechan:[25,11],order:[7,15,22],talk:[23,17],serv:11,origin:[25,11],composit:11,help:10,xmpp:[26,18],offici:[21,4],move:7,becaus:[16,7,10,18],cross:26,paper:[6,1],through:[6,23,25,10,21],size_t:[14,10],still:[23,24,17,10,11,21],vari:[16,18,11],dynam:[24,16,10,4,5],paramet:[23,24,17,18,25,10,11,7,21,22],write:[6,24,9,10,22,26],style:[14,3],group:[6,21,26],fit:10,fix:22,atom_read:20,complex:[13,3,21,15],twitter:[13,2,4,22],unsupported_tag:11,better:[22,10,21],platform:[26,10,21],window:[21,4,22],pend:10,headers_contain:[18,17],bin:3,mail:[6,21],hidden:[24,7],main:[6,13,14,15,8,9,20,3,21],might:[25,11],easier:[24,18],them:[23,21,24,10,17],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],handl:[24,16,10,8],smarter:11,safe:[24,8],initi:[24,26,10,22],"break":[24,16,22],framework:8,facilit:16,find_last_of:14,now:[23,8,24,17,20,21,22],discuss:[6,21],nor:18,choic:21,term:[24,10,18],opaqu:[3,11],somewher:24,name:[23,14,24,18,10,17,25,21,22],from_user_nam:13,realist:2,edit:10,separ:22,easili:[24,26],slide:[6,1],http_server:[6,23,10,17],timeout:10,each:[15,24,18,10,20,21],debug:21,found:[6,13,8,15,10,21,26],complet:[21,15],side:[16,8],mean:[24,21,10,18],compil:[24,7,10,22,21],dcmake_cxx_compil:21,weight:[6,26],michael:26,chunk:[24,10],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,patch:21,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],safeti:11,network:[6,23,13,14,15,8,24,9,11,18,25,26,2,17,20,3,21,10],webservic:9,cppnetlib:[21,22],open:26,req:10,publish:20,rational:7,profil:10,typenam:[18,11,23,17],adapt:18,rel:3,reader:[20,2,4],print:[20,15,25],current:[24,3,10],factori:[16,7,18],model:[23,24,18,10,17,7,21],earlier:[9,16],iostream:[13,14,15,8,9,20,7,3],linear:10,insid:[10,25],watermark:10,migrat:26,basic_cli:[24,25],manipul:[10,18],situat:[16,7,10],differ:[23,14,0,24,16,11,18,10,17,7,3,22,12],free:[10,18],standard:[7,26],standalon:[24,16],base:[13,16,18,11,7,3,21],latest:[6,21],releas:[6,23,13,24,10,17,21,4,22],org:[14,3,15,25],"byte":[24,10],version_minor:[24,23,19,25],bash:3,log:6,netib:24,chose:18,usag:[13,14,8,15,9,10,20],suffici:21,thread:[8,24,10,19,22,25],document:[23,13,0,24,9,10,17,21,22],prescrib:21,synchron:[8,0,24,19,25,4,10],unavoid:16,thing:[23,14,15,16,17,11,21],enforc:23,place:10,outsid:[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],feed:[20,2,4,22],softwar:26,major:[24,23,26],attent:7,directli:[24,10],onc:[24,21,10,15,11],twitter_search:13,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],"long":10,body_:[6,23,17],stabl:[6,21],"_reuse_address":10,happi:6,miss:26,predefin:25,size:[13,10],take:[6,14,8,24,18,25,10,7,3,22],given:[6,23,13,16,11,18,10,17,3,25],com:[6,13,24,9,20,3,21],convent:15,width:24,associ:[23,18,11,10,17],top:[21,26],mkdir:21,sometim:[18,11],wrapper:[23,0,18,25,17,12,4,22],grow:6,destination_:[23,17],master:20,accept:[6,7,10],interfac:[23,14,0,24,25,10,19,7,22],scheme:[14,23,3],zipfil:21,cite:14,store:[24,10,18],listen:[10,8],adher:10,udp:[24,19,25],shell:[9,21,8],consol:[20,15],option:[22,26,10,21],especi:10,namespac:[6,23,13,14,15,8,24,9,11,10,17,20,3,25],tool:21,copi:[14,24,18,10,3,22],specifi:[14,15,24,18,19,25,3,21,10],aptli:25,part:[23,13,24,18,17,3,22],pars:[13,14,25,10,20,3,22],mostli:21,submiss:6,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],remov:[23,18,17],dive:[13,14,8,15,9,20],requesthandl:25,structur:[15,11],"final":[15,22],project:[6,21,4,26],matter:10,reus:7,not_accept:10,boil:7,str:9,bind:10,other:[6,24,18,1,10,11,7,4,26],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,argument:[13,14,8,15,24,18,10,25],packag:21,properli:[24,10],manner:[24,23,11,10,17],have:[21,13,8,24,16,18,25,26,10,11,7,9,19],tabl:[25,24,18,10,17],need:[8,15,24,16,2,11,26,21,10],seen:8,dedic:24,incompat:21,well:[7,10,18],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],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],build:[13,14,8,15,9,25,20,21,4,26],which:[6,21,20,15,8,24,9,18,25,10,11,7,3,16,22],combin:[16,11],subject:18,schedul:10,mit:13,singl:[8,15,24,10,22,25],even:[18,7,23,17],begin:[24,25],sure:8,distribut:[24,26,10,21],plenti:26,though:[16,21,15],buffer:[22,10,11],conncetionptr:10,compress:15,deleg:25,discov:6,most:[20,14,10,18],wire:7,artifact:21,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,21,25],filesystem:14,url:[14,15,9,1,20,3,21],clear:[24,18],later:10,cover:[22,18],uri:[6,23,13,14,15,16,25,1,22,3,21,4,12],doe:[23,8,24,18,10,17,3],declar:[23,25,17],directive2:7,determin:[25,14,10,11],neg:13,readcallback:10,usual:[23,7,17],microsoft:21,fact:15,ofstream:14,connection_ptr:10,show:[9,20,3,2,10],text:13,inherit_linearli:11,sent:[24,10],"_non_blocking_io":10,concurr:10,radic:22,protocol:[6,23,13,14,15,8,24,9,18,20,26,2,7,3,12],trivial:[7,25],find:[6,21],foo_direct:18,cout:[13,14,15,24,9,20,3,25],redirect:24,"_address":10,onli:[13,24,16,25,20,10,11,7,3,21,22,19],submit:[6,21,26],locat:24,pointer:[24,10],explain:15,response_head:[10,25],activ:[24,25,19,26],written:[6,23,17],makefil:21,"short":22,prolong:7,configur:[6,21,8,22],hello_world:8,meant:[23,18,11,10,17],set_head:10,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,fluid:16,soon:[6,10],ssl:[24,16,22],is_base_of:11,greatli:16,command:[13,8,9,20,3,21],"import":[10,22],report:[6,10,4,21],metafunct:[18,11,4,5],requir:[23,24,16,18,10,17,3,21,26],embedd:[25,22],question:[6,21],enabl:[21,26,10,11],emb:[24,10],applac:10,"_receive_low_watermark":10,"_port":10,rfc:[3,1,15,14,22],provid:[6,23,13,14,8,24,11,19,17,25,3,26],common:[26,2,15,18],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],"_openssl_verify_path":24,certif:24,lvalu:[10,18],tree:15,truli:7,"_thread_pool":10,accord:[3,15,18],packet:18,compliant:14,increasingli:26,see:[8,24,19,11,25,10,22],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],close:[6,20,10,15,25],charact:24,best:1,concern:22,awar:[6,26],statu:[25,22,10,8,17],flexibl:[7,15,11],extend:[7,26,11],correctli:[23,17],"_report_abort":10,pattern:[24,16,7,10,18],review:[6,18],easi:[6,9,26],"_body_handl":24,conveni:24,user_info:[14,3],state:[7,10],bridg:16,gaga:13,between:[3,21],progress:6,awai:10,approach:[16,11],across:[24,8],signatur:[24,10],assumpt:25,handler_:6,sstream:9,syntact:[7,18],status_message_:17,web:[21,26],numer:22,ask:[6,21],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,come:[23,16,7,21,17],endl:[13,14,8,15,24,9,20,3,25],addit:[16,7,3,21],both:[23,24,2,17,25,10,19],metaprogram:[1,21,4,11],exist:[24,20,21,26],subtitl:20,berri:26,cycl:24,response_:[6,24],howev:[25,21,11],alon:16,default_wstr:11,against:10,etc:26,handler_inst:10,context:[7,11],logic:[25,7,10,15,18],behaviour:13,whole:[11,17],load:24,concret:7,simpli:[23,7,14,25],publicli:[23,10,17],point:[18,11],instanti:10,overview:[3,4,12],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],linux:[21,4,22],comput:[10,21],pod:[23,18],throughout:22,assum:[23,15,24,9,18,10,17,21],summar:18,sever:[10,5],save:14,rudimentari:7,creat:[23,8,15,24,9,21,10,17,3,16],version_major:[24,23,19,25],"_receive_buffer_s":10,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,strategi:[24,16],bzip:21,flight:13,togeth:[21,26],target_typ:7,convert:[23,18,3,17],depend:[23,24,18,10,17,21,25],ani:[13,8,15,24,16,18,10,21,22],assert:3,unzip:21,craft:9,understand:10,deep:7,demand:26,"catch":[9,13,14,20,8],rang:[24,10],synchronoushandl:10,resid:[15,25],present:[6,15,18],"case":[23,8,24,16,17,18,10,11,21,25],inhibit:24,therefor:[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],boost_root:21,behavior:[24,16,25,11],error:[6,24,10,15,22],thrash:21,aid:2,invoc:10,anchor:23,loop:10,pack:[24,10],real:11,layer:[6,16,7,26],tar:21,almost:10,non:[3,10,18],destin:[23,18,17],itself:[7,11],motiv:[4,26],new_statu:10,boost_network_enable_http:22,no_cont:10,sizetyp:13,conn:10,headers_container_typ:[23,17],oper:[6,23,13,8,24,18,25,10,17,7,22],peopl:6,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,interact:21,http_keepalive_8bit_udp_resolv:[24,19,25],none:10,eventu:[6,26],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],user:[13,24,25,10,7,3,21,22,19],mani:[24,26,21,22],extern:[24,16,22],studi:6,soap:26,recent:[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,uint16_t:17,builder:[22,13,3,4,12],string_typ:[6,23,11,10,17],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],choos:[24,23,21,18],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],among:11,boost_network_no_lib:[24,22],tcp:[24,16,19,25],clear_resolved_cach:24,refactor:[6,22],world:[6,8,9,10,4,2],derived1:16,derived0:16,rest:14,body_handl:24,yet:[10,11],languag:26,previous:[10,8],"_handler":10,struct:[6,8,24,16,18,10,11,7,25],expos:10,critial:22,percent:13,had:26,except:[13,14,8,24,9,19,20,16,25],littl:[16,11],add:[23,18,21,15,17],is_valid:3,http_default_8bit_tcp_resolv:[24,19,25],versa:18,appli:[7,18],compat:24,els:24,adl:[18,11],subsequ:[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],read:[20,10,22,21],fuss:6,ladi:13,regard:22,wstring:[23,11,17],distanc:24,built:[15,24,16,2,21,22],asynchronoushandl:10,burden:21,guid:[6,1,21],mikhailberi:21,bit:[23,17],foo:[16,18,11],you:[6,14,8,15,24,9,21,10,11,16,25],licens:13,if_:11,"_cache_resolv":24,like:[21,13,8,24,16,18,10,11,7,9,25],specif:[8,24,18,1,3,21],filenam:[24,14],docutil:12,signal:15,echo_serv:25,cannot:[24,10],unix:[3,21],integ:23,noth:16,collect:26,"boolean":[24,10],necessari:8,either:[23,18,26,10,17],http_async_8bit_tcp_resolv:[24,19,25],http_version_minor:24,not_modifi:10,decis:16,input_rang:10,fulfil:26,encount:[24,10],www:[14,3,15,25],right:[10,11],dean:26,"_linger":10,deal:[16,10,8],simplifi:7,manual:[0,4],status_:17,creation:7,some:[6,23,13,9,11,21,10,17,20,3,16,22,5],pipelin:10,resolv:[24,19,25],certain:[25,18,7,10,11],intern:[23,24,10,11,22,25],enumer:8,sampl:[10,21],home:[21,26],indirect:[16,7],server:[6,23,14,0,8,15,24,9,21,25,26,2,19,22,3,10,4,12],variou:24,titl:[20,19],librari:[6,23,13,24,16,11,18,20,26,2,17,7,21,22],hasparseerror:13,googl:[6,21,22],connectionptr:10,scale:10,lead:7,abort:10,"_io_servic":[24,10],broad:7,normal:[24,23],octet:24,achiev:5,when:[16,22,26,10,18],tracker:6,larg:[10,11],slash:3,sequenc:24,three:[24,18,10,12,21,25],localhost:9,mode:22,msvc:22,mailto:3,previou:[14,21],run:[6,13,14,15,8,9,10,20,21,22],power:[13,3,21],whose:11,"enum":10,my_io_servic:[24,10],http_statu:10,broken:3,step:21,although:[21,16,18,10,11],output:3,wget:[14,2,4],post:[24,9,15,25],"throw":[24,10],session:24,src:21,c_str:[13,14],actual:10,socket:10,constraint:26,static_cast:14,slightli:11,page:[6,13,21],distinct:10,basic_serv:25,constructor:[14,8,15,24,10,20,3,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],erro:24,rapidjson:13,lifetim:24,default_str:11,within:[10,0,21],encod:[23,13,17],bound:10,two:[23,8,24,10,22,25],down:[16,7,3],creativ:16,been:[24,26,10,21],wrap:[16,18,17],default_tag:11,updat:22,destructor:16,mere:18,manag:[24,10,22],websit:[14,15],git:21,string_tag:11,object:[23,8,15,24,16,22,18,25,26,10,17,7,4,19],wai:[24,3,10,11],area:18,transfer:10,support:[6,23,13,15,8,24,16,11,18,25,26,10,17,7,3,21,4,22],snmp:18,primari:[10,11],fast:6,custom:24,avail:[24,16,18,10,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,reduc:21,head:[24,15,25],zip:21,gzip:21,form:[25,18,7,3,11],enough:[7,21],basic:[7,18],idea:[6,11],link:[6,21,24],translat:11,newer:[24,10,18],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,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],libcppnetlib:[21,22],until:24,asynchron:[24,22,0,4,10],not_support:10,below:[6,13,24,10,17,3,21,25],unspecifi:[23,17],those:[23,5,17],otherwis:[23,16,3,21],problem:16,http_version_major:24,similar:[20,14,24,9,18,25,10,11,7,19],impl:8,significantli:10,version_:17,featur:[6,13,26,21,11],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],"abstract":[16,15,8],parser:[14,20,3,21,22],moved_temporarili:10,doesn:22,repres:10,"char":[6,13,14,15,8,24,9,10,20],boostcon:[6,1],bad_gatewai:10,"8bit":24,file:[6,14,24,10,3,21],compulsori:21,face:[24,10],check:[6,21,15,22],fill:24,echo:25,denot:[10,11],readi:[24,22],macro:[24,22],cmake:[15,2,4,21],infosystem:3,nonetheless:18,"7zip":21,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,10],finish:[24,10],valid:[21,18],bool:[24,10],futur:[6,24,10,19,17,25],branch:[20,21],trait:[11,17],test:[21,22],linger:10,runtim:16,tmp:24,intend:[6,24,10,21],directive1:7,lend:7,subdivid:3,polymorph:[16,4,5],time:[7,10,22,21],source_typ:18,gcc:21,"_linger_timeout":10,definit:[23,18,10,11],"public":[10,0,25],intent:26,embed:[2,8,10],not_found:10,receiv:[24,10],pool:[10,22],your:[24,25,10,21],moved_perman:10,studio:21,vice:18,argpack:[24,10],info:[6,3],suit:21,descript:[23,24,18,10,17,25,3,19],flag:22,notion:[7,18],not_impl:10,some_str:24,basic_respons:[25,17],ignor:11,invok:[10,8,21],potenti:10,tcp_resolv:24,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-0.9.4/libs/network/doc/html/techniques.html000066400000000000000000000124461174460560600227720ustar00rootroot00000000000000 Techniques — cpp-netlib v0.9.4

    Techniques¶

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

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/techniques/000077500000000000000000000000001174460560600220755ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/html/techniques/directives.html000066400000000000000000000250621174460560600251310ustar00rootroot00000000000000 Directives — cpp-netlib v0.9.4

    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 | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/techniques/polymorphism.html000066400000000000000000000316401174460560600255310ustar00rootroot00000000000000 Static and dynamic polymorphism — cpp-netlib v0.9.4

    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 | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/techniques/tag_metafunctions.html000066400000000000000000000460161174460560600265040ustar00rootroot00000000000000 Tag metafunctions — cpp-netlib v0.9.4

    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.

    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/html/whats_new.html000066400000000000000000000322051174460560600226140ustar00rootroot00000000000000 What’s New — cpp-netlib v0.9.4

    What’s New¶

    cpp-netlib 0.9¶

    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
    « previous | up | next »
    documentation automatically generated by Sphinx | style mostly stolen from lettuce.it
    cpp-netlib-0.9.4/libs/network/doc/in_depth.rst000066400000000000000000000005331174460560600213060ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/in_depth/000077500000000000000000000000001174460560600205535ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/in_depth/http.rst000066400000000000000000000127411174460560600222710ustar00rootroot00000000000000HTTP 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_default_8bit_udp_resolve`` tag, and implements HTTP 1.0. 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-0.9.4/libs/network/doc/in_depth/http_client_tags.rst000066400000000000000000000062631174460560600246470ustar00rootroot00000000000000+---------------------------------+---------------------------------------------+ | 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-0.9.4/libs/network/doc/in_depth/message.rst000066400000000000000000000246701174460560600227420ustar00rootroot00000000000000The 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 is under review at present and will be subject to change in newer versions. 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-0.9.4/libs/network/doc/in_depth/uri.rst000066400000000000000000000134011174460560600221030ustar00rootroot00000000000000The 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-0.9.4/libs/network/doc/index.rst000066400000000000000000000100041174460560600206150ustar00rootroot00000000000000.. _index: .. rubric:: Straightforward network programming in modern C++ .. :Authors: Glyn Matthews .. Dean Michael Berris .. :Date: Feb 22, 2012 .. :Version: 0.9.4 .. :Description: Complete user documentation, with examples, for the :mod:`cpp-netlib`. .. :Copyright: Copyright Glyn Matthews, Dean Michael Berris 2008-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) Getting cpp-netlib ================== **Download** You can download the latest releases of the library at: http://github.com/cpp-netlib/cpp-netlib/downloads 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. Boost ===== The :mod:`cpp-netlib` is being developed for eventual submission to Boost_. .. image:: _static/boost.png :align: left C++ Network Library =================== The :mod:`cpp-netlib` is a library 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. It is developed by people linked to the Boost_ community and will soon be submitted for review into Boost. A presentation about :mod:`cpp-netlib` was given at `BoostCon 2010`_, for which the `slides`_ and the `paper`_ can be found on-line. 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:: c++ 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:: c++ 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 server_("0.0.0.0", "8000", handler_); 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 ` .. 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/ .. _`BoostCon 2010`: http://www.boostcon.com/ .. _`slides`: http://www.filetolink.com/b0e89d06 .. _`paper`: http://github.com/downloads/mikhailberis/cpp-netlib-boostcon-paper/cpp-netlib.pdf .. _Git: http://git-scm.com/ .. _GitHub: http://github.com/ cpp-netlib-0.9.4/libs/network/doc/make.bat000066400000000000000000000060071174460560600203710ustar00rootroot00000000000000@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-0.9.4/libs/network/doc/reference.rst000066400000000000000000000005311174460560600214500ustar00rootroot00000000000000.. _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-0.9.4/libs/network/doc/reference/000077500000000000000000000000001174460560600207175ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/reference/http_client.rst000066400000000000000000000366601174460560600240010ustar00rootroot00000000000000 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. * **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 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. 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 erros 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. 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. 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. Constructors ~~~~~~~~~~~~ The client implementation can be default constructed, or customized at initialization. ``client()`` Default constructor. ``client(boost::asio::io_service & io_service)`` Construct a client to use an existing Boost.Asio ``io_service`` instance. ``template client(ArgPack const & args)`` Pass in an argument pack. See supported parameters in the table below. +----------------------+-------------------------------+-------------------------+ | 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 | ``boost::asio::io_service &`` | Reference to an | | | | instance of 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. | +----------------------+-------------------------------+-------------------------+ 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 boost::asio::io_service my_io_service; client client_(_follow_redirects=true, _cache_resolved=true, _io_service=my_io_service , _openssl_certificate="/tmp/my-cert" , _openssl_verify_path="/tmp/ca-certs/"); // 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_, _body_handler=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_, _body_handler=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, _body_handler=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_, content_type, body)`` 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_, content_type, body, _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 &)``. ``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_, _body_handler=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, _body_handler=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_, content_type, body)`` 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_, content_type, body, _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 &)``. ``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=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/"), _body_handler=print_body); The ``BOOST_NETWORK_HTTP_BODY_CALLBACK`` macro is defined in ``boost/network/protocol/http/client/macros.hpp``. cpp-netlib-0.9.4/libs/network/doc/reference/http_request.rst000066400000000000000000000316341174460560600242070ustar00rootroot00000000000000 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: 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-0.9.4/libs/network/doc/reference/http_response.rst000066400000000000000000000427461174460560600243630ustar00rootroot00000000000000 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. 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: 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 string::type`` 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-0.9.4/libs/network/doc/reference/http_server.rst000066400000000000000000000632511174460560600240250ustar00rootroot00000000000000 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 ``````````` ``http_server(address, port, handler)`` Construct an HTTP Server instance, passing in the address and port as ``std::string const &`` and handler being of type ``handler_type`` but passed in as an lvalue reference. ``template client(ArgPack const & args)`` Pass in an argument pack. See supported parameters in the table below. +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | 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. | +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | _handler | ``Handler &`` | An lvalue reference to an instance of ``Handler``. This parameter is required. | +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ | _thread_pool | ``boost::network::utils::thread_pool &`` | An lvalue reference 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 | ``boost::asio::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``. | +------------------------+------------------------------------------+--------------------------------------------------------------------------------------------------+ 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 boost::asio::io_service my_io_service; boost::network::utils::thread_pool pool(2); handler handler_instance; async_server instance(_address="0.0.0.0", _port="80", _handler=handler_instance, _io_service=my_io_service, _thread_pool=pool, _reuse_address=true); 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 server("127.0.0.1", "8000", handler); ``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 applacation 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 ``````````` ``http_server(address, port, handler, thread_pool)`` Construct an HTTP Server instance, passing in the address and port as ``std::string const &`` and handler being of type ``handler_type`` but passed in as an lvalue reference. The ``thread_pool`` parameter is an instance of ``boost::network::utils::thread_pool`` that has been previously instantiated. .. note:: The ``boost::network::utils::thread_pool`` has a single constructor parameter which is the number of threads to run the thread pool. 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; boost::network::utils::thread_pool thread_pool(2); http_server server("127.0.0.1", "8000", handler, thread_pool); ``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. .. _Boost.Range: http://www.boost.org/libs/range .. _Boost.Function: http://www.boost.org/libs/function cpp-netlib-0.9.4/libs/network/doc/references.rst000066400000000000000000000020141174460560600216310ustar00rootroot00000000000000References ========== 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-0.9.4/libs/network/doc/techniques.rst000066400000000000000000000004111174460560600216570ustar00rootroot00000000000000Techniques ========== 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-0.9.4/libs/network/doc/techniques/000077500000000000000000000000001174460560600211315ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/doc/techniques/directives.rst000066400000000000000000000066741174460560600240410ustar00rootroot00000000000000Directives ========== 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-0.9.4/libs/network/doc/techniques/polymorphism.rst000066400000000000000000000065001174460560600244260ustar00rootroot00000000000000Static 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-0.9.4/libs/network/doc/techniques/tag_metafunctions.rst000066400000000000000000000130661174460560600254030ustar00rootroot00000000000000Tag 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-0.9.4/libs/network/doc/whats_new.rst000066400000000000000000000103011174460560600215050ustar00rootroot00000000000000.. _whats_new: ************ What's New ************ :mod:`cpp-netlib` 0.9 --------------------- 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-0.9.4/libs/network/example/000077500000000000000000000000001174460560600176475ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/CMakeLists.txt000066400000000000000000000075661174460560600224250ustar00rootroot00000000000000# 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) 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) set(BOOST_CLIENT_LIBS ${Boost_PROGRAM_OPTIONS_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_DATE_TIME_LIBRARY} ${Boost_REGEX_LIBRARY} ${Boost_SYSTEM_LIBRARY}) set(BOOST_SERVER_LIBS ${Boost_THREAD_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${Boost_DATE_TIME_LIBRARY} ${Boost_PROGRAM_OPTIONS_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(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) 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}) endif (OPENSSL_FOUND) if (UNIX) target_link_libraries(fileserver ${BOOST_SERVER_LIBS} ${Boost_FILESYSTEM_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} cppnetlib-server-parsers) 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(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) if (UNIX) set_target_properties(fileserver PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CPP-NETLIB_BINARY_DIR}/example) endif (UNIX) cpp-netlib-0.9.4/libs/network/example/Jamfile.v2000066400000000000000000000033671174460560600215000ustar00rootroot00000000000000 # 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) project network_test : requirements ../../../ /boost//system /boost//date_time /boost//regex /boost//thread /boost//program_options gcc:-lpthread gcc:-lssl msvc:BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN msvc:WIN32_LEAN_AND_MEAN static 256 debug:BOOST_NETWORK_DEBUG ; exe uri : uri.cpp /cpp-netlib//cppnetlib-uri ; exe http_client : http_client.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; exe http_client1 : http_client1.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; exe simple_wget : simple_wget.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; exe atom_reader : atom/main.cpp atom/atom.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; exe rss_reader : rss/main.cpp rss/rss.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; exe twitter_search : twitter/search.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; exe hello_world_server : http/hello_world_server.cpp /cpp-netlib//cppnetlib-server-parsers ; exe hello_world_client : http/hello_world_client.cpp /cpp-netlib//cppnetlib-uri ; exe one_liner : http/one_liner.cpp /cpp-netlib//cppnetlib-uri ; exe fileserver : http/fileserver.cpp /cpp-netlib//cppnetlib-server-parsers ; cpp-netlib-0.9.4/libs/network/example/atom/000077500000000000000000000000001174460560600206075ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/atom/atom.cpp000066400000000000000000000056321174460560600222610ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/atom/atom.hpp000066400000000000000000000057211174460560600222650ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/atom/main.cpp000066400000000000000000000021331174460560600222360ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/http/000077500000000000000000000000001174460560600206265ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/http/fileserver.cpp000066400000000000000000000156201174460560600235040ustar00rootroot00000000000000// 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); utils::thread_pool thread_pool(4); server instance("0.0.0.0", "8000", handler, thread_pool); instance.run(); return 0; } cpp-netlib-0.9.4/libs/network/example/http/hello_world_client.cpp000066400000000000000000000024331174460560600252040ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/http/hello_world_server.cpp000066400000000000000000000035601174460560600252360ustar00rootroot00000000000000// 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); std::ostringstream data; data << "Hello, " << ip << "!"; 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 server_(argv[1], argv[2], handler); /*<< Runs the server. >>*/ server_.run(); } catch (std::exception &e) { std::cerr << e.what() << std::endl; return 1; } return 0; } //] cpp-netlib-0.9.4/libs/network/example/http/one_liner.cpp000066400000000000000000000011471174460560600233070ustar00rootroot00000000000000 // 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-0.9.4/libs/network/example/http_client.cpp000066400000000000000000000051271174460560600226750ustar00rootroot00000000000000 // 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) //[ 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") ("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 ; typedef http::basic_client http_client; http_client::request request(source); http_client::string_type destination_ = host(request); request << ::boost::network::header("Connection", "close"); http_client client(http::_follow_redirects=true); http_client::response response = client.get(request); 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; }; body_range::type body_ = body(response).range(); boost::copy(body_, std::ostream_iterator::type>(std::cout)); return EXIT_SUCCESS; } //] cpp-netlib-0.9.4/libs/network/example/http_client1.cpp000066400000000000000000000012661174460560600227560ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/rapidxml/000077500000000000000000000000001174460560600214675ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/rapidxml/license.txt000066400000000000000000000053001174460560600236500ustar00rootroot00000000000000Use 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-0.9.4/libs/network/example/rapidxml/manual.html000066400000000000000000003347131174460560600236450ustar00rootroot00000000000000

    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-0.9.4/libs/network/example/rapidxml/rapidxml.hpp000066400000000000000000003471051174460560600240320ustar00rootroot00000000000000#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_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-0.9.4/libs/network/example/rapidxml/rapidxml_iterators.hpp000066400000000000000000000075161174460560600261250ustar00rootroot00000000000000#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-0.9.4/libs/network/example/rapidxml/rapidxml_print.hpp000066400000000000000000000364671174460560600252540ustar00rootroot00000000000000#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-0.9.4/libs/network/example/rapidxml/rapidxml_utils.hpp000066400000000000000000000065311174460560600252450ustar00rootroot00000000000000#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-0.9.4/libs/network/example/rss/000077500000000000000000000000001174460560600204565ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/rss/main.cpp000066400000000000000000000021461174460560600221110ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/rss/rss.cpp000066400000000000000000000041701174460560600217730ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/rss/rss.hpp000066400000000000000000000037541174460560600220070ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/simple_wget.cpp000066400000000000000000000031241174460560600226720ustar00rootroot00000000000000// 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; } 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; } //] cpp-netlib-0.9.4/libs/network/example/twitter/000077500000000000000000000000001174460560600213515ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/twitter/rapidjson/000077500000000000000000000000001174460560600233425ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/twitter/rapidjson/document.h000066400000000000000000000704521174460560600253410ustar00rootroot00000000000000#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.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-0.9.4/libs/network/example/twitter/rapidjson/filestream.h000066400000000000000000000017111174460560600256460ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/internal/000077500000000000000000000000001174460560600251565ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/example/twitter/rapidjson/internal/pow10.h000066400000000000000000000116151174460560600263010ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/internal/stack.h000066400000000000000000000045131174460560600264370ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/internal/strfunc.h000066400000000000000000000012501174460560600270110ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/prettywriter.h000066400000000000000000000121671174460560600263060ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/rapidjson.h000066400000000000000000000402011174460560600255010ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/reader.h000066400000000000000000000473741174460560600247740ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/stringbuffer.h000066400000000000000000000025341174460560600262170ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/rapidjson/writer.h000066400000000000000000000150061174460560600250310ustar00rootroot00000000000000#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-0.9.4/libs/network/example/twitter/search.cpp000066400000000000000000000031051174460560600233210ustar00rootroot00000000000000// 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-0.9.4/libs/network/example/uri_builder.cpp000066400000000000000000000010601174460560600226550ustar00rootroot00000000000000// 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-0.9.4/libs/network/src/000077500000000000000000000000001174460560600170035ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/src/CMakeLists.txt000066400000000000000000000012661174460560600215500ustar00rootroot00000000000000# 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}) set(CPP-NETLIB_URI_SRCS uri/uri.cpp uri/schemes.cpp) add_library(cppnetlib-uri ${CPP-NETLIB_URI_SRCS}) set(CPP-NETLIB_HTTP_SERVER_SRCS server_request_parsers_impl.cpp) add_library(cppnetlib-server-parsers ${CPP-NETLIB_HTTP_SERVER_SRCS}) set(CPP-NETLIB_HTTP_CLIENT_SRCS client.cpp) add_library(cppnetlib-client-connections ${CPP-NETLIB_HTTP_CLIENT_SRCS}) cpp-netlib-0.9.4/libs/network/src/client.cpp000066400000000000000000000010751174460560600207700ustar00rootroot00000000000000 // 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-0.9.4/libs/network/src/server_request_parsers_impl.cpp000066400000000000000000000005051174460560600253450ustar00rootroot00000000000000// 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-0.9.4/libs/network/src/uri/000077500000000000000000000000001174460560600176025ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/src/uri/schemes.cpp000066400000000000000000000037011174460560600217360ustar00rootroot00000000000000// 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-0.9.4/libs/network/src/uri/uri.cpp000066400000000000000000000003751174460560600211120ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/000077500000000000000000000000001174460560600171735ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/test/CMakeLists.txt000066400000000000000000000023101174460560600217270ustar00rootroot00000000000000# 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 ) 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() 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-0.9.4/libs/network/test/Jamfile.v2000066400000000000000000000033711174460560600210170ustar00rootroot00000000000000 # 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) import testing ; import os ; if [ os.name ] = CYGWIN { lib ws2_32 ; lib mswsock ; } project network_test : requirements ../../../ . /boost//unit_test_framework /boost//system /boost//date_time /boost//regex /boost//thread /boost//filesystem debug:BOOST_NETWORK_DEBUG gcc:BOOST_NETWORK_ENABLE_HTTPS gcc:-lpthread gcc:-lssl gcc:-lcrypto darwin:BOOST_NETWORK_ENABLE_HTTPS darwin:-lpthread darwin:-lssl darwin:-lcrypto clang:BOOST_NETWORK_ENABLE_HTTPS clang:-lpthread clang:-lssl clang:-lcrypto cygwin,gcc:_WIN32_WINNT=0x0501 cygwin,gcc:__USE_W32_SOCKETS cygwin,gcc:ws2_32 cygwin,gcc:mswsock msvc:BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN msvc:WIN32_LEAN_AND_MEAN msvc:_SCL_SECURE_NO_WARNINGS msvc:_WIN32_WINNT=0x0501 256 static ; build-project http ; build-project uri ; run message_test.cpp ; run message_transform_test.cpp ; cpp-netlib-0.9.4/libs/network/test/client_server_include_failure.cpp000066400000000000000000000014421174460560600257560ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/http/000077500000000000000000000000001174460560600201525ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/test/http/CMakeLists.txt000066400000000000000000000045011174460560600227120ustar00rootroot00000000000000 # 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 client_constructor_test client_get_test client_get_different_port_test client_get_timeout_test client_get_streaming_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-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() 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 ) foreach ( test ${SERVER_API_TESTS} ) if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU) set_source_files_properties(${test}.cpp PROPERTIES COMPILE_FLAGS "-Wall") endif() 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) 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-0.9.4/libs/network/test/http/Jamfile.v2000066400000000000000000000051041174460560600217720ustar00rootroot00000000000000 # 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) import testing ; import modules ; import feature ; project network_test/http : requirements ../../../../ ../ debug:BOOST_NETWORK_DEBUG ; run client_constructor_test.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; run client_get_test.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; run client_get_different_port_test.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; run client_get_timeout_test.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; #run client_include_inlined.cpp : BOOST_NETWORK_NO_LIB ; run client_localhost_normal_test.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; run client_localhost_ssl_test.cpp /cpp-netlib//cppnetlib-uri /cpp-netlib//cppnetlib-client-connections ; run message_async_ready_test.cpp ; run message_test.cpp /cpp-netlib//cppnetlib-uri ; run request_incremental_parser_test.cpp ; run request_linearize_test.cpp /cpp-netlib//cppnetlib-uri ; run response_incremental_parser_test.cpp /cpp-netlib//cppnetlib-server-parsers ; run server_constructor_test.cpp /cpp-netlib//cppnetlib-server-parsers ; #run server_include_inlined.cpp : BOOST_NETWORK_NO_LIB ; exe http_async_server : server_async.cpp /cpp-netlib//cppnetlib-server-parsers ; exe hello_world : server_hello_world.cpp /cpp-netlib//cppnetlib-server-parsers ; exe http_async_less_copy_server : server_async_less_copy.cpp /cpp-netlib//cppnetlib-server-parsers ; exe http_async_run_stop_concurrency_server : server_async_run_stop_concurrency.cpp /cpp-netlib//cppnetlib-server-parsers ; make httplib_acceptance.passed : ../httplib_acceptance.py hello_world : @httplib_acceptance ; make httplib_async_acceptance.passed : ../httplib_acceptance.py http_async_server : @httplib_acceptance ; make httplib_async_less_copy_acceptance.passed : ../httplib_acceptance.py http_async_less_copy_server : @httplib_acceptance ; make httplib_async_run_stop_concurrency_acceptance.passed : ../httplib_acceptance.py http_async_run_stop_concurrency_server : @httplib_acceptance ; actions httplib_acceptance { export TEST_SCRIPT=`echo "$(>)" | awk '{print $1}'` export EXECUTABLE=`echo "$(>)" | awk '{print $2}'` export PORT=`echo "import random; print random.randint(8000, 8010)" | python` python $TEST_SCRIPT $EXECUTABLE $PORT $(<) } cpp-netlib-0.9.4/libs/network/test/http/client_constructor_test.cpp000066400000000000000000000021661174460560600256450ustar00rootroot00000000000000 // 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) { client instance; boost::asio::io_service io_service; client instance2(io_service); client instance3(http::_io_service=io_service); } BOOST_AUTO_TEST_CASE_TEMPLATE(http_cient_constructor_params_test, client, client_types) { client instance( http::_follow_redirects=true, http::_cache_resolved=true ); boost::asio::io_service io_service; client instance2( http::_follow_redirects=true, http::_io_service=io_service, http::_cache_resolved=true ); client instance3( http::_openssl_certificate="foo", http::_openssl_verify_path="bar" ); } cpp-netlib-0.9.4/libs/network/test/http/client_get_different_port_test.cpp000066400000000000000000000016071174460560600271300ustar00rootroot00000000000000 // 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-0.9.4/libs/network/test/http/client_get_streaming_test.cpp000066400000000000000000000033341174460560600261060ustar00rootroot00000000000000// 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, http::_body_handler=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-0.9.4/libs/network/test/http/client_get_test.cpp000066400000000000000000000031141174460560600240310ustar00rootroot00000000000000// 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 cpp-netlib-0.9.4/libs/network/test/http/client_get_timeout_test.cpp000066400000000000000000000015231174460560600256010ustar00rootroot00000000000000 // 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 ); } cpp-netlib-0.9.4/libs/network/test/http/client_include_inlined.cpp000066400000000000000000000012471174460560600253450ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/http/client_localhost_normal_test.cpp000066400000000000000000000311461174460560600266200ustar00rootroot00000000000000// // 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-0.9.4/libs/network/test/http/client_localhost_ssl_test.cpp000066400000000000000000000275751174460560600261440ustar00rootroot00000000000000// // 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-0.9.4/libs/network/test/http/client_types.hpp000066400000000000000000000030671174460560600233730ustar00rootroot00000000000000#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< tag_types, client_adapter<1,0> >::type client_1_0; typedef mpl::transform< tag_types, client_adapter<1,1> >::type client_1_1; typedef mpl::joint_view< client_1_0 , client_1_1 >::type client_types; typedef mpl::joint_view< mpl::transform< mpl::remove_if< tag_types, boost::network::is_sync< boost::mpl::_ > >::type, client_adapter<1,0> >::type, mpl::transform< mpl::remove_if< tag_types, boost::network::is_sync< boost::mpl::_ > >::type, client_adapter<1,1> >::type >::type async_only_client_types; #endif /* CLIENT_TYPES_ROOWQCLE */ cpp-netlib-0.9.4/libs/network/test/http/http_test_server.hpp000066400000000000000000000107421174460560600242730ustar00rootroot00000000000000// // 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-0.9.4/libs/network/test/http/message_async_ready_test.cpp000066400000000000000000000010511174460560600257170ustar00rootroot00000000000000 // 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-0.9.4/libs/network/test/http/message_test.cpp000066400000000000000000000171161174460560600233470ustar00rootroot00000000000000 // 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< http::tags::http_default_8bit_tcp_resolve , http::tags::http_default_8bit_udp_resolve , http::tags::http_keepalive_8bit_tcp_resolve , http::tags::http_keepalive_8bit_udp_resolve > 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-0.9.4/libs/network/test/http/request_incremental_parser_test.cpp000066400000000000000000000133341174460560600273460ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/http/request_linearize_test.cpp000066400000000000000000000021511174460560600254460ustar00rootroot00000000000000 // 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 namespace http = boost::network::http; namespace tags = boost::network::http::tags; namespace mpl = boost::mpl; namespace net = boost::network; typedef mpl::list< tags::http_default_8bit_tcp_resolve , tags::http_default_8bit_udp_resolve , tags::http_async_8bit_tcp_resolve , tags::http_async_8bit_udp_resolve > tag_types; BOOST_AUTO_TEST_CASE_TEMPLATE(linearize_request, T, tag_types) { http::basic_request request("http://www.boost.org"); linearize(request, "GET", 1, 0, std::ostream_iterator::type>(std::cout)); linearize(request, "GET", 1, 1, std::ostream_iterator::type>(std::cout)); } cpp-netlib-0.9.4/libs/network/test/http/response_incremental_parser_test.cpp000066400000000000000000000230101174460560600275040ustar00rootroot00000000000000 // 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; 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(incremental_parser_parse_status) { 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; } /** 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(incremental_parser_parse_status_message) { 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\r\nServer: 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\r\n"; 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\r\n"; 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(incremental_parser_parse_header_lines) { 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\r\nContent-Type: application/json\r\n\r\n"; 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); } cpp-netlib-0.9.4/libs/network/test/http/server_async.cpp000066400000000000000000000032701174460560600233630ustar00rootroot00000000000000 // 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-0.9.4/libs/network/test/http/server_async_less_copy.cpp000066400000000000000000000037401174460560600254450ustar00rootroot00000000000000 // 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-0.9.4/libs/network/test/http/server_async_run_stop_concurrency.cpp000066400000000000000000000107441174460560600277320ustar00rootroot00000000000000#define BOOST_TEST_MODULE HTTP Asynchronous Server Tests #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 \ http::_address = "127.0.0.1", \ http::_port = "8007", \ http::_handler = async_handler, \ http::_thread_pool = pool, \ http::_reuse_address = true #define ASYNC_SERVER_SLEEP_TIME \ boost::posix_time::milliseconds(100) // stop from main thread { BOOST_NETWORK_MESSAGE("TEST: stop without running"); util::thread_pool pool; async_server server_instance(ASYNC_SERVER_TEST_CONFIG); server_instance.stop(); } // run-stop from main thread { BOOST_NETWORK_MESSAGE("TEST: stop from main thread"); util::thread_pool pool; 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"); util::thread_pool pool; 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"); util::thread_pool pool; 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"); util::thread_pool pool; 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"); util::thread_pool pool; 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; } cpp-netlib-0.9.4/libs/network/test/http/server_constructor_test.cpp000066400000000000000000000053451174460560600256770ustar00rootroot00000000000000 // 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; util::thread_pool pool; BOOST_CHECK_NO_THROW(sync_server sync_instance("127.0.0.1", "80", sync_handler) ); BOOST_CHECK_NO_THROW(async_server async_instance("127.0.0.1", "80", async_handler, pool) ); } BOOST_AUTO_TEST_CASE(with_io_service_parameter) { dummy_sync_handler sync_handler; dummy_async_handler async_handler; util::thread_pool pool; boost::asio::io_service io_service; BOOST_CHECK_NO_THROW(sync_server sync_instance("127.0.0.1", "80", sync_handler, io_service)); BOOST_CHECK_NO_THROW(async_server async_instance("127.0.0.1", "80", async_handler, pool, io_service)); } BOOST_AUTO_TEST_CASE(with_socket_options_parameter) { dummy_sync_handler sync_handler; dummy_async_handler async_handler; util::thread_pool pool; BOOST_CHECK_NO_THROW(sync_server sync_instance("127.0.0.1", "80", sync_handler, http::_reuse_address=true, http::_report_aborted=true, http::_receive_buffer_size=4096, http::_send_buffer_size=4096, http::_receive_low_watermark=1024, http::_send_low_watermark=1024, http::_non_blocking_io=true, http::_linger=true, http::_linger_timeout=0 )); BOOST_CHECK_NO_THROW(async_server async_instance("127.0.0.1", "80", async_handler, pool, http::_reuse_address=true, http::_report_aborted=true, http::_receive_buffer_size=4096, http::_send_buffer_size=4096, http::_receive_low_watermark=1024, http::_send_low_watermark=1024, http::_non_blocking_io=true, http::_linger=true, http::_linger_timeout=0 )); } cpp-netlib-0.9.4/libs/network/test/http/server_hello_world.cpp000066400000000000000000000027641174460560600245670ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/http/server_include_inlined.cpp000066400000000000000000000033231174460560600253720ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/http/tag_types.hpp000066400000000000000000000013361174460560600226650ustar00rootroot00000000000000#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< http::tags::http_default_8bit_tcp_resolve , http::tags::http_default_8bit_udp_resolve , http::tags::http_keepalive_8bit_tcp_resolve , http::tags::http_keepalive_8bit_udp_resolve , http::tags::http_async_8bit_udp_resolve , http::tags::http_async_8bit_tcp_resolve > tag_types; #endif /* TAG_TYPES_4NNM8B5T */ cpp-netlib-0.9.4/libs/network/test/http_server_async_less_copy.cpp000066400000000000000000000052511174460560600255240ustar00rootroot00000000000000 // 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-0.9.4/libs/network/test/httplib_acceptance.py000066400000000000000000000052661174460560600233720ustar00rootroot00000000000000# 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-0.9.4/libs/network/test/message_test.cpp000066400000000000000000000123711174460560600223660ustar00rootroot00000000000000 // 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< http::tags::http_default_8bit_tcp_resolve, http::tags::http_default_8bit_udp_resolve, http::tags::http_keepalive_8bit_tcp_resolve, http::tags::http_keepalive_8bit_udp_resolve, tags::default_string, tags::default_wstring > 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-0.9.4/libs/network/test/message_transform_test.cpp000066400000000000000000000024201174460560600244530ustar00rootroot00000000000000 // 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-0.9.4/libs/network/test/server/000077500000000000000000000000001174460560600205015ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/test/server/boost.jpg000066400000000000000000000107061174460560600223350ustar00rootroot00000000000000ÿØÿà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-0.9.4/libs/network/test/server/certificate.pem000066400000000000000000000013651174460560600234730ustar00rootroot00000000000000-----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-0.9.4/libs/network/test/server/cgi-bin/000077500000000000000000000000001174460560600220115ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/test/server/cgi-bin/cgisupport.py000077500000000000000000000022361174460560600245700ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/cgi-bin/echo_body.py000077500000000000000000000013011174460560600243140ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/cgi-bin/echo_headers.py000077500000000000000000000011521174460560600247760ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/cgi-bin/multiline-header.py000077500000000000000000000024161174460560600256210ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/cgi-bin/requestinfo.py000077500000000000000000000032221174460560600247310ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/cgi_server.py000066400000000000000000000016641174460560600232120ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/http_test_server.py000066400000000000000000000020671174460560600244640ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/https_test_server.py000066400000000000000000000031711174460560600246440ustar00rootroot00000000000000#!/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-0.9.4/libs/network/test/server/key.pem000066400000000000000000000015671174460560600220050ustar00rootroot00000000000000-----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-0.9.4/libs/network/test/server/test.xml000066400000000000000000000001611174460560600222000ustar00rootroot00000000000000 Hi! This is node 1 Node 2 here. cpp-netlib-0.9.4/libs/network/test/uri/000077500000000000000000000000001174460560600177725ustar00rootroot00000000000000cpp-netlib-0.9.4/libs/network/test/uri/CMakeLists.txt000066400000000000000000000023341174460560600225340ustar00rootroot00000000000000# 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() 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-0.9.4/libs/network/test/uri/Jamfile.v2000066400000000000000000000007471174460560600216220ustar00rootroot00000000000000 # Copyright 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) import testing ; project network_test/uri : requirements ../../../../ ../ ; run url_test.cpp /cpp-netlib//cppnetlib-uri ; run url_builder_test.cpp /cpp-netlib//cppnetlib-uri ; run url_encoding_test.cpp /cpp-netlib//cppnetlib-uri ; cpp-netlib-0.9.4/libs/network/test/uri/relative_uri_test.cpp000066400000000000000000000011471174460560600242320ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/uri/uri_builder_stream_test.cpp000066400000000000000000000106151174460560600254200ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/uri/uri_builder_test.cpp000066400000000000000000000112211174460560600240370ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/uri/uri_encoding_test.cpp000066400000000000000000000020301174460560600241750ustar00rootroot00000000000000// 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-0.9.4/libs/network/test/uri/uri_test.cpp000066400000000000000000000452301174460560600223400ustar00rootroot00000000000000// 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/")); } cpp-netlib-0.9.4/libs/network/test/utils_thread_pool.cpp000066400000000000000000000027341174460560600234250ustar00rootroot00000000000000 // 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-0.9.4/package.sh000077500000000000000000000013321174460560600155230ustar00rootroot00000000000000#!/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."