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

@return the no-op implementation of the {@code LongCumulative}.
@since 0.21
775629
static LongCumulative newNoopLongCumulative(
      String name, String description, String unit, List<LabelKey> labelKeys) {
    return NoopLongCumulative.create(name, description, unit, labelKeys);
  }
328124
public static Function<Object,Long> l(final String methodName, final Object... optionalParameters) {
        return methodForLong(methodName, optionalParameters);
    }
188869
public Iterator<E> iterator() {

        return new Iterator<E>() {

            public boolean hasNext() {
                return enumeration.hasMoreElements();
            }

            public E next() {
                return enumeration.nextElement();
            }

            public void remove() {
                throw new UnsupportedOperationException("IterableEnumeration does not support remove");
            }
        };
    }
217433
public long getDigest()
  {
    try {
      if (_newDigest != 0)
        return _newDigest;
      
      if (_cl == null)
        return -1;

      long digest = 37;

      digest = addDigest(digest, _cl);
      
      _newDigest = digest;
    } catch (Throwable e) {
      log.log(Level.FINER, e.toString(), e);

      _newDigest = -1;
    }

    return _newDigest;
  }
335449
public Long asLongObj() {
		if (current == null)
			return null;
		if (current instanceof Number) {
			if (current instanceof Long)
				return (Long) current;
			if (current instanceof Integer)
				return Long.valueOf(((Number) current).longValue());
			return null;
		}
		return null;
	}
158090
public static LongBinding negateExact(final ObservableLongValue a) {
        return createLongBinding(() -> Math.negateExact(a.get()), a);
    }
923336
@NotNull
    public OptionalLong min() {
        return reduce(new LongBinaryOperator() {
            @Override
            public long applyAsLong(long left, long right) {
                return Math.min(left, right);
            }
        });
    }
913789
public static LongIterator of(final Supplier<? extends LongIterator> iteratorSupplier) {
        N.checkArgNotNull(iteratorSupplier, "iteratorSupplier");

        return new LongIterator() {
            private LongIterator iter = null;
            private boolean isInitialized = false;

            @Override
            public boolean hasNext() {
                if (isInitialized == false) {
                    init();
                }

                return iter.hasNext();
            }

            @Override
            public long nextLong() {
                if (isInitialized == false) {
                    init();
                }

                return iter.nextLong();
            }

            private void init() {
                if (isInitialized == false) {
                    isInitialized = true;
                    iter = iteratorSupplier.get();
                }
            }
        };
    }
978519
private long toLong() {
        assert (intLen <= 2) : "this MutableBigInteger exceeds the range of long";
        if (intLen == 0)
            return 0;
        long d = value[offset] & LONG_MASK;
        return (intLen == 2) ? d << 32 | (value[offset + 1] & LONG_MASK) : d;
    }
1144590
public long getLong() {
        return ((long) (_buffer[_offset++] & 0xff) << 56 | (long) (_buffer[_offset++] & 0xff) << 48
                | (long) (_buffer[_offset++] & 0xff) << 40 | (long) (_buffer[_offset++] & 0xff) << 32
                | (long) (_buffer[_offset++] & 0xff) << 24 | (long) (_buffer[_offset++] & 0xff) << 16
                | (long) (_buffer[_offset++] & 0xff) << 8 | (long) (_buffer[_offset++] & 0xff));
    }
223860
public Type toNonNull() {
        if (isNonNull()) {
            return this;
        }
        else {
            return new Type(this) {
                private static final long serialVersionUID = 1L;

                public boolean isNonNull() {
                    return true;
                }

                public boolean isNullable() {
                    return false;
                }

                public Type toNullable() {
                    return Type.this;
                }
            };
        }
    }
380636
public int getCumulativeProgress(){
        int numChildren = getChildCount();
        int total = 0;
        for (int i = 0; i < numChildren; i++) {
            total += getChildProgress(i);
        }
        checkCumulativeSmallerThanMax(maxProgress, total);
        return total;
    }
856033
@Override
    public final LongStream asLongStream() {
        return new LongPipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                     StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
            @Override
            public Sink<Integer> opWrapSink(int flags, Sink<Long> sink) {
                return new Sink.ChainedInt<Long>(sink) {
                    @Override
                    public void accept(int t) {
                        downstream.accept((long) t);
                    }
                };
            }
        };
    }
1217676
public static LongIteratorEx of(final Supplier<? extends LongIterator> iteratorSupplier) {
        N.checkArgNotNull(iteratorSupplier, "iteratorSupplier");

        return new LongIteratorEx() {
            private LongIterator iter = null;
            private LongIteratorEx iterEx = null;
            private boolean isInitialized = false;

            @Override
            public boolean hasNext() {
                if (isInitialized == false) {
                    init();
                }

                return iter.hasNext();
            }

            @Override
            public long nextLong() {
                if (isInitialized == false) {
                    init();
                }

                return iter.nextLong();
            }

            @Override
            public void skip(long n) {
                N.checkArgNotNegative(n, "n");

                if (isInitialized == false) {
                    init();
                }

                if (iterEx != null) {
                    iterEx.skip(n);
                } else {
                    super.skip(n);
                }
            }

            @Override
            public long count() {
                if (isInitialized == false) {
                    init();
                }

                if (iterEx != null) {
                    return iterEx.count();
                } else {
                    return super.count();
                }
            }

            @Override
            public void close() {
                if (isInitialized == false) {
                    init();
                }

                if (iterEx != null) {
                    iterEx.close();
                }
            }

            private void init() {
                if (isInitialized == false) {
                    isInitialized = true;
                    iter = iteratorSupplier.get();
                    iterEx = iter instanceof LongIteratorEx ? (LongIteratorEx) iter : null;
                }
            }
        };
    }
627714
public String toLongString() {
        String plz = this.getCode();
        if (this.hasLandeskennung()) {
            plz = toLongString(plz);
        }
        return plz;
    }
1143506
public T get(final long _id)
    {
        return getCache4Id() == null ? null : getCache4Id().get(new Long(_id));
    }
886608
public long toLong() {
    int workingDays = days;
    int workingHours = hours;
    if (hours >= hoursInDay) {
      int nbAdditionalDays = hours / hoursInDay;
      workingDays += nbAdditionalDays;
      workingHours = hours - (nbAdditionalDays * hoursInDay);
    }
    return 1L * workingDays * DAY_POSITION_IN_LONG + workingHours * HOUR_POSITION_IN_LONG + minutes * MINUTE_POSITION_IN_LONG;
  }