Returns list with all indexed partitions.
776398
def all(self):
        
        partitions = []
        for partition in self.index.searcher().documents():
            partitions.append(
                PartitionSearchResult(dataset_vid=partition['dataset_vid'], vid=partition['vid'], score=1))
        return partitions
1105083
def get_partitions(self, db_name, tbl_name, max_parts):
    
    self.send_get_partitions(db_name, tbl_name, max_parts)
    return self.recv_get_partitions()
1195029
public String[] list() throws IOException {
    FileStatus[] fileStatus =
        fs.listStatus(directory, LuceneIndexFileNameFilter.getFilter());
    String[] result = new String[fileStatus.length];
    for (int i = 0; i < fileStatus.length; i++) {
      result[i] = fileStatus[i].getPath().getName();
    }
    return result;
  }
678934
def _listChunks(self):
        
        chunks = []
        for fileName in os.listdir(self.dataDir):
            index = ChunkedFileStore._fileNameToChunkIndex(fileName)
            if index is not None:
                chunks.append(index)
        return sorted(chunks)
552117
def getAll(self):
        """"""
        if self._jconf is not None:
            return [(elem._1(), elem._2()) for elem in self._jconf.getAll()]
        else:
            return self._conf.items()
920471
public static <T> List<Partition<T>> getPartitions(List<T> list, Integer... elementCounts) {
		int totalCount = 0;
		for (Integer elements : elementCounts)
			totalCount += elements;
		if (totalCount != list.size())
			return null;
		Integer[] cuts = new Integer[elementCounts.length - 1];
		for (int i = 0; i < elementCounts.length - 1; i++)
			cuts[i] = elementCounts[i] + (i == 0 ? 0 : cuts[i - 1]);
		List<Partition<T>> result = new ArrayList<>();
		Iterator<List<T>> permutations = getPermutations(list);
		while (permutations.hasNext()) {
			Partition<T> part = new Partition<>(list);
			List<List<T>> dividedList = divideListPos(permutations.next(), cuts);
			for (List<T> l : dividedList)
				part.addSubset(l);
			result.add(part);
		}
		return result;
	}
284149
public List<Partition> getPartitionsFromDataset() throws IOException{
    try (AutoReturnableObject<IMetaStoreClient> client = getClientPool().getClient()) {
      List<Partition> partitions =
          HiveUtils.getPartitions(client.get(), getTable(), Optional.<String>absent());
      return sortPartitions(partitions);
    }
  }
281521
private static List<Integer> getUsedIndexes() {
        File folder = getMotdFileOutputStreamProvider().getMOTDFolder();
        List<Integer> res = new ArrayList<>();

        for (File file : folder.listFiles()) {
            if (file.isFile() && file.getName().matches(getRegexToMatchSerializedMOTs())) {
                res.add(getIndexFromFilename(file.getName()));
            }
        }

        return res;
    }
652625
public java.util.List<Disk> getDisks() {
        if (disks == null) {
            disks = new com.amazonaws.internal.SdkInternalList<Disk>();
        }
        return disks;
    }
30625
def partitions(self):
        
        # We do here some lazy loading.
        if not self._partitions:
            self._partitions = PartitionManager(self)
        return self._partitions
114930
public long[] getSitesForPartitionsAsArray(int[] partitions) {
        ArrayList<Long> all_sites = new ArrayList<Long>();
        for (int p : partitions) {
            List<Long> sites = getSitesForPartition(p);
            for (long site : sites)
            {
                all_sites.add(site);
            }
        }
        return longListToArray(all_sites);
    }
976348
def outputs_of(self, partition_index):
        
        partition = self.partition[partition_index]
        outputs = set(partition).intersection(self.output_indices)
        return tuple(sorted(outputs))
1314813
public static List<PartitionIDRange> getGlobalRange(final int partitionBits) {
        Preconditions.checkArgument(partitionBits>=0 && partitionBits<(Integer.SIZE-1),"Invalid partition bits: %s",partitionBits);
        final int partitionIdBound = (1 << (partitionBits));
        return ImmutableList.of(new PartitionIDRange(0, partitionIdBound, partitionIdBound));
    }
45087
public String[] getPartitionKeys(String location, Job job) throws IOException
    {
        if (!usePartitionFilter)
            return null;
        List<ColumnDef> indexes = getIndexes();
        String[] partitionKeys = new String[indexes.size()];
        for (int i = 0; i < indexes.size(); i++)
        {
            partitionKeys[i] = new String(indexes.get(i).getName());
        }
        return partitionKeys;
    }
348408
def list_():
    '''
    

    '''
    ret = []
    states_path = _states_path()
    if not os.path.isdir(states_path):
        return ret

    for state in os.listdir(states_path):
        if state.endswith(('-pkgs.yml', '-reps.yml')):
            # Remove the suffix, as both share the same size
            ret.append(state[:-9])
    return sorted(set(ret))
526599
def partitions(self):
        
        if not self._partitions:
            self._partitions = [Partition(d, self)
                                for d in self.device.children]
        return self._partitions
32835
def list(self):
        
        backups = []
        for d in glob(join(self.backup_directory, '*')):
            backups.append(WorkspaceBackup.from_path(d))
        backups.sort(key=lambda b: b.lastmod, reverse=True)
        return backups