@param string $groupName

@return DataModifierGroup
@throws DataModifierGroupNotFoundException
439278
public function getGroup(string $groupName) : DataModifierGroup
    {
        if (false === $this->hasGroup($groupName)) {
            throw new DataModifierGroupNotFoundException($groupName);
        }

        return $this->dataModifierGroups[$groupName];
    }
604938
public function load($groupName)
    {
        if (! count($this->readers)) {
            throw new \RuntimeException('No config readers attached');
        }

        if (! $groupName) {
            throw new \InvalidArgumentException('No config group specified');
        }

        if (! is_string($groupName)) {
            throw new \InvalidArgumentException('Config group must be a string');
        }

        if (isset($this->groups[$groupName])) {
            return $this->groups[$groupName];
        }

        $config = [];

        foreach ($this->readers as $reader) {
            if ($groupConfig = $reader->load($groupName)) {
                $config = array_replace_recursive($config, $groupConfig);
            }
        }

        $this->groups[$groupName] = $config;

        return $this->groups[$groupName];
    }
1339630
public function count(string $groupName): int
    {
        return $this->useRedis(function($resource, $redis) use($groupName){
            $key = $this->getGroupNameKey($groupName);
            return $redis->scard($key);
        });
    }
168543
public function deletePausedTriggerGroup($groupName)
    {
        $result = $this->res->getPausedTriggerCol()->deleteOne(['groupName' => $groupName]);

        return $result->isAcknowledged() && $result->getDeletedCount();
    }
364745
public Response deleteGroup(String groupName) {
		return restClient.delete("groups/" + groupName, new HashMap<String, String>());
	}
647810
private function setRequired(array $fields, string $groupName = null): array
    {
        foreach ($fields as $fieldName => $field) {
            if (!empty($field['required'])) {
                if (isset($field['groups']) && !is_array($field['groups'])) {
                    $field['groups'] = [$field['groups']];
                }
                if (empty($field['groups']) || in_array($groupName, $field['groups'])) {
                    $fields[$fieldName] = $this->makeRequired($fields[$fieldName]);
                }
            }
        }

        return $fields;
    }
770917
public function addGroup($groupName)
    {
        if (true === is_string($groupName) && false === in_array($groupName, $this->groups)) {
            $this->groups[] = $groupName;
        }
        return $this;
    }
478603
public function addGroup($groupName, $nameSuffixes) {
    // @todo More performant dedicated implementation.
    foreach ($nameSuffixes as $suffix) {
      $this->addName($groupName . '.' . $suffix);
    }
  }
69414
public function renderGroupWith($groupName, callable $renderer)
    {
        $this->parent->renderGroupWith($this->groupName($groupName), $renderer);

        return $this;
    }
756513
public function getRouteGroup(string $groupName): \Nofuzz\Route\Group
  {
    foreach ($this->routeGroups as $routeGroup)
    {
      if ( strcasecmp($routeGroup->getName(),$groupName)==0 ) {
        return $routeGroup;
      }
    }

    return null;
  }
1334786
public function indexAction($groupName)
    {
        $acl = $this->get('bacon_acl.service.authorization');

        if (!$acl->authorize('acl', 'ACL')) {
            throw $this->createAccessDeniedException();
        }

        $groupClassName     =   $this->getParameter('bacon_acl.group_class');
        $moduleClassName    =   $this->getParameter('bacon_acl.entities.module_class');

        $module = $this->getDoctrine()->getRepository($moduleClassName)->findAll();
        $group  = $this->getDoctrine()->getRepository($groupClassName)->findOneBy(array('name' => urldecode($groupName)));

        return [
            'modules' => $module,
            'group'  => $group
        ];
    }
673972
public function getResourceGroupUrl($groupName) {
        $url = sprintf($this->getBaseUrl() . '/groups/%s.json', $groupName);

        return Http\ResourceGroupUrl::factory(
            $url,
            $this->getConfig('privateKey'),
            $this->getPublicKey()
        );
    }
730583
public function getActionRequestsGroupByName($actionGroupName)
    {
        // Action Group is configured?
        if (!isset($this->actions[$actionGroupName])) {
            throw new NotConfiguredActionException(
                sprintf(
                    '[%s] No action group configured with the following name: %s.',
                    $this->getApiName(),
                    $actionGroupName
                ),
                $actionGroupName
            );
        }

        // Returning action group
        return $this->actions[$actionGroupName];
    }
503908
public function fromPreviousTable(string $tableName) : GroupedTableDefiner
    {
        if (!isset($this->previousTables[$tableName])) {
            throw InvalidArgumentException::format(
                'Invalid table name supplied to %s: expecting one of (%s), \'%s\' given',
                __METHOD__, Debug::formatValues(array_keys($this->previousTables)), $tableName
            );
        }

        return new GroupedTableDefiner($this->name, $this->callback, $this->previousTables[$tableName]->getDataSource());
    }
819399
public function setName(string $name): self
    {
        if (empty($name)) {
            throw new \InvalidArgumentException("Group name can not be empty");
        }
        $this->name = $name;
        return $this;
    }
890774
public function createFromImportedData($name, $data)
    {
        if (!is_array($data)) {
            return new GroupParameter($name, [$data]);
        } elseif (!$this->isAssociativeArray($data)) {
            return new GroupParameter($name, $data);
        }
        $parameter = new GroupParameter($name);
        foreach ($data as $childName => $childData) {
            $parameter->addChild($this->createFromImportedData($childName, $childData));
        }
        return $parameter;
    }
421634
public function setGroupId( $groupId )
    {
        $this->groupId = (int) $groupId ?: null;

        if ( $this->group && $this->group->id != $this->groupId )
        {
            $this->group = null;
        }

        return $this;
    }