← Back to branch summary

~ubuntu-branches/ubuntu/quantal/zeroc-ice/quantal

« back to all changes in this revision

Viewing changes to java/src/IceGridGUI/Application/ServerTemplates.java

  • Committer: Bazaar Package Importer
  • Author(s): Cleto Martin Angelina
  • Date: 2011-04-25 18:44:24 UTC
  • mfrom: (6.1.14 sid)
  • Revision ID: james.westby@ubuntu.com-20110425184424-sep9i9euu434vq4c
Tags: 3.4.1-7
http://bugs.debian.org/623555
* Bug fix: "libdb5.1-java.jar was renamed to db.jar", thanks to Ondřej
  Surý (Closes: #623555).
* Bug fix: "causes noise in php5", thanks to Jayen Ashar (Closes:
  #623533).

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/src/IceGridGUI/Application/ServerTemplates.java
1
1
// **********************************************************************
2
2
//
3
 
// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
 
3
// Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.
4
4
//
5
5
// This copy of Ice is licensed to you under the terms described in the
6
6
// ICE_LICENSE file included in this distribution.
7
7
//
8
8
// **********************************************************************
 
9
 
9
10
package IceGridGUI.Application;
10
11
 
11
12
import javax.swing.JMenuItem;
16
17
 
17
18
class ServerTemplates extends Templates
18
19
{
19
 
    static public java.util.Map
20
 
    copyDescriptors(java.util.Map descriptors)
 
20
    static public java.util.Map<String, TemplateDescriptor>
 
21
    copyDescriptors(java.util.Map<String, TemplateDescriptor> descriptors)
21
22
    {
22
 
        java.util.Map copy = new java.util.HashMap();
23
 
        java.util.Iterator p = descriptors.entrySet().iterator();
24
 
        while(p.hasNext())
 
23
        java.util.Map<String, TemplateDescriptor> copy = new java.util.HashMap<String, TemplateDescriptor>();
 
24
        for(java.util.Map.Entry<String, TemplateDescriptor> p : descriptors.entrySet())
25
25
        {
26
 
            java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
27
 
            
28
 
            copy.put(entry.getKey(), 
29
 
                     ServerTemplate.copyDescriptor(
30
 
                         (TemplateDescriptor)entry.getValue()));
 
26
            copy.put(p.getKey(), ServerTemplate.copyDescriptor(p.getValue()));
31
27
        }
32
28
        return copy;
33
29
    }
40
36
        boolean[] actions = new boolean[ACTION_COUNT];
41
37
        actions[NEW_TEMPLATE_SERVER] = true;
42
38
        actions[NEW_TEMPLATE_SERVER_ICEBOX] = true;
43
 
        
 
39
 
44
40
        Object clipboard = getCoordinator().getClipboard();
45
41
        if(clipboard != null && clipboard instanceof TemplateDescriptor)
46
42
        {
49
45
        }
50
46
        return actions;
51
47
    }
 
48
 
52
49
    public JPopupMenu getPopupMenu()
53
50
    {
54
51
        ApplicationActions actions = getCoordinator().getActionsForPopup();
65
62
    public void newTemplateServer()
66
63
    {
67
64
        newServerTemplate(new TemplateDescriptor(
68
 
                              PlainServer.newServerDescriptor(), 
69
 
                              new java.util.LinkedList(),
70
 
                              new java.util.TreeMap()));
 
65
                              PlainServer.newServerDescriptor(),
 
66
                              new java.util.LinkedList<String>(),
 
67
                              new java.util.TreeMap<String, String>()));
71
68
    }
 
69
 
72
70
    public void newTemplateServerIceBox()
73
71
    {
74
72
        newServerTemplate(new TemplateDescriptor(
75
 
                              PlainServer.newIceBoxDescriptor(), 
76
 
                              new java.util.LinkedList(),
77
 
                              new java.util.TreeMap()));
 
73
                              PlainServer.newIceBoxDescriptor(),
 
74
                              new java.util.LinkedList<String>(),
 
75
                              new java.util.TreeMap<String, String>()));
78
76
    }
 
77
 
79
78
    public void paste()
80
79
    {
81
80
        Object descriptor =  getCoordinator().getClipboard();
88
87
                return;
89
88
            }
