String.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or any later version.
 *
 * Hypertable is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Hypertable. If not, see <http://www.gnu.org/licenses/>
 */

#ifndef HYPERTABLE_STRING_H
#define HYPERTABLE_STRING_H

#include <string>
#include <sstream>
#include <limits>

namespace Hypertable {

  typedef std::string String;

  typedef long unsigned int Lu;

  typedef long long unsigned int Llu;

  typedef long long int Lld;

  String format(const char *fmt, ...) __attribute__((format (printf, 1, 2)));

  String format_number(int64_t n, int sep = ',');

  String format_bytes(size_t n, const void *buf, size_t len,
          const char *trailer = "...");

  template <class SequenceT>
  String format_list(const SequenceT &seq, const char *sep = ", ") {
    typedef typename SequenceT::const_iterator Iterator;
    Iterator it = seq.begin(), end = seq.end();
    std::ostringstream out;
    out << '[';

    if (it != end) {
      out << *it;
      ++it;
    }
    for (; it != end; ++it)
      out << sep << *it;

    out << ']';
    return out.str();
  }

  inline bool strip_enclosing_quotes(const char *input, size_t input_len,
                                     const char **output, size_t *output_len) {
    if (input_len < 2 ||
        !((*input == '\'' && input[input_len-1] == '\'') ||
          (*input == '"' && input[input_len-1] == '"'))) {
      *output = input;
      *output_len = input_len;
      return false;
    }
    *output = input + 1;
    *output_len = input_len - 2;
    return true;
  }

  class NumericFormatterDigits {
  protected:
    static const char DIGITS[];
  };

  template<class T>
  class NumericFormatter : public NumericFormatterDigits {
  public:

    size_t size() const { return buf - s + BUFFER_SIZE - 1; }

    const char *data() const { return str; }

    const char *c_str() const {
      return s;
    }

    std::string str() const { return std::string(s, size()); }

    char* append_to(char* p) const {
      memcpy(p, s, size());
      return p + size();
    }

  protected:

    NumericFormatter() {
      buf[BUFFER_SIZE - 1] = '\0';
    }
    void format_unsigned(T value) {
      s = buf + BUFFER_SIZE - 1;
      while (value >= 100) {
        // Integer division is slow so do it for a group of two digits instead
        // of for every digit. The idea comes from the talk by Alexandrescu
        // "Three Optimization Tips for C++". See speed-test for a comparison.
        unsigned index = (value % 100) * 2;
        value /= 100;
        *--s = DIGITS[index + 1];
        *--s = DIGITS[index];
      }
      if (value < 10) {
        *--s = static_cast<char>('0' + value);
        return;
      }
      unsigned index = static_cast<unsigned>(value * 2);
      *--s = DIGITS[index + 1];
      *--s = DIGITS[index];
    }

    void format_signed(T value) {
      if (value >= 0)
        format_unsigned(value);
      else {
        format_unsigned(-value);
        *--s = '-';
      }
    }

  private:
    enum { BUFFER_SIZE = std::numeric_limits<T>::digits10 + 3 };
    char buf[BUFFER_SIZE];
    char* s;
  };

  template<class T>
  class NumericSignedFormatter : public NumericFormatter<T> {
  public:
    explicit NumericSignedFormatter(T value) {
      NumericFormatter<T>::format_signed(value);
    }
  };

  template<class T>
  class NumericUnsignedFormatter : public NumericFormatter<T> {
  public:
    explicit NumericUnsignedFormatter(T value) {
      NumericFormatter<T>::format_unsigned(value);
    }
  };

  typedef NumericUnsignedFormatter<uint8_t> UInt8Formatter;
  typedef NumericUnsignedFormatter<uint16_t> UInt16Formatter;
  typedef NumericUnsignedFormatter<uint32_t> UInt32Formatter;
  typedef NumericUnsignedFormatter<uint64_t> UInt64Formatter;

  typedef NumericSignedFormatter<int8_t> Int8Formatter;
  typedef NumericSignedFormatter<int16_t> Int16Formatter;
  typedef NumericSignedFormatter<int32_t> Int32Formatter;
  typedef NumericSignedFormatter<int64_t> Int64Formatter;

} // namespace Hypertable

#endif // HYPERTABLE_STRING_H