Revision 628 org.gvsig.tools/library/trunk/org.gvsig.tools/org.gvsig.tools.lib/src/main/java/org/gvsig/tools/dynobject/impl/DynClassImportHelper.java
DynClassImportHelper.java | ||
---|---|---|
29 | 29 |
|
30 | 30 |
public class DynClassImportHelper { |
31 | 31 |
|
32 |
private static final Logger LOG = LoggerFactory.getLogger(DynClassImportHelper.class); |
|
33 |
|
|
32 |
private static final Logger LOG = LoggerFactory |
|
33 |
.getLogger(DynClassImportHelper.class); |
|
34 |
|
|
34 | 35 |
private static final String VERSION_VALUE = "1.0.0"; |
35 |
|
|
36 |
|
|
36 | 37 |
private static final String DEFINITIONS_TAG = "definitions"; |
37 | 38 |
private static final String VERSION_TAG = "version"; |
38 | 39 |
private static final String CLASSES_TAG = "classes"; |
39 |
|
|
40 |
|
|
40 | 41 |
private static final String CLASS_TAG = "class"; |
41 | 42 |
private static final String CLASS_NAME_TAG = "name"; |
42 | 43 |
private static final String CLASS_NAMESPACE_TAG = "namespace"; |
... | ... | |
46 | 47 |
private static final String CLASS_EXTENDS_TAG = "extends"; |
47 | 48 |
private static final String CLASS_EXTENDS_CLASS_TAG = "class"; |
48 | 49 |
private static final String CLASS_FIELDS_TAG = "fields"; |
49 |
|
|
50 |
|
|
50 | 51 |
private static final String FIELD_TAG = "field"; |
51 | 52 |
private static final String FIELD_NAME_TAG = "name"; |
52 | 53 |
private static final String FIELD_DESCRIPTION_TAG = "description"; |
... | ... | |
59 | 60 |
private static final String FIELD_CLASSOFVALUE_TAG = "classOfValue"; |
60 | 61 |
private static final String FIELD_CLASSOFITEMS_TAG = "classOfItems"; |
61 | 62 |
private static final String FIELD_DEFAULTVALUE_TAG = "defaultValue"; |
62 |
// private static final String FIELD_TYPEOFAVALILABLEVALUES_TAG = "typeOfAvailableValues"; |
|
63 |
// private static final String FIELD_TYPEOFAVALILABLEVALUES_TAG = |
|
64 |
// "typeOfAvailableValues"; |
|
63 | 65 |
private static final String FIELD_AVALILABLEVALUES_TAG = "availableValues"; |
64 | 66 |
private static final String FIELD_GROUP_TAG = "group"; |
65 | 67 |
private static final String FIELD_ORDER_TAG = "order"; |
... | ... | |
72 | 74 |
private DynObjectManager manager = ToolsLocator.getDynObjectManager(); |
73 | 75 |
|
74 | 76 |
private String getNullWhenEmptyString(String value) { |
75 |
if( value!= null ) {
|
|
76 |
if( value.trim().length()==0) {
|
|
77 |
if (value != null) {
|
|
78 |
if (value.trim().length() == 0) {
|
|
77 | 79 |
return null; |
78 | 80 |
} |
79 | 81 |
} |
80 | 82 |
return value; |
81 |
|
|
83 |
|
|
82 | 84 |
} |
83 |
private String nextText(XmlPullParser parser) throws XmlPullParserException, IOException { |
|
85 |
|
|
86 |
private String nextText(XmlPullParser parser) |
|
87 |
throws XmlPullParserException, IOException { |
|
84 | 88 |
return getNullWhenEmptyString(parser.nextText()); |
85 | 89 |
} |
86 |
|
|
87 |
private String getAttributeValue(XmlPullParser parser, int i) throws XmlPullParserException, IOException { |
|
90 |
|
|
91 |
private String getAttributeValue(XmlPullParser parser, int i) |
|
92 |
throws XmlPullParserException, IOException { |
|
88 | 93 |
return getNullWhenEmptyString(parser.getAttributeValue(i)); |
89 | 94 |
} |
90 | 95 |
|
91 |
public Map importDefinitions(InputStream resource, ClassLoader loader, String defaultNamespace) throws XmlPullParserException, IOException { |
|
96 |
public Map importDefinitions(InputStream resource, ClassLoader loader, |
|
97 |
String defaultNamespace) throws XmlPullParserException, IOException { |
|
92 | 98 |
|
93 | 99 |
XmlPullParserFactory factory = XmlPullParserFactory.newInstance( |
94 | 100 |
ToolsLocator.getInstance().getXmlPullParserFactoryClassNames(), |
95 | 101 |
null); |
96 | 102 |
|
97 | 103 |
XmlPullParser parser = factory.newPullParser(); |
98 |
|
|
104 |
|
|
99 | 105 |
parser.setInput(resource, null); |
100 |
|
|
106 |
|
|
101 | 107 |
return importDefinitions(parser, loader, defaultNamespace); |
102 | 108 |
} |
103 |
|
|
109 |
|
|
104 | 110 |
private class Definitions extends HashMap implements Map { |
105 |
|
|
111 |
|
|
106 | 112 |
/** |
107 | 113 |
* |
108 | 114 |
*/ |
109 | 115 |
private static final long serialVersionUID = -3322643637478345069L; |
110 | 116 |
|
111 | 117 |
public Object put(Object key, Object value) { |
112 |
return super.put(((String)key).toLowerCase(), value); |
|
118 |
return super.put(((String) key).toLowerCase(), value);
|
|
113 | 119 |
} |
114 |
|
|
120 |
|
|
115 | 121 |
public Object get(Object theName) { |
116 | 122 |
DynClass definition; |
117 |
definition = (DynClass) super.get(((String)theName).toLowerCase()); |
|
118 |
if( definition != null ) {
|
|
123 |
definition = (DynClass) super.get(((String) theName).toLowerCase());
|
|
124 |
if (definition != null) {
|
|
119 | 125 |
return definition; |
120 | 126 |
} |
121 | 127 |
// No ha encontrado la clase pedida, podria ser que el namespace |
122 | 128 |
// no coincida, vamos a buscarla ignorando el namespace en caso |
123 | 129 |
// de que este no se haya indicado. |
124 |
DynClassName name = manager |
|
125 |
.createDynClassName((String) theName); |
|
126 |
if( name.getNamespace()==null ) { |
|
130 |
DynClassName name = manager.createDynClassName((String) theName); |
|
131 |
if (name.getNamespace() == null) { |
|
127 | 132 |
// No han especificado namespace, asi que busco la primera |
128 | 133 |
// que tenga como nombre el indicado independientemente del |
129 | 134 |
// namespace que tenga. |
130 | 135 |
Iterator it = this.values().iterator(); |
131 |
while( it.hasNext() ) {
|
|
136 |
while (it.hasNext()) {
|
|
132 | 137 |
definition = (DynClass) it.next(); |
133 |
if( definition.getName().equalsIgnoreCase(name.getName()) ) {
|
|
138 |
if (definition.getName().equalsIgnoreCase(name.getName())) {
|
|
134 | 139 |
return definition; |
135 | 140 |
} |
136 | 141 |
} |
... | ... | |
138 | 143 |
// Han especificaso un namespace, asi que voy a buscar una que |
139 | 144 |
// no tenga namespace y su nombre concuerde. |
140 | 145 |
Iterator it = this.values().iterator(); |
141 |
while( it.hasNext() ) {
|
|
146 |
while (it.hasNext()) {
|
|
142 | 147 |
definition = (DynClass) it.next(); |
143 |
if( definition.getNamespace()==null && definition.getName().equalsIgnoreCase(name.getName()) ) { |
|
148 |
if (definition.getNamespace() == null |
|
149 |
&& definition.getName().equalsIgnoreCase( |
|
150 |
name.getName())) { |
|
144 | 151 |
return definition; |
145 | 152 |
} |
146 | 153 |
} |
147 | 154 |
} |
148 | 155 |
return null; |
149 | 156 |
} |
150 |
|
|
157 |
|
|
151 | 158 |
public boolean containsKey(Object key) { |
152 |
String lowerKey = ((String)key).toLowerCase(); |
|
153 |
if( super.containsKey(lowerKey) ) {
|
|
159 |
String lowerKey = ((String) key).toLowerCase();
|
|
160 |
if (super.containsKey(lowerKey)) {
|
|
154 | 161 |
return true; |
155 | 162 |
} |
156 | 163 |
Object value = this.get(lowerKey); |
157 | 164 |
return value != null; |
158 | 165 |
} |
159 | 166 |
} |
160 |
|
|
161 |
public Map importDefinitions(XmlPullParser parser, ClassLoader loader, String defaultNamespace) throws XmlPullParserException, IOException { |
|
167 |
|
|
168 |
public Map importDefinitions(XmlPullParser parser, ClassLoader loader, |
|
169 |
String defaultNamespace) throws XmlPullParserException, IOException { |
|
162 | 170 |
Map dynClasses = new Definitions(); |
163 | 171 |
String version = null; |
164 |
|
|
165 |
if( loader == null ) {
|
|
172 |
|
|
173 |
if (loader == null) {
|
|
166 | 174 |
loader = this.getClass().getClassLoader(); |
167 | 175 |
} |
168 | 176 |
parser.nextTag(); |
169 | 177 |
parser.require(XmlPullParser.START_TAG, null, DEFINITIONS_TAG); |
170 |
for( int i=0;i<parser.getAttributeCount(); i++) {
|
|
178 |
for (int i = 0; i < parser.getAttributeCount(); i++) {
|
|
171 | 179 |
String name = parser.getAttributeName(i); |
172 |
if( name.equalsIgnoreCase(VERSION_TAG) ) {
|
|
180 |
if (name.equalsIgnoreCase(VERSION_TAG)) {
|
|
173 | 181 |
version = this.getAttributeValue(parser, i); |
174 | 182 |
} else { |
175 | 183 |
throw new WrongVersionException(parser); |
176 | 184 |
} |
177 | 185 |
} |
178 | 186 |
parser.nextTag(); |
179 |
if( parser.getName().equalsIgnoreCase(VERSION_TAG) ) {
|
|
187 |
if (parser.getName().equalsIgnoreCase(VERSION_TAG)) {
|
|
180 | 188 |
parser.require(XmlPullParser.START_TAG, null, VERSION_TAG); |
181 | 189 |
version = parser.nextText(); |
182 |
if (!version.trim().equals(VERSION_VALUE) ) {
|
|
190 |
if (!version.trim().equals(VERSION_VALUE)) { |
|
183 | 191 |
throw new UnsupportedClassVersionError(); |
184 | 192 |
} |
185 | 193 |
parser.require(XmlPullParser.END_TAG, "", VERSION_TAG); |
186 | 194 |
parser.nextTag(); |
187 | 195 |
} |
188 |
|
|
196 |
|
|
189 | 197 |
parser.require(XmlPullParser.START_TAG, "", CLASSES_TAG); |
190 | 198 |
parser.nextTag(); |
191 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
192 |
parser.getName().equals(CLASSES_TAG))) {
|
|
199 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
200 |
.getName().equals(CLASSES_TAG))) { |
|
193 | 201 |
checkEndDocument(parser); |
194 |
DynClass dynClass = importDynClass(parser, loader, defaultNamespace, dynClasses); |
|
202 |
DynClass dynClass = importDynClass(parser, loader, |
|
203 |
defaultNamespace, dynClasses); |
|
195 | 204 |
try { |
196 |
((DefaultDynClass)dynClass).check(); |
|
205 |
((DefaultDynClass) dynClass).check();
|
|
197 | 206 |
} catch (ListBaseException e) { |
198 | 207 |
throw new DynObjectRuntimeException(e); |
199 | 208 |
} |
200 |
if( dynClasses.get(dynClass.getFullName())!=null ) { |
|
201 |
throw new DuplicateDynClassException(parser, dynClass.getFullName()); |
|
209 |
if (dynClasses.get(dynClass.getFullName()) != null) { |
|
210 |
throw new DuplicateDynClassException(parser, |
|
211 |
dynClass.getFullName()); |
|
202 | 212 |
} |
203 | 213 |
dynClasses.put(dynClass.getFullName(), dynClass); |
204 | 214 |
} |
... | ... | |
217 | 227 |
List l = new ArrayList(theMap.keySet()); |
218 | 228 |
return l.toString(); |
219 | 229 |
} |
220 |
|
|
221 |
private DynClass importDynClass(XmlPullParser parser, ClassLoader loader, String defaultNamespace, Map classes) throws XmlPullParserException, IOException { |
|
230 |
|
|
231 |
private DynClass importDynClass(XmlPullParser parser, ClassLoader loader, |
|
232 |
String defaultNamespace, Map classes) |
|
233 |
throws XmlPullParserException, IOException { |
|
222 | 234 |
DynObjectManager manager = ToolsLocator.getDynObjectManager(); |
223 |
DynClass dynClass;
|
|
235 |
DynClass dynClass; |
|
224 | 236 |
List superClasses = new ArrayList(); |
225 | 237 |
Map values = new HashMap(); |
226 |
|
|
238 |
|
|
227 | 239 |
parser.require(XmlPullParser.START_TAG, null, CLASS_TAG); |
228 | 240 |
// |
229 | 241 |
// Collect class attributes from tag attributes |
230 | 242 |
// |
231 |
for( int i=0; i<parser.getAttributeCount(); i++ ) { |
|
232 |
values.put(parser.getAttributeName(i), this.getAttributeValue(parser, i)); |
|
243 |
for (int i = 0; i < parser.getAttributeCount(); i++) { |
|
244 |
values.put(parser.getAttributeName(i), |
|
245 |
this.getAttributeValue(parser, i)); |
|
233 | 246 |
} |
234 | 247 |
parser.nextTag(); |
235 | 248 |
|
236 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
237 |
parser.getName().equals(CLASSES_TAG))) {
|
|
249 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
250 |
.getName().equals(CLASSES_TAG))) { |
|
238 | 251 |
checkEndDocument(parser); |
239 | 252 |
|
240 | 253 |
parser.require(XmlPullParser.START_TAG, null, null); |
241 | 254 |
String tagName = parser.getName(); |
242 |
if( tagName.equalsIgnoreCase(CLASS_DESCRIPTION_TAG)) {
|
|
255 |
if (tagName.equalsIgnoreCase(CLASS_DESCRIPTION_TAG)) {
|
|
243 | 256 |
values.put(CLASS_DESCRIPTION_TAG, this.nextText(parser)); |
244 | 257 |
|
245 |
} else if( tagName.equalsIgnoreCase(CLASS_NAME_TAG)) {
|
|
258 |
} else if (tagName.equalsIgnoreCase(CLASS_NAME_TAG)) {
|
|
246 | 259 |
values.put(CLASS_NAME_TAG, this.nextText(parser)); |
247 |
|
|
248 |
} else if( tagName.equalsIgnoreCase(CLASS_NAMESPACE_TAG)) {
|
|
260 |
|
|
261 |
} else if (tagName.equalsIgnoreCase(CLASS_NAMESPACE_TAG)) {
|
|
249 | 262 |
values.put(CLASS_NAMESPACE_TAG, this.nextText(parser)); |
250 | 263 |
|
251 |
} else if( tagName.equalsIgnoreCase(CLASS_SUPERCLASSNAMES_TAG) ) {
|
|
264 |
} else if (tagName.equalsIgnoreCase(CLASS_SUPERCLASSNAMES_TAG)) {
|
|
252 | 265 |
parser.nextTag(); |
253 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
254 |
parser.getName().equals(CLASS_SUPERCLASSNAMES_TAG))) {
|
|
266 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
267 |
.getName().equals(CLASS_SUPERCLASSNAMES_TAG))) { |
|
255 | 268 |
checkEndDocument(parser); |
256 |
parser.require(XmlPullParser.START_TAG, "", CLASS_SUPERCLASSNAME_TAG); |
|
269 |
parser.require(XmlPullParser.START_TAG, "", |
|
270 |
CLASS_SUPERCLASSNAME_TAG); |
|
257 | 271 |
superClasses.add(manager.createDynClassName( |
258 | 272 |
defaultNamespace, this.nextText(parser))); |
259 |
parser.require(XmlPullParser.END_TAG, null, CLASS_SUPERCLASSNAME_TAG); |
|
273 |
parser.require(XmlPullParser.END_TAG, null, |
|
274 |
CLASS_SUPERCLASSNAME_TAG); |
|
260 | 275 |
parser.nextTag(); |
261 | 276 |
} |
262 |
|
|
263 |
} else if( tagName.equalsIgnoreCase(CLASS_EXTENDS_TAG) ) {
|
|
277 |
|
|
278 |
} else if (tagName.equalsIgnoreCase(CLASS_EXTENDS_TAG)) {
|
|
264 | 279 |
parser.nextTag(); |
265 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
266 |
parser.getName().equals(CLASS_EXTENDS_TAG))) {
|
|
280 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
281 |
.getName().equals(CLASS_EXTENDS_TAG))) { |
|
267 | 282 |
checkEndDocument(parser); |
268 |
superClasses.add( importSuperClass(parser, defaultNamespace) ); |
|
283 |
superClasses |
|
284 |
.add(importSuperClass(parser, defaultNamespace)); |
|
269 | 285 |
parser.nextTag(); |
270 | 286 |
} |
271 | 287 |
} else { |
... | ... | |
280 | 296 |
// |
281 | 297 |
// Create dynclass |
282 | 298 |
// |
283 |
if( values.get(CLASS_NAME_TAG) == null ) {
|
|
284 |
throw new NeedTagOrAttributeException(parser,CLASS_NAME_TAG); |
|
299 |
if (values.get(CLASS_NAME_TAG) == null) {
|
|
300 |
throw new NeedTagOrAttributeException(parser, CLASS_NAME_TAG);
|
|
285 | 301 |
} |
286 |
if( values.get(CLASS_NAMESPACE_TAG)==null ) {
|
|
302 |
if (values.get(CLASS_NAMESPACE_TAG) == null) {
|
|
287 | 303 |
values.put(CLASS_NAMESPACE_TAG, defaultNamespace); |
288 | 304 |
} |
289 | 305 |
dynClass = manager.createDynClass( |
290 |
(String)values.get(CLASS_NAMESPACE_TAG), |
|
291 |
(String)values.get(CLASS_NAME_TAG), |
|
292 |
(String)values.get(CLASS_DESCRIPTION_TAG) |
|
293 |
); |
|
294 |
for( int i=0; i<superClasses.size(); i++) { |
|
306 |
(String) values.get(CLASS_NAMESPACE_TAG), |
|
307 |
(String) values.get(CLASS_NAME_TAG), |
|
308 |
(String) values.get(CLASS_DESCRIPTION_TAG)); |
|
309 |
for (int i = 0; i < superClasses.size(); i++) { |
|
295 | 310 |
DynClassName superClass = (DynClassName) superClasses.get(i); |
296 |
if( superClass.getName() == null ) {
|
|
297 |
throw new NeedTagOrAttributeException(parser,CLASS_NAME_TAG); |
|
311 |
if (superClass.getName() == null) {
|
|
312 |
throw new NeedTagOrAttributeException(parser, CLASS_NAME_TAG);
|
|
298 | 313 |
} |
299 |
DynClass superDynClass = (DynClass) classes.get(superClass.getFullName()); |
|
300 |
if( superDynClass==null ) { |
|
301 |
superDynClass = ToolsLocator.getDynObjectManager().get(superClass.getNamespace(), superClass.getName()); |
|
302 |
if( superDynClass==null ) { |
|
303 |
throw new CantLocateDynClassException(parser,superClass.getFullName()); |
|
314 |
DynClass superDynClass = (DynClass) classes.get(superClass |
|
315 |
.getFullName()); |
|
316 |
if (superDynClass == null) { |
|
317 |
superDynClass = ToolsLocator.getDynObjectManager().get( |
|
318 |
superClass.getNamespace(), superClass.getName()); |
|
319 |
if (superDynClass == null) { |
|
320 |
throw new CantLocateDynClassException(parser, |
|
321 |
superClass.getFullName()); |
|
304 | 322 |
} |
305 | 323 |
} |
306 | 324 |
dynClass.extend(superDynClass); |
... | ... | |
309 | 327 |
// |
310 | 328 |
// Parse and load fields of dynclass |
311 | 329 |
// |
312 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
313 |
parser.getName().equals(CLASS_FIELDS_TAG))) {
|
|
330 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
331 |
.getName().equals(CLASS_FIELDS_TAG))) { |
|
314 | 332 |
checkEndDocument(parser); |
315 |
importDynField(parser, dynClass, loader);
|
|
316 |
parser.nextTag();
|
|
333 |
importDynField(parser, dynClass, loader);
|
|
334 |
parser.nextTag();
|
|
317 | 335 |
} |
318 | 336 |
parser.require(XmlPullParser.END_TAG, null, CLASS_FIELDS_TAG); |
319 | 337 |
parser.nextTag(); |
... | ... | |
323 | 341 |
return dynClass; |
324 | 342 |
} |
325 | 343 |
|
326 |
|
|
327 | 344 |
private DynClassName importSuperClass(XmlPullParser parser, |
328 | 345 |
String defaultNamespace) throws XmlPullParserException, IOException { |
329 |
|
|
346 |
|
|
330 | 347 |
String name = null; |
331 | 348 |
String namespace = defaultNamespace; |
332 | 349 |
|
333 | 350 |
parser.require(XmlPullParser.START_TAG, null, CLASS_EXTENDS_CLASS_TAG); |
334 |
for( int i=0; i<parser.getAttributeCount(); i++) {
|
|
351 |
for (int i = 0; i < parser.getAttributeCount(); i++) {
|
|
335 | 352 |
String attrname = parser.getAttributeName(i); |
336 |
if( attrname.equalsIgnoreCase(CLASS_NAME_TAG)) {
|
|
353 |
if (attrname.equalsIgnoreCase(CLASS_NAME_TAG)) {
|
|
337 | 354 |
name = this.getAttributeValue(parser, i); |
338 |
} else if( attrname.equalsIgnoreCase(CLASS_NAMESPACE_TAG)) {
|
|
355 |
} else if (attrname.equalsIgnoreCase(CLASS_NAMESPACE_TAG)) {
|
|
339 | 356 |
namespace = this.getAttributeValue(parser, i); |
340 | 357 |
} else { |
341 |
throw new UnexpectedTagOrAttributeException(parser,attrname); |
|
358 |
throw new UnexpectedTagOrAttributeException(parser, attrname);
|
|
342 | 359 |
} |
343 | 360 |
} |
344 |
if( name == null) {
|
|
361 |
if (name == null) {
|
|
345 | 362 |
name = this.nextText(parser); |
346 | 363 |
} else { |
347 | 364 |
parser.nextTag(); |
... | ... | |
351 | 368 |
return dynClassName; |
352 | 369 |
} |
353 | 370 |
|
354 |
|
|
355 |
private void importDynField(XmlPullParser parser, DynClass dynClass, ClassLoader loader) throws XmlPullParserException, IOException {
|
|
371 |
private void importDynField(XmlPullParser parser, DynClass dynClass, |
|
372 |
ClassLoader loader) throws XmlPullParserException, IOException {
|
|
356 | 373 |
DynField field; |
357 | 374 |
List availableValues = null; |
358 | 375 |
Map values = new HashMap(); |
... | ... | |
361 | 378 |
// |
362 | 379 |
// Collect field attributes from tag attributes |
363 | 380 |
// |
364 |
for( int i=0; i<parser.getAttributeCount(); i++ ) { |
|
365 |
values.put(parser.getAttributeName(i), this.getAttributeValue(parser, i)); |
|
381 |
for (int i = 0; i < parser.getAttributeCount(); i++) { |
|
382 |
values.put(parser.getAttributeName(i), |
|
383 |
this.getAttributeValue(parser, i)); |
|
366 | 384 |
} |
367 | 385 |
parser.nextTag(); |
368 | 386 |
|
369 | 387 |
// |
370 | 388 |
// Collect field attributes from tags |
371 | 389 |
// |
372 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
373 |
parser.getName().equals(FIELD_TAG))) {
|
|
390 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
391 |
.getName().equals(FIELD_TAG))) { |
|
374 | 392 |
checkEndDocument(parser); |
375 | 393 |
|
376 | 394 |
parser.require(XmlPullParser.START_TAG, null, null); |
377 | 395 |
String name = parser.getName(); |
378 |
if( name.equalsIgnoreCase(FIELD_NAME_TAG)) {
|
|
396 |
if (name.equalsIgnoreCase(FIELD_NAME_TAG)) {
|
|
379 | 397 |
values.put(FIELD_NAME_TAG, this.nextText(parser)); |
380 |
|
|
381 |
} else if( name.equalsIgnoreCase(FIELD_DESCRIPTION_TAG)) {
|
|
398 |
|
|
399 |
} else if (name.equalsIgnoreCase(FIELD_DESCRIPTION_TAG)) {
|
|
382 | 400 |
values.put(FIELD_DESCRIPTION_TAG, this.nextText(parser)); |
383 | 401 |
|
384 |
} else if( name.equalsIgnoreCase(FIELD_TYPE_TAG)) {
|
|
402 |
} else if (name.equalsIgnoreCase(FIELD_TYPE_TAG)) {
|
|
385 | 403 |
values.put(FIELD_TYPE_TAG, this.nextText(parser)); |
386 |
|
|
387 |
} else if( name.equalsIgnoreCase(FIELD_SUBTYPE_TAG)) {
|
|
404 |
|
|
405 |
} else if (name.equalsIgnoreCase(FIELD_SUBTYPE_TAG)) {
|
|
388 | 406 |
values.put(FIELD_SUBTYPE_TAG, this.nextText(parser)); |
389 |
|
|
390 |
} else if( name.equalsIgnoreCase(FIELD_GROUP_TAG)) {
|
|
407 |
|
|
408 |
} else if (name.equalsIgnoreCase(FIELD_GROUP_TAG)) {
|
|
391 | 409 |
values.put(FIELD_GROUP_TAG, this.nextText(parser)); |
392 |
|
|
393 |
} else if( name.equalsIgnoreCase(FIELD_ORDER_TAG)) {
|
|
410 |
|
|
411 |
} else if (name.equalsIgnoreCase(FIELD_ORDER_TAG)) {
|
|
394 | 412 |
values.put(FIELD_ORDER_TAG, this.nextText(parser)); |
395 |
|
|
396 |
} else if( name.equalsIgnoreCase(FIELD_ISMANDATORY_TAG)) {
|
|
413 |
|
|
414 |
} else if (name.equalsIgnoreCase(FIELD_ISMANDATORY_TAG)) {
|
|
397 | 415 |
values.put(FIELD_ISMANDATORY_TAG, this.nextText(parser)); |
398 |
|
|
399 |
} else if( name.equalsIgnoreCase(FIELD_ISPERSISTENT_TAG)) {
|
|
416 |
|
|
417 |
} else if (name.equalsIgnoreCase(FIELD_ISPERSISTENT_TAG)) {
|
|
400 | 418 |
values.put(FIELD_ISPERSISTENT_TAG, this.nextText(parser)); |
401 |
|
|
402 |
} else if( name.equalsIgnoreCase(FIELD_MINVALUE_TAG)) {
|
|
419 |
|
|
420 |
} else if (name.equalsIgnoreCase(FIELD_MINVALUE_TAG)) {
|
|
403 | 421 |
values.put(FIELD_MINVALUE_TAG, this.nextText(parser)); |
404 |
|
|
405 |
} else if( name.equalsIgnoreCase(FIELD_MAXVALUE_TAG)) {
|
|
422 |
|
|
423 |
} else if (name.equalsIgnoreCase(FIELD_MAXVALUE_TAG)) {
|
|
406 | 424 |
values.put(FIELD_MAXVALUE_TAG, this.nextText(parser)); |
407 |
|
|
408 |
} else if( name.equalsIgnoreCase(FIELD_CLASSOFVALUE_TAG)) {
|
|
425 |
|
|
426 |
} else if (name.equalsIgnoreCase(FIELD_CLASSOFVALUE_TAG)) {
|
|
409 | 427 |
values.put(FIELD_CLASSOFVALUE_TAG, this.nextText(parser)); |
410 |
|
|
411 |
} else if( name.equalsIgnoreCase(FIELD_CLASSOFITEMS_TAG)) {
|
|
428 |
|
|
429 |
} else if (name.equalsIgnoreCase(FIELD_CLASSOFITEMS_TAG)) {
|
|
412 | 430 |
values.put(FIELD_CLASSOFITEMS_TAG, this.nextText(parser)); |
413 |
|
|
414 |
} else if( name.equalsIgnoreCase(FIELD_DEFAULTVALUE_TAG)) {
|
|
431 |
|
|
432 |
} else if (name.equalsIgnoreCase(FIELD_DEFAULTVALUE_TAG)) {
|
|
415 | 433 |
values.put(FIELD_DEFAULTVALUE_TAG, this.nextText(parser)); |
416 |
|
|
417 |
} else if( name.equalsIgnoreCase(FIELD_HIDDEN_TAG)) {
|
|
434 |
|
|
435 |
} else if (name.equalsIgnoreCase(FIELD_HIDDEN_TAG)) {
|
|
418 | 436 |
values.put(FIELD_HIDDEN_TAG, this.nextText(parser)); |
419 |
|
|
420 |
} else if( name.equalsIgnoreCase(FIELD_AVALILABLEVALUES_TAG)) {
|
|
437 |
|
|
438 |
} else if (name.equalsIgnoreCase(FIELD_AVALILABLEVALUES_TAG)) {
|
|
421 | 439 |
parser.nextTag(); |
422 | 440 |
availableValues = new ArrayList(); |
423 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
424 |
parser.getName().equals(FIELD_AVALILABLEVALUES_TAG))) {
|
|
441 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
442 |
.getName().equals(FIELD_AVALILABLEVALUES_TAG))) { |
|
425 | 443 |
checkEndDocument(parser); |
426 | 444 |
availableValues.add(importValueItem(parser)); |
427 | 445 |
parser.nextTag(); |
428 | 446 |
} |
429 |
|
|
447 |
|
|
430 | 448 |
} else { |
431 | 449 |
break; |
432 | 450 |
} |
... | ... | |
435 | 453 |
} |
436 | 454 |
parser.require(XmlPullParser.END_TAG, null, FIELD_TAG); |
437 | 455 |
|
438 |
|
|
439 |
if( values.get(FIELD_NAME_TAG)==null ) { |
|
440 |
throw new NeedTagOrAttributeException(parser,FIELD_NAME_TAG); |
|
456 |
if (values.get(FIELD_NAME_TAG) == null) { |
|
457 |
throw new NeedTagOrAttributeException(parser, FIELD_NAME_TAG); |
|
441 | 458 |
} |
442 | 459 |
|
443 | 460 |
// |
444 | 461 |
// Create the field |
445 | 462 |
// |
446 |
field = dynClass.addDynField((String)values.get(FIELD_NAME_TAG)); |
|
447 |
|
|
463 |
field = dynClass.addDynField((String) values.get(FIELD_NAME_TAG));
|
|
464 |
|
|
448 | 465 |
// |
449 |
// Load values in the field
|
|
466 |
// Setting type and subtype first
|
|
450 | 467 |
// |
468 |
|
|
469 |
String name = FIELD_TYPE_TAG; |
|
470 |
String value = (String) values.get(name); |
|
471 |
if (value != null) { |
|
472 |
int type = ToolsLocator.getDataTypesManager().getType(value); |
|
473 |
if (type == DataTypes.INVALID) { |
|
474 |
throw new InvalidFieldTypeException(parser, value); |
|
475 |
} |
|
476 |
field.setType(type); |
|
477 |
name = FIELD_CLASSOFVALUE_TAG; |
|
478 |
value = (String) values.get(name); |
|
479 |
if (value != null) { |
|
480 |
try { |
|
481 |
Class klass; |
|
482 |
LOG.info("Intentando cargar clase '" + value + "'."); |
|
483 |
klass = Class.forName(value, true, loader); |
|
484 |
field.setClassOfValue(klass); |
|
485 |
} catch (DynFieldIsNotAContainerException e) { |
|
486 |
LOG.warn("No se ha encontrado la clase '" + value + "'.", e); |
|
487 |
throw new IncompatibleAttributeValueException(parser, |
|
488 |
FIELD_NAME_TAG); |
|
489 |
} catch (ClassNotFoundException e) { |
|
490 |
LOG.warn("No se ha encontrado la clase '" + value + "'.", e); |
|
491 |
throw new CantLocateClassException(parser, FIELD_NAME_TAG); |
|
492 |
} |
|
493 |
} |
|
494 |
name = FIELD_CLASSOFITEMS_TAG; |
|
495 |
value = (String) values.get(name); |
|
496 |
if (value != null) { |
|
497 |
try { |
|
498 |
Class klass; |
|
499 |
klass = Class.forName(value, true, loader); |
|
500 |
field.setClassOfValue(klass); |
|
501 |
} catch (DynFieldIsNotAContainerException e) { |
|
502 |
throw new IncompatibleAttributeValueException(parser, |
|
503 |
FIELD_NAME_TAG); |
|
504 |
} catch (ClassNotFoundException e) { |
|
505 |
throw new CantLocateClassException(parser, FIELD_NAME_TAG); |
|
506 |
} |
|
507 |
} |
|
508 |
} |
|
509 |
|
|
510 |
name = FIELD_SUBTYPE_TAG; |
|
511 |
value = (String) values.get(name); |
|
512 |
if (value != null) { |
|
513 |
try { |
|
514 |
field.setSubtype(value); |
|
515 |
} catch (IllegalArgumentException e) { |
|
516 |
// Ignore exception |
|
517 |
} |
|
518 |
} |
|
519 |
|
|
520 |
// |
|
521 |
// Load other values in the field |
|
522 |
// |
|
451 | 523 |
Iterator names = values.keySet().iterator(); |
452 |
while( names.hasNext() ) {
|
|
453 |
String name = (String) names.next();
|
|
454 |
String value = (String)values.get(name);
|
|
455 |
if( value == null ) {
|
|
524 |
while (names.hasNext()) {
|
|
525 |
name = (String) names.next(); |
|
526 |
value = (String) values.get(name);
|
|
527 |
if (value == null) {
|
|
456 | 528 |
continue; |
457 | 529 |
} |
458 |
if( name.equalsIgnoreCase(FIELD_NAME_TAG)) {
|
|
530 |
if (name.equalsIgnoreCase(FIELD_NAME_TAG)) {
|
|
459 | 531 |
// Do nothing |
460 | 532 |
|
461 |
} else if( name.equalsIgnoreCase(FIELD_DESCRIPTION_TAG)) {
|
|
533 |
} else if (name.equalsIgnoreCase(FIELD_DESCRIPTION_TAG)) {
|
|
462 | 534 |
field.setDescription(value); |
463 | 535 |
|
464 |
} else if( name.equalsIgnoreCase(FIELD_TYPE_TAG)) { |
|
465 |
int type = ToolsLocator.getDataTypesManager().getType(value); |
|
466 |
if( type == DataTypes.INVALID ) { |
|
467 |
throw new InvalidFieldTypeException(parser, value); |
|
468 |
} |
|
469 |
field.setType( type ); |
|
470 |
name = FIELD_CLASSOFVALUE_TAG; |
|
471 |
value = (String)values.get(name); |
|
472 |
if( value!=null ) { |
|
473 |
try { |
|
474 |
Class klass ; |
|
475 |
LOG.info("Intentando cargar clase '"+value+"'."); |
|
476 |
klass = Class.forName(value, true, loader); |
|
477 |
field.setClassOfValue( klass ); |
|
478 |
} catch (DynFieldIsNotAContainerException e) { |
|
479 |
LOG.warn("No se ha encontrado la clase '"+value+"'.",e); |
|
480 |
throw new IncompatibleAttributeValueException(parser, FIELD_NAME_TAG); |
|
481 |
} catch (ClassNotFoundException e) { |
|
482 |
LOG.warn("No se ha encontrado la clase '"+value+"'.",e); |
|
483 |
throw new CantLocateClassException(parser, FIELD_NAME_TAG); |
|
484 |
} |
|
485 |
} |
|
486 |
name = FIELD_CLASSOFITEMS_TAG; |
|
487 |
value = (String)values.get(name); |
|
488 |
if( value!=null ) { |
|
489 |
try { |
|
490 |
Class klass ; |
|
491 |
klass = Class.forName(value, true, loader); |
|
492 |
field.setClassOfValue( klass ); |
|
493 |
} catch (DynFieldIsNotAContainerException e) { |
|
494 |
throw new IncompatibleAttributeValueException(parser, FIELD_NAME_TAG); |
|
495 |
} catch (ClassNotFoundException e) { |
|
496 |
throw new CantLocateClassException(parser, FIELD_NAME_TAG); |
|
497 |
} |
|
498 |
} |
|
499 |
|
|
500 |
} else if( name.equalsIgnoreCase(FIELD_SUBTYPE_TAG)) { |
|
501 |
field.setSubtype(value); |
|
502 |
|
|
503 |
} else if( name.equalsIgnoreCase(FIELD_GROUP_TAG)) { |
|
536 |
} else if (name.equalsIgnoreCase(FIELD_TYPE_TAG)) { |
|
537 |
// Do nothing |
|
538 |
} else if (name.equalsIgnoreCase(FIELD_SUBTYPE_TAG)) { |
|
539 |
// Do nothing |
|
540 |
} else if (name.equalsIgnoreCase(FIELD_GROUP_TAG)) { |
|
504 | 541 |
field.setGroup(value); |
505 |
|
|
506 |
} else if( name.equalsIgnoreCase(FIELD_ORDER_TAG)) {
|
|
507 |
field.setOrder( Integer.parseInt(value));
|
|
508 |
|
|
509 |
} else if( name.equalsIgnoreCase(FIELD_ISMANDATORY_TAG)) {
|
|
542 |
|
|
543 |
} else if (name.equalsIgnoreCase(FIELD_ORDER_TAG)) {
|
|
544 |
field.setOrder(Integer.parseInt(value)); |
|
545 |
|
|
546 |
} else if (name.equalsIgnoreCase(FIELD_ISMANDATORY_TAG)) {
|
|
510 | 547 |
field.setMandatory(new Boolean(value).booleanValue()); |
511 |
|
|
512 |
} else if( name.equalsIgnoreCase(FIELD_ISPERSISTENT_TAG)) {
|
|
548 |
|
|
549 |
} else if (name.equalsIgnoreCase(FIELD_ISPERSISTENT_TAG)) {
|
|
513 | 550 |
field.setPersistent(new Boolean(value).booleanValue()); |
514 |
|
|
515 |
} else if( name.equalsIgnoreCase(FIELD_HIDDEN_TAG)) {
|
|
551 |
|
|
552 |
} else if (name.equalsIgnoreCase(FIELD_HIDDEN_TAG)) {
|
|
516 | 553 |
field.setHidden(new Boolean(value).booleanValue()); |
517 |
|
|
518 |
} else if( name.equalsIgnoreCase(FIELD_MINVALUE_TAG)) {
|
|
554 |
|
|
555 |
} else if (name.equalsIgnoreCase(FIELD_MINVALUE_TAG)) {
|
|
519 | 556 |
// Do nothing |
520 |
|
|
521 |
} else if( name.equalsIgnoreCase(FIELD_MAXVALUE_TAG)) {
|
|
557 |
|
|
558 |
} else if (name.equalsIgnoreCase(FIELD_MAXVALUE_TAG)) {
|
|
522 | 559 |
// Do nothing |
523 |
|
|
524 |
} else if( name.equalsIgnoreCase(FIELD_DEFAULTVALUE_TAG)) {
|
|
560 |
|
|
561 |
} else if (name.equalsIgnoreCase(FIELD_DEFAULTVALUE_TAG)) {
|
|
525 | 562 |
// Do nothing |
526 |
|
|
527 |
} else if( name.equalsIgnoreCase(FIELD_AVALILABLEVALUES_TAG)) {
|
|
563 |
|
|
564 |
} else if (name.equalsIgnoreCase(FIELD_AVALILABLEVALUES_TAG)) {
|
|
528 | 565 |
// Do nothing |
529 | 566 |
|
530 |
} else if( name.equalsIgnoreCase(FIELD_CLASSOFVALUE_TAG)) {
|
|
567 |
} else if (name.equalsIgnoreCase(FIELD_CLASSOFVALUE_TAG)) {
|
|
531 | 568 |
// Do nothing |
532 | 569 |
|
533 |
} else if( name.equalsIgnoreCase(FIELD_CLASSOFITEMS_TAG)) {
|
|
570 |
} else if (name.equalsIgnoreCase(FIELD_CLASSOFITEMS_TAG)) {
|
|
534 | 571 |
// Do nothing |
535 | 572 |
|
536 | 573 |
} else { |
537 |
throw new UnexpectedTagOrAttributeException(parser,name); |
|
574 |
throw new UnexpectedTagOrAttributeException(parser, name);
|
|
538 | 575 |
} |
539 | 576 |
} |
540 | 577 |
|
... | ... | |
543 | 580 |
// Coerce the min/max/default/available values to the type of |
544 | 581 |
// the field |
545 | 582 |
// |
546 |
if( availableValues!= null && !availableValues.isEmpty() ) {
|
|
583 |
if (availableValues != null && !availableValues.isEmpty()) {
|
|
547 | 584 |
for (int i = 0; i < availableValues.size(); i++) { |
548 |
PairValueLabel pair = (PairValueLabel) availableValues.get(i); |
|
585 |
PairValueLabel pair = (PairValueLabel) availableValues |
|
586 |
.get(i); |
|
549 | 587 |
if (pair.label == null) { |
550 | 588 |
if (pair.value == null) { |
551 | 589 |
pair.label = "null"; |
... | ... | |
553 | 591 |
pair.label = pair.value.toString(); |
554 | 592 |
} |
555 | 593 |
} |
556 |
availableValues.set(i, new DynObjectValueItem(field.coerce(pair.value), pair.label)); |
|
594 |
availableValues.set(i, |
|
595 |
new DynObjectValueItem(field.coerce(pair.value), |
|
596 |
pair.label)); |
|
557 | 597 |
} |
558 | 598 |
field.setAvailableValues(availableValues); |
559 | 599 |
} |
560 | 600 |
field.setMaxValue(field.coerce(values.get(FIELD_MAXVALUE_TAG))); |
561 | 601 |
field.setMinValue(field.coerce(values.get(FIELD_MINVALUE_TAG))); |
562 |
field.setDefaultFieldValue(field.coerce(values.get(FIELD_DEFAULTVALUE_TAG))); |
|
602 |
field.setDefaultFieldValue(field.coerce(values |
|
603 |
.get(FIELD_DEFAULTVALUE_TAG))); |
|
563 | 604 |
} catch (CoercionException e) { |
564 | 605 |
throw new ParseCoerceException(e, parser); |
565 | 606 |
} |
566 | 607 |
} |
567 | 608 |
|
568 | 609 |
private class PairValueLabel { |
569 |
String label=null;
|
|
570 |
String value=null;
|
|
610 |
String label = null;
|
|
611 |
String value = null;
|
|
571 | 612 |
} |
572 |
|
|
573 |
private PairValueLabel importValueItem(XmlPullParser parser) throws XmlPullParserException, IOException { |
|
613 |
|
|
614 |
private PairValueLabel importValueItem(XmlPullParser parser) |
|
615 |
throws XmlPullParserException, IOException { |
|
574 | 616 |
PairValueLabel pair = new PairValueLabel(); |
575 |
|
|
576 |
if( parser.getName().equalsIgnoreCase(VALUEITEM_TAG)) {
|
|
617 |
|
|
618 |
if (parser.getName().equalsIgnoreCase(VALUEITEM_TAG)) {
|
|
577 | 619 |
parser.require(XmlPullParser.START_TAG, null, VALUEITEM_TAG); |
578 |
for( int i=0; i<parser.getAttributeCount(); i++) {
|
|
620 |
for (int i = 0; i < parser.getAttributeCount(); i++) {
|
|
579 | 621 |
String name = parser.getAttributeName(i); |
580 |
if( name.equalsIgnoreCase(VALUEITEM_LABEL_TAG)) {
|
|
581 |
pair.label = this.getAttributeValue(parser,i); |
|
582 |
} else if( name.equalsIgnoreCase(VALUEITEM_VALUE_TAG)) {
|
|
583 |
pair.value = this.getAttributeValue(parser,i); |
|
622 |
if (name.equalsIgnoreCase(VALUEITEM_LABEL_TAG)) {
|
|
623 |
pair.label = this.getAttributeValue(parser, i);
|
|
624 |
} else if (name.equalsIgnoreCase(VALUEITEM_VALUE_TAG)) {
|
|
625 |
pair.value = this.getAttributeValue(parser, i);
|
|
584 | 626 |
} else { |
585 |
throw new UnexpectedTagOrAttributeException(parser,name); |
|
627 |
throw new UnexpectedTagOrAttributeException(parser, name);
|
|
586 | 628 |
} |
587 | 629 |
} |
588 | 630 |
parser.nextTag(); |
589 |
|
|
590 |
while ( !( parser.getEventType() == XmlPullParser.END_TAG &&
|
|
591 |
parser.getName().equals(VALUEITEM_TAG))) {
|
|
631 |
|
|
632 |
while (!(parser.getEventType() == XmlPullParser.END_TAG && parser
|
|
633 |
.getName().equals(VALUEITEM_TAG))) { |
|
592 | 634 |
checkEndDocument(parser); |
593 | 635 |
parser.require(XmlPullParser.START_TAG, null, null); |
594 | 636 |
String name = parser.getName(); |
595 |
if( name.equalsIgnoreCase(VALUEITEM_LABEL_TAG)) {
|
|
637 |
if (name.equalsIgnoreCase(VALUEITEM_LABEL_TAG)) {
|
|
596 | 638 |
pair.label = this.nextText(parser); |
597 |
} else if( name.equalsIgnoreCase(VALUEITEM_VALUE_TAG)) {
|
|
639 |
} else if (name.equalsIgnoreCase(VALUEITEM_VALUE_TAG)) {
|
|
598 | 640 |
pair.value = this.nextText(parser); |
599 | 641 |
} else { |
600 | 642 |
break; |
... | ... | |
605 | 647 |
parser.require(XmlPullParser.END_TAG, null, VALUEITEM_TAG); |
606 | 648 |
} else { |
607 | 649 |
parser.require(XmlPullParser.START_TAG, null, VALUEITEM_VALUE_TAG); |
608 |
for( int i=0; i<parser.getAttributeCount(); i++) {
|
|
650 |
for (int i = 0; i < parser.getAttributeCount(); i++) {
|
|
609 | 651 |
String name = parser.getAttributeName(i); |
610 |
if( name.equalsIgnoreCase(VALUEITEM_LABEL_TAG)) {
|
|
652 |
if (name.equalsIgnoreCase(VALUEITEM_LABEL_TAG)) {
|
|
611 | 653 |
pair.label = parser.getAttributeValue(i); |
612 | 654 |
} else { |
613 |
throw new UnexpectedTagOrAttributeException(parser,name); |
|
655 |
throw new UnexpectedTagOrAttributeException(parser, name);
|
|
614 | 656 |
} |
615 | 657 |
} |
616 | 658 |
pair.value = parser.nextText(); |
... | ... | |
618 | 660 |
} |
619 | 661 |
return pair; |
620 | 662 |
} |
621 |
|
|
622 |
private void checkEndDocument(XmlPullParser parser) throws XmlPullParserException { |
|
663 |
|
|
664 |
private void checkEndDocument(XmlPullParser parser) |
|
665 |
throws XmlPullParserException { |
|
623 | 666 |
if (parser.getEventType() == XmlPullParser.END_DOCUMENT) { |
624 |
throw new UnexpectedTagOrAttributeException(parser,"(end-of-document)"); |
|
667 |
throw new UnexpectedTagOrAttributeException(parser, |
|
668 |
"(end-of-document)"); |
|
625 | 669 |
} |
626 | 670 |
|
627 | 671 |
} |
628 | 672 |
|
629 |
|
|
630 |
public static abstract class ImportDynClassesException extends BaseRuntimeException {
|
|
673 |
public static abstract class ImportDynClassesException extends |
|
674 |
BaseRuntimeException {
|
|
631 | 675 |
|
632 | 676 |
/** |
633 | 677 |
* |
634 | 678 |
*/ |
635 |
private static final long serialVersionUID = 3346283395112730192L;
|
|
636 |
|
|
679 |
private static final long serialVersionUID = 3346283395112730192L; |
|
680 |
|
|
637 | 681 |
/** |
638 | 682 |
* Don't call this constructor form subclasses. |
639 | 683 |
* |
... | ... | |
641 | 685 |
*/ |
642 | 686 |
public ImportDynClassesException(XmlPullParser parser) { |
643 | 687 |
super( |
644 |
"Error importing classes from file at line %(line) column %(column).", |
|
645 |
"_Error_importing_classes_from_file_at_line_XlineX_column_XcolumnX", |
|
646 |
serialVersionUID |
|
647 |
); |
|
688 |
"Error importing classes from file at line %(line) column %(column).", |
|
689 |
"_Error_importing_classes_from_file_at_line_XlineX_column_XcolumnX", |
|
690 |
serialVersionUID); |
|
648 | 691 |
} |
649 |
|
|
650 |
protected ImportDynClassesException(XmlPullParser parser, String msg, String key, long code) { |
|
692 |
|
|
693 |
protected ImportDynClassesException(XmlPullParser parser, String msg, |
|
694 |
String key, long code) { |
|
651 | 695 |
super( |
652 |
"Error importing classes from file at line %(line) column %(column). "+msg, |
|
653 |
key, |
|
654 |
code |
|
655 |
); |
|
656 |
this.setValue("line",new Integer(parser.getLineNumber())); |
|
657 |
this.setValue("column",new Integer(parser.getColumnNumber())); |
|
696 |
"Error importing classes from file at line %(line) column %(column). " |
|
697 |
+ msg, key, code); |
|
698 |
this.setValue("line", new Integer(parser.getLineNumber())); |
|
699 |
this.setValue("column", new Integer(parser.getColumnNumber())); |
|
658 | 700 |
} |
659 | 701 |
} |
660 |
|
|
661 |
public static class DuplicateDynClassException extends ImportDynClassesException { |
|
702 |
|
|
703 |
public static class DuplicateDynClassException extends |
|
704 |
ImportDynClassesException { |
|
662 | 705 |
/** |
663 | 706 |
* |
664 | 707 |
*/ |
665 | 708 |
private static final long serialVersionUID = 3653024321140806121L; |
666 | 709 |
|
667 | 710 |
public DuplicateDynClassException(XmlPullParser parser, String name) { |
668 |
super( |
|
669 |
parser, |
|
670 |
"Duplicate DynClass definition for '%(name)'.", |
|
671 |
"_Duplicate_DynClass_definition_for_XnameX", |
|
672 |
serialVersionUID |
|
673 |
); |
|
711 |
super(parser, "Duplicate DynClass definition for '%(name)'.", |
|
712 |
"_Duplicate_DynClass_definition_for_XnameX", |
|
713 |
serialVersionUID); |
|
674 | 714 |
this.setValue("name", name); |
675 | 715 |
} |
676 | 716 |
} |
677 |
|
|
678 |
public static class InvalidFieldTypeException extends ImportDynClassesException { |
|
679 | 717 |
|
718 |
public static class InvalidFieldTypeException extends |
|
719 |
ImportDynClassesException { |
|
720 |
|
|
680 | 721 |
/** |
681 | 722 |
* |
682 | 723 |
*/ |
683 | 724 |
private static final long serialVersionUID = 8501343258053356775L; |
684 | 725 |
|
685 | 726 |
public InvalidFieldTypeException(XmlPullParser parser, String value) { |
686 |
super( |
|
687 |
parser, |
|
688 |
"Invalid field type '%(value)'.", |
|
689 |
"_Invalid_field_type_XvalueX", |
|
690 |
serialVersionUID |
|
691 |
); |
|
727 |
super(parser, "Invalid field type '%(value)'.", |
|
728 |
"_Invalid_field_type_XvalueX", serialVersionUID); |
|
692 | 729 |
this.setValue("value", value); |
693 | 730 |
} |
694 | 731 |
} |
695 |
|
|
696 |
public static class UnexpectedTagOrAttributeException extends ImportDynClassesException { |
|
732 |
|
|
733 |
public static class UnexpectedTagOrAttributeException extends |
|
734 |
ImportDynClassesException { |
|
697 | 735 |
/** |
698 | 736 |
* |
699 | 737 |
*/ |
700 | 738 |
private static final long serialVersionUID = -808282903423455613L; |
701 | 739 |
|
702 |
public UnexpectedTagOrAttributeException(XmlPullParser parser, String tag) { |
|
703 |
super( |
|
704 |
parser, |
|
705 |
"Unexpected tag or attribute '%(tag)'.", |
|
706 |
"_Unexpected_tag_or_attribute_XtagX", |
|
707 |
serialVersionUID |
|
708 |
); |
|
740 |
public UnexpectedTagOrAttributeException(XmlPullParser parser, |
|
741 |
String tag) { |
|
742 |
super(parser, "Unexpected tag or attribute '%(tag)'.", |
|
743 |
"_Unexpected_tag_or_attribute_XtagX", serialVersionUID); |
|
709 | 744 |
this.setValue("tag", tag); |
710 |
}
|
|
745 |
} |
|
711 | 746 |
} |
712 |
|
|
713 |
public static class NeedTagOrAttributeException extends ImportDynClassesException { |
|
747 |
|
|
748 |
public static class NeedTagOrAttributeException extends |
|
749 |
ImportDynClassesException { |
|
714 | 750 |
/** |
715 | 751 |
* |
716 | 752 |
*/ |
717 | 753 |
private static final long serialVersionUID = -808282903423455613L; |
718 | 754 |
|
719 | 755 |
public NeedTagOrAttributeException(XmlPullParser parser, String tag) { |
720 |
super( |
|
721 |
parser, |
|
722 |
"Need tag or attribute '%(tag)'.", |
|
723 |
"_Need_tag_or_attribute_XtagX", |
|
724 |
serialVersionUID |
|
725 |
); |
|
756 |
super(parser, "Need tag or attribute '%(tag)'.", |
|
757 |
"_Need_tag_or_attribute_XtagX", serialVersionUID); |
|
726 | 758 |
this.setValue("tag", tag); |
727 |
}
|
|
759 |
} |
|
728 | 760 |
} |
729 |
|
|
730 |
public static class CantLocateClassException extends ImportDynClassesException { |
|
761 |
|
|
762 |
public static class CantLocateClassException extends |
|
763 |
ImportDynClassesException { |
|
731 | 764 |
/** |
732 | 765 |
* |
733 | 766 |
*/ |
734 | 767 |
private static final long serialVersionUID = 5733585544096433612L; |
735 | 768 |
|
736 |
public CantLocateClassException(XmlPullParser parser, String tagname) { |
|
737 |
super( |
|
738 |
parser, |
|
739 |
"Can't locate class '%(name).", |
|
740 |
"_Cant_locate_class_XnameX", |
|
741 |
serialVersionUID |
|
742 |
); |
|
769 |
public CantLocateClassException(XmlPullParser parser, String tagname) { |
|
770 |
super(parser, "Can't locate class '%(name).", |
|
771 |
"_Cant_locate_class_XnameX", serialVersionUID); |
|
743 | 772 |
this.setValue("name", tagname); |
744 | 773 |
} |
745 | 774 |
} |
746 | 775 |
|
747 |
public static class CantLocateDynClassException extends ImportDynClassesException { |
|
776 |
public static class CantLocateDynClassException extends |
|
777 |
ImportDynClassesException { |
|
748 | 778 |
|
749 | 779 |
/** |
750 | 780 |
* |
751 | 781 |
*/ |
752 | 782 |
private static final long serialVersionUID = 6286170415562358806L; |
753 | 783 |
|
754 |
public CantLocateDynClassException(XmlPullParser parser, String tagname) { |
|
755 |
super( |
|
756 |
parser, |
|
784 |
public CantLocateDynClassException(XmlPullParser parser, String tagname) { |
|
785 |
super(parser, |
|
757 | 786 |
"Can't locate DynClass '%(name). Look at the extends tag.", |
758 |
"_Cant_locate_DynClass_XnameX", |
|
759 |
serialVersionUID |
|
760 |
); |
|
787 |
"_Cant_locate_DynClass_XnameX", serialVersionUID); |
|
761 | 788 |
this.setValue("name", tagname); |
762 | 789 |
} |
763 | 790 |
} |
764 | 791 |
|
765 |
public static class IncompatibleAttributeValueException extends ImportDynClassesException { |
|
792 |
public static class IncompatibleAttributeValueException extends |
|
793 |
ImportDynClassesException { |
|
766 | 794 |
/** |
767 | 795 |
* |
768 | 796 |
*/ |
769 | 797 |
private static final long serialVersionUID = 2646530094487375049L; |
770 | 798 |
|
771 |
public IncompatibleAttributeValueException(XmlPullParser parser, String name) { |
|
772 |
super( |
|
773 |
parser, |
|
774 |
"incompatible attribute value for field '%(name).", |
|
799 |
public IncompatibleAttributeValueException(XmlPullParser parser, |
|
800 |
String name) { |
|
801 |
super(parser, "incompatible attribute value for field '%(name).", |
|
775 | 802 |
"_Incompatible_attribute_value_for_field_XnameX", |
776 |
serialVersionUID |
|
777 |
); |
|
803 |
serialVersionUID); |
|
778 | 804 |
this.setValue("name", name); |
779 | 805 |
} |
780 | 806 |
} |
781 | 807 |
|
782 |
public static class ParseCoerceException extends ImportDynClassesException {
|
|
808 |
public static class ParseCoerceException extends ImportDynClassesException { |
|
783 | 809 |
|
784 | 810 |
/** |
785 | 811 |
* |
786 | 812 |
*/ |
787 | 813 |
private static final long serialVersionUID = 1447718822981628834L; |
788 | 814 |
|
789 |
public ParseCoerceException(Throwable cause, XmlPullParser parser) { |
|
790 |
super( |
|
791 |
parser, |
|
792 |
"Can't convert value.", |
|
793 |
"_Cant_convert_value", |
|
794 |
serialVersionUID |
|
795 |
); |
|
815 |
public ParseCoerceException(Throwable cause, XmlPullParser parser) { |
|
816 |
super(parser, "Can't convert value.", "_Cant_convert_value", |
|
817 |
serialVersionUID); |
|
796 | 818 |
this.initCause(cause); |
797 | 819 |
} |
798 | 820 |
} |
799 | 821 |
|
800 |
public static class WrongVersionException extends ImportDynClassesException {
|
|
822 |
public static class WrongVersionException extends ImportDynClassesException { |
|
801 | 823 |
|
802 | 824 |
private static final long serialVersionUID = 6620589308398698367L; |
803 | 825 |
|
804 |
public WrongVersionException(XmlPullParser parser) { |
|
805 |
super( |
|
806 |
parser, |
|
807 |
"Wrong format version.", |
|
808 |
"_Wrong_format_version", |
|
809 |
serialVersionUID |
|
810 |
); |
|
826 |
public WrongVersionException(XmlPullParser parser) { |
|
827 |
super(parser, "Wrong format version.", "_Wrong_format_version", |
|
828 |
serialVersionUID); |
|
811 | 829 |
} |
812 | 830 |
} |
813 | 831 |
|
814 |
|
|
815 | 832 |
} |
Also available in: Unified diff