Changeset 73895 in vbox for trunk/src/VBox

Timestamp:

Aug 26, 2018 3:47:58 PM (6 years ago)

Author:

vboxsync

Message:

IPRT/rest: Wrap primitive types to unify serializing, deserializing, formatting, array, maps, and whatnot. bugref:9167

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• common/rest/rest-primary-object-types.cpp (moved) (moved from trunk/src/VBox/Runtime/common/rest/RTCRestObjectBase.cpp ) (8 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -543 +543 @@
         common/rand/randadv.cpp \
         common/rand/randparkmiller.cpp \
+        common/rest/rest-primary-object-types.cpp \
         common/rest/RTCRestClientApiBase.cpp \
         common/rest/RTCRestJsonPrimaryCursor.cpp \
-        common/rest/RTCRestObjectBase.cpp \
         common/rest/RTCRestOutputToString.cpp \
         common/sort/RTSortIsSorted.cpp \

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

@@ -38 +38 @@
 
 
-/*static*/ int
-RTCRestObjectBase::deserialize_RTCString_FromJson(RTCRestJsonCursor const &a_rCursor, RTCString *a_pDst)
+
+/*********************************************************************************************************************************
+*   RTCRestObjectBase implementation                                                                                             *
+*********************************************************************************************************************************/
+
+/** Default constructor. */
+RTCRestObjectBase::RTCRestObjectBase()
+{
+}
+
+
+/** Destructor. */
+RTCRestObjectBase::~RTCRestObjectBase()
+{
+    /* nothing to do */
+}
+
+
+int RTCRestObjectBase::toString(RTCString *a_pDst, uint32_t fFlags)
+{
+    Assert(fFlags == 0);
+
+    /*
+     * Just wrap the JSON serialization method.
+     */
+    RTCRestOutputToString Tmp(a_pDst);
+    serializeAsJson(Tmp);
+    return Tmp.finalize() ? VINF_SUCCESS : VERR_NO_MEMORY;
+}
+
+
+RTCString RTCRestObjectBase::toString()
+{
+    RTCString strRet;
+    toString(&strRet, 0);
+    return strRet;
+}
+
+
+
+/*********************************************************************************************************************************
+*   RTCRestBool implementation                                                                                                   *
+*********************************************************************************************************************************/
+
+/** Default destructor. */
+RTCRestBool::RTCRestBool()
+    : m_fValue(false)
+{
+}
+
+
+/** Copy constructor. */
+RTCRestBool::RTCRestBool(RTCRestBool const &a_rThat)
+    : m_fValue(a_rThat.m_fValue)
+{
+}
+
+
+/** From value constructor. */
+RTCRestBool::RTCRestBool(bool fValue)
+    : m_fValue(fValue)
+{
+}
+
+
+/** Destructor. */
+RTCRestBool::~RTCRestBool()
+{
+    /* nothing to do */
+}
+
+
+/** Copy assignment operator. */
+RTCRestBool &RTCRestBool::operator=(RTCRestBool const &a_rThat)
+{
+    m_fValue = a_rThat.m_fValue;
+    return *this;
+}
+
+
+void RTCRestBool::resetToDefault()
+{
+    m_fValue = false;
+}
+
+
+RTCRestOutputBase &RTCRestBool::serializeAsJson(RTCRestOutputBase &a_rDst)
+{
+    a_rDst.printf(m_fValue ? "true" : "false");
+    return a_rDst;
+}
+
+
+int RTCRestBool::deserializeFromJson(RTCRestJsonCursor const &a_rCursor)
 {
     RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue);
-    if (enmType == RTJSONVALTYPE_STRING)
-    {
-        const char  *pszValue = RTJsonValueGetString(a_rCursor.m_hValue);
-        const size_t cchValue = strlen(pszValue);
-        int rc = a_pDst->reserveNoThrow(cchValue + 1);
-        if (RT_SUCCESS(rc))
-        {
-            *a_pDst = pszValue;
-            return VINF_SUCCESS;
-        }
-        return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "no memory for %zu char long string", cchValue);
-    }
-
-    if (enmType == RTJSONVALTYPE_NULL) /** @todo RTJSONVALTYPE_NULL for strings??? */
-    {
-        a_pDst->setNull();
+
+    if (enmType == RTJSONVALTYPE_TRUE)
+    {
+        m_fValue = true;
         return VINF_SUCCESS;
     }
 
-    return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type %s for string",
+    if (enmType == RTJSONVALTYPE_FALSE)
+    {
+        m_fValue = false;
+        return VINF_SUCCESS;
+    }
+
+    /* This is probably non-sense... */
+    if (enmType == RTJSONVALTYPE_NULL)
+        m_fValue = false;
+
+    return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type %s for boolean",
                                           RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue)));
 }
 
 
