delete all options entries from .

@param null $group
@return array
12098
public function clear($group = null) {
        if( isset($group) )
            unset($this->settings[$group]);
        else
            $this->settings = [];

        return $this;
    }
1065899
public function removeGroup(\Enhavo\Bundle\NewsletterBundle\Entity\Group $group)
    {
        $this->group->removeElement($group);
    }
543687
public static function ungroup($group)
    {
        if (!static::isValidGroupId($group)) {
            return false;
        }
        $gateway_data             = GatewayProtocol::$empty;
        $gateway_data['cmd']      = GatewayProtocol::CMD_UNGROUP;
        $gateway_data['ext_data'] = $group;
        return static::sendToAllGateway($gateway_data);

    }
701824
public function removeFields($fieldset = null, $group = null)
    {
        foreach ($this->fields as $current) {
            if ($fieldset && $current->getFieldset() != $fieldset) {
                $this->removeField($current->getName(true));
            }

            if ($group && $current->getGroup() != $group) {
                $this->removeField($current->getName(true));
            }
        }

        return $this;
    }
916099
protected function loadGroupConfig($group)
    {
        // data from files
        $res = $this->loader->load($group);

        // mark pool dirty
        if (count($res)) {
            $this->setPoolDirty();
        }

        $config = [];
        foreach($res as $grp => $grpData) {
            if (!isset($config[$grp])) {
                $config[$grp] = [];
            }
            foreach ($grpData as $data) {
                $config[$grp] = array_replace_recursive(
                    $config[$grp], $this->fixValue($data)
                );
            }
        }

        // set the whole pool
        if (null === $group) {
            $this->pool = $config;

        // set a group
        } else {
            $this->pool[$group] = $config[$group];
        }
    }
467046
public function removeGroup($group)
    {
        if (is_string($group)) {
            // If the group is a string, we'll assume the dev is passing
            // in a DN string of the group. We'll try to locate it.
            $group = $this->query->newInstance()->findByDn($group);
        }

        if ($group instanceof Group) {
            // If the group is Group model instance, we can
            // remove the current models DN from the group.
            return $group->removeMember($this->getDn());
        }

        return false;
    }
425290
public function clean($group = null)
	{
		$hash = $this->options['hash'];

		$allinfo = xcache_list(XC_TYPE_VAR, 0);

		foreach ($allinfo['cache_list'] as $key)
		{
			if (strpos($key['name'], $hash . '-cache-' . $group . '-') === 0) // xor $mode != 'group')
			{
				xcache_unset($key['name']);
			}
		}

		return true;
	}
1024728
public function delete(Group $group, $userId = null)
    {
        $this->dispatch($group, 'preDelete', [], $userId);

        $this->database->delete('ucms_group')->condition('id', $group->getId())->execute();

        $this->dispatch($group, 'delete', [], $userId);
    }
974918
public function formProperties(array $group = null)
    {
        $obj = $this->obj();
        $props = $obj->metadata()->properties();

        // We need to sort form properties by form group property order if a group exists
        if (!empty($group)) {
            $props = array_merge(array_flip($group), $props);
        }

        foreach ($props as $propertyIdent => $propertyMetadata) {
            if (method_exists($obj, 'filterPropertyMetadata')) {
                $propertyMetadata = $obj->filterPropertyMetadata($propertyMetadata, $propertyIdent);
            }

            if (!is_array($propertyMetadata)) {
                throw new UnexpectedValueException(sprintf(
                    'Invalid property data for "%1$s", received %2$s',
                    $propertyIdent,
                    (is_object($propertyMetadata) ? get_class($propertyMetadata) : gettype($propertyMetadata))
                ));
            }

            $propertyMetadata['display_options'] = $this->displayOptions();

            $formProperty = $this->createFormProperty();
            $formProperty->setViewController($this->viewController());
            $formProperty->setPropertyIdent($propertyIdent);
            $formProperty->setData($propertyMetadata);
            $formProperty->setPropertyVal($obj[$propertyIdent]);

            if ($formProperty->hidden()) {
                $this->hiddenProperties[$propertyIdent] = $formProperty;
            } else {
                yield $propertyIdent => $formProperty;
            }
        }
    }
1358062
public function deleteGroup($sGrouping)
    {
        $oDb = Factory::service('Database');
        $oDb->where('grouping', $sGrouping);

        return $oDb->delete($this->sTable);
    }
113029
public function clearGroup($group)
    {
        $this->_File = null;

        $prefix = (string)$this->_config['prefix'];

        $directoryIterator = new RecursiveDirectoryIterator($this->_config['path']);
        $contents = new RecursiveIteratorIterator(
            $directoryIterator,
            RecursiveIteratorIterator::CHILD_FIRST
        );
        $filtered = new CallbackFilterIterator(
            $contents,
            function (SplFileInfo $current) use ($group, $prefix) {
                if (!$current->isFile()) {
                    return false;
                }

                $hasPrefix = $prefix === ''
                    || strpos($current->getBasename(), $prefix) === 0;
                if ($hasPrefix === false) {
                    return false;
                }

                $pos = strpos(
                    $current->getPathname(),
                    DIRECTORY_SEPARATOR . $group . DIRECTORY_SEPARATOR
                );

                return $pos !== false;
            }
        );
        foreach ($filtered as $object) {
            $path = $object->getPathname();
            $object = null;
            // @codingStandardsIgnoreLine
            @unlink($path);
        }

        return true;
    }
377262
public function canDelete(GroupInterface $group, array $parameters)
    {
        $nbrGroupsUsers = $parameters;
        if (!array_key_exists($group->getId(), $nbrGroupsUsers)) {
            $nbrGroupsUsers = $this->userRepository->getCountsUsersByGroups(array($group->getId()));
        }

        return 0 === $nbrGroupsUsers[$group->getId()];
    }
612553
public function getConfigurable($group = null)
    {
        if (empty($this->configurable)) {
            foreach ($this->customfields as $category => $customfield) {
                foreach ($customfield as $field) {
                    if (!$field->configurable()) {
                        continue;
                    }
                    $this->configurable[strtolower(last(explode('\\', $category)))][] = $field->getName();
                }
            }
        }
        return !is_null($group) ? array_get($this->configurable, $group, []) : $this->configurable;
    }
16587
public function destroy(Group $group)
    {
        $ml = $this->guiHandler->getManialink($group, $this);
        if ($ml) {
            $this->guiHandler->addToHide($ml, $this);
        }
    }
351478
public function clean($group = null)
	{
		$success = true;

		if (is_dir($this->directory . DS . $group))
		{
			$this->engine->setOption('cacheDir', $this->directory . DS . $group . DS);
			$success = $this->engine->clean($group, 'group');
		}

		if ($success == true)
		{
			return $success;
		}

		return false;
	}
98565
public function removeGroup(GroupInterface $group)
    {
        if ($this->hasGroup($group)) {
            $this->groups->removeElement($group);
        }

        return $this;
    }
766855
public function clean($group = null)
	{
		$prefix = $this->options['hash'] . '-cache-' . $group . '-';

		foreach ($this->data as $key => $value)
		{
			if (substr($key, 0, strlen($prefix)) == $prefix)
			{
				unset($this->data[$key]);
			}
		}

		return true;
	}