Signal a waiter.
<p>
We need to pass objectName because the name in {#objectName} is unrealible.

@param conditionId
@param maxSignalCount
@param objectName
@see InternalLockNamespace
978828
public void signal(String conditionId, int maxSignalCount, String objectName) {
        if (waiters == null) {
            return;
        }

        Set<WaitersInfo.ConditionWaiter> waiters;
        WaitersInfo condition = this.waiters.get(conditionId);
        if (condition == null) {
            return;
        } else {
            waiters = condition.getWaiters();
        }
        if (waiters == null) {
            return;
        }
        Iterator<WaitersInfo.ConditionWaiter> iterator = waiters.iterator();
        for (int i = 0; iterator.hasNext() && i < maxSignalCount; i++) {
            WaitersInfo.ConditionWaiter waiter = iterator.next();
            ConditionKey signalKey = new ConditionKey(objectName,
                    key, conditionId, waiter.getCaller(), waiter.getThreadId());
            registerSignalKey(signalKey);
            iterator.remove();
        }
        if (!condition.hasWaiter()) {
            this.waiters.remove(conditionId);
        }

    }
556569
protected void waitingNotify()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "waitingNotify");

        this.lock();
        try
        {
            if (_waiting)
                _waiter.signal();
        } finally
        {
            this.unlock();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "waitingNotify");
    }
1060120
private Condition buildIdCondition(Object argument) {
         if (argument instanceof String && ObjectId.isValid((String) argument)) {
             return new Condition(ID_FIELD, new ObjectId((String) argument));
         } else if (Iterable.class.isAssignableFrom(argument.getClass())) {
             List<Object> objectIds = new ArrayList<Object>();

             //noinspection ConstantConditions
             for (Object argumentItem : (Iterable) argument) {
                 if (argumentItem instanceof String && ObjectId.isValid((String) argumentItem)) {
                     objectIds.add(new ObjectId((String) argumentItem));
                 } else if (argumentItem instanceof ObjectId) {
                     objectIds.add( argumentItem);
                 }
             }

             return new Condition(ID_FIELD, new BasicDBObject("$in", objectIds));
         } else {
             return new Condition(ID_FIELD, argument);
         }
     }
1221691
public static <T extends MethodDescription> ElementMatcher.Junction<T> hasSignature(MethodDescription.SignatureToken token) {
        return new SignatureTokenMatcher<T>(is(token));
    }
466375
protected void maybeSignalForMoreConnections(ConnectionPartition connectionPartition) {

		if (!connectionPartition.isUnableToCreateMoreTransactions() 
				&& !this.poolShuttingDown &&
				connectionPartition.getAvailableConnections()*100/connectionPartition.getMaxConnections() <= this.poolAvailabilityThreshold){
			connectionPartition.getPoolWatchThreadSignalQueue().offer(new Object()); // item being pushed is not important.
		}
	}
651017
private static void checkPreconditions(final int min, final int max) {
        if( min > max ) {
            throw new IllegalArgumentException(String.format("max (%d) should not be < min (%d)", max, min));
        }
        
        if( min < 0 ) {
            throw new IllegalArgumentException(String.format("min length (%d) should not be < 0", min));
        }
    }
1291819
@Override
  public void visitMaxs(int maxStack, int maxLocals) {
    if (withPreconditions || withPostconditions || withInvariants) {
      mark(methodEnd);
      catchException(methodStart, methodEnd, null);

      if (withPostconditions) {
        Label skipEx = new Label();
        dup();
        instanceOf(EXCEPTION_TYPE);
        ifZCmp(EQ, skipEx);

        Label skip = enterBusySection();
        int throwIndex = newLocal(EXCEPTION_TYPE);
        checkCast(EXCEPTION_TYPE);
        storeLocal(throwIndex);

        invokeCommonPostconditions(ContractKind.SIGNAL, signalOldValueLocals,
                                   throwIndex);
        if (withInvariants && !statik) {
          invokeInvariants();
        }

        loadLocal(throwIndex);
        leaveBusySection(skip);

        mark(skipEx);
      }

      /*
       * The exception to throw is on the stack and
       * leaveContractedMethod() does not alter that fact.
       */
      leaveContractedMethod();
      throwException();
    }
    super.visitMaxs(maxStack, maxLocals);
  }
224023
public void notifyReceiveAllowedRCD(DestinationHandler destinationHandler)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "notifyReceiveAllowedRCD", new Object[] {destinationHandler});

    // For PtoP iterate over anycastInputHandlers
    synchronized (_anycastInputHandlers) 
    { 
      for(Iterator i=_anycastInputHandlers.keySet().iterator(); i.hasNext();) 
      { 
        String key = (String) i.next(); 
        AnycastInputHandler aih = _anycastInputHandlers.get(key); 
        if (aih != null) 
        { 
          RemoteConsumerDispatcher rcd = aih.getRCD();
          rcd.notifyReceiveAllowed(destinationHandler);
        }
      }
    }
        
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "notifyReceiveAllowedRCD");
  }
