// Used to detect the version of "xl" format.
type formatErasureVersionDetect struct {
	Erasure struct {
		Version string `json:"version"`
	} `json:"xl"`
}

// Represents the V1 backend disk structure version
// under `.minio.sys` and actual data namespace.
// formatErasureV1 - structure holds format config version '1'.
type formatErasureV1 struct {
	formatMetaV1
	Erasure struct {

		t.Errorf("Modified: got %s, want %s\n", got, want)
	}
}

type repeatedByte struct {
	off int64
	b   byte
	n   int64
}

// rleBuffer is a run-length-encoded byte buffer.
// It's an io.Writer (like a bytes.Buffer) and also an io.ReaderAt,
// allowing random-access reads.
type rleBuffer struct {
	buf []repeatedByte
}

func (r *rleBuffer) Size() int64 {

	// fmt.Printf("JPATHexpr: %v jsonobj: %v\n\n", p, v)
	if len(p) == 0 || v == nil {
		return v, false, nil
	}

	switch {
	case p[0].Key != nil:
		key := p[0].Key.keyString()

		switch kvs := v.(type) {
		case jstream.KVS:
			for _, kv := range kvs {
				if kv.Key == key {
					return jsonpathEval(p[1:], kv.Value)
				}
			}
			// Key not found - return nil result
			return Missing{}, false, nil

     * Encodes an NDR referent pointer.
     *
     * @param obj the object to encode as a referent
     * @param type the referent type
     */
    public void enc_ndr_referent(final Object obj, final int type) {
        if (obj == null) {
            enc_ndr_long(0);
            return;
        }
        switch (type) {
        case 1: /* unique */
        case 3: /* ref */
            enc_ndr_long(System.identityHashCode(obj));

    }

    @Test
    void testEncNdrReferent() {
        Object obj1 = new Object();
        Object obj2 = new Object();

        // Test unique/ref type (type 1 or 3)
        ndrBuffer.enc_ndr_referent(obj1, 1);
        assertEquals(4, ndrBuffer.getIndex());
        assertEquals(System.identityHashCode(obj1), Encdec.dec_uint32le(buffer, 0));

        ndrBuffer.reset();

### Tested { #tested }

* 100% <dfn title="The amount of code that is automatically tested">test coverage</dfn>.
* 100% <dfn title="Python type annotations, with this your editor and external tools can give you better support">type annotated</dfn> code base.
* Used in production applications.

## Starlette features { #starlette-features }

type SpeedTestResult struct {
	Endpoint      string
	Uploads       uint64
	Downloads     uint64
	UploadTimes   madmin.TimeDurations
	DownloadTimes madmin.TimeDurations
	DownloadTTFB  madmin.TimeDurations
	Error         string
}

func newRandomReader(size int) io.Reader {
	return io.LimitReader(randreader.New(), int64(size))
}

type firstByteRecorder struct {
	t *time.Time

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.collection;

/**
 * Element to be iterated by {@link IndexedIterator}.
 *
 * @author wyukawa
 * @param <T> the element type
 * @see IndexedIterator
 */
public class Indexed<T> {

    /** The element. */
    private final T element;

    /** The index of the element. */
    private final int index;

    /**

                    }
                }
            },
            "components": {
                "securitySchemes": {
                    "APIKeyQuery": {
                        "type": "apiKey",
                        "name": "key",
                        "in": "query",
                        "description": "API Key Query",
                    }
                }
            },
        }

                        "security": [{"APIKeyQuery": []}],
                    }
                }
            },
            "components": {
                "securitySchemes": {
                    "APIKeyQuery": {"type": "apiKey", "name": "key", "in": "query"}
                }
            },
        }