Line data    Source code

       1              : //
       2              : // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
       3              : // Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)
       4              : //
       5              : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       6              : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       7              : //
       8              : // Official repository: https://github.com/boostorg/json
       9              : //
      10              : 
      11              : #ifndef BOOST_JSON_IMPL_PARSE_INTO_HPP
      12              : #define BOOST_JSON_IMPL_PARSE_INTO_HPP
      13              : 
      14              : #include <boost/json/basic_parser_impl.hpp>
      15              : #include <boost/json/error.hpp>
      16              : #include <istream>
      17              : 
      18              : namespace boost {
      19              : namespace json {
      20              : 
      21              : template< class V, class Ctx >
      22              : void
      23          247 : parse_into(
      24              :     V& v,
      25              :     string_view sv,
      26              :     system::error_code& ec,
      27              :     parse_options const& opt,
      28              :     Ctx const& ctx )
      29              : {
      30          247 :     parser_for<V, Ctx> p(opt, &v, ctx);
      31          247 :     std::size_t n = p.write_some(false, sv.data(), sv.size(), ec);
      32          247 :     if( !ec && n < sv.size() )
      33              :     {
      34            1 :         BOOST_JSON_FAIL(ec, error::extra_data);
      35              :     }
      36          247 : }
      37              : 
      38              : template< class V, class Ctx >
      39              : void
      40           71 : parse_into(
      41              :     V& v,
      42              :     string_view sv,
      43              :     std::error_code& ec,
      44              :     parse_options const& opt,
      45              :     Ctx const& ctx )
      46              : {
      47           71 :     system::error_code jec;
      48           71 :     parse_into(v, sv, jec, opt, ctx);
      49           71 :     ec = jec;
      50           71 : }
      51              : 
      52              : template< class V, class Ctx >
      53              : void
      54           79 : parse_into(
      55              :     V& v,
      56              :     string_view sv,
      57              :     parse_options const& opt,
      58              :     Ctx const& ctx )
      59              : {
      60           79 :     system::error_code ec;
      61           79 :     parse_into(v, sv, ec, opt, ctx);
      62           79 :     if( ec.failed() )
      63            1 :         detail::throw_system_error( ec );
      64           78 : }
      65              : 
      66              : template< class V, class Ctx >
      67              : void
      68          216 : parse_into(
      69              :     V& v,
      70              :     std::istream& is,
      71              :     system::error_code& ec,
      72              :     parse_options const& opt,
      73              :     Ctx const& ctx )
      74              : {
      75          216 :     parser_for<V, Ctx> p(opt, &v, ctx);
      76              : 
      77              :     char read_buffer[BOOST_JSON_STACK_BUFFER_SIZE];
      78              :     do
      79              :     {
      80          429 :         if( is.eof() )
      81              :         {
      82          213 :             p.write_some(false, nullptr, 0, ec);
      83          213 :             break;
      84              :         }
      85              : 
      86          216 :         if( !is )
      87              :         {
      88            1 :             BOOST_JSON_FAIL( ec, error::input_error );
      89            1 :             break;
      90              :         }
      91              : 
      92          215 :         is.read(read_buffer, sizeof(read_buffer));
      93          215 :         std::size_t const consumed = static_cast<std::size_t>( is.gcount() );
      94              : 
      95          215 :         std::size_t const n = p.write_some( true, read_buffer, consumed, ec );
      96          215 :         if( !ec.failed() && n < consumed )
      97              :         {
      98            1 :             BOOST_JSON_FAIL( ec, error::extra_data );
      99              :         }
     100              :     }
     101          215 :     while( !ec.failed() );
     102          216 : }
     103              : 
     104              : template< class V, class Ctx >
     105              : void
     106           71 : parse_into(
     107              :     V& v,
     108              :     std::istream& is,
     109              :     std::error_code& ec,
     110              :     parse_options const& opt,
     111              :     Ctx const& ctx )
     112              : {
     113           71 :     system::error_code jec;
     114           71 :     parse_into(v, is, jec, opt, ctx);
     115           71 :     ec = jec;
     116           71 : }
     117              : 
     118              : template< class V, class Ctx >
     119              : void
     120           72 : parse_into(
     121              :     V& v,
     122              :     std::istream& is,
     123              :     parse_options const& opt,
     124              :     Ctx const& ctx )
     125              : {
     126           72 :     system::error_code ec;
     127           72 :     parse_into(v, is, ec, opt, ctx);
     128           72 :     if( ec.failed() )
     129            1 :         detail::throw_system_error( ec );
     130           71 : }
     131              : 
     132              : } // namespace boost
     133              : } // namespace json
     134              : 
     135              : #endif