list.hh 2.91 KB
Newer Older
Mark Haines's avatar
Mark Haines committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* Copyright 2015 OpenMarket Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <cstddef>

namespace axolotl {

template<typename T, std::size_t max_size>
class List {
public:
    List() : _end(_data) {}

    typedef T * iterator;
    typedef T const * const_iterator;

    T * begin() { return _data; }
    T * end() { return _end; }
    T const * begin() const { return _data; }
    T const * end() const { return _end; }

32
33
34
    /**
     * Is the list empty?
     */
35
    bool empty() const { return _end == _data; }
36

37
38
39
    /**
     * The number of items in the list.
     */
40
    std::size_t size() const { return _end - _data; }
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

    T & operator[](std::size_t index) { return _data[index]; }

    T const & operator[](std::size_t index) const { return _data[index]; }

    /**
     * Erase the item from the list at the given position.
     */
    void erase(T * pos) {
        --_end;
        while (pos != _end) {
            *pos = *(pos + 1);
            ++pos;
        }
    }

    /**
     * Make space for an item in the list at a given position.
     * If inserting the item makes the list longer than max_size then
     * the end of the list is discarded.
     * Returns the where the item is inserted.
     */
    T * insert(T * pos) {
        if (_end != _data + max_size) {
            ++_end;
        } else if (pos == _end) {
            --pos;
        }
        T * tmp = pos;
        while (tmp != _end - 1) {
            *(tmp + 1) = *tmp;
            ++tmp;
        }
        return pos;
    }

Mark Haines's avatar
Mark Haines committed
77
78
79
80
81
    /**
     * Make space for an item in the list at the start of the list
     */
    T * insert() { return insert(begin()); }

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
    /**
     * Insert an item into the list at a given position.
     * If inserting the item makes the list longer than max_size then
     * the end of the list is discarded.
     * Returns the where the item is inserted.
     */
    T * insert(T * pos, T const & value) {
        pos = insert(pos);
        *pos = value;
        return pos;
    }

    List<T, max_size> & operator=(List<T, max_size> const & other) {
        if (this = &other) {
            return *this;
        }
        T * this_pos = _data;
        T * const other_pos = other._data;
        while (other_pos != other._end) {
            *this_pos = *other;
            ++this_pos;
            ++other_pos;
        }
        _end = this_pos;
        return *this;
    }

private:
    T * _end;
    T _data[max_size];
};

} // namespace axolotl