secondo/Javagui/viewer/update2/RelationTableModel.java

//This file is part of SECONDO.

//Copyright (C) 2004, University in Hagen, Department of Computer Science, 
//Database Systems for New Applications.

//SECONDO is free software; you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation; either version 2 of the License, or
//(at your option) any later version.

//SECONDO is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.

//You should have received a copy of the GNU General Public License
//along with SECONDO; if not, write to the Free Software
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

package viewer.update2;

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import gui.idmanager.*;
import gui.SecondoObject;

import sj.lang.ListExpr;

import tools.Reporter;

import viewer.update2.*;

/**
 * This class provides table data displayed in the RelationPanel.
 */

public class RelationTableModel extends AbstractTableModel 
{
	private Relation relation;
	private String relationName;
	private String[] columnNames = {"TupleId", "Name", "Value"};
	private List<String> attributeNames;
	private int tupleSize;
	private int[] maxContentLengths;
	private int state;
	private boolean editable;
	
	// contains changes in chronological order
	private List<Change> changes;
    
    // contains tuple ids for deletion in chronological order
	private List<String> deletions;
	
	// hits from latest search, ordered by tow and startindex
	private List<SearchHit> hitList;
	
	private int currHit;
	
	public static final int COL_TUPLEID = 0;
	public static final int COL_ATTRNAME = 1;
	public static final int COL_ATTRVALUE = 2;
	
		
	/**
	 * Constructor.
	 */
	public RelationTableModel(Relation pRelation, boolean pEditable) throws InvalidRelationException
	{
		if(pRelation==null || !pRelation.isInitialized())
		{
			throw(new InvalidRelationException());
		}
		
		this.relation = pRelation;
		this.relationName = pRelation.getName();
		this.tupleSize = pRelation.getTupleSize();
		this.attributeNames = pRelation.getAttributeNames();
		this.changes = new ArrayList<Change>();
		this.deletions = new ArrayList<String>();
		this.hitList = new ArrayList<SearchHit>();
		this.state = pEditable? States.LOADED : States.LOADED_READ_ONLY;
			 
		Reporter.debug(this.toString());
	}
	
	/**
     * Append specified change to change list for this relation.
     */
	public void addChange(Change pChange)
	{
		if (!this.isReadOnly())
		{
			//Reporter.debug("RelationTableModel.addChange :" + pChange.toString());
			this.changes.add(pChange);
		}
	}

	
    /**
     * Marks the tuple corresponding to the specified row index for deletion.
     * Return true if it was not yet marked else  false.
     */
    public boolean addDeletion(int pRow)
    {
		if (!this.isReadOnly() && !isRowSeparator(pRow) )
		{
			String tupleid = (String)this.getValueAt(pRow, this.COL_TUPLEID);
			if (!this.isRowDeleted(pRow))
			{
				this.deletions.add(tupleid);
				//Reporter.debug("RelationTableModel.addDeletion: marked tuple " + tupleid);
				return true;
			}
			//else Reporter.debug("RelationTableModel.addDeletion: already marked tuple " + tupleid);
		}
        return false;
    }
	
	
	
