Returns the long value stored in this object for the given key.
Returns 0 if there is no such key.

@param key the name of the field on this object
@return the requested long value or 0 if there was no such key
345339
public long optLong(String key){
		LazyNode token=getOptionalFieldToken(key);
		if(token==null)return 0l;
		if(token.type==LazyNode.VALUE_NULL)return 0l;
		return token.getLongValue();
	}
340493
public static long getLong ( Properties props, String key, long def ) {
        String s = props.getProperty(key);
        if ( s != null ) {
            try {
                def = Long.parseLong(s);
            }
            catch ( NumberFormatException nfe ) {
                log.error("Not a number", nfe);
            }
        }
        return def;
    }
657600
public long getLong( String key )
        throws MissingResourceException
    {
        ResourceBundle bundle = getBundle();
        String value = bundle.getString( key );
        try
        {
            return Long.parseLong( value );
        }
        catch( NumberFormatException nfe )
        {
            throw new MissingResourceException( "Expecting a long value but got " + value,
                                                "java.lang.String",
                                                key
            );
        }
    }
60952
public boolean isValueExistForKey(String key) {
		boolean isValueExists;
		try {
			String string = getString(key, "");
			isValueExists = !string.equalsIgnoreCase("");
		} catch (ClassCastException e) {
			try {
				int anInt = getInt(key, 0);
				isValueExists = anInt != 0;
			} catch (ClassCastException e1) {
				try {
					long aLong = getLong(key, 0);
					isValueExists = aLong != 0;
				} catch (ClassCastException e2) {
					try {
						float aFloat = getFloat(key, 0f);
						isValueExists = aFloat != 0;
					} catch (ClassCastException e3) {
						try {
							boolean aBoolean = getBoolean(key, false);
							isValueExists = !aBoolean;
						} catch (Exception e4) {
							isValueExists = false;
							e.printStackTrace();
						}
					}

				}

			}
		} catch (Exception e) {
			isValueExists = false;
		}
		return isValueExists;
	}
1295686
public long[] getLongArray(final String key) {
		final String[] value = getArray(key);
		if (value != null) {
			final long[] result = new long[value.length];
			for (int i = 0; i < value.length; i++) {
				result[i] = Long.parseLong(value[i]);
			}
			return result;
		}
		return null;
	}
1215308
public V get(final int key) {
		final int index = (key & 0x7FFFFFFF) % elementData.length;

		IntEntry<V> m = elementData[index];
		while (m != null) {
			if (key == m.key) {
				return m.value;
			}
			m = m.nextInSlot;
		}
		return null;
	}
985044
public Number getNumber(String key) throws NumberFormatException {
        String value = getString(key);
        if (value == null) {
            return null;
        }
        else {
            try {
                return Integer.valueOf(value);
            }
            catch (NumberFormatException e) {
            }
            try {
                return Long.valueOf(value);
            }
            catch (NumberFormatException e) {
            }
            return Double.valueOf(value);
        }
    }
884144
public long getTotalBytesOnTiersOrThrow(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, java.lang.Long> map =
        internalGetTotalBytesOnTiers().getMap();
    if (!map.containsKey(key)) {
      throw new java.lang.IllegalArgumentException();
    }
    return map.get(key);
  }
1099642
public long getLong(String key) {
    if (containsKey(key)) {
      return Long.parseLong(get(key));
    } else {
      throw new IllegalArgumentException("Missing key " + key + ".");
    }
  }
1272910
public String getValue(String key) {
        KeyValue kv = getKV(key);
        return kv == null ? null : kv.getValue();
    }
71763
@Override
    public Object getValue(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        final int index = indexForColumnName(key);
        return index >= 0 ? getValue(index) : null;
    }
1172633
public long remove(K key) {
    AtomicLong atomic = map.get(key);
    if (atomic == null) {
      return 0L;
    }

    for (;;) {
      long oldValue = atomic.get();
      if (oldValue == 0L || atomic.compareAndSet(oldValue, 0L)) {
        // only remove after setting to zero, to avoid concurrent updates
        map.remove(key, atomic);
        // succeed even if the remove fails, since the value was already adjusted
        return oldValue;
      }
    }
  }
275290
public Long getInteger(int key) {
        PebbleTuple tuple = getTuple(key, PebbleTuple.TupleType.INT);
        if (tuple == null) {
            return null;
        }
        return (Long) tuple.value;
    }
1077359
public long getLong( String key, long defaultValue )
        throws MissingResourceException
    {
        try
        {
            return getLong( key );
        }
        catch( MissingResourceException mre )
        {
            return defaultValue;
        }
    }
1094193
public int getExisting(Object key) {
        if (key == null) { key = UniqueTag.NULL_VALUE; }
        int index = findIndex(key);
        if (0 <= index) {
            return values[index];
        }
        // Key must exist
        Kit.codeBug();
        return 0;
    }
1094727
public long[] getLongArray(final String key, final long[] def) {
		try {
			final long[] result = getLongArray(key);
			return result != null ? result : def;
		} catch (final NumberFormatException nfe) {
			return def;
		}
	}
534771
public Object get(long key)
  {
    int hash = (int) (key & mask);

    while (true) {
      long mapKey = keys[hash];

      if (mapKey == key)
        return values[hash];
      else if (mapKey == DEAD_KEY) {
        if ((flags[hash] & DELETED) == 0)
          return null;
      }

      hash = (hash + 1) & mask;
    }
  }