00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #include "olsr-state.h"
00030
00031
00032 namespace ns3 {
00033
00034
00035
00036
00037 MprSelectorTuple*
00038 OlsrState::FindMprSelectorTuple (Ipv4Address const &mainAddr)
00039 {
00040 for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();
00041 it != m_mprSelectorSet.end (); it++)
00042 {
00043 if (it->mainAddr == mainAddr)
00044 return &(*it);
00045 }
00046 return NULL;
00047 }
00048
00049 void
00050 OlsrState::EraseMprSelectorTuple (const MprSelectorTuple &tuple)
00051 {
00052 for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();
00053 it != m_mprSelectorSet.end (); it++)
00054 {
00055 if (*it == tuple)
00056 {
00057 m_mprSelectorSet.erase (it);
00058 break;
00059 }
00060 }
00061 }
00062
00063 void
00064 OlsrState::EraseMprSelectorTuples (const Ipv4Address &mainAddr)
00065 {
00066 for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();
00067 it != m_mprSelectorSet.end ();)
00068 {
00069 if (it->mainAddr == mainAddr)
00070 {
00071 it = m_mprSelectorSet.erase (it);
00072 }
00073 else
00074 {
00075 it++;
00076 }
00077 }
00078 }
00079
00080 void
00081 OlsrState::InsertMprSelectorTuple (MprSelectorTuple const &tuple)
00082 {
00083 m_mprSelectorSet.push_back (tuple);
00084 }
00085
00086 std::string
00087 OlsrState::PrintMprSelectorSet () const
00088 {
00089 std::ostringstream os;
00090 os << "[";
00091 for (MprSelectorSet::const_iterator iter = m_mprSelectorSet.begin ();
00092 iter != m_mprSelectorSet.end (); iter++)
00093 {
00094 MprSelectorSet::const_iterator next = iter;
00095 next++;
00096 os << iter->mainAddr;
00097 if (next != m_mprSelectorSet.end ())
00098 os << ", ";
00099 }
00100 os << "]";
00101 return os.str ();
00102 }
00103
00104
00105
00106
00107 NeighborTuple*
00108 OlsrState::FindNeighborTuple (Ipv4Address const &mainAddr)
00109 {
00110 for (NeighborSet::iterator it = m_neighborSet.begin ();
00111 it != m_neighborSet.end (); it++)
00112 {
00113 if (it->neighborMainAddr == mainAddr)
00114 return &(*it);
00115 }
00116 return NULL;
00117 }
00118
00119 const NeighborTuple*
00120 OlsrState::FindSymNeighborTuple (Ipv4Address const &mainAddr) const
00121 {
00122 for (NeighborSet::const_iterator it = m_neighborSet.begin ();
00123 it != m_neighborSet.end (); it++)
00124 {
00125 if (it->neighborMainAddr == mainAddr && it->status == NeighborTuple::STATUS_SYM)
00126 return &(*it);
00127 }
00128 return NULL;
00129 }
00130
00131 NeighborTuple*
00132 OlsrState::FindNeighborTuple (Ipv4Address const &mainAddr, uint8_t willingness)
00133 {
00134 for (NeighborSet::iterator it = m_neighborSet.begin ();
00135 it != m_neighborSet.end (); it++)
00136 {
00137 if (it->neighborMainAddr == mainAddr && it->willingness == willingness)
00138 return &(*it);
00139 }
00140 return NULL;
00141 }
00142
00143 void
00144 OlsrState::EraseNeighborTuple (const NeighborTuple &tuple)
00145 {
00146 for (NeighborSet::iterator it = m_neighborSet.begin ();
00147 it != m_neighborSet.end (); it++)
00148 {
00149 if (*it == tuple)
00150 {
00151 m_neighborSet.erase (it);
00152 break;
00153 }
00154 }
00155 }
00156
00157 void
00158 OlsrState::EraseNeighborTuple (const Ipv4Address &mainAddr)
00159 {
00160 for (NeighborSet::iterator it = m_neighborSet.begin ();
00161 it != m_neighborSet.end (); it++)
00162 {
00163 if (it->neighborMainAddr == mainAddr)
00164 {
00165 it = m_neighborSet.erase (it);
00166 break;
00167 }
00168 }
00169 }
00170
00171 void
00172 OlsrState::InsertNeighborTuple (NeighborTuple const &tuple)
00173 {
00174 for (NeighborSet::iterator it = m_neighborSet.begin ();
00175 it != m_neighborSet.end (); it++)
00176 {
00177 if (it->neighborMainAddr == tuple.neighborMainAddr)
00178 {
00179
00180 *it = tuple;
00181 return;
00182 }
00183 }
00184 m_neighborSet.push_back (tuple);
00185 }
00186
00187
00188
00189 TwoHopNeighborTuple*
00190 OlsrState::FindTwoHopNeighborTuple (Ipv4Address const &neighborMainAddr,
00191 Ipv4Address const &twoHopNeighborAddr)
00192 {
00193 for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();
00194 it != m_twoHopNeighborSet.end (); it++)
00195 {
00196 if (it->neighborMainAddr == neighborMainAddr
00197 && it->twoHopNeighborAddr == twoHopNeighborAddr)
00198 {
00199 return &(*it);
00200 }
00201 }
00202 return NULL;
00203 }
00204
00205 void
00206 OlsrState::EraseTwoHopNeighborTuple (const TwoHopNeighborTuple &tuple)
00207 {
00208 for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();
00209 it != m_twoHopNeighborSet.end (); it++)
00210 {
00211 if (*it == tuple)
00212 {
00213 m_twoHopNeighborSet.erase(it);
00214 break;
00215 }
00216 }
00217 }
00218
00219 void
00220 OlsrState::EraseTwoHopNeighborTuples (const Ipv4Address &neighborMainAddr,
00221 const Ipv4Address &twoHopNeighborAddr)
00222 {
00223 for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();
00224 it != m_twoHopNeighborSet.end ();)
00225 {
00226 if (it->neighborMainAddr == neighborMainAddr
00227 && it->twoHopNeighborAddr == twoHopNeighborAddr)
00228 {
00229 it = m_twoHopNeighborSet.erase (it);
00230 }
00231 else
00232 {
00233 it++;
00234 }
00235 }
00236 }
00237
00238 void
00239 OlsrState::EraseTwoHopNeighborTuples (const Ipv4Address &neighborMainAddr)
00240 {
00241 for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();
00242 it != m_twoHopNeighborSet.end ();)
00243 {
00244 if (it->neighborMainAddr == neighborMainAddr)
00245 {
00246 it = m_twoHopNeighborSet.erase (it);
00247 }
00248 else
00249 {
00250 it++;
00251 }
00252 }
00253 }
00254
00255 void
00256 OlsrState::InsertTwoHopNeighborTuple (TwoHopNeighborTuple const &tuple)
00257 {
00258 m_twoHopNeighborSet.push_back (tuple);
00259 }
00260
00261
00262
00263 bool
00264 OlsrState::FindMprAddress (Ipv4Address const &addr)
00265 {
00266 MprSet::iterator it = m_mprSet.find (addr);
00267 return (it != m_mprSet.end ());
00268 }
00269
00270 void
00271 OlsrState::SetMprSet (MprSet mprSet)
00272 {
00273 m_mprSet = mprSet;
00274 }
00275
00276
00277
00278 DuplicateTuple*
00279 OlsrState::FindDuplicateTuple (Ipv4Address const &addr, uint16_t sequenceNumber)
00280 {
00281 for (DuplicateSet::iterator it = m_duplicateSet.begin ();
00282 it != m_duplicateSet.end(); it++)
00283 {
00284 if (it->address == addr && it->sequenceNumber == sequenceNumber)
00285 return &(*it);
00286 }
00287 return NULL;
00288 }
00289
00290 void
00291 OlsrState::EraseDuplicateTuple (const DuplicateTuple &tuple)
00292 {
00293 for (DuplicateSet::iterator it = m_duplicateSet.begin ();
00294 it != m_duplicateSet.end (); it++)
00295 {
00296 if (*it == tuple)
00297 {
00298 m_duplicateSet.erase (it);
00299 break;
00300 }
00301 }
00302 }
00303
00304 void
00305 OlsrState::InsertDuplicateTuple (DuplicateTuple const &tuple)
00306 {
00307 m_duplicateSet.push_back (tuple);
00308 }
00309
00310
00311
00312 LinkTuple*
00313 OlsrState::FindLinkTuple (Ipv4Address const & ifaceAddr)
00314 {
00315 for (LinkSet::iterator it = m_linkSet.begin ();
00316 it != m_linkSet.end (); it++)
00317 {
00318 if (it->neighborIfaceAddr == ifaceAddr)
00319 return &(*it);
00320 }
00321 return NULL;
00322 }
00323
00324 LinkTuple*
00325 OlsrState::FindSymLinkTuple (Ipv4Address const &ifaceAddr, Time now)
00326 {
00327 for (LinkSet::iterator it = m_linkSet.begin ();
00328 it != m_linkSet.end (); it++)
00329 {
00330 if (it->neighborIfaceAddr == ifaceAddr)
00331 {
00332 if (it->symTime > now)
00333 return &(*it);
00334 else
00335 break;
00336 }
00337 }
00338 return NULL;
00339 }
00340
00341 void
00342 OlsrState::EraseLinkTuple (const LinkTuple &tuple)
00343 {
00344 for (LinkSet::iterator it = m_linkSet.begin ();
00345 it != m_linkSet.end (); it++)
00346 {
00347 if (*it == tuple)
00348 {
00349 m_linkSet.erase (it);
00350 break;
00351 }
00352 }
00353 }
00354
00355 LinkTuple&
00356 OlsrState::InsertLinkTuple (LinkTuple const &tuple)
00357 {
00358 m_linkSet.push_back (tuple);
00359 return m_linkSet.back ();
00360 }
00361
00362
00363
00364 TopologyTuple*
00365 OlsrState::FindTopologyTuple (Ipv4Address const &destAddr,
00366 Ipv4Address const &lastAddr)
00367 {
00368 for (TopologySet::iterator it = m_topologySet.begin ();
00369 it != m_topologySet.end (); it++)
00370 {
00371 if (it->destAddr == destAddr && it->lastAddr == lastAddr)
00372 return &(*it);
00373 }
00374 return NULL;
00375 }
00376
00377 TopologyTuple*
00378 OlsrState::FindNewerTopologyTuple (Ipv4Address const & lastAddr, uint16_t ansn)
00379 {
00380 for (TopologySet::iterator it = m_topologySet.begin ();
00381 it != m_topologySet.end (); it++)
00382 {
00383 if (it->lastAddr == lastAddr && it->sequenceNumber > ansn)
00384 return &(*it);
00385 }
00386 return NULL;
00387 }
00388
00389 void
00390 OlsrState::EraseTopologyTuple(const TopologyTuple &tuple)
00391 {
00392 for (TopologySet::iterator it = m_topologySet.begin ();
00393 it != m_topologySet.end (); it++)
00394 {
00395 if (*it == tuple)
00396 {
00397 m_topologySet.erase (it);
00398 break;
00399 }
00400 }
00401 }
00402
00403 void
00404 OlsrState::EraseOlderTopologyTuples (const Ipv4Address &lastAddr, uint16_t ansn)
00405 {
00406 for (TopologySet::iterator it = m_topologySet.begin();
00407 it != m_topologySet.end();)
00408 {
00409 if (it->lastAddr == lastAddr && it->sequenceNumber < ansn)
00410 {
00411 it = m_topologySet.erase (it);
00412 }
00413 else
00414 {
00415 it++;
00416 }
00417 }
00418 }
00419
00420 void
00421 OlsrState::InsertTopologyTuple (TopologyTuple const &tuple)
00422 {
00423 m_topologySet.push_back (tuple);
00424 }
00425
00426
00427
00428 IfaceAssocTuple*
00429 OlsrState::FindIfaceAssocTuple (Ipv4Address const &ifaceAddr)
00430 {
00431 for (IfaceAssocSet::iterator it = m_ifaceAssocSet.begin ();
00432 it != m_ifaceAssocSet.end (); it++)
00433 {
00434 if (it->ifaceAddr == ifaceAddr)
00435 return &(*it);
00436 }
00437 return NULL;
00438 }
00439
00440 const IfaceAssocTuple*
00441 OlsrState::FindIfaceAssocTuple (Ipv4Address const &ifaceAddr) const
00442 {
00443 for (IfaceAssocSet::const_iterator it = m_ifaceAssocSet.begin ();
00444 it != m_ifaceAssocSet.end (); it++)
00445 {
00446 if (it->ifaceAddr == ifaceAddr)
00447 return &(*it);
00448 }
00449 return NULL;
00450 }
00451
00452 void
00453 OlsrState::EraseIfaceAssocTuple (const IfaceAssocTuple &tuple)
00454 {
00455 for (IfaceAssocSet::iterator it = m_ifaceAssocSet.begin ();
00456 it != m_ifaceAssocSet.end (); it++)
00457 {
00458 if (*it == tuple)
00459 {
00460 m_ifaceAssocSet.erase (it);
00461 break;
00462 }
00463 }
00464 }
00465
00466 void
00467 OlsrState::InsertIfaceAssocTuple (const IfaceAssocTuple &tuple)
00468 {
00469 m_ifaceAssocSet.push_back (tuple);
00470 }
00471
00472 std::vector<Ipv4Address>
00473 OlsrState::FindNeighborInterfaces (const Ipv4Address &neighborMainAddr) const
00474 {
00475 std::vector<Ipv4Address> retval;
00476 for (IfaceAssocSet::const_iterator it = m_ifaceAssocSet.begin ();
00477 it != m_ifaceAssocSet.end (); it++)
00478 {
00479 if (it->mainAddr == neighborMainAddr)
00480 retval.push_back (it->ifaceAddr);
00481 }
00482 return retval;
00483 }
00484
00485 }