<p>
A list of criteria that can be used in selecting this connection.
</p>

@param matchCriteria
A list of criteria that can be used in selecting this connection.
336498
public void setMatchCriteria(java.util.Collection<String> matchCriteria) {
        if (matchCriteria == null) {
            this.matchCriteria = null;
            return;
        }

        this.matchCriteria = new java.util.ArrayList<String>(matchCriteria);
    }
223118
public BuildableCriteria join(String associationPath) {
        criteria.setFetchMode(calculatePropertyName(associationPath), FetchMode.JOIN);
        return this;
    }
258836
public SelectionCriteria createSelectionCriteria(String discriminator,
                                                 String selectorString,
                                                 SelectorDomain selectorDomain) 
  
  throws SIErrorException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "createSelectionCriteria", 
        new Object[]{discriminator, selectorString, selectorDomain});        
    
    SelectionCriteria criteria = new SelectionCriteriaImpl(discriminator,
                                                           selectorString,
                                                           selectorDomain);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createSelectionCriteria", criteria);
      
    return criteria;
  }
437544
@Override
	public RuntimeResourceDefinition validateCriteriaAndReturnResourceDefinition(String criteria) {
		String resourceName;
		if (criteria == null || criteria.trim().isEmpty()) {
			throw new IllegalArgumentException("Criteria cannot be empty");
		}
		if (criteria.contains("?")) {
			resourceName = criteria.substring(0, criteria.indexOf("?"));
		} else {
			resourceName = criteria;
		}

		return getContext().getResourceDefinition(resourceName);
	}
259952
public void addQueryCriterion(QueryCriterion criterion){
        if( criteria == null){
            criteria = new ArrayList<QueryCriterion>();
        }
        criteria.add(criterion);
    }
151604
public static void copyCriteriaNoSelection(CriteriaQuery<?> from, CriteriaQuery<?> to) {

        // Copy Roots
        for (Root<?> root : from.getRoots()) {
            Root<?> dest = to.from(root.getJavaType());
            dest.alias(getOrCreateAlias(root));
            copyJoins(root, dest);
        }

        if (from.getGroupList() != null) to.groupBy(from.getGroupList());
        to.distinct(from.isDistinct());
        if (from.getGroupRestriction() != null) to.having(from.getGroupRestriction());
        if (from.getRestriction() != null) to.where(from.getRestriction());
        if (from.getOrderList() != null) to.orderBy(from.getOrderList());
    }
306646
private void matchX509CRLs(CRLSelector selector, Collection<CRL> matches) {
        for (Object obj : crlIssuers.values()) {
            if (obj instanceof X509CRL) {
                X509CRL crl = (X509CRL)obj;
                if (selector.match(crl)) {
                    matches.add(crl);
                }
            } else {
                // See crlIssuers javadoc.
                @SuppressWarnings("unchecked")
                List<X509CRL> list = (List<X509CRL>)obj;
                for (X509CRL crl : list) {
                    if (selector.match(crl)) {
                        matches.add(crl);
                    }
                }
            }
        }
    }
454266
public void setMatchingEventTypes(java.util.Collection<String> matchingEventTypes) {
        if (matchingEventTypes == null) {
            this.matchingEventTypes = null;
            return;
        }

        this.matchingEventTypes = new java.util.ArrayList<String>(matchingEventTypes);
    }
54491
public SelectionCriteria[] getCriterias()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getCriterias");
      
    SelectionCriteria[] criterias = aiRequestedTick.getCriterias();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "getCriterias", criterias);
    return criterias;
  }
1011904
public Criteria addCriteria(final int _idx, final List<String> _sqlColNames, final Comparison _comparison,
                            final Set<String> _values, final boolean _escape, final Connection _connection)
    {
        final Criteria criteria = new Criteria()
                        .tableIndex(_idx)
                        .colNames(_sqlColNames)
                        .comparison(_comparison)
                        .values(_values)
                        .escape(_escape)
                        .connection(_connection);
        sections.add(criteria);
        return criteria;
    }