90
89
        }
91
 
      
 
90
 
92
91
        newServerTemplate(td);
93
92
    }
94
93
 
95
 
 
96
 
    ServerTemplates(Root parent, java.util.Map descriptors)
 
94
    ServerTemplates(Root parent, java.util.Map<String, TemplateDescriptor> descriptors)
97
95
        throws UpdateFailedException
98
96
    {
99
97
        super(parent, "Server templates");
100
98
 
101
99
        _descriptors = descriptors;
102
100
 
103
 
        java.util.Iterator p = _descriptors.entrySet().iterator();
104
 
        
105
 
        while(p.hasNext())
 
101
        for(java.util.Map.Entry<String, TemplateDescriptor> p : _descriptors.entrySet())
106
102
        {
107
 
            java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
108
 
            insertChild(new ServerTemplate(false, this,
109
 
                                           (String)entry.getKey(),
110
 
                                           (TemplateDescriptor)entry.getValue()),
111
 
                        false);
 
103
            insertChild(new ServerTemplate(false, this, p.getKey(), p.getValue()), false);
112
104
        }
113
105
    }
114
106
 
120
112
        return null;
121
113
    }
122
114
 
123
 
    java.util.Map getUpdates()
 
115
    java.util.Map<String, TemplateDescriptor> getUpdates()
