Returns the no-op implementation of the {@code DerivedDoubleCumulative}.

@return the no-op implementation of the {@code DerivedDoubleCumulative}.
@since 0.21
760048
static DerivedDoubleCumulative newNoopDerivedDoubleCumulative(
      String name, String description, String unit, List<LabelKey> labelKeys) {
    return NoopDerivedDoubleCumulative.create(name, description, unit, labelKeys);
  }
644611
public AbstractJobVertex areVertexDegreesCorrect() {

		// Check input vertices
		final Iterator<AbstractJobInputVertex> iter = getInputVertices();
		while (iter.hasNext()) {

			final AbstractJobVertex jv = iter.next();

			if (jv.getNumberOfForwardConnections() < 1 || jv.getNumberOfBackwardConnections() > 0) {
				return jv;
			}
		}

		// Check task vertices
		final Iterator<JobTaskVertex> iter2 = getTaskVertices();
		while (iter2.hasNext()) {

			final AbstractJobVertex jv = iter2.next();

			if (jv.getNumberOfForwardConnections() < 1 || jv.getNumberOfBackwardConnections() < 1) {
				return jv;
			}
		}

		// Check output vertices
		final Iterator<AbstractJobOutputVertex> iter3 = getOutputVertices();
		while (iter3.hasNext()) {

			final AbstractJobVertex jv = iter3.next();

			if (jv.getNumberOfForwardConnections() > 0 || jv.getNumberOfBackwardConnections() < 1) {
				return jv;
			}
		}

		return null;
	}
442382
public Iterator<ISO9660Directory> unsortedIterator() {
        if (unsortedIterator == null) {
            unsortedIterator = new ISO9660DirectoryIterator(this, false);
        }
        unsortedIterator.reset();
        return unsortedIterator;
	}
1181204
public com.google.api.ads.adwords.axis.v201809.cm.PredicateOperator getOperator() {
        return operator;
    }
1282759
public Double asDoubleObj() {
		if (current == null)
			return null;
		if (current instanceof Number) {
			if (current instanceof Double)
				return (Double) current;
			return Double.valueOf(((Number) current).doubleValue());
		}
		return Double.NaN;
	}
1183641
@Override
    public final DoubleStream asDoubleStream() {
        return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                                    StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
            @Override
            public Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
                return new Sink.ChainedLong<Double>(sink) {
                    @Override
                    public void accept(long t) {
                        downstream.accept((double) t);
                    }
                };
            }
        };
    }
1304661
public SoyExpression coerceToDouble() {
    if (!isBoxed()) {
      if (soyRuntimeType.isKnownFloat()) {
        return this;
      }
      if (soyRuntimeType.isKnownInt()) {
        return forFloat(BytecodeUtils.numericConversion(delegate, Type.DOUBLE_TYPE));
      }
      throw new UnsupportedOperationException("Can't convert " + resultType() + " to a double");
    }
    if (soyRuntimeType.isKnownFloat()) {
      return forFloat(delegate.invoke(MethodRef.SOY_VALUE_FLOAT_VALUE));
    }
    return forFloat(delegate.invoke(MethodRef.SOY_VALUE_NUMBER_VALUE));
  }
1352950
public static IJavaBatchCompiler newDefaultJavaBatchCompiler() {
		try {
			synchronized (SarlBatchCompiler.class) {
				if (defaultJavaBatchCompiler == null) {
					final ImplementedBy annotation = IJavaBatchCompiler.class.getAnnotation(ImplementedBy.class);
					assert annotation != null;
					final Class<?> type = annotation.value();
					assert type != null;
					defaultJavaBatchCompiler = type.asSubclass(IJavaBatchCompiler.class);
				}
				return defaultJavaBatchCompiler.newInstance();
			}
		} catch (Exception exception) {
			throw new RuntimeException(exception);
		}
	}
