bufstr_t.hpp

Go to the documentation of this file.

#ifndef GLIM_BUFSTR_T_HPP_
#define GLIM_BUFSTR_T_HPP_

/// Stack-allocated string buffer.
/// @file

#include <stdexcept>
#include <limits>
#include <utility> // pair
#include <string>
#include "config.h"
#if defined HAS_stpncpy
# include <string.h>
#endif
#include "c_func.hpp"

namespace glim {

/**
 * Stack-allocated string buffer.
 * Based on str_t and safestr_t classes from libaga, of the same author,
 * which were made back in 1999, but without C++ templating and exceptions.\n\n
 * Operations that would overflow will either throw the std::out_of_range error
 * (if the THROW template parameter is true, which it is by default),
 * or silently ignored.\n\n
 * See also http://www.codeproject.com/string/Allocdynstringsonstack.asp
 */
template <int SIZE, bool THROW = true>
struct bufstr_t {
  /**
   * The buffer (stack-allocated, if the containing instance is).
   * The size of the buffer is SIZE + 1, so that we always have a space to zero-terminate the string.
   */
  char buf[SIZE+1];
  /** The current length of the string. */
  int len;

  /**
   * This default constructor is sufficient to use the buffer.
   */
  bufstr_t(): len(0) {}

  /**
   * Access the buffer as null-terminated C string.
   * This method will terminate the buffer with zero.
   */
  char* c() {
    buf[len] = 0;
    return buf;
  }

  /**
   * Access the buffer as null-terminated C string.
   * This method will terminate the buffer with zero.
   */
  char* c_str() {
    buf[len] = 0;
    return buf;
  }

  /**
   * Returns a pointer to the end of the contained string.
   * bufstr.end() is a shorthand to (bufstr.buf + bufstr.len).
   */
  char* end() const {
    return (char*) buf + len;
  }

  /**
   * Access the buffer as std::pair.
   * The pair consists of a pointer to the beginning and the length of the contained string.
   */
  std::pair<char const*, int> pair() const {
    return std::pair<char const*, int> (buf, len);
  }

  /**
   * Set the length counter back to 0, so that the buffer can be reused.
   */
  bufstr_t& reset() {
    len = 0;
    return *this;
  }

  /**
   * Append another buffer.
   */
  template <int C_SIZE, bool C_THROW>
  bufstr_t& operator << (const bufstr_t<C_SIZE, C_THROW>& ab) {
    return appendString(ab.buf, ab.len); }

  /**
   * Append a string whose length is known.
   */
  bufstr_t& operator << (std::pair<char const*, int> str) {
    return appendString(str.first, str.second); }

  /**
   * Append a null-terminated character string.
   */
  bufstr_t& operator << (char const* cs) {
    return appendString(cs); }

  /// Append a C++ string into the buffer.
  bufstr_t& operator << (const std::string& str) {
    return appendString (str.c_str(), str.length()); }

  /**
   * Append a signed integer to the buffer, converting it to decimal form.
   */
  template <typename INT>
  bufstr_t& appendInt (INT integer) {
    if (SIZE - len < std::numeric_limits<INT>::digits10 + 2) {
      if (THROW) throw std::out_of_range("bufstr_t");
      else return *this;
    }
    char* end = buf + len;
    len += glim::itoa(end, integer) - end;
    return *this; }

  /**
   * Append a string whose length is known.
   */
  bufstr_t& appendString (char const* str, int strLen) {
    if (strLen > 0) {
      if (strLen + len > SIZE) {
        if (THROW) throw std::out_of_range("bufstr_t");
        else return *this;
      } else {
        memcpy(buf+len, str, strLen);
        len += strLen;
    } }
    return *this; }

  /**
   * Append a null-terminated character string.
   */
  bufstr_t& appendString (char const* cs) {
    if (cs) {
      char* end = buf + len;
      #if defined HAS_stpncpy
        len += ::stpncpy(end, cs, SIZE - len) - end;
      #else
        len += glim::stpncpy(end, cs, SIZE - len) - end;
      #endif
      if(THROW && len == SIZE) throw std::out_of_range("bufstr_t");
    }
    return *this; }

  /// Append a C++ string into the buffer.
  bufstr_t& appendString (const std::string& str) {
    return appendString (str.c_str(), str.length()); }

  /// Append an int to the buffer, converting it to decimal form.
  bufstr_t& operator << (int integer) {
    return appendInt(integer); }

  /// Append a long long to the buffer, converting it to decimal form.
  bufstr_t& operator << (long long integer) {
    return appendInt(integer); }

  /**
   * Append a single character to the buffer.
   */
  bufstr_t& operator << (char ch) {
    if (len >= SIZE) {
      if (THROW) throw std::out_of_range("bufstr_t");
      else return *this;
    }
    buf[len++] = ch;
    return *this;
  }
};

} // namespace glim

#endif // GLIM_BUFSTR_T_HPP_

---