Returns true if the Mathoid service is reachable, otherwise false.

@return
429147
public boolean isReachable() {
        try {
            URL url = new URL(mathoidConfig.getUrl() + "/mml");
            SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
            ClientHttpRequest req = factory.createRequest(url.toURI(), HttpMethod.POST);
            req.execute();
            return true;
        } catch (Exception e) {
            return false;
        }
    }
750061
public boolean isSimple() {
		if (isEmpty()) {
			return true;
		}

		if (getNumGeometries() > 1) {
			for (int n = 0; n < getNumGeometries(); n++) {
				if (!getGeometryN(n).isSimple()) {
					return false;
				}
			}
		} else {
			final Coordinate[] coords1 = getCoordinates();
			final Coordinate[] coords2 = getCoordinates();
			if (coords1.length > 1 && coords2.length > 1) {
				for (int i = 0; i < coords2.length - 1; i++) {
					for (int j = 0; j < coords1.length - 1; j++) {
						if (Mathlib.lineIntersects(coords2[i], coords2[i + 1], coords1[j], coords1[j + 1])) {
							return false;
						}
					}
				}
			} else {
				// TODO implement me
			}
		}

		return true;
	}
717885
public static boolean isAvailable(Context context){
        FingerprintManager manager = (FingerprintManager) context.getSystemService(Context.FINGERPRINT_SERVICE);
        return (manager!=null && manager.isHardwareDetected() && manager.hasEnrolledFingerprints());
    }
1070393
public boolean isServerAvailable(){
        final Client client = getClient();
        final ClientResponse response = client.resource(serverURL).get(ClientResponse.class);

        if(ClientResponse.Status.OK.getStatusCode() == response.getStatus()){
            return true;
        }

        if(LOG.isErrorEnabled()) {
            LOG.error(String.format(HTTP_STATUS_TEMPLATE_MSG, "Failed to reach the targeted Grapes server", response.getStatus()));
        }
        client.destroy();

        return false;
    }
659477
public Boolean pushEnabled() {
        Long value = get(SETTINGS_ENABLE_PUSH);
        if (value == null) {
            return null;
        }
        return TRUE.equals(value);
    }
283624
public boolean canPing() {
        try {
            val connection = (HttpURLConnection) new URL(this.swivelUrl).openConnection();
            connection.setRequestMethod(HttpMethod.GET.name());
            connection.connect();
            return connection.getResponseCode() == HttpStatus.SC_OK;
        } catch (final Exception e) {
            LOGGER.warn(e.getMessage(), e);
        }
        return false;
    }
1141898
public boolean canRun() {
    Status status = getStatus();
    return Status.STATUS_READY.equals(status) || Status.STATUS_COMPLETE.equals(status);
  }
1203665
public boolean hasRemote()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "hasRemote");
      SibTr.exit(tc, "hasRemote", Boolean.valueOf(_hasRemote));
    }

    return _hasRemote;
  }
956173
@Override
	public boolean reachedEnd() {
		try {
			if (resultSet.isLast()) {
				resultSet.close();
				statement.close();
				dbConn.close();
				return true;
			} else {
				return false;
			}
		} catch (SQLException e) {
			throw new IllegalArgumentException("Couldn't evaluate reachedEnd():\t" + e.getMessage());
		} catch (NullPointerException e) {
			throw new IllegalArgumentException("Couldn't access resultSet:\t" + e.getMessage());
		}
	}
649185
public boolean isIdle() {
        long lastPingTime = lastPingSentOn.get();
        long lastPongTime = lastPongReceivedOn.get();
        boolean idle = (lastPongTime > 0 && (lastPingTime - lastPongTime > maxInactivity));
        if (log.isTraceEnabled()) {
            log.trace("Connection {} {} idle", getSessionId(), (idle ? "is" : "is not"));
        }
        return idle;
    }
312831
boolean checkAvailablePush(Context context) {

        int connectionStatus = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context);
        if (connectionStatus == ConnectionResult.SUCCESS) {
            log.i("Google Play Services are available on this device.");
            return true;
        } else {
            if (GoogleApiAvailability.getInstance().isUserResolvableError(connectionStatus)) {
                log.e("Google Play Services is probably not up to date. User recoverable Error Code is " + connectionStatus);
            } else {
                log.e("This device is not supported by Google Play Services.");
            }
            return false;
        }
    }
534522
private boolean isWorkAvailable() throws SIConnectionDroppedException {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isWorkAvailable");
      final boolean isWork;
      if (terminate) {
         isWork = false;
      } else {
         isWork = (partiallySentTransmission != null) || !priorityQueue.isEmpty();
      }
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isWorkAvailable", Boolean.valueOf(isWork));
      return isWork;
   }
1233514
public static boolean isServiceRunning(Context context, Class<? extends Service> service) {
        return isServiceRunning(context, service, Integer.MAX_VALUE);
    }
406060
@Override
	public ESat isEntailed() {
		boolean done = true;
		for (int i = 0; i < n; i++) {
			if ((!degrees[i].contains(0)) && !g.getPotentialNodes().contains(i)) {
				return ESat.FALSE;
			}
			ISet env = target.getPotSet(g, i);
			ISet ker = target.getMandSet(g, i);
			if (degrees[i].getLB() > env.size()
					|| degrees[i].getUB() < ker.size()) {
				return ESat.FALSE;
			}
			if (env.size() != ker.size() || !degrees[i].isInstantiated()) {
				done = false;
			}
		}
		if (!done) {
			return ESat.UNDEFINED;
		}
		return ESat.TRUE;
	}
136653
public boolean hasNext() throws SISessionUnavailableException, SISessionDroppedException, SIIncorrectCallException
  {
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.entry(CoreSPILockedMessageEnumeration.tc, "hasNext",
        new Object[] {new Integer(hashCode()), this});

    boolean hasNext = false;

    checkValidState("hasNext");

    localConsumerPoint.checkNotClosed();

    synchronized(this)
    {
      if(!endReached)
      {
        // If currentMsg is null it means we start from the begining
        if(currentMsg == null)
        {
          if(firstMsg != null)
            hasNext = true;
        }
        else
        {
          if(currentMsg.next != null)
            hasNext = true;
        }
      }
    }

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

    return hasNext;
  }
57752
def _is_reachable(self, server):
        """"""

        try:
            server['redis'].ping()
            return True
        except UserWarning:
            self._logger.warn('Cannot reach redis server: ' + server['url'])
        except Exception:
            self._logger.warn('Cannot reach redis server: ' + server['url'])

        return False
848473
public boolean isValid() {
    if (lc_dev_proxy == null) {
      return false;
    }
    try {
      lc_dev_proxy.ping();
    }
    catch (DevFailed dv) {
      close();
      return false;
    }
    return true;
  }