/**
     * Checks if this sitemap set is of type URLSET.
     * @return true if this is a URLSET, false otherwise
     */
    public boolean isUrlSet() {
        return URLSET.equals(type);
    }

    /**
     * Checks if this sitemap set is of type INDEX.
     * @return true if this is an INDEX, false otherwise
     */
    public boolean isIndex() {
        return INDEX.equals(type);
    }

    /**

     *
     * @param key the metadata key
     * @return the values associated with the key, or null if not found
     */
    public String[] getValues(final String key) {
        return metadata.get(key);
    }

    /**
     * Gets the set of all metadata keys.
     *
     * @return the set of metadata keys
     */
    public Set<String> getKeySet() {
        return metadata.keySet();
    }

    /**

		return archArm()
	case "arm64":
		return archArm64()
	case "loong64":
		return archLoong64(&loong64.Linkloong64)
	case "mips":
		return archMips(&mips.Linkmips)
	case "mipsle":
		return archMips(&mips.Linkmipsle)
	case "mips64":
		return archMips64(&mips.Linkmips64)
	case "mips64le":
		return archMips64(&mips.Linkmips64le)
	case "ppc64":
		return archPPC64(&ppc64.Linkppc64)
	case "ppc64le":

            return true;
        }

        return false;
    }

    /**
     * Returns whether the crawler waits on folder operations.
     * @return true if no wait on folder, false otherwise.
     */
    public boolean isNoWaitOnFolder() {
        return noWaitOnFolder;
    }

    /**
     * Sets whether the crawler waits on folder operations.

                logger.debug("Failed to decode URL: " + name + " with encoding: " + enc, e);
            }
            return name;
        }
    }

    /**
     * Returns the charset name.
     * @return the charsetName
     */
    public String getCharsetName() {
        return charsetName;
    }

    /**
     * Sets the charset name.
     * @param charsetName The charset name to set.

			t.Errorf("ReadFile(%s) error=%v", path, err2)
			return
		}
	}
	if err != zt.Error {
		t.Errorf("error=%v, want %v", err, zt.Error)
		return
	}

	// bail if file is not zip
	if err == ErrFormat {
		return
	}

	// bail here if no Files expected to be tested
	// (there may actually be files in the zip, but we don't care)
	if zt.File == nil {
		return
	}

	if z.Comment != zt.Comment {

            return resultData;
        } catch (final IOException e) {
            throw new CrawlerSystemException("Could not convert the input stream.", e);
        }

    }

    /**
     * Retrieves data from the given AccessResultData object as a ByteArrayInputStream.
     * @param accessResultData The AccessResultData object.
     * @return A ByteArrayInputStream containing the data.
     */

func (w *Writer) AddFS(fsys fs.FS) error {
	return fs.WalkDir(fsys, ".", func(name string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if name == "." {
			return nil
		}
		info, err := d.Info()
		if err != nil {
			return err
		}
		if !d.IsDir() && !info.Mode().IsRegular() {
			return errors.New("zip: cannot add non-regular file")
		}

     *
     * @return true if the response has a body (either as bytes or file), false otherwise
     */
    public boolean hasResponseBody() {
        return responseBodyBytes != null || responseBodyFile != null;
    }

    /**
     * Gets the response body as an InputStream.
     * If the response body is stored as bytes, returns a ByteArrayInputStream.

    /**
     * Get the encoding.
     * @return encoding
     */
    public String getEncoding() {
        return encoding;
    }

    /**
     * Set the encoding.
     * @param encoding the encoding to set
     */
    public void setEncoding(final String encoding) {
        this.encoding = encoding;
    }

    /**
     * Returns a string representation of this object.