1374930
public void removeSelectionCriteria(SelectionCriteria selCriteria) 
    throws SIResourceException
    {

      if (tc.isEntryEnabled())
        SibTr.entry(tc, "removeSelectionCriteria", 
          new Object[] { selCriteria });
      
      // If the selection criteria was removed then this is an indication that it was
      // in the matchspace and it can be removed.
      boolean wasRemoved = 
        _consumerDispatcher.getConsumerDispatcherState().removeSelectionCriteria(selCriteria);      
      
      if (wasRemoved)
      {
        Transaction tran = _messageProcessor.getTXManager().createAutoCommitTransaction();
        if( !_consumerDispatcher.getReferenceStream().isUpdating() )
        {
          try 
          {
            _consumerDispatcher.getReferenceStream().requestUpdate(tran);
          } 
          catch (MessageStoreException e) 
          {
            // MessageStoreException shouldn't occur so FFDC.
            FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.impl.MPSubscriptionImpl.removeSelectionCriteria",
            "1:203:1.6",
            this);
    
            // Add the criteria back into the list as the remove failed.
            _consumerDispatcher.getConsumerDispatcherState().addSelectionCriteria(selCriteria);
            
            SibTr.exception(tc, e);
            if (tc.isEntryEnabled()) SibTr.exit(tc, "removeSelectionCriteria", "SIResourceException");
            throw new SIResourceException(e);
              
          }
        }
  
        // Remove the criteria from the matchspace
        _messageProcessor
         .getMessageProcessorMatching()
         .removeConsumerDispatcherMatchTarget(
          _consumerDispatcher,
          selCriteria );
      }
        
      if (tc.isEntryEnabled())
        SibTr.exit(tc, "removeSelectionCriteria"); 
   
    }
1037990
public boolean match(String destination, String metricName) {
        int[] matches = match(destination);
        if (matches == null || matches.length == 0) {
            return false;
        }
        for (int match : matches) {
            String candidateMetricName = proxyRules.get(match).getMetricSystemName();
            if (metricName.equals(candidateMetricName)) {
                return true;
            }
        }
        return false;
    }
128602
public void setCriterion(Criterion criterion) {
		this.criterion = criterion;

		// Replace the handler if it is of type featureList 
		// (when we have a criterion it is better to use that as it has no limitation on returned items)
		if (exportCsvHandler == null || exportCsvHandler instanceof ExportFeatureListToCsvHandler) {
			this.exportCsvHandler = new ExportSearchToCsvHandler(mapWidget.getMapModel(), layer, criterion);
		} else if (exportCsvHandler instanceof ExportSearchToCsvHandler) {
			((ExportSearchToCsvHandler) exportCsvHandler).setCriterion(criterion);
		}
	}
699825
@Override
	public <Q> List<Q> executeCriteria(CriteriaQuery<Q> criteriaQuery, Map<String, Object> parameters) {
		
		// Si la Requete est nulle
		if(criteriaQuery == null) throw new JPersistenceToolsException("jpagenericdaorulesbased.executeCriteria.query.null");
		
		// Requete Typee
		TypedQuery<Q> query = getEntityManager().createQuery(criteriaQuery);
		
		// Ajout des Parametres
		addQueryParameters(query, parameters);
		
		// Execution
		return query.getResultList();
	}
325162
public SelectionCriteria createSelectionCriteria()
    throws SIErrorException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "createSelectionCriteria" );        
    
    SelectionCriteria criteria = new SelectionCriteriaImpl(null,
                                                           "",
                                                           SelectorDomain.SIMESSAGE);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createSelectionCriteria", criteria);
      
    return criteria;
  }
689111
public List<Object> match() {
        final IntMatchResults result = new IntMatchResults();
        if (matches(result)) {
            return result.getIntResultList();
        } else {
            return null;
        }
    }
1030517
public synchronized SelectionCriteria getSelectionCriteria()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getSelectionCriteria"); //469395

      checkReleased();

      SelectorDomain selectorDomain = SelectorDomain.getSelectorDomain(getShort());
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Selector domain", selectorDomain);

      /**************************************************************/
      /* Destination                                                */
      /**************************************************************/
      String discriminator = getString();
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Discriminator:", discriminator);

      /**************************************************************/
      /* Destination                                                */
      /**************************************************************/
      String selector = getString();
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Selector:", selector);

      SelectionCriteria selectionCriteria =
    		  CommsClientServiceFacade.getSelectionCriteriaFactory().createSelectionCriteria(discriminator,
                                                                        selector,
                                                                        selectorDomain);



      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getSelectionCriteria"); //469395
      return selectionCriteria;
   }