When used adapter with IMMUTABLE data, returns columns position modifications
(old position -> new position)

@return row position modification map. Includes only modified column numbers
6463
@SuppressWarnings("unchecked")
    public Map<Integer, Integer> getLinkedAdapterColumnsModifications() {
        return mAdapter instanceof LinkedAdaptiveTableAdapterImpl ?
                ((LinkedAdaptiveTableAdapterImpl) mAdapter).getColumnsModifications() :
                Collections.<Integer, Integer>emptyMap();
    }
983682
public Object mapRowToReturnType() {

        Object resultObject = null;

        // if the ResultSet only contains a single column we may be able to map directly
        // to the return type -- if so we don't need to build any structures to support
        // mapping
        if (_columnCount == 1) {

            final int typeId = _tmf.getTypeId(_returnTypeClass);

            try {
                if (typeId != TypeMappingsFactory.TYPE_UNKNOWN) {
                    return extractColumnValue(1, typeId);
                } else {
                    // we still might want a single value (i.e. java.util.Date)
                    Object val = extractColumnValue(1, typeId);
                    if (_returnTypeClass.isAssignableFrom(val.getClass())) {
                        return val;
                    }
                }
            } catch (SQLException e) {
                throw new ControlException(e.getMessage(), e);
            }
        }

        if (_fields == null) {
            try {
                getFieldMappings();
            } catch (SQLException e) {
                throw new ControlException(e.getMessage(), e);
            }
        }

        try {
            resultObject = _returnTypeClass.newInstance();
        } catch (InstantiationException e) {
            throw new ControlException("InstantiationException when trying to create instance of : "
                                       + _returnTypeClass.getName(), e);
        } catch (IllegalAccessException e) {
            throw new ControlException("IllegalAccessException when trying to create instance of : "
                                       + _returnTypeClass.getName(), e);
        }

        for (int i = 1; i < _fields.length; i++) {
            AccessibleObject f = _fields[i];
            Object resultValue = null;

            try {
                resultValue = extractColumnValue(i, _fieldTypes[i]);
                if (f instanceof Field) {
                    ((Field) f).set(resultObject, resultValue);
                } else {
                    _args[0] = resultValue;
                    ((Method) f).invoke(resultObject, _args);
                }
            } catch (SQLException e) {
                throw new ControlException(e.getMessage(), e);
            } catch (IllegalArgumentException iae) {

                try {
                    ResultSetMetaData md = _resultSet.getMetaData();
                    if (f instanceof Field) {
                        throw new ControlException("The declared Java type for field " + ((Field) f).getName()
                                                   + ((Field) f).getType().toString()
                                                   + " is incompatible with the SQL format of column " + md.getColumnName(i).toString()
                                                   + md.getColumnTypeName(i).toString()
                                                   + " which returns objects of type " + resultValue.getClass().getName());
                    } else {
                        throw new ControlException("The declared Java type for method " + ((Method) f).getName()
                                                   + ((Method) f).getParameterTypes()[0].toString()
                                                   + " is incompatible with the SQL format of column " + md.getColumnName(i).toString()
                                                   + md.getColumnTypeName(i).toString()
                                                   + " which returns objects of type " + resultValue.getClass().getName());
                    }
                } catch (SQLException e) {
                    throw new ControlException(e.getMessage(), e);
                }

            } catch (IllegalAccessException e) {
                if (f instanceof Field) {
                    throw new ControlException("IllegalAccessException when trying to access field " + ((Field) f).getName(), e);
                } else {
                    throw new ControlException("IllegalAccessException when trying to access method " + ((Method) f).getName(), e);
                }
            } catch (InvocationTargetException e) {
                if (f instanceof Field) {
                    throw new ControlException("InvocationTargetException when trying to access field " + ((Field) f).getName(), e);
                } else {
                    throw new ControlException("InvocationTargetException when trying to access method " + ((Method) f).getName(), e);
                }
            }
        }
        return resultObject;
    }
1349812
public Map<String, List<String>> getRowDeletesMap() {
        Map<String, List<String>> storeMap = new HashMap<>();
        for(RowDelete mutation: getRowDeletes()) {
            String storeName = mutation.getStoreName();
            String rowKey = mutation.getRowKey();
            List<String> rowList = storeMap.get(storeName);
            if(rowList == null) {
                rowList = new ArrayList<>();
                storeMap.put(storeName, rowList);
            }
            rowList.add(rowKey);
        }
        return storeMap;
    }
450174
public Map<String, Integer> buildIndex() {
        Map<String, Integer> index = new HashMap<String, Integer>();
        for (int i = 0; i < columns.length; ++i) {
            index.put(columns[i], i);
        }
        return index;
    }
