1. /*

  2.  * The Apache Software License, Version 1.1

  3.  *

  4.  *

  5.  * Copyright (c) 2000-2002 The Apache Software Foundation.  All rights 

  6.  * reserved.

  7.  *

  8.  * Redistribution and use in source and binary forms, with or without

  9.  * modification, are permitted provided that the following conditions

  10.  * are met:

  11.  *

  12.  * 1. Redistributions of source code must retain the above copyright

  13.  *    notice, this list of conditions and the following disclaimer. 

  14.  *

  15.  * 2. Redistributions in binary form must reproduce the above copyright

  16.  *    notice, this list of conditions and the following disclaimer in

  17.  *    the documentation and/or other materials provided with the

  18.  *    distribution.

  19.  *

  20.  * 3. The end-user documentation included with the redistribution,

  21.  *    if any, must include the following acknowledgment:  

  22.  *       "This product includes software developed by the

  23.  *        Apache Software Foundation (http://www.apache.org/)."

  24.  *    Alternately, this acknowledgment may appear in the software itself,

  25.  *    if and wherever such third-party acknowledgments normally appear.

  26.  *

  27.  * 4. The names "Xerces" and "Apache Software Foundation" must

  28.  *    not be used to endorse or promote products derived from this

  29.  *    software without prior written permission. For written 

  30.  *    permission, please contact apache@apache.org.

  31.  *

  32.  * 5. Products derived from this software may not be called "Apache",

  33.  *    nor may "Apache" appear in their name, without prior written

  34.  *    permission of the Apache Software Foundation.

  35.  *

  36.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

  37.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

  38.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  39.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

  42.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

  43.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

  44.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  45.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

  46.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  47.  * SUCH DAMAGE.

  48.  * ====================================================================

  49.  *

  50.  * This software consists of voluntary contributions made by many

  51.  * individuals on behalf of the Apache Software Foundation and was

  52.  * originally based on software copyright (c) 1999, International

  53.  * Business Machines, Inc., http://www.apache.org.  For more

  54.  * information on the Apache Software Foundation, please see

  55.  * <http://www.apache.org/>.

  56.  */

  57. 

  58. package com.sun.org.apache.xerces.internal.impl.dtd;

  59. 

  60. import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;

  61. import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;

  62. import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;

  63. 

  64. import com.sun.org.apache.xerces.internal.util.XMLResourceIdentifierImpl;

  65. import java.util.Vector;

  66. 

  67. /*

  68.  * All information specific to dTD grammars.  

  69.  * 

  70.  * @author Neil Graham, IBM

  71.  * @version $Id: XMLDTDDescription.java,v 1.7 2003/01/07 22:46:53 sandygao Exp $

  72.  */

  73. 

  74. public class XMLDTDDescription extends XMLResourceIdentifierImpl

  75.         implements com.sun.org.apache.xerces.internal.xni.grammars.XMLDTDDescription {

  76. 

  77.     // Data

  78. 

  79.     // pieces of information needed to make this usable as a Grammar key

  80.     // if we know the root of this grammar, here's its name:

  81.     protected String fRootName = null;

  82. 

  83.     // if we don't know the root name, this stores all elements that

  84.     // could serve; fPossibleRoots and fRootName cannot both be non-null

  85.     protected Vector fPossibleRoots = null;

  86. 

  87.     // Constructors:

  88.     public XMLDTDDescription(XMLResourceIdentifier id, String rootName) {

  89.         this.setValues(id.getPublicId(), id.getLiteralSystemId(),

  90.                 id.getBaseSystemId(), id.getExpandedSystemId());

  91.         this.fRootName = rootName;

  92.         this.fPossibleRoots = null;

  93.     } // init(XMLResourceIdentifier, String)

  94. 

  95.     public XMLDTDDescription(String publicId, String literalId,

  96.                 String baseId, String expandedId, String rootName) {

  97.         this.setValues(publicId, literalId, baseId, expandedId);

  98.         this.fRootName = rootName;

  99.         this.fPossibleRoots = null;

  100.     } // init(String, String, String, String, String)

  101. 

  102.     public XMLDTDDescription(XMLInputSource source) {

  103.         this.setValues(source.getPublicId(), null,

  104.                 source.getBaseSystemId(), source.getSystemId());

  105.         this.fRootName = null;

  106.         this.fPossibleRoots = null;

  107.     } // init(XMLInputSource)

  108. 

  109.     // XMLGrammarDescription methods

  110. 

  111.     public String getGrammarType () {

  112.         return XMLGrammarDescription.XML_DTD;

  113.     } // getGrammarType():  String

  114. 

  115.     // return the root name of this DTD

  116.     // returns null if root name is unknown

  117.     public String getRootName() {

  118.         return fRootName;

  119.     } // getRootName():  String

  120. 

  121.     // set the root name

  122.     public void setRootName(String rootName) {

  123.         fRootName = rootName;

  124.         fPossibleRoots = null;

  125.     }

  126. 

  127.     // set possible roots

  128.     public void setPossibleRoots(Vector possibleRoots) {

  129.         fPossibleRoots = possibleRoots;

  130.     } 

  131. 

  132.     /**

  133.      * Compares this grammar with the given grammar. Currently, we compare 

  134.      * as follows:

  135.      * - if grammar type not equal return false immediately

  136.      * - try and find a common root name:

  137.      *    - if both have roots, use them

  138.      *    - else if one has a root, examine other's possible root's for a match;

  139.      *    - else try all combinations

  140.      *  - test fExpandedSystemId and fPublicId as above

  141.      * 

  142.      * @param desc The description of the grammar to be compared with

  143.      * @return     True if they are equal, else false

  144.      */

  145.     public boolean equals(Object desc) {

  146.         if(!(desc instanceof XMLGrammarDescription)) return false;

  147.     	if (!getGrammarType().equals(((XMLGrammarDescription)desc).getGrammarType())) {

  148.     	    return false;

  149.     	}

  150.         // assume it's a DTDDescription

  151.         XMLDTDDescription dtdDesc = (XMLDTDDescription)desc;

  152.         if(fRootName != null) {

  153.             if((dtdDesc.fRootName) != null && !dtdDesc.fRootName.equals(fRootName)) {

  154.                 return false;

  155.             } else if(dtdDesc.fPossibleRoots != null && !dtdDesc.fPossibleRoots.contains(fRootName)) {

  156.                 return false;

  157.             }

  158.         } else if(fPossibleRoots != null) {

  159.             if(dtdDesc.fRootName != null) {

  160.                 if(!fPossibleRoots.contains(dtdDesc.fRootName)) { 

  161.                     return false;

  162.                 }

  163.             } else if(dtdDesc.fPossibleRoots == null) {

  164.                 return false;

  165.             } else {

  166.                 boolean found = false;

  167.                 for(int i = 0; i<fPossibleRoots.size(); i++) {

  168.                     String root = (String)fPossibleRoots.elementAt(i);

  169.                     found = dtdDesc.fPossibleRoots.contains(root);

  170.                     if(found) break;

  171.                 }

  172.                 if(!found) return false;

  173.             }

  174.         }

  175.         // if we got this far we've got a root match... try other two fields,

  176.         // since so many different DTD's have roots in common:

  177.         if(fExpandedSystemId != null) {

  178.             if(!fExpandedSystemId.equals(dtdDesc.fExpandedSystemId)) 

  179.                 return false;

  180.         } 

  181.         else if(dtdDesc.fExpandedSystemId != null)

  182.             return false;

  183.         if(fPublicId != null) {

  184.             if(!fPublicId.equals(dtdDesc.fPublicId)) 

  185.                 return false;

  186.         } 

  187.         else if(dtdDesc.fPublicId != null)

  188.             return false;

  189.     	return true;

  190.     }

  191.     

  192.     /**

  193.      * Returns the hash code of this grammar

  194.      * Because our .equals method is so complex, we just return a very

  195.      * simple hash that might avoid calls to the equals method a bit...

  196.      * @return The hash code

  197.      */

  198.     public int hashCode() {

  199.         if(fExpandedSystemId != null)

  200.             return fExpandedSystemId.hashCode();

  201.         if(fPublicId != null)

  202.             return fPublicId.hashCode();

  203.         // give up; hope .equals can handle it:

  204.         return 0;

  205.     }

  206. } // class XMLDTDDescription

  207.