C++ basic_ostream::getloc方法代码示例

    void write_json_helper(std::basic_ostream<typename Ptree::char_type> &stream, 
                           const Ptree &pt, 
                           int indent)
    {

        typedef typename Ptree::char_type Ch;
        typedef typename std::basic_string<Ch> Str;
        
        // Value or object or array
        if (indent > 0 && pt.empty())
        {
            
            // Write value
            Str data = create_escapes(pt.template get_own<Str>(), stream.getloc());
            stream << Ch('"') << data << Ch('"');

        }
        else if (indent > 0 && pt.count(Str()) == pt.size())
        {
                
            // Write array
            stream << Ch('[') << Ch('\n');
            typename Ptree::const_iterator it = pt.begin();
            for (; it != pt.end(); ++it)
            {
                stream << Str(4 * (indent + 1), Ch(' '));
                write_json_helper(stream, it->second, indent + 1);
                if (boost::next(it) != pt.end())
                    stream << Ch(',');
                stream << Ch('\n');
            }
            stream << Str(4 * indent, Ch(' ')) << Ch(']');

        }
        else
        {
        
            // Write object
            stream << Ch('{') << Ch('\n');
            typename Ptree::const_iterator it = pt.begin();
            for (; it != pt.end(); ++it)
            {
                stream << Str(4 * (indent + 1), Ch(' '));
                stream << Ch('"') << create_escapes(it->first, stream.getloc()) << Ch('"') << Ch(':');
                if (it->second.empty())
                    stream << Ch(' ');
                else
                    stream << Ch('\n') << Str(4 * (indent + 1), Ch(' '));
                write_json_helper(stream, it->second, indent + 1);
                if (boost::next(it) != pt.end())
                    stream << Ch(',');
                stream << Ch('\n');
            }
            stream << Str(4 * indent, Ch(' ')) << Ch('}');

        }

    }

 ///
 /// Translate message and write to stream \a out, using imbued locale and domain set to the 
 /// stream
 ///
 void write(std::basic_ostream<char_type> &out) const
 {
     std::locale const &loc = out.getloc();
     int id = ios_info::get(out).domain_id();
     string_type buffer;
     out << write(loc,id,buffer);
 }

inline void fprint(std::basic_ostream<Char, Trait>& out, const Char* str, Args&&... arguments) {
    // %[parameter][flags][width][.precision]verb
    // if it's *n$ instead of %n$ then it'll use the specific parameter number
    // n starts at 1 to sizeof...(Args)
    // at the moment I'm too lazy to do * at all.
    auto&& args = std::make_tuple(std::forward<Args>(arguments)...);
    stream_state<Char, Trait> original{out};
    stream_state<Char, Trait> changed;
    printer<Char, Trait> func(out);
    const Char percent = out.widen('%');
    const Char zero    = out.widen('0');
    auto&& loc = out.getloc();
    size_t index = 0;
    size_t position = 0;
    bool has_positional = false;

    while(*str != 0) {
        // not a %
        if(!Trait::eq(*str, percent)) {
            out << *str++;
            continue;
        }

        // at this point -- *str == '%'
        // so just increment it to get to the format-spec
        ++str;

        // escaped %
        if(*str && Trait::eq(*str, percent)) {
            out << percent;
            ++str;
            continue;
        }

        // beginning of format-spec
        changed = original;

        // check for [parameter], i.e. n$
        // or a numeric value for [width]
        position = parse_integer(str, zero, loc);

        // check if it's [parameter] rather than [width]
        if(Trait::eq(*str, out.widen('$'))) {
            has_positional = true;
            ++str;
        }

        // check for [flags]
        // they are as follows:
        // +       - equivalent to std::showpos
        // -       - left aligns instead of right align, i.e. std::left
        // 0       - pad with 0s instead of spaces
        // '[char] - pad with [char] instead of spaces
        while(*str) {
            if(Trait::eq(*str, out.widen('+'))) {
                changed.flags |= out.showpos;
            }
            else if(Trait::eq(*str, out.widen('-'))) {
                changed.flags |= out.left;
            }
            else if(Trait::eq(*str, out.widen('0'))) {
                changed.fill = out.widen('0');
            }
            else if(Trait::eq(*str, out.widen('\''))) {
                // the next character is unconditionally the fill character
                changed.fill = *(++str);
            }
            else {
                // unknown flag, so just exit
                break;
            }
            ++str;
        }

        // check for [width]
        changed.width = parse_integer(str, zero, loc);

        // check for [precision]
        if(Trait::eq(*str, out.widen('.'))) {
            changed.precision = parse_integer(++str, zero, loc);
        }


        size_t final_index = has_positional ? position - 1 : index++;

        // check for verb
        if(Trait::eq(*str, out.widen('s')) || Trait::eq(*str, out.widen('c'))) {
            // do nothing since these don't add any extra format specifiers.
            // many of these are provided as a thin compatibility layer for
            // the original printf -- albeit strict compatibility is not a requirement here.
        }
        else if(Trait::eq(*str, out.widen('f')) || Trait::eq(*str, out.widen('F'))) {
            changed.flags |= out.fixed;
        }
        else if(Trait::eq(*str, out.widen('e'))) {
            changed.flags |= out.scientific;
        }
        else if(Trait::eq(*str, out.widen('E'))) {
            changed.flags |= out.scientific;
            changed.flags |= out.uppercase;
//.........这里部分代码省略.........