time.h

Go to the documentation of this file.

//    sampalib.org ESL library and tools
//    Copyright (C) 2007  Thierry Grellier
//
//    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.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//    contact: www.sampalib.org

#ifndef SAMPA_TIME_H
#define SAMPA_TIME_H

#include <sampa/core/persistence.h>

namespace Sampa {

struct SAMPA_PERSISTENT_CLASS(Time) {
public:
  enum Unit {  
    FS,   
    PS,   
    NS,   
    US,   
    MS,   
    SEC   
  };

  // constructors
  Time( DefaultCtrTag );
  Time( double, Unit );
  Time( double, bool scale );
  Time( unsigned long long, bool scale );
  Time( const Time& );

  // assignment operator
  Time& operator = ( const Time& );

  // conversion functions
  unsigned long long value() const;     
  double to_double() const;             
  unsigned long long to_default_time_unit() const;
 
  const std::string to_string() const;

  // relational operators
  bool operator == ( const Time& ) const;
  bool operator != ( const Time& ) const;
  bool operator <  ( const Time& ) const;
  bool operator <= ( const Time& ) const;
  bool operator >  ( const Time& ) const;
  bool operator >= ( const Time& ) const;

  // arithmetic operators
  Time& operator += ( const Time& );
  Time& operator -= ( const Time& );
  friend const Time operator + ( const Time&, const Time& );
  friend const Time operator - ( const Time&, const Time& );
  Time& operator *= ( double );
  Time& operator /= ( double );
  friend const Time operator * ( const Time&, double );
  friend const Time operator * ( double, const Time& );
  friend const Time operator / ( const Time&, double );
  friend double   operator / ( const Time&, const Time& );

  struct SAMPA_PERSISTENT_CLASS(Params) {
    unsigned long long m_default_time_unit; // in time resolution
    double             m_time_resolution; // in femto seconds
    bool               m_time_resolution_specified;
    bool               m_time_resolution_fixed;
    bool               m_default_time_unit_specified;
    Params(int);
    ~Params();
    SAMPA_PERSISTENT(Params);  
  };

  static Time ZERO;  
  static void set_params(Params*);
private:
  static Params*     M_params;
  unsigned long long m_value;
public:
  SAMPA_PERSISTENT(Time);
};

extern void set_time_resolution( double, Time::Unit );
extern Time get_time_resolution();

extern void set_default_time_unit( double, Time::Unit );
extern Time get_default_time_unit();

inline
Time::Time( DefaultCtrTag )
: m_value( 0 )
{}

inline
Time::Time( const Time& t )
: m_value( t.m_value )
{}

// assignment operator

inline
Time&
Time::operator = ( const Time& t )
{
  m_value = t.m_value;
  return *this;
}


// conversion functions

inline
unsigned long long 
Time::value() const  // relative to the time resolution
{
  return m_value;
}

inline
double
Time::to_double() const  // relative to the time resolution
{
  return m_value;
}

inline
unsigned long long
Time::to_default_time_unit() const
{
  return (  m_value / M_params->m_default_time_unit );
}

// relational operators

inline
bool
Time::operator == ( const Time& t ) const
{
  return ( m_value == t.m_value );
}

inline
bool
Time::operator != ( const Time& t ) const
{
  return ( m_value != t.m_value );
}

inline
bool
Time::operator < ( const Time& t ) const
{
  return ( m_value < t.m_value );
}

inline
bool
Time::operator <= ( const Time& t ) const
{
  return ( m_value <= t.m_value );
}

inline
bool
Time::operator > ( const Time& t ) const
{
  return ( m_value > t.m_value );
}

inline
bool
Time::operator >= ( const Time& t ) const
{
  return ( m_value >= t.m_value );
}


// arithmetic operators
inline
Time&
Time::operator += ( const Time& t )
{
  m_value += t.m_value;
  return *this;
}

inline
Time&
Time::operator -= ( const Time& t )
{
  m_value -= t.m_value;
  return *this;
}


inline
const Time
operator + ( const Time& t1, const Time& t2 )
{
  return Time( t1 ) += t2;
}

inline
const Time
operator - ( const Time& t1, const Time& t2 )
{
  return Time( t1 ) -= t2;
}

inline
Time&
Time::operator *= ( double d )
{
  // linux bug workaround; don't change next two lines
  volatile double tmp = d * double(m_value) + 0.5;
  m_value = static_cast<unsigned long long>(tmp);
  return *this;
}

inline
Time&
Time::operator /= ( double d )
{
  // linux bug workaround; don't change next two lines
  volatile double tmp = double(m_value) / d + 0.5;
  m_value = static_cast<unsigned long long>(tmp);
  return *this;
}

inline
const Time
operator * ( const Time& t, double d )
{
  Time tmp( t );
  return tmp *= d;
}

inline
const Time
operator * ( double d, const Time& t )
{
  Time tmp( t );
  return tmp *= d;
}

inline
const Time
operator / ( const Time& t, double d )
{
  Time tmp( t );
  return tmp /= d;
}

inline
double
operator / ( const Time& t1, const Time& t2 )
{
  return ( t1.to_double() / t2.to_double() );
}

} // namespace Sampa

#endif

---