except.hpp

Go to the documentation of this file.

#ifndef IOF_EXCEPTIONS_H
#define IOF_EXCEPTIONS_H

#include <sstream>
#include <stdexcept>

namespace iof 
{


namespace iof_private
{

/*  Formatted I/O can really benefit from knowing for which arg did the I/O fail. 
    So all std::ios::failure and all error bits (eof, fail, bad) are trapped
    and converted to a iof_private::failure exception that can get caught at the top 
    level and information saved there. Note that iof_private::failure should never 
    escape out of the iof library. 
    */
class failure
{
public:
    enum err_type 
    {
        IO_FAILURE, 
        MARKER_NOT_CLOSED
    };
    
    failure(const char* problem, err_type type = IO_FAILURE)
        : problem(problem), errType(type) {}
    
    const char* const problem;
    const err_type errType;
    
};

}


class except: public std::runtime_error
{
    public:
        except(const std::string& msg): std::runtime_error(msg) {}
};


class marker_not_closed: public iof::except
{
    public:
        marker_not_closed(const iof_private::failure& fail, const std::string& fmt, 
            const std::string& msg): except(msg), 
            start(fail.problem ? fail.problem - fmt.c_str() : -1), fmt(fmt) {}
        
        const size_t start;
        const std::string& fmt;
};


class marker_not_closed_fmt: public marker_not_closed
{
    public:
        marker_not_closed_fmt(const iof_private::failure& fail, const std::string& fmt)
            : marker_not_closed(fail, fmt, "Unclosed format marker") {}
};

class marker_not_closed_skip: public marker_not_closed
{
    public:
        marker_not_closed_skip(const iof_private::failure& fail, const std::string& fmt)
            : marker_not_closed(fail, fmt, "Unclosed skip marker") {}
};


class in_failure: public std::ios::failure
{
    public: 
        in_failure(size_t pos, const std::ios::failure& fail)
            : std::ios::failure(msg(pos, fail)), pos(pos) {}
        
        static std::string msg(size_t pos, const std::ios::failure&) {return msg(pos);}
        
        static std::string msg(size_t pos) 
        {
            std::ostringstream msg;
            msg << "Pos " << (unsigned int)(pos) << " of fmt string caused input exception";
            return msg.str();
        }
        
        const size_t pos;
        
};


class too_many_markers: public iof::except
{
    public: 
        too_many_markers(size_t pos, const char* fmt)
            : except(msg(pos, fmt)), pos(pos) {}
        
        static std::string msg(size_t pos, const char* fmt) 
        {
            std::ostringstream msg;
            msg << "Too many format markers, starting at pos " 
                << (unsigned int)(pos) << " of '" << fmt << "'";
            return msg.str();
        }
        
        const size_t pos;
};


class fmt_no_effect: public iof::except
{
    public: 
        static inline int getPos(const char* next, const char* fmt) {return next ? int(next - fmt): -1;}
        
        fmt_no_effect(const char* next, const char* fmt)
            : except(msg(getPos(next, fmt), fmt)), pos(getPos(next, fmt)) {}
        
        static std::string msg(int pos, const char* fmt) 
        {
            std::ostringstream msg;
            std::ostringstream posStr; 
            if (pos >= 0) posStr << "pos " << pos;
            else posStr << "end"; 
            msg << "fmt_spec obj used at " << posStr.str() << " of '" << fmt 
                << "' needs to be persistent to have an effect";
            return msg.str();
        }
        
        const size_t pos;
};


} // namespace 

#endif // IOF_EXCEPTIONS_H

---

Thanks to for hosting