834898
public static AGeneralOperation getOperation(OperationType operationType){
		switch(operationType){
			case BASIC_INSTRUCTION:			   return new BasicOperation();			
			case BASIC_CONVERSION:             return new BasicConversion();			
			case OBJECT:					   return new ObjectOperation();			
			case ARRAY: 					   return new ArrayOperation();			
			case ARRAY_LIST:				   return new ArrayListOperation();		
			case LIST_ARRAY:			       return new ListArrayOperation();		
			case ARRAY_WITH_MAPPED_ITEMS:	   return new MappedArrayOperation();		
			case ARRAY_LIST_WITH_MAPPED_ITEMS: return new MappedArrayListOperation();	
			case LIST_ARRAY_WITH_MAPPED_ITEMS: return new MappedListArrayOperation();	
			case COLLECTION: 				   return new CollectionOperation();		
			case COLLECTION_WITH_MAPPED_ITEMS: return new MappedCollectionOperation();	
			case MAP:	     				   return new MapOperation();				
			case MAP_WITH_MAPPED_ITEMS: 	   return new MappedMapOperation();		
			case CONVERSION: 				   return new ConversionOperation();
			case DATE_CALENDAR:				   return new DateCalendarOperation();
			case STRING_ENUM: 				   return new StringEnumOperation();
			case STRING_STRINGBUFFER:		   return new StringStringBufferOperation();
			case STRING_STRINGBUILDER:		   return new StringStringBuilderOperation();
			case CALENDAR_DATE:				   return new CalendarDateOperation();
			case ENUM_STRING:				   return new EnumStringOperation();
			case STRINGBUILDER_STRING:         return new StringBuilderStringOperation();
			case STRINGBUFFER_STRING:		   return new StringBufferStringOperation();
			case ENUM_ENUM: 				   return new EnumEnumOperation();
			default: return null;
		}
		
	}
452037
public static NoProxyPortSelector getInstance()
    {
        if( _instance == null )
        {
            synchronized( NoProxyPortSelector.class )
            {
                if( _instance == null )
                {
                    _instance = new NoProxyPortSelector();
                }
            }
        }

        return _instance;
    }
275044
static DerivedLongCumulative newNoopDerivedLongCumulative(
      String name, String description, String unit, List<LabelKey> labelKeys) {
    return NoopDerivedLongCumulative.create(name, description, unit, labelKeys);
  }
1091801
public final Optional<L> asOptionalLeft() {
		return fold(Optional::of, val -> Optional.<L> empty());
	}
632828
public DTMAxisIterator cloneIterator()
  {

    try
    {
      final DTMAxisIteratorBase clone = (DTMAxisIteratorBase) super.clone();

      clone._isRestartable = false;

      // return clone.reset();
      return clone;
    }
    catch (CloneNotSupportedException e)
    {
      throw new org.apache.xml.utils.WrappedRuntimeException(e);
    }
  }
267295
public static <ElementType> Ordering<Multiset.Entry<ElementType>> byCountOrdering() {
    return Ordering.natural().onResultOf(MultisetUtils.<ElementType>toCountFunction());
  }
917098
public MethodDoc overriddenMethod() {

        // Real overriding only.  Static members are simply hidden.
        // Likewise for constructors, but the MethodSymbol.overrides
        // method takes this into account.
        if ((sym.flags() & Flags.STATIC) != 0) {
            return null;
        }

        // Derived from  com.sun.tools.javac.comp.Check.checkOverride .

        ClassSymbol origin = (ClassSymbol)sym.owner;
        for (Type t = env.types.supertype(origin.type);
             t.hasTag(CLASS);
             t = env.types.supertype(t)) {
            ClassSymbol c = (ClassSymbol)t.tsym;
            for (Symbol sym2 : membersOf(c).getSymbolsByName(sym.name)) {
                if (sym.overrides(sym2, origin, env.types, true)) {
                    return env.getMethodDoc((MethodSymbol)sym2);
                }
            }
        }
        return null;
    }
46648
public static <T> Source<T> empty() {
        return new AbstractSource<T>() {
            @Override
            public T computeNext() {
                return endOfData();
            }
        };
    }
468142
public T max() {
        TObjectIntIterator<T> iter = counts.iterator();
        int maxCount = -1;
        T max = null;
        while (iter.hasNext()) {
            iter.advance();
            int count = iter.value();
            if (count > maxCount) {
                max = iter.key();
                maxCount = count;
            }
        }
        return max;
    }