boost.any源码整理和使用说明

Source

#include <algorithm>

#include <typeinfo>

 

#include "boost/config.hpp"

#include <boost/type_traits/remove_reference.hpp>

#include <boost/type_traits/is_reference.hpp>

#include <boost/throw_exception.hpp>

#include <boost/static_assert.hpp>

 

namespace kimi_boost

{

    class any

    {

              template<typename ValueType>

              friend ValueType * any_cast(any *);

    public:

              //ctor

        any() : content(0){}

              //ctor: from a value of any type

        template<typename ValueType>

        any(const ValueType & value): content(new holder<ValueType>(value)){}

              //copy-ctor: from another any object

        any(const any & other): content(other.content ? other.content->clone() : 0){}

              //dtor

              ~any(){delete content;}

 

              //swap two any objects

        any& swap(any & rhs)

        {

            std::swap(content, rhs.content);

            return *this;

        }

 

              //assign from a value of any type

        template<typename ValueType>

        any & operator=(const ValueType & rhs)

        {

            any(rhs).swap(*this);

            return *this;

        }

 

              //assign from another any object

        any & operator=(const any & rhs)

        {

            any(rhs).swap(*this);

            return *this;

        }

 

        bool empty() const {return !content;}

 

              //get the type_info& using RTTI

        const std::type_info & type() const

        {

                     //see holder::type()

            return content ? content->type() : typeid(void);

        }

 

 

    private:

              //inner class

        class placeholder

        {

        public:

            virtual ~placeholder(){}

            virtual const std::type_info & type() const = 0;

            virtual placeholder * clone() const = 0;

        };//class placeholder

 

        template<typename ValueType>

        class holder : public placeholder

        {

        public:

                     holder(const ValueType & value): held(value){}

 

            virtual const std::type_info & type() const

            {return typeid(ValueType);}

 

 

                     //note the return type is "placeholder*" rather than "holder*"

            virtual placeholder * clone() const

            {return new holder(held);}

 

                     //the real object of various type

            ValueType held;

              };//class holder

 

 

    private://the only member data

        placeholder* content;

       };//class any

 

 

 

       //an exception class that will be thrown when type cast fails

    class bad_any_cast : public std::bad_cast

    {

    public:

        virtual const char * what() const throw()

        {return "boost::bad_any_cast: failed conversion using boost::any_cast";}

    };

 

 

      

 

       //两个指针版本的any_cast不会抛出异常,失败时返回

       //any_cast functions are based on typeid and type_info

 

 

    template<typename ValueType>

    ValueType * any_cast(any * operand)

    {

        return ( operand && operand->type() == typeid(ValueType) )

                    ? &static_cast<any::holder<ValueType> *>(operand->content)->held

                    : 0;

    }

 

    template<typename ValueType>

    const ValueType * any_cast(const any * operand)

    {

        return any_cast<ValueType>(const_cast<any *>(operand));

    }

 

 

       //两个引用版本的any_cast失败时会抛出异常

    template<typename ValueType>

    ValueType any_cast(const any & operand)

    {

        typedef typename remove_reference<ValueType>::type nonref;

 

        const nonref * result = any_cast<nonref>(&operand);

        if(!result)

            boost::throw_exception(bad_any_cast());

        return *result;

    }

 

    template<typename ValueType>

    ValueType any_cast(any & operand)

    {

        typedef typename remove_reference<ValueType>::type nonref;

 

        nonref * result = any_cast<nonref>(&operand);

        if(!result)

            boost::throw_exception(bad_any_cast());

        return *result;

    }

 

}

Test code

bool is_empty(const kimi_boost::any & operand)

{

    return operand.empty();

}

 

bool is_int(const kimi_boost::any & operand)

{

    return operand.type() == typeid(int);

}

 

bool is_char_ptr(const kimi_boost::any & operand)

{

    try

    {

        kimi_boost::any_cast<const char *>(operand);

        return true;

    }

    catch(const kimi_boost::bad_any_cast &)

    {

        return false;

    }

}

 

bool is_string(const kimi_boost::any & operand)

{

    return kimi_boost::any_cast<std::string>(&operand);

}

 

void count_all(std::list<kimi_boost::any> & 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;

}

 

 

void any_test()

{

       std::list<kimi_boost::any> la;

       la.push_back(int(1));

       la.push_back(double(1));

       la.push_back(char(1));

       la.push_back(float(1));

       la.push_back(kimi_boost::any((char)3));//char type

       la.push_back(kimi_boost::any((int)3));//int type

       la.push_back(kimi_boost::any());//empty

       la.push_back(kimi_boost::any());//empty

 

       count_all(la,std::cout);

      

}

Output

#empty == 2

#int == 2

#const char * == 0

#string == 0