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

@return row position modification map. Includes only modified row numbers
548845
@SuppressWarnings("unchecked")
    public Map<Integer, Integer> getLinkedAdapterRowsModifications() {
        return mAdapter instanceof LinkedAdaptiveTableAdapterImpl ?
                ((LinkedAdaptiveTableAdapterImpl) mAdapter).getRowsModifications() :
                Collections.<Integer, Integer>emptyMap();
    }
553706
public JTransfo get() {
        ConfigurableJTransfo jTransfo = JTransfoFactory.get();
        if (null != typeConverters) {
            jTransfo.getTypeConverters().addAll(typeConverters);
            jTransfo.updateTypeConverters();
        }

        if (null != objectFinders) {
            jTransfo.getObjectFinders().addAll(objectFinders);
            jTransfo.updateObjectFinders();
        }

        if (null != convertInterceptors) {
            Collections.sort(convertInterceptors, new AnnotationAwareOrderComparator());
            jTransfo.getConvertInterceptors().addAll(convertInterceptors);
            jTransfo.updateConvertInterceptors();
        }

        if (null != objectReplacers) {
            List<ObjectReplacer> orderedInterceptors = new ArrayList<>();
            for (ObjectReplacer objectClassDeterminator : objectReplacers) {
                orderedInterceptors.add(objectClassDeterminator);
            }
            Collections.sort(orderedInterceptors, new AnnotationAwareOrderComparator());
            jTransfo.getObjectReplacers().addAll(orderedInterceptors);
            jTransfo.updateObjectReplacers();
        }
        return jTransfo;
    }
958214
public Iterator<InternalRow> rowIterator() {
    final int maxRows = numRows;
    final MutableColumnarRow row = new MutableColumnarRow(columns);
    return new Iterator<InternalRow>() {
      int rowId = 0;

      @Override
      public boolean hasNext() {
        return rowId < maxRows;
      }

      @Override
      public InternalRow next() {
        if (rowId >= maxRows) {
          throw new NoSuchElementException();
        }
        row.rowId = rowId++;
        return row;
      }

      @Override
      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }
457893
public IntegerDataStore getPositions() {
    if(positions != null) {
      return positions; // Return cached.
    }
    final ArrayDBIDs order = topologicalSort();
    WritableIntegerDataStore siz = computeSubtreeSizes(order);
    WritableIntegerDataStore pos = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_DB, -1);
    WritableIntegerDataStore ins = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, -1);

    int defins = 0; // Next root insertion position.
    DBIDVar v1 = DBIDUtil.newVar();
    // Place elements based on their successor
    for(DBIDArrayIter it = order.iter().seek(order.size() - 1); it.valid(); it.retract()) {
      final int size = siz.intValue(it);
      parent.assignVar(it, v1); // v1 = parent
      final int ipos = ins.intValue(v1); // Position of parent
      if(ipos < 0 || DBIDUtil.equal(it, v1)) {
        // Root: use interval [defins; defins + size]
        ins.putInt(it, defins);
        pos.putInt(it, defins + size - 1);
        defins += size;
        continue;
      }
      // Insertion position of parent = leftmost
      pos.putInt(it, ipos + size - 1);
      ins.putInt(it, ipos);
      ins.increment(v1, size);
    }
    siz.destroy();
    ins.destroy();
    return positions = pos;
  }
1023980
public int getRow() {
        if(_currentRow != null) {
            int row = _currentRow.intValue();

            /* if the row is out of range, simply adjust to the last row */
            if(_dataSetSize != null && (row > _dataSetSize.intValue()))
                row = _dataSetSize.intValue();

            if(row % getPageSize() != 0) {
                int adjustedPage = row - (row % getPageSize());
                return adjustedPage;
            }
            else return row;
        }
        else return DEFAULT_ROW;
    }
501179
public RowMutation adapt(org.apache.hadoop.hbase.client.Mutation mutation) {
    RowMutation rowMutation = newRowMutationModel(mutation.getRow());
    adapt(mutation, rowMutation);
    return rowMutation;
  }
1198141
public Map<K, V> getMap() {
        if (mode == StorageMode.LIST) {
            synchronized (this) {
                if (mode == StorageMode.LIST) {
                    mapData = convertListToMap(listData);
                    mode = StorageMode.BOTH;
                }
            }
        }
        return Collections.unmodifiableMap(mapData);
    }
