如何使用opDispatch转发到带有编译时参数的方法。请参阅以下代码：
import std.stdio;
struct B{
auto p1(T)(T arg) {
writeln( "p1: ", arg );
}
auto p2(T, int C)(T s) {
writeln( "p2: ", s, " / ", C);
}
}
struct C(T) {
T b;
auto opDispatch(string s, Args...)(Args args) {
mixin("b."~s)(args);
}
}
void main() {
C!B b;
//fine: compiler is smart enough
b.p1("abc");
//oops: "no property 'p2' for type ..."
b.p2!(int, 10)(5);
B origB;
//fine:
origB.p2!(int, 10)(5);
}
修改
用struct替换class：避免使用CTFE进行new字段初始化。这与我的问题无关。
答案 0 :(得分：7)
D模板系统非常强大。这是更通用的解决方案：
import std.stdio;
class B {
auto p1(T)(T arg) { writeln( "p1: ", arg ); }
auto p2(T, int C)(T s) { writeln( "p2: ", s, " / ", C); }
}
class C(T) {
T b = new T;
template opDispatch(string s) {
template opDispatch(TARGS...) {
auto opDispatch(ARGS...)(ARGS args) {
static if(TARGS.length) return mixin("b." ~ s ~ "!TARGS(args)");
else return mixin("b." ~ s ~ "(args)");
}
}
}
}
void main() {
auto b = new C!(B)();
b.p1("abc");
b.p2!(int, 10)(5);
}
答案 1 :(得分：1)
如果确实这对opDispatch无法实现，就像Adam D. Ruppe的回答所暗示的那样，那么你唯一的办法就是转向弦乐混音，这有点难看，但却非常强大。除非使用opDispatch是一项艰难的要求，否则字符串mixin可能是唯一的方法。
幸运的是，执行此操作的大部分工作是already done（并且它比您想象的更为复杂）。代码本身很毛茸茸，但您需要做的就是如下：
import std.stdio;
class B{
auto p1(T)(T arg) {
writeln( "p1: ", arg );
}
auto p2(T, int C)(T s) {
writeln( "p2: ", s, " / ", C);
}
}
class C(T) {
T b = new T;
mixin(forwardToMember!(b, "p1", "p2"));
}
void main() {
auto b = new C!(B)();
b.p1("abc");
//This now compiles and correctly forwards to b.b.p2
b.p2!(int, 10)(5);
}
我已经包含了下面的代码，所有的单元测试都被删除了。值得注意的是forwardToMember目前不支持常规函数的重载;它只是选择它找到的指定函数的第一个实例。我认为他们 应该为模板功能工作。
import std.traits;
import std.meta;
private alias isSomeStringType(alias str) = isSomeString!(typeof(str));
template forwardToMember(alias member, symbols...)
if (symbols.length > 0 && allSatisfy!(isSomeStringType, symbols))
{
static if (symbols.length == 1)
{
static assert(hasMember!(typeof(member), symbols[0]),
"Cannot dispatch: member '" ~ member.stringof ~
"' does not support method '" ~ symbols[0] ~ "'");
enum forwardToMember = genWrapperMixin!(member, symbols[0]);
}
else
{
enum forwardToMember = forwardToMember!(member, symbols[0]) ~ forwardToMember!(member, symbols[1..$]);
}
}
private enum SymbolKind
{
function_,
property,
templateFunction,
fieldFunction,
field,
aliasableSym,
}
//Ugly hack but there's no other way to do this
private template isTemplateFunction(f...)
if (f.length == 1)
{
import std.algorithm: among, balancedParens, canFind, count;
static if (!__traits(isTemplate, f[0]))
{
enum isTemplateFunction = false;
}
else
{
enum fstr = f[0].stringof;
//A template function's .stringof is of the format <function name>(<template args>)(<function args>)
//so match on the number of brackets to determine whether it's a template function or not
enum isTemplateFunction = __traits(isTemplate, f)
&& fstr.balancedParens('(', ')')
&& (fstr.canFind("if")
|| fstr.count!(c => cast(bool)c.among!('(', ')')) == 4);
}
}
private template getSymbolKind(Aggregate, string symbol)
{
import std.traits;
import std.typetuple;
enum getMemberMixin = "Aggregate." ~ symbol;
//Appears in Aggregate.tupleof so it must be a field
static if (staticIndexOf!(symbol, FieldNameTuple!Aggregate) > -1)
{
//Check if it's a regular field or a function pointer
static if (isSomeFunction!(mixin(getMemberMixin)))
enum getSymbolKind = SymbolKind.fieldFunction;
else
enum getSymbolKind = SymbolKind.field;
}
else
{
static if (isSomeFunction!(mixin(getMemberMixin))
&& !__traits(isStaticFunction, mixin(getMemberMixin))
|| isTemplateFunction!(mixin(getMemberMixin)))
{
static if (isTemplateFunction!(mixin(getMemberMixin)))
enum getSymbolKind = SymbolKind.templateFunction;
else static if (functionAttributes!(mixin(getMemberMixin)) & FunctionAttribute.property)
enum getSymbolKind = SymbolKind.property;
else
enum getSymbolKind = SymbolKind.function_;
}
//If it's not a member function/property then it should be an aliasable static symbol
else static if (__traits(compiles, { alias _ = Alias!(mixin(getMemberMixin)); }))
enum getSymbolKind = SymbolKind.aliasableSym;
else
static assert(0, "Error: " ~ Aggregate.stringof ~ "." ~ symbol ~ " is not a member function, field, or aliasable symbol");
}
}
private template genWrapperMixin(alias member, string symbol)
{
import std.algorithm: among;
import std.string: format;
enum symbolKind = getSymbolKind!(typeof(member), symbol);
static if (symbolKind.among!(SymbolKind.function_, SymbolKind.property, SymbolKind.fieldFunction))
{
alias MethodType = FunctionTypeOf!(mixin("member." ~ symbol));
enum funAttrs = functionAttributes!MethodType;
enum methodIsStatic = __traits(isStaticFunction, mixin("member." ~ symbol));
enum funAttrStr = getFunctionAttributeStr(funAttrs) ~ (methodIsStatic ? " static" : "");
//Workaround Issue 14913
enum returnStr = funAttrs & FunctionAttribute.return_ ? "return" : "";
enum genWrapperMixin = q{
%3$s
auto ref %2$s(ParameterTypeTuple!(FunctionTypeOf!(%1$s.%2$s)) args) %4$s
{
import std.functional: forward;
return %1$s.%2$s(forward!args);
}
}
.format(member.stringof, symbol, funAttrStr, returnStr);
}
else static if (symbolKind == SymbolKind.templateFunction)
{
enum genWrapperMixin = q{
template %2$s(TemplateArgs...)
{
auto ref %2$s(FunArgs...)(auto ref FunArgs args)
{
import std.functional: forward;
return %1$s.%2$s!(TemplateArgs)(forward!args);
}
}
}
.format(member.stringof, symbol);
}
else static if (symbolKind == SymbolKind.field)
{
alias FieldType = typeof(mixin("member." ~ symbol));
alias FA = FunctionAttribute;
enum attrStr = getFunctionAttributeStr(FA.pure_ | FA.nothrow_ | FA.safe | FA.nogc);
enum genWrapperMixin = q{
@property %3$s %4$s %1$s()
{
return %2$s.%1$s;
}
@property %3$s void %1$s(%4$s val)
{
%2$s.%1$s = val;
}
}
.format(symbol, member.stringof, attrStr, FieldType.stringof);
}
else static if (symbolKind == SymbolKind.aliasableSym)
{
enum genWrapperMixin = q{
alias %1$s = %2$s.%1$s;
}
.format(symbol, member.stringof);
}
else
static assert(member.stringof ~ "." ~ symbol ~ " has unexpected kind '" ~ symbolKind.to!string);
}
private string getFunctionAttributeStr(FunctionAttribute funAttrs)
{
import std.algorithm: among, filter, joiner, map, strip;
import std.conv: to;
string funAttrStr;
with (FunctionAttribute)
{
funAttrStr = [EnumMembers!FunctionAttribute]
.filter!(e => (funAttrs & e) && e != none && e != ref_ && e != return_)
.map!(e => e.to!string.strip('_'))
.map!(s => s.among!("safe", "trusted", "system", "nogc", "property") ? '@' ~ s : s)
.joiner(" ")
.to!string;
}
return funAttrStr;
}
答案 2 :(得分：0)
您需要使用同名模板模式，并在外部opDispatch模板中使用带有编译时参数的opDispatch函数，该模板采用常规opDispatch字符串参数。您还可以拥有多个遵循常规重载规则的内部opDispatch函数（和字段）。
import std.stdio;
struct Foo {
public template opDispatch(string name) {
public string opDispatch() {
return name;
}
public T opDispatch(T)() {
return T.init;
}
public string opDispatch(T)(string s) {
return name ~ ' ' ~ T.stringof ~ ' ' ~ s;
}
}
}
void main()
{
Foo foo;
writeln( foo.bar );
writeln( foo.baz!int );
writeln( foo.foo!Foo("foo") );
}
产生输出：
bar
0
foo Foo foo
DPaste链接：http://dpaste.dzfl.pl/6e5cfca8b702