---
product: Chilkat
product_version: 11.7.0
language: wcpp
language_label: Unicode C++
class: CkDateTime
class_name: CkDateTimeW
license: free
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/wcppCkDateTimeWRef.html
---
# Chilkat CkDateTime — Unicode C++ — v11.7.0

> Chilkat 11.7.0 · language=wcpp · class=CkDateTime (CkDateTimeW)
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/CkDateTime.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/guide.md`.

## Purpose

`CkDateTime` represents a date/time value and provides conversion methods for common date/time formats, including .NET DateTime, DateTime ticks, RFC 822, RFC 3339 / ISO 8601-style timestamps, Unix time, DOS date/time, OLE DATE, NTP time, ULID timestamps, and Chilkat DtObj. It also supports date arithmetic, age/expiration checks, serialization, and local/UTC conversion.

For an extended overview, see [CkDateTime Class Overview](https://www.chilkatsoft.com/ckdatetime_class_overview.asp)

## Object creation, unlocking and error handling

**Object Creation**

```cpp
// Local variable on the stack
CkDateTimeW obj;

// Dynamically allocate/delete
CkDateTimeW *pObj = new CkDateTimeW();
// ...
delete pObj;
```

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Unicode C++.

How failure is reported depends on the method's return type and is stated in the note under each method below. In every case the diagnostic text is in the `LastErrorText` property of the object whose method was called.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `void get_DebugLogFilePath(CkString &str); const wchar_t *debugLogFilePath(void); void put_DebugLogFilePath(const wchar_t *str);` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `void get_LastErrorHtml(CkString &str); const wchar_t *lastErrorHtml(void);` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `void get_LastErrorText(CkString &str); const wchar_t *lastErrorText(void);` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `void get_LastErrorXml(CkString &str); const wchar_t *lastErrorXml(void);` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `bool get_LastMethodSuccess(void); void put_LastMethodSuccess(bool newVal);` | read/write | Indicates the success or failure of the most recent method call: `true` means success, `false` means failure. |
| `VerboseLogging` | `bool get_VerboseLogging(void); void put_VerboseLogging(bool newVal);` | read/write | If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `void get_Version(CkString &str); const wchar_t *version(void);` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `IsDst` | property, read-only | `int get_IsDst(void);` |
| `UtcOffset` | property, read-only | `int get_UtcOffset(void);` |
| `AddDays` | method | `bool AddDays(int numDays);` |
| `AddSeconds` | method | `bool AddSeconds(int numSeconds);` |
| `DeSerialize` | method | `void DeSerialize(const wchar_t *serializedDateTime);` |
| `DiffSeconds` | method | `int DiffSeconds(CkDateTimeW &dateTimeArg);` |
| `ExpiresWithin` | method | `bool ExpiresWithin(int n, const wchar_t *units);` |
| `GetAsDateTimeTicks` | method | `__int64 GetAsDateTimeTicks(bool bLocal);` |
| `GetAsDosDate` | method | `unsigned long GetAsDosDate(bool bLocal);` |
| `GetAsIso8601` | method | `bool GetAsIso8601(const wchar_t *formatStr, bool bLocal, CkString &outStr); const wchar_t *getAsIso8601(const wchar_t *formatStr, bool bLocal);` |
| `GetAsOleDate` | method | `double GetAsOleDate(bool bLocal);` |
| `GetAsRfc822` | method | `bool GetAsRfc822(bool bLocal, CkString &outStr); const wchar_t *getAsRfc822(bool bLocal);` |
| `GetAsTimestamp` | method | `bool GetAsTimestamp(bool bLocal, CkString &outStr); const wchar_t *getAsTimestamp(bool bLocal);` |
| `GetAsUnixTime` | method | `unsigned long GetAsUnixTime(bool bLocal);` |
| `GetAsUnixTime64` | method | `__int64 GetAsUnixTime64(bool bLocal);` |
| `GetAsUnixTimeDbl` | method | `double GetAsUnixTimeDbl(bool bLocal);` |
| `GetAsUnixTimeStr` | method | `bool GetAsUnixTimeStr(bool bLocal, CkString &outStr); const wchar_t *getAsUnixTimeStr(bool bLocal);` |
| `LoadTaskResult` | method | `bool LoadTaskResult(CkTaskW &task);` |
| `OlderThan` | method | `bool OlderThan(int n, const wchar_t *units);` |
| `Serialize` | method | `bool Serialize(CkString &outStr); const wchar_t *serialize(void);` |
| `SetFromCurrentSystemTime` | method | `bool SetFromCurrentSystemTime(void);` |
| `SetFromDateTimeTicks` | method | `bool SetFromDateTimeTicks(bool bLocal, __int64 ticks);` |
| `SetFromDosDate` | method | `bool SetFromDosDate(bool bLocal, unsigned long t);` |
| `SetFromDtObj` | method | `bool SetFromDtObj(CkDtObjW &dt);` |
| `SetFromNtpServer` | method | `bool SetFromNtpServer(const wchar_t *jsonStr);` |
| `SetFromNtpTime` | method | `bool SetFromNtpTime(int ntpSeconds);` |
| `SetFromOleDate` | method | `bool SetFromOleDate(bool bLocal, double dt);` |
| `SetFromRfc822` | method | `bool SetFromRfc822(const wchar_t *rfc822Str);` |
| `SetFromTimestamp` | method | `bool SetFromTimestamp(const wchar_t *timestamp);` |
| `SetFromUlid` | method | `bool SetFromUlid(bool bLocal, const wchar_t *ulid);` |
| `SetFromUnixTime` | method | `bool SetFromUnixTime(bool bLocal, unsigned long t);` |
| `SetFromUnixTime64` | method | `bool SetFromUnixTime64(bool bLocal, __int64 t);` |
| `SetFromUnixTimeDbl` | method | `bool SetFromUnixTimeDbl(bool bLocal, double d);` |
| `ToDtObj` | method | `void ToDtObj(bool bLocal, CkDtObjW &dtObj);` |
| `UlidGenerate` | method | `bool UlidGenerate(bool bLocal, CkString &outStr); const wchar_t *ulidGenerate(bool bLocal);` |
| `UlidIncrement` | method | `bool UlidIncrement(CkStringBuilderW &ulid);` |
| `UlidValidate` | method | `bool UlidValidate(const wchar_t *ulid);` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### CkDateTime.IsDst

`Chilkat 11.7.0 · wcpp · CkDateTime · IsDst · property · read-only`

```cpp
int get_IsDst(void);
```

This is the Daylight Saving Time flag. It can have one of three possible values: 1, 0, or -1. It has the value 1 if Daylight Saving Time is in effect, 0 if Daylight Saving Time is not in effect, and -1 if the information is not available.

Note: This is NOT the DST for the current system time. It is the DST that was in effect at the date value contained in this object.

### CkDateTime.UtcOffset

`Chilkat 11.7.0 · wcpp · CkDateTime · UtcOffset · property · read-only`

```cpp
int get_UtcOffset(void);
```

For the current system's timezone, returns the number of seconds offset from UTC for this date/time. The offset includes daylight savings adjustment. Local timezones west of UTC return a negative offset.

## Methods

### CkDateTime.AddDays

`Chilkat 11.7.0 · wcpp · CkDateTime · AddDays · method`

```cpp
bool AddDays(int numDays);
```

Adds an integer number of days to the date/time. To subtract days, pass a negative integer.

Returns true for success, false for failure.

### CkDateTime.AddSeconds

`Chilkat 11.7.0 · wcpp · CkDateTime · AddSeconds · method · since 9.5.0.65`

```cpp
bool AddSeconds(int numSeconds);
```

Adds an integer number of seconds to the date/time. To subtract seconds, pass a negative integer.

Returns true for success, false for failure.

### CkDateTime.DeSerialize

`Chilkat 11.7.0 · wcpp · CkDateTime · DeSerialize · method`

```cpp
void DeSerialize(const wchar_t *serializedDateTime);
```

Loads the date/time with a string having the format as produced by the Serialize method, which is a string of SPACE separated integers containing (in this order) year, month, day, hour, minutes, seconds, and a UTC flag having the value of 1/0.

### CkDateTime.DiffSeconds

`Chilkat 11.7.0 · wcpp · CkDateTime · DiffSeconds · method · since 9.5.0.65`

```cpp
int DiffSeconds(CkDateTimeW &dateTimeArg);
```

Returns the difference in seconds between the `dateTimeArg` and this date/time. The value returned is this object's date/time - `dateTimeArg`'s date/time. For example, if the returned value is positive, then this object's date/time is more recent than `dateTimeArg`'s date/time. If the return value is negative, then this object's date/time is older than `dateTimeArg`'s date/time.

### CkDateTime.ExpiresWithin

`Chilkat 11.7.0 · wcpp · CkDateTime · ExpiresWithin · method · since 9.5.0.67`

```cpp
bool ExpiresWithin(int n, const wchar_t *units);
```

Returns `true` if the date/time is within `n` seconds/minutes/hours/days of the current system date/time. Otherwise returns `false`. The `units` can be `seconds`, `minutes`, `hours`, or `days` (plural or singular).

### CkDateTime.GetAsDateTimeTicks

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsDateTimeTicks · method`

