lastUpdate   time.Time  `msg:"u"`
	bucket       string     `msg:"b"`
	filter       string     `msg:"flt"`
	id           string     `msg:"id"`
	error        string     `msg:"err"`
	root         string     `msg:"root"`
	fileNotFound bool       `msg:"fnf"`
	status       scanStatus `msg:"stat"`
	recursive    bool       `msg:"rec"`
	dataVersion  uint8      `msg:"v"`
}

func (m *metacache) finished() bool {

     * <p>
     * If a root package is specified at instance construction, only classes under the root package are targeted.
     * </p>
     *
     * @param handler the handler to process classes
     */
    void forEach(ClassHandler handler);

    /**
     * Searches for resources handled by this instance and calls the handler for each resource.
     * <p>

        IOException ioe = se;
        Throwable root = se.getCause();
        if (root instanceof TransportException) {
            ioe = (TransportException) root;
            root = ioe.getCause();
        }
        if (root instanceof InterruptedException) {
            ioe = new InterruptedIOException(root.getMessage());
            ioe.initCause(root);
        }
        return ioe;
    }

    /**

        void testGetRootCause() {
            Exception rootCause = new IllegalStateException("Test root cause");
            TransportException exception = new TransportException("Message", rootCause);

            assertEquals(rootCause, exception.getRootCause());
        }

        @Test
        @DisplayName("Should return null when no root cause")
        void testGetRootCauseWhenNull() {

            // Verify only one dependency remains
            Editor editor = new Editor(document);
            Element root = editor.root();
            Element dependencyManagement = DomUtils.findChildElement(root, "dependencyManagement");
            Element dependencies = DomUtils.findChildElement(dependencyManagement, "dependencies");

     *
     * @param root the root directory (e.g., "WEB-INF/")
     * @param base the base directory under root (e.g., "conf", "classes")
     * @param names the path components to append to the base directory
     * @return the Path object pointing to the requested resource
     */
    protected static Path getPath(final String root, final String base, final String... names) {

        try {

 * roots on a server using the NetDFS RPC interface.
 */
public class MsrpcDfsRootEnum extends netdfs.NetrDfsEnumEx {

    /**
     * Creates a new DFS root enumeration request for the specified server.
     *
     * @param server the server name to enumerate DFS roots from
     */
    public MsrpcDfsRootEnum(final String server) {

starting with its own and including everything up-to but not including the root. We don't need to
include root certificates because the client already has them.

```java
HandshakeCertificates serverHandshakeCertificates = new HandshakeCertificates.Builder()
    .heldCertificate(serverCertificate, intermediateCertificate.certificate())
    .build();
```

The client only needs to know the trusted root certificate. It checks the server's certificate by

**NOTE:**

- All the nodes running distributed MinIO should share a common root credentials, for the nodes to connect and trust each other. To achieve this, it is **recommended** to export root user and root password as environment variables, `MINIO_ROOT_USER` and `MINIO_ROOT_PASSWORD`, on all the nodes before executing MinIO server command. If not exported, default `minioadmin/minioadmin` credentials shall be used.

            // not used
        }

        @Override
        public void merge(ArtifactMetadata metadata) {
            // not used
        }

        @Override
        public void storeInLocalRepository(ArtifactRepository localRepository, ArtifactRepository remoteRepository)
                throws RepositoryMetadataStoreException {
            // not used
        }

        @Override