[PartialCloning]

Does register_forward register the forward multiple times if it's already registered under the same function?

gForwardHandle = register_forward(FM_EmitSound , "EmitSound");

If I call that line twice is the same old handle returned by the forward or would this cause memory leaks assuming I call that line multiple times before unregistering the forward?

[klippy]

It's all fine, you can register the same one multiple times in one plugin.

[PartialCloning]

Are you sure it's all fine?

gForwardHandle = register_forward(FM_EmitSound , "EmitSound");
client_print(0, print_chat, "Handle: %d.", gForwardHandle);
gForwardHandle = register_forward(FM_EmitSound , "EmitSound");
client_print(0, print_chat, "Handle: %d.", gForwardHandle);
gForwardHandle = register_forward(FM_EmitSound , "EmitSound");
client_print(0, print_chat, "Handle: %d.", gForwardHandle);

Handle: 595. Handle: 597. Handle: 599.

[klippy]

Yes, it will be a different handle every time, that's normal. What I meant by "it's all fine" is that you can register the same forward as many times as you want. If you register it let's say two times for the same callback, the callback will be called two times.

[PartialCloning]

So to avoid that I should check if my handle is valid before registering the forward. Does unregister_forward set the handle to 0 or do I have to do that after unregistering the forward?

[klippy]

It can't set it to 0 because, as you can see just by looking at the native prototype, it doesn't pass it by reference. So you have to keep track of your handle manually.
Also, by looking at the code, register_forward() return value doesn't have to be unique - it seems that for every function you can hook there is a vector of single plugin forwards. That means that multiple of these handles can have the same value. Anything < 0 is surely an invalid handle.

[aron9forever]

Originally Posted by KliPPy Yes, it will be a different handle every time, that's normal. What I meant by "it's all fine" is that you can register the same forward as many times as you want. If you register it let's say two times for the same callback, the callback will be called two times.

sorry for reviving the old thread, but the main question was not answered and I have the same problem

I'm talking about the scenario where g_handle = register_forward() is called twice, then unregister_forward() is called only once and obviously on the latest handle, since the first one was overwritten and is now lost

what if this happens often, like, every round?

I'd just like to know if there is a point in complicating the code to check for handler and invalidating cache when unregistering, or if I can just leave it like this. To be honest my intuition would say it's not fine, but I'd like to be sure

[fysiks]

Don't register the forward twice. It should require only trivial code to prevent this.

[CrazY.]

Why do you necessarily need to register multiple forwards in the same callback?

[KiLLeR.]

Originally Posted by aron9forever what if this happens often, like, every round?

The only thing, that can happen will be too many registered forwards somewhere in the memory...
Probably, if this was expensive operation, will cause memory leaks.