```cpp
__int64 GetAsDateTimeTicks(bool bLocal);
```

Returns the date/time as a 64-bit integer .NET DateTime value.

`bLocal` indicates whether a local or UTC time is returned.

This is a date and time expressed in the number of 100-nanosecond intervals that have elapsed since January 1, 0001 at 00:00:00.000 in the Gregorian calendar.

The DateTime value type represents dates and times with values ranging from 12:00:00 midnight, January 1, 0001 Anno Domini (Common Era) through 11:59:59 P.M., December 31, 9999 A.D. (C.E.).

Time values are measured in 100-nanosecond units called ticks, and a particular date is the number of ticks since 12:00 midnight, January 1, 0001 A.D. (C.E.) in the GregorianCalendar calendar (excluding ticks that would be added by leap seconds). For example, a ticks value of 31241376000000000L represents the date, Friday, January 01, 0100 12:00:00 midnight. A DateTime value is always expressed in the context of an explicit or default calendar.

### CkDateTime.GetAsDosDate

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsDosDate · method`

```cpp
unsigned long GetAsDosDate(bool bLocal);
```

Returns the date/time as a 32-bit DOS date/time bitmask.

`bLocal` indicates whether a local or UTC time is returned.

The DOS date/time format is a bitmask:

```

			   24                16                 8                 0
	    +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+
	    |Y|Y|Y|Y|Y|Y|Y|M| |M|M|M|D|D|D|D|D| |h|h|h|h|h|m|m|m| |m|m|m|s|s|s|s|s|
	    +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+
	     \___________/\________/\_________/ \________/\____________/\_________/
		 year        month       day      hour       minute        second
