detime.h

Go to the documentation of this file.

/*
  $Id: detime.h,v 1.3 2004/12/12 23:44:44 pecos Exp $
*/

/* *********
*  
*  This file is part of:
*  NePSing, Network Protocol Simulator next generation
*  
*  Copyright (C) 2004  Tommaso Pecorella <tpecorella@mac.com>
*  
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*  
*  This library 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
*  Lesser General Public License for more details.
*  
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*  
********* */

#ifndef ___DETIME_H___
#define ___DETIME_H___

#include <iostream>
#include <iomanip>
#include <string>
#include <math.h>

#include "parameter.h"

#define ULL_MAX  ~0ULL

#define PRINT_ABS_TIME          1
#define PRINT_ABS_SUPERSTEP     2
#define PRINT_ABS_BIGSTEP       4
#define PRINT_ABS_STEP          8
#define PRINT_REL_BIGSTEP      16
#define PRINT_REL_STEP         32
#define PRINT_OFFSET           64
#define PRINT_PARENTHESIS     128

typedef unsigned long long int time_int;


class DETime
{
protected:

  //  The number of ticks. Each tick represent a fraction of a second, depending on TimeResolution.
  time_int tick;

  //  overflow flag, set if the time is above the maximum representable time.
  bool overflow;

  //  Describes how to print this time.
  /*
   \internal 
   PrintMask: bitmask representing the printing format of timestamps.
   
   PRINT_ABS_TIME               1 : Absolute time
   PRINT_ABS_SUPERSTEP          2 : Absolute SuperStep
   PRINT_ABS_BIGSTEP            4 : Absolute BigStep
   PRINT_ABS_STEP               8 : Absolute Step
   PRINT_REL_BIGSTEP           16 : BigStep position in SuperStep
   PRINT_REL_STEP              32 : Step position in BigStep
   PRINT_OFFSET                64 : Offset
   PRINT_PARENTHESIS          128 : Encloses in parenthesis
   */
  int PrintMask;

  //   The Time Resolution; es: -3 == milliseconds (\f$10^{-3}\f$ seconds).
  static int TickSize;

  //   The size of the step, expressed in ticks.
  static time_int TicksPerStep;

  //  Number of Ticks in each BigStep.
  static time_int TicksPerBigStep;

  //  Number of Ticks in each SuperStep.
  static time_int TicksPerSuperStep;

  //  Number of Steps in each BigStep.
  static time_int StepsPerBigStep;

  //  Number of BigSteps in each SuperStep.
  static time_int BigStepsPerSuperStep;

  //  The default value assigned to printmask.
  static int DefaultPrintMask;

  //  Prints the time represented to \c os.
  virtual void print(ostream &os) const;

public:

  //  Main setup function. Used once at the simulation begin, it MUST be never called after.
  static void setup(int _TimeResolution,
             time_int _TicksPerStep,
         time_int _StepsPerBigStep,
         time_int _BigStepsPerSuperStep,
         int _DefaultPrintMask = DefaultPrintMask);

  //  constructor used to set up the \c overflow bit too. Do NOT use outside detime.cpp.
  DETime(time_int _tick,
         bool _overflow,
         int _PrintMask = PRINT_ABS_TIME);

  DETime();

  DETime(string A);

  DETime(time_int _tick,
         int _PrintMask = DefaultPrintMask);

  DETime(const DETime& A);

  DETime( time_int _step,
          time_int _bigStep,
          time_int _superStep );

  DETime( double A, int _PrintMask = DefaultPrintMask);
  
  time_int Tick() const { return tick; };
  time_int Step() const { return tick / TicksPerStep; };
  time_int BigStep() const { return tick / TicksPerBigStep; };
  time_int SuperStep() const { return tick / TicksPerSuperStep; };

  time_int RelativeTick()  const { return tick % TicksPerStep; };
  time_int RelativeStep()  const { return (tick % TicksPerBigStep)/TicksPerStep; };
  time_int RelativeBigStep() const { return (tick % TicksPerSuperStep)/TicksPerBigStep; };

  DETime operator = (const DETime& A);

  DETime operator + (const DETime& A) const;
  DETime operator + (const time_int A) const;
  DETime operator + (const double A) const { return (*this) + DETime(A); };
  
  DETime operator += (const DETime& A);
  DETime operator += (const time_int A);
  
  DETime operator - (const DETime& A) const;
  DETime operator - (const time_int A) const;

  // Other operators
  // WARNING: necessary to test overflow on *
  //          the test assumes unsigned long long has 64 bits
  
  DETime operator * (const time_int A) const;
  DETime operator * (const double A) const;

