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.
array.hpp in vendors/XIOS/current/extern/boost/include/boost – NEMO

source: vendors/XIOS/current/extern/boost/include/boost/array.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: 13.4 KB
Line 
1/* The following code declares class array,
2 * an STL container (as wrapper) for arrays of constant size.
3 *
4 * See
5 *      http://www.boost.org/libs/array/
6 * for documentation.
7 *
8 * The original author site is at: http://www.josuttis.com/
9 *
10 * (C) Copyright Nicolai M. Josuttis 2001.
11 *
12 * Distributed under the Boost Software License, Version 1.0. (See
13 * accompanying file LICENSE_1_0.txt or copy at
14 * http://www.boost.org/LICENSE_1_0.txt)
15 *
16 * 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group.
17 *      See <http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776> or Trac issue #3168
18 *      Eventually, we should remove "assign" which is now a synonym for "fill" (Marshall Clow)
19 * 10 Mar 2010 - added workaround for SUNCC and !STLPort [trac #3893] (Marshall Clow)
20 * 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis)
21 * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries.
22 * 05 Aug 2001 - minor update (Nico Josuttis)
23 * 20 Jan 2001 - STLport fix (Beman Dawes)
24 * 29 Sep 2000 - Initial Revision (Nico Josuttis)
25 *
26 * Jan 29, 2004
27 */
28#ifndef BOOST_ARRAY_HPP
29#define BOOST_ARRAY_HPP
30
31#include <boost/detail/workaround.hpp>
32
33#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) 
34# pragma warning(push) 
35# pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe
36# pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated
37# pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required
38#endif
39
40#include <cstddef>
41#include <stdexcept>
42#include <boost/assert.hpp>
43#include <boost/swap.hpp>
44
45// Handles broken standard libraries better than <iterator>
46#include <boost/detail/iterator.hpp>
47#include <boost/throw_exception.hpp>
48#include <algorithm>
49
50// FIXES for broken compilers
51#include <boost/config.hpp>
52
53
54namespace boost {
55
56    template<class T, std::size_t N>
57    class array {
58      public:
59        T elems[N];    // fixed-size array of elements of type T
60
61      public:
62        // type definitions
63        typedef T              value_type;
64        typedef T*             iterator;
65        typedef const T*       const_iterator;
66        typedef T&             reference;
67        typedef const T&       const_reference;
68        typedef std::size_t    size_type;
69        typedef std::ptrdiff_t difference_type;
70
71        // iterator support
72        iterator begin() { return elems; }
73        const_iterator begin() const { return elems; }
74        iterator end() { return elems+N; }
75        const_iterator end() const { return elems+N; }
76
77        // reverse iterator support
78#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
79        typedef std::reverse_iterator<iterator> reverse_iterator;
80        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
81#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
82        // workaround for broken reverse_iterator in VC7
83        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
84                                      reference, iterator, reference> > reverse_iterator;
85        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
86                                      const_reference, iterator, reference> > const_reverse_iterator;
87#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
88        typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, 
89              value_type, reference, iterator, difference_type> reverse_iterator; 
90        typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
91              value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
92#else
93        // workaround for broken reverse_iterator implementations
94        typedef std::reverse_iterator<iterator,T> reverse_iterator;
95        typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
96#endif
97
98        reverse_iterator rbegin() { return reverse_iterator(end()); }
99        const_reverse_iterator rbegin() const {
100            return const_reverse_iterator(end());
101        }
102        reverse_iterator rend() { return reverse_iterator(begin()); }
103        const_reverse_iterator rend() const {
104            return const_reverse_iterator(begin());
105        }
106
107        // operator[]
108        reference operator[](size_type i) 
109        { 
110            BOOST_ASSERT( i < N && "out of range" ); 
111            return elems[i];
112        }
113       
114        const_reference operator[](size_type i) const 
115        {     
116            BOOST_ASSERT( i < N && "out of range" ); 
117            return elems[i]; 
118        }
119
120        // at() with range check
121        reference at(size_type i) { rangecheck(i); return elems[i]; }
122        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
123   
124        // front() and back()
125        reference front() 
126        { 
127            return elems[0]; 
128        }
129       
130        const_reference front() const 
131        {
132            return elems[0];
133        }
134       
135        reference back() 
136        { 
137            return elems[N-1]; 
138        }
139       
140        const_reference back() const 
141        { 
142            return elems[N-1]; 
143        }
144
145        // size is constant
146        static size_type size() { return N; }
147        static bool empty() { return false; }
148        static size_type max_size() { return N; }
149        enum { static_size = N };
150
151        // swap (note: linear complexity)
152        void swap (array<T,N>& y) {
153            for (size_type i = 0; i < N; ++i)
154                boost::swap(elems[i],y.elems[i]);
155        }
156
157        // direct access to data (read-only)
158        const T* data() const { return elems; }
159        T* data() { return elems; }
160
161        // use array as C array (direct read/write access to data)
162        T* c_array() { return elems; }
163
164        // assignment with type conversion
165        template <typename T2>
166        array<T,N>& operator= (const array<T2,N>& rhs) {
167            std::copy(rhs.begin(),rhs.end(), begin());
168            return *this;
169        }
170
171        // assign one value to all elements
172        void assign (const T& value) { fill ( value ); }    // A synonym for fill
173        void fill   (const T& value)
174        {
175            std::fill_n(begin(),size(),value);
176        }
177
178        // check range (may be private because it is static)
179        static void rangecheck (size_type i) {
180            if (i >= size()) {
181                std::out_of_range e("array<>: index out of range");
182                boost::throw_exception(e);
183            }
184        }
185
186    };
187
188#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
189    template< class T >
190    class array< T, 0 > {
191
192      public:
193        // type definitions
194        typedef T              value_type;
195        typedef T*             iterator;
196        typedef const T*       const_iterator;
197        typedef T&             reference;
198        typedef const T&       const_reference;
199        typedef std::size_t    size_type;
200        typedef std::ptrdiff_t difference_type;
201
202        // iterator support
203        iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
204        const_iterator begin() const { return const_iterator(  reinterpret_cast< const T * >( this ) ); }
205        iterator end() { return begin(); }
206        const_iterator end() const { return begin(); }
207
208        // reverse iterator support
209#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
210        typedef std::reverse_iterator<iterator> reverse_iterator;
211        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
212#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
213        // workaround for broken reverse_iterator in VC7
214        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
215                                      reference, iterator, reference> > reverse_iterator;
216        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
217                                      const_reference, iterator, reference> > const_reverse_iterator;
218#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
219        typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, 
220              value_type, reference, iterator, difference_type> reverse_iterator; 
221        typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
222              value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
223#else
224        // workaround for broken reverse_iterator implementations
225        typedef std::reverse_iterator<iterator,T> reverse_iterator;
226        typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
227#endif
228
229        reverse_iterator rbegin() { return reverse_iterator(end()); }
230        const_reverse_iterator rbegin() const {
231            return const_reverse_iterator(end());
232        }
233        reverse_iterator rend() { return reverse_iterator(begin()); }
234        const_reverse_iterator rend() const {
235            return const_reverse_iterator(begin());
236        }
237
238        // operator[]
239        reference operator[](size_type /*i*/)
240        {
241            return failed_rangecheck();
242        }
243
244        const_reference operator[](size_type /*i*/) const
245        {
246            return failed_rangecheck();
247        }
248
249        // at() with range check
250        reference at(size_type /*i*/)               {   return failed_rangecheck(); }
251        const_reference at(size_type /*i*/) const   {   return failed_rangecheck(); }
252
253        // front() and back()
254        reference front()
255        {
256            return failed_rangecheck();
257        }
258
259        const_reference front() const
260        {
261            return failed_rangecheck();
262        }
263
264        reference back()
265        {
266            return failed_rangecheck();
267        }
268
269        const_reference back() const
270        {
271            return failed_rangecheck();
272        }
273
274        // size is constant
275        static size_type size() { return 0; }
276        static bool empty() { return true; }
277        static size_type max_size() { return 0; }
278        enum { static_size = 0 };
279
280        void swap (array<T,0>& /*y*/) {
281        }
282
283        // direct access to data (read-only)
284        const T* data() const { return 0; }
285        T* data() { return 0; }
286
287        // use array as C array (direct read/write access to data)
288        T* c_array() { return 0; }
289
290        // assignment with type conversion
291        template <typename T2>
292        array<T,0>& operator= (const array<T2,0>& ) {
293            return *this;
294        }
295
296        // assign one value to all elements
297        void assign (const T& value) { fill ( value ); }
298        void fill   (const T& ) {}
299       
300        // check range (may be private because it is static)
301        static reference failed_rangecheck () {
302                std::out_of_range e("attempt to access element of an empty array");
303                boost::throw_exception(e);
304#if defined(BOOST_NO_EXCEPTIONS) || !defined(BOOST_MSVC)
305                //
306                // We need to return something here to keep
307                // some compilers happy: however we will never
308                // actually get here....
309                //
310                static T placeholder;
311                return placeholder;
312#endif
313            }
314    };
315#endif
316
317    // comparisons
318    template<class T, std::size_t N>
319    bool operator== (const array<T,N>& x, const array<T,N>& y) {
320        return std::equal(x.begin(), x.end(), y.begin());
321    }
322    template<class T, std::size_t N>
323    bool operator< (const array<T,N>& x, const array<T,N>& y) {
324        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
325    }
326    template<class T, std::size_t N>
327    bool operator!= (const array<T,N>& x, const array<T,N>& y) {
328        return !(x==y);
329    }
330    template<class T, std::size_t N>
331    bool operator> (const array<T,N>& x, const array<T,N>& y) {
332        return y<x;
333    }
334    template<class T, std::size_t N>
335    bool operator<= (const array<T,N>& x, const array<T,N>& y) {
336        return !(y<x);
337    }
338    template<class T, std::size_t N>
339    bool operator>= (const array<T,N>& x, const array<T,N>& y) {
340        return !(x<y);
341    }
342
343    // global swap()
344    template<class T, std::size_t N>
345    inline void swap (array<T,N>& x, array<T,N>& y) {
346        x.swap(y);
347    }
348
349    // Specific for boost::array: simply returns its elems data member.
350    template <typename T, std::size_t N>
351    T(&get_c_array(boost::array<T,N>& arg))[N]
352    {
353        return arg.elems;
354    }
355   
356    // Const version.
357    template <typename T, std::size_t N>
358    const T(&get_c_array(const boost::array<T,N>& arg))[N]
359    {
360        return arg.elems;
361    }
362
363#if 0
364    // Overload for std::array, assuming that std::array will have
365    // explicit conversion functions as discussed at the WG21 meeting
366    // in Summit, March 2009.
367    template <typename T, std::size_t N>
368    T(&get_c_array(std::array<T,N>& arg))[N]
369    {
370        return static_cast<T(&)[N]>(arg);
371    }
372   
373    // Const version.
374    template <typename T, std::size_t N>
375    const T(&get_c_array(const std::array<T,N>& arg))[N]
376    {
377        return static_cast<T(&)[N]>(arg);
378    }
379#endif
380
381} /* namespace boost */
382
383
384#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) 
385# pragma warning(pop) 
386#endif
387
388#endif /*BOOST_ARRAY_HPP*/
Note: See TracBrowser for help on using the repository browser.