Changeset 74149 in vbox

Timestamp:

Sep 7, 2018 6:51:37 PM (7 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

124921

Message:

IPRT/rest: Adding RTCRestDate (untested). bugref:9167

Location:

trunk

Files:

• include/iprt/cpp/restbase.h (modified) (3 diffs)
• include/iprt/err.h (modified) (1 diff)
• src/VBox/Runtime/common/rest/RTCRestAnyObject.cpp (modified) (2 diffs)
• src/VBox/Runtime/common/rest/RTCRestClientApiBaseOci.cpp (modified) (1 diff)
• src/VBox/Runtime/common/rest/rest-binary.cpp (modified) (1 diff)
• src/VBox/Runtime/common/rest/rest-primary-object-types.cpp (modified) (2 diffs)

trunk/include/iprt/cpp/restbase.h

@@ -31 +31 @@
 #include <iprt/json.h>
 #include <iprt/stdarg.h>
+#include <iprt/time.h>
 #include <iprt/cpp/ministring.h>
 
@@ -362 +363 @@
         kTypeClass_Invalid = 0,
         kTypeClass_Bool,                /**< Primitive: bool. */
-        kTypeClass_Int64,               /**< Primitive: bool. */
-        kTypeClass_Int32,               /**< Primitive: bool. */
-        kTypeClass_Int16,               /**< Primitive: bool. */
-        kTypeClass_Double,              /**< Primitive: bool. */
-        kTypeClass_String,              /**< Primitive: bool. */
+        kTypeClass_Int64,               /**< Primitive: int64_t. */
+        kTypeClass_Int32,               /**< Primitive: int32_t. */
+        kTypeClass_Int16,               /**< Primitive: int16_t. */
+        kTypeClass_Double,              /**< Primitive: double. */
+        kTypeClass_String,              /**< Primitive: string. */
+        kTypeClass_Date,                /**< Date. */
+        kTypeClass_Uuid,                /**< UUID. */
+        kTypeClass_Binary,              /**< Binary blob. */
         kTypeClass_Object,              /**< Object (any kind of data model object). */
         kTypeClass_Array,               /**< Array (containing any kind of object). */
         kTypeClass_StringMap,           /**< String map (containing any kind of object). */
-        kTypeClass_StringEnum,          /**< String enum. */
-        kTypeClass_BinaryString         /**< Binary string. */
+        kTypeClass_StringEnum           /**< String enum. */
     } kTypeClass;
 
@@ -642 +645 @@
     static DECLCALLBACK(RTCRestObjectBase *) createInstance(void);
 };
