View source for Template:cpp/io/manip/iomanip return value

An object of unspecified type such that
{{#switch: {{{1|}}}|get_money=|get_time=|
* if {{c|out}} is an object of type {{c|std::basic_ostream<CharT, Traits>}}, the expression {{#switch: {{{1|}}}
|resetiosflags={{c|out << resetiosflags(mask)}}
|setiosflags={{c|out << setiosflags(mask)}}
|setbase={{c|out << setbase(base)}}
|setfill={{c|out << setfill(c)}}
|setprecision={{c|out << setprecision(n)}}
|setw={{c|out << setw(n)}}
|put_money={{c|out << put_money(mon, intl)}}
|put_time={{c|out << put_time(tmb, fmt)}}
|{{templated}}}}
** has type {{c|std::basic_ostream<CharT, Traits>&}}
** has value {{c|out}}
{{#switch: {{{1|}}}
|put_money=** behaves as a {{named req|FormattedOutputFunction}} that calls {{c|f(out, mon, intl)}}
|** behaves as if it called {{#switch: {{{1|}}}
|resetiosflags={{c|f(out, mask)}}
|setiosflags={{c|f(out, mask)}}
|setbase={{c|f(out, base)}}
|setfill={{c|f(out, c)}}
|setprecision={{c|f(out, n)}}
|setw={{c|f(out, n)}}
|put_time={{c|f(out, tmb, fmt)}}
|{{templated}}}}
}}
}}
{{#switch: {{{1|}}}|setfill=|put_money=|put_time=|
* if {{c|in}} is an object of type {{c|std::basic_istream<CharT, Traits>}}, the expression {{#switch: {{{1|}}}
|resetiosflags={{c|in >> resetiosflags(mask)}}
|setiosflags={{c|in >> setiosflags(mask)}}
|setbase={{c|in >> setbase(base)}}
|setprecision={{c|in >> setprecision(n)}}
|setw={{c|in >> setw(n)}}
|get_money={{c|in >> get_money(mon, intl)}}
|get_time={{c|in >> get_time(tmb, fmt)}}
|{{templated}}}}
** has type {{c|std::basic_istream<CharT, Traits>&}}
** has value {{c|in}}
** behaves as if it called {{#switch: {{{1|}}}
|resetiosflags={{c|f(in, mask)}}
|setiosflags={{c|f(in, mask)}}
|setbase={{c|f(in, base)}}
|setprecision={{c|f(in, n)}}
|setw={{c|f(in, n)}}
|get_money={{c|f(in, mon, intl)}}
|get_time={{c|f(in, tmb, fmt)}}
|{{templated}}}}
}}
where the function {{c|f}} is defined as:
{{#switch: {{{1|}}}
|resetiosflags=
{{source|
void f(std::ios_base& str, std::ios_base::fmtflags mask)
{
    // reset specified flags
    str.setf(ios_base::fmtflags(0), mask);
}
}}
|setiosflags=
{{source|
void f(std::ios_base& str, std::ios_base::fmtflags mask)
{
    // set specified flags
    str.setf(mask);
}
}}
|setbase=
{{source|1=
void f(std::ios_base& str, int base)
{
    // set basefield
    str.setf(base == 8 ? std::ios_base::oct :
        base == 10 ? std::ios_base::dec :
        base == 16 ? std::ios_base::hex :
        std::ios_base::fmtflags(0), std::ios_base::basefield);
}
}}
|setfill=
{{source|
template<class CharT, class Traits>
void f(std::basic_ios<CharT, Traits>& str, CharT c)
{
    // set fill character
    str.fill(c);
}
}}
|setprecision=
{{source|
void f(std::ios_base& str, int n)
{
    // set precision
    str.precision(n);
}
}}
|setw=
{{source|
void f(std::ios_base& str, int n)
{
    // set width
    str.width(n);
}
}}
|get_money=
{{source|1=
template<class CharT, class Traits, class MoneyT>
void f(std::basic_ios<CharT, Traits>& str, MoneyT& mon, bool intl)
{
    using Iter = std::istreambuf_iterator<CharT, Traits>;
    using MoneyGet = std::money_get<CharT, Iter>;
    
    std::ios_base::iostate err = std::ios_base::goodbit;
    const MoneyGet& mg = std::use_facet<MoneyGet>(str.getloc());
    
    mg.get(Iter(str.rdbuf()), Iter(), intl, str, err, mon);
    
    if (err != std::ios_base::goodbit)
        str.setstate(err);
}
}}
|put_money=
{{source|1=
template<class CharT, class Traits, class MoneyT>
void f(std::basic_ios<CharT, Traits>& str, const MoneyT& mon, bool intl)
{
    using Iter = std::ostreambuf_iterator<CharT, Traits>;
    using MoneyPut = std::money_put<CharT, Iter>;
    
    const MoneyPut& mp = std::use_facet<MoneyPut>(str.getloc());
    const Iter end = mp.put(Iter(str.rdbuf()), intl, str, str.fill(), mon);
    
    if (end.failed())
        str.setstate(std::ios_base::badbit);
}
}}
|get_time=
{{source|1=
template<class CharT, class Traits>
void f(std::basic_ios<CharT, Traits>& str, std::tm* tmb, const CharT* fmt)
{
    using Iter = std::istreambuf_iterator<CharT, Traits>;
    using TimeGet = time_get<CharT, Iter>;
    
    std::ios_base::iostate err = std::ios_base::goodbit;
    const TimeGet& tg = std::use_facet<TimeGet>(str.getloc());
    
    tg.get(Iter(str.rdbuf()), Iter(), str, err, tmb,
        fmt, fmt + Traits::length(fmt));
    
    if (err != std::ios_base::goodbit)
        str.setstate(err);
}
}}
|put_time=
{{source|1=
template<class CharT, class Traits>
void f(std::basic_ios<CharT, Traits>& str, const std::tm* tmb, const CharT* fmt)
{
    using Iter = std::ostreambuf_iterator<CharT, Traits>;
    using TimePut = std::time_put<CharT, Iter>;
    
    const TimePut& tp = std::use_facet<TimePut>(str.getloc());
    const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
        fmt, fmt + Traits::length(fmt));
    
    if (end.failed())
        str.setstate(std::ios_base::badbit);
}
}}
|{{templated}}
}}