Autogenerated callbacks

[gucio321]

If you were sent here from Pool panic

make sure you didn't exceed max amount of callbacks (currently 32). Also consider using ClearXXXPool if you set callback every frame/on specific event.

If you think you experience a bug, please ping me here.

read this for some implementation details.

original OP

Things like InputTextCallback should be autogenerated. I have an idea how to do this

• declare go callback type
• if C function needs callback, take go callback and convert it to uintptr via cgo.handle
• in c declare a local function (in the function that wants to pass callback to c++) and make it compatible with our destination type
• in go were should also have an exported to c function that takes uintptr (and other necessary parameters of needed). This one should just decide uintptr back to go type and call it
• local c function mentioned above calf go exported function

This workflow should allow us to autogenerate callbacks

[gucio321]

This is not possible as C doesn't support so called "deltas"

I have another Idea. I need set of "global variables" (yeah I know its awful but its C).

type Callback1;
bool Callback1_used;

[gucio321]

There is another idea posted on this thread.
its a bit tricky but may work in our case.

Impl specs.

I see it like this:

1. for each cb type generator generates N similar functions (we can default N=64 or something and add map in generator for types that requires more/less)

// extern cRet callbackX01(cArg1);
...
//export callbackX01
func callbackX01(cArg1) cRet {
   // do wrapper stuff
   return poolCallbackX.Get(1)
}

2. There is some kind of pool

type Pool[T any, CCbType any] interface {
   Allocate(x T) CCbType // this binds x with any free callbackXN and returns C.callbckXN where N is a number of function (see code above)
   Get(n int) T // used by callbackXN, where n=N. Returns T allocated by Allocate
   // Deallocate or something would be necessary too!
}

3. each callback's def looks like that:

type CallbackX func(goFriendlyArg) goFriendlyRet
type callbackXC func(cArg) cRet
var callbackXPool Pool[CallbackX, callbackXC] // note that I consider Pool as an impl not interface here.

4. With this setup, wrapper for imgui fn requiring callbacks can be e.g.:

func WrapFn(cb CallbackX) {
   C.wrap_ImGuiWrapX(callbackXPool.Allocate(cb))
}

Example impl

Here is an example implementation of Pool

NOTE This type might be easily generic but I write it with static types for clearness.

type Pool struct {
   cMap map[int]callbackXC // list of C function pointers
   cb   map[int]CallbackX // list of allocated callbacks
}

// NewPool here
func NewPool() *Pool {...}

func (p *Pool) Get(n int) {
   if c, ok := p.cb[n]; ok {
      return c
   }

   panic("some meaningful message")
}

func (p *Pool) Allocate(x CallbackX) callbackXC {
   // I see it e.g. like this
   for k, v := range p.cMap {
      if _, ok := p.cb[k]; !ok { // this means the callbck is free already
         p.cb[k] = x
         return v
      }
   }

   panic("out of pool and link to this post or the OP here")
}

Possible issues

1. You can easily run out of pool
2. I can't see any way to free unused functions (Maybe CallbackX can implement Deallocate but it'd be slow probably)
3. if there are methods requireing to call this every frame, I don't want to consider what that may cause.

@AllenDang its the only way I found now but it mignt work somehow. Could you tell me what do you think about it pls.

[AllenDang]

@gucio321 Sorry for the late reply, and after a careful reading of the context, I think your proposal is the working way to implement callback in current CGO implementation. Not ideal, but should work.