1.1.0 #

• pedantic lints.
• Add ThrowingReflector, which throws on all operations.
• EmptyReflector uses Object instead of dynamic as its returned type, as the dynamic type is (apparently?) no longer a valid constant value.
• registerSingleton now returns the provided object.
• registerFactory and registerLazySingleton now return the provided function f.

1.0.4 #

• Slight patch to prevent annoying segfault.

1.0.3 #

• Added Future support to Reflector.

1.0.2 #

• Added makeAsync<T>.

1.0.1 #

• Added hasNamed.

1.0.0 #

• Removed @GenerateReflector.

1.0.0-alpha.12 #

• StaticReflector now defaults to empty arguments.

1.0.0-alpha.11 #

• Added StaticReflector.

1.0.0-alpha.10 #

• Added Container.registerLazySingleton<T>.
• Added named singleton support.

1.0.0-alpha.9 #

• Added Container.has<T>.

1.0.0-alpha.8 #

• Fixed a bug where _ReflectedTypeInstance.isAssignableTo always failed.
• Added @GenerateReflector annotation.

1.0.0-alpha.7 #

• Add EmptyReflector.
• ReflectedType.newInstance now returns a ReflectedInstance.
• Moved ReflectedInstance.invoke to ReflectedFunction.invoke.

1.0.0-alpha.6 #

• Add getField to ReflectedInstance.

1.0.0-alpha.5 #

• Remove concrete type from ReflectedTypeParameter.

1.0.0-alpha.4 #

• Safely handle void return types of methods.

1.0.0-alpha.3 #

• Reflecting void in MirrorsReflector now forwards to dynamic.

1.0.0-alpha.2 #

• Added ReflectedInstance.reflectee.

1.0.0-alpha.1 #

• Allow omission of the first argument of Container.make, to use a generic type argument instead.
• singleton -> registerSingleton
• Add createChild, and support hierarchical containers.

example/main.dart

import 'dart:async';

import 'package:angel_container/angel_container.dart';
import 'package:angel_container/mirrors.dart';

Future<void> main() async {
  // Create a container instance.
  var container = Container(const MirrorsReflector());

  // Register a singleton.
  container.registerSingleton<Engine>(Engine(40));

  // You can also omit the type annotation, in which the object's runtime type will be used.
  // If you're injecting an abstract class, prefer the type annotation.
  //
  // container.registerSingleton(Engine(40));

  // Register a factory that creates a truck.
  container.registerFactory<Truck>((container) {
    return _TruckImpl(container.make<Engine>());
  });

  // Use `make` to create an instance.
  var truck = container.make<Truck>();

  // You can also resolve injections asynchronously.
  container.registerFactory<Future<int>>((_) async => 24);
  print(await container.makeAsync<int>());

  // Asynchronous resolution also works for plain objects.
  await container.makeAsync<Truck>().then((t) => t.drive());

  // Register a named singleton.
  container.registerNamedSingleton('the_truck', truck);

  // Should print: 'Vroom! I have 40 horsepower in my engine.'
  truck.drive();

  // Should print the same.
  container.findByName<Truck>('the_truck').drive();

  // We can make a child container with its own factory.
  var childContainer = container.createChild();

  childContainer.registerFactory<Truck>((container) {
    return _TruckImpl(Engine(5666));
  });

  // Make a truck with 5666 HP.
  childContainer.make<Truck>().drive();

  // However, calling `make<Engine>` will return the Engine singleton we created above.
  print(childContainer.make<Engine>().horsePower);
}

abstract class Truck {
  void drive();
}

class Engine {
  final int horsePower;

  Engine(this.horsePower);
}

class _TruckImpl implements Truck {
  final Engine engine;

  _TruckImpl(this.engine);

  @override
  void drive() {
    print('Vroom! I have ${engine.horsePower} horsepower in my engine.');
  }
}