locator.dart

typedef Func<T> = T Function();

abstract class ServiceDefinition<T> {
  factory ServiceDefinition.singleton(T instance) = _SingletonServiceDefinition;
  factory ServiceDefinition.factory(Func<T> create) = _FactoryServiceDefinition;
  const ServiceDefinition._();

  T instantiate();

  bool matches<E>() => E == T;
}

class ServiceCollection {
  ServiceCollection() : services = <ServiceDefinition>[];

  final List<ServiceDefinition> services;

  void register(ServiceDefinition definition) => services.add(definition);

  T? findService<T>() {
    for (final definition in services) {
      if (definition.matches<T>()) {
        return definition.instantiate() as T;
      }
    }
  }

  T requireService<T>() {
    for (final definition in services) {
      if (definition.matches<T>()) {
        return definition.instantiate() as T;
      }
    }
    throw Exception('Service is not registered');
  }
}

class Locator {
  Locator() : _collection = ServiceCollection();

  final ServiceCollection _collection;

  void registerSingleton<T>(T instance) {
    _collection.register(ServiceDefinition<T>.singleton(instance));
  }

  void registerFactory<T>(Func<T> create) {
    _collection.register(ServiceDefinition<T>.factory(create));
  }

  void register(ServiceDefinition definition) {
    _collection.register(definition);
  }

  T get<T>() => _collection.requireService<T>();
}

class _SingletonServiceDefinition<T> extends ServiceDefinition<T> {
  const _SingletonServiceDefinition(this.instance) : super._();

  final T instance;

  @override
  T instantiate() => instance;
}

class _FactoryServiceDefinition<T> extends ServiceDefinition<T> {
  const _FactoryServiceDefinition(this.create) : super._();

  final Func<T> create;

  @override
  T instantiate() => create();
}