<?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE owl [
  <!ENTITY dc "http://purl.org/dc/elements/1.1/">
  <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">
  <!ENTITY policyContainmentTest "http://www.mindswap.org/dav/ontologies/policyContainmentTest.owl#">
  <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <!ENTITY owl "http://www.w3.org/2002/07/owl#">
  <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#">
  ]>
  
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"
    xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
    xmlns:wsse="http://schemas.xmlsoap.org/ws/2004/09/wsse"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    >
    
    <xsl:output method="xml"  indent="yes" cdata-section-elements="rdfs:comment "/>

    

    <xsl:template match="wsp:Policy/wsp:ExactlyOne">
      
        
        <xsl:variable name = "numVar">0</xsl:variable> 
        
        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
          <owl:Ontology rdf:about="http://www.mindswap.org/dav/ontologies/example.owl"> 
              <owl:imports rdf:resource="http://www.mindswap.org/dav/ontologies/Policy/WS-PolicyAssertion.owl"/>
          </owl:Ontology>
            
            <xsl:element name="owl:Class">
                <xsl:attribute name="rdf:about">http://www.mindswap.org/dav/ontologies/example.owl#ExamplePolicy</xsl:attribute>
        <xsl:element name="owl:equivalentClass">
            <xsl:element name="owl:Class">
        <xsl:element name="owl:intersectionOf"   >
            <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>
            <xsl:element name="owl:Class">
            
                <xsl:element name="owl:unionOf"> 
                    <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>
  
                <xsl:for-each select="wsp:All">
                    
                    <xsl:variable name = "pos" ><xsl:value-of select="count(preceding-sibling::*)"/></xsl:variable> 
                    
                    <xsl:element name="owl:Class">
                        <xsl:element name="owl:intersectionOf">
                            <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>
                            <xsl:for-each select="*">
                                    <!-- print out all of the assertions inside -->
                               <xsl:call-template name="classOnly">
                                   <xsl:with-param name="num"> <xsl:value-of select="$pos*10 + count(preceding-sibling::*)"/> </xsl:with-param>
                               </xsl:call-template>                                                                

                            </xsl:for-each>

                        </xsl:element>
                    </xsl:element> <!-- owl:Class -->
                </xsl:for-each>
                        
            </xsl:element> <!-- owl:unionOf -->
             </xsl:element> <!-- owl:Class -->
                <xsl:element name="owl:Class">
            <xsl:element name="owl:complementOf">
                <xsl:element name="owl:Class">
                <xsl:element name="owl:unionOf">
                    <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>
                <!-- pairwise intersections here -->
                    <xsl:for-each select="wsp:All">                                
                        
                        <xsl:if test = "not(position()=last())" > <!-- this works ok -->
                            
                            <xsl:variable name = "pos" ><xsl:value-of select="count(preceding-sibling::*)"/></xsl:variable> 
                              
                                <xsl:for-each select="/wsp:Policy/wsp:ExactlyOne/wsp:All">                                                    
                                    <xsl:if test="count(preceding-sibling::*) &gt; $pos">
                                         
                                        <xsl:element name="owl:Class">
                                            <xsl:element name="owl:intersectionOf">
                                                <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>
                                                 <!-- print the current one -->
                                                    <xsl:for-each select="/wsp:Policy/wsp:ExactlyOne/wsp:All[count(preceding-sibling::*)=$pos]">
                                                        <!-- print out the assertions inside -->                                                        
                                                        
                                                        <xsl:for-each select="*">                                                 
                                                        <xsl:call-template name="classOnly">
                                                            <xsl:with-param name="num"> <xsl:value-of select="$pos*10 + count(preceding-sibling::*)"/> </xsl:with-param>
                                                        </xsl:call-template>
                                                        </xsl:for-each>
                                                    </xsl:for-each>
                                                <!-- print all alternatives after the current one
                                                  be careful if there are multiple assertions in an alternative! -->
                                                <xsl:variable name = "prevAll" ><xsl:value-of select="count(preceding-sibling::*)"/></xsl:variable> 
                                                
                                                <xsl:for-each select="*">
                                                    <xsl:call-template name="classOnly">
                                                        <xsl:with-param name="num"> <xsl:value-of select=" $prevAll*10 + count(preceding-sibling::*)"/> </xsl:with-param>
                                                    </xsl:call-template>
                                                </xsl:for-each> 
                                                
                                            </xsl:element> 
                                            </xsl:element>
                                    </xsl:if>
                                </xsl:for-each> 
                        </xsl:if>
                    </xsl:for-each>
                </xsl:element>
                </xsl:element> 
            </xsl:element>
                </xsl:element><!-- owl:Class -->            
        </xsl:element> <!-- owl:intersectionOf -->
        </xsl:element>       
        </xsl:element> <!-- /owl:equivalentClass -->
            </xsl:element> <!-- owl:Class -->

            <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/example.owl#errorType">
            </owl:Class>
            <owl:DatatypeProperty rdf:about="http://www.mindswap.org/dav/ontologies/example.owl#hasAssertion">
                <rdfs:domain>    <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/example.owl#errorType">
                </owl:Class>
            </rdfs:domain>
              <rdfs:range>    <rdfs:Datatype rdf:about="&xsd;string"/>
              </rdfs:range>
            </owl:DatatypeProperty>
            
            
            

            <xsl:for-each select="/wsp:Policy/wsp:ExactlyOne/wsp:All">
                <xsl:variable name = "pos" ><xsl:value-of select="count(preceding-sibling::*)"/></xsl:variable> 
                
                    
                    <xsl:for-each select="*">
                        <!-- print out all of the assertions inside -->
                        <xsl:call-template name="assertion">
                            <xsl:with-param name="num"> <xsl:value-of select="$pos*10 + count(preceding-sibling::*)"/> </xsl:with-param>
                        </xsl:call-template>                                                                
                        
                    </xsl:for-each>
            </xsl:for-each>
            
            
            <!-- print out al of the element classes -->
            <xsl:for-each select="/wsp:Policy/wsp:ExactlyOne/wsp:All">
                <xsl:variable name = "pos" ><xsl:value-of select="count(preceding-sibling::*)"/></xsl:variable>
                
                <xsl:for-each select="*">                    
                    <xsl:call-template name="printElementClassDescription">
                        <xsl:with-param name="num"> <xsl:value-of select="$pos*10 + count(preceding-sibling::*)"/> </xsl:with-param>
                    </xsl:call-template>
                    
                </xsl:for-each>
            </xsl:for-each>
            
        </rdf:RDF>
    </xsl:template>

    
    <xsl:template name="classOnly">
        <xsl:param name="num">0</xsl:param>        
        <owl:Class>
            <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#policyClass',$num)"/></xsl:attribute>                                  
        </owl:Class>      
    </xsl:template>
    
    <xsl:template name="getElementClassName">
        <xsl:param name="num">0</xsl:param>               
        <xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#elementClass',$num)"/>                                          
    </xsl:template>
    

        
    <xsl:template name="assertion">
        <xsl:param name="num">0</xsl:param>
        <!-- translate the policy assertions here -->
        <!-- other templates can be invoked from here -->
        <xsl:choose>
            <xsl:when test="name()='wsse:Integrity'"> 
                <owl:Class>
                    <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#policyClass',$num)"/></xsl:attribute>                   
                    <xsl:choose>
                        <xsl:when test="count(descendant::*) &gt; 0">
                            <xsl:element name="owl:intersectionOf"   >
                                <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>                        
                                <xsl:choose>
                                    <!-- todo: handle allvaluesfrom restrictions -->
                                    <xsl:when test="count(descendant::*) &gt; 0">
                                    <owl:Class>
                                        <owl:intersectionOf rdf:parseType="Collection">
                                            <owl:Restriction>
                                                <owl:onProperty rdf:resource="#hasAlgorithm" />
                                            <owl:allValuesFrom>                                           
                                                <!-- add attribute here -->
                                                <xsl:attribute name="rdf:resource">
                                                    <xsl:call-template name="getElementClassName">
                                                        <xsl:with-param name="num"> <xsl:value-of select="$num"/></xsl:with-param>
                                                    </xsl:call-template>
                                                    
                                                </xsl:attribute>                        
                                             </owl:allValuesFrom>
                                    </owl:Restriction>
                                    </owl:intersectionOf>
                                    </owl:Class>
                                    </xsl:when>              
                                </xsl:choose>                            
                            </xsl:element>
                        </xsl:when>
                    </xsl:choose> 
                    <rdfs:subClassOf>
                        <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/Policy/WS-PolicyAssertion.owl#Integrity">
                        </owl:Class>
                    </rdfs:subClassOf>                     
                </owl:Class>
            </xsl:when>
            
            <xsl:when test="name()='wsse:SecurityToken'"> 
                <owl:Class>
                    <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#policyClass',$num)"/></xsl:attribute>                   
                    <xsl:choose>
                        <xsl:when test="count(descendant::*) &gt; 0">
                            <xsl:element name="owl:intersectionOf"   >
                                <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>                        
                                <xsl:choose>
                                    <!-- todo: handle allvaluesfrom restrictions -->
                                    <xsl:when test="count(descendant::*) &gt; 0">
                                        <owl:Class>
                                            <owl:intersectionOf rdf:parseType="Collection">
                                                <owl:Restriction>
                                                    <owl:onProperty rdf:resource="#hasSecurityToken" />
                                                    <owl:allValuesFrom>                                           
                                                        <!-- add attribute here -->
                                                        <xsl:attribute name="rdf:resource">
                                                            <xsl:call-template name="getElementClassName">
                                                                <xsl:with-param name="num"> <xsl:value-of select="$num"/></xsl:with-param>
                                                            </xsl:call-template>                                                            
                                                        </xsl:attribute>                        
                                                    </owl:allValuesFrom>
                                                </owl:Restriction>
                                            </owl:intersectionOf>
                                        </owl:Class>
                                    </xsl:when>              
                                </xsl:choose>                            
                            </xsl:element>
                        </xsl:when>
                    </xsl:choose> 
                    <rdfs:subClassOf>
                        <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/Policy/WS-PolicyAssertion.owl#SecurityToken">
                        </owl:Class>
                    </rdfs:subClassOf>                     
                </owl:Class>
            </xsl:when>
            
            
            <xsl:when  test="name()='wsp:Language'">
                <owl:Class>
                    <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#policyClass',$num)"/></xsl:attribute>                   
                        <xsl:choose>
                            <xsl:when test="@Language or @Preference or count(descendant::*) &gt; 0">
                                <xsl:element name="owl:intersectionOf"   >
                                    <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>                        
                                <xsl:choose>
                                   <!-- todo: handle allvaluesfrom restrictions
                                    <xsl:when test="count(descendant::*) &gt; 0">
                                        <owl:Class>
                                            <owl:intersectionOf rdf:parseType="Collection">
                                                <owl:Restriction>
                                                    <owl:onProperty rdf:resource="#Test" />
                                                    <owl:allValuesFrom rdf:resource="<xsl:value-of select="@Language" />
                                                </owl:Restriction>
                                            </owl:intersectionOf>
                                        </owl:Class>
                                    </xsl:when>
                                    -->
                                    <xsl:when test="@Language">                                        
                                            <owl:Class>
                                                <owl:intersectionOf rdf:parseType="Collection">
                                                    <owl:Restriction>
                                                        <owl:onProperty rdf:resource="#hasLanguage" />
                                                        <owl:hasValue rdf:datatype="&xsd;string" xml:lang="EN"> <xsl:value-of select="@Language" /></owl:hasValue>
                                                    </owl:Restriction>
                                                </owl:intersectionOf>
                                            </owl:Class>
                                    </xsl:when> 
                                </xsl:choose>
                        <xsl:choose>
                        <xsl:when test="@Preference">                            
                                <owl:Class>
                                    <owl:intersectionOf rdf:parseType="Collection">
                                        <owl:Restriction>
                                            <owl:onProperty rdf:resource="#hasPreference" />
                                            <owl:hasValue rdf:datatype="&xsd;int" xml:lang="EN"> <xsl:value-of select="@Preference" /></owl:hasValue>
                                        </owl:Restriction>
                                    </owl:intersectionOf>
                                </owl:Class>                            
                        </xsl:when> 
                    </xsl:choose>                    
                            </xsl:element>
                        </xsl:when>
                    </xsl:choose> 
                    <rdfs:subClassOf>
                        <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/Policy/WS-PolicyAssertion.owl#Language">
                        </owl:Class>
                    </rdfs:subClassOf>                     
                </owl:Class>
            </xsl:when> 
            
            <xsl:when  test="name()='wsp:TextEncoding'">                
                <owl:Class>
                    <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#policyClass',$num)"/></xsl:attribute>
                    <xsl:choose>
                        <xsl:when test="@Encoding or @Preference">
                            <xsl:element name="owl:intersectionOf"   >
                                <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>                        
                                <xsl:choose>
                                    <xsl:when test="@Encoding">                                        
                                            <owl:Class>
                                                <owl:intersectionOf rdf:parseType="Collection">
                                                    <owl:Restriction>
                                                        <owl:onProperty rdf:resource="#hasEncoding" />
                                                        <owl:hasValue rdf:datatype="&xsd;string" xml:lang="EN"> <xsl:value-of select="@Encoding" /></owl:hasValue>
                                                    </owl:Restriction>
                                                </owl:intersectionOf>
                                            </owl:Class>                                        
                                    </xsl:when> 
                                </xsl:choose>
                                <xsl:choose>
                                    <xsl:when test="@Preference">                                        
                                            <owl:Class>
                                                <owl:intersectionOf rdf:parseType="Collection">
                                                    <owl:Restriction>
                                                        <owl:onProperty rdf:resource="#hasPreference" />
                                                        <owl:hasValue rdf:datatype="&xsd;int" xml:lang="EN"> <xsl:value-of select="@Preference" /></owl:hasValue>
                                                    </owl:Restriction>
                                                </owl:intersectionOf>
                                            </owl:Class>                                        
                                    </xsl:when> 
                                </xsl:choose>                    
                            </xsl:element>
                        </xsl:when>
                    </xsl:choose> 
                    <rdfs:subClassOf>
                        <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/Policy/WS-PolicyAssertion.owl#TextEncoding">
                        </owl:Class>
                    </rdfs:subClassOf>                     
                </owl:Class>
                
                
            </xsl:when>            
            <xsl:otherwise>
                <!-- unrecognized policy assertion -  display error message -->                
               <owl:Class>
                   <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#policyClass',$num)"/></xsl:attribute>
                   
                   <rdfs:comment>  <!-- need to put text in CDATA section -->
                           <xsl:call-template name="write-starttag"/>
                           <xsl:apply-templates/>
                           <xsl:call-template name="write-endtag"/>       
                   </rdfs:comment>            
                    <rdfs:subClassOf>
                        <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/example.owl#errorType">
                        </owl:Class>
                    </rdfs:subClassOf> 
                </owl:Class>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    
    
    
    <xsl:template name="printElementClassDescription">
        <xsl:param name="num">0</xsl:param>
        <!-- translate the policy assertions here -->
        <!-- other templates can be invoked from here -->
        <xsl:choose>
            <xsl:when test="name()='wsse:Integrity'">           
                    <xsl:choose>
                        <xsl:when test="count(descendant::*) &gt; 0">                            
                                <xsl:choose>
                                    <!-- todo: handle allvaluesfrom restrictions -->
                                    <xsl:when test="count(descendant::*) &gt; 0">
                                        <owl:Class>
                                            <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#elementClass',$num)"/></xsl:attribute> 
                                            <!-- has value restrictions for algorithm here -->
                                            <xsl:for-each select="wsse:Algorithm">
                                            <xsl:choose>                                                
                                                <xsl:when test="@Type">                                                    
                                                    <xsl:element name="owl:intersectionOf"   >
                                                        <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>                        
                                                        <xsl:choose>                                                         
                                                            <xsl:when test="@Type">                                        
                                                                <owl:Class>
                                                                    <owl:intersectionOf rdf:parseType="Collection">
                                                                        <owl:Restriction>
                                                                            <owl:onProperty rdf:resource="#hasType" />
                                                                            <owl:hasValue rdf:datatype="&xsd;string" xml:lang="EN"> <xsl:value-of select="@Type" /></owl:hasValue>
                                                                        </owl:Restriction>
                                                                    </owl:intersectionOf>
                                                                </owl:Class>
                                                            </xsl:when> 
                                                        </xsl:choose>
                                                        <xsl:choose>
                                                            <xsl:when test="@URI">                            
                                                                <owl:Class>
                                                                    <owl:intersectionOf rdf:parseType="Collection">
                                                                        <owl:Restriction>
                                                                            <owl:onProperty rdf:resource="#hasURI" />
                                                                            <owl:hasValue rdf:datatype="&xsd;int" xml:lang="EN"> <xsl:value-of select="@URI" /></owl:hasValue>
                                                                        </owl:Restriction>
                                                                    </owl:intersectionOf>
                                                                </owl:Class>                            
                                                            </xsl:when> 
                                                        </xsl:choose>                    
                                                    </xsl:element>
                                                </xsl:when>
                                            </xsl:choose> 
                                            </xsl:for-each>
         
                                            <rdfs:subClassOf>
                                                <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/Policy/WS-PolicyAssertion.owl#Algorithm">
                                                </owl:Class>
                                            </rdfs:subClassOf>              
                                          </owl:Class>
                                    </xsl:when>              
                                </xsl:choose>                                                        
                                                          
                        </xsl:when>
                    </xsl:choose>                    
            </xsl:when>
            
            
            <xsl:when test="name()='wsse:SecurityToken'">           
                <xsl:choose>
                    <xsl:when test="count(descendant::*) &gt; 0">                            
                        <xsl:choose>
                            <!-- todo: handle allvaluesfrom restrictions -->
                            <xsl:when test="count(descendant::*) &gt; 0">
                                <owl:Class>
                                    <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#elementClass',$num)"/></xsl:attribute> 
                                    <!-- has value restrictions for algorithm here -->
                                    <xsl:for-each select="wsse:TokenType">                                        
                                        <xsl:choose>                                                
                                            <xsl:when test="text()">                                                    
                                                <xsl:element name="owl:intersectionOf"   >
                                                    <xsl:attribute name="rdf:parseType">Collection</xsl:attribute>                        
                                                    <xsl:choose>                                                         
                                                        <xsl:when test="text()">                                        
                                                            <owl:Class>
                                                                <owl:intersectionOf rdf:parseType="Collection">
                                                                    <owl:Restriction>
                                                                        <owl:onProperty rdf:resource="#hasTokenType" />
                                                                        <owl:hasValue rdf:datatype="&xsd;string" xml:lang="EN"> <xsl:value-of select="text()" /></owl:hasValue>
                                                                    </owl:Restriction>
                                                                </owl:intersectionOf>
                                                            </owl:Class>
                                                        </xsl:when> 
                                                    </xsl:choose>                                                  
                                                </xsl:element>
                                            </xsl:when>
                                        </xsl:choose> 
                                    </xsl:for-each>
                                    
                                    <rdfs:subClassOf>
                                        <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/Policy/WS-PolicyAssertion.owl#SecurityToken">
                                        </owl:Class>
                                    </rdfs:subClassOf>              
                                </owl:Class>
                            </xsl:when>              
                        </xsl:choose>                                                        
                        
                    </xsl:when>
                </xsl:choose>                    
            </xsl:when>
            
            
            
            
          
            
             
            <xsl:otherwise>
                <!-- unrecognized policy assertion -  display error message -->                
                <owl:Class>
                    <xsl:attribute name="rdf:about"><xsl:value-of select="concat('http://www.mindswap.org/dav/ontologies/example.owl#policyClass',$num)"/></xsl:attribute>
                    
                    <rdfs:comment>  <!-- need to put text in CDATA section -->
                        <xsl:call-template name="write-starttag"/>
                        <xsl:apply-templates/>
                        <xsl:call-template name="write-endtag"/>       
                    </rdfs:comment>            
                    <rdfs:subClassOf>
                        <owl:Class rdf:about="http://www.mindswap.org/dav/ontologies/example.owl#errorType">
                        </owl:Class>
                    </rdfs:subClassOf> 
                </owl:Class>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    
    
    
    
            
    
    
    <xsl:template name="write-starttag">
        <xsl:text>&lt;</xsl:text>
        <xsl:value-of select="local-name()"/>
        <xsl:for-each select="@*">
            <xsl:call-template name="write-attribute"/>
        </xsl:for-each>
        <xsl:text>></xsl:text>
    </xsl:template>
    
    
    <xsl:template name="write-endtag">
        <xsl:text>&lt;/</xsl:text>
        <xsl:value-of select="local-name()"/>
        <xsl:text>></xsl:text>
    </xsl:template>
    
    
    <xsl:template name="write-attribute">
        <xsl:text> </xsl:text>
        <xsl:value-of select="local-name()"/>
        <xsl:text>="</xsl:text>
        <xsl:value-of select="."/>
        <xsl:text>"</xsl:text>
    </xsl:template>
    
</xsl:stylesheet>
