javax.enterprise.event.Event Java Examples

@Inject
public SQLDataSetBasicAttributesWorkflow( final DataSetClientServices clientServices,
                                          final DataSetValidatorProvider validatorProvider,
                                          final SyncBeanManager beanManager,
                                          final DataSetDefBasicAttributesEditor basicAttributesEditor,
                                          final Event<SaveRequestEvent> saveRequestEvent,
                                          final Event<TestDataSetRequestEvent> testDataSetEvent,
                                          final Event<CancelRequestEvent> cancelRequestEvent,
                                          final View view ) {

    super( clientServices,
           validatorProvider,
           beanManager,
           basicAttributesEditor,
           saveRequestEvent,
           testDataSetEvent,
           cancelRequestEvent,
           view );
}
 

@Test
public void testRepeatingQualifiers() {
    ArcContainer container = Arc.container();
    Event<String> event = container.beanManager().getEvent().select(String.class);
    ObservingBean bean = container.instance(ObservingBean.class).get();

    List<String> expectedList = new ArrayList<>();
    assertListsAreEqual(expectedList, bean.getEvents());
    event.select(new Location.Literal("home")).fire("home");
    expectedList.add("home");
    assertListsAreEqual(expectedList, bean.getEvents());
    event.select(new Location.Literal("farAway"), new Location.Literal("dreamland")).fire("farAway");
    expectedList.add("farAway");
    assertListsAreEqual(expectedList, bean.getEvents());
    event.select(new Location.Literal("work"), new Location.Literal("office")).fire("work");
    expectedList.add("work");
    assertListsAreEqual(expectedList, bean.getEvents());
}
 

@Inject
public ElasticSearchDataSetEditor(final DataSetDefBasicAttributesEditor basicAttributesEditor,
                                  final ElasticSearchDataSetDefAttributesEditor attributesEditor,
                                  final DataSetDefColumnsFilterEditor columnsAndFilterEditor,
                                  final DataSetDefPreviewTable previewTable,
                                  final DataSetDefBackendCacheAttributesEditor backendCacheAttributesEditor,
                                  final DataSetDefClientCacheAttributesEditor clientCacheAttributesEditor,
                                  final DataSetDefRefreshAttributesEditor refreshEditor,
                                  final DataSetClientServices clientServices,
                                  final LoadingBox loadingBox,
                                  final Event<ErrorEvent> errorEvent,
                                  final Event<TabChangedEvent> tabChangedEvent,
                                  final DataSetEditor.View view) {
    super(basicAttributesEditor, attributesEditor.view, columnsAndFilterEditor,
            previewTable, backendCacheAttributesEditor, clientCacheAttributesEditor,
            refreshEditor, clientServices, loadingBox, errorEvent, tabChangedEvent, view);
    this.attributesEditor = attributesEditor;
}
 

@Inject
public SQLDataSetEditor(final DataSetDefBasicAttributesEditor basicAttributesEditor,
                        final SQLDataSetDefAttributesEditor attributesEditor,
                        final DataSetDefColumnsFilterEditor columnsAndFilterEditor,
                        final DataSetDefPreviewTable previewTable,
                        final DataSetDefBackendCacheAttributesEditor backendCacheAttributesEditor,
                        final DataSetDefClientCacheAttributesEditor clientCacheAttributesEditor,
                        final DataSetDefRefreshAttributesEditor refreshEditor,
                        final DataSetClientServices clientServices,
                        final LoadingBox loadingBox,
                        final Event<ErrorEvent> errorEvent,
                        final Event<TabChangedEvent> tabChangedEvent,
                        final View view) {
    super(basicAttributesEditor, attributesEditor.view, columnsAndFilterEditor, 
            previewTable, backendCacheAttributesEditor, clientCacheAttributesEditor,
            refreshEditor, clientServices, loadingBox, errorEvent, tabChangedEvent, view);
    this.attributesEditor = attributesEditor;
}
 

