VirtualBox

Ignore:
Timestamp:
Sep 12, 2014 12:33:41 PM (10 years ago)
Author:
vboxsync
Message:

Main/Event: wrapper conversion, not covering the automatically generated event implementations

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r52413 r52719  
    8383};
    8484
     85DEFINE_EMPTY_CTOR_DTOR(VBoxEvent)
     86
    8587HRESULT VBoxEvent::FinalConstruct()
    8688{
    … …  
    9597        uninit();
    9698        delete m;
    97         m = 0;
    98         BaseFinalRelease();
    99     }
     99        m = NULL;
     100    }
     101    BaseFinalRelease();
    100102}
    101103
    … …  
    151153}
    152154
    153 STDMETHODIMP VBoxEvent::COMGETTER(Type)(VBoxEventType_T *aType)
    154 {
    155     CheckComArgNotNull(aType);
    156 
    157     AutoCaller autoCaller(this);
    158     if (FAILED(autoCaller.rc()))
    159         return autoCaller.rc();
    160 
     155HRESULT VBoxEvent::getType(VBoxEventType_T *aType)
     156{
    161157    // never changes while event alive, no locking
    162158    *aType = m->mType;
    … …  
    164160}
    165161
    166 STDMETHODIMP VBoxEvent::COMGETTER(Source)(IEventSource **aSource)
    167 {
    168     CheckComArgOutPointerValid(aSource);
    169 
    170     AutoCaller autoCaller(this);
    171     if (FAILED(autoCaller.rc()))
    172         return autoCaller.rc();
    173 
    174     m->mSource.queryInterfaceTo(aSource);
    175     return S_OK;
    176 }
    177 
    178 STDMETHODIMP VBoxEvent::COMGETTER(Waitable)(BOOL *aWaitable)
    179 {
    180     CheckComArgNotNull(aWaitable);
    181 
    182     AutoCaller autoCaller(this);
    183     if (FAILED(autoCaller.rc()))
    184         return autoCaller.rc();
    185 
     162HRESULT VBoxEvent::getSource(ComPtr<IEventSource> &aSource)
     163{
     164    m->mSource.queryInterfaceTo(aSource.asOutParam());
     165    return S_OK;
     166}
     167
     168HRESULT VBoxEvent::getWaitable(BOOL *aWaitable)
     169{
    186170    // never changes while event alive, no locking
    187171    *aWaitable = m->mWaitable;
    … …  
    189173}
    190174
    191 
    192 STDMETHODIMP VBoxEvent::SetProcessed()
    193 {
    194     AutoCaller autoCaller(this);
    195     if (FAILED(autoCaller.rc()))
    196         return autoCaller.rc();
    197 
     175HRESULT VBoxEvent::setProcessed()
     176{
    198177    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    199178
    … …  
    209188}
    210189
    211 STDMETHODIMP VBoxEvent::WaitProcessed(LONG aTimeout, BOOL *aResult)
    212 {
    213     CheckComArgNotNull(aResult);
    214 
    215     AutoCaller autoCaller(this);
    216     if (FAILED(autoCaller.rc()))
    217         return autoCaller.rc();
    218 
    219     {
    220         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    221 
    222         if (m->mProcessed)
    223         {
    224             *aResult = TRUE;
    225             return S_OK;
    226         }
    227 
    228         if (aTimeout == 0)
    229         {
    230             *aResult = m->mProcessed;
    231             return S_OK;
    232         }
     190HRESULT VBoxEvent::waitProcessed(LONG aTimeout, BOOL *aResult)
     191{
     192    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     193
     194    if (m->mProcessed)
     195    {
     196        *aResult = TRUE;
     197        return S_OK;
     198    }
     199
     200    if (aTimeout == 0)
     201    {
     202        *aResult = m->mProcessed;
     203        return S_OK;
    233204    }
    234205
    … …  
    252223}
    253224
    254 typedef std::list<Bstr> VetoList;
     225typedef std::list<Utf8Str> VetoList;
    255226struct VBoxVetoEvent::Data
    256227{
    … …  
    258229        mVetoed(FALSE)
    259230    {}
     231    ComObjPtr<VBoxEvent>    mEvent;
    260232    BOOL                    mVetoed;
    261233    VetoList                mVetoList;
    … …  
    264236HRESULT VBoxVetoEvent::FinalConstruct()
    265237{
    266     VBoxEvent::FinalConstruct();
    267238    m = new Data;
    268     return S_OK;
     239    HRESULT rc = m->mEvent.createObject();
     240    BaseFinalConstruct();
     241    return rc;
    269242}
    270243
    … …  
    275248        uninit();
    276249        delete m;
    277         m = 0;
    278     }
    279     VBoxEvent::FinalRelease();
    280 }
    281 
     250        m = NULL;
     251    }
     252    BaseFinalRelease();
     253}
     254
     255DEFINE_EMPTY_CTOR_DTOR(VBoxVetoEvent)
    282256
    283257HRESULT VBoxVetoEvent::init(IEventSource *aSource, VBoxEventType_T aType)
    … …  
    285259    HRESULT rc = S_OK;
    286260    // all veto events are waitable
    287     rc = VBoxEvent::init(aSource, aType, TRUE);
     261    rc = m->mEvent->init(aSource, aType, TRUE);
    288262    if (FAILED(rc))
    289263        return rc;
    … …  
    292266    m->mVetoList.clear();
    293267
    294     return rc;
     268    return S_OK;
    295269}
    296270
    297271void VBoxVetoEvent::uninit()
    298272{
    299     VBoxEvent::uninit();
    300273    if (!m)
    301274        return;
     275
    302276    m->mVetoed = FALSE;
    303 }
    304 
    305 STDMETHODIMP VBoxVetoEvent::AddVeto(IN_BSTR aVeto)
    306 {
    307     AutoCaller autoCaller(this);
    308     if (FAILED(autoCaller.rc()))
    309         return autoCaller.rc();
    310 
    311     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    312 
    313     if (aVeto)
    314         m->mVetoList.push_back(aVeto);
     277    if (!m->mEvent.isNull())
     278    {
     279        m->mEvent->uninit();
     280        m->mEvent.setNull();
     281    }
     282}
     283
     284HRESULT VBoxVetoEvent::getType(VBoxEventType_T *aType)
     285{
     286    return m->mEvent->COMGETTER(Type)(aType);
     287}
     288
     289HRESULT VBoxVetoEvent::getSource(ComPtr<IEventSource> &aSource)
     290{
     291    return m->mEvent->COMGETTER(Source)(aSource.asOutParam());
     292}
     293
     294HRESULT VBoxVetoEvent::getWaitable(BOOL *aWaitable)
     295{
     296    return m->mEvent->COMGETTER(Waitable)(aWaitable);
     297}
     298
     299HRESULT VBoxVetoEvent::setProcessed()
     300{
     301    return m->mEvent->SetProcessed();
     302}
     303
     304HRESULT VBoxVetoEvent::waitProcessed(LONG aTimeout, BOOL *aResult)
     305{
     306    return m->mEvent->WaitProcessed(aTimeout, aResult);
     307}
     308
     309HRESULT VBoxVetoEvent::addVeto(const com::Utf8Str &aReason)
     310{
     311    // AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     312    if (aReason.length())
     313        m->mVetoList.push_back(aReason);
    315314
    316315    m->mVetoed = TRUE;
    … …  
    319318}
    320319
    321 STDMETHODIMP VBoxVetoEvent::IsVetoed(BOOL *aResult)
    322 {
    323     CheckComArgOutPointerValid(aResult);
    324 
    325     AutoCaller autoCaller(this);
    326     if (FAILED(autoCaller.rc()))
    327         return autoCaller.rc();
    328 
    329     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    330 
     320HRESULT VBoxVetoEvent::isVetoed(BOOL *aResult)
     321{
     322    // AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    331323    *aResult = m->mVetoed;
    332324
    … …  
    334326}
    335327
    336 STDMETHODIMP VBoxVetoEvent::GetVetos(ComSafeArrayOut(BSTR, aVetos))
    337 {
    338     if (ComSafeArrayOutIsNull(aVetos))
    339         return E_POINTER;
    340 
    341     AutoCaller autoCaller(this);
    342     if (FAILED(autoCaller.rc()))
    343         return autoCaller.rc();
    344 
    345     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    346     com::SafeArray<BSTR> vetos(m->mVetoList.size());
    347     int i = 0;
    348     for (VetoList::const_iterator it = m->mVetoList.begin();
    349          it != m->mVetoList.end();
    350          ++it, ++i)
    351     {
    352         const Bstr &str = *it;
    353         str.cloneTo(&vetos[i]);
    354     }
    355     vetos.detachTo(ComSafeArrayOutArg(aVetos));
     328HRESULT VBoxVetoEvent::getVetos(std::vector<com::Utf8Str> &aResult)
     329{
     330    // AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     331    aResult.resize(m->mVetoList.size());
     332    size_t i = 0;
     333    for (VetoList::const_iterator it = m->mVetoList.begin(); it != m->mVetoList.end(); ++it, ++i)
     334        aResult[i] = (*it);
    356335
    357336    return S_OK;
    … …  
    1006985}
    1007986
    1008 STDMETHODIMP EventSource::RegisterListener(IEventListener *aListener,
    1009                                            ComSafeArrayIn(VBoxEventType_T, aInterested),
    1010                                            BOOL aActive)
    1011 {
    1012     CheckComArgNotNull(aListener);
    1013     CheckComArgSafeArrayNotNull(aInterested);
    1014 
    1015     AutoCaller autoCaller(this);
    1016     if (FAILED(autoCaller.rc()))
    1017         return autoCaller.rc();
    1018 
    1019     {
    1020         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1021 
    1022         if (m->fShutdown)
    1023             return setError(VBOX_E_INVALID_OBJECT_STATE,
    1024                             tr("This event source is already shut down"));
    1025 
    1026         Listeners::const_iterator it = m->mListeners.find(aListener);
    1027         if (it != m->mListeners.end())
    1028             return setError(E_INVALIDARG,
    1029                             tr("This listener already registered"));
    1030 
    1031         com::SafeArray<VBoxEventType_T> interested(ComSafeArrayInArg(aInterested));
    1032         RecordHolder<ListenerRecord> lrh(new ListenerRecord(aListener, interested, aActive, this));
    1033         m->mListeners.insert(Listeners::value_type(aListener, lrh));
    1034     }
     987HRESULT EventSource::registerListener(const ComPtr<IEventListener> &aListener,
     988                                      const std::vector<VBoxEventType_T> &aInteresting,
     989                                      BOOL aActive)
     990{
     991    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     992
     993    if (m->fShutdown)
     994        return setError(VBOX_E_INVALID_OBJECT_STATE,
     995                        tr("This event source is already shut down"));
     996
     997    Listeners::const_iterator it = m->mListeners.find(aListener);
     998    if (it != m->mListeners.end())
     999        return setError(E_INVALIDARG,
     1000                        tr("This listener already registered"));
     1001
     1002    com::SafeArray<VBoxEventType_T> interested(aInteresting);
     1003    RecordHolder<ListenerRecord> lrh(new ListenerRecord(aListener, interested, aActive, this));
     1004    m->mListeners.insert(Listeners::value_type((IEventListener *)aListener, lrh));
    10351005
    10361006    VBoxEventDesc evDesc;
    1037     evDesc.init(this, VBoxEventType_OnEventSourceChanged, aListener, TRUE);
     1007    evDesc.init(this, VBoxEventType_OnEventSourceChanged, (IEventListener *)aListener, TRUE);
    10381008    evDesc.fire(0);
    10391009
    … …  
    10411011}
    10421012
    1043 STDMETHODIMP EventSource::UnregisterListener(IEventListener *aListener)
    1044 {
    1045     CheckComArgNotNull(aListener);
    1046 
    1047     AutoCaller autoCaller(this);
    1048     if (FAILED(autoCaller.rc()))
    1049         return autoCaller.rc();
    1050 
    1051     HRESULT rc;
    1052     {
    1053         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1054 
    1055         Listeners::iterator it = m->mListeners.find(aListener);
    1056 
    1057         if (it != m->mListeners.end())
    1058         {
    1059             it->second.obj()->shutdown();
    1060             m->mListeners.erase(it);
    1061             // destructor removes refs from the event map
    1062             rc = S_OK;
    1063         }
    1064         else
    1065         {
    1066             rc = setError(VBOX_E_OBJECT_NOT_FOUND,
    1067                           tr("Listener was never registered"));
    1068         }
     1013HRESULT EventSource::unregisterListener(const ComPtr<IEventListener> &aListener)
     1014{
     1015    HRESULT rc = S_OK;;
     1016
     1017    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1018
     1019    Listeners::iterator it = m->mListeners.find(aListener);
     1020
     1021    if (it != m->mListeners.end())
     1022    {
     1023        it->second.obj()->shutdown();
     1024        m->mListeners.erase(it);
     1025        // destructor removes refs from the event map
     1026        rc = S_OK;
     1027    }
     1028    else
     1029    {
     1030        rc = setError(VBOX_E_OBJECT_NOT_FOUND,
     1031                      tr("Listener was never registered"));
    10691032    }
    10701033
    … …  
    10721035    {
    10731036        VBoxEventDesc evDesc;
    1074         evDesc.init(this, VBoxEventType_OnEventSourceChanged, aListener, FALSE);
     1037        evDesc.init(this, VBoxEventType_OnEventSourceChanged, (IEventListener *)aListener, FALSE);
    10751038        evDesc.fire(0);
    10761039    }
    … …  
    10791042}
    10801043
    1081 STDMETHODIMP EventSource::FireEvent(IEvent *aEvent,
    1082                                     LONG aTimeout,
    1083                                     BOOL *aProcessed)
    1084 {
    1085     CheckComArgNotNull(aEvent);
    1086     CheckComArgOutPointerValid(aProcessed);
    1087 
    1088     AutoCaller autoCaller(this);
    1089     if (FAILED(autoCaller.rc()))
    1090         return autoCaller.rc();
    1091 
    1092     HRESULT hrc;
     1044HRESULT EventSource::fireEvent(const ComPtr<IEvent> &aEvent,
     1045                               LONG aTimeout,
     1046                               BOOL *aResult)
     1047{
     1048
     1049    HRESULT hrc = S_OK;
    10931050    BOOL aWaitable = FALSE;
    10941051    aEvent->COMGETTER(Waitable)(&aWaitable);
    … …  
    11581115
    11591116    if (aWaitable)
    1160         hrc = aEvent->WaitProcessed(aTimeout, aProcessed);
     1117        hrc = aEvent->WaitProcessed(aTimeout, aResult);
    11611118    else
    1162         *aProcessed = TRUE;
     1119        *aResult = TRUE;
    11631120
    11641121    return hrc;
    11651122}
    11661123
    1167 
    1168 STDMETHODIMP EventSource::GetEvent(IEventListener *aListener,
    1169                                    LONG aTimeout,
    1170                                    IEvent **aEvent)
    1171 {
    1172 
    1173     CheckComArgNotNull(aListener);
    1174 
    1175     AutoCaller autoCaller(this);
    1176     if (FAILED(autoCaller.rc()))
    1177         return autoCaller.rc();
    1178 
     1124HRESULT EventSource::getEvent(const ComPtr<IEventListener> &aListener,
     1125                              LONG aTimeout,
     1126                              ComPtr<IEvent> &aEvent)
     1127{
    11791128    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    11801129
    … …  
    11841133
    11851134    Listeners::iterator it = m->mListeners.find(aListener);
    1186     HRESULT rc;
     1135    HRESULT rc = S_OK;
     1136
     1137    IEvent *ae = aEvent;
    11871138
    11881139    if (it != m->mListeners.end())
    1189         rc = it->second.obj()->dequeue(aEvent, aTimeout, alock);
     1140        rc = it->second.obj()->dequeue(&ae, aTimeout, alock);
    11901141    else
    11911142        rc = setError(VBOX_E_OBJECT_NOT_FOUND,
    … …  
    11981149}
    11991150
    1200 STDMETHODIMP EventSource::EventProcessed(IEventListener *aListener,
    1201                                          IEvent *aEvent)
    1202 {
    1203     CheckComArgNotNull(aListener);
    1204     CheckComArgNotNull(aEvent);
    1205 
    1206     AutoCaller autoCaller(this);
    1207     if (FAILED(autoCaller.rc()))
    1208         return autoCaller.rc();
    1209 
     1151HRESULT EventSource::eventProcessed(const ComPtr<IEventListener> &aListener,
     1152                                    const ComPtr<IEvent> &aEvent)
     1153{
    12101154    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    12111155
    … …  
    13911335
    13921336    // internal public
    1393     HRESULT init(ComSafeArrayIn(IEventSource *, aSources));
     1337    HRESULT init(const std::vector<ComPtr<IEventSource> >  aSourcesIn);
    13941338
    13951339    // IEventSource methods
    … …  
    14231367NS_DECL_CLASSINFO(PassiveEventListener)
    14241368NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PassiveEventListener, IEventListener)
    1425 NS_DECL_CLASSINFO(VBoxEvent)
    1426 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VBoxEvent, IEvent)
    1427 NS_DECL_CLASSINFO(VBoxVetoEvent)
    14281369NS_IMPL_ISUPPORTS_INHERITED1(VBoxVetoEvent, VBoxEvent, IVetoEvent)
    1429 NS_DECL_CLASSINFO(EventSource)
    1430 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EventSource, IEventSource)
    14311370NS_DECL_CLASSINFO(EventSourceAggregator)
    14321371NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EventSourceAggregator, IEventSource)
    … …  
    14341373
    14351374
    1436 STDMETHODIMP EventSource::CreateListener(IEventListener **aListener)
    1437 {
    1438     CheckComArgOutPointerValid(aListener);
    1439 
    1440     AutoCaller autoCaller(this);
    1441     if (FAILED(autoCaller.rc()))
    1442         return autoCaller.rc();
    1443 
     1375HRESULT EventSource::createListener(ComPtr<IEventListener> &aListener)
     1376{
    14441377    ComObjPtr<PassiveEventListener> listener;
    14451378
    … …  
    14471380    ComAssertMsgRet(SUCCEEDED(rc), ("Could not create wrapper object (%Rhrc)", rc),
    14481381                    E_FAIL);
    1449     listener.queryInterfaceTo(aListener);
    1450     return S_OK;
    1451 }
    1452 
    1453 
    1454 STDMETHODIMP EventSource::CreateAggregator(ComSafeArrayIn(IEventSource *, aSubordinates),
    1455                                            IEventSource **aResult)
    1456 {
    1457     CheckComArgOutPointerValid(aResult);
    1458 
    1459     AutoCaller autoCaller(this);
    1460     if (FAILED(autoCaller.rc()))
    1461         return autoCaller.rc();
    1462 
     1382    listener.queryInterfaceTo(aListener.asOutParam());
     1383    return S_OK;
     1384}
     1385
     1386HRESULT EventSource::createAggregator(const std::vector<ComPtr<IEventSource> > &aSubordinates,
     1387                                      ComPtr<IEventSource> &aResult)
     1388{
    14631389    ComObjPtr<EventSourceAggregator> agg;
    14641390
    … …  
    14671393                    E_FAIL);
    14681394
    1469     rc = agg->init(ComSafeArrayInArg(aSubordinates));
     1395    rc = agg->init(aSubordinates);
    14701396    if (FAILED(rc))
    14711397        return rc;
    14721398
    1473     agg.queryInterfaceTo(aResult);
    1474     return S_OK;
    1475 }
    1476 
    1477 HRESULT EventSourceAggregator::init(ComSafeArrayIn(IEventSource *, aSourcesIn))
     1399    agg.queryInterfaceTo(aResult.asOutParam());
     1400    return S_OK;
     1401}
     1402
     1403HRESULT EventSourceAggregator::init(const std::vector<ComPtr<IEventSource> >  aSourcesIn)
    14781404{
    14791405    HRESULT rc;
    … …  
    14891415                    E_FAIL);
    14901416
    1491     com::SafeIfaceArray<IEventSource> aSources(ComSafeArrayInArg (aSourcesIn));
    1492 
    1493     size_t cSize = aSources.size();
    1494 
    1495     for (size_t i = 0; i < cSize; i++)
    1496     {
    1497         if (aSources[i] != NULL)
    1498             mEventSources.push_back(aSources[i]);
     1417    for (size_t i = 0; i < aSourcesIn.size(); i++)
     1418    {
     1419        if (aSourcesIn[i] != NULL)
     1420            mEventSources.push_back(aSourcesIn[i]);
    14991421    }
    15001422
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