fmt_spec.hpp

Go to the documentation of this file.

#ifndef IOF_FMT_SPEC_HPP_
#define IOF_FMT_SPEC_HPP_

#include "iof/process_fmt_in.hpp"
#include "iof/process_fmt_out.hpp"
#include "iof/stream_fmt.hpp"


namespace iof 
{
    

namespace iof_private
{

    
template <typename TT>
class formatted
{
public:
    const std::string fmt;
    const TT& obj; 

    formatted(const std::string& fmt, const TT& obj): fmt(fmt), obj(obj) {}
    inline void applyTo(std::ostream&, fmt_extensions& fmtExtensions) const;
    
private:
};

} // namespace iof_private


class fmt_spec
{
    public:
        fmt_spec() {}
        fmt_spec(const std::string& fmt): my_fmt(fmt) {}
        void operator=(const std::string& fmt) {my_fmt = fmt;}
        
        bool operator==(const std::string& fmt) const {return my_fmt == fmt;}
        bool operator==(const fmt_spec& rhs) const { return rhs.my_fmt == my_fmt; }
        bool operator!=(const fmt_spec& rhs) const { return ! (*this == rhs); }
        
        const std::string& str() const {return my_fmt;}
        
        template <typename TT> 
        iof_private::formatted<TT> operator()(const TT& obj) const 
        {
            return iof_private::formatted<TT>(my_fmt, obj);
        }

    private:
        std::string my_fmt;
};


inline std::ostream& 
operator<<(std::ostream& out, const fmt_spec& fmt)
{
    bool restore; // not used
    iof_private::fmt_extensions fmtExtensions;
    iof_private::process1FmtSpec(out, fmt.str().c_str(), fmtExtensions, restore, false);
    if (fmtExtensions.extensionsUsed()) 
        throw std::runtime_error(
        "Formatting extensions (centering, ...) not supported without iof::fmtr");
    return out;
}


inline std::istream& 
operator>>(std::istream& in, const fmt_spec& fmt)
{
    bool restore; // not used
    char delim = 0; // not used
    iof_private::process1FmtSpec(in, fmt.str().c_str(), restore, delim, false);
    return in;
}



template <typename TT> 
inline void 
iof_private::formatted<TT>::applyTo(std::ostream& out, fmt_extensions& fmtExtensions)
const
{
    bool restore; // not used
    iof_private::process1FmtSpec(out, fmt.c_str(), fmtExtensions, restore, false);
    outputAdvanced(obj, out, fmtExtensions);
}


template <typename TT>
inline std::ostream& 
operator<<(std::ostream& out, const iof_private::formatted<TT>& fmtdObj)
{
    iof_private::fmt_extensions fmtExtensions;
    fmtdObj.applyTo(out, fmtExtensions);
    if (fmtExtensions.extensionsUsed()) 
        throw std::runtime_error(
        "Formatting extensions (centering, ...) not supported without iof::fmtr");
    return out;
}


} // namespace iof

#endif // IOF_FMT_SPEC_HPP_

---

Thanks to for hosting