strip is_ prefixes on clock_info fields

5 files changed, 55 insertions, 55 deletions

diff --git a/Doc/library/time.rst b/Doc/library/time.rst
index 55285d1..0e1c6fb 100644
--- a/Doc/library/time.rst
+++ b/Doc/library/time.rst
@@ -168,11 +168,11 @@ The module defines the following functions and data items:
 
       The name of the underlying C function used to get the clock value.
 
-   .. attribute::  is_monotonic
+   .. attribute::  monotonic
 
       ``True`` if the clock cannot go backward, ``False`` otherwise.
 
-   .. attribute:: is_adjusted
+   .. attribute:: adjusted
 
       ``True`` if the clock can be adjusted (e.g. by a NTP daemon), ``False``
       otherwise.
diff --git a/Include/pytime.h b/Include/pytime.h
index a0cedb2..7442c6f 100644
--- a/Include/pytime.h
+++ b/Include/pytime.h
@@ -25,8 +25,8 @@ typedef struct {
 /* Structure used by time.get_clock_info() */
 typedef struct {
     const char *implementation;
-    int is_monotonic;
-    int is_adjusted;
+    int monotonic;
+    int adjusted;
     double resolution;
 } _Py_clock_info_t;
 
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
index 06047cf..aff5c82 100644
--- a/Lib/test/test_time.py
+++ b/Lib/test/test_time.py
@@ -30,16 +30,16 @@ class TimeTestCase(unittest.TestCase):
     def test_time(self):
         time.time()
         info = time.get_clock_info('time')
-        self.assertEqual(info.is_monotonic, False)
+        self.assertEqual(info.monotonic, False)
         if sys.platform != 'win32':
-            self.assertEqual(info.is_adjusted, True)
+            self.assertEqual(info.adjusted, True)
 
     def test_clock(self):
         time.clock()
 
         info = time.get_clock_info('clock')
-        self.assertEqual(info.is_monotonic, True)
-        self.assertEqual(info.is_adjusted, False)
+        self.assertEqual(info.monotonic, True)
+        self.assertEqual(info.adjusted, False)
 
     @unittest.skipUnless(hasattr(time, 'clock_gettime'),
                          'need time.clock_gettime()')
@@ -370,11 +370,11 @@ class TimeTestCase(unittest.TestCase):
         self.assertAlmostEqual(dt, 0.1, delta=0.2)
 
         info = time.get_clock_info('monotonic')
-        self.assertEqual(info.is_monotonic, True)
+        self.assertEqual(info.monotonic, True)
         if sys.platform == 'linux':
-            self.assertEqual(info.is_adjusted, True)
+            self.assertEqual(info.adjusted, True)
         else:
-            self.assertEqual(info.is_adjusted, False)
+            self.assertEqual(info.adjusted, False)
 
     def test_perf_counter(self):
         time.perf_counter()
@@ -386,8 +386,8 @@ class TimeTestCase(unittest.TestCase):
         self.assertLess(stop - start, 0.01)
 
         info = time.get_clock_info('process_time')
-        self.assertEqual(info.is_monotonic, True)
-        self.assertEqual(info.is_adjusted, False)
+        self.assertEqual(info.monotonic, True)
+        self.assertEqual(info.adjusted, False)
 
     @unittest.skipUnless(hasattr(time, 'monotonic'),
                          'need time.monotonic')
@@ -433,12 +433,12 @@ class TimeTestCase(unittest.TestCase):
             #self.assertIsInstance(info, dict)
             self.assertIsInstance(info.implementation, str)
             self.assertNotEqual(info.implementation, '')
-            self.assertIsInstance(info.is_monotonic, bool)
+            self.assertIsInstance(info.monotonic, bool)
             self.assertIsInstance(info.resolution, float)
             # 0.0 < resolution <= 1.0
             self.assertGreater(info.resolution, 0.0)
             self.assertLessEqual(info.resolution, 1.0)
-            self.assertIsInstance(info.is_adjusted, bool)
+            self.assertIsInstance(info.adjusted, bool)
 
         self.assertRaises(ValueError, time.get_clock_info, 'xxx')
 
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
index 1e843b9..5961ac9 100644
--- a/Modules/timemodule.c
+++ b/Modules/timemodule.c
@@ -95,8 +95,8 @@ floatclock(_Py_clock_info_t *info)
     if (info) {
         info->implementation = "clock()";
         info->resolution = 1.0 / (double)CLOCKS_PER_SEC;
-        info->is_monotonic = 1;
-        info->is_adjusted = 0;
+        info->monotonic = 1;
+        info->adjusted = 0;
     }
     return PyFloat_FromDouble((double)value / CLOCKS_PER_SEC);
 }
