namespace boost {
  class any;
  void swap(any &, any &);
  template<typename T> T any_cast(any &);
  template<typename T> T any_cast(any &&);
  template<typename T> T any_cast(const any &);
  template<typename ValueType> const ValueType * any_cast(const any *);
  template<typename ValueType> ValueType * any_cast(any *);
}

namespace boost {
  class bad_any_cast;
}

namespace boost {
  namespace anys {
    template<std::size_t OptimizeForSize, std::size_t OptimizeForAlignment> 
      class basic_any;
    void swap(basic_any &, basic_any &);
    template<typename T> T any_cast(basic_any &);
    template<typename T> T any_cast(basic_any &&);
    template<typename T> T any_cast(const basic_any &);
    template<typename ValueType> const ValueType * any_cast(const basic_any *);
    template<typename ValueType> ValueType * any_cast(basic_any *);
  }
}

#include <list>
#include <boost/any.hpp>
#include <algorithm>
#include <iostream>
using boost::any_cast;
typedef std::list<boost::any> many;
void append_int(many& values, int value) {
  boost::any to_append = value;
  values.push_back(to_append);
}
void append_string(many& values, const std::string& value) {
  values.push_back(value);
}
void append_char_ptr(many& values, const char* value) {
  values.push_back(value);
}
void append_any(many& values, const boost::any& value) {
  values.push_back(value);
}
void append_noting(many& values) {
  values.push_back(boost::any());
}
bool is_empty(const boost::any& operand)
{
    return operand.empty();
}
bool is_int(const boost::any& operand)
{
    return operand.type() == typeid(int);
}
bool is_char_ptr(const boost::any& operand)
{
    try
    {
        any_cast<const char*>(operand);
        return true;
    }
    catch (const boost::bad_any_cast&)
    {
        return false;
    }
}
bool is_string(const boost::any& operand)
{
    return any_cast<std::string>(&operand);
}
void count_all(many& values, std::ostream& out)
{
    out << "#empty == "
        << std::count_if(values.begin(), values.end(), is_empty) << std::endl;
    out << "#int == "
        << std::count_if(values.begin(), values.end(), is_int) << std::endl;
    out << "#const char * == "
        << std::count_if(values.begin(), values.end(), is_char_ptr) << std::endl;
    out << "#string == "
        << std::count_if(values.begin(), values.end(), is_string) << std::endl;
}
struct property
{
    property() = default;
    property(const std::string&, const boost::any&);
    std::string name;
    boost::any value;
};
property::property(const std::string& name, const boost::any& value)
{
    this->name = name;
    this->value = value;
}
typedef std::list<property> properties;
class consumer
{
public:
    virtual void notify(const boost::any&) = 0;
    std::string name;
};
class school_consumer :public consumer {
public:
    school_consumer() = default;
    void notify(const boost::any& object) {
        std::cout << "notify:   "<< std::endl;
    }
};
int main(int argc, char** argv) {
    std::list<boost::any> myList;
    append_int(myList, 1);
    append_string(myList, "test");
    append_any(myList, 4);
    char cs = 's';
    const char* ptr = &cs;
    append_char_ptr(myList, ptr);
    append_noting(myList);
    //对所有类型计数
    count_all(myList,std::cout);
    //利用any的特性做配置的存储
    properties pros;
    property pro1("url", "https://xxx.com");
    property pro2("ConnnectionCount", 8);
    pros.push_back(pro1);
    pros.push_back(pro2);
    school_consumer scConsumer;
    scConsumer.notify(5);
    return 0;
}