straccum.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/straccum.cc" -*-
#ifndef CLICK_STRACCUM_HH
#define CLICK_STRACCUM_HH
#include <click/glue.hh>
#include <click/string.hh>
#ifdef CLICK_LINUXMODULE
# include <click/cxxprotect.h>
CLICK_CXX_PROTECT
# include <asm/string.h>
CLICK_CXX_UNPROTECT
# include <click/cxxunprotect.h>
#elif defined(CLICK_BSDMODULE)
# include <sys/systm.h>
#else   /* User-space */
# include <string.h>
#endif
#if __GNUC__ > 4
# define CLICK_SNPRINTF_ATTR __attribute__((__format__(__printf__, 3, 4)))
#else
# define CLICK_SNPRINTF_ATTR /* nothing */
#endif
CLICK_DECLS
 
class StringAccum { public:
 
    typedef const char *const_iterator;
    typedef char *iterator;
 
    typedef int (StringAccum::*unspecified_bool_type)() const;
 
    inline StringAccum();
    explicit inline StringAccum(int capacity);
    inline StringAccum(const String &str);
    inline StringAccum(const StringAccum &x);
#if HAVE_CXX_RVALUE_REFERENCES
    inline StringAccum(StringAccum &&x);
#endif
    inline ~StringAccum();
 
    inline StringAccum &operator=(const StringAccum &x);
#if HAVE_CXX_RVALUE_REFERENCES
    inline StringAccum &operator=(StringAccum &&x);
#endif
 
    inline const char *data() const;
    inline char *data();
    inline int length() const;
    inline int capacity() const;
 
    const char *c_str();
 
    inline operator unspecified_bool_type() const;
    inline bool empty() const;
    inline bool operator!() const;
 
    inline const_iterator begin() const;
    inline iterator begin();
    inline const_iterator end() const;
    inline iterator end();
 
    inline char operator[](int i) const;
    inline char &operator[](int i);
    inline char front() const;
    inline char &front();
    inline char back() const;
    inline char &back();
 
    inline bool out_of_memory() const;
    void assign_out_of_memory();
 
    inline void clear();
    inline char *reserve(int n);
    inline void set_length(int len);
    int resize(int len);
    inline void adjust_length(int delta);
    inline char *extend(int nadjust, int nreserve = 0);
 
    inline void pop_back(int n = 1);
 
    inline void append(char c);
    inline void append(unsigned char c);
    inline bool append_utf8(int ch);
    inline void append(const char *cstr);
    inline void append(const char *s, int len);
    inline void append(const unsigned char *s, int len);
    inline void append(const char *first, const char *last);
    inline void append(const unsigned char *first, const unsigned char *last);
    void append_fill(int c, int len);
    void append_numeric(String::intmax_t x, int base = 10, bool uppercase = true);
    void append_numeric(String::uintmax_t x, int base = 10, bool uppercase = true);
 
    StringAccum &snprintf(int n, const char *format, ...) CLICK_SNPRINTF_ATTR;
 
    String take_string();
 
    void swap(StringAccum &x);
 
    // see also operator<< declarations below
 
    inline void forward(int delta) CLICK_DEPRECATED;
 
  private:
 
    enum {
        MEMO_SPACE = String::MEMO_SPACE
    };
 
    struct rep_t {
        unsigned char *s;
        int len;
        int cap;
        rep_t()
            : s(reinterpret_cast<unsigned char *>(const_cast<char *>(String::empty_data()))),
              len(0), cap(0) {
        }
        explicit rep_t(uninitialized_type) {
        }
    };
 
    rep_t r_;
 
    char *grow(int);
    char *hard_extend(int nadjust, int nreserve);
    void hard_append(const char *s, int len);
    void hard_append_cstr(const char *cstr);
    bool append_utf8_hard(int ch);
 
    friend StringAccum &operator<<(StringAccum &sa, const String &str);
#if HAVE_PERMSTRING
    friend StringAccum &operator<<(StringAccum &sa, PermString s);
#endif
 
};
 
inline StringAccum &operator<<(StringAccum &sa, char c);
inline StringAccum &operator<<(StringAccum &sa, unsigned char c);
inline StringAccum &operator<<(StringAccum &sa, const char *cstr);
inline StringAccum &operator<<(StringAccum &sa, const String &s);
inline StringAccum &operator<<(StringAccum &sa, const StringAccum &x);
 
