Динамическое использование пространства имен на основе параметра шаблона

Question

Я не знаю, возможно ли это вообще, но этого я хотел бы достичь: в шаблоном классе я хотел бы использовать пространство имен параметра шаблона ,

например.

template<class P> 
class Foo 
{ 
    public: 
     Foo(); 
     virtual ~Foo(); 

     void doSomething(P&); 
     void doSomethingElse(); 

    protected: 
     // There I'm hardcoding "namespace1" but that's what I'd like to 
     // be possibly dynamic 
     // (I'm assuming template parameter P = namespace1::Type) 
     void method1(namespace1::Type1&); 
     ... 
     void methodN(namespace1::TypeN&); 
} 

// Again, supposing P == namespace1::Type then I want to be using namespace1 
// everywhere in the implementation... 
using namespace namespace1; 

template<class P> 
void Foo<P>::doSomething(P& parameter) 
{ 
    ... 
    Type1 type1 = P.getType1(); // There namespace1::Type1 is returned !! 
    method1(type1); 
    ... 
} 

template<class P> 
void Foo<P>::doSomethingElse() 
{ 
    ... 
    TypeN typen; // There I want to instanciate a namespace1::TypeN !! 
    ... 
} 

... 

Конечно, я не хочу, чтобы специализировать шаблон и обеспечить специальную реализацию для каждого возможного P значения, а также я хотел бы избежать прохождения всех типов как Type1 и TypeN в качестве параметров шаблона, так как я потенциально их много.

Возможно ли это?

Проект основан на C++ 3, любое решение для ускорения приветствуется.

Update

Будучи параметр шаблона P сам точно так же как любой TypeN параметра, это может быть правильный подход:

template<typename NAMESPACE> 
class Foo 
{ 
    typedef typename NAMESPACE::Parameter MyParameter; 
    typedef typename NAMESPACE::Type1 MyType1; 
    typedef typename NAMESPACE::Type1 MyTypeN; 
    ... 
} 

Answer 1

Да и №

Да можно вывести вторичные виды из первичного одного, как правило, с использованием системы признака:

template <typename T> struct Trait { typedef typename T::Secondary Secondary; }; 

template <typename X> 
struct Foo { 
    typedef typename Trait<X>::Secondary Secondary; 

    void foo(Secondary const& s); 
}; 

Нет, вы не можете вывести пространство имен и, следовательно, не может использовать it; но обратите внимание, как с помощью локального псевдонима (typedef ...) в классе нет необходимости.

Answer 2

Нет, это невозможно, но вы можете использовать уродливый файл макросов.

//my_class.inl 
template<TYPE_ARG> 
struct my_class_t<TYPE_ARG> 
{ 
    foo() 
    { 
     NS_ARG::bar(); 
    } 
} 

//my.h 
template<class T> 
struct my_class_t{}; 

#define TYPE_ARG T1 
#define NS_ARG std 
#include "my_class.inl" 

#define TYPE_ARG T2 
#define NS_ARG boost 
#include "my_class.inl" 

#undef TYPE_ARG 
#undef NS_ARG 

Таким образом, вы будете автоматизировать специализацию классов для разных пространств имен. Вам это действительно нужно? : О)

Answer 3

Если вы готовы добавить структуру внутри каждого пространства имен, в котором перечислены все типы, вам нужно, вы можете рассчитывать на ADL, чтобы получить эту структуру в зависимости от параметра шаблона:

#include <iostream> 
#include <utility> 

namespace Foo_ns 
{ 
    struct T1 
    { 
     static void m() { std::cout << "Foo_ns::T1" << '\n'; } 
    }; 
    struct Foo {}; 

    // List of all the types you need from this namespace 
    struct Types 
    { 
     typedef Foo_ns::T1 T1;   
    }; 

    // dummy function needed for ADL   
    Types types(...); 
} 

namespace Bar_ns 
{ 
    struct T1 
    { 
     static void m() { std::cout << "Bar_ns::T1" << '\n'; } 
    }; 
    struct Bar {}; 

    struct Types 
    { 
     typedef Bar_ns::T1 T1; 
    }; 

    Types types(...); 
} 

template <typename T> 
void callMOnT1(const T &arg) 
{ 
    typedef decltype(types(std::declval<T>())) Types; // ADL kicks in 
    //typedef typename std::result_of<types(T)>::type Types; 
    Types::T1::m(); 
} 

int main() 
{ 
    callMOnT1((Bar_ns::Bar())); // Bar_ns::T1 
    callMOnT1((Foo_ns::Foo())); // Foo_ns::T1 
} 

К сожалению, это решение используя некоторые возможности C++ 11 (а именно decltype и declval). По какой-то причине мне не удалось заставить код работать с result_of, который присутствует в Boost (возможно, кто-то мог объяснить, почему код с result_of не компилируется?).