-/*static*/ int
-RTCRestObjectBase::deserialize_int64_t_FromJson(RTCRestJsonCursor const &a_rCursor, int64_t *a_piDst)
+int RTCRestBool::toString(RTCString *a_pDst, uint32_t fFlags /*= 0*/)
+{
+    Assert(!fFlags);
+
+    /* Be a little careful here to avoid throwing anything. */
+    int rc = a_pDst->reserveNoThrow(m_fValue ? sizeof("true") : sizeof("false"));
+    if (RT_SUCCESS(rc))
+    {
+        if (m_fValue)
+            a_pDst->assign(RT_STR_TUPLE("true"));
+        else
+            a_pDst->assign(RT_STR_TUPLE("false"));
+    }
+    return rc;
+}
+
+
+const char *RTCRestBool::getType()
+{
+    return "bool";
+}
+
+
+/*********************************************************************************************************************************
+*   RTCRestInt64 implementation                                                                                                  *
+*********************************************************************************************************************************/
+
+/** Default destructor. */
+RTCRestInt64::RTCRestInt64()
+    : m_iValue(0)
+{
+}
+
+
+/** Copy constructor. */
+RTCRestInt64::RTCRestInt64(RTCRestInt64 const &a_rThat)
+    : m_iValue(a_rThat.m_iValue)
+{
+}
+
+
+/** From value constructor. */
+RTCRestInt64::RTCRestInt64(int64_t iValue)
+    : m_iValue(iValue)
+{
+}
+
+
+/** Destructor. */
+RTCRestInt64::~RTCRestInt64()
+{
+    /* nothing to do */
+}
+
+
+/** Copy assignment operator. */
+RTCRestInt64 &RTCRestInt64::operator=(RTCRestInt64 const &a_rThat)
+{
+    m_iValue = a_rThat.m_iValue;
+    return *this;
+}
+
+
+void RTCRestInt64::resetToDefault()
+{
+    m_iValue = 0;
+}
+
+
+RTCRestOutputBase &RTCRestInt64::serializeAsJson(RTCRestOutputBase &a_rDst)
+{
+    a_rDst.printf("%RI64", m_iValue);
+    return a_rDst;
+}
+
+
+int RTCRestInt64::deserializeFromJson(RTCRestJsonCursor const &a_rCursor)
 {
     RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue);
     if (enmType == RTJSONVALTYPE_NUMBER)
     {
-        int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, a_piDst);
+        int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, &m_iValue);
         if (RT_SUCCESS(rc))
             return rc;
@@ -80 +245 @@
     /* This is probably non-sense... */
     if (enmType == RTJSONVALTYPE_NULL || enmType == RTJSONVALTYPE_FALSE)
-        *a_piDst = 0;
+        m_iValue = 0;
     else if (enmType == RTJSONVALTYPE_TRUE)
-        *a_piDst = 1;
+        m_iValue = 1;
 
     return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type %s for 64-bit integer",
