Returns file information.

@param int $index index of file
@return stdClass|bool info object or false if error
770758
public function get_info($index) {
        if (!isset($this->za)) {
            return false;
        }

        // Need to use the ZipArchive's numfiles, as $this->count() relies on this function to count actual files (skipping OSX junk).
        if ($index < 0 or $index >=$this->za->numFiles) {
            return false;
        }

        // PHP 5.6 introduced encoding guessing logic, we need to fall back
        // to raw ZIP_FL_ENC_RAW (== 64) to get consistent results as in PHP 5.5.
        $result = $this->za->statIndex($index, 64);

        if ($result === false) {
            return false;
        }

        $info = new stdClass();
        $info->index             = $index;
        $info->original_pathname = $result['name'];
        $info->pathname          = $this->unmangle_pathname($result['name']);
        $info->mtime             = (int)$result['mtime'];

        if ($info->pathname[strlen($info->pathname)-1] === '/') {
            $info->is_directory = true;
            $info->size         = 0;
        } else {
            $info->is_directory = false;
            $info->size         = (int)$result['size'];
        }

        if ($this->is_system_file($info)) {
            // Don't return system files.
            return false;
        }

        return $info;
    }
854755
public function offsetGet($index)
    {
        if (parent::offsetExists($index)) {
            return parent::offsetGet($index);
        }
        if (isset(self::$global[$index])) {
            return self::$global[$index];
        }

        return null;
    }
481660
public function get(int $index)
    {
        $this->internalDataListUpdate();
        if (isset($this->internalDataListData[$index])) {
            return $this->internalDataListUpdateValueIfNeeded($this->internalDataListData, $index);
        }
        return null;
    }
31895
public function Item( $index )
	{
		if ( $this->getCount() <= $index && ! $this->_done )
		{
			$count = $this->getCount();
			while ( ! $this->_done && ( $count <= $index))
			{
				if ( $this->_iter->MoveNext() )
				{
					/**
					 * @var XmlNode $node
					 */
					$node = $this->GetNode( $this->_iter->getCurrent() );
					if ( ! is_null( $node ) )
					{
						$this->_list[] = $node;
						$count++;
					}
				}
				else
					$this->_done = true;
			}
		}
		if ( $index >= 0 && count( $this->_list ) > $index )
			return $this->_list[ $index ];
		return null;
	}
116248
public function get(?string $index = null, $xss_clean = false)
    {
        if ($index === null && \count($_GET) > 0) {
            $get = [];

            // Loop through the full $_GET array.
            foreach (array_keys($_GET) as $key) {
                $get[$key] = $this->fetchFromArray($_GET, $key, $xss_clean);
            }

            return $get;
        }

        return $this->fetchFromArray($_GET, $index, $xss_clean);
    }
124751
public function get($index = 0)
        {
            if (is_integer($index)) {
                if ($index + 1 > $this->count()) {
                    return null;
                } else {
                    return Arrays::first(array_slice($this->_items, $index, 1));
                }
            } else {
                if ($this->has($index)) {
                    return $this->_items[$index];
                }
            }

            return null;
        }
537976
public function getLog($index = null)
    {
        if (is_null($index)) {
            return $this->log;
        }

        return $this->log[$index];
    }
1189048
public static function detect($index = 0)
    {
        $context = new Context();
        $backtrace = debug_backtrace();
        $position = $backtrace[$index];
        if (isset($position['file'])) {
            $context->filename = $position['file'];
        }
        if (isset($position['line'])) {
            $context->line = $position['line'];
        }
        $caller = isset($backtrace[$index + 1]) ? $backtrace[$index + 1] : null;
        if (isset($caller['function'])) {
            $context->method = $caller['function'];
            if (isset($caller['type']) && $caller['type'] === '::') {
                $context->static = true;
            }
        }
        if (isset($caller['class'])) {
            $fqn = explode('\\', $caller['class']);
            $context->class = array_pop($fqn);
            if (count($fqn)) {
                $context->namespace = implode('\\', $fqn);
            }
        }

        // @todo extract namespaces and use statements
        return $context;
    }
83196
public function getParamClean($index){
        if(isset($this->params[$index])){
            return $this->params[$index];
        }else{
            return NULL;
        }
    }
180538
public function get(int $index): string
    {
        return $this->handle->lIndex($this->name, $index);
    }
795316
public function getParameter($index) {
        $parameter = null;
        if ($this->hasParameter($index)) {
            $parameter = $this->_parameters[$index];
        }
        return $parameter;
    }
1334942
public function getValidFiles($index = null)
	{
		// prepare the selection
		if (is_numeric($index))
		{
			$selection = $this->container;
		}
		else
		{
			$selection = (func_num_args() and ! is_null($index)) ? $this[$index] : $this->container;
		}

		// storage for the results
		$results = array();

		if ($selection)
		{
			// make sure selection is an array
			is_array($selection) or $selection = array($selection);

			// loop through all files
			foreach ($selection as $file)
			{
				// store only files that are valid
				$file->isValid() and $results[] = $file;
			}
		}

		// return the results
		if (is_numeric($index))
		{
			// a specific valid file was requested
			return isset($results[$index]) ? array($results[$index]) : array();
		}
		else
		{
			return $results;
		}
	}
705147
public function readArray($index) {
        return isset ($_SESSION [$index]) && is_array($_SESSION [$index]) ? $_SESSION [$index] : [];
    }
846302
public function get_sent( $index = 0 ) {
		$retval = false;
		if ( isset( $this->mock_sent[ $index ] ) ) {
			$retval = (object) $this->mock_sent[ $index ];
		}
		return $retval;
	}
806941
public function get($index)
    {
        if($index > $this->count() || $index <= 0) {
            return null;
        }
        
        $this->rewind();
        while(($index - 1) > 0) {
            $this->next();
            $index = $index - 1;
        }
        
        return $this->current();
        
    }
1159828
public function get($index)
	{
		return array_slice($this->items, $index * $this->itemsPerPage, $this->itemsPerPage);
	}
1129073
public static function get_files($index = null)
	{
		// convert element name formats
		is_string($index) and $index = str_replace(':', '.', $index);

		$files = static::$upload->getValidFiles($index);

		// convert the file object to 1.x compatible data
		$result = array();

		foreach ($files as $file)
		{
			$data = array();
			foreach ($file as $item => $value)
			{
				$item == 'element' and $item = 'field';
				$item == 'tmp_name' and $item = 'file';
				$item == 'filename' and $item = 'saved_as';
				$item == 'path' and $item = 'saved_to';
				$data[$item] = $value;
			}
			$data['field'] = str_replace('.', ':', $data['field']);
			$data['error'] = ! $file->isValid();
			$data['errors'] = array();
			$result[] = $data;
		}

		// compatibility with < 1.5, return the single entry if only one was found
		if (func_num_args() and count($result) == 1)
		{
			return reset($result);
		}
		else
		{
			return $result;
		}
	}