Set configuration structs to the given $blockCreateStruct.
188632
private function setConfigStructs(
        ConfigAwareStruct $configAwareStruct,
        ConfigDefinitionAwareInterface $configDefinitionAware,
        array $configurationData
    ): void {
        $configDefinitions = $configDefinitionAware->getConfigDefinitions();

        foreach ($configurationData as $configKey => $hash) {
            $configStruct = new ConfigStruct();
            $configStruct->fillParametersFromHash($configDefinitions[$configKey], $hash, true);
            $configAwareStruct->setConfigStruct($configKey, $configStruct);
        }
    }
68805
def __build_config_block(self, config_block_node):
        
        node_lists = []

        for line_node in config_block_node:
            if isinstance(line_node, pegnode.ConfigLine):
                node_lists.append(self.__build_config(line_node))
            elif isinstance(line_node, pegnode.OptionLine):
                node_lists.append(self.__build_option(line_node))
            elif isinstance(line_node, pegnode.ServerLine):
                node_lists.append(
                    self.__build_server(line_node))
            elif isinstance(line_node, pegnode.BindLine):
                node_lists.append(
                    self.__build_bind(line_node))
            elif isinstance(line_node, pegnode.AclLine):
                node_lists.append(
                    self.__build_acl(line_node))
            elif isinstance(line_node, pegnode.BackendLine):
                node_lists.append(
                    self.__build_usebackend(line_node))
            elif isinstance(line_node, pegnode.UserLine):
                node_lists.append(
                    self.__build_user(line_node))
            elif isinstance(line_node, pegnode.GroupLine):
                node_lists.append(
                    self.__build_group(line_node))
            else:
                # may blank_line, comment_line
                pass
        return node_lists
979865
private function setSettings()
    {
        // Use faster compression if available
        if (Memcached::HAVE_IGBINARY) {
            $this->memcached->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY);
        }
        $this->memcached->setOption(Memcached::OPT_DISTRIBUTION, Memcached::DISTRIBUTION_CONSISTENT);
        $this->memcached->setOption(Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
        $this->memcached->setOption(Memcached::OPT_NO_BLOCK, true);
        $this->memcached->setOption(Memcached::OPT_TCP_NODELAY, true);
        $this->memcached->setOption(Memcached::OPT_COMPRESSION, false);
        $this->memcached->setOption(Memcached::OPT_CONNECT_TIMEOUT, 2);
    }
1288785
public function create(CreateStruct $struct)
    {
        $language = $this->languageMapper->createLanguageFromCreateStruct(
            $struct
        );
        $language->id = $this->languageGateway->insertLanguage($language);

        return $language;
    }
298786
public function setBuild($build, $hash = null)
    {
        $params = [
            'system::core.build' => $build
        ];

        if ($hash) {
            $params['system::core.hash'] = $hash;
        }

        Parameter::set($params);
    }
1173397
def setup(app):
    """"""
    app.add_config_value('jsdoc_source_root', '..', 'env')
    app.add_config_value('jsdoc_output_root', 'javascript', 'env')
    app.add_config_value('jsdoc_exclude', [], 'env')
    app.connect('builder-inited', generate_docs)
915311
public function createGroupFromCreateStruct(GroupCreateStruct $struct)
    {
        $group = new Group();

        $group->name = $struct->name;

        // $group->description is intentionally left out, since DB structure does not support it, yet

        $group->identifier = $struct->identifier;
        $group->created = $struct->created;
        $group->modified = $struct->modified;
        $group->creatorId = $struct->creatorId;
        $group->modifierId = $struct->modifierId;

        return $group;
    }
