Returns the type of file at <i>$row</i> position, like <i>filetype</i>.

@param int $row
@param int $column
@return null|string
432160
public function type(int $row, int $column)
    {
        $file = $this->getData($row, $column);

        if ($file == null) {
            return null;
        }

        $file = rtrim($file, DIRECTORY_SEPARATOR);
        $file = $this->rootPath . DIRECTORY_SEPARATOR . $file;

        $fileType = filetype($file);

        if ($fileType != 'file') {
            return $fileType;
        }

        return mime_content_type($file);
    }
968199
function get( $row, $col )
    {
        $pos = $row * $this->Cols + $col;
        $pos = base_convert( $pos, 10, 36 );
        return isset( $this->Matrix["*$pos"] ) ? $this->Matrix["*$pos"] : 0;
    }
2111
public static function string( $str, $row = null, $col = null ) {
		if( $col !== null || $row !== null ) {
			Cursor::rowcol($row, $col);
		}
		fwrite(self::$stream, $str);
	}
306645
public function isEmpty($col, $row)
    {
        $this->checkCoords($col, $row);

        return self::NONE === $this->get($col, $row);
    }
296088
public function info($row, $col, $type = '', $sheet = 0)
    {
        $col = $this->getCol($col);
        if (array_key_exists('cellsInfo', $this->sheets[$sheet])
            && array_key_exists($row, $this->sheets[$sheet]['cellsInfo'])
            && array_key_exists($col, $this->sheets[$sheet]['cellsInfo'][$row])
            && array_key_exists($type, $this->sheets[$sheet]['cellsInfo'][$row][$col])) {
            return $this->sheets[$sheet]['cellsInfo'][$row][$col][$type];
        }
        return "";
    }
575781
public <T> T get(int row, int col, DataType dataType)
	{
		List<String> rowList = row(row);
		
		if(rowList == null || rowList.isEmpty() || col >= rowList.size())
			return nullFor(dataType);
		
	
		String cell = rowList.get(col);
		
		
		
		T results = toType(cell,dataType);
		return results;
	}
931838
protected function field($row, $column)
    {
        return is_object($row) && !$row instanceof \ArrayAccess ? $row->$column : $row[$column];
    }
274257
public function isEmpty(int $row, int $column)
    {
        $this->assertIndexesAreValid($row, $column);
        return $this->get($row, $column) === null;
    }
77691
private function getObjectResult(array $columns, array $row)
    {
        $obj = new \stdClass();
        foreach ($columns as $key => $column) {
            $obj->{$column} = $row[$key];
        }

        return $obj;
    }
384524
public function getAlt($row)
    {
        $altField = $this->getData('config/altField') ?: self::ALT_FIELD;
        return isset($row[$altField]) ? $row[$altField] : null;
    }
1101693
public function getConfirm(Row $row)
	{
		if (!$this->confirm) {
			return null;
		}

		$question = $this->confirm[0];

		if (is_string($question)) {
			$question = $this->translate($question);
		} else {
			/**
			 * If user callback was used for setting action confirmation dialog, it has to return string
			 */
			$question = $this->getPropertyStringOrCallableGetString($row, $question, 'confirmation dialog');
		}

		if (!$this->confirm[1]) {
			return $question;
		}

		return str_replace('%s', $row->getValue($this->confirm[1]), $question);
	}
496036
public function getHighestRow($column = null)
    {
        if ($column == null) {
            return $this->_cachedHighestRow;
        }
        return $this->getHighestDataRow($column);
    }
782072
public Object get(int row, @NotNull String column) {
        return rows.get(row).get(column);
    }
1020795
public function getCellPrototype($row = NULL)
    {
        $td = parent::getCellPrototype($row);

        if ($this->isEditable() && $row !== NULL) {
            if (!in_array('editable', $td->class)) {
                $td->class[] = 'editable';
            }

            $value = $this->editableValueCallback === NULL
                ? $this->getValue($row)
                : call_user_func_array($this->editableValueCallback, [$row, $this]);

            $td->setAttribute('data-grido-editable-value', $value);
        }

        return $td;
    }