@Inject
public CSVDataSetEditor(final DataSetDefBasicAttributesEditor basicAttributesEditor,
                        final CSVDataSetDefAttributesEditor attributesEditor,
                        final DataSetDefColumnsFilterEditor columnsAndFilterEditor,
                        final DataSetDefPreviewTable previewTable,
                        final DataSetDefBackendCacheAttributesEditor backendCacheAttributesEditor,
                        final DataSetDefClientCacheAttributesEditor clientCacheAttributesEditor,
                        final DataSetDefRefreshAttributesEditor refreshEditor,
                        final DataSetClientServices clientServices,
                        final LoadingBox loadingBox,
                        final Event<ErrorEvent> errorEvent,
                        final Event<TabChangedEvent> tabChangedEvent,
                        final View view) {
    super(basicAttributesEditor, attributesEditor.view, columnsAndFilterEditor, 
            previewTable, backendCacheAttributesEditor, clientCacheAttributesEditor,
            refreshEditor, clientServices, loadingBox, errorEvent, tabChangedEvent, view);
    this.attributesEditor = attributesEditor;
}
 

@Inject
public DataSetEditor(final DataSetDefBasicAttributesEditor basicAttributesEditor,
                     final IsWidget providerAttributesEditorView,
                     final DataSetDefColumnsFilterEditor columnsAndFilterEditor,
                     final DataSetDefPreviewTable previewTable,
                     final DataSetDefBackendCacheAttributesEditor backendCacheAttributesEditor,
                     final DataSetDefClientCacheAttributesEditor clientCacheAttributesEditor,
                     final DataSetDefRefreshAttributesEditor refreshEditor,
                     final DataSetClientServices clientServices,
                     final LoadingBox loadingBox,
                     final Event<ErrorEvent> errorEvent,
                     final Event<TabChangedEvent> tabChangedEvent,
                     final View view) {
    this.basicAttributesEditor = basicAttributesEditor;
    this.providerAttributesEditorView = providerAttributesEditorView;
    this.columnsAndFilterEditor = columnsAndFilterEditor;
    this.previewTable = previewTable;
    this.backendCacheAttributesEditor = backendCacheAttributesEditor;
    this.clientCacheAttributesEditor = clientCacheAttributesEditor;
    this.refreshEditor = refreshEditor;
    this.clientServices = clientServices;
    this.loadingBox = loadingBox;
    this.errorEvent = errorEvent;
    this.tabChangedEvent = tabChangedEvent;
    this.view = view;
}
 

@Inject
public FaultToleranceInterceptor(
        FallbackHandlerProvider fallbackHandlerProvider,
        @Intercepted Bean<?> interceptedBean,
        MetricsCollectorFactory metricsCollectorFactory,
        FaultToleranceOperationProvider operationProvider,
        StrategyCache cache,
        ExecutorProvider executorProvider,
        Event<CircuitBreakerStateChanged> cbStateEvent) {
    this.fallbackHandlerProvider = fallbackHandlerProvider;
    this.interceptedBean = interceptedBean;
    this.metricsCollectorFactory = metricsCollectorFactory;
    this.operationProvider = operationProvider;
    this.executorProvider = executorProvider;
    this.cache = cache;
    this.cbStateEvent = cbStateEvent;
    asyncExecutor = executorProvider.getGlobalExecutor();
    timeoutExecutor = executorProvider.getTimeoutExecutor();
    requestContextController = RequestContextControllerProvider.load().get();
}
 

@Inject
public DataSetEditorWorkflow(final DataSetClientServices clientServices,
                             final DataSetValidatorProvider validatorProvider,
                             final SyncBeanManager beanManager,
                             final Event<SaveRequestEvent> saveRequestEvent,
                             final Event<TestDataSetRequestEvent> testDataSetEvent,
                             final Event<CancelRequestEvent> cancelRequestEvent,
                             final View view) {
    this.clientServices = clientServices;
    this.validatorProvider = validatorProvider;
    this.beanManager = beanManager;
    this.saveRequestEvent = saveRequestEvent;
    this.cancelRequestEvent = cancelRequestEvent;
    this.testDataSetEvent = testDataSetEvent;
    this.view = view;
}
 

@Inject
public BuildResultPushManager(
        BuildConfigurationAuditedRepository buildConfigurationAuditedRepository,
        BuildRecordPushResultRepository buildRecordPushResultRepository,
        BuildPushResultMapper mapper,
        InProgress inProgress,
        Event<BuildPushResult> buildPushResultEvent,
        ArtifactRepository artifactRepository,
        CausewayClient causewayClient) {
    this.buildConfigurationAuditedRepository = buildConfigurationAuditedRepository;
    this.buildRecordPushResultRepository = buildRecordPushResultRepository;
    this.mapper = mapper;
    this.inProgress = inProgress;
    this.buildPushResultEvent = buildPushResultEvent;
    this.artifactRepository = artifactRepository;
    this.causewayClient = causewayClient;
}
 

