}
        }
    };

    @Override
    public void addListener(BuildOperationListener listener) {
        listenersLock.lock();
        try {
            List<ProgressShieldingBuildOperationListener> listeners = new ArrayList<ProgressShieldingBuildOperationListener>(this.listeners);
            listeners.add(new ProgressShieldingBuildOperationListener(listener));

   */
  public void addListener(L listener, Executor executor) {
    checkNotNull(listener, "listener");
    checkNotNull(executor, "executor");
    listeners.add(new PerListenerQueue<>(listener, executor));
  }

  /**
   * Enqueues an event to be run on currently known listeners.
   *
   * <p>The {@code toString} method of the Event itself will be used to describe the event in the
   * case of an error.

  for (const std::unique_ptr<XlaActivityListener>& listener :
       listener_list->listeners) {
    TF_RETURN_IF_ERROR(fn(listener.get()));
  }

  return absl::OkStatus();
}

void FlushAllListeners() {
  Status s = ForEachListener([](XlaActivityListener* listener) {
    listener->Flush();
    return absl::OkStatus();
  });
  CHECK(s.ok());
}
}  // namespace

                maybeNotify(node, listener);
            }
        }
        parentListeners.put(listener.getParent(), listener);
    }

    private void addPathListener(ModelListener listener) {
        ModelNodeInternal node = flattened.get(listener.getPath());
        if (node != null) {
            maybeNotify(node, listener);
        }
        pathListeners.put(listener.getPath(), listener);
    }

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Manages listeners of build operations.
 *
 * There is one global listener for the life of the build runtime.
 * Listeners must be sure to remove themselves if they want to only listen for a single build.
 *
 * Listeners are notified in registration order.
 * Started and progress notifications are emitted in registration order,

                    InternalMavenSession.from(ee.getSession().getSession());
            Collection<Listener> listeners = session.getListeners();
            if (!listeners.isEmpty()) {
                Event event = new DefaultEvent(session, ee);
                for (Listener listener : listeners) {
                    listener.onEvent(event);
                }
            }
        }
    }

    @Override

        project.path >> project.projectPath.toString()
        project.identityPath >> Path.path(":project1")
        project.stepEvaluationListener(listener, _) >> { listener, step ->
            step.execute(listener)
            null
        }
        project.getOwner() >> mutationState
        mutationState.applyToMutableState(_) >> { Consumer consumer -> consumer.accept(project) }
    }

class XlaActivityListenerTest : public ::testing::Test {
 protected:
  XlaActivityListenerTest() {
    auto listener = std::make_unique<TestListener>();
    listener_ = listener.get();
    RegisterXlaActivityListener(std::move(listener));
  }

  TestListener* listener() const { return listener_; }

 private:
  TestListener* listener_;
};

GraphDef CreateGraphDef() {
  Scope root = Scope::NewRootScope().ExitOnError().WithAssignedDevice(

        with(operations.only(NotifyProjectBeforeEvaluatedBuildOperationType, { it.details.projectPath == ':foo' })) {
            displayName == 'Notify beforeEvaluate listeners of :foo'
            children*.displayName == ["Execute Project.beforeEvaluate listener"]
            children.first().children*.displayName == ["Apply script '${relativePath('foo/before.gradle')}' to project ':foo'"]
            parentId == configOp.id
        }

class DeviceCompilerSerializeTest : public ::testing::Test {
 protected:
  DeviceCompilerSerializeTest() {
    auto listener = std::make_unique<JitCompilationListener>();
    listener_ = listener.get();
    RegisterXlaActivityListener(std::move(listener));
  }

  JitCompilationListener* listener() const { return listener_; }

  // Returns a test graph that will split into two XLA clusters (due to a node
  // with _XlaCompile = false).