On Wednesday, 6 January 2021 at 17:05:02 UTC, ludo wrote:
...
Using a static class like this seems to mostly be a design
decision.
i.e. instead of using something like
```
openalGetMutex();
// OR
OpenAL openal = ...;
openal.getMutex();
// OR I guess even this
g_openal.getMutex();
```
They specifically want the interface to look like:
```
OpenAL.getMutex();
```
So in otherwords, this class is essentially being used as a
unique namespace for all of the other functions. Another way to
look at it is just a singleton without a `.instance` getter.
As for some of the other stuff, Associative Array literals in D
can't actually be used at compile-time (at least, last time I
tried), so they have to be created inside of the static
constructor.
Next is the mutex. `Object` is the base class that every class in
D will implicitly inherit from, like in C# for example. Object
has a `.monitor` field which is basically just a mutex, so is
used with multi-threading synchronisation. I find it a bit odd
that they're just returning an object instead of a Mutex (module
core.sync.mutex), but I'm sure there's a reason why.
(The README of this project states that this is a resurrection of
some old project, and even refers to D as "Digital Mars", so this
code may or may not have been built on a very old version of D
originally.)
A better explanation of the monitor field can be found:
https://forum.dlang.org/post/op.vqi9vrqueav7ka@steve-laptop
Hope this answers some questions.
