@param string $group

@return \Guzzle\Service\Builder\ServiceBuilder
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);
    }
59259
protected function createConfigGroupForm(ConfigGroup $group = null)
    {
        $formBuilder = $this->createFormBuilder();
        if ($group) {
            $values = $this->container->get('admin.configuration.configvalue_manager')->getRepository()->findByConfigGroupId($group->getId());
            foreach ($values as $configValue) {
                $sub = $this->container->get('form.factory')->createNamedBuilder(
                    str_replace(':', '___', $configValue->getPath()),
                    'admin_configuration_configvalue_'.$configValue->getConfigType()->getFormType(),
                    $configValue
                );
                $formBuilder->add($sub);
            }
        }

        return $formBuilder->getForm();
    }
886144
public function init($group)
	{
		// Lets validate if the post type exists and if so, continue.
		$postTypeModel = $this->getPostType($group);
		if(!$postTypeModel){
    		$errorMessages = 'You are not authorized to do this.';
    		return $this->abort($errorMessages);
    	}

		// Receiving the current data of the group
		$config = NikuConfig::where('group', '=', $group)
			->get()
			->keyBy('option_name')
			->toArray();

		$templates = $postTypeModel->view;

		// Appending the key added in the config to the array
        // so we can use it very easliy in the component.
        foreach($templates as $key => $template){

	    	if(!empty($template['customFields'])){

	    		// For each custom fields
	            foreach($template['customFields'] as $ckey => $customField){
	                $templates[$key]['customFields'][$ckey]['id'] = $ckey;

	                // Adding the values to the result
	            	if(!empty($config[$ckey])){
	            		$templates[$key]['customFields'][$ckey]['value'] = $config[$ckey]['option_value'];
	            	}
	            }
	        }
	    }

		$collection = collect([
			'config' => $this->getConfig($postTypeModel),
			'templates' => $templates,
		]);

		return response()->json($collection);
	}
182089
public function setGroup($group)
    {
        if (!empty($group)) {
            $this->query['group'] = $group;
        } else {
            unset($this->query['group']);
        }
        return $this;
    }
1193326
public function createGroup(Api\GroupCreate $group)
    {
        $json = Serialize::group($group);
        $result = $this->_post($this->_url('/groups'), $json);
        return Deserialize::groupResponse($result);
    }
659538
public function tenantsWithGroup(string $group = null): Collection
    {
        return $this->tenants->filter(function (Tenant $tenant) use ($group) {
            return $tenant->group === $group;
        });
    }
661942
public function setGroup($group)
    {
        //Argument 1 must be a string or array
        Argument::i()->test(1, 'string', 'array');
            
        if (is_string($group)) {
            $group = array($group);
        }
        
        $this->group = $group;
        return $this;
    }
641116
public function getServiceNamesByGroup($group, $only_active = false)
    {
        $types = $this->getServiceTypeNames($group);

        return $this->getServiceNamesByType($types, $only_active);
    }
408258
public function group($group = null) {
		if ($group) {
			$this->_config['group'] = $group;
			return $this;
		}
		if ($group === false) {
			$this->_config['group'] = null;
			return $this;
		}
		return $this->_config['group'];
	}
509334
public function cacheFlushByGroup($group)
    {
        $group = StringHelper::toUnderscoreVariable(get_called_class()) . '/' . StringHelper::toUnderscoreVariable($group);
        $this->getCache()->setGroup($group)->clear();
        
        return $this;
    }
541413
public function render(Group $group)
    {
        if ($group->isAuthorized()) {
            $items = [];
            foreach ($group->getItems() as $item) {
                $items[] = (new IlluminateItemRenderer($this->factory))->render($item);
            }

            return $this->factory->make($this->view, [
                'group' => $group,
                'items' => $items
            ])->render();
        }
    }
697687
public function findByGroup(Group $group)
    {
        return $this->createQueryBuilder('o')
            ->select('o.id', 'o.name')
            ->join('o.groups', 'g')
            ->where('g = :group')
            ->groupBy('o.id')
            ->setParameter(':group', $group)
            ->getQuery()
            ->getArrayResult();
    }
1038319
public function group($group)
    {
        if ($group instanceof Closure) {
            $callback = $group;
            $group = new Group();
            is_callable('Closure::bind') && $callback = $callback->bindTo($group, $group);
            $callback($group);
        }

        if ($group instanceof Group) {
            $group = $group->getGroup();
        }

        $this->pipeline[] = ['$group' => $group];

        return $this;
    }
1154207
public static function getInstance($group)
	{
		static $instances;

		// Set instances array
		if (!isset($instances))
		{
			$instances = array();
		}

		// Do we have a matching instance?
		if (!isset($instances[$group]))
		{
			// If an ID is passed, check for a match in existing instances
			if (is_numeric($group))
			{
				foreach ($instances as $instance)
				{
					if ($instance && $instance->get('gidNumber') == $group)
					{
						// Match found
						return $instance;
						break;
					}
				}
			}

			// No matches
			// Create group object
			$hzg = new self();

			if ($hzg->read($group) === false)
			{
				$instances[$group] = false;
			}
			else
			{
				$instances[$group] = $hzg;
			}
		}

		// Return instance
		return $instances[$group];
	}
271873
public function group($group)
    {
        $group = $this->prepareNames(func_get_args(), false);
        $this->group = $group;
        return $this;
    }
169842
protected function createManialink(Group $group)
    {
        $className = $this->className;

        $manialink = new $className(
            $this,
            $group,
            $this->translationsHelper,
            $this->windowFrameFactory,
            $this->name,
            $this->sizeX,
            $this->sizeY,
            $this->posX,
            $this->posY
        );

        $actionId = $this->actionFactory->createManialinkAction(
            $manialink,
            [$this, 'closeManialink'],
            [],
            true
        );

        $manialink->setCloseAction($actionId);

        return $manialink;
    }
947876
public function create($group)
    {
        if (is_string($group)) {
            $group = $this->groupFactory->createForPlayer($group);
        } else {
            if (is_array($group)) {
                $group = $this->groupFactory->createForPlayers($group);
            }
        }

        if (!is_null($this->guiHandler->getManialink($group, $this))) {
            $this->update($group);

            return $group;
        }


        $ml = $this->createManialink($group);
        $this->guiHandler->addToDisplay($ml, $this);

        $this->createContent($ml);
        $this->updateContent($ml);

        return $group;
    }