www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Feature request: clone a class (similar to typedef)

reply coxalan <coxalan web.de> writes:
Hello!

There are situations where you want an exact clone of a class, including two
separated sets of static class members.

A first try using typedef:

import std.stdio;

class foo {
    static uint a;
}

typedef foo foo1;
typedef foo foo2;

void main() {
    foo1.a = 1;
    foo2.a = 2;
    writefln(foo1.a);
    writefln(foo2.a);
}

gives the output
2
2

So typedef gives new types foo1 and foo2, but they share the same static class
members.


A version which distinguishes the two copies by a template id:

import std.stdio;

class foo(uint id) {
    static uint a;
}


void main() {
    foo!(1).a = 1;
    foo!(2).a = 2;
    writefln(foo!(1).a);
    writefln(foo!(2).a);
}

gives the output
1
2


So basically this works.
But the problem is, that the code of the class needs to be extended by a id
template variable.


I wonder if it would make sense to introduce a new keyword, say 'clone', which
works like 'typedef', but additionally gives a new set of static class members.

coxalan
Sep 21 2007
next sibling parent reply Robert Fraser <fraserofthenight gmail.com> writes:
coxalan Wrote:

 Hello!
 
 There are situations where you want an exact clone of a class, including two
separated sets of static class members.
 
 A first try using typedef:
 
 import std.stdio;
 
 class foo {
     static uint a;
 }
 
 typedef foo foo1;
 typedef foo foo2;
 
 void main() {
     foo1.a = 1;
     foo2.a = 2;
     writefln(foo1.a);
     writefln(foo2.a);
 }
 
 gives the output
 2
 2
 
 So typedef gives new types foo1 and foo2, but they share the same static class
members.
 

I've _never_ run into this situation, and I doubt it's a common one. Certainly too limited, IMO, for a language feature.
 
 A version which distinguishes the two copies by a template id:
 
 import std.stdio;
 
 class foo(uint id) {
     static uint a;
 }
 
 
 void main() {
     foo!(1).a = 1;
     foo!(2).a = 2;
     writefln(foo!(1).a);
     writefln(foo!(2).a);
 }
 
 gives the output
 1
 2
 
 
 So basically this works.
 But the problem is, that the code of the class needs to be extended by a id
template variable.
 
 
 I wonder if it would make sense to introduce a new keyword, say 'clone', which
works like 'typedef', but additionally gives a new set of static class members.
 
 coxalan

Sep 21 2007
parent reply BCS <BCS pathlink.com> writes:
Robert Fraser wrote:
 
 I've _never_ run into this situation, and I doubt it's a common one. Certainly
too limited, IMO, for a language feature.
 

I run into it all the time when I want to create a new Exception type. I practically have "class NewExp:Exception{this(char[]c){super(c);}}" burned into my keyboard
Sep 21 2007
parent Daniel Keep <daniel.keep.lists gmail.com> writes:
BCS wrote:
 Robert Fraser wrote:
 I've _never_ run into this situation, and I doubt it's a common one.
 Certainly too limited, IMO, for a language feature.

I run into it all the time when I want to create a new Exception type. I practically have "class NewExp:Exception{this(char[]c){super(c);}}" burned into my keyboard

I feel your pain. import util.ex; // adds trailing Exception for me b/c I'm declared lazy ;) mixin NewException!("DivideByCucumber"); -- Daniel
Sep 21 2007
prev sibling parent Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
coxalan wrote:
 Hello!
 
 There are situations where you want an exact clone of a class, including two
separated sets of static class members.
 
 A first try using typedef:
 
 import std.stdio;
 
 class foo {
     static uint a;
 }
 
 typedef foo foo1;
 typedef foo foo2;
 
 void main() {
     foo1.a = 1;
     foo2.a = 2;
     writefln(foo1.a);
     writefln(foo2.a);
 }
 
 gives the output
 2
 2
 
 So typedef gives new types foo1 and foo2, but they share the same static class
members.
 
 
 A version which distinguishes the two copies by a template id:
 
 import std.stdio;
 
 class foo(uint id) {
     static uint a;
 }
 
 
 void main() {
     foo!(1).a = 1;
     foo!(2).a = 2;
     writefln(foo!(1).a);
     writefln(foo!(2).a);
 }
 
 gives the output
 1
 2
 
 
 So basically this works.
 But the problem is, that the code of the class needs to be extended by a id
template variable.
 
 
 I wonder if it would make sense to introduce a new keyword, say 'clone', which
works like 'typedef', but additionally gives a new set of static class members.
 
 coxalan

One alternative is to put the class's body into a template and then use template mixins to create several "clones": template Foo_body() { static uint a; int b; void someMethod() {} } class Foo1 { mixin Foo_body!(); } class Foo2 { mixin Foo_body!(); } -- Bruno Medeiros - MSc in CS/E student http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Sep 21 2007