this.usedTypes = new ConcurrentHashMap<>();
        this.manager = requireNonNull(manager, "artifactHandlerManager cannot be null");
    }

    @Override
    public void onEvent(Object event) {
        if (event instanceof ExecutionEvent executionEvent) {
            if (executionEvent.getType() == ExecutionEvent.Type.SessionEnded) {
                usedTypes.clear();
            }
        }
    }

            Element root = document.root();
            Element profiles = root.child("profiles").orElse(null);
            Element profile = profiles.child("profile").orElse(null);
            Element profileBuild = profile.child("build").orElse(null);
            Element profilePlugins = profileBuild.child("plugins").orElse(null);
            Element antrunPlugin = profilePlugins

            }
        }
    }

    /**
     * Writes a search log event.
     *
     * @param event The search log event.
     */
    public void writeSearchLogEvent(final SearchLogEvent event) {
        try {
            final Map<String, Object> source = toSource(event);
            searchLogLogger.info(objectMapper.writeValueAsString(source));

                logError("initialize", e, eventSpy);
            }
        }
    }

    public void onEvent(Object event) {
        if (eventSpies.isEmpty()) {
            return;
        }
        for (EventSpy eventSpy : eventSpies) {
            try {
                eventSpy.onEvent(event);
            } catch (Exception | LinkageError e) {
                logError("notify", e, eventSpy);
            }

// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package event

import (
	"strings"

	"github.com/minio/pkg/v3/wildcard"

  /**
   * Removes a single instance of the specified element from this queue, if it is present. More
   * formally, removes an element {@code e} such that {@code o.equals(e)}, if this queue contains
   * one or more such elements. Returns {@code true} if this queue contained the specified element
   * (or equivalently, if this queue changed as a result of the call).
   *
   * @param o element to be removed from this queue, if present

  @Override
  void setCountCheckReturnValue(E element, int count) {
    assertEquals(
        "multiset.setCount() should return the old count",
        getMultiset().count(element),
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private int setCount(E element, int count) {

    assertEquals("Should be able to peek() at first element", "A", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() first element multiple times", "A", peekingIterator.peek());
    assertEquals(
        "next() should still return first element after peeking", "A", peekingIterator.next());

    assertEquals("Should be able to peek() at middle element", "B", peekingIterator.peek());
    assertEquals(

            Element moduleBRoot = moduleBDoc.root();
            Element build = moduleBRoot.child("build").orElse(null);
            Element plugins = build.child("plugins").orElse(null);
            Element plugin = plugins.child("plugin").orElse(null);
            Element dependencies = plugin.child("dependencies").orElse(null);
            Element dependency = dependencies.child("dependency").orElse(null);

  final transient E element;

  SingletonImmutableSet(E element) {
    this.element = Preconditions.checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public boolean contains(@Nullable Object target) {
    return element.equals(target);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {