1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module glib.TimeVal; 26 27 private import glib.Str; 28 private import gtkc.glib; 29 public import gtkc.glibtypes; 30 31 32 /** 33 * Represents a precise time, with seconds and microseconds. 34 * Similar to the struct timeval returned by the gettimeofday() 35 * UNIX system call. 36 * 37 * GLib is attempting to unify around the use of 64bit integers to 38 * represent microsecond-precision time. As such, this type will be 39 * removed from a future version of GLib. 40 */ 41 public class TimeVal 42 { 43 /** the main Gtk struct */ 44 protected GTimeVal* gTimeVal; 45 46 /** Get the main Gtk struct */ 47 public GTimeVal* getTimeValStruct() 48 { 49 return gTimeVal; 50 } 51 52 /** the main Gtk struct as a void* */ 53 protected void* getStruct() 54 { 55 return cast(void*)gTimeVal; 56 } 57 58 /** 59 * Sets our main struct and passes it to the parent class. 60 */ 61 public this (GTimeVal* gTimeVal) 62 { 63 this.gTimeVal = gTimeVal; 64 } 65 66 /** 67 */ 68 69 /** 70 * Adds the given number of microseconds to @time_. @microseconds can 71 * also be negative to decrease the value of @time_. 72 * 73 * Params: 74 * microseconds = number of microseconds to add to @time 75 */ 76 public void add(glong microseconds) 77 { 78 g_time_val_add(gTimeVal, microseconds); 79 } 80 81 /** 82 * Converts @time_ into an RFC 3339 encoded string, relative to the 83 * Coordinated Universal Time (UTC). This is one of the many formats 84 * allowed by ISO 8601. 85 * 86 * ISO 8601 allows a large number of date/time formats, with or without 87 * punctuation and optional elements. The format returned by this function 88 * is a complete date and time, with optional punctuation included, the 89 * UTC time zone represented as "Z", and the @tv_usec part included if 90 * and only if it is nonzero, i.e. either 91 * "YYYY-MM-DDTHH:MM:SSZ" or "YYYY-MM-DDTHH:MM:SS.fffffZ". 92 * 93 * This corresponds to the Internet date/time format defined by 94 * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt), 95 * and to either of the two most-precise formats defined by 96 * the W3C Note 97 * [Date and Time Formats](http://www.w3.org/TR/NOTE-datetime-19980827). 98 * Both of these documents are profiles of ISO 8601. 99 * 100 * Use g_date_time_format() or g_strdup_printf() if a different 101 * variation of ISO 8601 format is required. 102 * 103 * Return: a newly allocated string containing an ISO 8601 date 104 * 105 * Since: 2.12 106 */ 107 public string toIso8601() 108 { 109 return Str.toString(g_time_val_to_iso8601(gTimeVal)); 110 } 111 112 /** 113 * Converts a string containing an ISO 8601 encoded date and time 114 * to a #GTimeVal and puts it into @time_. 115 * 116 * @iso_date must include year, month, day, hours, minutes, and 117 * seconds. It can optionally include fractions of a second and a time 118 * zone indicator. (In the absence of any time zone indication, the 119 * timestamp is assumed to be in local time.) 120 * 121 * Params: 122 * isoDate = an ISO 8601 encoded date string 123 * time = a #GTimeVal 124 * 125 * Return: %TRUE if the conversion was successful. 126 * 127 * Since: 2.12 128 */ 129 public static bool fromIso8601(string isoDate, out TimeVal time) 130 { 131 GTimeVal* outtime = new GTimeVal; 132 133 auto p = g_time_val_from_iso8601(Str.toStringz(isoDate), outtime) != 0; 134 135 time = new TimeVal(outtime); 136 137 return p; 138 } 139 140 /** 141 * Equivalent to the UNIX gettimeofday() function, but portable. 142 * 143 * You may find g_get_real_time() to be more convenient. 144 * 145 * Params: 146 * result = #GTimeVal structure in which to store current time. 147 */ 148 public static void getCurrentTime(TimeVal result) 149 { 150 g_get_current_time((result is null) ? null : result.getTimeValStruct()); 151 } 152 153 /** 154 * Queries the system monotonic time. 155 * 156 * The monotonic clock will always increase and doesn't suffer 157 * discontinuities when the user (or NTP) changes the system time. It 158 * may or may not continue to tick during times where the machine is 159 * suspended. 160 * 161 * We try to use the clock that corresponds as closely as possible to 162 * the passage of time as measured by system calls such as poll() but it 163 * may not always be possible to do this. 164 * 165 * Return: the monotonic time, in microseconds 166 * 167 * Since: 2.28 168 */ 169 public static long getMonotonicTime() 170 { 171 return g_get_monotonic_time(); 172 } 173 174 /** 175 * Queries the system wall-clock time. 176 * 177 * This call is functionally equivalent to g_get_current_time() except 178 * that the return value is often more convenient than dealing with a 179 * #GTimeVal. 180 * 181 * You should only use this call if you are actually interested in the real 182 * wall-clock time. g_get_monotonic_time() is probably more useful for 183 * measuring intervals. 184 * 185 * Return: the number of microseconds since January 1, 1970 UTC. 186 * 187 * Since: 2.28 188 */ 189 public static long getRealTime() 190 { 191 return g_get_real_time(); 192 } 193 194 /** 195 * Pauses the current thread for the given number of microseconds. 196 * 197 * There are 1 million microseconds per second (represented by the 198 * #G_USEC_PER_SEC macro). g_usleep() may have limited precision, 199 * depending on hardware and operating system; don't rely on the exact 200 * length of the sleep. 201 * 202 * Params: 203 * microseconds = number of microseconds to pause 204 */ 205 public static void usleep(gulong microseconds) 206 { 207 g_usleep(microseconds); 208 } 209 }