inline StringAccum &operator<<(StringAccum &sa, bool x);
inline StringAccum &operator<<(StringAccum &sa, short x);
inline StringAccum &operator<<(StringAccum &sa, unsigned short x);
inline StringAccum &operator<<(StringAccum &sa, int x);
inline StringAccum &operator<<(StringAccum &sa, unsigned x);
StringAccum &operator<<(StringAccum &sa, long x);
StringAccum &operator<<(StringAccum &sa, unsigned long x);
#if HAVE_LONG_LONG
inline StringAccum &operator<<(StringAccum &sa, long long x);
inline StringAccum &operator<<(StringAccum &sa, unsigned long long x);
#endif
#if HAVE_INT64_TYPES && !HAVE_INT64_IS_LONG && !HAVE_INT64_IS_LONG_LONG
inline StringAccum &operator<<(StringAccum &sa, int64_t x);
inline StringAccum &operator<<(StringAccum &sa, uint64_t x);
#endif
#if defined(CLICK_USERLEVEL) || defined(CLICK_TOOL) || defined(CLICK_MINIOS)
StringAccum &operator<<(StringAccum &sa, double x);
#endif
StringAccum &operator<<(StringAccum &sa, const void *ptr);
 
 
inline StringAccum::StringAccum() {
}
 
inline StringAccum::StringAccum(int capacity) {
    assert(capacity >= 0);
    unsigned char *s;
    if (capacity
        && (s = (unsigned char *) CLICK_LALLOC(capacity + MEMO_SPACE))) {
        r_.s = s + MEMO_SPACE;
        r_.cap = capacity;
    }
}
 
inline StringAccum::StringAccum(const String &str) {
    append(str.begin(), str.end());
}
 
inline StringAccum::StringAccum(const StringAccum &x) {
    append(x.data(), x.length());
}
 
#if HAVE_CXX_RVALUE_REFERENCES
inline StringAccum::StringAccum(StringAccum &&x)
    : r_(x.r_) {
    x.r_.cap = 0;
}
#endif
 
inline StringAccum::~StringAccum() {
    if (r_.cap > 0)
        CLICK_LFREE(r_.s - MEMO_SPACE, r_.cap + MEMO_SPACE);
}
 
inline const char *StringAccum::data() const {
    return reinterpret_cast<const char *>(r_.s);
}
 
inline char *StringAccum::data() {
    return reinterpret_cast<char *>(r_.s);
}
 
inline int StringAccum::length() const {
    return r_.len;
}
 
inline int StringAccum::capacity() const {
    return r_.cap;
}
 
inline StringAccum::const_iterator StringAccum::begin() const {
    return reinterpret_cast<char *>(r_.s);
}
 
inline StringAccum::iterator StringAccum::begin() {
    return reinterpret_cast<char *>(r_.s);
}
 
inline StringAccum::const_iterator StringAccum::end() const {
    return reinterpret_cast<char *>(r_.s + r_.len);
}
 
inline StringAccum::iterator StringAccum::end() {
    return reinterpret_cast<char *>(r_.s + r_.len);
}
 
inline StringAccum::operator unspecified_bool_type() const {
    return r_.len != 0 ? &StringAccum::capacity : 0;
}
 
inline bool StringAccum::operator!() const {
    return r_.len == 0;
}
 
inline bool StringAccum::empty() const {
    return r_.len == 0;
}
 
inline bool StringAccum::out_of_memory() const {
    return unlikely(r_.cap < 0);
}
 
inline char StringAccum::operator[](int i) const {
    assert((unsigned) i < (unsigned) r_.len);
    return static_cast<char>(r_.s[i]);
}
 
inline char &StringAccum::operator[](int i) {
    assert((unsigned) i < (unsigned) r_.len);
    return reinterpret_cast<char &>(r_.s[i]);
}
 
inline char StringAccum::front() const {
    assert(r_.len > 0);
    return static_cast<char>(r_.s[0]);
}
 
inline char &StringAccum::front() {
    assert(r_.len > 0);
    return reinterpret_cast<char &>(r_.s[0]);
}
 
inline char StringAccum::back() const {
    assert(r_.len > 0);
    return static_cast<char>(r_.s[r_.len - 1]);
}
 
inline char &StringAccum::back() {
    assert(r_.len > 0);
    return reinterpret_cast<char &>(r_.s[r_.len - 1]);
}
 
inline void StringAccum::clear() {
    if (r_.cap < 0)
        r_.cap = 0;
    r_.len = 0;
}
 
inline char *StringAccum::reserve(int n) {
    assert(n >= 0);
    if (r_.len + n <= r_.cap)
        return reinterpret_cast<char *>(r_.s + r_.len);
    else
        return grow(r_.len + n);
}
 
inline void StringAccum::set_length(int len) {
    assert(len >= 0 && r_.len <= r_.cap);
    r_.len = len;
}
 
inline void StringAccum::adjust_length(int delta) {
    assert(r_.len + delta >= 0 && r_.len + delta <= r_.cap);
    r_.len += delta;
}
 
inline char *StringAccum::extend(int nadjust, int nreserve) {
#if CLICK_OPTIMIZE_SIZE || __OPTIMIZE_SIZE__
    return hard_extend(nadjust, nreserve);
#else
    assert(nadjust >= 0 && nreserve >= 0);
    if (r_.len + nadjust + nreserve <= r_.cap) {
        char *x = reinterpret_cast<char *>(r_.s + r_.len);
        r_.len += nadjust;
        return x;
    } else
        return hard_extend(nadjust, nreserve);
#endif
}
 
