b = Multisets.immutableEntry(entries.get(1), sortedMultiset.count(entries.get(1)));
        c = Multisets.immutableEntry(entries.get(2), sortedMultiset.count(entries.get(2)));
      }
    }
  }

  /** Resets the contents of sortedMultiset to have entries a, c, for the navigation tests. */
  // Needed to stop Eclipse whining
  private void resetWithHole() {
    List<E> container = new ArrayList<>();

	defer scannerTimer.Stop()
	defer globalScannerMetrics.setCycle(nil)

	for {
		select {
		case <-ctx.Done():
			return
		case <-scannerTimer.C:
			// Reset the timer for next cycle.
			// If scanner takes longer we start at once.
			scannerTimer.Reset(scannerCycle.Load())

			stopFn := globalScannerMetrics.log(scannerMetricScanCycle)
			cycleInfo.current = cycleInfo.next
			cycleInfo.started = time.Now()

                            }
                        }
                    } catch (final Exception e) {
                        logger.warn(e.getLocalizedMessage());
                    }
                    buf.reset();
                } else {
                    buf.write(b);
                }
            }
        }));
    }

    /** The charset used for encoding and decoding. */

java.io.InputStream { private java.io.StringReader in; public void StringInputStream(String); public int read() throws java.io.IOException; public void close() throws java.io.IOException; public synchronized void mark(int); public synchronized void reset() throws java.io.IOException; public boolean markSupported(); } org/codehaus/plexus/util/StringOutputStream.class package org.codehaus.plexus.util; public synchronized class StringOutputStream extends java.io.OutputStream { private StringBuffer buf;...

// Return with readMsgpReaderPoolPut when done.
func msgpNewReader(r io.Reader) *msgp.Reader {
	p := readMsgpReaderPool.Get()
	if p.R == nil {
		p.R = xbufio.NewReaderSize(r, 32<<10)
	} else {
		p.R.Reset(r)
	}
	return p
}

// readMsgpReaderPoolPut can be used to reuse a *msgp.Reader.
func readMsgpReaderPoolPut(r *msgp.Reader) {
	if r != nil {
		readMsgpReaderPool.Put(r)
	}
}

        this.emptySource = emptySource;
    }

    /**
     * Sets the ID of the suggest item.
     * @param id The ID to set.
     */
    public void setId(final String id) {
        this.id = id;
    }

    /**
     * Returns an empty map with default values for suggest item fields.
     * @return An empty map.
     */

					forceUnlock(ctx, dm.clnt, id)
					// Execute the caller lock loss callback
					if lockLossCallback != nil {
						lockLossCallback()
					}
					return
				}

				refreshTimer.Reset(dm.refreshInterval)
			}
		}
	}()
}

func forceUnlock(ctx context.Context, ds *Dsync, id string) {
	ctx, cancel := context.WithTimeout(ctx, ds.Timeouts.ForceUnlockCall)
	defer cancel()

}

// pathJoin - like path.Join() but retains trailing SlashSeparator of the last element
func pathJoin(elem ...string) string {
	sb := bytebufferpool.Get()
	defer func() {
		sb.Reset()
		bytebufferpool.Put(sb)
	}()

	return pathJoinBuf(sb, elem...)
}

// pathJoinBuf - like path.Join() but retains trailing SlashSeparator of the last element.

}

// InlineData returns true if object contents are inlined alongside its metadata.
func (fi FileInfo) InlineData() bool {
	_, ok := fi.Metadata[ReservedMetadataPrefixLower+"inline-data"]
	// Earlier MinIO versions didn't reset "x-minio-internal-inline-data"
	// from fi.Metadata when the object was tiered. So, tiered objects
	// would return true for InlineData() in these versions even though the
	// object isn't inlined in xl.meta

	enc := json.NewEncoder(buf)
	tmpEvt := struct{ Records []event.Event }{[]event.Event{{}}}
	for {
		select {
		case <-ctx.Done():
			grid.PutByteBuffer(buf.Bytes())
			return nil
		case ev := <-ch:
			buf.Reset()
			tmpEvt.Records[0] = ev
			if err := enc.Encode(tmpEvt); err != nil {
				peersLogOnceIf(ctx, err, "event: Encode failed")
				continue
			}
			out <- grid.NewBytesWithCopyOf(buf.Bytes())
		}
	}
}