1 // See http://www.boost.org/libs/any for Documentation.

     2 

     3 #ifndef BOOST_ANY_INCLUDED

     4 #define BOOST_ANY_INCLUDED

     5 

     6 // what:  variant type boost::any

     7 // who:   contributed by Kevlin Henney,

     8 //        with features contributed and bugs found by

     9 //        Ed Brey, Mark Rodgers, Peter Dimov, and James Curran

    10 // when:  July 2001

    11 // where: tested with BCC 5.5, MSVC 6.0, and g++ 2.95

    12 

    13 #include <algorithm>

    14 #include <typeinfo>

    15 

    16 #include "boost/config.hpp"

    17 #include <boost/type_traits/remove_reference.hpp>

    18 #include <boost/type_traits/is_reference.hpp>

    19 #include <boost/throw_exception.hpp>

    20 #include <boost/static_assert.hpp>

    21 

    22 namespace boost

    23 {

    24     class any

    25     {

    26     public: // structors

    27 

    28         any()

    29           : content(0)

    30         {

    31         }

    32 

    33         template<typename ValueType>

    34         any(const ValueType & value)

    35           : content(new holder<ValueType>(value))

    36         {

    37         }

    38 

    39         any(const any & other)

    40           : content(other.content ? other.content->clone() : 0)

    41         {

    42         }

    43 

    44         ~any()

    45         {

    46             delete content;

    47         }

    48 

    49     public: // modifiers

    50 

    51         any & swap(any & rhs)

    52         {

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

    54             return *this;

    55         }

    56 

    57         template<typename ValueType>

    58         any & operator=(const ValueType & rhs)

    59         {

    60             any(rhs).swap(*this);

    61             return *this;

    62         }

    63 

    64         any & operator=(const any & rhs)

    65         {

    66             any(rhs).swap(*this);

    67             return *this;

    68         }

    69 

    70     public: // queries

    71 

    72         bool empty() const

    73         {

    74             return !content;

    75         }

    76 

    77         const std::type_info & type() const

    78         {

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

    80         }

    81 

    82 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS

    83     private: // types

    84 #else

    85     public: // types (public so any_cast can be non-friend)

    86 #endif

    87 

    88         class placeholder

    89         {

    90         public: // structors

    91 

    92             virtual ~placeholder()

    93             {

    94             }

    95 

    96         public: // queries

    97 

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

    99 

   100             virtual placeholder * clone() const = 0;

   101 

   102         };

   103 

   104         template<typename ValueType>

   105         class holder : public placeholder

   106         {

   107         public: // structors

   108 

   109             holder(const ValueType & value)

   110               : held(value)

   111             {

   112             }

   113 

   114         public: // queries

   115 

   116             virtual const std::type_info & type() const

   117             {

   118                 return typeid(ValueType);

   119             }

   120 

   121             virtual placeholder * clone() const

   122             {

   123                 return new holder(held);

   124             }

   125 

   126         public: // representation

   127 

   128             ValueType held;

   129 

   130         };

   131 

   132 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS

   133 

   134     private: // representation

   135 

   136         template<typename ValueType>

   137         friend ValueType * any_cast(any *);

   138 

   139         template<typename ValueType>

   140         friend ValueType * unsafe_any_cast(any *);

   141 

   142 #else

   143 

   144     public: // representation (public so any_cast can be non-friend)

   145 

   146 #endif

   147 

   148         placeholder * content;

   149 

   150     };

   151 

   152     class bad_any_cast : public std::bad_cast

   153     {

   154     public:

   155         virtual const char * what() const throw()

   156         {

   157             return "boost::bad_any_cast: "

   158                    "failed conversion using boost::any_cast";

   159         }

   160     };

   161 

   162     template<typename ValueType>

   163     ValueType * any_cast(any * operand)

   164     {

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

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

   167                     : 0;

   168     }

   169 

   170     template<typename ValueType>

   171     const ValueType * any_cast(const any * operand)

   172     {

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

   174     }

   175 

   176     template<typename ValueType>

   177     ValueType any_cast(const any & operand)

   178     {

   179         typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;

   180 

   181 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

   182         // If 'nonref' is still reference type, it means the user has not

   183         // specialized 'remove_reference'.

   184 

   185         // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro

   186         // to generate specialization of remove_reference for your class

   187         // See type traits library documentation for details

   188         BOOST_STATIC_ASSERT(!is_reference<nonref>::value);

   189 #endif

   190 

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

   192         if(!result)

   193             boost::throw_exception(bad_any_cast());

   194         return *result;

   195     }

   196 

   197     template<typename ValueType>

   198     ValueType any_cast(any & operand)

   199     {

   200         typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;

   201 

   202 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

   203         // The comment in the above version of 'any_cast' explains when this

   204         // assert is fired and what to do.

   205         BOOST_STATIC_ASSERT(!is_reference<nonref>::value);

   206 #endif

   207 

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

   209         if(!result)

   210             boost::throw_exception(bad_any_cast());

   211         return *result;

   212     }

   213 

   214     // Note: The "unsafe" versions of any_cast are not part of the

   215     // public interface and may be removed at any time. They are

   216     // required where we know what type is stored in the any and can't

   217     // use typeid() comparison, e.g., when our types may travel across

   218     // different shared libraries.

   219     template<typename ValueType>

   220     inline ValueType * unsafe_any_cast(any * operand)

   221     {

   222         return &static_cast<any::holder<ValueType> *>(operand->content)->held;

   223     }

   224 

   225     template<typename ValueType>

   226     inline const ValueType * unsafe_any_cast(const any * operand)

   227     {

   228         return unsafe_any_cast<ValueType>(const_cast<any *>(operand));

   229     }

   230 }

   231 

   232 // Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.

   233 //

   234 // Distributed under the Boost Software License, Version 1.0. (See

   235 // accompanying file LICENSE_1_0.txt or copy at

   236 // http://www.boost.org/LICENSE_1_0.txt)

   237 

   238 #endif