/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

 /*

  * Copyright (c) 2004 Francisco J. Ros 

  * Copyright (c) 2007 INESC Porto

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License version 2 as

  * published by the Free Software Foundation;

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  * Authors: Francisco J. Ros  <fjrm@dif.um.es>

  *          Gustavo J. A. M. Carneiro <gjc@inescporto.pt>

  */

 ///

 /// \file	OlsrState.cc

 /// \brief	Implementation of all functions needed for manipulating the internal

 ///		state of an OLSR node.

 ///

 #include "olsr-state.h"

 namespace ns3 {

 /********** MPR Selector Set Manipulation **********/

 MprSelectorTuple*

 OlsrState::FindMprSelectorTuple (Ipv4Address const &mainAddr)

 {

   for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();

        it != m_mprSelectorSet.end (); it++)

     {

       if (it->mainAddr == mainAddr)

         return &(*it);

     }

   return NULL;

 }

 void

 OlsrState::EraseMprSelectorTuple (const MprSelectorTuple &tuple)

 {

   for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();

        it != m_mprSelectorSet.end (); it++)

     {

       if (*it == tuple)

         {

           m_mprSelectorSet.erase (it);

           break;

         }

     }

 }

 void

 OlsrState::EraseMprSelectorTuples (const Ipv4Address &mainAddr)

 {

   for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();

        it != m_mprSelectorSet.end ();)

     {

       if (it->mainAddr == mainAddr)

         {

           it = m_mprSelectorSet.erase (it);

         }

       else

         {

           it++;

         }

     }

 }

 void

 OlsrState::InsertMprSelectorTuple (MprSelectorTuple const &tuple)

 {

   m_mprSelectorSet.push_back (tuple);

 }

 std::string

 OlsrState::PrintMprSelectorSet () const

 {

   std::ostringstream os;

   os << "[";

   for (MprSelectorSet::const_iterator iter = m_mprSelectorSet.begin ();

        iter != m_mprSelectorSet.end (); iter++)

     {

       MprSelectorSet::const_iterator next = iter;

       next++;

       os << iter->mainAddr;

       if (next != m_mprSelectorSet.end ())

         os << ", ";

     }

   os << "]";

   return os.str ();

 }

 /********** Neighbor Set Manipulation **********/

 NeighborTuple*

 OlsrState::FindNeighborTuple (Ipv4Address const &mainAddr)

 {

   for (NeighborSet::iterator it = m_neighborSet.begin ();

        it != m_neighborSet.end (); it++)

     {

       if (it->neighborMainAddr == mainAddr)

         return &(*it);

     }

   return NULL;

 }

 const NeighborTuple*

 OlsrState::FindSymNeighborTuple (Ipv4Address const &mainAddr) const

 {

   for (NeighborSet::const_iterator it = m_neighborSet.begin ();

        it != m_neighborSet.end (); it++)

     {

       if (it->neighborMainAddr == mainAddr && it->status == NeighborTuple::STATUS_SYM)

         return &(*it);

     }

   return NULL;

 }

 NeighborTuple*

 OlsrState::FindNeighborTuple (Ipv4Address const &mainAddr, uint8_t willingness)

 {

   for (NeighborSet::iterator it = m_neighborSet.begin ();

        it != m_neighborSet.end (); it++)

     {

       if (it->neighborMainAddr == mainAddr && it->willingness == willingness)

         return &(*it);

     }

   return NULL;

 }

 void

 OlsrState::EraseNeighborTuple (const NeighborTuple &tuple)

 {

   for (NeighborSet::iterator it = m_neighborSet.begin ();

        it != m_neighborSet.end (); it++)

     {

       if (*it == tuple)

         {

           m_neighborSet.erase (it);

           break;

         }

     }

 }

 void

 OlsrState::EraseNeighborTuple (const Ipv4Address &mainAddr)

 {

   for (NeighborSet::iterator it = m_neighborSet.begin ();

        it != m_neighborSet.end (); it++)

     {

       if (it->neighborMainAddr == mainAddr)

         {

           it = m_neighborSet.erase (it);

           break;

         }

     }

 }

 void

 OlsrState::InsertNeighborTuple (NeighborTuple const &tuple)

 {

   for (NeighborSet::iterator it = m_neighborSet.begin ();

        it != m_neighborSet.end (); it++)

     {

       if (it->neighborMainAddr == tuple.neighborMainAddr)

         {

           // Update it

           *it = tuple;

           return;

         }

     }

   m_neighborSet.push_back (tuple);

 }

 /********** Neighbor 2 Hop Set Manipulation **********/

 TwoHopNeighborTuple*

 OlsrState::FindTwoHopNeighborTuple (Ipv4Address const &neighborMainAddr,

                                     Ipv4Address const &twoHopNeighborAddr)

 {

   for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

        it != m_twoHopNeighborSet.end (); it++)

     {

       if (it->neighborMainAddr == neighborMainAddr

           && it->twoHopNeighborAddr == twoHopNeighborAddr)

         {

           return &(*it);

         }

   }

   return NULL;

 }

 void

 OlsrState::EraseTwoHopNeighborTuple (const TwoHopNeighborTuple &tuple)

 {

   for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

        it != m_twoHopNeighborSet.end (); it++)

     {

       if (*it == tuple)

         {

           m_twoHopNeighborSet.erase(it);

           break;

         }

     }

 }

 void

 OlsrState::EraseTwoHopNeighborTuples (const Ipv4Address &neighborMainAddr,

                                       const Ipv4Address &twoHopNeighborAddr)

 {

   for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

        it != m_twoHopNeighborSet.end ();)

     {

       if (it->neighborMainAddr == neighborMainAddr

           && it->twoHopNeighborAddr == twoHopNeighborAddr)

         {

           it = m_twoHopNeighborSet.erase (it);

         }

       else

         {

           it++;

         }

     }

 }

 void

 OlsrState::EraseTwoHopNeighborTuples (const Ipv4Address &neighborMainAddr)

 {

   for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

        it != m_twoHopNeighborSet.end ();)

     {

       if (it->neighborMainAddr == neighborMainAddr)

         {

           it = m_twoHopNeighborSet.erase (it);

         }

       else

         {

           it++;

         }

     }

 }

 void

 OlsrState::InsertTwoHopNeighborTuple (TwoHopNeighborTuple const &tuple)

 {

   m_twoHopNeighborSet.push_back (tuple);

 }

 /********** MPR Set Manipulation **********/

 bool

 OlsrState::FindMprAddress (Ipv4Address const &addr)

 {

   MprSet::iterator it = m_mprSet.find (addr);

   return (it != m_mprSet.end ());

 }

 void

 OlsrState::SetMprSet (MprSet mprSet)

 {

   m_mprSet = mprSet;

 }

 /********** Duplicate Set Manipulation **********/

 DuplicateTuple*

 OlsrState::FindDuplicateTuple (Ipv4Address const &addr, uint16_t sequenceNumber)

 {

   for (DuplicateSet::iterator it = m_duplicateSet.begin ();

        it != m_duplicateSet.end(); it++)

     {

       if (it->address == addr && it->sequenceNumber == sequenceNumber)

         return &(*it);

     }

   return NULL;

 }

 void

 OlsrState::EraseDuplicateTuple (const DuplicateTuple &tuple)

 {

   for (DuplicateSet::iterator it = m_duplicateSet.begin ();

        it != m_duplicateSet.end (); it++)

     {

       if (*it == tuple)

         {

           m_duplicateSet.erase (it);

           break;

         }

     }

 }

 void

 OlsrState::InsertDuplicateTuple (DuplicateTuple const &tuple)

 {

   m_duplicateSet.push_back (tuple);

 }

 /********** Link Set Manipulation **********/

 LinkTuple*

 OlsrState::FindLinkTuple (Ipv4Address const & ifaceAddr)

 {

   for (LinkSet::iterator it = m_linkSet.begin ();

        it != m_linkSet.end (); it++)

     {

       if (it->neighborIfaceAddr == ifaceAddr)

         return &(*it);

     }

   return NULL;

 }

 LinkTuple*

 OlsrState::FindSymLinkTuple (Ipv4Address const &ifaceAddr, Time now)

 {

   for (LinkSet::iterator it = m_linkSet.begin ();

        it != m_linkSet.end (); it++)

     {

       if (it->neighborIfaceAddr == ifaceAddr)

         {

           if (it->symTime > now)

             return &(*it);

           else

             break;

         }

     }

   return NULL;

 }

 void

 OlsrState::EraseLinkTuple (const LinkTuple &tuple)

 {

   for (LinkSet::iterator it = m_linkSet.begin ();

        it != m_linkSet.end (); it++)

     {

       if (*it == tuple)

         {

           m_linkSet.erase (it);

           break;

         }

     }

 }

 LinkTuple&

 OlsrState::InsertLinkTuple (LinkTuple const &tuple)

 {

   m_linkSet.push_back (tuple);

   return m_linkSet.back ();

 }

 /********** Topology Set Manipulation **********/

 TopologyTuple*

 OlsrState::FindTopologyTuple (Ipv4Address const &destAddr,

                               Ipv4Address const &lastAddr)

 {

   for (TopologySet::iterator it = m_topologySet.begin ();

        it != m_topologySet.end (); it++)

     {

       if (it->destAddr == destAddr && it->lastAddr == lastAddr)

         return &(*it);

     }

   return NULL;

 }

 TopologyTuple*

 OlsrState::FindNewerTopologyTuple (Ipv4Address const & lastAddr, uint16_t ansn)

 {

   for (TopologySet::iterator it = m_topologySet.begin ();

        it != m_topologySet.end (); it++)

     {

       if (it->lastAddr == lastAddr && it->sequenceNumber > ansn)

         return &(*it);

     }

   return NULL;

 }

 void

 OlsrState::EraseTopologyTuple(const TopologyTuple &tuple)

 {

   for (TopologySet::iterator it = m_topologySet.begin ();

        it != m_topologySet.end (); it++)

     {

       if (*it == tuple)

         {

           m_topologySet.erase (it);

           break;

         }

     }

 }

 void

 OlsrState::EraseOlderTopologyTuples (const Ipv4Address &lastAddr, uint16_t ansn)

 {

   for (TopologySet::iterator it = m_topologySet.begin();

        it != m_topologySet.end();)

     {

       if (it->lastAddr == lastAddr && it->sequenceNumber < ansn)

         {

           it = m_topologySet.erase (it);

         }

       else

         {

           it++;

         }

     }

 }

 void

 OlsrState::InsertTopologyTuple (TopologyTuple const &tuple)

 {

   m_topologySet.push_back (tuple);

 }

 /********** Interface Association Set Manipulation **********/

 IfaceAssocTuple*

 OlsrState::FindIfaceAssocTuple (Ipv4Address const &ifaceAddr)

 {

   for (IfaceAssocSet::iterator it = m_ifaceAssocSet.begin ();

        it != m_ifaceAssocSet.end (); it++)

     {

       if (it->ifaceAddr == ifaceAddr)

         return &(*it);

     }

   return NULL;

 }

 const IfaceAssocTuple*

 OlsrState::FindIfaceAssocTuple (Ipv4Address const &ifaceAddr) const

 {

   for (IfaceAssocSet::const_iterator it = m_ifaceAssocSet.begin ();

        it != m_ifaceAssocSet.end (); it++)

     {

       if (it->ifaceAddr == ifaceAddr)

         return &(*it);

     }

   return NULL;

 }

 void

 OlsrState::EraseIfaceAssocTuple (const IfaceAssocTuple &tuple)

 {

   for (IfaceAssocSet::iterator it = m_ifaceAssocSet.begin ();

        it != m_ifaceAssocSet.end (); it++)

     {

       if (*it == tuple)

         {

           m_ifaceAssocSet.erase (it);

           break;

         }

     }

 }

 void

 OlsrState::InsertIfaceAssocTuple (const IfaceAssocTuple &tuple)

 {

   m_ifaceAssocSet.push_back (tuple);

 }

 std::vector<Ipv4Address>

 OlsrState::FindNeighborInterfaces (const Ipv4Address &neighborMainAddr) const

 {

   std::vector<Ipv4Address> retval;

   for (IfaceAssocSet::const_iterator it = m_ifaceAssocSet.begin ();

        it != m_ifaceAssocSet.end (); it++)

     {

       if (it->mainAddr == neighborMainAddr)

         retval.push_back (it->ifaceAddr);

     }

   return retval;

 }

 } // namespace ns3