com.datastax.data.dataset.DataRow Maven / Gradle / Ivy

Go to download


package com.datastax.data.dataset;

import com.datastax.data.dataset.event.RowChangeEvent;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class DataRow {
    
    public enum DataRowStatus {
        
        INSERTED,
        
        DELETED,
        
        UPDATED,
        
        UNCHANGED
    };
    
    
    
    
    private PropertyChangeSupport pcs = new PropertyChangeSupport(this);
    
    
      private DataTable table;
    
    
    private DataRowStatus status = DataRowStatus.INSERTED;
    
    
    private Map cells = new HashMap();
    
    
    protected DataRow(DataTable table) {
        assert table != null;
        this.table = table;
        
        for (DataColumn col : this.table.getColumns()) {
            addCell(col);
        }
    }
    
    
    public void setReferenceValue(String colName, Object value) {
        setReferenceValue(table.getColumn(colName), value);
    }

    public int getCellsCount(){
        return cells.size();
    }
    
    
    public void setReferenceValue(DataColumn col, Object value) {
        assert col != null;
        
        
        getCell(col).setReferenceValue(table, col, value);
        
        
        DataRowStatus newStatus = deriveRowStatus();
        if ( newStatus != status ) {
            setStatus(newStatus);
        }
    }
    
    
    public void setValue(String colName, Object value) {
        DataColumn col = table.getColumn(colName);
        setValue(col, value);
    }
    
    
    public void setValue(DataColumn col, Object value) {
        assert col != null;
        
        Object oldValue = getValue(col);
        DataCell cell = getCell(col);
        getCell(col).setValue(table, col, value);
        
        DataRowStatus oldStatus = status;
        DataRowStatus newStatus = deriveRowStatus();
        if ( newStatus != oldStatus ) {
            setStatus(newStatus);
        }
        
        
        if (!cell.isSame(getTable(), col, oldValue, value))
            fireDataRowChanged(RowChangeEvent.newCellChangedEvent(this, col, oldValue, oldStatus));
    }
    
    
    public void resetAllToReferenceValue() {
        List cols = table.getColumns();
        for ( DataColumn col : cols ) {
            resetToReferenceValue(col);
        }
    }  
    
    
    public void resetToReferenceValue(String colName) {
        resetToReferenceValue(table.getColumn(colName));
    }
    
    
    public void resetToReferenceValue(DataColumn col) {
        setValue(col, getCell(col).referenceValue);
        
    }
    
    
    public Object getReferenceValue(String colName) {
        return getReferenceValue(table.getColumn(colName));
    }
    
    
    public Object getValue(String colName) {
        return getValue(table.getColumn(colName));
    }

    
    public Object getReferenceValue(DataColumn col) {
        assert col != null;
        String exp = col.getExpression();
        if (exp == null || exp.equals("")) {
            DataCell cell = getCell(col);
            return cell.referenceValue;
        } else {
            return col.getValueForRow(this);
        }
    }
    
    
    public Object getValue(DataColumn col) {
        assert col != null;
        String exp = col.getExpression();
        if (exp == null || exp.equals("")) {
            DataCell cell = getCell(col);
            return cell.value;
        } else {
            return col.getValueForRow(this);
        }
    }
    
    
    protected DataCell getCell(DataColumn col) {
        DataCell cell = cells.get(col);
        if (cell == null && col.getTable() == table) {
            cell = addCell(col);
        }
        return cell;
    }
    
    
    public DataTable getTable() {
        return table;
    }
    
    
    void removeFromTable() {
        table = null;
    }
    
    
    public DataRowStatus getStatus() {
        return status;
    }
    
    
    public boolean isModified(String colName) {
        return isModified(table.getColumn(colName));
    }
    
    
    public boolean isModified(DataColumn col) {
        return cells.get(col).changed;
    }
    
    
    public Object getOriginalValue(String colName) {
        return getReferenceValue(colName);
    }
    
    
    public Object getOriginalValue(DataColumn col) {
        return getReferenceValue(col);
    }
    
    
    public void setStatus(DataRowStatus status) {
        if (this.status != status) {
            DataRowStatus priorStatus = this.status;
            this.status = status;
            
            pcs.firePropertyChange("status", priorStatus, status);
            
            if (this.status == DataRowStatus.UNCHANGED) {
                
                List cols = table.getColumns();
                for ( DataColumn col : cols ) {
                    
                    
                    DataCell cell = getCell(col);
                    if ( cell.changed ) cell.overwriteReference();
                }
            }
        }
    }
    
    
    public int getIndex() {
        return table.indexOfRow(this);
    }
    
    
    public void fireDataRowChanged(RowChangeEvent evt) {
        table.fireRowChanged(evt);
    }
    
    
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(listener);
    }
    
    
    public void addPropertyChangeListener(String property, PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(property,  listener);
    }
    
    
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        pcs.removePropertyChangeListener(listener);
    }
    
    
    public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
        pcs.removePropertyChangeListener(propertyName,  listener);
    }
    
    
    public String toString() {
        StringBuilder buffer = new StringBuilder();
        buffer.append("Row #");
        buffer.append(table.indexOfRow(this));
        buffer.append(" [ ");
        int i=0;
        for (DataCell c : cells.values()) {
            buffer.append(c.value);
            if (i < cells.size() -1) {
                buffer.append(", ");
            }
            i++;
        }
        buffer.append(" ]");
        return buffer.toString();
    }
    
    
    protected DataCell addCell(DataColumn col) {
        DataCell cell = cells.get(col);
        if ( cell == null ) {
            cell = new DataCell(col);
            cells.put(col, cell);
        }
        return cell;
    }
    
    
    protected DataRowStatus deriveRowStatus() {
        DataRowStatus derived;
        switch (status) {
            case INSERTED: 
            case DELETED:
                derived = status;
                break;
            case UPDATED: 
            case UNCHANGED:
                boolean any = false;
                for ( DataCell cell : cells.values()) {
                    if ( cell.changed ) {
                        any = true;
                        break;
                    }
                }
                derived = ( any ? DataRowStatus.UPDATED : DataRowStatus.UNCHANGED );
                break;
            default:
                throw new RuntimeException("deriveRowStatus() has no case for row status of " + status);
        }
        return derived;
    }
    
    
    private static final class DataCell {
        
        Object referenceValue;
        
        Object value;
        
        boolean changed;
        
        boolean valueSet;
        
        
        DataCell(DataColumn col){
            this.value = this.referenceValue = col.getDefaultValue();
        }
        
        
        public void setReferenceValue(DataTable table, DataColumn col, Object newRef) {
            referenceValue = newRef;
            changed = isSame(table, col, referenceValue, newRef);
        }
        
        
        public void setValue(DataTable table, DataColumn col, Object newValue) {
            
            if ( !valueSet ) {
                value = referenceValue = newValue;
                changed = true;
                valueSet = true;
                return;
            }
            
            
            
            if ( isSame(table, col, referenceValue, newValue )) {
                value = referenceValue;
                changed = false;
                return;
            } else {
                
                if ( ! isSame( table, col, value, newValue )) {
                    value = newValue;
                    changed = true;
                }
            }
        }
        
        
        public void overwriteReference() {
            referenceValue = value;
            changed = false;
        }

        
        private boolean isSame(DataTable table, DataColumn col, Object baseValue, Object newValue) {
            if ( table.isIdentityComparisonEnabled()) {
                return newValue == baseValue;
            } else {
                Comparator comp = null;
                if ( table.hasColumnComparator(col)) {
                    comp = table.getColumnComparator(col);
                } else {
                    
                    
                    comp = table.getClassComparator(col.getType());
                }
                return comp.compare(baseValue, newValue) == 0;
            }
        }
    }
}