@param string $group

@return DefaultRuleResult[]
966412
public function getRuleResultsByGroup($group)
    {
        $results = [];
        foreach ($this->getRuleResults() as $rule => $ruleResult) {
            if (in_array($group, $ruleResult->getGroups())) {
                $results[$rule] = $ruleResult;
            }
        }

        return $results;
    }
62951
public function get_settings( $group ) {
		if ( ! isset( $this->_group_priority[ $group ], $this->_groups[ $this->_group_priority[ $group ] ] ) ) {
			return $this->apply_filters( 'get_settings', [], $group );
		}

		return $this->apply_filters( 'get_settings', $this->_groups[ $this->_group_priority[ $group ] ][ $group ], $group );
	}
264434
public function filter($data, $group = null)
	{
		// Make sure there is a valid Form XML document.
		if (!($this->xml instanceof \SimpleXMLElement))
		{
			return false;
		}

		$input = new Registry($data);
		$output = new Registry;

		// Get the fields for which to filter the data.
		$fields = $this->findFieldsByGroup($group);

		if (!$fields)
		{
			// PANIC!
			return false;
		}

		// Filter the fields.
		foreach ($fields as $field)
		{
			$name = (string) $field['name'];

			// Get the field groups for the element.
			$attrs = $field->xpath('ancestor::fields[@name]/@name');
			$groups = array_map('strval', $attrs ? $attrs : array());
			$group = implode('.', $groups);

			// Get the field value from the data input.
			if ($group)
			{
				// Filter the value if it exists.
				if ($input->exists($group . '.' . $name))
				{
					$output->set($group . '.' . $name, $this->filterField($field, $input->get($group . '.' . $name, (string) $field['default'])));
				}
			}
			else
			{
				// Filter the value if it exists.
				if ($input->exists($name))
				{
					$output->set($name, $this->filterField($field, $input->get($name, (string) $field['default'])));
				}
			}
		}

		return $output->toArray();
	}
482802
public function offsetGet($group)
    {
        if (!isset($this[$group])) {

            // Load builder from file or instantiate an empty one.
            if ($this->hasConfigFile($group)) {
                $this[$group] = $this->load($group);
            } else {
                $this[$group] = ServiceBuilder::factory(array());
            }

            // Initialize the "removed" flag.
            $this->removed[$group] = array();
        }
        return parent::offsetGet($group);
    }
27731
public function load($locale, $group, $namespace = null)
    {
        $defaults = [];

        if (empty($this->locales) || $this->isSupported($locale))
            $defaults = $this->loadPath($this->getVendorPath(), $locale, $group);

        return array_replace_recursive($defaults, parent::load($locale, $group, $namespace));
    }
731123
public static function getReasonPhraseByGroup($group)
    {
        if (!isset(self::$codeGroups[$group])) {
            $group = 0;
        }

        return self::$codeGroups[$group];
    }
66782
public static function group(Api\GroupCreate $group)
    {
        $fields = [];

        if ($group->getName() != null) {
            $fields['name'] = $group->getName();
        }

        if (!empty($group->getMembers())) {
            $fields['members'] = $group->getMembers();
        }

        if (!empty($group->getChildGroups())) {
            $fields['child_groups'] = $group->getChildGroups();
        }

        if ($group->getAutoUpdate() != null) {
            $fields['auto_update'] = Serialize::_groupAutoUpdateHelper(
                $group->getAutoUpdate()
            );
        }

        if (!empty($group->getTags())) {
            $fields['tags'] = $group->getTags();
        }

        return Serialize::_toJson($fields);
    }
302126
public static function get($key, $default = NULL, $group = NULL)
	{
		$result = $default;
		try {
			!self::classExists() or $result = self::instance($group)->get($key, $default);
		} catch (Cache_Exception $e) {
			self::exception($e);
		}

		return $result;
	}