```

The year is stored as an offset from 1980. Seconds are stored in two-second increments. (So if the `second` value is 15, it actually represents 30 seconds.)

### CkDateTime.GetAsIso8601

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsIso8601 · method · since 9.5.0.65`

```cpp
bool GetAsIso8601(const wchar_t *formatStr, bool bLocal, CkString &outStr);

const wchar_t *getAsIso8601(const wchar_t *formatStr, bool bLocal);
```

Returns the date/time in a compatible ISO 8601 format according to the format specified in `formatStr`.. Examples of ISO 8601 formats include the following:

```
    YYYY-MM-DD

    YYYY-MM-DDThh:mmTZD

    YYYY-MM-DDThh:mm:ssTZD

    YYYY-MM-DDThh:mm:ss:sssTZD
```

For the date portion of these formats, `YYYY` is a four-digit year representation, `MM` is a two-digit month, and `DD` is a two-digit day. For the time portion, `hh` is the hour in 24-hour notation, `mm` is the two-digit minutes, `ss` is the two-digit seconds, and `sss` is the 3-digit milliseconds. A time designator `T` separates the date and time portions of the string, while a time zone designator `TZD` specifies a time zone (UTC).

`bLocal` indicates whether a local or UTC time is returned.

Returns true for success, false for failure.

