314ee350982b367c1bb29ed37cbad909d1928b34
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / jdom / DOMInitializer.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.core.jdom;
12
13 import net.sourceforge.phpdt.core.IJavaElement;
14 import net.sourceforge.phpdt.core.IType;
15 import net.sourceforge.phpdt.core.jdom.IDOMInitializer;
16 import net.sourceforge.phpdt.core.jdom.IDOMNode;
17 import net.sourceforge.phpdt.internal.compiler.util.Util;
18 import net.sourceforge.phpdt.internal.core.util.CharArrayBuffer;
19 import net.sourceforge.phpdt.internal.core.util.CharArrayOps;
20
21 /**
22  * DOMInitializer provides an implementation of IDOMInitializer.
23  *
24  * @see IDOMInitializer
25  * @see DOMNode
26  */
27 class DOMInitializer extends DOMMember implements IDOMInitializer {
28
29         /**
30          * The contents of the initializer's body when the
31          * body has been altered from the contents in the
32          * document, otherwise <code>null</code>.
33          */
34         protected String fBody;
35
36         /**
37          * The original inclusive source range of the
38          * body in the document.
39          */
40         protected int[]  fBodyRange;
41
42 /**
43  * Constructs an empty initializer node.
44  */
45 DOMInitializer() {
46
47 }
48 /**
49  * Creates a new detailed INITIALIZER document fragment on the given range of the document.
50  *
51  * @param document - the document containing this node's original contents
52  * @param sourceRange - a two element array of integers describing the
53  *              entire inclusive source range of this node within its document.
54  *              Contents start on and include the character at the first position.
55  *              Contents end on and include the character at the last position.
56  *              An array of -1's indicates this node's contents do not exist
57  *              in the document.
58  * @param commentRange - a two element array describing the comments that precede
59  *              the member declaration. The first matches the start of this node's
60  *              sourceRange, and the second is the new-line or first non-whitespace
61  *              character following the last comment. If no comments are present,
62  *              this array contains two -1's.
63  * @param flags - an integer representing the modifiers for this member. The
64  *              integer can be analyzed with org.eclipse.jdt.core.Flags
65  * @param modifierRange - a two element array describing the location of
66  *              modifiers for this member within its source range. The first integer
67  *              is the first character of the first modifier for this member, and
68  *              the second integer is the last whitespace character preceeding the
69  *              next part of this member declaration. If there are no modifiers present
70  *              in this node's source code (that is, package default visibility), this array
71  *              contains two -1's.
72  * @param bodyStartPosition - the position of the open brace of the body
73  *              of this initialzer.
74  */
75 DOMInitializer(char[] document, int[] sourceRange, int[] commentRange, int flags, int[] modifierRange, int bodyStartPosition) {
76         super(document, sourceRange, null, new int[]{-1, -1}, commentRange, flags, modifierRange);
77         fBodyRange= new int[2];
78         fBodyRange[0]= bodyStartPosition;
79         fBodyRange[1]= sourceRange[1];
80         setHasBody(true);
81         setMask(MASK_DETAILED_SOURCE_INDEXES, true);
82 }
83 /**
84  * Creates a new simple INITIALIZER document fragment on the given range of the document.
85  *
86  * @param document - the document containing this node's original contents
87  * @param sourceRange - a two element array of integers describing the
88  *              entire inclusive source range of this node within its document.
89  *              Contents start on and include the character at the first position.
90  *              Contents end on and include the character at the last position.
91  *              An array of -1's indicates this node's contents do not exist
92  *              in the document.
93  * @param flags - an integer representing the modifiers for this member. The
94  *              integer can be analyzed with org.eclipse.jdt.core.Flags
95  */
96 DOMInitializer(char[] document, int[] sourceRange, int flags) {
97         this(document, sourceRange, new int[] {-1, -1}, flags, new int[] {-1, -1}, -1);
98         setMask(MASK_DETAILED_SOURCE_INDEXES, false);
99         
100 }
101 /**
102  * @see DOMMember#appendMemberBodyContents(CharArrayBuffer)
103  */
104 protected void appendMemberBodyContents(CharArrayBuffer buffer) {
105         if (hasBody()) {
106                 buffer
107                         .append(getBody())
108                         .append(fDocument, fBodyRange[1] + 1, fSourceRange[1] - fBodyRange[1]);
109         } else {
110                 buffer.append("{}").append(Util.LINE_SEPARATOR); //$NON-NLS-1$
111         }
112 }
113 /**
114  * @see DOMMember#appendMemberDeclarationContents(CharArrayBuffer)
115  */
116 protected void appendMemberDeclarationContents(CharArrayBuffer buffer) {}
117 /**
118  * @see DOMNode#appendSimpleContents(CharArrayBuffer)
119  */
120 protected void appendSimpleContents(CharArrayBuffer buffer) {
121         // append eveything before my name
122         buffer.append(fDocument, fSourceRange[0], fNameRange[0] - fSourceRange[0]);
123         // append my name
124         buffer.append(fName);
125         // append everything after my name
126         buffer.append(fDocument, fNameRange[1] + 1, fSourceRange[1] - fNameRange[1]);
127 }
128 /**
129  * @see IDOMInitializer#getBody()
130  */
131 public String getBody() {
132         becomeDetailed();
133         if (hasBody()) {
134                 if (fBody != null) {
135                         return fBody;
136                 } else {
137                         return CharArrayOps.substring(fDocument, fBodyRange[0], fBodyRange[1] + 1 - fBodyRange[0]);
138                 }
139         } else {
140                 return null;
141         }
142 }
143 /**
144  * @see DOMNode#getDetailedNode()
145  */
146 //protected DOMNode getDetailedNode() {
147 //      return (DOMNode)getFactory().createInitializer(getContents());
148 //}
149 /**
150  * @see IDOMNode#getJavaElement
151  */
152 public IJavaElement getJavaElement(IJavaElement parent) throws IllegalArgumentException {
153 //      if (parent.getElementType() == IJavaElement.TYPE) {
154 //              int count = 1;
155 //              IDOMNode previousNode = getPreviousNode();
156 //              while (previousNode != null) {
157 //                      if (previousNode instanceof DOMInitializer) {
158 //                              count++;
159 //                      }
160 //                      previousNode = previousNode.getPreviousNode();
161 //              }
162 //              return ((IType) parent).getInitializer(count);
163 //      } else {
164                 throw new IllegalArgumentException(Util.bind("element.illegalParent")); //$NON-NLS-1$
165 //      }
166 }
167 /**
168  * @see DOMMember#getMemberDeclarationStartPosition()
169  */
170 protected int getMemberDeclarationStartPosition() {
171         return fBodyRange[0];
172 }
173 /**
174  * @see IDOMNode#getNodeType()
175  */
176 public int getNodeType() {
177         return IDOMNode.INITIALIZER;
178 }
179 /**
180  * @see IDOMNode#isSigantureEqual(IDOMNode).
181  *
182  * <p>This method always answers false since an initializer
183  * does not have a signature.
184  */
185 public boolean isSignatureEqual(IDOMNode node) {
186         return false;
187 }
188 /**
189  * @see DOMNode
190  */
191 protected DOMNode newDOMNode() {
192         return new DOMInitializer();
193 }
194 /**
195  * Offsets all the source indexes in this node by the given amount.
196  */
197 protected void offset(int offset) {
198         super.offset(offset);
199         offsetRange(fBodyRange, offset);
200 }
201 /**
202  * @see IDOMInitializer#setBody(char[])
203  */
204 public void setBody(String body) {
205         becomeDetailed();
206         fBody= body;
207         setHasBody(body != null);
208         fragment();
209 }
210 /**
211  * @see IDOMInitializer#setName(String)
212  */
213 public void setName(String name) {}
214 /**
215  * @see DOMNode#shareContents(DOMNode)
216  */
217 protected void shareContents(DOMNode node) {
218         super.shareContents(node);
219         DOMInitializer init= (DOMInitializer)node;
220         fBody= init.fBody;
221         fBodyRange= rangeCopy(init.fBodyRange);
222 }
223 /**
224  * @see IDOMNode#toString()
225  */
226 public String toString() {
227         return "INITIALIZER"; //$NON-NLS-1$
228 }
229 }