Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file NBConnection.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @date Sept 2002
19 : ///
20 : // The class holds a description of a connection between two edges
21 : /****************************************************************************/
22 : #include <config.h>
23 :
24 : #include <sstream>
25 : #include <iostream>
26 : #include <cassert>
27 : #include "NBEdgeCont.h"
28 : #include "NBEdge.h"
29 : #include "NBConnection.h"
30 :
31 :
32 : // ===========================================================================
33 : // static members
34 : // ===========================================================================
35 : const int NBConnection::InvalidTlIndex = -1;
36 : const NBConnection NBConnection::InvalidConnection("invalidFrom", nullptr, "invalidTo", nullptr);
37 :
38 : // ===========================================================================
39 : // method definitions
40 : // ===========================================================================
41 388 : NBConnection::NBConnection(NBEdge* from, NBEdge* to) :
42 388 : myFrom(from), myTo(to),
43 388 : myFromID(from->getID()), myToID(to->getID()),
44 388 : myFromLane(-1), myToLane(-1),
45 388 : myTlIndex(InvalidTlIndex),
46 388 : myTlIndex2(InvalidTlIndex) {
47 388 : }
48 :
49 :
50 2297 : NBConnection::NBConnection(const std::string& fromID, NBEdge* from,
51 2297 : const std::string& toID, NBEdge* to) :
52 2297 : myFrom(from), myTo(to),
53 2297 : myFromID(fromID), myToID(toID),
54 2297 : myFromLane(-1), myToLane(-1),
55 2297 : myTlIndex(InvalidTlIndex),
56 2297 : myTlIndex2(InvalidTlIndex) {
57 2297 : }
58 :
59 :
60 31829 : NBConnection::NBConnection(NBEdge* from, int fromLane,
61 31829 : NBEdge* to, int toLane, int tlIndex, int tlIndex2) :
62 31829 : myFrom(from), myTo(to),
63 31829 : myFromLane(fromLane), myToLane(toLane),
64 31829 : myTlIndex(tlIndex),
65 31829 : myTlIndex2(tlIndex2) {
66 : /* @todo what should we assert here?
67 : assert(myFromLane<0||from->getNumLanes()>(int) myFromLane);
68 : assert(myToLane<0||to->getNumLanes()>(int) myToLane);
69 : */
70 63658 : myFromID = from != nullptr ? from->getID() : "";
71 63658 : myToID = to != nullptr ? to->getID() : "";
72 31829 : }
73 :
74 :
75 131236 : NBConnection::~NBConnection() {}
76 :
77 :
78 96722 : NBConnection::NBConnection(const NBConnection& c) :
79 96722 : myFrom(c.myFrom), myTo(c.myTo),
80 96722 : myFromID(c.myFromID), myToID(c.myToID),
81 96722 : myFromLane(c.myFromLane), myToLane(c.myToLane),
82 96722 : myTlIndex(c.myTlIndex),
83 96722 : myTlIndex2(c.myTlIndex2) {
84 96722 : }
85 :
86 :
87 : NBEdge*
88 730350 : NBConnection::getFrom() const {
89 730350 : return myFrom;
90 : }
91 :
92 :
93 : NBEdge*
94 619095 : NBConnection::getTo() const {
95 619095 : return myTo;
96 : }
97 :
98 :
99 : bool
100 0 : NBConnection::replaceFrom(NBEdge* which, NBEdge* by) {
101 0 : if (myFrom == which) {
102 0 : myFrom = by;
103 0 : if (myFrom != nullptr) {
104 0 : myFromID = myFrom->getID();
105 : } else {
106 0 : myFromID = "invalidFrom";
107 : }
108 0 : return true;
109 : }
110 : return false;
111 : }
112 :
113 :
114 : bool
115 1023 : NBConnection::replaceFrom(NBEdge* which, int whichLane,
116 : NBEdge* by, int byLane) {
117 1023 : if (myFrom == which && (myFromLane == whichLane || myFromLane < 0 || whichLane < 0)) {
118 252 : myFrom = by;
119 252 : if (myFrom != nullptr) {
120 189 : myFromID = myFrom->getID();
121 : } else {
122 63 : myFromID = "invalidFrom";
123 : }
124 252 : if (byLane >= 0) {
125 93 : myFromLane = byLane;
126 : }
127 252 : return true;
128 : }
129 : return false;
130 : }
131 :
132 :
133 : bool
134 0 : NBConnection::replaceTo(NBEdge* which, NBEdge* by) {
135 0 : if (myTo == which) {
136 0 : myTo = by;
137 0 : if (myTo != nullptr) {
138 0 : myToID = myTo->getID();
139 : } else {
140 0 : myToID = "invalidTo";
141 : }
142 0 : return true;
143 : }
144 : return false;
145 : }
146 :
147 :
148 : bool
149 734 : NBConnection::replaceTo(NBEdge* which, int whichLane,
150 : NBEdge* by, int byLane) {
151 734 : if (myTo == which && (myToLane == whichLane || myFromLane < 0 || whichLane < 0)) {
152 108 : myTo = by;
153 108 : if (myTo != nullptr) {
154 42 : myToID = myTo->getID();
155 : } else {
156 66 : myToID = "invalidTo";
157 : }
158 108 : if (byLane >= 0) {
159 14 : myToLane = byLane;
160 : }
161 108 : return true;
162 : }
163 : return false;
164 : }
165 :
166 :
167 : bool
168 1640 : operator<(const NBConnection& c1, const NBConnection& c2) {
169 1640 : if (c1.myFromID != c2.myFromID) {
170 732 : return c1.myFromID < c2.myFromID;
171 : }
172 908 : if (c1.myToID != c2.myToID) {
173 316 : return c1.myToID < c2.myToID;
174 : }
175 592 : if (c1.myFromLane != c2.myFromLane) {
176 0 : return c1.myFromLane < c2.myFromLane;
177 : }
178 592 : return c1.myToLane < c2.myToLane;
179 : }
180 :
181 :
182 : bool
183 137 : NBConnection::operator==(const NBConnection& c) const {
184 19 : return (myFrom == c.myFrom && myTo == c.myTo &&
185 1 : myFromID == c.myFromID && myToID == c.myToID &&
186 1 : myFromLane == c.myFromLane && myToLane == c.myToLane &&
187 137 : myTlIndex == c.myTlIndex &&
188 137 : myTlIndex2 == c.myTlIndex2);
189 : }
190 :
191 :
192 : bool
193 24601 : NBConnection::check(const NBEdgeCont& ec) {
194 24601 : myFrom = checkFrom(ec);
195 24601 : myTo = checkTo(ec);
196 24601 : return myFrom != nullptr && myTo != nullptr;
197 : }
198 :
199 :
200 : NBEdge*
201 24601 : NBConnection::checkFrom(const NBEdgeCont& ec) {
202 24601 : NBEdge* e = ec.retrieve(myFromID);
203 : // ok, the edge was not changed
204 24601 : if (e == myFrom) {
205 : return myFrom;
206 : }
207 : // try to get the edge
208 94 : return ec.retrievePossiblySplit(myFromID, myToID, true);
209 : }
210 :
211 :
212 : NBEdge*
213 24601 : NBConnection::checkTo(const NBEdgeCont& ec) {
214 24601 : NBEdge* e = ec.retrieve(myToID);
215 : // ok, the edge was not changed
216 24601 : if (e == myTo) {
217 : return myTo;
218 : }
219 : // try to get the edge
220 54 : return ec.retrievePossiblySplit(myToID, myFromID, false);
221 : }
222 :
223 :
224 : std::string
225 0 : NBConnection::getID() const {
226 0 : std::stringstream str;
227 0 : str << myFromID << "_" << myFromLane << "->" << myToID << "_" << myToLane;
228 0 : return str.str();
229 0 : }
230 :
231 :
232 : int
233 227005 : NBConnection::getFromLane() const {
234 227005 : return myFromLane;
235 : }
236 :
237 :
238 : int
239 35401 : NBConnection::getToLane() const {
240 35401 : return myToLane;
241 : }
242 :
243 :
244 : void
245 220 : NBConnection::shiftLaneIndex(NBEdge* edge, int offset, int threshold) {
246 220 : if (myFrom == edge && myFromLane > threshold) {
247 31 : myFromLane += offset;
248 189 : } else if (myTo == edge && myToLane > threshold) {
249 26 : myToLane += offset;
250 : }
251 220 : }
252 :
253 :
254 : std::ostream&
255 0 : operator<<(std::ostream& os, const NBConnection& c) {
256 : os
257 0 : << "Con(from=" << Named::getIDSecure(c.getFrom())
258 : << " fromLane=" << c.getFromLane()
259 0 : << " to=" << Named::getIDSecure(c.getTo())
260 0 : << " toLane=" << c.getToLane()
261 0 : << " tlIndex=" << c.getTLIndex()
262 0 : << ")";
263 0 : return os;
264 : }
265 :
266 :
267 : /****************************************************************************/
|
