time.h

//***************************************************************************
//
// file : bmptk/core/time.h
//
// LICENSE (MIT expat license, copy of bmptk/license.txt)
//
// Copyright (c) 2013 Wouter van Ooijen (wouter@voti.nl)
// 
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE..
//
//***************************************************************************


namespace bmptk {

//
class time {

   // the time expressed as 64-bit signed integer
   long long int t;
   
   // convert an integer to a time
   constexpr time( long long int n ): t( n ){}
   
   // current_time() must be able to convert an integer to a time
   friend bmptk::time bmptk::current_time();
public:

   time(){}

   #ifndef DOXYDOC
   // to be used only by const us, hence not documented
   // return the time value for one microsecond
   static constexpr time us(){ return time( BMPTK_TICKS_PER_US ); }
   #endif
   
   constexpr time operator+( const time &rhs ) const {
      return time( t + rhs.t );
   }
   
   void operator+=( const time &rhs ){
      t += rhs.t;
   }
   
   constexpr time operator-( const time &rhs ) const {
      return time( t - rhs.t );
   }
   
   void operator-=( const time &rhs ){
      t -= rhs.t;
   }
   
   constexpr time operator*( const int n ) const {
      return time( t * n );
   }
   
   void operator*=( const int n ){
      t *= n;
   }
   
   constexpr time operator/( const int n ) const {
      return time( t / n );
   }
   
   void operator/=( const int n ){
      t /= n;
   }
   
   constexpr unsigned long long int operator/( const time rhs ) const {
      return t / rhs.t;
   }
   
   constexpr bool operator<( const time rhs ) const {
      return t < rhs.t;
   }
   
   constexpr bool operator<=( const time rhs ) const {
      return t <= rhs.t;
   }
   
   constexpr bool operator>( const time rhs ) const {
      return t > rhs.t;
   }
   
   constexpr bool operator>=( const time rhs ) const {
      return t >= rhs.t;
   }
   
   constexpr bool operator==( const time rhs ) const {
      return t == rhs.t;
   }

   constexpr bool operator!=( const time rhs ) const {
      return t != rhs.t;
   }
};

inline constexpr time operator*( long long int n, const time rhs ){
   return rhs * n;
}


//
constexpr time us( time::us() );

//
constexpr time ms( us * 1000 );

//
constexpr time s( us * 1000 * 1000 );


time current_time();
      
//
void wait_busy_until( time t );      

//
void wait_until( time t );      

//
void wait_busy( time t );      
  
//
void wait( time t );      


}; // namespace bmptk;