View Javadoc
1   /*
2    * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  
26  package com.sun.xml.internal.stream.buffer;
27  
28  /**
29   * Base class for classes that creates {@link MutableXMLStreamBuffer}
30   * and from infoset in API-specific form.
31   */
32  public class AbstractCreator extends AbstractCreatorProcessor {
33  
34      protected MutableXMLStreamBuffer _buffer;
35  
36      public void setXMLStreamBuffer(MutableXMLStreamBuffer buffer) {
37          if (buffer == null) {
38              throw new NullPointerException("buffer cannot be null");
39          }
40          setBuffer(buffer);
41      }
42  
43      public MutableXMLStreamBuffer getXMLStreamBuffer() {
44          return _buffer;
45      }
46  
47  
48      protected final void createBuffer() {
49          setBuffer(new MutableXMLStreamBuffer());
50      }
51  
52      /**
53       * Should be called whenever a new tree is stored on the buffer.
54       */
55      protected final void increaseTreeCount() {
56          _buffer.treeCount++;
57      }
58  
59      protected final void setBuffer(MutableXMLStreamBuffer buffer) {
60          _buffer = buffer;
61  
62          _currentStructureFragment = _buffer.getStructure();
63          _structure = _currentStructureFragment.getArray();
64          _structurePtr = 0;
65  
66          _currentStructureStringFragment = _buffer.getStructureStrings();
67          _structureStrings = _currentStructureStringFragment.getArray();
68          _structureStringsPtr = 0;
69  
70          _currentContentCharactersBufferFragment = _buffer.getContentCharactersBuffer();
71          _contentCharactersBuffer = _currentContentCharactersBufferFragment.getArray();
72          _contentCharactersBufferPtr = 0;
73  
74          _currentContentObjectFragment = _buffer.getContentObjects();
75          _contentObjects = _currentContentObjectFragment.getArray();
76          _contentObjectsPtr = 0;
77      }
78  
79      protected final void setHasInternedStrings(boolean hasInternedStrings) {
80          _buffer.setHasInternedStrings(hasInternedStrings);
81      }
82  
83      protected final void storeStructure(int b) {
84          _structure[_structurePtr++] = (byte)b;
85          if (_structurePtr == _structure.length) {
86              resizeStructure();
87          }
88      }
89  
90      protected final void resizeStructure() {
91          _structurePtr = 0;
92          if (_currentStructureFragment.getNext() != null) {
93              _currentStructureFragment = _currentStructureFragment.getNext();
94              _structure = _currentStructureFragment.getArray();
95          } else {
96              _structure = new byte[_structure.length];
97              _currentStructureFragment = new FragmentedArray(_structure, _currentStructureFragment);
98          }
99      }
100 
101     protected final void storeStructureString(String s) {
102         _structureStrings[_structureStringsPtr++] = s;
103         if (_structureStringsPtr == _structureStrings.length) {
104             resizeStructureStrings();
105         }
106     }
107 
108     protected final void resizeStructureStrings() {
109         _structureStringsPtr = 0;
110         if (_currentStructureStringFragment.getNext() != null) {
111             _currentStructureStringFragment = _currentStructureStringFragment.getNext();
112             _structureStrings = _currentStructureStringFragment.getArray();
113         } else {
114             _structureStrings = new String[_structureStrings.length];
115             _currentStructureStringFragment = new FragmentedArray(_structureStrings, _currentStructureStringFragment);
116         }
117     }
118 
119     protected final void storeContentString(String s) {
120         storeContentObject(s);
121     }
122 
123     protected final void storeContentCharacters(int type, char[] ch, int start, int length) {
124         if (_contentCharactersBufferPtr + length >= _contentCharactersBuffer.length) {
125             if (length >= 512) {
126                 storeStructure(type | CONTENT_TYPE_CHAR_ARRAY_COPY);
127                 storeContentCharactersCopy(ch, start, length);
128                 return;
129             }
130             resizeContentCharacters();
131         }
132 
133         if (length < CHAR_ARRAY_LENGTH_SMALL_SIZE) {
134             storeStructure(type);
135             storeStructure(length);
136             System.arraycopy(ch, start, _contentCharactersBuffer, _contentCharactersBufferPtr, length);
137             _contentCharactersBufferPtr += length;
138         } else if (length < CHAR_ARRAY_LENGTH_MEDIUM_SIZE) {
139             storeStructure(type | CHAR_ARRAY_LENGTH_MEDIUM);
140             storeStructure(length >> 8);
141             storeStructure(length & 255);
142             System.arraycopy(ch, start, _contentCharactersBuffer, _contentCharactersBufferPtr, length);
143             _contentCharactersBufferPtr += length;
144         } else {
145             storeStructure(type | CONTENT_TYPE_CHAR_ARRAY_COPY);
146             storeContentCharactersCopy(ch, start, length);
147         }
148     }
149 
150     protected final void resizeContentCharacters() {
151         _contentCharactersBufferPtr = 0;
152         if (_currentContentCharactersBufferFragment.getNext() != null) {
153             _currentContentCharactersBufferFragment = _currentContentCharactersBufferFragment.getNext();
154             _contentCharactersBuffer = _currentContentCharactersBufferFragment.getArray();
155         } else {
156             _contentCharactersBuffer = new char[_contentCharactersBuffer.length];
157             _currentContentCharactersBufferFragment = new FragmentedArray(_contentCharactersBuffer,
158                     _currentContentCharactersBufferFragment);
159         }
160     }
161 
162     protected final void storeContentCharactersCopy(char[] ch, int start, int length) {
163         char[] copyOfCh = new char[length];
164         System.arraycopy(ch, start, copyOfCh, 0, length);
165         storeContentObject(copyOfCh);
166     }
167 
168     protected final Object peekAtContentObject() {
169         return _contentObjects[_contentObjectsPtr];
170     }
171 
172     protected final void storeContentObject(Object s) {
173         _contentObjects[_contentObjectsPtr++] = s;
174         if (_contentObjectsPtr == _contentObjects.length) {
175             resizeContentObjects();
176         }
177     }
178 
179     protected final void resizeContentObjects() {
180         _contentObjectsPtr = 0;
181         if (_currentContentObjectFragment.getNext() != null) {
182             _currentContentObjectFragment = _currentContentObjectFragment.getNext();
183             _contentObjects = _currentContentObjectFragment.getArray();
184         } else {
185             _contentObjects = new Object[_contentObjects.length];
186             _currentContentObjectFragment = new FragmentedArray(_contentObjects, _currentContentObjectFragment);
187         }
188     }
189 }