67 virtual const std::string&
getID()
const = 0;
193 Connection(
int fromLane_,
NBEdge* toEdge_,
int toLane_,
bool mayDefinitelyPass_,
194 bool keepClear_ =
true,
195 double contPos_ = UNSPECIFIED_CONTPOS,
196 double visibility_ = UNSPECIFIED_VISIBILITY_DISTANCE,
197 double speed_ = UNSPECIFIED_SPEED,
198 bool haveVia_ =
false,
199 bool uncontrolled_ =
false,
266 std::string getInternalLaneID()
const;
269 std::string getDescription(
const NBEdge* parent)
const;
287 throw ProcessError(
"NBEdge::Connection does not implement getNumericalID()");
294 return myViaSuccessors;
358 NBEdge(
const std::string&
id,
360 double speed,
int nolanes,
int priority,
361 double width,
double endOffset,
362 const std::string& streetName =
"",
387 NBEdge(
const std::string&
id,
389 double speed,
int nolanes,
int priority,
390 double width,
double endOffset,
392 const std::string& streetName =
"",
393 const std::string& origID =
"",
395 bool tryIgnoreNodePositions =
false);
408 NBEdge(
const std::string&
id,
434 void reinit(
NBNode* from,
NBNode* to,
const std::string& type,
435 double speed,
int nolanes,
int priority,
437 const std::string& streetName,
439 bool tryIgnoreNodePositions =
false);
453 void reshiftPosition(
double xoff,
double yoff);
466 return (
int)myLanes.size();
512 double getShapeStartAngle()
const;
520 double getShapeEndAngle()
const;
543 return myLoadedLength > 0 ? myLoadedLength : myLength;
547 double getFinalLength()
const;
553 return myLoadedLength > 0;
582 double getLaneWidth(
int lane)
const;
585 double getTotalWidth()
const;
612 return myStopOffsets;
618 double getEndOffset(
int lane)
const;
623 const std::map<int, double>& getStopOffsets(
int lane)
const;
627 return mySignalOffset;
637 mySignalOffset = offset;
638 mySignalNode = signalNode;
644 const std::vector<NBEdge::Lane>&
getLanes()
const {
653 int getFirstNonPedestrianLaneIndex(
int direction,
bool exclusive =
false)
const;
661 int getFirstAllowedLaneIndex(
int direction)
const;
664 NBEdge::Lane getFirstNonPedestrianLane(
int direction)
const;
667 std::set<SVCPermissions> getPermissionVariants(
int iStart,
int iEnd)
const;
670 double getCrossingAngle(
NBNode* node);
673 std::string getSidewalkID();
688 bool hasDefaultGeometry()
const;
695 bool hasDefaultGeometryEndpoints()
const;
702 bool hasDefaultGeometryEndpointAtNode(
const NBNode* node)
const;
725 void addGeometryPoint(
int index,
const Position& p);
728 void extendGeometryAtNode(
const NBNode* node,
double maxExtent);
731 void shortenGeometryAtNode(
const NBNode* node,
double reduction);
734 void shiftPositionAtNode(
NBNode* node,
NBEdge* opposite);
745 void computeEdgeShape(
double smoothElevationThreshold = -1);
763 return myLaneSpreadFunction;
776 void reduceGeometry(
const double minDist);
783 void checkGeometry(
const double maxAngle,
const double minRadius,
bool fix);
802 bool addEdge2EdgeConnection(
NBEdge* dest);
824 bool addLane2LaneConnection(
int fromLane,
NBEdge* dest,
826 bool mayUseSameDestination =
false,
827 bool mayDefinitelyPass =
false,
828 bool keepClear =
true,
829 double contPos = UNSPECIFIED_CONTPOS,
830 double visibility = UNSPECIFIED_VISIBILITY_DISTANCE,
831 double speed = UNSPECIFIED_SPEED,
833 const bool uncontrolled = UNSPECIFIED_CONNECTION_UNCONTROLLED);
852 bool addLane2LaneConnections(
int fromLane,
853 NBEdge* dest,
int toLane,
int no,
855 bool mayDefinitelyPass =
false);
867 bool setConnection(
int lane,
NBEdge* destEdge,
870 bool mayUseSameDestination =
false,
871 bool mayDefinitelyPass =
false,
872 bool keepClear =
true,
873 double contPos = UNSPECIFIED_CONTPOS,
874 double visibility = UNSPECIFIED_VISIBILITY_DISTANCE,
875 double speed = UNSPECIFIED_SPEED,
877 const bool uncontrolled = UNSPECIFIED_CONNECTION_UNCONTROLLED);
889 std::vector<Connection> getConnectionsFromLane(
int lane,
NBEdge* to =
nullptr,
int toLane = -1)
const;
911 bool hasConnectionTo(
NBEdge* destEdge,
int destLane,
int fromLane = -1)
const;
919 bool isConnectedTo(
const NBEdge* e)
const;
925 return myConnections;
932 return myConnections;
953 std::vector<int> getConnectionLanes(
NBEdge* currentOutgoing,
bool withBikes =
true)
const;
956 void sortOutgoingConnectionsByAngle();
959 void sortOutgoingConnectionsByIndex();
966 void remapConnections(
const EdgeVector& incoming);
975 void removeFromConnections(
NBEdge* toEdge,
int fromLane = -1,
int toLane = -1,
bool tryLater =
false,
const bool adaptToLaneRemoval =
false,
const bool keepPossibleTurns =
false);
981 void invalidateConnections(
bool reallowSetting =
false);
984 void replaceInConnections(
NBEdge* which,
NBEdge* by,
int laneOff);
987 void replaceInConnections(
NBEdge* which,
const std::vector<NBEdge::Connection>& origConns);
990 void copyConnectionsFrom(
NBEdge* src);
993 void shiftToLanesToEdge(
NBEdge* to,
int laneOff);
1001 bool isTurningDirectionAt(
const NBEdge*
const edge)
const;
1007 void setTurningDestination(
NBEdge* e,
bool onlyPossible =
false);
1013 myAmMacroscopicConnector =
true;
1020 return myAmMacroscopicConnector;
1041 void setJunctionPriority(
const NBNode*
const node,
int prio);
1052 int getJunctionPriority(
const NBNode*
const node)
const;
1055 void setLoadedLength(
double val);
1058 void dismissVehicleClassInformation();
1066 bool needsLaneSpecificOutput()
const;
1069 bool hasPermissions()
const;
1072 bool hasLaneSpecificPermissions()
const;
1075 bool hasLaneSpecificSpeed()
const;
1078 bool hasLaneSpecificWidth()
const;
1081 bool hasLaneSpecificType()
const;
1084 bool hasLaneSpecificEndOffset()
const;
1087 bool hasLaneSpecificStopOffsets()
const;
1090 bool hasAccelLane()
const;
1093 bool hasCustomLaneShape()
const;
1096 bool hasLaneParams()
const;
1099 bool computeEdge2Edges(
bool noLeftMovers);
1102 bool computeLanes2Edges();
1105 bool recheckLanes();
1115 void appendTurnaround(
bool noTLSControlled,
bool onlyDeadends,
bool noGeometryLike,
bool checkPermissions);
1120 NBNode* tryGetNodeAtPosition(
double pos,
double tolerance = 5.0)
const;
1123 double getMaxLaneOffset();
1126 bool lanesWereAssigned()
const;
1129 bool mayBeTLSControlled(
int fromLane,
NBEdge* toEdge,
int toLane)
const;
1132 bool setControllingTLInformation(
const NBConnection& c,
const std::string& tlID);
1135 void clearControllingTLInformation();
1147 bool expandableBy(
NBEdge* possContinuation, std::string& reason)
const;
1150 void append(
NBEdge* continuation);
1153 bool hasSignalisedConnectionTo(
const NBEdge*
const e)
const;
1156 void moveOutgoingConnectionsFrom(
NBEdge* e,
int laneOff);
1162 NBEdge* getTurnDestination(
bool possibleDestination =
false)
const;
1165 std::string getLaneID(
int lane)
const;
1168 double getLaneSpeed(
int lane)
const;
1171 bool isNearEnough2BeJoined2(
NBEdge* e,
double threshold)
const;
1180 double getAngleAtNode(
const NBNode*
const node)
const;
1190 double getAngleAtNodeToCenter(
const NBNode*
const node)
const;
1193 void incLaneNo(
int by);
1196 void decLaneNo(
int by);
1199 void deleteLane(
int index,
bool recompute,
bool shiftIndices);
1202 void addLane(
int index,
bool recomputeShape,
bool recomputeConnections,
bool shiftIndices);
1205 void markAsInLane2LaneState();
1208 void addSidewalk(
double width);
1211 void restoreSidewalk(std::vector<NBEdge::Lane> oldLanes,
PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);
1214 void addBikeLane(
double width);
1217 void restoreBikelane(std::vector<NBEdge::Lane> oldLanes,
PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);
1223 void setPreferredVehicleClass(
SVCPermissions permissions,
int lane = -1);
1235 void setLaneWidth(
int lane,
double width);
1238 void setLaneType(
int lane,
const std::string& type);
1241 void setEndOffset(
int lane,
double offset);
1244 void setSpeed(
int lane,
double speed);
1248 bool setStopOffsets(
int lane, std::map<int, double> offsets,
bool overwrite =
false);
1251 void setAcceleration(
int lane,
bool accelRamp);
1260 void setOrigID(
const std::string origID);
1264 myDistance = distance;
1268 void disableConnection4TLS(
int fromLane,
NBEdge* toEdge,
int toLane);
1273 assert(lane < (
int)myLanes.size());
1274 return myLanes[lane];
1280 assert(lane < (
int)myLanes.size());
1281 return myLanes[lane];
1295 void buildInnerEdges(
const NBNode& n,
int noInternalNoSplits,
int& linkIndex,
int& splitIndex);
1304 mySigns.push_back(sign);
1313 void resetNodeBorder(
const NBNode* node);
1316 bool isBidiRail(
bool ignoreSpread =
false)
const;
1319 bool isRailDeadEnd()
const;
1322 void debugPrintConnections(
bool outgoing =
true,
bool incoming =
false)
const;
1339 static int getLaneIndexFromLaneID(
const std::string laneID);
1386 : myTransitions(transitions) { }
1392 void execute(
const int lane,
const int virtEdge);
1396 return myConnections;
1418 enum Direction { DIR_RIGHTMOST, DIR_LEFTMOST, DIR_FORWARD };
1429 return myStraightest;
1456 void computeLaneShapes();
1475 void init(
int noLanes,
bool tryIgnoreNodePositions,
const std::string& origID);
1478 void divideOnEdges(
const EdgeVector* outgoing);
1481 void divideSelectedLanesOnEdges(
const EdgeVector* outgoing,
const std::vector<int>& availableLanes);
1484 void addStraightConnections(
const EdgeVector* outgoing,
const std::vector<int>& availableLanes,
const std::vector<int>& priorities);
1487 const std::vector<int> prepareEdgePriorities(
const EdgeVector* outgoing,
const std::vector<int>& availableLanes);
1494 void moveConnectionToLeft(
int lane);
1499 void moveConnectionToRight(
int lane);
1502 bool canMoveConnection(
const Connection& con,
int newFromLane)
const;
1506 void computeAngle();
1518 void restoreRestrictedLane(
SUMOVehicleClass vclass, std::vector<NBEdge::Lane> oldLanes,
PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);
1521 void assignInternalLaneLength(std::vector<Connection>::iterator i,
int numLanes,
double lengthSum);
1639 myHasFromLane(hasFromLane),
1640 myEdge2Find(edge2find) { }
1644 return c.
toEdge == myEdge2Find && (!myHasFromLane || c.
fromLane != -1);
1664 myEdge2Find(edge2find),
1665 myLane2Find(lane2find),
1666 myFromLane2Find(fromLane2find) { }
1670 return c.
toEdge == myEdge2Find && c.
toLane == myLane2Find && (myFromLane2Find < 0 || c.
fromLane == myFromLane2Find);
1694 myFromLane(fromLane), myEdge2Find(edge2find), myLane2Find(lane2find), myInvertEdge2find(invertEdge2find) { }
1698 return ((c.
fromLane == myFromLane || myFromLane == -1)
1699 && ((!myInvertEdge2find && c.
toEdge == myEdge2Find) || (myInvertEdge2find && c.
toEdge != myEdge2Find))
1700 && (c.
toLane == myLane2Find || myLane2Find == -1));
1727 myFromLane(fromLane), myEdge2Find(edge2find), myCheckRight(checkRight) { }
1731 return (((myCheckRight && c.
fromLane < myFromLane) || (!myCheckRight && c.
fromLane > myFromLane))
1733 && c.
toEdge == myEdge2Find);
ToEdgeConnectionsAdder(const EdgeVector &transitions)
constructor
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
static const PositionVector EMPTY
empty Vector
std::string id
id of Connection
static const bool UNSPECIFIED_CONNECTION_UNCONTROLLED
TLS-controlled despite its node controlled not specified.
std::vector< Lane > myLanes
Lane information.
double vmax
maximum velocity
double getLength() const
Returns the computed length of the edge.
A structure which describes a connection between edges or lanes.
int toLane
The lane the connections yields in.
void setInsideTLS()
Marks this edge being within an intersection.
Superclass for NBEdge and NBEdge::Connection to initialize Router.
std::vector< std::pair< const NBRouterEdge *, const NBRouterEdge * > > ConstRouterEdgePairVector
A class representing a single street sign.
connections_conflict_finder(int fromLane, NBEdge *const edge2find, bool checkRight)
constructor
PositionVector shape
The lane's shape.
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
const std::map< int, double > & getStopOffsets() const
Returns the stopOffset to the end of the edge.
connections_relative_edgelane_sorter(NBEdge *e)
constructor
const std::string & getID() const
LaneSpreadFunction myLaneSpreadFunction
The information about how to spread the lanes.
std::string viaID
if Connection have a via, ID of it
void addSign(NBSign sign)
add Sign
NBEdge * toEdge
The edge the connections yields in.
std::string type
the type of this lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
static ConstRouterEdgePairVector myViaSuccessors
static NBEdge DummyEdge
Dummy edge to use when a reference must be supplied in the no-arguments constructor (FOX technicality...
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
The relationships between edges are computed/loaded.
bool isInsideTLS() const
Returns whether this edge was marked as being within an intersection.
bool operator()(const Connection &c) const
operator ()
double myLaneWidth
This width of this edge's lanes.
std::map< int, double > myStopOffsets
A vClass specific stop offset - assumed of length 0 (unspecified) or 1. For the latter case the int i...
std::vector< NBSign > mySigns
the street signs along this edge
double myEndOffset
This edges's offset to the intersection begin (will be applied to all lanes)
Holds (- relative to the edge it is build from -!!!) the list of main directions a vehicle that drive...
double getSignalOffset() const
Returns the offset of a traffic signal from the end of this edge.
static const double ANGLE_LOOKAHEAD
the distance at which to take the default angle
int myLane2Find
lane to find
~ToEdgeConnectionsAdder()
destructor
virtual const std::string & getID() const =0
int getPriority() const
Returns the priority of the edge.
const std::string & getTypeID() const
get ID of type
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
const std::vector< NBSign > & getSigns() const
get Signs
int myFromLane2Find
from lane to find
std::map< NBEdge *, std::vector< int > > myConnections
map of edges to this edge's lanes that reach them
The representation of a single edge during network building.
Lane2LaneInfoType
Modes of setting connections between lanes.
static const double UNSPECIFIED_SIGNAL_OFFSET
unspecified signal offset
void setStreetName(const std::string &name)
sets the street name of this edge
ConstRouterEdgePairVector myViaSuccessors
std::vector< Direction > myDirs
list of the main direction within the following junction relative to the edge
static const double UNSPECIFIED_OFFSET
unspecified lane offset
Lanes to lanes - relationships are computed; should be recheked.
double length
computed length (average of all internal lane shape lengths that share an internal edge) ...
bool hasLoadedLength() const
Returns whether a length was set explicitly.
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
int myFromJunctionPriority
The priority normalised for the node the edge is outgoing of.
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
double endOffset
This lane's offset to the intersection begin.
PositionVector myGeom
The geometry for the edge.
double visibility
custom foe visiblity for connection
bool operator()(const Connection &c) const
operator ()
const NBEdge *const myEdge2Find
edge to find
bool connectionsDone
Whether connection information for this lane is already completed.
const std::string & getID() const
Returns the id.
Lane & getLaneStruct(int lane)
PositionVector myFromBorder
intersection borders (because the node shape might be invalid)
NBNode * getSignalNode() const
Returns the node that (possibly) represents a traffic signal controlling at the end of this edge...
#define UNUSED_PARAMETER(x)
static const double UNSPECIFIED_WIDTH
unspecified lane width
double myDistance
The mileage/kilometrage at the start of this edge in a linear coordination system.
const EdgeVector & myTransitions
the transition from the virtual lane to the edge it belongs to
PositionVector customShape
custom shape for connection
double getDistance() const
bool accelRamp
Whether this lane is an acceleration lane.
The edge has been loaded, nothing is computed yet.
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)...
bool myInvertEdge2find
invert edge to find
int myToJunctionPriority
The priority normalised for the node the edge is incoming in.
static const double UNSPECIFIED_SPEED
unspecified lane speed
PositionVector shape
shape of Connection
bool keepClear
whether the junction must be kept clear when using this connection
int myStraightest
the index of the straightmost among the given outgoing edges
An (internal) definition of a single lane of an edge.
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
bool myAmMacroscopicConnector
Information whether this edge is a (macroscopic) connector.
NBEdge * myTurnDestination
The turn destination edge (if a connection exists)
bool operator()(const Connection &c) const
operator ()
double myStartAngle
The angles of the edge.
connections_finder(int fromLane, NBEdge *const edge2find, int lane2find, bool invertEdge2find=false)
constructor
static double getTravelTimeStatic(const NBRouterEdge *const edge, const NBVehicle *const, double)
double speed
custom speed for connection
bool myAmInTLS
Information whether this is lies within a joined tls.
std::string tlID
The id of the traffic light that controls this connection.
SVCPermissions preferred
List of vehicle types that are preferred on this lane.
const ConstRouterEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
int getNumLanes() const
Returns the number of lanes.
int fromLane
The lane the connections starts at.
A point in 2D or 3D with translation and scaling methods.
int getNumericalID() const
Returns the index (numeric id) of the edge.
virtual double getLength() const =0
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
connections_toedge_finder(const NBEdge *const edge2find, bool hasFromLane=false)
constructor
std::vector< Connection > & getConnections()
Returns the connections.
const Lane & getLaneStruct(int lane) const
EdgeBuildingStep
Current state of the edge within the building process.
NBEdge * myPossibleTurnDestination
The edge that would be the turn destination if there was one.
void setAsMacroscopicConnector()
const std::string & getID() const
int myPriority
The priority of the edge.
Storage for edges, including some functionality operating on multiple edges.
EdgeBuildingStep myStep
The building step.
EdgeBuildingStep getStep() const
The building step of this edge.
const bool myHasFromLane
check if has from lane
const std::string & getStreetName() const
Returns the street name of this edge.
Class to sort edges by their angle.
A vehicle as used by router.
double getEndOffset() const
Returns the offset to the destination node.
std::vector< Connection > myConnections
List of connections to following edges.
connections_fromlane_finder(int lane2find)
The connection was given by the user.
An upper class for objects with additional parameters.
double speed
The speed allowed on this lane.
double width
This lane's width.
int myIndex
the index of the edge in the list of all edges. Set by NBEdgeCont and requires re-set whenever the li...
int tlLinkIndex
The index of this connection within the controlling traffic light.
Base class for objects which have an id.
int myLane2Find
index of lane to find
double mySpeed
The maximal speed.
double getSpeed() const
Returns the speed allowed on this edge.
int internalLaneIndex
The lane index of this internal lane within the internal edge.
const PositionVector & getGeometry() const
Returns the geometry of the edge.
int myLane2Find
lane to find
A road/street connecting two junctions (netedit-version)
bool myCheckRight
check if is right
JunctionPriority
junction priority values set by setJunctionPriority
virtual bool isInternal() const
double getLaneWidth() const
Returns the default width of lanes of this edge.
double getTotalAngle() const
Returns the angle at the start of the edge.
int myFromLane
index of from lane
virtual double getSpeed() const =0
double length() const
Returns the length.
PositionVector viaShape
shape of via
std::string oppositeID
An opposite lane ID, if given.
const std::vector< Connection > & getConnections() const
Returns the connections.
PositionVector myToBorder
std::map< int, double > stopOffsets
stopOffsets.second - The stop offset for vehicles stopping at the lane's end. Applies if vClass is in...
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
static const int UNSPECIFIED_INTERNAL_LANE_INDEX
internal lane computation not yet done
NBEdge * myEdge
the edge to compute the relative angle of
double mySignalOffset
the offset of a traffic light signal from the end of this edge (-1 for None)
The edge has been loaded and connections shall not be added.
bool operator()(const Connection &c) const
operator ()
std::vector< Connection > myConnectionsToDelete
List of connections marked for delayed removal.
double contPos
custom position for internal junction on this connection
std::vector< std::string > foeIncomingLanes
FOE Incomings lanes.
bool uncontrolled
check if Connection is uncontrolled
connections_toedgelane_finder(NBEdge *const edge2find, int lane2find, int fromLane2find)
constructor
static double getTravelTimeStatic(const NBEdge *const edge, const NBVehicle *const, double)
NBEdge *const myEdge2Find
edge to find
NBEdge *const myEdge2Find
edge to find
std::string myType
The type of the edge.
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
double getStartAngle() const
Returns the angle at the start of the edge (relative to the node shape center) The angle is computed ...
void declareConnectionsAsLoaded(EdgeBuildingStep step=LANES2LANES_USER)
declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has ...
The connection was computed.
bool operator()(const Connection &c) const
operator ()
Represents a single node (junction) during network building.
Lanes to lanes - relationships are computed; no recheck is necessary/wished.
virtual int getNumericalID() const =0
Static storage of an output device and its base (abstract) implementation.
Direction
enum of possible directions
int getNumericalID() const
bool isMacroscopicConnector() const
Returns whether this edge was marked as a macroscopic connector.
NBNode * getFromNode() const
Returns the origin node of the edge.
int getStraightest() const
returns the index of the straightmost among the given outgoing edges
Container for nodes during the netbuilding process.
void setDistance(double distance)
set lane specific speed (negative lane implies set for all lanes)
int myFromLane
index of from lane
bool haveVia
check if Connection have a Via
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
double myLength
The length of the edge.
double myLoadedLength
An optional length to use (-1 if not valid)
Lanes to edges - relationships are computed/loaded.
std::string myStreetName
The street name (or whatever arbitrary string you wish to attach)
PositionVector customShape
A custom shape for this lane set by the user.
NBNode * getToNode() const
Returns the destination node of the edge.
std::vector< int > foeInternalLinks
FOE Internal links.
void setNumericalID(int index)
sets the index of the edge in the list of all network edges
NBEdge *const myEdge2Find
edge to find
vehicles ignoring classes
virtual const ConstRouterEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const =0
void setSignalOffset(double offset, NBNode *signalNode)
sets the offset of a traffic signal from the end of this edge
A class that being a bresenham-callback assigns the incoming lanes to the edges.
double getEndAngle() const
Returns the angle at the end of the edge (relative to the node shape center) The angle is computed in...
const std::map< NBEdge *, std::vector< int > > & getBuiltConnections() const
get built connections