    /**
	 * Inserts a hit in the hitlist, if not already exists.
     */
    public void addHit(SearchHit pHit)
    {
		if (!this.hitList.contains(pHit))
		{
			this.hitList.add(pHit);
			Collections.sort(hitList);
		}
    }
	
	
	/**
	 * Appends a tuple specified by the ListExpression
     */
    public void addTuple(ListExpr pTuple)
    {
		try
		{
			Tuple tuple = this.relation.createEmptyTuple();
			tuple.readValueFromLE(pTuple);
			this.relation.addTuple(tuple);
			fireTableRowsInserted(0, this.getRowsPerTuple());
		}
		catch (InvalidRelationException e)
		{
      Reporter.debug(e);
			Reporter.writeError("RelationTableModel.addTuple: invalid LE is " + pTuple.toString());
		}
	}
	
	
	/**
	 * Removes all changes. Returns true if any changes existed.
	 */
	public boolean clearChanges()
	{
		if (this.changes != null && !this.changes.isEmpty())
		{
			this.changes.clear();
		}
		return false;
	}
    
    
    /**
	 * Removes all deletions. Returns true if any deletions existed.
	 */
	public boolean clearDeletions()
	{
		if (this.hasDeletions())
		{
			this.deletions.clear();
            return true;
		}
		return false;
	}
	
	
	/*
	 * Returns all changes in chronological order.	 
	 */	
	public List<Change> getChanges()
	{
		return this.changes;
	}	

	
	/**
	 * Returns a list of changes, that contain newest value and original value of each changed cell. 
	 */
	public List<Change> getChangesForReset()
	{
		List<Change> result = new ArrayList<Change>();
		Map<Integer, HashMap<String, Change>> updateTuples = new HashMap<Integer, HashMap<String, Change>>();
		
		for (Integer i : updateTuples.keySet())
		{
			for (String s : updateTuples.get(i).keySet())
			{
				result.add(updateTuples.get(i).get(s));
			}
		}
		return result;
	}
	
	
	/*
	 * Returns only valid (=last change of attribute) changes mapped by tuple index and attribute name.
	 * Changes include original values.
	 */	
	public Map<Integer, HashMap<String, Change>> getChangesForUpdate()
	{
		Map<Integer, HashMap<String, Change>> result = new HashMap<Integer, HashMap<String, Change>>();
		
		Integer tid;
		String attrName;
		HashMap<String, Change> mapTuple;		
		
		for (Change ch : this.changes)
		{
			tid = ch.getTupleIndex();
			attrName = ch.getAttributeName();
			
			mapTuple = result.get(tid);
			if (mapTuple == null)
			{
				mapTuple = new HashMap<String, Change>();
			}
			mapTuple.put(attrName, ch);	
			
			if (!mapTuple.isEmpty())
			{
				Change chOld = mapTuple.get(attrName);
				if (chOld == null && ch.changesSameObject(chOld))
				{
					ch.setOldValue(chOld.getOldValue());
				}
				mapTuple.put(attrName, ch);
			}
			
			result.put(tid, mapTuple);
		}
		
		// only debugging
		for (Integer i : result.keySet())
		{
			for (String s : result.get(i).keySet())
			{
				//Reporter.debug("RelationPanel.getUpdateTuples result is :" + result.get(i).get(s).toString());
			}
		}
		return result;
	}
	
	
			
	/**
	 * Method of interface AbstractTableModel.
	 *
	 */
    public Class getColumnClass(int pCol) 
	{
        return getValueAt(0, pCol).getClass();
    }
	
	/**
	 * Returns a List of String representations of all the values in the specified column.
	 */ 
	public List<String> getColumnContent(int pCol)
	{
		List<String> result = new ArrayList<String>();
		
		for (int i = 0; i < this.relation.getTupleCount() * this.getRowsPerTuple(); i++)
		{
			Object o = this.getValueAt(i, pCol);
			
			if (o== null)
			{
				Reporter.debug("RelationPanel.getColumnContent: null object at tupleindex=" + i + ", columnindex=" + pCol);
			}
			result.add(o.toString());
		}
		
		return result;
	}
	
	/*
	 * Method of interface AbstractTableModel.
	 */
	public int getColumnCount() 
	{
        return columnNames.length;
    }
	
	
	/*
	 * Method of interface AbstractTableModel.
	 */
    public String getColumnName(int pCol) 
	{
        return columnNames[pCol];
    }
	
	
	/*
	 * Method of interface AbstractTableModel.
	 */
    public String[] getColumnNames() 
	{
        return columnNames;
    }
	
	
	public int getCurrentHitIndex()
	{
		return this.currHit;
	}
    
    public List<String> getDeletions()
    {
        return this.deletions;
    }
	
	/**
     * Returns SearchHit with specified index in this relation.
     */
	public SearchHit getHit(int pIndex)
	{
		if (pIndex >= 0 && this.hitList != null && pIndex < this.hitList.size())
		{
			return this.hitList.get(pIndex);
		}
		return null;
	}
	
	/**
	 * Returns number of all search hits
	 */
	public int getHitCount()
	{
		if (this.hitList != null)
		{
			return this.hitList.size();
		}
		return 0;
	}
		
	
	/**
	 * Returns all SearchHits for the specified row.
	 */
	public List<SearchHit> getHits(int pRow)
	{
		List<SearchHit> result = new ArrayList<SearchHit>();
		if (this.hasSearchHits())
		{
			for (SearchHit hit : this.hitList)
			{
				if (hit.getRowIndex() == pRow)
				{
					result.add(hit);
				}
			}
		}
		return result;
	}
	
	
	/**
	 * Returns newest change.	 
	 */
	public Change getLastChange()
	{
		if (this.hasChanges())
		{
			return this.changes.get(this.changes.size()-1);			
		}
		return null;
	}
	

