Maps to the component id.

@param string $componentId

@return void
@throws InvalidOperationException
178805
public function toComponent(string $componentId)
    {
        if ($this->hidden) {
            throw InvalidOperationException::format('Invalid call to %s: cannot hide an existing column', __METHOD__);
        }

        call_user_func($this->componentIdCallback, $componentId);
    }
802731
public function aggregate(string $componentId, callable $aggregateCallback) : ColumnMappingDefiner
    {
        $componentId = $this->structure->normalizeComponentId($componentId);
        list($column, $component) = explode('.', $componentId);

        return $this->computed(function (array $rows) use ($column, $component, $aggregateCallback) {
            return $aggregateCallback(array_column(array_column($rows, $column), $component));
        });
    }
52262
public function callComponent($componentName)
    {
        if (!isset($this->components[$componentName])) {
            $requiredInterface = isset(static::$defaultComponents[$componentName][1])
                ? static::$defaultComponents[$componentName][1]
                : null;
            $componentConfig = isset(static::$defaultComponents[$componentName][2])
                ? static::$defaultComponents[$componentName][2]
                : [];
            if (isset($this->config['components'][$componentName])){
                $componentConfig = array_merge($componentConfig, $this->config['components'][$componentName]);
            }
            if (isset($componentConfig['class'])) {
                $componentClassName = $componentConfig['class'];
            } else {
                $componentClassName = isset(static::$defaultComponents[$componentName][0])
                    ? static::$defaultComponents[$componentName][0]
                    : null;
            }
            unset($this->config['components'][$componentName]);
            if (isset($componentConfig['class']))
            unset($componentConfig['class']);
            if ($componentClassName) {
                $instance = new $componentClassName($componentConfig, $this);
                if (null === $requiredInterface || ($instance instanceof $requiredInterface)) {
                    $this->components[$componentName] = $instance;
                } else {
                    throw new InvalidInterfaceException([$componentName, $componentClassName, $requiredInterface]);
                }
            } else {
                throw new UnknownComponentException($componentName);
            }
        }
        return $this->components[$componentName];
    }
867031
private function grantAccess($perfilId, $componentId)
    {
        $permissao = [
            'perfil_id' => $perfilId,
            'componente_id' => $componentId
        ];

        $this->db->insert('singular_permissao', $permissao);
    }
41637
public function setId($id)
    {
        if (is_integer($id) || is_float($id)) {
            $this->id = $id;
        } else {
            throw new InvalidArgumentException();
        }
    }
199187
public function orderBy(string $componentId, string $direction)
    {
        list($column, $component) = $this->structure->getColumnAndComponent($componentId);

        $this->orderings[] = new ColumnOrdering($column, $component, $direction);

        return $this;
    }
764068
public function offsetExists($componentId) : bool
    {
        list($columnName, $componentName) = explode('.', $componentId) + [1 => null];

        if (!array_key_exists($columnName, $this->data)) {
            return false;
        }

        $cellData = $this->getCellData($columnName);

        if (!$componentName) {
            return count($cellData) === 1;
        } else {
            return array_key_exists($componentName, $cellData);
        }
    }
327574
@DeleteOperation
    public void invalidate(@Nullable final String serviceId) {
        if (StringUtils.isBlank(serviceId)) {
            cachingMetadataResolver.invalidate();
        } else {
            val registeredService = findRegisteredService(serviceId);
            val criteriaSet = new CriteriaSet();
            criteriaSet.add(new EntityIdCriterion(serviceId));
            criteriaSet.add(new EntityRoleCriterion(SPSSODescriptor.DEFAULT_ELEMENT_NAME));
            cachingMetadataResolver.invalidate(registeredService, criteriaSet);
        }
    }
1296711
public function invalidateModuleCache(string $moduleId)
    {
        /**
         * @TODO we have to implement it in ShopModuleCacheService or use ModuleCache::resetCache() method.
         */
        $module = oxNew(Module::class);

        $templates = $module->getTemplates($moduleId);
        $utils = Registry::getUtils();
        $utils->resetTemplateCache($templates);
        $utils->resetLanguageCache();
        $utils->resetMenuCache();

        ModuleVariablesLocator::resetModuleVariables();

        if (extension_loaded('apc') && ini_get('apc.enabled')) {
            apc_clear_cache();
        }
    }
455344
public function setId($keyId = 0)
    {
        if (empty($keyId) || $keyId == 0) {
            throw new GdgCommonsInvalidArgumentException("Key id must not be null or empty");
        }
        
        if (!is_int($keyId)) {
            throw new GdgCommonsInvalidArgumentException("Key id must be integer");
        }
        
        $this->_keyId = $keyId;
    }
1220112
public function setSubscriptionId($subscriptionId)
    {
        if (strlen($subscriptionId) > 50) {
            throw new InvalidArgumentException("Subscription id cannot be longer than 50 characters");
        }
        if (preg_match('/[^a-zA-Z0-9_-]/', $subscriptionId)) {
            throw new InvalidArgumentException("Subscription id cannot contain special characters");
        }
        $this->parameters['subscription_id'] = $subscriptionId;
    }
1112213
private function getComponentComposer($libraryRootPath, $componentId, $defaultComposerPath = null)
    {
        if (!$defaultComposerPath) {
            $defaultComposerPath = isset($this->defaultComponentComposer)
                ? $this->defaultComponentComposer
                : null;
        }

        $componentsDir = isset($this->components)
            ? $this->components
            : $libraryRootPath;

        $components = $this->getComponents($libraryRootPath, $componentsDir, $defaultComposerPath);

        $components = array_values(array_filter($components, function ($component) use ($componentId) {
            return ($component['id'] === $componentId);
        }));

        if (count($components) === 0) {
            throw new \InvalidArgumentException(sprintf(
                'Given component id %s is not a valid component.',
                $componentId
            ));
        }

        return $components[0];
    }
1325260
public function registerService($name, $serviceId)
    {
        if (isset($this->serviceMap[$name])) {
            throw new \InvalidArgumentException(sprintf(
                '%s service "%s" is already registered',
                $this->serviceType, $name
            ));
        }

        $this->serviceMap[$name] = $serviceId;
        $this->services[$name] = null;
    }
1150745
protected function setAutoId ()
  {
    if ($this->regenerateId || (isset($this->props) && !property ($this->props, 'id'))) {
      $this->regenerateId = true; // if the component is re-rendered, always generate an id from now on.
      // Strip non alpha-numeric chars from generated name.
      $this->props->id =
        preg_replace ('/\W/', '', property ($this->props, 'name') ?: lcfirst ($this->className)) .
        $this->getUniqueId ();
    }

    return $this->props->id;
  }
330276
public function readSubscription($subscriptionId, $componentId)
    {
        $service = $this->getService();

        $response      = $service->request('subscriptions/' . (int)$subscriptionId . '/components/' . (int)$componentId, 'GET');
        $responseArray = $this->getResponseArray($response);

        if (!$this->isError()) {
            $this->_data = $responseArray['component'];
        } else {
            $this->_data = array();
        }

        return $this;
    }
727294
public function orderBy(string $componentId, string $direction)
    {
        $this->rowCriteria->orderBy($componentId, $direction);

        return $this;
    }
566038
public void deleteComponent(String componentName) throws IOException {
    String path = RegistryUtils.componentPath(
        user, jstormServiceClass, instanceName,
        componentName);
    registryOperations.delete(path, false);
  }