{@inheritDoc}
@see \rocket\ei\component\prop\GuiEiPropFork::buildGuiPropFork()
554879
public function buildGuiProp(Eiu $eiu): ?GuiProp {
		if (!$this->isMandatory()) {
			return new EmbeddedGuiProp($this);
		}
		
		$eiu->engine()->onNewEntryGui(function (Eiu $eiu) {
			$value = $eiu->entry()->getValue($this);
			
			if ($value !== null) return;
			
			$eiu->entryGui()->onSave(function () use ($eiu) {
				$eiu->entry()->setValue($this, $eiu->entry()->fieldMap($this));
			});
		});
		
		return null;
	}
274602
public function build()
    {
        $config = $this->classMetadata->getExtension(Fluent::EXTENSION_NAME);

        $config['loggable'] = true;
        $config['versioned'] = array_unique(array_merge(
            isset($config['versioned']) ? $config['versioned'] : [],
            [
                $this->fieldName,
            ]
        ));

        $this->classMetadata->addExtension(Fluent::EXTENSION_NAME, $config);
    }
246536
public function build(ContainerBuilder $container)
    {
        parent::build($container);

        $container->addCompilerPass(
            new DependencyInjection\Compiler\EventPropagationPass(),
            PassConfig::TYPE_BEFORE_OPTIMIZATION
        );
    }
1179637
public function build(array $parameters = array())
    {
        if (!isset($this->config['framework'])) {
            $this->config['framework'] = array();
        }

        // Core parameters set by PPI\Framework\App
        $parametersBag = new ParameterBag($parameters);
        $parametersBag->resolve();
        $this->setService('ApplicationParameters', $parametersBag);

        // Settings provided by the application itself on App boot, config provided by modules is not included
        $this->setService('ApplicationConfig', $parametersBag->resolveArray($this->config));

        if (false === $this->has('Logger')) {
            $this->setService('Logger', new NullLogger());
        }

        foreach (array(
            new Config\SessionConfig(),
            new Config\TemplatingConfig(),
        ) as $serviceConfig) {
            $serviceConfig->configureServiceManager($this);
        }

        return $this;
    }
222422
private function build() {
        $this->getObject()->addUse('Bullhorn\FastRest\Api\Models\ApiInterface as ModelInterface');
        $this->getObject()->setName(ucfirst(strtolower($this->getClassName())) . 'Controller');
        $this->getObject()->setNamespace($this->getConfiguration()->getRootNamespace() . '\Controllers');
        $this->getObject()->setExtends('ControllerBase');
        $this->buildFactory();
        $this->buildIndexAction();
        $this->buildShowAction();
        $this->buildCreateAction();
        $this->buildUpdateAction();
        $this->buildDeleteAction();
        $this->buildDocumentation();
    }
621660
protected function build(OutputInterface $output)
    {
        $this->command->run($this->input, $output);

        $this->lastBuild = new DateTime();
    }
104650
public function build(): SetInspectModeRequest
	{
		$instance = new SetInspectModeRequest();
		if ($this->mode === null) {
			throw new BuilderException('Property [mode] is required.');
		}
		$instance->mode = $this->mode;
		$instance->highlightConfig = $this->highlightConfig;
		return $instance;
	}
580311
public function build(): EmulateTouchFromMouseEventRequest
	{
		$instance = new EmulateTouchFromMouseEventRequest();
		if ($this->type === null) {
			throw new BuilderException('Property [type] is required.');
		}
		$instance->type = $this->type;
		if ($this->x === null) {
			throw new BuilderException('Property [x] is required.');
		}
		$instance->x = $this->x;
		if ($this->y === null) {
			throw new BuilderException('Property [y] is required.');
		}
		$instance->y = $this->y;
		if ($this->button === null) {
			throw new BuilderException('Property [button] is required.');
		}
		$instance->button = $this->button;
		$instance->timestamp = $this->timestamp;
		$instance->deltaX = $this->deltaX;
		$instance->deltaY = $this->deltaY;
		$instance->modifiers = $this->modifiers;
		$instance->clickCount = $this->clickCount;
		return $instance;
	}
