Application: gvSIG desktop

import java.text.FieldPosition;

import java.text.NumberFormat;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Locale;

 * 

    private DbaseFileHeader header;

    private DbaseFileWriter.FieldFormatter formatter =

        new DbaseFileWriter.FieldFormatter();

    FileChannel channel;

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

     * 

     * @param header

     *            The DbaseFileHeader to write.

     * @param out

     *            The Channel to write to.

     * 

     * 

     * @throws InitializeWriterException

     * @throws IOException

     *             If errors occur while initializing.

        boolean isNew) throws InitializeException {

        ((Buffer)buffer).position(0);

                ; // do nothing

            header.writeHeader(channel);

     * 

     * @param record

     *            The entries to write.

        UnsupportedEncodingException {

        throws UnsupportedEncodingException, WriteException {

            ((Buffer)buffer).position(0);

            Iterator<FeatureAttributeDescriptor> iterator =

                featureType.iterator();

                        "DBF file", fad.getName());

        long newPos =

            header.getHeaderLength() + numReg * header.getRecordLength();

     * 

     * @param record

     *            The entries to write.

        UnsupportedEncodingException {

    private String fieldString(FeatureAttributeDescriptor attr, Feature feature) throws java.io.UnsupportedEncodingException {

        int dbfFieldIndex = this.header.getFieldIndex(attr.getName());

        final int fieldLen = header.getFieldLength(dbfFieldIndex);

        String fieldString = "";

        //

        // https://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm

        //

            if (b) {

                fieldString = "T";

            } else {

                fieldString = "F";

            }

        } else

            if (DataTypes.BYTE == type) {

                fieldString = String.valueOf(feature.getByte(attr.getIndex()));

            } else

                if (DataTypes.DATE == type) {

                    Date date = feature.getDate(attr.getIndex());

                    fieldString = formatter.getFieldString(date);

                } else

                    if (DataTypes.DOUBLE == type) {

                        double d = feature.getDouble(attr.getIndex());

                        fieldString =

                            formatter.getFieldString(fieldLen,

                                header.getFieldDecimalCount(dbfFieldIndex), d);

                    } else

                        if (DataTypes.FLOAT == type) {

                            float f = feature.getFloat(attr.getIndex());

                            fieldString =

                                formatter.getFieldString(fieldLen,

                                    header.getFieldDecimalCount(dbfFieldIndex),

                                    f);

                        } else

                            if (DataTypes.INT == type) {

                                int integer = feature.getInt(attr.getIndex());

                                fieldString =

                                    formatter.getFieldString(fieldLen, header

                                        .getFieldDecimalCount(dbfFieldIndex),

                                        integer);

                            } else

                                if (DataTypes.LONG == type) {

                                    long l = feature.getLong(attr.getIndex());

                                    fieldString =

                                        formatter

                                            .getFieldString(

                                                fieldLen,

                                                header

                                                    .getFieldDecimalCount(dbfFieldIndex),

                                                l);

                                } else

                                    if (DataTypes.STRING == type) {

                                        String s =

                                            feature.getString(attr.getIndex());

                                        return s;

                                    }

        return fieldString;

    }

    private void encodeField(FeatureAttributeDescriptor attr, Feature feature) throws java.io.UnsupportedEncodingException, UnsupportedEncodingException {

        int type = attr.getType();

        int dbfFieldIndex = this.header.getFieldIndex(attr.getName());

        final int fieldLen = header.getFieldLength(dbfFieldIndex);

        String fieldString = "";

        if( DataTypes.BOOLEAN == type ) {

            boolean b = feature.getBoolean(attr.getIndex());

            if( b ) {

                safeEncode("T", 1, true);

            } else {

                safeEncode("F", 1, true);

            }

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

            fieldString = String.valueOf(feature.getByte(attr.getIndex()));

            safeEncode(fieldString, 8, false);

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

            fieldString = formatter.getFieldString(date);

            safeEncode(fieldString, 8, false);

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

            double d = feature.getDouble(attr.getIndex());

            fieldString  = formatter.getFieldString(

                fieldLen, header.getFieldDecimalCount(dbfFieldIndex), d

            );

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

            float f = feature.getFloat(attr.getIndex());

            fieldString = formatter.getFieldString(

                fieldLen, header.getFieldDecimalCount(dbfFieldIndex), f

            );

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

            int integer = feature.getInt(attr.getIndex());

            fieldString = formatter.getFieldString(

                fieldLen, header.getFieldDecimalCount(dbfFieldIndex), integer

            );

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

            fieldString = formatter.getFieldString(

                fieldLen, header.getFieldDecimalCount(dbfFieldIndex),l

            );

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

     * Returns a safely padded (and potentially truncated) string 

     * 

     * This may truncate some record, but it is required to ensure

     * that the field limit is not overflowed when using 

     * variable-length charsets such as UTF-8.

     * @throws UnsupportedEncodingException 

    	try {

    		byte[] encodedString = in.getBytes(this.charset);

    		if (encodedString.length>limit) {

    			// too long, truncating

    			/*

    			 */

    			String str = in;

    			int estimatedDiff, deviation;

    			int deviationPrev;

    			double ratio;

    			byte[] encodedChar;

    			int truncatePos = 0;

    			deviation = encodedString.length - limit;

    			deviationPrev = deviation - 1;

    			while(Math.abs(deviation)>Math.abs(deviationPrev) && str.length()>0) {

    				ratio = ((double)encodedString.length) / ((double)str.length());

    				// apply the estimated diff, ensuring it is at least >= 1.0 in absolute value

    				estimatedDiff = Math.max((int)(((double)deviation)/ratio), (int)(Math.signum(deviation)*1));

    				// too long, truncating

    				if (rightPadding) {

    					truncatePos = Math.max(str.length()-estimatedDiff, 0);

    					str = in.substring(0, truncatePos);

    				}

    				else {

    					truncatePos = Math.max(truncatePos + estimatedDiff, 0);

    					str = in.substring(truncatePos);				  

    				}

    				encodedString = str.getBytes(charset);

    				deviationPrev = deviation;

    				deviation = encodedString.length - limit;

    			}

    			// now we are close enough, get the exact position for truncating

    			while (encodedString.length>limit) {

    				// too long, truncating

    				//    				  System.out.println("truncating");

    				if (rightPadding) {

    					str = in.substring(0, str.length()-1);

    				}

    				else {

    					truncatePos = truncatePos + 1;

    					str = in.substring(truncatePos);

    				}

    				encodedString = str.getBytes(charset);

    			}

    			while (encodedString.length<limit && str.length()<in.length()) {

    				// Extend if necessary:

    				// 1 - Get the length in bytes of the next char

    				// 2 - Add the char to the substring if we are still within the limits 

    				//    				  System.out.println("extending");

    				if (rightPadding) {

    					encodedChar = in.substring(str.length(), str.length()+1).getBytes(charset);

    				}

    				else {

    					encodedChar = in.substring(truncatePos-1, truncatePos).getBytes(charset);

    					//    					  System.out.println(encodedChar);

    					//    					  System.out.println(encodedChar.length);

    					//    					  System.out.println(testStrings[i].substring(truncatePos-1, truncatePos));

    				}

    				//    				  System.out.println(testStrings[i].substring(in.length(), in.length()+1));

    				if ((encodedString.length + encodedChar.length)>limit) {

    					// one more char would overflow the limit

    					break;

    				}

    				// too short, extending

    				if (rightPadding) {

    					str = in.substring(0, str.length()+1);

    				}

    				else {

    					truncatePos = truncatePos - 1;

    					str = in.substring(truncatePos);

    				}

    				encodedString = str.getBytes(charset);

    			}

    		}

    		if (rightPadding) {

    			buffer.put(encodedString);

    		}

    		if (encodedString.length<limit) {

    			// too short, padding

    			int i = encodedString.length;

    			while (i<limit) {

    				((Buffer)blank).position(0);

    				buffer.put(blank);

    				i=i+blankSize;

    			}

    			if (i>limit) {

    				// Might happen for instance if charset is UTF16 and the

    				// limit of characters in the field is an odd number

    				throw new UnsupportedEncodingException(new Exception("Impossible to encode this DBF using the selected charset"));

    			}

    		}

    		if (!rightPadding) {

    			buffer.put(encodedString);

    		}

    	}

		catch(BufferOverflowException exc) {

			// Might happen for instance if charset is UTF16 and the

			// limit of characters in the field is an odd number

			throw new UnsupportedEncodingException(exc);

		}

    /**

     * Returns a safely padded (and potentially truncated) string 

     * 

     * This may truncate some record, but it is required to ensure

     * that the field limit is not overflowed when using 

     * variable-length charsets such as UTF-8.

     * 

     * This implementation is not used but it is kept here for reference.

     * It is fully equivalent to the {@link #safeEncode(String, int, boolean)}

     * method and easier to understand, but this implementation is much

     * slower for any multibyte charset (such as UTF-8).

     *  

     * @throws UnsupportedEncodingException 

     */

    private void safeEncodeSlow(String in, int limit, boolean rightPadding) throws UnsupportedEncodingException {

    	try {

    		byte[] encodedString = in.getBytes(this.charset);

    		while (encodedString.length>limit) {

    			// too long, truncating

    			if (rightPadding) {

    				in = in.substring(0, in.length()-1);

    				encodedString = in.getBytes(charset);

    			}

    			else {

    				in.substring(1, in.length());

    				encodedString = in.getBytes(charset);

    			}

    		}

    		if (rightPadding) {

    			buffer.put(encodedString);

    		}

    		if (encodedString.length<limit) {

    			// too short, padding

    			int i = encodedString.length;

    			while (i<limit) {

    				((Buffer)blank).position(0);

    				buffer.put(blank);

    				i=i+blankSize;

    			}

    			if (i>limit) {

    				throw new UnsupportedEncodingException(new Exception("Impossible to encode this DBF using the selected charset"));

    			}

    		}

    		if (!rightPadding) {

    			buffer.put(encodedString);

    		}

    	}

    	catch(BufferOverflowException exc) {

    		// Might happen for instance if charset is UTF16 and the

    		// limit of characters in the field is an odd number

    		throw new UnsupportedEncodingException(exc);

    	}

    }

     * 

     * @throws IOException

     *             If errors occur.

    /** Utility for formatting Dbase fields. */

    public static class FieldFormatter {

        private StringBuffer buffer = new StringBuffer(255);

        private NumberFormat numFormat = NumberFormat

            .getNumberInstance(Locale.US);

        private Calendar calendar = Calendar.getInstance(Locale.US);

        private String emtpyString;

        private static final int MAXCHARS = 255;

        public FieldFormatter() {

            // Avoid grouping on number format

            numFormat.setGroupingUsed(false);

            // build a 255 white spaces string

            StringBuffer sb = new StringBuffer(MAXCHARS);

            sb.setLength(MAXCHARS);

            for (int i = 0; i < MAXCHARS; i++) {

                sb.setCharAt(i, ' ');

            }

            emtpyString = sb.toString();

        }

        public String getFieldString(int size, String s) {

            buffer.replace(0, size, emtpyString);

            buffer.setLength(size);

            if (s != null) {

                buffer.replace(0, size, s);

                if (s.length() <= size) {

                    for (int i = s.length(); i < size; i++) {

                        buffer.append(' ');

                    }

                }

            }

            buffer.setLength(size);

            return buffer.toString();

        }

        public String getFieldString(Date d) {

            if (d != null) {

                buffer.delete(0, buffer.length());

                calendar.setTime(d);

                int year = calendar.get(Calendar.YEAR);

                int month = calendar.get(Calendar.MONTH) + 1; // returns 0 based

                                                              // month?

                int day = calendar.get(Calendar.DAY_OF_MONTH);

                if (year < 1000) {

                    if (year >= 100) {

                        buffer.append("0");

                    } else

                        if (year >= 10) {

                            buffer.append("00");

                        } else {

                            buffer.append("000");

                        }

                }

                buffer.append(year);

                if (month < 10) {

                    buffer.append("0");

                }

                buffer.append(month);

                if (day < 10) {

                    buffer.append("0");

                }

                buffer.append(day);

            } else {

                buffer.setLength(8);

                buffer.replace(0, 8, emtpyString);

            }

            buffer.setLength(8);

            return buffer.toString();

        }

        public String getFieldString(int size, int decimalPlaces, double n) {

            buffer.delete(0, buffer.length());

            numFormat.setMaximumFractionDigits(decimalPlaces);

            numFormat.setMinimumFractionDigits(decimalPlaces);

            numFormat.format(n, buffer, new FieldPosition(

                NumberFormat.INTEGER_FIELD));

            return buffer.toString();

        }

    }

    	blank = charset.encode(" ");

    	blankSize = blank.limit();