Constructor.
@param messageReceiver The message receiver that this listener is added to.
@param messageFilter The filter for this message listener.
421017
public void init(BaseMessageReceiver messageReceiver, BaseMessageFilter messageFilter)
    {
        if (messageFilter == null)
        {
            if (messageReceiver != null)
            {
                messageFilter = messageReceiver.createDefaultFilter(this);    // Add filter to handler
                return; // All done. (createDefaultFilter adds the message listener to the new filter)
            }
        }
        if (messageFilter != null)
            messageFilter.addMessageListener(this);     // This will also add the message filter to my list.
    }
645419
public static MessageFilter compile(String filter) throws InvalidFilterException {
        MessageFilterParser parser = MessageFilterParser.createParser(filter);
        MessageFilterTranslatable t = parseToTranslatable(parser);
        MessageFilter translate = t.translate();
        if (BaseMessageFilter.class.isAssignableFrom(translate.getClass())) {
            ((BaseMessageFilter) translate).setOriginalDslString(filter);
        }

        return translate;
    }
781818
public BaseMessageFilter addRemoteMessageFilter(BaseMessageFilter messageFilter, RemoteSession remoteSession) throws RemoteException
    {
        BaseTransport transport = this.createProxyTransport(ADD_REMOTE_MESSAGE_FILTER);
        transport.addParam(FILTER, messageFilter);   // Don't use COMMAND
        String strSessionPathID = null;
        if (remoteSession instanceof BaseProxy)
        {   // Always a SessionProxy
            strSessionPathID = ((BaseProxy)remoteSession).getIDPath();
        }
        transport.addParam(SESSION, strSessionPathID);
        Object strReturn = transport.sendMessageAndGetReply();
        Object objReturn = transport.convertReturnObject(strReturn);
        return (BaseMessageFilter)objReturn;
    }
320647
public void addFilter(PropFilter filter)
	{
		if (mFilter == null)
		{
			mFilter = new ArrayList<PropFilter>(8);
		}

		mFilter.add(filter);
	}
1082747
public void init(String strQueueName, String strQueueType, Object source, Map<String,Object> properties)
    {
        m_messageReceiver = null;
        m_vListenerList = null;
        m_bCreateRemoteFilter = true;
        m_bUpdateRemoteFilter = true;
        m_bThinTarget = false;
        super.init(strQueueName, strQueueType, source, properties);
    }
1175019
@Override
	public final MessageConsumer createConsumer(Destination destination) throws JMSException
    {
        return createConsumer(destination,null,false);
    }
1369422
public void setFilter(Filter filter)
    {
        if (this.filter == null)
        {
            this.filter = new FilterList();
        }
        if (filter != null)
        {
            this.filter.addFilter(filter);
        }
    }
31796
@Override
    public ItemStream findFirstMatching(Filter filter) throws MessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "findFirstMatching", filter);

        if (_rootMembership != null)
        {
            ItemStream item = _rootMembership.findFirstMatchingItemStream(filter);

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "findFirstMatching", item);
            return item;
        }
        else
        {
            MessageStoreUnavailableException msue;
            if (!_startupExceptions.isEmpty())
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                    SibTr.event(this, tc, "Operation not possible as MessageStore failed to start!");
                msue = new MessageStoreUnavailableException("Operation not possible as MessageStore failed to start!", _startupExceptions.get(0));
            }
            else
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                    SibTr.event(this, tc, "Operation not possible as MessageStore is unavailable!");
                msue = new MessageStoreUnavailableException("Operation not possible as MessageStore is unavailable!");
            }

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "findFirstMatching");
            throw msue;
        }
    }
656969
public BaseMessageFilter createDefaultFilter(JMessageListener listener)
    {
        BaseMessageFilter messageFilter = null;
        String strQueueName = MessageConstants.RECORD_QUEUE_NAME; // Default queue name=
        String strQueueType = MessageConstants.INTRANET_QUEUE;    // Default queue type
        if (m_baseMessageQueue != null)
        {
            strQueueName = m_baseMessageQueue.getQueueName();
            strQueueType = m_baseMessageQueue.getQueueType();
        }
        messageFilter = new BaseMessageFilter(strQueueName, strQueueType, null, null);    // Take all messages
        messageFilter.addMessageListener(listener);
        //xif (bAddToReceiver)  // Already added at previous line.
        //x    this.addMessageFilter(messageFilter);
        return messageFilter;
    }
518283
public void removeDuplicateFilters(JMessageListener listenerToCheck)
    {
        for (int iIndex = 0; ; iIndex++)
        {
            BaseMessageFilter filter = listenerToCheck.getListenerMessageFilter(iIndex);
            if (filter == null)
                break;
            if (this.isSameFilter(filter))
            {
                if (filter.getMessageListener(1) == null)
                {   // Only free if the message list is the same and only
                    filter.removeFilterMessageListener(listenerToCheck);
                // DO NOT free the listener.
                    filter.free();     // Cool, it was a dup... get rid of it.
                    iIndex--;
                }
            }
        }
    }
289050
public void removeMessageListener(DigitalChannel channel, MessageListener<? extends Message> messageListener) {
        removeListener(channel.getIdentifier(), messageListener.getMessageType(), messageListener);
    }
142185
public void init(FieldList record, BaseMessageReceiver messageReceiver, BaseMessageFilter messageFilter)
    {
        super.init(messageReceiver, messageFilter);
        m_record = record;
    }
1216381
public void addFilter(final ItemFilter filter) {
        if (filters == null) {
            filters = new ArrayList<ItemFilter>();
        }

        filters.add(filter);
    }
1211471
public void addFilter(AuditEventFilter filter){
        if (filters == null) {
            filters = new ArrayList<AuditEventFilter>();
        }
        filters.add(filter);
    }
1346333
public void init(BaseMessageReceiver messageReceiver, AbstractTableModel model)
    {
        super.init(messageReceiver, null);
        m_model = model;
    }
941393
public MessageReceiverFilterList getMessageFilterList()
    {
        if (m_filterList == null)
        {
            String strFilterType = null;
            App app = this.getMessageQueue().getMessageManager().getApplication();
            if (app != null)
                strFilterType = app.getProperty(MessageConstants.MESSAGE_FILTER);
            if (MessageConstants.TREE_FILTER.equals(strFilterType))
                m_filterList = new TreeMessageFilterList(this);
        }
        return super.getMessageFilterList();
    }
1036545
@Override
    public void setFilter(Service.Filter filter) {
        _filter = _filter == null ? filter : new CompoundServiceFilter(filter, _filter);
    }