@Inject
public DefaultBuildCoordinator(
        DatastoreAdapter datastoreAdapter,
        Event<BuildStatusChangedEvent> buildStatusChangedEventNotifier,
        Event<BuildSetStatusChangedEvent> buildSetStatusChangedEventNotifier,
        BuildSchedulerFactory buildSchedulerFactory,
        BuildQueue buildQueue,
        SystemConfig systemConfig,
        GroupBuildMapper groupBuildMapper,
        BuildMapper buildMapper) {
    this.datastoreAdapter = datastoreAdapter;
    this.buildStatusChangedEventNotifier = buildStatusChangedEventNotifier;
    this.buildSetStatusChangedEventNotifier = buildSetStatusChangedEventNotifier;
    this.buildScheduler = buildSchedulerFactory.getBuildScheduler();
    this.systemConfig = systemConfig;
    this.buildQueue = buildQueue;
    this.buildTasksInitializer = new BuildTasksInitializer(
            datastoreAdapter,
            systemConfig.getTemporaryBuildsLifeSpan());
    this.groupBuildMapper = groupBuildMapper;
    this.buildMapper = buildMapper;
}
 

@Inject
public GalleryWidgetPresenter(SalesGoals salesGoals,
                              SalesExpectedByDate salesExpectedByDate,
                              SalesDistributionByCountry salesDistributionByCountry,
                              SalesTableReports salesTableReports,
                              ExpensesDashboard expensesDashboard,
                              ClusterMetricsDashboard clusterMetricsDashboard,
                              Event<NotificationEvent> workbenchNotification) {
    this.salesGoals = salesGoals;
    this.salesExpectedByDate = salesExpectedByDate;
    this.salesDistributionByCountry = salesDistributionByCountry;
    this.salesTableReports = salesTableReports;
    this.expensesDashboard = expensesDashboard;
    this.clusterMetricsDashboard = clusterMetricsDashboard;
    this.workbenchNotification = workbenchNotification;
}
 

@Inject
public DataSetLookupEditor(final View view,
                           SyncBeanManager beanManager,
                           DataSetFilterEditor filterEditor,
                           DataSetGroupDateEditor groupDateEditor,
                           DataSetClientServices clientServices,
                           Event<DataSetLookupChangedEvent> event) {
    this.view = view;
    this.beanManager = beanManager;
    this.filterEditor = filterEditor;
    this.groupDateEditor = groupDateEditor;
    this.clientServices = clientServices;
    this.changeEvent = event;
    this.dataSetLookup = null;
    this.lookupConstraints = null;
    this.dataSetMetadata = null;
    view.init(this);
}
 

@Inject
public BeanDataSetEditor(final DataSetDefBasicAttributesEditor basicAttributesEditor,
                         final BeanDataSetDefAttributesEditor attributesEditor,
                         final DataSetDefColumnsFilterEditor columnsAndFilterEditor,
                         final DataSetDefPreviewTable previewTable,
                         final DataSetDefBackendCacheAttributesEditor backendCacheAttributesEditor,
                         final DataSetDefClientCacheAttributesEditor clientCacheAttributesEditor,
                         final DataSetDefRefreshAttributesEditor refreshEditor,
                         final DataSetClientServices clientServices,
                         final LoadingBox loadingBox,
                         final Event<ErrorEvent> errorEvent,
                         final Event<TabChangedEvent> tabChangedEvent,
                         final View view) {
    super(basicAttributesEditor, attributesEditor.view, columnsAndFilterEditor, 
            previewTable, backendCacheAttributesEditor, clientCacheAttributesEditor,
            refreshEditor, clientServices, loadingBox, errorEvent, tabChangedEvent, view);
    this.attributesEditor = attributesEditor;
}
 

