MemBlob.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2025 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_SRC_SBUF_MEMBLOB_H
#define SQUID_SRC_SBUF_MEMBLOB_H
 
#define MEMBLOB_DEBUGSECTION 24
 
#include "base/InstanceId.h"
#include "base/RefCount.h"
#include "mem/forward.h"
 
class MemBlobStats
{
public:
    std::ostream& dump(std::ostream& os) const;
 
    MemBlobStats& operator += (const MemBlobStats&);
 
public:
    uint64_t alloc = 0;     
    uint64_t live = 0;      
    uint64_t append = 0;    
    uint64_t liveBytes = 0; 
};
 
class MemBlob: public RefCountable
{
    MEMPROXY_CLASS(MemBlob);
 
public:
    typedef RefCount<MemBlob> Pointer;
 
    /* emulate std::basic_string API */
    using value_type = char;
    using size_type = uint32_t;
    using const_pointer = const value_type *;
 
    static const MemBlobStats& GetStats();
 
    explicit MemBlob(const size_type reserveSize);
 
    /* emulate std::basic_string API */
    MemBlob(const_pointer, const size_type);
    ~MemBlob() override;
 
    size_type spaceSize() const { return capacity - size; }
 
    bool canAppend(const size_type off, const size_type n) const {
        // TODO: ignore offset (and adjust size) when the blob is not shared?
        return (isAppendOffset(off) && willFit(n)) || !n;
    }
 
    void appended(const size_type n);
 
    void append(const_pointer source, const size_type n);
 
    /* non-const methods below require exclusive object ownership */
 
    void syncSize(const size_type n);
 
    void consume(const size_type n);
 
    std::ostream & dump(std::ostream &os) const;
 
    /* emulate std::basic_string API */
    void clear() { size = 0; }
 
public:
    /* MemBlob users should avoid these and must treat them as read-only */
    value_type *mem = nullptr; 
    size_type capacity = 0; 
    size_type size = 0; 
    const InstanceId<MemBlob> id; 
 
private:
    void memAlloc(const size_type memSize);
 
    bool isAppendOffset(const size_type off) const { return off == size; }
 
    bool willFit(const size_type n) const { return n <= spaceSize(); }
 
    /* copying is not implemented */
    MemBlob(const MemBlob &);
    MemBlob& operator =(const MemBlob &);
};
 
#endif /* SQUID_SRC_SBUF_MEMBLOB_H */