    001    // $HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_testing/src/org/deegree/ogcwebservices/wcs/configuration/ExtensionDocument.java $
    002    /*----------------------------------------------------------------------------
    003     This file is part of deegree, http://deegree.org/
    004     Copyright (C) 2001-2009 by:
    005     Department of Geography, University of Bonn
    006     and
    007     lat/lon GmbH
    008
    009     This library is free software; you can redistribute it and/or modify it under
    010     the terms of the GNU Lesser General Public License as published by the Free
    011     Software Foundation; either version 2.1 of the License, or (at your option)
    012     any later version.
    013     This library is distributed in the hope that it will be useful, but WITHOUT
    014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
    016     details.
    017     You should have received a copy of the GNU Lesser General Public License
    018     along with this library; if not, write to the Free Software Foundation, Inc.,
    019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    020
    021     Contact information:
    022
    023     lat/lon GmbH
    024     Aennchenstr. 19, 53177 Bonn
    025     Germany
    026     http://lat-lon.de/
    027
    028     Department of Geography, University of Bonn
    029     Prof. Dr. Klaus Greve
    030     Postfach 1147, 53001 Bonn
    031     Germany
    032     http://www.geographie.uni-bonn.de/deegree/
    033
    034     e-mail: info@deegree.org
    035     ----------------------------------------------------------------------------*/
    036    package org.deegree.ogcwebservices.wcs.configuration;
    037
    038    import java.io.File;
    039    import java.net.MalformedURLException;
    040    import java.net.URI;
    041    import java.net.URISyntaxException;
    042    import java.net.URL;
    043    import java.util.ArrayList;
    044    import java.util.List;
    045
    046    import org.deegree.datatypes.values.Interval;
    047    import org.deegree.datatypes.values.TypedLiteral;
    048    import org.deegree.framework.log.ILogger;
    049    import org.deegree.framework.log.LoggerFactory;
    050    import org.deegree.framework.util.StringTools;
    051    import org.deegree.framework.xml.ElementList;
    052    import org.deegree.framework.xml.NamespaceContext;
    053    import org.deegree.framework.xml.XMLFragment;
    054    import org.deegree.framework.xml.XMLParsingException;
    055    import org.deegree.framework.xml.XMLTools;
    056    import org.deegree.io.IODocument;
    057    import org.deegree.io.JDBCConnection;
    058    import org.deegree.model.crs.CRSFactory;
    059    import org.deegree.model.crs.CoordinateSystem;
    060    import org.deegree.model.crs.UnknownCRSException;
    061    import org.deegree.model.spatialschema.Envelope;
    062    import org.deegree.model.spatialschema.GMLGeometryAdapter;
    063    import org.deegree.ogcbase.CommonNamespaces;
    064    import org.deegree.ogcbase.InvalidGMLException;
    065    import org.deegree.ogcwebservices.InvalidParameterValueException;
    066    import org.w3c.dom.Element;
    067    import org.w3c.dom.Node;
    068
    069    /**
    070     * This class creates a class representation of the Extension section of a deegree WCS coverage offering (coverage
    071     * configuration) element. the extension section contains informations about data access/sources for different
    072     * resolutions and ranges.<BR>
    073     * an extension section must contain at least one Resolution element but can contains as much as the user may defined. A
    074     * resoluton contains a access informations for data and the ranges the data are assigned to. because of this it is
    075     * possible that more than one Resoultion element with same resolution range but with different other ranges (e.g. time
    076     * or elevation)
    077     *
    078     * @version $Revision: 23585 $
    079     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
    080     * @author last edited by: $Author: aschmitz $
    081     *
    082     * @version 1.0. $Revision: 23585 $, $Date: 2010-04-13 14:07:18 +0200 (Di, 13. Apr 2010) $
    083     *
    084     * @since 1.1
    085     */
    086    public class ExtensionDocument {
    087
    088        private static final ILogger LOG = LoggerFactory.getLogger( ExtensionDocument.class );
    089
    090        private static URI GMLNS = CommonNamespaces.GMLNS;
    091
    092        private static URI DGRNS = CommonNamespaces.DEEGREEWCS;
    093
    094        private static NamespaceContext nsc = CommonNamespaces.getNamespaceContext();
    095
    096        private URL systemId = null;
    097
    098        private Element root = null;
    099
    100        /**
    101         * constructing the ExtensionBuilder by passing the root element of a deegree WCS CoverageOffering Extension.
    102         *
    103         * @param root
    104         * @param systemId
    105         */
    106        public ExtensionDocument( Element root, URL systemId ) {
    107            this.root = root;
    108            this.systemId = systemId;
    109        }
    110
    111        /**
    112         * returns the content of the Extension element of te deegree WCS coverage description (configuration document). the
    113         * extension section contains informations about data access/sources for different resolutions and ranges.<BR>
    114         * an extension section must contain at least one Resolution element but can contains as much as the user may
    115         * defined. A resoluton contains a access informations for data and the ranges the data are assigned to. because of
    116         * this it is possible that more than one Resoultion element with same resolution range but with different other
    117         * ranges (e.g. time or elevation)
    118         *
    119         * @return content of the Extension element of te deegree WCS coverage description
    120         * @throws InvalidCVExtensionException
    121         * @throws UnknownCVExtensionException
    122         * @throws InvalidParameterValueException
    123         * @throws InvalidGMLException
    124         * @throws UnknownCRSException
    125         */
    126        public Extension getExtension()
    127                                throws InvalidCVExtensionException, UnknownCVExtensionException,
    128                                InvalidParameterValueException, InvalidGMLException, UnknownCRSException {
    129            Extension extension = null;
    130            try {
    131                String type = XMLTools.getRequiredNodeAsString( root, "./@type", nsc );
    132                double offset = XMLTools.getNodeAsDouble( root, "./@offset", nsc, 0 );
    133                double scaleFactor = XMLTools.getNodeAsDouble( root, "./@scaleFactor", nsc, 1 );
    134                ElementList el = XMLTools.getChildElements( "Resolution", DGRNS, root );
    135                Resolution[] resolutions = getResolutions( type, el );
    136                extension = new DefaultExtension( type, resolutions, offset, scaleFactor );
    137            } catch ( XMLParsingException e ) {
    138                throw new InvalidCVExtensionException( StringTools.stackTraceToString( e ) );
    139            }
    140            return extension;
    141        }
    142
    143        /**
    144         * returns the resolutions definitions within the Extension element of the deegree WCS coverage offering. Each
    145         * resoultion contains access description for its data and an optional description of the ranges the data are valid
    146         * for.
    147         *
    148         * @param type
    149         * @param el
    150         * @return resolutions definitions within the Extension element of the deegree WCS coverage offering
    151         * @throws XMLParsingException
    152         * @throws InvalidParameterValueException
    153         * @throws UnknownCRSException
    154         */
    155        private Resolution[] getResolutions( String type, ElementList el )
    156                                throws XMLParsingException, InvalidParameterValueException, InvalidGMLException,
    157                                UnknownCRSException {
    158            Resolution[] resolutions = new Resolution[el.getLength()];
    159            for ( int i = 0; i < resolutions.length; i++ ) {
    160                resolutions[i] = getResolution( type, el.item( i ) );
    161            }
    162            return resolutions;
    163        }
    164
    165        /**
    166         * creates an instance of <tt>Resoltuion</tt> from the passed <tt>Element</tt> and the type of the coverage source.
    167         * Valid values for type are:
    168         * <ul>
    169         * <li>shapeIndexed
    170         * <li>nameIndexed
    171         * <li>file
    172         * </ul>
    173         * if an unknown typed is passed an <tt>InvalidParameterValueException</tt> will be thrown
    174         *
    175         * @param type
    176         * @param element
    177         * @return created Resoltuion
    178         * @throws XMLParsingException
    179         * @throws UnknownCRSException
    180         */
    181        private Resolution getResolution( String type, Element element )
    182                                throws XMLParsingException, InvalidParameterValueException, InvalidGMLException,
    183                                UnknownCRSException {
    184            String tmp = XMLTools.getRequiredAttrValue( "min", null, element );
    185            double min = Double.parseDouble( tmp );
    186            tmp = XMLTools.getRequiredAttrValue( "max", null, element );
    187            double max = Double.parseDouble( tmp );
    188            // ElementList el = XMLTools.getChildElements( "Range", DGRNS, element );
    189            NamespaceContext nsContext = CommonNamespaces.getNamespaceContext();
    190            List<Node> el = XMLTools.getNodes( element, "deegreewcs:Range", nsContext );
    191            Range[] ranges = getRanges( el );
    192            Resolution resolution = null;
    193
    194            if ( type.equals( Extension.SHAPEINDEXED ) ) {
    195                // TODO
    196                // enable more than one shape
    197                Element elem = XMLTools.getRequiredElement( element, "deegreewcs:Shape", nsContext );
    198                Shape shape = getShape( elem );
    199                resolution = new ShapeResolution( min, max, ranges, shape );
    200            } else if ( type.equals( Extension.NAMEINDEXED ) ) {
    201                ElementList ell = XMLTools.getChildElements( "Directory", DGRNS, element );
    202                Directory[] dirs = new Directory[ell.getLength()];
    203                for ( int i = 0; i < dirs.length; i++ ) {
    204                    dirs[i] = getDirectory( ell.item( i ) );
    205                }
    206                resolution = new DirectoryResolution( min, max, ranges, dirs );
    207            } else if ( type.equals( Extension.FILEBASED ) ) {
    208                ElementList ell = XMLTools.getChildElements( "File", DGRNS, element );
    209                org.deegree.ogcwebservices.wcs.configuration.File[] files = new org.deegree.ogcwebservices.wcs.configuration.File[ell.getLength()];
    210                for ( int i = 0; i < files.length; i++ ) {
    211                    files[i] = getFile( ell.item( i ) );
    212                }
    213                resolution = new FileResolution( min, max, ranges, files );
    214            } else if ( type.equals( Extension.ORACLEGEORASTER ) ) {
    215                resolution = getOracleGeoRasterResolution( element, min, max, ranges );
    216
    217            } else if ( type.equals( Extension.DATABASEINDEXED ) ) {
    218                resolution = getDatabaseIndexed( element, min, max, ranges );
    219            } else if ( type.equals( Extension.SCRIPTBASED ) ) {
    220                resolution = getScriptBased( element, min, max, ranges );
    221            } else {
    222                String msg = StringTools.concat( 200, "type: ", type, " not known ", "by the deegree WCS" );
    223                throw new InvalidParameterValueException( msg );
    224            }
    225            return resolution;
    226        }
    227
    228        private Resolution getScriptBased( Element element, double min, double max, Range[] ranges )
    229                                throws XMLParsingException, InvalidParameterValueException {
    230
    231            XMLFragment xml = new XMLFragment( element );
    232            try {
    233                xml.setSystemId( systemId.toExternalForm() );
    234            } catch ( MalformedURLException e ) {
    235                // should never happen because systemID is read from a valid URL
    236            }
    237
    238            NamespaceContext nsc = CommonNamespaces.getNamespaceContext();
    239            String xpath = "deegreewcs:Script/deegreewcs:Name";
    240            String script = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    241
    242            xpath = "deegreewcs:Script/deegreewcs:Parameter";
    243            List<Node> list = XMLTools.getNodes( element, xpath, nsc );
    244            List<String> parameter = new ArrayList<String>( list.size() );
    245            for ( Node node : list ) {
    246                parameter.add( XMLTools.getStringValue( node ) );
    247            }
    248            xpath = "deegreewcs:Script/deegreewcs:ResultFormat";
    249            String resultFormat = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    250            xpath = "deegreewcs:Script/deegreewcs:StorageLocation";
    251            String storageLocation = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    252            try {
    253                storageLocation = new File( xml.resolve( storageLocation ).getFile() ).getAbsolutePath();
    254            } catch ( MalformedURLException e ) {
    255                e.printStackTrace();
    256                throw new InvalidParameterValueException( e.getMessage(), e );
    257            }
    258            return new ScriptResolution( min, max, ranges, script, parameter, resultFormat, storageLocation );
    259        }
    260
    261        /**
    262         * creates a <tt>DatabaseResolution</tt> object from the passed element
    263         *
    264         * @param element
    265         * @param min
    266         * @param max
    267         * @param ranges
    268         * @return the resolution
    269         * @throws XMLParsingException
    270         */
    271        private Resolution getDatabaseIndexed( Element element, double min, double max, Range[] ranges )
    272                                throws XMLParsingException {
    273
    274            NamespaceContext nsc = CommonNamespaces.getNamespaceContext();
    275            String xpath = "deegreewcs:Database/dgjdbc:JDBCConnection";
    276            Node node = XMLTools.getRequiredNode( element, xpath, nsc );
    277            IODocument io = new IODocument( (Element) node );
    278            JDBCConnection jdbc = io.parseJDBCConnection();
    279            xpath = "deegreewcs:Database/deegreewcs:Table/text()";
    280            String table = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    281            xpath = "deegreewcs:Database/deegreewcs:DataRootDirectory/text()";
    282            String rootDir = XMLTools.getNodeAsString( element, xpath, nsc, "./" );
    283            File dir = new File( rootDir );
    284            if ( !dir.isAbsolute() ) {
    285                XMLFragment xml = new XMLFragment();
    286                xml.setRootElement( root );
    287                xml.setSystemId( systemId );
    288                try {
    289                    URL url = xml.resolve( rootDir );
    290                    dir = new File( url.toURI() );
    291                } catch ( Exception e ) {
    292                    LOG.logError( e.getMessage(), e );
    293                }
    294            }
    295            return new DatabaseResolution( min, max, ranges, jdbc, table, dir.getAbsolutePath() );
    296        }
    297
    298        /**
    299         * creates a <tt>OracleGeoRasterResolution</tt> object from the passed element
    300         *
    301         * @param element
    302         * @param min
    303         * @param max
    304         * @param ranges
    305         * @return the Resolution
    306         * @throws XMLParsingException
    307         */
    308        private Resolution getOracleGeoRasterResolution( Element element, double min, double max, Range[] ranges )
    309                                throws XMLParsingException {
    310            Resolution resolution;
    311            NamespaceContext nsc = CommonNamespaces.getNamespaceContext();
    312            String xpath = "deegreewcs:OracleGeoRaster/dgjdbc:JDBCConnection";
    313            Node node = XMLTools.getRequiredNode( element, xpath, nsc );
    314            IODocument io = new IODocument( (Element) node );
    315            JDBCConnection jdbc = io.parseJDBCConnection();
    316            xpath = "deegreewcs:OracleGeoRaster/deegreewcs:Table/text()";
    317            String table = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    318            xpath = "deegreewcs:OracleGeoRaster/deegreewcs:RDTTable/text()";
    319            String rdtTable = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    320            xpath = "deegreewcs:OracleGeoRaster/deegreewcs:Column/text()";
    321            String column = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    322            xpath = "deegreewcs:OracleGeoRaster/deegreewcs:Identification/text()";
    323            String identification = XMLTools.getRequiredNodeAsString( element, xpath, nsc );
    324            xpath = "deegreewcs:OracleGeoRaster/deegreewcs:Level/text()";
    325            int level = XMLTools.getNodeAsInt( element, xpath, nsc, 1 );
    326            resolution = new OracleGeoRasterResolution( min, max, ranges, jdbc, table, rdtTable, column, identification,
    327                                                        level );
    328            return resolution;
    329        }
    330
    331        /**
    332         * creates a <tt>Shape</tt> object from the passed element
    333         *
    334         * @param element
    335         * @return created Shape
    336         * @throws XMLParsingException
    337         * @throws UnknownCRSException
    338         */
    339        private Shape getShape( Element element )
    340                                throws XMLParsingException, UnknownCRSException {
    341            String tilePoperty = XMLTools.getRequiredAttrValue( "tileProperty", null, element );
    342            String directoryProperty = XMLTools.getRequiredAttrValue( "directoryProperty", null, element );
    343            String srsName = XMLTools.getRequiredAttrValue( "srsName", null, element );
    344            CoordinateSystem crs = CRSFactory.create( srsName );
    345            String rootFileName = XMLTools.getStringValue( element );
    346            rootFileName = rootFileName.trim();
    347            XMLFragment xml = new XMLFragment();
    348            xml.setRootElement( root );
    349            xml.setSystemId( systemId );
    350            java.io.File file = null;
    351            try {
    352                URL url = xml.resolve( rootFileName + ".shp" );
    353                file = new java.io.File( url.toURI() );
    354            } catch ( Exception e ) {
    355                LOG.logError( e.getMessage(), e );
    356            }
    357            rootFileName = file.getAbsolutePath();
    358            rootFileName = rootFileName.substring( 0, rootFileName.lastIndexOf( "." ) );
    359            return new Shape( crs, rootFileName, tilePoperty, directoryProperty );
    360        }
    361
    362        /**
    363         * creates a <tt>File</tt> object from the passed Element that describes the extensions and locations of the
    364         * coverages assigned to a <tt>Resolution</tt>
    365         *
    366         * @param element
    367         * @return <tt>File</tt> object from the passed Element that describes the extensions and locations of the coverages
    368         *         assigned to a <tt>Resolution</tt>
    369         * @throws XMLParsingException
    370         * @throws UnknownCRSException
    371         */
    372        private org.deegree.ogcwebservices.wcs.configuration.File getFile( Element element )
    373                                throws XMLParsingException, InvalidGMLException, UnknownCRSException {
    374            String name = XMLTools.getRequiredStringValue( "Name", DGRNS, element );
    375            XMLFragment xml = new XMLFragment();
    376            xml.setRootElement( element );
    377            xml.setSystemId( systemId );
    378            File file = new File( name );
    379            try {
    380                URL url = xml.resolve( name );
    381                file = new java.io.File( url.toURI() );
    382            } catch ( Exception e ) {
    383                LOG.logError( e.getMessage(), e );
    384                e.printStackTrace();
    385            }
    386            name = file.getAbsolutePath();
    387
    388            Element elem = XMLTools.getRequiredChildElement( "Envelope", GMLNS, element );
    389            Envelope envelope = GMLGeometryAdapter.wrapBox( elem, null );
    390            String srs = XMLTools.getRequiredAttrValue( "srsName", null, elem );
    391
    392            String[] tmp = StringTools.toArray( srs, "#", false );
    393            // just a heuristic because it is not guarranteed that the URL
    394            // in the srsName attribute can be solved
    395            if ( srs.toLowerCase().indexOf( "epsg" ) > -1 ) {
    396                srs = "EPSG:" + tmp[1];
    397            } else {
    398                srs = "CRS:" + tmp[1];
    399            }
    400            if ( tmp[1].equals( "0" ) ) {
    401                srs = null;
    402            }
    403
    404            CoordinateSystem crs = CRSFactory.create( srs );
    405            return new org.deegree.ogcwebservices.wcs.configuration.File( crs, name, envelope );
    406        }
    407
    408        /**
    409         * creates a <tt>Directory</tt> object from the passed Elememt that describes the extensions and locations of the
    410         * coverages assigned to a <tt>Resolution</tt>
    411         *
    412         * @param element
    413         * @return <tt>Directory</tt> object from the passed Elememt that describes the extensions and locations of the
    414         *         coverages assigned to a <tt>Resolution</tt>
    415         * @throws XMLParsingException
    416         * @throws UnknownCRSException
    417         */
    418        private Directory getDirectory( Element element )
    419                                throws XMLParsingException, InvalidGMLException, UnknownCRSException {
    420            // get valid file extension for this directory
    421            String temp = XMLTools.getRequiredAttrValue( "extensions", null, element );
    422            String[] extensions = StringTools.toArray( temp, ",;", true );
    423            // get the width and height (in pixels) af the tiles in this directory
    424            temp = XMLTools.getRequiredAttrValue( "tileWidth", null, element );
    425            double tileWidth = 0;
    426            try {
    427                tileWidth = Double.parseDouble( temp );
    428            } catch ( Exception e ) {
    429                throw new XMLParsingException( "tileWidth attribute isn't a number" );
    430            }
    431            double tileHeight = 0;
    432            try {
    433                tileHeight = Double.parseDouble( temp );
    434            } catch ( Exception e ) {
    435                throw new XMLParsingException( "tileHeight attribute isn't a number" );
    436            }
    437            // get the directroy name
    438            String name = XMLTools.getRequiredStringValue( "Name", DGRNS, element );
    439            XMLFragment xml = new XMLFragment();
    440            xml.setRootElement( element );
    441            xml.setSystemId( systemId );
    442            try {
    443                // resolve name if relative
    444                name = xml.resolve( name ).toExternalForm();
    445            } catch ( MalformedURLException e ) {
    446                throw new XMLParsingException( "invalid file name/path: " + name );
    447            }
    448            // get the bounding envelope of all tiles in the directory
    449            Element elem = XMLTools.getRequiredChildElement( "Envelope", GMLNS, element );
    450            Envelope envelope = GMLGeometryAdapter.wrapBox( elem, null );
    451            String srs = XMLTools.getRequiredAttrValue( "srsName", null, elem );
    452            if ( srs != null ) {
    453                String[] tmp = StringTools.toArray( srs, "#", false );
    454                // just a heuristic because it is not guarranteed that the URL
    455                // in the srsName attribute can be solved
    456                if ( srs.toLowerCase().indexOf( "epsg" ) > -1 ) {
    457                    srs = "EPSG:" + tmp[1];
    458                } else {
    459                    srs = "CRS:" + tmp[1];
    460                }
    461                if ( tmp[1].equals( "0" ) )
    462                    srs = null;
    463            }
    464            CoordinateSystem crs = CRSFactory.create( srs );
    465            return new GridDirectory( name, envelope, crs, extensions, tileWidth, tileHeight );
    466        }
    467
    468        /**
    469         * creates an array of <tt>Ranges</tt> from the passed element list
    470         *
    471         * @param el
    472         * @return created array of <tt>Ranges</tt>
    473         * @throws XMLParsingException
    474         */
    475        private Range[] getRanges( List<Node> el )
    476                                throws XMLParsingException {
    477            Range[] ranges = new Range[el.size()];
    478            for ( int i = 0; i < ranges.length; i++ ) {
    479                ranges[i] = getRange( (Element) el.get( i ) );
    480            }
    481            return ranges;
    482        }
    483
    484        /**
    485         * creates a <tt>Range</tt> object from the passed element
    486         *
    487         * @param element
    488         * @return created <tt>Range</tt>
    489         * @throws XMLParsingException
    490         */
    491        private Range getRange( Element element )
    492                                throws XMLParsingException {
    493            String name = XMLTools.getRequiredStringValue( "Name", DGRNS, element );
    494            ElementList el = XMLTools.getChildElements( "Axis", DGRNS, element );
    495            Axis[] axis = getAxis( el );
    496            return new Range( name, axis );
    497        }
    498
    499        /**
    500         * creates an array of <tt>Axis</tt> objects from the passed element list
    501         *
    502         * @param el
    503         * @return created array of <tt>Axis</tt>
    504         * @throws XMLParsingException
    505         */
    506        private Axis[] getAxis( ElementList el )
    507                                throws XMLParsingException {
    508            Axis[] axis = new Axis[el.getLength()];
    509            for ( int i = 0; i < axis.length; i++ ) {
    510                axis[i] = getAxis( el.item( i ) );
    511            }
    512            return axis;
    513        }
    514
    515        /**
    516         * creates an <tt>Axis</tt> object from the passed element. The <tt>Interval</tt> included in the <tt>Axis</tt>
    517         * doesn't have a resolution because it isn't required.
    518         *
    519         * @param element
    520         * @return created <tt>Axis</tt>
    521         * @throws XMLParsingException
    522         */
    523        private Axis getAxis( Element element )
    524                                throws XMLParsingException {
    525            try {
    526                String name = XMLTools.getRequiredStringValue( "Name", DGRNS, element );
    527                Element elem = XMLTools.getRequiredChildElement( "Interval", DGRNS, element );
    528                String tmp = XMLTools.getRequiredStringValue( "min", DGRNS, elem );
    529                TypedLiteral min = new TypedLiteral( tmp, new URI( "xs:double" ) );
    530                tmp = XMLTools.getRequiredStringValue( "max", DGRNS, elem );
    531                TypedLiteral max = new TypedLiteral( tmp, new URI( "xs:double" ) );
    532                Interval interval = new Interval( min, max, null, null, null );
    533                return new Axis( name, interval );
    534            } catch ( URISyntaxException e ) {
    535                LOG.logError( e.getMessage(), e );
    536                throw new XMLParsingException( e.getMessage() );
    537            }
    538        }
    539
    540    }