/*
(non-Javadoc)

@see com.ibm.ws.sib.processor.impl.interfaces.DestinationHandler#isTopicAccessCheckRequired()
510977
@Override
    public boolean isTopicAccessCheckRequired()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isTopicAccessCheckRequired");
        // Look to the resolved destination for this value
        boolean ret = getTarget().isTopicAccessCheckRequired();
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isTopicAccessCheckRequired", Boolean.valueOf(ret));
        return ret;
    }
241745
function checkRequired(k, cb) {
    if (k in args)
      return cb(null);
    else
      return cb(buildError(k, 'argument missing'));
  }
684055
public function isRequired()
    {
        if (!empty($this->validation)) {
            foreach ($this->validation as $validation) {
                if ($validation instanceof Validation\Required) {
                    return true;
                }
            }
        }

        return false;
    }
989101
@Override
   public boolean promptRequiredMissingValues(ShellImpl shell) throws InterruptedException
   {
      Map<String, InputComponent<?, ?>> inputs = getController().getInputs();
      if (hasMissingRequiredInputValues(inputs.values()))
      {
         UIOutput output = shell.getOutput();
         if (!getContext().isInteractive())
         {
            output.error(output.out(), NON_INTERACTIVE_MODE_MESSAGE);
            return false;
         }
         output.info(output.out(), INTERACTIVE_MODE_MESSAGE);
         promptRequiredMissingValues(shell, inputs.values());
      }
      return true;
   }
337678
private boolean checkZoneRequirement(HashMap<Integer, Integer> requiredRepFactor, int zoneId) {
        if(requiredRepFactor.containsKey(zoneId)) {
            if(requiredRepFactor.get(zoneId) == 0) {
                return false;
            } else {
                requiredRepFactor.put(zoneId, requiredRepFactor.get(zoneId) - 1);
                return true;
            }
        }
        return false;

    }
797556
public function isRemoteCheckRequired()
    {
        if ($this->uid && $this->sessionToken && $this->recheck) {
            if($this->recheck > (new DateTime('NOW'))) {
                return false;
            }
        }

        return true;
    }
756564
protected void promptRequiredMissingValues(ShellImpl shell, Iterable<InputComponent<?, ?>> inputs)
            throws InterruptedException
   {
      ShellUIPromptImpl prompt = shell.createPrompt(context);
      for (InputComponent<?, ?> input : inputs)
      {
         if (input.isEnabled() && !input.isDeprecated())
         {
            boolean requiredInputMissing = input.isRequired() && !(input.hasDefaultValue() || input.hasValue());
            Object obj = prompt.promptValueFrom(input);
            if (obj == null && requiredInputMissing)
            {
               // No value returned. Just stop testing other inputs
               break;
            }
         }
      }

   }
663899
public Deferred<ArrayList<Object>> checkNecessaryTablesExist() {
    final ArrayList<Deferred<Object>> checks =
      new ArrayList<Deferred<Object>>(2);
    checks.add(client.ensureTableExists(
        config.getString("tsd.storage.hbase.data_table")));
    checks.add(client.ensureTableExists(
        config.getString("tsd.storage.hbase.uid_table")));
    if (config.enable_tree_processing()) {
      checks.add(client.ensureTableExists(
          config.getString("tsd.storage.hbase.tree_table")));
    }
    if (config.enable_realtime_ts() || config.enable_realtime_uid() ||
        config.enable_tsuid_incrementing()) {
      checks.add(client.ensureTableExists(
          config.getString("tsd.storage.hbase.meta_table")));
    }
    return Deferred.group(checks);
  }
1312197
public static boolean isWaiting(int iStatusID)
    {
        switch (iStatusID)
        {
            case REQUEST_SENT:
            case DATA_REQUIRED:
                return true;
            case NULL_STATUS:
            case NO_STATUS:
            case PROPOSAL:
            case ACCEPTED:
            case CANCELED:
            case OKAY:
            case NOT_USED:
            case ERROR:
            case MANUAL_REQUEST_REQUIRED:
            case MANUAL_REQUEST_SENT:
            case NOT_VALID:
            case DATA_VALID:
            default:
                return false;        
        }
    }
609402
private void checkForCompletion() {
        final String methodName = "checkForCompletion(): ";
        // mark the list complete if that was the last awaited key
        if (actualIndices.isEmpty()) {
            if (tc.isDebugEnabled())
                Tr.debug(tc, methodName + "setting state=COMPLETE");
            state = failedKeys == null
                            ? COMPLETE
                            : COMPLETE_WITH_FAILURES; // state change must be last action
        }
    }
622284
private void checkStarted() throws SINotPossibleInCurrentConfigurationException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "checkStarted");

    synchronized (this)
    {
      if (!isStarted())
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "checkStarted", "ME not started");

        throw new SINotPossibleInCurrentConfigurationException(
          nls.getFormattedMessage("MESSAGE_PROCESSOR_NOT_STARTED_ERROR_CWSIP0211", 
          new Object[] { messageProcessor.getMessagingEngineName(), messageProcessor.getMessagingEngineBus()}, 
          null));
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "checkStarted");
  }
710443
public void verifyStatus() {
    if (sequential) {
      boolean unopenedIterator = responseIterator == null && !responses.isEmpty();
      if (unopenedIterator || responseIterator.hasNext()) {
        throw new VerificationAssertionError("More executions were expected");
      }
    }
  }
1141943
public boolean isTopicAccessCheckRequired()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "isTopicAccessCheckRequired");
    // Look to the underlying definition
    boolean ret = definition.isTopicAccessCheckRequired();
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "isTopicAccessCheckRequired", Boolean.valueOf(ret));
    return ret;
  }
1079325
@Override
	public void check() throws JMSException
	{
		if (destinationType == null)
			throw new InvalidDescriptorException("Missing destination reference property : 'destinationType'");
		if (!destinationType.equals("queue") && !destinationType.equals("topic"))
			throw new InvalidDescriptorException("Destination reference property 'destinationType' should be one of : queue, topic");
		if (destinationName == null)
			throw new InvalidDescriptorException("Missing destination reference property : 'destinationName'");
	}
835637
public void requestSucceeded()
  {
    if (_tc.isEntryEnabled()) SibTr.entry(this, _tc, "requestSucceeded");
    //lohith liberty change
  //  _invoker.requestSucceeded();
    
    if (_tc.isEntryEnabled()) SibTr.exit(this, _tc, "requestSucceeded");
  }
394617
private boolean isRequiredViaNestedRequiredValidator() {
        boolean result = false;
        if (null == validators) {
            return result;
        }
        Iterator<Validator> iter = validators.iterator();
        while (iter.hasNext()) {
            if (iter.next() instanceof RequiredValidator) {
                // See JAVASERVERFACES-2526.  Note that we can assume
                // that at this point the validator is not disabled, 
                // so the mere existence of the validator implies it is
                // enabled.
                result = true;
                Object submittedValue = getSubmittedValue();
                if (submittedValue == null) {
                    // JAVASERVERFACES-3058 asserts that view parameters 
                    // should be treated differently than form parameters
                    // if they are not submitted.  I'm not sure if that's 
                    // correct, but let's put this in and see how 
                    // the community responds.
                    this.setSubmittedValue("");
                }
                break;
            }
        }
                
        return result;
    }
1163036
function verifyImplementations(interfaces, target) {
    for (var
      current,
      key,
      i = 0; i < interfaces.length; i++
    ) {
      current = interfaces[i];
      for (key in current) {
        if (hOP.call(current, key) && !hOP.call(target, key)) {
          warn(key.toString() + ' is not implemented');
        }
      }
    }
  }