@@ -89 +254 @@
 
 
-/*static*/ int
-RTCRestObjectBase::deserialize_int32_t_FromJson(RTCRestJsonCursor const &a_rCursor, int32_t *a_piDst)
+int RTCRestInt64::toString(RTCString *a_pDst, uint32_t fFlags /*= 0*/)
+{
+    Assert(!fFlags);
+
+    /* Be a little careful here to avoid throwing anything. */
+    char   szValue[64];
+    size_t cchValue = RTStrPrintf(szValue, sizeof(szValue), "%RI64", m_iValue);
+    int rc = a_pDst->reserveNoThrow(cchValue + 1);
+    if (RT_SUCCESS(rc))
+        a_pDst->assign(szValue, cchValue);
+    return rc;
+}
+
+
+const char *RTCRestInt64::getType()
+{
+    return "int64_t";
+}
+
+
+
+/*********************************************************************************************************************************
+*   RTCRestInt32 implementation                                                                                                  *
+*********************************************************************************************************************************/
+
+/** Default destructor. */
+RTCRestInt32::RTCRestInt32()
+    : m_iValue(0)
+{
+}
+
+
+/** Copy constructor. */
+RTCRestInt32::RTCRestInt32(RTCRestInt32 const &a_rThat)
+    : m_iValue(a_rThat.m_iValue)
+{
+}
+
+
+/** From value constructor. */
+RTCRestInt32::RTCRestInt32(int32_t iValue)
+    : m_iValue(iValue)
+{
+}
+
+
+/** Destructor. */
+RTCRestInt32::~RTCRestInt32()
+{
+    /* nothing to do */
+}
+
+
+/** Copy assignment operator. */
+RTCRestInt32 &RTCRestInt32::operator=(RTCRestInt32 const &a_rThat)
+{
+    m_iValue = a_rThat.m_iValue;
+    return *this;
+}
+
+
+void RTCRestInt32::resetToDefault()
+{
+    m_iValue = 0;
+}
+
+
+RTCRestOutputBase &RTCRestInt32::serializeAsJson(RTCRestOutputBase &a_rDst)
+{
+    a_rDst.printf("%RI32", m_iValue);
+    return a_rDst;
+}
+
+
+int RTCRestInt32::deserializeFromJson(RTCRestJsonCursor const &a_rCursor)
 {
     RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue);
     if (enmType == RTJSONVALTYPE_NUMBER)
     {
-        int64_t iTmp = *a_piDst;
+        int64_t iTmp = m_iValue;
         int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, &iTmp);
         if (RT_SUCCESS(rc))
         {
-            *a_piDst = (int32_t)iTmp;
-            if (*a_piDst == iTmp)
+            m_iValue = (int32_t)iTmp;
+            if (m_iValue == iTmp)
                 return rc;
             return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_OUT_OF_RANGE, "value %RI64 does not fit in 32 bits", iTmp);
@@ -109 +347 @@
     /* This is probably non-sense... */
     if (enmType == RTJSONVALTYPE_NULL || enmType == RTJSONVALTYPE_FALSE)
-        *a_piDst = 0;
+        m_iValue = 0;
     else if (enmType == RTJSONVALTYPE_TRUE)
-        *a_piDst = 1;
+        m_iValue = 1;
 
     return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type %s for 32-bit integer",
@@ -118 +356 @@
 
 
-/*static*/ int
-RTCRestObjectBase::deserialize_int16_t_FromJson(RTCRestJsonCursor const &a_rCursor, int16_t *a_piDst)
+int RTCRestInt32::toString(RTCString *a_pDst, uint32_t fFlags /*= 0*/)
+{
+    Assert(!fFlags);
+
+    /* Be a little careful here to avoid throwing anything. */
+    char   szValue[16];
+    size_t cchValue = RTStrPrintf(szValue, sizeof(szValue), "%RI32", m_iValue);
+    int rc = a_pDst->reserveNoThrow(cchValue + 1);
+    if (RT_SUCCESS(rc))
+        a_pDst->assign(szValue, cchValue);
+    return rc;
+}
+
+
+const char *RTCRestInt32::getType()
+{
+    return "int32_t";
+}
+
+
+
+/*********************************************************************************************************************************
+*   RTCRestInt16 implementation                                                                                                  *
+*********************************************************************************************************************************/
+
+/** Default destructor. */
+RTCRestInt16::RTCRestInt16()
+    : m_iValue(0)
+{
+}
+
+
+/** Copy constructor. */
+RTCRestInt16::RTCRestInt16(RTCRestInt16 const &a_rThat)
+    : m_iValue(a_rThat.m_iValue)
+{
+}
+
+
+/** From value constructor. */
+RTCRestInt16::RTCRestInt16(int16_t iValue)
+    : m_iValue(iValue)
+{
+}
+
+
+/** Destructor. */
+RTCRestInt16::~RTCRestInt16()
+{
+    /* nothing to do */
+}
+
+
+/** Copy assignment operator. */
+RTCRestInt16 &RTCRestInt16::operator=(RTCRestInt16 const &a_rThat)
+{
+    m_iValue = a_rThat.m_iValue;
+    return *this;
+}
+
+
+void RTCRestInt16::resetToDefault()
+{
+    m_iValue = 0;
+}
+
+
+RTCRestOutputBase &RTCRestInt16::serializeAsJson(RTCRestOutputBase &a_rDst)
+{
+    a_rDst.printf("%RI16", m_iValue);
+    return a_rDst;
+}
+
+
+int RTCRestInt16::deserializeFromJson(RTCRestJsonCursor const &a_rCursor)
 {
     RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue);
     if (enmType == RTJSONVALTYPE_NUMBER)
     {
-        int64_t iTmp = *a_piDst;
+        int64_t iTmp = m_iValue;
         int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, &iTmp);
         if (RT_SUCCESS(rc))
         {
-            *a_piDst = (int16_t)iTmp;
-            if (*a_piDst == iTmp)
+            m_iValue = (int16_t)iTmp;
+            if (m_iValue == iTmp)
                 return rc;
             return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_OUT_OF_RANGE, "value %RI64 does not fit in 16 bits", iTmp);
