clear()

[Andrei Alexandrescu]

I'm talking with Sean and Walter about taking the first step towards 
eliminating delete: defining function clear() that clears the state of 
an object. Let me know of what you think.

One problem I encountered is that I can't distinguish between a default 
constructor that doesn't need to exist, and one that was disabled 
because of other constructors. Consider:

class A {}
class B { this(int) {} }

You can evaluate "new A" but not "new B". So it's legit to create 
objects of type A all default-initialized. But the pointer to 
constructor stored in A.classinfo is null, same as B.

Any ideas?


Andrei

===============================

void clear(T)(T obj) if (is(T == class))
{
     auto defaultCtor =
         cast(void function(Object)) obj.classinfo.defaultConstructor;
     enforce(defaultCtor);
     immutable size = obj.classinfo.init.length;
     static if (is(typeof(obj.__dtor())))
     {
         obj.__dtor();
     }
     auto buf = (cast(void*) obj)[0 .. size];
     buf[] = obj.classinfo.init;
     defaultCtor(obj);
}

unittest
{
     {
         class A { string s = "A"; this() {} }
         auto a = new A;
         a.s = "asd";
         clear(a);
         assert(a.s == "A");
     }
     {
         static bool destroyed = false;
         class B {
             string s = "B";
             this() {}
             ~this() {
                 destroyed = true;
             }
         }
         auto a = new B;
         a.s = "asd";
         clear(a);
         assert(destroyed);
         assert(a.s == "B");
     }
     {
         class C {
             string s;
             this() {
                 s = "C";
             }
         }
         auto a = new C;
         a.s = "asd";
         clear(a);
         assert(a.s == "C");
     }
}

void clear(T)(ref T obj) if (is(T == struct))
{
     static if (is(typeof(obj.__dtor())))
     {
         obj.__dtor();
     }
     auto buf = (cast(void*) &obj)[0 .. T.sizeof];
     auto init = (cast(void*) &T.init)[0 .. T.sizeof];
     buf[] = init[];
}

unittest
{
     {
         struct A { string s = "A";  }
         A a;
         a.s = "asd";
         clear(a);
         assert(a.s == "A");
     }
     {
         static bool destroyed = false;
         struct B
         {
             string s = "B";
             ~this()
             {
                 destroyed = true;
             }
         }
         B a;
         a.s = "asd";
         clear(a);
         assert(destroyed);
         assert(a.s == "B");
     }
}

void clear(T : U[n], U, size_t n)(/*ref*/ T obj)
{
     obj = T.init;
}

unittest
{
     int[2] a;
     a[0] = 1;
     a[1] = 2;
     clear(a);
     assert(a == [ 0, 0 ]);
}

void clear(T)(ref T obj)
         if (!is(T == struct) && !is(T == class) && !isStaticArray!T)
{
     obj = T.init;
}

unittest
{
     {
         int a = 42;
         clear(a);
         assert(a == 0);
     }
     {
         float a = 42;
         clear(a);
         assert(isnan(a));
     }
}