dlls/windows.gaming.input/vector.c

   1 /* WinRT Windows.Gaming.Input implementation
   2  *
   3  * Copyright 2021 Rémi Bernon for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "private.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(combase);
  25
  26 struct iterator
  27 {
  28     IIterator_IInspectable IIterator_IInspectable_iface;
  29     const GUID *iid;
  30     LONG ref;
  31
  32     IVectorView_IInspectable *view;
  33     UINT32 index;
  34     UINT32 size;
  35 };
  36
  37 static inline struct iterator *impl_from_IIterator_IInspectable( IIterator_IInspectable *iface )
  38 {
  39     return CONTAINING_RECORD( iface, struct iterator, IIterator_IInspectable_iface );
  40 }
  41
  42 static HRESULT WINAPI iterator_QueryInterface( IIterator_IInspectable *iface, REFIID iid, void **out )
  43 {
  44     struct iterator *impl = impl_from_IIterator_IInspectable( iface );
  45
  46     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
  47
  48     if (IsEqualGUID( iid, &IID_IUnknown ) ||
  49         IsEqualGUID( iid, &IID_IInspectable ) ||
  50         IsEqualGUID( iid, &IID_IAgileObject ) ||
  51         IsEqualGUID( iid, impl->iid ))
  52     {
  53         IInspectable_AddRef( (*out = &impl->IIterator_IInspectable_iface) );
  54         return S_OK;
  55     }
  56
  57     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
  58     *out = NULL;
  59     return E_NOINTERFACE;
  60 }
  61
  62 static ULONG WINAPI iterator_AddRef( IIterator_IInspectable *iface )
  63 {
  64     struct iterator *impl = impl_from_IIterator_IInspectable( iface );
  65     ULONG ref = InterlockedIncrement( &impl->ref );
  66     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
  67     return ref;
  68 }
  69
  70 static ULONG WINAPI iterator_Release( IIterator_IInspectable *iface )
  71 {
  72     struct iterator *impl = impl_from_IIterator_IInspectable( iface );
  73     ULONG ref = InterlockedDecrement( &impl->ref );
  74
  75     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
  76
  77     if (!ref)
  78     {
  79         IVectorView_IInspectable_Release( impl->view );
  80         free( impl );
  81     }
  82
  83     return ref;
  84 }
  85
  86 static HRESULT WINAPI iterator_GetIids( IIterator_IInspectable *iface, ULONG *iid_count, IID **iids )
  87 {
  88     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
  89     return E_NOTIMPL;
  90 }
  91
  92 static HRESULT WINAPI iterator_GetRuntimeClassName( IIterator_IInspectable *iface, HSTRING *class_name )
  93 {
  94     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
  95     return E_NOTIMPL;
  96 }
  97
  98 static HRESULT WINAPI iterator_GetTrustLevel( IIterator_IInspectable *iface, TrustLevel *trust_level )
  99 {
 100     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 101     return E_NOTIMPL;
 102 }
 103
 104 static HRESULT WINAPI iterator_get_Current( IIterator_IInspectable *iface, IInspectable **value )
 105 {
 106     struct iterator *impl = impl_from_IIterator_IInspectable( iface );
 107     TRACE( "iface %p, value %p.\n", iface, value );
 108     return IVectorView_IInspectable_GetAt( impl->view, impl->index, value );
 109 }
 110
 111 static HRESULT WINAPI iterator_get_HasCurrent( IIterator_IInspectable *iface, boolean *value )
 112 {
 113     struct iterator *impl = impl_from_IIterator_IInspectable( iface );
 114
 115     TRACE( "iface %p, value %p.\n", iface, value );
 116
 117     *value = impl->index < impl->size;
 118     return S_OK;
 119 }
 120
 121 static HRESULT WINAPI iterator_MoveNext( IIterator_IInspectable *iface, boolean *value )
 122 {
 123     struct iterator *impl = impl_from_IIterator_IInspectable( iface );
 124
 125     TRACE( "iface %p, value %p.\n", iface, value );
 126
 127     if (impl->index < impl->size) impl->index++;
 128     return IIterator_IInspectable_get_HasCurrent( iface, value );
 129 }
 130
 131 static HRESULT WINAPI iterator_GetMany( IIterator_IInspectable *iface, UINT32 items_size,
 132                                         IInspectable **items, UINT *count )
 133 {
 134     struct iterator *impl = impl_from_IIterator_IInspectable( iface );
 135     TRACE( "iface %p, items_size %u, items %p, count %p.\n", iface, items_size, items, count );
 136     return IVectorView_IInspectable_GetMany( impl->view, impl->index, items_size, items, count );
 137 }
 138
 139 static const IIterator_IInspectableVtbl iterator_vtbl =
 140 {
 141     iterator_QueryInterface,
 142     iterator_AddRef,
 143     iterator_Release,
 144     /* IInspectable methods */
 145     iterator_GetIids,
 146     iterator_GetRuntimeClassName,
 147     iterator_GetTrustLevel,
 148     /* IIterator<IInspectable*> methods */
 149     iterator_get_Current,
 150     iterator_get_HasCurrent,
 151     iterator_MoveNext,
 152     iterator_GetMany,
 153 };
 154
 155 struct vector_view
 156 {
 157     IVectorView_IInspectable IVectorView_IInspectable_iface;
 158     IIterable_IInspectable IIterable_IInspectable_iface;
 159     struct vector_iids iids;
 160     LONG ref;
 161
 162     UINT32 size;
 163     IInspectable *elements[1];
 164 };
 165
 166 static inline struct vector_view *impl_from_IVectorView_IInspectable( IVectorView_IInspectable *iface )
 167 {
 168     return CONTAINING_RECORD( iface, struct vector_view, IVectorView_IInspectable_iface );
 169 }
 170
 171 static HRESULT WINAPI vector_view_QueryInterface( IVectorView_IInspectable *iface, REFIID iid, void **out )
 172 {
 173     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 174
 175     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 176
 177     if (IsEqualGUID( iid, &IID_IUnknown ) ||
 178         IsEqualGUID( iid, &IID_IInspectable ) ||
 179         IsEqualGUID( iid, &IID_IAgileObject ) ||
 180         IsEqualGUID( iid, impl->iids.view ))
 181     {
 182         IInspectable_AddRef( (*out = &impl->IVectorView_IInspectable_iface) );
 183         return S_OK;
 184     }
 185
 186     if (IsEqualGUID( iid, impl->iids.iterable ))
 187     {
 188         IInspectable_AddRef( (*out = &impl->IIterable_IInspectable_iface) );
 189         return S_OK;
 190     }
 191
 192     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 193     *out = NULL;
 194     return E_NOINTERFACE;
 195 }
 196
 197 static ULONG WINAPI vector_view_AddRef( IVectorView_IInspectable *iface )
 198 {
 199     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 200     ULONG ref = InterlockedIncrement( &impl->ref );
 201     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 202     return ref;
 203 }
 204
 205 static ULONG WINAPI vector_view_Release( IVectorView_IInspectable *iface )
 206 {
 207     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 208     ULONG i, ref = InterlockedDecrement( &impl->ref );
 209
 210     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 211
 212     if (!ref)
 213     {
 214         for (i = 0; i < impl->size; ++i) IInspectable_Release( impl->elements[i] );
 215         free( impl );
 216     }
 217
 218     return ref;
 219 }
 220
 221 static HRESULT WINAPI vector_view_GetIids( IVectorView_IInspectable *iface, ULONG *iid_count, IID **iids )
 222 {
 223     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI vector_view_GetRuntimeClassName( IVectorView_IInspectable *iface, HSTRING *class_name )
 228 {
 229     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI vector_view_GetTrustLevel( IVectorView_IInspectable *iface, TrustLevel *trust_level )
 234 {
 235     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 236     return E_NOTIMPL;
 237 }
 238
 239 static HRESULT WINAPI vector_view_GetAt( IVectorView_IInspectable *iface, UINT32 index, IInspectable **value )
 240 {
 241     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 242
 243     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 244
 245     *value = NULL;
 246     if (index >= impl->size) return E_BOUNDS;
 247
 248     IInspectable_AddRef( (*value = impl->elements[index]) );
 249     return S_OK;
 250 }
 251
 252 static HRESULT WINAPI vector_view_get_Size( IVectorView_IInspectable *iface, UINT32 *value )
 253 {
 254     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 255
 256     TRACE( "iface %p, value %p.\n", iface, value );
 257
 258     *value = impl->size;
 259     return S_OK;
 260 }
 261
 262 static HRESULT WINAPI vector_view_IndexOf( IVectorView_IInspectable *iface, IInspectable *element,
 263                                            UINT32 *index, BOOLEAN *found )
 264 {
 265     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 266     ULONG i;
 267
 268     TRACE( "iface %p, element %p, index %p, found %p.\n", iface, element, index, found );
 269
 270     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
 271     if ((*found = (i < impl->size))) *index = i;
 272     else *index = 0;
 273
 274     return S_OK;
 275 }
 276
 277 static HRESULT WINAPI vector_view_GetMany( IVectorView_IInspectable *iface, UINT32 start_index,
 278                                            UINT32 items_size, IInspectable **items, UINT *count )
 279 {
 280     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 281     UINT32 i;
 282
 283     TRACE( "iface %p, start_index %u, items_size %u, items %p, count %p.\n",
 284            iface, start_index, items_size, items, count );
 285
 286     if (start_index >= impl->size) return E_BOUNDS;
 287
 288     for (i = start_index; i < impl->size; ++i)
 289     {
 290         if (i - start_index >= items_size) break;
 291         IInspectable_AddRef( (items[i - start_index] = impl->elements[i]) );
 292     }
 293     *count = i - start_index;
 294
 295     return S_OK;
 296 }
 297
 298 static const struct IVectorView_IInspectableVtbl vector_view_vtbl =
 299 {
 300     vector_view_QueryInterface,
 301     vector_view_AddRef,
 302     vector_view_Release,
 303     /* IInspectable methods */
 304     vector_view_GetIids,
 305     vector_view_GetRuntimeClassName,
 306     vector_view_GetTrustLevel,
 307     /* IVectorView<IInspectable*> methods */
 308     vector_view_GetAt,
 309     vector_view_get_Size,
 310     vector_view_IndexOf,
 311     vector_view_GetMany,
 312 };
 313
 314 DEFINE_IINSPECTABLE_( iterable_view, IIterable_IInspectable, struct vector_view, view_impl_from_IIterable_IInspectable,
 315                       IIterable_IInspectable_iface, &impl->IVectorView_IInspectable_iface )
 316
 317 static HRESULT WINAPI iterable_view_First( IIterable_IInspectable *iface, IIterator_IInspectable **value )
 318 {
 319     struct vector_view *impl = view_impl_from_IIterable_IInspectable( iface );
 320     struct iterator *iter;
 321
 322     TRACE( "iface %p, value %p.\n", iface, value );
 323
 324     if (!(iter = calloc( 1, sizeof(struct iterator) ))) return E_OUTOFMEMORY;
 325     iter->IIterator_IInspectable_iface.lpVtbl = &iterator_vtbl;
 326     iter->iid = impl->iids.iterator;
 327     iter->ref = 1;
 328
 329     IVectorView_IInspectable_AddRef( (iter->view = &impl->IVectorView_IInspectable_iface) );
 330     iter->size = impl->size;
 331
 332     *value = &iter->IIterator_IInspectable_iface;
 333     return S_OK;
 334 }
 335
 336 static const struct IIterable_IInspectableVtbl iterable_view_vtbl =
 337 {
 338     iterable_view_QueryInterface,
 339     iterable_view_AddRef,
 340     iterable_view_Release,
 341     /* IInspectable methods */
 342     iterable_view_GetIids,
 343     iterable_view_GetRuntimeClassName,
 344     iterable_view_GetTrustLevel,
 345     /* IIterable<T> methods */
 346     iterable_view_First,
 347 };
 348
 349 struct vector
 350 {
 351     IVector_IInspectable IVector_IInspectable_iface;
 352     IIterable_IInspectable IIterable_IInspectable_iface;
 353     struct vector_iids iids;
 354     LONG ref;
 355
 356     UINT32 size;
 357     UINT32 capacity;
 358     IInspectable **elements;
 359 };
 360
 361 static inline struct vector *impl_from_IVector_IInspectable( IVector_IInspectable *iface )
 362 {
 363     return CONTAINING_RECORD( iface, struct vector, IVector_IInspectable_iface );
 364 }
 365
 366 static HRESULT WINAPI vector_QueryInterface( IVector_IInspectable *iface, REFIID iid, void **out )
 367 {
 368     struct vector *impl = impl_from_IVector_IInspectable( iface );
 369
 370     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 371
 372     if (IsEqualGUID( iid, &IID_IUnknown ) ||
 373         IsEqualGUID( iid, &IID_IInspectable ) ||
 374         IsEqualGUID( iid, &IID_IAgileObject ) ||
 375         IsEqualGUID( iid, impl->iids.vector ))
 376     {
 377         IInspectable_AddRef( (*out = &impl->IVector_IInspectable_iface) );
 378         return S_OK;
 379     }
 380
 381     if (IsEqualGUID( iid, impl->iids.iterable ))
 382     {
 383         IInspectable_AddRef( (*out = &impl->IIterable_IInspectable_iface) );
 384         return S_OK;
 385     }
 386
 387     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 388     *out = NULL;
 389     return E_NOINTERFACE;
 390 }
 391
 392 static ULONG WINAPI vector_AddRef( IVector_IInspectable *iface )
 393 {
 394     struct vector *impl = impl_from_IVector_IInspectable( iface );
 395     ULONG ref = InterlockedIncrement( &impl->ref );
 396     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 397     return ref;
 398 }
 399
 400 static ULONG WINAPI vector_Release( IVector_IInspectable *iface )
 401 {
 402     struct vector *impl = impl_from_IVector_IInspectable( iface );
 403     ULONG ref = InterlockedDecrement( &impl->ref );
 404
 405     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 406
 407     if (!ref)
 408     {
 409         IVector_IInspectable_Clear( iface );
 410         free( impl );
 411     }
 412
 413     return ref;
 414 }
 415
 416 static HRESULT WINAPI vector_GetIids( IVector_IInspectable *iface, ULONG *iid_count, IID **iids )
 417 {
 418     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 419     return E_NOTIMPL;
 420 }
 421
 422 static HRESULT WINAPI vector_GetRuntimeClassName( IVector_IInspectable *iface, HSTRING *class_name )
 423 {
 424     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
 425     return E_NOTIMPL;
 426 }
 427
 428 static HRESULT WINAPI vector_GetTrustLevel( IVector_IInspectable *iface, TrustLevel *trust_level )
 429 {
 430     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI vector_GetAt( IVector_IInspectable *iface, UINT32 index, IInspectable **value )
 435 {
 436     struct vector *impl = impl_from_IVector_IInspectable( iface );
 437
 438     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 439
 440     *value = NULL;
 441     if (index >= impl->size) return E_BOUNDS;
 442
 443     IInspectable_AddRef( (*value = impl->elements[index]) );
 444     return S_OK;
 445 }
 446
 447 static HRESULT WINAPI vector_get_Size( IVector_IInspectable *iface, UINT32 *value )
 448 {
 449     struct vector *impl = impl_from_IVector_IInspectable( iface );
 450     TRACE( "iface %p, value %p.\n", iface, value );
 451     *value = impl->size;
 452     return S_OK;
 453 }
 454
 455 static HRESULT WINAPI vector_GetView( IVector_IInspectable *iface, IVectorView_IInspectable **value )
 456 {
 457     struct vector *impl = impl_from_IVector_IInspectable( iface );
 458     struct vector_view *view;
 459     ULONG i;
 460
 461     TRACE( "iface %p, value %p.\n", iface, value );
 462
 463     if (!(view = calloc( 1, offsetof( struct vector_view, elements[impl->size] ) ))) return E_OUTOFMEMORY;
 464     view->IVectorView_IInspectable_iface.lpVtbl = &vector_view_vtbl;
 465     view->IIterable_IInspectable_iface.lpVtbl = &iterable_view_vtbl;
 466     view->iids = impl->iids;
 467     view->ref = 1;
 468
 469     for (i = 0; i < impl->size; ++i) IInspectable_AddRef( (view->elements[view->size++] = impl->elements[i]) );
 470
 471     *value = &view->IVectorView_IInspectable_iface;
 472     return S_OK;
 473 }
 474
 475 static HRESULT WINAPI vector_IndexOf( IVector_IInspectable *iface, IInspectable *element, UINT32 *index, BOOLEAN *found )
 476 {
 477     struct vector *impl = impl_from_IVector_IInspectable( iface );
 478     ULONG i;
 479
 480     TRACE( "iface %p, element %p, index %p, found %p.\n", iface, element, index, found );
 481
 482     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
 483     if ((*found = (i < impl->size))) *index = i;
 484     else *index = 0;
 485
 486     return S_OK;
 487 }
 488
 489 static HRESULT WINAPI vector_SetAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
 490 {
 491     struct vector *impl = impl_from_IVector_IInspectable( iface );
 492
 493     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 494
 495     if (index >= impl->size) return E_BOUNDS;
 496     IInspectable_Release( impl->elements[index] );
 497     IInspectable_AddRef( (impl->elements[index] = value) );
 498     return S_OK;
 499 }
 500
 501 static HRESULT WINAPI vector_InsertAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
 502 {
 503     struct vector *impl = impl_from_IVector_IInspectable( iface );
 504     IInspectable **tmp = impl->elements;
 505
 506     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 507
 508     if (impl->size == impl->capacity)
 509     {
 510         impl->capacity = max( 32, impl->capacity * 3 / 2 );
 511         if (!(impl->elements = realloc( impl->elements, impl->capacity * sizeof(*impl->elements) )))
 512         {
 513             impl->elements = tmp;
 514             return E_OUTOFMEMORY;
 515         }
 516     }
 517
 518     memmove( impl->elements + index + 1, impl->elements + index, (impl->size++ - index) * sizeof(*impl->elements) );
 519     IInspectable_AddRef( (impl->elements[index] = value) );
 520     return S_OK;
 521 }
 522
 523 static HRESULT WINAPI vector_RemoveAt( IVector_IInspectable *iface, UINT32 index )
 524 {
 525     struct vector *impl = impl_from_IVector_IInspectable( iface );
 526
 527     TRACE( "iface %p, index %u.\n", iface, index );
 528
 529     if (index >= impl->size) return E_BOUNDS;
 530     IInspectable_Release( impl->elements[index] );
 531     memmove( impl->elements + index, impl->elements + index + 1, (--impl->size - index) * sizeof(*impl->elements) );
 532     return S_OK;
 533 }
 534
 535 static HRESULT WINAPI vector_Append( IVector_IInspectable *iface, IInspectable *value )
 536 {
 537     struct vector *impl = impl_from_IVector_IInspectable( iface );
 538
 539     TRACE( "iface %p, value %p.\n", iface, value );
 540
 541     return IVector_IInspectable_InsertAt( iface, impl->size, value );
 542 }
 543
 544 static HRESULT WINAPI vector_RemoveAtEnd( IVector_IInspectable *iface )
 545 {
 546     struct vector *impl = impl_from_IVector_IInspectable( iface );
 547
 548     TRACE( "iface %p.\n", iface );
 549
 550     if (impl->size) IInspectable_Release( impl->elements[--impl->size] );
 551     return S_OK;
 552 }
 553
 554 static HRESULT WINAPI vector_Clear( IVector_IInspectable *iface )
 555 {
 556     struct vector *impl = impl_from_IVector_IInspectable( iface );
 557
 558     TRACE( "iface %p.\n", iface );
 559
 560     while (impl->size) IVector_IInspectable_RemoveAtEnd( iface );
 561     free( impl->elements );
 562     impl->capacity = 0;
 563     impl->elements = NULL;
 564
 565     return S_OK;
 566 }
 567
 568 static HRESULT WINAPI vector_GetMany( IVector_IInspectable *iface, UINT32 start_index,
 569                                       UINT32 items_size, IInspectable **items, UINT *count )
 570 {
 571     struct vector *impl = impl_from_IVector_IInspectable( iface );
 572     UINT32 i;
 573
 574     TRACE( "iface %p, start_index %u, items_size %u, items %p, count %p.\n",
 575            iface, start_index, items_size, items, count );
 576
 577     if (start_index >= impl->size) return E_BOUNDS;
 578
 579     for (i = start_index; i < impl->size; ++i)
 580     {
 581         if (i - start_index >= items_size) break;
 582         IInspectable_AddRef( (items[i - start_index] = impl->elements[i]) );
 583     }
 584     *count = i - start_index;
 585
 586     return S_OK;
 587 }
 588
 589 static HRESULT WINAPI vector_ReplaceAll( IVector_IInspectable *iface, UINT32 count, IInspectable **items )
 590 {
 591     HRESULT hr;
 592     ULONG i;
 593
 594     TRACE( "iface %p, count %u, items %p.\n", iface, count, items );
 595
 596     hr = IVector_IInspectable_Clear( iface );
 597     for (i = 0; i < count && SUCCEEDED(hr); ++i) hr = IVector_IInspectable_Append( iface, items[i] );
 598     return hr;
 599 }
 600
 601 static const struct IVector_IInspectableVtbl vector_vtbl =
 602 {
 603     vector_QueryInterface,
 604     vector_AddRef,
 605     vector_Release,
 606     /* IInspectable methods */
 607     vector_GetIids,
 608     vector_GetRuntimeClassName,
 609     vector_GetTrustLevel,
 610     /* IVector<IInspectable*> methods */
 611     vector_GetAt,
 612     vector_get_Size,
 613     vector_GetView,
 614     vector_IndexOf,
 615     vector_SetAt,
 616     vector_InsertAt,
 617     vector_RemoveAt,
 618     vector_Append,
 619     vector_RemoveAtEnd,
 620     vector_Clear,
 621     vector_GetMany,
 622     vector_ReplaceAll,
 623 };
 624
 625 DEFINE_IINSPECTABLE( iterable, IIterable_IInspectable, struct vector, IVector_IInspectable_iface )
 626
 627 static HRESULT WINAPI iterable_First( IIterable_IInspectable *iface, IIterator_IInspectable **value )
 628 {
 629     struct vector *impl = impl_from_IIterable_IInspectable( iface );
 630     IIterable_IInspectable *iterable;
 631     IVectorView_IInspectable *view;
 632     HRESULT hr;
 633
 634     TRACE( "iface %p, value %p.\n", iface, value );
 635
 636     if (FAILED(hr = IVector_IInspectable_GetView( &impl->IVector_IInspectable_iface, &view ))) return hr;
 637
 638     hr = IVectorView_IInspectable_QueryInterface( view, impl->iids.iterable, (void **)&iterable );
 639     IVectorView_IInspectable_Release( view );
 640     if (FAILED(hr)) return hr;
 641
 642     hr = IIterable_IInspectable_First( iterable, value );
 643     IIterable_IInspectable_Release( iterable );
 644     return hr;
 645 }
 646
 647 static const struct IIterable_IInspectableVtbl iterable_vtbl =
 648 {
 649     iterable_QueryInterface,
 650     iterable_AddRef,
 651     iterable_Release,
 652     /* IInspectable methods */
 653     iterable_GetIids,
 654     iterable_GetRuntimeClassName,
 655     iterable_GetTrustLevel,
 656     /* IIterable<T> methods */
 657     iterable_First,
 658 };
 659
 660 HRESULT vector_create( const struct vector_iids *iids, void **out )
 661 {
 662     struct vector *impl;
 663
 664     TRACE( "iid %s, out %p.\n", debugstr_guid( iids->vector ), out );
 665
 666     if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
 667     impl->IVector_IInspectable_iface.lpVtbl = &vector_vtbl;
 668     impl->IIterable_IInspectable_iface.lpVtbl = &iterable_vtbl;
 669     impl->iids = *iids;
 670     impl->ref = 1;
 671
 672     *out = &impl->IVector_IInspectable_iface;
 673     TRACE( "created %p\n", *out );
 674     return S_OK;
 675 }