/* (non-Javadoc)
@see com.ibm.ws.sib.processor.impl.interfaces.DestinationHandler#hasRemote()
963587
public boolean hasRemote()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "hasRemote");
      
    boolean hasRemote = _localisationManager.hasRemote();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())      
      SibTr.exit(tc, "hasRemote", new Boolean(hasRemote));
    
    return hasRemote;
  }
682351
public static WsonrpcRemote getRemote(String sessionId) {
        if (sessionId == null) {
            return null;
        }
        return remotes.get(sessionId);
    }
1164335
public void hasLastKey(@NullableDecl Object key) {
    if (actualAsNavigableMap().isEmpty()) {
      failWithActual("expected to have last key", key);
      return;
    }

    if (!Objects.equal(actualAsNavigableMap().lastKey(), key)) {
      if (actualAsNavigableMap().containsKey(key)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has last key <%s>. "
                        + "It does contain this key, but the last key is <%s>",
                    actualAsString(), key, actualAsNavigableMap().lastKey())));
        return;
      }
      failWithoutActual(
          simpleFact(
              lenientFormat(
                  "Not true that %s has last key <%s>. "
                      + "It does not contain this key, and the last key is <%s>",
                  actualAsString(), key, actualAsNavigableMap().lastKey())));
    }
  }
584552
public Object doRemoteAction(String strCommand, Map<String, Object> properties) throws DBException, RemoteException
    {
        synchronized(m_objSync)
        {
            return m_tableRemote.doRemoteAction(strCommand, properties);
        }
    }
273818
public void hasFirstKey(@NullableDecl Object key) {
    if (actualAsNavigableMap().isEmpty()) {
      failWithActual("expected to have first key", key);
      return;
    }

    if (!Objects.equal(actualAsNavigableMap().firstKey(), key)) {
      if (actualAsNavigableMap().containsKey(key)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s has first key <%s>. "
                        + "It does contain this key, but the first key is <%s>",
                    actualAsString(), key, actualAsNavigableMap().firstKey())));
        return;
      }
      failWithoutActual(
          simpleFact(
              lenientFormat(
                  "Not true that %s has first key <%s>. "
                      + "It does not contain this key, and the first key is <%s>",
                  actualAsString(), key, actualAsNavigableMap().firstKey())));
    }
  }
1253497
private boolean isAvailable(
                                BaseDestinationHandler destinationHandler,
                                DestinationAvailability destinationAvailability)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isAvailable", new Object[] { destinationHandler, destinationAvailability });

        boolean sendAvailable = false;
        boolean receiveAvailable = false;

        if (destinationAvailability == DestinationAvailability.SEND
            || destinationAvailability == DestinationAvailability.SEND_AND_RECEIVE)
        {
            // Destination must be a non-mediated destination with a local queue point
            if (destinationHandler.hasLocal())
            {
                sendAvailable = true;
            }

            if (sendAvailable)
            {
                if ((destinationHandler.definition.isSendAllowed())
                    && (isLocalizationAvailable(destinationHandler, destinationAvailability)))
                {
                    sendAvailable = true;
                }
                else
                {
                    sendAvailable = false;
                }
            }
        }

        if (destinationAvailability == DestinationAvailability.RECEIVE
            || destinationAvailability == DestinationAvailability.SEND_AND_RECEIVE)
        {
            // Destination must have a queue point on the ME to which the connection is connected
            if (destinationHandler.hasLocal())
            {
                receiveAvailable = true;
            }

            if (receiveAvailable)
            {
                if ((destinationHandler.definition.isReceiveAllowed())
                    && (isLocalizationAvailable(destinationHandler, destinationAvailability)))
                {
                    receiveAvailable = true;
                }
                else
                {
                    receiveAvailable = false;
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isAvailable", new Object[] { new Boolean(sendAvailable || receiveAvailable) });

        return (sendAvailable || receiveAvailable);
    }
1029248
public boolean verifySender(InetAddress remoteAddr) {
        boolean returnValue = true;

        if (alists != null) {
            returnValue = !alists.accessDenied(remoteAddr);
        }
        return returnValue;
    }
657647
public void setRemote(boolean hasRemote)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "setRemote", Boolean.valueOf(hasRemote));

        getLocalisationManager().setRemote(hasRemote);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "setRemote");
    }
528969
public void notifyRCDReceiveExclusiveChange(boolean isReceiveExclusive)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "notifyRCDReceiveExclusiveChange", new Object[] {Boolean.valueOf(isReceiveExclusive)});

    // Only do this for ptp as it does not seem to make sense for p/s
    synchronized (_anycastInputHandlers) 
    { 
      for(Iterator i=_anycastInputHandlers.keySet().iterator(); i.hasNext();) 
      { 
        AnycastInputHandler aih = _anycastInputHandlers.get(i.next()); 
        if (aih != null) 
        { 
          RemoteConsumerDispatcher rcd = aih.getRCD();

          rcd.notifyReceiveExclusiveChange(isReceiveExclusive);
        }
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "notifyRCDReceiveExclusiveChange");
  }
644695
boolean performRemoteCheck(MnoHttpClient httpClient) {
		// Prepare request
		String url = sso.getSessionCheckUrl(this.uid, this.sessionToken);
		String respStr;
		try {
			respStr = httpClient.get(url);
		} catch (AuthenticationException e1) {
			// TODO log error
			e1.printStackTrace();
			return false;
		} catch (ApiException e1) {
			// TODO log error
			e1.printStackTrace();
			return false;
		}

		// Parse response
		Gson gson = new Gson();
		Type type = new TypeToken<Map<String, String>>() {
		}.getType();
		Map<String, String> respObj = gson.fromJson(respStr, type);
		Boolean isValid = (respObj.get("valid") != null && respObj.get("valid").equals("true"));

		if (isValid) {
			try {
				this.recheck = MnoDateHelper.fromIso8601(respObj.get("recheck"));
			} catch (Exception e) {
				return false;
			}

			return true;
		}
		return false;
	}
433825
public boolean destinationExists(JsDestinationAddress addr) throws SIMPNullParameterException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "destinationExists", new Object[] { addr });

        // Now look for the destination in the hash table
        boolean exists = destinationExists(addr.getDestinationName(), addr.getBusName());

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "destinationExists", new Boolean(exists));

        return exists;
    }
1142200
function checkRemote (remotes, remote) {
  if (remotes === "ALL") {
    return true;
  }

  if (!_.isArray(remotes)) {
    remotes = _.invoke(remotes.split(","), "trim");
  }

  return _.any(remotes, _.partial(minimatch, remote));
}
977557
@Override
	public boolean hasNext() {
		if (next == null) {
			try {
				next = readNextFromStream();
			} catch (Exception e) {
				throw new RuntimeException("Failed to receive next element: " + e.getMessage(), e);
			}
		}

		return next != null;
	}
171421
@Override
  public int portRemote()
  {
    if (_channel != null) {
      try {
        SocketAddress addr = _channel.getRemoteAddress();
        
        return 0;
      } catch (Exception e) {
        e.printStackTrace();
        return 0;
      }
    }
    else
      return 0;
  }
1258214
public Object readRemote()
        throws IOException
    {
        String type = readType();
        String url = readString();

        return resolveRemote(type, url);
    }
1217640
@Override
	public boolean hasNext()
	{
		try
		{
			
		
			if(this.resultSet == null)
				return false;
			else if(!this.resultSet.next())
			{
				this.dispose();
				return false;
			}
			return true;
		}
		catch (SQLException e)
		{
			dispose();

			throw new CommunicationException(e.getMessage(),e);
		}
			
	}
41835
public boolean moveTo(final long pKey) {
        try {
            if (pKey < 0 || mRTX.moveTo(pKey)) {
                lastPointer.put(mRTX, pKey);
                return true;
            } else {
                return false;
            }
        } catch (TTIOException exc) {
            throw new RuntimeException(exc);
        }
    }