root/trunk/infrastructure/pyd/generators/op_wrap.txt

template opAdd_wrap(T) {
    static if (is(typeof(&T.opAdd))) {
        const binaryfunc opAdd_wrap = &opfunc_binary_wrap!(T, T.opAdd).func;
    } else {
        const binaryfunc opAdd_wrap = null;
    }
}


template opSub_wrap(T) {
    static if (is(typeof(&T.opSub))) {
        const binaryfunc opSub_wrap = &opfunc_binary_wrap!(T, T.opSub).func;
    } else {
        const binaryfunc opSub_wrap = null;
    }
}


template opMul_wrap(T) {
    static if (is(typeof(&T.opMul))) {
        const binaryfunc opMul_wrap = &opfunc_binary_wrap!(T, T.opMul).func;
    } else {
        const binaryfunc opMul_wrap = null;
    }
}


template opDiv_wrap(T) {
    static if (is(typeof(&T.opDiv))) {
        const binaryfunc opDiv_wrap = &opfunc_binary_wrap!(T, T.opDiv).func;
    } else {
        const binaryfunc opDiv_wrap = null;
    }
}


template opMod_wrap(T) {
    static if (is(typeof(&T.opMod))) {
        const binaryfunc opMod_wrap = &opfunc_binary_wrap!(T, T.opMod).func;
    } else {
        const binaryfunc opMod_wrap = null;
    }
}


template opAnd_wrap(T) {
    static if (is(typeof(&T.opAnd))) {
        const binaryfunc opAnd_wrap = &opfunc_binary_wrap!(T, T.opAnd).func;
    } else {
        const binaryfunc opAnd_wrap = null;
    }
}


template opOr_wrap(T) {
    static if (is(typeof(&T.opOr))) {
        const binaryfunc opOr_wrap = &opfunc_binary_wrap!(T, T.opOr).func;
    } else {
        const binaryfunc opOr_wrap = null;
    }
}


template opXor_wrap(T) {
    static if (is(typeof(&T.opXor))) {
        const binaryfunc opXor_wrap = &opfunc_binary_wrap!(T, T.opXor).func;
    } else {
        const binaryfunc opXor_wrap = null;
    }
}


template opShl_wrap(T) {
    static if (is(typeof(&T.opShl))) {
        const binaryfunc opShl_wrap = &opfunc_binary_wrap!(T, T.opShl).func;
    } else {
        const binaryfunc opShl_wrap = null;
    }
}


template opShr_wrap(T) {
    static if (is(typeof(&T.opShr))) {
        const binaryfunc opShr_wrap = &opfunc_binary_wrap!(T, T.opShr).func;
    } else {
        const binaryfunc opShr_wrap = null;
    }
}


template opUShr_wrap(T) {
    static if (is(typeof(&T.opUShr))) {
        const binaryfunc opUShr_wrap = &opfunc_binary_wrap!(T, T.opUShr).func;
    } else {
        const binaryfunc opUShr_wrap = null;
    }
}


template opCat_wrap(T) {
    static if (is(typeof(&T.opCat))) {
        const binaryfunc opCat_wrap = &opfunc_binary_wrap!(T, T.opCat).func;
    } else {
        const binaryfunc opCat_wrap = null;
    }
}


template opAddAssign_wrap(T) {
    static if (is(typeof(&T.opAddAssign))) {
        const binaryfunc opAddAssign_wrap = &opfunc_binary_wrap!(T, T.opAddAssign).func;
    } else {
        const binaryfunc opAddAssign_wrap = null;
    }
}


template opSubAssign_wrap(T) {
    static if (is(typeof(&T.opSubAssign))) {
        const binaryfunc opSubAssign_wrap = &opfunc_binary_wrap!(T, T.opSubAssign).func;
    } else {
        const binaryfunc opSubAssign_wrap = null;
    }
}


