cbdata.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_SRC_CBDATA_H
#define SQUID_SRC_CBDATA_H
 
typedef int cbdata_type;
static const cbdata_type CBDATA_UNKNOWN = 0;
 
void *cbdataInternalAlloc(cbdata_type type);
 
void *cbdataInternalFree(void *p);
 
void cbdataInternalLock(const void *p);
void cbdataInternalUnlock(const void *p);
 
int cbdataInternalReferenceDoneValid(void **p, void **tp);
#define cbdataReferenceValidDone(var, ptr) cbdataInternalReferenceDoneValid((void **)&(var), (ptr))
 
int cbdataReferenceValid(const void *p);
 
cbdata_type cbdataInternalAddType(cbdata_type type, const char *label, int size);
 
#define CBDATA_DECL_(type, methodSpecifiers) \
        void *operator new(size_t size) { \
          assert(size == sizeof(type)); \
          if (!CBDATA_##type) CBDATA_##type = cbdataInternalAddType(CBDATA_##type, #type, sizeof(type)); \
          return (type *)cbdataInternalAlloc(CBDATA_##type); \
        } \
    public: \
        void operator delete (void *address) { \
          if (address) cbdataInternalFree(address); \
        } \
        void *toCbdata() methodSpecifiers { return this; } \
    private: \
       static cbdata_type CBDATA_##type;
 
class CbdataParent
{
public:
    virtual ~CbdataParent() {}
    virtual void *toCbdata() = 0;
 
private:
    virtual void finalizedInCbdataChild() = 0;
};
 
#define CBDATA_CLASS(type) public: CBDATA_DECL_(type, noexcept)
 
#define CBDATA_CLASS_WITH_MAKE(type) private: CBDATA_DECL_(type, noexcept)
 
#define CBDATA_CHILD(type) public: CBDATA_DECL_(type, final) \
      void finalizedInCbdataChild() final {}
 
#define CBDATA_INTERMEDIATE() \
    public: \
        void *toCbdata() override { return this; } \
    private:
 
#define CBDATA_CLASS_INIT(type) cbdata_type type::CBDATA_##type = CBDATA_UNKNOWN
 
#define CBDATA_NAMESPACED_CLASS_INIT(namespace, type) cbdata_type namespace::type::CBDATA_##type = CBDATA_UNKNOWN
 
#define cbdataReference(var)    (cbdataInternalLock(var), var)
 
#define cbdataReferenceDone(var) do {if (var) {cbdataInternalUnlock(var); var = nullptr;}} while(0)
 
class generic_cbdata
{
    CBDATA_CLASS(generic_cbdata);
 
public:
    generic_cbdata(void *aData) : data(aData) {}
 
    template<typename wrapped_type>void unwrap(wrapped_type **output) {
        *output = static_cast<wrapped_type *>(data);
        delete this;
    }
 
private:
    void *data;
};
 
// Discouraged: Use CbcPointer<> and asynchronous calls instead if possible.
class CallbackData
{
public:
    CallbackData(): data_(nullptr) {}
    CallbackData(void *data): data_(cbdataReference(data)) {}
    CallbackData(const CallbackData &other): data_(cbdataReference(other.data_)) {}
    CallbackData(CallbackData &&other): data_(other.data_) { other.data_ = nullptr; }
    ~CallbackData() { cbdataReferenceDone(data_); }
 
    CallbackData &operator =(const CallbackData &other);
    CallbackData &operator =(CallbackData &&other) { cbdataReferenceDone(data_); data_ = other.data_; other.data_ = nullptr; return *this; }
 
    bool valid() const { return cbdataReferenceValid(data_); }
    void *validDone() { void *result; return cbdataReferenceValidDone(data_, &result) ? result : nullptr; }
 
private:
    void *data_; 
};
 
#endif /* SQUID_SRC_CBDATA_H */