Creates a new {@code ServiceBuilder} for the given service interface
type.

@param serviceType the service interface type
@return the newly created builder
347953
public static <C, T extends Service<C>> ServiceBuilder<C, T> forService(
            Class<T> serviceType) {

        if (serviceType == null) {
            throw new NullPointerException("serviceType");
        }

        V1ServiceInterface v1annotation =
                serviceType.getAnnotation(V1ServiceInterface.class);

        if (v1annotation != null) {
            return new ServiceBuilder<>(
                    new V1ServiceFactory<>(serviceType, v1annotation));
        }

        CustomServiceInterface customAnnotation =
                serviceType.getAnnotation(CustomServiceInterface.class);

        if (customAnnotation != null) {
            return new ServiceBuilder<>(
                    new CustomServiceFactory<>(serviceType, customAnnotation));
        }

        throw new IllegalArgumentException(
                "Service interfaces must be decorated with an "
                + "@[Type]ServiceInterface annotation.");
    }
405904
@Nonnull
	public static <R> LBiDblFunctionBuilder<R> biDblFunction(Consumer<LBiDblFunction<R>> consumer) {
		return new LBiDblFunctionBuilder(consumer);
	}
1337997
public static <B extends ProcessBuilder> QueueBuilder<B> newQueueBuilder(Class<B> process_builder_class)
    {
        return new QueueBuilder<B>(ROOT_QUEUE, process_builder_class);
    }
116783
public <T> JdbcMapperBuilder<T> newBuilder(final Class<T> target) {
		return newBuilder((Type)target);
	}
258177
@Nonnull
	public static <T1, T2, R> LBiObjBoolFunction<T1, T2, R> biObjBoolFunctionFrom(Consumer<LBiObjBoolFunctionBuilder<T1, T2, R>> buildingFunction) {
		LBiObjBoolFunctionBuilder builder = new LBiObjBoolFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
706221
@Nonnull
	public static <T1, T2> LToSrtBiFunctionBuilder<T1, T2> toSrtBiFunction(Consumer<LToSrtBiFunction<T1, T2>> consumer) {
		return new LToSrtBiFunctionBuilder(consumer);
	}
78115
@Override
  public <T> ServiceRef.ServiceBuilder service(Class<T> serviceClass)
  {
    Objects.requireNonNull(serviceClass);

    validator().serviceClass(serviceClass);

    Key<?> key = Key.of(serviceClass, ServiceImpl.class);

    ServiceBuilderWebImpl service
      = new ServiceBuilderWebImpl(this, key, serviceClass);

    _includes.add(service);

    return service;
  }
476673
@Override
  public ServiceBuilderAmp service(Key<?> key, Class<?> api)
  {
    Objects.requireNonNull(api);
    
    //return newService().service(key, api);
    //throw new UnsupportedOperationException();
    return new ServiceBuilderImpl(this, api, key);
  }
1123388
public static <T extends Annotation> T create(Class<T> annotationType) {
    return new Builder<T>(annotationType).create();
  }
1310810
public function createService($serviceType)
    {
        $class = sprintf('%s\services\%s', __NAMESPACE__, ucwords($serviceType));
        if (class_exists($class)) {
            $handler = new $class($this);
            return $handler;
        } else {
            throw new Exception("Unknown service: $serviceType");
        }
    }
772455
@Override
    public <T> PluggableProviderService<T> createPluginService(Class<T> type, final String serviceName) {
        //load provider service implementation via java ServiceLoader if available
        PluggableProviderService<T> pluginProviderService = ServiceTypes.getPluginProviderService(type, serviceName, this);
        if (null != pluginProviderService) {
            return pluginProviderService;
        }

        //otherwise construct default service implementation
        BasePluginProviderService<T> basePluginProviderService = new BasePluginProviderService<T>(
                serviceName,
                type
        );
        basePluginProviderService.setRundeckServerServiceProviderLoader(this);
        return basePluginProviderService;
    }
318444
public ParamConfigBuilder newParamConfig(Class<?> type, Type genericType){
        return paramConfigBuilderFactory.newInstance(type, genericType);
    }
123455
public BuildableType.Builder partialToBuilder(PartialToBuilderMethod partialToBuilder) {
    this.partialToBuilder = Objects.requireNonNull(partialToBuilder);
    _unsetProperties.remove(Property.PARTIAL_TO_BUILDER);
    return (BuildableType.Builder) this;
  }
862207
@SuppressWarnings("unchecked")
  private static <T> T newInstance(Class<?> type) {
    try {
      return (T) type.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
      throw new ServiceException("Cannot instantiate service class " + type, e);
    }
  }
1017071
public BuildableType.Builder builderFactory(BuilderFactory builderFactory) {
    this.builderFactory = Objects.requireNonNull(builderFactory);
    _unsetProperties.remove(Property.BUILDER_FACTORY);
    return (BuildableType.Builder) this;
  }
578662
public static RequestOptions.RequestOptionsBuilder builder(
            @Nullable String publishableApiKey,
            @NonNull @RequestType String requestType) {
        return new RequestOptions.RequestOptionsBuilder(
                publishableApiKey,
                requestType);
    }
1363438
@Override
    public Builder<K, V> toBuilder() {
        return new Builder<K, V>(metadata, key, value);
    }