	/**
	 * Returns the relation name.
	 */
	public String getRelationName()
	{
		return this.relationName;
	}
	
	
	public int getRow(String pTupleId, String pAttributeName)
	{
		int tupleIndex = this.relation.getTupleIndex(pTupleId);
		int attributeIndex = this.relation.getAttributeNames().indexOf(pAttributeName);
		int result = tupleIndex*this.getRowsPerTuple() + attributeIndex +1;
		return result;
	}
	
	/*
	 * Method of interface AbstractTableModel.
	 */
    public int getRowCount() 
	{
		// add (empty) extra row as separator between tuples
        return this.relation.getTupleCount() * this.getRowsPerTuple();
    }
	
	
	public int getRowsPerTuple()
	{
		return (this.tupleSize+1);
	}
	

    /**
     * Returns state.
     * Used in TableCellEditor/-Renderer.
     * @see viewer.update2.States
     */
	public int getState()
	{
		return this.state;
	}
	
	
	/*
	 * Method of interface AbstractTableModel.
	 * Returns String representation of Tuple ID for column 1, 
	 * String representation of attribute name for column 2,
	 * formatted String representation of attribute value for column 3.
	 */
    public Object getValueAt(int pRow, int pCol) 
	{
		String result = " ";
		
		// if this is not a Separator Row
		if(!this.isRowSeparator(pRow)) 
		{
			// get Tuple value
			int tupleIndex = this.rowToTupleIndex(pRow);
			int attrIndex = this.rowToAttributeIndex(pRow);
			
			Tuple tuple = this.relation.getTupleAt(tupleIndex);
			
			// get value
			switch (pCol)
			{
				case COL_TUPLEID: 
					result = tuple.getID();
					break;
				case COL_ATTRNAME:
					result = this.attributeNames.get(attrIndex);
					break;
				case COL_ATTRVALUE: 
					result = tuple.getValueAt(attrIndex);
					break;
				default: 
					result = "Fehler";
			}
		}
		//Reporter.debug("RelationTableModel.getValueAt(" + pRow + ", " + pCol + ": " + result);		
		return result;
    }
	
    
    public boolean hasChanges()
    {
        return (this.changes != null && !this.changes.isEmpty());
    }
    
    
    public boolean hasDeletions()
    {
        return (this.deletions != null && !this.deletions.isEmpty());
    }
	
	public boolean hasSearchHits()
    {
        return (this.hitList != null && !this.hitList.isEmpty());
    }
	
    
	
	/*
	 * Method of interface AbstractTableModel.
     * Don't need to implement this method unless your table's
     * editable.
     */
    public boolean isCellEditable(int pRow, int pCol) 
	{
		if (this.state == States.UPDATE || this.state == States.INSERT)
		{
			int attrIndex = this.rowToAttributeIndex(pRow);
			
			if (attrIndex < 0)
			{
				return false;
			}
			
			String attrName = this.relation.getAttributeNames().get(attrIndex);
			
			if (attrIndex != this.relation.getTypeInfo().getTidIndex() 
				&& !this.relation.isAttributeReadOnly(attrName))
			{
				return (pCol == COL_ATTRVALUE && !this.isRowSeparator(pRow));
			}
		}
		return false;
	}
    
