Application: gvSIG desktop » gvSIG data provider for GPE

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.xmlschema.prov.kxml.model;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.xmlpull.v1.XmlPullParserException;

import org.gvsig.xmlpull.lib.api.XmlPullLocator;

import org.gvsig.xmlpull.lib.api.stream.IXmlStreamReader;

import org.gvsig.xmlpull.lib.api.stream.XmlStreamException;

import org.gvsig.xmlschema.lib.api.XMLSchemaLocator;

import org.gvsig.xmlschema.lib.api.XMLSchemaManager;

import org.gvsig.xmlschema.lib.api.exceptions.SchemaWrittingException;

import org.gvsig.xmlschema.lib.api.som.IXSComplexTypeDefinition;

import org.gvsig.xmlschema.lib.api.som.IXSDocument;

import org.gvsig.xmlschema.lib.api.som.IXSElement;

import org.gvsig.xmlschema.lib.api.som.IXSElementDeclaration;

import org.gvsig.xmlschema.lib.api.som.IXSSchema;

import org.gvsig.xmlschema.lib.api.som.IXSTypeDefinition;

import org.gvsig.xmlschema.lib.api.utils.SchemaObjectsMapping;

import org.gvsig.xmlschema.lib.api.utils.SchemaTags;

import org.gvsig.xmlschema.prov.kxml.xsd.type.GMLTypes;

