Learn whether {@code operation} is supported by this context.

@param operation
@return boolean
@throws NullPointerException on {@code null} input
515726
public synchronized <RESULT> boolean supports(final Operation<RESULT> operation, Hint... hints) {
        final Frame<RESULT> frame = new Frame<>(Phase.SUPPORT_CHECK, operation, hints);
        try {
            return handle(frame);
        } catch (Frame.RecursionException e) {
            return false;
        }
    }
974678
boolean evaluatePureAnnotationAdapters(org.eclipse.xtext.common.types.JvmOperation operation, ISideEffectContext context) {
		int index = -1;
		int i = 0;
		for (final Adapter adapter : operation.eAdapters()) {
			if (adapter.isAdapterForType(AnnotationJavaGenerationAdapter.class)) {
				index = i;
				break;
			}
			++i;
		}
		if (index >= 0) {
			final AnnotationJavaGenerationAdapter annotationAdapter = (AnnotationJavaGenerationAdapter) operation.eAdapters().get(index);
			assert annotationAdapter != null;
			return annotationAdapter.applyAdaptations(this, operation, context);
		}
		return false;
	}
39332
@SuppressWarnings("unchecked")
    public static <T> Operation<T> operation(Class<? extends T> type, Operator operator,
                                             ImmutableList<Expression<?>> args) {
        if (type.equals(Boolean.class)) {
            return (Operation<T>) new PredicateOperation(operator, args);
        } else {
            return new OperationImpl<T>(type, operator, args);
        }
    }
1135707
public java.util.List<String> getOperations() {
        if (operations == null) {
            operations = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return operations;
    }
594630
@Override
	public OperationResult<R> tryOperation(Operation<CL, R> operation) throws ConnectionException {
	    Operation<CL, R> filteredOperation = config.getOperationFilterFactory().attachFilter(operation);
	    
        while (true) {
            attemptCounter++;
            
            try {
                connection = borrowConnection(filteredOperation);
                startTime = System.currentTimeMillis();
                OperationResult<R> result = connection.execute(filteredOperation);
                result.setAttemptsCount(attemptCounter);
                monitor.incOperationSuccess(getCurrentHost(), result.getLatency());
                return result;
            }
            catch (Exception e) {
                ConnectionException ce = (e instanceof ConnectionException) ? (ConnectionException) e
                        : new UnknownException(e);
            	try {
            		informException(ce);
                    monitor.incFailover(ce.getHost(), ce);
            	}
            	catch (ConnectionException ex) {
                    monitor.incOperationFailure(getCurrentHost(), ex);
                    throw ex;
            	}
            }
            finally {
            	releaseConnection();
            }
        }
    }
330360
public Object handleOperation(String operation, Object[] params) throws IOException {
        if (OPERATION_DOWNLOAD.equals(operation)) {
            if (params.length == 2) {
                downloadFile((String) params[0], (String) params[1]);
            } else {
                //partial download
                return downloadFile((String) params[0], (String) params[1], (Long) params[2], (Long) params[3]);
            }
        } else if (OPERATION_UPLOAD.equals(operation)) {
            uploadFile((String) params[0], (String) params[1], (Boolean) params[2]);
        } else if (OPERATION_DELETE.equals(operation)) {
            deleteFile((String) params[0]);
        } else if (OPERATION_DELETE_ALL.equals(operation)) {
            deleteAll((List<String>) params[0]);
        } else {
            throw logUnsupportedOperationError("handleOperation", operation);
        }

        //currently all operations are void, so return null.
        return null;
    }
705910
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString name_validator = new MPSString();
		name_validator.validate(operationType, name, "\"name\"");
		
		MPSIPAddress host_ip_address_validator = new MPSIPAddress();
		host_ip_address_validator.validate(operationType, host_ip_address, "\"host_ip_address\"");
		
		MPSString current_value_validator = new MPSString();
		current_value_validator.validate(operationType, current_value, "\"current_value\"");
		
		MPSString expected_value_validator = new MPSString();
		expected_value_validator.validate(operationType, expected_value, "\"expected_value\"");
		
		MPSString unit_validator = new MPSString();
		unit_validator.validate(operationType, unit, "\"unit\"");
		
		MPSString status_validator = new MPSString();
		status_validator.validate(operationType, status, "\"status\"");
		
	}
985053
@Override
    public Operation zCombinedAnd(Operation op)
    {
        if (op instanceof IsNullOperation)
        {
            return zCombineWithNullOperation((IsNullOperation) op);
        }
        return op.zCombinedAnd(this);
    }
681689
public static boolean hasOperator (@Nullable final IJSExpression aExpr)
  {
    return aExpr instanceof JSOpUnary || aExpr instanceof JSOpBinary || aExpr instanceof JSOpTernary;
  }
1309250
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString response_validator = new MPSString();
		response_validator.validate(operationType, response, "\"response\"");
		
		MPSIPAddress ns_ip_address_validator = new MPSIPAddress();
		ns_ip_address_validator.validate(operationType, ns_ip_address, "\"ns_ip_address\"");
		
	}
501659
public <T> T runUnchecked(Retryable<T> operation) throws RuntimeException
	{
		try
		{
			return run(operation);
		}
		catch (RuntimeException e)
		{
			throw e;
		}
		catch (Exception e)
		{
			throw new RuntimeException("Retryable " + operation + " failed: " + e.getMessage(), e);
		}
	}
165423
public void setOperations(java.util.Collection<String> operations) {
        if (operations == null) {
            this.operations = null;
            return;
        }

        this.operations = new com.amazonaws.internal.SdkInternalList<String>(operations);
    }
69521
void acceptOperation(UpdateAttributesOperation operation) {
        ensureSegmentId(operation);
        acceptAttributes(operation.getAttributeUpdates());
        this.isChanged = true;
    }
200661
@NotNull public static <T> Single<T> from(@NotNull final ApolloStoreOperation<T> operation) {
    checkNotNull(operation, "operation == null");
    return Single.create(new Single.OnSubscribe<T>() {
      @Override
      public void call(final SingleSubscriber<? super T> subscriber) {
        operation.enqueue(new ApolloStoreOperation.Callback<T>() {
          @Override public void onSuccess(T result) {
            subscriber.onSuccess(result);
          }

          @Override public void onFailure(Throwable t) {
            subscriber.onError(t);
          }
        });
      }
    });
  }
829071
boolean isPurableOperation(XtendFunction operation, ISideEffectContext context) {
		if (isUnpureOperationPrototype(operation)) {
			return false;
		}
		if (this.nameValidator.isNamePatternForNotPureOperation(operation)) {
			return false;
		}
		if (this.nameValidator.isNamePatternForPureOperation(operation)) {
			return true;
		}
		if (context == null) {
			return !hasSideEffects(
					getInferredPrototype(operation),
					operation.getExpression());
		}
		final Boolean result = internalHasSideEffects(operation.getExpression(), context);
		return result == null || !result.booleanValue();
	}
241383
public static boolean isSetNullParameterOperation(ParameterSetOperation operation) {
        String methodName = operation.getMethod().getName();
        return StatementMethodNames.PARAMETER_METHOD_SET_NULL.equals(methodName);
    }
1351870
public <X> DataSet<X> runOperation(CustomUnaryOperation<T, X> operation) {
		Validate.notNull(operation, "The custom operator must not be null.");
		operation.setInput(this);
		return operation.createResult();
	}