"Value class instance" pattern?

[bearophile]

Benjamin Thaut:

>> Trying to use ClassCompose in my code I have had some problems 
>> caused by const classes and ClassCompose dtor. Maybe such dtor
>> (and isDestructed) can be versioned out for composed-in classes
>> that only contain values...
>
> Can you give an example for that?

As a simple example try to make this work:


struct UseDefaultCtor {}
/// Call default ctor type for Composition.
enum useDefaultCtor = UseDefaultCtor();


struct Composition(T) if (is(T == class)) {
     void[__traits(classInstanceSize, T)] classInstanceBuf = void;
     bool isDestructed = false;

     @property T _instance() {
         return cast(T)classInstanceBuf.ptr;
     }

     @property const(T) _instance() const {
         return cast(const T)classInstanceBuf.ptr;
     }

     alias _instance this;

     @disable this();
     @disable this(this);

     this()(UseDefaultCtor) {
         classInstanceBuf[] = typeid(T).init[];
         _instance.__ctor;
     }

     this(Targs...)(Targs args)
     if (__traits(compiles, _instance.__ctor(args))) {
         classInstanceBuf[] = typeid(T).init[];
         _instance.__ctor(args);
     }

     ~this() {
         if (!isDestructed) {
             _instance.destroy;
             isDestructed = true;
         }
     }
}

// ----------------------------------

const class Foo {
     int x;
     this(int xx) const pure nothrow {
         this.x = x;
     }
}

const class Bar {
     const Composition!Foo f;

     this(int x) const pure nothrow {
         f = typeof(f)(x);
     }
}

void main() {}



>> Maybe such alignment can be added to the ClassCompose too.
>>
>
> But that would be a uneccessary overhead. Just adding a 
> align(4) or align(16) like suggested below would be sufficient.

I don't understand. What overhead? It's an annotation that 
depends on the contents of ClassCompose. I think it should cause 
no bad overhead.

Bye,
bearophile