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

//

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

//

#include "seq-num.h"

#include "ns3/test.h"

#include "ns3/object.h"

#include "ns3/traced-value.h"

#include "ns3/trace-source-accessor.h"

namespace ns3 {

class SeqNumTestObj : public Object

{

  TracedValue<SeqNum32> m_testTracedSeqNum;

public:

  SeqNumTestObj () 

  {

    m_testTracedSeqNum = SeqNum32 (0);

  }

  static TypeId GetTypeId (void)

  {

    static TypeId tid = TypeId("ns3::SeqNumTestObj")

      .SetParent<Object> ()

      .AddTraceSource ("TestTracedSeqNum",

                       "A traceable sequence number",

                       MakeTraceSourceAccessor (&SeqNumTestObj::m_testTracedSeqNum))

      .AddConstructor<SeqNumTestObj> ()

      ;

    return tid;

  }

  TypeId GetInstanceTypeId (void) const

  {

    return GetTypeId ();

  }

  void IncSeqNum ()

  {

    ++m_testTracedSeqNum;

  }

};

class SeqNumTestCase : public TestCase

{

  SeqNum32 m_oldval;

  SeqNum32 m_newval;

  void SeqNumTracer (SeqNum32 oldval, SeqNum32 newval);

public:

  SeqNumTestCase ();

  virtual ~SeqNumTestCase ();

  virtual bool DoRun (void);

};

SeqNumTestCase::SeqNumTestCase ()

  : TestCase ("SeqNum")

{

  m_oldval = 0;

  m_newval = 0;

}

SeqNumTestCase::~SeqNumTestCase ()

{}

void

SeqNumTestCase::SeqNumTracer (SeqNum32 oldval, SeqNum32 newval) 

{

  m_oldval = oldval;

  m_newval = newval;

}

bool SeqNumTestCase::DoRun (void)

{

#define NS_TEST_ASSERT_EQUAL(a,b) NS_TEST_ASSERT_MSG_EQ(a,b, "foo")

#define NS_TEST_ASSERT(a) NS_TEST_ASSERT_MSG_EQ(bool(a), true, "foo")

  {

      SeqNum32 num1 (3), num2 (5);

      uint32_t value;

      value = (num1 + num2).GetValue ();

      NS_TEST_ASSERT_EQUAL (value, 8);

      num1 += num2.GetValue ();

      NS_TEST_ASSERT_EQUAL (num1, SeqNum32 (8));

      ++num1;

      NS_TEST_ASSERT_EQUAL (num1, SeqNum32 (9));

      --num1;

      NS_TEST_ASSERT_EQUAL (num1, SeqNum32 (8));

      num1++;

      NS_TEST_ASSERT_EQUAL (num1, SeqNum32 (9));

      num1--;

      NS_TEST_ASSERT_EQUAL (num1, SeqNum32 (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, SeqNum32 (13));

    num1 += -1;

    NS_TEST_ASSERT_EQUAL (num1, SeqNum32 (2));

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

  }

  {

    Ptr<SeqNumTestObj> obj = CreateObject<SeqNumTestObj> ();

    obj->TraceConnectWithoutContext ("TestTracedSeqNum", MakeCallback (&SeqNumTestCase::SeqNumTracer, this));

    obj->IncSeqNum ();

    NS_TEST_ASSERT_EQUAL (m_oldval, SeqNum32 (0));

    NS_TEST_ASSERT_EQUAL (m_newval, SeqNum32 (1));

    obj->Dispose ();

  }

  return false;

}

static class SeqNumTestSuite : public TestSuite

{

public:

  SeqNumTestSuite ()

    : TestSuite ("SeqNum", UNIT) 

  {

    AddTestCase (new SeqNumTestCase ());

  }

} g_seqNumTests;

}

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

//

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

#include <stdint.h>

namespace ns3 {

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

class SeqNum

{

public:

  SeqNum ()

    : m_value (0)

  {}

  // contruct from a plain number; but the contructor is _explicit_, so not called automatically, ever.

  explicit SeqNum (NUMERIC_TYPE value)

    : m_value (value)

  {}

  // copy contructor

  SeqNum (SeqNum<NUMERIC_TYPE, SIGNED_TYPE> const &value)

    : m_value (value.m_value)

  {}

  // assignment from a plain number

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

  {

    m_value = value;

    return *this;

  }

  // assignment from a sequence number

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

  {

    m_value = value.m_value;

    return *this;

  }

#if 0

  // a SeqNum implicitly converts to a plain number, but not the other way around

  operator NUMERIC_TYPE () const

  {

    return m_value;

  }

#endif

  NUMERIC_TYPE GetValue () const

  {

    return m_value;

  }

  // 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;

  }

  template<typename NUMERIC_TYPE2, typename SIGNED_TYPE2>

  friend std::ostream & operator<< (std::ostream& os, const SeqNum<NUMERIC_TYPE2, SIGNED_TYPE2> &val);

  template<typename NUMERIC_TYPE2, typename SIGNED_TYPE2>

  friend std::istream & operator >> (std::istream &is, const SeqNum<NUMERIC_TYPE2, SIGNED_TYPE2> &val);

private: // unimplemented operators

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

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

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator* (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator/ (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator% (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  bool operator ! () const;

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

  bool operator || (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator~ () const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator& (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator| (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator^ (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator<< (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE> operator>> (const SeqNum<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

  int operator* ();

  SeqNum<NUMERIC_TYPE, SIGNED_TYPE>* operator& ();

private:

  NUMERIC_TYPE m_value;

};

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

std::ostream &

operator<< (std::ostream& os, const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &val)

{

  os << val.m_value;

  return os;

}

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

std::istream & operator >> (std::istream &is, const SeqNum<NUMERIC_TYPE, SIGNED_TYPE> &val)

{

  is >> val.m_value;

  return is;

}

typedef SeqNum<uint32_t, int32_t> SeqNum32;

typedef SeqNum<uint16_t, int16_t> SeqNum16;

} // namespace ns3

#endif

        'seq-num.cc',

        'seq-num.h',