1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
77
78
79
80
81
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
// ************************************************************************************************
//
// BornAgain: simulate and fit reflection and scattering
//
//! @file Base/Type/OwningVector.h
//! @brief Defines and implements templated class OwningVector.
//!
//! @homepage http://www.bornagainproject.org
//! @license GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
// ************************************************************************************************
#ifdef SWIG
#error no need to expose this header to Swig
#endif // SWIG
#ifndef BORNAGAIN_BASE_TYPE_OWNINGVECTOR_H
#define BORNAGAIN_BASE_TYPE_OWNINGVECTOR_H
#include <algorithm>
#include <cstddef>
#include <utility>
#include <vector>
//! A vector of unique pointers to objects.
//!
//! Cannot be copied. For a copyable vector of cloneable objects, use CloneableVector.
template <typename T> class OwningVector {
public:
OwningVector() = default;
//! Constructor that takes over ownership of elements in given vector
OwningVector(std::vector<T*> v)
{
m_v.reserve(v.size());
for (T* e : v)
m_v.push_back(e);
}
OwningVector(const OwningVector& other) = delete;
OwningVector(OwningVector&& other) = default;
~OwningVector() { clear(); }
OwningVector& operator=(const OwningVector& other) = delete;
OwningVector& operator=(OwningVector&& other) = default;
void reserve(size_t n) { m_v.reserve(n); }
void push_back(T* e) { m_v.push_back(e); }
void insert_at(size_t i, T* e) { m_v.insert(m_v.begin() + i, e); }
void replace_at(size_t i, T* e)
{
delete m_v.at(i);
m_v[i] = e;
}
void delete_element(const T* e)
{
if (!e)
return;
for (size_t i = 0; i < m_v.size(); i++)
if (m_v[i] == e) {
delete m_v[i];
m_v.erase(m_v.begin() + i);
return;
}
}
void delete_at(size_t i)
{
if (i >= m_v.size())
return;
delete m_v[i];
m_v.erase(m_v.begin() + i);
return;
}
T* release_at(size_t i)
{
if (i >= m_v.size())
return nullptr;
T* result = m_v.at(i);
m_v.erase(m_v.begin() + i);
return result;
}
T* release_back()
{
if (m_v.empty())
return nullptr;
T* result = back();
m_v.pop_back();
return result;
}
T* release_front()
{
if (m_v.empty())
return nullptr;
T* result = m_v.front();
m_v.erase(m_v.begin());
return result;
}
void swap(size_t fromIndex, size_t toIndex)
{
if (fromIndex > toIndex)
std::rotate(m_v.rend() - fromIndex - 1, m_v.rend() - fromIndex, m_v.rend() - toIndex);
else
std::rotate(m_v.begin() + fromIndex, m_v.begin() + fromIndex + 1,
m_v.begin() + toIndex + 1);
}
void clear()
{
for (T* e : *this)
delete e;
m_v.clear();
}
const T* operator[](size_t i) const { return m_v.operator[](i); }
T* operator[](size_t i) { return m_v.operator[](i); }
const T* at(size_t i) const { return m_v.at(i); }
T* at(size_t i) { return m_v.at(i); }
const T* front() const { return m_v.front(); }
T* front() { return m_v.front(); }
const T* back() const { return m_v.back(); }
T* back() { return m_v.back(); }
size_t size() const { return m_v.size(); }
bool empty() const { return m_v.empty(); }
int index_of(const T* t) const
{
for (size_t i = 0; i < m_v.size(); i++)
if (m_v[i] == t)
return int(i);
return -1;
}
const T* at_or(size_t i, T* defolt) const
{
if (i < size())
return m_v.at(i);
return defolt;
}
const std::vector<T*>& shared() const { return m_v; }
using Iterator = typename std::vector<T*>::iterator; // "typename" can be dropped under C++20
using ConstIterator = typename std::vector<T*>::const_iterator;
ConstIterator begin() const { return m_v.cbegin(); }
ConstIterator end() const { return m_v.cend(); }
Iterator begin() { return m_v.begin(); }
Iterator end() { return m_v.end(); }
protected:
std::vector<T*> m_v;
};
#endif // BORNAGAIN_BASE_TYPE_OWNINGVECTOR_H
|
