1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/array.hpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,321 @@
1.4 +/* The following code declares class array,
1.5 + * an STL container (as wrapper) for arrays of constant size.
1.6 + *
1.7 + * See
1.8 + * http://www.boost.org/libs/array/
1.9 + * for documentation.
1.10 + *
1.11 + * The original author site is at: http://www.josuttis.com/
1.12 + *
1.13 + * (C) Copyright Nicolai M. Josuttis 2001.
1.14 + *
1.15 + * Distributed under the Boost Software License, Version 1.0. (See
1.16 + * accompanying file LICENSE_1_0.txt or copy at
1.17 + * http://www.boost.org/LICENSE_1_0.txt)
1.18 + *
1.19 + * 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis)
1.20 + * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries.
1.21 + * 05 Aug 2001 - minor update (Nico Josuttis)
1.22 + * 20 Jan 2001 - STLport fix (Beman Dawes)
1.23 + * 29 Sep 2000 - Initial Revision (Nico Josuttis)
1.24 + *
1.25 + * Jan 29, 2004
1.26 + */
1.27 +#ifndef BOOST_ARRAY_HPP
1.28 +#define BOOST_ARRAY_HPP
1.29 +
1.30 +#include <cstddef>
1.31 +#include <stdexcept>
1.32 +#include <boost/assert.hpp>
1.33 +
1.34 +// Handles broken standard libraries better than <iterator>
1.35 +#include <boost/detail/iterator.hpp>
1.36 +#include <boost/throw_exception.hpp>
1.37 +#include <algorithm>
1.38 +
1.39 +// FIXES for broken compilers
1.40 +#include <boost/config.hpp>
1.41 +
1.42 +
1.43 +namespace boost {
1.44 +
1.45 + template<class T, std::size_t N>
1.46 + class array {
1.47 + public:
1.48 + T elems[N]; // fixed-size array of elements of type T
1.49 +
1.50 + public:
1.51 + // type definitions
1.52 + typedef T value_type;
1.53 + typedef T* iterator;
1.54 + typedef const T* const_iterator;
1.55 + typedef T& reference;
1.56 + typedef const T& const_reference;
1.57 + typedef std::size_t size_type;
1.58 + typedef std::ptrdiff_t difference_type;
1.59 +
1.60 + // iterator support
1.61 + iterator begin() { return elems; }
1.62 + const_iterator begin() const { return elems; }
1.63 + iterator end() { return elems+N; }
1.64 + const_iterator end() const { return elems+N; }
1.65 +
1.66 + // reverse iterator support
1.67 +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
1.68 + typedef std::reverse_iterator<iterator> reverse_iterator;
1.69 + typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
1.70 +#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
1.71 + // workaround for broken reverse_iterator in VC7
1.72 + typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
1.73 + reference, iterator, reference> > reverse_iterator;
1.74 + typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
1.75 + const_reference, iterator, reference> > const_reverse_iterator;
1.76 +#else
1.77 + // workaround for broken reverse_iterator implementations
1.78 + typedef std::reverse_iterator<iterator,T> reverse_iterator;
1.79 + typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
1.80 +#endif
1.81 +
1.82 + reverse_iterator rbegin() { return reverse_iterator(end()); }
1.83 + const_reverse_iterator rbegin() const {
1.84 + return const_reverse_iterator(end());
1.85 + }
1.86 + reverse_iterator rend() { return reverse_iterator(begin()); }
1.87 + const_reverse_iterator rend() const {
1.88 + return const_reverse_iterator(begin());
1.89 + }
1.90 +
1.91 + // operator[]
1.92 + reference operator[](size_type i)
1.93 + {
1.94 + BOOST_ASSERT( i < N && "out of range" );
1.95 + return elems[i];
1.96 + }
1.97 +
1.98 + const_reference operator[](size_type i) const
1.99 + {
1.100 + BOOST_ASSERT( i < N && "out of range" );
1.101 + return elems[i];
1.102 + }
1.103 +
1.104 + // at() with range check
1.105 + reference at(size_type i) { rangecheck(i); return elems[i]; }
1.106 + const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
1.107 +
1.108 + // front() and back()
1.109 + reference front()
1.110 + {
1.111 + return elems[0];
1.112 + }
1.113 +
1.114 + const_reference front() const
1.115 + {
1.116 + return elems[0];
1.117 + }
1.118 +
1.119 + reference back()
1.120 + {
1.121 + return elems[N-1];
1.122 + }
1.123 +
1.124 + const_reference back() const
1.125 + {
1.126 + return elems[N-1];
1.127 + }
1.128 +
1.129 + // size is constant
1.130 + static size_type size() { return N; }
1.131 + static bool empty() { return false; }
1.132 + static size_type max_size() { return N; }
1.133 + enum { static_size = N };
1.134 +
1.135 + // swap (note: linear complexity)
1.136 + void swap (array<T,N>& y) {
1.137 + std::swap_ranges(begin(),end(),y.begin());
1.138 + }
1.139 +
1.140 + // direct access to data (read-only)
1.141 + const T* data() const { return elems; }
1.142 + T* data() { return elems; }
1.143 +
1.144 + // use array as C array (direct read/write access to data)
1.145 + T* c_array() { return elems; }
1.146 +
1.147 + // assignment with type conversion
1.148 + template <typename T2>
1.149 + array<T,N>& operator= (const array<T2,N>& rhs) {
1.150 + std::copy(rhs.begin(),rhs.end(), begin());
1.151 + return *this;
1.152 + }
1.153 +
1.154 + // assign one value to all elements
1.155 + void assign (const T& value)
1.156 + {
1.157 + std::fill_n(begin(),size(),value);
1.158 + }
1.159 +
1.160 + // check range (may be private because it is static)
1.161 + static void rangecheck (size_type i) {
1.162 + if (i >= size()) {
1.163 + throw std::range_error("array<>: index out of range");
1.164 + }
1.165 + }
1.166 +
1.167 + };
1.168 +
1.169 +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
1.170 + template< class T >
1.171 + class array< T, 0 > {
1.172 +
1.173 + public:
1.174 + // type definitions
1.175 + typedef T value_type;
1.176 + typedef T* iterator;
1.177 + typedef const T* const_iterator;
1.178 + typedef T& reference;
1.179 + typedef const T& const_reference;
1.180 + typedef std::size_t size_type;
1.181 + typedef std::ptrdiff_t difference_type;
1.182 +
1.183 + // iterator support
1.184 + iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
1.185 + const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
1.186 + iterator end() { return begin(); }
1.187 + const_iterator end() const { return begin(); }
1.188 +
1.189 + // reverse iterator support
1.190 +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
1.191 + typedef std::reverse_iterator<iterator> reverse_iterator;
1.192 + typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
1.193 +#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
1.194 + // workaround for broken reverse_iterator in VC7
1.195 + typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
1.196 + reference, iterator, reference> > reverse_iterator;
1.197 + typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
1.198 + const_reference, iterator, reference> > const_reverse_iterator;
1.199 +#else
1.200 + // workaround for broken reverse_iterator implementations
1.201 + typedef std::reverse_iterator<iterator,T> reverse_iterator;
1.202 + typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
1.203 +#endif
1.204 +
1.205 + reverse_iterator rbegin() { return reverse_iterator(end()); }
1.206 + const_reverse_iterator rbegin() const {
1.207 + return const_reverse_iterator(end());
1.208 + }
1.209 + reverse_iterator rend() { return reverse_iterator(begin()); }
1.210 + const_reverse_iterator rend() const {
1.211 + return const_reverse_iterator(begin());
1.212 + }
1.213 +
1.214 + // operator[]
1.215 + reference operator[](size_type i)
1.216 + {
1.217 + return failed_rangecheck();
1.218 + }
1.219 +
1.220 + const_reference operator[](size_type i) const
1.221 + {
1.222 + return failed_rangecheck();
1.223 + }
1.224 +
1.225 + // at() with range check
1.226 + reference at(size_type i) { return failed_rangecheck(); }
1.227 + const_reference at(size_type i) const { return failed_rangecheck(); }
1.228 +
1.229 + // front() and back()
1.230 + reference front()
1.231 + {
1.232 + return failed_rangecheck();
1.233 + }
1.234 +
1.235 + const_reference front() const
1.236 + {
1.237 + return failed_rangecheck();
1.238 + }
1.239 +
1.240 + reference back()
1.241 + {
1.242 + return failed_rangecheck();
1.243 + }
1.244 +
1.245 + const_reference back() const
1.246 + {
1.247 + return failed_rangecheck();
1.248 + }
1.249 +
1.250 + // size is constant
1.251 + static size_type size() { return 0; }
1.252 + static bool empty() { return true; }
1.253 + static size_type max_size() { return 0; }
1.254 + enum { static_size = 0 };
1.255 +
1.256 + void swap (array<T,0>& y) {
1.257 + }
1.258 +
1.259 + // direct access to data (read-only)
1.260 + const T* data() const { return 0; }
1.261 + T* data() { return 0; }
1.262 +
1.263 + // use array as C array (direct read/write access to data)
1.264 + T* c_array() { return 0; }
1.265 +
1.266 + // assignment with type conversion
1.267 + template <typename T2>
1.268 + array<T,0>& operator= (const array<T2,0>& ) {
1.269 + return *this;
1.270 + }
1.271 +
1.272 + // assign one value to all elements
1.273 + void assign (const T& ) { }
1.274 +
1.275 + // check range (may be private because it is static)
1.276 + static reference failed_rangecheck () {
1.277 + std::range_error e("attempt to access element of an empty array");
1.278 + boost::throw_exception(e);
1.279 + //
1.280 + // We need to return something here to keep
1.281 + // some compilers happy: however we will never
1.282 + // actually get here....
1.283 + //
1.284 + static T placeholder;
1.285 + return placeholder;
1.286 + }
1.287 + };
1.288 +#endif
1.289 +
1.290 + // comparisons
1.291 + template<class T, std::size_t N>
1.292 + bool operator== (const array<T,N>& x, const array<T,N>& y) {
1.293 + return std::equal(x.begin(), x.end(), y.begin());
1.294 + }
1.295 + template<class T, std::size_t N>
1.296 + bool operator< (const array<T,N>& x, const array<T,N>& y) {
1.297 + return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
1.298 + }
1.299 + template<class T, std::size_t N>
1.300 + bool operator!= (const array<T,N>& x, const array<T,N>& y) {
1.301 + return !(x==y);
1.302 + }
1.303 + template<class T, std::size_t N>
1.304 + bool operator> (const array<T,N>& x, const array<T,N>& y) {
1.305 + return y<x;
1.306 + }
1.307 + template<class T, std::size_t N>
1.308 + bool operator<= (const array<T,N>& x, const array<T,N>& y) {
1.309 + return !(y<x);
1.310 + }
1.311 + template<class T, std::size_t N>
1.312 + bool operator>= (const array<T,N>& x, const array<T,N>& y) {
1.313 + return !(x<y);
1.314 + }
1.315 +
1.316 + // global swap()
1.317 + template<class T, std::size_t N>
1.318 + inline void swap (array<T,N>& x, array<T,N>& y) {
1.319 + x.swap(y);
1.320 + }
1.321 +
1.322 +} /* namespace boost */
1.323 +
1.324 +#endif /*BOOST_ARRAY_HPP*/