* number of characters copied.
   */
  private int drain(byte[] b, int off, int len) {
    int remaining = min(len, byteBuffer.remaining());
    byteBuffer.get(b, off, remaining);
    return remaining;
  }

      this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();
      } catch (IllegalAccessException e) {
        throw newLinkageError(e);

@ElementTypesAreNonnullByDefault
public abstract class AbstractCache<K, V> implements Cache<K, V> {

  /** Constructor for use by subclasses. */
  protected AbstractCache() {}

  /** @since 11.0 */
  @Override
  public V get(K key, Callable<? extends V> valueLoader) throws ExecutionException {
    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   *

   * number of characters copied.
   */
  private int drain(byte[] b, int off, int len) {
    int remaining = min(len, byteBuffer.remaining());
    byteBuffer.get(b, off, remaining);
    return remaining;
  }

  // but not yet healthy are considered disrupted and can be evicted regardless
  // of whether the criteria in a PDB is met. This means perspective running
  // pods of a disrupted application might not get a chance to become healthy.
  // Healthy pods will be subject to the PDB for eviction.
  //
  // Additional policies may be added in the future.
  // Clients making eviction decisions should disallow eviction of unhealthy pods

    checkNotNull(multimapSupplier);
    return Collector.of(
        multimapSupplier,
        (multimap, input) -> {
          K key = keyFunction.apply(input);
          Collection<V> valuesForKey = multimap.get(key);
          valueFunction.apply(input).forEachOrdered(valuesForKey::add);
        },
        (multimap1, multimap2) -> {
          multimap1.putAll(multimap2);
          return multimap1;
        });
  }

* Documentation automatique des modèles de données avec <a href="http://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a> (comme...

// if values kind is Slice/Array, check all items have been saved
var visitMapStoreKey = "gorm:saved_association_map"

func checkAssociationsSaved(db *gorm.DB, values reflect.Value) bool {
	if visit, ok := db.Get(visitMapStoreKey); ok {
		if v, ok := visit.(*visitMap); ok {
			if loadOrStoreVisitMap(v, values) {
				return true
			}
		}
	} else {
		vistMap := make(visitMap)
		loadOrStoreVisitMap(&vistMap, values)

func (rl ReplicationLatency) merge(other ReplicationLatency) (newReplLatency ReplicationLatency) {
	newReplLatency.UploadHistogram = rl.UploadHistogram.Merge(other.UploadHistogram)
	return
}

// Get upload latency of each object size range
func (rl ReplicationLatency) getUploadLatency() (ret map[string]uint64) {
	ret = make(map[string]uint64)
	avg := rl.UploadHistogram.GetAvgData()
	for k, v := range avg {

	}
	if !target.firstPing {
		if err := target.executeStmts(); err != nil {
			if IsConnErr(err) {
				return store.ErrNotConnected
			}
			return err
		}
	}

	eventData, eErr := target.store.Get(key)
	if eErr != nil {
		// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()
		// Such events will not exist and wouldve been already been sent successfully.