www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Is there any way to differentiate between a type and an alias?

reply "Rene Zwanenburg" <renezwanenburg gmail.com> writes:
Given

alias GLenum = uint;
void glSomeFunction(GLenum, uint);

Now, is there some way to differentiate between GLenum and uint 
when using ParameterTypeTuple!glSomeFunction?

I'm writing a function which shows the arguments a GL function 
was called with when an error occurs. The GLenum needs to be 
printed as a stringified version of the constant's name, while 
the uint is just an uint.
May 25 2014
next sibling parent Damian Day <damianroyday gmail.com> writes:
On 25/05/2014 12:04, Rene Zwanenburg wrote:
 Given

 alias GLenum = uint;
 void glSomeFunction(GLenum, uint);

 Now, is there some way to differentiate between GLenum and uint when
 using ParameterTypeTuple!glSomeFunction?

 I'm writing a function which shows the arguments a GL function was
 called with when an error occurs. The GLenum needs to be printed as a
 stringified version of the constant's name, while the uint is just an uint.
Apparently this is deprecated even though alias cannot replicate it. typedef uint GLenum; writeln(GLenum.stringof);
May 25 2014
prev sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Sun, 25 May 2014 04:04:09 -0700, Rene Zwanenburg  
<renezwanenburg gmail.com> wrote:

 Given

 alias GLenum = uint;
 void glSomeFunction(GLenum, uint);

 Now, is there some way to differentiate between GLenum and uint when  
 using ParameterTypeTuple!glSomeFunction?

 I'm writing a function which shows the arguments a GL function was  
 called with when an error occurs. The GLenum needs to be printed as a  
 stringified version of the constant's name, while the uint is just an  
 uint.
An alias is simply another name for the same thing. There is no type difference. You may be able to do some template trickery with template aliases to detect when an alias is used. But I'd recommend using enum instead of alias: enum GLenum : uint { constant = value} This creates a genuine new type, and also gives you a place to put constants. However, it's not implicitly castable from uint, so it has some drawbacks. You can cast back to uint implicitly though. There is also a library typedef mechanism (in std.typecons perhaps?), you can look into that. It should have the same limitations as enum. -Steve
May 25 2014
parent reply "Rene Zwanenburg" <renezwanenburg gmail.com> writes:
On Sunday, 25 May 2014 at 14:40:06 UTC, Steven Schveighoffer 
wrote:
 On Sun, 25 May 2014 04:04:09 -0700, Rene Zwanenburg 
 <renezwanenburg gmail.com> wrote:

 Given

 alias GLenum = uint;
 void glSomeFunction(GLenum, uint);

 Now, is there some way to differentiate between GLenum and 
 uint when using ParameterTypeTuple!glSomeFunction?

 I'm writing a function which shows the arguments a GL function 
 was called with when an error occurs. The GLenum needs to be 
 printed as a stringified version of the constant's name, while 
 the uint is just an uint.
An alias is simply another name for the same thing. There is no type difference. You may be able to do some template trickery with template aliases to detect when an alias is used. But I'd recommend using enum instead of alias: enum GLenum : uint { constant = value} This creates a genuine new type, and also gives you a place to put constants. However, it's not implicitly castable from uint, so it has some drawbacks. You can cast back to uint implicitly though. There is also a library typedef mechanism (in std.typecons perhaps?), you can look into that. It should have the same limitations as enum. -Steve
I'm using Derelict as OpenGL binding, so I can't change the API. Derelict has chosen not to use enum so any C code sample can be used as-is. The downside is that it makes writing idiomatic D code a bit harder. For a D enum I could get the string representation using to!string, now I have to do some compile time magic. It's not really an issue though. I was wondering if there was a simple solution, but I'll just print both the uint value and string representation if any. Good enough for me :)
May 25 2014
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Sun, 25 May 2014 18:13:17 -0400, Rene Zwanenburg  
<renezwanenburg gmail.com> wrote:

 On Sunday, 25 May 2014 at 14:40:06 UTC, Steven Schveighoffer wrote:
 On Sun, 25 May 2014 04:04:09 -0700, Rene Zwanenburg  
 <renezwanenburg gmail.com> wrote:

 Given

 alias GLenum = uint;
 void glSomeFunction(GLenum, uint);

 Now, is there some way to differentiate between GLenum and uint when  
 using ParameterTypeTuple!glSomeFunction?

 I'm writing a function which shows the arguments a GL function was  
 called with when an error occurs. The GLenum needs to be printed as a  
 stringified version of the constant's name, while the uint is just an  
 uint.
An alias is simply another name for the same thing. There is no type difference. You may be able to do some template trickery with template aliases to detect when an alias is used. But I'd recommend using enum instead of alias: enum GLenum : uint { constant = value} This creates a genuine new type, and also gives you a place to put constants. However, it's not implicitly castable from uint, so it has some drawbacks. You can cast back to uint implicitly though. There is also a library typedef mechanism (in std.typecons perhaps?), you can look into that. It should have the same limitations as enum.
I'm using Derelict as OpenGL binding, so I can't change the API.Derelict has chosen not to use enum so any C code sample can be used as-is.
I get it. I don't necessarily agree with that, but it's not my library :) I think it would be difficult to achieve without changing the actual function definition. Perhaps you could wrap the functions with your own, and use your own enum type. The enum as I defined it above, should implicitly cast to uint. -Steve
May 27 2014
parent "Rene Zwanenburg" <renezwanenburg gmail.com> writes:
On Tuesday, 27 May 2014 at 18:05:24 UTC, Steven Schveighoffer 
wrote:
 I get it. I don't necessarily agree with that, but it's not my 
 library :)

 I think it would be difficult to achieve without changing the 
 actual function definition. Perhaps you could wrap the 
 functions with your own, and use your own enum type. The enum 
 as I defined it above, should implicitly cast to uint.

 -Steve
Apologies for the late reply. Manually wrapping seems a bit too heavy handed. On the other hand I have similar issues with the other Derelict libraries. For example, the GLFW_KEY_XXX enums. I'd much rather store stringified key bindings in a configuration file than raw key codes. With a bit of effort I should be able to build something that translates all these C like libraries to something more D like...
Jun 01 2014