← Back to branch summary

~ubuntu-branches/ubuntu/breezy/aqsis/breezy

« back to all changes in this revision

Viewing changes to boost/boost/array.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Will Newton
  • Date: 2004-12-07 20:06:49 UTC
  • Revision ID: james.westby@ubuntu.com-20041207200649-fccswkrvp4oc8lmn
Tags: upstream-0.9.3
Import upstream version 0.9.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/boost/array.hpp
 
1
/* The following code declares class array,
 
2
 * an STL container (as wrapper) for arrays of constant size.
 
3
 *
 
4
 * See
 
5
 *      http://www.josuttis.com/cppcode
 
6
 * for details and the latest version.
 
7
 *
 
8
 * (C) Copyright Nicolai M. Josuttis 2001.
 
9
 * Permission to copy, use, modify, sell and distribute this software
 
10
 * is granted provided this copyright notice appears in all copies.
 
11
 * This software is provided "as is" without express or implied
 
12
 * warranty, and with no claim as to its suitability for any purpose.
 
13
 *
 
14
 * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries.
 
15
 * 05 Aug 2001 - minor update (Nico Josuttis)
 
16
 * 20 Jan 2001 - STLport fix (Beman Dawes)
 
17
 * 29 Sep 2000 - Initial Revision (Nico Josuttis)
 
18
 */
 
19
 
 
20
// See http://www.boost.org/libs/array for Documentation.
 
21
 
 
22
#ifndef BOOST_ARRAY_HPP
 
23
#define BOOST_ARRAY_HPP
 
24
 
 
25
#include <cstddef>
 
26
#include <stdexcept>
 
27
 
 
28
// Handles broken standard libraries better than <iterator>
 
29
#include <boost/detail/iterator.hpp>
 
30
#include <algorithm>
 
31
 
 
32
// FIXES for broken compilers
 
33
#include <boost/config.hpp>
 
34
 
 
35
namespace boost {
 
36
 
 
37
    template<class T, std::size_t N>
 
38
    class array {
 
39
      public:
 
40
        T elems[N];    // fixed-size array of elements of type T
 
41
 
 
42
      public:
 
43
        // type definitions
 
44
        typedef T              value_type;
 
45
        typedef T*             iterator;
 
46
        typedef const T*       const_iterator;
 
47
        typedef T&             reference;
 
48
        typedef const T&       const_reference;
 
49
        typedef std::size_t    size_type;
 
50
        typedef std::ptrdiff_t difference_type;
 
51
    
 
52
        // iterator support
 
53
        iterator begin() { return elems; }
 
54
        const_iterator begin() const { return elems; }
 
55
        iterator end() { return elems+N; }
 
56
        const_iterator end() const { return elems+N; }
 
57
 
 
58
        // reverse iterator support
 
59
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
 
60
        typedef std::reverse_iterator<iterator> reverse_iterator;
 
61
        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
62
#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
 
63
        // workaround for broken reverse_iterator in VC7
 
64
        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
 
65
                                      reference, iterator, reference> > reverse_iterator;
 
66
        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
 
67
                                      const_reference, iterator, reference> > const_reverse_iterator;
 
68
#else
 
69
        // workaround for broken reverse_iterator implementations
 
70
        typedef std::reverse_iterator<iterator,T> reverse_iterator;
 
71
        typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
 
72
#endif
 
73
 
 
74
        reverse_iterator rbegin() { return reverse_iterator(end()); }
 
75
        const_reverse_iterator rbegin() const {
 
76
            return const_reverse_iterator(end());
 
77
        }
 
78
        reverse_iterator rend() { return reverse_iterator(begin()); }
 
79
        const_reverse_iterator rend() const {
 
80
            return const_reverse_iterator(begin());
 
81
        }
 
82
 
 
83
        // operator[]
 
84
        reference operator[](size_type i) { return elems[i]; }
 
85
        const_reference operator[](size_type i) const { return elems[i]; }
 
86
 
 
87
        // at() with range check
 
88
        reference at(size_type i) { rangecheck(i); return elems[i]; }
 
89
        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
 
90
    
 
91
        // front() and back()
 
92
        reference front() { return elems[0]; }
 
93
        const_reference front() const { return elems[0]; }
 
94
        reference back() { return elems[N-1]; }
 
95
        const_reference back() const { return elems[N-1]; }
 
96
 
 
97
        // size is constant
 
98
        static size_type size() { return N; }
 
99
        static bool empty() { return false; }
 
100
        static size_type max_size() { return N; }
 
101
        enum { static_size = N };
 
102
 
 
103
        // swap (note: linear complexity)
 
104
        void swap (array<T,N>& y) {
 
105
            std::swap_ranges(begin(),end(),y.begin());
 
106
        }
 
107
 
 
108
        // direct access to data
 
109
        const T* data() const { return elems; }
 
110
 
 
111
        // assignment with type conversion
 
112
        template <typename T2>
 
113
        array<T,N>& operator= (const array<T2,N>& rhs) {
 
114
            std::copy(rhs.begin(),rhs.end(), begin());
 
115
            return *this;
 
116
        }
 
117
 
 
118
        // assign one value to all elements
 
119
        void assign (const T& value)
 
120
        {
 
121
            std::fill_n(begin(),size(),value);
 
122
        }
 
123
 
 
124
#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE
 
125
      private:
 
126
#endif
 
127
        // check range (may be private because it is static)
 
128
        static void rangecheck (size_type i) {
 
129
            if (i >= size()) { throw std::range_error("array"); }
 
130
        }
 
131
 
 
132
    };
 
133
 
 
134
    // comparisons
 
135
    template<class T, std::size_t N>
 
136
    bool operator== (const array<T,N>& x, const array<T,N>& y) {
 
137
        return std::equal(x.begin(), x.end(), y.begin());
 
138
    }
 
139
    template<class T, std::size_t N>
 
140
    bool operator< (const array<T,N>& x, const array<T,N>& y) {
 
141
        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
 
142
    }
 
143
    template<class T, std::size_t N>
 
144
    bool operator!= (const array<T,N>& x, const array<T,N>& y) {
 
145
        return !(x==y);
 
146
    }
 
147
    template<class T, std::size_t N>
 
148
    bool operator> (const array<T,N>& x, const array<T,N>& y) {
 
149
        return y<x;
 
150
    }
 
151
    template<class T, std::size_t N>
 
152
    bool operator<= (const array<T,N>& x, const array<T,N>& y) {
 
153
        return !(y<x);
 
154
    }
 
155
    template<class T, std::size_t N>
 
156
    bool operator>= (const array<T,N>& x, const array<T,N>& y) {
 
157
        return !(x<y);
 
158
    }
 
159
 
 
160
    // global swap()
 
161
    template<class T, std::size_t N>
 
162
    inline void swap (array<T,N>& x, array<T,N>& y) {
 
163
        x.swap(y);
 
164
    }
 
165
 
 
166
} /* namespace boost */
 
167
 
 
168
#endif /*BOOST_ARRAY_HPP*/
 
169
 
 
170
 
 
171
 
 
172
 
 
173
 
 
174
 
 
175