Russian Qt Forum

C++ (Qt)
#include <iostream>
#include <list>
#include <string>
 
#include "any_visitor.h"
#include <boost/any.hpp>
 
 
struct to_double : public any_visitor<double, type_list<double, int, float,  std::string>> /* Первый аргумент - возвращаемый тип, второй - список всех возможных типов, для хранимого в any значения. 
                                                                                          Если нужный тип не будет найден, из этого списка, будет выкинуто исключение std::bad_cast. */
{
    double operator()(const std::string & str) const { return std::stod(str); }
 
    template <class T>
    double operator()(const T & val) const { return val; }
};
 
 
struct to_string : public any_visitor<std::string, type_list<double, int, float, std::string>>
{
    std::string operator()(const std::string & str) const { return str; }
 
    template <class T>
    std::string operator()(const T & val) const { return std::to_string(val); }
};
 
 
 
int main()
{
 
   std::list<boost::any> many = {123, 3.14, 5.6f, std::string("2.71")}; 
 
   double sum = 0.0;
 
   for (const auto & x : many)
       sum += apply_any_visitor(to_double(), x); // считаем сумму элементов
 
   std::cout << sum << std::endl;
 
   std::string str;
   for (const auto & x : many)
       str += apply_any_visitor(to_string(), x) + "; "; // Объединяем строки
 
   std::cout << str << std::endl;
 
    return 0;
}
 

C++ (Qt)
std::list<boost::any> many = {123, 3.14, 5.6f, std::string("2.71")}; 
 

C++ (Qt)
double sum = 0.0;
 
   for (const auto & x : many)
       sum += apply_any_visitor(to_double(), x); // считаем сумму элементов
 

C++ (Qt)
std::string str;
   for (const auto & x : many)
       str += apply_any_visitor(to_string(), x) + "; "; // Объединяем строки
 

C++ (Qt)
type_list<double, int, float,  std::string>
 

C++ (Qt)
template < typename _Type >
struct to_double_helper;
 
template <>
struct to_double_helper< double >
{
    static double execute ( const boost::any & value )
    {
        return boost::any_cast< double >( value );
    }
};
 
template <>
struct to_double_helper< std::string >
{
    static double execute ( const boost::any & value )
    {
        return std::stod( boost::any_cast< std::string >( value ) );
    }
};
 
double to_double ( const boost::any & value )
{
    if ( value.type() == typeid( double ) )
        return to_double_helper< double >::execute( value );
    if ( value.type() == typeid( std::string ) )
        return to_double_helper< std::string >::execute( value );
    //...
 
 
    return 0;
}
 
int main()
{
    std::list< boost::any > many = {123, 3.14, 5.6f, std::string("2.71")};
    double sum = 0.0;
 
    for ( const auto & x : many )
        sum += to_double( x );
 
    std::cout << sum << std::endl;
    return 0;
}
 

C++ (Qt)
typedef double ( *to_double_function )( const boost::any & );
 
to_double_function to_double_function_for_type ( const std::type_info & type )
{
    to_double_function result = to_double_function();
    //...
    return result;
}
 
double to_double ( const boost::any & value )
{
    return (*to_double_function_for_type( value.type() ) )( value );
}
 

C++ (Qt)
...
double to_double ( const boost::any & value )
{
    if ( value.type() == typeid( double ) )
        return to_double_helper< double >::execute( value );
    if ( value.type() == typeid( std::string ) )
        return to_double_helper< std::string >::execute( value );
    //...
 
 
    return 0;
}
 

C++ (Qt)
typedef type_list<double, int, float,  std::string> default_type_list;
 
struct to_double : public any_visitor<double, default_type_list>
{
    double operator()(const std::string & str) const { return std::stod(str); }
 
    template <class T>
    double operator()(const T & val) const { return val; }
};
 

C++ (Qt)
struct to_double_advance : public any_visitor<double, merge<std::complex<double>, default_type_list>::type>
{
    double operator()(const std::complex<double> & c) const { return c.real(); }
 
    template <class T>
    double operator()(const T & val) const { return to_double()(val); }
};
 

C++ (Qt)
std::list<boost::any> many = {123, 3.14, 5.6f, std::string("2.71"), std::complex<double>(123.4, 5.6)};
 
       double sum = 0.0;
 
       for (const auto & x : many)
           sum += apply_any_visitor(to_double_advance(), x);
 
       std::cout << sum << std::endl;
 

C++ (Qt)
struct CData {
 int mType;
 union {
   int mInt;
   float mFloat;
   bool mBool;
   ARGB mColor;
 };
};

C++ (Qt)
 
struct AbstractAnyFabric
{
    virtual ~AbstractAnyFabric () {}
    virtual boost::any make () = 0;
};
 
template < typename _Type >
struct AnyFabric : public AbstractAnyFabric
{
    virtual boost::any make ()
    {
        return boost::any( _Type() );
    }
};
 

template < typename _Type >
const AbstractAnyFactory & any_factory ()
{
    static const AnyFactory< _Type > factory;
    return factory;
}

C++ (Qt)
Result foo ( const boost::any & )
 

C++ (Qt)
struct to_TypeID : public any_visitor<uint, type_list<int, uint, float,  bool, ARGB>> 
{
    uint operator()(const int &) const { return 'SINT'; }
    uint operator()(const uint &) const { return 'UINT'; }
    uint operator()(const float &) const { return 'REAL'; }
    uint operator()(const bool &) const { return 'BOOL'; }
    uint operator()(const ARGB &) const { return 'ARGB'; }
 };

