    001    //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_testing/src/org/deegree/ogcwebservices/sos/ComponentDescriptionDocument.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.sos;
    037
    038    import java.io.IOException;
    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.framework.xml.XMLParsingException;
    047    import org.deegree.framework.xml.XMLTools;
    048    import org.deegree.model.metadata.iso19115.Address;
    049    import org.deegree.model.metadata.iso19115.CitedResponsibleParty;
    050    import org.deegree.model.metadata.iso19115.ContactInfo;
    051    import org.deegree.model.metadata.iso19115.FunctionCode;
    052    import org.deegree.model.metadata.iso19115.Linkage;
    053    import org.deegree.model.metadata.iso19115.OnlineResource;
    054    import org.deegree.model.metadata.iso19115.Phone;
    055    import org.deegree.model.metadata.iso19115.RoleCode;
    056    import org.deegree.ogcbase.OGCDocument;
    057    import org.deegree.ogcwebservices.sos.sensorml.BasicResponse;
    058    import org.deegree.ogcwebservices.sos.sensorml.Classifier;
    059    import org.deegree.ogcwebservices.sos.sensorml.ComponentDescription;
    060    import org.deegree.ogcwebservices.sos.sensorml.CoordinateReferenceSystem;
    061    import org.deegree.ogcwebservices.sos.sensorml.Discussion;
    062    import org.deegree.ogcwebservices.sos.sensorml.EngineeringCRS;
    063    import org.deegree.ogcwebservices.sos.sensorml.GeoLocation;
    064    import org.deegree.ogcwebservices.sos.sensorml.GeoPositionModel;
    065    import org.deegree.ogcwebservices.sos.sensorml.GeographicCRS;
    066    import org.deegree.ogcwebservices.sos.sensorml.Identifier;
    067    import org.deegree.ogcwebservices.sos.sensorml.LocationModel;
    068    import org.deegree.ogcwebservices.sos.sensorml.ProjectedCRS;
    069    import org.deegree.ogcwebservices.sos.sensorml.Quantity;
    070    import org.deegree.ogcwebservices.sos.sensorml.Reference;
    071    import org.deegree.ogcwebservices.sos.sensorml.ResponseModel;
    072    import org.deegree.ogcwebservices.sos.sensorml.TypedQuantity;
    073    import org.w3c.dom.Node;
    074    import org.xml.sax.SAXException;
    075
    076    /**
    077     * gets the metadata from a XSL transformed wfs result
    078     *
    079     * @author <a href="mailto:mkulbe@lat-lon.de">Matthias Kulbe </a>
    080     * @author last edited by: $Author: mschneider $
    081     *
    082     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
    083     */
    084    public abstract class ComponentDescriptionDocument extends OGCDocument {
    085
    086        /**
    087         * exceptions decleration must be there because this method will be overeritten by extending
    088         * classes
    089         *
    090         * @throws IOException
    091         * @throws SAXException
    092         */
    093        public abstract void createEmptyDocument()
    094                                throws IOException, SAXException;
    095
    096        /**
    097         * gets the identifiedAs part of a item
    098         *
    099         * @param node
    100         * @return the identifiedAs part of a item (maybe <code>null</code>)
    101         * @throws XMLParsingException
    102         */
    103        protected Identifier getIdentifiedAs( Node node )
    104                                throws XMLParsingException {
    105
    106            if ( node != null ) {
    107                // value is required
    108                String value = XMLTools.getRequiredNodeAsString( node, "sml:Identifier/text()", nsContext );
    109                // type is optional
    110                String type = XMLTools.getNodeAsString( node, "sml:Identifier/@type", nsContext, null );
    111                // codeSpace is optional
    112                String codeSpace = XMLTools.getNodeAsString( node, "sml:Identifier/@codespace", nsContext, null );
    113
    114                int typeId = 0;
    115
    116                // type must compare to one of this values
    117                if ( type == null ) {
    118                    typeId = 0;
    119                } else if ( "shortName".equalsIgnoreCase( type ) ) {
    120                    typeId = 1;
    121                } else if ( "longName".equalsIgnoreCase( type ) ) {
    122                    typeId = 2;
    123                } else if ( "serialNumber".equalsIgnoreCase( type ) ) {
    124                    typeId = 3;
    125                } else if ( "modelNumber".equalsIgnoreCase( type ) ) {
    126                    typeId = 4;
    127                } else if ( "missionNumber".equalsIgnoreCase( type ) ) {
    128                    typeId = 5;
    129                } else if ( "partNumber".equalsIgnoreCase( type ) ) {
    130                    typeId = 6;
    131                } else {
    132                    throw new XMLParsingException( type + " is not a valid type for Identifier" );
    133                }
    134
    135                return new Identifier( value, typeId, codeSpace );
    136            }
    137            return null;
    138        }
    139
    140        /**
    141         * gets the classifiedAs part of a item
    142         *
    143         * @param node
    144         * @return the classifiedAs part of a item (maybe <code>null</code>)
    145         * @throws XMLParsingException
    146         */
    147        protected Classifier getClassifiedAs( Node node )
    148                                throws XMLParsingException {
    149
    150            if ( node != null ) {
    151                // value is required
    152                String value = XMLTools.getRequiredNodeAsString( node, "sml:Classifier/text()", nsContext );
    153                // type ist required
    154                String type = XMLTools.getRequiredNodeAsString( node, "sml:Classifier/@type", nsContext );
    155                // codeSpace is optional
    156                String codeSpace = XMLTools.getNodeAsString( node, "sml:Classifier/@codespace", nsContext, null );
    157
    158                return new Classifier( value, type, codeSpace );
    159            }
    160            return null;
    161
    162        }
    163
    164        /**
    165         * gets the attachedTo part of a Item
    166         *
    167         * @param node
    168         * @return the attachedTo part of a Item (maybe <code>null</code>)
    169         * @throws XMLParsingException
    170         */
    171        protected String getAttachedTo( Node node )
    172                                throws XMLParsingException {
    173            if ( node != null ) {
    174                return XMLTools.getNodeAsString( node, "sml:Component/text()", nsContext, null );
    175            }
    176            return null;
    177        }
    178
    179        /**
    180         * gets the hasCRS part of a Item
    181         *
    182         * @param node
    183         * @return the hasCRS part of a Item (maybe <code>null</code>)
    184         * @throws XMLParsingException
    185         */
    186        protected EngineeringCRS getHasCRS( Node node )
    187                                throws XMLParsingException {
    188            if ( node != null ) {
    189                return getEngineeringCRS( node );
    190            }
    191            return null;
    192        }
    193
    194        /**
    195         *
    196         * @param node
    197         * @return the crs
    198         * @throws XMLParsingException
    199         */
    200        protected EngineeringCRS getEngineeringCRS( Node node )
    201                                throws XMLParsingException {
    202            if ( node != null ) {
    203                String srsName = XMLTools.getRequiredNodeAsString( node, "gml:EngineeringCRS/gml:srsName/text()", nsContext );
    204                return new EngineeringCRS( srsName );
    205            }
    206            return null;
    207        }
    208
    209        /**
    210         *
    211         * @param node
    212         * @return the crs
    213         * @throws XMLParsingException
    214         */
    215        protected CoordinateReferenceSystem getCoordinateReferenceSystemCRS( Node node )
    216                                throws XMLParsingException {
    217            if ( node != null ) {
    218                // is GeographicCRS
    219                if ( ( XMLTools.getNode( node, "gml:GeographicCRS", nsContext ) ) != null ) {
    220                    String srsName = XMLTools.getNodeAsString( node, "gml:GeographicCRS/gml:srsName/text()", nsContext,
    221                                                               null );
    222                    if ( srsName != null ) {
    223                        return new GeographicCRS( srsName );
    224                    }
    225
    226                }
    227
    228                // is ProjectedCRS
    229                if ( ( XMLTools.getNode( node, "gml:ProjectedCRS", nsContext ) ) != null ) {
    230                    String srsName = XMLTools.getNodeAsString( node, "gml:ProjectedCRS/gml:srsName/text()", nsContext, null );
    231                    if ( srsName != null ) {
    232                        return new ProjectedCRS( srsName );
    233                    }
    234
    235                }
    236
    237            }
    238            return null;
    239        }
    240
    241        /**
    242         *
    243         * @param node
    244         * @return the geo location?
    245         * @throws XMLParsingException
    246         * @throws URISyntaxException
    247         */
    248        protected Object getUsesParametersFromGeoLocation( Node node )
    249                                throws XMLParsingException, URISyntaxException {
    250            if ( node != null ) {
    251                if ( ( XMLTools.getNode( node, "sml:GeoLocation", nsContext ) ) != null ) {
    252                    String id = XMLTools.getNodeAsString( node, "sml:GeoLocation/@id", nsContext, null );
    253
    254                    // required
    255                    Quantity latitude = getQuantity( XMLTools.getRequiredNode( node, "sml:GeoLocation/sml:latitude",
    256                                                                               nsContext ) );
    257                    Quantity longitude = getQuantity( XMLTools.getRequiredNode( node, "sml:GeoLocation/sml:longitude",
    258                                                                                nsContext ) );
    259
    260                    // optional
    261                    Quantity altitude = getQuantity( XMLTools.getNode( node, "sml:GeoLocation/sml:altitude", nsContext ) );
    262                    Quantity trueHeading = getQuantity( XMLTools.getNode( node, "sml:GeoLocation/sml:trueHeading",
    263                                                                          nsContext ) );
    264                    Quantity speed = getQuantity( XMLTools.getNode( node, "sml:GeoLocation/sml:speed", nsContext ) );
    265
    266                    return new GeoLocation( id, latitude, longitude, altitude, trueHeading, speed );
    267                }
    268
    269            }
    270            return null;
    271        }
    272
    273        /**
    274         *
    275         * @param node
    276         * @return the basic response?
    277         * @throws XMLParsingException
    278         * @throws URISyntaxException
    279         */
    280        protected Object getUsesParametersFromResponseModel( Node node )
    281                                throws XMLParsingException, URISyntaxException {
    282            if ( node != null ) {
    283                if ( ( XMLTools.getNode( node, "sml:BasicResponse", nsContext ) ) != null ) {
    284
    285                    // required
    286                    TypedQuantity resolution = getTypedQuantity( XMLTools.getRequiredNode(
    287                                                                                           node,
    288                                                                                           "sml:BasicResponse/sml:resolution",
    289                                                                                           nsContext ) );
    290
    291                    return new BasicResponse( resolution );
    292                }
    293
    294                // can add other types, but now not implemented
    295
    296            }
    297            return null;
    298        }
    299
    300        /**
    301         *
    302         * @param node
    303         * @return the quantity
    304         * @throws XMLParsingException
    305         * @throws URISyntaxException
    306         */
    307        protected Quantity getQuantity( Node node )
    308                                throws XMLParsingException, URISyntaxException {
    309            if ( node != null ) {
    310                String value = XMLTools.getRequiredNodeAsString( node, "sml:Quantity/text()", nsContext );
    311
    312                if ( value != null ) {
    313                    Quantity temp = new Quantity( Double.parseDouble( value ) );
    314
    315                    // gets the uom parameter
    316                    String paramUom = XMLTools.getNodeAsString( node, "sml:Quantity/@uom", nsContext, null );
    317                    if ( paramUom != null ) {
    318
    319                        temp.setUom( new URI( paramUom ) );
    320                    }
    321
    322                    // gets the min parameter
    323                    String paramMin = XMLTools.getNodeAsString( node, "sml:Quantity/@min", nsContext, null );
    324                    if ( paramMin != null ) {
    325
    326                        temp.setMin( Double.parseDouble( paramMin ) );
    327                    }
    328
    329                    // gets the max parameter
    330                    String paramMax = XMLTools.getNodeAsString( node, "sml:Quantity/@max", nsContext, null );
    331                    if ( paramMax != null ) {
    332
    333                        temp.setMax( Double.parseDouble( paramMax ) );
    334                    }
    335
    336                    // gets the fixed parameter
    337                    String paramFixed = XMLTools.getNodeAsString( node, "sml:Quantity/@fixed", nsContext, null );
    338                    if ( paramFixed != null ) {
    339                        if ( paramFixed.equalsIgnoreCase( "true" ) ) {
    340
    341                            temp.setFixed( true );
    342                        } else if ( paramFixed.equalsIgnoreCase( "false" ) ) {
    343
    344                            temp.setFixed( false );
    345                        }
    346                    }
    347                    return temp;
    348                }
    349
    350            }
    351
    352            return null;
    353        }
    354
    355        /**
    356         *
    357         * @param node
    358         * @return the bean
    359         * @throws XMLParsingException
    360         * @throws URISyntaxException
    361         */
    362        protected TypedQuantity getTypedQuantity( Node node )
    363                                throws XMLParsingException, URISyntaxException {
    364            if ( node != null ) {
    365
    366                String value = XMLTools.getRequiredNodeAsString( node, "sml:TypedQuantity/text()", nsContext );
    367
    368                String type = XMLTools.getRequiredNodeAsString( node, "sml:TypedQuantity/@type", nsContext );
    369
    370                TypedQuantity temp = new TypedQuantity( Double.parseDouble( value ), new URI( type ) );
    371
    372                // gets the uom parameter
    373                String paramUom = XMLTools.getNodeAsString( node, "sml:TypedQuantity/@uom", nsContext, null );
    374                if ( paramUom != null ) {
    375
    376                    temp.setUom( new URI( paramUom ) );
    377                }
    378
    379                // gets the min parameter
    380                String paramMin = XMLTools.getNodeAsString( node, "sml:TypedQuantity/@min", nsContext, null );
    381                if ( paramMin != null ) {
    382
    383                    temp.setMin( Double.parseDouble( paramMin ) );
    384                }
    385
    386                // gets the max parameter
    387                String paramMax = XMLTools.getNodeAsString( node, "sml:TypedQuantity/@max", nsContext, null );
    388                if ( paramMax != null ) {
    389
    390                    temp.setMax( Double.parseDouble( paramMax ) );
    391                }
    392
    393                // gets the fixed parameter
    394                String paramFixed = XMLTools.getNodeAsString( node, "sml:TypedQuantity/@fixed", nsContext, null );
    395                if ( paramFixed != null ) {
    396                    if ( paramFixed.equalsIgnoreCase( "false" ) ) {
    397
    398                        temp.setFixed( false );
    399                    }
    400                }
    401
    402                // gets the codeSpace parameter
    403                String codeSpaceAsString = XMLTools.getNodeAsString( node, "sml:TypedQuantity/@codeSpace", nsContext, null );
    404                if ( codeSpaceAsString != null ) {
    405                    URI codeSpace = new URI( codeSpaceAsString );
    406                    temp.setCodeSpace( codeSpace );
    407                }
    408                return temp;
    409            }
    410
    411            return null;
    412        }
    413
    414        /**
    415         *
    416         * @param node
    417         * @return the bean
    418         * @throws XMLParsingException
    419         * @throws MalformedURLException
    420         */
    421        protected ComponentDescription getDescribedBy( Node node )
    422                                throws MalformedURLException, XMLParsingException {
    423            if ( node != null ) {
    424
    425                boolean create = false;
    426
    427                // get optional id
    428                String id = XMLTools.getNodeAsString( node, "sml:ComponentDescription/@id", nsContext, null );
    429                if ( id != null )
    430                    create = true;
    431
    432                // get optional description
    433                ArrayList<Discussion> descriptions = new ArrayList<Discussion>();
    434                List<Node> descriptionList = XMLTools.getNodes( node, "sml:ComponentDescription/sml:description", nsContext );
    435                if ( ( descriptionList != null ) && ( descriptionList.size() > 0 ) )
    436                    create = true;
    437                for ( int i = 0; i < descriptionList.size(); i++ ) {
    438                    descriptions.add( getDiscussion( descriptionList.get( i ) ) );
    439                }
    440
    441                // get optional reference
    442                List<Node> referenceList = XMLTools.getNodes( node, "sml:ComponentDescription/sml:reference", nsContext );
    443                if ( ( referenceList != null ) && ( referenceList.size() > 0 ) ) {
    444                    create = true;
    445
    446                }
    447                ArrayList<Reference> references = new ArrayList<Reference>( referenceList.size() );
    448                for ( int i = 0; i < referenceList.size(); i++ ) {
    449                    Reference actreference = getReference( referenceList.get( i ) );
    450                    if ( actreference != null ) {
    451                        references.add( actreference );
    452                    }
    453                }
    454
    455                // get optional operatedBy
    456                List<Node> operatedByList = XMLTools.getNodes( node, "sml:ComponentDescription/sml:operatedBy", nsContext );
    457                if ( ( operatedByList != null ) && ( operatedByList.size() > 0 ) ) {
    458                    create = true;
    459
    460                }
    461                ArrayList<CitedResponsibleParty> operatedBys = new ArrayList<CitedResponsibleParty>( operatedByList.size() );
    462                for ( int i = 0; i < operatedByList.size(); i++ ) {
    463                    CitedResponsibleParty actResponsibleParty = getResponsibleParty( operatedByList.get( i ) );
    464                    if ( actResponsibleParty != null ) {
    465                        operatedBys.add( actResponsibleParty );
    466                    }
    467                }
    468
    469                // get optional manufactedBy
    470                List<Node> manufactedByList = XMLTools.getNodes( node, "sml:ComponentDescription/sml:manufactedBy",
    471                                                                 nsContext );
    472                if ( ( manufactedByList != null ) && ( manufactedByList.size() > 0 ) ) {
    473                    create = true;
    474
    475                }
    476                ArrayList<CitedResponsibleParty> manufactedBys = new ArrayList<CitedResponsibleParty>(
    477                                                                                                       manufactedByList.size() );
    478                for ( int i = 0; i < manufactedByList.size(); i++ ) {
    479                    CitedResponsibleParty actResponsibleParty = getResponsibleParty( manufactedByList.get( i ) );
    480                    if ( actResponsibleParty != null ) {
    481                        manufactedBys.add( actResponsibleParty );
    482                    }
    483                }
    484
    485                // get optional deployedBys
    486                List<Node> deployedByList = XMLTools.getNodes( node, "sml:ComponentDescription/sml:deployedBy", nsContext );
    487                if ( ( deployedByList != null ) && ( deployedByList.size() > 0 ) ) {
    488                    create = true;
    489
    490                }
    491                ArrayList<CitedResponsibleParty> deployedBys = new ArrayList<CitedResponsibleParty>( deployedByList.size() );
    492                for ( int i = 0; i < deployedByList.size(); i++ ) {
    493                    CitedResponsibleParty actResponsibleParty = getResponsibleParty( deployedByList.get( i ) );
    494                    if ( actResponsibleParty != null ) {
    495                        deployedBys.add( actResponsibleParty );
    496                    }
    497                }
    498
    499                if ( create ) {
    500                    return new ComponentDescription(
    501                                                     id,
    502                                                     ( manufactedBys.toArray( new CitedResponsibleParty[manufactedBys.size()] ) ),
    503                                                     ( deployedBys.toArray( new CitedResponsibleParty[deployedBys.size()] ) ),
    504                                                     ( operatedBys.toArray( new CitedResponsibleParty[operatedBys.size()] ) ),
    505                                                     ( descriptions.toArray( new Discussion[descriptions.size()] ) ),
    506                                                     ( references.toArray( new Reference[references.size()] ) ) );
    507                }
    508
    509            }
    510            return null;
    511
    512        }
    513
    514        /**
    515         *
    516         * @param node
    517         * @return the bean
    518         * @throws XMLParsingException
    519         * @throws URISyntaxException
    520         */
    521        protected LocationModel getLocatedUsing( Node node )
    522                                throws XMLParsingException, URISyntaxException {
    523
    524            if ( node != null ) {
    525                if ( ( XMLTools.getNode( node, "sml:GeoPositionModel", nsContext ) ) != null ) {
    526
    527                    String id = XMLTools.getNodeAsString( node, "sml:GeoPositionModel/@id", nsContext, null );
    528
    529                    // get identifiedAs
    530                    ArrayList<Identifier> identifiers = new ArrayList<Identifier>();
    531                    List<Node> identifierList = XMLTools.getNodes( node, "sml:GeoPositionModel/sml:identifiedAs", nsContext );
    532                    for ( int i = 0; i < identifierList.size(); i++ ) {
    533                        identifiers.add( getIdentifiedAs( identifierList.get( i ) ) );
    534                    }
    535
    536                    // get ClassifiedAs
    537                    ArrayList<Classifier> classifiers = new ArrayList<Classifier>();
    538                    List<Node> classifierList = XMLTools.getNodes( node, "sml:GeoPositionModel/sml:classifiedAs", nsContext );
    539                    for ( int i = 0; i < classifierList.size(); i++ ) {
    540                        classifiers.add( getClassifiedAs( classifierList.get( i ) ) );
    541                    }
    542
    543                    // get optional description
    544                    ArrayList<Discussion> descriptions = new ArrayList<Discussion>();
    545                    List<Node> descriptionList = XMLTools.getNodes( node, "sml:GeoPositionModel/sml:description", nsContext );
    546                    for ( int i = 0; i < descriptionList.size(); i++ ) {
    547                        descriptions.add( getDiscussion( descriptionList.get( i ) ) );
    548                    }
    549
    550                    // get sourceCRS
    551                    Node tNode = XMLTools.getRequiredNode( node, "sml:GeoPositionModel/sml:sourceCRS", nsContext );
    552                    EngineeringCRS sourceCRS = getEngineeringCRS( tNode );
    553
    554                    // get referenceCRS
    555                    tNode = XMLTools.getRequiredNode( node, "sml:GeoPositionModel/sml:referenceCRS", nsContext );
    556                    CoordinateReferenceSystem referenceCRS = getCoordinateReferenceSystemCRS( tNode );
    557
    558                    // get usesParameters
    559                    ArrayList<Object> usesParameters = new ArrayList<Object>();
    560                    List<Node> usesParametersList = XMLTools.getNodes( node, "sml:GeoPositionModel/sml:usesParameters",
    561                                                                       nsContext );
    562                    if ( ( usesParametersList == null ) || ( usesParametersList.size() <= 0 ) ) {
    563                        throw new XMLParsingException( "at least one usesParameters required" );
    564                    }
    565                    for ( int i = 0; i < usesParametersList.size(); i++ ) {
    566                        usesParameters.add( getUsesParametersFromGeoLocation( usesParametersList.get( i ) ) );
    567                    }
    568
    569                    return new GeoPositionModel( id, ( identifiers.toArray( new Identifier[identifiers.size()] ) ),
    570                                                 ( classifiers.toArray( new Classifier[classifiers.size()] ) ),
    571                                                 ( descriptions.toArray( new Discussion[descriptions.size()] ) ),
    572                                                 sourceCRS, referenceCRS,
    573                                                 usesParameters.toArray( new Object[usesParameters.size()] ) );
    574                }
    575
    576            }
    577            return null;
    578
    579        }
    580
    581        /**
    582         *
    583         * @param node
    584         * @return the bean
    585         * @throws XMLParsingException
    586         * @throws URISyntaxException
    587         */
    588        protected ResponseModel getDerivedFrom( Node node )
    589                                throws XMLParsingException, URISyntaxException {
    590
    591            if ( node != null ) {
    592
    593                String id = XMLTools.getNodeAsString( node, "sml:ResponseModel/@id", nsContext, null );
    594
    595                // get identifiedAs
    596                ArrayList<Identifier> identifiers = new ArrayList<Identifier>();
    597                List<Node> identifierList = XMLTools.getNodes( node, "sml:ResponseModel/sml:identifiedAs", nsContext );
    598                for ( int i = 0; i < identifierList.size(); i++ ) {
    599                    identifiers.add( getIdentifiedAs( identifierList.get( i ) ) );
    600                }
    601
    602                // get ClassifiedAs
    603                ArrayList<Classifier> classifiers = new ArrayList<Classifier>();
    604                List<Node> classifierList = XMLTools.getNodes( node, "sml:ResponseModel/sml:classifiedAs", nsContext );
    605                for ( int i = 0; i < classifierList.size(); i++ ) {
    606                    classifiers.add( getClassifiedAs( classifierList.get( i ) ) );
    607                }
    608
    609                // get optional description
    610                ArrayList<Discussion> descriptions = new ArrayList<Discussion>();
    611                List<Node> descriptionList = XMLTools.getNodes( node, "sml:ResponseModel/sml:description", nsContext );
    612                for ( int i = 0; i < descriptionList.size(); i++ ) {
    613                    descriptions.add( getDiscussion( descriptionList.get( i ) ) );
    614                }
    615
    616                // get usesParameters
    617                // in spec this parameter is optional, but now is required for set
    618                // time resolution
    619                ArrayList<Object> usesParameters = new ArrayList<Object>();
    620                List<Node> usesParametersList = XMLTools.getNodes( node, "sml:ResponseModel/sml:usesParameters", nsContext );
    621                for ( int i = 0; i < usesParametersList.size(); i++ ) {
    622                    usesParameters.add( getUsesParametersFromResponseModel( usesParametersList.get( i ) ) );
    623                }
    624
    625                // only creats the object if least one value set
    626                if ( ( id != null ) || ( identifiers.size() > 0 ) || ( classifiers.size() > 0 )
    627                     || ( descriptions.size() > 0 ) || ( usesParameters.size() > 0 ) ) {
    628                    return new ResponseModel( id, ( identifiers.toArray( new Identifier[identifiers.size()] ) ),
    629                                              ( classifiers.toArray( new Classifier[classifiers.size()] ) ),
    630                                              ( descriptions.toArray( new Discussion[descriptions.size()] ) ),
    631                                              usesParameters.toArray( new Object[usesParameters.size()] ) );
    632                }
    633            }
    634            return null;
    635
    636        }
    637
    638        /**
    639         *
    640         * @param node
    641         * @return the bean
    642         * @throws MalformedURLException
    643         * @throws XMLParsingException
    644         */
    645        protected Reference getReference( Node node )
    646                                throws MalformedURLException, XMLParsingException {
    647
    648            if ( node != null ) {
    649                Object getvalue = null;
    650
    651                getvalue = getOnlineResource( node );
    652
    653                if ( getvalue != null ) {
    654
    655                    return new Reference( getvalue );
    656                }
    657            }
    658            return null;
    659
    660        }
    661
    662        /**
    663         *
    664         * @param node
    665         * @return the bean
    666         * @throws XMLParsingException
    667         */
    668        protected Discussion getDiscussion( Node node )
    669                                throws XMLParsingException {
    670            if ( node != null ) {
    671                // required
    672                String value = XMLTools.getRequiredNodeAsString( node, "text()", nsContext );
    673                URI topic = null;
    674                // optional
    675                String topicString = XMLTools.getNodeAsString( node, "@topic", nsContext, null );
    676                URI codeSpace = null;
    677                // optional
    678                String codeSpaceString = XMLTools.getNodeAsString( node, "@codeSpace", nsContext, null );
    679                // optional
    680                String id = XMLTools.getNodeAsString( node, "@id", nsContext, null );
    681
    682                try {
    683                    if ( topicString != null )
    684                        topic = new URI( topicString );
    685
    686                    if ( codeSpaceString != null )
    687                        codeSpace = new URI( codeSpaceString );
    688                } catch ( URISyntaxException e ) {
    689                    throw new XMLParsingException( "URISyntaxException: not a valid URI" );
    690                }
    691
    692                return new Discussion( value, topic, codeSpace, id );
    693            }
    694            return null;
    695
    696        }
    697
    698        /**
    699         *
    700         * @param node
    701         * @return the bean
    702         * @throws XMLParsingException
    703         * @throws MalformedURLException
    704         */
    705        protected OnlineResource getOnlineResource( Node node )
    706                                throws XMLParsingException, MalformedURLException {
    707
    708            if ( node != null ) {
    709                String function = XMLTools.getNodeAsString( node, "iso19115:CI_OnlineResource/iso19115:function/text()",
    710                                                            nsContext, null );
    711
    712                String linkageString = XMLTools.getNodeAsString( node,
    713                                                                 "iso19115:CI_OnlineResource/iso19115:linkage/text()",
    714                                                                 nsContext, null );
    715
    716                String protocol = XMLTools.getNodeAsString( node, "iso19115:CI_OnlineResource/iso19115:protocol/text()",
    717                                                            nsContext, null );
    718
    719                String applicationProfile = XMLTools.getNodeAsString(
    720                                                                      node,
    721                                                                      "iso19115:CI_OnlineResource/iso19115:applicationProfile/text()",
    722                                                                      nsContext, null );
    723
    724                String name = XMLTools.getNodeAsString( node, "iso19115:CI_OnlineResource/iso19115:name/text()", nsContext,
    725                                                        null );
    726
    727                String description = XMLTools.getNodeAsString( node,
    728                                                               "iso19115:CI_OnlineResource/iso19115:description/text()",
    729                                                               nsContext, null );
    730
    731                if ( linkageString != null ) {
    732                    return new OnlineResource( applicationProfile, new FunctionCode( function ),
    733                                               new Linkage( new URL( linkageString ) ), description, name, protocol );
    734                }
    735            }
    736            return null;
    737        }
    738
    739        /**
    740         *
    741         * @param node
    742         * @return the bean
    743         * @throws XMLParsingException
    744         */
    745        protected Phone getPhone( Node node )
    746                                throws XMLParsingException {
    747
    748            if ( node != null ) {
    749                // get voices
    750                String[] voices = XMLTools.getNodesAsStrings( node, "iso19115:phone/iso19115:voice/text()", nsContext );
    751                // get facsimiles
    752                String[] facsimiles = XMLTools.getNodesAsStrings( node, "iso19115:phone/iso19115:facsimile/text()",
    753                                                                  nsContext );
    754                return new Phone( facsimiles, null, null, voices );
    755            }
    756            return null;
    757        }
    758
    759        /**
    760         *
    761         * @param node
    762         * @return the bean
    763         * @throws XMLParsingException
    764         */
    765        protected Address getAddress( Node node )
    766                                throws XMLParsingException {
    767
    768            if ( node != null ) {
    769                String city = XMLTools.getNodeAsString( node, "iso19115:address/iso19115:city/text()", nsContext, null );
    770
    771                String administrativeArea = XMLTools.getNodeAsString(
    772                                                                      node,
    773                                                                      "iso19115:address/iso19115:administrativeArea/text()",
    774                                                                      nsContext, null );
    775
    776                String postalCode = XMLTools.getNodeAsString( node, "iso19115:address/iso19115:postalCode/text()",
    777                                                              nsContext, null );
    778
    779                String country = XMLTools.getNodeAsString( node, "iso19115:address/iso19115:country/text()", nsContext,
    780                                                           null );
    781
    782                // get deliveryPoints
    783                String[] deliveryPoints = XMLTools.getNodesAsStrings( node,
    784                                                                      "iso19115:address/iso19115:deliveryPoint/text()",
    785                                                                      nsContext );
    786                // get electronicMailAdresses
    787                String[] electronicMailAdresses = XMLTools.getNodesAsStrings(
    788                                                                              node,
    789                                                                              "iso19115:address/iso19115:electronicMailAddress/text()",
    790                                                                              nsContext );
    791                return new Address( administrativeArea, city, country, deliveryPoints, electronicMailAdresses, postalCode );
    792            }
    793            return null;
    794        }
    795
    796        /**
    797         *
    798         * @param node
    799         * @return the bean
    800         * @throws MalformedURLException
    801         * @throws XMLParsingException
    802         */
    803        protected ContactInfo getContactInfo( Node node )
    804                                throws MalformedURLException, XMLParsingException {
    805
    806            if ( node != null ) {
    807                Phone phone = getPhone( node );
    808                Address address = getAddress( node );
    809                OnlineResource onlineResource = getOnlineResource( node );
    810                String hoursOfService = XMLTools.getNodeAsString( node, "iso19115:hoursOfService/text()", nsContext, null );
    811                String contactInstructions = XMLTools.getNodeAsString( node, "iso19115:contactInstructions/text()",
    812                                                                       nsContext, null );
    813
    814                return new ContactInfo( address, contactInstructions, hoursOfService, onlineResource, phone );
    815            }
    816            return null;
    817        }
    818
    819        /**
    820         *
    821         * @param node
    822         * @return the bean
    823         * @throws XMLParsingException
    824         * @throws XMLParsingException
    825         * @throws MalformedURLException
    826         */
    827        protected CitedResponsibleParty getResponsibleParty( Node node )
    828                                throws MalformedURLException, XMLParsingException {
    829
    830            if ( node != null ) {
    831                // gets individualNames
    832                String[] individualNames = XMLTools.getNodesAsStrings(
    833                                                                       node,
    834                                                                       "iso19115:CI_ResponsibleParty/iso19115:individualName/text()",
    835                                                                       nsContext );
    836
    837                // gets organisationNames
    838                String[] organisationNames = XMLTools.getNodesAsStrings(
    839                                                                         node,
    840                                                                         "iso19115:CI_ResponsibleParty/iso19115:organisationName/text()",
    841                                                                         nsContext );
    842
    843                // gets positionNames
    844                String[] positionNames = XMLTools.getNodesAsStrings(
    845                                                                     node,
    846                                                                     "iso19115:CI_ResponsibleParty/iso19115:positionName/text()",
    847                                                                     nsContext );
    848
    849                // gets role_CodeList
    850                List<Node> role_CodeListList = XMLTools.getNodes(
    851                                                                  node,
    852                                                                  "iso19115:CI_ResponsibleParty/iso19115:role/iso19115:CI_RoleCode_CodeList",
    853                                                                  nsContext );
    854                ArrayList<RoleCode> role_CodeList = new ArrayList<RoleCode>( role_CodeListList.size() );
    855                for ( int i = 0; i < role_CodeListList.size(); i++ ) {
    856                    role_CodeList.add( new RoleCode( XMLTools.getRequiredNodeAsString( role_CodeListList.get( i ),
    857                                                                                       "text()", nsContext ) ) );
    858                }
    859
    860                // gets contactInfo
    861                List<Node> contactInfoList = XMLTools.getNodes( node, "iso19115:CI_ResponsibleParty/iso19115:contactInfo",
    862                                                                nsContext );
    863                ArrayList<ContactInfo> contactInfo = new ArrayList<ContactInfo>( contactInfoList.size() );
    864                for ( int i = 0; i < contactInfoList.size(); i++ ) {
    865                    contactInfo.add( getContactInfo( contactInfoList.get( i ) ) );
    866                }
    867
    868                return new CitedResponsibleParty( contactInfo.toArray( new ContactInfo[contactInfo.size()] ),
    869                                                  individualNames, organisationNames, positionNames,
    870                                                  role_CodeList.toArray( new RoleCode[role_CodeList.size()] ) );
    871            }
    872            return null;
    873        }
    874    }