    /**
	 * Returns true if there are uncommitted changes for specified table cell.
	 */
	public boolean isCellChanged(int pRow, int pCol)
	{
		for (Change ch : this.changes)
		{
			if (ch.getRowIndex() == pRow)
			{
				return true;
			}
		}
		return false;
	}

	
	/**
	 * Returns true if relation is read-only (no edit function)
	 */
	public boolean isReadOnly()
	{
		//Reporter.debug("RelationTableModel.isReadOnly: " + (this.state == States.LOADED_READ_ONLY));
		return (this.state == States.LOADED_READ_ONLY);
	}
	
    
    /**
	 * Returns true if the tuple this row belongs to has been marked for deletion.
	 */
	public boolean isRowDeleted(int pRow)
	{
		if (!this.isRowSeparator(pRow))
		{		
			String tupleid = (String)this.getValueAt(pRow, this.COL_TUPLEID);
			
			if (tupleid != null && (tupleid.length() > 0) && this.deletions.contains(tupleid))
			{
				return true;
			}
		}

		return false;
	}
	
    
	/**
	 * Returns true if rowIndex specifies a separator row (empty row between tuples).
	 */
	private boolean isRowSeparator(int pRow)
	{
		return (pRow % this.getRowsPerTuple() == 0);
	}

		
	/**
	 * Removes change at specified index from change history list.	 
	 */
	public Change removeChange(int pIndex)
	{
		//Reporter.debug("RelationTableModel.removeChange :" + pIndex);
		Change result = null;
		
		if (this.hasChanges() && pIndex < this.changes.size())
		{
			return (Change)this.changes.remove(this.changes.size()-1);			
		}		
		return result;
	}
	
	
	/**
	 * Removes specified change and returns TRUE if it existed.
	 */
	public boolean removeChange(Change pChange)
	{
		//Reporter.debug("RelationTableModel.removeChange :" + pChange.toString());
		boolean result = false;
		
		if (this.hasChanges())
		{
			result = this.changes.remove(pChange);			
		}		
		return result;
	}

	/**
	 * Removes specified SearchHit and returns TRUE if it existed.
	 */
	public boolean removeHit(SearchHit pHit)
	{
		//Reporter.debug("RelationTableModel.removeHit :" + pHit.toString());
		boolean result = false;
		
		if (this.hasSearchHits())
		{
			int delIndex = this.hitList.indexOf(pHit);

			result = this.hitList.remove(pHit);		
			
			if (this.currHit > delIndex  || this.currHit >= this.getHitCount())
			{
				this.currHit--;
			}
		}

		return result;
	}
	
    
	/**
	 * Removes last deletion from deletion history list, if any.
     * Returns TRUE if deletion existed.
	 */
	public boolean removeLastDeletion()
	{
		if (this.hasDeletions())
		{
			this.deletions.remove(this.deletions.size()-1);
            return true;
		}
        return false;
	}
	
	/**
	 * Removes Tuple from Relation and notifies table of deleted rows.
	 */
	public void removeTuple(String pTupleId)
	{
		this.relation.removeTupleByID(pTupleId);
		fireTableRowsDeleted(0, this.getRowsPerTuple()-1);
	}
	
	
	public int rowToTupleIndex(int pRow)
	{
		return (pRow / this.getRowsPerTuple());
	}
	
	public int rowToAttributeIndex(int pRow)
	{
		return ((pRow % this.getRowsPerTuple()) - 1);
	}
		
	/**
	 * Builds map for searchhits by row index.
	 * Resets index for currently displayed searchhit.  
	 */
	public void setSearchHits(List<SearchHit> pHitlist)
	{
		if (pHitlist == null || pHitlist.isEmpty())
		{
			this.hitList.clear();
			this.currHit = -1;
		}
		else
		{
			this.hitList = pHitlist;
			this.currHit = 0;
		}
	}
	
    /**
     * Sets the hit index if valid.
     */
	public void setCurrentHitIndex(int pIndex)
	{
		if (pIndex >= 0 && pIndex < this.hitList.size())
		{
			this.currHit = pIndex;
		}
	}
	
	
	/*
	 * Method of interface AbstractTableModel.
     * Change table data.
     */
	@Override
    public void setValueAt(Object pValue, int pRow, int pCol) 
	{
		//Reporter.debug("RelationTableModel.setValueAt: " + pRow + ", " + pCol);
		
		if(!this.isReadOnly() && isCellEditable(pRow, pCol)) 
		{
			int tupleIndex = this.rowToTupleIndex(pRow);
			int attrIndex = this.rowToAttributeIndex(pRow);
									
			this.relation.setValueAt(tupleIndex, attrIndex, (String)pValue);
			
			fireTableCellUpdated(pRow, pCol);
		}
    }

	/**
     * Sets the state.
	 * Does not change state if model was initialized with States.LOADED_READ_ONLY.
	 * @see viewer.update2.States
	 */
	public void setState(int pState)
	{
		if (!this.isReadOnly())
		{
			this.state = pState;
		}
	}
    
	
    
	public String toString()
	{
		StringBuffer sb = new StringBuffer("[RelationTableModel]: ");
		sb.append(", relationName: ").append(relationName);
		sb.append(", tupleCount: ").append(this.relation.getTupleCount());
		sb.append(", tupleSize: ").append(tupleSize);
		sb.append(this.relation.toString());
		return sb.toString();
	}
}