Get element by index
@param <T> the input type
@param i the index
@param args the input argument
@return the object at the index
346442
public  static <T> T at(int i, T[] args)
	{
		if(args == null || i < 0)
			return null;
		
		if(i>= args.length)
			return null;
		
		return args[i];
	}
265921
public Object get(int index)
	{
		if (value == null)
			return value;
		if (value != null && !(value instanceof Object[]))
			throw new IllegalStateException("Trying to access indexed element of non-array Parameter");

		Object[] v = (Object[]) value;
		if (index < 0 || index >= v.length)
			return null;

		return Array.get(value, index);
	}
1072403
public Optional<E> get(int index) {
        return getOptional(linkedList)
                .filter(getGreaterSize(0).and(getGreaterSize(index)))
                .map(l -> l.get(index));
    }
1337733
@SuppressWarnings("unchecked")
    @Override
    public E get(int index) {

        _tailLock.lock();
        try {

            _headLock.lock();
            try {
                if (index < 0 || index >= _size.get())
                    throw new IndexOutOfBoundsException("!(" + 0 + "<" + index + "<=" + _size + ")");
                int i = _indexes[HEAD_OFFSET] + index;
                int capacity = _elements.length;
                if (i >= capacity)
                    i -= capacity;
                return (E) _elements[i];
            } finally {
                _headLock.unlock();
            }
        } finally {
            _tailLock.unlock();
        }
    }
845176
@Override
    public Byte get(int i)
    {
        if (checkIndex(i)) {
            throw new IndexOutOfBoundsException();
        }
        return (Byte)js_get(i);
    }
694287
public CalendarItem getItem(int i)
    {
        FieldList item = this.makeRowCurrent(i, false);
        int iRowCount = this.getRowCount();
        if (this.isAppending())
            iRowCount--;
        if (i >= iRowCount)
            return null;
        if (item instanceof CalendarItem)
            return (CalendarItem)item;
        else if (item != null)
            return this.getFieldListProxy(item);
        return null;
    }
69581
public T findElement(By by, int index) {
        T element = null;
        List<T> elements = findElements(by);
        if (elements.size() > index) {
            element = elements.get(index);
        }
        return element;
    }
319971
public E get(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        return (E) elementData[index];
    }
944200
public int get(int i, int j) {
        if (i < 0 || i >= size()) {
            throw new IllegalArgumentException("Invalid index: i = " + i);
        }

        int[] x = get(i).x;
        if (x.length == 0) {
            return 0;
        }
        
        int low = 0;
        int high = x.length - 1;
        int mid = (low + high) / 2;
        
        while (j != x[mid] && low <= high) {
            mid = (low + high) / 2;
            if (j < x[mid]) 
                high = mid - 1;
            else
                low = mid + 1;
        }
        
        if (j == x[mid]) {
            return 1;
        } else {
            return 0;
        }
    }
1002983
def gep(self, i):
        
        if not isinstance(i.type, IntType):
            raise TypeError(i.type)
        return self.element
1330213
@Override
	public E get() {
		if (originalElements.isEmpty()) {
			return null;
		}
		if (!priorityElements.isEmpty()) {
			return priorityElements.remove(0);
		}
		if (currentElements.size() <= originalElements.size()) {
			currentElements.addAll(originalElements);
		}
		int index = random.getInt(currentElements.size() - 1);
		return currentElements.remove(index);
	}
151283
@Override
    public E get(int index) {
        int idx = checkRangeConvert(index);
        return pointer.getElem(idx, idx ^ focus);
    }
454669
public IntBuffer get(int index, IntBuffer buffer) {
        MemUtil.INSTANCE.put(this, index, buffer);
        return buffer;
    }
704050
public String getOrElse(int i, String def)
    {
        if (i >= 0 && i < values.size())
        {
            return values.get(i);
        }
        return def;
    }
146862
private final Integer getInteger(NamedList<Object> response, String... args) {
    Object objectItem = response.findRecursive(args);
    if (objectItem != null && objectItem instanceof Integer) {
      return (Integer) objectItem;
    } else {
      return null;
    }
  }
1286322
public double get(long i) {
        if (i < 0 || i >= idxAfterLast) {
            return missingEntries;
        }
        return elements[SafeCast.safeLongToInt(i)];
    }
1087853
public int get(long idx) {
        if (idx < 0 || idx >= size) {
            return 0;
        }
        return elements[SafeCast.safeLongToInt(idx + start)];
    }