+
+
+/**
+ * Date class.
+ *
+ * There are numerous ways of formatting a timestamp and the specifications
+ * we're currently working with doesn't have a way of telling it seems.
+ * Thus, decoding need to have fail safes built in so the user can give hints.
+ * The formatting likewise needs to be told which format to use by the user.
+ *
+ * Two side-effects of the format stuff is that the default constructor creates
+ * an object that is null, and resetToDefault will do the same bug leave the
+ * format as a hint.
+ */
+class RT_DECL_CLASS RTCRestDate : public RTCRestObjectBase
+{
+public:
+    /** Default constructor.
+     * @note The result is a null-object.   */
+    RTCRestDate();
+    /** Copy constructor. */
+    RTCRestDate(RTCRestDate const &a_rThat);
+    /** Destructor. */
+    virtual ~RTCRestDate();
+    /** Copy assignment operator. */
+    RTCRestDate &operator=(RTCRestDate const &a_rThat);
+    /** Safe copy assignment method. */
+    int assignCopy(RTCRestDate const &a_rThat);
+
+    /* Overridden methods: */
+    virtual int resetToDefault() RT_OVERRIDE;
+    virtual RTCRestOutputBase &serializeAsJson(RTCRestOutputBase &a_rDst) const RT_OVERRIDE;
+    virtual int deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_OVERRIDE;
+    virtual int toString(RTCString *a_pDst, uint32_t a_fFlags = 0) const RT_OVERRIDE;
+    virtual int fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo = NULL,
+                           uint32_t a_fFlags = kCollectionFormat_Unspecified) RT_OVERRIDE;
+    virtual kTypeClass typeClass(void) const RT_OVERRIDE;
+    virtual const char *typeName(void) const RT_OVERRIDE;
+
+    /** Factory method. */
+    static DECLCALLBACK(RTCRestObjectBase *) createInstance(void);
+
+    /** Date formats. */
+    typedef enum
+    {
+        kFormat_Invalid = 0,
+        kFormat_Rfc2822,            /**< Format it according to RFC-2822. */
+        kFormat_Rfc7131,            /**< Format it according to RFC-7131 (HTTP). */
+        kFormat_Rfc3339,            /**< Format it according to RFC-3339 (ISO-8601) (no fraction). */
+        kFormat_Rfc3339_Fraction_2, /**< Format it according to RFC-3339 (ISO-8601) with two digit fraction (hundreths). */
+        kFormat_Rfc3339_Fraction_3, /**< Format it according to RFC-3339 (ISO-8601) with three digit fraction (milliseconds). */
+        kFormat_Rfc3339_Fraction_6, /**< Format it according to RFC-3339 (ISO-8601) with six digit fraction (microseconds). */
+        kFormat_Rfc3339_Fraction_9, /**< Format it according to RFC-3339 (ISO-8601) with nine digit fraction (nanoseconds). */
+        kFormat_End
+    } kFormat;
+
+    /**
+     * Assigns the value, formats it as a string and clears the null indicator.
+     *
+     * @returns VINF_SUCCESS, VERR_NO_STR_MEMORY or VERR_INVALID_PARAMETER.
+     * @param   a_pTimeSpec     The time spec to set.
+     * @param   a_enmFormat     The date format to use when formatting it.
+     */
+    int assignValue(PCRTTIMESPEC a_pTimeSpec, kFormat a_enmFormat);
+    int assignValueRfc2822(PCRTTIMESPEC a_pTimeSpec); /**< Convenience method. */
+    int assignValueRfc7131(PCRTTIMESPEC a_pTimeSpec); /**< Convenience method. */
+    int assignValueRfc3339(PCRTTIMESPEC a_pTimeSpec); /**< Convenience method. */
+
+    /**
+     * Assigns the current UTC time and clears the null indicator .
+     *
+     * @returns VINF_SUCCESS, VERR_NO_STR_MEMORY or VERR_INVALID_PARAMETER.
+     * @returns VINF_SUCCESS or VERR_NO_STR_MEMORY.
+     * @param   a_enmFormat     The date format to use when formatting it.
+     */
+    int assignNow(kFormat a_enmFormat);
+    int assignNowRfc2822(); /**< Convenience method. */
+    int assignNowRfc7131(); /**< Convenience method. */
+    int assignNowRfc3339(); /**< Convenience method. */
+
+    /**
+     * Sets the format to help deal with decoding issues.
+     *
+     * This can also be used to change the date format for an okay timespec.
+     * @returns IPRT status code.
+     * @param   a_enmFormat     The date format to try/set.
+     */
+    int setFormat(kFormat a_enmFormat);
+
+    /** Check if the value is okay (m_TimeSpec & m_Exploded). */
+    bool              isOkay() const        { return m_fTimeSpecOkay; }
+    /** Get the timespec value. */
+    RTTIMESPEC const &getTimeSpec() const   { return m_TimeSpec; }
+    /** Get the exploded time. */
+    RTTIME const     &getExploded() const   { return m_Exploded; }
+    /** Get the formatted/raw string value. */
+    RTCString const  &getString() const     { return m_strFormatted; }
+
+protected:
+    /** The value. */
+    RTTIMESPEC  m_TimeSpec;
+    /** The exploded time value. */
+    RTTIME      m_Exploded;
+    /** Set if m_TimeSpec is okay, consult m_strFormatted if not. */
+    bool        m_fTimeSpecOkay;
+    /** The format / format hint. */
+    kFormat     m_enmFormat;
+    /** The formatted date string.
+     * This will be the raw input string for a deserialized value, where as for
+     * a value set by the user it will be the formatted value. */
+    RTCString   m_strFormatted;
+
+    /**
+     * Explodes and formats the m_TimeSpec value.
+     *
+     * Sets m_Exploded, m_strFormatted, m_fTimeSpecOkay, and m_enmFormat, clears m_fNullIndicator.
+     *
+     * @returns VINF_SUCCESS or VERR_NO_STR_MEMORY.
+     * @param   a_enmFormat The format to use.
+     */
+    int explodeAndFormat(kFormat a_enmFormat);
+
+    /**
+     * Formats the m_Exploded value.
+     *
+     * Sets m_strFormatted, m_fTimeSpecOkay, and m_enmFormat, clears m_fNullIndicator.
+     *
+     * @returns VINF_SUCCESS or VERR_NO_STR_MEMORY.
+     * @param   a_enmFormat The format to use.
+     */
+    int format(kFormat a_enmFormat);
+
+    /**
+     * Internal worker that attempts to decode m_strFormatted.
+     *
+     * Sets m_fTimeSpecOkay.
+     *
+     * @returns IPRT status code.
+     * @param   enmFormat   Specific format to try, kFormat_Invalid (default) to try guess it.
+     */
+    int decodeFormattedString(kFormat enmFormat = kFormat_Invalid);
+};
+
+
+/** We should provide a proper UUID class eventually.  Currently it is not used. */
+typedef RTCRestString RTCRestUuid;
 
 