@Inject
public DataSetDefRegistryCDI(@Config("10485760" /* 10 Mb */) int maxCsvLength,
                             @Named("ioStrategy") IOService ioService,
                             DataSetProviderRegistryCDI dataSetProviderRegistry,
                             SchedulerCDI scheduler,
                             ExceptionManager exceptionManager,
                             Event<DataSetDefModifiedEvent> dataSetDefModifiedEvent,
                             Event<DataSetDefRegisteredEvent> dataSetDefRegisteredEvent,
                             Event<DataSetDefRemovedEvent> dataSetDefRemovedEvent,
                             Event<DataSetStaleEvent> dataSetStaleEvent) {

    super(dataSetProviderRegistry,
          scheduler);
    this.uuidGenerator = DataSetCore.get().getUuidGenerator();
    this.maxCsvLength = maxCsvLength;
    this.ioService = ioService;
    this.exceptionManager = exceptionManager;
    this.dataSetDefModifiedEvent = dataSetDefModifiedEvent;
    this.dataSetDefRegisteredEvent = dataSetDefRegisteredEvent;
    this.dataSetDefRemovedEvent = dataSetDefRemovedEvent;
    this.dataSetStaleEvent = dataSetStaleEvent;
}
 

@Inject
public DataSetProviderTypeWorkflow(final DataSetClientServices clientServices,
                                   final DataSetValidatorProvider validatorProvider,
                                   final SyncBeanManager beanManager,
                                   final DataSetDefProviderTypeEditor providerTypeEditor,
                                   final Event<SaveRequestEvent> saveRequestEvent,
                                   final Event<CancelRequestEvent> cancelRequestEvent,
                                   final Event<TestDataSetRequestEvent> testDataSetEvent,
                                   final View view) {

    super(clientServices,
          validatorProvider,
          beanManager,
          saveRequestEvent,
          testDataSetEvent,
          cancelRequestEvent,
          view);

    this.providerTypeEditor = providerTypeEditor;
}
 

@Inject
public CSVDataSetBasicAttributesWorkflow( final DataSetClientServices clientServices,
                                          final DataSetValidatorProvider validatorProvider,
                                          final SyncBeanManager beanManager,
                                          final DataSetDefBasicAttributesEditor basicAttributesEditor,
                                          final Event<SaveRequestEvent> saveRequestEvent,
                                          final Event<TestDataSetRequestEvent> testDataSetEvent,
                                          final Event<CancelRequestEvent> cancelRequestEvent,
                                          final View view ) {

    super( clientServices,
           validatorProvider,
           beanManager,
           basicAttributesEditor,
           saveRequestEvent,
           testDataSetEvent,
           cancelRequestEvent,
           view );
}
 

@Inject
public DataSetClientServices(ClientDataSetManager clientDataSetManager,
                             PathUrlFactory pathUrlFactory,
                             AggregateFunctionManager aggregateFunctionManager,
                             IntervalBuilderLocator intervalBuilderLocator,
                             Event<DataSetPushingEvent> dataSetPushingEvent,
                             Event<DataSetPushOkEvent> dataSetPushOkEvent,
                             Event<DataSetModifiedEvent> dataSetModifiedEvent,
                             Caller<DataSetLookupServices> dataSetLookupServices,
                             Caller<DataSetDefServices> dataSetDefServices,
                             Caller<DataSetExportServices> dataSetExportServices) {

    this.clientDataSetManager = clientDataSetManager;
    this.pathUrlFactory = pathUrlFactory;
    this.aggregateFunctionManager = aggregateFunctionManager;
    this.intervalBuilderLocator = intervalBuilderLocator;
    this.dataSetPushingEvent = dataSetPushingEvent;
    this.dataSetPushOkEvent = dataSetPushOkEvent;
    this.dataSetModifiedEvent = dataSetModifiedEvent;
    this.dataSetLookupServices = dataSetLookupServices;
    this.dataSetDefServices = dataSetDefServices;
    this.dataSetExportServices = dataSetExportServices;
}
 

@Inject
public DataSetDefWizardScreen(final SyncBeanManager beanManager,
                              final DataSetEditorWorkflowFactory workflowFactory,
                              final Caller<DataSetDefVfsServices> services,
                              final DataSetClientServices clientServices,
                              final Event<NotificationEvent> notification,
                              final PlaceManager placeManager,
                              final ErrorPopupPresenter errorPopupPresenter,
                              final SavePopUpPresenter savePopUpPresenter,
                              final DataSetDefScreenView view) {
    this.beanManager = beanManager;
    this.workflowFactory = workflowFactory;
    this.services = services;
    this.clientServices = clientServices;
    this.notification = notification;
    this.placeManager = placeManager;
    this.errorPopupPresenter = errorPopupPresenter;
    this.savePopUpPresenter = savePopUpPresenter;
    this.view = view;
}
 

