Checks if value(by index) is present in cache

@param index index at which the specified element is to be inserted
@return true if value is present in cache, false otherwize
510825
private boolean valueCached(int index) {
        boolean result = false;

        if (generatedCacheMap.containsKey(index) == true || resultSetCacheMap.containsKey(index) == true) {
            result = true;
        }

        return result;
    }
472858
private function hasIndex($index)
    {
        return is_string($index) ? $this->hasName($index) : $this->hasPosition($index);
    }
946818
protected boolean containsElem(int index, final T key, int hashCode) {
    for (LinkedElement<T> e = entries[index]; e != null; e = e.next) {
      // element found
      if (hashCode == e.hashCode && e.element.equals(key)) {
        return true;
      }
    }
    // element not found
    return false;
  }
849271
public boolean isCompactable(long index) {
    Map.Entry<Long, JournalSegment<E>> segmentEntry = segments.floorEntry(index);
    return segmentEntry != null && segments.headMap(segmentEntry.getValue().index()).size() > 0;
  }
302411
private boolean isPreamble(int index) {
        if (index <= buffer.length() - 6) {
            if (
                    buffer.get(index)     == '<' && 
                    buffer.get(index + 1) == '?' && 
                    buffer.get(index + 2) == 'x' && 
                    buffer.get(index + 3) == 'm' && 
                    buffer.get(index + 4) == 'l' && 
                    buffer.get(index + 5) == ' '
                ) {
                return true;
            }
        }
        return false;
    }
307762
public boolean containsValue(Object val) {
        synchronized( this ) {
            for( V item : values() ) {
                if( item instanceof CachedItem ){
                    CachedItem ci = (CachedItem)item;

                    if( ci.isValidForCache() && ci.equals(val) ) {
                        return true;
                    }
                }
                else if( item.equals(val) ) {
                    return true;
                }
            }
        }
        return false;
    }
913520
public <V> boolean contains(IndexDefinition<T, V> indexDefinition, V value) {
    FieldIndex<T, V> index = (FieldIndex<T, V>) mIndices.get(indexDefinition);
    if (index == null) {
      throw new IllegalStateException("the given index isn't defined for this IndexedSet");
    }
    return index.containsField(value);
  }
807108
public boolean isOuterJoin(int index) throws IndexOutOfBoundsException {
        if (index < 0) {
            throw new IndexOutOfBoundsException();
        }
        if (mOuterJoin == null) {
            if (index > getChainCount()) {
                throw new IndexOutOfBoundsException();
            }
            return false;
        }
        return mOuterJoin[index];
    }
527248
public function hasIndex($index)
    {
        if ($index instanceof Index) {
            $index = $index->getName();
        }

        return \in_array($index, $this->_indices);
    }
850093
public function offsetExists($index)
    {
        if (!$exists = parent::offsetExists($index)) {
            if (isset($this->{$index})) {
                return true;
            }
        }
        return $exists;
    }
1250533
public function hasNode($index)
    {
        if (is_string($index) and in_array($index, $this->nodesEntities)) {
            if (false !== ($key = array_search($index, $this->nodesEntities))) {
                if ($this->offsetExists($key)) {
                    return true;
                }
            }
        }

        return false;
    }
833111
private boolean contains(final int key, final int index) {
        return (key != 0 || states[index] == FULL) && keys[index] == key;
    }
660351
public boolean getAndSet(int index)
    {
        int wordNum = index >> 6; // div 64
        int bit = index & 0x3f; // mod 64
        long bitmask = 1L << bit;
        boolean val = (bits[wordNum] & bitmask) != 0;
        bits[wordNum] |= bitmask;
        return val;
    }
240200
public boolean remove(int index) {

        Widget w = getWidget(index);
        if (w != null) {
            return remove(getWidget(index));
        }
        return false;
    }
890379
private boolean containsKey(final int key, final int index) {
        return (key != 0 || states[index] == FULL) && keys[index] == key;
    }
1171777
synchronized public Element get(long index) {
    int bind = ((int)index & Integer.MAX_VALUE) % buckets.length;
    Element[] bucket = buckets[bind];
    if (bucket == null)
      return null;
    for (int i = 0; i < counts[bind]; i++)
      if (bucket[i].getIndex() == index)
        return bucket[i];
    return null;
  }
580537
private function _isset($index, $accept_reverse_index) : bool
    {
        $values = $this->getValues();
        if ($accept_reverse_index){
            $index = $this->_rindex($index, $values);
        }
        return isset($values[$index]);
    }