trunk/include/iprt/err.h

@@ -3218 +3218 @@
 /** Server response contains unexpected repetitive header field. */
 #define VERR_REST_RESPONSE_REPEAT_HEADER_FIELD          (-25703)
+/** Unable to decode date value. */
+#define VWRN_REST_UNABLE_TO_DECODE_DATE                 (25704)
+/** Unable to decode date value. */
+#define VERR_REST_UNABLE_TO_DECODE_DATE                 (-25704)
 
 /** Internal error \#1. */

trunk/src/VBox/Runtime/common/rest/RTCRestAnyObject.cpp

@@ -108 +108 @@
 
             /* Currently unused of invalid: */
+            case kTypeClass_Date:
+            case kTypeClass_Uuid:
+            case kTypeClass_Binary:
             case kTypeClass_StringEnum:
-            case kTypeClass_BinaryString:
             case kTypeClass_Object:
             case kTypeClass_Invalid:
@@ -541 +543 @@
 
             /* Currently unused of invalid: */
+            case kTypeClass_Date:
+            case kTypeClass_Uuid:
+            case kTypeClass_Binary:
             case kTypeClass_StringEnum:
-            case kTypeClass_BinaryString:
             case kTypeClass_Object:
             case kTypeClass_Invalid:

trunk/src/VBox/Runtime/common/rest/RTCRestClientApiBaseOci.cpp

@@ -59 +59 @@
     RTTIMESPEC NowSpec;
     RTTIME     Now;
-    char       szDate[RTTIME_RTC2822_LEN];
+    char       szDate[RTTIME_RFC2822_LEN];
     ssize_t cch = RTTimeToRfc2822(RTTimeExplode(&Now, RTTimeNow(&NowSpec)), szDate, sizeof(szDate), RTTIME_RFC2822_F_GMT);
     AssertRCReturn((int)cch, (int)cch);

trunk/src/VBox/Runtime/common/rest/rest-binary.cpp

@@ -222 +222 @@
 RTCRestObjectBase::kTypeClass RTCRestBinary::typeClass(void) const
 {
-    return kTypeClass_BinaryString;
+    return kTypeClass_Binary;
 }
 

trunk/src/VBox/Runtime/common/rest/rest-primary-object-types.cpp

@@ -32 +32 @@
 #include <iprt/cpp/restbase.h>
 
+#include <iprt/ctype.h>
 #include <iprt/err.h>
 #include <iprt/string.h>
