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 vector_view
  27 {
  28     IVectorView_IInspectable IVectorView_IInspectable_iface;
  29     const GUID *iid;
  30     LONG ref;
  31
  32     UINT32 size;
  33     IInspectable *elements[1];
  34 };
  35
  36 static inline struct vector_view *impl_from_IVectorView_IInspectable( IVectorView_IInspectable *iface )
  37 {
  38     return CONTAINING_RECORD( iface, struct vector_view, IVectorView_IInspectable_iface );
  39 }
  40
  41 static HRESULT WINAPI vector_view_QueryInterface( IVectorView_IInspectable *iface, REFIID iid, void **out )
  42 {
  43     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
  44
  45     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
  46
  47     if (IsEqualGUID( iid, &IID_IUnknown ) ||
  48         IsEqualGUID( iid, &IID_IInspectable ) ||
  49         IsEqualGUID( iid, &IID_IAgileObject ) ||
  50         IsEqualGUID( iid, impl->iid ))
  51     {
  52         IUnknown_AddRef( iface );
  53         *out = iface;
  54         return S_OK;
  55     }
  56
  57     WARN( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
  58     *out = NULL;
  59     return E_NOINTERFACE;
  60 }
  61
  62 static ULONG WINAPI vector_view_AddRef( IVectorView_IInspectable *iface )
  63 {
  64     struct vector_view *impl = impl_from_IVectorView_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 vector_view_Release( IVectorView_IInspectable *iface )
  71 {
  72     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
  73     ULONG i, ref = InterlockedDecrement( &impl->ref );
  74
  75     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
  76
  77     if (!ref)
  78     {
  79         for (i = 0; i < impl->size; ++i) IInspectable_Release( impl->elements[i] );
  80         free( impl );
  81     }
  82
  83     return ref;
  84 }
  85
  86 static HRESULT WINAPI vector_view_GetIids( IVectorView_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 vector_view_GetRuntimeClassName( IVectorView_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 vector_view_GetTrustLevel( IVectorView_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 vector_view_GetAt( IVectorView_IInspectable *iface, UINT32 index, IInspectable **value )
 105 {
 106     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 107
 108     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 109
 110     *value = NULL;
 111     if (index >= impl->size) return E_BOUNDS;
 112
 113     IInspectable_AddRef( (*value = impl->elements[index]) );
 114     return S_OK;
 115 }
 116
 117 static HRESULT WINAPI vector_view_get_Size( IVectorView_IInspectable *iface, UINT32 *value )
 118 {
 119     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 120
 121     TRACE( "iface %p, value %p.\n", iface, value );
 122
 123     *value = impl->size;
 124     return S_OK;
 125 }
 126
 127 static HRESULT WINAPI vector_view_IndexOf( IVectorView_IInspectable *iface, IInspectable *element,
 128                                            UINT32 *index, BOOLEAN *found )
 129 {
 130     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 131     ULONG i;
 132
 133     TRACE( "iface %p, element %p, index %p, found %p.\n", iface, element, index, found );
 134
 135     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
 136     if ((*found = (i < impl->size))) *index = i;
 137     else *index = 0;
 138
 139     return S_OK;
 140 }
 141
 142 static HRESULT WINAPI vector_view_GetMany( IVectorView_IInspectable *iface, UINT32 start_index,
 143                                            UINT32 items_size, IInspectable **items, UINT *count )
 144 {
 145     struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
 146     UINT32 i;
 147
 148     TRACE( "iface %p, start_index %u, items_size %u, items %p, count %p.\n",
 149            iface, start_index, items_size, items, count );
 150
 151     if (start_index >= impl->size) return E_BOUNDS;
 152
 153     for (i = start_index; i < impl->size; ++i)
 154     {
 155         if (i - start_index >= items_size) break;
 156         IInspectable_AddRef( (items[i - start_index] = impl->elements[i]) );
 157     }
 158     *count = i - start_index;
 159
 160     return S_OK;
 161 }
 162
 163 static const struct IVectorView_IInspectableVtbl vector_view_vtbl =
 164 {
 165     vector_view_QueryInterface,
 166     vector_view_AddRef,
 167     vector_view_Release,
 168     /* IInspectable methods */
 169     vector_view_GetIids,
 170     vector_view_GetRuntimeClassName,
 171     vector_view_GetTrustLevel,
 172     /* IVectorView<IInspectable*> methods */
 173     vector_view_GetAt,
 174     vector_view_get_Size,
 175     vector_view_IndexOf,
 176     vector_view_GetMany,
 177 };
 178
 179 struct vector
 180 {
 181     IVector_IInspectable IVector_IInspectable_iface;
 182     const GUID *iid;
 183     const GUID *view_iid;
 184     LONG ref;
 185
 186     UINT32 size;
 187     UINT32 capacity;
 188     IInspectable **elements;
 189 };
 190
 191 static inline struct vector *impl_from_IVector_IInspectable( IVector_IInspectable *iface )
 192 {
 193     return CONTAINING_RECORD( iface, struct vector, IVector_IInspectable_iface );
 194 }
 195
 196 static HRESULT WINAPI vector_QueryInterface( IVector_IInspectable *iface, REFIID iid, void **out )
 197 {
 198     struct vector *impl = impl_from_IVector_IInspectable( iface );
 199
 200     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 201
 202     if (IsEqualGUID( iid, &IID_IUnknown ) ||
 203         IsEqualGUID( iid, &IID_IInspectable ) ||
 204         IsEqualGUID( iid, &IID_IAgileObject ) ||
 205         IsEqualGUID( iid, impl->iid ))
 206     {
 207         IUnknown_AddRef( iface );
 208         *out = iface;
 209         return S_OK;
 210     }
 211
 212     WARN( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 213     *out = NULL;
 214     return E_NOINTERFACE;
 215 }
 216
 217 static ULONG WINAPI vector_AddRef( IVector_IInspectable *iface )
 218 {
 219     struct vector *impl = impl_from_IVector_IInspectable( iface );
 220     ULONG ref = InterlockedIncrement( &impl->ref );
 221     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 222     return ref;
 223 }
 224
 225 static ULONG WINAPI vector_Release( IVector_IInspectable *iface )
 226 {
 227     struct vector *impl = impl_from_IVector_IInspectable( iface );
 228     ULONG ref = InterlockedDecrement( &impl->ref );
 229
 230     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 231
 232     if (!ref)
 233     {
 234         IVector_IInspectable_Clear( iface );
 235         free( impl );
 236     }
 237
 238     return ref;
 239 }
 240
 241 static HRESULT WINAPI vector_GetIids( IVector_IInspectable *iface, ULONG *iid_count, IID **iids )
 242 {
 243     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 244     return E_NOTIMPL;
 245 }
 246
 247 static HRESULT WINAPI vector_GetRuntimeClassName( IVector_IInspectable *iface, HSTRING *class_name )
 248 {
 249     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT WINAPI vector_GetTrustLevel( IVector_IInspectable *iface, TrustLevel *trust_level )
 254 {
 255     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 256     return E_NOTIMPL;
 257 }
 258
 259 static HRESULT WINAPI vector_GetAt( IVector_IInspectable *iface, UINT32 index, IInspectable **value )
 260 {
 261     struct vector *impl = impl_from_IVector_IInspectable( iface );
 262
 263     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 264
 265     *value = NULL;
 266     if (index >= impl->size) return E_BOUNDS;
 267
 268     IInspectable_AddRef( (*value = impl->elements[index]) );
 269     return S_OK;
 270 }
 271
 272 static HRESULT WINAPI vector_get_Size( IVector_IInspectable *iface, UINT32 *value )
 273 {
 274     struct vector *impl = impl_from_IVector_IInspectable( iface );
 275     TRACE( "iface %p, value %p.\n", iface, value );
 276     *value = impl->size;
 277     return S_OK;
 278 }
 279
 280 static HRESULT WINAPI vector_GetView( IVector_IInspectable *iface, IVectorView_IInspectable **value )
 281 {
 282     struct vector *impl = impl_from_IVector_IInspectable( iface );
 283     struct vector_view *view;
 284     ULONG i;
 285
 286     TRACE( "iface %p, value %p.\n", iface, value );
 287
 288     if (!(view = calloc( 1, offsetof( struct vector_view, elements[impl->size] ) ))) return E_OUTOFMEMORY;
 289     view->IVectorView_IInspectable_iface.lpVtbl = &vector_view_vtbl;
 290     view->iid = impl->view_iid;
 291     view->ref = 1;
 292
 293     for (i = 0; i < impl->size; ++i) IInspectable_AddRef( (view->elements[view->size++] = impl->elements[i]) );
 294
 295     *value = &view->IVectorView_IInspectable_iface;
 296     return S_OK;
 297 }
 298
 299 static HRESULT WINAPI vector_IndexOf( IVector_IInspectable *iface, IInspectable *element, UINT32 *index, BOOLEAN *found )
 300 {
 301     struct vector *impl = impl_from_IVector_IInspectable( iface );
 302     ULONG i;
 303
 304     TRACE( "iface %p, element %p, index %p, found %p.\n", iface, element, index, found );
 305
 306     for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
 307     if ((*found = (i < impl->size))) *index = i;
 308     else *index = 0;
 309
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI vector_SetAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
 314 {
 315     struct vector *impl = impl_from_IVector_IInspectable( iface );
 316
 317     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 318
 319     if (index >= impl->size) return E_BOUNDS;
 320     IInspectable_Release( impl->elements[index] );
 321     IInspectable_AddRef( (impl->elements[index] = value) );
 322     return S_OK;
 323 }
 324
 325 static HRESULT WINAPI vector_InsertAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
 326 {
 327     struct vector *impl = impl_from_IVector_IInspectable( iface );
 328     IInspectable **tmp = impl->elements;
 329
 330     TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
 331
 332     if (impl->size == impl->capacity)
 333     {
 334         impl->capacity = max( 32, impl->capacity * 3 / 2 );
 335         if (!(impl->elements = realloc( impl->elements, impl->capacity * sizeof(*impl->elements) )))
 336         {
 337             impl->elements = tmp;
 338             return E_OUTOFMEMORY;
 339         }
 340     }
 341
 342     memmove( impl->elements + index + 1, impl->elements + index, impl->size++ * sizeof(*impl->elements) );
 343     IInspectable_AddRef( (impl->elements[index] = value) );
 344     return S_OK;
 345 }
 346
 347 static HRESULT WINAPI vector_RemoveAt( IVector_IInspectable *iface, UINT32 index )
 348 {
 349     struct vector *impl = impl_from_IVector_IInspectable( iface );
 350
 351     TRACE( "iface %p, index %u.\n", iface, index );
 352
 353     if (index >= impl->size) return E_BOUNDS;
 354     IInspectable_Release( impl->elements[index] );
 355     memmove( impl->elements + index, impl->elements + index + 1, --impl->size * sizeof(*impl->elements) );
 356     return S_OK;
 357 }
 358
 359 static HRESULT WINAPI vector_Append( IVector_IInspectable *iface, IInspectable *value )
 360 {
 361     struct vector *impl = impl_from_IVector_IInspectable( iface );
 362
 363     TRACE( "iface %p, value %p.\n", iface, value );
 364
 365     return IVector_IInspectable_InsertAt( iface, impl->size, value );
 366 }
 367
 368 static HRESULT WINAPI vector_RemoveAtEnd( IVector_IInspectable *iface )
 369 {
 370     struct vector *impl = impl_from_IVector_IInspectable( iface );
 371
 372     TRACE( "iface %p.\n", iface );
 373
 374     if (impl->size) IInspectable_Release( impl->elements[--impl->size] );
 375     return S_OK;
 376 }
 377
 378 static HRESULT WINAPI vector_Clear( IVector_IInspectable *iface )
 379 {
 380     struct vector *impl = impl_from_IVector_IInspectable( iface );
 381
 382     TRACE( "iface %p.\n", iface );
 383
 384     while (impl->size) IVector_IInspectable_RemoveAtEnd( iface );
 385     free( impl->elements );
 386     impl->capacity = 0;
 387     impl->elements = NULL;
 388
 389     return S_OK;
 390 }
 391
 392 static HRESULT WINAPI vector_GetMany( IVector_IInspectable *iface, UINT32 start_index,
 393                                       UINT32 items_size, IInspectable **items, UINT *count )
 394 {
 395     struct vector *impl = impl_from_IVector_IInspectable( iface );
 396     UINT32 i;
 397
 398     TRACE( "iface %p, start_index %u, items_size %u, items %p, count %p.\n",
 399            iface, start_index, items_size, items, count );
 400
 401     if (start_index >= impl->size) return E_BOUNDS;
 402
 403     for (i = start_index; i < impl->size; ++i)
 404     {
 405         if (i - start_index >= items_size) break;
 406         IInspectable_AddRef( (items[i - start_index] = impl->elements[i]) );
 407     }
 408     *count = i - start_index;
 409
 410     return S_OK;
 411 }
 412
 413 static HRESULT WINAPI vector_ReplaceAll( IVector_IInspectable *iface, UINT32 count, IInspectable **items )
 414 {
 415     HRESULT hr;
 416     ULONG i;
 417
 418     TRACE( "iface %p, count %u, items %p.\n", iface, count, items );
 419
 420     hr = IVector_IInspectable_Clear( iface );
 421     for (i = 0; i < count && SUCCEEDED(hr); ++i) hr = IVector_IInspectable_Append( iface, items[i] );
 422     return hr;
 423 }
 424
 425 static const struct IVector_IInspectableVtbl vector_vtbl =
 426 {
 427     vector_QueryInterface,
 428     vector_AddRef,
 429     vector_Release,
 430     /* IInspectable methods */
 431     vector_GetIids,
 432     vector_GetRuntimeClassName,
 433     vector_GetTrustLevel,
 434     /* IVector<IInspectable*> methods */
 435     vector_GetAt,
 436     vector_get_Size,
 437     vector_GetView,
 438     vector_IndexOf,
 439     vector_SetAt,
 440     vector_InsertAt,
 441     vector_RemoveAt,
 442     vector_Append,
 443     vector_RemoveAtEnd,
 444     vector_Clear,
 445     vector_GetMany,
 446     vector_ReplaceAll,
 447 };
 448
 449 HRESULT vector_create( REFIID iid, REFIID view_iid, void **out )
 450 {
 451     struct vector *impl;
 452
 453     TRACE( "iid %s, out %p.\n", debugstr_guid( iid ), out );
 454
 455     if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
 456     impl->IVector_IInspectable_iface.lpVtbl = &vector_vtbl;
 457     impl->iid = iid;
 458     impl->view_iid = view_iid;
 459     impl->ref = 1;
 460
 461     *out = &impl->IVector_IInspectable_iface;
 462     TRACE( "created %p\n", *out );
 463     return S_OK;
 464 }