Nfy VS EA Standard Template Library

For me, the answer is a generic multicast notification system. It utilizes a template based approach that allows you to define prototype messages using a class-based interface that you wish to send to another library. For example, your input library might respond to things like a button down / up, mouse clicks, etc, etc. So you'd create an interface that defines all your input notifications as functions. I won't go into detail, because it's well documented in that link.

In my own code, I make use a generic notification system which allows high-level systems to register themselves with lower-level libraries to help invert dependencies. An example of this is how my game engine's UI library can register itself with the Input library, so it can receive mouse, keyboard, and gamepad events, necessary for manipulating UI controls. But the Game itself also needs to register for some UI events itself, not to mention debug functionality like ImGui for debug windows, etc. So I use this notification system to ensure the low-level Input library can push events out to multiple subscribers without needing to know about them.

See if this is close to what you're looking for: https://github.com/JamesBoer/Nfy

> you can still use it with smart pointers provided by any other library

Is the point of having a kitchen-sink library like this not that you dont have to reach for a 3rdparty library for things that you need 'all the time'?

Certainly, not everyone needs it.

...but, not everyone needs threads either. Not everyone needs an http server; and yet, if you have an application framework that provides them, when you do need them, it saves you reaching for yet-another-dependency.

Was that no the point from the beginning?

unique_ptr is a fundamental primitive for many, as you see from some other frameworks (1), and implementation is not always either a) trivial, or b) as simple as 'just use std::unique_ptr'.

This does seem like a very opinionated decision with reasonably unclear justification.

[1] - eg. https://github.com/EpicGames/UnrealEngine/blob/release/Engin..., https://github.com/electronicarts/EASTL/blob/master/include/...

Can I introduce you to EASTL

For games focused stuff have a look at EASTL https://github.com/electronicarts/EASTL also perhaps some of the Data Oriented Design stuff (see Mike Acton's CPP Con Talks). This also have loads of good stuff https://www.dataorienteddesign.com/dodbook/

C++, but generally treat it as C. STL is pretty slow while debugging so we avoid it and write our own replacements. If you don't want to drive that deep use something like EASTL: https://github.com/electronicarts/EASTL

In my experience game devs don't eschew the STL because of compile times, but because (a) its memory management is not sufficiently tunable and (b) it uses exceptions heavily which many game engines disable entirely due to perceived performance problems. For this reason, some of the engines I've worked on have used their own forks of the STL in the spirit of EASTL to rectify these issues. Others like my current project just don't use the STL at all (outside of some third-party library code) and use custom libraries for everything.

In my opinion, you should also benchmark it against something like boost::container::flat_set or eastl::vector_set and you should expect the same performance as with your ordered functionality. Another interesting idea for organization of such flat and sorted container can be found here.

finally, if you're worried about performance (a lot of aspiring game programmers seem to be, even though for anything but high-end engines the STL is likely fine if you know what you're doing..) you could look into the EA STL or other STL replacements..

check it out: https://github.com/electronicarts/EASTL

I just took a look at their atomic.h and wow, "well-documented" is an understatement !