Changeset 1528:6cc6a1963350


Ignore:
Timestamp:
01/04/16 17:47:18 (21 months ago)
Author:
Panayiotis Smeros <psmeros@…>
Branch:
temporals
Message:

Backed out changeset ba8fb069b2ca

Files:
53 added
12 deleted
40 edited

Legend:

Unmodified
Added
Removed
  • .hgtags

    r1527 r1528  
    21210ed49ee3eb94c6bfc122254342e86bfd097c1200 v3.2.9-temporals 
    2222e453684f594f568079ec28733e0a4a6df8be0e37 v3.2.10 
    23 fb3821b625fda9a2041e8ce662680328087398c6 v3.3.1 
     230ed49ee3eb94c6bfc122254342e86bfd097c1200 v3.2.9-temporals 
     240000000000000000000000000000000000000000 v3.2.9-temporals 
     250000000000000000000000000000000000000000 v3.2.9-temporals 
     26391c74ff7dc007b836a57812c280402534213a02 v3.2.9-temporals 
  • ChangeLog

    r1527 r1528  
    1 Wed Mar 11 21:02:48 2015   Pyravlos Team 
    2          
    3         * Bug #73, modified appendBuffer function to take the srid into 
    4           consideration even if the argument is a constant (wktLiteral 
    5           or strdf literal) 
    6  
    7         * Update jar references on scripts used by the debian packaging. 
    8           Previously these references pointed only (incorrectly) to 
    9           SNAPSHOTs. 
    10  
    11         * Updated package names (since repositories cannot include capital 
    12           letters + runtime and endpoint-exec must have different names 
    13  
    14         * Version 3.3.1 released. 
    15  
    16         * Bug #58, added script that is invoked my maven to also update the 
    17           version described in the deb/control file of the runtime and 
    18           endpoint-exec components. 
    19  
    20         * Related to bug #58, but it generally enhances Strabon; The runtime 
    21           component has also been debianized. Dependencies are added to 
    22           /usr/share/jdeb/lib/strabon-runtime. ClassPath and strabon script 
    23           have also been updated accordingly (strabon-cmd) 
    24  
    25         * Bug #58: Maven creates the debian package conditionally. Use 
    26           -Ddebian=true in the mvn package command.  
    27  
    28         * Bug #58: Added dependencies - java, postgresql, tomcat. Also, added 
    29           a strabon-init script that detects the postgis installation path 
    30           and sets up the template_postgis. Finally the script creates a db 
    31           called "endpoint" (assuming it does not already exist) that is used 
    32           for the strabon-endpoint command. 
    33          
    34         * Fixed an issue that returned null SRID when unmarshalling GML geometries if 
    35           the SRID did not follow one of the supported formats by GML-JTS. To fix that 
    36           we added a function that handles these cases by reading the userData variable 
    37           that JTS provides. 
    38  
    39         * Fixed a bug that would return no results when a variable that results  
    40           from a BIND clause appears in the FILTER or in the projection of a 
    41           query and is inside a spatial function. 
    42           (bug #78: http://bug.strabon.di.uoa.gr/ticket/78) 
    43  
    44         * Fixed the precision of the geometry literals in GeoJSON writer. Now, 
    45           this defaults to the precision model of JTS (equals to 16). Prior to 
    46           this it was fixed to 4. 
    47  
    48         * Now the GeoJSON writer is aware of the kind of typed literals (e.g., 
    49           numeric, boolean, calendar, etc.) and prints the corresponding 
    50           values according to these types.  
    51  
    52         * Fixed a bug that would not return the correct result or would fail  
    53           when a spatial function involved a constant and a variable. 
    54           (bug #74: http://bug.strabon.di.uoa.gr/ticket/74) 
    55  
     1        * Completed implementation of the period function, that constructs 
     2          a period with start and end points the given arguments 
    563        * Fixed a bug that would not return the correct spatial datatype of a 
    574          projected geometry literal stored in the database. 
  • endpoint-client/pom.xml

    r1527 r1528  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • endpoint-client/src/main/java/eu/earthobservatory/org/StrabonEndpoint/client/SpatialEndpoint.java

    r1438 r1528  
    6060                stSPARQLResultsKMLWriter kmlWriter = new stSPARQLResultsKMLWriter(outputStream); 
    6161                         
    62                 kmlWriter.startQueryResult(results.getBindingNames()); 
     62                kmlWriter.startQueryResult(new Vector<String>()); 
    6363                                         
    6464                while(results.hasNext()){ 
  • endpoint-client/src/test/java/eu/earthobservatory/org/StrabonEndpoint/client/TestSPARQLEndpointStoreWithStrabon.java

    r1458 r1528  
    3232        public void init() { 
    3333                // initialize endpoint 
    34                 endpoint = new SPARQLEndpoint("geo.linkedopendata.gr", 80, "teststrabon-endpoint/Store"); 
     34                endpoint = new SPARQLEndpoint("luna.di.uoa.gr", 8080, "sextant-endpoint/Store"); 
    3535                 
    3636                // set url data 
    3737                try { 
    38                         data = new URL("http://geo.linkedopendata.gr/teststrabon-endpoint/map.nt"); 
     38                        data = new URL("http://luna.di.uoa.gr:8080/strabon-endpoint-gwt/mapontology/map.nt"); 
    3939                } catch (MalformedURLException e) { 
    4040                        // TODO Auto-generated catch block 
     
    5757                        URL namedGraph = new URL("http://geo.linkedopendata.gr/map/example"); 
    5858                        Boolean response = endpoint.store(data, RDFFormat.NTRIPLES , namedGraph); 
     59                         
    5960                        assertTrue(response == true); 
    6061        } 
  • endpoint-client/src/test/java/eu/earthobservatory/org/StrabonEndpoint/client/TestSPARQLEndpointUpdateWithStrabon.java

    r1458 r1528  
    1616        public void init() { 
    1717                // initialize endpoint 
    18                 endpoint = new SPARQLEndpoint("geo.linkedopendata.gr", 80, "teststrabon-endpoint/Update"); 
     18                endpoint = new SPARQLEndpoint("luna.di.uoa.gr", 8080, "sextant-endpoint/Update"); 
    1919                 
    2020                // set url data 
  • endpoint-exec/pom.xml

    r1527 r1528  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
     
    9494                                </executions> 
    9595                        </plugin> 
    96                          
    97                      
     96                    <plugin> 
     97                                <artifactId>jdeb</artifactId> 
     98                                <groupId>org.vafer</groupId> 
     99                                <version>1.3</version> 
     100                                <executions> 
     101                                        <execution> 
     102                                                <phase>package</phase> 
     103                                                <goals> 
     104                                                        <goal>jdeb</goal> 
     105                                                </goals> 
     106                                        <configuration> 
     107                                                <skipPOMs>false</skipPOMs> 
     108                                                <dataSet> 
     109                                                        <data> 
     110                                                                <src>${project.build.directory}/strabon-endpoint-executable-${project.version}.jar</src> 
     111                                                                <type>file</type> 
     112                                                                <mapper> 
     113                                                                        <type>perm</type> 
     114                                                                        <prefix>/usr/share/jdeb/lib</prefix> 
     115                                                                </mapper> 
     116                                                        </data> 
     117                                                        <data> 
     118                                                                <src>${basedir}/strabon-endpoint</src> 
     119                                                                <type>file</type> 
     120                                                                <mapper> 
     121                                                                        <type>perm</type> 
     122                                                                        <prefix>/usr/local/bin</prefix> 
     123                                                                        <user>root</user> 
     124                                                                        <group>root</group> 
     125                                                                        <filemode>755</filemode> 
     126                                                                </mapper> 
     127                                                        </data> 
     128                                                </dataSet> 
     129                                        </configuration> 
     130                                </execution> 
     131                        </executions> 
     132                        </plugin> 
     133 
     134 
    98135                </plugins> 
    99136        </build> 
    100  
    101 <profiles> 
    102                 <profile> 
    103                         <id>create-debian</id> 
    104                         <activation> 
    105                                 <activeByDefault>false</activeByDefault> 
    106                                 <property> 
    107                                         <name>debian</name> 
    108                                         <value>true</value> 
    109                                 </property> 
    110                         </activation> 
    111                                 <build> 
    112                                         <plugins> 
    113                                                 <plugin> 
    114                                                     <groupId>org.codehaus.mojo</groupId> 
    115                                                     <artifactId>exec-maven-plugin</artifactId> 
    116                                                     <version>1.1.1</version> 
    117                                                     <executions> 
    118                                                       <execution> 
    119                                                         <!-- 
    120                                                         <id>some-execution</id> 
    121                                                         --> 
    122                                                         <phase>package</phase> 
    123                                                         <goals> 
    124                                                           <goal>exec</goal> 
    125                                                         </goals> 
    126                                                       </execution> 
    127                                                     </executions> 
    128                                                     <configuration> 
    129                                                       <executable>${basedir}/../scripts/update-debian-version.sh</executable> 
    130                                                     </configuration> 
    131                                                   </plugin> 
    132  
    133                                                 <plugin> 
    134                                                         <artifactId>jdeb</artifactId> 
    135                                                         <groupId>org.vafer</groupId> 
    136                                                         <version>1.3</version> 
    137                                                         <executions> 
    138                                                                 <execution> 
    139                                                                         <phase>package</phase> 
    140                                                                         <goals> 
    141                                                                                 <goal>jdeb</goal> 
    142                                                                         </goals> 
    143                                                                 <configuration> 
    144                                                                         <skipPOMs>false</skipPOMs> 
    145                                                                         <dataSet> 
    146                                                                                 <data> 
    147                                                                                         <src>${project.build.directory}/strabon-endpoint-executable-${project.version}.jar</src> 
    148                                                                                         <type>file</type> 
    149                                                                                         <mapper> 
    150                                                                                                 <type>perm</type> 
    151                                                                                                 <prefix>/usr/share/jdeb/lib</prefix> 
    152                                                                                         </mapper> 
    153                                                                                 </data> 
    154                                                                                 <data> 
    155                                                                                         <src>${basedir}/strabon-endpoint</src> 
    156                                                                                         <type>file</type> 
    157                                                                                         <mapper> 
    158                                                                                                 <type>perm</type> 
    159                                                                                                 <prefix>/usr/local/bin</prefix> 
    160                                                                                                 <user>root</user> 
    161                                                                                                 <group>root</group> 
    162                                                                                                 <filemode>755</filemode> 
    163                                                                                         </mapper> 
    164                                                                                 </data> 
    165                                                                                 <data> 
    166                                                                                         <src>${basedir}/strabon-init</src> 
    167                                                                                         <type>file</type> 
    168                                                                                         <mapper> 
    169                                                                                                 <type>perm</type> 
    170                                                                                                 <prefix>/usr/local/bin</prefix> 
    171                                                                                                 <user>root</user> 
    172                                                                                                 <group>root</group> 
    173                                                                                                 <filemode>755</filemode> 
    174                                                                                         </mapper> 
    175                                                                                 </data> 
    176                                                                         </dataSet> 
    177                                                                 </configuration> 
    178                                                         </execution> 
    179                                                 </executions> 
    180                                         </plugin> 
    181                                 </plugins> 
    182                         </build> 
    183                 </profile> 
    184         </profiles> 
    185137</project> 
  • endpoint-exec/src/deb/control/control

    r1508 r1528  
    1 Package: strabon-endpoint 
    2 Version: 3.3.2-SNAPSHOT 
     1Package: Strabon 
     2Version: 3.2.10 
    33Section: strabon-endpoint 
    44Priority: optional 
     
    66Maintainer: Manolis Karpathiotakis <manos.karpathiotakis@epfl.ch>, Kostis Kyzirakos <Kostis.Kyzirakos@cwi.nl>, Charalampos Nikolaou <charnik@di.uoa.gr>, Konstantina Bereta <konstantina.bereta@di.uoa.gr>, Georgios Garbis <ggarbis@di.uoa.gr>,  Dimitrios Bilidas <dbilidas@di.uoa.gr>, Stella Giannakopoulou <sgian@di.uoa.gr>, Panayiotis Smeros <psmeros@di.uoa.gr>, Kalliroi Dogani <kallirroi@di.uoa.gr>, Maria Karpathiotaki <mkarpat@di.uoa.gr>, Ioannis Vlachopoulos <johnvl@di.uoa.gr>, Dimitrianos Savva <dimis@di.uoa.gr>, Georgios Stamoulis <gstam@di.uoa.gr>, Kanela Kaligosi <kalkan@di.uoa.gr> 
    77Description: Strabon endpoint executable 
    8 Depends: openjdk-7-jre | oracle-java7-installer, postgresql (>= 9.1) | postgresql-9.1, tomcat7 
    98Distribution: Mozilla v2.0 Public Liscence 
  • endpoint-exec/strabon-endpoint

    r1508 r1528  
    11#!/bin/bash 
    22 
    3 java -jar /usr/share/jdeb/lib/strabon-endpoint-executable-*.jar "$@" 
     3java -jar /usr/share/jdeb/lib/strabon-endpoint-executable-3.2.10-SNAPSHOT.jar "$@" 
    44 
  • endpoint/WebContent/WEB-INF/beans.xml

    r1446 r1528  
    9292PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
    9393PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> 
    94 PREFIX uom: <http://www.opengis.net/def/uom/OGC/1.0/> 
    9594]]> 
    9695</value> 
  • endpoint/pom.xml

    r1527 r1528  
    55                <groupId>eu.earthobservatory</groupId> 
    66                <artifactId>strabon</artifactId> 
    7                 <version>3.3.2-SNAPSHOT</version> 
     7                <version>3.2.10-temporals-SNAPSHOT</version> 
    88        </parent> 
    99 
  • evaluation/pom.xml

    r1527 r1528  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/AbstractWKT.java

    r1527 r1528  
    195195         * @return 
    196196          
    197         protected Integer getEPSG_SRID(String wkt) { 
     197        protected int getEPSG_SRID(String wkt) { 
    198198                int srid = GeoConstants.defaultSRID; 
    199199                 
    200200                try { 
    201201                        srid = Integer.parseInt(wkt.substring(wkt.lastIndexOf('/') + 1).replace(">", "")); 
    202  
     202                         
    203203                } catch (NumberFormatException e) { 
    204204                        logger.warn("[Strabon.AbstractWKT] Was expecting an integer. The URL of the EPSG SRID was {}. Continuing with the default SRID, {}", wkt, srid); 
     
    208208                return srid; 
    209209        }*/ 
    210         */ 
    211210} 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/util/JTSWrapper.java

    r1527 r1528  
    2424import org.opengis.referencing.operation.MathTransform; 
    2525import org.opengis.referencing.operation.TransformException; 
    26 import org.openrdf.query.algebra.evaluation.function.spatial.AbstractWKT; 
    2726import org.openrdf.query.algebra.evaluation.function.spatial.WKTHelper; 
    2827import org.slf4j.Logger; 
     
    3029 
    3130import com.vividsolutions.jts.geom.Geometry; 
    32 import com.vividsolutions.jts.geom.PrecisionModel; 
    3331import com.vividsolutions.jts.io.ParseException; 
    3432import com.vividsolutions.jts.io.WKBReader; 
     
    3937import com.vividsolutions.jts.io.gml2.GMLWriter; 
    4038 
    41 import eu.earthobservatory.constants.GeoConstants; 
    42  
    4339/** 
    4440 * This class is a singleton and provides access to the readers/writers 
     
    8177        private GMLWriter gmlw; 
    8278         
    83         /** 
    84          * Stores the number of decimal places for the 
    85          * default precision model of JTS.  
    86          */ 
    87         private int numDecimalPlaces; 
    88  
    8979        private JTSWrapper() { 
    9080                // use a private constructor to force call of getInstance method and forbid subclassing 
     
    9585//              wkbw = new WKBWriter(2, WKBConstants.wkbXDR); // MonetDB 
    9686                gmlw = new GMLWriter(); 
    97  
    98                 numDecimalPlaces = (new PrecisionModel()).getMaximumSignificantDigits(); 
    9987        } 
    10088         
     
    235223                        return geometry; 
    236224                }                
    237                 }                
    238225        } 
    239226         
     
    241228                return gmlw.write(geom); 
    242229        } 
    243  
    244         /** 
    245          * Returns the number of decimal places corresponding to the 
    246          * precision model that is used by default by the JTS library. 
    247          *  
    248          * @return 
    249          */ 
    250         public int getPrecision() { 
    251                 return numDecimalPlaces; 
    252         } 
    253230} 
  • generaldb/pom.xml

    r1527 r1528  
    77                <groupId>eu.earthobservatory</groupId> 
    88                <artifactId>strabon</artifactId> 
    9                 <version>3.3.2-SNAPSHOT</version> 
     9                <version>3.2.10-temporals-SNAPSHOT</version> 
    1010        </parent> 
    1111   
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBEvaluation.java

    r1527 r1528  
    1515import java.util.Collection; 
    1616import java.util.HashMap; 
    17 import java.util.HashSet; 
    1817import java.util.Iterator; 
    1918import java.util.List; 
    2019import java.util.Map; 
    21 import java.util.Set; 
    2220 
    2321import org.openrdf.model.Literal; 
     
    3331import org.openrdf.query.algebra.Avg; 
    3432import org.openrdf.query.algebra.Distinct; 
    35 import org.openrdf.query.algebra.Filter; 
    3633import org.openrdf.query.algebra.FunctionCall; 
    3734import org.openrdf.query.algebra.Group; 
     
    9188import org.openrdf.query.algebra.evaluation.function.temporal.stsparql.relation.TemporalRelationFunc; 
    9289import org.openrdf.query.algebra.evaluation.impl.EvaluationStrategyImpl; 
    93 import org.openrdf.query.algebra.evaluation.iterator.FilterIterator; 
    9490import org.openrdf.query.algebra.evaluation.iterator.OrderIterator; 
    95 import org.openrdf.query.algebra.evaluation.iterator.StSPARQLFilterIterator; 
    9691import org.openrdf.query.algebra.evaluation.iterator.StSPARQLGroupIterator; 
    9792import org.openrdf.query.algebra.evaluation.util.JTSWrapper; 
     
    355350                                if(function instanceof AreaFunc) 
    356351                                { 
    357                                         // check required number of arguments 
    358                                         checkArgs(leftResult, rightResult, thirdResult, 1); 
    359                                          
    360352                                        funcResult = leftGeom.getArea(); 
    361353                                }  
     
    540532                        return null; 
    541533                } 
    542         } 
    543  
    544         /*Evaluation of Filter*/ 
    545         public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(Filter filter, BindingSet bindings) 
    546                         throws QueryEvaluationException 
    547         { 
    548                         CloseableIteration<BindingSet, QueryEvaluationException> result; 
    549                         result = this.evaluate(filter.getArg(), bindings); 
    550  
    551                         Set <String> spatialConstructs = new HashSet<String>(); 
    552                         for(GeneralDBSpatialFuncInfo construct : constructIndexesAndNames.keySet()) { 
    553                                 spatialConstructs.add(construct.getFieldName()); 
    554                         } 
    555                         //add the spatial constructs to the scope of the FILTER (case of a BIND clause 
    556                         //that contains a spatial construct)     
    557                         result = new StSPARQLFilterIterator(filter, result, spatialConstructs, this); 
    558                         return result; 
    559534        } 
    560535 
     
    583558                                 
    584559                        } 
    585  
     560                         
    586561                        if (size > 3) { 
    587                                 throw new NoSuchMethodException("too many arguments."); 
    588                         } 
    589  
    590                         if (size == 1 && (rightResult !=null || thirdResult != null) ) { 
    591                                 throw new NoSuchMethodException("too many arguments."); 
    592                         } 
    593                         if (size == 2 && thirdResult != null) { 
    594562                                throw new NoSuchMethodException("too many arguments."); 
    595563                        } 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/model/XMLGSDatatypeUtil.java

    r1527 r1528  
    11package org.openrdf.sail.generaldb.model; 
    22 
     3import java.math.BigDecimal; 
     4import java.math.BigInteger; 
     5import java.util.StringTokenizer; 
     6 
     7import javax.xml.datatype.DatatypeConfigurationException; 
     8import javax.xml.datatype.DatatypeConstants; 
     9import javax.xml.datatype.DatatypeFactory; 
    310import javax.xml.datatype.XMLGregorianCalendar; 
     11import javax.xml.namespace.QName; 
    412 
    513import org.openrdf.model.Literal; 
    614import org.openrdf.model.URI; 
    715import org.openrdf.model.Value; 
     16import org.openrdf.model.datatypes.XMLDateTime; 
    817import org.openrdf.model.vocabulary.XMLSchema; 
    918import org.openrdf.query.algebra.evaluation.function.spatial.StrabonPolyhedron; 
     
    1524 
    1625 
     26 
    1727public class XMLGSDatatypeUtil { 
    1828         
     29        private static DatatypeFactory dtFactory; 
     30 
     31        static { 
     32                try { 
     33                        dtFactory = DatatypeFactory.newInstance(); 
     34                } 
     35                catch (DatatypeConfigurationException e) { 
     36                        throw new RuntimeException(e); 
     37                } 
     38        } 
     39 
     40        /*-------------------* 
     41         * Datatype checking * 
     42         *-------------------*/ 
     43 
    1944        /** 
    2045         * Returns true when the given value is an instance of class @{link GeneralDBPolyhedron}  
     
    165190        public static boolean isPrimitiveDatatype(URI datatype) { 
    166191                return 
    167                 XMLSchema.DURATION.equals(datatype)|| 
    168                 XMLSchema.DATETIME.equals(datatype) || 
    169                 XMLSchema.TIME.equals(datatype) || 
    170                 XMLSchema.DATE.equals(datatype) || 
    171                 XMLSchema.GYEARMONTH.equals(datatype) || 
    172                 XMLSchema.GYEAR.equals(datatype) || 
    173                 XMLSchema.GMONTHDAY.equals(datatype) || 
    174                 XMLSchema.GDAY.equals(datatype) || 
    175                 XMLSchema.GMONTH.equals(datatype) || 
    176                 XMLSchema.STRING.equals(datatype) || 
    177                 XMLSchema.BOOLEAN.equals(datatype) || 
    178                 XMLSchema.BASE64BINARY.equals(datatype) || 
    179                 XMLSchema.HEXBINARY.equals(datatype) || 
    180                 XMLSchema.FLOAT.equals(datatype) || 
    181                 XMLSchema.DECIMAL.equals(datatype) || 
    182                 XMLSchema.DOUBLE.equals(datatype) || 
    183                 XMLSchema.ANYURI.equals(datatype) || 
    184                 XMLSchema.QNAME.equals(datatype) || 
    185                 XMLSchema.NOTATION.equals(datatype); 
     192                datatype.equals(XMLSchema.DURATION) || 
     193                datatype.equals(XMLSchema.DATETIME) || 
     194                datatype.equals(XMLSchema.TIME) || 
     195                datatype.equals(XMLSchema.DATE) || 
     196                datatype.equals(XMLSchema.GYEARMONTH) || 
     197                datatype.equals(XMLSchema.GYEAR) || 
     198                datatype.equals(XMLSchema.GMONTHDAY) || 
     199                datatype.equals(XMLSchema.GDAY) || 
     200                datatype.equals(XMLSchema.GMONTH) || 
     201                datatype.equals(XMLSchema.STRING) || 
     202                datatype.equals(XMLSchema.BOOLEAN) || 
     203                datatype.equals(XMLSchema.BASE64BINARY) || 
     204                datatype.equals(XMLSchema.HEXBINARY) || 
     205                datatype.equals(XMLSchema.FLOAT) || 
     206                datatype.equals(XMLSchema.DECIMAL) || 
     207                datatype.equals(XMLSchema.DOUBLE) || 
     208                datatype.equals(XMLSchema.ANYURI) || 
     209                datatype.equals(XMLSchema.QNAME) || 
     210                datatype.equals(XMLSchema.NOTATION); 
    186211        } 
    187212 
     
    191216        public static boolean isDerivedDatatype(URI datatype) { 
    192217                return 
    193                 XMLSchema.NORMALIZEDSTRING.equals(datatype) || 
    194                 XMLSchema.TOKEN.equals(datatype) || 
    195                 XMLSchema.LANGUAGE.equals(datatype) || 
    196                 XMLSchema.NMTOKEN.equals(datatype) || 
    197                 XMLSchema.NMTOKENS.equals(datatype) || 
    198                 XMLSchema.NAME.equals(datatype) || 
    199                 XMLSchema.NCNAME.equals(datatype) || 
    200                 XMLSchema.ID.equals(datatype) || 
    201                 XMLSchema.IDREF.equals(datatype) || 
    202                 XMLSchema.IDREFS.equals(datatype) || 
    203                 XMLSchema.ENTITY.equals(datatype) || 
    204                 XMLSchema.ENTITIES.equals(datatype) || 
    205                 XMLSchema.INTEGER.equals(datatype) || 
    206                 XMLSchema.LONG.equals(datatype) || 
    207                 XMLSchema.INT.equals(datatype) || 
    208                 XMLSchema.SHORT.equals(datatype) || 
    209                 XMLSchema.BYTE.equals(datatype) || 
    210                 XMLSchema.NON_POSITIVE_INTEGER.equals(datatype) || 
    211                 XMLSchema.NEGATIVE_INTEGER.equals(datatype) || 
    212                 XMLSchema.NON_NEGATIVE_INTEGER.equals(datatype) || 
    213                 XMLSchema.POSITIVE_INTEGER.equals(datatype) || 
    214                 XMLSchema.UNSIGNED_LONG.equals(datatype) || 
    215                 XMLSchema.UNSIGNED_INT.equals(datatype) || 
    216                 XMLSchema.UNSIGNED_SHORT.equals(datatype) || 
    217                 XMLSchema.UNSIGNED_BYTE.equals(datatype); 
     218                datatype.equals(XMLSchema.NORMALIZEDSTRING) || 
     219                datatype.equals(XMLSchema.TOKEN) || 
     220                datatype.equals(XMLSchema.LANGUAGE) || 
     221                datatype.equals(XMLSchema.NMTOKEN) || 
     222                datatype.equals(XMLSchema.NMTOKENS) || 
     223                datatype.equals(XMLSchema.NAME) || 
     224                datatype.equals(XMLSchema.NCNAME) || 
     225                datatype.equals(XMLSchema.ID) || 
     226                datatype.equals(XMLSchema.IDREF) || 
     227                datatype.equals(XMLSchema.IDREFS) || 
     228                datatype.equals(XMLSchema.ENTITY) || 
     229                datatype.equals(XMLSchema.ENTITIES) || 
     230                datatype.equals(XMLSchema.INTEGER) || 
     231                datatype.equals(XMLSchema.LONG) || 
     232                datatype.equals(XMLSchema.INT) || 
     233                datatype.equals(XMLSchema.SHORT) || 
     234                datatype.equals(XMLSchema.BYTE) || 
     235                datatype.equals(XMLSchema.NON_POSITIVE_INTEGER) || 
     236                datatype.equals(XMLSchema.NEGATIVE_INTEGER) || 
     237                datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER) || 
     238                datatype.equals(XMLSchema.POSITIVE_INTEGER) || 
     239                datatype.equals(XMLSchema.UNSIGNED_LONG) || 
     240                datatype.equals(XMLSchema.UNSIGNED_INT) || 
     241                datatype.equals(XMLSchema.UNSIGNED_SHORT) || 
     242                datatype.equals(XMLSchema.UNSIGNED_BYTE); 
    218243        } 
    219244 
     
    240265        public static boolean isDecimalDatatype(URI datatype) { 
    241266                return 
    242                 XMLSchema.DECIMAL.equals(datatype) || 
     267                datatype.equals(XMLSchema.DECIMAL) || 
    243268                isIntegerDatatype(datatype); 
    244269        } 
     
    250275        public static boolean isIntegerDatatype(URI datatype) { 
    251276                return 
    252                 XMLSchema.INTEGER.equals(datatype) || 
    253                 XMLSchema.LONG.equals(datatype) || 
    254                 XMLSchema.INT.equals(datatype) || 
    255                 XMLSchema.SHORT.equals(datatype) || 
    256                 XMLSchema.BYTE.equals(datatype) || 
    257                 XMLSchema.NON_POSITIVE_INTEGER.equals(datatype) || 
    258                 XMLSchema.NEGATIVE_INTEGER.equals(datatype) || 
    259                 XMLSchema.NON_NEGATIVE_INTEGER.equals(datatype) || 
    260                 XMLSchema.POSITIVE_INTEGER.equals(datatype) || 
    261                 XMLSchema.UNSIGNED_LONG.equals(datatype) || 
    262                 XMLSchema.UNSIGNED_INT.equals(datatype) || 
    263                 XMLSchema.UNSIGNED_SHORT.equals(datatype) || 
    264                 XMLSchema.UNSIGNED_BYTE.equals(datatype); 
     277                datatype.equals(XMLSchema.INTEGER) || 
     278                datatype.equals(XMLSchema.LONG) || 
     279                datatype.equals(XMLSchema.INT) || 
     280                datatype.equals(XMLSchema.SHORT) || 
     281                datatype.equals(XMLSchema.BYTE) || 
     282                datatype.equals(XMLSchema.NON_POSITIVE_INTEGER) || 
     283                datatype.equals(XMLSchema.NEGATIVE_INTEGER) || 
     284                datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER) || 
     285                datatype.equals(XMLSchema.POSITIVE_INTEGER) || 
     286                datatype.equals(XMLSchema.UNSIGNED_LONG) || 
     287                datatype.equals(XMLSchema.UNSIGNED_INT) || 
     288                datatype.equals(XMLSchema.UNSIGNED_SHORT) || 
     289                datatype.equals(XMLSchema.UNSIGNED_BYTE); 
    265290        } 
    266291 
     
    270295        public static boolean isFloatingPointDatatype(URI datatype) { 
    271296                return  
    272                 XMLSchema.FLOAT.equals(datatype) ||  
    273                 XMLSchema.DOUBLE.equals(datatype); 
     297                datatype.equals(XMLSchema.FLOAT) ||  
     298                datatype.equals(XMLSchema.DOUBLE); 
    274299        } 
    275300 
     
    284309        public static boolean isCalendarDatatype(URI datatype) { 
    285310                return 
    286                 XMLSchema.DATETIME.equals(datatype) || 
    287                 XMLSchema.DATE.equals(datatype) || 
    288                 XMLSchema.TIME.equals(datatype) || 
    289                 XMLSchema.GYEARMONTH.equals(datatype) || 
    290                 XMLSchema.GMONTHDAY.equals(datatype) || 
    291                 XMLSchema.GYEAR.equals(datatype) || 
    292                 XMLSchema.GMONTH.equals(datatype) || 
    293                 XMLSchema.GDAY.equals(datatype); 
    294  
    295         } 
    296  
    297         /** 
    298          * Checks whether the supplied datatype is equal to xsd:boolean. 
    299          *  
     311                datatype.equals(XMLSchema.DATETIME) || 
     312                datatype.equals(XMLSchema.DATE)|| 
     313                datatype.equals(XMLSchema.TIME) || 
     314                datatype.equals(XMLSchema.GYEARMONTH) || 
     315                datatype.equals(XMLSchema.GMONTHDAY) || 
     316                datatype.equals(XMLSchema.GYEAR) || 
     317                datatype.equals(XMLSchema.GMONTH) || 
     318                datatype.equals(XMLSchema.GDAY); 
     319 
     320        } 
     321 
     322        /** 
     323         * Checks whether the supplied datatype is ordered. The values of an ordered 
     324         * datatype can be compared to eachother using operators like <tt>&lt;</tt> 
     325         * and <tt>&gt;</tt>. 
     326         */ 
     327        public static boolean isOrderedDatatype(URI datatype) { 
     328                return isNumericDatatype(datatype) || isCalendarDatatype(datatype); 
     329        } 
     330 
     331        /*----------------* 
     332         * Value checking * 
     333         *----------------*/ 
     334 
     335        public static boolean isValidValue(String value, URI datatype) { 
     336                boolean result = true; 
     337 
     338                if (datatype.equals(XMLSchema.DECIMAL)) { 
     339                        result = isValidDecimal(value); 
     340                } 
     341                else if (datatype.equals(XMLSchema.INTEGER)) { 
     342                        result = isValidInteger(value); 
     343                } 
     344                else if (datatype.equals(XMLSchema.NEGATIVE_INTEGER)) { 
     345                        result = isValidNegativeInteger(value); 
     346                } 
     347                else if (datatype.equals(XMLSchema.NON_POSITIVE_INTEGER)) { 
     348                        result = isValidNonPositiveInteger(value); 
     349                } 
     350                else if (datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER)) { 
     351                        result = isValidNonNegativeInteger(value); 
     352                } 
     353                else if (datatype.equals(XMLSchema.POSITIVE_INTEGER)) { 
     354                        result = isValidPositiveInteger(value); 
     355                } 
     356                else if (datatype.equals(XMLSchema.LONG)) { 
     357                        result = isValidLong(value); 
     358                } 
     359                else if (datatype.equals(XMLSchema.INT)) { 
     360                        result = isValidInt(value); 
     361                } 
     362                else if (datatype.equals(XMLSchema.SHORT)) { 
     363                        result = isValidShort(value); 
     364                } 
     365                else if (datatype.equals(XMLSchema.BYTE)) { 
     366                        result = isValidByte(value); 
     367                } 
     368                else if (datatype.equals(XMLSchema.UNSIGNED_LONG)) { 
     369                        result = isValidUnsignedLong(value); 
     370                } 
     371                else if (datatype.equals(XMLSchema.UNSIGNED_INT)) { 
     372                        result = isValidUnsignedInt(value); 
     373                } 
     374                else if (datatype.equals(XMLSchema.UNSIGNED_SHORT)) { 
     375                        result = isValidUnsignedShort(value); 
     376                } 
     377                else if (datatype.equals(XMLSchema.UNSIGNED_BYTE)) { 
     378                        result = isValidUnsignedByte(value); 
     379                } 
     380                else if (datatype.equals(XMLSchema.FLOAT)) { 
     381                        result = isValidFloat(value); 
     382                } 
     383                else if (datatype.equals(XMLSchema.DOUBLE)) { 
     384                        result = isValidDouble(value); 
     385                } 
     386                else if (datatype.equals(XMLSchema.BOOLEAN)) { 
     387                        result = isValidBoolean(value); 
     388                } 
     389                else if (datatype.equals(XMLSchema.DATETIME)) { 
     390                        result = isValidDateTime(value); 
     391                } 
     392 
     393                return result; 
     394        } 
     395 
     396        public static boolean isValidDecimal(String value) { 
     397                try { 
     398                        normalizeDecimal(value); 
     399                        return true; 
     400                } 
     401                catch (IllegalArgumentException e) { 
     402                        return false; 
     403                } 
     404        } 
     405 
     406        public static boolean isValidInteger(String value) { 
     407                try { 
     408                        normalizeInteger(value); 
     409                        return true; 
     410                } 
     411                catch (IllegalArgumentException e) { 
     412                        return false; 
     413                } 
     414        } 
     415 
     416        public static boolean isValidNegativeInteger(String value) { 
     417                try { 
     418                        normalizeNegativeInteger(value); 
     419                        return true; 
     420                } 
     421                catch (IllegalArgumentException e) { 
     422                        return false; 
     423                } 
     424        } 
     425 
     426        public static boolean isValidNonPositiveInteger(String value) { 
     427                try { 
     428                        normalizeNonPositiveInteger(value); 
     429                        return true; 
     430                } 
     431                catch (IllegalArgumentException e) { 
     432                        return false; 
     433                } 
     434        } 
     435 
     436        public static boolean isValidNonNegativeInteger(String value) { 
     437                try { 
     438                        normalizeNonNegativeInteger(value); 
     439                        return true; 
     440                } 
     441                catch (IllegalArgumentException e) { 
     442                        return false; 
     443                } 
     444        } 
     445 
     446        public static boolean isValidPositiveInteger(String value) { 
     447                try { 
     448                        normalizePositiveInteger(value); 
     449                        return true; 
     450                } 
     451                catch (IllegalArgumentException e) { 
     452                        return false; 
     453                } 
     454        } 
     455        public static boolean isValidLong(String value) { 
     456                try { 
     457                        normalizeLong(value); 
     458                        return true; 
     459                } 
     460                catch (IllegalArgumentException e) { 
     461                        return false; 
     462                } 
     463        } 
     464 
     465        public static boolean isValidInt(String value) { 
     466                try { 
     467                        normalizeInt(value); 
     468                        return true; 
     469                } 
     470                catch (IllegalArgumentException e) { 
     471                        return false; 
     472                } 
     473        } 
     474 
     475        public static boolean isValidShort(String value) { 
     476                try { 
     477                        normalizeShort(value); 
     478                        return true; 
     479                } 
     480                catch (IllegalArgumentException e) { 
     481                        return false; 
     482                } 
     483        } 
     484 
     485        public static boolean isValidByte(String value) { 
     486                try { 
     487                        normalizeByte(value); 
     488                        return true; 
     489                } 
     490                catch (IllegalArgumentException e) { 
     491                        return false; 
     492                } 
     493        } 
     494 
     495        public static boolean isValidUnsignedLong(String value) { 
     496                try { 
     497                        normalizeUnsignedLong(value); 
     498                        return true; 
     499                } 
     500                catch (IllegalArgumentException e) { 
     501                        return false; 
     502                } 
     503        } 
     504 
     505        public static boolean isValidUnsignedInt(String value) { 
     506                try { 
     507                        normalizeUnsignedInt(value); 
     508                        return true; 
     509                } 
     510                catch (IllegalArgumentException e) { 
     511                        return false; 
     512                } 
     513        } 
     514 
     515        public static boolean isValidUnsignedShort(String value) { 
     516                try { 
     517                        normalizeUnsignedShort(value); 
     518                        return true; 
     519                } 
     520                catch (IllegalArgumentException e) { 
     521                        return false; 
     522                } 
     523        } 
     524 
     525        public static boolean isValidUnsignedByte(String value) { 
     526                try { 
     527                        normalizeUnsignedByte(value); 
     528                        return true; 
     529                } 
     530                catch (IllegalArgumentException e) { 
     531                        return false; 
     532                } 
     533        } 
     534 
     535        public static boolean isValidFloat(String value) { 
     536                try { 
     537                        normalizeFloat(value); 
     538                        return true; 
     539                } 
     540                catch (IllegalArgumentException e) { 
     541                        return false; 
     542                } 
     543        } 
     544 
     545        public static boolean isValidDouble(String value) { 
     546                try { 
     547                        normalizeDouble(value); 
     548                        return true; 
     549                } 
     550                catch (IllegalArgumentException e) { 
     551                        return false; 
     552                } 
     553        } 
     554 
     555        public static boolean isValidBoolean(String value) { 
     556                try { 
     557                        normalizeBoolean(value); 
     558                        return true; 
     559                } 
     560                catch (IllegalArgumentException e) { 
     561                        return false; 
     562                } 
     563        } 
     564 
     565        public static boolean isValidDateTime(String value) { 
     566                try { 
     567                        @SuppressWarnings("unused") 
     568                        XMLDateTime dt = new XMLDateTime(value); 
     569                        return true; 
     570                } 
     571                catch (IllegalArgumentException e) { 
     572                        return false; 
     573                } 
     574        } 
     575 
     576        /*---------------------* 
     577         * Value normalization * 
     578         *---------------------*/ 
     579 
     580        /** 
     581         * Normalizes the supplied value according to the normalization rules for the 
     582         * supplied datatype. 
     583         *  
     584         * @param value 
     585         *        The value to normalize. 
    300586         * @param datatype 
    301          * @return 
    302          */ 
    303         public static boolean isBooleanDatatype(URI datatype) { 
    304                 return XMLSchema.BOOLEAN.equals(datatype); 
    305         } 
     587         *        The value's datatype. 
     588         * @return The normalized value if there are any (supported) normalization 
     589         *         rules for the supplied datatype, or the original supplied value 
     590         *         otherwise. 
     591         * @throws IllegalArgumentException 
     592         *         If the supplied value is illegal considering the supplied 
     593         *         datatype. 
     594         */ 
     595        public static String normalize(String value, URI datatype) { 
     596                String result = value; 
     597 
     598                if (datatype.equals(XMLSchema.DECIMAL)) { 
     599                        result = normalizeDecimal(value); 
     600                } 
     601                else if (datatype.equals(XMLSchema.INTEGER)) { 
     602                        result = normalizeInteger(value); 
     603                } 
     604                else if (datatype.equals(XMLSchema.NEGATIVE_INTEGER)) { 
     605                        result = normalizeNegativeInteger(value); 
     606                } 
     607                else if (datatype.equals(XMLSchema.NON_POSITIVE_INTEGER)) { 
     608                        result = normalizeNonPositiveInteger(value); 
     609                } 
     610                else if (datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER)) { 
     611                        result = normalizeNonNegativeInteger(value); 
     612                } 
     613                else if (datatype.equals(XMLSchema.POSITIVE_INTEGER)) { 
     614                        result = normalizePositiveInteger(value); 
     615                } 
     616                else if (datatype.equals(XMLSchema.LONG)) { 
     617                        result = normalizeLong(value); 
     618                } 
     619                else if (datatype.equals(XMLSchema.INT)) { 
     620                        result = normalizeInt(value); 
     621                } 
     622                else if (datatype.equals(XMLSchema.SHORT)) { 
     623                        result = normalizeShort(value); 
     624                } 
     625                else if (datatype.equals(XMLSchema.BYTE)) { 
     626                        result = normalizeByte(value); 
     627                } 
     628                else if (datatype.equals(XMLSchema.UNSIGNED_LONG)) { 
     629                        result = normalizeUnsignedLong(value); 
     630                } 
     631                else if (datatype.equals(XMLSchema.UNSIGNED_INT)) { 
     632                        result = normalizeUnsignedInt(value); 
     633                } 
     634                else if (datatype.equals(XMLSchema.UNSIGNED_SHORT)) { 
     635                        result = normalizeUnsignedShort(value); 
     636                } 
     637                else if (datatype.equals(XMLSchema.UNSIGNED_BYTE)) { 
     638                        result = normalizeUnsignedByte(value); 
     639                } 
     640                else if (datatype.equals(XMLSchema.FLOAT)) { 
     641                        result = normalizeFloat(value); 
     642                } 
     643                else if (datatype.equals(XMLSchema.DOUBLE)) { 
     644                        result = normalizeDouble(value); 
     645                } 
     646                else if (datatype.equals(XMLSchema.BOOLEAN)) { 
     647                        result = normalizeBoolean(value); 
     648                } 
     649                else if (datatype.equals(XMLSchema.DATETIME)) { 
     650                        result = normalizeDateTime(value); 
     651                } 
     652 
     653                return result; 
     654        } 
     655 
     656        /** 
     657         * Normalizes a boolean value to its canonical representation. More 
     658         * specifically, the values <tt>1</tt> and <tt>0</tt> will be normalized 
     659         * to the canonical values <tt>true</tt> and <tt>false</tt>, 
     660         * respectively. Supplied canonical values will remain as is. 
     661         *  
     662         * @param value 
     663         *        The boolean value to normalize. 
     664         * @return The normalized value. 
     665         * @throws IllegalArgumentException 
     666         *         If the supplied value is not a legal boolean. 
     667         */ 
     668        public static String normalizeBoolean(String value) { 
     669                value = collapseWhiteSpace(value); 
     670 
     671                if (value.equals("1")) { 
     672                        return "true"; 
     673                } 
     674                else if (value.equals("0")) { 
     675                        return "false"; 
     676                } 
     677                else if (value.equals("true") || value.equals("false")) { 
     678                        return value; 
     679                } 
     680                else { 
     681                        throw new IllegalArgumentException("Not a legal boolean value: " + value); 
     682                } 
     683        } 
     684 
     685        /** 
     686         * Normalizes a decimal to its canonical representation. For example: 
     687         * <tt>120</tt> becomes <tt>120.0</tt>, <tt>+.3</tt> becomes 
     688         * <tt>0.3</tt>, <tt>00012.45000</tt> becomes <tt>12.45</tt> and 
     689         * <tt>-.0</tt> becomes <tt>0.0</tt>. 
     690         *  
     691         * @param decimal 
     692         *        The decimal to normalize. 
     693         * @return The canonical representation of <tt>decimal</tt>. 
     694         * @throws IllegalArgumentException 
     695         *         If one of the supplied strings is not a legal decimal. 
     696         */ 
     697        public static String normalizeDecimal(String decimal) { 
     698                decimal = collapseWhiteSpace(decimal); 
     699 
     700                String errMsg = "Not a legal decimal: " + decimal; 
     701 
     702                int decLength = decimal.length(); 
     703                StringBuilder result = new StringBuilder(decLength + 2); 
     704 
     705                if (decLength == 0) { 
     706                        throwIAE(errMsg); 
     707                } 
     708 
     709                boolean isZeroPointZero = true; 
     710 
     711                // process any sign info 
     712                int idx = 0; 
     713                if (decimal.charAt(idx) == '-') { 
     714                        result.append('-'); 
     715                        idx++; 
     716                } 
     717                else if (decimal.charAt(idx) == '+') { 
     718                        idx++; 
     719                } 
     720 
     721                if (idx == decLength) { 
     722                        throwIAE(errMsg); 
     723                } 
     724 
     725                // skip any leading zeros 
     726                while (idx < decLength && decimal.charAt(idx) == '0') { 
     727                        idx++; 
     728                } 
     729 
     730                // Process digits before the dot 
     731                if (idx == decLength) { 
     732                        // decimal consists of zeros only 
     733                        result.append('0'); 
     734                } 
     735                else if (idx < decLength && decimal.charAt(idx) == '.') { 
     736                        // no non-zero digit before the dot 
     737                        result.append('0'); 
     738                } 
     739                else { 
     740                        isZeroPointZero = false; 
     741 
     742                        // Copy any digits before the dot 
     743                        while (idx < decLength) { 
     744                                char c = decimal.charAt(idx); 
     745                                if (c == '.') { 
     746                                        break; 
     747                                } 
     748                                if (!isDigit(c)) { 
     749                                        throwIAE(errMsg); 
     750                                } 
     751                                result.append(c); 
     752                                idx++; 
     753                        } 
     754                } 
     755 
     756                result.append('.'); 
     757 
     758                // Process digits after the dot 
     759                if (idx == decLength) { 
     760                        // No dot was found in the decimal 
     761                        result.append('0'); 
     762                } 
     763                else { 
     764                        idx++; 
     765 
     766                        // search last non-zero digit 
     767                        int lastIdx = decLength - 1; 
     768                        while (lastIdx >= 0 && decimal.charAt(lastIdx) == '0') { 
     769                                lastIdx--; 
     770                        } 
     771 
     772                        if (idx > lastIdx) { 
     773                                // No non-zero digits found 
     774                                result.append('0'); 
     775                        } 
     776                        else { 
     777                                isZeroPointZero = false; 
     778 
     779                                while (idx <= lastIdx) { 
     780                                        char c = decimal.charAt(idx); 
     781                                        if (!isDigit(c)) { 
     782                                                throwIAE(errMsg); 
     783                                        } 
     784                                        result.append(c); 
     785                                        idx++; 
     786                                } 
     787                        } 
     788                } 
     789 
     790                if (isZeroPointZero) { 
     791                        // Make sure we don't return "-0.0" 
     792                        return "0.0"; 
     793                } 
     794                else { 
     795                        return result.toString(); 
     796                } 
     797        } 
     798 
     799        /** 
     800         * Normalizes an integer to its canonical representation. For example: 
     801         * <tt>+120</tt> becomes <tt>120</tt> and <tt>00012</tt> becomes 
     802         * <tt>12</tt>. 
     803         *  
     804         * @param value 
     805         *        The value to normalize. 
     806         * @return The canonical representation of <tt>value</tt>. 
     807         * @throws IllegalArgumentException 
     808         *         If the supplied value is not a legal integer. 
     809         */ 
     810        public static String normalizeInteger(String value) { 
     811                return normalizeIntegerValue(value, null, null); 
     812        } 
     813 
     814        /** 
     815         * Normalizes an xsd:negativeInteger. 
     816         */ 
     817        public static String normalizeNegativeInteger(String value) { 
     818                return normalizeIntegerValue(value, null, "-1"); 
     819        } 
     820 
     821        /** 
     822         * Normalizes an xsd:nonPositiveInteger. 
     823         */ 
     824        public static String normalizeNonPositiveInteger(String value) { 
     825                return normalizeIntegerValue(value, null, "0"); 
     826        } 
     827 
     828        /** 
     829         * Normalizes an xsd:nonNegativeInteger. 
     830         */ 
     831        public static String normalizeNonNegativeInteger(String value) { 
     832                return normalizeIntegerValue(value, "0", null); 
     833        } 
     834 
     835        /** 
     836         * Normalizes an xsd:positiveInteger. 
     837         */ 
     838        public static String normalizePositiveInteger(String value) { 
     839                return normalizeIntegerValue(value, "1", null); 
     840        } 
     841 
     842        /** 
     843         * Normalizes an xsd:long. 
     844         */ 
     845        public static String normalizeLong(String value) { 
     846                return normalizeIntegerValue(value, "-9223372036854775808", "9223372036854775807"); 
     847        } 
     848 
     849        /** 
     850         * Normalizes an xsd:int. 
     851         */ 
     852        public static String normalizeInt(String value) { 
     853                return normalizeIntegerValue(value, "-2147483648", "2147483647"); 
     854        } 
     855 
     856        /** 
     857         * Normalizes an xsd:short. 
     858         */ 
     859        public static String normalizeShort(String value) { 
     860                return normalizeIntegerValue(value, "-32768", "32767"); 
     861        } 
     862 
     863        /** 
     864         * Normalizes an xsd:byte. 
     865         */ 
     866        public static String normalizeByte(String value) { 
     867                return normalizeIntegerValue(value, "-128", "127"); 
     868        } 
     869 
     870        /** 
     871         * Normalizes an xsd:unsignedLong. 
     872         */ 
     873        public static String normalizeUnsignedLong(String value) { 
     874                return normalizeIntegerValue(value, "0", "18446744073709551615"); 
     875        } 
     876 
     877        /** 
     878         * Normalizes an xsd:unsignedInt. 
     879         */ 
     880        public static String normalizeUnsignedInt(String value) { 
     881                return normalizeIntegerValue(value, "0", "4294967295"); 
     882        } 
     883 
     884        /** 
     885         * Normalizes an xsd:unsignedShort. 
     886         */ 
     887        public static String normalizeUnsignedShort(String value) { 
     888                return normalizeIntegerValue(value, "0", "65535"); 
     889        } 
     890 
     891        /** 
     892         * Normalizes an xsd:unsignedByte. 
     893         */ 
     894        public static String normalizeUnsignedByte(String value) { 
     895                return normalizeIntegerValue(value, "0", "255"); 
     896        } 
     897 
     898        /** 
     899         * Normalizes an integer to its canonical representation and checks that the 
     900         * value is in the range [minValue, maxValue]. 
     901         */ 
     902        private static String normalizeIntegerValue(String integer, String minValue, String maxValue) { 
     903                integer = collapseWhiteSpace(integer); 
     904 
     905                String errMsg = "Not a legal integer: " + integer; 
     906 
     907                int intLength = integer.length(); 
     908 
     909                if (intLength == 0) { 
     910                        throwIAE(errMsg); 
     911                } 
     912 
     913                int idx = 0; 
     914 
     915                // process any sign info 
     916                boolean isNegative = false; 
     917                if (integer.charAt(idx) == '-') { 
     918                        isNegative = true; 
     919                        idx++; 
     920                } 
     921                else if (integer.charAt(idx) == '+') { 
     922                        idx++; 
     923                } 
     924 
     925                if (idx == intLength) { 
     926                        throwIAE(errMsg); 
     927                } 
     928 
     929                if (integer.charAt(idx) == '0' && idx < intLength - 1) { 
     930                        // integer starts with a zero followed by more characters, 
     931                        // skip any leading zeros 
     932                        idx++; 
     933                        while (idx < intLength - 1 && integer.charAt(idx) == '0') { 
     934                                idx++; 
     935                        } 
     936                } 
     937 
     938                String norm = integer.substring(idx); 
     939 
     940                // Check that all characters in 'norm' are digits 
     941                for (int i = 0; i < norm.length(); i++) { 
     942                        if (!isDigit(norm.charAt(i))) { 
     943                                throwIAE(errMsg); 
     944                        } 
     945                } 
     946 
     947                if (isNegative && norm.charAt(0) != '0') { 
     948                        norm = "-" + norm; 
     949                } 
     950 
     951                // Check lower and upper bounds, if applicable 
     952                if (minValue != null) { 
     953                        if (compareCanonicalIntegers(norm, minValue) < 0) { 
     954                                throwIAE("Value smaller than minimum value"); 
     955                        } 
     956                } 
     957                if (maxValue != null) { 
     958                        if (compareCanonicalIntegers(norm, maxValue) > 0) { 
     959                                throwIAE("Value larger than maximum value"); 
     960                        } 
     961                } 
     962 
     963                return norm; 
     964        } 
     965 
     966        /** 
     967         * Normalizes a float to its canonical representation. 
     968         *  
     969         * @param value 
     970         *        The value to normalize. 
     971         * @return The canonical representation of <tt>value</tt>. 
     972         * @throws IllegalArgumentException 
     973         *         If the supplied value is not a legal float. 
     974         */ 
     975        public static String normalizeFloat(String value) { 
     976                return normalizeFPNumber(value, "-16777215.0", "16777215.0", "-149", "104"); 
     977        } 
     978 
     979        /** 
     980         * Normalizes a double to its canonical representation. 
     981         *  
     982         * @param value 
     983         *        The value to normalize. 
     984         * @return The canonical representation of <tt>value</tt>. 
     985         * @throws IllegalArgumentException 
     986         *         If the supplied value is not a legal double. 
     987         */ 
     988        public static String normalizeDouble(String value) { 
     989                return normalizeFPNumber(value, "-9007199254740991.0", "9007199254740991.0", "-1075", "970"); 
     990        } 
     991 
     992        /** 
     993         * Normalizes a floating point number to its canonical representation. 
     994         *  
     995         * @param value 
     996         *        The value to normalize. 
     997         * @return The canonical representation of <tt>value</tt>. 
     998         * @throws IllegalArgumentException 
     999         *         If the supplied value is not a legal floating point number. 
     1000         */ 
     1001        public static String normalizeFPNumber(String value) { 
     1002                return normalizeFPNumber(value, null, null, null, null); 
     1003        } 
     1004 
     1005        /** 
     1006         * Normalizes a floating point number to its canonical representation. 
     1007         *  
     1008         * @param value 
     1009         *        The value to normalize. 
     1010         * @param minMantissa 
     1011         *        A normalized decimal indicating the lowest value that the mantissa 
     1012         *        may have. 
     1013         * @param maxMantissa 
     1014         *        A normalized decimal indicating the highest value that the mantissa 
     1015         *        may have. 
     1016         * @param minExponent 
     1017         *        A normalized integer indicating the lowest value that the exponent 
     1018         *        may have. 
     1019         * @param maxExponent 
     1020         *        A normalized integer indicating the highest value that the exponent 
     1021         *        may have. 
     1022         * @return The canonical representation of <tt>value</tt>. 
     1023         * @throws IllegalArgumentException 
     1024         *         If the supplied value is not a legal floating point number. 
     1025         */ 
     1026        private static String normalizeFPNumber( 
     1027                        String value, 
     1028                        String minMantissa, String maxMantissa, 
     1029                        String minExponent, String maxExponent) 
     1030        { 
     1031                value = collapseWhiteSpace(value); 
     1032 
     1033                // handle special values 
     1034                if (value.equals("INF") || value.equals("-INF") || value.equals("NaN")) { 
     1035                        return value; 
     1036                } 
     1037 
     1038                // Search for the exponent character E or e 
     1039                int eIdx = value.indexOf('E'); 
     1040                if (eIdx == -1) { 
     1041                        // try lower case 
     1042                        eIdx = value.indexOf('e'); 
     1043                } 
     1044 
     1045                // Extract mantissa and exponent 
     1046                String mantissa, exponent; 
     1047                if (eIdx == -1) { 
     1048                        mantissa = normalizeDecimal(value); 
     1049                        exponent = "0"; 
     1050                } 
     1051                else { 
     1052                        mantissa = normalizeDecimal(value.substring(0, eIdx)); 
     1053                        exponent = normalizeInteger(value.substring(eIdx + 1)); 
     1054                } 
     1055 
     1056                // Check lower and upper bounds, if applicable 
     1057                if (minMantissa != null) { 
     1058                        if (compareCanonicalDecimals(mantissa, minMantissa) < 0) { 
     1059                                throwIAE("Mantissa smaller than minimum value (" + minMantissa + ")"); 
     1060                        } 
     1061                } 
     1062                if (maxMantissa != null) { 
     1063                        if (compareCanonicalDecimals(mantissa, maxMantissa) > 0) { 
     1064                                throwIAE("Mantissa larger than maximum value (" + maxMantissa + ")"); 
     1065                        } 
     1066                } 
     1067                if (minExponent != null) { 
     1068                        if (compareCanonicalIntegers(exponent, minExponent) < 0) { 
     1069                                throwIAE("Exponent smaller than minimum value (" + minExponent + ")"); 
     1070                        } 
     1071                } 
     1072                if (maxExponent != null) { 
     1073                        if (compareCanonicalIntegers(exponent, maxExponent) > 0) { 
     1074                                throwIAE("Exponent larger than maximum value (" + maxExponent + ")"); 
     1075                        } 
     1076                } 
     1077 
     1078                // Normalize mantissa to one non-zero digit before the dot 
     1079                int shift = 0; 
     1080 
     1081                int dotIdx = mantissa.indexOf('.'); 
     1082                int digitCount = dotIdx; 
     1083                if (mantissa.charAt(0) == '-') { 
     1084                        digitCount--; 
     1085                } 
     1086 
     1087                if (digitCount > 1) { 
     1088                        // more than one digit before the dot, e.g 123.45, -10.0 or 100.0 
     1089                        StringBuilder sb = new StringBuilder(mantissa.length()); 
     1090                        int firstDigitIdx = 0; 
     1091                        if (mantissa.charAt(0) == '-') { 
     1092                                sb.append('-'); 
     1093                                firstDigitIdx = 1; 
     1094                        } 
     1095                        sb.append(mantissa.charAt(firstDigitIdx)); 
     1096                        sb.append('.'); 
     1097                        sb.append(mantissa.substring(firstDigitIdx + 1, dotIdx)); 
     1098                        sb.append(mantissa.substring(dotIdx + 1)); 
     1099 
     1100                        mantissa = sb.toString(); 
     1101 
     1102                        // Check if the mantissa has excessive trailing zeros. 
     1103                        // For example, 100.0 will be normalize to 1.000 and 
     1104                        // -10.0 to -1.00. 
     1105                        int nonZeroIdx = mantissa.length() - 1; 
     1106                        while (nonZeroIdx >= 3 && mantissa.charAt(nonZeroIdx) == '0') { 
     1107                                nonZeroIdx--; 
     1108                        } 
     1109 
     1110                        if (nonZeroIdx < 3 && mantissa.charAt(0) == '-') { 
     1111                                nonZeroIdx++; 
     1112                        } 
     1113 
     1114                        if (nonZeroIdx < mantissa.length() - 1) { 
     1115                                mantissa = mantissa.substring(0, nonZeroIdx + 1); 
     1116                        } 
     1117 
     1118                        shift = 1 - digitCount; 
     1119                } 
     1120                else if (mantissa.startsWith("0.") || mantissa.startsWith("-0.")) { 
     1121                        // Example mantissas: 0.0, -0.1, 0.00345 and 0.09 
     1122                        // search first non-zero digit 
     1123                        int nonZeroIdx = 2; 
     1124                        while (nonZeroIdx < mantissa.length() && mantissa.charAt(nonZeroIdx) == '0') { 
     1125                                nonZeroIdx++; 
     1126                        } 
     1127 
     1128                        // 0.0 does not need any normalization: 
     1129                        if (nonZeroIdx < mantissa.length()) { 
     1130                                StringBuilder sb = new StringBuilder(mantissa.length()); 
     1131                                sb.append(mantissa.charAt(nonZeroIdx)); 
     1132                                sb.append('.'); 
     1133                                if (nonZeroIdx == mantissa.length() - 1) { 
     1134                                        // There was only one non-zero digit, e.g. as in 0.09 
     1135                                        sb.append('0'); 
     1136                                } 
     1137                                else { 
     1138                                        sb.append(mantissa.substring(nonZeroIdx + 1)); 
     1139                                } 
     1140 
     1141                                mantissa = sb.toString(); 
     1142                                shift = nonZeroIdx - 1; 
     1143                        } 
     1144                } 
     1145 
     1146                if (shift != 0) { 
     1147                        try { 
     1148                                int exp = Integer.parseInt(exponent); 
     1149                                exponent = String.valueOf(exp - shift); 
     1150                        } 
     1151                        catch (NumberFormatException e) { 
     1152                                throw new RuntimeException("NumberFormatException: " + e.getMessage()); 
     1153                        } 
     1154                } 
     1155 
     1156                return mantissa + "E" + exponent; 
     1157        } 
     1158 
     1159        /** 
     1160         * Normalizes an xsd:dateTime. 
     1161         *  
     1162         * @param value 
     1163         *        The value to normalize. 
     1164         * @return The normalized value. 
     1165         * @throws IllegalArgumentException 
     1166         *         If the supplied value is not a legal xsd:dateTime value. 
     1167         */ 
     1168        public static String normalizeDateTime(String value) { 
     1169                XMLDateTime dt = new XMLDateTime(value); 
     1170                dt.normalize(); 
     1171                return dt.toString(); 
     1172        } 
     1173 
     1174        /** 
     1175         * Replaces all occurences of #x9 (tab), #xA (line feed) and #xD (carriage 
     1176         * return) with #x20 (space), as specified for whiteSpace facet 
     1177         * <tt>replace</tt>. 
     1178         */ 
     1179        // private static String replaceWhiteSpace(String s) { 
     1180        // s = StringUtil.gsub("\t", " ", s); 
     1181        // s = StringUtil.gsub("\r", " ", s); 
     1182        // s = StringUtil.gsub("\n", " ", s); 
     1183        // return s; 
     1184        // } 
     1185 
     1186        /** 
     1187         * Replaces all contiguous sequences of #x9 (tab), #xA (line feed) and #xD 
     1188         * (carriage return) with a single #x20 (space) character, and removes any 
     1189         * leading and trailing whitespace characters, as specified for whiteSpace 
     1190         * facet <tt>collapse</tt>. 
     1191         */ 
     1192        public static String collapseWhiteSpace(String s) { 
     1193                StringBuilder sb = new StringBuilder(s.length()); 
     1194 
     1195                StringTokenizer st = new StringTokenizer(s, "\t\r\n "); 
     1196 
     1197                if (st.hasMoreTokens()) { 
     1198                        sb.append(st.nextToken()); 
     1199                } 
     1200 
     1201                while (st.hasMoreTokens()) { 
     1202                        sb.append(' ').append(st.nextToken()); 
     1203                } 
     1204 
     1205                return sb.toString(); 
     1206        } 
     1207 
     1208        /*------------------* 
     1209         * Value comparison * 
     1210         *------------------*/ 
     1211 
     1212        public static int compare(String value1, String value2, URI datatype) { 
     1213                if (datatype.equals(XMLSchema.DECIMAL)) { 
     1214                        return compareDecimals(value1, value2); 
     1215                } 
     1216                else if (datatype.equals(XMLSchema.INTEGER)) { 
     1217                        return compareIntegers(value1, value2); 
     1218                } 
     1219                else if (datatype.equals(XMLSchema.NEGATIVE_INTEGER)) { 
     1220                        return compareNegativeIntegers(value1, value2); 
     1221                } 
     1222                else if (datatype.equals(XMLSchema.NON_POSITIVE_INTEGER)) { 
     1223                        return compareNonPositiveIntegers(value1, value2); 
     1224                } 
     1225                else if (datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER)) { 
     1226                        return compareNonNegativeIntegers(value1, value2); 
     1227                } 
     1228                else if (datatype.equals(XMLSchema.POSITIVE_INTEGER)) { 
     1229                        return comparePositiveIntegers(value1, value2); 
     1230                } 
     1231                else if (datatype.equals(XMLSchema.LONG)) { 
     1232                        return compareLongs(value1, value2); 
     1233                } 
     1234                else if (datatype.equals(XMLSchema.INT)) { 
     1235                        return compareInts(value1, value2); 
     1236                } 
     1237                else if (datatype.equals(XMLSchema.SHORT)) { 
     1238                        return compareShorts(value1, value2); 
     1239                } 
     1240                else if (datatype.equals(XMLSchema.BYTE)) { 
     1241                        return compareBytes(value1, value2); 
     1242                } 
     1243                else if (datatype.equals(XMLSchema.UNSIGNED_LONG)) { 
     1244                        return compareUnsignedLongs(value1, value2); 
     1245                } 
     1246                else if (datatype.equals(XMLSchema.UNSIGNED_INT)) { 
     1247                        return compareUnsignedInts(value1, value2); 
     1248                } 
     1249                else if (datatype.equals(XMLSchema.UNSIGNED_SHORT)) { 
     1250                        return compareUnsignedShorts(value1, value2); 
     1251                } 
     1252                else if (datatype.equals(XMLSchema.UNSIGNED_BYTE)) { 
     1253                        return compareUnsignedBytes(value1, value2); 
     1254                } 
     1255                else if (datatype.equals(XMLSchema.FLOAT)) { 
     1256                        return compareFloats(value1, value2); 
     1257                } 
     1258                else if (datatype.equals(XMLSchema.DOUBLE)) { 
     1259                        return compareDoubles(value1, value2); 
     1260                } 
     1261                else if (datatype.equals(XMLSchema.DATETIME)) { 
     1262                        return compareDateTime(value1, value2); 
     1263                } 
     1264                else { 
     1265                        throw new IllegalArgumentException("datatype is not ordered"); 
     1266                } 
     1267        } 
     1268 
     1269        /** 
     1270         * Compares two decimals to eachother. 
     1271         *  
     1272         * @return A negative number if <tt>dec1</tt> is smaller than <tt>dec2</tt>, 
     1273         *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
     1274         *         <tt>dec1</tt> is larger than <tt>dec2</tt>. 
     1275         * @throws IllegalArgumentException 
     1276         *         If one of the supplied strings is not a legal decimal. 
     1277         */ 
     1278        public static int compareDecimals(String dec1, String dec2) { 
     1279                dec1 = normalizeDecimal(dec1); 
     1280                dec2 = normalizeDecimal(dec2); 
     1281 
     1282                return compareCanonicalDecimals(dec1, dec2); 
     1283        } 
     1284 
     1285        /** 
     1286         * Compares two canonical decimals to eachother. 
     1287         *  
     1288         * @return A negative number if <tt>dec1</tt> is smaller than <tt>dec2</tt>, 
     1289         *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
     1290         *         <tt>dec1</tt> is larger than <tt>dec2</tt>. The result is 
     1291         *         undefined when one or both of the arguments is not a canonical 
     1292         *         decimal. 
     1293         * @throws IllegalArgumentException 
     1294         *         If one of the supplied strings is not a legal decimal. 
     1295         */ 
     1296        public static int compareCanonicalDecimals(String dec1, String dec2) { 
     1297                if (dec1.equals(dec2)) { 
     1298                        return 0; 
     1299                } 
     1300 
     1301                // Check signs 
     1302                if (dec1.charAt(0) == '-' && dec2.charAt(0) != '-') { 
     1303                        // dec1 is negative, dec2 is not 
     1304                        return -1; 
     1305                } 
     1306                if (dec2.charAt(0) == '-' && dec1.charAt(0) != '-') { 
     1307                        // dec2 is negative, dec1 is not 
     1308                        return 1; 
     1309                } 
     1310 
     1311                int dotIdx1 = dec1.indexOf('.'); 
     1312                int dotIdx2 = dec2.indexOf('.'); 
     1313 
     1314                // The decimal with the most digits before the dot is the largest 
     1315                int result = dotIdx1 - dotIdx2; 
     1316 
     1317                if (result == 0) { 
     1318                        // equal number of digits before the dot, compare them 
     1319                        for (int i = 0; result == 0 && i < dotIdx1; i++) { 
     1320                                result = dec1.charAt(i) - dec2.charAt(i); 
     1321                        } 
     1322 
     1323                        // Continue comparing digits after the dot if necessary 
     1324                        int dec1Length = dec1.length(); 
     1325                        int dec2Length = dec2.length(); 
     1326                        int lastIdx = dec1Length <= dec2Length ? dec1Length : dec2Length; 
     1327 
     1328                        for (int i = dotIdx1 + 1; result == 0 && i < lastIdx; i++) { 
     1329                                result = dec1.charAt(i) - dec2.charAt(i); 
     1330                        } 
     1331 
     1332                        // Still equal? The decimal with the most digits is the largest 
     1333                        if (result == 0) { 
     1334                                result = dec1Length - dec2Length; 
     1335                        } 
     1336                } 
     1337 
     1338                if (dec1.charAt(0) == '-') { 
     1339                        // reverse result for negative values 
     1340                        result = -result; 
     1341                } 
     1342 
     1343                return result; 
     1344        } 
     1345 
     1346        /** 
     1347         * Compares two integers to eachother. 
     1348         *  
     1349         * @return A negative number if <tt>int1</tt> is smaller than <tt>int2</tt>, 
     1350         *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
     1351         *         <tt>int1</tt> is larger than <tt>int2</tt>. 
     1352         * @throws IllegalArgumentException 
     1353         *         If one of the supplied strings is not a legal integer. 
     1354         */ 
     1355        public static int compareIntegers(String int1, String int2) { 
     1356                int1 = normalizeInteger(int1); 
     1357                int2 = normalizeInteger(int2); 
     1358 
     1359                return compareCanonicalIntegers(int1, int2); 
     1360        } 
     1361 
     1362        /** 
     1363         * Compares two canonical integers to eachother. 
     1364         *  
     1365         * @return A negative number if <tt>int1</tt> is smaller than <tt>int2</tt>, 
     1366         *         <tt>0</tt> if they are equal, or positive (&gt;0) if 
     1367         *         <tt>int1</tt> is larger than <tt>int2</tt>. The result is 
     1368         *         undefined when one or both of the arguments is not a canonical 
     1369         *         integer. 
     1370         * @throws IllegalArgumentException 
     1371         *         If one of the supplied strings is not a legal integer. 
     1372         */ 
     1373        public static int compareCanonicalIntegers(String int1, String int2) { 
     1374                if (int1.equals(int2)) { 
     1375                        return 0; 
     1376                } 
     1377 
     1378                // Check signs 
     1379                if (int1.charAt(0) == '-' && int2.charAt(0) != '-') { 
     1380                        // int1 is negative, int2 is not 
     1381                        return -1; 
     1382                } 
     1383                if (int2.charAt(0) == '-' && int1.charAt(0) != '-') { 
     1384                        // int2 is negative, int1 is not 
     1385                        return 1; 
     1386                } 
     1387 
     1388                // The integer with the most digits is the largest 
     1389                int result = int1.length() - int2.length(); 
     1390 
     1391                if (result == 0) { 
     1392                        // equal number of digits, compare them 
     1393                        for (int i = 0; result == 0 && i < int1.length(); i++) { 
     1394                                result = int1.charAt(i) - int2.charAt(i); 
     1395                        } 
     1396                } 
     1397 
     1398                if (int1.charAt(0) == '-') { 
     1399                        // reverse result for negative values 
     1400                        result = -result; 
     1401                } 
     1402 
     1403                return result; 
     1404        } 
     1405 
     1406        public static int compareNegativeIntegers(String int1, String int2) { 
     1407                int1 = normalizeNegativeInteger(int1); 
     1408                int2 = normalizeNegativeInteger(int2); 
     1409 
     1410                return compareCanonicalIntegers(int1, int2); 
     1411        } 
     1412 
     1413        public static int compareNonPositiveIntegers(String int1, String int2) { 
     1414                int1 = normalizeNonPositiveInteger(int1); 
     1415                int2 = normalizeNonPositiveInteger(int2); 
     1416 
     1417                return compareCanonicalIntegers(int1, int2); 
     1418        } 
     1419 
     1420        public static int compareNonNegativeIntegers(String int1, String int2) { 
     1421                int1 = normalizeNonNegativeInteger(int1); 
     1422                int2 = normalizeNonNegativeInteger(int2); 
     1423 
     1424                return compareCanonicalIntegers(int1, int2); 
     1425        } 
     1426 
     1427        public static int comparePositiveIntegers(String int1, String int2) { 
     1428                int1 = normalizePositiveInteger(int1); 
     1429                int2 = normalizePositiveInteger(int2); 
     1430 
     1431                return compareCanonicalIntegers(int1, int2); 
     1432        } 
     1433 
     1434        public static int compareLongs(String int1, String int2) { 
     1435                int1 = normalizeLong(int1); 
     1436                int2 = normalizeLong(int2); 
     1437 
     1438                return compareCanonicalIntegers(int1, int2); 
     1439        } 
     1440 
     1441        public static int compareInts(String int1, String int2) { 
     1442                int1 = normalizeInt(int1); 
     1443                int2 = normalizeInt(int2); 
     1444 
     1445                return compareCanonicalIntegers(int1, int2); 
     1446        } 
     1447 
     1448        public static int compareShorts(String int1, String int2) { 
     1449                int1 = normalizeShort(int1); 
     1450                int2 = normalizeShort(int2); 
     1451 
     1452                return compareCanonicalIntegers(int1, int2); 
     1453        } 
     1454 
     1455        public static int compareBytes(String int1, String int2) { 
     1456                int1 = normalizeByte(int1); 
     1457                int2 = normalizeByte(int2); 
     1458 
     1459                return compareCanonicalIntegers(int1, int2); 
     1460        } 
     1461 
     1462        public static int compareUnsignedLongs(String int1, String int2) { 
     1463                int1 = normalizeUnsignedLong(int1); 
     1464                int2 = normalizeUnsignedLong(int2); 
     1465 
     1466                return compareCanonicalIntegers(int1, int2); 
     1467        } 
     1468 
     1469        public static int compareUnsignedInts(String int1, String int2) { 
     1470                int1 = normalizeUnsignedInt(int1); 
     1471                int2 = normalizeUnsignedInt(int2); 
     1472 
     1473                return compareCanonicalIntegers(int1, int2); 
     1474        } 
     1475 
     1476        public static int compareUnsignedShorts(String int1, String int2) { 
     1477                int1 = normalizeUnsignedShort(int1); 
     1478                int2 = normalizeUnsignedShort(int2); 
     1479 
     1480                return compareCanonicalIntegers(int1, int2); 
     1481        } 
     1482 
     1483        public static int compareUnsignedBytes(String int1, String int2) { 
     1484                int1 = normalizeUnsignedByte(int1); 
     1485                int2 = normalizeUnsignedByte(int2); 
     1486 
     1487                return compareCanonicalIntegers(int1, int2); 
     1488        } 
     1489 
     1490        /** 
     1491         * Compares two floats to eachother. 
     1492         *  
     1493         * @return A negative number if <tt>float1</tt> is smaller than 
     1494         *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
     1495         *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
     1496         * @throws IllegalArgumentException 
     1497         *         If one of the supplied strings is not a legal float or if 
     1498         *         <tt>NaN</tt> is compared to a float other than <tt>NaN</tt>. 
     1499         */ 
     1500        public static int compareFloats(String float1, String float2) { 
     1501                float1 = normalizeFloat(float1); 
     1502                float2 = normalizeFloat(float2); 
     1503 
     1504                return compareCanonicalFloats(float1, float2); 
     1505        } 
     1506 
     1507        /** 
     1508         * Compares two canonical floats to eachother. 
     1509         *  
     1510         * @return A negative number if <tt>float1</tt> is smaller than 
     1511         *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
     1512         *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
     1513         *         The result is undefined when one or both of the arguments is not a 
     1514         *         canonical float. 
     1515         * @throws IllegalArgumentException 
     1516         *         If one of the supplied strings is not a legal float or if 
     1517         *         <tt>NaN</tt> is compared to a float other than <tt>NaN</tt>. 
     1518         */ 
     1519        public static int compareCanonicalFloats(String float1, String float2) { 
     1520                return compareCanonicalFPNumbers(float1, float2); 
     1521        } 
     1522 
     1523        /** 
     1524         * Compares two doubles to eachother. 
     1525         *  
     1526         * @return A negative number if <tt>double1</tt> is smaller than 
     1527         *         <tt>double2</tt>, <tt>0</tt> if they are equal, or positive 
     1528         *         (&gt;0) if <tt>double1</tt> is larger than <tt>double2</tt>. 
     1529         * @throws IllegalArgumentException 
     1530         *         If one of the supplied strings is not a legal double or if 
     1531         *         <tt>NaN</tt> is compared to a double other than <tt>NaN</tt>. 
     1532         */ 
     1533        public static int compareDoubles(String double1, String double2) { 
     1534                double1 = normalizeDouble(double1); 
     1535                double2 = normalizeDouble(double2); 
     1536 
     1537                return compareCanonicalDoubles(double1, double2); 
     1538        } 
     1539 
     1540        /** 
     1541         * Compares two canonical doubles to eachother. 
     1542         *  
     1543         * @return A negative number if <tt>double1</tt> is smaller than 
     1544         *         <tt>double2</tt>, <tt>0</tt> if they are equal, or positive 
     1545         *         (&gt;0) if <tt>double1</tt> is larger than <tt>double2</tt>. 
     1546         *         The result is undefined when one or both of the arguments is not a 
     1547         *         canonical double. 
     1548         * @throws IllegalArgumentException 
     1549         *         If one of the supplied strings is not a legal double or if 
     1550         *         <tt>NaN</tt> is compared to a double other than <tt>NaN</tt>. 
     1551         */ 
     1552        public static int compareCanonicalDoubles(String double1, String double2) { 
     1553                return compareCanonicalFPNumbers(double1, double2); 
     1554        } 
     1555 
     1556        /** 
     1557         * Compares two floating point numbers to eachother. 
     1558         *  
     1559         * @return A negative number if <tt>float1</tt> is smaller than 
     1560         *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
     1561         *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
     1562         * @throws IllegalArgumentException 
     1563         *         If one of the supplied strings is not a legal floating point 
     1564         *         number or if <tt>NaN</tt> is compared to a floating point number 
     1565         *         other than <tt>NaN</tt>. 
     1566         */ 
     1567        public static int compareFPNumbers(String fp1, String fp2) { 
     1568                fp1 = normalizeFPNumber(fp1); 
     1569                fp2 = normalizeFPNumber(fp2); 
     1570 
     1571                return compareCanonicalFPNumbers(fp1, fp2); 
     1572        } 
     1573 
     1574        /** 
     1575         * Compares two canonical floating point numbers to eachother. 
     1576         *  
     1577         * @return A negative number if <tt>float1</tt> is smaller than 
     1578         *         <tt>float2</tt>, <tt>0</tt> if they are equal, or positive 
     1579         *         (&gt;0) if <tt>float1</tt> is larger than <tt>float2</tt>. 
     1580         *         The result is undefined when one or both of the arguments is not a 
     1581         *         canonical floating point number. 
     1582         * @throws IllegalArgumentException 
     1583         *         If one of the supplied strings is not a legal floating point 
     1584         *         number or if <tt>NaN</tt> is compared to a floating point number 
     1585         *         other than <tt>NaN</tt>. 
     1586         */ 
     1587        public static int compareCanonicalFPNumbers(String float1, String float2) { 
     1588                // Handle special case NaN 
     1589                if (float1.equals("NaN") || float2.equals("NaN")) { 
     1590                        if (float1.equals(float2)) { 
     1591                                // NaN is equal to itself 
     1592                                return 0; 
     1593                        } 
     1594                        else { 
     1595                                throwIAE("NaN cannot be compared to other floats"); 
     1596                        } 
     1597                } 
     1598 
     1599                // Handle special case INF 
     1600                if (float1.equals("INF")) { 
     1601                        return (float2.equals("INF")) ? 0 : 1; 
     1602                } 
     1603                else if (float2.equals("INF")) { 
     1604                        return -1; 
     1605                } 
     1606 
     1607                // Handle special case -INF 
     1608                if (float1.equals("-INF")) { 
     1609                        return (float2.equals("-INF")) ? 0 : -1; 
     1610                } 
     1611                else if (float2.equals("-INF")) { 
     1612                        return 1; 
     1613                } 
     1614 
     1615                // Check signs 
     1616                if (float1.charAt(0) == '-' && float2.charAt(0) != '-') { 
     1617                        // float1 is negative, float2 is not 
     1618                        return -1; 
     1619                } 
     1620                if (float2.charAt(0) == '-' && float1.charAt(0) != '-') { 
     1621                        // float2 is negative, float1 is not 
     1622                        return 1; 
     1623                } 
     1624 
     1625                int eIdx1 = float1.indexOf('E'); 
     1626                String mantissa1 = float1.substring(0, eIdx1); 
     1627                String exponent1 = float1.substring(eIdx1 + 1); 
     1628 
     1629                int eIdx2 = float2.indexOf('E'); 
     1630                String mantissa2 = float2.substring(0, eIdx2); 
     1631                String exponent2 = float2.substring(eIdx2 + 1); 
     1632 
     1633                // Compare exponents 
     1634                int result = compareCanonicalIntegers(exponent1, exponent2); 
     1635 
     1636                if (result != 0 && float1.charAt(0) == '-') { 
     1637                        // reverse result for negative values 
     1638                        result = -result; 
     1639                } 
     1640 
     1641                if (result == 0) { 
     1642                        // Equal exponents, compare mantissas 
     1643                        result = compareCanonicalDecimals(mantissa1, mantissa2); 
     1644                } 
     1645 
     1646                return result; 
     1647        } 
     1648 
     1649        /** 
     1650         * Compares two dateTime objects. <b>Important:</b> The comparison only 
     1651         * works if both values have, or both values don't have specified a valid 
     1652         * value for the timezone. 
     1653         *  
     1654         * @param value1 
     1655         *        An xsd:dateTime value. 
     1656         * @param value2 
     1657         *        An xsd:dateTime value. 
     1658         * @return <tt>-1</tt> if <tt>value1</tt> is before <tt>value2</tt> 
     1659         *         (i.e. if the dateTime object represented by value1 is before the 
     1660         *         dateTime object represented by value2), <tt>0</tt> if both are 
     1661         *         equal and <tt>1</tt> if <tt>value2</tt> is before 
     1662         *         <tt>value1</tt><br>. 
     1663         */ 
     1664        public static int compareDateTime(String value1, String value2) { 
     1665                XMLDateTime dateTime1 = new XMLDateTime(value1); 
     1666                XMLDateTime dateTime2 = new XMLDateTime(value2); 
     1667 
     1668                dateTime1.normalize(); 
     1669                dateTime2.normalize(); 
     1670 
     1671                return dateTime1.compareTo(dateTime2); 
     1672        } 
     1673 
     1674        /*---------------* 
     1675         * Value parsing * 
     1676         *---------------*/ 
     1677 
     1678        /** 
     1679         * Parses the supplied xsd:boolean string and returns its value. 
     1680         *  
     1681         * @param s 
     1682         *        A string representation of an xsd:boolean value. 
     1683         * @return The <tt>boolean</tt> value represented by the supplied string 
     1684         *         argument. 
     1685         * @throws NumberFormatException 
     1686         *         If the supplied string is not a valid xsd:boolean value. 
     1687         */ 
     1688        public static boolean parseBoolean(String s) { 
     1689                return normalizeBoolean(s).equals("true"); 
     1690        } 
     1691 
     1692        /** 
     1693         * Parses the supplied xsd:byte string and returns its value. 
     1694         *  
     1695         * @param s 
     1696         *        A string representation of an xsd:byte value. 
     1697         * @return The <tt>byte</tt> value represented by the supplied string 
     1698         *         argument. 
     1699         * @throws NumberFormatException 
     1700         *         If the supplied string is not a valid xsd:byte value. 
     1701         */ 
     1702        public static byte parseByte(String s) { 
     1703                s = trimPlusSign(s); 
     1704                return Byte.parseByte(s); 
     1705        } 
     1706 
     1707        /** 
     1708         * Parses the supplied xsd:short string and returns its value. 
     1709         *  
     1710         * @param s 
     1711         *        A string representation of an xsd:short value. 
     1712         * @return The <tt>short</tt> value represented by the supplied string 
     1713         *         argument. 
     1714         * @throws NumberFormatException 
     1715         *         If the supplied string is not a valid xsd:short value. 
     1716         */ 
     1717        public static short parseShort(String s) { 
     1718                s = trimPlusSign(s); 
     1719                return Short.parseShort(s); 
     1720        } 
     1721 
     1722        /** 
     1723         * Parses the supplied xsd:int strings and returns its value. 
     1724         *  
     1725         * @param s 
     1726         *        A string representation of an xsd:int value. 
     1727         * @return The <tt>int</tt> value represented by the supplied string 
     1728         *         argument. 
     1729         * @throws NumberFormatException 
     1730         *         If the supplied string is not a valid xsd:int value. 
     1731         */ 
     1732        public static int parseInt(String s) { 
     1733                s = trimPlusSign(s); 
     1734                return Integer.parseInt(s); 
     1735        } 
     1736 
     1737        /** 
     1738         * Parses the supplied xsd:long string and returns its value. 
     1739         *  
     1740         * @param s 
     1741         *        A string representation of an xsd:long value. 
     1742         * @return The <tt>long</tt> value represented by the supplied string 
     1743         *         argument. 
     1744         * @throws NumberFormatException 
     1745         *         If the supplied string is not a valid xsd:long value. 
     1746         */ 
     1747        public static long parseLong(String s) { 
     1748                s = trimPlusSign(s); 
     1749                return Long.parseLong(s); 
     1750        } 
     1751 
     1752        /** 
     1753         * Parses the supplied xsd:float string and returns its value. 
     1754         *  
     1755         * @param s 
     1756         *        A string representation of an xsd:float value. 
     1757         * @return The <tt>float</tt> value represented by the supplied string 
     1758         *         argument. 
     1759         * @throws NumberFormatException 
     1760         *         If the supplied string is not a valid xsd:float value. 
     1761         */ 
     1762        public static float parseFloat(String s) { 
     1763                s = trimPlusSign(s); 
     1764                return Float.parseFloat(s); 
     1765        } 
     1766 
     1767        /** 
     1768         * Parses the supplied xsd:double string and returns its value. 
     1769         *  
     1770         * @param s 
     1771         *        A string representation of an xsd:double value. 
     1772         * @return The <tt>double</tt> value represented by the supplied string 
     1773         *         argument. 
     1774         * @throws NumberFormatException 
     1775         *         If the supplied string is not a valid xsd:double value. 
     1776         */ 
     1777        public static double parseDouble(String s) { 
     1778                s = trimPlusSign(s); 
     1779                return Double.parseDouble(s); 
     1780        } 
     1781 
     1782        /** 
     1783         * Parses the supplied xsd:integer string and returns its value. 
     1784         *  
     1785         * @param s 
     1786         *        A string representation of an xsd:integer value. 
     1787         * @return The integer value represented by the supplied string argument. 
     1788         * @throws NumberFormatException 
     1789         *         If the supplied string is not a valid xsd:integer value. 
     1790         */ 
     1791        public static BigInteger parseInteger(String s) { 
     1792                s = trimPlusSign(s); 
     1793                return new BigInteger(s); 
     1794        } 
     1795 
     1796        /** 
     1797         * Parses the supplied decimal/floating point string and returns its value. 
     1798         *  
     1799         * @param s 
     1800         *        A string representation of an xsd:decimal or xsd:double value. 
     1801         * @return The decimal/floating point value represented by the supplied 
     1802         *         string argument. 
     1803         * @throws NumberFormatException 
     1804         *         If the supplied string is not a valid xsd:decimal or xsd:double 
     1805         *         value. 
     1806         */ 
     1807        public static BigDecimal parseDecimal(String s) { 
     1808                // Note: BigDecimal can handle leading plus signs itself 
     1809                return new BigDecimal(s); 
     1810        } 
     1811 
     1812        /** 
     1813         * Parses the supplied calendar value string and returns its value. 
     1814         *  
     1815         * @param s 
     1816         *        A string representation of an xsd:dateTime, xsd:time, xsd:date, 
     1817         *        xsd:gYearMonth, xsd:gMonthDay, xsd:gYear, xsd:gMonth or xsd:gDay 
     1818         *        value. 
     1819         * @return The calendar value represented by the supplied string argument. 
     1820         * @throws NumberFormatException 
     1821         *         If the supplied string is not a valid calendar value. 
     1822         */ 
     1823        public static XMLGregorianCalendar parseCalendar(String s) { 
     1824                return dtFactory.newXMLGregorianCalendar(s); 
     1825        } 
     1826 
     1827        /** 
     1828         * Removes the first character from the supplied string if this is a plus 
     1829         * sign ('+'). Number strings with leading plus signs cannot be parsed by 
     1830         * methods such as {@link Integer#parseInt(String)}. 
     1831         */ 
     1832        private static String trimPlusSign(String s) { 
     1833                if (s.length() > 0 && s.charAt(0) == '+') { 
     1834                        return s.substring(1); 
     1835                } 
     1836                else { 
     1837                        return s; 
     1838                } 
     1839        } 
     1840 
     1841        /** 
     1842         * Maps a datatype QName from the javax.xml.namespace package to an XML 
     1843         * Schema URI for the corresponding datatype. This method recognizes the XML 
     1844         * Schema qname mentioned in {@link DatatypeConstants}. 
     1845         *  
     1846         * @param qname 
     1847         *        One of the XML Schema qnames from {@link DatatypeConstants}. 
     1848         * @return A URI for the specified datatype. 
     1849         * @throws IllegalArgumentException 
     1850         *         If the supplied qname was not recognized by this method. 
     1851         * @see DatatypeConstants 
     1852         */ 
     1853        public static URI qnameToURI(QName qname) { 
     1854                if (DatatypeConstants.DATETIME.equals(qname)) { 
     1855                        return XMLSchema.DATETIME; 
     1856                } 
     1857                else if (DatatypeConstants.DATE.equals(qname)) { 
     1858                        return XMLSchema.DATE; 
     1859                } 
     1860                else if (DatatypeConstants.TIME.equals(qname)) { 
     1861                        return XMLSchema.TIME; 
     1862                } 
     1863                else if (DatatypeConstants.GYEARMONTH.equals(qname)) { 
     1864                        return XMLSchema.GYEARMONTH; 
     1865                } 
     1866                else if (DatatypeConstants.GMONTHDAY.equals(qname)) { 
     1867                        return XMLSchema.GMONTHDAY; 
     1868                } 
     1869                else if (DatatypeConstants.GYEAR.equals(qname)) { 
     1870                        return XMLSchema.GYEAR; 
     1871                } 
     1872                else if (DatatypeConstants.GMONTH.equals(qname)) { 
     1873                        return XMLSchema.GMONTH; 
     1874                } 
     1875                else if (DatatypeConstants.GDAY.equals(qname)) { 
     1876                        return XMLSchema.GDAY; 
     1877                } 
     1878                else if (DatatypeConstants.DURATION.equals(qname)) { 
     1879                        return XMLSchema.DURATION; 
     1880                } 
     1881                else { 
     1882                        throw new IllegalArgumentException("QName cannot be mapped to an XML Schema URI: " + qname.toString()); 
     1883                } 
     1884        } 
     1885 
     1886        /*-----------------* 
     1887         * Utility methods * 
     1888         *-----------------*/ 
     1889 
     1890        /** 
     1891         * Checks whether the supplied character is a digit. 
     1892         */ 
     1893        private static final boolean isDigit(char c) { 
     1894                return c >= '0' && c <= '9'; 
     1895        } 
     1896 
     1897        /** 
     1898         * Throws an IllegalArgumentException that contains the supplied message. 
     1899         */ 
     1900        private static final void throwIAE(String msg) { 
     1901                throw new IllegalArgumentException(msg); 
     1902        } 
     1903 
    3061904} 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/optimizers/GeneralDBSelectQueryOptimizer.java

    r1527 r1528  
    153153        private Group referenceGroupBy = null; 
    154154 
    155         //used to keep the names used in a BIND clause 
    156         private Set<String> namesInBind = new HashSet<String>(); 
    157  
    158155        //Counter used to enumerate expressions in having 
    159156        private int havingID = 1; 
     
    12311228                        if (expr instanceof FunctionCall) 
    12321229                        //if (expr instanceof FunctionCall && !isFuncExprGrounded(expr)) 
    1233                         { // if the expr is grounded we are going to evaluate it in Java 
    1234                                 //also if the function involves variables from a BIND clause 
    1235                                 //we evaluate it in java 
    1236                                 if(!evaluateInJava(expr) && !varInBind(expr)) 
     1230                        { // if the expr is grounded we are going to evaluate it in Java  
     1231                                if(!evaluateInJava(expr)) 
    12371232                                { 
    12381233                                        Function function = FunctionRegistry.getInstance().get(((FunctionCall) expr).getURI()); 
     
    12591254                                        } 
    12601255                                } 
    1261                                 else if(!varInBind(expr)) //Union (or Extent) is used as an aggregate function on Select Clause! 
     1256                                else //Union (or Extent) is used as an aggregate function on Select Clause! 
    12621257                                { 
    12631258                                        //must add as aggregate 
     
    12691264                                        iter.remove(); 
    12701265                                } 
    1271                                 //if the name of the new variable is not present in the projection 
    1272                                 //then it results from a BIND 
    1273                                 if(!(node.getParentNode() instanceof Projection)) 
    1274                                         namesInBind.add(name+"?spatial"); 
     1266 
    12751267                        } 
    12761268                        //Issue: MathExpr is not exclusively met in spatial cases! 
     
    15131505        } 
    15141506 
    1515         /** 
    1516          * 
    1517          * @param expr 
    1518          * @return true if the variable occurs inside a BIND clause 
    1519          * false otherwise 
    1520          */ 
    1521         private boolean varInBind(ValueExpr expr) 
    1522         { 
    1523                 if(expr instanceof FunctionCall) 
    1524                 { 
    1525                         for(int i = 0 ; i< ((FunctionCall) expr).getArgs().size(); i++) 
    1526                         { 
    1527                                 return varInBind(((FunctionCall) expr).getArgs().get(i)); 
    1528                         } 
    1529                         return false; 
    1530                 } 
    1531                 else if(expr instanceof Var) //Var 
    1532                 { 
    1533                         if(namesInBind.contains(((Var)expr).getName())) 
    1534                                 return true; 
    1535                         return false; 
    1536                 } 
    1537                 else 
    1538                         return false; 
    1539         } 
    1540  
    15411507        @Override 
    15421508        public void meet(Slice node) 
  • monetdb/pom.xml

    r1527 r1528  
    77                <groupId>eu.earthobservatory</groupId> 
    88                <artifactId>strabon</artifactId> 
    9                 <version>3.3.2-SNAPSHOT</version> 
     9                <version>3.2.10-temporals-SNAPSHOT</version> 
    1010        </parent> 
    1111   
  • monetdb/src/main/java/org/openrdf/sail/monetdb/evaluation/MonetDBQueryBuilder.java

    r1527 r1528  
    987987        } 
    988988 
    989         protected String appendConstantWKT(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) 
    990         { 
    991                 GeneralDBStringValue arg = (GeneralDBStringValue) expr; 
    992                 String raw = arg.getValue(); 
    993  
    994                 AbstractWKT wkt = new AbstractWKT(raw); 
    995                 filter.append("Transform("); 
    996                 filter.append(" GeomFromText('" + wkt.getWKT() + "'," + String.valueOf(GeoConstants.defaultSRID) + ")"); 
    997                 filter.append(", "+GeoConstants.defaultSRID +")"); 
    998  
    999                 return raw; 
    1000         } 
    1001          
    1002989        //Used in all the generaldb stsparql boolean spatial functions of the form ST_Function(?GEO1,?GEO2)  
    1003990        protected void appendTransformFunc(GeneralDBSqlGeoTransform expr, GeneralDBSqlExprBuilder filter) 
     
    13541341                        ///// 
    13551342 
    1356                         //case where both arguments are constnats 
    1357                         boolean constantArgs = false;    
    1358   
     1343 
    13591344                        switch(func) 
    13601345                        { 
     
    13771362                        if(expr.getLeftArg() instanceof GeneralDBStringValue) 
    13781363                        { 
    1379                                 if(expr.getRightArg() instanceof GeneralDBStringValue) 
    1380                                 {        
    1381                                         //both arguments are constants so we do not need 
    1382                                         //to transform the geometries to WGS84 
    1383                                         constantArgs = true; 
    1384                                         appendWKT(expr.getLeftArg(), filter); 
    1385                                 } 
    1386                                 else 
    1387                                         appendConstantWKT(expr.getLeftArg(), filter); 
     1364                                appendWKT(expr.getLeftArg(),filter); 
    13881365                        } 
    13891366                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 
     
    14141391                                if(expr.getRightArg() instanceof GeneralDBStringValue) 
    14151392                                { 
    1416                                         if(constantArgs == true) 
    1417                                                 // both arguments are constants, so we do not need 
    1418                                                 // to transform the geometries to WGS84 
    1419                                                 appendWKT(expr.getRightArg(), filter); 
    1420                                         else 
    1421                                                 appendConstantWKT(expr.getRightArg(),filter); 
     1393                                        appendWKT(expr.getRightArg(),filter); 
    14221394                                } 
    14231395                                else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 
  • pom.xml

    r1527 r1528  
    55        <groupId>eu.earthobservatory</groupId> 
    66        <artifactId>strabon</artifactId> 
    7         <version>3.3.2-SNAPSHOT</version> 
     7        <version>3.2.10-temporals-SNAPSHOT</version> 
    88        <packaging>pom</packaging> 
    99 
     
    141141 
    142142        <properties> 
    143         <eu.earthobservatory.version>3.3.2-SNAPSHOT</eu.earthobservatory.version> 
     143        <eu.earthobservatory.version>3.2.10-temporals-SNAPSHOT</eu.earthobservatory.version> 
    144144                <sesame.version>2.6.3</sesame.version> 
    145145                <aduna.appbase.version>3.5.0</aduna.appbase.version> 
     
    819819                                <groupId>org.apache.maven.plugins</groupId> 
    820820                                <artifactId>maven-javadoc-plugin</artifactId> 
    821                                 <version>2.10.1</version> 
     821                                <version>2.8.1</version> 
    822822                                <configuration> 
    823823                                        <source>1.6</source> 
     
    825825                                </configuration> 
    826826                        </plugin> 
     827 
    827828                        <!-- 
    828829                        <plugin> 
  • postgis/pom.xml

    r1527 r1528  
    77                <groupId>eu.earthobservatory</groupId> 
    88                <artifactId>strabon</artifactId> 
    9                 <version>3.3.2-SNAPSHOT</version> 
     9                <version>3.2.10-temporals-SNAPSHOT</version> 
    1010        </parent> 
    1111   
  • postgis/src/main/java/org/openrdf/sail/postgis/PostGISSqlStore.java

    r1525 r1528  
    105105                Iterator<Entry<String, String>> iter; 
    106106                iter = getProperties().entrySet().iterator(); 
    107                  
    108                 // append application name for identifying connection in `pg_stat_activity' table 
    109                 url.append("?application_name=strabon"); 
    110107                if (iter.hasNext()) { 
    111                         url.append("&"); 
     108                        url.append("?"); 
    112109                } 
    113110                while (iter.hasNext()) { 
  • postgis/src/main/java/org/openrdf/sail/postgis/evaluation/PostGISQueryBuilder.java

    r1527 r1528  
    12781278         
    12791279 
    1280         protected String appendConstantWKT(GeneralDBSqlExpr expr, GeneralDBSqlExprBuilder filter) throws UnsupportedRdbmsOperatorException 
    1281         { 
    1282                 GeneralDBStringValue arg = (GeneralDBStringValue) expr; 
    1283                 String raw = arg.getValue(); 
    1284                  
    1285                 // parse raw WKT 
    1286                 AbstractWKT wkt = new AbstractWKT(raw); 
    1287                 // transform constant geometry to the default SRID 
    1288                 filter.append("ST_Transform("); 
    1289                 filter.append(" ST_GeomFromText('" + wkt.getWKT() + "'," + String.valueOf(wkt.getSRID()) + ")"); 
    1290                 filter.append(", "+GeoConstants.defaultSRID +")"); 
    1291                  
    1292                 return raw; 
    1293         } 
    1294          
    12951280        //Used in all the generaldb boolean spatial functions of the form ?GEO1 ~ ?GEO2  
    12961281        //      protected void appendStSPARQLSpatialOperand(BinaryGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialOperandsPostGIS operand) throws UnsupportedRdbmsOperatorException 
     
    20182003                        ///// 
    20192004 
    2020                         //case where both arguments are constnats 
    2021                         boolean constantArgs = false;    
     2005 
    20222006 
    20232007                        switch(func) 
     
    20282012                        case ST_Union: filter.appendFunction("ST_Union"); break; 
    20292013                        case ST_SymDifference: filter.appendFunction("ST_SymDifference"); break; 
     2014                        case ST_Buffer: filter.appendFunction("ST_Buffer"); break; 
    20302015                         
    20312016                        // PostGIS 
     
    20452030                        if(expr.getLeftArg() instanceof GeneralDBStringValue) 
    20462031                        { 
    2047                                 if(expr.getRightArg() instanceof GeneralDBStringValue) 
    2048                                 {        
    2049                                         //both arguments are constants so we do not need 
    2050                                         //to transform the geometries to WGS84 
    2051                                         constantArgs = true; 
    2052                                         appendWKT(expr.getLeftArg(), filter); 
    2053                                 } 
    2054                                 else 
    2055                                         appendConstantWKT(expr.getLeftArg(), filter); 
     2032                                appendWKT(expr.getLeftArg(),filter); 
    20562033                        } 
    20572034                        else if(expr.getLeftArg() instanceof GeneralDBSqlSpatialConstructBinary) 
     
    20802057                        if(expr.getRightArg() instanceof GeneralDBStringValue) 
    20812058                        { 
    2082                                 if(constantArgs == true) 
    2083                                         // both arguments are constants, so we do not need 
    2084                                         // to transform the geometries to WGS84 
    2085                                         appendWKT(expr.getRightArg(), filter); 
    2086                                 else 
    2087                                         appendConstantWKT(expr.getRightArg(),filter); 
     2059                                appendWKT(expr.getRightArg(),filter); 
    20882060                        } 
    20892061                        else if(expr.getRightArg() instanceof GeneralDBSqlSpatialConstructUnary) 
     
    23442316        } 
    23452317 
    2346         //Buffer function (Giannis: dont get deceived by "filter". It also applies for the case the buffer occurs in the select clause too) 
     2318        //Buffer function 
    23472319        protected void appendBuffer(TripleGeneralDBOperator expr, GeneralDBSqlExprBuilder filter, SpatialFunctionsPostGIS func) throws UnsupportedRdbmsOperatorException 
    23482320        { 
     
    24132385                                        else if (tmp instanceof GeneralDBStringValue) //Constant!! 
    24142386                                        { 
    2415                                                 sridNeeded  = true; 
     2387                                                sridNeeded  = false; 
    24162388                                                sridExpr = String.valueOf(WKTHelper.getSRID(((GeneralDBStringValue) tmp).getValue())); 
    24172389                                                break; 
  • resultio-spatial/api/pom.xml

    r1527 r1528  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/pom.xml

    r1527 r1528  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlgeojson/pom.xml

    r1527 r1528  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlgeojson/src/main/java/org/openrdf/query/resultio/sparqlgeojson/stSPARQLResultsGeoJSONWriter.java

    r1443 r1528  
    1414import java.nio.charset.Charset; 
    1515import java.util.ArrayList; 
    16 import java.util.Calendar; 
    1716import java.util.List; 
    1817 
     
    2221import org.geotools.feature.simple.SimpleFeatureTypeBuilder; 
    2322import org.geotools.geojson.feature.FeatureJSON; 
    24 import org.geotools.geojson.geom.GeometryJSON; 
    2523import org.opengis.feature.simple.SimpleFeature; 
    2624import org.opengis.feature.simple.SimpleFeatureType; 
    2725import org.openrdf.model.Literal; 
    28 import org.openrdf.model.URI; 
    2926import org.openrdf.model.Value; 
     27import org.openrdf.model.impl.LiteralImpl; 
     28import org.openrdf.model.impl.URIImpl; 
    3029import org.openrdf.query.Binding; 
    3130import org.openrdf.query.BindingSet; 
     
    103102        @Override 
    104103        public void startQueryResult(List<String> bindingNames) throws TupleQueryResultHandlerException { 
    105                 fjson = new FeatureJSON(new GeometryJSON(jts.getPrecision())); 
     104                fjson = new FeatureJSON(); 
    106105                fjson.setEncodeFeatureCRS(true); 
    107106        } 
     
    225224                                // add the properties 
    226225                                for (int p = 0; p < properties.size(); p++) { 
    227                                         Value val = values.get(p); 
    228                                          
    229                                         if (val instanceof Literal) { 
    230                                                 Literal lit = (Literal) val; 
    231                                                 URI datatype = lit.getDatatype(); 
    232                                                  
    233                                                 if (XMLGSDatatypeUtil.isNumericDatatype(datatype)) { 
    234                                                         sftb.add(properties.get(p), Number.class); 
    235                                                          
    236                                                 } else if (XMLGSDatatypeUtil.isCalendarDatatype(datatype)) { 
    237                                                         sftb.add(properties.get(p), Calendar.class); 
    238                                                          
    239                                                 } else if (XMLGSDatatypeUtil.isBooleanDatatype(datatype)) { 
    240                                                         sftb.add(properties.get(p), Boolean.class); 
    241                                                          
    242                                                 } else { // fallback to String 
    243                                                         sftb.add(properties.get(p), String.class);       
    244                                                 } 
    245                                                  
    246                                         } else { // fallback to String 
    247                                                 sftb.add(properties.get(p), String.class); 
    248                                         } 
    249                                          
     226                                        sftb.add(properties.get(p), String.class); 
    250227                                } 
    251228                                 
     
    258235                                // add the values to the builder of the feature 
    259236                                for (int v = 0; v < values.size(); v++) { 
    260                                         featureBuilder.add(values.get(v).stringValue()); 
     237                                        featureBuilder.add(values.get(v)); 
    261238                                } 
    262239                                 
  • resultio-spatial/sparqlhtml/pom.xml

    r1527 r1528  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlhtml/src/main/java/org/openrdf/query/resultio/sparqlhtml/stSPARQLResultsHTMLWriter.java

    r1446 r1528  
    114114                         
    115115                        // if set to FALSE, urls link to web. if set to TRUE, urls are described // 
    116                         boolean linkURL = true;  
     116                        boolean linkURL = false;  
    117117                        /////////////////////////////////////////////////////////////////////////// 
    118118                         
  • resultio-spatial/sparqlkml/pom.xml

    r1527 r1528  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/sparqlkml/src/main/java/org/openrdf/query/resultio/sparqlkml/stSPARQLResultsKMLWriter.java

    r1527 r1528  
    177177                        // keep the order of binding names 
    178178                        this.bindingNames = bindingNames; 
    179                          
    180179                        xmlWriter.startDocument(); 
    181180                        xmlWriter.setAttribute("xmlns", NAMESPACE); 
     
    256255                        xmlWriter.startTag(PLACEMARK_TAG); 
    257256                        for (Binding binding : bindingSet) { 
     257                                 
    258258                                if(!binding.getValue().toString().contains("^^") || (binding.getValue() instanceof org.openrdf.sail.generaldb.model.GeneralDBPolyhedron)){ 
    259259                                        continue; 
     
    299299                         
    300300                        // parse binding set 
    301                         for (String bindingName : bindingNames) {                                
     301                        for (String bindingName : bindingNames) { 
     302                                 
    302303                                Binding binding = bindingSet.getBinding(bindingName); 
    303                                  
    304304                                if(binding != null) { 
    305305                                        Value value = binding.getValue(); 
     
    316316                                                 
    317317                                        } else { // URI, BlankNode, or Literal other than spatial literal 
     318                                                 
    318319                                                if (logger.isDebugEnabled()) { 
    319320                                                        logger.debug("[Strabon.KMLWriter] Found URI/BlankNode/Literal ({}): {}", value.getClass(), value); 
  • resultio-spatial/sparqlxml/pom.xml

    r1527 r1528  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • resultio-spatial/text/pom.xml

    r1527 r1528  
    66                <groupId>org.openrdf.sesame</groupId> 
    77                <artifactId>sesame-queryresultio-spatial</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • runtime/pom.xml

    r1527 r1528  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
     
    458458                </plugins> 
    459459        </build> 
    460  
    461 <profiles> 
    462                 <profile> 
    463                         <id>create-debian</id> 
    464                         <activation> 
    465                                 <activeByDefault>false</activeByDefault> 
    466                                 <property> 
    467                                         <name>debian</name> 
    468                                         <value>true</value> 
    469                                 </property> 
    470                         </activation> 
    471                                 <build> 
    472                                         <plugins> 
    473 <plugin> 
    474                                                     <groupId>org.codehaus.mojo</groupId> 
    475                                                     <artifactId>exec-maven-plugin</artifactId> 
    476                                                     <version>1.1.1</version> 
    477                                                     <executions> 
    478                                                       <execution> 
    479                                                         <!-- 
    480                                                         <id>some-execution</id> 
    481                                                         --> 
    482                                                         <phase>package</phase> 
    483                                                         <goals> 
    484                                                           <goal>exec</goal> 
    485                                                         </goals> 
    486                                                       </execution> 
    487                                                     </executions> 
    488                                                     <configuration> 
    489                                                       <executable>${basedir}/../scripts/update-debian-version.sh</executable> 
    490                                                     </configuration> 
    491                                                   </plugin> 
    492                                                 <plugin> 
    493                                 <artifactId>jdeb</artifactId> 
    494                                 <groupId>org.vafer</groupId> 
    495                                 <version>1.3</version> 
    496                                 <executions> 
    497                                         <execution> 
    498                                                 <phase>package</phase> 
    499                                                 <goals> 
    500                                                         <goal>jdeb</goal> 
    501                                                 </goals> 
    502                                         <configuration> 
    503                                                 <skipPOMs>false</skipPOMs> 
    504                                                 <dataSet> 
    505                                                         <data> 
    506                                                                 <src>${project.build.directory}</src> 
    507                                                                 <type>directory</type> 
    508                                                                 <includes>**/</includes> 
    509                                                                 <mapper> 
    510                                                                         <type>perm</type> 
    511                                                                         <prefix>/usr/share/jdeb/lib/strabon-runtime</prefix> 
    512                                                                 </mapper> 
    513                                                         </data> 
    514                                                         <data> 
    515                                                                 <src>${basedir}/strabon-cmd</src> 
    516                                                                 <type>file</type> 
    517                                                                 <mapper> 
    518                                                                         <type>perm</type> 
    519                                                                         <prefix>/usr/local/bin</prefix> 
    520                                                                         <user>root</user> 
    521                                                                         <group>root</group> 
    522                                                                         <filemode>755</filemode> 
    523                                                                 </mapper> 
    524                                                         </data> 
    525                                                 </dataSet> 
    526                                         </configuration> 
    527                                 </execution> 
    528                         </executions> 
    529                         </plugin> 
    530  
    531                                         </plugins> 
    532                                 </build> 
    533  
    534                 </profile> 
    535         </profiles> 
    536460</project> 
    537461 
  • runtime/src/main/java/eu/earthobservatory/runtime/monetdb/Strabon.java

    r1523 r1528  
    115115                         
    116116                } catch (ClassNotFoundException e) { 
    117                         logger.error("[Strabon.isLocked] Could not load MonetDB jdbc driver: {}", e.getMessage()); 
     117                        logger.error("[Strabon.isLocked] Could not load postgres jdbc driver: {}", e.getMessage()); 
    118118                        throw e; 
    119119                         
  • runtime/src/main/java/eu/earthobservatory/runtime/postgis/Strabon.java

    r1525 r1528  
    5656                        Class.forName("org.postgresql.Driver"); 
    5757                        url = "jdbc:postgresql://" + serverName + ":" + port + "/" 
    58                         + databaseName + "?user=" + user + "&password=" + password + "&application_name=strabon"; 
     58                        + databaseName + "?user=" + user + "&password=" + password; 
    5959                        Connection conn = DriverManager.getConnection(url); 
    6060                        java.sql.Statement st = conn.createStatement(); 
     
    9696                        logger.info("[Strabon] Checking for locks..."); 
    9797                        Class.forName("org.postgresql.Driver"); 
    98                         url = "jdbc:postgresql://" + serverName + ":" + port + "/" + databaseName + "?user=" + user + "&password=" + password + "&application_name=strabon"; 
     98                        url = "jdbc:postgresql://" + serverName + ":" + port + "/" + databaseName + "?user=" + user + "&password=" + password; 
    9999                         
    100100                        conn = DriverManager.getConnection(url); 
  • testsuite/pom.xml

    r1527 r1528  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
  • testsuite/src/test/resources/stSPARQL/SpatialAnalysisFunctionsTest/BufferWithConstantTest.srx

    r1520 r1528  
    77                <result> 
    88                        <binding name='buffer'> 
    9                                 <literal datatype='http://strdf.di.uoa.gr/ontology#WKT'>POLYGON ((-111699.52621351427 0.005688101702437, -111699.52621351369 1.0072227565753598, -109548.05371968949 21663.07894035089, -103177.26815752243 42488.64666773878, -92834.65151931695 61674.09877429663, -78921.47789677524 78480.19101539368, -61976.62825599895 92260.76607374407, -42655.07913255412 102487.5654796481, -21702.06885195989 108770.20628473054, 75.93636650929693 110870.6459331801, 76.93621333519695 110870.64456365933, 21843.307355598197 108711.70631747066, 42763.184566801065 102379.46736776605, 62035.14038828469 92119.5188906428, 78921.48117425787 78327.2927247086, 92776.13555651536 61532.82653947292, 103069.1338115732 42380.51312016071, 109406.76119514595 21604.553904167882, 111546.58914580086 1.0058440464288212, 111546.58914580313 0.0070681672776757, 109406.76128921594 -21603.538101944774, 103069.13397595414 -42379.48903809927, 92776.13575692166 -61531.7900471042, 78921.48137102922 -78326.24157852355, 62035.14054274524 -92118.45307486111, 42763.18464769027 -102378.3890965244, 21843.30734426086 -108710.61969803026, 76.93610651465133 -110869.55497162463, 75.93625968572451 -110869.55634114263, -21702.06899164256 -108769.11955591492, -42655.07928695646 -102486.48702223192, -61976.62840535829 -92259.70003516495, -78921.47802427062 -78479.13965042801, -92834.6516142562 -61673.062100869174, -103177.26821643289 -42487.622463514286, -109548.05374545977 -21662.063081215245, -111699.52621351427 0.005688101702437));http://www.opengis.net/def/crs/EPSG/0/2100</literal> 
     9                                <literal datatype='http://strdf.di.uoa.gr/ontology#WKT'>POLYGON ((18.51248908676886 0.0022304072306898, 18.512489086768802 0.0022394268391313, 18.531703805007 0.1973297483274672, 18.5886095513394 0.3849228584614706, 18.681019469862246 0.5578096592705463, 18.80538229925464 0.7093462080002653, 18.956918845758608 0.8337090401047385, 19.129805644913805 0.9261189617217735, 19.317398754029355 0.983024711411565, 19.512489075173807 1.0022394331413353, 19.51249803440009 1.0022394331414393, 19.7075883572879 0.9830247156776696, 19.89518146887027 0.9261189695835728, 20.0680682710241 0.833709050783125, 20.219604820854016 0.7093462206556026, 20.343967653693618 0.5578096730514313, 20.436377575588256 0.3849228725514822, 20.493283325039744 0.1973297619875636, 20.512498045995084 0.002239439443644, 20.51249804599514 0.0022304198350916, 20.493283327453618 -0.1928599031781553, 20.436377580234563 -0.3804530146601173, 20.34396766031032 -0.5533398164745945, 20.21960482911171 -0.7048763657236403, 20.06806828054155 -0.8292391977494786, 19.895181479231532 -0.9216491186174952, 19.707588368060215 -0.9785548668606079, 19.512498045151858 -0.9977695864671131, 19.512489085925576 -0.9977695864671056, 19.317398764801673 -0.9785548668800716, 19.12980565527507 -0.9216491193392968, 18.956918855276065 -0.8292391997898305, 18.805382307512332 -0.7048763695836736, 18.681019476478948 -0.5533398224988286, 18.588609555985705 -0.3804530230042807, 18.531703807420875 -0.1928599137883199, 18.51248908676886 0.0022304072306898));http://www.opengis.net/def/crs/EPSG/0/2100</literal> 
    1010                        </binding> 
    1111                </result> 
  • vocab/pom.xml

    r1527 r1528  
    66                <groupId>eu.earthobservatory</groupId> 
    77                <artifactId>strabon</artifactId> 
    8                 <version>3.3.2-SNAPSHOT</version> 
     8                <version>3.2.10-temporals-SNAPSHOT</version> 
    99        </parent> 
    1010 
Note: See TracChangeset for help on using the changeset viewer.