Retrieve all options/values.

@param null|string $group
@return array
173726
public function all($group = self::DEFAULT_GROUP) {
        if( $group == self::DEFAULT_GROUP )
            return $this->settings;

        return isset($this->settings[$group]) ? $this->settings[$group] : [];
    }
473697
protected function getSettingsByGroup($group)
    {
        $result = array();
        foreach ($this->getKeyInfo() as $key => $keyInfo) {
            if ($keyInfo['group'] === $group) {
                $result[$key] = $this->get($key);
            }
        }
        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;
    }
929654
public function retrieve_group_ids(string $id_option = null, string $id_group): ?array
  {
    return $this->_retrieve_ids($id_option, null, $id_group);
  }
1374377
public function get($key, $group = self::DEFAULT_GROUP, $default = null) {
        return isset($this->settings[$group][$key]) ? $this->settings[$group][$key] : $default;
    }
349068
public function getGroup ($groupID)
    {
        $groups = $this->getAllGroups();
        
        foreach ($groups as $group) {
            if ($group->getID() == $groupID) {
                return $group;
            }
        }
        
        return null;
    }
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;
    }
34149
public static function getUidListByGroup($group)
    {
        if (!static::isValidGroupId($group)) {
            return array();
        }

        $group = is_array($group) ? $group : array($group);
        $data = static::select(array('uid'), array('groups' => $group));
        $uid_map = array();
        foreach ($data as $local_ip => $buffer_array) {
            foreach ($buffer_array as $local_port => $items) {
                //$items = ['connection_id'=>['uid'=>x, 'group'=>[x,x..], 'session'=>[..]], 'client_id'=>[..], ..];
                foreach ($items as $connection_id => $info) {
                    if (!empty($info['uid'])) {
                        $uid_map[$info['uid']] = $info['uid'];
                    }
                }
            }
        }
        return $uid_map;
    }
207614
public function groupBy($group=null)
    {
        $group = LambdaUtils::toSelectCallable($group);

        $result = new ObjectArray(array());
        if($this instanceof ObjectArray)
        {
            $result = $this->newInstance();
        }

        foreach($this as $record)
        {
            $key = call_user_func($group, $record);

            $data = array();
            if($this->__converter instanceof IListConverter)
            {
                $data = $this->newConverterInstance();
            }
            $newitemtype = new ArrayList($data);

            $result->get($key, $newitemtype, true)->add($record);
        }

        return $result;
    }
398052
public function getValues($fieldset = null, $group = null)
    {
        $data = [];

        foreach ($this->getFields($fieldset, $group) as $name => $field) {
            FormHelper::setByPath($data, $name, $field->getRawValue());
        }

        return $data;
    }
645896
public function formProperties(array $group = null)
    {
        if (!key_exists(self::DATA_SOURCE_METADATA, array_flip($this->dataSources())) ||
            !$this->widgetMetadata()) {
            return iterator_to_array($this->form()->formProperties());
        }

        $propertyIdentPattern = '%1$s[%2$s]';
        $entry                = null;

        try {
            $store = $this->storageProperty();
        } catch (\Exception $e) {
            $store = null;
        }

        if ($store) {
            $entry = $this->obj()[$store->ident()];
            if (is_string($entry)) {
                $entry = $store->parseVal($entry);
            }
        }

        $props = $this->widgetMetadata()['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);
        }

        $out = [];

        foreach ($props as $propertyIdent => $propertyMetadata) {
            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))
                ));
            }

            if ($store) {
                $propertyMetadata['input_name'] = sprintf(
                    $propertyIdentPattern,
                    $store['input_name'] ?: $store->ident(),
                    $propertyIdent
                );
            }

            if (!empty($entry) && isset($entry[$propertyIdent])) {
                $val = $entry[$propertyIdent];

                $propertyMetadata['property_val'] = $val;
            }

            $formProperty = $this->form()->getOrCreateFormProperty($propertyIdent, $propertyMetadata);

            if (!$formProperty->hidden()) {
                $out[$propertyIdent] = $formProperty;
            }
        }

        return $out;
    }
946733
public function getAssets($group='head',$type=null) {
		$assets = array();
		if (!isset($this->assets[$group]))
			return $assets;
		$types = array_keys($this->assets[$group]);
		foreach($types as $asset_type) {
			if ($type && $type!=$asset_type)
				continue;
			krsort($this->assets[$group][$asset_type]);
			foreach($this->assets[$group][$asset_type] as $prio_set)
				foreach($prio_set as $asset) {
					if ($asset['origin']=='inline')
						$assets[$asset_type][$asset['data']] = $asset;
					else
						$assets[$asset_type][$asset['path']] = $asset;
				}
			$assets[$asset_type] = array_values($assets[$asset_type]);
		}
		return $assets;
	}
524418
public function retrieveGroup($group)
    {
        $result = array();

        foreach (Profiler::$_samples as $record) {
            if ($record[3] == $group) {
                $result[] = $record;
            }
        }

        return $result;
    }
190402
public function getField($name, $group = '')
    {
        if ($group) {
            $name = $group . '/' . $name;
        }

        return isset($this->fields[$name]) ? $this->fields[$name] : null;
    }
1320713
public function group($group = null)
    {
        if ($group !== null) {
            $this->_group = $group;
        }
        return $this->_group;
    }
898869
public function serviceGroup($group)
	{
		# Check if empty
		$group = intval($group);
		if(empty($group))
		{
			return array();
		}
		
		$json = $this->service('group', $group);
		return $json;
	}
603921
protected function getBuildConfig($group)
    {
        if (!$this->buildRepository || !$this->checkBuilds) {
            return null;
        }

        if (!$this->buildRepository->has($group)) {
            return null;
        }

        $config = $this->buildRepository->getOrFail($group);

        $config->target();

        if (!$this->mergeOption(self::CHECK_COMPILED_FILE_EXISTS, $config->managerOptions())) {
            return $config;
        }

        if (!$this->buildRepository->compiledFileExists($config)) {
            return null;
        }

        return $config;
    }