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
|
/* Ergo, version 3.8.2, a program for linear scaling electronic structure
* calculations.
* Copyright (C) 2023 Elias Rudberg, Emanuel H. Rubensson, Pawel Salek,
* and Anastasia Kruchinina.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Primary academic reference:
* Ergo: An open-source program for linear-scaling electronic structure
* calculations,
* Elias Rudberg, Emanuel H. Rubensson, Pawel Salek, and Anastasia
* Kruchinina,
* SoftwareX 7, 107 (2018),
* <http://dx.doi.org/10.1016/j.softx.2018.03.005>
*
* For further information about Ergo, see <http://www.ergoscf.org>.
*/
/** @file ValidPtr.h Smart pointer class to control access to object.
*
* Copyright(c) Emanuel Rubensson 2006
*
* @author Emanuel Rubensson @a responsible @a author
* @date November 2006
*
*/
#ifndef MAT_VALIDPTR
#define MAT_VALIDPTR
namespace mat {
/** Smart pointer class to control access to object
*
* Primary use:
* Control access to objects that may be written to file.
*
*/
template <typename Tobj>
class ValidPtr {
public:
/** Copy ordinary pointer constructor */
explicit ValidPtr(Tobj * p)
: ptr(p), inMemory(true), haveDataStructure(false){}
~ValidPtr() {
delete ptr;
}
/* Pointer can not be changed only object pointed to.
* Therefore this is a const operation.
* Note that if Tobj is const it can not be changed of course.
*/
Tobj & operator*() const {
if (!inMemory)
throw Failure("ValidPtr::operator*() const: "
"Attempt to access invalid object. "
"Object is on file.");
if (!haveDataStructure)
throw Failure("ValidPtr::operator*() const: "
"Attempt to access invalid object. "
"Do not have data structure.");
return *ptr;
}
Tobj * operator->() const {
if (!inMemory)
throw Failure("ValidPtr::operator->() const: "
"Attempt to access invalid pointer."
"Object is on file.");
if (!haveDataStructure)
throw Failure("ValidPtr::operator->() const: "
"Attempt to access invalid pointer. "
"Do not have data structure.");
return ptr;
}
/** getConstRefForCopying() is provided to make it possible to
copy the object also when it is written to file. */
const Tobj & getConstRefForCopying() const {
return *ptr;
}
inline void inMemorySet(bool val) {
inMemory = val;
}
inline bool inMemoryGet() const {
return inMemory;
}
inline void haveDataStructureSet(bool val) {
haveDataStructure = val;
}
inline bool haveDataStructureGet() const {
return haveDataStructure;
}
static void swap( ValidPtr<Tobj> & ptrA, ValidPtr<Tobj> & ptrB ) {
// For the moment, we do not allow swapping ptrs with objs
// written to file. This could be a feature to add but would
// require swapping filenames.
if ( !ptrA.inMemoryGet() || !ptrB.inMemoryGet() )
throw "Swap called for objects not in memory";
if ( !ptrA.haveDataStructureGet() || !ptrB.haveDataStructureGet() )
throw "Swap called for objects without data structure";
Tobj * tmpPtr = ptrA.ptr;
ptrA.ptr = ptrB.ptr;
ptrB.ptr = tmpPtr;
}
protected:
Tobj * ptr;
/** Access to ptr forbidden if inMemory is false */
bool inMemory;
/** Access to ptr forbidden if haveDataStructure is false */
bool haveDataStructure;
private:
ValidPtr<Tobj>(ValidPtr<Tobj> const &) {}
ValidPtr<Tobj>& operator=(ValidPtr<Tobj> const &) {}
};
} /* end namespace mat */
#endif
|