560752
public function getColumnFromRow($row, Table $table)
    {
        $name = $row['Field'];
        $is_nullable = ($row['Null'] == 'YES');
        $autoincrement = (strpos($row['Extra'], 'auto_increment') !== false);
        $size = null;
        $precision = null;
        $scale = null;
        $sqlType = false;
        $desc = $row['Comment'];

        $regexp = '/^
            (\w+)        # column type [1]
            [\(]         # (
                ?([\d,]*)  # size or size, precision [2]
            [\)]         # )
            ?\s*         # whitespace
            (\w*)        # extra description (UNSIGNED, CHARACTER SET, ...) [3]
        $/x';
        if (preg_match($regexp, $row['Type'], $matches)) {
            $nativeType = $matches[1];
            if ($matches[2]) {
                if (($cpos = strpos($matches[2], ',')) !== false) {
                    $size = (int) substr($matches[2], 0, $cpos);
                    $precision = $size;
                    $scale = (int) substr($matches[2], $cpos + 1);
                } else {
                    $size = (int) $matches[2];
                }
            }
            if ($matches[3]) {
                $sqlType = $row['Type'];
            }
            foreach (self::$defaultTypeSizes as $type => $defaultSize) {
                if ($nativeType == $type && $size == $defaultSize && $scale === null) {
                    $size = null;
                    continue;
                }
            }
        } elseif (preg_match('/^(\w+)\(/', $row['Type'], $matches)) {
            $nativeType = $matches[1];
            if ($nativeType == 'enum') {
                $sqlType = $row['Type'];
            }
        } else {
            $nativeType = $row['Type'];
        }

        //BLOBs can't have any default values in MySQL
        $default = preg_match('~blob|text~', $nativeType) ? null : $row['Default'];

        $propelType = $this->getMappedPropelType($nativeType);
        if (!$propelType) {
            $propelType = Column::DEFAULT_TYPE;
            $sqlType = $row['Type'];
            $this->warn("Column [" . $table->getName() . "." . $name . "] has a column type (" . $nativeType . ") that Propel does not support.");
        }

        // Special case for TINYINT(1) which is a BOOLEAN
        if (PropelTypes::TINYINT === $propelType && 1 === $size) {
            $propelType = PropelTypes::BOOLEAN;
        }

        $column = new Column($name);
        $column->setTable($table);
        $column->setDomainForType($propelType);
        if ($sqlType) {
            $column->getDomain()->replaceSqlType($sqlType);
        }
        $column->getDomain()->replaceSize($size);
        $column->getDomain()->replaceScale($scale);
        if ($default !== null) {
            if ($propelType == PropelTypes::BOOLEAN) {
                if ($default == '1') {
                    $default = 'true';
                }
                if ($default == '0') {
                    $default = 'false';
                }
            }
            if (in_array($default, array('CURRENT_TIMESTAMP'))) {
                $type = ColumnDefaultValue::TYPE_EXPR;
            } else {
                $type = ColumnDefaultValue::TYPE_VALUE;
            }
            $column->getDomain()->setDefaultValue(new ColumnDefaultValue($default, $type));
        }
        $column->setAutoIncrement($autoincrement);
        $column->setNotNull(!$is_nullable);

        if ($this->addVendorInfo) {
            $vi = $this->getNewVendorInfoObject($row);
            $column->addVendorInfo($vi);
        }

        if ($desc){
            if(!$this->isUtf8($desc))
                $desc = utf8_encode($desc);
            $column->setDescription($desc);
        }

        return $column;
    }
393149
public function readCell($column, $row, $worksheetName = '')
    {
        //  Only read the heading row, and the rows that are configured in $this->_startRow and $this->_endRow
        return ($worksheetName === $this->worksheetName || $worksheetName === '')
            && ($row === $this->headingRow || ($row >= $this->startRow && $row < $this->endRow));
    }
342440
protected function getColumnStructure($row, $column_key)
    {
        // Check if method exists i.e colSetID
        $key_col_method = Str::camel('col_set_' . $column_key);

        if (method_exists($this, $key_col_method))
        {
            ob_start();
            $this->{$key_col_method}($row);
            return ob_get_clean();
        }

        return e($row->{$column_key});
    }