965173
@Override
    public void registerAsynchConsumerCallback(
                                               AsynchConsumerCallback callback,
                                               int maxActiveMessages,
                                               long messageLockExpiry,
                                               int maxBatchSize,
                                               OrderingContext context)
                    throws SISessionUnavailableException, SISessionDroppedException,
                    SIErrorException,
                    SIIncorrectCallException
    {
        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.entry(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback",
                        new Object[] { this,
                                      callback,
                                      new Integer(maxActiveMessages),
                                      new Long(messageLockExpiry),
                                      new Integer(maxBatchSize),
                                      context });
        registerAsynchConsumerCallback(callback,
                                       maxActiveMessages,
                                       messageLockExpiry,
                                       maxBatchSize,
                                       null,
                                       false,
                                       context);

        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.exit(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback");
    }
98166
public void setMaxTokenLength(int maxTokenLength)
    {
        if(maxTokenLength < 1)
            throw new IllegalArgumentException("Max token length must be positive, not " + maxTokenLength);
        if(maxTokenLength <= minTokenLength)
            throw new IllegalArgumentException("Max token length must be larger than the min token length");
        this.maxTokenLength = maxTokenLength;
    }
866319
public void addLockInformation(Object key, boolean contention, boolean failLock) {
      if (!isEnabled()) {
         return;
      }

      syncOffer(Stat.MOST_LOCKED_KEYS, key);

      if (contention) {
         syncOffer(Stat.MOST_CONTENDED_KEYS, key);
      }
      if (failLock) {
         syncOffer(Stat.MOST_FAILED_KEYS, key);
      }
   }
513275
public static void cancelTaskById(Context context, final long id, final int reason,
      final SingleCancelListener cancelListener,
      Class<? extends GroundyService> groundyServiceClass) {
    if (id <= 0) {
      throw new IllegalStateException("id must be greater than zero");
    }
    new GroundyServiceConnection(context, groundyServiceClass) {
      @Override
      protected void onGroundyServiceBound(GroundyService.GroundyServiceBinder binder) {
        int result = binder.cancelTaskById(id, reason);
        if (cancelListener != null) {
          cancelListener.onCancelResult(id, result);
        }
      }
    }.start();
  }
274413
public void registerAsynchConsumerCallback(
            final AsynchConsumerCallback callback, final int maxActiveMessages,
            final long messageLockExpiry, final int maxBatchSize,
            final OrderingContext extendedMessageOrderingContext)
            throws SISessionUnavailableException, SISessionDroppedException,
            SIConnectionUnavailableException, SIConnectionDroppedException,
            SIIncorrectCallException {

        throw new SibRaNotSupportedException(NLS
                .getString("ASYNCHRONOUS_METHOD_CWSIV0250"));

    }
406436
private void tokenStatsAdd(int min, int max) {
    tokenStatsNumber++;
    if (tokenStatsMinPos == null) {
      tokenStatsMinPos = min;
    } else {
      tokenStatsMinPos = Math.min(tokenStatsMinPos, min);
    }
    if (tokenStatsMaxPos == null) {
      tokenStatsMaxPos = max;
    } else {
      tokenStatsMaxPos = Math.max(tokenStatsMaxPos, max);
    }
  }
227405
public static void verifyCondition(@Nullable ErrorCollector errorCollector, @Nullable ValueRecorder recorder,
      @Nullable String text, int line, int column, @Nullable Object message, @Nullable Object condition) {
    if (!GroovyRuntimeUtil.isTruthy(condition)) {
      final ConditionNotSatisfiedError conditionNotSatisfiedError = new ConditionNotSatisfiedError(
        new Condition(getValues(recorder), text, TextPosition.create(line, column), messageToString(message), null, null));
      errorCollector.collectOrThrow(conditionNotSatisfiedError);
    }
  }
180422
public OvhTimeCondition billingAccount_timeCondition_serviceName_condition_id_GET(String billingAccount, String serviceName, Long id) throws IOException {
		String qPath = "/telephony/{billingAccount}/timeCondition/{serviceName}/condition/{id}";
		StringBuilder sb = path(qPath, billingAccount, serviceName, id);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhTimeCondition.class);
	}
672198
@Override
  public final void setItsId(final CustomerGoodsSeenId pItsId) {
    this.itsId = pItsId;
    if (this.itsId != null) {
      this.goods = this.itsId.getGoods();
      this.customer = this.itsId.getCustomer();
    } else {
      this.goods = null;
      this.customer = null;
    }
  }