433375
public TableLayoutBuilder row() {
        ++currentRow;
        lastCC = null;
        maxColumns = Math.max(maxColumns, currentCol);
        currentCol = 0;
        return this;
    }
31665
@Pure
	public List<Object> getAddedValues() {
		if (this.newValues == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableList(this.newValues);
	}
863978
public java.util.List<? extends com.google.privacy.dlp.v2.Table.RowOrBuilder>
      getRowsOrBuilderList() {
    return rows_;
  }
1334864
public int[] getRow(int rowIndex) {
        if (isCompacted) {
            throw new IllegalStateException(
                    "Illegal Invocation of the method after compact()");
        }
        if (rowIndex < 0 || rowIndex > rows) {
            throw new IllegalArgumentException("rowIndex out of bound!");
        }
        int[] rowToReturn = new int[columns - 2];
        System.arraycopy(v, rowIndex * columns + 2, rowToReturn, 0,
                         columns - 2);
        return rowToReturn;
    }
78325
public Map<String, IndexInformation> getIndexInformation() {
        ImmutableMap.Builder<String, IndexInformation> copy = ImmutableMap.builder();
        copy.putAll(indexes);
        return copy.build();
    }
1333634
public ArrayList<String> getColumns() {
		ArrayList<String> columns = new ArrayList<String>();
		for (String col : columnLookup.keySet()) {
			HeaderInfo hi = columnLookup.get(col);
			if (!hi.isHide()) {
				columns.add(col);
			}
		}
		return columns;
	}
395850
public Map<String, ColumnMetadata> getColumnMetadata() {
        if(columnMetadata == null || columnMetadata.isEmpty()) throw new InitException("Failed to find table: " + getTableName());
        return Collections.unmodifiableMap(columnMetadata);
    }
129093
public ArrayList<String> getRows() {
		ArrayList<String> rows = new ArrayList<String>();
		for (String row : rowLookup.keySet()) {
			HeaderInfo hi = rowLookup.get(row);
			if (!hi.isHide()) {
				rows.add(row);
			}
		}
		return rows;
	}
640255
public Map<String, Map<String, List<DColumn>>> getColumnUpdatesMap() {
        Map<String, Map<String, List<DColumn>>> storeMap = new HashMap<>();
        for(ColumnUpdate mutation: getColumnUpdates()) {
            String storeName = mutation.getStoreName();
            String rowKey = mutation.getRowKey();
            DColumn column = mutation.getColumn();
            Map<String, List<DColumn>> rowMap = storeMap.get(storeName);
            if(rowMap == null) {
                rowMap = new HashMap<>();
                storeMap.put(storeName, rowMap);
            }
            List<DColumn> columnsList = rowMap.get(rowKey);
            if(columnsList == null) {
                columnsList = new ArrayList<>();
                rowMap.put(rowKey, columnsList);
            }
            columnsList.add(column);
        }
        return storeMap;
    }
1255276
function() {
            var oldRow = api.getParentElement(this.cell, { nodeName: ["TR"] });
            if (oldRow) {
                this.setTableMap();
                this.idx = this.getMapIndex(this.cell);
                if (this.idx !== false) {
                    var modRow = this.map[this.idx.row];
                    for (var cidx = 0, cmax = modRow.length; cidx < cmax; cidx++) {
                        if (!modRow[cidx].modified) {
                            this.setCellAsModified(modRow[cidx]);
                            this.removeRowCell(modRow[cidx]);
                        }
                    }
                }
                removeElement(oldRow);
            }
        }
107514
public boolean[] getModified()
    {
        int iFieldCount = this.getFieldCount();  // BaseField Count
        boolean[] rgbModified = new boolean[iFieldCount];
        for (int iFieldSeq = DBConstants.MAIN_FIELD; iFieldSeq < iFieldCount + DBConstants.MAIN_FIELD; iFieldSeq++)
        {
            BaseField field = this.getField(iFieldSeq);
            rgbModified[iFieldSeq] = field.isModified();
        }
        return rgbModified;
    }
720045
public Map<K, V> getMutableMap() {
        if (mode != StorageMode.MAP) {
            if (mode == StorageMode.LIST) {
                mapData = convertListToMap(listData);
            }
            listData = null;
            mode = StorageMode.MAP;
        }
        return mapData;
    }
968312
public Map<String, String> getFieldMap() {
		if (headerMap == null) {
			throw new IllegalStateException("No header available");
		}

		final Map<String, String> fieldMap = new LinkedHashMap<>(headerMap.size());
		String key;
		Integer col;
		String val;
		for (final Map.Entry<String, Integer> header : headerMap.entrySet()) {
			key = header.getKey();
			col = headerMap.get(key);
			val = null == col ? null : get(col);
			fieldMap.put(key, val);
		}

		return fieldMap;
	}