istream.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifndef ADOBE_ISTREAM_HPP
#define ADOBE_ISTREAM_HPP
 
#include <adobe/config.hpp>
 
#include <functional>
#include <iosfwd>
#include <memory>
#include <stdexcept>
#include <vector>
 
#include <adobe/istream_fwd.hpp>
#include <adobe/name.hpp>
 
/**************************************************************************************************/
 
namespace adobe {
 
/**************************************************************************************************/
 
#if 0
std::istream& getline(std::istream& is, std::string& str);
#endif
 
/**************************************************************************************************/






 
//***************************************************************************//
//***************************************************************************//
//***************************************************************************//






 
 
// line_position_t is used to remember a position on a particular line of a file.
struct line_position_t {
public:
    typedef std::function<std::string(name_t, std::streampos)> getline_proc_impl_t;
    typedef std::shared_ptr<getline_proc_impl_t> getline_proc_t;
 
    // line_number starts at 1.
    line_position_t(name_t file_path, getline_proc_t getline_proc, int line_number = 1,
                    std::streampos line_start = 0, std::streampos position = -1);
 
    // This constructor is used with __FILE__ and __LINE__, line_number starts at 1
    explicit line_position_t(const char*, int line_number = 1);
 
#if !defined(ADOBE_NO_DOCUMENTATION)
    line_position_t();
#endif // !defined(ADOBE_NO_DOCUMENTATION)
 
    const char* stream_name() const { return file_name_m.c_str(); }
 
    std::string file_snippet() const {
        return getline_proc_m ? (*getline_proc_m)(file_name_m, line_start_m) : std::string();
    }
 
    int line_number_m; // type int to match __LINE__ token
    std::streampos line_start_m;
    std::streampos position_m;
 
#if !defined(ADOBE_NO_DOCUMENTATION)
private:
    name_t file_name_m;
    getline_proc_t getline_proc_m;
#endif // !defined(ADOBE_NO_DOCUMENTATION)
};
 
/**************************************************************************************************/
 
std::ostream& operator<<(std::ostream&, const line_position_t&);
 
/**************************************************************************************************/
 
class stream_error_t : public std::logic_error {
public:
    using position_set_t = std::vector<line_position_t>;
 
    stream_error_t(const std::exception& base, const line_position_t& position)
        : std::logic_error(base.what()) {
        try {
            const stream_error_t* error = dynamic_cast<const stream_error_t*>(&base);
 
            if (error)
                line_position_set_m = error->line_position_set_m;
 
            line_position_set_m.push_back(position);
        } catch (...) {
        }
    }
 
    stream_error_t(const char* what, const line_position_t& position)
        : std::logic_error(what), line_position_set_m(1, position) {}
 
    stream_error_t(const std::string& what, const line_position_t& position)
        : std::logic_error(what), line_position_set_m(1, position) {}
 
    const position_set_t& line_position_set() const { return line_position_set_m; }
 
#if !defined(ADOBE_NO_DOCUMENTATION)
    ~stream_error_t() {}
 
private:
    position_set_t line_position_set_m;
#endif // !defined(ADOBE_NO_DOCUMENTATION)
};
 
 
/**************************************************************************************************/
 
std::ostream& operator<<(std::ostream&, const stream_error_t&);
 
/**************************************************************************************************/
 
/*
    REVISIT (sparent) : I'm not certain this code is correct when used with an istream iterator
    which might do line ending conversions with operator <<. Read up on this.
*/
 
/*
    REVISIT (sparent) : The interface to is_line_end should take an iterator pair and return
    a pair (first, bool) - not work on a reference to first.
*/
 
template <typename I> // I models InputIterator
bool is_line_end(I& first, I last) {
    // Handle any type of line ending.
 
    typename std::iterator_traits<I>::value_type c(*first);
 
    if (c != '\n' && c != '\r')
        return false;
 
    ++first;
 
    if (c == '\r' && first != last && *first == '\n')
        ++first;
 
    return true;
}
 
/**************************************************************************************************/
 
template <typename I> // I models InputIterator
std::size_t is_line_end(I& first, I last, char c) {
    // Handle any type of line ending.
 
    if (c == '\n')
        return 1;
 
    if (c == '\r') {
        if (first != last && *first == '\n') {
            ++first;
 
            return 2;
        }
 
        return 1;
    }
 
    return 0;
}
 
/**************************************************************************************************/
 
template <typename I> // I models InputIterator
std::pair<I, std::string> get_line(I first, I last) {
    std::string result;
 
    while (first != last && !is_line_end(first, last)) {
        result.append(1, *first);
        ++first;
    }
 
    return std::make_pair(first, result);
}
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/