RCArray is unsafe

[Zach the Mystic via Digitalmars-d]

On Wednesday, 4 March 2015 at 18:05:52 UTC, Zach the Mystic wrote:
> On Wednesday, 4 March 2015 at 17:22:15 UTC, Steven 
> Schveighoffer wrote:
>> Again, I think this is an issue with the expectation of 
>> RCArray. You cannot *save* a ref to an array element, only a 
>> ref to the array itself, because you lose control over the 
>> reference count.
>
> What you need is a special RCSlave type, which is reference 
> counted not to the type of its *own* data, but to its parent's. 
> In this case, a RCArraySlave!(T) holds data of type T, but a 
> pointer to an RCArray, which it decrements when it gets 
> destroyed. This could get expensive, with an extra pointer per 
> instance than a regular T, but it would probably be safe.

A way to do this is to have a core RCData type which has the 
count itself and the chunk of memory the count refers to in type 
ambiguous form:

struct RCData {
   int count;
   // the point is that RCData can be type ambiguous
   void[] chunk;

   this(size_t size)
   {
     chunk = new void[size];
     count = 0;
   }
   void addRef() {
     ++count;
   }
   void decRef() {
     if (count && --count == 0)
       delete chunk;
   }
}

Over top of that you create a basic element type which refcounts 
an RCData rather than itself:

struct RCType(E) {
   E element;
   RCType* data;

   this(this)
   {
     data.addRef();
   }

   ~this()
   {
     data.decRef();
   }
   [...etc...]
}

Then you have an RCArray which returns RCType elements when 
indexed rather than naked types:

struct RCArray(E) {

   E[] array;
   private RCData* data;

   RCElement!E opIndex(size_t i) return
   {
     return RCElement!E(array[start + i], data);
   }

   this(E[] a)
   {
     data = new RCData(a * sizeof(a));
     array = cast(E[]) data.chunk;

   }

   this(this)
   {
     data.addRef();
   }

   ~this()
   {
     data.decRef();
   }

   //...
}

This might work. The idea is to only leak references to types 
which also have pointers to the original data.