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-2020 Lucas Czech and HITS gGmbH

    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@h-its.org>
    Exelixis Lab, Heidelberg Institute for Theoretical Studies
    Schloss-Wolfsbrunnenweg 35, D-69118 Heidelberg, Germany
*/

#include "genesis/utils/io/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