@Inject
public DisplayerScreenPresenter(SyncBeanManager beanManager,
                                DataSetClientServices dataSetClientServices,
                                UUIDGenerator uuidGenerator,
                                PerspectiveManager perspectiveManager,
                                PlaceManager placeManager,
                                DisplayerViewer displayerViewer,
                                PanelManager panelManager,
                                PerspectiveCoordinator perspectiveCoordinator,
                                Event<ChangeTitleWidgetEvent> changeTitleEvent) {

    this.beanManager = beanManager;
    this.dataSetClientServices = dataSetClientServices;
    this.uuidGenerator = uuidGenerator;
    this.placeManager = placeManager;
    this.perspectiveManager = perspectiveManager;
    this.displayerViewer = displayerViewer;
    this.panelManager = panelManager;
    this.perspectiveCoordinator = perspectiveCoordinator;
    this.menuActionsButton = getMenuActionsButton();
    this.changeTitleEvent = changeTitleEvent;
    this.jsonMarshaller = DisplayerSettingsJSONMarshaller.get();
}
 

@Inject
public NavRootNodeEditor(NavRootNodeEditorView view,
                         SyncBeanManager beanManager,
                         PlaceManager placeManager,
                         PerspectiveTreeProvider perspectiveTreeProvider,
                         TargetPerspectiveEditor targetPerspectiveEditor,
                         PerspectivePluginManager perspectivePluginManager,
                         Event<NavItemEditStartedEvent> navItemEditStartedEvent,
                         Event<NavItemEditCancelledEvent> navItemEditCancelledEvent) {

    super(view, beanManager,
            placeManager,
            perspectiveTreeProvider,
            targetPerspectiveEditor,
            perspectivePluginManager,
            navItemEditStartedEvent,
            navItemEditCancelledEvent);

    this.view = view;
    this.view.init(this);

    super.setChildEditorClass(NavItemDefaultEditor.class);
}
 

@Inject
public NavTreeEditor(NavTreeEditorView view,
                     NavigationManager navigationManager,
                     SyncBeanManager beanManager,
                     PlaceManager placeManager,
                     PerspectiveTreeProvider perspectiveTreeProvider,
                     TargetPerspectiveEditor targetPerspectiveEditor,
                     PerspectivePluginManager perspectivePluginManager,
                     Event<NavItemEditStartedEvent> navItemEditStartedEvent,
                     Event<NavItemEditCancelledEvent> navItemEditCancelledEvent) {

    super(view, beanManager,
            placeManager,
            perspectiveTreeProvider,
            targetPerspectiveEditor,
            perspectivePluginManager,
            navItemEditStartedEvent,
            navItemEditCancelledEvent);

    this.view = view;
    this.navigationManager = navigationManager;
    this.view.init(this);

    super.setChildEditorClass(NavItemDefaultEditor.class);
}
 

@Inject
public NavItemDefaultEditor(NavItemDefaultEditorView view,
                            SyncBeanManager beanManager,
                            PlaceManager placeManager,
                            PerspectiveTreeProvider perspectiveTreeProvider,
                            TargetPerspectiveEditor targetPerspectiveEditor,
                            PerspectivePluginManager perspectivePluginManager,
                            Event<NavItemEditStartedEvent> navItemEditStartedEvent,
                            Event<NavItemEditCancelledEvent> navItemEditCancelledEvent) {

    super(view, beanManager,
            placeManager,
            perspectiveTreeProvider,
            targetPerspectiveEditor,
            perspectivePluginManager,
            navItemEditStartedEvent,
            navItemEditCancelledEvent);

    super.setChildEditorClass(NavItemDefaultEditor.class);
}
 

public NavItemEditor(View view,
                     SyncBeanManager beanManager,
                     PlaceManager placeManager,
                     PerspectiveTreeProvider perspectiveTreeProvider,
                     TargetPerspectiveEditor targetPerspectiveEditor,
                     PerspectivePluginManager perspectivePluginManager,
                     Event<NavItemEditStartedEvent> navItemEditStartedEvent,
                     Event<NavItemEditCancelledEvent> navItemEditCancelledEvent) {
    this.beanManager = beanManager;
    this.placeManager = placeManager;
    this.perspectiveTreeProvider = perspectiveTreeProvider;
    this.targetPerspectiveEditor = targetPerspectiveEditor;
    this.targetPerspectiveEditor.setOnUpdateCommand(this::onTargetPerspectiveUpdated);
    this.perspectivePluginManager = perspectivePluginManager;
    this.navItemEditStartedEvent = navItemEditStartedEvent;
    this.navItemEditCancelledEvent = navItemEditCancelledEvent;

    this.view = view;
    this.view.init(this);
}
 

