Statistics
| Revision:

gvsig-tools / org.gvsig.tools / library / trunk / org.gvsig.tools / org.gvsig.tools.lib / src / test / java / org / gvsig / tools / persistence / case1 / model / ModelManager.java @ 330

History | View | Annotate | Download (5.73 KB)

1
package org.gvsig.tools.persistence.case1.model;
2

    
3
import java.awt.Color;
4

    
5
import org.gvsig.tools.ToolsLocator;
6
import org.gvsig.tools.dynobject.DynStruct;
7
import org.gvsig.tools.persistence.PersistenceManager;
8
import org.gvsig.tools.persistence.exception.PersistenceClassNotRegistered;
9

    
10
public class ModelManager {
11

    
12
        private static ModelManager manager = null;
13
        
14
        public static ModelManager getManager() {
15
                if( manager != null ) {
16
                        return manager;
17
                }
18
                manager = new ModelManager();
19
                return manager;
20
        }
21
        
22
        AwtFactory awtFactory;
23
        ProjectionFactory projectionFactory;
24
        
25
        public Projection getDefaultProjection() {
26
                return new Projection();
27
        }
28
        
29
        public void registerPersistence() {
30
                
31
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
32
        
33
                this.awtFactory = new AwtFactory();
34
                this.projectionFactory = new ProjectionFactory();
35
                
36
                manager.registerFactory(        this.awtFactory);
37
                manager.registerFactory(this.projectionFactory);
38
                
39
                registerDocumentPersistence();
40
                registerLayerPersistence();
41
                registerLayersPersistence();
42
                registerMapContextPersistence();
43
                registerProjectPersistence();
44
                registerProjectExtentPersistence();
45
                registerViewPortPersistence();
46
        }
47
        
48
        public void unregisterPersistence() throws PersistenceClassNotRegistered {
49
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
50

    
51
                manager.unregisterFactory(this.awtFactory);
52
                manager.unregisterFactory(this.projectionFactory);
53
                manager.unregisterClass("Document");
54
                manager.unregisterClass("Layer");
55
                manager.unregisterClass("Layers");
56
                manager.unregisterClass("MapContext");
57
                manager.unregisterClass("Project");
58
                manager.unregisterClass("ProjectExtent");
59
                manager.unregisterClass("ViewPort");                
60
        }
61

    
62
        private void registerDocumentPersistence() {
63
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
64
                DynStruct definition = manager.addDefinition(
65
                                Document.class,
66
                                "Document",
67
                                "Document Persistence definition",
68
                                null, 
69
                                null
70
                );
71
                definition.addDynFieldString("comment");
72
                definition.addDynFieldInt("code").setMandatory(true);
73
                definition.addDynFieldString("creationDate").setMandatory(true);
74
                definition.addDynFieldString("name").setMandatory(true);
75
                definition.addDynFieldString("owner");
76
                definition.addDynFieldBoolean("locked");
77
                
78
                definition.addDynFieldObject("mainMapContext")
79
                        .setClassOfValue(MapContext.class)
80
                        .setMandatory(true);
81
                definition.addDynFieldObject("overviewMapContext")
82
                        .setClassOfValue(MapContext.class)
83
                        .setMandatory(false);
84
        }
85

    
86
        private void registerLayerPersistence() {
87
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
88
                DynStruct definition = manager.addDefinition(
89
                                Layer.class,
90
                                "Layer",
91
                                "Layer Persistence definition",
92
                                null, 
93
                                null
94
                );
95
                
96
                definition.addDynFieldObject("context")
97
                        .setClassOfValue(MapContext.class)
98
                        .setMandatory(true);
99

    
100
                /*
101
                 * FIXME:  Esto es una primera aproximacion, habria que ver de persistir directamente
102
                 * el valor de this.values en cuanto haya algo que nos permita persistir un
103
                 * DynObject.
104
                 */
105
                definition.addDynFieldInt("code").setMandatory(true);
106
                definition.addDynFieldString("name").setMandatory(true);
107
                definition.addDynFieldObject("projection")
108
                        .setClassOfValue(Projection.class)
109
                        .setMandatory(true);
110
        }
111
        
112
        private void registerLayersPersistence() {
113
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
114
                DynStruct definition = manager.addDefinition(
115
                                Layers.class,
116
                                "Layers",
117
                                "Layers Persistence definition",
118
                                null, 
119
                                null
120
                );
121
                definition.addDynFieldInt("code").setMandatory(true);
122
                definition.addDynFieldList("layers")
123
                        .setClassOfItems(Layer.class);
124
                definition.addDynFieldObject("context")
125
                        .setClassOfValue(MapContext.class);
126
        }
127

    
128
        private void registerMapContextPersistence() {
129
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
130
                DynStruct definition = manager.addDefinition(
131
                                MapContext.class,
132
                                "MapContext",
133
                                "MapContext Persistence definition",
134
                                null, 
135
                                null
136
                );
137
                definition.addDynFieldInt("code").setMandatory(true);
138
                definition.addDynFieldObject("layers")
139
                        .setClassOfValue(Layers.class);
140
                definition.addDynFieldObject("viewPort")
141
                        .setClassOfValue(ViewPort.class);
142

    
143
        }
144

    
145
        private void registerProjectPersistence() {
146
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
147
                DynStruct definition = manager.addDefinition(
148
                                Project.class,
149
                                "Project",
150
                                "Project Persistence definition", 
151
                                null, 
152
                                null
153
                );
154
                definition.addDynFieldInt("code").setMandatory(true);
155
                definition.addDynFieldString("comments").setMandatory(true);
156
                definition.addDynFieldObject("color")
157
                        .setClassOfValue(Color.class)
158
                        .setMandatory(true);
159
                definition.addDynFieldObject("projection")
160
                        .setClassOfValue(Projection.class)
161
                        .setMandatory(true);
162
                definition.addDynFieldList("extents")
163
                        .setClassOfItems(ProjectExtent.class)
164
                        .setMandatory(true);
165
                definition.addDynFieldList("documents")
166
                        .setClassOfItems(Document.class)
167
                        .setMandatory(true);
168
        }
169

    
170
        private void registerProjectExtentPersistence() {
171
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
172
                DynStruct definition = manager.addDefinition(
173
                                ProjectExtent.class,
174
                                "ProjectExtent",
175
                                "ProjectExtent Persistence definition" ,
176
                                null, 
177
                                null
178
                );
179
                definition.addDynFieldInt("code").setMandatory(true);
180
                definition.addDynFieldString("description").setMandatory(true);
181
        }
182
        
183
        public void registerViewPortPersistence() {
184
                PersistenceManager manager = ToolsLocator.getPersistenceManager();
185
                DynStruct definition = manager.addDefinition(
186
                                ViewPort.class,
187
                                "ViewPort",
188
                                "ViewPort Persistence definition",
189
                                null, 
190
                                null
191
                );
192
                definition.addDynFieldInt("code").setMandatory(true);
193
                definition.addDynFieldObject("projection")
194
                        .setClassOfValue(Projection.class);
195
        }
196

    
197

    
198
}