Reference counting example

[vit]

On Tuesday, 26 April 2022 at 23:33:28 UTC, cc wrote:
> On Tuesday, 26 April 2022 at 22:16:01 UTC, cc wrote:
>> Test application:
>
> I should point out that all this stuff with saving refcounted 
> things to arrays and so on is extremely untested and 
> experimental🙄
>
> One problem I'm seeing is the inability for a refcounted class 
> to pass itself to another function, since the class internals 
> don't see the struct wrapper.. you can pass the naked object 
> reference itself, and hope the reference doesn't get saved 
> otherwise there's your dangling pointer, but then you also have 
> the problem of inconsistent method declarations, with some 
> things taking Foo and others taking RefCounted!Foo etc...
>
> Every night I pray for a `refcounted` keyword.  Wouldn't 
> something like `auto foo = new refcount Foo();` be nice?  Then 
> every class that deals with the objects could continue to be 
> allocator-agnostic... definitely not a trivial change though.

Yor code has antoher big problem. Class Animal has 
@safe/pure/nothrow/@nogc destruction but class Cow has @system 
destructor. When you assign RC!Cow to RC!Animal you can have 
@safe @nogc ... function call @system destructor of Cow.


I have library with check this kind of error for you 
(https://code.dlang.org/packages/btl).

If you need aliasing (your case) or weak pointers then try it.

```d

     import std.stdio;
     import core.memory;
     import core.lifetime;

     import btl.autoptr;
     import btl.vector;

     alias ARRAY = Vector;
     alias RC = RcPtr;

     class Animal {
         void speak() {
             writeln("Animal: ???");
         }

         ~this()@system{}   //without this code doesnt compile
     }
     class Cow : Animal {
         ARRAY!(RC!Animal) friends; // Amazingly, this works, as 
long as the array elem type is NOT the same as RC!(this class)
                                     // otherwise we get a 
forwarding error
         int x;
         this() { writefln("[Cow]"); }
         this(int x) { this.x = x; writefln("[Cow %s]", x); }
         ~this() { writefln("[/Cow %s]", x); }
         override void speak() {
             writefln("Cow#%s: Moo.", x);
         }
     }

     class Farm {
         ARRAY!(RC!Cow) animals;
         //this() {}
         this(int) { writeln("[Farm]"); }
         ~this() {
             writeln("[~Farm]");
             animals.clear();
             writeln("[/Farm]");
         }

         void pet(RC!Animal animal) {
             writefln("Farm: The %s says...", animal);
             animal.get.speak;
         }

     }

     void main() {
         auto used = GC.stats.usedSize;
         scope(exit) assert(GC.stats.usedSize == used); // GC is 
not touched!
         {
             assert(RC!Cow.make().get.x == 0);
             assert(RC!Cow.make(99).get.x == 99);
         }

         RC!Animal other;

         auto farm = RC!Farm.make(1);
         {
             auto cow = RC!Cow.make(1);
             farm.get.animals ~= cow;
             farm.get.animals ~= RC!Cow.make(2);
             other = farm.get.animals[1];
             auto cowGoesOutOfScope = RC!Cow.make(70);
         }
         writeln("out, should have seen Cow#70's dtor");

         farm.get.animals[0] = farm.get.animals[1];
         writeln("animals[0] (Cow#1) just got overwritten so we 
should have seen its dtor");

         farm.get.animals ~= RC!Cow.make(3);

         farm.get.pet(other);
         other = null;

         farm = null;

         writeln("done");
     }
```