Builds the instance of class

@return \Puzzlout\Framework\Core\DirectoryManager\ArrayFilterDirectorySearch
6370
public static function Init(\Puzzlout\Framework\Core\Application $app) {
        $instance = new ArrayFilterFileSearch();
        $instance->FileList = array();
        $instance->ContextApp = $app;
        return $instance;
    }
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;
    }
239876
public function buildScopes()
	{
		$this->setScopeMapper(new ScopeMapper);
		$this->configureScopes($this->getScopeMapper());

		$this->setScopeBuilder(new FilterBuilder($this->getScopeMapper()));
		$this->getScopeBuilder()
			->build();

		return $this;
	}
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;
    }
37142
public function build(): SetDiscoverTargetsRequest
	{
		$instance = new SetDiscoverTargetsRequest();
		if ($this->discover === null) {
			throw new BuilderException('Property [discover] is required.');
		}
		$instance->discover = $this->discover;
		return $instance;
	}
660055
public function build()
    {
        if (!$this->factory) {
            $this->factory = $this->createDefaultFactory();
        }

        return $this->cache ? new CachedLoggerFactory($this->factory) : $this->factory;
    }
829874
public function build(): SearchInResourceRequest
	{
		$instance = new SearchInResourceRequest();
		if ($this->frameId === null) {
			throw new BuilderException('Property [frameId] is required.');
		}
		$instance->frameId = $this->frameId;
		if ($this->url === null) {
			throw new BuilderException('Property [url] is required.');
		}
		$instance->url = $this->url;
		if ($this->query === null) {
			throw new BuilderException('Property [query] is required.');
		}
		$instance->query = $this->query;
		$instance->caseSensitive = $this->caseSensitive;
		$instance->isRegex = $this->isRegex;
		return $instance;
	}
293350
protected function buildDispatcher()
    {
        $this->app->singleton(
            'Ratchet\Wamp\WampServerInterface',
            Dispatcher::class
        );
        
        return $this->Dispatcher = $this->app->make('Ratchet\Wamp\WampServerInterface', [$this->getSession(), $this->buildKernel(), clone $this->out]);
    }
6979
public function buildFromClass($classname)
	{
		$reflectionClass = new ReflectionClass($classname);

		$classDefinition = new ClassDefinition();
		$classDefinition->name = $reflectionClass->getName();
		$classDefinition->namespace = $reflectionClass->getNamespaceName();

		$reflectionProperties = $this->classPropertyFinder->findProperties($reflectionClass);

		foreach ($reflectionProperties as $reflectionProperty) {
			$classDefinition->properties[$reflectionProperty->getName()] = $this->buildPropertyDefinition($reflectionProperty);
		}

		return $classDefinition;
	}
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 );
    }
384108
public function createInstance()
    {
        $classname = $this->getPlatformClassname();

        if (!class_exists($classname)) {
            throw new \Exception(
                sprintf('Unable to locate class %s', $classname)
            );
        }

        return new $classname();
    }
293509
public function build(): SetSamplingIntervalRequest
	{
		$instance = new SetSamplingIntervalRequest();
		if ($this->interval === null) {
			throw new BuilderException('Property [interval] is required.');
		}
		$instance->interval = $this->interval;
		return $instance;
	}
1001947
public function build()
    {
        $filtered = array_diff(
            array_map('trim', $this->values),
            ['']
        );

        if (is_null($this->original)) {
            // If the original value is null, we'll assume
            // that the attribute doesn't exist yet.
            if (! empty($filtered)) {
                // If the filtered array is not empty, we can
                // assume we're looking to add values
                // to the current attribute.
                $this->setType(LDAP_MODIFY_BATCH_ADD);
            }

            // If the filtered array is empty and there is no original
            // value, then we can ignore this attribute since
            // we can't push null values to the server.
        } else {
            if (empty($filtered)) {
                // If there's an original value and the array is
                // empty then we can assume we are looking
                // to completely remove all values
                // of the current attribute.
                $this->setType(LDAP_MODIFY_BATCH_REMOVE_ALL);
            } else {
                // If the array isn't empty then we can assume
                // we're looking to replace all attributes.
                $this->setType(LDAP_MODIFY_BATCH_REPLACE);
            }
        }

        return $this;
    }
196785
public function build()
    {
        if ($this->container->hasDefinition($this->definitionName())) {
            $this->container->getDefinition(
                $this->definitionName()
            )->replaceArgument(0, array_unique($this->configuration, SORT_REGULAR));
        }
        if ($this->container->hasDefinition($this->definitionApiName())) {
            foreach ($this->configuration as $key => $config) {
                $this->configuration[$key]['enabled'] = $config['api_enabled'];

                if (array_key_exists('type', $config)) {
                    $this->configuration[$key]['type'] = $config['api_type'];
                }
            }

            $this->container->getDefinition(
                $this->definitionApiName()
            )->replaceArgument(0, array_unique($this->configuration, SORT_REGULAR));
        }

        return $this->container;
    }
533158
public function build(): QueryObjectsRequest
	{
		$instance = new QueryObjectsRequest();
		if ($this->prototypeObjectId === null) {
			throw new BuilderException('Property [prototypeObjectId] is required.');
		}
		$instance->prototypeObjectId = $this->prototypeObjectId;
		$instance->objectGroup = $this->objectGroup;
		return $instance;
	}
1095382
public function Build()
    {
        $obj           = new \stdClass();
        $obj->metadata = $this->metadata;
        $obj->contents = $this->contents;

        return \json_encode($obj);
    }
73623
public function build(): ForcePseudoStateRequest
	{
		$instance = new ForcePseudoStateRequest();
		if ($this->nodeId === null) {
			throw new BuilderException('Property [nodeId] is required.');
		}
		$instance->nodeId = $this->nodeId;
		if ($this->forcedPseudoClasses === null) {
			throw new BuilderException('Property [forcedPseudoClasses] is required.');
		}
		$instance->forcedPseudoClasses = $this->forcedPseudoClasses;
		return $instance;
	}