Build a raw pipeline without a terminating transformer. It is the caller's responsibility to set the final transformer (@see JsonTransformer.setTarget()) and to apply the pipeline to a stream.
@return
336170
public JsonTransformer build() {
		try {
			return new WrappingTransformer(buildPipe());
		} catch(Exception e) {
			throw new RuntimeException("Failed to build pipeline: " + e.getMessage(), e);
		}
	}
650519
protected T build() {
        if (encoder != null) {
            assert decoder != null;
            return buildFromCodec(decoder, encoder);
        }

        Http2Connection connection = this.connection;
        if (connection == null) {
            connection = new DefaultHttp2Connection(isServer(), maxReservedStreams());
        }

        return buildFromConnection(connection);
    }
625634
public Object next()
  {
    if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "next");
    
    StreamSet sourceStreamSet = (StreamSet)super.next();
    SIMPPtoPOutboundTransmitControllable sourceStreamSetControl = 
      (SIMPPtoPOutboundTransmitControllable)sourceStreamSet.getControlAdapter();
    if(sourceStreamSetControl != null)
    {
      ((SourceStreamSetControl)sourceStreamSetControl).setSourceStreamManager(sourceStreamMgr);
    }
    
    if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "next", sourceStreamSetControl);
    return sourceStreamSetControl;
  }
705096
public T build() {
        C clientObject = client;
        if (clientObject == null) {
            clientObject = createClient();
        }

        return factory.create(clientObject);
    }
