MemBlob.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 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_MEMBLOB_H_
#define SQUID_MEMBLOB_H_
 
#define MEMBLOB_DEBUGSECTION 24
 
#include "base/InstanceId.h"
#include "base/RefCount.h"
#include "mem/forward.h"
 
class MemBlobStats
{
public:
    MemBlobStats();
 
    std::ostream& dump(std::ostream& os) const;
 
    MemBlobStats& operator += (const MemBlobStats&);
 
public:
    uint64_t alloc;     
    uint64_t live;      
    uint64_t append;    
    uint64_t liveBytes; 
};
 
class MemBlob: public RefCountable
{
    MEMPROXY_CLASS(MemBlob);
 
public:
    typedef RefCount<MemBlob> Pointer;
    typedef uint32_t size_type;
 
    static const MemBlobStats& GetStats();
 
    explicit MemBlob(const size_type reserveSize);
 
    MemBlob(const char *buffer, const size_type bufferSize);
 
    ~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 char *source, const size_type n);
 
    /* non-const methods below require exclusive object ownership */
 
    void clear() { size = 0; }
 
    void syncSize(const size_type n);
 
    void consume(const size_type n);
 
    std::ostream & dump(std::ostream &os) const;
 
public:
    /* MemBlob users should avoid these and must treat them as read-only */
    char *mem;          
    size_type capacity; 
    size_type size;     
    const InstanceId<MemBlob> id; 
 
private:
    static MemBlobStats Stats; 
 
    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_MEMBLOB_H_ */