Synchronisation help

[Anonymouse]

On Monday, 1 January 2024 at 19:49:28 UTC, Jonathan M Davis wrote:
> [...]

Thank you. Yes, `Foo` is a class for the purposes of inheritance 
-- I left that out of the example.

So a completely valid solution is to write a struct wrapper 
around an AA of the type I need, overload the required operators, 
and then just drop-in replace the current AA? All array 
operations would then transparently be between lock and unlock 
statements.

```d
struct MutexedAA(AA : V[K], V, K)
{
     import core.sync.mutex : Mutex;

     shared Mutex mutex;

     shared AA aa;

     void setup() nothrow
     {
         mutex = new shared Mutex;

         mutex.lock_nothrow();

         if (K.init !in (cast()aa))
         {
             (cast()aa)[K.init] = V.init;
             (cast()aa).remove(K.init);
         }

         mutex.unlock_nothrow();
     }

     auto opIndexAssign(V value, K key)
     in (mutex, typeof(this).stringof ~ " has null Mutex")
     {
         mutex.lock_nothrow();
         (cast()aa)[key] = value;
         mutex.unlock_nothrow();
         return value;
     }

     auto opIndex(K key)
     in (mutex, typeof(this).stringof ~ " has null Mutex")
     {
         mutex.lock_nothrow();
         auto value = (cast()aa)[key];
         mutex.unlock_nothrow();
         return value;
     }

     auto opBinaryRight(string op : "in")(K key)
     in (mutex, typeof(this).stringof ~ " has null Mutex")
     {
         mutex.lock_nothrow();
         auto value = key in cast()aa;
         mutex.unlock_nothrow();
         return value;
     }

     auto remove(K key)
     in (mutex, typeof(this).stringof ~ " has null Mutex")
     {
         mutex.lock_nothrow();
         auto value = (cast()aa).remove(key);
         mutex.unlock_nothrow();
         return value;
     }

     auto opEquals()(auto ref typeof(this) other)
     in (mutex, typeof(this).stringof ~ " has null Mutex")
     {
         mutex.lock_nothrow();
         auto isEqual = (cast()aa == cast()(other.aa));
         mutex.unlock_nothrow();
         return isEqual;
     }

     auto opEquals()(auto ref AA other)
     in (mutex, typeof(this).stringof ~ " has null Mutex")
     {
         mutex.lock_nothrow();
         auto isEqual = (cast()aa == other);
         mutex.unlock_nothrow();
         return isEqual;
     }
}
```

(https://gist.github.com/zorael/433c50f238b21b9bb68d076d8a495045)

I tried this and it seems to work. Is it glaringly incorrect 
somehow, or am I free to roll with this?

You mention passing a `shared Foo*`. In the gist I pass the 
instance of the `MutexedAA!(string[int])` to the worker thread 
*by value* instead of as something `shared`, since I couldn't get 
operator overloading to work when `shared`. (Calling 
`sharedAA.opIndexAssign("hello", 42)` worked, but `sharedAA[42] = 
"hello"` wouldn't compile.)

I guess this can break synchronisation between the two if I 
replace the `Mutex` in either thread. Are there any other obvious 
caveats?