Lists the storage accounts available under the current subscription.

@return ListStorageServicesResult

@see http://msdn.microsoft.com/en-us/library/windowsazure/ee460787.aspx
334231
public function listStorageServices()
    {
        $context = new HttpCallContext();
        $context->setMethod(Resources::HTTP_GET);
        $context->setPath($this->_getStorageServicePath());
        $context->addStatusCode(Resources::STATUS_OK);

        $response = $this->sendHttpContext($context);
        $serialized = $this->dataSerializer->unserialize($response->getBody());

        return ListStorageServicesResult::create($serialized);
    }
1117154
public function listFiles()
    {
        $innerIterator = new \FilesystemIterator($this->getAbsolutePath());
        $innerIterator->setInfoClass(get_class($this));
        $iterator = new FileFilterType($innerIterator, 'file');
        return $iterator;
    }
1177129
public function listBuckets()
    {
        $buckets = [];

        $response = $this->generateAuthenticatedClient([
            'accountId' => $this->accountId,
        ])->request('POST', '/b2_list_buckets');

        foreach ($response['buckets'] as $bucket) {
            $buckets[] = new Bucket($bucket['bucketId'], $bucket['bucketName'], $bucket['bucketType']);
        }

        return $buckets;
    }
306214
public function getStoragePlugins()
    {
        if (null === $this->storagePlugins) {
            $this->setStoragePlugins(new Storage\PluginManager());
        }
        return $this->storagePlugins;
    }
823314
public function getAll(){
        $rest = $this->getService( self::API_STORAGE_DISK);
        $rest->GET();

        return $rest->getResultAsArray( models\Storage\StorageDisk::class);
    }
1070209
def list_storages(self):
        '''
        '''
        # Filter out any storages used by xbmcswift2 so caller doesn't corrupt
        # them.
        return [name for name in os.listdir(self.storage_path)
                if not name.startswith('.')]
1226580
def GetAccounts(self):
    
    selector = {
        'fields': ['CustomerId', 'CanManageClients']
    }

    accounts = self.client.GetService('ManagedCustomerService').get(selector)

    return accounts['entries']
1283590
public function getLists()
    {
        if(!$this->isPropertyAvailable('Lists')){
            $this->setProperty("Lists", new ListCollection($this->getContext(),new ResourcePathEntity($this->getContext(),$this->getResourcePath(),"Lists")));
        }
        return $this->getProperty("Lists");
    }
787029
public function storageNames()
    {
        $names = [];

        foreach ($this->storages as $name=>$storage) {
            $names[$name] = true;
        }

        foreach ($this->bindings as $name=>$binding) {
            $names[$name] = true;
        }

        return new StringList(array_keys($names));
    }
1053794
public function getAvailableLists()
    {
        if (self::$cache !== null) {
            return array_keys(self::$cache);
        }

        $lists = array();
        foreach (self::$paths as $path) {
            $files = scandir($path);
            foreach ($files as $file) {
                if (substr($file, -7) == '.sqlite') {
                    $name = strtolower(substr($file, 0, -7));
                    if (isset($lists[$name])) {
                        ; /// @TODO: log a warning
                    } else {
                        $lists[$name] = $path . DIRECTORY_SEPARATOR . $file;
                    }
                }
            }
        }

        // Create a regexp pattern for the policy
        // and filter the lists according to that policy.
        $policy = self::compilePolicy(
            explode(' ', $this->parseString('policy', ''))
        );
        $lists = self::filterLists($lists, $policy);

        self::$cache = $lists;
        return array_keys($lists);
    }
301120
protected function getFileStorage()
    {
        if (!$this->storageService) {
            $this->storageService = $this->getServiceManager()->get(\tao_models_classes_service_FileStorage::SERVICE_ID);
        }
        return $this->storageService;
    }
1131349
public function get_accounts(){
		static $ga_accounts = null;
		if( !is_null($ga_accounts) ){
			return $ga_accounts;
		}
		$ga_accounts = array();
		if( $this->ga ){
			try{
				$accounts = $this->ga->management_accounts->listManagementAccounts();
				if( count($accounts->getItems()) > 0 ){
					$ga_accounts = $accounts;
				}
			}catch (\Exception $e){
				// Do nothing.
				error_log($e->getMessage(), $e->getCode());
			}
		}
		return $ga_accounts;
	}
834223
public function getSubCatList()
    {
        if ($this->_oSubCatList === null) {
            $this->_oSubCatList = [];
            if ($this->hasVisibleSubCats()) {
                return $this->_oSubCatList;
            }
        }

        return $this->_oSubCatList;
    }
894811
public function getListSorting()
    {
        $sorting = parent::getListSorting();
        if (isset($sorting["oxorder"]["oxbilllname"])) {
            $this->_blDesc = false;
        }

        return $sorting;
    }
178092
public function getList()
    {
        /** @var Select|QueryObjectInterface $query */
        $query = $this->getRepository()->find();
        $this->getFilters()->apply($query);
        $this->getPagination()->setTotal($query->count());
        $query->order($this->getOrder());
        $query->limit(
            $this->getPagination()->rowsPerPage,
            $this->getPagination()->offset
        );
        return $query->all();
    }
468566
public function getAccounts()
    {
        $resource = 'accounts';

        $response = $this->sendGetRequest($resource);
        $accountsResponse = new Models\GetAccountsResponse($response);
        return $accountsResponse->getAccounts();
    }
140271
public function getAccounts()
    {
        $accounts = [];
        $groups   = $this->rpc->query("listAccounts", [0]);
        foreach($groups as $account => $balance) {
            $accounts[] = $account;
        }
        
        return $accounts;
    }