boost/boost/exception/info.hpp

   1 //Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
   2
   3 //Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef UUID_8D22C4CA9CC811DCAA9133D256D89593
   7 #define UUID_8D22C4CA9CC811DCAA9133D256D89593
   8
   9 #include <boost/exception/exception.hpp>
  10 #include <boost/exception/to_string_stub.hpp>
  11 #include <boost/exception/detail/error_info_impl.hpp>
  12 #include <boost/shared_ptr.hpp>
  13 #include <map>
  14
  15 namespace
  16 boost
  17     {
  18     template <class Tag,class T>
  19     inline
  20     typename enable_if<has_to_string<T>,std::string>::type
  21     to_string( error_info<Tag,T> const & x )
  22         {
  23         return to_string(x.value());
  24         }
  25
  26     template <class Tag,class T>
  27     inline
  28     error_info<Tag,T>::
  29     error_info( value_type const & value ):
  30         value_(value)
  31         {
  32         }
  33
  34     template <class Tag,class T>
  35     inline
  36     error_info<Tag,T>::
  37     ~error_info() throw()
  38         {
  39         }
  40
  41     template <class Tag,class T>
  42     inline
  43     char const *
  44     error_info<Tag,T>::
  45     tag_typeid_name() const
  46         {
  47         return tag_type_name<Tag>();
  48         }
  49
  50     template <class Tag,class T>
  51     inline
  52     std::string
  53     error_info<Tag,T>::
  54     value_as_string() const
  55         {
  56         return to_string_stub(*this);
  57         }
  58
  59     namespace
  60     exception_detail
  61         {
  62         class
  63         error_info_container_impl:
  64             public error_info_container
  65             {
  66             public:
  67
  68             error_info_container_impl():
  69                 count_(0)
  70                 {
  71                 }
  72
  73             ~error_info_container_impl() throw()
  74                 {
  75                 }
  76
  77             void
  78             set( shared_ptr<error_info_base const> const & x, type_info_ const & typeid_ )
  79                 {
  80                 BOOST_ASSERT(x);
  81                 info_[typeid_] = x;
  82                 diagnostic_info_str_.clear();
  83                 }
  84
  85             shared_ptr<error_info_base const>
  86             get( type_info_ const & ti ) const
  87                 {
  88                 error_info_map::const_iterator i=info_.find(ti);
  89                 if( info_.end()!=i )
  90                     {
  91                     shared_ptr<error_info_base const> const & p = i->second;
  92 #ifndef BOOST_NO_RTTI
  93                     BOOST_ASSERT( BOOST_EXCEPTION_DYNAMIC_TYPEID(*p)==ti );
  94 #endif
  95                     return p;
  96                     }
  97                 return shared_ptr<error_info_base const>();
  98                 }
  99
 100             char const *
 101             diagnostic_information() const
 102                 {
 103                 if( diagnostic_info_str_.empty() )
 104                     {
 105                     std::ostringstream tmp;
 106                     for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
 107                         {
 108                         shared_ptr<error_info_base const> const & x = i->second;
 109                         tmp << '[' << x->tag_typeid_name() << "] = " << x->value_as_string() << std::endl;
 110                         }
 111                     tmp.str().swap(diagnostic_info_str_);
 112                     }
 113                 return diagnostic_info_str_.c_str();
 114                 }
 115
 116             private:
 117
 118             friend class boost::exception;
 119
 120             typedef std::map< type_info_, shared_ptr<error_info_base const> > error_info_map;
 121             error_info_map info_;
 122             mutable std::string diagnostic_info_str_;
 123             mutable int count_;
 124
 125             void
 126             add_ref() const
 127                 {
 128                 ++count_;
 129                 }
 130
 131             void
 132             release() const
 133                 {
 134                 if( !--count_ )
 135                     delete this;
 136                 }
 137             };
 138         }
 139
 140     template <class E,class Tag,class T>
 141     inline
 142     E const &
 143     operator<<( E const & x, error_info<Tag,T> const & v )
 144         {
 145         typedef error_info<Tag,T> error_info_tag_t;
 146         shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
 147         exception_detail::error_info_container * c;
 148         if( !(c=x.data_.get()) )
 149             x.data_.adopt(c=new exception_detail::error_info_container_impl);
 150         c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
 151         return x;
 152         }
 153     }
 154
 155 #endif