| gvSIG desktop 1

	public void setAttributes(Value[] att) {

		this.attributes = att;

	}

	public void setAttributes(Value[] att);

import com.hardcode.gdbms.engine.values.NullValue;

import com.hardcode.gdbms.engine.values.Value;

    private Value defaultValue = new NullValue();

	public Value getDefaultValue() {

		return defaultValue;

	}

	public void setDefaultValue(Value defaultValue) {

		this.defaultValue = defaultValue;

	}

import java.util.Collection;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.TreeMap;

import sun.print.PSPrinterJob.PluginPrinter;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.edition.commands.AddFieldCommand;

import com.iver.cit.gvsig.fmap.edition.commands.RemoveFieldCommand;

import com.iver.cit.gvsig.fmap.edition.commands.RenameFieldCommand;

import com.iver.cit.gvsig.fmap.edition.fieldmanagers.AbstractFieldManager;

 * 

	protected ArrayList listFields = new ArrayList();

	protected ArrayList listInternalFields = new ArrayList();

	/**

	 * La clave ser? el fieldIndex. Para buscar si un value de una row ha de ser

	 * rellenado con defaultValue o con lo que venga del expansion file,

	 * miraremos si existe en este hash. Si existe, usamos el value del

	 * expansion file. Si no existe, usamos el defaultValue del campo busc?ndolo

	 * en la lista internalFields. Por cierto, en listInternalFields NO se

	 * borran campos. Solo se marcan como borrados.

	 */

	protected TreeMap actualFields; // la clave ser? el fieldIndex.

	protected class MyFieldManager extends AbstractFieldManager {

		public boolean alterTable() throws EditionException {

			return getFieldManager().alterTable();

		}

		public void addField(FieldDescription fieldDesc) {

			super.addField(fieldDesc);

		}

		public FieldDescription removeField(String fieldName) {

			// TODO Auto-generated method stub

			return super.removeField(fieldName);

		}

		public void renameField(String antName, String newName) {

			// TODO Auto-generated method stub

			super.renameField(antName, newName);

		}

	}

	protected int actualIndexFields;

		expansionFile = new MemoryExpansionFile(this);

	 * 

	 * @throws DriverException 

	public void setOriginalDataSource(SelectableDataSource ds) throws DriverException {

		FieldDescription[] fields = ds.getFieldsDescription();

		actualFields = new TreeMap();

		for (int i=0; i < fields.length; i++)

		{

			InternalField field = new InternalField(fields[i], InternalField.ORIGINAL, new Integer(i));

			listFields.add(field);

			actualFields.put(field.getFieldId(), field);

		}

		fieldsChanged();

	private void fieldsChanged() {

		listInternalFields.add(actualFields);

		actualIndexFields = listInternalFields.size()-1;

	}

	 * 

		/*

		 * DataWare dataWare =

		 * ods.getDataWare(DataSourceFactory.DATA_WARE_DIRECT_MODE);

		 * dataWare.get

		 */

		if (drv instanceof IWriteable) {

	 * 

	 * 

	public void stopEdition(IWriter writer, int sourceType)

			throws EditionException {

		saveEdits(writer, sourceType);

		fireStopEditionEvent(sourceType);

	}

	public void saveEdits(IWriter writer, int sourceType)

			throws EditionException {

			for (int i = delRows.nextSetBit(0); i >= 0; i = delRows

					.nextSetBit(i + 1)) {

							.getLinkedRow().cloneRow(),

							DefaultRowEdited.STATUS_DELETED, calculatedIndex);

	 * 

	 * 

	 * 

	 * 

			// expansionFile.getInvalidRows().cardinality();

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.iver.cit.gvsig.fmap.edition.IEditableSource#addRow(com.iver.cit.gvsig.fmap.core.IRow,

	 *      java.lang.String)

	public int addRow(IRow row, String descrip, int sourceType)

			throws DriverIOException, IOException {

		Command command = new AddRowCommand(this, row, calculatedIndex,

				sourceType);

	 * 

	 * 

	/*

	 * 

	public void removeRow(int index, String descrip, int sourceType)

			throws IOException, DriverIOException {

		Command command = new RemoveRowCommand(this, calculatedIndex,

				sourceType);

	 * 

		Command command = new ModifyRowCommand(this, calculatedIndex, pos, row,

				sourceType);

	 * 

	public void endComplexRow(String description) throws IOException,

			DriverIOException {

	 * 

	 * 

	public void undoModifyRow(int geometryIndex,

			int previousExpansionFileIndex, int sourceType) throws IOException,

			DriverIOException {

			DefaultRowEdited edRow = null;

						DefaultRowEdited.STATUS_ORIGINAL, geometryIndex);

			boolean cancel = fireBeforeModifyRow(edRow, geometryIndex,

					sourceType);

			boolean cancel = fireBeforeModifyRow(expansionFile

					.getRow(previousExpansionFileIndex), geometryIndex,

					sourceType);

		fireAfterModifyRow(geometryIndex, sourceType);

	 * 

	 * 

	public IRow doRemoveRow(int index, int sourceType)

			throws DriverIOException, IOException {

	 * 

	 * 

	 * 

	public int doModifyRow(int index, IRow feat, int sourceType)

			throws IOException, DriverIOException {

		boolean cancel = fireBeforeModifyRow(feat, index, sourceType);

			int expansionIndex = expansionFile.addRow(feat,

					IRowEdited.STATUS_MODIFIED, actualIndexFields);

			num = expansionFile.modifyRow(num, feat, actualIndexFields);

	 * 

	 * 

	 * 

	public int doAddRow(IRow feat, int sourceType) throws DriverIOException,

			IOException {

		int pos = expansionFile.addRow(feat, IRowEdited.STATUS_ADDED, actualIndexFields);

	 * 

	 * 

	public void undoRemoveRow(int index, int sourceType) throws IOException,

			DriverIOException {

	 * 

	 * 

	public void undoAddRow(int calculatedIndex, int sourceType)

			throws DriverIOException, IOException {

		boolean cancel = fireBeforeRemoveRow(calculatedIndex, sourceType);

		fireAfterRemoveRow(calculatedIndex, sourceType);

	 * 

	 * 

	 * 

	 * 

	 * 

	 * 

		 * 

		 * 

		 * 

		 * 

		 * 

		 * 

		 * 

		 * 

				// expansionFile.getInvalidRows().cardinality();

		 * 

	protected void fireAfterRemoveRow(int index, int sourceType) {

		AfterRowEditEvent event = new AfterRowEditEvent(this, index,

				EditionEvent.CHANGE_TYPE_DELETE, sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

	protected boolean fireBeforeRemoveRow(int index, int sourceType) {

		BeforeRowEditEvent event = new BeforeRowEditEvent(this, index,

				EditionEvent.CHANGE_TYPE_DELETE, cancel, sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

			listener.beforeRowEditEvent(null, event);

	protected void fireAfterRowAdded(int calculatedIndex, int sourceType) {

		AfterRowEditEvent event = new AfterRowEditEvent(this, calculatedIndex,

				EditionEvent.CHANGE_TYPE_ADD, sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

	protected boolean fireBeforeRowAdded(int sourceType)

			throws DriverIOException, IOException {

		BeforeRowEditEvent event = new BeforeRowEditEvent(this, getRowCount(),

				EditionEvent.CHANGE_TYPE_ADD, cancel, sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

			listener.beforeRowEditEvent(null, event);

	protected boolean fireBeforeModifyRow(IRow feat, int index, int sourceType) {

		BeforeRowEditEvent event = new BeforeRowEditEvent(this, index,

				EditionEvent.CHANGE_TYPE_MODIFY, cancel, sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

	protected void fireAfterModifyRow(int index, int sourceType) {

		AfterRowEditEvent event = new AfterRowEditEvent(this, index,

				EditionEvent.CHANGE_TYPE_MODIFY, sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

		EditionEvent ev = new EditionEvent(this, EditionEvent.START_EDITION,

				sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

		EditionEvent ev = new EditionEvent(this, EditionEvent.STOP_EDITION,

				sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

		EditionEvent ev = new EditionEvent(this, EditionEvent.CANCEL_EDITION,

				sourceType);

		for (int i = 0; i < editionListeners.size(); i++) {

			IEditionListener listener = (IEditionListener) editionListeners

					.get(i);

	public void addEditionListener(IEditionListener listener) {

	public void removeEditionListener(IEditionListener listener) {

	protected void setWriter(IWriter writer) {

	public ITableDefinition getTableDefinition() throws DriverLoadException,

			DriverException {

		for (int i = 0; i < rules.size(); i++) {

			if (bAux == false) {

				EditionException ex = new EditionException(

						"NOT follow the rule: " + rule.getDescription());

	private void clean() throws IOException {

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.iver.cit.gvsig.fmap.edition.IEditableSource#getFieldManager()

	 */

	public IFieldManager getFieldManager() {

		if (ods.getDriver() instanceof IFieldManager)

			return (IFieldManager) ods.getDriver();

		return null;

	}

	/**

	 * Tiene en cuenta los campos actuales para formatear una row con ellos. Le

	 * pasamos los campos que hab?a en el momento en que se cre? esa row.

	 * 

	 * @param edRow

	 * @param indexInternalFields

	 * @return

	 */

	public IRowEdited createExternalRow(IRowEdited edRow,

			int indexInternalFields) {

		Value[] att = edRow.getAttributes();

		TreeMap ancientFields = (TreeMap) listInternalFields

				.get(indexInternalFields);

		Value[] newAtt = new Value[actualFields.size()];

		Collection aux = actualFields.values();

		Iterator it = aux.iterator();

		int i = 0;

		Value val = null;

		while (it.hasNext()) {

			InternalField fld = (InternalField) it.next();

			if (ancientFields.containsKey(fld.getFieldId())) {

				InternalField ancientField = (InternalField) ancientFields

						.get(fld.getFieldId());

				val = att[ancientField.getFieldIndex()];

			} else

				val = fld.getFieldDesc().getDefaultValue();

			newAtt[i] = val;

		}

		IRowEdited newRow = (IRowEdited) edRow.cloneRow();

		newRow.setAttributes(newAtt);

		return newRow;

	}

	public void removeField(String fieldName) throws EditionException {

		InternalField fld = findFieldByName(fieldName);

		Command command = new RemoveFieldCommand(this, fld);

		if (complex) {

			commands.add(command);

		} else {

			cr.pushCommand(command);

		}

		doRemoveField(fld);

	}

	private InternalField findFieldByName(String fieldName) {

		Collection aux = actualFields.values();

		Iterator it = aux.iterator();

		while (it.hasNext()) {

			InternalField fld = (InternalField) it.next();

			if (fld.getFieldDesc().getFieldName().compareToIgnoreCase(fieldName) == 0)

				return fld;

		}

		return null;

	}

	public void undoRemoveField(InternalField field) {

		field.setDeleted(false);

		actualFields.put(field.getFieldId(), field);

		fieldsChanged();

	}

	public void doRemoveField(InternalField field) {

		field.setDeleted(true);

		actualFields.remove(field.getFieldId());

		fieldsChanged();

	}

	public void renameField(String antName, String newName) throws EditionException {

		InternalField fld = findFieldByName(antName);

		Command command = new RenameFieldCommand(this, fld, newName);

		if (complex) {

			commands.add(command);

		} else {

			cr.pushCommand(command);

		}

		doRenameField(fld, newName);

	}

	public void undoRenameField(InternalField field, String antName) {

		field.getFieldDesc().setFieldAlias(antName);

	}

	public void doRenameField(InternalField field, String newName) {

		field.getFieldDesc().setFieldAlias(newName);

	}

	public void addField(FieldDescription field) throws EditionException {

		InternalField fld = new InternalField(field, InternalField.ADDED, new Integer(listFields.size()));

		Command command = new AddFieldCommand(this, fld);

		if (complex) {

			commands.add(command);

		} else {

			cr.pushCommand(command);

		}

		listFields.add(fld);

		doAddField(fld);

	}

	public void undoAddField(InternalField field) {

		field.setDeleted(true);

		field.setFieldIndex(actualFields.size());

		actualFields.put(field.getFieldId(), field);

		fieldsChanged();

	}

	public void doAddField(InternalField field) {

		field.setDeleted(false);

		actualFields.remove(field.getFieldId());

		fieldsChanged();

	}

	private ArrayList fieldCommands = new ArrayList();

		alterTable();

		System.err.println("DBFWriter: " + row.getStatus() + " numRows = "

				+ numRows);

		switch (row.getStatus()) {

		// campos muy grandes

	public boolean alterTable() throws EditionException {

		for (int i = 0; i < fieldCommands.size(); i++) {

			FieldCommand fc = (FieldCommand) fieldCommands.get(i);

			if (fc instanceof AddFieldCommand) {

				AddFieldCommand addFC = (AddFieldCommand) fc;

			if (fc instanceof RemoveFieldCommand) {

				RemoveFieldCommand deleteFC = (RemoveFieldCommand) fc;

				// for (int j=0; j < myHeader.getNumFields(); j++)

				// {

				// if

				// (myHeader.getFieldName(j).compareTo(deleteFC.getFieldName())

				// == 0)

				// {

				myHeader.removeColumn(deleteFC.getFieldName());

				// break;

				// }

				// }

			if (fc instanceof RenameFieldCommand) {

				RenameFieldCommand renFC = (RenameFieldCommand) fc;

				for (int j = 0; j < myHeader.getNumFields(); j++) {

					if (myHeader.getFieldName(j).compareTo(renFC.getAntName()) == 0) {

			}

		FieldDescription[] fieldsDesc = (FieldDescription[]) fields

				.toArray(new FieldDescription[0]);

//			if (bNeedRewrite) {

//				int aux = (int) (Math.random() * 1000);

//				File fTemp = new File(System.getProperty("java.io.tmpdir")

//						+ "/tmpDbf" + aux + ".dbf");

//

//				// TODO: TERMINAR!!

//

//			}

		return bNeedRewrite;

	}

	public void addField(FieldDescription fieldDesc) {

		AddFieldCommand c = new AddFieldCommand(fieldDesc);

		fieldCommands.add(c);

	}

	public FieldDescription removeField(String fieldName) {

		RemoveFieldCommand c = new RemoveFieldCommand(fieldName);

		FieldDescription[] act = getFields();

		FieldDescription found = null;

		for (int i=0; i < act.length; i++)

		{

			if (act[i].getFieldAlias().compareToIgnoreCase(fieldName) == 0)

			{

				found = act[i];

				break;

			}

		}

		fieldCommands.add(c);

		return found;

	}

	public void renameField(String antName, String newName) {

		RenameFieldCommand c = new RenameFieldCommand(antName, newName);

		fieldCommands.add(c);

	}

	public FieldDescription[] getFields() {

		ArrayList aux = new ArrayList();

		for (int i=0; i < aux.size(); i++)

		{

			aux.add(getOriginalFields()[i]);

		}

		// procesamos comandos para devolver los campos reales.

		for (int j=0; j < fieldCommands.size(); j++)

		{

			FieldCommand fc = (FieldCommand) fieldCommands.get(j);

			if (fc instanceof AddFieldCommand)

			{

				AddFieldCommand ac = (AddFieldCommand) fc;

				aux.add(ac.getFieldDesc());

			}

			if (fc instanceof RemoveFieldCommand)

			{

				RemoveFieldCommand rc = (RemoveFieldCommand) fc;

				for (int k = 0; k < aux.size(); k++) {

					FieldDescription fAux = (FieldDescription) aux.get(k);

					if (fAux.getFieldAlias().compareTo(rc.getFieldName()) == 0) {

						aux.remove(k);

						break;

					}

				}

			}

			if (fc instanceof RenameFieldCommand)

			{

				RenameFieldCommand renc = (RenameFieldCommand) fc;

				for (int k = 0; k < aux.size(); k++) {

					FieldDescription fAux = (FieldDescription) aux.get(k);

					if (fAux.getFieldAlias().compareTo(renc.getAntName()) == 0) {

						fAux.setFieldAlias(renc.getNewName());

						break;

					}

				}

			}			

		}

		return (FieldDescription[]) aux.toArray(new FieldDescription[0]);

	}

}

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program 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.

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.fmap.edition;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

public class InternalField {

	public final static int ORIGINAL = 0;

	public final static int DELETED = 2;

	public final static int ADDED = 3;

	private int fieldType = -1;

	private Integer fieldId;

	private boolean isDeleted = false;

	private FieldDescription fieldDesc = null;

	private int fieldIndex;

	public boolean isDeleted() {

		return isDeleted;

	}

	public void setDeleted(boolean isDeleted) {

		this.isDeleted = isDeleted;

	}

	public FieldDescription getFieldDesc() {

		return fieldDesc;

	}

	/**

	 * Possible values: InternalField.ORIGINAL, InternalField.DELETED, ADDED

	 * 

	 * @return

	 */

	public int getFieldType() {

		return fieldType;

	}

	public InternalField(FieldDescription fieldDesc, int fieldType, Integer fieldId) {

		this.fieldDesc = fieldDesc;		

		this.fieldType  =fieldType;

		this.fieldId = fieldId;

	}

	/**

	 * All fields are created and stored in fieldList. Every field has a unique

	 * fieldId. This fieldId is useful to find the field that was used to

	 * generate a row. De esta forma, si nos interesa saber si un campo actual

	 * es el mismo que aqu?l con el que fue generado la row correspondiente,

	 * miramos si coincide su fieldIndex.

	 * 

	 * @return

	 */

	public Integer getFieldId() {

		return fieldId;

	}

	public int getFieldIndex() {

		return fieldIndex;

	}

	public void setFieldIndex(int i) {

		fieldIndex = i;

	}

}