LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
StorableMap.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_IMAGE_DETAIL_STORABLEMAP_H
26 #define LSST_AFW_IMAGE_DETAIL_STORABLEMAP_H
27 
28 #include <exception>
29 #include <memory>
30 #include <sstream>
31 #include <string>
32 #include <type_traits>
33 #include <unordered_map>
34 #include <utility>
35 
36 #include "lsst/pex/exceptions.h"
39 
40 namespace lsst {
41 namespace afw {
42 namespace image {
43 namespace detail {
44 
60 public:
67  using const_reference = value_type const&;
68  using pointer = value_type*;
69  using const_pointer = value_type const*;
70 
71 private:
73 
74 public:
75  // These definitions may be replaced with adapters if we need
76  // StorableMap's iterators to behave differently from _Impl's.
77  using const_iterator = _Impl::const_iterator;
78  using iterator = _Impl::iterator;
81 
82  template <typename V>
85 
87  StorableMap(StorableMap const& other);
91  ~StorableMap() noexcept;
92 
105  StorableMap(std::initializer_list<value_type> init);
106 
121  template <typename T>
122  std::shared_ptr<T> at(Key<std::shared_ptr<T>> const& key) const {
124  "Can only retrieve pointers to subclasses of Storable.");
125  static_assert(std::is_const<T>::value,
126  "Due to implementation constraints, pointers to non-const are not supported.");
127  try {
128  // unordered_map::at(Key<Storable>) does not do any type-checking.
129  mapped_type const& pointer = _contents.at(key);
130 
131  // Null pointer stored; skip dynamic_cast because won't change result.
132  if (pointer == nullptr) {
133  return nullptr;
134  }
135 
136  std::shared_ptr<T> typedPointer = std::dynamic_pointer_cast<T>(pointer);
137  // shared_ptr can be empty without being null. dynamic_pointer_cast
138  // only promises result of failed cast is empty, so test for that.
139  if (typedPointer.use_count() > 0) {
140  return typedPointer;
141  } else {
142  std::stringstream message;
143  message << "Key " << key << " not found, but a key labeled " << key.getId() << " is present.";
145  }
146  } catch (std::out_of_range const&) {
148  "No key labeled " + key.getId() + " found."));
149  }
150  }
151 
153  size_type size() const noexcept;
154 
156  bool empty() const noexcept;
157 
167  size_type max_size() const noexcept;
168 
184  bool contains(std::string const& key) const;
185 
200  template <typename T>
201  bool contains(Key<std::shared_ptr<T>> const& key) const {
203  "Can only retrieve pointers to subclasses of Storable.");
204  static_assert(std::is_const<T>::value,
205  "Due to implementation constraints, pointers to non-const are not supported.");
206  if (_contents.count(key) > 0) {
207  // unordered_map::at(Key<Storable>) does not do any type-checking.
208  mapped_type const& pointer = _contents.at(key);
209 
210  // Null pointer stored; dynamic_cast will always return null.
211  if (pointer == nullptr) {
212  return true;
213  }
214 
215  std::shared_ptr<T> typedPointer = std::dynamic_pointer_cast<T>(pointer);
216  // shared_ptr can be empty without being null. dynamic_pointer_cast
217  // only promises result of failed cast is empty, so test for that.
218  return typedPointer.use_count() > 0;
219  } else {
220  return false;
221  }
222  }
223 
232  bool operator==(StorableMap const& other) const noexcept;
233 
234  bool operator!=(StorableMap const& other) const noexcept { return !(*this == other); }
235 
243  void clear() noexcept;
244 
262  template <typename T>
263  bool insert(Key<std::shared_ptr<T>> const& key, std::shared_ptr<T> const& value) {
265  "Can only store shared pointers to subclasses of Storable.");
266  static_assert(std::is_const<T>::value,
267  "Due to implementation constraints, pointers to non-const are not supported.");
268  // unordered_map uses Key<shared_ptr<Storable>> internally, so
269  // any key with the same ID will block emplacement.
270  return _contents.emplace(key, value).second;
271  }
272 
292  template <typename T>
293  std::pair<Key<T>, bool> insert(std::string const& key, T const& value) {
294  auto strongKey = typehandling::makeKey<T>(key);
295  // Construct return value in advance, so that exception from
296  // copying/moving Key is atomic.
297  auto result = std::make_pair(strongKey, false);
298  result.second = insert(strongKey, value);
299  return result;
300  }
301 
310  template <typename T>
311  bool erase(Key<T> const& key) noexcept {
312  // unordered_map::erase(Key<Storable>) does no type checking.
313  if (this->contains(key)) {
314  return _contents.erase(key) > 0;
315  } else {
316  return false;
317  }
318  }
319 
328  iterator begin() noexcept;
329  const_iterator begin() const noexcept;
330  const_iterator cbegin() const noexcept { return begin(); }
331 
342  iterator end() noexcept;
343  const_iterator end() const noexcept;
344  const_iterator cend() const noexcept { return end(); }
345 
348 private:
349  _Impl _contents;
350 };
351 
352 } // namespace detail
353 } // namespace image
354 } // namespace afw
355 } // namespace lsst
356 
357 #endif
py::object result
Definition: _schema.cc:429
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
T at(T... args)
A map of Storable supporting strongly-typed access.
Definition: StorableMap.h:59
bool operator==(StorableMap const &other) const noexcept
Test for map equality.
Definition: StorableMap.cc:52
StorableMap & operator=(StorableMap &&other)
std::shared_ptr< T > at(Key< std::shared_ptr< T >> const &key) const
Return a the mapped value of the element with key equal to key.
Definition: StorableMap.h:122
std::pair< Key< T >, bool > insert(std::string const &key, T const &value)
Insert an element into the map, if the map doesn't already contain a mapping with a conflicting key.
Definition: StorableMap.h:293
bool empty() const noexcept
Return true if this map contains no key-value pairs.
Definition: StorableMap.cc:46
bool contains(std::string const &key) const
Return true if this map contains a mapping whose key has the specified label.
Definition: StorableMap.cc:50
bool operator!=(StorableMap const &other) const noexcept
Test for map equality.
Definition: StorableMap.h:234
void clear() noexcept
Remove all of the mappings from this map.
Definition: StorableMap.cc:54
size_type size() const noexcept
Return the number of key-value pairs in the map.
Definition: StorableMap.cc:44
bool erase(Key< T > const &key) noexcept
Remove the mapping for a key from this map, if it exists.
Definition: StorableMap.h:311
const_iterator cend() const noexcept
Return an iterator to the element past the end of the map.
Definition: StorableMap.h:344
const_iterator cbegin() const noexcept
Return an iterator to the first element of the map.
Definition: StorableMap.h:330
iterator begin() noexcept
Return an iterator to the first element of the map.
Definition: StorableMap.cc:63
bool insert(Key< std::shared_ptr< T >> const &key, std::shared_ptr< T > const &value)
Insert an element into the map, if the map doesn't already contain a mapping with the same or a confl...
Definition: StorableMap.h:263
StorableMap(StorableMap const &other)
_Impl::const_iterator const_iterator
Definition: StorableMap.h:77
iterator end() noexcept
Return an iterator to the element past the end of the map.
Definition: StorableMap.cc:64
StorableMap & operator=(StorableMap const &other)
size_type max_size() const noexcept
Return the maximum number of elements the container is able to hold due to system or library implemen...
Definition: StorableMap.cc:48
Key for type-safe lookup in a GenericMap.
Definition: Key.h:52
Interface supporting iteration over heterogenous containers.
Definition: Storable.h:58
Reports attempts to access elements outside a valid range of indices.
Definition: Runtime.h:89
T count(T... args)
T emplace(T... args)
T erase(T... args)
T make_pair(T... args)
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.
class[[deprecated("Removed with no replacement (but see lsst::afw::image::TransmissionCurve). Will be " "removed after v22.")]] FilterProperty final
Describe the properties of a Filter (e.g.
Definition: Filter.h:53
A base class for image defects.
STL namespace.
T str(T... args)
T throw_with_nested(T... args)