@@ -131,8 +131,8 @@ win_perf_counter(_Py_clock_info_t *info, PyObject **result)
     if (info) {
         info->implementation = "QueryPerformanceCounter()";
         info->resolution = 1.0 / (double)cpu_frequency;
-        info->is_monotonic = 1;
-        info->is_adjusted = 0;
+        info->monotonic = 1;
+        info->adjusted = 0;
     }
     *result = PyFloat_FromDouble(diff / (double)cpu_frequency);
     return 0;
@@ -874,7 +874,7 @@ pymonotonic(_Py_clock_info_t *info)
             info->implementation = "GetTickCount64()";
         else
             info->implementation = "GetTickCount()";
-        info->is_monotonic = 1;
+        info->monotonic = 1;
         ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
                                      &isTimeAdjustmentDisabled);
         if (!ok) {
@@ -882,7 +882,7 @@ pymonotonic(_Py_clock_info_t *info)
             return NULL;
         }
         info->resolution = timeIncrement * 1e-7;
-        info->is_adjusted = 0;
+        info->adjusted = 0;
     }
     return PyFloat_FromDouble(result);
 
@@ -902,8 +902,8 @@ pymonotonic(_Py_clock_info_t *info)
     if (info) {
         info->implementation = "mach_absolute_time()";
         info->resolution = (double)timebase.numer / timebase.denom * 1e-9;
-        info->is_monotonic = 1;
-        info->is_adjusted = 0;
+        info->monotonic = 1;
+        info->adjusted = 0;
     }
     return PyFloat_FromDouble(secs);
 
