Extract one value from the selected pipe, if it exists

@param key : Adapter identifier
@return Maybe containing next value from the Adapter identified by the provided key
14827
@SuppressWarnings({ "unchecked", "rawtypes" })
    public Option<V> oneValue(final K key) {
        final ValueSubscriber<V> sub = ValueSubscriber.subscriber();
        return get(key).peek(a -> a.stream()
                                   .subscribe(sub))
                       .flatMap(a -> sub.toMaybe());
    }
236082
def get(self, section, key):
        
        line = self._make_line(key)
        for line in self.get_line(section, line):
            yield line.value
569511
public V remove (int key)
    {
        Record<V> removed = removeImpl(key, true);
        return (removed == null) ? null : removed.value;
    }
566978
public boolean containsKey(Object key) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);
        while (true) {
            Object item = tab[i];
            if (item == k)
                return true;
            if (item == null)
                return false;
            i = nextKeyIndex(i, len);
        }
    }
760189
protected Object extractSpecificConfig(String key)
    {
        if (this.specificConfig == null)
        {
            return null;
        }

        Object result = this.specificConfig.get(key);
        return result;
    }
630515
public synchronized V get(final K key) {
		if (!validState) {
			throw new InvalidStateException();
		}
		if (_isEmpty()) {
			return null;
		}
		if (key == null) {
			return null;
		}
		try {
			final LeafNode<K, V> node = findLeafNode(key, false);
			if (node == null) {
				return null;
			}
			int slot = node.findSlotByKey(key);
			if (slot >= 0) {
				return node.values[slot];
			}
			return null;
		} finally {
			releaseNodes();
		}
	}
261480
def _get(self, key):
        
        buf = BytesIO()

        self._get_file(key, buf)

        return buf.getvalue()
79665
public boolean containsKey(final int key)
    {
        boolean found = false;
        @DoNotSub final int setNumber = Hashing.hash(key, mask);
        @DoNotSub final int setBeginIndex = setNumber << setSizeShift;

        for (@DoNotSub int i = setBeginIndex, setEndIndex = setBeginIndex + setSize; i < setEndIndex; i++)
        {
            if (null == values[i])
            {
                break;
            }

            if (key == keys[i])
            {
                found = true;
                break;
            }
        }

        return found;
    }
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;
    }
  }
679738
public MatchIterator get(long key, int hashCode) {
		int bucket = hashCode & numBucketsMask;

		int bucketOffset = bucket << 4;
		MemorySegment segment = buckets[bucketOffset >>> segmentSizeBits];
		int segOffset = bucketOffset & segmentSizeMask;

		while (true) {
			long address = segment.getLong(segOffset + 8);
			if (address != INVALID_ADDRESS) {
				if (segment.getLong(segOffset) == key) {
					return valueIter(address);
				} else {
					bucket = (bucket + 1) & numBucketsMask;
					if (segOffset + 16 < segmentSize) {
						segOffset += 16;
					} else {
						bucketOffset = bucket << 4;
						segOffset = bucketOffset & segmentSizeMask;
						segment = buckets[bucketOffset >>> segmentSizeBits];
					}
				}
			} else {
				return valueIter(INVALID_ADDRESS);
			}
		}
	}
33239
public VALUE get(KEY key) {
        CacheEntry<VALUE> entry;
        synchronized (this) {
            entry = values.get(key);
        }
        VALUE value;
        if (entry != null) {
            if (isExpiring) {
                long age = System.currentTimeMillis() - entry.timeCreated;
                if (age < expirationMillis) {
                    value = getValue(key, entry);
                } else {
                    countExpired++;
                    synchronized (this) {
                        values.remove(key);
                    }
                    value = null;
                }
            } else {
                value = getValue(key, entry);
            }
        } else {
            value = null;
        }
        if (value != null) {
            countHit++;
        } else {
            countMiss++;
        }
        return value;
    }
149677
public V get(K key) {
    if (root == null) {
      return null;
    }
    return root.get(key, key.hashCode(), 0);
  }
1030294
long get(final T key) {
    if (key == null) { return 0; }
    final int probe = hashProbe(key);
    if (states[probe] > 0) {
      assert (keys[probe]).equals(key);
      return values[probe];
    }
    return 0;
  }
485755
public String get(String key) {
        int i = indexOfKey(key);
        return i == NotFound ? EmptyString : checkNotNull(vals[i]);
    }
1315262
protected boolean matchesFilter(String key) {
		boolean rets = (null == filterList);
		if (!rets) {
			for (Iterator<String> it = filterList.iterator(); it.hasNext() && !rets;)
				rets = key.startsWith(it.next());
		}
		return rets;

	}
685050
function (key) {
        var index = this.indexOfKey(key);

        if (index >= 0) {
            return this.slot.values[index];
        }

        error(ERROR_KEY_NOT_FOUND);
    }
406840
@Override
	public DataSet getNextDataSet(final String key) {
		DataSet data = getNextDataSetImpl(key);
		if (data != null) {
			copyFixedValues(key, data);
			currentDataSets.put(key, data);
		}
		return data;
	}