YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// Copyright 2008 and onwards Google Inc.  All rights reserved.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, 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.

//

#include "yb/gutil/strings/strcat.h"

#include <stdarg.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <glog/logging.h>

#include "yb/gutil/stl_util.h"

AlphaNum gEmptyAlphaNum("");

// ----------------------------------------------------------------------

// StrCat()

//    This merges the given strings or integers, with no delimiter.  This

//    is designed to be the fastest possible way to construct a string out

//    of a mix of raw C strings, GStringPieces, strings, and integer values.

// ----------------------------------------------------------------------

// Append is merely a version of memcpy that returns the address of the byte

// after the area just overwritten.  It comes in multiple flavors to minimize

// call overhead.

static char *Append1(char *out, const AlphaNum &x) {

  memcpy(out, x.data(), x.size());

  return out + x.size();

}

static char *Append2(char *out, const AlphaNum &x1, const AlphaNum &x2) {

  memcpy(out, x1.data(), x1.size());

  out += x1.size();

  memcpy(out, x2.data(), x2.size());

  return out + x2.size();

}

static char *Append4(char *out,

                     const AlphaNum &x1, const AlphaNum &x2,

                     const AlphaNum &x3, const AlphaNum &x4) {

  memcpy(out, x1.data(), x1.size());

  out += x1.size();

  memcpy(out, x2.data(), x2.size());

  out += x2.size();

  memcpy(out, x3.data(), x3.size());

  out += x3.size();

  memcpy(out, x4.data(), x4.size());

  return out + x4.size();

}

string StrCat(const AlphaNum &a) {

  return string(a.data(), a.size());

}

string StrCat(const AlphaNum &a, const AlphaNum &b) {

  string result;

  STLStringResizeUninitialized(&result, a.size() + b.size());

  char *const begin = &*result.begin();

  char *out = Append2(begin, a, b);

  DCHECK_EQ(out, begin + result.size());

  return result;

}

string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c) {

  string result;

  STLStringResizeUninitialized(&result, a.size() + b.size() + c.size());

  char *const begin = &*result.begin();

  char *out = Append2(begin, a, b);

  out = Append1(out, c);

  DCHECK_EQ(out, begin + result.size());

  return result;

}

string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,

              const AlphaNum &d) {

  string result;

  STLStringResizeUninitialized(&result,

                               a.size() + b.size() + c.size() + d.size());

  char *const begin = &*result.begin();

  char *out = Append4(begin, a, b, c, d);

  DCHECK_EQ(out, begin + result.size());

  return result;

}

string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,

              const AlphaNum &d, const AlphaNum &e) {

  string result;

  STLStringResizeUninitialized(&result,

      a.size() + b.size() + c.size() + d.size() + e.size());

  char *const begin = &*result.begin();

  char *out = Append4(begin, a, b, c, d);

  out = Append1(out, e);

  DCHECK_EQ(out, begin + result.size());

  return result;

}

string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,

              const AlphaNum &d, const AlphaNum &e, const AlphaNum &f) {

  string result;

  STLStringResizeUninitialized(&result,

      a.size() + b.size() + c.size() + d.size() + e.size() + f.size());

  char *const begin = &*result.begin();

  char *out = Append4(begin, a, b, c, d);

  out = Append2(out, e, f);

  DCHECK_EQ(out, begin + result.size());

  return result;

}

string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,

              const AlphaNum &d, const AlphaNum &e, const AlphaNum &f,

              const AlphaNum &g) {

  string result;

  STLStringResizeUninitialized(&result,

      a.size() + b.size() + c.size() + d.size() + e.size()

               + f.size() + g.size());

  char *const begin = &*result.begin();

  char *out = Append4(begin, a, b, c, d);

  out = Append2(out, e, f);

  out = Append1(out, g);

  DCHECK_EQ(out, begin + result.size());

  return result;

}

string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,

              const AlphaNum &d, const AlphaNum &e, const AlphaNum &f,

              const AlphaNum &g, const AlphaNum &h) {

  string result;

  STLStringResizeUninitialized(&result,

      a.size() + b.size() + c.size() + d.size() + e.size()

               + f.size() + g.size() + h.size());

  char *const begin = &*result.begin();

  char *out = Append4(begin, a, b, c, d);

  out = Append4(out, e, f, g, h);

  DCHECK_EQ(out, begin + result.size());

  return result;

}

