SquidString.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2026 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
/* DEBUG: section 67    String */
 
#ifndef SQUID_SRC_SQUIDSTRING_H
#define SQUID_SRC_SQUIDSTRING_H
 
#include "base/TextException.h"
#include "debug/Stream.h"
#include "sbuf/forward.h"
 
#include <ostream>
 
/* squid string placeholder (for printf) */
#ifndef SQUIDSTRINGPH
#define SQUIDSTRINGPH "%.*s"
#define SQUIDSTRINGPRINT(s) (s).psize(),(s).rawBuf()
#endif /* SQUIDSTRINGPH */
 
class String
{
 
public:
    String() = default;
    String(char const *);
    String(String const &);
    String(String && S) : size_(S.size_), len_(S.len_), buf_(S.buf_) {
        S.buf_ = nullptr; // S is about to be destructed
        S.size_ = S.len_ = 0;
    }
    ~String();
 
    typedef size_t size_type; //storage size intentionally unspecified
    const static size_type npos = static_cast<size_type>(-1);
 
    String &operator =(char const *);
    String &operator =(String const &);
    String &operator =(String && S) {
        if (this != &S) {
            clean();
            size_ = S.size_;
            len_ = S.len_;
            buf_ = S.buf_;
            S.size_ = 0;
            S.len_ = 0;
            S.buf_ = nullptr; // S is about to be destructed
        }
        return *this;
    }
 
    bool operator ==(String const &) const;
    bool operator !=(String const &) const;
 
    char operator [](unsigned int aPos) const {
        assert(aPos < size_);
        return buf_[aPos];
    }
 
    static size_type SizeMaxXXX() { return SizeMax_; }
 
    static size_type RawSizeMaxXXX() { return (SizeMaxXXX()+1)/3; }
 
    size_type size() const { return len_; }
 
    int psize() const {
        Must(size() < INT_MAX);
        return size();
    }
 
    char const * rawBuf() const { return buf_; }
 
    char const * termedBuf() const { return buf_; }
 
    void assign(const char *str, int len);
    void clean();
    void reset(char const *str);
    void append(char const *buf, int len);
    void append(char const *buf);
    void append(char const);
    void append(String const &);
    void append(const SBuf &); 
    void absorb(String &old);
    const char * pos(char const *aString) const;
    const char * pos(char const ch) const;
    size_type find(char const ch) const;
    size_type find(char const *aString) const;
    const char * rpos(char const ch) const;
    size_type rfind(char const ch) const;
    int cmp(char const *) const;
    int cmp(char const *, size_type count) const;
    int cmp(String const &) const;
    int caseCmp(char const *) const;
    int caseCmp(char const *, size_type count) const;
    int caseCmp(String const &str) const {
        return caseCmp(str.rawBuf(),str.size());
    }
 
    static bool CanGrowTo(size_type totalLen, const size_type extras = 0) { return SafeAdd(totalLen, extras) && SafeAdd(totalLen, 1); }
    bool canGrowBy(const size_type growthLen) const { return CanGrowTo(size(), growthLen); }
 
    String substr(size_type from, size_type to) const;
 
    void cut(size_type newLength);
 
private:
    void allocAndFill(const char *str, int len);
    void allocBuffer(size_type sz);
    void setBuffer(char *buf, size_type sz);
 
    bool defined() const {return buf_!=nullptr;}
    bool undefined() const {return !defined();}
 
    /* never reference these directly! */
    size_type size_ = 0; /* buffer size; limited by SizeMax_ */
 
    size_type len_ = 0;  /* current length  */
 
    static const size_type SizeMax_ = 3*64*1024 - 1;
 
    static bool SafeAdd(size_type &base, size_type extra) { if (extra <= SizeMax_ && base <= SizeMax_ - extra) { base += extra; return true; } return false; }
 
    char *buf_ = nullptr;
 
    void set(char const *loc, char const ch) {
        if (loc < buf_ || loc > (buf_ + size_))
            return;
        buf_[loc-buf_] = ch;
    }
 
    void cutPointer(char const *loc) {
        if (loc < buf_ || loc > (buf_ + size_))
            return;
        len_ = loc-buf_;
        buf_[len_] = '\0';
    }
};
 
inline std::ostream & operator<<(std::ostream &os, String const &aString)
{
    os.write(aString.rawBuf(),aString.size());
    return os;
}
 
inline bool operator<(const String &a, const String &b)
{
    return a.cmp(b) < 0;
}
 
const char *checkNullString(const char *p);
int stringHasWhitespace(const char *);
int stringHasCntl(const char *);
char *strwordtok(char *buf, char **t);
 
#endif /* SQUID_SRC_SQUIDSTRING_H */