Statistics
| Revision:

gvsig-tools / org.gvsig.tools / library / trunk / org.gvsig.tools / org.gvsig.tools.lib / src / main / java / org / gvsig / tools / dynobject / exception / DynFieldValidateException.java @ 592

History | View | Annotate | Download (4.44 KB)

1
package org.gvsig.tools.dynobject.exception;
2

    
3
import org.gvsig.tools.ToolsLocator;
4
import org.gvsig.tools.dynobject.DynClass;
5
import org.gvsig.tools.dynobject.DynField;
6
import org.gvsig.tools.dynobject.DynObject;
7
import org.gvsig.tools.dynobject.DynStruct;
8

    
9
public class DynFieldValidateException extends DynMethodException {
10

    
11
        /**
12
         * 
13
         */
14
        private static final long serialVersionUID = -5033443492130842514L;
15
        private final static String MESSAGE_FORMAT = "Field '%(field)': Invalid value '%(value)'.";
16
        private final static String MESSAGE_KEY = "_Field_XfieldX_Invalid_value_XvalueX";
17

    
18
        protected DynFieldValidateException(String messagefmt, String key, long code) {
19
                super(messagefmt, key, code);
20
        }
21

    
22
        public DynFieldValidateException(Object value, DynField field,
23
                        Throwable cause) {
24
                super(MESSAGE_FORMAT, MESSAGE_KEY, serialVersionUID);
25
                if (cause != null) {
26
                        this.initCause(cause);
27
                }
28

    
29
                setValue("field", field.getName());
30
                setValue(value);
31
                if (field.getAvailableValues() != null) {
32
                        StringBuffer buffer = new StringBuffer();
33
                        buffer.append(ToolsLocator.getDataTypesManager().getTypeName(
34
                                        field.getType()));
35
                        buffer.append(" ( ");
36
                        for (int i = 0; i < field.getAvailableValues().length; i++) {
37
                                buffer.append(field.getAvailableValues()[i].getValue()
38
                                                .toString());
39
                                buffer.append(", ");
40
                        }
41
                        buffer.append(")");
42
                        setValue("fieldtype", buffer.toString());
43
                } else if (field.getMaxValue() != null && field.getMinValue() != null) {
44
                        setValue("fieldtype", ToolsLocator.getDataTypesManager()
45
                                        .getTypeName(field.getType())
46
                                        + "  (  "
47
                                        + field.getMinValue().toString()
48
                                        + " <= x <=  "
49
                                        + field.getMaxValue().toString() + ")");
50

    
51
                } else {
52
                        setValue("fieldtype", ToolsLocator.getDataTypesManager()
53
                                        .getTypeName(field.getType()));
54
                }
55
                if (value == null) {
56
                        setValue("valuetype", "null");
57
                } else {
58
                        setValue("valuetype", value.getClass().getName());
59
                }
60
        }
61

    
62
        private void setValue(Object value) {
63
                try {
64
                        if (value instanceof DynObject) {
65
                                // setValue("value", getDynObjectValueText((DynObject) value));
66
                                setValue("value",
67
                                                getDynClassValueText(((DynObject) value).getDynClass()));
68
                                return;
69
                        } else if (value instanceof DynClass) {
70
                                setValue("value", getDynClassValueText((DynStruct) value));
71
                                return;
72
                        } else if (value instanceof DynStruct) {
73
                                setValue("value", getDynClassValueText((DynStruct) value));
74
                                return;
75
                        }
76
                        if (value == null) {
77
                                setValue("value", "null");
78
                        } else {
79
                                setValue("value", value.toString());
80
                        }
81
                } catch (Exception e) {
82
                        setValue("value", "(unknow)");
83
                }
84
        }
85

    
86
        private String getDynClassValueText(DynStruct definition) {
87
                StringBuffer buffer = new StringBuffer();
88
                buffer.append(definition.getName()).append("\n  ");
89
                buffer.append("Mandatory values are: ");
90
                DynField[] fields = definition.getDynFields();
91
                if (fields == null || fields.length == 0) {
92
                        buffer.append("(none)\n");
93
                        return buffer.toString();
94
                }
95
                
96
                DynField field;
97
                String DEL = ",  ";
98
                StringBuffer items = new StringBuffer();
99
                
100
                buffer.append("[");
101
                for (int i = 0; i < fields.length; i++) {
102
                        field = fields[i];
103
                        if (field.isMandatory()) {
104
                                items.append(field.getName());
105
                                items.append(DEL);
106
                        }
107
                }
108
                buffer.append(items);
109
                buffer.append("]");
110
                
111
                return buffer.toString();
112
        }
113

    
114
        private String getDynObjectValueText(DynObject dynObject) {
115
                String space = "  ";
116
                StringBuffer buffer = new StringBuffer();
117
                buffer.append(dynObject.getDynClass().getName()).append("\n");
118
                DynField[] fields = dynObject.getDynClass().getDynFields();
119
                if (fields == null || fields.length == 0) {
120
                        return buffer.toString();
121
                }
122

    
123
                DynField field;
124
                buffer.append("(\n");
125
                for (int i = 0; i < fields.length; i++) {
126
                        field = fields[i];
127
                        Object value = null;
128
                        try {
129
                                value = dynObject.getDynValue(field.getName());
130
                                field.validate(value);
131
                        } catch (DynFieldValidateException ex) {
132
                                if (value instanceof DynObject) {
133
                                        buffer.append(space).append(
134
                                                        getDynObjectValueText((DynObject) value));
135
                                } else {
136
                                        buffer.append(space).append(ex.getLocalizedMessageStack());
137
                                }
138
                        } catch (DynFieldNotFoundException ex2) {
139
                                if (value instanceof DynObject) {
140
                                        buffer.append(space).append(
141
                                                        getDynObjectValueText((DynObject) value));
142
                                } else {
143
                                        buffer.append(space).append(ex2.getLocalizedMessageStack());
144
                                }
145
                        }
146
                }
147
                buffer.append(")");
148
                return buffer.toString();
149
        }
150

    
151
        public DynFieldValidateException(Object value, DynField field) {
152
                this(value, field, null);
153
        }
154
}