namespace strings {

namespace internal {

// StrCat with this many params is exceedingly rare, but it has been

// requested...  therefore we'll rely on default arguments to make calling

// slightly less efficient, to preserve code size.

string StrCatNineOrMore(const AlphaNum *a, ...) {

  string result;

  va_list args;

  va_start(args, a);

  size_t size = a->size();

  while (const AlphaNum *arg = va_arg(args, const AlphaNum *)) {

    size += arg->size();

  }

  STLStringResizeUninitialized(&result, size);

  va_end(args);

  va_start(args, a);

  char *const begin = &*result.begin();

  char *out = Append1(begin, *a);

  while (const AlphaNum *arg = va_arg(args, const AlphaNum *)) {

    out = Append1(out, *arg);

  }

  va_end(args);

  DCHECK_EQ(out, begin + size);

  return result;

}

}  // namespace internal

}  // namespace strings

// It's possible to call StrAppend with a GStringPiece that is itself a fragment

// of the string we're appending to.  However the results of this are random.

// Therefore, check for this in debug mode.  Use unsigned math so we only have

// to do one comparison.

#define DCHECK_NO_OVERLAP(dest, src) \

    DCHECK_GT(uintptr_t((src).data() - (dest).data()), uintptr_t((dest).size()))

void StrAppend(string *result, const AlphaNum &a) {

  DCHECK_NO_OVERLAP(*result, a);

  result->append(a.data(), a.size());

}

void StrAppend(string *result, const AlphaNum &a, const AlphaNum &b) {

  DCHECK_NO_OVERLAP(*result, a);

  DCHECK_NO_OVERLAP(*result, b);

  string::size_type old_size = result->size();

  STLStringResizeUninitialized(result, old_size + a.size() + b.size());

  char *const begin = &*result->begin();

  char *out = Append2(begin + old_size, a, b);

  DCHECK_EQ(out, begin + result->size());

}

void StrAppend(string *result,

               const AlphaNum &a, const AlphaNum &b, const AlphaNum &c) {

  DCHECK_NO_OVERLAP(*result, a);

  DCHECK_NO_OVERLAP(*result, b);

  DCHECK_NO_OVERLAP(*result, c);

  string::size_type old_size = result->size();

  STLStringResizeUninitialized(result,

                               old_size + a.size() + b.size() + c.size());

  char *const begin = &*result->begin();

  char *out = Append2(begin + old_size, a, b);

  out = Append1(out, c);

  DCHECK_EQ(out, begin + result->size());

}

void StrAppend(string *result,

               const AlphaNum &a, const AlphaNum &b,

               const AlphaNum &c, const AlphaNum &d) {

  DCHECK_NO_OVERLAP(*result, a);

  DCHECK_NO_OVERLAP(*result, b);

  DCHECK_NO_OVERLAP(*result, c);

  DCHECK_NO_OVERLAP(*result, d);

  string::size_type old_size = result->size();

  STLStringResizeUninitialized(result,

      old_size + a.size() + b.size() + c.size() + d.size());

  char *const begin = &*result->begin();

  char *out = Append4(begin + old_size, a, b, c, d);

  DCHECK_EQ(out, begin + result->size());

}

// StrAppend with this many params is even rarer than with StrCat.

// Therefore we'll again rely on default arguments to make calling

// slightly less efficient, to preserve code size.

void StrAppend(string *result,

               const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,

               const AlphaNum &d, const AlphaNum &e, const AlphaNum &f,

               const AlphaNum &g, const AlphaNum &h, const AlphaNum &i) {

  DCHECK_NO_OVERLAP(*result, a);

  DCHECK_NO_OVERLAP(*result, b);

  DCHECK_NO_OVERLAP(*result, c);

  DCHECK_NO_OVERLAP(*result, d);

  DCHECK_NO_OVERLAP(*result, e);

  DCHECK_NO_OVERLAP(*result, f);

  DCHECK_NO_OVERLAP(*result, g);

  DCHECK_NO_OVERLAP(*result, h);

  DCHECK_NO_OVERLAP(*result, i);

  string::size_type old_size = result->size();

  STLStringResizeUninitialized(result,

      old_size + a.size() + b.size() + c.size() + d.size()

               + e.size() + f.size() + g.size() + h.size() + i.size());

  char *const begin = &*result->begin();

  char *out = Append4(begin + old_size, a, b, c, d);

  out = Append4(out, e, f, g, h);

  out = Append1(out, i);

  DCHECK_EQ(out, begin + result->size());

}