/// <summary>
 /// Get IServiceLocator instace.
 /// </summary>
 /// <returns></returns>
 public static IServiceLocator GetInstance()
 {
     if (singletonServiceLocator == null) {
         singletonServiceLocator = new AbstractServiceLocator ();
     }
     return singletonServiceLocator;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ServiceLocatorAutoRegistrationManager" /> class.
        /// </summary>
        /// <param name="serviceLocator">The service locator.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="serviceLocator"/> is <c>null</c>.</exception>
        public ServiceLocatorAutoRegistrationManager(IServiceLocator serviceLocator)
        {
            Argument.IsNotNull("serviceLocator", serviceLocator);

            _serviceLocator = serviceLocator;

            if (EnvironmentHelper.IsProcessCurrentlyHostedByTool())
            {
                return;
            }

            TypeCache.AssemblyLoaded += (sender, args) =>
            {
                foreach (var type in args.LoadedTypes)
                {
                    _pendingTypes.Enqueue(type);
                }

                if (_autoRegisterTypesViaAttributes)
                {
                    try
                    {
                        InspectLoadedAssemblies();
                    }
                    catch (Exception ex)
                    {
                        Log.Error(ex, "Failed to handle dynamically loaded assembly '{0}'", args.Assembly.FullName);
                    }
                }
            };
        }

 public AbstractTestRunner(IServiceLocator services, TestPackage package)
 {
     Services = services;
     TestPackage = package;
     TestRunnerFactory = Services.GetService<ITestRunnerFactory>();
     ProjectService = Services.GetService<IProjectService>();
 }

 	public XmlMessageSerializer(IReflection reflection, IServiceLocator serviceLocator )
     {
         this.reflection = reflection;
         this.serviceLocator = serviceLocator;
     	customElementSerializers = this.serviceLocator.ResolveAll<ICustomElementSerializer>().ToArray();
 		elementSerializationBehaviors = this.serviceLocator.ResolveAll<IElementSerializationBehavior>().ToArray();
     }

 public ApplicationController(IShellView shellView, IServiceLocator serviceLocator)
 {
     if (shellView == null) throw new ArgumentNullException("shellView");
     if (serviceLocator == null) throw new ArgumentNullException("serviceLocator");
     this.shellView = shellView;
     this.serviceLocator = serviceLocator;
 }

 public ExampleHtmlWriter(IServiceLocator serviceLocator, IUrlRegistry urlRegistry, BehaviorGraph behaviorGraph)
 {
     _serviceLocator = serviceLocator;
     _urlRegistry = urlRegistry;
     _behaviorGraph = behaviorGraph;
     _examplePageUrl = "_fubu/html/example".ToAbsoluteUrl();
 }

        internal static void Setup(IServiceLocator locator, ProviderConfiguration config)
        {
            var factories = config.Datastores.Cast<Datastore>().Select(LoadFactory);
            var proxy = new UnitOfWorkFactoryProxy(factories);

            locator.Inject<IUnitOfWorkFactory>(proxy);
        }

 private static void RegisterHandlers(IServiceLocator serviceLocator)
 {
     var registrar = new BusRegistrar(serviceLocator);
     registrar.Register(typeof(CartHandlers));
     registrar.Register(typeof(CartViewProjections));
     registrar.Register(typeof(CustomerCreatedEventHandler));
 }

			public static void SetLocator(IServiceLocator locator)
			{
				if (locator == null)
					throw new ArgumentNullException();

				instance = locator;
			}

 /// <summary>
 /// Initializes an instance of <see cref="EventMigratorManager">EventMigratorManager</see>
 /// </summary>
 /// <param name="typeDiscoverer"></param>
 /// <param name="serviceLocator"></param>
 public EventMigratorManager(ITypeDiscoverer typeDiscoverer, IServiceLocator serviceLocator)
 {
     _typeDiscoverer = typeDiscoverer;
     _serviceLocator = serviceLocator;
     _migratorTypes = new Dictionary<Type, Type>();
     Initialize();
 }

 public override void Initialize(IServiceLocator locator)
 {
     //Initializácia kodových tabuliek modulu administrácia
     locator.GetInstance<AdministrationCodeTableService>()
         .Initialize();
     
 }

        /// <summary>
        /// Default constructor for the type
        /// </summary>
        /// <param name="serviceLocator"></param>
        public TurbineControllerActivator(IServiceLocator serviceLocator) {
            if (serviceLocator == null) {
                throw new ArgumentNullException("serviceLocator");
            }

            ServiceLocator = serviceLocator;
        }

        public MailService(IServiceLocator locator)
        {
            Contract.Requires(locator != null);

            this.Serialization = locator.Resolve<ISerialization<byte[]>>();
            this.Repository = locator.Resolve<Func<string, IMailMessage>>();
        }

 /// <summary>
 /// Create executor 
 /// </summary>
 public void Execute(Object message, IServiceLocator serviceLocator)
 {
     if (_shortAction != null)
         _shortAction(message);
     else
         _fullAction(message, serviceLocator);
 }

        /// <summary>
        /// Initializes the specified service locator.
        /// </summary>
        /// <param name="serviceLocator">The service locator.</param>
        public void Initialize(IServiceLocator serviceLocator)
        {
            Argument.IsNotNull(() => serviceLocator);

            serviceLocator.RegisterTypeIfNotYetRegistered<IConnectionStringManager, ConnectionStringManager>();
            serviceLocator.RegisterTypeIfNotYetRegistered<IContextFactory, ContextFactory>();
        }

        /// <summary>
        /// Initializes the specified service locator.
        /// </summary>
        /// <param name="serviceLocator">The service locator.</param>
        public void Initialize(IServiceLocator serviceLocator)
        {
            Argument.IsNotNull(() => serviceLocator);

            serviceLocator.RegisterTypeIfNotYetRegistered<IDataContextSubscriptionService, DataContextSubscriptionService>();
            serviceLocator.RegisterTypeIfNotYetRegistered<ICommandManager, CommandManager>();
            serviceLocator.RegisterTypeIfNotYetRegistered<IViewLoadManager, ViewLoadManager>();
            serviceLocator.RegisterTypeIfNotYetRegistered<IViewModelWrapperService, ViewModelWrapperService>();
            serviceLocator.RegisterTypeIfNotYetRegistered<IViewManager, ViewManager>();
            serviceLocator.RegisterTypeIfNotYetRegistered<IViewModelManager, ViewModelManager>();
            serviceLocator.RegisterTypeIfNotYetRegistered<IAutoCompletionService, AutoCompletionService>();

#if !XAMARIN && !WIN80
            serviceLocator.RegisterTypeIfNotYetRegistered<IInteractivityManager, InteractivityManager>();
#endif

            ViewModelServiceHelper.RegisterDefaultViewModelServices(serviceLocator);

            // Don't use property, we cannot trust the cached property here yet in Visual Studio
            if (CatelEnvironment.GetIsInDesignMode())
            {
                foreach (var assembly in AssemblyHelper.GetLoadedAssemblies())
                {
                    var attributes = assembly.GetCustomAttributesEx(typeof (DesignTimeCodeAttribute));
                    foreach (var attribute in attributes)
                    {
                        // No need to do anything
                    }
                }
            }
        }

        public CatelWebApiDependencyResolver(IServiceLocator serviceLocator)
        {
            Argument.IsNotNull(() => serviceLocator);

            _serviceLocator = serviceLocator;
            _typeFactory = serviceLocator.ResolveType<ITypeFactory>();
        }

        public ContainerSwitcher(IServiceLocator newContainer, bool shouldDisposeContainerWhenDone)
        {
            originalContainer = EnterpriseLibraryContainer.Current;
            shouldDisposeNewContainer = shouldDisposeContainerWhenDone;

            EnterpriseLibraryContainer.Current = newContainer;
        }

        /// <summary>
        /// Queries the <see cref="IServiceLocator"/> instance for any instances of <see cref="IFilterRegistry"/> to process.
        /// </summary>
        /// <param name="serviceLocator">Current <see cref="IServiceLocator"/> instance for the application.</param>
        public virtual void SetupFilterRegistries(IServiceLocator serviceLocator) {
            var filterRegistries = GetFilterRegistries(serviceLocator);
            if (filterRegistries == null) return;

            var filterList = new List<Filter>();
            var typeList = new List<Type>();

            foreach (var filterRegistry in filterRegistries) {
                var registrations = filterRegistry.GetFilterRegistrations();

                using (serviceLocator.Batch()) {
                    foreach (var registration in registrations) {
                        var filterType = registration.FilterType;

                        // Prevent double registration of the same filter
                        if (typeList.Contains(filterType)) continue;

                        serviceLocator.Register(filterType, filterType);
                        typeList.Add(filterType);
                    }
                }

                filterList.AddRange(registrations);
            }

            typeList.Clear();
            FilterProviders.Providers.Add(new FilterRegistryProvider(serviceLocator, filterList));
        }

        /// <summary>
        ///     Initializes a new instance of the <see cref="DbAccessProvider" /> class.
        /// </summary>
        /// <param name="dbAccessProviders">
        ///     The db access providers.
        /// </param>
        /// <param name="serviceLocator">
        ///     The service locator.
        /// </param>
        public DbAccessProvider(IIndex<string, IDbAccess> dbAccessProviders, IServiceLocator serviceLocator)
        {
            this._dbAccessProviders = dbAccessProviders;
            this._serviceLocator = serviceLocator;
            this._providerName = Config.ConnectionProviderName;

            this._dbAccessSafe = new SafeReadWriteProvider<IDbAccess>(
                () =>
                    {
                        IDbAccess dbAccess;

                        // attempt to get the provider...
                        if (this._dbAccessProviders.TryGetValue(this.ProviderName, out dbAccess))
                        {
                            // first time...
                            this._serviceLocator.Get<IRaiseEvent>().Raise(new InitDatabaseProviderEvent(this.ProviderName, dbAccess));
                        }
                        else
                        {
                            throw new NoValidDbAccessProviderFoundException(
                                @"Unable to Locate Provider Named ""{0}"" in Data Access Providers (DLL Not Located in Bin Directory?).".FormatWith(
                                    this.ProviderName));
                        }

                        return dbAccess;
                    });
        }