VirtualBox

Changeset 33294 in vbox


Ignore:
Timestamp:
Oct 21, 2010 10:45:26 AM (14 years ago)
Author:
vboxsync
Message:

Main: API change, merge IVirtualBox::getMachine() with findMachine()

Location:
trunk
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/doc/manual/en_US/SDKRef.xml

    r33238 r33294  
    34263426
    34273427        <listitem>
    3428           <para>IVirtualBox::unregisterMachine was replaced with <xref
     3428          <para>To reduce code duplication and for consistency with the
     3429          aforementioned changes, IVirtualBox::getMachine() has been merged
     3430          with <xref linkend="IVirtualBox__findMachine"
     3431          xreflabel="IVirtualBox::findMachine()" />.</para>
     3432        </listitem>
     3433
     3434        <listitem>
     3435          <para>IVirtualBox::unregisterMachine() was replaced with <xref
    34293436          linkend="IMachine__unregister" xreflabel="IMachine::unregister()" />
    34303437          with additional functionality.</para>
    … …  
    34503457          xreflabel="IGuest::additionsVersion()" /> no longer returns the
    34513458          Guest Additions interface version but the installed Guest Additions
    3452           version + revision in form of
     3459          version and revision in form of
    34533460          <computeroutput>3.3.0r12345</computeroutput>.</para>
    34543461        </listitem>
    34553462
    34563463        <listitem>
    3457           <para>additionsActive() was replaced by <xref
     3464          <para>additionsActive() was replaced with <xref
    34583465          linkend="IGuest__additionsRunLevel"
    34593466          xreflabel="additionsRunLevel()" /> and <xref
    … …  
    34903497        <listitem>
    34913498          <para><xref linkend="IAppliance__write"
    3492           xreflabel="IAppliance::write()" /> got an extra parameter
    3493           <computeroutput>manifest</computeroutput>. This allows to
    3494           enable/disable the manifest file creation on export.</para>
     3499          xreflabel="IAppliance::write()" /> received an extra parameter
     3500          <computeroutput>manifest</computeroutput>, which can suppress
     3501          creating the manifest file on export.</para>
    34953502        </listitem>
    34963503

  • trunk/src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp

    r33004 r33294  
    793793        ComPtr<IMachine> m;
    794794
    795         /* find ID by name */
    796         if (id.isEmpty())
    797         {
    798             rc = virtualBox->FindMachine(Bstr(name).raw(), m.asOutParam());
    799             if (FAILED(rc))
    800             {
    801                 LogError("Invalid machine name!\n", rc);
    802                 break;
    803             }
    804             m->COMGETTER(Id)(id.asOutParam());
    805             AssertComRC(rc);
    806             if (FAILED(rc))
    807                 break;
    808         }
    809         else
    810         {
    811             /* Use the GUID. */
    812             rc = virtualBox->GetMachine(id.raw(), m.asOutParam());
    813             if (FAILED(rc))
    814             {
    815                 LogError("Invalid machine uid!\n", rc);
    816                 break;
    817             }
    818         }
     795        rc = virtualBox->FindMachine(Bstr(name).raw(), m.asOutParam());
     796        if (FAILED(rc))
     797        {
     798            LogError("Invalid machine name or UUID!\n", rc);
     799            break;
     800        }
     801        m->COMGETTER(Id)(id.asOutParam());
     802        AssertComRC(rc);
     803        if (FAILED(rc))
     804            break;
    819805
    820806        Log(("VBoxHeadless: Opening a session with machine (id={%s})...\n",

  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r33229 r33294  
    441441     */
    442442    ComPtr<IMachine> machine;
    443     /* assume it's a UUID */
    444     rc = aVirtualBox->GetMachine(Bstr(argv[0]).raw(), machine.asOutParam());
    445     if (FAILED(rc) || !machine)
    446     {
    447         /* must be a name */
    448         CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
    449                                                  machine.asOutParam()), 1);
    450     }
     443    CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
     444                                             machine.asOutParam()), 1);
    451445
    452446    /*
    … …  
    19061900
    19071901    ComPtr<IMachine> ptrMachine;
    1908     HRESULT rc = aVirtualBox->GetMachine(Bstr(argv[0]).raw(),
    1909                                          ptrMachine.asOutParam());
    1910     if (FAILED(rc) || ptrMachine.isNull())
    1911         CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
    1912                                                  ptrMachine.asOutParam()), 1);
     1902    HRESULT rc;
     1903    CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
     1904                                             ptrMachine.asOutParam()), 1);
    19131905
    19141906    CHECK_ERROR_RET(ptrMachine, LockMachine(aSession, LockType_Shared), 1);
    … …  
    20262018    RTSha256ToString(abDigest, pszDigest, sizeof(pszDigest));
    20272019    RTPrintf("Password hash: %s\n", pszDigest);
    2028    
     2020
    20292021    return 0;
    20302022}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

    r32885 r33294  
    7575    /* try to find the given machine */
    7676    ComPtr <IMachine> machine;
    77     Bstr machineuuid(a->argv[0]);
    78     if (!Guid(machineuuid).isEmpty())
    79     {
    80         CHECK_ERROR(a->virtualBox, GetMachine(machineuuid.raw(),
    81                                               machine.asOutParam()));
    82     }
    83     else
    84     {
    85         CHECK_ERROR(a->virtualBox, FindMachine(machineuuid.raw(),
    86                                                machine.asOutParam()));
    87         if (SUCCEEDED (rc))
    88             machine->COMGETTER(Id)(machineuuid.asOutParam());
    89     }
    90     if (FAILED (rc))
     77    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     78                                           machine.asOutParam()));
     79    if (FAILED(rc))
    9180        return 1;
    9281

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r33132 r33294  
    13051305            {
    13061306                ComPtr<IMachine> machine;
    1307                 CHECK_ERROR(a->virtualBox, GetMachine(machineIds[j], machine.asOutParam()));
     1307                CHECK_ERROR(a->virtualBox, FindMachine(machineIds[j], machine.asOutParam()));
    13081308                ASSERT(machine);
    13091309                Bstr name;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

    r33253 r33294  
    288288    /* lookup VM. */
    289289    ComPtr<IMachine> machine;
    290     /* assume it's an UUID */
    291     HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    292                                            machine.asOutParam());
    293     if (FAILED(rc) || !machine)
    294     {
    295         /* must be a name */
    296         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    297                                                machine.asOutParam()));
    298     }
    299 
     290    HRESULT rc;
     291    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     292                                           machine.asOutParam()));
    300293    if (machine)
    301294    {
    … …  
    689682    ComPtr<IMachine> machine;
    690683    /* assume it's an UUID */
    691     HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    692                                            machine.asOutParam());
    693     if (FAILED(rc) || !machine)
    694     {
    695         /* must be a name */
    696         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    697                                                machine.asOutParam()));
    698     }
    699 
     684    HRESULT rc;
     685    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     686                                           machine.asOutParam()));
    700687    if (machine)
    701688    {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp

    r32718 r33294  
    8888
    8989    ComPtr<IMachine> machine;
    90     /* assume it's a UUID */
    91     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    92                                    machine.asOutParam());
    93     if (FAILED(rc) || !machine)
    94     {
    95         /* must be a name */
    96         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    97                                                machine.asOutParam()));
    98     }
     90    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     91                                           machine.asOutParam()));
    9992    if (machine)
    10093    {
    … …  
    156149
    157150    ComPtr<IMachine> machine;
    158     /* assume it's a UUID */
    159     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    160                                    machine.asOutParam());
    161     if (FAILED(rc) || !machine)
    162     {
    163         /* must be a name */
    164         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    165                                                machine.asOutParam()));
    166     }
     151    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     152                                           machine.asOutParam()));
    167153    if (machine)
    168154    {
    … …  
    222208     */
    223209    ComPtr<IMachine> machine;
    224     /* assume it's a UUID */
    225     HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    226                                            machine.asOutParam());
    227     if (FAILED(rc) || !machine)
    228     {
    229         /* must be a name */
    230         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    231                                                machine.asOutParam()));
    232     }
     210    HRESULT rc;
     211    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     212                                           machine.asOutParam()));
    233213    if (machine)
    234214    {
    … …  
    280260        pszPatterns = a->argv[1];
    281261    ComPtr<IMachine> machine;
    282     /* assume it's a UUID */
    283     HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    284                                            machine.asOutParam());
    285     if (FAILED(rc) || !machine)
    286     {
    287         /* must be a name */
    288         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    289                                                machine.asOutParam()));
    290     }
     262    HRESULT rc;
     263    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     264                                           machine.asOutParam()));
    291265    if (!machine)
    292266        usageOK = false;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageImport.cpp

    r32718 r33294  
    831831                    // must be machine: try UUID or name
    832832                    ComPtr<IMachine> machine;
    833                     /* assume it's a UUID */
    834                     rc = a->virtualBox->GetMachine(Bstr(strMachine).raw(),
    835                                                    machine.asOutParam());
    836                     if (FAILED(rc) || !machine)
    837                     {
    838                         /* must be a name */
    839                         CHECK_ERROR_BREAK(a->virtualBox, FindMachine(Bstr(strMachine).raw(),
    840                                                                      machine.asOutParam()));
    841                     }
    842 
     833                    CHECK_ERROR_BREAK(a->virtualBox, FindMachine(Bstr(strMachine).raw(),
     834                                                                 machine.asOutParam()));
    843835                    if (machine)
    844836                        llMachines.push_back(machine);

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r33020 r33294  
    21232123    /* try to find the given machine */
    21242124    ComPtr <IMachine> machine;
    2125     Bstr uuid(VMNameOrUuid);
    2126     if (!Guid(VMNameOrUuid).isEmpty())
    2127     {
    2128         CHECK_ERROR(a->virtualBox, GetMachine(uuid.raw(),
    2129                                               machine.asOutParam()));
    2130     }
    2131     else
    2132     {
    2133         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid).raw(),
    2134                                                machine.asOutParam()));
    2135         if (SUCCEEDED(rc))
    2136             machine->COMGETTER(Id)(uuid.asOutParam());
    2137     }
     2125    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid).raw(),
     2126                                           machine.asOutParam()));
    21382127    if (FAILED(rc))
    21392128        return 1;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

    r33238 r33294  
    137137        {
    138138            ComPtr<IMachine> machine;
    139             CHECK_ERROR(aVirtualBox, GetMachine(machineIds[j], machine.asOutParam()));
     139            CHECK_ERROR(aVirtualBox, FindMachine(machineIds[j], machine.asOutParam()));
    140140            ASSERT(machine);
    141141            Bstr name;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp

    r33238 r33294  
    150150
    151151    ComPtr<IMachine> machine;
    152     /* assume it's a UUID */
    153     rc = a->virtualBox->GetMachine(Bstr(VMName).raw(), machine.asOutParam());
    154     if (FAILED(rc) || !machine)
    155     {
    156         /* must be a name */
    157         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),
    158                                                machine.asOutParam()));
    159     }
     152    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),
     153                                           machine.asOutParam()));
    160154    if (machine)
    161155    {
    … …  
    350344
    351345    ComPtr<IMachine> machine;
    352     /* assume it's a UUID */
    353     rc = a->virtualBox->GetMachine(Bstr(VMName).raw(), machine.asOutParam());
    354     if (FAILED(rc) || !machine)
    355     {
    356         /* must be a name */
    357         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),
    358                                                machine.asOutParam()));
    359     }
     346    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),
     347                                           machine.asOutParam()));
    360348    if (machine)
    361349    {
    … …  
    411399
    412400    ComPtr<IMachine> machine;
    413     /* assume it's a UUID */
    414     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    415                                    machine.asOutParam());
    416     if (FAILED(rc) || !machine)
    417     {
    418         /* must be a name */
    419         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    420                                                machine.asOutParam()));
    421     }
     401    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     402                                           machine.asOutParam()));
    422403    if (machine)
    423404    {
    … …  
    447428
    448429    ComPtr<IMachine> machine;
    449     /* assume it's a UUID */
    450     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    451                                    machine.asOutParam());
    452     if (FAILED(rc) || !machine)
    453     {
    454         /* must be a name */
    455         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    456                                                machine.asOutParam()));
    457     }
     430    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     431                                           machine.asOutParam()));
    458432    if (machine)
    459433    {
    … …  
    517491    {
    518492        ComPtr<IMachine> machine;
    519         /* assume it's a UUID */
    520         rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    521                                        machine.asOutParam());
    522         if (FAILED(rc) || !machine)
    523         {
    524             /* must be a name */
    525             CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    526                                                    machine.asOutParam()));
    527         }
     493        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     494                                               machine.asOutParam()));
    528495        if (machine)
    529496        {
    … …  
    584551    {
    585552        ComPtr<IMachine> machine;
    586         /* assume it's a UUID */
    587         rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
    588                                        machine.asOutParam());
    589         if (FAILED(rc) || !machine)
    590         {
    591             /* must be a name */
    592             CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    593                                        machine.asOutParam()));
    594         }
     553        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     554                                               machine.asOutParam()));
    595555        if (machine)
    596556        {
    … …  
    668628
    669629    ComPtr<IMachine> machine;
    670     /* assume it's a UUID */
    671     rc = a->virtualBox->GetMachine(Bstr(a->argv[1]).raw(),
    672                                    machine.asOutParam());
    673     if (FAILED(rc) || !machine)
    674     {
    675         /* must be a name */
    676         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[1]).raw(),
    677                                                machine.asOutParam()));
    678     }
     630    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[1]).raw(),
     631                                           machine.asOutParam()));
    679632    if (!machine)
    680633        return 1;
    … …  
    852805    /* try to find the given machine */
    853806    ComPtr<IMachine> machine;
    854     Bstr uuid(a->argv[0]);
    855     if (!Guid(a->argv[0]).isEmpty())
    856         CHECK_ERROR(a->virtualBox, GetMachine(uuid.raw(),
    857                                               machine.asOutParam()));
    858     else
    859     {
    860         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    861                                                machine.asOutParam()));
    862         if (SUCCEEDED(rc))
    863             machine->COMGETTER(Id)(uuid.asOutParam());
    864     }
     807    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     808                                           machine.asOutParam()));
    865809    if (FAILED(rc))
    866810        return 1;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r33201 r33294  
    284284    HRESULT rc;
    285285    Bstr name;
    286     Bstr machineuuid(a->argv[0]);
    287286    RTGETOPTUNION ValueUnion;
    288287    RTGETOPTSTATE GetOptState;
    … …  
    310309
    311310    /* try to find the given machine */
    312     if (!Guid(machineuuid).isEmpty())
    313     {
    314         CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid.raw(),
    315                                                   machine.asOutParam()), 1);
    316     }
    317     else
    318     {
    319         CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    320                                                    machine.asOutParam()), 1);
    321         machine->COMGETTER(Id)(machineuuid.asOutParam());
    322     }
     311    CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     312                                               machine.asOutParam()), 1);
    323313
    324314    /* open a session for the VM */

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp

    r32718 r33294  
    227227    Bstr bstrMachine(a->argv[0]);
    228228    ComPtr<IMachine> pMachine;
    229     /* assume it's a UUID */
    230     rc = a->virtualBox->GetMachine(bstrMachine.raw(), pMachine.asOutParam());
    231     if (FAILED(rc) || !pMachine)
    232     {
    233         /* must be a name */
    234         CHECK_ERROR(a->virtualBox, FindMachine(bstrMachine.raw(),
    235                                                pMachine.asOutParam()));
    236     }
     229    CHECK_ERROR(a->virtualBox, FindMachine(bstrMachine.raw(),
     230                                           pMachine.asOutParam()));
    237231    if (!pMachine)
    238232        return 1;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp

    r33140 r33294  
    6565    const char *pszMedium = NULL;
    6666    const char *pszPassThrough = NULL;
    67     Bstr machineuuid (a->argv[0]);
    6867    RTGETOPTUNION ValueUnion;
    6968    RTGETOPTSTATE GetState;
    … …  
    162161
    163162    /* try to find the given machine */
    164     if (!Guid(machineuuid).isEmpty())
    165     {
    166         CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid.raw(),
    167                                                   machine.asOutParam()), 1);
    168     }
    169     else
    170     {
    171         CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    172                                                    machine.asOutParam()), 1);
    173         machine->COMGETTER(Id)(machineuuid.asOutParam());
    174     }
     163    CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     164                                               machine.asOutParam()), 1);
    175165
    176166    /* open a session for the VM (new or shared) */
    … …  
    671661    ULONG             sataportcount  = ~0U;
    672662    bool              fRemoveCtl     = false;
    673     Bstr              machineuuid (a->argv[0]);
    674663    ComPtr<IMachine>  machine;
    675664    RTGETOPTUNION     ValueUnion;
    … …  
    752741
    753742    /* try to find the given machine */
    754     if (!Guid(machineuuid).isEmpty())
    755     {
    756         CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid.raw(),
    757                                                   machine.asOutParam()), 1);
    758     }
    759     else
    760     {
    761         CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    762                                                    machine.asOutParam()), 1);
    763         machine->COMGETTER(Id)(machineuuid.asOutParam());
    764     }
     743    CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     744                                               machine.asOutParam()), 1);
    765745
    766746    /* open a session for the VM */

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUSB.cpp

    r32718 r33294  
    234234                    {
    235235                        /* assume it's a UUID of a machine */
    236                         rc = a->virtualBox->GetMachine(Bstr(a->argv[i]).raw(),
    237                                                        cmd.mMachine.asOutParam());
    238                         if (FAILED(rc) || !cmd.mMachine)
    239                         {
    240                             /* must be a name */
    241                             CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(),
    242                                                                        cmd.mMachine.asOutParam()), 1);
    243                         }
     236                        CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(),
     237                                                                   cmd.mMachine.asOutParam()), 1);
    244238                    }
    245239                }
    … …  
    389383                    else
    390384                    {
    391                         /* assume it's a UUID of a machine */
    392                         rc = a->virtualBox->GetMachine(Bstr(a->argv[i]).raw(),
    393                                                        cmd.mMachine.asOutParam());
    394                         if (FAILED(rc) || !cmd.mMachine)
    395                         {
    396                             /* must be a name */
    397                             CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(),
    398                                                                        cmd.mMachine.asOutParam()), 1);
    399                         }
     385                        CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(),
     386                                                                   cmd.mMachine.asOutParam()), 1);
    400387                    }
    401388                }

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxMediaManagerDlg.cpp

    r33238 r33294  
    11371137    for (QList <QString>::const_iterator it = machineIds.begin(); it != machineIds.end(); ++ it)
    11381138    {
    1139         CMachine m = mVBox.GetMachine (*it);
     1139        CMachine m = mVBox.FindMachine (*it);
    11401140        if (!mVBox.isOk())
    11411141            continue;
    … …  
    11871187    else
    11881188    {
    1189         session = vboxGlobal().openSession (aMachineId);
     1189        session = vboxGlobal().openSession(aMachineId);
    11901190        if (session.isNull())
    11911191            return false;

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxMedium.cpp

    r32532 r33294  
    191191            for (QVector <QString>::ConstIterator it = machineIds.begin(); it != machineIds.end(); ++ it)
    192192            {
    193                 CMachine machine = vbox.GetMachine (*it);
     193                CMachine machine = vbox.FindMachine(*it);
    194194
    195195                QString sName = machine.GetName();

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.cpp

    r33044 r33294  
    21662166    }
    21672167
    2168     CMachine foundMachine = CVirtualBox(mVBox).GetMachine(aId);
     2168    CMachine foundMachine = CVirtualBox(mVBox).FindMachine(aId);
    21692169    if (!foundMachine.isNull())
    21702170    {
    … …  
    48034803    if (bForceSeamless && !vmUuid.isEmpty())
    48044804    {
    4805         mVBox.GetMachine(vmUuid).SetExtraData(VBoxDefs::GUI_Seamless, "on");
     4805        mVBox.FindMachine(vmUuid).SetExtraData(VBoxDefs::GUI_Seamless, "on");
    48064806    }
    48074807    else if (bForceFullscreen && !vmUuid.isEmpty())
    48084808    {
    4809         mVBox.GetMachine(vmUuid).SetExtraData(VBoxDefs::GUI_Fullscreen, "on");
     4809        mVBox.FindMachine(vmUuid).SetExtraData(VBoxDefs::GUI_Fullscreen, "on");
    48104810    }
    48114811

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/VBoxSelectorWnd.cpp

    r32789 r33294  
    779779    }
    780780
    781     CMachine foundMachine = vbox.GetMachine(id);
     781    CMachine foundMachine = vbox.FindMachine(id);
    782782    if (!foundMachine.isNull())
    783783        foundMachine.LockMachine(session, KLockType_Write);
    … …  
    14071407    {
    14081408        CVirtualBox vbox = vboxGlobal().virtualBox();
    1409         CMachine m = vbox.GetMachine(strId);
     1409        CMachine m = vbox.FindMachine(strId);
    14101410        if (!m.isNull())
    14111411        {

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/exportappliance/UIExportApplianceWzd.cpp

    r33077 r33294  
    254254        {
    255255            /* Get the machine with the uuid */
    256             CMachine m = vbox.GetMachine(uuid);
     256            CMachine m = vbox.FindMachine(uuid);
    257257            fResult = m.isOk();
    258258            if (fResult)

  • trunk/src/VBox/HostServices/auth/simple/VBoxAuthSimple.cpp

    r33229 r33294  
    101101        {
    102102            ComPtr<IMachine> machine;
    103             virtualBox->GetMachine(Bstr(uuid).raw(), machine.asOutParam());
     103            virtualBox->FindMachine(Bstr(uuid).raw(), machine.asOutParam());
    104104            if (machine)
    105105                machine->GetExtraData(key.raw(), password.asOutParam());
    … …  
    115115            char pszDigest[RTSHA256_DIGEST_LEN + 1];
    116116            RTSha256ToString(abDigest, pszDigest, sizeof(pszDigest));
    117                        
     117
    118118            if (password == pszDigest)
    119119                result = VRDPAuthAccessGranted;

  • trunk/src/VBox/Main/ApplianceImplImport.cpp

    r33289 r33294  
    10851085            Bstr bstrGuid = guid.toUtf16();
    10861086            ComPtr<IMachine> failedMachine;
    1087             HRESULT rc2 = mVirtualBox->GetMachine(bstrGuid.raw(), failedMachine.asOutParam());
     1087            HRESULT rc2 = mVirtualBox->FindMachine(bstrGuid.raw(), failedMachine.asOutParam());
    10881088            if (SUCCEEDED(rc2))
    10891089            {

  • trunk/src/VBox/Main/VirtualBoxImpl.cpp

    r33254 r33294  
    13061306}
    13071307
    1308 /** @note Locks objects! */
    1309 STDMETHODIMP VirtualBox::GetMachine(IN_BSTR aId, IMachine **aMachine)
    1310 {
     1308/** @note Locks this object for reading, then some machine objects for reading. */
     1309STDMETHODIMP VirtualBox::FindMachine(IN_BSTR aNameOrId, IMachine **aMachine)
     1310{
     1311    LogFlowThisFuncEnter();
     1312    LogFlowThisFunc(("aName=\"%ls\", aMachine={%p}\n", aNameOrId, aMachine));
     1313
     1314    CheckComArgStrNotEmptyOrNull(aNameOrId);
    13111315    CheckComArgOutSafeArrayPointerValid(aMachine);
    13121316
    … …  
    13141318    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13151319
    1316     ComObjPtr<Machine> machine;
    1317     HRESULT rc = findMachine(Guid(aId),
    1318                              true /* fPermitInaccessible */,
    1319                              true /* setError */,
    1320                              &machine);
    1321 
    1322     /* the below will set *aMachine to NULL if machine is null */
    1323     machine.queryInterfaceTo(aMachine);
    1324 
    1325     return rc;
    1326 }
    1327 
    1328 /** @note Locks this object for reading, then some machine objects for reading. */
    1329 STDMETHODIMP VirtualBox::FindMachine(IN_BSTR aName, IMachine **aMachine)
    1330 {
    1331     LogFlowThisFuncEnter();
    1332     LogFlowThisFunc(("aName=\"%ls\", aMachine={%p}\n", aName, aMachine));
    1333 
    1334     CheckComArgStrNotEmptyOrNull(aName);
    1335     CheckComArgOutSafeArrayPointerValid(aMachine);
    1336 
    1337     AutoCaller autoCaller(this);
    1338     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1339 
    13401320    /* start with not found */
     1321    HRESULT rc = S_OK;
    13411322    ComObjPtr<Machine> pMachineFound;
    1342     Utf8Str strName(aName);
    1343 
    1344     AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
    1345     for (MachinesOList::iterator it = m->allMachines.begin();
    1346          it != m->allMachines.end();
    1347          ++it)
    1348     {
    1349         ComObjPtr<Machine> &pMachine2 = *it;
    1350         AutoCaller machCaller(pMachine2);
    1351         /* skip inaccessible machines */
    1352         if (FAILED(machCaller.rc()))
    1353             continue;
    1354 
    1355         AutoReadLock machLock(pMachine2 COMMA_LOCKVAL_SRC_POS);
    1356         if (pMachine2->getName() == strName)
    1357         {
    1358             pMachineFound = pMachine2;
    1359             break;
    1360         }
     1323
     1324    Guid id(aNameOrId);
     1325    if (!id.isEmpty())
     1326        rc = findMachine(id,
     1327                         true /* fPermitInaccessible */,
     1328                         true /* setError */,
     1329                         &pMachineFound);
     1330                // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error
     1331    else
     1332    {
     1333        Utf8Str strName(aNameOrId);
     1334        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
     1335        for (MachinesOList::iterator it = m->allMachines.begin();
     1336             it != m->allMachines.end();
     1337             ++it)
     1338        {
     1339            ComObjPtr<Machine> &pMachine2 = *it;
     1340            AutoCaller machCaller(pMachine2);
     1341            if (machCaller.rc())
     1342                continue;       // we can't ask inaccessible machines for their names
     1343
     1344            AutoReadLock machLock(pMachine2 COMMA_LOCKVAL_SRC_POS);
     1345            if (pMachine2->getName() == strName)
     1346            {
     1347                pMachineFound = pMachine2;
     1348                break;
     1349            }
     1350        }
     1351
     1352        if (!pMachineFound)
     1353            rc = setError(VBOX_E_OBJECT_NOT_FOUND,
     1354                          tr("Could not find a registered machine named '%ls'"), aNameOrId);
    13611355    }
    13621356
    … …  
    13641358    pMachineFound.queryInterfaceTo(aMachine);
    13651359
    1366     HRESULT rc = pMachineFound
    1367         ? S_OK
    1368         : setError(VBOX_E_OBJECT_NOT_FOUND,
    1369                    tr("Could not find a registered machine named '%ls'"), aName);
    1370 
    1371     LogFlowThisFunc(("aName=\"%ls\", aMachine=%p, rc=%08X\n", aName, *aMachine, rc));
     1360    LogFlowThisFunc(("aName=\"%ls\", aMachine=%p, rc=%08X\n", aNameOrId, *aMachine, rc));
    13721361    LogFlowThisFuncLeave();
    13731362

  • trunk/src/VBox/Main/cbinding/tstXPCOMCGlue.c

    r31070 r33294  
    206206    PRUnichar *sessionType;
    207207
    208     rc = virtualBox->vtbl->GetMachine(virtualBox, id, &machine);
     208    rc = virtualBox->vtbl->FindMachine(virtualBox, id, &machine);
    209209
    210210    if (NS_FAILED(rc) || !machine)

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r33253 r33294  
    13741374  <interface
    13751375    name="IVirtualBox" extends="$unknown"
    1376     uuid="a35a051c-0966-4582-8e9c-7c1b973f6bd2"
     1376    uuid="5e887b09-e3f3-4787-b9f3-8ade5d04d675"
    13771377    wsmap="managed"
    13781378  >
    … …  
    16991699    </method>
    17001700
    1701     <method name="getMachine">
    1702       <desc>
    1703         Attempts to find a virtual machine given its UUID.
    1704         To look up a machine by name, use <link to="IVirtualBox::findMachine" />
    1705         instead.
     1701    <method name="findMachine">
     1702      <desc>
     1703        Attempts to find a virtual machine given its name or UUID.
     1704
     1705        <note>Inaccessible machines cannot be found by name, only by UUID, because their name
     1706          cannot safely be determined.</note>
    17061707
    17071708        <result name="VBOX_E_OBJECT_NOT_FOUND">
    1708           Could not find registered machine matching @a id.
    1709         </result>
    1710 
    1711       </desc>
    1712       <param name="id" type="uuid" mod="string" dir="in"/>
    1713       <param name="machine" type="IMachine" dir="return"/>
    1714     </method>
    1715 
    1716     <method name="findMachine">
    1717       <desc>
    1718         Attempts to find a virtual machine given its name.
    1719         To look up a machine by UUID, use <link to="IVirtualBox::getMachine" />
    1720         instead.
    1721 
    1722         <result name="VBOX_E_OBJECT_NOT_FOUND">
    1723           Could not find registered machine matching @a name.
    1724         </result>
    1725 
    1726       </desc>
    1727       <param name="name" type="wstring" dir="in"/>
    1728       <param name="machine" type="IMachine" dir="return"/>
     1709          Could not find registered machine matching @a nameOrId.
     1710        </result>
     1711
     1712      </desc>
     1713      <param name="nameOrId" type="wstring" dir="in">
     1714        <desc>What to search for. This can either be the UUID or the name of a virtual machine.</desc>
     1715      </param>
     1716      <param name="machine" type="IMachine" dir="return">
     1717        <desc>Machine object, if found.</desc>
     1718      </param>
    17291719    </method>
    17301720

  • trunk/src/VBox/Main/include/VirtualBoxImpl.h

    r33239 r33294  
    127127    STDMETHOD(OpenMachine) (IN_BSTR aSettingsFile, IMachine **aMachine);
    128128    STDMETHOD(RegisterMachine) (IMachine *aMachine);
    129     STDMETHOD(GetMachine) (IN_BSTR aId, IMachine **aMachine);
    130     STDMETHOD(FindMachine) (IN_BSTR aName, IMachine **aMachine);
     129    STDMETHOD(FindMachine) (IN_BSTR aNameOrId, IMachine **aMachine);
    131130    STDMETHOD(CreateAppliance) (IAppliance **anAppliance);
    132131

  • trunk/src/VBox/Main/testcase/tstOVF.cpp

    r32718 r33294  
    345345            Bstr bstrUUID(uuid.toUtf16());
    346346            ComPtr<IMachine> pMachine;
    347             rc = pVirtualBox->GetMachine(bstrUUID.raw(), pMachine.asOutParam());
     347            rc = pVirtualBox->FindMachine(bstrUUID.raw(), pMachine.asOutParam());
    348348            if (FAILED(rc)) throw MyError(rc, "VirtualBox::FindMachine() failed\n");
    349349
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