scanner.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_IO_SCANNER_H_
#define GENESIS_UTILS_IO_SCANNER_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2022 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 <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include "genesis/utils/text/char.hpp"
 
#include <cassert>
#include <cctype>
#include <functional>
#include <stdexcept>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Helper Classes and Enums
// =================================================================================================
 
enum class SkipWhitespace : unsigned char
{
    kNone        = 0,
 
    kLeading     = 1,
 
    kTrailing    = 2,
 
    kSurrounding = 3
};
 
inline constexpr bool operator & ( SkipWhitespace lhs, SkipWhitespace rhs ) noexcept
{
    using T = std::underlying_type< SkipWhitespace >::type;
    return static_cast< T >( lhs ) & static_cast< T >( rhs );
}
 
// =================================================================================================
//     Scanners
// =================================================================================================
 
// -------------------------------------------------------------------------
//     end of line
// -------------------------------------------------------------------------
 
template< typename InputStream >
inline void skip_to_end_of_line(
    InputStream& source
) {
    while( source && *source != '\n' ) {
        ++source;
    }
}
 
template< typename InputStream >
inline std::string read_to_end_of_line(
    InputStream&            source
) {
    std::string target;
    while( source && *source != '\n' ) {
        target += *source;
        ++source;
    }
    return target;
}
 
// -------------------------------------------------------------------------
//     skip while
// -------------------------------------------------------------------------
 
template< typename InputStream >
inline void skip_while(
    InputStream&            source,
    char                    criterion
) {
    while( source && *source == criterion ) {
        ++source;
    }
}
 
template< typename InputStream >
inline void skip_while(
    InputStream&               source,
    std::function<bool (char)> criterion
) {
    while( source && criterion( *source )) {
        ++source;
    }
}
 
// -------------------------------------------------------------------------
//     skip until
// -------------------------------------------------------------------------
 
template< typename InputStream >
inline void skip_until(
    InputStream&            source,
    char                    criterion
) {
    while( source && *source != criterion ) {
        ++source;
    }
}
 
template< typename InputStream >
inline void skip_until(
    InputStream&               source,
    std::function<bool (char)> criterion
) {
    while( source && ! criterion( *source )) {
        ++source;
    }
}
 
// -------------------------------------------------------------------------
//     read while
// -------------------------------------------------------------------------
 
template< typename InputStream >
inline std::string read_while(
    InputStream&            source,
    char                    criterion
) {
    std::string target;
    while( source && *source == criterion ) {
        target += *source;
        ++source;
    }
    return target;
}
 
template< typename InputStream >
inline std::string read_while(
    InputStream&               source,
    std::function<bool (char)> criterion
) {
    std::string target;
    while( source && criterion( *source )) {
        target += *source;
        ++source;
    }
    return target;
}
 
// -------------------------------------------------------------------------
//     read until
// -------------------------------------------------------------------------
 
template< typename InputStream >
inline std::string read_until(
    InputStream&            source,
    char                    criterion
) {
    std::string target;
    while( source && *source != criterion ) {
        target += *source;
        ++source;
    }
    return target;
}
 
template< typename InputStream >
inline std::string read_until(
    InputStream&               source,
    std::function<bool (char)> criterion
) {
    std::string target;
    while( source && ! criterion( *source )) {
        target += *source;
        ++source;
    }
    return target;
}
 
// -------------------------------------------------------------------------
//     read char
// -------------------------------------------------------------------------
 
template< typename InputStream >
inline char read_char_or_throw(
    InputStream&               source,
    char                       criterion,
    SkipWhitespace skip_ws = SkipWhitespace::kNone
) {
    // Skip leading whitespace
    if( skip_ws & SkipWhitespace::kLeading ) {
        skip_while( source, ::isspace );
    }
 
    // Check char and move to next.
    if( !source || *source != criterion ) {
        throw std::runtime_error(
            std::string("In ") + source.source_name() + ": " +
            "Expecting " + char_to_hex( criterion ) + " at " + source.at() + ", " +
            "but received " + char_to_hex( *source ) + " instead."
        );
    }
    assert( source && *source == criterion );
    ++source;
 
    // Skip trailing whitespace
    if( skip_ws & SkipWhitespace::kTrailing ) {
        skip_while( source, ::isspace );
    }
 
    return criterion;
}
 
template< typename InputStream >
inline char read_char_or_throw(
    InputStream&               source,
    std::function<bool (char)> criterion,
    SkipWhitespace skip_ws = SkipWhitespace::kNone
) {
    // Skip leading whitespace
    if( skip_ws & SkipWhitespace::kLeading ) {
        skip_while( source, ::isspace );
    }
 
    // Check char and move to next.
    if( !source || ! criterion( *source )) {
        throw std::runtime_error(
            std::string("In ") + source.source_name() + ": " +
            "Unexpected char " + char_to_hex( *source ) + " at " + source.at() + "."
        );
    }
    assert( source );
    auto chr = *source;
    ++source;
 
    // Skip trailing whitespace
    if( skip_ws & SkipWhitespace::kTrailing ) {
        skip_while( source, ::isspace );
    }
 
    return chr;
}
 
// -------------------------------------------------------------------------
//     expect char
// -------------------------------------------------------------------------
 
template< typename InputStream >
inline void affirm_char_or_throw(
    InputStream&            source,
    char                    criterion,
    SkipWhitespace skip_ws = SkipWhitespace::kNone
) {
    // Skip leading whitespace
    if( skip_ws & SkipWhitespace::kLeading ) {
        skip_while( source, ::isspace );
    }
 
    // Check char.
    if( !source || *source != criterion ) {
        throw std::runtime_error(
            std::string("In ") + source.source_name() + ": " +
            "Expecting " + char_to_hex( criterion ) + " at " + source.at() + ", " +
            "but received " + char_to_hex( *source ) + " instead."
        );
    }
 
    // Skip trailing whitespace
    if( skip_ws & SkipWhitespace::kTrailing ) {
        skip_while( source, ::isspace );
    }
}
 
template< typename InputStream >
inline void affirm_char_or_throw(
    InputStream&               source,
    std::function<bool (char)> criterion,
    SkipWhitespace skip_ws = SkipWhitespace::kNone
) {
    // Skip leading whitespace
    if( skip_ws & SkipWhitespace::kLeading ) {
        skip_while( source, ::isspace );
    }
 
    // Check char.
    if( !source || ! criterion( *source )) {
        throw std::runtime_error(
            std::string("In ") + source.source_name() + ": " +
            "Unexpected char " + char_to_hex( *source ) + " at " + source.at() + "."
        );
    }
 
    // Skip trailing whitespace
    if( skip_ws & SkipWhitespace::kTrailing ) {
        skip_while( source, ::isspace );
    }
}
 
} // namespace utils
} // namespace genesis
 
#endif // include guard