@@ -138 +449 @@
     /* This is probably non-sense... */
     if (enmType == RTJSONVALTYPE_NULL || enmType == RTJSONVALTYPE_FALSE)
-        *a_piDst = 0;
+        m_iValue = 0;
     else if (enmType == RTJSONVALTYPE_TRUE)
-        *a_piDst = 1;
+        m_iValue = 1;
 
     return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type %s for 16-bit integer",
@@ -147 +458 @@
 
 
-/*static*/ int
-RTCRestObjectBase::deserialize_bool_FromJson(RTCRestJsonCursor const &a_rCursor, bool *pfDst)
-{
-    RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue);
-
-    if (enmType == RTJSONVALTYPE_TRUE)
-    {
-        *pfDst = true;
-        return VINF_SUCCESS;
-    }
-
-    if (enmType == RTJSONVALTYPE_FALSE)
-    {
-        *pfDst = false;
-        return VINF_SUCCESS;
-    }
-
-    /* This is probably non-sense... */
-    if (enmType == RTJSONVALTYPE_NULL)
-        *pfDst = false;
-
-    return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type %s for boolean",
-                                          RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue)));
-}
-
-
-/*static*/ int
-RTCRestObjectBase::deserialize_double_FromJson(RTCRestJsonCursor const &a_rCursor, double *a_prdDst)
+int RTCRestInt16::toString(RTCString *a_pDst, uint32_t fFlags /*= 0*/)
+{
+    Assert(!fFlags);
+
+    /* Be a little careful here to avoid throwing anything. */
+    char   szValue[8];
+    size_t cchValue = RTStrPrintf(szValue, sizeof(szValue), "%RI16", m_iValue);
+    int rc = a_pDst->reserveNoThrow(cchValue + 1);
+    if (RT_SUCCESS(rc))
+        a_pDst->assign(szValue, cchValue);
+    return rc;
+}
+
+
+const char *RTCRestInt16::getType()
+{
+    return "int16_t";
+}
+
+
+
+/*********************************************************************************************************************************
+*   RTCRestDouble implementation                                                                                                 *
+*********************************************************************************************************************************/
+
+/** Default destructor. */
+RTCRestDouble::RTCRestDouble()
+    : m_rdValue(0.0)
+{
+}
+
+
+/** Copy constructor. */
+RTCRestDouble::RTCRestDouble(RTCRestDouble const &a_rThat)
+    : m_rdValue(a_rThat.m_rdValue)
+{
+}
+
+
+/** From value constructor. */
+RTCRestDouble::RTCRestDouble(double rdValue)
+    : m_rdValue(rdValue)
+{
+}
+
+
+/** Destructor. */
+RTCRestDouble::~RTCRestDouble()
+{
+    /* nothing to do */
+}
+
+
+void RTCRestDouble::resetToDefault()
+{
+    m_rdValue = 0.0;
+}
+
+
+RTCRestOutputBase &RTCRestDouble::serializeAsJson(RTCRestOutputBase &a_rDst)
+{
+    /* Just a simple approximation here. */
+    /** @todo implement floating point values for json. */
+    char szValue[128];
+#ifdef _MSC_VER
+    _snprintf(szValue, sizeof(szValue), "%g", m_rdValue);
+#else
+    snprintf(szValue, sizeof(szValue), "%g", m_rdValue);
+#endif
+    a_rDst.printf("%s", szValue);
+    return a_rDst;
+}
+
+
+int RTCRestDouble::deserializeFromJson(RTCRestJsonCursor const &a_rCursor)
 {
     AssertMsgFailed(("RTJson needs to be taught double values."));
-    RT_NOREF(a_prdDst);
     /** @todo implement floating point values for json. */
     return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NOT_IMPLEMENTED, "double is not supported yet");
