Builds the functional interface implementation and if previously provided calls the consumer.
975112
@Nonnull
	public final LBiCharFunction<R> build() {

		final LBiCharFunction<R> eventuallyFinal = this.eventually;

		LBiCharFunction<R> retval;

		final Case<LBiCharPredicate, LBiCharFunction<R>>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LBiCharFunction.<R> biCharFunc((a1, a2) -> {
			try {
				for (Case<LBiCharPredicate, LBiCharFunction<R>> aCase : casesArray) {
					if (aCase.casePredicate().test(a1, a2)) {
						return aCase.caseFunction().apply(a1, a2);
					}
				}

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

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
1251959
public function build()
    {
        $builder = OverrideBuilderFactory::create(
            $this->builder,
            $this->namingStrategy,
            $this->name,
            $this->callback
        );

        $builder->build();
    }
257305
@Nonnull
	public static <T> LOiToDblFunctionBuilder<T> oiToDblFunction(Consumer<LOiToDblFunction<T>> consumer) {
		return new LOiToDblFunctionBuilder(consumer);
	}
417132
def build(self):
        """"""
        if self.is_built():  # pragma: no cover
            return
        with _wait_signal(self.loadFinished, 20):
            self.rebuild()
        self._built = True
816466
function build() {
    // Start creating the body of the new Type constructor, first calling super()
    var _ret = buildIdentity.call(this);
    var typeId = _ret.typeId;
    var typeName = _ret.typeName;
    var body =
        '\tvar opts = options ? options : {};\n' +
        '\tthis.constructor.util._extend(this, opts.props);\n' +
        '\tthis.constructor.super_.call(this, opts.buffer, opts.offset' +
        (typeId ? '' : ', true') +
        ');\n';
    // Init fields
    body += _ret.body;
    body += buildSerialize.call(this);
    body += buildDeserialize.call(this);
    // Add to body all the read/write methods
    for (var i = 0; i < this._methods.length; i++) {
        body += this._methods[i];
    }
    if (logger.isDebugEnabled()) {
        logger.debug('Body for %s type constructor:', typeName);
        logger.debug('\n' + body);
    }
    return createConstructor(body, typeId, typeName);
}
378430
@Nonnull
	public static <T, R> LObjIntSrtFunctionBuilder<T, R> objIntSrtFunction(Consumer<LObjIntSrtFunction<T, R>> consumer) {
		return new LObjIntSrtFunctionBuilder(consumer);
	}
1326033
@Nonnull
	public static <R> LBiBoolFunctionBuilder<R> biBoolFunction(Consumer<LBiBoolFunction<R>> consumer) {
		return new LBiBoolFunctionBuilder(consumer);
	}
296993
@Nonnull
	public static <T1, T2, R> LBiObjLongFunctionBuilder<T1, T2, R> biObjLongFunction(Consumer<LBiObjLongFunction<T1, T2, R>> consumer) {
		return new LBiObjLongFunctionBuilder(consumer);
	}
888231
def build(self, builder):
        """"""
        params = dict(Value=self.value,
                      Status=self.status.value,
                      ProtocolDeviationRepeatKey=self.repeat_key
                      )

        if self.code:
            params['Code'] = self.code
        if self.pdclass:
            params['Class'] = self.pdclass
        if self.transaction_type:
            params['TransactionType'] = self.transaction_type
        builder.start('mdsol:ProtocolDeviation', params)
        builder.end('mdsol:ProtocolDeviation')
95200
@Nonnull
	public static <T1, T2> ToIntBiFunctionBuilder<T1, T2> toIntBiFunction(Consumer<ToIntBiFunction<T1, T2>> consumer) {
		return new ToIntBiFunctionBuilder(consumer);
	}
1216928
@Nonnull
	public final LTriBoolFunction<R> build() {

		final LTriBoolFunction<R> eventuallyFinal = this.eventually;

		LTriBoolFunction<R> retval;

		final Case<LLogicalTernaryOperator, LTriBoolFunction<R>>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LTriBoolFunction.<R> triBoolFunc((a1, a2, a3) -> {
			try {
				for (Case<LLogicalTernaryOperator, LTriBoolFunction<R>> aCase : casesArray) {
					if (aCase.casePredicate().apply(a1, a2, a3)) {
						return aCase.caseFunction().apply(a1, a2, a3);
					}
				}

				return eventuallyFinal.apply(a1, a2, a3);
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
639018
@Nonnull
	public static LFltToDblFunction fltToDblFunctionFrom(Consumer<LFltToDblFunctionBuilder> buildingFunction) {
		LFltToDblFunctionBuilder builder = new LFltToDblFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
1182126
@Nonnull
	public static <T1, T2> LBiObjFltConsumerBuilder<T1, T2> biObjFltConsumer(Consumer<LBiObjFltConsumer<T1, T2>> consumer) {
		return new LBiObjFltConsumerBuilder(consumer);
	}
841747
@Nonnull
	public static <T1, T2, T3> LToIntTriFunctionBuilder<T1, T2, T3> toIntTriFunction(Consumer<LToIntTriFunction<T1, T2, T3>> consumer) {
		return new LToIntTriFunctionBuilder(consumer);
	}
550462
@Nonnull
	public static <T1, T2> LToFltBiFunctionBuilder<T1, T2> toFltBiFunction(Consumer<LToFltBiFunction<T1, T2>> consumer) {
		return new LToFltBiFunctionBuilder(consumer);
	}
113171
public void buildForMerge() {
        Preconditions.checkState(!isBuilt, "Tree already built");
        root.mergeExistingAndProposed(items, targetInvoiceId);
        isBuilt = true;
        isMerged = true;
    }
935881
private function buildObjects(): void
    {
        //deep dependency level, start to array end for not use array_reverse
        for ($i = \count($this->tree) - 1; $i >= 0; $i--) {

            //class
            foreach ($this->tree[$i] as $class => $arguments) {

                //try to find object in class
                $object = $this->cache[$class] ?? null;

                //if object is not in cache and need arguments try to build
                if ($object === null && \count($arguments)) {

                    //build arguments
                    $args = $this->buildArguments($class, $arguments);

                    //store object with dependencies in cache
                    $this->cache[$class] = (new ReflectionClass($class))->newInstanceArgs($args);

                    continue;
                }

                if ($object === null) {

                    //store object in cache
                    $this->cache[$class] = (new ReflectionClass($class))->newInstance();
                }
            }
        }
    }