On 02/28/2010 09:16 PM, Ellery Newcomer wrote:
Hello
The impetus:
I agree, except I more and more think that scope classes were a
mistake. Structs with destructors are a much better solution, and
wrapping a class inside a struct would give it RAII semantics.
The problem:
In designing a library (or rather touching up someone else's library), I
have a class (interface?) Foo, and it has a method close (actually
several methods). Almost invariably (although conceivably not always),
usage involves manipulating Foo, and then remembering to call close.
That last part is obnoxious.
One obtains a Foo from function foo.
What I'd like is for the result of foo to have RAII semantics by
default, with the possibility of nixing it if the user actually cares.
I want to take the burden of remembering that stupid close off the user.
For example:
void bar(){
auto a = foo();
a.doStuff();
}
has an implicit call to close after doStuff.
The impetus suggests I can do this by wrapping Foo inside a struct, but
I'm not so sure how well this would work out. Also note that close can
fail in a number of ways relating to file io.
So I wrote up a simple prototype.
Thoughts?
import std.stdio;
class Foo{
int k;
this(int i){
writefln("bin %d",k);
k = i;
}
void doStuff(){
writefln("do stuff %d",k);
}
void close(){
writefln("close %d",k);
}
}
struct RAII(T){
T b;
bool extracted = false;
alias b this;
this (T i){
assert(i !is null);
writeln("in");
b = i;
}
~this(){
writeln("~this");
if(!extracted) b.close();
}
T extract(){
assert(!extracted);
T t = b;
b = null;
extracted = true;
return t;
}
}
RAII!(Foo) foo(int i){
return RAII!(Foo)(new Foo(i));
}
void main(){
auto a = foo(1);
auto b = foo(2).extract();
a.doStuff();
b.doStuff();
}
Maybe something along the lines of this
struct RAII(T : Object){
T b;
alias b this;
void delegate(T) destroyer;
this (T i, void delegate(T) called_at_exit){
b = i;
destroyer = called_at_exit;
}
~this(){
if (b) destroyer(b);
}
T extract(){
T t = b;
b = null;
return t;
}
}
class Foo {
this() { }
void close() {
writeln("closed.");
}
}
RAII!Foo foo() {
return RAII!Foo(new Foo, (Foo f) {f.close;});
}
for a slightly more generalized RAII struct, which works on classes only.
