getAsync<T> static method

Future<List<T>> getAsync<T>(String key, [ BuildContext? context ])

Get only type T extensions which are registered with key and await until every extension is created async

Implementation

static Future<List<T>> getAsync<T>(String key,
    [BuildContext? context]) async {
  List<_CreatedExtension> extensions = [];

  // Check is there any object registered with same key
  if (_extensions.keys.contains(key)) {
    // List of extension which are going to be created async or created sync
    List<_CreatingExtension> extensionCreating = [];

    // Start every extension creation simultaneously without awaiting
    for (int i = 0; i < _extensions[key]!.length; i++) {
      var extItem = _extensions[key]![i];
      extensionCreating
          .add(_CreatingExtension(extItem.create(context), extItem));
    }

    // Loop all extensions which are going to be created async or already created sync
    for (int i = 0; i < extensionCreating.length; i++) {
      var extItem = extensionCreating[i];

      if (extItem.extensionItem is _ExtensionItemCollection) {
        // Create collection of extension objects
        var extensionCollection;

        // If extension creation should await
        if (extItem.createResult is Future) {
          extensionCollection = await extItem.createResult;
        } else {
          extensionCollection = extItem.createResult;
        }

        // Add all single items from collection to extension list
        for (int i = 0; i < extensionCollection.length; i++) {
          extensions.add(_CreatedExtension(extensionCollection[i], 0));
        }
      } else {
        // Create extension
        var singleExtension;

        // If extension creation should await
        if (extItem.createResult is Future) {
          singleExtension = await extItem.createResult;
        } else {
          singleExtension = extItem.createResult;
        }

        var item = extItem.extensionItem as _ExtensionItem;
        extensions.add(_CreatedExtension(singleExtension, item.weight));
      }
    }
  }

  // Sort extensions by weight. More weight, then closer to 0 index.
  extensions.sort((a, b) => a.weight.compareTo(b.weight));

  // Return only type T extensions
  return _getTypedExtensionsOnly<T>(extensions);
}