227780
def setConfiguration(self, configuration):
        
        """
        if isinstance(configuration, Configuration):
           configuration = configuration.value

        self.dev.set_configuration(configuration)
688545
def configure(env=:default, &block)
      environment = config_attributes[env.to_sym]

      Builder.new(environment, &block)
    end
694357
protected function setBuildItems()
    {
        $crcy = Factory::create($this->code);

        $refl = new \ReflectionClass($crcy);
        $fmt = $refl->getProperty('displayFormat'); $fmt->setAccessible(true);
        $locale = $refl->getProperty('locale'); $locale->setAccessible(true);
        $precision = $refl->getProperty('precision'); $precision->setAccessible(true);

        $this->buildItems = [
            'code' => $this->code,
            'name' => $crcy->getName()->get(),
            'symbol' => $crcy->getSymbol()->get(),
            'displayFormat' => $fmt->getValue($crcy)->get(),
            'locale' => $locale->getValue($crcy)->get(),
            'precision' => $precision->getValue($crcy)->get(),
            'value' => $crcy()
        ];
    }
455501
public function set_attributes() {

		if ( ! empty( $this->struct['config'] ) ) {
			$this->set_config();
		}

		$this->attributes['class'] += $this->classes();

		parent::set_attributes();

	}
1227707
def build_set(id=None, name=None, temporary_build=False, timestamp_alignment=False,
              force=False, rebuild_mode=common.REBUILD_MODES_DEFAULT, **kwargs):
    
    content = build_set_raw(id, name,
                            temporary_build, timestamp_alignment, force, rebuild_mode, **kwargs)
    if content:
        return utils.format_json(content)
656963
def init_submodules(self, cache):
    """"""
    self.cache = CacheService(cache, weakref.proxy(self)) 
    self.mesh = PrecomputedMeshService(weakref.proxy(self))
    self.skeleton = PrecomputedSkeletonService(weakref.proxy(self))
239401
private function buildBlockCreateStruct(array $blockData): BlockCreateStruct
    {
        if (!array_key_exists($blockData['main_locale'], $blockData['parameters'])) {
            throw new RuntimeException(
                sprintf('Missing data for block main locale "%s"', $blockData['main_locale'])
            );
        }

        $blockDefinition = $this->blockDefinitionRegistry->getBlockDefinition($blockData['definition_identifier']);

        $blockCreateStruct = $this->blockService->newBlockCreateStruct($blockDefinition);
        $blockCreateStruct->name = $blockData['name'];
        $blockCreateStruct->viewType = $blockData['view_type'];
        $blockCreateStruct->itemViewType = $blockData['item_view_type'];
        $blockCreateStruct->isTranslatable = $blockData['is_translatable'];
        $blockCreateStruct->alwaysAvailable = $blockData['is_always_available'];
        $blockCreateStruct->fillParametersFromHash($blockData['parameters'][$blockData['main_locale']], true);
        $this->setConfigStructs($blockCreateStruct, $blockDefinition, $blockData['configuration'] ?? []);
        $this->setCollectionStructs($blockCreateStruct, $blockData['collections']);

        return $blockCreateStruct;
    }
801955
def _construct_config(self, basedir, port, name=None, isreplset=False):
        """"""
        if isreplset:
            return self._construct_replset(basedir=basedir, portstart=port,
                                           name=name,
                                           num_nodes=list(range(
                                               self.args['config'])),
                                           arbiter=False, extra='--configsvr')
        else:
            datapath = self._create_paths(basedir, name)
            self._construct_mongod(os.path.join(datapath, 'db'),
                                   os.path.join(datapath, 'mongod.log'),
                                   port, replset=None, extra='--configsvr')
76664
public static function configure(): void
    {
        $filesystem = new Filesystem();
        $config     = [
            'colors'          => '1',
            'installed_paths' => implode(',', [
                Path::VENDOR_DIR . '/hostnet/phpcs-tool/src/',
                Path::VENDOR_DIR . '/slevomat/coding-standard/SlevomatCodingStandard',
            ]),
        ];

        if (!$filesystem->exists(['phpcs.xml', 'phpcs.xml.dist'])) {
            $config['default_standard'] = 'Hostnet';
        }

        $filesystem->dumpFile(
            Path::VENDOR_DIR . '/squizlabs/php_codesniffer/CodeSniffer.conf',
            sprintf('<?php $phpCodeSnifferConfig = %s;', var_export($config, true))
        );

        $filesystem->dumpFile(__DIR__ . '/../../../HostnetPaths/ruleset.xml', self::generateHostnetPathsXml());
    }
31559
def create(self):
        """"""
        pk = CRTPPacket()
        pk.set_header(5, CHAN_SETTINGS)
        if self.useV2:
            pk.data = (CMD_CREATE_BLOCK_V2, self.id)
        else:
            pk.data = (CMD_CREATE_BLOCK, self.id)
        for var in self.variables:
            if (var.is_toc_variable() is False):  # Memory location
                logger.debug('Logging to raw memory %d, 0x%04X',
                             var.get_storage_and_fetch_byte(), var.address)
                pk.data.append(struct.pack('<B',
                                           var.get_storage_and_fetch_byte()))
                pk.data.append(struct.pack('<I', var.address))
            else:  # Item in TOC
                logger.debug('Adding %s with id=%d and type=0x%02X',
                             var.name,
                             self.cf.log.toc.get_element_id(
                                 var.name), var.get_storage_and_fetch_byte())
                pk.data.append(var.get_storage_and_fetch_byte())
                if self.useV2:
                    ident = self.cf.log.toc.get_element_id(var.name)
                    pk.data.append(ident & 0x0ff)
                    pk.data.append((ident >> 8) & 0x0ff)
                else:
                    pk.data.append(self.cf.log.toc.get_element_id(var.name))
        logger.debug('Adding log block id {}'.format(self.id))
        if self.useV2:
            self.cf.send_packet(pk, expected_reply=(
                CMD_CREATE_BLOCK_V2, self.id))
        else:
            self.cf.send_packet(pk, expected_reply=(CMD_CREATE_BLOCK, self.id))