Builds the parameter definition.
@return Parameter definition
186690
public Parameter<T> build() {
    if (this.name == null) {
      throw new IllegalArgumentException("Name is missing.");
    }
    if (this.type == null) {
      throw new IllegalArgumentException("Type is missing.");
    }
    if (this.applicationId == null) {
      throw new IllegalArgumentException("Application id is missing.");
    }
    return new Parameter<T>(
        this.name,
        this.type,
        this.applicationId,
        this.defaultOsgiConfigProperty,
        this.defaultValue,
        ImmutableValueMap.copyOf(this.properties));
  }
646209
public function build()
    {
        $config = new Config();

        $event = new GetConfigEvent($config);
        $this->eventDispatcher->dispatch(GuiEvents::GET_CONFIG, $event);

        return $config;
    }
349442
public function build() : string
    {
        $path = collect([
                $this->prepends,
                $this->resourceKey,
                $this->id,
                $this->appends,
            ])
            ->filter()
            ->implode('/');

        $uri = "{$path}.{$this->format}";

        return $this->hasParams() ? $uri.'?'.http_build_query($this->params) : $uri;
    }
983911
public function build()
    {
        $cm = $this->builder->getClassMetadata();
        if ($this->generatedValue) {
            $cm->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $this->generatedValue));
        }
        if ($this->version) {
            $cm->setVersionMapping($this->mapping);
        }
        $cm->mapField($this->mapping);
        if ($this->sequenceDef) {
            $cm->setSequenceGeneratorDefinition($this->sequenceDef);
        }
        return $this->builder;
    }
1024907
public function build()
    {
        $this->readConfigs();

        $files = $this->getSiteFiles();

        $otherFiles = array_filter($files, function ($file) {
            return ! str_contains($file->getRelativePath(), '_blog');
        });

        if (@$this->configs['enableBlog']) {
            $blogPostsFiles = array_filter($files, function ($file) {
                return str_contains($file->getRelativePath(), '_blog');
            });

            $this->readBlogPostsData($blogPostsFiles);
        }

        $this->buildViewsData();

        $this->filesystem->cleanDirectory(KATANA_PUBLIC_DIR);

        if ($this->forceBuild) {
            $this->filesystem->cleanDirectory(KATANA_CACHE_DIR);
        }

        $this->handleSiteFiles($otherFiles);

        if (@$this->configs['enableBlog']) {
            $this->handleBlogPostsFiles($blogPostsFiles);
            $this->buildBlogPagination();
            $this->buildRSSFeed();
        }
    }
1109173
public static function build()
    {
        if ( !isset( self::$instance ) )
        {
            self::$instance = self::buildHandler(
                eZINI::instance( 'file.ini' )->variable( 'eZDFSClusteringSettings', 'DFSBackend' )
            );
        }

        return self::$instance;
    }
1193357
public function build()
    {

        $query = $this->getQuery();
        $manager = new BuildManager($this->getBase()->getConnection());
        $manager->setPage($this->page);
        $manager->setQuery($query);
        $manager->setParams($this->string['parameters']);

        return $manager;
    }
348582
public function
	Build() {
	/*//
	compile the files down to the final form.
	//*/

		if($this->Print) {
			header(sprintf(
				"Content-type: %s",
				$this->GetFullContentType()
			));
		}

		$ds = DIRECTORY_SEPARATOR;
		$source = '';
		$filelist = $this->FindTheFiles();
		$outfile = sprintf(
			"%s{$ds}%s{$ds}%s",
			$this->OutputDir,
			$this->DistDir,
			$this->OutputFile
		);

		if($this->AddScriptHeader) $this->AppendScriptHeader(
			$filelist,
			$source
		);

		foreach($filelist as $filepath)
		$this->AppendFile($filepath,$source);

		if($this->OutputFile) {
			if(!$this->WriteToDisk($outfile,$source)) {
				echo $this->GetComment(
					$this->Print,
					"INFO: output was unchanged with this build.",
					$source
				);

				if($this->Print)
				echo PHP_EOL;
			}
		}

		if($this->Print) {
			echo $source, PHP_EOL;
		}

		return $this;
	}
