1 /*

     2  * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.

     3  */

     4 

     5 /*

     6  * Copyright 2005 The Apache Software Foundation.

     7  *

     8  * Licensed under the Apache License, Version 2.0 (the "License");

     9  * you may not use this file except in compliance with the License.

    10  * You may obtain a copy of the License at

    11  *

    12  *      http://www.apache.org/licenses/LICENSE-2.0

    13  *

    14  * Unless required by applicable law or agreed to in writing, software

    15  * distributed under the License is distributed on an "AS IS" BASIS,

    16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    17  * See the License for the specific language governing permissions and

    18  * limitations under the License.

    19  */

    20 

    21 package com.sun.xml.internal.stream;

    22 

    23 import java.io.InputStream;

    24 import java.io.Reader;

    25 import java.io.IOException;

    26 

    27 import com.sun.xml.internal.stream.util.BufferAllocator;

    28 import com.sun.xml.internal.stream.util.ThreadLocalBufferAllocator;

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

    30 

    31 /**

    32  * Entity information.

    33  *

    34  * @author

    35  */

    36 public abstract class Entity {

    37 

    38     //

    39     // Data

    40     //

    41 

    42     //xxx why dont we declare the type of entities, like assign integer for external/ internal etc..

    43 

    44     /** Entity name. */

    45     public String name;

    46 

    47     // whether this entity's declaration was found in the internal

    48     // or external subset

    49     public boolean inExternalSubset;

    50 

    51     //

    52     // Constructors

    53     //

    54 

    55     /** Default constructor. */

    56     public Entity() {

    57         clear();

    58     } // <init>()

    59 

    60     /** Constructs an entity. */

    61     public Entity(String name, boolean inExternalSubset) {

    62         this.name = name;

    63         this.inExternalSubset = inExternalSubset;

    64     } // <init>(String)

    65 

    66     //

    67     // Public methods

    68     //

    69 

    70     /** Returns true if this entity was declared in the external subset. */

    71     public boolean isEntityDeclInExternalSubset() {

    72         return inExternalSubset;

    73     }

    74 

    75     /** Returns true if this is an external entity. */

    76     public abstract boolean isExternal();

    77 

    78     /** Returns true if this is an unparsed entity. */

    79     public abstract boolean isUnparsed();

    80 

    81     /** Clears the entity. */

    82     public void clear() {

    83         name = null;

    84         inExternalSubset = false;

    85     } // clear()

    86 

    87     /** Sets the values of the entity. */

    88     public void setValues(Entity entity) {

    89         name = entity.name;

    90         inExternalSubset = entity.inExternalSubset;

    91     } // setValues(Entity)

    92 

    93 

    94     /**

    95      * Internal entity.

    96      *

    97      * @author nb131165

    98      */

    99     public static class InternalEntity

   100             extends Entity {

   101 

   102         //

   103         // Data

   104         //

   105 

   106         /** Text value of entity. */

   107         public String text;

   108 

   109         //

   110         // Constructors

   111         //

   112 

   113         /** Default constructor. */

   114         public InternalEntity() {

   115             clear();

   116         } // <init>()

   117 

   118         /** Constructs an internal entity. */

   119         public InternalEntity(String name, String text, boolean inExternalSubset) {

   120             super(name,inExternalSubset);

   121             this.text = text;

   122         } // <init>(String,String)

   123 

   124         //

   125         // Entity methods

   126         //

   127 

   128         /** Returns true if this is an external entity. */

   129         public final boolean isExternal() {

   130             return false;

   131         } // isExternal():boolean

   132 

   133         /** Returns true if this is an unparsed entity. */

   134         public final boolean isUnparsed() {

   135             return false;

   136         } // isUnparsed():boolean

   137 

   138         /** Clears the entity. */

   139         public void clear() {

   140             super.clear();

   141             text = null;

   142         } // clear()

   143 

   144         /** Sets the values of the entity. */

   145         public void setValues(Entity entity) {

   146             super.setValues(entity);

   147             text = null;

   148         } // setValues(Entity)

   149 

   150         /** Sets the values of the entity. */

   151         public void setValues(InternalEntity entity) {

   152             super.setValues(entity);

   153             text = entity.text;

   154         } // setValues(InternalEntity)

   155 

   156     } // class InternalEntity

   157 

   158     /**

   159      * External entity.

   160      *

   161      * @author nb131165

   162      */

   163     public  static class ExternalEntity

   164             extends Entity {

   165 

   166         //

   167         // Data

   168         //

   169 

   170         /** container for all relevant entity location information. */

   171         public XMLResourceIdentifier entityLocation;

   172 

   173         /** Notation name for unparsed entity. */

   174         public String notation;

   175 

   176         //

   177         // Constructors

   178         //

   179 

   180         /** Default constructor. */

   181         public ExternalEntity() {

   182             clear();

   183         } // <init>()

   184 

   185         /** Constructs an internal entity. */

   186         public ExternalEntity(String name, XMLResourceIdentifier entityLocation,

   187                 String notation, boolean inExternalSubset) {

   188             super(name,inExternalSubset);

   189             this.entityLocation = entityLocation;

   190             this.notation = notation;

   191         } // <init>(String,XMLResourceIdentifier, String)

   192 

   193         //

   194         // Entity methods

   195         //

   196 

   197         /** Returns true if this is an external entity. */

   198         public final boolean isExternal() {

   199             return true;

   200         } // isExternal():boolean

   201 

   202         /** Returns true if this is an unparsed entity. */

   203         public final boolean isUnparsed() {

   204             return notation != null;

   205         } // isUnparsed():boolean

   206 

   207         /** Clears the entity. */

   208         public void clear() {

   209             super.clear();

   210             entityLocation = null;

   211             notation = null;

   212         } // clear()

   213 

   214         /** Sets the values of the entity. */

   215         public void setValues(Entity entity) {

   216             super.setValues(entity);

   217             entityLocation = null;

   218             notation = null;

   219         } // setValues(Entity)

   220 

   221         /** Sets the values of the entity. */

   222         public void setValues(ExternalEntity entity) {

   223             super.setValues(entity);

   224             entityLocation = entity.entityLocation;

   225             notation = entity.notation;

   226         } // setValues(ExternalEntity)

   227 

   228     } // class ExternalEntity

   229 

   230     /**

   231      * Entity state.

   232      *

   233      * @author nb131165

   234      */

   235     public static class ScannedEntity

   236             extends Entity {

   237 

   238 

   239         /** Default buffer size (4096). */

   240         public static final int DEFAULT_BUFFER_SIZE = 8192;

   241         //4096;

   242 

   243         /**

   244          * Buffer size. We get this value from a property. The default size

   245          * is used if the input buffer size property is not specified.

   246          * REVISIT: do we need a property for internal entity buffer size?

   247          */

   248         public int fBufferSize = DEFAULT_BUFFER_SIZE;

   249 

   250         /** Default buffer size before we've finished with the XMLDecl:  */

   251         public static final int DEFAULT_XMLDECL_BUFFER_SIZE = 28;

   252 

   253         /** Default internal entity buffer size (1024). */

   254         public static final int DEFAULT_INTERNAL_BUFFER_SIZE = 1024;

   255 

   256         //

   257         // Data

   258         //

   259 

   260         // i/o

   261 

   262         /** XXX let these field remain public right now, though we have defined methods for them.

   263          * Input stream. */

   264         public InputStream stream;

   265 

   266         /** XXX let these field remain public right now, though we have defined methods for them.

   267          * Reader. */

   268         public Reader reader;

   269 

   270         // locator information

   271 

   272         /** entity location information */

   273         public XMLResourceIdentifier entityLocation;

   274 

   275         // encoding

   276 

   277         /** Auto-detected encoding. */

   278         public String encoding;

   279 

   280         // status

   281 

   282         /** True if in a literal.  */

   283         public boolean literal;

   284 

   285         // whether this is an external or internal scanned entity

   286         public boolean isExternal;

   287 

   288         //each 'external' parsed entity may have xml/text declaration containing version information

   289         public String  version ;

   290 

   291         // buffer

   292 

   293         /** Character buffer. */

   294         public char[] ch = null;

   295 

   296         /** Position in character buffer at any point of time. */

   297         public int position;

   298 

   299         /** Count of characters present in buffer. */

   300         public int count;

   301 

   302         /** Line number. */

   303         public int lineNumber = 1;

   304 

   305         /** Column number. */

   306         public int columnNumber = 1;

   307 

   308         /** Encoding has been set externally for eg: using DOMInput*/

   309         boolean declaredEncoding = false;

   310 

   311         // status

   312 

   313         /**

   314          * Encoding has been set externally, for example

   315          * using a SAX InputSource or a DOM LSInput.

   316          */

   317         boolean externallySpecifiedEncoding = false;

   318 

   319         /** XML version. **/

   320         public String xmlVersion = "1.0";

   321 

   322         /** This variable is used to calculate the current position in the XML stream.

   323          * Note that fCurrentEntity.position maintains the position relative to

   324          * the buffer.

   325          *  At any point of time absolute position in the XML stream can be calculated

   326          *  as fTotalCountTillLastLoad + fCurrentEntity.position

   327          */

   328         public int fTotalCountTillLastLoad ;

   329 

   330         /** This variable stores the number of characters read during the load()

   331          * operation. It is used to calculate fTotalCountTillLastLoad

   332          */

   333         public  int fLastCount ;

   334 

   335         /** Base character offset for computing absolute character offset. */

   336         public int baseCharOffset;

   337 

   338         /** Start position in character buffer. */

   339         public int startPosition;

   340 

   341         // to allow the reader/inputStream to behave efficiently:

   342         public boolean mayReadChunks;

   343 

   344         // to know that prolog is read

   345         public boolean xmlDeclChunkRead = false;

   346 

   347         /** returns the name of the current encoding

   348          *  @return current encoding name

   349          */

   350         public String getEncodingName(){

   351             return encoding ;

   352         }

   353 

   354         /**each 'external' parsed entity may have xml/text declaration containing version information

   355          * @return String version of the enity, for an internal entity version would be null

   356          */

   357         public String getEntityVersion(){

   358             return version ;

   359         }

   360 

   361         /** each 'external' parsed entity may have xml/text declaration containing version information

   362          * @param String version of the external parsed entity

   363          */

   364         public void setEntityVersion(String version){

   365             this.version = version ;

   366         }

   367 

   368         /**  Returns the java.io.Reader associated with this entity.Readers are used

   369          * to read from the file. Readers wrap any particular  InputStream that was

   370          * used to open the entity.

   371          * @return java.io.Reader Reader associated with this entity

   372          */

   373         public Reader getEntityReader(){

   374             return reader;

   375         }

   376 

   377 

   378         /** if entity was opened using the stream, return the associated inputstream

   379          * with this entity

   380          *@return java.io.InputStream InputStream associated with this entity

   381          */

   382         public InputStream getEntityInputStream(){

   383             return stream;

   384         }

   385 

   386         //

   387         // Constructors

   388         //

   389 

   390         /** Constructs a scanned entity. */

   391         public ScannedEntity(String name,

   392                 XMLResourceIdentifier entityLocation,

   393                 InputStream stream, Reader reader,

   394                 String encoding, boolean literal, boolean mayReadChunks, boolean isExternal) {

   395             this.name = name ;

   396             this.entityLocation = entityLocation;

   397             this.stream = stream;

   398             this.reader = reader;

   399             this.encoding = encoding;

   400             this.literal = literal;

   401             this.mayReadChunks = mayReadChunks;

   402             this.isExternal = isExternal;

   403             final int size = isExternal ? fBufferSize : DEFAULT_INTERNAL_BUFFER_SIZE;

   404             BufferAllocator ba = ThreadLocalBufferAllocator.getBufferAllocator();

   405             ch = ba.getCharBuffer(size);

   406             if (ch == null) {

   407                 this.ch = new char[size];

   408             }

   409         } // <init>(StringXMLResourceIdentifier,InputStream,Reader,String,boolean, boolean)

   410 

   411         /**

   412          * Release any resources associated with this entity.

   413          */

   414         public void close() throws IOException {

   415             BufferAllocator ba = ThreadLocalBufferAllocator.getBufferAllocator();

   416             ba.returnCharBuffer(ch);

   417             ch = null;

   418             reader.close();

   419         }

   420 

   421         //

   422         // Entity methods

   423         //

   424 

   425         /** Returns whether the encoding of this entity was externally specified. **/

   426         public boolean isEncodingExternallySpecified() {

   427             return externallySpecifiedEncoding;

   428         }

   429 

   430         /** Sets whether the encoding of this entity was externally specified. **/

   431         public void setEncodingExternallySpecified(boolean value) {

   432             externallySpecifiedEncoding = value;

   433         }

   434 

   435         public boolean isDeclaredEncoding() {

   436             return declaredEncoding;

   437         }

   438 

   439         public void setDeclaredEncoding(boolean value) {

   440             declaredEncoding = value;

   441         }

   442 

   443         /** Returns true if this is an external entity. */

   444         public final boolean isExternal() {

   445             return isExternal;

   446         } // isExternal():boolean

   447 

   448         /** Returns true if this is an unparsed entity. */

   449         public final boolean isUnparsed() {

   450             return false;

   451         } // isUnparsed():boolean

   452 

   453         //

   454         // Object methods

   455         //

   456 

   457         /** Returns a string representation of this object. */

   458         public String toString() {

   459 

   460             StringBuffer str = new StringBuffer();

   461             str.append("name=\""+name+'"');

   462             str.append(",ch="+ new String(ch));

   463             str.append(",position="+position);

   464             str.append(",count="+count);

   465             return str.toString();

   466 

   467         } // toString():String

   468 

   469     } // class ScannedEntity

   470 

   471 } // class Entity