Updates this bean with data from another instance.<p>

@param updateRow the bean which the data should be updated from
336064
public void update(CmsAliasTableRow updateRow) {

        m_aliasError = updateRow.m_aliasError;
        m_aliasPath = updateRow.m_aliasPath;
        m_mode = updateRow.m_mode;
        m_pathError = updateRow.m_pathError;
        m_resourcePath = updateRow.m_resourcePath;
        m_structureId = updateRow.m_structureId;
        m_isEdited = updateRow.m_isEdited;
        m_originalStructureId = updateRow.m_originalStructureId;
    }
1101459
public void newRow(ByteBuffer key) throws IOException
    {
        if (currentKey != null && !columnFamily.isEmpty())
            writeRow(currentKey, columnFamily);

        currentKey = DatabaseDescriptor.getPartitioner().decorateKey(key);
        columnFamily = getColumnFamily();
    }
422648
public void setRow(int row, DoubleVector data) {
        checkIndices(row, data.length() -1);

        if (cols <= data.length())
            cols = data.length();

        Vectors.copy(updateRow(row), data);
    }
566692
@Override
    public void setRowId(int parameterIndex, RowId x) throws SQLException
    {
        checkParameterBounds(parameterIndex);
        throw SQLError.noSupport();
    }
325805
@Override
	public void tableChanged(TableModelEvent e) {
		int rows = ((TableModel) e.getSource()).getRowCount();
		updateStatus(rows);
	}
150811
public void setEditedData(List<CmsAliasTableRow> data) {

        m_editedData = new ArrayList<CmsAliasTableRow>();
        m_editedData.addAll(data);
    }
180056
public void updateIndex() {

        CmsRpcAction<Void> action = new CmsRpcAction<Void>() {

            @Override
            public void execute() {

                start(200, true);
                getGalleryService().updateIndex(this);
            }

            @Override
            protected void onResponse(Void result) {

                stop(false);
                updateResultsTab(false);
                m_handler.hideShowPreviewButton(true);
            }
        };
        action.execute();
    }
461708
public void setDataModel(final TableDataModel dataModel) {
		getOrCreateComponentModel().dataModel = dataModel;
		getOrCreateComponentModel().rowIndexMapping = null;

		if (dataModel instanceof BeanTableDataModel) {
			((BeanTableDataModel) dataModel).setBeanProvider(new DataTableBeanProvider(this));
			((BeanTableDataModel) dataModel).setBeanProperty(".");
		}

		if (dataModel instanceof ScrollableTableDataModel) {
			int startIndex = getCurrentPage() * getRowsPerPage();
			int endIndex = startIndex + getRowsPerPage() - 1;
			((ScrollableTableDataModel) dataModel).setCurrentRows(startIndex, endIndex);
		}

		// Flush the repeater's row contexts and scratch maps
		repeater.reset();
	}
