src/main/java/io/devnulllabs/openjava/ptree/ArrayInitializer.java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

/*
 * ArrayInitializer.java 1.0
 *
 * Jun 11, 1997 by mich
 * Oct 10, 1997 by mich
 *
 * @see io.devnulllabs.openjava.ptree.ParseTree
 * @version last updated:  Oct 10, 1997
 * @author  Michiaki Tatsubori
 */
package io.devnulllabs.openjava.ptree;

import io.devnulllabs.openjava.ptree.util.ParseTreeVisitor;

/**
 * The ArrayInitializer class presents initializer list of array elements.
 *
 * @see io.devnulllabs.openjava.ptree.ParseTree
 * @see io.devnulllabs.openjava.ptree.List
 * @see io.devnulllabs.openjava.ptree.VariableInitializer
 */
public class ArrayInitializer extends List implements VariableInitializer {

    private boolean _isRemainderOmitted = false;

    /**
     * Allocates a new ArrayInitializer.
     *
     * @param arrayinit prototype object
     */
    public ArrayInitializer() {
        super(", ");
    }

    public ArrayInitializer(VariableInitializer vi) {
        this();
        add(vi);
    }

    public ArrayInitializer(ExpressionList exprs) {
        this();
        int len = exprs.size();
        for (int i = 0; i < len; ++i) {
            add(exprs.get(i));
        }
    }

    public void omitRemainder(boolean is_omitted) {
        this._isRemainderOmitted = is_omitted;
    }

    public void omitRemainder() {
        this._isRemainderOmitted = true;
    }

    public boolean isRemainderOmitted() {
        return this._isRemainderOmitted;
    }

    /**
     * Gets the specified element at the index.
     *
     * @param  n  index
     */
    public VariableInitializer get(int n) {
        return (VariableInitializer) contents_elementAt(n);
    }

    /**
     * Adds the specified element after the list
     * This causes side-effect.
     *
     * @param  p  VariableInitializer to be inserted into the list
     */
    public void add(VariableInitializer p) {
        contents_addElement(p);
    }

    /**
     * Adds the specified element after the list
     * This causes side-effect.
     *
     * @param  p  VariableInitializer to be inserted into the list
     */
    public void set(int index, VariableInitializer p) {
        contents_setElementAt(p, index);
    }

    /**
     * Removes the element at the specified position in this Vector.
     * shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the Vector.
     *
     * @exception ArrayIndexOutOfBoundsException index out of range (index
     *            &lt; 0 || index &gt;= size()).
     * @param index the index of the element to removed.
     * @since JDK1.2
     */
    public VariableInitializer remove(int index) {
        VariableInitializer removed =
            (VariableInitializer) contents_elementAt(index);
        contents_removeElementAt(index);
        return removed;
    }

    /**
     * Inserts the specified element into the list
     * before the specified element of the list.
     * This causes side-effect.
     *
     * @param  p  the element to be inserted into the list
     * @param  n  number of the element before which insertion ocuurs
     */
    public void insertElementAt(VariableInitializer p, int n) {
        contents_insertElementAt(p, n);
    }

    /**
     * Appends a list after this list.
     *
     * @param  lst  a list to be appended
     */
    public void addAll(ArrayInitializer lst) {
        for (int i = 0, len = lst.size(); i < len; i++) {
            contents_addElement(lst.get(i));
        }
    }

    /**
     * Returns a view of the portion of this List between fromIndex,
     * inclusive, and toIndex, exclusive.  The returned List is backed by this
     * List, but changes in the returned List are not reflected in this List.
     * <p>
     *
     * @param fromIndex low endpoint (inclusive) of the subList.
     * @param toKey high endpoint (exclusive) of the subList.
     * @return a view of the specified range within this List.
     * @exception IndexOutOfBoundsException Illegal endpoint index value
     *     (fromIndex &lt; 0 || toIndex &gt; size || fromIndex &gt; toIndex).
     */
    public ArrayInitializer subList(int from_index, int to_index) {
        ArrayInitializer result = new ArrayInitializer();
        for (int i = from_index; i < to_index; ++i) {
            result.add(this.get(i));
        }
        return result;
    }

    public void accept(ParseTreeVisitor v) throws ParseTreeException {
        v.visit(this);
    }
}