public void Process(Type type, Registry registry)
        {
            var validatorTypes = type.FindInterfacesThatClose(typeof(IValidator<>));

            foreach(var validatorType in validatorTypes)
                registry.AddType(validatorType, type);
        }

 public void Process(Type type, Registry registry)
 {
     if (type.CanBeCastTo<Controller>() && !type.IsAbstract)
     {
         registry.For(type).LifecycleIs(new UniquePerRequestLifecycle());
     }
 }

 private void Process(Type type, Registry registry)
 {
     if (type.CanBeCastTo(typeof(Controller)) && !type.IsAbstract)
     {
         registry.For(type).LifecycleIs(new UniquePerRequestLifecycle());
     }
 }

 private void SetupSingletons(Registry registry)
 {
     foreach (Type type in _singletons)
     {
         registry.For(type).Singleton();
     }
 }

 private static void ConfigureModuleSpecificDependencies(Registry registry)
 {
     registry.For<IMasslogConfiguration>().Singleton().Use<LoggingConfiguration>();
     registry.For<ILoggingConfiguration>().Singleton().Use<LoggingConfiguration>();
     registry.For<IMonitorBehaviorFactory>().Singleton().Use<MonitorBehaviorFactory>();
     registry.For<IMonitor>().HttpContextScoped().Use<Monitor>();
 }

 public void Process(Type type, Registry registry)
 {
     if(type.GetInterfaces().Contains(typeof(IQuery)) && !type.IsAbstract)
     {
         registry.For(typeof (IQuery)).Use(type);
     }
 }

        public void ScanTypes(TypeSet types, Registry registry)
        {
            types.FindTypes(TypeClassification.Closed | TypeClassification.Concretes)
                .Where(Registry.IsPublicRegistry)
                .Each(type => registry.Configure(x => x.ImportRegistry(type)));

        }

        public void Process(Type type, Registry registry)
        {




        }

 public void Process(Type type, Registry registry)
 {
     if (!type.IsAbstract && typeof(ICommandEvent).IsAssignableFrom(type))
     {
         registry.AddType(typeof(ICommand), typeof(EventCommand<>).MakeGenericType(type), type.Name);
     }
 }

 public PluginGraphBuilder(ConfigurationParser[] parsers, Registry[] registries, GraphLog log)
 {
     _parsers = parsers;
     _registries = registries;
     _graph = new PluginGraph();
     _graph.Log = log;
 }

 public void Process(Type type, Registry registry)
 {
     if (type.CanBeCastTo(typeof(Controller)) && !type.IsAbstract)
     {
         registry.For(type).LifecycleIs(new UniquePerRequestLifecycle());// will create a new instance per request
     }
 }

        public INoobotContainer Generate()
        {
            var registry = new Registry();

            registry.Scan(x =>
            {
                x.TheCallingAssembly();
                x.WithDefaultConventions();
            });

            registry = _pipelineManager.Initialise(registry);
            registry = _pluginManager.Initialise(registry);

            registry
                .For<ISlackWrapper>()
                .Singleton();

            registry
                .For<IPipelineFactory>()
                .Singleton();

            Type[] pluginTypes = _pluginManager.ListPluginTypes();
            var container = new NoobotContainer(registry, pluginTypes);

            IPipelineFactory pipelineFactory = container.GetInstance<IPipelineFactory>();
            pipelineFactory.SetContainer(container);

            return container;
        }

        public Application()
        {
            _peers = new List<Case42Peer>();
            Registry = new Registry();

            Registry.Set(new LobbyComponent(this));
        }

        public void Apply(PluginGraph graph)
        {
            var registry = new Registry();

            _interfaces.Each(@interface =>
            {
                var expression = registry.For(@interface);
                ConfigureFamily(expression);

                var exactMatches = _concretions.Where(x => x.CanBeCastTo(@interface)).ToArray();
                if (exactMatches.Length == 1)
                {
                    expression.Use(exactMatches.Single());
                }
                else
                {
                    exactMatches.Each(type => expression.Add(type));
                }


                if ([email protected]())
                {
                    addConcretionsThatCouldBeClosed(@interface, expression);
                }
            });

            _concretions.Each(t => graph.ConnectedConcretions.Fill(t));
            registry.As<IPluginGraphConfiguration>().Configure(graph);
        }

        public void RegisterCommand(Registry registry)
        {
            var openCommandMethodResultType = typeof(CommandResult<>);
            var closedCommandMethodResultType = openCommandMethodResultType.MakeGenericType(CommandType);

            var openActionMethodInvokerType = typeof(IActionMethodResultInvoker<>);
            var closedActionMethodInvokerType =
                openActionMethodInvokerType.MakeGenericType(closedCommandMethodResultType);

            var closedDomainResultType = typeof(CommandResult);

            var openCommandMethodResultInvokerType = typeof(ResultInvoker<,>);
            var closedCommandMethodResultInvokerType =
                openCommandMethodResultInvokerType.MakeGenericType(closedCommandMethodResultType, closedDomainResultType);

            registry.For(closedActionMethodInvokerType).Use(closedCommandMethodResultInvokerType);

            var openResultProcessor = typeof(IResultProcessor<,>);
            var closedResultProcessor =
                openResultProcessor.MakeGenericType(closedCommandMethodResultType, closedDomainResultType);

            var openCommandMethodResultProcessorType = typeof(CommandResultProcessor<>);
            var closedCommandMethodResultProcessorType =
                openCommandMethodResultProcessorType.MakeGenericType(CommandType);

            registry.For(closedResultProcessor).Use(closedCommandMethodResultProcessorType);
        }

        public void FindRegistriesWithinPluginGraphSeal()
        {
            var builder = new PluginGraphBuilder();
            var registry = new Registry();
            registry.Scan(x =>
            {
                x.AssemblyContainingType(typeof(RedGreenRegistry));
                x.LookForRegistries();
            });
            builder.AddConfiguration(registry);

            var graph = builder.Build();

            var colors = new List<string>();
            PluginFamily family = graph.FindFamily(typeof (IWidget));

            family.Instances.Each(instance => colors.Add(instance.Name));

            Assert.Contains("Red", colors);
            Assert.Contains("Green", colors);
            Assert.Contains("Yellow", colors);
            Assert.Contains("Blue", colors);
            Assert.Contains("Brown", colors);
            Assert.Contains("Black", colors);
        }

        public Application()
        {
            _peers = new List<RunePeer>();
            Registry = new Registry();

            Registry.Set(new LobbyComponent());
        }

 public void Process(Type type, Registry registry)
 {
     if (type.CanBeCastTo<ITeam>() && type != typeof(ITeam))
     {
         registry.For(typeof(ITeam)).Add(type);
     }
 }

 public void Process(Type type, Registry registry)
 {
     if (Registry.IsPublicRegistry(type))
     {
         registry.Configure(x => x.ImportRegistry(type));
     }
 }

        public static void RegisterStandardInteractionHandlersForEntities(Registry registry, StandardInteractionHandlerGenericTypeDefinitions standardInteractionHandlerGenericTypeDefinitions, params Assembly[] assembliesContainingEntities)
        {
            Argument.IsNotNull(registry, "registry");
            Argument.IsNotNull(standardInteractionHandlerGenericTypeDefinitions, "standardInteractionHandlerGenericTypeDefinitions");
            Argument.IsNotNull(assembliesContainingEntities, "assembliesContainingEntities");
            Argument.IsValid(assembliesContainingEntities.Length > 0,
                             "The array of assemblies that contain entities is empty. The array must have at least one assembly specified.",
                             "assembliesContainingEntities");

            var entityTypes = assembliesContainingEntities.SelectMany(assembly => assembly.GetTypes().Where(type => type != typeof(Entity) && typeof(Entity).IsAssignableFrom(type)));

            foreach (var entityType in entityTypes) // E.g. User.
            {
                // E.g. IQueryHandler<GetByIdQuery<User>, Option<User>>.
                ConnectInteractionHandlerToStandardInteractionForEntityType(registry, typeof(IQueryHandler<,>), typeof(GetByIdQuery<>), typeof(Option<>).MakeGenericType(entityType), standardInteractionHandlerGenericTypeDefinitions.GetByIdQueryHandler, entityType);
                // E.g. IQueryHandler<GetOneQuery<User>, Option<User>>.
                ConnectInteractionHandlerToStandardInteractionForEntityType(registry, typeof(IQueryHandler<,>), typeof(GetOneQuery<>), typeof(Option<>).MakeGenericType(entityType), standardInteractionHandlerGenericTypeDefinitions.GetOneQueryHandler, entityType);
                // E.g. IQueryHandler<GetAllQuery<User>, IPagedEnumerable<User>>.
                ConnectInteractionHandlerToStandardInteractionForEntityType(registry, typeof(IQueryHandler<,>), typeof(GetAllQuery<>), typeof(IPagedEnumerable<>).MakeGenericType(entityType), standardInteractionHandlerGenericTypeDefinitions.GetAllQueryHandler, entityType);
                // E.g. IQueryHandler<GetTotalCountQuery<User>, int>.
                ConnectInteractionHandlerToStandardInteractionForEntityType(registry, typeof(IQueryHandler<,>), typeof(GetTotalCountQuery<>), typeof(int), standardInteractionHandlerGenericTypeDefinitions.GetTotalCountQueryHandler, entityType);

                // E.g. IRequestHandler<CanDeleteEntityRequest<User>, Response<Option<User>>>.
                ConnectInteractionHandlerToStandardInteractionForEntityType(registry, typeof(IRequestHandler<,>), typeof(CanDeleteEntityRequest<>), typeof(Response<>).MakeGenericType(typeof(Option<>).MakeGenericType(entityType)), standardInteractionHandlerGenericTypeDefinitions.CanDeleteEntityRequestHandler, entityType);

                // E.g. ICommandHandler<DeleteEntityCommand<User>, Response>.
                ConnectInteractionHandlerToStandardInteractionForEntityType(registry, typeof(ICommandHandler<,>), typeof(DeleteEntityCommand<>), typeof(Response), standardInteractionHandlerGenericTypeDefinitions.DeleteEntityCommandHandler, entityType);
            }
        }