### CkDateTime.GetAsOleDate

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsOleDate · method`

```cpp
double GetAsOleDate(bool bLocal);
```

Returns the date/time in a Windows OLE `DATE` format.

`bLocal` indicates whether a local or UTC time is returned.

The OLE automation date format is a floating point value, counting days since midnight 30 December 1899. Hours and minutes are represented as fractional days.

### CkDateTime.GetAsRfc822

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsRfc822 · method`

```cpp
bool GetAsRfc822(bool bLocal, CkString &outStr);

const wchar_t *getAsRfc822(bool bLocal);
```

Returns the date/time as an RFC822 formatted string. (An RFC822 format string is what is found in the `Date` header field of an email, such as `Wed, 18 Oct 2017 09:08:21 GMT`.)

`bLocal` indicates whether a local or UTC time is returned.

Returns true for success, false for failure.

### CkDateTime.GetAsTimestamp

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsTimestamp · method · since 9.5.0.58`

```cpp
bool GetAsTimestamp(bool bLocal, CkString &outStr);

const wchar_t *getAsTimestamp(bool bLocal);
```

Returns the date/time as an RFC 3339 formatted string, such as `1990-12-31T23:59:60Z`. (This is an ISO 8061 format like the following: YYYY-MM-DDThh:mm:ssTZD)

`bLocal` indicates whether a local or UTC time is returned.

Returns true for success, false for failure.

### CkDateTime.GetAsUnixTime

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsUnixTime · method`

```cpp
unsigned long GetAsUnixTime(bool bLocal);
```

Returns the date/time as a Unix time value, which is the number of seconds elapsed since 00:00:00 UTC on January 1, 1970.

`bLocal` indicates whether the date/time returned is local or UTC.

### CkDateTime.GetAsUnixTime64

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsUnixTime64 · method`

```cpp
__int64 GetAsUnixTime64(bool bLocal);
```

The same as GetUnixTime, except returns the date/time as a 64-bit integer.

`bLocal` indicates whether a local or UTC time is returned.

Note: 64-bit integers are needed after Jan 19, 2038. The Y2038 problem happens because some systems store Unix time as a signed 32-bit number of seconds since Jan 1, 1970. This number runs out on Jan 19, 2038, causing the time to wrap around to a date in 1901.

### CkDateTime.GetAsUnixTimeDbl

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsUnixTimeDbl · method`

```cpp
double GetAsUnixTimeDbl(bool bLocal);
```

The same as GetUnixTime, except returns the date/time as a double.

`bLocal` indicates whether a local or UTC time is returned.

### CkDateTime.GetAsUnixTimeStr

`Chilkat 11.7.0 · wcpp · CkDateTime · GetAsUnixTimeStr · method · since 9.5.0.65`

```cpp
bool GetAsUnixTimeStr(bool bLocal, CkString &outStr);

const wchar_t *getAsUnixTimeStr(bool bLocal);
```

Returns the time in Unix format (in seconds since the epoch: 00:00:00 UTC on 1 January 1970).

`bLocal` indicates whether the date/time returned is local or UTC.

Returns true for success, false for failure.

### CkDateTime.LoadTaskResult

`Chilkat 11.7.0 · wcpp · CkDateTime · LoadTaskResult · method · since 9.5.0.52`

```cpp
bool LoadTaskResult(CkTaskW &task);
```

