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

/*

 * Copyright (c) 2009 University of Applied Sciences Rapperswil, Switzerland (HSR)

 *

 * 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:  Fabian Mauchle <fabian.mauchle@hsr.ch>

 */

#include "sequence.h"

#include "ns3/test.h"

#include "ns3/assert.h"

//all functions are implemented in the header

//--sequence test

namespace ns3

{

class SequenceTest : public TestCase

{

public:

  SequenceTest () : TestCase ("Check sequence mathematical correctness"){}

  virtual bool DoRun (void)

  {

    sequence32_t testValues[][2] = {

        {1,2},

        {-1,0},

        {0,0xefffffff},

        {0xefffffff,-1},

        {0xf0000000,0},

        {1,0xf0000000}

    };

    for(int i = 0; i < 2; i++)

      {

        sequence32_t    a = testValues[i][0],

                        b = testValues[i][1];

        NS_TEST_ASSERT_MSG_EQ((bool)(a < b), true, "a < b");

        NS_TEST_ASSERT_MSG_EQ((bool)(a > b), (bool)(b < a), "fail");

        NS_TEST_ASSERT_MSG_EQ((bool)(a < b), (bool)(b > a), "fail");

        NS_TEST_ASSERT_MSG_EQ((bool)(a <= b), (bool)(b >= a), "fail");

        NS_TEST_ASSERT_MSG_EQ((bool)(a >= b), (bool)(b <= a), "fail");

        NS_TEST_ASSERT_MSG_NE((bool)(a >= b), (bool)(a < b), "fail");

        NS_TEST_ASSERT_MSG_NE((bool)(a <= b), (bool)(a > b), "fail");

      }

    sequence32_t x = 10, y = 10;

    NS_TEST_ASSERT_MSG_EQ((bool)(x <= y), true, "x <= y");

    NS_TEST_ASSERT_MSG_EQ((bool)(x >= y), true, "x <= y");

    NS_TEST_ASSERT_MSG_EQ((bool)(x == y), true, "x <= y");

    return GetErrorStatus ();

  }

};

class SequenceTestSuite : public TestSuite

{

public:

  SequenceTestSuite () : TestSuite ("sequence-test", UNIT)

  {

    AddTestCase (new SequenceTest);

  }

} sequenceTestSuite;

}

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

/*

 * Copyright (c) 2009 University of Applied Sciences Rapperswil, Switzerland (HSR)

 *

 * 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:  Fabian Mauchle <fabian.mauchle@hsr.ch>

 */

#ifndef SEQUENCE_H

#define SEQUENCE_H

#include <stdint.h>

/**

 * \breif generic sequence number

 *

 * LessOrEqualThan is defined as the compared number itself and the preceding

 * 2^(n-1) -1 numbers in the finite field of 2^n

 *

 * GreaterThan is defined as the proceding 2^(n-1) numbers in the finite field

 * of 2^n

 *

 */

template <typename T>

class Sequence

{

public:

  Sequence () : seq(0) {}

  Sequence (const T s) : seq (s) { }

  operator T () const { return seq;}

  Sequence& operator= (const T s) { seq = s; return *this;}

  Sequence& operator+= (const T s) { seq += s; return *this;}

  Sequence  operator++ ()              { seq++; return *this;}

  Sequence  operator++ (int)           { Sequence ss (seq); seq++; return ss;}

  Sequence& operator-= (const T s) { seq -= s; return *this;}

  Sequence  operator-- ()              { seq--; return *this;}

  Sequence  operator-- (int)           { Sequence ss (seq); seq--; return ss;}

  T seq;

};

template <typename T>

bool operator<= (Sequence<T> a, Sequence<T> b)

{

  return (b - a) < (((Sequence<T>)(-1))>>1);

}

template <typename T>

bool operator>= (Sequence<T> a, Sequence<T> b)

{

  return b <= a;

}

template <typename T>

bool operator< (Sequence<T> a, Sequence<T> b)

{

  return ! (a >= b);

}

template <typename T>

bool operator> (Sequence<T> a, Sequence<T> b)

{

  return b < a;

}

template <typename T>

Sequence<T>  operator+ (const Sequence<T> l, const Sequence<T> r)

{

  return Sequence<T> (l.seq + r.seq);

}

template <typename T>

Sequence<T>  operator+ (const Sequence<T> l, const T r)

{

  return Sequence<T> (l.seq + r);

}

template <typename T>

Sequence<T>  operator- (const Sequence<T> l, const Sequence<T> r)

{

  return Sequence<T> (l.seq - r.seq);

}

template <typename T>

Sequence<T>  operator- (const Sequence<T> l, const T r)

{

  return Sequence<T> (l.seq - r);

}

typedef Sequence<uint32_t> sequence32_t;

typedef Sequence<uint16_t> sequence16_t;

typedef Sequence<uint8_t> sequence8_t;

#endif /* sequence_H_ */

        'sequence.cc',

        'sequence.h',