Returns a unique numeric value across the entire life of the message store.
At least until the <code>long</code> value wraps around.

@return a value which is unique across the entire life of the
message store
178691
public long getUniqueValue() throws PersistenceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "getUniqueValue");

        long retval;
            
        synchronized (_globalUniqueLock) 
        {
            if (_globalUnique == _globalUniqueThreshold) 
            {
                _globalUniqueManager.scheduleUpdate(this);
            }
            else if (_globalUnique == _globalUniqueLimit) 
            {
                _globalUniqueManager.updateEntry(this);
                nextRangeMaximumAvailable();
            }
            
            retval = _globalUnique++;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getUniqueValue", "return="+retval);
        return retval;
    }
722498
public final long getPackedLong() {
        final int lead = getUint8();
        if (lead < 251) return lead;

        switch (lead) {
            case 251:
                return NULL_LENGTH;
            case 252:
                return getUint16();
            case 253:
                return getUint24();
            default: /* Must be 254 when here */
                final long value = getUint32();
                position += 4; /* ignore other */
                return value;
        }
    }
263782
public synchronized long peekLong()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "peekLong");

      checkReleased();

      long result = 0;
      if (receivedBuffer != null)
      {
         int currentPosition = receivedBuffer.position();
         result = receivedBuffer.getLong();
         receivedBuffer.position(currentPosition);
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "peekLong", result);
      return result;
   }
1232906
public LongSubject hasValueThat() {
    if (actual() == null || !actual().isPresent()) {
      isPresent(); // fails
      return ignoreCheck().that(0L);
    } else {
      return check("getAsLong()").that(actual().getAsLong());
    }
  }
1018347
public com.google.protobuf.ByteString
      getOldValueBytes() {
    java.lang.Object ref = oldValue_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      oldValue_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
789628
public LongLongIndex.LLEntry nextULL() {
		if (!hasNextULL()) {
			throw new NoSuchElementException();
		}

        LongLongIndex.LLEntry e = new LongLongIndex.LLEntry(nextKey, nextValue);
		if (currentPage == null) {
			hasValue = false;
		} else {
			gotoPosInPage();
		}
		return e;
	}
1098780
@Override
    public synchronized Object getValue() {
        if (id != null) {
            if (serializedValue != null) {
                long oldSize = -1;
                if (cacheEntryPool != null) {
                    if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                        oldSize = getObjectSize();
                    }
                }

                try {
                    value = SerializationUtility.deserialize(serializedValue, cacheName);
                } catch (Exception ex) {
                    com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.CacheEntry.getValue", "200", this);
                }
                if (value != null) {
                    serializedValue = null;
                    if (cacheEntryPool != null) {
                        if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                            long newSize = getObjectSize();
                            if (oldSize != -1 && newSize != -1) {
                                cacheEntryPool.cache.increaseCacheSizeInBytes(newSize - oldSize, "GET_VALUE");
                            } else {
                                cacheEntryPool.cache.disableCacheSizeInMB();
                            }
                        }
                    }
                }
            }
        }
        return value;
    }
257377
public long getValueAsLong(int index) throws IOException {
        if (index >= structure.valueSizes.size()) {
            throw new IOException("Index " + index + " is out of range.");
        }
        return Bytes.toLong(value, structure.valueByteOffsets.get(index));
    }
1148138
public long calcChecksum() {
        if (checksum == null) {
            Lock lock = lockForRead();
            try {
                checksum = checksum();
            } finally {
                lock.unlock();
            }
        }
        return checksum.longValue();
    }
735383
public long getLastModified() throws GetLastModifiedException {
        long result;

        result = Long.MIN_VALUE;
        for (Node node : nodes) {
            if (node instanceof HttpNode) {
                // skip getLastModified - it's not supported by Webservice Stub Servlet
            } else {
                result = Math.max(result, node.getLastModified());
            }
        }
        return result == Long.MIN_VALUE ? -1 : result;
    }
883693
public long getFirstNumericValue() {
    String val = (value != null) ? value.get(0).toString() : readValue.get(0).toString();
    if (isInteger(val)) {
      return Long.parseLong(val);
    } else {
      return 0;
    }
  }
323226
protected Long getLong(Exchange exchange, Message message, String name) {
        Object value = getObject(exchange, message, name);
        if (value instanceof Long) {
            return (Long)value;
        } else if (value instanceof Number) {
            return Long.valueOf(((Number)value).longValue());
        } else if (value instanceof String) {
            return Long.valueOf(((String)value).trim());
        }
        return null;
    }
280195
public synchronized long term() {
    Map.Entry<Long, Long> entry = terms.lastEntry();
    return entry != null ? entry.getValue() : 0;
  }
1129779
public synchronized long getCheckpointedSequence() {
		long sequence = lastSequence;
		if(!sequences.isEmpty()) {
			sequence = sequences.first() - 1;
		}
		
		if(sequence > firstValueSequence) {
			// Garbage-collect inaccessible values:
			int numToRemove = (int)(sequence - firstValueSequence);
			for(int i = 0; i < numToRemove; i++) {
				values.remove(0);
			}
			firstValueSequence += numToRemove;
		}
		
		return sequence;
	}
961911
public long getLong(int index)
  {
    Object value = _values[index - 1];

    if (value instanceof Long) {
      return (Long) value;
    }
    else if (value instanceof Integer) {
      return (Integer) value;
    }
    else {
      return Long.valueOf(value.toString());
    }
  }
894880
public int uIntValue() throws OtpErlangRangeException {
        final long l = longValue();
        final int i = (int) l;

        if (i != l) {
            throw new OtpErlangRangeException("Value too large for int: " + val);
        } else if (i < 0) {
            throw new OtpErlangRangeException("Value not positive: " + val);
        }

        return i;
    }
772318
public static long getRandomLong()
  {
    Random random = getRandom();

    long value = random.nextLong();

    if (! _isTest) {
      _freeRandomList.free(random);
    }

    return value;
  }