import org.gvsig.xmlschema.prov.kxml.xsd.type.XSDTypes;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class XSSchema implements IXSSchema{

    private String targetNameSpace = null;

    private String version = null;

    private Hashtable types = new Hashtable();

    private List elements = new ArrayList();

    private XMLSchemaManager schemaManager;

    public XSSchema(InputStream is) throws IOException {

        schemaManager = XMLSchemaLocator.getXMLSchemaManager();

        IXmlStreamReader xmlStreamReader = XmlPullLocator.getXMLManager().createStreamReader("text/xml", is);

        parse(xmlStreamReader);       

    }   

    /********************************************************************************

     *  FUNCTION PARSE(FILE,NAMESPACE) PARSING THE XML SCHEMA ".xsd"                *

     *                                                                              *

     *      -gml version                                                            *

     *      -elementFormDefault {qualified,non-qualified} (not implemented yet)     *

     *      -namespaces "xmlns" (nor implemented,only in gml file)                  *

     *      -targetNamespace (the name of this schema)                              *

     *      -imports (not implemented)                                              *  

     *      -features -> "elements"="types"                                         *

     *                                                                              *   

     * @param f (file ".xsd" to parse)                                              *

     * @param nameSpace (Schemas name)                                              *

     * @throws IOException                                                          *

     * @throws XmlPullParserException                                               *

     *                                                                              *

     ********************************************************************************/

    private void parse(IXmlStreamReader xmlStreamReader) throws IOException{

        int tag;

        while (xmlStreamReader.getEventType() != IXmlStreamReader.START_ELEMENT){

            xmlStreamReader.next();

            if (xmlStreamReader.getEventType() == IXmlStreamReader.END_DOCUMENT ) {

                return;

            }

        }

        parseHeader(xmlStreamReader);

        tag = xmlStreamReader.nextTag();

        while(tag != IXmlStreamReader.END_DOCUMENT)

        {

            switch(tag)

            {

            case IXmlStreamReader.START_ELEMENT:

                /************************

                 * Etiqueta <import>    *

                 ************************/

                //imports elements from other schemas (other schema  ".xsd" files)

                /****************************

                 * Etiqueta <complexType>   *

                 ****************************/

                if (SchemaTags.COMPLEX_TYPE.equals(xmlStreamReader.getName().getLocalPart())){                           

                    for (int i=0 ; i<xmlStreamReader.getAttributeCount() ; i++){

                        /********************

                         * Atributo <name>  *

                         ********************/

                        if (SchemaTags.NAME.equals(xmlStreamReader.getAttributeName(i).getLocalPart())){

                            // inserts a new complex type inside the namespace

                            XSComplexTypeDefinition complexTypeDefinition = 

                                new XSComplexTypeDefinition(this, null, xmlStreamReader.getAttributeValue(i), xmlStreamReader);

                            addType(complexTypeDefinition);                     

                        }

                    }

                }

                /****************************

                 * Etiqueta <simpleType>    *

                 ****************************/

                // SIMPLE TYPE elements like enumerations not implemented 

                else if (SchemaTags.SIMPLE_TYPE.equals(xmlStreamReader.getName().getLocalPart())){

                    parseSimpleType(xmlStreamReader);

                }

                /************************

                 * Etiqueta <element>   *

                 ************************/

                else if (SchemaTags.ELEMENT.equals(xmlStreamReader.getName().getLocalPart())){             

                    XSElement element = new XSElement(this, xmlStreamReader);

                    elements.add(element);                       

                }

                break;

            case IXmlStreamReader.END_ELEMENT:                            

                break;

                //Show the Text on the screen

            case IXmlStreamReader.CHARACTERS:

                break;

            }

            tag = xmlStreamReader.next();

        }

        //require(KXmlParser.END_DOCUMENT, null, null);

    }

    private void parseHeader(IXmlStreamReader xmlStreamReader) throws XmlStreamException {

        /************************

         * Etiqueta <schema>    *

         ************************/

        //Searching the init tag "schema"            

        //xmlStreamReader.require(KXmlParser.START_TAG, null, SchemaTags.SCHEMA_ROOT); 

        for (int i=0 ; i<xmlStreamReader.getAttributeCount() ; i++){

            //getting attributes and values

            String attName = xmlStreamReader.getAttributeName(i).getLocalPart();

            String attValue = xmlStreamReader.getAttributeValue(i);

            /********************************

             * Atributo <targetNamespace>   *

             ********************************/

            //Target Namespace (URI)

            //this is the namespace of all components in the schema

            //setTargetNamespace(); 

            if (SchemaTags.TARGET_NAMESPACE.equals(attName)){

                targetNameSpace = attValue;

            }

            /************************************

             * Atributo <elementFormDefault>    *

             ************************************/

            //Qualified--> Los elementos del espacio de nombres de destino deben cualificarse 

            //con el prefijo del espacio de nombres.

            //Unqualified--> No es necesario que los elementos del 

            //espacio de nombres de destino est?n cualificados con el prefijo del espacio de nombres.

            //(Espacion_de_Nombres:Elemento)

            //elementFormDefault(); 

            if (SchemaTags.ELEMENTFORMDEFAULT.equals(attName)){

            }

            /************************************

             * Atributo <attributeFormDefault>  *

             ************************************/

            //Lo mismo que el anterior pero con los atributos...

            //(Espacio_de_Nombres:Atributo)

            //attributeFormDefault();

            if (SchemaTags.ATTRIBUTEFORMDEFAULT.equals(attName)){

            }

            /************************

             * Atributo <Version>   *

             ************************/

            //Gets gml version to parse by the right parser.

            //getversion();

            if (SchemaTags.VERSION.equals(attName)){

                version = attValue;

            }

        }        

    }

    /****************************************************

     *  FUNCTION PARSE SIMPLE TYPE()                    *

     *                                                  *

     *  Parse simple types and its restrictions         *

     *                                                  *   

     ****************************************************/

    private void parseSimpleType(IXmlStreamReader xmlStreamReader) throws IOException{   

        int currentTag;

        boolean end = false;        

        currentTag = xmlStreamReader.getEventType();

        String typeName = null;

        String typeValue = null;

        for (int i=0 ; i<xmlStreamReader.getAttributeCount() ; i++){            

            if (SchemaTags.NAME.equals(xmlStreamReader.getName().getLocalPart())){     

                typeName = xmlStreamReader.getAttributeValue(i);

            }

        }

        while (!end){

            switch(currentTag){

            case IXmlStreamReader.START_ELEMENT:

                if (SchemaTags.RESTRICTION.equals(xmlStreamReader.getName().getLocalPart())){     

                    for (int i=0 ; i<xmlStreamReader.getAttributeCount() ; i++){

                        if (SchemaTags.BASE.equals(xmlStreamReader.getName().getLocalPart())){     

                            typeValue = xmlStreamReader.getAttributeValue(i);

                        }

                    }                   

                }   

                //Falta parsear los tipos enumerados

                break;

            case IXmlStreamReader.END_ELEMENT:

                if (SchemaTags.SIMPLE_TYPE.equals(xmlStreamReader.getName().getLocalPart())){     

                    end = true;

                }

                break;

            case IXmlStreamReader.CHARACTERS:                   

                break;

            }

            if (!end){

                currentTag = xmlStreamReader.next();

            }           

        }

        if ((typeName != null) && (typeValue != null)){            

            this.addType(new XSimpleTypeDefinition(this, typeName, typeValue));

        }

    }

    void addType(IXSTypeDefinition typeDefinition){

        types.put(typeDefinition.getTypeName().toUpperCase(), typeDefinition);

    }

    public IXSComplexTypeDefinition addComplexType(String name, String type,

        String contentType, String conteTypeRestriction) {

        // TODO Auto-generated method stub

        return null;

    }

    public IXSElementDeclaration addElement(String name, String type,

        String substitutionGroup) {

        // TODO Auto-generated method stub

        return null;

    }

    public IXSElementDeclaration addElement(String name, String type) {

        // TODO Auto-generated method stub

        return null;

    }

    public IXSDocument getDocument() {

        // TODO Auto-generated method stub

        return null;

    }

    public IXSElementDeclaration getElementDeclarationByName(

        String targetNamespace, String elementName) {

       Iterator it = elements.iterator();

       while (it.hasNext()){

           IXSElementDeclaration elementDeclaration = (IXSElementDeclaration)it.next();

           if (elementName.equals(elementDeclaration.getQName().getLocalPart())){

               return elementDeclaration;

           }

       }

        return null;

    }

    public Collection getElementDeclarations() {

        return elements;

    }

    public String getNamespacePrefix(String namespaceURI) {

        // TODO Auto-generated method stub

        return null;

    }

    public SchemaObjectsMapping getObjectsMapping() {

        // TODO Auto-generated method stub

        return null;

    }

    public String getTargetNamespace() {

        // TODO Auto-generated method stub

        return null;

    }

    public String getTargetNamespacePrefix() {

        // TODO Auto-generated method stub

        return null;

    }

    public IXSTypeDefinition getTypeByName(String targetNamespace,

        String typeName) {

        IXSTypeDefinition xmlType = (IXSTypeDefinition)types.get(typeName.toUpperCase());

        if (xmlType == null){

            xmlType = schemaManager.getTypeDefinition(typeName);

        }

        if (xmlType == null){            

            xmlType = getTypeWithOutNameSpace(typeName);            

        }

        return xmlType;     

    }

    /**

     * This method is used to solve some mistakes. It doesn't

     * consider the namespace

     * @param type

     * @return

     */

    private IXSTypeDefinition getTypeWithOutNameSpace(String typeName){

        Set keys = types.keySet();

        Iterator it = keys.iterator();

        String[] typeParts = typeName.split(":");

        String typeAux = typeName;

        if (typeParts.length > 1){

            typeAux = typeParts[1];

        }

        while(it.hasNext()){

            String key = (String)it.next();

            String[] parts = key.split(":");

            if (parts.length == 1){

                if (parts[0].compareTo(typeAux.toUpperCase())==0){

                    return (IXSTypeDefinition)types.get(key);

                }

            }else if (parts.length > 1){

                if (parts[parts.length-1].compareTo(typeAux.toUpperCase())==0){

                    return (IXSTypeDefinition)types.get(key);

                }

            }

        }

        return null;

    }

    public Collection getTypeDefinitions() {

        // TODO Auto-generated method stub

        return null;

    }

    public void write(OutputStream os) throws SchemaWrittingException {

        // TODO Auto-generated method stub

    }

}