VirtualBox

Changeset 49028 in vbox


Ignore:
Timestamp:
Oct 10, 2013 12:55:06 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
89794
Message:

iprt/cpp/xml: Fixed attribute lookup with namespace by doing the same way as for elements. Also renamed the two methods with namespace prefix and name in the 'logical' order so they can safely be changed to the order dictated C++ default parameter value handling (name first, then optionally ns-prefix), like the rest.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/cpp/xml.h

    r48862 r49028  
    399399    const char *getPrefix() const;
    400400    const char *getNamespaceURI() const;
    401     bool nameEquals(const char *pcszNamespace, const char *pcsz) const;
     401    bool nameEqualsNS(const char *pcszNamespace, const char *pcsz) const;
    402402    bool nameEquals(const char *pcsz) const
    403403    {
    404         return nameEquals(NULL, pcsz);
    405     }
    406     bool nameEqualsN(const char *pcszNamespace, const char *pcsz, size_t cchMax) const;
     404        return nameEqualsNS(NULL, pcsz);
     405    }
     406    bool nameEqualsN(const char *pcsz, size_t cchMax, const char *pcszNamespace = NULL) const;
    407407
    408408    const char *getValue() const;
    … …  
    534534    AttributeNode(const AttributeNode &x);      // no copying
    535535
    536     /** For storing attribute names with namespace prefix.
    537      * Only used if with non-default namespace specified. */
    538     RTCString    m_strKey;
    539 
    540536    friend class Node;
    541537    friend class ElementNode;
    … …  
    557553{
    558554public:
    559     int getChildElements(ElementNodesList &children,
    560                          const char *pcszMatch = NULL) const;
    561 
    562     const ElementNode *findChildElement(const char *pcszNamespace,
    563                                         const char *pcszMatch) const;
     555    int getChildElements(ElementNodesList &children, const char *pcszMatch = NULL) const;
     556
     557    const ElementNode *findChildElementNS(const char *pcszNamespace, const char *pcszMatch) const;
    564558    const ElementNode *findChildElement(const char *pcszMatch) const
    565559    {
    566         return findChildElement(NULL, pcszMatch);
     560        return findChildElementNS(NULL, pcszMatch);
    567561    }
    568562    const ElementNode *findChildElementFromId(const char *pcszId) const;
    … …  
    610604     *                              (default) match any namespace.  When using a
    611605     *                              path, this matches all elements along the way.
     606     * @param   pcszAttribNamespace The namespace prefix to apply to the attribute,
     607     *                              NULL (default) match any namespace.
    612608     * @see     findChildElementP and findAttributeValue
    613609     */
    614610    const char *findChildElementAttributeValueP(const char *pcszPath, const char *pcszAttribute,
    615                                                 const char *pcszPathNamespace = NULL) const
     611                                                const char *pcszPathNamespace = NULL,
     612                                                const char *pcszAttributeNamespace = NULL) const
    616613    {
    617614        const ElementNode *pElem = findChildElementP(pcszPath, pcszPathNamespace);
    618615        if (pElem)
    619             return pElem->findAttributeValue(pcszAttribute);
     616            return pElem->findAttributeValue(pcszAttribute, pcszAttributeNamespace);
    620617        return NULL;
    621618    }
    … …  
    695692
    696693
    697     const AttributeNode *findAttribute(const char *pcszMatch) const;
     694    const AttributeNode *findAttribute(const char *pcszMatch, const char *pcszNamespace = NULL) const;
    698695    /** Find the first attribute with the given name, returning its value string.
    699696     * @returns Pointer to the attribute string value.
    700697     * @param   pcszName        The attribute name.
     698     * @param   pcszNamespace   The namespace name, default is NULL which means
     699     *                          anything goes.
    701700     * @see getAttributeValue
    702701     */
    703     const char *findAttributeValue(const char *pcszName) const
    704     {
    705         const AttributeNode *pAttr = findAttribute(pcszName);
     702    const char *findAttributeValue(const char *pcszName, const char *pcszNamespace = NULL) const
     703    {
     704        const AttributeNode *pAttr = findAttribute(pcszName, pcszNamespace);
    706705        if (pAttr)
    707706            return pAttr->getValue();
    … …  
    709708    }
    710709
    711     bool getAttributeValue(const char *pcszMatch, const char *&pcsz) const  { return getAttributeValue(pcszMatch, &pcsz); }
    712     bool getAttributeValue(const char *pcszMatch, RTCString &str) const;
    713     bool getAttributeValuePath(const char *pcszMatch, RTCString &str) const;
    714     bool getAttributeValue(const char *pcszMatch, int32_t &i) const;
    715     bool getAttributeValue(const char *pcszMatch, uint32_t &i) const;
    716     bool getAttributeValue(const char *pcszMatch, int64_t &i) const         { return getAttributeValue(pcszMatch, &i); }
    717     bool getAttributeValue(const char *pcszMatch, uint64_t &i) const;
    718     bool getAttributeValue(const char *pcszMatch, bool &f) const;
     710    bool getAttributeValue(const char *pcszMatch, const char *&pcsz, const char *pcszNamespace = NULL) const
     711    { return getAttributeValue(pcszMatch, &pcsz, pcszNamespace); }
     712    bool getAttributeValue(const char *pcszMatch, RTCString &str, const char *pcszNamespace = NULL) const
     713    { return getAttributeValue(pcszMatch, &str, pcszNamespace); }
     714    bool getAttributeValuePath(const char *pcszMatch, RTCString &str, const char *pcszNamespace = NULL) const
     715    { return getAttributeValue(pcszMatch, &str, pcszNamespace); }
     716    bool getAttributeValue(const char *pcszMatch, int32_t &i, const char *pcszNamespace = NULL) const
     717    { return getAttributeValue(pcszMatch, &i, pcszNamespace); }
     718    bool getAttributeValue(const char *pcszMatch, uint32_t &i, const char *pcszNamespace = NULL) const
     719    { return getAttributeValue(pcszMatch, &i, pcszNamespace); }
     720    bool getAttributeValue(const char *pcszMatch, int64_t &i, const char *pcszNamespace = NULL) const
     721    { return getAttributeValue(pcszMatch, &i, pcszNamespace); }
     722    bool getAttributeValue(const char *pcszMatch, uint64_t &u, const char *pcszNamespace = NULL) const
     723    { return getAttributeValue(pcszMatch, &u, pcszNamespace); }
     724    bool getAttributeValue(const char *pcszMatch, bool &f, const char *pcszNamespace = NULL) const
     725    { return getAttributeValue(pcszMatch, &f, pcszNamespace); }
    719726
    720727    /** @name Variants that for clarity does not use references for output params.
    721728     * @{ */
    722     bool getAttributeValue(const char *pcszMatch, const char **ppcsz) const;
    723     bool getAttributeValue(const char *pcszMatch, RTCString *pStr) const    { return getAttributeValue(pcszMatch, *pStr); }
    724     bool getAttributeValuePath(const char *pcszMatch, RTCString *pStr) const { return getAttributeValuePath(pcszMatch, *pStr); }
    725     bool getAttributeValue(const char *pcszMatch, int32_t *pi) const        { return getAttributeValue(pcszMatch, *pi); }
    726     bool getAttributeValue(const char *pcszMatch, uint32_t *pu) const       { return getAttributeValue(pcszMatch, *pu); }
    727     bool getAttributeValue(const char *pcszMatch, int64_t *piValue) const;
    728     bool getAttributeValue(const char *pcszMatch, uint64_t *pu) const       { return getAttributeValue(pcszMatch, *pu); }
    729     bool getAttributeValue(const char *pcszMatch, bool *pf) const           { return getAttributeValue(pcszMatch, *pf); }
     729    bool getAttributeValue(const char *pcszMatch, const char **ppcsz, const char *pcszNamespace = NULL) const;
     730    bool getAttributeValue(const char *pcszMatch, RTCString *pStr, const char *pcszNamespace = NULL) const;
     731    bool getAttributeValuePath(const char *pcszMatch, RTCString *pStr, const char *pcszNamespace = NULL) const;
     732    bool getAttributeValue(const char *pcszMatch, int32_t *pi, const char *pcszNamespace = NULL) const;
     733    bool getAttributeValue(const char *pcszMatch, uint32_t *pu, const char *pcszNamespace = NULL) const;
     734    bool getAttributeValue(const char *pcszMatch, int64_t *piValue, const char *pcszNamespace = NULL) const;
     735    bool getAttributeValue(const char *pcszMatch, uint64_t *pu, const char *pcszNamespace = NULL) const;
     736    bool getAttributeValue(const char *pcszMatch, bool *pf, const char *pcszNamespace = NULL) const;
    730737    /** @} */
    731738

  • trunk/src/VBox/Main/xml/Settings.cpp

    r48983 r49028  
    493493            // <ExtraDataItem name="GUI/LastWindowPostion" value="97,88,981,858"/>
    494494            Utf8Str strName, strValue;
    495             if (    ((pelmExtraDataItem->getAttributeValue("name", strName)))
    496                  && ((pelmExtraDataItem->getAttributeValue("value", strValue)))
    497                )
     495            if (   pelmExtraDataItem->getAttributeValue("name", strName)
     496                && pelmExtraDataItem->getAttributeValue("value", strValue) )
    498497                map[strName] = strValue;
    499498            else
    … …  
    521520        flt.action = USBDeviceFilterAction_Ignore;
    522521        Utf8Str strAction;
    523         if (    (pelmLevel4Child->getAttributeValue("name", flt.strName))
    524              && (pelmLevel4Child->getAttributeValue("active", flt.fActive))
    525            )
     522        if (   pelmLevel4Child->getAttributeValue("name", flt.strName)
     523            && pelmLevel4Child->getAttributeValue("active", flt.fActive))
    526524        {
    527525            if (!pelmLevel4Child->getAttributeValue("vendorId", flt.strVendorId))
    … …  
    576574    settings::Medium med;
    577575    Utf8Str strUUID;
    578     if (!(elmMedium.getAttributeValue("uuid", strUUID)))
     576    if (!elmMedium.getAttributeValue("uuid", strUUID))
    579577        throw ConfigFileError(this, &elmMedium, N_("Required %s/@uuid attribute is missing"), elmMedium.getName());
    580578
    … …  
    669667
    670668        if (med.strFormat.isEmpty())        // not set with 1.4 format above, or 1.4 Custom format?
    671             if (!(elmMedium.getAttributeValue("format", med.strFormat)))
     669            if (!elmMedium.getAttributeValue("format", med.strFormat))
    672670                throw ConfigFileError(this, &elmMedium, N_("Required %s/@format attribute is missing"), elmMedium.getName());
    673671
    674         if (!(elmMedium.getAttributeValue("autoReset", med.fAutoReset)))
     672        if (!elmMedium.getAttributeValue("autoReset", med.fAutoReset))
    675673            med.fAutoReset = false;
    676674
    677675        Utf8Str strType;
    678         if ((elmMedium.getAttributeValue("type", strType)))
     676        if (elmMedium.getAttributeValue("type", strType))
    679677        {
    680678            // pre-1.4 used lower case, so make this case-insensitive
    … …  
    701699        {
    702700            // DVD and floppy images before 1.4 had "src" attribute instead of "location"
    703             if (!(elmMedium.getAttributeValue("src", med.strLocation)))
     701            if (!elmMedium.getAttributeValue("src", med.strLocation))
    704702                throw ConfigFileError(this, &elmMedium, N_("Required %s/@src attribute is missing"), elmMedium.getName());
    705703
    … …  
    707705        }
    708706
    709         if (!(elmMedium.getAttributeValue("format", med.strFormat)))
     707        if (!elmMedium.getAttributeValue("format", med.strFormat))
    710708        {
    711709            // DVD and floppy images before 1.11 had no format attribute. assign the default.
    … …  
    721719    if (fNeedsLocation)
    722720        // current files and 1.4 CustomHardDisk elements must have a location attribute
    723         if (!(elmMedium.getAttributeValue("location", med.strLocation)))
     721        if (!elmMedium.getAttributeValue("location", med.strLocation))
    724722            throw ConfigFileError(this, &elmMedium, N_("Required %s/@location attribute is missing"), elmMedium.getName());
    725723
    … …  
    745743        {
    746744            Utf8Str strPropName, strPropValue;
    747             if (    (pelmHDChild->getAttributeValue("name", strPropName))
    748                  && (pelmHDChild->getAttributeValue("value", strPropValue))
    749                )
     745            if (   pelmHDChild->getAttributeValue("name", strPropName)
     746                && pelmHDChild->getAttributeValue("value", strPropValue) )
    750747                med.properties[strPropName] = strPropValue;
    751748            else
    … …  
    13021299            MachineRegistryEntry mre;
    13031300            Utf8Str strUUID;
    1304             if (    ((pelmChild1->getAttributeValue("uuid", strUUID)))
    1305                  && ((pelmChild1->getAttributeValue("src", mre.strSettingsFile)))
    1306                )
     1301            if (   pelmChild1->getAttributeValue("uuid", strUUID)
     1302                && pelmChild1->getAttributeValue("src", mre.strSettingsFile) )
    13071303            {
    13081304                parseUUID(mre.uuid, strUUID);
    … …  
    13281324        {
    13291325            DHCPServer srv;
    1330             if (    (pelmServer->getAttributeValue("networkName", srv.strNetworkName))
    1331                  && (pelmServer->getAttributeValue("IPAddress", srv.strIPAddress))
    1332                     && (pelmServer->getAttributeValue("networkMask", srv.GlobalDhcpOptions[DhcpOpt_SubnetMask]))
    1333                  && (pelmServer->getAttributeValue("lowerIP", srv.strIPLower))
    1334                  && (pelmServer->getAttributeValue("upperIP", srv.strIPUpper))
    1335                  && (pelmServer->getAttributeValue("enabled", srv.fEnabled))
    1336                )
     1326            if (   pelmServer->getAttributeValue("networkName", srv.strNetworkName)
     1327                && pelmServer->getAttributeValue("IPAddress", srv.strIPAddress)
     1328                && pelmServer->getAttributeValue("networkMask", srv.GlobalDhcpOptions[DhcpOpt_SubnetMask])
     1329                && pelmServer->getAttributeValue("lowerIP", srv.strIPLower)
     1330                && pelmServer->getAttributeValue("upperIP", srv.strIPUpper)
     1331                && pelmServer->getAttributeValue("enabled", srv.fEnabled) )
    13371332            {
    13381333                xml::NodesLoop nlOptions(*pelmServer, "Options");
    … …  
    13511346                    uint32_t u32Slot;
    13521347                    cfg->getAttributeValue("vm-name", strVmName);
    1353                     cfg->getAttributeValue("slot", (uint32_t&)u32Slot);
    1354                     readDhcpOptions(srv.VmSlot2OptionsM[VmNameSlotKey(strVmName, u32Slot)],
    1355                                    *cfg);
     1348                    cfg->getAttributeValue("slot", u32Slot);
     1349                    readDhcpOptions(srv.VmSlot2OptionsM[VmNameSlotKey(strVmName, u32Slot)], *cfg);
    13561350                }
    13571351                llDhcpServers.push_back(srv);
    … …  
    13681362    xml::NodesLoop nl2(options, "Option");
    13691363    const xml::ElementNode *opt;
    1370     while((opt = nl2.forAllNodes()))
     1364    while ((opt = nl2.forAllNodes()))
    13711365    {
    13721366        DhcpOpt_T OptName;
    … …  
    13791373        opt->getAttributeValue("value", OptValue);
    13801374
    1381         map.insert(
    1382           std::map<DhcpOpt_T, Utf8Str>::value_type(OptName, OptValue));
     1375        map.insert(std::map<DhcpOpt_T, Utf8Str>::value_type(OptName, OptValue));
    13831376    } /* end of forall("Option") */
    13841377
    … …  
    13981391        {
    13991392            NATNetwork net;
    1400             if (    (pelmNet->getAttributeValue("networkName", net.strNetworkName))
    1401                  && (pelmNet->getAttributeValue("enabled", net.fEnabled))
    1402                  && (pelmNet->getAttributeValue("network", net.strNetwork))
    1403                  && (pelmNet->getAttributeValue("ipv6", net.fIPv6))
    1404                  && (pelmNet->getAttributeValue("ipv6prefix", net.strIPv6Prefix))
    1405                  && (pelmNet->getAttributeValue("advertiseDefaultIPv6Route", net.fAdvertiseDefaultIPv6Route))
    1406                  && (pelmNet->getAttributeValue("needDhcp", net.fNeedDhcpServer))
    1407                )
     1393            if (   pelmNet->getAttributeValue("networkName", net.strNetworkName)
     1394                && pelmNet->getAttributeValue("enabled", net.fEnabled)
     1395                && pelmNet->getAttributeValue("network", net.strNetwork)
     1396                && pelmNet->getAttributeValue("ipv6", net.fIPv6)
     1397                && pelmNet->getAttributeValue("ipv6prefix", net.strIPv6Prefix)
     1398                && pelmNet->getAttributeValue("advertiseDefaultIPv6Route", net.fAdvertiseDefaultIPv6Route)
     1399                && pelmNet->getAttributeValue("needDhcp", net.fNeedDhcpServer) )
    14081400            {
    14091401                pelmNet->getAttributeValue("loopback6", net.u32HostLoopback6Offset);
    … …  
    23792371        readNATForwardRuleList(elmMode, nic.nat.llRules);
    23802372    }
    2381     else if (   (elmMode.nameEquals("HostInterface"))
    2382              || (elmMode.nameEquals("BridgedInterface")))
     2373    else if (   elmMode.nameEquals("HostInterface")
     2374             || elmMode.nameEquals("BridgedInterface"))
    23832375    {
    23842376        enmAttachmentType = NetworkAttachmentType_Bridged;
    … …  
    24142406            {
    24152407                Utf8Str strPropName, strPropValue;
    2416                 if (    (pelmModeChild->getAttributeValue("name", strPropName))
    2417                      && (pelmModeChild->getAttributeValue("value", strPropValue))
    2418                    )
     2408                if (   pelmModeChild->getAttributeValue("name", strPropName)
     2409                    && pelmModeChild->getAttributeValue("value", strPropValue) )
    24192410                    nic.genericProperties[strPropName] = strPropValue;
    24202411                else
    … …  
    29582949                        /* <Property name="TCP/Ports" value="3000-3002"/> */
    29592950                        Utf8Str strName, strValue;
    2960                         if (    ((pelmProperty->getAttributeValue("name", strName)))
    2961                              && ((pelmProperty->getAttributeValue("value", strValue)))
    2962                            )
     2951                        if (   pelmProperty->getAttributeValue("name", strName)
     2952                            && pelmProperty->getAttributeValue("value", strValue))
    29632953                            hw.vrdeSettings.mapProperties[strName] = strValue;
    29642954                        else
    … …  
    30062996            // legacy BIOS/IDEController (pre 1.7)
    30072997            if (    (m->sv < SettingsVersion_v1_7)
    3008                  && ((pelmBIOSChild = pelmHwChild->findChildElement("IDEController")))
     2998                 && (pelmBIOSChild = pelmHwChild->findChildElement("IDEController"))
    30092999               )
    30103000            {
    … …  
    30923082                readUSBDeviceFilters(*pelmUSBChild, hw.usbSettings.llDeviceFilters);
    30933083        }
    3094         else if (    (m->sv < SettingsVersion_v1_7)
    3095                   && (pelmHwChild->nameEquals("SATAController"))
    3096                 )
     3084        else if (   m->sv < SettingsVersion_v1_7
     3085                 && pelmHwChild->nameEquals("SATAController"))
    30973086        {
    30983087            bool f;
    3099             if (    (pelmHwChild->getAttributeValue("enabled", f))
    3100                  && (f)
    3101                )
     3088            if (   pelmHwChild->getAttributeValue("enabled", f)
     3089                && f)
    31023090            {
    31033091                StorageController sctl;
    … …  
    31163104        {
    31173105            Utf8Str strLocalOrUTC;
    3118             machineUserData.fRTCUseUTC =    pelmHwChild->getAttributeValue("localOrUTC", strLocalOrUTC)
    3119                                          && strLocalOrUTC == "UTC";
    3120         }
    3121         else if (    (pelmHwChild->nameEquals("UART"))
    3122                   || (pelmHwChild->nameEquals("Uart"))      // used before 1.3
     3106            machineUserData.fRTCUseUTC = pelmHwChild->getAttributeValue("localOrUTC", strLocalOrUTC)
     3107                                      && strLocalOrUTC == "UTC";
     3108        }
     3109        else if (    pelmHwChild->nameEquals("UART")
     3110                  || pelmHwChild->nameEquals("Uart")      // used before 1.3
    31233111                )
    31243112            readSerialPorts(*pelmHwChild, hw.llSerialPorts);
    3125         else if (    (pelmHwChild->nameEquals("LPT"))
    3126                   || (pelmHwChild->nameEquals("Lpt"))       // used before 1.3
     3113        else if (    pelmHwChild->nameEquals("LPT")
     3114                  || pelmHwChild->nameEquals("Lpt")       // used before 1.3
    31273115                )
    31283116            readParallelPorts(*pelmHwChild, hw.llParallelPorts);
    … …  
    32263214                }
    32273215            }
    3228         }  else if (pelmHwChild->nameEquals("HostPci")) {
     3216        }
     3217        else if (pelmHwChild->nameEquals("HostPci"))
     3218        {
    32293219            const xml::ElementNode *pelmDevices;
    32303220
    … …  
    35373527            const xml::ElementNode *pDriveChild;
    35383528            Utf8Str strTmp;
    3539             if (    ((pDriveChild = pelmHwChild->findChildElement("Image")))
    3540                  && (pDriveChild->getAttributeValue("uuid", strTmp))
    3541                )
     3529            if (   (pDriveChild = pelmHwChild->findChildElement("Image")) != NULL
     3530                && pDriveChild->getAttributeValue("uuid", strTmp))
    35423531                parseUUID(att.uuid, strTmp);
    35433532            else if ((pDriveChild = pelmHwChild->findChildElement("HostDrive")))
    … …  
    35673556        {
    35683557            bool fEnabled;
    3569             if (    (pelmHwChild->getAttributeValue("enabled", fEnabled))
    3570                  && (fEnabled)
    3571                )
     3558            if (   pelmHwChild->getAttributeValue("enabled", fEnabled)
     3559                && fEnabled)
    35723560            {
    35733561                // create a new floppy controller and attach a floppy "attached device"
    … …  
    35853573                const xml::ElementNode *pDriveChild;
    35863574                Utf8Str strTmp;
    3587                 if (    ((pDriveChild = pelmHwChild->findChildElement("Image")))
    3588                      && (pDriveChild->getAttributeValue("uuid", strTmp))
    3589                    )
     3575                if (   (pDriveChild = pelmHwChild->findChildElement("Image"))
     3576                    && pDriveChild->getAttributeValue("uuid", strTmp) )
    35903577                    parseUUID(att.uuid, strTmp);
    35913578                else if ((pDriveChild = pelmHwChild->findChildElement("HostDrive")))
    … …  
    37343721        if (pelmSnapshotChild->nameEquals("Description"))
    37353722            snap.strDescription = pelmSnapshotChild->getValue();
    3736         else if (    (m->sv < SettingsVersion_v1_7)
    3737                   && (pelmSnapshotChild->nameEquals("HardDiskAttachments"))
    3738                 )
     3723        else if (   m->sv < SettingsVersion_v1_7
     3724                 && pelmSnapshotChild->nameEquals("HardDiskAttachments"))
    37393725            readHardDiskAttachments_pre1_7(*pelmSnapshotChild, snap.storage);
    3740         else if (    (m->sv >= SettingsVersion_v1_7)
    3741                   && (pelmSnapshotChild->nameEquals("StorageControllers"))
    3742                 )
     3726        else if (   m->sv >= SettingsVersion_v1_7
     3727                 && pelmSnapshotChild->nameEquals("StorageControllers"))
    37433728            readStorageControllers(*pelmSnapshotChild, snap.storage);
    37443729        else if (pelmSnapshotChild->nameEquals("Snapshots"))
    … …  
    38373822{
    38383823    Utf8Str strUUID;
    3839     if (    (elmMachine.getAttributeValue("uuid", strUUID))
    3840          && (elmMachine.getAttributeValue("name", machineUserData.strName))
    3841        )
     3824    if (   elmMachine.getAttributeValue("uuid", strUUID)
     3825        && elmMachine.getAttributeValue("name", machineUserData.strName))
    38423826    {
    38433827        parseUUID(uuid, strUUID);

  • trunk/src/VBox/Main/xml/ovfreader.cpp

    r48009 r49028  
    9191    }
    9292
    93     if ((pTypeAttr = pRootElem->findAttribute("xml:lang")))
     93    if ((pTypeAttr = pRootElem->findAttribute("lang", "xml")))
    9494    {
    9595        pcszTypeAttr = pTypeAttr->getValue();
    … …  
    135135        const char *pcszTypeAttr = "";
    136136        const xml::AttributeNode *pTypeAttr;
    137         if (    ((pTypeAttr = pElem->findAttribute("xsi:type")))
    138              || ((pTypeAttr = pElem->findAttribute("type")))
     137        if (    (pTypeAttr = pElem->findAttribute("type", "xsi")) != NULL
     138             || (pTypeAttr = pElem->findAttribute("type")) != NULL
    139139           )
    140140            pcszTypeAttr = pTypeAttr->getValue();
    … …  
    231231
    232232            // optional vbox:uuid attribute (if OVF was exported by VirtualBox != 3.2)
    233             pelmDisk->getAttributeValue("vbox:uuid", d.uuidVbox);
     233            pelmDisk->getAttributeValue("uuid", d.uuidVbox, "vbox");
    234234
    235235            const char *pcszFileRef;
    … …  
    335335    // peek under the <VirtualSystem> node whether we have a <vbox:Machine> node;
    336336    // that case case, the caller can completely ignore the OVF but only load the VBox machine XML
    337     vsys.pelmVboxMachine = pelmVirtualSystem->findChildElement("vbox", "Machine");
     337    vsys.pelmVboxMachine = pelmVirtualSystem->findChildElementNS("vbox", "Machine");
    338338
    339339    // now look for real OVF
    … …  
    351351        {
    352352            const xml::AttributeNode *pTypeAttr;
    353             if (    ((pTypeAttr = pelmThis->findAttribute("type")))
    354                  || ((pTypeAttr = pelmThis->findAttribute("xsi:type")))
     353            if (    (pTypeAttr = pelmThis->findAttribute("type")) != NULL
     354                 || (pTypeAttr = pelmThis->findAttribute("type", "xsi")) != NULL
    355355               )
    356356                pcszTypeAttr = pTypeAttr->getValue();
    … …  
    813813
    814814            const xml::ElementNode *pelmVBoxOSType;
    815             if ((pelmVBoxOSType = pelmThis->findChildElement("vbox",            // namespace
    816                                                              "OSType")))        // element name
     815            if ((pelmVBoxOSType = pelmThis->findChildElementNS("vbox",            // namespace
     816                                                               "OSType")))        // element name
    817817                vsys.strTypeVbox = pelmVBoxOSType->getValue();
    818818        }

  • trunk/src/VBox/Runtime/common/zip/xarvfs.cpp

    r48868 r49028  
    19261926                    xml::ElementNode const *pTocElem  = NULL;
    19271927                    if (pRootElem && pRootElem->nameEquals("xar"))
    1928                         pTocElem = pRootElem ? pRootElem->findChildElement(NULL, "toc") : NULL;
     1928                        pTocElem = pRootElem ? pRootElem->findChildElement("toc") : NULL;
    19291929                    if (pTocElem)
    19301930                    {

  • trunk/src/VBox/Runtime/r3/xml.cpp

    r48935 r49028  
    484484 * @return
    485485 */
    486 bool Node::nameEquals(const char *pcszNamespace, const char *pcsz) const
     486bool Node::nameEqualsNS(const char *pcszNamespace, const char *pcsz) const
    487487{
    488488    if (m_pcszName == pcsz)
    … …  
    508508 * Variant of nameEquals that checks the namespace as well.
    509509 *
    510  * @return  true if equal, false if not.
    511  * @param   pcszNamespace   The name space prefix or NULL.
     510 * @returns true if equal, false if not.
    512511 * @param   pcsz            The element name.
    513512 * @param   cchMax          The maximum number of character from @a pcsz to
    514513 *                          match.
    515  */
    516 bool Node::nameEqualsN(const char *pcszNamespace, const char *pcsz, size_t cchMax) const
     514 * @param   pcszNamespace   The name space prefix or NULL (default).
     515 */
     516bool Node::nameEqualsN(const char *pcsz, size_t cchMax, const char *pcszNamespace /* = NULL*/) const
    517517{
    518518    /* Match the name. */
    … …  
    793793 * @return
    794794 */
    795 const ElementNode *ElementNode::findChildElement(const char *pcszNamespace, const char *pcszMatch) const
     795const ElementNode *ElementNode::findChildElementNS(const char *pcszNamespace, const char *pcszMatch) const
    796796{
    797797    Node *p;
    … …  
    801801        {
    802802            ElementNode *pelm = static_cast<ElementNode*>(p);
    803             if (pelm->nameEquals(pcszNamespace, pcszMatch))
     803            if (pelm->nameEqualsNS(pcszNamespace, pcszMatch))
    804804                return pelm;
    805805        }
    … …  
    834834    size_t cchThis = strchr(pcszPath, '/') - pcszPath;
    835835    if (cchThis == (size_t)((const char *)0 - pcszPath))
    836         return this->findChildElement(pcszNamespace, pcszPath);
     836        return findChildElementNS(pcszNamespace, pcszPath);
    837837
    838838    /** @todo Can be done without recursion as we have both sibling lists and parent
    … …  
    844844        {
    845845            const ElementNode *pElm = static_cast<const ElementNode *>(p);
    846             if (pElm->nameEqualsN(pcszNamespace, pcszPath, cchThis))
     846            if (pElm->nameEqualsN(pcszPath, cchThis, pcszNamespace))
    847847            {
    848848                pElm = findChildElementP(pcszPath + cchThis, pcszNamespace);
    … …  
    921921        {
    922922            const ElementNode *pElem = static_cast<const ElementNode *>(pSibling);
    923             if (pElem->nameEquals(pcszNamespace, pcszMatch))
     923            if (pElem->nameEqualsNS(pcszNamespace, pcszMatch))
    924924                return pElem;
    925925        }
    … …  
    940940        {
    941941            const ElementNode *pElem = static_cast<const ElementNode *>(pSibling);
    942             if (pElem->nameEquals(pcszNamespace, pcszMatch))
     942            if (pElem->nameEqualsNS(pcszNamespace, pcszMatch))
    943943                return pElem;
    944944        }
    … …  
    950950 * Looks up the given attribute node in this element's attribute map.
    951951 *
    952  * With respect to namespaces, the internal attributes map stores namespace
    953  * prefixes with attribute names only if the attribute uses a non-default
    954  * namespace. As a result, the following rules apply:
    955  *
    956  *  -- To find attributes from a non-default namespace, pcszMatch must not
    957  *     be prefixed with a namespace.
    958  *
    959  *  -- To find attributes from the default namespace (or if the document does
    960  *     not use namespaces), pcszMatch must be prefixed with the namespace
    961  *     prefix and a colon.
    962  *
    963  * For example, if the document uses the "vbox:" namespace by default, you
    964  * must omit "vbox:" from pcszMatch to find such attributes, whether they
    965  * are specifed in the xml or not.
    966  *
    967  * @param pcszMatch
    968  * @return
    969  */
    970 const AttributeNode *ElementNode::findAttribute(const char *pcszMatch) const
     952 * @param   pcszMatch       The name of the attribute to find.
     953 * @param   pcszNamespace   The attribute name space prefix or NULL.
     954 */
     955const AttributeNode *ElementNode::findAttribute(const char *pcszMatch, const char *pcszNamespace /*= NULL*/) const
    971956{
    972957    AttributeNode *p;
    973958    RTListForEachCpp(&m_attributes, p, AttributeNode, m_listEntry)
    974959    {
    975         if (p->nameEquals(pcszMatch))
     960        if (p->nameEqualsNS(pcszNamespace, pcszMatch))
    976961            return p;
    977962    }
    … …  
    983968 * name and returns its value as a string.
    984969 *
    985  * @param   pcszMatch   Name of attribute to find (see findAttribute() for
    986  *                      namespace remarks).
    987  * @param   ppcsz       Where to return the attribute.
     970 * @param   pcszMatch       Name of attribute to find.
     971 * @param   ppcsz           Where to return the attribute.
     972 * @param   pcszNamespace   The attribute name space prefix or NULL.
    988973 * @returns Boolean success indicator.
    989974 */
    990 bool ElementNode::getAttributeValue(const char *pcszMatch, const char **ppcsz) const
    991 {
    992     const AttributeNode *pAttr = findAttribute(pcszMatch);
     975bool ElementNode::getAttributeValue(const char *pcszMatch, const char **ppcsz, const char *pcszNamespace /*= NULL*/) const
     976{
     977    const AttributeNode *pAttr = findAttribute(pcszMatch, pcszNamespace);
    993978    if (pAttr)
    994979    {
    … …  
    1003988 * name and returns its value as a string.
    1004989 *
    1005  * @param   pcszMatch   Name of attribute to find (see findAttribute() for
    1006  *                      namespace remarks).
    1007  * @param   rStr        Reference to the string object that should receive the
    1008  *                      attribute value.
     990 * @param   pcszMatch       Name of attribute to find.
     991 * @param   pStr            Pointer to the string object that should receive the
     992 *                          attribute value.
     993 * @param   pcszNamespace   The attribute name space prefix or NULL.
    1009994 * @returns Boolean success indicator.
    1010995 *
    1011996 * @throws  Whatever the string class may throw on assignment.
    1012997 */
    1013 bool ElementNode::getAttributeValue(const char *pcszMatch, RTCString &rStr) const
    1014 {
    1015     const AttributeNode *pAttr = findAttribute(pcszMatch);
     998bool ElementNode::getAttributeValue(const char *pcszMatch, RTCString *pStr, const char *pcszNamespace /*= NULL*/) const
     999{
     1000    const AttributeNode *pAttr = findAttribute(pcszMatch, pcszNamespace);
    10161001    if (pAttr)
    10171002    {
    1018         rStr = pAttr->getValue();
     1003        *pStr = pAttr->getValue();
    10191004        return true;
    10201005    }
    … …  
    10261011 * Like getAttributeValue (ministring variant), but makes sure that all backslashes
    10271012 * are converted to forward slashes.
    1028  * @param pcszMatch
    1029  * @param str
    1030  * @return
    1031  */
    1032 bool ElementNode::getAttributeValuePath(const char *pcszMatch, RTCString &str) const
    1033 {
    1034     if (getAttributeValue(pcszMatch, str))
    1035     {
    1036         str.findReplace('\\', '/');
     1013 *
     1014 * @param   pcszMatch       Name of attribute to find.
     1015 * @param   pStr            Pointer to the string object that should
     1016 *                          receive the attribute path value.
     1017 * @param   pcszNamespace   The attribute name space prefix or NULL.
     1018 * @returns Boolean success indicator.
     1019 */
     1020bool ElementNode::getAttributeValuePath(const char *pcszMatch, RTCString *pStr, const char *pcszNamespace /*= NULL*/) const
     1021{
     1022    if (getAttributeValue(pcszMatch, pStr, pcszNamespace))
     1023    {
     1024        pStr->findReplace('\\', '/');
    10371025        return true;
    10381026    }
    … …  
    10431031/**
    10441032 * Convenience method which attempts to find the attribute with the given
    1045  * name and returns its value as a signed integer. This calls
    1046  * RTStrToInt32Ex internally and will only output the integer if that
    1047  * function returns no error.
    1048  *
    1049  * @param pcszMatch name of attribute to find (see findAttribute() for namespace remarks)
    1050  * @param i out: attribute value; overwritten only if attribute was found
    1051  * @return TRUE if attribute was found and str was thus updated.
    1052  */
    1053 bool ElementNode::getAttributeValue(const char *pcszMatch, int32_t &i) const
    1054 {
    1055     const char *pcsz;
    1056     if (    (getAttributeValue(pcszMatch, pcsz))
    1057          && (VINF_SUCCESS == RTStrToInt32Ex(pcsz, NULL, 0, &i))
    1058        )
    1059         return true;
    1060 
     1033 * name and returns its value as a signed 32-bit integer.
     1034 *
     1035 * @param   pcszMatch       Name of attribute to find.
     1036 * @param   piValue         Where to return the value.
     1037 * @param   pcszNamespace   The attribute name space prefix or NULL.
     1038 * @returns Boolean success indicator.
     1039 */
     1040bool ElementNode::getAttributeValue(const char *pcszMatch, int32_t *piValue, const char *pcszNamespace /*= NULL*/) const
     1041{
     1042    const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
     1043    if (pcsz)
     1044    {
     1045        int rc = RTStrToInt32Ex(pcsz, NULL, 0, piValue);
     1046        if (rc == VINF_SUCCESS)
     1047            return true;
     1048    }
    10611049    return false;
    10621050}
    … …  
    10641052/**
    10651053 * Convenience method which attempts to find the attribute with the given
    1066  * name and returns its value as an unsigned integer.This calls
    1067  * RTStrToUInt32Ex internally and will only output the integer if that
    1068  * function returns no error.
    1069  *
    1070  * @param pcszMatch name of attribute to find (see findAttribute() for namespace remarks)
    1071  * @param i out: attribute value; overwritten only if attribute was found
    1072  * @return TRUE if attribute was found and str was thus updated.
    1073  */
    1074 bool ElementNode::getAttributeValue(const char *pcszMatch, uint32_t &i) const
    1075 {
    1076     const char *pcsz;
    1077     if (    (getAttributeValue(pcszMatch, pcsz))
    1078          && (VINF_SUCCESS == RTStrToUInt32Ex(pcsz, NULL, 0, &i))
    1079        )
    1080         return true;
    1081 
     1054 * name and returns its value as an unsigned 32-bit integer.
     1055 *
     1056 * @param   pcszMatch       Name of attribute to find.
     1057 * @param   puValue         Where to return the value.
     1058 * @param   pcszNamespace   The attribute name space prefix or NULL.
     1059 * @returns Boolean success indicator.
     1060 */
     1061bool ElementNode::getAttributeValue(const char *pcszMatch, uint32_t *puValue, const char *pcszNamespace /*= NULL*/) const
     1062{
     1063    const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
     1064    if (pcsz)
     1065    {
     1066        int rc = RTStrToUInt32Ex(pcsz, NULL, 0, puValue);
     1067        if (rc == VINF_SUCCESS)
     1068            return true;
     1069    }
    10821070    return false;
    10831071}
    … …  
    10851073/**
    10861074 * Convenience method which attempts to find the attribute with the given
    1087  * name and returns its value as a signed long integer. This calls
    1088  * RTStrToInt64Ex internally and will only output the integer if that
    1089  * function returns no error.
    1090  *
    1091  * @param   pcszMatch   Name of attribute to find (see findAttribute() for
    1092  *                      namespace remarks).
    1093  * @param   i           Where to return the attribute value on success.
     1075 * name and returns its value as a signed 64-bit integer.
     1076 *
     1077 * @param   pcszMatch       Name of attribute to find.
     1078 * @param   piValue         Where to return the value.
     1079 * @param   pcszNamespace   The attribute name space prefix or NULL.
    10941080 * @returns Boolean success indicator.
    10951081 */
    1096 bool ElementNode::getAttributeValue(const char *pcszMatch, int64_t *piValue) const
    1097 {
    1098     const char *pcsz = findAttributeValue(pcszMatch);
     1082bool ElementNode::getAttributeValue(const char *pcszMatch, int64_t *piValue, const char *pcszNamespace /*= NULL*/) const
     1083{
     1084    const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
    10991085    if (pcsz)
    11001086    {
    … …  
    11081094/**
    11091095 * Convenience method which attempts to find the attribute with the given
    1110  * name and returns its value as an unsigned long integer.This calls
    1111  * RTStrToUInt64Ex internally and will only output the integer if that
    1112  * function returns no error.
    1113  *
    1114  * @param pcszMatch name of attribute to find (see findAttribute() for namespace remarks)
    1115  * @param i out: attribute value; overwritten only if attribute was found
    1116  * @return TRUE if attribute was found and str was thus updated.
    1117  */
    1118 bool ElementNode::getAttributeValue(const char *pcszMatch, uint64_t &i) const
    1119 {
    1120     const char *pcsz;
    1121     if (    (getAttributeValue(pcszMatch, pcsz))
    1122          && (VINF_SUCCESS == RTStrToUInt64Ex(pcsz, NULL, 0, &i))
    1123        )
    1124         return true;
    1125 
     1096 * name and returns its value as an unsigned 64-bit integer.
     1097 *
     1098 * @param   pcszMatch       Name of attribute to find.
     1099 * @param   puValue         Where to return the value.
     1100 * @param   pcszNamespace   The attribute name space prefix or NULL.
     1101 * @returns Boolean success indicator.
     1102 */
     1103bool ElementNode::getAttributeValue(const char *pcszMatch, uint64_t *puValue, const char *pcszNamespace /*= NULL*/) const
     1104{
     1105    const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
     1106    if (pcsz)
     1107    {
     1108        int rc = RTStrToUInt64Ex(pcsz, NULL, 0, puValue);
     1109        if (rc == VINF_SUCCESS)
     1110            return true;
     1111    }
    11261112    return false;
    11271113}
    … …  
    11321118 * "yes", "no", "1" or "0" as valid values.
    11331119 *
    1134  * @param pcszMatch name of attribute to find (see findAttribute() for namespace remarks)
    1135  * @param f out: attribute value; overwritten only if attribute was found
    1136  * @return TRUE if attribute was found and str was thus updated.
    1137  */
    1138 bool ElementNode::getAttributeValue(const char *pcszMatch, bool &f) const
    1139 {
    1140     const char *pcsz;
    1141     if (getAttributeValue(pcszMatch, pcsz))
     1120 * @param   pcszMatch       Name of attribute to find.
     1121 * @param   pfValue         Where to return the value.
     1122 * @param   pcszNamespace   The attribute name space prefix or NULL.
     1123 * @returns Boolean success indicator.
     1124 */
     1125bool ElementNode::getAttributeValue(const char *pcszMatch, bool *pfValue, const char *pcszNamespace /*= NULL*/) const
     1126{
     1127    const char *pcsz = findAttributeValue(pcszMatch, pcszNamespace);
     1128    if (pcsz)
    11421129    {
    11431130        if (   !strcmp(pcsz, "true")
    … …  
    11461133           )
    11471134        {
    1148             f = true;
     1135            *pfValue = true;
    11491136            return true;
    11501137        }
    … …  
    11541141           )
    11551142        {
    1156             f = false;
     1143            *pfValue = false;
    11571144            return true;
    11581145        }
    … …  
    14831470        m_pcszNamespacePrefix = (const char *)pLibAttr->ns->prefix;
    14841471        m_pcszNamespaceHref   = (const char *)pLibAttr->ns->href;
    1485 
    1486         if (   !pElmRoot->m_pcszNamespaceHref
    1487             || strcmp(m_pcszNamespaceHref, pElmRoot->m_pcszNamespaceHref))
    1488         {
    1489             // not default namespace:
    1490             m_strKey = m_pcszNamespacePrefix;
    1491             m_strKey.append(':');
    1492             m_strKey.append(m_pcszName);
    1493         }
    14941472    }
    14951473}
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