LSSTApplications  18.1.0
LSSTDataManagementBasePackage
SimpleGenericMap.h
Go to the documentation of this file.
1 // -*- LSST-C++ -*-
2 /*
3  * This file is part of afw.
4  *
5  * Developed for the LSST Data Management System.
6  * This product includes software developed by the LSST Project
7  * (https://www.lsst.org).
8  * See the COPYRIGHT file at the top-level directory of this distribution
9  * for details of code ownership.
10  *
11  * This program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see <https://www.gnu.org/licenses/>.
23  */
24 
25 #ifndef LSST_AFW_TYPEHANDLING_SIMPLEGENERICMAP_H
26 #define LSST_AFW_TYPEHANDLING_SIMPLEGENERICMAP_H
27 
28 #include <exception>
29 #include <sstream>
30 #include <unordered_map>
31 #include <utility>
32 
33 #include "boost/variant.hpp"
34 
36 
37 namespace lsst {
38 namespace afw {
39 namespace typehandling {
40 
49 template <typename K>
50 class SimpleGenericMap final : public MutableGenericMap<K> {
51 protected:
52  using typename GenericMap<K>::StorableType;
54 
55 public:
56  SimpleGenericMap() = default;
57  SimpleGenericMap(SimpleGenericMap const& other) = default;
58  SimpleGenericMap(SimpleGenericMap&&) noexcept = default;
66  SimpleGenericMap(GenericMap<K> const& other) : _storage(_convertStorage(other)), _keyView(other.keys()) {}
67  virtual ~SimpleGenericMap() noexcept = default;
68 
70  std::vector<K> newKeys = other._keyView;
71  _storage = other._storage;
72  // strong exception safety because no exceptions can occur past this point
73  using std::swap;
74  swap(_keyView, newKeys);
75  return *this;
76  }
77  SimpleGenericMap& operator=(SimpleGenericMap&&) noexcept = default;
79  std::vector<K> newKeys = other.keys();
80  // strong exception safety: unordered_map is nothrow move-assignable and
81  // vector is nothrow swappable, so no exceptions can occur after _convertStorage returns
82  _storage = _convertStorage(other);
83  using std::swap;
84  swap(_keyView, newKeys);
85  return *this;
86  }
87 
88  typename GenericMap<K>::size_type size() const noexcept override { return _storage.size(); }
89 
90  bool empty() const noexcept override { return _storage.empty(); }
91 
92  typename GenericMap<K>::size_type max_size() const noexcept override {
93  return std::min(_storage.max_size(), _keyView.max_size());
94  }
95 
96  bool contains(K const& key) const override { return _storage.count(key) > 0; }
97 
98  std::vector<K> const& keys() const noexcept override { return _keyView; }
99 
100  void clear() noexcept override {
101  _storage.clear();
102  _keyView.clear();
103  }
104 
105 protected:
107  try {
108  return _storage.at(key);
109  } catch (std::out_of_range& e) {
110  std::stringstream message;
111  message << "Key not found: " << key;
113  }
114  }
115 
116  bool unsafeInsert(K key, StorableType&& value) override {
117  std::vector<K> newKeys = _keyView;
118  newKeys.emplace_back(key);
119  bool inserted = _storage.emplace(key, std::move(value)).second;
120  // strong exception safety because no exceptions can occur past this point
121  if (inserted) {
122  // _storage did not previously include key, so the key appended to newKeys is unique
123  using std::swap;
124  swap(_keyView, newKeys);
125  }
126  return inserted;
127  }
128 
129  bool unsafeErase(K key) override {
130  std::vector<K> newKeys = _keyView;
131  for (auto it = newKeys.cbegin(); it != newKeys.cend();) {
132  if (*it == key) {
133  it = newKeys.erase(it);
134  } else {
135  ++it;
136  }
137  }
138  // strong exception safety because no exceptions can occur past this point
139  bool erased = _storage.erase(key) > 0;
140  if (erased) {
141  using std::swap;
142  swap(_keyView, newKeys);
143  }
144  return erased;
145  }
146 
147 private:
148  // StorableType is a value, so we might as well use it in the implementation
150  std::vector<K> _keyView;
151  // Class invariant: the elements of _keyView are unique
152  // Class invariant: the elements of _keyView and the keys of _storage are the same
153  // Class invariant: the elements of _keyView are arranged in insertion order, oldest to newest
154 
163  static std::unordered_map<K, StorableType> _convertStorage(GenericMap<K> const& map) {
165  map.apply([&newStorage](K const& key, auto const& value) { newStorage.emplace(key, value); });
166  return newStorage;
167  }
168 };
169 
170 } // namespace typehandling
171 } // namespace afw
172 } // namespace lsst
173 
174 #endif
T empty(T... args)
virtual ~SimpleGenericMap() noexcept=default
bool unsafeInsert(K key, StorableType &&value) override
Create a new mapping with key equal to key and value equal to value.
T swap(T... args)
bool unsafeErase(K key) override
Remove the mapping for a key from this map, if it exists.
decltype(_typeToConstRef(std::declval< StorableType >())) ConstValueReference
A type-agnostic reference to the value stored inside the map.
Definition: GenericMap.h:512
T cend(T... args)
bool empty() const noexcept override
Return true if this map contains no key-value pairs.
boost::variant< bool, std::int32_t, std::int64_t, float, double, std::string, PolymorphicValue, std::shared_ptr< Storable > > StorableType
The types that can be stored in a map.
Definition: GenericMap.h:503
T min(T... args)
T at(T... args)
A base class for image defects.
std::vector< K > const & keys() const noexcept override
Return the set of all keys, without type information.
A GenericMap that allows insertion and deletion of arbitrary values.
T erase(T... args)
T throw_with_nested(T... args)
auto apply(Visitor &&visitor) const
Apply an operation to each key-value pair in the map.
Definition: GenericMap.h:453
T str(T... args)
SimpleGenericMap & operator=(SimpleGenericMap const &other)
T clear(T... args)
T move(T... args)
T count(T... args)
T size(T... args)
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
Reports attempts to access elements outside a valid range of indices.
Definition: Runtime.h:89
GenericMap< K >::size_type size() const noexcept override
Return the number of key-value pairs in the map.
bool contains(K const &key) const override
Return true if this map contains a mapping whose key has the specified label.
T cbegin(T... args)
Key< U > key
Definition: Schema.cc:281
ConstValueReference unsafeLookup(K key) const override
Return a reference to the mapped value of the element with key equal to key.
T max_size(T... args)
T emplace(T... args)
void clear() noexcept override
Remove all of the mappings from this map.
void swap(PolymorphicValue &lhs, PolymorphicValue &rhs) noexcept
Swap specialization for PolymorphicValue.
SimpleGenericMap(GenericMap< K > const &other)
Convert another GenericMap into a SimpleGenericMap.
ItemVariant const * other
Definition: Schema.cc:56
GenericMap< K >::size_type max_size() const noexcept override
Return the maximum number of elements the container is able to hold due to system or library implemen...
Interface for a GenericMap that allows element addition and removal.
Definition: GenericMap.h:742
Interface for a heterogeneous map.
Definition: GenericMap.h:230
SimpleGenericMap & operator=(GenericMap< K > const &other)
T emplace_back(T... args)
virtual std::vector< K > const & keys() const noexcept=0
Return the set of all keys, without type information.