Statistics
| Revision:

root / branches / v2_0_0_prep / libraries / libIverUtiles / src / com / iver / utiles / extensionPointsOld / ExtensionPoint.java @ 26870

History | View | Annotate | Download (7.51 KB)

1
package com.iver.utiles.extensionPointsOld;
2

    
3
import java.lang.reflect.InvocationTargetException;
4
import java.security.KeyException;
5
import java.util.*;
6

    
7
/**
8
 * Esta clase permite registrar extensiones para un punto de extension. <br>
9
 * <br>
10
 * La clase se comporta como un Map que mantiene el orden de insercion de los
11
 * elementos, para que puedan ser recorridos en ese orden. <br>
12
 * Ademas de registrar las extensiones para un punto de extension, presenta
13
 * metodos para facilitar la creacion de la extension. <br>
14
 * A la hora de registrar una extension, mediante el metodo <i>put</i>, podremos
15
 * suministrarle una clase o una instancia que implemente el interface
16
 * IExtensionBuilder. Si le suministramos una clase, cuando queramos crear la
17
 * extension mediante el metodo <i>create</i>, se creara una instancia de la
18
 * clase y se retornara. Si lo que se suministro fue una instancia que
19
 * implementa el interface IExtensionBuilder, se invocara al metodo
20
 * <i>create</i> de esta para crear la extension. <br>
21
 * 
22
 * @author jjdelcerro
23
 * 
24
 * @deprecated @see org.gvsig.tools.extensionPoint.ExtensionPoint
25
 */
