New conditions element.

@param notBefore    the not before
@param notOnOrAfter the not on or after
@param audienceUri  the service id
@return the conditions
173847
public Conditions newConditions(final ZonedDateTime notBefore, final ZonedDateTime notOnOrAfter, final String... audienceUri) {
        LOGGER.debug("Building conditions for audience [{}] that enforce not-before [{}] and not-after [{}]", audienceUri, notBefore, notOnOrAfter);
        val conditions = newSamlObject(Conditions.class);
        conditions.setNotBefore(DateTimeUtils.dateTimeOf(notBefore));
        conditions.setNotOnOrAfter(DateTimeUtils.dateTimeOf(notOnOrAfter));

        val audienceRestriction = newSamlObject(AudienceRestriction.class);
        Arrays.stream(audienceUri).forEach(audienceEntry -> {
            val audience = newSamlObject(Audience.class);
            audience.setAudienceURI(audienceEntry);
            audienceRestriction.getAudiences().add(audience);
        });
        conditions.getAudienceRestrictions().add(audienceRestriction);
        return conditions;
    }
552318
public Element<T> insertBefore( Element<T> next , T object ) {
		Element<T> e = requestNew();
		e.object = object;
		e.previous = next.previous;
		e.next = next;

		if( e.previous != null ) {
			e.previous.next = e;
		} else {
			first = e;
		}
		next.previous = e;
		size++;
		return e;
	}
998225
function checkNewlineBefore({
  string,
  globalIndex,
  startIndex,
  endIndex,
  node,
  result
}) {
  const symbol = string.substring(startIndex, endIndex + 1);
  let newLineBefore = false;

  let index = endIndex + 1;

  while (index && isWhitespace(string[index])) {
    if (string[index] === "\n") {
      newLineBefore = true;
      break;
    }

    index++;
  }

  if (newLineBefore) {
    utils.report({
      ruleName,
      result,
      node,
      message: messages.rejected(symbol),
      index: endIndex + globalIndex
    });
  }
}
711632
function before (el, newEl) {
  if (typeof newEl === 'string') {
    return el.insertAdjacentHTML('beforebegin', newEl)
  } else {
    return el.parentNode.insertBefore(newEl, el)
  }
}
975026
public boolean isSubscriptionPreApprovalSupported() throws NotLoggedInException {
        final XMPPConnection connection = getAuthenticatedConnectionOrThrow();
        return connection.hasFeature(SubscriptionPreApproval.ELEMENT, SubscriptionPreApproval.NAMESPACE);
    }
1321045
public BusItineraryHalt insertBusHaltBefore(BusItineraryHalt beforeHalt, UUID id, BusItineraryHaltType type) {
		return this.insertBusHaltBefore(beforeHalt, id, null, type);
	}
785900
public void addRuleParserBefore(IRuleParser parser, Class<? extends IRuleParser> beforeParser) {
        int index = getIndexOfClass(ruleParsers, beforeParser);
        if (index == -1) {
            throw new ParserAddException("parser " + beforeParser.getSimpleName() + " has not been added");
        }
        ruleParsers.add(index, parser);
    }
1246433
public static final IEventFilter not(final IEventFilter filter)
    {
        return new AbstractEventFilter()
        {
            @Override
            public final boolean test(final GwtEvent<?> event)
            {
                return (false == filter.test(event));
            }
        };
    }
578042
public static void notifyChange(ContentProvider provider, Uri uri, ContentObserver observer) {
        notifyChange(provider.getContext(), uri, observer);
    }
353407
@CheckResult
    @NonNull
    public static Condition observableCondition(@NonNull Observable<Boolean> observable) {
        return new ObservableCondition(observable);
    }
