Sets if the publish queue is re-initialized on startup.<p>

@param publishQueuePersistance the persistence flag, parsed as <code>boolean</code>
347422
public void setPublishQueuePersistance(String publishQueuePersistance) {

        if (m_frozen) {
            throw new CmsRuntimeException(Messages.get().container(Messages.ERR_CONFIG_FROZEN_0));
        }
        m_publishQueuePersistance = Boolean.valueOf(publishQueuePersistance).booleanValue();
    }
94908
public void initialiseNonPersistent(MessageProcessor messageProcessor,
                                      SIMPTransactionManager txManager)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "initialiseNonPersistent", messageProcessor);

    //Release 1 has no Link Bundle IDs for this Neighbour

    // Cache the reference to the message processor
    _messageProcessor = messageProcessor;

    // Create the ObjectPool that will be used to store the 
    // subscriptionMessages.  Creating with an intial length of
    // 2, but this could be made a settable parameter for performance
    _subscriptionMessagePool = new ObjectPool("SubscriptionMessages", NUM_MESSAGES);

    // Create a new object to contain all the Neighbours
    _neighbours = new Neighbours(this, _messageProcessor.getMessagingEngineBus());

    // Create a new LockManager instance
    _lockManager = new LockManager();
    
    // Assign the transaction manager
    _transactionManager = txManager;
            
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "initialiseNonPersistent");
  }
201719
void initializeReplQueues() throws SafeModeException {
    writeLock();
    try {
      if (isPopulatingReplQueues()) {
        NameNode.stateChangeLog.info("STATE* Safe mode is already OFF."
            + " Replication queues are initialized");
        return;
      }
      safeMode.initializeReplicationQueues();
    } finally {
      writeUnlock();
    }
  }
527056
public void setReplicasToRemove(java.util.Collection<String> replicasToRemove) {
        if (replicasToRemove == null) {
            this.replicasToRemove = null;
            return;
        }

        this.replicasToRemove = new com.amazonaws.internal.SdkInternalList<String>(replicasToRemove);
    }
1229967
public DelegateEbeanServer withPersisting(boolean persisting) {
    persistBulkUpdates = persisting;
    persistDeletes = persisting;
    persistInserts = persisting;
    persistUpdates = persisting;
    persistSaves = persisting;
    return this;
  }
197536
protected void initRefreshCycle() {
        // Check if should check for updates
        Integer refresh = PropertyUtil.getPropertyAsInteger(PropertyUtil.HAWKULAR_APM_CONFIG_REFRESH);

        if (log.isLoggable(Level.FINER)) {
            log.finer("Configuration refresh cycle (in seconds) = " + refresh);
        }

        if (refresh != null) {
            Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
                public Thread newThread(Runnable r) {
                    Thread t = Executors.defaultThreadFactory().newThread(r);
                    t.setDaemon(true);
                    return t;
                }
            }).scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        Map<String, TransactionConfig> changed = configurationService.getTransactions(null,
                                configLastUpdated);

                        for (Map.Entry<String, TransactionConfig> stringBusinessTxnConfigEntry : changed.entrySet()) {
                            TransactionConfig btc = stringBusinessTxnConfigEntry.getValue();

                            if (btc.isDeleted()) {
                                if (log.isLoggable(Level.FINER)) {
                                    log.finer("Removing config for btxn '" + stringBusinessTxnConfigEntry.getKey() + "' = " + btc);
                                }

                                filterManager.remove(stringBusinessTxnConfigEntry.getKey());
                                processorManager.remove(stringBusinessTxnConfigEntry.getKey());
                            } else {
                                if (log.isLoggable(Level.FINER)) {
                                    log.finer("Changed config for btxn '" + stringBusinessTxnConfigEntry.getKey() + "' = " + btc);
                                }

                                filterManager.init(stringBusinessTxnConfigEntry.getKey(), btc);
                                processorManager.init(stringBusinessTxnConfigEntry.getKey(), btc);
                            }

                            if (btc.getLastUpdated() > configLastUpdated) {
                                configLastUpdated = btc.getLastUpdated();
                            }
                        }
                    } catch (Exception e) {
                        log.log(Level.SEVERE, "Failed to update transaction configuration", e);
                    }
                }
            }, refresh.intValue(), refresh.intValue(), TimeUnit.SECONDS);
        }
    }
