Commit | Line | Data |
---|---|---|
a3fc8213 AM |
1 | /******************************************************************************* |
2 | * Copyright (c) 2011 Ericsson | |
3 | * | |
4 | * All rights reserved. This program and the accompanying materials are made | |
5 | * available under the terms of the Eclipse Public License v1.0 which | |
6 | * accompanies this distribution, and is available at | |
7 | * http://www.eclipse.org/legal/epl-v10.html | |
8 | * | |
9 | * Contributors: Matthew Khouzam - Initial API and implementation | |
10 | * Contributors: Alexendre Montplaisir - Initial API and implementation | |
11 | *******************************************************************************/ | |
12 | ||
13 | package org.eclipse.linuxtools.tmf.core.ctfadaptor; | |
14 | ||
15 | import org.eclipse.linuxtools.ctf.core.event.types.ArrayDeclaration; | |
16 | import org.eclipse.linuxtools.ctf.core.event.types.ArrayDefinition; | |
17 | import org.eclipse.linuxtools.ctf.core.event.types.Definition; | |
18 | import org.eclipse.linuxtools.ctf.core.event.types.IntegerDeclaration; | |
19 | import org.eclipse.linuxtools.ctf.core.event.types.IntegerDefinition; | |
20 | import org.eclipse.linuxtools.ctf.core.event.types.SequenceDeclaration; | |
21 | import org.eclipse.linuxtools.ctf.core.event.types.SequenceDefinition; | |
22 | import org.eclipse.linuxtools.ctf.core.event.types.StringDefinition; | |
23 | import org.eclipse.linuxtools.tmf.core.event.ITmfEventField; | |
24 | ||
25 | /** | |
26 | * <b><u>CTFEventField</u></b> | |
27 | */ | |
28 | public abstract class CtfTmfEventField implements ITmfEventField { | |
29 | ||
30 | // ------------------------------------------------------------------------ | |
31 | // Attributes | |
32 | // ------------------------------------------------------------------------ | |
33 | ||
34 | protected final String name; | |
35 | ||
36 | // ------------------------------------------------------------------------ | |
37 | // Constructors | |
38 | // ------------------------------------------------------------------------ | |
39 | ||
40 | protected CtfTmfEventField(String name) { | |
41 | this.name = name; | |
42 | } | |
43 | ||
44 | // ------------------------------------------------------------------------ | |
45 | // Getters/Setters/Predicates | |
46 | // ------------------------------------------------------------------------ | |
47 | ||
48 | @Override | |
49 | public String getName() { | |
50 | return this.name; | |
51 | } | |
52 | ||
53 | // ------------------------------------------------------------------------ | |
54 | // Operations | |
55 | // ------------------------------------------------------------------------ | |
56 | ||
57 | public static CtfTmfEventField parseField(Definition fieldDef, | |
58 | String fieldName) { | |
59 | CtfTmfEventField field = null; | |
60 | ||
61 | /* Determine the Definition type */ | |
62 | if (fieldDef instanceof IntegerDefinition) { | |
63 | field = new CTFIntegerField( | |
64 | ((IntegerDefinition) fieldDef).getValue(), fieldName); | |
65 | ||
66 | } else if (fieldDef instanceof StringDefinition) { | |
67 | field = new CTFStringField( | |
68 | ((StringDefinition) fieldDef).getValue(), fieldName); | |
69 | ||
70 | } else if (fieldDef instanceof ArrayDefinition) { | |
71 | ArrayDefinition arrayDef = (ArrayDefinition) fieldDef; | |
72 | ArrayDeclaration arrayDecl = arrayDef.getDeclaration(); | |
73 | ||
74 | if (arrayDef.isString()) { | |
75 | /* This is an array of UTF-8 bytes, a.k.a. a String! */ | |
76 | field = new CTFStringField(fieldDef.toString(), fieldName); | |
77 | ||
78 | } else if (arrayDecl.getElementType() instanceof IntegerDeclaration) { | |
79 | /* This is a an array of CTF Integers */ | |
80 | long[] values = new long[arrayDecl.getLength()]; | |
81 | for (int i = 0; i < arrayDecl.getLength(); i++) { | |
82 | values[i] = ((IntegerDefinition) arrayDef.getElem(i)).getValue(); | |
83 | } | |
84 | field = new CTFIntegerArrayField(values, fieldName); | |
85 | } | |
86 | /* Add other types of arrays here */ | |
87 | ||
88 | } else if (fieldDef instanceof SequenceDefinition) { | |
89 | SequenceDefinition seqDef = (SequenceDefinition) fieldDef; | |
90 | SequenceDeclaration seqDecl = seqDef.getDeclaration(); | |
91 | ||
92 | if (seqDef.getLength() == 0) { | |
93 | /* Some sequences have length = 0. Simply use an empty string */ | |
94 | field = new CTFStringField("", fieldName); //$NON-NLS-1$ | |
95 | } else if (seqDef.isString()) { | |
96 | /* Interpret this sequence as a String */ | |
97 | field = new CTFStringField(seqDef.toString(), fieldName); | |
98 | } else if (seqDecl.getElementType() instanceof IntegerDeclaration) { | |
99 | /* Sequence of integers => CTFIntegerArrayField */ | |
100 | long[] values = new long[seqDef.getLength()]; | |
101 | for (int i = 0; i < seqDef.getLength(); i++) { | |
102 | values[i] = ((IntegerDefinition) seqDef.getElem(i)).getValue(); | |
103 | } | |
104 | field = new CTFIntegerArrayField(values, fieldName); | |
105 | } | |
106 | /* Add other Sequence types here */ | |
107 | } | |
108 | /* Add other field types here */ | |
109 | ||
110 | return field; | |
111 | } | |
112 | ||
113 | public static CtfTmfEventField copyFrom(CtfTmfEventField other) { | |
114 | switch (other.getFieldType()) { | |
115 | case 0: | |
116 | return new CTFIntegerField(((CTFIntegerField) other).getValue(), | |
117 | other.name); | |
118 | case 1: | |
119 | return new CTFStringField(((CTFStringField) other).getValue(), | |
120 | other.name); | |
121 | case 2: | |
122 | return new CTFIntegerArrayField( | |
123 | ((CTFIntegerArrayField) other).getValue(), other.name); | |
124 | default: | |
125 | return null; | |
126 | } | |
127 | } | |
128 | ||
129 | @Override | |
130 | public CtfTmfEventField clone() { | |
131 | return CtfTmfEventField.copyFrom(this); | |
132 | } | |
133 | ||
134 | /** | |
135 | * Return the int representing this field's value type | |
136 | * | |
137 | * @return | |
138 | */ | |
139 | public abstract int getFieldType(); | |
140 | ||
141 | /** | |
142 | * Return this field's value. You can cast it to the correct type depending | |
143 | * on what getFieldType says. | |
144 | * | |
145 | * @return | |
146 | */ | |
147 | @Override | |
148 | public abstract Object getValue(); | |
149 | ||
150 | /** | |
151 | * @name Other methods defined by ITmfEventField, but not used here: the CTF | |
152 | * fields do not have sub-fields (yet!) | |
153 | */ | |
154 | ||
155 | @Override | |
156 | public String[] getFieldNames() { | |
157 | return null; | |
158 | } | |
159 | ||
160 | @Override | |
161 | public String getFieldName(int index) { | |
162 | return null; | |
163 | } | |
164 | ||
165 | @Override | |
166 | public ITmfEventField[] getFields() { | |
167 | return null; | |
168 | } | |
169 | ||
170 | @Override | |
171 | public ITmfEventField getField(String fieldName) { | |
172 | return null; | |
173 | } | |
174 | ||
175 | @Override | |
176 | public ITmfEventField getField(int index) { | |
177 | return null; | |
178 | } | |
179 | } | |
180 | ||
181 | /** | |
182 | * <b><u>CTFIntegerField</u></b> | |
183 | */ | |
184 | final class CTFIntegerField extends CtfTmfEventField { | |
185 | ||
186 | private final long longValue; | |
187 | ||
188 | /** | |
189 | * A CTF "IntegerDefinition" can be an integer of any byte size, so in the | |
190 | * Java parser this is interpreted as a long. | |
191 | */ | |
192 | CTFIntegerField(long longValue, String name) { | |
193 | super(name); | |
194 | this.longValue = longValue; | |
195 | } | |
196 | ||
197 | @Override | |
198 | public int getFieldType() { | |
199 | return 0; | |
200 | } | |
201 | ||
202 | @Override | |
203 | public Long getValue() { | |
204 | return this.longValue; | |
205 | } | |
206 | ||
207 | /* | |
208 | * (non-Javadoc) | |
209 | * | |
210 | * @see java.lang.Object#toString() | |
211 | */ | |
212 | @Override | |
213 | public String toString() { | |
214 | return name + '=' + longValue; | |
215 | } | |
216 | } | |
217 | ||
218 | /** | |
219 | * <b><u>CTFStringField</u></b> | |
220 | */ | |
221 | final class CTFStringField extends CtfTmfEventField { | |
222 | ||
223 | private final String strValue; | |
224 | ||
225 | CTFStringField(String strValue, String name) { | |
226 | super(name); | |
227 | this.strValue = strValue; | |
228 | } | |
229 | ||
230 | @Override | |
231 | public int getFieldType() { | |
232 | return 1; | |
233 | } | |
234 | ||
235 | @Override | |
236 | public String getValue() { | |
237 | return this.strValue; | |
238 | } | |
239 | ||
240 | /* | |
241 | * (non-Javadoc) | |
242 | * | |
243 | * @see java.lang.Object#toString() | |
244 | */ | |
245 | @Override | |
246 | public String toString() { | |
247 | return name + '=' + strValue; | |
248 | } | |
249 | } | |
250 | ||
251 | /** | |
252 | * <b><u>CTFIntegerArrayField</u></b> | |
253 | */ | |
254 | final class CTFIntegerArrayField extends CtfTmfEventField { | |
255 | ||
256 | private final long[] longValues; | |
257 | ||
258 | CTFIntegerArrayField(long[] longValues, String name) { | |
259 | super(name); | |
260 | this.longValues = longValues; | |
261 | } | |
262 | ||
263 | @Override | |
264 | public int getFieldType() { | |
265 | return 2; | |
266 | } | |
267 | ||
268 | @Override | |
269 | public long[] getValue() { | |
270 | return this.longValues; | |
271 | } | |
272 | ||
273 | @Override | |
274 | public String toString() { | |
275 | StringBuffer buffer = new StringBuffer(); | |
276 | buffer.append("{ "); //$NON-NLS-1$ | |
277 | ||
278 | buffer.append(longValues[0]); | |
279 | for (int i = 1; i < longValues.length; i++) { | |
280 | buffer.append(", " + longValues[i]); //$NON-NLS-1$ | |
281 | } | |
282 | buffer.append('}'); | |
283 | return name + '=' + buffer.toString(); | |
284 | } | |
285 | } | |
286 | ||
287 | /* Implement other possible fields types here... */ |