gravatar
retvari@tmit.bme.hu
retvari@tmit.bme.hu
Fix PredMapPath::empty() (#366)
0 1 0
default
1 file changed with 1 insertions and 1 deletions:
↑ Collapse diff ↑
Ignore white space 384 line context
1 1
/* -*- mode: C++; indent-tabs-mode: nil; -*-
2 2
 *
3 3
 * This file is a part of LEMON, a generic C++ optimization library.
4 4
 *
5 5
 * Copyright (C) 2003-2008
6 6
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 7
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
8 8
 *
9 9
 * Permission to use, modify and distribute this software is granted
10 10
 * provided that this copyright notice appears in all copies. For
11 11
 * precise terms see the accompanying LICENSE file.
12 12
 *
13 13
 * This software is provided "AS IS" with no warranty of any kind,
14 14
 * express or implied, and with no claim as to its suitability for any
15 15
 * purpose.
16 16
 *
17 17
 */
18 18

	
19 19
#ifndef LEMON_BITS_PRED_MAP_PATH_H
20 20
#define LEMON_BITS_PRED_MAP_PATH_H
21 21

	
22 22
namespace lemon {
23 23

	
24 24
  template <typename _Digraph, typename _PredMap>
25 25
  class PredMapPath {
26 26
  public:
27 27
    typedef True RevPathTag;
28 28

	
29 29
    typedef _Digraph Digraph;
30 30
    typedef typename Digraph::Arc Arc;
31 31
    typedef _PredMap PredMap;
32 32

	
33 33
    PredMapPath(const Digraph& _digraph, const PredMap& _predMap,
34 34
                typename Digraph::Node _target)
35 35
      : digraph(_digraph), predMap(_predMap), target(_target) {}
36 36

	
37 37
    int length() const {
38 38
      int len = 0;
39 39
      typename Digraph::Node node = target;
40 40
      typename Digraph::Arc arc;
41 41
      while ((arc = predMap[node]) != INVALID) {
42 42
        node = digraph.source(arc);
43 43
        ++len;
44 44
      }
45 45
      return len;
46 46
    }
47 47

	
48 48
    bool empty() const {
49
      return predMap[target] != INVALID;
49
      return predMap[target] == INVALID;
50 50
    }
51 51

	
52 52
    class RevArcIt {
53 53
    public:
54 54
      RevArcIt() {}
55 55
      RevArcIt(Invalid) : path(0), current(INVALID) {}
56 56
      RevArcIt(const PredMapPath& _path)
57 57
        : path(&_path), current(_path.target) {
58 58
        if (path->predMap[current] == INVALID) current = INVALID;
59 59
      }
60 60

	
61 61
      operator const typename Digraph::Arc() const {
62 62
        return path->predMap[current];
63 63
      }
64 64

	
65 65
      RevArcIt& operator++() {
66 66
        current = path->digraph.source(path->predMap[current]);
67 67
        if (path->predMap[current] == INVALID) current = INVALID;
68 68
        return *this;
69 69
      }
70 70

	
71 71
      bool operator==(const RevArcIt& e) const {
72 72
        return current == e.current;
73 73
      }
74 74

	
75 75
      bool operator!=(const RevArcIt& e) const {
76 76
        return current != e.current;
77 77
      }
78 78

	
79 79
      bool operator<(const RevArcIt& e) const {
80 80
        return current < e.current;
81 81
      }
82 82

	
83 83
    private:
84 84
      const PredMapPath* path;
85 85
      typename Digraph::Node current;
86 86
    };
87 87

	
88 88
  private:
89 89
    const Digraph& digraph;
90 90
    const PredMap& predMap;
91 91
    typename Digraph::Node target;
92 92
  };
93 93

	
94 94

	
95 95
  template <typename _Digraph, typename _PredMatrixMap>
96 96
  class PredMatrixMapPath {
97 97
  public:
98 98
    typedef True RevPathTag;
99 99

	
100 100
    typedef _Digraph Digraph;
101 101
    typedef typename Digraph::Arc Arc;
102 102
    typedef _PredMatrixMap PredMatrixMap;
103 103

	
104 104
    PredMatrixMapPath(const Digraph& _digraph,
105 105
                      const PredMatrixMap& _predMatrixMap,
106 106
                      typename Digraph::Node _source,
107 107
                      typename Digraph::Node _target)
108 108
      : digraph(_digraph), predMatrixMap(_predMatrixMap),
109 109
        source(_source), target(_target) {}
110 110

	
111 111
    int length() const {
112 112
      int len = 0;
113 113
      typename Digraph::Node node = target;
114 114
      typename Digraph::Arc arc;
115 115
      while ((arc = predMatrixMap(source, node)) != INVALID) {
116 116
        node = digraph.source(arc);
117 117
        ++len;
118 118
      }
119 119
      return len;
120 120
    }
121 121

	
122 122
    bool empty() const {
123 123
      return source != target;
124 124
    }
125 125

	
126 126
    class RevArcIt {
127 127
    public:
128 128
      RevArcIt() {}
129 129
      RevArcIt(Invalid) : path(0), current(INVALID) {}
130 130
      RevArcIt(const PredMatrixMapPath& _path)
131 131
        : path(&_path), current(_path.target) {
132 132
        if (path->predMatrixMap(path->source, current) == INVALID)
133 133
          current = INVALID;
134 134
      }
135 135

	
136 136
      operator const typename Digraph::Arc() const {
137 137
        return path->predMatrixMap(path->source, current);
138 138
      }
139 139

	
140 140
      RevArcIt& operator++() {
141 141
        current =
142 142
          path->digraph.source(path->predMatrixMap(path->source, current));
143 143
        if (path->predMatrixMap(path->source, current) == INVALID)
144 144
          current = INVALID;
145 145
        return *this;
146 146
      }
147 147

	
148 148
      bool operator==(const RevArcIt& e) const {
149 149
        return current == e.current;
150 150
      }
151 151

	
152 152
      bool operator!=(const RevArcIt& e) const {
153 153
        return current != e.current;
154 154
      }
155 155

	
156 156
      bool operator<(const RevArcIt& e) const {
157 157
        return current < e.current;
158 158
      }
159 159

	
160 160
    private:
161 161
      const PredMatrixMapPath* path;
162 162
      typename Digraph::Node current;
163 163
    };
164 164

	
165 165
  private:
166 166
    const Digraph& digraph;
167 167
    const PredMatrixMap& predMatrixMap;
168 168
    typename Digraph::Node source;
169 169
    typename Digraph::Node target;
170 170
  };
171 171

	
172 172
}
173 173

	
174 174
#endif
0 comments (0 inline)