/// <summary>
		///   Returns true if the resolver is able to satisfy the specified dependency.
		/// </summary>
		/// <param name = "context">Creation context, which is a resolver itself</param>
		/// <param name = "contextHandlerResolver">Parent resolver</param>
		/// <param name = "model">Model of the component that is requesting the dependency</param>
		/// <param name = "dependency">The dependency model</param>
		/// <returns>
		///   <c>true</c>
		///   if the dependency can be satisfied</returns>
		public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
		{
			// 1 - check for the dependency on CreationContext, if present
			if (CanResolveFromContext(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 2 - check with the model's handler, if not the same as the parent resolver
			if (CanResolveFromHandler(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 3 - check within parent resolver, if present
			if (CanResolveFromContextHandlerResolver(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 4 - check within subresolvers
			if (CanResolveFromSubResolvers(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 5 - normal flow, checking against the kernel
			return CanResolveFromKernel(context, model, dependency);
		}

        public object Resolve(
			 CreationContext context,
			 ISubDependencyResolver parentResolver,
			 ComponentModel model,
			 DependencyModel dependency)
        {
            MockingStrategy strategy = _relatedRepository.GetStrategyFor(dependency);

            if (strategy.Instance != null)
                return strategy.Instance;
            if (strategy.Mock == MockingStrategyType.Mock)
            {
                //if a dependencywas already registered in the main controller, go and use it
                var registration = this._relatedRepository.Kernel.GetHandler(dependency.TargetType);
                object resolvedDependencyObject;
                if (registration == null)
                {
                    resolvedDependencyObject = MockRepository.GenerateStub(dependency.TargetType);
                }
                else
                {
                    resolvedDependencyObject = _relatedRepository.Resolve(dependency.TargetType);
                }
                _relatedRepository.OnMockCreated(resolvedDependencyObject, dependency.DependencyKey);
                return resolvedDependencyObject;
            }
            if (strategy.Mock == MockingStrategyType.Resolve)
                return _relatedRepository.Resolve(dependency.TargetType);

            return null;
        }

 public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
     DependencyModel dependency)
 {
     if (dependency.TargetType == typeof (ISession))
         return SessionFactory.OpenSession();
     return SessionFactory.OpenStatelessSession();
 }

        public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
        {
			return dependency.TargetType != null &&
			       dependency.TargetType.IsArray &&
			       dependency.TargetType.GetElementType().IsInterface &&
				   !model.Parameters.Contains(dependency.DependencyKey);
        }

 public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
 {
     string componentName = null;
     if (!_knownDependencies.ContainsKey(dependency))
         componentName = dependency.DependencyKey;
     return _kernel.Resolve(componentName, dependency.TargetType);
 }

			public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
			                      DependencyModel dependency)
			{
				return contextHandlerResolver.Resolve(context, contextHandlerResolver, model,
				                                      new DependencyModel(DependencyType.Service, typeof(IBookStore).FullName,
				                                                          typeof(IBookStore), false));
			}

        /// <inheritdoc />
        public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, Castle.Core.ComponentModel model, DependencyModel dependency)
        {
            if (dependency.TargetType == null)
            {
                return false;
            }

            Type genericArgument = null;
            if ((dependency.TargetType.IsGenericType) && (dependency.TargetType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
            {
                genericArgument = dependency.TargetType.GetGenericArguments()[0];
            }
            else
            {
                dependency.TargetType.GetInterfaces().Any(implemented => (implemented.IsGenericType) && (implemented.GetGenericTypeDefinition() == typeof(IEnumerable<>)) &&
                    ((genericArgument = implemented.GetGenericArguments()[0]) != null));
            }

            if ((genericArgument == null) || (!_kernel.HasComponent(genericArgument)))
            {
                return false;
            }

            return true;
        }

 public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
     ComponentModel model,
     DependencyModel dependency)
 {
     Type t = dependency.TargetType.GetGenericArguments()[0];
     return kernel.ResolveAll(t, null);
 }

		public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
		                       DependencyModel dependency)
		{
			return dependency.TargetType == typeof(IBookStore) && contextHandlerResolver.CanResolve(context, contextHandlerResolver, model,
			                                                                                        new DependencyModel(typeof(IBookStore).FullName,
			                                                                                                            typeof(IBookStore), false));
		}

		public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
							  DependencyModel dependency)
		{
			Type elementType = dependency.TargetType.GetElementType();
			Array all = kernel.ResolveAll(elementType, new Hashtable());
			return all;
		}

 public object Resolve(CreationContext context,
     ISubDependencyResolver parentResolver,
     ComponentModel model,
     DependencyModel dependency)
 {
     return _kernel.ResolveAll(dependency.TargetType.GetElementType(), null);
 }

        public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
                               DependencyModel dependency)
        {

            return Context.CurrentUser != null &&
                   dependency.TargetType == typeof (INotifications);
        }

 public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver,
                        ComponentModel model,
                        DependencyModel dependency)
 {
     return dependency.TargetType != null &&
            dependency.TargetType.IsArray &&
            dependency.TargetType.GetElementType().IsInterface;
 }

		public override object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
		                               ComponentModel model,
		                               DependencyModel dependency)
		{
			var items = base.Resolve(context, contextHandlerResolver, model, dependency);
			var listType = BuildListType(dependency);
			return listType.CreateInstance<object>(items);
		}

		public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
		                       ComponentModel model,
		                       DependencyModel dependency)
		{
			return dependency.TargetType != null &&
			       dependency.TargetType.IsArray &&
				   kernel.HasComponent(dependency.TargetType.GetElementType());
		}

        public bool CanResolve(
			CreationContext context,
			ISubDependencyResolver parentResolver,
			ComponentModel model,
			DependencyModel dependency )
        {
            return dependency.DependencyType == DependencyType.Service;
        }

		/// <summary>
		/// Initializes a new instance of the <see cref="ParentHandlerWithChildResolver"/> class.
		/// </summary>
		/// <param name="parentHandler">The parent handler.</param>
		/// <param name="childResolver">The child resolver.</param>
		public ParentHandlerWithChildResolver(IHandler parentHandler, ISubDependencyResolver childResolver) 
		{
			if (parentHandler == null) throw new ArgumentNullException("parentHandler");
			if (childResolver == null) throw new ArgumentNullException("childResolver");

			this.parentHandler = parentHandler;
			parentHandler.OnHandlerStateChanged += new HandlerStateDelegate(RaiseHandlerStateChanged);
			this.childResolver = childResolver;
		}

		public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
		                       ComponentModel model,
		                       DependencyModel dependency)
		{
			var targetType = dependency.TargetItemType;
			return targetType != null &&
			       targetType.IsArray &&
			       (allowEmptyArray || kernel.HasComponent(targetType.GetElementType()));
		}

		/// <summary>
		/// Returns true if the resolver is able to satisfy the specified dependency.
		/// </summary>
		/// <param name="context">Creation context, which is a resolver itself</param>
		/// <param name="contextHandlerResolver">Parent resolver</param>
		/// <param name="model">Model of the component that is requesting the dependency</param>
		/// <param name="dependency">The dependency model</param>
		/// <returns><c>true</c> if the dependency can be satisfied</returns>
		public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
							   DependencyModel dependency)
		{
			// 1 - check for the dependency on CreationContext, if present

			if (context != null)
			{
				if (context.CanResolve(context, contextHandlerResolver, model, dependency))
				{
					return true;
				}
			}

			// 2 - check with the model's handler, if not the same as the parent resolver

			IHandler handler = kernel.GetHandler(model.Name);

			if (handler != null && handler != contextHandlerResolver)
			{
				if (handler.CanResolve(context, contextHandlerResolver, model, dependency))
				{
					return true;
				}
			}

			// 3 - check within parent resolver, if present

			if (contextHandlerResolver != null)
			{
				if (contextHandlerResolver.CanResolve(context, contextHandlerResolver, model, dependency))
				{
					return true;
				}
			}

			// 4 - check within subresolvers

			foreach(ISubDependencyResolver subResolver in subResolvers)
			{
				if (subResolver.CanResolve(context, contextHandlerResolver, model, dependency))
				{
					return true;
				}
			}

			// 5 - normal flow, checking against the kernel

			if (dependency.DependencyType == DependencyType.Service ||
				dependency.DependencyType == DependencyType.ServiceOverride)
			{
				return CanResolveServiceDependency(context, model, dependency);
			}
			else
			{
				return CanResolveParameterDependency(model, dependency);
			}
		}

 public object Resolve(CreationContext context,
     ISubDependencyResolver parentResolver,
     ComponentModel model,
     DependencyModel dependency)
 {
     var targetType = dependency.TargetType.GetElementType();
     var resolved = _kernel.ResolveAll(targetType, null);
     return resolved;
 }