/// <inheritdoc />
 public virtual void Prepare(ILocator locator)
 {
     if (!this.IsInitialized || this.IsPrepared)
     throw new InvalidOperationException();
      this.Locator = locator;
      this.IsPrepared = true;
 }

 public DetectAndHashJob(JobDescriptor jobDescription, Guid workerId, ILocator locator) : 
     base(jobDescription, workerId, locator)
 {
     _codeLocationRepository = _serviceLocator.Locate<ICodeLocationRepository>();
     _fileRepository = _serviceLocator.Locate<IFileRepository>();
     _repositoryController = _serviceLocator.Locate<IRepositoryController>();
 }

 public EncodeJobNotification(IJob[] jobsReady, string OriginalAssetName, ILocator[] Locators, string UrlForClientStreaming)
 {
     myJobList = jobsReady;
     myAssetName = OriginalAssetName;
     myLocators = Locators;
     myUrlForClientStreaming = UrlForClientStreaming;
 }

 public ToggleButtonHandle(Figure owner, ILocator locator)
     : base(owner, locator)
 {
     FillColor = new Color (1, 1, 0.0, 0.3);
     Width = 15.0;
     Height = 15.0;
 }

 public ButtonHandle(IFigure owner, ILocator locator, kindButton type)
     : base(owner)
 {
     _locator = locator;
     _clicked = false;
     typeButton = type;
 }

 /// <summary>
 ///   Wrap an existing exception in a SAXParseException.
 ///   <para>
 ///     This constructor is especially useful when an application is
 ///     creating its own exception from within a <see cref="org.xml.sax.ContentHandler" /> callback,
 ///     and needs to wrap an existing exception that is not a
 ///     subclass of <see cref="SAXException" />.
 ///   </para>
 /// </summary>
 /// <param name="message">
 ///   The error or warning message, or null to
 ///   use the message from the embedded exception.
 /// </param>
 /// <param name="locator">
 ///   The locator object for the error or warning (may be null).
 /// </param>
 /// <param name="ex">Any exception.</param>
 /// <seealso cref="ILocator" />
 public SAXParseException(string message, ILocator locator, Exception ex) : base(message, ex) {
   if (locator != null) {
     Init(locator.PublicId, locator.SystemId, locator.LineNumber, locator.ColumnNumber);
   } else {
     Init(null, null, -1, -1);
   }
 }

		public ServiceConfiguration(ILocator locator, ICollection<RouteBase> routes, string[] allowedSchemes, Type contractType, Type serviceType)
		{
			this.locator = locator;
			this.routes = routes;
			this.allowedSchemes = allowedSchemes;
			this.contractType = contractType;
			this.serviceType = serviceType;
		}

    ////
    /// <summary>
    ///   Copy an existing Locator or Locator2 object.
    ///   If the object implements Locator2, values of the
    ///   <em>encoding</em> and <em>version</em>strings are copied,
    ///   otherwise they set to <em>null</em>.
    /// </summary>
    /// <param name="locator">
    ///   The existing Locator object.
    /// </param>
    public Locator2(ILocator locator) : base(locator) {
      if (locator is ILocator2) {
        var l2 = (ILocator2)locator;

        _version = l2.XmlVersion;
        _encoding = l2.Encoding;
      }
    }

 private ProjectionGatewayConfigurationBuilder(ILocator locator)
 {
     _locator = locator;
     var stringEqComparer = EqualityComparerFactory.Create<string>(
         (x, y) => x.ToLower() == y.ToLower(),
         s => s.GetHashCode());
     Subscriptions = new MultiValueDictionary<string, Subscription>(stringEqComparer);
 }

        public TransformHandle(MoonlightController controller, IHandleGroup group, ILocator locator)
            : base(controller, group)
        {
            Locator = locator;

            rotation = new RotateTransform();
            Transforms.Children.Add(rotation);
        }

		public LocatorServiceHostFactory(
			ServiceHostConfigurator configurator,
			ILocator locator,
			string[] allowedSchemes)
		{
			this.configurator = configurator;
			this.locator = locator;
			this.allowedSchemes = allowedSchemes;
		}

 public GatewayConfiguration(IReadOnlyCollection<Host> hosts, UserCrenedtial userCredential, ILocator locator, int prefetchCount, int eventSubscriberThreadCount, int commandHandlerThreadCount)
 {
     Hosts = hosts;
     UserCrenedtial = userCredential;
     Locator = locator;
     PrefetchCount = prefetchCount;
     EventSubscriberThreadCount = eventSubscriberThreadCount;
     CommandHandlerThreadCount = commandHandlerThreadCount;
 }

 public static ILocator GetLocator()
 {
     if (locator == null)
     {
         locator = new DefaultLocator(new DefaultFactoryMethodFactory());
         RegisterAbstractions(locator);
     }
     return locator;
 }

        public JobPoller(WorkloadPresenter presenter, ILocator locator, WorkerState worker, int? intervalSeconds = null)
        {
            _interval = intervalSeconds ?? _interval;

            _presenter = presenter;
            _jobRepository = locator.Locate<IJobRepository>();
            _worker = worker;
            _serviceLocator = locator;
        }

		private IContractBehavior ContractBehavior(ILocator locator, Type serviceType)
		{
			var provider =
				locator.IsRegistered(contractType) ?
					(IContractBehavior)new LocatorInstanceProvider(locator, contractType) :
					new ActivatorInstanceProvider(serviceType);

			return provider;
		}

 public NewConnectionHandle(IFigure owner, ILocator locator)
     : base(owner, locator)
 {
     if (_icon == null) {
         // TODO: use icon factory.
         Pixbuf pixbuf = Pixbuf.LoadFromResource("icons.new_association_handle.png");
         _icon = GdkCairoHelper.PixbufToImageSurface(pixbuf);
     }
 }

		public LocatorServiceHost(ILocator locator, Type contractType, Type serviceType, params Uri[] baseAddresses)
			: base(serviceType, baseAddresses)
		{
			this.contractType = contractType;

			foreach (var contractDescription in ImplementedContracts.Values)
			{
				contractDescription.Behaviors.Add(ContractBehavior(locator, serviceType));
			}
		}

        public Job(JobDescriptor jobDescription, Guid workerId, ILocator locator)
        {
            _serviceLocator = locator;
            _jobRepository = locator.Locate<IJobRepository>();
            _apiRepository = locator.Locate<IApiDataRepository>();

            Id = jobDescription.Id;
            WorkerId = workerId;
            JobDescriptor = jobDescription;
        }

 public RabbitMqGateway(string connectionString, int eventSubscriberThreadCount, int commandHandlerThreadCount, ILocator locator)
 {
     _eventSubscriberThreadCount = eventSubscriberThreadCount;
     _commandHandlerThreadCount = commandHandlerThreadCount;
     var adapter = new EasyNetQContainerAdapter(locator);
     RabbitHutch.SetContainerFactory(() => adapter);
     _externalMessageBus = RabbitHutch.CreateBus(connectionString, register => register.Register<IConsumerErrorStrategy, MyClass>());
     _eventBus = locator.Resolve<Core.IEventBus>();
     _commandHandlerFactory = locator.Resolve<ICommandHandlerFactory>();
     var a = locator.Resolve<IConsumerErrorStrategy>();
 }

        public static IJob CreateJob(JobDescriptor description, WorkerState worker, ILocator locator)
        {
            var jobType = Type.GetType(description.JobType);
            if (jobType == null)
            {
                throw new TypeAccessException("Could not create a type from " + description.JobType);
            }
            var instance = Activator.CreateInstance(jobType, description, worker.Id, locator) as IJob;

            return instance;
        }