@Inject
public DisplayerEditor(View view,
                       DataSetClientServices clientServices,
                       DisplayerLocator displayerLocator,
                       DisplayerPrototypes displayerPrototypes,
                       DisplayerTypeSelector typeSelector,
                       DataSetLookupEditor lookupEditor,
                       DisplayerSettingsEditor settingsEditor,
                       DisplayerEditorStatus editorStatus,
                       DisplayerHtmlEditor displayerHtmlEditor,
                       Event<DisplayerEditorSavedEvent> savedEvent,
                       Event<DisplayerEditorClosedEvent> closedEvent) {
    this.view = view;
    this.displayerLocator = displayerLocator;
    this.clientServices = clientServices;
    this.displayerPrototypes = displayerPrototypes;
    this.typeSelector = typeSelector;
    this.lookupEditor = lookupEditor;
    this.settingsEditor = settingsEditor;
    this.editorStatus = editorStatus;
    this.displayerHtmlEditor = displayerHtmlEditor;
    this.saveEvent = savedEvent;
    this.closeEvent = closedEvent;

    view.init(this);
}
 

@Inject
public RequestHandlerObserver(UrlToControllerTranslator translator,
		ControllerNotFoundHandler controllerNotFoundHandler, MethodNotAllowedHandler methodNotAllowedHandler,
		Event<ControllerFound> controllerFoundEvent, Event<RequestSucceded> endRequestEvent,
		InterceptorStack interceptorStack, InvalidInputHandler invalidInputHandler) {
	
	this.translator = translator;
	this.methodNotAllowedHandler = methodNotAllowedHandler;
	this.controllerNotFoundHandler = controllerNotFoundHandler;
	this.controllerFoundEvent = controllerFoundEvent;
	this.endRequestEvent = endRequestEvent;
	this.interceptorStack = interceptorStack;
	this.invalidInputHandler = invalidInputHandler;
}
 

@Inject
public ColumnFilterEditor(View view,
                          SyncBeanManager beanManager,
                          Event<ColumnFilterChangedEvent> changedEvent,
                          Event<ColumnFilterDeletedEvent> deletedEvent) {
    this.view = view;
    this.beanManager = beanManager;
    this.changedEvent = changedEvent;
    this.deletedEvent = deletedEvent;
    this.view.init(this);
}
 

@Inject
public ColumnListEditor(final SyncBeanManager beanManager,
                        final DataColumnDefDriver dataColumnDefDriver,
                        final Event<ColumnsChangedEvent> columnsChangedEvent,
                        final View view) {
    this.beanManager = beanManager;
    this.dataColumnDefDriver = dataColumnDefDriver;
    this.columnsChangedEvent = columnsChangedEvent;
    this.view = view;
}
 

@Inject
public DataSetFilterEditor(View view,
                           SyncBeanManager beanManager,
                           Event<DataSetFilterChangedEvent> changeEvent) {
    this.view = view;
    this.beanManager = beanManager;
    this.changeEvent = changeEvent;
    view.init(this);
}
 

@Inject
public DisplayerSubtypeSelector(View view,
                                RendererManager rendererManager,
                                Event<DisplayerSubtypeSelectedEvent> selectEvent) {
    this.view = view;
    this.rendererManager = rendererManager;
    this.selectEvent = selectEvent;
    view.init(this);
}
 

@Inject
public ExecuteMethod(MethodInfo methodInfo, Messages messages, 
		Event<MethodExecuted> methodExecutedEvent, Event<MethodReady> methodReady,
		ExecuteMethodExceptionHandler exceptionHandler, ReflectionProvider reflectionProvider) {
	this.methodInfo = methodInfo;
	this.messages = messages;
	this.methodExecutedEvent = methodExecutedEvent;
	this.methodReady = methodReady;
	this.executeMethodExceptionHandler = exceptionHandler;
	this.reflectionProvider = reflectionProvider;
}