1 /*
   2  * Copyright (c) 2005, 2013, 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 entity, 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