performPost

@param array $components
@access public
@return void
965136
public function performPost(array $components)
    {
        $response = $this->httpClient->post('', [
            'json' => ['components' => $components]
        ]);

        return (string) $response->getBody();
    }
1058097
public function renderHeader(array $comments = []) : void
    {
        if ($this->isSilent()) {
            return;
        }

        $this->logger->debug('rendering comments');

        foreach ($comments as $comment) {
            fwrite($this->file, ';;; ' . $comment . PHP_EOL);
        }

        fwrite($this->file, PHP_EOL);
    }
791297
private function update_components( $components )
    {
        foreach ( $components as $component ) 
        {
            // Update each component in the composite collection
            if ( $component instanceof UI\Components\Composite )
            {
                $this->update_components( $component->components );
            }
            
            // Update individual fields, as well as the composite parent field.
            if ( $component instanceof UI\ValueComponentInterface )
            {
                $this->update_component( $component );
            }
        }
    }
641489
protected function filterElements(array &$elements): void
    {
        if (!empty($elements['storage_key'])) {
            $this->_storage['storage_key'] = trim($elements['storage_key']);
        }
        if (!empty($elements['storage_timestamp'])) {
            $this->_storage['storage_timestamp'] = (int)$elements['storage_timestamp'];
        }

        unset ($elements['storage_key'], $elements['storage_timestamp'], $elements['_post_entries_save']);
    }
1018834
protected function setup_components() {
		$this->load_components();

		$components = $this->get_components();
		$this->set_component_parents( $components );
		/** @var \ComposePress\Core\Abstracts\Component[] $components */
		foreach ( $components as $component ) {
			if ( method_exists( $component, 'init' ) ) {
				$component->init();
			}
		}
	}
1363800
function(components){
        if(!(OpenLayers.Util.isArray(components))) {
            components = [components];
        }
        for(var i=0, len=components.length; i<len; i++) {
            this.addComponent(components[i]);
        }
    }
1279258
public function handleArray(array $data = []): void
    {
        $this->getForm()->submit($data);
        $this->handleForm($data['page'] ?? null);
    }
1217220
public function replaceBy (array $components = null)
  {
    $p = $this->getIndex ();
    if ($p !== false) {
      array_splice ($this->parent->children, $p, 1, $components);
      $this->parent->attach ($components);
    }
    else {
      $t = ComponentInspector::inspectSet ($this->parent->children);
      throw new ComponentException($this,
        "The component was not found on the parent's children.<h3>The children are:</h3><fieldset>$t</fieldset>");
    }
  }
695440
private function setUpComponents($components)
  {
    if (empty($components)) {
      $this->components = $components;
    // sequential
    } elseif (array_keys($components) === range(0, count($components) - 1)) {
      for ($i = 0; $i < count($components); $i++) {
        $this->components[$components[$i]] = 0;
      }
    // associative
    } else {
      foreach ($components as $component => $value) {
        $this->components[$component] = 0;
      }
    }
  }
1072151
public function setComponents($components)
	{
	    if ($components) foreach ($components as $k => $v) {
	        $v = static::formatDefinition($k, $v);
	        if (is_numeric($k)) {
	            $k = static::formatName($v);
	        }
	        $this->set($k, $v);
	    }
	}
598246
protected function setPostFields (array $fields)
	{
		foreach ($fields as $key => $value) $this->fields[$key] = $value;
	}
1203221
protected function requireResponseComponents(array $components, $response) {
		foreach($components as $component) {
			if(empty($response[$component])) {
				throw new OpauthValidationException('Required component missing', 2, $component);
			}
		}
	}
895237
public function update(Component $component)
    {
        try {
            execute(new UpdateComponentCommand(
                $component,
                Binput::get('name'),
                Binput::get('description'),
                Binput::get('status'),
                Binput::get('link'),
                Binput::get('order'),
                Binput::get('group_id'),
                Binput::get('enabled', $component->enabled),
                Binput::get('meta', null),
                (bool) Binput::get('silent', false)
            ));
        } catch (QueryException $e) {
            throw new BadRequestHttpException();
        }

        if (Binput::has('tags')) {
            $component->tags()->delete();

            // The component was added successfully, so now let's deal with the tags.
            Collection::make(preg_split('/ ?, ?/', $tags))->map(function ($tag) {
                return trim($tag);
            })->map(function ($tag) {
                return execute(new CreateTagCommand($tag));
            })->each(function ($tag) use ($component) {
                execute(new ApplyTagCommand($component, $tag));
            });
        }

        return $this->item($component);
    }
460781
public function set_component($component) {
        $this->areacache = null;
        list($type, $name) = core_component::normalize_component($component);
        $this->component = $type.'_'.$name;
    }
654491
public void add(Collection<PluginComponent> components)
    {
        for(PluginComponent component : components)
            this.components.put(component.getId(), component);
    }
331764
public function addParamsSelected($fields = null, $props = null)
    {
        if (is_array($fields) && !empty($fields))
        {
            $this->arParams['SELECT_FIELDS'] = array_merge($this->arParams['SELECT_FIELDS'], $fields);
        }

        if (is_array($props) && !empty($props))
        {
            $this->arParams['SELECT_PROPS'] = array_merge($this->arParams['SELECT_PROPS'], $props);
        }
    }
1299892
protected static function triggerAfterInitialize($component)
    {
        if (self::getCoroutineMode($component) == ComponentInterface::COROUTINE_MODE_REFERENCE) {
            return;
        }
        if ($component->getStatus() == ComponentInterface::STATUS_RUNNING) {
            $component->onAfterInitialize();
        }
    }