Call.h

/* Copyright (C) 2020-2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_LUA_CALL_H
#define PT_LUA_CALL_H
 
#include <Pt/Lua/Api.h>
#include <Pt/Reflex/MethodInfo.h>
#include <Pt/Reflex/PropertyInfo.h>
#include <Pt/Reflex/ConstructorInfo.h>
#include <Pt/Reflex/Argument.h>
#include <Pt/Any.h>
 
#include <string>
#include <vector>
 
namespace Pt {
 
namespace Lua {

class Call
{
  public:
    virtual ~Call()
    {}

    virtual Pt::Any call() = 0;

    virtual Pt::Reflex::Type* rtype() const = 0;

    bool hasError() const
    { return ! _errorMsg.empty(); }

    const std::string& errorMessage() const
    { return _errorMsg; }
 
  protected:
    Call() = default;
 
    Call(const Call&) = delete;
 
    Call& operator=(const Call&) = delete;

    void setError(const std::string& msg)
    { _errorMsg = msg; }
 
  private:
    std::string _errorMsg;
};
 

class MethodCall : public Call
{
  public:
    MethodCall(Pt::Reflex::MethodInfo* mi, void* self,
               std::vector<Pt::Reflex::Argument> args)
    : _mi(mi)
    , _self(self)
    , _args(args)
    {}
 
    Pt::Any call() override
    {
      try
      {
        Pt::Reflex::ArgumentList arglist(
          _args.empty() ? static_cast<Pt::Reflex::Argument*>(0) : &_args[0],
          _args.size());
        return _mi->call(_self, arglist);
      }
      catch(const std::exception& e) { setError(e.what()); }
 
      return Pt::Any();
    }
 
    Pt::Reflex::Type* rtype() const override
    { return &_mi->rtype(); }
 
  private:
    Pt::Reflex::MethodInfo*           _mi;
    void*                             _self;
    std::vector<Pt::Reflex::Argument> _args;
};
 

class PropertyGetCall : public Call
{
  public:
    PropertyGetCall(Pt::Reflex::PropertyInfo* pi, void* self)
    : _pi(pi)
    , _self(self)
    {}
 
    Pt::Any call() override
    {
      try { return _pi->get(_self); }
      catch(const std::exception& e) { setError(e.what()); }
 
      return Pt::Any();
    }
 
    Pt::Reflex::Type* rtype() const override
    { return &_pi->type(); }
 
  private:
    Pt::Reflex::PropertyInfo* _pi;
    void*                     _self;
};
 

class PropertySetCall : public Call
{
  public:
    PropertySetCall(Pt::Reflex::PropertyInfo* pi, void* self,
                    Pt::Reflex::Argument value)
    : _pi(pi)
    , _self(self)
    , _value(value)
    {}
 
    Pt::Any call() override
    {
      try { _pi->set(_self, _value.toAny(), _value.type()); }
      catch(const std::exception& e) { setError(e.what()); }
 
      return Pt::Any();
    }
 
    Pt::Reflex::Type* rtype() const override
    { return 0; }
 
  private:
    Pt::Reflex::PropertyInfo* _pi;
    void*                     _self;
    Pt::Reflex::Argument      _value;
};
 

class ConstructorCall : public Call
{
  public:
    ConstructorCall(Pt::Reflex::ConstructorInfo* ci, void* instance,
                    std::vector<Pt::Reflex::Argument> args)
    : _ci(ci)
    , _instance(instance)
    , _args(args)
    {}
 
    Pt::Any call() override
    {
      try
      {
        Pt::Reflex::ArgumentList arglist(
          _args.empty() ? static_cast<Pt::Reflex::Argument*>(0) : &_args[0],
          _args.size());
        _ci->call(_instance, arglist);
      }
      catch(const std::exception& e) { setError(e.what()); }
 
      return Pt::Any();
    }
 
    Pt::Reflex::Type* rtype() const override
    { return 0; }
 
  private:
    Pt::Reflex::ConstructorInfo*      _ci;
    void*                             _instance;
    std::vector<Pt::Reflex::Argument> _args;
};
 
} // namespace
 
} // namespace
 
#endif // PT_LUA_CALL_H