Line data    Source code

       1             : //
       2             : // Copyright (c) 2021 Vinnie Falco (vinnie.falco@gmail.com)
       3             : //
       4             : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5             : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6             : //
       7             : // Official repository: https://github.com/CPPAlliance/http_proto
       8             : //
       9             : 
      10             : #ifndef BOOST_HTTP_PROTO_IMPL_ERROR_IPP
      11             : #define BOOST_HTTP_PROTO_IMPL_ERROR_IPP
      12             : 
      13             : #include <boost/http_proto/error.hpp>
      14             : #include <boost/url/grammar/error.hpp>
      15             : #include <boost/assert.hpp>
      16             : #include <type_traits>
      17             : 
      18             : namespace boost {
      19             : namespace http_proto {
      20             : 
      21             : system::error_code
      22       18047 : make_error_code(
      23             :     error ev) noexcept
      24             : {
      25             :     struct cat_type
      26             :         : system::error_category
      27             :     {
      28           6 :         cat_type() noexcept
      29           6 :             : error_category(
      30           6 :                 0x3663257e7585fbfd)
      31             :         {
      32           6 :         }
      33             : 
      34             :         const char*
      35          29 :         name() const noexcept override
      36             :         {
      37          29 :             return "boost.http.proto";
      38             :         }
      39             : 
      40             :         std::string
      41          29 :         message(int code) const override
      42             :         {
      43          29 :             switch(static_cast<error>(code))
      44             :             {
      45           1 :             case error::expect_100_continue: return "expect continue";
      46           1 :             case error::end_of_message: return "end of message";
      47           1 :             case error::end_of_stream: return "end of stream";
      48           1 :             case error::need_data: return "need data";
      49             : 
      50           1 :             case error::bad_connection: return "bad Connection";
      51           1 :             case error::bad_content_length: return "bad Content-Length";
      52           1 :             case error::bad_expect: return "bad Expect";
      53           1 :             case error::bad_field_name: return "bad field name";
      54           1 :             case error::bad_field_value: return "bad field value";
      55           1 :             case error::bad_line_ending: return "bad line ending";
      56           1 :             case error::bad_list: return "bad list";
      57           1 :             case error::bad_method: return "bad method";
      58           1 :             case error::bad_number: return "bad number";
      59           1 :             case error::bad_payload: return "bad payload";
      60           1 :             case error::bad_version: return "bad version";
      61           1 :             case error::bad_reason: return "bad reason-phrase";
      62           1 :             case error::bad_request_target: return "bad request-target";
      63           1 :             case error::bad_status_code: return "bad status-code";
      64           1 :             case error::bad_status_line: return "bad status-line";
      65           1 :             case error::bad_transfer_encoding: return "bad Transfer-Encoding";
      66           1 :             case error::bad_upgrade: return "bad Upgrade";
      67             : 
      68           1 :             case error::body_too_large: return "body too large";
      69           1 :             case error::headers_limit: return "headers limit";
      70           1 :             case error::start_line_limit: return "start line limit";
      71           1 :             case error::field_size_limit: return "field size limit";
      72           1 :             case error::fields_limit: return "fields limit";
      73           1 :             case error::incomplete: return "incomplete";
      74             : 
      75           1 :             case error::numeric_overflow: return "numeric overflow";
      76           1 :             case error::multiple_content_length: return "multiple Content-Length";
      77           0 :             default:
      78           0 :                 return "unknown";
      79             :             }
      80             :         }
      81             :     };
      82             : 
      83       18047 :     static cat_type const cat{};
      84             :     return system::error_code{static_cast<
      85             :         std::underlying_type<
      86       18047 :             error>::type>(ev), cat};
      87             : }
      88             : 
      89             : system::error_condition
      90       41213 : make_error_condition(
      91             :     condition cv) noexcept
      92             : {
      93             :     struct cat_type
      94             :         : system::error_category
      95             :     {
      96           3 :         cat_type() noexcept
      97           3 :             : error_category(
      98           3 :                 0xa36e10f16c666a7)
      99             :         {
     100           3 :         }
     101             : 
     102             :         const char*
     103           1 :         name() const noexcept override
     104             :         {
     105           1 :             return "boost.http.proto";
     106             :         }
     107             : 
     108             :         std::string
     109           1 :         message(int code) const override
     110             :         {
     111             :             switch(static_cast<condition>(code))
     112             :             {
     113             :             default:
     114           1 :             case condition::need_more_input: return "need more input";
     115             :             }
     116             :         }
     117             : 
     118             :         bool
     119       41211 :         equivalent(
     120             :             system::error_code const& ec,
     121             :             int code) const noexcept override
     122             :         {
     123       41211 :             switch(static_cast<condition>(code))
     124             :             {
     125       41211 :             case condition::need_more_input:
     126       56791 :                 if( ec == urls::grammar::error::need_more ||
     127       56791 :                     ec == error::need_data)
     128       27978 :                     return true;
     129       13233 :                 break;
     130             : 
     131           0 :             default:
     132           0 :                 break;
     133             :             }
     134             :             return
     135       13233 :                 *this == ec.category() &&
     136       13233 :                 ec.value() == code;
     137             :         }
     138             :     };
     139             : 
     140       41213 :     static cat_type const cat{};
     141       41213 :     return system::error_condition{
     142             :         static_cast<std::underlying_type<
     143       41213 :             error>::type>(cv), cat};
     144             : }
     145             : 
     146             : } // http_proto
     147             : } // boost
     148             : 
     149             : #endif