template opMulAssign_wrap(T) {
    static if (is(typeof(&T.opMulAssign))) {
        const binaryfunc opMulAssign_wrap = &opfunc_binary_wrap!(T, T.opMulAssign).func;
    } else {
        const binaryfunc opMulAssign_wrap = null;
    }
}


template opDivAssign_wrap(T) {
    static if (is(typeof(&T.opDivAssign))) {
        const binaryfunc opDivAssign_wrap = &opfunc_binary_wrap!(T, T.opDivAssign).func;
    } else {
        const binaryfunc opDivAssign_wrap = null;
    }
}


template opModAssign_wrap(T) {
    static if (is(typeof(&T.opModAssign))) {
        const binaryfunc opModAssign_wrap = &opfunc_binary_wrap!(T, T.opModAssign).func;
    } else {
        const binaryfunc opModAssign_wrap = null;
    }
}


template opAndAssign_wrap(T) {
    static if (is(typeof(&T.opAndAssign))) {
        const binaryfunc opAndAssign_wrap = &opfunc_binary_wrap!(T, T.opAndAssign).func;
    } else {
        const binaryfunc opAndAssign_wrap = null;
    }
}


template opOrAssign_wrap(T) {
    static if (is(typeof(&T.opOrAssign))) {
        const binaryfunc opOrAssign_wrap = &opfunc_binary_wrap!(T, T.opOrAssign).func;
    } else {
        const binaryfunc opOrAssign_wrap = null;
    }
}


template opXorAssign_wrap(T) {
    static if (is(typeof(&T.opXorAssign))) {
        const binaryfunc opXorAssign_wrap = &opfunc_binary_wrap!(T, T.opXorAssign).func;
    } else {
        const binaryfunc opXorAssign_wrap = null;
    }
}


template opShlAssign_wrap(T) {
    static if (is(typeof(&T.opShlAssign))) {
        const binaryfunc opShlAssign_wrap = &opfunc_binary_wrap!(T, T.opShlAssign).func;
    } else {
        const binaryfunc opShlAssign_wrap = null;
    }
}


template opShrAssign_wrap(T) {
    static if (is(typeof(&T.opShrAssign))) {
        const binaryfunc opShrAssign_wrap = &opfunc_binary_wrap!(T, T.opShrAssign).func;
    } else {
        const binaryfunc opShrAssign_wrap = null;
    }
}


template opUShrAssign_wrap(T) {
    static if (is(typeof(&T.opUShrAssign))) {
        const binaryfunc opUShrAssign_wrap = &opfunc_binary_wrap!(T, T.opUShrAssign).func;
    } else {
        const binaryfunc opUShrAssign_wrap = null;
    }
}


template opCatAssign_wrap(T) {
    static if (is(typeof(&T.opCatAssign))) {
        const binaryfunc opCatAssign_wrap = &opfunc_binary_wrap!(T, T.opCatAssign).func;
    } else {
        const binaryfunc opCatAssign_wrap = null;
    }
}


template opIn_wrap(T) {
    static if (is(typeof(&T.opIn))) {
        const binaryfunc opIn_wrap = &opfunc_binary_wrap!(T, T.opIn).func;
    } else {
        const binaryfunc opIn_wrap = null;
    }
}


template opNeg_wrap(T) {
    static if (is(typeof(&T.opNeg))) {
        const unaryfunc opNeg_wrap = &opfunc_unary_wrap!(T, T.opNeg).func;
    } else {
        const unaryfunc opNeg_wrap = null;
    }
}

template opPos_wrap(T) {
    static if (is(typeof(&T.opPos))) {
        const unaryfunc opPos_wrap = &opfunc_unary_wrap!(T, T.opPos).func;
    } else {
        const unaryfunc opPos_wrap = null;
    }
}

template opCom_wrap(T) {
    static if (is(typeof(&T.opCom))) {
        const unaryfunc opCom_wrap = &opfunc_unary_wrap!(T, T.opCom).func;
    } else {
        const unaryfunc opCom_wrap = null;
    }
}