Receives all added log entries.

@return Log entries to write
765997
private List<Task> receiveTasks() {
		synchronized (mutex) {
			if (tasks.isEmpty()) {
				return Collections.emptyList();
			} else {
				List<Task> currentTasks = tasks;
				tasks = new ArrayList<Task>();
				return currentTasks;
			}
		}
	}
681702
public java.util.List<String> getEnableLogTypes() {
        if (enableLogTypes == null) {
            enableLogTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return enableLogTypes;
    }
600317
@SuppressWarnings("unchecked")
  @Deprecated
  public final List<E> getEntries() {
    List<E> result = new ArrayList<>(numEntries);
    for(Entry entry : entries) {
      if(entry != null) {
        result.add((E) entry);
      }
    }
    return result;
  }
872829
public List<Entry> getEntries() {
		if(_sortedEntries == null) {
			this._sortedEntries = Lists.newArrayListWithCapacity(entries.size());
			for(Map.Entry<Term, Entry> e:entries.entrySet())
				this._sortedEntries.add(e.getValue());
			Collections.sort(this._sortedEntries);
		}
		return _sortedEntries;
	}
246603
public synchronized Collection<T> getAllChannels()
    {
        Collection<T> allChannels = new ArrayList<T>();
        allChannels.addAll(this.channels);
        allChannels.addAll(this.channelsWithId.values());
        return allChannels;
    }
709623
public List<T> getResults() {
        return values().stream().filter(rsp -> rsp.wasReceived() && rsp.getValue() != null)
          .collect(() -> new ArrayList<>(size()), (list,rsp) -> list.add(rsp.getValue()), (l,r) -> {});
    }
972980
private void writeLogEntries(Iterable<LogEntry> logEntries, WriteOption... writeOptions) {
    switch (this.writeSynchronicity) {
      case SYNC:
        get(writeAsync(logEntries, writeOptions));
        break;

      case ASYNC:
      default:
        final ApiFuture<Void> writeFuture = writeAsync(logEntries, writeOptions);
        final Object pendingKey = new Object();
        pendingWrites.put(pendingKey, writeFuture);
        ApiFutures.addCallback(
            writeFuture,
            new ApiFutureCallback<Void>() {
              private void removeFromPending() {
                pendingWrites.remove(pendingKey);
              }

              @Override
              public void onSuccess(Void v) {
                removeFromPending();
              }

              @Override
              public void onFailure(Throwable t) {
                try {
                  Exception ex = t instanceof Exception ? (Exception) t : new Exception(t);
                  throw new RuntimeException(ex);
                } finally {
                  removeFromPending();
                }
              }
            });
        break;
    }
  }
1016184
public List<T> getAll() {
		List<T> result = new ArrayList<T>();
		if (nodes != null)
			for(Node element : nodes) 
				result.add(getCachedOrNewRepresentation(element));
		return result;
	}
	
	public int size() {
		return nodes.size();
	}
	
	public T get(int index) {
		return getCachedOrNewRepresentation(nodes.get(index));
	}
		
	public Iterator<T> iterator() {
		return getAll().iterator();
	}
}
783277
public Log[] getChildren() {
        Collection copy;

        synchronized (mChildren) {
            copy = new ArrayList(mChildren.size());
            Iterator it = mChildren.iterator();
            while (it.hasNext()) {
                Log child = (Log)((WeakReference)it.next()).get();
                if (child == null) {
                    it.remove();
                }
                else {
                    copy.add(child);
                }
            }
        }

        return (Log[])copy.toArray(new Log[copy.size()]);
    }
368664
public Collection<String> getAllLoggerNames() {
		Set<String> loggerNames = new TreeSet<>();
		for (Logger logger : getParentLoggers()) {
			loggerNames.add(logger.getName());
		}
		for (Logger logger : getLoggers()) {
			loggerNames.add(logger.getName());
		}
		if (!customLoggers.isEmpty()) {
			for (Entry<LoggerConfig, String> entry : customLoggers.entrySet()) {
				loggerNames.add(entry.getKey().getName());
			}
		}
		if (!customParentLoggers.isEmpty()) {
			for (Entry<LoggerConfig, String> entry : customParentLoggers.entrySet()) {
				loggerNames.add(entry.getKey().getName());
			}
		}
		return loggerNames;
	}
931378
def ReadFlowLogEntries(self,
                         client_id,
                         flow_id,
                         offset,
                         count,
                         with_substring=None):
    """"""
    entries = sorted(
        self.flow_log_entries.get((client_id, flow_id), []),
        key=lambda e: e.timestamp)

    if with_substring is not None:
      entries = [i for i in entries if with_substring in i.message]

    return entries[offset:offset + count]
1082497
public final Set<Entry<String, L[]>> getEntries() {
        return (this.map != null)
                ? this.map.entrySet()
                : Collections.<Entry<String, L[]>>emptySet();
    }
495204
private function readLogs(): array
	{
		$logs = [];
		$dir = @dir($this->path);
		if (!$dir) {
			throw new IOException("getLogs: Failed opening directory '$this->path' for reading");
		}
		while ($file = $dir->read()) {
			if ($file == '.' || $file == '..' || $file == 'web.config' || $file == '.htaccess') {
				continue;
			} else {
				$hash = $this->hasher->hash($file);
				$logs[$hash] = new Log($hash, $this->path, $file);
			}
		}
		return $logs;
	}
641313
public function all()
    {
        $entries = [];
        while ($keys = $this->redis->scan($it, self::KEY_PREFIX.'*')) {
            foreach ($keys as $key) {
                $entries[substr($key, strlen(self::KEY_PREFIX))] = Collection::make($this->redis->get($key));
            }
        }

        return $entries;
    }
723856
public synchronized List<SessionId> getLoggedSessions() {
    // TODO: Find a solution that can handle large numbers of sessions, maybe by
    // reading them from disc.
    ImmutableList.Builder<SessionId> builder = new ImmutableList.Builder<>();
    builder.addAll(perSessionDriverEntries.keySet());
    return builder.build();
  }
25667
public com.google.api.ads.adwords.axis.v201809.mcm.ManagedCustomer[] getEntries() {
        return entries;
    }
1124415
public java.util.List<NetworkAclEntry> getEntries() {
        if (entries == null) {
            entries = new com.amazonaws.internal.SdkInternalList<NetworkAclEntry>();
        }
        return entries;
    }