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

#ifdef RUN_SELF_TESTS

#include "seq-num.h"

#include "ns3/test.h"

namespace ns3 {

class SeqNumTest : public ns3::Test {

private:

public:

  SeqNumTest ();

  virtual bool RunTests (void);

};

SeqNumTest::SeqNumTest ()

  : ns3::Test ("SeqNum")

{}

bool 

SeqNumTest::RunTests (void)

{

  bool result = true;

  {

      SeqNum32 num1 (3), num2 (5);

      uint32_t value;

      value = num1 + num2;

      NS_TEST_ASSERT_EQUAL (value, 8);

      num1 += num2;

      NS_TEST_ASSERT_EQUAL (num1, 8);

      ++num1;

      NS_TEST_ASSERT_EQUAL (num1, 9);

      --num1;

      NS_TEST_ASSERT_EQUAL (num1, 8);

      num1++;

      NS_TEST_ASSERT_EQUAL (num1, 9);

      num1--;

      NS_TEST_ASSERT_EQUAL (num1, 8);

  }

  {

      SeqNum16 num1 (60900), num2 (5), num3 (10000);

      NS_TEST_ASSERT (num1 == num1);

      NS_TEST_ASSERT (num2 != num1);

      NS_TEST_ASSERT (num3 > num2);

      NS_TEST_ASSERT (num3 >= num2);

      NS_TEST_ASSERT (num1 < num3);

      NS_TEST_ASSERT (num1 <= num3);

      NS_TEST_ASSERT (num1 < num2);

      NS_TEST_ASSERT (num1 <= num2);

      NS_TEST_ASSERT (num2 > num1);

      NS_TEST_ASSERT (num2 >= num1);

      NS_TEST_ASSERT (num1+num2 > num1);

      NS_TEST_ASSERT (num1+num2 >= num1);

      NS_TEST_ASSERT (num1 < num1+num2);

      NS_TEST_ASSERT (num1 <= num1+num2);

      NS_TEST_ASSERT (num1 < num1+num3);

      NS_TEST_ASSERT (num1 <= num1+num3);

      NS_TEST_ASSERT (num1+num3 > num1);

      NS_TEST_ASSERT (num1+num3 >= num1);

  }

  {

      NS_TEST_ASSERT_EQUAL ((SeqNum16 (1000) + SeqNum16 (6000)) - SeqNum16 (1000), 6000);

      NS_TEST_ASSERT_EQUAL ((SeqNum16 (60000) + SeqNum16 (6000)) - SeqNum16 (60000), 6000);

      NS_TEST_ASSERT_EQUAL (SeqNum16 (1000) - SeqNum16 (6000), -5000);

      NS_TEST_ASSERT_EQUAL ((SeqNum16 (60000) + SeqNum16 (1000)) - SeqNum16 (65000), -4000);

  }

  {

      SeqNum32 num1 (3);

      NS_TEST_ASSERT_EQUAL (num1 + 10, 13);

      num1 += -1;

      NS_TEST_ASSERT_EQUAL (num1, 2);

      NS_TEST_ASSERT_EQUAL (num1 - (num1 - 100), 100);

  }

  return result;

}

static SeqNumTest gSeqNumTest;

}; // namespace

#endif /* RUN_SELF_TESTS */

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

//

// Copyright (c) 2008 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

//

// Author: Gustavo J. A. M. Carneiro  <gjc@inescporto.pt> <gjcarneiro@gmail.com>

//

#ifndef __NS3_SEQ_NUM_H__

#define __NS3_SEQ_NUM_H__

#include <limits>

#include <stdint.h>

namespace ns3 {

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

class SeqNum

{

public:

  SeqNum ()

    : m_value (0)

  {}

  explicit SeqNum (NUMERIC_TYPE value)

    : m_value (value)

  {}

  operator NUMERIC_TYPE () const

  {

    return m_value;

  }

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& operator= (NUMERIC_TYPE value)

  {

    m_value = value;

    return *this;

  }

