Whenever I start writing a class which would support "shared"
methods, either there are lots of duplicate methods come into
class, synchronisation code required.
PROBLEM 1: Duplication
Look at the code below:
class NamedPipe{
private string filename;
private int mode;
public this(string filename, int mode){
// cast is used to fix `shared` problem
this.filename = cast( typeof(this.filename) )filename;
this.mode = cast( typeof(this.mode) )mode;
}
}
If I define the constructor WITHOUT "shared" keyword, and try to
create a shared object as `auto pipe = new shared
NamedPipe("/tmp/pipe", 432);`, compiler tells me, I can't do this
with shared keyword. If I define the constructor WITH "shared"
keyword, and try to create a non-shared object, again compiler
gives error. So, it is pushing me to either duplicate constructor
or do casting. Some of you may say `pure` function etc., though
if you are writing a complex class, that may not be possible. So,
duplication is inevitable.
PROBLEM 2: Synchronisation
Let's say I want to write a method that will do synchronisation
ONLY IF the method is called from a shared object.
public void updateMode( int newMode ){
// THIS IS NOT SHARED. CHANGE IT IMMEDIATELY.
mode = newMode;
}
public void updateMode( int newMode ) shared{
// THIS IS SHARED. SYNCHRONISE WHILE CHANGING.
synchronized( this ){
mode = newMode;
}
}
The above code is good, but same method is duplicated again just
to be able to enable synchronisation on shared method. So,
non-shared method can run at much higher speed if it is to be
called so many times.
CONCLUSION:
In the current implementation, duplication is almost inevitable,
and if codes are long, then God help us. Long maintenance and
error prone coding.
To be able to solve this, I thought a coding style as below:
public void foo(){
static if( is(this: shared) ){
// some of codes come here if the object is shared
}
else{
// some of codes come here if the object is not shared
}
}
But unfortunately it doesn't work in this way.
Is there really need to allow shared objects different methods,
and non-shared objects different methods? Why don't we separate
implementation instead of methods according to being shared?
