source: XIOS/dev/dev_olga/src/extern/boost/include/boost/exception/exception.hpp @ 1022

Last change on this file since 1022 was 1022, checked in by mhnguyen, 7 years ago
File size: 10.6 KB
Line 
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_274DA366004E11DCB1DDFE2E56D89593
7#define UUID_274DA366004E11DCB1DDFE2E56D89593
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
15namespace
16boost
17    {
18    namespace
19    exception_detail
20        {
21        template <class T>
22        class
23        refcount_ptr
24            {
25            public:
26
27            refcount_ptr():
28                px_(0)
29                {
30                }
31
32            ~refcount_ptr()
33                {
34                release();
35                }
36
37            refcount_ptr( refcount_ptr const & x ):
38                px_(x.px_)
39                {
40                add_ref();
41                }
42
43            refcount_ptr &
44            operator=( refcount_ptr const & x )
45                {
46                adopt(x.px_);
47                return *this;
48                }
49
50            void
51            adopt( T * px )
52                {
53                release();
54                px_=px;
55                add_ref();
56                }
57
58            T *
59            get() const
60                {
61                return px_;
62                }
63
64            private:
65
66            T * px_;
67
68            void
69            add_ref()
70                {
71                if( px_ )
72                    px_->add_ref();
73                }
74
75            void
76            release()
77                {
78                if( px_ && px_->release() )
79                    px_=0;
80                }
81            };
82        }
83
84    ////////////////////////////////////////////////////////////////////////
85
86    template <class Tag,class T>
87    class error_info;
88
89    typedef error_info<struct throw_function_,char const *> throw_function;
90    typedef error_info<struct throw_file_,char const *> throw_file;
91    typedef error_info<struct throw_line_,int> throw_line;
92
93    template <>
94    class
95    error_info<throw_function_,char const *>
96        {
97        public:
98        typedef char const * value_type;
99        value_type v_;
100        explicit
101        error_info( value_type v ):
102            v_(v)
103            {
104            }
105        };
106
107    template <>
108    class
109    error_info<throw_file_,char const *>
110        {
111        public:
112        typedef char const * value_type;
113        value_type v_;
114        explicit
115        error_info( value_type v ):
116            v_(v)
117            {
118            }
119        };
120
121    template <>
122    class
123    error_info<throw_line_,int>
124        {
125        public:
126        typedef int value_type;
127        value_type v_;
128        explicit
129        error_info( value_type v ):
130            v_(v)
131            {
132            }
133        };
134
135    class exception;
136
137    template <class T>
138    class shared_ptr;
139
140    namespace
141    exception_detail
142        {
143        class error_info_base;
144        struct type_info_;
145
146        struct
147        error_info_container
148            {
149            virtual char const * diagnostic_information( char const * ) const = 0;
150            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
151            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
152            virtual void add_ref() const = 0;
153            virtual bool release() const = 0;
154            virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
155
156            protected:
157
158            ~error_info_container() throw()
159                {
160                }
161            };
162
163        template <class>
164        struct get_info;
165
166        template <>
167        struct get_info<throw_function>;
168
169        template <>
170        struct get_info<throw_file>;
171
172        template <>
173        struct get_info<throw_line>;
174
175        char const * get_diagnostic_information( exception const &, char const * );
176
177        void copy_boost_exception( exception *, exception const * );
178
179        template <class E,class Tag,class T>
180        E const & set_info( E const &, error_info<Tag,T> const & );
181
182        template <class E>
183        E const & set_info( E const &, throw_function const & );
184
185        template <class E>
186        E const & set_info( E const &, throw_file const & );
187
188        template <class E>
189        E const & set_info( E const &, throw_line const & );
190        }
191
192    class
193    exception
194        {
195        protected:
196
197        exception():
198            throw_function_(0),
199            throw_file_(0),
200            throw_line_(-1)
201            {
202            }
203
204#ifdef __HP_aCC
205        //On HP aCC, this protected copy constructor prevents throwing boost::exception.
206        //On all other platforms, the same effect is achieved by the pure virtual destructor.
207        exception( exception const & x ) throw():
208            data_(x.data_),
209            throw_function_(x.throw_function_),
210            throw_file_(x.throw_file_),
211            throw_line_(x.throw_line_)
212            {
213            }
214#endif
215
216        virtual ~exception() throw()
217#ifndef __HP_aCC
218            = 0 //Workaround for HP aCC, =0 incorrectly leads to link errors.
219#endif
220            ;
221
222#if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310)
223        public:
224#else
225        private:
226
227        template <class E>
228        friend E const & exception_detail::set_info( E const &, throw_function const & );
229
230        template <class E>
231        friend E const & exception_detail::set_info( E const &, throw_file const & );
232
233        template <class E>
234        friend E const & exception_detail::set_info( E const &, throw_line const & );
235
236        template <class E,class Tag,class T>
237        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
238
239        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
240
241        template <class>
242        friend struct exception_detail::get_info;
243        friend struct exception_detail::get_info<throw_function>;
244        friend struct exception_detail::get_info<throw_file>;
245        friend struct exception_detail::get_info<throw_line>;
246        friend void exception_detail::copy_boost_exception( exception *, exception const * );
247#endif
248        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
249        mutable char const * throw_function_;
250        mutable char const * throw_file_;
251        mutable int throw_line_;
252        };
253
254    inline
255    exception::
256    ~exception() throw()
257        {
258        }
259
260    namespace
261    exception_detail
262        {
263        template <class E>
264        E const &
265        set_info( E const & x, throw_function const & y )
266            {
267            x.throw_function_=y.v_;
268            return x;
269            }
270
271        template <class E>
272        E const &
273        set_info( E const & x, throw_file const & y )
274            {
275            x.throw_file_=y.v_;
276            return x;
277            }
278
279        template <class E>
280        E const &
281        set_info( E const & x, throw_line const & y )
282            {
283            x.throw_line_=y.v_;
284            return x;
285            }
286        }
287
288    ////////////////////////////////////////////////////////////////////////
289
290    namespace
291    exception_detail
292        {
293        template <class T>
294        struct
295        error_info_injector:
296            public T,
297            public exception
298            {
299            explicit
300            error_info_injector( T const & x ):
301                T(x)
302                {
303                }
304
305            ~error_info_injector() throw()
306                {
307                }
308            };
309
310        struct large_size { char c[256]; };
311        large_size dispatch_boost_exception( exception const * );
312
313        struct small_size { };
314        small_size dispatch_boost_exception( void const * );
315
316        template <class,int>
317        struct enable_error_info_helper;
318
319        template <class T>
320        struct
321        enable_error_info_helper<T,sizeof(large_size)>
322            {
323            typedef T type;
324            };
325
326        template <class T>
327        struct
328        enable_error_info_helper<T,sizeof(small_size)>
329            {
330            typedef error_info_injector<T> type;
331            };
332
333        template <class T>
334        struct
335        enable_error_info_return_type
336            {
337            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception((T*)0))>::type type;
338            };
339        }
340
341    template <class T>
342    inline
343    typename
344    exception_detail::enable_error_info_return_type<T>::type
345    enable_error_info( T const & x )
346        {
347        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
348        return rt(x);
349        }
350
351    ////////////////////////////////////////////////////////////////////////
352
353    namespace
354    exception_detail
355        {
356        class
357        clone_base
358            {
359            public:
360
361            virtual clone_base const * clone() const = 0;
362            virtual void rethrow() const = 0;
363
364            virtual
365            ~clone_base() throw()
366                {
367                }
368            };
369
370        inline
371        void
372        copy_boost_exception( exception * a, exception const * b )
373            {
374            refcount_ptr<error_info_container> data;
375            if( error_info_container * d=b->data_.get() )
376                data = d->clone();
377            a->throw_file_ = b->throw_file_;
378            a->throw_line_ = b->throw_line_;
379            a->throw_function_ = b->throw_function_;
380            a->data_ = data;
381            }
382
383        inline
384        void
385        copy_boost_exception( void *, void const * )
386            {
387            }
388
389        template <class T>
390        class
391        clone_impl:
392            public T,
393            public clone_base
394            {
395            public:
396
397            explicit
398            clone_impl( T const & x ):
399                T(x)
400                {
401                copy_boost_exception(this,&x);
402                }
403
404            ~clone_impl() throw()
405                {
406                }
407
408            private:
409
410            clone_base const *
411            clone() const
412                {
413                return new clone_impl(*this);
414                }
415
416            void
417            rethrow() const
418                {
419                throw*this;
420                }
421            };
422        }
423
424    template <class T>
425    inline
426    exception_detail::clone_impl<T>
427    enable_current_exception( T const & x )
428        {
429        return exception_detail::clone_impl<T>(x);
430        }
431    }
432
433#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
434#pragma warning(pop)
435#endif
436#endif
Note: See TracBrowser for help on using the repository browser.