Return a new instance of {@code {@link BeadledomWebTarget}} with the given UriBuilder path by
using the default builder implementation on the classpath found using SPI.
182539
public BeadledomWebTarget buildTarget(UriBuilder baseUrl) {
    BeadledomClient beadledomClient = build();
    return beadledomClient.target(baseUrl);
  }
844241
public ISarlClassBuilder addSarlClass(String name) {
		ISarlClassBuilder builder = this.iSarlClassBuilderProvider.get();
		builder.eInit(getSarlBehavior(), name, getTypeResolutionContext());
		return builder;
	}
877611
@Override
    public T addAsWebInfResource(final URL resource, final String target) throws IllegalArgumentException {
        Validate.notNull(resource, "Resource should be specified");
        Validate.notNullOrEmpty(target, "Target should be specified");

        return addAsWebInfResource(new UrlAsset(resource), target);
    }
3270
public Builder newBuilder(String link) {
        Builder builder = new Builder();
        Builder.ParseResult result = builder.parse(this, link);
        return result == Builder.ParseResult.SUCCESS ? builder : null;
    }
239990
public static Builder newBuilder(String projectId, String datasetId) {
    return newBuilder(DatasetId.of(projectId, datasetId));
  }
1150106
public Builder newBuilder() {
        return new Builder()
                .name(name)
                .addColumn(columns)
                .addFk(fks)
                .pkFields(pkFields)
                .addIndexes(indexes);
    }
169339
public static Builder newBuilder(String bucket, String name) {
    return newBuilder(BlobId.of(bucket, name));
  }
570219
public UrlBuilder addPath(String path) {
		if (path.charAt(0) == '/' && baseUrl.endsWith("/")) {
			baseUrl = baseUrl + path.substring(1);
		} else {
			baseUrl = baseUrl + path;
		}
		return this;
	}
885402
public static<T> ServiceInstanceBuilder<T>builder() throws Exception
    {
        String                  address = null;
        Collection<InetAddress> ips = ServiceInstanceBuilder.getAllLocalIPs();
        if ( ips.size() > 0 )
        {
            address = ips.iterator().next().getHostAddress();   // default to the first address
        }

        String                  id = UUID.randomUUID().toString();

        return new ServiceInstanceBuilder<T>().address(address).id(id).registrationTimeUTC(System.currentTimeMillis());
    }
1150175
@Override
    public WebTarget target(UriBuilder builder) {
        checkClosed();
        WebTargetImpl wt = (WebTargetImpl) super.target(builder);

        //construct our own webclient
        JAXRSClientFactoryBean bean = new JAXRSClientFactoryBean();
        URI uri = builder.build();
        bean.setAddress(uri.toString());
        WebClient targetClient = bean.createWebClient();

        //get ClientCongfiguration
        ClientConfiguration ccfg = WebClient.getConfig(targetClient);

        //add Liberty Jax-RS Client Config Interceptor to configure things like KeepAlive, timeouts, etc.
        ccfg.getOutInterceptors().add(new LibertyJaxRsClientConfigInterceptor(Phase.PRE_LOGICAL));

        //add Liberty Jax-RS Client Proxy Interceptor to configure the proxy
        ccfg.getOutInterceptors().add(new LibertyJaxRsClientProxyInterceptor(Phase.PRE_LOGICAL));

        //add Liberty Ltpa handler Interceptor to check if is using ltpa token for sso
        ccfg.getOutInterceptors().add(new LibertyJaxRsClientLtpaInterceptor());

        //add Liberty Jax-RS OAuth Interceptor to check whether it has to propagate OAuth/access token
        ccfg.getOutInterceptors().add(new LibertyJaxRsClientOAuthInterceptor());

        //add  Interceptor to check whether it has to propagate SAML token for sso
        ccfg.getOutInterceptors().add(new PropagationHandler());

        /**
         * if no any user programmed SSL context info
         * put the LibertyJaxRsClientSSLOutInterceptor into client OUT interceptor chain
         * see if Liberty SSL can help
         */
        if (hasSSLConfigInfo == false) {
            LibertyJaxRsClientSSLOutInterceptor sslOutInterceptor = new LibertyJaxRsClientSSLOutInterceptor(Phase.PRE_LOGICAL);
            sslOutInterceptor.setTLSConfiguration(secConfig);
            ccfg.getOutInterceptors().add(sslOutInterceptor);
        }
        //set bus
        LibertyApplicationBus bus;
        //202957 same url use same bus, add a lock to busCache to ensure only one bus will be created in concurrent mode.
        //ConcurrentHashMap can't ensure that.
        String moduleName = getModuleName();
        String id = moduleName + uri.getHost() + "-" + uri.getPort();
        synchronized (busCache) {
            bus = busCache.get(id);
            if (bus == null) {
                bus = LibertyJAXRSClientBusFactory.getInstance().getClientScopeBus(id);
                busCache.put(id, bus);
            }
        }

        ccfg.setBus(bus);

        //add the root WebTarget to managed set so we can close it's associated WebClient
        synchronized (baseClients) {
            baseClients.add(targetClient);
        }

        return new WebTargetImpl(wt.getUriBuilder(), wt.getConfiguration(), targetClient);
    }
1347944
@Override
    public T addAsWebResource(URL resource, String target) throws IllegalArgumentException {
        Validate.notNull(resource, "Resource should be specified");
        Validate.notNull(target, "Target should be specified");

        return addAsWebResource(new UrlAsset(resource), target);
    }
440745
public static HttpFileServiceBuilder forClassPath(ClassLoader classLoader, String rootDir) {
        return forVfs(HttpVfs.ofClassPath(classLoader, rootDir));
    }
1281926
@CheckReturnValue
  public static <ReqT, RespT> Builder<ReqT, RespT> newBuilder(
      Marshaller<ReqT> requestMarshaller, Marshaller<RespT> responseMarshaller) {
    return new Builder<ReqT, RespT>()
        .setRequestMarshaller(requestMarshaller)
        .setResponseMarshaller(responseMarshaller);
  }
189276
public static SearchArgumentFactory.Builder newBuilder() {
    org.apache.hadoop.hive.ql.io.sarg.SearchArgument.Builder internalBuilder = org.apache.hadoop.hive.ql.io.sarg.SearchArgumentFactory
        .newBuilder();
    return new Builder(internalBuilder);
  }
659411
public static HttpHubConnectionBuilder create(String url) {
        if (url == null || url.isEmpty()) {
            throw new IllegalArgumentException("A valid url is required.");
        }
        return new HttpHubConnectionBuilder(url);
    }
301454
public static DocumentBuilderFactory newInstance(String factoryClassName,
            ClassLoader classLoader) {
        if (factoryClassName == null) {
            throw new FactoryConfigurationError("factoryClassName == null");
        }
        if (classLoader == null) {
            classLoader = Thread.currentThread().getContextClassLoader();
        }
        try {
            Class<?> type = classLoader != null
                    ? classLoader.loadClass(factoryClassName)
                    : Class.forName(factoryClassName);
            return (DocumentBuilderFactory) type.newInstance();
        } catch (ClassNotFoundException e) {
            throw new FactoryConfigurationError(e);
        } catch (InstantiationException e) {
            throw new FactoryConfigurationError(e);
        } catch (IllegalAccessException e) {
            throw new FactoryConfigurationError(e);
        }
    }
205418
public static ClientConfigurationBuilder builder(final String url, final String username, final String password) {
        return new ClientConfigurationBuilder(url, username, password);
    }