0001    //
0002    //  Container.Arguments.swift
0003    //  Swinject
0004    //
0005    //  Created by Yoichi Tagaya on 8/18/15.
0006    //  Copyright © 2015 Swinject Contributors. All rights reserved.
0007    //
0008    
0009    //
0010    // NOTICE:
0011    //
0012    // Container.Arguments.swift is generated from Container.Arguments.erb by ERB.
0013    // Do NOT modify Container.Arguments.swift directly.
0014    // Instead, modify Container.Arguments.erb and run `script/gencode` at the project root directory to generate the code.
0015    //
0016    
0017    
0018    import Foundation
0019    
0020    // MARK: - Registeration with Arguments
0021    extension Container {
0022        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0023        ///
0024        /// - Parameters:
0025        ///   - serviceType: The service type to register.
0026        ///   - name:        A registration name, which is used to differenciate from other registrations
0027        ///                  that have the same service and factory types.
0028        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0029        ///                  It is invoked when the `Container` needs to instantiate the instance.
0030        ///                  It takes a `ResolverType` instance and 1 argument to inject dependencies to the instance,
0031        ///                  and returns the instance of the component type for the service.
0032        ///
0033        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0034        public func register<Service, Arg1>(
0035            serviceType: Service.Type,
0036            name: String? = nil,
0037            factory: (ResolverType, Arg1) -> Service) -> ServiceEntry<Service>
0038        {
0039            return registerImpl(serviceType, factory: factory, name: name)
0040        }
0041    
0042        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0043        ///
0044        /// - Parameters:
0045        ///   - serviceType: The service type to register.
0046        ///   - name:        A registration name, which is used to differenciate from other registrations
0047        ///                  that have the same service and factory types.
0048        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0049        ///                  It is invoked when the `Container` needs to instantiate the instance.
0050        ///                  It takes a `ResolverType` instance and 2 arguments to inject dependencies to the instance,
0051        ///                  and returns the instance of the component type for the service.
0052        ///
0053        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0054        public func register<Service, Arg1, Arg2>(
0055            serviceType: Service.Type,
0056            name: String? = nil,
0057            factory: (ResolverType, Arg1, Arg2) -> Service) -> ServiceEntry<Service>
0058        {
0059            return registerImpl(serviceType, factory: factory, name: name)
0060        }
0061    
0062        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0063        ///
0064        /// - Parameters:
0065        ///   - serviceType: The service type to register.
0066        ///   - name:        A registration name, which is used to differenciate from other registrations
0067        ///                  that have the same service and factory types.
0068        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0069        ///                  It is invoked when the `Container` needs to instantiate the instance.
0070        ///                  It takes a `ResolverType` instance and 3 arguments to inject dependencies to the instance,
0071        ///                  and returns the instance of the component type for the service.
0072        ///
0073        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0074        public func register<Service, Arg1, Arg2, Arg3>(
0075            serviceType: Service.Type,
0076            name: String? = nil,
0077            factory: (ResolverType, Arg1, Arg2, Arg3) -> Service) -> ServiceEntry<Service>
0078        {
0079            return registerImpl(serviceType, factory: factory, name: name)
0080        }
0081    
0082        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0083        ///
0084        /// - Parameters:
0085        ///   - serviceType: The service type to register.
0086        ///   - name:        A registration name, which is used to differenciate from other registrations
0087        ///                  that have the same service and factory types.
0088        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0089        ///                  It is invoked when the `Container` needs to instantiate the instance.
0090        ///                  It takes a `ResolverType` instance and 4 arguments to inject dependencies to the instance,
0091        ///                  and returns the instance of the component type for the service.
0092        ///
0093        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0094        public func register<Service, Arg1, Arg2, Arg3, Arg4>(
0095            serviceType: Service.Type,
0096            name: String? = nil,
0097            factory: (ResolverType, Arg1, Arg2, Arg3, Arg4) -> Service) -> ServiceEntry<Service>
0098        {
0099            return registerImpl(serviceType, factory: factory, name: name)
0100        }
0101    
0102        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0103        ///
0104        /// - Parameters:
0105        ///   - serviceType: The service type to register.
0106        ///   - name:        A registration name, which is used to differenciate from other registrations
0107        ///                  that have the same service and factory types.
0108        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0109        ///                  It is invoked when the `Container` needs to instantiate the instance.
0110        ///                  It takes a `ResolverType` instance and 5 arguments to inject dependencies to the instance,
0111        ///                  and returns the instance of the component type for the service.
0112        ///
0113        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0114        public func register<Service, Arg1, Arg2, Arg3, Arg4, Arg5>(
0115            serviceType: Service.Type,
0116            name: String? = nil,
0117            factory: (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5) -> Service) -> ServiceEntry<Service>
0118        {
0119            return registerImpl(serviceType, factory: factory, name: name)
0120        }
0121    
0122        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0123        ///
0124        /// - Parameters:
0125        ///   - serviceType: The service type to register.
0126        ///   - name:        A registration name, which is used to differenciate from other registrations
0127        ///                  that have the same service and factory types.
0128        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0129        ///                  It is invoked when the `Container` needs to instantiate the instance.
0130        ///                  It takes a `ResolverType` instance and 6 arguments to inject dependencies to the instance,
0131        ///                  and returns the instance of the component type for the service.
0132        ///
0133        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0134        public func register<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(
0135            serviceType: Service.Type,
0136            name: String? = nil,
0137            factory: (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) -> Service) -> ServiceEntry<Service>
0138        {
0139            return registerImpl(serviceType, factory: factory, name: name)
0140        }
0141    
0142        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0143        ///
0144        /// - Parameters:
0145        ///   - serviceType: The service type to register.
0146        ///   - name:        A registration name, which is used to differenciate from other registrations
0147        ///                  that have the same service and factory types.
0148        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0149        ///                  It is invoked when the `Container` needs to instantiate the instance.
0150        ///                  It takes a `ResolverType` instance and 7 arguments to inject dependencies to the instance,
0151        ///                  and returns the instance of the component type for the service.
0152        ///
0153        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0154        public func register<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(
0155            serviceType: Service.Type,
0156            name: String? = nil,
0157            factory: (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) -> Service) -> ServiceEntry<Service>
0158        {
0159            return registerImpl(serviceType, factory: factory, name: name)
0160        }
0161    
0162        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0163        ///
0164        /// - Parameters:
0165        ///   - serviceType: The service type to register.
0166        ///   - name:        A registration name, which is used to differenciate from other registrations
0167        ///                  that have the same service and factory types.
0168        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0169        ///                  It is invoked when the `Container` needs to instantiate the instance.
0170        ///                  It takes a `ResolverType` instance and 8 arguments to inject dependencies to the instance,
0171        ///                  and returns the instance of the component type for the service.
0172        ///
0173        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0174        public func register<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8>(
0175            serviceType: Service.Type,
0176            name: String? = nil,
0177            factory: (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) -> Service) -> ServiceEntry<Service>
0178        {
0179            return registerImpl(serviceType, factory: factory, name: name)
0180        }
0181    
0182        /// Adds a registration for the specified service with the factory closure to specify how the service is resolved with dependencies.
0183        ///
0184        /// - Parameters:
0185        ///   - serviceType: The service type to register.
0186        ///   - name:        A registration name, which is used to differenciate from other registrations
0187        ///                  that have the same service and factory types.
0188        ///   - factory:     The closure to specify how the service type is resolved with the dependencies of the type.
0189        ///                  It is invoked when the `Container` needs to instantiate the instance.
0190        ///                  It takes a `ResolverType` instance and 9 arguments to inject dependencies to the instance,
0191        ///                  and returns the instance of the component type for the service.
0192        ///
0193        /// - Returns: A registered `ServiceEntry` to configure more settings with method chaining.
0194        public func register<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9>(
0195            serviceType: Service.Type,
0196            name: String? = nil,
0197            factory: (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9) -> Service) -> ServiceEntry<Service>
0198        {
0199            return registerImpl(serviceType, factory: factory, name: name)
0200        }
0201    
0202    }
0203    
0204    // MARK: - Resolvable with Arguments
0205    extension Container {
0206        /// Retrieves the instance with the specified service type and 1 argument to the factory closure.
0207        ///
0208        /// - Parameters:
0209        ///   - serviceType: The service type to resolve.
0210        ///   - argument:   1 argument to pass to the factory closure.
0211        ///
0212        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0213        ///            and 1 argument is found in the `Container`.
0214        public func resolve
SynchronizedResolver.Arguments.swift:25
            return self.container.resolve(serviceType, argument: argument)<Service, Arg1>(
0215            serviceType: Service.Type,
0216            argument: Arg1) -> Service?
0217        {
0218            return resolve(serviceType, name: nil, argument: argument)
0219        }
0220    
0221        /// Retrieves the instance with the specified service type, 1 argument to the factory closure and registration name.
0222        ///
0223        /// - Parameters:
0224        ///   - serviceType: The service type to resolve.
0225        ///   - name:        The registration name.
0226        ///   - argument:   1 argument to pass to the factory closure.
0227        ///
0228        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0229        ///            1 argument and name is found in the `Container`.
0230        public func resolve
Container.Arguments.swift:218
        return resolve(serviceType, name: nil, argument: argument)
SynchronizedResolver.Arguments.swift:35
            return self.container.resolve(serviceType, name: name, argument: argument)<Service, Arg1>(
0231            serviceType: Service.Type,
0232            name: String?,
0233            argument: Arg1) -> Service?
0234        {
0235            typealias FactoryType = (ResolverType, Arg1) -> Service
0236            return resolveImpl(name) { (factory: FactoryType) in factory(self, argument) }
0237        }
0238    
0239        /// Retrieves the instance with the specified service type and tuple of 2 arguments to the factory closure.
0240        ///
0241        /// - Parameters:
0242        ///   - serviceType: The service type to resolve.
0243        ///   - arguments:   Tuple of 2 arguments to pass to the factory closure.
0244        ///
0245        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0246        ///            and tuple of 2 arguments is found in the `Container`.
0247        public func resolve
SynchronizedResolver.Arguments.swift:44
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2>(
0248            serviceType: Service.Type,
0249            arguments: (Arg1, Arg2)) -> Service?
0250        {
0251            return resolve(serviceType, name: nil, arguments: arguments)
0252        }
0253    
0254        /// Retrieves the instance with the specified service type, tuple of 2 arguments to the factory closure and registration name.
0255        ///
0256        /// - Parameters:
0257        ///   - serviceType: The service type to resolve.
0258        ///   - name:        The registration name.
0259        ///   - arguments:   Tuple of 2 arguments to pass to the factory closure.
0260        ///
0261        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0262        ///            tuple of 2 arguments and name is found in the `Container`.
0263        public func resolve
Container.Arguments.swift:251
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:54
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2>(
0264            serviceType: Service.Type,
0265            name: String?,
0266            arguments: (Arg1, Arg2)) -> Service?
0267        {
0268            typealias FactoryType = (ResolverType, Arg1, Arg2) -> Service
0269            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments.) }
0270        }
0271    
0272        /// Retrieves the instance with the specified service type and tuple of 3 arguments to the factory closure.
0273        ///
0274        /// - Parameters:
0275        ///   - serviceType: The service type to resolve.
0276        ///   - arguments:   Tuple of 3 arguments to pass to the factory closure.
0277        ///
0278        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0279        ///            and tuple of 3 arguments is found in the `Container`.
0280        public func resolve
SynchronizedResolver.Arguments.swift:63
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2, Arg3>(
0281            serviceType: Service.Type,
0282            arguments: (Arg1, Arg2, Arg3)) -> Service?
0283        {
0284            return resolve(serviceType, name: nil, arguments: arguments)
0285        }
0286    
0287        /// Retrieves the instance with the specified service type, tuple of 3 arguments to the factory closure and registration name.
0288        ///
0289        /// - Parameters:
0290        ///   - serviceType: The service type to resolve.
0291        ///   - name:        The registration name.
0292        ///   - arguments:   Tuple of 3 arguments to pass to the factory closure.
0293        ///
0294        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0295        ///            tuple of 3 arguments and name is found in the `Container`.
0296        public func resolve
Container.Arguments.swift:284
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:73
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2, Arg3>(
0297            serviceType: Service.Type,
0298            name: String?,
0299            arguments: (Arg1, Arg2, Arg3)) -> Service?
0300        {
0301            typealias FactoryType = (ResolverType, Arg1, Arg2, Arg3) -> Service
0302            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments., arguments.) }
0303        }
0304    
0305        /// Retrieves the instance with the specified service type and tuple of 4 arguments to the factory closure.
0306        ///
0307        /// - Parameters:
0308        ///   - serviceType: The service type to resolve.
0309        ///   - arguments:   Tuple of 4 arguments to pass to the factory closure.
0310        ///
0311        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0312        ///            and tuple of 4 arguments is found in the `Container`.
0313        public func resolve
SynchronizedResolver.Arguments.swift:82
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4>(
0314            serviceType: Service.Type,
0315            arguments: (Arg1, Arg2, Arg3, Arg4)) -> Service?
0316        {
0317            return resolve(serviceType, name: nil, arguments: arguments)
0318        }
0319    
0320        /// Retrieves the instance with the specified service type, tuple of 4 arguments to the factory closure and registration name.
0321        ///
0322        /// - Parameters:
0323        ///   - serviceType: The service type to resolve.
0324        ///   - name:        The registration name.
0325        ///   - arguments:   Tuple of 4 arguments to pass to the factory closure.
0326        ///
0327        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0328        ///            tuple of 4 arguments and name is found in the `Container`.
0329        public func resolve
Container.Arguments.swift:317
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:92
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4>(
0330            serviceType: Service.Type,
0331            name: String?,
0332            arguments: (Arg1, Arg2, Arg3, Arg4)) -> Service?
0333        {
0334            typealias FactoryType = (ResolverType, Arg1, Arg2, Arg3, Arg4) -> Service
0335            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments., arguments., arguments.) }
0336        }
0337    
0338        /// Retrieves the instance with the specified service type and tuple of 5 arguments to the factory closure.
0339        ///
0340        /// - Parameters:
0341        ///   - serviceType: The service type to resolve.
0342        ///   - arguments:   Tuple of 5 arguments to pass to the factory closure.
0343        ///
0344        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0345        ///            and tuple of 5 arguments is found in the `Container`.
0346        public func resolve
SynchronizedResolver.Arguments.swift:101
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5>(
0347            serviceType: Service.Type,
0348            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5)) -> Service?
0349        {
0350            return resolve(serviceType, name: nil, arguments: arguments)
0351        }
0352    
0353        /// Retrieves the instance with the specified service type, tuple of 5 arguments to the factory closure and registration name.
0354        ///
0355        /// - Parameters:
0356        ///   - serviceType: The service type to resolve.
0357        ///   - name:        The registration name.
0358        ///   - arguments:   Tuple of 5 arguments to pass to the factory closure.
0359        ///
0360        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0361        ///            tuple of 5 arguments and name is found in the `Container`.
0362        public func resolve
Container.Arguments.swift:350
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:111
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5>(
0363            serviceType: Service.Type,
0364            name: String?,
0365            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5)) -> Service?
0366        {
0367            typealias FactoryType = (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5) -> Service
0368            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments., arguments., arguments., arguments.) }
0369        }
0370    
0371        /// Retrieves the instance with the specified service type and tuple of 6 arguments to the factory closure.
0372        ///
0373        /// - Parameters:
0374        ///   - serviceType: The service type to resolve.
0375        ///   - arguments:   Tuple of 6 arguments to pass to the factory closure.
0376        ///
0377        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0378        ///            and tuple of 6 arguments is found in the `Container`.
0379        public func resolve
SynchronizedResolver.Arguments.swift:120
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(
0380            serviceType: Service.Type,
0381            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)) -> Service?
0382        {
0383            return resolve(serviceType, name: nil, arguments: arguments)
0384        }
0385    
0386        /// Retrieves the instance with the specified service type, tuple of 6 arguments to the factory closure and registration name.
0387        ///
0388        /// - Parameters:
0389        ///   - serviceType: The service type to resolve.
0390        ///   - name:        The registration name.
0391        ///   - arguments:   Tuple of 6 arguments to pass to the factory closure.
0392        ///
0393        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0394        ///            tuple of 6 arguments and name is found in the `Container`.
0395        public func resolve
Container.Arguments.swift:383
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:130
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(
0396            serviceType: Service.Type,
0397            name: String?,
0398            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)) -> Service?
0399        {
0400            typealias FactoryType = (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) -> Service
0401            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments., arguments., arguments., arguments., arguments.) }
0402        }
0403    
0404        /// Retrieves the instance with the specified service type and tuple of 7 arguments to the factory closure.
0405        ///
0406        /// - Parameters:
0407        ///   - serviceType: The service type to resolve.
0408        ///   - arguments:   Tuple of 7 arguments to pass to the factory closure.
0409        ///
0410        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0411        ///            and tuple of 7 arguments is found in the `Container`.
0412        public func resolve
SynchronizedResolver.Arguments.swift:139
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(
0413            serviceType: Service.Type,
0414            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)) -> Service?
0415        {
0416            return resolve(serviceType, name: nil, arguments: arguments)
0417        }
0418    
0419        /// Retrieves the instance with the specified service type, tuple of 7 arguments to the factory closure and registration name.
0420        ///
0421        /// - Parameters:
0422        ///   - serviceType: The service type to resolve.
0423        ///   - name:        The registration name.
0424        ///   - arguments:   Tuple of 7 arguments to pass to the factory closure.
0425        ///
0426        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0427        ///            tuple of 7 arguments and name is found in the `Container`.
0428        public func resolve
Container.Arguments.swift:416
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:149
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(
0429            serviceType: Service.Type,
0430            name: String?,
0431            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)) -> Service?
0432        {
0433            typealias FactoryType = (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) -> Service
0434            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments., arguments., arguments., arguments., arguments., arguments.) }
0435        }
0436    
0437        /// Retrieves the instance with the specified service type and tuple of 8 arguments to the factory closure.
0438        ///
0439        /// - Parameters:
0440        ///   - serviceType: The service type to resolve.
0441        ///   - arguments:   Tuple of 8 arguments to pass to the factory closure.
0442        ///
0443        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0444        ///            and tuple of 8 arguments is found in the `Container`.
0445        public func resolve
SynchronizedResolver.Arguments.swift:158
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8>(
0446            serviceType: Service.Type,
0447            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)) -> Service?
0448        {
0449            return resolve(serviceType, name: nil, arguments: arguments)
0450        }
0451    
0452        /// Retrieves the instance with the specified service type, tuple of 8 arguments to the factory closure and registration name.
0453        ///
0454        /// - Parameters:
0455        ///   - serviceType: The service type to resolve.
0456        ///   - name:        The registration name.
0457        ///   - arguments:   Tuple of 8 arguments to pass to the factory closure.
0458        ///
0459        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0460        ///            tuple of 8 arguments and name is found in the `Container`.
0461        public func resolve
Container.Arguments.swift:449
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:168
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8>(
0462            serviceType: Service.Type,
0463            name: String?,
0464            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)) -> Service?
0465        {
0466            typealias FactoryType = (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) -> Service
0467            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments., arguments., arguments., arguments., arguments., arguments., arguments.) }
0468        }
0469    
0470        /// Retrieves the instance with the specified service type and tuple of 9 arguments to the factory closure.
0471        ///
0472        /// - Parameters:
0473        ///   - serviceType: The service type to resolve.
0474        ///   - arguments:   Tuple of 9 arguments to pass to the factory closure.
0475        ///
0476        /// - Returns: The resolved service type instance, or nil if no registration for the service type
0477        ///            and tuple of 9 arguments is found in the `Container`.
0478        public func resolve
SynchronizedResolver.Arguments.swift:177
            return self.container.resolve(serviceType, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9>(
0479            serviceType: Service.Type,
0480            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)) -> Service?
0481        {
0482            return resolve(serviceType, name: nil, arguments: arguments)
0483        }
0484    
0485        /// Retrieves the instance with the specified service type, tuple of 9 arguments to the factory closure and registration name.
0486        ///
0487        /// - Parameters:
0488        ///   - serviceType: The service type to resolve.
0489        ///   - name:        The registration name.
0490        ///   - arguments:   Tuple of 9 arguments to pass to the factory closure.
0491        ///
0492        /// - Returns: The resolved service type instance, or nil if no registration for the service type,
0493        ///            tuple of 9 arguments and name is found in the `Container`.
0494        public func resolve
Container.Arguments.swift:482
        return resolve(serviceType, name: nil, arguments: arguments)
SynchronizedResolver.Arguments.swift:187
            return self.container.resolve(serviceType, name: name, arguments: arguments)<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9>(
0495            serviceType: Service.Type,
0496            name: String?,
0497            arguments: (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)) -> Service?
0498        {
0499            typealias FactoryType = (ResolverType, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9) -> Service
0500            return resolveImpl(name) { (factory: FactoryType) in factory(self, arguments., arguments., arguments., arguments., arguments., arguments., arguments., arguments., arguments.) }
0501        }
0502    
0503    }
0504