@@ -1156 +1157 @@
 
 /*********************************************************************************************************************************
+*   RTCRestDate implementation                                                                                                   *
+*********************************************************************************************************************************/
+
+RTCRestDate::RTCRestDate()
+    : RTCRestObjectBase()
+    , m_fTimeSpecOkay(false)
+    , m_enmFormat(kFormat_Invalid)
+    , m_strFormatted()
+{
+    RTTimeSpecSetNano(&m_TimeSpec, 0);
+    RT_ZERO(m_Exploded);
+
+    /* Since we need to know the format, all date-time values default to 'null'. */
+    m_fNullIndicator = true;
+}
+
+
+RTCRestDate::RTCRestDate(RTCRestDate const &a_rThat)
+    : RTCRestObjectBase(a_rThat)
+    , m_fTimeSpecOkay(a_rThat.m_fTimeSpecOkay)
+    , m_enmFormat(a_rThat.m_enmFormat)
+    , m_strFormatted(a_rThat.m_strFormatted)
+{
+    m_TimeSpec = a_rThat.m_TimeSpec;
+    m_Exploded = a_rThat.m_Exploded;
+}
+
+
+RTCRestDate::~RTCRestDate()
+{
+    /* nothing to do */
+}
+
+
+RTCRestDate &RTCRestDate::operator=(RTCRestDate const &a_rThat)
+{
+    RTCRestObjectBase::operator=(a_rThat);
+    m_TimeSpec      = a_rThat.m_TimeSpec;
+    m_Exploded      = a_rThat.m_Exploded;
+    m_fTimeSpecOkay = a_rThat.m_fTimeSpecOkay;
+    m_enmFormat     = a_rThat.m_enmFormat;
+    m_strFormatted  = a_rThat.m_strFormatted;
+    return *this;
+}
+
+
+int RTCRestDate::assignCopy(RTCRestDate const &a_rThat)
+{
+    m_fNullIndicator = a_rThat.m_fNullIndicator;
+    m_TimeSpec       = a_rThat.m_TimeSpec;
+    m_Exploded       = a_rThat.m_Exploded;
+    m_fTimeSpecOkay  = a_rThat.m_fTimeSpecOkay;
+    m_enmFormat      = a_rThat.m_enmFormat;
+    return m_strFormatted.assignNoThrow(a_rThat.m_strFormatted);
+}
+
+
+int RTCRestDate::resetToDefault()
+{
+    m_fNullIndicator = true;
+    RTTimeSpecSetNano(&m_TimeSpec, 0);
+    RT_ZERO(m_Exploded);
+    m_fTimeSpecOkay = false;
+    m_strFormatted.setNull();
+    /*m_enmFormat - leave as hint. */
+    return VINF_SUCCESS;
+}
+
+
+RTCRestOutputBase &RTCRestDate::serializeAsJson(RTCRestOutputBase &a_rDst) const
+{
+    if (m_fNullIndicator)
+        a_rDst.printf("null");
+    else
+        a_rDst.printf("%RMjs", m_strFormatted.c_str());
+    return a_rDst;
+}
+
+
+int RTCRestDate::deserializeFromJson(RTCRestJsonCursor const &a_rCursor)
+{
+    RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue);
+    if (enmType == RTJSONVALTYPE_STRING)
+    {
+        int rc = m_strFormatted.assignNoThrow(RTJsonValueGetString(a_rCursor.m_hValue));
+        AssertRCReturn(rc, rc);
+
+        m_fNullIndicator = false;
+        rc = decodeFormattedString(m_enmFormat);
+        if (RT_SUCCESS(rc))
+            return rc;
+        if (m_enmFormat != kFormat_Invalid)
+        {
+            rc = decodeFormattedString();
+            if (RT_SUCCESS(rc))
+                return rc;
+        }
+        return a_rCursor.m_pPrimary->addError(a_rCursor, VWRN_REST_UNABLE_TO_DECODE_DATE,
+                                              "Unable to decode date value: %s", m_strFormatted.c_str());
+    }
+
+    if (enmType == RTJSONVALTYPE_NULL)
+    {
+        setNull();
+        return VINF_SUCCESS;
+    }
+
+    return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type for date: %s",
+                                          RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue)));
+}
+
+
+int RTCRestDate::toString(RTCString *a_pDst, uint32_t a_fFlags /*= 0*/) const
+{
+    if (m_fNullIndicator)
+    {
+        if (a_fFlags & kToString_Append)
+            return a_pDst->appendNoThrow(RT_STR_TUPLE("null"));
+        return a_pDst->assignNoThrow(RT_STR_TUPLE("null"));
+    }
+    if (a_fFlags & kToString_Append)
+        return a_pDst->appendNoThrow(m_strFormatted);
+    return a_pDst->assignNoThrow(m_strFormatted);
+}
+
+
+int RTCRestDate::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/,
+                            uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/)
+{
+    if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive))
+    {
+        setNull();
+        return VINF_SUCCESS;
+    }
+
+    int rc = m_strFormatted.assignNoThrow(a_rValue);
+    AssertRCReturn(rc, rc);
+
+    m_fNullIndicator = false;
+    rc = decodeFormattedString(m_enmFormat);
+    if (RT_SUCCESS(rc))
+        return rc;
+    if (m_enmFormat != kFormat_Invalid)
+    {
+        rc = decodeFormattedString();
+        if (RT_SUCCESS(rc))
+            return rc;
+    }
+    RT_NOREF(a_fFlags);
+    return RTErrInfoSetF(a_pErrInfo, VERR_REST_UNABLE_TO_DECODE_DATE,
+                         "Unable to decode date value (%s): %s", a_pszName, m_strFormatted.c_str());
+}
+
+
+RTCRestObjectBase::kTypeClass RTCRestDate::typeClass(void) const
+{
+    return kTypeClass_Date;
+}
+
+
+const char *RTCRestDate::typeName(void) const
+{
+    return "RTCRestDate";
+}
+
+
+/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestDate::createInstance(void)
+{
+    return new (std::nothrow) RTCRestDate();
+}
+
+int RTCRestDate::assignValue(PCRTTIMESPEC a_pTimeSpec, kFormat a_enmFormat)
+{
+    AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER);
+    AssertReturn(a_enmFormat > kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER);
+
+    m_TimeSpec = *a_pTimeSpec;
+    return explodeAndFormat(a_enmFormat);
+}
+
+
+int RTCRestDate::assignValueRfc2822(PCRTTIMESPEC a_pTimeSpec)
+{
+    AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER);
+    m_TimeSpec = *a_pTimeSpec;
+    return explodeAndFormat(kFormat_Rfc2822);
+}
+
+
+int RTCRestDate::assignValueRfc7131(PCRTTIMESPEC a_pTimeSpec)
+{
+    AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER);
+    m_TimeSpec = *a_pTimeSpec;
+    return explodeAndFormat(kFormat_Rfc7131);
+}
+
+
+int RTCRestDate::assignValueRfc3339(PCRTTIMESPEC a_pTimeSpec)
+{
+    AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER);
+    m_TimeSpec = *a_pTimeSpec;
+    return explodeAndFormat(kFormat_Rfc3339);
+}
+
+
+int RTCRestDate::assignNow(kFormat a_enmFormat)
+{
+    RTTIMESPEC Now;
+    return assignValue(RTTimeNow(&Now), a_enmFormat);
+}
+
+
+int RTCRestDate::assignNowRfc2822()
+{
+    RTTIMESPEC Now;
+    return assignValueRfc2822(RTTimeNow(&Now));
+}
+
+
+int RTCRestDate::assignNowRfc7131()
+{
+    RTTIMESPEC Now;
+    return assignValueRfc7131(RTTimeNow(&Now));
+}
+
+
+int RTCRestDate::assignNowRfc3339()
+{
+    RTTIMESPEC Now;
+    return assignValueRfc3339(RTTimeNow(&Now));
+}
+
+
+int RTCRestDate::setFormat(kFormat a_enmFormat)
+{
+    /*
+     * If this is a null object, just set the format as a hint for upcoming deserialization.
+     */
+    if (m_fNullIndicator)
+    {
+        AssertReturn(a_enmFormat >= kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER);
+        m_enmFormat = a_enmFormat;
+        return VINF_SUCCESS;
+    }
+
+    /*
+     * If the tiem spec is okay, just reformat the string value accordingly.
+     */
+    if (m_fTimeSpecOkay)
+    {
+        AssertReturn(a_enmFormat > kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER);
+        if (a_enmFormat ==  m_enmFormat)
+            return VINF_SUCCESS;
+        return format(a_enmFormat);
+    }
+
+    /*
+     * Try decode
+     */
+    AssertReturn(a_enmFormat > kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER);
+    return decodeFormattedString(a_enmFormat);
+}
+
+
+int RTCRestDate::explodeAndFormat(kFormat a_enmFormat)
+{
+    RTTimeExplode(&m_Exploded, &m_TimeSpec);
+    return format(a_enmFormat);
+}
+
+
+/**
+ * Formats the m_Exploded value.
+ *
+ * Sets m_strFormatted, m_fTimeSpecOkay, and m_enmFormat, clears m_fNullIndicator.
+ *
+ * @returns VINF_SUCCESS or VERR_NO_STR_MEMORY.
+ * @param   a_enmFormat The format to use.
+ */
+int RTCRestDate::format(kFormat a_enmFormat)
+{
+    m_fNullIndicator = true;
+    m_enmFormat = a_enmFormat;
+    int rc;
+    switch (a_enmFormat)
+    {
+        case kFormat_Rfc2822:
+        case kFormat_Rfc7131:
+            rc = m_strFormatted.reserveNoThrow(RTTIME_RFC2822_LEN);
+            AssertRCReturn(rc, rc);
+            RTTimeToRfc2822(&m_Exploded, m_strFormatted.mutableRaw(), m_strFormatted.capacity(),
+                            a_enmFormat == kFormat_Rfc7131 ? RTTIME_RFC2822_F_GMT : 0);
+            m_strFormatted.jolt();
+            return VINF_SUCCESS;
+
+        case kFormat_Rfc3339:
+        case kFormat_Rfc3339_Fraction_2:
+        case kFormat_Rfc3339_Fraction_3:
+        case kFormat_Rfc3339_Fraction_6:
+        case kFormat_Rfc3339_Fraction_9:
+            rc = m_strFormatted.reserveNoThrow(RTTIME_STR_LEN);
+            AssertRCReturn(rc, rc);
+            RTTimeToStringEx(&m_Exploded, m_strFormatted.mutableRaw(), m_strFormatted.capacity(),
+                             a_enmFormat == kFormat_Rfc3339 ? 0
+                             : a_enmFormat == kFormat_Rfc3339_Fraction_2 ? 2
+                             : a_enmFormat == kFormat_Rfc3339_Fraction_3 ? 3
+                             : a_enmFormat == kFormat_Rfc3339_Fraction_6 ? 6 : 9);
+            m_strFormatted.jolt();
+            return VINF_SUCCESS;
+
+        /* no default */
+        case kFormat_Invalid:
+        case kFormat_End:
+            break;
+    }
+    AssertFailedReturn(VERR_REST_INTERNAL_ERROR_7);
+}
+
+
+/**
+ * Internal worker that attempts to decode m_strFormatted.
+ *
+ * Sets m_fTimeSpecOkay.
+ *
+ * @returns IPRT status code.
+ * @param   enmFormat   Specific format to try, kFormat_Invalid (default) to try guess it.
+ */
+int RTCRestDate::decodeFormattedString(kFormat enmFormat /*= kFormat_Invalid*/)
+{
+    /*
+     * Take empty string to mean null.
+     */
+    const char *pszTmp = RTStrStripL(m_strFormatted.c_str());
+    if (*pszTmp == '\0')
+    {
+        setNull();
+        return VINF_SUCCESS;
+    }
+
+    switch (enmFormat)
+    {
+        case kFormat_Invalid:
+        {
+            size_t cch = strlen(pszTmp);
+            if (cch >= 6)
+            {
+                if (   !RT_C_IS_DIGIT(pszTmp[0])
+                    || RT_C_IS_SPACE(pszTmp[5])
+                    || RT_C_IS_SPACE(pszTmp[2])
+                    || RT_C_IS_SPACE(pszTmp[1])
+                    || RT_C_IS_SPACE(pszTmp[3])
+                    || RT_C_IS_SPACE(pszTmp[4]))
+                    return decodeFormattedString(kFormat_Rfc2822);
+                return decodeFormattedString(kFormat_Rfc3339);
+            }
+            return VERR_REST_UNABLE_TO_DECODE_DATE;
+        }
+
+        /*
+         * Examples:
+         *      Fri, 31 Aug 2018 00:00:00 +0200
+         *      Mon, 3 Sep 2018 00:00:00 GMT
+         *      Mon, 3 Sep 2018 00:00:00 -0000
+         *      3 Sep 2018 00:00:00 -0000 (?)
+         *      3 Sep 2018 00:00:00 GMT   (?)
+         */
+        case kFormat_Rfc2822:
+        case kFormat_Rfc7131:
+            if (RTTimeFromRfc2822(&m_Exploded, pszTmp))
+            {
+                RTTimeImplode(&m_TimeSpec, &m_Exploded);
+
+                pszTmp = strchr(pszTmp, '\0');
+                if (pszTmp[-1] == 'T' || pszTmp[-1] == 't')
+                    m_enmFormat = kFormat_Rfc7131;
+                else
+                    m_enmFormat = kFormat_Rfc2822;
+                m_fTimeSpecOkay = true;
+                return VINF_SUCCESS;
+            }
+            return VERR_REST_UNABLE_TO_DECODE_DATE;
+
+        /*
+         * Examples:
+         *      2018-08-31T00:00:00+0200
+         *      2018-09-03T00:00:00Z
+         *      2018-09-03T00:00:00+0000
+         *      2018-09-03T00:00:00.123456789Z
+         */
+        case kFormat_Rfc3339:
+        case kFormat_Rfc3339_Fraction_2:
+        case kFormat_Rfc3339_Fraction_3:
+        case kFormat_Rfc3339_Fraction_6:
+        case kFormat_Rfc3339_Fraction_9:
+            if (RTTimeFromString(&m_Exploded, pszTmp))
+            {
+                RTTimeImplode(&m_TimeSpec, &m_Exploded);
+
+                pszTmp = strchr(pszTmp, '.');
+                if (!pszTmp)
+                    m_enmFormat = kFormat_Rfc3339;
+                else
+                {
+                    size_t cchFraction = 0;
+                    pszTmp++;
+                    while (RT_C_IS_DIGIT(pszTmp[cchFraction]))
+                        cchFraction++;
+                    if (cchFraction == 0)
+                        m_enmFormat = kFormat_Rfc3339;
+                    else if (cchFraction <= 2)
+                        m_enmFormat = kFormat_Rfc3339_Fraction_2;
+                    else if (cchFraction <= 3)
+                        m_enmFormat = kFormat_Rfc3339_Fraction_3;
+                    else if (cchFraction <= 6)
+                        m_enmFormat = kFormat_Rfc3339_Fraction_6;
+                    else
+                        m_enmFormat = kFormat_Rfc3339_Fraction_9;
+                }
+                m_fTimeSpecOkay = true;
+                return VINF_SUCCESS;
+            }
+            return VERR_REST_UNABLE_TO_DECODE_DATE;
+
+        /* no default */
+        case kFormat_End:
+            break;
+    }
+    AssertFailedReturn(VERR_INVALID_PARAMETER);
+}
+
+
+/*********************************************************************************************************************************
 *   RTCRestStringEnumBase implementation                                                                                         *
 *********************************************************************************************************************************/