@@ -183 +540 @@
 
 
-/*static*/ RTCRestOutputBase &
-RTCRestObjectBase::serialize_double_AsJson(RTCRestOutputBase &a_rDst, double const *a_prdValue)
-{
+int RTCRestDouble::toString(RTCString *a_pDst, uint32_t fFlags /*= 0*/)
+{
+    Assert(!fFlags);
+
     /* Just a simple approximation here. */
     /** @todo implement floating point values for json. */
-    double const rdValue = *a_prdValue;
-    char szTmp[128];
+    char szValue[128];
 #ifdef _MSC_VER
-    _snprintf(szTmp, sizeof(szTmp), "%g", rdValue);
+    _snprintf(szValue, sizeof(szValue), "%g", m_rdValue);
 #else
-    snprintf(szTmp, sizeof(szTmp), "%g", rdValue);
+    snprintf(szValue, sizeof(szValue), "%g", m_rdValue);
 #endif
-    a_rDst.printf("%s", szTmp);
+    size_t const cchValue = strlen(szValue);
+
+    int rc = a_pDst->reserveNoThrow(cchValue + 1);
+    if (RT_SUCCESS(rc))
+        a_pDst->assign(szValue, cchValue);
+    return rc;
+}
+
+
+const char *RTCRestDouble::getType()
+{
+    return "double";
+}
+
+
+
+/*********************************************************************************************************************************
+*   RTCRestString implementation                                                                                                 *
+*********************************************************************************************************************************/
+
+/** Default destructor. */
+RTCRestString::RTCRestString()
+    : RTCString()
+{
+}
+
+
+/** Copy constructor. */
+RTCRestString::RTCRestString(RTCRestString const &a_rThat)
+    : RTCString(a_rThat)
+{
+}
+
+
+/** From value constructor. */
+RTCRestString::RTCRestString(RTCString const &a_rThat)
+    : RTCString(a_rThat)
+{
+}
+
+
+/** From value constructor. */
+RTCRestString::RTCRestString(const char *a_pszSrc)
+    : RTCString(a_pszSrc)
+{
+}
+
+
+/** Destructor. */
+RTCRestString::~RTCRestString()
+{
+    /* nothing to do */
+}
+
+
+void RTCRestString::resetToDefault()
+{
+    setNull();
+}
+
+
+RTCRestOutputBase &RTCRestString::serializeAsJson(RTCRestOutputBase &a_rDst)
+{
+    a_rDst.printf("%RJs", m_psz);
     return a_rDst;
 }
 
+
+int RTCRestString::deserializeFromJson(RTCRestJsonCursor const &a_rCursor)
+{
+    RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue);
+    if (enmType == RTJSONVALTYPE_STRING)
+    {
+        const char  *pszValue = RTJsonValueGetString(a_rCursor.m_hValue);
+        const size_t cchValue = strlen(pszValue);
+        int rc = reserveNoThrow(cchValue + 1);
+        if (RT_SUCCESS(rc))
+        {
+            assign(pszValue, cchValue);
+            return VINF_SUCCESS;
+        }
+        return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "no memory for %zu char long string", cchValue);
+    }
+
+    if (enmType == RTJSONVALTYPE_NULL) /** @todo RTJSONVALTYPE_NULL for strings??? */
+    {
+        setNull();
+        return VINF_SUCCESS;
+    }
+
+    return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "wrong JSON type %s for string",
+                                          RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue)));
+}
+
+
+int RTCRestString::toString(RTCString *a_pDst, uint32_t fFlags /*= 0*/)
+{
+    Assert(!fFlags);
+
+    /* Careful as always. */
+    if (m_cch)
+    {
+        int rc = a_pDst->reserveNoThrow(m_cch + 1);
+        if (RT_SUCCESS(rc))
+        { /* likely */ }
+        else
+            return rc;
+    }
+    a_pDst->assign(*this);
+    return VINF_SUCCESS;
+}
+
+
+const char *RTCRestString::getType()
+{
+    return "RTCString";
+}
+