LSSTApplications  20.0.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;
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  }
78  SimpleGenericMap& operator=(GenericMap<K> const& other) {
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
lsst::afw::typehandling::SimpleGenericMap::~SimpleGenericMap
virtual ~SimpleGenericMap() noexcept=default
std::move
T move(T... args)
lsst::afw::typehandling::SimpleGenericMap::SimpleGenericMap
SimpleGenericMap()=default
GenericMap.h
lsst::afw::typehandling::GenericMap::ConstValueReference
decltype(_typeToConstRef(std::declval< StorableType >())) ConstValueReference
A type-agnostic reference to the value stored inside the map.
Definition: GenericMap.h:367
std::vector< K >
std::unordered_map::size
T size(T... args)
lsst::afw::typehandling::SimpleGenericMap::unsafeInsert
bool unsafeInsert(K key, StorableType &&value) override
Create a new mapping with key equal to key and value equal to value.
Definition: SimpleGenericMap.h:116
lsst::afw::typehandling::SimpleGenericMap::SimpleGenericMap
SimpleGenericMap(SimpleGenericMap &&) noexcept=default
lsst::afw
Definition: imageAlgorithm.dox:1
std::unordered_map::emplace
T emplace(T... args)
lsst::afw::typehandling::SimpleGenericMap::keys
std::vector< K > const & keys() const noexcept override
Return the set of all keys, without type information.
Definition: SimpleGenericMap.h:98
std::stringstream
STL class.
std::unordered_map::clear
T clear(T... args)
lsst::afw::typehandling::SimpleGenericMap::SimpleGenericMap
SimpleGenericMap(SimpleGenericMap const &other)=default
lsst::afw::typehandling::SimpleGenericMap::unsafeErase
bool unsafeErase(K key) override
Remove the mapping for a key from this map, if it exists.
Definition: SimpleGenericMap.h:129
lsst::afw::typehandling::SimpleGenericMap::operator=
SimpleGenericMap & operator=(SimpleGenericMap &&) noexcept=default
lsst::afw::typehandling::SimpleGenericMap::max_size
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...
Definition: SimpleGenericMap.h:92
std::unordered_map::at
T at(T... args)
lsst::afw::typehandling::GenericMap
Interface for a heterogeneous map.
Definition: GenericMap.h:78
std::throw_with_nested
T throw_with_nested(T... args)
other
ItemVariant const * other
Definition: Schema.cc:56
lsst::afw::typehandling::GenericMap::StorableType
boost::variant< bool, int, long, long long, float, double, std::string, PolymorphicValue, std::shared_ptr< Storable const > > StorableType
The types that can be stored in a map.
Definition: GenericMap.h:358
std::vector::erase
T erase(T... args)
lsst::afw::typehandling::swap
void swap(PolymorphicValue &lhs, PolymorphicValue &rhs) noexcept
Swap specialization for PolymorphicValue.
Definition: PolymorphicValue.h:152
std::unordered_map::max_size
T max_size(T... args)
lsst::afw::typehandling::SimpleGenericMap::clear
void clear() noexcept override
Remove all of the mappings from this map.
Definition: SimpleGenericMap.h:100
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
std::swap
T swap(T... args)
std::min
T min(T... args)
std::vector::emplace_back
T emplace_back(T... args)
lsst::afw::typehandling::SimpleGenericMap::size
GenericMap< K >::size_type size() const noexcept override
Return the number of key-value pairs in the map.
Definition: SimpleGenericMap.h:88
std::vector::cbegin
T cbegin(T... args)
key
Key< U > key
Definition: Schema.cc:281
lsst::afw::typehandling::SimpleGenericMap
A GenericMap that allows insertion and deletion of arbitrary values.
Definition: SimpleGenericMap.h:50
lsst::afw::typehandling::MutableGenericMap
Interface for a GenericMap that allows element addition and removal.
Definition: GenericMap.h:606
lsst::pex::exceptions::OutOfRangeError
Reports attempts to access elements outside a valid range of indices.
Definition: Runtime.h:89
std::unordered_map::count
T count(T... args)
std::unordered_map::empty
T empty(T... args)
std::out_of_range
STL class.
std::stringstream::str
T str(T... args)
std::size_t
lsst::afw::typehandling::GenericMap::apply
auto apply(Visitor &&visitor) const
Apply an operation to each key-value pair in the map.
Definition: GenericMap.h:306
lsst::afw::typehandling::SimpleGenericMap::contains
bool contains(K const &key) const override
Return true if this map contains a mapping whose key has the specified label.
Definition: SimpleGenericMap.h:96
std::vector::cend
T cend(T... args)
lsst::afw::typehandling::SimpleGenericMap::empty
bool empty() const noexcept override
Return true if this map contains no key-value pairs.
Definition: SimpleGenericMap.h:90
std::unordered_map< K, StorableType >
lsst::afw::typehandling::SimpleGenericMap::unsafeLookup
ConstValueReference unsafeLookup(K key) const override
Return a reference to the mapped value of the element with key equal to key.
Definition: SimpleGenericMap.h:106