Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages
HashGrid.h
Go to the documentation of this file.
1 // --------------------------------------------------------------------------
2 // OpenMS -- Open-Source Mass Spectrometry
3 // --------------------------------------------------------------------------
4 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
5 // ETH Zurich, and Freie Universitaet Berlin 2002-2015.
6 //
7 // This software is released under a three-clause BSD license:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of any author or any participating institution
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 // For a full list of authors, refer to the file AUTHORS.
17 // --------------------------------------------------------------------------
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
22 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // --------------------------------------------------------------------------
31 // $Maintainer: Lars Nilse $
32 // $Authors: Bastian Blank $
33 // --------------------------------------------------------------------------
34 
35 #include <cmath>
36 #include <iterator>
37 #include <limits>
38 
39 #include <boost/array.hpp>
40 #include <boost/functional/hash.hpp>
41 #include <boost/unordered/unordered_map.hpp>
42 
43 #include <OpenMS/CONCEPT/Types.h>
45 
46 #ifndef OPENMS_COMPARISON_CLUSTERING_HASHGRID_H
47 #define OPENMS_COMPARISON_CLUSTERING_HASHGRID_H
48 
49 namespace OpenMS
50 {
61  template <typename Cluster>
62  class HashGrid
63  {
64 public:
68  // XXX: Check is there is another type handy in OpenMS already
70 
75 
79  typedef typename boost::unordered_multimap<ClusterCenter, Cluster> CellContent;
80 
84  typedef boost::unordered_map<CellIndex, CellContent> Grid;
85 
86  typedef typename CellContent::key_type key_type;
87  typedef typename CellContent::mapped_type mapped_type;
88  typedef typename CellContent::value_type value_type;
89 
90 private:
94  class Iterator :
95  public std::iterator<std::input_iterator_tag, value_type>
96  {
97 private:
98  friend class HashGrid;
99 
100  typedef typename Grid::iterator grid_iterator;
101  typedef typename CellContent::iterator cell_iterator;
102 
106 
107  // Search for next non-empty cell
109  {
110  while (cell_it_ == grid_it_->second.end())
111  {
112  grid_it_++;
113 
114  // If we are at the last cell, set cell iterator to something well-known
115  if (grid_it_ == grid_.end())
116  {
118  return;
119  }
120 
121  cell_it_ = grid_it_->second.begin();
122  }
123  }
124 
125 public:
126  Iterator(Grid & grid) :
127  grid_(grid), grid_it_(grid.end())
128  {}
129 
130  Iterator(Grid & grid, grid_iterator grid_it, cell_iterator cell_it) :
131  grid_(grid), grid_it_(grid_it), cell_it_(cell_it)
132  {
133  searchNextCell_();
134  }
135 
137  {
138  ++cell_it_;
139  searchNextCell_();
140  return *this;
141  }
142 
144  {
145  Iterator ret(*this);
146  operator++();
147  return ret;
148  }
149 
150  bool operator==(const Iterator & rhs) const
151  { return grid_it_ == rhs.grid_it_ && cell_it_ == rhs.cell_it_; }
152 
153  bool operator!=(const Iterator & rhs) const
154  { return !(*this == rhs); }
155 
157  { return *cell_it_; }
158 
160  { return &*cell_it_; }
161 
162  const CellIndex index() const
163  {
164  return grid_it_->first;
165  }
166 
167  };
168 
173  public std::iterator<std::input_iterator_tag, const value_type>
174  {
175 private:
176  friend class HashGrid;
177 
178  typedef typename Grid::const_iterator grid_iterator;
179  typedef typename CellContent::const_iterator cell_iterator;
180 
181  const Grid & grid_;
184 
185  // Search for next non-empty cell
187  {
188  while (cell_it_ == grid_it_->second.end())
189  {
190  grid_it_++;
191 
192  // If we are at the last cell, set cell iterator to something well-known
193  if (grid_it_ == grid_.end())
194  {
196  return;
197  }
198 
199  cell_it_ = grid_it_->second.begin();
200  }
201  }
202 
203 public:
204  ConstIterator(const Grid & grid) :
205  grid_(grid), grid_it_(grid.end())
206  {}
207 
208  ConstIterator(const Grid & grid, grid_iterator grid_it, cell_iterator cell_it) :
209  grid_(grid), grid_it_(grid_it), cell_it_(cell_it)
210  {
211  searchNextCell_();
212  }
213 
214  ConstIterator(const Iterator & it) :
216  {}
217 
219  {
220  ++cell_it_;
221  searchNextCell_();
222  return *this;
223  }
224 
226  {
227  ConstIterator ret(*this);
228  operator++();
229  return ret;
230  }
231 
232  bool operator==(const ConstIterator & rhs) const
233  { return grid_it_ == rhs.grid_it_ && cell_it_ == rhs.cell_it_; }
234 
235  bool operator!=(const ConstIterator & rhs) const
236  { return !(*this == rhs); }
237 
238  const value_type & operator*() const
239  { return *cell_it_; }
240 
241  const value_type * operator->() const
242  { return &*cell_it_; }
243 
244  const CellIndex index() const
245  {
246  return grid_it_->first;
247  }
248 
249  };
250 
251 public:
254  typedef typename Grid::const_iterator const_grid_iterator;
255  typedef typename Grid::iterator grid_iterator;
256  typedef typename CellContent::const_iterator const_cell_iterator;
257  typedef typename CellContent::iterator cell_iterator;
258  typedef typename CellContent::size_type size_type;
259 
260 private:
263 
264 public:
273 
274 public:
276  cells_(),
277  grid_dimension_(),
278  cell_dimension(cell_dimension),
280  {}
281 
288  {
289  const CellIndex cellkey = cellindexAtClustercenter_(v.first);
290  CellContent & cell = cells_[cellkey];
291  updateGridDimension_(cellkey);
292  return cell.insert(v);
293  }
294 
298  void erase(iterator pos)
299  {
300  CellContent & cell = pos.grid_it_->second;
301  cell.erase(pos.cell_it_);
302  }
303 
309  size_type erase(const key_type & key)
310  {
311  const CellIndex cellkey = cellindexAtClustercenter_(key);
312  try
313  {
314  CellContent & cell = cells_.at(cellkey);
315  return cell.erase(key);
316  }
317  catch (std::out_of_range &) {}
318  return 0;
319  }
320 
324  void clear() { cells_.clear(); }
325 
330  {
331  grid_iterator grid_it = cells_.begin();
332  if (grid_it == cells_.end()) return end();
333 
334  cell_iterator cell_it = grid_it->second.begin();
335  return iterator(cells_, grid_it, cell_it);
336  }
337 
342  {
343  const_grid_iterator grid_it = cells_.begin();
344  if (grid_it == cells_.end()) return end();
345 
346  const_cell_iterator cell_it = grid_it->second.begin();
347  return const_iterator(cells_, grid_it, cell_it);
348  }
349 
354  {
355  return iterator(cells_);
356  }
357 
362  {
363  return const_iterator(cells_);
364  }
365 
369  bool empty() const
370  {
371  return size() == 0;
372  }
373 
377  size_type size() const
378  {
379  size_type ret = 0;
380 
381  for (const_grid_iterator it = grid_begin(); it != grid_end(); ++it)
382  {
383  ret += it->second.size();
384  }
385 
386  return ret;
387  }
388 
392  const_grid_iterator grid_begin() const { return cells_.begin(); }
393 
397  const_grid_iterator grid_end() const { return cells_.end(); }
398 
402  const typename Grid::mapped_type & grid_at(const CellIndex & x) const { return cells_.at(x); }
403 
407  grid_iterator grid_begin() { return cells_.begin(); }
411  grid_iterator grid_end() { return cells_.end(); }
415  typename Grid::mapped_type & grid_at(const CellIndex & x) { return cells_.at(x); }
416 
417 private:
418  // XXX: Replace with proper operator
420  {
421  CellIndex ret;
422  typename CellIndex::iterator it = ret.begin();
423  typename ClusterCenter::const_iterator lit = key.begin(), rit = cell_dimension.begin();
424  for (; it != ret.end(); ++it, ++lit, ++rit)
425  {
426  double t = std::floor(*lit / *rit);
427  if (t < std::numeric_limits<Int64>::min() || t > std::numeric_limits<Int64>::max()) throw Exception::OutOfRange(__FILE__, __LINE__, __PRETTY_FUNCTION__);
428  *it = static_cast<Int64>(t);
429  }
430  return ret;
431  }
432 
434  {
435  typename CellIndex::const_iterator it_new = d.begin();
436  typename CellIndex::iterator it_cur = grid_dimension_.begin();
437  for (; it_new != d.end(); ++it_new, ++it_cur)
438  {
439  if (*it_cur < *it_new)
440  *it_cur = *it_new;
441  }
442  }
443 
444  };
445 
447  template <UInt N, typename T>
448  std::size_t hash_value(const DPosition<N, T> & b)
449  {
450  boost::hash<T> hasher;
451  std::size_t hash = 0;
452  for (typename DPosition<N, T>::const_iterator it = b.begin(); it != b.end(); ++it)
453  hash ^= hasher(*it);
454  return hash;
455  }
456 
457 }
458 
459 #endif /* OPENMS_COMPARISON_CLUSTERING_HASHGRID_H */
Iterator(Grid &grid, grid_iterator grid_it, cell_iterator cell_it)
Definition: HashGrid.h:130
HashGrid(const ClusterCenter &cell_dimension)
Definition: HashGrid.h:275
Container for (2-dimensional coordinate, value) pairs.
Definition: HashGrid.h:62
Grid & grid_
Definition: HashGrid.h:103
CellContent::iterator cell_iterator
Definition: HashGrid.h:101
Grid::iterator grid_iterator
Definition: HashGrid.h:100
const CoordinateType * const_iterator
Definition: DPosition.h:77
CellContent::const_iterator const_cell_iterator
Definition: HashGrid.h:256
Out of range exception.
Definition: Exception.h:320
boost::unordered_map< CellIndex, CellContent > Grid
Map of (cell-index, cell-content).
Definition: HashGrid.h:84
ConstIterator(const Grid &grid, grid_iterator grid_it, cell_iterator cell_it)
Definition: HashGrid.h:208
DPosition< 2, Int64 > CellIndex
Index for cells.
Definition: HashGrid.h:74
cell_iterator insert(const value_type &v)
Inserts a (2-dimensional coordinate, value) pair.
Definition: HashGrid.h:287
bool empty() const
Return true if HashGrid is empty.
Definition: HashGrid.h:369
const Grid & grid_
Definition: HashGrid.h:181
grid_iterator grid_it_
Definition: HashGrid.h:104
grid_iterator grid_begin()
Definition: HashGrid.h:407
const_grid_iterator grid_end() const
Returns iterator to on after last grid cell.
Definition: HashGrid.h:397
const value_type & operator*() const
Definition: HashGrid.h:238
ConstIterator const_iterator
Definition: HashGrid.h:252
void updateGridDimension_(const CellIndex &d)
Definition: HashGrid.h:433
Iterator iterator
Definition: HashGrid.h:253
std::size_t hash_value(const DPosition< N, T > &b)
Definition: HashGrid.h:448
Iterator operator++(int)
Definition: HashGrid.h:143
boost::unordered_multimap< ClusterCenter, Cluster > CellContent
Contents of a cell.
Definition: HashGrid.h:79
Grid::const_iterator grid_iterator
Definition: HashGrid.h:178
CellContent::key_type key_type
Definition: HashGrid.h:86
ConstIterator(const Iterator &it)
Definition: HashGrid.h:214
const CellIndex & grid_dimension
Upper-right corner of key space for cells.
Definition: HashGrid.h:272
Constant element iterator for the hash grid.
Definition: HashGrid.h:172
cell_iterator cell_it_
Definition: HashGrid.h:105
Grid cells_
Definition: HashGrid.h:261
iterator begin()
Returns iterator to first element.
Definition: HashGrid.h:329
ConstIterator & operator++()
Definition: HashGrid.h:218
CellContent::value_type value_type
Definition: HashGrid.h:88
ConstIterator end() const
Non-mutable end iterator.
Definition: DPosition.h:395
CoordinateType * iterator
Definition: DPosition.h:76
void searchNextCell_()
Definition: HashGrid.h:186
CellIndex grid_dimension_
Definition: HashGrid.h:262
Representation of a coordinate in D-dimensional space.
Definition: DPosition.h:54
const_grid_iterator grid_begin() const
Returns iterator to first grid cell.
Definition: HashGrid.h:392
void searchNextCell_()
Definition: HashGrid.h:108
const value_type * operator->() const
Definition: HashGrid.h:241
value_type * operator->() const
Definition: HashGrid.h:159
void clear()
Clears the map.
Definition: HashGrid.h:324
grid_iterator grid_end()
Definition: HashGrid.h:411
const CellIndex index() const
Definition: HashGrid.h:244
Grid::mapped_type & grid_at(const CellIndex &x)
Definition: HashGrid.h:415
bool operator!=(const ConstIterator &rhs) const
Definition: HashGrid.h:235
bool operator==(const Iterator &rhs) const
Definition: HashGrid.h:150
ConstIterator(const Grid &grid)
Definition: HashGrid.h:204
CellIndex cellindexAtClustercenter_(const ClusterCenter &key)
Definition: HashGrid.h:419
const_iterator begin() const
Returns iterator to first element.
Definition: HashGrid.h:341
bool operator==(const ConstIterator &rhs) const
Definition: HashGrid.h:232
Element iterator for the hash grid.
Definition: HashGrid.h:94
Grid::iterator grid_iterator
Definition: HashGrid.h:255
DPosition< 2, double > ClusterCenter
Coordinate for stored pairs.
Definition: HashGrid.h:69
const_iterator end() const
Returns iterator to first element.
Definition: HashGrid.h:361
CellContent::size_type size_type
Definition: HashGrid.h:258
size_type erase(const key_type &key)
Erases elements matching the 2-dimensional coordinate.
Definition: HashGrid.h:309
CellContent::mapped_type mapped_type
Definition: HashGrid.h:87
const CellIndex index() const
Definition: HashGrid.h:162
grid_iterator grid_it_
Definition: HashGrid.h:182
OPENMS_INT64_TYPE Int64
Signed integer type (64bit)
Definition: Types.h:64
Iterator(Grid &grid)
Definition: HashGrid.h:126
bool operator!=(const Iterator &rhs) const
Definition: HashGrid.h:153
const ClusterCenter cell_dimension
Dimension of cells.
Definition: HashGrid.h:268
CellContent::const_iterator cell_iterator
Definition: HashGrid.h:179
size_type size() const
Return number of elements.
Definition: HashGrid.h:377
Grid::const_iterator const_grid_iterator
Definition: HashGrid.h:254
ConstIterator operator++(int)
Definition: HashGrid.h:225
Iterator & operator++()
Definition: HashGrid.h:136
void erase(iterator pos)
Erases element on given iterator.
Definition: HashGrid.h:298
CellContent::iterator cell_iterator
Definition: HashGrid.h:257
value_type & operator*() const
Definition: HashGrid.h:156
iterator end()
Returns iterator to first element.
Definition: HashGrid.h:353
ConstIterator begin() const
Non-mutable begin iterator.
Definition: DPosition.h:389
cell_iterator cell_it_
Definition: HashGrid.h:183
const Grid::mapped_type & grid_at(const CellIndex &x) const
Returns the grid cell at given index.
Definition: HashGrid.h:402

OpenMS / TOPP release 2.0.0 Documentation generated on Wed Mar 30 2016 16:18:39 using doxygen 1.8.5