public static KDateTime FromString(string arg1, KDateTime.TimeFormat format) { return (KDateTime) staticInterceptor.Invoke("fromString$$", "fromString(const QString&, KDateTime::TimeFormat)", typeof(KDateTime), typeof(string), arg1, typeof(KDateTime.TimeFormat), format); }
/// <remarks> /// Returns the current date and time, as reported by the system clock, /// expressed in a given time specification. /// <param> name="spec" time specification /// </param></remarks> <return> current date/time /// </return> /// <short> Returns the current date and time, as reported by the system clock, expressed in a given time specification.</short> /// <see> currentUtcDateTime</see> /// <see> currentLocalDateTime</see> public static KDateTime CurrentDateTime(KDateTime.Spec spec) { return (KDateTime) staticInterceptor.Invoke("currentDateTime#", "currentDateTime(const KDateTime::Spec&)", typeof(KDateTime), typeof(KDateTime.Spec), spec); }
/// <remarks> /// Returns the KDateTime represented by <code>string</code>, using the <code>format</code> given. /// This method is the inverse of <see cref="#toString"></see>, except that it can /// only return a time specification of UTC, OffsetFromUTC or ClockTime. An /// actual named time zone cannot be returned since an offset from UTC only /// partially specifies a time zone. /// The time specification of the result is determined by the UTC offset /// present in the string: /// - if the UTC offset is zero the result is type <code>UTC.</code> /// - if the UTC offset is non-zero, the result is type <code>OffsetFromUTC.</code> /// - if there is no UTC offset, the result is by default type /// <code>ClockTime.</code> You can use setFromStringDefault() to change this default. /// If no time is found in <code>string</code>, a date-only value is returned, except /// when the specified <code>format</code> does not permit the time to be omitted, in /// which case an error is returned. An error is therefore returned for /// ISODate when <code>string</code> includes a time zone specification, and for /// RFCDate in all cases. /// For RFC format strings, you should normally set <code>format</code> to /// RFCDate. Only set it to RFCDateDay if you want to return an error /// when the day of the week is omitted. /// For <code>format</code> = ISODate or RFCDate[Day], if an invalid KDateTime is /// returned, you can check why <code>format</code> was considered invalid by use of /// outOfRange(). If that method returns true, it indicates that <code>format</code> /// was in fact valid, but the date lies outside the range which can be /// represented by QDate. /// <param> name="string" string to convert /// </param><param> name="format" format code. LocalDate cannot be used here. /// </param><param> name="negZero" if non-null, the value is set to true if a UTC offset of /// '-0000' is found or, for RFC 2822 format, an unrecognised /// or invalid time zone abbreviation is found, else false. /// </param></remarks> <return> KDateTime value, or an invalid KDateTime if either parameter is invalid /// </return> /// <short> Returns the KDateTime represented by <code>string</code>, using the <code>format</code> given.</short> /// <see> setFromStringDefault</see> /// <see> toString</see> /// <see> outOfRange</see> public static KDateTime FromString(string arg1, KDateTime.TimeFormat format, ref bool negZero) { StackItem[] stack = new StackItem[4]; #if DEBUG stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(arg1); #else stack[1].s_class = (IntPtr) GCHandle.Alloc(arg1); #endif stack[2].s_int = (int) format; stack[3].s_bool = negZero; staticInterceptor.Invoke("fromString$$$", "fromString(const QString&, KDateTime::TimeFormat, bool*)", stack); #if DEBUG DebugGCHandle.Free((GCHandle) stack[1].s_class); #else ((GCHandle) stack[1].s_class).Free(); #endif negZero = stack[3].s_bool; object returnValue = ((GCHandle) stack[0].s_class).Target; #if DEBUG DebugGCHandle.Free((GCHandle) stack[0].s_class); #else ((GCHandle) stack[0].s_class).Free(); #endif return (KDateTime) returnValue; }
/// <remarks> /// Changes the time specification of the instance. /// Any previous time zone is forgotten. The stored date/time component of /// the instance is left unchanged (except that its UTC/local time setting /// is set to correspond with <code>spec</code>). Usually this method will change the /// absolute time which this instance represents. /// <param> name="spec" new time specification /// </param></remarks> <short> Changes the time specification of the instance.</short> /// <see> timeSpec</see> /// <see> timeZone</see> public void SetTimeSpec(KDateTime.Spec spec) { interceptor.Invoke("setTimeSpec#", "setTimeSpec(const KDateTime::Spec&)", typeof(void), typeof(KDateTime.Spec), spec); }
public KDateTime(KDateTime other) : this((Type) null) { CreateProxy(); interceptor.Invoke("KDateTime#", "KDateTime(const KDateTime&)", typeof(void), typeof(KDateTime), other); }
/// <remarks> /// Calculates the number of days from this date/time to the <code>other</code> date/time. /// In calculating the result, <code>other</code> is first converted to this instance's /// time zone. The number of days difference is then calculated ignoring /// the time parts of the two date/times. For example, if this date/time /// was 13:00 on 1 January 2000, and <code>other</code> was 02:00 on 2 January 2000, /// the result would be 1. /// Note that if either instance is a local clock time (type <code>ClockTime</code>), /// the result cannot be guaranteed to be accurate, since by definition they /// contain no information about time zones or daylight savings changes. /// If one instance is date-only and the other is date-time, the date-time /// value is first converted to the same time specification as the date-only /// value, and the result is the difference in days between the resultant /// date and the date-only date. /// If both instances are date-only, the calculation ignores time zones. /// <param> name="other" other date/time /// </param></remarks> <return> number of days difference /// </return> /// <short> Calculates the number of days from this date/time to the <code>other</code> date/time.</short> /// <see> secsTo</see> /// <see> addDays</see> public int DaysTo(KDateTime other) { return (int) interceptor.Invoke("daysTo#", "daysTo(const KDateTime&) const", typeof(int), typeof(KDateTime), other); }
public string FormatDateTime(KDateTime dateTime, KLocale.DateFormat format) { return (string) interceptor.Invoke("formatDateTime#$", "formatDateTime(const KDateTime&, KLocale::DateFormat) const", typeof(string), typeof(KDateTime), dateTime, typeof(KLocale.DateFormat), format); }
/// <remarks> /// Copy constructor. /// </remarks> <short> Copy constructor.</short> public Spec(KDateTime.Spec spec) : this((Type) null) { CreateProxy(); interceptor.Invoke("Spec#", "Spec(const KDateTime::Spec&)", typeof(void), typeof(KDateTime.Spec), spec); }
/// <remarks> /// Checks whether this instance is equivalent to another. /// The two instances are considered to be equivalent if any of the following /// conditions apply: /// - both instances are type <code>ClockTime.</code> /// - both instances are type <code>OffsetFromUTC</code> and their offsets from UTC are equal. /// - both instances are type <code>TimeZone</code> and their time zones are equal. /// - both instances are UTC. An instance is considered to be UTC if it is /// either type <code>UTC</code>, or is type <code>OffsetFromUTC</code> with a zero UTC offset. /// </remarks> <return> @c true if the two instances are equivalent, @c false otherwise /// </return> /// <short> Checks whether this instance is equivalent to another.</short> /// <see> operator==</see> public bool EquivalentTo(KDateTime.Spec other) { return (bool) interceptor.Invoke("equivalentTo#", "equivalentTo(const KDateTime::Spec&) const", typeof(bool), typeof(KDateTime.Spec), other); }
/// <remarks> /// Constructs a time specification. /// <param> name="type" time specification type, which should not be <code>TimeZone</code> /// </param><param> name="utcOffset" number of seconds to add to UTC to get the local /// time. Ignored if <code>type</code> is not <code>OffsetFromUTC.</code> /// </param></remarks> <short> Constructs a time specification.</short> public Spec(KDateTime.SpecType type, int utcOffset) : this((Type) null) { CreateProxy(); interceptor.Invoke("Spec$$", "Spec(KDateTime::SpecType, int)", typeof(void), typeof(KDateTime.SpecType), type, typeof(int), utcOffset); }
public Spec(KDateTime.SpecType type) : this((Type) null) { CreateProxy(); interceptor.Invoke("Spec$", "Spec(KDateTime::SpecType)", typeof(void), typeof(KDateTime.SpecType), type); }
/// <remarks> /// Returns the time converted to the time specification of another instance. /// If this instance is a local clock time, it is first set to the local time /// zone, and then converted to the <code>spec</code> time specification. /// If this instance is a date-only value, a date-only value is returned, /// with the date unchanged. /// <param> name="dt" instance providing the new time specification /// </param></remarks> <return> converted time /// </return> /// <short> Returns the time converted to the time specification of another instance.</short> /// <see> toLocalZone</see> /// <see> toUtc</see> /// <see> toOffsetFromUtc</see> /// <see> toZone</see> /// <see> KTimeZone.Convert</see> public KDateTime ToTimeSpec(KDateTime dt) { return (KDateTime) interceptor.Invoke("toTimeSpec#", "toTimeSpec(const KDateTime&) const", typeof(KDateTime), typeof(KDateTime), dt); }
/// <remarks> /// Returns the time converted to a new time specification. /// If the instance is a local clock time, it is first set to the local time /// zone, and then converted to the <code>spec</code> time specification. /// If the instance is a date-only value, a date-only value is returned, /// with the date unchanged. /// <param> name="spec" new time specification /// </param></remarks> <return> converted time /// </return> /// <short> Returns the time converted to a new time specification.</short> /// <see> toLocalZone</see> /// <see> toUtc</see> /// <see> toOffsetFromUtc</see> /// <see> toZone</see> /// <see> KTimeZone.Convert</see> public KDateTime ToTimeSpec(KDateTime.Spec spec) { return (KDateTime) interceptor.Invoke("toTimeSpec#", "toTimeSpec(const KDateTime::Spec&) const", typeof(KDateTime), typeof(KDateTime.Spec), spec); }
/// <remarks> /// Returns the date/time as a string, formatted according to the <code>format</code> /// parameter, with the UTC offset appended. /// Note that if the instance has a time specification of ClockTime, the UTC /// offset in the result will be blank, except for RFC 2822 format in which /// it will be the offset for the local system time zone. /// If the instance is date-only, the time will when <code>format</code> permits be /// omitted from the output string. This applies to <code>format</code> = QtTextDate /// or LocalDate. It also applies to <code>format</code> = ISODate when the instance /// has a time specification of ClockTime. For all other cases, a time of /// 00:00:00 will be output. /// For RFC 2822 format, set <code>format</code> to RFCDateDay to include the day /// of the week, or to RFCDate to omit it. /// <param> name="format" format for output string /// </param></remarks> <return> formatted string /// </return> /// <short> Returns the date/time as a string, formatted according to the <code>format</code> parameter, with the UTC offset appended.</short> /// <see> fromString</see> /// <see> QDateTime.ToString</see> public string ToString(KDateTime.TimeFormat format) { return (string) interceptor.Invoke("toString$", "toString(KDateTime::TimeFormat) const", typeof(string), typeof(KDateTime.TimeFormat), format); }
/// <remarks> /// Sets the default time specification for use by fromString() when no time /// zone or UTC offset is found in the string being parsed, or when "-0000" /// is found in an RFC 2822 string. /// By default, fromString() returns a local clock time (type <code>ClockTime</code>) /// when no definite zone or UTC offset is found. You can use this method /// to make it return the local time zone, UTC, or whatever you wish. /// <param> name="spec" the new default time specification /// </param></remarks> <short> Sets the default time specification for use by fromString() when no time zone or UTC offset is found in the string being parsed, or when "-0000" is found in an RFC 2822 string.</short> /// <see> fromString</see> public static void SetFromStringDefault(KDateTime.Spec spec) { staticInterceptor.Invoke("setFromStringDefault#", "setFromStringDefault(const KDateTime::Spec&)", typeof(void), typeof(KDateTime.Spec), spec); }
/// <remarks> /// Initialises the time specification. /// <param> name="type" the time specification type. Note that <code>TimeZone</code> /// is invalid here. /// </param><param> name="utcOffset" number of seconds to add to UTC to get the local /// time. Ignored if <code>spec</code> is not <code>OffsetFromUTC.</code> /// </param></remarks> <short> Initialises the time specification.</short> /// <see> type</see> /// <see> setType(const</see> /// <see> KTimeZone&)</see> public void SetType(KDateTime.SpecType type, int utcOffset) { interceptor.Invoke("setType$$", "setType(KDateTime::SpecType, int)", typeof(void), typeof(KDateTime.SpecType), type, typeof(int), utcOffset); }
/// <remarks> /// Compare this instance with another to determine whether they are /// simultaneous, earlier or later, and in the case of date-only values, /// whether they overlap (i.e. partly coincide but are not wholly /// simultaneous). /// The comparison takes time zones into account: if the two instances have /// different time zones, they are first converted to UTC before comparing. /// If both instances are date/time values, this instance is considered to /// be either simultaneous, earlier or later, and does not overlap. /// If one instance is date-only and the other is a date/time, this instance /// is either strictly earlier, strictly later, or overlaps. /// If both instance are date-only, they are considered simultaneous if both /// their start of day and end of day times are simultaneous with each /// other. (Both start and end of day times need to be considered in case a /// daylight savings change occurs during that day.) Otherwise, this instance /// can be strictly earlier, earlier but overlapping, later but overlapping, /// or strictly later. /// Note that if either instance is a local clock time (type <code>ClockTime</code>), /// the result cannot be guaranteed to be correct, since by definition they /// contain no information about time zones or daylight savings changes. /// </remarks> <return> @c true if the two instances represent the same time, @c false otherwise /// </return> /// <short> Compare this instance with another to determine whether they are simultaneous, earlier or later, and in the case of date-only values, whether they overlap (i.</short> /// <see> operator==</see> /// <see> operator!=</see> /// <see> operator<</see> /// <see> operator<=</see> /// <see> operator>=</see> /// <see> operator></see> public KDateTime.Comparison Compare(KDateTime other) { return (KDateTime.Comparison) interceptor.Invoke("compare#", "compare(const KDateTime&) const", typeof(KDateTime.Comparison), typeof(KDateTime), other); }
public void SetType(KDateTime.SpecType type) { interceptor.Invoke("setType$", "setType(KDateTime::SpecType)", typeof(void), typeof(KDateTime.SpecType), type); }
/// <remarks> /// Returns a string formatted to the current locale's conventions /// regarding both date and time. /// <param> name="dateTime" the date and time to be formatted /// </param><param> name="format" category of date format to use /// </param><param> name="options" additional output options /// </param></remarks> <return> The date and time as a string /// </return> /// <short> Returns a string formatted to the current locale's conventions regarding both date and time.</short> public string FormatDateTime(KDateTime dateTime, KLocale.DateFormat format, uint options) { return (string) interceptor.Invoke("formatDateTime#$$", "formatDateTime(const KDateTime&, KLocale::DateFormat, KLocale::DateTimeFormatOptions) const", typeof(string), typeof(KDateTime), dateTime, typeof(KLocale.DateFormat), format, typeof(uint), options); }
/// <remarks> /// Constructs a date/time expressed in a given time specification. /// <code>dt</code> is interpreted and stored according to the time specification type /// of <code>spec</code> as follows: /// - <code>UTC</code> : <code>dt</code> is stored as a UTC value. If /// <code>dt.timeSpec</code>() is <code>Qt</code>.LocalTime, <code>dt</code> is first /// converted from the current system time zone to UTC /// before storage. /// - <code>OffsetFromUTC</code> : date/time is stored as a local time at the specified /// offset from UTC. If <code>dt.timeSpec</code>() is <code>Qt</code>.UTC, /// the time is adjusted by the UTC offset before /// storage. If <code>dt.timeSpec</code>() is <code>Qt</code>.LocalTime, /// it is assumed to be a local time at the specified /// offset from UTC, and is stored without adjustment. /// - <code>TimeZone</code> : if <code>dt</code> is specified as a UTC time (i.e. <code>dt.timeSpec</code>() /// is <code>Qt</code>.UTC), it is first converted to local time in /// specified time zone before being stored. /// - <code>LocalZone</code> : <code>dt</code> is stored as a local time in the current system /// time zone. If <code>dt.timeSpec</code>() is <code>Qt</code>.UTC, <code>dt</code> is /// first converted to local time before storage. /// - <code>ClockTime</code> : If <code>dt.timeSpec</code>() is <code>Qt</code>.UTC, <code>dt</code> is first /// converted to local time in the current system time zone /// before storage. After storage, the time is treated as a /// simple clock time, ignoring time zones. /// <param> name="dt" date and time /// </param><param> name="spec" time specification /// </param></remarks> <short> Constructs a date/time expressed in a given time specification.</short> public KDateTime(QDateTime dt, KDateTime.Spec spec) : this((Type) null) { CreateProxy(); interceptor.Invoke("KDateTime##", "KDateTime(const QDateTime&, const KDateTime::Spec&)", typeof(void), typeof(QDateTime), dt, typeof(KDateTime.Spec), spec); }
public string FormatDateTime(KDateTime dateTime) { return (string) interceptor.Invoke("formatDateTime#", "formatDateTime(const KDateTime&) const", typeof(string), typeof(KDateTime), dateTime); }
/// <remarks> /// Returns the number of seconds from this date/time to the <code>other</code> date/time. /// Before performing the comparison, the two date/times are converted to UTC /// to ensure that the result is correct if one of the two date/times has /// daylight saving time (DST) and the other doesn't. The exception is when /// both instances are local clock time, in which case no conversion to UTC /// is done. /// Note that if either instance is a local clock time (type <code>ClockTime</code>), /// the result cannot be guaranteed to be accurate, since by definition they /// contain no information about time zones or daylight savings changes. /// If one instance is date-only and the other is date-time, the date-time /// value is first converted to the same time specification as the date-only /// value, and the result is the difference in days between the resultant /// date and the date-only date. /// If both instances are date-only, the result is the difference in days /// between the two dates, ignoring time zones. /// <param> name="other" other date/time /// </param></remarks> <return> number of seconds difference /// </return> /// <short> Returns the number of seconds from this date/time to the <code>other</code> date/time.</short> /// <see> secsTo</see> /// <see> addSecs</see> /// <see> daysTo</see> public long SecsTo_long(KDateTime other) { return (long) interceptor.Invoke("secsTo_long#", "secsTo_long(const KDateTime&) const", typeof(long), typeof(KDateTime), other); }