396838
@Nonnull
	public final LCharSupplier build() {

		final LCharSupplier eventuallyFinal = this.eventually;

		LCharSupplier retval;

		final Case<LBoolSupplier, LCharSupplier>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LCharSupplier.charSup(() -> {
			try {
				for (Case<LBoolSupplier, LCharSupplier> aCase : casesArray) {
					if (aCase.casePredicate().getAsBool()) {
						return aCase.caseFunction().getAsChar();
					}
				}

				return eventuallyFinal.getAsChar();
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
759754
public Config build() {
    if (this.language == null) {
      this.language = "java";
    }
    if (this.endpoint == null) {
      this.endpoint = SyncSender.DEFAULT_API_ENDPOINT;
    }
    if (this.notifier == null) {
      this.notifier = new NotifierProvider();
    }
    if (this.sender == null) {
      SyncSender.Builder innerSender =
          new SyncSender.Builder(this.endpoint)
          .accessToken(accessToken)
          .proxy(proxy);
      if (this.jsonSerializer != null) {
        innerSender.jsonSerializer(this.jsonSerializer);
      }
      this.sender =
        new BufferedSender.Builder().sender(innerSender.build()).build();
    }
    if (this.timestamp == null) {
      this.timestamp = new TimestampProvider();
    }

    return new ConfigImpl(this);
  }
1149572
public TargetProtocolItemStream getTargetProtocolItemStream()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
    {
      SibTr.entry(tc, "getTargetProtocolItemStream");
      SibTr.exit(tc, "getTargetProtocolItemStream", _targetProtocolItemStream);	
    }
    return _targetProtocolItemStream;
  }
892229
@Nonnull
	public final LByteSupplier build() {

		final LByteSupplier eventuallyFinal = this.eventually;

		LByteSupplier retval;

		final Case<LBoolSupplier, LByteSupplier>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LByteSupplier.byteSup(() -> {
			try {
				for (Case<LBoolSupplier, LByteSupplier> aCase : casesArray) {
					if (aCase.casePredicate().getAsBool()) {
						return aCase.caseFunction().getAsByte();
					}
				}

				return eventuallyFinal.getAsByte();
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
694290
public static StdoutStream create()
  {
    if (_stdout == null) {
      _stdout = new StdoutStream();
      ConstPath path = new ConstPath(null, _stdout);
      path.setScheme("stdout");
      //_stdout.setPath(path);
    }

    return _stdout;
  }
1182858
public AbstractProject getBuildingDownstream() {
        Set<Task> unblockedTasks = Jenkins.getInstance().getQueue().getUnblockedTasks();

        for (AbstractProject tup : getTransitiveDownstreamProjects()) {
			if (tup!=this && (tup.isBuilding() || unblockedTasks.contains(tup)))
                return tup;
        }
        return null;
    }
1018173
public OAuthFlow build() {
        if(httpClient == null){
            httpClient = new DefaultHttpClient();
        }

        if(tokenURL == null){
            tokenURL = DEFAULT_TOKEN_URL;
        }

        if(authorizationURL == null){
            authorizationURL = DEFAULT_AUTHORIZATION_URL;
        }

        if(jsonSerializer == null){
            jsonSerializer = new JacksonJsonSerializer();
        }

        if(clientId == null || clientSecret == null || redirectURL == null){
            throw new IllegalStateException();
        }

        return new OAuthFlowImpl(clientId, clientSecret, redirectURL, authorizationURL, tokenURL, httpClient,
                jsonSerializer);
    }
892557
public JwkProvider build() {
        JwkProvider urlProvider = new UrlJwkProvider(url);
        if (this.rateLimited) {
            urlProvider = new RateLimitedJwkProvider(urlProvider, bucket);
        }
        if (this.cached) {
            urlProvider = new GuavaCachedJwkProvider(urlProvider, cacheSize, expiresIn, expiresUnit);
        }
        return urlProvider;
    }
911422
public static <T> Observable.Transformer<T,ImmutableSet<T>> toImmutableSet() {
        return new Observable.Transformer<T, ImmutableSet<T>>() {
            @Override
            public Observable<ImmutableSet<T>> call(Observable<T> source) {
                return source.collect(new Func0<ImmutableSet.Builder<T>>() {
                    @Override
                    public ImmutableSet.Builder<T> call() {
                        return ImmutableSet.builder();
                    }
                }, new Action2<ImmutableSet.Builder<T>, T>() {
                    @Override
                    public void call(ImmutableSet.Builder<T> builder, T t) {
                        builder.add(t);
                    }
                })
                .map(new Func1<ImmutableSet.Builder<T>, ImmutableSet<T>>() {
                    @Override
                    public ImmutableSet<T> call(ImmutableSet.Builder<T> builder) {
                        return builder.build();
                    }
                });
            }
        };
    }
459468
@Nonnull
	public final LSrtSupplier build() {

		final LSrtSupplier eventuallyFinal = this.eventually;

		LSrtSupplier retval;

		final Case<LBoolSupplier, LSrtSupplier>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LSrtSupplier.srtSup(() -> {
			try {
				for (Case<LBoolSupplier, LSrtSupplier> aCase : casesArray) {
					if (aCase.casePredicate().getAsBool()) {
						return aCase.caseFunction().getAsSrt();
					}
				}

				return eventuallyFinal.getAsSrt();
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
401213
public final T build() {
    getParser().parseImpl(this);
    // There was a gap in the parameters if either:
    // 1) the mask had a gap, e.g. ..00110111
    // 2) there were more than 32 parameters and the mask wasn't full.
    // Gaps above the 32nd parameter are not detected.
    if ((pmask & (pmask + 1)) != 0 || (maxIndex > 31 && pmask != -1)) {
      int firstMissing = Integer.numberOfTrailingZeros(~pmask);
      throw ParseException.generic(
          String.format("unreferenced arguments [first missing index=%d]", firstMissing),
          getMessage());
    }
    return buildImpl();
  }
204143
private TargetStream createStream(StreamSet streamSet,
                              int priority,
                              Reliability reliability) throws SIResourceException

  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "createStream",
        new Object[] { streamSet, Integer.valueOf(priority), reliability });

    TargetStream stream = null;

    if(reliability.compareTo(Reliability.BEST_EFFORT_NONPERSISTENT) <= 0)
    {
      stream = new ExpressTargetStream(deliverer,
        streamSet.getRemoteMEUuid(), streamSet.getStreamID());
    }
    else
    {
      //Warning - this assumes that ASSURED is always the highest Reliability
      //and that UNKNOWN is always the lowest (0).
      stream = new GuaranteedTargetStream(
                        deliverer,
                        upControl,
                        am,
                        streamSet,
                        priority, //priority
                        reliability, //reliability
                        new ArrayList(),
                        messageProcessor);
    }

    streamSet.setStream(priority, reliability, stream);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createStream", stream);

    return stream;
  }
918237
protected T build() {
        final T instance;
        try {
            instance = build(connection(), maxContentLength(),
                                     isValidateHttpHeaders(), isPropagateSettings());
        } catch (Throwable t) {
            throw new IllegalStateException("failed to create a new InboundHttp2ToHttpAdapter", t);
        }
        connection.addListener(instance);
        return instance;
    }