Loads the date/time from a completed asynchronous task.

Returns true for success, false for failure.

### CkDateTime.OlderThan

`Chilkat 11.7.0 · wcpp · CkDateTime · OlderThan · method · since 9.5.0.67`

```cpp
bool OlderThan(int n, const wchar_t *units);
```

Returns `true` if the date/time is older than the current system date/time by `n` seconds/minutes/hours/days. Otherwise returns `false`. The `units` can be `seconds`, `minutes`, `hours`, or `days` (plural or singular).

### CkDateTime.Serialize

`Chilkat 11.7.0 · wcpp · CkDateTime · Serialize · method`

```cpp
bool Serialize(CkString &outStr);

const wchar_t *serialize(void);
```

Serializes the date/time to a us-ascii string that can be imported at a later time via the DeSerialize method. The format of the string returned by this method is not intended to match any published standard. It is formatted to a string with SPACE separated integers containing (in this order) year, month, day, hour, minutes, seconds, and a UTC flag having the value of 1 or 0.

Returns true for success, false for failure.

### CkDateTime.SetFromCurrentSystemTime

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromCurrentSystemTime · method`

```cpp
bool SetFromCurrentSystemTime(void);
```

Sets the date/time from the current system time.

Returns true for success, false for failure.

### CkDateTime.SetFromDateTimeTicks

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromDateTimeTicks · method`

```cpp
bool SetFromDateTimeTicks(bool bLocal, __int64 ticks);
```

Sets the date/time from a .NET DateTime value represented in ticks. See GetAsDateTimeTicks for more information.

`bLocal` indicates whether the passed in date/time is local or UTC.

Returns true for success, false for failure.

### CkDateTime.SetFromDosDate

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromDosDate · method`

```cpp
bool SetFromDosDate(bool bLocal, unsigned long t);
```

Sets the date/time from a 32-bit DOS date/time bitmask. See GetAsDosDate for more information.

Returns true for success, false for failure.

### CkDateTime.SetFromDtObj

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromDtObj · method · since 9.5.0.47`

```cpp
bool SetFromDtObj(CkDtObjW &dt);
```

Sets the date/time from a Chilkat `Dt` object.

Returns true for success, false for failure.

### CkDateTime.SetFromNtpServer

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromNtpServer · method · since 9.5.0.96`

```cpp
bool SetFromNtpServer(const wchar_t *jsonStr);
```

Sets the date/time by sending a query to an NTP server.

Returns true for success, false for failure.

### CkDateTime.SetFromNtpTime

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromNtpTime · method · since 9.5.0.50`

```cpp
bool SetFromNtpTime(int ntpSeconds);
```

Sets the date/time from a 32-bit NTP time value. `ntpSeconds` is the number of seconds since 00:00 (midnight) 1 January 1900 GMT.

Returns true for success, false for failure.

### CkDateTime.SetFromOleDate

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromOleDate · method`

```cpp
bool SetFromOleDate(bool bLocal, double dt);
```

Sets the date/time from a Windows OLE `DATE` value.

`bLocal` indicates whether the passed in date/time is local or UTC.

**Note:** This method was not working correctly. The problem was discovered just after releasing v9.5.0.65. It will be fixed in the next version update.

Returns true for success, false for failure.

### CkDateTime.SetFromRfc822

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromRfc822 · method`

```cpp
bool SetFromRfc822(const wchar_t *rfc822Str);
```

Sets the date/time from an RFC822 date/time formatted string. Here are some examples of RFC822 formatted date/times:

```
Tue, 15 Nov 2022 22:00:58 +0000
Tue, 15 Nov 2022 20:21:50 +0100
Tue, 01 Nov 2022 18:09:41 -0600
```

Returns true for success, false for failure.

