dlls/windows.media.speech/vector.c

   1 /* WinRT Windows.Media.Speech implementation
   2  *
   3  * Copyright 2022 Bernhard Kölbl 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(speech);
  25
  26 /*
  27  *
  28  * IIterator<HSTRING>
  29  *
  30  */
  31
  32 struct iterator_hstring
  33 {
  34    IIterator_HSTRING IIterator_HSTRING_iface;
  35    LONG ref;
  36
  37    IVectorView_HSTRING *view;
  38    UINT32 index;
  39    UINT32 size;
  40 };
  41
  42 static inline struct iterator_hstring *impl_from_IIterator_HSTRING( IIterator_HSTRING *iface )
  43 {
  44    return CONTAINING_RECORD(iface, struct iterator_hstring, IIterator_HSTRING_iface);
  45 }
  46
  47 static HRESULT WINAPI iterator_hstring_QueryInterface( IIterator_HSTRING *iface, REFIID iid, void **out )
  48 {
  49     struct iterator_hstring *impl = impl_from_IIterator_HSTRING(iface);
  50
  51    TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  52
  53    if (IsEqualGUID(iid, &IID_IUnknown) ||
  54        IsEqualGUID(iid, &IID_IInspectable) ||
  55        IsEqualGUID(iid, &IID_IAgileObject) ||
  56        IsEqualGUID(iid, &IID_IIterator_HSTRING))
  57     {
  58        IInspectable_AddRef((*out = &impl->IIterator_HSTRING_iface));
  59        return S_OK;
  60     }
  61
  62     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  63     *out = NULL;
  64     return E_NOINTERFACE;
  65 }
  66
  67 static ULONG WINAPI iterator_hstring_AddRef( IIterator_HSTRING *iface )
  68 {
  69     struct iterator_hstring *impl = impl_from_IIterator_HSTRING(iface);
  70     ULONG ref = InterlockedIncrement(&impl->ref);
  71     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
  72     return ref;
  73 }
  74
  75 static ULONG WINAPI iterator_hstring_Release( IIterator_HSTRING *iface )
  76 {
  77     struct iterator_hstring *impl = impl_from_IIterator_HSTRING(iface);
  78     ULONG ref = InterlockedDecrement(&impl->ref);
  79
  80     TRACE("iface %p decreasing refcount to %lu.\n", iface, ref);
  81
  82     if (!ref)
  83     {
  84         IVectorView_HSTRING_Release(impl->view);
  85         free(impl);
  86     }
  87
  88     return ref;
  89 }
  90
  91 static HRESULT WINAPI iterator_hstring_GetIids( IIterator_HSTRING *iface, ULONG *iid_count, IID **iids )
  92 {
  93     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
  94     return E_NOTIMPL;
  95 }
  96
  97 static HRESULT WINAPI iterator_hstring_GetRuntimeClassName( IIterator_HSTRING *iface, HSTRING *class_name )
  98 {
  99     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 100     return E_NOTIMPL;
 101 }
 102
 103 static HRESULT WINAPI iterator_hstring_GetTrustLevel( IIterator_HSTRING *iface, TrustLevel *trust_level )
 104 {
 105     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 106     return E_NOTIMPL;
 107 }
 108
 109 static HRESULT WINAPI iterator_hstring_get_Current( IIterator_HSTRING *iface, HSTRING *value )
 110 {
 111     struct iterator_hstring *impl = impl_from_IIterator_HSTRING(iface);
 112     TRACE("iface %p, value %p.\n", iface, value);
 113     return IVectorView_HSTRING_GetAt(impl->view, impl->index, value);
 114 }
 115
 116 static HRESULT WINAPI iterator_hstring_get_HasCurrent( IIterator_HSTRING *iface, BOOL *value )
 117 {
 118     struct iterator_hstring *impl = impl_from_IIterator_HSTRING(iface);
 119
 120     TRACE("iface %p, value %p.\n", iface, value);
 121
 122     *value = impl->index < impl->size;
 123     return S_OK;
 124 }
 125
 126 static HRESULT WINAPI iterator_hstring_MoveNext( IIterator_HSTRING *iface, BOOL *value )
 127 {
 128     struct iterator_hstring *impl = impl_from_IIterator_HSTRING(iface);
 129
 130     TRACE("iface %p, value %p.\n", iface, value);
 131
 132     if (impl->index < impl->size) impl->index++;
 133     return IIterator_HSTRING_get_HasCurrent(iface, value);
 134 }
 135
 136 static HRESULT WINAPI iterator_hstring_GetMany( IIterator_HSTRING *iface, UINT32 items_size,
 137                                                 HSTRING *items, UINT *count )
 138 {
 139     struct iterator_hstring *impl = impl_from_IIterator_HSTRING(iface);
 140     TRACE("iface %p, items_size %u, items %p, count %p.\n", iface, items_size, items, count);
 141     return IVectorView_HSTRING_GetMany(impl->view, impl->index, items_size, items, count);
 142 }
 143
 144 static const IIterator_HSTRINGVtbl iterator_hstring_vtbl =
 145 {
 146     /* IUnknown methods */
 147     iterator_hstring_QueryInterface,
 148     iterator_hstring_AddRef,
 149     iterator_hstring_Release,
 150     /* IInspectable methods */
 151     iterator_hstring_GetIids,
 152     iterator_hstring_GetRuntimeClassName,
 153     iterator_hstring_GetTrustLevel,
 154     /* IIterator<HSTRING> methods */
 155     iterator_hstring_get_Current,
 156     iterator_hstring_get_HasCurrent,
 157     iterator_hstring_MoveNext,
 158     iterator_hstring_GetMany,
 159 };
 160
 161 /*
 162  *
 163  * IVectorView<HSTRING>
 164  *
 165  */
 166
 167 struct vector_view_hstring
 168 {
 169     IVectorView_HSTRING IVectorView_HSTRING_iface;
 170     IIterable_HSTRING IIterable_HSTRING_iface;
 171     LONG ref;
 172
 173     UINT32 size;
 174     HSTRING elements[];
 175 };
 176
 177 C_ASSERT(sizeof(struct vector_view_hstring) == offsetof(struct vector_view_hstring, elements[0]));
 178
 179 static inline struct vector_view_hstring *impl_from_IVectorView_HSTRING( IVectorView_HSTRING *iface )
 180 {
 181     return CONTAINING_RECORD(iface, struct vector_view_hstring, IVectorView_HSTRING_iface);
 182 }
 183
 184 static HRESULT WINAPI vector_view_hstring_QueryInterface( IVectorView_HSTRING *iface, REFIID iid, void **out )
 185 {
 186     struct vector_view_hstring *impl = impl_from_IVectorView_HSTRING(iface);
 187
 188     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 189
 190     if (IsEqualGUID(iid, &IID_IUnknown) ||
 191         IsEqualGUID(iid, &IID_IInspectable) ||
 192         IsEqualGUID(iid, &IID_IAgileObject) ||
 193         IsEqualGUID(iid, &IID_IVectorView_HSTRING))
 194     {
 195         IInspectable_AddRef((*out = &impl->IVectorView_HSTRING_iface));
 196         return S_OK;
 197     }
 198
 199     if (IsEqualGUID(iid, &IID_IIterable_HSTRING))
 200     {
 201         IInspectable_AddRef((*out = &impl->IIterable_HSTRING_iface));
 202         return S_OK;
 203     }
 204
 205     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 206     *out = NULL;
 207     return E_NOINTERFACE;
 208 }
 209
 210 static ULONG WINAPI vector_view_hstring_AddRef( IVectorView_HSTRING *iface )
 211 {
 212     struct vector_view_hstring *impl = impl_from_IVectorView_HSTRING(iface);
 213     ULONG ref = InterlockedIncrement(&impl->ref);
 214     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
 215     return ref;
 216 }
 217
 218 static ULONG WINAPI vector_view_hstring_Release( IVectorView_HSTRING *iface )
 219 {
 220     struct vector_view_hstring *impl = impl_from_IVectorView_HSTRING(iface);
 221     ULONG i, ref = InterlockedDecrement(&impl->ref);
 222
 223     TRACE("iface %p decreasing refcount to %lu.\n", iface, ref);
 224
 225     if (!ref)
 226     {
 227         for (i = 0; i < impl->size; ++i) WindowsDeleteString(impl->elements[i]);
 228         free(impl);
 229     }
 230
 231     return ref;
 232 }
 233
 234 static HRESULT WINAPI vector_view_hstring_GetIids( IVectorView_HSTRING *iface, ULONG *iid_count, IID **iids )
 235 {
 236     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI vector_view_hstring_GetRuntimeClassName( IVectorView_HSTRING *iface, HSTRING *class_name )
 241 {
 242     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI vector_view_hstring_GetTrustLevel( IVectorView_HSTRING *iface, TrustLevel *trust_level )
 247 {
 248     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI vector_view_hstring_GetAt( IVectorView_HSTRING *iface, UINT32 index, HSTRING *value )
 253 {
 254     struct vector_view_hstring *impl = impl_from_IVectorView_HSTRING(iface);
 255
 256     TRACE("iface %p, index %u, value %p.\n", iface, index, value);
 257
 258     *value = NULL;
 259     if (index >= impl->size) return E_BOUNDS;
 260
 261     return WindowsDuplicateString(impl->elements[index], value);
 262 }
 263
 264 static HRESULT WINAPI vector_view_hstring_get_Size( IVectorView_HSTRING *iface, UINT32 *value )
 265 {
 266     struct vector_view_hstring *impl = impl_from_IVectorView_HSTRING(iface);
 267
 268     TRACE("iface %p, value %p.\n", iface, value);
 269
 270     *value = impl->size;
 271     return S_OK;
 272 }
 273
 274 static HRESULT WINAPI vector_view_hstring_IndexOf( IVectorView_HSTRING *iface, HSTRING element,
 275                                                    UINT32 *index, BOOLEAN *found )
 276 {
 277     struct vector_view_hstring *impl = impl_from_IVectorView_HSTRING(iface);
 278     ULONG i;
 279
 280     TRACE("iface %p, element %p, index %p, found %p.\n", iface, element, index, found);
 281
 282     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
 283     if ((*found = (i < impl->size))) *index = i;
 284     else *index = 0;
 285
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI vector_view_hstring_GetMany( IVectorView_HSTRING *iface, UINT32 start_index,
 290                                                    UINT32 items_size, HSTRING *items, UINT *count )
 291 {
 292     struct vector_view_hstring *impl = impl_from_IVectorView_HSTRING(iface);
 293     HRESULT hr;
 294     UINT32 i;
 295
 296     TRACE( "iface %p, start_index %u, items_size %u, items %p, count %p.\n",
 297            iface, start_index, items_size, items, count );
 298
 299     if (start_index >= impl->size) return E_BOUNDS;
 300
 301     for (i = start_index; i < impl->size; ++i)
 302     {
 303         if (i - start_index >= items_size) break;
 304         if (FAILED(hr = WindowsDuplicateString(impl->elements[i], &items[i - start_index]))) goto error;
 305     }
 306     *count = i - start_index;
 307
 308     return S_OK;
 309
 310 error:
 311     *count = 0;
 312     while (i-- > start_index) WindowsDeleteString(items[i-start_index]);
 313     return hr;
 314 }
 315
 316 static const struct IVectorView_HSTRINGVtbl vector_view_hstring_vtbl =
 317 {
 318     /* IUnknown methods */
 319     vector_view_hstring_QueryInterface,
 320     vector_view_hstring_AddRef,
 321     vector_view_hstring_Release,
 322     /* IInspectable methods */
 323     vector_view_hstring_GetIids,
 324     vector_view_hstring_GetRuntimeClassName,
 325     vector_view_hstring_GetTrustLevel,
 326     /* IVectorView<HSTRING> methods */
 327     vector_view_hstring_GetAt,
 328     vector_view_hstring_get_Size,
 329     vector_view_hstring_IndexOf,
 330     vector_view_hstring_GetMany,
 331 };
 332
 333 /*
 334  *
 335  * IIterable<HSTRING>
 336  *
 337  */
 338
 339 DEFINE_IINSPECTABLE_(iterable_view_hstring, IIterable_HSTRING, struct vector_view_hstring, view_impl_from_IIterable_HSTRING,
 340                      IIterable_HSTRING_iface, &impl->IVectorView_HSTRING_iface)
 341
 342 static HRESULT WINAPI iterable_view_hstring_First( IIterable_HSTRING *iface, IIterator_HSTRING **value )
 343 {
 344     struct vector_view_hstring *impl = view_impl_from_IIterable_HSTRING(iface);
 345     struct iterator_hstring *iter;
 346
 347     TRACE("iface %p, value %p.\n", iface, value);
 348
 349     if (!(iter = calloc(1, sizeof(*iter)))) return E_OUTOFMEMORY;
 350     iter->IIterator_HSTRING_iface.lpVtbl = &iterator_hstring_vtbl;
 351     iter->ref = 1;
 352
 353     IVectorView_HSTRING_AddRef((iter->view = &impl->IVectorView_HSTRING_iface));
 354     iter->size = impl->size;
 355
 356     *value = &iter->IIterator_HSTRING_iface;
 357     return S_OK;
 358 }
 359
 360 static const struct IIterable_HSTRINGVtbl iterable_view_hstring_vtbl =
 361 {
 362     /* IUnknown methods */
 363     iterable_view_hstring_QueryInterface,
 364     iterable_view_hstring_AddRef,
 365     iterable_view_hstring_Release,
 366     /* IInspectable methods */
 367     iterable_view_hstring_GetIids,
 368     iterable_view_hstring_GetRuntimeClassName,
 369     iterable_view_hstring_GetTrustLevel,
 370     /* IIterable<HSTRING> methods */
 371     iterable_view_hstring_First,
 372 };
 373
 374 /*
 375  *
 376  * IVector<HSTRING>
 377  *
 378  */
 379
 380 struct vector_hstring
 381 {
 382     IVector_HSTRING IVector_HSTRING_iface;
 383     IIterable_HSTRING IIterable_HSTRING_iface;
 384     LONG ref;
 385
 386     UINT32 size;
 387     UINT32 capacity;
 388     HSTRING *elements;
 389 };
 390
 391 static inline struct vector_hstring *impl_from_IVector_HSTRING( IVector_HSTRING *iface )
 392 {
 393     return CONTAINING_RECORD(iface, struct vector_hstring, IVector_HSTRING_iface);
 394 }
 395
 396 static HRESULT WINAPI vector_hstring_QueryInterface( IVector_HSTRING *iface, REFIID iid, void **out )
 397 {
 398     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 399
 400     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 401
 402     if (IsEqualGUID(iid, &IID_IUnknown) ||
 403         IsEqualGUID(iid, &IID_IInspectable) ||
 404         IsEqualGUID(iid, &IID_IAgileObject) ||
 405         IsEqualGUID(iid, &IID_IVector_HSTRING))
 406     {
 407         IInspectable_AddRef((*out = &impl->IVector_HSTRING_iface));
 408         return S_OK;
 409     }
 410
 411     if (IsEqualGUID(iid, &IID_IIterable_HSTRING))
 412     {
 413         IInspectable_AddRef((*out = &impl->IIterable_HSTRING_iface));
 414         return S_OK;
 415     }
 416
 417     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 418     *out = NULL;
 419     return E_NOINTERFACE;
 420 }
 421
 422 static ULONG WINAPI vector_hstring_AddRef( IVector_HSTRING *iface )
 423 {
 424     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 425     ULONG ref = InterlockedIncrement(&impl->ref);
 426     TRACE("iface %p, ref %lu.\n", iface, ref);
 427     return ref;
 428 }
 429
 430 static ULONG WINAPI vector_hstring_Release( IVector_HSTRING *iface )
 431 {
 432     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 433     ULONG ref = InterlockedDecrement(&impl->ref);
 434
 435     TRACE("iface %p, ref %lu.\n", iface, ref);
 436
 437     if (!ref)
 438     {
 439         IVector_HSTRING_Clear(iface);
 440         free(impl);
 441     }
 442
 443     return ref;
 444 }
 445
 446 static HRESULT WINAPI vector_hstring_GetIids( IVector_HSTRING *iface, ULONG *iid_count, IID **iids )
 447 {
 448     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 449     return E_NOTIMPL;
 450 }
 451
 452 static HRESULT WINAPI vector_hstring_GetRuntimeClassName( IVector_HSTRING *iface, HSTRING *class_name )
 453 {
 454     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
 455     return E_NOTIMPL;
 456 }
 457
 458 static HRESULT WINAPI vector_hstring_GetTrustLevel( IVector_HSTRING *iface, TrustLevel *trust_level )
 459 {
 460     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI vector_hstring_GetAt( IVector_HSTRING *iface, UINT32 index, HSTRING *value )
 465 {
 466     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 467
 468     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 469
 470     *value = NULL;
 471     if (index >= impl->size) return E_BOUNDS;
 472
 473     return WindowsDuplicateString(impl->elements[index], value);
 474 }
 475
 476 static HRESULT WINAPI vector_hstring_get_Size( IVector_HSTRING *iface, UINT32 *value )
 477 {
 478     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 479     TRACE( "iface %p, value %p.\n", iface, value );
 480     *value = impl->size;
 481     return S_OK;
 482 }
 483
 484 static HRESULT WINAPI vector_hstring_GetView( IVector_HSTRING *iface, IVectorView_HSTRING **value )
 485 {
 486     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 487     struct vector_view_hstring *view;
 488     HRESULT hr;
 489     ULONG i;
 490
 491     TRACE("iface %p, value %p.\n", iface, value);
 492
 493     if (!(view = calloc(1, offsetof(struct vector_view_hstring, elements[impl->size])))) return E_OUTOFMEMORY;
 494     view->IVectorView_HSTRING_iface.lpVtbl = &vector_view_hstring_vtbl;
 495     view->IIterable_HSTRING_iface.lpVtbl = &iterable_view_hstring_vtbl;
 496     view->ref = 1;
 497
 498     for (i = 0; i < impl->size; ++i)
 499         if (FAILED(hr = WindowsDuplicateString(impl->elements[i], &view->elements[view->size++]))) goto error;
 500
 501     *value = &view->IVectorView_HSTRING_iface;
 502     return S_OK;
 503
 504 error:
 505     while (i-- > 0) WindowsDeleteString(view->elements[i]);
 506     free(view);
 507     return hr;
 508 }
 509
 510 static HRESULT WINAPI vector_hstring_IndexOf( IVector_HSTRING *iface, HSTRING element, UINT32 *index, BOOLEAN *found )
 511 {
 512     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 513     ULONG i;
 514
 515     TRACE("iface %p, element %p, index %p, found %p.\n", iface, element, index, found);
 516
 517     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
 518     if ((*found = (i < impl->size))) *index = i;
 519     else *index = 0;
 520
 521     return S_OK;
 522 }
 523
 524 static HRESULT WINAPI vector_hstring_SetAt( IVector_HSTRING *iface, UINT32 index, HSTRING value )
 525 {
 526     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 527     HSTRING tmp;
 528     HRESULT hr;
 529
 530     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 531
 532     if (index >= impl->size) return E_BOUNDS;
 533
 534     if (FAILED(hr = WindowsDuplicateString(value, &tmp))) return hr;
 535
 536     WindowsDeleteString(impl->elements[index]);
 537     impl->elements[index] = tmp;
 538     return S_OK;
 539 }
 540
 541 static HRESULT WINAPI vector_hstring_InsertAt( IVector_HSTRING *iface, UINT32 index, HSTRING value )
 542 {
 543     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 544     HSTRING tmp, *tmp2 = impl->elements;
 545     HRESULT hr;
 546
 547     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 548
 549     if (FAILED(hr = WindowsDuplicateString(value, &tmp))) return hr;
 550
 551     if (impl->size == impl->capacity)
 552     {
 553         impl->capacity = max(32, impl->capacity * 3 / 2);
 554         if (!(impl->elements = realloc(impl->elements, impl->capacity * sizeof(*impl->elements))))
 555         {
 556             impl->elements = tmp2;
 557             return E_OUTOFMEMORY;
 558         }
 559     }
 560
 561     memmove(impl->elements + index + 1, impl->elements + index, (impl->size++ - index) * sizeof(*impl->elements));
 562     impl->elements[index] = tmp;
 563     return S_OK;
 564 }
 565
 566 static HRESULT WINAPI vector_hstring_RemoveAt( IVector_HSTRING *iface, UINT32 index )
 567 {
 568     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 569
 570     TRACE("iface %p, index %u.\n", iface, index);
 571
 572     if (index >= impl->size) return E_BOUNDS;
 573
 574     WindowsDeleteString(impl->elements[index]);
 575     memmove(impl->elements + index, impl->elements + index + 1, (--impl->size - index) * sizeof(*impl->elements));
 576     return S_OK;
 577 }
 578
 579 static HRESULT WINAPI vector_hstring_Append( IVector_HSTRING *iface, HSTRING value )
 580 {
 581     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 582
 583     TRACE("iface %p, value %p.\n", iface, value);
 584
 585     return IVector_HSTRING_InsertAt(iface, impl->size, value);
 586 }
 587
 588 static HRESULT WINAPI vector_hstring_RemoveAtEnd( IVector_HSTRING *iface )
 589 {
 590     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 591
 592     TRACE("iface %p.\n", iface);
 593
 594     if (impl->size) WindowsDeleteString(impl->elements[--impl->size]);
 595     return S_OK;
 596 }
 597
 598 static HRESULT WINAPI vector_hstring_Clear( IVector_HSTRING *iface )
 599 {
 600     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 601
 602     TRACE("iface %p.\n", iface);
 603
 604     while (impl->size) IVector_HSTRING_RemoveAtEnd(iface);
 605     free(impl->elements);
 606     impl->capacity = 0;
 607     impl->elements = NULL;
 608
 609     return S_OK;
 610 }
 611
 612 static HRESULT WINAPI vector_hstring_GetMany( IVector_HSTRING *iface, UINT32 start_index,
 613                                               UINT32 items_size, HSTRING *items, UINT32 *count )
 614 {
 615     struct vector_hstring *impl = impl_from_IVector_HSTRING(iface);
 616     HRESULT hr;
 617     UINT32 i;
 618
 619     TRACE("iface %p, start_index %u, items_size %u, items %p, count %p.\n", iface, start_index, items_size, items, count);
 620
 621     if (start_index >= impl->size) return E_BOUNDS;
 622
 623     for (i = start_index; i < impl->size; ++i)
 624     {
 625         if (i - start_index >= items_size) break;
 626         if (FAILED(hr = WindowsDuplicateString(impl->elements[i], &items[i-start_index]))) goto error;
 627     }
 628     *count = i - start_index;
 629
 630     return S_OK;
 631
 632 error:
 633     *count = 0;
 634     while (i-- > start_index) WindowsDeleteString(items[i-start_index]);
 635     return hr;
 636 }
 637
 638 static HRESULT WINAPI vector_hstring_ReplaceAll( IVector_HSTRING *iface, UINT32 count, HSTRING *items )
 639 {
 640     HRESULT hr;
 641     ULONG i;
 642
 643     TRACE("iface %p, count %u, items %p.\n", iface, count, items);
 644
 645     hr = IVector_HSTRING_Clear(iface);
 646     for (i = 0; i < count && SUCCEEDED(hr); ++i) hr = IVector_HSTRING_Append(iface, items[i]);
 647     return hr;
 648 }
 649
 650 static const struct IVector_HSTRINGVtbl vector_hstring_vtbl =
 651 {
 652     /* IUnknown methods */
 653     vector_hstring_QueryInterface,
 654     vector_hstring_AddRef,
 655     vector_hstring_Release,
 656     /* IInspectable methods */
 657     vector_hstring_GetIids,
 658     vector_hstring_GetRuntimeClassName,
 659     vector_hstring_GetTrustLevel,
 660     /* IVector<HSTRING> methods */
 661     vector_hstring_GetAt,
 662     vector_hstring_get_Size,
 663     vector_hstring_GetView,
 664     vector_hstring_IndexOf,
 665     vector_hstring_SetAt,
 666     vector_hstring_InsertAt,
 667     vector_hstring_RemoveAt,
 668     vector_hstring_Append,
 669     vector_hstring_RemoveAtEnd,
 670     vector_hstring_Clear,
 671     vector_hstring_GetMany,
 672     vector_hstring_ReplaceAll,
 673 };
 674
 675 /*
 676  *
 677  * IIterable<HSTRING>
 678  *
 679  */
 680
 681 DEFINE_IINSPECTABLE(iterable_hstring, IIterable_HSTRING, struct vector_hstring, IVector_HSTRING_iface)
 682
 683 static HRESULT WINAPI iterable_hstring_First( IIterable_HSTRING *iface, IIterator_HSTRING **value )
 684 {
 685     struct vector_hstring *impl = impl_from_IIterable_HSTRING(iface);
 686     IIterable_HSTRING *iterable;
 687     IVectorView_HSTRING *view;
 688     HRESULT hr;
 689
 690     TRACE("iface %p, value %p.\n", iface, value);
 691
 692     if (FAILED(hr = IVector_HSTRING_GetView(&impl->IVector_HSTRING_iface, &view))) return hr;
 693
 694     hr = IVectorView_HSTRING_QueryInterface(view, &IID_IIterable_HSTRING, (void **)&iterable);
 695     IVectorView_HSTRING_Release(view);
 696     if (FAILED(hr)) return hr;
 697
 698     hr = IIterable_HSTRING_First(iterable, value);
 699     IIterable_HSTRING_Release(iterable);
 700     return hr;
 701 }
 702
 703 static const struct IIterable_HSTRINGVtbl iterable_hstring_vtbl =
 704 {
 705     /* IUnknown methods */
 706     iterable_hstring_QueryInterface,
 707     iterable_hstring_AddRef,
 708     iterable_hstring_Release,
 709     /* IInspectable methods */
 710     iterable_hstring_GetIids,
 711     iterable_hstring_GetRuntimeClassName,
 712     iterable_hstring_GetTrustLevel,
 713     /* IIterable<HSTRING> methods */
 714     iterable_hstring_First,
 715 };
 716
 717 HRESULT vector_hstring_create( IVector_HSTRING **out )
 718 {
 719     struct vector_hstring *impl;
 720
 721     TRACE("out %p.\n", out);
 722
 723     if (!(impl = calloc(1, sizeof(*impl)))) return E_OUTOFMEMORY;
 724     impl->IVector_HSTRING_iface.lpVtbl = &vector_hstring_vtbl;
 725     impl->IIterable_HSTRING_iface.lpVtbl = &iterable_hstring_vtbl;
 726     impl->ref = 1;
 727
 728     *out = &impl->IVector_HSTRING_iface;
 729     TRACE("created %p\n", *out);
 730     return S_OK;
 731 }
 732
 733 HRESULT vector_hstring_create_copy( IIterable_HSTRING *iterable, IVector_HSTRING **out )
 734 {
 735     struct vector_hstring *impl;
 736     IIterator_HSTRING *iterator;
 737     UINT32 capacity = 0;
 738     BOOL available;
 739     HRESULT hr;
 740
 741     TRACE("iterable %p, out %p.\n", iterable, out);
 742
 743     if (FAILED(hr = vector_hstring_create(out))) return hr;
 744     if (FAILED(hr = IIterable_HSTRING_First(iterable, &iterator))) goto error;
 745
 746     for (IIterator_HSTRING_get_HasCurrent(iterator, &available); available; IIterator_HSTRING_MoveNext(iterator, &available))
 747         capacity++;
 748
 749     IIterator_HSTRING_Release(iterator);
 750
 751     impl = impl_from_IVector_HSTRING(*out);
 752     impl->size = 0;
 753     impl->capacity = capacity;
 754     if (!(impl->elements = realloc(impl->elements, impl->capacity * sizeof(*impl->elements)))) goto error;
 755
 756     if (FAILED(hr = IIterable_HSTRING_First(iterable, &iterator))) goto error;
 757
 758     for (IIterator_HSTRING_get_HasCurrent(iterator, &available); available; IIterator_HSTRING_MoveNext(iterator, &available))
 759     {
 760         HSTRING str;
 761         if (FAILED(hr = IIterator_HSTRING_get_Current(iterator, &str))) goto error;
 762         if (FAILED(hr = WindowsDuplicateString(str, &impl->elements[impl->size]))) goto error;
 763         WindowsDeleteString(str);
 764         impl->size++;
 765     }
 766
 767     IIterator_HSTRING_Release(iterator);
 768
 769     TRACE("created %p\n", *out);
 770     return S_OK;
 771
 772 error:
 773     IVector_HSTRING_Release(*out);
 774     return hr;
 775 }
 776
 777 /*
 778  *
 779  * IVectorView<Inspectable*>
 780  *
 781  */
 782
 783 struct vector_view_inspectable
 784 {
 785     IVectorView_IInspectable IVectorView_IInspectable_iface;
 786     IIterable_IInspectable IIterable_IInspectable_iface;
 787     struct vector_iids iids;
 788     LONG ref;
 789
 790     UINT32 size;
 791     IInspectable *elements[];
 792 };
 793
 794 C_ASSERT(sizeof(struct vector_view_inspectable) == offsetof(struct vector_view_inspectable, elements[0]));
 795
 796 static inline struct vector_view_inspectable *impl_from_IVectorView_IInspectable( IVectorView_IInspectable *iface )
 797 {
 798     return CONTAINING_RECORD(iface, struct vector_view_inspectable, IVectorView_IInspectable_iface);
 799 }
 800
 801 static HRESULT WINAPI vector_view_inspectable_QueryInterface( IVectorView_IInspectable *iface, REFIID iid, void **out )
 802 {
 803     struct vector_view_inspectable *impl = impl_from_IVectorView_IInspectable(iface);
 804
 805     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 806
 807     if (IsEqualGUID(iid, &IID_IUnknown) ||
 808         IsEqualGUID(iid, &IID_IInspectable) ||
 809         IsEqualGUID(iid, &IID_IAgileObject) ||
 810         IsEqualGUID(iid, impl->iids.view))
 811     {
 812         IInspectable_AddRef((*out = &impl->IVectorView_IInspectable_iface));
 813         return S_OK;
 814     }
 815
 816     if (IsEqualGUID(iid, impl->iids.iterable))
 817     {
 818         IInspectable_AddRef((*out = &impl->IIterable_IInspectable_iface));
 819         return S_OK;
 820     }
 821
 822     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 823     *out = NULL;
 824     return E_NOINTERFACE;
 825 }
 826
 827 static ULONG WINAPI vector_view_inspectable_AddRef( IVectorView_IInspectable *iface )
 828 {
 829     struct vector_view_inspectable *impl = impl_from_IVectorView_IInspectable(iface);
 830     ULONG ref = InterlockedIncrement(&impl->ref);
 831     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
 832     return ref;
 833 }
 834
 835 static ULONG WINAPI vector_view_inspectable_Release( IVectorView_IInspectable *iface )
 836 {
 837     struct vector_view_inspectable *impl = impl_from_IVectorView_IInspectable(iface);
 838     ULONG i, ref = InterlockedDecrement(&impl->ref);
 839
 840     TRACE("iface %p decreasing refcount to %lu.\n", iface, ref);
 841
 842     if (!ref)
 843     {
 844         for (i = 0; i < impl->size; ++i) IInspectable_Release(impl->elements[i]);
 845         free(impl);
 846     }
 847
 848     return ref;
 849 }
 850
 851 static HRESULT WINAPI vector_view_inspectable_GetIids( IVectorView_IInspectable *iface, ULONG *iid_count, IID **iids )
 852 {
 853     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 854     return E_NOTIMPL;
 855 }
 856
 857 static HRESULT WINAPI vector_view_inspectable_GetRuntimeClassName( IVectorView_IInspectable *iface, HSTRING *class_name )
 858 {
 859     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 860     return E_NOTIMPL;
 861 }
 862
 863 static HRESULT WINAPI vector_view_inspectable_GetTrustLevel( IVectorView_IInspectable *iface, TrustLevel *trust_level )
 864 {
 865     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 866     return E_NOTIMPL;
 867 }
 868
 869 static HRESULT WINAPI vector_view_inspectable_GetAt( IVectorView_IInspectable *iface, UINT32 index, IInspectable **value )
 870 {
 871     struct vector_view_inspectable *impl = impl_from_IVectorView_IInspectable(iface);
 872
 873     TRACE("iface %p, index %u, value %p.\n", iface, index, value);
 874
 875     *value = NULL;
 876     if (index >= impl->size) return E_BOUNDS;
 877
 878     IInspectable_AddRef((*value = impl->elements[index]));
 879     return S_OK;
 880 }
 881
 882 static HRESULT WINAPI vector_view_inspectable_get_Size( IVectorView_IInspectable *iface, UINT32 *value )
 883 {
 884     struct vector_view_inspectable *impl = impl_from_IVectorView_IInspectable(iface);
 885
 886     TRACE("iface %p, value %p.\n", iface, value);
 887
 888     *value = impl->size;
 889     return S_OK;
 890 }
 891
 892 static HRESULT WINAPI vector_view_inspectable_IndexOf( IVectorView_IInspectable *iface, IInspectable *element,
 893                                                        UINT32 *index, BOOLEAN *found )
 894 {
 895     struct vector_view_inspectable *impl = impl_from_IVectorView_IInspectable(iface);
 896     ULONG i;
 897
 898     TRACE("iface %p, element %p, index %p, found %p.\n", iface, element, index, found);
 899
 900     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
 901     if ((*found = (i < impl->size))) *index = i;
 902     else *index = 0;
 903
 904     return S_OK;
 905 }
 906
 907 static HRESULT WINAPI vector_view_inspectable_GetMany( IVectorView_IInspectable *iface, UINT32 start_index,
 908                                                        UINT32 items_size, IInspectable **items, UINT *count )
 909 {
 910     struct vector_view_inspectable *impl = impl_from_IVectorView_IInspectable(iface);
 911     UINT32 i;
 912
 913     TRACE("iface %p, start_index %u, items_size %u, items %p, count %p.\n",
 914            iface, start_index, items_size, items, count);
 915
 916     if (start_index >= impl->size) return E_BOUNDS;
 917
 918     for (i = start_index; i < impl->size; ++i)
 919     {
 920         if (i - start_index >= items_size) break;
 921         IInspectable_AddRef((items[i - start_index] = impl->elements[i]));
 922     }
 923     *count = i - start_index;
 924
 925     return S_OK;
 926 }
 927
 928 static const struct IVectorView_IInspectableVtbl vector_view_inspectable_vtbl =
 929 {
 930     /* IUnknown methods */
 931     vector_view_inspectable_QueryInterface,
 932     vector_view_inspectable_AddRef,
 933     vector_view_inspectable_Release,
 934     /* IInspectable methods */
 935     vector_view_inspectable_GetIids,
 936     vector_view_inspectable_GetRuntimeClassName,
 937     vector_view_inspectable_GetTrustLevel,
 938     /* IVectorView<IInspectable*> methods */
 939     vector_view_inspectable_GetAt,
 940     vector_view_inspectable_get_Size,
 941     vector_view_inspectable_IndexOf,
 942     vector_view_inspectable_GetMany
 943 };
 944
 945 /*
 946  *
 947  * IIterable<Inspectable*>
 948  *
 949  */
 950
 951 DEFINE_IINSPECTABLE_(iterable_view_inspectable, IIterable_IInspectable, struct vector_view_inspectable,
 952                      view_impl_from_IIterable_IInspectable, IIterable_IInspectable_iface, &impl->IVectorView_IInspectable_iface)
 953
 954 static HRESULT WINAPI iterable_view_inspectable_First( IIterable_IInspectable *iface, IIterator_IInspectable **value )
 955 {
 956     FIXME("iface %p, value %p stub!\n", iface, value);
 957     return E_NOTIMPL;
 958 }
 959
 960 static const struct IIterable_IInspectableVtbl iterable_view_inspectable_vtbl =
 961 {
 962     /* IUnknown methods */
 963     iterable_view_inspectable_QueryInterface,
 964     iterable_view_inspectable_AddRef,
 965     iterable_view_inspectable_Release,
 966     /* IInspectable methods */
 967     iterable_view_inspectable_GetIids,
 968     iterable_view_inspectable_GetRuntimeClassName,
 969     iterable_view_inspectable_GetTrustLevel,
 970     /* IIterable<IInspectable*> methods */
 971     iterable_view_inspectable_First
 972 };
 973
 974 /*
 975  *
 976  * IVector<Inspectable*>
 977  *
 978  */
 979
 980 struct vector_inspectable
 981 {
 982     IVector_IInspectable IVector_IInspectable_iface;
 983     IIterable_IInspectable IIterable_IInspectable_iface;
 984     struct vector_iids iids;
 985     LONG ref;
 986
 987     UINT32 size;
 988     UINT32 capacity;
 989     IInspectable **elements;
 990 };
 991
 992 static inline struct vector_inspectable *impl_from_IVector_IInspectable( IVector_IInspectable *iface )
 993 {
 994     return CONTAINING_RECORD(iface, struct vector_inspectable, IVector_IInspectable_iface);
 995 }
 996
 997 static HRESULT WINAPI vector_inspectable_QueryInterface( IVector_IInspectable *iface, REFIID iid, void **out )
 998 {
 999     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1000
1001     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1002
1003     if (IsEqualGUID(iid, &IID_IUnknown) ||
1004         IsEqualGUID(iid, &IID_IInspectable) ||
1005         IsEqualGUID(iid, &IID_IAgileObject) ||
1006         IsEqualGUID(iid, impl->iids.vector))
1007     {
1008         IInspectable_AddRef((*out = &impl->IVector_IInspectable_iface));
1009         return S_OK;
1010     }
1011
1012     if (IsEqualGUID(iid, impl->iids.iterable))
1013     {
1014         IInspectable_AddRef((*out = &impl->IIterable_IInspectable_iface));
1015         return S_OK;
1016     }
1017
1018     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
1019     *out = NULL;
1020     return E_NOINTERFACE;
1021 }
1022
1023 static ULONG WINAPI vector_inspectable_AddRef( IVector_IInspectable *iface )
1024 {
1025     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1026     ULONG ref = InterlockedIncrement(&impl->ref);
1027     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
1028     return ref;
1029 }
1030
1031 static ULONG WINAPI vector_inspectable_Release( IVector_IInspectable *iface )
1032 {
1033     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1034     ULONG ref = InterlockedDecrement(&impl->ref);
1035
1036     TRACE("iface %p decreasing refcount to %lu.\n", iface, ref);
1037
1038     if (!ref)
1039     {
1040         IVector_IInspectable_Clear(iface);
1041         free(impl);
1042     }
1043
1044     return ref;
1045 }
1046
1047 static HRESULT WINAPI vector_inspectable_GetIids( IVector_IInspectable *iface, ULONG *iid_count, IID **iids )
1048 {
1049     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
1050     return E_NOTIMPL;
1051 }
1052
1053 static HRESULT WINAPI vector_inspectable_GetRuntimeClassName( IVector_IInspectable *iface, HSTRING *class_name )
1054 {
1055     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
1056     return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI vector_inspectable_GetTrustLevel( IVector_IInspectable *iface, TrustLevel *trust_level )
1060 {
1061     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
1062     return E_NOTIMPL;
1063 }
1064
1065 static HRESULT WINAPI vector_inspectable_GetAt( IVector_IInspectable *iface, UINT32 index, IInspectable **value )
1066 {
1067     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1068
1069     TRACE("iface %p, index %u, value %p.\n", iface, index, value);
1070
1071     *value = NULL;
1072     if (index >= impl->size) return E_BOUNDS;
1073
1074     IInspectable_AddRef((*value = impl->elements[index]));
1075     return S_OK;
1076 }
1077
1078 static HRESULT WINAPI vector_inspectable_get_Size( IVector_IInspectable *iface, UINT32 *value )
1079 {
1080     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1081     TRACE("iface %p, value %p.\n", iface, value);
1082     *value = impl->size;
1083     return S_OK;
1084 }
1085
1086 static HRESULT WINAPI vector_inspectable_GetView( IVector_IInspectable *iface, IVectorView_IInspectable **value )
1087 {
1088     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1089     struct vector_view_inspectable *view;
1090     ULONG i;
1091
1092     TRACE("iface %p, value %p.\n", iface, value);
1093
1094     if (!(view = calloc(1, offsetof(struct vector_view_inspectable, elements[impl->size])))) return E_OUTOFMEMORY;
1095     view->IVectorView_IInspectable_iface.lpVtbl = &vector_view_inspectable_vtbl;
1096     view->IIterable_IInspectable_iface.lpVtbl = &iterable_view_inspectable_vtbl;
1097     view->iids = impl->iids;
1098     view->ref = 1;
1099
1100     for (i = 0; i < impl->size; ++i) IInspectable_AddRef((view->elements[view->size++] = impl->elements[i]));
1101
1102     *value = &view->IVectorView_IInspectable_iface;
1103     return S_OK;
1104 }
1105
1106 static HRESULT WINAPI vector_inspectable_IndexOf( IVector_IInspectable *iface,
1107                                                   IInspectable *element, UINT32 *index, BOOLEAN *found )
1108 {
1109     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1110     ULONG i;
1111
1112     TRACE("iface %p, element %p, index %p, found %p.\n", iface, element, index, found);
1113
1114     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
1115     if ((*found = (i < impl->size))) *index = i;
1116     else *index = 0;
1117
1118     return S_OK;
1119 }
1120
1121 static HRESULT WINAPI vector_inspectable_SetAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
1122 {
1123     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1124
1125     TRACE("iface %p, index %u, value %p.\n", iface, index, value);
1126
1127     if (index >= impl->size) return E_BOUNDS;
1128     IInspectable_Release(impl->elements[index]);
1129     IInspectable_AddRef((impl->elements[index] = value));
1130     return S_OK;
1131 }
1132
1133 static HRESULT WINAPI vector_inspectable_InsertAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
1134 {
1135     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1136     IInspectable **tmp = impl->elements;
1137
1138     TRACE("iface %p, index %u, value %p.\n", iface, index, value);
1139
1140     if (impl->size == impl->capacity)
1141     {
1142         impl->capacity = max(32, impl->capacity * 3 / 2);
1143         if (!(impl->elements = realloc(impl->elements, impl->capacity * sizeof(*impl->elements))))
1144         {
1145             impl->elements = tmp;
1146             return E_OUTOFMEMORY;
1147         }
1148     }
1149
1150     memmove(impl->elements + index + 1, impl->elements + index, (impl->size++ - index) * sizeof(*impl->elements));
1151     IInspectable_AddRef((impl->elements[index] = value));
1152     return S_OK;
1153 }
1154
1155 static HRESULT WINAPI vector_inspectable_RemoveAt( IVector_IInspectable *iface, UINT32 index )
1156 {
1157     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1158
1159     TRACE("iface %p, index %u.\n", iface, index);
1160
1161     if (index >= impl->size) return E_BOUNDS;
1162     IInspectable_Release(impl->elements[index]);
1163     memmove(impl->elements + index, impl->elements + index + 1, (--impl->size - index) * sizeof(*impl->elements));
1164     return S_OK;
1165 }
1166
1167 static HRESULT WINAPI vector_inspectable_Append( IVector_IInspectable *iface, IInspectable *value )
1168 {
1169     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1170
1171     TRACE("iface %p, value %p.\n", iface, value);
1172
1173     return IVector_IInspectable_InsertAt(iface, impl->size, value);
1174 }
1175
1176 static HRESULT WINAPI vector_inspectable_RemoveAtEnd( IVector_IInspectable *iface )
1177 {
1178     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1179
1180     TRACE("iface %p.\n", iface);
1181
1182     if (impl->size) IInspectable_Release(impl->elements[--impl->size]);
1183     return S_OK;
1184 }
1185
1186 static HRESULT WINAPI vector_inspectable_Clear( IVector_IInspectable *iface )
1187 {
1188     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1189
1190     TRACE("iface %p.\n", iface);
1191
1192     while (impl->size) IVector_IInspectable_RemoveAtEnd(iface);
1193     free(impl->elements);
1194     impl->capacity = 0;
1195     impl->elements = NULL;
1196
1197     return S_OK;
1198 }
1199
1200 static HRESULT WINAPI vector_inspectable_GetMany( IVector_IInspectable *iface, UINT32 start_index,
1201                                                   UINT32 items_size, IInspectable **items, UINT *count )
1202 {
1203     struct vector_inspectable *impl = impl_from_IVector_IInspectable(iface);
1204     UINT32 i;
1205
1206     TRACE("iface %p, start_index %u, items_size %u, items %p, count %p.\n",
1207            iface, start_index, items_size, items, count);
1208
1209     if (start_index >= impl->size) return E_BOUNDS;
1210
1211     for (i = start_index; i < impl->size; ++i)
1212     {
1213         if (i - start_index >= items_size) break;
1214         IInspectable_AddRef((items[i - start_index] = impl->elements[i]));
1215     }
1216     *count = i - start_index;
1217
1218     return S_OK;
1219 }
1220
1221 static HRESULT WINAPI vector_inspectable_ReplaceAll( IVector_IInspectable *iface, UINT32 count, IInspectable **items )
1222 {
1223     HRESULT hr;
1224     ULONG i;
1225
1226     TRACE("iface %p, count %u, items %p.\n", iface, count, items);
1227
1228     hr = IVector_IInspectable_Clear(iface);
1229     for (i = 0; i < count && SUCCEEDED(hr); ++i) hr = IVector_IInspectable_Append(iface, items[i]);
1230     return hr;
1231 }
1232
1233 static const struct IVector_IInspectableVtbl vector_inspectable_vtbl =
1234 {
1235     /* IUnknown methods */
1236     vector_inspectable_QueryInterface,
1237     vector_inspectable_AddRef,
1238     vector_inspectable_Release,
1239     /* IInspectable methods */
1240     vector_inspectable_GetIids,
1241     vector_inspectable_GetRuntimeClassName,
1242     vector_inspectable_GetTrustLevel,
1243     /* IVector<IInspectable*> methods */
1244     vector_inspectable_GetAt,
1245     vector_inspectable_get_Size,
1246     vector_inspectable_GetView,
1247     vector_inspectable_IndexOf,
1248     vector_inspectable_SetAt,
1249     vector_inspectable_InsertAt,
1250     vector_inspectable_RemoveAt,
1251     vector_inspectable_Append,
1252     vector_inspectable_RemoveAtEnd,
1253     vector_inspectable_Clear,
1254     vector_inspectable_GetMany,
1255     vector_inspectable_ReplaceAll
1256 };
1257
1258 /*
1259  *
1260  * IIterable<Inspectable*>
1261  *
1262  */
1263
1264 DEFINE_IINSPECTABLE(iterable_inspectable, IIterable_IInspectable, struct vector_inspectable, IVector_IInspectable_iface)
1265
1266 static HRESULT WINAPI iterable_inspectable_First( IIterable_IInspectable *iface, IIterator_IInspectable **value )
1267 {
1268     FIXME("iface %p, value %p stub!\n", iface, value);
1269     return E_NOTIMPL;
1270 }
1271
1272 static const struct IIterable_IInspectableVtbl iterable_inspectable_vtbl =
1273 {
1274     /* IUnknown methods */
1275     iterable_inspectable_QueryInterface,
1276     iterable_inspectable_AddRef,
1277     iterable_inspectable_Release,
1278     /* IInspectable methods */
1279     iterable_inspectable_GetIids,
1280     iterable_inspectable_GetRuntimeClassName,
1281     iterable_inspectable_GetTrustLevel,
1282     /* IIterable<IInspectable*> methods */
1283     iterable_inspectable_First
1284 };
1285
1286 HRESULT vector_inspectable_create( const struct vector_iids *iids, IVector_IInspectable **out )
1287 {
1288     struct vector_inspectable *impl;
1289
1290     TRACE("iid %s, out %p.\n", debugstr_guid(iids->vector), out);
1291
1292     if (!(impl = calloc(1, sizeof(*impl)))) return E_OUTOFMEMORY;
1293     impl->IVector_IInspectable_iface.lpVtbl = &vector_inspectable_vtbl;
1294     impl->IIterable_IInspectable_iface.lpVtbl = &iterable_inspectable_vtbl;
1295     impl->iids = *iids;
1296     impl->ref = 1;
1297
1298     *out = &impl->IVector_IInspectable_iface;
1299     TRACE("created %p\n", *out);
1300     return S_OK;
1301 }