private void ConfigureHttpInterfaces(ConfigurationExpression x)
 {
     // Woot!!  Interfaces for HttpContext stuff!  Goodbye to nasty unmockable
     // abstract base classes.
     // http://haacked.com/archive/2007/09/09/ihttpcontext-and-other-interfaces-for-your-duck-typing-benefit.aspx
     // Update: the third party library in that post causes problems in production if multiple
     // requests during the bootstrapping process.  I made hand-rolled proxies instead, which you can get here:
     // http://github.com/jonkruger/httpinterfaces
     x.For<IHttpApplication>().Use(
         c => WebContext.Cast(HttpContext.Current.ApplicationInstance));
     x.For<IHttpApplicationState>().Use(
         c => WebContext.Cast(HttpContext.Current.Application));
     x.For<IHttpCachePolicy>().Use(
         c => WebContext.Cast(HttpContext.Current.Response.Cache));
     x.For<IHttpClientCertificate>().Use(
         c => WebContext.Cast(HttpContext.Current.Request.ClientCertificate));
     x.For<IHttpContext>().Use(
         c => WebContext.Cast(HttpContext.Current));
     x.For<IHttpFileCollection>().Use(
         c => WebContext.Cast(HttpContext.Current.Request.Files));
     x.For<IHttpModuleCollection>().Use(
         c => WebContext.Cast(HttpContext.Current.ApplicationInstance.Modules));
     x.For<IHttpRequest>().Use(
         c => WebContext.Cast(HttpContext.Current.Request));
     x.For<IHttpResponse>().Use(
         c => WebContext.Cast(HttpContext.Current.Response));
     x.For<IHttpServerUtility>().Use(
         c => WebContext.Cast(HttpContext.Current.Server));
     x.For<IHttpSession>().Use(
         c => WebContext.Cast(HttpContext.Current.Session));
     x.For<ITraceContext>().Use(
         c => WebContext.Cast(HttpContext.Current.Trace));
 }

        public void Configure(ConfigurationExpression cfg, IFoundationConfigurator foundationConfigurator)
        {

            if (foundationConfigurator.UseQueryContainer)
            {
                cfg.AddRegistry(new QueryRegistery());
                cfg.For<IQueryRegistery>().Use<QueryRegistery>();
            }

            if (foundationConfigurator.UseBuseinssManagers)
            {
                cfg.AddRegistry(new BusinessManagerRegistery());
                cfg.For<IBusinessManagerRegistery>().Use<BusinessManagerRegistery>();
                cfg.For<IBusinessManagerInvocationLogger>(foundationConfigurator.Business.BusinessInvocationLogger, true);
            }

            if (foundationConfigurator.UseEmailing)
            {
                cfg.AddRegistry(new EmailRegistery());
                cfg.For<IEmailLogger>(foundationConfigurator.Business.EmailLogger);
            }

            if (foundationConfigurator.Web.FlashMessenger != null)
            {
                cfg.For<IFlashMessenger>(foundationConfigurator.Web.FlashMessenger);
            }

            cfg.AddRegistry(new SecurityRegistery());
        }

		protected virtual void InitializeActivityLogging(ConfigurationExpression x)
		{
			x.For<IActivityLogPathProvider>().HybridHttpOrThreadLocalScoped().Use<ActivityLogPathProvider>();
			x.For<ILogManager>().HybridHttpOrThreadLocalScoped().Use<TpLogManager>();
			x.For<Log4NetFileRepositoryMock>().Singleton().Use<Log4NetFileRepositoryMock>();
			x.Forward<Log4NetFileRepositoryMock, ILog4NetFileRepository>();
		}

        private static void ConfigureContainer(ConfigurationExpression container)
        {
            //Swap out the default ContentRenderer for our custom
            container.For<IContentRenderer>().Use<ErrorHandlingContentRenderer>();

            //Implementations for custom interfaces can be registered here.
        }

 public static void AddGitChangeTypes(ConfigurationExpression initializer)
 {
     initializer.For<IGitChangedFile>().Use<Add>().Named("A");
     initializer.For<IGitChangedFile>().Use<Modify>().Named("M");
     initializer.For<IGitChangedFile>().Use<Delete>().Named("D");
     initializer.For<IGitChangedFile>().Use<RenameEdit>().Named("R");
 }

 private static void SetDefaultClickatellClient(ClickatellConfigFileSettings clickatellConfigFileSettings,
     ConfigurationExpression x)
 {
     var clickatellClient = new ClickatellClient(clickatellConfigFileSettings);
     x.For<ClickatellClient>()
         .Use(new IgnoreAuthErrorClickatellClient(clickatellConfigFileSettings,
             new IgnoreNoCreditErrorClickatellClient(clickatellConfigFileSettings, clickatellClient)));
 }

 protected override void Configure(ConfigurationExpression cfg)
 {
     cfg.Scan(x =>
                  {
                      x.TheCallingAssembly();
                      x.LookForRegistries();
                  });
 }

        public static IPipelineGraph For(Action<ConfigurationExpression> action)
        {
            var expression = new ConfigurationExpression();
            action(expression);

            var graph = expression.BuildGraph();

            return BuildRoot(graph);
        }

        private SecurityContext(ConfigurationExpression configurationExpression)
        {
            _data = new ExpandoObject();
            _isAuthenticated = configurationExpression.IsAuthenticated;
            _roles = configurationExpression.Roles;

            var modifyer = configurationExpression.Advanced.SecurityContextModifyer;
            if (modifyer != null) modifyer.Invoke(this);
        }

        public static RootPipelineGraph For(Action<ConfigurationExpression> action)
        {
            var expression = new ConfigurationExpression();
            action(expression);

            PluginGraph graph = expression.BuildGraph();

            return new RootPipelineGraph(graph);
        }

 public void Configure(ConfigurationExpression cfg, IFoundationConfigurator foundationConfigurator)
 {
     if (foundationConfigurator.UsePresistence)
     {
         cfg.AddRegistry(new PersistenceRegistery());
         cfg.For<IConnectionString>()
            .Use(new ConnectionString(foundationConfigurator.Persistence.ConnectionStringKeyName));
     }
 }

 private static void SetupContainer(ConfigurationExpression x)
 {
     x.Scan(i =>
     {
         i.TheCallingAssembly();
         i.Convention<SettingsScanner>();
     });
     x.SetAllProperties(s => s.Matching(p => p.Name.EndsWith("Settings")));
 }

 private static void ConfigureContainer(ConfigurationExpression container)
 {
     //Swap out the default ContentRenderer for our custom
     //container.For<IContentRenderer>().Use<ErrorHandlingContentRenderer>();
     container.For<ContentAreaRenderer>().Use<ContentAreaWithDefaultsRenderer>();
     container.For<ICustomerAddressRepository>().Use<CustomerAddressRepository>();
     container.For<IOrderRepository>().Use<OrderRepository>();
     container.For<IExportOrderService>().Use<ExportOrderService>();
 }

 private static void Initialize(ConfigurationExpression initializer)
 {
     var tfsPlugin = TfsPlugin.Find();
     initializer.Scan(x => { Initialize(x); tfsPlugin.Initialize(x); });
     initializer.For<TextWriter>().Use(() => Console.Out);
     initializer.For<IGitRepository>().Add<GitRepository>();
     AddGitChangeTypes(initializer);
     DoCustomConfiguration(initializer);
     tfsPlugin.Initialize(initializer);
 }

        private static void ConfigureContainer(ConfigurationExpression container)
        {
            container.For<IFormSerializer>().Use<FormSerializer>();
            container.For<IFormFieldSerializeUtils>().Use<FormFieldSerializeUtils>();
            container.For<IFormFieldModelBuilder>().Use<FormFieldModelBuilder>();
            container.For<IXFormBuilder>().Use<XFormBuilder>();

            container.For<IFormTypeModelSynchronizer>().Use<FormTypeModelSynchronizer>();
            container.For<IFormFieldTypeSynchronizer>().Use<FormFieldTypeSynchronizer>();
        }

 private static void RegisterComplex(ConfigurationExpression r)
 {
     r.For<IFirstService>().Singleton().Use<FirstService>();
     r.For<ISecondService>().Singleton().Use<SecondService>();
     r.For<IThirdService>().Singleton().Use<ThirdService>();
     r.For<ISubObjectOne>().Transient().Use<SubObjectOne>();
     r.For<ISubObjectTwo>().Transient().Use<SubObjectTwo>();
     r.For<ISubObjectThree>().Transient().Use<SubObjectThree>();
     r.For<IComplex>().Transient().Use<Complex>();
 }

 private static void DoCustomConfiguration(ConfigurationExpression initializer)
 {
     foreach(var type in typeof(Program).Assembly.GetTypes())
     {
         foreach(ConfiguresStructureMap attribute in type.GetCustomAttributes(typeof(ConfiguresStructureMap), false))
         {
             attribute.Initialize(initializer, type);
         }
     }
 }

 private static void SetupContainer(ConfigurationExpression x)
 {
     x.For<IHttpSession>().Use<CurrentHttpContextSession>();
     x.Scan(i =>
     {
         i.TheCallingAssembly();
         i.Convention<SettingsScanner>();
     });
     x.For<ISettingsProvider>().Use<AppSettingsProvider>();
     x.SetAllProperties(s => s.Matching(p => p.Name.EndsWith("Settings")));
 }

        static void Configure(ConfigurationExpression x)
        {
            x.AddRegistry(new MyAppRegistry());

            x.For<IObjectContainer>()
                .Singleton()
                .Use(Db4oEmbedded.OpenFile(Db4oEmbedded.NewConfiguration(), DbPath));

            x.For(typeof (IRepository<>))
                .Use(typeof (Repository<>));
        }

        private static void ConfigureContainer(ConfigurationExpression container)
        {
            container.For<IEpiServerDependenciesResolver>().Use<EpiServerDependenciesResolver>();
            container.For<IBlockHelper>().Use<BlockHelper>();
            container.For<IContextResolver>().Use<ContextResolver>();
            container.For<ILinkResolver>().Use<LinkResolver>()
                .Ctor<IEpiServerDependenciesResolver>().Is<EpiServerDependenciesResolver>();
 
            container.For<IEpiServerDependencies>()
                .Use<EpiServerDependencies>();
        }