inline void StringAccum::pop_back(int n) {
    assert(n >= 0 && r_.len >= n);
    r_.len -= n;
}
 
inline void StringAccum::append(char c) {
    if (r_.len < r_.cap || grow(r_.len))
        r_.s[r_.len++] = c;
}
 
inline void StringAccum::append(unsigned char c) {
    append(static_cast<char>(c));
}
 
inline void StringAccum::append(const char *s, int len) {
#if CLICK_OPTIMIZE_SIZE || __OPTIMIZE_SIZE__
    hard_append(s, len);
#else
    assert(len >= 0);
    if (r_.len + len <= r_.cap) {
        memcpy(r_.s + r_.len, s, len);
        r_.len += len;
    } else
        hard_append(s, len);
#endif
}
 
inline void StringAccum::append(const unsigned char *s, int len) {
    append(reinterpret_cast<const char *>(s), len);
}
 
inline void StringAccum::append(const char *cstr) {
    if (CLICK_CONSTANT_CSTR(cstr))
        append(cstr, strlen(cstr));
    else
        hard_append_cstr(cstr);
}
 
inline void StringAccum::append(const char *first, const char *last) {
    if (first < last)
        append(first, last - first);
}
 
inline void StringAccum::append(const unsigned char *first, const unsigned char *last) {
    if (first < last)
        append(first, last - first);
}
 
inline bool StringAccum::append_utf8(int ch) {
    if (unlikely(ch <= 0))
        return false;
    else if (likely(ch <= 0x7F)) {
        append(static_cast<char>(ch));
        return true;
    } else
        return append_utf8_hard(ch);
}
 
inline StringAccum &StringAccum::operator=(const StringAccum &x) {
    if (&x != this) {
        if (out_of_memory())
            r_.cap = 0;
        r_.len = 0;
        append(x.data(), x.length());
    }
    return *this;
}
 
#if HAVE_CXX_RVALUE_REFERENCES
inline StringAccum &StringAccum::operator=(StringAccum &&x) {
    x.swap(*this);
    return *this;
}
#endif
 
inline void StringAccum::forward(int delta) {
    adjust_length(delta);
}
inline StringAccum &operator<<(StringAccum &sa, char c) {
    sa.append(c);
    return sa;
}
 
inline StringAccum &operator<<(StringAccum &sa, unsigned char c) {
    sa.append(c);
    return sa;
}
 
inline StringAccum &operator<<(StringAccum &sa, const char *cstr) {
    sa.append(cstr);
    return sa;
}
 
inline StringAccum &operator<<(StringAccum &sa, bool x) {
    sa.append(String::bool_data + (-x & 6), 5 - x);
    return sa;
}
 
inline StringAccum &operator<<(StringAccum &sa, short x) {
    return sa << static_cast<long>(x);
}
 
inline StringAccum &operator<<(StringAccum &sa, unsigned short x) {
    return sa << static_cast<unsigned long>(x);
}
 
inline StringAccum &operator<<(StringAccum &sa, int x) {
    return sa << static_cast<long>(x);
}
 
inline StringAccum &operator<<(StringAccum &sa, unsigned x) {
    return sa << static_cast<unsigned long>(x);
}
 
#if HAVE_LONG_LONG
inline StringAccum &operator<<(StringAccum &sa, long long x) {
    sa.append_numeric(static_cast<String::intmax_t>(x));
    return sa;
}
 
inline StringAccum &operator<<(StringAccum &sa, unsigned long long x) {
    sa.append_numeric(static_cast<String::uintmax_t>(x));
    return sa;
}
#endif
 
#if HAVE_INT64_TYPES && !HAVE_INT64_IS_LONG && !HAVE_INT64_IS_LONG_LONG
inline StringAccum &operator<<(StringAccum &sa, int64_t x) {
    sa.append_numeric(static_cast<String::intmax_t>(x));
    return sa;
}
 
inline StringAccum &operator<<(StringAccum &sa, uint64_t x) {
    sa.append_numeric(static_cast<String::uintmax_t>(x));
    return sa;
}
#endif
 
inline StringAccum &operator<<(StringAccum &sa, const String &str) {
    sa.append(str.data(), str.length());
    return sa;
}
 
inline StringAccum &operator<<(StringAccum &sa, const StringAccum &x) {
    sa.append(x.begin(), x.end());
    return sa;
}
 
inline void click_swap(StringAccum &a, StringAccum &b) {
    a.swap(b);
}
 
inline void assign_consume(StringAccum &a, StringAccum &b) {
    a.swap(b);
}
 
#undef CLICK_SNPRINTF_ATTR
CLICK_ENDDECLS
#endif