| gvSIG desktop 1

import org.gvsig.fmap.dal.DataExplorer;

			this.testSimpleIteration(dbfParameters);

	public void test() {

		DBFStoreParameters dbfParameters = null;

		try {

			dbfParameters = (DBFStoreParameters) dataManager

					.createStoreParameters(DBFStoreProvider.NAME);

			dbfParameters.setFile(dbf_prueba);

			FeatureStore store = (FeatureStore) dataManager

					.createStore(dbfParameters);

			FeatureSet set = store.getFeatureSet();

			set.dispose();

		} catch (DataException e3) {

			e3.printStackTrace();

			fail();

			return;

		}

	}

			DataExplorer explorer = store.getExplorer();

			assertEquals(2, explorer.list().size());

			store.dispose();

		params.setSHPFileName(file.getPath());

			fin = new FileInputStream(this.params.getSHPFile());

			throw new FileNotFoundException(this.params.getSHPFileName());

			throw new ReadException(this.params.getSHPFileName(), e);

			finShx = new FileInputStream(this.params.getSHXFile());

			throw new FileNotFoundException(this.params.getSHXFileName());

			throw new ReadException(this.params.getSHXFileName(), e);

		File prjFile = SHP.getPrjFile(this.params.getSHPFile());

		return this.params.getSHPFile().canWrite()

				&& this.params.getSHXFile().canWrite();

	private void drain() throws WriteException {

			throw new WriteException("SHP File Write Drain", e);

	public void close() throws WriteException {

			throw new WriteException("SHP File Write Close", e);

			throws WriteException {

			throws WriteException {

			int fileLength) throws WriteException {

			throw new WriteException("SHP File Write Headers", e);

	public int writeIGeometry(Geometry g) throws WriteException {

			throws WriteException {

				throw new WriteException("SHP File Write", e);

import java.io.File;

import java.io.IOException;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.exception.CreateException;

import org.gvsig.fmap.dal.feature.FeatureSet;

	protected static final String GEOMETRY_ATTIBUTE_NAME = "GEOMETRY";

				new Object[] { this.shpParams.getSHPFileName() });

	private EditableFeatureAttributeDescriptor addGeometryColumn(

			EditableFeatureType fType) {

		fType.setDefaultGeometryAttributeName(GEOMETRY_ATTIBUTE_NAME);

		return fType.add(GEOMETRY_ATTIBUTE_NAME, DataTypes.GEOMETRY);

	}

	private void removeGeometryColumn(

			EditableFeatureType fType) {

		fType.setDefaultGeometryAttributeName(null);

		fType.remove(GEOMETRY_ATTIBUTE_NAME);

	}

			EditableFeatureAttributeDescriptor attr = this.addGeometryColumn(

					fType).setGeometryType(

		FeatureType fType;

		try {

			fType = this.store.getDefaultFeatureType();

		} catch (DataException e) {

			throw new PerformEditingException(this.getName(), e);

		}

		// TODO Comprobar el campo de geometria

		EditableFeatureType dbfFtype = fType.getEditable();

		this.removeGeometryColumn(dbfFtype);

		SHPFeatureWriter writer = null;

		try {

			this.shpResource.begin();

			FeatureSet set = this.store.getFeatureSet();

			writer = new SHPFeatureWriter(this.getName());

			writer.begin(this.shpParams, fType, dbfFtype, set.getSize());

			Iterator iter = set.iterator();

			while (iter.hasNext()) {

				writer.write((Feature) iter.next());

			}

			writer.end();

			shpResource.notifyChanges();

		} catch (Exception e) {

			throw new PerformEditingException(this.getName(), e);

		} finally {

			shpResource.end();

		}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		SHPNewStoreParameters params = (SHPNewStoreParameters) parameters;

		FeatureType fType = params.getDefaultFeatureType();

		// TODO Comprobar que el campo de geometria

		EditableFeatureType dbfFtype = fType.getEditable();

		this.removeGeometryColumn(dbfFtype);

		File shpFile = params.getSHPFile();

		File shxFile = params.getSHXFile();

		if (shpFile.exists()) {

			if (overwrite) {

				if (!shpFile.delete()) {

					throw new CreateException(this.getName(), new IOException(

							"cannot delete file: " + shpFile.getPath()));

				}

				if (shxFile.exists()) {

					if (!shxFile.delete()) {

						throw new CreateException(this.getName(),

								new IOException("cannot delete file: "

										+ shxFile.getPath()));

					}

				}

			} else {

				throw new CreateException(this.getName(), new IOException(

						"file already exist"));

			}

		}

		FileResource resource;

		try {

			resource = (FileResource) this.createResource(FileResource.NAME,

					new Object[] { shpFile.getAbsolutePath() });

		} catch (InitializeException e1) {

			throw new CreateException(shpFile.getPath(), e1);

		}

		resource.addConsumer(this);

		SHPFeatureWriter writer = null;

		try {

			resource.begin();

			writer = new SHPFeatureWriter(this.getName());

			writer.begin(params, fType, dbfFtype, 0);

			writer.end();

			resource.notifyChanges();

		} catch (Exception e) {

			throw new CreateException(this.getName(), e);

		} finally {

			resource.end();

			resource.removeConsumer(this);

		}

	}

	protected NewDataStoreParameters createInstanceNewDataStoreParameters() {

		return new SHPNewStoreParameters();

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		SHPNewStoreParameters params = (SHPNewStoreParameters) super

				.getCreateParameters();

		EditableFeatureType fType = params.getDefaultFeatureType().getEditable();

		this.addGeometryColumn(fType);

		params.setDefaultFeatureType(fType);

		return params;

	}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.dal.store.shp;

import java.io.File;

import java.io.IOException;

import java.nio.channels.FileChannel;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.WriteException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.store.dbf.DBFFeatureWriter;

import org.gvsig.fmap.dal.store.dbf.DBFStoreParameters;

import org.gvsig.fmap.dal.store.shp.utils.SHPFileWrite;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.DefaultEnvelope;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.NullGeometry;

public class SHPFeatureWriter extends DBFFeatureWriter {

	private SHPFileWrite shpWrite;

	private Envelope envelope;

	private long fileSize;

	private int[] supportedGeometryTypes;

	private Geometry defaultGeometry;

	protected SHPFeatureWriter(String name) {

		super(name);

	}

	public void begin(DBFStoreParameters dbfParameters,

			FeatureType featureType, FeatureType dbfFeatureType, long numRows)

			throws DataException {

		super.begin(dbfParameters, featureType, numRows);

		SHPStoreParameters shpParameters = (SHPStoreParameters) dbfParameters;

		File shpFile = shpParameters.getSHPFile();

		File shxFile = shpParameters.getSHXFile();

		FileChannel shpChannel = null;

		FileChannel shxChannel = null;

		try {

			shpChannel = (FileChannel) getWriteChannel(shpFile

					.getAbsolutePath());

			shxChannel = (FileChannel) getWriteChannel(shxFile

					.getAbsolutePath());

		} catch (IOException e) {

			throw new WriteException(this.name, e);

		}

		shpWrite = new SHPFileWrite(shpChannel, shxChannel);

		int gvSIG_geometryType =featureType.getAttributeDescriptor(

				featureType.getDefaultGeometryAttributeIndex())

				.getGeometryType();

		this.setSupportedGeometryTypes(gvSIG_geometryType);

		int shapeType = 0;

		shapeType = shpWrite

				.getShapeType(gvSIG_geometryType);

		defaultGeometry= (Geometry) featureType.getAttributeDescriptor(

				featureType.getDefaultGeometryAttributeIndex()).getDefaultValue();

		if (defaultGeometry == null){

			defaultGeometry = new NullGeometry();

		}

		envelope = new DefaultEnvelope(2);

		shpWrite.writeHeaders(envelope, shapeType,(int) numRows, 0); //FIXME long!!!

	}

	public void dispose() {

		super.dispose();

		this.envelope = null;

		this.shpWrite = null;

	}

	public void end() throws DataException {

		super.end();

		shpWrite.close();

	}

	public void write(Feature feature) throws DataException {

		Geometry theGeom = feature.getDefaultGeometry();

		if (theGeom==null){

			theGeom=this.defaultGeometry;

		}

		if (!canWriteGeometry(theGeom.getType())){

			throw new WriteException(this.name, // FIXME Excepcion correcta

					new RuntimeException("UnsupportedGeometryType: "+ theGeom.getGeometryType().getName()));

		}

		super.write(feature);

		fileSize = shpWrite.writeIGeometry(theGeom);

		Envelope envelope = theGeom.getEnvelope();

		if (envelope!=null){

			this.envelope.add(envelope);

		}

	}

	private void setSupportedGeometryTypes(int gvSIG_geometryType) {

		switch (gvSIG_geometryType % Geometry.TYPES.Z)

		{

		case Geometry.TYPES.POINT:

			supportedGeometryTypes = new int[] {Geometry.TYPES.POINT, Geometry.TYPES.NULL };

			break;

		case Geometry.TYPES.MULTIPOINT:

			supportedGeometryTypes = new int[] {Geometry.TYPES.MULTIPOINT, Geometry.TYPES.NULL };

			break;

		case Geometry.TYPES.CURVE:

			supportedGeometryTypes = new int[] {Geometry.TYPES.CURVE, Geometry.TYPES.ELLIPSE,

				Geometry.TYPES.ARC, Geometry.TYPES.CIRCLE, Geometry.TYPES.SURFACE, Geometry.TYPES.NULL };

			break;

		case Geometry.TYPES.SURFACE:

			supportedGeometryTypes = new int[] {Geometry.TYPES.ELLIPSE,

				Geometry.TYPES.CIRCLE, Geometry.TYPES.SURFACE, Geometry.TYPES.NULL };

			break;

		default:

			supportedGeometryTypes = new int[] {};

		}

	}

	public boolean canWriteGeometry(int gvSIGgeometryType) {

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

		{

			if (gvSIGgeometryType == supportedGeometryTypes[i] ||

				gvSIGgeometryType == (supportedGeometryTypes[i] | Geometry.TYPES.Z)) {

				return true;

			}

		}

		return false;

	}

	public void begin(DBFStoreParameters storeParameters,

			FeatureType featureType, long numRows) throws DataException {

		throw new UnsupportedOperationException();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.dal.store.shp;

import java.io.File;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.store.dbf.DBFNewStoreParameters;

import org.gvsig.fmap.dal.store.shp.utils.SHP;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

public class SHPNewStoreParameters extends DBFNewStoreParameters {

	public DataStoreParameters initialize() {

		super.initialize();

		this.addParameter("shpfilename", DataTypes.STRING,

				"Ruta al fichero shp",

				null);

		this.addAttributeAlias("shpfilename", "filename");

		this.addParameter("shxfilename", DataTypes.STRING,

				"Ruta al fichero shx",

				null);

		this.addParameter("srs", DataTypes.STRING, "SRS", null);

		return this;

	}

	public String getDataStoreName() {

		return SHPStoreProvider.NAME;

	}

	public boolean isValid() {

		return super.isValid() && (this.getSHPFileName() != null);

	}

	public File getFile() {

		return new File(this.getSHPFileName());

	}

	public void setFile(File aFile) {

		this.setSHPFile(aFile);

	}

	public String getSHPFileName() {

		return (String) this.getAttribute("shpfilename");

	}

	public File getSHPFile() {

		return new File((String) this.getAttribute("shpfilename"));

	}

	public void setSHPFile(File aFile) {

		this.setAttribute("shpfilename", aFile.getPath());

		if (this.getDBFFileName() == null) {

			this.setDBFFile(SHP.getDbfFile(aFile));

		}

		if (this.getSHXFileName() == null) {

			this.setSHXFile(SHP.getShxFile(aFile));

		}

	}

	public void setSHPFileName(String aFileName) {

		this.setAttribute("shpfilename", aFileName);

		if (this.getDBFFileName() == null) {

			this.setDBFFile(SHP.getDbfFile(new File(aFileName)));

		}

		if (this.getSHXFileName() == null) {

			this.setSHXFile(SHP.getShxFile(new File(aFileName)));

		}

	}

	public String getSHXFileName() {

		return (String) this.getAttribute("shxfilename");

	}

	public File getSHXFile() {

		return new File((String) this.getAttribute("shxfilename"));

	}

	public void setSHXFile(File aFile) {

		this.setAttribute("shxfilename", aFile.getPath());

	}

	public void setSHXFileName(String aFileName) {

		this.setAttribute("shxfilename", aFileName);

	}

	public String getDescription() {

		return SHPStoreProvider.DESCRIPTION;

	}

	public void getState(PersistentState arg0) throws PersistenceException {

		// TODO Auto-generated method stub

		throw new NotYetImplemented();

	}

	public void setState(PersistentState state) throws PersistenceException {

		// TODO Auto-generated method stub

		super.setState(state);

		throw new NotYetImplemented();

	}

}

		this.addParameter("shpfilename", DataTypes.STRING,

				"Ruta al fichero shp",

		this.addAttributeAlias("shpfilename", "filename");

		this.addParameter("shxfilename", DataTypes.STRING,

				"Ruta al fichero shx",

		return super.isValid() && (this.getSHPFileName() != null);

		return new File(this.getSHPFileName());

	public String getSHPFileName() {

		return (String) this.getAttribute("shpfilename");

	public File getSHPFile() {

		return new File((String) this.getAttribute("shpfilename"));

		this.setAttribute("shpfilename", aFile.getPath());

		if (this.getSHXFileName() == null) {

	public void setSHPFileName(String aFileName) {

		this.setAttribute("shpfilename", aFileName);

		if (this.getSHXFileName() == null) {

	public String getSHXFileName() {

		return (String) this.getAttribute("shxfilename");

	public File getSHXFile() {

		return new File((String) this.getAttribute("shxfilename"));

		this.setAttribute("shxfilename", aFile.getPath());

	public void setSHXFileName(String aFileName) {

		this.setAttribute("shxfilename", aFileName);

	public void performEditing(Iterator deleteds, Iterator inserteds,

			Iterator updateds)

			throws PerformEditingException {

			DBFFeatureWriter writer = new DBFFeatureWriter(this.getName());

			writer.begin(this.getDBFParameters(), this.store

					.getDefaultFeatureType(), set.getSize());

				writer.write((Feature) iter.next());

			writer.end();

		File file = params.getDBFFile();

			DBFFeatureWriter writer = new DBFFeatureWriter(this.getName());

			writer.begin(params, params.getDefaultFeatureType(), 0);

			writer.end();

			writer.dispose();

	protected NewDataStoreParameters createInstanceNewDataStoreParameters() {

		return new DBFNewStoreParameters();

	}

		DBFNewStoreParameters params = (DBFNewStoreParameters) this

				.createInstanceNewDataStoreParameters();

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.dal.store.dbf;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.channels.FileChannel;

import java.nio.channels.WritableByteChannel;

import java.nio.charset.Charset;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.WriteException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.exception.AttributeFeatureTypeNotSuportedException;

import org.gvsig.fmap.dal.store.dbf.utils.DbaseFileHeader;

import org.gvsig.fmap.dal.store.dbf.utils.DbaseFileWriter;

public class DBFFeatureWriter {

	private DbaseFileWriter dbfWriter = null;

	protected String name;

	protected DBFFeatureWriter(String name) {

		this.name= name;

	}

	public void begin(DBFStoreParameters storeParameters,

			FeatureType featureType, long numRows) throws DataException {

		File file = storeParameters.getDBFFile();

		DbaseFileHeader myHeader;

		try {

			myHeader = DbaseFileHeader.createDbaseHeader(featureType);

		} catch (AttributeFeatureTypeNotSuportedException e1) {

			throw new WriteException(this.name, e1);

		}

		myHeader.setNumRecords((int) numRows); //FIXME long !!!

		try {

			this.dbfWriter = new DbaseFileWriter(myHeader,

					(FileChannel) getWriteChannel(file.getAbsolutePath()));

			dbfWriter.setCharset(Charset.forName("ISO-8859-1")); // FIXME !!!! y actualizar codePage

		} catch (IOException e) {

			throw new WriteException(this.name, e);

		} catch (InitializeException e) {

			throw new WriteException(this.name, e);

		}

	}

	public void write(Feature feature) throws DataException {

		dbfWriter.append(feature);

	}

	public void end() throws DataException {

		dbfWriter.close();

	}

	public void dispose() {

		dbfWriter = null;

	}

	protected static WritableByteChannel getWriteChannel(String path)

	throws IOException {

		WritableByteChannel channel;

		File f = new File(path);

		if (!f.exists()) {

			//			System.out.println("Creando fichero " + f.getAbsolutePath());

			if (!f.createNewFile()) {

				System.err.print("Error al crear el fichero "

						+ f.getAbsolutePath());

				throw new IOException("Cannot create file " + f);

			}

		}

		RandomAccessFile raf = new RandomAccessFile(f, "rw");

		channel = raf.getChannel();

		return channel;

	}

}

/**

 * A DbaseFileReader is used to read a dbase III format file. The general use of

 * this class is: <CODE><PRE>

 * </PRE></CODE> You must supply the <CODE>moreRecords</CODE> and

 * <CODE>getMyRecord()</CODE> logic...

 *

public class DbaseFileWriter {

	private DbaseFileHeader header;

	private DbaseFileWriter.FieldFormatter formatter = new DbaseFileWriter.FieldFormatter();

	FileChannel channel;

	private ByteBuffer buffer;

	private final Number NULL_NUMBER = new Integer(0);

	private final String NULL_STRING = "";

	private final String NULL_DATE = "        ";

	private boolean headDrity = false;

	// TODO: READ HEADER AND STABLIST THE RIGHT CHARSET

	private Charset charset = Charset.forName("ISO-8859-1");

	/**

	 * Create a DbaseFileWriter using the specified header and writing to the

	 * given channel.

	 *

	 * @param header

	 *            The DbaseFileHeader to write.

	 * @param out

	 *            The Channel to write to.

	 * @throws InitializeWriterException

	 * @throws IOException

	 *             If errors occur while initializing.

	 */

	public DbaseFileWriter(DbaseFileHeader header, FileChannel out)

		this.header = header;

		this.channel = out;

		init();

	private void init() throws InitializeException {

		try {

			if (this.channel.size() < this.header.getHeaderLength()) {

				this.writeHeader();

			}

			buffer = ByteBuffer.allocateDirect(header.getRecordLength());

		} catch (Exception e) {

			throw new InitializeException("DBF Writer", e);

		}

	}

	private void write() throws WriteException {

		buffer.position(0);

		int r = buffer.remaining();

		try {

			while ((r -= channel.write(buffer)) > 0) {

				; // do nothing

			}

		} catch (IOException e) {

			throw new WriteException("DBF Writer", e);

		}

	private void writeHeader() throws WriteException {

		try {

			channel.position(0);

			header.writeHeader(channel);

		} catch (IOException e) {

			throw new WriteException("DBF Writer", e);

	/**

	 * Write a single dbase record.

	 *

	 * @param record

	 *            The entries to write.

	 * @throws UnsupportedEncodingException

	 * @throws WriteException

	 */

	public void append(Feature feature) throws WriteException,

			UnsupportedEncodingException {

		this.fillBuffer(feature);

		try {

			this.moveToEOF();

		} catch (IOException e) {

			throw new WriteException("DbaseFileWriter", e);

		}

		write();

		this.header.setNumRecords(this.header.getNumRecords() + 1);

		this.headDrity = true;

	}

	private void fillBuffer(Feature feature)

			throws UnsupportedEncodingException {

		FeatureType featureType = feature.getType();

		buffer.position(0);

		// put the 'not-deleted' marker

		buffer.put((byte) ' ');

		Iterator iterator = featureType.iterator();

		while (iterator.hasNext()) {

			FeatureAttributeDescriptor fad = (FeatureAttributeDescriptor) iterator

					.next();

			int type = fad.getDataType();

			int i = fad.getIndex(); // TODO comprobar

			//		  int i=fad.ordinal();

			String fieldString = fieldString(type, feature, i);

			if (fieldString == null) {

				if (type == DataTypes.STRING) {

					fieldString = NULL_STRING;

				} else if (type == DataTypes.DATE) {

					fieldString = NULL_DATE;

				} else {

					fieldString = "0";

				}

			}

			try {

				buffer.put(fieldString.getBytes(charset.name()));

			} catch (java.io.UnsupportedEncodingException e) {

				throw new UnsupportedEncodingException(e);

			}

		}

	private void moveToEOF() throws IOException {

		this.moveTo(this.header.getNumRecords() + 1);

	}

	private void moveTo(long numReg) throws IOException {

		//		if (!(channel instanceof FileChannel)) {

		//			throw new IOException(

		//							"DbaseFileWriterNIO: channel is not a FileChannel. Cannot position properly");

		//		}

		long newPos = header.getHeaderLength() + numReg

				* header.getRecordLength();

		if (this.channel.position() != newPos) {

			this.channel.position(newPos);

		}

	}

	/**

	 * Write a single dbase record. Useful to update a dbf.

	 *

	 * @param record

	 *            The entries to write.

	 * @throws WriteException

	 * @throws UnsupportedEncodingException

	 */

	public void update(Feature feature, long numReg) throws WriteException,

			UnsupportedEncodingException {

		this.fillBuffer(feature);

		try {

			this.moveTo(numReg);

		} catch (IOException e) {

			throw new WriteException("DbaseFileWriter", e);

		}

		write();

	private String fieldString(int type, Feature feature, int i) {

		final int fieldLen = header.getFieldLength(i);

		String fieldString = "";

		if (DataTypes.BOOLEAN == type) {

			boolean b = feature.getBoolean(i);