API Overview API Index Package Overview Direct link to this page
JDK 1.6
  javax.management.openmbean. TabularData View Javadoc
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290

/*
 * @(#)TabularData.java	3.21 05/11/17
 * 
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */


package javax.management.openmbean;


// java import
//
import java.util.Set;
import java.util.Collection;

// jmx import
//


/**
 * The <tt>TabularData</tt> interface specifies the behavior of a specific type of complex <i>open data</i> objects
 * which represent <i>tabular data</i> structures.
 *
 * @version     3.21  05/11/17
 * @author      Sun Microsystems, Inc.
 *
 * @since 1.5
 * @since.unbundled JMX 1.1
 */
public interface TabularData /*extends Map*/ { 


    /* *** TabularData specific information methods *** */


    /**
     * Returns the <i>tabular type</i> describing this
     * <tt>TabularData</tt> instance.
     *
     * @return the tabular type.
     */
    public TabularType getTabularType();


    /**
     * Calculates the index that would be used in this <tt>TabularData</tt> instance to refer to the specified
     * composite data <var>value</var> parameter if it were added to this instance.
     * This method checks for the type validity of the specified <var>value</var>, 
     * but does not check if the calculated index is already used to refer to a value in this <tt>TabularData</tt> instance.
     *
     * @param  value			  the composite data value whose index in this 
     *					  <tt>TabularData</tt> instance is to be calculated;
     *					  must be of the same composite type as this instance's row type;
     *					  must not be null.
     *
     * @return the index that the specified <var>value</var> would have in this <tt>TabularData</tt> instance.
     * 
     * @throws NullPointerException       if <var>value</var> is <tt>null</tt> 
     * 
     * @throws InvalidOpenTypeException   if <var>value</var> does not conform to this <tt>TabularData</tt> instance's 
     *				          row type definition.
     */
    public Object[] calculateIndex(CompositeData value) ;




    /* *** Content information query methods *** */

    /**
     * Returns the number of <tt>CompositeData</tt> values (ie the
     * number of rows) contained in this <tt>TabularData</tt>
     * instance.
     *
     * @return the number of values contained.
     */
    public int size() ;

    /**
     * Returns <tt>true</tt> if the number of <tt>CompositeData</tt>
     * values (ie the number of rows) contained in this
     * <tt>TabularData</tt> instance is zero.
     *
     * @return true if this <tt>TabularData</tt> is empty.
     */
    public boolean isEmpty() ;

    /**
     * Returns <tt>true</tt> if and only if this <tt>TabularData</tt> instance contains a <tt>CompositeData</tt> value 
     * (ie a row) whose index is the specified <var>key</var>. If <var>key</var> is <tt>null</tt> or does not conform to
     * this <tt>TabularData</tt> instance's <tt>TabularType</tt> definition, this method simply returns <tt>false</tt>.
     * 
     * @param  key  the index value whose presence in this <tt>TabularData</tt> instance is to be tested.
     *
     * @return  <tt>true</tt> if this <tt>TabularData</tt> indexes a row value with the specified key.
     */ 
    public boolean containsKey(Object[] key) ;

    /**
     * Returns <tt>true</tt> if and only if this <tt>TabularData</tt> instance contains the specified
     * <tt>CompositeData</tt> value. If <var>value</var> is <tt>null</tt> or does not conform to
     * this <tt>TabularData</tt> instance's row type definition, this method simply returns <tt>false</tt>.
     *
     * @param  value  the row value whose presence in this <tt>TabularData</tt> instance is to be tested.
     *
     * @return  <tt>true</tt> if this <tt>TabularData</tt> instance contains the specified row value.
     */
    public boolean containsValue(CompositeData value) ;

    /**
     * Returns the <tt>CompositeData</tt> value whose index is
     * <var>key</var>, or <tt>null</tt> if there is no value mapping
     * to <var>key</var>, in this <tt>TabularData</tt> instance.
     *
     * @param key the key of the row to return.
     *
     * @return the value corresponding to <var>key</var>.
     *
     * @throws NullPointerException if the <var>key</var> is
     * <tt>null</tt>
     * @throws InvalidKeyException if the <var>key</var> does not
     * conform to this <tt>TabularData</tt> instance's *
     * <tt>TabularType</tt> definition
     */
    public CompositeData get(Object[] key) ;




    /* *** Content modification operations (one element at a time) *** */


    /**
     * Adds <var>value</var> to this <tt>TabularData</tt> instance.
     * The composite type of <var>value</var> must be the same as this
     * instance's row type (ie the composite type returned by
     * <tt>this.getTabularType().{@link TabularType#getRowType
     * getRowType()}</tt>), and there must not already be an existing
     * value in this <tt>TabularData</tt> instance whose index is the
     * same as the one calculated for the <var>value</var> to be
     * added. The index for <var>value</var> is calculated according
     * to this <tt>TabularData</tt> instance's <tt>TabularType</tt>
     * definition (see <tt>TabularType.{@link
     * TabularType#getIndexNames getIndexNames()}</tt>).
     *
     * @param  value			  the composite data value to be added as a new row to this <tt>TabularData</tt> instance;
     *					  must be of the same composite type as this instance's row type;
     *					  must not be null.
     *
     * @throws NullPointerException       if <var>value</var> is <tt>null</tt> 
     * @throws InvalidOpenTypeException   if <var>value</var> does not conform to this <tt>TabularData</tt> instance's 
     *				          row type definition.
     * @throws KeyAlreadyExistsException  if the index for <var>value</var>, calculated according to 
     *					  this <tt>TabularData</tt> instance's <tt>TabularType</tt> definition 
     *					  already maps to an existing value in the underlying HashMap.
     */
    public void put(CompositeData value) ;

