1 | /// @file
|
---|
2 | ///
|
---|
3 | /// @brief A binary predicate to compare two numbers referred by indices
|
---|
4 | /// @details While sorting a vector, it is often necessary to track
|
---|
5 | /// permutations. One way of doing this is to write a std::pair-like class
|
---|
6 | /// with comparison operators using one element of the pair only and store
|
---|
7 | /// both value and its index. This is done in the PairOrderedFirst class
|
---|
8 | /// in AIPS++, which I wrote some time ago. However, there exists a more elegant
|
---|
9 | /// solution using a version of std::sort with a user-suppled binary predicate.
|
---|
10 | /// This file defines such binary predicate class comparing two values
|
---|
11 | /// stored in a container defined by its random access iterator of the origin
|
---|
12 | /// each time it is asked to compare two indicies. Each instance of the class
|
---|
13 | /// holds a copy of the rangom access iterator.
|
---|
14 | ///
|
---|
15 | /// @copyright (c) 2007 CSIRO
|
---|
16 | /// Australia Telescope National Facility (ATNF)
|
---|
17 | /// Commonwealth Scientific and Industrial Research Organisation (CSIRO)
|
---|
18 | /// PO Box 76, Epping NSW 1710, Australia
|
---|
19 | /// atnf-enquiries@csiro.au
|
---|
20 | ///
|
---|
21 | /// This file was originally written as a part of the ASKAP software
|
---|
22 | /// distribution and then adapted and reused in the ASAP project.
|
---|
23 | ///
|
---|
24 | /// The ASKAP software distribution is free software: you can redistribute it
|
---|
25 | /// and/or modify it under the terms of the GNU General Public License as
|
---|
26 | /// published by the Free Software Foundation; either version 2 of the License,
|
---|
27 | /// or (at your option) any later version.
|
---|
28 | ///
|
---|
29 | /// This program is distributed in the hope that it will be useful,
|
---|
30 | /// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
31 | /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
32 | /// GNU General Public License for more details.
|
---|
33 | ///
|
---|
34 | /// You should have received a copy of the GNU General Public License
|
---|
35 | /// along with this program; if not, write to the Free Software
|
---|
36 | /// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
---|
37 | ///
|
---|
38 | /// @author Max Voronkov <maxim.voronkov@csiro.au>
|
---|
39 |
|
---|
40 | #ifndef INDEXED_COMPARE_H
|
---|
41 | #define INDEXED_COMPARE_H
|
---|
42 |
|
---|
43 | #include <functional>
|
---|
44 |
|
---|
45 | namespace asap {
|
---|
46 |
|
---|
47 | /// @brief A binary predicate to compare two numbers referred by indices
|
---|
48 | /// @details While sorting a vector, it is often necessary to track
|
---|
49 | /// permutations. One way of doing this is to write a std::pair-like class
|
---|
50 | /// with comparison operators using one element of the pair only and store
|
---|
51 | /// both value and its index. This is done in the PairOrderedFirst class
|
---|
52 | /// in AIPS++, which I wrote some time ago. However, there exists a more elegant
|
---|
53 | /// solution using a version of std::sort with a user-suppled binary predicate.
|
---|
54 | /// This is such binary predicate class comparing two values
|
---|
55 | /// stored in a container defined by its random access iterator of the origin
|
---|
56 | /// each time it is asked to compare two indicies. Each instance of the class
|
---|
57 | /// holds a copy of the rangom access iterator.
|
---|
58 | template<typename IndexType, typename Iter,
|
---|
59 | typename Cmp = std::less<typename Iter::value_type> >
|
---|
60 | struct IndexedCompare : public std::binary_function<IndexType,IndexType,bool> {
|
---|
61 | /// @brief constructor with a default comparator initialization
|
---|
62 | /// @details
|
---|
63 | /// A comparator (which type is a template parameter) is set up with its
|
---|
64 | /// default constructor.
|
---|
65 | /// @param[in] iter random access iterator to work with
|
---|
66 | IndexedCompare(const Iter &iter) : itsIter(iter) {}
|
---|
67 |
|
---|
68 | /// @brief constructor with a user-specified comparator initialization
|
---|
69 | /// @details
|
---|
70 | /// A comparator (which type is a template parameter) is set up using a
|
---|
71 | /// a copy constructor
|
---|
72 | /// @param[in] iter random access iterator to work with
|
---|
73 | IndexedCompare(const Iter &iter, const Cmp &cmp) : itsIter(iter),
|
---|
74 | itsComparator(cmp) {}
|
---|
75 |
|
---|
76 |
|
---|
77 | /// @brief main operator of the predicate
|
---|
78 | /// @details Returns result of comparison of the value referred to by the
|
---|
79 | /// first and the second indices
|
---|
80 | /// @param[in] index1 index of the first value
|
---|
81 | /// @param[in] index2 index of the second value
|
---|
82 | /// @return result of comparison
|
---|
83 | bool operator()(const IndexType &index1, const IndexType &index2) const
|
---|
84 | {
|
---|
85 | return itsComparator(*(itsIter+index1), *(itsIter+index2));
|
---|
86 | }
|
---|
87 |
|
---|
88 |
|
---|
89 | private:
|
---|
90 | /// random access iterator to work with
|
---|
91 | Iter itsIter;
|
---|
92 | /// underlying binary predicate to do the comparison
|
---|
93 | Cmp itsComparator;
|
---|
94 | };
|
---|
95 |
|
---|
96 | /// @brief helper function to construct IndexedCompare object
|
---|
97 | /// @details It is handy to have a helper method to avoid
|
---|
98 | /// writing type names all the time. This function can extract the
|
---|
99 | /// template parameter from the argument type, i.e. automatically
|
---|
100 | /// @param[in] iter random access iterator to work with
|
---|
101 | /// @param[in] cmp an object which does the actual comparison
|
---|
102 | template<typename IndexType, typename Iter, typename Cmp>
|
---|
103 | IndexedCompare<IndexType,Iter,Cmp> indexedCompare(const Iter &iter, const Cmp &cmp =
|
---|
104 | std::less<typename Iter::value_type>())
|
---|
105 | {
|
---|
106 | return IndexedCompare<IndexType,Iter,Cmp>(iter,cmp);
|
---|
107 | }
|
---|
108 |
|
---|
109 | template<typename IndexType, typename Iter>
|
---|
110 | IndexedCompare<IndexType,Iter> indexedCompare(const Iter &iter)
|
---|
111 | {
|
---|
112 | return IndexedCompare<IndexType,Iter>(iter);
|
---|
113 | }
|
---|
114 |
|
---|
115 | } // namespace asap
|
---|
116 |
|
---|
117 | #endif // #define INDEXED_COMPARE_H
|
---|
118 |
|
---|