773768
public function getServiceTypes($group = null)
    {
        ksort($this->types, SORT_NATURAL); // sort by name for display
        if (!empty($group)) {
            if (!empty($group) && !is_array($group)) {
                $group = array_map('trim', explode(',', trim($group, ',')));
            }
            $group = array_map('strtolower', (array)$group);
            $types = [];
            foreach ($this->types as $type) {
                if (in_array(strtolower($type->getGroup()), $group)) {
                    $types[$type->getName()] = $type;
                }
            }

            return $types;
        }

        return $this->types;
    }
1276653
public static function &getSelectedResource ($group)
	{
		
		// If the resource group is not set
		
		if (!isset (self::$resources[$group]) || !self::getGroupSetting ($group, 'default'))
		{
			
			// Return FALSE
			
			$bln = FALSE;
			return $bln;
			
		}
		
		// Return resource reference
		
		return self::getResource (array ($group, self::getGroupSetting ($group, 'default')));
		
	}
1016478
public function getAdminsByGroup($group)
    {
        if (!isset($this->adminGroups[$group])) {
            throw new \InvalidArgumentException(sprintf('Group "%s" not found in admin pool.', $group));
        }

        $admins = [];

        if (!isset($this->adminGroups[$group]['items'])) {
            return $admins;
        }

        foreach ($this->adminGroups[$group]['items'] as $item) {
            $admins[] = $this->getInstance($item['admin']);
        }

        return $admins;
    }
904
protected function getResponseCodeGroupRange($group) {
        switch ($group) {
            case 'informational':
                $min = 100;
                $max = 199;
                break;
            case 'success':
                $min = 200;
                $max = 299;
                break;
            case 'redirection':
                $min = 300;
                $max = 399;
                break;
            case 'client error':
                $min = 400;
                $max = 499;
                break;
            case 'server error':
                $min = 500;
                $max = 599;
                break;
            default:
                throw new InvalidArgumentException(sprintf('Invalid response code group: %s', $group));
        }

        return [
            'min' => $min,
            'max' => $max,
        ];
    }
1300447
public function getFrom($group, $locale, $default = null)
    {
        if ( ! $this->hasCollection($group))
            return $default;

        $locales = $this->getCollection($group);

        return $locales->get($locale, $default);
    }
12098
public function clear($group = null) {
        if( isset($group) )
            unset($this->settings[$group]);
        else
            $this->settings = [];

        return $this;
    }
885059
public function decodeAspiringTranslatorsGroup(Group $group)
    {
        $result = null;
        $match = null;
        if (preg_match('/^\/' . preg_quote(self::GROUPNAME_ASPIRING_TRANSLATORS, '/') . '\/(.+)$/', $group->getGroupPath(), $match)) {
            $result = $this->app->make(LocaleRepository::class)->findApproved($match[1]);
        }

        return $result;
    }
901006
public function get($group, $default = null)
    {
        $this->autoFillIfNotDone();
        if (isset($this->buildConfigs[$group])) {
            return $this->buildConfigs[$group];
        }

        return $default;
    }
936150
public function getEnabledTaxonomies($group = true)
    {
        $grouped = array();
        $ungrouped = array();
        $taxonomies = $this->taxonomies;

        if (!$taxonomies) {
            return array();
        }

        if (is_category()) {
            $taxonomies = array_filter($taxonomies, function ($item) {
                return $item !== 'category';
            });
        }

        if (is_a(get_queried_object(), 'WP_Term')) {
            $taxonomies = array_diff($taxonomies, (array)get_queried_object()->taxonomy);
        }

        foreach ($taxonomies as $key => $item) {
            $tax = get_taxonomy($item);
            $terms = get_terms($item, array(
                'hide_empty' => false
            ));

            $placement = $this->taxonomyType;
            if (is_null($placement)) {
                $placement = 'secondary';
            }

            $type = $this->taxonomyType;

            $grouped[$placement][$tax->name] = array(
                'label' => $tax->label,
                'type' => $type,
                'slug' => $item,
                'values' => $terms
            );

            $ungrouped[$tax->name] = array(
                'label' => $tax->label,
                'type' => $type,
                'values' => $terms
            );
        }

        if ($group) {
            $grouped = json_decode(json_encode($grouped));
            return $grouped;
        }

        return $ungrouped;
    }