Gets all entries of a space.
347311
def all(self, query=None):
        

        if query is None:
            query = {}

        if self.content_type_id is not None:
            query['content_type'] = self.content_type_id

        normalize_select(query)

        return super(EntriesProxy, self).all(query=query)
477663
function readEntries(buf) {
  const entries = {}

  let off = 0

  // Entry collection is terminated by 0x08 byte
  for (; buf.readUInt8(off) != 0x08;) {
    let [key, val, size] = readEntry(buf.slice(off))

    entries[key] = val

    off += size
  }

  return [entries, off + 1]
}
532005
def _get_spaces(self):
        
        guid = self.api.config.get_organization_guid()
        uri = '/v2/organizations/%s/spaces' % (guid)
        return self.api.get(uri)
371554
def findAllByBiSearch(self, strSeq) :
		""""""
		arr = self.encode(strSeq)
		lst = []
		self._dichFind(arr[0], self, 0, lst)
		return lst
1288585
@Override
    public Iterator<String> getSpaces() {
        DuracloudUserDetails user = getCurrentUserDetails();
        if (isAdmin(user)) {
            return targetProvider.getSpaces();
        }

        waitForCache();

        List<String> spaces = new ArrayList<String>();
        for (String space : spaceACLMap.keySet()) {
            Map<String, AclType> acls = spaceACLMap.get(space);
            if (userHasAccess(user, acls) && !spaces.contains(space)) {
                spaces.add(space);
            }
        }

        Collections.sort(spaces);
        return spaces.iterator();
    }
622569
def get_entries(dir, subfolder)
      base = site.in_source_dir(dir, subfolder)
      return [] unless File.exist?(base)

      entries = Dir.chdir(base) { filter_entries(Dir["**/*"], base) }
      entries.delete_if { |e| File.directory?(site.in_source_dir(base, e)) }
    end
897785
public static String getSpaces( int SpacesCount ) {
		//
		if ( SpacesCount < 0 ) return "?";
		//
		String Info = "";
		//
		for ( int K = 1; K <= SpacesCount; K ++ ) {
			Info += " ";
		}
		//
		//
		return Info;
	}
109916
def _get_all_slots(self):
        """"""
        all_slots = (getattr(cls, '__slots__', [])
                         for cls in self.__class__.__mro__)
        return set(slot for slots in all_slots for slot in slots)
552829
function getDirEntries(ifdHex) {
        var entries = [],
            offset = 0;

        while (offset + 24 <= ifdHex.length) {
            entries.push(ifdHex.slice(offset, offset + 24));
            offset += 24;
        }

        return entries;
    }
42743
def get_entries(path):
    """"""
    dirs, files = [], []
    for entry in os.listdir(path):
        # Categorize entry as directory or file.
        if os.path.isdir(os.path.join(path, entry)):
            dirs.append(entry)
        else:
            files.append(entry)
    dirs.sort()
    files.sort()
    return dirs, files
1128090
function getEntries(config) {
    assert_usage(config && config.entry);
    if( config.entry.constructor===String ) {
        return {main: [config.entry]};
    }
    if( config.entry.constructor===Array ) {
        return {main: [...config.entry]};
    }
    if( config.entry.constructor===Object ) {
        const entries = {};
        Object.entries(config.entry)
        .forEach(([entryName, entryFiles]) => {
            if( entryFiles && entryFiles.constructor===Array ) {
                entries[entryName] = [...entryFiles];
                return;
            }
            if( entryFiles && entryFiles.constructor===String ) {
                entries[entryName] = [entryFiles];
                return;
            }
            assert_usage(false, entryFiles, entryName);
        });
        return entries;
    }
    assert_usage(false);
}
842303
def all_unstable_entries(self):
        
        all_stable_entries = self.all_stable_entries
        return [e for e in self.entries if e not in all_stable_entries]
335302
def get_all():
    '''
    
    '''
    ret = set()
    lines = glob.glob('/etc/init.d/*')
    for line in lines:
        service = line.split('/etc/init.d/')[1]
        # Remove README.  If it's an enabled service, it will be added back in.
        if service != 'README':
            ret.add(service)
    return sorted(ret | set(get_enabled()))
915795
def _entries_sorted(self):
        """"""
        return sorted(self.entries.values(), key=lambda e: (e.path, e.stage))
1115305
private Iterator<String> getSpaceListing(final StorageProvider store,
                                             final String spaceId)
        throws TaskExecutionFailedException {
        try {
            return new Retrier().execute(new Retriable() {
                @Override
                public Iterator<String> retry() throws Exception {
                    // The actual method being executed
                    return store.getSpaceContents(spaceId, null);
                }
            });
        } catch (Exception e) {
            String msg = "Error attempting to retrieve space listing: " +
                         e.getMessage();
            throw new DuplicationTaskExecutionFailedException(
                buildFailureMessage(msg), e);
        }
    }
406747
function getEntries(config, context) {
  var filter = config.filter && new RegExp(config.filter)
  var files = context.entries.length > 0
    ? context.entries
    : glob.sync(config.$path.source.client + '/**/index.scss')
  files = files
    .filter(file => !/node_modules/.test(file))
    .filter(file => !filter || !filter.test(file))
    .filter(file => /index\.scss$/.test(file))
  var entries = {}
  files.forEach(file => {
    var name = path.relative(config.$path.source.client, file).slice(0, -5)
    entries[name] = file
  })
  return entries
}
253580
public Set<String> entries() {
        Set<String> es = this.entries;
        if (es == null) {
            // lazily scan the entries
            this.entries = scan();
        }
        return this.entries;
    }