www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Wrapper Struct

reply Salih Dincer <salihdb hotmail.com> writes:
I want to have a wrapper structure for the variables I want to 
protect, but in D I can't do it the way I want. It doesn't work 
in W1 Test's constructor, but it works in main():

```d
struct W1(T) {
   private T value;

   alias getset this;

    property T getset(T v)
   {
     return value = v;
   }

    property T getset() inout
   {
     return value;
   }
}

struct W1test {
   W1!int i;

   this(int i) {
     this.i = i;/* doesn't work
     this.i.getset = i; //*/
   }
}

void main()
  {
   import std.stdio;

   W1!int w1;
   w1 = 1;
   w1.writeln;

   auto w1Test = W1test(2);
   w1Test.writeln;
}
```

What do I do when this doesn't work the way I want! I need to 
upgrade to a new version (W2) which I did with opCall():

```d
struct W2(T) {
   private T value;

   alias opCall this;

    property T opCall(T v)
   {
     return value = v;
   }

    property T opCall() inout
   {
     return value;
   }
}

struct W2test {
   W2!int i;

   this(int i) {
     //this.i = i;/* doesn't work
     this.i(i); //*/
   }
}

void main()
  {
   import std.stdio;

   W2!int w2;
   w2 = 2;
   w2.writeln;

   auto w2Test = W2test(3);
   w2Test.writeln;
}
```

Yes except one thing, I don't need to know getset() now and 
everything is as I want:

Why do I need to use parentheses when inside the constructor? 
Because when I'm in main() I can use it like a regular variable!

SDB 79
Dec 20 2022
parent reply rikki cattermole <rikki cattermole.co.nz> writes:
This may be what you want: https://dlang.org/phobos/std_typecons.html#Proxy
Dec 21 2022
parent Salih Dincer <salihdb hotmail.com> writes:
On Wednesday, 21 December 2022 at 15:02:42 UTC, rikki cattermole 
wrote:
 This may be what you want: 
 https://dlang.org/phobos/std_typecons.html#Proxy
Thank you, now no need proxy! It's works: ```d void main() { import std.stdio; auto p1 = Point(1, 2); auto p2 = Point(10, 20); writeln(p1 + p2); class Foo {    NP!Point point;    this(double x = 0.0, double y = 0.0) {      point = Point(x, y);   } }  auto foo = new Foo(0.1234, 567.89); writeln(foo.point + p2); } struct NP(T) { // NP: No Proxy private T value; this(T x) { value = x; } alias opCall this; property opCall() inout { return value; } property opCall(T x) { return value = x; } } struct Point {  double x, y; pure const nothrow safe: auto opBinary(string op)(in Point rhs) nogc { return Point(mixin("x" ~ op ~ "rhs.x"), mixin("y" ~ op ~ "rhs.y")); } auto opBinary(string op)(int rhs) nogc { return Point(mixin("x" ~ op ~ "rhs"), mixin("y" ~ op ~ "rhs")); } } ```
Dec 22 2022