So I've been walking along the edges of cutting edge metatemplate programming lately, but I've hit a snag, and figured maybe someone here might have an idea...

So, anyway, first the problem.
The problem is that there is some type T whose properties I want to check. In the class constructor, this type T is known and I can check it just fine. But in the copy constructor, the type T is unknown (incomplete) due to it being a forward declaration. So I can't check its properties in the copy constructor and I want to check if type T is copyable or not.

This problem is easily reproduced by:
Code:
class foo
{
    foo(); // Forward declare this and define in source file to ensure type T is known in the constructor
    struct Impl;
    MyContainer<Impl> hello;
}
foo.cpp:
Code:
struct foo::Impl
{
    // ...
}

foo::foo() { /* ... */ }
Container.cpp:
Code:
template<typename T>
MyContainer::MyContainer()
{
    // Type T is known, so do some checks
}

MyContainer::MyContainer(const MyContainer& that)
{
    // Because copy constructor is not forward declaration, it is instantiated in the header file, so type T is unknown.
    // But I want to check its properties, especially to check if T is copyable or not. So how do I solve it?
}
My only possible idea on how to do this so far is to somehow remember state from the constructor (at compile time), such that the copy constructor can check this. But I haven't found a way how. Maybe it's not possible, but if it, I'd be very interested in knowing the how.

The only other way I can think of is let the user specify whether it's copyable or not as a parameter and verify that in the constructor so the user doesn't lie. But I'd rather not do that.

If there's some alternate way I'm not thinking of, I am of course, all ears.

Thanks.