  DETime operator / (const time_int A) const { return(DETime( tick/A, false, PrintMask ) ); };
  const time_int operator / (const DETime &A) const { return tick/A.tick; };
  
  time_int operator % (const time_int A) const { return( tick % A ); };

  bool operator < (const DETime& A) const   { return (tick < A.tick); };
  bool operator > (const DETime& A) const   { return (tick > A.tick); };
  bool operator <= (const DETime& A) const  { return (tick <= A.tick); };
  bool operator >= (const DETime& A) const  { return (tick >= A.tick); };
  bool operator == (const DETime& A) const  { return (tick == A.tick); };
  bool operator != (const DETime& A) const  { return (tick != A.tick); };

  // returns the time representing the end of the Step
  //
  // Not needed, same as NextStep()
  // DETime EndOfStep();

/***************************************************************
*                                                              *
*     Some funtions are overloaded to allow efficient coding   *
*                                                              *
***************************************************************/

  DETime AddStep() const;   
  DETime AddStep(time_int S) const;

  DETime AddBigStep() const;
  DETime AddBigStep(time_int BS) const;

  DETime AddSuperStep() const;
  DETime AddSuperStep(time_int SS) const;

  DETime NextStep() const;
  DETime NextStep(time_int S) const;

  DETime NextBigStep() const;
  DETime NextBigStep(time_int BS) const;

  DETime NextSuperStep() const;
  DETime NextSuperStep(time_int SS) const;

  DETime NextIndexedStep(time_int S) const;

  //DETime NextIndexedStep(int S, int BS) const;

  DETime NextIndexedBigStep(time_int BS) const;

  DETime BeginOfTheNextUsefulStep(void) const;

  DETime ToNextStep() const;
  DETime ToNextStep(time_int S) const;

  DETime ToNextBigStep() const;
  DETime ToNextBigStep(time_int S) const;

  DETime ToNextSuperStep() const;
  DETime ToNextSuperStep(time_int S) const;

  DETime ToNextIndexedStep(time_int S) const;

  DETime ToNextIndexedBigStep(time_int BS) const;

  DETime ToBeginOfTheNextUsefulStep(void) const;

  bool HasOffsetZero() const;

  bool IsInOverFlow() const;

  friend ostream& operator<< ( ostream& os, const DETime& t );

  operator double() { return double(tick) * pow(10.0, TickSize); };

};


// Misc inline operators to override dangerous operations leading to wrong results due to automatic type conversions.
inline DETime operator + (const time_int A, const DETime B) { return B+A; };
inline DETime operator + (const double A, const DETime B) { return DETime(A)+B; };
inline DETime operator - (const time_int A, const DETime B) { return DETime(A) - B; };
inline DETime operator - (const double A, const DETime B) { return DETime(A) - B; };
inline DETime operator * (const time_int A, const DETime B) { return B*A; };
inline DETime operator * (const double A, const DETime B) { return B*A; };


//



class DETimeParameter : public GenericParameter
{
 public:
  DETimeParameter(string aName, string aComment, string aDefault, string aValues)
    : GenericParameter(aName, aComment, aDefault, aValues)
  {};

  DETime get(string aClass, string aInstance)
  {
    return DETime(getValue(aClass, aInstance));
  };
};


#endif

/*
$Log: detime.h,v $
Revision 1.3  2004/12/12 23:44:44  pecos
Added Copyright message - LGPL

Revision 1.2  2004/12/11 23:53:25  pecos
Added DoxyGen comments

Revision 1.1.1.1  2004/07/08 16:59:33  pecos
NePSing framework

Revision 1.4  2002/02/13 09:59:40  pecos
*** empty log message ***

Revision 1.3  2002/02/04 12:33:17  pecos
Updated operators

Revision 1.2  2001/03/16 20:22:50  pecos
various bugs in ToNextXXX(int)

new functions added:
DETime ToNextBigStep() const;
DETime ToNextBigStep(time_int S) const;
DETime ToNextSuperStep() const;
DETime ToNextSuperStep(time_int S) const;
DETime ToNextIndexedBigStep(time_int BS) const;

Revision 1.1.1.1  1999/05/24 15:59:57  inesis
INeSiS Project

Revision 1.1.1.1  1999/05/24 15:17:20  inesis
INeSiS Project

Revision 1.3  1999/02/05 11:57:20  pecos
*** empty log message ***

Revision 1.2  1999/01/26 11:24:23  pecos
*** empty log message ***

Revision 1.1  1999/01/02 09:09:22  nanni
*** empty log message ***

*/

---