LCOV - code coverage report
Current view: top level - boost/http_proto/file_stdio.hpp (source / functions) Coverage Total Hit
Test: coverage_filtered.info Lines: 100.0 % 4 4
Test Date: 2024-07-12 15:42:45 Functions: 100.0 % 2 2

            Line data    Source code
       1              : //
       2              : // Copyright (c) 2022 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_FILE_STDIO_HPP
      11              : #define BOOST_HTTP_PROTO_FILE_STDIO_HPP
      12              : 
      13              : #include <boost/http_proto/detail/config.hpp>
      14              : #include <boost/http_proto/error.hpp>
      15              : #include <boost/http_proto/file_base.hpp>
      16              : #include <cstdio>
      17              : #include <cstdint>
      18              : 
      19              : namespace boost {
      20              : namespace http_proto {
      21              : 
      22              : /** An implementation of File which uses cstdio.
      23              : 
      24              :     This class implements a file using the interfaces present
      25              :     in the C++ Standard Library, in `<stdio>`.
      26              : */
      27              : class file_stdio
      28              : {
      29              :     std::FILE* f_ = nullptr;
      30              : 
      31              : public:
      32              :     /** The type of the underlying file handle.
      33              : 
      34              :         This is platform-specific.
      35              :     */
      36              :     using native_handle_type = std::FILE*;
      37              : 
      38              :     /** Destructor
      39              : 
      40              :         If the file is open it is first closed.
      41              :     */
      42              :     BOOST_HTTP_PROTO_DECL
      43              :     ~file_stdio();
      44              : 
      45              :     /** Constructor
      46              : 
      47              :         There is no open file initially.
      48              :     */
      49              :     file_stdio() = default;
      50              : 
      51              :     /** Constructor
      52              : 
      53              :         The moved-from object behaves as if default constructed.
      54              :     */
      55              :     BOOST_HTTP_PROTO_DECL
      56              :     file_stdio(
      57              :         file_stdio&& other) noexcept;
      58              : 
      59              :     /** Assignment
      60              : 
      61              :         The moved-from object behaves as if default constructed.
      62              :     */
      63              :     BOOST_HTTP_PROTO_DECL
      64              :     file_stdio&
      65              :     operator=(
      66              :         file_stdio&& other) noexcept;
      67              : 
      68              :     /// Returns the native handle associated with the file.
      69              :     std::FILE*
      70            2 :     native_handle() const
      71              :     {
      72            2 :         return f_;
      73              :     }
      74              : 
      75              :     /** Set the native handle associated with the file.
      76              : 
      77              :         If the file is open it is first closed.
      78              : 
      79              :         @param f The native file handle to assign.
      80              :     */
      81              :     BOOST_HTTP_PROTO_DECL
      82              :     void
      83              :     native_handle(std::FILE* f);
      84              : 
      85              :     /// Returns `true` if the file is open
      86              :     bool
      87           10 :     is_open() const
      88              :     {
      89           10 :         return f_ != nullptr;
      90              :     }
      91              : 
      92              :     /** Close the file if open
      93              : 
      94              :         @param ec Set to the error, if any occurred.
      95              :     */
      96              :     BOOST_HTTP_PROTO_DECL
      97              :     void
      98              :     close(system::error_code& ec);
      99              : 
     100              :     /** Open a file at the given path with the specified mode
     101              : 
     102              :         @param path The utf-8 encoded path to the file
     103              : 
     104              :         @param mode The file mode to use
     105              : 
     106              :         @param ec Set to the error, if any occurred
     107              :     */
     108              :     BOOST_HTTP_PROTO_DECL
     109              :     void
     110              :     open(char const* path, file_mode mode, system::error_code& ec);
     111              : 
     112              :     /** Return the size of the open file
     113              : 
     114              :         @param ec Set to the error, if any occurred
     115              : 
     116              :         @return The size in bytes
     117              :     */
     118              :     BOOST_HTTP_PROTO_DECL
     119              :     std::uint64_t
     120              :     size(system::error_code& ec) const;
     121              : 
     122              :     /** Return the current position in the open file
     123              : 
     124              :         @param ec Set to the error, if any occurred
     125              : 
     126              :         @return The offset in bytes from the beginning of the file
     127              :     */
     128              :     BOOST_HTTP_PROTO_DECL
     129              :     std::uint64_t
     130              :     pos(system::error_code& ec) const;
     131              : 
     132              :     /** Adjust the current position in the open file
     133              : 
     134              :         @param offset The offset in bytes from the beginning of the file
     135              : 
     136              :         @param ec Set to the error, if any occurred
     137              :     */
     138              :     BOOST_HTTP_PROTO_DECL
     139              :     void
     140              :     seek(std::uint64_t offset, system::error_code& ec);
     141              : 
     142              :     /** Read from the open file
     143              : 
     144              :         @param buffer The buffer for storing the result of the read
     145              : 
     146              :         @param n The number of bytes to read
     147              : 
     148              :         @param ec Set to the error, if any occurred
     149              :     */
     150              :     BOOST_HTTP_PROTO_DECL
     151              :     std::size_t
     152              :     read(void* buffer, std::size_t n, system::error_code& ec) const;
     153              : 
     154              :     /** Write to the open file
     155              : 
     156              :         @param buffer The buffer holding the data to write
     157              : 
     158              :         @param n The number of bytes to write
     159              : 
     160              :         @param ec Set to the error, if any occurred
     161              :     */
     162              :     BOOST_HTTP_PROTO_DECL
     163              :     std::size_t
     164              :     write(void const* buffer, std::size_t n, system::error_code& ec);
     165              : };
     166              : 
     167              : } // http_proto
     168              : } // boost
     169              : 
     170              : #endif
        

Generated by: LCOV version 2.1