I have roughly the following code in C++ (vastly simplified from reality):

template<typename T>
class Wrapper {
private:
  T t;
  bool valid;

public:
  bool isValid() { return valid; }
};


template<>
class Wrapper\<void> {
private:
  bool valid;

public:
  bool isValid() { return valid; }
};

I can bind Wrapper<T> from D with no problem:

extern(C++, class)
class Wrapper(T) {
  private T t;
  private bool valid;
  public final isValid();
}

But how can I bind Wrapper<void> in D? Specifically, how do I even express that template specialization in D syntax?

Gregor

On Wednesday, 28 February 2024 at 22:48:33 UTC, Gregor Mückl wrote:

Did you mean any of these?

1. Parameter specialization:

extern(C++, class):
class Wrapper(T) {...}
class Wrapper(T : void) {...}

2. Template constraints:

extern(C++, class):
class Wrapper(T) if(!is(T == void)) {...}
class Wrapper(T) if(is(T == void)) {...}

3. static if:

extern(C++, class)
class Wrapper(T) {
  static if (!is(T == void))
    private T t;
  private bool valid;
  public final isValid();
}

On Thursday, 29 February 2024 at 10:30:59 UTC, DUser wrote:

extern(C++, class):
class Wrapper(T) {...}
class Wrapper(T : void) {...}

extern(C++, class):
class Wrapper(T) if(!is(T == void)) {...}
class Wrapper(T) if(is(T == void)) {...}

extern(C++, class)
class Wrapper(T) {
  static if (!is(T == void))
    private T t;
  private bool valid;
  public final isValid();
}

Thanks! This got me unstuck. I've picked the first solution. It mirrors the C++ code nicely.

The embarrassing part is that I should have known the other two options, but my head got completely stuck trying to convert C++ to D too literally.