584733
public final void add(VoltTableRow row) {
        assert(verifyTableInvariants());
        if (m_readOnly) {
            throw new IllegalStateException("Table is read-only. Make a copy before changing.");
        }
        if (m_colCount == 0) {
            throw new IllegalStateException("Table has no columns defined");
        }
        if (row.getColumnCount() != m_colCount) {
            throw new IllegalArgumentException(row.getColumnCount() + " arguments but table has " + m_colCount + " columns");
        }

        // memoize the start of this row in case we roll back
        final int pos = m_buffer.position();

        try {
            // Allow the buffer to grow to max capacity
            m_buffer.limit(m_buffer.capacity());

            byte[] inboundSchemaString = row.getSchemaString();
            byte[] mySchemaString = getSchemaString();

            // The way this works is that when two schema strings are found to have
            // the same value, the target table's reference is pointed at the source
            // table's reference. This allows the copying of multiple rows from one
            // table to another to only do a deep comparison once, and to do reference
            // equivalence checks for subsequent rows.
            boolean canDoRawCopy = (inboundSchemaString == mySchemaString) ||
                    Arrays.equals(inboundSchemaString, mySchemaString);

            if (canDoRawCopy) {
                // make them the same object if equal for faster comparison next time
                m_schemaString = inboundSchemaString;

                // raw blit the row (assume the row is valid with proper length)
                ByteBuffer rawRow = row.getRawRow();
                m_buffer.put(rawRow);
            }
            else {
                // advance the row size value
                m_buffer.position(pos + 4);

                for (int i = 0; i < m_colCount; i++) {
                    VoltType inboundType = row.getColumnType(i);
                    VoltType outboundType = getColumnType(i);

                    if (inboundType == outboundType) {
                        byte[] raw = row.getRaw(i);
                        m_buffer.put(raw);
                    }
                    else {
                        Object inboundValue = row.get(i, inboundType);
                        addColumnValue(inboundValue, outboundType, i);
                    }
                }

                final int rowsize = m_buffer.position() - pos - 4;
                assert(rowsize >= 0);

                // check for too big rows
                if (rowsize > VoltTableRow.MAX_TUPLE_LENGTH) {
                    throw new VoltOverflowException(
                            "Table row total length larger than allowed max " + VoltTableRow.MAX_TUPLE_LENGTH_STR);
                }

                // buffer overflow is caught and handled below.
                m_buffer.putInt(pos, rowsize);
            }

            // constrain buffer limit back to the new position
            m_buffer.limit(m_buffer.position());

            // increment the rowcount in the member var and in the buffer
            m_rowCount++;
            m_buffer.putInt(m_rowStart, m_rowCount);
        }
        catch (VoltTypeException vte) {
            // revert the row size advance and any other
            // buffer additions
            m_buffer.position(pos);
            throw vte;
        }
        catch (BufferOverflowException e) {
            m_buffer.position(pos);
            expandBuffer();
            add(row);
        }
        // row was too big, reset and rethrow
        catch (VoltOverflowException e) {
            m_buffer.position(pos);
            throw e;
        }
        catch (IllegalArgumentException e) {
            // if this was thrown because of a lack of space
            // then grow the buffer
            // the number 32 was picked out of a hat ( maybe a bug if str > 32 )
            if (m_buffer.limit() - m_buffer.position() < 32) {
                m_buffer.position(pos);
                expandBuffer();
                add(row);
            } else {
                throw e;
            }
        }
        assert(verifyTableInvariants());
    }
980249
public void set(Bean bean) {
        properties.set(bean);
        references.set(bean, getRowKey());
    }
543914
void insertRow(Session session, PersistentStore store, Object[] data) {

        setIdentityColumn(session, data);

        if (triggerLists[Trigger.INSERT_BEFORE].length != 0) {
            fireBeforeTriggers(session, Trigger.INSERT_BEFORE, null, data,
                               null);
        }

        if (isView) {
            return;
        }

        checkRowDataInsert(session, data);
        insertNoCheck(session, store, data);
    }
1155365
@Nullable
  public InputRow transform(@Nullable final InputRow row)
  {
    if (row == null) {
      return null;
    }

    final InputRow transformedRow;

    if (transforms.isEmpty()) {
      transformedRow = row;
    } else {
      transformedRow = new TransformedInputRow(row, transforms);
    }

    if (valueMatcher != null) {
      rowSupplierForValueMatcher.set(transformedRow);
      if (!valueMatcher.matches()) {
        return null;
      }
    }

    return transformedRow;
  }
33591
public void remove(I_CmsEditableGroupRow row) {

        int index = m_container.getComponentIndex(row);
        if (index >= 0) {
            m_container.removeComponent(row);
        }
        updatePlaceholder();
        updateButtonBars();
        updateGroupValidation();
    }
162880
public void setRows(int rows) {

        if (rows < 0) {
            throw new IllegalArgumentException(String.valueOf(rows));
        }
        getStateHelper().put(PropertyKeys.rows, rows);

    }
343742
void set(int row, int column, V value) {
        this.row = row;
        this.column = column;
        this.value = value;
    }
1191156
public void flushRemainingRowsFrom(final XMLUtil util, final Appendable appendable,
                                       final int rowIndex) throws IOException {
        this.appender.flushRemainingRowsFrom(util, appendable, rowIndex);
    }
1019574
public void insertDatum (Object element, int row)
    {
        _data.add(row, element);
        _model.fireTableRowsInserted(row, row);
    }