Шаблоны template с ограниченными параметрами

template <class T>
class MyVec {
    std::vector<T> m_vec;
};

typeid(val) == typeid(double)

typeid(val) == typeid(MyClass1)

#include <vector>
#include <iostream>
using namespace std;
 
template <class T>
class GybridContainer
{
private:
    vector<T> vec;
    //typedef vector<T>::iterator iterator;
public:
    GybridContainer(){vec.clear();}
    void push_back(T val)
    {
        if
        (
            typeid(val) == typeid(double)
            ||
            typeid(val) == typeid(int)
        )
        {
            cout<<val<<" is added"<<endl;
            vec.push_back(val);
        }
        else
            cout<<val<<" not added"<<endl;
    }
    T at(int i)
    {
        return vec.at(i);
    }
};
 
int main()
{
    int i;
    GybridContainer<int> pInt;
    for(i = 0; i < 20; i++)
        pInt.push_back(i);
    GybridContainer<double> pDbl;
    for(i = 0; i < 20; i++)
        pDbl.push_back(1.0*i);
    GybridContainer<char> pChr;
    for(i = 0; i < 20; i++)
        pChr.push_back((char)(i + 48));
    return 0;
}

template <class T>
struct ContainerWrapper;
 
template <>
struct ContainerWrapper<int>
{
   typedef std::vector<int> TContainer;
};
 
template <>
struct ContainerWrapper<MyClass>
{
   typedef std::vector<MyClass> TContainer;
};
 
template <class T>
class MyVec
{
   ContainerWrapper<T>::TContainer;
};

template <bool clause> struct static_assert__;
template <> struct static_assert__<true> {};
#define STATIC_ASSERT(clause) enum {___ = sizeof(static_assert__<(bool)(clause)>)}
 
class Foo {
  STATIC_ASSERT(1 == 2);
};
 
int foo()
{
  STATIC_ASSERT(1 == 2);
}
 
int main()
{
  STATIC_ASSERT(1 == 2);
}

template <bool clause> struct static_assert__;
template <> struct static_assert__<true> {};
#define STATIC_ASSERT(clause) enum {___ = sizeof(static_assert__<(bool)(clause)>)}
 
template <typename T1, typename T2>
struct type_equals__ {
  static const bool value = false;
};
 
template <typename T>
struct type_equals__<T, T> {
  static const bool value = true;
};
 
#define TYPE_EQUALS(T1, T2) (type_equals__<T1, T2>::value)
 
template <class T>
class Foo {
  STATIC_ASSERT(TYPE_EQUALS(T, int) || TYPE_EQUALS(T, double));
  
  // ...
};
 
int main()
{
  Foo<int> ();
  Foo<double> ();
  Foo<char> ();
}

class Type1 {   
    ...
public:
    double Calc() {}
};
 
class Type2{
    ...
public:
    double Calc() {}
};
 
 
class Base {
public:
    virtual double Calc() = 0;
};
 
template <class T>
class MyVec {
    std::vector<T> m_vec;
    ...
    double AllCalc(){
        for(int i = 0; i < m_vec.size(); ++i)
            m_vec[i].Calc(); // хотелось бы чтобы MyVec работал только с теми типами
                         // в которых есть метод Calc()
    }
};

template <typename T1, typename T2>
struct is_same
{
  static const bool result = false;
};
 
template <typename T>
struct is_same<T, T>
{
  static const bool result = true;
};
 
 
template <typename T>
class Class
{
  template <typename U>
  struct check_method_existance
  {
    static bool result = true; // вот тут нужно имплементить. посмотреть можно у саттера или александревску.
  };
 
  template <typename U>
  struct validate_type
  {
    // набор проверок для типа сливается в одну переменную
    static const bool result = is_same<U, int>::result
                            || is_same<U, double>::result
                            || check_method_existance<U>::result
                            ;
  };
 
  STATIC_ASSERT(validate_type<T>::result);
 
public:
  Class()
  {
  }
};