How to register std::span?

[Lveyou]

For example:

using BufferView = std::span<std::byte>; 

uint32_t HashCrc32(BufferView buf, uint32_t crc = 0)
{
     ...
}

It would be great if std::span were supported by default.

Additionally, I also tried using default parameters in functions; this should be how they are used, right?

addFunction("HashCrc32", luabridge::bind_back(&HashCrc32, 0))

I think providing default parameter values is a very important feature.

[kunitoki]

Span cannot be passed from lua to C++, can only be passed from C++ to lua (by converting to a table). A table is not contiguous so it cannot be forwarded to a span unless materialised as contiguous memory:

addFunction("HashCrc32",
    +[](const std::vector<std::byte>& v) { return HashCrc32(v); },
    +[](const std::vector<std::byte>& v, uint32_t crc) { return HashCrc32(v, crc); })

[Lveyou]

std::span was created for the sake of efficiency. Its principle should be a starting address plus a length. It is more about being passed around as a parameter rather than being operated like a table in Lua.
Alternatively, I can disable the default span registration to achieve the effect I want.

[kunitoki]

I understand how would you use span for efficiency, but here we need to cross language boundaries. Who is providing a BufferView, lua or C++ ?

[kunitoki]

starting address plus a length

the only thing that it's like that in lua is the string type, otherwise you will have to register a custom type that is holding the span (with the risk of passing dangling references into lua).

[Lveyou]

I am not very clear about the underlying mechanism and lifecycle of Lua. But I know it is a weak reference, and no matter what it points to, it is valid for a short time, so if it becomes invalid, it becomes invalid. I even directly give Lua raw pointers and discard them after use. For example, I also register this kind of delete function:

static void lua_delete(Image* img)
{
delete img;
}

But I would clearly indicate that this kind of usage is only valid for a short time.

[kunitoki]

addFunction("HashCrc32", luabridge::bind_back(&HashCrc32, 0))

this should work, isn't it working for you ?

default parameter values is a very important feature.

this is tricky for luabridge to know, maybe with C++26 metaprogramming we can, but now it's only possible this way with bind_back or with this (like pybind is doing):

addFunction("HashCrc32", &HashCrc32, luabridge::arg("buf"), luabridge::arg("crc") = 0)

but it's not available now in luabridge3

[kunitoki]

I am not very clear about the underlying mechanism and lifecycle of Lua. But I know it is a weak reference, and no matter what it points to, it is valid for a short time, so if it becomes invalid, it becomes invalid. I even directly give Lua raw pointers and discard them after use. For example, I also register this kind of delete function:

static void lua_delete(Image* img)
{
delete img;
}
But I would clearly indicate that this kind of usage is only valid for a short time.

But how do you want to call HashCrc32 from lua ?

local x = ?
print (HashCrc32 (x))

what is x ?

• a lua table ?
• a C++ std::vector<bytes> binded with luabridge3 (if you passed it as a Stack<> vector, is converted to a lua table) ?
• a C++ custom class you binded with luabridge3 ?

[kunitoki]

You have two options and it depends on how you are expected to use the call:

• Use lua string which ensure contiguity if you have a byte buffer in lua to hash:

uint32_t LuaHashCrc32(lua_State* L, uint32_t crc)
{
    size_t len;
    const char* data = luaL_checklstring(L, 1, &len);

    std::span<const std::byte> buf(
        reinterpret_cast<const std::byte*>(data), len);

    return HashCrc32(buf, crc);
}

addFunction("HashCrc32",
    &LuaHashCrc32,
    luabridge::bind_back(&LuaHashCrc32, 0));

• Expose a buffer type

struct Buffer {
    std::vector<std::byte> data;
};

luabridge::getGlobalNamespace(L)
    .beginClass<Buffer>("Buffer")
    .addConstructor<void(*)()>()
    .endClass();

addFunction("HashCrc32",
    +[](const Buffer& b) {
        return HashCrc32(std::span<const std::byte>(b.data));
    });

Then from lua:

local b = Buffer()
-- fill it somehow
print(HashCrc32(b))

[Lveyou]

lua:

local buf = File.GetBuffer(value)
local crc32 = Crypto.HashCrc32(buf)

C++:

using Buffer = std::vector<std::byte>;
using BufferView = std::span<std::byte>;
Buffer GetBuffer(std::string_view path_name);
uint32_t HashCrc32(BufferView buf, uint32_t crc)

In C++, a vector can be implicitly converted to a span, it's just like the relationship between string and string_view.

[Lveyou]

addFunction("HashCrc32", luabridge::bind_back(&HashCrc32, 0))
this should work, isn't it working for you ?

default parameter values is a very important feature.

this is tricky for luabridge to know, maybe with C++26 metaprogramming we can, but now it's only possible this way with bind_back or with this (like pybind is doing):

addFunction("HashCrc32", &HashCrc32, luabridge::arg("buf"), luabridge::arg("crc") = 0)
but it's not available now in luabridge3

This is effective; I just wanted to ask if there is a better way to write it. I know that currently no binding library can support default function parameters (except by using Clang, likes tolua++, which is another matter). Once C++26 supports static reflection, it should also simplify quite a few things.

[kunitoki]

lua:

local buf = File.GetBuffer(value)
local crc32 = Crypto.HashCrc32(buf)
C++:

using Buffer = std::vectorstd::byte;
using BufferView = std::spanstd::byte;
Buffer GetBuffer(std::string_view path_name);
uint32_t HashCrc32(BufferView buf, uint32_t crc)
In C++, a vector can be implicitly converted to a span, it's just like the relationship between string and string_view.

The way luabridge3 works is that if you include the Vector.h you assume you want a std::vector<T> <-> lua_table{ T, ... } conversion when sending to or receiving from the stack. So from lua, there is no std::vector, only a lua table and the only way to make it a span is to materialise a vector in C++ land and forward that, but it's rather inefficient.

I suggest that instead of making type aliases like you are doing with using you define your own types that you then expose to lua, which will be way more efficient:

using Buffer = std::vector<std::byte>;

Becomes

class Buffer {
    std::vector<std::byte> data;
};

Buffer GetBuffer(std::string_view path_name);

using BufferView = std::span<std::byte>;
uint32_t HashCrc32(BufferView buf, uint32_t crc)

.beginClass<Buffer>()
    .addConstructor<void (*)()>()
.endClass()
.addFunction("HashCrc32", [](const Buffer& b) { return HashCrc32(b.data); })

this will be order of magnitude faster as you will pass around a reference and use the fast path in C++, avoiding per item conversions from vector to lua_table and vice versa.

[Lveyou]

Is it possible to achieve implicit type conversion in Lua?
For example:

void print(A a);

addConvert([](const B& b) { return (A)b; })

local b = B()
print(b)

[kunitoki]

You need to register the hierarchy in luabridge3:

luabridge::getGlobalNamespace(L)                                     
      .beginClass<A>("A").endClass()                                                                                                                                                                                  
      .deriveClass<B, A>("B").endClass()                                                                                                                                                                              
      .addFunction("print", &print);

[Lveyou]

A and B do not have an inheritance relationship. What I am thinking is that they can define a custom conversion operation, allowing implicit conversion in Lua.