@@ -924,14 +924,14 @@ pymonotonic(_Py_clock_info_t *info)
 
     if (info) {
         struct timespec res;
-        info->is_monotonic = 1;
+        info->monotonic = 1;
         info->implementation = function;
 #if (defined(linux) || defined(__linux) || defined(__linux__)) \
     && !defined(CLOCK_HIGHRES)
         /* CLOCK_MONOTONIC is adjusted on Linux */
-        info->is_adjusted = 1;
+        info->adjusted = 1;
 #else
-        info->is_adjusted = 0;
+        info->adjusted = 0;
 #endif
         if (clock_getres(clk_id, &res) == 0)
             info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
@@ -1023,8 +1023,8 @@ py_process_time(_Py_clock_info_t *info)
     if (info) {
         info->implementation = "GetProcessTimes()";
         info->resolution = 1e-7;
-        info->is_monotonic = 1;
-        info->is_adjusted = 0;
+        info->monotonic = 1;
+        info->adjusted = 0;
     }
     return PyFloat_FromDouble(total * 1e-7);
 #else
@@ -1052,8 +1052,8 @@ py_process_time(_Py_clock_info_t *info)
         if (info) {
             struct timespec res;
             info->implementation = function;
-            info->is_monotonic = 1;
-            info->is_adjusted = 0;
+            info->monotonic = 1;
+            info->adjusted = 0;
             if (clock_getres(clk_id, &res) == 0)
                 info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
             else
@@ -1070,8 +1070,8 @@ py_process_time(_Py_clock_info_t *info)
         total += ru.ru_stime.tv_sec + ru.ru_stime.tv_usec * 1e-6;
         if (info) {
             info->implementation = "getrusage(RUSAGE_SELF)";
-            info->is_monotonic = 1;
-            info->is_adjusted = 0;
+            info->monotonic = 1;
+            info->adjusted = 0;
             info->resolution = 1e-6;
         }
         return PyFloat_FromDouble(total);
@@ -1099,8 +1099,8 @@ py_process_time(_Py_clock_info_t *info)
             total += (double)t.tms_stime / ticks_per_second;
             if (info) {
                 info->implementation = "times()";
-                info->is_monotonic = 1;
-                info->is_adjusted = 0;
+                info->monotonic = 1;
+                info->adjusted = 0;
                 info->resolution = 1.0 / ticks_per_second;
             }
             return PyFloat_FromDouble(total);
@@ -1132,8 +1132,8 @@ PyDoc_STRVAR(ClockInfo_docstring,
 static PyStructSequence_Field ClockInfo_fields[] = {
     {"implementation", "name of the underlying C function "
                        "used to get the clock value"},
-    {"is_monotonic", "True if the clock cannot go backward, False otherwise"},
-    {"is_adjusted", "True if the clock can be adjusted "
+    {"monotonic", "True if the clock cannot go backward, False otherwise"},
+    {"adjusted", "True if the clock can be adjusted "
                     "(e.g. by a NTP daemon), False otherwise"},
     {"resolution", "resolution of the clock in seconds"},
     {NULL, NULL}
@@ -1159,13 +1159,13 @@ time_get_clock_info(PyObject *self, PyObject *args)
 
 #ifdef Py_DEBUG
     info.implementation = NULL;
-    info.is_monotonic = -1;
-    info.is_adjusted = -1;
+    info.monotonic = -1;
+    info.adjusted = -1;
     info.resolution = -1.0;
 #else
     info.implementation = "";
-    info.is_monotonic = 0;
-    info.is_adjusted = 0;
+    info.monotonic = 0;
+    info.adjusted = 0;
     info.resolution = 1.0;
 #endif
 
@@ -1201,14 +1201,14 @@ time_get_clock_info(PyObject *self, PyObject *args)
         goto error;
     PyStructSequence_SET_ITEM(result, 0, obj);
 
-    assert(info.is_monotonic != -1);
-    obj = PyBool_FromLong(info.is_monotonic);
+    assert(info.monotonic != -1);
+    obj = PyBool_FromLong(info.monotonic);
     if (obj == NULL)
         goto error;
     PyStructSequence_SET_ITEM(result, 1, obj);
 
-    assert(info.is_adjusted != -1);
-    obj = PyBool_FromLong(info.is_adjusted);
+    assert(info.adjusted != -1);
+    obj = PyBool_FromLong(info.adjusted);
     if (obj == NULL)
         goto error;
     PyStructSequence_SET_ITEM(result, 2, obj);
@@ -1487,8 +1487,8 @@ floattime(_Py_clock_info_t *info)
         if (info) {
             struct timespec res;
             info->implementation = "clock_gettime(CLOCK_REALTIME)";
-            info->is_monotonic = 0;
-            info->is_adjusted = 1;
+            info->monotonic = 0;
+            info->adjusted = 1;
             if (clock_getres(CLOCK_REALTIME, &res) == 0)
                 info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
             else
diff --git a/Python/pytime.c b/Python/pytime.c
index ddd3088..0ffe799 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -40,14 +40,14 @@ pygettimeofday(_PyTime_timeval *tp, _Py_clock_info_t *info)
         BOOL isTimeAdjustmentDisabled;
 
         info->implementation = "GetSystemTimeAsFileTime()";
-        info->is_monotonic = 0;
+        info->monotonic = 0;
         (void) GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
                                        &isTimeAdjustmentDisabled);
         info->resolution = timeIncrement * 1e-7;
         if (isTimeAdjustmentDisabled)
-            info->is_adjusted = 0;
+            info->adjusted = 0;
         else
-            info->is_adjusted = 1;
+            info->adjusted = 1;
     }
 #else
     /* There are three ways to get the time:
@@ -70,8 +70,8 @@ pygettimeofday(_PyTime_timeval *tp, _Py_clock_info_t *info)
         if (info) {
             info->implementation = "gettimeofday()";
             info->resolution = 1e-6;
-            info->is_monotonic = 0;
-            info->is_adjusted = 1;
+            info->monotonic = 0;
+            info->adjusted = 1;
         }
         return;
     }
@@ -86,8 +86,8 @@ pygettimeofday(_PyTime_timeval *tp, _Py_clock_info_t *info)
         if (info) {
             info->implementation = "ftime()";
             info->resolution = 1e-3;
-            info->is_monotonic = 0;
-            info->is_adjusted = 1;
+            info->monotonic = 0;
+            info->adjusted = 1;
         }
     }
 #else /* !HAVE_FTIME */
@@ -96,8 +96,8 @@ pygettimeofday(_PyTime_timeval *tp, _Py_clock_info_t *info)
     if (info) {
         info->implementation = "time()";
         info->resolution = 1.0;
-        info->is_monotonic = 0;
-        info->is_adjusted = 1;
+        info->monotonic = 0;
+        info->adjusted = 1;
     }
 #endif /* !HAVE_FTIME */