124
116
    {
125
 
        java.util.Map updates = new java.util.HashMap();
126
 
        java.util.Iterator p = _children.iterator();
127
 
        while(p.hasNext())
 
117
        java.util.Map<String, TemplateDescriptor> updates = new java.util.HashMap<String, TemplateDescriptor>();
 
118
        for(TreeNodeBase p : _children)
128
119
        {
129
 
            ServerTemplate t = (ServerTemplate)p.next();
 
120
            ServerTemplate t = (ServerTemplate)p;
130
121
            if(t.getEditable().isNew() || t.getEditable().isModified())
131
122
            {
132
 
                updates.put(t.getId(), t.getDescriptor());
 
123
                updates.put(t.getId(), (TemplateDescriptor)t.getDescriptor());
133
124
            }
134
125
        }
135
126
        return updates;
138
129
    void commit()
139
130
    {
140
131
        _editable.commit();
141
 
        java.util.Iterator p = _children.iterator();
142
 
        while(p.hasNext())
 
132
        for(TreeNodeBase p : _children)
143
133
        {
144
 
            ServerTemplate st = (ServerTemplate)p.next();
 
134
            ServerTemplate st = (ServerTemplate)p;
145
135
            st.commit();
146
136
        }
147
137
    }
148
138
 
149
 
    java.util.List findServiceInstances(String template)
 
139
    java.util.List<ServiceInstance> findServiceInstances(String template)
150
140
    {
151
 
        java.util.List result = new java.util.LinkedList();
152
 
        java.util.Iterator p = _children.iterator();
153
 
        while(p.hasNext())
 
141
        java.util.List<ServiceInstance> result = new java.util.LinkedList<ServiceInstance>();
 
142
        for(TreeNodeBase p : _children)
154
143
        {
155
 
            ServerTemplate t = (ServerTemplate)p.next();
 
144
            ServerTemplate t = (ServerTemplate)p;
156
145
            result.addAll(t.findServiceInstances(template));
157
146
        }
158
147
        return result;
160
149
 
161
150
    void removeServiceInstances(String template)
162
151
    {
163
 
        java.util.Iterator p = _children.iterator();
164
 
        while(p.hasNext())
 
152
        for(TreeNodeBase p : _children)
165
153
        {
166
 
            ServerTemplate t = (ServerTemplate)p.next();
 
154
            ServerTemplate t = (ServerTemplate)p;
167
155
            t.removeServiceInstances(template);
168
156
        }
169
157
    }
170
 
    
 
158
 
171
159
    void newServerTemplate(TemplateDescriptor descriptor)
172
160
    {
173
161
        String id;
179
167
        {
180
168
            id = makeNewChildId("NewServerTemplate");
181
169
        }
182
 
        
 
170
 
183
171
        ServerTemplate t = new ServerTemplate(this, id, descriptor);
184
172
        try
185
173
        {
195
183
    void tryAdd(String newId, TemplateDescriptor descriptor)
196
184
        throws UpdateFailedException
197
185
    {
198
 
        insertChild(new ServerTemplate(true, this, newId, descriptor), 
199
 
                    true);
 
186
        insertChild(new ServerTemplate(true, this, newId, descriptor), true);
200
187
        _descriptors.put(newId, descriptor);
201
188
    }
202
189
 
203
 
    void update(java.util.Map updates, String[] removeTemplates, 
204
 
                java.util.Set serviceTemplates)
 
190
    void update(java.util.Map<String, TemplateDescriptor> updates, String[] removeTemplates,
 
191
                java.util.Set<String> serviceTemplates)
205
192
        throws UpdateFailedException
206
193
    {
207
194
        //
208
195
        // Note: _descriptors is updated by Root
209
196
        //
210
 
        
 
197
 
211
198
        Root root = getRoot();
212
199
 
213
200
        //
218
205
        //
219
206
        // One big set of updates, followed by inserts
220
207
        //
221
 
        java.util.Vector newChildren = new java.util.Vector();
222
 
        java.util.Vector updatedChildren = new java.util.Vector();
223
 
        
224
 
        java.util.Iterator p = updates.entrySet().iterator();
225
 
        while(p.hasNext())
 
208
        java.util.List<TreeNodeBase> newChildren = new java.util.ArrayList<TreeNodeBase>();
 
209
        java.util.List<TreeNodeBase> updatedChildren = new java.util.LinkedList<TreeNodeBase>();
 
210
 
 
211
        for(java.util.Map.Entry<String, TemplateDescriptor> p : updates.entrySet())
226
212
        {
227
 
            java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
228
 
            String name = (String)entry.getKey();
229
 
            TemplateDescriptor templateDescriptor 
230
 
                = (TemplateDescriptor)entry.getValue();
 
213
            String name = p.getKey();
 
214
            TemplateDescriptor templateDescriptor = p.getValue();
231
215
            ServerTemplate child = (ServerTemplate)findChild(name);
232
216
            if(child == null)
233
217
            {
239
223
                updatedChildren.add(child);
240
224
            }
241
225
        }
242
 
        
 
226
 
243
227
        //
244
228
        // Rebuild template affected by service template updates
245
229
        //
246
 
        p = serviceTemplates.iterator();
247
 
        while(p.hasNext())
 
230
        for(String p : serviceTemplates)
248
231
        {
249
 
            java.util.List serviceInstances = 
250
 
                findServiceInstances((String)p.next());
251
 
            java.util.Iterator q = serviceInstances.iterator();
252
 
            while(q.hasNext())
 
232
            java.util.List<ServiceInstance> serviceInstances = findServiceInstances(p);
 
233
            for(ServiceInstance q : serviceInstances)
253
234
            {
254
 
                ServiceInstance service = (ServiceInstance)q.next();
255
 
                ServerTemplate serverTemplate = 
256
 
                    (ServerTemplate)service.getParent();
257
 
                
258
 
                if(!updatedChildren.contains(serverTemplate) &&
259
 
                   !newChildren.contains(serverTemplate))
 
235
                ServerTemplate serverTemplate = (ServerTemplate)q.getParent();
 
236
 
 
237
                if(!updatedChildren.contains(serverTemplate) && !newChildren.contains(serverTemplate))
260
238
                {
261
239
                    serverTemplate.rebuild();
262
240
                    updatedChildren.add(serverTemplate);
263
241
                }
264
242
            }
265
243
        }
266
 
        
 
244
 
267
245
        childrenChanged(updatedChildren);
268
246
        insertChildren(newChildren, true);
269
247
    }
270
 
    
 
248
 
271
249
    void removeDescriptor(String id)
272
250
    {
273
251
        _descriptors.remove(id);
274
252
    }
275
 
    
 
253
 
276
254
    Object getDescriptor()
277
255
    {
278
256
        return _descriptors;
279
257
    }
280
258
 
281
 
    private java.util.Map _descriptors;
 
259
    private java.util.Map<String, TemplateDescriptor> _descriptors;
282
260
    static private JPopupMenu _popup;
283
261
}