labels.authRealm	=	Royaume
labels.available	=	Statut
labels.createdBy	=	Créé par
labels.createdTime	=	Heure de création
labels.depth	=	Profondeur
labels.excludedPaths	=	Chemins exclus pour l'exploration
labels.excludedUrls	=	URL exclues pour l'exploration
labels.excludedDocPaths	=	Chemins exclus pour l'indexation
labels.excludedDocUrls	=	URL exclues pour l'indexation
labels.hostname	=	Nom d'hôte
labels.id	=	IDENTIFIANT

pkg syscall (linux-arm-cgo), type Timex struct, Shift int32
pkg syscall (linux-arm-cgo), type Timex struct, Stabil int32
pkg syscall (linux-arm-cgo), type Timex struct, Status int32
pkg syscall (linux-arm-cgo), type Timex struct, Stbcnt int32
pkg syscall (linux-arm-cgo), type Timex struct, Tai int32
pkg syscall (linux-arm-cgo), type Timex struct, Tick int32

     * by Kadatch and Jenkins, 2010.
     */

    Crc32cHasher() {
      super(16);
    }

    private boolean finished = false;

    /*
     * This trick allows us to avoid having separate states for "first four ints" and "all other
     * four int chunks."  The state we want after the first four bytes is
     *
     * crc0 = ~int0
     * crc1 = int1
     * crc2 = int2
     * crc3 = int3
     *

    public static final String TEXT_FRAGMENT_TYPE_QUERY = "query";

    public static final String TEXT_FRAGMENT_TYPE_HIGHLIGHT = "highlight";

    public static final String CRAWLER_STATS_KEY = "crawler.stats.key";

   * {@link Cache#stats} will return zero for all statistics. Note that recording stats requires
   * bookkeeping to be performed with each operation, and thus imposes a performance penalty on
   * cache operation.
   *
   * @return this {@code CacheBuilder} instance (for chaining)
   * @since 12.0 (previously, stats collection was automatic)
   */
  @CanIgnoreReturnValue

     *   <li>If this field's value == null because it was associated with our thread and was
     *       cleared, we know that we're not executing inline any more
     * </ul>
     *
     * All the states where thread != currentThread are identical for our purposes, and so even
     * though it's racy, we don't care which of those values we get, so no need to synchronize.
     */
    @CheckForNull @LazyInit Thread thread;

}

func (s3Select *S3Select) getProgress() (bytesScanned, bytesProcessed int64) {
	if s3Select.progressReader != nil {
		return s3Select.progressReader.Stats()
	}

	return -1, -1
}

// Open - opens S3 object by using callback for SQL selection query.
// Currently CSV, JSON and Apache Parquet formats are supported.

   * this fluent iterable supports it. Note that it is <i>not</i> possible to delete the last
   * skipped element by immediately calling {@code remove()} on the returned fluent iterable's
   * iterator, as the {@code Iterator} contract states that a call to {@code * remove()} before a
   * call to {@code next()} will throw an {@link IllegalStateException}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#skip} (same).
   */

	filePath := r.Form.Get(storageRESTFilePath)
	glob := r.Form.Get(storageRESTGlob)
	done := keepHTTPResponseAlive(w)
	stats, err := s.getStorage().StatInfoFile(r.Context(), volume, filePath, glob == "true")
	done(err)
	if err != nil {
		return
	}
	for _, si := range stats {
		msgp.Encode(w, &si)
	}
}

func (s *storageRESTServer) DeleteBulkHandler(w http.ResponseWriter, r *http.Request) {

   * iterable supports it. Note that it is <i>not</i> possible to delete the last skipped element by
   * immediately calling {@code remove()} on that iterator, as the {@code Iterator} contract states
   * that a call to {@code remove()} before a call to {@code next()} will throw an {@link
   * IllegalStateException}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#skip}
   *
   * @since 3.0