* <p>
 * <strong>Thread-Safety:</strong> This class is <strong>NOT thread-safe</strong>.
 * It extends {@link LinkedHashMap} without synchronization. If multiple threads access
 * an instance concurrently, and at least one thread modifies the map structurally,
 * it must be synchronized externally.
 * </p>
 * <p>
 * For thread-safe usage, wrap with {@link java.util.Collections#synchronizedMap(Map)}:
 * </p>
 * <pre>

                                    });
                        }));
                    }
                });

    }

    /**
     * Modifies user attributes in the LDAP directory.
     *
     * @param user the user object with new attribute values
     * @param adminEnv the supplier for admin environment
     * @param userDN the DN of the user entry

import org.gradle.process.ExecResult
import java.io.File
import javax.inject.Inject
import org.gradle.work.DisableCachingByDefault

@DisableCachingByDefault(because = "Must not cache because it modifies global Android home")
abstract class AndroidHomeWarmupTask : DefaultTask() {

    @get:OutputDirectory
    abstract val warmupProjectsDirectory: DirectoryProperty

    @get:Input

        String targetNamespace = getNamespaceForModelVersion(targetModelVersion);

        // Use element's attribute method to set the namespace declaration
        // This modifies the element in place and marks it as modified
        root.attribute("xmlns", targetNamespace);
        context.detail("Updated namespace to " + targetNamespace);

        // Update schema location if present

#### `lru_cache` Technical Details { #lru-cache-technical-details }

`@lru_cache` modifies the function it decorates to return the same value that was returned the first time, instead of computing it again, executing the code of the function every time.

        assertEquals(42, pooledInt.getObject().intValue());

        // Should not throw for non-AutoCloseable type
        intFactory.destroyObject(pooledInt);
    }

    /**
     * Test listener that modifies object state
     */
    public void test_listener_modifiesObjectState() throws Exception {
        final AtomicInteger modificationCount = new AtomicInteger(0);

                    .artifactId("test")
                    .version("1.0.0")
                    .build();

            Document document = Document.of(pomXml);
            // Use a mutable map since the strategy modifies it
            Map<Path, Document> pomMap = new HashMap<>();
            pomMap.put(Paths.get("pom.xml"), document);

 * methods for more details.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access the same cell of
 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that
 * modifications are visible, synchronize access to the table. Unlike other {@code Table}

            It is generally not needed for non-modular projects, or for modular projects having only one module.

            <p>If a module name is specified for resources or script files,
            then this value modifies the directory where the files will be copied.
            For example, if a Java module name is "foo.biz", then the {@code foo/bar.properties}
            resource file will be copied as {@code foo.biz/foo/bar.properties}.</p>

        result.addAll(c.declaredMethods.findAll { isPublicApi(it) })

        collect(result, c.superclass)
    }

    private boolean isPublicApi(CtMethod method) {
        return Modifier.isPublic(method.modifiers) || Modifier.isProtected(method.modifiers)
    }

    private List<String> filterChangesToReport(CtClass c, Set<CtMethod> methods) {
        return methods.findAll { isFirstPublicClassInHierarchy(it, c) }*.longName.sort()
    }