try {
                disposable.dispose();
            } catch (final Throwable t) {
                System.err.println("[DisposableUtil] Failed to dispose resource: " + t.getClass().getName() + ": " + t.getMessage()); // must not use Logger.
            }
        }
        disposables.clear();
        Introspector.flushCaches();
    }

    }

    // Helper method to get private searchAttributes field using reflection
    private int getSearchAttributes(SmbComDelete smbComDelete) {
        try {
            Field field = smbComDelete.getClass().getDeclaredField("searchAttributes");
            field.setAccessible(true);
            return field.getInt(smbComDelete);
        } catch (Exception e) {

        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }

        if (!ArtifactModelSource.class.equals(obj.getClass())) {
            return false;
        }

        ArtifactModelSource other = (ArtifactModelSource) obj;
        return Objects.equals(artifactId, other.artifactId)

        return null;
    }

    @Override
    public SecDispatcher.ValidationResponse validateConfiguration(String config) {
        if (NAME.equals(config)) {
            return new SecDispatcher.ValidationResponse(getClass().getSimpleName(), true, Map.of(), List.of());
        }
        return null;
    }

        assertArgumentNotNull("array", array);

        final int length = array.length;
        @SuppressWarnings("unchecked")
        final T[] newArray = (T[]) Array.newInstance(array.getClass().getComponentType(), length + 1);
        System.arraycopy(array, 0, newArray, 0, length);
        newArray[length] = obj;
        return newArray;
    }

    /**

    @Override
    public ConfigurationConverter lookupConverterForType(Class<?> type) throws ComponentConfigurationException {
        ConfigurationConverter converter = delegate.lookupConverterForType(type);
        return converter.getClass().equals(ObjectWithFieldsConverter.class)
                ? new EnhancedConfigurationConverter()
                : converter;
    }

    @Override
    public void apply(Project project) {
        if (project != project.getRootProject()) {
            throw new IllegalStateException(this.getClass().getName() + " can only be applied to the root project.");
        }

        Provider<DockerSupportService> dockerSupportServiceProvider = project.getGradle()
            .getSharedServices()
            .registerIfAbsent(

            failureUrlService.delete(entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
        });
        return redirect(getClass());
    }

    /**
     * Deletes all failure URL records that match the current search criteria.
     *
     * @return HTML response redirecting to the failure URL list page
     */
    @Execute

        jobLogService.getJobLog(id).alwaysPresent(entity -> {
            jobLogService.delete(entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
        });
        return redirect(getClass());
    }

    /**
     * Deletes all job logs.
     *
     * @return HTML response after deletion
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse deleteall() {

        return Objects.hash(css, id, tag);
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        final PrunedTag other = (PrunedTag) obj;
        return StringUtils.compare(tag, other.tag) == 0 //