  // prefix ++

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator++ ()

  {

    m_value++;

    return *this;

  }

  // postfix ++

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator++ (int)

  {

    SeqNum<NUMERIC_TYPE, SIGNED_TYPE> retval (m_value);

    m_value++;

    return retval;

  }

  // prefix --

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator-- ()

  {

    m_value--;

    return *this;

  }

  // postfix --

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator-- (int)

  {

    SeqNum<NUMERIC_TYPE, SIGNED_TYPE> retval (m_value);

    m_value--;

    return retval;

  }

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& operator+= (SIGNED_TYPE value)

  {

    m_value += value;

    return *this;

  }

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& operator-= (SIGNED_TYPE value)

  {

    m_value -= value;

    return *this;

  }

   SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator + (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

   {

     return SeqNum<NUMERIC_TYPE, SIGNED_TYPE> (m_value + other.m_value);

   }

   SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator + (SIGNED_TYPE delta)

   {

     return SeqNum<NUMERIC_TYPE, SIGNED_TYPE> (m_value + delta);

   }

   SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator - (SIGNED_TYPE delta)

   {

     return SeqNum<NUMERIC_TYPE, SIGNED_TYPE> (m_value - delta);

   }

   SIGNED_TYPE operator - (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

   {

     static const NUMERIC_TYPE maxValue = std::numeric_limits<NUMERIC_TYPE>::max ();

     static const NUMERIC_TYPE halfMaxValue = std::numeric_limits<NUMERIC_TYPE>::max () / 2;

     if (m_value > other.m_value)

       {

         NUMERIC_TYPE diff = m_value - other.m_value;

         if (diff < halfMaxValue)

           {

             return static_cast<SIGNED_TYPE> (diff);

           }

         else

           {

             //      |------------|------------|

             //       ====                  ===

             //          ^                  ^   

             //       other.m_value      m_value

             return -(static_cast<SIGNED_TYPE> (maxValue - m_value + 1 + other.m_value));

           }

       }

     else

       {

         NUMERIC_TYPE diff = other.m_value - m_value;

         if (diff < halfMaxValue)

           {

             //      |------------|------------|

             //          ========

             //          ^      ^   

             //     m_value   other.m_value

             return -(static_cast<SIGNED_TYPE> (diff));

           }

         else

           {

             //      |------------|------------|

             //       ====                  ===

             //          ^                  ^   

             //       m_value      other.m_value

             return static_cast<SIGNED_TYPE> (maxValue - other.m_value + 1 + m_value);

           }

       }

   }

  // Here is the critical part, how the comparison is made taking into

  // account wrap-around.  From RFC 3626:

  //

  //   The sequence number S1 is said to be "greater than" the sequence

  //    number S2 if:

  //

  //           S1 > S2 AND S1 - S2 <= MAXVALUE/2 OR

  //

  //           S2 > S1 AND S2 - S1 > MAXVALUE/2

  bool operator > (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

  {

    static const NUMERIC_TYPE halfMaxValue = std::numeric_limits<NUMERIC_TYPE>::max () / 2;

    return (((m_value > other.m_value) && (m_value - other.m_value) <= halfMaxValue)

            || ((other.m_value > m_value) && (other.m_value - m_value) > halfMaxValue));

  }

  bool operator == (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

  {

    return (m_value == other.m_value);

  }

  bool operator != (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

  {

    return (m_value != other.m_value);

  }

  bool operator <= (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

  {

    return (!this->operator> (other));

  }

  bool operator >= (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

  {

    return (this->operator> (other) || this->operator== (other));

  }

  bool operator < (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &other)

  {

    return !this->operator> (other) && m_value != other.m_value;

  }

private:

  NUMERIC_TYPE m_value;

};

typedef SeqNum<uint32_t, int32_t> SeqNum32;

typedef SeqNum<uint16_t, int16_t> SeqNum16;

} // namespace ns3

#endif

        'seq-num.cc',

        'seq-num.h',