1110631
protected function buildParams()
    {
        if (empty($this->get)) {
            foreach (@$_GET as $k => $v) {
                $this->get[$k] = $v;
                $this->params[$k] = $v;
            }
        }

        if (empty($this->post)) {
            foreach (@$_POST as $k => $v) {
                $this->post[$k] = $v;
                $this->params[$k] = $v;
            }
        }

        foreach ($this->userParams as $k => $v) {
            $this->params[$k] = $v;
        }
    }
417611
public function processParameters()
    {
        $parameters = $this->getParameters();
        $factory = $this->buildFactory();
        $parametersType = $this->buildParametersType();
        $request = $factory->create($parametersType);
        if (!is_null($parameters)) {
            $processorFactory = new ParametersProcessorFactory();
            $processor = $processorFactory->create(gettype($parameters));
            $request = $processor->convertToObjectParameters(
                $request,
                $parameters
            );
        }
        return $request;
    }
658438
private function build() {

        //Get value
        $selected = null;

        if(true === $this -> filled) {

            if(true === isset($this -> attributes['name'])) {

                if(true === Request :: isPost()) {
                    $selected = Request :: fromPost($this -> attributes['name']);
                }
            }
        }

        //Build select
        $html = '<select';
        
        foreach($this -> attributes as $attribute => $value) {

            if('value' !== $attribute) {
                $html .= ' ' . $attribute . '="'. Escape :: attr($value) .'"';
            }
        }

        $html .= '>';

        //Build options
        foreach($this -> options as $key => $value) {

            if(true === is_array($value)) {

                $html .= '<optgroup label="'. Escape :: attr($key) .'">';

                    foreach($value as $key => $value) {

                        $html .= '<option value="'. Escape :: attr($key) .'"';

                            if($key === $selected) {
                                $html .= ' selected="selected"';
                            }

                        $html .= '>'. Escape :: html($value) .'</option>';
                    }

                $html .= '</optgroup>';
            }
            else {

                $html .= '<option value="'. Escape :: attr($key) .'"';

                    if($key === $selected) {
                        $html .= ' selected="selected"';
                    }

                $html .= '>'. Escape :: html($value) .'</option>';
            }
        }
        
        $html .= '</select>';

        return $html;
    }
637862
public function build(){

        $html = '';
        if ($this->isBuildFormElement == true){
            $html .= $this->buildHeader();
        }

        $html .= $this->buildElements();

        if ($this->isBuildFormElement == true){
            $html .= "</form>";
        }

        return $html;
    }
220706
public function build()
    {
        if (isset($this->component)) {
            return $this->component;
        }

        $this->component = BuildUtil::removeNullElements([
            'type' => ComponentType::BUTTON,
            'action' => $this->actionBuilder->buildTemplateAction(),
            'flex' => $this->flex,
            'margin' => $this->margin,
            'height' => $this->height,
            'style' => $this->style,
            'color' => $this->color,
            'gravity' => $this->gravity,
        ]);

        return $this->component;
    }
383526
public static function build()
    {
        $args = func_get_args();

        $sql = [];

        foreach ($args as $arg) {
            if ($arg === '' || $arg === null || $arg === false) {
                continue;
            }

            $sql[] = $arg;
        }

        return implode(' ', $sql);
    }
1254897
private function buildSearchParameters() {
        $fields = $this->getModelBuilder()->getFields();
        $numberOfFields = sizeof($fields);
        if($numberOfFields > 5) {
            $numberOfFields = 5;
        }
        $parameters = array();
        for($i = 0; $i < $numberOfFields; $i++) {
            $parameter = new Swagger\Parameter();
            $parameter->setName($fields[$i]->getShortName());
            $parameter->setDescription($fields[$i]->getComment());
            $parameter->setParamType('query');
            $parameter->setType($fields[$i]->getSwaggerType());
            $parameters[] = $parameter;
        }

        return $parameters;
    }
399378
public function build()
    {
        $input = new BucketInput($this->namespace, $this->filters);
        $spec  = new Specification($input, $this->phases, $this->timeout);

        return new BucketMapReduce($spec);
    }
1261658
public function build()
    {
        $params = parent::build();

        if ($this->sendDate) {
            $params['schedule'] = [
                'time' => $this->sendDate->format('c'),
            ];
        }

        return $params;
    }