Builds the functional interface implementation and if previously provided calls the consumer.
164524
@Nonnull
	public final LLongSupplier build() {

		final LLongSupplier eventuallyFinal = this.eventually;

		LLongSupplier retval;

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

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

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
44649
def build(self, builder):
        
        builder.start("ReasonForChange", {})
        builder.data(self.reason)
        builder.end("ReasonForChange")
378430
@Nonnull
	public static <T, R> LObjIntSrtFunctionBuilder<T, R> objIntSrtFunction(Consumer<LObjIntSrtFunction<T, R>> consumer) {
		return new LObjIntSrtFunctionBuilder(consumer);
	}
104551
@Nonnull
	public static <T, R> FunctionBuilder<T, R> function(Consumer<Function<T, R>> consumer) {
		return new FunctionBuilder(consumer);
	}
415582
public function build()
    {
        $this->builder->addEmbedded(
            $this->relation,
            $this->embeddable,
            $this->columnPrefix
        );
    }
113171
public void buildForMerge() {
        Preconditions.checkState(!isBuilt, "Tree already built");
        root.mergeExistingAndProposed(items, targetInvoiceId);
        isBuilt = true;
        isMerged = true;
    }
296993
@Nonnull
	public static <T1, T2, R> LBiObjLongFunctionBuilder<T1, T2, R> biObjLongFunction(Consumer<LBiObjLongFunction<T1, T2, R>> consumer) {
		return new LBiObjLongFunctionBuilder(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;
	}
417132
def build(self):
        """"""
        if self.is_built():  # pragma: no cover
            return
        with _wait_signal(self.loadFinished, 20):
            self.rebuild()
        self._built = True
301385
View build() throws IOException {
        final Class<? extends T> proxyClass = generateProxyClass();
        if (proxyClass == null) {
            return null;
        }

        final Constructor<? extends T> constructor = getProxyClassConstructor(proxyClass);

        final View result;
        try {
            result = constructor.newInstance(CONSTRUCTOR_ARG_VALUES);
        } catch (InstantiationException e) {
            // Should not be thrown, generated class is not abstract.
            throw new AssertionError(e);
        } catch (IllegalAccessException e) {
            // Should not be thrown, the generated constructor is accessible.
            throw new AssertionError(e);
        } catch (InvocationTargetException e) {
            // Thrown when the base class constructor throws an exception.
            throw launderCause(e);
        }

        ((ViewProxy) result).setInterceptor(mInterceptor);
        return result;
    }
1009134
def build(self):
        """"""
        self.load_builtins()
        self.load_functions(self.tree)
        self.visit(self.tree)
83947
@Nonnull
	public final LFltSupplier build() {

		final LFltSupplier eventuallyFinal = this.eventually;

		LFltSupplier retval;

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

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

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
284524
@Nonnull
	public static <T1, T2, R> LBiObjDblFunctionBuilder<T1, T2, R> biObjDblFunction(Consumer<LBiObjDblFunction<T1, T2, R>> consumer) {
		return new LBiObjDblFunctionBuilder(consumer);
	}
282184
public CHDMinimalPerfectHashFunction<T> build() throws IOException {
			if (built) throw new IllegalStateException("This builder has been already used");
			built = true;
			if (transform == null) {
				if (chunkedHashStore != null) transform = chunkedHashStore.transform();
				else throw new IllegalArgumentException("You must specify a TransformationStrategy, either explicitly or via a given ChunkedHashStore");
			}
			return new CHDMinimalPerfectHashFunction<>(keys, transform, lambda, loadFactor, signatureWidth, tempDir, chunkedHashStore);
		}
195027
public TwoStepsGOV3Function<T> build() throws IOException {
			if (built) throw new IllegalStateException("This builder has been already used");
			built = true;
			if (transform == null) {
				if (chunkedHashStore != null) transform = chunkedHashStore.transform();
				else throw new IllegalArgumentException("You must specify a TransformationStrategy, either explicitly or via a given ChunkedHashStore");
			}
			return new TwoStepsGOV3Function<>(keys, transform, values, tempDir, chunkedHashStore);
		}
1126492
FunctionType buildAndRegister() {
    if (returnType == null) {
      provideDefaultReturnType();
      checkNotNull(returnType);
    }

    if (parametersNode == null) {
      throw new IllegalStateException(
          "All Function types must have params and a return type");
    }

    FunctionType fnType;
    if (isConstructor) {
      fnType = getOrCreateConstructor();
    } else if (isInterface) {
      fnType = getOrCreateInterface();
    } else {
      fnType =
          FunctionType.builder(typeRegistry)
              .withName(fnName)
              .withSourceNode(contents.getSourceNode())
              .withParamsNode(parametersNode)
              .withReturnType(returnType, returnTypeInferred)
              .withTypeOfThis(thisType)
              .withTemplateKeys(templateTypeNames)
              .withIsAbstract(isAbstract)
              .withClosurePrimitiveId(closurePrimitiveId)
              .build();
      maybeSetBaseType(fnType);
    }

    if (implementedInterfaces != null && fnType.isConstructor()) {
      fnType.setImplementedInterfaces(implementedInterfaces);
    }

    if (extendedInterfaces != null) {
      fnType.setExtendedInterfaces(extendedInterfaces);
    }

    if (isRecord) {
      fnType.setImplicitMatch(true);
    }

    return fnType;
  }
167883
@Override
    public T build() {
        return build(new ProxyCreatedCallback<T>() {

            @Override
            public void onProxyCreationFinished(T result) {
                logger.trace("proxy created: interface: {} domains: {}", interfaceName, domains);
            }

            @Override
            public void onProxyCreationError(JoynrRuntimeException error) {
                logger.error("error creating proxy: interface: {} domains: {}, error: {}",
                             interfaceName,
                             domains,
                             error.getMessage());
            }
        });
    }