VirtualBox

Changeset 74013 in vbox


Ignore:
Timestamp:
Aug 31, 2018 8:57:59 PM (6 years ago)
Author:
vboxsync
Message:

IPRT/rest: Added parameter based api methods (constructs Request objects themselves). More on the null subject. Misc. bugref:9167

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/iprt/cpp/restbase.h

    r74009 r74013  
    404404    /** Safe copy assignment method. */
    405405    int assignCopy(RTCRestBool const &a_rThat);
     406    /** Assign value and clear null indicator. */
     407    void assignValue(bool a_fValue);
    406408
    407409    /* Overridden methods: */
     
    434436    RTCRestInt64(RTCRestInt64 const &a_rThat);
    435437    /** From value constructor. */
    436     RTCRestInt64(int64_t iValue);
     438    RTCRestInt64(int64_t a_iValue);
    437439    /** Destructor. */
    438440    virtual ~RTCRestInt64();
     
    441443    /** Safe copy assignment method. */
    442444    int assignCopy(RTCRestInt64 const &a_rThat);
     445    /** Assign value and clear null indicator. */
     446    void assignValue(int64_t a_iValue);
    443447
    444448    /* Overridden methods: */
     
    478482    /** Safe copy assignment method. */
    479483    int assignCopy(RTCRestInt32 const &a_rThat);
     484    /** Assign value and clear null indicator. */
     485    void assignValue(int32_t a_iValue);
    480486
    481487    /* Overridden methods: */
     
    515521    /** Safe copy assignment method. */
    516522    int assignCopy(RTCRestInt16 const &a_rThat);
     523    /** Assign value and clear null indicator. */
     524    void assignValue(int16_t a_iValue);
    517525
    518526    /* Overridden methods: */
     
    552560    /** Safe copy assignment method. */
    553561    int assignCopy(RTCRestDouble const &a_rThat);
     562    /** Assign value and clear null indicator. */
     563    void assignValue(double a_rdValue);
    554564
    555565    /* Overridden methods: */
  • trunk/src/VBox/Runtime/common/rest/RTCRestClientApiBase.cpp

    r74009 r74013  
    6868    LogFlow(("doCall: %s %s\n", a_pszMethod, RTHttpMethodName(a_enmHttpMethod)));
    6969
    70     /*
    71      * Reset the response object, allowing reuse of such.
    72      */
    73     a_pResponse->reset();
    7470
    7571    /*
    76      * Initialize the HTTP instance.
     72     * Reset the response object (allowing reuse of such) and check the request
     73     * object for assignment errors.
    7774     */
     75    int    rc;
    7876    RTHTTP hHttp = NIL_RTHTTP;
    79     int rc = reinitHttpInstance();
    80     if (RT_SUCCESS(rc))
     77
     78    a_pResponse->reset();
     79    if (!a_rRequest.hasAssignmentErrors())
    8180    {
    82         hHttp = m_hHttp;
    83         Assert(hHttp != NIL_RTHTTP);
    84 
    8581        /*
    86          * Prepare the response side.  This may install output callbacks and
    87          * indicate this by clearing the ppvBody/ppvHdr variables.
     82         * Initialize the HTTP instance.
    8883         */
    89         size_t   cbHdrs  = 0;
    90         void    *pvHdrs  = NULL;
    91         void   **ppvHdrs = &pvHdrs;
    92 
    93         size_t   cbBody  = 0;
    94         void    *pvBody  = NULL;
    95         void   **ppvBody = &pvBody;
    96 
    97         rc = a_pResponse->receivePrepare(hHttp, &ppvBody, &ppvHdrs);
     84        rc = reinitHttpInstance();
    9885        if (RT_SUCCESS(rc))
    9986        {
     87            hHttp = m_hHttp;
     88            Assert(hHttp != NIL_RTHTTP);
     89
    10090            /*
    101              * Prepare the request for the transmission.
     91             * Prepare the response side.  This may install output callbacks and
     92             * indicate this by clearing the ppvBody/ppvHdr variables.
    10293             */
    103             RTCString strExtraPath;
    104             RTCString strQuery;
    105             RTCString strXmitBody;
    106             rc = a_rRequest.xmitPrepare(&strExtraPath, &strQuery, hHttp, &strXmitBody);
     94            size_t   cbHdrs  = 0;
     95            void    *pvHdrs  = NULL;
     96            void   **ppvHdrs = &pvHdrs;
     97
     98            size_t   cbBody  = 0;
     99            void    *pvBody  = NULL;
     100            void   **ppvBody = &pvBody;
     101
     102            rc = a_pResponse->receivePrepare(hHttp, &ppvBody, &ppvHdrs);
    107103            if (RT_SUCCESS(rc))
    108104            {
    109105                /*
    110                  * Construct the full URL.
     106                 * Prepare the request for the transmission.
    111107                 */
    112                 RTCString strFullUrl;
    113                 rc = strFullUrl.assignNoThrow(m_strBasePath);
    114                 if (strExtraPath.isNotEmpty())
    115                 {
    116                     if (!strExtraPath.startsWith("/") && !strFullUrl.endsWith("/") && RT_SUCCESS(rc))
    117                         rc = strFullUrl.appendNoThrow('/');
    118                     if (RT_SUCCESS(rc))
    119                         rc = strFullUrl.appendNoThrow(strExtraPath);
    120                     strExtraPath.setNull();
    121                 }
    122                 if (strQuery.isNotEmpty())
    123                 {
    124                     Assert(strQuery.startsWith("?"));
    125                     rc = strFullUrl.appendNoThrow(strQuery);
    126                     strQuery.setNull();
    127                 }
     108                RTCString strExtraPath;
     109                RTCString strQuery;
     110                RTCString strXmitBody;
     111                rc = a_rRequest.xmitPrepare(&strExtraPath, &strQuery, hHttp, &strXmitBody);
    128112                if (RT_SUCCESS(rc))
    129113                {
    130114                    /*
    131                      * Perform HTTP request.
     115                     * Construct the full URL.
    132116                     */
    133                     uint32_t uHttpStatus = 0;
    134                     rc = RTHttpPerform(hHttp, strFullUrl.c_str(), a_enmHttpMethod, strXmitBody.c_str(), strXmitBody.length(),
    135                                        &uHttpStatus, ppvHdrs, &cbHdrs, ppvBody, &cbBody);
     117                    RTCString strFullUrl;
     118                    rc = strFullUrl.assignNoThrow(m_strBasePath);
     119                    if (strExtraPath.isNotEmpty())
     120                    {
     121                        if (!strExtraPath.startsWith("/") && !strFullUrl.endsWith("/") && RT_SUCCESS(rc))
     122                            rc = strFullUrl.appendNoThrow('/');
     123                        if (RT_SUCCESS(rc))
     124                            rc = strFullUrl.appendNoThrow(strExtraPath);
     125                        strExtraPath.setNull();
     126                    }
     127                    if (strQuery.isNotEmpty())
     128                    {
     129                        Assert(strQuery.startsWith("?"));
     130                        rc = strFullUrl.appendNoThrow(strQuery);
     131                        strQuery.setNull();
     132                    }
    136133                    if (RT_SUCCESS(rc))
    137134                    {
    138                         a_rRequest.xmitComplete(uHttpStatus, hHttp);
     135                        /*
     136                         * Perform HTTP request.
     137                         */
     138                        uint32_t uHttpStatus = 0;
     139                        rc = RTHttpPerform(hHttp, strFullUrl.c_str(), a_enmHttpMethod, strXmitBody.c_str(), strXmitBody.length(),
     140                                           &uHttpStatus, ppvHdrs, &cbHdrs, ppvBody, &cbBody);
     141                        if (RT_SUCCESS(rc))
     142                        {
     143                            a_rRequest.xmitComplete(uHttpStatus, hHttp);
    139144
    140                         /*
    141                          * Do response processing.
    142                          */
    143                         a_pResponse->receiveComplete(uHttpStatus, hHttp);
    144                         if (pvHdrs)
    145                         {
    146                             a_pResponse->consumeHeaders((const char *)pvHdrs, cbHdrs);
    147                             RTHttpFreeResponse(pvHdrs);
     145                            /*
     146                             * Do response processing.
     147                             */
     148                            a_pResponse->receiveComplete(uHttpStatus, hHttp);
     149                            if (pvHdrs)
     150                            {
     151                                a_pResponse->consumeHeaders((const char *)pvHdrs, cbHdrs);
     152                                RTHttpFreeResponse(pvHdrs);
     153                            }
     154                            if (pvBody)
     155                            {
     156                                a_pResponse->consumeBody((const char *)pvBody, cbBody);
     157                                RTHttpFreeResponse(pvBody);
     158                            }
     159                            a_pResponse->receiveFinal();
     160
     161                            return a_pResponse->getStatus();
    148162                        }
    149                         if (pvBody)
    150                         {
    151                             a_pResponse->consumeBody((const char *)pvBody, cbBody);
    152                             RTHttpFreeResponse(pvBody);
    153                         }
    154                         a_pResponse->receiveFinal();
    155 
    156                         return a_pResponse->getStatus();
    157163                    }
    158164                }
     165                a_rRequest.xmitComplete(rc, hHttp);
    159166            }
    160             a_rRequest.xmitComplete(rc, hHttp);
    161167        }
    162168    }
     169    else
     170        rc = VERR_NO_MEMORY;
     171
    163172    a_pResponse->receiveComplete(rc, hHttp);
    164173    RT_NOREF_PV(a_pszMethod);
  • trunk/src/VBox/Runtime/common/rest/rest-primary-object-types.cpp

    r74008 r74013  
    176176
    177177
     178void RTCRestBool::assignValue(bool a_fValue)
     179{
     180    m_fValue = a_fValue;
     181    m_fNullIndicator = false;
     182}
     183
     184
    178185int RTCRestBool::resetToDefault()
    179186{
     
    336343
    337344
     345void RTCRestInt64::assignValue(int64_t a_iValue)
     346{
     347    m_iValue = a_iValue;
     348    m_fNullIndicator = false;
     349}
     350
     351
    338352int RTCRestInt64::resetToDefault()
    339353{
     
    491505    m_fNullIndicator = false;
    492506    return VINF_SUCCESS;
     507}
     508
     509
     510void RTCRestInt32::assignValue(int32_t a_iValue)
     511{
     512    m_iValue = a_iValue;
     513    m_fNullIndicator = false;
    493514}
    494515
     
    642663
    643664
     665void RTCRestInt16::assignValue(int16_t a_iValue)
     666{
     667    m_iValue = a_iValue;
     668    m_fNullIndicator = false;
     669}
     670
     671
    644672int RTCRestInt16::resetToDefault()
    645673{
     
    797825
    798826
     827void RTCRestDouble::assignValue(double a_rdValue)
     828{
     829    m_rdValue = a_rdValue;
     830    m_fNullIndicator = false;
     831}
     832
     833
    799834int RTCRestDouble::resetToDefault()
    800835{
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette