Convert the column value
 @param [String, Symbol] column the CSV header column value
 @param [Integer] index the CSV header column index
 @return [Symbol] the converted column
557809
def convert_column(column, index)
      value = if converter_arity == 1
                @converter.call(column)
              else
                @converter.call(column, index)
              end
      value.to_sym
    end
648778
def cell_to_rowcol(cell)       #:nodoc:
    cell =~ /\$?([A-I]?[A-Z])\$?(\d+)/
    col     = $1
    row     = $2.to_i

    col = chars_to_col($1.split(//))

    # Convert 1-index to zero-index
    row -= 1
    col -= 1

    [row, col]
  end
51103
def extra_value(index, convert = false)
      return nil if index < 1 || index > 5
      val = send "extra_#{index}_value"
      if convert
        case extra_type(index)
          when 'boolean'
            BarkestCore::BooleanParser.parse_for_boolean_column(val)
          when 'integer'
            BarkestCore::NumberParser.parse_for_int_column(val)
          when 'float'
            BarkestCore::NumberParser.parse_for_float_column(val)
          else
            val.to_s
        end
      end
    end
500494
function Column (table, header, i) {
  this._table = table, this._header = header, this._i = i
}
1274699
public String get(int columnIndex) throws IOException {
		checkClosed();

		if (columnIndex > -1 && columnIndex < columnsCount) {
			return values[columnIndex];
		} else {
			return "";
		}
	}
646010
def get_value(self, spec, row):
        
        column = spec.get('column')
        default = spec.get('default')
        if column is None:
            if default is not None:
                return self.convert_type(default, spec)
            return
        value = row.get(column)
        if is_empty(value):
            if default is not None:
                return self.convert_type(default, spec)
            return None
        return self.convert_type(value, spec)
991084
def convert_value_to_text r, count
      if r == :separator
        return separator
      elsif r == :columns
        return "??" unless @columns # column was requested but not supplied
        # FIXME putting entire header into this, take care of hidden
        r = []
        @columns.each_with_index { |e, i| r << e unless get_column(i).hidden  }
        return @headerfmtstr % r if @numbering
      end
      str = ""

      if @numbering
        #r = r.dup
        #r.insert 0, count+1
        # TODO get the width
        str << "%*d |"%  [2, count + 1]
      end
      # unroll r, get width and align
      # This is to truncate column to requested width
      fmta = []
      r.each_with_index { |e, i| 
        next if get_column(i).hidden == true
        #w = @pw[i] || @cw[i]  # XXX
        #$log.debug "WIDTH XXX  #{i} w= #{w} , #{@pw[i]}, #{@cw[i]} :: #{e} " if $log.debug? 
        w = @cw[i]
        l = e.to_s.length
        fmt = "%-#{w}s "
        # if value is longer than width, then truncate it
        if l > w
          fmt = "%.#{w}s "
        else
          # ack we don;t need to recalc this we can pull out of hash FIXME
          case @calign[i]
          when :right
            fmt = "%#{w}s "
          else
            fmt = "%-#{w}s "
          end
        end
        str << fmt % e
        fmta << fmt
      }
      #fmstr = fmta.join(@y)
      #return fmstr % r; # FIXME hidden column still goes int 
      return str
    end
921808
private function getColumnByIndex(array $columns, int $index):? Column
    {
        $currentIndex = $index;

        if (!array_key_exists($currentIndex, $columns) && $currentIndex > 0) {
            $currentIndex = ($currentIndex % count($columns));
        }

        if (array_key_exists($currentIndex, $columns)) {
            return $columns[$currentIndex];
        }

        return null;
    }
621698
public int columnIndex(Column<?> column) {
        int columnIndex = -1;
        for (int i = 0; i < columnList.size(); i++) {
            if (columnList.get(i).equals(column)) {
                columnIndex = i;
                break;
            }
        }
        if (columnIndex == -1) {
            throw new IllegalArgumentException(
                    String.format("Column %s is not present in table %s", column.name(), name));
        }
        return columnIndex;
    }
701416
public String convertIndexToString(int index)
    {
        String[][] rgstring = this.getPopupMap();
        if (index >= rgstring.length)
            index = 0;
        return rgstring[index][0];
    }
1008875
protected function renderColumn($column, $index)
    {
        if (is_string($this->template)) {
            return strtr($this->template, [
                '{label}' => $column->renderHeaderCell(),
                '{value}' => $column->renderDataCell($this->model, $this->model->getPrimaryKey(), 0),
            ]);
        }

        return call_user_func($this->template, $column, $index, $this);
    }
381401
def convert(value)
      case value
      when java.util.List then value.to_a
      when java.util.Set then value.to_set
      when java.util.Map then value.to_hash
      else value
      end
    end
117739
def [](arg)
      case
      when arg.is_a?(Range)
        index = @index.select{|i| arg.include?(i)}
        Mikon::DataFrame.new(index.map{|i| self.row(i)}, {index: index})

      when arg.is_a?(Symbol)
        self.column(arg)
      end
    end
923844
public Table insertColumn(int index, Column<?> column) {
        validateColumn(column);
        columnList.add(index, column);
        return this;
    }
115777
def _convert_index_to_printable_row index=@current_index
      r,c = rowcol
      pos = _convert_index_to_visible_row(index)
      return nil unless pos
      pos = r + pos
      return pos
    end
1158389
def get_cell(self, index, column):
        
        i = sorted_index(self._index, index) if self._sort else self._index.index(index)
        c = self._columns.index(column)
        return self._data[c][i]
1371535
def column(x)
      assert_x!(x)
      (0...height).inject([]) { |pixels, y| pixels << get_pixel(x, y) }
    end