FM / 4.4.4

/usr/include/c++/4.4.4/

/usr/include/c++/4.4.4

Name	Size	Mode	Actions
backward/	-	0755	rm
bits/	-	0755	rm
debug/	-	0755	rm
ext/	-	0755	rm
parallel/	-	0755	rm
tr1/	-	0755	rm
tr1_impl/	-	0755	rm
x86_64-redhat-linux/	-	0755	rm
algorithm	2528	0644	edit dl rm
array	1861	0644	edit dl rm
bitset	38246	0644	edit dl rm
c++0x_warning.h	1441	0644	edit dl rm
cassert	1691	0644	edit dl rm
ccomplex	1425	0644	edit dl rm
cctype	2862	0644	edit dl rm
cerrno	1813	0644	edit dl rm
cfenv	1872	0644	edit dl rm
cfloat	2046	0644	edit dl rm
chrono	21125	0644	edit dl rm
cinttypes	2151	0644	edit dl rm
ciso646	1513	0644	edit dl rm
climits	1956	0644	edit dl rm
clocale	1996	0644	edit dl rm
cmath	15560	0644	edit dl rm
complex	42262	0644	edit dl rm
complex.h	1374	0644	edit dl rm
condition_variable	6208	0644	edit dl rm
csetjmp	2040	0644	edit dl rm
csignal	1946	0644	edit dl rm
cstdarg	1935	0644	edit dl rm
cstdatomic	24336	0644	edit dl rm
cstdbool	1412	0644	edit dl rm
cstddef	1830	0644	edit dl rm
cstdint	2374	0644	edit dl rm
cstdio	4812	0644	edit dl rm
cstdlib	5723	0644	edit dl rm
cstring	3261	0644	edit dl rm
ctgmath	1327	0644	edit dl rm
ctime	2211	0644	edit dl rm
cwchar	6538	0644	edit dl rm
cwctype	3294	0644	edit dl rm
cxxabi-forced.h	1631	0644	edit dl rm
cxxabi.h	19106	0644	edit dl rm
deque	2658	0644	edit dl rm
exception	4856	0644	edit dl rm
exception_defines.h	1648	0644	edit dl rm
exception_ptr.h	4355	0644	edit dl rm
fenv.h	1888	0644	edit dl rm
forward_list	1480	0644	edit dl rm
fstream	29267	0644	edit dl rm
functional	2658	0644	edit dl rm
initializer_list	1987	0644	edit dl rm
iomanip	8696	0644	edit dl rm
ios	1658	0644	edit dl rm
iosfwd	6017	0644	edit dl rm
iostream	2654	0644	edit dl rm
istream	28304	0644	edit dl rm
iterator	2639	0644	edit dl rm
limits	45520	0644	edit dl rm
list	2588	0644	edit dl rm
locale	1480	0644	edit dl rm
map	2479	0644	edit dl rm
memory	3356	0644	edit dl rm
mutex	18380	0644	edit dl rm
new	3735	0644	edit dl rm
numeric	2808	0644	edit dl rm
ostream	18442	0644	edit dl rm
queue	2507	0644	edit dl rm
random	2086	0644	edit dl rm
ratio	9176	0644	edit dl rm
regex	2002	0644	edit dl rm
set	2479	0644	edit dl rm
sstream	18876	0644	edit dl rm
stack	2431	0644	edit dl rm
stdatomic.h	7263	0644	edit dl rm
stdexcept	4247	0644	edit dl rm
streambuf	28107	0644	edit dl rm
string	2021	0644	edit dl rm
system_error	9434	0644	edit dl rm
tgmath.h	1368	0644	edit dl rm
thread	6562	0644	edit dl rm
tuple	21068	0644	edit dl rm
typeinfo	7170	0644	edit dl rm
type_traits	17152	0644	edit dl rm
unordered_map	2448	0644	edit dl rm
unordered_set	2448	0644	edit dl rm
utility	3320	0644	edit dl rm
valarray	36486	0644	edit dl rm
vector	2698	0644	edit dl rm

Edit: /usr/include/c++/4.4.4/chrono (21125B)

// <chrono> -*- C++ -*-

// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, 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 General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file include/chrono
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_CHRONO
#define _GLIBCXX_CHRONO 1

#pragma GCC system_header

#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#else

#ifdef _GLIBCXX_INCLUDE_AS_TR1
#  error C++0x header cannot be included from TR1 header
#endif

#include <ratio>
#include <type_traits>
#include <limits>
#include <ctime>

#ifdef _GLIBCXX_USE_C99_STDINT_TR1

