MemBuf.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2022 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.
 */
 
#ifndef SQUID_MEMBUF_H
#define SQUID_MEMBUF_H
 
#include "base/Packable.h"
#include "cbdata.h"
#include "mem/forward.h"
 
/* in case we want to change it later */
typedef ssize_t mb_size_t;
 
class MemBuf : public Packable
{
    CBDATA_CLASS(MemBuf);
 
public:
    MemBuf():
        buf(nullptr),
        size(0),
        max_capacity(0),
        capacity(0),
        stolen(0)
    {}
    virtual ~MemBuf() {
        if (!stolen && buf)
            clean();
    }
 
    char *content() { return buf; }
 
    const char *content() const { return buf; }
 
    mb_size_t contentSize() const { return size; }
 
    bool hasContent() const { return size > 0; }
 
    char *space() { return buf + size; } 
 
    char *space(mb_size_t required) { if (size + required >= capacity) grow(size + required + 1); return buf + size; }
 
    mb_size_t spaceSize() const;
 
    bool hasSpace() const { return size+1 < capacity; }
 
    mb_size_t potentialSpaceSize() const; // accounts for possible growth
    bool hasPotentialSpace() const { return potentialSpaceSize() > 0; }
 
 
    void consume(mb_size_t sz);  // removes sz bytes, moving content left
    void consumeWhitespacePrefix();    
 
    void appended(mb_size_t sz); // updates content size after external append
    void truncate(mb_size_t sz);  // removes sz last bytes
 
    void terminate(); // zero-terminates the buffer w/o increasing contentSize
 
    bool wasStolen() const { return stolen; }
 
    void init(mb_size_t szInit, mb_size_t szMax);
 
    void init();
 
    void clean();
 
    void reset();
 
    int isNull() const;
 
    FREE *freeFunc();
 
    /* Packable API */
    virtual void append(const char *c, int sz);
    virtual void vappendf(const char *fmt, va_list ap);
 
private:
    MemBuf(const MemBuf &) {assert(false);}
 
    MemBuf& operator= (const MemBuf &) {assert(false); return *this;}
 
    void grow(mb_size_t min_cap);
 
public:
    char *buf;          // available content
    mb_size_t size;     // used space, does not count 0-terminator
 
    mb_size_t max_capacity;
 
    mb_size_t capacity;
 
    unsigned stolen:1;      /* the buffer has been stolen for use by someone else */
 
#if 0
 
    unsigned valid:1;       /* to be used for debugging only! */
#endif
};
 
void memBufReport(MemBuf * mb);
 
#endif /* SQUID_MEMBUF_H */