input_stream.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_IO_INPUT_STREAM_H_
#define GENESIS_UTILS_IO_INPUT_STREAM_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2024 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@sund.ku.dk>
    University of Copenhagen, Globe Institute, Section for GeoGenetics
    Oster Voldgade 5-7, 1350 Copenhagen K, Denmark
*/
 
#include "genesis/utils/core/std.hpp"
#include "genesis/utils/io/input_reader.hpp"
#include "genesis/utils/io/input_source.hpp"
#include "genesis/utils/text/char.hpp"
 
#include <array>
#include <cassert>
#include <cstdint>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
 
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
 
    #include <string_view>
 
#endif // ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Input Stream
// =================================================================================================
 
class InputStream
{
public:
 
    // -------------------------------------------------------------------------
    //     Member Types
    // -------------------------------------------------------------------------
 
    static const size_t BlockLength = 1 << 22;
 
    using self_type         = InputStream;
    using value_type        = char;
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    InputStream()
        : source_name_( "invalid source" )
        , buffer_(   nullptr )
        , data_pos_( 0 )
        , data_end_( 0 )
        , current_( '\0' )
        , line_(     0 )
        , column_(   0 )
    {}
 
    explicit InputStream( std::shared_ptr<BaseInputSource> input_source )
        : line_(   1 )
        , column_( 1 )
    {
        init_( input_source );
    }
 
    ~InputStream()
    {
        delete[] buffer_;
        buffer_ = nullptr;
    }
 
    InputStream( self_type const& ) = delete;
    InputStream( self_type&& other )
        : buffer_( nullptr )
    {
        *this = std::move( other );
    }
 
    self_type& operator= ( self_type const& ) = delete;
    self_type& operator= ( self_type&& other );
 
    // -------------------------------------------------------------------------
    //     Stream Iterator Operations
    // -------------------------------------------------------------------------
 
    inline char operator* () const
    {
        return current_;
    }
 
    inline char current() const
    {
        if( data_pos_ >= data_end_ ) GENESIS_UNLIKELY {
            throw std::runtime_error(
                "Unexpected end of " + source_name() + " at " + at() + "."
            );
        }
        if( current_ < 0 ) GENESIS_UNLIKELY {
            throw std::domain_error(
                "Invalid input char in " + source_name() + " at " + at() + "."
            );
        }
        return current_;
    }
 
    inline self_type& advance()
    {
        operator++();
        return *this;
    }
 
    inline self_type& operator ++ ()
    {
        // If we were already at the end, set counter so zero.
        if( data_pos_ >= data_end_ ) GENESIS_UNLIKELY {
            reset_();
            return *this;
        }
 
        // Read data if necessary.
        if( data_pos_ >= BlockLength ) GENESIS_UNLIKELY {
            update_blocks_();
        }
        assert( data_pos_ < BlockLength );
 
        // In case we are moving to a new line, set the counters accordingly.
        if( current_ == '\n' ) {
            ++line_;
            column_ = 1;
        } else {
            ++column_;
        }
 
        // Next position.
        ++data_pos_;
 
        // Set the char.
        set_current_char_();
        return *this;
    }
 
    inline char get_char()
    {
        char ret = current_;
        operator++();
        return ret;
    }
 
    // -------------------------------------------------------------------------
    //     Char Operations
    // -------------------------------------------------------------------------
 
    char read_char_or_throw( char const criterion );
 
 
    char read_char_or_throw( std::function<bool (char)> criterion );
 
    // -------------------------------------------------------------------------
    //     Line Operations
    // -------------------------------------------------------------------------
 
    void get_line( std::string& target );
 
    std::string get_line()
    {
        std::string result;
        get_line( result );
        return result;
    }
 
    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
 
    std::string_view get_line_view();
 
    template<size_t N>
    std::array<std::string_view, N> get_line_views()
    {
        // We relay the work to a non-template inner function, to keep this header clean.
        std::array<std::string_view, N> result;
        fill_line_views_( result.data(), result.size() );
        return result;
    }
 
private:
 
    // Internal helper that does the actual work of the get_line_views() function.
    void fill_line_views_( std::string_view* str_views, size_t n_lines );
 
    #endif // ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
 
private:
 
    // Internal functions for the line operations.
    size_t update_and_move_to_line_or_buffer_end_();
    void move_to_line_or_buffer_end_( size_t const stop_pos );
    void approach_line_or_buffer_end_avx512_( size_t const stop_pos );
    void approach_line_or_buffer_end_avx2_( size_t const stop_pos );
    void approach_line_or_buffer_end_unrolled_( size_t const stop_pos );
    void increment_to_next_line_();
 
public:
 
    // -------------------------------------------------------------------------
    //     Buffer Access
    // -------------------------------------------------------------------------
 
    std::pair<char const*, size_t> buffer()
    {
        assert( data_pos_ <= data_end_ );
        return { &buffer_[ data_pos_ ], data_end_ - data_pos_ };
    }
 
    void jump_unchecked( size_t n );
 
    // -------------------------------------------------------------------------
    //     State
    // -------------------------------------------------------------------------
 
    size_t line() const
    {
        return line_;
    }
 
    size_t column() const
    {
        return column_;
    }
 
    std::string at() const
    {
        return std::to_string( line_ ) + ":" + std::to_string( column_ );
    }
 
    inline bool good() const
    {
        return data_pos_ < data_end_;
    }
 
    inline explicit operator bool() const
    {
        return data_pos_ < data_end_;
    }
 
    inline bool eof() const
    {
        return data_pos_ >= data_end_;
    }
 
    std::string source_name() const
    {
        return source_name_;
    }
 
    // -------------------------------------------------------------------------
    //     Internal Members
    // -------------------------------------------------------------------------
 
private:
 
    void init_( std::shared_ptr<BaseInputSource> input_source );
 
    void reset_()
    {
        line_    = 0;
        column_  = 0;
        current_ = '\0';
    }
 
    void update_blocks_();
 
    void set_current_char_();
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    // Input data comes from here...
    // (we use a unique ptr to make the class movable)
    std::unique_ptr<InputReader> input_reader_ = nullptr;
    std::string source_name_;
 
    // ...and is buffered here.
    char*  buffer_;
    size_t data_pos_;
    size_t data_end_;
 
    // Also, keep track of the current char and position in the data.
    char   current_;
    size_t line_;
    size_t column_;
};
 
} // namespace utils
} // namespace genesis
 
#endif // include guard