/ - Diff - Application: gvSIG desktop - gvSIG

Revision 2269

     package com.iver.cit.gvsig.fmap.drivers;
     import com.iver.cit.gvsig.fmap.core.FGeometry;
     import com.iver.cit.gvsig.fmap.core.FMultiPoint2D;
     import com.iver.cit.gvsig.fmap.core.FPoint2D;
     import com.iver.cit.gvsig.fmap.core.FPolygon2D;
     import com.iver.cit.gvsig.fmap.core.FPolyline2D;
     import com.iver.cit.gvsig.fmap.core.GeneralPathX;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     import com.iver.cit.gvsig.fmap.core.ShapeFactory;
     import com.vividsolutions.jts.geom.Coordinate;
     import com.vividsolutions.jts.io.ParseException;
     import java.awt.geom.Point2D;
     import java.io.IOException;
     import java.io.Reader;
     import java.io.StreamTokenizer;
     import java.io.StringReader;
     import java.util.ArrayList;
     /**
      *  Converts a Well-Known Text string to a <code>Geometry</code>.
      * <p>
      *  The <code>WKTReader</code> allows
      *  extracting <code>Geometry</code> objects from either input streams or
      *  internal strings. This allows it to function as a parser to read <code>Geometry</code>
      *  objects from text blocks embedded in other data formats (e.g. XML). <P>
      * <p>
      * The Well-known
      *  Text format is defined in the <A HREF="http://www.opengis.org/techno/specs.htm">
      *  OpenGIS Simple Features Specification for SQL</A> . <P>
      * <p>
      *  <B>Note: </B> There is an inconsistency in the SFS. The WKT grammar states
      *  that <code>MultiPoints</code> are represented by <code>MULTIPOINT ( ( x y), (x y) )</code>
      *  , but the examples show <code>MultiPoint</code>s as <code>MULTIPOINT ( x y, x y )</code>
      *  . Other implementations follow the latter syntax, so JTS will adopt it as
      *  well.
+     *
      *  A <code>WKTReader</code> is parameterized by a <code>GeometryFactory</code>
      *  , to allow it to create <code>Geometry</code> objects of the appropriate
      *  implementation. In particular, the <code>GeometryFactory</code> will
      *  determine the <code>PrecisionModel</code> and <code>SRID</code> that is
      *  used. <P>
+     *
      *  The <code>WKTReader</code> will convert the input numbers to the precise
      *  internal representation.
+     *
      *  Reads non-standard "LINEARRING" tags.
+     *
      *@version 1.5
      */
     public class WKTParser {
       /**
        * Creates a WKTReader that creates objects using a basic GeometryFactory.
        */
       public WKTParser() {
+      }
     	/**
          * Converts a Well-known Text representation to a <code>Geometry</code>.
+         *
          * @param wellKnownText
          *            one or more <Geometry Tagged Text>strings (see the OpenGIS
          *            Simple Features Specification) separated by whitespace
          * @return a <code>Geometry</code> specified by <code>wellKnownText</code>
          * @throws ParseException
          *             if a parsing problem occurs
     	 */
       public IGeometry read(String wellKnownText) throws ParseException {
         StringReader reader = new StringReader(wellKnownText);
         try {
           return read(reader);
+        }
         finally {
           reader.close();
+        }
+      }
       /**
        *  Converts a Well-known Text representation to a <code>Geometry</code>.
+       *
        *@param  reader           a Reader which will return a <Geometry Tagged Text>
        *      string (see the OpenGIS Simple Features Specification)
        *@return                  a <code>Geometry</code> read from <code>reader</code>
        *@throws  ParseException  if a parsing problem occurs
        */
       public IGeometry read(Reader reader) throws ParseException {
         StreamTokenizer tokenizer = new StreamTokenizer(reader);
         try {
           return readGeometryTaggedText(tokenizer);
+        }
         catch (IOException e) {
           throw new ParseException(e.toString());
+        }
+      }
       /**
        *  Returns the next array of <code>Coordinate</code>s in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next element returned by the stream should be "(" (the
        *      beginning of "(x1 y1, x2 y2, ..., xn yn)") or "EMPTY".
        *@return                  the next array of <code>Coordinate</code>s in the
        *      stream, or an empty array if "EMPTY" is the next element returned by
        *      the stream.
        *@throws  IOException     if an I/O error occurs
        *@throws  ParseException  if an unexpected token was encountered
        */
       private Coordinate[] getCoordinates(StreamTokenizer tokenizer)
           throws IOException, ParseException
+      {
         String nextToken = getNextEmptyOrOpener(tokenizer);
         if (nextToken.equals("EMPTY")) {
           return new Coordinate[]{};
+        }
         ArrayList coordinates = new ArrayList();
         coordinates.add(getPreciseCoordinate(tokenizer));
         nextToken = getNextCloserOrComma(tokenizer);
         while (nextToken.equals(",")) {
           coordinates.add(getPreciseCoordinate(tokenizer));
           nextToken = getNextCloserOrComma(tokenizer);
+        }
         Coordinate[] array = new Coordinate[coordinates.size()];
         return (Coordinate[]) coordinates.toArray(array);
+      }
       private Coordinate getPreciseCoordinate(StreamTokenizer tokenizer)
           throws IOException, ParseException
+      {
         Coordinate coord = new Coordinate();
         coord.x = getNextNumber(tokenizer);
         coord.y = getNextNumber(tokenizer);
         if (isNumberNext(tokenizer)) {
             coord.z = getNextNumber(tokenizer);
+        }
         return coord;
+      }
       private boolean isNumberNext(StreamTokenizer tokenizer) throws IOException {
           try {
               return tokenizer.nextToken() == StreamTokenizer.TT_NUMBER;
+          }
           finally {
               tokenizer.pushBack();
+          }
+      }
       /**
        *  Returns the next number in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next token must be a number.
        *@return                  the next number in the stream
        *@throws  ParseException  if the next token is not a number
        *@throws  IOException     if an I/O error occurs
        */
       private double getNextNumber(StreamTokenizer tokenizer) throws IOException,
           ParseException {
         int type = tokenizer.nextToken();
         switch (type) {
           case StreamTokenizer.TT_EOF:
             throw new ParseException("Expected number but encountered end of stream");
           case StreamTokenizer.TT_EOL:
             throw new ParseException("Expected number but encountered end of line");
           case StreamTokenizer.TT_NUMBER:
             return tokenizer.nval;
           case StreamTokenizer.TT_WORD:
             throw new ParseException("Expected number but encountered word: " +
                 tokenizer.sval);
           case '(':
             throw new ParseException("Expected number but encountered '('");
           case ')':
             throw new ParseException("Expected number but encountered ')'");
           case ',':
             throw new ParseException("Expected number but encountered ','");
+        }
         return 0;
+      }
       /**
        *  Returns the next "EMPTY" or "(" in the stream as uppercase text.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next token must be "EMPTY" or "(".
        *@return                  the next "EMPTY" or "(" in the stream as uppercase
        *      text.
        *@throws  ParseException  if the next token is not "EMPTY" or "("
        *@throws  IOException     if an I/O error occurs
        */
       private String getNextEmptyOrOpener(StreamTokenizer tokenizer) throws IOException, ParseException {
         String nextWord = getNextWord(tokenizer);
         if (nextWord.equals("EMPTY") || nextWord.equals("(")) {
           return nextWord;
+        }
         throw new ParseException("Expected 'EMPTY' or '(' but encountered '" +
             nextWord + "'");
+      }
       /**
        *  Returns the next ")" or "," in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next token must be ")" or ",".
        *@return                  the next ")" or "," in the stream
        *@throws  ParseException  if the next token is not ")" or ","
        *@throws  IOException     if an I/O error occurs
        */
       private String getNextCloserOrComma(StreamTokenizer tokenizer) throws IOException, ParseException {
         String nextWord = getNextWord(tokenizer);
         if (nextWord.equals(",") || nextWord.equals(")")) {
           return nextWord;
+        }
         throw new ParseException("Expected ')' or ',' but encountered '" + nextWord
              + "'");
+      }
       /**
        *  Returns the next ")" in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next token must be ")".
        *@return                  the next ")" in the stream
        *@throws  ParseException  if the next token is not ")"
        *@throws  IOException     if an I/O error occurs
        */
       private String getNextCloser(StreamTokenizer tokenizer) throws IOException, ParseException {
         String nextWord = getNextWord(tokenizer);
         if (nextWord.equals(")")) {
           return nextWord;
+        }
         throw new ParseException("Expected ')' but encountered '" + nextWord + "'");
+      }
       /**
        *  Returns the next word in the stream as uppercase text.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next token must be a word.
        *@return                  the next word in the stream as uppercase text
        *@throws  ParseException  if the next token is not a word
        *@throws  IOException     if an I/O error occurs
        */
       private String getNextWord(StreamTokenizer tokenizer) throws IOException, ParseException {
         int type = tokenizer.nextToken();
         switch (type) {
           case StreamTokenizer.TT_EOF:
             throw new ParseException("Expected word but encountered end of stream");
           case StreamTokenizer.TT_EOL:
             throw new ParseException("Expected word but encountered end of line");
           case StreamTokenizer.TT_NUMBER:
             throw new ParseException("Expected word but encountered number: " +
                 tokenizer.nval);
           case StreamTokenizer.TT_WORD:
             return tokenizer.sval.toUpperCase();
           case '(':
             return "(";
           case ')':
             return ")";
           case ',':
             return ",";
+        }
         // Assert.shouldNeverReachHere("Encountered unexpected StreamTokenizer type: " + type);
         return null;
+      }
       /**
        *  Creates a <code>Geometry</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;Geometry Tagged Text&gt;.
        *@return                  a <code>Geometry</code> specified by the next token
        *      in the stream
        *@throws  ParseException  if the coordinates used to create a <code>Polygon</code>
        *      shell and holes do not form closed linestrings, or if an unexpected
        *      token was encountered
        *@throws  IOException     if an I/O error occurs
        */
       private IGeometry readGeometryTaggedText(StreamTokenizer tokenizer) throws IOException, ParseException {
         String type = getNextWord(tokenizer);
         if (type.equals("POINT")) {
           return readPointText(tokenizer);
+        }
         else if (type.equals("LINESTRING")) {
           return readLineStringText(tokenizer);
+        }
         else if (type.equals("LINEARRING")) {
           return readLinearRingText(tokenizer);
+        }
         else if (type.equals("POLYGON")) {
           return readPolygonText(tokenizer);
+        }
         else if (type.equals("MULTIPOINT")) {
           return readMultiPointText(tokenizer);
+        }
         else if (type.equals("MULTILINESTRING")) {
           return readMultiLineStringText(tokenizer);
+        }
         else if (type.equals("MULTIPOLYGON")) {
           return readMultiPolygonText(tokenizer);
+        }
         /* else if (type.equals("GEOMETRYCOLLECTION")) {
           return readGeometryCollectionText(tokenizer);
         } */
         System.err.println("Unknown type: " + type);
         throw new ParseException("Unknown type: " + type);
+      }
       /**
        *  Creates a <code>Point</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;Point Text&gt;.
        *@return                  a <code>Point</code> specified by the next token in
        *      the stream
        *@throws  IOException     if an I/O error occurs
        *@throws  ParseException  if an unexpected token was encountered
        */
       private FGeometry readPointText(StreamTokenizer tokenizer) throws IOException, ParseException {
         String nextToken = getNextEmptyOrOpener(tokenizer);
         if (nextToken.equals("EMPTY")) {
           return null;
+        }
         Coordinate c = getPreciseCoordinate(tokenizer);
         FPoint2D point = new FPoint2D(c.x, c.y );
         getNextCloser(tokenizer);
         return ShapeFactory.createGeometry(point);
+      }
       /**
        *  Creates a <code>LineString</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;LineString Text&gt;.
        *@return                  a <code>LineString</code> specified by the next
        *      token in the stream
        *@throws  IOException     if an I/O error occurs
        *@throws  ParseException  if an unexpected token was encountered
        */
       private FGeometry readLineStringText(StreamTokenizer tokenizer) throws IOException, ParseException {
           Coordinate[] arrayC = getCoordinates(tokenizer);
           GeneralPathX gp = new GeneralPathX();
           gp.moveTo(arrayC[0].x,arrayC[0].y);
           for (int i=1;i < arrayC.length; i++)
+          {
               gp.lineTo(arrayC[i].x, arrayC[i].y);
+          }
         return ShapeFactory.createGeometry(new FPolyline2D(gp));
+      }
       /**
        *  Creates a <code>LinearRing</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;LineString Text&gt;.
        *@return                  a <code>LinearRing</code> specified by the next
        *      token in the stream
        *@throws  IOException     if an I/O error occurs
        *@throws  ParseException  if the coordinates used to create the <code>LinearRing</code>
        *      do not form a closed linestring, or if an unexpected token was
        *      encountered
        */
       private FGeometry readLinearRingText(StreamTokenizer tokenizer)
         throws IOException, ParseException
+      {
           Coordinate[] arrayC = getCoordinates(tokenizer);
           GeneralPathX gp = new GeneralPathX();
           gp.moveTo(arrayC[0].x, arrayC[0].y);
           for (int i=1;i < arrayC.length; i++)
+          {
               gp.lineTo(arrayC[i].x, arrayC[i].y);
+          }
           return ShapeFactory.createGeometry(new FPolygon2D(gp));
+      }
       /**
        *  Creates a <code>MultiPoint</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;MultiPoint Text&gt;.
        *@return                  a <code>MultiPoint</code> specified by the next
        *      token in the stream
        *@throws  IOException     if an I/O error occurs
        *@throws  ParseException  if an unexpected token was encountered
        */
       private IGeometry readMultiPointText(StreamTokenizer tokenizer) throws IOException, ParseException {
         Coordinate[] coords = getCoordinates(tokenizer);
         double[] x = new double[coords.length];
         double[] y = new double[coords.length];
         for (int i=0; i < coords.length; i++)
+        {
             x[i] = coords[i].x;
             y[i] = coords[i].y;
+        }
         FMultiPoint2D multi = new FMultiPoint2D(x, y);
         return multi;
+      }
       /**
        *  Creates a <code>Polygon</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;Polygon Text&gt;.
        *@return                  a <code>Polygon</code> specified by the next token
        *      in the stream
        *@throws  ParseException  if the coordinates used to create the <code>Polygon</code>
        *      shell and holes do not form closed linestrings, or if an unexpected
        *      token was encountered.
        *@throws  IOException     if an I/O error occurs
        */
       private FGeometry readPolygonText(StreamTokenizer tokenizer) throws IOException, ParseException {
         String nextToken = getNextEmptyOrOpener(tokenizer);
         if (nextToken.equals("EMPTY")) {
             return null;
+        }
         ArrayList holes = new ArrayList();
         FGeometry shell = readLinearRingText(tokenizer);
         nextToken = getNextCloserOrComma(tokenizer);
         while (nextToken.equals(",")) {
           FGeometry hole = readLinearRingText(tokenizer);
           holes.add(hole);
           nextToken = getNextCloserOrComma(tokenizer);
+        }
         // LinearRing[] array = new LinearRing[holes.size()];
         return shell; //geometryFactory.createPolygon(shell, (LinearRing[]) holes.toArray(array));
+      }
       /**
        *  Creates a <code>MultiLineString</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;MultiLineString Text&gt;.
        *@return                  a <code>MultiLineString</code> specified by the
        *      next token in the stream
        *@throws  IOException     if an I/O error occurs
        *@throws  ParseException  if an unexpected token was encountered
        */
       private FGeometry readMultiLineStringText(StreamTokenizer tokenizer) throws IOException, ParseException {
           // TODO: HACER ESTO BIEN, CON UN GENERAL PATH
         String nextToken = getNextEmptyOrOpener(tokenizer);
         if (nextToken.equals("EMPTY")) {
           return null;
+        }
         ArrayList lineStrings = new ArrayList();
         FGeometry lineString = readLineStringText(tokenizer);
         lineStrings.add(lineString);
         nextToken = getNextCloserOrComma(tokenizer);
         while (nextToken.equals(",")) {
           lineString = readLineStringText(tokenizer);
           lineStrings.add(lineString);
           nextToken = getNextCloserOrComma(tokenizer);
+        }
         // LineString[] array = new LineString[lineStrings.size()];
         return lineString; // geometryFactory.createMultiLineString((LineString[]) lineStrings.toArray(array));
+      }
       /**
        *  Creates a <code>MultiPolygon</code> using the next token in the stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;MultiPolygon Text&gt;.
        *@return                  a <code>MultiPolygon</code> specified by the next
        *      token in the stream, or if if the coordinates used to create the
        *      <code>Polygon</code> shells and holes do not form closed linestrings.
        *@throws  IOException     if an I/O error occurs
        *@throws  ParseException  if an unexpected token was encountered
        */
       // TODO:
       private IGeometry readMultiPolygonText(StreamTokenizer tokenizer) throws IOException, ParseException {
         String nextToken = getNextEmptyOrOpener(tokenizer);
         if (nextToken.equals("EMPTY")) {
           return null;
+        }
         ArrayList polygons = new ArrayList();
         FGeometry polygon = readPolygonText(tokenizer);
         /* polygons.add(polygon);
         nextToken = getNextCloserOrComma(tokenizer);
         while (nextToken.equals(",")) {
           polygon = readPolygonText(tokenizer);
           polygons.add(polygon);
           nextToken = getNextCloserOrComma(tokenizer);
         } */
         // Polygon[] array = new Polygon[polygons.size()];
         return polygon; //geometryFactory.createMultiPolygon((Polygon[]) polygons.toArray(array));
+      }
       /**
        *  Creates a <code>GeometryCollection</code> using the next token in the
        *  stream.
+       *
        *@param  tokenizer        tokenizer over a stream of text in Well-known Text
        *      format. The next tokens must form a &lt;GeometryCollection Text&gt;.
        *@return                  a <code>GeometryCollection</code> specified by the
        *      next token in the stream
        *@throws  ParseException  if the coordinates used to create a <code>Polygon</code>
        *      shell and holes do not form closed linestrings, or if an unexpected
        *      token was encountered
        *@throws  IOException     if an I/O error occurs
        */
       // TODO:
       /* private GeometryCollection readGeometryCollectionText(StreamTokenizer tokenizer) throws IOException, ParseException {
         String nextToken = getNextEmptyOrOpener(tokenizer);
         if (nextToken.equals("EMPTY")) {
           return geometryFactory.createGeometryCollection(new Geometry[]{});
+        }
         ArrayList geometries = new ArrayList();
         Geometry geometry = readGeometryTaggedText(tokenizer);
         geometries.add(geometry);
         nextToken = getNextCloserOrComma(tokenizer);
         while (nextToken.equals(",")) {
           geometry = readGeometryTaggedText(tokenizer);
           geometries.add(geometry);
           nextToken = getNextCloserOrComma(tokenizer);
+        }
         Geometry[] array = new Geometry[geometries.size()];
         return geometryFactory.createGeometryCollection((Geometry[]) geometries.toArray(array));
       } */
+    }

     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="lib/log4j-1.2.8.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="lib/geoapi-SNAPSHOT.jar">
     		<attributes>
     		</attributes>
