Russian Qt Forum

C++ (Qt)
template <class ...Args>
class variant
{
...
};
 

C++ (Qt)
typedef variant<int, float, long, double, short, std::string> variant_t;
 

C++ (Qt)
template <class T, class ...Args>
struct num_args
{
    static constexpr int value = num_args<Args...>::value + 1;
};
 
template <class T>
struct num_args<T>
{
    static constexpr int value = 1;
};
 

C++ (Qt)
template <class T>
struct num_args<T>
{
    static constexpr int value = 1;
};
 

C++ (Qt)
std::cout << type_id<double,        double, int, short>::value // вернёт 0
 
std::cout << type_id<int,           double, int, short>::value // вернёт 1
 
std::cout << type_id<short,         double, int, short>::value // вернёт 2
 
std::cout << type_id<std::string,   double, int, short>::value // вернёт bad_id, поскольку в списке нет класса std::string 
 

C++ (Qt)
template <class T, class Arg1, class ...Args>
struct type_id_helper
{
    static constexpr int value = (std::is_same<T, Arg1>::value) ? num_args<Arg1, Args...>::value : type_id_helper<T, Args...>::value;
};
 
template <class T, class Arg>
struct type_id_helper<T, Arg>
{
    static constexpr int value = (std::is_same<T, Arg>::value) ? 1 : -1;
};
 
// type_id_helper::value возвращает индексы для типов в обратном порядке, а нам хочется чтобы они начинались с нуля:
 
template <class T, class ...Args>
struct type_id
{
    static constexpr int bad_id = -1;
 
    static constexpr int value = (type_id_helper<T, Args...>::value > -1) ? num_args<Args...>::value - type_id_helper<T, Args...>::value : bad_id;
};
 

C++ (Qt)
template <class ...Args>
class variant
{
private:
struct holder_base
    {
        holder_base(int _id) : id(_id) {}
        virtual ~holder_base() {}
        int id;
    };
 
    template <class T>
    struct holder : holder_base
    {
        holder(const T & _data, int _id) : holder_base(_id), data(_data) {}
        T data;
    };
 
    std::shared_ptr<holder_base> _holder;
};
 

C++ (Qt)
template <class T>
    bool is_type() const
    {
        return (_holder) ? detail::type_id<T, Args...>::value == _holder->id : false;
    }
 

C++ (Qt)
template <size_t N, class T, class ...Args>
struct type_for_id : public type_for_id<N-1,  Args...>
{};
 
template <class T, class...Args>
struct type_for_id<0, T, Args...>
{
    typedef T type;
};
 

C++ (Qt)
typename type_for_id<0,  double, int, std::string>::type d = 3.1415; // double
typename type_for_id<1,  double, int, std::string>::type i = 10; // int
typename type_for_id<2,  double, int, std::string>::type str = "hello-hello";
 

C++ (Qt)
template <class ...Args>
class variant
{
...
private:
    template <class Visitor>
    typename Visitor::result_type apply_visitor(Visitor visitor) throw (std::runtime_error)
    {
        if (!_holder)
            throw std::runtime_error("variant::apply_visitor: variant is empty");
 
        #define APPLY_VISITOR(n) return visitor(get_p<typename detail::type_for_id<n, Args...>::type>());
 
        STATIC_SWITCH(_holder->id, APPLY_VISITOR);
 
        return typename Visitor::result_type();
    }
};
 

C++ (Qt)
 #define APPLY_VISITOR(n) return visitor(get_p<typename detail::type_for_id<n, Args...>::type>());
 

C++ (Qt)
STATIC_SWITCH(_holder->id, APPLY_VISITOR);
 

C++ (Qt)
switch (_holder->id)
{
case 0: return visitor(get_p<typename detail::type_for_id<0, Args...>::type>()); break;
case 1: return visitor(get_p<typename detail::type_for_id<1, Args...>::type>()); break;
case 2: return visitor(get_p<typename detail::type_for_id<2, Args...>::type>()); break;
case 3: return visitor(get_p<typename detail::type_for_id<3, Args...>::type>()); break;
....
default: break;
}
 

C++ (Qt)
template <class R>
struct static_visitor
{
    typedef R result_type;
};
 
 
template <class Visitor, class Visitable>
typename Visitor::result_type apply_visitor(Visitor visitor, Visitable & v)
{
    return v.apply_visitor(visitor);
}
 

