Get the paths to publish.

@param  string $provider
@param  string $group
@return array
9368
public static function pathsToPublish( $provider = null, $group = null )
	{
		if ( $provider && $group )
		{
			if ( empty( static::$publishes[$provider] ) || empty( static::$publishGroups[$group] ) )
				return [];

			return array_intersect_key( static::$publishes[$provider], static::$publishGroups[$group] );
		}

		if ( $group && array_key_exists( $group, static::$publishGroups ) )
			return static::$publishGroups[$group];

		if ( $provider && array_key_exists( $provider, static::$publishes ) )
			return static::$publishes[$provider];

		if ( $group || $provider )
			return [];

		$paths = [];

		foreach ( static::$publishes as $class => $publish )
			$paths = array_merge( $paths, $publish );

		return $paths;
	}
786614
public static function getClientIdListByGroup($group)
    {
        if (!static::isValidGroupId($group)) {
            return array();
        }

        $data = static::select(array('uid'), array('groups' => is_array($group) ? $group : array($group)));
        $client_id_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) {
                    $client_id = Context::addressToClientId($local_ip, $local_port, $connection_id);
                    $client_id_map[$client_id] = $client_id;
                }
            }
        }
        return $client_id_map;
    }
421191
protected function chgrpRecurse($path, $group) {

        if (!file_exists($path)) {
            return false;
        }

        if (!is_dir($path)) {
            return $this->chgrpReal($path, $group);
        }

        $result = $this->chgrpReal($path, $group);

        $allFiles = $this->getFileManager()->getFileList($path);
        foreach ($allFiles as $item) {
            $result &= $this->chgrpRecurse($path . Utils\Util::getSeparator() . $item, $group);
        }

        return (bool) $result;
    }
854618
public function scripts($group, array $assets = [], $prefix = null)
    {
        $scripts = [];

        if (!isset($assets[$group]) || count($assets[$group]) == 0) {
            return $scripts;
        }

        is_null($prefix) || $this->path = rtrim($prefix, '/');

        foreach ($this->resolver->arrange($assets[$group]) as $data) {
            $path = $this->getAssetSourceUrl($data['source']);

            !starts_with($path, '/') && $group !== 'inline' ? $path = '/' . $path : null;

            array_push($scripts, $path);
        }
        return $scripts;
    }
604708
protected function findInPaths(array $paths, $group, $mode = null, $exists = false)
    {
        $items = [];

        foreach ($paths as $path) {
            if ($this->fs->exists($file = "{$path}/{$group}.php")) {
                if ($exists) return true;

                $items = array_merge_recursive($this->fs->getRequire($file), $items);
            }

            if ($mode and $this->fs->exists($file = "{$path}/{$mode}/{$group}.php")) {
                if ($exists) return true;

                $items = array_merge_recursive($this->fs->getRequire($file), $items);
            }
        }

        return $items;
    }
367993
protected function group($group)
    {
        return $this->dispatcher->run($group, $this->assets, $this->path);
    }
1001654
public function ToString( $provider = null )
	{
		$result = "";
		if ( $this->S ) $result .= "-";
		if ( $this->IsLocal )
			$result .= $this->Value->format("--m-d");
		else
			if ( $this->Value->getOffset() == 0 )
				$result .= $this->Value->format("--m-d\Z");
			else
				$result .= $this->Value->format("--m-dP");

		return $result;
	}
1196771
def group_path(cls, project, group):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/groups/{group}", project=project, group=group
        )
1329744
protected function GetAdminGroups($group = "")
	{
		$keys = array_keys($this->GetAdminModulesList());
		if ($group != "")
		{
			if (in_array($group, $keys))
			{
				$keys = array($group);
			}
			else
			{
				$keys = array();
			}
		}
		
		$arr = new ArrayDataset($keys, "name");
		return $arr->getIterator();
	}
1243975
public function paths(Source $source = null) {
		if ($source) {
			$this->applyStrategy($source);
		}
		return $this->_paths;
	}
940390
protected function getDaxkoLocations($group = FALSE) {
    $locations_config = $this->daxkoConfig->get('locations');
    $locations = $this->parseGrouppedSetting($locations_config, $group);

    if (!$group) {
      return $locations;
    }

    $numericalKeyedLocations = [];
    foreach ($locations as $label => $value) {
      $numericalKeyedLocations[] = ['value' => $value, 'label' => $label];
    }

    return $numericalKeyedLocations;
  }
682033
public function findByGroup(Group $group)
    {
        $query = $this->createQueryBuilder('a')
                      ->innerjoin('a.groups', 'g')
                      ->where('g.id = :group')
                      ->setParameter('group', $group->getId());
        return $query->getQuery()->getResult();
     }
821814
public function group($group = null) {
		if (is_null($group))
			return $this->discard('query.group');
	
		if ($group instanceof Column) {
			//get referred attribute
			$map = $this->entityProfile->getPropertyMap();
			if (!in_array($group->getName(), $map))
				throw new \InvalidArgumentException(sprintf("Column '%s' is unknown for class '%s'", $group->getName(), $this->entityProfile->getReflectionClass()->getName()));
			$name = array_flip($map)[$group->getName()];
		}
		elseif ($group instanceof Attr)
			$name = $group->getName();
		elseif (is_string($group))
			$name = $group;
		else
			throw new \InvalidArgumentException("Group must be specified through an Attr instance or a valid property name");
		
		//get custom type (if any)
		$type = $group->getType();
		if (isset($type))
			return $this->merge(['query.group' => $group->getName() . ':' . $type]);
		return $this->merge(['query.group' => $group->getName()]);
	}
221561
public static function get_files_to_publish($type = null)
    {
        if (!isset(static::$publishes[ static::class ])) {
            return [];
        }

        if ($type !== null) {
            return static::$publishes[ static::class ][ $type ];
        }

        $iterator = new RecursiveIteratorIterator(
            new RecursiveArrayIterator(static::$publishes[ static::class ])
        );

        return \iterator_to_array($iterator);
    }
909577
public function load($mode, $group, $namespace = null)
    {
        // Lets find where the paths are
        $paths = $this->getPaths($namespace);

        if (empty($paths)) return [];

        return $this->findInPaths($paths, $group, $mode);
    }
760163
protected function publishes(array $paths, $group = null)
	{
		$class = get_class($this);

		if ( ! array_key_exists($class, static::$publishes))
		{
			static::$publishes[$class] = [];
		}

		static::$publishes[$class] = array_merge(static::$publishes[$class], $paths);

		if ($group)
		{
			static::$publishGroups[$group] = $paths;
		}
	}
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;
	}