namespace std 
{
  /**
   * @defgroup chrono Time
   * @ingroup utilities
   *
   * Classes and functions for time.
   * @{
   */

/** @namespace std::chrono
   *  @brief ISO C++ 0x entities sub namespace for time and date.
   */
  namespace chrono
  {
    template<typename _Rep, typename _Period = ratio<1>>
      struct duration;

template<typename _Clock, typename _Duration = typename _Clock::duration>
      struct time_point;
  }

// 20.8.2.3 specialization of common_type (for duration)
  template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
    struct common_type<chrono::duration<_Rep1, _Period1>,
                       chrono::duration<_Rep2, _Period2>>
    {
      typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
        ratio<__static_gcd<_Period1::num, _Period2::num>::value,
        (_Period1::den / __static_gcd<_Period1::den, _Period2::den>::value)
        * _Period2::den>> type;
    };
  
  // 20.8.2.3 specialization of common_type (for time_point)
  template<typename _Clock, typename _Duration1, typename _Duration2>
    struct common_type<chrono::time_point<_Clock, _Duration1>,
                       chrono::time_point<_Clock, _Duration2>>
    {
      typedef chrono::time_point<_Clock, 
        typename common_type<_Duration1, _Duration2>::type> type;
    };

namespace chrono 
  {
    // Primary template for duration_cast impl.
    template<typename _ToDuration, typename _CF, typename _CR,
             bool _NumIsOne = false, bool _DenIsOne = false>
      struct __duration_cast_impl
      {
        template<typename _Rep, typename _Period>
          static _ToDuration __cast(const duration<_Rep, _Period>& __d)
          {
            return _ToDuration(static_cast<
              typename _ToDuration::rep>(static_cast<_CR>(__d.count())
              * static_cast<_CR>(_CF::num)
              / static_cast<_CR>(_CF::den)));
          }
      };

template<typename _ToDuration, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDuration, _CF, _CR, true, true>
      {
        template<typename _Rep, typename _Period>
          static _ToDuration __cast(const duration<_Rep, _Period>& __d)
          {
            return _ToDuration(
              static_cast<typename _ToDuration::rep>(__d.count()));
          }
      };

template<typename _ToDuration, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDuration, _CF, _CR, true, false>
      {
        template<typename _Rep, typename _Period>
          static _ToDuration __cast(const duration<_Rep, _Period>& __d)
          {
            return _ToDuration(static_cast<typename _ToDuration::rep>(
              static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); 
          }
      };

template<typename _ToDuration, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDuration, _CF, _CR, false, true>
      {
        template<typename _Rep, typename _Period>
          static _ToDuration __cast(const duration<_Rep, _Period>& __d)
          {
            return _ToDuration(static_cast<typename _ToDuration::rep>(
              static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
          }
      };

/// duration_cast
    template<typename _ToDuration, typename _Rep, typename _Period>
      inline _ToDuration
      duration_cast(const duration<_Rep, _Period>& __d)
      {
        typedef typename
          ratio_divide<_Period, typename _ToDuration::period>::type __cf;
        typedef typename
          common_type<typename _ToDuration::rep, _Rep, intmax_t>::type __cr;

return __duration_cast_impl<_ToDuration, __cf, __cr,
          __cf::num == 1, __cf::den == 1>::__cast(__d);
      }

/// treat_as_floating_point
    template<typename _Rep>
      struct treat_as_floating_point 
      : is_floating_point<_Rep>
      { };

/// duration_values
    template<typename _Rep>
      struct duration_values
      {
        static const _Rep
        zero()
        { return _Rep(0); }
        
        static const _Rep
        max()
        { return numeric_limits<_Rep>::max(); }
        
        static const _Rep
        min()
        { return numeric_limits<_Rep>::min(); }
      };

template<typename _Tp>
      struct __is_duration
      : std::false_type
      { };

template<typename _Rep, typename _Period>
      struct __is_duration<duration<_Rep, _Period>>
      : std::true_type
      { };

template<typename T>
      struct __is_ratio
      : std::false_type
      { };

template<intmax_t _Num, intmax_t _Den>
      struct __is_ratio<ratio<_Num, _Den>>
      : std::true_type
      { };

/// duration
    template<typename _Rep, typename _Period>
      struct duration
      {
	static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
	static_assert(__is_ratio<_Period>::value, 
		      "period must be a specialization of ratio");
        static_assert(_Period::num > 0, "period must be positive");
        
        typedef _Rep    rep;
        typedef _Period period;
        
        // 20.8.3.1 construction / copy / destroy
	duration() = default;

template<typename _Rep2>
          explicit duration(_Rep2 const& __rep)
          : __r(static_cast<rep>(__rep))
          {
            static_assert(is_convertible<_Rep2,rep>::value 
			  && (treat_as_floating_point<rep>::value 
			      || !treat_as_floating_point<_Rep2>::value),
	      "cannot construct integral duration with floating point type");
          }

template<typename _Rep2, typename _Period2>
          duration(const duration<_Rep2, _Period2>& __d)
          : __r(duration_cast<duration>(__d).count())
          {
            static_assert(treat_as_floating_point<rep>::value == true 
              || ratio_divide<_Period2, period>::type::den == 1, 
              "the resulting duration is not exactly representable");
          }

~duration() = default;
	duration(const duration&) = default;
	duration& operator=(const duration&) = default;

// 20.8.3.2 observer
        rep
        count() const
        { return __r; }

// 20.8.3.3 arithmetic
        duration
        operator+() const 
        { return *this; }

duration
        operator-() const 
        { return duration(-__r); }

duration&
        operator++() 
        {
          ++__r;
          return *this;
        }

duration
        operator++(int) 
        { return duration(__r++); }

duration&
        operator--() 
        { 
          --__r;
          return *this;
        }

duration
        operator--(int) 
        { return duration(__r--); }
        
        duration&
        operator+=(const duration& __d)
        {
          __r += __d.count();
          return *this;
        }

duration&
        operator-=(const duration& __d)
        {
          __r -= __d.count();
          return *this;
        }

duration&
        operator*=(const rep& __rhs)
        {
          __r *= __rhs;
          return *this;
        }

duration&
        operator/=(const rep& __rhs)
        { 
          __r /= __rhs;
          return *this;
        }

// 20.8.3.4 special values
        // TODO: These should be constexprs.
        static const duration
        zero()
        { return duration(duration_values<rep>::zero()); }

static const duration
        min()
        { return duration(duration_values<rep>::min()); }
      
        static const duration
        max()
        { return duration(duration_values<rep>::max()); }
   
      private:    
        rep __r;
      };

template<typename _Rep1, typename _Period1,
             typename _Rep2, typename _Period2>
      inline typename common_type<duration<_Rep1, _Period1>, 
                                  duration<_Rep2, _Period2>>::type
      operator+(const duration<_Rep1, _Period1>& __lhs, 
                const duration<_Rep2, _Period2>& __rhs)
      {
        typedef typename common_type<duration<_Rep1, _Period1>, 
                                     duration<_Rep2, _Period2>>::type __ct;
        return __ct(__lhs) += __rhs;
      }

template<typename _Rep1, typename _Period1, 
             typename _Rep2, typename _Period2>
      inline typename common_type<duration<_Rep1, _Period1>, 
                                  duration<_Rep2, _Period2>>::type
      operator-(const duration<_Rep1, _Period1>& __lhs, 
                const duration<_Rep2, _Period2>& __rhs)
      {
        typedef typename common_type<duration<_Rep1, _Period1>,
                                     duration<_Rep2, _Period2>>::type __ct;
        return __ct(__lhs) -= __rhs;
      }

template<typename _Rep1, typename _Period, typename _Rep2>
      inline duration<typename common_type<_Rep1, _Rep2>::type, _Period>
      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
      {
        typedef typename common_type<_Rep1, _Rep2>::type __cr;
        return duration<__cr, _Period>(__d) *= __s;
      }

template<typename _Rep1, typename _Period, typename _Rep2>
      inline duration<typename common_type<_Rep1, _Rep2>::type, _Period>
      operator*(const _Rep2& __s, const duration<_Rep1, _Period>& __d)
      { return __d * __s; }

template<typename _Tp, typename _Up, typename _Ep = void>
      struct __division_impl;
  
    template<typename _Rep1, typename _Period, typename _Rep2>
      struct __division_impl<duration<_Rep1, _Period>, _Rep2, 
        typename enable_if<!__is_duration<_Rep2>::value>::type>
      {
        typedef typename common_type<_Rep1, _Rep2>::type __cr;
        typedef 
          duration<typename common_type<_Rep1, _Rep2>::type, _Period> __rt;

static __rt
        __divide(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
        { return duration<__cr, _Period>(__d) /= __s; }
      };

template<typename _Rep1, typename _Period1, 
             typename _Rep2, typename _Period2>
      struct __division_impl<duration<_Rep1, _Period1>, 
                             duration<_Rep2, _Period2>>
      {
        typedef typename common_type<duration<_Rep1, _Period1>, 
                                     duration<_Rep2, _Period2>>::type __ct;
        typedef typename common_type<_Rep1, _Rep2>::type __rt;

static __rt
        __divide(const duration<_Rep1, _Period1>& __lhs, 
                 const duration<_Rep2, _Period2>& __rhs)
        { return __ct(__lhs).count() / __ct(__rhs).count(); }
      };
  
    template<typename _Rep, typename _Period, typename _Up>
      inline typename __division_impl<duration<_Rep, _Period>, _Up>::__rt
      operator/(const duration<_Rep, _Period>& __d, const _Up& __u)
      {
        return 
          __division_impl<duration<_Rep, _Period>, _Up>::__divide(__d, __u);
      }
 
    // comparisons
    template<typename _Rep1, typename _Period1,
             typename _Rep2, typename _Period2>
      inline bool
      operator==(const duration<_Rep1, _Period1>& __lhs, 
                 const duration<_Rep2, _Period2>& __rhs)
      {
        typedef typename common_type<duration<_Rep1, _Period1>, 
                                     duration<_Rep2, _Period2>>::type __ct;
        return __ct(__lhs).count() == __ct(__rhs).count();
      }

template<typename _Rep1, typename _Period1,
             typename _Rep2, typename _Period2>
      inline bool
      operator<(const duration<_Rep1, _Period1>& __lhs, 
                const duration<_Rep2, _Period2>& __rhs)
      {
        typedef typename common_type<duration<_Rep1, _Period1>, 
                                     duration<_Rep2, _Period2>>::type __ct;
        return __ct(__lhs).count() < __ct(__rhs).count();
      }

template<typename _Rep1, typename _Period1,
             typename _Rep2, typename _Period2>
      inline bool
      operator!=(const duration<_Rep1, _Period1>& __lhs, 
                 const duration<_Rep2, _Period2>& __rhs)
      { return !(__lhs == __rhs); }

template<typename _Rep1, typename _Period1,
             typename _Rep2, typename _Period2>
      inline bool
      operator<=(const duration<_Rep1, _Period1>& __lhs, 
                 const duration<_Rep2, _Period2>& __rhs)
      { return !(__rhs < __lhs); }

template<typename _Rep1, typename _Period1,
             typename _Rep2, typename _Period2>
      inline bool 
      operator>(const duration<_Rep1, _Period1>& __lhs, 
                const duration<_Rep2, _Period2>& __rhs)
      { return __rhs < __lhs; }

template<typename _Rep1, typename _Period1, 
             typename _Rep2, typename _Period2>
      inline bool
      operator>=(const duration<_Rep1, _Period1>& __lhs, 
                 const duration<_Rep2, _Period2>& __rhs)
      { return !(__lhs < __rhs); }

/// nanoseconds
    typedef duration<int64_t,        nano> nanoseconds;

/// microseconds
    typedef duration<int64_t,       micro> microseconds;

/// milliseconds
    typedef duration<int64_t,       milli> milliseconds;
    
    /// seconds
    typedef duration<int64_t             > seconds;

/// minutes
    typedef duration<int,     ratio<  60>> minutes;

/// hours
    typedef duration<int,     ratio<3600>> hours;

/// time_point
    template<typename _Clock, typename _Duration>
      struct time_point
      {
	typedef _Clock                    clock;
	typedef _Duration                 duration;
	typedef typename duration::rep    rep;
	typedef typename duration::period period;

time_point() : __d(duration::zero())
	{ }

explicit time_point(const duration& __dur) 
	: __d(duration::zero() + __dur)
	{ }

// conversions
	template<typename _Duration2>
	  time_point(const time_point<clock, _Duration2>& __t)
	  : __d(__t.time_since_epoch())
	  { }

// observer
	duration
	time_since_epoch() const
	{ return __d; }
	
	// arithmetic
	time_point&
	operator+=(const duration& __dur)
	{
	  __d += __dur;
	  return *this;
	}
	
	time_point&
	operator-=(const duration& __dur)
	{
	  __d -= __dur;
	  return *this;
	}
	
	// special values
	// TODO: These should be constexprs.
	static const time_point
	min()
	{ return time_point(duration::min()); }
	
	static const time_point
	max()
	{ return time_point(duration::max()); }
	
      private:
	duration __d;
      };
  
    /// time_point_cast
    template<typename _ToDuration, typename _Clock, typename _Duration>
      inline time_point<_Clock, _ToDuration> 
      time_point_cast(const time_point<_Clock, _Duration>& __t)
      {
        return time_point<_Clock, _ToDuration>(
          duration_cast<_ToDuration>(__t.time_since_epoch()));  
      }

template<typename _Clock, typename _Duration1,
             typename _Rep2, typename _Period2>
      inline time_point<_Clock, 
        typename common_type<_Duration1, duration<_Rep2, _Period2>>::type>
      operator+(const time_point<_Clock, _Duration1>& __lhs, 
                const duration<_Rep2, _Period2>& __rhs)
      {
        typedef time_point<_Clock, 
          typename common_type<_Duration1, 
                               duration<_Rep2, _Period2>>::type> __ct;
        return __ct(__lhs) += __rhs;
      }

template<typename _Rep1, typename _Period1,
             typename _Clock, typename _Duration2>
      inline time_point<_Clock, 
        typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
      operator+(const duration<_Rep1, _Period1>& __lhs, 
                const time_point<_Clock, _Duration2>& __rhs)
      { return __rhs + __lhs; }

template<typename _Clock, typename _Duration1, typename _Duration2>
      inline typename common_type<_Duration1, _Duration2>::type
      operator-(const time_point<_Clock, _Duration1>& __lhs, 
                const time_point<_Clock, _Duration2>& __rhs)
      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }

template<typename _Clock, typename _Duration1, typename _Duration2>
      inline bool
      operator==(const time_point<_Clock, _Duration1>& __lhs,
                 const time_point<_Clock, _Duration2>& __rhs)
      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }

template<typename _Clock, typename _Duration1, typename _Duration2>
      inline bool
      operator!=(const time_point<_Clock, _Duration1>& __lhs,
                 const time_point<_Clock, _Duration2>& __rhs)
      { return !(__lhs == __rhs); }

template<typename _Clock, typename _Duration1, typename _Duration2>
      inline bool
      operator<(const time_point<_Clock, _Duration1>& __lhs,
                const time_point<_Clock, _Duration2>& __rhs)
      { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }

template<typename _Clock, typename _Duration1, typename _Duration2>
      inline bool
      operator<=(const time_point<_Clock, _Duration1>& __lhs,
                 const time_point<_Clock, _Duration2>& __rhs)
      { return !(__rhs < __lhs); }

template<typename _Clock, typename _Duration1, typename _Duration2>
      inline bool
      operator>(const time_point<_Clock, _Duration1>& __lhs,
                const time_point<_Clock, _Duration2>& __rhs)
      { return __rhs < __lhs; }

template<typename _Clock, typename _Duration1, typename _Duration2>
      inline bool
      operator>=(const time_point<_Clock, _Duration1>& __lhs,
                 const time_point<_Clock, _Duration2>& __rhs)
      { return !(__lhs < __rhs); }

/// system_clock
    struct system_clock
    {
#ifdef _GLIBCXX_USE_CLOCK_REALTIME
      typedef chrono::nanoseconds     duration;      
#elif defined(_GLIBCXX_USE_GETTIMEOFDAY)
      typedef chrono::microseconds    duration;      
#else
      typedef chrono::seconds         duration;      
#endif

typedef duration::rep    rep;
      typedef duration::period period;
      typedef chrono::time_point<system_clock, duration> time_point;

static const bool is_monotonic = false;

static time_point
      now();

// Map to C API
      static std::time_t
      to_time_t(const time_point& __t)
      {
        return std::time_t(
          duration_cast<chrono::seconds>(__t.time_since_epoch()).count());
      }

static time_point
      from_time_t(std::time_t __t)
      { 
        return time_point_cast<system_clock::duration>(
          chrono::time_point<system_clock, chrono::seconds>(
            chrono::seconds(__t)));
      }

// TODO: requires constexpr
      /*  
      static_assert(
        system_clock::duration::min() < 
        system_clock::duration::zero(), 
        "a clock's minimum duration cannot be less than its epoch");
      */
    };

#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
    /// monotonic_clock
    struct monotonic_clock
    {
      typedef chrono::nanoseconds duration;
      typedef duration::rep       rep;
      typedef duration::period    period;
      typedef chrono::time_point<monotonic_clock, duration> time_point;

static const bool is_monotonic = true;

static time_point
      now();
    };
#else
    typedef system_clock monotonic_clock;
#endif

typedef system_clock high_resolution_clock;
  } // namespace chrono

// @} group chrono
} // namespace std

#endif //_GLIBCXX_USE_C99_STDINT_TR1

#endif //__GXX_EXPERIMENTAL_CXX0X__

#endif //_GLIBCXX_CHRONO

cmd: