src/butil/string_printf.cpp

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#include <stdio.h>                               // vsnprintf
#include <string.h>                              // strlen
#include "butil/string_printf.h"

namespace butil {

// Copyright 2012 Facebook, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//   http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

namespace {
inline int string_printf_impl(std::string& output, const char* format,
                              va_list args) {
    // Tru to the space at the end of output for our output buffer.
    // Find out write point then inflate its size temporarily to its
    // capacity; we will later shrink it to the size needed to represent
    // the formatted string.  If this buffer isn't large enough, we do a
    // resize and try again.

    const int write_point = output.size();
    int remaining = output.capacity() - write_point;
    output.resize(output.capacity());

    va_list copied_args;
    va_copy(copied_args, args);
    int bytes_used = vsnprintf(&output[write_point], remaining, format,
                               copied_args);
    va_end(copied_args);
    if (bytes_used < 0) {
        return -1;
    } else if (bytes_used < remaining) {
        // There was enough room, just shrink and return.
        output.resize(write_point + bytes_used);
    } else {
        output.resize(write_point + bytes_used + 1);
        remaining = bytes_used + 1;
        bytes_used = vsnprintf(&output[write_point], remaining, format, args);
        if (bytes_used + 1 != remaining) {
            return -1;
        }
        output.resize(write_point + bytes_used);
    }
    return 0;
}

inline int string_printf_impl(std::string& output,  size_t hint,
                              const char* format, va_list args) {
    if (hint > output.capacity()) {
        output.reserve(hint);
    }
    return string_printf_impl(output,  format, args);
}
}  // end anonymous namespace

std::string string_printf(const char* format, ...) {
    // snprintf will tell us how large the output buffer should be, but
    // we then have to call it a second time, which is costly. By
    // guestimating the final size, we avoid the double snprintf in many
    // cases, resulting in a performance win. We use this constructor
    // of std::string to avoid a double allocation, though it does pad
    // the resulting string with nul bytes. Our guestimation is twice
    // the format string size, or 32 bytes, whichever is larger.  This
    // is a heuristic that doesn't affect correctness but attempts to be
    // reasonably fast for the most common cases.
    std::string ret;
    va_list ap;
    va_start(ap, format);
    if (string_printf_impl(ret, std::max(32UL, strlen(format) * 2),
                           format, ap) != 0) {
        ret.clear();
    }
    va_end(ap);
    return ret;
}

std::string string_printf(size_t hint_size, const char* format, ...) {
    // snprintf will tell us how large the output buffer should be, but
    // we then have to call it a second time, which is costly. By
    // passing the hint size of formatted string, we avoid the double
    // snprintf in many cases, resulting in a performance win. We use
    // this constructor  of std::string to avoid a double allocation,
    // though it does pad the resulting string with nul bytes.
    std::string ret;
    va_list ap;
    va_start(ap, format);
    if (string_printf_impl(ret, std::max(hint_size, strlen(format) * 2),
                           format, ap) != 0) {
        ret.clear();
    }
    va_end(ap);
    return ret;
}

// Basic declarations; allow for parameters of strings and string
// pieces to be specified.
int string_appendf(std::string* output, const char* format, ...) {
    va_list ap;
    va_start(ap, format);
    const int rc = string_vappendf(output, format, ap);
    va_end(ap);
    return rc;
}

int string_vappendf(std::string* output, const char* format, va_list args) {
    const size_t old_size = output->size();
    const int rc = string_printf_impl(*output, format, args);
    if (rc != 0) {
        output->resize(old_size);
    }
    return rc;
}

int string_printf(std::string* output, const char* format, ...) {
    va_list ap;
    va_start(ap, format);
    const int rc = string_vprintf(output, format, ap);
    va_end(ap);
    return rc;
};

int string_vprintf(std::string* output, const char* format, va_list args) {
    output->clear();
    const int rc = string_printf_impl(*output, format, args);
    if (rc != 0) {
        output->clear();
    }
    return rc;
};

}  // namespace butil