AsyncCall.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_ASYNCCALL_H
#define SQUID_ASYNCCALL_H
 
#include "base/CodeContext.h"
#include "base/forward.h"
#include "base/InstanceId.h"
#include "event.h"
#include "RefCount.h"
 
class CallDialer;
 
class AsyncCall: public RefCountable
{
public:
    using Pointer = AsyncCallPointer;
 
    AsyncCall(int aDebugSection, int aDebugLevel, const char *aName);
    ~AsyncCall() override;
 
    void make(); // fire if we can; handles general call debugging
 
    // can be called from canFire() for debugging; always returns false
    bool cancel(const char *reason);
 
    bool canceled() const { return isCanceled != nullptr; }
 
    virtual CallDialer *getDialer() = 0;
 
    void print(std::ostream &os);
 
    void dequeue(AsyncCall::Pointer &head, AsyncCall::Pointer &prev);
 
    void setNext(AsyncCall::Pointer aNext) {
        theNext = aNext;
    }
 
    AsyncCall::Pointer &Next() {
        return theNext;
    }
 
public:
    const char *const name;
 
    CodeContext::Pointer codeContext;
 
    const int debugSection;
    const int debugLevel;
    const InstanceId<AsyncCall> id;
 
protected:
    virtual bool canFire();
 
    virtual void fire() = 0;
 
    AsyncCall::Pointer theNext; 
 
private:
    const char *isCanceled; // set to the cancellation reason by cancel()
 
    // not implemented to prevent nil calls from being passed around and unknowingly scheduled, for now.
    AsyncCall();
    AsyncCall(const AsyncCall &);
};
 
inline
std::ostream &operator <<(std::ostream &os, AsyncCall &call)
{
    call.print(os);
    return os;
}
 
class CallDialer
{
public:
    CallDialer() {}
    virtual ~CallDialer() {}
 
    // TODO: Add these for clarity when CommCbFunPtrCallT is gone
    //virtual bool canDial(AsyncCall &call) = 0;
    //virtual void dial(AsyncCall &call) = 0;
 
    virtual void print(std::ostream &os) const = 0;
};
 
template <class DialerClass>
class AsyncCallT: public AsyncCall
{
public:
    using Dialer = DialerClass;
 
    AsyncCallT(int aDebugSection, int aDebugLevel, const char *aName,
               const Dialer &aDialer): AsyncCall(aDebugSection, aDebugLevel, aName),
        dialer(aDialer) {}
 
    AsyncCallT(const AsyncCallT<Dialer> &o):
        AsyncCall(o.debugSection, o.debugLevel, o.name),
        dialer(o.dialer) {}
 
    ~AsyncCallT() override {}
 
    CallDialer *getDialer() override { return &dialer; }
 
    Dialer dialer;
 
protected:
    bool canFire() override {
        return AsyncCall::canFire() &&
               dialer.canDial(*this);
    }
    void fire() override { dialer.dial(*this); }
 
private:
    AsyncCallT & operator=(const AsyncCallT &); // not defined. call assignments not permitted.
};
 
template <class Dialer>
RefCount< AsyncCallT<Dialer> >
asyncCall(int aDebugSection, int aDebugLevel, const char *aName,
          const Dialer &aDialer)
{
    return new AsyncCallT<Dialer>(aDebugSection, aDebugLevel, aName, aDialer);
}
 
bool ScheduleCall(const char *fileName, int fileLine, const AsyncCall::Pointer &);
 
#define ScheduleCallHere(call) ScheduleCall(__FILE__, __LINE__, (call))
 
#endif /* SQUID_ASYNCCALL_H */