New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
info.hpp in vendors/XIOS/current/extern/boost/include/boost/exception – NEMO

source: vendors/XIOS/current/extern/boost/include/boost/exception/info.hpp @ 3428

Last change on this file since 3428 was 3428, checked in by rblod, 12 years ago

importing initial XIOS vendor drop

File size: 5.6 KB
Line 
1//Copyright (c) 2006-2010 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#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
9#pragma GCC system_header
10#endif
11#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
12#pragma warning(push,1)
13#endif
14
15#include <boost/exception/exception.hpp>
16#include <boost/exception/to_string_stub.hpp>
17#include <boost/exception/detail/error_info_impl.hpp>
18#include <boost/shared_ptr.hpp>
19#include <boost/config.hpp>
20#include <map>
21
22namespace
23boost
24    {
25    template <class Tag,class T>
26    inline
27    typename enable_if<has_to_string<T>,std::string>::type
28    to_string( error_info<Tag,T> const & x )
29        {
30        return to_string(x.value());
31        }
32
33    template <class Tag,class T>
34    inline
35    error_info<Tag,T>::
36    error_info( value_type const & value ):
37        value_(value)
38        {
39        }
40
41    template <class Tag,class T>
42    inline
43    error_info<Tag,T>::
44    ~error_info() throw()
45        {
46        }
47
48    template <class Tag,class T>
49    inline
50    std::string
51    error_info<Tag,T>::
52    tag_typeid_name() const
53        {
54        return tag_type_name<Tag>();
55        }
56
57    template <class Tag,class T>
58    inline
59    std::string
60    error_info<Tag,T>::
61    value_as_string() const
62        {
63        return to_string_stub(*this);
64        }
65
66    namespace
67    exception_detail
68        {
69        class
70        error_info_container_impl:
71            public error_info_container
72            {
73            public:
74
75            error_info_container_impl():
76                count_(0)
77                {
78                }
79
80            ~error_info_container_impl() throw()
81                {
82                }
83
84            void
85            set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ )
86                {
87                BOOST_ASSERT(x);
88                info_[typeid_] = x;
89                diagnostic_info_str_.clear();
90                }
91
92            shared_ptr<error_info_base>
93            get( type_info_ const & ti ) const
94                {
95                error_info_map::const_iterator i=info_.find(ti);
96                if( info_.end()!=i )
97                    {
98                    shared_ptr<error_info_base> const & p = i->second;
99#ifndef BOOST_NO_RTTI
100                    BOOST_ASSERT( BOOST_EXCEPTION_DYNAMIC_TYPEID(*p).type_==ti.type_ );
101#endif
102                    return p;
103                    }
104                return shared_ptr<error_info_base>();
105                }
106
107            char const *
108            diagnostic_information( char const * header ) const
109                {
110                if( header )
111                    {
112                    BOOST_ASSERT(*header!=0);
113                    std::ostringstream tmp;
114                    tmp << header;
115                    for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
116                        {
117                        error_info_base const & x = *i->second;
118                        tmp << '[' << x.tag_typeid_name() << "] = " << x.value_as_string() << '\n';
119                        }
120                    tmp.str().swap(diagnostic_info_str_);
121                    }
122                return diagnostic_info_str_.c_str();
123                }
124
125            private:
126
127            friend class boost::exception;
128
129            typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map;
130            error_info_map info_;
131            mutable std::string diagnostic_info_str_;
132            mutable int count_;
133
134            error_info_container_impl( error_info_container_impl const & );
135            error_info_container_impl & operator=( error_info_container const & );
136
137            void
138            add_ref() const
139                {
140                ++count_;
141                }
142
143            bool
144            release() const
145                {
146                if( --count_ )
147                    return false;
148                else
149                    {
150                    delete this;
151                    return true;
152                    }
153                }
154
155            refcount_ptr<error_info_container>
156            clone() const
157                {
158                refcount_ptr<error_info_container> p;
159                error_info_container_impl * c=new error_info_container_impl;
160                p.adopt(c);
161                c->info_ = info_;
162                return p;
163                }
164            };
165
166        template <class E,class Tag,class T>
167        inline
168        E const &
169        set_info( E const & x, error_info<Tag,T> const & v )
170            {
171            typedef error_info<Tag,T> error_info_tag_t;
172            shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
173            exception_detail::error_info_container * c=x.data_.get();
174            if( !c )
175                x.data_.adopt(c=new exception_detail::error_info_container_impl);
176            c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
177            return x;
178            }
179
180        template <class T>
181        struct
182        derives_boost_exception
183            {
184            enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
185            };
186        }
187
188    template <class E,class Tag,class T>
189    inline
190    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
191    operator<<( E const & x, error_info<Tag,T> const & v )
192        {
193        return exception_detail::set_info(x,v);
194        }
195    }
196
197#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
198#pragma warning(pop)
199#endif
200#endif
Note: See TracBrowser for help on using the repository browser.