// If we have have any records left, return these before any error.
	for len(r.current) <= r.recordsRead {
		if r.err != nil {
			return nil, r.err
		}
		// Move to next block
		item, ok := <-r.queue
		if !ok {
			r.err = io.EOF
			return nil, r.err
		}

		r.csvDstPool.Put(r.current)
		r.current = <-item.dst
		r.err = item.err
		r.recordsRead = 0
	}
	csvRecord := r.current[r.recordsRead]

  }

  // b/4558855
  public void testMadbotsBug() {
    assertEquals("../this", simplifyPath("../this"));
    assertEquals("../this/is/ok", simplifyPath("../this/is/ok"));
    assertEquals("../ok", simplifyPath("../this/../ok"));
  }

  // https://github.com/google/guava/issues/705
  public void test705() {
    assertEquals("../b", simplifyPath("x/../../b"));

	for tier, st := range m {
		l[tier] = l[tier].merge(st)
	}
}

func (l DailyAllTierStats) addToTierInfo(tierInfos []madmin.TierInfo) []madmin.TierInfo {
	for i := range tierInfos {
		lst, ok := l[tierInfos[i].Name]
		if !ok {
			continue
		}
		for hr, st := range lst.Bins {
			tierInfos[i].DailyStats.Bins[hr] = madmin.TierStats{
				TotalSize:   st.TotalSize,
				NumVersions: st.NumVersions,

		}()

		// Read from subChT and write to subCh
		var buf bytes.Buffer
		enc := json.NewEncoder(&buf)
		for {
			select {
			case <-doneCh:
				return
			case v, ok := <-subChT:
				if !ok {
					return
				}
				buf.Reset()
				err := enc.Encode(v)
				if err != nil {
					return
				}

				select {
				case subCh <- append(GetByteBuffer()[:0], buf.Bytes()...):

	wg.Wait()
	return nil
}

func (s *peerRESTServer) BackgroundHealStatusHandler(_ *grid.MSS) (*grid.JSON[madmin.BgHealState], *grid.RemoteErr) {
	state, ok := getLocalBackgroundHealStatus(context.Background(), newObjectLayerFn())
	if !ok {
		return nil, grid.NewRemoteErr(errServerNotInitialized)
	}
	return madminBgHealState.NewJSONWith(&state), nil
}

}

// Unwrap will unwrap the connection and remove the deadline if applied.
// If not a *DeadlineConn, the unmodified net.Conn is returned.
func Unwrap(c net.Conn) net.Conn {
	if dc, ok := c.(*DeadlineConn); ok {
		return dc.Conn
	}
	return c
}

// Sets read deadline
func (c *DeadlineConn) setReadDeadline() {
	// Do not set a Read deadline, if upstream wants to cancel all reads.

import org.jline.utils.AttributedStyle;
import org.jline.utils.Colors;

/**
 * mvnenc invoker implementation.
 */
public class EncryptInvoker extends LookupInvoker<EncryptContext> {

    public static final int OK = 0; // OK
    public static final int ERROR = 1; // "generic" error
    public static final int BAD_OPERATION = 2; // bad user input or alike
    public static final int CANCELED = 3; // user canceled

import org.jline.utils.AttributedStyle;
import org.jline.utils.Colors;

/**
 * mvnup invoker implementation.
 */
public class UpgradeInvoker extends LookupInvoker<UpgradeContext> {

    public static final int OK = 0; // OK
    public static final int ERROR = 1; // "generic" error
    public static final int BAD_OPERATION = 2; // bad user input or alike
    public static final int CANCELED = 3; // user canceled

}

func recycleFunc[RT RoundTripper](newRT func() RT) (newFn func() RT, recycle func(r RT)) {
	rAny := any(newRT())
	var rZero RT
	if _, ok := rAny.(Recycler); ok {
		return newRT, func(r RT) {
			if r != rZero {
				if rc, ok := any(r).(Recycler); ok {
					rc.Recycle()
				}
			}
		}
	}
	pool := bpool.Pool[RT]{
		New: func() RT {
			return newRT()
		},
	}
	return pool.Get,

		case <-doneCh:
			if err := context.Cause(s.ctx); !errors.Is(err, errStreamEOF) {
				return err
			}
			// Fall through to be sure we have returned all responses.
			doneCh = nil
		case resp, ok := <-s.responses:
			if !ok {
				done = true
				return nil
			}
			if resp.Err != nil {
				s.cancel(resp.Err)
				return resp.Err
			}
			err = next(resp.Msg)
			if err != nil {
				s.cancel(err)
				return err