* \brief Check the Ipv4Address allocation in the list of IPv4 entries

   *

   * \param addr The Ipv4Address to be checked in the list of Ipv4 entries

   * \returns true if the network is already allocated

   */

  bool CheckAllocated (const Ipv4Address addr);

  /**

bool

Ipv4AddressGeneratorImpl::CheckAllocated (const Ipv4Address address)

{

  NS_LOG_FUNCTION (this << address);

  uint32_t addr = address.Get ();

  NS_ABORT_MSG_UNLESS (addr, "Ipv4AddressGeneratorImpl::CheckAllocated(): Don't check for the broadcast address...");

  std::list<Entry>::iterator i;

  for (i = m_entries.begin (); i != m_entries.end (); ++i)

    {

      NS_LOG_LOGIC ("examine entry: " << Ipv4Address ((*i).addrLow) <<

                    " to " << Ipv4Address ((*i).addrHigh));

//

// First things first.  Is there an address collision -- that is, does the

// new address fall in a previously allocated block of addresses.

//

      if (addr >= (*i).addrLow && addr <= (*i).addrHigh)

        {

          NS_LOG_LOGIC ("Ipv4AddressGeneratorImpl::CheckAllocated(): Address Collision: " << Ipv4Address (addr));

          return false;

        }

//

// If the new address is less than the lowest address in the current block,

// and can't be merged into to the current block, then insert it as a new

// block before the current block.

//

      if (addr < (*i).addrLow - 1)

        {

          break;

        }

//

// If the new address fits at the end of the block, look ahead to the next

// block and make sure it's not a collision there.  If we won't overlap, then

// just extend the current block by one address.  We expect that completely

// filled network ranges will be a fairly rare occurrence, so we don't worry

// about collapsing address range blocks.

//

      if (addr == (*i).addrHigh + 1)

        {

          std::list<Entry>::iterator j = i;

          ++j;

          if (j != m_entries.end ())

            {

              if (addr == (*j).addrLow)

                {

                  NS_LOG_LOGIC ("Ipv4AddressGeneratorImpl::CheckAllocated(): "

                                "Address Collision: " << Ipv4Address (addr));

                  return false;

                }

            }

          NS_LOG_LOGIC ("New addrHigh = " << Ipv4Address (addr));

          (*i).addrHigh = addr;

          return true;

        }

//

// If we get here, we know that the next lower block of addresses couldn't

// have been extended to include this new address since the code immediately

// above would have been executed and that next lower block extended upward.

// So we know it's safe to extend the current block down to include the new

// address.

//

      if (addr == (*i).addrLow - 1)

        {

          NS_LOG_LOGIC ("New addrLow = " << Ipv4Address (addr));

          (*i).addrLow = addr;

          return true;

        }

    }

  return true;

}

bool

Ipv4AddressGenerator::CheckAllocated (const Ipv4Address addr)

{

  NS_LOG_FUNCTION_NOARGS ();

  return SimulationSingleton<Ipv4AddressGeneratorImpl>::Get ()

         ->CheckAllocated (addr);

}

   * \brief Check the Ipv4Address allocation in the list of IPv4 entries

   *

   * \param addr The Ipv4Address to be checked in the list of Ipv4 entries

   * \returns true if the network is already allocated

   */

  static bool CheckAllocated (const Ipv4Address addr);

  /**

   * \brief Check the Ipv6Address allocation in the list of IPv6 entries

   *

   * \param addr The Ipv6Address to be checked in the list of Ipv4 entries

   * \returns true if the network is already allocated

   */

  bool CheckAllocated (const Ipv6Address addr);

  /**

bool

Ipv6AddressGeneratorImpl::CheckAllocated (const Ipv6Address address)

{

  NS_LOG_FUNCTION (this << address);

  uint8_t addr[16];

  address.GetBytes (addr);

  std::list<Entry>::iterator i;

  for (i = m_entries.begin (); i != m_entries.end (); ++i)

    {

      NS_LOG_LOGIC ("examine entry: " << Ipv6Address ((*i).addrLow) <<

                    " to " << Ipv6Address ((*i).addrHigh));

      //

      // First things first.  Is there an address collision -- that is, does the

      // new address fall in a previously allocated block of addresses.

      //

      if (!(Ipv6Address (addr) < Ipv6Address ((*i).addrLow))

          && ((Ipv6Address (addr) < Ipv6Address ((*i).addrHigh))

              || (Ipv6Address (addr) == Ipv6Address ((*i).addrHigh))))

        {

          NS_LOG_LOGIC ("Ipv6AddressGeneratorImpl::CheckAllocated(): Address Collision: " << Ipv6Address (addr));

          return false;

        }

      //

      // If the new address is less than the lowest address in the current

      // block and can't be merged into to the current block, then insert it

      // as a new block before the current block.

      //

      uint8_t taddr[16];

      for (uint32_t j = 0; j < 16; j++)

        {

          taddr[j] = (*i).addrLow[j];

        }

      taddr[15] -= 1;

      if (Ipv6Address (addr) < Ipv6Address (taddr))

        {

          break;

        }

      //

      // If the new address fits at the end of the block, look ahead to the next

      // block and make sure it's not a collision there.  If we won't overlap,

      // then just extend the current block by one address.  We expect that

      // completely filled network ranges will be a fairly rare occurrence,

      // so we don't worry about collapsing address range blocks.

      //

      for (uint32_t j = 0; j < 16; j++)

        {

          taddr[j] = (*i).addrLow[j];

        }

      taddr[15] += 1;

      if (Ipv6Address (addr) == Ipv6Address (taddr))

        {

          std::list<Entry>::iterator j = i;

          ++j;

          if (j != m_entries.end ())

            {

              if (Ipv6Address (addr) == Ipv6Address ((*j).addrLow))

                {

                  NS_LOG_LOGIC ("Ipv6AddressGeneratorImpl::CheckAllocated(): "

                                "Address Collision: " << Ipv6Address (addr));

                 }

            }

          NS_LOG_LOGIC ("New addrHigh = " << Ipv6Address (addr));

          for (uint32_t j = 0; j < 16; j++)

            {

              (*i).addrHigh[j] = addr[j];

            }

          return true;

        }

      //

      // If we get here, we know that the next lower block of addresses

      // couldn't have been extended to include this new address since the

      // code immediately above would have been executed and that next lower

      // block extended upward.  So we know it's safe to extend the current

      // block down to includ the new address.

      //

      for (uint32_t j = 0; j < 16; j++)

        {

          taddr[j] = (*i).addrLow[j];

        }

      taddr[15] -= 1;

      if ((Ipv6Address (addr) == Ipv6Address (taddr)))

        {

          NS_LOG_LOGIC ("New addrLow = " << Ipv6Address (addr));

          for (uint32_t j = 0; j < 16; j++)

            {

              (*i).addrLow[j] = addr[j];

            }

          return true;

        }

    }

  return true;

}

bool

Ipv6AddressGenerator::CheckAllocated (const Ipv6Address addr)

{

  NS_LOG_FUNCTION_NOARGS ();

  return SimulationSingleton<Ipv6AddressGeneratorImpl>::Get ()

         ->CheckAllocated (addr);

}

   * \brief Check the Ipv6Address allocation in the list of IPv6 entries

   *

   * \param addr The Ipv6Address to be checked in the list of Ipv4 entries

   * \returns true if the network is already allocated

   */

  static bool CheckAllocated (const Ipv6Address addr);

  /**