-...
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="lib/gdbms-0.7.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="lib/jts-1.6.jar">
     		<attributes>
     		</attributes>
-...
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="lib/gdbms-0.8-SNAPSHOT.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="/Andami/lib/log4j-1.2.8.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="output" path="bin"/>
     </classpath>

trunk/extensions/extJDBC/.cvsignore
	1	bin
0	2

     <project name="Generar extension en Andami" default="generate-without-source" basedir=".">
         <description>
             Instala el plugin en Andami
         </description>
       <!-- set global properties for this build -->
       <property name="src" location="src"/>
       <property name="build" location="bin"/>
       <property name="dist"  location="dist"/>
       <property name="mainplugin" value="com.iver.cit.gvsig"/>
       <property name="plugin" value="com.iver.cit.gvsig.jdbc_spatial"/>
       <property name="gvsiglibjar" value="gvsig-jdbcspatial"/>
       <property name="fmapjar" value="fmap-jdbcspatial"/>
       <property name="driverjar" value="jdbc"/>
       <property name="extensionDir" location="../Andami/gvSIG/extensiones"/>
       <property name="drivers-dir" location="${extensionDir}/${mainplugin}/drivers" />
       <target name="init">
         <!-- Create the time stamp -->
         <tstamp/>
         <!-- Create the build directory structure used by compile -->
         <mkdir dir="${build}"/>
         <mkdir dir="${dist}"/>
       </target>
       <target name="generate-without-source"
       		description="generate the distribution without the source file">
         <!-- Create the distribution directory -->
         <mkdir dir="${dist}"/>
     	<mkdir dir="${drivers-dir}/jdbc_spatial" />
         <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
         <jar jarfile="${dist}/${plugin}.jar" basedir="${build}" includes="com/iver/cit/gvsig/**"/>
       	<copy file="config/config.xml" todir="${dist}"/>
         <copy todir="${dist}">
         	<fileset dir="." includes="text*.properties"/>
         </copy>
         <!-- <copy todir="${dist}">
         	<fileset dir="./lib" includes="*.jar,*.zip"/>
         	<fileset dir="." includes=".keystore"/>
         </copy> -->
       	<move todir="${extensionDir}/${mainplugin}/lib">
       		<fileset dir="${dist}" includes="${gvsiglibjar}.jar"/>
      		<fileset dir="${dist}" includes="${fmapjar}.jar"/>
      	</move>
         <move todir="${extensionDir}/${plugin}/">
         	<fileset dir="${dist}" includes="**/**"/>
         </move>
       </target>
       <target name="generate-with-source" description="generate the distribution with the source file" >
         <!-- Create the distribution directory -->
         <mkdir dir="${dist}"/>
         <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
         <jar jarfile="${dist}/${plugin}.jar" basedir="${build}"/>
         <copy file="config/config.xml" todir="${dist}"/>
         <copy todir="${dist}">
         	<fileset dir="." includes="text*.properties"/>
         </copy>
         <copy todir="${dist}">
         	<fileset dir="." includes="${src}"/>
         </copy>
         <copy todir="${dist}/images">
         	<fileset dir="images/" includes="*"/>
         </copy>
         <move todir="${extension-dir}/${plugin}/">
         	<fileset dir="${dist}" includes="**/**"/>
         </move>
       </target>
       <target name="clean"
             description="clean up" >
         <!-- Delete the ${build} and ${dist} directory trees -->
         <delete dir="${dist}"/>
       </target>
     </project>

     <?xml version="1.0" encoding="UTF-8"?>
     <classpath>
     	<classpathentry kind="src" path="src">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry combineaccessrules="false" kind="src" path="/Andami">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry combineaccessrules="false" kind="src" path="/FMap 03">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry sourcepath="/Utiles/src" kind="lib" path="/Andami/lib/iver-utiles.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry sourcepath="/DriverManager/src" kind="lib" path="/FMap 03/lib/driver-manager-1.0.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="/FMap 03/lib/gdbms-0.8-SNAPSHOT.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry combineaccessrules="false" kind="src" path="/gvSIG 03">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry sourcepath="/jCMS" kind="lib" path="/FMap 03/lib/cms.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="/Andami/lib/log4j-1.2.8.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="lib" path="/FMap 03/lib/postgis-jdbc-driver.jar">
     		<attributes>
     		</attributes>
     	</classpathentry>
     	<classpathentry kind="output" path="bin"/>
     </classpath>

     <?xml version="1.0" encoding="UTF-8"?>
     <projectDescription>
     	<name>gvSIG_JDBC</name>
     	<comment></comment>
     	<projects>
     	</projects>
     	<buildSpec>
     		<buildCommand>
     			<name>org.eclipse.jdt.core.javabuilder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     	</buildSpec>
     	<natures>
     		<nature>org.eclipse.jdt.core.javanature</nature>
     	</natures>
     </projectDescription>

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <plugin-config>
     	<depends plugin-name="com.iver.cit.gvsig" />
     	<libraries library-dir="."/>
     	<extensions>
     		<extension class-name="com.iver.cit.gvsig.jdbc_spatial.ExtJDBC_Spatial"
     			description="Support to access JDBC spatial databases PostgreSQL and mySQL"
     			active="true"
     			priority="1">
     		</extension>
     	</extensions>
     </plugin-config>

     /*
      * Created on 04-mar-2005
+     *
      * 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.drivers.jdbc.mysql;
     import java.awt.geom.Rectangle2D;
     import java.sql.Connection;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import java.sql.Statement;
     import com.hardcode.gdbms.engine.data.edition.DataWare;
     import com.iver.cit.gvsig.fmap.DriverException;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     import com.iver.cit.gvsig.fmap.drivers.DefaultDBDriver;
     import com.iver.cit.gvsig.fmap.drivers.DriverAttributes;
     import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;
     import com.iver.cit.gvsig.fmap.drivers.WKBParser;
     /**
      * @author FJP
+     *
      * TODO To change the template for this generated type comment go to
      * Window - Preferences - Java - Code Generation - Code and Comments
      */
     public class MySQLDriver extends DefaultDBDriver {
         private WKBParser parser = new WKBParser();
         /* private int fetch_min=-1;
         private int fetch_max=-1; */
         private Statement st;
         private Rectangle2D fullExtent = null;
         private String strAux;
         private Rectangle2D workingArea;
         /**
+         *
          */
         public MySQLDriver() {
+        }
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.drivers.VectorialDriver#getDriverAttributes()
          */
         public DriverAttributes getDriverAttributes() {
             return null;
+        }
         /* (non-Javadoc)
          * @see com.hardcode.driverManager.Driver#getName()
          */
         public String getName() {
             return "mySQL JDBC Driver";
+        }
     	/**
     	 * @see com.iver.cit.gvsig.fmap.layers.ReadableVectorial#getShape(int)
     	 */
     	public IGeometry getShape(int index) {
     	    IGeometry geom = null;
     	    boolean resul;
     	        try {
     	            // EL ABSOLUTE NO HACE QUE SE VUELVAN A LEER LAS
     	            // FILAS, ASI QUE MONTAMOS ESTA HISTORIA PARA QUE
     	            // LO HAGA
     	            // System.out.println("getShape " + index);
     	            /* if (index < fetch_min)
+    	            {
     	                rs.close();
     	    	        rs = st.executeQuery(sqlOrig);
     	                fetch_min = 0;
     	                fetch_max = rs.getFetchSize();
+    	            }
     	            while (index >= fetch_max)
+    	            {
     	                rs.last();
     	                // forzamos una carga
     	                rs.next();
     	                fetch_min = fetch_max;
     	                fetch_max = fetch_max + rs.getFetchSize();
     	                // System.out.println("fetchSize = " + rs.getFetchSize() + " " + fetch_min + "-" + fetch_max);
+    	            }
     	            rs.absolute(index+1 - fetch_min); */
     	            rs.absolute(index+1);
         	        // strAux = rs.getString(1);
         	        // geom = parser.read(strAux);
     	            byte[] data = rs.getBytes(1);
     	            geom = parser.parse(data);
                 } catch (SQLException e) {
                     e.printStackTrace();
+                }
     	    return geom;
+    	}
     	/**
     	 * @param conn
     	 * @param tableName
     	 * @param fields OJO: EL PRIMER CAMPO HA DE SER EL DE GEOMETRIA
     	 * @param whereClause
     	 */
     	public void setData(Connection conn, String tableName, String fields, String whereClause, int id_FID_field)
+    	{
     	    this.conn = conn;
     	    this.tableName = tableName;
     	    this.fields = fields;
     	    this.whereClause = whereClause;
     	    this.sqlOrig = "SELECT " + fields + " FROM " + tableName + " " + whereClause;
             this.idFID_FieldName = id_FID_field;
     	    try {
     	        st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
     	        rs = st.executeQuery(sqlOrig);
                 metaData = rs.getMetaData();
                 // Le pegamos un primera pasada para poder relacionar
                 // un campo de identificador ?nico (parecido al OID en
                 // postgresql) con el ?ndice dentro del recordset.
                 // Esto cuando haya ediciones, no es v?lido, y hay
                 // que refrescarlo.
                 doRelateID_FID();
             } catch (SQLException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
+            }
+    	}
     	/**
     	 * @see com.iver.cit.gvsig.fmap.layers.ReadableVectorial#getFullExtent()
     	 */
     	public Rectangle2D getFullExtent(){
     	    if (fullExtent == null)
+    	    {
         	    try
+                {
         	        IFeatureIterator itGeom = getFeatureIterator("SELECT ASBINARY(ogc_geom) AS the_geom FROM " + tableName);
         	        IGeometry geom;
         	        int cont = 0;
         	        while (itGeom.hasNext())
+        	        {
         	            geom = itGeom.next().getGeometry();
         	            if (cont==0)
         	                fullExtent = geom.getBounds2D();
         	            else
         	                fullExtent.add(geom.getBounds2D());
         	            cont++;
+        	        }
+                }
         	    catch (SQLException e)
+        	    {
         	        System.err.println(e.getMessage());
         	    } catch (DriverException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
+                }
+    	    }
     	    return fullExtent;
+    	}
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.drivers.VectorialDatabaseDriver#getGeometryIterator(java.lang.String)
          */
         public IFeatureIterator getFeatureIterator(String sql) throws com.iver.cit.gvsig.fmap.DriverException {
             Statement st;
             MySqlFeatureIterator geomIterator = null;
             try {
                 st = conn.createStatement();
                 // st.setFetchSize(2000);
                 ResultSet rs = st.executeQuery(sql);
                 geomIterator = new MySqlFeatureIterator(rs);
             } catch (SQLException e) {
                 e.printStackTrace();
                 throw new com.iver.cit.gvsig.fmap.DriverException(e);
+            }
             return geomIterator;
+        }
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.drivers.VectorialDatabaseDriver#getGeometryIterator(java.awt.geom.Rectangle2D)
          */
         public IFeatureIterator getFeatureIterator(Rectangle2D r, String strEPSG) throws DriverException {
             if (workingArea != null)
             r = r.createIntersection(workingArea);
             double xMin = r.getMinX();
             double yMin = r.getMinY();
             double xMax = r.getMaxX();
             double yMax = r.getMaxY();
             String wktBox = "GeomFromText('LINESTRING(" + xMin + " " + yMin + ", "
     		+ xMax + " " + yMin + ", "
     		+ xMax + " " + yMax + ", "
     		+ xMin + " " + yMax + ")', "
     		+ strEPSG + ")";
             String sqlAux;
             if (getWhereClause().startsWith("WHERE"))
                 sqlAux = sqlOrig + " MBRIntersects(" + wktBox + ",ogc_geom);" ;
             else
                 sqlAux = sqlOrig + "WHERE MBRIntersects(" + wktBox + ",ogc_geom);" ;
             return getFeatureIterator(sqlAux);
+        }
         public void open() {
             // TODO Auto-generated method stub
+        }
     	/**
     	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialDatabaseDriver#getConnectionStringBeginning()
     	 */
     	public String getConnectionStringBeginning() {
     		return "jdbc:mysql:";
+    	}
         static{
     	    try {
     			Class.forName("com.mysql.jdbc.Driver");
     		} catch (ClassNotFoundException e) {
     			throw new RuntimeException(e);
+    		}
+        }
     	/**
     	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialDatabaseDriver#getGeometryField(java.lang.String)
     	 */
     	public String getGeometryField(String fieldName) {
     		return "ASBINARY(" + fieldName +")";
+    	}
         /**
          * @see com.hardcode.gdbms.engine.data.driver.ObjectDriver#getPrimaryKeys()
          */
         public int[] getPrimaryKeys() throws com.hardcode.gdbms.engine.data.driver.DriverException {
             return new int[]{idFID_FieldName - 2};
+        }
         /**
          * @see com.iver.cit.gvsig.fmap.drivers.VectorialJDBCDriver#getDefaultPort()
          */
         public int getDefaultPort() {
             return 3306;
+        }
         /**
          * @see com.iver.cit.gvsig.fmap.drivers.VectorialJDBCDriver#setWorkingArea(java.awt.geom.Rectangle2D)
          */
         public void setWorkingArea(Rectangle2D rect) {
             this.workingArea = rect;
+        }
         /**
          * @see com.iver.cit.gvsig.fmap.drivers.VectorialJDBCDriver#getWorkingArea()
          */
         public Rectangle2D getWorkingArea() {
             return workingArea;
+        }
         /**
          * @see com.hardcode.gdbms.engine.data.driver.ObjectDriver#write(com.hardcode.gdbms.engine.data.edition.DataWare)
          */
         public void write(DataWare arg0) throws com.hardcode.gdbms.engine.data.driver.DriverException {
             // TODO Auto-generated method stub
+        }
+    }

     /*
      * Created on 03-mar-2005
+     *
      * 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.drivers.jdbc.mysql;
     import java.sql.DriverManager;
     import java.sql.ResultSet;
     import java.sql.Statement;
     import java.util.Enumeration;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     import com.iver.cit.gvsig.fmap.drivers.WKTParser;
     /**
      * @author FJP
+     *
      * TODO To change the template for this generated type comment go to
      * Window - Preferences - Java - Code Generation - Code and Comments
      */
     public class testMySQL {
           public static void main(String[] args)
+          {
           /*    System.err.println("dburl has the following format:");
               System.err.println("jdbc:postgresql://HOST:PORT/DATABASENAME");
               System.err.println("tablename is 'jdbc_test' by default.");
               System.exit(1); */
           // Tarda casi 28 segundos en recuperar el tema de provincias!!
           String dburl = "jdbc:mysql://localhost/test";
           String dbuser = "root";
           String dbpass = "aquilina";
           String dbtable = "vias";
          java.sql.Connection conn;
             try
+            {
                 System.out.println("Creating JDBC connection...");
                 Class.forName("com.mysql.jdbc.Driver");
                 Enumeration enumDrivers = DriverManager.getDrivers();
                 while (enumDrivers.hasMoreElements())
+                {
                     System.out.println("Driver " + enumDrivers.nextElement().toString());
+                }
                 conn = DriverManager.getConnection(dburl, dbuser, dbpass);
                 // magic trickery to be pgjdbc 7.2 compatible
                 // This works due to the late binding of data types in most java VMs. As
                 // this is more a demo source than a real-world app, we can risk this
                 // problem.
                 /* if (conn.getClass().getName().equals("org.postgresql.jdbc2.Connection")) {
                     ((org.postgresql.Connection) conn).addDataType("geometry", "org.postgis.PGgeometry");
                     ((org.postgresql.Connection) conn).addDataType("box3d", "org.postgis.PGbox3d");
                 } else {
                     ((org.postgresql.PGConnection) conn).addDataType("geometry", "org.postgis.PGgeometry");
                     ((org.postgresql.PGConnection) conn).addDataType("box3d", "org.postgis.PGbox3d");
                 } */
                 conn.setAutoCommit(false);
               /*
               * Create a statement and execute a select query.
               */
                 // String strSQL = "select ogc_geom as geom from vias";
                 String strSQL = "select ASTEXT(ogc_geom) as geom from " + dbtable;
                 /* String strSQL = "SELECT gid, rd_3, rd_5, rd_6, rd_10, rd_11, rd_12, rd_13, rd_14,";
                 strSQL = strSQL + " rd_15, rd_16, kilometers, cost, metros, AsText(force_2d(the_geom)) FROM vias";
                 strSQL = strSQL + " WHERE TRUE";
                 */
                 // PreparedStatement s = conn.prepareStatement(strSQL);
                 long t1 = System.currentTimeMillis();
                 Statement s = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
                 s.setFetchSize(2000);
                 ResultSet r = s.executeQuery(strSQL);
     			long t2 = System.currentTimeMillis();
     			System.out.println("Tiempo de consulta:" + (t2 - t1) + " milisegundos");
     			t1 = System.currentTimeMillis();
     			int cont = 0;
     			WKTParser parser = new WKTParser();
               while( r.next() )
+              {
                 /*
                 * Retrieve the geometry as an object then cast it to the geometry type.
                 * Print things out.
                 */
                   // Object obj = r.getObject(1);
                   // InputStream inS = r.getAsciiStream(1);
                   String strAux = r.getString(1);
                   // IGeometry geom = parser.read(strAux);
                   cont++;
                   // int id = r.getInt(2);
                   // System.out.println("Row " + id + ":");
                   // Geometry regeom = PGgeometry.geomFromString(obj.toString());
                   // System.out.println(obj.toString());
                 // PGgeometry geom = (PGgeometry)obj;
                 /* int id = r.getInt(2);
                 System.out.println("Row " + id + ":");
                 System.out.println(geom.toString()); */
+              }
               s.close();
               conn.close();
     			t2 = System.currentTimeMillis();
     			System.out.println("Tiempo de recorrido:"  + (t2 - t1) + " milisegundos. " + cont + " registros.");
+            }
             catch( Exception e )
+            {
               e.printStackTrace();
+            }
+          }
+    }

     /*
      * Created on 11-mar-2005
+     *
      * 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.drivers.jdbc.mysql;
     import java.sql.ResultSet;
     import java.sql.ResultSetMetaData;
     import java.sql.SQLException;
     import java.sql.Types;
     import com.hardcode.gdbms.engine.values.Value;
     import com.hardcode.gdbms.engine.values.ValueFactory;
     import com.iver.cit.gvsig.fmap.core.DefaultFeature;
     import com.iver.cit.gvsig.fmap.core.IFeature;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;
     import com.iver.cit.gvsig.fmap.drivers.WKBParser;
     /**
      * @author FJP
+     *
      * TODO To change the template for this generated type comment go to
      * Window - Preferences - Java - Code Generation - Code and Comments
      */
     public class MySqlFeatureIterator implements IFeatureIterator {
         private WKBParser parser = new WKBParser();
         ResultSet rs;
         String strAux;
         IGeometry geom;
         int numColumns;
         private ResultSetMetaData metaData = null;
         Value[] regAtt;
         /**
          * @throws SQLException
+         *
          */
         public MySqlFeatureIterator(ResultSet rs) {
             // Debe ser forward only
             this.rs = rs;
             try {
                 numColumns = rs.getMetaData().getColumnCount();
                 regAtt = new Value[numColumns-1];
                 metaData = rs.getMetaData();
             } catch (SQLException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
+            }
+        }
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.drivers.jdbc.GeometryIterator#hasNext()
          */
         public boolean hasNext() throws SQLException {
             if (rs.next())
                 return true;
             else
+            {
                 rs.close();
                 return false;
+            }
+        }
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.drivers.jdbc.GeometryIterator#next()
          */
         public IFeature next() throws SQLException {
             byte[] data = rs.getBytes(1);
             geom = parser.parse(data);
             for (int fieldId=2; fieldId <= numColumns; fieldId++ )
+            {
                 if (metaData.getColumnType(fieldId) == Types.VARCHAR)
+                {
                     String strAux = rs.getString(fieldId);
                     if (strAux == null) strAux = "";
                     regAtt[fieldId-2] =  ValueFactory.createValue(strAux);
+                }
                 if (metaData.getColumnType(fieldId) == Types.FLOAT)
                     regAtt[fieldId-2] = ValueFactory.createValue(rs.getFloat(fieldId));
                 if (metaData.getColumnType(fieldId) == Types.DOUBLE)
                     regAtt[fieldId-2] = ValueFactory.createValue(rs.getDouble(fieldId));
                 if (metaData.getColumnType(fieldId) == Types.INTEGER)
                     regAtt[fieldId-2] = ValueFactory.createValue(rs.getInt(fieldId));
                 if (metaData.getColumnType(fieldId) == Types.BIGINT)
                     regAtt[fieldId-2] = ValueFactory.createValue(rs.getLong(fieldId));
                 if (metaData.getColumnType(fieldId) == Types.BIT)
                     regAtt[fieldId-2] = ValueFactory.createValue(rs.getBoolean(fieldId));
                 if (metaData.getColumnType(fieldId) == Types.DATE)
                     regAtt[fieldId-2] = ValueFactory.createValue(rs.getDate(fieldId));
+            }
             // TODO: Aqu? habr?a que usar una Factor?a.
             IFeature feat = new DefaultFeature(geom, regAtt);
             return feat;
+        }
+    }

     /*
      * Created on 11-mar-2005
+     *
      * 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.drivers.jdbc.postgis;
     import java.nio.ByteBuffer;
     import java.sql.ResultSet;
     import java.sql.ResultSetMetaData;
     import java.sql.SQLException;
     import java.sql.Statement;
     import java.sql.Types;
     import com.hardcode.gdbms.engine.values.Value;
     import com.hardcode.gdbms.engine.values.ValueFactory;
     import com.iver.cit.gvsig.fmap.core.DefaultFeature;
     import com.iver.cit.gvsig.fmap.core.IFeature;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;
     import com.iver.cit.gvsig.fmap.drivers.WKBParser;
     /**

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff