www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Magic type return

reply Andrea Fontana <nospam example.com> writes:
class Known
{
         void* data; // external data by c api
         int type;  // 0 for int, 1 for string, etc. ..
}

How can I implement a method like this?

Known  known;  // <-- suppose known.type =3D=3D 1;
string s  =3D known.value(); // <-- automatic=20

I just know how to do this:

string s =3D know.value!string();=20
Jul 17 2012
next sibling parent reply "Tobias Pankrath" <tobias pankrath.net> writes:
On Tuesday, 17 July 2012 at 13:56:29 UTC, Andrea Fontana wrote:

 class Known
 {
          void* data; // external data by c api
          int type;  // 0 for int, 1 for string, etc. ..
 }

 How can I implement a method like this?

 Known  known;  // <-- suppose known.type == 1;
 string s  = known.value(); // <-- automatic

 I just know how to do this:

 string s = know.value!string();


You can't. You could do

string s;
known.value(s);

where

void value(T)(ref T t);
Jul 17 2012
parent Andrea Fontana <nospam example.com> writes:
Better than nothing :)
Hope in better template deduction...

Il giorno mar, 17/07/2012 alle 16.22 +0200, Tobias Pankrath ha scritto:


 On Tuesday, 17 July 2012 at 13:56:29 UTC, Andrea Fontana wrote:

 class Known
 {
          void* data; // external data by c api
          int type;  // 0 for int, 1 for string, etc. ..
 }

 How can I implement a method like this?

 Known  known;  // <-- suppose known.type =3D=3D 1;
 string s  =3D known.value(); // <-- automatic

 I just know how to do this:

 string s =3D know.value!string();


=20
 You can't. You could do
=20
 string s;
 known.value(s);
=20
 where
=20
 void value(T)(ref T t);
Jul 17 2012
prev sibling next sibling parent reply "bearophile" <bearophileHUGS lycos.com> writes:
Andrea Fontana:


 class Known
 {
          void* data; // external data by c api
          int type;  // 0 for int, 1 for string, etc. ..
 }

 How can I implement a method like this?

 Known  known;  // <-- suppose known.type == 1;
 string s  = known.value(); // <-- automatic


To do this Known.value() needs to return different types 
according to the run-time value of Known.type. This is not 
possible in a statically typed language... You need to find other 
solutions.

Bye,
bearophile
Jul 17 2012
parent reply "Regan Heath" <regan netmail.co.nz> writes:
On Tue, 17 Jul 2012 15:23:05 +0100, bearophile <bearophileHUGS lycos.com>  
wrote:


 Andrea Fontana:


 class Known
 {
          void* data; // external data by c api
          int type;  // 0 for int, 1 for string, etc. ..
 }

 How can I implement a method like this?

 Known  known;  // <-- suppose known.type == 1;
 string s  = known.value(); // <-- automatic


 To do this Known.value() needs to return different types according to  
 the run-time value of Known.type. This is not possible in a statically  
 typed language... You need to find other solutions.


Unless we had overload based on return type, right?

e.g.

class Known
{
   string value()
   {
     if (type != 1)
       throw..;
     return cast(string)data;
   }

   int value()
   {
     if (type != 0)
       throw ..;
     return cast(int)data;
   }
}

The compiler could produce the correct code/call for the line

string s = known.value();

then, but it's not a feature we're likely to see any time soon.

R

-- 
Using Opera's revolutionary email client: http://www.opera.com/mail/
Jul 18 2012
parent Andrea Fontana <nospam example.com> writes:
Or template inference based on return type like

T hello(T)()
{
    static if (is(T =3D=3D)) ....

}

string v =3D hello();

Il giorno mer, 18/07/2012 alle 17.38 +0100, Regan Heath ha scritto:


 On Tue, 17 Jul 2012 15:23:05 +0100, bearophile <bearophileHUGS lycos.com>=


 =20

 wrote:
=20

 Andrea Fontana:


 class Known
 {
          void* data; // external data by c api
          int type;  // 0 for int, 1 for string, etc. ..
 }

 How can I implement a method like this?

 Known  known;  // <-- suppose known.type =3D=3D 1;
 string s  =3D known.value(); // <-- automatic


 To do this Known.value() needs to return different types according to =




=20

 the run-time value of Known.type. This is not possible in a statically =




=20

 typed language... You need to find other solutions.


=20
 Unless we had overload based on return type, right?
=20
 e.g.
=20
 class Known
 {
    string value()
    {
      if (type !=3D 1)
        throw..;
      return cast(string)data;
    }
=20
    int value()
    {
      if (type !=3D 0)
        throw ..;
      return cast(int)data;
    }
 }
=20
 The compiler could produce the correct code/call for the line
=20
 string s =3D known.value();
=20
 then, but it's not a feature we're likely to see any time soon.
=20
 R
=20
Jul 19 2012
prev sibling next sibling parent Mirko Pilger <pilger cymotec.de> writes:
i'm not completely sure i understand your problem but i think you are 
looking for something like this:

http://pocoproject.org/docs/Poco.DynamicAny.html

maybe the c++ source code could be of some inspiration. this should be 
possible in d, too.
Jul 17 2012
prev sibling parent reply Philippe Sigaud <philippe.sigaud gmail.com> writes:
 class Known
 {
          void* data; // external data by c api
          int type;  // 0 for int, 1 for string, etc. ..
 }

 How can I implement a method like this?

 Known  known;  // <-- suppose known.type == 1;
 string s  = known.value(); // <-- automatic

 I just know how to do this:

 string s = know.value!string();


As bearophile said, you cannot change a value's type (which is a
compile-time construct) with a runtime value, as is Known.type.

Second point, in D, the rhs is fully evaluated before being assigned to the
lhs, I think. So, known.value() must evaluate to *something*, without
knowing it will be assigned to a string.
In your example, what happens if known.type != 1?

You can use Phobos Variant, (or Algebraic if the range of types you plan to
use is known beforehand). Then, you should test typeid before using it.
Jul 18 2012
parent Andrea Fontana <nospam example.com> writes:
Yes I did it using Variant and it works fine

Il giorno mer, 18/07/2012 alle 16.42 +0200, Philippe Sigaud ha scritto:


 class Known
 {
          void* data; // external data by c api
          int type;  // 0 for int, 1 for string, etc. ..
 }

 How can I implement a method like this?

 Known  known;  // <-- suppose known.type =3D=3D 1;
 string s  =3D known.value(); // <-- automatic=20

 I just know how to do this:

 string s =3D know.value!string();=20


=20
 As bearophile said, you cannot change a value's type (which is a
 compile-time construct) with a runtime value, as is Known.type.=20
=20
 Second point, in D, the rhs is fully evaluated before being assigned
 to the lhs, I think. So, known.value() must evaluate to *something*,
 without knowing it will be assigned to a string.
 In your example, what happens if known.type !=3D 1?=20
=20
 You can use Phobos Variant, (or Algebraic if the range of types you
 plan to use is known beforehand). Then, you should test typeid before
 using it.
=20
Jul 18 2012