Register the recovery event callback listener.

@param rel The new recovery event listener
555463
@Override
    public void registerRecoveryEventListener(RecoveryEventListener rel) /* @MD19638A */
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "registerRecoveryEventListener", rel);

        RegisteredRecoveryEventListeners.instance().add(rel);

        if (tc.isEntryEnabled())
            Tr.exit(tc, "registerRecoveryEventListener");
    }
1356685
public void registerUndoRedo(Button undo, Button redo) {

        if (getState().m_enableUndoRedo) {
            throw new RuntimeException("Undo/redo already registered.");
        }
        undo.setId(HTML_ID_PREFIX + m_componentId + "-undo");
        redo.setId(HTML_ID_PREFIX + m_componentId + "-redo");
        getState().m_enableUndoRedo = true;
        markAsDirty();
    }
1286638
def register_callback_deleted(self, func, serialised=True):
        
        self.__add_callback(_CB_DELETED, func, serialised_if_crud=serialised)
940152
@Override
    public boolean registerRecoveryCoordinator(String recoveryCoordinatorFactoryFilter, Serializable recoveryCoordinatorInfo, String globalId) throws SystemException {

        final DistributableTransaction tx = getTransactionForID(globalId);

        WSATRecoveryCoordinator rc = new WSATRecoveryCoordinator(recoveryCoordinatorFactoryFilter, recoveryCoordinatorInfo, globalId);

        tx.setWSATRecoveryCoordinator(rc);

        return true;
    }
396532
public void registerCallback(UOWCallback callback)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) Tr.entry(tc, "registerCallback", callback);

        if (!_callbacks.contains(callback))
        {
            _callbacks.add(callback);

            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) Tr.debug(tc, "Number of registered Callbacks: "+_callbacks.size());
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) Tr.exit(tc, "registerCallback");
    }
210821
public static void registerRequestHandler(RequestHandler<? extends Request> rh) {
		if (rh == null) {
			throw new NullPointerException("rh is null");
		}

		if (rh.handles() == null) {
			throw new NullPointerException("rh.handles() returns null");
		}

		if (sRequestHandlers == null) {
			initializeDefaultHandlers();
		}

		if (sRequestHandlers.containsKey(rh.handles())) {
			throw new RuntimeException("RequestHandler already registered for "
					+ rh.handles());
		}

		sRequestHandlers.put(rh.handles(), rh);
	}
338909
public RetryPolicy<R> onRetriesExceeded(CheckedConsumer<? extends ExecutionCompletedEvent<R>> listener) {
    retriesExceededListener = EventListener.of(Assert.notNull(listener, "listener"));
    return this;
  }
276650
public void triggerReload() {
		synchronized (this.monitor) {
			synchronized (this.connections) {
				for (Connection connection : this.connections) {
					try {
						connection.triggerReload();
					}
					catch (Exception ex) {
						logger.debug("Unable to send reload message", ex);
					}
				}
			}
		}
	}
78541
public void setRel(java.lang.String rel) {
        getStateHelper().put(PropertyKeys.rel, rel);
        handleAttribute("rel", rel);
    }
7200
protected function registerWorkerErrorCallback()
    {
        $this->swooleServer->on('WorkerError', function ($server, $workerId, $workerPid, $exitCode, $signal) {
            $this->reportWorkerError($workerId, $workerPid, $exitCode, $signal);

            $this->events->dispatch(new Events\WorkerError($this, $workerId, $workerPid, $exitCode, $signal));

            $this->dispatchEvent('WorkerError', $this, $workerId, $workerPid, $exitCode, $signal);
        });
    }
1356245
@Handler(channels = Self.class)
    public void onRegistered(NioRegistration.Completed event)
            throws InterruptedException, IOException {
        NioHandler handler = event.event().handler();
        if (handler == this) {
            if (event.event().get() == null) {
                fire(new Error(event,
                    "Registration failed, no NioDispatcher?"));
                return;
            }
            registration = event.event().get();
            purger = new Purger();
            purger.start();
            fire(new Ready(serverSocketChannel.getLocalAddress()));
            return;
        }
        if (handler instanceof TcpChannelImpl) {
            TcpChannelImpl channel = (TcpChannelImpl) handler;
            channel.downPipeline()
                .fire(new Accepted(channel.nioChannel().getLocalAddress(),
                    channel.nioChannel().getRemoteAddress(), false,
                    Collections.emptyList()), channel);
            channel.registrationComplete(event.event());
        }
    }