C++ (Qt)
typedef type_list< double, int, std::string, float > list_of_types;
 
struct cals_sum : public any_visitor< double, list_of_types >
{
    double m_sum;
 
    cals_sum () : m_sum() {}
 
    double operator()( const std::string & str ) { return m_sum += std::stod(str); }
    template <class T>
    double operator()( const T & val ) { return m_sum += double( val ); }
};
 
 
struct to_string : public any_visitor< std::string, list_of_types >
{
    std::string operator()( const std::string & str ) const { return str; }
 
    template <class T>
    std::string operator()(const T & val) const { return std::to_string(val); }
};
 
int main()
{
    std::list< boost::any > many = {123, 3.14, 5.6f, std::string("2.71")};
 
    cals_sum visitor;
    for ( const auto & x : many )
        apply_any_visitor( visitor, x );
 
    std::cout << visitor.m_sum << std::endl;
    return 0;
}
 

C++ (Qt)
template <class Visitor, class TypeList>
struct any_cast_helper
{
    static typename Visitor::result_type get(const boost::any & any, Visitor & visitor)
    {
        if (any.type() == typeid(typename TypeList::first_type))
            return visitor(boost::any_cast<typename TypeList::first_type >(any));
 
        return any_cast_helper<Visitor, typename TypeList::next_type_list>::get(any, visitor);
    }
    static typename Visitor::result_type get(const boost::any & any, const Visitor & visitor)
    {
        if (any.type() == typeid(typename TypeList::first_type))
            return visitor(boost::any_cast<typename TypeList::first_type>(any));
 
        return any_cast_helper<Visitor, typename TypeList::next_type_list>::get(any, visitor);
    }
};
 
 
template <class Visitor>
struct any_cast_helper<Visitor, null_type>
{
    static typename Visitor::result_type get(const boost::any &, Visitor &) throw(std::bad_cast)
    {
        throw std::bad_cast();
    }
    static typename Visitor::result_type get(const boost::any &, const Visitor &) throw(std::bad_cast)
    {
        throw std::bad_cast();
    }
};
 
 
template <class Visitor>
typename Visitor::result_type apply_any_visitor(const Visitor & visitor, const boost::any & any)
{
    return any_cast_helper<Visitor, typename Visitor::type_list>::get(any, visitor);
}
 
template <class Visitor>
typename Visitor::result_type apply_any_visitor( Visitor & visitor, const boost::any & any)
{
    return any_cast_helper<Visitor, typename Visitor::type_list>::get(any, visitor);
}
 

C++ (Qt)
template <class Stream>
struct serialize : public any_visitor<void, type_list<int, uint, float,  bool, ARGB>>
{
    serialize(Stream & out) : m_out(out) {}
 
    template <class T>
    void operator()(const T & val) { m_out << val; }
 
private:
    Stream & m_out;
};
 

C++ (Qt)
static typename Visitor::result_type get(const boost::any & any, Visitor visitor)
 

C++ (Qt)
class serializator
{
public:
    serializator(std::ofstream & out) : m_out(out) {}
 
    template <class T>
    friend serializator & operator<<(serializator &, const T &);
 
    friend serializator & operator<<(serializator &, bool);
 
private:
    int bool_packet; 
    std::ofstream & m_out;
};
 

C++ (Qt)
struct editor : public any_visitor<void, type_list<int, double, std::string>>
{
    void operator()(std::string & s) { s += " Qt5"; }
 
    void operator()(int & i) { i += 100500; }
 
    void operator()(double & d) { d = 3.14159; }
};
 
struct printer : public any_visitor<void, type_list<int, double, std::string>>
{
    template <class T>
    void operator()(const T & val) const { std::cout << val << std::endl; }
};
 
int main()
{
    std::list<boost::any> many = {13, 1.34834657, std::string("hello")};
 
    std::cout << "before:" << std::endl;
    for (auto & x : many)
        apply_any_visitor(printer(), x);
 
    for (auto & x : many)
        apply_any_visitor(editor(), x); // Editor изменяет значения элементов. 
 
    std::cout << "after:" << std::endl;
    for (auto & x : many)
        apply_any_visitor(printer(), x);
 
    return 0;
}
 

C++ (Qt)
typedef type_list<int, bool, float> default_type_list;
struct some_visitor : public any_visitor<void, merge<default_type_list, double, std::string, long /* и т.д. */ >::type> 
{
...
};
 

C++ (Qt)
namespace detail
{
    template<class, class>
    struct merge_helper;
 
    template <class T, class...Types>
    struct merge_helper<type_list<Types...>, T>
    {
        typedef type_list<T, Types...> type;
    };
 
} /* namespace detail */
 
template <class T, class A, class...Types>
struct merge
{
    typedef typename merge<typename detail::merge_helper<T, A>::type, Types...>::type type;
};
 
template <class T, class A>
struct merge<T, A>
{
    typedef typename detail::merge_helper<T, A>::type type;
};
 

C++ (Qt)
typedef type_list<int, long, double> my_type_list;
 
std::cout << std::boolalpha << std::is_same<typename merge<my_type_list, bool, std::string>::type, type_list<std::string, bool, int, long, double>>::value << std::endl;