    /**
     * Removes the <tt>CompositeData</tt> value whose index is <var>key</var> from this <tt>TabularData</tt> instance,
     * and returns the removed value, or returns <tt>null</tt> if there is no value whose index is <var>key</var>.
     *
     * @param  key  the index of the value to get in this <tt>TabularData</tt> instance;
     *		    must be valid with this <tt>TabularData</tt> instance's row type definition;
     *		    must not be null.
     * 
     * @return previous value associated with specified key, or <tt>null</tt>
     *	       if there was no mapping for key.  
     *
     * @throws NullPointerException  if the <var>key</var> is <tt>null</tt> 
     * @throws InvalidKeyException   if the <var>key</var> does not conform to this <tt>TabularData</tt> instance's 
     *				     <tt>TabularType</tt> definition 
     */
    public CompositeData remove(Object[] key) ;




    /* ***   Content modification bulk operations   *** */


    /**
     * Add all the elements in <var>values</var> to this <tt>TabularData</tt> instance. 
     * If any  element in <var>values</var> does not satisfy the constraints defined in {@link #put(CompositeData) <tt>put</tt>},
     * or if any two elements in <var>values</var> have the same index calculated according to this <tt>TabularData</tt> 
     * instance's <tt>TabularType</tt> definition, then an exception describing the failure is thrown 
     * and no element of <var>values</var> is added,  thus leaving this <tt>TabularData</tt> instance unchanged.
     *
     * @param  values  the array of composite data values to be added as new rows to this <tt>TabularData</tt> instance;
     *		       if <var>values</var> is <tt>null</tt> or empty, this method returns without doing anything.
     * 
     * @throws NullPointerException       if an element of <var>values</var> is <tt>null</tt> 
     * @throws InvalidOpenTypeException   if an element of <var>values</var> does not conform to 
     *					  this <tt>TabularData</tt> instance's row type definition 
     * @throws KeyAlreadyExistsException  if the index for an element of <var>values</var>, calculated according to 
     *					  this <tt>TabularData</tt> instance's <tt>TabularType</tt> definition 
     *					  already maps to an existing value in this instance,
     *					  or two elements of <var>values</var> have the same index.
     */
    public void putAll(CompositeData[] values) ;

    /**
     * Removes all <tt>CompositeData</tt> values (ie rows) from this <tt>TabularData</tt> instance.
     */
    public void clear();




    /* ***   Collection views of the keys and values   *** */


    /**
     * Returns a set view of the keys (ie the index values) of the
     * {@code CompositeData} values (ie the rows) contained in this
     * {@code TabularData} instance. The returned {@code Set} is a
     * {@code Set<List<?>>} but is declared as a {@code Set<?>} for
     * compatibility reasons. The returned set can be used to iterate
     * over the keys.
     *
     * @return a set view ({@code Set<List<?>>}) of the index values
     * used in this {@code TabularData} instance.
     */
    public Set<?> keySet();

    /**
     * Returns a collection view of the {@code CompositeData} values
     * (ie the rows) contained in this {@code TabularData} instance.
     * The returned {@code Collection} is a {@code Collection<CompositeData>}
     * but is declared as a {@code Collection<?>} for compatibility reasons.
     * The returned collection can be used to iterate over the values.
     *
     * @return a collection view ({@code Collection<CompositeData>})
     * of the rows contained in this {@code TabularData} instance.
     */
    public Collection<?> values();




    /* ***  Commodity methods from java.lang.Object  *** */


    /**
     * Compares the specified <var>obj</var> parameter with this <code>TabularData</code> instance for equality. 
     * <p>
     * Returns <tt>true</tt> if and only if all of the following statements are true:
     * <ul>
     * <li><var>obj</var> is non null,</li>
     * <li><var>obj</var> also implements the <code>TabularData</code> interface,</li>
     * <li>their row types are equal</li>
     * <li>their contents (ie index to value mappings) are equal</li>
     * </ul>
     * This ensures that this <tt>equals</tt> method works properly for <var>obj</var> parameters which are
     * different implementations of the <code>TabularData</code> interface.
     * <br>&nbsp;
     * @param  obj  the object to be compared for equality with this <code>TabularData</code> instance;
     * 
     * @return  <code>true</code> if the specified object is equal to this <code>TabularData</code> instance.
     */
    public boolean equals(Object obj);

    /**
     * Returns the hash code value for this <code>TabularData</code> instance. 
     * <p>
     * The hash code of a <code>TabularData</code> instance is the sum of the hash codes
     * of all elements of information used in <code>equals</code> comparisons 
     * (ie: its <i>tabular type</i> and its content, where the content is defined as all the index to value mappings). 
     * <p>
     * This ensures that <code> t1.equals(t2) </code> implies that <code> t1.hashCode()==t2.hashCode() </code> 
     * for any two <code>TabularDataSupport</code> instances <code>t1</code> and <code>t2</code>, 
     * as required by the general contract of the method
     * {@link Object#hashCode() Object.hashCode()}.
     *
     * @return  the hash code value for this <code>TabularDataSupport</code> instance
     */
    public int hashCode();

    /**
     * Returns a string representation of this <code>TabularData</code> instance. 
     * <p>
     * The string representation consists of the name of the implementing class, 
     * and the tabular type of this instance.
     * 
     * @return  a string representation of this <code>TabularData</code> instance
     */
    public String toString();

}

Generated By: JavaOnTracks Doclet 0.1.4     ©Thibaut Colar