336267
protected BaseDescr lhsNot(CEDescrBuilder<?, ?> ce,
            boolean allowOr) throws RecognitionException {
        CEDescrBuilder<?, NotDescr> not = null;

        if (state.backtracking == 0) {
            not = ce.not();
            helper.start(not,
                    CEDescrBuilder.class,
                    null);
        }

        try {
            match(input,
                    DRL6Lexer.ID,
                    DroolsSoftKeywords.NOT,
                    null,
                    DroolsEditorType.KEYWORD);
            if (state.failed)
                return null;

            if (state.backtracking == 0) {
                helper.emit(Location.LOCATION_LHS_BEGIN_OF_CONDITION_NOT);
            }
            if (input.LA(1) == DRL6Lexer.LEFT_PAREN) {
                boolean prefixed = helper.validateLT(2,
                        DroolsSoftKeywords.AND) || helper.validateLT(2,
                        DroolsSoftKeywords.OR);

                if (!prefixed) {
                    match(input,
                            DRL6Lexer.LEFT_PAREN,
                            null,
                            null,
                            DroolsEditorType.SYMBOL);
                    if (state.failed)
                        return null;
                }
                if (state.backtracking == 0 && input.LA(1) != DRL6Lexer.EOF) {
                    helper.emit(Location.LOCATION_LHS_BEGIN_OF_CONDITION);
                }

                lhsOr(not,
                        allowOr);
                if (state.failed)
                    return null;

                if (!prefixed) {
                    match(input,
                            DRL6Lexer.RIGHT_PAREN,
                            null,
                            null,
                            DroolsEditorType.SYMBOL);
                    if (state.failed)
                        return null;
                }
            } else if (input.LA(1) != DRL6Lexer.EOF) {

                lhsPatternBind(not,
                        true);
                if (state.failed)
                    return null;
            }

        } finally {
            if (state.backtracking == 0) {
                helper.end(CEDescrBuilder.class,
                        not);
            }
        }
        return not != null ? not.getDescr() : null;
    }
1119969
protected function dateBefore($value, $arg, $not = true)
    {
        if (!($value <= $arg) && $not) {
            $this->addReturn('date_before_or_equal', 'before', [ ':datebefore' => $arg ]);
        } elseif (($value <= $arg) && !$not) {
            $this->addReturn('date_before_or_equal', 'not_before', [ ':datebefore' => $arg ]);
        }
    }
40097
public Tabs setAjaxBeforeActivateEvent(ITabsAjaxEvent beforeActivateEvent)
	{
		this.ajaxEvents.put(TabEvent.beforeActivate, beforeActivateEvent);
		setBeforeActivateEvent(new TabsAjaxBeforeActivateJsScopeUiEvent(this, TabEvent.beforeActivate, false));
		return this;
	}
730277
private Object onWithoutAroundScript(UrlLepResourceKey compositeResourceKey,
                                         Map<XmLepResourceSubType, UrlLepResourceKey> atomicResourceKeys,
                                         LepMethod method,
                                         LepManagerService managerService,
                                         Supplier<GroovyScriptRunner> resourceExecutorSupplier)
        throws LepInvocationCauseException {

        Object target = method.getTarget();

        // Call BEFORE script if it exists
        executeBeforeIfExists(atomicResourceKeys, method, managerService, resourceExecutorSupplier);

        MethodResultProcessor methodResultProcessor;

        if (atomicResourceKeys.containsKey(TENANT)) {
            // Call TENANT script if it exists
            methodResultProcessor = executeLepScript(atomicResourceKeys, method, managerService, resourceExecutorSupplier,
                                                     TENANT);
        } else if (atomicResourceKeys.containsKey(DEFAULT)) {
            // Call DEFAULT script if it exists
            methodResultProcessor = executeLepScript(atomicResourceKeys, method, managerService, resourceExecutorSupplier,
                                                     DEFAULT);
        } else {
            // Call method on target object
            methodResultProcessor = executeLepTargetMethod(compositeResourceKey, method, target);
        }

        // Call AFTER script if it exists
        methodResultProcessor = executeAfterScriptIfExists(atomicResourceKeys,
                                                           method,
                                                           managerService,
                                                           resourceExecutorSupplier,
                                                           methodResultProcessor);

        return methodResultProcessor.processResult();
    }
478785
func (s *LoadBalancerTlsCertificate) SetNotBefore(v time.Time) *LoadBalancerTlsCertificate {
	s.NotBefore = &v
	return s
}
990372
public Where<T, ID> not(Where<T, ID> comparison) {
		addClause(new Not(pop("NOT")));
		return this;
	}
664976
public final BooleanExpression notIn(Expression<? extends T>... right) {
        return Expressions.booleanOperation(Ops.NOT_IN, mixin, Expressions.list(right));
    }