### CkDateTime.SetFromTimestamp

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromTimestamp · method · since 9.5.0.58`

```cpp
bool SetFromTimestamp(const wchar_t *timestamp);
```

Sets the date/time from an RFC 3339 timestamp format. (such as `1990-12-31T23:59:60Z:`)

(This is an ISO 8061 format like the following: YYYY-MM-DDThh:mm:ssTZD)

**Note:** Starting in v9.5.0.77, strings formatted as `YYMMDDhhmmssZ`, such as `181221132225Z`, can also be passed to this method.

Returns true for success, false for failure.

### CkDateTime.SetFromUlid

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromUlid · method · since 9.5.0.94`

```cpp
bool SetFromUlid(bool bLocal, const wchar_t *ulid);
```

Sets this object's date/time using the timestamp embedded in the `ulid`. If the `ulid` was not a valid ULID, returns `false` and the date/time is not set. `bLocal` indicates whether the `ulid` uses a local time or UTC time.

Returns true for success, false for failure.

### CkDateTime.SetFromUnixTime

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromUnixTime · method`

```cpp
bool SetFromUnixTime(bool bLocal, unsigned long t);
```

Sets the date/time from a UNIX time value.

`bLocal` indicates whether the passed in date/time is local or UTC.

Returns true for success, false for failure.

### CkDateTime.SetFromUnixTime64

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromUnixTime64 · method`

```cpp
bool SetFromUnixTime64(bool bLocal, __int64 t);
```

The same as SetFromUnixTime, except that it uses a 64-bit integer to solve the Y2038 problem.

`bLocal` indicates whether the passed in date/time is local or UTC.

Note: 64-bit integers are needed after Jan 19, 2038. The Y2038 problem happens because some systems store Unix time as a signed 32-bit number of seconds since Jan 1, 1970. This number runs out on Jan 19, 2038, causing the time to wrap around to a date in 1901.

Returns true for success, false for failure.

### CkDateTime.SetFromUnixTimeDbl

`Chilkat 11.7.0 · wcpp · CkDateTime · SetFromUnixTimeDbl · method`

```cpp
bool SetFromUnixTimeDbl(bool bLocal, double d);
```

The same as SetFromUnixTime, except that it uses a double to solve the Y2038 problem. (See GetAsUnixTime for more information about Y2038).

`bLocal` indicates whether the passed in date/time is local or UTC.

Returns true for success, false for failure.

### CkDateTime.ToDtObj

`Chilkat 11.7.0 · wcpp · CkDateTime · ToDtObj · method · since 11.0.0`

```cpp
void ToDtObj(bool bLocal, CkDtObjW &dtObj);
```

Copies the date/time to the `dtObj`. Gets the date/time in the local time if `bLocal` is `true`, or GMT if `bLocal` is `false`.

### CkDateTime.UlidGenerate

`Chilkat 11.7.0 · wcpp · CkDateTime · UlidGenerate · method · since 9.5.0.94`

```cpp
bool UlidGenerate(bool bLocal, CkString &outStr);

const wchar_t *ulidGenerate(bool bLocal);
```

Generates and returns a new ULID using this object's date/time value. `bLocal` indicates whether to use local time or UTC time.

Returns true for success, false for failure.

### CkDateTime.UlidIncrement

`Chilkat 11.7.0 · wcpp · CkDateTime · UlidIncrement · method · since 9.5.0.94`

```cpp
bool UlidIncrement(CkStringBuilderW &ulid);
```

Increments the ULID that is passed in `ulid`.

Returns true for success, false for failure.

### CkDateTime.UlidValidate

`Chilkat 11.7.0 · wcpp · CkDateTime · UlidValidate · method · since 9.5.0.94`

```cpp
bool UlidValidate(const wchar_t *ulid);
```

Validates the `ulid`. Returns `true` if the `ulid` is valid, otherwise returns `false`.

Returns true for success, false for failure.

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `GetDtObj` | method | before 11.6.1 | — |

## Related classes

[`DtObj`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/DtObj.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/StringBuilder.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/Task.md)