26
public class ExtensionPoint extends LinkedHashMap {
27

    
28
    private static final long serialVersionUID = -5908427725588553371L;
29

    
30
        private String name;
31
        private String description;
32
        private Hashtable extensionDescriptions = new Hashtable();
33
        private Hashtable aliases = new Hashtable();
34

    
35
        /**
36
         * Construye un punto de extension.
37
         * <br>
38
         * @param extensionPointName Nombre del punto de extension.
39
         */
40
        public ExtensionPoint(String extensionPointName) {
41
                this.name = extensionPointName;
42
        }
43
        
44
        /**
45
         * Construye un punto de extension.
46
         * <br>
47
         * @param extensionPointName Nombre del punto de extension
48
         * @param description Descripcion del punto de extension
49
         */
50
        public ExtensionPoint(String extensionPointName, String description) {
51
                this.name = extensionPointName;
52
                this.description = description;
53
        }
54
        
55
        /**
56
         * Retorna el nombre de punto de extension.
57
         * <br>
58
         * @return Nombre del punto de extension
59
         */
60
        public String getName() {
61
                return this.name;
62
        }
63
        
64
        /**
65
         * Retorna la descripcion asociada al punto de extension.
66
         * <br>
67
         * @return descripcion del punto de extension
68
         */
69
        public String getDescription() {
70
                return this.description;
71
        }
72
        
73
        /**
74
         * Asocia una descripcion al punto de extension.
75
         * <br>
76
         * 
77
         * @param description
78
         */
79
        public void setDescripcion(String description) {
80
                this.description = description;
81
        }
82
        
83
        /**
84
         * Retorna la descripcion asociada a una extension.
85
         * <br>
86
         * @param key 
87
         * <br>
88
         * @return descripcion del punto de extension
89
         */
90
        public String getExtensionDescription(String key) {
91
                return (String)this.extensionDescriptions.get(key);
92
        }
93
        
94
        /**
95
         * Asocia una descripcion a una extension registrada.
96
         * <br>
97
         * 
98
         * @param key Nombre de la extension
99
         * @param description
100
         */        
101
        public void setExtensionDescription(String key,String description) {
102
                if (this.containsKey(key)) {
103
                        this.extensionDescriptions.put(key,description);
104
                }
105
        }
106
        
107
        /**
108
         * A?ade una extension con su descripcion asociada
109
         * 
110
         * @param key clave de la extension
111
         * @param decription descripcion de la extension
112
         * @param value extension
113
         */
114
        
115
        public Object put(String key, String description,Object value) {                
116
                this.extensionDescriptions.put(key,description);
117
                return super.put(key,value);
118
        }
119

    
120
        /**
121
         * A?ade una extension antes de la indicada con beforeKey,
122
         * con su descripcion asociada
123
         * 
124
         * @param key clave de la extension
125
         * @param decription descripcion de la extension
126
         * @param value extension
127
         */
128
        
129
        public Object insert(String beforeKey, String key, String description,Object value) {                
130
                boolean mover = false;
131
                Map tmp = new LinkedHashMap();
132

    
133
                for (Iterator i = this.entrySet().iterator(); i.hasNext(); ) {
134
            Map.Entry e = (Map.Entry)i.next();
135
            if ( e.getKey().equals(beforeKey) ) {
136
                    mover = true;
137
            }
138
            if( mover ) {
139
                    tmp.put(e.getKey(), e.getValue());
140
            }
141
        }
142
                for (Iterator i = tmp.keySet().iterator(); i.hasNext(); ) {
143
                        String key1 = (String)i.next();
144
                        this.remove(key1);
145
                }
146
                if ( description!= null ) {
147
                        this.extensionDescriptions.put(key,description);
148
                }
149
                Object returnValue = super.put(key,value);
150
                this.putAll(tmp);
151
                return returnValue;
152
        }
153
        
154
        /**
155
         * Crea una extension.
156
         * <br>
157
         * Dado un nombre de extension asociada a este punto de extension, crea
158
         * el objeto registrado para manejar la extension.
159
         * <br>
160
         * Si el objeto registrado para esa extension implementa el interface
161
         * <i>IExtensionBuilder</i>, se invoca al metodo create para crear la instancia
162
         * de la extension. 
163
         * <br>
164
         * Si no implementa este interface, debera ser una clase, y se creara una
165
         * instancia de esa clase.
166
         * <br>
167
         * @param name Nombre de la extension a crear.
168
         * @return La instancia creada de la extension.
169
         * 
170
         * @throws InstantiationException
171
         * @throws IllegalAccessException
172
         */
173
        public Object create(String name) throws InstantiationException, IllegalAccessException {
174
                Object extension = this.get(name);
175
                if (extension == null) {
176
                        extension = this.get(this.aliases.get(name));
177
                }
178
                
179
                if( extension instanceof IExtensionBuilder ) {
180
                        return ((IExtensionBuilder)extension).create();
181
                }
182
                return ExtensionBuilder.create((Class) extension);
183
        }
184
        
185
        /**
186
         * Crea una extension.
187
         * <br>
188
         * Dado un nombre de extension asociada a este punto de extension, crea
189
         * el objeto registrado para manejar la extension.
190
         * <br>
191
         * A la hora de crear la instancia de la extension, le pasara los parametros
192
         * indicados en <i>args</i>.
193
         * <br>
194
         * Debido a que los argumentos se pasan como un array de objetos, no es posible
195
         * pasar al constructor de la extension parametros de tipos basicos como <i>int</i>
196
         * o <i>long</i>. Se deberan pasar como objetos y existir un constructor de la clase
197
         * que los pueda recibir de esta manera.
198
         * <br>
199
         * @param name Nombre de la extension a crear.
200
         * @param args Array de objetos a pasar como parametros en la construccion de la instancia de la extension.
201
         * @return La instancia creada de la extension.
202
         * 
203
         * @throws SecurityException
204
         * @throws NoSuchMethodException
205
         * @throws IllegalArgumentException
206
         * @throws InstantiationException
207
         * @throws IllegalAccessException
208
         * @throws InvocationTargetException
209
         */
210
        public Object create(String name, Object [] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
211
                Object extension = this.get(name);
212
                if (extension == null) {
213
                        extension = this.get(this.aliases.get(name));
214
                }
215
                
216
                if( extension instanceof IExtensionBuilder ) {
217
                        return ((IExtensionBuilder)extension).create(args);
218
                }
219
                return ExtensionBuilder.create((Class) extension, args);
220
        }        
221

    
222
        public Object create(String name, Map args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
223
                Object extension = this.get(name);
224
                if (extension == null) {
225
                        extension = this.get(this.aliases.get(name));
226
                }
227
                
228
                if( extension instanceof IExtensionBuilder ) {
229
                        return ((IExtensionBuilder)extension).create(args);
230
                }
231
                return ExtensionBuilder.create((Class) extension, args);
232
        }
233
        
234
        /**
235
         * Crea un alias para una extension registrada.
236
         * <br>
237
         * @param item Nombre de la extension registrada.
238
         * @param alias alias a a?adir.
239
         * 
240
         **/        
241
        public void addAlias(String item, String alias) throws KeyException{
242
                if (!this.containsKey(item)) {
243
                        throw new KeyException(item);
244
                }
245
                this.aliases.put(alias,item);                
246
        }
247
}