1000032
public void setRecoveryLogService(ServiceReference<RecLogServiceImpl> ref) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "setRecoveryLogService", ref);

        _recoveryLogServiceReady = true;

        if (ableToStartRecoveryNow()) {
            // Can start recovery now
            try {
                startRecovery();
            } catch (Exception e) {
                FFDCFilter.processException(e, "com.ibm.tx.jta.util.impl.TxTMHelper.setRecoveryLogService", "148", this);
            }
        }
        if (tc.isEntryEnabled())
            Tr.exit(tc, "setRecoveryLogService");
    }
1248520
private synchronized void recover() {

		try {

			// close all reopen dataRecorders
			this.close();

			Set<String> loggerNames = this.dataLoggerFactory.findLoggerNames();

			// recover all logs
			for (String loggerName : loggerNames) {

				IDataLogger dataLogger = this.dataLoggerFactory.instanciateLogger(loggerName);
				XADataLogger xaLogger = new XADataLogger(dataLogger);

				PhynixxXADataRecorder phynixxXADataRecorder = PhynixxXADataRecorder.recoverDataRecorder(xaLogger, this);
				this.addXADataRecorder(phynixxXADataRecorder);

			}
		} catch (Exception e) {
			throw new DelegatedRuntimeException(e);
		}

	}
315176
function recrawlError(error, options, callback) {

      if (options.currentRetries <= options.retries) {
        onRecrawl(error,options, callback);
      }
      else {
        callback();
      }
  }
123756
protected void storeRecovery(Recovery r, XMLStreamWriter writer) throws Exception
   {
      writer.writeStartElement(CommonXML.ELEMENT_RECOVERY);

      if (r.isNoRecovery() != null)
         writer.writeAttribute(CommonXML.ATTRIBUTE_NO_RECOVERY,
                               r.getValue(CommonXML.ATTRIBUTE_NO_RECOVERY, r.isNoRecovery().toString()));

      if (r.getCredential() != null)
      {
         writer.writeStartElement(CommonXML.ELEMENT_RECOVERY_CREDENTIAL);

         writer.writeStartElement(CommonXML.ELEMENT_SECURITY_DOMAIN);
         writer.writeCharacters(r.getCredential().getValue(CommonXML.ELEMENT_SECURITY_DOMAIN,
                                                              r.getCredential().getSecurityDomain()));
         writer.writeEndElement();

         writer.writeEndElement();
      }

      if (r.getPlugin() != null)
      {
         storeExtension(r.getPlugin(), writer, CommonXML.ELEMENT_RECOVERY_PLUGIN);
      }

      writer.writeEndElement();
   }
480887
public static function register(self $handler = null, $replace = true)
    {
        if (null === self::$reservedMemory) {
            self::$reservedMemory = str_repeat('x', 10240);
            register_shutdown_function(__CLASS__.'::handleFatalError');
        }

        if ($handlerIsNew = null === $handler) {
            $handler = new static();
        }

        if (null === $prev = set_error_handler(array($handler, 'handleError'))) {
            restore_error_handler();
            // Specifying the error types earlier would expose us to https://bugs.php.net/63206
            set_error_handler(array($handler, 'handleError'), $handler->thrownErrors | $handler->loggedErrors);
            $handler->isRoot = true;
        }

        if ($handlerIsNew && is_array($prev) && $prev[0] instanceof self) {
            $handler = $prev[0];
            $replace = false;
        }
        if ($replace || !$prev) {
            $handler->setExceptionHandler(set_exception_handler(array($handler, 'handleException')));
        } else {
            restore_error_handler();
        }

        $handler->throwAt(E_ALL & $handler->thrownErrors, true);

        return $handler;
    }
458915
public synchronized void sendRetry(long retry, EventCallback callback) {

        if (open == 0 || shutdown) {
            if (callback != null) {
                callback.failed(this, null, null, null, new ClosedChannelException());
            }
            return;
        }
        queue.add(new SSEData(retry, callback));
        sink.getIoThread().execute(new Runnable() {
            @Override
            public void run() {
                synchronized (ServerSentEventConnection.this) {
                    if (pooled == null) {
                        fillBuffer();
                        writeListener.handleEvent(sink);
                    }
                }
            }
        });
    }