|
1
22
23 package org.snmp4j.agent.mo.jmx;
24
25 import java.util.Iterator  ;
26
27 import org.snmp4j.agent.mo.*;
28 import org.snmp4j.mp.SnmpConstants;
29 import org.snmp4j.smi.AbstractVariable;
30 import org.snmp4j.smi.OID;
31 import org.snmp4j.smi.Variable;
32 import org.snmp4j.agent.mo.jmx.util.JMXArrayIndexKey;
33
34
41 public class JMXTableModel implements MOTableModel {
42
43 private OID tableOID;
44 private JMXTableSupport table;
45 private MOColumn[] columns;
46 private MOTableRowFactory rowFactory = new JMXMutableTableRowFactory();
47
48 public JMXTableModel(OID tableEntryOID,
49 JMXTableSupport table,
50 MOColumn[] columns) {
51 this.table = table;
52 this.tableOID = tableEntryOID;
53 this.columns = columns;
54 }
55
56 private Variable[] getInitialRowValues() {
57 Variable[] values = new Variable[getColumnCount()];
58 for (int i = 0; (i < values.length); i++) {
59 if (columns[i] instanceof MOMutableColumn) {
60 values[i] = ((MOMutableColumn) columns[i]).getDefaultValue();
61 if (values[i] == null) {
62 values[i] = AbstractVariable.createFromSyntax(columns[i].getSyntax());
63 }
64 }
65 else {
66 values[i] = AbstractVariable.createFromSyntax(columns[i].getSyntax());
67 }
68 }
69 return values;
70 }
71
72
73 public boolean containsRow(OID index) {
74 int i=0;
75 for (Iterator it = table.rowIdIterator(tableOID); it.hasNext(); i++) {
76 Object rowKey = it.next();
77 OID rowIndex = table.mapToIndex(tableOID, rowKey, i);
78 if (index.equals(rowIndex)) {
79 return true;
80 }
81 }
82 return false;
83 }
84
85 public OID firstIndex() {
86 Iterator it = table.rowIdIterator(tableOID);
87 if (it.hasNext()) {
88 return table.mapToIndex(tableOID, it.next(), 0);
89 }
90 return null;
91 }
92
93 public MOTableRow firstRow() {
94 OID firstIndex = firstIndex();
95 if (firstIndex != null) {
96 MOTableRow row = rowFactory.createRow(firstIndex, getInitialRowValues());
97 table.getRow(tableOID, row);
98 return row;
99 }
100 return null;
101 }
102
103 public int getColumnCount() {
104 return columns.length;
105 }
106
107 public MOTableRow getRow(OID index) {
108 MOTableRow row = rowFactory.createRow(index, getInitialRowValues());
109 int status = table.getRow(tableOID, row);
110 if (status == SnmpConstants.SNMP_ERROR_SUCCESS) {
111 return row;
112 }
113 return null;
114 }
115
116 public int getRowCount() {
117 return table.getRowCount(tableOID);
118 }
119
120 public Iterator iterator() {
121 return new JMXTableRowIterator(table.rowIdIterator(tableOID));
122 }
123
124
129 public OID lastIndex() {
130 return table.getLastIndex(tableOID);
131 }
132
133
139 public MOTableRow lastRow() {
140 OID lastIndex = lastIndex();
141 if (lastIndex != null) {
142 MOTableRow row = rowFactory.createRow(lastIndex, getInitialRowValues());
143 table.getRow(tableOID, row);
144 return row;
145 }
146 return null;
147 }
148
149
158 public Iterator tailIterator(OID lowerBound) {
159 int i=0;
160 Object rowId = table.mapToRowId(tableOID, lowerBound);
161 if (rowId != null) {
162 return new JMXTableRowIterator(table.rowIdTailIterator(tableOID, rowId));
163 }
164 else {
165 for (Iterator it = table.rowIdIterator(tableOID); it.hasNext(); i++) {
166 Object key = it.next();
167 OID index = table.mapToIndex(tableOID, key, i+1);
168 if ((lowerBound == null) || (index.compareTo(lowerBound) >= 0)) {
169 return new JMXTableRowIterator(it, key, i+1);
170 }
171 }
172 }
173 return null;
174 }
175
176 public class JMXTableRowIterator implements Iterator {
177
178 private Object nextKey;
179 private Iterator keys;
180 private int nativeIndex = 0;
181
182 private JMXTableRowIterator(Iterator keys) {
183 this.keys = keys;
184 }
185
186 private JMXTableRowIterator(Iterator keys, Object firstKey,
187 int firstNativeIndex) {
188 this(keys);
189 this.nextKey = firstKey;
190 this.nativeIndex = firstNativeIndex;
191 }
192
193 public boolean hasNext() {
194 return (nextKey != null) || keys.hasNext();
195 }
196
197 public Object next() {
198 Object key = nextKey;
199 if (key == null) {
200 key = keys.next();
201 }
202 else {
203 nextKey = null;
204 }
205 if (key instanceof JMXArrayIndexKey) {
206 nativeIndex = ((JMXArrayIndexKey)key).getIndex();
207 }
208 OID index = table.mapToIndex(tableOID, key, nativeIndex++);
209 MOTableRow row = rowFactory.createRow(index, getInitialRowValues());
210 int status = table.getRow(tableOID, row);
211 if (status == SnmpConstants.SNMP_ERROR_SUCCESS) {
212 return row;
213 }
214 return null;
215 }
216
217 public void remove() {
218 throw new UnsupportedOperationException ();
219 }
220 }
221
222 public MOTableRowFactory getRowFactory() {
223 return rowFactory;
224 }
225
226 public void setRowFactory(MOTableRowFactory rowFactory) {
227 this.rowFactory = rowFactory;
228 }
229
230 class JMXMutableTableRowFactory extends DefaultMOMutableRow2PCFactory {
231
232 public MOTableRow createRow(OID index, Variable[] values) throws
233 UnsupportedOperationException {
234 return new JMXMutableRow2PC(index, values);
235 }
236
237 }
238
239 class JMXMutableRow2PC extends DefaultMOMutableRow2PC {
240 public JMXMutableRow2PC(OID index, Variable[] values) {
241 super(index, values);
242 }
243
244 public void setValue(int column, Variable value) {
245 super.setValue(column, value);
246 table.setRow(tableOID, this, column);
247 }
248
249 }
250 }
251 |
Popular Tags |
Java API By Example, From Geeks To Geeks.