VirtualBox

Changeset 106903 in vbox


Ignore:
Timestamp:
Nov 9, 2024 12:38:48 AM (6 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
165826
Message:

Main/ObjectsTracker.h/cpp: Another build fix attempt - the extpack solaris VM doesn't know the C++11 for loop style. It also doesn't have std::map::at(). Kicked out the std::string variant of the map type, it just clutters up the code with unnecessary string copies. jiraref:VBP-1187

Location:
trunk/src/VBox/Main
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r106902 r106903  
    150150};
    151151
    152 /** The string representation for object IDs in the internal map.
    153  * @todo r=bird: Why are you using std::string here? We use should use
    154  *       com::Utf8Str where possible. In this case, though, it's a com::Guid
    155  *       which would have much more efficient storage compared to both the
    156  *       string variants... */
    157 #if 0 /* The solaris VM seems to have trouble with this or something related to it. */
    158 typedef std::string ObjIdString_T;
    159 #else
    160 typedef com::Utf8Str ObjIdString_T;
    161 #endif
    162152
    163153/////////////////////////////////////////////////////////////////////////////
    … …  
    171161    std::set<com::Utf8Str> m_trackedObjectIds;//Full list of valid + invalid objects
    172162    std::set<com::Utf8Str> m_trackedInvalidObjectIds;//List of invalid objects only
    173     std::map<ObjIdString_T, TrackedObjectData> m_trackedObjectsData;//Mapping Object Id -> Object Data
     163    std::map<com::Utf8Str, TrackedObjectData> m_trackedObjectsData;//Mapping Object Id -> Object Data
    174164
    175165    uint64_t m_Added;//Counter of the added objects

  • trunk/src/VBox/Main/src-all/ObjectsTracker.cpp

    r106901 r106903  
    3535#include <iprt/time.h>
    3636#include <iprt/asm.h>
    37 
    38 typedef std::map<ObjIdString_T, TrackedObjectData>::const_iterator ConstIterTrObjDataType;
    39 typedef std::map<ObjIdString_T, TrackedObjectData>::iterator iterTrObjDataType;
     37#include <stdexcept>
     38
     39typedef std::map<com::Utf8Str, TrackedObjectData>::iterator IterTrObjData_T;
     40typedef std::map<com::Utf8Str, TrackedObjectData>::const_iterator ConstIterTrObjData_T;
    4041
    4142/////////////////////////////////////////////////////////////////////////////
    … …  
    317318}
    318319
    319 HRESULT TrackedObjectsCollector::getObj (const com::Utf8Str& aObjId,
    320                                          TrackedObjectData& aObjData,
    321                                          bool fUpdate)
     320HRESULT TrackedObjectsCollector::getObj(const com::Utf8Str &aObjId,
     321                                        TrackedObjectData &aObjData,
     322                                        bool fUpdate)
    322323{
    323324    LogFlowFuncEnter();
    … …  
    330331    RTCritSectEnter(&m_CritSectData);
    331332
    332     ObjIdString_T sTemp(aObjId.c_str());
    333333    HRESULT hrc = E_FAIL;
    334334
    335     iterTrObjDataType pIter = m_trackedObjectsData.find(sTemp);
     335    IterTrObjData_T pIter = m_trackedObjectsData.find(aObjId);
    336336    if (pIter != m_trackedObjectsData.end() && fUpdate == true)
    337337    {
    … …  
    342342    }
    343343
    344     if (RT_SUCCESS(vrc))
    345     {
     344    if (RT_SUCCESS(vrc)) /** @todo r=bird: This won't ever fail. Did you mixup vrc and hrc above? */
     345    {
     346        /** @todo r=bird: Why do three lookups? */
    346347        if ( i_getObj(aObjId).getInterface().isNotNull() )
    347348        {
    … …  
    368369{
    369370    /* No check for existence of aObjId */
     371#if 0 /* the solaris VM's stl_map.h code doesn't have any at() function. */
    370372    return m_trackedObjectsData.at(aObjId);
     373#else
     374    ConstIterTrObjData_T const Iter = m_trackedObjectsData.find(aObjId);
     375    if (Iter == m_trackedObjectsData.cend())
     376        throw std::out_of_range(aObjId.c_str());
     377    return (*Iter).second;
     378#endif
    371379}
    372380
    … …  
    384392    RTCritSectEnter(&m_CritSectData);
    385393
    386     ObjIdString_T sTemp(aObjId.c_str());
    387 
    388     iterTrObjDataType pIter = m_trackedObjectsData.find(sTemp);
     394    IterTrObjData_T pIter = m_trackedObjectsData.find(aObjId);
    389395    if (pIter != m_trackedObjectsData.end())
    390396    {
    … …  
    404410}
    405411
    406 HRESULT TrackedObjectsCollector::removeObj (const com::Utf8Str& aObjId)
     412HRESULT TrackedObjectsCollector::removeObj(const com::Utf8Str &aObjId)
    407413{
    408414    Log2(("%s: object Id %s\n", __FUNCTION__, aObjId.c_str()));
    … …  
    412418    if (RT_FAILURE(vrc))
    413419        return VBOX_E_INVALID_OBJECT_STATE;
    414 
    415     ObjIdString_T sTemp(aObjId.c_str());
    416420
    417421    vrc = VERR_NOT_FOUND;
    … …  
    420424    RTCritSectEnter(&m_CritSectData);
    421425
    422     ConstIterTrObjDataType pIter = m_trackedObjectsData.find(sTemp);
    423     if (pIter != m_trackedObjectsData.end())
     426    IterTrObjData_T Iter = m_trackedObjectsData.find(aObjId);
     427    if (Iter != m_trackedObjectsData.end())
    424428    {
    425429        Log2(("RELEASED TrackedObjectData: creation time %s, object Id %s, class IID %s\n",
    426                pIter->second.creationTimeStr().c_str(), pIter->second.objectIdStr().c_str(), pIter->second.classIIDStr().c_str()));
    427 
    428         m_trackedObjectsData.erase(pIter);
     430               Iter->second.creationTimeStr().c_str(), Iter->second.objectIdStr().c_str(), Iter->second.classIIDStr().c_str()));
     431
     432        m_trackedObjectsData.erase(Iter);
    429433        m_trackedObjectIds.erase(aObjId);
    430434        m_trackedInvalidObjectIds.erase(aObjId);
    … …  
    499503}
    500504
    501 int TrackedObjectsCollector::i_getObjIdsByClassIID (const Guid& iid,
    502                                                         std::vector<com::Utf8Str>& aObjIdMap) const
    503 {
    504     for (const std::pair<const ObjIdString_T, TrackedObjectData> &item : m_trackedObjectsData)
     505int TrackedObjectsCollector::i_getObjIdsByClassIID(const Guid &aIId, std::vector<com::Utf8Str> &aObjIdMap) const
     506{
     507    //for (const std::pair<const com::Utf8Str, TrackedObjectData> &item : m_trackedObjectsData)  - the gcc in the solaris VM doesn't grok this.
     508    for (ConstIterTrObjData_T Iter = m_trackedObjectsData.cbegin();
     509         Iter != m_trackedObjectsData.cend();
     510         ++Iter)
    505511    {
    506512        /* IID found and the object is valid */
    507         if (item.second.classIID() == iid && !m_trackedInvalidObjectIds.count(item.first.c_str()))
    508             aObjIdMap.push_back(item.first.c_str());
     513        if (Iter->second.classIID() == aIId && !m_trackedInvalidObjectIds.count(Iter->first))
     514            aObjIdMap.push_back(Iter->first);
    509515    }
    510516
    … …  
    512518}
    513519
    514 bool TrackedObjectsCollector::checkObj(const com::Utf8Str& aObjId)
     520bool TrackedObjectsCollector::checkObj(const com::Utf8Str &aObjId)
    515521{
    516522    Log2(("%s: Checking object with Id %s\n", __FUNCTION__, aObjId.c_str()));
    … …  
    604610    RTCritSectEnter(&m_CritSectData);
    605611
    606     iterTrObjDataType pIter = m_trackedObjectsData.find(aObjId.c_str());
     612    IterTrObjData_T pIter = m_trackedObjectsData.find(aObjId.c_str());
    607613    if (pIter != m_trackedObjectsData.end())
    608614    {
    … …  
    651657    LogFlowFuncEnter();
    652658
    653     HRESULT hrc = S_OK;
    654659    int vrc = i_checkInitialization();
    655660    if (RT_FAILURE(vrc))
    … …  
    659664    RTCritSectEnter(&m_CritSectData);
    660665
    661     ObjIdString_T sTemp(aObjId.c_str());
    662     vrc = VERR_NOT_FOUND;
    663 
    664     iterTrObjDataType pIter = m_trackedObjectsData.find(sTemp);
     666    HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND;
     667    IterTrObjData_T pIter = m_trackedObjectsData.find(aObjId);
    665668    if (pIter != m_trackedObjectsData.end())
    666669    {
    667670        pIter->second.resetState();
    668671        m_trackedInvalidObjectIds.insert(aObjId);
    669         vrc = VINF_SUCCESS;
    670     }
    671 
    672     if (RT_FAILURE(vrc))
    673         hrc = VBOX_E_OBJECT_NOT_FOUND;
     672        hrc = S_OK;
     673    }
    674674
    675675    /* Leave critical section here */
    … …  
    723723    {
    724724        std::vector<com::Utf8Str> lObjIdMap;
    725 
    726725        hrc = gTrackedObjectsCollector.getAllObjIds(lObjIdMap);
    727         for (const com::Utf8Str& item : lObjIdMap)
     726
     727        //for (const com::Utf8Str& item : lObjIdMap) - the gcc in the solaris VM doesn't grok this.
     728        for (std::vector<com::Utf8Str>::const_iterator Iter = lObjIdMap.cbegin();
     729             Iter != lObjIdMap.cend();
     730             ++Iter)
    728731        {
    729732            TrackedObjectData temp;
    730             if(gTrackedObjectsCollector.checkObj(item.c_str()))
     733            if(gTrackedObjectsCollector.checkObj(*Iter))
    731734            {
    732                 hrc = gTrackedObjectsCollector.getObj(item.c_str(), temp);
     735                hrc = gTrackedObjectsCollector.getObj(*Iter, temp);
    733736                if (SUCCEEDED(hrc))
    734737                {
    … …  
    762765                            if (temp.m_fIdleTimeStart == false)
    763766                            {
    764                                 gTrackedObjectsCollector.initObjIdleTime(item);
    765                                 Log2(("Idle time for the object with Id %s has been started\n", item.c_str()));
     767                                gTrackedObjectsCollector.initObjIdleTime(*Iter);
     768                                Log2(("Idle time for the object with Id %s has been started\n", Iter->c_str()));
    766769                            }
    767770                            else
    … …  
    773776                                {
    774777                                    Log2(("Object with Id %s removed from Object Collector "
    775                                             "(recount is %u, idle time exceeded %u sec)\n", item.c_str(), cRefs - 1, temp.m_idleTime));
    776                                     gTrackedObjectsCollector.removeObj(item.c_str());
     778                                            "(recount is %u, idle time exceeded %u sec)\n", Iter->c_str(), cRefs - 1, temp.m_idleTime));
     779                                    gTrackedObjectsCollector.removeObj(*Iter);
    777780                                }
    778781                            }
    … …  
    804807                            {
    805808                                Log2(("Object with Id %s removed from Object Collector "
    806                                         "(lifetime exceeded %u sec)\n", item.c_str(), temp.m_lifeTime));
    807                                 gTrackedObjectsCollector.removeObj(item.c_str());
     809                                        "(lifetime exceeded %u sec)\n", Iter->c_str(), temp.m_lifeTime));
     810                                gTrackedObjectsCollector.removeObj(*Iter);
    808811                            }
    809812                        }
    … …  
    812815            }
    813816            else
    814                 Log2(("Tracked Object with ID %s was not found\n", item.c_str()));
     817                Log2(("Tracked Object with ID %s was not found\n", Iter->c_str()));
    815818        }
    816819
Note: See TracChangeset for help on using the changeset viewer.

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