9941
public function build(): DispatchMouseEventRequest
	{
		$instance = new DispatchMouseEventRequest();
		if ($this->type === null) {
			throw new BuilderException('Property [type] is required.');
		}
		$instance->type = $this->type;
		if ($this->x === null) {
			throw new BuilderException('Property [x] is required.');
		}
		$instance->x = $this->x;
		if ($this->y === null) {
			throw new BuilderException('Property [y] is required.');
		}
		$instance->y = $this->y;
		$instance->modifiers = $this->modifiers;
		$instance->timestamp = $this->timestamp;
		$instance->button = $this->button;
		$instance->buttons = $this->buttons;
		$instance->clickCount = $this->clickCount;
		$instance->deltaX = $this->deltaX;
		$instance->deltaY = $this->deltaY;
		$instance->pointerType = $this->pointerType;
		return $instance;
	}
1361271
public function buildContainer(
        ExtensionInterface $extension = null,
        array $config = [],
        array $parameters = [],
        array $compilerPasses = []
    ) {
        $container = new ContainerBuilder();
        if ($extension !== null) {
            $extension->setConfigDirectories($this->configDirectories);
            $extension->buildContainer($container, $config);
        }
        foreach ($parameters as $key => $value) {
            $container->setParameter($key, $value);
        }
        foreach ($compilerPasses as $compilerPass) {
            $container->addCompilerPass($compilerPass);
        }
        $container->compile();

        return $container;
    }
597331
public function build(string $className): interfaces\commands\Command
    {
        $params = is_subclass_of($className, interfaces\commands\ExecutableCommand::class) ? [$this->bus] : [];

        /** @var interfaces\commands\Command $command */
        $command = \Yii::createObject($className, $params);

        $this->prepareCommand($command);

        return $command;
    }
1114085
public static function build()
    {
        $ini = eZINI::instance( 'file.ini' );
        $defaultHandler = eZDFSFileHandlerBackendFactory::buildHandler(
            $ini->variable( 'DispatchableDFS', 'DefaultBackend' )
        );

        $pathHandlers = array();
        foreach ( $ini->variable( 'DispatchableDFS', 'PathBackends' ) as $supportedPath => $backendClass )
        {
            // @todo Make it possible to use a Symfony2 service
            $pathHandlers[$supportedPath] = eZDFSFileHandlerBackendFactory::buildHandler( $backendClass );
        }

        return new static( $defaultHandler, $pathHandlers );
    }
61870
public function build(array $config, ContainerInterface $container = null)
    {
        $dispatcher = new Dispatcher($container);
        foreach ((array) $config as $name => $listeners) {
            foreach ($listeners as $listener) {
                if (is_callable($listener)) {
                    $dispatcher->register($name, $listener);
                    continue;
                }

                $listener = $this->applyDefaults($listener);

                $dispatcher->register(
                    $name,
                    $this->buildDefinition($listener)
                );
            }
        }

        return $dispatcher;
    }
505191
public function build(): ScreencastFrameAckRequest
	{
		$instance = new ScreencastFrameAckRequest();
		if ($this->sessionId === null) {
			throw new BuilderException('Property [sessionId] is required.');
		}
		$instance->sessionId = $this->sessionId;
		return $instance;
	}
880908
public function build($index, $default = null, $params = [])
    {
        $class = $this->get($index, $default);
        if (!class_exists($class)) {
            throw new \Exception('Class doesn\'t exist for the index : ' .$index);
        }

        $class = new \ReflectionClass($class);
        return $class->newInstanceArgs($params);
    }
623708
public function build() : RouterInterface
    {
        $router = $this->router;
        try{
            // call bootstrap code
            $startup = $this->bootstrap;
            
            $startup($router);
        }
        catch(\Throwable $e)
        {
            throw new RouterBuildingException($e);
        }
        return $router;
    }
290015
public function build(): SetEffectivePropertyValueForNodeRequest
	{
		$instance = new SetEffectivePropertyValueForNodeRequest();
		if ($this->nodeId === null) {
			throw new BuilderException('Property [nodeId] is required.');
		}
		$instance->nodeId = $this->nodeId;
		if ($this->propertyName === null) {
			throw new BuilderException('Property [propertyName] is required.');
		}
		$instance->propertyName = $this->propertyName;
		if ($this->value === null) {
			throw new BuilderException('Property [value] is required.');
		}
		$instance->value = $this->value;
		return $instance;
	}