1123480
@Override
    public void setJobQueue(int jobId, Queue queue)
    {
        JqmClientFactory.getClient().setJobQueue(jobId, queue);
    }
1273806
private void publishStartedEvent() {
        BatchEventsPublisher publisher = getBatchEventsPublisher();
        if (publisher != null) {

            publisher.publishSplitFlowEvent(getSplitName(),
                                            getFlowName(),
                                            getTopLevelInstanceId(),
                                            getTopLevelExecutionId(),
                                            BatchEventsPublisher.TOPIC_EXECUTION_SPLIT_FLOW_STARTED,
                                            correlationId);
        }
    }
1283162
@Override
    public void engineReloaded(Object messagingEngine)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "engineReloaded");

        // Defect 337421.1
        // Our config has been reloaded so we need to essentially
        // re-initialize so that the next time that we run start()
        // we pick up any changes.
        initialize((JsMessagingEngine) messagingEngine, true);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "engineReloaded");
    }
192955
public boolean enable(Jid pushJid, String node, HashMap<String, String> publishOptions)
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        EnablePushNotificationsIQ enablePushNotificationsIQ = new EnablePushNotificationsIQ(pushJid, node,
                publishOptions);
        return changePushNotificationsStatus(enablePushNotificationsIQ);
    }
1242502
public void setPublishModel(PublishModel publish)  {
        addField(ConfigureNodeFields.publish_model, FormField.Type.list_single);
        setAnswer(ConfigureNodeFields.publish_model.getFieldName(), getListSingle(publish.toString()));
    }
1205754
public function prePersist(LifecycleEventArgs $args): void
    {
        // Get the object and make sure it is what we need.
        $object = $args->getObject();
        if (!$object instanceof PublishableInterface) {
            return;
        }

        // Publish active objects immediately.
        if ($object->isActive()) {
            $object->setPublished(true);
        } else {
            $object->setPublished(false);
        }
    }
88356
public void setQueueList(List<String> queueList) throws RabbitmqCommunicateException
    {
        if (queueList == null || queueList.size() == 0)
        {
            String message = "QueueList is not defined.";
            throw new RabbitmqCommunicateException(message);
        }
        this.queueList = queueList;
    }
949081
@Override
    public final void setJmsDeliveryMode(PersistenceType value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setJmsDeliveryMode", value);
        getHdr2().setField(JsHdr2Access.JMSDELIVERYMODE_DATA, value.toByte());
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setJmsDeliveryMode");
    }
552367
private void restoreQueuedSubscription(String providerId, ProviderContainer providerContainer) {
        Collection<PublicationInformation> queuedRequests = queuedSubscriptionRequests.get(providerId);
        Iterator<PublicationInformation> queuedRequestsIterator = queuedRequests.iterator();
        while (queuedRequestsIterator.hasNext()) {
            PublicationInformation publicationInformation = queuedRequestsIterator.next();
            queuedRequestsIterator.remove();
            if (!isExpired(publicationInformation)) {
                addSubscriptionRequest(publicationInformation.getProxyParticipantId(),
                                       publicationInformation.getProviderParticipantId(),
                                       publicationInformation.subscriptionRequest,
                                       providerContainer);
            }
        }
    }
1050306
public function postPersist(LifecycleEventArgs $args): void
    {
        // Get the object and make sure it is what we need.
        $object = $args->getObject();
        if (!$object instanceof PublishableInterface) {
            return;
        }

        // Execute published event after the object is persisted.
        if ($object->isPublished()) {
            $event = new EntityPublishedEvent($object);
            $this->event_dispatcher->dispatch(EntityPublishedEvent::NAME, $event);
        }
    }
720830
@Reference(service = ServerStarted.class,
               policy = ReferencePolicy.DYNAMIC,
               cardinality = ReferenceCardinality.OPTIONAL,
               policyOption = ReferencePolicyOption.GREEDY)
    protected void setServerStarted(ServiceReference<ServerStarted> ref) {
        // set will be called when the ServerStarted service has been registered (by the FeatureManager as of 9/2015).  This is a signal that that
        // the server is fully started.  Therefore we can signal such things as the TCP Channel Accept logic to start accepting connections, if the
        // channel has been configured to do that.

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "Server Completely Started signal received");
        }

        synchronized (syncStarted) {
            serverCompletelyStarted = true;
            syncStarted.notifyAll();
        }
    }