Returns an {@link Operator} that logs every <i>onNext</i> value using a
{@link Logger} based on the current class. Is equivalent to
<tt>logger().showValue().log()</tt>.

@return operator that logs every <i>onNext</i> value.
557296
public static <T> OperatorLogging<T> log(String onNextFormat) {
        return Logging.<T> logger().onNextFormat(onNextFormat).log();
    }
821512
public static JTSLineStringExpression<LineString> lineStringOperation(Operator op, Expression<?>... args) {
        return new JTSLineStringOperation<LineString>(LineString.class, op, args);
    }
54466
private static Selector DNF0(Selector tree) {
    if (!(tree instanceof Operator))
      return tree;
    Operator oper = (Operator) tree;
    switch(oper.getOp()) {
    case Selector.AND:
      return processAND(oper.getOperands()[0], oper.getOperands()[1]);
    case Selector.OR:
      return makeOR(DNF0(oper.getOperands()[0]), DNF0(oper.getOperands()[1]));
    default:
      return tree;
    }
  }
668770
public static <T extends Number & Comparable<?>> NumberOperation<T> numberOperation(Class<? extends T> type,
            Operator operator, Expression<?>... args) {
        return new NumberOperation<T>(type, operator, args);
    }
139439
public Iterator<JsonValue> iterator() {
    final Iterator<JsonValue> iterator = values.iterator();
    return new Iterator<JsonValue>() {

      public boolean hasNext() {
        return iterator.hasNext();
      }

      public JsonValue next() {
        return iterator.next();
      }

      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }
101316
private static String getOperatorId(AstNode operatorFunctionId) {

    StringBuilder builder = new StringBuilder(
      operatorFunctionId.getTokenValue());
    AstNode operator = operatorFunctionId
      .getFirstDescendant(CxxGrammarImpl.overloadableOperator);

    if (operator != null) {

      AstNode opNode = operator.getFirstChild();
      while (opNode != null) {
        builder.append(opNode.getTokenValue());
        opNode = opNode.getNextSibling();
      }
    }

    return builder.toString();
  }
405511
@SuppressWarnings("unchecked")
  @Override
  protected T getNext() {
    T token = null;
    if (lexer == null) {
      return token;
    }
    try {
      token = (T) lexer.next();
      while (token != null && token.word().equals(WhitespaceLexer.NEWLINE)) {
        if (eolIsSignificant) {
          return token;
        } else {
          token = (T) lexer.next();
        }
      }
    } catch (IOException e) {
      // do nothing, return null
    }
    return token;
  }
880475
@Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            private int cursor = 0;

            @Override
            public boolean hasNext() {
                return size == INFINITE_SIZE || cursor < size;
            }

            @Override
            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                cursor++;
                return generator.next();
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException("remove() operation is not supported");
            }
        };
    }
957482
public static <T extends Comparable<?>> ComparableOperation<T> comparableOperation(Class<? extends T> type,
            Operator operator, Expression<?>... args) {
        return new ComparableOperation<T>(type, operator, args);
    }
293494
final public ReturnExpressionBuilder<T> returnExp() {
    final int sourceLineNumber = builder.getSourceLineNumber();
    return new ReturnExpressionBuilder<T>(new ExpressionHandler<T>() {
      public T handleExpression(Expression e) {
        return statementHandler().handleStatement(new ReturnStatement(sourceLineNumber, e));
      }
    });
  }
1081165
@NotNull
	public static ILogger getLogger(@Nullable ILogger logger) {
		return logger == null ? new NullLogger() : logger;
	}
1020546
public final DRL5Expressions.neg_operator_key_return neg_operator_key() throws RecognitionException {
		DRL5Expressions.neg_operator_key_return retval = new DRL5Expressions.neg_operator_key_return();
		retval.start = input.LT(1);

		Token id=null;

		try {
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:775:3: ({...}? =>id= ID )
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:775:10: {...}? =>id= ID
			{
			if ( !(((helper.isPluggableEvaluator(true)))) ) {
				if (state.backtracking>0) {state.failed=true; return retval;}
				throw new FailedPredicateException(input, "neg_operator_key", "(helper.isPluggableEvaluator(true))");
			}
			id=(Token)match(input,ID,FOLLOW_ID_in_neg_operator_key4819); if (state.failed) return retval;
			if ( state.backtracking==0 ) { helper.emit(id, DroolsEditorType.KEYWORD); }
			}

			retval.stop = input.LT(-1);

		}

		catch (RecognitionException re) {
		    throw re;
		}

		finally {
			// do for sure before leaving
		}
		return retval;
	}
29587
public static Matcher<ExpressionTree> methodReturnsNonNull() {
    return anyOf(
        instanceMethod().onDescendantOf("java.lang.Object").named("toString"),
        instanceMethod().onExactClass("java.lang.String"),
        staticMethod().onClass("java.lang.String"),
        instanceMethod().onExactClass("java.util.StringTokenizer").named("nextToken"));
  }
1115911
@SuppressWarnings({ "unchecked", "rawtypes" })
	public static Class<? extends Operator> getContractClass(final Class<?> stubClass) {
		if (stubClass == null) {
			return null;
		}
		final Class<?> contract = STUB_CONTRACTS.get(stubClass);
		if (contract != null) {
			return (Class<? extends Operator<?>>) contract;
		}
		Iterator<Entry<Class<?>, Class<? extends Operator>>> stubContracts = STUB_CONTRACTS.entrySet().iterator();
		while (stubContracts.hasNext()) {
			Map.Entry<Class<?>, Class<? extends Operator>> entry = stubContracts.next();
			if (entry.getKey().isAssignableFrom(stubClass)) {
				return entry.getValue();
			}
		}
		return null;

	}
35017
public static <OPERATOR extends Operator<?>> OPERATOR validateImplementation(OPERATOR operator) {
        for (TypeVariable<?> var : Validate.notNull(operator, "operator").getClass().getTypeParameters()) {
            if (Types.resolveAt(operator, var) == null) {
                throw new OperatorDefinitionException(operator, "Could not resolve %s against operator %s",
                    TypeUtils.toLongString(var), operator);
            }
        }
        return operator;
    }
623191
@Nullable
  public static <E extends AbstractOperator> E findForClass(@Nonnull final Class<E> operatorClass) {
    for (final AbstractOperator operator : getAllOperators()) {
      if (operator.getClass() == operatorClass) {
        return operatorClass.cast(operator);
      }
    }
    return null;
  }
610070
public ObjectProperty<Logger> loggerProperty() {
		if (this.logger == null) {
			this.logger = new SimpleObjectProperty<Logger>(this, LOGGER_PROPERTY, Logger.getLogger(getClass().getName())) {
				@Override
				protected void invalidated() {
					final Logger log = get();
					if (log == null) {
						set(Logger.getLogger(getClass().getName()));
					}
				}
			};
		}
		return this.logger;
	}