Set the message receiver for this filter.
@param messageReceiver The message receiver.
772629
public void setMessageReceiver(BaseMessageReceiver messageReceiver, Integer intID)
    {
        if ((messageReceiver != null) || (intID != null))
            if ((m_intID != null) || (m_messageReceiver != null))
                Util.getLogger().warning("BaseMessageFilter/setMessageReceiver()----Error - Filter added twice.");
        m_messageReceiver = messageReceiver;
        m_intID = intID;
    }
614769
public void addMessageFilter(MessageFilter messageFilter)
    {
        super.addMessageFilter(messageFilter);
        try   {
            // If at all possible, pass the queue's current session, so the filter is in the proper environment
            if (((BaseMessageFilter)messageFilter).isCreateRemoteFilter())   // Almost always true
            {       // Create the remote version of this filter.
                RemoteSession remoteSession = (RemoteSession)((BaseMessageFilter)messageFilter).getRemoteSession();
                BaseMessageFilter remoteFilter = m_receiveQueue.addRemoteMessageFilter((BaseMessageFilter)messageFilter, remoteSession);
                ((BaseMessageFilter)messageFilter).setRemoteFilterInfo(remoteFilter.getQueueName(), remoteFilter.getQueueType(), remoteFilter.getFilterID(), remoteFilter.getRegistryID());
            }
        } catch (RemoteException ex)    {
            ex.printStackTrace();
        }
    }
354435
private synchronized void setService( final T newService )
    {
        if( m_service != newService )
        {
            LOG.debug( "Service changed [" + m_service + "]  -> [" + newService + "]" );
            final T oldService = m_service;
            m_service = newService;
            if( m_serviceListener != null )
            {
                m_serviceListener.serviceChanged( oldService, m_service );
            }
        }
    }
773982
public void setMessageControlClassification(String value) {
        if (value != null) {
            getHdr2().setField(JsHdr2Access.MESSAGECONTROLCLASSIFICATION_DATA, value);
        }
        else {
            getHdr2().setChoiceField(JsHdr2Access.MESSAGECONTROLCLASSIFICATION, JsHdr2Access.IS_MESSAGECONTROLCLASSIFICATION_EMPTY);
        }
    }
1092533
static synchronized void setRetryBroadcastReceiver(Context context) {
        if (sRetryReceiver == null) {
            if (sRetryReceiverClassName == null) {
                // should never happen
                Log.e(TAG, "internal error: retry receiver class not set yet");
                sRetryReceiver = new GCMBroadcastReceiver();
            } else {
                Class<?> clazz;
                try {
                    clazz = Class.forName(sRetryReceiverClassName);
                    sRetryReceiver = (GCMBroadcastReceiver) clazz.newInstance();
                } catch (Exception e) {
                    Log.e(TAG, "Could not create instance of " +
                            sRetryReceiverClassName + ". Using " +
                            GCMBroadcastReceiver.class.getName() +
                            " directly.");
                    sRetryReceiver = new GCMBroadcastReceiver();
                }
            }
            String category = context.getPackageName();
            IntentFilter filter = new IntentFilter(
                    GCMConstants.INTENT_FROM_GCM_LIBRARY_RETRY);
            filter.addCategory(category);
            // must use a permission that is defined on manifest for sure
            String permission = category + ".permission.C2D_MESSAGE";
            Log.v(TAG, "Registering receiver");
            context.registerReceiver(sRetryReceiver, filter, permission, null);
        }
    }
270873
public void setNewFilterTree(BaseMessageFilter messageFilter, Object[][] mxProperties)
    {
        if (mxProperties != null)
            messageFilter.setNameValueTree(mxProperties);  // Update the new properties.
    }
49493
public synchronized void setRegistry( MessagingClientFactoryRegistry registry ) {

		if( this.registry != null )
			this.registry.removeListener(this);

		this.registry = registry;
		if (registry != null)
			registry.addListener(this);
	}
620008
private void collectReceiver(final Class<?> eventClass, final Collection<ReceiverDescriptor> receiverCollection) {

		if (this.receiverMap.get(eventClass) != null) {
			receiverCollection.addAll(this.receiverMap.get(eventClass));
		}
		if (!eventClass.isInterface() && eventClass.getSuperclass() != Object.class) {
			this.collectReceiver(eventClass.getSuperclass(), receiverCollection);
		}
		for (final Class interfaceClass : eventClass.getInterfaces()) {
			this.collectReceiver(interfaceClass, receiverCollection);
		}
	}
1215966
public void setErrorMessage(String errorMessage) {

        m_errorMessage = errorMessage;
        m_errorLabel.setValue(errorMessage != null ? errorMessage : "");
    }
856342
@Reference(name = KEY_MESSAGE_STORE, service = MessageStore.class)
    protected void setMessageStore(ServiceReference<MessageStore> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.entry(tc, "setMessageStore", ref);
        messageStoreRef.setReference(ref);

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.exit(tc, "setMessageStore");
    }
1232569
public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
		Assert.notEmpty(messageConverters, "'messageConverters' must not be empty");
		// Take getMessageConverters() List as-is when passed in here
		if (this.messageConverters != messageConverters) {
			this.messageConverters.clear();
			this.messageConverters.addAll(messageConverters);
		}
	}
52804
public void registerReceiver (InvocationDecoder decoder)
    {
        // add the receiver to the list
        _reclist.add(decoder);

        // if we're already online, assign a receiver id to this decoder
        if (_clobj != null) {
            assignReceiverId(decoder);
        }
    }
696734
@Generated(value={"com.threerings.presents.tools.GenDObjectTask"})
    public void updateReceivers (InvocationReceiver.Registration elem)
    {
        requestEntryUpdate(RECEIVERS, receivers, elem);
    }
1153692
public void setMessagingAuthenticationService(
			MessagingAuthenticationService messagingAuthenticationService) {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
			SibTr.entry(tc, CLASS_NAME + "setMessagingAuthenticationService",
					messagingAuthenticationService);
		}
		this.messagingAuthenticationService = messagingAuthenticationService;
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
			SibTr.exit(tc, CLASS_NAME + "setMessagingAuthenticationService");
		}
	}
231842
protected void assignReceiverId (InvocationDecoder decoder)
    {
        Registration reg = new Registration(decoder.getReceiverCode(), nextReceiverId());
        // stick the mapping into the client object
        _clobj.addToReceivers(reg);
        // and map the receiver in our receivers table
        _receivers.put(reg.receiverId, decoder);
//         Log.info("Registered receiver " + StringUtil.shortClassName(decoder) + " " + reg + ".");
    }
777997
@Override
    public void onReceive(Object message) {
        if (message instanceof NewMessage) {
            NewMessage newMessage = (NewMessage) message;
            onNewMessage(newMessage.getPeer(), newMessage.getSender(), newMessage.getSortDate(),
                    newMessage.getContentDescription(), newMessage.getHasCurrentUserMention(),
                    newMessage.getUnreadMessagesCount(), newMessage.getUnreadDialogsCount());
        } else if (message instanceof MessagesRead) {
            MessagesRead read = (MessagesRead) message;
            onMessagesRead(read.getPeer(), read.getFromDate());
        } else if (message instanceof PauseNotifications) {
            onNotificationsPaused();
        } else if (message instanceof ResumeNotifications) {
            onNotificationsResumed();
        } else {
            super.onReceive(message);
        }
    }
721544
def send_msg(self, msg):
        
        for receiver in msg.receivers:
            current_receiver = self.receivers.get(receiver, self.default_receiver)
            current_receiver.send_msg(msg)