itk::TimeStamp Class Reference
[ITK System Objects]

Generate a unique, increasing time value. More...

#include <itkTimeStamp.h>

Collaboration diagram for itk::TimeStamp:

[legend]

List of all members.

Public Types
typedef TimeStamp	Self
Public Member Functions
	TimeStamp ()
void	Delete ()
void	Modified ()
unsigned long	GetMTime () const
bool	operator> (TimeStamp &ts)
bool	operator< (TimeStamp &ts)
	operator unsigned long () const
Static Public Member Functions
static Self *	New ()
static const char *	GetNameOfClass ()
Private Attributes
unsigned long	m_ModifiedTime

---

Detailed Description

Generate a unique, increasing time value.

TimeStamp records a unique time when the method Modified() is executed. This time is guaranteed to be monotonically increasing. Classes use this object to record modified and/or execution time. There is built in support for the binary < and > comparison operators between two TimeStamp objects.

Warning:

On most platforms, this class uses a lock-free incremental counter. The Modified function can safely be called simultaneously by multiple threads on different instances of the class. However, calling the Modified function by different threads on the same instance of the class can lead to some unexpected behavior. The global counter will always be correct but the local m_ModifiedTime might not (see http://www.itk.org/mailman/private/insight-developers/2009-February/011732.html for more detail).

Definition at line 49 of file itkTimeStamp.h.

---

Member Typedef Documentation

typedef TimeStamp itk::TimeStamp::Self

Standard class typedefs.

Definition at line 53 of file itkTimeStamp.h.

---

Constructor & Destructor Documentation

itk::TimeStamp::TimeStamp

(

)

[inline]

Constructor must remain public because classes instantiate TimeStamps implicitly in their construction.

Definition at line 61 of file itkTimeStamp.h.

    {m_ModifiedTime = 0;}

---

Member Function Documentation

TimeStamp * itk::TimeStamp::New

(

void

)

[static]

Create an instance of this class. We don't want to use reference counting.

Instance creation.

Definition at line 57 of file itkTimeStamp.cxx.

{
  return new Self;
}

void itk::TimeStamp::Delete

(

)

[inline]

Destoy this instance.

Definition at line 65 of file itkTimeStamp.h.

    {delete this;}

static const char* itk::TimeStamp::GetNameOfClass

(

)

[inline, static]

The class name as a string.

Definition at line 69 of file itkTimeStamp.h.

    {return "TimeStamp";}

void itk::TimeStamp::Modified

(

void

)

Set this objects time to the current time. The current time is just a monotonically increasing unsigned long integer. It is possible for this number to wrap around back to zero. This should only happen for processes that have been running for a very long time, while constantly changing objects within the program. When this does occur, the typical consequence should be that some filters will update themselves when really they don't need to.

Make sure the new time stamp is greater than all others so far.

Initialize static member

Used for mutex locking

Definition at line 68 of file itkTimeStamp.cxx.

References itk::SimpleFastMutexLock::Lock(), and itk::SimpleFastMutexLock::Unlock().

Referenced by otb::Function::StandardRenderingFunction< TPixel, TRGBPixel, TPixelRepresentationFunction, TTransferFunction >::Initialize(), itk::Object::Modified(), and itk::MatrixOffsetTransformBase< TScalarType, 3, 3 >::SetMatrix().

{
  // Windows optimization
#if defined(WIN32) || defined(_WIN32)
  static LONG itkTimeStampTime = 0;
  m_ModifiedTime = (unsigned long)InterlockedIncrement(&itkTimeStampTime);

  // Mac optimization
#elif defined(__APPLE__) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
 #if __LP64__
  // "m_ModifiedTime" is "unsigned long", a type that changess sizes
  // depending on architecture.  The atomic increment is safe, since it
  // operates on a variable of the exact type needed.  The cast does not
  // change the size, but does change signedness, which is not ideal.
  static volatile int64_t itkTimeStampTime = 0;
  m_ModifiedTime = (unsigned long)OSAtomicIncrement64Barrier(&itkTimeStampTime);
 #else
  static volatile int32_t itkTimeStampTime = 0;
  m_ModifiedTime = (unsigned long)OSAtomicIncrement32Barrier(&itkTimeStampTime);
 #endif

// gcc optimization
#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
  // We start from 1 since __exchange_and_add returns the old (non-incremented)
  // value. This is not really necessary but will make the absolute value of the
  // timestamp more consistent across platforms. 
  static volatile _Atomic_word itkTimeStampTime = 1;
  m_ModifiedTime = (unsigned long)__exchange_and_add(&itkTimeStampTime, 1);

// General case
#else

  static unsigned long itkTimeStampTime = 0;

  static SimpleFastMutexLock TimeStampMutex;
  
  TimeStampMutex.Lock();
  m_ModifiedTime = ++itkTimeStampTime;
  TimeStampMutex.Unlock();
#endif


}

unsigned long itk::TimeStamp::GetMTime

(

void

)

const [inline]

Return this object's Modified time.

Definition at line 82 of file itkTimeStamp.h.

Referenced by itk::Object::GetMTime().

    {return m_ModifiedTime;}

bool itk::TimeStamp::operator>

(

TimeStamp &

ts

)

[inline]

Support comparisons of time stamp objects directly.

Definition at line 86 of file itkTimeStamp.h.

References m_ModifiedTime.

    {return (m_ModifiedTime > ts.m_ModifiedTime);}

itk::TimeStamp::operator unsigned long

(

)

const [inline]

Allow for typcasting to unsigned long.

Definition at line 92 of file itkTimeStamp.h.

    {return m_ModifiedTime;}

---

The documentation for this class was generated from the following files:

• itkTimeStamp.h
• itkTimeStamp.cxx