work around about gzip file input

[shuizaiku7]

Hi, I'm reading in some big gzip file.
I've got some lib to read in the gzip as input stream, but the input stream class is not derived from std::istream.
It's some class the lib defined on its own, but the gzstrem class do implement api like read/gcount/eof.
So my work around is to implement gzstream_reader which is just like the internal::istream_reader,
and then implement the gzstream_input as istream_input do.
My question is
01.Is my work around ok?
02.What does this code do?
I'm sorry it's a C++ problem, but it's hard for me to search this code on the internet.
Really appreciated if you can give me an explanation.

template< typename... Ts >
   istream_input( Ts&&... ) -> istream_input<>;

[ColinH]

2. It's a user-defined deduction guide, see https://en.cppreference.com/w/cpp/language/class_template_argument_deduction for more.

[shuizaiku7]

Thanks for your help.

[ColinH]

1. Sounds reasonable, can you post the code?

[shuizaiku7]

sure

This is the code for gzstream_input

struct gzstream_reader
{
    explicit gzstream_reader( xxx_gzstream& s ) noexcept
        : m_xxx_gzstream( s )
    {}

    [[nodiscard]] std::size_t operator()( char* buffer, const std::size_t length )
    {
        m_xxx_gzstream.read( buffer, std::streamsize( length ) );

        if( const auto r = m_xxx_gzstream.gcount() ) {
            return std::size_t( r );
        }
        if( m_xxx_gzstream.eof() ) {
            return 0;
        }
#if defined( __cpp_exceptions )
        const auto ec = errno;
        throw std::system_error( ec, std::system_category(), "xxx_gzstream::read() failed" );
#else
        std::fputs( "xxx_gzstream::read() failed\n", stderr );
        std::terminate();
#endif
    }

    xxx_gzstream& m_xxx_gzstream;
};

template< typename Eol = pegtl::ascii::eol::lf_crlf, std::size_t Chunk = 64 >
struct gzstream_input
    : pegtl::buffer_input< gzstream_reader, Eol, std::string, Chunk >
{
    template< typename T >
    gzstream_input( verific_gzstream& in_stream, const std::size_t in_maximum, T&& in_source )
        : pegtl::buffer_input< gzstream_reader, Eol, std::string, Chunk >( std::forward< T >( in_source ), in_maximum, in_stream )
    {}
};

template< typename... Ts >
gzstream_input( Ts&&... ) -> gzstream_input<>;

and this is my code for using it.

auto* gzstreamInput = get_xxx_gzstream(path);
gzstream_input in(*gzstreamInput, bufLen, path);
pegtl::parse<my::grammar, my::action>(in, other states);

and i will add some pegtl::discard in my rule.

[ColinH]

Looks reasonable, too (assuming that in production code gzStreamInput is a std::unique_ptr or similar instead of a plain pointer.)

Withgzstream being so similar to std::istream it might make sense to template the istream_reader over the stream type. One more template won't do any harm :-)