forked from npshub/mantid
-
Notifications
You must be signed in to change notification settings - Fork 0
/
IPropertyManager.cpp
139 lines (127 loc) · 5.41 KB
/
IPropertyManager.cpp
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
// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
// NScD Oak Ridge National Laboratory, European Spallation Source,
// Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidKernel/IPropertyManager.h"
#include "MantidKernel/IPropertySettings.h"
#include "MantidKernel/OptionalBool.h"
///@cond
DEFINE_IPROPERTYMANAGER_GETVALUE(int16_t)
DEFINE_IPROPERTYMANAGER_GETVALUE(uint16_t)
DEFINE_IPROPERTYMANAGER_GETVALUE(int32_t)
DEFINE_IPROPERTYMANAGER_GETVALUE(uint32_t)
DEFINE_IPROPERTYMANAGER_GETVALUE(int64_t)
DEFINE_IPROPERTYMANAGER_GETVALUE(uint64_t)
DEFINE_IPROPERTYMANAGER_GETVALUE(bool)
DEFINE_IPROPERTYMANAGER_GETVALUE(double)
DEFINE_IPROPERTYMANAGER_GETVALUE(OptionalBool)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<int16_t>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<uint16_t>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<int32_t>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<uint32_t>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<int64_t>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<uint64_t>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<double>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<std::string>)
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<std::vector<std::string>>)
namespace Mantid {
namespace Kernel {
// This template implementation has been left in because although you can't
// assign to an existing string
// via the getProperty() method, you can construct a local variable by saying,
// e.g.: std::string s = getProperty("myProperty")
template <> DLLExport std::string IPropertyManager::getValue<std::string>(const std::string &name) const {
return getPropertyValue(name);
}
template <> DLLExport Property *IPropertyManager::getValue<Property *>(const std::string &name) const {
return getPointerToProperty(name);
}
// If a string is given in the argument, we can be more flexible
template <>
IPropertyManager *IPropertyManager::setProperty<std::string>(const std::string &name, const std::string &value) {
this->setPropertyValue(name, value);
return this;
}
/**
* @param name The name of the property being looked for.
* @return True if the property is managed by this.
*/
bool IPropertyManager::existsProperty(const std::string &name) const {
auto props = this->getProperties();
for (std::vector<Property *>::const_iterator prop = props.begin(); prop != props.end(); ++prop) {
if (name == (*prop)->name())
return true;
}
return false;
}
/**
* Set values of the properties existing in this manager to the values of
* properties with the same name in another manger.
* @param other A property manager to copy property values from.
*/
void IPropertyManager::updatePropertyValues(const IPropertyManager &other) {
auto props = this->getProperties();
for (auto &prop : props) {
const std::string propName = (*prop).name();
if (other.existsProperty(propName)) {
(*prop).setValueFromProperty(*other.getPointerToProperty(propName));
}
}
}
/** Give settings to a property to determine when it gets enabled/hidden.
* Passes ownership of the given IPropertySettings object to the named
* property
* @param name :: property name
* @param settings :: IPropertySettings */
void IPropertyManager::setPropertySettings(const std::string &name, std::unique_ptr<IPropertySettings> settings) {
Property *prop = getPointerToProperty(name);
if (prop)
prop->setSettings(std::move(settings));
}
/**
* Get all properties in a group.
* @param group Name of a group.
*/
std::vector<Property *> IPropertyManager::getPropertiesInGroup(const std::string &group) const {
auto props = getProperties();
for (auto prop = props.begin(); prop != props.end();) {
if ((**prop).getGroup() == group) {
++prop;
} else {
prop = props.erase(prop);
}
}
return props;
}
// Definitions for TypedValue cast operators
// Have to come after getValue definitions above to keep MSVS2010 happy
IPropertyManager::TypedValue::operator int16_t() { return pm.getValue<int16_t>(prop); }
IPropertyManager::TypedValue::operator uint16_t() { return pm.getValue<uint16_t>(prop); }
IPropertyManager::TypedValue::operator int32_t() { return pm.getValue<int32_t>(prop); }
IPropertyManager::TypedValue::operator uint32_t() { return pm.getValue<uint32_t>(prop); }
IPropertyManager::TypedValue::operator int64_t() { return pm.getValue<int64_t>(prop); }
IPropertyManager::TypedValue::operator uint64_t() { return pm.getValue<uint64_t>(prop); }
IPropertyManager::TypedValue::operator bool() { return pm.getValue<bool>(prop); }
IPropertyManager::TypedValue::operator double() { return pm.getValue<double>(prop); }
IPropertyManager::TypedValue::operator std::string() { return pm.getPropertyValue(prop); }
IPropertyManager::TypedValue::operator OptionalBool() { return pm.getValue<OptionalBool>(prop); }
IPropertyManager::TypedValue::operator Property *() { return pm.getPointerToProperty(prop); }
#ifdef __APPLE__
} // namespace Kernel
} // namespace Mantid
// These must precede the operator() declaration
DEFINE_IPROPERTYMANAGER_GETVALUE(unsigned long);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<unsigned long>);
namespace Mantid {
namespace Kernel {
// Intel 64-bit size_t
IPropertyManager::TypedValue::operator unsigned long() { return pm.getValue<unsigned long>(prop); }
} // namespace Kernel
} // namespace Mantid
#else
} // namespace Kernel
} // namespace Mantid
#endif
/// @endcond