<p>
A list of "DatasetTrigger" objects. The list can be empty or can contain up to five <b>DataSetTrigger</b>
objects.
</p>

@param triggers
A list of "DatasetTrigger" objects. The list can be empty or can contain up to five <b>DataSetTrigger</b>
objects.
196619
public void setTriggers(java.util.Collection<DatasetTrigger> triggers) {
        if (triggers == null) {
            this.triggers = null;
            return;
        }

        this.triggers = new java.util.ArrayList<DatasetTrigger>(triggers);
    }
1358232
public DataProviderContext on(final Trigger... triggers) {
        if (triggers != null) {
            Collections.addAll(registeredTriggers, triggers);
        }
        return this;
    }
426901
public void setTriggerNames(java.util.Collection<String> triggerNames) {
        if (triggerNames == null) {
            this.triggerNames = null;
            return;
        }

        this.triggerNames = new java.util.ArrayList<String>(triggerNames);
    }
379589
private void hookToTrigger(final T trigger) {
        // Hook to trigger only if not already done (the same trigger adatper will be used if it was already hooked)
        if (!triggersToTriggerAdapters.containsKey(trigger)) {
            final TriggerListener triggerAdapter = new TriggerAdapter(trigger);
            triggersToTriggerAdapters.put(trigger, triggerAdapter);
            trigger.addTriggerListener(triggerAdapter);
        }
    }
350633
@Override
	public void changeTriggerState(String groupName, String jobName, final String triggerGroup, final String triggerName) throws SchedulerException {
		if (!config.isChangetTriggerStateAllowed()) {
			LOGGER.warn("not allowed to change any trigger state");
			return;
		}
		Trigger triggerFound = findTrigger(groupName, jobName, triggerGroup, triggerName);
		
		if (null != triggerFound) {
			// pause only the one trigger of job
			changeTriggerState(triggerFound);
			if (LOGGER.isDebugEnabled())
				LOGGER.debug(String.format("pausing trigger for group: %s, job: %s, trigger: %s ", groupName, jobName,
						triggerName));
		} else {
			if (LOGGER.isDebugEnabled())
				LOGGER.debug(String.format("pausing all triggers for group: %s, job: %s", groupName, jobName));
			List<? extends Trigger> triggers = scheduler.getTriggersOfJob(new JobKey(jobName, groupName));
			for (Trigger trigger : triggers) {
				// pause all triggers of job
				changeTriggerState(trigger);
			}
		}
	}
29321
@Override
    public OperableTrigger retrieveTrigger(final TriggerKey triggerKey) throws JobPersistenceException {
        return doWithLock(new LockCallback<OperableTrigger>() {
            @Override
            public OperableTrigger doWithLock(JedisCommands jedis) throws JobPersistenceException {
                return storage.retrieveTrigger(triggerKey, jedis);
            }
        }, "Could not retrieve trigger.");
    }
526234
public void setTrigger(EventTrigger v) {
    if (EventMention_Type.featOkTst && ((EventMention_Type)jcasType).casFeat_trigger == null)
      jcasType.jcas.throwFeatMissing("trigger", "de.julielab.jules.types.EventMention");
    jcasType.ll_cas.ll_setRefValue(addr, ((EventMention_Type)jcasType).casFeatCode_trigger, jcasType.ll_cas.ll_getFSRef(v));}
1124741
public static List<TriggerDefinition> fromSchema(Row serializedTriggers)
    {
        List<TriggerDefinition> triggers = new ArrayList<>();
        String query = String.format("SELECT * FROM %s.%s", Keyspace.SYSTEM_KS, SystemKeyspace.SCHEMA_TRIGGERS_CF);
        for (UntypedResultSet.Row row : QueryProcessor.resultify(query, serializedTriggers))
        {
            String name = row.getString(TRIGGER_NAME);
            String classOption = row.getMap(TRIGGER_OPTIONS, UTF8Type.instance, UTF8Type.instance).get(CLASS);
            triggers.add(new TriggerDefinition(name, classOption));
        }
        return triggers;
    }
1223754
public static void validateTriggers(String targetType, Collection<BoxWebHook.Trigger> triggers) {
        for (BoxWebHook.Trigger trigger : triggers) {
            validateTrigger(targetType, trigger);
        }
    }
848645
public void createDeleteTrigger(String tableName,
			String geometryColumnName, String idColumnName) {

		String sqlName = GeoPackageProperties.getProperty(TRIGGER_PROPERTY,
				TRIGGER_DELETE_NAME);
		executeSQL(sqlName, tableName, geometryColumnName, idColumnName);
	}
983422
public void addInternalTriggerListener (final ITriggerListener triggerListener)
  {
    ValueEnforcer.notNull (triggerListener, "TriggerListener");
    ValueEnforcer.notEmpty (triggerListener.getName (), "TriggerListener.getName()");

    synchronized (m_aInternalTriggerListeners)
    {
      m_aInternalTriggerListeners.put (triggerListener.getName (), triggerListener);
    }
  }
1016958
TriggerDef getTrigger(String name) {

        for (int i = triggerList.length - 1; i >= 0; i--) {
            if (triggerList[i].name.name.equals(name)) {
                return triggerList[i];
            }
        }

        return null;
    }
1255503
private static void validateTrigger(String targetType, BoxWebHook.Trigger trigger) {
        for (String type : trigger.getTypes()) {
            if (targetType.equals(type)) {
                return;
            }
        }
        throw new IllegalArgumentException(String.format(
                "Provided trigger '%s' is not supported on provided target '%s'.", trigger.name(), targetType));
    }
313032
@PublicEvolving
	public WindowedStream<T, K, W> trigger(Trigger<? super T, ? super W> trigger) {
		if (windowAssigner instanceof MergingWindowAssigner && !trigger.canMerge()) {
			throw new UnsupportedOperationException("A merging window assigner cannot be used with a trigger that does not support merging.");
		}

		if (windowAssigner instanceof BaseAlignedWindowAssigner) {
			throw new UnsupportedOperationException("Cannot use a " + windowAssigner.getClass().getSimpleName() + " with a custom trigger.");
		}

		this.trigger = trigger;
		return this;
	}
169551
@Override
    public List<OperableTrigger> getTriggersForJob(final JobKey jobKey) throws JobPersistenceException {
        return doWithLock(new LockCallback<List<OperableTrigger>>() {
            @Override
            public List<OperableTrigger> doWithLock(JedisCommands jedis) throws JobPersistenceException {
                return storage.getTriggersForJob(jobKey, jedis);
            }
        }, "Could not retrieve triggers for job.");
    }
93844
public void setTriggersNotFound(java.util.Collection<String> triggersNotFound) {
        if (triggersNotFound == null) {
            this.triggersNotFound = null;
            return;
        }

        this.triggersNotFound = new java.util.ArrayList<String>(triggersNotFound);
    }
1297686
protected void fireTriggerEvent(TriggerEvent event) {
        try {
            for (TriggerListener listener : listeners) {
                listener.triggerValidation(event);
            }
        } catch (RuntimeException e) {
            uncheckedExceptionHandler.handleException(e);
        } catch (Error e) {
            uncheckedExceptionHandler.handleError(e);
        }
    }