C++ (Qt)
struct my_visitor : public static_visitor<int>
{
    int operator()(int val) const
    {
        std::cout << val << std::endl;
        return val;
    }
 
    int operator()(const double & val) const
    {
        std::cout << val << std::endl;
        return val;
    }
};
 
 
typedef variant<int, double> variant_t;
 
...
 
variant_t v1 = 10;
variant_t v2 = 3.14;
 
apply_visitor(my_visitor(), v1);
apply_visitor(my_visitor(), v2);
 

C++ (Qt)
    variant_t v1 = 3.14;  // double
    variant_t v2 = 10;  // int
    variant_t v3 = 23234L; // long
 
    double dval = variant_cast<double>(v1);
    int ival = variant_cast<int>(v3);
    ... 
 

C++ (Qt)
struct Point3d { double x, y, z; }
struct Point3f { float x, y, z; }
struct Color3u { uchar r, g, b; }
struct Color4u { uchar a, r, g, b; }

C++ (Qt)
struct Model {
 vector <Point3d> mCoord;
 vector <Point3f> mUV;
 vector <Color3u> mColor;
...
};

C++ (Qt)
struct Model {
 Container * mCoord;
 vector <Container *>  mAttribute;
};
 
struct Container {
 virtual size_t size( void ) const = 0;
 ...
}
 
template <class T>
struct TypedContainer : public Container {
 virtual size_t size( void ) const { return mData.size(); }
 
// data
  vector <T> mData;
};
 

C++ (Qt)
if (data_double)
 model.mCoord = new TypedContainer <Point3d>;
else  
 model.mCoord = new TypedContainer <Point3f>;
if (hasUV)
 model.mAttribute.push_back(new TypedContainer <Point3f>);
 

C++ (Qt)
template <class T>
void Model::Interpolate( vector <T> & vec, size_t index1, size_t index2 )
{
 vec.push_back((vec[index1] + vec[index2]) / 2);
}
 

C++ (Qt)
void Model::Interpolate( Container & vec, size_t index1, size_t index2 )
{
  ?????
}
 

C++ (Qt)
template <class ...Args>
class variant_container
{
...
};
 
...
 
typedef variant_container<Point3d, Point3f, Color3u, Color4u> my_variant_container_type;
 

C++ (Qt)
template <class ...Args>
class variant_container
{
public:
    size_t size() const { ... }
    template <class T>
    const T& operator[](size_t i) const { ... }
...
private:
struct holder_base
    {
        holder_base(int _id) : id(_id) {}
        virtual ~holder_base() {}
        int id;
    };
 
    template <class T>
    struct holder : holder_base
    {
        holder(const std::vector<T> & _data, int _id) : holder_base(_id), data(_data) {}
        std::vector<T> data;
    };
 
    std::shared_ptr<holder_base> _holder;
};
 

C++ (Qt)
typedef variant_container<Point3d, Point3f, Color3u, Color4u> my_variant_container_type;
 

C++ (Qt)
struct interpolate : public static_visitor<void>
{
    interpolate(size_t _index1, size_t _index2) : index1(_index1), index2(_index) {}
 
    template <class Container>
    void operator()(Container & vec) const 
    {
         vec.push_back((vec[index1] + vec[index2]) / 2);)
    }
 
private:
   size_t index1, index2;
};
 
typedef variant_container<vector<Point3d>, vector<Point3f>, vector<Color3u>, vector<Color4u> > my_variant_container_type;
 

C++ (Qt)
struct interpolate : public static_visitor<void>
{
    interpolate(size_t _index1, size_t _index2) : index1(_index1), index2(_index) {}
 
    template <class Container>
    void operator()(Container & vec) const 
    {
         vec.push_back((vec[index1] + vec[index2]) / 2);)
    }
 
private:
   size_t index1, index2;
};
 
typedef variant_container<vector<Point3d>, vector<Point3f>, vector<Color3u>, vector<Color4u> > my_variant_container_type;
 

C++ (Qt)
void DoCopy( const my_variant_container_type & src, my_variant_container_type & dst )
{
 for (size_t i = 0; i < dst.size(); ++i)
  dst[i] = src[i];
}