239947
public int changedRowCount () {
    if ( getChangedRowCount == null ) {
      try {  // JNA/J2SE compatibility method.
        getChangedRowCount = sqliteDatabase.getClass().getMethod("changedRowCount", (Class<?>[])null);
      } catch ( Exception any ) {
        try {
          // Android
          getChangedRowCount = sqliteDatabase.getClass().getDeclaredMethod("lastChangeCount", (Class<?>[])null);
          getChangedRowCount.setAccessible(true);
        } catch (Exception e) {
          // ignore
        } 
      }
    }
    if ( getChangedRowCount != null ) {
      try {
        return ((Integer)getChangedRowCount.invoke(sqliteDatabase, (Object[])null)).intValue();
      } catch (Exception e) {
        // ignore
      } 
    }
    return 1;  // assume that the insert/update succeeded in changing exactly one row (terrible assumption, but I have nothing better).
  }
1085876
public List<ChildData> getCurrentData()
    {
        return ImmutableList.copyOf(Sets.<ChildData>newTreeSet(currentData.values()));
    }
1146624
public IMatrix transpose() {
        IMatrix result = new IMatrix(rows, columns);
        transpose(result);
        return result;
    }
309672
public List<Row> getRowsCopy()
    {
        final List<Row> rows = new ArrayList<>(this.getRowsCount());

        for (Row cells : this)
        {
            rows.add(cells);
        }

        return rows;
    }
344463
public java.util.List<AccountModification> getAccountModifications() {
        if (accountModifications == null) {
            accountModifications = new com.amazonaws.internal.SdkInternalList<AccountModification>();
        }
        return accountModifications;
    }
160778
public function getAffectedRowData()
    {
        $data = array();

        $description = $this->getEntityDescription();

        switch ($this->getEntityState()) {
            case AnDomain::STATE_NEW :
                //get all the serializable property/value pairs
                foreach ($description->getProperty() as $name => $property) {
                    if ($property instanceof AnDomainPropertySerializable) {
                        $data[$name] = $name;
                    }
                }
                //@TODO why are we forcing to unset the property
                //unset($data[$description->getIdentityProperty()->getName()]);
                break;
            case AnDomain::STATE_MODIFIED :
                //get all the updated serializable property/value pairs
                $data = array_keys($this->_modified);
                break;
            case  AnDomain::STATE_DELETED :
                break;
            default :
                return $data;
        }

        $tmp = array();

        foreach ($data as $name) {
            $value = $this->get($name);
            $property = $description->getProperty($name);
            $tmp = array_merge($tmp, $property->serialize($value));
        }

        $data = $tmp;

        if ($description->getInheritanceColumn() && $this->getEntityState() == AnDomain::STATE_NEW) {
            $data[(string) $description->getInheritanceColumn()] = (string) $description->getInheritanceColumnValue();
        }

        return $data;
    }
210184
public Map<URI, URI> getChangeTable() {
        for (final Map.Entry<URI, URI> e : changeTable.entrySet()) {
            assert e.getKey().isAbsolute();
            assert e.getValue().isAbsolute();
        }
        return Collections.unmodifiableMap(changeTable);
    }
360441
public Map<String, String> getSortedMap()
    {
        ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder();
        for ( FieldValue fv : fieldValues )
        {
            builder.put(fv.getField(), fv.getValue());
        }

        return builder.build();
    }
1155767
public List<UIContext> getRowContexts() {
		List<?> beanList = this.getBeanList();
		List<UIContext> contexts = new ArrayList<>(beanList.size());

		for (int i = 0; i < beanList.size(); i++) {
			Object rowData = beanList.get(i);
			contexts.add(this.getRowContext(rowData, i));
		}

		return Collections.unmodifiableList(contexts);
	}
999498
public ArrayList<String> getDataRows() {
		ArrayList<String> rows = new ArrayList<String>();
		for (String row : rowLookup.keySet()) {
			if (this.isMetaDataRow(row)) {
				continue;
			}
			HeaderInfo hi = rowLookup.get(row);
			if (!hi.isHide()) {
				rows.add(row);
			}
		}
		return rows;
	}