AsyncCall.h

/* Copyright (C) 2020-2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_LUA_ASYNCCALL_H
#define PT_LUA_ASYNCCALL_H
 
#include <Pt/Lua/Api.h>
#include <Pt/Signal.h>
#include <Pt/Reflex/TypeManager.h>
#include <Pt/Reflex/Argument.h>
#include <Pt/Reflex/ArgumentTraits.h>
#include <Pt/System/EventLoop.h>
#include <Pt/Any.h>
 
#include <exception>
#include <string>
 
namespace Pt {
 
namespace Lua {

class PT_LUA_API AsyncCall
{
  public:
    AsyncCall();

    virtual ~AsyncCall();

    void bind(Pt::Reflex::TypeManager& tm);

    Pt::Reflex::Type* rtype() const;

    void beginCall(Pt::System::EventLoop& loop);

    Pt::Any getResult();

    Pt::Signal<>& finished();

    void cancel();

    bool hasError() const;

    const std::string& errorMessage() const;
 
  protected:
    void setReady();

    void setError(const std::string& msg);
 
  private:
    virtual Pt::Reflex::Type* onBind(Pt::Reflex::TypeManager& tm) = 0;
 
    virtual void onBeginCall(Pt::System::EventLoop& loop) = 0;
 
    virtual Pt::Any onGetResult() = 0;
 
    virtual void onCancel() = 0;
 
  private:
    Pt::Signal<>      _finished;
    bool              _hasError;
    std::string       _errorMsg;
    Pt::Reflex::Type* _rtype;
};
 

template <typename R>
class BasicAsyncCall : public AsyncCall
{
  protected:
    virtual Pt::Reflex::Type* onBind(Pt::Reflex::TypeManager& tm) override
    {
      return tm.getType( typeid(R) );
    }

    virtual R onResult() = 0;
 
  private:
    Pt::Any onGetResult() override
    {
      R r = onResult();
      return Pt::Any(r);
    }
};
 

template <>
class BasicAsyncCall<void> : public AsyncCall
{
  protected:
    virtual Pt::Reflex::Type* onBind(Pt::Reflex::TypeManager& tm) override
    {
      return tm.getType( typeid(void) );
    }
 
  private:
    Pt::Any onGetResult() override
    { return Pt::Any(); }
};
 
} // namespace
 
} // namespace
 
#endif // PT_LUA_ASYNCCALL_H