return dstRec, nil
}

// Close - closes underlying reader.
func (r *Reader) Close() error {
	// Close the input.
	err := r.readCloser.Close()
	for range r.valueCh {
		// Drain values so we don't leak a goroutine.
		// Since we have closed the input, it should fail rather quickly.
	}
	return err
}

// NewReader - creates new JSON reader using readCloser.

   * accommodate as many threads as will ever concurrently modify the table. Using a significantly
   * higher value than you need can waste space and time, and a significantly lower value can lead
   * to thread contention. But overestimates and underestimates within an order of magnitude do not
   * usually have much noticeable impact. A value of one permits only one thread to modify the map

    /** Whether to use SMB2/SMB3 leases for caching */
    protected boolean useLease = true;
    /** Lease timeout in milliseconds */
    protected int leaseTimeout = 30000;
    /** Maximum number of concurrent leases */
    protected int maxLeases = 1000;
    /** Preferred lease version (1 or 2) */
    protected int leaseVersion = 2;
    /** Lease break timeout in seconds (per MS-SMB2 spec) */
    protected int leaseBreakTimeout = 60;

	return getFileInfoVersions(e.metadata, bucket, e.name, true)
}

// metaCacheEntries is a slice of metacache entries.
type metaCacheEntries []metaCacheEntry

// less function for sorting.
func (m metaCacheEntries) less(i, j int) bool {
	return m[i].name < m[j].name
}

// sort entries by name.
// m is sorted and a sorted metadata object is returned.

   * accommodate as many threads as will ever concurrently modify the table. Using a significantly
   * higher value than you need can waste space and time, and a significantly lower value can lead
   * to thread contention. But overestimates and underestimates within an order of magnitude do not
   * usually have much noticeable impact. A value of one permits only one thread to modify the map

# Alternativas, Inspiração e Comparações { #alternatives-inspiration-and-comparisons }

O que inspirou o **FastAPI**, como ele se compara às alternativas e o que ele aprendeu com elas.

## Introdução { #intro }

**FastAPI** não existiria se não fosse pelo trabalho anterior de outras pessoas.

Houve muitas ferramentas criadas antes que ajudaram a inspirar sua criação.

    }
}

/**
 * Determine the number of buckets for the first element in the list
 * when it needs to be split into several smaller pieces.
 *
 * The basic idea is:
 * 1. Make sure the rest elements has at least one bucket.
 * 2. Make sure the "roughSizeOfEachBucket" for the rest elements is smaller than the current "roughSizeOfEachBucket".
 */
private fun <T> determineBucketNumberForLargeElment(
    largestElementSize: Int,

 * <p><b>Warning:</b> The methods of {@code ForwardingQueue} forward <b>indiscriminately</b> to the
 * methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change the
 * behavior of {@link #offer} which can lead to unexpected behavior. In this case, you should
 * override {@code offer} as well, either providing your own implementation, or delegating to the
 * provided {@code standardOffer} method.
 *

    // http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_10_ConstantFold.java

    // we cannot use individual @Params as some will lead to invalid combinations which do not let the benchmark terminate. JMH offers no
    // support to constrain the combinations of benchmark parameters and we do not want to rely on OptionsBuilder as each benchmark would

                        maximal.remove();
                        break;

                    case LESS_SPECIFIC:
                        // This method is less specific than some of the
                        // currently known maximally specific methods, so we
                        // won't add it into the set of maximally specific
                        // methods