Gets the positive query.

@param index the index
@return the positive query
555640
public MtasSpanQuery getPositiveQuery(int index) {
    if ((index >= 0) && (index < positiveQueryList.size())) {
      return positiveQueryList.get(index);
    } else {
      return null;
    }
  }
440927
public Object get (int index)
    {
        return _list[(_lastPos-index-1+_list.length)%_list.length];
    }
1290553
public com.google.rpc.PreconditionFailure.ViolationOrBuilder getViolationsOrBuilder(
      int index) {
    return violations_.get(index);
  }
1336810
@Override
    public T get(int index) {
        if (displacement != null) {
            return super.get(index - displacement);
        }
        return super.get(index);
    }
1027314
public Boolean getBoolean(int index, boolean strict) throws JsonException {
        JsonElement el = get(index);
        Boolean res = null;
        if (strict && !el.isBoolean()) {
            throw Util.typeMismatch(index, el, "boolean", true);
        }
        if (el.isBoolean()) {
            res = el.asBoolean();
        }
        if (el.isString()) {
            res = Util.toBoolean(el.asString());
        }
        if (res == null)
            throw Util.typeMismatch(index, el, "boolean", strict);
        return res;
    }
838809
def get( index )
      raise "Only positive indexes, #{index}" if index < 0
      if index >= data_length
        return nil unless next_list
        return next_list.get( index - data_length)
      else
        ret = nil
        if(index < get_length)
          ret = get_internal_word(index + self.class.type_length )
        end
        return ret
      end
    end
1232871
public T get(int index) {
        if (index < 0 || index >= size) {
            return null;
        }
        if (!wasFullAtleastOnce && index >= emptyItemIndex) {
            return null;
        }
        return (T)(items[index]);
    }
776981
public int get(int index) {
        if (d_bitsPerElem == 0)
            return 0;

        int startIdx = (index * d_bitsPerElem) / INT_SIZE;
        int startBit = (index * d_bitsPerElem) % INT_SIZE;

        int result = (d_data[startIdx] >>> startBit) & MASK[d_bitsPerElem];

        if ((startBit + d_bitsPerElem) > INT_SIZE) {
            int done = INT_SIZE - startBit;
            result |= (d_data[startIdx + 1] & MASK[d_bitsPerElem - done]) << done;
        }

        return result;
    }
79677
public boolean get(int index) throws ArrayIndexOutOfBoundsException {
        if (index < 0 || index >= length) {
            throw new ArrayIndexOutOfBoundsException(Integer.toString(index));
        }

        return (repn[subscript(index)] & position(index)) != 0;
    }
513230
public int trueNegatives(int classindex) {
    int tn = 0;
    for(int i = 0; i < confusion.length; i++) {
      for(int j = 0; j < confusion[i].length; j++) {
        if(i != classindex && j != classindex) {
          tn += confusion[i][j];
        }
      }
    }
    return tn;
  }
1048967
@Override
    public boolean getBoolean(int index) {
        synchronized (lock) {
            return CBLConverter.asBoolean(getMValue(internalArray, index).asNative(internalArray));
        }
    }
62291
private QueryParameters readCachedValue(int index) {
        QueryParameters result = null;

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

        return result;
    }
429113
public T get( int index ) {
		if( index >= size )
			throw new IllegalArgumentException("Index out of bounds: index "+index+" size "+size);
		return data[index];
	}
414006
public E get(int index) {
        if (index >= mSize)
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + mSize);

        return index < 0 ? mElements.get(index + mSize) : mElements.get(index);
    }
713098
@Override
    public boolean getBoolean(int index) {
        check(index);
        final FLValue flValue = values.get(index);
        return flValue != null && flValue.asBool();
    }
142099
public String getKeyByIndex(int index) {
		Set<String> keySet = keyIndexs.keySet();
		for (String key : keySet) {
			int idx = keyIndexs.get(key);
			if (index == idx) {
				return key;
			}
		}
		return null;
	}
11232
public boolean get(long index) {
    if (!(index < size))
      throw new IndexOutOfBoundsException();
    return (bytes.readLong(offset(index)) & (1l << (position(index)))) != 0;
  }