32ebdb1176fbe180f8c733732e20cb7928180e2c
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / jdom / DOMField.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 java.util.Enumeration;
14
15 import net.sourceforge.phpdt.core.IJavaElement;
16 import net.sourceforge.phpdt.core.IType;
17 import net.sourceforge.phpdt.core.jdom.DOMException;
18 import net.sourceforge.phpdt.core.jdom.IDOMField;
19 import net.sourceforge.phpdt.core.jdom.IDOMNode;
20 import net.sourceforge.phpdt.internal.compiler.util.Util;
21 import net.sourceforge.phpdt.internal.core.util.CharArrayBuffer;
22 import net.sourceforge.phpdt.internal.core.util.CharArrayOps;
23
24 /**
25  * DOMField provides an implementation of IDOMField.
26  *
27  * @see IDOMField
28  * @see DOMNode
29  */
30 class DOMField extends DOMMember implements IDOMField {
31         
32         /**
33          * Contains the type of the field when the type
34          * has been altered from the contents in the
35          * document, otherwise <code>null</code>.
36          */
37         protected String fType;
38
39         /**
40          * The original inclusive source range of the
41          * field's type in the document.
42          */
43         protected int[] fTypeRange;
44                 
45         /**
46          * The contents of the initializer when the
47          * initializer has been altered from the
48          * original state in the document, otherwise
49          * <code>null</code>.
50          */
51         protected String fInitializer;
52
53         /**
54          * The original inclusive source range of the
55          * initializer in the document.
56          */
57         protected int[] fInitializerRange;
58
59 /**
60  * Constructs an empty field node.
61  */
62 DOMField() {
63 }
64 /**
65  * Creates a new detailed FIELD document fragment on the given range of the document.
66  *
67  * @param document - the document containing this node's original contents
68  * @param sourceRange - a two element array of integers describing the
69  *              entire inclusive source range of this node within its document.
70  *              Contents start on and include the character at the first position.
71  *              Contents end on and include the character at the last position.
72  *              An array of -1's indicates this node's contents do not exist
73  *              in the document.
74  * @param name - the identifier portion of the name of this field,
75  *              corresponding to VariableDeclaratorId (JLS 8.3).
76  * @param nameRange - a two element array of integers describing the
77  *              entire inclusive source range of this node's name within its document,
78  *              including any array qualifiers that might follow the name.
79  * @param commentRange - a two element array describing the comments that precede
80  *              the member declaration. The first matches the start of this node's
81  *              sourceRange, and the second is the new-line or first non-whitespace
82  *              character following the last comment. If no comments are present,
83  *              this array contains two -1's.
84  * @param flags - an integer representing the modifiers for this member. The
85  *              integer can be analyzed with org.eclipse.jdt.core.Flags
86  * @param modifierRange - a two element array describing the location of
87  *              modifiers for this member within its source range. The first integer
88  *              is the first character of the first modifier for this member, and
89  *              the second integer is the last whitespace character preceeding the
90  *              next part of this member declaration. If there are no modifiers present
91  *              in this node's source code (that is, package default visibility), this array
92  *              contains two -1's.
93  * @param typeRange- a two element array describing the location of the
94  *              typeName in the document - the positions of the first and last characters
95  *              of the typeName.
96  * @param type - the type of the field, in normalized form, as defined in
97  *      Type in Field Declaration (JLS 8.3)
98  * @param hasInitializer - true if this field declaration includes an initializer,
99  *              otherwise false
100  * @param initRange - a two element array describing the location of the initializer
101  *              in the declaration. The first integer is the position of the character
102  *              following the equals sign, and the position of the last character is the last
103  *              in the initializer. If this field has no initializer, this array contains
104  *              two -1's.
105  * @param isVariableDeclarator - true if the field is a seconday variable declarator
106  *              for a previous field declaration.
107  */
108 DOMField(char[] document, int[] sourceRange, String name, int[] nameRange, int[] commentRange, int flags, int[] modifierRange, int[] typeRange, String type, boolean hasInitializer, int[] initRange, boolean isVariableDeclarator) {
109         super(document, sourceRange, name, nameRange, commentRange, flags, modifierRange);
110
111         fType= type;
112         fTypeRange= typeRange;
113         setHasInitializer(hasInitializer);
114         fInitializerRange= initRange;
115         setIsVariableDeclarator(isVariableDeclarator);
116         setMask(MASK_DETAILED_SOURCE_INDEXES, true);
117
118 }
119 /**
120  * Creates a new simple FIELD document fragment on the given range of the document.
121  *
122  * @param document - the document containing this node's original contents
123  * @param sourceRange - a two element array of integers describing the
124  *              entire inclusive source range of this node within its document.
125  *              Contents start on and include the character at the first position.
126  *              Contents end on and include the character at the last position.
127  *              An array of -1's indicates this node's contents do not exist
128  *              in the document.
129  * @param name - the identifier portion of the name of this field,
130  *              corresponding to VariableDeclaratorId (JLS 8.3).
131  * @param nameRange - a two element array of integers describing the
132  *              entire inclusive source range of this node's name within its document,
133  *              including any array qualifiers that might follow the name.
134  * @param flags - an integer representing the modifiers for this member. The
135  *              integer can be analyzed with org.eclipse.jdt.core.Flags
136  * @param type - the type of the field, in normalized form, as defined in
137  *      Type in Field Declaration (JLS 8.3)
138  * @param isVariableDeclarator - true if the field is a seconday variable declarator
139  *              for a previous field declaration.
140  */
141 DOMField(char[] document, int[] sourceRange, String name, int[] nameRange, int flags, String type, boolean isVariableDeclarator) {
142         this(document, sourceRange, name, nameRange, new int[] {-1, -1}, flags, new int[] {-1, -1}, new int[] {-1, -1}, type, false, new int[] {-1, -1}, isVariableDeclarator);
143         setMask(MASK_DETAILED_SOURCE_INDEXES, false);
144 }
145 /**
146  * Appends this member's body contents to the given CharArrayBuffer.
147  * Body contents include the member body and any trailing whitespace.
148  *
149  * <p>A field does not have a body.
150  *
151  * @see DOMMember#appendMemberBodyContents(CharArrayBuffer)
152  */
153 protected void appendMemberBodyContents(CharArrayBuffer buffer) {}
154 /**
155  * @see DOMMember#appendMemberDeclarationContents(CharArrayBuffer)
156  */
157 protected void appendMemberDeclarationContents(CharArrayBuffer buffer) {
158
159         if (isVariableDeclarator()) {
160                 buffer.append(fDocument, fSourceRange[0], fNameRange[0] - fSourceRange[0]);
161         } else {
162                 buffer
163                         .append(getTypeContents())
164                         .append(fDocument, fTypeRange[1] + 1, fNameRange[0] - fTypeRange[1] - 1);
165         }
166         
167         buffer.append(getNameContents());
168         if (hasInitializer()) {
169                 if (fInitializerRange[0] < 0) {
170                         buffer
171                                 .append('=')
172                                 .append(fInitializer)
173                                 .append(fDocument, fNameRange[1] + 1, fSourceRange[1] - fNameRange[1]);
174                 } else {
175                         buffer
176                                 .append(fDocument, fNameRange[1] + 1, fInitializerRange[0] - fNameRange[1] - 1)
177                                 .append(getInitializer())
178                                 .append(fDocument, fInitializerRange[1] + 1, fSourceRange[1] - fInitializerRange[1]);
179                 }
180         } else {
181                 if (fInitializerRange[0] < 0) {
182                         buffer.append(fDocument, fNameRange[1] + 1, fSourceRange[1] - fNameRange[1]);
183                 } else {
184                         buffer.append(fDocument, fInitializerRange[1] + 1, fSourceRange[1] - fInitializerRange[1]);
185                 }
186         }
187
188 }
189 /**
190  * Appends this member's header contents to the given CharArrayBuffer.
191  * Header contents include any preceding comments and modifiers.
192  *
193  * <p>If this field is a secondary variable declarator, there is no header.
194  *
195  * @see DOMMember#appendMemberHeaderFragment(CharArrayBuffer)
196  */
197 protected void appendMemberHeaderFragment(CharArrayBuffer buffer) {
198
199         if (isVariableDeclarator()) {
200                 return;
201         } else {
202                 super.appendMemberHeaderFragment(buffer);
203         }
204
205 }
206 /**
207  * @see DOMMember#appendSimpleContents(CharArrayBuffer)
208  */
209 protected void appendSimpleContents(CharArrayBuffer buffer) {
210         // append eveything before my name
211         buffer.append(fDocument, fSourceRange[0], fNameRange[0] - fSourceRange[0]);
212         // append my name
213         buffer.append(fName);
214         // append everything after my name
215         buffer.append(fDocument, fNameRange[1] + 1, fSourceRange[1] - fNameRange[1]);
216 }
217 /**
218  * Generates detailed source indexes for this node if possible.
219  *
220  * @exception DOMException if unable to generate detailed source indexes
221  *      for this node
222  */
223 //protected void becomeDetailed() throws DOMException {
224 //      if (!isDetailed()) {
225 //              if (isVariableDeclarator() || hasMultipleVariableDeclarators()) {
226 //                      DOMNode first = getFirstFieldDeclaration();
227 //                      DOMNode last = getLastFieldDeclaration();
228 //                      DOMNode node= first;
229 //                      String source= first.getContents();
230 //                      while (node != last) {
231 //                              node= node.fNextNode;
232 //                              source+=node.getContents();
233 //                      }
234 //                      DOMBuilder builder = new DOMBuilder();
235 //                      IDOMField[] details= builder.createFields(source.toCharArray());
236 //                      if (details.length == 0) {
237 //                              throw new DOMException(Util.bind("dom.cannotDetail")); //$NON-NLS-1$
238 //                      } else {
239 //                              node= this;
240 //                              for (int i= 0; i < details.length; i++) {
241 //                                      node.shareContents((DOMNode)details[i]);
242 //                                      node= node.fNextNode;
243 //                              }
244 //                      }
245 //              } else {
246 //                      super.becomeDetailed();
247 //              }
248 //
249 //      }
250 //}
251 /**
252  * @see IDOMNode#clone()
253  */
254 public Object clone() {
255 //      if (isVariableDeclarator() || hasMultipleVariableDeclarators()) {
256 //              return getFactory().createField(new String(getSingleVariableDeclaratorContents()));
257 //      } else {
258                 return super.clone();
259 //      }
260 }
261 /**
262  * Expands all variable declarators in this field declaration into
263  * stand-alone field declarations. 
264  */
265 protected void expand() {
266         if (isVariableDeclarator() || hasMultipleVariableDeclarators()) {
267                 Enumeration siblings= new SiblingEnumeration(getFirstFieldDeclaration());
268                 DOMField field= (DOMField)siblings.nextElement();
269                 DOMNode next= field.fNextNode;
270                 while (siblings.hasMoreElements() && (next instanceof DOMField) && (((DOMField)next).isVariableDeclarator())) {
271                         field.localizeContents();
272                         if (field.fParent != null) {
273                                 field.fParent.fragment();
274                         }
275                         field= (DOMField)siblings.nextElement();
276                         next= field.fNextNode;
277                 }
278                 field.localizeContents();
279         }
280 }
281 /**
282  * @see DOMNode#getDetailedNode()
283  */
284 //protected DOMNode getDetailedNode() {
285 //      if (isVariableDeclarator() || hasMultipleVariableDeclarators()) {
286 //              return (DOMNode)getFactory().createField(new String(getSingleVariableDeclaratorContents()));
287 //      } else {
288 //              return (DOMNode)getFactory().createField(getContents());
289 //      }
290 //}
291 /**
292  * Returns the first field document fragment that defines
293  * the type for this variable declarator.
294  */
295 protected DOMField getFirstFieldDeclaration() {
296         if (isVariableDeclarator()) {
297                 return ((DOMField)fPreviousNode).getFirstFieldDeclaration();
298         } else {
299                 return this;
300         }
301 }
302 /**
303  * @see IDOMField#getInitializer()
304  */
305 public String getInitializer() {
306         becomeDetailed();
307         if (hasInitializer()) {
308                 if (fInitializer != null) {
309                         return fInitializer;
310                 } else {
311                         return CharArrayOps.substring(fDocument, fInitializerRange[0], fInitializerRange[1] + 1 - fInitializerRange[0]);
312                 }
313         } else {
314                 return null;
315         }
316 }
317 /**
318  * @see IDOMNode#getJavaElement
319  */
320 public IJavaElement getJavaElement(IJavaElement parent) throws IllegalArgumentException {
321         if (parent.getElementType() == IJavaElement.TYPE) {
322                 return ((IType)parent).getField(getName());
323         } else {
324                 throw new IllegalArgumentException(Util.bind("element.illegalParent")); //$NON-NLS-1$
325         }
326 }
327 /**
328  * Returns the last field document fragment in this muli-declarator statement.
329  */
330 protected DOMField getLastFieldDeclaration() {
331         DOMField field = this;
332         while (field.isVariableDeclarator() || field.hasMultipleVariableDeclarators()) {
333                 if (field.fNextNode instanceof DOMField && ((DOMField)field.fNextNode).isVariableDeclarator()) {
334                         field= (DOMField)field.fNextNode;
335                 } else {
336                         break;
337                 }
338         }
339         return field;
340 }
341 /**
342  * @see DOMMember#getMemberDeclarationStartPosition()
343  */
344 protected int getMemberDeclarationStartPosition() {
345         return fTypeRange[0];
346 }
347 /**
348  * @see IDOMNode#getNodeType()
349  */
350 public int getNodeType() {
351         return IDOMNode.FIELD;
352 }
353 /**
354  * Returns a String representing this field declaration as a field
355  * declaration with one variable declarator.
356  */
357 protected char[] getSingleVariableDeclaratorContents() {
358
359
360         CharArrayBuffer buffer= new CharArrayBuffer();
361         DOMField first= getFirstFieldDeclaration();
362         if (first.isDetailed()) {
363                 first.appendMemberHeaderFragment(buffer);
364                 buffer.append(getType());
365                 if (isVariableDeclarator()) {
366                         buffer.append(' ');
367                 } else {
368                         buffer.append(fDocument, fTypeRange[1] + 1, fNameRange[0] - fTypeRange[1] - 1);
369                 }
370         } else {
371                 buffer.append(first.fDocument, first.fSourceRange[0], first.fNameRange[0] - first.fSourceRange[0]);
372         }
373         
374         buffer.append(getName());
375         if (hasInitializer()) {
376                 if (fInitializerRange[0] < 0) {
377                         buffer
378                                 .append('=')
379                                 .append(fInitializer)
380                                 .append(';')
381                                 .append(Util.LINE_SEPARATOR);
382                 } else {
383                         buffer
384                                 .append(fDocument, fNameRange[1] + 1, fInitializerRange[0] - fNameRange[1] - 1)
385                                 .append(getInitializer())
386                                 .append(';')
387                                 .append(Util.LINE_SEPARATOR);
388                 }
389         } else {
390                 buffer.append(';').append(Util.LINE_SEPARATOR);
391         }
392         return buffer.getContents();
393 }
394 /**
395  * @see IDOMField#getType()
396  */
397 public String getType() {
398         return fType;
399 }
400 /**
401  * Returns the souce code to be used for this
402  * field's type.
403  */
404 protected char[] getTypeContents() {
405         if (isTypeAltered()) {
406                 return fType.toCharArray();
407         } else {
408                 return CharArrayOps.subarray(fDocument, fTypeRange[0], fTypeRange[1] + 1 - fTypeRange[0]); 
409         }
410 }
411 /**
412  * Returns true if this field has an initializer expression,
413  * otherwise false.
414  */
415 protected boolean hasInitializer() {
416         return getMask(MASK_FIELD_HAS_INITIALIZER);
417 }
418 /**
419  * Returns true is this field declarations has more than one
420  * variable declarator, otherwise false;
421  */
422 protected boolean hasMultipleVariableDeclarators() {
423         return fNextNode != null && (fNextNode instanceof DOMField) &&
424                 ((DOMField)fNextNode).isVariableDeclarator();
425 }
426 /**
427  * Inserts the given un-parented node as a sibling of this node, immediately before
428  * this node. Once inserted, the sibling is only dependent on this document fragment.
429  *
430  * <p>When a sibling is inserted before a variable declarator, it must first
431  * be expanded.
432  *
433  * @see IDOMNode#insertSibling(IDOMNode)
434  */
435 public void insertSibling(IDOMNode sibling) throws IllegalArgumentException, DOMException {
436         if (isVariableDeclarator()) {
437                 expand();
438         } 
439         super.insertSibling(sibling);
440 }
441 /**
442  * Returns true if this field's type has been altered
443  * from the original document contents.
444  */
445 protected boolean isTypeAltered() {
446         return getMask(MASK_FIELD_TYPE_ALTERED);
447 }
448 /**
449  * Returns true if this field is declared as a secondary variable
450  * declarator for a previous field declaration.
451  */
452 protected boolean isVariableDeclarator() {
453         return getMask(MASK_FIELD_IS_VARIABLE_DECLARATOR);
454 }
455 /**
456  * @see DOMNode
457  */
458 protected DOMNode newDOMNode() {
459         return new DOMField();
460 }
461 /**
462  * Normalizes this <code>DOMNode</code>'s end position.
463  */
464 void normalizeEndPosition(ILineStartFinder finder, DOMNode next) {
465         if (next == null) {
466                 // this node's end position includes all of the characters up
467                 // to the end of the enclosing node
468                 DOMNode parent = (DOMNode) getParent();
469                 if (parent == null || parent instanceof DOMCompilationUnit) {
470                         setSourceRangeEnd(fDocument.length - 1);
471                 } else {
472                         // parent is a type
473                         int temp = ((DOMType)parent).getCloseBodyPosition() - 1;
474                         setSourceRangeEnd(temp);
475                         fInsertionPosition = Math.max(finder.getLineStart(temp + 1), getEndPosition());
476                 }
477         } else {
478                 // this node's end position is just before the start of the next node
479                 // unless the next node is a field that is declared along with this one
480                 int temp = next.getStartPosition() - 1;
481                 fInsertionPosition = Math.max(finder.getLineStart(temp + 1), getEndPosition());
482                 
483                 next.normalizeStartPosition(getEndPosition(), finder);
484                 if (next instanceof DOMField) {
485                         DOMField field = (DOMField) next;
486                         if (field.isVariableDeclarator() && fTypeRange[0] == field.fTypeRange[0])
487                                 return;
488                 }
489                 setSourceRangeEnd(next.getStartPosition() - 1);
490         }
491 }
492 /**
493  * Normalizes this <code>DOMNode</code>'s start position.
494  */
495 void normalizeStartPosition(int endPosition, ILineStartFinder finder) {
496         if (isVariableDeclarator()) {
497                 // start position is end of last element
498                 setStartPosition(fPreviousNode.getEndPosition() + 1);
499         } else {
500                 super.normalizeStartPosition(endPosition, finder);
501         }
502 }
503 /**
504  * Offsets all the source indexes in this node by the given amount.
505  */
506 protected void offset(int offset) {
507         super.offset(offset);
508         offsetRange(fInitializerRange, offset);
509         offsetRange(fTypeRange, offset);
510 }
511 /**
512  * Separates this node from its parent and siblings, maintaining any ties that
513  * this node has to the underlying document fragment.
514  *
515  * <p>When a field with multiple declarators is removed, its declaration
516  * must first be expanded.
517  *
518  * @see IDOMNode#remove()
519  */
520 public void remove() {
521         expand();
522         super.remove();
523 }
524 /**
525  * @see IDOMMember#setComment(String)
526  */
527 public void setComment(String comment) {
528         expand();
529         super.setComment(comment);
530 }
531 /**
532  * @see IDOMMember#setFlags(int)
533  */
534 public void setFlags(int flags) {
535         expand();
536         super.setFlags(flags);
537 }
538 /**
539  * Sets the state of this field declaration as having
540  * an initializer expression.
541  */
542 protected void setHasInitializer(boolean hasInitializer) {
543         setMask(MASK_FIELD_HAS_INITIALIZER, hasInitializer);
544 }
545 /**
546  * @see IDOMField#setInitializer(char[])
547  */
548 public void setInitializer(String initializer) {
549         becomeDetailed();
550         fragment();
551         setHasInitializer(initializer != null);
552         fInitializer= initializer;
553 }
554 /**
555  * Sets the initializer range.
556  */
557 void setInitializerRange(int start, int end) {
558         fInitializerRange[0] = start;
559         fInitializerRange[1] = end;
560 }
561 /**
562  * Sets the state of this field declaration as being a
563  * secondary variable declarator for a previous field
564  * declaration.
565  */
566 protected void setIsVariableDeclarator(boolean isVariableDeclarator) {
567         setMask(MASK_FIELD_IS_VARIABLE_DECLARATOR, isVariableDeclarator);
568 }
569 /**
570  * @see IDOMField#setName(char[])
571  */
572 public void setName(String name) throws IllegalArgumentException {
573         if (name == null) {
574                 throw new IllegalArgumentException(Util.bind("element.nullName")); //$NON-NLS-1$
575         } else {
576                 super.setName(name);
577                 setTypeAltered(true);
578         }
579 }
580 /**
581  * @see IDOMField#setType(char[])
582  */
583 public void setType(String typeName) throws IllegalArgumentException {
584         if (typeName == null) {
585                 throw new IllegalArgumentException(Util.bind("element.nullType")); //$NON-NLS-1$
586         }
587         becomeDetailed();
588         expand();
589         fragment();
590         setTypeAltered(true);
591         setNameAltered(true);
592         fType= typeName;
593 }
594 /**
595  * Sets the state of this field declaration as having
596  * the field type altered from the original document.
597  */
598 protected void setTypeAltered(boolean typeAltered) {
599         setMask(MASK_FIELD_TYPE_ALTERED, typeAltered);
600 }
601 /**
602  * @see DOMNode#shareContents(DOMNode)
603  */
604 protected void shareContents(DOMNode node) {
605         super.shareContents(node);
606         DOMField field= (DOMField)node;
607         fInitializer= field.fInitializer;
608         fInitializerRange= rangeCopy(field.fInitializerRange);
609         fType= field.fType;
610         fTypeRange= rangeCopy(field.fTypeRange);
611 }
612 /**
613  * @see IDOMNode#toString()
614  */
615 public String toString() {
616         return "FIELD: " + getName(); //$NON-NLS-1$
617 }
618 }