}

        /**
         * Checks if the overwrite option is enabled in the configuration.
         * Returns true if "overwrite" is present in the values.
         *
         * @return true if overwriting is enabled, false otherwise
         */
        public boolean isOverwrite() {
            for (final String value : values) {
                if ("overwrite".equalsIgnoreCase(value)) {
                    return true;

// with governance bypass headers set in the request.
// Objects under site wide WORM cannot be overwritten.
// For objects in "Governance" mode, overwrite is allowed if a) object retention date is past OR
// governance bypass headers are set and user has governance bypass permissions.

        assertFalse(dataMap.containsKey("y.overwrite"));
        assertEquals(1, dataMap.size());
        assertEquals("Y1", dataMap.get("y"));
    }

    /** Case 4: Both baseKey and baseKey.overwrite exist → Overwrite with the value of .overwrite */
    @Test
    public void test_mergeResponseData_baseAndOverwrite() {
        Map<String, Object> dataMap = new HashMap<>();
        Map<String, Object> responseDataMap = new HashMap<>();

        assertFalse(fieldConfigs.getConfig("foo").map(FieldConfigs.Config::isOverwrite).orElse(false));
    }

    @Test
    public void test_overwrite() {
        final Map<String, String> params = Maps.of("foo", "overwrite");
        FieldConfigs fieldConfigs = new FieldConfigs(params);
        assertTrue(fieldConfigs.getConfig("test").isEmpty());

This is a toy example to demonstrate how it works, if you need Gzip support, you can use the provided [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware).

///

First, we create a `GzipRequest` class, which will overwrite the `Request.body()` method to decompress the body in the presence of an appropriate header.

If there's no `gzip` in the header, it will not try to decompress the body.

     * aka OPEN_ALWAYS
     */

    static final int FILE_OPEN_IF = 0x3;

    /* Open the file and overwrite it's contents or fail if it does not exist
     * aka TRUNCATE_EXISTING
     */

    static final int FILE_OVERWRITE = 0x4;

    /* Open the file and overwrite it's contents or create it if it does not exist
     * aka CREATE_ALWAYS (according to the wire when calling CreateFile)
     */

}

func (fw *regFileWriter) Write(b []byte) (n int, err error) {
	overwrite := int64(len(b)) > fw.nb
	if overwrite {
		b = b[:fw.nb]
	}
	if len(b) > 0 {
		n, err = fw.w.Write(b)
		fw.nb -= int64(n)
	}
	switch {
	case err != nil:
		return n, err
	case overwrite:
		return n, ErrWriteTooLong
	default:
		return n, nil
	}
}

     * @return <code>true</code> if this is a valid property for this processor
     */
    boolean isValidProperty(String property);

    /**
     * This method is responsible for examining the request and possibly overwrite of the valid properties in the model
     *
     * @param modelProperties
     * @param request
     */
    void overwriteModelProperties(Properties modelProperties, ModelBuildingRequest request);

import java.nio.file.StandardCopyOption;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * Export Elasticsearch build resources to configurable paths
 * <p>
 * Wil overwrite existing files and create missing directories.
 * Useful for resources that that need to be passed to other processes trough the filesystem or otherwise can't be
 * consumed from the classpath.
 */

TFCI_USE_CLANG_CL=0

# Map TFCI_BAZEL_* to BAZEL_* so cc_configure can find them in the environment.
# We use the shell's default value substitution to ensure that if these are
# already set (e.g. poisoned for RBE), we don't overwrite them with empty values
# before setup.sh has a chance to restore the TFCI_ variables.
export BAZEL_VC="${TFCI_BAZEL_VC:-$BAZEL_VC}"
export BAZEL_LLVM="${TFCI_BAZEL_LLVM:-$BAZEL_LLVM}"